541 files changed, 22817 insertions, 4558 deletions

diff --git a/include/Kbuild b/include/Kbuild
index d8c3e3cbf416..8d226bfa2696 100644
--- a/include/Kbuild
+++ b/include/Kbuild
@@ -8,3 +8,5 @@ header-y += mtd/
 header-y += rdma/
 header-y += video/
 header-y += drm/
+header-y += xen/
+header-y += scsi/
diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index c34b11022908..c65e4ce6c3af 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -114,10 +114,13 @@ struct acpi_device_ops {
         acpi_op_notify notify;
 };
 
+#define ACPI_DRIVER_ALL_NOTIFY_EVENTS   0x1     /* system AND device events */
+
 struct acpi_driver {
         char name[80];
         char class[80];
         const struct acpi_device_id *ids; /* Supported Hardware IDs */
+        unsigned int flags;
         struct acpi_device_ops ops;
         struct device_driver drv;
         struct module *owner;
@@ -168,7 +171,7 @@ struct acpi_device_dir {
 
 /* Plug and Play */
 
-typedef char acpi_bus_id[5];
+typedef char acpi_bus_id[8];
 typedef unsigned long acpi_bus_address;
 typedef char acpi_hardware_id[15];
 typedef char acpi_unique_id[9];
@@ -365,10 +368,10 @@ struct acpi_bus_type {
 int register_acpi_bus_type(struct acpi_bus_type *);
 int unregister_acpi_bus_type(struct acpi_bus_type *);
 struct device *acpi_get_physical_device(acpi_handle);
-struct device *acpi_get_physical_pci_device(acpi_handle);
 
 /* helper */
 acpi_handle acpi_get_child(acpi_handle, acpi_integer);
+int acpi_is_root_bridge(acpi_handle);
 acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int);
 #define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->archdata.acpi_handle))
 
diff --git a/include/acpi/acpi_drivers.h b/include/acpi/acpi_drivers.h
index 0352c8f0b05b..f4906f6568d4 100644
--- a/include/acpi/acpi_drivers.h
+++ b/include/acpi/acpi_drivers.h
@@ -57,8 +57,7 @@
  */
 
 #define ACPI_POWER_HID                  "LNXPOWER"
-#define ACPI_PROCESSOR_OBJECT_HID       "ACPI_CPU"
-#define ACPI_PROCESSOR_HID              "ACPI0007"
+#define ACPI_PROCESSOR_OBJECT_HID       "LNXCPU"
 #define ACPI_SYSTEM_HID                 "LNXSYSTM"
 #define ACPI_THERMAL_HID                "LNXTHERM"
 #define ACPI_BUTTON_HID_POWERF          "LNXPWRBN"
@@ -91,17 +90,15 @@ int acpi_pci_link_free_irq(acpi_handle handle);
 
 /* ACPI PCI Interrupt Routing (pci_irq.c) */
 
-int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus);
-void acpi_pci_irq_del_prt(int segment, int bus);
+int acpi_pci_irq_add_prt(acpi_handle handle, struct pci_bus *bus);
+void acpi_pci_irq_del_prt(struct pci_bus *bus);
 
 /* ACPI PCI Device Binding (pci_bind.c) */
 
 struct pci_bus;
 
-acpi_status acpi_get_pci_id(acpi_handle handle, struct acpi_pci_id *id);
-int acpi_pci_bind(struct acpi_device *device);
-int acpi_pci_bind_root(struct acpi_device *device, struct acpi_pci_id *id,
-                       struct pci_bus *bus);
+struct pci_dev *acpi_get_pci_dev(acpi_handle);
+int acpi_pci_bind_root(struct acpi_device *device);
 
 /* Arch-defined function to add a bus to the system */
 
diff --git a/include/acpi/acpiosxf.h b/include/acpi/acpiosxf.h
index 3e798593b17b..ab0b85cf21f3 100644
--- a/include/acpi/acpiosxf.h
+++ b/include/acpi/acpiosxf.h
@@ -242,6 +242,10 @@ acpi_os_derive_pci_id(acpi_handle rhandle,
 acpi_status acpi_os_validate_interface(char *interface);
 acpi_status acpi_osi_invalidate(char* interface);
 
+acpi_status
+acpi_os_validate_address(u8 space_id, acpi_physical_address address,
+                         acpi_size length, char *name);
+
 u64 acpi_os_get_timer(void);
 
 acpi_status acpi_os_signal(u32 function, void *info);
diff --git a/include/acpi/acpixf.h b/include/acpi/acpixf.h
index 4db89e98535d..82ec6a3c0500 100644
--- a/include/acpi/acpixf.h
+++ b/include/acpi/acpixf.h
@@ -47,7 +47,7 @@
 
 /* Current ACPICA subsystem version in YYYYMMDD format */
 
-#define ACPI_CA_VERSION                 0x20090320
+#define ACPI_CA_VERSION                 0x20090521
 
 #include "actypes.h"
 #include "actbl.h"
@@ -201,6 +201,8 @@ acpi_evaluate_object_typed(acpi_handle object,
 acpi_status
 acpi_get_object_info(acpi_handle handle, struct acpi_buffer *return_buffer);
 
+acpi_status acpi_install_method(u8 *buffer);
+
 acpi_status
 acpi_get_next_object(acpi_object_type type,
                      acpi_handle parent,
@@ -375,7 +377,7 @@ acpi_status acpi_leave_sleep_state_prep(u8 sleep_state);
 acpi_status acpi_leave_sleep_state(u8 sleep_state);
 
 /*
- * Debug output
+ * Error/Warning output
  */
 void ACPI_INTERNAL_VAR_XFACE
 acpi_error(const char *module_name,
@@ -394,6 +396,9 @@ void ACPI_INTERNAL_VAR_XFACE
 acpi_info(const char *module_name,
           u32 line_number, const char *format, ...) ACPI_PRINTF_LIKE(3);
 
+/*
+ * Debug output
+ */
 #ifdef ACPI_DEBUG_OUTPUT
 
 void ACPI_INTERNAL_VAR_XFACE
diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
index f555d927f7c0..37ba576d06e8 100644
--- a/include/acpi/actypes.h
+++ b/include/acpi/actypes.h
@@ -429,20 +429,12 @@ typedef unsigned long long acpi_integer;
 
 /* Data manipulation */
 
-#define ACPI_LOWORD(l)                  ((u16)(u32)(l))
-#define ACPI_HIWORD(l)                  ((u16)((((u32)(l)) >> 16) & 0xFFFF))
-#define ACPI_LOBYTE(l)                  ((u8)(u16)(l))
-#define ACPI_HIBYTE(l)                  ((u8)((((u16)(l)) >> 8) & 0xFF))
-
-/* Full 64-bit integer must be available on both 32-bit and 64-bit platforms */
-
-struct acpi_integer_overlay {
-        u32 lo_dword;
-        u32 hi_dword;
-};
-
-#define ACPI_LODWORD(integer)           (ACPI_CAST_PTR (struct acpi_integer_overlay, &integer)->lo_dword)
-#define ACPI_HIDWORD(integer)           (ACPI_CAST_PTR (struct acpi_integer_overlay, &integer)->hi_dword)
+#define ACPI_LOBYTE(integer)            ((u8)   (u16)(integer))
+#define ACPI_HIBYTE(integer)            ((u8) (((u16)(integer)) >> 8))
+#define ACPI_LOWORD(integer)            ((u16)  (u32)(integer))
+#define ACPI_HIWORD(integer)            ((u16)(((u32)(integer)) >> 16))
+#define ACPI_LODWORD(integer64)         ((u32)  (u64)(integer64))
+#define ACPI_HIDWORD(integer64)         ((u32)(((u64)(integer64)) >> 32))
 
 #define ACPI_SET_BIT(target,bit)        ((target) |= (bit))
 #define ACPI_CLEAR_BIT(target,bit)      ((target) &= ~(bit))
diff --git a/include/acpi/platform/acgcc.h b/include/acpi/platform/acgcc.h
index 8e2cdc57b197..935c5d7fc86e 100644
--- a/include/acpi/platform/acgcc.h
+++ b/include/acpi/platform/acgcc.h
@@ -62,4 +62,8 @@
  */
 #define ACPI_UNUSED_VAR __attribute__ ((unused))
 
+#ifdef _ANSI
+#define inline
+#endif
+
 #endif                          /* __ACGCC_H__ */
diff --git a/include/acpi/platform/aclinux.h b/include/acpi/platform/aclinux.h
index 6d49b2a498c4..fcb8e4b159b1 100644
--- a/include/acpi/platform/aclinux.h
+++ b/include/acpi/platform/aclinux.h
@@ -1,11 +1,11 @@
 /******************************************************************************
  *
- * Name: aclinux.h - OS specific defines, etc.
+ * Name: aclinux.h - OS specific defines, etc. for Linux
  *
  *****************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2008, Intel Corp.
+ * Copyright (C) 2000 - 2009, Intel Corp.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -44,10 +44,13 @@
 #ifndef __ACLINUX_H__
 #define __ACLINUX_H__
 
+/* Common (in-kernel/user-space) ACPICA configuration */
+
 #define ACPI_USE_SYSTEM_CLIBRARY
 #define ACPI_USE_DO_WHILE_0
 #define ACPI_MUTEX_TYPE             ACPI_BINARY_SEMAPHORE
 
+
 #ifdef __KERNEL__
 
 #include <linux/string.h>
@@ -63,15 +66,18 @@
 #include <linux/spinlock_types.h>
 #include <asm/current.h>
 
-/* Host-dependent types and defines */
+/* Host-dependent types and defines for in-kernel ACPICA */
 
 #define ACPI_MACHINE_WIDTH          BITS_PER_LONG
-#define acpi_cache_t                        struct kmem_cache
-#define acpi_spinlock                   spinlock_t *
 #define ACPI_EXPORT_SYMBOL(symbol)  EXPORT_SYMBOL(symbol);
 #define strtoul                     simple_strtoul
 
-#else                           /* !__KERNEL__ */
+#define acpi_cache_t                        struct kmem_cache
+#define acpi_spinlock                       spinlock_t *
+#define acpi_cpu_flags                      unsigned long
+#define acpi_thread_id                      struct task_struct *
+
+#else /* !__KERNEL__ */
 
 #include <stdarg.h>
 #include <string.h>
@@ -79,6 +85,11 @@
 #include <ctype.h>
 #include <unistd.h>
 
+/* Host-dependent types and defines for user-space ACPICA */
+
+#define ACPI_FLUSH_CPU_CACHE()
+#define acpi_thread_id                      pthread_t
+
 #if defined(__ia64__) || defined(__x86_64__)
 #define ACPI_MACHINE_WIDTH          64
 #define COMPILER_DEPENDENT_INT64    long
@@ -94,17 +105,17 @@
 #define __cdecl
 #endif
 
-#define ACPI_FLUSH_CPU_CACHE()
-#endif                          /* __KERNEL__ */
+#endif /* __KERNEL__ */
 
 /* Linux uses GCC */
 
 #include "acgcc.h"
 
-#define acpi_cpu_flags unsigned long
-
-#define acpi_thread_id struct task_struct *
 
+#ifdef __KERNEL__
+/*
+ * Overrides for in-kernel ACPICA
+ */
 static inline acpi_thread_id acpi_os_get_thread_id(void)
 {
         return current;
@@ -119,30 +130,32 @@ static inline acpi_thread_id acpi_os_get_thread_id(void)
 #include <acpi/actypes.h>
 static inline void *acpi_os_allocate(acpi_size size)
 {
-        return kmalloc(size, irqs_disabled()? GFP_ATOMIC : GFP_KERNEL);
+        return kmalloc(size, irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
 }
+
 static inline void *acpi_os_allocate_zeroed(acpi_size size)
 {
-        return kzalloc(size, irqs_disabled()? GFP_ATOMIC : GFP_KERNEL);
+        return kzalloc(size, irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
 }
 
 static inline void *acpi_os_acquire_object(acpi_cache_t * cache)
 {
         return kmem_cache_zalloc(cache,
-                                 irqs_disabled()? GFP_ATOMIC : GFP_KERNEL);
+                irqs_disabled() ? GFP_ATOMIC : GFP_KERNEL);
 }
 
-#define ACPI_ALLOCATE(a)        acpi_os_allocate(a)
-#define ACPI_ALLOCATE_ZEROED(a) acpi_os_allocate_zeroed(a)
-#define ACPI_FREE(a)            kfree(a)
+#define ACPI_ALLOCATE(a)        acpi_os_allocate(a)
+#define ACPI_ALLOCATE_ZEROED(a) acpi_os_allocate_zeroed(a)
+#define ACPI_FREE(a)            kfree(a)
 
-/*
- * We need to show where it is safe to preempt execution of ACPICA
- */
-#define ACPI_PREEMPTION_POINT()         \
-        do {                            \
-                if (!irqs_disabled())   \
-                        cond_resched(); \
+/* Used within ACPICA to show where it is safe to preempt execution */
+
+#define ACPI_PREEMPTION_POINT() \
+        do { \
+                if (!irqs_disabled()) \
+                        cond_resched(); \
         } while (0)
 
-#endif                          /* __ACLINUX_H__ */
+#endif /* __KERNEL__ */
+
+#endif /* __ACLINUX_H__ */
diff --git a/include/acpi/processor.h b/include/acpi/processor.h
index 4927c063347c..baf1e0a9a7ee 100644
--- a/include/acpi/processor.h
+++ b/include/acpi/processor.h
@@ -258,6 +258,7 @@ DECLARE_PER_CPU(struct acpi_processor *, processors);
 extern struct acpi_processor_errata errata;
 
 void arch_acpi_processor_init_pdc(struct acpi_processor *pr);
+void arch_acpi_processor_cleanup_pdc(struct acpi_processor *pr);
 
 #ifdef ARCH_HAS_POWER_INIT
 void acpi_processor_power_init_bm_check(struct acpi_processor_flags *flags,
diff --git a/include/acpi/video.h b/include/acpi/video.h
index af6fe95fd3d0..cf7be3dd157b 100644
--- a/include/acpi/video.h
+++ b/include/acpi/video.h
@@ -3,10 +3,10 @@
 
 #if (defined CONFIG_ACPI_VIDEO || defined CONFIG_ACPI_VIDEO_MODULE)
 extern int acpi_video_register(void);
-extern int acpi_video_exit(void);
+extern void acpi_video_unregister(void);
 #else
 static inline int acpi_video_register(void) { return 0; }
-static inline void acpi_video_exit(void) { return; }
+static inline void acpi_video_unregister(void) { return; }
 #endif
 
 #endif
diff --git a/include/asm-generic/4level-fixup.h b/include/asm-generic/4level-fixup.h
index 9d40e879f99e..77ff547730af 100644
--- a/include/asm-generic/4level-fixup.h
+++ b/include/asm-generic/4level-fixup.h
@@ -27,9 +27,9 @@
 #define pud_page_vaddr(pud)             pgd_page_vaddr(pud)
 
 #undef pud_free_tlb
-#define pud_free_tlb(tlb, x)            do { } while (0)
+#define pud_free_tlb(tlb, x, addr)      do { } while (0)
 #define pud_free(mm, x)                 do { } while (0)
-#define __pud_free_tlb(tlb, x)          do { } while (0)
+#define __pud_free_tlb(tlb, x, addr)    do { } while (0)
 
 #undef  pud_addr_end
 #define pud_addr_end(addr, end)         (end)
diff --git a/include/asm-generic/Kbuild b/include/asm-generic/Kbuild
index 4c9932a2503f..eb62334cda29 100644
--- a/include/asm-generic/Kbuild
+++ b/include/asm-generic/Kbuild
@@ -1,11 +1,33 @@
+header-y += auxvec.h
+header-y += bitsperlong.h
 header-y += errno-base.h
 header-y += errno.h
 header-y += fcntl.h
 header-y += ioctl.h
+header-y += ioctls.h
+header-y += ipcbuf.h
+header-y += mman-common.h
 header-y += mman.h
+header-y += msgbuf.h
+header-y += param.h
 header-y += poll.h
+header-y += posix_types.h
+header-y += sembuf.h
+header-y += setup.h
+header-y += shmbuf.h
+header-y += shmparam.h
+header-y += signal-defs.h
 header-y += signal.h
+header-y += socket.h
+header-y += sockios.h
+header-y += stat.h
 header-y += statfs.h
+header-y += swab.h
+header-y += termbits.h
+header-y += termios.h
+header-y += types.h
+header-y += ucontext.h
+header-y += unistd.h
 
 unifdef-y += int-l64.h
 unifdef-y += int-ll64.h
diff --git a/include/asm-generic/Kbuild.asm b/include/asm-generic/Kbuild.asm
index 70d185534b9d..290910e4ede4 100644
--- a/include/asm-generic/Kbuild.asm
+++ b/include/asm-generic/Kbuild.asm
@@ -9,6 +9,7 @@ unifdef-y += a.out.h
 endif
 unifdef-y += auxvec.h
 unifdef-y += byteorder.h
+unifdef-y += bitsperlong.h
 unifdef-y += errno.h
 unifdef-y += fcntl.h
 unifdef-y += ioctl.h
diff --git a/include/asm-generic/atomic-long.h b/include/asm-generic/atomic-long.h
new file mode 100644
index 000000000000..b7babf0206b8
--- /dev/null
+++ b/include/asm-generic/atomic-long.h
@@ -0,0 +1,258 @@
+#ifndef _ASM_GENERIC_ATOMIC_LONG_H
+#define _ASM_GENERIC_ATOMIC_LONG_H
+/*
+ * Copyright (C) 2005 Silicon Graphics, Inc.
+ *      Christoph Lameter
+ *
+ * Allows to provide arch independent atomic definitions without the need to
+ * edit all arch specific atomic.h files.
+ */
+
+#include <asm/types.h>
+
+/*
+ * Suppport for atomic_long_t
+ *
+ * Casts for parameters are avoided for existing atomic functions in order to
+ * avoid issues with cast-as-lval under gcc 4.x and other limitations that the
+ * macros of a platform may have.
+ */
+
+#if BITS_PER_LONG == 64
+
+typedef atomic64_t atomic_long_t;
+
+#define ATOMIC_LONG_INIT(i)     ATOMIC64_INIT(i)
+
+static inline long atomic_long_read(atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return (long)atomic64_read(v);
+}
+
+static inline void atomic_long_set(atomic_long_t *l, long i)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        atomic64_set(v, i);
+}
+
+static inline void atomic_long_inc(atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        atomic64_inc(v);
+}
+
+static inline void atomic_long_dec(atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        atomic64_dec(v);
+}
+
+static inline void atomic_long_add(long i, atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        atomic64_add(i, v);
+}
+
+static inline void atomic_long_sub(long i, atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        atomic64_sub(i, v);
+}
+
+static inline int atomic_long_sub_and_test(long i, atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return atomic64_sub_and_test(i, v);
+}
+
+static inline int atomic_long_dec_and_test(atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return atomic64_dec_and_test(v);
+}
+
+static inline int atomic_long_inc_and_test(atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return atomic64_inc_and_test(v);
+}
+
+static inline int atomic_long_add_negative(long i, atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return atomic64_add_negative(i, v);
+}
+
+static inline long atomic_long_add_return(long i, atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return (long)atomic64_add_return(i, v);
+}
+
+static inline long atomic_long_sub_return(long i, atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return (long)atomic64_sub_return(i, v);
+}
+
+static inline long atomic_long_inc_return(atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return (long)atomic64_inc_return(v);
+}
+
+static inline long atomic_long_dec_return(atomic_long_t *l)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return (long)atomic64_dec_return(v);
+}
+
+static inline long atomic_long_add_unless(atomic_long_t *l, long a, long u)
+{
+        atomic64_t *v = (atomic64_t *)l;
+
+        return (long)atomic64_add_unless(v, a, u);
+}
+
+#define atomic_long_inc_not_zero(l) atomic64_inc_not_zero((atomic64_t *)(l))
+
+#define atomic_long_cmpxchg(l, old, new) \
+        (atomic64_cmpxchg((atomic64_t *)(l), (old), (new)))
+#define atomic_long_xchg(v, new) \
+        (atomic64_xchg((atomic64_t *)(v), (new)))
+
+#else  /*  BITS_PER_LONG == 64  */
+
+typedef atomic_t atomic_long_t;
+
+#define ATOMIC_LONG_INIT(i)     ATOMIC_INIT(i)
+static inline long atomic_long_read(atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return (long)atomic_read(v);
+}
+
+static inline void atomic_long_set(atomic_long_t *l, long i)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        atomic_set(v, i);
+}
+
+static inline void atomic_long_inc(atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        atomic_inc(v);
+}
+
+static inline void atomic_long_dec(atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        atomic_dec(v);
+}
+
+static inline void atomic_long_add(long i, atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        atomic_add(i, v);
+}
+
+static inline void atomic_long_sub(long i, atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        atomic_sub(i, v);
+}
+
+static inline int atomic_long_sub_and_test(long i, atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return atomic_sub_and_test(i, v);
+}
+
+static inline int atomic_long_dec_and_test(atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return atomic_dec_and_test(v);
+}
+
+static inline int atomic_long_inc_and_test(atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return atomic_inc_and_test(v);
+}
+
+static inline int atomic_long_add_negative(long i, atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return atomic_add_negative(i, v);
+}
+
+static inline long atomic_long_add_return(long i, atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return (long)atomic_add_return(i, v);
+}
+
+static inline long atomic_long_sub_return(long i, atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return (long)atomic_sub_return(i, v);
+}
+
+static inline long atomic_long_inc_return(atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return (long)atomic_inc_return(v);
+}
+
+static inline long atomic_long_dec_return(atomic_long_t *l)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return (long)atomic_dec_return(v);
+}
+
+static inline long atomic_long_add_unless(atomic_long_t *l, long a, long u)
+{
+        atomic_t *v = (atomic_t *)l;
+
+        return (long)atomic_add_unless(v, a, u);
+}
+
+#define atomic_long_inc_not_zero(l) atomic_inc_not_zero((atomic_t *)(l))
+
+#define atomic_long_cmpxchg(l, old, new) \
+        (atomic_cmpxchg((atomic_t *)(l), (old), (new)))
+#define atomic_long_xchg(v, new) \
+        (atomic_xchg((atomic_t *)(v), (new)))
+
+#endif  /*  BITS_PER_LONG == 64  */
+
+#endif  /*  _ASM_GENERIC_ATOMIC_LONG_H  */
diff --git a/include/asm-generic/atomic.h b/include/asm-generic/atomic.h
index 3673a13b6703..c99c64dc5f3d 100644
--- a/include/asm-generic/atomic.h
+++ b/include/asm-generic/atomic.h
@@ -1,258 +1,165 @@
-#ifndef _ASM_GENERIC_ATOMIC_H
-#define _ASM_GENERIC_ATOMIC_H
 /*
- * Copyright (C) 2005 Silicon Graphics, Inc.
- *      Christoph Lameter
+ * Generic C implementation of atomic counter operations
+ * Originally implemented for MN10300.
  *
- * Allows to provide arch independent atomic definitions without the need to
- * edit all arch specific atomic.h files.
+ * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
  */
+#ifndef __ASM_GENERIC_ATOMIC_H
+#define __ASM_GENERIC_ATOMIC_H
 
-#include <asm/types.h>
+#ifdef CONFIG_SMP
+#error not SMP safe
+#endif
 
 /*
- * Suppport for atomic_long_t
- *
- * Casts for parameters are avoided for existing atomic functions in order to
- * avoid issues with cast-as-lval under gcc 4.x and other limitations that the
- * macros of a platform may have.
+ * Atomic operations that C can't guarantee us.  Useful for
+ * resource counting etc..
  */
 
-#if BITS_PER_LONG == 64
-
-typedef atomic64_t atomic_long_t;
-
-#define ATOMIC_LONG_INIT(i)     ATOMIC64_INIT(i)
+#define ATOMIC_INIT(i)  { (i) }
 
-static inline long atomic_long_read(atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return (long)atomic64_read(v);
-}
-
-static inline void atomic_long_set(atomic_long_t *l, long i)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        atomic64_set(v, i);
-}
-
-static inline void atomic_long_inc(atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        atomic64_inc(v);
-}
-
-static inline void atomic_long_dec(atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        atomic64_dec(v);
-}
-
-static inline void atomic_long_add(long i, atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        atomic64_add(i, v);
-}
-
-static inline void atomic_long_sub(long i, atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        atomic64_sub(i, v);
-}
-
-static inline int atomic_long_sub_and_test(long i, atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return atomic64_sub_and_test(i, v);
-}
-
-static inline int atomic_long_dec_and_test(atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return atomic64_dec_and_test(v);
-}
-
-static inline int atomic_long_inc_and_test(atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return atomic64_inc_and_test(v);
-}
-
-static inline int atomic_long_add_negative(long i, atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return atomic64_add_negative(i, v);
-}
-
-static inline long atomic_long_add_return(long i, atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return (long)atomic64_add_return(i, v);
-}
-
-static inline long atomic_long_sub_return(long i, atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
+#ifdef __KERNEL__
 
-        return (long)atomic64_sub_return(i, v);
-}
-
-static inline long atomic_long_inc_return(atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return (long)atomic64_inc_return(v);
-}
-
-static inline long atomic_long_dec_return(atomic_long_t *l)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return (long)atomic64_dec_return(v);
-}
-
-static inline long atomic_long_add_unless(atomic_long_t *l, long a, long u)
-{
-        atomic64_t *v = (atomic64_t *)l;
-
-        return (long)atomic64_add_unless(v, a, u);
-}
-
-#define atomic_long_inc_not_zero(l) atomic64_inc_not_zero((atomic64_t *)(l))
-
-#define atomic_long_cmpxchg(l, old, new) \
-        (atomic64_cmpxchg((atomic64_t *)(l), (old), (new)))
-#define atomic_long_xchg(v, new) \
-        (atomic64_xchg((atomic64_t *)(l), (new)))
-
-#else  /*  BITS_PER_LONG == 64  */
-
-typedef atomic_t atomic_long_t;
-
-#define ATOMIC_LONG_INIT(i)     ATOMIC_INIT(i)
-static inline long atomic_long_read(atomic_long_t *l)
-{
-        atomic_t *v = (atomic_t *)l;
-
-        return (long)atomic_read(v);
-}
+/**
+ * atomic_read - read atomic variable
+ * @v: pointer of type atomic_t
+ *
+ * Atomically reads the value of @v.  Note that the guaranteed
+ * useful range of an atomic_t is only 24 bits.
+ */
+#define atomic_read(v)  ((v)->counter)
 
-static inline void atomic_long_set(atomic_long_t *l, long i)
-{
-        atomic_t *v = (atomic_t *)l;
+/**
+ * atomic_set - set atomic variable
+ * @v: pointer of type atomic_t
+ * @i: required value
+ *
+ * Atomically sets the value of @v to @i.  Note that the guaranteed
+ * useful range of an atomic_t is only 24 bits.
+ */
+#define atomic_set(v, i) (((v)->counter) = (i))
 
-        atomic_set(v, i);
-}
+#include <asm/system.h>
 
-static inline void atomic_long_inc(atomic_long_t *l)
+/**
+ * atomic_add_return - add integer to atomic variable
+ * @i: integer value to add
+ * @v: pointer of type atomic_t
+ *
+ * Atomically adds @i to @v and returns the result
+ * Note that the guaranteed useful range of an atomic_t is only 24 bits.
+ */
+static inline int atomic_add_return(int i, atomic_t *v)
 {
-        atomic_t *v = (atomic_t *)l;
-
-        atomic_inc(v);
-}
+        unsigned long flags;
+        int temp;
 
-static inline void atomic_long_dec(atomic_long_t *l)
-{
-        atomic_t *v = (atomic_t *)l;
+        local_irq_save(flags);
+        temp = v->counter;
+        temp += i;
+        v->counter = temp;
+        local_irq_restore(flags);
 
-        atomic_dec(v);
+        return temp;
 }
 
-static inline void atomic_long_add(long i, atomic_long_t *l)
+/**
+ * atomic_sub_return - subtract integer from atomic variable
+ * @i: integer value to subtract
+ * @v: pointer of type atomic_t
+ *
+ * Atomically subtracts @i from @v and returns the result
+ * Note that the guaranteed useful range of an atomic_t is only 24 bits.
+ */
+static inline int atomic_sub_return(int i, atomic_t *v)
 {
-        atomic_t *v = (atomic_t *)l;
-
-        atomic_add(i, v);
-}
+        unsigned long flags;
+        int temp;
 
-static inline void atomic_long_sub(long i, atomic_long_t *l)
-{
-        atomic_t *v = (atomic_t *)l;
+        local_irq_save(flags);
+        temp = v->counter;
+        temp -= i;
+        v->counter = temp;
+        local_irq_restore(flags);
 
-        atomic_sub(i, v);
+        return temp;
 }
 
-static inline int atomic_long_sub_and_test(long i, atomic_long_t *l)
+static inline int atomic_add_negative(int i, atomic_t *v)
 {
-        atomic_t *v = (atomic_t *)l;
-
-        return atomic_sub_and_test(i, v);
+        return atomic_add_return(i, v) < 0;
 }
 
-static inline int atomic_long_dec_and_test(atomic_long_t *l)
+static inline void atomic_add(int i, atomic_t *v)
 {
-        atomic_t *v = (atomic_t *)l;
-
-        return atomic_dec_and_test(v);
+        atomic_add_return(i, v);
 }
 
-static inline int atomic_long_inc_and_test(atomic_long_t *l)
+static inline void atomic_sub(int i, atomic_t *v)
 {
-        atomic_t *v = (atomic_t *)l;
-
-        return atomic_inc_and_test(v);
+        atomic_sub_return(i, v);
 }
 
-static inline int atomic_long_add_negative(long i, atomic_long_t *l)
+static inline void atomic_inc(atomic_t *v)
 {
-        atomic_t *v = (atomic_t *)l;
-
-        return atomic_add_negative(i, v);
+        atomic_add_return(1, v);
 }
 
-static inline long atomic_long_add_return(long i, atomic_long_t *l)
+static inline void atomic_dec(atomic_t *v)
 {
-        atomic_t *v = (atomic_t *)l;
-
-        return (long)atomic_add_return(i, v);
+        atomic_sub_return(1, v);
 }
 
-static inline long atomic_long_sub_return(long i, atomic_long_t *l)
-{
-        atomic_t *v = (atomic_t *)l;
+#define atomic_dec_return(v)            atomic_sub_return(1, (v))
+#define atomic_inc_return(v)            atomic_add_return(1, (v))
 
-        return (long)atomic_sub_return(i, v);
-}
+#define atomic_sub_and_test(i, v)       (atomic_sub_return((i), (v)) == 0)
+#define atomic_dec_and_test(v)          (atomic_sub_return(1, (v)) == 0)
+#define atomic_inc_and_test(v)          (atomic_add_return(1, (v)) == 0)
 
-static inline long atomic_long_inc_return(atomic_long_t *l)
-{
-        atomic_t *v = (atomic_t *)l;
+#define atomic_add_unless(v, a, u)                              \
+({                                                              \
+        int c, old;                                             \
+        c = atomic_read(v);                                     \
+        while (c != (u) && (old = atomic_cmpxchg((v), c, c + (a))) != c) \
+                c = old;                                        \
+        c != (u);                                               \
+})
 
-        return (long)atomic_inc_return(v);
-}
+#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
 
-static inline long atomic_long_dec_return(atomic_long_t *l)
+static inline void atomic_clear_mask(unsigned long mask, unsigned long *addr)
 {
-        atomic_t *v = (atomic_t *)l;
+        unsigned long flags;
 
-        return (long)atomic_dec_return(v);
+        mask = ~mask;
+        local_irq_save(flags);
+        *addr &= mask;
+        local_irq_restore(flags);
 }
 
-static inline long atomic_long_add_unless(atomic_long_t *l, long a, long u)
-{
-        atomic_t *v = (atomic_t *)l;
+#define atomic_xchg(ptr, v)             (xchg(&(ptr)->counter, (v)))
+#define atomic_cmpxchg(v, old, new)     (cmpxchg(&((v)->counter), (old), (new)))
 
-        return (long)atomic_add_unless(v, a, u);
-}
+#define cmpxchg_local(ptr, o, n)                                               \
+        ((__typeof__(*(ptr)))__cmpxchg_local_generic((ptr), (unsigned long)(o),\
+                        (unsigned long)(n), sizeof(*(ptr))))
 
-#define atomic_long_inc_not_zero(l) atomic_inc_not_zero((atomic_t *)(l))
+#define cmpxchg64_local(ptr, o, n) __cmpxchg64_local_generic((ptr), (o), (n))
 
-#define atomic_long_cmpxchg(l, old, new) \
-        (atomic_cmpxchg((atomic_t *)(l), (old), (new)))
-#define atomic_long_xchg(v, new) \
-        (atomic_xchg((atomic_t *)(v), (new)))
+/* Assume that atomic operations are already serializing */
+#define smp_mb__before_atomic_dec()     barrier()
+#define smp_mb__after_atomic_dec()      barrier()
+#define smp_mb__before_atomic_inc()     barrier()
+#define smp_mb__after_atomic_inc()      barrier()
 
-#endif  /*  BITS_PER_LONG == 64  */
+#include <asm-generic/atomic-long.h>
 
-#endif  /*  _ASM_GENERIC_ATOMIC_H  */
+#endif /* __KERNEL__ */
+#endif /* __ASM_GENERIC_ATOMIC_H */
diff --git a/include/asm-generic/atomic64.h b/include/asm-generic/atomic64.h
new file mode 100644
index 000000000000..b18ce4f9ee3d
--- /dev/null
+++ b/include/asm-generic/atomic64.h
@@ -0,0 +1,42 @@
+/*
+ * Generic implementation of 64-bit atomics using spinlocks,
+ * useful on processors that don't have 64-bit atomic instructions.
+ *
+ * Copyright © 2009 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+#ifndef _ASM_GENERIC_ATOMIC64_H
+#define _ASM_GENERIC_ATOMIC64_H
+
+typedef struct {
+        long long counter;
+} atomic64_t;
+
+#define ATOMIC64_INIT(i)        { (i) }
+
+extern long long atomic64_read(const atomic64_t *v);
+extern void      atomic64_set(atomic64_t *v, long long i);
+extern void      atomic64_add(long long a, atomic64_t *v);
+extern long long atomic64_add_return(long long a, atomic64_t *v);
+extern void      atomic64_sub(long long a, atomic64_t *v);
+extern long long atomic64_sub_return(long long a, atomic64_t *v);
+extern long long atomic64_dec_if_positive(atomic64_t *v);
+extern long long atomic64_cmpxchg(atomic64_t *v, long long o, long long n);
+extern long long atomic64_xchg(atomic64_t *v, long long new);
+extern int       atomic64_add_unless(atomic64_t *v, long long a, long long u);
+
+#define atomic64_add_negative(a, v)     (atomic64_add_return((a), (v)) < 0)
+#define atomic64_inc(v)                 atomic64_add(1LL, (v))
+#define atomic64_inc_return(v)          atomic64_add_return(1LL, (v))
+#define atomic64_inc_and_test(v)        (atomic64_inc_return(v) == 0)
+#define atomic64_sub_and_test(a, v)     (atomic64_sub_return((a), (v)) == 0)
+#define atomic64_dec(v)                 atomic64_sub(1LL, (v))
+#define atomic64_dec_return(v)          atomic64_sub_return(1LL, (v))
+#define atomic64_dec_and_test(v)        (atomic64_dec_return((v)) == 0)
+#define atomic64_inc_not_zero(v)        atomic64_add_unless((v), 1LL, 0LL)
+
+#endif  /*  _ASM_GENERIC_ATOMIC64_H  */
diff --git a/include/asm-generic/auxvec.h b/include/asm-generic/auxvec.h
new file mode 100644
index 000000000000..b99573b0ad12
--- /dev/null
+++ b/include/asm-generic/auxvec.h
@@ -0,0 +1,8 @@
+#ifndef __ASM_GENERIC_AUXVEC_H
+#define __ASM_GENERIC_AUXVEC_H
+/*
+ * Not all architectures need their own auxvec.h, the most
+ * common definitions are already in linux/auxvec.h.
+ */
+
+#endif /* __ASM_GENERIC_AUXVEC_H */
diff --git a/include/asm-generic/bitops.h b/include/asm-generic/bitops.h
index c9f369c4bd7e..a54f4421a24d 100644
--- a/include/asm-generic/bitops.h
+++ b/include/asm-generic/bitops.h
@@ -1,19 +1,29 @@
-#ifndef _ASM_GENERIC_BITOPS_H_
-#define _ASM_GENERIC_BITOPS_H_
+#ifndef __ASM_GENERIC_BITOPS_H
+#define __ASM_GENERIC_BITOPS_H
 
 /*
  * For the benefit of those who are trying to port Linux to another
  * architecture, here are some C-language equivalents.  You should
  * recode these in the native assembly language, if at all possible.
- * 
+ *
  * C language equivalents written by Theodore Ts'o, 9/26/92
  */
 
-#include <asm-generic/bitops/atomic.h>
-#include <asm-generic/bitops/non-atomic.h>
+#include <linux/irqflags.h>
+#include <linux/compiler.h>
+
+/*
+ * clear_bit may not imply a memory barrier
+ */
+#ifndef smp_mb__before_clear_bit
+#define smp_mb__before_clear_bit()      smp_mb()
+#define smp_mb__after_clear_bit()       smp_mb()
+#endif
+
 #include <asm-generic/bitops/__ffs.h>
 #include <asm-generic/bitops/ffz.h>
 #include <asm-generic/bitops/fls.h>
+#include <asm-generic/bitops/__fls.h>
 #include <asm-generic/bitops/fls64.h>
 #include <asm-generic/bitops/find.h>
 
@@ -26,8 +36,10 @@
 #include <asm-generic/bitops/hweight.h>
 #include <asm-generic/bitops/lock.h>
 
+#include <asm-generic/bitops/atomic.h>
+#include <asm-generic/bitops/non-atomic.h>
 #include <asm-generic/bitops/ext2-non-atomic.h>
 #include <asm-generic/bitops/ext2-atomic.h>
 #include <asm-generic/bitops/minix.h>
 
-#endif /* _ASM_GENERIC_BITOPS_H */
+#endif /* __ASM_GENERIC_BITOPS_H */
diff --git a/include/asm-generic/bitops/atomic.h b/include/asm-generic/bitops/atomic.h
index 4657f3e410fc..c8946465e63a 100644
--- a/include/asm-generic/bitops/atomic.h
+++ b/include/asm-generic/bitops/atomic.h
@@ -2,6 +2,7 @@
 #define _ASM_GENERIC_BITOPS_ATOMIC_H_
 
 #include <asm/types.h>
+#include <asm/system.h>
 
 #ifdef CONFIG_SMP
 #include <asm/spinlock.h>
diff --git a/include/asm-generic/bitsperlong.h b/include/asm-generic/bitsperlong.h
new file mode 100644
index 000000000000..4ae54e07de83
--- /dev/null
+++ b/include/asm-generic/bitsperlong.h
@@ -0,0 +1,32 @@
+#ifndef __ASM_GENERIC_BITS_PER_LONG
+#define __ASM_GENERIC_BITS_PER_LONG
+
+/*
+ * There seems to be no way of detecting this automatically from user
+ * space, so 64 bit architectures should override this in their
+ * bitsperlong.h. In particular, an architecture that supports
+ * both 32 and 64 bit user space must not rely on CONFIG_64BIT
+ * to decide it, but rather check a compiler provided macro.
+ */
+#ifndef __BITS_PER_LONG
+#define __BITS_PER_LONG 32
+#endif
+
+#ifdef __KERNEL__
+
+#ifdef CONFIG_64BIT
+#define BITS_PER_LONG 64
+#else
+#define BITS_PER_LONG 32
+#endif /* CONFIG_64BIT */
+
+/*
+ * FIXME: The check currently breaks x86-64 build, so it's
+ * temporarily disabled. Please fix x86-64 and reenable
+ */
+#if 0 && BITS_PER_LONG != __BITS_PER_LONG
+#error Inconsistent word size. Check asm/bitsperlong.h
+#endif
+
+#endif /* __KERNEL__ */
+#endif /* __ASM_GENERIC_BITS_PER_LONG */
diff --git a/include/asm-generic/bugs.h b/include/asm-generic/bugs.h
new file mode 100644
index 000000000000..6c4f62ea714d
--- /dev/null
+++ b/include/asm-generic/bugs.h
@@ -0,0 +1,10 @@
+#ifndef __ASM_GENERIC_BUGS_H
+#define __ASM_GENERIC_BUGS_H
+/*
+ * This file is included by 'init/main.c' to check for
+ * architecture-dependent bugs.
+ */
+
+static inline void check_bugs(void) { }
+
+#endif  /* __ASM_GENERIC_BUGS_H */
diff --git a/include/asm-generic/cache.h b/include/asm-generic/cache.h
new file mode 100644
index 000000000000..1bfcfe5c2237
--- /dev/null
+++ b/include/asm-generic/cache.h
@@ -0,0 +1,12 @@
+#ifndef __ASM_GENERIC_CACHE_H
+#define __ASM_GENERIC_CACHE_H
+/*
+ * 32 bytes appears to be the most common cache line size,
+ * so make that the default here. Architectures with larger
+ * cache lines need to provide their own cache.h.
+ */
+
+#define L1_CACHE_SHIFT          5
+#define L1_CACHE_BYTES          (1 << L1_CACHE_SHIFT)
+
+#endif /* __ASM_GENERIC_CACHE_H */
diff --git a/include/asm-generic/cacheflush.h b/include/asm-generic/cacheflush.h
new file mode 100644
index 000000000000..ba4ec39a1131
--- /dev/null
+++ b/include/asm-generic/cacheflush.h
@@ -0,0 +1,30 @@
+#ifndef __ASM_CACHEFLUSH_H
+#define __ASM_CACHEFLUSH_H
+
+/* Keep includes the same across arches.  */
+#include <linux/mm.h>
+
+/*
+ * The cache doesn't need to be flushed when TLB entries change when
+ * the cache is mapped to physical memory, not virtual memory
+ */
+#define flush_cache_all()                       do { } while (0)
+#define flush_cache_mm(mm)                      do { } while (0)
+#define flush_cache_dup_mm(mm)                  do { } while (0)
+#define flush_cache_range(vma, start, end)      do { } while (0)
+#define flush_cache_page(vma, vmaddr, pfn)      do { } while (0)
+#define flush_dcache_page(page)                 do { } while (0)
+#define flush_dcache_mmap_lock(mapping)         do { } while (0)
+#define flush_dcache_mmap_unlock(mapping)       do { } while (0)
+#define flush_icache_range(start, end)          do { } while (0)
+#define flush_icache_page(vma,pg)               do { } while (0)
+#define flush_icache_user_range(vma,pg,adr,len) do { } while (0)
+#define flush_cache_vmap(start, end)            do { } while (0)
+#define flush_cache_vunmap(start, end)          do { } while (0)
+
+#define copy_to_user_page(vma, page, vaddr, dst, src, len) \
+        memcpy(dst, src, len)
+#define copy_from_user_page(vma, page, vaddr, dst, src, len) \
+        memcpy(dst, src, len)
+
+#endif /* __ASM_CACHEFLUSH_H */
diff --git a/include/asm-generic/checksum.h b/include/asm-generic/checksum.h
new file mode 100644
index 000000000000..4647c762d970
--- /dev/null
+++ b/include/asm-generic/checksum.h
@@ -0,0 +1,79 @@
+#ifndef __ASM_GENERIC_CHECKSUM_H
+#define __ASM_GENERIC_CHECKSUM_H
+
+/*
+ * computes the checksum of a memory block at buff, length len,
+ * and adds in "sum" (32-bit)
+ *
+ * returns a 32-bit number suitable for feeding into itself
+ * or csum_tcpudp_magic
+ *
+ * this function must be called with even lengths, except
+ * for the last fragment, which may be odd
+ *
+ * it's best to have buff aligned on a 32-bit boundary
+ */
+extern __wsum csum_partial(const void *buff, int len, __wsum sum);
+
+/*
+ * the same as csum_partial, but copies from src while it
+ * checksums
+ *
+ * here even more important to align src and dst on a 32-bit (or even
+ * better 64-bit) boundary
+ */
+extern __wsum csum_partial_copy(const void *src, void *dst, int len, __wsum sum);
+
+/*
+ * the same as csum_partial_copy, but copies from user space.
+ *
+ * here even more important to align src and dst on a 32-bit (or even
+ * better 64-bit) boundary
+ */
+extern __wsum csum_partial_copy_from_user(const void __user *src, void *dst,
+                                        int len, __wsum sum, int *csum_err);
+
+#define csum_partial_copy_nocheck(src, dst, len, sum)   \
+        csum_partial_copy((src), (dst), (len), (sum))
+
+/*
+ * This is a version of ip_compute_csum() optimized for IP headers,
+ * which always checksum on 4 octet boundaries.
+ */
+extern __sum16 ip_fast_csum(const void *iph, unsigned int ihl);
+
+/*
+ * Fold a partial checksum
+ */
+static inline __sum16 csum_fold(__wsum csum)
+{
+        u32 sum = (__force u32)csum;
+        sum = (sum & 0xffff) + (sum >> 16);
+        sum = (sum & 0xffff) + (sum >> 16);
+        return (__force __sum16)~sum;
+}
+
+#ifndef csum_tcpudp_nofold
+/*
+ * computes the checksum of the TCP/UDP pseudo-header
+ * returns a 16-bit checksum, already complemented
+ */
+extern __wsum
+csum_tcpudp_nofold(__be32 saddr, __be32 daddr, unsigned short len,
+                unsigned short proto, __wsum sum);
+#endif
+
+static inline __sum16
+csum_tcpudp_magic(__be32 saddr, __be32 daddr, unsigned short len,
+                  unsigned short proto, __wsum sum)
+{
+        return csum_fold(csum_tcpudp_nofold(saddr, daddr, len, proto, sum));
+}
+
+/*
+ * this routine is used for miscellaneous IP-like checksums, mainly
+ * in icmp.c
+ */
+extern __sum16 ip_compute_csum(const void *buff, int len);
+
+#endif /* __ASM_GENERIC_CHECKSUM_H */
diff --git a/include/asm-generic/current.h b/include/asm-generic/current.h
new file mode 100644
index 000000000000..5e86f6ae7cab
--- /dev/null
+++ b/include/asm-generic/current.h
@@ -0,0 +1,9 @@
+#ifndef __ASM_GENERIC_CURRENT_H
+#define __ASM_GENERIC_CURRENT_H
+
+#include <linux/thread_info.h>
+
+#define get_current() (current_thread_info()->task)
+#define current get_current()
+
+#endif /* __ASM_GENERIC_CURRENT_H */
diff --git a/include/asm-generic/delay.h b/include/asm-generic/delay.h
new file mode 100644
index 000000000000..4586fec75ddb
--- /dev/null
+++ b/include/asm-generic/delay.h
@@ -0,0 +1,9 @@
+#ifndef __ASM_GENERIC_DELAY_H
+#define __ASM_GENERIC_DELAY_H
+
+extern void __udelay(unsigned long usecs);
+extern void __delay(unsigned long loops);
+
+#define udelay(n) __udelay(n)
+
+#endif /* __ASM_GENERIC_DELAY_H */
diff --git a/include/asm-generic/dma-mapping-common.h b/include/asm-generic/dma-mapping-common.h
new file mode 100644
index 000000000000..5406a601185c
--- /dev/null
+++ b/include/asm-generic/dma-mapping-common.h
@@ -0,0 +1,190 @@
+#ifndef _ASM_GENERIC_DMA_MAPPING_H
+#define _ASM_GENERIC_DMA_MAPPING_H
+
+#include <linux/kmemcheck.h>
+#include <linux/scatterlist.h>
+#include <linux/dma-debug.h>
+#include <linux/dma-attrs.h>
+
+static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
+                                              size_t size,
+                                              enum dma_data_direction dir,
+                                              struct dma_attrs *attrs)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+        dma_addr_t addr;
+
+        kmemcheck_mark_initialized(ptr, size);
+        BUG_ON(!valid_dma_direction(dir));
+        addr = ops->map_page(dev, virt_to_page(ptr),
+                             (unsigned long)ptr & ~PAGE_MASK, size,
+                             dir, attrs);
+        debug_dma_map_page(dev, virt_to_page(ptr),
+                           (unsigned long)ptr & ~PAGE_MASK, size,
+                           dir, addr, true);
+        return addr;
+}
+
+static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
+                                          size_t size,
+                                          enum dma_data_direction dir,
+                                          struct dma_attrs *attrs)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->unmap_page)
+                ops->unmap_page(dev, addr, size, dir, attrs);
+        debug_dma_unmap_page(dev, addr, size, dir, true);
+}
+
+static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
+                                   int nents, enum dma_data_direction dir,
+                                   struct dma_attrs *attrs)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+        int i, ents;
+        struct scatterlist *s;
+
+        for_each_sg(sg, s, nents, i)
+                kmemcheck_mark_initialized(sg_virt(s), s->length);
+        BUG_ON(!valid_dma_direction(dir));
+        ents = ops->map_sg(dev, sg, nents, dir, attrs);
+        debug_dma_map_sg(dev, sg, nents, ents, dir);
+
+        return ents;
+}
+
+static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
+                                      int nents, enum dma_data_direction dir,
+                                      struct dma_attrs *attrs)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        debug_dma_unmap_sg(dev, sg, nents, dir);
+        if (ops->unmap_sg)
+                ops->unmap_sg(dev, sg, nents, dir, attrs);
+}
+
+static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
+                                      size_t offset, size_t size,
+                                      enum dma_data_direction dir)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+        dma_addr_t addr;
+
+        kmemcheck_mark_initialized(page_address(page) + offset, size);
+        BUG_ON(!valid_dma_direction(dir));
+        addr = ops->map_page(dev, page, offset, size, dir, NULL);
+        debug_dma_map_page(dev, page, offset, size, dir, addr, false);
+
+        return addr;
+}
+
+static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
+                                  size_t size, enum dma_data_direction dir)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->unmap_page)
+                ops->unmap_page(dev, addr, size, dir, NULL);
+        debug_dma_unmap_page(dev, addr, size, dir, false);
+}
+
+static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
+                                           size_t size,
+                                           enum dma_data_direction dir)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->sync_single_for_cpu)
+                ops->sync_single_for_cpu(dev, addr, size, dir);
+        debug_dma_sync_single_for_cpu(dev, addr, size, dir);
+        flush_write_buffers();
+}
+
+static inline void dma_sync_single_for_device(struct device *dev,
+                                              dma_addr_t addr, size_t size,
+                                              enum dma_data_direction dir)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->sync_single_for_device)
+                ops->sync_single_for_device(dev, addr, size, dir);
+        debug_dma_sync_single_for_device(dev, addr, size, dir);
+        flush_write_buffers();
+}
+
+static inline void dma_sync_single_range_for_cpu(struct device *dev,
+                                                 dma_addr_t addr,
+                                                 unsigned long offset,
+                                                 size_t size,
+                                                 enum dma_data_direction dir)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->sync_single_range_for_cpu) {
+                ops->sync_single_range_for_cpu(dev, addr, offset, size, dir);
+                debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
+
+                flush_write_buffers();
+        } else
+                dma_sync_single_for_cpu(dev, addr, size, dir);
+}
+
+static inline void dma_sync_single_range_for_device(struct device *dev,
+                                                    dma_addr_t addr,
+                                                    unsigned long offset,
+                                                    size_t size,
+                                                    enum dma_data_direction dir)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->sync_single_range_for_device) {
+                ops->sync_single_range_for_device(dev, addr, offset, size, dir);
+                debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
+
+                flush_write_buffers();
+        } else
+                dma_sync_single_for_device(dev, addr, size, dir);
+}
+
+static inline void
+dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
+                    int nelems, enum dma_data_direction dir)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->sync_sg_for_cpu)
+                ops->sync_sg_for_cpu(dev, sg, nelems, dir);
+        debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
+        flush_write_buffers();
+}
+
+static inline void
+dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
+                       int nelems, enum dma_data_direction dir)
+{
+        struct dma_map_ops *ops = get_dma_ops(dev);
+
+        BUG_ON(!valid_dma_direction(dir));
+        if (ops->sync_sg_for_device)
+                ops->sync_sg_for_device(dev, sg, nelems, dir);
+        debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
+
+        flush_write_buffers();
+}
+
+#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
+#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL)
+#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)
+#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)
+
+#endif
diff --git a/include/asm-generic/dma.h b/include/asm-generic/dma.h
new file mode 100644
index 000000000000..9dfc3a7f36d2
--- /dev/null
+++ b/include/asm-generic/dma.h
@@ -0,0 +1,15 @@
+#ifndef __ASM_GENERIC_DMA_H
+#define __ASM_GENERIC_DMA_H
+/*
+ * This file traditionally describes the i8237 PC style DMA controller.
+ * Most architectures don't have these any more and can get the minimal
+ * implementation from kernel/dma.c by not defining MAX_DMA_CHANNELS.
+ *
+ * Some code relies on seeing MAX_DMA_ADDRESS though.
+ */
+#define MAX_DMA_ADDRESS PAGE_OFFSET
+
+extern int request_dma(unsigned int dmanr, const char *device_id);
+extern void free_dma(unsigned int dmanr);
+
+#endif /* __ASM_GENERIC_DMA_H */
diff --git a/include/asm-generic/errno.h b/include/asm-generic/errno.h
index e8852c092fea..28cc03bf19e6 100644
--- a/include/asm-generic/errno.h
+++ b/include/asm-generic/errno.h
@@ -106,4 +106,6 @@
 #define EOWNERDEAD      130     /* Owner died */
 #define ENOTRECOVERABLE 131     /* State not recoverable */
 
+#define ERFKILL         132     /* Operation not possible due to RF-kill */
+
 #endif
diff --git a/include/asm-generic/fb.h b/include/asm-generic/fb.h
new file mode 100644
index 000000000000..fe8ca7fcea00
--- /dev/null
+++ b/include/asm-generic/fb.h
@@ -0,0 +1,12 @@
+#ifndef __ASM_GENERIC_FB_H_
+#define __ASM_GENERIC_FB_H_
+#include <linux/fb.h>
+
+#define fb_pgprotect(...) do {} while (0)
+
+static inline int fb_is_primary_device(struct fb_info *info)
+{
+        return 0;
+}
+
+#endif /* __ASM_GENERIC_FB_H_ */
diff --git a/include/asm-generic/getorder.h b/include/asm-generic/getorder.h
new file mode 100644
index 000000000000..67e7245dc9b3
--- /dev/null
+++ b/include/asm-generic/getorder.h
@@ -0,0 +1,24 @@
+#ifndef __ASM_GENERIC_GETORDER_H
+#define __ASM_GENERIC_GETORDER_H
+
+#ifndef __ASSEMBLY__
+
+#include <linux/compiler.h>
+
+/* Pure 2^n version of get_order */
+static inline __attribute_const__ int get_order(unsigned long size)
+{
+        int order;
+
+        size = (size - 1) >> (PAGE_SHIFT - 1);
+        order = -1;
+        do {
+                size >>= 1;
+                order++;
+        } while (size);
+        return order;
+}
+
+#endif  /* __ASSEMBLY__ */
+
+#endif  /* __ASM_GENERIC_GETORDER_H */
diff --git a/include/asm-generic/hardirq.h b/include/asm-generic/hardirq.h
new file mode 100644
index 000000000000..23bb4dad4962
--- /dev/null
+++ b/include/asm-generic/hardirq.h
@@ -0,0 +1,21 @@
+#ifndef __ASM_GENERIC_HARDIRQ_H
+#define __ASM_GENERIC_HARDIRQ_H
+
+#include <linux/cache.h>
+#include <linux/threads.h>
+#include <linux/irq.h>
+
+typedef struct {
+        unsigned long __softirq_pending;
+} ____cacheline_aligned irq_cpustat_t;
+
+#include <linux/irq_cpustat.h>  /* Standard mappings for irq_cpustat_t above */
+
+#ifndef ack_bad_irq
+static inline void ack_bad_irq(unsigned int irq)
+{
+        printk(KERN_CRIT "unexpected IRQ trap at vector %02x\n", irq);
+}
+#endif
+
+#endif /* __ASM_GENERIC_HARDIRQ_H */
diff --git a/include/asm-generic/hw_irq.h b/include/asm-generic/hw_irq.h
new file mode 100644
index 000000000000..89036d7b40e0
--- /dev/null
+++ b/include/asm-generic/hw_irq.h
@@ -0,0 +1,9 @@
+#ifndef __ASM_GENERIC_HW_IRQ_H
+#define __ASM_GENERIC_HW_IRQ_H
+/*
+ * hw_irq.h has internal declarations for the low-level interrupt
+ * controller, like the original i8259A.
+ * In general, this is not needed for new architectures.
+ */
+
+#endif /* __ASM_GENERIC_HW_IRQ_H */
diff --git a/include/asm-generic/int-l64.h b/include/asm-generic/int-l64.h
index 2af9b75d77db..1ca3efc976cc 100644
--- a/include/asm-generic/int-l64.h
+++ b/include/asm-generic/int-l64.h
@@ -8,6 +8,8 @@
 #ifndef _ASM_GENERIC_INT_L64_H
 #define _ASM_GENERIC_INT_L64_H
 
+#include <asm/bitsperlong.h>
+
 #ifndef __ASSEMBLY__
 /*
  * __xx is ok: it doesn't pollute the POSIX namespace. Use these in the
diff --git a/include/asm-generic/int-ll64.h b/include/asm-generic/int-ll64.h
index f9bc9ac29b36..f394147c0739 100644
--- a/include/asm-generic/int-ll64.h
+++ b/include/asm-generic/int-ll64.h
@@ -8,6 +8,8 @@
 #ifndef _ASM_GENERIC_INT_LL64_H
 #define _ASM_GENERIC_INT_LL64_H
 
+#include <asm/bitsperlong.h>
+
 #ifndef __ASSEMBLY__
 /*
  * __xx is ok: it doesn't pollute the POSIX namespace. Use these in the
diff --git a/include/asm-generic/io.h b/include/asm-generic/io.h
new file mode 100644
index 000000000000..bcee6365dca0
--- /dev/null
+++ b/include/asm-generic/io.h
@@ -0,0 +1,300 @@
+/* Generic I/O port emulation, based on MN10300 code
+ *
+ * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+#ifndef __ASM_GENERIC_IO_H
+#define __ASM_GENERIC_IO_H
+
+#include <asm/page.h> /* I/O is all done through memory accesses */
+#include <asm/cacheflush.h>
+#include <linux/types.h>
+
+#ifdef CONFIG_GENERIC_IOMAP
+#include <asm-generic/iomap.h>
+#endif
+
+#define mmiowb() do {} while (0)
+
+/*****************************************************************************/
+/*
+ * readX/writeX() are used to access memory mapped devices. On some
+ * architectures the memory mapped IO stuff needs to be accessed
+ * differently. On the simple architectures, we just read/write the
+ * memory location directly.
+ */
+static inline u8 __raw_readb(const volatile void __iomem *addr)
+{
+        return *(const volatile u8 __force *) addr;
+}
+
+static inline u16 __raw_readw(const volatile void __iomem *addr)
+{
+        return *(const volatile u16 __force *) addr;
+}
+
+static inline u32 __raw_readl(const volatile void __iomem *addr)
+{
+        return *(const volatile u32 __force *) addr;
+}
+
+#define readb __raw_readb
+#define readw(addr) __le16_to_cpu(__raw_readw(addr))
+#define readl(addr) __le32_to_cpu(__raw_readl(addr))
+
+static inline void __raw_writeb(u8 b, volatile void __iomem *addr)
+{
+        *(volatile u8 __force *) addr = b;
+}
+
+static inline void __raw_writew(u16 b, volatile void __iomem *addr)
+{
+        *(volatile u16 __force *) addr = b;
+}
+
+static inline void __raw_writel(u32 b, volatile void __iomem *addr)
+{
+        *(volatile u32 __force *) addr = b;
+}
+
+#define writeb __raw_writeb
+#define writew(b,addr) __raw_writew(__cpu_to_le16(b),addr)
+#define writel(b,addr) __raw_writel(__cpu_to_le32(b),addr)
+
+#ifdef CONFIG_64BIT
+static inline u64 __raw_readq(const volatile void __iomem *addr)
+{
+        return *(const volatile u64 __force *) addr;
+}
+#define readq(addr) __le64_to_cpu(__raw_readq(addr))
+
+static inline void __raw_writeq(u64 b, volatile void __iomem *addr)
+{
+        *(volatile u64 __force *) addr = b;
+}
+#define writeq(b,addr) __raw_writeq(__cpu_to_le64(b),addr)
+#endif
+
+/*****************************************************************************/
+/*
+ * traditional input/output functions
+ */
+
+static inline u8 inb(unsigned long addr)
+{
+        return readb((volatile void __iomem *) addr);
+}
+
+static inline u16 inw(unsigned long addr)
+{
+        return readw((volatile void __iomem *) addr);
+}
+
+static inline u32 inl(unsigned long addr)
+{
+        return readl((volatile void __iomem *) addr);
+}
+
+static inline void outb(u8 b, unsigned long addr)
+{
+        writeb(b, (volatile void __iomem *) addr);
+}
+
+static inline void outw(u16 b, unsigned long addr)
+{
+        writew(b, (volatile void __iomem *) addr);
+}
+
+static inline void outl(u32 b, unsigned long addr)
+{
+        writel(b, (volatile void __iomem *) addr);
+}
+
+#define inb_p(addr)     inb(addr)
+#define inw_p(addr)     inw(addr)
+#define inl_p(addr)     inl(addr)
+#define outb_p(x, addr) outb((x), (addr))
+#define outw_p(x, addr) outw((x), (addr))
+#define outl_p(x, addr) outl((x), (addr))
+
+static inline void insb(unsigned long addr, void *buffer, int count)
+{
+        if (count) {
+                u8 *buf = buffer;
+                do {
+                        u8 x = inb(addr);
+                        *buf++ = x;
+                } while (--count);
+        }
+}
+
+static inline void insw(unsigned long addr, void *buffer, int count)
+{
+        if (count) {
+                u16 *buf = buffer;
+                do {
+                        u16 x = inw(addr);
+                        *buf++ = x;
+                } while (--count);
+        }
+}
+
+static inline void insl(unsigned long addr, void *buffer, int count)
+{
+        if (count) {
+                u32 *buf = buffer;
+                do {
+                        u32 x = inl(addr);
+                        *buf++ = x;
+                } while (--count);
+        }
+}
+
+static inline void outsb(unsigned long addr, const void *buffer, int count)
+{
+        if (count) {
+                const u8 *buf = buffer;
+                do {
+                        outb(*buf++, addr);
+                } while (--count);
+        }
+}
+
+static inline void outsw(unsigned long addr, const void *buffer, int count)
+{
+        if (count) {
+                const u16 *buf = buffer;
+                do {
+                        outw(*buf++, addr);
+                } while (--count);
+        }
+}
+
+static inline void outsl(unsigned long addr, const void *buffer, int count)
+{
+        if (count) {
+                const u32 *buf = buffer;
+                do {
+                        outl(*buf++, addr);
+                } while (--count);
+        }
+}
+
+#ifndef CONFIG_GENERIC_IOMAP
+#define ioread8(addr)           readb(addr)
+#define ioread16(addr)          readw(addr)
+#define ioread32(addr)          readl(addr)
+
+#define iowrite8(v, addr)       writeb((v), (addr))
+#define iowrite16(v, addr)      writew((v), (addr))
+#define iowrite32(v, addr)      writel((v), (addr))
+
+#define ioread8_rep(p, dst, count) \
+        insb((unsigned long) (p), (dst), (count))
+#define ioread16_rep(p, dst, count) \
+        insw((unsigned long) (p), (dst), (count))
+#define ioread32_rep(p, dst, count) \
+        insl((unsigned long) (p), (dst), (count))
+
+#define iowrite8_rep(p, src, count) \
+        outsb((unsigned long) (p), (src), (count))
+#define iowrite16_rep(p, src, count) \
+        outsw((unsigned long) (p), (src), (count))
+#define iowrite32_rep(p, src, count) \
+        outsl((unsigned long) (p), (src), (count))
+#endif /* CONFIG_GENERIC_IOMAP */
+
+
+#define IO_SPACE_LIMIT 0xffffffff
+
+#ifdef __KERNEL__
+
+#include <linux/vmalloc.h>
+#define __io_virt(x) ((void __force *) (x))
+
+#ifndef CONFIG_GENERIC_IOMAP
+/* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
+struct pci_dev;
+extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
+static inline void pci_iounmap(struct pci_dev *dev, void __iomem *p)
+{
+}
+#endif /* CONFIG_GENERIC_IOMAP */
+
+/*
+ * Change virtual addresses to physical addresses and vv.
+ * These are pretty trivial
+ */
+static inline unsigned long virt_to_phys(volatile void *address)
+{
+        return __pa((unsigned long)address);
+}
+
+static inline void *phys_to_virt(unsigned long address)
+{
+        return __va(address);
+}
+
+/*
+ * Change "struct page" to physical address.
+ */
+static inline void __iomem *ioremap(phys_addr_t offset, unsigned long size)
+{
+        return (void __iomem*) (unsigned long)offset;
+}
+
+#define __ioremap(offset, size, flags)  ioremap(offset, size)
+
+#ifndef ioremap_nocache
+#define ioremap_nocache ioremap
+#endif
+
+#ifndef ioremap_wc
+#define ioremap_wc ioremap_nocache
+#endif
+
+static inline void iounmap(void *addr)
+{
+}
+
+#ifndef CONFIG_GENERIC_IOMAP
+static inline void __iomem *ioport_map(unsigned long port, unsigned int nr)
+{
+        return (void __iomem *) port;
+}
+
+static inline void ioport_unmap(void __iomem *p)
+{
+}
+#else /* CONFIG_GENERIC_IOMAP */
+extern void __iomem *ioport_map(unsigned long port, unsigned int nr);
+extern void ioport_unmap(void __iomem *p);
+#endif /* CONFIG_GENERIC_IOMAP */
+
+#define xlate_dev_kmem_ptr(p)   p
+#define xlate_dev_mem_ptr(p)    ((void *) (p))
+
+#ifndef virt_to_bus
+static inline unsigned long virt_to_bus(volatile void *address)
+{
+        return ((unsigned long) address);
+}
+
+static inline void *bus_to_virt(unsigned long address)
+{
+        return (void *) address;
+}
+#endif
+
+#define memset_io(a, b, c)      memset(__io_virt(a), (b), (c))
+#define memcpy_fromio(a, b, c)  memcpy((a), __io_virt(b), (c))
+#define memcpy_toio(a, b, c)    memcpy(__io_virt(a), (b), (c))
+
+#endif /* __KERNEL__ */
+
+#endif /* __ASM_GENERIC_IO_H */
diff --git a/include/asm-generic/ioctls.h b/include/asm-generic/ioctls.h
new file mode 100644
index 000000000000..a799e20a769e
--- /dev/null
+++ b/include/asm-generic/ioctls.h
@@ -0,0 +1,110 @@
+#ifndef __ASM_GENERIC_IOCTLS_H
+#define __ASM_GENERIC_IOCTLS_H
+
+#include <linux/ioctl.h>
+
+/*
+ * These are the most common definitions for tty ioctl numbers.
+ * Most of them do not use the recommended _IOC(), but there is
+ * probably some source code out there hardcoding the number,
+ * so we might as well use them for all new platforms.
+ *
+ * The architectures that use different values here typically
+ * try to be compatible with some Unix variants for the same
+ * architecture.
+ */
+
+/* 0x54 is just a magic number to make these relatively unique ('T') */
+
+#define TCGETS          0x5401
+#define TCSETS          0x5402
+#define TCSETSW         0x5403
+#define TCSETSF         0x5404
+#define TCGETA          0x5405
+#define TCSETA          0x5406
+#define TCSETAW         0x5407
+#define TCSETAF         0x5408
+#define TCSBRK          0x5409
+#define TCXONC          0x540A
+#define TCFLSH          0x540B
+#define TIOCEXCL        0x540C
+#define TIOCNXCL        0x540D
+#define TIOCSCTTY       0x540E
+#define TIOCGPGRP       0x540F
+#define TIOCSPGRP       0x5410
+#define TIOCOUTQ        0x5411
+#define TIOCSTI         0x5412
+#define TIOCGWINSZ      0x5413
+#define TIOCSWINSZ      0x5414
+#define TIOCMGET        0x5415
+#define TIOCMBIS        0x5416
+#define TIOCMBIC        0x5417
+#define TIOCMSET        0x5418
+#define TIOCGSOFTCAR    0x5419
+#define TIOCSSOFTCAR    0x541A
+#define FIONREAD        0x541B
+#define TIOCINQ         FIONREAD
+#define TIOCLINUX       0x541C
+#define TIOCCONS        0x541D
+#define TIOCGSERIAL     0x541E
+#define TIOCSSERIAL     0x541F
+#define TIOCPKT         0x5420
+#define FIONBIO         0x5421
+#define TIOCNOTTY       0x5422
+#define TIOCSETD        0x5423
+#define TIOCGETD        0x5424
+#define TCSBRKP         0x5425  /* Needed for POSIX tcsendbreak() */
+#define TIOCSBRK        0x5427  /* BSD compatibility */
+#define TIOCCBRK        0x5428  /* BSD compatibility */
+#define TIOCGSID        0x5429  /* Return the session ID of FD */
+#define TCGETS2         _IOR('T', 0x2A, struct termios2)
+#define TCSETS2         _IOW('T', 0x2B, struct termios2)
+#define TCSETSW2        _IOW('T', 0x2C, struct termios2)
+#define TCSETSF2        _IOW('T', 0x2D, struct termios2)
+#define TIOCGRS485      0x542E
+#define TIOCSRS485      0x542F
+#define TIOCGPTN        _IOR('T', 0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
+#define TIOCSPTLCK      _IOW('T', 0x31, int)  /* Lock/unlock Pty */
+#define TCGETX          0x5432 /* SYS5 TCGETX compatibility */
+#define TCSETX          0x5433
+#define TCSETXF         0x5434
+#define TCSETXW         0x5435
+
+#define FIONCLEX        0x5450
+#define FIOCLEX         0x5451
+#define FIOASYNC        0x5452
+#define TIOCSERCONFIG   0x5453
+#define TIOCSERGWILD    0x5454
+#define TIOCSERSWILD    0x5455
+#define TIOCGLCKTRMIOS  0x5456
+#define TIOCSLCKTRMIOS  0x5457
+#define TIOCSERGSTRUCT  0x5458 /* For debugging only */
+#define TIOCSERGETLSR   0x5459 /* Get line status register */
+#define TIOCSERGETMULTI 0x545A /* Get multiport config  */
+#define TIOCSERSETMULTI 0x545B /* Set multiport config */
+
+#define TIOCMIWAIT      0x545C  /* wait for a change on serial input line(s) */
+#define TIOCGICOUNT     0x545D  /* read serial port inline interrupt counts */
+
+/*
+ * some architectures define FIOQSIZE as 0x545E, which is used for
+ * TIOCGHAYESESP on others
+ */
+#ifndef FIOQSIZE
+# define TIOCGHAYESESP  0x545E  /* Get Hayes ESP configuration */
+# define TIOCSHAYESESP  0x545F  /* Set Hayes ESP configuration */
+# define FIOQSIZE       0x5460
+#endif
+
+/* Used for packet mode */
+#define TIOCPKT_DATA             0
+#define TIOCPKT_FLUSHREAD        1
+#define TIOCPKT_FLUSHWRITE       2
+#define TIOCPKT_STOP             4
+#define TIOCPKT_START            8
+#define TIOCPKT_NOSTOP          16
+#define TIOCPKT_DOSTOP          32
+
+#define TIOCSER_TEMT    0x01    /* Transmitter physically empty */
+
+#endif /* __ASM_GENERIC_IOCTLS_H */
diff --git a/include/asm-generic/ipcbuf.h b/include/asm-generic/ipcbuf.h
new file mode 100644
index 000000000000..76982b2a1b58
--- /dev/null
+++ b/include/asm-generic/ipcbuf.h
@@ -0,0 +1,34 @@
+#ifndef __ASM_GENERIC_IPCBUF_H
+#define __ASM_GENERIC_IPCBUF_H
+
+/*
+ * The generic ipc64_perm structure:
+ * Note extra padding because this structure is passed back and forth
+ * between kernel and user space.
+ *
+ * ipc64_perm was originally meant to be architecture specific, but
+ * everyone just ended up making identical copies without specific
+ * optimizations, so we may just as well all use the same one.
+ *
+ * Pad space is left for:
+ * - 32-bit mode_t on architectures that only had 16 bit
+ * - 32-bit seq
+ * - 2 miscellaneous 32-bit values
+ */
+
+struct ipc64_perm {
+        __kernel_key_t          key;
+        __kernel_uid32_t        uid;
+        __kernel_gid32_t        gid;
+        __kernel_uid32_t        cuid;
+        __kernel_gid32_t        cgid;
+        __kernel_mode_t         mode;
+                                /* pad if mode_t is u16: */
+        unsigned char           __pad1[4 - sizeof(__kernel_mode_t)];
+        unsigned short          seq;
+        unsigned short          __pad2;
+        unsigned long           __unused1;
+        unsigned long           __unused2;
+};
+
+#endif /* __ASM_GENERIC_IPCBUF_H */
diff --git a/include/asm-generic/irq.h b/include/asm-generic/irq.h
new file mode 100644
index 000000000000..b90ec0bc485f
--- /dev/null
+++ b/include/asm-generic/irq.h
@@ -0,0 +1,18 @@
+#ifndef __ASM_GENERIC_IRQ_H
+#define __ASM_GENERIC_IRQ_H
+
+/*
+ * NR_IRQS is the upper bound of how many interrupts can be handled
+ * in the platform. It is used to size the static irq_map array,
+ * so don't make it too big.
+ */
+#ifndef NR_IRQS
+#define NR_IRQS 64
+#endif
+
+static inline int irq_canonicalize(int irq)
+{
+        return irq;
+}
+
+#endif /* __ASM_GENERIC_IRQ_H */
diff --git a/include/asm-generic/irqflags.h b/include/asm-generic/irqflags.h
new file mode 100644
index 000000000000..9aebf618275a
--- /dev/null
+++ b/include/asm-generic/irqflags.h
@@ -0,0 +1,72 @@
+#ifndef __ASM_GENERIC_IRQFLAGS_H
+#define __ASM_GENERIC_IRQFLAGS_H
+
+/*
+ * All architectures should implement at least the first two functions,
+ * usually inline assembly will be the best way.
+ */
+#ifndef RAW_IRQ_DISABLED
+#define RAW_IRQ_DISABLED 0
+#define RAW_IRQ_ENABLED 1
+#endif
+
+/* read interrupt enabled status */
+#ifndef __raw_local_save_flags
+unsigned long __raw_local_save_flags(void);
+#endif
+
+/* set interrupt enabled status */
+#ifndef raw_local_irq_restore
+void raw_local_irq_restore(unsigned long flags);
+#endif
+
+/* get status and disable interrupts */
+#ifndef __raw_local_irq_save
+static inline unsigned long __raw_local_irq_save(void)
+{
+        unsigned long flags;
+        flags = __raw_local_save_flags();
+        raw_local_irq_restore(RAW_IRQ_DISABLED);
+        return flags;
+}
+#endif
+
+/* test flags */
+#ifndef raw_irqs_disabled_flags
+static inline int raw_irqs_disabled_flags(unsigned long flags)
+{
+        return flags == RAW_IRQ_DISABLED;
+}
+#endif
+
+/* unconditionally enable interrupts */
+#ifndef raw_local_irq_enable
+static inline void raw_local_irq_enable(void)
+{
+        raw_local_irq_restore(RAW_IRQ_ENABLED);
+}
+#endif
+
+/* unconditionally disable interrupts */
+#ifndef raw_local_irq_disable
+static inline void raw_local_irq_disable(void)
+{
+        raw_local_irq_restore(RAW_IRQ_DISABLED);
+}
+#endif
+
+/* test hardware interrupt enable bit */
+#ifndef raw_irqs_disabled
+static inline int raw_irqs_disabled(void)
+{
+        return raw_irqs_disabled_flags(__raw_local_save_flags());
+}
+#endif
+
+#define raw_local_save_flags(flags) \
+        do { (flags) = __raw_local_save_flags(); } while (0)
+
+#define raw_local_irq_save(flags) \
+        do { (flags) = __raw_local_irq_save(); } while (0)
+
+#endif /* __ASM_GENERIC_IRQFLAGS_H */
diff --git a/include/asm-generic/kmap_types.h b/include/asm-generic/kmap_types.h
new file mode 100644
index 000000000000..eddbce0f9fb9
--- /dev/null
+++ b/include/asm-generic/kmap_types.h
@@ -0,0 +1,35 @@
+#ifndef _ASM_GENERIC_KMAP_TYPES_H
+#define _ASM_GENERIC_KMAP_TYPES_H
+
+#ifdef __WITH_KM_FENCE
+# define D(n) __KM_FENCE_##n ,
+#else
+# define D(n)
+#endif
+
+enum km_type {
+D(0)    KM_BOUNCE_READ,
+D(1)    KM_SKB_SUNRPC_DATA,
+D(2)    KM_SKB_DATA_SOFTIRQ,
+D(3)    KM_USER0,
+D(4)    KM_USER1,
+D(5)    KM_BIO_SRC_IRQ,
+D(6)    KM_BIO_DST_IRQ,
+D(7)    KM_PTE0,
+D(8)    KM_PTE1,
+D(9)    KM_IRQ0,
+D(10)   KM_IRQ1,
+D(11)   KM_SOFTIRQ0,
+D(12)   KM_SOFTIRQ1,
+D(13)   KM_SYNC_ICACHE,
+D(14)   KM_SYNC_DCACHE,
+D(15)   KM_UML_USERCOPY, /* UML specific, for copy_*_user - used in do_op_one_page */
+D(16)   KM_IRQ_PTE,
+D(17)   KM_NMI,
+D(18)   KM_NMI_PTE,
+D(19)   KM_TYPE_NR
+};
+
+#undef D
+
+#endif
diff --git a/include/asm-generic/linkage.h b/include/asm-generic/linkage.h
new file mode 100644
index 000000000000..fef7a01e5415
--- /dev/null
+++ b/include/asm-generic/linkage.h
@@ -0,0 +1,8 @@
+#ifndef __ASM_GENERIC_LINKAGE_H
+#define __ASM_GENERIC_LINKAGE_H
+/*
+ * linux/linkage.h provides reasonable defaults.
+ * an architecture can override them by providing its own version.
+ */
+
+#endif /* __ASM_GENERIC_LINKAGE_H */
diff --git a/include/asm-generic/mman-common.h b/include/asm-generic/mman-common.h
new file mode 100644
index 000000000000..3b69ad34189a
--- /dev/null
+++ b/include/asm-generic/mman-common.h
@@ -0,0 +1,41 @@
+#ifndef __ASM_GENERIC_MMAN_COMMON_H
+#define __ASM_GENERIC_MMAN_COMMON_H
+
+/*
+ Author: Michael S. Tsirkin <mst@mellanox.co.il>, Mellanox Technologies Ltd.
+ Based on: asm-xxx/mman.h
+*/
+
+#define PROT_READ       0x1             /* page can be read */
+#define PROT_WRITE      0x2             /* page can be written */
+#define PROT_EXEC       0x4             /* page can be executed */
+#define PROT_SEM        0x8             /* page may be used for atomic ops */
+#define PROT_NONE       0x0             /* page can not be accessed */
+#define PROT_GROWSDOWN  0x01000000      /* mprotect flag: extend change to start of growsdown vma */
+#define PROT_GROWSUP    0x02000000      /* mprotect flag: extend change to end of growsup vma */
+
+#define MAP_SHARED      0x01            /* Share changes */
+#define MAP_PRIVATE     0x02            /* Changes are private */
+#define MAP_TYPE        0x0f            /* Mask for type of mapping */
+#define MAP_FIXED       0x10            /* Interpret addr exactly */
+#define MAP_ANONYMOUS   0x20            /* don't use a file */
+
+#define MS_ASYNC        1               /* sync memory asynchronously */
+#define MS_INVALIDATE   2               /* invalidate the caches */
+#define MS_SYNC         4               /* synchronous memory sync */
+
+#define MADV_NORMAL     0               /* no further special treatment */
+#define MADV_RANDOM     1               /* expect random page references */
+#define MADV_SEQUENTIAL 2               /* expect sequential page references */
+#define MADV_WILLNEED   3               /* will need these pages */
+#define MADV_DONTNEED   4               /* don't need these pages */
+
+/* common parameters: try to keep these consistent across architectures */
+#define MADV_REMOVE     9               /* remove these pages & resources */
+#define MADV_DONTFORK   10              /* don't inherit across fork */
+#define MADV_DOFORK     11              /* do inherit across fork */
+
+/* compatibility flags */
+#define MAP_FILE        0
+
+#endif /* __ASM_GENERIC_MMAN_COMMON_H */
diff --git a/include/asm-generic/mman.h b/include/asm-generic/mman.h
index 5e3dde2ee5ad..7cab4de2bca6 100644
--- a/include/asm-generic/mman.h
+++ b/include/asm-generic/mman.h
@@ -1,41 +1,18 @@
-#ifndef _ASM_GENERIC_MMAN_H
-#define _ASM_GENERIC_MMAN_H
+#ifndef __ASM_GENERIC_MMAN_H
+#define __ASM_GENERIC_MMAN_H
 
-/*
- Author: Michael S. Tsirkin <mst@mellanox.co.il>, Mellanox Technologies Ltd.
- Based on: asm-xxx/mman.h
-*/
+#include <asm-generic/mman-common.h>
 
-#define PROT_READ       0x1             /* page can be read */
-#define PROT_WRITE      0x2             /* page can be written */
-#define PROT_EXEC       0x4             /* page can be executed */
-#define PROT_SEM        0x8             /* page may be used for atomic ops */
-#define PROT_NONE       0x0             /* page can not be accessed */
-#define PROT_GROWSDOWN  0x01000000      /* mprotect flag: extend change to start of growsdown vma */
-#define PROT_GROWSUP    0x02000000      /* mprotect flag: extend change to end of growsup vma */
+#define MAP_GROWSDOWN   0x0100          /* stack-like segment */
+#define MAP_DENYWRITE   0x0800          /* ETXTBSY */
+#define MAP_EXECUTABLE  0x1000          /* mark it as an executable */
+#define MAP_LOCKED      0x2000          /* pages are locked */
+#define MAP_NORESERVE   0x4000          /* don't check for reservations */
+#define MAP_POPULATE    0x8000          /* populate (prefault) pagetables */
+#define MAP_NONBLOCK    0x10000         /* do not block on IO */
+#define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
 
-#define MAP_SHARED      0x01            /* Share changes */
-#define MAP_PRIVATE     0x02            /* Changes are private */
-#define MAP_TYPE        0x0f            /* Mask for type of mapping */
-#define MAP_FIXED       0x10            /* Interpret addr exactly */
-#define MAP_ANONYMOUS   0x20            /* don't use a file */
+#define MCL_CURRENT     1               /* lock all current mappings */
+#define MCL_FUTURE      2               /* lock all future mappings */
 
-#define MS_ASYNC        1               /* sync memory asynchronously */
-#define MS_INVALIDATE   2               /* invalidate the caches */
-#define MS_SYNC         4               /* synchronous memory sync */
-
-#define MADV_NORMAL     0               /* no further special treatment */
-#define MADV_RANDOM     1               /* expect random page references */
-#define MADV_SEQUENTIAL 2               /* expect sequential page references */
-#define MADV_WILLNEED   3               /* will need these pages */
-#define MADV_DONTNEED   4               /* don't need these pages */
-
-/* common parameters: try to keep these consistent across architectures */
-#define MADV_REMOVE     9               /* remove these pages & resources */
-#define MADV_DONTFORK   10              /* don't inherit across fork */
-#define MADV_DOFORK     11              /* do inherit across fork */
-
-/* compatibility flags */
-#define MAP_FILE        0
-
-#endif
+#endif /* __ASM_GENERIC_MMAN_H */
diff --git a/include/asm-generic/mmu.h b/include/asm-generic/mmu.h
new file mode 100644
index 000000000000..4f4aa56d6b52
--- /dev/null
+++ b/include/asm-generic/mmu.h
@@ -0,0 +1,15 @@
+#ifndef __ASM_GENERIC_MMU_H
+#define __ASM_GENERIC_MMU_H
+
+/*
+ * This is the mmu.h header for nommu implementations.
+ * Architectures with an MMU need something more complex.
+ */
+#ifndef __ASSEMBLY__
+typedef struct {
+        struct vm_list_struct   *vmlist;
+        unsigned long           end_brk;
+} mm_context_t;
+#endif
+
+#endif /* __ASM_GENERIC_MMU_H */
diff --git a/include/asm-generic/mmu_context.h b/include/asm-generic/mmu_context.h
new file mode 100644
index 000000000000..a7eec910ba6c
--- /dev/null
+++ b/include/asm-generic/mmu_context.h
@@ -0,0 +1,45 @@
+#ifndef __ASM_GENERIC_MMU_CONTEXT_H
+#define __ASM_GENERIC_MMU_CONTEXT_H
+
+/*
+ * Generic hooks for NOMMU architectures, which do not need to do
+ * anything special here.
+ */
+
+#include <asm-generic/mm_hooks.h>
+
+struct task_struct;
+struct mm_struct;
+
+static inline void enter_lazy_tlb(struct mm_struct *mm,
+                        struct task_struct *tsk)
+{
+}
+
+static inline int init_new_context(struct task_struct *tsk,
+                        struct mm_struct *mm)
+{
+        return 0;
+}
+
+static inline void destroy_context(struct mm_struct *mm)
+{
+}
+
+static inline void deactivate_mm(struct task_struct *task,
+                        struct mm_struct *mm)
+{
+}
+
+static inline void switch_mm(struct mm_struct *prev,
+                        struct mm_struct *next,
+                        struct task_struct *tsk)
+{
+}
+
+static inline void activate_mm(struct mm_struct *prev_mm,
+                               struct mm_struct *next_mm)
+{
+}
+
+#endif /* __ASM_GENERIC_MMU_CONTEXT_H */
diff --git a/include/asm-generic/module.h b/include/asm-generic/module.h
new file mode 100644
index 000000000000..ed5b44de4c91
--- /dev/null
+++ b/include/asm-generic/module.h
@@ -0,0 +1,22 @@
+#ifndef __ASM_GENERIC_MODULE_H
+#define __ASM_GENERIC_MODULE_H
+
+/*
+ * Many architectures just need a simple module
+ * loader without arch specific data.
+ */
+struct mod_arch_specific
+{
+};
+
+#ifdef CONFIG_64BIT
+#define Elf_Shdr Elf64_Shdr
+#define Elf_Sym Elf64_Sym
+#define Elf_Ehdr Elf64_Ehdr
+#else
+#define Elf_Shdr Elf32_Shdr
+#define Elf_Sym Elf32_Sym
+#define Elf_Ehdr Elf32_Ehdr
+#endif
+
+#endif /* __ASM_GENERIC_MODULE_H */
diff --git a/include/asm-generic/msgbuf.h b/include/asm-generic/msgbuf.h
new file mode 100644
index 000000000000..aec850d9159e
--- /dev/null
+++ b/include/asm-generic/msgbuf.h
@@ -0,0 +1,47 @@
+#ifndef __ASM_GENERIC_MSGBUF_H
+#define __ASM_GENERIC_MSGBUF_H
+
+#include <asm/bitsperlong.h>
+/*
+ * generic msqid64_ds structure.
+ *
+ * Note extra padding because this structure is passed back and forth
+ * between kernel and user space.
+ *
+ * msqid64_ds was originally meant to be architecture specific, but
+ * everyone just ended up making identical copies without specific
+ * optimizations, so we may just as well all use the same one.
+ *
+ * 64 bit architectures typically define a 64 bit __kernel_time_t,
+ * so they do not need the first three padding words.
+ * On big-endian systems, the padding is in the wrong place.
+ *
+ * Pad space is left for:
+ * - 64-bit time_t to solve y2038 problem
+ * - 2 miscellaneous 32-bit values
+ */
+
+struct msqid64_ds {
+        struct ipc64_perm msg_perm;
+        __kernel_time_t msg_stime;      /* last msgsnd time */
+#if __BITS_PER_LONG != 64
+        unsigned long   __unused1;
+#endif
+        __kernel_time_t msg_rtime;      /* last msgrcv time */
+#if __BITS_PER_LONG != 64
+        unsigned long   __unused2;
+#endif
+        __kernel_time_t msg_ctime;      /* last change time */
+#if __BITS_PER_LONG != 64
+        unsigned long   __unused3;
+#endif
+        unsigned long  msg_cbytes;      /* current number of bytes on queue */
+        unsigned long  msg_qnum;        /* number of messages in queue */
+        unsigned long  msg_qbytes;      /* max number of bytes on queue */
+        __kernel_pid_t msg_lspid;       /* pid of last msgsnd */
+        __kernel_pid_t msg_lrpid;       /* last receive pid */
+        unsigned long  __unused4;
+        unsigned long  __unused5;
+};
+
+#endif /* __ASM_GENERIC_MSGBUF_H */
diff --git a/include/asm-generic/mutex.h b/include/asm-generic/mutex.h
new file mode 100644
index 000000000000..fe91ab502793
--- /dev/null
+++ b/include/asm-generic/mutex.h
@@ -0,0 +1,9 @@
+#ifndef __ASM_GENERIC_MUTEX_H
+#define __ASM_GENERIC_MUTEX_H
+/*
+ * Pull in the generic implementation for the mutex fastpath,
+ * which is a reasonable default on many architectures.
+ */
+
+#include <asm-generic/mutex-dec.h>
+#endif /* __ASM_GENERIC_MUTEX_H */
diff --git a/include/asm-generic/page.h b/include/asm-generic/page.h
index 14db733b8e68..75fec18cdc59 100644
--- a/include/asm-generic/page.h
+++ b/include/asm-generic/page.h
@@ -1,24 +1,99 @@
-#ifndef _ASM_GENERIC_PAGE_H
-#define _ASM_GENERIC_PAGE_H
+#ifndef __ASM_GENERIC_PAGE_H
+#define __ASM_GENERIC_PAGE_H
+/*
+ * Generic page.h implementation, for NOMMU architectures.
+ * This provides the dummy definitions for the memory management.
+ */
+
+#ifdef CONFIG_MMU
+#error need to prove a real asm/page.h
+#endif
+
+
+/* PAGE_SHIFT determines the page size */
+
+#define PAGE_SHIFT      12
+#ifdef __ASSEMBLY__
+#define PAGE_SIZE       (1 << PAGE_SHIFT)
+#else
+#define PAGE_SIZE       (1UL << PAGE_SHIFT)
+#endif
+#define PAGE_MASK       (~(PAGE_SIZE-1))
+
+#include <asm/setup.h>
+
+#ifndef __ASSEMBLY__
+
+#define get_user_page(vaddr)            __get_free_page(GFP_KERNEL)
+#define free_user_page(page, addr)      free_page(addr)
+
+#define clear_page(page)        memset((page), 0, PAGE_SIZE)
+#define copy_page(to,from)      memcpy((to), (from), PAGE_SIZE)
+
+#define clear_user_page(page, vaddr, pg)        clear_page(page)
+#define copy_user_page(to, from, vaddr, pg)     copy_page(to, from)
+
+/*
+ * These are used to make use of C type-checking..
+ */
+typedef struct {
+        unsigned long pte;
+} pte_t;
+typedef struct {
+        unsigned long pmd[16];
+} pmd_t;
+typedef struct {
+        unsigned long pgd;
+} pgd_t;
+typedef struct {
+        unsigned long pgprot;
+} pgprot_t;
+typedef struct page *pgtable_t;
+
+#define pte_val(x)      ((x).pte)
+#define pmd_val(x)      ((&x)->pmd[0])
+#define pgd_val(x)      ((x).pgd)
+#define pgprot_val(x)   ((x).pgprot)
+
+#define __pte(x)        ((pte_t) { (x) } )
+#define __pmd(x)        ((pmd_t) { (x) } )
+#define __pgd(x)        ((pgd_t) { (x) } )
+#define __pgprot(x)     ((pgprot_t) { (x) } )
+
+extern unsigned long memory_start;
+extern unsigned long memory_end;
+
+#endif /* !__ASSEMBLY__ */
+
+#ifdef CONFIG_KERNEL_RAM_BASE_ADDRESS
+#define PAGE_OFFSET             (CONFIG_KERNEL_RAM_BASE_ADDRESS)
+#else
+#define PAGE_OFFSET             (0)
+#endif
 
 #ifndef __ASSEMBLY__
 
-#include <linux/compiler.h>
+#define __va(x) ((void *)((unsigned long)(x) + PAGE_OFFSET))
+#define __pa(x) ((unsigned long) (x) - PAGE_OFFSET)
+
+#define virt_to_pfn(kaddr)      (__pa(kaddr) >> PAGE_SHIFT)
+#define pfn_to_virt(pfn)        __va((pfn) << PAGE_SHIFT)
+
+#define virt_to_page(addr)      (mem_map + (((unsigned long)(addr)-PAGE_OFFSET) >> PAGE_SHIFT))
+#define page_to_virt(page)      ((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
+
+#ifndef page_to_phys
+#define page_to_phys(page)      ((dma_addr_t)page_to_pfn(page) << PAGE_SHIFT)
+#endif
+
+#define pfn_valid(pfn)          ((pfn) < max_mapnr)
 
-/* Pure 2^n version of get_order */
-static __inline__ __attribute_const__ int get_order(unsigned long size)
-{
-        int order;
+#define virt_addr_valid(kaddr)  (((void *)(kaddr) >= (void *)PAGE_OFFSET) && \
+                                ((void *)(kaddr) < (void *)memory_end))
 
-        size = (size - 1) >> (PAGE_SHIFT - 1);
-        order = -1;
-        do {
-                size >>= 1;
-                order++;
-        } while (size);
-        return order;
-}
+#endif /* __ASSEMBLY__ */
 
-#endif  /* __ASSEMBLY__ */
+#include <asm-generic/memory_model.h>
+#include <asm-generic/getorder.h>
 
-#endif  /* _ASM_GENERIC_PAGE_H */
+#endif /* __ASM_GENERIC_PAGE_H */
diff --git a/include/asm-generic/param.h b/include/asm-generic/param.h
new file mode 100644
index 000000000000..cdf8251bfb6c
--- /dev/null
+++ b/include/asm-generic/param.h
@@ -0,0 +1,24 @@
+#ifndef __ASM_GENERIC_PARAM_H
+#define __ASM_GENERIC_PARAM_H
+
+#ifdef __KERNEL__
+# define HZ             CONFIG_HZ       /* Internal kernel timer frequency */
+# define USER_HZ        100             /* some user interfaces are */
+# define CLOCKS_PER_SEC (USER_HZ)       /* in "ticks" like times() */
+#endif
+
+#ifndef HZ
+#define HZ 100
+#endif
+
+#ifndef EXEC_PAGESIZE
+#define EXEC_PAGESIZE   4096
+#endif
+
+#ifndef NOGROUP
+#define NOGROUP         (-1)
+#endif
+
+#define MAXHOSTNAMELEN  64      /* max length of hostname */
+
+#endif /* __ASM_GENERIC_PARAM_H */
diff --git a/include/asm-generic/parport.h b/include/asm-generic/parport.h
new file mode 100644
index 000000000000..40528cb977e8
--- /dev/null
+++ b/include/asm-generic/parport.h
@@ -0,0 +1,23 @@
+#ifndef __ASM_GENERIC_PARPORT_H
+#define __ASM_GENERIC_PARPORT_H
+
+/*
+ * An ISA bus may have i8255 parallel ports at well-known
+ * locations in the I/O space, which are scanned by
+ * parport_pc_find_isa_ports.
+ *
+ * Without ISA support, the driver will only attach
+ * to devices on the PCI bus.
+ */
+
+static int __devinit parport_pc_find_isa_ports(int autoirq, int autodma);
+static int __devinit parport_pc_find_nonpci_ports(int autoirq, int autodma)
+{
+#ifdef CONFIG_ISA
+        return parport_pc_find_isa_ports(autoirq, autodma);
+#else
+        return 0;
+#endif
+}
+
+#endif /* __ASM_GENERIC_PARPORT_H */
diff --git a/include/asm-generic/pci.h b/include/asm-generic/pci.h
index c36a77d3bf44..b4326b5466eb 100644
--- a/include/asm-generic/pci.h
+++ b/include/asm-generic/pci.h
@@ -30,19 +30,6 @@ pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
         res->end = region->end;
 }
 
-static inline struct resource *
-pcibios_select_root(struct pci_dev *pdev, struct resource *res)
-{
-        struct resource *root = NULL;
-
-        if (res->flags & IORESOURCE_IO)
-                root = &ioport_resource;
-        if (res->flags & IORESOURCE_MEM)
-                root = &iomem_resource;
-
-        return root;
-}
-
 #define pcibios_scan_all_fns(a, b)      0
 
 #ifndef HAVE_ARCH_PCI_GET_LEGACY_IDE_IRQ
@@ -52,4 +39,12 @@ static inline int pci_get_legacy_ide_irq(struct pci_dev *dev, int channel)
 }
 #endif /* HAVE_ARCH_PCI_GET_LEGACY_IDE_IRQ */
 
+/*
+ * By default, assume that no iommu is in use and that the PCI
+ * space is mapped to address physical 0.
+ */
+#ifndef PCI_DMA_BUS_IS_PHYS
+#define PCI_DMA_BUS_IS_PHYS     (1)
 #endif
+
+#endif /* _ASM_GENERIC_PCI_H */
diff --git a/include/asm-generic/percpu.h b/include/asm-generic/percpu.h
index d7d50d7ee51e..aa00800adacc 100644
--- a/include/asm-generic/percpu.h
+++ b/include/asm-generic/percpu.h
@@ -97,4 +97,8 @@ extern void setup_per_cpu_areas(void);
 #define PER_CPU_ATTRIBUTES
 #endif
 
+#ifndef PER_CPU_DEF_ATTRIBUTES
+#define PER_CPU_DEF_ATTRIBUTES
+#endif
+
 #endif /* _ASM_GENERIC_PERCPU_H_ */
diff --git a/include/asm-generic/pgalloc.h b/include/asm-generic/pgalloc.h
new file mode 100644
index 000000000000..9e429d08b1f8
--- /dev/null
+++ b/include/asm-generic/pgalloc.h
@@ -0,0 +1,12 @@
+#ifndef __ASM_GENERIC_PGALLOC_H
+#define __ASM_GENERIC_PGALLOC_H
+/*
+ * an empty file is enough for a nommu architecture
+ */
+#ifdef CONFIG_MMU
+#error need to implement an architecture specific asm/pgalloc.h
+#endif
+
+#define check_pgt_cache()          do { } while (0)
+
+#endif /* __ASM_GENERIC_PGALLOC_H */
diff --git a/include/asm-generic/pgtable-nopmd.h b/include/asm-generic/pgtable-nopmd.h
index a7cdc48e8b78..725612b793ce 100644
--- a/include/asm-generic/pgtable-nopmd.h
+++ b/include/asm-generic/pgtable-nopmd.h
@@ -59,7 +59,7 @@ static inline pmd_t * pmd_offset(pud_t * pud, unsigned long address)
 static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
 {
 }
-#define __pmd_free_tlb(tlb, x)                  do { } while (0)
+#define __pmd_free_tlb(tlb, x, a)               do { } while (0)
 
 #undef  pmd_addr_end
 #define pmd_addr_end(addr, end)                 (end)
diff --git a/include/asm-generic/pgtable-nopud.h b/include/asm-generic/pgtable-nopud.h
index 87cf449a6df3..810431d8351b 100644
--- a/include/asm-generic/pgtable-nopud.h
+++ b/include/asm-generic/pgtable-nopud.h
@@ -52,7 +52,7 @@ static inline pud_t * pud_offset(pgd_t * pgd, unsigned long address)
  */
 #define pud_alloc_one(mm, address)              NULL
 #define pud_free(mm, x)                         do { } while (0)
-#define __pud_free_tlb(tlb, x)                  do { } while (0)
+#define __pud_free_tlb(tlb, x, a)               do { } while (0)
 
 #undef  pud_addr_end
 #define pud_addr_end(addr, end)                 (end)
diff --git a/include/asm-generic/pgtable.h b/include/asm-generic/pgtable.h
index 8e6d0ca70aba..e2bd73e8f9c0 100644
--- a/include/asm-generic/pgtable.h
+++ b/include/asm-generic/pgtable.h
@@ -129,6 +129,10 @@ static inline void ptep_set_wrprotect(struct mm_struct *mm, unsigned long addres
 #define move_pte(pte, prot, old_addr, new_addr) (pte)
 #endif
 
+#ifndef pgprot_noncached
+#define pgprot_noncached(prot)  (prot)
+#endif
+
 #ifndef pgprot_writecombine
 #define pgprot_writecombine pgprot_noncached
 #endif
@@ -280,17 +284,18 @@ static inline void ptep_modify_prot_commit(struct mm_struct *mm,
 #endif
 
 /*
- * A facility to provide batching of the reload of page tables with the
- * actual context switch code for paravirtualized guests.  By convention,
- * only one of the lazy modes (CPU, MMU) should be active at any given
- * time, entry should never be nested, and entry and exits should always
- * be paired.  This is for sanity of maintaining and reasoning about the
- * kernel code.
+ * A facility to provide batching of the reload of page tables and
+ * other process state with the actual context switch code for
+ * paravirtualized guests.  By convention, only one of the batched
+ * update (lazy) modes (CPU, MMU) should be active at any given time,
+ * entry should never be nested, and entry and exits should always be
+ * paired.  This is for sanity of maintaining and reasoning about the
+ * kernel code.  In this case, the exit (end of the context switch) is
+ * in architecture-specific code, and so doesn't need a generic
+ * definition.
  */
-#ifndef __HAVE_ARCH_ENTER_LAZY_CPU_MODE
-#define arch_enter_lazy_cpu_mode()      do {} while (0)
-#define arch_leave_lazy_cpu_mode()      do {} while (0)
-#define arch_flush_lazy_cpu_mode()      do {} while (0)
+#ifndef __HAVE_ARCH_START_CONTEXT_SWITCH
+#define arch_start_context_switch(prev) do {} while (0)
 #endif
 
 #ifndef __HAVE_PFNMAP_TRACKING
diff --git a/include/asm-generic/posix_types.h b/include/asm-generic/posix_types.h
new file mode 100644
index 000000000000..3dab00860e71
--- /dev/null
+++ b/include/asm-generic/posix_types.h
@@ -0,0 +1,165 @@
+#ifndef __ASM_GENERIC_POSIX_TYPES_H
+#define __ASM_GENERIC_POSIX_TYPES_H
+
+#include <asm/bitsperlong.h>
+/*
+ * This file is generally used by user-level software, so you need to
+ * be a little careful about namespace pollution etc.
+ *
+ * First the types that are often defined in different ways across
+ * architectures, so that you can override them.
+ */
+
+#ifndef __kernel_ino_t
+typedef unsigned long   __kernel_ino_t;
+#endif
+
+#ifndef __kernel_mode_t
+typedef unsigned int    __kernel_mode_t;
+#endif
+
+#ifndef __kernel_nlink_t
+typedef unsigned long   __kernel_nlink_t;
+#endif
+
+#ifndef __kernel_pid_t
+typedef int             __kernel_pid_t;
+#endif
+
+#ifndef __kernel_ipc_pid_t
+typedef int             __kernel_ipc_pid_t;
+#endif
+
+#ifndef __kernel_uid_t
+typedef unsigned int    __kernel_uid_t;
+typedef unsigned int    __kernel_gid_t;
+#endif
+
+#ifndef __kernel_suseconds_t
+typedef long            __kernel_suseconds_t;
+#endif
+
+#ifndef __kernel_daddr_t
+typedef int             __kernel_daddr_t;
+#endif
+
+#ifndef __kernel_uid32_t
+typedef __kernel_uid_t  __kernel_uid32_t;
+typedef __kernel_gid_t  __kernel_gid32_t;
+#endif
+
+#ifndef __kernel_old_uid_t
+typedef __kernel_uid_t  __kernel_old_uid_t;
+typedef __kernel_gid_t  __kernel_old_gid_t;
+#endif
+
+#ifndef __kernel_old_dev_t
+typedef unsigned int    __kernel_old_dev_t;
+#endif
+
+/*
+ * Most 32 bit architectures use "unsigned int" size_t,
+ * and all 64 bit architectures use "unsigned long" size_t.
+ */
+#ifndef __kernel_size_t
+#if __BITS_PER_LONG != 64
+typedef unsigned int    __kernel_size_t;
+typedef int             __kernel_ssize_t;
+typedef int             __kernel_ptrdiff_t;
+#else
+typedef unsigned long   __kernel_size_t;
+typedef long            __kernel_ssize_t;
+typedef long            __kernel_ptrdiff_t;
+#endif
+#endif
+
+/*
+ * anything below here should be completely generic
+ */
+typedef long            __kernel_off_t;
+typedef long long       __kernel_loff_t;
+typedef long            __kernel_time_t;
+typedef long            __kernel_clock_t;
+typedef int             __kernel_timer_t;
+typedef int             __kernel_clockid_t;
+typedef char *          __kernel_caddr_t;
+typedef unsigned short  __kernel_uid16_t;
+typedef unsigned short  __kernel_gid16_t;
+
+typedef struct {
+        int     val[2];
+} __kernel_fsid_t;
+
+#ifdef __KERNEL__
+
+#undef __FD_SET
+static inline void __FD_SET(unsigned long __fd, __kernel_fd_set *__fdsetp)
+{
+        unsigned long __tmp = __fd / __NFDBITS;
+        unsigned long __rem = __fd % __NFDBITS;
+        __fdsetp->fds_bits[__tmp] |= (1UL<<__rem);
+}
+
+#undef __FD_CLR
+static inline void __FD_CLR(unsigned long __fd, __kernel_fd_set *__fdsetp)
+{
+        unsigned long __tmp = __fd / __NFDBITS;
+        unsigned long __rem = __fd % __NFDBITS;
+        __fdsetp->fds_bits[__tmp] &= ~(1UL<<__rem);
+}
+
+#undef __FD_ISSET
+static inline int __FD_ISSET(unsigned long __fd, const __kernel_fd_set *__p)
+{
+        unsigned long __tmp = __fd / __NFDBITS;
+        unsigned long __rem = __fd % __NFDBITS;
+        return (__p->fds_bits[__tmp] & (1UL<<__rem)) != 0;
+}
+
+/*
+ * This will unroll the loop for the normal constant case (8 ints,
+ * for a 256-bit fd_set)
+ */
+#undef __FD_ZERO
+static inline void __FD_ZERO(__kernel_fd_set *__p)
+{
+        unsigned long *__tmp = __p->fds_bits;
+        int __i;
+
+        if (__builtin_constant_p(__FDSET_LONGS)) {
+                switch (__FDSET_LONGS) {
+                case 16:
+                        __tmp[ 0] = 0; __tmp[ 1] = 0;
+                        __tmp[ 2] = 0; __tmp[ 3] = 0;
+                        __tmp[ 4] = 0; __tmp[ 5] = 0;
+                        __tmp[ 6] = 0; __tmp[ 7] = 0;
+                        __tmp[ 8] = 0; __tmp[ 9] = 0;
+                        __tmp[10] = 0; __tmp[11] = 0;
+                        __tmp[12] = 0; __tmp[13] = 0;
+                        __tmp[14] = 0; __tmp[15] = 0;
+                        return;
+
+                case 8:
+                        __tmp[ 0] = 0; __tmp[ 1] = 0;
+                        __tmp[ 2] = 0; __tmp[ 3] = 0;
+                        __tmp[ 4] = 0; __tmp[ 5] = 0;
+                        __tmp[ 6] = 0; __tmp[ 7] = 0;
+                        return;
+
+                case 4:
+                        __tmp[ 0] = 0; __tmp[ 1] = 0;
+                        __tmp[ 2] = 0; __tmp[ 3] = 0;
+                        return;
+                }
+        }
+        __i = __FDSET_LONGS;
+        while (__i) {
+                __i--;
+                *__tmp = 0;
+                __tmp++;
+        }
+}
+
+#endif /* __KERNEL__ */
+
+#endif /* __ASM_GENERIC_POSIX_TYPES_H */
diff --git a/include/asm-generic/rtc.h b/include/asm-generic/rtc.h
index 763e3b060f43..fa86f240c874 100644
--- a/include/asm-generic/rtc.h
+++ b/include/asm-generic/rtc.h
@@ -202,7 +202,7 @@ static inline unsigned int get_rtc_ss(void)
 {
         struct rtc_time h;
 
-        __get_rtc_time(&h);
+        get_rtc_time(&h);
         return h.tm_sec;
 }
 
diff --git a/include/asm-generic/scatterlist.h b/include/asm-generic/scatterlist.h
new file mode 100644
index 000000000000..8b9454496a7c
--- /dev/null
+++ b/include/asm-generic/scatterlist.h
@@ -0,0 +1,43 @@
+#ifndef __ASM_GENERIC_SCATTERLIST_H
+#define __ASM_GENERIC_SCATTERLIST_H
+
+#include <linux/types.h>
+
+struct scatterlist {
+#ifdef CONFIG_DEBUG_SG
+        unsigned long   sg_magic;
+#endif
+        unsigned long   page_link;
+        unsigned int    offset;
+        unsigned int    length;
+        dma_addr_t      dma_address;
+        unsigned int    dma_length;
+};
+
+/*
+ * These macros should be used after a dma_map_sg call has been done
+ * to get bus addresses of each of the SG entries and their lengths.
+ * You should only work with the number of sg entries pci_map_sg
+ * returns, or alternatively stop on the first sg_dma_len(sg) which
+ * is 0.
+ */
+#define sg_dma_address(sg)      ((sg)->dma_address)
+#ifndef sg_dma_len
+/*
+ * Normally, you have an iommu on 64 bit machines, but not on 32 bit
+ * machines. Architectures that are differnt should override this.
+ */
+#if __BITS_PER_LONG == 64
+#define sg_dma_len(sg)          ((sg)->dma_length)
+#else
+#define sg_dma_len(sg)          ((sg)->length)
+#endif /* 64 bit */
+#endif /* sg_dma_len */
+
+#ifndef ISA_DMA_THRESHOLD
+#define ISA_DMA_THRESHOLD       (~0UL)
+#endif
+
+#define ARCH_HAS_SG_CHAIN
+
+#endif /* __ASM_GENERIC_SCATTERLIST_H */
diff --git a/include/asm-generic/sections.h b/include/asm-generic/sections.h
index 4ce48e878530..d083561337f2 100644
--- a/include/asm-generic/sections.h
+++ b/include/asm-generic/sections.h
@@ -14,6 +14,9 @@ extern char __kprobes_text_start[], __kprobes_text_end[];
 extern char __initdata_begin[], __initdata_end[];
 extern char __start_rodata[], __end_rodata[];
 
+/* Start and end of .ctors section - used for constructor calls. */
+extern char __ctors_start[], __ctors_end[];
+
 /* function descriptor handling (if any).  Override
  * in asm/sections.h */
 #ifndef dereference_function_descriptor
diff --git a/include/asm-generic/segment.h b/include/asm-generic/segment.h
new file mode 100644
index 000000000000..5580eace622c
--- /dev/null
+++ b/include/asm-generic/segment.h
@@ -0,0 +1,9 @@
+#ifndef __ASM_GENERIC_SEGMENT_H
+#define __ASM_GENERIC_SEGMENT_H
+/*
+ * Only here because we have some old header files that expect it...
+ *
+ * New architectures probably don't want to have their own version.
+ */
+
+#endif /* __ASM_GENERIC_SEGMENT_H */
diff --git a/include/asm-generic/sembuf.h b/include/asm-generic/sembuf.h
new file mode 100644
index 000000000000..4cb2c13e5090
--- /dev/null
+++ b/include/asm-generic/sembuf.h
@@ -0,0 +1,38 @@
+#ifndef __ASM_GENERIC_SEMBUF_H
+#define __ASM_GENERIC_SEMBUF_H
+
+#include <asm/bitsperlong.h>
+
+/*
+ * The semid64_ds structure for x86 architecture.
+ * Note extra padding because this structure is passed back and forth
+ * between kernel and user space.
+ *
+ * semid64_ds was originally meant to be architecture specific, but
+ * everyone just ended up making identical copies without specific
+ * optimizations, so we may just as well all use the same one.
+ *
+ * 64 bit architectures typically define a 64 bit __kernel_time_t,
+ * so they do not need the first two padding words.
+ * On big-endian systems, the padding is in the wrong place.
+ *
+ * Pad space is left for:
+ * - 64-bit time_t to solve y2038 problem
+ * - 2 miscellaneous 32-bit values
+ */
+struct semid64_ds {
+        struct ipc64_perm sem_perm;     /* permissions .. see ipc.h */
+        __kernel_time_t sem_otime;      /* last semop time */
+#if __BITS_PER_LONG != 64
+        unsigned long   __unused1;
+#endif
+        __kernel_time_t sem_ctime;      /* last change time */
+#if __BITS_PER_LONG != 64
+        unsigned long   __unused2;
+#endif
+        unsigned long   sem_nsems;      /* no. of semaphores in array */
+        unsigned long   __unused3;
+        unsigned long   __unused4;
+};
+
+#endif /* __ASM_GENERIC_SEMBUF_H */
diff --git a/include/asm-generic/serial.h b/include/asm-generic/serial.h
new file mode 100644
index 000000000000..5e291090fe04
--- /dev/null
+++ b/include/asm-generic/serial.h
@@ -0,0 +1,13 @@
+#ifndef __ASM_GENERIC_SERIAL_H
+#define __ASM_GENERIC_SERIAL_H
+
+/*
+ * This should not be an architecture specific #define, oh well.
+ *
+ * Traditionally, it just describes i8250 and related serial ports
+ * that have this clock rate.
+ */
+
+#define BASE_BAUD (1843200 / 16)
+
+#endif /* __ASM_GENERIC_SERIAL_H */
diff --git a/include/asm-generic/setup.h b/include/asm-generic/setup.h
new file mode 100644
index 000000000000..6fc26a51003c
--- /dev/null
+++ b/include/asm-generic/setup.h
@@ -0,0 +1,6 @@
+#ifndef __ASM_GENERIC_SETUP_H
+#define __ASM_GENERIC_SETUP_H
+
+#define COMMAND_LINE_SIZE       512
+
+#endif  /* __ASM_GENERIC_SETUP_H */
diff --git a/include/asm-generic/shmbuf.h b/include/asm-generic/shmbuf.h
new file mode 100644
index 000000000000..5768fa60ac82
--- /dev/null
+++ b/include/asm-generic/shmbuf.h
@@ -0,0 +1,59 @@
+#ifndef __ASM_GENERIC_SHMBUF_H
+#define __ASM_GENERIC_SHMBUF_H
+
+#include <asm/bitsperlong.h>
+
+/*
+ * The shmid64_ds structure for x86 architecture.
+ * Note extra padding because this structure is passed back and forth
+ * between kernel and user space.
+ *
+ * shmid64_ds was originally meant to be architecture specific, but
+ * everyone just ended up making identical copies without specific
+ * optimizations, so we may just as well all use the same one.
+ *
+ * 64 bit architectures typically define a 64 bit __kernel_time_t,
+ * so they do not need the first two padding words.
+ * On big-endian systems, the padding is in the wrong place.
+ *
+ *
+ * Pad space is left for:
+ * - 64-bit time_t to solve y2038 problem
+ * - 2 miscellaneous 32-bit values
+ */
+
+struct shmid64_ds {
+        struct ipc64_perm       shm_perm;       /* operation perms */
+        size_t                  shm_segsz;      /* size of segment (bytes) */
+        __kernel_time_t         shm_atime;      /* last attach time */
+#if __BITS_PER_LONG != 64
+        unsigned long           __unused1;
+#endif
+        __kernel_time_t         shm_dtime;      /* last detach time */
+#if __BITS_PER_LONG != 64
+        unsigned long           __unused2;
+#endif
+        __kernel_time_t         shm_ctime;      /* last change time */
+#if __BITS_PER_LONG != 64
+        unsigned long           __unused3;
+#endif
+        __kernel_pid_t          shm_cpid;       /* pid of creator */
+        __kernel_pid_t          shm_lpid;       /* pid of last operator */
+        unsigned long           shm_nattch;     /* no. of current attaches */
+        unsigned long           __unused4;
+        unsigned long           __unused5;
+};
+
+struct shminfo64 {
+        unsigned long   shmmax;
+        unsigned long   shmmin;
+        unsigned long   shmmni;
+        unsigned long   shmseg;
+        unsigned long   shmall;
+        unsigned long   __unused1;
+        unsigned long   __unused2;
+        unsigned long   __unused3;
+        unsigned long   __unused4;
+};
+
+#endif /* __ASM_GENERIC_SHMBUF_H */
diff --git a/include/asm-generic/shmparam.h b/include/asm-generic/shmparam.h
new file mode 100644
index 000000000000..51a3852de733
--- /dev/null
+++ b/include/asm-generic/shmparam.h
@@ -0,0 +1,6 @@
+#ifndef __ASM_GENERIC_SHMPARAM_H
+#define __ASM_GENERIC_SHMPARAM_H
+
+#define SHMLBA PAGE_SIZE         /* attach addr a multiple of this */
+
+#endif /* _ASM_GENERIC_SHMPARAM_H */
diff --git a/include/asm-generic/signal-defs.h b/include/asm-generic/signal-defs.h
new file mode 100644
index 000000000000..00f95df54297
--- /dev/null
+++ b/include/asm-generic/signal-defs.h
@@ -0,0 +1,28 @@
+#ifndef __ASM_GENERIC_SIGNAL_DEFS_H
+#define __ASM_GENERIC_SIGNAL_DEFS_H
+
+#include <linux/compiler.h>
+
+#ifndef SIG_BLOCK
+#define SIG_BLOCK          0    /* for blocking signals */
+#endif
+#ifndef SIG_UNBLOCK
+#define SIG_UNBLOCK        1    /* for unblocking signals */
+#endif
+#ifndef SIG_SETMASK
+#define SIG_SETMASK        2    /* for setting the signal mask */
+#endif
+
+#ifndef __ASSEMBLY__
+typedef void __signalfn_t(int);
+typedef __signalfn_t __user *__sighandler_t;
+
+typedef void __restorefn_t(void);
+typedef __restorefn_t __user *__sigrestore_t;
+
+#define SIG_DFL ((__force __sighandler_t)0)     /* default signal handling */
+#define SIG_IGN ((__force __sighandler_t)1)     /* ignore signal */
+#define SIG_ERR ((__force __sighandler_t)-1)    /* error return from signal */
+#endif
+
+#endif /* __ASM_GENERIC_SIGNAL_DEFS_H */
diff --git a/include/asm-generic/signal.h b/include/asm-generic/signal.h
index dae1d8720076..555c0aee8a47 100644
--- a/include/asm-generic/signal.h
+++ b/include/asm-generic/signal.h
@@ -1,28 +1,131 @@
 #ifndef __ASM_GENERIC_SIGNAL_H
 #define __ASM_GENERIC_SIGNAL_H
 
-#include <linux/compiler.h>
+#include <linux/types.h>
 
-#ifndef SIG_BLOCK
-#define SIG_BLOCK          0    /* for blocking signals */
-#endif
-#ifndef SIG_UNBLOCK
-#define SIG_UNBLOCK        1    /* for unblocking signals */
-#endif
-#ifndef SIG_SETMASK
-#define SIG_SETMASK        2    /* for setting the signal mask */
+#define _NSIG           64
+#define _NSIG_BPW       __BITS_PER_LONG
+#define _NSIG_WORDS     (_NSIG / _NSIG_BPW)
+
+#define SIGHUP           1
+#define SIGINT           2
+#define SIGQUIT          3
+#define SIGILL           4
+#define SIGTRAP          5
+#define SIGABRT          6
+#define SIGIOT           6
+#define SIGBUS           7
+#define SIGFPE           8
+#define SIGKILL          9
+#define SIGUSR1         10
+#define SIGSEGV         11
+#define SIGUSR2         12
+#define SIGPIPE         13
+#define SIGALRM         14
+#define SIGTERM         15
+#define SIGSTKFLT       16
+#define SIGCHLD         17
+#define SIGCONT         18
+#define SIGSTOP         19
+#define SIGTSTP         20
+#define SIGTTIN         21
+#define SIGTTOU         22
+#define SIGURG          23
+#define SIGXCPU         24
+#define SIGXFSZ         25
+#define SIGVTALRM       26
+#define SIGPROF         27
+#define SIGWINCH        28
+#define SIGIO           29
+#define SIGPOLL         SIGIO
+/*
+#define SIGLOST         29
+*/
+#define SIGPWR          30
+#define SIGSYS          31
+#define SIGUNUSED       31
+
+/* These should not be considered constants from userland.  */
+#define SIGRTMIN        32
+#ifndef SIGRTMAX
+#define SIGRTMAX        _NSIG
 #endif
 
+/*
+ * SA_FLAGS values:
+ *
+ * SA_ONSTACK indicates that a registered stack_t will be used.
+ * SA_RESTART flag to get restarting signals (which were the default long ago)
+ * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
+ * SA_RESETHAND clears the handler when the signal is delivered.
+ * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
+ * SA_NODEFER prevents the current signal from being masked in the handler.
+ *
+ * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
+ * Unix names RESETHAND and NODEFER respectively.
+ */
+#define SA_NOCLDSTOP    0x00000001
+#define SA_NOCLDWAIT    0x00000002
+#define SA_SIGINFO      0x00000004
+#define SA_ONSTACK      0x08000000
+#define SA_RESTART      0x10000000
+#define SA_NODEFER      0x40000000
+#define SA_RESETHAND    0x80000000
+
+#define SA_NOMASK       SA_NODEFER
+#define SA_ONESHOT      SA_RESETHAND
+
+/*
+ * New architectures should not define the obsolete
+ *      SA_RESTORER     0x04000000
+ */
+
+/*
+ * sigaltstack controls
+ */
+#define SS_ONSTACK      1
+#define SS_DISABLE      2
+
+#define MINSIGSTKSZ     2048
+#define SIGSTKSZ        8192
+
 #ifndef __ASSEMBLY__
-typedef void __signalfn_t(int);
-typedef __signalfn_t __user *__sighandler_t;
+typedef struct {
+        unsigned long sig[_NSIG_WORDS];
+} sigset_t;
+
+/* not actually used, but required for linux/syscalls.h */
+typedef unsigned long old_sigset_t;
 
-typedef void __restorefn_t(void);
-typedef __restorefn_t __user *__sigrestore_t;
+#include <asm-generic/signal-defs.h>
 
-#define SIG_DFL ((__force __sighandler_t)0)     /* default signal handling */
-#define SIG_IGN ((__force __sighandler_t)1)     /* ignore signal */
-#define SIG_ERR ((__force __sighandler_t)-1)    /* error return from signal */
+struct sigaction {
+        __sighandler_t sa_handler;
+        unsigned long sa_flags;
+#ifdef SA_RESTORER
+        __sigrestore_t sa_restorer;
 #endif
+        sigset_t sa_mask;               /* mask last for extensibility */
+};
+
+struct k_sigaction {
+        struct sigaction sa;
+};
+
+typedef struct sigaltstack {
+        void __user *ss_sp;
+        int ss_flags;
+        size_t ss_size;
+} stack_t;
+
+#ifdef __KERNEL__
+
+#include <asm/sigcontext.h>
+#undef __HAVE_ARCH_SIG_BITOPS
+
+#define ptrace_signal_deliver(regs, cookie) do { } while (0)
+
+#endif /* __KERNEL__ */
+#endif /* __ASSEMBLY__ */
 
-#endif /* __ASM_GENERIC_SIGNAL_H */
+#endif /* _ASM_GENERIC_SIGNAL_H */
diff --git a/include/asm-generic/socket.h b/include/asm-generic/socket.h
new file mode 100644
index 000000000000..5d79e409241c
--- /dev/null
+++ b/include/asm-generic/socket.h
@@ -0,0 +1,63 @@
+#ifndef __ASM_GENERIC_SOCKET_H
+#define __ASM_GENERIC_SOCKET_H
+
+#include <asm/sockios.h>
+
+/* For setsockopt(2) */
+#define SOL_SOCKET      1
+
+#define SO_DEBUG        1
+#define SO_REUSEADDR    2
+#define SO_TYPE         3
+#define SO_ERROR        4
+#define SO_DONTROUTE    5
+#define SO_BROADCAST    6
+#define SO_SNDBUF       7
+#define SO_RCVBUF       8
+#define SO_SNDBUFFORCE  32
+#define SO_RCVBUFFORCE  33
+#define SO_KEEPALIVE    9
+#define SO_OOBINLINE    10
+#define SO_NO_CHECK     11
+#define SO_PRIORITY     12
+#define SO_LINGER       13
+#define SO_BSDCOMPAT    14
+/* To add :#define SO_REUSEPORT 15 */
+
+#ifndef SO_PASSCRED /* powerpc only differs in these */
+#define SO_PASSCRED     16
+#define SO_PEERCRED     17
+#define SO_RCVLOWAT     18
+#define SO_SNDLOWAT     19
+#define SO_RCVTIMEO     20
+#define SO_SNDTIMEO     21
+#endif
+
+/* Security levels - as per NRL IPv6 - don't actually do anything */
+#define SO_SECURITY_AUTHENTICATION              22
+#define SO_SECURITY_ENCRYPTION_TRANSPORT        23
+#define SO_SECURITY_ENCRYPTION_NETWORK          24
+
+#define SO_BINDTODEVICE 25
+
+/* Socket filtering */
+#define SO_ATTACH_FILTER        26
+#define SO_DETACH_FILTER        27
+
+#define SO_PEERNAME             28
+#define SO_TIMESTAMP            29
+#define SCM_TIMESTAMP           SO_TIMESTAMP
+
+#define SO_ACCEPTCONN           30
+
+#define SO_PEERSEC              31
+#define SO_PASSSEC              34
+#define SO_TIMESTAMPNS          35
+#define SCM_TIMESTAMPNS         SO_TIMESTAMPNS
+
+#define SO_MARK                 36
+
+#define SO_TIMESTAMPING         37
+#define SCM_TIMESTAMPING        SO_TIMESTAMPING
+
+#endif /* __ASM_GENERIC_SOCKET_H */
diff --git a/include/asm-generic/sockios.h b/include/asm-generic/sockios.h
new file mode 100644
index 000000000000..9a61a369b901
--- /dev/null
+++ b/include/asm-generic/sockios.h
@@ -0,0 +1,13 @@
+#ifndef __ASM_GENERIC_SOCKIOS_H
+#define __ASM_GENERIC_SOCKIOS_H
+
+/* Socket-level I/O control calls. */
+#define FIOSETOWN       0x8901
+#define SIOCSPGRP       0x8902
+#define FIOGETOWN       0x8903
+#define SIOCGPGRP       0x8904
+#define SIOCATMARK      0x8905
+#define SIOCGSTAMP      0x8906          /* Get stamp (timeval) */
+#define SIOCGSTAMPNS    0x8907          /* Get stamp (timespec) */
+
+#endif /* __ASM_GENERIC_SOCKIOS_H */
diff --git a/include/asm-generic/spinlock.h b/include/asm-generic/spinlock.h
new file mode 100644
index 000000000000..1547a03ac50f
--- /dev/null
+++ b/include/asm-generic/spinlock.h
@@ -0,0 +1,11 @@
+#ifndef __ASM_GENERIC_SPINLOCK_H
+#define __ASM_GENERIC_SPINLOCK_H
+/*
+ * You need to implement asm/spinlock.h for SMP support. The generic
+ * version does not handle SMP.
+ */
+#ifdef CONFIG_SMP
+#error need an architecture specific asm/spinlock.h
+#endif
+
+#endif /* __ASM_GENERIC_SPINLOCK_H */
diff --git a/include/asm-generic/stat.h b/include/asm-generic/stat.h
new file mode 100644
index 000000000000..47e64170305d
--- /dev/null
+++ b/include/asm-generic/stat.h
@@ -0,0 +1,72 @@
+#ifndef __ASM_GENERIC_STAT_H
+#define __ASM_GENERIC_STAT_H
+
+/*
+ * Everybody gets this wrong and has to stick with it for all
+ * eternity. Hopefully, this version gets used by new architectures
+ * so they don't fall into the same traps.
+ *
+ * stat64 is copied from powerpc64, with explicit padding added.
+ * stat is the same structure layout on 64-bit, without the 'long long'
+ * types.
+ *
+ * By convention, 64 bit architectures use the stat interface, while
+ * 32 bit architectures use the stat64 interface. Note that we don't
+ * provide an __old_kernel_stat here, which new architecture should
+ * not have to start with.
+ */
+
+#include <asm/bitsperlong.h>
+
+#define STAT_HAVE_NSEC 1
+
+struct stat {
+        unsigned long   st_dev;         /* Device.  */
+        unsigned long   st_ino;         /* File serial number.  */
+        unsigned int    st_mode;        /* File mode.  */
+        unsigned int    st_nlink;       /* Link count.  */
+        unsigned int    st_uid;         /* User ID of the file's owner.  */
+        unsigned int    st_gid;         /* Group ID of the file's group. */
+        unsigned long   st_rdev;        /* Device number, if device.  */
+        unsigned long   __pad1;
+        long            st_size;        /* Size of file, in bytes.  */
+        int             st_blksize;     /* Optimal block size for I/O.  */
+        int             __pad2;
+        long            st_blocks;      /* Number 512-byte blocks allocated. */
+        int             st_atime;       /* Time of last access.  */
+        unsigned int    st_atime_nsec;
+        int             st_mtime;       /* Time of last modification.  */
+        unsigned int    st_mtime_nsec;
+        int             st_ctime;       /* Time of last status change.  */
+        unsigned int    st_ctime_nsec;
+        unsigned int    __unused4;
+        unsigned int    __unused5;
+};
+
+#if __BITS_PER_LONG != 64
+/* This matches struct stat64 in glibc2.1. Only used for 32 bit. */
+struct stat64 {
+        unsigned long long st_dev;      /* Device.  */
+        unsigned long long st_ino;      /* File serial number.  */
+        unsigned int    st_mode;        /* File mode.  */
+        unsigned int    st_nlink;       /* Link count.  */
+        unsigned int    st_uid;         /* User ID of the file's owner.  */
+        unsigned int    st_gid;         /* Group ID of the file's group. */
+        unsigned long long st_rdev;     /* Device number, if device.  */
+        unsigned long long __pad1;
+        long long       st_size;        /* Size of file, in bytes.  */
+        int             st_blksize;     /* Optimal block size for I/O.  */
+        int             __pad2;
+        long long       st_blocks;      /* Number 512-byte blocks allocated. */
+        int             st_atime;       /* Time of last access.  */
+        unsigned int    st_atime_nsec;
+        int             st_mtime;       /* Time of last modification.  */
+        unsigned int    st_mtime_nsec;
+        int             st_ctime;       /* Time of last status change.  */
+        unsigned int    st_ctime_nsec;
+        unsigned int    __unused4;
+        unsigned int    __unused5;
+};
+#endif
+
+#endif /* __ASM_GENERIC_STAT_H */
diff --git a/include/asm-generic/string.h b/include/asm-generic/string.h
new file mode 100644
index 000000000000..de5e0201459f
--- /dev/null
+++ b/include/asm-generic/string.h
@@ -0,0 +1,10 @@
+#ifndef __ASM_GENERIC_STRING_H
+#define __ASM_GENERIC_STRING_H
+/*
+ * The kernel provides all required functions in lib/string.c
+ *
+ * Architectures probably want to provide at least their own optimized
+ * memcpy and memset functions though.
+ */
+
+#endif /* __ASM_GENERIC_STRING_H */
diff --git a/include/asm-generic/swab.h b/include/asm-generic/swab.h
new file mode 100644
index 000000000000..a8e9029d9eba
--- /dev/null
+++ b/include/asm-generic/swab.h
@@ -0,0 +1,18 @@
+#ifndef _ASM_GENERIC_SWAB_H
+#define _ASM_GENERIC_SWAB_H
+
+#include <asm/bitsperlong.h>
+
+/*
+ * 32 bit architectures typically (but not always) want to
+ * set __SWAB_64_THRU_32__. In user space, this is only
+ * valid if the compiler supports 64 bit data types.
+ */
+
+#if __BITS_PER_LONG == 32
+#if defined(__GNUC__) && !defined(__STRICT_ANSI__) || defined(__KERNEL__)
+#define __SWAB_64_THRU_32__
+#endif
+#endif
+
+#endif /* _ASM_GENERIC_SWAB_H */
diff --git a/include/asm-generic/syscalls.h b/include/asm-generic/syscalls.h
new file mode 100644
index 000000000000..df84e3b04555
--- /dev/null
+++ b/include/asm-generic/syscalls.h
@@ -0,0 +1,60 @@
+#ifndef __ASM_GENERIC_SYSCALLS_H
+#define __ASM_GENERIC_SYSCALLS_H
+
+#include <linux/compiler.h>
+#include <linux/linkage.h>
+
+/*
+ * Calling conventions for these system calls can differ, so
+ * it's possible to override them.
+ */
+#ifndef sys_clone
+asmlinkage long sys_clone(unsigned long clone_flags, unsigned long newsp,
+                        void __user *parent_tid, void __user *child_tid,
+                        struct pt_regs *regs);
+#endif
+
+#ifndef sys_fork
+asmlinkage long sys_fork(struct pt_regs *regs);
+#endif
+
+#ifndef sys_vfork
+asmlinkage long sys_vfork(struct pt_regs *regs);
+#endif
+
+#ifndef sys_execve
+asmlinkage long sys_execve(char __user *filename, char __user * __user *argv,
+                        char __user * __user *envp, struct pt_regs *regs);
+#endif
+
+#ifndef sys_mmap2
+asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
+                        unsigned long prot, unsigned long flags,
+                        unsigned long fd, unsigned long pgoff);
+#endif
+
+#ifndef sys_mmap
+asmlinkage long sys_mmap(unsigned long addr, unsigned long len,
+                        unsigned long prot, unsigned long flags,
+                        unsigned long fd, off_t pgoff);
+#endif
+
+#ifndef sys_sigaltstack
+asmlinkage long sys_sigaltstack(const stack_t __user *, stack_t __user *,
+                        struct pt_regs *);
+#endif
+
+#ifndef sys_rt_sigreturn
+asmlinkage long sys_rt_sigreturn(struct pt_regs *regs);
+#endif
+
+#ifndef sys_rt_sigsuspend
+asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize);
+#endif
+
+#ifndef sys_rt_sigaction
+asmlinkage long sys_rt_sigaction(int sig, const struct sigaction __user *act,
+                         struct sigaction __user *oact, size_t sigsetsize);
+#endif
+
+#endif /* __ASM_GENERIC_SYSCALLS_H */
diff --git a/include/asm-generic/system.h b/include/asm-generic/system.h
new file mode 100644
index 000000000000..efa403b5e121
--- /dev/null
+++ b/include/asm-generic/system.h
@@ -0,0 +1,161 @@
+/* Generic system definitions, based on MN10300 definitions.
+ *
+ * It should be possible to use these on really simple architectures,
+ * but it serves more as a starting point for new ports.
+ *
+ * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+#ifndef __ASM_GENERIC_SYSTEM_H
+#define __ASM_GENERIC_SYSTEM_H
+
+#ifdef __KERNEL__
+#ifndef __ASSEMBLY__
+
+#include <linux/types.h>
+#include <linux/irqflags.h>
+
+#include <asm/cmpxchg-local.h>
+
+struct task_struct;
+
+/* context switching is now performed out-of-line in switch_to.S */
+extern struct task_struct *__switch_to(struct task_struct *,
+                struct task_struct *);
+#define switch_to(prev, next, last)                                     \
+        do {                                                            \
+                ((last) = __switch_to((prev), (next)));                 \
+        } while (0)
+
+#define arch_align_stack(x) (x)
+
+#define nop() asm volatile ("nop")
+
+#endif /* !__ASSEMBLY__ */
+
+/*
+ * Force strict CPU ordering.
+ * And yes, this is required on UP too when we're talking
+ * to devices.
+ *
+ * This implementation only contains a compiler barrier.
+ */
+
+#define mb()    asm volatile ("": : :"memory")
+#define rmb()   mb()
+#define wmb()   asm volatile ("": : :"memory")
+
+#ifdef CONFIG_SMP
+#define smp_mb()        mb()
+#define smp_rmb()       rmb()
+#define smp_wmb()       wmb()
+#else
+#define smp_mb()        barrier()
+#define smp_rmb()       barrier()
+#define smp_wmb()       barrier()
+#endif
+
+#define set_mb(var, value)  do { var = value;  mb(); } while (0)
+#define set_wmb(var, value) do { var = value; wmb(); } while (0)
+
+#define read_barrier_depends()          do {} while (0)
+#define smp_read_barrier_depends()      do {} while (0)
+
+/*
+ * we make sure local_irq_enable() doesn't cause priority inversion
+ */
+#ifndef __ASSEMBLY__
+
+/* This function doesn't exist, so you'll get a linker error
+ *    if something tries to do an invalid xchg().  */
+extern void __xchg_called_with_bad_pointer(void);
+
+static inline
+unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
+{
+        unsigned long ret, flags;
+
+        switch (size) {
+        case 1:
+#ifdef __xchg_u8
+                return __xchg_u8(x, ptr);
+#else
+                local_irq_save(flags);
+                ret = *(volatile u8 *)ptr;
+                *(volatile u8 *)ptr = x;
+                local_irq_restore(flags);
+                return ret;
+#endif /* __xchg_u8 */
+
+        case 2:
+#ifdef __xchg_u16
+                return __xchg_u16(x, ptr);
+#else
+                local_irq_save(flags);
+                ret = *(volatile u16 *)ptr;
+                *(volatile u16 *)ptr = x;
+                local_irq_restore(flags);
+                return ret;
+#endif /* __xchg_u16 */
+
+        case 4:
+#ifdef __xchg_u32
+                return __xchg_u32(x, ptr);
+#else
+                local_irq_save(flags);
+                ret = *(volatile u32 *)ptr;
+                *(volatile u32 *)ptr = x;
+                local_irq_restore(flags);
+                return ret;
+#endif /* __xchg_u32 */
+
+#ifdef CONFIG_64BIT
+        case 8:
+#ifdef __xchg_u64
+                return __xchg_u64(x, ptr);
+#else
+                local_irq_save(flags);
+                ret = *(volatile u64 *)ptr;
+                *(volatile u64 *)ptr = x;
+                local_irq_restore(flags);
+                return ret;
+#endif /* __xchg_u64 */
+#endif /* CONFIG_64BIT */
+
+        default:
+                __xchg_called_with_bad_pointer();
+                return x;
+        }
+}
+
+#define xchg(ptr, x) \
+        ((__typeof__(*(ptr))) __xchg((unsigned long)(x), (ptr), sizeof(*(ptr))))
+
+static inline unsigned long __cmpxchg(volatile unsigned long *m,
+                                      unsigned long old, unsigned long new)
+{
+        unsigned long retval;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        retval = *m;
+        if (retval == old)
+                *m = new;
+        local_irq_restore(flags);
+        return retval;
+}
+
+#define cmpxchg(ptr, o, n)                                      \
+        ((__typeof__(*(ptr))) __cmpxchg((unsigned long *)(ptr), \
+                                        (unsigned long)(o),     \
+                                        (unsigned long)(n)))
+
+#endif /* !__ASSEMBLY__ */
+
+#endif /* __KERNEL__ */
+#endif /* __ASM_GENERIC_SYSTEM_H */
diff --git a/include/asm-generic/termbits.h b/include/asm-generic/termbits.h
new file mode 100644
index 000000000000..1c9773d48cb0
--- /dev/null
+++ b/include/asm-generic/termbits.h
@@ -0,0 +1,198 @@
+#ifndef __ASM_GENERIC_TERMBITS_H
+#define __ASM_GENERIC_TERMBITS_H
+
+#include <linux/posix_types.h>
+
+typedef unsigned char   cc_t;
+typedef unsigned int    speed_t;
+typedef unsigned int    tcflag_t;
+
+#define NCCS 19
+struct termios {
+        tcflag_t c_iflag;               /* input mode flags */
+        tcflag_t c_oflag;               /* output mode flags */
+        tcflag_t c_cflag;               /* control mode flags */
+        tcflag_t c_lflag;               /* local mode flags */
+        cc_t c_line;                    /* line discipline */
+        cc_t c_cc[NCCS];                /* control characters */
+};
+
+struct termios2 {
+        tcflag_t c_iflag;               /* input mode flags */
+        tcflag_t c_oflag;               /* output mode flags */
+        tcflag_t c_cflag;               /* control mode flags */
+        tcflag_t c_lflag;               /* local mode flags */
+        cc_t c_line;                    /* line discipline */
+        cc_t c_cc[NCCS];                /* control characters */
+        speed_t c_ispeed;               /* input speed */
+        speed_t c_ospeed;               /* output speed */
+};
+
+struct ktermios {
+        tcflag_t c_iflag;               /* input mode flags */
+        tcflag_t c_oflag;               /* output mode flags */
+        tcflag_t c_cflag;               /* control mode flags */
+        tcflag_t c_lflag;               /* local mode flags */
+        cc_t c_line;                    /* line discipline */
+        cc_t c_cc[NCCS];                /* control characters */
+        speed_t c_ispeed;               /* input speed */
+        speed_t c_ospeed;               /* output speed */
+};
+
+/* c_cc characters */
+#define VINTR 0
+#define VQUIT 1
+#define VERASE 2
+#define VKILL 3
+#define VEOF 4
+#define VTIME 5
+#define VMIN 6
+#define VSWTC 7
+#define VSTART 8
+#define VSTOP 9
+#define VSUSP 10
+#define VEOL 11
+#define VREPRINT 12
+#define VDISCARD 13
+#define VWERASE 14
+#define VLNEXT 15
+#define VEOL2 16
+
+/* c_iflag bits */
+#define IGNBRK  0000001
+#define BRKINT  0000002
+#define IGNPAR  0000004
+#define PARMRK  0000010
+#define INPCK   0000020
+#define ISTRIP  0000040
+#define INLCR   0000100
+#define IGNCR   0000200
+#define ICRNL   0000400
+#define IUCLC   0001000
+#define IXON    0002000
+#define IXANY   0004000
+#define IXOFF   0010000
+#define IMAXBEL 0020000
+#define IUTF8   0040000
+
+/* c_oflag bits */
+#define OPOST   0000001
+#define OLCUC   0000002
+#define ONLCR   0000004
+#define OCRNL   0000010
+#define ONOCR   0000020
+#define ONLRET  0000040
+#define OFILL   0000100
+#define OFDEL   0000200
+#define NLDLY   0000400
+#define   NL0   0000000
+#define   NL1   0000400
+#define CRDLY   0003000
+#define   CR0   0000000
+#define   CR1   0001000
+#define   CR2   0002000
+#define   CR3   0003000
+#define TABDLY  0014000
+#define   TAB0  0000000
+#define   TAB1  0004000
+#define   TAB2  0010000
+#define   TAB3  0014000
+#define   XTABS 0014000
+#define BSDLY   0020000
+#define   BS0   0000000
+#define   BS1   0020000
+#define VTDLY   0040000
+#define   VT0   0000000
+#define   VT1   0040000
+#define FFDLY   0100000
+#define   FF0   0000000
+#define   FF1   0100000
+
+/* c_cflag bit meaning */
+#define CBAUD   0010017
+#define  B0     0000000         /* hang up */
+#define  B50    0000001
+#define  B75    0000002
+#define  B110   0000003
+#define  B134   0000004
+#define  B150   0000005
+#define  B200   0000006
+#define  B300   0000007
+#define  B600   0000010
+#define  B1200  0000011
+#define  B1800  0000012
+#define  B2400  0000013
+#define  B4800  0000014
+#define  B9600  0000015
+#define  B19200 0000016
+#define  B38400 0000017
+#define EXTA B19200
+#define EXTB B38400
+#define CSIZE   0000060
+#define   CS5   0000000
+#define   CS6   0000020
+#define   CS7   0000040
+#define   CS8   0000060
+#define CSTOPB  0000100
+#define CREAD   0000200
+#define PARENB  0000400
+#define PARODD  0001000
+#define HUPCL   0002000
+#define CLOCAL  0004000
+#define CBAUDEX 0010000
+#define    BOTHER 0010000
+#define    B57600 0010001
+#define   B115200 0010002
+#define   B230400 0010003
+#define   B460800 0010004
+#define   B500000 0010005
+#define   B576000 0010006
+#define   B921600 0010007
+#define  B1000000 0010010
+#define  B1152000 0010011
+#define  B1500000 0010012
+#define  B2000000 0010013
+#define  B2500000 0010014
+#define  B3000000 0010015
+#define  B3500000 0010016
+#define  B4000000 0010017
+#define CIBAUD    002003600000  /* input baud rate */
+#define CMSPAR    010000000000  /* mark or space (stick) parity */
+#define CRTSCTS   020000000000  /* flow control */
+
+#define IBSHIFT   16            /* Shift from CBAUD to CIBAUD */
+
+/* c_lflag bits */
+#define ISIG    0000001
+#define ICANON  0000002
+#define XCASE   0000004
+#define ECHO    0000010
+#define ECHOE   0000020
+#define ECHOK   0000040
+#define ECHONL  0000100
+#define NOFLSH  0000200
+#define TOSTOP  0000400
+#define ECHOCTL 0001000
+#define ECHOPRT 0002000
+#define ECHOKE  0004000
+#define FLUSHO  0010000
+#define PENDIN  0040000
+#define IEXTEN  0100000
+
+/* tcflow() and TCXONC use these */
+#define TCOOFF          0
+#define TCOON           1
+#define TCIOFF          2
+#define TCION           3
+
+/* tcflush() and TCFLSH use these */
+#define TCIFLUSH        0
+#define TCOFLUSH        1
+#define TCIOFLUSH       2
+
+/* tcsetattr uses these */
+#define TCSANOW         0
+#define TCSADRAIN       1
+#define TCSAFLUSH       2
+
+#endif /* __ASM_GENERIC_TERMBITS_H */
diff --git a/include/asm-generic/termios-base.h b/include/asm-generic/termios-base.h
new file mode 100644
index 000000000000..0a769feb22b0
--- /dev/null
+++ b/include/asm-generic/termios-base.h
@@ -0,0 +1,77 @@
+/* termios.h: generic termios/termio user copying/translation
+ */
+
+#ifndef _ASM_GENERIC_TERMIOS_BASE_H
+#define _ASM_GENERIC_TERMIOS_BASE_H
+
+#include <asm/uaccess.h>
+
+#ifndef __ARCH_TERMIO_GETPUT
+
+/*
+ * Translate a "termio" structure into a "termios". Ugh.
+ */
+static inline int user_termio_to_kernel_termios(struct ktermios *termios,
+                                                struct termio __user *termio)
+{
+        unsigned short tmp;
+
+        if (get_user(tmp, &termio->c_iflag) < 0)
+                goto fault;
+        termios->c_iflag = (0xffff0000 & termios->c_iflag) | tmp;
+
+        if (get_user(tmp, &termio->c_oflag) < 0)
+                goto fault;
+        termios->c_oflag = (0xffff0000 & termios->c_oflag) | tmp;
+
+        if (get_user(tmp, &termio->c_cflag) < 0)
+                goto fault;
+        termios->c_cflag = (0xffff0000 & termios->c_cflag) | tmp;
+
+        if (get_user(tmp, &termio->c_lflag) < 0)
+                goto fault;
+        termios->c_lflag = (0xffff0000 & termios->c_lflag) | tmp;
+
+        if (get_user(termios->c_line, &termio->c_line) < 0)
+                goto fault;
+
+        if (copy_from_user(termios->c_cc, termio->c_cc, NCC) != 0)
+                goto fault;
+
+        return 0;
+
+ fault:
+        return -EFAULT;
+}
+
+/*
+ * Translate a "termios" structure into a "termio". Ugh.
+ */
+static inline int kernel_termios_to_user_termio(struct termio __user *termio,
+                                                struct ktermios *termios)
+{
+        if (put_user(termios->c_iflag, &termio->c_iflag) < 0 ||
+            put_user(termios->c_oflag, &termio->c_oflag) < 0 ||
+            put_user(termios->c_cflag, &termio->c_cflag) < 0 ||
+            put_user(termios->c_lflag, &termio->c_lflag) < 0 ||
+            put_user(termios->c_line,  &termio->c_line) < 0 ||
+            copy_to_user(termio->c_cc, termios->c_cc, NCC) != 0)
+                return -EFAULT;
+
+        return 0;
+}
+
+#ifndef user_termios_to_kernel_termios
+#define user_termios_to_kernel_termios(k, u) copy_from_user(k, u, sizeof(struct termios))
+#endif
+
+#ifndef kernel_termios_to_user_termios
+#define kernel_termios_to_user_termios(u, k) copy_to_user(u, k, sizeof(struct termios))
+#endif
+
+#define user_termios_to_kernel_termios_1(k, u) copy_from_user(k, u, sizeof(struct termios))
+#define kernel_termios_to_user_termios_1(u, k) copy_to_user(u, k, sizeof(struct termios))
+
+#endif  /* __ARCH_TERMIO_GETPUT */
+
+#endif /* _ASM_GENERIC_TERMIOS_BASE_H */
diff --git a/include/asm-generic/termios.h b/include/asm-generic/termios.h
index 7d39ecc92d94..d0922adc56d4 100644
--- a/include/asm-generic/termios.h
+++ b/include/asm-generic/termios.h
@@ -1,18 +1,68 @@
-/* termios.h: generic termios/termio user copying/translation
- */
-
 #ifndef _ASM_GENERIC_TERMIOS_H
 #define _ASM_GENERIC_TERMIOS_H
+/*
+ * Most architectures have straight copies of the x86 code, with
+ * varying levels of bug fixes on top. Usually it's a good idea
+ * to use this generic version instead, but be careful to avoid
+ * ABI changes.
+ * New architectures should not provide their own version.
+ */
+
+#include <asm/termbits.h>
+#include <asm/ioctls.h>
+
+struct winsize {
+        unsigned short ws_row;
+        unsigned short ws_col;
+        unsigned short ws_xpixel;
+        unsigned short ws_ypixel;
+};
+
+#define NCC 8
+struct termio {
+        unsigned short c_iflag;         /* input mode flags */
+        unsigned short c_oflag;         /* output mode flags */
+        unsigned short c_cflag;         /* control mode flags */
+        unsigned short c_lflag;         /* local mode flags */
+        unsigned char c_line;           /* line discipline */
+        unsigned char c_cc[NCC];        /* control characters */
+};
+
+/* modem lines */
+#define TIOCM_LE        0x001
+#define TIOCM_DTR       0x002
+#define TIOCM_RTS       0x004
+#define TIOCM_ST        0x008
+#define TIOCM_SR        0x010
+#define TIOCM_CTS       0x020
+#define TIOCM_CAR       0x040
+#define TIOCM_RNG       0x080
+#define TIOCM_DSR       0x100
+#define TIOCM_CD        TIOCM_CAR
+#define TIOCM_RI        TIOCM_RNG
+#define TIOCM_OUT1      0x2000
+#define TIOCM_OUT2      0x4000
+#define TIOCM_LOOP      0x8000
+
+/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
+
+#ifdef __KERNEL__
 
 #include <asm/uaccess.h>
 
-#ifndef __ARCH_TERMIO_GETPUT
+/*      intr=^C         quit=^\         erase=del       kill=^U
+        eof=^D          vtime=\0        vmin=\1         sxtc=\0
+        start=^Q        stop=^S         susp=^Z         eol=\0
+        reprint=^R      discard=^U      werase=^W       lnext=^V
+        eol2=\0
+*/
+#define INIT_C_CC "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0"
 
 /*
  * Translate a "termio" structure into a "termios". Ugh.
  */
 static inline int user_termio_to_kernel_termios(struct ktermios *termios,
-                                                struct termio __user *termio)
+                                                const struct termio __user *termio)
 {
         unsigned short tmp;
 
@@ -61,17 +111,44 @@ static inline int kernel_termios_to_user_termio(struct termio __user *termio,
         return 0;
 }
 
-#ifndef user_termios_to_kernel_termios
-#define user_termios_to_kernel_termios(k, u) copy_from_user(k, u, sizeof(struct termios))
-#endif
+#ifdef TCGETS2
+static inline int user_termios_to_kernel_termios(struct ktermios *k,
+                                                 struct termios2 __user *u)
+{
+        return copy_from_user(k, u, sizeof(struct termios2));
+}
 
-#ifndef kernel_termios_to_user_termios
-#define kernel_termios_to_user_termios(u, k) copy_to_user(u, k, sizeof(struct termios))
-#endif
+static inline int kernel_termios_to_user_termios(struct termios2 __user *u,
+                                                 struct ktermios *k)
+{
+        return copy_to_user(u, k, sizeof(struct termios2));
+}
 
-#define user_termios_to_kernel_termios_1(k, u) copy_from_user(k, u, sizeof(struct termios))
-#define kernel_termios_to_user_termios_1(u, k) copy_to_user(u, k, sizeof(struct termios))
+static inline int user_termios_to_kernel_termios_1(struct ktermios *k,
+                                                   struct termios __user *u)
+{
+        return copy_from_user(k, u, sizeof(struct termios));
+}
+
+static inline int kernel_termios_to_user_termios_1(struct termios __user *u,
+                                                   struct ktermios *k)
+{
+        return copy_to_user(u, k, sizeof(struct termios));
+}
+#else /* TCGETS2 */
+static inline int user_termios_to_kernel_termios(struct ktermios *k,
+                                                 struct termios __user *u)
+{
+        return copy_from_user(k, u, sizeof(struct termios));
+}
+
+static inline int kernel_termios_to_user_termios(struct termios __user *u,
+                                                 struct ktermios *k)
+{
+        return copy_to_user(u, k, sizeof(struct termios));
+}
+#endif /* TCGETS2 */
 
-#endif  /* __ARCH_TERMIO_GETPUT */
+#endif  /* __KERNEL__ */
 
 #endif /* _ASM_GENERIC_TERMIOS_H */
diff --git a/include/asm-generic/timex.h b/include/asm-generic/timex.h
new file mode 100644
index 000000000000..b2243cb8d6f6
--- /dev/null
+++ b/include/asm-generic/timex.h
@@ -0,0 +1,22 @@
+#ifndef __ASM_GENERIC_TIMEX_H
+#define __ASM_GENERIC_TIMEX_H
+
+/*
+ * If you have a cycle counter, return the value here.
+ */
+typedef unsigned long cycles_t;
+#ifndef get_cycles
+static inline cycles_t get_cycles(void)
+{
+        return 0;
+}
+#endif
+
+/*
+ * Architectures are encouraged to implement read_current_timer
+ * and define this in order to avoid the expensive delay loop
+ * calibration during boot.
+ */
+#undef ARCH_HAS_READ_CURRENT_TIMER
+
+#endif /* __ASM_GENERIC_TIMEX_H */
diff --git a/include/asm-generic/tlb.h b/include/asm-generic/tlb.h
index f490e43a90b9..e43f9766259f 100644
--- a/include/asm-generic/tlb.h
+++ b/include/asm-generic/tlb.h
@@ -123,24 +123,24 @@ static inline void tlb_remove_page(struct mmu_gather *tlb, struct page *page)
                 __tlb_remove_tlb_entry(tlb, ptep, address);     \
         } while (0)
 
-#define pte_free_tlb(tlb, ptep)                                 \
+#define pte_free_tlb(tlb, ptep, address)                        \
         do {                                                    \
                 tlb->need_flush = 1;                            \
-                __pte_free_tlb(tlb, ptep);                      \
+                __pte_free_tlb(tlb, ptep, address);             \
         } while (0)
 
 #ifndef __ARCH_HAS_4LEVEL_HACK
-#define pud_free_tlb(tlb, pudp)                                 \
+#define pud_free_tlb(tlb, pudp, address)                        \
         do {                                                    \
                 tlb->need_flush = 1;                            \
-                __pud_free_tlb(tlb, pudp);                      \
+                __pud_free_tlb(tlb, pudp, address);             \
         } while (0)
 #endif
 
-#define pmd_free_tlb(tlb, pmdp)                                 \
+#define pmd_free_tlb(tlb, pmdp, address)                        \
         do {                                                    \
                 tlb->need_flush = 1;                            \
-                __pmd_free_tlb(tlb, pmdp);                      \
+                __pmd_free_tlb(tlb, pmdp, address);             \
         } while (0)
 
 #define tlb_migrate_finish(mm) do {} while (0)
diff --git a/include/asm-generic/tlbflush.h b/include/asm-generic/tlbflush.h
new file mode 100644
index 000000000000..c7af037024c7
--- /dev/null
+++ b/include/asm-generic/tlbflush.h
@@ -0,0 +1,18 @@
+#ifndef __ASM_GENERIC_TLBFLUSH_H
+#define __ASM_GENERIC_TLBFLUSH_H
+/*
+ * This is a dummy tlbflush implementation that can be used on all
+ * nommu architectures.
+ * If you have an MMU, you need to write your own functions.
+ */
+#ifdef CONFIG_MMU
+#error need to implement an architecture specific asm/tlbflush.h
+#endif
+
+static inline void flush_tlb_mm(struct mm_struct *mm)
+{
+        BUG();
+}
+
+
+#endif /* __ASM_GENERIC_TLBFLUSH_H */
diff --git a/include/asm-generic/types.h b/include/asm-generic/types.h
new file mode 100644
index 000000000000..fba7d33ca3f2
--- /dev/null
+++ b/include/asm-generic/types.h
@@ -0,0 +1,42 @@
+#ifndef _ASM_GENERIC_TYPES_H
+#define _ASM_GENERIC_TYPES_H
+/*
+ * int-ll64 is used practically everywhere now,
+ * so use it as a reasonable default.
+ */
+#include <asm-generic/int-ll64.h>
+
+#ifndef __ASSEMBLY__
+
+typedef unsigned short umode_t;
+
+#endif /* __ASSEMBLY__ */
+
+/*
+ * These aren't exported outside the kernel to avoid name space clashes
+ */
+#ifdef __KERNEL__
+#ifndef __ASSEMBLY__
+/*
+ * DMA addresses may be very different from physical addresses
+ * and pointers. i386 and powerpc may have 64 bit DMA on 32 bit
+ * systems, while sparc64 uses 32 bit DMA addresses for 64 bit
+ * physical addresses.
+ * This default defines dma_addr_t to have the same size as
+ * phys_addr_t, which is the most common way.
+ * Do not define the dma64_addr_t type, which never really
+ * worked.
+ */
+#ifndef dma_addr_t
+#ifdef CONFIG_PHYS_ADDR_T_64BIT
+typedef u64 dma_addr_t;
+#else
+typedef u32 dma_addr_t;
+#endif /* CONFIG_PHYS_ADDR_T_64BIT */
+#endif /* dma_addr_t */
+
+#endif /* __ASSEMBLY__ */
+
+#endif /* __KERNEL__ */
+
+#endif /* _ASM_GENERIC_TYPES_H */
diff --git a/include/asm-generic/uaccess-unaligned.h b/include/asm-generic/uaccess-unaligned.h
new file mode 100644
index 000000000000..67deb898f0c5
--- /dev/null
+++ b/include/asm-generic/uaccess-unaligned.h
@@ -0,0 +1,26 @@
+#ifndef __ASM_GENERIC_UACCESS_UNALIGNED_H
+#define __ASM_GENERIC_UACCESS_UNALIGNED_H
+
+/*
+ * This macro should be used instead of __get_user() when accessing
+ * values at locations that are not known to be aligned.
+ */
+#define __get_user_unaligned(x, ptr)                                    \
+({                                                                      \
+        __typeof__ (*(ptr)) __x;                                        \
+        __copy_from_user(&__x, (ptr), sizeof(*(ptr))) ? -EFAULT : 0;    \
+        (x) = __x;                                                      \
+})
+
+
+/*
+ * This macro should be used instead of __put_user() when accessing
+ * values at locations that are not known to be aligned.
+ */
+#define __put_user_unaligned(x, ptr)                                    \
+({                                                                      \
+        __typeof__ (*(ptr)) __x = (x);                                  \
+        __copy_to_user((ptr), &__x, sizeof(*(ptr))) ? -EFAULT : 0;      \
+})
+
+#endif /* __ASM_GENERIC_UACCESS_UNALIGNED_H */
diff --git a/include/asm-generic/uaccess.h b/include/asm-generic/uaccess.h
index 549cb3a1640a..b218b8513d04 100644
--- a/include/asm-generic/uaccess.h
+++ b/include/asm-generic/uaccess.h
@@ -1,26 +1,327 @@
-#ifndef _ASM_GENERIC_UACCESS_H_
-#define _ASM_GENERIC_UACCESS_H_
+#ifndef __ASM_GENERIC_UACCESS_H
+#define __ASM_GENERIC_UACCESS_H
 
 /*
- * This macro should be used instead of __get_user() when accessing
- * values at locations that are not known to be aligned.
+ * User space memory access functions, these should work
+ * on a ny machine that has kernel and user data in the same
+ * address space, e.g. all NOMMU machines.
  */
-#define __get_user_unaligned(x, ptr)                                    \
-({                                                                      \
-        __typeof__ (*(ptr)) __x;                                        \
-        __copy_from_user(&__x, (ptr), sizeof(*(ptr))) ? -EFAULT : 0;    \
-        (x) = __x;                                                      \
-})
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+
+#include <asm/segment.h>
+
+#define MAKE_MM_SEG(s)  ((mm_segment_t) { (s) })
+
+#ifndef KERNEL_DS
+#define KERNEL_DS       MAKE_MM_SEG(~0UL)
+#endif
+
+#ifndef USER_DS
+#define USER_DS         MAKE_MM_SEG(TASK_SIZE - 1)
+#endif
+
+#ifndef get_fs
+#define get_ds()        (KERNEL_DS)
+#define get_fs()        (current_thread_info()->addr_limit)
+
+static inline void set_fs(mm_segment_t fs)
+{
+        current_thread_info()->addr_limit = fs;
+}
+#endif
 
+#define segment_eq(a, b) ((a).seg == (b).seg)
+
+#define VERIFY_READ     0
+#define VERIFY_WRITE    1
+
+#define access_ok(type, addr, size) __access_ok((unsigned long)(addr),(size))
+
+/*
+ * The architecture should really override this if possible, at least
+ * doing a check on the get_fs()
+ */
+#ifndef __access_ok
+static inline int __access_ok(unsigned long addr, unsigned long size)
+{
+        return 1;
+}
+#endif
 
 /*
- * This macro should be used instead of __put_user() when accessing
- * values at locations that are not known to be aligned.
+ * The exception table consists of pairs of addresses: the first is the
+ * address of an instruction that is allowed to fault, and the second is
+ * the address at which the program should continue.  No registers are
+ * modified, so it is entirely up to the continuation code to figure out
+ * what to do.
+ *
+ * All the routines below use bits of fixup code that are out of line
+ * with the main instruction path.  This means when everything is well,
+ * we don't even have to jump over them.  Further, they do not intrude
+ * on our cache or tlb entries.
  */
-#define __put_user_unaligned(x, ptr)                                    \
-({                                                                      \
-        __typeof__ (*(ptr)) __x = (x);                                  \
-        __copy_to_user((ptr), &__x, sizeof(*(ptr))) ? -EFAULT : 0;      \
+
+struct exception_table_entry
+{
+        unsigned long insn, fixup;
+};
+
+/* Returns 0 if exception not found and fixup otherwise.  */
+extern unsigned long search_exception_table(unsigned long);
+
+/*
+ * architectures with an MMU should override these two
+ */
+#ifndef __copy_from_user
+static inline __must_check long __copy_from_user(void *to,
+                const void __user * from, unsigned long n)
+{
+        if (__builtin_constant_p(n)) {
+                switch(n) {
+                case 1:
+                        *(u8 *)to = *(u8 __force *)from;
+                        return 0;
+                case 2:
+                        *(u16 *)to = *(u16 __force *)from;
+                        return 0;
+                case 4:
+                        *(u32 *)to = *(u32 __force *)from;
+                        return 0;
+#ifdef CONFIG_64BIT
+                case 8:
+                        *(u64 *)to = *(u64 __force *)from;
+                        return 0;
+#endif
+                default:
+                        break;
+                }
+        }
+
+        memcpy(to, (const void __force *)from, n);
+        return 0;
+}
+#endif
+
+#ifndef __copy_to_user
+static inline __must_check long __copy_to_user(void __user *to,
+                const void *from, unsigned long n)
+{
+        if (__builtin_constant_p(n)) {
+                switch(n) {
+                case 1:
+                        *(u8 __force *)to = *(u8 *)from;
+                        return 0;
+                case 2:
+                        *(u16 __force *)to = *(u16 *)from;
+                        return 0;
+                case 4:
+                        *(u32 __force *)to = *(u32 *)from;
+                        return 0;
+#ifdef CONFIG_64BIT
+                case 8:
+                        *(u64 __force *)to = *(u64 *)from;
+                        return 0;
+#endif
+                default:
+                        break;
+                }
+        }
+
+        memcpy((void __force *)to, from, n);
+        return 0;
+}
+#endif
+
+/*
+ * These are the main single-value transfer routines.  They automatically
+ * use the right size if we just have the right pointer type.
+ * This version just falls back to copy_{from,to}_user, which should
+ * provide a fast-path for small values.
+ */
+#define __put_user(x, ptr) \
+({                                                              \
+        __typeof__(*(ptr)) __x = (x);                           \
+        int __pu_err = -EFAULT;                                 \
+        __chk_user_ptr(ptr);                                    \
+        switch (sizeof (*(ptr))) {                              \
+        case 1:                                                 \
+        case 2:                                                 \
+        case 4:                                                 \
+        case 8:                                                 \
+                __pu_err = __put_user_fn(sizeof (*(ptr)),       \
+                                         ptr, &__x);            \
+                break;                                          \
+        default:                                                \
+                __put_user_bad();                               \
+                break;                                          \
+         }                                                      \
+        __pu_err;                                               \
+})
+
+#define put_user(x, ptr)                                        \
+({                                                              \
+        might_sleep();                                          \
+        access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)) ?            \
+                __put_user(x, ptr) :                            \
+                -EFAULT;                                        \
 })
 
-#endif /* _ASM_GENERIC_UACCESS_H */
+static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
+{
+        size = __copy_to_user(ptr, x, size);
+        return size ? -EFAULT : size;
+}
+
+extern int __put_user_bad(void) __attribute__((noreturn));
+
+#define __get_user(x, ptr)                                      \
+({                                                              \
+        int __gu_err = -EFAULT;                                 \
+        __chk_user_ptr(ptr);                                    \
+        switch (sizeof(*(ptr))) {                               \
+        case 1: {                                               \
+                unsigned char __x;                              \
+                __gu_err = __get_user_fn(sizeof (*(ptr)),       \
+                                         ptr, &__x);            \
+                (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
+                break;                                          \
+        };                                                      \
+        case 2: {                                               \
+                unsigned short __x;                             \
+                __gu_err = __get_user_fn(sizeof (*(ptr)),       \
+                                         ptr, &__x);            \
+                (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
+                break;                                          \
+        };                                                      \
+        case 4: {                                               \
+                unsigned int __x;                               \
+                __gu_err = __get_user_fn(sizeof (*(ptr)),       \
+                                         ptr, &__x);            \
+                (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
+                break;                                          \
+        };                                                      \
+        case 8: {                                               \
+                unsigned long long __x;                         \
+                __gu_err = __get_user_fn(sizeof (*(ptr)),       \
+                                         ptr, &__x);            \
+                (x) = *(__force __typeof__(*(ptr)) *) &__x;     \
+                break;                                          \
+        };                                                      \
+        default:                                                \
+                __get_user_bad();                               \
+                break;                                          \
+        }                                                       \
+        __gu_err;                                               \
+})
+
+#define get_user(x, ptr)                                        \
+({                                                              \
+        might_sleep();                                          \
+        access_ok(VERIFY_READ, ptr, sizeof(*ptr)) ?             \
+                __get_user(x, ptr) :                            \
+                -EFAULT;                                        \
+})
+
+static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
+{
+        size = __copy_from_user(x, ptr, size);
+        return size ? -EFAULT : size;
+}
+
+extern int __get_user_bad(void) __attribute__((noreturn));
+
+#ifndef __copy_from_user_inatomic
+#define __copy_from_user_inatomic __copy_from_user
+#endif
+
+#ifndef __copy_to_user_inatomic
+#define __copy_to_user_inatomic __copy_to_user
+#endif
+
+static inline long copy_from_user(void *to,
+                const void __user * from, unsigned long n)
+{
+        might_sleep();
+        if (access_ok(VERIFY_READ, from, n))
+                return __copy_from_user(to, from, n);
+        else
+                return n;
+}
+
+static inline long copy_to_user(void __user *to,
+                const void *from, unsigned long n)
+{
+        might_sleep();
+        if (access_ok(VERIFY_WRITE, to, n))
+                return __copy_to_user(to, from, n);
+        else
+                return n;
+}
+
+/*
+ * Copy a null terminated string from userspace.
+ */
+#ifndef __strncpy_from_user
+static inline long
+__strncpy_from_user(char *dst, const char __user *src, long count)
+{
+        char *tmp;
+        strncpy(dst, (const char __force *)src, count);
+        for (tmp = dst; *tmp && count > 0; tmp++, count--)
+                ;
+        return (tmp - dst);
+}
+#endif
+
+static inline long
+strncpy_from_user(char *dst, const char __user *src, long count)
+{
+        if (!access_ok(VERIFY_READ, src, 1))
+                return -EFAULT;
+        return __strncpy_from_user(dst, src, count);
+}
+
+/*
+ * Return the size of a string (including the ending 0)
+ *
+ * Return 0 on exception, a value greater than N if too long
+ */
+#ifndef strnlen_user
+static inline long strnlen_user(const char __user *src, long n)
+{
+        if (!access_ok(VERIFY_READ, src, 1))
+                return 0;
+        return strlen((void * __force)src) + 1;
+}
+#endif
+
+static inline long strlen_user(const char __user *src)
+{
+        return strnlen_user(src, 32767);
+}
+
+/*
+ * Zero Userspace
+ */
+#ifndef __clear_user
+static inline __must_check unsigned long
+__clear_user(void __user *to, unsigned long n)
+{
+        memset((void __force *)to, 0, n);
+        return 0;
+}
+#endif
+
+static inline __must_check unsigned long
+clear_user(void __user *to, unsigned long n)
+{
+        might_sleep();
+        if (!access_ok(VERIFY_WRITE, to, n))
+                return n;
+
+        return __clear_user(to, n);
+}
+
+#endif /* __ASM_GENERIC_UACCESS_H */
diff --git a/include/asm-generic/ucontext.h b/include/asm-generic/ucontext.h
new file mode 100644
index 000000000000..ad77343e8a9a
--- /dev/null
+++ b/include/asm-generic/ucontext.h
@@ -0,0 +1,12 @@
+#ifndef __ASM_GENERIC_UCONTEXT_H
+#define __ASM_GENERIC_UCONTEXT_H
+
+struct ucontext {
+        unsigned long     uc_flags;
+        struct ucontext  *uc_link;
+        stack_t           uc_stack;
+        struct sigcontext uc_mcontext;
+        sigset_t          uc_sigmask;   /* mask last for extensibility */
+};
+
+#endif /* __ASM_GENERIC_UCONTEXT_H */
diff --git a/include/asm-generic/unaligned.h b/include/asm-generic/unaligned.h
new file mode 100644
index 000000000000..03cf5936bad6
--- /dev/null
+++ b/include/asm-generic/unaligned.h
@@ -0,0 +1,30 @@
+#ifndef __ASM_GENERIC_UNALIGNED_H
+#define __ASM_GENERIC_UNALIGNED_H
+
+/*
+ * This is the most generic implementation of unaligned accesses
+ * and should work almost anywhere.
+ *
+ * If an architecture can handle unaligned accesses in hardware,
+ * it may want to use the linux/unaligned/access_ok.h implementation
+ * instead.
+ */
+#include <asm/byteorder.h>
+
+#if defined(__LITTLE_ENDIAN)
+# include <linux/unaligned/le_struct.h>
+# include <linux/unaligned/be_byteshift.h>
+# include <linux/unaligned/generic.h>
+# define get_unaligned  __get_unaligned_le
+# define put_unaligned  __put_unaligned_le
+#elif defined(__BIG_ENDIAN)
+# include <linux/unaligned/be_struct.h>
+# include <linux/unaligned/le_byteshift.h>
+# include <linux/unaligned/generic.h>
+# define get_unaligned  __get_unaligned_be
+# define put_unaligned  __put_unaligned_be
+#else
+# error need to define endianess
+#endif
+
+#endif /* __ASM_GENERIC_UNALIGNED_H */
diff --git a/include/asm-generic/unistd.h b/include/asm-generic/unistd.h
new file mode 100644
index 000000000000..1125e5a1ee5d
--- /dev/null
+++ b/include/asm-generic/unistd.h
@@ -0,0 +1,859 @@
+#if !defined(_ASM_GENERIC_UNISTD_H) || defined(__SYSCALL)
+#define _ASM_GENERIC_UNISTD_H
+
+#include <asm/bitsperlong.h>
+
+/*
+ * This file contains the system call numbers, based on the
+ * layout of the x86-64 architecture, which embeds the
+ * pointer to the syscall in the table.
+ *
+ * As a basic principle, no duplication of functionality
+ * should be added, e.g. we don't use lseek when llseek
+ * is present. New architectures should use this file
+ * and implement the less feature-full calls in user space.
+ */
+
+#ifndef __SYSCALL
+#define __SYSCALL(x, y)
+#endif
+
+#if __BITS_PER_LONG == 32
+#define __SC_3264(_nr, _32, _64) __SYSCALL(_nr, _32)
+#else
+#define __SC_3264(_nr, _32, _64) __SYSCALL(_nr, _64)
+#endif
+
+#define __NR_io_setup 0
+__SYSCALL(__NR_io_setup, sys_io_setup)
+#define __NR_io_destroy 1
+__SYSCALL(__NR_io_destroy, sys_io_destroy)
+#define __NR_io_submit 2
+__SYSCALL(__NR_io_submit, sys_io_submit)
+#define __NR_io_cancel 3
+__SYSCALL(__NR_io_cancel, sys_io_cancel)
+#define __NR_io_getevents 4
+__SYSCALL(__NR_io_getevents, sys_io_getevents)
+
+/* fs/xattr.c */
+#define __NR_setxattr 5
+__SYSCALL(__NR_setxattr, sys_setxattr)
+#define __NR_lsetxattr 6
+__SYSCALL(__NR_lsetxattr, sys_lsetxattr)
+#define __NR_fsetxattr 7
+__SYSCALL(__NR_fsetxattr, sys_fsetxattr)
+#define __NR_getxattr 8
+__SYSCALL(__NR_getxattr, sys_getxattr)
+#define __NR_lgetxattr 9
+__SYSCALL(__NR_lgetxattr, sys_lgetxattr)
+#define __NR_fgetxattr 10
+__SYSCALL(__NR_fgetxattr, sys_fgetxattr)
+#define __NR_listxattr 11
+__SYSCALL(__NR_listxattr, sys_listxattr)
+#define __NR_llistxattr 12
+__SYSCALL(__NR_llistxattr, sys_llistxattr)
+#define __NR_flistxattr 13
+__SYSCALL(__NR_flistxattr, sys_flistxattr)
+#define __NR_removexattr 14
+__SYSCALL(__NR_removexattr, sys_removexattr)
+#define __NR_lremovexattr 15
+__SYSCALL(__NR_lremovexattr, sys_lremovexattr)
+#define __NR_fremovexattr 16
+__SYSCALL(__NR_fremovexattr, sys_fremovexattr)
+
+/* fs/dcache.c */
+#define __NR_getcwd 17
+__SYSCALL(__NR_getcwd, sys_getcwd)
+
+/* fs/cookies.c */
+#define __NR_lookup_dcookie 18
+__SYSCALL(__NR_lookup_dcookie, sys_lookup_dcookie)
+
+/* fs/eventfd.c */
+#define __NR_eventfd2 19
+__SYSCALL(__NR_eventfd2, sys_eventfd2)
+
+/* fs/eventpoll.c */
+#define __NR_epoll_create1 20
+__SYSCALL(__NR_epoll_create1, sys_epoll_create1)
+#define __NR_epoll_ctl 21
+__SYSCALL(__NR_epoll_ctl, sys_epoll_ctl)
+#define __NR_epoll_pwait 22
+__SYSCALL(__NR_epoll_pwait, sys_epoll_pwait)
+
+/* fs/fcntl.c */
+#define __NR_dup 23
+__SYSCALL(__NR_dup, sys_dup)
+#define __NR_dup3 24
+__SYSCALL(__NR_dup3, sys_dup3)
+#define __NR3264_fcntl 25
+__SC_3264(__NR3264_fcntl, sys_fcntl64, sys_fcntl)
+
+/* fs/inotify_user.c */
+#define __NR_inotify_init1 26
+__SYSCALL(__NR_inotify_init1, sys_inotify_init1)
+#define __NR_inotify_add_watch 27
+__SYSCALL(__NR_inotify_add_watch, sys_inotify_add_watch)
+#define __NR_inotify_rm_watch 28
+__SYSCALL(__NR_inotify_rm_watch, sys_inotify_rm_watch)
+
+/* fs/ioctl.c */
+#define __NR_ioctl 29
+__SYSCALL(__NR_ioctl, sys_ioctl)
+
+/* fs/ioprio.c */
+#define __NR_ioprio_set 30
+__SYSCALL(__NR_ioprio_set, sys_ioprio_set)
+#define __NR_ioprio_get 31
+__SYSCALL(__NR_ioprio_get, sys_ioprio_get)
+
+/* fs/locks.c */
+#define __NR_flock 32
+__SYSCALL(__NR_flock, sys_flock)
+
+/* fs/namei.c */
+#define __NR_mknodat 33
+__SYSCALL(__NR_mknodat, sys_mknodat)
+#define __NR_mkdirat 34
+__SYSCALL(__NR_mkdirat, sys_mkdirat)
+#define __NR_unlinkat 35
+__SYSCALL(__NR_unlinkat, sys_unlinkat)
+#define __NR_symlinkat 36
+__SYSCALL(__NR_symlinkat, sys_symlinkat)
+#define __NR_linkat 37
+__SYSCALL(__NR_linkat, sys_linkat)
+#define __NR_renameat 38
+__SYSCALL(__NR_renameat, sys_renameat)
+
+/* fs/namespace.c */
+#define __NR_umount2 39
+__SYSCALL(__NR_umount2, sys_umount)
+#define __NR_mount 40
+__SYSCALL(__NR_mount, sys_mount)
+#define __NR_pivot_root 41
+__SYSCALL(__NR_pivot_root, sys_pivot_root)
+
+/* fs/nfsctl.c */
+#define __NR_nfsservctl 42
+__SYSCALL(__NR_nfsservctl, sys_nfsservctl)
+
+/* fs/open.c */
+#define __NR3264_statfs 43
+__SC_3264(__NR3264_statfs, sys_statfs64, sys_statfs)
+#define __NR3264_fstatfs 44
+__SC_3264(__NR3264_fstatfs, sys_fstatfs64, sys_fstatfs)
+#define __NR3264_truncate 45
+__SC_3264(__NR3264_truncate, sys_truncate64, sys_truncate)
+#define __NR3264_ftruncate 46
+__SC_3264(__NR3264_ftruncate, sys_ftruncate64, sys_ftruncate)
+
+#define __NR_fallocate 47
+__SYSCALL(__NR_fallocate, sys_fallocate)
+#define __NR_faccessat 48
+__SYSCALL(__NR_faccessat, sys_faccessat)
+#define __NR_chdir 49
+__SYSCALL(__NR_chdir, sys_chdir)
+#define __NR_fchdir 50
+__SYSCALL(__NR_fchdir, sys_fchdir)
+#define __NR_chroot 51
+__SYSCALL(__NR_chroot, sys_chroot)
+#define __NR_fchmod 52
+__SYSCALL(__NR_fchmod, sys_fchmod)
+#define __NR_fchmodat 53
+__SYSCALL(__NR_fchmodat, sys_fchmodat)
+#define __NR_fchownat 54
+__SYSCALL(__NR_fchownat, sys_fchownat)
+#define __NR_fchown 55
+__SYSCALL(__NR_fchown, sys_fchown)
+#define __NR_openat 56
+__SYSCALL(__NR_openat, sys_openat)
+#define __NR_close 57
+__SYSCALL(__NR_close, sys_close)
+#define __NR_vhangup 58
+__SYSCALL(__NR_vhangup, sys_vhangup)
+
+/* fs/pipe.c */
+#define __NR_pipe2 59
+__SYSCALL(__NR_pipe2, sys_pipe2)
+
+/* fs/quota.c */
+#define __NR_quotactl 60
+__SYSCALL(__NR_quotactl, sys_quotactl)
+
+/* fs/readdir.c */
+#define __NR_getdents64 61
+__SYSCALL(__NR_getdents64, sys_getdents64)
+
+/* fs/read_write.c */
+#define __NR3264_lseek 62
+__SC_3264(__NR3264_lseek, sys_llseek, sys_lseek)
+#define __NR_read 63
+__SYSCALL(__NR_read, sys_read)
+#define __NR_write 64
+__SYSCALL(__NR_write, sys_write)
+#define __NR_readv 65
+__SYSCALL(__NR_readv, sys_readv)
+#define __NR_writev 66
+__SYSCALL(__NR_writev, sys_writev)
+#define __NR_pread64 67
+__SYSCALL(__NR_pread64, sys_pread64)
+#define __NR_pwrite64 68
+__SYSCALL(__NR_pwrite64, sys_pwrite64)
+#define __NR_preadv 69
+__SYSCALL(__NR_preadv, sys_preadv)
+#define __NR_pwritev 70
+__SYSCALL(__NR_pwritev, sys_pwritev)
+
+/* fs/sendfile.c */
+#define __NR3264_sendfile 71
+__SC_3264(__NR3264_sendfile, sys_sendfile64, sys_sendfile)
+
+/* fs/select.c */
+#define __NR_pselect6 72
+__SYSCALL(__NR_pselect6, sys_pselect6)
+#define __NR_ppoll 73
+__SYSCALL(__NR_ppoll, sys_ppoll)
+
+/* fs/signalfd.c */
+#define __NR_signalfd4 74
+__SYSCALL(__NR_signalfd4, sys_signalfd4)
+
+/* fs/splice.c */
+#define __NR_vmsplice 75
+__SYSCALL(__NR_vmsplice, sys_vmsplice)
+#define __NR_splice 76
+__SYSCALL(__NR_splice, sys_splice)
+#define __NR_tee 77
+__SYSCALL(__NR_tee, sys_tee)
+
+/* fs/stat.c */
+#define __NR_readlinkat 78
+__SYSCALL(__NR_readlinkat, sys_readlinkat)
+#define __NR3264_fstatat 79
+__SC_3264(__NR3264_fstatat, sys_fstatat64, sys_newfstatat)
+#define __NR3264_fstat 80
+__SC_3264(__NR3264_fstat, sys_fstat64, sys_newfstat)
+
+/* fs/sync.c */
+#define __NR_sync 81
+__SYSCALL(__NR_sync, sys_sync)
+#define __NR_fsync 82
+__SYSCALL(__NR_fsync, sys_fsync)
+#define __NR_fdatasync 83
+__SYSCALL(__NR_fdatasync, sys_fdatasync)
+#define __NR_sync_file_range 84
+__SYSCALL(__NR_sync_file_range, sys_sync_file_range) /* .long sys_sync_file_range2, */
+
+/* fs/timerfd.c */
+#define __NR_timerfd_create 85
+__SYSCALL(__NR_timerfd_create, sys_timerfd_create)
+#define __NR_timerfd_settime 86
+__SYSCALL(__NR_timerfd_settime, sys_timerfd_settime)
+#define __NR_timerfd_gettime 87
+__SYSCALL(__NR_timerfd_gettime, sys_timerfd_gettime)
+
+/* fs/utimes.c */
+#define __NR_utimensat 88
+__SYSCALL(__NR_utimensat, sys_utimensat)
+
+/* kernel/acct.c */
+#define __NR_acct 89
+__SYSCALL(__NR_acct, sys_acct)
+
+/* kernel/capability.c */
+#define __NR_capget 90
+__SYSCALL(__NR_capget, sys_capget)
+#define __NR_capset 91
+__SYSCALL(__NR_capset, sys_capset)
+
+/* kernel/exec_domain.c */
+#define __NR_personality 92
+__SYSCALL(__NR_personality, sys_personality)
+
+/* kernel/exit.c */
+#define __NR_exit 93
+__SYSCALL(__NR_exit, sys_exit)
+#define __NR_exit_group 94
+__SYSCALL(__NR_exit_group, sys_exit_group)
+#define __NR_waitid 95
+__SYSCALL(__NR_waitid, sys_waitid)
+
+/* kernel/fork.c */
+#define __NR_set_tid_address 96
+__SYSCALL(__NR_set_tid_address, sys_set_tid_address)
+#define __NR_unshare 97
+__SYSCALL(__NR_unshare, sys_unshare)
+
+/* kernel/futex.c */
+#define __NR_futex 98
+__SYSCALL(__NR_futex, sys_futex)
+#define __NR_set_robust_list 99
+__SYSCALL(__NR_set_robust_list, sys_set_robust_list)
+#define __NR_get_robust_list 100
+__SYSCALL(__NR_get_robust_list, sys_get_robust_list)
+
+/* kernel/hrtimer.c */
+#define __NR_nanosleep 101
+__SYSCALL(__NR_nanosleep, sys_nanosleep)
+
+/* kernel/itimer.c */
+#define __NR_getitimer 102
+__SYSCALL(__NR_getitimer, sys_getitimer)
+#define __NR_setitimer 103
+__SYSCALL(__NR_setitimer, sys_setitimer)
+
+/* kernel/kexec.c */
+#define __NR_kexec_load 104
+__SYSCALL(__NR_kexec_load, sys_kexec_load)
+
+/* kernel/module.c */
+#define __NR_init_module 105
+__SYSCALL(__NR_init_module, sys_init_module)
+#define __NR_delete_module 106
+__SYSCALL(__NR_delete_module, sys_delete_module)
+
+/* kernel/posix-timers.c */
+#define __NR_timer_create 107
+__SYSCALL(__NR_timer_create, sys_timer_create)
+#define __NR_timer_gettime 108
+__SYSCALL(__NR_timer_gettime, sys_timer_gettime)
+#define __NR_timer_getoverrun 109
+__SYSCALL(__NR_timer_getoverrun, sys_timer_getoverrun)
+#define __NR_timer_settime 110
+__SYSCALL(__NR_timer_settime, sys_timer_settime)
+#define __NR_timer_delete 111
+__SYSCALL(__NR_timer_delete, sys_timer_delete)
+#define __NR_clock_settime 112
+__SYSCALL(__NR_clock_settime, sys_clock_settime)
+#define __NR_clock_gettime 113
+__SYSCALL(__NR_clock_gettime, sys_clock_gettime)
+#define __NR_clock_getres 114
+__SYSCALL(__NR_clock_getres, sys_clock_getres)
+#define __NR_clock_nanosleep 115
+__SYSCALL(__NR_clock_nanosleep, sys_clock_nanosleep)
+
+/* kernel/printk.c */
+#define __NR_syslog 116
+__SYSCALL(__NR_syslog, sys_syslog)
+
+/* kernel/ptrace.c */
+#define __NR_ptrace 117
+__SYSCALL(__NR_ptrace, sys_ptrace)
+
+/* kernel/sched.c */
+#define __NR_sched_setparam 118
+__SYSCALL(__NR_sched_setparam, sys_sched_setparam)
+#define __NR_sched_setscheduler 119
+__SYSCALL(__NR_sched_setscheduler, sys_sched_setscheduler)
+#define __NR_sched_getscheduler 120
+__SYSCALL(__NR_sched_getscheduler, sys_sched_getscheduler)
+#define __NR_sched_getparam 121
+__SYSCALL(__NR_sched_getparam, sys_sched_getparam)
+#define __NR_sched_setaffinity 122
+__SYSCALL(__NR_sched_setaffinity, sys_sched_setaffinity)
+#define __NR_sched_getaffinity 123
+__SYSCALL(__NR_sched_getaffinity, sys_sched_getaffinity)
+#define __NR_sched_yield 124
+__SYSCALL(__NR_sched_yield, sys_sched_yield)
+#define __NR_sched_get_priority_max 125
+__SYSCALL(__NR_sched_get_priority_max, sys_sched_get_priority_max)
+#define __NR_sched_get_priority_min 126
+__SYSCALL(__NR_sched_get_priority_min, sys_sched_get_priority_min)
+#define __NR_sched_rr_get_interval 127
+__SYSCALL(__NR_sched_rr_get_interval, sys_sched_rr_get_interval)
+
+/* kernel/signal.c */
+#define __NR_restart_syscall 128
+__SYSCALL(__NR_restart_syscall, sys_restart_syscall)
+#define __NR_kill 129
+__SYSCALL(__NR_kill, sys_kill)
+#define __NR_tkill 130
+__SYSCALL(__NR_tkill, sys_tkill)
+#define __NR_tgkill 131
+__SYSCALL(__NR_tgkill, sys_tgkill)
+#define __NR_sigaltstack 132
+__SYSCALL(__NR_sigaltstack, sys_sigaltstack)
+#define __NR_rt_sigsuspend 133
+__SYSCALL(__NR_rt_sigsuspend, sys_rt_sigsuspend) /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
+#define __NR_rt_sigaction 134
+__SYSCALL(__NR_rt_sigaction, sys_rt_sigaction) /* __ARCH_WANT_SYS_RT_SIGACTION */
+#define __NR_rt_sigprocmask 135
+__SYSCALL(__NR_rt_sigprocmask, sys_rt_sigprocmask)
+#define __NR_rt_sigpending 136
+__SYSCALL(__NR_rt_sigpending, sys_rt_sigpending)
+#define __NR_rt_sigtimedwait 137
+__SYSCALL(__NR_rt_sigtimedwait, sys_rt_sigtimedwait)
+#define __NR_rt_sigqueueinfo 138
+__SYSCALL(__NR_rt_sigqueueinfo, sys_rt_sigqueueinfo)
+#define __NR_rt_sigreturn 139
+__SYSCALL(__NR_rt_sigreturn, sys_rt_sigreturn) /* sys_rt_sigreturn_wrapper, */
+
+/* kernel/sys.c */
+#define __NR_setpriority 140
+__SYSCALL(__NR_setpriority, sys_setpriority)
+#define __NR_getpriority 141
+__SYSCALL(__NR_getpriority, sys_getpriority)
+#define __NR_reboot 142
+__SYSCALL(__NR_reboot, sys_reboot)
+#define __NR_setregid 143
+__SYSCALL(__NR_setregid, sys_setregid)
+#define __NR_setgid 144
+__SYSCALL(__NR_setgid, sys_setgid)
+#define __NR_setreuid 145
+__SYSCALL(__NR_setreuid, sys_setreuid)
+#define __NR_setuid 146
+__SYSCALL(__NR_setuid, sys_setuid)
+#define __NR_setresuid 147
+__SYSCALL(__NR_setresuid, sys_setresuid)
+#define __NR_getresuid 148
+__SYSCALL(__NR_getresuid, sys_getresuid)
+#define __NR_setresgid 149
+__SYSCALL(__NR_setresgid, sys_setresgid)
+#define __NR_getresgid 150
+__SYSCALL(__NR_getresgid, sys_getresgid)
+#define __NR_setfsuid 151
+__SYSCALL(__NR_setfsuid, sys_setfsuid)
+#define __NR_setfsgid 152
+__SYSCALL(__NR_setfsgid, sys_setfsgid)
+#define __NR_times 153
+__SYSCALL(__NR_times, sys_times)
+#define __NR_setpgid 154
+__SYSCALL(__NR_setpgid, sys_setpgid)
+#define __NR_getpgid 155
+__SYSCALL(__NR_getpgid, sys_getpgid)
+#define __NR_getsid 156
+__SYSCALL(__NR_getsid, sys_getsid)
+#define __NR_setsid 157
+__SYSCALL(__NR_setsid, sys_setsid)
+#define __NR_getgroups 158
+__SYSCALL(__NR_getgroups, sys_getgroups)
+#define __NR_setgroups 159
+__SYSCALL(__NR_setgroups, sys_setgroups)
+#define __NR_uname 160
+__SYSCALL(__NR_uname, sys_newuname)
+#define __NR_sethostname 161
+__SYSCALL(__NR_sethostname, sys_sethostname)
+#define __NR_setdomainname 162
+__SYSCALL(__NR_setdomainname, sys_setdomainname)
+#define __NR_getrlimit 163
+__SYSCALL(__NR_getrlimit, sys_getrlimit)
+#define __NR_setrlimit 164
+__SYSCALL(__NR_setrlimit, sys_setrlimit)
+#define __NR_getrusage 165
+__SYSCALL(__NR_getrusage, sys_getrusage)
+#define __NR_umask 166
+__SYSCALL(__NR_umask, sys_umask)
+#define __NR_prctl 167
+__SYSCALL(__NR_prctl, sys_prctl)
+#define __NR_getcpu 168
+__SYSCALL(__NR_getcpu, sys_getcpu)
+
+/* kernel/time.c */
+#define __NR_gettimeofday 169
+__SYSCALL(__NR_gettimeofday, sys_gettimeofday)
+#define __NR_settimeofday 170
+__SYSCALL(__NR_settimeofday, sys_settimeofday)
+#define __NR_adjtimex 171
+__SYSCALL(__NR_adjtimex, sys_adjtimex)
+
+/* kernel/timer.c */
+#define __NR_getpid 172
+__SYSCALL(__NR_getpid, sys_getpid)
+#define __NR_getppid 173
+__SYSCALL(__NR_getppid, sys_getppid)
+#define __NR_getuid 174
+__SYSCALL(__NR_getuid, sys_getuid)
+#define __NR_geteuid 175
+__SYSCALL(__NR_geteuid, sys_geteuid)
+#define __NR_getgid 176
+__SYSCALL(__NR_getgid, sys_getgid)
+#define __NR_getegid 177
+__SYSCALL(__NR_getegid, sys_getegid)
+#define __NR_gettid 178
+__SYSCALL(__NR_gettid, sys_gettid)
+#define __NR_sysinfo 179
+__SYSCALL(__NR_sysinfo, sys_sysinfo)
+
+/* ipc/mqueue.c */
+#define __NR_mq_open 180
+__SYSCALL(__NR_mq_open, sys_mq_open)
+#define __NR_mq_unlink 181
+__SYSCALL(__NR_mq_unlink, sys_mq_unlink)
+#define __NR_mq_timedsend 182
+__SYSCALL(__NR_mq_timedsend, sys_mq_timedsend)
+#define __NR_mq_timedreceive 183
+__SYSCALL(__NR_mq_timedreceive, sys_mq_timedreceive)
+#define __NR_mq_notify 184
+__SYSCALL(__NR_mq_notify, sys_mq_notify)
+#define __NR_mq_getsetattr 185
+__SYSCALL(__NR_mq_getsetattr, sys_mq_getsetattr)
+
+/* ipc/msg.c */
+#define __NR_msgget 186
+__SYSCALL(__NR_msgget, sys_msgget)
+#define __NR_msgctl 187
+__SYSCALL(__NR_msgctl, sys_msgctl)
+#define __NR_msgrcv 188
+__SYSCALL(__NR_msgrcv, sys_msgrcv)
+#define __NR_msgsnd 189
+__SYSCALL(__NR_msgsnd, sys_msgsnd)
+
+/* ipc/sem.c */
+#define __NR_semget 190
+__SYSCALL(__NR_semget, sys_semget)
+#define __NR_semctl 191
+__SYSCALL(__NR_semctl, sys_semctl)
+#define __NR_semtimedop 192
+__SYSCALL(__NR_semtimedop, sys_semtimedop)
+#define __NR_semop 193
+__SYSCALL(__NR_semop, sys_semop)
+
+/* ipc/shm.c */
+#define __NR_shmget 194
+__SYSCALL(__NR_shmget, sys_shmget)
+#define __NR_shmctl 195
+__SYSCALL(__NR_shmctl, sys_shmctl)
+#define __NR_shmat 196
+__SYSCALL(__NR_shmat, sys_shmat)
+#define __NR_shmdt 197
+__SYSCALL(__NR_shmdt, sys_shmdt)
+
+/* net/socket.c */
+#define __NR_socket 198
+__SYSCALL(__NR_socket, sys_socket)
+#define __NR_socketpair 199
+__SYSCALL(__NR_socketpair, sys_socketpair)
+#define __NR_bind 200
+__SYSCALL(__NR_bind, sys_bind)
+#define __NR_listen 201
+__SYSCALL(__NR_listen, sys_listen)
+#define __NR_accept 202
+__SYSCALL(__NR_accept, sys_accept)
+#define __NR_connect 203
+__SYSCALL(__NR_connect, sys_connect)
+#define __NR_getsockname 204
+__SYSCALL(__NR_getsockname, sys_getsockname)
+#define __NR_getpeername 205
+__SYSCALL(__NR_getpeername, sys_getpeername)
+#define __NR_sendto 206
+__SYSCALL(__NR_sendto, sys_sendto)
+#define __NR_recvfrom 207
+__SYSCALL(__NR_recvfrom, sys_recvfrom)
+#define __NR_setsockopt 208
+__SYSCALL(__NR_setsockopt, sys_setsockopt)
+#define __NR_getsockopt 209
+__SYSCALL(__NR_getsockopt, sys_getsockopt)
+#define __NR_shutdown 210
+__SYSCALL(__NR_shutdown, sys_shutdown)
+#define __NR_sendmsg 211
+__SYSCALL(__NR_sendmsg, sys_sendmsg)
+#define __NR_recvmsg 212
+__SYSCALL(__NR_recvmsg, sys_recvmsg)
+
+/* mm/filemap.c */
+#define __NR_readahead 213
+__SYSCALL(__NR_readahead, sys_readahead)
+
+/* mm/nommu.c, also with MMU */
+#define __NR_brk 214
+__SYSCALL(__NR_brk, sys_brk)
+#define __NR_munmap 215
+__SYSCALL(__NR_munmap, sys_munmap)
+#define __NR_mremap 216
+__SYSCALL(__NR_mremap, sys_mremap)
+
+/* security/keys/keyctl.c */
+#define __NR_add_key 217
+__SYSCALL(__NR_add_key, sys_add_key)
+#define __NR_request_key 218
+__SYSCALL(__NR_request_key, sys_request_key)
+#define __NR_keyctl 219
+__SYSCALL(__NR_keyctl, sys_keyctl)
+
+/* arch/example/kernel/sys_example.c */
+#define __NR_clone 220
+__SYSCALL(__NR_clone, sys_clone)        /* .long sys_clone_wrapper */
+#define __NR_execve 221
+__SYSCALL(__NR_execve, sys_execve)      /* .long sys_execve_wrapper */
+
+#define __NR3264_mmap 222
+__SC_3264(__NR3264_mmap, sys_mmap2, sys_mmap)
+/* mm/fadvise.c */
+#define __NR3264_fadvise64 223
+__SC_3264(__NR3264_fadvise64, sys_fadvise64_64, sys_fadvise64)
+
+/* mm/, CONFIG_MMU only */
+#ifndef __ARCH_NOMMU
+#define __NR_swapon 224
+__SYSCALL(__NR_swapon, sys_swapon)
+#define __NR_swapoff 225
+__SYSCALL(__NR_swapoff, sys_swapoff)
+#define __NR_mprotect 226
+__SYSCALL(__NR_mprotect, sys_mprotect)
+#define __NR_msync 227
+__SYSCALL(__NR_msync, sys_msync)
+#define __NR_mlock 228
+__SYSCALL(__NR_mlock, sys_mlock)
+#define __NR_munlock 229
+__SYSCALL(__NR_munlock, sys_munlock)
+#define __NR_mlockall 230
+__SYSCALL(__NR_mlockall, sys_mlockall)
+#define __NR_munlockall 231
+__SYSCALL(__NR_munlockall, sys_munlockall)
+#define __NR_mincore 232
+__SYSCALL(__NR_mincore, sys_mincore)
+#define __NR_madvise 233
+__SYSCALL(__NR_madvise, sys_madvise)
+#define __NR_remap_file_pages 234
+__SYSCALL(__NR_remap_file_pages, sys_remap_file_pages)
+#define __NR_mbind 235
+__SYSCALL(__NR_mbind, sys_mbind)
+#define __NR_get_mempolicy 236
+__SYSCALL(__NR_get_mempolicy, sys_get_mempolicy)
+#define __NR_set_mempolicy 237
+__SYSCALL(__NR_set_mempolicy, sys_set_mempolicy)
+#define __NR_migrate_pages 238
+__SYSCALL(__NR_migrate_pages, sys_migrate_pages)
+#define __NR_move_pages 239
+__SYSCALL(__NR_move_pages, sys_move_pages)
+#endif
+
+#define __NR_rt_tgsigqueueinfo 240
+__SYSCALL(__NR_rt_tgsigqueueinfo, sys_rt_tgsigqueueinfo)
+#define __NR_perf_counter_open 241
+__SYSCALL(__NR_perf_counter_open, sys_perf_counter_open)
+
+#undef __NR_syscalls
+#define __NR_syscalls 242
+
+/*
+ * All syscalls below here should go away really,
+ * these are provided for both review and as a porting
+ * help for the C library version.
+*
+ * Last chance: are any of these important enought to
+ * enable by default?
+ */
+#ifdef __ARCH_WANT_SYSCALL_NO_AT
+#define __NR_open 1024
+__SYSCALL(__NR_open, sys_open)
+#define __NR_link 1025
+__SYSCALL(__NR_link, sys_link)
+#define __NR_unlink 1026
+__SYSCALL(__NR_unlink, sys_unlink)
+#define __NR_mknod 1027
+__SYSCALL(__NR_mknod, sys_mknod)
+#define __NR_chmod 1028
+__SYSCALL(__NR_chmod, sys_chmod)
+#define __NR_chown 1029
+__SYSCALL(__NR_chown, sys_chown)
+#define __NR_mkdir 1030
+__SYSCALL(__NR_mkdir, sys_mkdir)
+#define __NR_rmdir 1031
+__SYSCALL(__NR_rmdir, sys_rmdir)
+#define __NR_lchown 1032
+__SYSCALL(__NR_lchown, sys_lchown)
+#define __NR_access 1033
+__SYSCALL(__NR_access, sys_access)
+#define __NR_rename 1034
+__SYSCALL(__NR_rename, sys_rename)
+#define __NR_readlink 1035
+__SYSCALL(__NR_readlink, sys_readlink)
+#define __NR_symlink 1036
+__SYSCALL(__NR_symlink, sys_symlink)
+#define __NR_utimes 1037
+__SYSCALL(__NR_utimes, sys_utimes)
+#define __NR3264_stat 1038
+__SC_3264(__NR3264_stat, sys_stat64, sys_newstat)
+#define __NR3264_lstat 1039
+__SC_3264(__NR3264_lstat, sys_lstat64, sys_newlstat)
+
+#undef __NR_syscalls
+#define __NR_syscalls (__NR3264_lstat+1)
+#endif /* __ARCH_WANT_SYSCALL_NO_AT */
+
+#ifdef __ARCH_WANT_SYSCALL_NO_FLAGS
+#define __NR_pipe 1040
+__SYSCALL(__NR_pipe, sys_pipe)
+#define __NR_dup2 1041
+__SYSCALL(__NR_dup2, sys_dup2)
+#define __NR_epoll_create 1042
+__SYSCALL(__NR_epoll_create, sys_epoll_create)
+#define __NR_inotify_init 1043
+__SYSCALL(__NR_inotify_init, sys_inotify_init)
+#define __NR_eventfd 1044
+__SYSCALL(__NR_eventfd, sys_eventfd)
+#define __NR_signalfd 1045
+__SYSCALL(__NR_signalfd, sys_signalfd)
+
+#undef __NR_syscalls
+#define __NR_syscalls (__NR_signalfd+1)
+#endif /* __ARCH_WANT_SYSCALL_NO_FLAGS */
+
+#if __BITS_PER_LONG == 32 && defined(__ARCH_WANT_SYSCALL_OFF_T)
+#define __NR_sendfile 1046
+__SYSCALL(__NR_sendfile, sys_sendfile)
+#define __NR_ftruncate 1047
+__SYSCALL(__NR_ftruncate, sys_ftruncate)
+#define __NR_truncate 1048
+__SYSCALL(__NR_truncate, sys_truncate)
+#define __NR_stat 1049
+__SYSCALL(__NR_stat, sys_newstat)
+#define __NR_lstat 1050
+__SYSCALL(__NR_lstat, sys_newlstat)
+#define __NR_fstat 1051
+__SYSCALL(__NR_fstat, sys_newfstat)
+#define __NR_fcntl 1052
+__SYSCALL(__NR_fcntl, sys_fcntl)
+#define __NR_fadvise64 1053
+#define __ARCH_WANT_SYS_FADVISE64
+__SYSCALL(__NR_fadvise64, sys_fadvise64)
+#define __NR_newfstatat 1054
+#define __ARCH_WANT_SYS_NEWFSTATAT
+__SYSCALL(__NR_newfstatat, sys_newfstatat)
+#define __NR_fstatfs 1055
+__SYSCALL(__NR_fstatfs, sys_fstatfs)
+#define __NR_statfs 1056
+__SYSCALL(__NR_statfs, sys_statfs)
+#define __NR_lseek 1057
+__SYSCALL(__NR_lseek, sys_lseek)
+#define __NR_mmap 1058
+__SYSCALL(__NR_mmap, sys_mmap)
+
+#undef __NR_syscalls
+#define __NR_syscalls (__NR_mmap+1)
+#endif /* 32 bit off_t syscalls */
+
+#ifdef __ARCH_WANT_SYSCALL_DEPRECATED
+#define __NR_alarm 1059
+#define __ARCH_WANT_SYS_ALARM
+__SYSCALL(__NR_alarm, sys_alarm)
+#define __NR_getpgrp 1060
+#define __ARCH_WANT_SYS_GETPGRP
+__SYSCALL(__NR_getpgrp, sys_getpgrp)
+#define __NR_pause 1061
+#define __ARCH_WANT_SYS_PAUSE
+__SYSCALL(__NR_pause, sys_pause)
+#define __NR_time 1062
+#define __ARCH_WANT_SYS_TIME
+__SYSCALL(__NR_time, sys_time)
+#define __NR_utime 1063
+#define __ARCH_WANT_SYS_UTIME
+__SYSCALL(__NR_utime, sys_utime)
+
+#define __NR_creat 1064
+__SYSCALL(__NR_creat, sys_creat)
+#define __NR_getdents 1065
+#define __ARCH_WANT_SYS_GETDENTS
+__SYSCALL(__NR_getdents, sys_getdents)
+#define __NR_futimesat 1066
+__SYSCALL(__NR_futimesat, sys_futimesat)
+#define __NR_select 1067
+#define __ARCH_WANT_SYS_SELECT
+__SYSCALL(__NR_select, sys_select)
+#define __NR_poll 1068
+__SYSCALL(__NR_poll, sys_poll)
+#define __NR_epoll_wait 1069
+__SYSCALL(__NR_epoll_wait, sys_epoll_wait)
+#define __NR_ustat 1070
+__SYSCALL(__NR_ustat, sys_ustat)
+#define __NR_vfork 1071
+__SYSCALL(__NR_vfork, sys_vfork)
+#define __NR_wait4 1072
+__SYSCALL(__NR_wait4, sys_wait4)
+#define __NR_recv 1073
+__SYSCALL(__NR_recv, sys_recv)
+#define __NR_send 1074
+__SYSCALL(__NR_send, sys_send)
+#define __NR_bdflush 1075
+__SYSCALL(__NR_bdflush, sys_bdflush)
+#define __NR_umount 1076
+__SYSCALL(__NR_umount, sys_oldumount)
+#define __ARCH_WANT_SYS_OLDUMOUNT
+#define __NR_uselib 1077
+__SYSCALL(__NR_uselib, sys_uselib)
+#define __NR__sysctl 1078
+__SYSCALL(__NR__sysctl, sys_sysctl)
+
+#define __NR_fork 1079
+#ifdef CONFIG_MMU
+__SYSCALL(__NR_fork, sys_fork)
+#else
+__SYSCALL(__NR_fork, sys_ni_syscall)
+#endif /* CONFIG_MMU */
+
+#undef __NR_syscalls
+#define __NR_syscalls (__NR_fork+1)
+
+#endif /* __ARCH_WANT_SYSCALL_DEPRECATED */
+
+/*
+ * 32 bit systems traditionally used different
+ * syscalls for off_t and loff_t arguments, while
+ * 64 bit systems only need the off_t version.
+ * For new 32 bit platforms, there is no need to
+ * implement the old 32 bit off_t syscalls, so
+ * they take different names.
+ * Here we map the numbers so that both versions
+ * use the same syscall table layout.
+ */
+#if __BITS_PER_LONG == 64
+#define __NR_fcntl __NR3264_fcntl
+#define __NR_statfs __NR3264_statfs
+#define __NR_fstatfs __NR3264_fstatfs
+#define __NR_truncate __NR3264_truncate
+#define __NR_ftruncate __NR3264_truncate
+#define __NR_lseek __NR3264_lseek
+#define __NR_sendfile __NR3264_sendfile
+#define __NR_newfstatat __NR3264_fstatat
+#define __NR_fstat __NR3264_fstat
+#define __NR_mmap __NR3264_mmap
+#define __NR_fadvise64 __NR3264_fadvise64
+#ifdef __NR3264_stat
+#define __NR_stat __NR3264_stat
+#define __NR_lstat __NR3264_lstat
+#endif
+#else
+#define __NR_fcntl64 __NR3264_fcntl
+#define __NR_statfs64 __NR3264_statfs
+#define __NR_fstatfs64 __NR3264_fstatfs
+#define __NR_truncate64 __NR3264_truncate
+#define __NR_ftruncate64 __NR3264_truncate
+#define __NR_llseek __NR3264_lseek
+#define __NR_sendfile64 __NR3264_sendfile
+#define __NR_fstatat64 __NR3264_fstatat
+#define __NR_fstat64 __NR3264_fstat
+#define __NR_mmap2 __NR3264_mmap
+#define __NR_fadvise64_64 __NR3264_fadvise64
+#ifdef __NR3264_stat
+#define __NR_stat64 __NR3264_stat
+#define __NR_lstat64 __NR3264_lstat
+#endif
+#endif
+
+#ifdef __KERNEL__
+
+/*
+ * These are required system calls, we should
+ * invert the logic eventually and let them
+ * be selected by default.
+ */
+#if __BITS_PER_LONG == 32
+#define __ARCH_WANT_STAT64
+#define __ARCH_WANT_SYS_LLSEEK
+#endif
+#define __ARCH_WANT_SYS_RT_SIGACTION
+#define __ARCH_WANT_SYS_RT_SIGSUSPEND
+
+/*
+ * "Conditional" syscalls
+ *
+ * What we want is __attribute__((weak,alias("sys_ni_syscall"))),
+ * but it doesn't work on all toolchains, so we just do it by hand
+ */
+#ifndef cond_syscall
+#define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
+#endif
+
+#endif /* __KERNEL__ */
+#endif /* _ASM_GENERIC_UNISTD_H */
diff --git a/include/asm-generic/user.h b/include/asm-generic/user.h
new file mode 100644
index 000000000000..8b9c3c960aeb
--- /dev/null
+++ b/include/asm-generic/user.h
@@ -0,0 +1,8 @@
+#ifndef __ASM_GENERIC_USER_H
+#define __ASM_GENERIC_USER_H
+/*
+ * This file may define a 'struct user' structure. However, it it only
+ * used for a.out file, which are not supported on new architectures.
+ */
+
+#endif  /* __ASM_GENERIC_USER_H */
diff --git a/include/asm-generic/vga.h b/include/asm-generic/vga.h
new file mode 100644
index 000000000000..36c8ff52016b
--- /dev/null
+++ b/include/asm-generic/vga.h
@@ -0,0 +1,24 @@
+/*
+ *      Access to VGA videoram
+ *
+ *      (c) 1998 Martin Mares <mj@ucw.cz>
+ */
+#ifndef __ASM_GENERIC_VGA_H
+#define __ASM_GENERIC_VGA_H
+
+/*
+ *      On most architectures that support VGA, we can just
+ *      recalculate addresses and then access the videoram
+ *      directly without any black magic.
+ *
+ *      Everyone else needs to ioremap the address and use
+ *      proper I/O accesses.
+ */
+#ifndef VGA_MAP_MEM
+#define VGA_MAP_MEM(x, s) (unsigned long)phys_to_virt(x)
+#endif
+
+#define vga_readb(x) (*(x))
+#define vga_writeb(x, y) (*(y) = (x))
+
+#endif /* _ASM_GENERIC_VGA_H */
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index 89853bcd27a6..6ad76bf5fb40 100644
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -1,4 +1,55 @@
-#include <linux/section-names.h>
+/*
+ * Helper macros to support writing architecture specific
+ * linker scripts.
+ *
+ * A minimal linker scripts has following content:
+ * [This is a sample, architectures may have special requiriements]
+ *
+ * OUTPUT_FORMAT(...)
+ * OUTPUT_ARCH(...)
+ * ENTRY(...)
+ * SECTIONS
+ * {
+ *      . = START;
+ *      __init_begin = .;
+ *      HEAD_TEXT_SECTION
+ *      INIT_TEXT_SECTION(PAGE_SIZE)
+ *      INIT_DATA_SECTION(...)
+ *      PERCPU(PAGE_SIZE)
+ *      __init_end = .;
+ *
+ *      _stext = .;
+ *      TEXT_SECTION = 0
+ *      _etext = .;
+ *
+ *      _sdata = .;
+ *      RO_DATA_SECTION(PAGE_SIZE)
+ *      RW_DATA_SECTION(...)
+ *      _edata = .;
+ *
+ *      EXCEPTION_TABLE(...)
+ *      NOTES
+ *
+ *      BSS_SECTION(0, 0, 0)
+ *      _end = .;
+ *
+ *      /DISCARD/ : {
+ *              EXIT_TEXT
+ *              EXIT_DATA
+ *              EXIT_CALL
+ *      }
+ *      STABS_DEBUG
+ *      DWARF_DEBUG
+ * }
+ *
+ * [__init_begin, __init_end] is the init section that may be freed after init
+ * [_stext, _etext] is the text section
+ * [_sdata, _edata] is the data section
+ *
+ * Some of the included output section have their own set of constants.
+ * Examples are: [__initramfs_start, __initramfs_end] for initramfs and
+ *               [__nosave_begin, __nosave_end] for the nosave data
+ */
 
 #ifndef LOAD_OFFSET
 #define LOAD_OFFSET 0
@@ -63,7 +114,7 @@
 #define BRANCH_PROFILE()
 #endif
 
-#ifdef CONFIG_EVENT_TRACER
+#ifdef CONFIG_EVENT_TRACING
 #define FTRACE_EVENTS() VMLINUX_SYMBOL(__start_ftrace_events) = .;      \
                         *(_ftrace_events)                               \
                         VMLINUX_SYMBOL(__stop_ftrace_events) = .;
@@ -116,7 +167,36 @@
         FTRACE_EVENTS()                                                 \
         TRACE_SYSCALLS()
 
-#define RO_DATA(align)                                                  \
+/*
+ * Data section helpers
+ */
+#define NOSAVE_DATA                                                     \
+        . = ALIGN(PAGE_SIZE);                                           \
+        VMLINUX_SYMBOL(__nosave_begin) = .;                             \
+        *(.data.nosave)                                                 \
+        . = ALIGN(PAGE_SIZE);                                           \
+        VMLINUX_SYMBOL(__nosave_end) = .;
+
+#define PAGE_ALIGNED_DATA(page_align)                                   \
+        . = ALIGN(page_align);                                          \
+        *(.data.page_aligned)
+
+#define READ_MOSTLY_DATA(align)                                         \
+        . = ALIGN(align);                                               \
+        *(.data.read_mostly)
+
+#define CACHELINE_ALIGNED_DATA(align)                                   \
+        . = ALIGN(align);                                               \
+        *(.data.cacheline_aligned)
+
+#define INIT_TASK_DATA(align)                                           \
+        . = ALIGN(align);                                               \
+        *(.data.init_task)
+
+/*
+ * Read only Data
+ */
+#define RO_DATA_SECTION(align)                                          \
         . = ALIGN((align));                                             \
         .rodata           : AT(ADDR(.rodata) - LOAD_OFFSET) {           \
                 VMLINUX_SYMBOL(__start_rodata) = .;                     \
@@ -270,9 +350,10 @@
         }                                                               \
         . = ALIGN((align));
 
-/* RODATA provided for backward compatibility.
+/* RODATA & RO_DATA provided for backward compatibility.
  * All archs are supposed to use RO_DATA() */
-#define RODATA RO_DATA(4096)
+#define RODATA          RO_DATA_SECTION(4096)
+#define RO_DATA(align)  RO_DATA_SECTION(align)
 
 #define SECURITY_INIT                                                   \
         .security_initcall.init : AT(ADDR(.security_initcall.init) - LOAD_OFFSET) { \
@@ -330,16 +411,52 @@
 #endif
 
 /* Section used for early init (in .S files) */
-#define HEAD_TEXT  *(HEAD_TEXT_SECTION)
+#define HEAD_TEXT  *(.head.text)
+
+#define HEAD_TEXT_SECTION                                                       \
+        .head.text : AT(ADDR(.head.text) - LOAD_OFFSET) {               \
+                HEAD_TEXT                                               \
+        }
+
+/*
+ * Exception table
+ */
+#define EXCEPTION_TABLE(align)                                          \
+        . = ALIGN(align);                                               \
+        __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {               \
+                VMLINUX_SYMBOL(__start___ex_table) = .;                 \
+                *(__ex_table)                                           \
+                VMLINUX_SYMBOL(__stop___ex_table) = .;                  \
+        }
+
+/*
+ * Init task
+ */
+#define INIT_TASK_DATA_SECTION(align)                                   \
+        . = ALIGN(align);                                               \
+        .data.init_task : {                                             \
+                INIT_TASK_DATA(align)                                   \
+        }
+
+#ifdef CONFIG_CONSTRUCTORS
+#define KERNEL_CTORS()  . = ALIGN(8);                      \
+                        VMLINUX_SYMBOL(__ctors_start) = .; \
+                        *(.ctors)                          \
+                        VMLINUX_SYMBOL(__ctors_end) = .;
+#else
+#define KERNEL_CTORS()
+#endif
 
 /* init and exit section handling */
 #define INIT_DATA                                                       \
         *(.init.data)                                                   \
         DEV_DISCARD(init.data)                                          \
-        DEV_DISCARD(init.rodata)                                        \
         CPU_DISCARD(init.data)                                          \
-        CPU_DISCARD(init.rodata)                                        \
         MEM_DISCARD(init.data)                                          \
+        KERNEL_CTORS()                                                  \
+        *(.init.rodata)                                                 \
+        DEV_DISCARD(init.rodata)                                        \
+        CPU_DISCARD(init.rodata)                                        \
         MEM_DISCARD(init.rodata)
 
 #define INIT_TEXT                                                       \
@@ -363,9 +480,34 @@
         CPU_DISCARD(exit.text)                                          \
         MEM_DISCARD(exit.text)
 
-                /* DWARF debug sections.
-                Symbols in the DWARF debugging sections are relative to
-                the beginning of the section so we begin them at 0.  */
+#define EXIT_CALL                                                       \
+        *(.exitcall.exit)
+
+/*
+ * bss (Block Started by Symbol) - uninitialized data
+ * zeroed during startup
+ */
+#define SBSS(sbss_align)                                                \
+        . = ALIGN(sbss_align);                                          \
+        .sbss : AT(ADDR(.sbss) - LOAD_OFFSET) {                         \
+                *(.sbss)                                                \
+                *(.scommon)                                             \
+        }
+
+#define BSS(bss_align)                                                  \
+        . = ALIGN(bss_align);                                           \
+        .bss : AT(ADDR(.bss) - LOAD_OFFSET) {                           \
+                *(.bss.page_aligned)                                    \
+                *(.dynbss)                                              \
+                *(.bss)                                                 \
+                *(COMMON)                                               \
+        }
+
+/*
+ * DWARF debug sections.
+ * Symbols in the DWARF debugging sections are relative to
+ * the beginning of the section so we begin them at 0.
+ */
 #define DWARF_DEBUG                                                     \
                 /* DWARF 1 */                                           \
                 .debug          0 : { *(.debug) }                       \
@@ -432,6 +574,12 @@
                 VMLINUX_SYMBOL(__stop_notes) = .;                       \
         }
 
+#define INIT_SETUP(initsetup_align)                                     \
+                . = ALIGN(initsetup_align);                             \
+                VMLINUX_SYMBOL(__setup_start) = .;                      \
+                *(.init.setup)                                          \
+                VMLINUX_SYMBOL(__setup_end) = .;
+
 #define INITCALLS                                                       \
         *(.initcallearly.init)                                          \
         VMLINUX_SYMBOL(__early_initcall_end) = .;                       \
@@ -453,6 +601,31 @@
         *(.initcall7.init)                                              \
         *(.initcall7s.init)
 
+#define INIT_CALLS                                                      \
+                VMLINUX_SYMBOL(__initcall_start) = .;                   \
+                INITCALLS                                               \
+                VMLINUX_SYMBOL(__initcall_end) = .;
+
+#define CON_INITCALL                                                    \
+                VMLINUX_SYMBOL(__con_initcall_start) = .;               \
+                *(.con_initcall.init)                                   \
+                VMLINUX_SYMBOL(__con_initcall_end) = .;
+
+#define SECURITY_INITCALL                                               \
+                VMLINUX_SYMBOL(__security_initcall_start) = .;          \
+                *(.security_initcall.init)                              \
+                VMLINUX_SYMBOL(__security_initcall_end) = .;
+
+#ifdef CONFIG_BLK_DEV_INITRD
+#define INIT_RAM_FS                                                     \
+        . = ALIGN(PAGE_SIZE);                                           \
+        VMLINUX_SYMBOL(__initramfs_start) = .;                          \
+        *(.init.ramfs)                                                  \
+        VMLINUX_SYMBOL(__initramfs_end) = .;
+#else
+#define INIT_RAM_FS
+#endif
+
 /**
  * PERCPU_VADDR - define output section for percpu area
  * @vaddr: explicit base address (optional)
@@ -509,3 +682,60 @@
                 *(.data.percpu.shared_aligned)                          \
                 VMLINUX_SYMBOL(__per_cpu_end) = .;                      \
         }
+
+
+/*
+ * Definition of the high level *_SECTION macros
+ * They will fit only a subset of the architectures
+ */
+
+
+/*
+ * Writeable data.
+ * All sections are combined in a single .data section.
+ * The sections following CONSTRUCTORS are arranged so their
+ * typical alignment matches.
+ * A cacheline is typical/always less than a PAGE_SIZE so
+ * the sections that has this restriction (or similar)
+ * is located before the ones requiring PAGE_SIZE alignment.
+ * NOSAVE_DATA starts and ends with a PAGE_SIZE alignment which
+ * matches the requirment of PAGE_ALIGNED_DATA.
+ *
+ * use 0 as page_align if page_aligned data is not used */
+#define RW_DATA_SECTION(cacheline, pagealigned, inittask)               \
+        . = ALIGN(PAGE_SIZE);                                           \
+        .data : AT(ADDR(.data) - LOAD_OFFSET) {                         \
+                INIT_TASK_DATA(inittask)                                \
+                CACHELINE_ALIGNED_DATA(cacheline)                       \
+                READ_MOSTLY_DATA(cacheline)                             \
+                DATA_DATA                                               \
+                CONSTRUCTORS                                            \
+                NOSAVE_DATA                                             \
+                PAGE_ALIGNED_DATA(pagealigned)                          \
+        }
+
+#define INIT_TEXT_SECTION(inittext_align)                               \
+        . = ALIGN(inittext_align);                                      \
+        .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {               \
+                VMLINUX_SYMBOL(_sinittext) = .;                         \
+                INIT_TEXT                                               \
+                VMLINUX_SYMBOL(_einittext) = .;                         \
+        }
+
+#define INIT_DATA_SECTION(initsetup_align)                              \
+        .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) {               \
+                INIT_DATA                                               \
+                INIT_SETUP(initsetup_align)                             \
+                INIT_CALLS                                              \
+                CON_INITCALL                                            \
+                SECURITY_INITCALL                                       \
+                INIT_RAM_FS                                             \
+        }
+
+#define BSS_SECTION(sbss_align, bss_align, stop_align)                  \
+        . = ALIGN(sbss_align);                                          \
+        VMLINUX_SYMBOL(__bss_start) = .;                                \
+        SBSS(sbss_align)                                                \
+        BSS(bss_align)                                                  \
+        . = ALIGN(stop_align);                                          \
+        VMLINUX_SYMBOL(__bss_stop) = .;
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index b84d8ae35e6f..45b67d9c39c1 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -34,9 +34,6 @@
 #ifndef _DRM_P_H_
 #define _DRM_P_H_
 
-/* If you want the memory alloc debug functionality, change define below */
-/* #define DEBUG_MEMORY */
-
 #ifdef __KERNEL__
 #ifdef __alpha__
 /* add include of current.h so that "current" is defined
@@ -86,7 +83,17 @@ struct drm_device;
 
 #include "drm_os_linux.h"
 #include "drm_hashtab.h"
+#include "drm_mm.h"
+
+#define DRM_UT_CORE             0x01
+#define DRM_UT_DRIVER           0x02
+#define DRM_UT_KMS              0x04
+#define DRM_UT_MODE             0x08
 
+extern void drm_ut_debug_printk(unsigned int request_level,
+                                const char *prefix,
+                                const char *function_name,
+                                const char *format, ...);
 /***********************************************************************/
 /** \name DRM template customization defaults */
 /*@{*/
@@ -123,31 +130,6 @@ struct drm_device;
 
 #define DRM_FLAG_DEBUG    0x01
 
-#define DRM_MEM_DMA        0
-#define DRM_MEM_SAREA      1
-#define DRM_MEM_DRIVER     2
-#define DRM_MEM_MAGIC      3
-#define DRM_MEM_IOCTLS     4
-#define DRM_MEM_MAPS       5
-#define DRM_MEM_VMAS       6
-#define DRM_MEM_BUFS       7
-#define DRM_MEM_SEGS       8
-#define DRM_MEM_PAGES      9
-#define DRM_MEM_FILES     10
-#define DRM_MEM_QUEUES    11
-#define DRM_MEM_CMDS      12
-#define DRM_MEM_MAPPINGS  13
-#define DRM_MEM_BUFLISTS  14
-#define DRM_MEM_AGPLISTS  15
-#define DRM_MEM_TOTALAGP  16
-#define DRM_MEM_BOUNDAGP  17
-#define DRM_MEM_CTXBITMAP 18
-#define DRM_MEM_STUB      19
-#define DRM_MEM_SGLISTS   20
-#define DRM_MEM_CTXLIST   21
-#define DRM_MEM_MM        22
-#define DRM_MEM_HASHTAB   23
-
 #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
 #define DRM_MAP_HASH_OFFSET 0x10000000
 
@@ -186,15 +168,57 @@ struct drm_device;
  * \param arg arguments
  */
 #if DRM_DEBUG_CODE
-#define DRM_DEBUG(fmt, arg...)                                          \
+#define DRM_DEBUG(fmt, args...)                                         \
+        do {                                                            \
+                drm_ut_debug_printk(DRM_UT_CORE, DRM_NAME,              \
+                                        __func__, fmt, ##args);         \
+        } while (0)
+
+#define DRM_DEBUG_DRIVER(prefix, fmt, args...)                          \
+        do {                                                            \
+                drm_ut_debug_printk(DRM_UT_DRIVER, prefix,              \
+                                        __func__, fmt, ##args);         \
+        } while (0)
+#define DRM_DEBUG_KMS(prefix, fmt, args...)                             \
+        do {                                                            \
+                drm_ut_debug_printk(DRM_UT_KMS, prefix,                 \
+                                         __func__, fmt, ##args);        \
+        } while (0)
+#define DRM_DEBUG_MODE(prefix, fmt, args...)                            \
+        do {                                                            \
+                drm_ut_debug_printk(DRM_UT_MODE, prefix,                \
+                                         __func__, fmt, ##args);        \
+        } while (0)
+#define DRM_LOG(fmt, args...)                                           \
+        do {                                                            \
+                drm_ut_debug_printk(DRM_UT_CORE, NULL,                  \
+                                        NULL, fmt, ##args);             \
+        } while (0)
+#define DRM_LOG_KMS(fmt, args...)                                       \
         do {                                                            \
-                if ( drm_debug )                        \
-                        printk(KERN_DEBUG                               \
-                               "[" DRM_NAME ":%s] " fmt ,       \
-                               __func__ , ##arg);                       \
+                drm_ut_debug_printk(DRM_UT_KMS, NULL,                   \
+                                        NULL, fmt, ##args);             \
+        } while (0)
+#define DRM_LOG_MODE(fmt, args...)                                      \
+        do {                                                            \
+                drm_ut_debug_printk(DRM_UT_MODE, NULL,                  \
+                                        NULL, fmt, ##args);             \
+        } while (0)
+#define DRM_LOG_DRIVER(fmt, args...)                                    \
+        do {                                                            \
+                drm_ut_debug_printk(DRM_UT_DRIVER, NULL,                \
+                                        NULL, fmt, ##args);             \
         } while (0)
 #else
+#define DRM_DEBUG_DRIVER(prefix, fmt, args...) do { } while (0)
+#define DRM_DEBUG_KMS(prefix, fmt, args...)     do { } while (0)
+#define DRM_DEBUG_MODE(prefix, fmt, args...)    do { } while (0)
 #define DRM_DEBUG(fmt, arg...)           do { } while (0)
+#define DRM_LOG(fmt, arg...)            do { } while (0)
+#define DRM_LOG_KMS(fmt, args...) do { } while (0)
+#define DRM_LOG_MODE(fmt, arg...) do { } while (0)
+#define DRM_LOG_DRIVER(fmt, arg...) do { } while (0)
+
 #endif
 
 #define DRM_PROC_LIMIT (PAGE_SIZE-80)
@@ -237,15 +261,15 @@ struct drm_device;
  * \param dev DRM device.
  * \param filp file pointer of the caller.
  */
-#define LOCK_TEST_WITH_RETURN( dev, file_priv )                         \
-do {                                                                    \
-        if (!_DRM_LOCK_IS_HELD(file_priv->master->lock.hw_lock->lock) ||                \
-            file_priv->master->lock.file_priv != file_priv)     {                       \
+#define LOCK_TEST_WITH_RETURN( dev, _file_priv )                                \
+do {                                                                            \
+        if (!_DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock) ||       \
+            _file_priv->master->lock.file_priv != _file_priv)   {               \
                 DRM_ERROR( "%s called without lock held, held  %d owner %p %p\n",\
-                           __func__, _DRM_LOCK_IS_HELD(file_priv->master->lock.hw_lock->lock),\
-                           file_priv->master->lock.file_priv, file_priv);               \
-                return -EINVAL;                                         \
-        }                                                               \
+                           __func__, _DRM_LOCK_IS_HELD(_file_priv->master->lock.hw_lock->lock),\
+                           _file_priv->master->lock.file_priv, _file_priv);     \
+                return -EINVAL;                                                 \
+        }                                                                       \
 } while (0)
 
 /**
@@ -502,26 +526,6 @@ struct drm_sigdata {
 };
 
 
-/*
- * Generic memory manager structs
- */
-
-struct drm_mm_node {
-        struct list_head fl_entry;
-        struct list_head ml_entry;
-        int free;
-        unsigned long start;
-        unsigned long size;
-        struct drm_mm *mm;
-        void *private;
-};
-
-struct drm_mm {
-        struct list_head fl_entry;
-        struct list_head ml_entry;
-};
-
-
 /**
  * Kernel side of a mapping
  */
@@ -1385,22 +1389,6 @@ extern char *drm_get_connector_status_name(enum drm_connector_status status);
 extern int drm_sysfs_connector_add(struct drm_connector *connector);
 extern void drm_sysfs_connector_remove(struct drm_connector *connector);
 
-/*
- * Basic memory manager support (drm_mm.c)
- */
-extern struct drm_mm_node *drm_mm_get_block(struct drm_mm_node * parent,
-                                       unsigned long size,
-                                       unsigned alignment);
-extern void drm_mm_put_block(struct drm_mm_node * cur);
-extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm, unsigned long size,
-                                         unsigned alignment, int best_match);
-extern int drm_mm_init(struct drm_mm *mm, unsigned long start, unsigned long size);
-extern void drm_mm_takedown(struct drm_mm *mm);
-extern int drm_mm_clean(struct drm_mm *mm);
-extern unsigned long drm_mm_tail_space(struct drm_mm *mm);
-extern int drm_mm_remove_space_from_tail(struct drm_mm *mm, unsigned long size);
-extern int drm_mm_add_space_to_tail(struct drm_mm *mm, unsigned long size);
-
 /* Graphics Execution Manager library functions (drm_gem.c) */
 int drm_gem_init(struct drm_device *dev);
 void drm_gem_destroy(struct drm_device *dev);
@@ -1501,39 +1489,17 @@ static __inline__ void drm_core_dropmap(struct drm_local_map *map)
 {
 }
 
-#ifndef DEBUG_MEMORY
-/** Wrapper around kmalloc() */
-static __inline__ void *drm_alloc(size_t size, int area)
-{
-        return kmalloc(size, GFP_KERNEL);
-}
-
-/** Wrapper around kfree() */
-static __inline__ void drm_free(void *pt, size_t size, int area)
-{
-        kfree(pt);
-}
-
-/** Wrapper around kcalloc() */
-static __inline__ void *drm_calloc(size_t nmemb, size_t size, int area)
-{
-        return kcalloc(nmemb, size, GFP_KERNEL);
-}
 
 static __inline__ void *drm_calloc_large(size_t nmemb, size_t size)
 {
-        u8 *addr;
-
-        if (size <= PAGE_SIZE)
+        if (size * nmemb <= PAGE_SIZE)
             return kcalloc(nmemb, size, GFP_KERNEL);
 
-        addr = vmalloc(nmemb * size);
-        if (!addr)
+        if (size != 0 && nmemb > ULONG_MAX / size)
                 return NULL;
 
-        memset(addr, 0, nmemb * size);
-
-        return addr;
+        return __vmalloc(size * nmemb,
+                         GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
 }
 
 static __inline void drm_free_large(void *ptr)
@@ -1543,12 +1509,6 @@ static __inline void drm_free_large(void *ptr)
 
         vfree(ptr);
 }
-#else
-extern void *drm_alloc(size_t size, int area);
-extern void drm_free(void *pt, size_t size, int area);
-extern void *drm_calloc(size_t nmemb, size_t size, int area);
-#endif
-
 /*@}*/
 
 #endif                          /* __KERNEL__ */
diff --git a/include/drm/drm_edid.h b/include/drm/drm_edid.h
index a11cc9d32591..7d6c9a2dfcbb 100644
--- a/include/drm/drm_edid.h
+++ b/include/drm/drm_edid.h
@@ -28,53 +28,49 @@
 #define EDID_LENGTH 128
 #define DDC_ADDR 0x50
 
-#ifdef BIG_ENDIAN
-#error "EDID structure is little endian, need big endian versions"
-#else
-
 struct est_timings {
         u8 t1;
         u8 t2;
         u8 mfg_rsvd;
 } __attribute__((packed));
 
+/* 00=16:10, 01=4:3, 10=5:4, 11=16:9 */
+#define EDID_TIMING_ASPECT_SHIFT 6
+#define EDID_TIMING_ASPECT_MASK  (0x3 << EDID_TIMING_ASPECT_SHIFT)
+
+/* need to add 60 */
+#define EDID_TIMING_VFREQ_SHIFT  0
+#define EDID_TIMING_VFREQ_MASK   (0x3f << EDID_TIMING_VFREQ_SHIFT)
+
 struct std_timing {
         u8 hsize; /* need to multiply by 8 then add 248 */
-        u8 vfreq:6; /* need to add 60 */
-        u8 aspect_ratio:2; /* 00=16:10, 01=4:3, 10=5:4, 11=16:9 */
+        u8 vfreq_aspect;
 } __attribute__((packed));
 
+#define DRM_EDID_PT_HSYNC_POSITIVE (1 << 1)
+#define DRM_EDID_PT_VSYNC_POSITIVE (1 << 2)
+#define DRM_EDID_PT_SEPARATE_SYNC  (3 << 3)
+#define DRM_EDID_PT_STEREO         (1 << 5)
+#define DRM_EDID_PT_INTERLACED     (1 << 7)
+
 /* If detailed data is pixel timing */
 struct detailed_pixel_timing {
         u8 hactive_lo;
         u8 hblank_lo;
-        u8 hblank_hi:4;
-        u8 hactive_hi:4;
+        u8 hactive_hblank_hi;
         u8 vactive_lo;
         u8 vblank_lo;
-        u8 vblank_hi:4;
-        u8 vactive_hi:4;
+        u8 vactive_vblank_hi;
         u8 hsync_offset_lo;
         u8 hsync_pulse_width_lo;
-        u8 vsync_pulse_width_lo:4;
-        u8 vsync_offset_lo:4;
-        u8 vsync_pulse_width_hi:2;
-        u8 vsync_offset_hi:2;
-        u8 hsync_pulse_width_hi:2;
-        u8 hsync_offset_hi:2;
+        u8 vsync_offset_pulse_width_lo;
+        u8 hsync_vsync_offset_pulse_width_hi;
         u8 width_mm_lo;
         u8 height_mm_lo;
-        u8 height_mm_hi:4;
-        u8 width_mm_hi:4;
+        u8 width_height_mm_hi;
         u8 hborder;
         u8 vborder;
-        u8 unknown0:1;
-        u8 hsync_positive:1;
-        u8 vsync_positive:1;
-        u8 separate_sync:2;
-        u8 stereo:1;
-        u8 unknown6:1;
-        u8 interlaced:1;
+        u8 misc;
 } __attribute__((packed));
 
 /* If it's not pixel timing, it'll be one of the below */
@@ -88,18 +84,16 @@ struct detailed_data_monitor_range {
         u8 min_hfreq_khz;
         u8 max_hfreq_khz;
         u8 pixel_clock_mhz; /* need to multiply by 10 */
-        u16 sec_gtf_toggle; /* A000=use above, 20=use below */ /* FIXME: byte order */
+        __le16 sec_gtf_toggle; /* A000=use above, 20=use below */
         u8 hfreq_start_khz; /* need to multiply by 2 */
         u8 c; /* need to divide by 2 */
-        u16 m; /* FIXME: byte order */
+        __le16 m;
         u8 k;
         u8 j; /* need to divide by 2 */
 } __attribute__((packed));
 
 struct detailed_data_wpindex {
-        u8 white_y_lo:2;
-        u8 white_x_lo:2;
-        u8 pad:4;
+        u8 white_yx_lo; /* Lower 2 bits each */
         u8 white_x_hi;
         u8 white_y_hi;
         u8 gamma; /* need to divide by 100 then add 1 */
@@ -134,13 +128,29 @@ struct detailed_non_pixel {
 #define EDID_DETAIL_MONITOR_SERIAL 0xff
 
 struct detailed_timing {
-        u16 pixel_clock; /* need to multiply by 10 KHz */ /* FIXME: byte order */
+        __le16 pixel_clock; /* need to multiply by 10 KHz */
         union {
                 struct detailed_pixel_timing pixel_data;
                 struct detailed_non_pixel other_data;
         } data;
 } __attribute__((packed));
 
+#define DRM_EDID_INPUT_SERRATION_VSYNC (1 << 0)
+#define DRM_EDID_INPUT_SYNC_ON_GREEN   (1 << 1)
+#define DRM_EDID_INPUT_COMPOSITE_SYNC  (1 << 2)
+#define DRM_EDID_INPUT_SEPARATE_SYNCS  (1 << 3)
+#define DRM_EDID_INPUT_BLANK_TO_BLACK  (1 << 4)
+#define DRM_EDID_INPUT_VIDEO_LEVEL     (3 << 5)
+#define DRM_EDID_INPUT_DIGITAL         (1 << 7) /* bits below must be zero if set */
+
+#define DRM_EDID_FEATURE_DEFAULT_GTF      (1 << 0)
+#define DRM_EDID_FEATURE_PREFERRED_TIMING (1 << 1)
+#define DRM_EDID_FEATURE_STANDARD_COLOR   (1 << 2)
+#define DRM_EDID_FEATURE_DISPLAY_TYPE     (3 << 3) /* 00=mono, 01=rgb, 10=non-rgb, 11=unknown */
+#define DRM_EDID_FEATURE_PM_ACTIVE_OFF    (1 << 5)
+#define DRM_EDID_FEATURE_PM_SUSPEND       (1 << 6)
+#define DRM_EDID_FEATURE_PM_STANDBY       (1 << 7)
+
 struct edid {
         u8 header[8];
         /* Vendor & product info */
@@ -153,25 +163,11 @@ struct edid {
         u8 version;
         u8 revision;
         /* Display info: */
-        /*   input definition */
-        u8 serration_vsync:1;
-        u8 sync_on_green:1;
-        u8 composite_sync:1;
-        u8 separate_syncs:1;
-        u8 blank_to_black:1;
-        u8 video_level:2;
-        u8 digital:1; /* bits below must be zero if set */
+        u8 input;
         u8 width_cm;
         u8 height_cm;
         u8 gamma;
-        /*   feature support */
-        u8 default_gtf:1;
-        u8 preferred_timing:1;
-        u8 standard_color:1;
-        u8 display_type:2; /* 00=mono, 01=rgb, 10=non-rgb, 11=unknown */
-        u8 pm_active_off:1;
-        u8 pm_suspend:1;
-        u8 pm_standby:1;
+        u8 features;
         /* Color characteristics */
         u8 red_green_lo;
         u8 black_white_lo;
@@ -195,8 +191,6 @@ struct edid {
         u8 checksum;
 } __attribute__((packed));
 
-#endif /* little endian structs */
-
 #define EDID_PRODUCT_ID(e) ((e)->prod_code[0] | ((e)->prod_code[1] << 8))
 
 #endif /* __DRM_EDID_H__ */
diff --git a/include/drm/drm_hashtab.h b/include/drm/drm_hashtab.h
index cd2b189e1be6..0af087a4d3b3 100644
--- a/include/drm/drm_hashtab.h
+++ b/include/drm/drm_hashtab.h
@@ -35,6 +35,8 @@
 #ifndef DRM_HASHTAB_H
 #define DRM_HASHTAB_H
 
+#include <linux/list.h>
+
 #define drm_hash_entry(_ptr, _type, _member) container_of(_ptr, _type, _member)
 
 struct drm_hash_item {
diff --git a/include/drm/drm_memory_debug.h b/include/drm/drm_memory_debug.h
deleted file mode 100644
index 6463271deea8..000000000000
--- a/include/drm/drm_memory_debug.h
+++ /dev/null
@@ -1,309 +0,0 @@
-/**
- * \file drm_memory_debug.h
- * Memory management wrappers for DRM.
- *
- * \author Rickard E. (Rik) Faith <faith@valinux.com>
- * \author Gareth Hughes <gareth@valinux.com>
- */
-
-/*
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "drmP.h"
-
-typedef struct drm_mem_stats {
-        const char *name;
-        int succeed_count;
-        int free_count;
-        int fail_count;
-        unsigned long bytes_allocated;
-        unsigned long bytes_freed;
-} drm_mem_stats_t;
-
-static DEFINE_SPINLOCK(drm_mem_lock);
-static unsigned long drm_ram_available = 0;     /* In pages */
-static unsigned long drm_ram_used = 0;
-static drm_mem_stats_t drm_mem_stats[] =
-{
-        [DRM_MEM_DMA] = {"dmabufs"},
-        [DRM_MEM_SAREA] = {"sareas"},
-        [DRM_MEM_DRIVER] = {"driver"},
-        [DRM_MEM_MAGIC] = {"magic"},
-        [DRM_MEM_IOCTLS] = {"ioctltab"},
-        [DRM_MEM_MAPS] = {"maplist"},
-        [DRM_MEM_VMAS] = {"vmalist"},
-        [DRM_MEM_BUFS] = {"buflist"},
-        [DRM_MEM_SEGS] = {"seglist"},
-        [DRM_MEM_PAGES] = {"pagelist"},
-        [DRM_MEM_FILES] = {"files"},
-        [DRM_MEM_QUEUES] = {"queues"},
-        [DRM_MEM_CMDS] = {"commands"},
-        [DRM_MEM_MAPPINGS] = {"mappings"},
-        [DRM_MEM_BUFLISTS] = {"buflists"},
-        [DRM_MEM_AGPLISTS] = {"agplist"},
-        [DRM_MEM_SGLISTS] = {"sglist"},
-        [DRM_MEM_TOTALAGP] = {"totalagp"},
-        [DRM_MEM_BOUNDAGP] = {"boundagp"},
-        [DRM_MEM_CTXBITMAP] = {"ctxbitmap"},
-        [DRM_MEM_CTXLIST] = {"ctxlist"},
-        [DRM_MEM_STUB] = {"stub"},
-        {NULL, 0,}              /* Last entry must be null */
-};
-
-void drm_mem_init (void) {
-        drm_mem_stats_t *mem;
-        struct sysinfo si;
-
-        for (mem = drm_mem_stats; mem->name; ++mem) {
-                mem->succeed_count = 0;
-                mem->free_count = 0;
-                mem->fail_count = 0;
-                mem->bytes_allocated = 0;
-                mem->bytes_freed = 0;
-        }
-
-        si_meminfo(&si);
-        drm_ram_available = si.totalram;
-        drm_ram_used = 0;
-}
-
-/* drm_mem_info is called whenever a process reads /dev/drm/mem. */
-
-static int drm__mem_info (char *buf, char **start, off_t offset,
-                           int request, int *eof, void *data) {
-        drm_mem_stats_t *pt;
-        int len = 0;
-
-        if (offset > DRM_PROC_LIMIT) {
-                *eof = 1;
-                return 0;
-        }
-
-        *eof = 0;
-        *start = &buf[offset];
-
-        DRM_PROC_PRINT("                  total counts                  "
-                       " |    outstanding  \n");
-        DRM_PROC_PRINT("type       alloc freed fail     bytes      freed"
-                       " | allocs      bytes\n\n");
-        DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB         |\n",
-                       "system", 0, 0, 0,
-                       drm_ram_available << (PAGE_SHIFT - 10));
-        DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu kB         |\n",
-                       "locked", 0, 0, 0, drm_ram_used >> 10);
-        DRM_PROC_PRINT("\n");
-        for (pt = drm_mem_stats; pt->name; pt++) {
-                DRM_PROC_PRINT("%-9.9s %5d %5d %4d %10lu %10lu | %6d %10ld\n",
-                               pt->name,
-                               pt->succeed_count,
-                               pt->free_count,
-                               pt->fail_count,
-                               pt->bytes_allocated,
-                               pt->bytes_freed,
-                               pt->succeed_count - pt->free_count,
-                               (long)pt->bytes_allocated
-                               - (long)pt->bytes_freed);
-        }
-
-        if (len > request + offset)
-                return request;
-        *eof = 1;
-        return len - offset;
-}
-
-int drm_mem_info (char *buf, char **start, off_t offset,
-                   int len, int *eof, void *data) {
-        int ret;
-
-        spin_lock(&drm_mem_lock);
-        ret = drm__mem_info (buf, start, offset, len, eof, data);
-        spin_unlock(&drm_mem_lock);
-        return ret;
-}
-
-void *drm_alloc (size_t size, int area) {
-        void *pt;
-
-        if (!size) {
-                DRM_MEM_ERROR(area, "Allocating 0 bytes\n");
-                return NULL;
-        }
-
-        if (!(pt = kmalloc(size, GFP_KERNEL))) {
-                spin_lock(&drm_mem_lock);
-                ++drm_mem_stats[area].fail_count;
-                spin_unlock(&drm_mem_lock);
-                return NULL;
-        }
-        spin_lock(&drm_mem_lock);
-        ++drm_mem_stats[area].succeed_count;
-        drm_mem_stats[area].bytes_allocated += size;
-        spin_unlock(&drm_mem_lock);
-        return pt;
-}
-
-void *drm_calloc (size_t nmemb, size_t size, int area) {
-        void *addr;
-
-        addr = drm_alloc (nmemb * size, area);
-        if (addr != NULL)
-                memset((void *)addr, 0, size * nmemb);
-
-        return addr;
-}
-
-void *drm_realloc (void *oldpt, size_t oldsize, size_t size, int area) {
-        void *pt;
-
-        if (!(pt = drm_alloc (size, area)))
-                return NULL;
-        if (oldpt && oldsize) {
-                memcpy(pt, oldpt, oldsize);
-                drm_free (oldpt, oldsize, area);
-        }
-        return pt;
-}
-
-void drm_free (void *pt, size_t size, int area) {
-        int alloc_count;
-        int free_count;
-
-        if (!pt)
-                DRM_MEM_ERROR(area, "Attempt to free NULL pointer\n");
-        else
-                kfree(pt);
-        spin_lock(&drm_mem_lock);
-        drm_mem_stats[area].bytes_freed += size;
-        free_count = ++drm_mem_stats[area].free_count;
-        alloc_count = drm_mem_stats[area].succeed_count;
-        spin_unlock(&drm_mem_lock);
-        if (free_count > alloc_count) {
-                DRM_MEM_ERROR(area, "Excess frees: %d frees, %d allocs\n",
-                              free_count, alloc_count);
-        }
-}
-
-#if __OS_HAS_AGP
-
-DRM_AGP_MEM *drm_alloc_agp (drm_device_t *dev, int pages, u32 type) {
-        DRM_AGP_MEM *handle;
-
-        if (!pages) {
-                DRM_MEM_ERROR(DRM_MEM_TOTALAGP, "Allocating 0 pages\n");
-                return NULL;
-        }
-
-        if ((handle = drm_agp_allocate_memory (pages, type))) {
-                spin_lock(&drm_mem_lock);
-                ++drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count;
-                drm_mem_stats[DRM_MEM_TOTALAGP].bytes_allocated
-                    += pages << PAGE_SHIFT;
-                spin_unlock(&drm_mem_lock);
-                return handle;
-        }
-        spin_lock(&drm_mem_lock);
-        ++drm_mem_stats[DRM_MEM_TOTALAGP].fail_count;
-        spin_unlock(&drm_mem_lock);
-        return NULL;
-}
-
-int drm_free_agp (DRM_AGP_MEM * handle, int pages) {
-        int alloc_count;
-        int free_count;
-        int retval = -EINVAL;
-
-        if (!handle) {
-                DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
-                              "Attempt to free NULL AGP handle\n");
-                return retval;
-        }
-
-        if (drm_agp_free_memory (handle)) {
-                spin_lock(&drm_mem_lock);
-                free_count = ++drm_mem_stats[DRM_MEM_TOTALAGP].free_count;
-                alloc_count = drm_mem_stats[DRM_MEM_TOTALAGP].succeed_count;
-                drm_mem_stats[DRM_MEM_TOTALAGP].bytes_freed
-                    += pages << PAGE_SHIFT;
-                spin_unlock(&drm_mem_lock);
-                if (free_count > alloc_count) {
-                        DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
-                                      "Excess frees: %d frees, %d allocs\n",
-                                      free_count, alloc_count);
-                }
-                return 0;
-        }
-        return retval;
-}
-
-int drm_bind_agp (DRM_AGP_MEM * handle, unsigned int start) {
-        int retcode = -EINVAL;
-
-        if (!handle) {
-                DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-                              "Attempt to bind NULL AGP handle\n");
-                return retcode;
-        }
-
-        if (!(retcode = drm_agp_bind_memory (handle, start))) {
-                spin_lock(&drm_mem_lock);
-                ++drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count;
-                drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_allocated
-                    += handle->page_count << PAGE_SHIFT;
-                spin_unlock(&drm_mem_lock);
-                return retcode;
-        }
-        spin_lock(&drm_mem_lock);
-        ++drm_mem_stats[DRM_MEM_BOUNDAGP].fail_count;
-        spin_unlock(&drm_mem_lock);
-        return retcode;
-}
-
-int drm_unbind_agp (DRM_AGP_MEM * handle) {
-        int alloc_count;
-        int free_count;
-        int retcode = -EINVAL;
-
-        if (!handle) {
-                DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-                              "Attempt to unbind NULL AGP handle\n");
-                return retcode;
-        }
-
-        if ((retcode = drm_agp_unbind_memory (handle)))
-                return retcode;
-        spin_lock(&drm_mem_lock);
-        free_count = ++drm_mem_stats[DRM_MEM_BOUNDAGP].free_count;
-        alloc_count = drm_mem_stats[DRM_MEM_BOUNDAGP].succeed_count;
-        drm_mem_stats[DRM_MEM_BOUNDAGP].bytes_freed
-            += handle->page_count << PAGE_SHIFT;
-        spin_unlock(&drm_mem_lock);
-        if (free_count > alloc_count) {
-                DRM_MEM_ERROR(DRM_MEM_BOUNDAGP,
-                              "Excess frees: %d frees, %d allocs\n",
-                              free_count, alloc_count);
-        }
-        return retcode;
-}
-#endif
diff --git a/include/drm/drm_mm.h b/include/drm/drm_mm.h
new file mode 100644
index 000000000000..f8332073d277
--- /dev/null
+++ b/include/drm/drm_mm.h
@@ -0,0 +1,99 @@
+/**************************************************************************
+ *
+ * Copyright 2006-2008 Tungsten Graphics, Inc., Cedar Park, TX. USA.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ *
+ **************************************************************************/
+/*
+ * Authors:
+ * Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
+ */
+
+#ifndef _DRM_MM_H_
+#define _DRM_MM_H_
+
+/*
+ * Generic range manager structs
+ */
+#include <linux/list.h>
+
+struct drm_mm_node {
+        struct list_head fl_entry;
+        struct list_head ml_entry;
+        int free;
+        unsigned long start;
+        unsigned long size;
+        struct drm_mm *mm;
+        void *private;
+};
+
+struct drm_mm {
+        struct list_head fl_entry;
+        struct list_head ml_entry;
+        struct list_head unused_nodes;
+        int num_unused;
+        spinlock_t unused_lock;
+};
+
+/*
+ * Basic range manager support (drm_mm.c)
+ */
+extern struct drm_mm_node *drm_mm_get_block_generic(struct drm_mm_node *node,
+                                                    unsigned long size,
+                                                    unsigned alignment,
+                                                    int atomic);
+static inline struct drm_mm_node *drm_mm_get_block(struct drm_mm_node *parent,
+                                                   unsigned long size,
+                                                   unsigned alignment)
+{
+        return drm_mm_get_block_generic(parent, size, alignment, 0);
+}
+static inline struct drm_mm_node *drm_mm_get_block_atomic(struct drm_mm_node *parent,
+                                                          unsigned long size,
+                                                          unsigned alignment)
+{
+        return drm_mm_get_block_generic(parent, size, alignment, 1);
+}
+extern void drm_mm_put_block(struct drm_mm_node *cur);
+extern struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm,
+                                              unsigned long size,
+                                              unsigned alignment,
+                                              int best_match);
+extern int drm_mm_init(struct drm_mm *mm, unsigned long start,
+                       unsigned long size);
+extern void drm_mm_takedown(struct drm_mm *mm);
+extern int drm_mm_clean(struct drm_mm *mm);
+extern unsigned long drm_mm_tail_space(struct drm_mm *mm);
+extern int drm_mm_remove_space_from_tail(struct drm_mm *mm,
+                                         unsigned long size);
+extern int drm_mm_add_space_to_tail(struct drm_mm *mm,
+                                    unsigned long size, int atomic);
+extern int drm_mm_pre_get(struct drm_mm *mm);
+
+static inline struct drm_mm *drm_get_mm(struct drm_mm_node *block)
+{
+        return block->mm;
+}
+
+#endif
diff --git a/include/drm/drm_pciids.h b/include/drm/drm_pciids.h
index fc55db780199..853508499d20 100644
--- a/include/drm/drm_pciids.h
+++ b/include/drm/drm_pciids.h
@@ -43,6 +43,7 @@
         {0x1002, 0x4A4F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x4A50, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x4A54, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x4B48, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x4B49, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x4B4A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x4B4B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R420|RADEON_NEW_MEMMAP}, \
@@ -254,9 +255,18 @@
         {0x1002, 0x940A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R600|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x940B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R600|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x940F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R600|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x94A0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV740|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x94A1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV740|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x94A3, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV740|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x94B1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV740|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x94B3, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV740|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x94B4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV740|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x94B5, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV740|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x94B9, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV740|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9440, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9441, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9442, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x9443, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9444, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9446, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x944A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
@@ -268,6 +278,8 @@
         {0x1002, 0x9456, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x945A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x945B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x9460, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x9462, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x946A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x946B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x947A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV770|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
@@ -279,6 +291,7 @@
         {0x1002, 0x948F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV730|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9490, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV730|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9491, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV730|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x9495, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV730|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9498, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV730|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x949C, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV730|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x949E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV730|RADEON_NEW_MEMMAP}, \
@@ -316,6 +329,7 @@
         {0x1002, 0x9552, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV710|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9553, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV710|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9555, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV710|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x9557, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV710|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9580, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV630|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9581, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV630|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x9583, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV630|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
@@ -339,12 +353,12 @@
         {0x1002, 0x9599, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV635|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x959B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV635|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x95C0, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x95C2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x95C4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x95C5, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x95C6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x95C7, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x95C9, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x95C2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x95C4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x95CC, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x95CD, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x95CE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV620|RADEON_NEW_MEMMAP}, \
@@ -356,6 +370,11 @@
         {0x1002, 0x9614, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS780|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
         {0x1002, 0x9615, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS780|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
         {0x1002, 0x9616, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS780|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+        {0x1002, 0x9710, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+        {0x1002, 0x9711, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+        {0x1002, 0x9712, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+        {0x1002, 0x9713, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
+        {0x1002, 0x9714, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS880|RADEON_NEW_MEMMAP|RADEON_IS_IGP}, \
         {0, 0, 0}
 
 #define r128_PCI_IDS \
@@ -536,4 +555,6 @@
         {0x8086, 0xa001, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, 0xffff00, 0}, \
         {0x8086, 0xa011, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, 0xffff00, 0}, \
         {0x8086, 0x35e8, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, 0xffff00, 0}, \
+        {0x8086, 0x0042, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, 0xffff00, 0}, \
+        {0x8086, 0x0046, PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_DISPLAY_VGA << 8, 0xffff00, 0}, \
         {0, 0, 0}
diff --git a/include/drm/radeon_drm.h b/include/drm/radeon_drm.h
index fe3e3a4b4aed..af4b4826997e 100644
--- a/include/drm/radeon_drm.h
+++ b/include/drm/radeon_drm.h
@@ -496,6 +496,18 @@ typedef struct {
 #define DRM_RADEON_SETPARAM   0x19
 #define DRM_RADEON_SURF_ALLOC 0x1a
 #define DRM_RADEON_SURF_FREE  0x1b
+/* KMS ioctl */
+#define DRM_RADEON_GEM_INFO             0x1c
+#define DRM_RADEON_GEM_CREATE           0x1d
+#define DRM_RADEON_GEM_MMAP             0x1e
+#define DRM_RADEON_GEM_PREAD            0x21
+#define DRM_RADEON_GEM_PWRITE           0x22
+#define DRM_RADEON_GEM_SET_DOMAIN       0x23
+#define DRM_RADEON_GEM_WAIT_IDLE        0x24
+#define DRM_RADEON_CS                   0x26
+#define DRM_RADEON_INFO                 0x27
+#define DRM_RADEON_GEM_SET_TILING       0x28
+#define DRM_RADEON_GEM_GET_TILING       0x29
 
 #define DRM_IOCTL_RADEON_CP_INIT    DRM_IOW( DRM_COMMAND_BASE + DRM_RADEON_CP_INIT, drm_radeon_init_t)
 #define DRM_IOCTL_RADEON_CP_START   DRM_IO(  DRM_COMMAND_BASE + DRM_RADEON_CP_START)
@@ -524,6 +536,18 @@ typedef struct {
 #define DRM_IOCTL_RADEON_SETPARAM   DRM_IOW( DRM_COMMAND_BASE + DRM_RADEON_SETPARAM, drm_radeon_setparam_t)
 #define DRM_IOCTL_RADEON_SURF_ALLOC DRM_IOW( DRM_COMMAND_BASE + DRM_RADEON_SURF_ALLOC, drm_radeon_surface_alloc_t)
 #define DRM_IOCTL_RADEON_SURF_FREE  DRM_IOW( DRM_COMMAND_BASE + DRM_RADEON_SURF_FREE, drm_radeon_surface_free_t)
+/* KMS */
+#define DRM_IOCTL_RADEON_GEM_INFO       DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_INFO, struct drm_radeon_gem_info)
+#define DRM_IOCTL_RADEON_GEM_CREATE     DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_CREATE, struct drm_radeon_gem_create)
+#define DRM_IOCTL_RADEON_GEM_MMAP       DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_MMAP, struct drm_radeon_gem_mmap)
+#define DRM_IOCTL_RADEON_GEM_PREAD      DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_PREAD, struct drm_radeon_gem_pread)
+#define DRM_IOCTL_RADEON_GEM_PWRITE     DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_PWRITE, struct drm_radeon_gem_pwrite)
+#define DRM_IOCTL_RADEON_GEM_SET_DOMAIN DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_SET_DOMAIN, struct drm_radeon_gem_set_domain)
+#define DRM_IOCTL_RADEON_GEM_WAIT_IDLE  DRM_IOW(DRM_COMMAND_BASE + DRM_RADEON_GEM_WAIT_IDLE, struct drm_radeon_gem_wait_idle)
+#define DRM_IOCTL_RADEON_CS             DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_CS, struct drm_radeon_cs)
+#define DRM_IOCTL_RADEON_INFO           DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_INFO, struct drm_radeon_info)
+#define DRM_IOCTL_RADEON_SET_TILING     DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_SET_TILING, struct drm_radeon_gem_set_tiling)
+#define DRM_IOCTL_RADEON_GET_TILING     DRM_IOWR(DRM_COMMAND_BASE + DRM_RADEON_GEM_GET_TILING, struct drm_radeon_gem_get_tiling)
 
 typedef struct drm_radeon_init {
         enum {
@@ -682,6 +706,7 @@ typedef struct drm_radeon_indirect {
 #define RADEON_PARAM_VBLANK_CRTC           13   /* VBLANK CRTC */
 #define RADEON_PARAM_FB_LOCATION           14   /* FB location */
 #define RADEON_PARAM_NUM_GB_PIPES          15   /* num GB pipes */
+#define RADEON_PARAM_DEVICE_ID             16
 
 typedef struct drm_radeon_getparam {
         int param;
@@ -751,4 +776,130 @@ typedef struct drm_radeon_surface_free {
 #define DRM_RADEON_VBLANK_CRTC1         1
 #define DRM_RADEON_VBLANK_CRTC2         2
 
+/*
+ * Kernel modesetting world below.
+ */
+#define RADEON_GEM_DOMAIN_CPU           0x1
+#define RADEON_GEM_DOMAIN_GTT           0x2
+#define RADEON_GEM_DOMAIN_VRAM          0x4
+
+struct drm_radeon_gem_info {
+        uint64_t        gart_size;
+        uint64_t        vram_size;
+        uint64_t        vram_visible;
+};
+
+#define RADEON_GEM_NO_BACKING_STORE 1
+
+struct drm_radeon_gem_create {
+        uint64_t        size;
+        uint64_t        alignment;
+        uint32_t        handle;
+        uint32_t        initial_domain;
+        uint32_t        flags;
+};
+
+#define RADEON_TILING_MACRO 0x1
+#define RADEON_TILING_MICRO 0x2
+#define RADEON_TILING_SWAP  0x4
+#define RADEON_TILING_SURFACE  0x8 /* this object requires a surface
+                                    * when mapped - i.e. front buffer */
+
+struct drm_radeon_gem_set_tiling {
+        uint32_t        handle;
+        uint32_t        tiling_flags;
+        uint32_t        pitch;
+};
+
+struct drm_radeon_gem_get_tiling {
+        uint32_t        handle;
+        uint32_t        tiling_flags;
+        uint32_t        pitch;
+};
+
+struct drm_radeon_gem_mmap {
+        uint32_t        handle;
+        uint32_t        pad;
+        uint64_t        offset;
+        uint64_t        size;
+        uint64_t        addr_ptr;
+};
+
+struct drm_radeon_gem_set_domain {
+        uint32_t        handle;
+        uint32_t        read_domains;
+        uint32_t        write_domain;
+};
+
+struct drm_radeon_gem_wait_idle {
+        uint32_t        handle;
+        uint32_t        pad;
+};
+
+struct drm_radeon_gem_busy {
+        uint32_t        handle;
+        uint32_t        busy;
+};
+
+struct drm_radeon_gem_pread {
+        /** Handle for the object being read. */
+        uint32_t handle;
+        uint32_t pad;
+        /** Offset into the object to read from */
+        uint64_t offset;
+        /** Length of data to read */
+        uint64_t size;
+        /** Pointer to write the data into. */
+        /* void *, but pointers are not 32/64 compatible */
+        uint64_t data_ptr;
+};
+
+struct drm_radeon_gem_pwrite {
+        /** Handle for the object being written to. */
+        uint32_t handle;
+        uint32_t pad;
+        /** Offset into the object to write to */
+        uint64_t offset;
+        /** Length of data to write */
+        uint64_t size;
+        /** Pointer to read the data from. */
+        /* void *, but pointers are not 32/64 compatible */
+        uint64_t data_ptr;
+};
+
+#define RADEON_CHUNK_ID_RELOCS  0x01
+#define RADEON_CHUNK_ID_IB      0x02
+
+struct drm_radeon_cs_chunk {
+        uint32_t                chunk_id;
+        uint32_t                length_dw;
+        uint64_t                chunk_data;
+};
+
+struct drm_radeon_cs_reloc {
+        uint32_t                handle;
+        uint32_t                read_domains;
+        uint32_t                write_domain;
+        uint32_t                flags;
+};
+
+struct drm_radeon_cs {
+        uint32_t                num_chunks;
+        uint32_t                cs_id;
+        /* this points to uint64_t * which point to cs chunks */
+        uint64_t                chunks;
+        /* updates to the limits after this CS ioctl */
+        uint64_t                gart_limit;
+        uint64_t                vram_limit;
+};
+
+#define RADEON_INFO_DEVICE_ID           0x00
+#define RADEON_INFO_NUM_GB_PIPES        0x01
+
+struct drm_radeon_info {
+        uint32_t                request;
+        uint32_t                pad;
+        uint64_t                value;
+};
+
 #endif
diff --git a/include/drm/ttm/ttm_bo_api.h b/include/drm/ttm/ttm_bo_api.h
new file mode 100644
index 000000000000..cd22ab4b495c
--- /dev/null
+++ b/include/drm/ttm/ttm_bo_api.h
@@ -0,0 +1,618 @@
+/**************************************************************************
+ *
+ * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+/*
+ * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
+ */
+
+#ifndef _TTM_BO_API_H_
+#define _TTM_BO_API_H_
+
+#include "drm_hashtab.h"
+#include <linux/kref.h>
+#include <linux/list.h>
+#include <linux/wait.h>
+#include <linux/mutex.h>
+#include <linux/mm.h>
+#include <linux/rbtree.h>
+#include <linux/bitmap.h>
+
+struct ttm_bo_device;
+
+struct drm_mm_node;
+
+/**
+ * struct ttm_mem_reg
+ *
+ * @mm_node: Memory manager node.
+ * @size: Requested size of memory region.
+ * @num_pages: Actual size of memory region in pages.
+ * @page_alignment: Page alignment.
+ * @placement: Placement flags.
+ *
+ * Structure indicating the placement and space resources used by a
+ * buffer object.
+ */
+
+struct ttm_mem_reg {
+        struct drm_mm_node *mm_node;
+        unsigned long size;
+        unsigned long num_pages;
+        uint32_t page_alignment;
+        uint32_t mem_type;
+        uint32_t placement;
+};
+
+/**
+ * enum ttm_bo_type
+ *
+ * @ttm_bo_type_device: These are 'normal' buffers that can
+ * be mmapped by user space. Each of these bos occupy a slot in the
+ * device address space, that can be used for normal vm operations.
+ *
+ * @ttm_bo_type_user: These are user-space memory areas that are made
+ * available to the GPU by mapping the buffer pages into the GPU aperture
+ * space. These buffers cannot be mmaped from the device address space.
+ *
+ * @ttm_bo_type_kernel: These buffers are like ttm_bo_type_device buffers,
+ * but they cannot be accessed from user-space. For kernel-only use.
+ */
+
+enum ttm_bo_type {
+        ttm_bo_type_device,
+        ttm_bo_type_user,
+        ttm_bo_type_kernel
+};
+
+struct ttm_tt;
+
+/**
+ * struct ttm_buffer_object
+ *
+ * @bdev: Pointer to the buffer object device structure.
+ * @buffer_start: The virtual user-space start address of ttm_bo_type_user
+ * buffers.
+ * @type: The bo type.
+ * @destroy: Destruction function. If NULL, kfree is used.
+ * @num_pages: Actual number of pages.
+ * @addr_space_offset: Address space offset.
+ * @acc_size: Accounted size for this object.
+ * @kref: Reference count of this buffer object. When this refcount reaches
+ * zero, the object is put on the delayed delete list.
+ * @list_kref: List reference count of this buffer object. This member is
+ * used to avoid destruction while the buffer object is still on a list.
+ * Lru lists may keep one refcount, the delayed delete list, and kref != 0
+ * keeps one refcount. When this refcount reaches zero,
+ * the object is destroyed.
+ * @event_queue: Queue for processes waiting on buffer object status change.
+ * @lock: spinlock protecting mostly synchronization members.
+ * @proposed_placement: Proposed placement for the buffer. Changed only by the
+ * creator prior to validation as opposed to bo->mem.proposed_flags which is
+ * changed by the implementation prior to a buffer move if it wants to outsmart
+ * the buffer creator / user. This latter happens, for example, at eviction.
+ * @mem: structure describing current placement.
+ * @persistant_swap_storage: Usually the swap storage is deleted for buffers
+ * pinned in physical memory. If this behaviour is not desired, this member
+ * holds a pointer to a persistant shmem object.
+ * @ttm: TTM structure holding system pages.
+ * @evicted: Whether the object was evicted without user-space knowing.
+ * @cpu_writes: For synchronization. Number of cpu writers.
+ * @lru: List head for the lru list.
+ * @ddestroy: List head for the delayed destroy list.
+ * @swap: List head for swap LRU list.
+ * @val_seq: Sequence of the validation holding the @reserved lock.
+ * Used to avoid starvation when many processes compete to validate the
+ * buffer. This member is protected by the bo_device::lru_lock.
+ * @seq_valid: The value of @val_seq is valid. This value is protected by
+ * the bo_device::lru_lock.
+ * @reserved: Deadlock-free lock used for synchronization state transitions.
+ * @sync_obj_arg: Opaque argument to synchronization object function.
+ * @sync_obj: Pointer to a synchronization object.
+ * @priv_flags: Flags describing buffer object internal state.
+ * @vm_rb: Rb node for the vm rb tree.
+ * @vm_node: Address space manager node.
+ * @offset: The current GPU offset, which can have different meanings
+ * depending on the memory type. For SYSTEM type memory, it should be 0.
+ * @cur_placement: Hint of current placement.
+ *
+ * Base class for TTM buffer object, that deals with data placement and CPU
+ * mappings. GPU mappings are really up to the driver, but for simpler GPUs
+ * the driver can usually use the placement offset @offset directly as the
+ * GPU virtual address. For drivers implementing multiple
+ * GPU memory manager contexts, the driver should manage the address space
+ * in these contexts separately and use these objects to get the correct
+ * placement and caching for these GPU maps. This makes it possible to use
+ * these objects for even quite elaborate memory management schemes.
+ * The destroy member, the API visibility of this object makes it possible
+ * to derive driver specific types.
+ */
+
+struct ttm_buffer_object {
+        /**
+         * Members constant at init.
+         */
+
+        struct ttm_bo_device *bdev;
+        unsigned long buffer_start;
+        enum ttm_bo_type type;
+        void (*destroy) (struct ttm_buffer_object *);
+        unsigned long num_pages;
+        uint64_t addr_space_offset;
+        size_t acc_size;
+
+        /**
+        * Members not needing protection.
+        */
+
+        struct kref kref;
+        struct kref list_kref;
+        wait_queue_head_t event_queue;
+        spinlock_t lock;
+
+        /**
+         * Members protected by the bo::reserved lock.
+         */
+
+        uint32_t proposed_placement;
+        struct ttm_mem_reg mem;
+        struct file *persistant_swap_storage;
+        struct ttm_tt *ttm;
+        bool evicted;
+
+        /**
+         * Members protected by the bo::reserved lock only when written to.
+         */
+
+        atomic_t cpu_writers;
+
+        /**
+         * Members protected by the bdev::lru_lock.
+         */
+
+        struct list_head lru;
+        struct list_head ddestroy;
+        struct list_head swap;
+        uint32_t val_seq;
+        bool seq_valid;
+
+        /**
+         * Members protected by the bdev::lru_lock
+         * only when written to.
+         */
+
+        atomic_t reserved;
+
+
+        /**
+         * Members protected by the bo::lock
+         */
+
+        void *sync_obj_arg;
+        void *sync_obj;
+        unsigned long priv_flags;
+
+        /**
+         * Members protected by the bdev::vm_lock
+         */
+
+        struct rb_node vm_rb;
+        struct drm_mm_node *vm_node;
+
+
+        /**
+         * Special members that are protected by the reserve lock
+         * and the bo::lock when written to. Can be read with
+         * either of these locks held.
+         */
+
+        unsigned long offset;
+        uint32_t cur_placement;
+};
+
+/**
+ * struct ttm_bo_kmap_obj
+ *
+ * @virtual: The current kernel virtual address.
+ * @page: The page when kmap'ing a single page.
+ * @bo_kmap_type: Type of bo_kmap.
+ *
+ * Object describing a kernel mapping. Since a TTM bo may be located
+ * in various memory types with various caching policies, the
+ * mapping can either be an ioremap, a vmap, a kmap or part of a
+ * premapped region.
+ */
+
+struct ttm_bo_kmap_obj {
+        void *virtual;
+        struct page *page;
+        enum {
+                ttm_bo_map_iomap,
+                ttm_bo_map_vmap,
+                ttm_bo_map_kmap,
+                ttm_bo_map_premapped,
+        } bo_kmap_type;
+};
+
+/**
+ * ttm_bo_reference - reference a struct ttm_buffer_object
+ *
+ * @bo: The buffer object.
+ *
+ * Returns a refcounted pointer to a buffer object.
+ */
+
+static inline struct ttm_buffer_object *
+ttm_bo_reference(struct ttm_buffer_object *bo)
+{
+        kref_get(&bo->kref);
+        return bo;
+}
+
+/**
+ * ttm_bo_wait - wait for buffer idle.
+ *
+ * @bo:  The buffer object.
+ * @interruptible:  Use interruptible wait.
+ * @no_wait:  Return immediately if buffer is busy.
+ *
+ * This function must be called with the bo::mutex held, and makes
+ * sure any previous rendering to the buffer is completed.
+ * Note: It might be necessary to block validations before the
+ * wait by reserving the buffer.
+ * Returns -EBUSY if no_wait is true and the buffer is busy.
+ * Returns -ERESTART if interrupted by a signal.
+ */
+extern int ttm_bo_wait(struct ttm_buffer_object *bo, bool lazy,
+                       bool interruptible, bool no_wait);
+/**
+ * ttm_buffer_object_validate
+ *
+ * @bo: The buffer object.
+ * @proposed_placement: Proposed_placement for the buffer object.
+ * @interruptible: Sleep interruptible if sleeping.
+ * @no_wait: Return immediately if the buffer is busy.
+ *
+ * Changes placement and caching policy of the buffer object
+ * according to bo::proposed_flags.
+ * Returns
+ * -EINVAL on invalid proposed_flags.
+ * -ENOMEM on out-of-memory condition.
+ * -EBUSY if no_wait is true and buffer busy.
+ * -ERESTART if interrupted by a signal.
+ */
+extern int ttm_buffer_object_validate(struct ttm_buffer_object *bo,
+                                      uint32_t proposed_placement,
+                                      bool interruptible, bool no_wait);
+/**
+ * ttm_bo_unref
+ *
+ * @bo: The buffer object.
+ *
+ * Unreference and clear a pointer to a buffer object.
+ */
+extern void ttm_bo_unref(struct ttm_buffer_object **bo);
+
+/**
+ * ttm_bo_synccpu_write_grab
+ *
+ * @bo: The buffer object:
+ * @no_wait: Return immediately if buffer is busy.
+ *
+ * Synchronizes a buffer object for CPU RW access. This means
+ * blocking command submission that affects the buffer and
+ * waiting for buffer idle. This lock is recursive.
+ * Returns
+ * -EBUSY if the buffer is busy and no_wait is true.
+ * -ERESTART if interrupted by a signal.
+ */
+
+extern int
+ttm_bo_synccpu_write_grab(struct ttm_buffer_object *bo, bool no_wait);
+/**
+ * ttm_bo_synccpu_write_release:
+ *
+ * @bo : The buffer object.
+ *
+ * Releases a synccpu lock.
+ */
+extern void ttm_bo_synccpu_write_release(struct ttm_buffer_object *bo);
+
+/**
+ * ttm_buffer_object_init
+ *
+ * @bdev: Pointer to a ttm_bo_device struct.
+ * @bo: Pointer to a ttm_buffer_object to be initialized.
+ * @size: Requested size of buffer object.
+ * @type: Requested type of buffer object.
+ * @flags: Initial placement flags.
+ * @page_alignment: Data alignment in pages.
+ * @buffer_start: Virtual address of user space data backing a
+ * user buffer object.
+ * @interruptible: If needing to sleep to wait for GPU resources,
+ * sleep interruptible.
+ * @persistant_swap_storage: Usually the swap storage is deleted for buffers
+ * pinned in physical memory. If this behaviour is not desired, this member
+ * holds a pointer to a persistant shmem object. Typically, this would
+ * point to the shmem object backing a GEM object if TTM is used to back a
+ * GEM user interface.
+ * @acc_size: Accounted size for this object.
+ * @destroy: Destroy function. Use NULL for kfree().
+ *
+ * This function initializes a pre-allocated struct ttm_buffer_object.
+ * As this object may be part of a larger structure, this function,
+ * together with the @destroy function,
+ * enables driver-specific objects derived from a ttm_buffer_object.
+ * On successful return, the object kref and list_kref are set to 1.
+ * Returns
+ * -ENOMEM: Out of memory.
+ * -EINVAL: Invalid placement flags.
+ * -ERESTART: Interrupted by signal while sleeping waiting for resources.
+ */
+
+extern int ttm_buffer_object_init(struct ttm_bo_device *bdev,
+                                  struct ttm_buffer_object *bo,
+                                  unsigned long size,
+                                  enum ttm_bo_type type,
+                                  uint32_t flags,
+                                  uint32_t page_alignment,
+                                  unsigned long buffer_start,
+                                  bool interrubtible,
+                                  struct file *persistant_swap_storage,
+                                  size_t acc_size,
+                                  void (*destroy) (struct ttm_buffer_object *));
+/**
+ * ttm_bo_synccpu_object_init
+ *
+ * @bdev: Pointer to a ttm_bo_device struct.
+ * @bo: Pointer to a ttm_buffer_object to be initialized.
+ * @size: Requested size of buffer object.
+ * @type: Requested type of buffer object.
+ * @flags: Initial placement flags.
+ * @page_alignment: Data alignment in pages.
+ * @buffer_start: Virtual address of user space data backing a
+ * user buffer object.
+ * @interruptible: If needing to sleep while waiting for GPU resources,
+ * sleep interruptible.
+ * @persistant_swap_storage: Usually the swap storage is deleted for buffers
+ * pinned in physical memory. If this behaviour is not desired, this member
+ * holds a pointer to a persistant shmem object. Typically, this would
+ * point to the shmem object backing a GEM object if TTM is used to back a
+ * GEM user interface.
+ * @p_bo: On successful completion *p_bo points to the created object.
+ *
+ * This function allocates a ttm_buffer_object, and then calls
+ * ttm_buffer_object_init on that object.
+ * The destroy function is set to kfree().
+ * Returns
+ * -ENOMEM: Out of memory.
+ * -EINVAL: Invalid placement flags.
+ * -ERESTART: Interrupted by signal while waiting for resources.
+ */
+
+extern int ttm_buffer_object_create(struct ttm_bo_device *bdev,
+                                    unsigned long size,
+                                    enum ttm_bo_type type,
+                                    uint32_t flags,
+                                    uint32_t page_alignment,
+                                    unsigned long buffer_start,
+                                    bool interruptible,
+                                    struct file *persistant_swap_storage,
+                                    struct ttm_buffer_object **p_bo);
+
+/**
+ * ttm_bo_check_placement
+ *
+ * @bo: the buffer object.
+ * @set_flags: placement flags to set.
+ * @clr_flags: placement flags to clear.
+ *
+ * Performs minimal validity checking on an intended change of
+ * placement flags.
+ * Returns
+ * -EINVAL: Intended change is invalid or not allowed.
+ */
+
+extern int ttm_bo_check_placement(struct ttm_buffer_object *bo,
+                                  uint32_t set_flags, uint32_t clr_flags);
+
+/**
+ * ttm_bo_init_mm
+ *
+ * @bdev: Pointer to a ttm_bo_device struct.
+ * @mem_type: The memory type.
+ * @p_offset: offset for managed area in pages.
+ * @p_size: size managed area in pages.
+ *
+ * Initialize a manager for a given memory type.
+ * Note: if part of driver firstopen, it must be protected from a
+ * potentially racing lastclose.
+ * Returns:
+ * -EINVAL: invalid size or memory type.
+ * -ENOMEM: Not enough memory.
+ * May also return driver-specified errors.
+ */
+
+extern int ttm_bo_init_mm(struct ttm_bo_device *bdev, unsigned type,
+                          unsigned long p_offset, unsigned long p_size);
+/**
+ * ttm_bo_clean_mm
+ *
+ * @bdev: Pointer to a ttm_bo_device struct.
+ * @mem_type: The memory type.
+ *
+ * Take down a manager for a given memory type after first walking
+ * the LRU list to evict any buffers left alive.
+ *
+ * Normally, this function is part of lastclose() or unload(), and at that
+ * point there shouldn't be any buffers left created by user-space, since
+ * there should've been removed by the file descriptor release() method.
+ * However, before this function is run, make sure to signal all sync objects,
+ * and verify that the delayed delete queue is empty. The driver must also
+ * make sure that there are no NO_EVICT buffers present in this memory type
+ * when the call is made.
+ *
+ * If this function is part of a VT switch, the caller must make sure that
+ * there are no appications currently validating buffers before this
+ * function is called. The caller can do that by first taking the
+ * struct ttm_bo_device::ttm_lock in write mode.
+ *
+ * Returns:
+ * -EINVAL: invalid or uninitialized memory type.
+ * -EBUSY: There are still buffers left in this memory type.
+ */
+
+extern int ttm_bo_clean_mm(struct ttm_bo_device *bdev, unsigned mem_type);
+
+/**
+ * ttm_bo_evict_mm
+ *
+ * @bdev: Pointer to a ttm_bo_device struct.
+ * @mem_type: The memory type.
+ *
+ * Evicts all buffers on the lru list of the memory type.
+ * This is normally part of a VT switch or an
+ * out-of-memory-space-due-to-fragmentation handler.
+ * The caller must make sure that there are no other processes
+ * currently validating buffers, and can do that by taking the
+ * struct ttm_bo_device::ttm_lock in write mode.
+ *
+ * Returns:
+ * -EINVAL: Invalid or uninitialized memory type.
+ * -ERESTART: The call was interrupted by a signal while waiting to
+ * evict a buffer.
+ */
+
+extern int ttm_bo_evict_mm(struct ttm_bo_device *bdev, unsigned mem_type);
+
+/**
+ * ttm_kmap_obj_virtual
+ *
+ * @map: A struct ttm_bo_kmap_obj returned from ttm_bo_kmap.
+ * @is_iomem: Pointer to an integer that on return indicates 1 if the
+ * virtual map is io memory, 0 if normal memory.
+ *
+ * Returns the virtual address of a buffer object area mapped by ttm_bo_kmap.
+ * If *is_iomem is 1 on return, the virtual address points to an io memory area,
+ * that should strictly be accessed by the iowriteXX() and similar functions.
+ */
+
+static inline void *ttm_kmap_obj_virtual(struct ttm_bo_kmap_obj *map,
+                                         bool *is_iomem)
+{
+        *is_iomem = (map->bo_kmap_type == ttm_bo_map_iomap ||
+                     map->bo_kmap_type == ttm_bo_map_premapped);
+        return map->virtual;
+}
+
+/**
+ * ttm_bo_kmap
+ *
+ * @bo: The buffer object.
+ * @start_page: The first page to map.
+ * @num_pages: Number of pages to map.
+ * @map: pointer to a struct ttm_bo_kmap_obj representing the map.
+ *
+ * Sets up a kernel virtual mapping, using ioremap, vmap or kmap to the
+ * data in the buffer object. The ttm_kmap_obj_virtual function can then be
+ * used to obtain a virtual address to the data.
+ *
+ * Returns
+ * -ENOMEM: Out of memory.
+ * -EINVAL: Invalid range.
+ */
+
+extern int ttm_bo_kmap(struct ttm_buffer_object *bo, unsigned long start_page,
+                       unsigned long num_pages, struct ttm_bo_kmap_obj *map);
+
+/**
+ * ttm_bo_kunmap
+ *
+ * @map: Object describing the map to unmap.
+ *
+ * Unmaps a kernel map set up by ttm_bo_kmap.
+ */
+
+extern void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map);
+
+#if 0
+#endif
+
+/**
+ * ttm_fbdev_mmap - mmap fbdev memory backed by a ttm buffer object.
+ *
+ * @vma:       vma as input from the fbdev mmap method.
+ * @bo:        The bo backing the address space. The address space will
+ * have the same size as the bo, and start at offset 0.
+ *
+ * This function is intended to be called by the fbdev mmap method
+ * if the fbdev address space is to be backed by a bo.
+ */
+
+extern int ttm_fbdev_mmap(struct vm_area_struct *vma,
+                          struct ttm_buffer_object *bo);
+
+/**
+ * ttm_bo_mmap - mmap out of the ttm device address space.
+ *
+ * @filp:      filp as input from the mmap method.
+ * @vma:       vma as input from the mmap method.
+ * @bdev:      Pointer to the ttm_bo_device with the address space manager.
+ *
+ * This function is intended to be called by the device mmap method.
+ * if the device address space is to be backed by the bo manager.
+ */
+
+extern int ttm_bo_mmap(struct file *filp, struct vm_area_struct *vma,
+                       struct ttm_bo_device *bdev);
+
+/**
+ * ttm_bo_io
+ *
+ * @bdev:      Pointer to the struct ttm_bo_device.
+ * @filp:      Pointer to the struct file attempting to read / write.
+ * @wbuf:      User-space pointer to address of buffer to write. NULL on read.
+ * @rbuf:      User-space pointer to address of buffer to read into.
+ * Null on write.
+ * @count:     Number of bytes to read / write.
+ * @f_pos:     Pointer to current file position.
+ * @write:     1 for read, 0 for write.
+ *
+ * This function implements read / write into ttm buffer objects, and is
+ * intended to
+ * be called from the fops::read and fops::write method.
+ * Returns:
+ * See man (2) write, man(2) read. In particular,
+ * the function may return -EINTR if
+ * interrupted by a signal.
+ */
+
+extern ssize_t ttm_bo_io(struct ttm_bo_device *bdev, struct file *filp,
+                         const char __user *wbuf, char __user *rbuf,
+                         size_t count, loff_t *f_pos, bool write);
+
+extern void ttm_bo_swapout_all(struct ttm_bo_device *bdev);
+
+#endif
diff --git a/include/drm/ttm/ttm_bo_driver.h b/include/drm/ttm/ttm_bo_driver.h
new file mode 100644
index 000000000000..a68829db381a
--- /dev/null
+++ b/include/drm/ttm/ttm_bo_driver.h
@@ -0,0 +1,885 @@
+/**************************************************************************
+ *
+ * Copyright (c) 2006-2009 Vmware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+/*
+ * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
+ */
+#ifndef _TTM_BO_DRIVER_H_
+#define _TTM_BO_DRIVER_H_
+
+#include "ttm/ttm_bo_api.h"
+#include "ttm/ttm_memory.h"
+#include "drm_mm.h"
+#include "linux/workqueue.h"
+#include "linux/fs.h"
+#include "linux/spinlock.h"
+
+struct ttm_backend;
+
+struct ttm_backend_func {
+        /**
+         * struct ttm_backend_func member populate
+         *
+         * @backend: Pointer to a struct ttm_backend.
+         * @num_pages: Number of pages to populate.
+         * @pages: Array of pointers to ttm pages.
+         * @dummy_read_page: Page to be used instead of NULL pages in the
+         * array @pages.
+         *
+         * Populate the backend with ttm pages. Depending on the backend,
+         * it may or may not copy the @pages array.
+         */
+        int (*populate) (struct ttm_backend *backend,
+                         unsigned long num_pages, struct page **pages,
+                         struct page *dummy_read_page);
+        /**
+         * struct ttm_backend_func member clear
+         *
+         * @backend: Pointer to a struct ttm_backend.
+         *
+         * This is an "unpopulate" function. Release all resources
+         * allocated with populate.
+         */
+        void (*clear) (struct ttm_backend *backend);
+
+        /**
+         * struct ttm_backend_func member bind
+         *
+         * @backend: Pointer to a struct ttm_backend.
+         * @bo_mem: Pointer to a struct ttm_mem_reg describing the
+         * memory type and location for binding.
+         *
+         * Bind the backend pages into the aperture in the location
+         * indicated by @bo_mem. This function should be able to handle
+         * differences between aperture- and system page sizes.
+         */
+        int (*bind) (struct ttm_backend *backend, struct ttm_mem_reg *bo_mem);
+
+        /**
+         * struct ttm_backend_func member unbind
+         *
+         * @backend: Pointer to a struct ttm_backend.
+         *
+         * Unbind previously bound backend pages. This function should be
+         * able to handle differences between aperture- and system page sizes.
+         */
+        int (*unbind) (struct ttm_backend *backend);
+
+        /**
+         * struct ttm_backend_func member destroy
+         *
+         * @backend: Pointer to a struct ttm_backend.
+         *
+         * Destroy the backend.
+         */
+        void (*destroy) (struct ttm_backend *backend);
+};
+
+/**
+ * struct ttm_backend
+ *
+ * @bdev: Pointer to a struct ttm_bo_device.
+ * @flags: For driver use.
+ * @func: Pointer to a struct ttm_backend_func that describes
+ * the backend methods.
+ *
+ */
+
+struct ttm_backend {
+        struct ttm_bo_device *bdev;
+        uint32_t flags;
+        struct ttm_backend_func *func;
+};
+
+#define TTM_PAGE_FLAG_VMALLOC         (1 << 0)
+#define TTM_PAGE_FLAG_USER            (1 << 1)
+#define TTM_PAGE_FLAG_USER_DIRTY      (1 << 2)
+#define TTM_PAGE_FLAG_WRITE           (1 << 3)
+#define TTM_PAGE_FLAG_SWAPPED         (1 << 4)
+#define TTM_PAGE_FLAG_PERSISTANT_SWAP (1 << 5)
+#define TTM_PAGE_FLAG_ZERO_ALLOC      (1 << 6)
+#define TTM_PAGE_FLAG_DMA32           (1 << 7)
+
+enum ttm_caching_state {
+        tt_uncached,
+        tt_wc,
+        tt_cached
+};
+
+/**
+ * struct ttm_tt
+ *
+ * @dummy_read_page: Page to map where the ttm_tt page array contains a NULL
+ * pointer.
+ * @pages: Array of pages backing the data.
+ * @first_himem_page: Himem pages are put last in the page array, which
+ * enables us to run caching attribute changes on only the first part
+ * of the page array containing lomem pages. This is the index of the
+ * first himem page.
+ * @last_lomem_page: Index of the last lomem page in the page array.
+ * @num_pages: Number of pages in the page array.
+ * @bdev: Pointer to the current struct ttm_bo_device.
+ * @be: Pointer to the ttm backend.
+ * @tsk: The task for user ttm.
+ * @start: virtual address for user ttm.
+ * @swap_storage: Pointer to shmem struct file for swap storage.
+ * @caching_state: The current caching state of the pages.
+ * @state: The current binding state of the pages.
+ *
+ * This is a structure holding the pages, caching- and aperture binding
+ * status for a buffer object that isn't backed by fixed (VRAM / AGP)
+ * memory.
+ */
+
+struct ttm_tt {
+        struct page *dummy_read_page;
+        struct page **pages;
+        long first_himem_page;
+        long last_lomem_page;
+        uint32_t page_flags;
+        unsigned long num_pages;
+        struct ttm_bo_device *bdev;
+        struct ttm_backend *be;
+        struct task_struct *tsk;
+        unsigned long start;
+        struct file *swap_storage;
+        enum ttm_caching_state caching_state;
+        enum {
+                tt_bound,
+                tt_unbound,
+                tt_unpopulated,
+        } state;
+};
+
+#define TTM_MEMTYPE_FLAG_FIXED         (1 << 0) /* Fixed (on-card) PCI memory */
+#define TTM_MEMTYPE_FLAG_MAPPABLE      (1 << 1) /* Memory mappable */
+#define TTM_MEMTYPE_FLAG_NEEDS_IOREMAP (1 << 2) /* Fixed memory needs ioremap
+                                                   before kernel access. */
+#define TTM_MEMTYPE_FLAG_CMA           (1 << 3) /* Can't map aperture */
+
+/**
+ * struct ttm_mem_type_manager
+ *
+ * @has_type: The memory type has been initialized.
+ * @use_type: The memory type is enabled.
+ * @flags: TTM_MEMTYPE_XX flags identifying the traits of the memory
+ * managed by this memory type.
+ * @gpu_offset: If used, the GPU offset of the first managed page of
+ * fixed memory or the first managed location in an aperture.
+ * @io_offset: The io_offset of the first managed page of IO memory or
+ * the first managed location in an aperture. For TTM_MEMTYPE_FLAG_CMA
+ * memory, this should be set to NULL.
+ * @io_size: The size of a managed IO region (fixed memory or aperture).
+ * @io_addr: Virtual kernel address if the io region is pre-mapped. For
+ * TTM_MEMTYPE_FLAG_NEEDS_IOREMAP there is no pre-mapped io map and
+ * @io_addr should be set to NULL.
+ * @size: Size of the managed region.
+ * @available_caching: A mask of available caching types, TTM_PL_FLAG_XX,
+ * as defined in ttm_placement_common.h
+ * @default_caching: The default caching policy used for a buffer object
+ * placed in this memory type if the user doesn't provide one.
+ * @manager: The range manager used for this memory type. FIXME: If the aperture
+ * has a page size different from the underlying system, the granularity
+ * of this manager should take care of this. But the range allocating code
+ * in ttm_bo.c needs to be modified for this.
+ * @lru: The lru list for this memory type.
+ *
+ * This structure is used to identify and manage memory types for a device.
+ * It's set up by the ttm_bo_driver::init_mem_type method.
+ */
+
+struct ttm_mem_type_manager {
+
+        /*
+         * No protection. Constant from start.
+         */
+
+        bool has_type;
+        bool use_type;
+        uint32_t flags;
+        unsigned long gpu_offset;
+        unsigned long io_offset;
+        unsigned long io_size;
+        void *io_addr;
+        uint64_t size;
+        uint32_t available_caching;
+        uint32_t default_caching;
+
+        /*
+         * Protected by the bdev->lru_lock.
+         * TODO: Consider one lru_lock per ttm_mem_type_manager.
+         * Plays ill with list removal, though.
+         */
+
+        struct drm_mm manager;
+        struct list_head lru;
+};
+
+/**
+ * struct ttm_bo_driver
+ *
+ * @mem_type_prio: Priority array of memory types to place a buffer object in
+ * if it fits without evicting buffers from any of these memory types.
+ * @mem_busy_prio: Priority array of memory types to place a buffer object in
+ * if it needs to evict buffers to make room.
+ * @num_mem_type_prio: Number of elements in the @mem_type_prio array.
+ * @num_mem_busy_prio: Number of elements in the @num_mem_busy_prio array.
+ * @create_ttm_backend_entry: Callback to create a struct ttm_backend.
+ * @invalidate_caches: Callback to invalidate read caches when a buffer object
+ * has been evicted.
+ * @init_mem_type: Callback to initialize a struct ttm_mem_type_manager
+ * structure.
+ * @evict_flags: Callback to obtain placement flags when a buffer is evicted.
+ * @move: Callback for a driver to hook in accelerated functions to
+ * move a buffer.
+ * If set to NULL, a potentially slow memcpy() move is used.
+ * @sync_obj_signaled: See ttm_fence_api.h
+ * @sync_obj_wait: See ttm_fence_api.h
+ * @sync_obj_flush: See ttm_fence_api.h
+ * @sync_obj_unref: See ttm_fence_api.h
+ * @sync_obj_ref: See ttm_fence_api.h
+ */
+
+struct ttm_bo_driver {
+        const uint32_t *mem_type_prio;
+        const uint32_t *mem_busy_prio;
+        uint32_t num_mem_type_prio;
+        uint32_t num_mem_busy_prio;
+
+        /**
+         * struct ttm_bo_driver member create_ttm_backend_entry
+         *
+         * @bdev: The buffer object device.
+         *
+         * Create a driver specific struct ttm_backend.
+         */
+
+        struct ttm_backend *(*create_ttm_backend_entry)
+         (struct ttm_bo_device *bdev);
+
+        /**
+         * struct ttm_bo_driver member invalidate_caches
+         *
+         * @bdev: the buffer object device.
+         * @flags: new placement of the rebound buffer object.
+         *
+         * A previosly evicted buffer has been rebound in a
+         * potentially new location. Tell the driver that it might
+         * consider invalidating read (texture) caches on the next command
+         * submission as a consequence.
+         */
+
+        int (*invalidate_caches) (struct ttm_bo_device *bdev, uint32_t flags);
+        int (*init_mem_type) (struct ttm_bo_device *bdev, uint32_t type,
+                              struct ttm_mem_type_manager *man);
+        /**
+         * struct ttm_bo_driver member evict_flags:
+         *
+         * @bo: the buffer object to be evicted
+         *
+         * Return the bo flags for a buffer which is not mapped to the hardware.
+         * These will be placed in proposed_flags so that when the move is
+         * finished, they'll end up in bo->mem.flags
+         */
+
+         uint32_t(*evict_flags) (struct ttm_buffer_object *bo);
+        /**
+         * struct ttm_bo_driver member move:
+         *
+         * @bo: the buffer to move
+         * @evict: whether this motion is evicting the buffer from
+         * the graphics address space
+         * @interruptible: Use interruptible sleeps if possible when sleeping.
+         * @no_wait: whether this should give up and return -EBUSY
+         * if this move would require sleeping
+         * @new_mem: the new memory region receiving the buffer
+         *
+         * Move a buffer between two memory regions.
+         */
+        int (*move) (struct ttm_buffer_object *bo,
+                     bool evict, bool interruptible,
+                     bool no_wait, struct ttm_mem_reg *new_mem);
+
+        /**
+         * struct ttm_bo_driver_member verify_access
+         *
+         * @bo: Pointer to a buffer object.
+         * @filp: Pointer to a struct file trying to access the object.
+         *
+         * Called from the map / write / read methods to verify that the
+         * caller is permitted to access the buffer object.
+         * This member may be set to NULL, which will refuse this kind of
+         * access for all buffer objects.
+         * This function should return 0 if access is granted, -EPERM otherwise.
+         */
+        int (*verify_access) (struct ttm_buffer_object *bo,
+                              struct file *filp);
+
+        /**
+         * In case a driver writer dislikes the TTM fence objects,
+         * the driver writer can replace those with sync objects of
+         * his / her own. If it turns out that no driver writer is
+         * using these. I suggest we remove these hooks and plug in
+         * fences directly. The bo driver needs the following functionality:
+         * See the corresponding functions in the fence object API
+         * documentation.
+         */
+
+        bool (*sync_obj_signaled) (void *sync_obj, void *sync_arg);
+        int (*sync_obj_wait) (void *sync_obj, void *sync_arg,
+                              bool lazy, bool interruptible);
+        int (*sync_obj_flush) (void *sync_obj, void *sync_arg);
+        void (*sync_obj_unref) (void **sync_obj);
+        void *(*sync_obj_ref) (void *sync_obj);
+
+        /* hook to notify driver about a driver move so it
+         * can do tiling things */
+        void (*move_notify)(struct ttm_buffer_object *bo,
+                            struct ttm_mem_reg *new_mem);
+        /* notify the driver we are taking a fault on this BO
+         * and have reserved it */
+        void (*fault_reserve_notify)(struct ttm_buffer_object *bo);
+};
+
+#define TTM_NUM_MEM_TYPES 8
+
+#define TTM_BO_PRIV_FLAG_MOVING  0      /* Buffer object is moving and needs
+                                           idling before CPU mapping */
+#define TTM_BO_PRIV_FLAG_MAX 1
+/**
+ * struct ttm_bo_device - Buffer object driver device-specific data.
+ *
+ * @mem_glob: Pointer to a struct ttm_mem_global object for accounting.
+ * @driver: Pointer to a struct ttm_bo_driver struct setup by the driver.
+ * @count: Current number of buffer object.
+ * @pages: Current number of pinned pages.
+ * @dummy_read_page: Pointer to a dummy page used for mapping requests
+ * of unpopulated pages.
+ * @shrink: A shrink callback object used for buffre object swap.
+ * @ttm_bo_extra_size: Extra size (sizeof(struct ttm_buffer_object) excluded)
+ * used by a buffer object. This is excluding page arrays and backing pages.
+ * @ttm_bo_size: This is @ttm_bo_extra_size + sizeof(struct ttm_buffer_object).
+ * @man: An array of mem_type_managers.
+ * @addr_space_mm: Range manager for the device address space.
+ * lru_lock: Spinlock that protects the buffer+device lru lists and
+ * ddestroy lists.
+ * @nice_mode: Try nicely to wait for buffer idle when cleaning a manager.
+ * If a GPU lockup has been detected, this is forced to 0.
+ * @dev_mapping: A pointer to the struct address_space representing the
+ * device address space.
+ * @wq: Work queue structure for the delayed delete workqueue.
+ *
+ */
+
+struct ttm_bo_device {
+
+        /*
+         * Constant after bo device init / atomic.
+         */
+
+        struct ttm_mem_global *mem_glob;
+        struct ttm_bo_driver *driver;
+        struct page *dummy_read_page;
+        struct ttm_mem_shrink shrink;
+
+        size_t ttm_bo_extra_size;
+        size_t ttm_bo_size;
+
+        rwlock_t vm_lock;
+        /*
+         * Protected by the vm lock.
+         */
+        struct ttm_mem_type_manager man[TTM_NUM_MEM_TYPES];
+        struct rb_root addr_space_rb;
+        struct drm_mm addr_space_mm;
+
+        /*
+         * Might want to change this to one lock per manager.
+         */
+        spinlock_t lru_lock;
+        /*
+         * Protected by the lru lock.
+         */
+        struct list_head ddestroy;
+        struct list_head swap_lru;
+
+        /*
+         * Protected by load / firstopen / lastclose /unload sync.
+         */
+
+        bool nice_mode;
+        struct address_space *dev_mapping;
+
+        /*
+         * Internal protection.
+         */
+
+        struct delayed_work wq;
+
+        bool need_dma32;
+};
+
+/**
+ * ttm_flag_masked
+ *
+ * @old: Pointer to the result and original value.
+ * @new: New value of bits.
+ * @mask: Mask of bits to change.
+ *
+ * Convenience function to change a number of bits identified by a mask.
+ */
+
+static inline uint32_t
+ttm_flag_masked(uint32_t *old, uint32_t new, uint32_t mask)
+{
+        *old ^= (*old ^ new) & mask;
+        return *old;
+}
+
+/**
+ * ttm_tt_create
+ *
+ * @bdev: pointer to a struct ttm_bo_device:
+ * @size: Size of the data needed backing.
+ * @page_flags: Page flags as identified by TTM_PAGE_FLAG_XX flags.
+ * @dummy_read_page: See struct ttm_bo_device.
+ *
+ * Create a struct ttm_tt to back data with system memory pages.
+ * No pages are actually allocated.
+ * Returns:
+ * NULL: Out of memory.
+ */
+extern struct ttm_tt *ttm_tt_create(struct ttm_bo_device *bdev,
+                                    unsigned long size,
+                                    uint32_t page_flags,
+                                    struct page *dummy_read_page);
+
+/**
+ * ttm_tt_set_user:
+ *
+ * @ttm: The struct ttm_tt to populate.
+ * @tsk: A struct task_struct for which @start is a valid user-space address.
+ * @start: A valid user-space address.
+ * @num_pages: Size in pages of the user memory area.
+ *
+ * Populate a struct ttm_tt with a user-space memory area after first pinning
+ * the pages backing it.
+ * Returns:
+ * !0: Error.
+ */
+
+extern int ttm_tt_set_user(struct ttm_tt *ttm,
+                           struct task_struct *tsk,
+                           unsigned long start, unsigned long num_pages);
+
+/**
+ * ttm_ttm_bind:
+ *
+ * @ttm: The struct ttm_tt containing backing pages.
+ * @bo_mem: The struct ttm_mem_reg identifying the binding location.
+ *
+ * Bind the pages of @ttm to an aperture location identified by @bo_mem
+ */
+extern int ttm_tt_bind(struct ttm_tt *ttm, struct ttm_mem_reg *bo_mem);
+
+/**
+ * ttm_ttm_destroy:
+ *
+ * @ttm: The struct ttm_tt.
+ *
+ * Unbind, unpopulate and destroy a struct ttm_tt.
+ */
+extern void ttm_tt_destroy(struct ttm_tt *ttm);
+
+/**
+ * ttm_ttm_unbind:
+ *
+ * @ttm: The struct ttm_tt.
+ *
+ * Unbind a struct ttm_tt.
+ */
+extern void ttm_tt_unbind(struct ttm_tt *ttm);
+
+/**
+ * ttm_ttm_destroy:
+ *
+ * @ttm: The struct ttm_tt.
+ * @index: Index of the desired page.
+ *
+ * Return a pointer to the struct page backing @ttm at page
+ * index @index. If the page is unpopulated, one will be allocated to
+ * populate that index.
+ *
+ * Returns:
+ * NULL on OOM.
+ */
+extern struct page *ttm_tt_get_page(struct ttm_tt *ttm, int index);
+
+/**
+ * ttm_tt_cache_flush:
+ *
+ * @pages: An array of pointers to struct page:s to flush.
+ * @num_pages: Number of pages to flush.
+ *
+ * Flush the data of the indicated pages from the cpu caches.
+ * This is used when changing caching attributes of the pages from
+ * cache-coherent.
+ */
+extern void ttm_tt_cache_flush(struct page *pages[], unsigned long num_pages);
+
+/**
+ * ttm_tt_set_placement_caching:
+ *
+ * @ttm A struct ttm_tt the backing pages of which will change caching policy.
+ * @placement: Flag indicating the desired caching policy.
+ *
+ * This function will change caching policy of any default kernel mappings of
+ * the pages backing @ttm. If changing from cached to uncached or
+ * write-combined,
+ * all CPU caches will first be flushed to make sure the data of the pages
+ * hit RAM. This function may be very costly as it involves global TLB
+ * and cache flushes and potential page splitting / combining.
+ */
+extern int ttm_tt_set_placement_caching(struct ttm_tt *ttm, uint32_t placement);
+extern int ttm_tt_swapout(struct ttm_tt *ttm,
+                          struct file *persistant_swap_storage);
+
+/*
+ * ttm_bo.c
+ */
+
+/**
+ * ttm_mem_reg_is_pci
+ *
+ * @bdev: Pointer to a struct ttm_bo_device.
+ * @mem: A valid struct ttm_mem_reg.
+ *
+ * Returns true if the memory described by @mem is PCI memory,
+ * false otherwise.
+ */
+extern bool ttm_mem_reg_is_pci(struct ttm_bo_device *bdev,
+                                   struct ttm_mem_reg *mem);
+
+/**
+ * ttm_bo_mem_space
+ *
+ * @bo: Pointer to a struct ttm_buffer_object. the data of which
+ * we want to allocate space for.
+ * @proposed_placement: Proposed new placement for the buffer object.
+ * @mem: A struct ttm_mem_reg.
+ * @interruptible: Sleep interruptible when sliping.
+ * @no_wait: Don't sleep waiting for space to become available.
+ *
+ * Allocate memory space for the buffer object pointed to by @bo, using
+ * the placement flags in @mem, potentially evicting other idle buffer objects.
+ * This function may sleep while waiting for space to become available.
+ * Returns:
+ * -EBUSY: No space available (only if no_wait == 1).
+ * -ENOMEM: Could not allocate memory for the buffer object, either due to
+ * fragmentation or concurrent allocators.
+ * -ERESTART: An interruptible sleep was interrupted by a signal.
+ */
+extern int ttm_bo_mem_space(struct ttm_buffer_object *bo,
+                            uint32_t proposed_placement,
+                            struct ttm_mem_reg *mem,
+                            bool interruptible, bool no_wait);
+/**
+ * ttm_bo_wait_for_cpu
+ *
+ * @bo: Pointer to a struct ttm_buffer_object.
+ * @no_wait: Don't sleep while waiting.
+ *
+ * Wait until a buffer object is no longer sync'ed for CPU access.
+ * Returns:
+ * -EBUSY: Buffer object was sync'ed for CPU access. (only if no_wait == 1).
+ * -ERESTART: An interruptible sleep was interrupted by a signal.
+ */
+
+extern int ttm_bo_wait_cpu(struct ttm_buffer_object *bo, bool no_wait);
+
+/**
+ * ttm_bo_pci_offset - Get the PCI offset for the buffer object memory.
+ *
+ * @bo Pointer to a struct ttm_buffer_object.
+ * @bus_base On return the base of the PCI region
+ * @bus_offset On return the byte offset into the PCI region
+ * @bus_size On return the byte size of the buffer object or zero if
+ * the buffer object memory is not accessible through a PCI region.
+ *
+ * Returns:
+ * -EINVAL if the buffer object is currently not mappable.
+ * 0 otherwise.
+ */
+
+extern int ttm_bo_pci_offset(struct ttm_bo_device *bdev,
+                             struct ttm_mem_reg *mem,
+                             unsigned long *bus_base,
+                             unsigned long *bus_offset,
+                             unsigned long *bus_size);
+
+extern int ttm_bo_device_release(struct ttm_bo_device *bdev);
+
+/**
+ * ttm_bo_device_init
+ *
+ * @bdev: A pointer to a struct ttm_bo_device to initialize.
+ * @mem_global: A pointer to an initialized struct ttm_mem_global.
+ * @driver: A pointer to a struct ttm_bo_driver set up by the caller.
+ * @file_page_offset: Offset into the device address space that is available
+ * for buffer data. This ensures compatibility with other users of the
+ * address space.
+ *
+ * Initializes a struct ttm_bo_device:
+ * Returns:
+ * !0: Failure.
+ */
+extern int ttm_bo_device_init(struct ttm_bo_device *bdev,
+                              struct ttm_mem_global *mem_glob,
+                              struct ttm_bo_driver *driver,
+                              uint64_t file_page_offset, bool need_dma32);
+
+/**
+ * ttm_bo_unmap_virtual
+ *
+ * @bo: tear down the virtual mappings for this BO
+ */
+extern void ttm_bo_unmap_virtual(struct ttm_buffer_object *bo);
+
+/**
+ * ttm_bo_reserve:
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ * @interruptible: Sleep interruptible if waiting.
+ * @no_wait: Don't sleep while trying to reserve, rather return -EBUSY.
+ * @use_sequence: If @bo is already reserved, Only sleep waiting for
+ * it to become unreserved if @sequence < (@bo)->sequence.
+ *
+ * Locks a buffer object for validation. (Or prevents other processes from
+ * locking it for validation) and removes it from lru lists, while taking
+ * a number of measures to prevent deadlocks.
+ *
+ * Deadlocks may occur when two processes try to reserve multiple buffers in
+ * different order, either by will or as a result of a buffer being evicted
+ * to make room for a buffer already reserved. (Buffers are reserved before
+ * they are evicted). The following algorithm prevents such deadlocks from
+ * occuring:
+ * 1) Buffers are reserved with the lru spinlock held. Upon successful
+ * reservation they are removed from the lru list. This stops a reserved buffer
+ * from being evicted. However the lru spinlock is released between the time
+ * a buffer is selected for eviction and the time it is reserved.
+ * Therefore a check is made when a buffer is reserved for eviction, that it
+ * is still the first buffer in the lru list, before it is removed from the
+ * list. @check_lru == 1 forces this check. If it fails, the function returns
+ * -EINVAL, and the caller should then choose a new buffer to evict and repeat
+ * the procedure.
+ * 2) Processes attempting to reserve multiple buffers other than for eviction,
+ * (typically execbuf), should first obtain a unique 32-bit
+ * validation sequence number,
+ * and call this function with @use_sequence == 1 and @sequence == the unique
+ * sequence number. If upon call of this function, the buffer object is already
+ * reserved, the validation sequence is checked against the validation
+ * sequence of the process currently reserving the buffer,
+ * and if the current validation sequence is greater than that of the process
+ * holding the reservation, the function returns -EAGAIN. Otherwise it sleeps
+ * waiting for the buffer to become unreserved, after which it retries
+ * reserving.
+ * The caller should, when receiving an -EAGAIN error
+ * release all its buffer reservations, wait for @bo to become unreserved, and
+ * then rerun the validation with the same validation sequence. This procedure
+ * will always guarantee that the process with the lowest validation sequence
+ * will eventually succeed, preventing both deadlocks and starvation.
+ *
+ * Returns:
+ * -EAGAIN: The reservation may cause a deadlock.
+ * Release all buffer reservations, wait for @bo to become unreserved and
+ * try again. (only if use_sequence == 1).
+ * -ERESTART: A wait for the buffer to become unreserved was interrupted by
+ * a signal. Release all buffer reservations and return to user-space.
+ */
+extern int ttm_bo_reserve(struct ttm_buffer_object *bo,
+                          bool interruptible,
+                          bool no_wait, bool use_sequence, uint32_t sequence);
+
+/**
+ * ttm_bo_unreserve
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ *
+ * Unreserve a previous reservation of @bo.
+ */
+extern void ttm_bo_unreserve(struct ttm_buffer_object *bo);
+
+/**
+ * ttm_bo_wait_unreserved
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ *
+ * Wait for a struct ttm_buffer_object to become unreserved.
+ * This is typically used in the execbuf code to relax cpu-usage when
+ * a potential deadlock condition backoff.
+ */
+extern int ttm_bo_wait_unreserved(struct ttm_buffer_object *bo,
+                                  bool interruptible);
+
+/**
+ * ttm_bo_block_reservation
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ * @interruptible: Use interruptible sleep when waiting.
+ * @no_wait: Don't sleep, but rather return -EBUSY.
+ *
+ * Block reservation for validation by simply reserving the buffer.
+ * This is intended for single buffer use only without eviction,
+ * and thus needs no deadlock protection.
+ *
+ * Returns:
+ * -EBUSY: If no_wait == 1 and the buffer is already reserved.
+ * -ERESTART: If interruptible == 1 and the process received a signal
+ * while sleeping.
+ */
+extern int ttm_bo_block_reservation(struct ttm_buffer_object *bo,
+                                    bool interruptible, bool no_wait);
+
+/**
+ * ttm_bo_unblock_reservation
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ *
+ * Unblocks reservation leaving lru lists untouched.
+ */
+extern void ttm_bo_unblock_reservation(struct ttm_buffer_object *bo);
+
+/*
+ * ttm_bo_util.c
+ */
+
+/**
+ * ttm_bo_move_ttm
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ * @evict: 1: This is an eviction. Don't try to pipeline.
+ * @no_wait: Never sleep, but rather return with -EBUSY.
+ * @new_mem: struct ttm_mem_reg indicating where to move.
+ *
+ * Optimized move function for a buffer object with both old and
+ * new placement backed by a TTM. The function will, if successful,
+ * free any old aperture space, and set (@new_mem)->mm_node to NULL,
+ * and update the (@bo)->mem placement flags. If unsuccessful, the old
+ * data remains untouched, and it's up to the caller to free the
+ * memory space indicated by @new_mem.
+ * Returns:
+ * !0: Failure.
+ */
+
+extern int ttm_bo_move_ttm(struct ttm_buffer_object *bo,
+                           bool evict, bool no_wait,
+                           struct ttm_mem_reg *new_mem);
+
+/**
+ * ttm_bo_move_memcpy
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ * @evict: 1: This is an eviction. Don't try to pipeline.
+ * @no_wait: Never sleep, but rather return with -EBUSY.
+ * @new_mem: struct ttm_mem_reg indicating where to move.
+ *
+ * Fallback move function for a mappable buffer object in mappable memory.
+ * The function will, if successful,
+ * free any old aperture space, and set (@new_mem)->mm_node to NULL,
+ * and update the (@bo)->mem placement flags. If unsuccessful, the old
+ * data remains untouched, and it's up to the caller to free the
+ * memory space indicated by @new_mem.
+ * Returns:
+ * !0: Failure.
+ */
+
+extern int ttm_bo_move_memcpy(struct ttm_buffer_object *bo,
+                              bool evict,
+                              bool no_wait, struct ttm_mem_reg *new_mem);
+
+/**
+ * ttm_bo_free_old_node
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ *
+ * Utility function to free an old placement after a successful move.
+ */
+extern void ttm_bo_free_old_node(struct ttm_buffer_object *bo);
+
+/**
+ * ttm_bo_move_accel_cleanup.
+ *
+ * @bo: A pointer to a struct ttm_buffer_object.
+ * @sync_obj: A sync object that signals when moving is complete.
+ * @sync_obj_arg: An argument to pass to the sync object idle / wait
+ * functions.
+ * @evict: This is an evict move. Don't return until the buffer is idle.
+ * @no_wait: Never sleep, but rather return with -EBUSY.
+ * @new_mem: struct ttm_mem_reg indicating where to move.
+ *
+ * Accelerated move function to be called when an accelerated move
+ * has been scheduled. The function will create a new temporary buffer object
+ * representing the old placement, and put the sync object on both buffer
+ * objects. After that the newly created buffer object is unref'd to be
+ * destroyed when the move is complete. This will help pipeline
+ * buffer moves.
+ */
+
+extern int ttm_bo_move_accel_cleanup(struct ttm_buffer_object *bo,
+                                     void *sync_obj,
+                                     void *sync_obj_arg,
+                                     bool evict, bool no_wait,
+                                     struct ttm_mem_reg *new_mem);
+/**
+ * ttm_io_prot
+ *
+ * @c_state: Caching state.
+ * @tmp: Page protection flag for a normal, cached mapping.
+ *
+ * Utility function that returns the pgprot_t that should be used for
+ * setting up a PTE with the caching model indicated by @c_state.
+ */
+extern pgprot_t ttm_io_prot(enum ttm_caching_state c_state, pgprot_t tmp);
+
+#if (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
+#define TTM_HAS_AGP
+#include <linux/agp_backend.h>
+
+/**
+ * ttm_agp_backend_init
+ *
+ * @bdev: Pointer to a struct ttm_bo_device.
+ * @bridge: The agp bridge this device is sitting on.
+ *
+ * Create a TTM backend that uses the indicated AGP bridge as an aperture
+ * for TT memory. This function uses the linux agpgart interface to
+ * bind and unbind memory backing a ttm_tt.
+ */
+extern struct ttm_backend *ttm_agp_backend_init(struct ttm_bo_device *bdev,
+                                                struct agp_bridge_data *bridge);
+#endif
+
+#endif
diff --git a/include/drm/ttm/ttm_memory.h b/include/drm/ttm/ttm_memory.h
new file mode 100644
index 000000000000..d8b8f042c4f1
--- /dev/null
+++ b/include/drm/ttm/ttm_memory.h
@@ -0,0 +1,153 @@
+/**************************************************************************
+ *
+ * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+
+#ifndef TTM_MEMORY_H
+#define TTM_MEMORY_H
+
+#include <linux/workqueue.h>
+#include <linux/spinlock.h>
+#include <linux/wait.h>
+#include <linux/errno.h>
+
+/**
+ * struct ttm_mem_shrink - callback to shrink TTM memory usage.
+ *
+ * @do_shrink: The callback function.
+ *
+ * Arguments to the do_shrink functions are intended to be passed using
+ * inheritance. That is, the argument class derives from struct ttm_mem_srink,
+ * and can be accessed using container_of().
+ */
+
+struct ttm_mem_shrink {
+        int (*do_shrink) (struct ttm_mem_shrink *);
+};
+
+/**
+ * struct ttm_mem_global - Global memory accounting structure.
+ *
+ * @shrink: A single callback to shrink TTM memory usage. Extend this
+ * to a linked list to be able to handle multiple callbacks when needed.
+ * @swap_queue: A workqueue to handle shrinking in low memory situations. We
+ * need a separate workqueue since it will spend a lot of time waiting
+ * for the GPU, and this will otherwise block other workqueue tasks(?)
+ * At this point we use only a single-threaded workqueue.
+ * @work: The workqueue callback for the shrink queue.
+ * @queue: Wait queue for processes suspended waiting for memory.
+ * @lock: Lock to protect the @shrink - and the memory accounting members,
+ * that is, essentially the whole structure with some exceptions.
+ * @emer_memory: Lowmem memory limit available for root.
+ * @max_memory: Lowmem memory limit available for non-root.
+ * @swap_limit: Lowmem memory limit where the shrink workqueue kicks in.
+ * @used_memory: Currently used lowmem memory.
+ * @used_total_memory: Currently used total (lowmem + highmem) memory.
+ * @total_memory_swap_limit: Total memory limit where the shrink workqueue
+ * kicks in.
+ * @max_total_memory: Total memory available to non-root processes.
+ * @emer_total_memory: Total memory available to root processes.
+ *
+ * Note that this structure is not per device. It should be global for all
+ * graphics devices.
+ */
+
+struct ttm_mem_global {
+        struct ttm_mem_shrink *shrink;
+        struct workqueue_struct *swap_queue;
+        struct work_struct work;
+        wait_queue_head_t queue;
+        spinlock_t lock;
+        uint64_t emer_memory;
+        uint64_t max_memory;
+        uint64_t swap_limit;
+        uint64_t used_memory;
+        uint64_t used_total_memory;
+        uint64_t total_memory_swap_limit;
+        uint64_t max_total_memory;
+        uint64_t emer_total_memory;
+};
+
+/**
+ * ttm_mem_init_shrink - initialize a struct ttm_mem_shrink object
+ *
+ * @shrink: The object to initialize.
+ * @func: The callback function.
+ */
+
+static inline void ttm_mem_init_shrink(struct ttm_mem_shrink *shrink,
+                                       int (*func) (struct ttm_mem_shrink *))
+{
+        shrink->do_shrink = func;
+}
+
+/**
+ * ttm_mem_register_shrink - register a struct ttm_mem_shrink object.
+ *
+ * @glob: The struct ttm_mem_global object to register with.
+ * @shrink: An initialized struct ttm_mem_shrink object to register.
+ *
+ * Returns:
+ * -EBUSY: There's already a callback registered. (May change).
+ */
+
+static inline int ttm_mem_register_shrink(struct ttm_mem_global *glob,
+                                          struct ttm_mem_shrink *shrink)
+{
+        spin_lock(&glob->lock);
+        if (glob->shrink != NULL) {
+                spin_unlock(&glob->lock);
+                return -EBUSY;
+        }
+        glob->shrink = shrink;
+        spin_unlock(&glob->lock);
+        return 0;
+}
+
+/**
+ * ttm_mem_unregister_shrink - unregister a struct ttm_mem_shrink object.
+ *
+ * @glob: The struct ttm_mem_global object to unregister from.
+ * @shrink: A previously registert struct ttm_mem_shrink object.
+ *
+ */
+
+static inline void ttm_mem_unregister_shrink(struct ttm_mem_global *glob,
+                                             struct ttm_mem_shrink *shrink)
+{
+        spin_lock(&glob->lock);
+        BUG_ON(glob->shrink != shrink);
+        glob->shrink = NULL;
+        spin_unlock(&glob->lock);
+}
+
+extern int ttm_mem_global_init(struct ttm_mem_global *glob);
+extern void ttm_mem_global_release(struct ttm_mem_global *glob);
+extern int ttm_mem_global_alloc(struct ttm_mem_global *glob, uint64_t memory,
+                                bool no_wait, bool interruptible, bool himem);
+extern void ttm_mem_global_free(struct ttm_mem_global *glob,
+                                uint64_t amount, bool himem);
+extern size_t ttm_round_pot(size_t size);
+#endif
diff --git a/include/drm/ttm/ttm_module.h b/include/drm/ttm/ttm_module.h
new file mode 100644
index 000000000000..d1d433834e4f
--- /dev/null
+++ b/include/drm/ttm/ttm_module.h
@@ -0,0 +1,58 @@
+/**************************************************************************
+ *
+ * Copyright 2008-2009 VMware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+/*
+ * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
+ */
+
+#ifndef _TTM_MODULE_H_
+#define _TTM_MODULE_H_
+
+#include <linux/kernel.h>
+
+#define TTM_PFX "[TTM] "
+
+enum ttm_global_types {
+        TTM_GLOBAL_TTM_MEM = 0,
+        TTM_GLOBAL_TTM_BO,
+        TTM_GLOBAL_TTM_OBJECT,
+        TTM_GLOBAL_NUM
+};
+
+struct ttm_global_reference {
+        enum ttm_global_types global_type;
+        size_t size;
+        void *object;
+        int (*init) (struct ttm_global_reference *);
+        void (*release) (struct ttm_global_reference *);
+};
+
+extern void ttm_global_init(void);
+extern void ttm_global_release(void);
+extern int ttm_global_item_ref(struct ttm_global_reference *ref);
+extern void ttm_global_item_unref(struct ttm_global_reference *ref);
+
+#endif /* _TTM_MODULE_H_ */
diff --git a/include/drm/ttm/ttm_placement.h b/include/drm/ttm/ttm_placement.h
new file mode 100644
index 000000000000..c84ff153a564
--- /dev/null
+++ b/include/drm/ttm/ttm_placement.h
@@ -0,0 +1,92 @@
+/**************************************************************************
+ *
+ * Copyright (c) 2006-2009 VMware, Inc., Palo Alto, CA., USA
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ **************************************************************************/
+/*
+ * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
+ */
+
+#ifndef _TTM_PLACEMENT_H_
+#define _TTM_PLACEMENT_H_
+/*
+ * Memory regions for data placement.
+ */
+
+#define TTM_PL_SYSTEM           0
+#define TTM_PL_TT               1
+#define TTM_PL_VRAM             2
+#define TTM_PL_PRIV0            3
+#define TTM_PL_PRIV1            4
+#define TTM_PL_PRIV2            5
+#define TTM_PL_PRIV3            6
+#define TTM_PL_PRIV4            7
+#define TTM_PL_PRIV5            8
+#define TTM_PL_SWAPPED          15
+
+#define TTM_PL_FLAG_SYSTEM      (1 << TTM_PL_SYSTEM)
+#define TTM_PL_FLAG_TT          (1 << TTM_PL_TT)
+#define TTM_PL_FLAG_VRAM        (1 << TTM_PL_VRAM)
+#define TTM_PL_FLAG_PRIV0       (1 << TTM_PL_PRIV0)
+#define TTM_PL_FLAG_PRIV1       (1 << TTM_PL_PRIV1)
+#define TTM_PL_FLAG_PRIV2       (1 << TTM_PL_PRIV2)
+#define TTM_PL_FLAG_PRIV3       (1 << TTM_PL_PRIV3)
+#define TTM_PL_FLAG_PRIV4       (1 << TTM_PL_PRIV4)
+#define TTM_PL_FLAG_PRIV5       (1 << TTM_PL_PRIV5)
+#define TTM_PL_FLAG_SWAPPED     (1 << TTM_PL_SWAPPED)
+#define TTM_PL_MASK_MEM         0x0000FFFF
+
+/*
+ * Other flags that affects data placement.
+ * TTM_PL_FLAG_CACHED indicates cache-coherent mappings
+ * if available.
+ * TTM_PL_FLAG_SHARED means that another application may
+ * reference the buffer.
+ * TTM_PL_FLAG_NO_EVICT means that the buffer may never
+ * be evicted to make room for other buffers.
+ */
+
+#define TTM_PL_FLAG_CACHED      (1 << 16)
+#define TTM_PL_FLAG_UNCACHED    (1 << 17)
+#define TTM_PL_FLAG_WC          (1 << 18)
+#define TTM_PL_FLAG_SHARED      (1 << 20)
+#define TTM_PL_FLAG_NO_EVICT    (1 << 21)
+
+#define TTM_PL_MASK_CACHING     (TTM_PL_FLAG_CACHED | \
+                                 TTM_PL_FLAG_UNCACHED | \
+                                 TTM_PL_FLAG_WC)
+
+#define TTM_PL_MASK_MEMTYPE     (TTM_PL_MASK_MEM | TTM_PL_MASK_CACHING)
+
+/*
+ * Access flags to be used for CPU- and GPU- mappings.
+ * The idea is that the TTM synchronization mechanism will
+ * allow concurrent READ access and exclusive write access.
+ * Currently GPU- and CPU accesses are exclusive.
+ */
+
+#define TTM_ACCESS_READ         (1 << 0)
+#define TTM_ACCESS_WRITE        (1 << 1)
+
+#endif
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 3f0eaa397ef5..334a3593cdfd 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -57,6 +57,7 @@ header-y += dlmconstants.h
 header-y += dlm_device.h
 header-y += dlm_netlink.h
 header-y += dm-ioctl.h
+header-y += dm-log-userspace.h
 header-y += dn.h
 header-y += dqblk_xfs.h
 header-y += efs_fs_sb.h
@@ -135,6 +136,7 @@ header-y += posix_types.h
 header-y += ppdev.h
 header-y += prctl.h
 header-y += qnxtypes.h
+header-y += qnx4_fs.h
 header-y += radeonfb.h
 header-y += raw.h
 header-y += resource.h
@@ -307,10 +309,11 @@ unifdef-y += pmu.h
 unifdef-y += poll.h
 unifdef-y += ppp_defs.h
 unifdef-y += ppp-comp.h
+unifdef-y += pps.h
 unifdef-y += ptrace.h
-unifdef-y += qnx4_fs.h
 unifdef-y += quota.h
 unifdef-y += random.h
+unifdef-y += rfkill.h
 unifdef-y += irqnr.h
 unifdef-y += reboot.h
 unifdef-y += reiserfs_fs.h
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 88be890ee3c7..34321cfffeab 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -113,13 +113,10 @@ void acpi_irq_stats_init(void);
 extern u32 acpi_irq_handled;
 extern u32 acpi_irq_not_handled;
 
-extern struct acpi_mcfg_allocation *pci_mmcfg_config;
-extern int pci_mmcfg_config_num;
-
 extern int sbf_port;
 extern unsigned long acpi_realmode_flags;
 
-int acpi_register_gsi (u32 gsi, int triggering, int polarity);
+int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);
 int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
 
 #ifdef CONFIG_X86_IO_APIC
@@ -293,7 +290,10 @@ void __init acpi_s4_no_nvs(void);
                                 OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL)
 
 extern acpi_status acpi_pci_osc_control_set(acpi_handle handle, u32 flags);
+extern void acpi_early_init(void);
+
 #else   /* CONFIG_ACPI */
+static inline void acpi_early_init(void) { }
 
 static inline int early_acpi_boot_init(void)
 {
diff --git a/include/linux/adfs_fs.h b/include/linux/adfs_fs.h
index ef788c2085a1..b19801f73890 100644
--- a/include/linux/adfs_fs.h
+++ b/include/linux/adfs_fs.h
@@ -41,8 +41,6 @@ struct adfs_discrecord {
 #define ADFS_DR_SIZE_BITS       (ADFS_DR_SIZE << 3)
 
 #ifdef __KERNEL__
-#include <linux/adfs_fs_i.h>
-#include <linux/adfs_fs_sb.h>
 /*
  * Calculate the boot block checksum on an ADFS drive.  Note that this will
  * appear to be correct if the sector contains all zeros, so also check that
@@ -60,17 +58,6 @@ static inline int adfs_checkbblk(unsigned char *ptr)
 
         return (result & 0xff) != ptr[511];
 }
-
-static inline struct adfs_sb_info *ADFS_SB(struct super_block *sb)
-{
-        return sb->s_fs_info;
-}
-
-static inline struct adfs_inode_info *ADFS_I(struct inode *inode)
-{
-        return container_of(inode, struct adfs_inode_info, vfs_inode);
-}
-
 #endif
 
 #endif
diff --git a/include/linux/adfs_fs_i.h b/include/linux/adfs_fs_i.h
deleted file mode 100644
index cb543034e54f..000000000000
--- a/include/linux/adfs_fs_i.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- *  linux/include/linux/adfs_fs_i.h
- *
- * Copyright (C) 1997 Russell King
- */
-
-#ifndef _ADFS_FS_I
-#define _ADFS_FS_I
-
-/*
- * adfs file system inode data in memory
- */
-struct adfs_inode_info {
-        loff_t          mmu_private;
-        unsigned long   parent_id;      /* object id of parent          */
-        __u32           loadaddr;       /* RISC OS load address         */
-        __u32           execaddr;       /* RISC OS exec address         */
-        unsigned int    filetype;       /* RISC OS file type            */
-        unsigned int    attr;           /* RISC OS permissions          */
-        unsigned int    stamped:1;      /* RISC OS file has date/time   */
-        struct inode vfs_inode;
-};
-
-#endif
diff --git a/include/linux/adfs_fs_sb.h b/include/linux/adfs_fs_sb.h
deleted file mode 100644
index d9bf05c02ccc..000000000000
--- a/include/linux/adfs_fs_sb.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- *  linux/include/linux/adfs_fs_sb.h
- *
- * Copyright (C) 1997-1999 Russell King
- */
-
-#ifndef _ADFS_FS_SB
-#define _ADFS_FS_SB
-
-/*
- * Forward-declare this
- */
-struct adfs_discmap;
-struct adfs_dir_ops;
-
-/*
- * ADFS file system superblock data in memory
- */
-struct adfs_sb_info {
-        struct adfs_discmap *s_map;     /* bh list containing map                */
-        struct adfs_dir_ops *s_dir;     /* directory operations                  */
-
-        uid_t           s_uid;          /* owner uid                             */
-        gid_t           s_gid;          /* owner gid                             */
-        umode_t         s_owner_mask;   /* ADFS owner perm -> unix perm          */
-        umode_t         s_other_mask;   /* ADFS other perm -> unix perm          */
-
-        __u32           s_ids_per_zone; /* max. no ids in one zone               */
-        __u32           s_idlen;        /* length of ID in map                   */
-        __u32           s_map_size;     /* sector size of a map                  */
-        unsigned long   s_size;         /* total size (in blocks) of this fs     */
-        signed int      s_map2blk;      /* shift left by this for map->sector    */
-        unsigned int    s_log2sharesize;/* log2 share size                       */
-        __le32          s_version;      /* disc format version                   */
-        unsigned int    s_namelen;      /* maximum number of characters in name  */
-};
-
-#endif
diff --git a/include/linux/agp_backend.h b/include/linux/agp_backend.h
index 2b8df8b420fd..76fa794fdac0 100644
--- a/include/linux/agp_backend.h
+++ b/include/linux/agp_backend.h
@@ -70,7 +70,7 @@ struct agp_memory {
         struct agp_memory *next;
         struct agp_memory *prev;
         struct agp_bridge_data *bridge;
-        unsigned long *memory;
+        struct page **pages;
         size_t page_count;
         int key;
         int num_scratch_pages;
diff --git a/include/linux/aio.h b/include/linux/aio.h
index b16a957030f8..47f7d932a01d 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -121,9 +121,9 @@ struct kiocb {
 
         /*
          * If the aio_resfd field of the userspace iocb is not zero,
-         * this is the underlying file* to deliver event to.
+         * this is the underlying eventfd context to deliver events to.
          */
-        struct file             *ki_eventfd;
+        struct eventfd_ctx      *ki_eventfd;
 };
 
 #define is_sync_kiocb(iocb)     ((iocb)->ki_key == KIOCB_SYNC_KEY)
diff --git a/include/linux/amba/pl022.h b/include/linux/amba/pl022.h
new file mode 100644
index 000000000000..dcad0ffd1755
--- /dev/null
+++ b/include/linux/amba/pl022.h
@@ -0,0 +1,264 @@
+/*
+ * include/linux/amba/pl022.h
+ *
+ * Copyright (C) 2008-2009 ST-Ericsson AB
+ * Copyright (C) 2006 STMicroelectronics Pvt. Ltd.
+ *
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ *
+ * Initial version inspired by:
+ *      linux-2.6.17-rc3-mm1/drivers/spi/pxa2xx_spi.c
+ * Initial adoption to PL022 by:
+ *      Sachin Verma <sachin.verma@st.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _SSP_PL022_H
+#define _SSP_PL022_H
+
+#include <linux/device.h>
+
+/**
+ * whether SSP is in loopback mode or not
+ */
+enum ssp_loopback {
+        LOOPBACK_DISABLED,
+        LOOPBACK_ENABLED
+};
+
+/**
+ * enum ssp_interface - interfaces allowed for this SSP Controller
+ * @SSP_INTERFACE_MOTOROLA_SPI: Motorola Interface
+ * @SSP_INTERFACE_TI_SYNC_SERIAL: Texas Instrument Synchronous Serial
+ * interface
+ * @SSP_INTERFACE_NATIONAL_MICROWIRE: National Semiconductor Microwire
+ * interface
+ * @SSP_INTERFACE_UNIDIRECTIONAL: Unidirectional interface (STn8810
+ * &STn8815 only)
+ */
+enum ssp_interface {
+        SSP_INTERFACE_MOTOROLA_SPI,
+        SSP_INTERFACE_TI_SYNC_SERIAL,
+        SSP_INTERFACE_NATIONAL_MICROWIRE,
+        SSP_INTERFACE_UNIDIRECTIONAL
+};
+
+/**
+ * enum ssp_hierarchy - whether SSP is configured as Master or Slave
+ */
+enum ssp_hierarchy {
+        SSP_MASTER,
+        SSP_SLAVE
+};
+
+/**
+ * enum ssp_clock_params - clock parameters, to set SSP clock at a
+ * desired freq
+ */
+struct ssp_clock_params {
+        u8 cpsdvsr; /* value from 2 to 254 (even only!) */
+        u8 scr;     /* value from 0 to 255 */
+};
+
+/**
+ * enum ssp_rx_endian - endianess of Rx FIFO Data
+ */
+enum ssp_rx_endian {
+        SSP_RX_MSB,
+        SSP_RX_LSB
+};
+
+/**
+ * enum ssp_tx_endian - endianess of Tx FIFO Data
+ */
+enum ssp_tx_endian {
+        SSP_TX_MSB,
+        SSP_TX_LSB
+};
+
+/**
+ * enum ssp_data_size - number of bits in one data element
+ */
+enum ssp_data_size {
+        SSP_DATA_BITS_4 = 0x03, SSP_DATA_BITS_5, SSP_DATA_BITS_6,
+        SSP_DATA_BITS_7, SSP_DATA_BITS_8, SSP_DATA_BITS_9,
+        SSP_DATA_BITS_10, SSP_DATA_BITS_11, SSP_DATA_BITS_12,
+        SSP_DATA_BITS_13, SSP_DATA_BITS_14, SSP_DATA_BITS_15,
+        SSP_DATA_BITS_16, SSP_DATA_BITS_17, SSP_DATA_BITS_18,
+        SSP_DATA_BITS_19, SSP_DATA_BITS_20, SSP_DATA_BITS_21,
+        SSP_DATA_BITS_22, SSP_DATA_BITS_23, SSP_DATA_BITS_24,
+        SSP_DATA_BITS_25, SSP_DATA_BITS_26, SSP_DATA_BITS_27,
+        SSP_DATA_BITS_28, SSP_DATA_BITS_29, SSP_DATA_BITS_30,
+        SSP_DATA_BITS_31, SSP_DATA_BITS_32
+};
+
+/**
+ * enum ssp_mode - SSP mode of operation (Communication modes)
+ */
+enum ssp_mode {
+        INTERRUPT_TRANSFER,
+        POLLING_TRANSFER,
+        DMA_TRANSFER
+};
+
+/**
+ * enum ssp_rx_level_trig - receive FIFO watermark level which triggers
+ * IT: Interrupt fires when _N_ or more elements in RX FIFO.
+ */
+enum ssp_rx_level_trig {
+        SSP_RX_1_OR_MORE_ELEM,
+        SSP_RX_4_OR_MORE_ELEM,
+        SSP_RX_8_OR_MORE_ELEM,
+        SSP_RX_16_OR_MORE_ELEM,
+        SSP_RX_32_OR_MORE_ELEM
+};
+
+/**
+ * Transmit FIFO watermark level which triggers (IT Interrupt fires
+ * when _N_ or more empty locations in TX FIFO)
+ */
+enum ssp_tx_level_trig {
+        SSP_TX_1_OR_MORE_EMPTY_LOC,
+        SSP_TX_4_OR_MORE_EMPTY_LOC,
+        SSP_TX_8_OR_MORE_EMPTY_LOC,
+        SSP_TX_16_OR_MORE_EMPTY_LOC,
+        SSP_TX_32_OR_MORE_EMPTY_LOC
+};
+
+/**
+ * enum SPI Clock Phase - clock phase (Motorola SPI interface only)
+ * @SSP_CLK_RISING_EDGE: Receive data on rising edge
+ * @SSP_CLK_FALLING_EDGE: Receive data on falling edge
+ */
+enum ssp_spi_clk_phase {
+        SSP_CLK_RISING_EDGE,
+        SSP_CLK_FALLING_EDGE
+};
+
+/**
+ * enum SPI Clock Polarity - clock polarity (Motorola SPI interface only)
+ * @SSP_CLK_POL_IDLE_LOW: Low inactive level
+ * @SSP_CLK_POL_IDLE_HIGH: High inactive level
+ */
+enum ssp_spi_clk_pol {
+        SSP_CLK_POL_IDLE_LOW,
+        SSP_CLK_POL_IDLE_HIGH
+};
+
+/**
+ * Microwire Conrol Lengths Command size in microwire format
+ */
+enum ssp_microwire_ctrl_len {
+        SSP_BITS_4 = 0x03, SSP_BITS_5, SSP_BITS_6,
+        SSP_BITS_7, SSP_BITS_8, SSP_BITS_9,
+        SSP_BITS_10, SSP_BITS_11, SSP_BITS_12,
+        SSP_BITS_13, SSP_BITS_14, SSP_BITS_15,
+        SSP_BITS_16, SSP_BITS_17, SSP_BITS_18,
+        SSP_BITS_19, SSP_BITS_20, SSP_BITS_21,
+        SSP_BITS_22, SSP_BITS_23, SSP_BITS_24,
+        SSP_BITS_25, SSP_BITS_26, SSP_BITS_27,
+        SSP_BITS_28, SSP_BITS_29, SSP_BITS_30,
+        SSP_BITS_31, SSP_BITS_32
+};
+
+/**
+ * enum Microwire Wait State
+ * @SSP_MWIRE_WAIT_ZERO: No wait state inserted after last command bit
+ * @SSP_MWIRE_WAIT_ONE: One wait state inserted after last command bit
+ */
+enum ssp_microwire_wait_state {
+        SSP_MWIRE_WAIT_ZERO,
+        SSP_MWIRE_WAIT_ONE
+};
+
+/**
+ * enum Microwire - whether Full/Half Duplex
+ * @SSP_MICROWIRE_CHANNEL_FULL_DUPLEX: SSPTXD becomes bi-directional,
+ *     SSPRXD not used
+ * @SSP_MICROWIRE_CHANNEL_HALF_DUPLEX: SSPTXD is an output, SSPRXD is
+ *     an input.
+ */
+enum ssp_duplex {
+        SSP_MICROWIRE_CHANNEL_FULL_DUPLEX,
+        SSP_MICROWIRE_CHANNEL_HALF_DUPLEX
+};
+
+/**
+ * CHIP select/deselect commands
+ */
+enum ssp_chip_select {
+        SSP_CHIP_SELECT,
+        SSP_CHIP_DESELECT
+};
+
+
+/**
+ * struct pl022_ssp_master - device.platform_data for SPI controller devices.
+ * @num_chipselect: chipselects are used to distinguish individual
+ *     SPI slaves, and are numbered from zero to num_chipselects - 1.
+ *     each slave has a chipselect signal, but it's common that not
+ *     every chipselect is connected to a slave.
+ * @enable_dma: if true enables DMA driven transfers.
+ */
+struct pl022_ssp_controller {
+        u16 bus_id;
+        u8 num_chipselect;
+        u8 enable_dma:1;
+};
+
+/**
+ * struct ssp_config_chip - spi_board_info.controller_data for SPI
+ * slave devices, copied to spi_device.controller_data.
+ *
+ * @lbm: used for test purpose to internally connect RX and TX
+ * @iface: Interface type(Motorola, TI, Microwire, Universal)
+ * @hierarchy: sets whether interface is master or slave
+ * @slave_tx_disable: SSPTXD is disconnected (in slave mode only)
+ * @clk_freq: Tune freq parameters of SSP(when in master mode)
+ * @endian_rx: Endianess of Data in Rx FIFO
+ * @endian_tx: Endianess of Data in Tx FIFO
+ * @data_size: Width of data element(4 to 32 bits)
+ * @com_mode: communication mode: polling, Interrupt or DMA
+ * @rx_lev_trig: Rx FIFO watermark level (for IT & DMA mode)
+ * @tx_lev_trig: Tx FIFO watermark level (for IT & DMA mode)
+ * @clk_phase: Motorola SPI interface Clock phase
+ * @clk_pol: Motorola SPI interface Clock polarity
+ * @ctrl_len: Microwire interface: Control length
+ * @wait_state: Microwire interface: Wait state
+ * @duplex: Microwire interface: Full/Half duplex
+ * @cs_control: function pointer to board-specific function to
+ * assert/deassert I/O port to control HW generation of devices chip-select.
+ * @dma_xfer_type: Type of DMA xfer (Mem-to-periph or Periph-to-Periph)
+ * @dma_config: DMA configuration for SSP controller and peripheral
+ */
+struct pl022_config_chip {
+        struct device *dev;
+        enum ssp_loopback lbm;
+        enum ssp_interface iface;
+        enum ssp_hierarchy hierarchy;
+        bool slave_tx_disable;
+        struct ssp_clock_params clk_freq;
+        enum ssp_rx_endian endian_rx;
+        enum ssp_tx_endian endian_tx;
+        enum ssp_data_size data_size;
+        enum ssp_mode com_mode;
+        enum ssp_rx_level_trig rx_lev_trig;
+        enum ssp_tx_level_trig tx_lev_trig;
+        enum ssp_spi_clk_phase clk_phase;
+        enum ssp_spi_clk_pol clk_pol;
+        enum ssp_microwire_ctrl_len ctrl_len;
+        enum ssp_microwire_wait_state wait_state;
+        enum ssp_duplex duplex;
+        void (*cs_control) (u32 control);
+};
+
+#endif /* _SSP_PL022_H */
diff --git a/include/linux/amba/pl061.h b/include/linux/amba/pl061.h
new file mode 100644
index 000000000000..b4fbd9862606
--- /dev/null
+++ b/include/linux/amba/pl061.h
@@ -0,0 +1,15 @@
+/* platform data for the PL061 GPIO driver */
+
+struct pl061_platform_data {
+        /* number of the first GPIO */
+        unsigned        gpio_base;
+
+        /* number of the first IRQ.
+         * If the IRQ functionality in not desired this must be set to
+         * (unsigned) -1.
+         */
+        unsigned        irq_base;
+
+        u8              directions;     /* startup directions, 1: out, 0: in */
+        u8              values;         /* startup values */
+};
diff --git a/include/linux/amba/serial.h b/include/linux/amba/serial.h
index 64a982ea5d5f..5a5a7fd62490 100644
--- a/include/linux/amba/serial.h
+++ b/include/linux/amba/serial.h
@@ -114,6 +114,9 @@
 #define UART011_IFLS_TX4_8      (2 << 0)
 #define UART011_IFLS_TX6_8      (3 << 0)
 #define UART011_IFLS_TX7_8      (4 << 0)
+/* special values for ST vendor with deeper fifo */
+#define UART011_IFLS_RX_HALF    (5 << 3)
+#define UART011_IFLS_TX_HALF    (5 << 0)
 
 #define UART011_OEIM            (1 << 10)       /* overrun error interrupt mask */
 #define UART011_BEIM            (1 << 9)        /* break error interrupt mask */
diff --git a/include/linux/ata.h b/include/linux/ata.h
index 915da43edee1..9c75921f0c16 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -800,6 +800,20 @@ static inline int ata_id_is_ssd(const u16 *id)
         return id[ATA_ID_ROT_SPEED] == 0x01;
 }
 
+static inline int ata_id_pio_need_iordy(const u16 *id, const u8 pio)
+{
+        /* CF spec. r4.1 Table 22 says no IORDY on PIO5 and PIO6. */
+        if (pio > 4 && ata_id_is_cfa(id))
+                return 0;
+        /* For PIO3 and higher it is mandatory. */
+        if (pio > 2)
+                return 1;
+        /* Turn it on when possible. */
+        if (ata_id_has_iordy(id))
+                return 1;
+        return 0;
+}
+
 static inline int ata_drive_40wire(const u16 *dev_id)
 {
         if (ata_id_is_sata(dev_id))
diff --git a/include/linux/atmel-mci.h b/include/linux/atmel-mci.h
index 2f1f95737acb..57b1846a3c87 100644
--- a/include/linux/atmel-mci.h
+++ b/include/linux/atmel-mci.h
@@ -10,6 +10,7 @@
  * @bus_width: Number of data lines wired up the slot
  * @detect_pin: GPIO pin wired to the card detect switch
  * @wp_pin: GPIO pin wired to the write protect sensor
+ * @detect_is_active_high: The state of the detect pin when it is active
  *
  * If a given slot is not present on the board, @bus_width should be
  * set to 0. The other fields are ignored in this case.
@@ -24,6 +25,7 @@ struct mci_slot_pdata {
         unsigned int            bus_width;
         int                     detect_pin;
         int                     wp_pin;
+        bool                    detect_is_active_high;
 };
 
 /**
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 4fa2810b675e..3c7a358241a7 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -599,6 +599,8 @@ extern void		    audit_log_untrustedstring(struct audit_buffer *ab,
 extern void                 audit_log_d_path(struct audit_buffer *ab,
                                              const char *prefix,
                                              struct path *path);
+extern void                 audit_log_key(struct audit_buffer *ab,
+                                          char *key);
 extern void                 audit_log_lost(const char *message);
 extern int                  audit_update_lsm_rules(void);
 
@@ -621,6 +623,7 @@ extern int audit_enabled;
 #define audit_log_n_untrustedstring(a,n,s) do { ; } while (0)
 #define audit_log_untrustedstring(a,s) do { ; } while (0)
 #define audit_log_d_path(b, p, d) do { ; } while (0)
+#define audit_log_key(b, k) do { ; } while (0)
 #define audit_enabled 0
 #endif
 #endif
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 0ec2c594868e..1d52425a6118 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -229,9 +229,14 @@ static inline int bdi_rw_congested(struct backing_dev_info *bdi)
                                   (1 << BDI_async_congested));
 }
 
-void clear_bdi_congested(struct backing_dev_info *bdi, int rw);
-void set_bdi_congested(struct backing_dev_info *bdi, int rw);
-long congestion_wait(int rw, long timeout);
+enum {
+        BLK_RW_ASYNC    = 0,
+        BLK_RW_SYNC     = 1,
+};
+
+void clear_bdi_congested(struct backing_dev_info *bdi, int sync);
+void set_bdi_congested(struct backing_dev_info *bdi, int sync);
+long congestion_wait(int sync, long timeout);
 
 
 static inline bool bdi_cap_writeback_dirty(struct backing_dev_info *bdi)
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 7b214fd672a2..2892b710771c 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -218,12 +218,12 @@ struct bio {
 #define bio_sectors(bio)        ((bio)->bi_size >> 9)
 #define bio_empty_barrier(bio)  (bio_barrier(bio) && !bio_has_data(bio) && !bio_discard(bio))
 
-static inline unsigned int bio_cur_sectors(struct bio *bio)
+static inline unsigned int bio_cur_bytes(struct bio *bio)
 {
         if (bio->bi_vcnt)
-                return bio_iovec(bio)->bv_len >> 9;
+                return bio_iovec(bio)->bv_len;
         else /* dataless requests such as discard */
-                return bio->bi_size >> 9;
+                return bio->bi_size;
 }
 
 static inline void *bio_data(struct bio *bio)
@@ -279,7 +279,7 @@ static inline int bio_has_allocated_vec(struct bio *bio)
 #define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
         (((addr1) | (mask)) == (((addr2) - 1) | (mask)))
 #define BIOVEC_SEG_BOUNDARY(q, b1, b2) \
-        __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, (q)->seg_boundary_mask)
+        __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, queue_segment_boundary((q)))
 #define BIO_SEG_BOUNDARY(q, b1, b2) \
         BIOVEC_SEG_BOUNDARY((q), __BVEC_END((b1)), __BVEC_START((b2)))
 
@@ -319,7 +319,6 @@ static inline int bio_has_allocated_vec(struct bio *bio)
  */
 struct bio_integrity_payload {
         struct bio              *bip_bio;       /* parent bio */
-        struct bio_vec          *bip_vec;       /* integrity data vector */
 
         sector_t                bip_sector;     /* virtual start sector */
 
@@ -328,11 +327,12 @@ struct bio_integrity_payload {
 
         unsigned int            bip_size;
 
-        unsigned short          bip_pool;       /* pool the ivec came from */
+        unsigned short          bip_slab;       /* slab the bip came from */
         unsigned short          bip_vcnt;       /* # of integrity bio_vecs */
         unsigned short          bip_idx;        /* current bip_vec index */
 
         struct work_struct      bip_work;       /* I/O completion */
+        struct bio_vec          bip_vec[0];     /* embedded bvec array */
 };
 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 
@@ -430,6 +430,9 @@ struct bio_set {
         unsigned int front_pad;
 
         mempool_t *bio_pool;
+#if defined(CONFIG_BLK_DEV_INTEGRITY)
+        mempool_t *bio_integrity_pool;
+#endif
         mempool_t *bvec_pool;
 };
 
@@ -506,7 +509,7 @@ static inline int bio_has_data(struct bio *bio)
 }
 
 /*
- * BIO list managment for use by remapping drivers (e.g. DM or MD).
+ * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
  *
  * A bio_list anchors a singly-linked list of bios chained through the bi_next
  * member of the bio.  The bio_list also caches the last list member to allow
@@ -590,6 +593,11 @@ static inline void bio_list_merge_head(struct bio_list *bl,
         bl->head = bl2->head;
 }
 
+static inline struct bio *bio_list_peek(struct bio_list *bl)
+{
+        return bl->head;
+}
+
 static inline struct bio *bio_list_pop(struct bio_list *bl)
 {
         struct bio *bio = bl->head;
@@ -629,8 +637,9 @@ static inline struct bio *bio_list_get(struct bio_list *bl)
 
 #define bio_integrity(bio) (bio->bi_integrity != NULL)
 
+extern struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *, gfp_t, unsigned int, struct bio_set *);
 extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
-extern void bio_integrity_free(struct bio *);
+extern void bio_integrity_free(struct bio *, struct bio_set *);
 extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
 extern int bio_integrity_enabled(struct bio *bio);
 extern int bio_integrity_set_tag(struct bio *, void *, unsigned int);
@@ -640,21 +649,27 @@ extern void bio_integrity_endio(struct bio *, int);
 extern void bio_integrity_advance(struct bio *, unsigned int);
 extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int);
 extern void bio_integrity_split(struct bio *, struct bio_pair *, int);
-extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
+extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t, struct bio_set *);
+extern int bioset_integrity_create(struct bio_set *, int);
+extern void bioset_integrity_free(struct bio_set *);
+extern void bio_integrity_init(void);
 
 #else /* CONFIG_BLK_DEV_INTEGRITY */
 
 #define bio_integrity(a)                (0)
+#define bioset_integrity_create(a, b)   (0)
 #define bio_integrity_prep(a)           (0)
 #define bio_integrity_enabled(a)        (0)
-#define bio_integrity_clone(a, b, c)    (0)
-#define bio_integrity_free(a)           do { } while (0)
+#define bio_integrity_clone(a, b, c, d) (0)
+#define bioset_integrity_free(a)        do { } while (0)
+#define bio_integrity_free(a, b)        do { } while (0)
 #define bio_integrity_endio(a, b)       do { } while (0)
 #define bio_integrity_advance(a, b)     do { } while (0)
 #define bio_integrity_trim(a, b, c)     do { } while (0)
 #define bio_integrity_split(a, b, c)    do { } while (0)
 #define bio_integrity_set_tag(a, b, c)  do { } while (0)
 #define bio_integrity_get_tag(a, b, c)  do { } while (0)
+#define bio_integrity_init(a)           do { } while (0)
 
 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index b4f71f1a4af7..69103e053c92 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -70,11 +70,6 @@ enum rq_cmd_type_bits {
         REQ_TYPE_ATA_PC,
 };
 
-enum {
-        BLK_RW_ASYNC    = 0,
-        BLK_RW_SYNC     = 1,
-};
-
 /*
  * For request of type REQ_TYPE_LINUX_BLOCK, rq->cmd[0] is the opcode being
  * sent down (similar to how REQ_TYPE_BLOCK_PC means that ->cmd[] holds a
@@ -166,19 +161,9 @@ struct request {
         enum rq_cmd_type_bits cmd_type;
         unsigned long atomic_flags;
 
-        /* Maintain bio traversal state for part by part I/O submission.
-         * hard_* are block layer internals, no driver should touch them!
-         */
-
-        sector_t sector;                /* next sector to submit */
-        sector_t hard_sector;           /* next sector to complete */
-        unsigned long nr_sectors;       /* no. of sectors left to submit */
-        unsigned long hard_nr_sectors;  /* no. of sectors left to complete */
-        /* no. of sectors left to submit in the current segment */
-        unsigned int current_nr_sectors;
-
-        /* no. of sectors left to complete in the current segment */
-        unsigned int hard_cur_sectors;
+        /* the following two fields are internal, NEVER access directly */
+        sector_t __sector;              /* sector cursor */
+        unsigned int __data_len;        /* total data len */
 
         struct bio *bio;
         struct bio *biotail;
@@ -211,8 +196,8 @@ struct request {
 
         unsigned short ioprio;
 
-        void *special;
-        char *buffer;
+        void *special;          /* opaque pointer available for LLD use */
+        char *buffer;           /* kaddr of the current segment if available */
 
         int tag;
         int errors;
@@ -226,10 +211,9 @@ struct request {
         unsigned char __cmd[BLK_MAX_CDB];
         unsigned char *cmd;
 
-        unsigned int data_len;
         unsigned int extra_len; /* length of alignment and padding */
         unsigned int sense_len;
-        void *data;
+        unsigned int resid_len; /* residual count */
         void *sense;
 
         unsigned long deadline;
@@ -312,10 +296,24 @@ struct blk_queue_tag {
 #define BLK_SCSI_MAX_CMDS       (256)
 #define BLK_SCSI_CMD_PER_LONG   (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
 
-struct blk_cmd_filter {
-        unsigned long read_ok[BLK_SCSI_CMD_PER_LONG];
-        unsigned long write_ok[BLK_SCSI_CMD_PER_LONG];
-        struct kobject kobj;
+struct queue_limits {
+        unsigned long           bounce_pfn;
+        unsigned long           seg_boundary_mask;
+
+        unsigned int            max_hw_sectors;
+        unsigned int            max_sectors;
+        unsigned int            max_segment_size;
+        unsigned int            physical_block_size;
+        unsigned int            alignment_offset;
+        unsigned int            io_min;
+        unsigned int            io_opt;
+
+        unsigned short          logical_block_size;
+        unsigned short          max_hw_segments;
+        unsigned short          max_phys_segments;
+
+        unsigned char           misaligned;
+        unsigned char           no_cluster;
 };
 
 struct request_queue
@@ -369,7 +367,6 @@ struct request_queue
         /*
          * queue needs bounce pages for pages above this limit
          */
-        unsigned long           bounce_pfn;
         gfp_t                   bounce_gfp;
 
         /*
@@ -398,14 +395,6 @@ struct request_queue
         unsigned int            nr_congestion_off;
         unsigned int            nr_batching;
 
-        unsigned int            max_sectors;
-        unsigned int            max_hw_sectors;
-        unsigned short          max_phys_segments;
-        unsigned short          max_hw_segments;
-        unsigned short          hardsect_size;
-        unsigned int            max_segment_size;
-
-        unsigned long           seg_boundary_mask;
         void                    *dma_drain_buffer;
         unsigned int            dma_drain_size;
         unsigned int            dma_pad_mask;
@@ -415,12 +404,14 @@ struct request_queue
         struct list_head        tag_busy_list;
 
         unsigned int            nr_sorted;
-        unsigned int            in_flight;
+        unsigned int            in_flight[2];
 
         unsigned int            rq_timeout;
         struct timer_list       timeout;
         struct list_head        timeout_list;
 
+        struct queue_limits     limits;
+
         /*
          * sg stuff
          */
@@ -443,7 +434,6 @@ struct request_queue
 #if defined(CONFIG_BLK_DEV_BSG)
         struct bsg_class_device bsg_dev;
 #endif
-        struct blk_cmd_filter cmd_filter;
 };
 
 #define QUEUE_FLAG_CLUSTER      0       /* cluster several segments into 1 */
@@ -522,6 +512,11 @@ static inline void queue_flag_clear_unlocked(unsigned int flag,
         __clear_bit(flag, &q->queue_flags);
 }
 
+static inline int queue_in_flight(struct request_queue *q)
+{
+        return q->in_flight[0] + q->in_flight[1];
+}
+
 static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
 {
         WARN_ON_ONCE(!queue_is_locked(q));
@@ -723,6 +718,7 @@ struct rq_map_data {
         int nr_entries;
         unsigned long offset;
         int null_mapped;
+        int from_user;
 };
 
 struct req_iterator {
@@ -752,10 +748,17 @@ extern void blk_rq_init(struct request_queue *q, struct request *rq);
 extern void blk_put_request(struct request *);
 extern void __blk_put_request(struct request_queue *, struct request *);
 extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
+extern struct request *blk_make_request(struct request_queue *, struct bio *,
+                                        gfp_t);
 extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
 extern void blk_requeue_request(struct request_queue *, struct request *);
 extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
 extern int blk_lld_busy(struct request_queue *q);
+extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
+                             struct bio_set *bs, gfp_t gfp_mask,
+                             int (*bio_ctr)(struct bio *, struct bio *, void *),
+                             void *data);
+extern void blk_rq_unprep_clone(struct request *rq);
 extern int blk_insert_cloned_request(struct request_queue *q,
                                      struct request *rq);
 extern void blk_plug_device(struct request_queue *);
@@ -768,28 +771,22 @@ extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
                          struct scsi_ioctl_command __user *);
 
 /*
- * Temporary export, until SCSI gets fixed up.
- */
-extern int blk_rq_append_bio(struct request_queue *q, struct request *rq,
-                             struct bio *bio);
-
-/*
  * A queue has just exitted congestion.  Note this in the global counter of
  * congested queues, and wake up anyone who was waiting for requests to be
  * put back.
  */
-static inline void blk_clear_queue_congested(struct request_queue *q, int rw)
+static inline void blk_clear_queue_congested(struct request_queue *q, int sync)
 {
-        clear_bdi_congested(&q->backing_dev_info, rw);
+        clear_bdi_congested(&q->backing_dev_info, sync);
 }
 
 /*
  * A queue has just entered congestion.  Flag that in the queue's VM-visible
  * state flags and increment the global gounter of congested queues.
  */
-static inline void blk_set_queue_congested(struct request_queue *q, int rw)
+static inline void blk_set_queue_congested(struct request_queue *q, int sync)
 {
-        set_bdi_congested(&q->backing_dev_info, rw);
+        set_bdi_congested(&q->backing_dev_info, sync);
 }
 
 extern void blk_start_queue(struct request_queue *q);
@@ -798,7 +795,6 @@ extern void blk_sync_queue(struct request_queue *q);
 extern void __blk_stop_queue(struct request_queue *q);
 extern void __blk_run_queue(struct request_queue *);
 extern void blk_run_queue(struct request_queue *);
-extern void blk_start_queueing(struct request_queue *);
 extern int blk_rq_map_user(struct request_queue *, struct request *,
                            struct rq_map_data *, void __user *, unsigned long,
                            gfp_t);
@@ -831,41 +827,73 @@ static inline void blk_run_address_space(struct address_space *mapping)
                 blk_run_backing_dev(mapping->backing_dev_info, NULL);
 }
 
-extern void blkdev_dequeue_request(struct request *req);
+/*
+ * blk_rq_pos()         : the current sector
+ * blk_rq_bytes()       : bytes left in the entire request
+ * blk_rq_cur_bytes()   : bytes left in the current segment
+ * blk_rq_sectors()     : sectors left in the entire request
+ * blk_rq_cur_sectors() : sectors left in the current segment
+ */
+static inline sector_t blk_rq_pos(const struct request *rq)
+{
+        return rq->__sector;
+}
+
+static inline unsigned int blk_rq_bytes(const struct request *rq)
+{
+        return rq->__data_len;
+}
+
+static inline int blk_rq_cur_bytes(const struct request *rq)
+{
+        return rq->bio ? bio_cur_bytes(rq->bio) : 0;
+}
+
+static inline unsigned int blk_rq_sectors(const struct request *rq)
+{
+        return blk_rq_bytes(rq) >> 9;
+}
+
+static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
+{
+        return blk_rq_cur_bytes(rq) >> 9;
+}
 
 /*
- * blk_end_request() and friends.
- * __blk_end_request() and end_request() must be called with
- * the request queue spinlock acquired.
+ * Request issue related functions.
+ */
+extern struct request *blk_peek_request(struct request_queue *q);
+extern void blk_start_request(struct request *rq);
+extern struct request *blk_fetch_request(struct request_queue *q);
+
+/*
+ * Request completion related functions.
+ *
+ * blk_update_request() completes given number of bytes and updates
+ * the request without completing it.
+ *
+ * blk_end_request() and friends.  __blk_end_request() must be called
+ * with the request queue spinlock acquired.
  *
  * Several drivers define their own end_request and call
  * blk_end_request() for parts of the original function.
  * This prevents code duplication in drivers.
  */
-extern int blk_end_request(struct request *rq, int error,
-                                unsigned int nr_bytes);
-extern int __blk_end_request(struct request *rq, int error,
-                                unsigned int nr_bytes);
-extern int blk_end_bidi_request(struct request *rq, int error,
-                                unsigned int nr_bytes, unsigned int bidi_bytes);
-extern void end_request(struct request *, int);
-extern int blk_end_request_callback(struct request *rq, int error,
-                                unsigned int nr_bytes,
-                                int (drv_callback)(struct request *));
+extern bool blk_update_request(struct request *rq, int error,
+                               unsigned int nr_bytes);
+extern bool blk_end_request(struct request *rq, int error,
+                            unsigned int nr_bytes);
+extern void blk_end_request_all(struct request *rq, int error);
+extern bool blk_end_request_cur(struct request *rq, int error);
+extern bool __blk_end_request(struct request *rq, int error,
+                              unsigned int nr_bytes);
+extern void __blk_end_request_all(struct request *rq, int error);
+extern bool __blk_end_request_cur(struct request *rq, int error);
+
 extern void blk_complete_request(struct request *);
 extern void __blk_complete_request(struct request *);
 extern void blk_abort_request(struct request *);
 extern void blk_abort_queue(struct request_queue *);
-extern void blk_update_request(struct request *rq, int error,
-                               unsigned int nr_bytes);
-
-/*
- * blk_end_request() takes bytes instead of sectors as a complete size.
- * blk_rq_bytes() returns bytes left to complete in the entire request.
- * blk_rq_cur_bytes() returns bytes left to complete in the current segment.
- */
-extern unsigned int blk_rq_bytes(struct request *rq);
-extern unsigned int blk_rq_cur_bytes(struct request *rq);
 
 /*
  * Access functions for manipulating queue properties
@@ -877,10 +905,22 @@ extern void blk_cleanup_queue(struct request_queue *);
 extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 extern void blk_queue_bounce_limit(struct request_queue *, u64);
 extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
+extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
 extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
-extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
+extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
+extern void blk_queue_physical_block_size(struct request_queue *, unsigned short);
+extern void blk_queue_alignment_offset(struct request_queue *q,
+                                       unsigned int alignment);
+extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
+extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
+extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
+extern void blk_set_default_limits(struct queue_limits *lim);
+extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
+                            sector_t offset);
+extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
+                              sector_t offset);
 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
 extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
 extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
@@ -948,13 +988,7 @@ static inline int sb_issue_discard(struct super_block *sb,
         return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL);
 }
 
-/*
-* command filter functions
-*/
-extern int blk_verify_command(struct blk_cmd_filter *filter,
-                              unsigned char *cmd, fmode_t has_write_perm);
-extern void blk_unregister_filter(struct gendisk *disk);
-extern void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter);
+extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
 
 #define MAX_PHYS_SEGMENTS 128
 #define MAX_HW_SEGMENTS 128
@@ -967,19 +1001,87 @@ extern void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter);
 
 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
 
-static inline int queue_hardsect_size(struct request_queue *q)
+static inline unsigned long queue_bounce_pfn(struct request_queue *q)
+{
+        return q->limits.bounce_pfn;
+}
+
+static inline unsigned long queue_segment_boundary(struct request_queue *q)
+{
+        return q->limits.seg_boundary_mask;
+}
+
+static inline unsigned int queue_max_sectors(struct request_queue *q)
+{
+        return q->limits.max_sectors;
+}
+
+static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
+{
+        return q->limits.max_hw_sectors;
+}
+
+static inline unsigned short queue_max_hw_segments(struct request_queue *q)
+{
+        return q->limits.max_hw_segments;
+}
+
+static inline unsigned short queue_max_phys_segments(struct request_queue *q)
+{
+        return q->limits.max_phys_segments;
+}
+
+static inline unsigned int queue_max_segment_size(struct request_queue *q)
+{
+        return q->limits.max_segment_size;
+}
+
+static inline unsigned short queue_logical_block_size(struct request_queue *q)
 {
         int retval = 512;
 
-        if (q && q->hardsect_size)
-                retval = q->hardsect_size;
+        if (q && q->limits.logical_block_size)
+                retval = q->limits.logical_block_size;
 
         return retval;
 }
 
-static inline int bdev_hardsect_size(struct block_device *bdev)
+static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
+{
+        return queue_logical_block_size(bdev_get_queue(bdev));
+}
+
+static inline unsigned int queue_physical_block_size(struct request_queue *q)
+{
+        return q->limits.physical_block_size;
+}
+
+static inline unsigned int queue_io_min(struct request_queue *q)
+{
+        return q->limits.io_min;
+}
+
+static inline unsigned int queue_io_opt(struct request_queue *q)
+{
+        return q->limits.io_opt;
+}
+
+static inline int queue_alignment_offset(struct request_queue *q)
+{
+        if (q && q->limits.misaligned)
+                return -1;
+
+        if (q && q->limits.alignment_offset)
+                return q->limits.alignment_offset;
+
+        return 0;
+}
+
+static inline int queue_sector_alignment_offset(struct request_queue *q,
+                                                sector_t sector)
 {
-        return queue_hardsect_size(bdev_get_queue(bdev));
+        return ((sector << 9) - q->limits.alignment_offset)
+                & (q->limits.io_min - 1);
 }
 
 static inline int queue_dma_alignment(struct request_queue *q)
@@ -1109,6 +1211,8 @@ struct block_device_operations {
         int (*direct_access) (struct block_device *, sector_t,
                                                 void **, unsigned long *);
         int (*media_changed) (struct gendisk *);
+        unsigned long long (*set_capacity) (struct gendisk *,
+                                                unsigned long long);
         int (*revalidate_disk) (struct gendisk *);
         int (*getgeo)(struct block_device *, struct hd_geometry *);
         struct module *owner;
diff --git a/include/linux/blktrace_api.h b/include/linux/blktrace_api.h
index d960889e92ef..7e4350ece0f8 100644
--- a/include/linux/blktrace_api.h
+++ b/include/linux/blktrace_api.h
@@ -116,9 +116,9 @@ struct blk_io_trace {
  * The remap event
  */
 struct blk_io_trace_remap {
-        __be32 device;
         __be32 device_from;
-        __be64 sector;
+        __be32 device_to;
+        __be64 sector_from;
 };
 
 enum {
@@ -165,8 +165,9 @@ struct blk_trace {
 
 extern int blk_trace_ioctl(struct block_device *, unsigned, char __user *);
 extern void blk_trace_shutdown(struct request_queue *);
-extern int do_blk_trace_setup(struct request_queue *q,
-        char *name, dev_t dev, struct blk_user_trace_setup *buts);
+extern int do_blk_trace_setup(struct request_queue *q, char *name,
+                              dev_t dev, struct block_device *bdev,
+                              struct blk_user_trace_setup *buts);
 extern void __trace_note_message(struct blk_trace *, const char *fmt, ...);
 
 /**
@@ -193,22 +194,42 @@ extern void __trace_note_message(struct blk_trace *, const char *fmt, ...);
 extern void blk_add_driver_data(struct request_queue *q, struct request *rq,
                                 void *data, size_t len);
 extern int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
+                           struct block_device *bdev,
                            char __user *arg);
 extern int blk_trace_startstop(struct request_queue *q, int start);
 extern int blk_trace_remove(struct request_queue *q);
+extern int blk_trace_init_sysfs(struct device *dev);
 
 extern struct attribute_group blk_trace_attr_group;
 
 #else /* !CONFIG_BLK_DEV_IO_TRACE */
-#define blk_trace_ioctl(bdev, cmd, arg)         (-ENOTTY)
-#define blk_trace_shutdown(q)                   do { } while (0)
-#define do_blk_trace_setup(q, name, dev, buts)  (-ENOTTY)
-#define blk_add_driver_data(q, rq, data, len)   do {} while (0)
-#define blk_trace_setup(q, name, dev, arg)      (-ENOTTY)
-#define blk_trace_startstop(q, start)           (-ENOTTY)
-#define blk_trace_remove(q)                     (-ENOTTY)
-#define blk_add_trace_msg(q, fmt, ...)          do { } while (0)
+# define blk_trace_ioctl(bdev, cmd, arg)                (-ENOTTY)
+# define blk_trace_shutdown(q)                          do { } while (0)
+# define do_blk_trace_setup(q, name, dev, bdev, buts)   (-ENOTTY)
+# define blk_add_driver_data(q, rq, data, len)          do {} while (0)
+# define blk_trace_setup(q, name, dev, bdev, arg)       (-ENOTTY)
+# define blk_trace_startstop(q, start)                  (-ENOTTY)
+# define blk_trace_remove(q)                            (-ENOTTY)
+# define blk_add_trace_msg(q, fmt, ...)                 do { } while (0)
+static inline int blk_trace_init_sysfs(struct device *dev)
+{
+        return 0;
+}
 
 #endif /* CONFIG_BLK_DEV_IO_TRACE */
+
+#if defined(CONFIG_EVENT_TRACING) && defined(CONFIG_BLOCK)
+
+static inline int blk_cmd_buf_len(struct request *rq)
+{
+        return blk_pc_request(rq) ? rq->cmd_len * 3 : 1;
+}
+
+extern void blk_dump_cmd(char *buf, struct request *rq);
+extern void blk_fill_rwbs(char *rwbs, u32 rw, int bytes);
+extern void blk_fill_rwbs_rq(char *rwbs, struct request *rq);
+
+#endif /* CONFIG_EVENT_TRACING && CONFIG_BLOCK */
+
 #endif /* __KERNEL__ */
 #endif
diff --git a/include/linux/bug.h b/include/linux/bug.h
index 54398d2c6d8d..d276b5510c83 100644
--- a/include/linux/bug.h
+++ b/include/linux/bug.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_BUG_H
 #define _LINUX_BUG_H
 
-#include <linux/module.h>
 #include <asm/bug.h>
 
 enum bug_trap_type {
@@ -24,10 +23,6 @@ const struct bug_entry *find_bug(unsigned long bugaddr);
 
 enum bug_trap_type report_bug(unsigned long bug_addr, struct pt_regs *regs);
 
-int  module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
-                         struct module *);
-void module_bug_cleanup(struct module *);
-
 /* These are defined by the architecture */
 int is_valid_bugaddr(unsigned long addr);
 
@@ -38,13 +33,6 @@ static inline enum bug_trap_type report_bug(unsigned long bug_addr,
 {
         return BUG_TRAP_TYPE_BUG;
 }
-static inline int  module_bug_finalize(const Elf_Ehdr *hdr,
-                                        const Elf_Shdr *sechdrs,
-                                        struct module *mod)
-{
-        return 0;
-}
-static inline void module_bug_cleanup(struct module *mod) {}
 
 #endif  /* CONFIG_GENERIC_BUG */
 #endif  /* _LINUX_BUG_H */
diff --git a/include/linux/c2port.h b/include/linux/c2port.h
index 7b5a2388ba67..2a5cd867c365 100644
--- a/include/linux/c2port.h
+++ b/include/linux/c2port.h
@@ -10,6 +10,7 @@
  */
 
 #include <linux/device.h>
+#include <linux/kmemcheck.h>
 
 #define C2PORT_NAME_LEN                 32
 
@@ -20,8 +21,10 @@
 /* Main struct */
 struct c2port_ops;
 struct c2port_device {
+        kmemcheck_bitfield_begin(flags);
         unsigned int access:1;
         unsigned int flash_access:1;
+        kmemcheck_bitfield_end(flags);
 
         int id;
         char name[C2PORT_NAME_LEN];
diff --git a/include/linux/can/Kbuild b/include/linux/can/Kbuild
index eff898aac02b..8cb05aae661c 100644
--- a/include/linux/can/Kbuild
+++ b/include/linux/can/Kbuild
@@ -1,3 +1,4 @@
 header-y += raw.h
 header-y += bcm.h
 header-y += error.h
+header-y += netlink.h
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
new file mode 100644
index 000000000000..4a37a56f6cdd
--- /dev/null
+++ b/include/linux/can/dev.h
@@ -0,0 +1,70 @@
+/*
+ * linux/can/dev.h
+ *
+ * Definitions for the CAN network device driver interface
+ *
+ * Copyright (C) 2006 Andrey Volkov <avolkov@varma-el.com>
+ *               Varma Electronics Oy
+ *
+ * Copyright (C) 2008 Wolfgang Grandegger <wg@grandegger.com>
+ *
+ * Send feedback to <socketcan-users@lists.berlios.de>
+ */
+
+#ifndef CAN_DEV_H
+#define CAN_DEV_H
+
+#include <linux/can/netlink.h>
+#include <linux/can/error.h>
+
+/*
+ * CAN mode
+ */
+enum can_mode {
+        CAN_MODE_STOP = 0,
+        CAN_MODE_START,
+        CAN_MODE_SLEEP
+};
+
+/*
+ * CAN common private data
+ */
+#define CAN_ECHO_SKB_MAX  4
+
+struct can_priv {
+        struct can_device_stats can_stats;
+
+        struct can_bittiming bittiming;
+        struct can_bittiming_const *bittiming_const;
+        struct can_clock clock;
+
+        enum can_state state;
+        u32 ctrlmode;
+
+        int restart_ms;
+        struct timer_list restart_timer;
+
+        struct sk_buff *echo_skb[CAN_ECHO_SKB_MAX];
+
+        int (*do_set_bittiming)(struct net_device *dev);
+        int (*do_set_mode)(struct net_device *dev, enum can_mode mode);
+        int (*do_get_state)(const struct net_device *dev,
+                            enum can_state *state);
+};
+
+struct net_device *alloc_candev(int sizeof_priv);
+void free_candev(struct net_device *dev);
+
+int open_candev(struct net_device *dev);
+void close_candev(struct net_device *dev);
+
+int register_candev(struct net_device *dev);
+void unregister_candev(struct net_device *dev);
+
+int can_restart_now(struct net_device *dev);
+void can_bus_off(struct net_device *dev);
+
+void can_put_echo_skb(struct sk_buff *skb, struct net_device *dev, int idx);
+void can_get_echo_skb(struct net_device *dev, int idx);
+
+#endif /* CAN_DEV_H */
diff --git a/include/linux/can/netlink.h b/include/linux/can/netlink.h
new file mode 100644
index 000000000000..9ecbb7871c0e
--- /dev/null
+++ b/include/linux/can/netlink.h
@@ -0,0 +1,113 @@
+/*
+ * linux/can/netlink.h
+ *
+ * Definitions for the CAN netlink interface
+ *
+ * Copyright (c) 2009 Wolfgang Grandegger <wg@grandegger.com>
+ *
+ * Send feedback to <socketcan-users@lists.berlios.de>
+ *
+ */
+
+#ifndef CAN_NETLINK_H
+#define CAN_NETLINK_H
+
+#include <linux/types.h>
+
+/*
+ * CAN bit-timing parameters
+ *
+ * For futher information, please read chapter "8 BIT TIMING
+ * REQUIREMENTS" of the "Bosch CAN Specification version 2.0"
+ * at http://www.semiconductors.bosch.de/pdf/can2spec.pdf.
+ */
+struct can_bittiming {
+        __u32 bitrate;          /* Bit-rate in bits/second */
+        __u32 sample_point;     /* Sample point in one-tenth of a percent */
+        __u32 tq;               /* Time quanta (TQ) in nanoseconds */
+        __u32 prop_seg;         /* Propagation segment in TQs */
+        __u32 phase_seg1;       /* Phase buffer segment 1 in TQs */
+        __u32 phase_seg2;       /* Phase buffer segment 2 in TQs */
+        __u32 sjw;              /* Synchronisation jump width in TQs */
+        __u32 brp;              /* Bit-rate prescaler */
+};
+
+/*
+ * CAN harware-dependent bit-timing constant
+ *
+ * Used for calculating and checking bit-timing parameters
+ */
+struct can_bittiming_const {
+        char name[16];          /* Name of the CAN controller hardware */
+        __u32 tseg1_min;        /* Time segement 1 = prop_seg + phase_seg1 */
+        __u32 tseg1_max;
+        __u32 tseg2_min;        /* Time segement 2 = phase_seg2 */
+        __u32 tseg2_max;
+        __u32 sjw_max;          /* Synchronisation jump width */
+        __u32 brp_min;          /* Bit-rate prescaler */
+        __u32 brp_max;
+        __u32 brp_inc;
+};
+
+/*
+ * CAN clock parameters
+ */
+struct can_clock {
+        __u32 freq;             /* CAN system clock frequency in Hz */
+};
+
+/*
+ * CAN operational and error states
+ */
+enum can_state {
+        CAN_STATE_ERROR_ACTIVE = 0,     /* RX/TX error count < 96 */
+        CAN_STATE_ERROR_WARNING,        /* RX/TX error count < 128 */
+        CAN_STATE_ERROR_PASSIVE,        /* RX/TX error count < 256 */
+        CAN_STATE_BUS_OFF,              /* RX/TX error count >= 256 */
+        CAN_STATE_STOPPED,              /* Device is stopped */
+        CAN_STATE_SLEEPING,             /* Device is sleeping */
+        CAN_STATE_MAX
+};
+
+/*
+ * CAN controller mode
+ */
+struct can_ctrlmode {
+        __u32 mask;
+        __u32 flags;
+};
+
+#define CAN_CTRLMODE_LOOPBACK   0x1     /* Loopback mode */
+#define CAN_CTRLMODE_LISTENONLY 0x2     /* Listen-only mode */
+#define CAN_CTRLMODE_3_SAMPLES  0x4     /* Triple sampling mode */
+
+/*
+ * CAN device statistics
+ */
+struct can_device_stats {
+        __u32 bus_error;        /* Bus errors */
+        __u32 error_warning;    /* Changes to error warning state */
+        __u32 error_passive;    /* Changes to error passive state */
+        __u32 bus_off;          /* Changes to bus off state */
+        __u32 arbitration_lost; /* Arbitration lost errors */
+        __u32 restarts;         /* CAN controller re-starts */
+};
+
+/*
+ * CAN netlink interface
+ */
+enum {
+        IFLA_CAN_UNSPEC,
+        IFLA_CAN_BITTIMING,
+        IFLA_CAN_BITTIMING_CONST,
+        IFLA_CAN_CLOCK,
+        IFLA_CAN_STATE,
+        IFLA_CAN_CTRLMODE,
+        IFLA_CAN_RESTART_MS,
+        IFLA_CAN_RESTART,
+        __IFLA_CAN_MAX
+};
+
+#define IFLA_CAN_MAX    (__IFLA_CAN_MAX - 1)
+
+#endif /* CAN_NETLINK_H */
diff --git a/include/linux/can/platform/sja1000.h b/include/linux/can/platform/sja1000.h
new file mode 100644
index 000000000000..01ee2aeb048d
--- /dev/null
+++ b/include/linux/can/platform/sja1000.h
@@ -0,0 +1,35 @@
+#ifndef _CAN_PLATFORM_SJA1000_H_
+#define _CAN_PLATFORM_SJA1000_H_
+
+/* clock divider register */
+#define CDR_CLKOUT_MASK 0x07
+#define CDR_CLK_OFF     0x08 /* Clock off (CLKOUT pin) */
+#define CDR_RXINPEN     0x20 /* TX1 output is RX irq output */
+#define CDR_CBP         0x40 /* CAN input comparator bypass */
+#define CDR_PELICAN     0x80 /* PeliCAN mode */
+
+/* output control register */
+#define OCR_MODE_BIPHASE  0x00
+#define OCR_MODE_TEST     0x01
+#define OCR_MODE_NORMAL   0x02
+#define OCR_MODE_CLOCK    0x03
+#define OCR_MODE_MASK     0x07
+#define OCR_TX0_INVERT    0x04
+#define OCR_TX0_PULLDOWN  0x08
+#define OCR_TX0_PULLUP    0x10
+#define OCR_TX0_PUSHPULL  0x18
+#define OCR_TX1_INVERT    0x20
+#define OCR_TX1_PULLDOWN  0x40
+#define OCR_TX1_PULLUP    0x80
+#define OCR_TX1_PUSHPULL  0xc0
+#define OCR_TX_MASK       0xfc
+#define OCR_TX_SHIFT      2
+
+struct sja1000_platform_data {
+        u32 clock;      /* CAN bus oscillator frequency in Hz */
+
+        u8 ocr;         /* output control register */
+        u8 cdr;         /* clock divider register */
+};
+
+#endif  /* !_CAN_PLATFORM_SJA1000_H_ */
diff --git a/include/linux/cb710.h b/include/linux/cb710.h
new file mode 100644
index 000000000000..8cc10411bab2
--- /dev/null
+++ b/include/linux/cb710.h
@@ -0,0 +1,208 @@
+/*
+ *  cb710/cb710.h
+ *
+ *  Copyright by Michał Mirosław, 2008-2009
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef LINUX_CB710_DRIVER_H
+#define LINUX_CB710_DRIVER_H
+
+#include <linux/io.h>
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+#include <linux/pci.h>
+#include <linux/platform_device.h>
+#include <linux/mmc/host.h>
+
+struct cb710_slot;
+
+typedef int (*cb710_irq_handler_t)(struct cb710_slot *);
+
+/* per-virtual-slot structure */
+struct cb710_slot {
+        struct platform_device  pdev;
+        void __iomem            *iobase;
+        cb710_irq_handler_t     irq_handler;
+};
+
+/* per-device structure */
+struct cb710_chip {
+        struct pci_dev          *pdev;
+        void __iomem            *iobase;
+        unsigned                platform_id;
+#ifdef CONFIG_CB710_DEBUG_ASSUMPTIONS
+        atomic_t                slot_refs_count;
+#endif
+        unsigned                slot_mask;
+        unsigned                slots;
+        spinlock_t              irq_lock;
+        struct cb710_slot       slot[0];
+};
+
+/* NOTE: cb710_chip.slots is modified only during device init/exit and
+ * they are all serialized wrt themselves */
+
+/* cb710_chip.slot_mask values */
+#define CB710_SLOT_MMC          1
+#define CB710_SLOT_MS           2
+#define CB710_SLOT_SM           4
+
+/* slot port accessors - so the logic is more clear in the code */
+#define CB710_PORT_ACCESSORS(t) \
+static inline void cb710_write_port_##t(struct cb710_slot *slot,        \
+        unsigned port, u##t value)                                      \
+{                                                                       \
+        iowrite##t(value, slot->iobase + port);                         \
+}                                                                       \
+                                                                        \
+static inline u##t cb710_read_port_##t(struct cb710_slot *slot,         \
+        unsigned port)                                                  \
+{                                                                       \
+        return ioread##t(slot->iobase + port);                          \
+}                                                                       \
+                                                                        \
+static inline void cb710_modify_port_##t(struct cb710_slot *slot,       \
+        unsigned port, u##t set, u##t clear)                            \
+{                                                                       \
+        iowrite##t(                                                     \
+                (ioread##t(slot->iobase + port) & ~clear)|set,          \
+                slot->iobase + port);                                   \
+}
+
+CB710_PORT_ACCESSORS(8)
+CB710_PORT_ACCESSORS(16)
+CB710_PORT_ACCESSORS(32)
+
+void cb710_pci_update_config_reg(struct pci_dev *pdev,
+        int reg, uint32_t and, uint32_t xor);
+void cb710_set_irq_handler(struct cb710_slot *slot,
+        cb710_irq_handler_t handler);
+
+/* some device struct walking */
+
+static inline struct cb710_slot *cb710_pdev_to_slot(
+        struct platform_device *pdev)
+{
+        return container_of(pdev, struct cb710_slot, pdev);
+}
+
+static inline struct cb710_chip *cb710_slot_to_chip(struct cb710_slot *slot)
+{
+        return dev_get_drvdata(slot->pdev.dev.parent);
+}
+
+static inline struct device *cb710_slot_dev(struct cb710_slot *slot)
+{
+        return &slot->pdev.dev;
+}
+
+static inline struct device *cb710_chip_dev(struct cb710_chip *chip)
+{
+        return &chip->pdev->dev;
+}
+
+/* debugging aids */
+
+#ifdef CONFIG_CB710_DEBUG
+void cb710_dump_regs(struct cb710_chip *chip, unsigned dump);
+#else
+#define cb710_dump_regs(c, d) do {} while (0)
+#endif
+
+#define CB710_DUMP_REGS_MMC     0x0F
+#define CB710_DUMP_REGS_MS      0x30
+#define CB710_DUMP_REGS_SM      0xC0
+#define CB710_DUMP_REGS_ALL     0xFF
+#define CB710_DUMP_REGS_MASK    0xFF
+
+#define CB710_DUMP_ACCESS_8     0x100
+#define CB710_DUMP_ACCESS_16    0x200
+#define CB710_DUMP_ACCESS_32    0x400
+#define CB710_DUMP_ACCESS_ALL   0x700
+#define CB710_DUMP_ACCESS_MASK  0x700
+
+#endif /* LINUX_CB710_DRIVER_H */
+/*
+ *  cb710/sgbuf2.h
+ *
+ *  Copyright by Michał Mirosław, 2008-2009
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef LINUX_CB710_SG_H
+#define LINUX_CB710_SG_H
+
+#include <linux/highmem.h>
+#include <linux/scatterlist.h>
+
+/*
+ * 32-bit PIO mapping sg iterator
+ *
+ * Hides scatterlist access issues - fragment boundaries, alignment, page
+ * mapping - for drivers using 32-bit-word-at-a-time-PIO (ie. PCI devices
+ * without DMA support).
+ *
+ * Best-case reading (transfer from device):
+ *   sg_miter_start(, SG_MITER_TO_SG);
+ *   cb710_sg_dwiter_write_from_io();
+ *   sg_miter_stop();
+ *
+ * Best-case writing (transfer to device):
+ *   sg_miter_start(, SG_MITER_FROM_SG);
+ *   cb710_sg_dwiter_read_to_io();
+ *   sg_miter_stop();
+ */
+
+uint32_t cb710_sg_dwiter_read_next_block(struct sg_mapping_iter *miter);
+void cb710_sg_dwiter_write_next_block(struct sg_mapping_iter *miter, uint32_t data);
+
+/**
+ * cb710_sg_dwiter_write_from_io - transfer data to mapped buffer from 32-bit IO port
+ * @miter: sg mapping iter
+ * @port: PIO port - IO or MMIO address
+ * @count: number of 32-bit words to transfer
+ *
+ * Description:
+ *   Reads @count 32-bit words from register @port and stores it in
+ *   buffer iterated by @miter.  Data that would overflow the buffer
+ *   is silently ignored.  Iterator is advanced by 4*@count bytes
+ *   or to the buffer's end whichever is closer.
+ *
+ * Context:
+ *   IRQ disabled if the SG_MITER_ATOMIC is set.  Don't care otherwise.
+ */
+static inline void cb710_sg_dwiter_write_from_io(struct sg_mapping_iter *miter,
+        void __iomem *port, size_t count)
+{
+        while (count-- > 0)
+                cb710_sg_dwiter_write_next_block(miter, ioread32(port));
+}
+
+/**
+ * cb710_sg_dwiter_read_to_io - transfer data to 32-bit IO port from mapped buffer
+ * @miter: sg mapping iter
+ * @port: PIO port - IO or MMIO address
+ * @count: number of 32-bit words to transfer
+ *
+ * Description:
+ *   Writes @count 32-bit words to register @port from buffer iterated
+ *   through @miter.  If buffer ends before @count words are written
+ *   missing data is replaced by zeroes. @miter is advanced by 4*@count
+ *   bytes or to the buffer's end whichever is closer.
+ *
+ * Context:
+ *   IRQ disabled if the SG_MITER_ATOMIC is set.  Don't care otherwise.
+ */
+static inline void cb710_sg_dwiter_read_to_io(struct sg_mapping_iter *miter,
+        void __iomem *port, size_t count)
+{
+        while (count-- > 0)
+                iowrite32(cb710_sg_dwiter_read_next_block(miter), port);
+}
+
+#endif /* LINUX_CB710_SG_H */
diff --git a/include/linux/cdev.h b/include/linux/cdev.h
index fb4591977b03..f389e319a454 100644
--- a/include/linux/cdev.h
+++ b/include/linux/cdev.h
@@ -28,6 +28,8 @@ int cdev_add(struct cdev *, dev_t, unsigned);
 
 void cdev_del(struct cdev *);
 
+int cdev_index(struct inode *inode);
+
 void cd_forget(struct inode *);
 
 extern struct backing_dev_info directly_mappable_cdev_bdi;
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 665fa70e4094..90bba9e62286 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -179,14 +179,11 @@ struct cgroup {
          */
         struct list_head release_list;
 
-        /* pids_mutex protects the fields below */
+        /* pids_mutex protects pids_list and cached pid arrays. */
         struct rw_semaphore pids_mutex;
-        /* Array of process ids in the cgroup */
-        pid_t *tasks_pids;
-        /* How many files are using the current tasks_pids array */
-        int pids_use_count;
-        /* Length of the current tasks_pids array */
-        int pids_length;
+
+        /* Linked list of struct cgroup_pids */
+        struct list_head pids_list;
 
         /* For RCU-protected deletion */
         struct rcu_head rcu_head;
@@ -366,6 +363,23 @@ int cgroup_task_count(const struct cgroup *cgrp);
 int cgroup_is_descendant(const struct cgroup *cgrp, struct task_struct *task);
 
 /*
+ * When the subsys has to access css and may add permanent refcnt to css,
+ * it should take care of racy conditions with rmdir(). Following set of
+ * functions, is for stop/restart rmdir if necessary.
+ * Because these will call css_get/put, "css" should be alive css.
+ *
+ *  cgroup_exclude_rmdir();
+ *  ...do some jobs which may access arbitrary empty cgroup
+ *  cgroup_release_and_wakeup_rmdir();
+ *
+ *  When someone removes a cgroup while cgroup_exclude_rmdir() holds it,
+ *  it sleeps and cgroup_release_and_wakeup_rmdir() will wake him up.
+ */
+
+void cgroup_exclude_rmdir(struct cgroup_subsys_state *css);
+void cgroup_release_and_wakeup_rmdir(struct cgroup_subsys_state *css);
+
+/*
  * Control Group subsystem type.
  * See Documentation/cgroups/cgroups.txt for details
  */
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 1db9bbf444a3..1d37f42ac294 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -142,4 +142,17 @@ struct clk *clk_get_parent(struct clk *clk);
  */
 struct clk *clk_get_sys(const char *dev_id, const char *con_id);
 
+/**
+ * clk_add_alias - add a new clock alias
+ * @alias: name for clock alias
+ * @alias_dev_name: device name
+ * @id: platform specific clock name
+ * @dev: device
+ *
+ * Allows using generic clock names for drivers by adding a new alias.
+ * Assumes clkdev, see clkdev.h for more info.
+ */
+int clk_add_alias(const char *alias, const char *alias_dev_name, char *id,
+                        struct device *dev);
+
 #endif
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 5a40d14daa9f..1219be4fb42e 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -288,7 +288,20 @@ static inline cycle_t clocksource_read(struct clocksource *cs)
  */
 static inline int clocksource_enable(struct clocksource *cs)
 {
-        return cs->enable ? cs->enable(cs) : 0;
+        int ret = 0;
+
+        if (cs->enable)
+                ret = cs->enable(cs);
+
+        /*
+         * The frequency may have changed while the clocksource
+         * was disabled. If so the code in ->enable() must update
+         * the mult value to reflect the new frequency. Make sure
+         * mult_orig follows this change.
+         */
+        cs->mult_orig = cs->mult;
+
+        return ret;
 }
 
 /**
@@ -301,6 +314,13 @@ static inline int clocksource_enable(struct clocksource *cs)
  */
 static inline void clocksource_disable(struct clocksource *cs)
 {
+        /*
+         * Save mult_orig in mult so clocksource_enable() can
+         * restore the value regardless if ->enable() updates
+         * the value of mult or not.
+         */
+        cs->mult = cs->mult_orig;
+
         if (cs->disable)
                 cs->disable(cs);
 }
diff --git a/include/linux/compat.h b/include/linux/compat.h
index f2ded21f9a3c..af931ee43dd8 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -222,6 +222,8 @@ int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from);
 int copy_siginfo_to_user32(struct compat_siginfo __user *to, siginfo_t *from);
 int get_compat_sigevent(struct sigevent *event,
                 const struct compat_sigevent __user *u_event);
+long compat_sys_rt_tgsigqueueinfo(compat_pid_t tgid, compat_pid_t pid, int sig,
+                                  struct compat_siginfo __user *uinfo);
 
 static inline int compat_timeval_compare(struct compat_timeval *lhs,
                                         struct compat_timeval *rhs)
diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h
index 8005effc04f1..b721129e0469 100644
--- a/include/linux/compiler-gcc3.h
+++ b/include/linux/compiler-gcc3.h
@@ -16,6 +16,12 @@
 #define __must_check            __attribute__((warn_unused_result))
 #endif
 
+#ifdef CONFIG_GCOV_KERNEL
+# if __GNUC_MINOR__ < 4
+#   error "GCOV profiling support for gcc versions below 3.4 not included"
+# endif /* __GNUC_MINOR__ */
+#endif /* CONFIG_GCOV_KERNEL */
+
 /*
  * A trick to suppress uninitialized variable warning without generating any
  * code
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 37bcb50a4d7c..04fb5135b4e1 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -261,6 +261,11 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
 # define __section(S) __attribute__ ((__section__(#S)))
 #endif
 
+/* Are two types/vars the same type (ignoring qualifiers)? */
+#ifndef __same_type
+# define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
+#endif
+
 /*
  * Prevent the compiler from merging or refetching accesses.  The compiler
  * is also forbidden from reordering successive instances of ACCESS_ONCE(),
diff --git a/include/linux/connector.h b/include/linux/connector.h
index b9966e64604e..b68d27850d51 100644
--- a/include/linux/connector.h
+++ b/include/linux/connector.h
@@ -41,8 +41,10 @@
 #define CN_IDX_BB                       0x5     /* BlackBoard, from the TSP GPL sampling framework */
 #define CN_DST_IDX                      0x6
 #define CN_DST_VAL                      0x1
+#define CN_IDX_DM                       0x7     /* Device Mapper */
+#define CN_VAL_DM_USERSPACE_LOG         0x1
 
-#define CN_NETLINK_USERS                7
+#define CN_NETLINK_USERS                8
 
 /*
  * Maximum connector's message size.
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index d71f7c0f931b..38fe59dc89ae 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -89,7 +89,6 @@ struct vc_data {
         unsigned int    vc_need_wrap    : 1;
         unsigned int    vc_can_do_color : 1;
         unsigned int    vc_report_mouse : 2;
-        unsigned int    vc_kmalloced    : 1;
         unsigned char   vc_utf          : 1;    /* Unicode UTF-8 encoding */
         unsigned char   vc_utf_count;
                  int    vc_utf_char;
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 2643d848df90..4d668e05d458 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -69,7 +69,6 @@ static inline void unregister_cpu_notifier(struct notifier_block *nb)
 
 int cpu_up(unsigned int cpu);
 void notify_cpu_starting(unsigned int cpu);
-extern void cpu_hotplug_init(void);
 extern void cpu_maps_update_begin(void);
 extern void cpu_maps_update_done(void);
 
@@ -84,10 +83,6 @@ static inline void unregister_cpu_notifier(struct notifier_block *nb)
 {
 }
 
-static inline void cpu_hotplug_init(void)
-{
-}
-
 static inline void cpu_maps_update_begin(void)
 {
 }
diff --git a/include/linux/cpuset.h b/include/linux/cpuset.h
index 05ea1dd7d681..a5740fc4d04b 100644
--- a/include/linux/cpuset.h
+++ b/include/linux/cpuset.h
@@ -18,7 +18,6 @@
 
 extern int number_of_cpusets;   /* How many cpusets are defined in system? */
 
-extern int cpuset_init_early(void);
 extern int cpuset_init(void);
 extern void cpuset_init_smp(void);
 extern void cpuset_cpus_allowed(struct task_struct *p, struct cpumask *mask);
@@ -27,7 +26,6 @@ extern void cpuset_cpus_allowed_locked(struct task_struct *p,
 extern nodemask_t cpuset_mems_allowed(struct task_struct *p);
 #define cpuset_current_mems_allowed (current->mems_allowed)
 void cpuset_init_current_mems_allowed(void);
-void cpuset_update_task_memory_state(void);
 int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask);
 
 extern int __cpuset_node_allowed_softwall(int node, gfp_t gfp_mask);
@@ -92,9 +90,13 @@ extern void rebuild_sched_domains(void);
 
 extern void cpuset_print_task_mems_allowed(struct task_struct *p);
 
+static inline void set_mems_allowed(nodemask_t nodemask)
+{
+        current->mems_allowed = nodemask;
+}
+
 #else /* !CONFIG_CPUSETS */
 
-static inline int cpuset_init_early(void) { return 0; }
 static inline int cpuset_init(void) { return 0; }
 static inline void cpuset_init_smp(void) {}
 
@@ -116,7 +118,6 @@ static inline nodemask_t cpuset_mems_allowed(struct task_struct *p)
 
 #define cpuset_current_mems_allowed (node_states[N_HIGH_MEMORY])
 static inline void cpuset_init_current_mems_allowed(void) {}
-static inline void cpuset_update_task_memory_state(void) {}
 
 static inline int cpuset_nodemask_valid_mems_allowed(nodemask_t *nodemask)
 {
@@ -188,6 +189,10 @@ static inline void cpuset_print_task_mems_allowed(struct task_struct *p)
 {
 }
 
+static inline void set_mems_allowed(nodemask_t nodemask)
+{
+}
+
 #endif /* !CONFIG_CPUSETS */
 
 #endif /* _LINUX_CPUSET_H */
diff --git a/include/linux/cramfs_fs.h b/include/linux/cramfs_fs.h
index 3be4e5a27d82..6fc2bed368b8 100644
--- a/include/linux/cramfs_fs.h
+++ b/include/linux/cramfs_fs.h
@@ -2,9 +2,8 @@
 #define __CRAMFS_H
 
 #include <linux/types.h>
+#include <linux/magic.h>
 
-#define CRAMFS_MAGIC            0x28cd3d45      /* some random number */
-#define CRAMFS_MAGIC_WEND       0x453dcd28      /* magic number with the wrong endianess */
 #define CRAMFS_SIGNATURE        "Compressed ROMFS"
 
 /*
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
index 2dac064d8359..0026f267da20 100644
--- a/include/linux/crash_dump.h
+++ b/include/linux/crash_dump.h
@@ -3,7 +3,6 @@
 
 #ifdef CONFIG_CRASH_DUMP
 #include <linux/kexec.h>
-#include <linux/smp_lock.h>
 #include <linux/device.h>
 #include <linux/proc_fs.h>
 
diff --git a/include/linux/cyclades.h b/include/linux/cyclades.h
index 788850ba4e75..1fbdea4f08eb 100644
--- a/include/linux/cyclades.h
+++ b/include/linux/cyclades.h
@@ -142,19 +142,6 @@ struct CYZ_BOOT_CTRL {
 
 
 #ifndef DP_WINDOW_SIZE
-/* #include "cyclomz.h" */
-/****************** ****************** *******************/
-/*
- *      The data types defined below are used in all ZFIRM interface
- *      data structures. They accomodate differences between HW
- *      architectures and compilers.
- */
-
-typedef __u64  ucdouble;                /* 64 bits, unsigned */
-typedef __u32  uclong;                  /* 32 bits, unsigned */
-typedef __u16  ucshort;         /* 16 bits, unsigned */
-typedef __u8   ucchar;                  /* 8 bits, unsigned */
-
 /*
  *      Memory Window Sizes
  */
@@ -507,16 +494,20 @@ struct ZFW_CTRL {
 
 /* Per card data structure */
 struct cyclades_card {
-    void __iomem *base_addr;
-    void __iomem *ctl_addr;
-    int irq;
-    unsigned int num_chips;     /* 0 if card absent, -1 if Z/PCI, else Y */
-    unsigned int first_line;    /* minor number of first channel on card */
-    unsigned int nports;        /* Number of ports in the card */
-    int bus_index;              /* address shift - 0 for ISA, 1 for PCI */
-    int intr_enabled;           /* FW Interrupt flag - 0 disabled, 1 enabled */
-    spinlock_t card_lock;
-    struct cyclades_port *ports;
+        void __iomem *base_addr;
+        union {
+                void __iomem *p9050;
+                struct RUNTIME_9060 __iomem *p9060;
+        } ctl_addr;
+        int irq;
+        unsigned int num_chips; /* 0 if card absent, -1 if Z/PCI, else Y */
+        unsigned int first_line;        /* minor number of first channel on card */
+        unsigned int nports;    /* Number of ports in the card */
+        int bus_index;          /* address shift - 0 for ISA, 1 for PCI */
+        int intr_enabled;               /* FW Interrupt flag - 0 disabled, 1 enabled */
+        u32 hw_ver;
+        spinlock_t card_lock;
+        struct cyclades_port *ports;
 };
 
 /***************************************
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 15156364d196..30b93b2a01a4 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -180,10 +180,12 @@ d_iput:		no		no		no       yes
 #define DCACHE_REFERENCED       0x0008  /* Recently used, don't discard. */
 #define DCACHE_UNHASHED         0x0010  
 
-#define DCACHE_INOTIFY_PARENT_WATCHED   0x0020 /* Parent inode is watched */
+#define DCACHE_INOTIFY_PARENT_WATCHED   0x0020 /* Parent inode is watched by inotify */
 
 #define DCACHE_COOKIE           0x0040  /* For use by dcookie subsystem */
 
+#define DCACHE_FSNOTIFY_PARENT_WATCHED  0x0080 /* Parent inode is watched by some fsnotify listener */
+
 extern spinlock_t dcache_lock;
 extern seqlock_t rename_lock;
 
@@ -351,6 +353,11 @@ static inline int d_unhashed(struct dentry *dentry)
         return (dentry->d_flags & DCACHE_UNHASHED);
 }
 
+static inline int d_unlinked(struct dentry *dentry)
+{
+        return d_unhashed(dentry) && !IS_ROOT(dentry);
+}
+
 static inline struct dentry *dget_parent(struct dentry *dentry)
 {
         struct dentry *ret;
@@ -368,7 +375,7 @@ static inline int d_mountpoint(struct dentry *dentry)
         return dentry->d_mounted;
 }
 
-extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
+extern struct vfsmount *lookup_mnt(struct path *);
 extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
 
 extern int sysctl_vfs_cache_pressure;
diff --git a/include/linux/decompress/generic.h b/include/linux/decompress/generic.h
index 6dfb856327bb..0c7111a55a1a 100644
--- a/include/linux/decompress/generic.h
+++ b/include/linux/decompress/generic.h
@@ -1,31 +1,37 @@
 #ifndef DECOMPRESS_GENERIC_H
 #define DECOMPRESS_GENERIC_H
 
-/* Minimal chunksize to be read.
- *Bzip2 prefers at least 4096
- *Lzma prefers 0x10000 */
-#define COMPR_IOBUF_SIZE        4096
-
 typedef int (*decompress_fn) (unsigned char *inbuf, int len,
                               int(*fill)(void*, unsigned int),
-                              int(*writebb)(void*, unsigned int),
-                              unsigned char *output,
+                              int(*flush)(void*, unsigned int),
+                              unsigned char *outbuf,
                               int *posp,
                               void(*error)(char *x));
 
 /* inbuf   - input buffer
  *len     - len of pre-read data in inbuf
- *fill    - function to fill inbuf if empty
- *writebb - function to write out outbug
+ *fill    - function to fill inbuf when empty
+ *flush   - function to write out outbuf
+ *outbuf  - output buffer
  *posp    - if non-null, input position (number of bytes read) will be
  *        returned here
  *
- *If len != 0, the inbuf is initialized (with as much data), and fill
- *should not be called
- *If len = 0, the inbuf is allocated, but empty. Its size is IOBUF_SIZE
- *fill should be called (repeatedly...) to read data, at most IOBUF_SIZE
+ *If len != 0, inbuf should contain all the necessary input data, and fill
+ *should be NULL
+ *If len = 0, inbuf can be NULL, in which case the decompressor will allocate
+ *the input buffer.  If inbuf != NULL it must be at least XXX_IOBUF_SIZE bytes.
+ *fill will be called (repeatedly...) to read data, at most XXX_IOBUF_SIZE
+ *bytes should be read per call.  Replace XXX with the appropriate decompressor
+ *name, i.e. LZMA_IOBUF_SIZE.
+ *
+ *If flush = NULL, outbuf must be large enough to buffer all the expected
+ *output.  If flush != NULL, the output buffer will be allocated by the
+ *decompressor (outbuf = NULL), and the flush function will be called to
+ *flush the output buffer at the appropriate time (decompressor and stream
+ *dependent).
  */
 
+
 /* Utility routine to detect the decompression method */
 decompress_fn decompress_method(const unsigned char *inbuf, int len,
                                 const char **name);
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index ded2d7c42668..655e7721580a 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -11,6 +11,7 @@
 #include <linux/bio.h>
 #include <linux/blkdev.h>
 
+struct dm_dev;
 struct dm_target;
 struct dm_table;
 struct mapped_device;
@@ -21,6 +22,7 @@ typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
 union map_info {
         void *ptr;
         unsigned long long ll;
+        unsigned flush_request;
 };
 
 /*
@@ -80,6 +82,15 @@ typedef int (*dm_ioctl_fn) (struct dm_target *ti, unsigned int cmd,
 typedef int (*dm_merge_fn) (struct dm_target *ti, struct bvec_merge_data *bvm,
                             struct bio_vec *biovec, int max_size);
 
+typedef int (*iterate_devices_callout_fn) (struct dm_target *ti,
+                                           struct dm_dev *dev,
+                                           sector_t start, sector_t len,
+                                           void *data);
+
+typedef int (*dm_iterate_devices_fn) (struct dm_target *ti,
+                                      iterate_devices_callout_fn fn,
+                                      void *data);
+
 /*
  * Returns:
  *    0: The target can handle the next I/O immediately.
@@ -92,7 +103,8 @@ void dm_error(const char *message);
 /*
  * Combine device limits.
  */
-void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev);
+int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
+                         sector_t start, sector_t len, void *data);
 
 struct dm_dev {
         struct block_device *bdev;
@@ -138,23 +150,12 @@ struct target_type {
         dm_ioctl_fn ioctl;
         dm_merge_fn merge;
         dm_busy_fn busy;
+        dm_iterate_devices_fn iterate_devices;
 
         /* For internal device-mapper use. */
         struct list_head list;
 };
 
-struct io_restrictions {
-        unsigned long bounce_pfn;
-        unsigned long seg_boundary_mask;
-        unsigned max_hw_sectors;
-        unsigned max_sectors;
-        unsigned max_segment_size;
-        unsigned short hardsect_size;
-        unsigned short max_hw_segments;
-        unsigned short max_phys_segments;
-        unsigned char no_cluster; /* inverted so that 0 is default */
-};
-
 struct dm_target {
         struct dm_table *table;
         struct target_type *type;
@@ -163,15 +164,18 @@ struct dm_target {
         sector_t begin;
         sector_t len;
 
-        /* FIXME: turn this into a mask, and merge with io_restrictions */
         /* Always a power of 2 */
         sector_t split_io;
 
         /*
-         * These are automatically filled in by
-         * dm_table_get_device.
+         * A number of zero-length barrier requests that will be submitted
+         * to the target for the purpose of flushing cache.
+         *
+         * The request number will be placed in union map_info->flush_request.
+         * It is a responsibility of the target driver to remap these requests
+         * to the real underlying devices.
          */
-        struct io_restrictions limits;
+        unsigned num_flush_requests;
 
         /* target specific data */
         void *private;
@@ -230,6 +234,7 @@ struct gendisk *dm_disk(struct mapped_device *md);
 int dm_suspended(struct mapped_device *md);
 int dm_noflush_suspending(struct dm_target *ti);
 union map_info *dm_get_mapinfo(struct bio *bio);
+union map_info *dm_get_rq_mapinfo(struct request *rq);
 
 /*
  * Geometry functions.
@@ -392,4 +397,12 @@ static inline unsigned long to_bytes(sector_t n)
         return (n << SECTOR_SHIFT);
 }
 
+/*-----------------------------------------------------------------
+ * Helper for block layer and dm core operations
+ *---------------------------------------------------------------*/
+void dm_dispatch_request(struct request *rq);
+void dm_requeue_unmapped_request(struct request *rq);
+void dm_kill_unmapped_request(struct request *rq, int error);
+int dm_underlying_device_busy(struct request_queue *q);
+
 #endif  /* _LINUX_DEVICE_MAPPER_H */
diff --git a/include/linux/device.h b/include/linux/device.h
index 5d5c197bad45..aebb81036db2 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -25,8 +25,6 @@
 #include <asm/atomic.h>
 #include <asm/device.h>
 
-#define BUS_ID_SIZE             20
-
 struct device;
 struct device_private;
 struct device_driver;
@@ -62,8 +60,6 @@ struct bus_type {
         void (*shutdown)(struct device *dev);
 
         int (*suspend)(struct device *dev, pm_message_t state);
-        int (*suspend_late)(struct device *dev, pm_message_t state);
-        int (*resume_early)(struct device *dev);
         int (*resume)(struct device *dev);
 
         struct dev_pm_ops *pm;
@@ -116,6 +112,8 @@ extern int bus_unregister_notifier(struct bus_type *bus,
 #define BUS_NOTIFY_BOUND_DRIVER         0x00000003 /* driver bound to device */
 #define BUS_NOTIFY_UNBIND_DRIVER        0x00000004 /* driver about to be
                                                       unbound */
+#define BUS_NOTIFY_UNBOUND_DRIVER       0x00000005 /* driver is unbound
+                                                      from the device */
 
 extern struct kset *bus_get_kset(struct bus_type *bus);
 extern struct klist *bus_get_device_klist(struct bus_type *bus);
@@ -194,6 +192,7 @@ struct class {
         struct kobject                  *dev_kobj;
 
         int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
+        char *(*nodename)(struct device *dev);
 
         void (*class_release)(struct class *class);
         void (*dev_release)(struct device *dev);
@@ -289,11 +288,9 @@ struct device_type {
         const char *name;
         struct attribute_group **groups;
         int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
+        char *(*nodename)(struct device *dev);
         void (*release)(struct device *dev);
 
-        int (*suspend)(struct device *dev, pm_message_t state);
-        int (*resume)(struct device *dev);
-
         struct dev_pm_ops *pm;
 };
 
@@ -491,6 +488,7 @@ extern struct device *device_find_child(struct device *dev, void *data,
 extern int device_rename(struct device *dev, char *new_name);
 extern int device_move(struct device *dev, struct device *new_parent,
                        enum dpm_order dpm_order);
+extern const char *device_get_nodename(struct device *dev, const char **tmp);
 
 /*
  * Root device objects for grouping under /sys/devices
diff --git a/include/linux/dlm.h b/include/linux/dlm.h
index b9cd38603fd8..0b3518c42356 100644
--- a/include/linux/dlm.h
+++ b/include/linux/dlm.h
@@ -81,8 +81,8 @@ struct dlm_lksb {
  * the cluster, the calling node joins it.
  */
 
-int dlm_new_lockspace(char *name, int namelen, dlm_lockspace_t **lockspace,
-                      uint32_t flags, int lvblen);
+int dlm_new_lockspace(const char *name, int namelen,
+                      dlm_lockspace_t **lockspace, uint32_t flags, int lvblen);
 
 /*
  * dlm_release_lockspace
diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h
index 48e44ee2b466..2ab84c83c31a 100644
--- a/include/linux/dm-ioctl.h
+++ b/include/linux/dm-ioctl.h
@@ -123,6 +123,16 @@ struct dm_ioctl {
         __u32 target_count;     /* in/out */
         __s32 open_count;       /* out */
         __u32 flags;            /* in/out */
+
+        /*
+         * event_nr holds either the event number (input and output) or the
+         * udev cookie value (input only).
+         * The DM_DEV_WAIT ioctl takes an event number as input.
+         * The DM_SUSPEND, DM_DEV_REMOVE and DM_DEV_RENAME ioctls
+         * use the field as a cookie to return in the DM_COOKIE
+         * variable with the uevents they issue.
+         * For output, the ioctls return the event number, not the cookie.
+         */
         __u32 event_nr;         /* in/out */
         __u32 padding;
 
@@ -256,9 +266,9 @@ enum {
 #define DM_DEV_SET_GEOMETRY     _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl)
 
 #define DM_VERSION_MAJOR        4
-#define DM_VERSION_MINOR        14
+#define DM_VERSION_MINOR        15
 #define DM_VERSION_PATCHLEVEL   0
-#define DM_VERSION_EXTRA        "-ioctl (2008-04-23)"
+#define DM_VERSION_EXTRA        "-ioctl (2009-04-01)"
 
 /* Status bits */
 #define DM_READONLY_FLAG        (1 << 0) /* In/Out */
diff --git a/include/linux/dm-log-userspace.h b/include/linux/dm-log-userspace.h
new file mode 100644
index 000000000000..642e3017b51f
--- /dev/null
+++ b/include/linux/dm-log-userspace.h
@@ -0,0 +1,386 @@
+/*
+ * Copyright (C) 2006-2009 Red Hat, Inc.
+ *
+ * This file is released under the LGPL.
+ */
+
+#ifndef __DM_LOG_USERSPACE_H__
+#define __DM_LOG_USERSPACE_H__
+
+#include <linux/dm-ioctl.h> /* For DM_UUID_LEN */
+
+/*
+ * The device-mapper userspace log module consists of a kernel component and
+ * a user-space component.  The kernel component implements the API defined
+ * in dm-dirty-log.h.  Its purpose is simply to pass the parameters and
+ * return values of those API functions between kernel and user-space.
+ *
+ * Below are defined the 'request_types' - DM_ULOG_CTR, DM_ULOG_DTR, etc.
+ * These request types represent the different functions in the device-mapper
+ * dirty log API.  Each of these is described in more detail below.
+ *
+ * The user-space program must listen for requests from the kernel (representing
+ * the various API functions) and process them.
+ *
+ * User-space begins by setting up the communication link (error checking
+ * removed for clarity):
+ *      fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
+ *      addr.nl_family = AF_NETLINK;
+ *      addr.nl_groups = CN_IDX_DM;
+ *      addr.nl_pid = 0;
+ *      r = bind(fd, (struct sockaddr *) &addr, sizeof(addr));
+ *      opt = addr.nl_groups;
+ *      setsockopt(fd, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &opt, sizeof(opt));
+ *
+ * User-space will then wait to receive requests form the kernel, which it
+ * will process as described below.  The requests are received in the form,
+ * ((struct dm_ulog_request) + (additional data)).  Depending on the request
+ * type, there may or may not be 'additional data'.  In the descriptions below,
+ * you will see 'Payload-to-userspace' and 'Payload-to-kernel'.  The
+ * 'Payload-to-userspace' is what the kernel sends in 'additional data' as
+ * necessary parameters to complete the request.  The 'Payload-to-kernel' is
+ * the 'additional data' returned to the kernel that contains the necessary
+ * results of the request.  The 'data_size' field in the dm_ulog_request
+ * structure denotes the availability and amount of payload data.
+ */
+
+/*
+ * DM_ULOG_CTR corresponds to (found in dm-dirty-log.h):
+ * int (*ctr)(struct dm_dirty_log *log, struct dm_target *ti,
+ *            unsigned argc, char **argv);
+ *
+ * Payload-to-userspace:
+ *      A single string containing all the argv arguments separated by ' 's
+ * Payload-to-kernel:
+ *      None.  ('data_size' in the dm_ulog_request struct should be 0.)
+ *
+ * The UUID contained in the dm_ulog_request structure is the reference that
+ * will be used by all request types to a specific log.  The constructor must
+ * record this assotiation with instance created.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_CTR                    1
+
+/*
+ * DM_ULOG_DTR corresponds to (found in dm-dirty-log.h):
+ * void (*dtr)(struct dm_dirty_log *log);
+ *
+ * Payload-to-userspace:
+ *      A single string containing all the argv arguments separated by ' 's
+ * Payload-to-kernel:
+ *      None.  ('data_size' in the dm_ulog_request struct should be 0.)
+ *
+ * The UUID contained in the dm_ulog_request structure is all that is
+ * necessary to identify the log instance being destroyed.  There is no
+ * payload data.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and clearing
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_DTR                    2
+
+/*
+ * DM_ULOG_PRESUSPEND corresponds to (found in dm-dirty-log.h):
+ * int (*presuspend)(struct dm_dirty_log *log);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      None.
+ *
+ * The UUID contained in the dm_ulog_request structure is all that is
+ * necessary to identify the log instance being presuspended.  There is no
+ * payload data.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_PRESUSPEND             3
+
+/*
+ * DM_ULOG_POSTSUSPEND corresponds to (found in dm-dirty-log.h):
+ * int (*postsuspend)(struct dm_dirty_log *log);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      None.
+ *
+ * The UUID contained in the dm_ulog_request structure is all that is
+ * necessary to identify the log instance being postsuspended.  There is no
+ * payload data.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_POSTSUSPEND            4
+
+/*
+ * DM_ULOG_RESUME corresponds to (found in dm-dirty-log.h):
+ * int (*resume)(struct dm_dirty_log *log);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      None.
+ *
+ * The UUID contained in the dm_ulog_request structure is all that is
+ * necessary to identify the log instance being resumed.  There is no
+ * payload data.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_RESUME                 5
+
+/*
+ * DM_ULOG_GET_REGION_SIZE corresponds to (found in dm-dirty-log.h):
+ * uint32_t (*get_region_size)(struct dm_dirty_log *log);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      uint64_t - contains the region size
+ *
+ * The region size is something that was determined at constructor time.
+ * It is returned in the payload area and 'data_size' is set to
+ * reflect this.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field appropriately.
+ */
+#define DM_ULOG_GET_REGION_SIZE        6
+
+/*
+ * DM_ULOG_IS_CLEAN corresponds to (found in dm-dirty-log.h):
+ * int (*is_clean)(struct dm_dirty_log *log, region_t region);
+ *
+ * Payload-to-userspace:
+ *      uint64_t - the region to get clean status on
+ * Payload-to-kernel:
+ *      int64_t  - 1 if clean, 0 otherwise
+ *
+ * Payload is sizeof(uint64_t) and contains the region for which the clean
+ * status is being made.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - filling the payload with 0 (not clean) or
+ * 1 (clean), setting 'data_size' and 'error' appropriately.
+ */
+#define DM_ULOG_IS_CLEAN               7
+
+/*
+ * DM_ULOG_IN_SYNC corresponds to (found in dm-dirty-log.h):
+ * int (*in_sync)(struct dm_dirty_log *log, region_t region,
+ *                int can_block);
+ *
+ * Payload-to-userspace:
+ *      uint64_t - the region to get sync status on
+ * Payload-to-kernel:
+ *      int64_t - 1 if in-sync, 0 otherwise
+ *
+ * Exactly the same as 'is_clean' above, except this time asking "has the
+ * region been recovered?" vs. "is the region not being modified?"
+ */
+#define DM_ULOG_IN_SYNC                8
+
+/*
+ * DM_ULOG_FLUSH corresponds to (found in dm-dirty-log.h):
+ * int (*flush)(struct dm_dirty_log *log);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      None.
+ *
+ * No incoming or outgoing payload.  Simply flush log state to disk.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and clearing
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_FLUSH                  9
+
+/*
+ * DM_ULOG_MARK_REGION corresponds to (found in dm-dirty-log.h):
+ * void (*mark_region)(struct dm_dirty_log *log, region_t region);
+ *
+ * Payload-to-userspace:
+ *      uint64_t [] - region(s) to mark
+ * Payload-to-kernel:
+ *      None.
+ *
+ * Incoming payload contains the one or more regions to mark dirty.
+ * The number of regions contained in the payload can be determined from
+ * 'data_size/sizeof(uint64_t)'.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and clearing
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_MARK_REGION           10
+
+/*
+ * DM_ULOG_CLEAR_REGION corresponds to (found in dm-dirty-log.h):
+ * void (*clear_region)(struct dm_dirty_log *log, region_t region);
+ *
+ * Payload-to-userspace:
+ *      uint64_t [] - region(s) to clear
+ * Payload-to-kernel:
+ *      None.
+ *
+ * Incoming payload contains the one or more regions to mark clean.
+ * The number of regions contained in the payload can be determined from
+ * 'data_size/sizeof(uint64_t)'.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and clearing
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_CLEAR_REGION          11
+
+/*
+ * DM_ULOG_GET_RESYNC_WORK corresponds to (found in dm-dirty-log.h):
+ * int (*get_resync_work)(struct dm_dirty_log *log, region_t *region);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      {
+ *              int64_t i; -- 1 if recovery necessary, 0 otherwise
+ *              uint64_t r; -- The region to recover if i=1
+ *      }
+ * 'data_size' should be set appropriately.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field appropriately.
+ */
+#define DM_ULOG_GET_RESYNC_WORK       12
+
+/*
+ * DM_ULOG_SET_REGION_SYNC corresponds to (found in dm-dirty-log.h):
+ * void (*set_region_sync)(struct dm_dirty_log *log,
+ *                         region_t region, int in_sync);
+ *
+ * Payload-to-userspace:
+ *      {
+ *              uint64_t - region to set sync state on
+ *              int64_t  - 0 if not-in-sync, 1 if in-sync
+ *      }
+ * Payload-to-kernel:
+ *      None.
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and clearing
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_SET_REGION_SYNC       13
+
+/*
+ * DM_ULOG_GET_SYNC_COUNT corresponds to (found in dm-dirty-log.h):
+ * region_t (*get_sync_count)(struct dm_dirty_log *log);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      uint64_t - the number of in-sync regions
+ *
+ * No incoming payload.  Kernel-bound payload contains the number of
+ * regions that are in-sync (in a size_t).
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_GET_SYNC_COUNT        14
+
+/*
+ * DM_ULOG_STATUS_INFO corresponds to (found in dm-dirty-log.h):
+ * int (*status)(struct dm_dirty_log *log, STATUSTYPE_INFO,
+ *               char *result, unsigned maxlen);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      Character string containing STATUSTYPE_INFO
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_STATUS_INFO           15
+
+/*
+ * DM_ULOG_STATUS_TABLE corresponds to (found in dm-dirty-log.h):
+ * int (*status)(struct dm_dirty_log *log, STATUSTYPE_TABLE,
+ *               char *result, unsigned maxlen);
+ *
+ * Payload-to-userspace:
+ *      None.
+ * Payload-to-kernel:
+ *      Character string containing STATUSTYPE_TABLE
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_STATUS_TABLE          16
+
+/*
+ * DM_ULOG_IS_REMOTE_RECOVERING corresponds to (found in dm-dirty-log.h):
+ * int (*is_remote_recovering)(struct dm_dirty_log *log, region_t region);
+ *
+ * Payload-to-userspace:
+ *      uint64_t - region to determine recovery status on
+ * Payload-to-kernel:
+ *      {
+ *              int64_t is_recovering;  -- 0 if no, 1 if yes
+ *              uint64_t in_sync_hint;  -- lowest region still needing resync
+ *      }
+ *
+ * When the request has been processed, user-space must return the
+ * dm_ulog_request to the kernel - setting the 'error' field and
+ * 'data_size' appropriately.
+ */
+#define DM_ULOG_IS_REMOTE_RECOVERING  17
+
+/*
+ * (DM_ULOG_REQUEST_MASK & request_type) to get the request type
+ *
+ * Payload-to-userspace:
+ *      A single string containing all the argv arguments separated by ' 's
+ * Payload-to-kernel:
+ *      None.  ('data_size' in the dm_ulog_request struct should be 0.)
+ *
+ * We are reserving 8 bits of the 32-bit 'request_type' field for the
+ * various request types above.  The remaining 24-bits are currently
+ * set to zero and are reserved for future use and compatibility concerns.
+ *
+ * User-space should always use DM_ULOG_REQUEST_TYPE to aquire the
+ * request type from the 'request_type' field to maintain forward compatibility.
+ */
+#define DM_ULOG_REQUEST_MASK 0xFF
+#define DM_ULOG_REQUEST_TYPE(request_type) \
+        (DM_ULOG_REQUEST_MASK & (request_type))
+
+struct dm_ulog_request {
+        char uuid[DM_UUID_LEN]; /* Ties a request to a specific mirror log */
+        char padding[7];        /* Padding because DM_UUID_LEN = 129 */
+
+        int32_t error;          /* Used to report back processing errors */
+
+        uint32_t seq;           /* Sequence number for request */
+        uint32_t request_type;  /* DM_ULOG_* defined above */
+        uint32_t data_size;     /* How much data (not including this struct) */
+
+        char data[0];
+};
+
+#endif /* __DM_LOG_USERSPACE_H__ */
diff --git a/include/linux/dma-debug.h b/include/linux/dma-debug.h
index 28d53cb7b5a2..171ad8aedc83 100644
--- a/include/linux/dma-debug.h
+++ b/include/linux/dma-debug.h
@@ -32,6 +32,8 @@ extern void dma_debug_add_bus(struct bus_type *bus);
 
 extern void dma_debug_init(u32 num_entries);
 
+extern int dma_debug_resize_entries(u32 num_entries);
+
 extern void debug_dma_map_page(struct device *dev, struct page *page,
                                size_t offset, size_t size,
                                int direction, dma_addr_t dma_addr,
@@ -91,6 +93,11 @@ static inline void dma_debug_init(u32 num_entries)
 {
 }
 
+static inline int dma_debug_resize_entries(u32 num_entries)
+{
+        return 0;
+}
+
 static inline void debug_dma_map_page(struct device *dev, struct page *page,
                                       size_t offset, size_t size,
                                       int direction, dma_addr_t dma_addr,
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 8083b6a36a38..07dfd460d286 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -63,24 +63,26 @@ struct dma_map_ops {
 
 #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
 
+typedef u64 DMA_nnBIT_MASK __deprecated;
+
 /*
  * NOTE: do not use the below macros in new code and do not add new definitions
  * here.
  *
  * Instead, just open-code DMA_BIT_MASK(n) within your driver
  */
-#define DMA_64BIT_MASK  DMA_BIT_MASK(64)
-#define DMA_48BIT_MASK  DMA_BIT_MASK(48)
-#define DMA_47BIT_MASK  DMA_BIT_MASK(47)
-#define DMA_40BIT_MASK  DMA_BIT_MASK(40)
-#define DMA_39BIT_MASK  DMA_BIT_MASK(39)
-#define DMA_35BIT_MASK  DMA_BIT_MASK(35)
-#define DMA_32BIT_MASK  DMA_BIT_MASK(32)
-#define DMA_31BIT_MASK  DMA_BIT_MASK(31)
-#define DMA_30BIT_MASK  DMA_BIT_MASK(30)
-#define DMA_29BIT_MASK  DMA_BIT_MASK(29)
-#define DMA_28BIT_MASK  DMA_BIT_MASK(28)
-#define DMA_24BIT_MASK  DMA_BIT_MASK(24)
+#define DMA_64BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(64)
+#define DMA_48BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(48)
+#define DMA_47BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(47)
+#define DMA_40BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(40)
+#define DMA_39BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(39)
+#define DMA_35BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(35)
+#define DMA_32BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(32)
+#define DMA_31BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(31)
+#define DMA_30BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(30)
+#define DMA_29BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(29)
+#define DMA_28BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(28)
+#define DMA_24BIT_MASK  (DMA_nnBIT_MASK)DMA_BIT_MASK(24)
 
 #define DMA_MASK_NONE   0x0ULL
 
@@ -107,9 +109,20 @@ static inline int is_buffer_dma_capable(u64 mask, dma_addr_t addr, size_t size)
 #include <asm-generic/dma-mapping-broken.h>
 #endif
 
-/* Backwards compat, remove in 2.7.x */
-#define dma_sync_single         dma_sync_single_for_cpu
-#define dma_sync_sg             dma_sync_sg_for_cpu
+/* for backwards compatibility, removed soon */
+static inline void __deprecated dma_sync_single(struct device *dev,
+                                                dma_addr_t addr, size_t size,
+                                                enum dma_data_direction dir)
+{
+        dma_sync_single_for_cpu(dev, addr, size, dir);
+}
+
+static inline void __deprecated dma_sync_sg(struct device *dev,
+                                            struct scatterlist *sg, int nelems,
+                                            enum dma_data_direction dir)
+{
+        dma_sync_sg_for_cpu(dev, sg, nelems, dir);
+}
 
 static inline u64 dma_get_mask(struct device *dev)
 {
diff --git a/include/linux/dma_remapping.h b/include/linux/dma_remapping.h
index 1a455f1f86d7..5619f8522738 100644
--- a/include/linux/dma_remapping.h
+++ b/include/linux/dma_remapping.h
@@ -13,6 +13,10 @@
 #define DMA_PTE_WRITE (2)
 #define DMA_PTE_SNP (1 << 11)
 
+#define CONTEXT_TT_MULTI_LEVEL  0
+#define CONTEXT_TT_DEV_IOTLB    1
+#define CONTEXT_TT_PASS_THROUGH 2
+
 struct intel_iommu;
 struct dmar_domain;
 struct root_entry;
@@ -21,11 +25,16 @@ extern void free_dmar_iommu(struct intel_iommu *iommu);
 
 #ifdef CONFIG_DMAR
 extern int iommu_calculate_agaw(struct intel_iommu *iommu);
+extern int iommu_calculate_max_sagaw(struct intel_iommu *iommu);
 #else
 static inline int iommu_calculate_agaw(struct intel_iommu *iommu)
 {
         return 0;
 }
+static inline int iommu_calculate_max_sagaw(struct intel_iommu *iommu)
+{
+        return 0;
+}
 #endif
 
 extern int dmar_disabled;
diff --git a/include/linux/dmar.h b/include/linux/dmar.h
index e397dc342cda..4a2b162c256a 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -108,6 +108,7 @@ struct irte {
 };
 #ifdef CONFIG_INTR_REMAP
 extern int intr_remapping_enabled;
+extern int intr_remapping_supported(void);
 extern int enable_intr_remapping(int);
 extern void disable_intr_remapping(void);
 extern int reenable_intr_remapping(int);
@@ -125,6 +126,8 @@ extern int free_irte(int irq);
 extern int irq_remapped(int irq);
 extern struct intel_iommu *map_dev_to_ir(struct pci_dev *dev);
 extern struct intel_iommu *map_ioapic_to_ir(int apic);
+extern int set_ioapic_sid(struct irte *irte, int apic);
+extern int set_msi_sid(struct irte *irte, struct pci_dev *dev);
 #else
 static inline int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
 {
@@ -155,8 +158,19 @@ static inline struct intel_iommu *map_ioapic_to_ir(int apic)
 {
         return NULL;
 }
+static inline int set_ioapic_sid(struct irte *irte, int apic)
+{
+        return 0;
+}
+static inline int set_msi_sid(struct irte *irte, struct pci_dev *dev)
+{
+        return 0;
+}
+
 #define irq_remapped(irq)               (0)
 #define enable_intr_remapping(mode)     (-1)
+#define disable_intr_remapping()        (0)
+#define reenable_intr_remapping(mode)   (0)
 #define intr_remapping_enabled          (0)
 #endif
 
@@ -185,6 +199,15 @@ struct dmar_rmrr_unit {
 
 #define for_each_rmrr_units(rmrr) \
         list_for_each_entry(rmrr, &dmar_rmrr_units, list)
+
+struct dmar_atsr_unit {
+        struct list_head list;          /* list of ATSR units */
+        struct acpi_dmar_header *hdr;   /* ACPI header */
+        struct pci_dev **devices;       /* target devices */
+        int devices_cnt;                /* target device count */
+        u8 include_all:1;               /* include all ports */
+};
+
 /* Intel DMAR  initialization functions */
 extern int intel_iommu_init(void);
 #else
diff --git a/include/linux/dnotify.h b/include/linux/dnotify.h
index 102a902b4396..ecc06286226d 100644
--- a/include/linux/dnotify.h
+++ b/include/linux/dnotify.h
@@ -10,7 +10,7 @@
 
 struct dnotify_struct {
         struct dnotify_struct * dn_next;
-        unsigned long           dn_mask;
+        __u32                   dn_mask;
         int                     dn_fd;
         struct file *           dn_filp;
         fl_owner_t              dn_owner;
@@ -21,23 +21,18 @@ struct dnotify_struct {
 
 #ifdef CONFIG_DNOTIFY
 
-extern void __inode_dir_notify(struct inode *, unsigned long);
+#define DNOTIFY_ALL_EVENTS (FS_DELETE | FS_DELETE_CHILD |\
+                            FS_MODIFY | FS_MODIFY_CHILD |\
+                            FS_ACCESS | FS_ACCESS_CHILD |\
+                            FS_ATTRIB | FS_ATTRIB_CHILD |\
+                            FS_CREATE | FS_DN_RENAME |\
+                            FS_MOVED_FROM | FS_MOVED_TO)
+
 extern void dnotify_flush(struct file *, fl_owner_t);
 extern int fcntl_dirnotify(int, struct file *, unsigned long);
-extern void dnotify_parent(struct dentry *, unsigned long);
-
-static inline void inode_dir_notify(struct inode *inode, unsigned long event)
-{
-        if (inode->i_dnotify_mask & (event))
-                __inode_dir_notify(inode, event);
-}
 
 #else
 
-static inline void __inode_dir_notify(struct inode *inode, unsigned long event)
-{
-}
-
 static inline void dnotify_flush(struct file *filp, fl_owner_t id)
 {
 }
@@ -47,14 +42,6 @@ static inline int fcntl_dirnotify(int fd, struct file *filp, unsigned long arg)
         return -EINVAL;
 }
 
-static inline void dnotify_parent(struct dentry *dentry, unsigned long event)
-{
-}
-
-static inline void inode_dir_notify(struct inode *inode, unsigned long event)
-{
-}
-
 #endif /* CONFIG_DNOTIFY */
 
 #endif /* __KERNEL __ */
diff --git a/include/linux/efi.h b/include/linux/efi.h
index bb66feb164bd..ce4581fbc08b 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -101,7 +101,7 @@ typedef struct {
         u64 attribute;
 } efi_memory_desc_t;
 
-typedef int (*efi_freemem_callback_t) (unsigned long start, unsigned long end, void *arg);
+typedef int (*efi_freemem_callback_t) (u64 start, u64 end, void *arg);
 
 /*
  * Types and defines for Time Services
diff --git a/include/linux/eisa.h b/include/linux/eisa.h
index e61c0be2a459..6925249a5ac6 100644
--- a/include/linux/eisa.h
+++ b/include/linux/eisa.h
@@ -78,12 +78,12 @@ static inline void eisa_driver_unregister (struct eisa_driver *edrv) { }
 /* Mimics pci.h... */
 static inline void *eisa_get_drvdata (struct eisa_device *edev)
 {
-        return edev->dev.driver_data;
+        return dev_get_drvdata(&edev->dev);
 }
 
 static inline void eisa_set_drvdata (struct eisa_device *edev, void *data)
 {
-        edev->dev.driver_data = data;
+        dev_set_drvdata(&edev->dev, data);
 }
 
 /* The EISA root device. There's rumours about machines with multiple
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index c59b769f62b0..1cb3372e65d8 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -103,10 +103,8 @@ extern int elv_merge(struct request_queue *, struct request **, struct bio *);
 extern void elv_merge_requests(struct request_queue *, struct request *,
                                struct request *);
 extern void elv_merged_request(struct request_queue *, struct request *, int);
-extern void elv_dequeue_request(struct request_queue *, struct request *);
 extern void elv_requeue_request(struct request_queue *, struct request *);
 extern int elv_queue_empty(struct request_queue *);
-extern struct request *elv_next_request(struct request_queue *q);
 extern struct request *elv_former_request(struct request_queue *, struct request *);
 extern struct request *elv_latter_request(struct request_queue *, struct request *);
 extern int elv_register_queue(struct request_queue *q);
@@ -171,7 +169,7 @@ enum {
         ELV_MQUEUE_MUST,
 };
 
-#define rq_end_sector(rq)       ((rq)->sector + (rq)->nr_sectors)
+#define rq_end_sector(rq)       (blk_rq_pos(rq) + blk_rq_sectors(rq))
 #define rb_entry_rq(node)       rb_entry((node), struct request, rb_node)
 
 /*
diff --git a/include/linux/elfcore.h b/include/linux/elfcore.h
index 7605c5e9589f..00d6a68d0421 100644
--- a/include/linux/elfcore.h
+++ b/include/linux/elfcore.h
@@ -122,9 +122,10 @@ static inline void elf_core_copy_kernel_regs(elf_gregset_t *elfregs, struct pt_r
 
 static inline int elf_core_copy_task_regs(struct task_struct *t, elf_gregset_t* elfregs)
 {
-#ifdef ELF_CORE_COPY_TASK_REGS
-        
+#if defined (ELF_CORE_COPY_TASK_REGS)
         return ELF_CORE_COPY_TASK_REGS(t, elfregs);
+#elif defined (task_pt_regs)
+        elf_core_copy_regs(elfregs, task_pt_regs(t));
 #endif
         return 0;
 }
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index a1f17abba7dc..3d7a6687d247 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -182,6 +182,33 @@ static inline unsigned compare_ether_addr_64bits(const u8 addr1[6+2],
         return compare_ether_addr(addr1, addr2);
 #endif
 }
+
+/**
+ * is_etherdev_addr - Tell if given Ethernet address belongs to the device.
+ * @dev: Pointer to a device structure
+ * @addr: Pointer to a six-byte array containing the Ethernet address
+ *
+ * Compare passed address with all addresses of the device. Return true if the
+ * address if one of the device addresses.
+ *
+ * Note that this function calls compare_ether_addr_64bits() so take care of
+ * the right padding.
+ */
+static inline bool is_etherdev_addr(const struct net_device *dev,
+                                    const u8 addr[6 + 2])
+{
+        struct netdev_hw_addr *ha;
+        int res = 1;
+
+        rcu_read_lock();
+        for_each_dev_addr(dev, ha) {
+                res = compare_ether_addr_64bits(addr, ha->addr);
+                if (!res)
+                        break;
+        }
+        rcu_read_unlock();
+        return !res;
+}
 #endif  /* __KERNEL__ */
 
 /**
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index 131b127b70f8..9b660bd2e2b3 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -26,11 +26,14 @@ struct ethtool_cmd {
         __u8    phy_address;
         __u8    transceiver;    /* Which transceiver to use */
         __u8    autoneg;        /* Enable or disable autonegotiation */
+        __u8    mdio_support;
         __u32   maxtxpkt;       /* Tx pkts before generating tx int */
         __u32   maxrxpkt;       /* Rx pkts before generating rx int */
         __u16   speed_hi;
-        __u16   reserved2;
-        __u32   reserved[3];
+        __u8    eth_tp_mdix;
+        __u8    reserved2;
+        __u32   lp_advertising; /* Features the link partner advertises */
+        __u32   reserved[2];
 };
 
 static inline void ethtool_cmd_speed_set(struct ethtool_cmd *ep,
@@ -563,6 +566,11 @@ struct ethtool_ops {
 #define SUPPORTED_Pause                 (1 << 13)
 #define SUPPORTED_Asym_Pause            (1 << 14)
 #define SUPPORTED_2500baseX_Full        (1 << 15)
+#define SUPPORTED_Backplane             (1 << 16)
+#define SUPPORTED_1000baseKX_Full       (1 << 17)
+#define SUPPORTED_10000baseKX4_Full     (1 << 18)
+#define SUPPORTED_10000baseKR_Full      (1 << 19)
+#define SUPPORTED_10000baseR_FEC        (1 << 20)
 
 /* Indicates what features are advertised by the interface. */
 #define ADVERTISED_10baseT_Half         (1 << 0)
@@ -581,6 +589,11 @@ struct ethtool_ops {
 #define ADVERTISED_Pause                (1 << 13)
 #define ADVERTISED_Asym_Pause           (1 << 14)
 #define ADVERTISED_2500baseX_Full       (1 << 15)
+#define ADVERTISED_Backplane            (1 << 16)
+#define ADVERTISED_1000baseKX_Full      (1 << 17)
+#define ADVERTISED_10000baseKX4_Full    (1 << 18)
+#define ADVERTISED_10000baseKR_Full     (1 << 19)
+#define ADVERTISED_10000baseR_FEC       (1 << 20)
 
 /* The following are all involved in forcing a particular link
  * mode for the device for setting things.  When getting the
@@ -605,6 +618,7 @@ struct ethtool_ops {
 #define PORT_MII                0x02
 #define PORT_FIBRE              0x03
 #define PORT_BNC                0x04
+#define PORT_OTHER              0xff
 
 /* Which transceiver to use. */
 #define XCVR_INTERNAL           0x00
@@ -619,6 +633,11 @@ struct ethtool_ops {
 #define AUTONEG_DISABLE         0x00
 #define AUTONEG_ENABLE          0x01
 
+/* Mode MDI or MDI-X */
+#define ETH_TP_MDI_INVALID      0x00
+#define ETH_TP_MDI              0x01
+#define ETH_TP_MDI_X            0x02
+
 /* Wake-On-Lan options. */
 #define WAKE_PHY                (1 << 0)
 #define WAKE_UCAST              (1 << 1)
diff --git a/include/linux/eventfd.h b/include/linux/eventfd.h
index f45a8ae5f828..3b85ba6479f4 100644
--- a/include/linux/eventfd.h
+++ b/include/linux/eventfd.h
@@ -8,10 +8,8 @@
 #ifndef _LINUX_EVENTFD_H
 #define _LINUX_EVENTFD_H
 
-#ifdef CONFIG_EVENTFD
-
-/* For O_CLOEXEC and O_NONBLOCK */
 #include <linux/fcntl.h>
+#include <linux/file.h>
 
 /*
  * CAREFUL: Check include/asm-generic/fcntl.h when defining
@@ -27,16 +25,37 @@
 #define EFD_SHARED_FCNTL_FLAGS (O_CLOEXEC | O_NONBLOCK)
 #define EFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS | EFD_SEMAPHORE)
 
+#ifdef CONFIG_EVENTFD
+
+struct eventfd_ctx *eventfd_ctx_get(struct eventfd_ctx *ctx);
+void eventfd_ctx_put(struct eventfd_ctx *ctx);
 struct file *eventfd_fget(int fd);
-int eventfd_signal(struct file *file, int n);
+struct eventfd_ctx *eventfd_ctx_fdget(int fd);
+struct eventfd_ctx *eventfd_ctx_fileget(struct file *file);
+int eventfd_signal(struct eventfd_ctx *ctx, int n);
 
 #else /* CONFIG_EVENTFD */
 
-#define eventfd_fget(fd) ERR_PTR(-ENOSYS)
-static inline int eventfd_signal(struct file *file, int n)
-{ return 0; }
+/*
+ * Ugly ugly ugly error layer to support modules that uses eventfd but
+ * pretend to work in !CONFIG_EVENTFD configurations. Namely, AIO.
+ */
+static inline struct eventfd_ctx *eventfd_ctx_fdget(int fd)
+{
+        return ERR_PTR(-ENOSYS);
+}
+
+static inline int eventfd_signal(struct eventfd_ctx *ctx, int n)
+{
+        return -ENOSYS;
+}
+
+static inline void eventfd_ctx_put(struct eventfd_ctx *ctx)
+{
+
+}
 
-#endif /* CONFIG_EVENTFD */
+#endif
 
 #endif /* _LINUX_EVENTFD_H */
 
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 634a5e5aba3e..7499b3667798 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -874,7 +874,7 @@ struct buffer_head * ext3_getblk (handle_t *, struct inode *, long, int, int *);
 struct buffer_head * ext3_bread (handle_t *, struct inode *, int, int, int *);
 int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
         sector_t iblock, unsigned long maxblocks, struct buffer_head *bh_result,
-        int create, int extend_disksize);
+        int create);
 
 extern struct inode *ext3_iget(struct super_block *, unsigned long);
 extern int  ext3_write_inode (struct inode *, int);
diff --git a/include/linux/ext3_fs_i.h b/include/linux/ext3_fs_i.h
index 7894dd0f3b77..ca1bfe90004f 100644
--- a/include/linux/ext3_fs_i.h
+++ b/include/linux/ext3_fs_i.h
@@ -103,10 +103,6 @@ struct ext3_inode_info {
          */
         struct rw_semaphore xattr_sem;
 #endif
-#ifdef CONFIG_EXT3_FS_POSIX_ACL
-        struct posix_acl        *i_acl;
-        struct posix_acl        *i_default_acl;
-#endif
 
         struct list_head i_orphan;      /* unlinked but open inodes */
 
diff --git a/include/linux/falloc.h b/include/linux/falloc.h
index 8e912ab6a072..3c155107d61f 100644
--- a/include/linux/falloc.h
+++ b/include/linux/falloc.h
@@ -3,4 +3,25 @@
 
 #define FALLOC_FL_KEEP_SIZE     0x01 /* default is extend size */
 
+#ifdef __KERNEL__
+
+/*
+ * Space reservation ioctls and argument structure
+ * are designed to be compatible with the legacy XFS ioctls.
+ */
+struct space_resv {
+        __s16           l_type;
+        __s16           l_whence;
+        __s64           l_start;
+        __s64           l_len;          /* len == 0 means until end of file */
+        __s32           l_sysid;
+        __u32           l_pid;
+        __s32           l_pad[4];       /* reserved area */
+};
+
+#define FS_IOC_RESVSP           _IOW('X', 40, struct space_resv)
+#define FS_IOC_RESVSP64         _IOW('X', 42, struct space_resv)
+
+#endif /* __KERNEL__ */
+
 #endif /* _FALLOC_H_ */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 330c4b1bfcaa..f847df9e99b6 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -677,6 +677,9 @@ struct fb_ops {
         /* get capability given var */
         void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
                             struct fb_var_screeninfo *var);
+
+        /* teardown any resources to do with this framebuffer */
+        void (*fb_destroy)(struct fb_info *info);
 };
 
 #ifdef CONFIG_FB_TILEBLITTING
@@ -786,6 +789,8 @@ struct fb_tile_ops {
 #define FBINFO_MISC_USEREVENT          0x10000 /* event request
                                                   from userspace */
 #define FBINFO_MISC_TILEBLITTING       0x20000 /* use tile blitting */
+#define FBINFO_MISC_FIRMWARE           0x40000 /* a replaceable firmware
+                                                  inited framebuffer */
 
 /* A driver may set this flag to indicate that it does want a set_par to be
  * called every time when fbcon_switch is executed. The advantage is that with
@@ -814,6 +819,7 @@ struct fb_info {
         int node;
         int flags;
         struct mutex lock;              /* Lock for open/release/ioctl funcs */
+        struct mutex mm_lock;           /* Lock for fb_mmap and smem_* fields */
         struct fb_var_screeninfo var;   /* Current var */
         struct fb_fix_screeninfo fix;   /* Current fix */
         struct fb_monspecs monspecs;    /* Current Monitor specs */
@@ -854,7 +860,12 @@ struct fb_info {
         u32 state;                      /* Hardware state i.e suspend */
         void *fbcon_par;                /* fbcon use-only private area */
         /* From here on everything is device dependent */
-        void *par;      
+        void *par;
+        /* we need the PCI or similiar aperture base/size not
+           smem_start/size as smem_start may just be an object
+           allocated inside the aperture so may not actually overlap */
+        resource_size_t aperture_base;
+        resource_size_t aperture_size;
 };
 
 #ifdef MODULE
@@ -893,7 +904,7 @@ struct fb_info {
 #define fb_writeq sbus_writeq
 #define fb_memset sbus_memset_io
 
-#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || defined(__avr32__)
+#elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || defined(__avr32__) || defined(__bfin__)
 
 #define fb_readb __raw_readb
 #define fb_readw __raw_readw
diff --git a/include/linux/firewire.h b/include/linux/firewire.h
new file mode 100644
index 000000000000..192d1e43c43c
--- /dev/null
+++ b/include/linux/firewire.h
@@ -0,0 +1,446 @@
+#ifndef _LINUX_FIREWIRE_H
+#define _LINUX_FIREWIRE_H
+
+#include <linux/completion.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/kernel.h>
+#include <linux/kref.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+#include <linux/sysfs.h>
+#include <linux/timer.h>
+#include <linux/types.h>
+#include <linux/workqueue.h>
+
+#include <asm/atomic.h>
+#include <asm/byteorder.h>
+
+#define fw_notify(s, args...) printk(KERN_NOTICE KBUILD_MODNAME ": " s, ## args)
+#define fw_error(s, args...) printk(KERN_ERR KBUILD_MODNAME ": " s, ## args)
+
+static inline void fw_memcpy_from_be32(void *_dst, void *_src, size_t size)
+{
+        u32    *dst = _dst;
+        __be32 *src = _src;
+        int i;
+
+        for (i = 0; i < size / 4; i++)
+                dst[i] = be32_to_cpu(src[i]);
+}
+
+static inline void fw_memcpy_to_be32(void *_dst, void *_src, size_t size)
+{
+        fw_memcpy_from_be32(_dst, _src, size);
+}
+#define CSR_REGISTER_BASE               0xfffff0000000ULL
+
+/* register offsets are relative to CSR_REGISTER_BASE */
+#define CSR_STATE_CLEAR                 0x0
+#define CSR_STATE_SET                   0x4
+#define CSR_NODE_IDS                    0x8
+#define CSR_RESET_START                 0xc
+#define CSR_SPLIT_TIMEOUT_HI            0x18
+#define CSR_SPLIT_TIMEOUT_LO            0x1c
+#define CSR_CYCLE_TIME                  0x200
+#define CSR_BUS_TIME                    0x204
+#define CSR_BUSY_TIMEOUT                0x210
+#define CSR_BUS_MANAGER_ID              0x21c
+#define CSR_BANDWIDTH_AVAILABLE         0x220
+#define CSR_CHANNELS_AVAILABLE          0x224
+#define CSR_CHANNELS_AVAILABLE_HI       0x224
+#define CSR_CHANNELS_AVAILABLE_LO       0x228
+#define CSR_BROADCAST_CHANNEL           0x234
+#define CSR_CONFIG_ROM                  0x400
+#define CSR_CONFIG_ROM_END              0x800
+#define CSR_FCP_COMMAND                 0xB00
+#define CSR_FCP_RESPONSE                0xD00
+#define CSR_FCP_END                     0xF00
+#define CSR_TOPOLOGY_MAP                0x1000
+#define CSR_TOPOLOGY_MAP_END            0x1400
+#define CSR_SPEED_MAP                   0x2000
+#define CSR_SPEED_MAP_END               0x3000
+
+#define CSR_OFFSET              0x40
+#define CSR_LEAF                0x80
+#define CSR_DIRECTORY           0xc0
+
+#define CSR_DESCRIPTOR          0x01
+#define CSR_VENDOR              0x03
+#define CSR_HARDWARE_VERSION    0x04
+#define CSR_NODE_CAPABILITIES   0x0c
+#define CSR_UNIT                0x11
+#define CSR_SPECIFIER_ID        0x12
+#define CSR_VERSION             0x13
+#define CSR_DEPENDENT_INFO      0x14
+#define CSR_MODEL               0x17
+#define CSR_INSTANCE            0x18
+#define CSR_DIRECTORY_ID        0x20
+
+struct fw_csr_iterator {
+        u32 *p;
+        u32 *end;
+};
+
+void fw_csr_iterator_init(struct fw_csr_iterator *ci, u32 *p);
+int fw_csr_iterator_next(struct fw_csr_iterator *ci, int *key, int *value);
+
+extern struct bus_type fw_bus_type;
+
+struct fw_card_driver;
+struct fw_node;
+
+struct fw_card {
+        const struct fw_card_driver *driver;
+        struct device *device;
+        struct kref kref;
+        struct completion done;
+
+        int node_id;
+        int generation;
+        int current_tlabel;
+        u64 tlabel_mask;
+        struct list_head transaction_list;
+        struct timer_list flush_timer;
+        unsigned long reset_jiffies;
+
+        unsigned long long guid;
+        unsigned max_receive;
+        int link_speed;
+        int config_rom_generation;
+
+        spinlock_t lock; /* Take this lock when handling the lists in
+                          * this struct. */
+        struct fw_node *local_node;
+        struct fw_node *root_node;
+        struct fw_node *irm_node;
+        u8 color; /* must be u8 to match the definition in struct fw_node */
+        int gap_count;
+        bool beta_repeaters_present;
+
+        int index;
+
+        struct list_head link;
+
+        /* Work struct for BM duties. */
+        struct delayed_work work;
+        int bm_retries;
+        int bm_generation;
+        __be32 bm_transaction_data[2];
+
+        bool broadcast_channel_allocated;
+        u32 broadcast_channel;
+        u32 topology_map[(CSR_TOPOLOGY_MAP_END - CSR_TOPOLOGY_MAP) / 4];
+};
+
+static inline struct fw_card *fw_card_get(struct fw_card *card)
+{
+        kref_get(&card->kref);
+
+        return card;
+}
+
+void fw_card_release(struct kref *kref);
+
+static inline void fw_card_put(struct fw_card *card)
+{
+        kref_put(&card->kref, fw_card_release);
+}
+
+struct fw_attribute_group {
+        struct attribute_group *groups[2];
+        struct attribute_group group;
+        struct attribute *attrs[12];
+};
+
+enum fw_device_state {
+        FW_DEVICE_INITIALIZING,
+        FW_DEVICE_RUNNING,
+        FW_DEVICE_GONE,
+        FW_DEVICE_SHUTDOWN,
+};
+
+/*
+ * Note, fw_device.generation always has to be read before fw_device.node_id.
+ * Use SMP memory barriers to ensure this.  Otherwise requests will be sent
+ * to an outdated node_id if the generation was updated in the meantime due
+ * to a bus reset.
+ *
+ * Likewise, fw-core will take care to update .node_id before .generation so
+ * that whenever fw_device.generation is current WRT the actual bus generation,
+ * fw_device.node_id is guaranteed to be current too.
+ *
+ * The same applies to fw_device.card->node_id vs. fw_device.generation.
+ *
+ * fw_device.config_rom and fw_device.config_rom_length may be accessed during
+ * the lifetime of any fw_unit belonging to the fw_device, before device_del()
+ * was called on the last fw_unit.  Alternatively, they may be accessed while
+ * holding fw_device_rwsem.
+ */
+struct fw_device {
+        atomic_t state;
+        struct fw_node *node;
+        int node_id;
+        int generation;
+        unsigned max_speed;
+        struct fw_card *card;
+        struct device device;
+
+        struct mutex client_list_mutex;
+        struct list_head client_list;
+
+        u32 *config_rom;
+        size_t config_rom_length;
+        int config_rom_retries;
+        unsigned is_local:1;
+        unsigned max_rec:4;
+        unsigned cmc:1;
+        unsigned irmc:1;
+        unsigned bc_implemented:2;
+
+        struct delayed_work work;
+        struct fw_attribute_group attribute_group;
+};
+
+static inline struct fw_device *fw_device(struct device *dev)
+{
+        return container_of(dev, struct fw_device, device);
+}
+
+static inline int fw_device_is_shutdown(struct fw_device *device)
+{
+        return atomic_read(&device->state) == FW_DEVICE_SHUTDOWN;
+}
+
+static inline struct fw_device *fw_device_get(struct fw_device *device)
+{
+        get_device(&device->device);
+
+        return device;
+}
+
+static inline void fw_device_put(struct fw_device *device)
+{
+        put_device(&device->device);
+}
+
+int fw_device_enable_phys_dma(struct fw_device *device);
+
+/*
+ * fw_unit.directory must not be accessed after device_del(&fw_unit.device).
+ */
+struct fw_unit {
+        struct device device;
+        u32 *directory;
+        struct fw_attribute_group attribute_group;
+};
+
+static inline struct fw_unit *fw_unit(struct device *dev)
+{
+        return container_of(dev, struct fw_unit, device);
+}
+
+static inline struct fw_unit *fw_unit_get(struct fw_unit *unit)
+{
+        get_device(&unit->device);
+
+        return unit;
+}
+
+static inline void fw_unit_put(struct fw_unit *unit)
+{
+        put_device(&unit->device);
+}
+
+static inline struct fw_device *fw_parent_device(struct fw_unit *unit)
+{
+        return fw_device(unit->device.parent);
+}
+
+struct ieee1394_device_id;
+
+struct fw_driver {
+        struct device_driver driver;
+        /* Called when the parent device sits through a bus reset. */
+        void (*update)(struct fw_unit *unit);
+        const struct ieee1394_device_id *id_table;
+};
+
+struct fw_packet;
+struct fw_request;
+
+typedef void (*fw_packet_callback_t)(struct fw_packet *packet,
+                                     struct fw_card *card, int status);
+typedef void (*fw_transaction_callback_t)(struct fw_card *card, int rcode,
+                                          void *data, size_t length,
+                                          void *callback_data);
+/*
+ * Important note:  The callback must guarantee that either fw_send_response()
+ * or kfree() is called on the @request.
+ */
+typedef void (*fw_address_callback_t)(struct fw_card *card,
+                                      struct fw_request *request,
+                                      int tcode, int destination, int source,
+                                      int generation, int speed,
+                                      unsigned long long offset,
+                                      void *data, size_t length,
+                                      void *callback_data);
+
+struct fw_packet {
+        int speed;
+        int generation;
+        u32 header[4];
+        size_t header_length;
+        void *payload;
+        size_t payload_length;
+        dma_addr_t payload_bus;
+        u32 timestamp;
+
+        /*
+         * This callback is called when the packet transmission has
+         * completed; for successful transmission, the status code is
+         * the ack received from the destination, otherwise it's a
+         * negative errno: ENOMEM, ESTALE, ETIMEDOUT, ENODEV, EIO.
+         * The callback can be called from tasklet context and thus
+         * must never block.
+         */
+        fw_packet_callback_t callback;
+        int ack;
+        struct list_head link;
+        void *driver_data;
+};
+
+struct fw_transaction {
+        int node_id; /* The generation is implied; it is always the current. */
+        int tlabel;
+        int timestamp;
+        struct list_head link;
+
+        struct fw_packet packet;
+
+        /*
+         * The data passed to the callback is valid only during the
+         * callback.
+         */
+        fw_transaction_callback_t callback;
+        void *callback_data;
+};
+
+struct fw_address_handler {
+        u64 offset;
+        size_t length;
+        fw_address_callback_t address_callback;
+        void *callback_data;
+        struct list_head link;
+};
+
+struct fw_address_region {
+        u64 start;
+        u64 end;
+};
+
+extern const struct fw_address_region fw_high_memory_region;
+
+int fw_core_add_address_handler(struct fw_address_handler *handler,
+                                const struct fw_address_region *region);
+void fw_core_remove_address_handler(struct fw_address_handler *handler);
+void fw_send_response(struct fw_card *card,
+                      struct fw_request *request, int rcode);
+void fw_send_request(struct fw_card *card, struct fw_transaction *t,
+                     int tcode, int destination_id, int generation, int speed,
+                     unsigned long long offset, void *payload, size_t length,
+                     fw_transaction_callback_t callback, void *callback_data);
+int fw_cancel_transaction(struct fw_card *card,
+                          struct fw_transaction *transaction);
+int fw_run_transaction(struct fw_card *card, int tcode, int destination_id,
+                       int generation, int speed, unsigned long long offset,
+                       void *payload, size_t length);
+
+static inline int fw_stream_packet_destination_id(int tag, int channel, int sy)
+{
+        return tag << 14 | channel << 8 | sy;
+}
+
+struct fw_descriptor {
+        struct list_head link;
+        size_t length;
+        u32 immediate;
+        u32 key;
+        const u32 *data;
+};
+
+int fw_core_add_descriptor(struct fw_descriptor *desc);
+void fw_core_remove_descriptor(struct fw_descriptor *desc);
+
+/*
+ * The iso packet format allows for an immediate header/payload part
+ * stored in 'header' immediately after the packet info plus an
+ * indirect payload part that is pointer to by the 'payload' field.
+ * Applications can use one or the other or both to implement simple
+ * low-bandwidth streaming (e.g. audio) or more advanced
+ * scatter-gather streaming (e.g. assembling video frame automatically).
+ */
+struct fw_iso_packet {
+        u16 payload_length;     /* Length of indirect payload. */
+        u32 interrupt:1;        /* Generate interrupt on this packet */
+        u32 skip:1;             /* Set to not send packet at all. */
+        u32 tag:2;
+        u32 sy:4;
+        u32 header_length:8;    /* Length of immediate header. */
+        u32 header[0];
+};
+
+#define FW_ISO_CONTEXT_TRANSMIT 0
+#define FW_ISO_CONTEXT_RECEIVE  1
+
+#define FW_ISO_CONTEXT_MATCH_TAG0        1
+#define FW_ISO_CONTEXT_MATCH_TAG1        2
+#define FW_ISO_CONTEXT_MATCH_TAG2        4
+#define FW_ISO_CONTEXT_MATCH_TAG3        8
+#define FW_ISO_CONTEXT_MATCH_ALL_TAGS   15
+
+/*
+ * An iso buffer is just a set of pages mapped for DMA in the
+ * specified direction.  Since the pages are to be used for DMA, they
+ * are not mapped into the kernel virtual address space.  We store the
+ * DMA address in the page private. The helper function
+ * fw_iso_buffer_map() will map the pages into a given vma.
+ */
+struct fw_iso_buffer {
+        enum dma_data_direction direction;
+        struct page **pages;
+        int page_count;
+};
+
+int fw_iso_buffer_init(struct fw_iso_buffer *buffer, struct fw_card *card,
+                       int page_count, enum dma_data_direction direction);
+void fw_iso_buffer_destroy(struct fw_iso_buffer *buffer, struct fw_card *card);
+
+struct fw_iso_context;
+typedef void (*fw_iso_callback_t)(struct fw_iso_context *context,
+                                  u32 cycle, size_t header_length,
+                                  void *header, void *data);
+struct fw_iso_context {
+        struct fw_card *card;
+        int type;
+        int channel;
+        int speed;
+        size_t header_size;
+        fw_iso_callback_t callback;
+        void *callback_data;
+};
+
+struct fw_iso_context *fw_iso_context_create(struct fw_card *card,
+                int type, int channel, int speed, size_t header_size,
+                fw_iso_callback_t callback, void *callback_data);
+int fw_iso_context_queue(struct fw_iso_context *ctx,
+                         struct fw_iso_packet *packet,
+                         struct fw_iso_buffer *buffer,
+                         unsigned long payload);
+int fw_iso_context_start(struct fw_iso_context *ctx,
+                         int cycle, int sync, int tags);
+int fw_iso_context_stop(struct fw_iso_context *ctx);
+void fw_iso_context_destroy(struct fw_iso_context *ctx);
+
+#endif /* _LINUX_FIREWIRE_H */
diff --git a/include/linux/firmware-map.h b/include/linux/firmware-map.h
index cca686b39123..875451f1373a 100644
--- a/include/linux/firmware-map.h
+++ b/include/linux/firmware-map.h
@@ -24,21 +24,17 @@
  */
 #ifdef CONFIG_FIRMWARE_MEMMAP
 
-int firmware_map_add(resource_size_t start, resource_size_t end,
-                     const char *type);
-int firmware_map_add_early(resource_size_t start, resource_size_t end,
-                           const char *type);
+int firmware_map_add(u64 start, u64 end, const char *type);
+int firmware_map_add_early(u64 start, u64 end, const char *type);
 
 #else /* CONFIG_FIRMWARE_MEMMAP */
 
-static inline int firmware_map_add(resource_size_t start, resource_size_t end,
-                                   const char *type)
+static inline int firmware_map_add(u64 start, u64 end, const char *type)
 {
         return 0;
 }
 
-static inline int firmware_map_add_early(resource_size_t start,
-                                         resource_size_t end, const char *type)
+static inline int firmware_map_add_early(u64 start, u64 end, const char *type)
 {
         return 0;
 }
diff --git a/include/linux/firmware.h b/include/linux/firmware.h
index c8ecf5b2a207..d31544628436 100644
--- a/include/linux/firmware.h
+++ b/include/linux/firmware.h
@@ -5,7 +5,6 @@
 #include <linux/types.h>
 #include <linux/compiler.h>
 
-#define FIRMWARE_NAME_MAX 30 
 #define FW_ACTION_NOHOTPLUG 0
 #define FW_ACTION_HOTPLUG 1
 
diff --git a/include/linux/flex_array.h b/include/linux/flex_array.h
new file mode 100644
index 000000000000..23c1ec79a31b
--- /dev/null
+++ b/include/linux/flex_array.h
@@ -0,0 +1,47 @@
+#ifndef _FLEX_ARRAY_H
+#define _FLEX_ARRAY_H
+
+#include <linux/types.h>
+#include <asm/page.h>
+
+#define FLEX_ARRAY_PART_SIZE PAGE_SIZE
+#define FLEX_ARRAY_BASE_SIZE PAGE_SIZE
+
+struct flex_array_part;
+
+/*
+ * This is meant to replace cases where an array-like
+ * structure has gotten too big to fit into kmalloc()
+ * and the developer is getting tempted to use
+ * vmalloc().
+ */
+
+struct flex_array {
+        union {
+                struct {
+                        int element_size;
+                        int total_nr_elements;
+                        struct flex_array_part *parts[0];
+                };
+                /*
+                 * This little trick makes sure that
+                 * sizeof(flex_array) == PAGE_SIZE
+                 */
+                char padding[FLEX_ARRAY_BASE_SIZE];
+        };
+};
+
+#define FLEX_ARRAY_INIT(size, total) { { {\
+        .element_size = (size),         \
+        .total_nr_elements = (total),   \
+} } }
+
+struct flex_array *flex_array_alloc(int element_size, int total, gfp_t flags);
+int flex_array_prealloc(struct flex_array *fa, int start, int end, gfp_t flags);
+void flex_array_free(struct flex_array *fa);
+void flex_array_free_parts(struct flex_array *fa);
+int flex_array_put(struct flex_array *fa, int element_nr, void *src,
+                gfp_t flags);
+void *flex_array_get(struct flex_array *fa, int element_nr);
+
+#endif /* _FLEX_ARRAY_H */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 3b534e527e09..a36ffa5a77a4 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -710,6 +710,9 @@ static inline int mapping_writably_mapped(struct address_space *mapping)
 #define i_size_ordered_init(inode) do { } while (0)
 #endif
 
+struct posix_acl;
+#define ACL_NOT_CACHED ((void *)(-1))
+
 struct inode {
         struct hlist_node       i_hash;
         struct list_head        i_list;
@@ -729,8 +732,8 @@ struct inode {
         struct timespec         i_atime;
         struct timespec         i_mtime;
         struct timespec         i_ctime;
-        unsigned int            i_blkbits;
         blkcnt_t                i_blocks;
+        unsigned int            i_blkbits;
         unsigned short          i_bytes;
         umode_t                 i_mode;
         spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
@@ -751,13 +754,12 @@ struct inode {
                 struct block_device     *i_bdev;
                 struct cdev             *i_cdev;
         };
-        int                     i_cindex;
 
         __u32                   i_generation;
 
-#ifdef CONFIG_DNOTIFY
-        unsigned long           i_dnotify_mask; /* Directory notify events */
-        struct dnotify_struct   *i_dnotify; /* for directory notifications */
+#ifdef CONFIG_FSNOTIFY
+        __u32                   i_fsnotify_mask; /* all events this inode cares about */
+        struct hlist_head       i_fsnotify_mark_entries; /* fsnotify mark entries */
 #endif
 
 #ifdef CONFIG_INOTIFY
@@ -774,6 +776,10 @@ struct inode {
 #ifdef CONFIG_SECURITY
         void                    *i_security;
 #endif
+#ifdef CONFIG_FS_POSIX_ACL
+        struct posix_acl        *i_acl;
+        struct posix_acl        *i_default_acl;
+#endif
         void                    *i_private; /* fs or device private pointer */
 };
 
@@ -880,7 +886,7 @@ struct file_ra_state {
                                            there are only # of pages ahead */
 
         unsigned int ra_pages;          /* Maximum readahead window */
-        int mmap_miss;                  /* Cache miss stat for mmap accesses */
+        unsigned int mmap_miss;         /* Cache miss stat for mmap accesses */
         loff_t prev_pos;                /* Cache last read() position */
 };
 
@@ -1108,6 +1114,7 @@ extern void locks_copy_lock(struct file_lock *, struct file_lock *);
 extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_flock(struct file *);
+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 *);
@@ -1321,7 +1328,7 @@ struct super_block {
         struct rw_semaphore     s_umount;
         struct mutex            s_lock;
         int                     s_count;
-        int                     s_need_sync_fs;
+        int                     s_need_sync;
         atomic_t                s_active;
 #ifdef CONFIG_SECURITY
         void                    *s_security;
@@ -1372,11 +1379,6 @@ struct super_block {
          * generic_show_options()
          */
         char *s_options;
-
-        /*
-         * storage for asynchronous operations
-         */
-        struct list_head s_async_list;
 };
 
 extern struct timespec current_fs_time(struct super_block *sb);
@@ -1800,7 +1802,7 @@ extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
 extern int may_umount_tree(struct vfsmount *);
 extern int may_umount(struct vfsmount *);
 extern long do_mount(char *, char *, char *, unsigned long, void *);
-extern struct vfsmount *collect_mounts(struct vfsmount *, struct dentry *);
+extern struct vfsmount *collect_mounts(struct path *);
 extern void drop_collected_mounts(struct vfsmount *);
 
 extern int vfs_statfs(struct dentry *, struct kstatfs *);
@@ -1911,6 +1913,8 @@ static inline int break_lease(struct inode *inode, unsigned int mode)
 
 extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
                        struct file *filp);
+extern int do_fallocate(struct file *file, int mode, loff_t offset,
+                        loff_t len);
 extern long do_sys_open(int dfd, const char __user *filename, int flags,
                         int mode);
 extern struct file *filp_open(const char *, int, int);
@@ -1919,14 +1923,19 @@ extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
 extern int filp_close(struct file *, fl_owner_t id);
 extern char * getname(const char __user *);
 
+/* fs/ioctl.c */
+
+extern int ioctl_preallocate(struct file *filp, void __user *argp);
+
 /* fs/dcache.c */
 extern void __init vfs_caches_init_early(void);
 extern void __init vfs_caches_init(unsigned long);
 
 extern struct kmem_cache *names_cachep;
 
-#define __getname()     kmem_cache_alloc(names_cachep, GFP_KERNEL)
-#define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
+#define __getname_gfp(gfp)      kmem_cache_alloc(names_cachep, (gfp))
+#define __getname()             __getname_gfp(GFP_KERNEL)
+#define __putname(name)         kmem_cache_free(names_cachep, (void *)(name))
 #ifndef CONFIG_AUDITSYSCALL
 #define putname(name)   __putname(name)
 #else
@@ -1937,6 +1946,7 @@ extern void putname(const char *name);
 extern int register_blkdev(unsigned int, const char *);
 extern void unregister_blkdev(unsigned int, const char *);
 extern struct block_device *bdget(dev_t);
+extern struct block_device *bdgrab(struct block_device *bdev);
 extern void bd_set_size(struct block_device *, loff_t size);
 extern void bd_forget(struct inode *inode);
 extern void bdput(struct block_device *);
@@ -1947,8 +1957,6 @@ extern struct super_block *freeze_bdev(struct block_device *);
 extern void emergency_thaw_all(void);
 extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
 extern int fsync_bdev(struct block_device *);
-extern int fsync_super(struct super_block *);
-extern int fsync_no_super(struct block_device *);
 #else
 static inline void bd_forget(struct inode *inode) {}
 static inline int sync_blockdev(struct block_device *bdev) { return 0; }
@@ -1964,6 +1972,7 @@ static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
         return 0;
 }
 #endif
+extern int sync_filesystem(struct super_block *);
 extern const struct file_operations def_blk_fops;
 extern const struct file_operations def_chr_fops;
 extern const struct file_operations bad_sock_fops;
@@ -2043,9 +2052,6 @@ extern int __invalidate_device(struct block_device *);
 extern int invalidate_partition(struct gendisk *, int);
 #endif
 extern int invalidate_inodes(struct super_block *);
-unsigned long __invalidate_mapping_pages(struct address_space *mapping,
-                                        pgoff_t start, pgoff_t end,
-                                        bool be_atomic);
 unsigned long invalidate_mapping_pages(struct address_space *mapping,
                                         pgoff_t start, pgoff_t end);
 
@@ -2082,12 +2088,8 @@ extern int filemap_fdatawrite_range(struct address_space *mapping,
 
 extern int vfs_fsync(struct file *file, struct dentry *dentry, int datasync);
 extern void sync_supers(void);
-extern void sync_filesystems(int wait);
-extern void __fsync_super(struct super_block *sb);
 extern void emergency_sync(void);
 extern void emergency_remount(void);
-extern int do_remount_sb(struct super_block *sb, int flags,
-                         void *data, int force);
 #ifdef CONFIG_BLOCK
 extern sector_t bmap(struct inode *, sector_t);
 #endif
@@ -2205,6 +2207,8 @@ extern int generic_segment_checks(const struct iovec *iov,
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
                 struct pipe_inode_info *, size_t, unsigned int);
+extern ssize_t default_file_splice_read(struct file *, loff_t *,
+                struct pipe_inode_info *, size_t, unsigned int);
 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,
@@ -2354,6 +2358,8 @@ extern void simple_release_fs(struct vfsmount **mount, int *count);
 extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
                         loff_t *ppos, const void *from, size_t available);
 
+extern int simple_fsync(struct file *, struct dentry *, int);
+
 #ifdef CONFIG_MIGRATION
 extern int buffer_migrate_page(struct address_space *,
                                 struct page *, struct page *);
diff --git a/include/linux/fs_enet_pd.h b/include/linux/fs_enet_pd.h
index 8300cab30f9a..51b793466ff3 100644
--- a/include/linux/fs_enet_pd.h
+++ b/include/linux/fs_enet_pd.h
@@ -17,6 +17,7 @@
 #define FS_ENET_PD_H
 
 #include <linux/string.h>
+#include <linux/of_mdio.h>
 #include <asm/types.h>
 
 #define FS_ENET_NAME    "fs_enet"
@@ -130,10 +131,7 @@ struct fs_platform_info {
         
         u32 device_flags;
 
-        int phy_addr;           /* the phy address (-1 no phy) */
-        char bus_id[16];
-        int phy_irq;            /* the phy irq (if it exists)  */
-
+        struct device_node *phy_node;
         const struct fs_mii_bus_info *bus_info;
 
         int rx_ring, tx_ring;   /* number of buffers on rx     */
diff --git a/include/linux/fsl_devices.h b/include/linux/fsl_devices.h
index 244677cc082b..43fc95d822d5 100644
--- a/include/linux/fsl_devices.h
+++ b/include/linux/fsl_devices.h
@@ -79,10 +79,6 @@ struct fsl_spi_platform_data {
         u16     max_chipselect;
         void    (*cs_control)(struct spi_device *spi, bool on);
         u32     sysclk;
-
-        /* Legacy hooks, used by mpc52xx_psc_spi driver. */
-        void    (*activate_cs)(u8 cs, u8 polarity);
-        void    (*deactivate_cs)(u8 cs, u8 polarity);
 };
 
 struct mpc8xx_pcmcia_ops {
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index 00fbd5b245c9..936f9aa8bb97 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -13,6 +13,7 @@
 
 #include <linux/dnotify.h>
 #include <linux/inotify.h>
+#include <linux/fsnotify_backend.h>
 #include <linux/audit.h>
 
 /*
@@ -22,19 +23,45 @@
 static inline void fsnotify_d_instantiate(struct dentry *entry,
                                                 struct inode *inode)
 {
+        __fsnotify_d_instantiate(entry, inode);
+
         inotify_d_instantiate(entry, inode);
 }
 
+/* Notify this dentry's parent about a child's events. */
+static inline void fsnotify_parent(struct dentry *dentry, __u32 mask)
+{
+        __fsnotify_parent(dentry, mask);
+
+        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
+}
+
 /*
  * fsnotify_d_move - entry has been moved
  * Called with dcache_lock and entry->d_lock held.
  */
 static inline void fsnotify_d_move(struct dentry *entry)
 {
+        /*
+         * On move we need to update entry->d_flags to indicate if the new parent
+         * cares about events from this entry.
+         */
+        __fsnotify_update_dcache_flags(entry);
+
         inotify_d_move(entry);
 }
 
 /*
+ * fsnotify_link_count - inode's link count changed
+ */
+static inline void fsnotify_link_count(struct inode *inode)
+{
+        inotify_inode_queue_event(inode, IN_ATTRIB, 0, NULL, NULL);
+
+        fsnotify(inode, FS_ATTRIB, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
+}
+
+/*
  * fsnotify_move - file old_name at old_dir was moved to new_name at new_dir
  */
 static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
@@ -42,42 +69,62 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
                                  int isdir, struct inode *target, struct dentry *moved)
 {
         struct inode *source = moved->d_inode;
-        u32 cookie = inotify_get_cookie();
+        u32 in_cookie = inotify_get_cookie();
+        u32 fs_cookie = fsnotify_get_cookie();
+        __u32 old_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_FROM);
+        __u32 new_dir_mask = (FS_EVENT_ON_CHILD | FS_MOVED_TO);
 
         if (old_dir == new_dir)
-                inode_dir_notify(old_dir, DN_RENAME);
-        else {
-                inode_dir_notify(old_dir, DN_DELETE);
-                inode_dir_notify(new_dir, DN_CREATE);
-        }
+                old_dir_mask |= FS_DN_RENAME;
 
-        if (isdir)
+        if (isdir) {
                 isdir = IN_ISDIR;
-        inotify_inode_queue_event(old_dir, IN_MOVED_FROM|isdir,cookie,old_name,
+                old_dir_mask |= FS_IN_ISDIR;
+                new_dir_mask |= FS_IN_ISDIR;
+        }
+
+        inotify_inode_queue_event(old_dir, IN_MOVED_FROM|isdir, in_cookie, old_name,
                                   source);
-        inotify_inode_queue_event(new_dir, IN_MOVED_TO|isdir, cookie, new_name,
+        inotify_inode_queue_event(new_dir, IN_MOVED_TO|isdir, in_cookie, new_name,
                                   source);
 
+        fsnotify(old_dir, old_dir_mask, old_dir, FSNOTIFY_EVENT_INODE, old_name, fs_cookie);
+        fsnotify(new_dir, new_dir_mask, new_dir, FSNOTIFY_EVENT_INODE, new_name, fs_cookie);
+
         if (target) {
                 inotify_inode_queue_event(target, IN_DELETE_SELF, 0, NULL, NULL);
                 inotify_inode_is_dead(target);
+
+                /* this is really a link_count change not a removal */
+                fsnotify_link_count(target);
         }
 
         if (source) {
                 inotify_inode_queue_event(source, IN_MOVE_SELF, 0, NULL, NULL);
+                fsnotify(source, FS_MOVE_SELF, moved->d_inode, FSNOTIFY_EVENT_INODE, NULL, 0);
         }
         audit_inode_child(new_name, moved, new_dir);
 }
 
 /*
+ * fsnotify_inode_delete - and inode is being evicted from cache, clean up is needed
+ */
+static inline void fsnotify_inode_delete(struct inode *inode)
+{
+        __fsnotify_inode_delete(inode);
+}
+
+/*
  * fsnotify_nameremove - a filename was removed from a directory
  */
 static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
 {
+        __u32 mask = FS_DELETE;
+
         if (isdir)
-                isdir = IN_ISDIR;
-        dnotify_parent(dentry, DN_DELETE);
-        inotify_dentry_parent_queue_event(dentry, IN_DELETE|isdir, 0, dentry->d_name.name);
+                mask |= FS_IN_ISDIR;
+
+        fsnotify_parent(dentry, mask);
 }
 
 /*
@@ -87,14 +134,9 @@ static inline void fsnotify_inoderemove(struct inode *inode)
 {
         inotify_inode_queue_event(inode, IN_DELETE_SELF, 0, NULL, NULL);
         inotify_inode_is_dead(inode);
-}
 
-/*
- * fsnotify_link_count - inode's link count changed
- */
-static inline void fsnotify_link_count(struct inode *inode)
-{
-        inotify_inode_queue_event(inode, IN_ATTRIB, 0, NULL, NULL);
+        fsnotify(inode, FS_DELETE_SELF, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
+        __fsnotify_inode_delete(inode);
 }
 
 /*
@@ -102,10 +144,11 @@ static inline void fsnotify_link_count(struct inode *inode)
  */
 static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
 {
-        inode_dir_notify(inode, DN_CREATE);
         inotify_inode_queue_event(inode, IN_CREATE, 0, dentry->d_name.name,
                                   dentry->d_inode);
         audit_inode_child(dentry->d_name.name, dentry, inode);
+
+        fsnotify(inode, FS_CREATE, dentry->d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0);
 }
 
 /*
@@ -115,11 +158,12 @@ static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
  */
 static inline void fsnotify_link(struct inode *dir, struct inode *inode, struct dentry *new_dentry)
 {
-        inode_dir_notify(dir, DN_CREATE);
         inotify_inode_queue_event(dir, IN_CREATE, 0, new_dentry->d_name.name,
                                   inode);
         fsnotify_link_count(inode);
         audit_inode_child(new_dentry->d_name.name, new_dentry, dir);
+
+        fsnotify(dir, FS_CREATE, inode, FSNOTIFY_EVENT_INODE, new_dentry->d_name.name, 0);
 }
 
 /*
@@ -127,10 +171,13 @@ static inline void fsnotify_link(struct inode *dir, struct inode *inode, struct
  */
 static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
 {
-        inode_dir_notify(inode, DN_CREATE);
-        inotify_inode_queue_event(inode, IN_CREATE | IN_ISDIR, 0, 
-                                  dentry->d_name.name, dentry->d_inode);
+        __u32 mask = (FS_CREATE | FS_IN_ISDIR);
+        struct inode *d_inode = dentry->d_inode;
+
+        inotify_inode_queue_event(inode, mask, 0, dentry->d_name.name, d_inode);
         audit_inode_child(dentry->d_name.name, dentry, inode);
+
+        fsnotify(inode, mask, d_inode, FSNOTIFY_EVENT_INODE, dentry->d_name.name, 0);
 }
 
 /*
@@ -139,14 +186,15 @@ static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
 static inline void fsnotify_access(struct dentry *dentry)
 {
         struct inode *inode = dentry->d_inode;
-        u32 mask = IN_ACCESS;
+        __u32 mask = FS_ACCESS;
 
         if (S_ISDIR(inode->i_mode))
-                mask |= IN_ISDIR;
+                mask |= FS_IN_ISDIR;
 
-        dnotify_parent(dentry, DN_ACCESS);
-        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+
+        fsnotify_parent(dentry, mask);
+        fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 }
 
 /*
@@ -155,14 +203,15 @@ static inline void fsnotify_access(struct dentry *dentry)
 static inline void fsnotify_modify(struct dentry *dentry)
 {
         struct inode *inode = dentry->d_inode;
-        u32 mask = IN_MODIFY;
+        __u32 mask = FS_MODIFY;
 
         if (S_ISDIR(inode->i_mode))
-                mask |= IN_ISDIR;
+                mask |= FS_IN_ISDIR;
 
-        dnotify_parent(dentry, DN_MODIFY);
-        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+
+        fsnotify_parent(dentry, mask);
+        fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 }
 
 /*
@@ -171,13 +220,15 @@ static inline void fsnotify_modify(struct dentry *dentry)
 static inline void fsnotify_open(struct dentry *dentry)
 {
         struct inode *inode = dentry->d_inode;
-        u32 mask = IN_OPEN;
+        __u32 mask = FS_OPEN;
 
         if (S_ISDIR(inode->i_mode))
-                mask |= IN_ISDIR;
+                mask |= FS_IN_ISDIR;
 
-        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+
+        fsnotify_parent(dentry, mask);
+        fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 }
 
 /*
@@ -187,15 +238,16 @@ static inline void fsnotify_close(struct file *file)
 {
         struct dentry *dentry = file->f_path.dentry;
         struct inode *inode = dentry->d_inode;
-        const char *name = dentry->d_name.name;
         fmode_t mode = file->f_mode;
-        u32 mask = (mode & FMODE_WRITE) ? IN_CLOSE_WRITE : IN_CLOSE_NOWRITE;
+        __u32 mask = (mode & FMODE_WRITE) ? FS_CLOSE_WRITE : FS_CLOSE_NOWRITE;
 
         if (S_ISDIR(inode->i_mode))
-                mask |= IN_ISDIR;
+                mask |= FS_IN_ISDIR;
 
-        inotify_dentry_parent_queue_event(dentry, mask, 0, name);
         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+
+        fsnotify_parent(dentry, mask);
+        fsnotify(inode, mask, file, FSNOTIFY_EVENT_FILE, NULL, 0);
 }
 
 /*
@@ -204,13 +256,15 @@ static inline void fsnotify_close(struct file *file)
 static inline void fsnotify_xattr(struct dentry *dentry)
 {
         struct inode *inode = dentry->d_inode;
-        u32 mask = IN_ATTRIB;
+        __u32 mask = FS_ATTRIB;
 
         if (S_ISDIR(inode->i_mode))
-                mask |= IN_ISDIR;
+                mask |= FS_IN_ISDIR;
 
-        inotify_dentry_parent_queue_event(dentry, mask, 0, dentry->d_name.name);
         inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+
+        fsnotify_parent(dentry, mask);
+        fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
 }
 
 /*
@@ -220,50 +274,37 @@ static inline void fsnotify_xattr(struct dentry *dentry)
 static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)
 {
         struct inode *inode = dentry->d_inode;
-        int dn_mask = 0;
-        u32 in_mask = 0;
+        __u32 mask = 0;
+
+        if (ia_valid & ATTR_UID)
+                mask |= FS_ATTRIB;
+        if (ia_valid & ATTR_GID)
+                mask |= FS_ATTRIB;
+        if (ia_valid & ATTR_SIZE)
+                mask |= FS_MODIFY;
 
-        if (ia_valid & ATTR_UID) {
-                in_mask |= IN_ATTRIB;
-                dn_mask |= DN_ATTRIB;
-        }
-        if (ia_valid & ATTR_GID) {
-                in_mask |= IN_ATTRIB;
-                dn_mask |= DN_ATTRIB;
-        }
-        if (ia_valid & ATTR_SIZE) {
-                in_mask |= IN_MODIFY;
-                dn_mask |= DN_MODIFY;
-        }
         /* both times implies a utime(s) call */
         if ((ia_valid & (ATTR_ATIME | ATTR_MTIME)) == (ATTR_ATIME | ATTR_MTIME))
-        {
-                in_mask |= IN_ATTRIB;
-                dn_mask |= DN_ATTRIB;
-        } else if (ia_valid & ATTR_ATIME) {
-                in_mask |= IN_ACCESS;
-                dn_mask |= DN_ACCESS;
-        } else if (ia_valid & ATTR_MTIME) {
-                in_mask |= IN_MODIFY;
-                dn_mask |= DN_MODIFY;
-        }
-        if (ia_valid & ATTR_MODE) {
-                in_mask |= IN_ATTRIB;
-                dn_mask |= DN_ATTRIB;
-        }
+                mask |= FS_ATTRIB;
+        else if (ia_valid & ATTR_ATIME)
+                mask |= FS_ACCESS;
+        else if (ia_valid & ATTR_MTIME)
+                mask |= FS_MODIFY;
+
+        if (ia_valid & ATTR_MODE)
+                mask |= FS_ATTRIB;
 
-        if (dn_mask)
-                dnotify_parent(dentry, dn_mask);
-        if (in_mask) {
+        if (mask) {
                 if (S_ISDIR(inode->i_mode))
-                        in_mask |= IN_ISDIR;
-                inotify_inode_queue_event(inode, in_mask, 0, NULL, NULL);
-                inotify_dentry_parent_queue_event(dentry, in_mask, 0,
-                                                  dentry->d_name.name);
+                        mask |= FS_IN_ISDIR;
+                inotify_inode_queue_event(inode, mask, 0, NULL, NULL);
+
+                fsnotify_parent(dentry, mask);
+                fsnotify(inode, mask, inode, FSNOTIFY_EVENT_INODE, NULL, 0);
         }
 }
 
-#ifdef CONFIG_INOTIFY   /* inotify helpers */
+#if defined(CONFIG_INOTIFY) || defined(CONFIG_FSNOTIFY) /* notify helpers */
 
 /*
  * fsnotify_oldname_init - save off the old filename before we change it
@@ -281,7 +322,7 @@ static inline void fsnotify_oldname_free(const char *old_name)
         kfree(old_name);
 }
 
-#else   /* CONFIG_INOTIFY */
+#else   /* CONFIG_INOTIFY || CONFIG_FSNOTIFY */
 
 static inline const char *fsnotify_oldname_init(const char *name)
 {
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
new file mode 100644
index 000000000000..4d6f47b51189
--- /dev/null
+++ b/include/linux/fsnotify_backend.h
@@ -0,0 +1,387 @@
+/*
+ * Filesystem access notification for Linux
+ *
+ *  Copyright (C) 2008 Red Hat, Inc., Eric Paris <eparis@redhat.com>
+ */
+
+#ifndef __LINUX_FSNOTIFY_BACKEND_H
+#define __LINUX_FSNOTIFY_BACKEND_H
+
+#ifdef __KERNEL__
+
+#include <linux/idr.h> /* inotify uses this */
+#include <linux/fs.h> /* struct inode */
+#include <linux/list.h>
+#include <linux/path.h> /* struct path */
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#include <asm/atomic.h>
+
+/*
+ * IN_* from inotfy.h lines up EXACTLY with FS_*, this is so we can easily
+ * convert between them.  dnotify only needs conversion at watch creation
+ * so no perf loss there.  fanotify isn't defined yet, so it can use the
+ * wholes if it needs more events.
+ */
+#define FS_ACCESS               0x00000001      /* File was accessed */
+#define FS_MODIFY               0x00000002      /* File was modified */
+#define FS_ATTRIB               0x00000004      /* Metadata changed */
+#define FS_CLOSE_WRITE          0x00000008      /* Writtable file was closed */
+#define FS_CLOSE_NOWRITE        0x00000010      /* Unwrittable file closed */
+#define FS_OPEN                 0x00000020      /* File was opened */
+#define FS_MOVED_FROM           0x00000040      /* File was moved from X */
+#define FS_MOVED_TO             0x00000080      /* File was moved to Y */
+#define FS_CREATE               0x00000100      /* Subfile was created */
+#define FS_DELETE               0x00000200      /* Subfile was deleted */
+#define FS_DELETE_SELF          0x00000400      /* Self was deleted */
+#define FS_MOVE_SELF            0x00000800      /* Self was moved */
+
+#define FS_UNMOUNT              0x00002000      /* inode on umount fs */
+#define FS_Q_OVERFLOW           0x00004000      /* Event queued overflowed */
+#define FS_IN_IGNORED           0x00008000      /* last inotify event here */
+
+#define FS_IN_ISDIR             0x40000000      /* event occurred against dir */
+#define FS_IN_ONESHOT           0x80000000      /* only send event once */
+
+#define FS_DN_RENAME            0x10000000      /* file renamed */
+#define FS_DN_MULTISHOT         0x20000000      /* dnotify multishot */
+
+/* This inode cares about things that happen to its children.  Always set for
+ * dnotify and inotify. */
+#define FS_EVENT_ON_CHILD       0x08000000
+
+/* This is a list of all events that may get sent to a parernt based on fs event
+ * happening to inodes inside that directory */
+#define FS_EVENTS_POSS_ON_CHILD   (FS_ACCESS | FS_MODIFY | FS_ATTRIB |\
+                                   FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | FS_OPEN |\
+                                   FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE |\
+                                   FS_DELETE)
+
+/* listeners that hard code group numbers near the top */
+#define DNOTIFY_GROUP_NUM       UINT_MAX
+#define INOTIFY_GROUP_NUM       (DNOTIFY_GROUP_NUM-1)
+
+struct fsnotify_group;
+struct fsnotify_event;
+struct fsnotify_mark_entry;
+struct fsnotify_event_private_data;
+
+/*
+ * Each group much define these ops.  The fsnotify infrastructure will call
+ * these operations for each relevant group.
+ *
+ * should_send_event - given a group, inode, and mask this function determines
+ *              if the group is interested in this event.
+ * handle_event - main call for a group to handle an fs event
+ * free_group_priv - called when a group refcnt hits 0 to clean up the private union
+ * freeing-mark - this means that a mark has been flagged to die when everything
+ *              finishes using it.  The function is supplied with what must be a
+ *              valid group and inode to use to clean up.
+ */
+struct fsnotify_ops {
+        bool (*should_send_event)(struct fsnotify_group *group, struct inode *inode, __u32 mask);
+        int (*handle_event)(struct fsnotify_group *group, struct fsnotify_event *event);
+        void (*free_group_priv)(struct fsnotify_group *group);
+        void (*freeing_mark)(struct fsnotify_mark_entry *entry, struct fsnotify_group *group);
+        void (*free_event_priv)(struct fsnotify_event_private_data *priv);
+};
+
+/*
+ * A group is a "thing" that wants to receive notification about filesystem
+ * events.  The mask holds the subset of event types this group cares about.
+ * refcnt on a group is up to the implementor and at any moment if it goes 0
+ * everything will be cleaned up.
+ */
+struct fsnotify_group {
+        /*
+         * global list of all groups receiving events from fsnotify.
+         * anchored by fsnotify_groups and protected by either fsnotify_grp_mutex
+         * or fsnotify_grp_srcu depending on write vs read.
+         */
+        struct list_head group_list;
+
+        /*
+         * Defines all of the event types in which this group is interested.
+         * This mask is a bitwise OR of the FS_* events from above.  Each time
+         * this mask changes for a group (if it changes) the correct functions
+         * must be called to update the global structures which indicate global
+         * interest in event types.
+         */
+        __u32 mask;
+
+        /*
+         * How the refcnt is used is up to each group.  When the refcnt hits 0
+         * fsnotify will clean up all of the resources associated with this group.
+         * As an example, the dnotify group will always have a refcnt=1 and that
+         * will never change.  Inotify, on the other hand, has a group per
+         * inotify_init() and the refcnt will hit 0 only when that fd has been
+         * closed.
+         */
+        atomic_t refcnt;                /* things with interest in this group */
+        unsigned int group_num;         /* simply prevents accidental group collision */
+
+        const struct fsnotify_ops *ops; /* how this group handles things */
+
+        /* needed to send notification to userspace */
+        struct mutex notification_mutex;        /* protect the notification_list */
+        struct list_head notification_list;     /* list of event_holder this group needs to send to userspace */
+        wait_queue_head_t notification_waitq;   /* read() on the notification file blocks on this waitq */
+        unsigned int q_len;                     /* events on the queue */
+        unsigned int max_events;                /* maximum events allowed on the list */
+
+        /* stores all fastapth entries assoc with this group so they can be cleaned on unregister */
+        spinlock_t mark_lock;           /* protect mark_entries list */
+        atomic_t num_marks;             /* 1 for each mark entry and 1 for not being
+                                         * past the point of no return when freeing
+                                         * a group */
+        struct list_head mark_entries;  /* all inode mark entries for this group */
+
+        /* prevents double list_del of group_list.  protected by global fsnotify_grp_mutex */
+        bool on_group_list;
+
+        /* groups can define private fields here or use the void *private */
+        union {
+                void *private;
+#ifdef CONFIG_INOTIFY_USER
+                struct inotify_group_private_data {
+                        spinlock_t      idr_lock;
+                        struct idr      idr;
+                        u32             last_wd;
+                        struct fasync_struct    *fa;    /* async notification */
+                        struct user_struct      *user;
+                } inotify_data;
+#endif
+        };
+};
+
+/*
+ * A single event can be queued in multiple group->notification_lists.
+ *
+ * each group->notification_list will point to an event_holder which in turns points
+ * to the actual event that needs to be sent to userspace.
+ *
+ * Seemed cheaper to create a refcnt'd event and a small holder for every group
+ * than create a different event for every group
+ *
+ */
+struct fsnotify_event_holder {
+        struct fsnotify_event *event;
+        struct list_head event_list;
+};
+
+/*
+ * Inotify needs to tack data onto an event.  This struct lets us later find the
+ * correct private data of the correct group.
+ */
+struct fsnotify_event_private_data {
+        struct fsnotify_group *group;
+        struct list_head event_list;
+};
+
+/*
+ * all of the information about the original object we want to now send to
+ * a group.  If you want to carry more info from the accessing task to the
+ * listener this structure is where you need to be adding fields.
+ */
+struct fsnotify_event {
+        /*
+         * If we create an event we are also likely going to need a holder
+         * to link to a group.  So embed one holder in the event.  Means only
+         * one allocation for the common case where we only have one group
+         */
+        struct fsnotify_event_holder holder;
+        spinlock_t lock;        /* protection for the associated event_holder and private_list */
+        /* to_tell may ONLY be dereferenced during handle_event(). */
+        struct inode *to_tell;  /* either the inode the event happened to or its parent */
+        /*
+         * depending on the event type we should have either a path or inode
+         * We hold a reference on path, but NOT on inode.  Since we have the ref on
+         * the path, it may be dereferenced at any point during this object's
+         * lifetime.  That reference is dropped when this object's refcnt hits
+         * 0.  If this event contains an inode instead of a path, the inode may
+         * ONLY be used during handle_event().
+         */
+        union {
+                struct path path;
+                struct inode *inode;
+        };
+/* when calling fsnotify tell it if the data is a path or inode */
+#define FSNOTIFY_EVENT_NONE     0
+#define FSNOTIFY_EVENT_PATH     1
+#define FSNOTIFY_EVENT_INODE    2
+#define FSNOTIFY_EVENT_FILE     3
+        int data_type;          /* which of the above union we have */
+        atomic_t refcnt;        /* how many groups still are using/need to send this event */
+        __u32 mask;             /* the type of access, bitwise OR for FS_* event types */
+
+        u32 sync_cookie;        /* used to corrolate events, namely inotify mv events */
+        char *file_name;
+        size_t name_len;
+
+        struct list_head private_data_list;     /* groups can store private data here */
+};
+
+/*
+ * a mark is simply an entry attached to an in core inode which allows an
+ * fsnotify listener to indicate they are either no longer interested in events
+ * of a type matching mask or only interested in those events.
+ *
+ * these are flushed when an inode is evicted from core and may be flushed
+ * when the inode is modified (as seen by fsnotify_access).  Some fsnotify users
+ * (such as dnotify) will flush these when the open fd is closed and not at
+ * inode eviction or modification.
+ */
+struct fsnotify_mark_entry {
+        __u32 mask;                     /* mask this mark entry is for */
+        /* we hold ref for each i_list and g_list.  also one ref for each 'thing'
+         * in kernel that found and may be using this mark. */
+        atomic_t refcnt;                /* active things looking at this mark */
+        struct inode *inode;            /* inode this entry is associated with */
+        struct fsnotify_group *group;   /* group this mark entry is for */
+        struct hlist_node i_list;       /* list of mark_entries by inode->i_fsnotify_mark_entries */
+        struct list_head g_list;        /* list of mark_entries by group->i_fsnotify_mark_entries */
+        spinlock_t lock;                /* protect group, inode, and killme */
+        struct list_head free_i_list;   /* tmp list used when freeing this mark */
+        struct list_head free_g_list;   /* tmp list used when freeing this mark */
+        void (*free_mark)(struct fsnotify_mark_entry *entry); /* called on final put+free */
+};
+
+#ifdef CONFIG_FSNOTIFY
+
+/* called from the vfs helpers */
+
+/* main fsnotify call to send events */
+extern void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
+                     const char *name, u32 cookie);
+extern void __fsnotify_parent(struct dentry *dentry, __u32 mask);
+extern void __fsnotify_inode_delete(struct inode *inode);
+extern u32 fsnotify_get_cookie(void);
+
+static inline int fsnotify_inode_watches_children(struct inode *inode)
+{
+        /* FS_EVENT_ON_CHILD is set if the inode may care */
+        if (!(inode->i_fsnotify_mask & FS_EVENT_ON_CHILD))
+                return 0;
+        /* this inode might care about child events, does it care about the
+         * specific set of events that can happen on a child? */
+        return inode->i_fsnotify_mask & FS_EVENTS_POSS_ON_CHILD;
+}
+
+/*
+ * Update the dentry with a flag indicating the interest of its parent to receive
+ * filesystem events when those events happens to this dentry->d_inode.
+ */
+static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
+{
+        struct dentry *parent;
+
+        assert_spin_locked(&dcache_lock);
+        assert_spin_locked(&dentry->d_lock);
+
+        parent = dentry->d_parent;
+        if (parent->d_inode && fsnotify_inode_watches_children(parent->d_inode))
+                dentry->d_flags |= DCACHE_FSNOTIFY_PARENT_WATCHED;
+        else
+                dentry->d_flags &= ~DCACHE_FSNOTIFY_PARENT_WATCHED;
+}
+
+/*
+ * fsnotify_d_instantiate - instantiate a dentry for inode
+ * Called with dcache_lock held.
+ */
+static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode *inode)
+{
+        if (!inode)
+                return;
+
+        assert_spin_locked(&dcache_lock);
+
+        spin_lock(&dentry->d_lock);
+        __fsnotify_update_dcache_flags(dentry);
+        spin_unlock(&dentry->d_lock);
+}
+
+/* called from fsnotify listeners, such as fanotify or dnotify */
+
+/* must call when a group changes its ->mask */
+extern void fsnotify_recalc_global_mask(void);
+/* get a reference to an existing or create a new group */
+extern struct fsnotify_group *fsnotify_obtain_group(unsigned int group_num,
+                                                    __u32 mask,
+                                                    const struct fsnotify_ops *ops);
+/* run all marks associated with this group and update group->mask */
+extern void fsnotify_recalc_group_mask(struct fsnotify_group *group);
+/* drop reference on a group from fsnotify_obtain_group */
+extern void fsnotify_put_group(struct fsnotify_group *group);
+
+/* take a reference to an event */
+extern void fsnotify_get_event(struct fsnotify_event *event);
+extern void fsnotify_put_event(struct fsnotify_event *event);
+/* find private data previously attached to an event and unlink it */
+extern struct fsnotify_event_private_data *fsnotify_remove_priv_from_event(struct fsnotify_group *group,
+                                                                           struct fsnotify_event *event);
+
+/* attach the event to the group notification queue */
+extern int fsnotify_add_notify_event(struct fsnotify_group *group, struct fsnotify_event *event,
+                                     struct fsnotify_event_private_data *priv);
+/* true if the group notification queue is empty */
+extern bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group);
+/* return, but do not dequeue the first event on the notification queue */
+extern struct fsnotify_event *fsnotify_peek_notify_event(struct fsnotify_group *group);
+/* return AND dequeue the first event on the notification queue */
+extern struct fsnotify_event *fsnotify_remove_notify_event(struct fsnotify_group *group);
+
+/* functions used to manipulate the marks attached to inodes */
+
+/* run all marks associated with an inode and update inode->i_fsnotify_mask */
+extern void fsnotify_recalc_inode_mask(struct inode *inode);
+extern void fsnotify_init_mark(struct fsnotify_mark_entry *entry, void (*free_mark)(struct fsnotify_mark_entry *entry));
+/* find (and take a reference) to a mark associated with group and inode */
+extern struct fsnotify_mark_entry *fsnotify_find_mark_entry(struct fsnotify_group *group, struct inode *inode);
+/* attach the mark to both the group and the inode */
+extern int fsnotify_add_mark(struct fsnotify_mark_entry *entry, struct fsnotify_group *group, struct inode *inode);
+/* given a mark, flag it to be freed when all references are dropped */
+extern void fsnotify_destroy_mark_by_entry(struct fsnotify_mark_entry *entry);
+/* run all the marks in a group, and flag them to be freed */
+extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group);
+extern void fsnotify_get_mark(struct fsnotify_mark_entry *entry);
+extern void fsnotify_put_mark(struct fsnotify_mark_entry *entry);
+extern void fsnotify_unmount_inodes(struct list_head *list);
+
+/* put here because inotify does some weird stuff when destroying watches */
+extern struct fsnotify_event *fsnotify_create_event(struct inode *to_tell, __u32 mask,
+                                                    void *data, int data_is, const char *name,
+                                                    u32 cookie, gfp_t gfp);
+
+#else
+
+static inline void fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
+                            const char *name, u32 cookie)
+{}
+
+static inline void __fsnotify_parent(struct dentry *dentry, __u32 mask)
+{}
+
+static inline void __fsnotify_inode_delete(struct inode *inode)
+{}
+
+static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
+{}
+
+static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode *inode)
+{}
+
+static inline u32 fsnotify_get_cookie(void)
+{
+        return 0;
+}
+
+static inline void fsnotify_unmount_inodes(struct list_head *list)
+{}
+
+#endif  /* CONFIG_FSNOTIFY */
+
+#endif  /* __KERNEL __ */
+
+#endif  /* __LINUX_FSNOTIFY_BACKEND_H */
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 8a0c2f221e6b..dc3b1328aaeb 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -233,8 +233,6 @@ extern int ftrace_arch_read_dyn_info(char *buf, int size);
 
 extern int skip_trace(unsigned long ip);
 
-extern void ftrace_release(void *start, unsigned long size);
-
 extern void ftrace_disable_daemon(void);
 extern void ftrace_enable_daemon(void);
 #else
@@ -325,13 +323,8 @@ static inline void __ftrace_enabled_restore(int enabled)
 
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 extern void ftrace_init(void);
-extern void ftrace_init_module(struct module *mod,
-                               unsigned long *start, unsigned long *end);
 #else
 static inline void ftrace_init(void) { }
-static inline void
-ftrace_init_module(struct module *mod,
-                   unsigned long *start, unsigned long *end) { }
 #endif
 
 /*
@@ -368,6 +361,8 @@ struct ftrace_ret_stack {
         unsigned long ret;
         unsigned long func;
         unsigned long long calltime;
+        unsigned long long subtime;
+        unsigned long fp;
 };
 
 /*
@@ -378,9 +373,8 @@ struct ftrace_ret_stack {
 extern void return_to_handler(void);
 
 extern int
-ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth);
-extern void
-ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret);
+ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth,
+                         unsigned long frame_pointer);
 
 /*
  * Sometimes we don't want to trace a function with the function
@@ -496,8 +490,15 @@ static inline int test_tsk_trace_graph(struct task_struct *tsk)
 
 extern int ftrace_dump_on_oops;
 
+#ifdef CONFIG_PREEMPT
+#define INIT_TRACE_RECURSION            .trace_recursion = 0,
+#endif
+
 #endif /* CONFIG_TRACING */
 
+#ifndef INIT_TRACE_RECURSION
+#define INIT_TRACE_RECURSION
+#endif
 
 #ifdef CONFIG_HW_BRANCH_TRACER
 
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
new file mode 100644
index 000000000000..5c093ffc655b
--- /dev/null
+++ b/include/linux/ftrace_event.h
@@ -0,0 +1,172 @@
+#ifndef _LINUX_FTRACE_EVENT_H
+#define _LINUX_FTRACE_EVENT_H
+
+#include <linux/trace_seq.h>
+#include <linux/ring_buffer.h>
+#include <linux/percpu.h>
+
+struct trace_array;
+struct tracer;
+struct dentry;
+
+DECLARE_PER_CPU(struct trace_seq, ftrace_event_seq);
+
+struct trace_print_flags {
+        unsigned long           mask;
+        const char              *name;
+};
+
+const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
+                                   unsigned long flags,
+                                   const struct trace_print_flags *flag_array);
+
+const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
+                                     const struct trace_print_flags *symbol_array);
+
+/*
+ * The trace entry - the most basic unit of tracing. This is what
+ * is printed in the end as a single line in the trace output, such as:
+ *
+ *     bash-15816 [01]   235.197585: idle_cpu <- irq_enter
+ */
+struct trace_entry {
+        unsigned short          type;
+        unsigned char           flags;
+        unsigned char           preempt_count;
+        int                     pid;
+        int                     tgid;
+};
+
+#define FTRACE_MAX_EVENT                                                \
+        ((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)
+
+/*
+ * Trace iterator - used by printout routines who present trace
+ * results to users and which routines might sleep, etc:
+ */
+struct trace_iterator {
+        struct trace_array      *tr;
+        struct tracer           *trace;
+        void                    *private;
+        int                     cpu_file;
+        struct mutex            mutex;
+        struct ring_buffer_iter *buffer_iter[NR_CPUS];
+        unsigned long           iter_flags;
+
+        /* The below is zeroed out in pipe_read */
+        struct trace_seq        seq;
+        struct trace_entry      *ent;
+        int                     cpu;
+        u64                     ts;
+
+        loff_t                  pos;
+        long                    idx;
+
+        cpumask_var_t           started;
+};
+
+
+typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
+                                              int flags);
+struct trace_event {
+        struct hlist_node       node;
+        struct list_head        list;
+        int                     type;
+        trace_print_func        trace;
+        trace_print_func        raw;
+        trace_print_func        hex;
+        trace_print_func        binary;
+};
+
+extern int register_ftrace_event(struct trace_event *event);
+extern int unregister_ftrace_event(struct trace_event *event);
+
+/* Return values for print_line callback */
+enum print_line_t {
+        TRACE_TYPE_PARTIAL_LINE = 0,    /* Retry after flushing the seq */
+        TRACE_TYPE_HANDLED      = 1,
+        TRACE_TYPE_UNHANDLED    = 2,    /* Relay to other output functions */
+        TRACE_TYPE_NO_CONSUME   = 3     /* Handled but ask to not consume */
+};
+
+
+struct ring_buffer_event *
+trace_current_buffer_lock_reserve(int type, unsigned long len,
+                                  unsigned long flags, int pc);
+void trace_current_buffer_unlock_commit(struct ring_buffer_event *event,
+                                        unsigned long flags, int pc);
+void trace_nowake_buffer_unlock_commit(struct ring_buffer_event *event,
+                                        unsigned long flags, int pc);
+void trace_current_buffer_discard_commit(struct ring_buffer_event *event);
+
+void tracing_record_cmdline(struct task_struct *tsk);
+
+struct ftrace_event_call {
+        struct list_head        list;
+        char                    *name;
+        char                    *system;
+        struct dentry           *dir;
+        struct trace_event      *event;
+        int                     enabled;
+        int                     (*regfunc)(void);
+        void                    (*unregfunc)(void);
+        int                     id;
+        int                     (*raw_init)(void);
+        int                     (*show_format)(struct trace_seq *s);
+        int                     (*define_fields)(void);
+        struct list_head        fields;
+        int                     filter_active;
+        void                    *filter;
+        void                    *mod;
+
+#ifdef CONFIG_EVENT_PROFILE
+        atomic_t        profile_count;
+        int             (*profile_enable)(struct ftrace_event_call *);
+        void            (*profile_disable)(struct ftrace_event_call *);
+#endif
+};
+
+#define MAX_FILTER_PRED         32
+#define MAX_FILTER_STR_VAL      128
+
+extern int init_preds(struct ftrace_event_call *call);
+extern void destroy_preds(struct ftrace_event_call *call);
+extern int filter_match_preds(struct ftrace_event_call *call, void *rec);
+extern int filter_current_check_discard(struct ftrace_event_call *call,
+                                        void *rec,
+                                        struct ring_buffer_event *event);
+
+extern int trace_define_field(struct ftrace_event_call *call, char *type,
+                              char *name, int offset, int size, int is_signed);
+
+#define is_signed_type(type)    (((type)(-1)) < 0)
+
+int trace_set_clr_event(const char *system, const char *event, int set);
+
+/*
+ * The double __builtin_constant_p is because gcc will give us an error
+ * if we try to allocate the static variable to fmt if it is not a
+ * constant. Even with the outer if statement optimizing out.
+ */
+#define event_trace_printk(ip, fmt, args...)                            \
+do {                                                                    \
+        __trace_printk_check_format(fmt, ##args);                       \
+        tracing_record_cmdline(current);                                \
+        if (__builtin_constant_p(fmt)) {                                \
+                static const char *trace_printk_fmt                     \
+                  __attribute__((section("__trace_printk_fmt"))) =      \
+                        __builtin_constant_p(fmt) ? fmt : NULL;         \
+                                                                        \
+                __trace_bprintk(ip, trace_printk_fmt, ##args);          \
+        } else                                                          \
+                __trace_printk(ip, fmt, ##args);                        \
+} while (0)
+
+#define __common_field(type, item, is_signed)                           \
+        ret = trace_define_field(event_call, #type, "common_" #item,    \
+                                 offsetof(typeof(field.ent), item),     \
+                                 sizeof(field.ent.item), is_signed);    \
+        if (ret)                                                        \
+                return ret;
+
+#endif /* _LINUX_FTRACE_EVENT_H */
diff --git a/include/linux/fuse.h b/include/linux/fuse.h
index 162e5defe683..cf593bf9fd32 100644
--- a/include/linux/fuse.h
+++ b/include/linux/fuse.h
@@ -25,6 +25,11 @@
  *  - add IOCTL message
  *  - add unsolicited notification support
  *  - add POLL message and NOTIFY_POLL notification
+ *
+ * 7.12
+ *  - add umask flag to input argument of open, mknod and mkdir
+ *  - add notification messages for invalidation of inodes and
+ *    directory entries
  */
 
 #ifndef _LINUX_FUSE_H
@@ -36,7 +41,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 11
+#define FUSE_KERNEL_MINOR_VERSION 12
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -112,6 +117,7 @@ struct fuse_file_lock {
  * INIT request/reply flags
  *
  * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
+ * FUSE_DONT_MASK: don't apply umask to file mode on create operations
  */
 #define FUSE_ASYNC_READ         (1 << 0)
 #define FUSE_POSIX_LOCKS        (1 << 1)
@@ -119,6 +125,14 @@ struct fuse_file_lock {
 #define FUSE_ATOMIC_O_TRUNC     (1 << 3)
 #define FUSE_EXPORT_SUPPORT     (1 << 4)
 #define FUSE_BIG_WRITES         (1 << 5)
+#define FUSE_DONT_MASK          (1 << 6)
+
+/**
+ * CUSE INIT request/reply flags
+ *
+ * CUSE_UNRESTRICTED_IOCTL:  use unrestricted ioctl
+ */
+#define CUSE_UNRESTRICTED_IOCTL (1 << 0)
 
 /**
  * Release flags
@@ -210,10 +224,15 @@ enum fuse_opcode {
         FUSE_DESTROY       = 38,
         FUSE_IOCTL         = 39,
         FUSE_POLL          = 40,
+
+        /* CUSE specific operations */
+        CUSE_INIT          = 4096,
 };
 
 enum fuse_notify_code {
         FUSE_NOTIFY_POLL   = 1,
+        FUSE_NOTIFY_INVAL_INODE = 2,
+        FUSE_NOTIFY_INVAL_ENTRY = 3,
         FUSE_NOTIFY_CODE_MAX,
 };
 
@@ -252,14 +271,18 @@ struct fuse_attr_out {
         struct fuse_attr attr;
 };
 
+#define FUSE_COMPAT_MKNOD_IN_SIZE 8
+
 struct fuse_mknod_in {
         __u32   mode;
         __u32   rdev;
+        __u32   umask;
+        __u32   padding;
 };
 
 struct fuse_mkdir_in {
         __u32   mode;
-        __u32   padding;
+        __u32   umask;
 };
 
 struct fuse_rename_in {
@@ -291,7 +314,14 @@ struct fuse_setattr_in {
 
 struct fuse_open_in {
         __u32   flags;
+        __u32   unused;
+};
+
+struct fuse_create_in {
+        __u32   flags;
         __u32   mode;
+        __u32   umask;
+        __u32   padding;
 };
 
 struct fuse_open_out {
@@ -401,6 +431,27 @@ struct fuse_init_out {
         __u32   max_write;
 };
 
+#define CUSE_INIT_INFO_MAX 4096
+
+struct cuse_init_in {
+        __u32   major;
+        __u32   minor;
+        __u32   unused;
+        __u32   flags;
+};
+
+struct cuse_init_out {
+        __u32   major;
+        __u32   minor;
+        __u32   unused;
+        __u32   flags;
+        __u32   max_read;
+        __u32   max_write;
+        __u32   dev_major;              /* chardev major */
+        __u32   dev_minor;              /* chardev minor */
+        __u32   spare[10];
+};
+
 struct fuse_interrupt_in {
         __u64   unique;
 };
@@ -477,4 +528,16 @@ struct fuse_dirent {
 #define FUSE_DIRENT_SIZE(d) \
         FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
 
+struct fuse_notify_inval_inode_out {
+        __u64   ino;
+        __s64   off;
+        __s64   len;
+};
+
+struct fuse_notify_inval_entry_out {
+        __u64   parent;
+        __u32   namelen;
+        __u32   padding;
+};
+
 #endif /* _LINUX_FUSE_H */
diff --git a/include/linux/futex.h b/include/linux/futex.h
index 3bf5bb5a34f9..34956c8fdebf 100644
--- a/include/linux/futex.h
+++ b/include/linux/futex.h
@@ -23,6 +23,8 @@ union ktime;
 #define FUTEX_TRYLOCK_PI        8
 #define FUTEX_WAIT_BITSET       9
 #define FUTEX_WAKE_BITSET       10
+#define FUTEX_WAIT_REQUEUE_PI   11
+#define FUTEX_CMP_REQUEUE_PI    12
 
 #define FUTEX_PRIVATE_FLAG      128
 #define FUTEX_CLOCK_REALTIME    256
@@ -38,6 +40,10 @@ union ktime;
 #define FUTEX_TRYLOCK_PI_PRIVATE (FUTEX_TRYLOCK_PI | FUTEX_PRIVATE_FLAG)
 #define FUTEX_WAIT_BITSET_PRIVATE       (FUTEX_WAIT_BITS | FUTEX_PRIVATE_FLAG)
 #define FUTEX_WAKE_BITSET_PRIVATE       (FUTEX_WAKE_BITS | FUTEX_PRIVATE_FLAG)
+#define FUTEX_WAIT_REQUEUE_PI_PRIVATE   (FUTEX_WAIT_REQUEUE_PI | \
+                                         FUTEX_PRIVATE_FLAG)
+#define FUTEX_CMP_REQUEUE_PI_PRIVATE    (FUTEX_CMP_REQUEUE_PI | \
+                                         FUTEX_PRIVATE_FLAG)
 
 /*
  * Support for robust futexes: the kernel cleans up held futexes at
diff --git a/include/linux/gcd.h b/include/linux/gcd.h
new file mode 100644
index 000000000000..69f5e8a01bad
--- /dev/null
+++ b/include/linux/gcd.h
@@ -0,0 +1,8 @@
+#ifndef _GCD_H
+#define _GCD_H
+
+#include <linux/compiler.h>
+
+unsigned long gcd(unsigned long a, unsigned long b) __attribute_const__;
+
+#endif /* _GCD_H */
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index a1a28caed23d..45fc320a53c6 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -90,6 +90,7 @@ struct disk_stats {
 struct hd_struct {
         sector_t start_sect;
         sector_t nr_sects;
+        sector_t alignment_offset;
         struct device __dev;
         struct kobject *holder_dir;
         int policy, partno;
@@ -113,6 +114,7 @@ struct hd_struct {
 #define GENHD_FL_UP                             16
 #define GENHD_FL_SUPPRESS_PARTITION_INFO        32
 #define GENHD_FL_EXT_DEVT                       64 /* allow extended devt */
+#define GENHD_FL_NATIVE_CAPACITY                128
 
 #define BLK_SCSI_MAX_CMDS       (256)
 #define BLK_SCSI_CMD_PER_LONG   (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
@@ -140,7 +142,7 @@ struct gendisk {
                                          * disks that can't be partitioned. */
 
         char disk_name[DISK_NAME_LEN];  /* name of major driver */
-
+        char *(*nodename)(struct gendisk *gd);
         /* Array of pointers to partitions indexed by partno.
          * Protected with matching bdev lock but stat and other
          * non-critical accesses use RCU.  Always access through
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 0bbc15f54536..7c777a0da17a 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -5,6 +5,7 @@
 #include <linux/stddef.h>
 #include <linux/linkage.h>
 #include <linux/topology.h>
+#include <linux/mmdebug.h>
 
 struct vm_area_struct;
 
@@ -20,7 +21,8 @@ struct vm_area_struct;
 #define __GFP_DMA       ((__force gfp_t)0x01u)
 #define __GFP_HIGHMEM   ((__force gfp_t)0x02u)
 #define __GFP_DMA32     ((__force gfp_t)0x04u)
-
+#define __GFP_MOVABLE   ((__force gfp_t)0x08u)  /* Page is movable */
+#define GFP_ZONEMASK    (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
 /*
  * Action modifiers - doesn't change the zoning
  *
@@ -50,9 +52,20 @@ struct vm_area_struct;
 #define __GFP_HARDWALL   ((__force gfp_t)0x20000u) /* Enforce hardwall cpuset memory allocs */
 #define __GFP_THISNODE  ((__force gfp_t)0x40000u)/* No fallback, no policies */
 #define __GFP_RECLAIMABLE ((__force gfp_t)0x80000u) /* Page is reclaimable */
-#define __GFP_MOVABLE   ((__force gfp_t)0x100000u)  /* Page is movable */
 
-#define __GFP_BITS_SHIFT 21     /* Room for 21 __GFP_FOO bits */
+#ifdef CONFIG_KMEMCHECK
+#define __GFP_NOTRACK   ((__force gfp_t)0x200000u)  /* Don't track with kmemcheck */
+#else
+#define __GFP_NOTRACK   ((__force gfp_t)0)
+#endif
+
+/*
+ * This may seem redundant, but it's a way of annotating false positives vs.
+ * allocations that simply cannot be supported (e.g. page tables).
+ */
+#define __GFP_NOTRACK_FALSE_POSITIVE (__GFP_NOTRACK)
+
+#define __GFP_BITS_SHIFT 22     /* Room for 22 __GFP_FOO bits */
 #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
 
 /* This equals 0, but use constants in case they ever change */
@@ -85,6 +98,9 @@ struct vm_area_struct;
                         __GFP_NOWARN|__GFP_REPEAT|__GFP_NOFAIL|\
                         __GFP_NORETRY|__GFP_NOMEMALLOC)
 
+/* Control slab gfp mask during early boot */
+#define GFP_BOOT_MASK __GFP_BITS_MASK & ~(__GFP_WAIT|__GFP_IO|__GFP_FS)
+
 /* Control allocation constraints */
 #define GFP_CONSTRAINT_MASK (__GFP_HARDWALL|__GFP_THISNODE)
 
@@ -112,24 +128,105 @@ static inline int allocflags_to_migratetype(gfp_t gfp_flags)
                 ((gfp_flags & __GFP_RECLAIMABLE) != 0);
 }
 
-static inline enum zone_type gfp_zone(gfp_t flags)
-{
+#ifdef CONFIG_HIGHMEM
+#define OPT_ZONE_HIGHMEM ZONE_HIGHMEM
+#else
+#define OPT_ZONE_HIGHMEM ZONE_NORMAL
+#endif
+
 #ifdef CONFIG_ZONE_DMA
-        if (flags & __GFP_DMA)
-                return ZONE_DMA;
+#define OPT_ZONE_DMA ZONE_DMA
+#else
+#define OPT_ZONE_DMA ZONE_NORMAL
 #endif
+
 #ifdef CONFIG_ZONE_DMA32
-        if (flags & __GFP_DMA32)
-                return ZONE_DMA32;
+#define OPT_ZONE_DMA32 ZONE_DMA32
+#else
+#define OPT_ZONE_DMA32 ZONE_NORMAL
 #endif
-        if ((flags & (__GFP_HIGHMEM | __GFP_MOVABLE)) ==
-                        (__GFP_HIGHMEM | __GFP_MOVABLE))
-                return ZONE_MOVABLE;
-#ifdef CONFIG_HIGHMEM
-        if (flags & __GFP_HIGHMEM)
-                return ZONE_HIGHMEM;
+
+/*
+ * GFP_ZONE_TABLE is a word size bitstring that is used for looking up the
+ * zone to use given the lowest 4 bits of gfp_t. Entries are ZONE_SHIFT long
+ * and there are 16 of them to cover all possible combinations of
+ * __GFP_DMA, __GFP_DMA32, __GFP_MOVABLE and __GFP_HIGHMEM
+ *
+ * The zone fallback order is MOVABLE=>HIGHMEM=>NORMAL=>DMA32=>DMA.
+ * But GFP_MOVABLE is not only a zone specifier but also an allocation
+ * policy. Therefore __GFP_MOVABLE plus another zone selector is valid.
+ * Only 1bit of the lowest 3 bit (DMA,DMA32,HIGHMEM) can be set to "1".
+ *
+ *       bit       result
+ *       =================
+ *       0x0    => NORMAL
+ *       0x1    => DMA or NORMAL
+ *       0x2    => HIGHMEM or NORMAL
+ *       0x3    => BAD (DMA+HIGHMEM)
+ *       0x4    => DMA32 or DMA or NORMAL
+ *       0x5    => BAD (DMA+DMA32)
+ *       0x6    => BAD (HIGHMEM+DMA32)
+ *       0x7    => BAD (HIGHMEM+DMA32+DMA)
+ *       0x8    => NORMAL (MOVABLE+0)
+ *       0x9    => DMA or NORMAL (MOVABLE+DMA)
+ *       0xa    => MOVABLE (Movable is valid only if HIGHMEM is set too)
+ *       0xb    => BAD (MOVABLE+HIGHMEM+DMA)
+ *       0xc    => DMA32 (MOVABLE+HIGHMEM+DMA32)
+ *       0xd    => BAD (MOVABLE+DMA32+DMA)
+ *       0xe    => BAD (MOVABLE+DMA32+HIGHMEM)
+ *       0xf    => BAD (MOVABLE+DMA32+HIGHMEM+DMA)
+ *
+ * ZONES_SHIFT must be <= 2 on 32 bit platforms.
+ */
+
+#if 16 * ZONES_SHIFT > BITS_PER_LONG
+#error ZONES_SHIFT too large to create GFP_ZONE_TABLE integer
 #endif
-        return ZONE_NORMAL;
+
+#define GFP_ZONE_TABLE ( \
+        (ZONE_NORMAL << 0 * ZONES_SHIFT)                                \
+        | (OPT_ZONE_DMA << __GFP_DMA * ZONES_SHIFT)                     \
+        | (OPT_ZONE_HIGHMEM << __GFP_HIGHMEM * ZONES_SHIFT)             \
+        | (OPT_ZONE_DMA32 << __GFP_DMA32 * ZONES_SHIFT)                 \
+        | (ZONE_NORMAL << __GFP_MOVABLE * ZONES_SHIFT)                  \
+        | (OPT_ZONE_DMA << (__GFP_MOVABLE | __GFP_DMA) * ZONES_SHIFT)   \
+        | (ZONE_MOVABLE << (__GFP_MOVABLE | __GFP_HIGHMEM) * ZONES_SHIFT)\
+        | (OPT_ZONE_DMA32 << (__GFP_MOVABLE | __GFP_DMA32) * ZONES_SHIFT)\
+)
+
+/*
+ * GFP_ZONE_BAD is a bitmap for all combination of __GFP_DMA, __GFP_DMA32
+ * __GFP_HIGHMEM and __GFP_MOVABLE that are not permitted. One flag per
+ * entry starting with bit 0. Bit is set if the combination is not
+ * allowed.
+ */
+#define GFP_ZONE_BAD ( \
+        1 << (__GFP_DMA | __GFP_HIGHMEM)                                \
+        | 1 << (__GFP_DMA | __GFP_DMA32)                                \
+        | 1 << (__GFP_DMA32 | __GFP_HIGHMEM)                            \
+        | 1 << (__GFP_DMA | __GFP_DMA32 | __GFP_HIGHMEM)                \
+        | 1 << (__GFP_MOVABLE | __GFP_HIGHMEM | __GFP_DMA)              \
+        | 1 << (__GFP_MOVABLE | __GFP_DMA32 | __GFP_DMA)                \
+        | 1 << (__GFP_MOVABLE | __GFP_DMA32 | __GFP_HIGHMEM)            \
+        | 1 << (__GFP_MOVABLE | __GFP_DMA32 | __GFP_DMA | __GFP_HIGHMEM)\
+)
+
+static inline enum zone_type gfp_zone(gfp_t flags)
+{
+        enum zone_type z;
+        int bit = flags & GFP_ZONEMASK;
+
+        z = (GFP_ZONE_TABLE >> (bit * ZONES_SHIFT)) &
+                                         ((1 << ZONES_SHIFT) - 1);
+
+        if (__builtin_constant_p(bit))
+                BUILD_BUG_ON((GFP_ZONE_BAD >> bit) & 1);
+        else {
+#ifdef CONFIG_DEBUG_VM
+                BUG_ON((GFP_ZONE_BAD >> bit) & 1);
+#endif
+        }
+        return z;
 }
 
 /*
@@ -169,30 +266,19 @@ static inline void arch_alloc_page(struct page *page, int order) { }
 #endif
 
 struct page *
-__alloc_pages_internal(gfp_t gfp_mask, unsigned int order,
+__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
                        struct zonelist *zonelist, nodemask_t *nodemask);
 
 static inline struct page *
 __alloc_pages(gfp_t gfp_mask, unsigned int order,
                 struct zonelist *zonelist)
 {
-        return __alloc_pages_internal(gfp_mask, order, zonelist, NULL);
+        return __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);
 }
 
-static inline struct page *
-__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
-                struct zonelist *zonelist, nodemask_t *nodemask)
-{
-        return __alloc_pages_internal(gfp_mask, order, zonelist, nodemask);
-}
-
-
 static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
                                                 unsigned int order)
 {
-        if (unlikely(order >= MAX_ORDER))
-                return NULL;
-
         /* Unknown node is current node */
         if (nid < 0)
                 nid = numa_node_id();
@@ -200,15 +286,20 @@ static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
         return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
 }
 
+static inline struct page *alloc_pages_exact_node(int nid, gfp_t gfp_mask,
+                                                unsigned int order)
+{
+        VM_BUG_ON(nid < 0 || nid >= MAX_NUMNODES);
+
+        return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
+}
+
 #ifdef CONFIG_NUMA
 extern struct page *alloc_pages_current(gfp_t gfp_mask, unsigned order);
 
 static inline struct page *
 alloc_pages(gfp_t gfp_mask, unsigned int order)
 {
-        if (unlikely(order >= MAX_ORDER))
-                return NULL;
-
         return alloc_pages_current(gfp_mask, order);
 }
 extern struct page *alloc_page_vma(gfp_t gfp_mask,
@@ -245,4 +336,23 @@ void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
 void drain_all_pages(void);
 void drain_local_pages(void *dummy);
 
+extern bool oom_killer_disabled;
+
+static inline void oom_killer_disable(void)
+{
+        oom_killer_disabled = true;
+}
+
+static inline void oom_killer_enable(void)
+{
+        oom_killer_disabled = false;
+}
+
+extern gfp_t gfp_allowed_mask;
+
+static inline void set_gfp_allowed_mask(gfp_t mask)
+{
+        gfp_allowed_mask = mask;
+}
+
 #endif /* __LINUX_GFP_H */
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 45257475623c..8246c697863d 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -2,7 +2,9 @@
 #define LINUX_HARDIRQ_H
 
 #include <linux/preempt.h>
+#ifdef CONFIG_PREEMPT
 #include <linux/smp_lock.h>
+#endif
 #include <linux/lockdep.h>
 #include <linux/ftrace_irq.h>
 #include <asm/hardirq.h>
diff --git a/include/linux/hid.h b/include/linux/hid.h
index a72876e43589..53489fd4d700 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -238,6 +238,42 @@ struct hid_item {
 #define HID_GD_RIGHT            0x00010092
 #define HID_GD_LEFT             0x00010093
 
+#define HID_DG_DIGITIZER        0x000d0001
+#define HID_DG_PEN              0x000d0002
+#define HID_DG_LIGHTPEN         0x000d0003
+#define HID_DG_TOUCHSCREEN      0x000d0004
+#define HID_DG_TOUCHPAD         0x000d0005
+#define HID_DG_STYLUS           0x000d0020
+#define HID_DG_PUCK             0x000d0021
+#define HID_DG_FINGER           0x000d0022
+#define HID_DG_TIPPRESSURE      0x000d0030
+#define HID_DG_BARRELPRESSURE   0x000d0031
+#define HID_DG_INRANGE          0x000d0032
+#define HID_DG_TOUCH            0x000d0033
+#define HID_DG_UNTOUCH          0x000d0034
+#define HID_DG_TAP              0x000d0035
+#define HID_DG_TABLETFUNCTIONKEY        0x000d0039
+#define HID_DG_PROGRAMCHANGEKEY 0x000d003a
+#define HID_DG_INVERT           0x000d003c
+#define HID_DG_TIPSWITCH        0x000d0042
+#define HID_DG_TIPSWITCH2       0x000d0043
+#define HID_DG_BARRELSWITCH     0x000d0044
+#define HID_DG_ERASER           0x000d0045
+#define HID_DG_TABLETPICK       0x000d0046
+/*
+ * as of May 20, 2009 the usages below are not yet in the official USB spec
+ * but are being pushed by Microsft as described in their paper "Digitizer
+ * Drivers for Windows Touch and Pen-Based Computers"
+ */
+#define HID_DG_CONFIDENCE       0x000d0047
+#define HID_DG_WIDTH            0x000d0048
+#define HID_DG_HEIGHT           0x000d0049
+#define HID_DG_CONTACTID        0x000d0051
+#define HID_DG_INPUTMODE        0x000d0052
+#define HID_DG_DEVICEINDEX      0x000d0053
+#define HID_DG_CONTACTCOUNT     0x000d0054
+#define HID_DG_CONTACTMAX       0x000d0055
+
 /*
  * HID report types --- Ouch! HID spec says 1 2 3!
  */
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 1fcb7126a01f..211ff4497269 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -55,7 +55,9 @@ static inline void *kmap(struct page *page)
         return page_address(page);
 }
 
-#define kunmap(page) do { (void) (page); } while (0)
+static inline void kunmap(struct page *page)
+{
+}
 
 static inline void *kmap_atomic(struct page *page, enum km_type idx)
 {
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 0d2f7c8a33d6..4759917adc71 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -21,6 +21,7 @@
 #include <linux/list.h>
 #include <linux/wait.h>
 #include <linux/percpu.h>
+#include <linux/timer.h>
 
 
 struct hrtimer_clock_base;
@@ -30,8 +31,11 @@ struct hrtimer_cpu_base;
  * Mode arguments of xxx_hrtimer functions:
  */
 enum hrtimer_mode {
-        HRTIMER_MODE_ABS,       /* Time value is absolute */
-        HRTIMER_MODE_REL,       /* Time value is relative to now */
+        HRTIMER_MODE_ABS = 0x0,         /* Time value is absolute */
+        HRTIMER_MODE_REL = 0x1,         /* Time value is relative to now */
+        HRTIMER_MODE_PINNED = 0x02,     /* Timer is bound to CPU */
+        HRTIMER_MODE_ABS_PINNED = 0x02,
+        HRTIMER_MODE_REL_PINNED = 0x03,
 };
 
 /*
@@ -444,6 +448,8 @@ extern void timer_stats_update_stats(void *timer, pid_t pid, void *startf,
 
 static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
 {
+        if (likely(!timer->start_site))
+                return;
         timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
                                  timer->function, timer->start_comm, 0);
 }
@@ -453,6 +459,8 @@ extern void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer,
 
 static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
 {
+        if (likely(!timer_stats_active))
+                return;
         __timer_stats_hrtimer_set_start_info(timer, __builtin_return_address(0));
 }
 
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 03be7f29ca01..2723513a5651 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -11,6 +11,8 @@
 
 struct ctl_table;
 
+int PageHuge(struct page *page);
+
 static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
 {
         return vma->vm_flags & VM_HUGETLB;
@@ -31,7 +33,7 @@ void hugetlb_report_meminfo(struct seq_file *);
 int hugetlb_report_node_meminfo(int, char *);
 unsigned long hugetlb_total_pages(void);
 int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
-                        unsigned long address, int write_access);
+                        unsigned long address, unsigned int flags);
 int hugetlb_reserve_pages(struct inode *inode, long from, long to,
                                                 struct vm_area_struct *vma,
                                                 int acctflags);
@@ -61,6 +63,11 @@ void hugetlb_change_protection(struct vm_area_struct *vma,
 
 #else /* !CONFIG_HUGETLB_PAGE */
 
+static inline int PageHuge(struct page *page)
+{
+        return 0;
+}
+
 static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
 {
         return 0;
@@ -91,7 +98,7 @@ static inline void hugetlb_report_meminfo(struct seq_file *m)
 #define pud_huge(x)     0
 #define is_hugepage_only_range(mm, addr, len)   0
 #define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) ({BUG(); 0; })
-#define hugetlb_fault(mm, vma, addr, write)     ({ BUG(); 0; })
+#define hugetlb_fault(mm, vma, addr, flags)     ({ BUG(); 0; })
 
 #define hugetlb_change_protection(vma, address, end, newprot)
 
diff --git a/include/linux/i2c-ocores.h b/include/linux/i2c-ocores.h
index 8ed591b0887e..4d5e57ff6614 100644
--- a/include/linux/i2c-ocores.h
+++ b/include/linux/i2c-ocores.h
@@ -14,6 +14,8 @@
 struct ocores_i2c_platform_data {
         u32 regstep;   /* distance between registers */
         u32 clock_khz; /* input clock in kHz */
+        u8 num_devices; /* number of devices in the devices list */
+        struct i2c_board_info const *devices; /* devices connected to the bus */
 };
 
 #endif /* _LINUX_I2C_OCORES_H */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index ad2580596033..f4784c0fe975 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -47,6 +47,7 @@ struct i2c_driver;
 union i2c_smbus_data;
 struct i2c_board_info;
 
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 /*
  * The master routines are the ones normally used to transmit data to devices
  * on a bus (or read from them). Apart from two basic transfer functions to
@@ -93,6 +94,7 @@ extern s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client,
 extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
                                           u8 command, u8 length,
                                           const u8 *values);
+#endif /* I2C */
 
 /**
  * struct i2c_driver - represent an I2C device driver
@@ -100,9 +102,8 @@ extern s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client,
  * @class: What kind of i2c device we instantiate (for detect)
  * @attach_adapter: Callback for bus addition (for legacy drivers)
  * @detach_adapter: Callback for bus removal (for legacy drivers)
- * @detach_client: Callback for device removal (for legacy drivers)
- * @probe: Callback for device binding (new-style drivers)
- * @remove: Callback for device unbinding (new-style drivers)
+ * @probe: Callback for device binding
+ * @remove: Callback for device unbinding
  * @shutdown: Callback for device shutdown
  * @suspend: Callback for device suspend
  * @resume: Callback for device resume
@@ -137,26 +138,14 @@ struct i2c_driver {
         int id;
         unsigned int class;
 
-        /* Notifies the driver that a new bus has appeared. This routine
-         * can be used by the driver to test if the bus meets its conditions
-         * & seek for the presence of the chip(s) it supports. If found, it
-         * registers the client(s) that are on the bus to the i2c admin. via
-         * i2c_attach_client.  (LEGACY I2C DRIVERS ONLY)
+        /* Notifies the driver that a new bus has appeared or is about to be
+         * removed. You should avoid using this if you can, it will probably
+         * be removed in a near future.
          */
         int (*attach_adapter)(struct i2c_adapter *);
         int (*detach_adapter)(struct i2c_adapter *);
 
-        /* tells the driver that a client is about to be deleted & gives it
-         * the chance to remove its private data. Also, if the client struct
-         * has been dynamically allocated by the driver in the function above,
-         * it must be freed here.  (LEGACY I2C DRIVERS ONLY)
-         */
-        int (*detach_client)(struct i2c_client *) __deprecated;
-
-        /* Standard driver model interfaces, for "new style" i2c drivers.
-         * With the driver model, device enumeration is NEVER done by drivers;
-         * it's done by infrastructure.  (NEW STYLE DRIVERS ONLY)
-         */
+        /* Standard driver model interfaces */
         int (*probe)(struct i2c_client *, const struct i2c_device_id *);
         int (*remove)(struct i2c_client *);
 
@@ -191,9 +180,8 @@ struct i2c_driver {
  * @driver: device's driver, hence pointer to access routines
  * @dev: Driver model device node for the slave.
  * @irq: indicates the IRQ generated by this device (if any)
- * @list: list of active/busy clients (DEPRECATED)
- * @detected: member of an i2c_driver.clients list
- * @released: used to synchronize client releases & detaches and references
+ * @detected: member of an i2c_driver.clients list or i2c-core's
+ *      userspace_devices list
  *
  * An i2c_client identifies a single device (i.e. chip) connected to an
  * i2c bus. The behaviour exposed to Linux is defined by the driver
@@ -209,9 +197,7 @@ struct i2c_client {
         struct i2c_driver *driver;      /* and our access routines      */
         struct device dev;              /* the device structure         */
         int irq;                        /* irq issued by device         */
-        struct list_head list;          /* DEPRECATED */
         struct list_head detected;
-        struct completion released;
 };
 #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
 
@@ -248,11 +234,10 @@ static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
  * that, such as chip type, configuration, associated IRQ, and so on.
  *
  * i2c_board_info is used to build tables of information listing I2C devices
- * that are present.  This information is used to grow the driver model tree
- * for "new style" I2C drivers.  For mainboards this is done statically using
- * i2c_register_board_info(); bus numbers identify adapters that aren't
- * yet available.  For add-on boards, i2c_new_device() does this dynamically
- * with the adapter already known.
+ * that are present.  This information is used to grow the driver model tree.
+ * For mainboards this is done statically using i2c_register_board_info();
+ * bus numbers identify adapters that aren't yet available.  For add-on boards,
+ * i2c_new_device() does this dynamically with the adapter already known.
  */
 struct i2c_board_info {
         char            type[I2C_NAME_SIZE];
@@ -277,6 +262,7 @@ struct i2c_board_info {
         .type = dev_type, .addr = (dev_addr)
 
 
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 /* Add-on boards should register/unregister their devices; e.g. a board
  * with integrated I2C, a config eeprom, sensors, and a codec that's
  * used in conjunction with the primary hardware.
@@ -300,6 +286,7 @@ extern struct i2c_client *
 i2c_new_dummy(struct i2c_adapter *adap, u16 address);
 
 extern void i2c_unregister_device(struct i2c_client *);
+#endif /* I2C */
 
 /* Mainboard arch_initcall() code should register all its I2C devices.
  * This is done at arch_initcall time, before declaring any i2c adapters.
@@ -316,7 +303,7 @@ i2c_register_board_info(int busnum, struct i2c_board_info const *info,
 {
         return 0;
 }
-#endif
+#endif /* I2C_BOARDINFO */
 
 /*
  * The following structs are for those who like to implement new bus drivers:
@@ -352,21 +339,15 @@ struct i2c_adapter {
         const struct i2c_algorithm *algo; /* the algorithm to access the bus */
         void *algo_data;
 
-        /* --- administration stuff. */
-        int (*client_register)(struct i2c_client *) __deprecated;
-        int (*client_unregister)(struct i2c_client *) __deprecated;
-
         /* data fields that are valid for all devices   */
         u8 level;                       /* nesting level for lockdep */
         struct mutex bus_lock;
-        struct mutex clist_lock;
 
         int timeout;                    /* in jiffies */
         int retries;
         struct device dev;              /* the adapter device */
 
         int nr;
-        struct list_head clients;       /* DEPRECATED */
         char name[48];
         struct completion dev_released;
 };
@@ -412,11 +393,16 @@ struct i2c_client_address_data {
 /* The numbers to use to set I2C bus address */
 #define ANY_I2C_BUS             0xffff
 
+/* Construct an I2C_CLIENT_END-terminated array of i2c addresses */
+#define I2C_ADDRS(addr, addrs...) \
+        ((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END })
+
 
 /* ----- functions exported by i2c.o */
 
 /* administration...
  */
+#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 extern int i2c_add_adapter(struct i2c_adapter *);
 extern int i2c_del_adapter(struct i2c_adapter *);
 extern int i2c_add_numbered_adapter(struct i2c_adapter *);
@@ -429,11 +415,6 @@ static inline int i2c_add_driver(struct i2c_driver *driver)
         return i2c_register_driver(THIS_MODULE, driver);
 }
 
-/* These are deprecated, your driver should use the standard .probe()
- * and .remove() methods instead. */
-extern int __deprecated i2c_attach_client(struct i2c_client *);
-extern int __deprecated i2c_detach_client(struct i2c_client *);
-
 extern struct i2c_client *i2c_use_client(struct i2c_client *client);
 extern void i2c_release_client(struct i2c_client *client);
 
@@ -442,14 +423,6 @@ extern void i2c_release_client(struct i2c_client *client);
 extern void i2c_clients_command(struct i2c_adapter *adap,
                                 unsigned int cmd, void *arg);
 
-/* Detect function. It iterates over all possible addresses itself.
- * It will only call found_proc if some client is connected at the
- * specific address (unless a 'force' matched);
- */
-extern int i2c_probe(struct i2c_adapter *adapter,
-                const struct i2c_client_address_data *address_data,
-                int (*found_proc) (struct i2c_adapter *, int, int));
-
 extern struct i2c_adapter *i2c_get_adapter(int id);
 extern void i2c_put_adapter(struct i2c_adapter *adap);
 
@@ -471,6 +444,7 @@ static inline int i2c_adapter_id(struct i2c_adapter *adap)
 {
         return adap->nr;
 }
+#endif /* I2C */
 #endif /* __KERNEL__ */
 
 /**
diff --git a/include/linux/i2c/pca953x.h b/include/linux/i2c/pca953x.h
index 3c7361217df8..81736d6a8db7 100644
--- a/include/linux/i2c/pca953x.h
+++ b/include/linux/i2c/pca953x.h
@@ -15,4 +15,5 @@ struct pca953x_platform_data {
         int             (*teardown)(struct i2c_client *client,
                                 unsigned gpio, unsigned ngpio,
                                 void *context);
+        char            **names;
 };
diff --git a/include/linux/icmpv6.h b/include/linux/icmpv6.h
index 10d701eec484..b6a85183c333 100644
--- a/include/linux/icmpv6.h
+++ b/include/linux/icmpv6.h
@@ -175,16 +175,16 @@ struct icmp6_filter {
 
 
 extern void                             icmpv6_send(struct sk_buff *skb,
-                                                    int type, int code,
+                                                    u8 type, u8 code,
                                                     __u32 info, 
                                                     struct net_device *dev);
 
 extern int                              icmpv6_init(void);
-extern int                              icmpv6_err_convert(int type, int code,
+extern int                              icmpv6_err_convert(u8 type, u8 code,
                                                            int *err);
 extern void                             icmpv6_cleanup(void);
 extern void                             icmpv6_param_prob(struct sk_buff *skb,
-                                                          int code, int pos);
+                                                          u8 code, int pos);
 
 struct flowi;
 struct in6_addr;
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 9fed365a598b..edc93a6d931d 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -26,6 +26,9 @@
 #include <asm/io.h>
 #include <asm/mutex.h>
 
+/* for request_sense */
+#include <linux/cdrom.h>
+
 #if defined(CONFIG_CRIS) || defined(CONFIG_FRV) || defined(CONFIG_MN10300)
 # define SUPPORT_VLB_SYNC 0
 #else
@@ -154,12 +157,6 @@ enum {
 #define REQ_UNPARK_HEADS        0x23
 
 /*
- * Check for an interrupt and acknowledge the interrupt status
- */
-struct hwif_s;
-typedef int (ide_ack_intr_t)(struct hwif_s *);
-
-/*
  * hwif_chipset_t is used to keep track of the specific hardware
  * chipset used by each IDE interface, if known.
  */
@@ -175,20 +172,18 @@ typedef u8 hwif_chipset_t;
 /*
  * Structure to hold all information about the location of this port
  */
-typedef struct hw_regs_s {
+struct ide_hw {
         union {
                 struct ide_io_ports     io_ports;
                 unsigned long           io_ports_array[IDE_NR_PORTS];
         };
 
         int             irq;                    /* our irq number */
-        ide_ack_intr_t  *ack_intr;              /* acknowledge interrupt */
-        hwif_chipset_t  chipset;
         struct device   *dev, *parent;
         unsigned long   config;
-} hw_regs_t;
+};
 
-static inline void ide_std_init_ports(hw_regs_t *hw,
+static inline void ide_std_init_ports(struct ide_hw *hw,
                                       unsigned long io_addr,
                                       unsigned long ctl_addr)
 {
@@ -215,21 +210,12 @@ static inline void ide_std_init_ports(hw_regs_t *hw,
 
 /*
  * Special Driver Flags
- *
- * set_geometry : respecify drive geometry
- * recalibrate  : seek to cyl 0
- * set_multmode : set multmode count
- * reserved     : unused
  */
-typedef union {
-        unsigned all                    : 8;
-        struct {
-                unsigned set_geometry   : 1;
-                unsigned recalibrate    : 1;
-                unsigned set_multmode   : 1;
-                unsigned reserved       : 5;
-        } b;
-} special_t;
+enum {
+        IDE_SFLAG_SET_GEOMETRY          = (1 << 0),
+        IDE_SFLAG_RECALIBRATE           = (1 << 1),
+        IDE_SFLAG_SET_MULTMODE          = (1 << 2),
+};
 
 /*
  * Status returned from various ide_ functions
@@ -324,7 +310,6 @@ struct ide_cmd {
         unsigned int            cursg_ofs;
 
         struct request          *rq;            /* copy of request */
-        void                    *special;       /* valid_t generally */
 };
 
 /* ATAPI packet command flags */
@@ -339,11 +324,6 @@ enum {
         PC_FLAG_WRITING                 = (1 << 6),
 };
 
-/*
- * With each packet command, we allocate a buffer of IDE_PC_BUFFER_SIZE bytes.
- * This is used for several packet commands (not for READ/WRITE commands).
- */
-#define IDE_PC_BUFFER_SIZE      64
 #define ATAPI_WAIT_PC           (60 * HZ)
 
 struct ide_atapi_pc {
@@ -355,16 +335,6 @@ struct ide_atapi_pc {
 
         /* bytes to transfer */
         int req_xfer;
-        /* bytes actually transferred */
-        int xferred;
-
-        /* data buffer */
-        u8 *buf;
-        /* current buffer position */
-        u8 *cur_pos;
-        int buf_size;
-        /* missing/available data on the current buffer */
-        int b_count;
 
         /* the corresponding request */
         struct request *rq;
@@ -375,12 +345,6 @@ struct ide_atapi_pc {
          * those are more or less driver-specific and some of them are subject
          * to change/removal later.
          */
-        u8 pc_buf[IDE_PC_BUFFER_SIZE];
-
-        /* idetape only */
-        struct idetape_bh *bh;
-        char *b_data;
-
         unsigned long timeout;
 };
 
@@ -397,6 +361,7 @@ struct ide_drive_s;
 struct ide_disk_ops {
         int             (*check)(struct ide_drive_s *, const char *);
         int             (*get_capacity)(struct ide_drive_s *);
+        u64             (*set_capacity)(struct ide_drive_s *, u64);
         void            (*setup)(struct ide_drive_s *);
         void            (*flush)(struct ide_drive_s *);
         int             (*init_media)(struct ide_drive_s *, struct gendisk *);
@@ -474,6 +439,8 @@ enum {
         IDE_DFLAG_NICE1                 = (1 << 5),
         /* device is physically present */
         IDE_DFLAG_PRESENT               = (1 << 6),
+        /* disable Host Protected Area */
+        IDE_DFLAG_NOHPA                 = (1 << 7),
         /* id read from device (synthetic if not set) */
         IDE_DFLAG_ID_READ               = (1 << 8),
         IDE_DFLAG_NOPROBE               = (1 << 9),
@@ -512,6 +479,7 @@ enum {
         /* write protect */
         IDE_DFLAG_WP                    = (1 << 29),
         IDE_DFLAG_FORMAT_IN_PROGRESS    = (1 << 30),
+        IDE_DFLAG_NIEN_QUIRK            = (1 << 31),
 };
 
 struct ide_drive_s {
@@ -536,14 +504,13 @@ struct ide_drive_s {
         unsigned long sleep;            /* sleep until this time */
         unsigned long timeout;          /* max time to wait for irq */
 
-        special_t       special;        /* special action flags */
+        u8      special_flags;          /* special action flags */
 
         u8      select;                 /* basic drive/head select reg value */
         u8      retry_pio;              /* retrying dma capable host in pio */
         u8      waiting_for_dma;        /* dma currently in progress */
         u8      dma;                    /* atapi dma flag */
 
-        u8      quirk_list;     /* considered quirky, set for a specific host */
         u8      init_speed;     /* transfer rate set at boot */
         u8      current_speed;  /* current transfer rate set */
         u8      desired_speed;  /* desired transfer rate set */
@@ -565,11 +532,10 @@ struct ide_drive_s {
 
         unsigned int    bios_cyl;       /* BIOS/fdisk/LILO number of cyls */
         unsigned int    cyl;            /* "real" number of cyls */
-        unsigned int    drive_data;     /* used by set_pio_mode/dev_select() */
+        void            *drive_data;    /* used by set_pio_mode/dev_select() */
         unsigned int    failures;       /* current failure count */
         unsigned int    max_failures;   /* maximum allowed failure count */
-        u64             probed_capacity;/* initial reported media capacity (ide-cd only currently) */
-
+        u64             probed_capacity;/* initial/native media capacity */
         u64             capacity64;     /* total number of sectors */
 
         int             lun;            /* logical unit */
@@ -593,16 +559,16 @@ struct ide_drive_s {
         /* callback for packet commands */
         int  (*pc_callback)(struct ide_drive_s *, int);
 
-        void (*pc_update_buffers)(struct ide_drive_s *, struct ide_atapi_pc *);
-        int  (*pc_io_buffers)(struct ide_drive_s *, struct ide_atapi_pc *,
-                              unsigned int, int);
-
         ide_startstop_t (*irq_handler)(struct ide_drive_s *);
 
         unsigned long atapi_flags;
 
         struct ide_atapi_pc request_sense_pc;
-        struct request request_sense_rq;
+
+        /* current sense rq and buffer */
+        bool sense_rq_armed;
+        struct request sense_rq;
+        struct request_sense sense_data;
 };
 
 typedef struct ide_drive_s ide_drive_t;
@@ -663,6 +629,7 @@ struct ide_port_ops {
         void    (*maskproc)(ide_drive_t *, int);
         void    (*quirkproc)(ide_drive_t *);
         void    (*clear_irq)(ide_drive_t *);
+        int     (*test_irq)(struct hwif_s *);
 
         u8      (*mdma_filter)(ide_drive_t *);
         u8      (*udma_filter)(ide_drive_t *);
@@ -688,6 +655,10 @@ struct ide_dma_ops {
         u8      (*dma_sff_read_status)(struct hwif_s *);
 };
 
+enum {
+        IDE_PFLAG_PROBING               = (1 << 0),
+};
+
 struct ide_host;
 
 typedef struct hwif_s {
@@ -704,6 +675,8 @@ typedef struct hwif_s {
 
         ide_drive_t     *devices[MAX_DRIVES + 1];
 
+        unsigned long   port_flags;
+
         u8 major;       /* our major number */
         u8 index;       /* 0 for ide0; 1 for ide1; ... */
         u8 channel;     /* for dual-port chips: 0=primary, 1=secondary */
@@ -722,8 +695,6 @@ typedef struct hwif_s {
 
         struct device *dev;
 
-        ide_ack_intr_t *ack_intr;
-
         void (*rw_disk)(ide_drive_t *, struct request *);
 
         const struct ide_tp_ops         *tp_ops;
@@ -1091,7 +1062,6 @@ int generic_ide_ioctl(ide_drive_t *, struct block_device *, unsigned, unsigned l
 extern int ide_vlb_clk;
 extern int ide_pci_clk;
 
-unsigned int ide_rq_bytes(struct request *);
 int ide_end_rq(ide_drive_t *, struct request *, int, unsigned int);
 void ide_kill_rq(ide_drive_t *, struct request *);
 
@@ -1144,6 +1114,8 @@ void SELECT_MASK(ide_drive_t *, int);
 u8 ide_read_error(ide_drive_t *);
 void ide_read_bcount_and_ireason(ide_drive_t *, u16 *, u8 *);
 
+int ide_check_ireason(ide_drive_t *, struct request *, int, int, int);
+
 int ide_check_atapi_device(ide_drive_t *, const char *);
 
 void ide_init_pc(struct ide_atapi_pc *);
@@ -1168,13 +1140,17 @@ enum {
         REQ_IDETAPE_WRITE       = (1 << 3),
 };
 
-int ide_queue_pc_tail(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *);
+int ide_queue_pc_tail(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *,
+                      void *, unsigned int);
 
 int ide_do_test_unit_ready(ide_drive_t *, struct gendisk *);
 int ide_do_start_stop(ide_drive_t *, struct gendisk *, int);
 int ide_set_media_lock(ide_drive_t *, struct gendisk *, int);
 void ide_create_request_sense_cmd(ide_drive_t *, struct ide_atapi_pc *);
-void ide_retry_pc(ide_drive_t *, struct gendisk *);
+void ide_retry_pc(ide_drive_t *drive);
+
+void ide_prep_sense(ide_drive_t *drive, struct request *rq);
+int ide_queue_sense_rq(ide_drive_t *drive, void *special);
 
 int ide_cd_expiry(ide_drive_t *);
 
@@ -1225,7 +1201,7 @@ static inline int ide_pci_is_in_compatibility_mode(struct pci_dev *dev)
 }
 
 void ide_pci_setup_ports(struct pci_dev *, const struct ide_port_info *,
-                         hw_regs_t *, hw_regs_t **);
+                         struct ide_hw *, struct ide_hw **);
 void ide_setup_pci_noise(struct pci_dev *, const struct ide_port_info *);
 
 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
@@ -1384,7 +1360,6 @@ int ide_in_drive_list(u16 *, const struct drive_list_entry *);
 #ifdef CONFIG_BLK_DEV_IDEDMA
 int ide_dma_good_drive(ide_drive_t *);
 int __ide_dma_bad_drive(ide_drive_t *);
-int ide_id_dma_bug(ide_drive_t *);
 
 u8 ide_find_dma_mode(ide_drive_t *, u8);
 
@@ -1425,7 +1400,6 @@ void ide_dma_lost_irq(ide_drive_t *);
 ide_startstop_t ide_dma_timeout_retry(ide_drive_t *, int);
 
 #else
-static inline int ide_id_dma_bug(ide_drive_t *drive) { return 0; }
 static inline u8 ide_find_dma_mode(ide_drive_t *drive, u8 speed) { return 0; }
 static inline u8 ide_max_dma_mode(ide_drive_t *drive) { return 0; }
 static inline void ide_dma_off_quietly(ide_drive_t *drive) { ; }
@@ -1445,6 +1419,7 @@ static inline void ide_dma_unmap_sg(ide_drive_t *drive,
 
 #ifdef CONFIG_BLK_DEV_IDEACPI
 int ide_acpi_init(void);
+bool ide_port_acpi(ide_hwif_t *hwif);
 extern int ide_acpi_exec_tfs(ide_drive_t *drive);
 extern void ide_acpi_get_timing(ide_hwif_t *hwif);
 extern void ide_acpi_push_timing(ide_hwif_t *hwif);
@@ -1453,6 +1428,7 @@ void ide_acpi_port_init_devices(ide_hwif_t *);
 extern void ide_acpi_set_state(ide_hwif_t *hwif, int on);
 #else
 static inline int ide_acpi_init(void) { return 0; }
+static inline bool ide_port_acpi(ide_hwif_t *hwif) { return 0; }
 static inline int ide_acpi_exec_tfs(ide_drive_t *drive) { return 0; }
 static inline void ide_acpi_get_timing(ide_hwif_t *hwif) { ; }
 static inline void ide_acpi_push_timing(ide_hwif_t *hwif) { ; }
@@ -1464,16 +1440,18 @@ static inline void ide_acpi_set_state(ide_hwif_t *hwif, int on) {}
 void ide_register_region(struct gendisk *);
 void ide_unregister_region(struct gendisk *);
 
+void ide_check_nien_quirk_list(ide_drive_t *);
 void ide_undecoded_slave(ide_drive_t *);
 
 void ide_port_apply_params(ide_hwif_t *);
 int ide_sysfs_register_port(ide_hwif_t *);
 
-struct ide_host *ide_host_alloc(const struct ide_port_info *, hw_regs_t **);
+struct ide_host *ide_host_alloc(const struct ide_port_info *, struct ide_hw **,
+                                unsigned int);
 void ide_host_free(struct ide_host *);
 int ide_host_register(struct ide_host *, const struct ide_port_info *,
-                      hw_regs_t **);
-int ide_host_add(const struct ide_port_info *, hw_regs_t **,
+                      struct ide_hw **);
+int ide_host_add(const struct ide_port_info *, struct ide_hw **, unsigned int,
                  struct ide_host **);
 void ide_host_remove(struct ide_host *);
 int ide_legacy_device_add(const struct ide_port_info *, unsigned long);
@@ -1533,6 +1511,7 @@ int ide_timing_compute(ide_drive_t *, u8, struct ide_timing *, int, int);
 int ide_scan_pio_blacklist(char *);
 const char *ide_xfer_verbose(u8);
 u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8);
+int ide_pio_need_iordy(ide_drive_t *, const u8);
 int ide_set_pio_mode(ide_drive_t *, u8);
 int ide_set_dma_mode(ide_drive_t *, u8);
 void ide_set_pio(ide_drive_t *, u8);
@@ -1570,6 +1549,16 @@ static inline ide_drive_t *ide_get_pair_dev(ide_drive_t *drive)
         return (peer->dev_flags & IDE_DFLAG_PRESENT) ? peer : NULL;
 }
 
+static inline void *ide_get_drivedata(ide_drive_t *drive)
+{
+        return drive->drive_data;
+}
+
+static inline void ide_set_drivedata(ide_drive_t *drive, void *data)
+{
+        drive->drive_data = data;
+}
+
 #define ide_port_for_each_dev(i, dev, port) \
         for ((i) = 0; ((dev) = (port)->devices[i]) || (i) < MAX_DRIVES; (i)++)
 
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 4b501b48ce86..a9173d5434d1 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -493,6 +493,7 @@ struct ieee80211s_hdr {
 /* Mesh flags */
 #define MESH_FLAGS_AE_A4        0x1
 #define MESH_FLAGS_AE_A5_A6     0x2
+#define MESH_FLAGS_AE           0x3
 #define MESH_FLAGS_PS_DEEP      0x4
 
 /**
@@ -540,10 +541,10 @@ struct ieee80211_tim_ie {
         u8 dtim_period;
         u8 bitmap_ctrl;
         /* variable size: 1 - 251 bytes */
-        u8 virtual_map[0];
+        u8 virtual_map[1];
 } __attribute__ ((packed));
 
-#define WLAN_SA_QUERY_TR_ID_LEN 16
+#define WLAN_SA_QUERY_TR_ID_LEN 2
 
 struct ieee80211_mgmt {
         __le16 frame_control;
@@ -1068,8 +1069,12 @@ enum ieee80211_category {
         WLAN_CATEGORY_DLS = 2,
         WLAN_CATEGORY_BACK = 3,
         WLAN_CATEGORY_PUBLIC = 4,
+        WLAN_CATEGORY_HT = 7,
         WLAN_CATEGORY_SA_QUERY = 8,
+        WLAN_CATEGORY_PROTECTED_DUAL_OF_ACTION = 9,
         WLAN_CATEGORY_WMM = 17,
+        WLAN_CATEGORY_VENDOR_SPECIFIC_PROTECTED = 126,
+        WLAN_CATEGORY_VENDOR_SPECIFIC = 127,
 };
 
 /* SPECTRUM_MGMT action code */
@@ -1081,6 +1086,15 @@ enum ieee80211_spectrum_mgmt_actioncode {
         WLAN_ACTION_SPCT_CHL_SWITCH = 4,
 };
 
+/* Security key length */
+enum ieee80211_key_len {
+        WLAN_KEY_LEN_WEP40 = 5,
+        WLAN_KEY_LEN_WEP104 = 13,
+        WLAN_KEY_LEN_CCMP = 16,
+        WLAN_KEY_LEN_TKIP = 32,
+        WLAN_KEY_LEN_AES_CMAC = 16,
+};
+
 /*
  * IEEE 802.11-2007 7.3.2.9 Country information element
  *
@@ -1261,7 +1275,9 @@ static inline bool ieee80211_is_robust_mgmt_frame(struct ieee80211_hdr *hdr)
                 if (ieee80211_has_protected(hdr->frame_control))
                         return true;
                 category = ((u8 *) hdr) + 24;
-                return *category != WLAN_CATEGORY_PUBLIC;
+                return *category != WLAN_CATEGORY_PUBLIC &&
+                        *category != WLAN_CATEGORY_HT &&
+                        *category != WLAN_CATEGORY_VENDOR_SPECIFIC;
         }
 
         return false;
@@ -1383,4 +1399,43 @@ static inline int ieee80211_freq_to_ofdm_chan(int s_freq, int freq)
                 return -1;
 }
 
+/**
+ * ieee80211_tu_to_usec - convert time units (TU) to microseconds
+ * @tu: the TUs
+ */
+static inline unsigned long ieee80211_tu_to_usec(unsigned long tu)
+{
+        return 1024 * tu;
+}
+
+/**
+ * ieee80211_check_tim - check if AID bit is set in TIM
+ * @tim: the TIM IE
+ * @tim_len: length of the TIM IE
+ * @aid: the AID to look for
+ */
+static inline bool ieee80211_check_tim(struct ieee80211_tim_ie *tim,
+                                       u8 tim_len, u16 aid)
+{
+        u8 mask;
+        u8 index, indexn1, indexn2;
+
+        if (unlikely(!tim || tim_len < sizeof(*tim)))
+                return false;
+
+        aid &= 0x3fff;
+        index = aid / 8;
+        mask  = 1 << (aid & 7);
+
+        indexn1 = tim->bitmap_ctrl & 0xfe;
+        indexn2 = tim_len + indexn1 - 4;
+
+        if (index < indexn1 || index > indexn2)
+                return false;
+
+        index -= indexn1;
+
+        return !!(tim->virtual_map[index] & mask);
+}
+
 #endif /* LINUX_IEEE80211_H */
diff --git a/include/linux/if.h b/include/linux/if.h
index 1108f3e099e3..b9a6229f3be7 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -67,6 +67,9 @@
 #define IFF_ISATAP      0x80            /* ISATAP interface (RFC4214)   */
 #define IFF_MASTER_ARPMON 0x100         /* bonding master, ARP mon in use */
 #define IFF_WAN_HDLC    0x200           /* WAN HDLC device              */
+#define IFF_XMIT_DST_RELEASE 0x400      /* dev_hard_start_xmit() is allowed to
+                                         * release skb->dst
+                                         */
 
 #define IF_GET_IFACE    0x0001          /* for querying only */
 #define IF_GET_PROTO    0x0002
diff --git a/include/linux/if_arp.h b/include/linux/if_arp.h
index 5ff89809a581..b554300ef8bf 100644
--- a/include/linux/if_arp.h
+++ b/include/linux/if_arp.h
@@ -86,6 +86,8 @@
 #define ARPHRD_IEEE80211 801            /* IEEE 802.11                  */
 #define ARPHRD_IEEE80211_PRISM 802      /* IEEE 802.11 + Prism2 header  */
 #define ARPHRD_IEEE80211_RADIOTAP 803   /* IEEE 802.11 + radiotap header */
+#define ARPHRD_IEEE802154         804
+#define ARPHRD_IEEE802154_PHY     805
 
 #define ARPHRD_PHONET   820             /* PhoNet media type            */
 #define ARPHRD_PHONET_PIPE 821          /* PhoNet pipe header           */
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index cfe4fe1b7132..70fdba2bbf71 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -78,7 +78,9 @@
 #define ETH_P_PAE       0x888E          /* Port Access Entity (IEEE 802.1X) */
 #define ETH_P_AOE       0x88A2          /* ATA over Ethernet            */
 #define ETH_P_TIPC      0x88CA          /* TIPC                         */
+#define ETH_P_1588      0x88F7          /* IEEE 1588 Timesync */
 #define ETH_P_FCOE      0x8906          /* Fibre Channel over Ethernet  */
+#define ETH_P_FIP       0x8914          /* FCoE Initialization Protocol */
 #define ETH_P_EDSA      0xDADA          /* Ethertype DSA [ NOT AN OFFICIALLY REGISTERED ID ] */
 
 /*
@@ -106,6 +108,7 @@
 #define ETH_P_DSA       0x001B          /* Distributed Switch Arch.     */
 #define ETH_P_TRAILER   0x001C          /* Trailer switch tagging       */
 #define ETH_P_PHONET    0x00F5          /* Nokia Phonet frames          */
+#define ETH_P_IEEE802154 0x00F6         /* IEEE802.15.4 frame           */
 
 /*
  *      This is an Ethernet frame header.
diff --git a/include/linux/if_packet.h b/include/linux/if_packet.h
index 18db0668065a..dea7d6b7cf98 100644
--- a/include/linux/if_packet.h
+++ b/include/linux/if_packet.h
@@ -46,6 +46,8 @@ struct sockaddr_ll
 #define PACKET_VERSION                  10
 #define PACKET_HDRLEN                   11
 #define PACKET_RESERVE                  12
+#define PACKET_TX_RING                  13
+#define PACKET_LOSS                     14
 
 struct tpacket_stats
 {
@@ -63,14 +65,22 @@ struct tpacket_auxdata
         __u16           tp_vlan_tci;
 };
 
+/* Rx ring - header status */
+#define TP_STATUS_KERNEL        0x0
+#define TP_STATUS_USER          0x1
+#define TP_STATUS_COPY          0x2
+#define TP_STATUS_LOSING        0x4
+#define TP_STATUS_CSUMNOTREADY  0x8
+
+/* Tx ring - header status */
+#define TP_STATUS_AVAILABLE     0x0
+#define TP_STATUS_SEND_REQUEST  0x1
+#define TP_STATUS_SENDING       0x2
+#define TP_STATUS_WRONG_FORMAT  0x4
+
 struct tpacket_hdr
 {
         unsigned long   tp_status;
-#define TP_STATUS_KERNEL        0
-#define TP_STATUS_USER          1
-#define TP_STATUS_COPY          2
-#define TP_STATUS_LOSING        4
-#define TP_STATUS_CSUMNOTREADY  8
         unsigned int    tp_len;
         unsigned int    tp_snaplen;
         unsigned short  tp_mac;
@@ -135,5 +145,6 @@ struct packet_mreq
 #define PACKET_MR_MULTICAST     0
 #define PACKET_MR_PROMISC       1
 #define PACKET_MR_ALLMULTI      2
+#define PACKET_MR_UNICAST       3
 
 #endif
diff --git a/include/linux/if_tun.h b/include/linux/if_tun.h
index 049d6c9428db..915ba5789f0e 100644
--- a/include/linux/if_tun.h
+++ b/include/linux/if_tun.h
@@ -55,6 +55,7 @@
 #define IFF_NO_PI       0x1000
 #define IFF_ONE_QUEUE   0x2000
 #define IFF_VNET_HDR    0x4000
+#define IFF_TUN_EXCL    0x8000
 
 /* Features for GSO (TUNSETOFFLOAD). */
 #define TUN_F_CSUM      0x01    /* You can hand me unchecksummed packets. */
diff --git a/include/linux/if_tunnel.h b/include/linux/if_tunnel.h
index 5a9aae4adb44..5eb9b0f857e0 100644
--- a/include/linux/if_tunnel.h
+++ b/include/linux/if_tunnel.h
@@ -44,7 +44,7 @@ struct ip_tunnel_prl {
         __u16                   flags;
         __u16                   __reserved;
         __u32                   datalen;
-        __u32                   __reserved2;
+        __u32                   rs_delay;
         /* data follows */
 };
 
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index e1ff5b14310e..7ff9af1d0f05 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -118,8 +118,7 @@ extern int vlan_hwaccel_do_receive(struct sk_buff *skb);
 extern int vlan_gro_receive(struct napi_struct *napi, struct vlan_group *grp,
                             unsigned int vlan_tci, struct sk_buff *skb);
 extern int vlan_gro_frags(struct napi_struct *napi, struct vlan_group *grp,
-                          unsigned int vlan_tci,
-                          struct napi_gro_fraginfo *info);
+                          unsigned int vlan_tci);
 
 #else
 static inline struct net_device *vlan_dev_real_dev(const struct net_device *dev)
@@ -154,8 +153,7 @@ static inline int vlan_gro_receive(struct napi_struct *napi,
 }
 
 static inline int vlan_gro_frags(struct napi_struct *napi,
-                                 struct vlan_group *grp, unsigned int vlan_tci,
-                                 struct napi_gro_fraginfo *info)
+                                 struct vlan_group *grp, unsigned int vlan_tci)
 {
         return NET_RX_DROP;
 }
diff --git a/include/linux/ima.h b/include/linux/ima.h
index 0e2aa45cb0ce..0e3f2a4c25f6 100644
--- a/include/linux/ima.h
+++ b/include/linux/ima.h
@@ -13,14 +13,18 @@
 #include <linux/fs.h>
 struct linux_binprm;
 
+#define IMA_COUNT_UPDATE 1
+#define IMA_COUNT_LEAVE 0
+
 #ifdef CONFIG_IMA
 extern int ima_bprm_check(struct linux_binprm *bprm);
 extern int ima_inode_alloc(struct inode *inode);
 extern void ima_inode_free(struct inode *inode);
-extern int ima_path_check(struct path *path, int mask);
+extern int ima_path_check(struct path *path, int mask, int update_counts);
 extern void ima_file_free(struct file *file);
 extern int ima_file_mmap(struct file *file, unsigned long prot);
-extern void ima_shm_check(struct file *file);
+extern void ima_counts_get(struct file *file);
+extern void ima_counts_put(struct path *path, int mask);
 
 #else
 static inline int ima_bprm_check(struct linux_binprm *bprm)
@@ -38,7 +42,7 @@ static inline void ima_inode_free(struct inode *inode)
         return;
 }
 
-static inline int ima_path_check(struct path *path, int mask)
+static inline int ima_path_check(struct path *path, int mask, int update_counts)
 {
         return 0;
 }
@@ -53,7 +57,12 @@ static inline int ima_file_mmap(struct file *file, unsigned long prot)
         return 0;
 }
 
-static inline void ima_shm_check(struct file *file)
+static inline void ima_counts_get(struct file *file)
+{
+        return;
+}
+
+static inline void ima_counts_put(struct path *path, int mask)
 {
         return;
 }
diff --git a/include/linux/in.h b/include/linux/in.h
index d60122a3a088..cf196da04ec9 100644
--- a/include/linux/in.h
+++ b/include/linux/in.h
@@ -107,6 +107,7 @@ struct in_addr {
 #define MCAST_JOIN_SOURCE_GROUP         46
 #define MCAST_LEAVE_SOURCE_GROUP        47
 #define MCAST_MSFILTER                  48
+#define IP_MULTICAST_ALL                49
 
 #define MCAST_EXCLUDE   0
 #define MCAST_INCLUDE   1
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index acef2a770b6b..ad27c7da8798 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -82,7 +82,7 @@ static inline void ipv4_devconf_setall(struct in_device *in_dev)
 
 #define IN_DEV_FORWARD(in_dev)          IN_DEV_CONF_GET((in_dev), FORWARDING)
 #define IN_DEV_MFORWARD(in_dev)         IN_DEV_ANDCONF((in_dev), MC_FORWARDING)
-#define IN_DEV_RPFILTER(in_dev)         IN_DEV_ANDCONF((in_dev), RP_FILTER)
+#define IN_DEV_RPFILTER(in_dev)         IN_DEV_MAXCONF((in_dev), RP_FILTER)
 #define IN_DEV_SOURCE_ROUTE(in_dev)     IN_DEV_ANDCONF((in_dev), \
                                                        ACCEPT_SOURCE_ROUTE)
 #define IN_DEV_BOOTP_RELAY(in_dev)      IN_DEV_ANDCONF((in_dev), BOOTP_RELAY)
diff --git a/include/linux/init.h b/include/linux/init.h
index 0e06c176f185..13b633ed695e 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -2,8 +2,6 @@
 #define _LINUX_INIT_H
 
 #include <linux/compiler.h>
-#include <linux/section-names.h>
-#include <linux/stringify.h>
 
 /* These macros are used to mark some functions or 
  * initialized data (doesn't apply to uninitialized data)
@@ -31,7 +29,7 @@
  * sign followed by value, e.g.:
  *
  * static int init_variable __initdata = 0;
- * static char linux_logo[] __initdata = { 0x32, 0x36, ... };
+ * static const char linux_logo[] __initconst = { 0x32, 0x36, ... };
  *
  * Don't forget to initialize data not at file scope, i.e. within a function,
  * as gcc otherwise puts the data into the bss section and not into the init
@@ -101,7 +99,7 @@
 #define __memexitconst   __section(.memexit.rodata)
 
 /* For assembly routines */
-#define __HEAD          .section        __stringify(HEAD_TEXT_SECTION),"ax"
+#define __HEAD          .section        ".head.text","ax"
 #define __INIT          .section        ".init.text","ax"
 #define __FINIT         .previous
 
@@ -136,6 +134,9 @@ typedef void (*exitcall_t)(void);
 extern initcall_t __con_initcall_start[], __con_initcall_end[];
 extern initcall_t __security_initcall_start[], __security_initcall_end[];
 
+/* Used for contructor calls. */
+typedef void (*ctor_fn_t)(void);
+
 /* Defined in init/main.c */
 extern int do_one_initcall(initcall_t fn);
 extern char __initdata boot_command_line[];
@@ -225,7 +226,8 @@ struct obs_kernel_param {
  * obs_kernel_param "array" too far apart in .init.setup.
  */
 #define __setup_param(str, unique_id, fn, early)                        \
-        static char __setup_str_##unique_id[] __initdata __aligned(1) = str; \
+        static const char __setup_str_##unique_id[] __initconst \
+                __aligned(1) = str; \
         static struct obs_kernel_param __setup_##unique_id      \
                 __used __section(.init.setup)                   \
                 __attribute__((aligned((sizeof(long)))))        \
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index d87247d2641f..7fc01b13be43 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -15,18 +15,6 @@
 extern struct files_struct init_files;
 extern struct fs_struct init_fs;
 
-#define INIT_MM(name) \
-{                                                               \
-        .mm_rb          = RB_ROOT,                              \
-        .pgd            = swapper_pg_dir,                       \
-        .mm_users       = ATOMIC_INIT(2),                       \
-        .mm_count       = ATOMIC_INIT(1),                       \
-        .mmap_sem       = __RWSEM_INITIALIZER(name.mmap_sem),   \
-        .page_table_lock =  __SPIN_LOCK_UNLOCKED(name.page_table_lock), \
-        .mmlist         = LIST_HEAD_INIT(name.mmlist),          \
-        .cpu_vm_mask    = CPU_MASK_ALL,                         \
-}
-
 #define INIT_SIGNALS(sig) {                                             \
         .count          = ATOMIC_INIT(1),                               \
         .wait_chldexit  = __WAIT_QUEUE_HEAD_INITIALIZER(sig.wait_chldexit),\
@@ -108,6 +96,15 @@ extern struct group_info init_groups;
 
 extern struct cred init_cred;
 
+#ifdef CONFIG_PERF_COUNTERS
+# define INIT_PERF_COUNTERS(tsk)                                        \
+        .perf_counter_mutex =                                           \
+                 __MUTEX_INITIALIZER(tsk.perf_counter_mutex),           \
+        .perf_counter_list = LIST_HEAD_INIT(tsk.perf_counter_list),
+#else
+# define INIT_PERF_COUNTERS(tsk)
+#endif
+
 /*
  *  INIT_TASK is used to set up the first task table, touch at
  * your own risk!. Base=0, limit=0x1fffff (=2MB)
@@ -145,8 +142,8 @@ extern struct cred init_cred;
         .group_leader   = &tsk,                                         \
         .real_cred      = &init_cred,                                   \
         .cred           = &init_cred,                                   \
-        .cred_exec_mutex =                                              \
-                 __MUTEX_INITIALIZER(tsk.cred_exec_mutex),              \
+        .cred_guard_mutex =                                             \
+                 __MUTEX_INITIALIZER(tsk.cred_guard_mutex),             \
         .comm           = "swapper",                                    \
         .thread         = INIT_THREAD,                                  \
         .fs             = &init_fs,                                     \
@@ -171,9 +168,11 @@ extern struct cred init_cred;
         },                                                              \
         .dirties = INIT_PROP_LOCAL_SINGLE(dirties),                     \
         INIT_IDS                                                        \
+        INIT_PERF_COUNTERS(tsk)                                         \
         INIT_TRACE_IRQFLAGS                                             \
         INIT_LOCKDEP                                                    \
         INIT_FTRACE_GRAPH                                               \
+        INIT_TRACE_RECURSION                                            \
 }
 
 
@@ -184,5 +183,8 @@ extern struct cred init_cred;
         LIST_HEAD_INIT(cpu_timers[2]),                                  \
 }
 
+/* Attach to the init_task data structure for proper alignment */
+#define __init_task_data __attribute__((__section__(".data.init_task")))
+
 
 #endif
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index aa8c53171233..482dc91fd53a 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -53,6 +53,7 @@
 #define DMAR_PHMLIMIT_REG 0x78  /* pmrr high limit */
 #define DMAR_IQH_REG    0x80    /* Invalidation queue head register */
 #define DMAR_IQT_REG    0x88    /* Invalidation queue tail register */
+#define DMAR_IQ_SHIFT   4       /* Invalidation queue head/tail shift */
 #define DMAR_IQA_REG    0x90    /* Invalidation queue addr register */
 #define DMAR_ICS_REG    0x98    /* Invalidation complete status register */
 #define DMAR_IRTA_REG   0xb8    /* Interrupt remapping table addr register */
@@ -120,8 +121,10 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
         (ecap_iotlb_offset(e) + ecap_niotlb_iunits(e) * 16)
 #define ecap_coherent(e)        ((e) & 0x1)
 #define ecap_qis(e)             ((e) & 0x2)
+#define ecap_pass_through(e)    ((e >> 6) & 0x1)
 #define ecap_eim_support(e)     ((e >> 4) & 0x1)
 #define ecap_ir_support(e)      ((e >> 3) & 0x1)
+#define ecap_dev_iotlb_support(e)       (((e) >> 2) & 0x1)
 #define ecap_max_handle_mask(e) ((e >> 20) & 0xf)
 #define ecap_sc_support(e)      ((e >> 7) & 0x1) /* Snooping Control */
 
@@ -197,6 +200,8 @@ static inline void dmar_writeq(void __iomem *addr, u64 val)
 #define DMA_FSTS_PPF ((u32)2)
 #define DMA_FSTS_PFO ((u32)1)
 #define DMA_FSTS_IQE (1 << 4)
+#define DMA_FSTS_ICE (1 << 5)
+#define DMA_FSTS_ITE (1 << 6)
 #define dma_fsts_fault_record_index(s) (((s) >> 8) & 0xff)
 
 /* FRCD_REG, 32 bits access */
@@ -225,7 +230,8 @@ do {									\
 enum {
         QI_FREE,
         QI_IN_USE,
-        QI_DONE
+        QI_DONE,
+        QI_ABORT
 };
 
 #define QI_CC_TYPE              0x1
@@ -254,6 +260,12 @@ enum {
 #define QI_CC_DID(did)          (((u64)did) << 16)
 #define QI_CC_GRAN(gran)        (((u64)gran) >> (DMA_CCMD_INVL_GRANU_OFFSET-4))
 
+#define QI_DEV_IOTLB_SID(sid)   ((u64)((sid) & 0xffff) << 32)
+#define QI_DEV_IOTLB_QDEP(qdep) (((qdep) & 0x1f) << 16)
+#define QI_DEV_IOTLB_ADDR(addr) ((u64)(addr) & VTD_PAGE_MASK)
+#define QI_DEV_IOTLB_SIZE       1
+#define QI_DEV_IOTLB_MAX_INVS   32
+
 struct qi_desc {
         u64 low, high;
 };
@@ -280,10 +292,10 @@ struct ir_table {
 #endif
 
 struct iommu_flush {
-        int (*flush_context)(struct intel_iommu *iommu, u16 did, u16 sid, u8 fm,
-                u64 type, int non_present_entry_flush);
-        int (*flush_iotlb)(struct intel_iommu *iommu, u16 did, u64 addr,
-                unsigned int size_order, u64 type, int non_present_entry_flush);
+        void (*flush_context)(struct intel_iommu *iommu, u16 did, u16 sid,
+                              u8 fm, u64 type);
+        void (*flush_iotlb)(struct intel_iommu *iommu, u16 did, u64 addr,
+                            unsigned int size_order, u64 type);
 };
 
 enum {
@@ -302,6 +314,7 @@ struct intel_iommu {
         spinlock_t      register_lock; /* protect register handling */
         int             seq_id; /* sequence id of the iommu */
         int             agaw; /* agaw of this iommu */
+        int             msagaw; /* max sagaw of this iommu */
         unsigned int    irq;
         unsigned char   name[13];    /* Device Name */
 
@@ -329,6 +342,7 @@ static inline void __iommu_flush_cache(
 }
 
 extern struct dmar_drhd_unit * dmar_find_matched_drhd_unit(struct pci_dev *dev);
+extern int dmar_find_matched_atsr_unit(struct pci_dev *dev);
 
 extern int alloc_iommu(struct dmar_drhd_unit *drhd);
 extern void free_iommu(struct intel_iommu *iommu);
@@ -337,11 +351,12 @@ extern void dmar_disable_qi(struct intel_iommu *iommu);
 extern int dmar_reenable_qi(struct intel_iommu *iommu);
 extern void qi_global_iec(struct intel_iommu *iommu);
 
-extern int qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid,
-                                u8 fm, u64 type, int non_present_entry_flush);
-extern int qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr,
-                          unsigned int size_order, u64 type,
-                          int non_present_entry_flush);
+extern void qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid,
+                             u8 fm, u64 type);
+extern void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr,
+                          unsigned int size_order, u64 type);
+extern void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 qdep,
+                               u64 addr, unsigned mask);
 
 extern int qi_submit_sync(struct qi_desc *desc, struct intel_iommu *iommu);
 
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 91bb76f44f14..35e7df1e9f30 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -14,6 +14,7 @@
 #include <linux/irqflags.h>
 #include <linux/smp.h>
 #include <linux/percpu.h>
+#include <linux/hrtimer.h>
 
 #include <asm/atomic.h>
 #include <asm/ptrace.h>
@@ -64,11 +65,13 @@
  * IRQTF_RUNTHREAD - signals that the interrupt handler thread should run
  * IRQTF_DIED      - handler thread died
  * IRQTF_WARNED    - warning "IRQ_WAKE_THREAD w/o thread_fn" has been printed
+ * IRQTF_AFFINITY  - irq thread is requested to adjust affinity
  */
 enum {
         IRQTF_RUNTHREAD,
         IRQTF_DIED,
         IRQTF_WARNED,
+        IRQTF_AFFINITY,
 };
 
 typedef irqreturn_t (*irq_handler_t)(int, void *);
@@ -183,6 +186,7 @@ extern void disable_irq(unsigned int irq);
 extern void enable_irq(unsigned int irq);
 
 /* The following three functions are for the core kernel use only. */
+#ifdef CONFIG_GENERIC_HARDIRQS
 extern void suspend_device_irqs(void);
 extern void resume_device_irqs(void);
 #ifdef CONFIG_PM_SLEEP
@@ -190,6 +194,11 @@ extern int check_wakeup_irqs(void);
 #else
 static inline int check_wakeup_irqs(void) { return 0; }
 #endif
+#else
+static inline void suspend_device_irqs(void) { };
+static inline void resume_device_irqs(void) { };
+static inline int check_wakeup_irqs(void) { return 0; }
+#endif
 
 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
 
@@ -466,6 +475,20 @@ static inline void tasklet_hi_schedule(struct tasklet_struct *t)
                 __tasklet_hi_schedule(t);
 }
 
+extern void __tasklet_hi_schedule_first(struct tasklet_struct *t);
+
+/*
+ * This version avoids touching any other tasklets. Needed for kmemcheck
+ * in order not to take any page faults while enqueueing this tasklet;
+ * consider VERY carefully whether you really need this or
+ * tasklet_hi_schedule()...
+ */
+static inline void tasklet_hi_schedule_first(struct tasklet_struct *t)
+{
+        if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
+                __tasklet_hi_schedule_first(t);
+}
+
 
 static inline void tasklet_disable_nosync(struct tasklet_struct *t)
 {
@@ -497,6 +520,31 @@ extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu);
 extern void tasklet_init(struct tasklet_struct *t,
                          void (*func)(unsigned long), unsigned long data);
 
+struct tasklet_hrtimer {
+        struct hrtimer          timer;
+        struct tasklet_struct   tasklet;
+        enum hrtimer_restart    (*function)(struct hrtimer *);
+};
+
+extern void
+tasklet_hrtimer_init(struct tasklet_hrtimer *ttimer,
+                     enum hrtimer_restart (*function)(struct hrtimer *),
+                     clockid_t which_clock, enum hrtimer_mode mode);
+
+static inline
+int tasklet_hrtimer_start(struct tasklet_hrtimer *ttimer, ktime_t time,
+                          const enum hrtimer_mode mode)
+{
+        return hrtimer_start(&ttimer->timer, time, mode);
+}
+
+static inline
+void tasklet_hrtimer_cancel(struct tasklet_hrtimer *ttimer)
+{
+        hrtimer_cancel(&ttimer->timer);
+        tasklet_kill(&ttimer->tasklet);
+}
+
 /*
  * Autoprobing for irqs:
  *
@@ -566,6 +614,6 @@ struct irq_desc;
 extern int early_irq_init(void);
 extern int arch_probe_nr_irqs(void);
 extern int arch_early_irq_init(void);
-extern int arch_init_chip_data(struct irq_desc *desc, int cpu);
+extern int arch_init_chip_data(struct irq_desc *desc, int node);
 
 #endif
diff --git a/include/linux/iocontext.h b/include/linux/iocontext.h
index 08b987bccf89..4da4a75c3f1e 100644
--- a/include/linux/iocontext.h
+++ b/include/linux/iocontext.h
@@ -64,7 +64,7 @@ struct cfq_io_context {
  * and kmalloc'ed. These could be shared between processes.
  */
 struct io_context {
-        atomic_t refcount;
+        atomic_long_t refcount;
         atomic_t nr_tasks;
 
         /* all the fields below are protected by this lock */
@@ -91,7 +91,7 @@ static inline struct io_context *ioc_task_link(struct io_context *ioc)
          * if ref count is zero, don't allow sharing (ioc is going away, it's
          * a race).
          */
-        if (ioc && atomic_inc_not_zero(&ioc->refcount)) {
+        if (ioc && atomic_long_inc_not_zero(&ioc->refcount)) {
                 atomic_inc(&ioc->nr_tasks);
                 return ioc;
         }
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 32e4b2f72294..786e7b8cece9 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -49,6 +49,8 @@ struct resource_list {
 #define IORESOURCE_SIZEALIGN    0x00020000      /* size indicates alignment */
 #define IORESOURCE_STARTALIGN   0x00040000      /* start field is alignment */
 
+#define IORESOURCE_MEM_64       0x00100000
+
 #define IORESOURCE_EXCLUSIVE    0x08000000      /* Userland may not map this resource */
 #define IORESOURCE_DISABLED     0x10000000
 #define IORESOURCE_UNSET        0x20000000
diff --git a/include/linux/ipc_namespace.h b/include/linux/ipc_namespace.h
index 3bf40e246a80..e408722a84c7 100644
--- a/include/linux/ipc_namespace.h
+++ b/include/linux/ipc_namespace.h
@@ -94,13 +94,8 @@ static inline int mq_init_ns(struct ipc_namespace *ns) { return 0; }
 #endif
 
 #if defined(CONFIG_IPC_NS)
-extern void free_ipc_ns(struct ipc_namespace *ns);
 extern struct ipc_namespace *copy_ipcs(unsigned long flags,
                                        struct ipc_namespace *ns);
-extern void free_ipcs(struct ipc_namespace *ns, struct ipc_ids *ids,
-                      void (*free)(struct ipc_namespace *,
-                                   struct kern_ipc_perm *));
-
 static inline struct ipc_namespace *get_ipc_ns(struct ipc_namespace *ns)
 {
         if (ns)
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 476d9464ac82..c662efa68289 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -169,6 +169,12 @@ struct ipv6_devconf {
         __s32           accept_dad;
         void            *sysctl;
 };
+
+struct ipv6_params {
+        __s32 disable_ipv6;
+        __s32 autoconf;
+};
+extern struct ipv6_params ipv6_defaults;
 #endif
 
 /* index values for the variables in ipv6_devconf */
diff --git a/include/linux/irq.h b/include/linux/irq.h
index b7cbeed972e4..cb2e77a3f7f7 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -117,7 +117,7 @@ struct irq_chip {
         void            (*eoi)(unsigned int irq);
 
         void            (*end)(unsigned int irq);
-        void            (*set_affinity)(unsigned int irq,
+        int             (*set_affinity)(unsigned int irq,
                                         const struct cpumask *dest);
         int             (*retrigger)(unsigned int irq);
         int             (*set_type)(unsigned int irq, unsigned int flow_type);
@@ -157,7 +157,7 @@ struct irq_2_iommu;
  * @irqs_unhandled:     stats field for spurious unhandled interrupts
  * @lock:               locking for SMP
  * @affinity:           IRQ affinity on SMP
- * @cpu:                cpu index useful for balancing
+ * @node:               node index useful for balancing
  * @pending_mask:       pending rebalanced interrupts
  * @threads_active:     number of irqaction threads currently running
  * @wait_for_threads:   wait queue for sync_irq to wait for threaded handlers
@@ -187,7 +187,7 @@ struct irq_desc {
         spinlock_t              lock;
 #ifdef CONFIG_SMP
         cpumask_var_t           affinity;
-        unsigned int            cpu;
+        unsigned int            node;
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         cpumask_var_t           pending_mask;
 #endif
@@ -201,26 +201,23 @@ struct irq_desc {
 } ____cacheline_internodealigned_in_smp;
 
 extern void arch_init_copy_chip_data(struct irq_desc *old_desc,
-                                        struct irq_desc *desc, int cpu);
+                                        struct irq_desc *desc, int node);
 extern void arch_free_chip_data(struct irq_desc *old_desc, struct irq_desc *desc);
 
 #ifndef CONFIG_SPARSE_IRQ
 extern struct irq_desc irq_desc[NR_IRQS];
-#else /* CONFIG_SPARSE_IRQ */
-extern struct irq_desc *move_irq_desc(struct irq_desc *old_desc, int cpu);
-#endif /* CONFIG_SPARSE_IRQ */
-
-extern struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu);
+#endif
 
-static inline struct irq_desc *
-irq_remap_to_desc(unsigned int irq, struct irq_desc *desc)
-{
-#ifdef CONFIG_NUMA_MIGRATE_IRQ_DESC
-        return irq_to_desc(irq);
+#ifdef CONFIG_NUMA_IRQ_DESC
+extern struct irq_desc *move_irq_desc(struct irq_desc *old_desc, int node);
 #else
+static inline struct irq_desc *move_irq_desc(struct irq_desc *desc, int node)
+{
         return desc;
-#endif
 }
+#endif
+
+extern struct irq_desc *irq_to_desc_alloc_node(unsigned int irq, int node);
 
 /*
  * Migration helpers for obsolete names, they will go away:
@@ -386,7 +383,7 @@ extern void set_irq_noprobe(unsigned int irq);
 extern void set_irq_probe(unsigned int irq);
 
 /* Handle dynamic irq creation and destruction */
-extern unsigned int create_irq_nr(unsigned int irq_want);
+extern unsigned int create_irq_nr(unsigned int irq_want, int node);
 extern int create_irq(void);
 extern void destroy_irq(unsigned int irq);
 
@@ -424,47 +421,44 @@ extern int set_irq_msi(unsigned int irq, struct msi_desc *entry);
 
 #ifdef CONFIG_SMP
 /**
- * init_alloc_desc_masks - allocate cpumasks for irq_desc
+ * alloc_desc_masks - allocate cpumasks for irq_desc
  * @desc:       pointer to irq_desc struct
- * @cpu:        cpu which will be handling the cpumasks
+ * @node:       node which will be handling the cpumasks
  * @boot:       true if need bootmem
  *
  * Allocates affinity and pending_mask cpumask if required.
  * Returns true if successful (or not required).
- * Side effect: affinity has all bits set, pending_mask has all bits clear.
  */
-static inline bool init_alloc_desc_masks(struct irq_desc *desc, int cpu,
-                                                                bool boot)
+static inline bool alloc_desc_masks(struct irq_desc *desc, int node,
+                                                        bool boot)
 {
-        int node;
-
-        if (boot) {
-                alloc_bootmem_cpumask_var(&desc->affinity);
-                cpumask_setall(desc->affinity);
-
-#ifdef CONFIG_GENERIC_PENDING_IRQ
-                alloc_bootmem_cpumask_var(&desc->pending_mask);
-                cpumask_clear(desc->pending_mask);
-#endif
-                return true;
-        }
+        gfp_t gfp = GFP_ATOMIC;
 
-        node = cpu_to_node(cpu);
+        if (boot)
+                gfp = GFP_NOWAIT;
 
-        if (!alloc_cpumask_var_node(&desc->affinity, GFP_ATOMIC, node))
+#ifdef CONFIG_CPUMASK_OFFSTACK
+        if (!alloc_cpumask_var_node(&desc->affinity, gfp, node))
                 return false;
-        cpumask_setall(desc->affinity);
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
-        if (!alloc_cpumask_var_node(&desc->pending_mask, GFP_ATOMIC, node)) {
+        if (!alloc_cpumask_var_node(&desc->pending_mask, gfp, node)) {
                 free_cpumask_var(desc->affinity);
                 return false;
         }
-        cpumask_clear(desc->pending_mask);
+#endif
 #endif
         return true;
 }
 
+static inline void init_desc_masks(struct irq_desc *desc)
+{
+        cpumask_setall(desc->affinity);
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+        cpumask_clear(desc->pending_mask);
+#endif
+}
+
 /**
  * init_copy_desc_masks - copy cpumasks for irq_desc
  * @old_desc:   pointer to old irq_desc struct
@@ -478,7 +472,7 @@ static inline bool init_alloc_desc_masks(struct irq_desc *desc, int cpu,
 static inline void init_copy_desc_masks(struct irq_desc *old_desc,
                                         struct irq_desc *new_desc)
 {
-#ifdef CONFIG_CPUMASKS_OFFSTACK
+#ifdef CONFIG_CPUMASK_OFFSTACK
         cpumask_copy(new_desc->affinity, old_desc->affinity);
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
@@ -499,12 +493,16 @@ static inline void free_desc_masks(struct irq_desc *old_desc,
 
 #else /* !CONFIG_SMP */
 
-static inline bool init_alloc_desc_masks(struct irq_desc *desc, int cpu,
+static inline bool alloc_desc_masks(struct irq_desc *desc, int node,
                                                                 bool boot)
 {
         return true;
 }
 
+static inline void init_desc_masks(struct irq_desc *desc)
+{
+}
+
 static inline void init_copy_desc_masks(struct irq_desc *old_desc,
                                         struct irq_desc *new_desc)
 {
diff --git a/include/linux/isdn/capilli.h b/include/linux/isdn/capilli.h
index 35e9b0fd014b..7acb87a44872 100644
--- a/include/linux/isdn/capilli.h
+++ b/include/linux/isdn/capilli.h
@@ -79,7 +79,7 @@ int attach_capi_ctr(struct capi_ctr *);
 int detach_capi_ctr(struct capi_ctr *);
 
 void capi_ctr_ready(struct capi_ctr * card);
-void capi_ctr_reseted(struct capi_ctr * card);
+void capi_ctr_down(struct capi_ctr * card);
 void capi_ctr_suspend_output(struct capi_ctr * card);
 void capi_ctr_resume_output(struct capi_ctr * card);
 void capi_ctr_handle_message(struct capi_ctr * card, u16 appl, struct sk_buff *skb);
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index cc02393bfce8..d97eb652d6ca 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -1315,6 +1315,12 @@ extern int jbd_blocks_per_page(struct inode *inode);
 #define BUFFER_TRACE2(bh, bh2, info)    do {} while (0)
 #define JBUFFER_TRACE(jh, info) do {} while (0)
 
+/* 
+ * jbd2_dev_to_name is a utility function used by the jbd2 and ext4 
+ * tracing infrastructure to map a dev_t to a device name.
+ */
+extern const char *jbd2_dev_to_name(dev_t device);
+
 #endif  /* __KERNEL__ */
 
 #endif  /* _LINUX_JBD2_H */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 883cd44ff765..d6320a3e8def 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -58,7 +58,7 @@ extern const char linux_proc_banner[];
 #define _RET_IP_                (unsigned long)__builtin_return_address(0)
 #define _THIS_IP_  ({ __label__ __here; __here: (unsigned long)&&__here; })
 
-#ifdef CONFIG_LBD
+#ifdef CONFIG_LBDAF
 # include <asm/div64.h>
 # define sector_div(a, b) do_div(a, b)
 #else
@@ -97,12 +97,14 @@ extern const char linux_proc_banner[];
 #define KERN_INFO       "<6>"   /* informational                        */
 #define KERN_DEBUG      "<7>"   /* debug-level messages                 */
 
+/* Use the default kernel loglevel */
+#define KERN_DEFAULT    "<d>"
 /*
  * Annotation for a "continued" line of log printout (only done after a
  * line that had no enclosing \n). Only to be used by core/arch code
  * during early bootup (a continued line is not SMP-safe otherwise).
  */
-#define KERN_CONT       ""
+#define KERN_CONT       "<c>"
 
 extern int console_printk[];
 
@@ -301,6 +303,7 @@ extern int oops_in_progress;		/* If set, an oops, panic(), BUG() or die() is in
 extern int panic_timeout;
 extern int panic_on_oops;
 extern int panic_on_unrecovered_nmi;
+extern int panic_on_io_nmi;
 extern const char *print_tainted(void);
 extern void add_taint(unsigned flag);
 extern int test_taint(unsigned flag);
@@ -406,7 +409,7 @@ static inline char *pack_hex_byte(char *buf, u8 byte)
  *
  * Use tracing_on/tracing_off when you want to quickly turn on or off
  * tracing. It simply enables or disables the recording of the trace events.
- * This also corresponds to the user space debugfs/tracing/tracing_on
+ * This also corresponds to the user space /sys/kernel/debug/tracing/tracing_on
  * file, which gives a means for the kernel and userspace to interact.
  * Place a tracing_off() in the kernel where you want tracing to end.
  * From user space, examine the trace, and then echo 1 > tracing_on
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index 0c8b89f28a95..348fa8874b52 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -5,6 +5,7 @@
 #include <linux/threads.h>
 #include <linux/percpu.h>
 #include <linux/cpumask.h>
+#include <linux/interrupt.h>
 #include <asm/irq.h>
 #include <asm/cputime.h>
 
@@ -31,6 +32,7 @@ struct kernel_stat {
 #ifndef CONFIG_GENERIC_HARDIRQS
        unsigned int irqs[NR_IRQS];
 #endif
+        unsigned int softirqs[NR_SOFTIRQS];
 };
 
 DECLARE_PER_CPU(struct kernel_stat, kstat);
@@ -67,6 +69,16 @@ extern unsigned int kstat_irqs_cpu(unsigned int irq, int cpu);
 
 #endif
 
+static inline void kstat_incr_softirqs_this_cpu(unsigned int irq)
+{
+        kstat_this_cpu.softirqs[irq]++;
+}
+
+static inline unsigned int kstat_softirqs_cpu(unsigned int irq, int cpu)
+{
+       return kstat_cpu(cpu).softirqs[irq];
+}
+
 /*
  * Number of interrupts per specific IRQ source, since bootup
  */
@@ -81,7 +93,12 @@ static inline unsigned int kstat_irqs(unsigned int irq)
         return sum;
 }
 
+
+/*
+ * Lock/unlock the current runqueue - to extract task statistics:
+ */
 extern unsigned long long task_delta_exec(struct task_struct *);
+
 extern void account_user_time(struct task_struct *, cputime_t, cputime_t);
 extern void account_system_time(struct task_struct *, int, cputime_t, cputime_t);
 extern void account_steal_time(cputime_t);
diff --git a/include/linux/keyboard.h b/include/linux/keyboard.h
index a3c984d780f0..33a63f62d57f 100644
--- a/include/linux/keyboard.h
+++ b/include/linux/keyboard.h
@@ -56,6 +56,7 @@ extern int unregister_keyboard_notifier(struct notifier_block *nb);
 #define KT_ASCII        9
 #define KT_LOCK         10
 #define KT_SLOCK        12
+#define KT_DEAD2        13
 #define KT_BRL          14
 
 #define K(t,v)          (((t)<<8)|(v))
diff --git a/include/linux/kmemcheck.h b/include/linux/kmemcheck.h
new file mode 100644
index 000000000000..47b39b7c7e84
--- /dev/null
+++ b/include/linux/kmemcheck.h
@@ -0,0 +1,153 @@
+#ifndef LINUX_KMEMCHECK_H
+#define LINUX_KMEMCHECK_H
+
+#include <linux/mm_types.h>
+#include <linux/types.h>
+
+#ifdef CONFIG_KMEMCHECK
+extern int kmemcheck_enabled;
+
+/* The slab-related functions. */
+void kmemcheck_alloc_shadow(struct page *page, int order, gfp_t flags, int node);
+void kmemcheck_free_shadow(struct page *page, int order);
+void kmemcheck_slab_alloc(struct kmem_cache *s, gfp_t gfpflags, void *object,
+                          size_t size);
+void kmemcheck_slab_free(struct kmem_cache *s, void *object, size_t size);
+
+void kmemcheck_pagealloc_alloc(struct page *p, unsigned int order,
+                               gfp_t gfpflags);
+
+void kmemcheck_show_pages(struct page *p, unsigned int n);
+void kmemcheck_hide_pages(struct page *p, unsigned int n);
+
+bool kmemcheck_page_is_tracked(struct page *p);
+
+void kmemcheck_mark_unallocated(void *address, unsigned int n);
+void kmemcheck_mark_uninitialized(void *address, unsigned int n);
+void kmemcheck_mark_initialized(void *address, unsigned int n);
+void kmemcheck_mark_freed(void *address, unsigned int n);
+
+void kmemcheck_mark_unallocated_pages(struct page *p, unsigned int n);
+void kmemcheck_mark_uninitialized_pages(struct page *p, unsigned int n);
+void kmemcheck_mark_initialized_pages(struct page *p, unsigned int n);
+
+int kmemcheck_show_addr(unsigned long address);
+int kmemcheck_hide_addr(unsigned long address);
+
+#else
+#define kmemcheck_enabled 0
+
+static inline void
+kmemcheck_alloc_shadow(struct page *page, int order, gfp_t flags, int node)
+{
+}
+
+static inline void
+kmemcheck_free_shadow(struct page *page, int order)
+{
+}
+
+static inline void
+kmemcheck_slab_alloc(struct kmem_cache *s, gfp_t gfpflags, void *object,
+                     size_t size)
+{
+}
+
+static inline void kmemcheck_slab_free(struct kmem_cache *s, void *object,
+                                       size_t size)
+{
+}
+
+static inline void kmemcheck_pagealloc_alloc(struct page *p,
+        unsigned int order, gfp_t gfpflags)
+{
+}
+
+static inline bool kmemcheck_page_is_tracked(struct page *p)
+{
+        return false;
+}
+
+static inline void kmemcheck_mark_unallocated(void *address, unsigned int n)
+{
+}
+
+static inline void kmemcheck_mark_uninitialized(void *address, unsigned int n)
+{
+}
+
+static inline void kmemcheck_mark_initialized(void *address, unsigned int n)
+{
+}
+
+static inline void kmemcheck_mark_freed(void *address, unsigned int n)
+{
+}
+
+static inline void kmemcheck_mark_unallocated_pages(struct page *p,
+                                                    unsigned int n)
+{
+}
+
+static inline void kmemcheck_mark_uninitialized_pages(struct page *p,
+                                                      unsigned int n)
+{
+}
+
+static inline void kmemcheck_mark_initialized_pages(struct page *p,
+                                                    unsigned int n)
+{
+}
+
+#endif /* CONFIG_KMEMCHECK */
+
+/*
+ * Bitfield annotations
+ *
+ * How to use: If you have a struct using bitfields, for example
+ *
+ *     struct a {
+ *             int x:8, y:8;
+ *     };
+ *
+ * then this should be rewritten as
+ *
+ *     struct a {
+ *             kmemcheck_bitfield_begin(flags);
+ *             int x:8, y:8;
+ *             kmemcheck_bitfield_end(flags);
+ *     };
+ *
+ * Now the "flags_begin" and "flags_end" members may be used to refer to the
+ * beginning and end, respectively, of the bitfield (and things like
+ * &x.flags_begin is allowed). As soon as the struct is allocated, the bit-
+ * fields should be annotated:
+ *
+ *     struct a *a = kmalloc(sizeof(struct a), GFP_KERNEL);
+ *     kmemcheck_annotate_bitfield(a, flags);
+ *
+ * Note: We provide the same definitions for both kmemcheck and non-
+ * kmemcheck kernels. This makes it harder to introduce accidental errors. It
+ * is also allowed to pass NULL pointers to kmemcheck_annotate_bitfield().
+ */
+#define kmemcheck_bitfield_begin(name)  \
+        int name##_begin[0];
+
+#define kmemcheck_bitfield_end(name)    \
+        int name##_end[0];
+
+#define kmemcheck_annotate_bitfield(ptr, name)                          \
+        do if (ptr) {                                                   \
+                int _n = (long) &((ptr)->name##_end)                    \
+                        - (long) &((ptr)->name##_begin);                \
+                BUILD_BUG_ON(_n < 0);                                   \
+                                                                        \
+                kmemcheck_mark_initialized(&((ptr)->name##_begin), _n); \
+        } while (0)
+
+#define kmemcheck_annotate_variable(var)                                \
+        do {                                                            \
+                kmemcheck_mark_initialized(&(var), sizeof(var));        \
+        } while (0)                                                     \
+
+#endif /* LINUX_KMEMCHECK_H */
diff --git a/include/linux/kmemleak.h b/include/linux/kmemleak.h
new file mode 100644
index 000000000000..6a63807f714e
--- /dev/null
+++ b/include/linux/kmemleak.h
@@ -0,0 +1,100 @@
+/*
+ * include/linux/kmemleak.h
+ *
+ * Copyright (C) 2008 ARM Limited
+ * Written by Catalin Marinas <catalin.marinas@arm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __KMEMLEAK_H
+#define __KMEMLEAK_H
+
+#ifdef CONFIG_DEBUG_KMEMLEAK
+
+extern void kmemleak_init(void);
+extern void kmemleak_alloc(const void *ptr, size_t size, int min_count,
+                           gfp_t gfp);
+extern void kmemleak_free(const void *ptr);
+extern void kmemleak_free_part(const void *ptr, size_t size);
+extern void kmemleak_padding(const void *ptr, unsigned long offset,
+                             size_t size);
+extern void kmemleak_not_leak(const void *ptr);
+extern void kmemleak_ignore(const void *ptr);
+extern void kmemleak_scan_area(const void *ptr, unsigned long offset,
+                               size_t length, gfp_t gfp);
+extern void kmemleak_no_scan(const void *ptr);
+
+static inline void kmemleak_alloc_recursive(const void *ptr, size_t size,
+                                            int min_count, unsigned long flags,
+                                            gfp_t gfp)
+{
+        if (!(flags & SLAB_NOLEAKTRACE))
+                kmemleak_alloc(ptr, size, min_count, gfp);
+}
+
+static inline void kmemleak_free_recursive(const void *ptr, unsigned long flags)
+{
+        if (!(flags & SLAB_NOLEAKTRACE))
+                kmemleak_free(ptr);
+}
+
+static inline void kmemleak_erase(void **ptr)
+{
+        *ptr = NULL;
+}
+
+#else
+
+static inline void kmemleak_init(void)
+{
+}
+static inline void kmemleak_alloc(const void *ptr, size_t size, int min_count,
+                                  gfp_t gfp)
+{
+}
+static inline void kmemleak_alloc_recursive(const void *ptr, size_t size,
+                                            int min_count, unsigned long flags,
+                                            gfp_t gfp)
+{
+}
+static inline void kmemleak_free(const void *ptr)
+{
+}
+static inline void kmemleak_free_part(const void *ptr, size_t size)
+{
+}
+static inline void kmemleak_free_recursive(const void *ptr, unsigned long flags)
+{
+}
+static inline void kmemleak_not_leak(const void *ptr)
+{
+}
+static inline void kmemleak_ignore(const void *ptr)
+{
+}
+static inline void kmemleak_scan_area(const void *ptr, unsigned long offset,
+                                      size_t length, gfp_t gfp)
+{
+}
+static inline void kmemleak_erase(void **ptr)
+{
+}
+static inline void kmemleak_no_scan(const void *ptr)
+{
+}
+
+#endif  /* CONFIG_DEBUG_KMEMLEAK */
+
+#endif  /* __KMEMLEAK_H */
diff --git a/include/linux/kmemtrace.h b/include/linux/kmemtrace.h
new file mode 100644
index 000000000000..b616d3930c3b
--- /dev/null
+++ b/include/linux/kmemtrace.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2008 Eduard - Gabriel Munteanu
+ *
+ * This file is released under GPL version 2.
+ */
+
+#ifndef _LINUX_KMEMTRACE_H
+#define _LINUX_KMEMTRACE_H
+
+#ifdef __KERNEL__
+
+#include <trace/events/kmem.h>
+
+#ifdef CONFIG_KMEMTRACE
+extern void kmemtrace_init(void);
+#else
+static inline void kmemtrace_init(void)
+{
+}
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif /* _LINUX_KMEMTRACE_H */
+
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index 8cc137911b34..3db5d8d37485 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -119,7 +119,7 @@ struct kvm_run {
                         __u32 error_code;
                 } ex;
                 /* KVM_EXIT_IO */
-                struct kvm_io {
+                struct {
 #define KVM_EXIT_IO_IN  0
 #define KVM_EXIT_IO_OUT 1
                         __u8 direction;
@@ -224,10 +224,10 @@ struct kvm_interrupt {
 /* for KVM_GET_DIRTY_LOG */
 struct kvm_dirty_log {
         __u32 slot;
-        __u32 padding;
+        __u32 padding1;
         union {
                 void __user *dirty_bitmap; /* one bit per page */
-                __u64 padding;
+                __u64 padding2;
         };
 };
 
@@ -409,6 +409,10 @@ struct kvm_trace_rec {
 #ifdef __KVM_HAVE_DEVICE_ASSIGNMENT
 #define KVM_CAP_DEVICE_DEASSIGNMENT 27
 #endif
+#ifdef __KVM_HAVE_MSIX
+#define KVM_CAP_DEVICE_MSIX 28
+#endif
+#define KVM_CAP_ASSIGN_DEV_IRQ 29
 /* Another bug in KVM_SET_USER_MEMORY_REGION fixed: */
 #define KVM_CAP_JOIN_MEMORY_REGIONS_WORKS 30
 
@@ -482,11 +486,18 @@ struct kvm_irq_routing {
 #define KVM_ASSIGN_PCI_DEVICE _IOR(KVMIO, 0x69, \
                                    struct kvm_assigned_pci_dev)
 #define KVM_SET_GSI_ROUTING       _IOW(KVMIO, 0x6a, struct kvm_irq_routing)
+/* deprecated, replaced by KVM_ASSIGN_DEV_IRQ */
 #define KVM_ASSIGN_IRQ _IOR(KVMIO, 0x70, \
                             struct kvm_assigned_irq)
+#define KVM_ASSIGN_DEV_IRQ        _IOW(KVMIO, 0x70, struct kvm_assigned_irq)
 #define KVM_REINJECT_CONTROL      _IO(KVMIO, 0x71)
 #define KVM_DEASSIGN_PCI_DEVICE _IOW(KVMIO, 0x72, \
                                      struct kvm_assigned_pci_dev)
+#define KVM_ASSIGN_SET_MSIX_NR \
+                        _IOW(KVMIO, 0x73, struct kvm_assigned_msix_nr)
+#define KVM_ASSIGN_SET_MSIX_ENTRY \
+                        _IOW(KVMIO, 0x74, struct kvm_assigned_msix_entry)
+#define KVM_DEASSIGN_DEV_IRQ       _IOW(KVMIO, 0x75, struct kvm_assigned_irq)
 
 /*
  * ioctls for vcpu fds
@@ -577,6 +588,8 @@ struct kvm_debug_guest {
 #define KVM_TRC_STLB_INVAL       (KVM_TRC_HANDLER + 0x18)
 #define KVM_TRC_PPC_INSTR        (KVM_TRC_HANDLER + 0x19)
 
+#define KVM_DEV_ASSIGN_ENABLE_IOMMU     (1 << 0)
+
 struct kvm_assigned_pci_dev {
         __u32 assigned_dev_id;
         __u32 busnr;
@@ -587,6 +600,17 @@ struct kvm_assigned_pci_dev {
         };
 };
 
+#define KVM_DEV_IRQ_HOST_INTX    (1 << 0)
+#define KVM_DEV_IRQ_HOST_MSI     (1 << 1)
+#define KVM_DEV_IRQ_HOST_MSIX    (1 << 2)
+
+#define KVM_DEV_IRQ_GUEST_INTX   (1 << 8)
+#define KVM_DEV_IRQ_GUEST_MSI    (1 << 9)
+#define KVM_DEV_IRQ_GUEST_MSIX   (1 << 10)
+
+#define KVM_DEV_IRQ_HOST_MASK    0x00ff
+#define KVM_DEV_IRQ_GUEST_MASK   0xff00
+
 struct kvm_assigned_irq {
         __u32 assigned_dev_id;
         __u32 host_irq;
@@ -602,9 +626,19 @@ struct kvm_assigned_irq {
         };
 };
 
-#define KVM_DEV_ASSIGN_ENABLE_IOMMU     (1 << 0)
 
-#define KVM_DEV_IRQ_ASSIGN_MSI_ACTION   KVM_DEV_IRQ_ASSIGN_ENABLE_MSI
-#define KVM_DEV_IRQ_ASSIGN_ENABLE_MSI   (1 << 0)
+struct kvm_assigned_msix_nr {
+        __u32 assigned_dev_id;
+        __u16 entry_nr;
+        __u16 padding;
+};
+
+#define KVM_MAX_MSIX_PER_DEV            512
+struct kvm_assigned_msix_entry {
+        __u32 assigned_dev_id;
+        __u32 gsi;
+        __u16 entry; /* The index of entry in the MSI-X table */
+        __u16 padding[3];
+};
 
 #endif
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 894a56e365e8..16713dc672e4 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -38,6 +38,7 @@
 #define KVM_REQ_UNHALT             6
 #define KVM_REQ_MMU_SYNC           7
 #define KVM_REQ_KVMCLOCK_UPDATE    8
+#define KVM_REQ_KICK               9
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID     0
 
@@ -72,7 +73,6 @@ struct kvm_vcpu {
         struct mutex mutex;
         int   cpu;
         struct kvm_run *run;
-        int guest_mode;
         unsigned long requests;
         unsigned long guest_debug;
         int fpu_active;
@@ -125,6 +125,7 @@ struct kvm_kernel_irq_routing_entry {
 struct kvm {
         struct mutex lock; /* protects the vcpus array and APIC accesses */
         spinlock_t mmu_lock;
+        spinlock_t requests_lock;
         struct rw_semaphore slots_lock;
         struct mm_struct *mm; /* userspace tied to this vm */
         int nmemslots;
@@ -298,6 +299,7 @@ int kvm_arch_hardware_setup(void);
 void kvm_arch_hardware_unsetup(void);
 void kvm_arch_check_processor_compat(void *rtn);
 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
+int kvm_arch_interrupt_allowed(struct kvm_vcpu *vcpu);
 
 void kvm_free_physmem(struct kvm *kvm);
 
@@ -319,6 +321,13 @@ struct kvm_irq_ack_notifier {
         void (*irq_acked)(struct kvm_irq_ack_notifier *kian);
 };
 
+#define KVM_ASSIGNED_MSIX_PENDING               0x1
+struct kvm_guest_msix_entry {
+        u32 vector;
+        u16 entry;
+        u16 flags;
+};
+
 struct kvm_assigned_dev_kernel {
         struct kvm_irq_ack_notifier ack_notifier;
         struct work_struct interrupt_work;
@@ -326,18 +335,18 @@ struct kvm_assigned_dev_kernel {
         int assigned_dev_id;
         int host_busnr;
         int host_devfn;
+        unsigned int entries_nr;
         int host_irq;
         bool host_irq_disabled;
+        struct msix_entry *host_msix_entries;
         int guest_irq;
-#define KVM_ASSIGNED_DEV_GUEST_INTX     (1 << 0)
-#define KVM_ASSIGNED_DEV_GUEST_MSI      (1 << 1)
-#define KVM_ASSIGNED_DEV_HOST_INTX      (1 << 8)
-#define KVM_ASSIGNED_DEV_HOST_MSI       (1 << 9)
+        struct kvm_guest_msix_entry *guest_msix_entries;
         unsigned long irq_requested_type;
         int irq_source_id;
         int flags;
         struct pci_dev *dev;
         struct kvm *kvm;
+        spinlock_t assigned_dev_lock;
 };
 
 struct kvm_irq_mask_notifier {
@@ -360,6 +369,9 @@ void kvm_unregister_irq_ack_notifier(struct kvm_irq_ack_notifier *kian);
 int kvm_request_irq_source_id(struct kvm *kvm);
 void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id);
 
+/* For vcpu->arch.iommu_flags */
+#define KVM_IOMMU_CACHE_COHERENCY       0x1
+
 #ifdef CONFIG_IOMMU_API
 int kvm_iommu_map_pages(struct kvm *kvm, gfn_t base_gfn,
                         unsigned long npages);
diff --git a/include/linux/kvm_types.h b/include/linux/kvm_types.h
index 2b8318c83e53..fb46efbeabec 100644
--- a/include/linux/kvm_types.h
+++ b/include/linux/kvm_types.h
@@ -40,4 +40,31 @@ typedef unsigned long  hfn_t;
 
 typedef hfn_t pfn_t;
 
+union kvm_ioapic_redirect_entry {
+        u64 bits;
+        struct {
+                u8 vector;
+                u8 delivery_mode:3;
+                u8 dest_mode:1;
+                u8 delivery_status:1;
+                u8 polarity:1;
+                u8 remote_irr:1;
+                u8 trig_mode:1;
+                u8 mask:1;
+                u8 reserve:7;
+                u8 reserved[4];
+                u8 dest_id;
+        } fields;
+};
+
+struct kvm_lapic_irq {
+        u32 vector;
+        u32 delivery_mode;
+        u32 dest_mode;
+        u32 level;
+        u32 trig_mode;
+        u32 shorthand;
+        u32 dest_id;
+};
+
 #endif /* __KVM_TYPES_H__ */
diff --git a/include/linux/leds-lp3944.h b/include/linux/leds-lp3944.h
new file mode 100644
index 000000000000..afc9f9fd70f5
--- /dev/null
+++ b/include/linux/leds-lp3944.h
@@ -0,0 +1,53 @@
+/*
+ * leds-lp3944.h - platform data structure for lp3944 led controller
+ *
+ * Copyright (C) 2009 Antonio Ospite <ospite@studenti.unina.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#ifndef __LINUX_LEDS_LP3944_H
+#define __LINUX_LEDS_LP3944_H
+
+#include <linux/leds.h>
+#include <linux/workqueue.h>
+
+#define LP3944_LED0 0
+#define LP3944_LED1 1
+#define LP3944_LED2 2
+#define LP3944_LED3 3
+#define LP3944_LED4 4
+#define LP3944_LED5 5
+#define LP3944_LED6 6
+#define LP3944_LED7 7
+#define LP3944_LEDS_MAX 8
+
+#define LP3944_LED_STATUS_MASK  0x03
+enum lp3944_status {
+        LP3944_LED_STATUS_OFF  = 0x0,
+        LP3944_LED_STATUS_ON   = 0x1,
+        LP3944_LED_STATUS_DIM0 = 0x2,
+        LP3944_LED_STATUS_DIM1 = 0x3
+};
+
+enum lp3944_type {
+        LP3944_LED_TYPE_NONE,
+        LP3944_LED_TYPE_LED,
+        LP3944_LED_TYPE_LED_INVERTED,
+};
+
+struct lp3944_led {
+        char *name;
+        enum lp3944_type type;
+        enum lp3944_status status;
+};
+
+struct lp3944_platform_data {
+        struct lp3944_led leds[LP3944_LEDS_MAX];
+        u8 leds_size;
+};
+
+#endif /* __LINUX_LEDS_LP3944_H */
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 376fe07732ea..d8bf9665e70c 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -45,7 +45,10 @@ struct led_classdev {
         /* Get LED brightness level */
         enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);
 
-        /* Activate hardware accelerated blink */
+        /* Activate hardware accelerated blink, delays are in
+         * miliseconds and if none is provided then a sensible default
+         * should be chosen. The call can adjust the timings if it can't
+         * match the values specified exactly. */
         int             (*blink_set)(struct led_classdev *led_cdev,
                                      unsigned long *delay_on,
                                      unsigned long *delay_off);
@@ -141,9 +144,14 @@ struct gpio_led {
         const char *name;
         const char *default_trigger;
         unsigned        gpio;
-        u8              active_low : 1;
-        u8              retain_state_suspended : 1;
+        unsigned        active_low : 1;
+        unsigned        retain_state_suspended : 1;
+        unsigned        default_state : 2;
+        /* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
 };
+#define LEDS_GPIO_DEFSTATE_OFF  0
+#define LEDS_GPIO_DEFSTATE_ON   1
+#define LEDS_GPIO_DEFSTATE_KEEP 2
 
 struct gpio_led_platform_data {
         int             num_leds;
diff --git a/include/linux/lguest.h b/include/linux/lguest.h
index 175e63f4a8c0..2fb1dcbcb5aa 100644
--- a/include/linux/lguest.h
+++ b/include/linux/lguest.h
@@ -1,5 +1,7 @@
-/* Things the lguest guest needs to know.  Note: like all lguest interfaces,
- * this is subject to wild and random change between versions. */
+/*
+ * Things the lguest guest needs to know.  Note: like all lguest interfaces,
+ * this is subject to wild and random change between versions.
+ */
 #ifndef _LINUX_LGUEST_H
 #define _LINUX_LGUEST_H
 
@@ -11,28 +13,41 @@
 #define LG_CLOCK_MIN_DELTA      100UL
 #define LG_CLOCK_MAX_DELTA      ULONG_MAX
 
-/*G:032 The second method of communicating with the Host is to via "struct
+/*G:031
+ * The second method of communicating with the Host is to via "struct
  * lguest_data".  Once the Guest's initialization hypercall tells the Host where
- * this is, the Guest and Host both publish information in it. :*/
-struct lguest_data
-{
-        /* 512 == enabled (same as eflags in normal hardware).  The Guest
-         * changes interrupts so often that a hypercall is too slow. */
+ * this is, the Guest and Host both publish information in it.
+:*/
+struct lguest_data {
+        /*
+         * 512 == enabled (same as eflags in normal hardware).  The Guest
+         * changes interrupts so often that a hypercall is too slow.
+         */
         unsigned int irq_enabled;
         /* Fine-grained interrupt disabling by the Guest */
         DECLARE_BITMAP(blocked_interrupts, LGUEST_IRQS);
 
-        /* The Host writes the virtual address of the last page fault here,
+        /*
+         * The Host writes the virtual address of the last page fault here,
          * which saves the Guest a hypercall.  CR2 is the native register where
-         * this address would normally be found. */
+         * this address would normally be found.
+         */
         unsigned long cr2;
 
         /* Wallclock time set by the Host. */
         struct timespec time;
 
-        /* Async hypercall ring.  Instead of directly making hypercalls, we can
+        /*
+         * Interrupt pending set by the Host.  The Guest should do a hypercall
+         * if it re-enables interrupts and sees this set (to X86_EFLAGS_IF).
+         */
+        int irq_pending;
+
+        /*
+         * Async hypercall ring.  Instead of directly making hypercalls, we can
          * place them in here for processing the next time the Host wants.
-         * This batching can be quite efficient. */
+         * This batching can be quite efficient.
+         */
 
         /* 0xFF == done (set by Host), 0 == pending (set by Guest). */
         u8 hcall_status[LHCALL_RING_SIZE];
diff --git a/include/linux/lguest_launcher.h b/include/linux/lguest_launcher.h
index a53407a4165c..495203ff221c 100644
--- a/include/linux/lguest_launcher.h
+++ b/include/linux/lguest_launcher.h
@@ -29,8 +29,10 @@ struct lguest_device_desc {
         __u8 type;
         /* The number of virtqueues (first in config array) */
         __u8 num_vq;
-        /* The number of bytes of feature bits.  Multiply by 2: one for host
-         * features and one for Guest acknowledgements. */
+        /*
+         * The number of bytes of feature bits.  Multiply by 2: one for host
+         * features and one for Guest acknowledgements.
+         */
         __u8 feature_len;
         /* The number of bytes of the config array after virtqueues. */
         __u8 config_len;
@@ -39,8 +41,10 @@ struct lguest_device_desc {
         __u8 config[0];
 };
 
-/*D:135 This is how we expect the device configuration field for a virtqueue
- * to be laid out in config space. */
+/*D:135
+ * This is how we expect the device configuration field for a virtqueue
+ * to be laid out in config space.
+ */
 struct lguest_vqconfig {
         /* The number of entries in the virtio_ring */
         __u16 num;
@@ -57,10 +61,13 @@ enum lguest_req
         LHREQ_INITIALIZE, /* + base, pfnlimit, start */
         LHREQ_GETDMA, /* No longer used */
         LHREQ_IRQ, /* + irq */
-        LHREQ_BREAK, /* + on/off flag (on blocks until someone does off) */
+        LHREQ_BREAK, /* No longer used */
+        LHREQ_EVENTFD, /* + address, fd. */
 };
 
-/* The alignment to use between consumer and producer parts of vring.
- * x86 pagesize for historical reasons. */
+/*
+ * The alignment to use between consumer and producer parts of vring.
+ * x86 pagesize for historical reasons.
+ */
 #define LGUEST_VRING_ALIGN      4096
 #endif /* _LINUX_LGUEST_LAUNCHER */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 3d501db36a26..e5b6e33c6571 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -385,6 +385,7 @@ enum {
                                                     not multiple of 16 bytes */
         ATA_HORKAGE_FIRMWARE_WARN = (1 << 12),  /* firmware update warning */
         ATA_HORKAGE_1_5_GBPS    = (1 << 13),    /* force 1.5 Gbps */
+        ATA_HORKAGE_NOSETXFER   = (1 << 14),    /* skip SETXFER, SATA only */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
@@ -588,6 +589,7 @@ struct ata_device {
 #endif
         /* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */
         u64                     n_sectors;      /* size of device, if ATA */
+        u64                     n_native_sectors; /* native size, if ATA */
         unsigned int            class;          /* ATA_DEV_xxx */
         unsigned long           unpark_deadline;
 
diff --git a/include/linux/linkage.h b/include/linux/linkage.h
index fee9e59649c1..691f59171c6c 100644
--- a/include/linux/linkage.h
+++ b/include/linux/linkage.h
@@ -22,6 +22,15 @@
 #define __page_aligned_bss      __section(.bss.page_aligned) __aligned(PAGE_SIZE)
 
 /*
+ * For assembly routines.
+ *
+ * Note when using these that you must specify the appropriate
+ * alignment directives yourself
+ */
+#define __PAGE_ALIGNED_DATA     .section ".data.page_aligned", "aw"
+#define __PAGE_ALIGNED_BSS      .section ".bss.page_aligned", "aw"
+
+/*
  * This is used by architectures to keep arguments on the stack
  * untouched by the compiler by keeping them live until the end.
  * The argument stack may be owned by the assembly-language
diff --git a/include/linux/linux_logo.h b/include/linux/linux_logo.h
index 08a92969c76e..ca5bd91d12e1 100644
--- a/include/linux/linux_logo.h
+++ b/include/linux/linux_logo.h
@@ -32,6 +32,22 @@ struct linux_logo {
         const unsigned char *data;
 };
 
+extern const struct linux_logo logo_linux_mono;
+extern const struct linux_logo logo_linux_vga16;
+extern const struct linux_logo logo_linux_clut224;
+extern const struct linux_logo logo_blackfin_vga16;
+extern const struct linux_logo logo_blackfin_clut224;
+extern const struct linux_logo logo_dec_clut224;
+extern const struct linux_logo logo_mac_clut224;
+extern const struct linux_logo logo_parisc_clut224;
+extern const struct linux_logo logo_sgi_clut224;
+extern const struct linux_logo logo_sun_clut224;
+extern const struct linux_logo logo_superh_mono;
+extern const struct linux_logo logo_superh_vga16;
+extern const struct linux_logo logo_superh_clut224;
+extern const struct linux_logo logo_m32r_clut224;
+extern const struct linux_logo logo_spe_clut224;
+
 extern const struct linux_logo *fb_find_logo(int depth);
 #ifdef CONFIG_FB_LOGO_EXTRA
 extern void fb_append_extra_logo(const struct linux_logo *logo,
diff --git a/include/linux/lis3lv02d.h b/include/linux/lis3lv02d.h
new file mode 100644
index 000000000000..ad651f4e45ac
--- /dev/null
+++ b/include/linux/lis3lv02d.h
@@ -0,0 +1,39 @@
+#ifndef __LIS3LV02D_H_
+#define __LIS3LV02D_H_
+
+struct lis3lv02d_platform_data {
+        /* please note: the 'click' feature is only supported for
+         * LIS[32]02DL variants of the chip and will be ignored for
+         * others */
+#define LIS3_CLICK_SINGLE_X     (1 << 0)
+#define LIS3_CLICK_DOUBLE_X     (1 << 1)
+#define LIS3_CLICK_SINGLE_Y     (1 << 2)
+#define LIS3_CLICK_DOUBLE_Y     (1 << 3)
+#define LIS3_CLICK_SINGLE_Z     (1 << 4)
+#define LIS3_CLICK_DOUBLE_Z     (1 << 5)
+        unsigned char click_flags;
+        unsigned char click_thresh_x;
+        unsigned char click_thresh_y;
+        unsigned char click_thresh_z;
+        unsigned char click_time_limit;
+        unsigned char click_latency;
+        unsigned char click_window;
+
+#define LIS3_IRQ1_DISABLE       (0 << 0)
+#define LIS3_IRQ1_FF_WU_1       (1 << 0)
+#define LIS3_IRQ1_FF_WU_2       (2 << 0)
+#define LIS3_IRQ1_FF_WU_12      (3 << 0)
+#define LIS3_IRQ1_DATA_READY    (4 << 0)
+#define LIS3_IRQ1_CLICK         (7 << 0)
+#define LIS3_IRQ2_DISABLE       (0 << 3)
+#define LIS3_IRQ2_FF_WU_1       (1 << 3)
+#define LIS3_IRQ2_FF_WU_2       (2 << 3)
+#define LIS3_IRQ2_FF_WU_12      (3 << 3)
+#define LIS3_IRQ2_DATA_READY    (4 << 3)
+#define LIS3_IRQ2_CLICK         (7 << 3)
+#define LIS3_IRQ_OPEN_DRAIN     (1 << 6)
+#define LIS3_IRQ_ACTIVE_HIGH    (1 << 7)
+        unsigned char irq_cfg;
+};
+
+#endif /* __LIS3LV02D_H_ */
diff --git a/include/linux/list_nulls.h b/include/linux/list_nulls.h
index 93150ecf3ea4..5d10ae364b5e 100644
--- a/include/linux/list_nulls.h
+++ b/include/linux/list_nulls.h
@@ -56,6 +56,18 @@ static inline int hlist_nulls_empty(const struct hlist_nulls_head *h)
         return is_a_nulls(h->first);
 }
 
+static inline void hlist_nulls_add_head(struct hlist_nulls_node *n,
+                                        struct hlist_nulls_head *h)
+{
+        struct hlist_nulls_node *first = h->first;
+
+        n->next = first;
+        n->pprev = &h->first;
+        h->first = n;
+        if (!is_a_nulls(first))
+                first->pprev = &n->next;
+}
+
 static inline void __hlist_nulls_del(struct hlist_nulls_node *n)
 {
         struct hlist_nulls_node *next = n->next;
@@ -65,6 +77,12 @@ static inline void __hlist_nulls_del(struct hlist_nulls_node *n)
                 next->pprev = pprev;
 }
 
+static inline void hlist_nulls_del(struct hlist_nulls_node *n)
+{
+        __hlist_nulls_del(n);
+        n->pprev = LIST_POISON2;
+}
+
 /**
  * hlist_nulls_for_each_entry   - iterate over list of given type
  * @tpos:       the type * to use as a loop cursor.
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index 51855dfd8adb..c325b187966b 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -195,7 +195,7 @@ extern struct svc_procedure	nlmsvc_procedures4[];
 extern int                      nlmsvc_grace_period;
 extern unsigned long            nlmsvc_timeout;
 extern int                      nsm_use_hostnames;
-extern int                      nsm_local_state;
+extern u32                      nsm_local_state;
 
 /*
  * Lockd client functions
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index da5a5a1f4cd2..b25d1b53df0d 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -258,6 +258,16 @@ extern void lockdep_init_map(struct lockdep_map *lock, const char *name,
 #define lockdep_set_subclass(lock, sub) \
                 lockdep_init_map(&(lock)->dep_map, #lock, \
                                  (lock)->dep_map.key, sub)
+/*
+ * Compare locking classes
+ */
+#define lockdep_match_class(lock, key) lockdep_match_key(&(lock)->dep_map, key)
+
+static inline int lockdep_match_key(struct lockdep_map *lock,
+                                    struct lock_class_key *key)
+{
+        return lock->key == key;
+}
 
 /*
  * Acquire a lock.
@@ -326,6 +336,11 @@ static inline void lockdep_on(void)
 #define lockdep_set_class_and_subclass(lock, key, sub) \
                 do { (void)(key); } while (0)
 #define lockdep_set_subclass(lock, sub)         do { } while (0)
+/*
+ * We don't define lockdep_match_class() and lockdep_match_key() for !LOCKDEP
+ * case since the result is not well defined and the caller should rather
+ * #ifdef the call himself.
+ */
 
 # define INIT_LOCKDEP
 # define lockdep_reset()                do { debug_locks = 1; } while (0)
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 40725447f5e0..66c194e2d9b9 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -56,8 +56,7 @@ struct loop_device {
         gfp_t           old_gfp_mask;
 
         spinlock_t              lo_lock;
-        struct bio              *lo_bio;
-        struct bio              *lo_biotail;
+        struct bio_list         lo_bio_list;
         int                     lo_state;
         struct mutex            lo_ctl_mutex;
         struct task_struct      *lo_thread;
diff --git a/include/linux/lsm_audit.h b/include/linux/lsm_audit.h
new file mode 100644
index 000000000000..e461b2c3d711
--- /dev/null
+++ b/include/linux/lsm_audit.h
@@ -0,0 +1,111 @@
+/*
+ * Common LSM logging functions
+ * Heavily borrowed from selinux/avc.h
+ *
+ * Author : Etienne BASSET  <etienne.basset@ensta.org>
+ *
+ * All credits to : Stephen Smalley, <sds@epoch.ncsc.mil>
+ * All BUGS to : Etienne BASSET  <etienne.basset@ensta.org>
+ */
+#ifndef _LSM_COMMON_LOGGING_
+#define _LSM_COMMON_LOGGING_
+
+#include <linux/stddef.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/kdev_t.h>
+#include <linux/spinlock.h>
+#include <linux/init.h>
+#include <linux/audit.h>
+#include <linux/in6.h>
+#include <linux/path.h>
+#include <linux/key.h>
+#include <linux/skbuff.h>
+#include <asm/system.h>
+
+
+/* Auxiliary data to use in generating the audit record. */
+struct common_audit_data {
+        char    type;
+#define LSM_AUDIT_DATA_FS      1
+#define LSM_AUDIT_DATA_NET     2
+#define LSM_AUDIT_DATA_CAP     3
+#define LSM_AUDIT_DATA_IPC     4
+#define LSM_AUDIT_DATA_TASK    5
+#define LSM_AUDIT_DATA_KEY     6
+        struct task_struct *tsk;
+        union   {
+                struct {
+                        struct path path;
+                        struct inode *inode;
+                } fs;
+                struct {
+                        int netif;
+                        struct sock *sk;
+                        u16 family;
+                        __be16 dport;
+                        __be16 sport;
+                        union {
+                                struct {
+                                        __be32 daddr;
+                                        __be32 saddr;
+                                } v4;
+                                struct {
+                                        struct in6_addr daddr;
+                                        struct in6_addr saddr;
+                                } v6;
+                        } fam;
+                } net;
+                int cap;
+                int ipc_id;
+                struct task_struct *tsk;
+#ifdef CONFIG_KEYS
+                struct {
+                        key_serial_t key;
+                        char *key_desc;
+                } key_struct;
+#endif
+        } u;
+        const char *function;
+        /* this union contains LSM specific data */
+        union {
+                /* SMACK data */
+                struct smack_audit_data {
+                        char *subject;
+                        char *object;
+                        char *request;
+                        int result;
+                } smack_audit_data;
+                /* SELinux data */
+                struct {
+                        u32 ssid;
+                        u32 tsid;
+                        u16 tclass;
+                        u32 requested;
+                        u32 audited;
+                        struct av_decision *avd;
+                        int result;
+                } selinux_audit_data;
+        } lsm_priv;
+        /* these callback will be implemented by a specific LSM */
+        void (*lsm_pre_audit)(struct audit_buffer *, void *);
+        void (*lsm_post_audit)(struct audit_buffer *, void *);
+};
+
+#define v4info fam.v4
+#define v6info fam.v6
+
+int ipv4_skb_to_auditdata(struct sk_buff *skb,
+                struct common_audit_data *ad, u8 *proto);
+
+int ipv6_skb_to_auditdata(struct sk_buff *skb,
+                struct common_audit_data *ad, u8 *proto);
+
+/* Initialize an LSM audit data structure. */
+#define COMMON_AUDIT_DATA_INIT(_d, _t) \
+        { memset((_d), 0, sizeof(struct common_audit_data)); \
+         (_d)->type = LSM_AUDIT_DATA_##_t; (_d)->function = __func__; }
+
+void common_lsm_audit(struct common_audit_data *a);
+
+#endif
diff --git a/include/linux/mISDNdsp.h b/include/linux/mISDNdsp.h
index 6b71d2dce508..41d1eeb9b3bd 100644
--- a/include/linux/mISDNdsp.h
+++ b/include/linux/mISDNdsp.h
@@ -12,7 +12,8 @@ struct mISDN_dsp_element {
         void    *(*new)(const char *arg);
         void    (*free)(void *p);
         void    (*process_tx)(void *p, unsigned char *data, int len);
-        void    (*process_rx)(void *p, unsigned char *data, int len);
+        void    (*process_rx)(void *p, unsigned char *data, int len,
+                        unsigned int txlen);
         int     num_args;
         struct mISDN_dsp_element_arg
                 *args;
@@ -24,6 +25,7 @@ extern void mISDN_dsp_element_unregister(struct mISDN_dsp_element *elem);
 struct dsp_features {
         int     hfc_id; /* unique id to identify the chip (or -1) */
         int     hfc_dtmf; /* set if HFCmulti card supports dtmf */
+        int     hfc_conf; /* set if HFCmulti card supports conferences */
         int     hfc_loops; /* set if card supports tone loops */
         int     hfc_echocanhw; /* set if card supports echocancelation*/
         int     pcm_id; /* unique id to identify the pcm bus (or -1) */
diff --git a/include/linux/mISDNhw.h b/include/linux/mISDNhw.h
index 97ffdc1d3442..7f9831da847f 100644
--- a/include/linux/mISDNhw.h
+++ b/include/linux/mISDNhw.h
@@ -89,11 +89,6 @@ struct dchannel {
         void                    (*phfunc) (struct dchannel *);
         u_int                   state;
         void                    *l1;
-        /* HW access */
-        u_char                  (*read_reg) (void *, u_char);
-        void                    (*write_reg) (void *, u_char, u_char);
-        void                    (*read_fifo) (void *, u_char *, int);
-        void                    (*write_fifo) (void *, u_char *, int);
         void                    *hw;
         int                     slot;   /* multiport card channel slot */
         struct timer_list       timer;
@@ -151,11 +146,6 @@ struct bchannel {
         u_long                  Flags;
         struct work_struct      workq;
         u_int                   state;
-        /* HW access */
-        u_char                  (*read_reg) (void *, u_char);
-        void                    (*write_reg) (void *, u_char, u_char);
-        void                    (*read_fifo) (void *, u_char *, int);
-        void                    (*write_fifo) (void *, u_char *, int);
         void                    *hw;
         int                     slot;   /* multiport card channel slot */
         struct timer_list       timer;
@@ -185,7 +175,7 @@ extern int	dchannel_senddata(struct dchannel *, struct sk_buff *);
 extern int      bchannel_senddata(struct bchannel *, struct sk_buff *);
 extern void     recv_Dchannel(struct dchannel *);
 extern void     recv_Echannel(struct dchannel *, struct dchannel *);
-extern void     recv_Bchannel(struct bchannel *);
+extern void     recv_Bchannel(struct bchannel *, unsigned int id);
 extern void     recv_Dchannel_skb(struct dchannel *, struct sk_buff *);
 extern void     recv_Bchannel_skb(struct bchannel *, struct sk_buff *);
 extern void     confirm_Bsend(struct bchannel *bch);
diff --git a/include/linux/mISDNif.h b/include/linux/mISDNif.h
index 5da3d95b27f1..45100b39a7cf 100644
--- a/include/linux/mISDNif.h
+++ b/include/linux/mISDNif.h
@@ -229,6 +229,7 @@
 #define OPTION_L2_PTP           2
 #define OPTION_L2_FIXEDTEI      3
 #define OPTION_L2_CLEANUP       4
+#define OPTION_L1_HOLD          5
 
 /* should be in sync with linux/kobject.h:KOBJ_NAME_LEN */
 #define MISDN_MAX_IDLEN         20
@@ -291,19 +292,19 @@ struct mISDN_devrename {
 
 /* MPH_INFORMATION_REQ payload */
 struct ph_info_ch {
-        __u32 protocol;
-        __u64 Flags;
+        __u32 protocol;
+        __u64 Flags;
 };
 
 struct ph_info_dch {
-        struct ph_info_ch ch;
-        __u16 state;
-        __u16 num_bch;
+        struct ph_info_ch ch;
+        __u16 state;
+        __u16 num_bch;
 };
 
 struct ph_info {
-        struct ph_info_dch dch;
-        struct ph_info_ch  bch[];
+        struct ph_info_dch dch;
+        struct ph_info_ch  bch[];
 };
 
 /* timer device ioctl */
@@ -317,6 +318,7 @@ struct ph_info {
 #define IMCTRLREQ       _IOR('I', 69, int)
 #define IMCLEAR_L2      _IOR('I', 70, int)
 #define IMSETDEVNAME    _IOR('I', 71, struct mISDN_devrename)
+#define IMHOLD_L1       _IOR('I', 72, int)
 
 static inline int
 test_channelmap(u_int nr, u_char *map)
@@ -362,7 +364,8 @@ clear_channelmap(u_int nr, u_char *map)
 #define MISDN_CTRL_HFC_RECEIVE_ON       0x4006
 #define MISDN_CTRL_HFC_ECHOCAN_ON       0x4007
 #define MISDN_CTRL_HFC_ECHOCAN_OFF      0x4008
-
+#define MISDN_CTRL_HFC_WD_INIT          0x4009
+#define MISDN_CTRL_HFC_WD_RESET         0x400A
 
 /* socket options */
 #define MISDN_TIME_STAMP                0x0001
diff --git a/include/linux/magic.h b/include/linux/magic.h
index 5b4e28bcb788..1923327b9869 100644
--- a/include/linux/magic.h
+++ b/include/linux/magic.h
@@ -6,9 +6,12 @@
 #define AFS_SUPER_MAGIC                0x5346414F
 #define AUTOFS_SUPER_MAGIC      0x0187
 #define CODA_SUPER_MAGIC        0x73757245
+#define CRAMFS_MAGIC            0x28cd3d45      /* some random number */
+#define CRAMFS_MAGIC_WEND       0x453dcd28      /* magic number with the wrong endianess */
 #define DEBUGFS_MAGIC          0x64626720
 #define SYSFS_MAGIC             0x62656572
 #define SECURITYFS_MAGIC        0x73636673
+#define SELINUX_MAGIC           0xf97cff8c
 #define TMPFS_MAGIC             0x01021994
 #define SQUASHFS_MAGIC          0x73717368
 #define EFS_SUPER_MAGIC         0x414A53
diff --git a/include/linux/major.h b/include/linux/major.h
index 058ec15dd060..6a8ca98c9a96 100644
--- a/include/linux/major.h
+++ b/include/linux/major.h
@@ -145,6 +145,7 @@
 #define UNIX98_PTY_MAJOR_COUNT  8
 #define UNIX98_PTY_SLAVE_MAJOR  (UNIX98_PTY_MASTER_MAJOR+UNIX98_PTY_MAJOR_COUNT)
 
+#define DRBD_MAJOR              147
 #define RTF_MAJOR               150
 #define RAW_MAJOR               162
 
diff --git a/include/linux/max17040_battery.h b/include/linux/max17040_battery.h
new file mode 100644
index 000000000000..ad97b06cf930
--- /dev/null
+++ b/include/linux/max17040_battery.h
@@ -0,0 +1,19 @@
+/*
+ *  Copyright (C) 2009 Samsung Electronics
+ *  Minkyu Kang <mk7.kang@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __MAX17040_BATTERY_H_
+#define __MAX17040_BATTERY_H_
+
+struct max17040_platform_data {
+        int (*battery_online)(void);
+        int (*charger_online)(void);
+        int (*charger_enable)(void);
+};
+
+#endif
diff --git a/include/linux/mdio.h b/include/linux/mdio.h
new file mode 100644
index 000000000000..cfdf1df2875e
--- /dev/null
+++ b/include/linux/mdio.h
@@ -0,0 +1,356 @@
+/*
+ * linux/mdio.h: definitions for MDIO (clause 45) transceivers
+ * Copyright 2006-2009 Solarflare Communications 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, incorporated herein by reference.
+ */
+
+#ifndef __LINUX_MDIO_H__
+#define __LINUX_MDIO_H__
+
+#include <linux/mii.h>
+
+/* MDIO Manageable Devices (MMDs). */
+#define MDIO_MMD_PMAPMD         1       /* Physical Medium Attachment/
+                                         * Physical Medium Dependent */
+#define MDIO_MMD_WIS            2       /* WAN Interface Sublayer */
+#define MDIO_MMD_PCS            3       /* Physical Coding Sublayer */
+#define MDIO_MMD_PHYXS          4       /* PHY Extender Sublayer */
+#define MDIO_MMD_DTEXS          5       /* DTE Extender Sublayer */
+#define MDIO_MMD_TC             6       /* Transmission Convergence */
+#define MDIO_MMD_AN             7       /* Auto-Negotiation */
+#define MDIO_MMD_C22EXT         29      /* Clause 22 extension */
+#define MDIO_MMD_VEND1          30      /* Vendor specific 1 */
+#define MDIO_MMD_VEND2          31      /* Vendor specific 2 */
+
+/* Generic MDIO registers. */
+#define MDIO_CTRL1              MII_BMCR
+#define MDIO_STAT1              MII_BMSR
+#define MDIO_DEVID1             MII_PHYSID1
+#define MDIO_DEVID2             MII_PHYSID2
+#define MDIO_SPEED              4       /* Speed ability */
+#define MDIO_DEVS1              5       /* Devices in package */
+#define MDIO_DEVS2              6
+#define MDIO_CTRL2              7       /* 10G control 2 */
+#define MDIO_STAT2              8       /* 10G status 2 */
+#define MDIO_PMA_TXDIS          9       /* 10G PMA/PMD transmit disable */
+#define MDIO_PMA_RXDET          10      /* 10G PMA/PMD receive signal detect */
+#define MDIO_PMA_EXTABLE        11      /* 10G PMA/PMD extended ability */
+#define MDIO_PKGID1             14      /* Package identifier */
+#define MDIO_PKGID2             15
+#define MDIO_AN_ADVERTISE       16      /* AN advertising (base page) */
+#define MDIO_AN_LPA             19      /* AN LP abilities (base page) */
+#define MDIO_PHYXS_LNSTAT       24      /* PHY XGXS lane state */
+
+/* Media-dependent registers. */
+#define MDIO_PMA_10GBT_SWAPPOL  130     /* 10GBASE-T pair swap & polarity */
+#define MDIO_PMA_10GBT_TXPWR    131     /* 10GBASE-T TX power control */
+#define MDIO_PMA_10GBT_SNR      133     /* 10GBASE-T SNR margin, lane A.
+                                         * Lanes B-D are numbered 134-136. */
+#define MDIO_PMA_10GBR_FECABLE  170     /* 10GBASE-R FEC ability */
+#define MDIO_PCS_10GBX_STAT1    24      /* 10GBASE-X PCS status 1 */
+#define MDIO_PCS_10GBRT_STAT1   32      /* 10GBASE-R/-T PCS status 1 */
+#define MDIO_PCS_10GBRT_STAT2   33      /* 10GBASE-R/-T PCS status 2 */
+#define MDIO_AN_10GBT_CTRL      32      /* 10GBASE-T auto-negotiation control */
+#define MDIO_AN_10GBT_STAT      33      /* 10GBASE-T auto-negotiation status */
+
+/* LASI (Link Alarm Status Interrupt) registers, defined by XENPAK MSA. */
+#define MDIO_PMA_LASI_RXCTRL    0x9000  /* RX_ALARM control */
+#define MDIO_PMA_LASI_TXCTRL    0x9001  /* TX_ALARM control */
+#define MDIO_PMA_LASI_CTRL      0x9002  /* LASI control */
+#define MDIO_PMA_LASI_RXSTAT    0x9003  /* RX_ALARM status */
+#define MDIO_PMA_LASI_TXSTAT    0x9004  /* TX_ALARM status */
+#define MDIO_PMA_LASI_STAT      0x9005  /* LASI status */
+
+/* Control register 1. */
+/* Enable extended speed selection */
+#define MDIO_CTRL1_SPEEDSELEXT          (BMCR_SPEED1000 | BMCR_SPEED100)
+/* All speed selection bits */
+#define MDIO_CTRL1_SPEEDSEL             (MDIO_CTRL1_SPEEDSELEXT | 0x003c)
+#define MDIO_CTRL1_FULLDPLX             BMCR_FULLDPLX
+#define MDIO_CTRL1_LPOWER               BMCR_PDOWN
+#define MDIO_CTRL1_RESET                BMCR_RESET
+#define MDIO_PMA_CTRL1_LOOPBACK         0x0001
+#define MDIO_PMA_CTRL1_SPEED1000        BMCR_SPEED1000
+#define MDIO_PMA_CTRL1_SPEED100         BMCR_SPEED100
+#define MDIO_PCS_CTRL1_LOOPBACK         BMCR_LOOPBACK
+#define MDIO_PHYXS_CTRL1_LOOPBACK       BMCR_LOOPBACK
+#define MDIO_AN_CTRL1_RESTART           BMCR_ANRESTART
+#define MDIO_AN_CTRL1_ENABLE            BMCR_ANENABLE
+#define MDIO_AN_CTRL1_XNP               0x2000  /* Enable extended next page */
+
+/* 10 Gb/s */
+#define MDIO_CTRL1_SPEED10G             (MDIO_CTRL1_SPEEDSELEXT | 0x00)
+/* 10PASS-TS/2BASE-TL */
+#define MDIO_CTRL1_SPEED10P2B           (MDIO_CTRL1_SPEEDSELEXT | 0x04)
+
+/* Status register 1. */
+#define MDIO_STAT1_LPOWERABLE           0x0002  /* Low-power ability */
+#define MDIO_STAT1_LSTATUS              BMSR_LSTATUS
+#define MDIO_STAT1_FAULT                0x0080  /* Fault */
+#define MDIO_AN_STAT1_LPABLE            0x0001  /* Link partner AN ability */
+#define MDIO_AN_STAT1_ABLE              BMSR_ANEGCAPABLE
+#define MDIO_AN_STAT1_RFAULT            BMSR_RFAULT
+#define MDIO_AN_STAT1_COMPLETE          BMSR_ANEGCOMPLETE
+#define MDIO_AN_STAT1_PAGE              0x0040  /* Page received */
+#define MDIO_AN_STAT1_XNP               0x0080  /* Extended next page status */
+
+/* Speed register. */
+#define MDIO_SPEED_10G                  0x0001  /* 10G capable */
+#define MDIO_PMA_SPEED_2B               0x0002  /* 2BASE-TL capable */
+#define MDIO_PMA_SPEED_10P              0x0004  /* 10PASS-TS capable */
+#define MDIO_PMA_SPEED_1000             0x0010  /* 1000M capable */
+#define MDIO_PMA_SPEED_100              0x0020  /* 100M capable */
+#define MDIO_PMA_SPEED_10               0x0040  /* 10M capable */
+#define MDIO_PCS_SPEED_10P2B            0x0002  /* 10PASS-TS/2BASE-TL capable */
+
+/* Device present registers. */
+#define MDIO_DEVS_PRESENT(devad)        (1 << (devad))
+#define MDIO_DEVS_PMAPMD                MDIO_DEVS_PRESENT(MDIO_MMD_PMAPMD)
+#define MDIO_DEVS_WIS                   MDIO_DEVS_PRESENT(MDIO_MMD_WIS)
+#define MDIO_DEVS_PCS                   MDIO_DEVS_PRESENT(MDIO_MMD_PCS)
+#define MDIO_DEVS_PHYXS                 MDIO_DEVS_PRESENT(MDIO_MMD_PHYXS)
+#define MDIO_DEVS_DTEXS                 MDIO_DEVS_PRESENT(MDIO_MMD_DTEXS)
+#define MDIO_DEVS_TC                    MDIO_DEVS_PRESENT(MDIO_MMD_TC)
+#define MDIO_DEVS_AN                    MDIO_DEVS_PRESENT(MDIO_MMD_AN)
+#define MDIO_DEVS_C22EXT                MDIO_DEVS_PRESENT(MDIO_MMD_C22EXT)
+
+/* Control register 2. */
+#define MDIO_PMA_CTRL2_TYPE             0x000f  /* PMA/PMD type selection */
+#define MDIO_PMA_CTRL2_10GBCX4          0x0000  /* 10GBASE-CX4 type */
+#define MDIO_PMA_CTRL2_10GBEW           0x0001  /* 10GBASE-EW type */
+#define MDIO_PMA_CTRL2_10GBLW           0x0002  /* 10GBASE-LW type */
+#define MDIO_PMA_CTRL2_10GBSW           0x0003  /* 10GBASE-SW type */
+#define MDIO_PMA_CTRL2_10GBLX4          0x0004  /* 10GBASE-LX4 type */
+#define MDIO_PMA_CTRL2_10GBER           0x0005  /* 10GBASE-ER type */
+#define MDIO_PMA_CTRL2_10GBLR           0x0006  /* 10GBASE-LR type */
+#define MDIO_PMA_CTRL2_10GBSR           0x0007  /* 10GBASE-SR type */
+#define MDIO_PMA_CTRL2_10GBLRM          0x0008  /* 10GBASE-LRM type */
+#define MDIO_PMA_CTRL2_10GBT            0x0009  /* 10GBASE-T type */
+#define MDIO_PMA_CTRL2_10GBKX4          0x000a  /* 10GBASE-KX4 type */
+#define MDIO_PMA_CTRL2_10GBKR           0x000b  /* 10GBASE-KR type */
+#define MDIO_PMA_CTRL2_1000BT           0x000c  /* 1000BASE-T type */
+#define MDIO_PMA_CTRL2_1000BKX          0x000d  /* 1000BASE-KX type */
+#define MDIO_PMA_CTRL2_100BTX           0x000e  /* 100BASE-TX type */
+#define MDIO_PMA_CTRL2_10BT             0x000f  /* 10BASE-T type */
+#define MDIO_PCS_CTRL2_TYPE             0x0003  /* PCS type selection */
+#define MDIO_PCS_CTRL2_10GBR            0x0000  /* 10GBASE-R type */
+#define MDIO_PCS_CTRL2_10GBX            0x0001  /* 10GBASE-X type */
+#define MDIO_PCS_CTRL2_10GBW            0x0002  /* 10GBASE-W type */
+#define MDIO_PCS_CTRL2_10GBT            0x0003  /* 10GBASE-T type */
+
+/* Status register 2. */
+#define MDIO_STAT2_RXFAULT              0x0400  /* Receive fault */
+#define MDIO_STAT2_TXFAULT              0x0800  /* Transmit fault */
+#define MDIO_STAT2_DEVPRST              0xc000  /* Device present */
+#define MDIO_STAT2_DEVPRST_VAL          0x8000  /* Device present value */
+#define MDIO_PMA_STAT2_LBABLE           0x0001  /* PMA loopback ability */
+#define MDIO_PMA_STAT2_10GBEW           0x0002  /* 10GBASE-EW ability */
+#define MDIO_PMA_STAT2_10GBLW           0x0004  /* 10GBASE-LW ability */
+#define MDIO_PMA_STAT2_10GBSW           0x0008  /* 10GBASE-SW ability */
+#define MDIO_PMA_STAT2_10GBLX4          0x0010  /* 10GBASE-LX4 ability */
+#define MDIO_PMA_STAT2_10GBER           0x0020  /* 10GBASE-ER ability */
+#define MDIO_PMA_STAT2_10GBLR           0x0040  /* 10GBASE-LR ability */
+#define MDIO_PMA_STAT2_10GBSR           0x0080  /* 10GBASE-SR ability */
+#define MDIO_PMD_STAT2_TXDISAB          0x0100  /* PMD TX disable ability */
+#define MDIO_PMA_STAT2_EXTABLE          0x0200  /* Extended abilities */
+#define MDIO_PMA_STAT2_RXFLTABLE        0x1000  /* Receive fault ability */
+#define MDIO_PMA_STAT2_TXFLTABLE        0x2000  /* Transmit fault ability */
+#define MDIO_PCS_STAT2_10GBR            0x0001  /* 10GBASE-R capable */
+#define MDIO_PCS_STAT2_10GBX            0x0002  /* 10GBASE-X capable */
+#define MDIO_PCS_STAT2_10GBW            0x0004  /* 10GBASE-W capable */
+#define MDIO_PCS_STAT2_RXFLTABLE        0x1000  /* Receive fault ability */
+#define MDIO_PCS_STAT2_TXFLTABLE        0x2000  /* Transmit fault ability */
+
+/* Transmit disable register. */
+#define MDIO_PMD_TXDIS_GLOBAL           0x0001  /* Global PMD TX disable */
+#define MDIO_PMD_TXDIS_0                0x0002  /* PMD TX disable 0 */
+#define MDIO_PMD_TXDIS_1                0x0004  /* PMD TX disable 1 */
+#define MDIO_PMD_TXDIS_2                0x0008  /* PMD TX disable 2 */
+#define MDIO_PMD_TXDIS_3                0x0010  /* PMD TX disable 3 */
+
+/* Receive signal detect register. */
+#define MDIO_PMD_RXDET_GLOBAL           0x0001  /* Global PMD RX signal detect */
+#define MDIO_PMD_RXDET_0                0x0002  /* PMD RX signal detect 0 */
+#define MDIO_PMD_RXDET_1                0x0004  /* PMD RX signal detect 1 */
+#define MDIO_PMD_RXDET_2                0x0008  /* PMD RX signal detect 2 */
+#define MDIO_PMD_RXDET_3                0x0010  /* PMD RX signal detect 3 */
+
+/* Extended abilities register. */
+#define MDIO_PMA_EXTABLE_10GCX4         0x0001  /* 10GBASE-CX4 ability */
+#define MDIO_PMA_EXTABLE_10GBLRM        0x0002  /* 10GBASE-LRM ability */
+#define MDIO_PMA_EXTABLE_10GBT          0x0004  /* 10GBASE-T ability */
+#define MDIO_PMA_EXTABLE_10GBKX4        0x0008  /* 10GBASE-KX4 ability */
+#define MDIO_PMA_EXTABLE_10GBKR         0x0010  /* 10GBASE-KR ability */
+#define MDIO_PMA_EXTABLE_1000BT         0x0020  /* 1000BASE-T ability */
+#define MDIO_PMA_EXTABLE_1000BKX        0x0040  /* 1000BASE-KX ability */
+#define MDIO_PMA_EXTABLE_100BTX         0x0080  /* 100BASE-TX ability */
+#define MDIO_PMA_EXTABLE_10BT           0x0100  /* 10BASE-T ability */
+
+/* PHY XGXS lane state register. */
+#define MDIO_PHYXS_LNSTAT_SYNC0         0x0001
+#define MDIO_PHYXS_LNSTAT_SYNC1         0x0002
+#define MDIO_PHYXS_LNSTAT_SYNC2         0x0004
+#define MDIO_PHYXS_LNSTAT_SYNC3         0x0008
+#define MDIO_PHYXS_LNSTAT_ALIGN         0x1000
+
+/* PMA 10GBASE-T pair swap & polarity */
+#define MDIO_PMA_10GBT_SWAPPOL_ABNX     0x0001  /* Pair A/B uncrossed */
+#define MDIO_PMA_10GBT_SWAPPOL_CDNX     0x0002  /* Pair C/D uncrossed */
+#define MDIO_PMA_10GBT_SWAPPOL_AREV     0x0100  /* Pair A polarity reversed */
+#define MDIO_PMA_10GBT_SWAPPOL_BREV     0x0200  /* Pair B polarity reversed */
+#define MDIO_PMA_10GBT_SWAPPOL_CREV     0x0400  /* Pair C polarity reversed */
+#define MDIO_PMA_10GBT_SWAPPOL_DREV     0x0800  /* Pair D polarity reversed */
+
+/* PMA 10GBASE-T TX power register. */
+#define MDIO_PMA_10GBT_TXPWR_SHORT      0x0001  /* Short-reach mode */
+
+/* PMA 10GBASE-T SNR registers. */
+/* Value is SNR margin in dB, clamped to range [-127, 127], plus 0x8000. */
+#define MDIO_PMA_10GBT_SNR_BIAS         0x8000
+#define MDIO_PMA_10GBT_SNR_MAX          127
+
+/* PMA 10GBASE-R FEC ability register. */
+#define MDIO_PMA_10GBR_FECABLE_ABLE     0x0001  /* FEC ability */
+#define MDIO_PMA_10GBR_FECABLE_ERRABLE  0x0002  /* FEC error indic. ability */
+
+/* PCS 10GBASE-R/-T status register 1. */
+#define MDIO_PCS_10GBRT_STAT1_BLKLK     0x0001  /* Block lock attained */
+
+/* PCS 10GBASE-R/-T status register 2. */
+#define MDIO_PCS_10GBRT_STAT2_ERR       0x00ff
+#define MDIO_PCS_10GBRT_STAT2_BER       0x3f00
+
+/* AN 10GBASE-T control register. */
+#define MDIO_AN_10GBT_CTRL_ADV10G       0x1000  /* Advertise 10GBASE-T */
+
+/* AN 10GBASE-T status register. */
+#define MDIO_AN_10GBT_STAT_LPTRR        0x0200  /* LP training reset req. */
+#define MDIO_AN_10GBT_STAT_LPLTABLE     0x0400  /* LP loop timing ability */
+#define MDIO_AN_10GBT_STAT_LP10G        0x0800  /* LP is 10GBT capable */
+#define MDIO_AN_10GBT_STAT_REMOK        0x1000  /* Remote OK */
+#define MDIO_AN_10GBT_STAT_LOCOK        0x2000  /* Local OK */
+#define MDIO_AN_10GBT_STAT_MS           0x4000  /* Master/slave config */
+#define MDIO_AN_10GBT_STAT_MSFLT        0x8000  /* Master/slave config fault */
+
+/* LASI RX_ALARM control/status registers. */
+#define MDIO_PMA_LASI_RX_PHYXSLFLT      0x0001  /* PHY XS RX local fault */
+#define MDIO_PMA_LASI_RX_PCSLFLT        0x0008  /* PCS RX local fault */
+#define MDIO_PMA_LASI_RX_PMALFLT        0x0010  /* PMA/PMD RX local fault */
+#define MDIO_PMA_LASI_RX_OPTICPOWERFLT  0x0020  /* RX optical power fault */
+#define MDIO_PMA_LASI_RX_WISLFLT        0x0200  /* WIS local fault */
+
+/* LASI TX_ALARM control/status registers. */
+#define MDIO_PMA_LASI_TX_PHYXSLFLT      0x0001  /* PHY XS TX local fault */
+#define MDIO_PMA_LASI_TX_PCSLFLT        0x0008  /* PCS TX local fault */
+#define MDIO_PMA_LASI_TX_PMALFLT        0x0010  /* PMA/PMD TX local fault */
+#define MDIO_PMA_LASI_TX_LASERPOWERFLT  0x0080  /* Laser output power fault */
+#define MDIO_PMA_LASI_TX_LASERTEMPFLT   0x0100  /* Laser temperature fault */
+#define MDIO_PMA_LASI_TX_LASERBICURRFLT 0x0200  /* Laser bias current fault */
+
+/* LASI control/status registers. */
+#define MDIO_PMA_LASI_LSALARM           0x0001  /* LS_ALARM enable/status */
+#define MDIO_PMA_LASI_TXALARM           0x0002  /* TX_ALARM enable/status */
+#define MDIO_PMA_LASI_RXALARM           0x0004  /* RX_ALARM enable/status */
+
+/* Mapping between MDIO PRTAD/DEVAD and mii_ioctl_data::phy_id */
+
+#define MDIO_PHY_ID_C45                 0x8000
+#define MDIO_PHY_ID_PRTAD               0x03e0
+#define MDIO_PHY_ID_DEVAD               0x001f
+#define MDIO_PHY_ID_C45_MASK                                            \
+        (MDIO_PHY_ID_C45 | MDIO_PHY_ID_PRTAD | MDIO_PHY_ID_DEVAD)
+
+static inline __u16 mdio_phy_id_c45(int prtad, int devad)
+{
+        return MDIO_PHY_ID_C45 | (prtad << 5) | devad;
+}
+
+static inline bool mdio_phy_id_is_c45(int phy_id)
+{
+        return (phy_id & MDIO_PHY_ID_C45) && !(phy_id & ~MDIO_PHY_ID_C45_MASK);
+}
+
+static inline __u16 mdio_phy_id_prtad(int phy_id)
+{
+        return (phy_id & MDIO_PHY_ID_PRTAD) >> 5;
+}
+
+static inline __u16 mdio_phy_id_devad(int phy_id)
+{
+        return phy_id & MDIO_PHY_ID_DEVAD;
+}
+
+#define MDIO_SUPPORTS_C22               1
+#define MDIO_SUPPORTS_C45               2
+
+#ifdef __KERNEL__ 
+
+/**
+ * struct mdio_if_info - Ethernet controller MDIO interface
+ * @prtad: PRTAD of the PHY (%MDIO_PRTAD_NONE if not present/unknown)
+ * @mmds: Mask of MMDs expected to be present in the PHY.  This must be
+ *      non-zero unless @prtad = %MDIO_PRTAD_NONE.
+ * @mode_support: MDIO modes supported.  If %MDIO_SUPPORTS_C22 is set then
+ *      MII register access will be passed through with @devad =
+ *      %MDIO_DEVAD_NONE.  If %MDIO_EMULATE_C22 is set then access to
+ *      commonly used clause 22 registers will be translated into
+ *      clause 45 registers.
+ * @dev: Net device structure
+ * @mdio_read: Register read function; returns value or negative error code
+ * @mdio_write: Register write function; returns 0 or negative error code
+ */
+struct mdio_if_info {
+        int prtad;
+        u32 __bitwise mmds;
+        unsigned mode_support;
+
+        struct net_device *dev;
+        int (*mdio_read)(struct net_device *dev, int prtad, int devad,
+                         u16 addr);
+        int (*mdio_write)(struct net_device *dev, int prtad, int devad,
+                          u16 addr, u16 val);
+};
+
+#define MDIO_PRTAD_NONE                 (-1)
+#define MDIO_DEVAD_NONE                 (-1)
+#define MDIO_EMULATE_C22                4
+
+struct ethtool_cmd;
+struct ethtool_pauseparam;
+extern int mdio45_probe(struct mdio_if_info *mdio, int prtad);
+extern int mdio_set_flag(const struct mdio_if_info *mdio,
+                         int prtad, int devad, u16 addr, int mask,
+                         bool sense);
+extern int mdio45_links_ok(const struct mdio_if_info *mdio, u32 mmds);
+extern int mdio45_nway_restart(const struct mdio_if_info *mdio);
+extern void mdio45_ethtool_gset_npage(const struct mdio_if_info *mdio,
+                                      struct ethtool_cmd *ecmd,
+                                      u32 npage_adv, u32 npage_lpa);
+extern void
+mdio45_ethtool_spauseparam_an(const struct mdio_if_info *mdio,
+                              const struct ethtool_pauseparam *ecmd);
+
+/**
+ * mdio45_ethtool_gset - get settings for ETHTOOL_GSET
+ * @mdio: MDIO interface
+ * @ecmd: Ethtool request structure
+ *
+ * Since the CSRs for auto-negotiation using next pages are not fully
+ * standardised, this function does not attempt to decode them.  Use
+ * mdio45_ethtool_gset_npage() to specify advertisement bits from next
+ * pages.
+ */
+static inline void mdio45_ethtool_gset(const struct mdio_if_info *mdio,
+                                       struct ethtool_cmd *ecmd)
+{
+        mdio45_ethtool_gset_npage(mdio, ecmd, 0, 0);
+}
+
+extern int mdio_mii_ioctl(const struct mdio_if_info *mdio,
+                          struct mii_ioctl_data *mii_data, int cmd);
+
+#endif /* __KERNEL__ */
+#endif /* __LINUX_MDIO_H__ */
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 25b9ca93d232..e46a0734ab6e 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -94,6 +94,7 @@ extern void mem_cgroup_note_reclaim_priority(struct mem_cgroup *mem,
 extern void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem,
                                                         int priority);
 int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg);
+int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg);
 unsigned long mem_cgroup_zone_nr_pages(struct mem_cgroup *memcg,
                                        struct zone *zone,
                                        enum lru_list lru);
@@ -116,7 +117,7 @@ static inline bool mem_cgroup_disabled(void)
 }
 
 extern bool mem_cgroup_oom_called(struct task_struct *task);
-
+void mem_cgroup_update_mapped_file_stat(struct page *page, int val);
 #else /* CONFIG_CGROUP_MEM_RES_CTLR */
 struct mem_cgroup;
 
@@ -239,6 +240,12 @@ mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg)
         return 1;
 }
 
+static inline int
+mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg)
+{
+        return 1;
+}
+
 static inline unsigned long
 mem_cgroup_zone_nr_pages(struct mem_cgroup *memcg, struct zone *zone,
                          enum lru_list lru)
@@ -264,6 +271,11 @@ mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
 {
 }
 
+static inline void mem_cgroup_update_mapped_file_stat(struct page *page,
+                                                        int val)
+{
+}
+
 #endif /* CONFIG_CGROUP_MEM_CONT */
 
 #endif /* _LINUX_MEMCONTROL_H */
diff --git a/include/linux/mfd/ab3100.h b/include/linux/mfd/ab3100.h
new file mode 100644
index 000000000000..7a3f316e3848
--- /dev/null
+++ b/include/linux/mfd/ab3100.h
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2007-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * AB3100 core access functions
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ */
+
+#include <linux/device.h>
+
+#ifndef MFD_AB3100_H
+#define MFD_AB3100_H
+
+#define ABUNKNOWN       0
+#define AB3000          1
+#define AB3100          2
+
+/*
+ * AB3100, EVENTA1, A2 and A3 event register flags
+ * these are catenated into a single 32-bit flag in the code
+ * for event notification broadcasts.
+ */
+#define AB3100_EVENTA1_ONSWA                            (0x01<<16)
+#define AB3100_EVENTA1_ONSWB                            (0x02<<16)
+#define AB3100_EVENTA1_ONSWC                            (0x04<<16)
+#define AB3100_EVENTA1_DCIO                             (0x08<<16)
+#define AB3100_EVENTA1_OVER_TEMP                        (0x10<<16)
+#define AB3100_EVENTA1_SIM_OFF                          (0x20<<16)
+#define AB3100_EVENTA1_VBUS                             (0x40<<16)
+#define AB3100_EVENTA1_VSET_USB                         (0x80<<16)
+
+#define AB3100_EVENTA2_READY_TX                         (0x01<<8)
+#define AB3100_EVENTA2_READY_RX                         (0x02<<8)
+#define AB3100_EVENTA2_OVERRUN_ERROR                    (0x04<<8)
+#define AB3100_EVENTA2_FRAMING_ERROR                    (0x08<<8)
+#define AB3100_EVENTA2_CHARG_OVERCURRENT                (0x10<<8)
+#define AB3100_EVENTA2_MIDR                             (0x20<<8)
+#define AB3100_EVENTA2_BATTERY_REM                      (0x40<<8)
+#define AB3100_EVENTA2_ALARM                            (0x80<<8)
+
+#define AB3100_EVENTA3_ADC_TRIG5                        (0x01)
+#define AB3100_EVENTA3_ADC_TRIG4                        (0x02)
+#define AB3100_EVENTA3_ADC_TRIG3                        (0x04)
+#define AB3100_EVENTA3_ADC_TRIG2                        (0x08)
+#define AB3100_EVENTA3_ADC_TRIGVBAT                     (0x10)
+#define AB3100_EVENTA3_ADC_TRIGVTX                      (0x20)
+#define AB3100_EVENTA3_ADC_TRIG1                        (0x40)
+#define AB3100_EVENTA3_ADC_TRIG0                        (0x80)
+
+/* AB3100, STR register flags */
+#define AB3100_STR_ONSWA                                (0x01)
+#define AB3100_STR_ONSWB                                (0x02)
+#define AB3100_STR_ONSWC                                (0x04)
+#define AB3100_STR_DCIO                                 (0x08)
+#define AB3100_STR_BOOT_MODE                            (0x10)
+#define AB3100_STR_SIM_OFF                              (0x20)
+#define AB3100_STR_BATT_REMOVAL                         (0x40)
+#define AB3100_STR_VBUS                                 (0x80)
+
+/**
+ * struct ab3100
+ * @access_mutex: lock out concurrent accesses to the AB3100 registers
+ * @dev: pointer to the containing device
+ * @i2c_client: I2C client for this chip
+ * @testreg_client: secondary client for test registers
+ * @chip_name: name of this chip variant
+ * @chip_id: 8 bit chip ID for this chip variant
+ * @work: an event handling worker
+ * @event_subscribers: event subscribers are listed here
+ * @startup_events: a copy of the first reading of the event registers
+ * @startup_events_read: whether the first events have been read
+ *
+ * This struct is PRIVATE and devices using it should NOT
+ * access ANY fields. It is used as a token for calling the
+ * AB3100 functions.
+ */
+struct ab3100 {
+        struct mutex access_mutex;
+        struct device *dev;
+        struct i2c_client *i2c_client;
+        struct i2c_client *testreg_client;
+        char chip_name[32];
+        u8 chip_id;
+        struct work_struct work;
+        struct blocking_notifier_head event_subscribers;
+        u32 startup_events;
+        bool startup_events_read;
+};
+
+int ab3100_set_register(struct ab3100 *ab3100, u8 reg, u8 regval);
+int ab3100_get_register(struct ab3100 *ab3100, u8 reg, u8 *regval);
+int ab3100_get_register_page(struct ab3100 *ab3100,
+                             u8 first_reg, u8 *regvals, u8 numregs);
+int ab3100_mask_and_set_register(struct ab3100 *ab3100,
+                                 u8 reg, u8 andmask, u8 ormask);
+u8 ab3100_get_chip_type(struct ab3100 *ab3100);
+int ab3100_event_register(struct ab3100 *ab3100,
+                          struct notifier_block *nb);
+int ab3100_event_unregister(struct ab3100 *ab3100,
+                            struct notifier_block *nb);
+int ab3100_event_registers_startup_state_get(struct ab3100 *ab3100,
+                                             u32 *fatevent);
+
+#endif
diff --git a/include/linux/mfd/asic3.h b/include/linux/mfd/asic3.h
index 322cd6deb9f0..de3c4ad19afb 100644
--- a/include/linux/mfd/asic3.h
+++ b/include/linux/mfd/asic3.h
@@ -30,6 +30,13 @@ struct asic3_platform_data {
 #define ASIC3_NUM_GPIOS         64
 #define ASIC3_NR_IRQS           ASIC3_NUM_GPIOS + 6
 
+#define ASIC3_IRQ_LED0          64
+#define ASIC3_IRQ_LED1          65
+#define ASIC3_IRQ_LED2          66
+#define ASIC3_IRQ_SPI           67
+#define ASIC3_IRQ_SMBUS         68
+#define ASIC3_IRQ_OWM           69
+
 #define ASIC3_TO_GPIO(gpio) (NR_BUILTIN_GPIO + (gpio))
 
 #define ASIC3_GPIO_BANK_A       0
@@ -227,8 +234,8 @@ struct asic3_platform_data {
 
 
 /* Basic control of the SD ASIC */
-#define ASIC3_SDHWCTRL_Base     0x0E00
-#define ASIC3_SDHWCTRL_SDConf    0x00
+#define ASIC3_SDHWCTRL_BASE     0x0E00
+#define ASIC3_SDHWCTRL_SDCONF     0x00
 
 #define ASIC3_SDHWCTRL_SUSPEND    (1 << 0)  /* 1=suspend all SD operations */
 #define ASIC3_SDHWCTRL_CLKSEL     (1 << 1)  /* 1=SDICK, 0=HCLK */
@@ -242,10 +249,10 @@ struct asic3_platform_data {
 /* SD card power supply ctrl 1=enable */
 #define ASIC3_SDHWCTRL_SDPWR      (1 << 6)
 
-#define ASIC3_EXTCF_Base                0x1100
+#define ASIC3_EXTCF_BASE        0x1100
 
-#define ASIC3_EXTCF_Select         0x00
-#define ASIC3_EXTCF_Reset          0x04
+#define ASIC3_EXTCF_SELECT        0x00
+#define ASIC3_EXTCF_RESET         0x04
 
 #define ASIC3_EXTCF_SMOD0                (1 << 0)  /* slot number of mode 0 */
 #define ASIC3_EXTCF_SMOD1                (1 << 1)  /* slot number of mode 1 */
@@ -279,222 +286,9 @@ struct asic3_platform_data {
  *  SDIO_CTRL         Control registers for SDIO operations
  *
  *****************************************************************************/
-#define ASIC3_SD_CONFIG_Base            0x0400 /* Assumes 32 bit addressing */
-
-#define ASIC3_SD_CONFIG_Command           0x08   /* R/W: Command */
-
-/* [0:8] SD Control Register Base Address */
-#define ASIC3_SD_CONFIG_Addr0             0x20
-
-/* [9:31] SD Control Register Base Address */
-#define ASIC3_SD_CONFIG_Addr1             0x24
-
-/* R/O: interrupt assigned to pin */
-#define ASIC3_SD_CONFIG_IntPin            0x78
-
-/*
- * Set to 0x1f to clock SD controller, 0 otherwise.
- * At 0x82 - Gated Clock Ctrl
- */
-#define ASIC3_SD_CONFIG_ClkStop           0x80
-
-/* Control clock of SD controller */
-#define ASIC3_SD_CONFIG_ClockMode         0x84
-#define ASIC3_SD_CONFIG_SDHC_PinStatus    0x88   /* R/0: SD pins status */
-#define ASIC3_SD_CONFIG_SDHC_Power1       0x90   /* Power1 - manual pwr ctrl */
-
-/* auto power up after card inserted */
-#define ASIC3_SD_CONFIG_SDHC_Power2       0x92
-
-/* auto power down when card removed */
-#define ASIC3_SD_CONFIG_SDHC_Power3       0x94
-#define ASIC3_SD_CONFIG_SDHC_CardDetect   0x98
-#define ASIC3_SD_CONFIG_SDHC_Slot         0xA0   /* R/O: support slot number */
-#define ASIC3_SD_CONFIG_SDHC_ExtGateClk1  0x1E0  /* Not used */
-#define ASIC3_SD_CONFIG_SDHC_ExtGateClk2  0x1E2  /* Not used*/
-
-/* GPIO Output Reg. , at 0x1EA - GPIO Output Enable Reg. */
-#define ASIC3_SD_CONFIG_SDHC_GPIO_OutAndEnable  0x1E8
-#define ASIC3_SD_CONFIG_SDHC_GPIO_Status  0x1EC  /* GPIO Status Reg. */
-
-/* Bit 1: double buffer/single buffer */
-#define ASIC3_SD_CONFIG_SDHC_ExtGateClk3  0x1F0
-
-/* Memory access enable (set to 1 to access SD Controller) */
-#define SD_CONFIG_COMMAND_MAE                (1<<1)
-
-#define SD_CONFIG_CLK_ENABLE_ALL             0x1f
-
-#define SD_CONFIG_POWER1_PC_33V              0x0200    /* Set for 3.3 volts */
-#define SD_CONFIG_POWER1_PC_OFF              0x0000    /* Turn off power */
-
- /* two bits - number of cycles for card detection */
-#define SD_CONFIG_CARDDETECTMODE_CLK           ((x) & 0x3)
-
-
-#define ASIC3_SD_CTRL_Base            0x1000
-
-#define ASIC3_SD_CTRL_Cmd                  0x00
-#define ASIC3_SD_CTRL_Arg0                 0x08
-#define ASIC3_SD_CTRL_Arg1                 0x0C
-#define ASIC3_SD_CTRL_StopInternal         0x10
-#define ASIC3_SD_CTRL_TransferSectorCount  0x14
-#define ASIC3_SD_CTRL_Response0            0x18
-#define ASIC3_SD_CTRL_Response1            0x1C
-#define ASIC3_SD_CTRL_Response2            0x20
-#define ASIC3_SD_CTRL_Response3            0x24
-#define ASIC3_SD_CTRL_Response4            0x28
-#define ASIC3_SD_CTRL_Response5            0x2C
-#define ASIC3_SD_CTRL_Response6            0x30
-#define ASIC3_SD_CTRL_Response7            0x34
-#define ASIC3_SD_CTRL_CardStatus           0x38
-#define ASIC3_SD_CTRL_BufferCtrl           0x3C
-#define ASIC3_SD_CTRL_IntMaskCard          0x40
-#define ASIC3_SD_CTRL_IntMaskBuffer        0x44
-#define ASIC3_SD_CTRL_CardClockCtrl        0x48
-#define ASIC3_SD_CTRL_MemCardXferDataLen   0x4C
-#define ASIC3_SD_CTRL_MemCardOptionSetup   0x50
-#define ASIC3_SD_CTRL_ErrorStatus0         0x58
-#define ASIC3_SD_CTRL_ErrorStatus1         0x5C
-#define ASIC3_SD_CTRL_DataPort             0x60
-#define ASIC3_SD_CTRL_TransactionCtrl      0x68
-#define ASIC3_SD_CTRL_SoftwareReset        0x1C0
-
-#define SD_CTRL_SOFTWARE_RESET_CLEAR            (1<<0)
-
-#define SD_CTRL_TRANSACTIONCONTROL_SET          (1<<8)
-
-#define SD_CTRL_CARDCLOCKCONTROL_FOR_SD_CARD    (1<<15)
-#define SD_CTRL_CARDCLOCKCONTROL_ENABLE_CLOCK   (1<<8)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_512    (1<<7)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_256    (1<<6)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_128    (1<<5)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_64     (1<<4)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_32     (1<<3)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_16     (1<<2)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_8      (1<<1)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_4      (1<<0)
-#define SD_CTRL_CARDCLOCKCONTROL_CLK_DIV_2      (0<<0)
-
-#define MEM_CARD_OPTION_REQUIRED                   0x000e
-#define MEM_CARD_OPTION_DATA_RESPONSE_TIMEOUT(x)   (((x) & 0x0f) << 4)
-#define MEM_CARD_OPTION_C2_MODULE_NOT_PRESENT      (1<<14)
-#define MEM_CARD_OPTION_DATA_XFR_WIDTH_1           (1<<15)
-#define MEM_CARD_OPTION_DATA_XFR_WIDTH_4           0
-
-#define SD_CTRL_COMMAND_INDEX(x)                   ((x) & 0x3f)
-#define SD_CTRL_COMMAND_TYPE_CMD                   (0 << 6)
-#define SD_CTRL_COMMAND_TYPE_ACMD                  (1 << 6)
-#define SD_CTRL_COMMAND_TYPE_AUTHENTICATION        (2 << 6)
-#define SD_CTRL_COMMAND_RESPONSE_TYPE_NORMAL       (0 << 8)
-#define SD_CTRL_COMMAND_RESPONSE_TYPE_EXT_R1       (4 << 8)
-#define SD_CTRL_COMMAND_RESPONSE_TYPE_EXT_R1B      (5 << 8)
-#define SD_CTRL_COMMAND_RESPONSE_TYPE_EXT_R2       (6 << 8)
-#define SD_CTRL_COMMAND_RESPONSE_TYPE_EXT_R3       (7 << 8)
-#define SD_CTRL_COMMAND_DATA_PRESENT               (1 << 11)
-#define SD_CTRL_COMMAND_TRANSFER_READ              (1 << 12)
-#define SD_CTRL_COMMAND_TRANSFER_WRITE             (0 << 12)
-#define SD_CTRL_COMMAND_MULTI_BLOCK                (1 << 13)
-#define SD_CTRL_COMMAND_SECURITY_CMD               (1 << 14)
-
-#define SD_CTRL_STOP_INTERNAL_ISSSUE_CMD12         (1 << 0)
-#define SD_CTRL_STOP_INTERNAL_AUTO_ISSUE_CMD12     (1 << 8)
-
-#define SD_CTRL_CARDSTATUS_RESPONSE_END            (1 << 0)
-#define SD_CTRL_CARDSTATUS_RW_END                  (1 << 2)
-#define SD_CTRL_CARDSTATUS_CARD_REMOVED_0          (1 << 3)
-#define SD_CTRL_CARDSTATUS_CARD_INSERTED_0         (1 << 4)
-#define SD_CTRL_CARDSTATUS_SIGNAL_STATE_PRESENT_0  (1 << 5)
-#define SD_CTRL_CARDSTATUS_WRITE_PROTECT           (1 << 7)
-#define SD_CTRL_CARDSTATUS_CARD_REMOVED_3          (1 << 8)
-#define SD_CTRL_CARDSTATUS_CARD_INSERTED_3         (1 << 9)
-#define SD_CTRL_CARDSTATUS_SIGNAL_STATE_PRESENT_3  (1 << 10)
-
-#define SD_CTRL_BUFFERSTATUS_CMD_INDEX_ERROR       (1 << 0)
-#define SD_CTRL_BUFFERSTATUS_CRC_ERROR             (1 << 1)
-#define SD_CTRL_BUFFERSTATUS_STOP_BIT_END_ERROR    (1 << 2)
-#define SD_CTRL_BUFFERSTATUS_DATA_TIMEOUT          (1 << 3)
-#define SD_CTRL_BUFFERSTATUS_BUFFER_OVERFLOW       (1 << 4)
-#define SD_CTRL_BUFFERSTATUS_BUFFER_UNDERFLOW      (1 << 5)
-#define SD_CTRL_BUFFERSTATUS_CMD_TIMEOUT           (1 << 6)
-#define SD_CTRL_BUFFERSTATUS_UNK7                  (1 << 7)
-#define SD_CTRL_BUFFERSTATUS_BUFFER_READ_ENABLE    (1 << 8)
-#define SD_CTRL_BUFFERSTATUS_BUFFER_WRITE_ENABLE   (1 << 9)
-#define SD_CTRL_BUFFERSTATUS_ILLEGAL_FUNCTION      (1 << 13)
-#define SD_CTRL_BUFFERSTATUS_CMD_BUSY              (1 << 14)
-#define SD_CTRL_BUFFERSTATUS_ILLEGAL_ACCESS        (1 << 15)
-
-#define SD_CTRL_INTMASKCARD_RESPONSE_END           (1 << 0)
-#define SD_CTRL_INTMASKCARD_RW_END                 (1 << 2)
-#define SD_CTRL_INTMASKCARD_CARD_REMOVED_0         (1 << 3)
-#define SD_CTRL_INTMASKCARD_CARD_INSERTED_0        (1 << 4)
-#define SD_CTRL_INTMASKCARD_SIGNAL_STATE_PRESENT_0 (1 << 5)
-#define SD_CTRL_INTMASKCARD_UNK6                   (1 << 6)
-#define SD_CTRL_INTMASKCARD_WRITE_PROTECT          (1 << 7)
-#define SD_CTRL_INTMASKCARD_CARD_REMOVED_3         (1 << 8)
-#define SD_CTRL_INTMASKCARD_CARD_INSERTED_3        (1 << 9)
-#define SD_CTRL_INTMASKCARD_SIGNAL_STATE_PRESENT_3 (1 << 10)
-
-#define SD_CTRL_INTMASKBUFFER_CMD_INDEX_ERROR      (1 << 0)
-#define SD_CTRL_INTMASKBUFFER_CRC_ERROR            (1 << 1)
-#define SD_CTRL_INTMASKBUFFER_STOP_BIT_END_ERROR   (1 << 2)
-#define SD_CTRL_INTMASKBUFFER_DATA_TIMEOUT         (1 << 3)
-#define SD_CTRL_INTMASKBUFFER_BUFFER_OVERFLOW      (1 << 4)
-#define SD_CTRL_INTMASKBUFFER_BUFFER_UNDERFLOW     (1 << 5)
-#define SD_CTRL_INTMASKBUFFER_CMD_TIMEOUT          (1 << 6)
-#define SD_CTRL_INTMASKBUFFER_UNK7                 (1 << 7)
-#define SD_CTRL_INTMASKBUFFER_BUFFER_READ_ENABLE   (1 << 8)
-#define SD_CTRL_INTMASKBUFFER_BUFFER_WRITE_ENABLE  (1 << 9)
-#define SD_CTRL_INTMASKBUFFER_ILLEGAL_FUNCTION     (1 << 13)
-#define SD_CTRL_INTMASKBUFFER_CMD_BUSY             (1 << 14)
-#define SD_CTRL_INTMASKBUFFER_ILLEGAL_ACCESS       (1 << 15)
-
-#define SD_CTRL_DETAIL0_RESPONSE_CMD_ERROR                   (1 << 0)
-#define SD_CTRL_DETAIL0_END_BIT_ERROR_FOR_RESPONSE_NON_CMD12 (1 << 2)
-#define SD_CTRL_DETAIL0_END_BIT_ERROR_FOR_RESPONSE_CMD12     (1 << 3)
-#define SD_CTRL_DETAIL0_END_BIT_ERROR_FOR_READ_DATA          (1 << 4)
-#define SD_CTRL_DETAIL0_END_BIT_ERROR_FOR_WRITE_CRC_STATUS   (1 << 5)
-#define SD_CTRL_DETAIL0_CRC_ERROR_FOR_RESPONSE_NON_CMD12     (1 << 8)
-#define SD_CTRL_DETAIL0_CRC_ERROR_FOR_RESPONSE_CMD12         (1 << 9)
-#define SD_CTRL_DETAIL0_CRC_ERROR_FOR_READ_DATA              (1 << 10)
-#define SD_CTRL_DETAIL0_CRC_ERROR_FOR_WRITE_CMD              (1 << 11)
-
-#define SD_CTRL_DETAIL1_NO_CMD_RESPONSE                      (1 << 0)
-#define SD_CTRL_DETAIL1_TIMEOUT_READ_DATA                    (1 << 4)
-#define SD_CTRL_DETAIL1_TIMEOUT_CRS_STATUS                   (1 << 5)
-#define SD_CTRL_DETAIL1_TIMEOUT_CRC_BUSY                     (1 << 6)
-
-#define ASIC3_SDIO_CTRL_Base          0x1200
-
-#define ASIC3_SDIO_CTRL_Cmd                  0x00
-#define ASIC3_SDIO_CTRL_CardPortSel          0x04
-#define ASIC3_SDIO_CTRL_Arg0                 0x08
-#define ASIC3_SDIO_CTRL_Arg1                 0x0C
-#define ASIC3_SDIO_CTRL_TransferBlockCount   0x14
-#define ASIC3_SDIO_CTRL_Response0            0x18
-#define ASIC3_SDIO_CTRL_Response1            0x1C
-#define ASIC3_SDIO_CTRL_Response2            0x20
-#define ASIC3_SDIO_CTRL_Response3            0x24
-#define ASIC3_SDIO_CTRL_Response4            0x28
-#define ASIC3_SDIO_CTRL_Response5            0x2C
-#define ASIC3_SDIO_CTRL_Response6            0x30
-#define ASIC3_SDIO_CTRL_Response7            0x34
-#define ASIC3_SDIO_CTRL_CardStatus           0x38
-#define ASIC3_SDIO_CTRL_BufferCtrl           0x3C
-#define ASIC3_SDIO_CTRL_IntMaskCard          0x40
-#define ASIC3_SDIO_CTRL_IntMaskBuffer        0x44
-#define ASIC3_SDIO_CTRL_CardXferDataLen      0x4C
-#define ASIC3_SDIO_CTRL_CardOptionSetup      0x50
-#define ASIC3_SDIO_CTRL_ErrorStatus0         0x54
-#define ASIC3_SDIO_CTRL_ErrorStatus1         0x58
-#define ASIC3_SDIO_CTRL_DataPort             0x60
-#define ASIC3_SDIO_CTRL_TransactionCtrl      0x68
-#define ASIC3_SDIO_CTRL_CardIntCtrl          0x6C
-#define ASIC3_SDIO_CTRL_ClocknWaitCtrl       0x70
-#define ASIC3_SDIO_CTRL_HostInformation      0x74
-#define ASIC3_SDIO_CTRL_ErrorCtrl            0x78
-#define ASIC3_SDIO_CTRL_LEDCtrl              0x7C
-#define ASIC3_SDIO_CTRL_SoftwareReset        0x1C0
+#define ASIC3_SD_CONFIG_BASE    0x0400 /* Assumes 32 bit addressing */
+#define ASIC3_SD_CTRL_BASE      0x1000
+#define ASIC3_SDIO_CTRL_BASE    0x1200
 
 #define ASIC3_MAP_SIZE_32BIT    0x2000
 #define ASIC3_MAP_SIZE_16BIT    0x1000
diff --git a/include/linux/mfd/ezx-pcap.h b/include/linux/mfd/ezx-pcap.h
new file mode 100644
index 000000000000..c12c3c0932bf
--- /dev/null
+++ b/include/linux/mfd/ezx-pcap.h
@@ -0,0 +1,256 @@
+/*
+ * Copyright 2009 Daniel Ribeiro <drwyrm@gmail.com>
+ *
+ * For further information, please see http://wiki.openezx.org/PCAP2
+ */
+
+#ifndef EZX_PCAP_H
+#define EZX_PCAP_H
+
+struct pcap_subdev {
+        int id;
+        const char *name;
+        void *platform_data;
+};
+
+struct pcap_platform_data {
+        unsigned int irq_base;
+        unsigned int config;
+        void (*init) (void *);  /* board specific init */
+        int num_subdevs;
+        struct pcap_subdev *subdevs;
+};
+
+struct pcap_chip;
+
+int ezx_pcap_write(struct pcap_chip *, u8, u32);
+int ezx_pcap_read(struct pcap_chip *, u8, u32 *);
+int pcap_to_irq(struct pcap_chip *, int);
+int pcap_adc_async(struct pcap_chip *, u8, u32, u8[], void *, void *);
+int pcap_adc_sync(struct pcap_chip *, u8, u32, u8[], u16[]);
+
+#define PCAP_SECOND_PORT        1
+#define PCAP_CS_AH              2
+
+#define PCAP_REGISTER_WRITE_OP_BIT      0x80000000
+#define PCAP_REGISTER_READ_OP_BIT       0x00000000
+
+#define PCAP_REGISTER_VALUE_MASK        0x01ffffff
+#define PCAP_REGISTER_ADDRESS_MASK      0x7c000000
+#define PCAP_REGISTER_ADDRESS_SHIFT     26
+#define PCAP_REGISTER_NUMBER            32
+#define PCAP_CLEAR_INTERRUPT_REGISTER   0x01ffffff
+#define PCAP_MASK_ALL_INTERRUPT         0x01ffffff
+
+/* registers acessible by both pcap ports */
+#define PCAP_REG_ISR            0x0     /* Interrupt Status */
+#define PCAP_REG_MSR            0x1     /* Interrupt Mask */
+#define PCAP_REG_PSTAT          0x2     /* Processor Status */
+#define PCAP_REG_VREG2          0x6     /* Regulator Bank 2 Control */
+#define PCAP_REG_AUXVREG        0x7     /* Auxiliary Regulator Control */
+#define PCAP_REG_BATT           0x8     /* Battery Control */
+#define PCAP_REG_ADC            0x9     /* AD Control */
+#define PCAP_REG_ADR            0xa     /* AD Result */
+#define PCAP_REG_CODEC          0xb     /* Audio Codec Control */
+#define PCAP_REG_RX_AMPS        0xc     /* RX Audio Amplifiers Control */
+#define PCAP_REG_ST_DAC         0xd     /* Stereo DAC Control */
+#define PCAP_REG_BUSCTRL        0x14    /* Connectivity Control */
+#define PCAP_REG_PERIPH         0x15    /* Peripheral Control */
+#define PCAP_REG_LOWPWR         0x18    /* Regulator Low Power Control */
+#define PCAP_REG_TX_AMPS        0x1a    /* TX Audio Amplifiers Control */
+#define PCAP_REG_GP             0x1b    /* General Purpose */
+#define PCAP_REG_TEST1          0x1c
+#define PCAP_REG_TEST2          0x1d
+#define PCAP_REG_VENDOR_TEST1   0x1e
+#define PCAP_REG_VENDOR_TEST2   0x1f
+
+/* registers acessible by pcap port 1 only (a1200, e2 & e6) */
+#define PCAP_REG_INT_SEL        0x3     /* Interrupt Select */
+#define PCAP_REG_SWCTRL         0x4     /* Switching Regulator Control */
+#define PCAP_REG_VREG1          0x5     /* Regulator Bank 1 Control */
+#define PCAP_REG_RTC_TOD        0xe     /* RTC Time of Day */
+#define PCAP_REG_RTC_TODA       0xf     /* RTC Time of Day Alarm */
+#define PCAP_REG_RTC_DAY        0x10    /* RTC Day */
+#define PCAP_REG_RTC_DAYA       0x11    /* RTC Day Alarm */
+#define PCAP_REG_MTRTMR         0x12    /* AD Monitor Timer */
+#define PCAP_REG_PWR            0x13    /* Power Control */
+#define PCAP_REG_AUXVREG_MASK   0x16    /* Auxiliary Regulator Mask */
+#define PCAP_REG_VENDOR_REV     0x17
+#define PCAP_REG_PERIPH_MASK    0x19    /* Peripheral Mask */
+
+/* PCAP2 Interrupts */
+#define PCAP_NIRQS              23
+#define PCAP_IRQ_ADCDONE        0       /* ADC done port 1 */
+#define PCAP_IRQ_TS             1       /* Touch Screen */
+#define PCAP_IRQ_1HZ            2       /* 1HZ timer */
+#define PCAP_IRQ_WH             3       /* ADC above high limit */
+#define PCAP_IRQ_WL             4       /* ADC below low limit */
+#define PCAP_IRQ_TODA           5       /* Time of day alarm */
+#define PCAP_IRQ_USB4V          6       /* USB above 4V */
+#define PCAP_IRQ_ONOFF          7       /* On/Off button */
+#define PCAP_IRQ_ONOFF2         8       /* On/Off button 2 */
+#define PCAP_IRQ_USB1V          9       /* USB above 1V */
+#define PCAP_IRQ_MOBPORT        10
+#define PCAP_IRQ_MIC            11      /* Mic attach/HS button */
+#define PCAP_IRQ_HS             12      /* Headset attach */
+#define PCAP_IRQ_ST             13
+#define PCAP_IRQ_PC             14      /* Power Cut */
+#define PCAP_IRQ_WARM           15
+#define PCAP_IRQ_EOL            16      /* Battery End Of Life */
+#define PCAP_IRQ_CLK            17
+#define PCAP_IRQ_SYSRST         18      /* System Reset */
+#define PCAP_IRQ_DUMMY          19
+#define PCAP_IRQ_ADCDONE2       20      /* ADC done port 2 */
+#define PCAP_IRQ_SOFTRESET      21
+#define PCAP_IRQ_MNEXB          22
+
+/* voltage regulators */
+#define V1              0
+#define V2              1
+#define V3              2
+#define V4              3
+#define V5              4
+#define V6              5
+#define V7              6
+#define V8              7
+#define V9              8
+#define V10             9
+#define VAUX1           10
+#define VAUX2           11
+#define VAUX3           12
+#define VAUX4           13
+#define VSIM            14
+#define VSIM2           15
+#define VVIB            16
+#define SW1             17
+#define SW2             18
+#define SW3             19
+#define SW1S            20
+#define SW2S            21
+
+#define PCAP_BATT_DAC_MASK              0x000000ff
+#define PCAP_BATT_DAC_SHIFT             0
+#define PCAP_BATT_B_FDBK                (1 << 8)
+#define PCAP_BATT_EXT_ISENSE            (1 << 9)
+#define PCAP_BATT_V_COIN_MASK           0x00003c00
+#define PCAP_BATT_V_COIN_SHIFT          10
+#define PCAP_BATT_I_COIN                (1 << 14)
+#define PCAP_BATT_COIN_CH_EN            (1 << 15)
+#define PCAP_BATT_EOL_SEL_MASK          0x000e0000
+#define PCAP_BATT_EOL_SEL_SHIFT         17
+#define PCAP_BATT_EOL_CMP_EN            (1 << 20)
+#define PCAP_BATT_BATT_DET_EN           (1 << 21)
+#define PCAP_BATT_THERMBIAS_CTRL        (1 << 22)
+
+#define PCAP_ADC_ADEN                   (1 << 0)
+#define PCAP_ADC_RAND                   (1 << 1)
+#define PCAP_ADC_AD_SEL1                (1 << 2)
+#define PCAP_ADC_AD_SEL2                (1 << 3)
+#define PCAP_ADC_ADA1_MASK              0x00000070
+#define PCAP_ADC_ADA1_SHIFT             4
+#define PCAP_ADC_ADA2_MASK              0x00000380
+#define PCAP_ADC_ADA2_SHIFT             7
+#define PCAP_ADC_ATO_MASK               0x00003c00
+#define PCAP_ADC_ATO_SHIFT              10
+#define PCAP_ADC_ATOX                   (1 << 14)
+#define PCAP_ADC_MTR1                   (1 << 15)
+#define PCAP_ADC_MTR2                   (1 << 16)
+#define PCAP_ADC_TS_M_MASK              0x000e0000
+#define PCAP_ADC_TS_M_SHIFT             17
+#define PCAP_ADC_TS_REF_LOWPWR          (1 << 20)
+#define PCAP_ADC_TS_REFENB              (1 << 21)
+#define PCAP_ADC_BATT_I_POLARITY        (1 << 22)
+#define PCAP_ADC_BATT_I_ADC             (1 << 23)
+
+#define PCAP_ADC_BANK_0                 0
+#define PCAP_ADC_BANK_1                 1
+/* ADC bank 0 */
+#define PCAP_ADC_CH_COIN                0
+#define PCAP_ADC_CH_BATT                1
+#define PCAP_ADC_CH_BPLUS               2
+#define PCAP_ADC_CH_MOBPORTB            3
+#define PCAP_ADC_CH_TEMPERATURE         4
+#define PCAP_ADC_CH_CHARGER_ID          5
+#define PCAP_ADC_CH_AD6                 6
+/* ADC bank 1 */
+#define PCAP_ADC_CH_AD7                 0
+#define PCAP_ADC_CH_AD8                 1
+#define PCAP_ADC_CH_AD9                 2
+#define PCAP_ADC_CH_TS_X1               3
+#define PCAP_ADC_CH_TS_X2               4
+#define PCAP_ADC_CH_TS_Y1               5
+#define PCAP_ADC_CH_TS_Y2               6
+
+#define PCAP_ADC_T_NOW                  0
+#define PCAP_ADC_T_IN_BURST             1
+#define PCAP_ADC_T_OUT_BURST            2
+
+#define PCAP_ADC_ATO_IN_BURST           6
+#define PCAP_ADC_ATO_OUT_BURST          0
+
+#define PCAP_ADC_TS_M_XY                1
+#define PCAP_ADC_TS_M_PRESSURE          2
+#define PCAP_ADC_TS_M_PLATE_X           3
+#define PCAP_ADC_TS_M_PLATE_Y           4
+#define PCAP_ADC_TS_M_STANDBY           5
+#define PCAP_ADC_TS_M_NONTS             6
+
+#define PCAP_ADR_ADD1_MASK              0x000003ff
+#define PCAP_ADR_ADD1_SHIFT             0
+#define PCAP_ADR_ADD2_MASK              0x000ffc00
+#define PCAP_ADR_ADD2_SHIFT             10
+#define PCAP_ADR_ADINC1                 (1 << 20)
+#define PCAP_ADR_ADINC2                 (1 << 21)
+#define PCAP_ADR_ASC                    (1 << 22)
+#define PCAP_ADR_ONESHOT                (1 << 23)
+
+#define PCAP_BUSCTRL_FSENB              (1 << 0)
+#define PCAP_BUSCTRL_USB_SUSPEND        (1 << 1)
+#define PCAP_BUSCTRL_USB_PU             (1 << 2)
+#define PCAP_BUSCTRL_USB_PD             (1 << 3)
+#define PCAP_BUSCTRL_VUSB_EN            (1 << 4)
+#define PCAP_BUSCTRL_USB_PS             (1 << 5)
+#define PCAP_BUSCTRL_VUSB_MSTR_EN       (1 << 6)
+#define PCAP_BUSCTRL_VBUS_PD_ENB        (1 << 7)
+#define PCAP_BUSCTRL_CURRLIM            (1 << 8)
+#define PCAP_BUSCTRL_RS232ENB           (1 << 9)
+#define PCAP_BUSCTRL_RS232_DIR          (1 << 10)
+#define PCAP_BUSCTRL_SE0_CONN           (1 << 11)
+#define PCAP_BUSCTRL_USB_PDM            (1 << 12)
+#define PCAP_BUSCTRL_BUS_PRI_ADJ        (1 << 24)
+
+/* leds */
+#define PCAP_LED0               0
+#define PCAP_LED1               1
+#define PCAP_BL0                2
+#define PCAP_BL1                3
+#define PCAP_VIB                4
+#define PCAP_LED_3MA            0
+#define PCAP_LED_4MA            1
+#define PCAP_LED_5MA            2
+#define PCAP_LED_9MA            3
+#define PCAP_LED_GPIO_VAL_MASK  0x00ffffff
+#define PCAP_LED_GPIO_EN        0x01000000
+#define PCAP_LED_GPIO_INVERT    0x02000000
+#define PCAP_LED_T_MASK         0xf
+#define PCAP_LED_C_MASK         0x3
+#define PCAP_BL_MASK            0x1f
+#define PCAP_BL0_SHIFT          0
+#define PCAP_LED0_EN            (1 << 5)
+#define PCAP_LED1_EN            (1 << 6)
+#define PCAP_LED0_T_SHIFT       7
+#define PCAP_LED1_T_SHIFT       11
+#define PCAP_LED0_C_SHIFT       15
+#define PCAP_LED1_C_SHIFT       17
+#define PCAP_BL1_SHIFT          20
+#define PCAP_VIB_MASK           0x3
+#define PCAP_VIB_SHIFT          20
+#define PCAP_VIB_EN             (1 << 19)
+
+/* RTC */
+#define PCAP_RTC_DAY_MASK       0x3fff
+#define PCAP_RTC_TOD_MASK       0xffff
+#define PCAP_RTC_PC_MASK        0x7
+#define SEC_PER_DAY             86400
+
+#endif
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 516d955ab8a1..6b9c5d06690c 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -19,6 +19,13 @@
         } while (0)
 
 /*
+ * data for the MMC controller
+ */
+struct tmio_mmc_data {
+        const unsigned int              hclk;
+};
+
+/*
  * data for the NAND controller
  */
 struct tmio_nand_data {
diff --git a/include/linux/mg_disk.h b/include/linux/mg_disk.h
index 1f76b1ebf627..e11f4d9f1c2e 100644
--- a/include/linux/mg_disk.h
+++ b/include/linux/mg_disk.h
@@ -1,8 +1,7 @@
 /*
  *  include/linux/mg_disk.c
  *
- *  Support for the mGine m[g]flash IO mode.
- *  Based on legacy hd.c
+ *  Private data for mflash platform driver
  *
  * (c) 2008 mGine Co.,LTD
  * (c) 2008 unsik Kim <donari75@gmail.com>
@@ -15,127 +14,13 @@
 #ifndef __MG_DISK_H__
 #define __MG_DISK_H__
 
-#include <linux/blkdev.h>
-#include <linux/ata.h>
-
-/* name for block device */
-#define MG_DISK_NAME "mgd"
 /* name for platform device */
 #define MG_DEV_NAME "mg_disk"
 
-#define MG_DISK_MAJ 0
-#define MG_DISK_MAX_PART 16
-#define MG_SECTOR_SIZE 512
-#define MG_MAX_SECTS 256
-
-/* Register offsets */
-#define MG_BUFF_OFFSET                  0x8000
-#define MG_STORAGE_BUFFER_SIZE          0x200
-#define MG_REG_OFFSET                   0xC000
-#define MG_REG_FEATURE                  (MG_REG_OFFSET + 2)     /* write case */
-#define MG_REG_ERROR                    (MG_REG_OFFSET + 2)     /* read case */
-#define MG_REG_SECT_CNT                 (MG_REG_OFFSET + 4)
-#define MG_REG_SECT_NUM                 (MG_REG_OFFSET + 6)
-#define MG_REG_CYL_LOW                  (MG_REG_OFFSET + 8)
-#define MG_REG_CYL_HIGH                 (MG_REG_OFFSET + 0xA)
-#define MG_REG_DRV_HEAD                 (MG_REG_OFFSET + 0xC)
-#define MG_REG_COMMAND                  (MG_REG_OFFSET + 0xE)   /* write case */
-#define MG_REG_STATUS                   (MG_REG_OFFSET + 0xE)   /* read  case */
-#define MG_REG_DRV_CTRL                 (MG_REG_OFFSET + 0x10)
-#define MG_REG_BURST_CTRL               (MG_REG_OFFSET + 0x12)
-
-/* "Drive Select/Head Register" bit values */
-#define MG_REG_HEAD_MUST_BE_ON          0xA0 /* These 2 bits are always on */
-#define MG_REG_HEAD_DRIVE_MASTER        (0x00 | MG_REG_HEAD_MUST_BE_ON)
-#define MG_REG_HEAD_DRIVE_SLAVE         (0x10 | MG_REG_HEAD_MUST_BE_ON)
-#define MG_REG_HEAD_LBA_MODE            (0x40 | MG_REG_HEAD_MUST_BE_ON)
-
-
-/* "Device Control Register" bit values */
-#define MG_REG_CTRL_INTR_ENABLE                 0x0
-#define MG_REG_CTRL_INTR_DISABLE                (0x1<<1)
-#define MG_REG_CTRL_RESET                       (0x1<<2)
-#define MG_REG_CTRL_INTR_POLA_ACTIVE_HIGH       0x0
-#define MG_REG_CTRL_INTR_POLA_ACTIVE_LOW        (0x1<<4)
-#define MG_REG_CTRL_DPD_POLA_ACTIVE_LOW         0x0
-#define MG_REG_CTRL_DPD_POLA_ACTIVE_HIGH        (0x1<<5)
-#define MG_REG_CTRL_DPD_DISABLE                 0x0
-#define MG_REG_CTRL_DPD_ENABLE                  (0x1<<6)
-
-/* Status register bit */
-/* error bit in status register */
-#define MG_REG_STATUS_BIT_ERROR                 0x01
-/* corrected error in status register */
-#define MG_REG_STATUS_BIT_CORRECTED_ERROR       0x04
-/* data request bit in status register */
-#define MG_REG_STATUS_BIT_DATA_REQ              0x08
-/* DSC - Drive Seek Complete */
-#define MG_REG_STATUS_BIT_SEEK_DONE             0x10
-/* DWF - Drive Write Fault */
-#define MG_REG_STATUS_BIT_WRITE_FAULT           0x20
-#define MG_REG_STATUS_BIT_READY                 0x40
-#define MG_REG_STATUS_BIT_BUSY                  0x80
-
-/* handy status */
-#define MG_STAT_READY   (MG_REG_STATUS_BIT_READY | MG_REG_STATUS_BIT_SEEK_DONE)
-#define MG_READY_OK(s)  (((s) & (MG_STAT_READY | \
-                                (MG_REG_STATUS_BIT_BUSY | \
-                                 MG_REG_STATUS_BIT_WRITE_FAULT | \
-                                 MG_REG_STATUS_BIT_ERROR))) == MG_STAT_READY)
-
-/* Error register */
-#define MG_REG_ERR_AMNF         0x01
-#define MG_REG_ERR_ABRT         0x04
-#define MG_REG_ERR_IDNF         0x10
-#define MG_REG_ERR_UNC          0x40
-#define MG_REG_ERR_BBK          0x80
-
-/* error code for others */
-#define MG_ERR_NONE             0
-#define MG_ERR_TIMEOUT          0x100
-#define MG_ERR_INIT_STAT        0x101
-#define MG_ERR_TRANSLATION      0x102
-#define MG_ERR_CTRL_RST         0x103
-#define MG_ERR_INV_STAT         0x104
-#define MG_ERR_RSTOUT           0x105
-
-#define MG_MAX_ERRORS   6       /* Max read/write errors */
-
-/* command */
-#define MG_CMD_RD 0x20
-#define MG_CMD_WR 0x30
-#define MG_CMD_SLEEP 0x99
-#define MG_CMD_WAKEUP 0xC3
-#define MG_CMD_ID 0xEC
-#define MG_CMD_WR_CONF 0x3C
-#define MG_CMD_RD_CONF 0x40
-
-/* operation mode */
-#define MG_OP_CASCADE (1 << 0)
-#define MG_OP_CASCADE_SYNC_RD (1 << 1)
-#define MG_OP_CASCADE_SYNC_WR (1 << 2)
-#define MG_OP_INTERLEAVE (1 << 3)
-
-/* synchronous */
-#define MG_BURST_LAT_4 (3 << 4)
-#define MG_BURST_LAT_5 (4 << 4)
-#define MG_BURST_LAT_6 (5 << 4)
-#define MG_BURST_LAT_7 (6 << 4)
-#define MG_BURST_LAT_8 (7 << 4)
-#define MG_BURST_LEN_4 (1 << 1)
-#define MG_BURST_LEN_8 (2 << 1)
-#define MG_BURST_LEN_16 (3 << 1)
-#define MG_BURST_LEN_32 (4 << 1)
-#define MG_BURST_LEN_CONT (0 << 1)
-
-/* timeout value (unit: ms) */
-#define MG_TMAX_CONF_TO_CMD     1
-#define MG_TMAX_WAIT_RD_DRQ     10
-#define MG_TMAX_WAIT_WR_DRQ     500
-#define MG_TMAX_RST_TO_BUSY     10
-#define MG_TMAX_HDRST_TO_RDY    500
-#define MG_TMAX_SWRST_TO_RDY    500
-#define MG_TMAX_RSTOUT          3000
+/* names of GPIO resource */
+#define MG_RST_PIN      "mg_rst"
+/* except MG_BOOT_DEV, reset-out pin should be assigned */
+#define MG_RSTOUT_PIN   "mg_rstout"
 
 /* device attribution */
 /* use mflash as boot device */
@@ -145,13 +30,6 @@
 /* same as MG_STORAGE_DEV, but bootloader already done reset sequence */
 #define MG_STORAGE_DEV_SKIP_RST (1 << 2)
 
-#define MG_DEV_MASK (MG_BOOT_DEV | MG_STORAGE_DEV | MG_STORAGE_DEV_SKIP_RST)
-
-/* names of GPIO resource */
-#define MG_RST_PIN      "mg_rst"
-/* except MG_BOOT_DEV, reset-out pin should be assigned */
-#define MG_RSTOUT_PIN   "mg_rstout"
-
 /* private driver data */
 struct mg_drv_data {
         /* disk resource */
@@ -161,46 +39,7 @@ struct mg_drv_data {
         u32 dev_attr;
 
         /* internally used */
-        struct mg_host *host;
+        void *host;
 };
 
-/* main structure for mflash driver */
-struct mg_host {
-        struct device *dev;
-
-        struct request_queue *breq;
-        spinlock_t lock;
-        struct gendisk *gd;
-
-        struct timer_list timer;
-        void (*mg_do_intr) (struct mg_host *);
-
-        u16 id[ATA_ID_WORDS];
-
-        u16 cyls;
-        u16 heads;
-        u16 sectors;
-        u32 n_sectors;
-        u32 nres_sectors;
-
-        void __iomem *dev_base;
-        unsigned int irq;
-        unsigned int rst;
-        unsigned int rstout;
-
-        u32 major;
-        u32 error;
-};
-
-/*
- * Debugging macro and defines
- */
-#undef DO_MG_DEBUG
-#ifdef DO_MG_DEBUG
-#  define MG_DBG(fmt, args...) \
-        printk(KERN_DEBUG "%s:%d "fmt, __func__, __LINE__, ##args)
-#else /* CONFIG_MG_DEBUG */
-#  define MG_DBG(fmt, args...) do { } while (0)
-#endif /* CONFIG_MG_DEBUG */
-
 #endif
diff --git a/include/linux/mii.h b/include/linux/mii.h
index ad748588faf1..359fba880274 100644
--- a/include/linux/mii.h
+++ b/include/linux/mii.h
@@ -240,6 +240,22 @@ static inline unsigned int mii_duplex (unsigned int duplex_lock,
 }
 
 /**
+ * mii_advertise_flowctrl - get flow control advertisement flags
+ * @cap: Flow control capabilities (FLOW_CTRL_RX, FLOW_CTRL_TX or both)
+ */
+static inline u16 mii_advertise_flowctrl(int cap)
+{
+        u16 adv = 0;
+
+        if (cap & FLOW_CTRL_RX)
+                adv = ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
+        if (cap & FLOW_CTRL_TX)
+                adv ^= ADVERTISE_PAUSE_ASYM;
+
+        return adv;
+}
+
+/**
  * mii_resolve_flowctrl_fdx
  * @lcladv: value of MII ADVERTISE register
  * @rmtadv: value of MII LPA register
@@ -250,18 +266,12 @@ static inline u8 mii_resolve_flowctrl_fdx(u16 lcladv, u16 rmtadv)
 {
         u8 cap = 0;
 
-        if (lcladv & ADVERTISE_PAUSE_CAP) {
-                if (lcladv & ADVERTISE_PAUSE_ASYM) {
-                        if (rmtadv & LPA_PAUSE_CAP)
-                                cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
-                        else if (rmtadv & LPA_PAUSE_ASYM)
-                                cap = FLOW_CTRL_RX;
-                } else {
-                        if (rmtadv & LPA_PAUSE_CAP)
-                                cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
-                }
-        } else if (lcladv & ADVERTISE_PAUSE_ASYM) {
-                if ((rmtadv & LPA_PAUSE_CAP) && (rmtadv & LPA_PAUSE_ASYM))
+        if (lcladv & rmtadv & ADVERTISE_PAUSE_CAP) {
+                cap = FLOW_CTRL_TX | FLOW_CTRL_RX;
+        } else if (lcladv & rmtadv & ADVERTISE_PAUSE_ASYM) {
+                if (lcladv & ADVERTISE_PAUSE_CAP)
+                        cap = FLOW_CTRL_RX;
+                else if (rmtadv & ADVERTISE_PAUSE_CAP)
                         cap = FLOW_CTRL_TX;
         }
 
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
index beb6ec99cfef..052117744629 100644
--- a/include/linux/miscdevice.h
+++ b/include/linux/miscdevice.h
@@ -41,6 +41,7 @@ struct miscdevice  {
         struct list_head list;
         struct device *parent;
         struct device *this_device;
+        const char *devnode;
 };
 
 extern int misc_register(struct miscdevice * misc);
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 3aff8a6a389e..ce7cc6c7bcbb 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -210,6 +210,7 @@ struct mlx4_caps {
         int                     num_comp_vectors;
         int                     num_mpts;
         int                     num_mtt_segs;
+        int                     mtts_per_seg;
         int                     fmr_reserved_mtts;
         int                     reserved_mtts;
         int                     reserved_mrws;
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index bf8f11982dae..9f29d86e5dc9 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -165,6 +165,7 @@ enum {
         MLX4_WQE_CTRL_IP_CSUM           = 1 << 4,
         MLX4_WQE_CTRL_TCP_UDP_CSUM      = 1 << 5,
         MLX4_WQE_CTRL_INS_VLAN          = 1 << 6,
+        MLX4_WQE_CTRL_STRONG_ORDER      = 1 << 7,
 };
 
 struct mlx4_wqe_ctrl_seg {
diff --git a/include/linux/mm.h b/include/linux/mm.h
index bff1f0d475c7..ba3a7cb1eaa0 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -7,7 +7,6 @@
 
 #include <linux/gfp.h>
 #include <linux/list.h>
-#include <linux/mmdebug.h>
 #include <linux/mmzone.h>
 #include <linux/rbtree.h>
 #include <linux/prio_tree.h>
@@ -19,6 +18,7 @@ struct anon_vma;
 struct file_ra_state;
 struct user_struct;
 struct writeback_control;
+struct rlimit;
 
 #ifndef CONFIG_DISCONTIGMEM          /* Don't use mapnrs, do it properly */
 extern unsigned long max_mapnr;
@@ -580,12 +580,10 @@ static inline void set_page_links(struct page *page, enum zone_type zone,
  */
 static inline unsigned long round_hint_to_min(unsigned long hint)
 {
-#ifdef CONFIG_SECURITY
         hint &= PAGE_MASK;
         if (((void *)hint != NULL) &&
             (hint < mmap_min_addr))
                 return PAGE_ALIGN(mmap_min_addr);
-#endif
         return hint;
 }
 
@@ -726,7 +724,7 @@ static inline int shmem_lock(struct file *file, int lock,
         return 0;
 }
 #endif
-struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags);
+struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags);
 
 int shmem_zero_setup(struct vm_area_struct *);
 
@@ -794,6 +792,8 @@ int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
                         struct vm_area_struct *vma);
 void unmap_mapping_range(struct address_space *mapping,
                 loff_t const holebegin, loff_t const holelen, int even_cows);
+int follow_pfn(struct vm_area_struct *vma, unsigned long address,
+        unsigned long *pfn);
 int follow_phys(struct vm_area_struct *vma, unsigned long address,
                 unsigned int flags, unsigned long *prot, resource_size_t *phys);
 int generic_access_phys(struct vm_area_struct *vma, unsigned long addr,
@@ -810,11 +810,11 @@ extern int vmtruncate_range(struct inode * inode, loff_t offset, loff_t end);
 
 #ifdef CONFIG_MMU
 extern int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
-                        unsigned long address, int write_access);
+                        unsigned long address, unsigned int flags);
 #else
 static inline int handle_mm_fault(struct mm_struct *mm,
                         struct vm_area_struct *vma, unsigned long address,
-                        int write_access)
+                        unsigned int flags)
 {
         /* should never happen if there's no MMU */
         BUG();
@@ -825,8 +825,11 @@ static inline int handle_mm_fault(struct mm_struct *mm,
 extern int make_pages_present(unsigned long addr, unsigned long end);
 extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
 
-int get_user_pages(struct task_struct *tsk, struct mm_struct *mm, unsigned long start,
-                int len, int write, int force, struct page **pages, struct vm_area_struct **vmas);
+int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
+                        unsigned long start, int nr_pages, int write, int force,
+                        struct page **pages, struct vm_area_struct **vmas);
+int get_user_pages_fast(unsigned long start, int nr_pages, int write,
+                        struct page **pages);
 
 extern int try_to_release_page(struct page * page, gfp_t gfp_mask);
 extern void do_invalidatepage(struct page *page, unsigned long offset);
@@ -851,17 +854,10 @@ extern int mprotect_fixup(struct vm_area_struct *vma,
                           unsigned long end, unsigned long newflags);
 
 /*
- * get_user_pages_fast provides equivalent functionality to get_user_pages,
- * operating on current and current->mm (force=0 and doesn't return any vmas).
- *
- * get_user_pages_fast may take mmap_sem and page tables, so no assumptions
- * can be made about locking. get_user_pages_fast is to be implemented in a
- * way that is advantageous (vs get_user_pages()) when the user memory area is
- * already faulted in and present in ptes. However if the pages have to be
- * faulted in, it may turn out to be slightly slower).
+ * doesn't attempt to fault and will return short.
  */
-int get_user_pages_fast(unsigned long start, int nr_pages, int write,
-                        struct page **pages);
+int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
+                          struct page **pages);
 
 /*
  * A callback you can register to apply pressure to ageable caches.
@@ -1031,8 +1027,6 @@ extern void add_active_range(unsigned int nid, unsigned long start_pfn,
                                         unsigned long end_pfn);
 extern void remove_active_range(unsigned int nid, unsigned long start_pfn,
                                         unsigned long end_pfn);
-extern void push_node_boundaries(unsigned int nid, unsigned long start_pfn,
-                                        unsigned long end_pfn);
 extern void remove_all_active_ranges(void);
 extern unsigned long absent_pages_in_range(unsigned long start_pfn,
                                                 unsigned long end_pfn);
@@ -1064,7 +1058,8 @@ extern int __meminit __early_pfn_to_nid(unsigned long pfn);
 extern void set_dma_reserve(unsigned long new_dma_reserve);
 extern void memmap_init_zone(unsigned long, int, unsigned long,
                                 unsigned long, enum memmap_context);
-extern void setup_per_zone_pages_min(void);
+extern void setup_per_zone_wmarks(void);
+extern void calculate_zone_inactive_ratio(struct zone *zone);
 extern void mem_init(void);
 extern void __init mmap_init(void);
 extern void show_mem(void);
@@ -1181,8 +1176,6 @@ void task_dirty_inc(struct task_struct *tsk);
 #define VM_MAX_READAHEAD        128     /* kbytes */
 #define VM_MIN_READAHEAD        16      /* kbytes (includes current page) */
 
-int do_page_cache_readahead(struct address_space *mapping, struct file *filp,
-                        pgoff_t offset, unsigned long nr_to_read);
 int force_page_cache_readahead(struct address_space *mapping, struct file *filp,
                         pgoff_t offset, unsigned long nr_to_read);
 
@@ -1200,6 +1193,9 @@ void page_cache_async_readahead(struct address_space *mapping,
                                 unsigned long size);
 
 unsigned long max_sane_readahead(unsigned long nr);
+unsigned long ra_submit(struct file_ra_state *ra,
+                        struct address_space *mapping,
+                        struct file *filp);
 
 /* Do stack extension */
 extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
@@ -1319,8 +1315,8 @@ int vmemmap_populate_basepages(struct page *start_page,
 int vmemmap_populate(struct page *start_page, unsigned long pages, int node);
 void vmemmap_populate_print_last(void);
 
-extern void *alloc_locked_buffer(size_t size);
-extern void free_locked_buffer(void *buffer, size_t size);
-extern void release_locked_buffer(void *buffer, size_t size);
+extern int account_locked_memory(struct mm_struct *mm, struct rlimit *rlim,
+                                 size_t size);
+extern void refund_locked_memory(struct mm_struct *mm, size_t size);
 #endif /* __KERNEL__ */
 #endif /* _LINUX_MM_H */
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 0e80e26ecf21..7acc8439d9b3 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -98,6 +98,14 @@ struct page {
 #ifdef CONFIG_WANT_PAGE_DEBUG_FLAGS
         unsigned long debug_flags;      /* Use atomic bitops on this */
 #endif
+
+#ifdef CONFIG_KMEMCHECK
+        /*
+         * kmemcheck wants to track the status of each byte in a page; this
+         * is a pointer to such a status block. NULL if not tracked.
+         */
+        void *shadow;
+#endif
 };
 
 /*
@@ -232,6 +240,8 @@ struct mm_struct {
 
         unsigned long saved_auxv[AT_VECTOR_SIZE]; /* for /proc/PID/auxv */
 
+        s8 oom_adj;     /* OOM kill score adjustment (bit shift) */
+
         cpumask_t cpu_vm_mask;
 
         /* Architecture-specific MM context */
diff --git a/include/linux/mmc/sdio_ids.h b/include/linux/mmc/sdio_ids.h
index ea1bf5ba092f..39751c8cde9c 100644
--- a/include/linux/mmc/sdio_ids.h
+++ b/include/linux/mmc/sdio_ids.h
@@ -25,5 +25,15 @@
 
 #define SDIO_VENDOR_ID_MARVELL                  0x02df
 #define SDIO_DEVICE_ID_MARVELL_LIBERTAS         0x9103
+#define SDIO_DEVICE_ID_MARVELL_8688WLAN         0x9104
+#define SDIO_DEVICE_ID_MARVELL_8688BT           0x9105
+
+#define SDIO_VENDOR_ID_SIANO                    0x039a
+#define SDIO_DEVICE_ID_SIANO_NOVA_B0            0x0201
+#define SDIO_DEVICE_ID_SIANO_NICE               0x0202
+#define SDIO_DEVICE_ID_SIANO_VEGA_A0            0x0300
+#define SDIO_DEVICE_ID_SIANO_VENICE             0x0301
+#define SDIO_DEVICE_ID_SIANO_NOVA_A0            0x1100
+#define SDIO_DEVICE_ID_SIANO_STELLAR            0x5347
 
 #endif
diff --git a/include/linux/mmiotrace.h b/include/linux/mmiotrace.h
index 3d1b7bde1283..97491f78b08c 100644
--- a/include/linux/mmiotrace.h
+++ b/include/linux/mmiotrace.h
@@ -30,6 +30,8 @@ extern unsigned int kmmio_count;
 
 extern int register_kmmio_probe(struct kmmio_probe *p);
 extern void unregister_kmmio_probe(struct kmmio_probe *p);
+extern int kmmio_init(void);
+extern void kmmio_cleanup(void);
 
 #ifdef CONFIG_MMIOTRACE
 /* kmmio is active by some kmmio_probes? */
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index a47c879e1304..889598537370 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -50,9 +50,6 @@ extern int page_group_by_mobility_disabled;
 
 static inline int get_pageblock_migratetype(struct page *page)
 {
-        if (unlikely(page_group_by_mobility_disabled))
-                return MIGRATE_UNMOVABLE;
-
         return get_pageblock_flags_group(page, PB_migrate, PB_migrate_end);
 }
 
@@ -86,13 +83,8 @@ enum zone_stat_item {
         NR_ACTIVE_ANON,         /*  "     "     "   "       "         */
         NR_INACTIVE_FILE,       /*  "     "     "   "       "         */
         NR_ACTIVE_FILE,         /*  "     "     "   "       "         */
-#ifdef CONFIG_UNEVICTABLE_LRU
         NR_UNEVICTABLE,         /*  "     "     "   "       "         */
         NR_MLOCK,               /* mlock()ed pages found and moved off LRU */
-#else
-        NR_UNEVICTABLE = NR_ACTIVE_FILE, /* avoid compiler errors in dead code */
-        NR_MLOCK = NR_ACTIVE_FILE,
-#endif
         NR_ANON_PAGES,  /* Mapped anonymous pages */
         NR_FILE_MAPPED, /* pagecache pages mapped into pagetables.
                            only modified from process context */
@@ -135,11 +127,7 @@ enum lru_list {
         LRU_ACTIVE_ANON = LRU_BASE + LRU_ACTIVE,
         LRU_INACTIVE_FILE = LRU_BASE + LRU_FILE,
         LRU_ACTIVE_FILE = LRU_BASE + LRU_FILE + LRU_ACTIVE,
-#ifdef CONFIG_UNEVICTABLE_LRU
         LRU_UNEVICTABLE,
-#else
-        LRU_UNEVICTABLE = LRU_ACTIVE_FILE, /* avoid compiler errors in dead code */
-#endif
         NR_LRU_LISTS
 };
 
@@ -159,13 +147,20 @@ static inline int is_active_lru(enum lru_list l)
 
 static inline int is_unevictable_lru(enum lru_list l)
 {
-#ifdef CONFIG_UNEVICTABLE_LRU
         return (l == LRU_UNEVICTABLE);
-#else
-        return 0;
-#endif
 }
 
+enum zone_watermarks {
+        WMARK_MIN,
+        WMARK_LOW,
+        WMARK_HIGH,
+        NR_WMARK
+};
+
+#define min_wmark_pages(z) (z->watermark[WMARK_MIN])
+#define low_wmark_pages(z) (z->watermark[WMARK_LOW])
+#define high_wmark_pages(z) (z->watermark[WMARK_HIGH])
+
 struct per_cpu_pages {
         int count;              /* number of pages in the list */
         int high;               /* high watermark, emptying needed */
@@ -278,7 +273,10 @@ struct zone_reclaim_stat {
 
 struct zone {
         /* Fields commonly accessed by the page allocator */
-        unsigned long           pages_min, pages_low, pages_high;
+
+        /* zone watermarks, access with *_wmark_pages(zone) macros */
+        unsigned long watermark[NR_WMARK];
+
         /*
          * We don't know if the memory that we're going to allocate will be freeable
          * or/and it will be released eventually, so to avoid totally wasting several
@@ -323,9 +321,9 @@ struct zone {
 
         /* Fields commonly accessed by the page reclaim scanner */
         spinlock_t              lru_lock;       
-        struct {
+        struct zone_lru {
                 struct list_head list;
-                unsigned long nr_scan;
+                unsigned long nr_saved_scan;    /* accumulated for batching */
         } lru[NR_LRU_LISTS];
 
         struct zone_reclaim_stat reclaim_stat;
diff --git a/include/linux/mnt_namespace.h b/include/linux/mnt_namespace.h
index 3a059298cc19..d74785c2393a 100644
--- a/include/linux/mnt_namespace.h
+++ b/include/linux/mnt_namespace.h
@@ -2,10 +2,9 @@
 #define _NAMESPACE_H_
 #ifdef __KERNEL__
 
-#include <linux/mount.h>
-#include <linux/sched.h>
-#include <linux/nsproxy.h>
+#include <linux/path.h>
 #include <linux/seq_file.h>
+#include <linux/wait.h>
 
 struct mnt_namespace {
         atomic_t                count;
@@ -24,24 +23,10 @@ struct proc_mounts {
 
 struct fs_struct;
 
+extern struct mnt_namespace *create_mnt_ns(struct vfsmount *mnt);
 extern struct mnt_namespace *copy_mnt_ns(unsigned long, struct mnt_namespace *,
                 struct fs_struct *);
-extern void __put_mnt_ns(struct mnt_namespace *ns);
-
-static inline void put_mnt_ns(struct mnt_namespace *ns)
-{
-        if (atomic_dec_and_lock(&ns->count, &vfsmount_lock))
-                /* releases vfsmount_lock */
-                __put_mnt_ns(ns);
-}
-
-static inline void exit_mnt_ns(struct task_struct *p)
-{
-        struct mnt_namespace *ns = p->nsproxy->mnt_ns;
-        if (ns)
-                put_mnt_ns(ns);
-}
-
+extern void put_mnt_ns(struct mnt_namespace *ns);
 static inline void get_mnt_ns(struct mnt_namespace *ns)
 {
         atomic_inc(&ns->count);
diff --git a/include/linux/module.h b/include/linux/module.h
index 627ac082e2a6..098bdb7bfacf 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -77,6 +77,7 @@ search_extable(const struct exception_table_entry *first,
 void sort_extable(struct exception_table_entry *start,
                   struct exception_table_entry *finish);
 void sort_main_extable(void);
+void trim_init_extable(struct module *m);
 
 #ifdef MODULE
 #define MODULE_GENERIC_TABLE(gtype,name)                        \
@@ -337,6 +338,14 @@ struct module
         const char **trace_bprintk_fmt_start;
         unsigned int num_trace_bprintk_fmt;
 #endif
+#ifdef CONFIG_EVENT_TRACING
+        struct ftrace_event_call *trace_events;
+        unsigned int num_trace_events;
+#endif
+#ifdef CONFIG_FTRACE_MCOUNT_RECORD
+        unsigned long *ftrace_callsites;
+        unsigned int num_ftrace_callsites;
+#endif
 
 #ifdef CONFIG_MODULE_UNLOAD
         /* What modules depend on me? */
@@ -354,6 +363,12 @@ struct module
         local_t ref;
 #endif
 #endif
+
+#ifdef CONFIG_CONSTRUCTORS
+        /* Constructor functions. */
+        ctor_fn_t *ctors;
+        unsigned int num_ctors;
+#endif
 };
 #ifndef MODULE_ARCH_INIT
 #define MODULE_ARCH_INIT {}
@@ -688,4 +703,21 @@ static inline void module_remove_modinfo_attrs(struct module *mod)
 
 #define __MODULE_STRING(x) __stringify(x)
 
+
+#ifdef CONFIG_GENERIC_BUG
+int  module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
+                         struct module *);
+void module_bug_cleanup(struct module *);
+
+#else   /* !CONFIG_GENERIC_BUG */
+
+static inline int  module_bug_finalize(const Elf_Ehdr *hdr,
+                                        const Elf_Shdr *sechdrs,
+                                        struct module *mod)
+{
+        return 0;
+}
+static inline void module_bug_cleanup(struct module *mod) {}
+#endif  /* CONFIG_GENERIC_BUG */
+
 #endif /* _LINUX_MODULE_H */
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index a4f0b931846c..6547c3cdbc4c 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -36,9 +36,14 @@ typedef int (*param_set_fn)(const char *val, struct kernel_param *kp);
 /* Returns length written or -errno.  Buffer is 4k (ie. be short!) */
 typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp);
 
+/* Flag bits for kernel_param.flags */
+#define KPARAM_KMALLOCED        1
+#define KPARAM_ISBOOL           2
+
 struct kernel_param {
         const char *name;
-        unsigned int perm;
+        u16 perm;
+        u16 flags;
         param_set_fn set;
         param_get_fn get;
         union {
@@ -79,7 +84,7 @@ struct kparam_array
    parameters.  perm sets the visibility in sysfs: 000 means it's
    not there, read bits mean it's readable, write bits mean it's
    writable. */
-#define __module_param_call(prefix, name, set, get, arg, perm)          \
+#define __module_param_call(prefix, name, set, get, arg, isbool, perm)  \
         /* Default value instead of permissions? */                     \
         static int __param_perm_check_##name __attribute__((unused)) =  \
         BUILD_BUG_ON_ZERO((perm) < 0 || (perm) > 0777 || ((perm) & 2))  \
@@ -88,10 +93,13 @@ struct kparam_array
         static struct kernel_param __moduleparam_const __param_##name   \
         __used                                                          \
     __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
-        = { __param_str_##name, perm, set, get, { arg } }
+        = { __param_str_##name, perm, isbool ? KPARAM_ISBOOL : 0,       \
+            set, get, { arg } }
 
 #define module_param_call(name, set, get, arg, perm)                          \
-        __module_param_call(MODULE_PARAM_PREFIX, name, set, get, arg, perm)
+        __module_param_call(MODULE_PARAM_PREFIX,                              \
+                            name, set, get, arg,                              \
+                            __same_type(*(arg), bool), perm)
 
 /* Helper functions: type is byte, short, ushort, int, uint, long,
    ulong, charp, bool or invbool, or XXX if you define param_get_XXX,
@@ -120,15 +128,16 @@ struct kparam_array
 #define core_param(name, var, type, perm)                               \
         param_check_##type(name, &(var));                               \
         __module_param_call("", name, param_set_##type, param_get_##type, \
-                            &var, perm)
+                            &var, __same_type(var, bool), perm)
 #endif /* !MODULE */
 
 /* Actually copy string: maxlen param is usually sizeof(string). */
 #define module_param_string(name, string, len, perm)                    \
         static const struct kparam_string __param_string_##name         \
                 = { len, string };                                      \
-        module_param_call(name, param_set_copystring, param_get_string, \
-                          .str = &__param_string_##name, perm);         \
+        __module_param_call(MODULE_PARAM_PREFIX, name,                  \
+                            param_set_copystring, param_get_string,     \
+                            .str = &__param_string_##name, 0, perm);    \
         __MODULE_PARM_TYPE(name, "string")
 
 /* Called on module insert or kernel boot */
@@ -186,21 +195,30 @@ extern int param_set_charp(const char *val, struct kernel_param *kp);
 extern int param_get_charp(char *buffer, struct kernel_param *kp);
 #define param_check_charp(name, p) __param_check(name, p, char *)
 
+/* For historical reasons "bool" parameters can be (unsigned) "int". */
 extern int param_set_bool(const char *val, struct kernel_param *kp);
 extern int param_get_bool(char *buffer, struct kernel_param *kp);
-#define param_check_bool(name, p) __param_check(name, p, int)
+#define param_check_bool(name, p)                                       \
+        static inline void __check_##name(void)                         \
+        {                                                               \
+                BUILD_BUG_ON(!__same_type(*(p), bool) &&                \
+                             !__same_type(*(p), unsigned int) &&        \
+                             !__same_type(*(p), int));                  \
+        }
 
 extern int param_set_invbool(const char *val, struct kernel_param *kp);
 extern int param_get_invbool(char *buffer, struct kernel_param *kp);
-#define param_check_invbool(name, p) __param_check(name, p, int)
+#define param_check_invbool(name, p) __param_check(name, p, bool)
 
 /* Comma-separated array: *nump is set to number they actually specified. */
 #define module_param_array_named(name, array, type, nump, perm)         \
         static const struct kparam_array __param_arr_##name             \
         = { ARRAY_SIZE(array), nump, param_set_##type, param_get_##type,\
             sizeof(array[0]), array };                                  \
-        module_param_call(name, param_array_set, param_array_get,       \
-                          .arr = &__param_arr_##name, perm);            \
+        __module_param_call(MODULE_PARAM_PREFIX, name,                  \
+                            param_array_set, param_array_get,           \
+                            .arr = &__param_arr_##name,                 \
+                            __same_type(array[0], bool), perm);         \
         __MODULE_PARM_TYPE(name, "array of " #type)
 
 #define module_param_array(name, type, nump, perm)              \
diff --git a/include/linux/mount.h b/include/linux/mount.h
index 51f55f903aff..5d5275364867 100644
--- a/include/linux/mount.h
+++ b/include/linux/mount.h
@@ -30,7 +30,7 @@ struct mnt_namespace;
 #define MNT_STRICTATIME 0x80
 
 #define MNT_SHRINKABLE  0x100
-#define MNT_IMBALANCED_WRITE_COUNT      0x200 /* just for debugging */
+#define MNT_WRITE_HOLD  0x200
 
 #define MNT_SHARED      0x1000  /* if the vfsmount is a shared mount */
 #define MNT_UNBINDABLE  0x2000  /* if the vfsmount is a unbindable mount */
@@ -65,13 +65,22 @@ struct vfsmount {
         int mnt_expiry_mark;            /* true if marked for expiry */
         int mnt_pinned;
         int mnt_ghosts;
-        /*
-         * This value is not stable unless all of the mnt_writers[] spinlocks
-         * are held, and all mnt_writer[]s on this mount have 0 as their ->count
-         */
-        atomic_t __mnt_writers;
+#ifdef CONFIG_SMP
+        int *mnt_writers;
+#else
+        int mnt_writers;
+#endif
 };
 
+static inline int *get_mnt_writers_ptr(struct vfsmount *mnt)
+{
+#ifdef CONFIG_SMP
+        return mnt->mnt_writers;
+#else
+        return &mnt->mnt_writers;
+#endif
+}
+
 static inline struct vfsmount *mntget(struct vfsmount *mnt)
 {
         if (mnt)
@@ -79,7 +88,11 @@ static inline struct vfsmount *mntget(struct vfsmount *mnt)
         return mnt;
 }
 
+struct file; /* forward dec */
+
 extern int mnt_want_write(struct vfsmount *mnt);
+extern int mnt_want_write_file(struct file *file);
+extern int mnt_clone_write(struct vfsmount *mnt);
 extern void mnt_drop_write(struct vfsmount *mnt);
 extern void mntput_no_expire(struct vfsmount *mnt);
 extern void mnt_pin(struct vfsmount *mnt);
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 7efb9be34662..4030ebada49e 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -563,6 +563,7 @@ extern int nand_do_read(struct mtd_info *mtd, loff_t from, size_t len,
  * @options:            Option flags, e.g. 16bit buswidth
  * @ecclayout:          ecc layout info structure
  * @part_probe_types:   NULL-terminated array of probe types
+ * @set_parts:          platform specific function to set partitions
  * @priv:               hardware controller specific settings
  */
 struct platform_nand_chip {
@@ -574,26 +575,41 @@ struct platform_nand_chip {
         int                     chip_delay;
         unsigned int            options;
         const char              **part_probe_types;
+        void                    (*set_parts)(uint64_t size,
+                                        struct platform_nand_chip *chip);
         void                    *priv;
 };
 
+/* Keep gcc happy */
+struct platform_device;
+
 /**
  * struct platform_nand_ctrl - controller level device structure
+ * @probe:              platform specific function to probe/setup hardware
+ * @remove:             platform specific function to remove/teardown hardware
  * @hwcontrol:          platform specific hardware control structure
  * @dev_ready:          platform specific function to read ready/busy pin
  * @select_chip:        platform specific chip select function
  * @cmd_ctrl:           platform specific function for controlling
  *                      ALE/CLE/nCE. Also used to write command and address
+ * @write_buf:          platform specific function for write buffer
+ * @read_buf:           platform specific function for read buffer
  * @priv:               private data to transport driver specific settings
  *
  * All fields are optional and depend on the hardware driver requirements
  */
 struct platform_nand_ctrl {
+        int             (*probe)(struct platform_device *pdev);
+        void            (*remove)(struct platform_device *pdev);
         void            (*hwcontrol)(struct mtd_info *mtd, int cmd);
         int             (*dev_ready)(struct mtd_info *mtd);
         void            (*select_chip)(struct mtd_info *mtd, int chip);
         void            (*cmd_ctrl)(struct mtd_info *mtd, int dat,
                                     unsigned int ctrl);
+        void            (*write_buf)(struct mtd_info *mtd,
+                                    const uint8_t *buf, int len);
+        void            (*read_buf)(struct mtd_info *mtd,
+                                    uint8_t *buf, int len);
         void            *priv;
 };
 
diff --git a/include/linux/mtd/onenand.h b/include/linux/mtd/onenand.h
index 9aa2a9149b58..8ed873374381 100644
--- a/include/linux/mtd/onenand.h
+++ b/include/linux/mtd/onenand.h
@@ -17,6 +17,7 @@
 #include <linux/mtd/onenand_regs.h>
 #include <linux/mtd/bbm.h>
 
+#define MAX_DIES                2
 #define MAX_BUFFERRAM           2
 
 /* Scan and identify a OneNAND device */
@@ -51,7 +52,12 @@ struct onenand_bufferram {
 /**
  * struct onenand_chip - OneNAND Private Flash Chip Data
  * @base:               [BOARDSPECIFIC] address to access OneNAND
+ * @dies:               [INTERN][FLEX-ONENAND] number of dies on chip
+ * @boundary:           [INTERN][FLEX-ONENAND] Boundary of the dies
+ * @diesize:            [INTERN][FLEX-ONENAND] Size of the dies
  * @chipsize:           [INTERN] the size of one chip for multichip arrays
+ *                      FIXME For Flex-OneNAND, chipsize holds maximum possible
+ *                      device size ie when all blocks are considered MLC
  * @device_id:          [INTERN] device ID
  * @density_mask:       chip density, used for DDP devices
  * @verstion_id:        [INTERN] version ID
@@ -68,6 +74,8 @@ struct onenand_bufferram {
  * @command:            [REPLACEABLE] hardware specific function for writing
  *                      commands to the chip
  * @wait:               [REPLACEABLE] hardware specific function for wait on ready
+ * @bbt_wait:           [REPLACEABLE] hardware specific function for bbt wait on ready
+ * @unlock_all:         [REPLACEABLE] hardware specific function for unlock all
  * @read_bufferram:     [REPLACEABLE] hardware specific function for BufferRAM Area
  * @write_bufferram:    [REPLACEABLE] hardware specific function for BufferRAM Area
  * @read_word:          [REPLACEABLE] hardware specific function for read
@@ -92,9 +100,13 @@ struct onenand_bufferram {
  */
 struct onenand_chip {
         void __iomem            *base;
+        unsigned                dies;
+        unsigned                boundary[MAX_DIES];
+        loff_t                  diesize[MAX_DIES];
         unsigned int            chipsize;
         unsigned int            device_id;
         unsigned int            version_id;
+        unsigned int            technology;
         unsigned int            density_mask;
         unsigned int            options;
 
@@ -108,6 +120,8 @@ struct onenand_chip {
 
         int (*command)(struct mtd_info *mtd, int cmd, loff_t address, size_t len);
         int (*wait)(struct mtd_info *mtd, int state);
+        int (*bbt_wait)(struct mtd_info *mtd, int state);
+        void (*unlock_all)(struct mtd_info *mtd);
         int (*read_bufferram)(struct mtd_info *mtd, int area,
                         unsigned char *buffer, int offset, size_t count);
         int (*write_bufferram)(struct mtd_info *mtd, int area,
@@ -145,6 +159,8 @@ struct onenand_chip {
 #define ONENAND_SET_BUFFERRAM0(this)            (this->bufferram_index = 0)
 #define ONENAND_SET_BUFFERRAM1(this)            (this->bufferram_index = 1)
 
+#define FLEXONENAND(this)                                               \
+        (this->device_id & DEVICE_IS_FLEXONENAND)
 #define ONENAND_GET_SYS_CFG1(this)                                      \
         (this->read_word(this->base + ONENAND_REG_SYS_CFG1))
 #define ONENAND_SET_SYS_CFG1(v, this)                                   \
@@ -153,6 +169,9 @@ struct onenand_chip {
 #define ONENAND_IS_DDP(this)                                            \
         (this->device_id & ONENAND_DEVICE_IS_DDP)
 
+#define ONENAND_IS_MLC(this)                                            \
+        (this->technology & ONENAND_TECHNOLOGY_IS_MLC)
+
 #ifdef CONFIG_MTD_ONENAND_2X_PROGRAM
 #define ONENAND_IS_2PLANE(this)                                         \
         (this->options & ONENAND_HAS_2PLANE)
@@ -169,6 +188,7 @@ struct onenand_chip {
 #define ONENAND_HAS_CONT_LOCK           (0x0001)
 #define ONENAND_HAS_UNLOCK_ALL          (0x0002)
 #define ONENAND_HAS_2PLANE              (0x0004)
+#define ONENAND_SKIP_UNLOCK_CHECK       (0x0100)
 #define ONENAND_PAGEBUF_ALLOC           (0x1000)
 #define ONENAND_OOBBUF_ALLOC            (0x2000)
 
@@ -176,6 +196,7 @@ struct onenand_chip {
  * OneNAND Flash Manufacturer ID Codes
  */
 #define ONENAND_MFR_SAMSUNG     0xec
+#define ONENAND_MFR_NUMONYX     0x20
 
 /**
  * struct onenand_manufacturers - NAND Flash Manufacturer ID Structure
@@ -189,5 +210,8 @@ struct onenand_manufacturers {
 
 int onenand_bbt_read_oob(struct mtd_info *mtd, loff_t from,
                          struct mtd_oob_ops *ops);
+unsigned onenand_block(struct onenand_chip *this, loff_t addr);
+loff_t onenand_addr(struct onenand_chip *this, int block);
+int flexonenand_region(struct mtd_info *mtd, loff_t addr);
 
 #endif  /* __LINUX_MTD_ONENAND_H */
diff --git a/include/linux/mtd/onenand_regs.h b/include/linux/mtd/onenand_regs.h
index 0c6bbe28f38c..86a6bbef6465 100644
--- a/include/linux/mtd/onenand_regs.h
+++ b/include/linux/mtd/onenand_regs.h
@@ -67,6 +67,9 @@
 /*
  * Device ID Register F001h (R)
  */
+#define DEVICE_IS_FLEXONENAND           (1 << 9)
+#define FLEXONENAND_PI_MASK             (0x3ff)
+#define FLEXONENAND_PI_UNLOCK_SHIFT     (14)
 #define ONENAND_DEVICE_DENSITY_MASK     (0xf)
 #define ONENAND_DEVICE_DENSITY_SHIFT    (4)
 #define ONENAND_DEVICE_IS_DDP           (1 << 3)
@@ -84,6 +87,11 @@
 #define ONENAND_VERSION_PROCESS_SHIFT   (8)
 
 /*
+ * Technology Register F006h (R)
+ */
+#define ONENAND_TECHNOLOGY_IS_MLC       (1 << 0)
+
+/*
  * Start Address 1 F100h (R/W) & Start Address 2 F101h (R/W)
  */
 #define ONENAND_DDP_SHIFT               (15)
@@ -93,7 +101,8 @@
 /*
  * Start Address 8 F107h (R/W)
  */
-#define ONENAND_FPA_MASK                (0x3f)
+/* Note: It's actually 0x3f in case of SLC */
+#define ONENAND_FPA_MASK                (0x7f)
 #define ONENAND_FPA_SHIFT               (2)
 #define ONENAND_FSA_MASK                (0x03)
 
@@ -105,7 +114,8 @@
 #define ONENAND_BSA_BOOTRAM             (0 << 2)
 #define ONENAND_BSA_DATARAM0            (2 << 2)
 #define ONENAND_BSA_DATARAM1            (3 << 2)
-#define ONENAND_BSC_MASK                (0x03)
+/* Note: It's actually 0x03 in case of SLC */
+#define ONENAND_BSC_MASK                (0x07)
 
 /*
  * Command Register F220h (R/W)
@@ -124,9 +134,13 @@
 #define ONENAND_CMD_RESET               (0xF0)
 #define ONENAND_CMD_OTP_ACCESS          (0x65)
 #define ONENAND_CMD_READID              (0x90)
+#define FLEXONENAND_CMD_PI_UPDATE       (0x05)
+#define FLEXONENAND_CMD_PI_ACCESS       (0x66)
+#define FLEXONENAND_CMD_RECOVER_LSB     (0x05)
 
 /* NOTE: Those are not *REAL* commands */
 #define ONENAND_CMD_BUFFERRAM           (0x1978)
+#define FLEXONENAND_CMD_READ_PI         (0x1985)
 
 /*
  * System Configuration 1 Register F221h (R, R/W)
@@ -192,10 +206,12 @@
 #define ONENAND_ECC_1BIT_ALL            (0x5555)
 #define ONENAND_ECC_2BIT                (1 << 1)
 #define ONENAND_ECC_2BIT_ALL            (0xAAAA)
+#define FLEXONENAND_UNCORRECTABLE_ERROR (0x1010)
 
 /*
  * One-Time Programmable (OTP)
  */
+#define FLEXONENAND_OTP_LOCK_OFFSET             (2048)
 #define ONENAND_OTP_LOCK_OFFSET         (14)
 
 #endif  /* __ONENAND_REG_H */
diff --git a/include/linux/mtd/partitions.h b/include/linux/mtd/partitions.h
index 7535a74083b9..af6dcb992bc3 100644
--- a/include/linux/mtd/partitions.h
+++ b/include/linux/mtd/partitions.h
@@ -40,7 +40,6 @@ struct mtd_partition {
         uint64_t offset;                /* offset within the master MTD space */
         uint32_t mask_flags;            /* master MTD flags to mask out for this partition */
         struct nand_ecclayout *ecclayout;       /* out of band layout for this partition (NAND only)*/
-        struct mtd_info **mtdp;         /* pointer to store the MTD object */
 };
 
 #define MTDPART_OFS_NXTBLK      (-2)
diff --git a/include/linux/mtd/ubi.h b/include/linux/mtd/ubi.h
index 6316fafe5c2a..6913b71d9ab2 100644
--- a/include/linux/mtd/ubi.h
+++ b/include/linux/mtd/ubi.h
@@ -132,6 +132,39 @@ struct ubi_device_info {
         dev_t cdev;
 };
 
+/*
+ * enum - volume notification types.
+ * @UBI_VOLUME_ADDED: volume has been added
+ * @UBI_VOLUME_REMOVED: start volume volume
+ * @UBI_VOLUME_RESIZED: volume size has been re-sized
+ * @UBI_VOLUME_RENAMED: volume name has been re-named
+ * @UBI_VOLUME_UPDATED: volume name has been updated
+ *
+ * These constants define which type of event has happened when a volume
+ * notification function is invoked.
+ */
+enum {
+        UBI_VOLUME_ADDED,
+        UBI_VOLUME_REMOVED,
+        UBI_VOLUME_RESIZED,
+        UBI_VOLUME_RENAMED,
+        UBI_VOLUME_UPDATED,
+};
+
+/*
+ * struct ubi_notification - UBI notification description structure.
+ * @di: UBI device description object
+ * @vi: UBI volume description object
+ *
+ * UBI notifiers are called with a pointer to an object of this type. The
+ * object describes the notification. Namely, it provides a description of the
+ * UBI device and UBI volume the notification informs about.
+ */
+struct ubi_notification {
+        struct ubi_device_info di;
+        struct ubi_volume_info vi;
+};
+
 /* UBI descriptor given to users when they open UBI volumes */
 struct ubi_volume_desc;
 
@@ -141,6 +174,10 @@ void ubi_get_volume_info(struct ubi_volume_desc *desc,
 struct ubi_volume_desc *ubi_open_volume(int ubi_num, int vol_id, int mode);
 struct ubi_volume_desc *ubi_open_volume_nm(int ubi_num, const char *name,
                                            int mode);
+int ubi_register_volume_notifier(struct notifier_block *nb,
+                                 int ignore_existing);
+int ubi_unregister_volume_notifier(struct notifier_block *nb);
+
 void ubi_close_volume(struct ubi_volume_desc *desc);
 int ubi_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset,
                  int len, int check);
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index 3069ec7e0ab8..878cab4f5fcc 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -150,5 +150,6 @@ extern int __must_check mutex_lock_killable(struct mutex *lock);
  */
 extern int mutex_trylock(struct mutex *lock);
 extern void mutex_unlock(struct mutex *lock);
+extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
 
 #endif
diff --git a/include/linux/namei.h b/include/linux/namei.h
index 518098fe63af..d870ae2faedc 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -18,6 +18,7 @@ enum { MAX_NESTED_LINKS = 8 };
 struct nameidata {
         struct path     path;
         struct qstr     last;
+        struct path     root;
         unsigned int    flags;
         int             last_type;
         unsigned        depth;
@@ -77,8 +78,8 @@ extern void release_open_intent(struct nameidata *);
 extern struct dentry *lookup_one_len(const char *, struct dentry *, int);
 extern struct dentry *lookup_one_noperm(const char *, struct dentry *);
 
-extern int follow_down(struct vfsmount **, struct dentry **);
-extern int follow_up(struct vfsmount **, struct dentry **);
+extern int follow_down(struct path *);
+extern int follow_up(struct path *);
 
 extern struct dentry *lock_rename(struct dentry *, struct dentry *);
 extern void unlock_rename(struct dentry *, struct dentry *);
diff --git a/include/linux/net_dropmon.h b/include/linux/net_dropmon.h
index 0e2e100c44a2..3ceb0cc1bc78 100644
--- a/include/linux/net_dropmon.h
+++ b/include/linux/net_dropmon.h
@@ -3,12 +3,20 @@
 
 #include <linux/types.h>
 #include <linux/netlink.h>
+#include <linux/types.h>
 
 struct net_dm_drop_point {
         __u8 pc[8];
         __u32 count;
 };
 
+#define is_drop_point_hw(x) do {\
+        int ____i, ____j;\
+        for (____i = 0; ____i < 8; i ____i++)\
+                ____j |= x[____i];\
+        ____j;\
+} while (0)
+
 #define NET_DM_CFG_VERSION  0
 #define NET_DM_CFG_ALERT_COUNT  1
 #define NET_DM_CFG_ALERT_DELAY 2
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 5a96a1a406e9..d4a4d9867794 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -39,9 +39,11 @@
 
 #include <linux/device.h>
 #include <linux/percpu.h>
+#include <linux/rculist.h>
 #include <linux/dmaengine.h>
 #include <linux/workqueue.h>
 
+#include <linux/ethtool.h>
 #include <net/net_namespace.h>
 #include <net/dsa.h>
 #ifdef CONFIG_DCB
@@ -49,7 +51,6 @@
 #endif
 
 struct vlan_group;
-struct ethtool_ops;
 struct netpoll_info;
 /* 802.11 specific */
 struct wireless_dev;
@@ -210,6 +211,24 @@ struct dev_addr_list
 #define dmi_users       da_users
 #define dmi_gusers      da_gusers
 
+struct netdev_hw_addr {
+        struct list_head        list;
+        unsigned char           addr[MAX_ADDR_LEN];
+        unsigned char           type;
+#define NETDEV_HW_ADDR_T_LAN            1
+#define NETDEV_HW_ADDR_T_SAN            2
+#define NETDEV_HW_ADDR_T_SLAVE          3
+#define NETDEV_HW_ADDR_T_UNICAST        4
+        int                     refcount;
+        bool                    synced;
+        struct rcu_head         rcu_head;
+};
+
+struct netdev_hw_addr_list {
+        struct list_head        list;
+        int                     count;
+};
+
 struct hh_cache
 {
         struct hh_cache *hh_next;       /* Next entry                        */
@@ -447,12 +466,25 @@ enum netdev_queue_state_t
 };
 
 struct netdev_queue {
+/*
+ * read mostly part
+ */
         struct net_device       *dev;
         struct Qdisc            *qdisc;
         unsigned long           state;
-        spinlock_t              _xmit_lock;
-        int                     xmit_lock_owner;
         struct Qdisc            *qdisc_sleeping;
+/*
+ * write mostly part
+ */
+        spinlock_t              _xmit_lock ____cacheline_aligned_in_smp;
+        int                     xmit_lock_owner;
+        /*
+         * please use this field instead of dev->trans_start
+         */
+        unsigned long           trans_start;
+        unsigned long           tx_bytes;
+        unsigned long           tx_packets;
+        unsigned long           tx_dropped;
 } ____cacheline_aligned_in_smp;
 
 
@@ -670,7 +702,9 @@ struct net_device
 #define NETIF_F_GRO             16384   /* Generic receive offload */
 #define NETIF_F_LRO             32768   /* large receive offload */
 
+/* the GSO_MASK reserves bits 16 through 23 */
 #define NETIF_F_FCOE_CRC        (1 << 24) /* FCoE CRC32 */
+#define NETIF_F_SCTP_CSUM       (1 << 25) /* SCTP checksum offload */
 
         /* Segmentation offload features */
 #define NETIF_F_GSO_SHIFT       16
@@ -747,10 +781,10 @@ struct net_device
         unsigned char           addr_len;       /* hardware address length      */
         unsigned short          dev_id;         /* for shared network cards */
 
-        spinlock_t              addr_list_lock;
-        struct dev_addr_list    *uc_list;       /* Secondary unicast mac addresses */
-        int                     uc_count;       /* Number of installed ucasts   */
+        struct netdev_hw_addr_list      uc;     /* Secondary unicast
+                                                   mac addresses */
         int                     uc_promisc;
+        spinlock_t              addr_list_lock;
         struct dev_addr_list    *mc_list;       /* Multicast mac addresses      */
         int                     mc_count;       /* Number of installed mcasts   */
         unsigned int            promiscuity;
@@ -776,8 +810,12 @@ struct net_device
  */
         unsigned long           last_rx;        /* Time of last Rx      */
         /* Interface address info used in eth_type_trans() */
-        unsigned char           dev_addr[MAX_ADDR_LEN]; /* hw address, (before bcast
-                                                           because most packets are unicast) */
+        unsigned char           *dev_addr;      /* hw address, (before bcast
+                                                   because most packets are
+                                                   unicast) */
+
+        struct netdev_hw_addr_list      dev_addrs; /* list of device
+                                                      hw addresses */
 
         unsigned char           broadcast[MAX_ADDR_LEN];        /* hw bcast add */
 
@@ -797,6 +835,11 @@ struct net_device
  * One part is mostly used on xmit path (device)
  */
         /* These may be needed for future network-power-down code. */
+
+        /*
+         * trans_start here is expensive for high speed devices on SMP,
+         * please use netdev_queue->trans_start instead.
+         */
         unsigned long           trans_start;    /* Time (in jiffies) of last Tx */
 
         int                     watchdog_timeo; /* used by dev_watchdog() */
@@ -867,49 +910,10 @@ struct net_device
         /* max exchange id for FCoE LRO by ddp */
         unsigned int            fcoe_ddp_xid;
 #endif
-
-#ifdef CONFIG_COMPAT_NET_DEV_OPS
-        struct {
-                int                     (*init)(struct net_device *dev);
-                void                    (*uninit)(struct net_device *dev);
-                int                     (*open)(struct net_device *dev);
-                int                     (*stop)(struct net_device *dev);
-                int                     (*hard_start_xmit) (struct sk_buff *skb,
-                                                            struct net_device *dev);
-                u16                     (*select_queue)(struct net_device *dev,
-                                                        struct sk_buff *skb);
-                void                    (*change_rx_flags)(struct net_device *dev,
-                                                           int flags);
-                void                    (*set_rx_mode)(struct net_device *dev);
-                void                    (*set_multicast_list)(struct net_device *dev);
-                int                     (*set_mac_address)(struct net_device *dev,
-                                                           void *addr);
-                int                     (*validate_addr)(struct net_device *dev);
-                int                     (*do_ioctl)(struct net_device *dev,
-                                                    struct ifreq *ifr, int cmd);
-                int                     (*set_config)(struct net_device *dev,
-                                                      struct ifmap *map);
-                int                     (*change_mtu)(struct net_device *dev, int new_mtu);
-                int                     (*neigh_setup)(struct net_device *dev,
-                                                       struct neigh_parms *);
-                void                    (*tx_timeout) (struct net_device *dev);
-                struct net_device_stats* (*get_stats)(struct net_device *dev);
-                void                    (*vlan_rx_register)(struct net_device *dev,
-                                                            struct vlan_group *grp);
-                void                    (*vlan_rx_add_vid)(struct net_device *dev,
-                                                           unsigned short vid);
-                void                    (*vlan_rx_kill_vid)(struct net_device *dev,
-                                                            unsigned short vid);
-#ifdef CONFIG_NET_POLL_CONTROLLER
-                void                    (*poll_controller)(struct net_device *dev);
-#endif
-        };
-#endif
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 
 #define NETDEV_ALIGN            32
-#define NETDEV_ALIGN_CONST      (NETDEV_ALIGN - 1)
 
 static inline
 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
@@ -980,9 +984,7 @@ static inline bool netdev_uses_trailer_tags(struct net_device *dev)
  */
 static inline void *netdev_priv(const struct net_device *dev)
 {
-        return (char *)dev + ((sizeof(struct net_device)
-                               + NETDEV_ALIGN_CONST)
-                              & ~NETDEV_ALIGN_CONST);
+        return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
 }
 
 /* Set the sysfs physical device reference for the network logical device
@@ -1012,6 +1014,12 @@ void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
 void netif_napi_del(struct napi_struct *napi);
 
 struct napi_gro_cb {
+        /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
+        void *frag0;
+
+        /* Length of frag0. */
+        unsigned int frag0_len;
+
         /* This indicates where we are processing relative to skb->data. */
         int data_offset;
 
@@ -1047,14 +1055,6 @@ struct packet_type {
         struct list_head        list;
 };
 
-struct napi_gro_fraginfo {
-        skb_frag_t frags[MAX_SKB_FRAGS];
-        unsigned int nr_frags;
-        unsigned int ip_summed;
-        unsigned int len;
-        __wsum csum;
-};
-
 #include <linux/interrupt.h>
 #include <linux/notifier.h>
 
@@ -1119,9 +1119,9 @@ extern int		dev_restart(struct net_device *dev);
 #ifdef CONFIG_NETPOLL_TRAP
 extern int              netpoll_trap(void);
 #endif
-extern void           *skb_gro_header(struct sk_buff *skb, unsigned int hlen);
 extern int             skb_gro_receive(struct sk_buff **head,
                                        struct sk_buff *skb);
+extern void            skb_gro_reset_offset(struct sk_buff *skb);
 
 static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
 {
@@ -1138,16 +1138,34 @@ static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
         NAPI_GRO_CB(skb)->data_offset += len;
 }
 
-static inline void skb_gro_reset_offset(struct sk_buff *skb)
+static inline void *skb_gro_header_fast(struct sk_buff *skb,
+                                        unsigned int offset)
+{
+        return NAPI_GRO_CB(skb)->frag0 + offset;
+}
+
+static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
+{
+        return NAPI_GRO_CB(skb)->frag0_len < hlen;
+}
+
+static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
+                                        unsigned int offset)
 {
-        NAPI_GRO_CB(skb)->data_offset = 0;
+        NAPI_GRO_CB(skb)->frag0 = NULL;
+        NAPI_GRO_CB(skb)->frag0_len = 0;
+        return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
 }
 
 static inline void *skb_gro_mac_header(struct sk_buff *skb)
 {
-        return skb_mac_header(skb) < skb->data ? skb_mac_header(skb) :
-               page_address(skb_shinfo(skb)->frags[0].page) +
-               skb_shinfo(skb)->frags[0].page_offset;
+        return NAPI_GRO_CB(skb)->frag0 ?: skb_mac_header(skb);
+}
+
+static inline void *skb_gro_network_header(struct sk_buff *skb)
+{
+        return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
+               skb_network_offset(skb);
 }
 
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
@@ -1442,12 +1460,18 @@ extern int		napi_gro_receive(struct napi_struct *napi,
                                          struct sk_buff *skb);
 extern void             napi_reuse_skb(struct napi_struct *napi,
                                        struct sk_buff *skb);
-extern struct sk_buff * napi_fraginfo_skb(struct napi_struct *napi,
-                                          struct napi_gro_fraginfo *info);
+extern struct sk_buff * napi_get_frags(struct napi_struct *napi);
 extern int              napi_frags_finish(struct napi_struct *napi,
                                           struct sk_buff *skb, int ret);
-extern int              napi_gro_frags(struct napi_struct *napi,
-                                       struct napi_gro_fraginfo *info);
+extern struct sk_buff * napi_frags_skb(struct napi_struct *napi);
+extern int              napi_gro_frags(struct napi_struct *napi);
+
+static inline void napi_free_frags(struct napi_struct *napi)
+{
+        kfree_skb(napi->skb);
+        napi->skb = NULL;
+}
+
 extern void             netif_nit_deliver(struct sk_buff *skb);
 extern int              dev_valid_name(const char *name);
 extern int              dev_ioctl(struct net *net, unsigned int cmd, void __user *);
@@ -1514,6 +1538,8 @@ static inline int netif_carrier_ok(const struct net_device *dev)
         return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
 }
 
+extern unsigned long dev_trans_start(struct net_device *dev);
+
 extern void __netdev_watchdog_up(struct net_device *dev);
 
 extern void netif_carrier_on(struct net_device *dev);
@@ -1671,6 +1697,12 @@ static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
         spin_unlock_bh(&txq->_xmit_lock);
 }
 
+static inline void txq_trans_update(struct netdev_queue *txq)
+{
+        if (txq->xmit_lock_owner != -1)
+                txq->trans_start = jiffies;
+}
+
 /**
  *      netif_tx_lock - grab network device transmit lock
  *      @dev: network device
@@ -1778,6 +1810,13 @@ static inline void netif_addr_unlock_bh(struct net_device *dev)
         spin_unlock_bh(&dev->addr_list_lock);
 }
 
+/*
+ * dev_addrs walker. Should be used only for read access. Call with
+ * rcu_read_lock held.
+ */
+#define for_each_dev_addr(dev, ha) \
+                list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
+
 /* These functions live elsewhere (drivers/net/net_init.c, but related) */
 
 extern void             ether_setup(struct net_device *dev);
@@ -1790,11 +1829,24 @@ extern struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
         alloc_netdev_mq(sizeof_priv, name, setup, 1)
 extern int              register_netdev(struct net_device *dev);
 extern void             unregister_netdev(struct net_device *dev);
+
+/* Functions used for device addresses handling */
+extern int dev_addr_add(struct net_device *dev, unsigned char *addr,
+                        unsigned char addr_type);
+extern int dev_addr_del(struct net_device *dev, unsigned char *addr,
+                        unsigned char addr_type);
+extern int dev_addr_add_multiple(struct net_device *to_dev,
+                                 struct net_device *from_dev,
+                                 unsigned char addr_type);
+extern int dev_addr_del_multiple(struct net_device *to_dev,
+                                 struct net_device *from_dev,
+                                 unsigned char addr_type);
+
 /* Functions used for secondary unicast and multicast support */
 extern void             dev_set_rx_mode(struct net_device *dev);
 extern void             __dev_set_rx_mode(struct net_device *dev);
-extern int              dev_unicast_delete(struct net_device *dev, void *addr, int alen);
-extern int              dev_unicast_add(struct net_device *dev, void *addr, int alen);
+extern int              dev_unicast_delete(struct net_device *dev, void *addr);
+extern int              dev_unicast_add(struct net_device *dev, void *addr);
 extern int              dev_unicast_sync(struct net_device *to, struct net_device *from);
 extern void             dev_unicast_unsync(struct net_device *to, struct net_device *from);
 extern int              dev_mc_delete(struct net_device *dev, void *addr, int alen, int all);
@@ -1856,15 +1908,14 @@ static inline int net_gso_ok(int features, int gso_type)
 
 static inline int skb_gso_ok(struct sk_buff *skb, int features)
 {
-        return net_gso_ok(features, skb_shinfo(skb)->gso_type);
+        return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
+               (!skb_has_frags(skb) || (features & NETIF_F_FRAGLIST));
 }
 
 static inline int netif_needs_gso(struct net_device *dev, struct sk_buff *skb)
 {
         return skb_is_gso(skb) &&
                (!skb_gso_ok(skb, dev->features) ||
-                (skb_shinfo(skb)->frag_list &&
-                 !(dev->features & NETIF_F_FRAGLIST)) ||
                 unlikely(skb->ip_summed != CHECKSUM_PARTIAL));
 }
 
@@ -1874,6 +1925,16 @@ static inline void netif_set_gso_max_size(struct net_device *dev,
         dev->gso_max_size = size;
 }
 
+static inline void skb_bond_set_mac_by_master(struct sk_buff *skb,
+                                              struct net_device *master)
+{
+        if (skb->pkt_type == PACKET_HOST) {
+                u16 *dest = (u16 *) eth_hdr(skb)->h_dest;
+
+                memcpy(dest, master->dev_addr, ETH_ALEN);
+        }
+}
+
 /* On bonding slaves other than the currently active slave, suppress
  * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and
  * ARP on active-backup slaves with arp_validate enabled.
@@ -1887,6 +1948,14 @@ static inline int skb_bond_should_drop(struct sk_buff *skb)
                 if (master->priv_flags & IFF_MASTER_ARPMON)
                         dev->last_rx = jiffies;
 
+                if ((master->priv_flags & IFF_MASTER_ALB) && master->br_port) {
+                        /* Do address unmangle. The local destination address
+                         * will be always the one master has. Provides the right
+                         * functionality in a bridge.
+                         */
+                        skb_bond_set_mac_by_master(skb, master);
+                }
+
                 if (dev->priv_flags & IFF_SLAVE_INACTIVE) {
                         if ((dev->priv_flags & IFF_SLAVE_NEEDARP) &&
                             skb->protocol == __cpu_to_be16(ETH_P_ARP))
@@ -1908,6 +1977,28 @@ static inline int skb_bond_should_drop(struct sk_buff *skb)
 }
 
 extern struct pernet_operations __net_initdata loopback_net_ops;
+
+static inline int dev_ethtool_get_settings(struct net_device *dev,
+                                           struct ethtool_cmd *cmd)
+{
+        if (!dev->ethtool_ops || !dev->ethtool_ops->get_settings)
+                return -EOPNOTSUPP;
+        return dev->ethtool_ops->get_settings(dev, cmd);
+}
+
+static inline u32 dev_ethtool_get_rx_csum(struct net_device *dev)
+{
+        if (!dev->ethtool_ops || !dev->ethtool_ops->get_rx_csum)
+                return 0;
+        return dev->ethtool_ops->get_rx_csum(dev);
+}
+
+static inline u32 dev_ethtool_get_flags(struct net_device *dev)
+{
+        if (!dev->ethtool_ops || !dev->ethtool_ops->get_flags)
+                return 0;
+        return dev->ethtool_ops->get_flags(dev);
+}
 #endif /* __KERNEL__ */
 
-#endif  /* _LINUX_DEV_H */
+#endif  /* _LINUX_NETDEVICE_H */
diff --git a/include/linux/netfilter/Kbuild b/include/linux/netfilter/Kbuild
index af9d2fb97212..2aea50399c0b 100644
--- a/include/linux/netfilter/Kbuild
+++ b/include/linux/netfilter/Kbuild
@@ -33,6 +33,7 @@ header-y += xt_limit.h
 header-y += xt_mac.h
 header-y += xt_mark.h
 header-y += xt_multiport.h
+header-y += xt_osf.h
 header-y += xt_owner.h
 header-y += xt_pkttype.h
 header-y += xt_quota.h
diff --git a/include/linux/netfilter/nf_conntrack_common.h b/include/linux/netfilter/nf_conntrack_common.h
index 885cbe282260..a8248ee422b7 100644
--- a/include/linux/netfilter/nf_conntrack_common.h
+++ b/include/linux/netfilter/nf_conntrack_common.h
@@ -75,75 +75,6 @@ enum ip_conntrack_status {
         IPS_FIXED_TIMEOUT = (1 << IPS_FIXED_TIMEOUT_BIT),
 };
 
-/* Connection tracking event bits */
-enum ip_conntrack_events
-{
-        /* New conntrack */
-        IPCT_NEW_BIT = 0,
-        IPCT_NEW = (1 << IPCT_NEW_BIT),
-
-        /* Expected connection */
-        IPCT_RELATED_BIT = 1,
-        IPCT_RELATED = (1 << IPCT_RELATED_BIT),
-
-        /* Destroyed conntrack */
-        IPCT_DESTROY_BIT = 2,
-        IPCT_DESTROY = (1 << IPCT_DESTROY_BIT),
-
-        /* Timer has been refreshed */
-        IPCT_REFRESH_BIT = 3,
-        IPCT_REFRESH = (1 << IPCT_REFRESH_BIT),
-
-        /* Status has changed */
-        IPCT_STATUS_BIT = 4,
-        IPCT_STATUS = (1 << IPCT_STATUS_BIT),
-
-        /* Update of protocol info */
-        IPCT_PROTOINFO_BIT = 5,
-        IPCT_PROTOINFO = (1 << IPCT_PROTOINFO_BIT),
-
-        /* Volatile protocol info */
-        IPCT_PROTOINFO_VOLATILE_BIT = 6,
-        IPCT_PROTOINFO_VOLATILE = (1 << IPCT_PROTOINFO_VOLATILE_BIT),
-
-        /* New helper for conntrack */
-        IPCT_HELPER_BIT = 7,
-        IPCT_HELPER = (1 << IPCT_HELPER_BIT),
-
-        /* Update of helper info */
-        IPCT_HELPINFO_BIT = 8,
-        IPCT_HELPINFO = (1 << IPCT_HELPINFO_BIT),
-
-        /* Volatile helper info */
-        IPCT_HELPINFO_VOLATILE_BIT = 9,
-        IPCT_HELPINFO_VOLATILE = (1 << IPCT_HELPINFO_VOLATILE_BIT),
-
-        /* NAT info */
-        IPCT_NATINFO_BIT = 10,
-        IPCT_NATINFO = (1 << IPCT_NATINFO_BIT),
-
-        /* Counter highest bit has been set, unused */
-        IPCT_COUNTER_FILLING_BIT = 11,
-        IPCT_COUNTER_FILLING = (1 << IPCT_COUNTER_FILLING_BIT),
-
-        /* Mark is set */
-        IPCT_MARK_BIT = 12,
-        IPCT_MARK = (1 << IPCT_MARK_BIT),
-
-        /* NAT sequence adjustment */
-        IPCT_NATSEQADJ_BIT = 13,
-        IPCT_NATSEQADJ = (1 << IPCT_NATSEQADJ_BIT),
-
-        /* Secmark is set */
-        IPCT_SECMARK_BIT = 14,
-        IPCT_SECMARK = (1 << IPCT_SECMARK_BIT),
-};
-
-enum ip_conntrack_expect_events {
-        IPEXP_NEW_BIT = 0,
-        IPEXP_NEW = (1 << IPEXP_NEW_BIT),
-};
-
 #ifdef __KERNEL__
 struct ip_conntrack_stat
 {
diff --git a/include/linux/netfilter/nf_conntrack_tcp.h b/include/linux/netfilter/nf_conntrack_tcp.h
index b2f384d42611..4352feed2377 100644
--- a/include/linux/netfilter/nf_conntrack_tcp.h
+++ b/include/linux/netfilter/nf_conntrack_tcp.h
@@ -15,7 +15,8 @@ enum tcp_conntrack {
         TCP_CONNTRACK_LAST_ACK,
         TCP_CONNTRACK_TIME_WAIT,
         TCP_CONNTRACK_CLOSE,
-        TCP_CONNTRACK_LISTEN,
+        TCP_CONNTRACK_LISTEN,   /* obsolete */
+#define TCP_CONNTRACK_SYN_SENT2 TCP_CONNTRACK_LISTEN
         TCP_CONNTRACK_MAX,
         TCP_CONNTRACK_IGNORE
 };
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index c600083cbdf5..bff4d5741d98 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -46,7 +46,8 @@ struct nfgenmsg {
 #define NFNL_SUBSYS_CTNETLINK_EXP       2
 #define NFNL_SUBSYS_QUEUE               3
 #define NFNL_SUBSYS_ULOG                4
-#define NFNL_SUBSYS_COUNT               5
+#define NFNL_SUBSYS_OSF                 5
+#define NFNL_SUBSYS_COUNT               6
 
 #ifdef __KERNEL__
 
@@ -75,7 +76,7 @@ extern int nfnetlink_subsys_unregister(const struct nfnetlink_subsystem *n);
 
 extern int nfnetlink_has_listeners(unsigned int group);
 extern int nfnetlink_send(struct sk_buff *skb, u32 pid, unsigned group, 
-                          int echo);
+                          int echo, gfp_t flags);
 extern void nfnetlink_set_err(u32 pid, u32 group, int error);
 extern int nfnetlink_unicast(struct sk_buff *skb, u_int32_t pid, int flags);
 
diff --git a/include/linux/netfilter/nfnetlink_conntrack.h b/include/linux/netfilter/nfnetlink_conntrack.h
index 1a865e48b8eb..ed4ef8d0b11b 100644
--- a/include/linux/netfilter/nfnetlink_conntrack.h
+++ b/include/linux/netfilter/nfnetlink_conntrack.h
@@ -101,6 +101,7 @@ enum ctattr_protoinfo_dccp {
         CTA_PROTOINFO_DCCP_UNSPEC,
         CTA_PROTOINFO_DCCP_STATE,
         CTA_PROTOINFO_DCCP_ROLE,
+        CTA_PROTOINFO_DCCP_HANDSHAKE_SEQ,
         __CTA_PROTOINFO_DCCP_MAX,
 };
 #define CTA_PROTOINFO_DCCP_MAX (__CTA_PROTOINFO_DCCP_MAX - 1)
diff --git a/include/linux/netfilter/x_tables.h b/include/linux/netfilter/x_tables.h
index c9efe039dc57..1030b7593898 100644
--- a/include/linux/netfilter/x_tables.h
+++ b/include/linux/netfilter/x_tables.h
@@ -184,9 +184,10 @@ struct xt_counters_info
  * @matchinfo:  per-match data
  * @fragoff:    packet is a fragment, this is the data offset
  * @thoff:      position of transport header relative to skb->data
- * @hotdrop:    drop packet if we had inspection problems
+ * @hook:       hook number given packet came from
  * @family:     Actual NFPROTO_* through which the function is invoked
  *              (helpful when match->family == NFPROTO_UNSPEC)
+ * @hotdrop:    drop packet if we had inspection problems
  */
 struct xt_match_param {
         const struct net_device *in, *out;
@@ -194,8 +195,9 @@ struct xt_match_param {
         const void *matchinfo;
         int fragoff;
         unsigned int thoff;
-        bool *hotdrop;
+        unsigned int hooknum;
         u_int8_t family;
+        bool *hotdrop;
 };
 
 /**
diff --git a/include/linux/netfilter/xt_NFQUEUE.h b/include/linux/netfilter/xt_NFQUEUE.h
index 982a89f78272..2584f4a777de 100644
--- a/include/linux/netfilter/xt_NFQUEUE.h
+++ b/include/linux/netfilter/xt_NFQUEUE.h
@@ -15,4 +15,9 @@ struct xt_NFQ_info {
         __u16 queuenum;
 };
 
+struct xt_NFQ_info_v1 {
+        __u16 queuenum;
+        __u16 queues_total;
+};
+
 #endif /* _XT_NFQ_TARGET_H */
diff --git a/include/linux/netfilter/xt_conntrack.h b/include/linux/netfilter/xt_conntrack.h
index 3430c7751948..7ae05338e94c 100644
--- a/include/linux/netfilter/xt_conntrack.h
+++ b/include/linux/netfilter/xt_conntrack.h
@@ -81,4 +81,17 @@ struct xt_conntrack_mtinfo1 {
         __u8 state_mask, status_mask;
 };
 
+struct xt_conntrack_mtinfo2 {
+        union nf_inet_addr origsrc_addr, origsrc_mask;
+        union nf_inet_addr origdst_addr, origdst_mask;
+        union nf_inet_addr replsrc_addr, replsrc_mask;
+        union nf_inet_addr repldst_addr, repldst_mask;
+        __u32 expires_min, expires_max;
+        __u16 l4proto;
+        __be16 origsrc_port, origdst_port;
+        __be16 replsrc_port, repldst_port;
+        __u16 match_flags, invert_flags;
+        __u16 state_mask, status_mask;
+};
+
 #endif /*_XT_CONNTRACK_H*/
diff --git a/include/linux/netfilter/xt_osf.h b/include/linux/netfilter/xt_osf.h
new file mode 100644
index 000000000000..18afa495f973
--- /dev/null
+++ b/include/linux/netfilter/xt_osf.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2003+ Evgeniy Polyakov <johnpol@2ka.mxt.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.
+ *
+ * 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 _XT_OSF_H
+#define _XT_OSF_H
+
+#include <linux/types.h>
+
+#define MAXGENRELEN             32
+
+#define XT_OSF_GENRE            (1<<0)
+#define XT_OSF_TTL              (1<<1)
+#define XT_OSF_LOG              (1<<2)
+#define XT_OSF_INVERT           (1<<3)
+
+#define XT_OSF_LOGLEVEL_ALL     0       /* log all matched fingerprints */
+#define XT_OSF_LOGLEVEL_FIRST   1       /* log only the first matced fingerprint */
+#define XT_OSF_LOGLEVEL_ALL_KNOWN       2 /* do not log unknown packets */
+
+#define XT_OSF_TTL_TRUE         0       /* True ip and fingerprint TTL comparison */
+#define XT_OSF_TTL_LESS         1       /* Check if ip TTL is less than fingerprint one */
+#define XT_OSF_TTL_NOCHECK      2       /* Do not compare ip and fingerprint TTL at all */
+
+struct xt_osf_info {
+        char                    genre[MAXGENRELEN];
+        __u32                   len;
+        __u32                   flags;
+        __u32                   loglevel;
+        __u32                   ttl;
+};
+
+/*
+ * Wildcard MSS (kind of).
+ * It is used to implement a state machine for the different wildcard values
+ * of the MSS and window sizes.
+ */
+struct xt_osf_wc {
+        __u32                   wc;
+        __u32                   val;
+};
+
+/*
+ * This struct represents IANA options
+ * http://www.iana.org/assignments/tcp-parameters
+ */
+struct xt_osf_opt {
+        __u16                   kind, length;
+        struct xt_osf_wc        wc;
+};
+
+struct xt_osf_user_finger {
+        struct xt_osf_wc        wss;
+
+        __u8                    ttl, df;
+        __u16                   ss, mss;
+        __u16                   opt_num;
+
+        char                    genre[MAXGENRELEN];
+        char                    version[MAXGENRELEN];
+        char                    subtype[MAXGENRELEN];
+
+        /* MAX_IPOPTLEN is maximum if all options are NOPs or EOLs */
+        struct xt_osf_opt       opt[MAX_IPOPTLEN];
+};
+
+struct xt_osf_nlmsg {
+        struct xt_osf_user_finger       f;
+        struct iphdr            ip;
+        struct tcphdr           tcp;
+};
+
+/* Defines for IANA option kinds */
+
+enum iana_options {
+        OSFOPT_EOL = 0,         /* End of options */
+        OSFOPT_NOP,             /* NOP */
+        OSFOPT_MSS,             /* Maximum segment size */
+        OSFOPT_WSO,             /* Window scale option */
+        OSFOPT_SACKP,           /* SACK permitted */
+        OSFOPT_SACK,            /* SACK */
+        OSFOPT_ECHO,
+        OSFOPT_ECHOREPLY,
+        OSFOPT_TS,              /* Timestamp option */
+        OSFOPT_POCP,            /* Partial Order Connection Permitted */
+        OSFOPT_POSP,            /* Partial Order Service Profile */
+
+        /* Others are not used in the current OSF */
+        OSFOPT_EMPTY = 255,
+};
+
+/*
+ * Initial window size option state machine: multiple of mss, mtu or
+ * plain numeric value. Can also be made as plain numeric value which
+ * is not a multiple of specified value.
+ */
+enum xt_osf_window_size_options {
+        OSF_WSS_PLAIN   = 0,
+        OSF_WSS_MSS,
+        OSF_WSS_MTU,
+        OSF_WSS_MODULO,
+        OSF_WSS_MAX,
+};
+
+/*
+ * Add/remove fingerprint from the kernel.
+ */
+enum xt_osf_msg_types {
+        OSF_MSG_ADD,
+        OSF_MSG_REMOVE,
+        OSF_MSG_MAX,
+};
+
+enum xt_osf_attr_type {
+        OSF_ATTR_UNSPEC,
+        OSF_ATTR_FINGER,
+        OSF_ATTR_MAX,
+};
+
+#endif                          /* _XT_OSF_H */
diff --git a/include/linux/netfilter/xt_socket.h b/include/linux/netfilter/xt_socket.h
new file mode 100644
index 000000000000..6f475b8ff34b
--- /dev/null
+++ b/include/linux/netfilter/xt_socket.h
@@ -0,0 +1,12 @@
+#ifndef _XT_SOCKET_H
+#define _XT_SOCKET_H
+
+enum {
+        XT_SOCKET_TRANSPARENT = 1 << 0,
+};
+
+struct xt_socket_mtinfo1 {
+        __u8 flags;
+};
+
+#endif /* _XT_SOCKET_H */
diff --git a/include/linux/nfs.h b/include/linux/nfs.h
index 214d499718f7..f387919bbc59 100644
--- a/include/linux/nfs.h
+++ b/include/linux/nfs.h
@@ -25,8 +25,9 @@
 #define NFSMODE_SOCK    0140000
 #define NFSMODE_FIFO    0010000
 
-#define NFS_MNT_PROGRAM 100005
-#define NFS_MNT_PORT    627
+#define NFS_MNT_PROGRAM         100005
+#define NFS_MNT_VERSION         1
+#define NFS_MNT3_VERSION        3
 
 /*
  * NFS stats. The good thing with these values is that NFSv3 errors are
diff --git a/include/linux/nfs2.h b/include/linux/nfs2.h
index 0ed9517138fc..fde24b30cc9e 100644
--- a/include/linux/nfs2.h
+++ b/include/linux/nfs2.h
@@ -64,11 +64,4 @@ struct nfs2_fh {
 #define NFSPROC_READDIR         16
 #define NFSPROC_STATFS          17
 
-#define NFS_MNT_PROGRAM         100005
-#define NFS_MNT_VERSION         1
-#define MNTPROC_NULL            0
-#define MNTPROC_MNT             1
-#define MNTPROC_UMNT            3
-#define MNTPROC_UMNTALL         4
-
 #endif /* _LINUX_NFS2_H */
diff --git a/include/linux/nfs3.h b/include/linux/nfs3.h
index 539f3b550eab..ac33806ec7f9 100644
--- a/include/linux/nfs3.h
+++ b/include/linux/nfs3.h
@@ -88,12 +88,7 @@ struct nfs3_fh {
 #define NFS3PROC_PATHCONF       20
 #define NFS3PROC_COMMIT         21
 
-#define NFS_MNT3_PROGRAM        100005
 #define NFS_MNT3_VERSION        3
-#define MOUNTPROC3_NULL         0
-#define MOUNTPROC3_MNT          1
-#define MOUNTPROC3_UMNT         3
-#define MOUNTPROC3_UMNTALL      4
  
 
 #if defined(__KERNEL__)
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index e3f0cbcbd0db..bd2eba530667 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -21,6 +21,7 @@
 #define NFS4_FHSIZE             128
 #define NFS4_MAXPATHLEN         PATH_MAX
 #define NFS4_MAXNAMLEN          NAME_MAX
+#define NFS4_OPAQUE_LIMIT       1024
 #define NFS4_MAX_SESSIONID_LEN  16
 
 #define NFS4_ACCESS_READ        0x0001
@@ -130,6 +131,16 @@
 
 #define NFS4_MAX_UINT64 (~(u64)0)
 
+/* An NFS4 sessions server must support at least NFS4_MAX_OPS operations.
+ * If a compound requires more operations, adjust NFS4_MAX_OPS accordingly.
+ */
+#define NFS4_MAX_OPS   8
+
+/* Our NFS4 client back channel server only wants the cb_sequene and the
+ * actual operation per compound
+ */
+#define NFS4_MAX_BACK_CHANNEL_OPS 2
+
 enum nfs4_acl_whotype {
         NFS4_ACL_WHO_NAMED = 0,
         NFS4_ACL_WHO_OWNER,
@@ -462,6 +473,13 @@ enum lock_type4 {
 #define NFSPROC4_NULL 0
 #define NFSPROC4_COMPOUND 1
 #define NFS4_MINOR_VERSION 0
+
+#if defined(CONFIG_NFS_V4_1)
+#define NFS4_MAX_MINOR_VERSION 1
+#else
+#define NFS4_MAX_MINOR_VERSION 0
+#endif /* CONFIG_NFS_V4_1 */
+
 #define NFS4_DEBUG 1
 
 /* Index of predefined Linux client operations */
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 6ad75948cbf7..19fe15d12042 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -4,11 +4,17 @@
 #include <linux/list.h>
 #include <linux/backing-dev.h>
 #include <linux/wait.h>
+#include <linux/nfs_xdr.h>
+#include <linux/sunrpc/xprt.h>
 
 #include <asm/atomic.h>
 
+struct nfs4_session;
 struct nfs_iostats;
 struct nlm_host;
+struct nfs4_sequence_args;
+struct nfs4_sequence_res;
+struct nfs_server;
 
 /*
  * The nfs_client identifies our client state to the server.
@@ -18,6 +24,7 @@ struct nfs_client {
         int                     cl_cons_state;  /* current construction state (-ve: init error) */
 #define NFS_CS_READY            0               /* ready to be used */
 #define NFS_CS_INITING          1               /* busy initialising */
+#define NFS_CS_SESSION_INITING  2               /* busy initialising  session */
         unsigned long           cl_res_state;   /* NFS resources state */
 #define NFS_CS_CALLBACK         1               /* - callback started */
 #define NFS_CS_IDMAP            2               /* - idmap started */
@@ -32,6 +39,7 @@ struct nfs_client {
         const struct nfs_rpc_ops *rpc_ops;      /* NFS protocol vector */
         int                     cl_proto;       /* Network transport protocol */
 
+        u32                     cl_minorversion;/* NFSv4 minorversion */
         struct rpc_cred         *cl_machine_cred;
 
 #ifdef CONFIG_NFS_V4
@@ -63,7 +71,22 @@ struct nfs_client {
          */
         char                    cl_ipaddr[48];
         unsigned char           cl_id_uniquifier;
-#endif
+        int                  (* cl_call_sync)(struct nfs_server *server,
+                                              struct rpc_message *msg,
+                                              struct nfs4_sequence_args *args,
+                                              struct nfs4_sequence_res *res,
+                                              int cache_reply);
+#endif /* CONFIG_NFS_V4 */
+
+#ifdef CONFIG_NFS_V4_1
+        /* clientid returned from EXCHANGE_ID, used by session operations */
+        u64                     cl_ex_clid;
+        /* The sequence id to use for the next CREATE_SESSION */
+        u32                     cl_seqid;
+        /* The flags used for obtaining the clientid during EXCHANGE_ID */
+        u32                     cl_exchange_flags;
+        struct nfs4_session     *cl_session;    /* sharred session */
+#endif /* CONFIG_NFS_V4_1 */
 
 #ifdef CONFIG_NFS_FSCACHE
         struct fscache_cookie   *fscache;       /* client index cache cookie */
@@ -145,4 +168,46 @@ struct nfs_server {
 #define NFS_CAP_ACLS            (1U << 3)
 #define NFS_CAP_ATOMIC_OPEN     (1U << 4)
 
+
+/* maximum number of slots to use */
+#define NFS4_MAX_SLOT_TABLE RPC_MAX_SLOT_TABLE
+
+#if defined(CONFIG_NFS_V4_1)
+
+/* Sessions */
+#define SLOT_TABLE_SZ (NFS4_MAX_SLOT_TABLE/(8*sizeof(long)))
+struct nfs4_slot_table {
+        struct nfs4_slot *slots;                /* seqid per slot */
+        unsigned long   used_slots[SLOT_TABLE_SZ]; /* used/unused bitmap */
+        spinlock_t      slot_tbl_lock;
+        struct rpc_wait_queue   slot_tbl_waitq; /* allocators may wait here */
+        int             max_slots;              /* # slots in table */
+        int             highest_used_slotid;    /* sent to server on each SEQ.
+                                                 * op for dynamic resizing */
+};
+
+static inline int slot_idx(struct nfs4_slot_table *tbl, struct nfs4_slot *sp)
+{
+        return sp - tbl->slots;
+}
+
+/*
+ * Session related parameters
+ */
+struct nfs4_session {
+        struct nfs4_sessionid           sess_id;
+        u32                             flags;
+        unsigned long                   session_state;
+        u32                             hash_alg;
+        u32                             ssv_len;
+
+        /* The fore and back channel */
+        struct nfs4_channel_attrs       fc_attrs;
+        struct nfs4_slot_table          fc_slot_table;
+        struct nfs4_channel_attrs       bc_attrs;
+        struct nfs4_slot_table          bc_slot_table;
+        struct nfs_client               *clp;
+};
+
+#endif /* CONFIG_NFS_V4_1 */
 #endif
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index b89c34e40bc2..62f63fb0c4c8 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -145,6 +145,44 @@ struct nfs4_change_info {
 };
 
 struct nfs_seqid;
+
+/* nfs41 sessions channel attributes */
+struct nfs4_channel_attrs {
+        u32                     headerpadsz;
+        u32                     max_rqst_sz;
+        u32                     max_resp_sz;
+        u32                     max_resp_sz_cached;
+        u32                     max_ops;
+        u32                     max_reqs;
+};
+
+/* nfs41 sessions slot seqid */
+struct nfs4_slot {
+        u32                     seq_nr;
+};
+
+struct nfs4_sequence_args {
+        struct nfs4_session     *sa_session;
+        u8                      sa_slotid;
+        u8                      sa_cache_this;
+};
+
+struct nfs4_sequence_res {
+        struct nfs4_session     *sr_session;
+        u8                      sr_slotid;      /* slot used to send request */
+        unsigned long           sr_renewal_time;
+        int                     sr_status;      /* sequence operation status */
+};
+
+struct nfs4_get_lease_time_args {
+        struct nfs4_sequence_args       la_seq_args;
+};
+
+struct nfs4_get_lease_time_res {
+        struct nfs_fsinfo              *lr_fsinfo;
+        struct nfs4_sequence_res        lr_seq_res;
+};
+
 /*
  * Arguments to the open call.
  */
@@ -165,6 +203,7 @@ struct nfs_openargs {
         const struct nfs_server *server;         /* Needed for ID mapping */
         const u32 *             bitmask;
         __u32                   claim;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_openres {
@@ -181,6 +220,7 @@ struct nfs_openres {
         __u32                   do_recall;
         __u64                   maxsize;
         __u32                   attrset[NFS4_BITMAP_SIZE];
+        struct nfs4_sequence_res        seq_res;
 };
 
 /*
@@ -206,6 +246,7 @@ struct nfs_closeargs {
         struct nfs_seqid *      seqid;
         fmode_t                 fmode;
         const u32 *             bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_closeres {
@@ -213,6 +254,7 @@ struct nfs_closeres {
         struct nfs_fattr *      fattr;
         struct nfs_seqid *      seqid;
         const struct nfs_server *server;
+        struct nfs4_sequence_res        seq_res;
 };
 /*
  *  * Arguments to the lock,lockt, and locku call.
@@ -233,12 +275,14 @@ struct nfs_lock_args {
         unsigned char           block : 1;
         unsigned char           reclaim : 1;
         unsigned char           new_lock_owner : 1;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_lock_res {
         nfs4_stateid            stateid;
         struct nfs_seqid *      lock_seqid;
         struct nfs_seqid *      open_seqid;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs_locku_args {
@@ -246,32 +290,38 @@ struct nfs_locku_args {
         struct file_lock *      fl;
         struct nfs_seqid *      seqid;
         nfs4_stateid *          stateid;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_locku_res {
         nfs4_stateid            stateid;
         struct nfs_seqid *      seqid;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs_lockt_args {
         struct nfs_fh *         fh;
         struct file_lock *      fl;
         struct nfs_lowner       lock_owner;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_lockt_res {
         struct file_lock *      denied; /* LOCK, LOCKT failed */
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_delegreturnargs {
         const struct nfs_fh *fhandle;
         const nfs4_stateid *stateid;
         const u32 * bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_delegreturnres {
         struct nfs_fattr * fattr;
         const struct nfs_server *server;
+        struct nfs4_sequence_res        seq_res;
 };
 
 /*
@@ -284,12 +334,14 @@ struct nfs_readargs {
         __u32                   count;
         unsigned int            pgbase;
         struct page **          pages;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_readres {
         struct nfs_fattr *      fattr;
         __u32                   count;
         int                     eof;
+        struct nfs4_sequence_res        seq_res;
 };
 
 /*
@@ -304,6 +356,7 @@ struct nfs_writeargs {
         unsigned int            pgbase;
         struct page **          pages;
         const u32 *             bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_writeverf {
@@ -316,6 +369,7 @@ struct nfs_writeres {
         struct nfs_writeverf *  verf;
         __u32                   count;
         const struct nfs_server *server;
+        struct nfs4_sequence_res        seq_res;
 };
 
 /*
@@ -325,12 +379,14 @@ struct nfs_removeargs {
         const struct nfs_fh     *fh;
         struct qstr             name;
         const u32 *             bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_removeres {
         const struct nfs_server *server;
         struct nfs4_change_info cinfo;
         struct nfs_fattr        dir_attr;
+        struct nfs4_sequence_res        seq_res;
 };
 
 /*
@@ -383,6 +439,7 @@ struct nfs_setattrargs {
         struct iattr *                  iap;
         const struct nfs_server *       server; /* Needed for name mapping */
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs_setaclargs {
@@ -390,6 +447,11 @@ struct nfs_setaclargs {
         size_t                          acl_len;
         unsigned int                    acl_pgbase;
         struct page **                  acl_pages;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs_setaclres {
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs_getaclargs {
@@ -397,11 +459,18 @@ struct nfs_getaclargs {
         size_t                          acl_len;
         unsigned int                    acl_pgbase;
         struct page **                  acl_pages;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs_getaclres {
+        size_t                          acl_len;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs_setattrres {
         struct nfs_fattr *              fattr;
         const struct nfs_server *       server;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs_linkargs {
@@ -583,6 +652,7 @@ struct nfs4_accessargs {
         const struct nfs_fh *           fh;
         const u32 *                     bitmask;
         u32                             access;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_accessres {
@@ -590,6 +660,7 @@ struct nfs4_accessres {
         struct nfs_fattr *              fattr;
         u32                             supported;
         u32                             access;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_create_arg {
@@ -609,6 +680,7 @@ struct nfs4_create_arg {
         const struct iattr *            attrs;
         const struct nfs_fh *           dir_fh;
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_create_res {
@@ -617,21 +689,30 @@ struct nfs4_create_res {
         struct nfs_fattr *              fattr;
         struct nfs4_change_info         dir_cinfo;
         struct nfs_fattr *              dir_fattr;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_fsinfo_arg {
         const struct nfs_fh *           fh;
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs4_fsinfo_res {
+        struct nfs_fsinfo              *fsinfo;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_getattr_arg {
         const struct nfs_fh *           fh;
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_getattr_res {
         const struct nfs_server *       server;
         struct nfs_fattr *              fattr;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_link_arg {
@@ -639,6 +720,7 @@ struct nfs4_link_arg {
         const struct nfs_fh *           dir_fh;
         const struct qstr *             name;
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_link_res {
@@ -646,6 +728,7 @@ struct nfs4_link_res {
         struct nfs_fattr *              fattr;
         struct nfs4_change_info         cinfo;
         struct nfs_fattr *              dir_attr;
+        struct nfs4_sequence_res        seq_res;
 };
 
 
@@ -653,21 +736,30 @@ struct nfs4_lookup_arg {
         const struct nfs_fh *           dir_fh;
         const struct qstr *             name;
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_lookup_res {
         const struct nfs_server *       server;
         struct nfs_fattr *              fattr;
         struct nfs_fh *                 fh;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_lookup_root_arg {
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_pathconf_arg {
         const struct nfs_fh *           fh;
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs4_pathconf_res {
+        struct nfs_pathconf            *pathconf;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_readdir_arg {
@@ -678,11 +770,13 @@ struct nfs4_readdir_arg {
         struct page **                  pages;  /* zero-copy data */
         unsigned int                    pgbase; /* zero-copy data */
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_readdir_res {
         nfs4_verifier                   verifier;
         unsigned int                    pgbase;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_readlink {
@@ -690,6 +784,11 @@ struct nfs4_readlink {
         unsigned int                    pgbase;
         unsigned int                    pglen;   /* zero-copy data */
         struct page **                  pages;   /* zero-copy data */
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs4_readlink_res {
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_rename_arg {
@@ -698,6 +797,7 @@ struct nfs4_rename_arg {
         const struct qstr *             old_name;
         const struct qstr *             new_name;
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_rename_res {
@@ -706,6 +806,7 @@ struct nfs4_rename_res {
         struct nfs_fattr *              old_fattr;
         struct nfs4_change_info         new_cinfo;
         struct nfs_fattr *              new_fattr;
+        struct nfs4_sequence_res        seq_res;
 };
 
 #define NFS4_SETCLIENTID_NAMELEN        (127)
@@ -724,6 +825,17 @@ struct nfs4_setclientid {
 struct nfs4_statfs_arg {
         const struct nfs_fh *           fh;
         const u32 *                     bitmask;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs4_statfs_res {
+        struct nfs_fsstat              *fsstat;
+        struct nfs4_sequence_res        seq_res;
+};
+
+struct nfs4_server_caps_arg {
+        struct nfs_fh                  *fhandle;
+        struct nfs4_sequence_args       seq_args;
 };
 
 struct nfs4_server_caps_res {
@@ -731,6 +843,7 @@ struct nfs4_server_caps_res {
         u32                             acl_bitmask;
         u32                             has_links;
         u32                             has_symlinks;
+        struct nfs4_sequence_res        seq_res;
 };
 
 struct nfs4_string {
@@ -765,10 +878,68 @@ struct nfs4_fs_locations_arg {
         const struct qstr *name;
         struct page *page;
         const u32 *bitmask;
+        struct nfs4_sequence_args       seq_args;
+};
+
+struct nfs4_fs_locations_res {
+        struct nfs4_fs_locations       *fs_locations;
+        struct nfs4_sequence_res        seq_res;
 };
 
 #endif /* CONFIG_NFS_V4 */
 
+struct nfstime4 {
+        u64     seconds;
+        u32     nseconds;
+};
+
+#ifdef CONFIG_NFS_V4_1
+struct nfs_impl_id4 {
+        u32             domain_len;
+        char            *domain;
+        u32             name_len;
+        char            *name;
+        struct nfstime4 date;
+};
+
+#define NFS4_EXCHANGE_ID_LEN    (48)
+struct nfs41_exchange_id_args {
+        struct nfs_client               *client;
+        nfs4_verifier                   *verifier;
+        unsigned int                    id_len;
+        char                            id[NFS4_EXCHANGE_ID_LEN];
+        u32                             flags;
+};
+
+struct server_owner {
+        uint64_t                        minor_id;
+        uint32_t                        major_id_sz;
+        char                            major_id[NFS4_OPAQUE_LIMIT];
+};
+
+struct server_scope {
+        uint32_t                        server_scope_sz;
+        char                            server_scope[NFS4_OPAQUE_LIMIT];
+};
+
+struct nfs41_exchange_id_res {
+        struct nfs_client               *client;
+        u32                             flags;
+};
+
+struct nfs41_create_session_args {
+        struct nfs_client              *client;
+        uint32_t                        flags;
+        uint32_t                        cb_program;
+        struct nfs4_channel_attrs       fc_attrs;       /* Fore Channel */
+        struct nfs4_channel_attrs       bc_attrs;       /* Back Channel */
+};
+
+struct nfs41_create_session_res {
+        struct nfs_client              *client;
+};
+#endif /* CONFIG_NFS_V4_1 */
+
 struct nfs_page;
 
 #define NFS_PAGEVEC_SIZE        (8U)
diff --git a/include/linux/nfsd/cache.h b/include/linux/nfsd/cache.h
index 5bccaab81056..3a3f58934f5e 100644
--- a/include/linux/nfsd/cache.h
+++ b/include/linux/nfsd/cache.h
@@ -14,8 +14,7 @@
 #include <linux/uio.h>
 
 /*
- * Representation of a reply cache entry. The first two members *must*
- * be hash_next and hash_prev.
+ * Representation of a reply cache entry.
  */
 struct svc_cacherep {
         struct hlist_node       c_hash;
diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h
index bcd0201589f8..a6d9ef2bb34a 100644
--- a/include/linux/nfsd/export.h
+++ b/include/linux/nfsd/export.h
@@ -125,11 +125,9 @@ void			nfsd_export_flush(void);
 void                    exp_readlock(void);
 void                    exp_readunlock(void);
 struct svc_export *     rqst_exp_get_by_name(struct svc_rqst *,
-                                             struct vfsmount *,
-                                             struct dentry *);
+                                             struct path *);
 struct svc_export *     rqst_exp_parent(struct svc_rqst *,
-                                        struct vfsmount *mnt,
-                                        struct dentry *dentry);
+                                        struct path *);
 int                     exp_rootfh(struct auth_domain *, 
                                         char *path, struct knfsd_fh *, int maxsize);
 __be32                  exp_pseudoroot(struct svc_rqst *, struct svc_fh *);
diff --git a/include/linux/nfsd/nfsfh.h b/include/linux/nfsd/nfsfh.h
index afa19016c4a8..8f641c908450 100644
--- a/include/linux/nfsd/nfsfh.h
+++ b/include/linux/nfsd/nfsfh.h
@@ -151,9 +151,15 @@ typedef struct svc_fh {
         __u64                   fh_pre_size;    /* size before operation */
         struct timespec         fh_pre_mtime;   /* mtime before oper */
         struct timespec         fh_pre_ctime;   /* ctime before oper */
+        /*
+         * pre-op nfsv4 change attr: note must check IS_I_VERSION(inode)
+         *  to find out if it is valid.
+         */
+        u64                     fh_pre_change;
 
         /* Post-op attributes saved in fh_unlock */
         struct kstat            fh_post_attr;   /* full attrs after operation */
+        u64                     fh_post_change; /* nfsv4 change; see above */
 #endif /* CONFIG_NFSD_V3 */
 
 } svc_fh;
@@ -298,6 +304,7 @@ fill_pre_wcc(struct svc_fh *fhp)
                 fhp->fh_pre_mtime = inode->i_mtime;
                 fhp->fh_pre_ctime = inode->i_ctime;
                 fhp->fh_pre_size  = inode->i_size;
+                fhp->fh_pre_change = inode->i_version;
                 fhp->fh_pre_saved = 1;
         }
 }
diff --git a/include/linux/nfsd/state.h b/include/linux/nfsd/state.h
index 4d61c873feed..57ab2ed08459 100644
--- a/include/linux/nfsd/state.h
+++ b/include/linux/nfsd/state.h
@@ -41,7 +41,6 @@
 #include <linux/kref.h>
 #include <linux/sunrpc/clnt.h>
 
-#define NFS4_OPAQUE_LIMIT 1024
 typedef struct {
         u32             cl_boot;
         u32             cl_id;
@@ -61,15 +60,6 @@ typedef struct {
 #define si_stateownerid   si_opaque.so_stateownerid
 #define si_fileid         si_opaque.so_fileid
 
-
-struct nfs4_cb_recall {
-        u32                     cbr_ident;
-        int                     cbr_trunc;
-        stateid_t               cbr_stateid;
-        struct knfsd_fh         cbr_fh;
-        struct nfs4_delegation  *cbr_dp;
-};
-
 struct nfs4_delegation {
         struct list_head        dl_perfile;
         struct list_head        dl_perclnt;
@@ -81,22 +71,25 @@ struct nfs4_delegation {
         struct file             *dl_vfs_file;
         u32                     dl_type;
         time_t                  dl_time;
-        struct nfs4_cb_recall   dl_recall;
+/* For recall: */
+        u32                     dl_ident;
+        stateid_t               dl_stateid;
+        struct knfsd_fh         dl_fh;
+        int                     dl_retries;
 };
 
-#define dl_stateid      dl_recall.cbr_stateid
-#define dl_fh           dl_recall.cbr_fh
-
 /* client delegation callback info */
-struct nfs4_callback {
+struct nfs4_cb_conn {
         /* SETCLIENTID info */
         u32                     cb_addr;
         unsigned short          cb_port;
         u32                     cb_prog;
-        u32                     cb_ident;
+        u32                     cb_minorversion;
+        u32                     cb_ident;       /* minorversion 0 only */
         /* RPC client info */
         atomic_t                cb_set;     /* successful CB_NULL call */
         struct rpc_clnt *       cb_client;
+        struct rpc_cred *       cb_cred;
 };
 
 /* Maximum number of slots per session. 128 is useful for long haul TCP */
@@ -122,6 +115,17 @@ struct nfsd4_slot {
         struct nfsd4_cache_entry        sl_cache_entry;
 };
 
+struct nfsd4_channel_attrs {
+        u32             headerpadsz;
+        u32             maxreq_sz;
+        u32             maxresp_sz;
+        u32             maxresp_cached;
+        u32             maxops;
+        u32             maxreqs;
+        u32             nr_rdma_attrs;
+        u32             rdma_attrs;
+};
+
 struct nfsd4_session {
         struct kref             se_ref;
         struct list_head        se_hash;        /* hash by sessionid */
@@ -129,11 +133,8 @@ struct nfsd4_session {
         u32                     se_flags;
         struct nfs4_client      *se_client;     /* for expire_client */
         struct nfs4_sessionid   se_sessionid;
-        u32                     se_fmaxreq_sz;
-        u32                     se_fmaxresp_sz;
-        u32                     se_fmaxresp_cached;
-        u32                     se_fmaxops;
-        u32                     se_fnumslots;
+        struct nfsd4_channel_attrs se_fchannel;
+        struct nfsd4_channel_attrs se_bchannel;
         struct nfsd4_slot       se_slots[];     /* forward channel slots */
 };
 
@@ -185,7 +186,7 @@ struct nfs4_client {
         struct svc_cred         cl_cred;        /* setclientid principal */
         clientid_t              cl_clientid;    /* generated by server */
         nfs4_verifier           cl_confirm;     /* generated by server */
-        struct nfs4_callback    cl_callback;    /* callback info */
+        struct nfs4_cb_conn     cl_cb_conn;     /* callback info */
         atomic_t                cl_count;       /* ref count */
         u32                     cl_firststate;  /* recovery dir creation */
 
diff --git a/include/linux/nfsd/xdr4.h b/include/linux/nfsd/xdr4.h
index f80d6013fdc3..2bacf7535069 100644
--- a/include/linux/nfsd/xdr4.h
+++ b/include/linux/nfsd/xdr4.h
@@ -64,10 +64,13 @@ static inline bool nfsd4_has_session(struct nfsd4_compound_state *cs)
 
 struct nfsd4_change_info {
         u32             atomic;
+        bool            change_supported;
         u32             before_ctime_sec;
         u32             before_ctime_nsec;
+        u64             before_change;
         u32             after_ctime_sec;
         u32             after_ctime_nsec;
+        u64             after_change;
 };
 
 struct nfsd4_access {
@@ -363,17 +366,6 @@ struct nfsd4_exchange_id {
         int             spa_how;
 };
 
-struct nfsd4_channel_attrs {
-        u32             headerpadsz;
-        u32             maxreq_sz;
-        u32             maxresp_sz;
-        u32             maxresp_cached;
-        u32             maxops;
-        u32             maxreqs;
-        u32             nr_rdma_attrs;
-        u32             rdma_attrs;
-};
-
 struct nfsd4_create_session {
         clientid_t              clientid;
         struct nfs4_sessionid   sessionid;
@@ -503,10 +495,16 @@ set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)
 {
         BUG_ON(!fhp->fh_pre_saved || !fhp->fh_post_saved);
         cinfo->atomic = 1;
-        cinfo->before_ctime_sec = fhp->fh_pre_ctime.tv_sec;
-        cinfo->before_ctime_nsec = fhp->fh_pre_ctime.tv_nsec;
-        cinfo->after_ctime_sec = fhp->fh_post_attr.ctime.tv_sec;
-        cinfo->after_ctime_nsec = fhp->fh_post_attr.ctime.tv_nsec;
+        cinfo->change_supported = IS_I_VERSION(fhp->fh_dentry->d_inode);
+        if (cinfo->change_supported) {
+                cinfo->before_change = fhp->fh_pre_change;
+                cinfo->after_change = fhp->fh_post_change;
+        } else {
+                cinfo->before_ctime_sec = fhp->fh_pre_ctime.tv_sec;
+                cinfo->before_ctime_nsec = fhp->fh_pre_ctime.tv_nsec;
+                cinfo->after_ctime_sec = fhp->fh_post_attr.ctime.tv_sec;
+                cinfo->after_ctime_nsec = fhp->fh_post_attr.ctime.tv_nsec;
+        }
 }
 
 int nfs4svc_encode_voidres(struct svc_rqst *, __be32 *, void *);
diff --git a/include/linux/nl80211.h b/include/linux/nl80211.h
index cbe8ce3bf486..dbea93b694e5 100644
--- a/include/linux/nl80211.h
+++ b/include/linux/nl80211.h
@@ -7,7 +7,7 @@
  * Copyright 2008 Michael Wu <flamingice@sourmilk.net>
  * Copyright 2008 Luis Carlos Cobo <luisca@cozybit.com>
  * Copyright 2008 Michael Buesch <mb@bu3sch.de>
- * Copyright 2008 Luis R. Rodriguez <lrodriguez@atheros.com>
+ * Copyright 2008, 2009 Luis R. Rodriguez <lrodriguez@atheros.com>
  * Copyright 2008 Jouni Malinen <jouni.malinen@atheros.com>
  * Copyright 2008 Colin McCabe <colin@cozybit.com>
  *
@@ -25,6 +25,8 @@
  *
  */
 
+#include <linux/types.h>
+
 /**
  * DOC: Station handling
  *
@@ -46,8 +48,10 @@
  *      to get a list of all present wiphys.
  * @NL80211_CMD_SET_WIPHY: set wiphy parameters, needs %NL80211_ATTR_WIPHY or
  *      %NL80211_ATTR_IFINDEX; can be used to set %NL80211_ATTR_WIPHY_NAME,
- *      %NL80211_ATTR_WIPHY_TXQ_PARAMS, %NL80211_ATTR_WIPHY_FREQ, and/or
- *      %NL80211_ATTR_WIPHY_CHANNEL_TYPE.
+ *      %NL80211_ATTR_WIPHY_TXQ_PARAMS, %NL80211_ATTR_WIPHY_FREQ,
+ *      %NL80211_ATTR_WIPHY_CHANNEL_TYPE, %NL80211_ATTR_WIPHY_RETRY_SHORT,
+ *      %NL80211_ATTR_WIPHY_RETRY_LONG, %NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
+ *      and/or %NL80211_ATTR_WIPHY_RTS_THRESHOLD.
  * @NL80211_CMD_NEW_WIPHY: Newly created wiphy, response to get request
  *      or rename notification. Has attributes %NL80211_ATTR_WIPHY and
  *      %NL80211_ATTR_WIPHY_NAME.
@@ -75,8 +79,8 @@
  * @NL80211_CMD_SET_KEY: Set key attributes %NL80211_ATTR_KEY_DEFAULT,
  *      %NL80211_ATTR_KEY_DEFAULT_MGMT, or %NL80211_ATTR_KEY_THRESHOLD.
  * @NL80211_CMD_NEW_KEY: add a key with given %NL80211_ATTR_KEY_DATA,
- *      %NL80211_ATTR_KEY_IDX, %NL80211_ATTR_MAC and %NL80211_ATTR_KEY_CIPHER
- *      attributes.
+ *      %NL80211_ATTR_KEY_IDX, %NL80211_ATTR_MAC, %NL80211_ATTR_KEY_CIPHER,
+ *      and %NL80211_ATTR_KEY_SEQ attributes.
  * @NL80211_CMD_DEL_KEY: delete a key identified by %NL80211_ATTR_KEY_IDX
  *      or %NL80211_ATTR_MAC.
  *
@@ -166,6 +170,22 @@
  *      set (%NL80211_ATTR_REG_TYPE), if the type of regulatory domain is
  *      %NL80211_REG_TYPE_COUNTRY the alpha2 to which we have moved on
  *      to (%NL80211_ATTR_REG_ALPHA2).
+ * @NL80211_CMD_REG_BEACON_HINT: indicates to userspace that an AP beacon
+ *      has been found while world roaming thus enabling active scan or
+ *      any mode of operation that initiates TX (beacons) on a channel
+ *      where we would not have been able to do either before. As an example
+ *      if you are world roaming (regulatory domain set to world or if your
+ *      driver is using a custom world roaming regulatory domain) and while
+ *      doing a passive scan on the 5 GHz band you find an AP there (if not
+ *      on a DFS channel) you will now be able to actively scan for that AP
+ *      or use AP mode on your card on that same channel. Note that this will
+ *      never be used for channels 1-11 on the 2 GHz band as they are always
+ *      enabled world wide. This beacon hint is only sent if your device had
+ *      either disabled active scanning or beaconing on a channel. We send to
+ *      userspace the wiphy on which we removed a restriction from
+ *      (%NL80211_ATTR_WIPHY) and the channel on which this occurred
+ *      before (%NL80211_ATTR_FREQ_BEFORE) and after (%NL80211_ATTR_FREQ_AFTER)
+ *      the beacon hint was processed.
  *
  * @NL80211_CMD_AUTHENTICATE: authentication request and notification.
  *      This command is used both as a command (request to authenticate) and
@@ -185,8 +205,12 @@
  *      frame, i.e., it was for the local STA and was received in correct
  *      state. This is similar to MLME-AUTHENTICATE.confirm primitive in the
  *      MLME SAP interface (kernel providing MLME, userspace SME). The
- *      included NL80211_ATTR_FRAME attribute contains the management frame
- *      (including both the header and frame body, but not FCS).
+ *      included %NL80211_ATTR_FRAME attribute contains the management frame
+ *      (including both the header and frame body, but not FCS). This event is
+ *      also used to indicate if the authentication attempt timed out. In that
+ *      case the %NL80211_ATTR_FRAME attribute is replaced with a
+ *      %NL80211_ATTR_TIMED_OUT flag (and %NL80211_ATTR_MAC to indicate which
+ *      pending authentication timed out).
  * @NL80211_CMD_ASSOCIATE: association request and notification; like
  *      NL80211_CMD_AUTHENTICATE but for Association and Reassociation
  *      (similar to MLME-ASSOCIATE.request, MLME-REASSOCIATE.request,
@@ -199,6 +223,25 @@
  *      NL80211_CMD_AUTHENTICATE but for Disassociation frames (similar to
  *      MLME-DISASSOCIATE.request and MLME-DISASSOCIATE.indication primitives).
  *
+ * @NL80211_CMD_MICHAEL_MIC_FAILURE: notification of a locally detected Michael
+ *      MIC (part of TKIP) failure; sent on the "mlme" multicast group; the
+ *      event includes %NL80211_ATTR_MAC to describe the source MAC address of
+ *      the frame with invalid MIC, %NL80211_ATTR_KEY_TYPE to show the key
+ *      type, %NL80211_ATTR_KEY_IDX to indicate the key identifier, and
+ *      %NL80211_ATTR_KEY_SEQ to indicate the TSC value of the frame; this
+ *      event matches with MLME-MICHAELMICFAILURE.indication() primitive
+ *
+ * @NL80211_CMD_JOIN_IBSS: Join a new IBSS -- given at least an SSID and a
+ *      FREQ attribute (for the initial frequency if no peer can be found)
+ *      and optionally a MAC (as BSSID) and FREQ_FIXED attribute if those
+ *      should be fixed rather than automatically determined. Can only be
+ *      executed on a network interface that is UP, and fixed BSSID/FREQ
+ *      may be rejected. Another optional parameter is the beacon interval,
+ *      given in the %NL80211_ATTR_BEACON_INTERVAL attribute, which if not
+ *      given defaults to 100 TU (102.4ms).
+ * @NL80211_CMD_LEAVE_IBSS: Leave the IBSS -- no special arguments, the IBSS is
+ *      determined by the network interface.
+ *
  * @NL80211_CMD_MAX: highest used command number
  * @__NL80211_CMD_AFTER_LAST: internal use
  */
@@ -260,6 +303,13 @@ enum nl80211_commands {
         NL80211_CMD_DEAUTHENTICATE,
         NL80211_CMD_DISASSOCIATE,
 
+        NL80211_CMD_MICHAEL_MIC_FAILURE,
+
+        NL80211_CMD_REG_BEACON_HINT,
+
+        NL80211_CMD_JOIN_IBSS,
+        NL80211_CMD_LEAVE_IBSS,
+
         /* add new commands above here */
 
         /* used to define NL80211_CMD_MAX below */
@@ -278,6 +328,7 @@ enum nl80211_commands {
 #define NL80211_CMD_ASSOCIATE NL80211_CMD_ASSOCIATE
 #define NL80211_CMD_DEAUTHENTICATE NL80211_CMD_DEAUTHENTICATE
 #define NL80211_CMD_DISASSOCIATE NL80211_CMD_DISASSOCIATE
+#define NL80211_CMD_REG_BEACON_HINT NL80211_CMD_REG_BEACON_HINT
 
 /**
  * enum nl80211_attrs - nl80211 netlink attributes
@@ -296,6 +347,18 @@ enum nl80211_commands {
  *      NL80211_CHAN_HT20 = HT20 only
  *      NL80211_CHAN_HT40MINUS = secondary channel is below the primary channel
  *      NL80211_CHAN_HT40PLUS = secondary channel is above the primary channel
+ * @NL80211_ATTR_WIPHY_RETRY_SHORT: TX retry limit for frames whose length is
+ *      less than or equal to the RTS threshold; allowed range: 1..255;
+ *      dot11ShortRetryLimit; u8
+ * @NL80211_ATTR_WIPHY_RETRY_LONG: TX retry limit for frames whose length is
+ *      greater than the RTS threshold; allowed range: 1..255;
+ *      dot11ShortLongLimit; u8
+ * @NL80211_ATTR_WIPHY_FRAG_THRESHOLD: fragmentation threshold, i.e., maximum
+ *      length in octets for frames; allowed range: 256..8000, disable
+ *      fragmentation with (u32)-1; dot11FragmentationThreshold; u32
+ * @NL80211_ATTR_WIPHY_RTS_THRESHOLD: RTS threshold (TX frames with length
+ *      larger than or equal to this use RTS/CTS handshake); allowed range:
+ *      0..65536, disable with (u32)-1; dot11RTSThreshold; u32
  *
  * @NL80211_ATTR_IFINDEX: network interface index of the device to operate on
  * @NL80211_ATTR_IFNAME: network interface name
@@ -319,7 +382,7 @@ enum nl80211_commands {
  *
  * @NL80211_ATTR_STA_AID: Association ID for the station (u16)
  * @NL80211_ATTR_STA_FLAGS: flags, nested element with NLA_FLAG attributes of
- *      &enum nl80211_sta_flags.
+ *      &enum nl80211_sta_flags (deprecated, use %NL80211_ATTR_STA_FLAGS2)
  * @NL80211_ATTR_STA_LISTEN_INTERVAL: listen interval as defined by
  *      IEEE 802.11 7.3.1.6 (u16).
  * @NL80211_ATTR_STA_SUPPORTED_RATES: supported rates, array of supported
@@ -380,6 +443,8 @@ enum nl80211_commands {
  *
  * @NL80211_ATTR_MAX_NUM_SCAN_SSIDS: number of SSIDs you can scan with
  *      a single scan request, a wiphy attribute.
+ * @NL80211_ATTR_MAX_SCAN_IE_LEN: maximum length of information elements
+ *      that can be added to a scan request
  *
  * @NL80211_ATTR_SCAN_FREQUENCIES: nested attribute with frequencies (in MHz)
  * @NL80211_ATTR_SCAN_SSIDS: nested attribute with SSIDs, leave out for passive
@@ -408,6 +473,44 @@ enum nl80211_commands {
  * @NL80211_ATTR_REASON_CODE: ReasonCode for %NL80211_CMD_DEAUTHENTICATE and
  *      %NL80211_CMD_DISASSOCIATE, u16
  *
+ * @NL80211_ATTR_KEY_TYPE: Key Type, see &enum nl80211_key_type, represented as
+ *      a u32
+ *
+ * @NL80211_ATTR_FREQ_BEFORE: A channel which has suffered a regulatory change
+ *      due to considerations from a beacon hint. This attribute reflects
+ *      the state of the channel _before_ the beacon hint processing. This
+ *      attributes consists of a nested attribute containing
+ *      NL80211_FREQUENCY_ATTR_*
+ * @NL80211_ATTR_FREQ_AFTER: A channel which has suffered a regulatory change
+ *      due to considerations from a beacon hint. This attribute reflects
+ *      the state of the channel _after_ the beacon hint processing. This
+ *      attributes consists of a nested attribute containing
+ *      NL80211_FREQUENCY_ATTR_*
+ *
+ * @NL80211_ATTR_CIPHER_SUITES: a set of u32 values indicating the supported
+ *      cipher suites
+ *
+ * @NL80211_ATTR_FREQ_FIXED: a flag indicating the IBSS should not try to look
+ *      for other networks on different channels
+ *
+ * @NL80211_ATTR_TIMED_OUT: a flag indicating than an operation timed out; this
+ *      is used, e.g., with %NL80211_CMD_AUTHENTICATE event
+ *
+ * @NL80211_ATTR_USE_MFP: Whether management frame protection (IEEE 802.11w) is
+ *      used for the association (&enum nl80211_mfp, represented as a u32);
+ *      this attribute can be used
+ *      with %NL80211_CMD_ASSOCIATE request
+ *
+ * @NL80211_ATTR_STA_FLAGS2: Attribute containing a
+ *      &struct nl80211_sta_flag_update.
+ *
+ * @NL80211_ATTR_CONTROL_PORT: A flag indicating whether user space controls
+ *      IEEE 802.1X port, i.e., sets/clears %NL80211_STA_FLAG_AUTHORIZED, in
+ *      station mode. If the flag is included in %NL80211_CMD_ASSOCIATE
+ *      request, the driver will assume that the port is unauthorized until
+ *      authorized by user space. Otherwise, port is marked authorized by
+ *      default in station mode.
+ *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
  */
@@ -492,6 +595,30 @@ enum nl80211_attrs {
         NL80211_ATTR_AUTH_TYPE,
         NL80211_ATTR_REASON_CODE,
 
+        NL80211_ATTR_KEY_TYPE,
+
+        NL80211_ATTR_MAX_SCAN_IE_LEN,
+        NL80211_ATTR_CIPHER_SUITES,
+
+        NL80211_ATTR_FREQ_BEFORE,
+        NL80211_ATTR_FREQ_AFTER,
+
+        NL80211_ATTR_FREQ_FIXED,
+
+
+        NL80211_ATTR_WIPHY_RETRY_SHORT,
+        NL80211_ATTR_WIPHY_RETRY_LONG,
+        NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
+        NL80211_ATTR_WIPHY_RTS_THRESHOLD,
+
+        NL80211_ATTR_TIMED_OUT,
+
+        NL80211_ATTR_USE_MFP,
+
+        NL80211_ATTR_STA_FLAGS2,
+
+        NL80211_ATTR_CONTROL_PORT,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -581,6 +708,18 @@ enum nl80211_sta_flags {
 };
 
 /**
+ * struct nl80211_sta_flag_update - station flags mask/set
+ * @mask: mask of station flags to set
+ * @set: which values to set them to
+ *
+ * Both mask and set contain bits as per &enum nl80211_sta_flags.
+ */
+struct nl80211_sta_flag_update {
+        __u32 mask;
+        __u32 set;
+} __attribute__((packed));
+
+/**
  * enum nl80211_rate_info - bitrate information
  *
  * These attribute types are used with %NL80211_STA_INFO_TXRATE
@@ -1062,4 +1201,27 @@ enum nl80211_auth_type {
         NL80211_AUTHTYPE_FT,
         NL80211_AUTHTYPE_NETWORK_EAP,
 };
+
+/**
+ * enum nl80211_key_type - Key Type
+ * @NL80211_KEYTYPE_GROUP: Group (broadcast/multicast) key
+ * @NL80211_KEYTYPE_PAIRWISE: Pairwise (unicast/individual) key
+ * @NL80211_KEYTYPE_PEERKEY: PeerKey (DLS)
+ */
+enum nl80211_key_type {
+        NL80211_KEYTYPE_GROUP,
+        NL80211_KEYTYPE_PAIRWISE,
+        NL80211_KEYTYPE_PEERKEY,
+};
+
+/**
+ * enum nl80211_mfp - Management frame protection state
+ * @NL80211_MFP_NO: Management frame protection not used
+ * @NL80211_MFP_REQUIRED: Management frame protection required
+ */
+enum nl80211_mfp {
+        NL80211_MFP_NO,
+        NL80211_MFP_REQUIRED,
+};
+
 #endif /* __LINUX_NL80211_H */
diff --git a/include/linux/nl802154.h b/include/linux/nl802154.h
new file mode 100644
index 000000000000..2cda00ccfcca
--- /dev/null
+++ b/include/linux/nl802154.h
@@ -0,0 +1,119 @@
+/*
+ * nl802154.h
+ *
+ * Copyright (C) 2007, 2008, 2009 Siemens AG
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef NL802154_H
+#define NL802154_H
+
+#define IEEE802154_NL_NAME "802.15.4 MAC"
+#define IEEE802154_MCAST_COORD_NAME "coordinator"
+#define IEEE802154_MCAST_BEACON_NAME "beacon"
+
+enum {
+        __IEEE802154_ATTR_INVALID,
+
+        IEEE802154_ATTR_DEV_NAME,
+        IEEE802154_ATTR_DEV_INDEX,
+
+        IEEE802154_ATTR_STATUS,
+
+        IEEE802154_ATTR_SHORT_ADDR,
+        IEEE802154_ATTR_HW_ADDR,
+        IEEE802154_ATTR_PAN_ID,
+
+        IEEE802154_ATTR_CHANNEL,
+
+        IEEE802154_ATTR_COORD_SHORT_ADDR,
+        IEEE802154_ATTR_COORD_HW_ADDR,
+        IEEE802154_ATTR_COORD_PAN_ID,
+
+        IEEE802154_ATTR_SRC_SHORT_ADDR,
+        IEEE802154_ATTR_SRC_HW_ADDR,
+        IEEE802154_ATTR_SRC_PAN_ID,
+
+        IEEE802154_ATTR_DEST_SHORT_ADDR,
+        IEEE802154_ATTR_DEST_HW_ADDR,
+        IEEE802154_ATTR_DEST_PAN_ID,
+
+        IEEE802154_ATTR_CAPABILITY,
+        IEEE802154_ATTR_REASON,
+        IEEE802154_ATTR_SCAN_TYPE,
+        IEEE802154_ATTR_CHANNELS,
+        IEEE802154_ATTR_DURATION,
+        IEEE802154_ATTR_ED_LIST,
+        IEEE802154_ATTR_BCN_ORD,
+        IEEE802154_ATTR_SF_ORD,
+        IEEE802154_ATTR_PAN_COORD,
+        IEEE802154_ATTR_BAT_EXT,
+        IEEE802154_ATTR_COORD_REALIGN,
+        IEEE802154_ATTR_SEC,
+
+        __IEEE802154_ATTR_MAX,
+};
+
+#define IEEE802154_ATTR_MAX (__IEEE802154_ATTR_MAX - 1)
+
+extern struct nla_policy ieee802154_policy[];
+
+/* commands */
+/* REQ should be responded with CONF
+ * and INDIC with RESP
+ */
+enum {
+        __IEEE802154_COMMAND_INVALID,
+
+        IEEE802154_ASSOCIATE_REQ,
+        IEEE802154_ASSOCIATE_CONF,
+        IEEE802154_DISASSOCIATE_REQ,
+        IEEE802154_DISASSOCIATE_CONF,
+        IEEE802154_GET_REQ,
+        IEEE802154_GET_CONF,
+        IEEE802154_RESET_REQ,
+        IEEE802154_RESET_CONF,
+        IEEE802154_SCAN_REQ,
+        IEEE802154_SCAN_CONF,
+        IEEE802154_SET_REQ,
+        IEEE802154_SET_CONF,
+        IEEE802154_START_REQ,
+        IEEE802154_START_CONF,
+        IEEE802154_SYNC_REQ,
+        IEEE802154_POLL_REQ,
+        IEEE802154_POLL_CONF,
+
+        IEEE802154_ASSOCIATE_INDIC,
+        IEEE802154_ASSOCIATE_RESP,
+        IEEE802154_DISASSOCIATE_INDIC,
+        IEEE802154_BEACON_NOTIFY_INDIC,
+        IEEE802154_ORPHAN_INDIC,
+        IEEE802154_ORPHAN_RESP,
+        IEEE802154_COMM_STATUS_INDIC,
+        IEEE802154_SYNC_LOSS_INDIC,
+
+        IEEE802154_GTS_REQ, /* Not supported yet */
+        IEEE802154_GTS_INDIC, /* Not supported yet */
+        IEEE802154_GTS_CONF, /* Not supported yet */
+        IEEE802154_RX_ENABLE_REQ, /* Not supported yet */
+        IEEE802154_RX_ENABLE_CONF, /* Not supported yet */
+
+        __IEEE802154_CMD_MAX,
+};
+
+#define IEEE802154_CMD_MAX (__IEEE802154_CMD_MAX - 1)
+
+#endif
diff --git a/include/linux/nls.h b/include/linux/nls.h
index 52b1a76c1b43..d47beef08dfd 100644
--- a/include/linux/nls.h
+++ b/include/linux/nls.h
@@ -3,8 +3,23 @@
 
 #include <linux/init.h>
 
-/* unicode character */
-typedef __u16 wchar_t;
+/* Unicode has changed over the years.  Unicode code points no longer
+ * fit into 16 bits; as of Unicode 5 valid code points range from 0
+ * to 0x10ffff (17 planes, where each plane holds 65536 code points).
+ *
+ * The original decision to represent Unicode characters as 16-bit
+ * wchar_t values is now outdated.  But plane 0 still includes the
+ * most commonly used characters, so we will retain it.  The newer
+ * 32-bit unicode_t type can be used when it is necessary to
+ * represent the full Unicode character set.
+ */
+
+/* Plane-0 Unicode character */
+typedef u16 wchar_t;
+#define MAX_WCHAR_T     0xffff
+
+/* Arbitrary Unicode character */
+typedef u32 unicode_t;
 
 struct nls_table {
         const char *charset;
@@ -21,6 +36,13 @@ struct nls_table {
 /* this value hold the maximum octet of charset */
 #define NLS_MAX_CHARSET_SIZE 6 /* for UTF-8 */
 
+/* Byte order for UTF-16 strings */
+enum utf16_endian {
+        UTF16_HOST_ENDIAN,
+        UTF16_LITTLE_ENDIAN,
+        UTF16_BIG_ENDIAN
+};
+
 /* nls.c */
 extern int register_nls(struct nls_table *);
 extern int unregister_nls(struct nls_table *);
@@ -28,10 +50,11 @@ extern struct nls_table *load_nls(char *);
 extern void unload_nls(struct nls_table *);
 extern struct nls_table *load_nls_default(void);
 
-extern int utf8_mbtowc(wchar_t *, const __u8 *, int);
-extern int utf8_mbstowcs(wchar_t *, const __u8 *, int);
-extern int utf8_wctomb(__u8 *, wchar_t, int);
-extern int utf8_wcstombs(__u8 *, const wchar_t *, int);
+extern int utf8_to_utf32(const u8 *s, int len, unicode_t *pu);
+extern int utf32_to_utf8(unicode_t u, u8 *s, int maxlen);
+extern int utf8s_to_utf16s(const u8 *s, int len, wchar_t *pwcs);
+extern int utf16s_to_utf8s(const wchar_t *pwcs, int len,
+                enum utf16_endian endian, u8 *s, int maxlen);
 
 static inline unsigned char nls_tolower(struct nls_table *t, unsigned char c)
 {
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index 848025cd7087..b359c4a9ec9e 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -82,6 +82,12 @@
  *    to generate slightly worse code.  So use a simple one-line #define
  *    for node_isset(), instead of wrapping an inline inside a macro, the
  *    way we do the other calls.
+ *
+ * NODEMASK_SCRATCH
+ * When doing above logical AND, OR, XOR, Remap operations the callers tend to
+ * need temporary nodemask_t's on the stack. But if NODES_SHIFT is large,
+ * nodemask_t's consume too much stack space.  NODEMASK_SCRATCH is a helper
+ * for such situations. See below and CPUMASK_ALLOC also.
  */
 
 #include <linux/kernel.h>
@@ -408,6 +414,19 @@ static inline int num_node_state(enum node_states state)
 #define next_online_node(nid)   next_node((nid), node_states[N_ONLINE])
 
 extern int nr_node_ids;
+extern int nr_online_nodes;
+
+static inline void node_set_online(int nid)
+{
+        node_set_state(nid, N_ONLINE);
+        nr_online_nodes = num_node_state(N_ONLINE);
+}
+
+static inline void node_set_offline(int nid)
+{
+        node_clear_state(nid, N_ONLINE);
+        nr_online_nodes = num_node_state(N_ONLINE);
+}
 #else
 
 static inline int node_state(int node, enum node_states state)
@@ -434,7 +453,10 @@ static inline int num_node_state(enum node_states state)
 #define first_online_node       0
 #define next_online_node(nid)   (MAX_NUMNODES)
 #define nr_node_ids             1
+#define nr_online_nodes         1
 
+#define node_set_online(node)      node_set_state((node), N_ONLINE)
+#define node_set_offline(node)     node_clear_state((node), N_ONLINE)
 #endif
 
 #define node_online_map         node_states[N_ONLINE]
@@ -454,10 +476,29 @@ static inline int num_node_state(enum node_states state)
 #define node_online(node)       node_state((node), N_ONLINE)
 #define node_possible(node)     node_state((node), N_POSSIBLE)
 
-#define node_set_online(node)      node_set_state((node), N_ONLINE)
-#define node_set_offline(node)     node_clear_state((node), N_ONLINE)
-
 #define for_each_node(node)        for_each_node_state(node, N_POSSIBLE)
 #define for_each_online_node(node) for_each_node_state(node, N_ONLINE)
 
+/*
+ * For nodemask scrach area.(See CPUMASK_ALLOC() in cpumask.h)
+ */
+
+#if NODES_SHIFT > 8 /* nodemask_t > 64 bytes */
+#define NODEMASK_ALLOC(x, m) struct x *m = kmalloc(sizeof(*m), GFP_KERNEL)
+#define NODEMASK_FREE(m) kfree(m)
+#else
+#define NODEMASK_ALLOC(x, m) struct x _m, *m = &_m
+#define NODEMASK_FREE(m)
+#endif
+
+/* A example struture for using NODEMASK_ALLOC, used in mempolicy. */
+struct nodemask_scratch {
+        nodemask_t      mask1;
+        nodemask_t      mask2;
+};
+
+#define NODEMASK_SCRATCH(x) NODEMASK_ALLOC(nodemask_scratch, x)
+#define NODEMASK_SCRATCH_FREE(x)  NODEMASK_FREE(x)
+
+
 #endif /* __LINUX_NODEMASK_H */
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index b86fa2ffca0c..81bc252dc8ac 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -198,6 +198,7 @@ static inline int notifier_to_errno(int ret)
 #define NETDEV_CHANGENAME       0x000A
 #define NETDEV_FEAT_CHANGE      0x000B
 #define NETDEV_BONDING_FAILOVER 0x000C
+#define NETDEV_PRE_UP           0x000D
 
 #define SYS_DOWN        0x0001  /* Notify of system down */
 #define SYS_RESTART     SYS_DOWN
diff --git a/include/linux/of.h b/include/linux/of.h
index 6a7efa242f5e..7be2d1043c16 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -77,6 +77,9 @@ extern int of_n_size_cells(struct device_node *np);
 extern const struct of_device_id *of_match_node(
         const struct of_device_id *matches, const struct device_node *node);
 extern int of_modalias_node(struct device_node *node, char *modalias, int len);
+extern struct device_node *of_parse_phandle(struct device_node *np,
+                                            const char *phandle_name,
+                                            int index);
 extern int of_parse_phandles_with_args(struct device_node *np,
         const char *list_name, const char *cells_name, int index,
         struct device_node **out_node, const void **out_args);
diff --git a/include/linux/of_mdio.h b/include/linux/of_mdio.h
new file mode 100644
index 000000000000..53b94e025c7c
--- /dev/null
+++ b/include/linux/of_mdio.h
@@ -0,0 +1,25 @@
+/*
+ * OF helpers for the MDIO (Ethernet PHY) API
+ *
+ * Copyright (c) 2009 Secret Lab Technologies, Ltd.
+ *
+ * This file is released under the GPLv2
+ */
+
+#ifndef __LINUX_OF_MDIO_H
+#define __LINUX_OF_MDIO_H
+
+#include <linux/phy.h>
+#include <linux/of.h>
+
+extern int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np);
+extern struct phy_device *of_phy_find_device(struct device_node *phy_np);
+extern struct phy_device *of_phy_connect(struct net_device *dev,
+                                         struct device_node *phy_np,
+                                         void (*hndlr)(struct net_device *),
+                                         u32 flags, phy_interface_t iface);
+extern struct phy_device *of_phy_connect_fixed_link(struct net_device *dev,
+                                         void (*hndlr)(struct net_device *),
+                                         phy_interface_t iface);
+
+#endif /* __LINUX_OF_MDIO_H */
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 62214c7d2d93..e2e5ce543595 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -95,9 +95,7 @@ enum pageflags {
         PG_reclaim,             /* To be reclaimed asap */
         PG_buddy,               /* Page is free, on buddy lists */
         PG_swapbacked,          /* Page is backed by RAM/swap */
-#ifdef CONFIG_UNEVICTABLE_LRU
         PG_unevictable,         /* Page is "unevictable"  */
-#endif
 #ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
         PG_mlocked,             /* Page is vma mlocked */
 #endif
@@ -120,7 +118,6 @@ enum pageflags {
         PG_savepinned = PG_dirty,
 
         /* SLOB */
-        PG_slob_page = PG_active,
         PG_slob_free = PG_private,
 
         /* SLUB */
@@ -203,7 +200,6 @@ PAGEFLAG(SavePinned, savepinned);			/* Xen */
 PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
 PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
 
-__PAGEFLAG(SlobPage, slob_page)
 __PAGEFLAG(SlobFree, slob_free)
 
 __PAGEFLAG(SlubFrozen, slub_frozen)
@@ -248,14 +244,8 @@ PAGEFLAG_FALSE(SwapCache)
         SETPAGEFLAG_NOOP(SwapCache) CLEARPAGEFLAG_NOOP(SwapCache)
 #endif
 
-#ifdef CONFIG_UNEVICTABLE_LRU
 PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
         TESTCLEARFLAG(Unevictable, unevictable)
-#else
-PAGEFLAG_FALSE(Unevictable) TESTCLEARFLAG_FALSE(Unevictable)
-        SETPAGEFLAG_NOOP(Unevictable) CLEARPAGEFLAG_NOOP(Unevictable)
-        __CLEARPAGEFLAG_NOOP(Unevictable)
-#endif
 
 #ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
 #define MLOCK_PAGES 1
@@ -382,12 +372,6 @@ static inline void __ClearPageTail(struct page *page)
 
 #endif /* !PAGEFLAGS_EXTENDED */
 
-#ifdef CONFIG_UNEVICTABLE_LRU
-#define __PG_UNEVICTABLE        (1 << PG_unevictable)
-#else
-#define __PG_UNEVICTABLE        0
-#endif
-
 #ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
 #define __PG_MLOCKED            (1 << PG_mlocked)
 #else
@@ -403,7 +387,7 @@ static inline void __ClearPageTail(struct page *page)
          1 << PG_private | 1 << PG_private_2 | \
          1 << PG_buddy   | 1 << PG_writeback | 1 << PG_reserved | \
          1 << PG_slab    | 1 << PG_swapcache | 1 << PG_active | \
-         __PG_UNEVICTABLE | __PG_MLOCKED)
+         1 << PG_unevictable | __PG_MLOCKED)
 
 /*
  * Flags checked when a page is prepped for return by the page allocator.
diff --git a/include/linux/page_cgroup.h b/include/linux/page_cgroup.h
index 7339c7bf7331..13f126c89ae8 100644
--- a/include/linux/page_cgroup.h
+++ b/include/linux/page_cgroup.h
@@ -18,7 +18,19 @@ struct page_cgroup {
 };
 
 void __meminit pgdat_page_cgroup_init(struct pglist_data *pgdat);
-void __init page_cgroup_init(void);
+
+#ifdef CONFIG_SPARSEMEM
+static inline void __init page_cgroup_init_flatmem(void)
+{
+}
+extern void __init page_cgroup_init(void);
+#else
+void __init page_cgroup_init_flatmem(void);
+static inline void __init page_cgroup_init(void)
+{
+}
+#endif
+
 struct page_cgroup *lookup_page_cgroup(struct page *page);
 
 enum {
@@ -87,6 +99,10 @@ static inline void page_cgroup_init(void)
 {
 }
 
+static inline void __init page_cgroup_init_flatmem(void)
+{
+}
+
 #endif
 
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 34da5230faab..aec3252afcf5 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -22,9 +22,7 @@ enum mapping_flags {
         AS_EIO          = __GFP_BITS_SHIFT + 0, /* IO error on async write */
         AS_ENOSPC       = __GFP_BITS_SHIFT + 1, /* ENOSPC on async write */
         AS_MM_ALL_LOCKS = __GFP_BITS_SHIFT + 2, /* under mm_take_all_locks() */
-#ifdef CONFIG_UNEVICTABLE_LRU
         AS_UNEVICTABLE  = __GFP_BITS_SHIFT + 3, /* e.g., ramdisk, SHM_LOCK */
-#endif
 };
 
 static inline void mapping_set_error(struct address_space *mapping, int error)
@@ -37,8 +35,6 @@ static inline void mapping_set_error(struct address_space *mapping, int error)
         }
 }
 
-#ifdef CONFIG_UNEVICTABLE_LRU
-
 static inline void mapping_set_unevictable(struct address_space *mapping)
 {
         set_bit(AS_UNEVICTABLE, &mapping->flags);
@@ -55,14 +51,6 @@ static inline int mapping_unevictable(struct address_space *mapping)
                 return test_bit(AS_UNEVICTABLE, &mapping->flags);
         return !!mapping;
 }
-#else
-static inline void mapping_set_unevictable(struct address_space *mapping) { }
-static inline void mapping_clear_unevictable(struct address_space *mapping) { }
-static inline int mapping_unevictable(struct address_space *mapping)
-{
-        return 0;
-}
-#endif
 
 static inline gfp_t mapping_gfp_mask(struct address_space * mapping)
 {
diff --git a/include/linux/pci-acpi.h b/include/linux/pci-acpi.h
index 092e82e0048c..93a7c08f869d 100644
--- a/include/linux/pci-acpi.h
+++ b/include/linux/pci-acpi.h
@@ -15,7 +15,7 @@ static inline acpi_handle acpi_find_root_bridge_handle(struct pci_dev *pdev)
 {
         struct pci_bus *pbus = pdev->bus;
         /* Find a PCI root bus */
-        while (pbus->parent)
+        while (!pci_is_root_bus(pbus))
                 pbus = pbus->parent;
         return acpi_get_pci_rootbridge_handle(pci_domain_nr(pbus),
                                               pbus->number);
@@ -23,7 +23,7 @@ static inline acpi_handle acpi_find_root_bridge_handle(struct pci_dev *pdev)
 
 static inline acpi_handle acpi_pci_get_bridge_handle(struct pci_bus *pbus)
 {
-        if (pbus->parent)
+        if (!pci_is_root_bus(pbus))
                 return DEVICE_ACPI_HANDLE(&(pbus->self->dev));
         return acpi_get_pci_rootbridge_handle(pci_domain_nr(pbus),
                                               pbus->number);
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 72698d89e767..115fb7ba5089 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -124,6 +124,14 @@ typedef int __bitwise pci_power_t;
 #define PCI_UNKNOWN     ((pci_power_t __force) 5)
 #define PCI_POWER_ERROR ((pci_power_t __force) -1)
 
+/* Remember to update this when the list above changes! */
+extern const char *pci_power_names[];
+
+static inline const char *pci_power_name(pci_power_t state)
+{
+        return pci_power_names[1 + (int) state];
+}
+
 #define PCI_PM_D2_DELAY 200
 #define PCI_PM_D3_WAIT  10
 #define PCI_PM_BUS_WAIT 50
@@ -188,6 +196,7 @@ struct pci_cap_saved_state {
 struct pcie_link_state;
 struct pci_vpd;
 struct pci_sriov;
+struct pci_ats;
 
 /*
  * The pci_dev structure is used to describe PCI devices.
@@ -285,6 +294,7 @@ struct pci_dev {
                 struct pci_sriov *sriov;        /* SR-IOV capability related */
                 struct pci_dev *physfn; /* the PF this VF is associated with */
         };
+        struct pci_ats  *ats;   /* Address Translation Service */
 #endif
 };
 
@@ -599,8 +609,6 @@ extern void pci_sort_breadthfirst(void);
 struct pci_dev __deprecated *pci_find_device(unsigned int vendor,
                                              unsigned int device,
                                              struct pci_dev *from);
-struct pci_dev __deprecated *pci_find_slot(unsigned int bus,
-                                           unsigned int devfn);
 #endif /* CONFIG_PCI_LEGACY */
 
 enum pci_lost_interrupt_reason {
@@ -639,6 +647,7 @@ int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn,
                               int where, u16 val);
 int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
                                int where, u32 val);
+struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops);
 
 static inline int pci_read_config_byte(struct pci_dev *dev, int where, u8 *val)
 {
@@ -703,8 +712,8 @@ int pcix_get_mmrbc(struct pci_dev *dev);
 int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
 int pcie_get_readrq(struct pci_dev *dev);
 int pcie_set_readrq(struct pci_dev *dev, int rq);
+int __pci_reset_function(struct pci_dev *dev);
 int pci_reset_function(struct pci_dev *dev);
-int pci_execute_reset_function(struct pci_dev *dev);
 void pci_update_resource(struct pci_dev *dev, int resno);
 int __must_check pci_assign_resource(struct pci_dev *dev, int i);
 int pci_select_bars(struct pci_dev *dev, unsigned long flags);
@@ -724,7 +733,7 @@ int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
 pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
 bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
 void pci_pme_active(struct pci_dev *dev, bool enable);
-int pci_enable_wake(struct pci_dev *dev, pci_power_t state, int enable);
+int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable);
 int pci_wake_from_d3(struct pci_dev *dev, bool enable);
 pci_power_t pci_target_state(struct pci_dev *dev);
 int pci_prepare_to_sleep(struct pci_dev *dev);
@@ -790,7 +799,7 @@ const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
 int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max,
                     int pass);
 
-void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
+void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
                   void *userdata);
 int pci_cfg_space_size_ext(struct pci_dev *dev);
 int pci_cfg_space_size(struct pci_dev *dev);
@@ -880,6 +889,17 @@ static inline int pcie_aspm_enabled(void)
 extern int pcie_aspm_enabled(void);
 #endif
 
+#ifndef CONFIG_PCIE_ECRC
+static inline void pcie_set_ecrc_checking(struct pci_dev *dev)
+{
+        return;
+}
+static inline void pcie_ecrc_get_policy(char *str) {};
+#else
+extern void pcie_set_ecrc_checking(struct pci_dev *dev);
+extern void pcie_ecrc_get_policy(char *str);
+#endif
+
 #define pci_enable_msi(pdev)    pci_enable_msi_block(pdev, 1)
 
 #ifdef CONFIG_HT_IRQ
@@ -936,12 +956,6 @@ static inline struct pci_dev *pci_find_device(unsigned int vendor,
         return NULL;
 }
 
-static inline struct pci_dev *pci_find_slot(unsigned int bus,
-                                            unsigned int devfn)
-{
-        return NULL;
-}
-
 static inline struct pci_dev *pci_get_device(unsigned int vendor,
                                              unsigned int device,
                                              struct pci_dev *from)
@@ -1097,6 +1111,10 @@ static inline struct pci_dev *pci_get_bus_and_slot(unsigned int bus,
 
 #include <asm/pci.h>
 
+#ifndef PCIBIOS_MAX_MEM_32
+#define PCIBIOS_MAX_MEM_32 (-1)
+#endif
+
 /* these helpers provide future and backwards compatibility
  * for accessing popular PCI BAR info */
 #define pci_resource_start(dev, bar)    ((dev)->resource[(bar)].start)
@@ -1127,7 +1145,7 @@ static inline void pci_set_drvdata(struct pci_dev *pdev, void *data)
 /* If you want to know what to call your pci_dev, ask this function.
  * Again, it's a wrapper around the generic device.
  */
-static inline const char *pci_name(struct pci_dev *pdev)
+static inline const char *pci_name(const struct pci_dev *pdev)
 {
         return dev_name(&pdev->dev);
 }
@@ -1253,5 +1271,10 @@ static inline irqreturn_t pci_sriov_migration(struct pci_dev *dev)
 }
 #endif
 
+#if defined(CONFIG_HOTPLUG_PCI) || defined(CONFIG_HOTPLUG_PCI_MODULE)
+extern void pci_hp_create_module_link(struct pci_slot *pci_slot);
+extern void pci_hp_remove_module_link(struct pci_slot *pci_slot);
+#endif
+
 #endif /* __KERNEL__ */
 #endif /* LINUX_PCI_H */
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index 20998746518e..4391741b99dc 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -66,17 +66,10 @@ enum pcie_link_speed {
         PCIE_LNK_SPEED_UNKNOWN  = 0xFF,
 };
 
-struct hotplug_slot;
-struct hotplug_slot_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct hotplug_slot *, char *);
-        ssize_t (*store)(struct hotplug_slot *, const char *, size_t);
-};
-#define to_hotplug_attr(n) container_of(n, struct hotplug_slot_attribute, attr);
-
 /**
  * struct hotplug_slot_ops -the callbacks that the hotplug pci core can use
  * @owner: The module owner of this structure
+ * @mod_name: The module name (KBUILD_MODNAME) of this structure
  * @enable_slot: Called when the user wants to enable a specific pci slot
  * @disable_slot: Called when the user wants to disable a specific pci slot
  * @set_attention_status: Called to set the specific slot's attention LED to
@@ -109,6 +102,7 @@ struct hotplug_slot_attribute {
  */
 struct hotplug_slot_ops {
         struct module *owner;
+        const char *mod_name;
         int (*enable_slot)              (struct hotplug_slot *slot);
         int (*disable_slot)             (struct hotplug_slot *slot);
         int (*set_attention_status)     (struct hotplug_slot *slot, u8 value);
@@ -167,12 +161,21 @@ static inline const char *hotplug_slot_name(const struct hotplug_slot *slot)
         return pci_slot_name(slot->pci_slot);
 }
 
-extern int pci_hp_register(struct hotplug_slot *, struct pci_bus *, int nr,
-                           const char *name);
+extern int __pci_hp_register(struct hotplug_slot *slot, struct pci_bus *pbus,
+                             int nr, const char *name,
+                             struct module *owner, const char *mod_name);
 extern int pci_hp_deregister(struct hotplug_slot *slot);
 extern int __must_check pci_hp_change_slot_info (struct hotplug_slot *slot,
                                                  struct hotplug_slot_info *info);
 
+static inline int pci_hp_register(struct hotplug_slot *slot,
+                                  struct pci_bus *pbus,
+                                  int devnr, const char *name)
+{
+        return __pci_hp_register(slot, pbus, devnr, name,
+                                 THIS_MODULE, KBUILD_MODNAME);
+}
+
 /* PCI Setting Record (Type 0) */
 struct hpp_type0 {
         u32 revision;
@@ -226,7 +229,6 @@ struct hotplug_params {
 extern acpi_status acpi_get_hp_params_from_firmware(struct pci_bus *bus,
                                 struct hotplug_params *hpp);
 int acpi_get_hp_hw_control_from_firmware(struct pci_dev *dev, u32 flags);
-int acpi_root_bridge(acpi_handle handle);
 int acpi_pci_check_ejectable(struct pci_bus *pbus, acpi_handle handle);
 int acpi_pci_detect_ejectable(struct pci_bus *pbus);
 #endif
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 0f71812d67d3..73b46b6b904f 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -104,6 +104,7 @@
 #define PCI_CLASS_SERIAL_USB_UHCI       0x0c0300
 #define PCI_CLASS_SERIAL_USB_OHCI       0x0c0310
 #define PCI_CLASS_SERIAL_USB_EHCI       0x0c0320
+#define PCI_CLASS_SERIAL_USB_XHCI       0x0c0330
 #define PCI_CLASS_SERIAL_FIBER          0x0c04
 #define PCI_CLASS_SERIAL_SMBUS          0x0c05
 
@@ -1005,6 +1006,7 @@
 #define PCI_DEVICE_ID_PLX_PCI200SYN     0x3196
 #define PCI_DEVICE_ID_PLX_9030          0x9030
 #define PCI_DEVICE_ID_PLX_9050          0x9050
+#define PCI_DEVICE_ID_PLX_9056          0x9056
 #define PCI_DEVICE_ID_PLX_9080          0x9080
 #define PCI_DEVICE_ID_PLX_GTEK_SERIAL2  0xa001
 
@@ -1066,8 +1068,6 @@
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SMBUS 0x0034
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE   0x0035
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA  0x0036
-#define PCI_DEVICE_ID_NVIDIA_NVENET_10          0x0037
-#define PCI_DEVICE_ID_NVIDIA_NVENET_11          0x0038
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2 0x003e
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800_ULTRA 0x0040
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_6800       0x0041
@@ -1078,21 +1078,16 @@
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE   0x0053
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA  0x0054
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA2 0x0055
-#define PCI_DEVICE_ID_NVIDIA_NVENET_8           0x0056
-#define PCI_DEVICE_ID_NVIDIA_NVENET_9           0x0057
 #define PCI_DEVICE_ID_NVIDIA_CK804_AUDIO        0x0059
 #define PCI_DEVICE_ID_NVIDIA_CK804_PCIE         0x005d
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2_SMBUS      0x0064
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2_IDE        0x0065
-#define PCI_DEVICE_ID_NVIDIA_NVENET_2           0x0066
 #define PCI_DEVICE_ID_NVIDIA_MCP2_MODEM         0x0069
 #define PCI_DEVICE_ID_NVIDIA_MCP2_AUDIO         0x006a
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2S_SMBUS     0x0084
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2S_IDE       0x0085
-#define PCI_DEVICE_ID_NVIDIA_NVENET_4           0x0086
 #define PCI_DEVICE_ID_NVIDIA_MCP2S_MODEM        0x0089
 #define PCI_DEVICE_ID_NVIDIA_CK8_AUDIO          0x008a
-#define PCI_DEVICE_ID_NVIDIA_NVENET_5           0x008c
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA      0x008e
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_7800_GT   0x0090
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_7800_GTX   0x0091
@@ -1108,15 +1103,12 @@
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3            0x00d1
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3_SMBUS      0x00d4
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3_IDE        0x00d5
-#define PCI_DEVICE_ID_NVIDIA_NVENET_3           0x00d6
 #define PCI_DEVICE_ID_NVIDIA_MCP3_MODEM         0x00d9
 #define PCI_DEVICE_ID_NVIDIA_MCP3_AUDIO         0x00da
-#define PCI_DEVICE_ID_NVIDIA_NVENET_7           0x00df
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3S           0x00e1
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA      0x00e3
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3S_SMBUS     0x00e4
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3S_IDE       0x00e5
-#define PCI_DEVICE_ID_NVIDIA_NVENET_6           0x00e6
 #define PCI_DEVICE_ID_NVIDIA_CK8S_AUDIO         0x00ea
 #define PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2     0x00ee
 #define PCIE_DEVICE_ID_NVIDIA_GEFORCE_6800_ALT1 0x00f0
@@ -1176,7 +1168,6 @@
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_SMBUS       0x01b4
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_IDE         0x01bc
 #define PCI_DEVICE_ID_NVIDIA_MCP1_MODEM         0x01c1
-#define PCI_DEVICE_ID_NVIDIA_NVENET_1           0x01c3
 #define PCI_DEVICE_ID_NVIDIA_NFORCE2            0x01e0
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE3           0x0200
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE3_1         0x0201
@@ -1199,8 +1190,6 @@
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE   0x036E
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA  0x037E
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2 0x037F
-#define PCI_DEVICE_ID_NVIDIA_NVENET_12          0x0268
-#define PCI_DEVICE_ID_NVIDIA_NVENET_13          0x0269
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800   0x0280
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800_8X    0x0281
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE4_TI_4800SE     0x0282
@@ -1247,46 +1236,21 @@
 #define PCI_DEVICE_ID_NVIDIA_GEFORCE_FX_GO5700_2    0x0348
 #define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_GO1000       0x034C
 #define PCI_DEVICE_ID_NVIDIA_QUADRO_FX_1100         0x034E
-#define PCI_DEVICE_ID_NVIDIA_NVENET_14              0x0372
 #define PCI_DEVICE_ID_NVIDIA_NVENET_15              0x0373
-#define PCI_DEVICE_ID_NVIDIA_NVENET_16              0x03E5
-#define PCI_DEVICE_ID_NVIDIA_NVENET_17              0x03E6
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA      0x03E7
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SMBUS     0x03EB
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE       0x03EC
-#define PCI_DEVICE_ID_NVIDIA_NVENET_18              0x03EE
-#define PCI_DEVICE_ID_NVIDIA_NVENET_19              0x03EF
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA2     0x03F6
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA3     0x03F7
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_SMBUS     0x0446
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP65_IDE       0x0448
-#define PCI_DEVICE_ID_NVIDIA_NVENET_20              0x0450
-#define PCI_DEVICE_ID_NVIDIA_NVENET_21              0x0451
-#define PCI_DEVICE_ID_NVIDIA_NVENET_22              0x0452
-#define PCI_DEVICE_ID_NVIDIA_NVENET_23              0x0453
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_SMBUS     0x0542
-#define PCI_DEVICE_ID_NVIDIA_NVENET_24              0x054C
-#define PCI_DEVICE_ID_NVIDIA_NVENET_25              0x054D
-#define PCI_DEVICE_ID_NVIDIA_NVENET_26              0x054E
-#define PCI_DEVICE_ID_NVIDIA_NVENET_27              0x054F
-#define PCI_DEVICE_ID_NVIDIA_NVENET_28              0x07DC
-#define PCI_DEVICE_ID_NVIDIA_NVENET_29              0x07DD
-#define PCI_DEVICE_ID_NVIDIA_NVENET_30              0x07DE
-#define PCI_DEVICE_ID_NVIDIA_NVENET_31              0x07DF
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_IDE       0x0560
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_IDE       0x056C
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP78S_SMBUS    0x0752
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP77_IDE       0x0759
-#define PCI_DEVICE_ID_NVIDIA_NVENET_32              0x0760
-#define PCI_DEVICE_ID_NVIDIA_NVENET_33              0x0761
-#define PCI_DEVICE_ID_NVIDIA_NVENET_34              0x0762
-#define PCI_DEVICE_ID_NVIDIA_NVENET_35              0x0763
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_SMBUS     0x07D8
 #define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP79_SMBUS     0x0AA2
-#define PCI_DEVICE_ID_NVIDIA_NVENET_36              0x0AB0
-#define PCI_DEVICE_ID_NVIDIA_NVENET_37              0x0AB1
-#define PCI_DEVICE_ID_NVIDIA_NVENET_38              0x0AB2
-#define PCI_DEVICE_ID_NVIDIA_NVENET_39              0x0AB3
 
 #define PCI_VENDOR_ID_IMS               0x10e0
 #define PCI_DEVICE_ID_IMS_TT128         0x9128
@@ -1314,6 +1278,13 @@
 
 #define PCI_VENDOR_ID_CREATIVE          0x1102 /* duplicate: ECTIVA */
 #define PCI_DEVICE_ID_CREATIVE_EMU10K1  0x0002
+#define PCI_DEVICE_ID_CREATIVE_20K1     0x0005
+#define PCI_DEVICE_ID_CREATIVE_20K2     0x000b
+#define PCI_SUBDEVICE_ID_CREATIVE_SB0760        0x0024
+#define PCI_SUBDEVICE_ID_CREATIVE_SB08801       0x0041
+#define PCI_SUBDEVICE_ID_CREATIVE_SB08802       0x0042
+#define PCI_SUBDEVICE_ID_CREATIVE_SB08803       0x0043
+#define PCI_SUBDEVICE_ID_CREATIVE_HENDRIX       0x6000
 
 #define PCI_VENDOR_ID_ECTIVA            0x1102 /* duplicate: CREATIVE */
 #define PCI_DEVICE_ID_ECTIVA_EV1938     0x8938
@@ -1847,6 +1818,10 @@
 #define PCI_SUBDEVICE_ID_HYPERCOPE_METRO        0x0107
 #define PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2       0x0108
 
+#define PCI_VENDOR_ID_DIGIGRAM          0x1369
+#define PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_SERIAL_SUBSYSTEM     0xc001
+#define PCI_SUBDEVICE_ID_DIGIGRAM_LX6464ES_CAE_SERIAL_SUBSYSTEM 0xc002
+
 #define PCI_VENDOR_ID_KAWASAKI          0x136b
 #define PCI_DEVICE_ID_MCHIP_KL5A72002   0xff01
 
@@ -1914,6 +1889,8 @@
 #define PCI_SUBDEVICE_ID_CCD_SWYX4S     0xB540
 #define PCI_SUBDEVICE_ID_CCD_JH4S20     0xB550
 #define PCI_SUBDEVICE_ID_CCD_IOB8ST_1   0xB552
+#define PCI_SUBDEVICE_ID_CCD_JHSE1      0xB553
+#define PCI_SUBDEVICE_ID_CCD_JH8S       0xB55B
 #define PCI_SUBDEVICE_ID_CCD_BN4S       0xB560
 #define PCI_SUBDEVICE_ID_CCD_BN8S       0xB562
 #define PCI_SUBDEVICE_ID_CCD_BNE1       0xB563
@@ -1996,10 +1973,12 @@
 #define PCI_DEVICE_ID_OXSEMI_PCIe952_1_U        0xC118
 #define PCI_DEVICE_ID_OXSEMI_PCIe952_1_GU       0xC11C
 #define PCI_DEVICE_ID_OXSEMI_16PCI954   0x9501
+#define PCI_DEVICE_ID_OXSEMI_C950       0x950B
 #define PCI_DEVICE_ID_OXSEMI_16PCI95N   0x9511
 #define PCI_DEVICE_ID_OXSEMI_16PCI954PP 0x9513
 #define PCI_DEVICE_ID_OXSEMI_16PCI952   0x9521
 #define PCI_DEVICE_ID_OXSEMI_16PCI952PP 0x9523
+#define PCI_SUBDEVICE_ID_OXSEMI_C950    0x0001
 
 #define PCI_VENDOR_ID_CHELSIO           0x1425
 
@@ -2113,6 +2092,7 @@
 #define PCI_VENDOR_ID_MAINPINE          0x1522
 #define PCI_DEVICE_ID_MAINPINE_PBRIDGE  0x0100
 #define PCI_VENDOR_ID_ENE               0x1524
+#define PCI_DEVICE_ID_ENE_CB710_FLASH   0x0510
 #define PCI_DEVICE_ID_ENE_CB712_SD      0x0550
 #define PCI_DEVICE_ID_ENE_CB712_SD_2    0x0551
 #define PCI_DEVICE_ID_ENE_CB714_SD      0x0750
@@ -2274,6 +2254,8 @@
 #define PCI_DEVICE_ID_MPC8547E          0x0018
 #define PCI_DEVICE_ID_MPC8545E          0x0019
 #define PCI_DEVICE_ID_MPC8545           0x001a
+#define PCI_DEVICE_ID_MPC8569E          0x0061
+#define PCI_DEVICE_ID_MPC8569           0x0060
 #define PCI_DEVICE_ID_MPC8568E          0x0020
 #define PCI_DEVICE_ID_MPC8568           0x0021
 #define PCI_DEVICE_ID_MPC8567E          0x0022
@@ -2286,6 +2268,8 @@
 #define PCI_DEVICE_ID_MPC8572           0x0041
 #define PCI_DEVICE_ID_MPC8536E          0x0050
 #define PCI_DEVICE_ID_MPC8536           0x0051
+#define PCI_DEVICE_ID_P2020E            0x0070
+#define PCI_DEVICE_ID_P2020             0x0071
 #define PCI_DEVICE_ID_MPC8641           0x7010
 #define PCI_DEVICE_ID_MPC8641D          0x7011
 #define PCI_DEVICE_ID_MPC8610           0x7018
@@ -2313,6 +2297,8 @@
 
 #define PCI_VENDOR_ID_QMI               0x1a32
 
+#define PCI_VENDOR_ID_AZWAVE            0x1a3b
+
 #define PCI_VENDOR_ID_TEKRAM            0x1de1
 #define PCI_DEVICE_ID_TEKRAM_DC290      0xdc29
 
@@ -2659,6 +2645,7 @@
 #define PCI_DEVICE_ID_NETMOS_9835       0x9835
 #define PCI_DEVICE_ID_NETMOS_9845       0x9845
 #define PCI_DEVICE_ID_NETMOS_9855       0x9855
+#define PCI_DEVICE_ID_NETMOS_9901       0x9901
 
 #define PCI_VENDOR_ID_3COM_2            0xa727
 
diff --git a/include/linux/pci_regs.h b/include/linux/pci_regs.h
index 616bf8b3c8b5..fcaee42c7ac2 100644
--- a/include/linux/pci_regs.h
+++ b/include/linux/pci_regs.h
@@ -295,8 +295,9 @@
 #define PCI_MSI_ADDRESS_LO      4       /* Lower 32 bits */
 #define PCI_MSI_ADDRESS_HI      8       /* Upper 32 bits (if PCI_MSI_FLAGS_64BIT set) */
 #define PCI_MSI_DATA_32         8       /* 16 bits of data for 32-bit devices */
+#define PCI_MSI_MASK_32         12      /* Mask bits register for 32-bit devices */
 #define PCI_MSI_DATA_64         12      /* 16 bits of data for 64-bit devices */
-#define PCI_MSI_MASK_BIT        16      /* Mask bits register */
+#define PCI_MSI_MASK_64         16      /* Mask bits register for 64-bit devices */
 
 /* MSI-X registers (these are at offset PCI_MSIX_FLAGS) */
 #define PCI_MSIX_FLAGS          2
@@ -304,7 +305,6 @@
 #define  PCI_MSIX_FLAGS_ENABLE  (1 << 15)
 #define  PCI_MSIX_FLAGS_MASKALL (1 << 14)
 #define PCI_MSIX_FLAGS_BIRMASK  (7 << 0)
-#define PCI_MSIX_FLAGS_BITMASK  (1 << 0)
 
 /* CompactPCI Hotswap Register */
 
@@ -502,6 +502,7 @@
 #define PCI_EXT_CAP_ID_DSN      3
 #define PCI_EXT_CAP_ID_PWR      4
 #define PCI_EXT_CAP_ID_ARI      14
+#define PCI_EXT_CAP_ID_ATS      15
 #define PCI_EXT_CAP_ID_SRIOV    16
 
 /* Advanced Error Reporting */
@@ -620,6 +621,15 @@
 #define  PCI_ARI_CTRL_ACS       0x0002  /* ACS Function Groups Enable */
 #define  PCI_ARI_CTRL_FG(x)     (((x) >> 4) & 7) /* Function Group */
 
+/* Address Translation Service */
+#define PCI_ATS_CAP             0x04    /* ATS Capability Register */
+#define  PCI_ATS_CAP_QDEP(x)    ((x) & 0x1f)    /* Invalidate Queue Depth */
+#define  PCI_ATS_MAX_QDEP       32      /* Max Invalidate Queue Depth */
+#define PCI_ATS_CTRL            0x06    /* ATS Control Register */
+#define  PCI_ATS_CTRL_ENABLE    0x8000  /* ATS Enable */
+#define  PCI_ATS_CTRL_STU(x)    ((x) & 0x1f)    /* Smallest Translation Unit */
+#define  PCI_ATS_MIN_STU        12      /* shift of minimum STU block */
+
 /* Single Root I/O Virtualization */
 #define PCI_SRIOV_CAP           0x04    /* SR-IOV Capabilities */
 #define  PCI_SRIOV_CAP_VFM      0x01    /* VF Migration Capable */
diff --git a/include/linux/percpu-defs.h b/include/linux/percpu-defs.h
index 8f921d74f49f..68438e18fff4 100644
--- a/include/linux/percpu-defs.h
+++ b/include/linux/percpu-defs.h
@@ -24,7 +24,8 @@
 
 #define DEFINE_PER_CPU_SECTION(type, name, section)                     \
         __attribute__((__section__(PER_CPU_BASE_SECTION section)))      \
-        PER_CPU_ATTRIBUTES __typeof__(type) per_cpu__##name
+        PER_CPU_ATTRIBUTES PER_CPU_DEF_ATTRIBUTES                       \
+        __typeof__(type) per_cpu__##name
 
 /*
  * Variant on the per-CPU variable declaration/definition theme used for
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index 1581ff235c7e..26fd9d12f050 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -86,7 +86,12 @@ struct percpu_data {
         void *ptrs[1];
 };
 
+/* pointer disguising messes up the kmemleak objects tracking */
+#ifndef CONFIG_DEBUG_KMEMLEAK
 #define __percpu_disguise(pdata) (struct percpu_data *)~(unsigned long)(pdata)
+#else
+#define __percpu_disguise(pdata) (struct percpu_data *)(pdata)
+#endif
 
 #define per_cpu_ptr(ptr, cpu)                                           \
 ({                                                                      \
diff --git a/include/linux/perf_counter.h b/include/linux/perf_counter.h
new file mode 100644
index 000000000000..e604e6ef72dd
--- /dev/null
+++ b/include/linux/perf_counter.h
@@ -0,0 +1,764 @@
+/*
+ *  Performance counters:
+ *
+ *    Copyright (C) 2008-2009, Thomas Gleixner <tglx@linutronix.de>
+ *    Copyright (C) 2008-2009, Red Hat, Inc., Ingo Molnar
+ *    Copyright (C) 2008-2009, Red Hat, Inc., Peter Zijlstra
+ *
+ *  Data type definitions, declarations, prototypes.
+ *
+ *    Started by: Thomas Gleixner and Ingo Molnar
+ *
+ *  For licencing details see kernel-base/COPYING
+ */
+#ifndef _LINUX_PERF_COUNTER_H
+#define _LINUX_PERF_COUNTER_H
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+#include <asm/byteorder.h>
+
+/*
+ * User-space ABI bits:
+ */
+
+/*
+ * attr.type
+ */
+enum perf_type_id {
+        PERF_TYPE_HARDWARE                      = 0,
+        PERF_TYPE_SOFTWARE                      = 1,
+        PERF_TYPE_TRACEPOINT                    = 2,
+        PERF_TYPE_HW_CACHE                      = 3,
+        PERF_TYPE_RAW                           = 4,
+
+        PERF_TYPE_MAX,                          /* non-ABI */
+};
+
+/*
+ * Generalized performance counter event types, used by the
+ * attr.event_id parameter of the sys_perf_counter_open()
+ * syscall:
+ */
+enum perf_hw_id {
+        /*
+         * Common hardware events, generalized by the kernel:
+         */
+        PERF_COUNT_HW_CPU_CYCLES                = 0,
+        PERF_COUNT_HW_INSTRUCTIONS              = 1,
+        PERF_COUNT_HW_CACHE_REFERENCES          = 2,
+        PERF_COUNT_HW_CACHE_MISSES              = 3,
+        PERF_COUNT_HW_BRANCH_INSTRUCTIONS       = 4,
+        PERF_COUNT_HW_BRANCH_MISSES             = 5,
+        PERF_COUNT_HW_BUS_CYCLES                = 6,
+
+        PERF_COUNT_HW_MAX,                      /* non-ABI */
+};
+
+/*
+ * Generalized hardware cache counters:
+ *
+ *       { L1-D, L1-I, LLC, ITLB, DTLB, BPU } x
+ *       { read, write, prefetch } x
+ *       { accesses, misses }
+ */
+enum perf_hw_cache_id {
+        PERF_COUNT_HW_CACHE_L1D                 = 0,
+        PERF_COUNT_HW_CACHE_L1I                 = 1,
+        PERF_COUNT_HW_CACHE_LL                  = 2,
+        PERF_COUNT_HW_CACHE_DTLB                = 3,
+        PERF_COUNT_HW_CACHE_ITLB                = 4,
+        PERF_COUNT_HW_CACHE_BPU                 = 5,
+
+        PERF_COUNT_HW_CACHE_MAX,                /* non-ABI */
+};
+
+enum perf_hw_cache_op_id {
+        PERF_COUNT_HW_CACHE_OP_READ             = 0,
+        PERF_COUNT_HW_CACHE_OP_WRITE            = 1,
+        PERF_COUNT_HW_CACHE_OP_PREFETCH         = 2,
+
+        PERF_COUNT_HW_CACHE_OP_MAX,             /* non-ABI */
+};
+
+enum perf_hw_cache_op_result_id {
+        PERF_COUNT_HW_CACHE_RESULT_ACCESS       = 0,
+        PERF_COUNT_HW_CACHE_RESULT_MISS         = 1,
+
+        PERF_COUNT_HW_CACHE_RESULT_MAX,         /* non-ABI */
+};
+
+/*
+ * Special "software" counters provided by the kernel, even if the hardware
+ * does not support performance counters. These counters measure various
+ * physical and sw events of the kernel (and allow the profiling of them as
+ * well):
+ */
+enum perf_sw_ids {
+        PERF_COUNT_SW_CPU_CLOCK                 = 0,
+        PERF_COUNT_SW_TASK_CLOCK                = 1,
+        PERF_COUNT_SW_PAGE_FAULTS               = 2,
+        PERF_COUNT_SW_CONTEXT_SWITCHES          = 3,
+        PERF_COUNT_SW_CPU_MIGRATIONS            = 4,
+        PERF_COUNT_SW_PAGE_FAULTS_MIN           = 5,
+        PERF_COUNT_SW_PAGE_FAULTS_MAJ           = 6,
+
+        PERF_COUNT_SW_MAX,                      /* non-ABI */
+};
+
+/*
+ * Bits that can be set in attr.sample_type to request information
+ * in the overflow packets.
+ */
+enum perf_counter_sample_format {
+        PERF_SAMPLE_IP                          = 1U << 0,
+        PERF_SAMPLE_TID                         = 1U << 1,
+        PERF_SAMPLE_TIME                        = 1U << 2,
+        PERF_SAMPLE_ADDR                        = 1U << 3,
+        PERF_SAMPLE_GROUP                       = 1U << 4,
+        PERF_SAMPLE_CALLCHAIN                   = 1U << 5,
+        PERF_SAMPLE_ID                          = 1U << 6,
+        PERF_SAMPLE_CPU                         = 1U << 7,
+        PERF_SAMPLE_PERIOD                      = 1U << 8,
+        PERF_SAMPLE_STREAM_ID                   = 1U << 9,
+
+        PERF_SAMPLE_MAX = 1U << 10,             /* non-ABI */
+};
+
+/*
+ * Bits that can be set in attr.read_format to request that
+ * reads on the counter should return the indicated quantities,
+ * in increasing order of bit value, after the counter value.
+ */
+enum perf_counter_read_format {
+        PERF_FORMAT_TOTAL_TIME_ENABLED          = 1U << 0,
+        PERF_FORMAT_TOTAL_TIME_RUNNING          = 1U << 1,
+        PERF_FORMAT_ID                          = 1U << 2,
+
+        PERF_FORMAT_MAX = 1U << 3,              /* non-ABI */
+};
+
+#define PERF_ATTR_SIZE_VER0     64      /* sizeof first published struct */
+
+/*
+ * Hardware event to monitor via a performance monitoring counter:
+ */
+struct perf_counter_attr {
+
+        /*
+         * Major type: hardware/software/tracepoint/etc.
+         */
+        __u32                   type;
+
+        /*
+         * Size of the attr structure, for fwd/bwd compat.
+         */
+        __u32                   size;
+
+        /*
+         * Type specific configuration information.
+         */
+        __u64                   config;
+
+        union {
+                __u64           sample_period;
+                __u64           sample_freq;
+        };
+
+        __u64                   sample_type;
+        __u64                   read_format;
+
+        __u64                   disabled       :  1, /* off by default        */
+                                inherit        :  1, /* children inherit it   */
+                                pinned         :  1, /* must always be on PMU */
+                                exclusive      :  1, /* only group on PMU     */
+                                exclude_user   :  1, /* don't count user      */
+                                exclude_kernel :  1, /* ditto kernel          */
+                                exclude_hv     :  1, /* ditto hypervisor      */
+                                exclude_idle   :  1, /* don't count when idle */
+                                mmap           :  1, /* include mmap data     */
+                                comm           :  1, /* include comm data     */
+                                freq           :  1, /* use freq, not period  */
+                                inherit_stat   :  1, /* per task counts       */
+                                enable_on_exec :  1, /* next exec enables     */
+                                task           :  1, /* trace fork/exit       */
+
+                                __reserved_1   : 50;
+
+        __u32                   wakeup_events;  /* wakeup every n events */
+        __u32                   __reserved_2;
+
+        __u64                   __reserved_3;
+};
+
+/*
+ * Ioctls that can be done on a perf counter fd:
+ */
+#define PERF_COUNTER_IOC_ENABLE         _IO ('$', 0)
+#define PERF_COUNTER_IOC_DISABLE        _IO ('$', 1)
+#define PERF_COUNTER_IOC_REFRESH        _IO ('$', 2)
+#define PERF_COUNTER_IOC_RESET          _IO ('$', 3)
+#define PERF_COUNTER_IOC_PERIOD         _IOW('$', 4, u64)
+
+enum perf_counter_ioc_flags {
+        PERF_IOC_FLAG_GROUP             = 1U << 0,
+};
+
+/*
+ * Structure of the page that can be mapped via mmap
+ */
+struct perf_counter_mmap_page {
+        __u32   version;                /* version number of this structure */
+        __u32   compat_version;         /* lowest version this is compat with */
+
+        /*
+         * Bits needed to read the hw counters in user-space.
+         *
+         *   u32 seq;
+         *   s64 count;
+         *
+         *   do {
+         *     seq = pc->lock;
+         *
+         *     barrier()
+         *     if (pc->index) {
+         *       count = pmc_read(pc->index - 1);
+         *       count += pc->offset;
+         *     } else
+         *       goto regular_read;
+         *
+         *     barrier();
+         *   } while (pc->lock != seq);
+         *
+         * NOTE: for obvious reason this only works on self-monitoring
+         *       processes.
+         */
+        __u32   lock;                   /* seqlock for synchronization */
+        __u32   index;                  /* hardware counter identifier */
+        __s64   offset;                 /* add to hardware counter value */
+        __u64   time_enabled;           /* time counter active */
+        __u64   time_running;           /* time counter on cpu */
+
+                /*
+                 * Hole for extension of the self monitor capabilities
+                 */
+
+        __u64   __reserved[123];        /* align to 1k */
+
+        /*
+         * Control data for the mmap() data buffer.
+         *
+         * User-space reading the @data_head value should issue an rmb(), on
+         * SMP capable platforms, after reading this value -- see
+         * perf_counter_wakeup().
+         *
+         * When the mapping is PROT_WRITE the @data_tail value should be
+         * written by userspace to reflect the last read data. In this case
+         * the kernel will not over-write unread data.
+         */
+        __u64   data_head;              /* head in the data section */
+        __u64   data_tail;              /* user-space written tail */
+};
+
+#define PERF_EVENT_MISC_CPUMODE_MASK            (3 << 0)
+#define PERF_EVENT_MISC_CPUMODE_UNKNOWN         (0 << 0)
+#define PERF_EVENT_MISC_KERNEL                  (1 << 0)
+#define PERF_EVENT_MISC_USER                    (2 << 0)
+#define PERF_EVENT_MISC_HYPERVISOR              (3 << 0)
+
+struct perf_event_header {
+        __u32   type;
+        __u16   misc;
+        __u16   size;
+};
+
+enum perf_event_type {
+
+        /*
+         * The MMAP events record the PROT_EXEC mappings so that we can
+         * correlate userspace IPs to code. They have the following structure:
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u32                             pid, tid;
+         *      u64                             addr;
+         *      u64                             len;
+         *      u64                             pgoff;
+         *      char                            filename[];
+         * };
+         */
+        PERF_EVENT_MMAP                 = 1,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u64                             id;
+         *      u64                             lost;
+         * };
+         */
+        PERF_EVENT_LOST                 = 2,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u32                             pid, tid;
+         *      char                            comm[];
+         * };
+         */
+        PERF_EVENT_COMM                 = 3,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             pid, ppid;
+         *      u32                             tid, ptid;
+         * };
+         */
+        PERF_EVENT_EXIT                 = 4,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u64                             time;
+         *      u64                             id;
+         *      u64                             stream_id;
+         * };
+         */
+        PERF_EVENT_THROTTLE             = 5,
+        PERF_EVENT_UNTHROTTLE           = 6,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             pid, ppid;
+         *      u32                             tid, ptid;
+         * };
+         */
+        PERF_EVENT_FORK                 = 7,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             pid, tid;
+         *      u64                             value;
+         *      { u64           time_enabled;   } && PERF_FORMAT_ENABLED
+         *      { u64           time_running;   } && PERF_FORMAT_RUNNING
+         *      { u64           parent_id;      } && PERF_FORMAT_ID
+         * };
+         */
+        PERF_EVENT_READ                 = 8,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      { u64                   ip;       } && PERF_SAMPLE_IP
+         *      { u32                   pid, tid; } && PERF_SAMPLE_TID
+         *      { u64                   time;     } && PERF_SAMPLE_TIME
+         *      { u64                   addr;     } && PERF_SAMPLE_ADDR
+         *      { u64                   id;       } && PERF_SAMPLE_ID
+         *      { u64                   stream_id;} && PERF_SAMPLE_STREAM_ID
+         *      { u32                   cpu, res; } && PERF_SAMPLE_CPU
+         *      { u64                   period;   } && PERF_SAMPLE_PERIOD
+         *
+         *      { u64                   nr;
+         *        { u64 id, val; }      cnt[nr];  } && PERF_SAMPLE_GROUP
+         *
+         *      { u64                   nr,
+         *        u64                   ips[nr];  } && PERF_SAMPLE_CALLCHAIN
+         * };
+         */
+        PERF_EVENT_SAMPLE               = 9,
+
+        PERF_EVENT_MAX,                 /* non-ABI */
+};
+
+enum perf_callchain_context {
+        PERF_CONTEXT_HV                 = (__u64)-32,
+        PERF_CONTEXT_KERNEL             = (__u64)-128,
+        PERF_CONTEXT_USER               = (__u64)-512,
+
+        PERF_CONTEXT_GUEST              = (__u64)-2048,
+        PERF_CONTEXT_GUEST_KERNEL       = (__u64)-2176,
+        PERF_CONTEXT_GUEST_USER         = (__u64)-2560,
+
+        PERF_CONTEXT_MAX                = (__u64)-4095,
+};
+
+#ifdef __KERNEL__
+/*
+ * Kernel-internal data types and definitions:
+ */
+
+#ifdef CONFIG_PERF_COUNTERS
+# include <asm/perf_counter.h>
+#endif
+
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/rculist.h>
+#include <linux/rcupdate.h>
+#include <linux/spinlock.h>
+#include <linux/hrtimer.h>
+#include <linux/fs.h>
+#include <linux/pid_namespace.h>
+#include <asm/atomic.h>
+
+#define PERF_MAX_STACK_DEPTH            255
+
+struct perf_callchain_entry {
+        __u64                           nr;
+        __u64                           ip[PERF_MAX_STACK_DEPTH];
+};
+
+struct task_struct;
+
+/**
+ * struct hw_perf_counter - performance counter hardware details:
+ */
+struct hw_perf_counter {
+#ifdef CONFIG_PERF_COUNTERS
+        union {
+                struct { /* hardware */
+                        u64             config;
+                        unsigned long   config_base;
+                        unsigned long   counter_base;
+                        int             idx;
+                };
+                union { /* software */
+                        atomic64_t      count;
+                        struct hrtimer  hrtimer;
+                };
+        };
+        atomic64_t                      prev_count;
+        u64                             sample_period;
+        u64                             last_period;
+        atomic64_t                      period_left;
+        u64                             interrupts;
+
+        u64                             freq_count;
+        u64                             freq_interrupts;
+        u64                             freq_stamp;
+#endif
+};
+
+struct perf_counter;
+
+/**
+ * struct pmu - generic performance monitoring unit
+ */
+struct pmu {
+        int (*enable)                   (struct perf_counter *counter);
+        void (*disable)                 (struct perf_counter *counter);
+        void (*read)                    (struct perf_counter *counter);
+        void (*unthrottle)              (struct perf_counter *counter);
+};
+
+/**
+ * enum perf_counter_active_state - the states of a counter
+ */
+enum perf_counter_active_state {
+        PERF_COUNTER_STATE_ERROR        = -2,
+        PERF_COUNTER_STATE_OFF          = -1,
+        PERF_COUNTER_STATE_INACTIVE     =  0,
+        PERF_COUNTER_STATE_ACTIVE       =  1,
+};
+
+struct file;
+
+struct perf_mmap_data {
+        struct rcu_head                 rcu_head;
+        int                             nr_pages;       /* nr of data pages  */
+        int                             writable;       /* are we writable   */
+        int                             nr_locked;      /* nr pages mlocked  */
+
+        atomic_t                        poll;           /* POLL_ for wakeups */
+        atomic_t                        events;         /* event limit       */
+
+        atomic_long_t                   head;           /* write position    */
+        atomic_long_t                   done_head;      /* completed head    */
+
+        atomic_t                        lock;           /* concurrent writes */
+        atomic_t                        wakeup;         /* needs a wakeup    */
+        atomic_t                        lost;           /* nr records lost   */
+
+        struct perf_counter_mmap_page   *user_page;
+        void                            *data_pages[0];
+};
+
+struct perf_pending_entry {
+        struct perf_pending_entry *next;
+        void (*func)(struct perf_pending_entry *);
+};
+
+/**
+ * struct perf_counter - performance counter kernel representation:
+ */
+struct perf_counter {
+#ifdef CONFIG_PERF_COUNTERS
+        struct list_head                list_entry;
+        struct list_head                event_entry;
+        struct list_head                sibling_list;
+        int                             nr_siblings;
+        struct perf_counter             *group_leader;
+        const struct pmu                *pmu;
+
+        enum perf_counter_active_state  state;
+        atomic64_t                      count;
+
+        /*
+         * These are the total time in nanoseconds that the counter
+         * has been enabled (i.e. eligible to run, and the task has
+         * been scheduled in, if this is a per-task counter)
+         * and running (scheduled onto the CPU), respectively.
+         *
+         * They are computed from tstamp_enabled, tstamp_running and
+         * tstamp_stopped when the counter is in INACTIVE or ACTIVE state.
+         */
+        u64                             total_time_enabled;
+        u64                             total_time_running;
+
+        /*
+         * These are timestamps used for computing total_time_enabled
+         * and total_time_running when the counter is in INACTIVE or
+         * ACTIVE state, measured in nanoseconds from an arbitrary point
+         * in time.
+         * tstamp_enabled: the notional time when the counter was enabled
+         * tstamp_running: the notional time when the counter was scheduled on
+         * tstamp_stopped: in INACTIVE state, the notional time when the
+         *      counter was scheduled off.
+         */
+        u64                             tstamp_enabled;
+        u64                             tstamp_running;
+        u64                             tstamp_stopped;
+
+        struct perf_counter_attr        attr;
+        struct hw_perf_counter          hw;
+
+        struct perf_counter_context     *ctx;
+        struct file                     *filp;
+
+        /*
+         * These accumulate total time (in nanoseconds) that children
+         * counters have been enabled and running, respectively.
+         */
+        atomic64_t                      child_total_time_enabled;
+        atomic64_t                      child_total_time_running;
+
+        /*
+         * Protect attach/detach and child_list:
+         */
+        struct mutex                    child_mutex;
+        struct list_head                child_list;
+        struct perf_counter             *parent;
+
+        int                             oncpu;
+        int                             cpu;
+
+        struct list_head                owner_entry;
+        struct task_struct              *owner;
+
+        /* mmap bits */
+        struct mutex                    mmap_mutex;
+        atomic_t                        mmap_count;
+        struct perf_mmap_data           *data;
+
+        /* poll related */
+        wait_queue_head_t               waitq;
+        struct fasync_struct            *fasync;
+
+        /* delayed work for NMIs and such */
+        int                             pending_wakeup;
+        int                             pending_kill;
+        int                             pending_disable;
+        struct perf_pending_entry       pending;
+
+        atomic_t                        event_limit;
+
+        void (*destroy)(struct perf_counter *);
+        struct rcu_head                 rcu_head;
+
+        struct pid_namespace            *ns;
+        u64                             id;
+#endif
+};
+
+/**
+ * struct perf_counter_context - counter context structure
+ *
+ * Used as a container for task counters and CPU counters as well:
+ */
+struct perf_counter_context {
+        /*
+         * Protect the states of the counters in the list,
+         * nr_active, and the list:
+         */
+        spinlock_t                      lock;
+        /*
+         * Protect the list of counters.  Locking either mutex or lock
+         * is sufficient to ensure the list doesn't change; to change
+         * the list you need to lock both the mutex and the spinlock.
+         */
+        struct mutex                    mutex;
+
+        struct list_head                counter_list;
+        struct list_head                event_list;
+        int                             nr_counters;
+        int                             nr_active;
+        int                             is_active;
+        int                             nr_stat;
+        atomic_t                        refcount;
+        struct task_struct              *task;
+
+        /*
+         * Context clock, runs when context enabled.
+         */
+        u64                             time;
+        u64                             timestamp;
+
+        /*
+         * These fields let us detect when two contexts have both
+         * been cloned (inherited) from a common ancestor.
+         */
+        struct perf_counter_context     *parent_ctx;
+        u64                             parent_gen;
+        u64                             generation;
+        int                             pin_count;
+        struct rcu_head                 rcu_head;
+};
+
+/**
+ * struct perf_counter_cpu_context - per cpu counter context structure
+ */
+struct perf_cpu_context {
+        struct perf_counter_context     ctx;
+        struct perf_counter_context     *task_ctx;
+        int                             active_oncpu;
+        int                             max_pertask;
+        int                             exclusive;
+
+        /*
+         * Recursion avoidance:
+         *
+         * task, softirq, irq, nmi context
+         */
+        int                             recursion[4];
+};
+
+#ifdef CONFIG_PERF_COUNTERS
+
+/*
+ * Set by architecture code:
+ */
+extern int perf_max_counters;
+
+extern const struct pmu *hw_perf_counter_init(struct perf_counter *counter);
+
+extern void perf_counter_task_sched_in(struct task_struct *task, int cpu);
+extern void perf_counter_task_sched_out(struct task_struct *task,
+                                        struct task_struct *next, int cpu);
+extern void perf_counter_task_tick(struct task_struct *task, int cpu);
+extern int perf_counter_init_task(struct task_struct *child);
+extern void perf_counter_exit_task(struct task_struct *child);
+extern void perf_counter_free_task(struct task_struct *task);
+extern void set_perf_counter_pending(void);
+extern void perf_counter_do_pending(void);
+extern void perf_counter_print_debug(void);
+extern void __perf_disable(void);
+extern bool __perf_enable(void);
+extern void perf_disable(void);
+extern void perf_enable(void);
+extern int perf_counter_task_disable(void);
+extern int perf_counter_task_enable(void);
+extern int hw_perf_group_sched_in(struct perf_counter *group_leader,
+               struct perf_cpu_context *cpuctx,
+               struct perf_counter_context *ctx, int cpu);
+extern void perf_counter_update_userpage(struct perf_counter *counter);
+
+struct perf_sample_data {
+        struct pt_regs                  *regs;
+        u64                             addr;
+        u64                             period;
+};
+
+extern int perf_counter_overflow(struct perf_counter *counter, int nmi,
+                                 struct perf_sample_data *data);
+
+/*
+ * Return 1 for a software counter, 0 for a hardware counter
+ */
+static inline int is_software_counter(struct perf_counter *counter)
+{
+        return (counter->attr.type != PERF_TYPE_RAW) &&
+                (counter->attr.type != PERF_TYPE_HARDWARE) &&
+                (counter->attr.type != PERF_TYPE_HW_CACHE);
+}
+
+extern atomic_t perf_swcounter_enabled[PERF_COUNT_SW_MAX];
+
+extern void __perf_swcounter_event(u32, u64, int, struct pt_regs *, u64);
+
+static inline void
+perf_swcounter_event(u32 event, u64 nr, int nmi, struct pt_regs *regs, u64 addr)
+{
+        if (atomic_read(&perf_swcounter_enabled[event]))
+                __perf_swcounter_event(event, nr, nmi, regs, addr);
+}
+
+extern void __perf_counter_mmap(struct vm_area_struct *vma);
+
+static inline void perf_counter_mmap(struct vm_area_struct *vma)
+{
+        if (vma->vm_flags & VM_EXEC)
+                __perf_counter_mmap(vma);
+}
+
+extern void perf_counter_comm(struct task_struct *tsk);
+extern void perf_counter_fork(struct task_struct *tsk);
+
+extern struct perf_callchain_entry *perf_callchain(struct pt_regs *regs);
+
+extern int sysctl_perf_counter_paranoid;
+extern int sysctl_perf_counter_mlock;
+extern int sysctl_perf_counter_sample_rate;
+
+extern void perf_counter_init(void);
+
+#ifndef perf_misc_flags
+#define perf_misc_flags(regs)   (user_mode(regs) ? PERF_EVENT_MISC_USER : \
+                                 PERF_EVENT_MISC_KERNEL)
+#define perf_instruction_pointer(regs)  instruction_pointer(regs)
+#endif
+
+#else
+static inline void
+perf_counter_task_sched_in(struct task_struct *task, int cpu)           { }
+static inline void
+perf_counter_task_sched_out(struct task_struct *task,
+                            struct task_struct *next, int cpu)          { }
+static inline void
+perf_counter_task_tick(struct task_struct *task, int cpu)               { }
+static inline int perf_counter_init_task(struct task_struct *child)     { return 0; }
+static inline void perf_counter_exit_task(struct task_struct *child)    { }
+static inline void perf_counter_free_task(struct task_struct *task)     { }
+static inline void perf_counter_do_pending(void)                        { }
+static inline void perf_counter_print_debug(void)                       { }
+static inline void perf_disable(void)                                   { }
+static inline void perf_enable(void)                                    { }
+static inline int perf_counter_task_disable(void)       { return -EINVAL; }
+static inline int perf_counter_task_enable(void)        { return -EINVAL; }
+
+static inline void
+perf_swcounter_event(u32 event, u64 nr, int nmi,
+                     struct pt_regs *regs, u64 addr)                    { }
+
+static inline void perf_counter_mmap(struct vm_area_struct *vma)        { }
+static inline void perf_counter_comm(struct task_struct *tsk)           { }
+static inline void perf_counter_fork(struct task_struct *tsk)           { }
+static inline void perf_counter_init(void)                              { }
+#endif
+
+#endif /* __KERNEL__ */
+#endif /* _LINUX_PERF_COUNTER_H */
diff --git a/include/linux/personality.h b/include/linux/personality.h
index a84e9ff9b27e..126120819a0d 100644
--- a/include/linux/personality.h
+++ b/include/linux/personality.h
@@ -40,7 +40,10 @@ enum {
  * Security-relevant compatibility flags that must be
  * cleared upon setuid or setgid exec:
  */
-#define PER_CLEAR_ON_SETID (READ_IMPLIES_EXEC|ADDR_NO_RANDOMIZE)
+#define PER_CLEAR_ON_SETID (READ_IMPLIES_EXEC  | \
+                            ADDR_NO_RANDOMIZE  | \
+                            ADDR_COMPAT_LAYOUT | \
+                            MMAP_PAGE_ZERO)
 
 /*
  * Personality types.
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 97e40cb6b588..b1368b8f6572 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -79,7 +79,7 @@ typedef enum {
  * Need to be a little smaller than phydev->dev.bus_id to leave room
  * for the ":%02x"
  */
-#define MII_BUS_ID_SIZE (BUS_ID_SIZE - 3)
+#define MII_BUS_ID_SIZE (20 - 3)
 
 /*
  * The Bus class for PHYs.  Devices which provide access to
@@ -407,7 +407,7 @@ struct phy_driver {
 /* A Structure for boards to register fixups with the PHY Lib */
 struct phy_fixup {
         struct list_head list;
-        char bus_id[BUS_ID_SIZE];
+        char bus_id[20];
         u32 phy_uid;
         u32 phy_uid_mask;
         int (*run)(struct phy_device *phydev);
@@ -444,10 +444,16 @@ static inline int phy_write(struct phy_device *phydev, u16 regnum, u16 val)
 
 int get_phy_id(struct mii_bus *bus, int addr, u32 *phy_id);
 struct phy_device* get_phy_device(struct mii_bus *bus, int addr);
+int phy_device_register(struct phy_device *phy);
 int phy_clear_interrupt(struct phy_device *phydev);
 int phy_config_interrupt(struct phy_device *phydev, u32 interrupts);
+int phy_attach_direct(struct net_device *dev, struct phy_device *phydev,
+                u32 flags, phy_interface_t interface);
 struct phy_device * phy_attach(struct net_device *dev,
                 const char *bus_id, u32 flags, phy_interface_t interface);
+int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
+                void (*handler)(struct net_device *), u32 flags,
+                phy_interface_t interface);
 struct phy_device * phy_connect(struct net_device *dev, const char *bus_id,
                 void (*handler)(struct net_device *), u32 flags,
                 phy_interface_t interface);
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index c8f038554e80..b43a9e039059 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -152,5 +152,6 @@ void generic_pipe_buf_unmap(struct pipe_inode_info *, struct pipe_buffer *, void
 void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
+void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
 
 #endif
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index b67bb5d7b221..8dc5123b6305 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -36,8 +36,8 @@ extern struct device platform_bus;
 
 extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
 extern int platform_get_irq(struct platform_device *, unsigned int);
-extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, char *);
-extern int platform_get_irq_byname(struct platform_device *, char *);
+extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, const char *);
+extern int platform_get_irq_byname(struct platform_device *, const char *);
 extern int platform_add_devices(struct platform_device **, int);
 
 extern struct platform_device *platform_device_register_simple(const char *, int id,
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 1d4e2d289821..b3f74764a586 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -382,14 +382,13 @@ struct dev_pm_info {
 #ifdef CONFIG_PM_SLEEP
 extern void device_pm_lock(void);
 extern int sysdev_resume(void);
-extern void device_power_up(pm_message_t state);
-extern void device_resume(pm_message_t state);
+extern void dpm_resume_noirq(pm_message_t state);
+extern void dpm_resume_end(pm_message_t state);
 
 extern void device_pm_unlock(void);
 extern int sysdev_suspend(pm_message_t state);
-extern int device_power_down(pm_message_t state);
-extern int device_suspend(pm_message_t state);
-extern int device_prepare_suspend(pm_message_t state);
+extern int dpm_suspend_noirq(pm_message_t state);
+extern int dpm_suspend_start(pm_message_t state);
 
 extern void __suspend_report_result(const char *function, void *fn, int ret);
 
@@ -403,7 +402,7 @@ extern void __suspend_report_result(const char *function, void *fn, int ret);
 #define device_pm_lock() do {} while (0)
 #define device_pm_unlock() do {} while (0)
 
-static inline int device_suspend(pm_message_t state)
+static inline int dpm_suspend_start(pm_message_t state)
 {
         return 0;
 }
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
index ca3c88773028..b063c7328ba5 100644
--- a/include/linux/pnp.h
+++ b/include/linux/pnp.h
@@ -446,6 +446,7 @@ int pnp_start_dev(struct pnp_dev *dev);
 int pnp_stop_dev(struct pnp_dev *dev);
 int pnp_activate_dev(struct pnp_dev *dev);
 int pnp_disable_dev(struct pnp_dev *dev);
+int pnp_range_reserved(resource_size_t start, resource_size_t end);
 
 /* protocol helpers */
 int pnp_is_active(struct pnp_dev *dev);
@@ -476,6 +477,7 @@ static inline int pnp_start_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_stop_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; }
 static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; }
+static inline int pnp_range_reserved(resource_size_t start, resource_size_t end) { return 0;}
 
 /* protocol helpers */
 static inline int pnp_is_active(struct pnp_dev *dev) { return 0; }
diff --git a/include/linux/poll.h b/include/linux/poll.h
index 8c24ef8d9976..fa287f25138d 100644
--- a/include/linux/poll.h
+++ b/include/linux/poll.h
@@ -32,6 +32,7 @@ typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_
 
 typedef struct poll_table_struct {
         poll_queue_proc qproc;
+        unsigned long key;
 } poll_table;
 
 static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
@@ -43,10 +44,12 @@ static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_addres
 static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
 {
         pt->qproc = qproc;
+        pt->key   = ~0UL; /* all events enabled */
 }
 
 struct poll_table_entry {
         struct file *filp;
+        unsigned long key;
         wait_queue_t wait;
         wait_queue_head_t *wait_address;
 };
diff --git a/include/linux/posix_acl.h b/include/linux/posix_acl.h
index 4bc241290c24..065a3652a3ea 100644
--- a/include/linux/posix_acl.h
+++ b/include/linux/posix_acl.h
@@ -83,4 +83,78 @@ extern int posix_acl_chmod_masq(struct posix_acl *, mode_t);
 extern struct posix_acl *get_posix_acl(struct inode *, int);
 extern int set_posix_acl(struct inode *, int, struct posix_acl *);
 
+#ifdef CONFIG_FS_POSIX_ACL
+static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
+{
+        struct posix_acl **p, *acl;
+        switch (type) {
+        case ACL_TYPE_ACCESS:
+                p = &inode->i_acl;
+                break;
+        case ACL_TYPE_DEFAULT:
+                p = &inode->i_default_acl;
+                break;
+        default:
+                return ERR_PTR(-EINVAL);
+        }
+        acl = ACCESS_ONCE(*p);
+        if (acl) {
+                spin_lock(&inode->i_lock);
+                acl = *p;
+                if (acl != ACL_NOT_CACHED)
+                        acl = posix_acl_dup(acl);
+                spin_unlock(&inode->i_lock);
+        }
+        return acl;
+}
+
+static inline void set_cached_acl(struct inode *inode,
+                                  int type,
+                                  struct posix_acl *acl)
+{
+        struct posix_acl *old = NULL;
+        spin_lock(&inode->i_lock);
+        switch (type) {
+        case ACL_TYPE_ACCESS:
+                old = inode->i_acl;
+                inode->i_acl = posix_acl_dup(acl);
+                break;
+        case ACL_TYPE_DEFAULT:
+                old = inode->i_default_acl;
+                inode->i_default_acl = posix_acl_dup(acl);
+                break;
+        }
+        spin_unlock(&inode->i_lock);
+        if (old != ACL_NOT_CACHED)
+                posix_acl_release(old);
+}
+
+static inline void forget_cached_acl(struct inode *inode, int type)
+{
+        struct posix_acl *old = NULL;
+        spin_lock(&inode->i_lock);
+        switch (type) {
+        case ACL_TYPE_ACCESS:
+                old = inode->i_acl;
+                inode->i_acl = ACL_NOT_CACHED;
+                break;
+        case ACL_TYPE_DEFAULT:
+                old = inode->i_default_acl;
+                inode->i_default_acl = ACL_NOT_CACHED;
+                break;
+        }
+        spin_unlock(&inode->i_lock);
+        if (old != ACL_NOT_CACHED)
+                posix_acl_release(old);
+}
+#endif
+
+static inline void cache_no_acl(struct inode *inode)
+{
+#ifdef CONFIG_FS_POSIX_ACL
+        inode->i_acl = NULL;
+        inode->i_default_acl = NULL;
+#endif
+}
+
 #endif  /* __LINUX_POSIX_ACL_H */
diff --git a/include/linux/pps.h b/include/linux/pps.h
new file mode 100644
index 000000000000..0194ab06177b
--- /dev/null
+++ b/include/linux/pps.h
@@ -0,0 +1,124 @@
+/*
+ * PPS API header
+ *
+ * Copyright (C) 2005-2009   Rodolfo Giometti <giometti@linux.it>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef _PPS_H_
+#define _PPS_H_
+
+#include <linux/types.h>
+
+#define PPS_VERSION             "5.3.6"
+#define PPS_MAX_SOURCES         16              /* should be enough... */
+
+/* Implementation note: the logical states ``assert'' and ``clear''
+ * are implemented in terms of the chip register, i.e. ``assert''
+ * means the bit is set.  */
+
+/*
+ * 3.2 New data structures
+ */
+
+#define PPS_API_VERS_1          1
+#define PPS_API_VERS            PPS_API_VERS_1  /* we use API version 1 */
+#define PPS_MAX_NAME_LEN        32
+
+/* 32-bit vs. 64-bit compatibility.
+ *
+ * 0n i386, the alignment of a uint64_t is only 4 bytes, while on most other
+ * architectures it's 8 bytes. On i386, there will be no padding between the
+ * two consecutive 'struct pps_ktime' members of struct pps_kinfo and struct
+ * pps_kparams. But on most platforms there will be padding to ensure correct
+ * alignment.
+ *
+ * The simple fix is probably to add an explicit padding.
+ *                                                      [David Woodhouse]
+ */
+struct pps_ktime {
+        __s64 sec;
+        __s32 nsec;
+        __u32 flags;
+};
+#define PPS_TIME_INVALID        (1<<0)  /* used to specify timeout==NULL */
+
+struct pps_kinfo {
+        __u32 assert_sequence;          /* seq. num. of assert event */
+        __u32 clear_sequence;           /* seq. num. of clear event */
+        struct pps_ktime assert_tu;     /* time of assert event */
+        struct pps_ktime clear_tu;      /* time of clear event */
+        int current_mode;               /* current mode bits */
+};
+
+struct pps_kparams {
+        int api_version;                /* API version # */
+        int mode;                       /* mode bits */
+        struct pps_ktime assert_off_tu; /* offset compensation for assert */
+        struct pps_ktime clear_off_tu;  /* offset compensation for clear */
+};
+
+/*
+ * 3.3 Mode bit definitions
+ */
+
+/* Device/implementation parameters */
+#define PPS_CAPTUREASSERT       0x01    /* capture assert events */
+#define PPS_CAPTURECLEAR        0x02    /* capture clear events */
+#define PPS_CAPTUREBOTH         0x03    /* capture assert and clear events */
+
+#define PPS_OFFSETASSERT        0x10    /* apply compensation for assert ev. */
+#define PPS_OFFSETCLEAR         0x20    /* apply compensation for clear ev. */
+
+#define PPS_CANWAIT             0x100   /* can we wait for an event? */
+#define PPS_CANPOLL             0x200   /* bit reserved for future use */
+
+/* Kernel actions */
+#define PPS_ECHOASSERT          0x40    /* feed back assert event to output */
+#define PPS_ECHOCLEAR           0x80    /* feed back clear event to output */
+
+/* Timestamp formats */
+#define PPS_TSFMT_TSPEC         0x1000  /* select timespec format */
+#define PPS_TSFMT_NTPFP         0x2000  /* select NTP format */
+
+/*
+ * 3.4.4 New functions: disciplining the kernel timebase
+ */
+
+/* Kernel consumers */
+#define PPS_KC_HARDPPS          0       /* hardpps() (or equivalent) */
+#define PPS_KC_HARDPPS_PLL      1       /* hardpps() constrained to
+                                           use a phase-locked loop */
+#define PPS_KC_HARDPPS_FLL      2       /* hardpps() constrained to
+                                           use a frequency-locked loop */
+/*
+ * Here begins the implementation-specific part!
+ */
+
+struct pps_fdata {
+        struct pps_kinfo info;
+        struct pps_ktime timeout;
+};
+
+#include <linux/ioctl.h>
+
+#define PPS_GETPARAMS           _IOR('p', 0xa1, struct pps_kparams *)
+#define PPS_SETPARAMS           _IOW('p', 0xa2, struct pps_kparams *)
+#define PPS_GETCAP              _IOR('p', 0xa3, int *)
+#define PPS_FETCH               _IOWR('p', 0xa4, struct pps_fdata *)
+
+#endif /* _PPS_H_ */
diff --git a/include/linux/pps_kernel.h b/include/linux/pps_kernel.h
new file mode 100644
index 000000000000..e0a193f830ef
--- /dev/null
+++ b/include/linux/pps_kernel.h
@@ -0,0 +1,89 @@
+/*
+ * PPS API kernel header
+ *
+ * Copyright (C) 2009   Rodolfo Giometti <giometti@linux.it>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/pps.h>
+
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/time.h>
+
+/*
+ * Global defines
+ */
+
+/* The specific PPS source info */
+struct pps_source_info {
+        char name[PPS_MAX_NAME_LEN];            /* simbolic name */
+        char path[PPS_MAX_NAME_LEN];            /* path of connected device */
+        int mode;                               /* PPS's allowed mode */
+
+        void (*echo)(int source, int event, void *data); /* PPS echo function */
+
+        struct module *owner;
+        struct device *dev;
+};
+
+/* The main struct */
+struct pps_device {
+        struct pps_source_info info;            /* PSS source info */
+
+        struct pps_kparams params;              /* PPS's current params */
+
+        __u32 assert_sequence;                  /* PPS' assert event seq # */
+        __u32 clear_sequence;                   /* PPS' clear event seq # */
+        struct pps_ktime assert_tu;
+        struct pps_ktime clear_tu;
+        int current_mode;                       /* PPS mode at event time */
+
+        int go;                                 /* PPS event is arrived? */
+        wait_queue_head_t queue;                /* PPS event queue */
+
+        unsigned int id;                        /* PPS source unique ID */
+        struct cdev cdev;
+        struct device *dev;
+        int devno;
+        struct fasync_struct *async_queue;      /* fasync method */
+        spinlock_t lock;
+
+        atomic_t usage;                         /* usage count */
+};
+
+/*
+ * Global variables
+ */
+
+extern spinlock_t pps_idr_lock;
+extern struct idr pps_idr;
+extern struct timespec pps_irq_ts[];
+
+extern struct device_attribute pps_attrs[];
+
+/*
+ * Exported functions
+ */
+
+struct pps_device *pps_get_source(int source);
+extern void pps_put_source(struct pps_device *pps);
+extern int pps_register_source(struct pps_source_info *info,
+                                int default_params);
+extern void pps_unregister_source(int source);
+extern int pps_register_cdev(struct pps_device *pps);
+extern void pps_unregister_cdev(struct pps_device *pps);
+extern void pps_event(int source, struct pps_ktime *ts, int event, void *data);
diff --git a/include/linux/prctl.h b/include/linux/prctl.h
index 48d887e3c6e7..b00df4c79c63 100644
--- a/include/linux/prctl.h
+++ b/include/linux/prctl.h
@@ -85,4 +85,7 @@
 #define PR_SET_TIMERSLACK 29
 #define PR_GET_TIMERSLACK 30
 
+#define PR_TASK_PERF_COUNTERS_DISABLE           31
+#define PR_TASK_PERF_COUNTERS_ENABLE            32
+
 #endif /* _LINUX_PRCTL_H */
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index fbfa3d44d33d..e6e77d31c418 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -93,20 +93,9 @@ struct vmcore {
 
 #ifdef CONFIG_PROC_FS
 
-extern spinlock_t proc_subdir_lock;
-
 extern void proc_root_init(void);
 
 void proc_flush_task(struct task_struct *task);
-struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *);
-int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir);
-unsigned long task_vsize(struct mm_struct *);
-int task_statm(struct mm_struct *, int *, int *, int *, int *);
-void task_mem(struct seq_file *, struct mm_struct *);
-void clear_refs_smap(struct mm_struct *mm);
-
-struct proc_dir_entry *de_get(struct proc_dir_entry *de);
-void de_put(struct proc_dir_entry *de);
 
 extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
                                                 struct proc_dir_entry *parent);
@@ -116,20 +105,7 @@ struct proc_dir_entry *proc_create_data(const char *name, mode_t mode,
                                 void *data);
 extern void remove_proc_entry(const char *name, struct proc_dir_entry *parent);
 
-extern struct vfsmount *proc_mnt;
 struct pid_namespace;
-extern int proc_fill_super(struct super_block *);
-extern struct inode *proc_get_inode(struct super_block *, unsigned int, struct proc_dir_entry *);
-
-/*
- * These are generic /proc routines that use the internal
- * "struct proc_dir_entry" tree to traverse the filesystem.
- *
- * The /proc root directory has extended versions to take care
- * of the /proc/<pid> subdirectories.
- */
-extern int proc_readdir(struct file *, void *, filldir_t);
-extern struct dentry *proc_lookup(struct inode *, struct dentry *, struct nameidata *);
 
 extern int pid_ns_prepare_proc(struct pid_namespace *ns);
 extern void pid_ns_release_proc(struct pid_namespace *ns);
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 67c15653fc23..7456d7d87a19 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -81,7 +81,6 @@
 
 
 extern long arch_ptrace(struct task_struct *child, long request, long addr, long data);
-extern struct task_struct *ptrace_get_task_struct(pid_t pid);
 extern int ptrace_traceme(void);
 extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len);
 extern int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len);
@@ -95,7 +94,6 @@ extern void __ptrace_link(struct task_struct *child,
                           struct task_struct *new_parent);
 extern void __ptrace_unlink(struct task_struct *child);
 extern void exit_ptrace(struct task_struct *tracer);
-extern void ptrace_fork(struct task_struct *task, unsigned long clone_flags);
 #define PTRACE_MODE_READ   1
 #define PTRACE_MODE_ATTACH 2
 /* Returns 0 on success, -errno on denial. */
@@ -327,15 +325,6 @@ static inline void user_enable_block_step(struct task_struct *task)
 #define arch_ptrace_untrace(task)               do { } while (0)
 #endif
 
-#ifndef arch_ptrace_fork
-/*
- * Do machine-specific work to initialize a new task.
- *
- * This is called from copy_process().
- */
-#define arch_ptrace_fork(child, clone_flags)    do { } while (0)
-#endif
-
 extern int task_current_syscall(struct task_struct *target, long *callno,
                                 unsigned long args[6], unsigned int maxargs,
                                 unsigned long *sp, unsigned long *pc);
diff --git a/include/linux/qnx4_fs.h b/include/linux/qnx4_fs.h
index 787d19ea9f46..8b9aee1a9ce3 100644
--- a/include/linux/qnx4_fs.h
+++ b/include/linux/qnx4_fs.h
@@ -85,65 +85,4 @@ struct qnx4_super_block {
         struct qnx4_inode_entry AltBoot;
 };
 
-#ifdef __KERNEL__
-
-#define QNX4_DEBUG 0
-
-#if QNX4_DEBUG
-#define QNX4DEBUG(X) printk X
-#else
-#define QNX4DEBUG(X) (void) 0
-#endif
-
-struct qnx4_sb_info {
-        struct buffer_head      *sb_buf;        /* superblock buffer */
-        struct qnx4_super_block *sb;            /* our superblock */
-        unsigned int            Version;        /* may be useful */
-        struct qnx4_inode_entry *BitMap;        /* useful */
-};
-
-struct qnx4_inode_info {
-        struct qnx4_inode_entry raw;
-        loff_t mmu_private;
-        struct inode vfs_inode;
-};
-
-extern struct inode *qnx4_iget(struct super_block *, unsigned long);
-extern struct dentry *qnx4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd);
-extern unsigned long qnx4_count_free_blocks(struct super_block *sb);
-extern unsigned long qnx4_block_map(struct inode *inode, long iblock);
-
-extern struct buffer_head *qnx4_bread(struct inode *, int, int);
-
-extern const struct inode_operations qnx4_file_inode_operations;
-extern const struct inode_operations qnx4_dir_inode_operations;
-extern const struct file_operations qnx4_file_operations;
-extern const struct file_operations qnx4_dir_operations;
-extern int qnx4_is_free(struct super_block *sb, long block);
-extern int qnx4_set_bitmap(struct super_block *sb, long block, int busy);
-extern int qnx4_create(struct inode *inode, struct dentry *dentry, int mode, struct nameidata *nd);
-extern void qnx4_truncate(struct inode *inode);
-extern void qnx4_free_inode(struct inode *inode);
-extern int qnx4_unlink(struct inode *dir, struct dentry *dentry);
-extern int qnx4_rmdir(struct inode *dir, struct dentry *dentry);
-extern int qnx4_sync_file(struct file *file, struct dentry *dentry, int);
-extern int qnx4_sync_inode(struct inode *inode);
-
-static inline struct qnx4_sb_info *qnx4_sb(struct super_block *sb)
-{
-        return sb->s_fs_info;
-}
-
-static inline struct qnx4_inode_info *qnx4_i(struct inode *inode)
-{
-        return container_of(inode, struct qnx4_inode_info, vfs_inode);
-}
-
-static inline struct qnx4_inode_entry *qnx4_raw_inode(struct inode *inode)
-{
-        return &qnx4_i(inode)->raw;
-}
-
-#endif                          /* __KERNEL__ */
-
 #endif
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index 36353d95c8db..26361c4c037a 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -7,7 +7,6 @@
 #ifndef _LINUX_QUOTAOPS_
 #define _LINUX_QUOTAOPS_
 
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 
 static inline struct quota_info *sb_dqopt(struct super_block *sb)
@@ -20,7 +19,12 @@ static inline struct quota_info *sb_dqopt(struct super_block *sb)
 /*
  * declaration of quota_function calls in kernel.
  */
-void sync_dquots(struct super_block *sb, int type);
+void sync_quota_sb(struct super_block *sb, int type);
+static inline void writeout_quota_sb(struct super_block *sb, int type)
+{
+        if (sb->s_qcop->quota_sync)
+                sb->s_qcop->quota_sync(sb, type);
+}
 
 int dquot_initialize(struct inode *inode, int type);
 int dquot_drop(struct inode *inode);
@@ -253,12 +257,7 @@ static inline void vfs_dq_free_inode(struct inode *inode)
                 inode->i_sb->dq_op->free_inode(inode, 1);
 }
 
-/* The following two functions cannot be called inside a transaction */
-static inline void vfs_dq_sync(struct super_block *sb)
-{
-        sync_dquots(sb, -1);
-}
-
+/* Cannot be called inside a transaction */
 static inline int vfs_dq_off(struct super_block *sb, int remount)
 {
         int ret = -ENOSYS;
@@ -334,7 +333,11 @@ static inline void vfs_dq_free_inode(struct inode *inode)
 {
 }
 
-static inline void vfs_dq_sync(struct super_block *sb)
+static inline void sync_quota_sb(struct super_block *sb, int type)
+{
+}
+
+static inline void writeout_quota_sb(struct super_block *sb, int type)
 {
 }
 
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 355f6e80db0d..c5da74918096 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -167,6 +167,8 @@ radix_tree_gang_lookup_slot(struct radix_tree_root *root, void ***results,
                         unsigned long first_index, unsigned int max_items);
 unsigned long radix_tree_next_hole(struct radix_tree_root *root,
                                 unsigned long index, unsigned long max_scan);
+unsigned long radix_tree_prev_hole(struct radix_tree_root *root,
+                                unsigned long index, unsigned long max_scan);
 int radix_tree_preload(gfp_t gfp_mask);
 void radix_tree_init(void);
 void *radix_tree_tag_set(struct radix_tree_root *root,
diff --git a/include/linux/raid/md_p.h b/include/linux/raid/md_p.h
index 6ba830fa8538..ffa2efbbe382 100644
--- a/include/linux/raid/md_p.h
+++ b/include/linux/raid/md_p.h
@@ -232,7 +232,7 @@ struct mdp_superblock_1 {
         __le64  reshape_position;       /* next address in array-space for reshape */
         __le32  delta_disks;    /* change in number of raid_disks               */
         __le32  new_layout;     /* new layout                                   */
-        __le32  new_chunk;      /* new chunk size (bytes)                       */
+        __le32  new_chunk;      /* new chunk size (512byte sectors)             */
         __u8    pad1[128-124];  /* set to 0 when written */
 
         /* constant this-device information - 64 bytes */
diff --git a/include/linux/rational.h b/include/linux/rational.h
new file mode 100644
index 000000000000..4f532fcd9eea
--- /dev/null
+++ b/include/linux/rational.h
@@ -0,0 +1,19 @@
+/*
+ * rational fractions
+ *
+ * Copyright (C) 2009 emlix GmbH, Oskar Schirmer <os@emlix.com>
+ *
+ * helper functions when coping with rational numbers,
+ * e.g. when calculating optimum numerator/denominator pairs for
+ * pll configuration taking into account restricted register size
+ */
+
+#ifndef _LINUX_RATIONAL_H
+#define _LINUX_RATIONAL_H
+
+void rational_best_approximation(
+        unsigned long given_numerator, unsigned long given_denominator,
+        unsigned long max_numerator, unsigned long max_denominator,
+        unsigned long *best_numerator, unsigned long *best_denominator);
+
+#endif /* _LINUX_RATIONAL_H */
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index e649bd3f2c97..5710f43bbc9e 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -198,6 +198,32 @@ static inline void list_splice_init_rcu(struct list_head *list,
         at->prev = last;
 }
 
+/**
+ * list_entry_rcu - get the struct for this entry
+ * @ptr:        the &struct list_head pointer.
+ * @type:       the type of the struct this is embedded in.
+ * @member:     the name of the list_struct within the struct.
+ *
+ * This primitive may safely run concurrently with the _rcu list-mutation
+ * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
+ */
+#define list_entry_rcu(ptr, type, member) \
+        container_of(rcu_dereference(ptr), type, member)
+
+/**
+ * list_first_entry_rcu - 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 list is expected to be not empty.
+ *
+ * This primitive may safely run concurrently with the _rcu list-mutation
+ * primitives such as list_add_rcu() as long as it's guarded by rcu_read_lock().
+ */
+#define list_first_entry_rcu(ptr, type, member) \
+        list_entry_rcu((ptr)->next, type, member)
+
 #define __list_for_each_rcu(pos, head) \
         for (pos = rcu_dereference((head)->next); \
                 pos != (head); \
@@ -214,9 +240,9 @@ static inline void list_splice_init_rcu(struct list_head *list,
  * as long as the traversal is guarded by rcu_read_lock().
  */
 #define list_for_each_entry_rcu(pos, head, member) \
-        for (pos = list_entry(rcu_dereference((head)->next), typeof(*pos), member); \
+        for (pos = list_entry_rcu((head)->next, typeof(*pos), member); \
                 prefetch(pos->member.next), &pos->member != (head); \
-                pos = list_entry(rcu_dereference(pos->member.next), typeof(*pos), member))
+                pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
 
 
 /**
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 58b2aa5312b9..5a5153806c42 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -161,8 +161,15 @@ struct rcu_data {
         unsigned long offline_fqs;      /* Kicked due to being offline. */
         unsigned long resched_ipi;      /* Sent a resched IPI. */
 
-        /* 5) For future __rcu_pending statistics. */
+        /* 5) __rcu_pending() statistics. */
         long n_rcu_pending;             /* rcu_pending() calls since boot. */
+        long n_rp_qs_pending;
+        long n_rp_cb_ready;
+        long n_rp_cpu_needs_gp;
+        long n_rp_gp_completed;
+        long n_rp_gp_started;
+        long n_rp_need_fqs;
+        long n_rp_need_nothing;
 
         int cpu;
 };
diff --git a/include/linux/regulator/lp3971.h b/include/linux/regulator/lp3971.h
new file mode 100644
index 000000000000..61401649fe7d
--- /dev/null
+++ b/include/linux/regulator/lp3971.h
@@ -0,0 +1,51 @@
+/*
+ * National Semiconductors LP3971 PMIC chip client interface
+ *
+ *  Copyright (C) 2009 Samsung Electronics
+ *  Author: Marek Szyprowski <m.szyprowski@samsung.com>
+ *
+ * Based on wm8400.h
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LINUX_REGULATOR_LP3971_H
+#define __LINUX_REGULATOR_LP3971_H
+
+#include <linux/regulator/machine.h>
+
+#define LP3971_LDO1  0
+#define LP3971_LDO2  1
+#define LP3971_LDO3  2
+#define LP3971_LDO4  3
+#define LP3971_LDO5  4
+
+#define LP3971_DCDC1 5
+#define LP3971_DCDC2 6
+#define LP3971_DCDC3 7
+
+#define LP3971_NUM_REGULATORS 8
+
+struct lp3971_regulator_subdev {
+        int id;
+        struct regulator_init_data *initdata;
+};
+
+struct lp3971_platform_data {
+        int num_regulators;
+        struct lp3971_regulator_subdev *regulators;
+};
+
+#endif
diff --git a/include/linux/regulator/max1586.h b/include/linux/regulator/max1586.h
new file mode 100644
index 000000000000..44563192bf16
--- /dev/null
+++ b/include/linux/regulator/max1586.h
@@ -0,0 +1,63 @@
+/*
+ * max1586.h  --  Voltage regulation for the Maxim 1586
+ *
+ * Copyright (C) 2008 Robert Jarzmik
+ *
+ * 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 REGULATOR_MAX1586
+#define REGULATOR_MAX1586
+
+#include <linux/regulator/machine.h>
+
+#define MAX1586_V3 0
+#define MAX1586_V6 1
+
+/* precalculated values for v3_gain */
+#define MAX1586_GAIN_NO_R24   1000000  /* 700000 .. 1475000 mV */
+#define MAX1586_GAIN_R24_3k32 1051098  /* 735768 .. 1550369 mV */
+#define MAX1586_GAIN_R24_5k11 1078648  /* 755053 .. 1591005 mV */
+#define MAX1586_GAIN_R24_7k5  1115432  /* 780802 .. 1645262 mV */
+
+/**
+ * max1586_subdev_data - regulator data
+ * @id: regulator Id (either MAX1586_V3 or MAX1586_V6)
+ * @name: regulator cute name (example for V3: "vcc_core")
+ * @platform_data: regulator init data (contraints, supplies, ...)
+ */
+struct max1586_subdev_data {
+        int                             id;
+        char                            *name;
+        struct regulator_init_data      *platform_data;
+};
+
+/**
+ * max1586_platform_data - platform data for max1586
+ * @num_subdevs: number of regultors used (may be 1 or 2)
+ * @subdevs: regulator used
+ *           At most, there will be a regulator for V3 and one for V6 voltages.
+ * @v3_gain: gain on the V3 voltage output multiplied by 1e6.
+ *           This can be calculated as ((1 + R24/R25 + R24/185.5kOhm) * 1e6)
+ *           for an external resistor configuration as described in the
+ *           data sheet (R25=100kOhm).
+ */
+struct max1586_platform_data {
+        int num_subdevs;
+        struct max1586_subdev_data *subdevs;
+        int v3_gain;
+};
+
+#endif
diff --git a/include/linux/regulator/userspace-consumer.h b/include/linux/regulator/userspace-consumer.h
new file mode 100644
index 000000000000..b4554ce9d4bb
--- /dev/null
+++ b/include/linux/regulator/userspace-consumer.h
@@ -0,0 +1,25 @@
+#ifndef __REGULATOR_PLATFORM_CONSUMER_H_
+#define __REGULATOR_PLATFORM_CONSUMER_H_
+
+struct regulator_consumer_supply;
+
+/**
+ * struct regulator_userspace_consumer_data - line consumer
+ * initialisation data.
+ *
+ * @name: Name for the consumer line
+ * @num_supplies: Number of supplies feeding the line
+ * @supplies: Supplies configuration.
+ * @init_on: Set if the regulators supplying the line should be
+ *           enabled during initialisation
+ */
+struct regulator_userspace_consumer_data {
+        const char *name;
+
+        int num_supplies;
+        struct regulator_bulk_data *supplies;
+
+        bool init_on;
+};
+
+#endif /* __REGULATOR_PLATFORM_CONSUMER_H_ */
diff --git a/include/linux/reiserfs_acl.h b/include/linux/reiserfs_acl.h
index 8cc65757e47a..b4448853900e 100644
--- a/include/linux/reiserfs_acl.h
+++ b/include/linux/reiserfs_acl.h
@@ -56,15 +56,6 @@ int reiserfs_cache_default_acl(struct inode *dir);
 extern struct xattr_handler reiserfs_posix_acl_default_handler;
 extern struct xattr_handler reiserfs_posix_acl_access_handler;
 
-static inline void reiserfs_init_acl_access(struct inode *inode)
-{
-        REISERFS_I(inode)->i_acl_access = NULL;
-}
-
-static inline void reiserfs_init_acl_default(struct inode *inode)
-{
-        REISERFS_I(inode)->i_acl_default = NULL;
-}
 #else
 
 #define reiserfs_cache_default_acl(inode) 0
@@ -86,12 +77,4 @@ reiserfs_inherit_default_acl(struct reiserfs_transaction_handle *th,
 {
         return 0;
 }
-
-static inline void reiserfs_init_acl_access(struct inode *inode)
-{
-}
-
-static inline void reiserfs_init_acl_default(struct inode *inode)
-{
-}
 #endif
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index 2245c78d5876..dd31e7bae35c 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -660,23 +660,54 @@ static inline void set_le_key_k_type(int version, struct reiserfs_key *key,
                    cpu_to_le32(type2uniqueness(type)))
             : (void)(set_offset_v2_k_type(&(key->u.k_offset_v2), type));
 }
+
 static inline void set_le_ih_k_type(struct item_head *ih, int type)
 {
         set_le_key_k_type(ih_version(ih), &(ih->ih_key), type);
 }
 
-#define is_direntry_le_key(version,key) (le_key_k_type (version, key) == TYPE_DIRENTRY)
-#define is_direct_le_key(version,key) (le_key_k_type (version, key) == TYPE_DIRECT)
-#define is_indirect_le_key(version,key) (le_key_k_type (version, key) == TYPE_INDIRECT)
-#define is_statdata_le_key(version,key) (le_key_k_type (version, key) == TYPE_STAT_DATA)
+static inline int is_direntry_le_key(int version, struct reiserfs_key *key)
+{
+        return le_key_k_type(version, key) == TYPE_DIRENTRY;
+}
+
+static inline int is_direct_le_key(int version, struct reiserfs_key *key)
+{
+        return le_key_k_type(version, key) == TYPE_DIRECT;
+}
+
+static inline int is_indirect_le_key(int version, struct reiserfs_key *key)
+{
+        return le_key_k_type(version, key) == TYPE_INDIRECT;
+}
+
+static inline int is_statdata_le_key(int version, struct reiserfs_key *key)
+{
+        return le_key_k_type(version, key) == TYPE_STAT_DATA;
+}
 
 //
 // item header has version.
 //
-#define is_direntry_le_ih(ih) is_direntry_le_key (ih_version (ih), &((ih)->ih_key))
-#define is_direct_le_ih(ih) is_direct_le_key (ih_version (ih), &((ih)->ih_key))
-#define is_indirect_le_ih(ih) is_indirect_le_key (ih_version(ih), &((ih)->ih_key))
-#define is_statdata_le_ih(ih) is_statdata_le_key (ih_version (ih), &((ih)->ih_key))
+static inline int is_direntry_le_ih(struct item_head *ih)
+{
+        return is_direntry_le_key(ih_version(ih), &ih->ih_key);
+}
+
+static inline int is_direct_le_ih(struct item_head *ih)
+{
+        return is_direct_le_key(ih_version(ih), &ih->ih_key);
+}
+
+static inline int is_indirect_le_ih(struct item_head *ih)
+{
+        return is_indirect_le_key(ih_version(ih), &ih->ih_key);
+}
+
+static inline int is_statdata_le_ih(struct item_head *ih)
+{
+        return is_statdata_le_key(ih_version(ih), &ih->ih_key);
+}
 
 //
 // key is pointer to cpu key, result is cpu
diff --git a/include/linux/reiserfs_fs_i.h b/include/linux/reiserfs_fs_i.h
index 76360b36ac33..89f4d3abbf5a 100644
--- a/include/linux/reiserfs_fs_i.h
+++ b/include/linux/reiserfs_fs_i.h
@@ -54,10 +54,6 @@ struct reiserfs_inode_info {
         unsigned int i_trans_id;
         struct reiserfs_journal_list *i_jl;
         struct mutex i_mmap;
-#ifdef CONFIG_REISERFS_FS_POSIX_ACL
-        struct posix_acl *i_acl_access;
-        struct posix_acl *i_acl_default;
-#endif
 #ifdef CONFIG_REISERFS_FS_XATTR
         struct rw_semaphore i_xattr_sem;
 #endif
diff --git a/include/linux/reiserfs_fs_sb.h b/include/linux/reiserfs_fs_sb.h
index 6473650c28f1..dab68bbed675 100644
--- a/include/linux/reiserfs_fs_sb.h
+++ b/include/linux/reiserfs_fs_sb.h
@@ -453,6 +453,7 @@ enum reiserfs_mount_options {
         REISERFS_ATTRS,
         REISERFS_XATTRS_USER,
         REISERFS_POSIXACL,
+        REISERFS_EXPOSE_PRIVROOT,
         REISERFS_BARRIER_NONE,
         REISERFS_BARRIER_FLUSH,
 
@@ -490,6 +491,7 @@ enum reiserfs_mount_options {
 #define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK))
 #define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER))
 #define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL))
+#define reiserfs_expose_privroot(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_EXPOSE_PRIVROOT))
 #define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s))
 #define reiserfs_barrier_none(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_NONE))
 #define reiserfs_barrier_flush(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_FLUSH))
diff --git a/include/linux/res_counter.h b/include/linux/res_counter.h
index 4c5bcf6ca7e8..511f42fc6816 100644
--- a/include/linux/res_counter.h
+++ b/include/linux/res_counter.h
@@ -49,6 +49,8 @@ struct res_counter {
         struct res_counter *parent;
 };
 
+#define RESOURCE_MAX (unsigned long long)LLONG_MAX
+
 /**
  * Helpers to interact with userspace
  * res_counter_read_u64() - returns the value of the specified member.
diff --git a/include/linux/rfkill.h b/include/linux/rfkill.h
index 164332cbb77c..278777fa8a3a 100644
--- a/include/linux/rfkill.h
+++ b/include/linux/rfkill.h
@@ -4,6 +4,7 @@
 /*
  * Copyright (C) 2006 - 2007 Ivo van Doorn
  * Copyright (C) 2007 Dmitry Torokhov
+ * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
  *
  * 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
@@ -22,131 +23,353 @@
  */
 
 #include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/list.h>
-#include <linux/mutex.h>
-#include <linux/device.h>
-#include <linux/leds.h>
+
+/* define userspace visible states */
+#define RFKILL_STATE_SOFT_BLOCKED       0
+#define RFKILL_STATE_UNBLOCKED          1
+#define RFKILL_STATE_HARD_BLOCKED       2
 
 /**
  * enum rfkill_type - type of rfkill switch.
- * RFKILL_TYPE_WLAN: switch is on a 802.11 wireless network device.
- * RFKILL_TYPE_BLUETOOTH: switch is on a bluetooth device.
- * RFKILL_TYPE_UWB: switch is on a ultra wideband device.
- * RFKILL_TYPE_WIMAX: switch is on a WiMAX device.
- * RFKILL_TYPE_WWAN: switch is on a wireless WAN device.
+ *
+ * @RFKILL_TYPE_ALL: toggles all switches (userspace only)
+ * @RFKILL_TYPE_WLAN: switch is on a 802.11 wireless network device.
+ * @RFKILL_TYPE_BLUETOOTH: switch is on a bluetooth device.
+ * @RFKILL_TYPE_UWB: switch is on a ultra wideband device.
+ * @RFKILL_TYPE_WIMAX: switch is on a WiMAX device.
+ * @RFKILL_TYPE_WWAN: switch is on a wireless WAN device.
+ * @NUM_RFKILL_TYPES: number of defined rfkill types
  */
 enum rfkill_type {
-        RFKILL_TYPE_WLAN ,
+        RFKILL_TYPE_ALL = 0,
+        RFKILL_TYPE_WLAN,
         RFKILL_TYPE_BLUETOOTH,
         RFKILL_TYPE_UWB,
         RFKILL_TYPE_WIMAX,
         RFKILL_TYPE_WWAN,
-        RFKILL_TYPE_MAX,
+        NUM_RFKILL_TYPES,
 };
 
-enum rfkill_state {
-        RFKILL_STATE_SOFT_BLOCKED = 0,  /* Radio output blocked */
-        RFKILL_STATE_UNBLOCKED    = 1,  /* Radio output allowed */
-        RFKILL_STATE_HARD_BLOCKED = 2,  /* Output blocked, non-overrideable */
-        RFKILL_STATE_MAX,               /* marker for last valid state */
+/**
+ * enum rfkill_operation - operation types
+ * @RFKILL_OP_ADD: a device was added
+ * @RFKILL_OP_DEL: a device was removed
+ * @RFKILL_OP_CHANGE: a device's state changed -- userspace changes one device
+ * @RFKILL_OP_CHANGE_ALL: userspace changes all devices (of a type, or all)
+ */
+enum rfkill_operation {
+        RFKILL_OP_ADD = 0,
+        RFKILL_OP_DEL,
+        RFKILL_OP_CHANGE,
+        RFKILL_OP_CHANGE_ALL,
 };
 
-/*
- * These are DEPRECATED, drivers using them should be verified to
- * comply with the rfkill usage guidelines in Documentation/rfkill.txt
- * and then converted to use the new names for rfkill_state
- */
-#define RFKILL_STATE_OFF RFKILL_STATE_SOFT_BLOCKED
-#define RFKILL_STATE_ON  RFKILL_STATE_UNBLOCKED
-
-/**
- * struct rfkill - rfkill control structure.
- * @name: Name of the switch.
- * @type: Radio type which the button controls, the value stored
- *      here should be a value from enum rfkill_type.
- * @state: State of the switch, "UNBLOCKED" means radio can operate.
- * @user_claim_unsupported: Whether the hardware supports exclusive
- *      RF-kill control by userspace. Set this before registering.
- * @user_claim: Set when the switch is controlled exlusively by userspace.
- * @mutex: Guards switch state transitions.  It serializes callbacks
- *      and also protects the state.
- * @data: Pointer to the RF button drivers private data which will be
- *      passed along when toggling radio state.
- * @toggle_radio(): Mandatory handler to control state of the radio.
- *      only RFKILL_STATE_SOFT_BLOCKED and RFKILL_STATE_UNBLOCKED are
- *      valid parameters.
- * @get_state(): handler to read current radio state from hardware,
- *      may be called from atomic context, should return 0 on success.
- *      Either this handler OR judicious use of rfkill_force_state() is
- *      MANDATORY for any driver capable of RFKILL_STATE_HARD_BLOCKED.
- * @led_trigger: A LED trigger for this button's LED.
- * @dev: Device structure integrating the switch into device tree.
- * @node: Used to place switch into list of all switches known to the
- *      the system.
- *
- * This structure represents a RF switch located on a network device.
- */
-struct rfkill {
-        const char *name;
-        enum rfkill_type type;
-
-        bool user_claim_unsupported;
-        bool user_claim;
-
-        /* the mutex serializes callbacks and also protects
-         * the state */
-        struct mutex mutex;
-        enum rfkill_state state;
-        void *data;
-        int (*toggle_radio)(void *data, enum rfkill_state state);
-        int (*get_state)(void *data, enum rfkill_state *state);
+/**
+ * struct rfkill_event - events for userspace on /dev/rfkill
+ * @idx: index of dev rfkill
+ * @type: type of the rfkill struct
+ * @op: operation code
+ * @hard: hard state (0/1)
+ * @soft: soft state (0/1)
+ *
+ * Structure used for userspace communication on /dev/rfkill,
+ * used for events from the kernel and control to the kernel.
+ */
+struct rfkill_event {
+        __u32 idx;
+        __u8  type;
+        __u8  op;
+        __u8  soft, hard;
+} __packed;
 
-#ifdef CONFIG_RFKILL_LEDS
-        struct led_trigger led_trigger;
-#endif
+/* ioctl for turning off rfkill-input (if present) */
+#define RFKILL_IOC_MAGIC        'R'
+#define RFKILL_IOC_NOINPUT      1
+#define RFKILL_IOCTL_NOINPUT    _IO(RFKILL_IOC_MAGIC, RFKILL_IOC_NOINPUT)
 
-        struct device dev;
-        struct list_head node;
-        enum rfkill_state state_for_resume;
+/* and that's all userspace gets */
+#ifdef __KERNEL__
+/* don't allow anyone to use these in the kernel */
+enum rfkill_user_states {
+        RFKILL_USER_STATE_SOFT_BLOCKED  = RFKILL_STATE_SOFT_BLOCKED,
+        RFKILL_USER_STATE_UNBLOCKED     = RFKILL_STATE_UNBLOCKED,
+        RFKILL_USER_STATE_HARD_BLOCKED  = RFKILL_STATE_HARD_BLOCKED,
 };
-#define to_rfkill(d)    container_of(d, struct rfkill, dev)
+#undef RFKILL_STATE_SOFT_BLOCKED
+#undef RFKILL_STATE_UNBLOCKED
+#undef RFKILL_STATE_HARD_BLOCKED
+
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/device.h>
+#include <linux/leds.h>
+#include <linux/err.h>
+
+/* this is opaque */
+struct rfkill;
+
+/**
+ * struct rfkill_ops - rfkill driver methods
+ *
+ * @poll: poll the rfkill block state(s) -- only assign this method
+ *      when you need polling. When called, simply call one of the
+ *      rfkill_set{,_hw,_sw}_state family of functions. If the hw
+ *      is getting unblocked you need to take into account the return
+ *      value of those functions to make sure the software block is
+ *      properly used.
+ * @query: query the rfkill block state(s) and call exactly one of the
+ *      rfkill_set{,_hw,_sw}_state family of functions. Assign this
+ *      method if input events can cause hardware state changes to make
+ *      the rfkill core query your driver before setting a requested
+ *      block.
+ * @set_block: turn the transmitter on (blocked == false) or off
+ *      (blocked == true) -- ignore and return 0 when hard blocked.
+ *      This callback must be assigned.
+ */
+struct rfkill_ops {
+        void    (*poll)(struct rfkill *rfkill, void *data);
+        void    (*query)(struct rfkill *rfkill, void *data);
+        int     (*set_block)(void *data, bool blocked);
+};
+
+#if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
+/**
+ * rfkill_alloc - allocate rfkill structure
+ * @name: name of the struct -- the string is not copied internally
+ * @parent: device that has rf switch on it
+ * @type: type of the switch (RFKILL_TYPE_*)
+ * @ops: rfkill methods
+ * @ops_data: data passed to each method
+ *
+ * This function should be called by the transmitter driver to allocate an
+ * rfkill structure. Returns %NULL on failure.
+ */
+struct rfkill * __must_check rfkill_alloc(const char *name,
+                                          struct device *parent,
+                                          const enum rfkill_type type,
+                                          const struct rfkill_ops *ops,
+                                          void *ops_data);
 
-struct rfkill * __must_check rfkill_allocate(struct device *parent,
-                                             enum rfkill_type type);
-void rfkill_free(struct rfkill *rfkill);
+/**
+ * rfkill_register - Register a rfkill structure.
+ * @rfkill: rfkill structure to be registered
+ *
+ * This function should be called by the transmitter driver to register
+ * the rfkill structure. Before calling this function the driver needs
+ * to be ready to service method calls from rfkill.
+ *
+ * If rfkill_init_sw_state() is not called before registration,
+ * set_block() will be called to initialize the software blocked state
+ * to a default value.
+ *
+ * If the hardware blocked state is not set before registration,
+ * it is assumed to be unblocked.
+ */
 int __must_check rfkill_register(struct rfkill *rfkill);
+
+/**
+ * rfkill_pause_polling(struct rfkill *rfkill)
+ *
+ * Pause polling -- say transmitter is off for other reasons.
+ * NOTE: not necessary for suspend/resume -- in that case the
+ * core stops polling anyway
+ */
+void rfkill_pause_polling(struct rfkill *rfkill);
+
+/**
+ * rfkill_resume_polling(struct rfkill *rfkill)
+ *
+ * Pause polling -- say transmitter is off for other reasons.
+ * NOTE: not necessary for suspend/resume -- in that case the
+ * core stops polling anyway
+ */
+void rfkill_resume_polling(struct rfkill *rfkill);
+
+
+/**
+ * rfkill_unregister - Unregister a rfkill structure.
+ * @rfkill: rfkill structure to be unregistered
+ *
+ * This function should be called by the network driver during device
+ * teardown to destroy rfkill structure. Until it returns, the driver
+ * needs to be able to service method calls.
+ */
 void rfkill_unregister(struct rfkill *rfkill);
 
-int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state);
-int rfkill_set_default(enum rfkill_type type, enum rfkill_state state);
+/**
+ * rfkill_destroy - free rfkill structure
+ * @rfkill: rfkill structure to be destroyed
+ *
+ * Destroys the rfkill structure.
+ */
+void rfkill_destroy(struct rfkill *rfkill);
+
+/**
+ * rfkill_set_hw_state - Set the internal rfkill hardware block state
+ * @rfkill: pointer to the rfkill class to modify.
+ * @state: the current hardware block state to set
+ *
+ * rfkill drivers that get events when the hard-blocked state changes
+ * use this function to notify the rfkill core (and through that also
+ * userspace) of the current state.  They should also use this after
+ * resume if the state could have changed.
+ *
+ * You need not (but may) call this function if poll_state is assigned.
+ *
+ * This function can be called in any context, even from within rfkill
+ * callbacks.
+ *
+ * The function returns the combined block state (true if transmitter
+ * should be blocked) so that drivers need not keep track of the soft
+ * block state -- which they might not be able to.
+ */
+bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked);
+
+/**
+ * rfkill_set_sw_state - Set the internal rfkill software block state
+ * @rfkill: pointer to the rfkill class to modify.
+ * @state: the current software block state to set
+ *
+ * rfkill drivers that get events when the soft-blocked state changes
+ * (yes, some platforms directly act on input but allow changing again)
+ * use this function to notify the rfkill core (and through that also
+ * userspace) of the current state.
+ *
+ * Drivers should also call this function after resume if the state has
+ * been changed by the user.  This only makes sense for "persistent"
+ * devices (see rfkill_init_sw_state()).
+ *
+ * This function can be called in any context, even from within rfkill
+ * callbacks.
+ *
+ * The function returns the combined block state (true if transmitter
+ * should be blocked).
+ */
+bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked);
+
+/**
+ * rfkill_init_sw_state - Initialize persistent software block state
+ * @rfkill: pointer to the rfkill class to modify.
+ * @state: the current software block state to set
+ *
+ * rfkill drivers that preserve their software block state over power off
+ * use this function to notify the rfkill core (and through that also
+ * userspace) of their initial state.  It should only be used before
+ * registration.
+ *
+ * In addition, it marks the device as "persistent", an attribute which
+ * can be read by userspace.  Persistent devices are expected to preserve
+ * their own state when suspended.
+ */
+void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked);
+
+/**
+ * rfkill_set_states - Set the internal rfkill block states
+ * @rfkill: pointer to the rfkill class to modify.
+ * @sw: the current software block state to set
+ * @hw: the current hardware block state to set
+ *
+ * This function can be called in any context, even from within rfkill
+ * callbacks.
+ */
+void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw);
 
 /**
- * rfkill_state_complement - return complementar state
- * @state: state to return the complement of
+ * rfkill_blocked - query rfkill block
  *
- * Returns RFKILL_STATE_SOFT_BLOCKED if @state is RFKILL_STATE_UNBLOCKED,
- * returns RFKILL_STATE_UNBLOCKED otherwise.
+ * @rfkill: rfkill struct to query
  */
-static inline enum rfkill_state rfkill_state_complement(enum rfkill_state state)
+bool rfkill_blocked(struct rfkill *rfkill);
+#else /* !RFKILL */
+static inline struct rfkill * __must_check
+rfkill_alloc(const char *name,
+             struct device *parent,
+             const enum rfkill_type type,
+             const struct rfkill_ops *ops,
+             void *ops_data)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline int __must_check rfkill_register(struct rfkill *rfkill)
+{
+        if (rfkill == ERR_PTR(-ENODEV))
+                return 0;
+        return -EINVAL;
+}
+
+static inline void rfkill_pause_polling(struct rfkill *rfkill)
+{
+}
+
+static inline void rfkill_resume_polling(struct rfkill *rfkill)
+{
+}
+
+static inline void rfkill_unregister(struct rfkill *rfkill)
+{
+}
+
+static inline void rfkill_destroy(struct rfkill *rfkill)
 {
-        return (state == RFKILL_STATE_UNBLOCKED) ?
-                RFKILL_STATE_SOFT_BLOCKED : RFKILL_STATE_UNBLOCKED;
 }
 
+static inline bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked)
+{
+        return blocked;
+}
+
+static inline bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked)
+{
+        return blocked;
+}
+
+static inline void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked)
+{
+}
+
+static inline void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw)
+{
+}
+
+static inline bool rfkill_blocked(struct rfkill *rfkill)
+{
+        return false;
+}
+#endif /* RFKILL || RFKILL_MODULE */
+
+
+#ifdef CONFIG_RFKILL_LEDS
 /**
- * rfkill_get_led_name - Get the LED trigger name for the button's LED.
+ * rfkill_get_led_trigger_name - Get the LED trigger name for the button's LED.
  * This function might return a NULL pointer if registering of the
- * LED trigger failed.
- * Use this as "default_trigger" for the LED.
+ * LED trigger failed. Use this as "default_trigger" for the LED.
  */
-static inline char *rfkill_get_led_name(struct rfkill *rfkill)
-{
-#ifdef CONFIG_RFKILL_LEDS
-        return (char *)(rfkill->led_trigger.name);
+const char *rfkill_get_led_trigger_name(struct rfkill *rfkill);
+
+/**
+ * rfkill_set_led_trigger_name -- set the LED trigger name
+ * @rfkill: rfkill struct
+ * @name: LED trigger name
+ *
+ * This function sets the LED trigger name of the radio LED
+ * trigger that rfkill creates. It is optional, but if called
+ * must be called before rfkill_register() to be effective.
+ */
+void rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name);
 #else
+static inline const char *rfkill_get_led_trigger_name(struct rfkill *rfkill)
+{
         return NULL;
-#endif
 }
 
+static inline void
+rfkill_set_led_trigger_name(struct rfkill *rfkill, const char *name)
+{
+}
+#endif
+
+#endif /* __KERNEL__ */
+
 #endif /* RFKILL_H */
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index e1b7b2173885..29f8599e6bea 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -1,6 +1,7 @@
 #ifndef _LINUX_RING_BUFFER_H
 #define _LINUX_RING_BUFFER_H
 
+#include <linux/kmemcheck.h>
 #include <linux/mm.h>
 #include <linux/seq_file.h>
 
@@ -11,7 +12,10 @@ struct ring_buffer_iter;
  * Don't refer to this struct directly, use functions below.
  */
 struct ring_buffer_event {
-        u32             type:2, len:3, time_delta:27;
+        kmemcheck_bitfield_begin(bitfield);
+        u32             type_len:5, time_delta:27;
+        kmemcheck_bitfield_end(bitfield);
+
         u32             array[];
 };
 
@@ -24,7 +28,8 @@ struct ring_buffer_event {
  *                                size is variable depending on how much
  *                                padding is needed
  *                               If time_delta is non zero:
- *                                everything else same as RINGBUF_TYPE_DATA
+ *                                array[0] holds the actual length
+ *                                size = 4 + length (bytes)
  *
  * @RINGBUF_TYPE_TIME_EXTEND:   Extend the time delta
  *                               array[0] = time delta (28 .. 59)
@@ -35,22 +40,23 @@ struct ring_buffer_event {
  *                               array[1..2] = tv_sec
  *                               size = 16 bytes
  *
- * @RINGBUF_TYPE_DATA:          Data record
- *                               If len is zero:
+ * <= @RINGBUF_TYPE_DATA_TYPE_LEN_MAX:
+ *                              Data record
+ *                               If type_len is zero:
  *                                array[0] holds the actual length
  *                                array[1..(length+3)/4] holds data
- *                                size = 4 + 4 + length (bytes)
+ *                                size = 4 + length (bytes)
  *                               else
- *                                length = len << 2
+ *                                length = type_len << 2
  *                                array[0..(length+3)/4-1] holds data
  *                                size = 4 + length (bytes)
  */
 enum ring_buffer_type {
+        RINGBUF_TYPE_DATA_TYPE_LEN_MAX = 28,
         RINGBUF_TYPE_PADDING,
         RINGBUF_TYPE_TIME_EXTEND,
         /* FIXME: RINGBUF_TYPE_TIME_STAMP not implemented */
         RINGBUF_TYPE_TIME_STAMP,
-        RINGBUF_TYPE_DATA,
 };
 
 unsigned ring_buffer_event_length(struct ring_buffer_event *event);
@@ -68,13 +74,54 @@ ring_buffer_event_time_delta(struct ring_buffer_event *event)
         return event->time_delta;
 }
 
+/*
+ * ring_buffer_event_discard can discard any event in the ring buffer.
+ *   it is up to the caller to protect against a reader from
+ *   consuming it or a writer from wrapping and replacing it.
+ *
+ * No external protection is needed if this is called before
+ * the event is commited. But in that case it would be better to
+ * use ring_buffer_discard_commit.
+ *
+ * Note, if an event that has not been committed is discarded
+ * with ring_buffer_event_discard, it must still be committed.
+ */
 void ring_buffer_event_discard(struct ring_buffer_event *event);
 
 /*
+ * ring_buffer_discard_commit will remove an event that has not
+ *   ben committed yet. If this is used, then ring_buffer_unlock_commit
+ *   must not be called on the discarded event. This function
+ *   will try to remove the event from the ring buffer completely
+ *   if another event has not been written after it.
+ *
+ * Example use:
+ *
+ *  if (some_condition)
+ *    ring_buffer_discard_commit(buffer, event);
+ *  else
+ *    ring_buffer_unlock_commit(buffer, event);
+ */
+void ring_buffer_discard_commit(struct ring_buffer *buffer,
+                                struct ring_buffer_event *event);
+
+/*
  * size is in bytes for each per CPU buffer.
  */
 struct ring_buffer *
-ring_buffer_alloc(unsigned long size, unsigned flags);
+__ring_buffer_alloc(unsigned long size, unsigned flags, struct lock_class_key *key);
+
+/*
+ * Because the ring buffer is generic, if other users of the ring buffer get
+ * traced by ftrace, it can produce lockdep warnings. We need to keep each
+ * ring buffer's lock class separate.
+ */
+#define ring_buffer_alloc(size, flags)                  \
+({                                                      \
+        static struct lock_class_key __key;             \
+        __ring_buffer_alloc((size), (flags), &__key);   \
+})
+
 void ring_buffer_free(struct ring_buffer *buffer);
 
 int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size);
@@ -122,6 +169,8 @@ unsigned long ring_buffer_entries(struct ring_buffer *buffer);
 unsigned long ring_buffer_overruns(struct ring_buffer *buffer);
 unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu);
+unsigned long ring_buffer_commit_overrun_cpu(struct ring_buffer *buffer, int cpu);
+unsigned long ring_buffer_nmi_dropped_cpu(struct ring_buffer *buffer, int cpu);
 
 u64 ring_buffer_time_stamp(struct ring_buffer *buffer, int cpu);
 void ring_buffer_normalize_time_stamp(struct ring_buffer *buffer,
@@ -137,6 +186,11 @@ void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data);
 int ring_buffer_read_page(struct ring_buffer *buffer, void **data_page,
                           size_t len, int cpu, int full);
 
+struct trace_seq;
+
+int ring_buffer_print_entry_header(struct trace_seq *s);
+int ring_buffer_print_page_header(struct trace_seq *s);
+
 enum ring_buffer_flags {
         RB_FL_OVERWRITE         = 1 << 0,
 };
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index b35bc0e19cd9..bf116d0dbf23 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -83,7 +83,8 @@ static inline void page_dup_rmap(struct page *page, struct vm_area_struct *vma,
 /*
  * Called from mm/vmscan.c to handle paging out
  */
-int page_referenced(struct page *, int is_locked, struct mem_cgroup *cnt);
+int page_referenced(struct page *, int is_locked,
+                        struct mem_cgroup *cnt, unsigned long *vm_flags);
 int try_to_unmap(struct page *, int ignore_refs);
 
 /*
@@ -105,18 +106,11 @@ unsigned long page_address_in_vma(struct page *, struct vm_area_struct *);
  */
 int page_mkclean(struct page *);
 
-#ifdef CONFIG_UNEVICTABLE_LRU
 /*
  * called in munlock()/munmap() path to check for other vmas holding
  * the page mlocked.
  */
 int try_to_munlock(struct page *);
-#else
-static inline int try_to_munlock(struct page *page)
-{
-        return 0;       /* a.k.a. SWAP_SUCCESS */
-}
-#endif
 
 #else   /* !CONFIG_MMU */
 
@@ -124,7 +118,14 @@ static inline int try_to_munlock(struct page *page)
 #define anon_vma_prepare(vma)   (0)
 #define anon_vma_link(vma)      do {} while (0)
 
-#define page_referenced(page,l,cnt) TestClearPageReferenced(page)
+static inline int page_referenced(struct page *page, int is_locked,
+                                  struct mem_cgroup *cnt,
+                                  unsigned long *vm_flags)
+{
+        *vm_flags = 0;
+        return TestClearPageReferenced(page);
+}
+
 #define try_to_unmap(page, refs) SWAP_FAIL
 
 static inline int page_mkclean(struct page *page)
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
index e5996984ddd0..9aaf5bfdad1a 100644
--- a/include/linux/scatterlist.h
+++ b/include/linux/scatterlist.h
@@ -242,6 +242,8 @@ size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents,
  */
 
 #define SG_MITER_ATOMIC         (1 << 0)         /* use kmap_atomic */
+#define SG_MITER_TO_SG          (1 << 1)        /* flush back to phys on unmap */
+#define SG_MITER_FROM_SG        (1 << 2)        /* nop */
 
 struct sg_mapping_iter {
         /* the following three fields can be accessed directly */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index b4c38bc8049c..3ab08e4bb6b8 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -77,6 +77,7 @@ struct sched_param {
 #include <linux/proportions.h>
 #include <linux/seccomp.h>
 #include <linux/rcupdate.h>
+#include <linux/rculist.h>
 #include <linux/rtmutex.h>
 
 #include <linux/time.h>
@@ -91,13 +92,13 @@ struct sched_param {
 
 #include <asm/processor.h>
 
-struct mem_cgroup;
 struct exec_domain;
 struct futex_pi_state;
 struct robust_list_head;
 struct bio;
-struct bts_tracer;
 struct fs_struct;
+struct bts_context;
+struct perf_counter_context;
 
 /*
  * List of flags we want to share for kernel threads,
@@ -116,6 +117,7 @@ struct fs_struct;
  *    11 bit fractions.
  */
 extern unsigned long avenrun[];         /* Load averages */
+extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
 
 #define FSHIFT          11              /* nr of bits of precision */
 #define FIXED_1         (1<<FSHIFT)     /* 1.0 as fixed-point */
@@ -135,8 +137,9 @@ DECLARE_PER_CPU(unsigned long, process_counts);
 extern int nr_processes(void);
 extern unsigned long nr_running(void);
 extern unsigned long nr_uninterruptible(void);
-extern unsigned long nr_active(void);
 extern unsigned long nr_iowait(void);
+extern void calc_global_load(void);
+extern u64 cpu_nr_migrations(int cpu);
 
 extern unsigned long get_parent_ip(unsigned long addr);
 
@@ -206,7 +209,7 @@ extern unsigned long long time_sync_thresh;
                         ((task->state & (__TASK_STOPPED | __TASK_TRACED)) != 0)
 #define task_contributes_to_load(task)  \
                                 ((task->state & TASK_UNINTERRUPTIBLE) != 0 && \
-                                 (task->flags & PF_FROZEN) == 0)
+                                 (task->flags & PF_FREEZING) == 0)
 
 #define __set_task_state(tsk, state_value)              \
         do { (tsk)->state = (state_value); } while (0)
@@ -257,6 +260,7 @@ extern void task_rq_unlock_wait(struct task_struct *p);
 extern cpumask_var_t nohz_cpu_mask;
 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
 extern int select_nohz_load_balancer(int cpu);
+extern int get_nohz_load_balancer(void);
 #else
 static inline int select_nohz_load_balancer(int cpu)
 {
@@ -345,8 +349,20 @@ extern int mutex_spin_on_owner(struct mutex *lock, struct thread_info *owner);
 struct nsproxy;
 struct user_namespace;
 
-/* Maximum number of active map areas.. This is a random (large) number */
-#define DEFAULT_MAX_MAP_COUNT   65536
+/*
+ * Default maximum number of active map areas, this limits the number of vmas
+ * per mm struct. Users can overwrite this number by sysctl but there is a
+ * problem.
+ *
+ * When a program's coredump is generated as ELF format, a section is created
+ * per a vma. In ELF, the number of sections is represented in unsigned short.
+ * This means the number of sections should be smaller than 65535 at coredump.
+ * Because the kernel adds some informative sections to a image of program at
+ * generating coredump, we need some margin. The number of extra sections is
+ * 1-3 now and depends on arch. We use "5" as safe margin, here.
+ */
+#define MAPCOUNT_ELF_CORE_MARGIN        (5)
+#define DEFAULT_MAX_MAP_COUNT   (USHORT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
 
 extern int sysctl_max_map_count;
 
@@ -482,6 +498,15 @@ struct task_cputime {
                 .sum_exec_runtime = 0,                          \
         }
 
+/*
+ * Disable preemption until the scheduler is running.
+ * Reset by start_kernel()->sched_init()->init_idle().
+ *
+ * We include PREEMPT_ACTIVE to avoid cond_resched() from working
+ * before the scheduler is active -- see should_resched().
+ */
+#define INIT_PREEMPT_COUNT      (1 + PREEMPT_ACTIVE)
+
 /**
  * struct thread_group_cputimer - thread group interval timer counts
  * @cputime:            thread group interval timers.
@@ -669,8 +694,12 @@ struct user_struct {
         struct task_group *tg;
 #ifdef CONFIG_SYSFS
         struct kobject kobj;
-        struct work_struct work;
+        struct delayed_work work;
+#endif
 #endif
+
+#ifdef CONFIG_PERF_COUNTERS
+        atomic_long_t locked_vm;
 #endif
 };
 
@@ -838,7 +867,17 @@ struct sched_group {
          */
         u32 reciprocal_cpu_power;
 
-        unsigned long cpumask[];
+        /*
+         * The CPUs this group covers.
+         *
+         * NOTE: this field is variable length. (Allocated dynamically
+         * by attaching extra space to the end of the structure,
+         * depending on how many CPUs the kernel has booted up with)
+         *
+         * It is also be embedded into static data structures at build
+         * time. (See 'struct static_sched_group' in kernel/sched.c)
+         */
+        unsigned long cpumask[0];
 };
 
 static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
@@ -924,8 +963,17 @@ struct sched_domain {
         char *name;
 #endif
 
-        /* span of all CPUs in this domain */
-        unsigned long span[];
+        /*
+         * Span of all CPUs in this domain.
+         *
+         * NOTE: this field is variable length. (Allocated dynamically
+         * by attaching extra space to the end of the structure,
+         * depending on how many CPUs the kernel has booted up with)
+         *
+         * It is also be embedded into static data structures at build
+         * time. (See 'struct static_sched_domain' in kernel/sched.c)
+         */
+        unsigned long span[0];
 };
 
 static inline struct cpumask *sched_domain_span(struct sched_domain *sd)
@@ -1052,9 +1100,10 @@ struct sched_entity {
         u64                     last_wakeup;
         u64                     avg_overlap;
 
+        u64                     nr_migrations;
+
         u64                     start_runtime;
         u64                     avg_wakeup;
-        u64                     nr_migrations;
 
 #ifdef CONFIG_SCHEDSTATS
         u64                     wait_start;
@@ -1149,7 +1198,6 @@ struct task_struct {
          * a short time
          */
         unsigned char fpu_counter;
-        s8 oomkilladj; /* OOM kill score adjustment (bit shift). */
 #ifdef CONFIG_BLK_DEV_IO_TRACE
         unsigned int btrace_seq;
 #endif
@@ -1209,18 +1257,11 @@ struct task_struct {
         struct list_head ptraced;
         struct list_head ptrace_entry;
 
-#ifdef CONFIG_X86_PTRACE_BTS
         /*
          * This is the tracer handle for the ptrace BTS extension.
          * This field actually belongs to the ptracer task.
          */
-        struct bts_tracer *bts;
-        /*
-         * The buffer to hold the BTS data.
-         */
-        void *bts_buffer;
-        size_t bts_size;
-#endif /* CONFIG_X86_PTRACE_BTS */
+        struct bts_context *bts;
 
         /* PID/PID hash table linkage. */
         struct pid_link pids[PIDTYPE_MAX];
@@ -1247,7 +1288,9 @@ struct task_struct {
                                          * credentials (COW) */
         const struct cred *cred;        /* effective (overridable) subjective task
                                          * credentials (COW) */
-        struct mutex cred_exec_mutex;   /* execve vs ptrace cred calculation mutex */
+        struct mutex cred_guard_mutex;  /* guard against foreign influences on
+                                         * credential calculations
+                                         * (notably. ptrace) */
 
         char comm[TASK_COMM_LEN]; /* executable name excluding path
                                      - access with [gs]et_task_comm (which lock
@@ -1294,7 +1337,8 @@ struct task_struct {
 /* Thread group tracking */
         u32 parent_exec_id;
         u32 self_exec_id;
-/* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
+/* Protection of (de-)allocation: mm, files, fs, tty, keyrings, mems_allowed,
+ * mempolicy */
         spinlock_t alloc_lock;
 
 #ifdef CONFIG_GENERIC_HARDIRQS
@@ -1362,8 +1406,7 @@ struct task_struct {
         cputime_t acct_timexpd; /* stime + utime since last update */
 #endif
 #ifdef CONFIG_CPUSETS
-        nodemask_t mems_allowed;
-        int cpuset_mems_generation;
+        nodemask_t mems_allowed;        /* Protected by alloc_lock */
         int cpuset_mem_spread_rotor;
 #endif
 #ifdef CONFIG_CGROUPS
@@ -1380,8 +1423,13 @@ struct task_struct {
         struct list_head pi_state_list;
         struct futex_pi_state *pi_state_cache;
 #endif
+#ifdef CONFIG_PERF_COUNTERS
+        struct perf_counter_context *perf_counter_ctxp;
+        struct mutex perf_counter_mutex;
+        struct list_head perf_counter_list;
+#endif
 #ifdef CONFIG_NUMA
-        struct mempolicy *mempolicy;
+        struct mempolicy *mempolicy;    /* Protected by alloc_lock */
         short il_next;
 #endif
         atomic_t fs_excl;       /* holding fs exclusive resources */
@@ -1428,7 +1476,9 @@ struct task_struct {
 #ifdef CONFIG_TRACING
         /* state flags for use by tracers */
         unsigned long trace;
-#endif
+        /* bitmask of trace recursion */
+        unsigned long trace_recursion;
+#endif /* CONFIG_TRACING */
 };
 
 /* Future-safe accessor for struct task_struct's cpus_allowed. */
@@ -1630,6 +1680,7 @@ extern cputime_t task_gtime(struct task_struct *p);
 #define PF_MEMALLOC     0x00000800      /* Allocating memory */
 #define PF_FLUSHER      0x00001000      /* responsible for disk writeback */
 #define PF_USED_MATH    0x00002000      /* if unset the fpu must be initialized before use */
+#define PF_FREEZING     0x00004000      /* freeze in progress. do not account to load */
 #define PF_NOFREEZE     0x00008000      /* this thread should not be frozen */
 #define PF_FROZEN       0x00010000      /* frozen for system suspend */
 #define PF_FSTRANS      0x00020000      /* inside a filesystem transaction */
@@ -1766,11 +1817,23 @@ extern unsigned int sysctl_sched_child_runs_first;
 extern unsigned int sysctl_sched_features;
 extern unsigned int sysctl_sched_migration_cost;
 extern unsigned int sysctl_sched_nr_migrate;
+extern unsigned int sysctl_timer_migration;
 
 int sched_nr_latency_handler(struct ctl_table *table, int write,
                 struct file *file, void __user *buffer, size_t *length,
                 loff_t *ppos);
 #endif
+#ifdef CONFIG_SCHED_DEBUG
+static inline unsigned int get_sysctl_timer_migration(void)
+{
+        return sysctl_timer_migration;
+}
+#else
+static inline unsigned int get_sysctl_timer_migration(void)
+{
+        return 1;
+}
+#endif
 extern unsigned int sysctl_sched_rt_period;
 extern int sysctl_sched_rt_runtime;
 
@@ -1837,9 +1900,6 @@ extern struct pid_namespace init_pid_ns;
 /*
  * find a task by one of its numerical ids
  *
- * find_task_by_pid_type_ns():
- *      it is the most generic call - it finds a task by all id,
- *      type and namespace specified
  * find_task_by_pid_ns():
  *      finds a task by its pid in the specified namespace
  * find_task_by_vpid():
@@ -1848,9 +1908,6 @@ extern struct pid_namespace init_pid_ns;
  * see also find_vpid() etc in include/linux/pid.h
  */
 
-extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
-                struct pid_namespace *ns);
-
 extern struct task_struct *find_task_by_vpid(pid_t nr);
 extern struct task_struct *find_task_by_pid_ns(pid_t nr,
                 struct pid_namespace *ns);
@@ -1885,6 +1942,7 @@ extern void sched_dead(struct task_struct *p);
 
 extern void proc_caches_init(void);
 extern void flush_signals(struct task_struct *);
+extern void __flush_signals(struct task_struct *);
 extern void ignore_signals(struct task_struct *);
 extern void flush_signal_handlers(struct task_struct *, int force_default);
 extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
@@ -2001,8 +2059,10 @@ extern void set_task_comm(struct task_struct *tsk, char *from);
 extern char *get_task_comm(char *to, struct task_struct *tsk);
 
 #ifdef CONFIG_SMP
+extern void wait_task_context_switch(struct task_struct *p);
 extern unsigned long wait_task_inactive(struct task_struct *, long match_state);
 #else
+static inline void wait_task_context_switch(struct task_struct *p) {}
 static inline unsigned long wait_task_inactive(struct task_struct *p,
                                                long match_state)
 {
@@ -2010,7 +2070,8 @@ static inline unsigned long wait_task_inactive(struct task_struct *p,
 }
 #endif
 
-#define next_task(p)    list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)
+#define next_task(p) \
+        list_entry_rcu((p)->tasks.next, struct task_struct, tasks)
 
 #define for_each_process(p) \
         for (p = &init_task ; (p = next_task(p)) != &init_task ; )
@@ -2049,8 +2110,8 @@ int same_thread_group(struct task_struct *p1, struct task_struct *p2)
 
 static inline struct task_struct *next_thread(const struct task_struct *p)
 {
-        return list_entry(rcu_dereference(p->thread_group.next),
-                          struct task_struct, thread_group);
+        return list_entry_rcu(p->thread_group.next,
+                              struct task_struct, thread_group);
 }
 
 static inline int thread_group_empty(struct task_struct *p)
@@ -2178,6 +2239,12 @@ static inline int test_tsk_need_resched(struct task_struct *tsk)
         return unlikely(test_tsk_thread_flag(tsk,TIF_NEED_RESCHED));
 }
 
+static inline int restart_syscall(void)
+{
+        set_tsk_thread_flag(current, TIF_SIGPENDING);
+        return -ERESTARTNOINTR;
+}
+
 static inline int signal_pending(struct task_struct *p)
 {
         return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
@@ -2388,6 +2455,13 @@ static inline void inc_syscw(struct task_struct *tsk)
 #define TASK_SIZE_OF(tsk)       TASK_SIZE
 #endif
 
+/*
+ * Call the function if the target task is executing on a CPU right now:
+ */
+extern void task_oncpu_function_call(struct task_struct *p,
+                                     void (*func) (void *info), void *info);
+
+
 #ifdef CONFIG_MM_OWNER
 extern void mm_update_next_owner(struct mm_struct *mm);
 extern void mm_init_owner(struct mm_struct *mm, struct task_struct *p);
diff --git a/include/linux/sctp.h b/include/linux/sctp.h
index c2731bfe04d8..b464b9d3d242 100644
--- a/include/linux/sctp.h
+++ b/include/linux/sctp.h
@@ -487,17 +487,17 @@ typedef enum {
          *
          * Value          Cause Code
          * ---------      ----------------
-         * 0x0100          Request to Delete Last Remaining IP Address.
-         * 0x0101          Operation Refused Due to Resource Shortage.
-         * 0x0102          Request to Delete Source IP Address.
-         * 0x0103          Association Aborted due to illegal ASCONF-ACK
-         * 0x0104          Request refused - no authorization.
+         * 0x00A0          Request to Delete Last Remaining IP Address.
+         * 0x00A1          Operation Refused Due to Resource Shortage.
+         * 0x00A2          Request to Delete Source IP Address.
+         * 0x00A3          Association Aborted due to illegal ASCONF-ACK
+         * 0x00A4          Request refused - no authorization.
          */
-        SCTP_ERROR_DEL_LAST_IP  = cpu_to_be16(0x0100),
-        SCTP_ERROR_RSRC_LOW     = cpu_to_be16(0x0101),
-        SCTP_ERROR_DEL_SRC_IP   = cpu_to_be16(0x0102),
-        SCTP_ERROR_ASCONF_ACK   = cpu_to_be16(0x0103),
-        SCTP_ERROR_REQ_REFUSED  = cpu_to_be16(0x0104),
+        SCTP_ERROR_DEL_LAST_IP  = cpu_to_be16(0x00A0),
+        SCTP_ERROR_RSRC_LOW     = cpu_to_be16(0x00A1),
+        SCTP_ERROR_DEL_SRC_IP   = cpu_to_be16(0x00A2),
+        SCTP_ERROR_ASCONF_ACK   = cpu_to_be16(0x00A3),
+        SCTP_ERROR_REQ_REFUSED  = cpu_to_be16(0x00A4),
 
         /* AUTH Section 4.  New Error Cause
          *
diff --git a/include/linux/section-names.h b/include/linux/section-names.h
deleted file mode 100644
index c956f4eb2adf..000000000000
--- a/include/linux/section-names.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef __LINUX_SECTION_NAMES_H
-#define __LINUX_SECTION_NAMES_H
-
-#define HEAD_TEXT_SECTION .head.text
-
-#endif /* !__LINUX_SECTION_NAMES_H */
diff --git a/include/linux/security.h b/include/linux/security.h
index d5fd6163606f..5eff459b3833 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -2197,6 +2197,8 @@ static inline int security_file_mmap(struct file *file, unsigned long reqprot,
                                      unsigned long addr,
                                      unsigned long addr_only)
 {
+        if ((addr < mmap_min_addr) && !capable(CAP_SYS_RAWIO))
+                return -EACCES;
         return 0;
 }
 
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index 004f3b3342c5..0c6a86b79596 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -43,6 +43,7 @@ int seq_release(struct inode *, struct file *);
 int seq_escape(struct seq_file *, const char *, const char *);
 int seq_putc(struct seq_file *m, char c);
 int seq_puts(struct seq_file *m, const char *s);
+int seq_write(struct seq_file *seq, const void *data, size_t len);
 
 int seq_printf(struct seq_file *, const char *, ...)
         __attribute__ ((format (printf,2,3)));
diff --git a/include/linux/serial.h b/include/linux/serial.h
index 9136cc5608c3..e5bb75a63802 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -96,54 +96,76 @@ struct serial_uart_config {
 
 /*
  * Definitions for async_struct (and serial_struct) flags field
+ *
+ * Define ASYNCB_* for convenient use with {test,set,clear}_bit.
  */
-#define ASYNC_HUP_NOTIFY 0x0001 /* Notify getty on hangups and closes 
-                                   on the callout port */
-#define ASYNC_FOURPORT  0x0002  /* Set OU1, OUT2 per AST Fourport settings */
-#define ASYNC_SAK       0x0004  /* Secure Attention Key (Orange book) */
-#define ASYNC_SPLIT_TERMIOS 0x0008 /* Separate termios for dialin/callout */
-
-#define ASYNC_SPD_MASK  0x1030
-#define ASYNC_SPD_HI    0x0010  /* Use 56000 instead of 38400 bps */
-
-#define ASYNC_SPD_VHI   0x0020  /* Use 115200 instead of 38400 bps */
-#define ASYNC_SPD_CUST  0x0030  /* Use user-specified divisor */
-
-#define ASYNC_SKIP_TEST 0x0040 /* Skip UART test during autoconfiguration */
-#define ASYNC_AUTO_IRQ  0x0080 /* Do automatic IRQ during autoconfiguration */
-#define ASYNC_SESSION_LOCKOUT 0x0100 /* Lock out cua opens based on session */
-#define ASYNC_PGRP_LOCKOUT    0x0200 /* Lock out cua opens based on pgrp */
-#define ASYNC_CALLOUT_NOHUP   0x0400 /* Don't do hangups for cua device */
-
-#define ASYNC_HARDPPS_CD        0x0800  /* Call hardpps when CD goes high  */
-
-#define ASYNC_SPD_SHI   0x1000  /* Use 230400 instead of 38400 bps */
-#define ASYNC_SPD_WARP  0x1010  /* Use 460800 instead of 38400 bps */
-
-#define ASYNC_LOW_LATENCY 0x2000 /* Request low latency behaviour */
-
-#define ASYNC_BUGGY_UART  0x4000 /* This is a buggy UART, skip some safety
-                                  * checks.  Note: can be dangerous! */
-
-#define ASYNC_AUTOPROBE  0x8000 /* Port was autoprobed by PCI or PNP code */
-
-#define ASYNC_FLAGS     0x7FFF  /* Possible legal async flags */
-#define ASYNC_USR_MASK  0x3430  /* Legal flags that non-privileged
-                                 * users can set or reset */
-
-/* Internal flags used only by kernel/chr_drv/serial.c */
-#define ASYNC_INITIALIZED       0x80000000 /* Serial port was initialized */
-#define ASYNC_NORMAL_ACTIVE     0x20000000 /* Normal device is active */
-#define ASYNC_BOOT_AUTOCONF     0x10000000 /* Autoconfigure port on bootup */
-#define ASYNC_CLOSING           0x08000000 /* Serial port is closing */
-#define ASYNC_CTS_FLOW          0x04000000 /* Do CTS flow control */
-#define ASYNC_CHECK_CD          0x02000000 /* i.e., CLOCAL */
-#define ASYNC_SHARE_IRQ         0x01000000 /* for multifunction cards
-                                             --- no longer used */
-#define ASYNC_CONS_FLOW         0x00800000 /* flow control for console  */
-
-#define ASYNC_BOOT_ONLYMCA      0x00400000 /* Probe only if MCA bus */
-#define ASYNC_INTERNAL_FLAGS    0xFFC00000 /* Internal flags */
+#define ASYNCB_HUP_NOTIFY        0 /* Notify getty on hangups and closes
+                                    * on the callout port */
+#define ASYNCB_FOURPORT          1 /* Set OU1, OUT2 per AST Fourport settings */
+#define ASYNCB_SAK               2 /* Secure Attention Key (Orange book) */
+#define ASYNCB_SPLIT_TERMIOS     3 /* Separate termios for dialin/callout */
+#define ASYNCB_SPD_HI            4 /* Use 56000 instead of 38400 bps */
+#define ASYNCB_SPD_VHI           5 /* Use 115200 instead of 38400 bps */
+#define ASYNCB_SKIP_TEST         6 /* Skip UART test during autoconfiguration */
+#define ASYNCB_AUTO_IRQ          7 /* Do automatic IRQ during
+                                    * autoconfiguration */
+#define ASYNCB_SESSION_LOCKOUT   8 /* Lock out cua opens based on session */
+#define ASYNCB_PGRP_LOCKOUT      9 /* Lock out cua opens based on pgrp */
+#define ASYNCB_CALLOUT_NOHUP    10 /* Don't do hangups for cua device */
+#define ASYNCB_HARDPPS_CD       11 /* Call hardpps when CD goes high  */
+#define ASYNCB_SPD_SHI          12 /* Use 230400 instead of 38400 bps */
+#define ASYNCB_LOW_LATENCY      13 /* Request low latency behaviour */
+#define ASYNCB_BUGGY_UART       14 /* This is a buggy UART, skip some safety
+                                    * checks.  Note: can be dangerous! */
+#define ASYNCB_AUTOPROBE        15 /* Port was autoprobed by PCI or PNP code */
+#define ASYNCB_LAST_USER        15
+
+/* Internal flags used only by kernel */
+#define ASYNCB_INITIALIZED      31 /* Serial port was initialized */
+#define ASYNCB_NORMAL_ACTIVE    29 /* Normal device is active */
+#define ASYNCB_BOOT_AUTOCONF    28 /* Autoconfigure port on bootup */
+#define ASYNCB_CLOSING          27 /* Serial port is closing */
+#define ASYNCB_CTS_FLOW         26 /* Do CTS flow control */
+#define ASYNCB_CHECK_CD         25 /* i.e., CLOCAL */
+#define ASYNCB_SHARE_IRQ        24 /* for multifunction cards, no longer used */
+#define ASYNCB_CONS_FLOW        23 /* flow control for console  */
+#define ASYNCB_BOOT_ONLYMCA     22 /* Probe only if MCA bus */
+#define ASYNCB_FIRST_KERNEL     22
+
+#define ASYNC_HUP_NOTIFY        (1U << ASYNCB_HUP_NOTIFY)
+#define ASYNC_FOURPORT          (1U << ASYNCB_FOURPORT)
+#define ASYNC_SAK               (1U << ASYNCB_SAK)
+#define ASYNC_SPLIT_TERMIOS     (1U << ASYNCB_SPLIT_TERMIOS)
+#define ASYNC_SPD_HI            (1U << ASYNCB_SPD_HI)
+#define ASYNC_SPD_VHI           (1U << ASYNCB_SPD_VHI)
+#define ASYNC_SKIP_TEST         (1U << ASYNCB_SKIP_TEST)
+#define ASYNC_AUTO_IRQ          (1U << ASYNCB_AUTO_IRQ)
+#define ASYNC_SESSION_LOCKOUT   (1U << ASYNCB_SESSION_LOCKOUT)
+#define ASYNC_PGRP_LOCKOUT      (1U << ASYNCB_PGRP_LOCKOUT)
+#define ASYNC_CALLOUT_NOHUP     (1U << ASYNCB_CALLOUT_NOHUP)
+#define ASYNC_HARDPPS_CD        (1U << ASYNCB_HARDPPS_CD)
+#define ASYNC_SPD_SHI           (1U << ASYNCB_SPD_SHI)
+#define ASYNC_LOW_LATENCY       (1U << ASYNCB_LOW_LATENCY)
+#define ASYNC_BUGGY_UART        (1U << ASYNCB_BUGGY_UART)
+#define ASYNC_AUTOPROBE         (1U << ASYNCB_AUTOPROBE)
+
+#define ASYNC_FLAGS             ((1U << ASYNCB_LAST_USER) - 1)
+#define ASYNC_USR_MASK          (ASYNC_SPD_HI|ASYNC_SPD_VHI| \
+                ASYNC_CALLOUT_NOHUP|ASYNC_SPD_SHI|ASYNC_LOW_LATENCY)
+#define ASYNC_SPD_CUST          (ASYNC_SPD_HI|ASYNC_SPD_VHI)
+#define ASYNC_SPD_WARP          (ASYNC_SPD_HI|ASYNC_SPD_SHI)
+#define ASYNC_SPD_MASK          (ASYNC_SPD_HI|ASYNC_SPD_VHI|ASYNC_SPD_SHI)
+
+#define ASYNC_INITIALIZED       (1U << ASYNCB_INITIALIZED)
+#define ASYNC_NORMAL_ACTIVE     (1U << ASYNCB_NORMAL_ACTIVE)
+#define ASYNC_BOOT_AUTOCONF     (1U << ASYNCB_BOOT_AUTOCONF)
+#define ASYNC_CLOSING           (1U << ASYNCB_CLOSING)
+#define ASYNC_CTS_FLOW          (1U << ASYNCB_CTS_FLOW)
+#define ASYNC_CHECK_CD          (1U << ASYNCB_CHECK_CD)
+#define ASYNC_SHARE_IRQ         (1U << ASYNCB_SHARE_IRQ)
+#define ASYNC_CONS_FLOW         (1U << ASYNCB_CONS_FLOW)
+#define ASYNC_BOOT_ONLYMCA      (1U << ASYNCB_BOOT_ONLYMCA)
+#define ASYNC_INTERNAL_FLAGS    (~((1U << ASYNCB_FIRST_KERNEL) - 1))
 
 /*
  * Multiport serial configuration structure --- external structure
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 57a97e52e58d..23d2fb051f97 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -41,7 +41,8 @@
 #define PORT_XSCALE     15
 #define PORT_RM9000     16      /* PMC-Sierra RM9xxx internal UART */
 #define PORT_OCTEON     17      /* Cavium OCTEON internal UART */
-#define PORT_MAX_8250   17      /* max port ID */
+#define PORT_AR7        18      /* Texas Instruments AR7 internal UART */
+#define PORT_MAX_8250   18      /* max port ID */
 
 /*
  * ARM specific type numbers.  These are not currently guaranteed
@@ -167,6 +168,12 @@
 /* MAX3100 */
 #define PORT_MAX3100    86
 
+/* Timberdale UART */
+#define PORT_TIMBUART   87
+
+/* Qualcomm MSM SoCs */
+#define PORT_MSM        88
+
 #ifdef __KERNEL__
 
 #include <linux/compiler.h>
diff --git a/include/linux/serial_reg.h b/include/linux/serial_reg.h
index 96c0d93fc2ca..850db2e80510 100644
--- a/include/linux/serial_reg.h
+++ b/include/linux/serial_reg.h
@@ -323,6 +323,7 @@
 #define UART_OMAP_MVER          0x14    /* Module version register */
 #define UART_OMAP_SYSC          0x15    /* System configuration register */
 #define UART_OMAP_SYSS          0x16    /* System status register */
+#define UART_OMAP_WER           0x17    /* Wake-up enable register */
 
 #endif /* _LINUX_SERIAL_REG_H */
 
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index 893cc53486bc..1c297ddc9d5a 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -25,8 +25,7 @@ struct plat_sci_port {
         unsigned int    irqs[SCIx_NR_IRQS];     /* ERI, RXI, TXI, BRI */
         unsigned int    type;                   /* SCI / SCIF / IRDA */
         upf_t           flags;                  /* UPF_* flags */
+        char            *clk;                   /* clock string */
 };
 
-int early_sci_setup(struct uart_port *port);
-
 #endif /* __LINUX_SERIAL_SCI_H */
diff --git a/include/linux/sh_cmt.h b/include/linux/sh_cmt.h
deleted file mode 100644
index 68cacde5954f..000000000000
--- a/include/linux/sh_cmt.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef __SH_CMT_H__
-#define __SH_CMT_H__
-
-struct sh_cmt_config {
-        char *name;
-        unsigned long channel_offset;
-        int timer_bit;
-        char *clk;
-        unsigned long clockevent_rating;
-        unsigned long clocksource_rating;
-};
-
-#endif /* __SH_CMT_H__ */
diff --git a/include/linux/sh_timer.h b/include/linux/sh_timer.h
new file mode 100644
index 000000000000..864bd56bd3b0
--- /dev/null
+++ b/include/linux/sh_timer.h
@@ -0,0 +1,13 @@
+#ifndef __SH_TIMER_H__
+#define __SH_TIMER_H__
+
+struct sh_timer_config {
+        char *name;
+        long channel_offset;
+        int timer_bit;
+        char *clk;
+        unsigned long clockevent_rating;
+        unsigned long clocksource_rating;
+};
+
+#endif /* __SH_TIMER_H__ */
diff --git a/include/linux/shmem_fs.h b/include/linux/shmem_fs.h
index fd83f2584b15..abff6c9b413c 100644
--- a/include/linux/shmem_fs.h
+++ b/include/linux/shmem_fs.h
@@ -19,10 +19,6 @@ struct shmem_inode_info {
         swp_entry_t             i_direct[SHMEM_NR_DIRECT]; /* first blocks */
         struct list_head        swaplist;       /* chain of maybes on swap */
         struct inode            vfs_inode;
-#ifdef CONFIG_TMPFS_POSIX_ACL
-        struct posix_acl        *i_acl;
-        struct posix_acl        *i_default_acl;
-#endif
 };
 
 struct shmem_sb_info {
@@ -45,7 +41,6 @@ static inline struct shmem_inode_info *SHMEM_I(struct inode *inode)
 #ifdef CONFIG_TMPFS_POSIX_ACL
 int shmem_permission(struct inode *, int);
 int shmem_acl_init(struct inode *, struct inode *);
-void shmem_acl_destroy_inode(struct inode *);
 
 extern struct xattr_handler shmem_xattr_acl_access_handler;
 extern struct xattr_handler shmem_xattr_acl_default_handler;
@@ -57,9 +52,6 @@ static inline int shmem_acl_init(struct inode *inode, struct inode *dir)
 {
         return 0;
 }
-static inline void shmem_acl_destroy_inode(struct inode *inode)
-{
-}
 #endif  /* CONFIG_TMPFS_POSIX_ACL */
 
 #endif
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 84f997f8aa53..c7552836bd95 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -235,6 +235,8 @@ static inline int valid_signal(unsigned long sig)
 extern int next_signal(struct sigpending *pending, sigset_t *mask);
 extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
 extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
+extern long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig,
+                                 siginfo_t *info);
 extern long do_sigpending(void __user *, unsigned long);
 extern int sigprocmask(int, sigset_t *, sigset_t *);
 extern int show_unhandled_signals;
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 5fd389162f01..f2c69a2cca17 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -15,6 +15,7 @@
 #define _LINUX_SKBUFF_H
 
 #include <linux/kernel.h>
+#include <linux/kmemcheck.h>
 #include <linux/compiler.h>
 #include <linux/time.h>
 #include <linux/cache.h>
@@ -189,20 +190,23 @@ struct skb_shared_info {
         atomic_t        dataref;
         unsigned short  nr_frags;
         unsigned short  gso_size;
+#ifdef CONFIG_HAS_DMA
+        dma_addr_t      dma_head;
+#endif
         /* Warning: this field is not always filled in (UFO)! */
         unsigned short  gso_segs;
         unsigned short  gso_type;
         __be32          ip6_frag_id;
         union skb_shared_tx tx_flags;
-#ifdef CONFIG_HAS_DMA
-        unsigned int    num_dma_maps;
-#endif
         struct sk_buff  *frag_list;
         struct skb_shared_hwtstamps hwtstamps;
         skb_frag_t      frags[MAX_SKB_FRAGS];
 #ifdef CONFIG_HAS_DMA
-        dma_addr_t      dma_maps[MAX_SKB_FRAGS + 1];
+        dma_addr_t      dma_maps[MAX_SKB_FRAGS];
 #endif
+        /* Intermediate layers must ensure that destructor_arg
+         * remains valid until skb destructor */
+        void *          destructor_arg;
 };
 
 /* We divide dataref into two halves.  The higher 16 bits hold references
@@ -261,7 +265,7 @@ typedef unsigned char *sk_buff_data_t;
  *      @transport_header: Transport layer header
  *      @network_header: Network layer header
  *      @mac_header: Link layer header
- *      @dst: destination entry
+ *      @_skb_dst: destination entry
  *      @sp: the security path, used for xfrm
  *      @cb: Control buffer. Free for use by every layer. Put private vars here
  *      @len: Length of actual data
@@ -301,9 +305,6 @@ typedef unsigned char *sk_buff_data_t;
  *      @tc_verd: traffic control verdict
  *      @ndisc_nodetype: router type (from link layer)
  *      @do_not_encrypt: set to prevent encryption of this frame
- *      @requeue: set to indicate that the wireless core should attempt
- *              a software retry on this frame if we failed to
- *              receive an ACK for it
  *      @dma_cookie: a cookie to one of several possible DMA operations
  *              done by skb DMA functions
  *      @secmark: security marking
@@ -319,10 +320,7 @@ struct sk_buff {
         ktime_t                 tstamp;
         struct net_device       *dev;
 
-        union {
-                struct  dst_entry       *dst;
-                struct  rtable          *rtable;
-        };
+        unsigned long           _skb_dst;
 #ifdef CONFIG_XFRM
         struct  sec_path        *sp;
 #endif
@@ -346,6 +344,7 @@ struct sk_buff {
                 };
         };
         __u32                   priority;
+        kmemcheck_bitfield_begin(flags1);
         __u8                    local_df:1,
                                 cloned:1,
                                 ip_summed:2,
@@ -356,6 +355,7 @@ struct sk_buff {
                                 ipvs_property:1,
                                 peeked:1,
                                 nf_trace:1;
+        kmemcheck_bitfield_end(flags1);
         __be16                  protocol;
 
         void                    (*destructor)(struct sk_buff *skb);
@@ -375,13 +375,16 @@ struct sk_buff {
         __u16                   tc_verd;        /* traffic control verdict */
 #endif
 #endif
+
+        kmemcheck_bitfield_begin(flags2);
 #ifdef CONFIG_IPV6_NDISC_NODETYPE
         __u8                    ndisc_nodetype:2;
 #endif
 #if defined(CONFIG_MAC80211) || defined(CONFIG_MAC80211_MODULE)
         __u8                    do_not_encrypt:1;
-        __u8                    requeue:1;
 #endif
+        kmemcheck_bitfield_end(flags2);
+
         /* 0/13/14 bit hole */
 
 #ifdef CONFIG_NET_DMA
@@ -423,6 +426,21 @@ extern void skb_dma_unmap(struct device *dev, struct sk_buff *skb,
                           enum dma_data_direction dir);
 #endif
 
+static inline struct dst_entry *skb_dst(const struct sk_buff *skb)
+{
+        return (struct dst_entry *)skb->_skb_dst;
+}
+
+static inline void skb_dst_set(struct sk_buff *skb, struct dst_entry *dst)
+{
+        skb->_skb_dst = (unsigned long)dst;
+}
+
+static inline struct rtable *skb_rtable(const struct sk_buff *skb)
+{
+        return (struct rtable *)skb_dst(skb);
+}
+
 extern void kfree_skb(struct sk_buff *skb);
 extern void consume_skb(struct sk_buff *skb);
 extern void            __kfree_skb(struct sk_buff *skb);
@@ -1062,7 +1080,7 @@ extern void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page,
                             int off, int size);
 
 #define SKB_PAGE_ASSERT(skb)    BUG_ON(skb_shinfo(skb)->nr_frags)
-#define SKB_FRAG_ASSERT(skb)    BUG_ON(skb_shinfo(skb)->frag_list)
+#define SKB_FRAG_ASSERT(skb)    BUG_ON(skb_has_frags(skb))
 #define SKB_LINEAR_ASSERT(skb)  BUG_ON(skb_is_nonlinear(skb))
 
 #ifdef NET_SKBUFF_DATA_USES_OFFSET
@@ -1324,12 +1342,12 @@ static inline int skb_network_offset(const struct sk_buff *skb)
  * shifting the start of the packet by 2 bytes. Drivers should do this
  * with:
  *
- * skb_reserve(NET_IP_ALIGN);
+ * skb_reserve(skb, NET_IP_ALIGN);
  *
  * The downside to this alignment of the IP header is that the DMA is now
  * unaligned. On some architectures the cost of an unaligned DMA is high
  * and this cost outweighs the gains made by aligning the IP header.
- * 
+ *
  * Since this trade off varies between architectures, we allow NET_IP_ALIGN
  * to be overridden.
  */
@@ -1701,6 +1719,25 @@ static inline int pskb_trim_rcsum(struct sk_buff *skb, unsigned int len)
                      skb = skb->prev)
 
 
+static inline bool skb_has_frags(const struct sk_buff *skb)
+{
+        return skb_shinfo(skb)->frag_list != NULL;
+}
+
+static inline void skb_frag_list_init(struct sk_buff *skb)
+{
+        skb_shinfo(skb)->frag_list = NULL;
+}
+
+static inline void skb_frag_add_head(struct sk_buff *skb, struct sk_buff *frag)
+{
+        frag->next = skb_shinfo(skb)->frag_list;
+        skb_shinfo(skb)->frag_list = frag;
+}
+
+#define skb_walk_frags(skb, iter)       \
+        for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
+
 extern struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
                                            int *peeked, int *err);
 extern struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags,
@@ -1715,8 +1752,14 @@ extern int	       skb_copy_and_csum_datagram_iovec(struct sk_buff *skb,
                                                         struct iovec *iov);
 extern int             skb_copy_datagram_from_iovec(struct sk_buff *skb,
                                                     int offset,
-                                                    struct iovec *from,
+                                                    const struct iovec *from,
+                                                    int from_offset,
                                                     int len);
+extern int             skb_copy_datagram_const_iovec(const struct sk_buff *from,
+                                                     int offset,
+                                                     const struct iovec *to,
+                                                     int to_offset,
+                                                     int size);
 extern void            skb_free_datagram(struct sock *sk, struct sk_buff *skb);
 extern int             skb_kill_datagram(struct sock *sk, struct sk_buff *skb,
                                          unsigned int flags);
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 24c5602bee99..2da8372519f5 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -62,6 +62,15 @@
 # define SLAB_DEBUG_OBJECTS     0x00000000UL
 #endif
 
+#define SLAB_NOLEAKTRACE        0x00800000UL    /* Avoid kmemleak tracing */
+
+/* Don't track use of uninitialized memory */
+#ifdef CONFIG_KMEMCHECK
+# define SLAB_NOTRACK           0x01000000UL
+#else
+# define SLAB_NOTRACK           0x00000000UL
+#endif
+
 /* The following flags affect the page allocator grouping pages by mobility */
 #define SLAB_RECLAIM_ACCOUNT    0x00020000UL            /* Objects are reclaimable */
 #define SLAB_TEMPORARY          SLAB_RECLAIM_ACCOUNT    /* Objects are short-lived */
@@ -317,4 +326,6 @@ static inline void *kzalloc_node(size_t size, gfp_t flags, int node)
         return kmalloc_node(size, flags | __GFP_ZERO, node);
 }
 
+void __init kmem_cache_init_late(void);
+
 #endif  /* _LINUX_SLAB_H */
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index 5ac9b0bcaf9a..850d057500de 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -14,7 +14,88 @@
 #include <asm/page.h>           /* kmalloc_sizes.h needs PAGE_SIZE */
 #include <asm/cache.h>          /* kmalloc_sizes.h needs L1_CACHE_BYTES */
 #include <linux/compiler.h>
-#include <trace/kmemtrace.h>
+#include <linux/kmemtrace.h>
+
+/*
+ * struct kmem_cache
+ *
+ * manages a cache.
+ */
+
+struct kmem_cache {
+/* 1) per-cpu data, touched during every alloc/free */
+        struct array_cache *array[NR_CPUS];
+/* 2) Cache tunables. Protected by cache_chain_mutex */
+        unsigned int batchcount;
+        unsigned int limit;
+        unsigned int shared;
+
+        unsigned int buffer_size;
+        u32 reciprocal_buffer_size;
+/* 3) touched by every alloc & free from the backend */
+
+        unsigned int flags;             /* constant flags */
+        unsigned int num;               /* # of objs per slab */
+
+/* 4) cache_grow/shrink */
+        /* order of pgs per slab (2^n) */
+        unsigned int gfporder;
+
+        /* force GFP flags, e.g. GFP_DMA */
+        gfp_t gfpflags;
+
+        size_t colour;                  /* cache colouring range */
+        unsigned int colour_off;        /* colour offset */
+        struct kmem_cache *slabp_cache;
+        unsigned int slab_size;
+        unsigned int dflags;            /* dynamic flags */
+
+        /* constructor func */
+        void (*ctor)(void *obj);
+
+/* 5) cache creation/removal */
+        const char *name;
+        struct list_head next;
+
+/* 6) statistics */
+#ifdef CONFIG_DEBUG_SLAB
+        unsigned long num_active;
+        unsigned long num_allocations;
+        unsigned long high_mark;
+        unsigned long grown;
+        unsigned long reaped;
+        unsigned long errors;
+        unsigned long max_freeable;
+        unsigned long node_allocs;
+        unsigned long node_frees;
+        unsigned long node_overflow;
+        atomic_t allochit;
+        atomic_t allocmiss;
+        atomic_t freehit;
+        atomic_t freemiss;
+
+        /*
+         * If debugging is enabled, then the allocator can add additional
+         * fields and/or padding to every object. buffer_size contains the total
+         * object size including these internal fields, the following two
+         * variables contain the offset to the user object and its size.
+         */
+        int obj_offset;
+        int obj_size;
+#endif /* CONFIG_DEBUG_SLAB */
+
+        /*
+         * We put nodelists[] at the end of kmem_cache, because we want to size
+         * this array to nr_node_ids slots instead of MAX_NUMNODES
+         * (see kmem_cache_init())
+         * We still use [MAX_NUMNODES] and not [1] or [0] because cache_cache
+         * is statically defined, so we reserve the max number of nodes.
+         */
+        struct kmem_list3 *nodelists[MAX_NUMNODES];
+        /*
+         * Do not add fields after nodelists[]
+         */
+};
 
 /* Size description struct for general caches. */
 struct cache_sizes {
diff --git a/include/linux/slob_def.h b/include/linux/slob_def.h
index 0ec00b39d006..bb5368df4be8 100644
--- a/include/linux/slob_def.h
+++ b/include/linux/slob_def.h
@@ -34,4 +34,9 @@ static __always_inline void *__kmalloc(size_t size, gfp_t flags)
         return kmalloc(size, flags);
 }
 
+static inline void kmem_cache_init_late(void)
+{
+        /* Nothing to do */
+}
+
 #endif /* __LINUX_SLOB_DEF_H */
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 5046f90c1171..c1c862b1d01a 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -10,7 +10,8 @@
 #include <linux/gfp.h>
 #include <linux/workqueue.h>
 #include <linux/kobject.h>
-#include <trace/kmemtrace.h>
+#include <linux/kmemtrace.h>
+#include <linux/kmemleak.h>
 
 enum stat_item {
         ALLOC_FASTPATH,         /* Allocation from cpu slab */
@@ -233,6 +234,7 @@ static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
         unsigned int order = get_order(size);
         void *ret = (void *) __get_free_pages(flags | __GFP_COMP, order);
 
+        kmemleak_alloc(ret, size, 1, flags);
         trace_kmalloc(_THIS_IP_, ret, size, PAGE_SIZE << order, flags);
 
         return ret;
@@ -302,4 +304,6 @@ static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 }
 #endif
 
+void __init kmem_cache_init_late(void);
+
 #endif /* _LINUX_SLUB_DEF_H */
diff --git a/include/linux/smp.h b/include/linux/smp.h
index a69db820eed6..9e3d8af09207 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -177,7 +177,6 @@ static inline void init_call_single_data(void)
 
 #define get_cpu()               ({ preempt_disable(); smp_processor_id(); })
 #define put_cpu()               preempt_enable()
-#define put_cpu_no_resched()    preempt_enable_no_resched()
 
 /*
  * Callback to arch code if there's nosmp or maxcpus=0 on the
diff --git a/include/linux/smsc911x.h b/include/linux/smsc911x.h
index b32725075d71..5241e4fb4eca 100644
--- a/include/linux/smsc911x.h
+++ b/include/linux/smsc911x.h
@@ -47,4 +47,14 @@ struct smsc911x_platform_config {
 #define SMSC911X_FORCE_EXTERNAL_PHY             (BIT(3))
 #define SMSC911X_SAVE_MAC_ADDRESS               (BIT(4))
 
+/*
+ * SMSC911X_SWAP_FIFO:
+ * Enables software byte swap for fifo data. Should only be used as a
+ * "last resort" in the case of big endian mode on boards with incorrectly
+ * routed data bus to older devices such as LAN9118. Newer devices such as
+ * LAN9221 can handle this in hardware, there are registers to control
+ * this swapping but the driver doesn't currently use them.
+ */
+#define SMSC911X_SWAP_FIFO                      (BIT(5))
+
 #endif /* __LINUX_SMSC911X_H__ */
diff --git a/include/linux/snmp.h b/include/linux/snmp.h
index aee3f1e1d1ce..0f953fe40413 100644
--- a/include/linux/snmp.h
+++ b/include/linux/snmp.h
@@ -18,7 +18,7 @@
 enum
 {
         IPSTATS_MIB_NUM = 0,
-        IPSTATS_MIB_INRECEIVES,                 /* InReceives */
+        IPSTATS_MIB_INPKTS,                     /* InReceives */
         IPSTATS_MIB_INHDRERRORS,                /* InHdrErrors */
         IPSTATS_MIB_INTOOBIGERRORS,             /* InTooBigErrors */
         IPSTATS_MIB_INNOROUTES,                 /* InNoRoutes */
@@ -28,7 +28,7 @@ enum
         IPSTATS_MIB_INDISCARDS,                 /* InDiscards */
         IPSTATS_MIB_INDELIVERS,                 /* InDelivers */
         IPSTATS_MIB_OUTFORWDATAGRAMS,           /* OutForwDatagrams */
-        IPSTATS_MIB_OUTREQUESTS,                /* OutRequests */
+        IPSTATS_MIB_OUTPKTS,                    /* OutRequests */
         IPSTATS_MIB_OUTDISCARDS,                /* OutDiscards */
         IPSTATS_MIB_OUTNOROUTES,                /* OutNoRoutes */
         IPSTATS_MIB_REASMTIMEOUT,               /* ReasmTimeout */
@@ -42,6 +42,12 @@ enum
         IPSTATS_MIB_OUTMCASTPKTS,               /* OutMcastPkts */
         IPSTATS_MIB_INBCASTPKTS,                /* InBcastPkts */
         IPSTATS_MIB_OUTBCASTPKTS,               /* OutBcastPkts */
+        IPSTATS_MIB_INOCTETS,                   /* InOctets */
+        IPSTATS_MIB_OUTOCTETS,                  /* OutOctets */
+        IPSTATS_MIB_INMCASTOCTETS,              /* InMcastOctets */
+        IPSTATS_MIB_OUTMCASTOCTETS,             /* OutMcastOctets */
+        IPSTATS_MIB_INBCASTOCTETS,              /* InBcastOctets */
+        IPSTATS_MIB_OUTBCASTOCTETS,             /* OutBcastOctets */
         __IPSTATS_MIB_MAX
 };
 
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 421afb4d29b0..3b461dffe244 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -194,7 +194,8 @@ struct ucred {
 #define AF_RXRPC        33      /* RxRPC sockets                */
 #define AF_ISDN         34      /* mISDN sockets                */
 #define AF_PHONET       35      /* Phonet sockets               */
-#define AF_MAX          36      /* For now.. */
+#define AF_IEEE802154   36      /* IEEE802154 sockets           */
+#define AF_MAX          37      /* For now.. */
 
 /* Protocol families, same as address families. */
 #define PF_UNSPEC       AF_UNSPEC
@@ -233,6 +234,7 @@ struct ucred {
 #define PF_RXRPC        AF_RXRPC
 #define PF_ISDN         AF_ISDN
 #define PF_PHONET       AF_PHONET
+#define PF_IEEE802154   AF_IEEE802154
 #define PF_MAX          AF_MAX
 
 /* Maximum queue length specifiable by listen.  */
@@ -303,14 +305,15 @@ struct ucred {
 #define SOL_BLUETOOTH   274
 #define SOL_PNPIPE      275
 #define SOL_RDS         276
+#define SOL_IUCV        277
 
 /* IPX options */
 #define IPX_TYPE        1
 
 #ifdef __KERNEL__
 extern int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
-extern int memcpy_fromiovecend(unsigned char *kdata, struct iovec *iov, 
-                                int offset, int len);
+extern int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
+                               int offset, int len);
 extern int csum_partial_copy_fromiovecend(unsigned char *kdata, 
                                           struct iovec *iov, 
                                           int offset, 
@@ -318,6 +321,8 @@ extern int csum_partial_copy_fromiovecend(unsigned char *kdata,
 
 extern int verify_iovec(struct msghdr *m, struct iovec *iov, struct sockaddr *address, int mode);
 extern int memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
+extern int memcpy_toiovecend(const struct iovec *v, unsigned char *kdata,
+                             int offset, int len);
 extern int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr, int __user *ulen);
 extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr);
 extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
diff --git a/include/linux/spi/libertas_spi.h b/include/linux/spi/libertas_spi.h
index 79506f5f9e67..1b5d5384fcd3 100644
--- a/include/linux/spi/libertas_spi.h
+++ b/include/linux/spi/libertas_spi.h
@@ -22,9 +22,6 @@ struct libertas_spi_platform_data {
          * speed, you may want to use 0 here. */
         u16 use_dummy_writes;
 
-        /* GPIO number to use as chip select */
-        u16 gpio_cs;
-
         /* Board specific setup/teardown */
         int (*setup)(struct spi_device *spi);
         int (*teardown)(struct spi_device *spi);
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index a0faa18f7b1b..c47c4b4da97e 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -80,6 +80,8 @@ struct spi_device {
 #define SPI_LSB_FIRST   0x08                    /* per-word bits-on-wire */
 #define SPI_3WIRE       0x10                    /* SI/SO signals shared */
 #define SPI_LOOP        0x20                    /* loopback mode */
+#define SPI_NO_CS       0x40                    /* 1 dev/bus, no chipselect */
+#define SPI_READY       0x80                    /* slave pulls low to pause */
         u8                      bits_per_word;
         int                     irq;
         void                    *controller_state;
@@ -245,6 +247,13 @@ struct spi_master {
          */
         u16                     dma_alignment;
 
+        /* spi_device.mode flags understood by this controller driver */
+        u16                     mode_bits;
+
+        /* other constraints relevant to this driver */
+        u16                     flags;
+#define SPI_MASTER_HALF_DUPLEX  BIT(0)          /* can't do full duplex */
+
         /* Setup mode and clock, etc (spi driver may call many times).
          *
          * IMPORTANT:  this may be called when transfers to another
@@ -523,30 +532,7 @@ static inline void spi_message_free(struct spi_message *m)
         kfree(m);
 }
 
-/**
- * spi_setup - setup SPI mode and clock rate
- * @spi: the device whose settings are being modified
- * Context: can sleep, and no requests are queued to the device
- *
- * SPI protocol drivers may need to update the transfer mode if the
- * device doesn't work with its default.  They may likewise need
- * to update clock rates or word sizes from initial values.  This function
- * changes those settings, and must be called from a context that can sleep.
- * Except for SPI_CS_HIGH, which takes effect immediately, the changes take
- * effect the next time the device is selected and data is transferred to
- * or from it.  When this function returns, the spi device is deselected.
- *
- * Note that this call will fail if the protocol driver specifies an option
- * that the underlying controller or its driver does not support.  For
- * example, not all hardware supports wire transfers using nine bit words,
- * LSB-first wire encoding, or active-high chipselects.
- */
-static inline int
-spi_setup(struct spi_device *spi)
-{
-        return spi->master->setup(spi);
-}
-
+extern int spi_setup(struct spi_device *spi);
 
 /**
  * spi_async - asynchronous SPI transfer
diff --git a/include/linux/spi/spidev.h b/include/linux/spi/spidev.h
index 95251ccd5a07..bf0570a84f7a 100644
--- a/include/linux/spi/spidev.h
+++ b/include/linux/spi/spidev.h
@@ -40,6 +40,8 @@
 #define SPI_LSB_FIRST           0x08
 #define SPI_3WIRE               0x10
 #define SPI_LOOP                0x20
+#define SPI_NO_CS               0x40
+#define SPI_READY               0x80
 
 /*---------------------------------------------------------------------------*/
 
diff --git a/include/linux/spi/wl12xx.h b/include/linux/spi/wl12xx.h
new file mode 100644
index 000000000000..11430cab2aad
--- /dev/null
+++ b/include/linux/spi/wl12xx.h
@@ -0,0 +1,31 @@
+/*
+ * This file is part of wl12xx
+ *
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * Contact: Kalle Valo <kalle.valo@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ */
+
+#ifndef _LINUX_SPI_WL12XX_H
+#define _LINUX_SPI_WL12XX_H
+
+struct wl12xx_platform_data {
+        void (*set_power)(bool enable);
+};
+
+#endif
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 252b245cfcf4..4be57ab03478 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -132,6 +132,11 @@ do {								\
 #endif /*__raw_spin_is_contended*/
 #endif
 
+/* The lock does not imply full memory barrier. */
+#ifndef ARCH_HAS_SMP_MB_AFTER_LOCK
+static inline void smp_mb__after_lock(void) { smp_mb(); }
+#endif
+
 /**
  * spin_unlock_wait - wait until the spinlock gets unlocked
  * @lock: the spinlock in question.
diff --git a/include/linux/spinlock_up.h b/include/linux/spinlock_up.h
index 938234c4a996..d4841ed8215b 100644
--- a/include/linux/spinlock_up.h
+++ b/include/linux/spinlock_up.h
@@ -60,6 +60,7 @@ static inline void __raw_spin_unlock(raw_spinlock_t *lock)
 #define __raw_spin_is_locked(lock)      ((void)(lock), 0)
 /* for sched.c and kernel_lock.c: */
 # define __raw_spin_lock(lock)          do { (void)(lock); } while (0)
+# define __raw_spin_lock_flags(lock, flags)     do { (void)(lock); } while (0)
 # define __raw_spin_unlock(lock)        do { (void)(lock); } while (0)
 # define __raw_spin_trylock(lock)       ({ (void)(lock); 1; })
 #endif /* DEBUG_SPINLOCK */
diff --git a/include/linux/splice.h b/include/linux/splice.h
index 5f3faa9d15ae..18e7c7c0cae6 100644
--- a/include/linux/splice.h
+++ b/include/linux/splice.h
@@ -11,8 +11,7 @@
 #include <linux/pipe_fs_i.h>
 
 /*
- * splice is tied to pipes as a transport (at least for now), so we'll just
- * add the splice flags here.
+ * Flags passed in from splice/tee/vmsplice
  */
 #define SPLICE_F_MOVE   (0x01)  /* move pages instead of copying */
 #define SPLICE_F_NONBLOCK (0x02) /* don't block on the pipe splicing (but */
diff --git a/include/linux/stacktrace.h b/include/linux/stacktrace.h
index 1a8cecc4f38c..51efbef38fb0 100644
--- a/include/linux/stacktrace.h
+++ b/include/linux/stacktrace.h
@@ -4,6 +4,8 @@
 struct task_struct;
 
 #ifdef CONFIG_STACKTRACE
+struct task_struct;
+
 struct stack_trace {
         unsigned int nr_entries, max_entries;
         unsigned long *entries;
@@ -11,6 +13,7 @@ struct stack_trace {
 };
 
 extern void save_stack_trace(struct stack_trace *trace);
+extern void save_stack_trace_bp(struct stack_trace *trace, unsigned long bp);
 extern void save_stack_trace_tsk(struct task_struct *tsk,
                                 struct stack_trace *trace);
 
diff --git a/include/linux/sunrpc/bc_xprt.h b/include/linux/sunrpc/bc_xprt.h
new file mode 100644
index 000000000000..6508f0dc0eff
--- /dev/null
+++ b/include/linux/sunrpc/bc_xprt.h
@@ -0,0 +1,49 @@
+/******************************************************************************
+
+(c) 2008 NetApp.  All Rights Reserved.
+
+NetApp provides this source code under the GPL v2 License.
+The GPL v2 license is available at
+http://opensource.org/licenses/gpl-license.php.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+******************************************************************************/
+
+/*
+ * Functions to create and manage the backchannel
+ */
+
+#ifndef _LINUX_SUNRPC_BC_XPRT_H
+#define _LINUX_SUNRPC_BC_XPRT_H
+
+#include <linux/sunrpc/svcsock.h>
+#include <linux/sunrpc/xprt.h>
+#include <linux/sunrpc/sched.h>
+
+#ifdef CONFIG_NFS_V4_1
+struct rpc_rqst *xprt_alloc_bc_request(struct rpc_xprt *xprt);
+void xprt_free_bc_request(struct rpc_rqst *req);
+int xprt_setup_backchannel(struct rpc_xprt *, unsigned int min_reqs);
+void xprt_destroy_backchannel(struct rpc_xprt *, int max_reqs);
+void bc_release_request(struct rpc_task *);
+int bc_send(struct rpc_rqst *req);
+#else /* CONFIG_NFS_V4_1 */
+static inline int xprt_setup_backchannel(struct rpc_xprt *xprt,
+                                         unsigned int min_reqs)
+{
+        return 0;
+}
+#endif /* CONFIG_NFS_V4_1 */
+#endif /* _LINUX_SUNRPC_BC_XPRT_H */
+
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index c39a21040dcb..37881f1a0bd7 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -143,6 +143,7 @@ int		rpc_call_sync(struct rpc_clnt *clnt,
                               const struct rpc_message *msg, int flags);
 struct rpc_task *rpc_call_null(struct rpc_clnt *clnt, struct rpc_cred *cred,
                                int flags);
+void            rpc_restart_call_prepare(struct rpc_task *);
 void            rpc_restart_call(struct rpc_task *);
 void            rpc_setbufsize(struct rpc_clnt *, unsigned int, unsigned int);
 size_t          rpc_max_payload(struct rpc_clnt *);
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 64981a2f1cae..401097781fc0 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -210,6 +210,8 @@ struct rpc_wait_queue {
  */
 struct rpc_task *rpc_new_task(const struct rpc_task_setup *);
 struct rpc_task *rpc_run_task(const struct rpc_task_setup *);
+struct rpc_task *rpc_run_bc_task(struct rpc_rqst *req,
+                                const struct rpc_call_ops *ops);
 void            rpc_put_task(struct rpc_task *);
 void            rpc_exit_task(struct rpc_task *);
 void            rpc_release_calldata(const struct rpc_call_ops *, void *);
@@ -237,6 +239,7 @@ void		rpc_show_tasks(void);
 int             rpc_init_mempool(void);
 void            rpc_destroy_mempool(void);
 extern struct workqueue_struct *rpciod_workqueue;
+void            rpc_prepare_task(struct rpc_task *task);
 
 static inline void rpc_exit(struct rpc_task *task, int status)
 {
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 2a30775959e9..ea8009695c69 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -96,6 +96,15 @@ struct svc_serv {
         svc_thread_fn           sv_function;    /* main function for threads */
         unsigned int            sv_drc_max_pages; /* Total pages for DRC */
         unsigned int            sv_drc_pages_used;/* DRC pages used */
+#if defined(CONFIG_NFS_V4_1)
+        struct list_head        sv_cb_list;     /* queue for callback requests
+                                                 * that arrive over the same
+                                                 * connection */
+        spinlock_t              sv_cb_lock;     /* protects the svc_cb_list */
+        wait_queue_head_t       sv_cb_waitq;    /* sleep here if there are no
+                                                 * entries in the svc_cb_list */
+        struct svc_xprt         *bc_xprt;
+#endif /* CONFIG_NFS_V4_1 */
 };
 
 /*
@@ -411,6 +420,8 @@ int		   svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
 int                svc_pool_stats_open(struct svc_serv *serv, struct file *file);
 void               svc_destroy(struct svc_serv *);
 int                svc_process(struct svc_rqst *);
+int                bc_svc_process(struct svc_serv *, struct rpc_rqst *,
+                        struct svc_rqst *);
 int                svc_register(const struct svc_serv *, const int,
                                 const unsigned short, const unsigned short);
 
diff --git a/include/linux/sunrpc/svc_xprt.h b/include/linux/sunrpc/svc_xprt.h
index 0d9cb6ef28b0..2223ae0b5ed5 100644
--- a/include/linux/sunrpc/svc_xprt.h
+++ b/include/linux/sunrpc/svc_xprt.h
@@ -83,7 +83,7 @@ int	svc_port_is_privileged(struct sockaddr *sin);
 int     svc_print_xprts(char *buf, int maxlen);
 struct  svc_xprt *svc_find_xprt(struct svc_serv *serv, const char *xcl_name,
                         const sa_family_t af, const unsigned short port);
-int     svc_xprt_names(struct svc_serv *serv, char *buf, int buflen);
+int     svc_xprt_names(struct svc_serv *serv, char *buf, const int buflen);
 
 static inline void svc_xprt_get(struct svc_xprt *xprt)
 {
@@ -118,7 +118,7 @@ static inline unsigned short svc_addr_port(const struct sockaddr *sa)
         return 0;
 }
 
-static inline size_t svc_addr_len(struct sockaddr *sa)
+static inline size_t svc_addr_len(const struct sockaddr *sa)
 {
         switch (sa->sa_family) {
         case AF_INET:
@@ -126,7 +126,8 @@ static inline size_t svc_addr_len(struct sockaddr *sa)
         case AF_INET6:
                 return sizeof(struct sockaddr_in6);
         }
-        return -EAFNOSUPPORT;
+
+        return 0;
 }
 
 static inline unsigned short svc_xprt_local_port(const struct svc_xprt *xprt)
diff --git a/include/linux/sunrpc/svcsock.h b/include/linux/sunrpc/svcsock.h
index 483e10380aae..04dba23c59f2 100644
--- a/include/linux/sunrpc/svcsock.h
+++ b/include/linux/sunrpc/svcsock.h
@@ -38,10 +38,15 @@ int		svc_recv(struct svc_rqst *, long);
 int             svc_send(struct svc_rqst *);
 void            svc_drop(struct svc_rqst *);
 void            svc_sock_update_bufs(struct svc_serv *serv);
-int             svc_sock_names(char *buf, struct svc_serv *serv, char *toclose);
-int             svc_addsock(struct svc_serv *serv, int fd, char *name_return);
+int             svc_sock_names(struct svc_serv *serv, char *buf,
+                                        const size_t buflen,
+                                        const char *toclose);
+int             svc_addsock(struct svc_serv *serv, const int fd,
+                                        char *name_return, const size_t len);
 void            svc_init_xprt_sock(void);
 void            svc_cleanup_xprt_sock(void);
+struct svc_xprt *svc_sock_create(struct svc_serv *serv, int prot);
+void            svc_sock_destroy(struct svc_xprt *);
 
 /*
  * svc_makesock socket characteristics
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index d8910b68e1bd..b99c625fddfe 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -12,7 +12,6 @@
 #include <linux/uio.h>
 #include <asm/byteorder.h>
 #include <linux/scatterlist.h>
-#include <linux/smp_lock.h>
 
 /*
  * Buffer adjustment
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 08afe43118f4..1175d58efc2e 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -67,7 +67,8 @@ struct rpc_rqst {
         struct rpc_task *       rq_task;        /* RPC task data */
         __be32                  rq_xid;         /* request XID */
         int                     rq_cong;        /* has incremented xprt->cong */
-        int                     rq_received;    /* receive completed */
+        int                     rq_reply_bytes_recvd;   /* number of reply */
+                                                        /* bytes received */
         u32                     rq_seqno;       /* gss seq no. used on req. */
         int                     rq_enc_pages_num;
         struct page             **rq_enc_pages; /* scratch pages for use by
@@ -97,6 +98,12 @@ struct rpc_rqst {
 
         unsigned long           rq_xtime;       /* when transmitted */
         int                     rq_ntrans;
+
+#if defined(CONFIG_NFS_V4_1)
+        struct list_head        rq_bc_list;     /* Callback service list */
+        unsigned long           rq_bc_pa_state; /* Backchannel prealloc state */
+        struct list_head        rq_bc_pa_list;  /* Backchannel prealloc list */
+#endif /* CONFIG_NFS_V4_1 */
 };
 #define rq_svec                 rq_snd_buf.head
 #define rq_slen                 rq_snd_buf.len
@@ -174,6 +181,15 @@ struct rpc_xprt {
         spinlock_t              reserve_lock;   /* lock slot table */
         u32                     xid;            /* Next XID value to use */
         struct rpc_task *       snd_task;       /* Task blocked in send */
+#if defined(CONFIG_NFS_V4_1)
+        struct svc_serv         *bc_serv;       /* The RPC service which will */
+                                                /* process the callback */
+        unsigned int            bc_alloc_count; /* Total number of preallocs */
+        spinlock_t              bc_pa_lock;     /* Protects the preallocated
+                                                 * items */
+        struct list_head        bc_pa_list;     /* List of preallocated
+                                                 * backchannel rpc_rqst's */
+#endif /* CONFIG_NFS_V4_1 */
         struct list_head        recv;
 
         struct {
@@ -192,6 +208,26 @@ struct rpc_xprt {
         const char              *address_strings[RPC_DISPLAY_MAX];
 };
 
+#if defined(CONFIG_NFS_V4_1)
+/*
+ * Backchannel flags
+ */
+#define RPC_BC_PA_IN_USE        0x0001          /* Preallocated backchannel */
+                                                /* buffer in use */
+#endif /* CONFIG_NFS_V4_1 */
+
+#if defined(CONFIG_NFS_V4_1)
+static inline int bc_prealloc(struct rpc_rqst *req)
+{
+        return test_bit(RPC_BC_PA_IN_USE, &req->rq_bc_pa_state);
+}
+#else
+static inline int bc_prealloc(struct rpc_rqst *req)
+{
+        return 0;
+}
+#endif /* CONFIG_NFS_V4_1 */
+
 struct xprt_create {
         int                     ident;          /* XPRT_TRANSPORT identifier */
         struct sockaddr *       srcaddr;        /* optional local address */
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 795032edfc46..cd15df6c63cd 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -245,11 +245,6 @@ extern unsigned long get_safe_page(gfp_t gfp_mask);
 
 extern void hibernation_set_ops(struct platform_hibernation_ops *ops);
 extern int hibernate(void);
-extern int hibernate_nvs_register(unsigned long start, unsigned long size);
-extern int hibernate_nvs_alloc(void);
-extern void hibernate_nvs_free(void);
-extern void hibernate_nvs_save(void);
-extern void hibernate_nvs_restore(void);
 extern bool system_entering_hibernation(void);
 #else /* CONFIG_HIBERNATION */
 static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
@@ -258,6 +253,16 @@ static inline void swsusp_unset_page_free(struct page *p) {}
 
 static inline void hibernation_set_ops(struct platform_hibernation_ops *ops) {}
 static inline int hibernate(void) { return -ENOSYS; }
+static inline bool system_entering_hibernation(void) { return false; }
+#endif /* CONFIG_HIBERNATION */
+
+#ifdef CONFIG_HIBERNATION_NVS
+extern int hibernate_nvs_register(unsigned long start, unsigned long size);
+extern int hibernate_nvs_alloc(void);
+extern void hibernate_nvs_free(void);
+extern void hibernate_nvs_save(void);
+extern void hibernate_nvs_restore(void);
+#else /* CONFIG_HIBERNATION_NVS */
 static inline int hibernate_nvs_register(unsigned long a, unsigned long b)
 {
         return 0;
@@ -266,8 +271,7 @@ static inline int hibernate_nvs_alloc(void) { return 0; }
 static inline void hibernate_nvs_free(void) {}
 static inline void hibernate_nvs_save(void) {}
 static inline void hibernate_nvs_restore(void) {}
-static inline bool system_entering_hibernation(void) { return false; }
-#endif /* CONFIG_HIBERNATION */
+#endif /* CONFIG_HIBERNATION_NVS */
 
 #ifdef CONFIG_PM_SLEEP
 void save_processor_state(void);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index d476aad3ff57..7c15334f3ff2 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -129,9 +129,10 @@ enum {
 
 #define SWAP_CLUSTER_MAX 32
 
-#define SWAP_MAP_MAX    0x7fff
-#define SWAP_MAP_BAD    0x8000
-
+#define SWAP_MAP_MAX    0x7ffe
+#define SWAP_MAP_BAD    0x7fff
+#define SWAP_HAS_CACHE  0x8000          /* There is a swap cache of entry. */
+#define SWAP_COUNT_MASK (~SWAP_HAS_CACHE)
 /*
  * The in-memory structure used to track swap areas.
  */
@@ -235,7 +236,6 @@ static inline int zone_reclaim(struct zone *z, gfp_t mask, unsigned int order)
 }
 #endif
 
-#ifdef CONFIG_UNEVICTABLE_LRU
 extern int page_evictable(struct page *page, struct vm_area_struct *vma);
 extern void scan_mapping_unevictable_pages(struct address_space *);
 
@@ -244,24 +244,6 @@ extern int scan_unevictable_handler(struct ctl_table *, int, struct file *,
                                         void __user *, size_t *, loff_t *);
 extern int scan_unevictable_register_node(struct node *node);
 extern void scan_unevictable_unregister_node(struct node *node);
-#else
-static inline int page_evictable(struct page *page,
-                                                struct vm_area_struct *vma)
-{
-        return 1;
-}
-
-static inline void scan_mapping_unevictable_pages(struct address_space *mapping)
-{
-}
-
-static inline int scan_unevictable_register_node(struct node *node)
-{
-        return 0;
-}
-
-static inline void scan_unevictable_unregister_node(struct node *node) { }
-#endif
 
 extern int kswapd_run(int nid);
 
@@ -274,7 +256,7 @@ extern void swap_unplug_io_fn(struct backing_dev_info *, struct page *);
 
 #ifdef CONFIG_SWAP
 /* linux/mm/page_io.c */
-extern int swap_readpage(struct file *, struct page *);
+extern int swap_readpage(struct page *);
 extern int swap_writepage(struct page *page, struct writeback_control *wbc);
 extern void end_swap_bio_read(struct bio *bio, int err);
 
@@ -300,9 +282,11 @@ extern long total_swap_pages;
 extern void si_swapinfo(struct sysinfo *);
 extern swp_entry_t get_swap_page(void);
 extern swp_entry_t get_swap_page_of_type(int);
-extern int swap_duplicate(swp_entry_t);
+extern void swap_duplicate(swp_entry_t);
+extern int swapcache_prepare(swp_entry_t);
 extern int valid_swaphandles(swp_entry_t, unsigned long *);
 extern void swap_free(swp_entry_t);
+extern void swapcache_free(swp_entry_t, struct page *page);
 extern int free_swap_and_cache(swp_entry_t);
 extern int swap_type_of(dev_t, sector_t, struct block_device **);
 extern unsigned int count_swap_pages(int, int);
@@ -314,8 +298,8 @@ extern int try_to_free_swap(struct page *);
 struct backing_dev_info;
 
 /* linux/mm/thrash.c */
-extern struct mm_struct * swap_token_mm;
-extern void grab_swap_token(void);
+extern struct mm_struct *swap_token_mm;
+extern void grab_swap_token(struct mm_struct *);
 extern void __put_swap_token(struct mm_struct *);
 
 static inline int has_swap_token(struct mm_struct *mm)
@@ -335,10 +319,11 @@ static inline void disable_swap_token(void)
 }
 
 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
-extern void mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent);
+extern void
+mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout);
 #else
 static inline void
-mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
+mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout)
 {
 }
 #endif
@@ -370,12 +355,20 @@ static inline void show_swap_cache_info(void)
 }
 
 #define free_swap_and_cache(swp)        is_migration_entry(swp)
-#define swap_duplicate(swp)             is_migration_entry(swp)
+#define swapcache_prepare(swp)          is_migration_entry(swp)
+
+static inline void swap_duplicate(swp_entry_t swp)
+{
+}
 
 static inline void swap_free(swp_entry_t swp)
 {
 }
 
+static inline void swapcache_free(swp_entry_t swp, struct page *page)
+{
+}
+
 static inline struct page *swapin_readahead(swp_entry_t swp, gfp_t gfp_mask,
                         struct vm_area_struct *vma, unsigned long addr)
 {
@@ -426,16 +419,10 @@ static inline swp_entry_t get_swap_page(void)
 }
 
 /* linux/mm/thrash.c */
-#define put_swap_token(x) do { } while(0)
-#define grab_swap_token()  do { } while(0)
-#define has_swap_token(x) 0
-#define disable_swap_token() do { } while(0)
-
-static inline int mem_cgroup_cache_charge_swapin(struct page *page,
-                        struct mm_struct *mm, gfp_t mask, bool locked)
-{
-        return 0;
-}
+#define put_swap_token(mm)      do { } while (0)
+#define grab_swap_token(mm)     do { } while (0)
+#define has_swap_token(mm)      0
+#define disable_swap_token()    do { } while (0)
 
 static inline void
 mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index ac9ff54f7cb3..cb1a6631b8f4 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -29,7 +29,8 @@ extern void *swiotlb_alloc(unsigned order, unsigned long nslabs);
 
 extern dma_addr_t swiotlb_phys_to_bus(struct device *hwdev,
                                       phys_addr_t address);
-extern phys_addr_t swiotlb_bus_to_phys(dma_addr_t address);
+extern phys_addr_t swiotlb_bus_to_phys(struct device *hwdev,
+                                       dma_addr_t address);
 
 extern int swiotlb_arch_range_needs_mapping(phys_addr_t paddr, size_t size);
 
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 30520844b8da..80de7003d8c2 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -55,6 +55,7 @@ struct compat_timeval;
 struct robust_list_head;
 struct getcpu_cache;
 struct old_linux_dirent;
+struct perf_counter_attr;
 
 #include <linux/types.h>
 #include <linux/aio_abi.h>
@@ -320,6 +321,8 @@ asmlinkage long sys_rt_sigtimedwait(const sigset_t __user *uthese,
                                 siginfo_t __user *uinfo,
                                 const struct timespec __user *uts,
                                 size_t sigsetsize);
+asmlinkage long sys_rt_tgsigqueueinfo(pid_t tgid, pid_t  pid, int sig,
+                siginfo_t __user *uinfo);
 asmlinkage long sys_kill(int pid, int sig);
 asmlinkage long sys_tgkill(int tgid, int pid, int sig);
 asmlinkage long sys_tkill(int pid, int sig);
@@ -433,6 +436,7 @@ asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
 asmlinkage long sys_fcntl64(unsigned int fd,
                                 unsigned int cmd, unsigned long arg);
 #endif
+asmlinkage long sys_pipe(int __user *fildes);
 asmlinkage long sys_pipe2(int __user *fildes, int flags);
 asmlinkage long sys_dup(unsigned int fildes);
 asmlinkage long sys_dup2(unsigned int oldfd, unsigned int newfd);
@@ -750,9 +754,11 @@ asmlinkage long sys_pselect6(int, fd_set __user *, fd_set __user *,
 asmlinkage long sys_ppoll(struct pollfd __user *, unsigned int,
                           struct timespec __user *, const sigset_t __user *,
                           size_t);
-asmlinkage long sys_pipe2(int __user *, int);
-asmlinkage long sys_pipe(int __user *);
 
 int kernel_execve(const char *filename, char *const argv[], char *const envp[]);
 
+
+asmlinkage long sys_perf_counter_open(
+                struct perf_counter_attr __user *attr_uptr,
+                pid_t pid, int cpu, int group_fd, unsigned long flags);
 #endif
diff --git a/include/linux/sysrq.h b/include/linux/sysrq.h
index 98a1d8cfb73d..99adcdc0d3ca 100644
--- a/include/linux/sysrq.h
+++ b/include/linux/sysrq.h
@@ -14,6 +14,8 @@
 #ifndef _LINUX_SYSRQ_H
 #define _LINUX_SYSRQ_H
 
+#include <linux/errno.h>
+
 struct pt_regs;
 struct tty_struct;
 
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 9d5078bd23a3..8afac76cd748 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -377,7 +377,7 @@ struct tcp_sock {
         unsigned int            keepalive_time;   /* time before keep alive takes place */
         unsigned int            keepalive_intvl;  /* time interval between keep alive probes */
 
-        unsigned long last_synq_overflow; 
+        int                     linger2;
 
 /* Receiver side RTT estimation */
         struct {
@@ -406,8 +406,6 @@ struct tcp_sock {
 /* TCP MD5 Signagure Option information */
         struct tcp_md5sig_info  *md5sig_info;
 #endif
-
-        int                     linger2;
 };
 
 static inline struct tcp_sock *tcp_sk(const struct sock *sk)
diff --git a/include/linux/thread_info.h b/include/linux/thread_info.h
index e6b820f8b56b..a8cc4e13434c 100644
--- a/include/linux/thread_info.h
+++ b/include/linux/thread_info.h
@@ -21,13 +21,14 @@ struct restart_block {
                 struct {
                         unsigned long arg0, arg1, arg2, arg3;
                 };
-                /* For futex_wait */
+                /* For futex_wait and futex_wait_requeue_pi */
                 struct {
                         u32 *uaddr;
                         u32 val;
                         u32 flags;
                         u32 bitset;
                         u64 time;
+                        u32 *uaddr2;
                 } futex;
                 /* For nanosleep */
                 struct {
diff --git a/include/linux/tick.h b/include/linux/tick.h
index 469b82d88b3b..0482229c07db 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -97,10 +97,12 @@ extern void tick_clock_notify(void);
 extern int tick_check_oneshot_change(int allow_nohz);
 extern struct tick_sched *tick_get_tick_sched(int cpu);
 extern void tick_check_idle(int cpu);
+extern int tick_oneshot_mode_active(void);
 # else
 static inline void tick_clock_notify(void) { }
 static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }
 static inline void tick_check_idle(int cpu) { }
+static inline int tick_oneshot_mode_active(void) { return 0; }
 # endif
 
 #else /* CONFIG_GENERIC_CLOCKEVENTS */
@@ -109,6 +111,7 @@ static inline void tick_cancel_sched_timer(int cpu) { }
 static inline void tick_clock_notify(void) { }
 static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }
 static inline void tick_check_idle(int cpu) { }
+static inline int tick_oneshot_mode_active(void) { return 0; }
 #endif /* !CONFIG_GENERIC_CLOCKEVENTS */
 
 # ifdef CONFIG_NO_HZ
diff --git a/include/linux/time.h b/include/linux/time.h
index 242f62499bb7..ea16c1a01d51 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -113,6 +113,21 @@ struct timespec current_kernel_time(void);
 #define CURRENT_TIME            (current_kernel_time())
 #define CURRENT_TIME_SEC        ((struct timespec) { get_seconds(), 0 })
 
+/* Some architectures do not supply their own clocksource.
+ * This is mainly the case in architectures that get their
+ * inter-tick times by reading the counter on their interval
+ * timer. Since these timers wrap every tick, they're not really
+ * useful as clocksources. Wrapping them to act like one is possible
+ * but not very efficient. So we provide a callout these arches
+ * can implement for use with the jiffies clocksource to provide
+ * finer then tick granular time.
+ */
+#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
+extern u32 arch_gettimeoffset(void);
+#else
+static inline u32 arch_gettimeoffset(void) { return 0; }
+#endif
+
 extern void do_gettimeofday(struct timeval *tv);
 extern int do_settimeofday(struct timespec *tv);
 extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
diff --git a/include/linux/timer.h b/include/linux/timer.h
index 6cdb6f3331f1..be62ec2ebea5 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -163,7 +163,10 @@ extern void add_timer_on(struct timer_list *timer, int cpu);
 extern int del_timer(struct timer_list * timer);
 extern int mod_timer(struct timer_list *timer, unsigned long expires);
 extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);
+extern int mod_timer_pinned(struct timer_list *timer, unsigned long expires);
 
+#define TIMER_NOT_PINNED        0
+#define TIMER_PINNED            1
 /*
  * The jiffies value which is added to now, when there is no timer
  * in the timer wheel:
@@ -187,6 +190,8 @@ extern unsigned long get_next_timer_interrupt(unsigned long now);
  */
 #ifdef CONFIG_TIMER_STATS
 
+extern int timer_stats_active;
+
 #define TIMER_STATS_FLAG_DEFERRABLE     0x1
 
 extern void init_timer_stats(void);
@@ -200,6 +205,8 @@ extern void __timer_stats_timer_set_start_info(struct timer_list *timer,
 
 static inline void timer_stats_timer_set_start_info(struct timer_list *timer)
 {
+        if (likely(!timer_stats_active))
+                return;
         __timer_stats_timer_set_start_info(timer, __builtin_return_address(0));
 }
 
diff --git a/include/linux/timex.h b/include/linux/timex.h
index aa3475fcff64..e6967d10d9e5 100644
--- a/include/linux/timex.h
+++ b/include/linux/timex.h
@@ -170,17 +170,37 @@ struct timex {
 #include <asm/timex.h>
 
 /*
- * SHIFT_KG and SHIFT_KF establish the damping of the PLL and are chosen
- * for a slightly underdamped convergence characteristic. SHIFT_KH
- * establishes the damping of the FLL and is chosen by wisdom and black
- * art.
+ * SHIFT_PLL is used as a dampening factor to define how much we
+ * adjust the frequency correction for a given offset in PLL mode.
+ * It also used in dampening the offset correction, to define how
+ * much of the current value in time_offset we correct for each
+ * second. Changing this value changes the stiffness of the ntp
+ * adjustment code. A lower value makes it more flexible, reducing
+ * NTP convergence time. A higher value makes it stiffer, increasing
+ * convergence time, but making the clock more stable.
  *
- * MAXTC establishes the maximum time constant of the PLL. With the
- * SHIFT_KG and SHIFT_KF values given and a time constant range from
- * zero to MAXTC, the PLL will converge in 15 minutes to 16 hours,
- * respectively.
+ * In David Mills' nanokernel reference implementation SHIFT_PLL is 4.
+ * However this seems to increase convergence time much too long.
+ *
+ * https://lists.ntp.org/pipermail/hackers/2008-January/003487.html
+ *
+ * In the above mailing list discussion, it seems the value of 4
+ * was appropriate for other Unix systems with HZ=100, and that
+ * SHIFT_PLL should be decreased as HZ increases. However, Linux's
+ * clock steering implementation is HZ independent.
+ *
+ * Through experimentation, a SHIFT_PLL value of 2 was found to allow
+ * for fast convergence (very similar to the NTPv3 code used prior to
+ * v2.6.19), with good clock stability.
+ *
+ *
+ * SHIFT_FLL is used as a dampening factor to define how much we
+ * adjust the frequency correction for a given offset in FLL mode.
+ * In David Mills' nanokernel reference implementation SHIFT_FLL is 2.
+ *
+ * MAXTC establishes the maximum time constant of the PLL.
  */
-#define SHIFT_PLL       4       /* PLL frequency factor (shift) */
+#define SHIFT_PLL       2       /* PLL frequency factor (shift) */
 #define SHIFT_FLL       2       /* FLL frequency factor (shift) */
 #define MAXTC           10      /* maximum time constant (shift) */
 
@@ -192,10 +212,10 @@ struct timex {
 #define SHIFT_USEC 16           /* frequency offset scale (shift) */
 #define PPM_SCALE ((s64)NSEC_PER_USEC << (NTP_SCALE_SHIFT - SHIFT_USEC))
 #define PPM_SCALE_INV_SHIFT 19
-#define PPM_SCALE_INV ((1ll << (PPM_SCALE_INV_SHIFT + NTP_SCALE_SHIFT)) / \
+#define PPM_SCALE_INV ((1LL << (PPM_SCALE_INV_SHIFT + NTP_SCALE_SHIFT)) / \
                        PPM_SCALE + 1)
 
-#define MAXPHASE 500000000l     /* max phase error (ns) */
+#define MAXPHASE 500000000L     /* max phase error (ns) */
 #define MAXFREQ 500000          /* max frequency error (ns/s) */
 #define MAXFREQ_SCALED ((s64)MAXFREQ << NTP_SCALE_SHIFT)
 #define MINSEC 256              /* min interval between updates (s) */
@@ -260,6 +280,9 @@ extern int do_adjtimex(struct timex *);
 
 int read_current_timer(unsigned long *timer_val);
 
+/* The clock frequency of the i8253/i8254 PIT */
+#define PIT_TICK_RATE 1193182ul
+
 #endif /* KERNEL */
 
 #endif /* LINUX_TIMEX_H */
diff --git a/include/linux/trace_seq.h b/include/linux/trace_seq.h
new file mode 100644
index 000000000000..c134dd1fe6b6
--- /dev/null
+++ b/include/linux/trace_seq.h
@@ -0,0 +1,94 @@
+#ifndef _LINUX_TRACE_SEQ_H
+#define _LINUX_TRACE_SEQ_H
+
+#include <linux/fs.h>
+
+#include <asm/page.h>
+
+/*
+ * Trace sequences are used to allow a function to call several other functions
+ * to create a string of data to use (up to a max of PAGE_SIZE.
+ */
+
+struct trace_seq {
+        unsigned char           buffer[PAGE_SIZE];
+        unsigned int            len;
+        unsigned int            readpos;
+};
+
+static inline void
+trace_seq_init(struct trace_seq *s)
+{
+        s->len = 0;
+        s->readpos = 0;
+}
+
+/*
+ * Currently only defined when tracing is enabled.
+ */
+#ifdef CONFIG_TRACING
+extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
+        __attribute__ ((format (printf, 2, 0)));
+extern int
+trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary);
+extern void trace_print_seq(struct seq_file *m, struct trace_seq *s);
+extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
+                                 size_t cnt);
+extern int trace_seq_puts(struct trace_seq *s, const char *str);
+extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
+extern int trace_seq_putmem(struct trace_seq *s, const void *mem, size_t len);
+extern int trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
+                                size_t len);
+extern void *trace_seq_reserve(struct trace_seq *s, size_t len);
+extern int trace_seq_path(struct trace_seq *s, struct path *path);
+
+#else /* CONFIG_TRACING */
+static inline int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+{
+        return 0;
+}
+static inline int
+trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
+{
+        return 0;
+}
+
+static inline void trace_print_seq(struct seq_file *m, struct trace_seq *s)
+{
+}
+static inline ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
+                                 size_t cnt)
+{
+        return 0;
+}
+static inline int trace_seq_puts(struct trace_seq *s, const char *str)
+{
+        return 0;
+}
+static inline int trace_seq_putc(struct trace_seq *s, unsigned char c)
+{
+        return 0;
+}
+static inline int
+trace_seq_putmem(struct trace_seq *s, const void *mem, size_t len)
+{
+        return 0;
+}
+static inline int trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
+                                       size_t len)
+{
+        return 0;
+}
+static inline void *trace_seq_reserve(struct trace_seq *s, size_t len)
+{
+        return NULL;
+}
+static inline int trace_seq_path(struct trace_seq *s, struct path *path)
+{
+        return 0;
+}
+#endif /* CONFIG_TRACING */
+
+#endif /* _LINUX_TRACE_SEQ_H */
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index eb96603d92db..17ba82efa483 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -143,7 +143,7 @@ static inline void tracehook_report_syscall_exit(struct pt_regs *regs, int step)
  *
  * Return %LSM_UNSAFE_* bits applied to an exec because of tracing.
  *
- * Called with task_lock() held on @task.
+ * @task->cred_guard_mutex is held by the caller through the do_execve().
  */
 static inline int tracehook_unsafe_exec(struct task_struct *task)
 {
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index d35a7ee7611f..b9dc4ca0246f 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -31,6 +31,8 @@ struct tracepoint {
                                          * Keep in sync with vmlinux.lds.h.
                                          */
 
+#ifndef DECLARE_TRACE
+
 #define TP_PROTO(args...)       args
 #define TP_ARGS(args...)                args
 
@@ -114,6 +116,7 @@ static inline void tracepoint_update_probe_range(struct tracepoint *begin,
         struct tracepoint *end)
 { }
 #endif /* CONFIG_TRACEPOINTS */
+#endif /* DECLARE_TRACE */
 
 /*
  * Connect a probe to a tracepoint.
@@ -154,10 +157,8 @@ static inline void tracepoint_synchronize_unregister(void)
 }
 
 #define PARAMS(args...) args
-#define TRACE_FORMAT(name, proto, args, fmt)            \
-        DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
-
 
+#ifndef TRACE_EVENT
 /*
  * For use with the TRACE_EVENT macro:
  *
@@ -197,7 +198,7 @@ static inline void tracepoint_synchronize_unregister(void)
  *      * This is how the trace record is structured and will
  *      * be saved into the ring buffer. These are the fields
  *      * that will be exposed to user-space in
- *      * /debug/tracing/events/<*>/format.
+ *      * /sys/kernel/debug/tracing/events/<*>/format.
  *      *
  *      * The declared 'local variable' is called '__entry'
  *      *
@@ -257,10 +258,11 @@ static inline void tracepoint_synchronize_unregister(void)
  * tracepoint callback (this is used by programmatic plugins and
  * can also by used by generic instrumentation like SystemTap), and
  * it is also used to expose a structured trace record in
- * /debug/tracing/events/.
+ * /sys/kernel/debug/tracing/events/.
  */
 
 #define TRACE_EVENT(name, proto, args, struct, assign, print)   \
         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
+#endif
 
 #endif
diff --git a/include/linux/tty.h b/include/linux/tty.h
index fc39db95499f..e8c6c9136c97 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -185,7 +185,7 @@ struct tty_port;
 struct tty_port_operations {
         /* Return 1 if the carrier is raised */
         int (*carrier_raised)(struct tty_port *port);
-        void (*raise_dtr_rts)(struct tty_port *port);
+        void (*dtr_rts)(struct tty_port *port, int raise);
 };
         
 struct tty_port {
@@ -201,6 +201,9 @@ struct tty_port {
         unsigned char           *xmit_buf;      /* Optional buffer */
         int                     close_delay;    /* Close port delay */
         int                     closing_wait;   /* Delay for output */
+        int                     drain_delay;    /* Set to zero if no pure time
+                                                   based drain is needed else
+                                                   set to size of fifo */
 };
 
 /*
@@ -223,8 +226,11 @@ struct tty_struct {
         struct tty_driver *driver;
         const struct tty_operations *ops;
         int index;
-        /* The ldisc objects are protected by tty_ldisc_lock at the moment */
-        struct tty_ldisc ldisc;
+
+        /* Protects ldisc changes: Lock tty not pty */
+        struct mutex ldisc_mutex;
+        struct tty_ldisc *ldisc;
+
         struct mutex termios_mutex;
         spinlock_t ctrl_lock;
         /* Termios values are protected by the termios mutex */
@@ -311,6 +317,7 @@ struct tty_struct {
 #define TTY_CLOSING             7       /* ->close() in progress */
 #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 */
@@ -387,6 +394,7 @@ extern void __do_SAK(struct tty_struct *tty);
 extern void disassociate_ctty(int priv);
 extern void no_tty(void);
 extern void tty_flip_buffer_push(struct tty_struct *tty);
+extern void tty_flush_to_ldisc(struct tty_struct *tty);
 extern void tty_buffer_free_all(struct tty_struct *tty);
 extern void tty_buffer_flush(struct tty_struct *tty);
 extern void tty_buffer_init(struct tty_struct *tty);
@@ -403,6 +411,7 @@ extern int tty_termios_hw_change(struct ktermios *a, struct ktermios *b);
 extern struct tty_ldisc *tty_ldisc_ref(struct tty_struct *);
 extern void tty_ldisc_deref(struct tty_ldisc *);
 extern struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *);
+extern void tty_ldisc_hangup(struct tty_struct *tty);
 extern const struct file_operations tty_ldiscs_proc_fops;
 
 extern void tty_wakeup(struct tty_struct *tty);
@@ -425,6 +434,9 @@ extern struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
 extern void tty_release_dev(struct file *filp);
 extern int tty_init_termios(struct tty_struct *tty);
 
+extern struct tty_struct *tty_pair_get_tty(struct tty_struct *tty);
+extern struct tty_struct *tty_pair_get_pty(struct tty_struct *tty);
+
 extern struct mutex tty_mutex;
 
 extern void tty_write_unlock(struct tty_struct *tty);
@@ -438,6 +450,7 @@ extern struct tty_struct *tty_port_tty_get(struct tty_port *port);
 extern void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty);
 extern int tty_port_carrier_raised(struct tty_port *port);
 extern void tty_port_raise_dtr_rts(struct tty_port *port);
+extern void tty_port_lower_dtr_rts(struct tty_port *port);
 extern void tty_port_hangup(struct tty_port *port);
 extern int tty_port_block_til_ready(struct tty_port *port,
                                 struct tty_struct *tty, struct file *filp);
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index bcba84ea2d86..3566129384a4 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -127,7 +127,8 @@
  *      the line discipline are close to full, and it should somehow
  *      signal that no more characters should be sent to the tty.
  *
- *      Optional: Always invoke via tty_throttle();
+ *      Optional: Always invoke via tty_throttle(), called under the
+ *      termios lock.
  * 
  * void (*unthrottle)(struct tty_struct * tty);
  *
@@ -135,7 +136,8 @@
  *      that characters can now be sent to the tty without fear of
  *      overrunning the input buffers of the line disciplines.
  * 
- *      Optional: Always invoke via tty_unthrottle();
+ *      Optional: Always invoke via tty_unthrottle(), called under the
+ *      termios lock.
  *
  * void (*stop)(struct tty_struct *tty);
  *
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index 40f38d896777..0c4ee9b88f85 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -144,7 +144,7 @@ struct tty_ldisc_ops {
 
 struct tty_ldisc {
         struct tty_ldisc_ops *ops;
-        int refcount;
+        atomic_t users;
 };
 
 #define TTY_LDISC_MAGIC 0x5403
diff --git a/include/linux/types.h b/include/linux/types.h
index 5abe354020f9..c42724f8c802 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -131,7 +131,7 @@ typedef		__s64		int64_t;
  *
  * blkcnt_t is the type of the inode's block count.
  */
-#ifdef CONFIG_LBD
+#ifdef CONFIG_LBDAF
 typedef u64 sector_t;
 typedef u64 blkcnt_t;
 #else
diff --git a/include/linux/uio.h b/include/linux/uio.h
index b7fe13883bdb..98c114323a8b 100644
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -19,15 +19,6 @@ struct iovec
         __kernel_size_t iov_len; /* Must be size_t (1003.1g) */
 };
 
-#ifdef __KERNEL__
-
-struct kvec {
-        void *iov_base; /* and that should *never* hold a userland pointer */
-        size_t iov_len;
-};
-
-#endif
-
 /*
  *      UIO_MAXIOV shall be at least 16 1003.1g (5.4.1.1)
  */
@@ -35,6 +26,13 @@ struct kvec {
 #define UIO_FASTIOV     8
 #define UIO_MAXIOV      1024
 
+#ifdef __KERNEL__
+
+struct kvec {
+        void *iov_base; /* and that should *never* hold a userland pointer */
+        size_t iov_len;
+};
+
 /*
  * Total number of bytes covered by an iovec.
  *
@@ -53,5 +51,6 @@ static inline size_t iov_length(const struct iovec *iov, unsigned long nr_segs)
 }
 
 unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to);
+#endif
 
 #endif
diff --git a/include/linux/ultrasound.h b/include/linux/ultrasound.h
index 6b7703e75cec..71339dc531c5 100644
--- a/include/linux/ultrasound.h
+++ b/include/linux/ultrasound.h
@@ -34,7 +34,7 @@
  *              _GUS_VOICEOFF   - Stops voice (no parameters)
  *              _GUS_VOICEFADE  - Stops the voice smoothly.
  *              _GUS_VOICEMODE  - Alters the voice mode, don't start or stop voice (P1=voice mode)
- *              _GUS_VOICEBALA  - Sets voice balence (P1, 0=left, 7=middle and 15=right, default 7)
+ *              _GUS_VOICEBALA  - Sets voice balance (P1, 0=left, 7=middle and 15=right, default 7)
  *              _GUS_VOICEFREQ  - Sets voice (sample) playback frequency (P1=Hz)
  *              _GUS_VOICEVOL   - Sets voice volume (P1=volume, 0xfff=max, 0xeff=half, 0x000=off)
  *              _GUS_VOICEVOL2  - Sets voice volume (P1=volume, 0xfff=max, 0xeff=half, 0x000=off)
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 3aa2cd1f8d08..b1e3c2fbfe11 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -36,6 +36,7 @@ struct wusb_dev;
  *  - configs have one (often) or more interfaces;
  *  - interfaces have one (usually) or more settings;
  *  - each interface setting has zero or (usually) more endpoints.
+ *  - a SuperSpeed endpoint has a companion descriptor
  *
  * And there might be other descriptors mixed in with those.
  *
@@ -44,6 +45,19 @@ struct wusb_dev;
 
 struct ep_device;
 
+/* For SS devices */
+/**
+ * struct usb_host_ss_ep_comp - Valid for SuperSpeed devices only
+ * @desc: endpoint companion descriptor, wMaxPacketSize in native byteorder
+ * @extra: descriptors following this endpoint companion descriptor
+ * @extralen: how many bytes of "extra" are valid
+ */
+struct usb_host_ss_ep_comp {
+        struct usb_ss_ep_comp_descriptor        desc;
+        unsigned char                           *extra;   /* Extra descriptors */
+        int                                     extralen;
+};
+
 /**
  * struct usb_host_endpoint - host-side endpoint descriptor and queue
  * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder
@@ -51,6 +65,7 @@ struct ep_device;
  * @hcpriv: for use by HCD; typically holds hardware dma queue head (QH)
  *      with one or more transfer descriptors (TDs) per urb
  * @ep_dev: ep_device for sysfs info
+ * @ss_ep_comp: companion descriptor information for this endpoint
  * @extra: descriptors following this endpoint in the configuration
  * @extralen: how many bytes of "extra" are valid
  * @enabled: URBs may be submitted to this endpoint
@@ -63,6 +78,7 @@ struct usb_host_endpoint {
         struct list_head                urb_list;
         void                            *hcpriv;
         struct ep_device                *ep_dev;        /* For sysfs info */
+        struct usb_host_ss_ep_comp      *ss_ep_comp;    /* For SS devices */
 
         unsigned char *extra;   /* Extra descriptors */
         int extralen;
@@ -336,7 +352,6 @@ struct usb_bus {
 #ifdef CONFIG_USB_DEVICEFS
         struct dentry *usbfs_dentry;    /* usbfs dentry entry for the bus */
 #endif
-        struct device *dev;             /* device for this bus */
 
 #if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
         struct mon_bus *mon_bus;        /* non-null when associated */
@@ -363,6 +378,7 @@ struct usb_tt;
  * struct usb_device - kernel's representation of a USB device
  * @devnum: device number; address on a USB bus
  * @devpath: device ID string for use in messages (e.g., /port/...)
+ * @route: tree topology hex string for use with xHCI
  * @state: device state: configured, not attached, etc.
  * @speed: device speed: high/full/low (or error)
  * @tt: Transaction Translator info; used with low/full speed dev, highspeed hub
@@ -420,6 +436,7 @@ struct usb_tt;
  * @skip_sys_resume: skip the next system resume
  * @wusb_dev: if this is a Wireless USB device, link to the WUSB
  *      specific data for the device.
+ * @slot_id: Slot ID assigned by xHCI
  *
  * Notes:
  * Usbcore drivers should not set usbdev->state directly.  Instead use
@@ -428,6 +445,7 @@ struct usb_tt;
 struct usb_device {
         int             devnum;
         char            devpath [16];
+        u32             route;
         enum usb_device_state   state;
         enum usb_device_speed   speed;
 
@@ -503,6 +521,7 @@ struct usb_device {
         unsigned skip_sys_resume:1;
 #endif
         struct wusb_dev *wusb_dev;
+        int slot_id;
 };
 #define to_usb_device(d) container_of(d, struct usb_device, dev)
 
@@ -903,6 +922,8 @@ extern struct bus_type usb_bus_type;
 /**
  * struct usb_class_driver - identifies a USB driver that wants to use the USB major number
  * @name: the usb class device name for this driver.  Will show up in sysfs.
+ * @nodename: Callback to provide a naming hint for a possible
+ *      device node to create.
  * @fops: pointer to the struct file_operations of this driver.
  * @minor_base: the start of the minor range for this driver.
  *
@@ -912,6 +933,7 @@ extern struct bus_type usb_bus_type;
  */
 struct usb_class_driver {
         char *name;
+        char *(*nodename)(struct device *dev);
         const struct file_operations *fops;
         int minor_base;
 };
@@ -1024,6 +1046,8 @@ typedef void (*usb_complete_t)(struct urb *);
  *      the device driver is saying that it provided this DMA address,
  *      which the host controller driver should use in preference to the
  *      transfer_buffer.
+ * @sg: scatter gather buffer list
+ * @num_sgs: number of entries in the sg list
  * @transfer_buffer_length: How big is transfer_buffer.  The transfer may
  *      be broken up into chunks according to the current maximum packet
  *      size for the endpoint, which is a function of the configuration
@@ -1041,7 +1065,9 @@ typedef void (*usb_complete_t)(struct urb *);
  * @setup_dma: For control transfers with URB_NO_SETUP_DMA_MAP set, the
  *      device driver has provided this DMA address for the setup packet.
  *      The host controller driver should use this in preference to
- *      setup_packet.
+ *      setup_packet, but the HCD may chose to ignore the address if it must
+ *      copy the setup packet into internal structures.  Therefore, setup_packet
+ *      must always point to a valid buffer.
  * @start_frame: Returns the initial frame for isochronous transfers.
  * @number_of_packets: Lists the number of ISO transfer buffers.
  * @interval: Specifies the polling interval for interrupt or isochronous
@@ -1177,6 +1203,8 @@ struct urb {
         unsigned int transfer_flags;    /* (in) URB_SHORT_NOT_OK | ...*/
         void *transfer_buffer;          /* (in) associated data buffer */
         dma_addr_t transfer_dma;        /* (in) dma addr for transfer_buffer */
+        struct usb_sg_request *sg;      /* (in) scatter gather buffer list */
+        int num_sgs;                    /* (in) number of entries in the sg list */
         u32 transfer_buffer_length;     /* (in) data buffer length */
         u32 actual_length;              /* (return) actual transfer length */
         unsigned char *setup_packet;    /* (in) setup packet (control only) */
@@ -1422,8 +1450,8 @@ struct usb_sg_request {
         int                     status;
         size_t                  bytes;
 
-        /*
-         * members below are private: to usbcore,
+        /* private:
+         * members below are private to usbcore,
          * and are not provided for driver access!
          */
         spinlock_t              lock;
@@ -1558,6 +1586,9 @@ extern void usb_unregister_notify(struct notifier_block *nb);
 #define err(format, arg...) printk(KERN_ERR KBUILD_MODNAME ": " \
         format "\n" , ## arg)
 
+/* debugfs stuff */
+extern struct dentry *usb_debug_root;
+
 #endif  /* __KERNEL__ */
 
 #endif
diff --git a/include/linux/usb/audio.h b/include/linux/usb/audio.h
index 8cb025fef634..b5744bc218ab 100644
--- a/include/linux/usb/audio.h
+++ b/include/linux/usb/audio.h
@@ -24,10 +24,75 @@
 #define USB_SUBCLASS_AUDIOCONTROL       0x01
 #define USB_SUBCLASS_AUDIOSTREAMING     0x02
 #define USB_SUBCLASS_MIDISTREAMING      0x03
+#define USB_SUBCLASS_VENDOR_SPEC        0xff
 
+/* A.5 Audio Class-Specific AC interface Descriptor Subtypes*/
+#define HEADER                          0x01
+#define INPUT_TERMINAL                  0x02
+#define OUTPUT_TERMINAL                 0x03
+#define MIXER_UNIT                      0x04
+#define SELECTOR_UNIT                   0x05
+#define FEATURE_UNIT                    0x06
+#define PROCESSING_UNIT                 0x07
+#define EXTENSION_UNIT                  0x08
+
+#define AS_GENERAL                      0x01
+#define FORMAT_TYPE                     0x02
+#define FORMAT_SPECIFIC                 0x03
+
+#define EP_GENERAL                      0x01
+
+#define MS_GENERAL                      0x01
+#define MIDI_IN_JACK                    0x02
+#define MIDI_OUT_JACK                   0x03
+
+/* endpoint attributes */
+#define EP_ATTR_MASK                    0x0c
+#define EP_ATTR_ASYNC                   0x04
+#define EP_ATTR_ADAPTIVE                0x08
+#define EP_ATTR_SYNC                    0x0c
+
+/* cs endpoint attributes */
+#define EP_CS_ATTR_SAMPLE_RATE          0x01
+#define EP_CS_ATTR_PITCH_CONTROL        0x02
+#define EP_CS_ATTR_FILL_MAX             0x80
+
+/* Audio Class specific Request Codes */
+#define USB_AUDIO_SET_INTF              0x21
+#define USB_AUDIO_SET_ENDPOINT          0x22
+#define USB_AUDIO_GET_INTF              0xa1
+#define USB_AUDIO_GET_ENDPOINT          0xa2
+
+#define SET_    0x00
+#define GET_    0x80
+
+#define _CUR    0x1
+#define _MIN    0x2
+#define _MAX    0x3
+#define _RES    0x4
+#define _MEM    0x5
+
+#define SET_CUR         (SET_ | _CUR)
+#define GET_CUR         (GET_ | _CUR)
+#define SET_MIN         (SET_ | _MIN)
+#define GET_MIN         (GET_ | _MIN)
+#define SET_MAX         (SET_ | _MAX)
+#define GET_MAX         (GET_ | _MAX)
+#define SET_RES         (SET_ | _RES)
+#define GET_RES         (GET_ | _RES)
+#define SET_MEM         (SET_ | _MEM)
+#define GET_MEM         (GET_ | _MEM)
+
+#define GET_STAT        0xff
+
+#define USB_AC_TERMINAL_UNDEFINED       0x100
+#define USB_AC_TERMINAL_STREAMING       0x101
+#define USB_AC_TERMINAL_VENDOR_SPEC     0x1FF
+
+/* Terminal Control Selectors */
 /* 4.3.2  Class-Specific AC Interface Descriptor */
 struct usb_ac_header_descriptor {
-        __u8  bLength;                  /* 8+n */
+        __u8  bLength;                  /* 8 + n */
         __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
         __u8  bDescriptorSubtype;       /* USB_MS_HEADER */
         __le16 bcdADC;                  /* 0x0100 */
@@ -36,7 +101,7 @@ struct usb_ac_header_descriptor {
         __u8  baInterfaceNr[];          /* [n] */
 } __attribute__ ((packed));
 
-#define USB_DT_AC_HEADER_SIZE(n)        (8+(n))
+#define USB_DT_AC_HEADER_SIZE(n)        (8 + (n))
 
 /* As above, but more useful for defining your own descriptors: */
 #define DECLARE_USB_AC_HEADER_DESCRIPTOR(n)                     \
@@ -50,4 +115,200 @@ struct usb_ac_header_descriptor_##n {				\
         __u8  baInterfaceNr[n];                                 \
 } __attribute__ ((packed))
 
+/* 4.3.2.1 Input Terminal Descriptor */
+struct usb_input_terminal_descriptor {
+        __u8  bLength;                  /* in bytes: 12 */
+        __u8  bDescriptorType;          /* CS_INTERFACE descriptor type */
+        __u8  bDescriptorSubtype;       /* INPUT_TERMINAL descriptor subtype */
+        __u8  bTerminalID;              /* Constant uniquely terminal ID */
+        __le16 wTerminalType;           /* USB Audio Terminal Types */
+        __u8  bAssocTerminal;           /* ID of the Output Terminal associated */
+        __u8  bNrChannels;              /* Number of logical output channels */
+        __le16 wChannelConfig;
+        __u8  iChannelNames;
+        __u8  iTerminal;
+} __attribute__ ((packed));
+
+#define USB_DT_AC_INPUT_TERMINAL_SIZE                   12
+
+#define USB_AC_INPUT_TERMINAL_UNDEFINED                 0x200
+#define USB_AC_INPUT_TERMINAL_MICROPHONE                0x201
+#define USB_AC_INPUT_TERMINAL_DESKTOP_MICROPHONE        0x202
+#define USB_AC_INPUT_TERMINAL_PERSONAL_MICROPHONE       0x203
+#define USB_AC_INPUT_TERMINAL_OMNI_DIR_MICROPHONE       0x204
+#define USB_AC_INPUT_TERMINAL_MICROPHONE_ARRAY          0x205
+#define USB_AC_INPUT_TERMINAL_PROC_MICROPHONE_ARRAY     0x206
+
+/* 4.3.2.2 Output Terminal Descriptor */
+struct usb_output_terminal_descriptor {
+        __u8  bLength;                  /* in bytes: 9 */
+        __u8  bDescriptorType;          /* CS_INTERFACE descriptor type */
+        __u8  bDescriptorSubtype;       /* OUTPUT_TERMINAL descriptor subtype */
+        __u8  bTerminalID;              /* Constant uniquely terminal ID */
+        __le16 wTerminalType;           /* USB Audio Terminal Types */
+        __u8  bAssocTerminal;           /* ID of the Input Terminal associated */
+        __u8  bSourceID;                /* ID of the connected Unit or Terminal*/
+        __u8  iTerminal;
+} __attribute__ ((packed));
+
+#define USB_DT_AC_OUTPUT_TERMINAL_SIZE                          9
+
+#define USB_AC_OUTPUT_TERMINAL_UNDEFINED                        0x300
+#define USB_AC_OUTPUT_TERMINAL_SPEAKER                          0x301
+#define USB_AC_OUTPUT_TERMINAL_HEADPHONES                       0x302
+#define USB_AC_OUTPUT_TERMINAL_HEAD_MOUNTED_DISPLAY_AUDIO       0x303
+#define USB_AC_OUTPUT_TERMINAL_DESKTOP_SPEAKER                  0x304
+#define USB_AC_OUTPUT_TERMINAL_ROOM_SPEAKER                     0x305
+#define USB_AC_OUTPUT_TERMINAL_COMMUNICATION_SPEAKER            0x306
+#define USB_AC_OUTPUT_TERMINAL_LOW_FREQ_EFFECTS_SPEAKER         0x307
+
+/* Set bControlSize = 2 as default setting */
+#define USB_DT_AC_FEATURE_UNIT_SIZE(ch)         (7 + ((ch) + 1) * 2)
+
+/* As above, but more useful for defining your own descriptors: */
+#define DECLARE_USB_AC_FEATURE_UNIT_DESCRIPTOR(ch)              \
+struct usb_ac_feature_unit_descriptor_##ch {                    \
+        __u8  bLength;                                          \
+        __u8  bDescriptorType;                                  \
+        __u8  bDescriptorSubtype;                               \
+        __u8  bUnitID;                                          \
+        __u8  bSourceID;                                        \
+        __u8  bControlSize;                                     \
+        __le16 bmaControls[ch + 1];                             \
+        __u8  iFeature;                                         \
+} __attribute__ ((packed))
+
+/* 4.5.2 Class-Specific AS Interface Descriptor */
+struct usb_as_header_descriptor {
+        __u8  bLength;                  /* in bytes: 7 */
+        __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
+        __u8  bDescriptorSubtype;       /* AS_GENERAL */
+        __u8  bTerminalLink;            /* Terminal ID of connected Terminal */
+        __u8  bDelay;                   /* Delay introduced by the data path */
+        __le16 wFormatTag;              /* The Audio Data Format */
+} __attribute__ ((packed));
+
+#define USB_DT_AS_HEADER_SIZE           7
+
+#define USB_AS_AUDIO_FORMAT_TYPE_I_UNDEFINED    0x0
+#define USB_AS_AUDIO_FORMAT_TYPE_I_PCM          0x1
+#define USB_AS_AUDIO_FORMAT_TYPE_I_PCM8         0x2
+#define USB_AS_AUDIO_FORMAT_TYPE_I_IEEE_FLOAT   0x3
+#define USB_AS_AUDIO_FORMAT_TYPE_I_ALAW         0x4
+#define USB_AS_AUDIO_FORMAT_TYPE_I_MULAW        0x5
+
+struct usb_as_format_type_i_continuous_descriptor {
+        __u8  bLength;                  /* in bytes: 8 + (ns * 3) */
+        __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
+        __u8  bDescriptorSubtype;       /* FORMAT_TYPE */
+        __u8  bFormatType;              /* FORMAT_TYPE_1 */
+        __u8  bNrChannels;              /* physical channels in the stream */
+        __u8  bSubframeSize;            /* */
+        __u8  bBitResolution;
+        __u8  bSamFreqType;
+        __u8  tLowerSamFreq[3];
+        __u8  tUpperSamFreq[3];
+} __attribute__ ((packed));
+
+#define USB_AS_FORMAT_TYPE_I_CONTINUOUS_DESC_SIZE       14
+
+struct usb_as_formate_type_i_discrete_descriptor {
+        __u8  bLength;                  /* in bytes: 8 + (ns * 3) */
+        __u8  bDescriptorType;          /* USB_DT_CS_INTERFACE */
+        __u8  bDescriptorSubtype;       /* FORMAT_TYPE */
+        __u8  bFormatType;              /* FORMAT_TYPE_1 */
+        __u8  bNrChannels;              /* physical channels in the stream */
+        __u8  bSubframeSize;            /* */
+        __u8  bBitResolution;
+        __u8  bSamFreqType;
+        __u8  tSamFreq[][3];
+} __attribute__ ((packed));
+
+#define DECLARE_USB_AS_FORMAT_TYPE_I_DISCRETE_DESC(n)           \
+struct usb_as_formate_type_i_discrete_descriptor_##n {          \
+        __u8  bLength;                                          \
+        __u8  bDescriptorType;                                  \
+        __u8  bDescriptorSubtype;                               \
+        __u8  bFormatType;                                      \
+        __u8  bNrChannels;                                      \
+        __u8  bSubframeSize;                                    \
+        __u8  bBitResolution;                                   \
+        __u8  bSamFreqType;                                     \
+        __u8  tSamFreq[n][3];                                   \
+} __attribute__ ((packed))
+
+#define USB_AS_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(n)      (8 + (n * 3))
+
+#define USB_AS_FORMAT_TYPE_UNDEFINED    0x0
+#define USB_AS_FORMAT_TYPE_I            0x1
+#define USB_AS_FORMAT_TYPE_II           0x2
+#define USB_AS_FORMAT_TYPE_III          0x3
+
+#define USB_AS_ENDPOINT_ASYNC           (1 << 2)
+#define USB_AS_ENDPOINT_ADAPTIVE        (2 << 2)
+#define USB_AS_ENDPOINT_SYNC            (3 << 2)
+
+struct usb_as_iso_endpoint_descriptor {
+        __u8  bLength;                  /* in bytes: 7 */
+        __u8  bDescriptorType;          /* USB_DT_CS_ENDPOINT */
+        __u8  bDescriptorSubtype;       /* EP_GENERAL */
+        __u8  bmAttributes;
+        __u8  bLockDelayUnits;
+        __le16 wLockDelay;
+};
+#define USB_AS_ISO_ENDPOINT_DESC_SIZE   7
+
+#define FU_CONTROL_UNDEFINED            0x00
+#define MUTE_CONTROL                    0x01
+#define VOLUME_CONTROL                  0x02
+#define BASS_CONTROL                    0x03
+#define MID_CONTROL                     0x04
+#define TREBLE_CONTROL                  0x05
+#define GRAPHIC_EQUALIZER_CONTROL       0x06
+#define AUTOMATIC_GAIN_CONTROL          0x07
+#define DELAY_CONTROL                   0x08
+#define BASS_BOOST_CONTROL              0x09
+#define LOUDNESS_CONTROL                0x0a
+
+#define FU_MUTE         (1 << (MUTE_CONTROL - 1))
+#define FU_VOLUME       (1 << (VOLUME_CONTROL - 1))
+#define FU_BASS         (1 << (BASS_CONTROL - 1))
+#define FU_MID          (1 << (MID_CONTROL - 1))
+#define FU_TREBLE       (1 << (TREBLE_CONTROL - 1))
+#define FU_GRAPHIC_EQ   (1 << (GRAPHIC_EQUALIZER_CONTROL - 1))
+#define FU_AUTO_GAIN    (1 << (AUTOMATIC_GAIN_CONTROL - 1))
+#define FU_DELAY        (1 << (DELAY_CONTROL - 1))
+#define FU_BASS_BOOST   (1 << (BASS_BOOST_CONTROL - 1))
+#define FU_LOUDNESS     (1 << (LOUDNESS_CONTROL - 1))
+
+struct usb_audio_control {
+        struct list_head list;
+        const char *name;
+        u8 type;
+        int data[5];
+        int (*set)(struct usb_audio_control *con, u8 cmd, int value);
+        int (*get)(struct usb_audio_control *con, u8 cmd);
+};
+
+static inline int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value)
+{
+        con->data[cmd] = value;
+
+        return 0;
+}
+
+static inline int generic_get_cmd(struct usb_audio_control *con, u8 cmd)
+{
+        return con->data[cmd];
+}
+
+struct usb_audio_control_selector {
+        struct list_head list;
+        struct list_head control;
+        u8 id;
+        const char *name;
+        u8 type;
+        struct usb_descriptor_header *desc;
+};
+
 #endif /* __LINUX_USB_AUDIO_H */
diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h
index b145119a90da..93223638f702 100644
--- a/include/linux/usb/ch9.h
+++ b/include/linux/usb/ch9.h
@@ -191,6 +191,8 @@ struct usb_ctrlrequest {
 #define USB_DT_WIRE_ADAPTER             0x21
 #define USB_DT_RPIPE                    0x22
 #define USB_DT_CS_RADIO_CONTROL         0x23
+/* From the USB 3.0 spec */
+#define USB_DT_SS_ENDPOINT_COMP         0x30
 
 /* Conventional codes for class-specific descriptors.  The convention is
  * defined in the USB "Common Class" Spec (3.11).  Individual class specs
@@ -535,6 +537,20 @@ static inline int usb_endpoint_is_isoc_out(
 
 /*-------------------------------------------------------------------------*/
 
+/* USB_DT_SS_ENDPOINT_COMP: SuperSpeed Endpoint Companion descriptor */
+struct usb_ss_ep_comp_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __u8  bMaxBurst;
+        __u8  bmAttributes;
+        __u16 wBytesPerInterval;
+} __attribute__ ((packed));
+
+#define USB_DT_SS_EP_COMP_SIZE          6
+
+/*-------------------------------------------------------------------------*/
+
 /* USB_DT_DEVICE_QUALIFIER: Device Qualifier descriptor */
 struct usb_qualifier_descriptor {
         __u8  bLength;
@@ -752,6 +768,7 @@ enum usb_device_speed {
         USB_SPEED_LOW, USB_SPEED_FULL,          /* usb 1.1 */
         USB_SPEED_HIGH,                         /* usb 2.0 */
         USB_SPEED_VARIABLE,                     /* wireless (usb 2.5) */
+        USB_SPEED_SUPER,                        /* usb 3.0 */
 };
 
 enum usb_device_state {
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index acd7b0f06c8a..4f6bb3d2160e 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -124,6 +124,7 @@ struct usb_function {
         void                    (*suspend)(struct usb_function *);
         void                    (*resume)(struct usb_function *);
 
+        /* private: */
         /* internals */
         struct list_head                list;
 };
@@ -219,6 +220,7 @@ struct usb_configuration {
 
         struct usb_composite_dev        *cdev;
 
+        /* private: */
         /* internals */
         struct list_head        list;
         struct list_head        functions;
@@ -321,6 +323,7 @@ struct usb_composite_dev {
 
         struct usb_configuration        *config;
 
+        /* private: */
         /* internals */
         struct usb_device_descriptor    desc;
         struct list_head                configs;
diff --git a/include/linux/usb/langwell_udc.h b/include/linux/usb/langwell_udc.h
new file mode 100644
index 000000000000..c949178a6530
--- /dev/null
+++ b/include/linux/usb/langwell_udc.h
@@ -0,0 +1,310 @@
+/*
+ * Intel Langwell USB Device Controller driver
+ * Copyright (C) 2008-2009, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef __LANGWELL_UDC_H
+#define __LANGWELL_UDC_H
+
+
+/* MACRO defines */
+#define CAP_REG_OFFSET          0x0
+#define OP_REG_OFFSET           0x28
+
+#define DMA_ADDR_INVALID        (~(dma_addr_t)0)
+
+#define DQH_ALIGNMENT           2048
+#define DTD_ALIGNMENT           64
+#define DMA_BOUNDARY            4096
+
+#define EP0_MAX_PKT_SIZE        64
+#define EP_DIR_IN               1
+#define EP_DIR_OUT              0
+
+#define FLUSH_TIMEOUT           1000
+#define RESET_TIMEOUT           1000
+#define SETUPSTAT_TIMEOUT       100
+#define PRIME_TIMEOUT           100
+
+
+/* device memory space registers */
+
+/* Capability Registers, BAR0 + CAP_REG_OFFSET */
+struct langwell_cap_regs {
+        /* offset: 0x0 */
+        u8      caplength;      /* offset of Operational Register */
+        u8      _reserved3;
+        u16     hciversion;     /* H: BCD encoding of host version */
+        u32     hcsparams;      /* H: host port steering logic capability */
+        u32     hccparams;      /* H: host multiple mode control capability */
+#define HCC_LEN BIT(17)         /* Link power management (LPM) capability */
+        u8      _reserved4[0x20-0xc];
+        /* offset: 0x20 */
+        u16     dciversion;     /* BCD encoding of device version */
+        u8      _reserved5[0x24-0x22];
+        u32     dccparams;      /* overall device controller capability */
+#define HOSTCAP BIT(8)          /* host capable */
+#define DEVCAP  BIT(7)          /* device capable */
+#define DEN(d)  \
+        (((d)>>0)&0x1f)         /* bits 4:0, device endpoint number */
+} __attribute__ ((packed));
+
+
+/* Operational Registers, BAR0 + OP_REG_OFFSET */
+struct langwell_op_regs {
+        /* offset: 0x28 */
+        u32     extsts;
+#define EXTS_TI1        BIT(4)  /* general purpose timer interrupt 1 */
+#define EXTS_TI1TI0     BIT(3)  /* general purpose timer interrupt 0 */
+#define EXTS_TI1UPI     BIT(2)  /* USB host periodic interrupt */
+#define EXTS_TI1UAI     BIT(1)  /* USB host asynchronous interrupt */
+#define EXTS_TI1NAKI    BIT(0)  /* NAK interrupt */
+        u32     extintr;
+#define EXTI_TIE1       BIT(4)  /* general purpose timer interrupt enable 1 */
+#define EXTI_TIE0       BIT(3)  /* general purpose timer interrupt enable 0 */
+#define EXTI_UPIE       BIT(2)  /* USB host periodic interrupt enable */
+#define EXTI_UAIE       BIT(1)  /* USB host asynchronous interrupt enable */
+#define EXTI_NAKE       BIT(0)  /* NAK interrupt enable */
+        /* offset: 0x30 */
+        u32     usbcmd;
+#define CMD_HIRD(u)     \
+        (((u)>>24)&0xf)         /* bits 27:24, host init resume duration */
+#define CMD_ITC(u)      \
+        (((u)>>16)&0xff)        /* bits 23:16, interrupt threshold control */
+#define CMD_PPE         BIT(15) /* per-port change events enable */
+#define CMD_ATDTW       BIT(14) /* add dTD tripwire */
+#define CMD_SUTW        BIT(13) /* setup tripwire */
+#define CMD_ASPE        BIT(11) /* asynchronous schedule park mode enable */
+#define CMD_FS2         BIT(10) /* frame list size */
+#define CMD_ASP1        BIT(9)  /* asynchronous schedule park mode count */
+#define CMD_ASP0        BIT(8)
+#define CMD_LR          BIT(7)  /* light host/device controller reset */
+#define CMD_IAA         BIT(6)  /* interrupt on async advance doorbell */
+#define CMD_ASE         BIT(5)  /* asynchronous schedule enable */
+#define CMD_PSE         BIT(4)  /* periodic schedule enable */
+#define CMD_FS1         BIT(3)
+#define CMD_FS0         BIT(2)
+#define CMD_RST         BIT(1)  /* controller reset */
+#define CMD_RUNSTOP     BIT(0)  /* run/stop */
+        u32     usbsts;
+#define STS_PPCI(u)     \
+        (((u)>>16)&0xffff)      /* bits 31:16, port-n change detect */
+#define STS_AS          BIT(15) /* asynchronous schedule status */
+#define STS_PS          BIT(14) /* periodic schedule status */
+#define STS_RCL         BIT(13) /* reclamation */
+#define STS_HCH         BIT(12) /* HC halted */
+#define STS_ULPII       BIT(10) /* ULPI interrupt */
+#define STS_SLI         BIT(8)  /* DC suspend */
+#define STS_SRI         BIT(7)  /* SOF received */
+#define STS_URI         BIT(6)  /* USB reset received */
+#define STS_AAI         BIT(5)  /* interrupt on async advance */
+#define STS_SEI         BIT(4)  /* system error */
+#define STS_FRI         BIT(3)  /* frame list rollover */
+#define STS_PCI         BIT(2)  /* port change detect */
+#define STS_UEI         BIT(1)  /* USB error interrupt */
+#define STS_UI          BIT(0)  /* USB interrupt */
+        u32     usbintr;
+/* bits 31:16, per-port interrupt enable */
+#define INTR_PPCE(u)    (((u)>>16)&0xffff)
+#define INTR_ULPIE      BIT(10) /* ULPI enable */
+#define INTR_SLE        BIT(8)  /* DC sleep/suspend enable */
+#define INTR_SRE        BIT(7)  /* SOF received enable */
+#define INTR_URE        BIT(6)  /* USB reset enable */
+#define INTR_AAE        BIT(5)  /* interrupt on async advance enable */
+#define INTR_SEE        BIT(4)  /* system error enable */
+#define INTR_FRE        BIT(3)  /* frame list rollover enable */
+#define INTR_PCE        BIT(2)  /* port change detect enable */
+#define INTR_UEE        BIT(1)  /* USB error interrupt enable */
+#define INTR_UE         BIT(0)  /* USB interrupt enable */
+        u32     frindex;        /* frame index */
+#define FRINDEX_MASK    (0x3fff << 0)
+        u32     ctrldssegment;  /* not used */
+        u32     deviceaddr;
+#define USBADR_SHIFT    25
+#define USBADR(d)       \
+        (((d)>>25)&0x7f)        /* bits 31:25, device address */
+#define USBADR_MASK     (0x7f << 25)
+#define USBADRA         BIT(24) /* device address advance */
+        u32     endpointlistaddr;/* endpoint list top memory address */
+/* bits 31:11, endpoint list pointer */
+#define EPBASE(d)       (((d)>>11)&0x1fffff)
+#define ENDPOINTLISTADDR_MASK   (0x1fffff << 11)
+        u32     ttctrl;         /* H: TT operatin, not used */
+        /* offset: 0x50 */
+        u32     burstsize;      /* burst size of data movement */
+#define TXPBURST(b)     \
+        (((b)>>8)&0xff)         /* bits 15:8, TX burst length */
+#define RXPBURST(b)     \
+        (((b)>>0)&0xff)         /* bits 7:0, RX burst length */
+        u32     txfilltuning;   /* TX tuning */
+        u32     txttfilltuning; /* H: TX TT tuning */
+        u32     ic_usb;         /* control the IC_USB FS/LS transceiver */
+        /* offset: 0x60 */
+        u32     ulpi_viewport;  /* indirect access to ULPI PHY */
+#define ULPIWU          BIT(31) /* ULPI wakeup */
+#define ULPIRUN         BIT(30) /* ULPI read/write run */
+#define ULPIRW          BIT(29) /* ULPI read/write control */
+#define ULPISS          BIT(27) /* ULPI sync state */
+#define ULPIPORT(u)     \
+        (((u)>>24)&7)           /* bits 26:24, ULPI port number */
+#define ULPIADDR(u)     \
+        (((u)>>16)&0xff)        /* bits 23:16, ULPI data address */
+#define ULPIDATRD(u)    \
+        (((u)>>8)&0xff)         /* bits 15:8, ULPI data read */
+#define ULPIDATWR(u)    \
+        (((u)>>0)&0xff)         /* bits 7:0, ULPI date write */
+        u8      _reserved6[0x70-0x64];
+        /* offset: 0x70 */
+        u32     configflag;     /* H: not used */
+        u32     portsc1;        /* port status */
+#define DA(p)   \
+        (((p)>>25)&0x7f)        /* bits 31:25, device address */
+#define PORTS_SSTS      (BIT(24) | BIT(23))     /* suspend status */
+#define PORTS_WKOC      BIT(22) /* wake on over-current enable */
+#define PORTS_WKDS      BIT(21) /* wake on disconnect enable */
+#define PORTS_WKCN      BIT(20) /* wake on connect enable */
+#define PORTS_PTC(p)    (((p)>>16)&0xf) /* bits 19:16, port test control */
+#define PORTS_PIC       (BIT(15) | BIT(14))     /* port indicator control */
+#define PORTS_PO        BIT(13) /* port owner */
+#define PORTS_PP        BIT(12) /* port power */
+#define PORTS_LS        (BIT(11) | BIT(10))     /* line status */
+#define PORTS_SLP       BIT(9)  /* suspend using L1 */
+#define PORTS_PR        BIT(8)  /* port reset */
+#define PORTS_SUSP      BIT(7)  /* suspend */
+#define PORTS_FPR       BIT(6)  /* force port resume */
+#define PORTS_OCC       BIT(5)  /* over-current change */
+#define PORTS_OCA       BIT(4)  /* over-current active */
+#define PORTS_PEC       BIT(3)  /* port enable/disable change */
+#define PORTS_PE        BIT(2)  /* port enable/disable */
+#define PORTS_CSC       BIT(1)  /* connect status change */
+#define PORTS_CCS       BIT(0)  /* current connect status */
+        u8      _reserved7[0xb4-0x78];
+        /* offset: 0xb4 */
+        u32     devlc;          /* control LPM and each USB port behavior */
+/* bits 31:29, parallel transceiver select */
+#define LPM_PTS(d)      (((d)>>29)&7)
+#define LPM_STS         BIT(28) /* serial transceiver select */
+#define LPM_PTW         BIT(27) /* parallel transceiver width */
+#define LPM_PSPD(d)     (((d)>>25)&3)   /* bits 26:25, port speed */
+#define LPM_PSPD_MASK   (BIT(26) | BIT(25))
+#define LPM_SPEED_FULL  0
+#define LPM_SPEED_LOW   1
+#define LPM_SPEED_HIGH  2
+#define LPM_SRT         BIT(24) /* shorten reset time */
+#define LPM_PFSC        BIT(23) /* port force full speed connect */
+#define LPM_PHCD        BIT(22) /* PHY low power suspend clock disable */
+#define LPM_STL         BIT(16) /* STALL reply to LPM token */
+#define LPM_BA(d)       \
+        (((d)>>1)&0x7ff)        /* bits 11:1, BmAttributes */
+#define LPM_NYT_ACK     BIT(0)  /* NYET/ACK reply to LPM token */
+        u8      _reserved8[0xf4-0xb8];
+        /* offset: 0xf4 */
+        u32     otgsc;          /* On-The-Go status and control */
+#define OTGSC_DPIE      BIT(30) /* data pulse interrupt enable */
+#define OTGSC_MSE       BIT(29) /* 1 ms timer interrupt enable */
+#define OTGSC_BSEIE     BIT(28) /* B session end interrupt enable */
+#define OTGSC_BSVIE     BIT(27) /* B session valid interrupt enable */
+#define OTGSC_ASVIE     BIT(26) /* A session valid interrupt enable */
+#define OTGSC_AVVIE     BIT(25) /* A VBUS valid interrupt enable */
+#define OTGSC_IDIE      BIT(24) /* USB ID interrupt enable */
+#define OTGSC_DPIS      BIT(22) /* data pulse interrupt status */
+#define OTGSC_MSS       BIT(21) /* 1 ms timer interrupt status */
+#define OTGSC_BSEIS     BIT(20) /* B session end interrupt status */
+#define OTGSC_BSVIS     BIT(19) /* B session valid interrupt status */
+#define OTGSC_ASVIS     BIT(18) /* A session valid interrupt status */
+#define OTGSC_AVVIS     BIT(17) /* A VBUS valid interrupt status */
+#define OTGSC_IDIS      BIT(16) /* USB ID interrupt status */
+#define OTGSC_DPS       BIT(14) /* data bus pulsing status */
+#define OTGSC_MST       BIT(13) /* 1 ms timer toggle */
+#define OTGSC_BSE       BIT(12) /* B session end */
+#define OTGSC_BSV       BIT(11) /* B session valid */
+#define OTGSC_ASV       BIT(10) /* A session valid */
+#define OTGSC_AVV       BIT(9)  /* A VBUS valid */
+#define OTGSC_USBID     BIT(8)  /* USB ID */
+#define OTGSC_HABA      BIT(7)  /* hw assist B-disconnect to A-connect */
+#define OTGSC_HADP      BIT(6)  /* hw assist data pulse */
+#define OTGSC_IDPU      BIT(5)  /* ID pullup */
+#define OTGSC_DP        BIT(4)  /* data pulsing */
+#define OTGSC_OT        BIT(3)  /* OTG termination */
+#define OTGSC_HAAR      BIT(2)  /* hw assist auto reset */
+#define OTGSC_VC        BIT(1)  /* VBUS charge */
+#define OTGSC_VD        BIT(0)  /* VBUS discharge */
+        u32     usbmode;
+#define MODE_VBPS       BIT(5)  /* R/W VBUS power select */
+#define MODE_SDIS       BIT(4)  /* R/W stream disable mode */
+#define MODE_SLOM       BIT(3)  /* R/W setup lockout mode */
+#define MODE_ENSE       BIT(2)  /* endian select */
+#define MODE_CM(u)      (((u)>>0)&3)    /* bits 1:0, controller mode */
+#define MODE_IDLE       0
+#define MODE_DEVICE     2
+#define MODE_HOST       3
+        u8      _reserved9[0x100-0xfc];
+        /* offset: 0x100 */
+        u32     endptnak;
+#define EPTN(e)         \
+        (((e)>>16)&0xffff)      /* bits 31:16, TX endpoint NAK */
+#define EPRN(e)         \
+        (((e)>>0)&0xffff)       /* bits 15:0, RX endpoint NAK */
+        u32     endptnaken;
+#define EPTNE(e)        \
+        (((e)>>16)&0xffff)      /* bits 31:16, TX endpoint NAK enable */
+#define EPRNE(e)        \
+        (((e)>>0)&0xffff)       /* bits 15:0, RX endpoint NAK enable */
+        u32     endptsetupstat;
+#define SETUPSTAT_MASK          (0xffff << 0)   /* bits 15:0 */
+#define EP0SETUPSTAT_MASK       1
+        u32     endptprime;
+/* bits 31:16, prime endpoint transmit buffer */
+#define PETB(e)         (((e)>>16)&0xffff)
+/* bits 15:0, prime endpoint receive buffer */
+#define PERB(e)         (((e)>>0)&0xffff)
+        /* offset: 0x110 */
+        u32     endptflush;
+/* bits 31:16, flush endpoint transmit buffer */
+#define FETB(e)         (((e)>>16)&0xffff)
+/* bits 15:0, flush endpoint receive buffer */
+#define FERB(e)         (((e)>>0)&0xffff)
+        u32     endptstat;
+/* bits 31:16, endpoint transmit buffer ready */
+#define ETBR(e)         (((e)>>16)&0xffff)
+/* bits 15:0, endpoint receive buffer ready */
+#define ERBR(e)         (((e)>>0)&0xffff)
+        u32     endptcomplete;
+/* bits 31:16, endpoint transmit complete event */
+#define ETCE(e)         (((e)>>16)&0xffff)
+/* bits 15:0, endpoint receive complete event */
+#define ERCE(e)         (((e)>>0)&0xffff)
+        /* offset: 0x11c */
+        u32     endptctrl[16];
+#define EPCTRL_TXE      BIT(23) /* TX endpoint enable */
+#define EPCTRL_TXR      BIT(22) /* TX data toggle reset */
+#define EPCTRL_TXI      BIT(21) /* TX data toggle inhibit */
+#define EPCTRL_TXT(e)   (((e)>>18)&3)   /* bits 19:18, TX endpoint type */
+#define EPCTRL_TXT_SHIFT        18
+#define EPCTRL_TXD      BIT(17) /* TX endpoint data source */
+#define EPCTRL_TXS      BIT(16) /* TX endpoint STALL */
+#define EPCTRL_RXE      BIT(7)  /* RX endpoint enable */
+#define EPCTRL_RXR      BIT(6)  /* RX data toggle reset */
+#define EPCTRL_RXI      BIT(5)  /* RX data toggle inhibit */
+#define EPCTRL_RXT(e)   (((e)>>2)&3)    /* bits 3:2, RX endpoint type */
+#define EPCTRL_RXT_SHIFT        2       /* bits 19:18, TX endpoint type */
+#define EPCTRL_RXD      BIT(1)  /* RX endpoint data sink */
+#define EPCTRL_RXS      BIT(0)  /* RX endpoint STALL */
+} __attribute__ ((packed));
+
+#endif /* __LANGWELL_UDC_H */
+
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index 1aaa826396a1..2443c0e7a80c 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -80,10 +80,10 @@ struct otg_transceiver {
 
 /* for board-specific init logic */
 extern int otg_set_transceiver(struct otg_transceiver *);
-#ifdef CONFIG_NOP_USB_XCEIV
+
+/* sometimes transceivers are accessed only through e.g. ULPI */
 extern void usb_nop_xceiv_register(void);
 extern void usb_nop_xceiv_unregister(void);
-#endif
 
 
 /* for usb host and peripheral controller drivers */
diff --git a/include/linux/usb/r8a66597.h b/include/linux/usb/r8a66597.h
new file mode 100644
index 000000000000..e9f0384fa20c
--- /dev/null
+++ b/include/linux/usb/r8a66597.h
@@ -0,0 +1,44 @@
+/*
+ * R8A66597 driver platform data
+ *
+ * Copyright (C) 2009  Renesas Solutions Corp.
+ *
+ * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __LINUX_USB_R8A66597_H
+#define __LINUX_USB_R8A66597_H
+
+#define R8A66597_PLATDATA_XTAL_12MHZ    0x01
+#define R8A66597_PLATDATA_XTAL_24MHZ    0x02
+#define R8A66597_PLATDATA_XTAL_48MHZ    0x03
+
+struct r8a66597_platdata {
+        /* This ops can controll port power instead of DVSTCTR register. */
+        void (*port_power)(int port, int power);
+
+        /* (external controller only) set R8A66597_PLATDATA_XTAL_nnMHZ */
+        unsigned        xtal:2;
+
+        /* set one = 3.3V, set zero = 1.5V */
+        unsigned        vif:1;
+
+        /* set one = big endian, set zero = little endian */
+        unsigned        endian:1;
+};
+#endif
+
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 625e9e4639c6..0ec50ba62139 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -15,6 +15,7 @@
 
 #include <linux/kref.h>
 #include <linux/mutex.h>
+#include <linux/sysrq.h>
 
 #define SERIAL_TTY_MAJOR        188     /* Nice legal number now */
 #define SERIAL_TTY_MINORS       254     /* loads of devices :) */
@@ -26,6 +27,13 @@
 /* parity check flag */
 #define RELEVANT_IFLAG(iflag)   (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
 
+enum port_dev_state {
+        PORT_UNREGISTERED,
+        PORT_REGISTERING,
+        PORT_REGISTERED,
+        PORT_UNREGISTERING,
+};
+
 /**
  * usb_serial_port: structure for the specific ports of a device.
  * @serial: pointer back to the struct usb_serial owner of this port.
@@ -91,12 +99,17 @@ struct usb_serial_port {
         int                     write_urb_busy;
         __u8                    bulk_out_endpointAddress;
 
+        int                     tx_bytes_flight;
+        int                     urbs_in_flight;
+
         wait_queue_head_t       write_wait;
         struct work_struct      work;
         char                    throttled;
         char                    throttle_req;
         char                    console;
+        unsigned long           sysrq; /* sysrq timeout */
         struct device           dev;
+        enum port_dev_state     dev_state;
 };
 #define to_usb_serial_port(d) container_of(d, struct usb_serial_port, dev)
 
@@ -181,8 +194,10 @@ static inline void usb_set_serial_data(struct usb_serial *serial, void *data)
  *      This will be called when the struct usb_serial structure is fully set
  *      set up.  Do any local initialization of the device, or any private
  *      memory structure allocation at this point in time.
- * @shutdown: pointer to the driver's shutdown function.  This will be
- *      called when the device is removed from the system.
+ * @disconnect: pointer to the driver's disconnect function.  This will be
+ *      called when the device is unplugged or unbound from the driver.
+ * @release: pointer to the driver's release function.  This will be called
+ *      when the usb_serial data structure is about to be destroyed.
  * @usb_driver: pointer to the struct usb_driver that controls this
  *      device.  This is necessary to allow dynamic ids to be added to
  *      the driver from sysfs.
@@ -207,12 +222,14 @@ struct usb_serial_driver {
         struct device_driver    driver;
         struct usb_driver       *usb_driver;
         struct usb_dynids       dynids;
+        int                     max_in_flight_urbs;
 
         int (*probe)(struct usb_serial *serial, const struct usb_device_id *id);
         int (*attach)(struct usb_serial *serial);
         int (*calc_num_ports) (struct usb_serial *serial);
 
-        void (*shutdown)(struct usb_serial *serial);
+        void (*disconnect)(struct usb_serial *serial);
+        void (*release)(struct usb_serial *serial);
 
         int (*port_probe)(struct usb_serial_port *port);
         int (*port_remove)(struct usb_serial_port *port);
@@ -224,8 +241,7 @@ struct usb_serial_driver {
         /* Called by console with tty = NULL and by tty */
         int  (*open)(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-        void (*close)(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+        void (*close)(struct usb_serial_port *port);
         int  (*write)(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
         /* Called only by the tty layer */
@@ -241,6 +257,10 @@ struct usb_serial_driver {
         int  (*tiocmget)(struct tty_struct *tty, struct file *file);
         int  (*tiocmset)(struct tty_struct *tty, struct file *file,
                          unsigned int set, unsigned int clear);
+        /* Called by the tty layer for port level work. There may or may not
+           be an attached tty at this point */
+        void (*dtr_rts)(struct usb_serial_port *port, int on);
+        int  (*carrier_raised)(struct usb_serial_port *port);
         /* USB events */
         void (*read_int_callback)(struct urb *urb);
         void (*write_int_callback)(struct urb *urb);
@@ -283,8 +303,7 @@ extern int usb_serial_generic_open(struct tty_struct *tty,
                 struct usb_serial_port *port, struct file *filp);
 extern int usb_serial_generic_write(struct tty_struct *tty,
         struct usb_serial_port *port, const unsigned char *buf, int count);
-extern void usb_serial_generic_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+extern void usb_serial_generic_close(struct usb_serial_port *port);
 extern int usb_serial_generic_resume(struct usb_serial *serial);
 extern int usb_serial_generic_write_room(struct tty_struct *tty);
 extern int usb_serial_generic_chars_in_buffer(struct tty_struct *tty);
@@ -292,9 +311,17 @@ extern void usb_serial_generic_read_bulk_callback(struct urb *urb);
 extern void usb_serial_generic_write_bulk_callback(struct urb *urb);
 extern void usb_serial_generic_throttle(struct tty_struct *tty);
 extern void usb_serial_generic_unthrottle(struct tty_struct *tty);
-extern void usb_serial_generic_shutdown(struct usb_serial *serial);
+extern void usb_serial_generic_disconnect(struct usb_serial *serial);
+extern void usb_serial_generic_release(struct usb_serial *serial);
 extern int usb_serial_generic_register(int debug);
 extern void usb_serial_generic_deregister(void);
+extern void usb_serial_generic_resubmit_read_urb(struct usb_serial_port *port,
+                                                 gfp_t mem_flags);
+extern int usb_serial_handle_sysrq_char(struct tty_struct *tty,
+                                        struct usb_serial_port *port,
+                                        unsigned int ch);
+extern int usb_serial_handle_break(struct usb_serial_port *port);
+
 
 extern int usb_serial_bus_register(struct usb_serial_driver *device);
 extern void usb_serial_bus_deregister(struct usb_serial_driver *device);
diff --git a/include/linux/usb/usbnet.h b/include/linux/usb/usbnet.h
index 36fabb95c7d3..310e18a880ff 100644
--- a/include/linux/usb/usbnet.h
+++ b/include/linux/usb/usbnet.h
@@ -42,7 +42,6 @@ struct usbnet {
 
         /* protocol/interface state */
         struct net_device       *net;
-        struct net_device_stats stats;
         int                     msg_enable;
         unsigned long           data [5];
         u32                     xid;
@@ -183,6 +182,7 @@ extern void usbnet_tx_timeout (struct net_device *net);
 extern int usbnet_change_mtu (struct net_device *net, int new_mtu);
 
 extern int usbnet_get_endpoints(struct usbnet *, struct usb_interface *);
+extern int usbnet_get_ethernet_addr(struct usbnet *, int);
 extern void usbnet_defer_kevent (struct usbnet *, int);
 extern void usbnet_skb_return (struct usbnet *, struct sk_buff *);
 extern void usbnet_unlink_rx_urbs(struct usbnet *);
diff --git a/include/linux/utsname.h b/include/linux/utsname.h
index 11232676bfff..3656b300de3a 100644
--- a/include/linux/utsname.h
+++ b/include/linux/utsname.h
@@ -22,12 +22,12 @@ struct old_utsname {
 };
 
 struct new_utsname {
-        char sysname[65];
-        char nodename[65];
-        char release[65];
-        char version[65];
-        char machine[65];
-        char domainname[65];
+        char sysname[__NEW_UTS_LEN + 1];
+        char nodename[__NEW_UTS_LEN + 1];
+        char release[__NEW_UTS_LEN + 1];
+        char version[__NEW_UTS_LEN + 1];
+        char machine[__NEW_UTS_LEN + 1];
+        char domainname[__NEW_UTS_LEN + 1];
 };
 
 #ifdef __KERNEL__
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index ebb2ea6b4995..74f16876f38d 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -318,6 +318,8 @@ struct v4l2_pix_format {
 /* see http://www.siliconimaging.com/RGB%20Bayer.htm */
 #define V4L2_PIX_FMT_SBGGR8  v4l2_fourcc('B', 'A', '8', '1') /*  8  BGBG.. GRGR.. */
 #define V4L2_PIX_FMT_SGBRG8  v4l2_fourcc('G', 'B', 'R', 'G') /*  8  GBGB.. RGRG.. */
+#define V4L2_PIX_FMT_SGRBG8  v4l2_fourcc('G', 'R', 'B', 'G') /*  8  GRGR.. BGBG.. */
+
 /*
  * 10bit raw bayer, expanded to 16 bits
  * xxxxrrrrrrrrrrxxxxgggggggggg xxxxggggggggggxxxxbbbbbbbbbb...
@@ -336,6 +338,7 @@ struct v4l2_pix_format {
 /*  Vendor-specific formats   */
 #define V4L2_PIX_FMT_WNVA     v4l2_fourcc('W', 'N', 'V', 'A') /* Winnov hw compress */
 #define V4L2_PIX_FMT_SN9C10X  v4l2_fourcc('S', '9', '1', '0') /* SN9C10x compression */
+#define V4L2_PIX_FMT_SN9C20X_I420 v4l2_fourcc('S', '9', '2', '0') /* SN9C20x YUV 4:2:0 */
 #define V4L2_PIX_FMT_PWC1     v4l2_fourcc('P', 'W', 'C', '1') /* pwc older webcam */
 #define V4L2_PIX_FMT_PWC2     v4l2_fourcc('P', 'W', 'C', '2') /* pwc newer webcam */
 #define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E', '6', '2', '5') /* ET61X251 compression */
@@ -347,7 +350,9 @@ struct v4l2_pix_format {
 #define V4L2_PIX_FMT_MR97310A v4l2_fourcc('M', '3', '1', '0') /* compressed BGGR bayer */
 #define V4L2_PIX_FMT_SQ905C   v4l2_fourcc('9', '0', '5', 'C') /* compressed RGGB bayer */
 #define V4L2_PIX_FMT_PJPG     v4l2_fourcc('P', 'J', 'P', 'G') /* Pixart 73xx JPEG */
-#define V4L2_PIX_FMT_YVYU    v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16  YVU 4:2:2     */
+#define V4L2_PIX_FMT_YVYU     v4l2_fourcc('Y', 'V', 'Y', 'U') /* 16 YVU 4:2:2 */
+#define V4L2_PIX_FMT_OV511    v4l2_fourcc('O', '5', '1', '1') /* ov511 JPEG */
+#define V4L2_PIX_FMT_OV518    v4l2_fourcc('O', '5', '1', '8') /* ov518 JPEG */
 
 /*
  *      F O R M A T   E N U M E R A T I O N
@@ -893,9 +898,10 @@ enum v4l2_colorfx {
         V4L2_COLORFX_BW         = 1,
         V4L2_COLORFX_SEPIA      = 2,
 };
+#define V4L2_CID_AUTOBRIGHTNESS                 (V4L2_CID_BASE+32)
 
 /* last CID + 1 */
-#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+32)
+#define V4L2_CID_LASTP1                         (V4L2_CID_BASE+33)
 
 /*  MPEG-class control IDs defined by V4L2 */
 #define V4L2_CID_MPEG_BASE                      (V4L2_CTRL_CLASS_MPEG | 0x900)
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index 06005fa9e982..4fca4f5440ba 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -10,14 +10,17 @@
 
 /**
  * virtqueue - a queue to register buffers for sending or receiving.
+ * @list: the chain of virtqueues for this device
  * @callback: the function to call when buffers are consumed (can be NULL).
+ * @name: the name of this virtqueue (mainly for debugging)
  * @vdev: the virtio device this queue was created for.
  * @vq_ops: the operations for this virtqueue (see below).
  * @priv: a pointer for the virtqueue implementation to use.
  */
-struct virtqueue
-{
+struct virtqueue {
+        struct list_head list;
         void (*callback)(struct virtqueue *vq);
+        const char *name;
         struct virtio_device *vdev;
         struct virtqueue_ops *vq_ops;
         void *priv;
@@ -76,15 +79,16 @@ struct virtqueue_ops {
  * @dev: underlying device.
  * @id: the device type identification (used to match it with a driver).
  * @config: the configuration ops for this device.
+ * @vqs: the list of virtqueues for this device.
  * @features: the features supported by both driver and device.
  * @priv: private pointer for the driver's use.
  */
-struct virtio_device
-{
+struct virtio_device {
         int index;
         struct device dev;
         struct virtio_device_id id;
         struct virtio_config_ops *config;
+        struct list_head vqs;
         /* Note that this is a Linux set_bit-style bitmap. */
         unsigned long features[1];
         void *priv;
@@ -99,8 +103,7 @@ void unregister_virtio_device(struct virtio_device *dev);
  * @id_table: the ids serviced by this driver.
  * @feature_table: an array of feature numbers supported by this device.
  * @feature_table_size: number of entries in the feature table array.
- * @probe: the function to call when a device is found.  Returns a token for
- *    remove, or PTR_ERR().
+ * @probe: the function to call when a device is found.  Returns 0 or -errno.
  * @remove: the function when a device is removed.
  * @config_changed: optional function to call when the device configuration
  *    changes; may be called in interrupt context.
diff --git a/include/linux/virtio_blk.h b/include/linux/virtio_blk.h
index 94c56d29869d..8dab9f2b8832 100644
--- a/include/linux/virtio_blk.h
+++ b/include/linux/virtio_blk.h
@@ -15,9 +15,12 @@
 #define VIRTIO_BLK_F_GEOMETRY   4       /* Legacy geometry available  */
 #define VIRTIO_BLK_F_RO         5       /* Disk is read-only */
 #define VIRTIO_BLK_F_BLK_SIZE   6       /* Block size of disk is available*/
+#define VIRTIO_BLK_F_SCSI       7       /* Supports scsi command passthru */
+#define VIRTIO_BLK_F_IDENTIFY   8       /* ATA IDENTIFY supported */
 
-struct virtio_blk_config
-{
+#define VIRTIO_BLK_ID_BYTES     (sizeof(__u16[256]))    /* IDENTIFY DATA */
+
+struct virtio_blk_config {
         /* The capacity (in 512-byte sectors). */
         __u64 capacity;
         /* The maximum segment size (if VIRTIO_BLK_F_SIZE_MAX) */
@@ -32,6 +35,7 @@ struct virtio_blk_config
         } geometry;
         /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
         __u32 blk_size;
+        __u8 identify[VIRTIO_BLK_ID_BYTES];
 } __attribute__((packed));
 
 /* These two define direction. */
@@ -45,8 +49,7 @@ struct virtio_blk_config
 #define VIRTIO_BLK_T_BARRIER    0x80000000
 
 /* This is the first element of the read scatter-gather list. */
-struct virtio_blk_outhdr
-{
+struct virtio_blk_outhdr {
         /* VIRTIO_BLK_T* */
         __u32 type;
         /* io priority. */
@@ -55,6 +58,13 @@ struct virtio_blk_outhdr
         __u64 sector;
 };
 
+struct virtio_scsi_inhdr {
+        __u32 errors;
+        __u32 data_len;
+        __u32 sense_len;
+        __u32 residual;
+};
+
 /* And this is the final byte of the write scatter-gather list. */
 #define VIRTIO_BLK_S_OK         0
 #define VIRTIO_BLK_S_IOERR      1
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index bf8ec283b232..e547e3c8ee9a 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -29,6 +29,7 @@
 #define VIRTIO_F_NOTIFY_ON_EMPTY        24
 
 #ifdef __KERNEL__
+#include <linux/err.h>
 #include <linux/virtio.h>
 
 /**
@@ -49,15 +50,26 @@
  * @set_status: write the status byte
  *      vdev: the virtio_device
  *      status: the new status byte
+ * @request_vqs: request the specified number of virtqueues
+ *      vdev: the virtio_device
+ *      max_vqs: the max number of virtqueues we want
+ *      If supplied, must call before any virtqueues are instantiated.
+ *      To modify the max number of virtqueues after request_vqs has been
+ *      called, call free_vqs and then request_vqs with a new value.
+ * @free_vqs: cleanup resources allocated by request_vqs
+ *      vdev: the virtio_device
+ *      If supplied, must call after all virtqueues have been deleted.
  * @reset: reset the device
  *      vdev: the virtio device
  *      After this, status and feature negotiation must be done again
- * @find_vq: find a virtqueue and instantiate it.
+ * @find_vqs: find virtqueues and instantiate them.
  *      vdev: the virtio_device
- *      index: the 0-based virtqueue number in case there's more than one.
- *      callback: the virqtueue callback
- *      Returns the new virtqueue or ERR_PTR() (eg. -ENOENT).
- * @del_vq: free a virtqueue found by find_vq().
+ *      nvqs: the number of virtqueues to find
+ *      vqs: on success, includes new virtqueues
+ *      callbacks: array of callbacks, for each virtqueue
+ *      names: array of virtqueue names (mainly for debugging)
+ *      Returns 0 on success or error status
+ * @del_vqs: free virtqueues found by find_vqs().
  * @get_features: get the array of feature bits for this device.
  *      vdev: the virtio_device
  *      Returns the first 32 feature bits (all we currently need).
@@ -66,8 +78,8 @@
  *      This gives the final feature bits for the device: it can change
  *      the dev->feature bits if it wants.
  */
-struct virtio_config_ops
-{
+typedef void vq_callback_t(struct virtqueue *);
+struct virtio_config_ops {
         void (*get)(struct virtio_device *vdev, unsigned offset,
                     void *buf, unsigned len);
         void (*set)(struct virtio_device *vdev, unsigned offset,
@@ -75,10 +87,11 @@ struct virtio_config_ops
         u8 (*get_status)(struct virtio_device *vdev);
         void (*set_status)(struct virtio_device *vdev, u8 status);
         void (*reset)(struct virtio_device *vdev);
-        struct virtqueue *(*find_vq)(struct virtio_device *vdev,
-                                     unsigned index,
-                                     void (*callback)(struct virtqueue *));
-        void (*del_vq)(struct virtqueue *vq);
+        int (*find_vqs)(struct virtio_device *, unsigned nvqs,
+                        struct virtqueue *vqs[],
+                        vq_callback_t *callbacks[],
+                        const char *names[]);
+        void (*del_vqs)(struct virtio_device *);
         u32 (*get_features)(struct virtio_device *vdev);
         void (*finalize_features)(struct virtio_device *vdev);
 };
@@ -99,7 +112,9 @@ static inline bool virtio_has_feature(const struct virtio_device *vdev,
         if (__builtin_constant_p(fbit))
                 BUILD_BUG_ON(fbit >= 32);
 
-        virtio_check_driver_offered_feature(vdev, fbit);
+        if (fbit < VIRTIO_TRANSPORT_F_START)
+                virtio_check_driver_offered_feature(vdev, fbit);
+
         return test_bit(fbit, vdev->features);
 }
 
@@ -126,5 +141,18 @@ static inline int virtio_config_buf(struct virtio_device *vdev,
         vdev->config->get(vdev, offset, buf, len);
         return 0;
 }
+
+static inline
+struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev,
+                                        vq_callback_t *c, const char *n)
+{
+        vq_callback_t *callbacks[] = { c };
+        const char *names[] = { n };
+        struct virtqueue *vq;
+        int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names);
+        if (err < 0)
+                return ERR_PTR(err);
+        return vq;
+}
 #endif /* __KERNEL__ */
 #endif /* _LINUX_VIRTIO_CONFIG_H */
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index cec79adbe3ea..d8dd539c9f48 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -27,11 +27,11 @@
 #define VIRTIO_NET_F_CTRL_VQ    17      /* Control channel available */
 #define VIRTIO_NET_F_CTRL_RX    18      /* Control channel RX mode support */
 #define VIRTIO_NET_F_CTRL_VLAN  19      /* Control channel VLAN filtering */
+#define VIRTIO_NET_F_CTRL_RX_EXTRA 20   /* Extra RX mode control support */
 
 #define VIRTIO_NET_S_LINK_UP    1       /* Link is up */
 
-struct virtio_net_config
-{
+struct virtio_net_config {
         /* The config defining mac address (if VIRTIO_NET_F_MAC) */
         __u8 mac[6];
         /* See VIRTIO_NET_F_STATUS and VIRTIO_NET_S_* above */
@@ -40,8 +40,7 @@ struct virtio_net_config
 
 /* This is the first element of the scatter-gather list.  If you don't
  * specify GSO or CSUM features, you can simply ignore the header. */
-struct virtio_net_hdr
-{
+struct virtio_net_hdr {
 #define VIRTIO_NET_HDR_F_NEEDS_CSUM     1       // Use csum_start, csum_offset
         __u8 flags;
 #define VIRTIO_NET_HDR_GSO_NONE         0       // Not a GSO frame
@@ -81,14 +80,19 @@ typedef __u8 virtio_net_ctrl_ack;
 #define VIRTIO_NET_ERR    1
 
 /*
- * Control the RX mode, ie. promisucous and allmulti.  PROMISC and
- * ALLMULTI commands require an "out" sg entry containing a 1 byte
- * state value, zero = disable, non-zero = enable.  These commands
- * are supported with the VIRTIO_NET_F_CTRL_RX feature.
+ * Control the RX mode, ie. promisucous, allmulti, etc...
+ * All commands require an "out" sg entry containing a 1 byte
+ * state value, zero = disable, non-zero = enable.  Commands
+ * 0 and 1 are supported with the VIRTIO_NET_F_CTRL_RX feature.
+ * Commands 2-5 are added with VIRTIO_NET_F_CTRL_RX_EXTRA.
  */
 #define VIRTIO_NET_CTRL_RX    0
  #define VIRTIO_NET_CTRL_RX_PROMISC      0
  #define VIRTIO_NET_CTRL_RX_ALLMULTI     1
+ #define VIRTIO_NET_CTRL_RX_ALLUNI       2
+ #define VIRTIO_NET_CTRL_RX_NOMULTI      3
+ #define VIRTIO_NET_CTRL_RX_NOUNI        4
+ #define VIRTIO_NET_CTRL_RX_NOBCAST      5
 
 /*
  * Control the MAC filter table.
diff --git a/include/linux/virtio_pci.h b/include/linux/virtio_pci.h
index cd0fd5d181a6..9a3d7c48c622 100644
--- a/include/linux/virtio_pci.h
+++ b/include/linux/virtio_pci.h
@@ -47,9 +47,17 @@
 /* The bit of the ISR which indicates a device configuration change. */
 #define VIRTIO_PCI_ISR_CONFIG           0x2
 
+/* MSI-X registers: only enabled if MSI-X is enabled. */
+/* A 16-bit vector for configuration changes. */
+#define VIRTIO_MSI_CONFIG_VECTOR        20
+/* A 16-bit vector for selected queue notifications. */
+#define VIRTIO_MSI_QUEUE_VECTOR         22
+/* Vector value used to disable MSI for queue */
+#define VIRTIO_MSI_NO_VECTOR            0xffff
+
 /* The remaining space is defined by each driver as the per-driver
  * configuration space */
-#define VIRTIO_PCI_CONFIG               20
+#define VIRTIO_PCI_CONFIG(dev)          ((dev)->msix_enabled ? 24 : 20)
 
 /* Virtio ABI version, this must match exactly */
 #define VIRTIO_PCI_ABI_VERSION          0
diff --git a/include/linux/virtio_ring.h b/include/linux/virtio_ring.h
index 71e03722fb59..e4d144b132b5 100644
--- a/include/linux/virtio_ring.h
+++ b/include/linux/virtio_ring.h
@@ -14,6 +14,8 @@
 #define VRING_DESC_F_NEXT       1
 /* This marks a buffer as write-only (otherwise read-only). */
 #define VRING_DESC_F_WRITE      2
+/* This means the buffer contains a list of buffer descriptors. */
+#define VRING_DESC_F_INDIRECT   4
 
 /* The Host uses this in used->flags to advise the Guest: don't kick me when
  * you add a buffer.  It's unreliable, so it's simply an optimization.  Guest
@@ -24,9 +26,11 @@
  * optimization.  */
 #define VRING_AVAIL_F_NO_INTERRUPT      1
 
+/* We support indirect buffer descriptors */
+#define VIRTIO_RING_F_INDIRECT_DESC     28
+
 /* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
-struct vring_desc
-{
+struct vring_desc {
         /* Address (guest-physical). */
         __u64 addr;
         /* Length. */
@@ -37,24 +41,21 @@ struct vring_desc
         __u16 next;
 };
 
-struct vring_avail
-{
+struct vring_avail {
         __u16 flags;
         __u16 idx;
         __u16 ring[];
 };
 
 /* u32 is used here for ids for padding reasons. */
-struct vring_used_elem
-{
+struct vring_used_elem {
         /* Index of start of used descriptor chain. */
         __u32 id;
         /* Total length of the descriptor chain which was used (written to) */
         __u32 len;
 };
 
-struct vring_used
-{
+struct vring_used {
         __u16 flags;
         __u16 idx;
         struct vring_used_elem ring[];
@@ -119,7 +120,8 @@ struct virtqueue *vring_new_virtqueue(unsigned int num,
                                       struct virtio_device *vdev,
                                       void *pages,
                                       void (*notify)(struct virtqueue *vq),
-                                      void (*callback)(struct virtqueue *vq));
+                                      void (*callback)(struct virtqueue *vq),
+                                      const char *name);
 void vring_del_virtqueue(struct virtqueue *vq);
 /* Filter out transport-specific feature bits. */
 void vring_transport_features(struct virtio_device *vdev);
diff --git a/include/linux/vlynq.h b/include/linux/vlynq.h
new file mode 100644
index 000000000000..8f6a95882b09
--- /dev/null
+++ b/include/linux/vlynq.h
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2006, 2007 Eugene Konev <ejka@openwrt.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __VLYNQ_H__
+#define __VLYNQ_H__
+
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/types.h>
+
+#define VLYNQ_NUM_IRQS 32
+
+struct vlynq_mapping {
+        u32 size;
+        u32 offset;
+};
+
+enum vlynq_divisor {
+        vlynq_div_auto = 0,
+        vlynq_ldiv1,
+        vlynq_ldiv2,
+        vlynq_ldiv3,
+        vlynq_ldiv4,
+        vlynq_ldiv5,
+        vlynq_ldiv6,
+        vlynq_ldiv7,
+        vlynq_ldiv8,
+        vlynq_rdiv1,
+        vlynq_rdiv2,
+        vlynq_rdiv3,
+        vlynq_rdiv4,
+        vlynq_rdiv5,
+        vlynq_rdiv6,
+        vlynq_rdiv7,
+        vlynq_rdiv8,
+        vlynq_div_external
+};
+
+struct vlynq_device_id {
+        u32 id;
+        enum vlynq_divisor divisor;
+        unsigned long driver_data;
+};
+
+struct vlynq_regs;
+struct vlynq_device {
+        u32 id, dev_id;
+        int local_irq;
+        int remote_irq;
+        enum vlynq_divisor divisor;
+        u32 regs_start, regs_end;
+        u32 mem_start, mem_end;
+        u32 irq_start, irq_end;
+        int irq;
+        int enabled;
+        struct vlynq_regs *local;
+        struct vlynq_regs *remote;
+        struct device dev;
+};
+
+struct vlynq_driver {
+        char *name;
+        struct vlynq_device_id *id_table;
+        int (*probe)(struct vlynq_device *dev, struct vlynq_device_id *id);
+        void (*remove)(struct vlynq_device *dev);
+        struct device_driver driver;
+};
+
+struct plat_vlynq_ops {
+        int (*on)(struct vlynq_device *dev);
+        void (*off)(struct vlynq_device *dev);
+};
+
+static inline struct vlynq_driver *to_vlynq_driver(struct device_driver *drv)
+{
+        return container_of(drv, struct vlynq_driver, driver);
+}
+
+static inline struct vlynq_device *to_vlynq_device(struct device *device)
+{
+        return container_of(device, struct vlynq_device, dev);
+}
+
+extern struct bus_type vlynq_bus_type;
+
+extern int __vlynq_register_driver(struct vlynq_driver *driver,
+                                   struct module *owner);
+
+static inline int vlynq_register_driver(struct vlynq_driver *driver)
+{
+        return __vlynq_register_driver(driver, THIS_MODULE);
+}
+
+static inline void *vlynq_get_drvdata(struct vlynq_device *dev)
+{
+        return dev_get_drvdata(&dev->dev);
+}
+
+static inline void vlynq_set_drvdata(struct vlynq_device *dev, void *data)
+{
+        dev_set_drvdata(&dev->dev, data);
+}
+
+static inline u32 vlynq_mem_start(struct vlynq_device *dev)
+{
+        return dev->mem_start;
+}
+
+static inline u32 vlynq_mem_end(struct vlynq_device *dev)
+{
+        return dev->mem_end;
+}
+
+static inline u32 vlynq_mem_len(struct vlynq_device *dev)
+{
+        return dev->mem_end - dev->mem_start + 1;
+}
+
+static inline int vlynq_virq_to_irq(struct vlynq_device *dev, int virq)
+{
+        int irq = dev->irq_start + virq;
+        if ((irq < dev->irq_start) || (irq > dev->irq_end))
+                return -EINVAL;
+
+        return irq;
+}
+
+static inline int vlynq_irq_to_virq(struct vlynq_device *dev, int irq)
+{
+        if ((irq < dev->irq_start) || (irq > dev->irq_end))
+                return -EINVAL;
+
+        return irq - dev->irq_start;
+}
+
+extern void vlynq_unregister_driver(struct vlynq_driver *driver);
+extern int vlynq_enable_device(struct vlynq_device *dev);
+extern void vlynq_disable_device(struct vlynq_device *dev);
+extern int vlynq_set_local_mapping(struct vlynq_device *dev, u32 tx_offset,
+                                   struct vlynq_mapping *mapping);
+extern int vlynq_set_remote_mapping(struct vlynq_device *dev, u32 tx_offset,
+                                    struct vlynq_mapping *mapping);
+extern int vlynq_set_local_irq(struct vlynq_device *dev, int virq);
+extern int vlynq_set_remote_irq(struct vlynq_device *dev, int virq);
+
+#endif /* __VLYNQ_H__ */
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index 524cd1b28ecb..81a97cf8f0a0 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -36,12 +36,14 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
                 FOR_ALL_ZONES(PGSTEAL),
                 FOR_ALL_ZONES(PGSCAN_KSWAPD),
                 FOR_ALL_ZONES(PGSCAN_DIRECT),
+#ifdef CONFIG_NUMA
+                PGSCAN_ZONE_RECLAIM_FAILED,
+#endif
                 PGINODESTEAL, SLABS_SCANNED, KSWAPD_STEAL, KSWAPD_INODESTEAL,
                 PAGEOUTRUN, ALLOCSTALL, PGROTATED,
 #ifdef CONFIG_HUGETLB_PAGE
                 HTLB_BUDDY_PGALLOC, HTLB_BUDDY_PGALLOC_FAIL,
 #endif
-#ifdef CONFIG_UNEVICTABLE_LRU
                 UNEVICTABLE_PGCULLED,   /* culled to noreclaim list */
                 UNEVICTABLE_PGSCANNED,  /* scanned for reclaimability */
                 UNEVICTABLE_PGRESCUED,  /* rescued from noreclaim list */
@@ -50,7 +52,6 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
                 UNEVICTABLE_PGCLEARED,  /* on COW, page truncate */
                 UNEVICTABLE_PGSTRANDED, /* unable to isolate on unlock */
                 UNEVICTABLE_MLOCKFREED,
-#endif
                 NR_VM_EVENT_ITEMS
 };
 
diff --git a/include/linux/w1-gpio.h b/include/linux/w1-gpio.h
index 9797fec7748a..3adeff82212f 100644
--- a/include/linux/w1-gpio.h
+++ b/include/linux/w1-gpio.h
@@ -18,6 +18,7 @@
 struct w1_gpio_platform_data {
         unsigned int pin;
         unsigned int is_open_drain:1;
+        void (*enable_external_pullup)(int enable);
 };
 
 #endif /* _LINUX_W1_GPIO_H */
diff --git a/include/linux/wait.h b/include/linux/wait.h
index bc024632f365..6788e1a4d4ca 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -132,8 +132,6 @@ static inline void __remove_wait_queue(wait_queue_head_t *head,
         list_del(&old->task_list);
 }
 
-void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
-                        int nr_exclusive, int sync, void *key);
 void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
 void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode, int nr,
diff --git a/include/linux/wimax.h b/include/linux/wimax.h
index c89de7f4e5b9..4fdcc5635518 100644
--- a/include/linux/wimax.h
+++ b/include/linux/wimax.h
@@ -59,7 +59,7 @@ enum {
          * M - Major: change if removing or modifying an existing call.
          * m - minor: change when adding a new call
          */
-        WIMAX_GNL_VERSION = 00,
+        WIMAX_GNL_VERSION = 01,
         /* Generic NetLink attributes */
         WIMAX_GNL_ATTR_INVALID = 0x00,
         WIMAX_GNL_ATTR_MAX = 10,
@@ -78,6 +78,7 @@ enum {
         WIMAX_GNL_OP_RFKILL,    /* Run wimax_rfkill() */
         WIMAX_GNL_OP_RESET,     /* Run wimax_rfkill() */
         WIMAX_GNL_RE_STATE_CHANGE,      /* Report: status change */
+        WIMAX_GNL_OP_STATE_GET,         /* Request for current state */
 };
 
 
@@ -113,6 +114,10 @@ enum {
         WIMAX_GNL_RESET_IFIDX = 1,
 };
 
+/* Atributes for wimax_state_get() */
+enum {
+        WIMAX_GNL_STGET_IFIDX = 1,
+};
 
 /*
  * Attributes for the Report State Change
diff --git a/include/linux/wimax/i2400m.h b/include/linux/wimax/i2400m.h
index d5148a7889a6..433693ef2bb0 100644
--- a/include/linux/wimax/i2400m.h
+++ b/include/linux/wimax/i2400m.h
@@ -266,7 +266,7 @@ enum i2400m_ro_type {
 
 /* Misc constants */
 enum {
-        I2400M_PL_PAD = 16,     /* Payload data size alignment */
+        I2400M_PL_ALIGN = 16,   /* Payload data size alignment */
         I2400M_PL_SIZE_MAX = 0x3EFF,
         I2400M_MAX_PLS_IN_MSG = 60,
         /* protocol barkers: sync sequences; for notifications they
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 93445477f86a..3224820c8514 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -79,7 +79,6 @@ struct writeback_control {
 void writeback_inodes(struct writeback_control *wbc);
 int inode_wait(void *);
 void sync_inodes_sb(struct super_block *, int wait);
-void sync_inodes(int wait);
 
 /* writeback.h requires fs.h; it, too, is not included from here. */
 static inline void wait_on_inode(struct inode *inode)
diff --git a/include/media/adv7343.h b/include/media/adv7343.h
new file mode 100644
index 000000000000..d6f8a4e1a1fc
--- /dev/null
+++ b/include/media/adv7343.h
@@ -0,0 +1,23 @@
+/*
+ * ADV7343 header file
+ *
+ * Copyright (C) 2009 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 version 2.
+ *
+ * This program is distributed .as is. WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef ADV7343_H
+#define ADV7343_H
+
+#define ADV7343_COMPOSITE_ID    (0)
+#define ADV7343_COMPONENT_ID    (1)
+#define ADV7343_SVIDEO_ID       (2)
+
+#endif                          /* End of #ifndef ADV7343_H */
diff --git a/include/media/ir-common.h b/include/media/ir-common.h
index 7b5b91f60425..9dcb632f6083 100644
--- a/include/media/ir-common.h
+++ b/include/media/ir-common.h
@@ -162,6 +162,8 @@ extern IR_KEYTAB_TYPE ir_codes_ati_tv_wonder_hd_600[IR_KEYTAB_SIZE];
 extern IR_KEYTAB_TYPE ir_codes_kworld_plus_tv_analog[IR_KEYTAB_SIZE];
 extern IR_KEYTAB_TYPE ir_codes_kaiomy[IR_KEYTAB_SIZE];
 extern IR_KEYTAB_TYPE ir_codes_dm1105_nec[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_evga_indtube[IR_KEYTAB_SIZE];
+
 #endif
 
 /*
diff --git a/include/media/ir-kbd-i2c.h b/include/media/ir-kbd-i2c.h
index 07963d705400..3ad4ed5402fb 100644
--- a/include/media/ir-kbd-i2c.h
+++ b/include/media/ir-kbd-i2c.h
@@ -7,7 +7,7 @@ struct IR_i2c;
 
 struct IR_i2c {
         IR_KEYTAB_TYPE         *ir_codes;
-        struct i2c_client      c;
+        struct i2c_client      *c;
         struct input_dev       *input;
         struct ir_input_state  ir;
 
@@ -15,7 +15,15 @@ struct IR_i2c {
         unsigned char          old;
 
         struct delayed_work    work;
+        char                   name[32];
         char                   phys[32];
         int                    (*get_key)(struct IR_i2c*, u32*, u32*);
 };
+
+/* Can be passed when instantiating an ir_video i2c device */
+struct IR_i2c_init_data {
+        IR_KEYTAB_TYPE         *ir_codes;
+        const char             *name;
+        int                    (*get_key)(struct IR_i2c*, u32*, u32*);
+};
 #endif
diff --git a/include/media/soc_camera.h b/include/media/soc_camera.h
index 37013688af44..23ecead35e7a 100644
--- a/include/media/soc_camera.h
+++ b/include/media/soc_camera.h
@@ -60,7 +60,7 @@ struct soc_camera_file {
 
 struct soc_camera_host {
         struct list_head list;
-        struct device dev;
+        struct device *dev;
         unsigned char nr;                               /* Host number */
         void *priv;
         const char *drv_name;
@@ -92,11 +92,16 @@ struct soc_camera_host_ops {
 #define SOCAM_SENSOR_INVERT_VSYNC       (1 << 3)
 #define SOCAM_SENSOR_INVERT_DATA        (1 << 4)
 
+struct i2c_board_info;
+
 struct soc_camera_link {
         /* Camera bus id, used to match a camera and a bus */
         int bus_id;
         /* Per camera SOCAM_SENSOR_* bus flags */
         unsigned long flags;
+        int i2c_adapter_id;
+        struct i2c_board_info *board_info;
+        const char *module_name;
         /* Optional callbacks to power on or off and reset the sensor */
         int (*power)(struct device *, int);
         int (*reset)(struct device *);
@@ -107,6 +112,7 @@ struct soc_camera_link {
          */
         int (*set_bus_param)(struct soc_camera_link *, unsigned long flags);
         unsigned long (*query_bus_param)(struct soc_camera_link *);
+        void (*free_bus)(struct soc_camera_link *);
 };
 
 static inline struct soc_camera_device *to_soc_camera_dev(struct device *dev)
@@ -116,7 +122,7 @@ static inline struct soc_camera_device *to_soc_camera_dev(struct device *dev)
 
 static inline struct soc_camera_host *to_soc_camera_host(struct device *dev)
 {
-        return container_of(dev, struct soc_camera_host, dev);
+        return dev_get_drvdata(dev);
 }
 
 extern int soc_camera_host_register(struct soc_camera_host *ici);
diff --git a/include/media/tuner.h b/include/media/tuner.h
index 7d4e2db78076..cbf97f45fbec 100644
--- a/include/media/tuner.h
+++ b/include/media/tuner.h
@@ -124,6 +124,8 @@
 #define TUNER_XC5000                    76      /* Xceive Silicon Tuner */
 #define TUNER_TCL_MF02GIP_5N            77      /* TCL MF02GIP_5N */
 #define TUNER_PHILIPS_FMD1216MEX_MK3    78
+#define TUNER_PHILIPS_FM1216MK5         79
+#define TUNER_PHILIPS_FQ1216LME_MK3     80      /* Active loopthrough, no FM */
 
 /* tv card specific */
 #define TDA9887_PRESENT                 (1<<0)
diff --git a/include/media/v4l2-chip-ident.h b/include/media/v4l2-chip-ident.h
index 1be461a29077..94e908c0d7a0 100644
--- a/include/media/v4l2-chip-ident.h
+++ b/include/media/v4l2-chip-ident.h
@@ -60,6 +60,10 @@ enum {
         V4L2_IDENT_OV7670 = 250,
         V4L2_IDENT_OV7720 = 251,
         V4L2_IDENT_OV7725 = 252,
+        V4L2_IDENT_OV7660 = 253,
+        V4L2_IDENT_OV9650 = 254,
+        V4L2_IDENT_OV9655 = 255,
+        V4L2_IDENT_SOI968 = 256,
 
         /* module saa7146: reserved range 300-309 */
         V4L2_IDENT_SAA7146 = 300,
@@ -137,6 +141,12 @@ enum {
         /* module saa7191: just ident 7191 */
         V4L2_IDENT_SAA7191 = 7191,
 
+        /* module ths7303: just ident 7303 */
+        V4L2_IDENT_THS7303 = 7303,
+
+        /* module adv7343: just ident 7343 */
+        V4L2_IDENT_ADV7343 = 7343,
+
         /* module wm8739: just ident 8739 */
         V4L2_IDENT_WM8739 = 8739,
 
@@ -149,9 +159,15 @@ enum {
         /* module cafe_ccic, just ident 8801 */
         V4L2_IDENT_CAFE = 8801,
 
+        /* module mt9v011, just ident 8243 */
+        V4L2_IDENT_MT9V011 = 8243,
+
         /* module tw9910: just ident 9910 */
         V4L2_IDENT_TW9910 = 9910,
 
+        /* module sn9c20x: just ident 10000 */
+        V4L2_IDENT_SN9C20X = 10000,
+
         /* module msp3400: reserved range 34000-34999 and 44000-44999 */
         V4L2_IDENT_MSPX4XX  = 34000, /* generic MSPX4XX identifier, only
                                         use internally (tveeprom.c). */
@@ -228,6 +244,11 @@ enum {
         V4L2_IDENT_MT9V022IX7ATC        = 45010, /* No way to detect "normal" I77ATx */
         V4L2_IDENT_MT9V022IX7ATM        = 45015, /* and "lead free" IA7ATx chips */
         V4L2_IDENT_MT9T031              = 45020,
+        V4L2_IDENT_MT9V111              = 45031,
+        V4L2_IDENT_MT9V112              = 45032,
+
+        /* HV7131R CMOS sensor: just ident 46000 */
+        V4L2_IDENT_HV7131R              = 46000,
 
         /* module cs53132a: just ident 53132 */
         V4L2_IDENT_CS53l32A = 53132,
diff --git a/include/media/v4l2-common.h b/include/media/v4l2-common.h
index c48c24e4d0fa..33a18426ab9b 100644
--- a/include/media/v4l2-common.h
+++ b/include/media/v4l2-common.h
@@ -153,6 +153,22 @@ struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct v4l2_device *v4l2_dev,
 struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev,
                 struct i2c_adapter *adapter,
                 const char *module_name, const char *client_type, u8 addr);
+
+/* Load an i2c module and return an initialized v4l2_subdev struct.
+   Only call request_module if module_name != NULL.
+   The client_type argument is the name of the chip that's on the adapter. */
+struct v4l2_subdev *v4l2_i2c_new_subdev_cfg(struct v4l2_device *v4l2_dev,
+                struct i2c_adapter *adapter,
+                const char *module_name, const char *client_type,
+                int irq, void *platform_data,
+                u8 addr, const unsigned short *probe_addrs);
+
+struct i2c_board_info;
+
+struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
+                struct i2c_adapter *adapter, const char *module_name,
+                struct i2c_board_info *info, const unsigned short *probe_addrs);
+
 /* Initialize an v4l2_subdev with data from an i2c_client struct */
 void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
                 const struct v4l2_subdev_ops *ops);
@@ -193,4 +209,14 @@ struct v4l2_routing {
         u32 output;
 };
 
+/* ------------------------------------------------------------------------- */
+
+/* Miscellaneous helper functions */
+
+void v4l_bound_align_image(unsigned int *w, unsigned int wmin,
+                           unsigned int wmax, unsigned int walign,
+                           unsigned int *h, unsigned int hmin,
+                           unsigned int hmax, unsigned int halign,
+                           unsigned int salign);
+
 #endif /* V4L2_COMMON_H_ */
diff --git a/include/media/v4l2-device.h b/include/media/v4l2-device.h
index 0dd3e8e8653e..5d5d550e63ad 100644
--- a/include/media/v4l2-device.h
+++ b/include/media/v4l2-device.h
@@ -30,7 +30,7 @@
    basic V4L2 device-level support.
  */
 
-#define V4L2_DEVICE_NAME_SIZE (BUS_ID_SIZE + 16)
+#define V4L2_DEVICE_NAME_SIZE (20 + 16)
 
 struct v4l2_device {
         /* dev->driver_data points to this struct.
@@ -53,10 +53,31 @@ struct v4l2_device {
    dev may be NULL in rare cases (ISA devices). In that case you
    must fill in the v4l2_dev->name field before calling this function. */
 int __must_check v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev);
+
+/* Optional function to initialize the name field of struct v4l2_device using
+   the driver name and a driver-global atomic_t instance.
+   This function will increment the instance counter and returns the instance
+   value used in the name.
+
+   Example:
+
+   static atomic_t drv_instance = ATOMIC_INIT(0);
+
+   ...
+
+   instance = v4l2_device_set_name(&v4l2_dev, "foo", &drv_instance);
+
+   The first time this is called the name field will be set to foo0 and
+   this function returns 0. If the name ends with a digit (e.g. cx18),
+   then the name will be set to cx18-0 since cx180 looks really odd. */
+int v4l2_device_set_name(struct v4l2_device *v4l2_dev, const char *basename,
+                                                atomic_t *instance);
+
 /* Set v4l2_dev->dev to NULL. Call when the USB parent disconnects.
    Since the parent disappears this ensures that v4l2_dev doesn't have an
    invalid parent pointer. */
 void v4l2_device_disconnect(struct v4l2_device *v4l2_dev);
+
 /* Unregister all sub-devices and any other resources related to v4l2_dev. */
 void v4l2_device_unregister(struct v4l2_device *v4l2_dev);
 
diff --git a/include/media/v4l2-i2c-drv.h b/include/media/v4l2-i2c-drv.h
index 10a2882c3cbf..74bf741d1a9b 100644
--- a/include/media/v4l2-i2c-drv.h
+++ b/include/media/v4l2-i2c-drv.h
@@ -22,7 +22,7 @@
  */
 
 /* NOTE: the full version of this header is in the v4l-dvb repository
- * and allows v4l i2c drivers to be compiled on older kernels as well.
+ * and allows v4l i2c drivers to be compiled on pre-2.6.26 kernels.
  * The version of this header as it appears in the kernel is a stripped
  * version (without all the backwards compatibility stuff) and so it
  * looks a bit odd.
@@ -30,6 +30,9 @@
  * If you look at the full version then you will understand the reason
  * for introducing this header since you really don't want to have all
  * the tricky backwards compatibility code in each and every i2c driver.
+ *
+ * If the i2c driver will never be compiled for pre-2.6.26 kernels, then
+ * DO NOT USE this header! Just write it as a regular i2c driver.
  */
 
 #ifndef __V4L2_I2C_DRV_H__
diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h
index 17856081c809..5dcb36785529 100644
--- a/include/media/v4l2-subdev.h
+++ b/include/media/v4l2-subdev.h
@@ -79,7 +79,11 @@ struct v4l2_decode_vbi_line {
    not yet implemented) since ops provide proper type-checking.
  */
 
-/* init: initialize the sensor registors to some sort of reasonable default
+/* s_config: if set, then it is always called by the v4l2_i2c_new_subdev*
+        functions after the v4l2_subdev was registered. It is used to pass
+        platform data to the subdev which can be used during initialization.
+
+   init: initialize the sensor registors to some sort of reasonable default
         values. Do not use for new drivers and should be removed in existing
         drivers.
 
@@ -96,6 +100,7 @@ struct v4l2_decode_vbi_line {
 struct v4l2_subdev_core_ops {
         int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip);
         int (*log_status)(struct v4l2_subdev *sd);
+        int (*s_config)(struct v4l2_subdev *sd, int irq, void *platform_data);
         int (*init)(struct v4l2_subdev *sd, u32 val);
         int (*load_fw)(struct v4l2_subdev *sd);
         int (*reset)(struct v4l2_subdev *sd, u32 val);
@@ -230,12 +235,16 @@ struct v4l2_subdev_ops {
 
 #define V4L2_SUBDEV_NAME_SIZE 32
 
+/* Set this flag if this subdev is a i2c device. */
+#define V4L2_SUBDEV_FL_IS_I2C (1U << 0)
+
 /* Each instance of a subdev driver should create this struct, either
    stand-alone or embedded in a larger struct.
  */
 struct v4l2_subdev {
         struct list_head list;
         struct module *owner;
+        u32 flags;
         struct v4l2_device *v4l2_dev;
         const struct v4l2_subdev_ops *ops;
         /* name must be unique */
@@ -264,6 +273,7 @@ static inline void v4l2_subdev_init(struct v4l2_subdev *sd,
         BUG_ON(!ops || !ops->core);
         sd->ops = ops;
         sd->v4l2_dev = NULL;
+        sd->flags = 0;
         sd->name[0] = '\0';
         sd->grp_id = 0;
         sd->priv = NULL;
diff --git a/include/mtd/Kbuild b/include/mtd/Kbuild
index 8eb018f96002..192f8fb7d546 100644
--- a/include/mtd/Kbuild
+++ b/include/mtd/Kbuild
@@ -1,5 +1,4 @@
 header-y += inftl-user.h
-header-y += jffs2-user.h
 header-y += mtd-abi.h
 header-y += mtd-user.h
 header-y += nftl-user.h
diff --git a/include/mtd/jffs2-user.h b/include/mtd/jffs2-user.h
deleted file mode 100644
index fa94b0eb67c1..000000000000
--- a/include/mtd/jffs2-user.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * JFFS2 definitions for use in user space only
- */
-
-#ifndef __JFFS2_USER_H__
-#define __JFFS2_USER_H__
-
-/* This file is blessed for inclusion by userspace */
-#include <linux/jffs2.h>
-#include <linux/types.h>
-#include <endian.h>
-#include <byteswap.h>
-
-#undef cpu_to_je16
-#undef cpu_to_je32
-#undef cpu_to_jemode
-#undef je16_to_cpu
-#undef je32_to_cpu
-#undef jemode_to_cpu
-
-extern int target_endian;
-
-#define t16(x) ({ __u16 __b = (x); (target_endian==__BYTE_ORDER)?__b:bswap_16(__b); })
-#define t32(x) ({ __u32 __b = (x); (target_endian==__BYTE_ORDER)?__b:bswap_32(__b); })
-
-#define cpu_to_je16(x) ((jint16_t){t16(x)})
-#define cpu_to_je32(x) ((jint32_t){t32(x)})
-#define cpu_to_jemode(x) ((jmode_t){t32(x)})
-
-#define je16_to_cpu(x) (t16((x).v16))
-#define je32_to_cpu(x) (t32((x).v32))
-#define jemode_to_cpu(x) (t32((x).m))
-
-#endif /* __JFFS2_USER_H__ */
diff --git a/include/mtd/mtd-abi.h b/include/mtd/mtd-abi.h
index b6595b3c68b6..be51ae2bd0ff 100644
--- a/include/mtd/mtd-abi.h
+++ b/include/mtd/mtd-abi.h
@@ -12,12 +12,24 @@ struct erase_info_user {
         __u32 length;
 };
 
+struct erase_info_user64 {
+        __u64 start;
+        __u64 length;
+};
+
 struct mtd_oob_buf {
         __u32 start;
         __u32 length;
         unsigned char __user *ptr;
 };
 
+struct mtd_oob_buf64 {
+        __u64 start;
+        __u32 pad;
+        __u32 length;
+        __u64 usr_ptr;
+};
+
 #define MTD_ABSENT              0
 #define MTD_RAM                 1
 #define MTD_ROM                 2
@@ -95,6 +107,9 @@ struct otp_info {
 #define ECCGETLAYOUT            _IOR('M', 17, struct nand_ecclayout)
 #define ECCGETSTATS             _IOR('M', 18, struct mtd_ecc_stats)
 #define MTDFILEMODE             _IO('M', 19)
+#define MEMERASE64              _IOW('M', 20, struct erase_info_user64)
+#define MEMWRITEOOB64           _IOWR('M', 21, struct mtd_oob_buf64)
+#define MEMREADOOB64            _IOWR('M', 22, struct mtd_oob_buf64)
 
 /*
  * Obsolete legacy interface. Keep it in order not to break userspace
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index 3ad5390a4dd5..968166a45f86 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -81,12 +81,6 @@ enum {
         BT_CLOSED
 };
 
-/* Endianness conversions */
-#define htobs(a)        __cpu_to_le16(a)
-#define htobl(a)        __cpu_to_le32(a)
-#define btohs(a)        __le16_to_cpu(a)
-#define btohl(a)        __le32_to_cpu(a)
-
 /* BD Address */
 typedef struct {
         __u8 b[6];
@@ -171,15 +165,6 @@ static inline struct sk_buff *bt_skb_send_alloc(struct sock *sk, unsigned long l
         return skb;
 }
 
-static inline int skb_frags_no(struct sk_buff *skb)
-{
-        register struct sk_buff *frag = skb_shinfo(skb)->frag_list;
-        register int n = 1;
-
-        for (; frag; frag=frag->next, n++);
-        return n;
-}
-
 int bt_err(__u16 code);
 
 extern int hci_sock_init(void);
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 73aead222b32..c4ca4228b083 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -137,6 +137,8 @@ struct hci_dev {
         struct device           *parent;
         struct device           dev;
 
+        struct rfkill           *rfkill;
+
         struct module           *owner;
 
         int (*open)(struct hci_dev *hdev);
diff --git a/include/net/bluetooth/l2cap.h b/include/net/bluetooth/l2cap.h
index f566aa1f0a4c..e919fca1072a 100644
--- a/include/net/bluetooth/l2cap.h
+++ b/include/net/bluetooth/l2cap.h
@@ -26,8 +26,13 @@
 #define __L2CAP_H
 
 /* L2CAP defaults */
-#define L2CAP_DEFAULT_MTU       672
-#define L2CAP_DEFAULT_FLUSH_TO  0xFFFF
+#define L2CAP_DEFAULT_MTU               672
+#define L2CAP_DEFAULT_FLUSH_TO          0xffff
+#define L2CAP_DEFAULT_RX_WINDOW         1
+#define L2CAP_DEFAULT_MAX_RECEIVE       1
+#define L2CAP_DEFAULT_RETRANS_TO        300    /* 300 milliseconds */
+#define L2CAP_DEFAULT_MONITOR_TO        1000   /* 1 second */
+#define L2CAP_DEFAULT_MAX_RX_APDU       0xfff7
 
 #define L2CAP_CONN_TIMEOUT      (40000) /* 40 seconds */
 #define L2CAP_INFO_TIMEOUT      (4000)  /*  4 seconds */
@@ -64,17 +69,29 @@ struct l2cap_conninfo {
 #define L2CAP_LM_SECURE         0x0020
 
 /* L2CAP command codes */
-#define L2CAP_COMMAND_REJ 0x01
-#define L2CAP_CONN_REQ    0x02
-#define L2CAP_CONN_RSP    0x03
-#define L2CAP_CONF_REQ    0x04
-#define L2CAP_CONF_RSP    0x05
-#define L2CAP_DISCONN_REQ 0x06
-#define L2CAP_DISCONN_RSP 0x07
-#define L2CAP_ECHO_REQ    0x08
-#define L2CAP_ECHO_RSP    0x09
-#define L2CAP_INFO_REQ    0x0a
-#define L2CAP_INFO_RSP    0x0b
+#define L2CAP_COMMAND_REJ       0x01
+#define L2CAP_CONN_REQ          0x02
+#define L2CAP_CONN_RSP          0x03
+#define L2CAP_CONF_REQ          0x04
+#define L2CAP_CONF_RSP          0x05
+#define L2CAP_DISCONN_REQ       0x06
+#define L2CAP_DISCONN_RSP       0x07
+#define L2CAP_ECHO_REQ          0x08
+#define L2CAP_ECHO_RSP          0x09
+#define L2CAP_INFO_REQ          0x0a
+#define L2CAP_INFO_RSP          0x0b
+
+/* L2CAP feature mask */
+#define L2CAP_FEAT_FLOWCTL      0x00000001
+#define L2CAP_FEAT_RETRANS      0x00000002
+#define L2CAP_FEAT_ERTM         0x00000008
+#define L2CAP_FEAT_STREAMING    0x00000010
+#define L2CAP_FEAT_FCS          0x00000020
+#define L2CAP_FEAT_FIXED_CHAN   0x00000080
+
+/* L2CAP checksum option */
+#define L2CAP_FCS_NONE          0x00
+#define L2CAP_FCS_CRC16         0x01
 
 /* L2CAP structures */
 struct l2cap_hdr {
@@ -106,17 +123,23 @@ struct l2cap_conn_rsp {
         __le16     status;
 } __attribute__ ((packed));
 
+/* channel indentifier */
+#define L2CAP_CID_SIGNALING     0x0001
+#define L2CAP_CID_CONN_LESS     0x0002
+#define L2CAP_CID_DYN_START     0x0040
+#define L2CAP_CID_DYN_END       0xffff
+
 /* connect result */
-#define L2CAP_CR_SUCCESS    0x0000
-#define L2CAP_CR_PEND       0x0001
-#define L2CAP_CR_BAD_PSM    0x0002
-#define L2CAP_CR_SEC_BLOCK  0x0003
-#define L2CAP_CR_NO_MEM     0x0004
+#define L2CAP_CR_SUCCESS        0x0000
+#define L2CAP_CR_PEND           0x0001
+#define L2CAP_CR_BAD_PSM        0x0002
+#define L2CAP_CR_SEC_BLOCK      0x0003
+#define L2CAP_CR_NO_MEM         0x0004
 
 /* connect status */
-#define L2CAP_CS_NO_INFO      0x0000
-#define L2CAP_CS_AUTHEN_PEND  0x0001
-#define L2CAP_CS_AUTHOR_PEND  0x0002
+#define L2CAP_CS_NO_INFO        0x0000
+#define L2CAP_CS_AUTHEN_PEND    0x0001
+#define L2CAP_CS_AUTHOR_PEND    0x0002
 
 struct l2cap_conf_req {
         __le16     dcid;
@@ -143,10 +166,14 @@ struct l2cap_conf_opt {
 } __attribute__ ((packed));
 #define L2CAP_CONF_OPT_SIZE     2
 
+#define L2CAP_CONF_HINT         0x80
+#define L2CAP_CONF_MASK         0x7f
+
 #define L2CAP_CONF_MTU          0x01
 #define L2CAP_CONF_FLUSH_TO     0x02
 #define L2CAP_CONF_QOS          0x03
 #define L2CAP_CONF_RFC          0x04
+#define L2CAP_CONF_FCS          0x05
 
 #define L2CAP_CONF_MAX_SIZE     22
 
@@ -162,6 +189,8 @@ struct l2cap_conf_rfc {
 #define L2CAP_MODE_BASIC        0x00
 #define L2CAP_MODE_RETRANS      0x01
 #define L2CAP_MODE_FLOWCTL      0x02
+#define L2CAP_MODE_ERTM         0x03
+#define L2CAP_MODE_STREAM       0x04
 
 struct l2cap_disconn_req {
         __le16     dcid;
diff --git a/include/net/bluetooth/rfcomm.h b/include/net/bluetooth/rfcomm.h
index 80072611d26a..c274993234e3 100644
--- a/include/net/bluetooth/rfcomm.h
+++ b/include/net/bluetooth/rfcomm.h
@@ -355,7 +355,17 @@ struct rfcomm_dev_list_req {
 };
 
 int  rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg);
+
+#ifdef CONFIG_BT_RFCOMM_TTY
 int  rfcomm_init_ttys(void);
 void rfcomm_cleanup_ttys(void);
-
+#else
+static inline int rfcomm_init_ttys(void)
+{
+        return 0;
+}
+static inline void rfcomm_cleanup_ttys(void)
+{
+}
+#endif
 #endif /* __RFCOMM_H */
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index 5389afdc1297..d1892d66701a 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -1,71 +1,220 @@
 #ifndef __NET_CFG80211_H
 #define __NET_CFG80211_H
+/*
+ * 802.11 device and configuration interface
+ *
+ * Copyright 2006-2009  Johannes Berg <johannes@sipsolutions.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
 
+#include <linux/netdevice.h>
+#include <linux/debugfs.h>
+#include <linux/list.h>
 #include <linux/netlink.h>
 #include <linux/skbuff.h>
 #include <linux/nl80211.h>
 #include <linux/if_ether.h>
 #include <linux/ieee80211.h>
-#include <linux/wireless.h>
-#include <net/iw_handler.h>
-#include <net/genetlink.h>
+#include <net/regulatory.h>
+
 /* remove once we remove the wext stuff */
 #include <net/iw_handler.h>
+#include <linux/wireless.h>
+
 
 /*
- * 802.11 configuration in-kernel interface
+ * wireless hardware capability structures
+ */
+
+/**
+ * enum ieee80211_band - supported frequency bands
+ *
+ * The bands are assigned this way because the supported
+ * bitrates differ in these bands.
  *
- * Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>
+ * @IEEE80211_BAND_2GHZ: 2.4GHz ISM band
+ * @IEEE80211_BAND_5GHZ: around 5GHz band (4.9-5.7)
  */
+enum ieee80211_band {
+        IEEE80211_BAND_2GHZ,
+        IEEE80211_BAND_5GHZ,
+
+        /* keep last */
+        IEEE80211_NUM_BANDS
+};
 
 /**
- * struct vif_params - describes virtual interface parameters
- * @mesh_id: mesh ID to use
- * @mesh_id_len: length of the mesh ID
+ * enum ieee80211_channel_flags - channel flags
+ *
+ * Channel flags set by the regulatory control code.
+ *
+ * @IEEE80211_CHAN_DISABLED: This channel is disabled.
+ * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted
+ *      on this channel.
+ * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel.
+ * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel.
+ * @IEEE80211_CHAN_NO_HT40PLUS: extension channel above this channel
+ *      is not permitted.
+ * @IEEE80211_CHAN_NO_HT40MINUS: extension channel below this channel
+ *      is not permitted.
  */
-struct vif_params {
-       u8 *mesh_id;
-       int mesh_id_len;
+enum ieee80211_channel_flags {
+        IEEE80211_CHAN_DISABLED         = 1<<0,
+        IEEE80211_CHAN_PASSIVE_SCAN     = 1<<1,
+        IEEE80211_CHAN_NO_IBSS          = 1<<2,
+        IEEE80211_CHAN_RADAR            = 1<<3,
+        IEEE80211_CHAN_NO_HT40PLUS      = 1<<4,
+        IEEE80211_CHAN_NO_HT40MINUS     = 1<<5,
 };
 
-/* Radiotap header iteration
- *   implemented in net/wireless/radiotap.c
- *   docs in Documentation/networking/radiotap-headers.txt
+#define IEEE80211_CHAN_NO_HT40 \
+        (IEEE80211_CHAN_NO_HT40PLUS | IEEE80211_CHAN_NO_HT40MINUS)
+
+/**
+ * struct ieee80211_channel - channel definition
+ *
+ * This structure describes a single channel for use
+ * with cfg80211.
+ *
+ * @center_freq: center frequency in MHz
+ * @max_bandwidth: maximum allowed bandwidth for this channel, in MHz
+ * @hw_value: hardware-specific value for the channel
+ * @flags: channel flags from &enum ieee80211_channel_flags.
+ * @orig_flags: channel flags at registration time, used by regulatory
+ *      code to support devices with additional restrictions
+ * @band: band this channel belongs to.
+ * @max_antenna_gain: maximum antenna gain in dBi
+ * @max_power: maximum transmission power (in dBm)
+ * @beacon_found: helper to regulatory code to indicate when a beacon
+ *      has been found on this channel. Use regulatory_hint_found_beacon()
+ *      to enable this, this is is useful only on 5 GHz band.
+ * @orig_mag: internal use
+ * @orig_mpwr: internal use
  */
+struct ieee80211_channel {
+        enum ieee80211_band band;
+        u16 center_freq;
+        u8 max_bandwidth;
+        u16 hw_value;
+        u32 flags;
+        int max_antenna_gain;
+        int max_power;
+        bool beacon_found;
+        u32 orig_flags;
+        int orig_mag, orig_mpwr;
+};
+
 /**
- * struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args
- * @rtheader: pointer to the radiotap header we are walking through
- * @max_length: length of radiotap header in cpu byte ordering
- * @this_arg_index: IEEE80211_RADIOTAP_... index of current arg
- * @this_arg: pointer to current radiotap arg
- * @arg_index: internal next argument index
- * @arg: internal next argument pointer
- * @next_bitmap: internal pointer to next present u32
- * @bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present
+ * enum ieee80211_rate_flags - rate flags
+ *
+ * Hardware/specification flags for rates. These are structured
+ * in a way that allows using the same bitrate structure for
+ * different bands/PHY modes.
+ *
+ * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short
+ *      preamble on this bitrate; only relevant in 2.4GHz band and
+ *      with CCK rates.
+ * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate
+ *      when used with 802.11a (on the 5 GHz band); filled by the
+ *      core code when registering the wiphy.
+ * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate
+ *      when used with 802.11b (on the 2.4 GHz band); filled by the
+ *      core code when registering the wiphy.
+ * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate
+ *      when used with 802.11g (on the 2.4 GHz band); filled by the
+ *      core code when registering the wiphy.
+ * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode.
  */
+enum ieee80211_rate_flags {
+        IEEE80211_RATE_SHORT_PREAMBLE   = 1<<0,
+        IEEE80211_RATE_MANDATORY_A      = 1<<1,
+        IEEE80211_RATE_MANDATORY_B      = 1<<2,
+        IEEE80211_RATE_MANDATORY_G      = 1<<3,
+        IEEE80211_RATE_ERP_G            = 1<<4,
+};
 
-struct ieee80211_radiotap_iterator {
-        struct ieee80211_radiotap_header *rtheader;
-        int max_length;
-        int this_arg_index;
-        u8 *this_arg;
+/**
+ * struct ieee80211_rate - bitrate definition
+ *
+ * This structure describes a bitrate that an 802.11 PHY can
+ * operate with. The two values @hw_value and @hw_value_short
+ * are only for driver use when pointers to this structure are
+ * passed around.
+ *
+ * @flags: rate-specific flags
+ * @bitrate: bitrate in units of 100 Kbps
+ * @hw_value: driver/hardware value for this rate
+ * @hw_value_short: driver/hardware value for this rate when
+ *      short preamble is used
+ */
+struct ieee80211_rate {
+        u32 flags;
+        u16 bitrate;
+        u16 hw_value, hw_value_short;
+};
 
-        int arg_index;
-        u8 *arg;
-        __le32 *next_bitmap;
-        u32 bitmap_shifter;
+/**
+ * struct ieee80211_sta_ht_cap - STA's HT capabilities
+ *
+ * This structure describes most essential parameters needed
+ * to describe 802.11n HT capabilities for an STA.
+ *
+ * @ht_supported: is HT supported by the STA
+ * @cap: HT capabilities map as described in 802.11n spec
+ * @ampdu_factor: Maximum A-MPDU length factor
+ * @ampdu_density: Minimum A-MPDU spacing
+ * @mcs: Supported MCS rates
+ */
+struct ieee80211_sta_ht_cap {
+        u16 cap; /* use IEEE80211_HT_CAP_ */
+        bool ht_supported;
+        u8 ampdu_factor;
+        u8 ampdu_density;
+        struct ieee80211_mcs_info mcs;
 };
 
-extern int ieee80211_radiotap_iterator_init(
-   struct ieee80211_radiotap_iterator *iterator,
-   struct ieee80211_radiotap_header *radiotap_header,
-   int max_length);
+/**
+ * struct ieee80211_supported_band - frequency band definition
+ *
+ * This structure describes a frequency band a wiphy
+ * is able to operate in.
+ *
+ * @channels: Array of channels the hardware can operate in
+ *      in this band.
+ * @band: the band this structure represents
+ * @n_channels: Number of channels in @channels
+ * @bitrates: Array of bitrates the hardware can operate with
+ *      in this band. Must be sorted to give a valid "supported
+ *      rates" IE, i.e. CCK rates first, then OFDM.
+ * @n_bitrates: Number of bitrates in @bitrates
+ */
+struct ieee80211_supported_band {
+        struct ieee80211_channel *channels;
+        struct ieee80211_rate *bitrates;
+        enum ieee80211_band band;
+        int n_channels;
+        int n_bitrates;
+        struct ieee80211_sta_ht_cap ht_cap;
+};
 
-extern int ieee80211_radiotap_iterator_next(
-   struct ieee80211_radiotap_iterator *iterator);
+/*
+ * Wireless hardware/device configuration structures and methods
+ */
 
+/**
+ * struct vif_params - describes virtual interface parameters
+ * @mesh_id: mesh ID to use
+ * @mesh_id_len: length of the mesh ID
+ */
+struct vif_params {
+       u8 *mesh_id;
+       int mesh_id_len;
+};
 
- /**
+/**
  * struct key_params - key information
  *
  * Information about a key
@@ -106,27 +255,6 @@ struct beacon_parameters {
 };
 
 /**
- * enum station_flags - station flags
- *
- * Station capability flags. Note that these must be the bits
- * according to the nl80211 flags.
- *
- * @STATION_FLAG_CHANGED: station flags were changed
- * @STATION_FLAG_AUTHORIZED: station is authorized to send frames (802.1X)
- * @STATION_FLAG_SHORT_PREAMBLE: station is capable of receiving frames
- *      with short preambles
- * @STATION_FLAG_WME: station is WME/QoS capable
- * @STATION_FLAG_MFP: station uses management frame protection
- */
-enum station_flags {
-        STATION_FLAG_CHANGED            = 1<<0,
-        STATION_FLAG_AUTHORIZED         = 1<<NL80211_STA_FLAG_AUTHORIZED,
-        STATION_FLAG_SHORT_PREAMBLE     = 1<<NL80211_STA_FLAG_SHORT_PREAMBLE,
-        STATION_FLAG_WME                = 1<<NL80211_STA_FLAG_WME,
-        STATION_FLAG_MFP                = 1<<NL80211_STA_FLAG_MFP,
-};
-
-/**
  * enum plink_action - actions to perform in mesh peers
  *
  * @PLINK_ACTION_INVALID: action 0 is reserved
@@ -148,14 +276,17 @@ enum plink_actions {
  * @supported_rates: supported rates in IEEE 802.11 format
  *      (or NULL for no change)
  * @supported_rates_len: number of supported rates
- * @station_flags: station flags (see &enum station_flags)
+ * @sta_flags_mask: station flags that changed
+ *      (bitmask of BIT(NL80211_STA_FLAG_...))
+ * @sta_flags_set: station flags values
+ *      (bitmask of BIT(NL80211_STA_FLAG_...))
  * @listen_interval: listen interval or -1 for no change
  * @aid: AID or zero for no change
  */
 struct station_parameters {
         u8 *supported_rates;
         struct net_device *vlan;
-        u32 station_flags;
+        u32 sta_flags_mask, sta_flags_set;
         int listen_interval;
         u16 aid;
         u8 supported_rates_len;
@@ -348,92 +479,6 @@ struct bss_parameters {
         u8 basic_rates_len;
 };
 
-/**
- * enum environment_cap - Environment parsed from country IE
- * @ENVIRON_ANY: indicates country IE applies to both indoor and
- *      outdoor operation.
- * @ENVIRON_INDOOR: indicates country IE applies only to indoor operation
- * @ENVIRON_OUTDOOR: indicates country IE applies only to outdoor operation
- */
-enum environment_cap {
-        ENVIRON_ANY,
-        ENVIRON_INDOOR,
-        ENVIRON_OUTDOOR,
-};
-
-/**
- * struct regulatory_request - used to keep track of regulatory requests
- *
- * @wiphy_idx: this is set if this request's initiator is
- *      %REGDOM_SET_BY_COUNTRY_IE or %REGDOM_SET_BY_DRIVER. This
- *      can be used by the wireless core to deal with conflicts
- *      and potentially inform users of which devices specifically
- *      cased the conflicts.
- * @initiator: indicates who sent this request, could be any of
- *      of those set in nl80211_reg_initiator (%NL80211_REGDOM_SET_BY_*)
- * @alpha2: the ISO / IEC 3166 alpha2 country code of the requested
- *      regulatory domain. We have a few special codes:
- *      00 - World regulatory domain
- *      99 - built by driver but a specific alpha2 cannot be determined
- *      98 - result of an intersection between two regulatory domains
- * @intersect: indicates whether the wireless core should intersect
- *      the requested regulatory domain with the presently set regulatory
- *      domain.
- * @country_ie_checksum: checksum of the last processed and accepted
- *      country IE
- * @country_ie_env: lets us know if the AP is telling us we are outdoor,
- *      indoor, or if it doesn't matter
- * @list: used to insert into the reg_requests_list linked list
- */
-struct regulatory_request {
-        int wiphy_idx;
-        enum nl80211_reg_initiator initiator;
-        char alpha2[2];
-        bool intersect;
-        u32 country_ie_checksum;
-        enum environment_cap country_ie_env;
-        struct list_head list;
-};
-
-struct ieee80211_freq_range {
-        u32 start_freq_khz;
-        u32 end_freq_khz;
-        u32 max_bandwidth_khz;
-};
-
-struct ieee80211_power_rule {
-        u32 max_antenna_gain;
-        u32 max_eirp;
-};
-
-struct ieee80211_reg_rule {
-        struct ieee80211_freq_range freq_range;
-        struct ieee80211_power_rule power_rule;
-        u32 flags;
-};
-
-struct ieee80211_regdomain {
-        u32 n_reg_rules;
-        char alpha2[2];
-        struct ieee80211_reg_rule reg_rules[];
-};
-
-#define MHZ_TO_KHZ(freq) ((freq) * 1000)
-#define KHZ_TO_MHZ(freq) ((freq) / 1000)
-#define DBI_TO_MBI(gain) ((gain) * 100)
-#define MBI_TO_DBI(gain) ((gain) / 100)
-#define DBM_TO_MBM(gain) ((gain) * 100)
-#define MBM_TO_DBM(gain) ((gain) / 100)
-
-#define REG_RULE(start, end, bw, gain, eirp, reg_flags) { \
-        .freq_range.start_freq_khz = MHZ_TO_KHZ(start), \
-        .freq_range.end_freq_khz = MHZ_TO_KHZ(end), \
-        .freq_range.max_bandwidth_khz = MHZ_TO_KHZ(bw), \
-        .power_rule.max_antenna_gain = DBI_TO_MBI(gain), \
-        .power_rule.max_eirp = DBM_TO_MBM(eirp), \
-        .flags = reg_flags, \
-        }
-
 struct mesh_config {
         /* Timeouts in ms */
         /* Mesh plink management parameters */
@@ -504,7 +549,7 @@ struct cfg80211_scan_request {
         int n_ssids;
         struct ieee80211_channel **channels;
         u32 n_channels;
-        u8 *ie;
+        const u8 *ie;
         size_t ie_len;
 
         /* internal */
@@ -612,6 +657,11 @@ struct cfg80211_auth_request {
  * @ssid_len: Length of ssid in octets
  * @ie: Extra IEs to add to (Re)Association Request frame or %NULL
  * @ie_len: Length of ie buffer in octets
+ * @use_mfp: Use management frame protection (IEEE 802.11w) in this association
+ * @control_port: Whether user space controls IEEE 802.1X port, i.e.,
+ *      sets/clears %NL80211_STA_FLAG_AUTHORIZED. If true, the driver is
+ *      required to assume that the port is unauthorized until authorized by
+ *      user space. Otherwise, port is marked authorized by default.
  */
 struct cfg80211_assoc_request {
         struct ieee80211_channel *chan;
@@ -620,6 +670,8 @@ struct cfg80211_assoc_request {
         size_t ssid_len;
         const u8 *ie;
         size_t ie_len;
+        bool use_mfp;
+        bool control_port;
 };
 
 /**
@@ -659,6 +711,60 @@ struct cfg80211_disassoc_request {
 };
 
 /**
+ * struct cfg80211_ibss_params - IBSS parameters
+ *
+ * This structure defines the IBSS parameters for the join_ibss()
+ * method.
+ *
+ * @ssid: The SSID, will always be non-null.
+ * @ssid_len: The length of the SSID, will always be non-zero.
+ * @bssid: Fixed BSSID requested, maybe be %NULL, if set do not
+ *      search for IBSSs with a different BSSID.
+ * @channel: The channel to use if no IBSS can be found to join.
+ * @channel_fixed: The channel should be fixed -- do not search for
+ *      IBSSs to join on other channels.
+ * @ie: information element(s) to include in the beacon
+ * @ie_len: length of that
+ * @beacon_interval: beacon interval to use
+ */
+struct cfg80211_ibss_params {
+        u8 *ssid;
+        u8 *bssid;
+        struct ieee80211_channel *channel;
+        u8 *ie;
+        u8 ssid_len, ie_len;
+        u16 beacon_interval;
+        bool channel_fixed;
+};
+
+/**
+ * enum wiphy_params_flags - set_wiphy_params bitfield values
+ * WIPHY_PARAM_RETRY_SHORT: wiphy->retry_short has changed
+ * WIPHY_PARAM_RETRY_LONG: wiphy->retry_long has changed
+ * WIPHY_PARAM_FRAG_THRESHOLD: wiphy->frag_threshold has changed
+ * WIPHY_PARAM_RTS_THRESHOLD: wiphy->rts_threshold has changed
+ */
+enum wiphy_params_flags {
+        WIPHY_PARAM_RETRY_SHORT         = 1 << 0,
+        WIPHY_PARAM_RETRY_LONG          = 1 << 1,
+        WIPHY_PARAM_FRAG_THRESHOLD      = 1 << 2,
+        WIPHY_PARAM_RTS_THRESHOLD       = 1 << 3,
+};
+
+/**
+ * enum tx_power_setting - TX power adjustment
+ *
+ * @TX_POWER_AUTOMATIC: the dbm parameter is ignored
+ * @TX_POWER_LIMITED: limit TX power by the dbm parameter
+ * @TX_POWER_FIXED: fix TX power to the dbm parameter
+ */
+enum tx_power_setting {
+        TX_POWER_AUTOMATIC,
+        TX_POWER_LIMITED,
+        TX_POWER_FIXED,
+};
+
+/**
  * struct cfg80211_ops - backend description for wireless configuration
  *
  * This struct is registered by fullmac card drivers and/or wireless stacks
@@ -688,10 +794,11 @@ struct cfg80211_disassoc_request {
  * @get_key: get information about the key with the given parameters.
  *      @mac_addr will be %NULL when requesting information for a group
  *      key. All pointers given to the @callback function need not be valid
- *      after it returns.
+ *      after it returns. This function should return an error if it is
+ *      not possible to retrieve the key, -ENOENT if it doesn't exist.
  *
  * @del_key: remove a key given the @mac_addr (%NULL for a group key)
- *      and @key_index
+ *      and @key_index, return -ENOENT if the key doesn't exist.
  *
  * @set_default_key: set the default key on an interface
  *
@@ -733,6 +840,23 @@ struct cfg80211_disassoc_request {
  * @assoc: Request to (re)associate with the specified peer
  * @deauth: Request to deauthenticate from the specified peer
  * @disassoc: Request to disassociate from the specified peer
+ *
+ * @join_ibss: Join the specified IBSS (or create if necessary). Once done, call
+ *      cfg80211_ibss_joined(), also call that function when changing BSSID due
+ *      to a merge.
+ * @leave_ibss: Leave the IBSS.
+ *
+ * @set_wiphy_params: Notify that wiphy parameters have changed;
+ *      @changed bitfield (see &enum wiphy_params_flags) describes which values
+ *      have changed. The actual parameter values are available in
+ *      struct wiphy. If returning an error, no value should be changed.
+ *
+ * @set_tx_power: set the transmit power according to the parameters
+ * @get_tx_power: store the current TX power into the dbm variable;
+ *      return 0 if successful
+ *
+ * @rfkill_poll: polls the hw rfkill line, use cfg80211 reporting
+ *      functions to adjust rfkill hw state
  */
 struct cfg80211_ops {
         int     (*suspend)(struct wiphy *wiphy);
@@ -747,13 +871,13 @@ struct cfg80211_ops {
                                        struct vif_params *params);
 
         int     (*add_key)(struct wiphy *wiphy, struct net_device *netdev,
-                           u8 key_index, u8 *mac_addr,
+                           u8 key_index, const u8 *mac_addr,
                            struct key_params *params);
         int     (*get_key)(struct wiphy *wiphy, struct net_device *netdev,
-                           u8 key_index, u8 *mac_addr, void *cookie,
+                           u8 key_index, const u8 *mac_addr, void *cookie,
                            void (*callback)(void *cookie, struct key_params*));
         int     (*del_key)(struct wiphy *wiphy, struct net_device *netdev,
-                           u8 key_index, u8 *mac_addr);
+                           u8 key_index, const u8 *mac_addr);
         int     (*set_default_key)(struct wiphy *wiphy,
                                    struct net_device *netdev,
                                    u8 key_index);
@@ -818,9 +942,478 @@ struct cfg80211_ops {
                           struct cfg80211_deauth_request *req);
         int     (*disassoc)(struct wiphy *wiphy, struct net_device *dev,
                             struct cfg80211_disassoc_request *req);
+
+        int     (*join_ibss)(struct wiphy *wiphy, struct net_device *dev,
+                             struct cfg80211_ibss_params *params);
+        int     (*leave_ibss)(struct wiphy *wiphy, struct net_device *dev);
+
+        int     (*set_wiphy_params)(struct wiphy *wiphy, u32 changed);
+
+        int     (*set_tx_power)(struct wiphy *wiphy,
+                                enum tx_power_setting type, int dbm);
+        int     (*get_tx_power)(struct wiphy *wiphy, int *dbm);
+
+        void    (*rfkill_poll)(struct wiphy *wiphy);
 };
 
-/* temporary wext handlers */
+/*
+ * wireless hardware and networking interfaces structures
+ * and registration/helper functions
+ */
+
+/**
+ * struct wiphy - wireless hardware description
+ * @idx: the wiphy index assigned to this item
+ * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name>
+ * @custom_regulatory: tells us the driver for this device
+ *      has its own custom regulatory domain and cannot identify the
+ *      ISO / IEC 3166 alpha2 it belongs to. When this is enabled
+ *      we will disregard the first regulatory hint (when the
+ *      initiator is %REGDOM_SET_BY_CORE).
+ * @strict_regulatory: tells us the driver for this device will ignore
+ *      regulatory domain settings until it gets its own regulatory domain
+ *      via its regulatory_hint(). After its gets its own regulatory domain
+ *      it will only allow further regulatory domain settings to further
+ *      enhance compliance. For example if channel 13 and 14 are disabled
+ *      by this regulatory domain no user regulatory domain can enable these
+ *      channels at a later time. This can be used for devices which do not
+ *      have calibration information gauranteed for frequencies or settings
+ *      outside of its regulatory domain.
+ * @disable_beacon_hints: enable this if your driver needs to ensure that
+ *      passive scan flags and beaconing flags may not be lifted by cfg80211
+ *      due to regulatory beacon hints. For more information on beacon
+ *      hints read the documenation for regulatory_hint_found_beacon()
+ * @reg_notifier: the driver's regulatory notification callback
+ * @regd: the driver's regulatory domain, if one was requested via
+ *      the regulatory_hint() API. This can be used by the driver
+ *      on the reg_notifier() if it chooses to ignore future
+ *      regulatory domain changes caused by other drivers.
+ * @signal_type: signal type reported in &struct cfg80211_bss.
+ * @cipher_suites: supported cipher suites
+ * @n_cipher_suites: number of supported cipher suites
+ * @retry_short: Retry limit for short frames (dot11ShortRetryLimit)
+ * @retry_long: Retry limit for long frames (dot11LongRetryLimit)
+ * @frag_threshold: Fragmentation threshold (dot11FragmentationThreshold);
+ *      -1 = fragmentation disabled, only odd values >= 256 used
+ * @rts_threshold: RTS threshold (dot11RTSThreshold); -1 = RTS/CTS disabled
+ */
+struct wiphy {
+        /* assign these fields before you register the wiphy */
+
+        /* permanent MAC address */
+        u8 perm_addr[ETH_ALEN];
+
+        /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */
+        u16 interface_modes;
+
+        bool custom_regulatory;
+        bool strict_regulatory;
+        bool disable_beacon_hints;
+
+        enum cfg80211_signal_type signal_type;
+
+        int bss_priv_size;
+        u8 max_scan_ssids;
+        u16 max_scan_ie_len;
+
+        int n_cipher_suites;
+        const u32 *cipher_suites;
+
+        u8 retry_short;
+        u8 retry_long;
+        u32 frag_threshold;
+        u32 rts_threshold;
+
+        /* If multiple wiphys are registered and you're handed e.g.
+         * a regular netdev with assigned ieee80211_ptr, you won't
+         * know whether it points to a wiphy your driver has registered
+         * or not. Assign this to something global to your driver to
+         * help determine whether you own this wiphy or not. */
+        const void *privid;
+
+        struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS];
+
+        /* Lets us get back the wiphy on the callback */
+        int (*reg_notifier)(struct wiphy *wiphy,
+                            struct regulatory_request *request);
+
+        /* fields below are read-only, assigned by cfg80211 */
+
+        const struct ieee80211_regdomain *regd;
+
+        /* the item in /sys/class/ieee80211/ points to this,
+         * you need use set_wiphy_dev() (see below) */
+        struct device dev;
+
+        /* dir in debugfs: ieee80211/<wiphyname> */
+        struct dentry *debugfsdir;
+
+        char priv[0] __attribute__((__aligned__(NETDEV_ALIGN)));
+};
+
+/**
+ * wiphy_priv - return priv from wiphy
+ *
+ * @wiphy: the wiphy whose priv pointer to return
+ */
+static inline void *wiphy_priv(struct wiphy *wiphy)
+{
+        BUG_ON(!wiphy);
+        return &wiphy->priv;
+}
+
+/**
+ * set_wiphy_dev - set device pointer for wiphy
+ *
+ * @wiphy: The wiphy whose device to bind
+ * @dev: The device to parent it to
+ */
+static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev)
+{
+        wiphy->dev.parent = dev;
+}
+
+/**
+ * wiphy_dev - get wiphy dev pointer
+ *
+ * @wiphy: The wiphy whose device struct to look up
+ */
+static inline struct device *wiphy_dev(struct wiphy *wiphy)
+{
+        return wiphy->dev.parent;
+}
+
+/**
+ * wiphy_name - get wiphy name
+ *
+ * @wiphy: The wiphy whose name to return
+ */
+static inline const char *wiphy_name(struct wiphy *wiphy)
+{
+        return dev_name(&wiphy->dev);
+}
+
+/**
+ * wiphy_new - create a new wiphy for use with cfg80211
+ *
+ * @ops: The configuration operations for this device
+ * @sizeof_priv: The size of the private area to allocate
+ *
+ * Create a new wiphy and associate the given operations with it.
+ * @sizeof_priv bytes are allocated for private use.
+ *
+ * The returned pointer must be assigned to each netdev's
+ * ieee80211_ptr for proper operation.
+ */
+struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv);
+
+/**
+ * wiphy_register - register a wiphy with cfg80211
+ *
+ * @wiphy: The wiphy to register.
+ *
+ * Returns a non-negative wiphy index or a negative error code.
+ */
+extern int wiphy_register(struct wiphy *wiphy);
+
+/**
+ * wiphy_unregister - deregister a wiphy from cfg80211
+ *
+ * @wiphy: The wiphy to unregister.
+ *
+ * After this call, no more requests can be made with this priv
+ * pointer, but the call may sleep to wait for an outstanding
+ * request that is being handled.
+ */
+extern void wiphy_unregister(struct wiphy *wiphy);
+
+/**
+ * wiphy_free - free wiphy
+ *
+ * @wiphy: The wiphy to free
+ */
+extern void wiphy_free(struct wiphy *wiphy);
+
+/**
+ * struct wireless_dev - wireless per-netdev state
+ *
+ * This structure must be allocated by the driver/stack
+ * that uses the ieee80211_ptr field in struct net_device
+ * (this is intentional so it can be allocated along with
+ * the netdev.)
+ *
+ * @wiphy: pointer to hardware description
+ * @iftype: interface type
+ * @list: (private) Used to collect the interfaces
+ * @netdev: (private) Used to reference back to the netdev
+ * @current_bss: (private) Used by the internal configuration code
+ * @bssid: (private) Used by the internal configuration code
+ * @ssid: (private) Used by the internal configuration code
+ * @ssid_len: (private) Used by the internal configuration code
+ * @wext: (private) Used by the internal wireless extensions compat code
+ * @wext_bssid: (private) Used by the internal wireless extensions compat code
+ */
+struct wireless_dev {
+        struct wiphy *wiphy;
+        enum nl80211_iftype iftype;
+
+        /* private to the generic wireless code */
+        struct list_head list;
+        struct net_device *netdev;
+
+        /* currently used for IBSS - might be rearranged in the future */
+        struct cfg80211_bss *current_bss;
+        u8 bssid[ETH_ALEN];
+        u8 ssid[IEEE80211_MAX_SSID_LEN];
+        u8 ssid_len;
+
+#ifdef CONFIG_WIRELESS_EXT
+        /* wext data */
+        struct {
+                struct cfg80211_ibss_params ibss;
+                u8 bssid[ETH_ALEN];
+                s8 default_key, default_mgmt_key;
+        } wext;
+#endif
+};
+
+/**
+ * wdev_priv - return wiphy priv from wireless_dev
+ *
+ * @wdev: The wireless device whose wiphy's priv pointer to return
+ */
+static inline void *wdev_priv(struct wireless_dev *wdev)
+{
+        BUG_ON(!wdev);
+        return wiphy_priv(wdev->wiphy);
+}
+
+/*
+ * Utility functions
+ */
+
+/**
+ * ieee80211_channel_to_frequency - convert channel number to frequency
+ */
+extern int ieee80211_channel_to_frequency(int chan);
+
+/**
+ * ieee80211_frequency_to_channel - convert frequency to channel number
+ */
+extern int ieee80211_frequency_to_channel(int freq);
+
+/*
+ * Name indirection necessary because the ieee80211 code also has
+ * a function named "ieee80211_get_channel", so if you include
+ * cfg80211's header file you get cfg80211's version, if you try
+ * to include both header files you'll (rightfully!) get a symbol
+ * clash.
+ */
+extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy,
+                                                         int freq);
+/**
+ * ieee80211_get_channel - get channel struct from wiphy for specified frequency
+ */
+static inline struct ieee80211_channel *
+ieee80211_get_channel(struct wiphy *wiphy, int freq)
+{
+        return __ieee80211_get_channel(wiphy, freq);
+}
+
+/**
+ * ieee80211_get_response_rate - get basic rate for a given rate
+ *
+ * @sband: the band to look for rates in
+ * @basic_rates: bitmap of basic rates
+ * @bitrate: the bitrate for which to find the basic rate
+ *
+ * This function returns the basic rate corresponding to a given
+ * bitrate, that is the next lower bitrate contained in the basic
+ * rate map, which is, for this function, given as a bitmap of
+ * indices of rates in the band's bitrate table.
+ */
+struct ieee80211_rate *
+ieee80211_get_response_rate(struct ieee80211_supported_band *sband,
+                            u32 basic_rates, int bitrate);
+
+/*
+ * Radiotap parsing functions -- for controlled injection support
+ *
+ * Implemented in net/wireless/radiotap.c
+ * Documentation in Documentation/networking/radiotap-headers.txt
+ */
+
+/**
+ * struct ieee80211_radiotap_iterator - tracks walk thru present radiotap args
+ * @rtheader: pointer to the radiotap header we are walking through
+ * @max_length: length of radiotap header in cpu byte ordering
+ * @this_arg_index: IEEE80211_RADIOTAP_... index of current arg
+ * @this_arg: pointer to current radiotap arg
+ * @arg_index: internal next argument index
+ * @arg: internal next argument pointer
+ * @next_bitmap: internal pointer to next present u32
+ * @bitmap_shifter: internal shifter for curr u32 bitmap, b0 set == arg present
+ */
+
+struct ieee80211_radiotap_iterator {
+        struct ieee80211_radiotap_header *rtheader;
+        int max_length;
+        int this_arg_index;
+        u8 *this_arg;
+
+        int arg_index;
+        u8 *arg;
+        __le32 *next_bitmap;
+        u32 bitmap_shifter;
+};
+
+extern int ieee80211_radiotap_iterator_init(
+   struct ieee80211_radiotap_iterator *iterator,
+   struct ieee80211_radiotap_header *radiotap_header,
+   int max_length);
+
+extern int ieee80211_radiotap_iterator_next(
+   struct ieee80211_radiotap_iterator *iterator);
+
+extern const unsigned char rfc1042_header[6];
+extern const unsigned char bridge_tunnel_header[6];
+
+/**
+ * ieee80211_get_hdrlen_from_skb - get header length from data
+ *
+ * Given an skb with a raw 802.11 header at the data pointer this function
+ * returns the 802.11 header length in bytes (not including encryption
+ * headers). If the data in the sk_buff is too short to contain a valid 802.11
+ * header the function returns 0.
+ *
+ * @skb: the frame
+ */
+unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb);
+
+/**
+ * ieee80211_hdrlen - get header length in bytes from frame control
+ * @fc: frame control field in little-endian format
+ */
+unsigned int ieee80211_hdrlen(__le16 fc);
+
+/**
+ * ieee80211_data_to_8023 - convert an 802.11 data frame to 802.3
+ * @skb: the 802.11 data frame
+ * @addr: the device MAC address
+ * @iftype: the virtual interface type
+ */
+int ieee80211_data_to_8023(struct sk_buff *skb, u8 *addr,
+                           enum nl80211_iftype iftype);
+
+/**
+ * ieee80211_data_from_8023 - convert an 802.3 frame to 802.11
+ * @skb: the 802.3 frame
+ * @addr: the device MAC address
+ * @iftype: the virtual interface type
+ * @bssid: the network bssid (used only for iftype STATION and ADHOC)
+ * @qos: build 802.11 QoS data frame
+ */
+int ieee80211_data_from_8023(struct sk_buff *skb, u8 *addr,
+                             enum nl80211_iftype iftype, u8 *bssid, bool qos);
+
+/**
+ * cfg80211_classify8021d - determine the 802.1p/1d tag for a data frame
+ * @skb: the data frame
+ */
+unsigned int cfg80211_classify8021d(struct sk_buff *skb);
+
+/*
+ * Regulatory helper functions for wiphys
+ */
+
+/**
+ * regulatory_hint - driver hint to the wireless core a regulatory domain
+ * @wiphy: the wireless device giving the hint (used only for reporting
+ *      conflicts)
+ * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain
+ *      should be in. If @rd is set this should be NULL. Note that if you
+ *      set this to NULL you should still set rd->alpha2 to some accepted
+ *      alpha2.
+ *
+ * Wireless drivers can use this function to hint to the wireless core
+ * what it believes should be the current regulatory domain by
+ * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory
+ * domain should be in or by providing a completely build regulatory domain.
+ * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried
+ * for a regulatory domain structure for the respective country.
+ *
+ * The wiphy must have been registered to cfg80211 prior to this call.
+ * For cfg80211 drivers this means you must first use wiphy_register(),
+ * for mac80211 drivers you must first use ieee80211_register_hw().
+ *
+ * Drivers should check the return value, its possible you can get
+ * an -ENOMEM.
+ */
+extern int regulatory_hint(struct wiphy *wiphy, const char *alpha2);
+
+/**
+ * regulatory_hint_11d - hints a country IE as a regulatory domain
+ * @wiphy: the wireless device giving the hint (used only for reporting
+ *      conflicts)
+ * @country_ie: pointer to the country IE
+ * @country_ie_len: length of the country IE
+ *
+ * We will intersect the rd with the what CRDA tells us should apply
+ * for the alpha2 this country IE belongs to, this prevents APs from
+ * sending us incorrect or outdated information against a country.
+ */
+extern void regulatory_hint_11d(struct wiphy *wiphy,
+                                u8 *country_ie,
+                                u8 country_ie_len);
+/**
+ * wiphy_apply_custom_regulatory - apply a custom driver regulatory domain
+ * @wiphy: the wireless device we want to process the regulatory domain on
+ * @regd: the custom regulatory domain to use for this wiphy
+ *
+ * Drivers can sometimes have custom regulatory domains which do not apply
+ * to a specific country. Drivers can use this to apply such custom regulatory
+ * domains. This routine must be called prior to wiphy registration. The
+ * custom regulatory domain will be trusted completely and as such previous
+ * default channel settings will be disregarded. If no rule is found for a
+ * channel on the regulatory domain the channel will be disabled.
+ */
+extern void wiphy_apply_custom_regulatory(
+        struct wiphy *wiphy,
+        const struct ieee80211_regdomain *regd);
+
+/**
+ * freq_reg_info - get regulatory information for the given frequency
+ * @wiphy: the wiphy for which we want to process this rule for
+ * @center_freq: Frequency in KHz for which we want regulatory information for
+ * @desired_bw_khz: the desired max bandwidth you want to use per
+ *      channel. Note that this is still 20 MHz if you want to use HT40
+ *      as HT40 makes use of two channels for its 40 MHz width bandwidth.
+ *      If set to 0 we'll assume you want the standard 20 MHz.
+ * @reg_rule: the regulatory rule which we have for this frequency
+ *
+ * Use this function to get the regulatory rule for a specific frequency on
+ * a given wireless device. If the device has a specific regulatory domain
+ * it wants to follow we respect that unless a country IE has been received
+ * and processed already.
+ *
+ * Returns 0 if it was able to find a valid regulatory rule which does
+ * apply to the given center_freq otherwise it returns non-zero. It will
+ * also return -ERANGE if we determine the given center_freq does not even have
+ * a regulatory rule for a frequency range in the center_freq's band. See
+ * freq_in_rule_band() for our current definition of a band -- this is purely
+ * subjective and right now its 802.11 specific.
+ */
+extern int freq_reg_info(struct wiphy *wiphy,
+                         u32 center_freq,
+                         u32 desired_bw_khz,
+                         const struct ieee80211_reg_rule **reg_rule);
+
+/*
+ * Temporary wext handlers & helper functions
+ *
+ * In the future cfg80211 will simply assign the entire wext handler
+ * structure to netdevs it manages, but we're not there yet.
+ */
 int cfg80211_wext_giwname(struct net_device *dev,
                           struct iw_request_info *info,
                           char *name, char *extra);
@@ -834,9 +1427,72 @@ int cfg80211_wext_siwscan(struct net_device *dev,
 int cfg80211_wext_giwscan(struct net_device *dev,
                           struct iw_request_info *info,
                           struct iw_point *data, char *extra);
+int cfg80211_wext_siwmlme(struct net_device *dev,
+                          struct iw_request_info *info,
+                          struct iw_point *data, char *extra);
 int cfg80211_wext_giwrange(struct net_device *dev,
                            struct iw_request_info *info,
                            struct iw_point *data, char *extra);
+int cfg80211_ibss_wext_siwfreq(struct net_device *dev,
+                               struct iw_request_info *info,
+                               struct iw_freq *freq, char *extra);
+int cfg80211_ibss_wext_giwfreq(struct net_device *dev,
+                               struct iw_request_info *info,
+                               struct iw_freq *freq, char *extra);
+int cfg80211_ibss_wext_siwessid(struct net_device *dev,
+                                struct iw_request_info *info,
+                                struct iw_point *data, char *ssid);
+int cfg80211_ibss_wext_giwessid(struct net_device *dev,
+                                struct iw_request_info *info,
+                                struct iw_point *data, char *ssid);
+int cfg80211_ibss_wext_siwap(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct sockaddr *ap_addr, char *extra);
+int cfg80211_ibss_wext_giwap(struct net_device *dev,
+                             struct iw_request_info *info,
+                             struct sockaddr *ap_addr, char *extra);
+
+struct ieee80211_channel *cfg80211_wext_freq(struct wiphy *wiphy,
+                                             struct iw_freq *freq);
+
+int cfg80211_wext_siwrts(struct net_device *dev,
+                         struct iw_request_info *info,
+                         struct iw_param *rts, char *extra);
+int cfg80211_wext_giwrts(struct net_device *dev,
+                         struct iw_request_info *info,
+                         struct iw_param *rts, char *extra);
+int cfg80211_wext_siwfrag(struct net_device *dev,
+                          struct iw_request_info *info,
+                          struct iw_param *frag, char *extra);
+int cfg80211_wext_giwfrag(struct net_device *dev,
+                          struct iw_request_info *info,
+                          struct iw_param *frag, char *extra);
+int cfg80211_wext_siwretry(struct net_device *dev,
+                           struct iw_request_info *info,
+                           struct iw_param *retry, char *extra);
+int cfg80211_wext_giwretry(struct net_device *dev,
+                           struct iw_request_info *info,
+                           struct iw_param *retry, char *extra);
+int cfg80211_wext_siwencodeext(struct net_device *dev,
+                               struct iw_request_info *info,
+                               struct iw_point *erq, char *extra);
+int cfg80211_wext_siwencode(struct net_device *dev,
+                            struct iw_request_info *info,
+                            struct iw_point *erq, char *keybuf);
+int cfg80211_wext_giwencode(struct net_device *dev,
+                            struct iw_request_info *info,
+                            struct iw_point *erq, char *keybuf);
+int cfg80211_wext_siwtxpower(struct net_device *dev,
+                             struct iw_request_info *info,
+                             union iwreq_data *data, char *keybuf);
+int cfg80211_wext_giwtxpower(struct net_device *dev,
+                             struct iw_request_info *info,
+                             union iwreq_data *data, char *keybuf);
+
+/*
+ * callbacks for asynchronous cfg80211 methods, notification
+ * functions and BSS handling helpers
+ */
 
 /**
  * cfg80211_scan_done - notify that scan finished
@@ -864,6 +1520,14 @@ cfg80211_inform_bss_frame(struct wiphy *wiphy,
                           struct ieee80211_mgmt *mgmt, size_t len,
                           s32 signal, gfp_t gfp);
 
+struct cfg80211_bss*
+cfg80211_inform_bss(struct wiphy *wiphy,
+                    struct ieee80211_channel *channel,
+                    const u8 *bssid,
+                    u64 timestamp, u16 capability, u16 beacon_interval,
+                    const u8 *ie, size_t ielen,
+                    s32 signal, gfp_t gfp);
+
 struct cfg80211_bss *cfg80211_get_bss(struct wiphy *wiphy,
                                       struct ieee80211_channel *channel,
                                       const u8 *bssid,
@@ -883,6 +1547,7 @@ struct cfg80211_bss *cfg80211_get_mesh(struct wiphy *wiphy,
                                        const u8 *meshid, size_t meshidlen,
                                        const u8 *meshcfg);
 void cfg80211_put_bss(struct cfg80211_bss *bss);
+
 /**
  * cfg80211_unlink_bss - unlink BSS from internal data structures
  * @wiphy: the wiphy
@@ -902,44 +1567,62 @@ void cfg80211_unlink_bss(struct wiphy *wiphy, struct cfg80211_bss *bss);
  * @len: length of the frame data
  *
  * This function is called whenever an authentication has been processed in
- * station mode.
+ * station mode. The driver is required to call either this function or
+ * cfg80211_send_auth_timeout() to indicate the result of cfg80211_ops::auth()
+ * call.
  */
 void cfg80211_send_rx_auth(struct net_device *dev, const u8 *buf, size_t len);
 
 /**
+ * cfg80211_send_auth_timeout - notification of timed out authentication
+ * @dev: network device
+ * @addr: The MAC address of the device with which the authentication timed out
+ */
+void cfg80211_send_auth_timeout(struct net_device *dev, const u8 *addr);
+
+/**
  * cfg80211_send_rx_assoc - notification of processed association
  * @dev: network device
  * @buf: (re)association response frame (header + body)
  * @len: length of the frame data
  *
  * This function is called whenever a (re)association response has been
- * processed in station mode.
+ * processed in station mode. The driver is required to call either this
+ * function or cfg80211_send_assoc_timeout() to indicate the result of
+ * cfg80211_ops::assoc() call.
  */
 void cfg80211_send_rx_assoc(struct net_device *dev, const u8 *buf, size_t len);
 
 /**
- * cfg80211_send_rx_deauth - notification of processed deauthentication
+ * cfg80211_send_assoc_timeout - notification of timed out association
+ * @dev: network device
+ * @addr: The MAC address of the device with which the association timed out
+ */
+void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr);
+
+/**
+ * cfg80211_send_deauth - notification of processed deauthentication
  * @dev: network device
  * @buf: deauthentication frame (header + body)
  * @len: length of the frame data
  *
  * This function is called whenever deauthentication has been processed in
- * station mode.
+ * station mode. This includes both received deauthentication frames and
+ * locally generated ones.
  */
-void cfg80211_send_rx_deauth(struct net_device *dev, const u8 *buf,
-                             size_t len);
+void cfg80211_send_deauth(struct net_device *dev, const u8 *buf, size_t len);
 
 /**
- * cfg80211_send_rx_disassoc - notification of processed disassociation
+ * cfg80211_send_disassoc - notification of processed disassociation
  * @dev: network device
  * @buf: disassociation response frame (header + body)
  * @len: length of the frame data
  *
  * This function is called whenever disassociation has been processed in
- * station mode.
+ * station mode. This includes both received disassociation frames and locally
+ * generated ones.
  */
-void cfg80211_send_rx_disassoc(struct net_device *dev, const u8 *buf,
-                               size_t len);
+void cfg80211_send_disassoc(struct net_device *dev, const u8 *buf, size_t len);
 
 /**
  * cfg80211_hold_bss - exclude bss from expiration
@@ -958,4 +1641,55 @@ void cfg80211_hold_bss(struct cfg80211_bss *bss);
  */
 void cfg80211_unhold_bss(struct cfg80211_bss *bss);
 
+/**
+ * cfg80211_michael_mic_failure - notification of Michael MIC failure (TKIP)
+ * @dev: network device
+ * @addr: The source MAC address of the frame
+ * @key_type: The key type that the received frame used
+ * @key_id: Key identifier (0..3)
+ * @tsc: The TSC value of the frame that generated the MIC failure (6 octets)
+ *
+ * This function is called whenever the local MAC detects a MIC failure in a
+ * received frame. This matches with MLME-MICHAELMICFAILURE.indication()
+ * primitive.
+ */
+void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
+                                  enum nl80211_key_type key_type, int key_id,
+                                  const u8 *tsc);
+
+/**
+ * cfg80211_ibss_joined - notify cfg80211 that device joined an IBSS
+ *
+ * @dev: network device
+ * @bssid: the BSSID of the IBSS joined
+ * @gfp: allocation flags
+ *
+ * This function notifies cfg80211 that the device joined an IBSS or
+ * switched to a different BSSID. Before this function can be called,
+ * either a beacon has to have been received from the IBSS, or one of
+ * the cfg80211_inform_bss{,_frame} functions must have been called
+ * with the locally generated beacon -- this guarantees that there is
+ * always a scan result for this IBSS. cfg80211 will handle the rest.
+ */
+void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp);
+
+/**
+ * wiphy_rfkill_set_hw_state - notify cfg80211 about hw block state
+ * @wiphy: the wiphy
+ * @blocked: block status
+ */
+void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked);
+
+/**
+ * wiphy_rfkill_start_polling - start polling rfkill
+ * @wiphy: the wiphy
+ */
+void wiphy_rfkill_start_polling(struct wiphy *wiphy);
+
+/**
+ * wiphy_rfkill_stop_polling - stop polling rfkill
+ * @wiphy: the wiphy
+ */
+void wiphy_rfkill_stop_polling(struct wiphy *wiphy);
+
 #endif /* __NET_CFG80211_H */
diff --git a/include/net/dst.h b/include/net/dst.h
index 6be3b082a070..7fc409c19b37 100644
--- a/include/net/dst.h
+++ b/include/net/dst.h
@@ -195,6 +195,12 @@ struct dst_entry * dst_clone(struct dst_entry * dst)
 }
 
 extern void dst_release(struct dst_entry *dst);
+static inline void skb_dst_drop(struct sk_buff *skb)
+{
+        if (skb->_skb_dst)
+                dst_release(skb_dst(skb));
+        skb->_skb_dst = 0UL;
+}
 
 /* Children define the path of the packet through the
  * Linux networking.  Thus, destinations are stackable.
@@ -246,7 +252,7 @@ static inline void dst_negative_advice(struct dst_entry **dst_p)
 
 static inline void dst_link_failure(struct sk_buff *skb)
 {
-        struct dst_entry * dst = skb->dst;
+        struct dst_entry *dst = skb_dst(skb);
         if (dst && dst->ops && dst->ops->link_failure)
                 dst->ops->link_failure(skb);
 }
@@ -265,13 +271,13 @@ static inline void dst_set_expires(struct dst_entry *dst, int timeout)
 /* Output packet to network from transport.  */
 static inline int dst_output(struct sk_buff *skb)
 {
-        return skb->dst->output(skb);
+        return skb_dst(skb)->output(skb);
 }
 
 /* Input packet from network to transport.  */
 static inline int dst_input(struct sk_buff *skb)
 {
-        return skb->dst->input(skb);
+        return skb_dst(skb)->input(skb);
 }
 
 static inline struct dst_entry *dst_check(struct dst_entry *dst, u32 cookie)
diff --git a/include/net/fib_rules.h b/include/net/fib_rules.h
index c2bb5cae6515..ca4b2e840078 100644
--- a/include/net/fib_rules.h
+++ b/include/net/fib_rules.h
@@ -48,14 +48,12 @@ struct fib_rules_ops
                                          struct flowi *, int);
         int                     (*configure)(struct fib_rule *,
                                              struct sk_buff *,
-                                             struct nlmsghdr *,
                                              struct fib_rule_hdr *,
                                              struct nlattr **);
         int                     (*compare)(struct fib_rule *,
                                            struct fib_rule_hdr *,
                                            struct nlattr **);
         int                     (*fill)(struct fib_rule *, struct sk_buff *,
-                                        struct nlmsghdr *,
                                         struct fib_rule_hdr *);
         u32                     (*default_pref)(struct fib_rules_ops *ops);
         size_t                  (*nlmsg_payload)(struct fib_rule *);
diff --git a/include/net/genetlink.h b/include/net/genetlink.h
index 747c255d1df0..1b0e3ee4ddd8 100644
--- a/include/net/genetlink.h
+++ b/include/net/genetlink.h
@@ -88,6 +88,8 @@ struct genl_ops
 };
 
 extern int genl_register_family(struct genl_family *family);
+extern int genl_register_family_with_ops(struct genl_family *family,
+        struct genl_ops *ops, size_t n_ops);
 extern int genl_unregister_family(struct genl_family *family);
 extern int genl_register_ops(struct genl_family *, struct genl_ops *ops);
 extern int genl_unregister_ops(struct genl_family *, struct genl_ops *ops);
diff --git a/include/net/ieee802154/af_ieee802154.h b/include/net/ieee802154/af_ieee802154.h
new file mode 100644
index 000000000000..0d78605fb1a6
--- /dev/null
+++ b/include/net/ieee802154/af_ieee802154.h
@@ -0,0 +1,60 @@
+/*
+ * IEEE 802.15.4 inteface for userspace
+ *
+ * Copyright 2007, 2008 Siemens AG
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Written by:
+ * Sergey Lapin <slapin@ossfans.org>
+ * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
+ */
+
+#ifndef _AF_IEEE802154_H
+#define _AF_IEEE802154_H
+
+#include <linux/socket.h> /* for sa_family_t */
+
+enum {
+        IEEE802154_ADDR_NONE = 0x0,
+        /* RESERVED = 0x01, */
+        IEEE802154_ADDR_SHORT = 0x2, /* 16-bit address + PANid */
+        IEEE802154_ADDR_LONG = 0x3, /* 64-bit address + PANid */
+};
+
+/* address length, octets */
+#define IEEE802154_ADDR_LEN     8
+
+struct ieee802154_addr {
+        int addr_type;
+        u16 pan_id;
+        union {
+                u8 hwaddr[IEEE802154_ADDR_LEN];
+                u16 short_addr;
+        };
+};
+
+#define IEEE802154_PANID_BROADCAST      0xffff
+#define IEEE802154_ADDR_BROADCAST       0xffff
+#define IEEE802154_ADDR_UNDEF           0xfffe
+
+struct sockaddr_ieee802154 {
+        sa_family_t family; /* AF_IEEE802154 */
+        struct ieee802154_addr addr;
+};
+
+/* master device */
+#define IEEE802154_SIOC_ADD_SLAVE               (SIOCDEVPRIVATE + 0)
+
+#endif
diff --git a/include/net/ieee802154/mac_def.h b/include/net/ieee802154/mac_def.h
new file mode 100644
index 000000000000..8cb684635650
--- /dev/null
+++ b/include/net/ieee802154/mac_def.h
@@ -0,0 +1,160 @@
+/*
+ * IEEE802.15.4-2003 specification
+ *
+ * Copyright (C) 2007, 2008 Siemens AG
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Written by:
+ * Pavel Smolenskiy <pavel.smolenskiy@gmail.com>
+ * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
+ * Maxim Osipov <maxim.osipov@siemens.com>
+ * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
+ */
+
+#ifndef IEEE802154_MAC_DEF_H
+#define IEEE802154_MAC_DEF_H
+
+#define IEEE802154_FC_TYPE_BEACON       0x0     /* Frame is beacon */
+#define IEEE802154_FC_TYPE_DATA         0x1     /* Frame is data */
+#define IEEE802154_FC_TYPE_ACK          0x2     /* Frame is acknowledgment */
+#define IEEE802154_FC_TYPE_MAC_CMD      0x3     /* Frame is MAC command */
+
+#define IEEE802154_FC_TYPE_SHIFT                0
+#define IEEE802154_FC_TYPE_MASK         ((1 << 3) - 1)
+#define IEEE802154_FC_TYPE(x)           ((x & IEEE802154_FC_TYPE_MASK) >> IEEE802154_FC_TYPE_SHIFT)
+#define IEEE802154_FC_SET_TYPE(v, x)    do {    \
+        v = (((v) & ~IEEE802154_FC_TYPE_MASK) | \
+            (((x) << IEEE802154_FC_TYPE_SHIFT) & IEEE802154_FC_TYPE_MASK)); \
+        } while (0)
+
+#define IEEE802154_FC_SECEN             (1 << 3)
+#define IEEE802154_FC_FRPEND            (1 << 4)
+#define IEEE802154_FC_ACK_REQ           (1 << 5)
+#define IEEE802154_FC_INTRA_PAN         (1 << 6)
+
+#define IEEE802154_FC_SAMODE_SHIFT      14
+#define IEEE802154_FC_SAMODE_MASK       (3 << IEEE802154_FC_SAMODE_SHIFT)
+#define IEEE802154_FC_DAMODE_SHIFT      10
+#define IEEE802154_FC_DAMODE_MASK       (3 << IEEE802154_FC_DAMODE_SHIFT)
+
+#define IEEE802154_FC_SAMODE(x)         \
+        (((x) & IEEE802154_FC_SAMODE_MASK) >> IEEE802154_FC_SAMODE_SHIFT)
+
+#define IEEE802154_FC_DAMODE(x)         \
+        (((x) & IEEE802154_FC_DAMODE_MASK) >> IEEE802154_FC_DAMODE_SHIFT)
+
+
+/* MAC's Command Frames Identifiers */
+#define IEEE802154_CMD_ASSOCIATION_REQ          0x01
+#define IEEE802154_CMD_ASSOCIATION_RESP         0x02
+#define IEEE802154_CMD_DISASSOCIATION_NOTIFY    0x03
+#define IEEE802154_CMD_DATA_REQ                 0x04
+#define IEEE802154_CMD_PANID_CONFLICT_NOTIFY    0x05
+#define IEEE802154_CMD_ORPHAN_NOTIFY            0x06
+#define IEEE802154_CMD_BEACON_REQ               0x07
+#define IEEE802154_CMD_COORD_REALIGN_NOTIFY     0x08
+#define IEEE802154_CMD_GTS_REQ                  0x09
+
+/*
+ * The return values of MAC operations
+ */
+enum {
+        /*
+         * The requested operation was completed successfully.
+         * For a transmission request, this value indicates
+         * a successful transmission.
+         */
+        IEEE802154_SUCCESS = 0x0,
+
+        /* The beacon was lost following a synchronization request. */
+        IEEE802154_BEACON_LOSS = 0xe0,
+        /*
+         * A transmission could not take place due to activity on the
+         * channel, i.e., the CSMA-CA mechanism has failed.
+         */
+        IEEE802154_CHNL_ACCESS_FAIL = 0xe1,
+        /* The GTS request has been denied by the PAN coordinator. */
+        IEEE802154_DENINED = 0xe2,
+        /* The attempt to disable the transceiver has failed. */
+        IEEE802154_DISABLE_TRX_FAIL = 0xe3,
+        /*
+         * The received frame induces a failed security check according to
+         * the security suite.
+         */
+        IEEE802154_FAILED_SECURITY_CHECK = 0xe4,
+        /*
+         * The frame resulting from secure processing has a length that is
+         * greater than aMACMaxFrameSize.
+         */
+        IEEE802154_FRAME_TOO_LONG = 0xe5,
+        /*
+         * The requested GTS transmission failed because the specified GTS
+         * either did not have a transmit GTS direction or was not defined.
+         */
+        IEEE802154_INVALID_GTS = 0xe6,
+        /*
+         * A request to purge an MSDU from the transaction queue was made using
+         * an MSDU handle that was not found in the transaction table.
+         */
+        IEEE802154_INVALID_HANDLE = 0xe7,
+        /* A parameter in the primitive is out of the valid range.*/
+        IEEE802154_INVALID_PARAMETER = 0xe8,
+        /* No acknowledgment was received after aMaxFrameRetries. */
+        IEEE802154_NO_ACK = 0xe9,
+        /* A scan operation failed to find any network beacons.*/
+        IEEE802154_NO_BEACON = 0xea,
+        /* No response data were available following a request. */
+        IEEE802154_NO_DATA = 0xeb,
+        /* The operation failed because a short address was not allocated. */
+        IEEE802154_NO_SHORT_ADDRESS = 0xec,
+        /*
+         * A receiver enable request was unsuccessful because it could not be
+         * completed within the CAP.
+         */
+        IEEE802154_OUT_OF_CAP = 0xed,
+        /*
+         * A PAN identifier conflict has been detected and communicated to the
+         * PAN coordinator.
+         */
+        IEEE802154_PANID_CONFLICT = 0xee,
+        /* A coordinator realignment command has been received. */
+        IEEE802154_REALIGMENT = 0xef,
+        /* The transaction has expired and its information discarded. */
+        IEEE802154_TRANSACTION_EXPIRED = 0xf0,
+        /* There is no capacity to store the transaction. */
+        IEEE802154_TRANSACTION_OVERFLOW = 0xf1,
+        /*
+         * The transceiver was in the transmitter enabled state when the
+         * receiver was requested to be enabled.
+         */
+        IEEE802154_TX_ACTIVE = 0xf2,
+        /* The appropriate key is not available in the ACL. */
+        IEEE802154_UNAVAILABLE_KEY = 0xf3,
+        /*
+         * A SET/GET request was issued with the identifier of a PIB attribute
+         * that is not supported.
+         */
+        IEEE802154_UNSUPPORTED_ATTR = 0xf4,
+        /*
+         * A request to perform a scan operation failed because the MLME was
+         * in the process of performing a previously initiated scan operation.
+         */
+        IEEE802154_SCAN_IN_PROGRESS = 0xfc,
+};
+
+
+#endif
+
+
diff --git a/include/net/ieee802154/netdevice.h b/include/net/ieee802154/netdevice.h
new file mode 100644
index 000000000000..e2506af3e7c8
--- /dev/null
+++ b/include/net/ieee802154/netdevice.h
@@ -0,0 +1,115 @@
+/*
+ * An interface between IEEE802.15.4 device and rest of the kernel.
+ *
+ * Copyright (C) 2007, 2008, 2009 Siemens AG
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Written by:
+ * Pavel Smolenskiy <pavel.smolenskiy@gmail.com>
+ * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
+ * Maxim Osipov <maxim.osipov@siemens.com>
+ * Dmitry Eremin-Solenikov <dbaryshkov@gmail.com>
+ */
+
+#ifndef IEEE802154_NETDEVICE_H
+#define IEEE802154_NETDEVICE_H
+
+/*
+ * A control block of skb passed between the ARPHRD_IEEE802154 device
+ * and other stack parts.
+ */
+struct ieee802154_mac_cb {
+        u8 lqi;
+        struct ieee802154_addr sa;
+        struct ieee802154_addr da;
+        u8 flags;
+        u8 seq;
+};
+
+static inline struct ieee802154_mac_cb *mac_cb(struct sk_buff *skb)
+{
+        return (struct ieee802154_mac_cb *)skb->cb;
+}
+
+#define MAC_CB_FLAG_TYPEMASK            ((1 << 3) - 1)
+
+#define MAC_CB_FLAG_ACKREQ              (1 << 3)
+#define MAC_CB_FLAG_SECEN               (1 << 4)
+#define MAC_CB_FLAG_INTRAPAN            (1 << 5)
+
+static inline int mac_cb_is_ackreq(struct sk_buff *skb)
+{
+        return mac_cb(skb)->flags & MAC_CB_FLAG_ACKREQ;
+}
+
+static inline int mac_cb_is_secen(struct sk_buff *skb)
+{
+        return mac_cb(skb)->flags & MAC_CB_FLAG_SECEN;
+}
+
+static inline int mac_cb_is_intrapan(struct sk_buff *skb)
+{
+        return mac_cb(skb)->flags & MAC_CB_FLAG_INTRAPAN;
+}
+
+static inline int mac_cb_type(struct sk_buff *skb)
+{
+        return mac_cb(skb)->flags & MAC_CB_FLAG_TYPEMASK;
+}
+
+#define IEEE802154_MAC_SCAN_ED          0
+#define IEEE802154_MAC_SCAN_ACTIVE      1
+#define IEEE802154_MAC_SCAN_PASSIVE     2
+#define IEEE802154_MAC_SCAN_ORPHAN      3
+
+/*
+ * This should be located at net_device->ml_priv
+ */
+struct ieee802154_mlme_ops {
+        int (*assoc_req)(struct net_device *dev,
+                        struct ieee802154_addr *addr,
+                        u8 channel, u8 cap);
+        int (*assoc_resp)(struct net_device *dev,
+                        struct ieee802154_addr *addr,
+                        u16 short_addr, u8 status);
+        int (*disassoc_req)(struct net_device *dev,
+                        struct ieee802154_addr *addr,
+                        u8 reason);
+        int (*start_req)(struct net_device *dev,
+                        struct ieee802154_addr *addr,
+                        u8 channel, u8 bcn_ord, u8 sf_ord,
+                        u8 pan_coord, u8 blx, u8 coord_realign);
+        int (*scan_req)(struct net_device *dev,
+                        u8 type, u32 channels, u8 duration);
+
+        /*
+         * FIXME: these should become the part of PIB/MIB interface.
+         * However we still don't have IB interface of any kind
+         */
+        u16 (*get_pan_id)(struct net_device *dev);
+        u16 (*get_short_addr)(struct net_device *dev);
+        u8 (*get_dsn)(struct net_device *dev);
+        u8 (*get_bsn)(struct net_device *dev);
+};
+
+static inline struct ieee802154_mlme_ops *ieee802154_mlme_ops(
+                struct net_device *dev)
+{
+        return dev->ml_priv;
+}
+
+#endif
+
+
diff --git a/include/net/ieee802154/nl802154.h b/include/net/ieee802154/nl802154.h
new file mode 100644
index 000000000000..78efcdf52b59
--- /dev/null
+++ b/include/net/ieee802154/nl802154.h
@@ -0,0 +1,41 @@
+/*
+ * nl802154.h
+ *
+ * Copyright (C) 2007, 2008, 2009 Siemens AG
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef IEEE802154_NL_H
+#define IEEE802154_NL_H
+
+struct net_device;
+struct ieee802154_addr;
+
+int ieee802154_nl_assoc_indic(struct net_device *dev,
+                struct ieee802154_addr *addr, u8 cap);
+int ieee802154_nl_assoc_confirm(struct net_device *dev,
+                u16 short_addr, u8 status);
+int ieee802154_nl_disassoc_indic(struct net_device *dev,
+                struct ieee802154_addr *addr, u8 reason);
+int ieee802154_nl_disassoc_confirm(struct net_device *dev,
+                u8 status);
+int ieee802154_nl_scan_confirm(struct net_device *dev,
+                u8 status, u8 scan_type, u32 unscanned,
+                u8 *edl/*, struct list_head *pan_desc_list */);
+int ieee802154_nl_beacon_indic(struct net_device *dev, u16 panid,
+                u16 coord_addr);
+
+#endif
diff --git a/include/net/inet6_hashtables.h b/include/net/inet6_hashtables.h
index f74665d7bea8..22c73a77cd99 100644
--- a/include/net/inet6_hashtables.h
+++ b/include/net/inet6_hashtables.h
@@ -100,7 +100,7 @@ static inline struct sock *__inet6_lookup_skb(struct inet_hashinfo *hashinfo,
 
         if (unlikely(sk = skb_steal_sock(skb)))
                 return sk;
-        else return __inet6_lookup(dev_net(skb->dst->dev), hashinfo,
+        else return __inet6_lookup(dev_net(skb_dst(skb)->dev), hashinfo,
                                    &ipv6_hdr(skb)->saddr, sport,
                                    &ipv6_hdr(skb)->daddr, ntohs(dport),
                                    inet6_iif(skb));
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index a44e2248b2ef..d522dcf3031a 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -385,7 +385,7 @@ static inline struct sock *__inet_lookup_skb(struct inet_hashinfo *hashinfo,
         if (unlikely(sk = skb_steal_sock(skb)))
                 return sk;
         else
-                return __inet_lookup(dev_net(skb->dst->dev), hashinfo,
+                return __inet_lookup(dev_net(skb_dst(skb)->dev), hashinfo,
                                      iph->saddr, sport,
                                      iph->daddr, dport, inet_iif(skb));
 }
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index de0ecc71cf03..47004f35cc7e 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -17,6 +17,7 @@
 #define _INET_SOCK_H
 
 
+#include <linux/kmemcheck.h>
 #include <linux/string.h>
 #include <linux/types.h>
 #include <linux/jhash.h>
@@ -66,14 +67,16 @@ struct inet_request_sock {
         __be32                  loc_addr;
         __be32                  rmt_addr;
         __be16                  rmt_port;
-        u16                     snd_wscale : 4, 
-                                rcv_wscale : 4, 
+        kmemcheck_bitfield_begin(flags);
+        u16                     snd_wscale : 4,
+                                rcv_wscale : 4,
                                 tstamp_ok  : 1,
                                 sack_ok    : 1,
                                 wscale_ok  : 1,
                                 ecn_ok     : 1,
                                 acked      : 1,
                                 no_srccheck: 1;
+        kmemcheck_bitfield_end(flags);
         struct ip_options       *opt;
 };
 
@@ -130,7 +133,8 @@ struct inet_sock {
                                 freebind:1,
                                 hdrincl:1,
                                 mc_loop:1,
-                                transparent:1;
+                                transparent:1,
+                                mc_all:1;
         int                     mc_index;
         __be32                  mc_addr;
         struct ip_mc_socklist   *mc_list;
@@ -198,9 +202,12 @@ static inline int inet_sk_ehashfn(const struct sock *sk)
 static inline struct request_sock *inet_reqsk_alloc(struct request_sock_ops *ops)
 {
         struct request_sock *req = reqsk_alloc(ops);
+        struct inet_request_sock *ireq = inet_rsk(req);
 
-        if (req != NULL)
-                inet_rsk(req)->opt = NULL;
+        if (req != NULL) {
+                kmemcheck_annotate_bitfield(ireq, flags);
+                ireq->opt = NULL;
+        }
 
         return req;
 }
diff --git a/include/net/inet_timewait_sock.h b/include/net/inet_timewait_sock.h
index 4b8ece22b8e9..b63b80fac567 100644
--- a/include/net/inet_timewait_sock.h
+++ b/include/net/inet_timewait_sock.h
@@ -16,6 +16,7 @@
 #define _INET_TIMEWAIT_SOCK_
 
 
+#include <linux/kmemcheck.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/timer.h>
@@ -127,10 +128,12 @@ struct inet_timewait_sock {
         __be32                  tw_rcv_saddr;
         __be16                  tw_dport;
         __u16                   tw_num;
+        kmemcheck_bitfield_begin(flags);
         /* And these are ours. */
         __u8                    tw_ipv6only:1,
                                 tw_transparent:1;
-        /* 15 bits hole, try to pack */
+        /* 14 bits hole, try to pack */
+        kmemcheck_bitfield_end(flags);
         __u16                   tw_ipv6_offset;
         unsigned long           tw_ttd;
         struct inet_bind_bucket *tw_tb;
diff --git a/include/net/ip.h b/include/net/ip.h
index 4ac7577f98d0..72c36926c26d 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -168,7 +168,10 @@ struct ipv4_config
 extern struct ipv4_config ipv4_config;
 #define IP_INC_STATS(net, field)        SNMP_INC_STATS((net)->mib.ip_statistics, field)
 #define IP_INC_STATS_BH(net, field)     SNMP_INC_STATS_BH((net)->mib.ip_statistics, field)
+#define IP_ADD_STATS(net, field, val)   SNMP_ADD_STATS((net)->mib.ip_statistics, field, val)
 #define IP_ADD_STATS_BH(net, field, val) SNMP_ADD_STATS_BH((net)->mib.ip_statistics, field, val)
+#define IP_UPD_PO_STATS(net, field, val) SNMP_UPD_PO_STATS((net)->mib.ip_statistics, field, val)
+#define IP_UPD_PO_STATS_BH(net, field, val) SNMP_UPD_PO_STATS_BH((net)->mib.ip_statistics, field, val)
 #define NET_INC_STATS(net, field)       SNMP_INC_STATS((net)->mib.net_statistics, field)
 #define NET_INC_STATS_BH(net, field)    SNMP_INC_STATS_BH((net)->mib.net_statistics, field)
 #define NET_INC_STATS_USER(net, field)  SNMP_INC_STATS_USER((net)->mib.net_statistics, field)
diff --git a/include/net/ip6_route.h b/include/net/ip6_route.h
index 5f53db7e4e57..0e1b8aebaff8 100644
--- a/include/net/ip6_route.h
+++ b/include/net/ip6_route.h
@@ -142,7 +142,7 @@ static inline void ip6_dst_store(struct sock *sk, struct dst_entry *dst,
 
 static inline int ipv6_unicast_destination(struct sk_buff *skb)
 {
-        struct rt6_info *rt = (struct rt6_info *) skb->dst;
+        struct rt6_info *rt = (struct rt6_info *) skb_dst(skb);
 
         return rt->rt6i_flags & RTF_LOCAL;
 }
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index 8b12667f7a2b..ef91fe924ba4 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -124,14 +124,12 @@ struct fib_result_nl {
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 
 #define FIB_RES_NH(res)         ((res).fi->fib_nh[(res).nh_sel])
-#define FIB_RES_RESET(res)      ((res).nh_sel = 0)
 
 #define FIB_TABLE_HASHSZ 2
 
 #else /* CONFIG_IP_ROUTE_MULTIPATH */
 
 #define FIB_RES_NH(res)         ((res).fi->fib_nh[0])
-#define FIB_RES_RESET(res)
 
 #define FIB_TABLE_HASHSZ 256
 
@@ -145,7 +143,6 @@ struct fib_result_nl {
 struct fib_table {
         struct hlist_node tb_hlist;
         u32             tb_id;
-        unsigned        tb_stamp;
         int             tb_default;
         int             (*tb_lookup)(struct fib_table *tb, const struct flowi *flp, struct fib_result *res);
         int             (*tb_insert)(struct fib_table *, struct fib_config *);
diff --git a/include/net/ipip.h b/include/net/ipip.h
index fdf9bd743705..5d3036fa1511 100644
--- a/include/net/ipip.h
+++ b/include/net/ipip.h
@@ -28,11 +28,18 @@ struct ip_tunnel
         unsigned int                    prl_count;      /* # of entries in PRL */
 };
 
+/* ISATAP: default interval between RS in secondy */
+#define IPTUNNEL_RS_DEFAULT_DELAY       (900)
+
 struct ip_tunnel_prl_entry
 {
         struct ip_tunnel_prl_entry      *next;
         __be32                          addr;
         u16                             flags;
+        unsigned long                   rs_delay;
+        struct timer_list               rs_timer;
+        struct ip_tunnel                *tunnel;
+        spinlock_t                      lock;
 };
 
 #define IPTUNNEL_XMIT() do {                                            \
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index c1f16fc49ade..f27fd83d67d8 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -126,15 +126,28 @@ extern struct ctl_path net_ipv6_ctl_path[];
         SNMP_ADD_STATS##modifier((net)->mib.statname##_statistics, (field), (val));\
 })
 
+#define _DEVUPD(net, statname, modifier, idev, field, val)              \
+({                                                                      \
+        struct inet6_dev *_idev = (idev);                               \
+        if (likely(_idev != NULL))                                      \
+                SNMP_UPD_PO_STATS##modifier((_idev)->stats.statname, field, (val)); \
+        SNMP_UPD_PO_STATS##modifier((net)->mib.statname##_statistics, field, (val));\
+})
+
 /* MIBs */
 
 #define IP6_INC_STATS(net, idev,field)          \
                 _DEVINC(net, ipv6, , idev, field)
 #define IP6_INC_STATS_BH(net, idev,field)       \
                 _DEVINC(net, ipv6, _BH, idev, field)
+#define IP6_ADD_STATS(net, idev,field,val)      \
+                _DEVADD(net, ipv6, , idev, field, val)
 #define IP6_ADD_STATS_BH(net, idev,field,val)   \
                 _DEVADD(net, ipv6, _BH, idev, field, val)
-
+#define IP6_UPD_PO_STATS(net, idev,field,val)   \
+                _DEVUPD(net, ipv6, , idev, field, val)
+#define IP6_UPD_PO_STATS_BH(net, idev,field,val)   \
+                _DEVUPD(net, ipv6, _BH, idev, field, val)
 #define ICMP6_INC_STATS(net, idev, field)       \
                 _DEVINC(net, icmpv6, , idev, field)
 #define ICMP6_INC_STATS_BH(net, idev, field)    \
diff --git a/include/net/iucv/af_iucv.h b/include/net/iucv/af_iucv.h
index 85f80eadfa35..f82a1e877372 100644
--- a/include/net/iucv/af_iucv.h
+++ b/include/net/iucv/af_iucv.h
@@ -73,8 +73,17 @@ struct iucv_sock {
         struct sk_buff_head     backlog_skb_q;
         struct sock_msg_q       message_q;
         unsigned int            send_tag;
+        u8                      flags;
+        u16                     msglimit;
 };
 
+/* iucv socket options (SOL_IUCV) */
+#define SO_IPRMDATA_MSG 0x0080          /* send/recv IPRM_DATA msgs */
+#define SO_MSGLIMIT     0x1000          /* get/set IUCV MSGLIMIT */
+
+/* iucv related control messages (scm) */
+#define SCM_IUCV_TRGCLS 0x0001          /* target class control message */
+
 struct iucv_sock_list {
         struct hlist_head head;
         rwlock_t          lock;
@@ -85,8 +94,6 @@ unsigned int iucv_sock_poll(struct file *file, struct socket *sock,
                             poll_table *wait);
 void iucv_sock_link(struct iucv_sock_list *l, struct sock *s);
 void iucv_sock_unlink(struct iucv_sock_list *l, struct sock *s);
-int  iucv_sock_wait_state(struct sock *sk, int state, int state2,
-                          unsigned long timeo);
 int  iucv_sock_wait_cnt(struct sock *sk, unsigned long timeo);
 void iucv_accept_enqueue(struct sock *parent, struct sock *sk);
 void iucv_accept_unlink(struct sock *sk);
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index 3b83a80e3fe0..c06104476973 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -19,7 +19,6 @@
 #include <linux/wireless.h>
 #include <linux/device.h>
 #include <linux/ieee80211.h>
-#include <net/wireless.h>
 #include <net/cfg80211.h>
 
 /**
@@ -74,22 +73,6 @@
  */
 
 /**
- * struct ieee80211_ht_bss_info - describing BSS's HT characteristics
- *
- * This structure describes most essential parameters needed
- * to describe 802.11n HT characteristics in a BSS.
- *
- * @primary_channel: channel number of primery channel
- * @bss_cap: 802.11n's general BSS capabilities (e.g. channel width)
- * @bss_op_mode: 802.11n's BSS operation modes (e.g. HT protection)
- */
-struct ieee80211_ht_bss_info {
-        u8 primary_channel;
-        u8 bss_cap;  /* use IEEE80211_HT_IE_CHA_ */
-        u8 bss_op_mode; /* use IEEE80211_HT_IE_ */
-};
-
-/**
  * enum ieee80211_max_queues - maximum number of queues
  *
  * @IEEE80211_MAX_QUEUES: Maximum number of regular device queues.
@@ -150,6 +133,13 @@ struct ieee80211_low_level_stats {
  * @BSS_CHANGED_ERP_SLOT: slot timing changed
  * @BSS_CHANGED_HT: 802.11n parameters changed
  * @BSS_CHANGED_BASIC_RATES: Basic rateset changed
+ * @BSS_CHANGED_BEACON_INT: Beacon interval changed
+ * @BSS_CHANGED_BSSID: BSSID changed, for whatever
+ *      reason (IBSS and managed mode)
+ * @BSS_CHANGED_BEACON: Beacon data changed, retrieve
+ *      new beacon (beaconing modes)
+ * @BSS_CHANGED_BEACON_ENABLED: Beaconing should be
+ *      enabled/disabled (beaconing modes)
  */
 enum ieee80211_bss_change {
         BSS_CHANGED_ASSOC               = 1<<0,
@@ -158,14 +148,10 @@ enum ieee80211_bss_change {
         BSS_CHANGED_ERP_SLOT            = 1<<3,
         BSS_CHANGED_HT                  = 1<<4,
         BSS_CHANGED_BASIC_RATES         = 1<<5,
-};
-
-/**
- * struct ieee80211_bss_ht_conf - BSS's changing HT configuration
- * @operation_mode: HT operation mode (like in &struct ieee80211_ht_info)
- */
-struct ieee80211_bss_ht_conf {
-        u16 operation_mode;
+        BSS_CHANGED_BEACON_INT          = 1<<6,
+        BSS_CHANGED_BSSID               = 1<<7,
+        BSS_CHANGED_BEACON              = 1<<8,
+        BSS_CHANGED_BEACON_ENABLED      = 1<<9,
 };
 
 /**
@@ -187,12 +173,16 @@ struct ieee80211_bss_ht_conf {
  * @timestamp: beacon timestamp
  * @beacon_int: beacon interval
  * @assoc_capability: capabilities taken from assoc resp
- * @ht: BSS's HT configuration
  * @basic_rates: bitmap of basic rates, each bit stands for an
  *      index into the rate table configured by the driver in
  *      the current band.
+ * @bssid: The BSSID for this BSS
+ * @enable_beacon: whether beaconing should be enabled or not
+ * @ht_operation_mode: HT operation mode (like in &struct ieee80211_ht_info).
+ *      This field is only valid when the channel type is one of the HT types.
  */
 struct ieee80211_bss_conf {
+        const u8 *bssid;
         /* association related data */
         bool assoc;
         u16 aid;
@@ -200,12 +190,13 @@ struct ieee80211_bss_conf {
         bool use_cts_prot;
         bool use_short_preamble;
         bool use_short_slot;
+        bool enable_beacon;
         u8 dtim_period;
         u16 beacon_int;
         u16 assoc_capability;
         u64 timestamp;
         u32 basic_rates;
-        struct ieee80211_bss_ht_conf ht;
+        u16 ht_operation_mode;
 };
 
 /**
@@ -248,6 +239,8 @@ struct ieee80211_bss_conf {
  * @IEEE80211_TX_INTFL_NEED_TXPROCESSING: completely internal to mac80211,
  *      used to indicate that a pending frame requires TX processing before
  *      it can be sent out.
+ * @IEEE80211_TX_INTFL_RETRIED: completely internal to mac80211,
+ *      used to indicate that a frame was already retried due to PS
  */
 enum mac80211_tx_control_flags {
         IEEE80211_TX_CTL_REQ_TX_STATUS          = BIT(0),
@@ -265,6 +258,7 @@ enum mac80211_tx_control_flags {
         IEEE80211_TX_CTL_RATE_CTRL_PROBE        = BIT(12),
         IEEE80211_TX_INTFL_RCALGO               = BIT(13),
         IEEE80211_TX_INTFL_NEED_TXPROCESSING    = BIT(14),
+        IEEE80211_TX_INTFL_RETRIED              = BIT(15),
 };
 
 /**
@@ -518,52 +512,76 @@ struct ieee80211_rx_status {
  * Flags to define PHY configuration options
  *
  * @IEEE80211_CONF_RADIOTAP: add radiotap header at receive time (if supported)
- * @IEEE80211_CONF_PS: Enable 802.11 power save mode
+ * @IEEE80211_CONF_PS: Enable 802.11 power save mode (managed mode only)
+ * @IEEE80211_CONF_IDLE: The device is running, but idle; if the flag is set
+ *      the driver should be prepared to handle configuration requests but
+ *      may turn the device off as much as possible. Typically, this flag will
+ *      be set when an interface is set UP but not associated or scanning, but
+ *      it can also be unset in that case when monitor interfaces are active.
  */
 enum ieee80211_conf_flags {
         IEEE80211_CONF_RADIOTAP         = (1<<0),
         IEEE80211_CONF_PS               = (1<<1),
+        IEEE80211_CONF_IDLE             = (1<<2),
 };
 
 
 /**
  * enum ieee80211_conf_changed - denotes which configuration changed
  *
- * @IEEE80211_CONF_CHANGE_RADIO_ENABLED: the value of radio_enabled changed
- * @IEEE80211_CONF_CHANGE_BEACON_INTERVAL: the beacon interval changed
+ * @_IEEE80211_CONF_CHANGE_RADIO_ENABLED: DEPRECATED
  * @IEEE80211_CONF_CHANGE_LISTEN_INTERVAL: the listen interval changed
  * @IEEE80211_CONF_CHANGE_RADIOTAP: the radiotap flag changed
- * @IEEE80211_CONF_CHANGE_PS: the PS flag changed
- * @IEEE80211_CONF_CHANGE_DYNPS_TIMEOUT: the dynamic PS timeout changed
+ * @IEEE80211_CONF_CHANGE_PS: the PS flag or dynamic PS timeout changed
  * @IEEE80211_CONF_CHANGE_POWER: the TX power changed
  * @IEEE80211_CONF_CHANGE_CHANNEL: the channel/channel_type changed
  * @IEEE80211_CONF_CHANGE_RETRY_LIMITS: retry limits changed
+ * @IEEE80211_CONF_CHANGE_IDLE: Idle flag changed
  */
 enum ieee80211_conf_changed {
-        IEEE80211_CONF_CHANGE_RADIO_ENABLED     = BIT(0),
-        IEEE80211_CONF_CHANGE_BEACON_INTERVAL   = BIT(1),
+        _IEEE80211_CONF_CHANGE_RADIO_ENABLED    = BIT(0),
         IEEE80211_CONF_CHANGE_LISTEN_INTERVAL   = BIT(2),
         IEEE80211_CONF_CHANGE_RADIOTAP          = BIT(3),
         IEEE80211_CONF_CHANGE_PS                = BIT(4),
-        IEEE80211_CONF_CHANGE_DYNPS_TIMEOUT     = BIT(5),
-        IEEE80211_CONF_CHANGE_POWER             = BIT(6),
-        IEEE80211_CONF_CHANGE_CHANNEL           = BIT(7),
-        IEEE80211_CONF_CHANGE_RETRY_LIMITS      = BIT(8),
+        IEEE80211_CONF_CHANGE_POWER             = BIT(5),
+        IEEE80211_CONF_CHANGE_CHANNEL           = BIT(6),
+        IEEE80211_CONF_CHANGE_RETRY_LIMITS      = BIT(7),
+        IEEE80211_CONF_CHANGE_IDLE              = BIT(8),
 };
 
+static inline __deprecated enum ieee80211_conf_changed
+__IEEE80211_CONF_CHANGE_RADIO_ENABLED(void)
+{
+        return _IEEE80211_CONF_CHANGE_RADIO_ENABLED;
+}
+#define IEEE80211_CONF_CHANGE_RADIO_ENABLED \
+        __IEEE80211_CONF_CHANGE_RADIO_ENABLED()
+
 /**
  * struct ieee80211_conf - configuration of the device
  *
  * This struct indicates how the driver shall configure the hardware.
  *
+ * @flags: configuration flags defined above
+ *
  * @radio_enabled: when zero, driver is required to switch off the radio.
- * @beacon_int: beacon interval (TODO make interface config)
+ * @beacon_int: DEPRECATED, DO NOT USE
+ *
  * @listen_interval: listen interval in units of beacon interval
- * @flags: configuration flags defined above
+ * @max_sleep_period: the maximum number of beacon intervals to sleep for
+ *      before checking the beacon for a TIM bit (managed mode only); this
+ *      value will be only achievable between DTIM frames, the hardware
+ *      needs to check for the multicast traffic bit in DTIM beacons.
+ *      This variable is valid only when the CONF_PS flag is set.
+ * @dynamic_ps_timeout: The dynamic powersave timeout (in ms), see the
+ *      powersave documentation below. This variable is valid only when
+ *      the CONF_PS flag is set.
+ *
  * @power_level: requested transmit power (in dBm)
- * @dynamic_ps_timeout: dynamic powersave timeout (in ms)
+ *
  * @channel: the channel to tune to
  * @channel_type: the channel (HT) type
+ *
  * @long_frame_max_tx_count: Maximum number of transmissions for a "long" frame
  *    (a frame not RTS protected), called "dot11LongRetryLimit" in 802.11,
  *    but actually means the number of transmissions not the number of retries
@@ -572,12 +590,13 @@ enum ieee80211_conf_changed {
  *    number of transmissions not the number of retries
  */
 struct ieee80211_conf {
-        int beacon_int;
+        int __deprecated beacon_int;
         u32 flags;
         int power_level, dynamic_ps_timeout;
+        int max_sleep_period;
 
         u16 listen_interval;
-        bool radio_enabled;
+        bool __deprecated radio_enabled;
 
         u8 long_frame_max_tx_count, short_frame_max_tx_count;
 
@@ -640,37 +659,6 @@ struct ieee80211_if_init_conf {
 };
 
 /**
- * enum ieee80211_if_conf_change - interface config change flags
- *
- * @IEEE80211_IFCC_BSSID: The BSSID changed.
- * @IEEE80211_IFCC_BEACON: The beacon for this interface changed
- *      (currently AP and MESH only), use ieee80211_beacon_get().
- * @IEEE80211_IFCC_BEACON_ENABLED: The enable_beacon value changed.
- */
-enum ieee80211_if_conf_change {
-        IEEE80211_IFCC_BSSID            = BIT(0),
-        IEEE80211_IFCC_BEACON           = BIT(1),
-        IEEE80211_IFCC_BEACON_ENABLED   = BIT(2),
-};
-
-/**
- * struct ieee80211_if_conf - configuration of an interface
- *
- * @changed: parameters that have changed, see &enum ieee80211_if_conf_change.
- * @bssid: BSSID of the network we are associated to/creating.
- * @enable_beacon: Indicates whether beacons can be sent.
- *      This is valid only for AP/IBSS/MESH modes.
- *
- * This structure is passed to the config_interface() callback of
- * &struct ieee80211_hw.
- */
-struct ieee80211_if_conf {
-        u32 changed;
-        const u8 *bssid;
-        bool enable_beacon;
-};
-
-/**
  * enum ieee80211_key_alg - key algorithm
  * @ALG_WEP: WEP40 or WEP104
  * @ALG_TKIP: TKIP
@@ -685,16 +673,6 @@ enum ieee80211_key_alg {
 };
 
 /**
- * enum ieee80211_key_len - key length
- * @LEN_WEP40: WEP 5-byte long key
- * @LEN_WEP104: WEP 13-byte long key
- */
-enum ieee80211_key_len {
-        LEN_WEP40 = 5,
-        LEN_WEP104 = 13,
-};
-
-/**
  * enum ieee80211_key_flags - key flags
  *
  * These flags are used for communication about keys between the driver
@@ -1109,11 +1087,9 @@ ieee80211_get_alt_retry_rate(const struct ieee80211_hw *hw,
  * need software support for parsing the TIM bitmap. This is also supported
  * by mac80211 by combining the %IEEE80211_HW_SUPPORTS_PS and
  * %IEEE80211_HW_PS_NULLFUNC_STACK flags. The hardware is of course still
- * required to pass up beacons. Additionally, in this case, mac80211 will
- * wake up the hardware when multicast traffic is announced in the beacon.
- *
- * FIXME: I don't think we can be fast enough in software when we want to
- *        receive multicast traffic?
+ * required to pass up beacons. The hardware is still required to handle
+ * waking up for multicast traffic; if it cannot the driver must handle that
+ * as best as it can, mac80211 is too slow.
  *
  * Dynamic powersave mode is an extension to normal powersave mode in which
  * the hardware stays awake for a user-specified period of time after sending
@@ -1134,11 +1110,53 @@ ieee80211_get_alt_retry_rate(const struct ieee80211_hw *hw,
  * way the host will only receive beacons where some relevant information
  * (for example ERP protection or WMM settings) have changed.
  *
- * Beacon filter support is informed with %IEEE80211_HW_BEACON_FILTER flag.
- * The driver needs to enable beacon filter support whenever power save is
- * enabled, that is %IEEE80211_CONF_PS is set. When power save is enabled,
- * the stack will not check for beacon miss at all and the driver needs to
- * notify about complete loss of beacons with ieee80211_beacon_loss().
+ * Beacon filter support is advertised with the %IEEE80211_HW_BEACON_FILTER
+ * hardware capability. The driver needs to enable beacon filter support
+ * whenever power save is enabled, that is %IEEE80211_CONF_PS is set. When
+ * power save is enabled, the stack will not check for beacon loss and the
+ * driver needs to notify about loss of beacons with ieee80211_beacon_loss().
+ *
+ * The time (or number of beacons missed) until the firmware notifies the
+ * driver of a beacon loss event (which in turn causes the driver to call
+ * ieee80211_beacon_loss()) should be configurable and will be controlled
+ * by mac80211 and the roaming algorithm in the future.
+ *
+ * Since there may be constantly changing information elements that nothing
+ * in the software stack cares about, we will, in the future, have mac80211
+ * tell the driver which information elements are interesting in the sense
+ * that we want to see changes in them. This will include
+ *  - a list of information element IDs
+ *  - a list of OUIs for the vendor information element
+ *
+ * Ideally, the hardware would filter out any beacons without changes in the
+ * requested elements, but if it cannot support that it may, at the expense
+ * of some efficiency, filter out only a subset. For example, if the device
+ * doesn't support checking for OUIs it should pass up all changes in all
+ * vendor information elements.
+ *
+ * Note that change, for the sake of simplification, also includes information
+ * elements appearing or disappearing from the beacon.
+ *
+ * Some hardware supports an "ignore list" instead, just make sure nothing
+ * that was requested is on the ignore list, and include commonly changing
+ * information element IDs in the ignore list, for example 11 (BSS load) and
+ * the various vendor-assigned IEs with unknown contents (128, 129, 133-136,
+ * 149, 150, 155, 156, 173, 176, 178, 179, 219); for forward compatibility
+ * it could also include some currently unused IDs.
+ *
+ *
+ * In addition to these capabilities, hardware should support notifying the
+ * host of changes in the beacon RSSI. This is relevant to implement roaming
+ * when no traffic is flowing (when traffic is flowing we see the RSSI of
+ * the received data packets). This can consist in notifying the host when
+ * the RSSI changes significantly or when it drops below or rises above
+ * configurable thresholds. In the future these thresholds will also be
+ * configured by mac80211 (which gets them from userspace) to implement
+ * them as the roaming algorithm requires.
+ *
+ * If the hardware cannot implement this, the driver should ask it to
+ * periodically pass beacon frames to the host so that software can do the
+ * signal strength threshold checking.
  */
 
 /**
@@ -1298,10 +1316,6 @@ enum ieee80211_ampdu_mlme_action {
  *      This function should never fail but returns a negative error code
  *      if it does.
  *
- * @config_interface: Handler for configuration requests related to interfaces
- *      (e.g. BSSID changes.)
- *      Returns a negative error code which will be seen in userspace.
- *
  * @bss_info_changed: Handler for configuration requests related to BSS
  *      parameters that may vary during BSS's lifespan, and may affect low
  *      level driver (e.g. assoc/disassoc status, erp parameters).
@@ -1330,11 +1344,14 @@ enum ieee80211_ampdu_mlme_action {
  *      the scan state machine in stack. The scan must honour the channel
  *      configuration done by the regulatory agent in the wiphy's
  *      registered bands. The hardware (or the driver) needs to make sure
- *      that power save is disabled. When the scan finishes,
- *      ieee80211_scan_completed() must be called; note that it also must
- *      be called when the scan cannot finish because the hardware is
- *      turned off! Anything else is a bug! Returns a negative error code
- *      which will be seen in userspace.
+ *      that power save is disabled.
+ *      The @req ie/ie_len members are rewritten by mac80211 to contain the
+ *      entire IEs after the SSID, so that drivers need not look at these
+ *      at all but just send them after the SSID -- mac80211 includes the
+ *      (extended) supported rates and HT information (where applicable).
+ *      When the scan finishes, ieee80211_scan_completed() must be called;
+ *      note that it also must be called when the scan cannot finish due to
+ *      any error unless this callback returned a negative error code.
  *
  * @sw_scan_start: Notifier function that is called just before a software scan
  *      is started. Can be NULL, if the driver doesn't need this notification.
@@ -1390,6 +1407,10 @@ enum ieee80211_ampdu_mlme_action {
  *      is the first frame we expect to perform the action on. Notice
  *      that TX/RX_STOP can pass NULL for this parameter.
  *      Returns a negative error code on failure.
+ *
+ * @rfkill_poll: Poll rfkill hardware state. If you need this, you also
+ *      need to set wiphy->rfkill_poll to %true before registration,
+ *      and need to call wiphy_rfkill_set_hw_state() in the callback.
  */
 struct ieee80211_ops {
         int (*tx)(struct ieee80211_hw *hw, struct sk_buff *skb);
@@ -1400,9 +1421,6 @@ struct ieee80211_ops {
         void (*remove_interface)(struct ieee80211_hw *hw,
                                  struct ieee80211_if_init_conf *conf);
         int (*config)(struct ieee80211_hw *hw, u32 changed);
-        int (*config_interface)(struct ieee80211_hw *hw,
-                                struct ieee80211_vif *vif,
-                                struct ieee80211_if_conf *conf);
         void (*bss_info_changed)(struct ieee80211_hw *hw,
                                  struct ieee80211_vif *vif,
                                  struct ieee80211_bss_conf *info,
@@ -1441,6 +1459,8 @@ struct ieee80211_ops {
         int (*ampdu_action)(struct ieee80211_hw *hw,
                             enum ieee80211_ampdu_mlme_action action,
                             struct ieee80211_sta *sta, u16 tid, u16 *ssn);
+
+        void (*rfkill_poll)(struct ieee80211_hw *hw);
 };
 
 /**
@@ -1572,6 +1592,20 @@ void ieee80211_unregister_hw(struct ieee80211_hw *hw);
  */
 void ieee80211_free_hw(struct ieee80211_hw *hw);
 
+/**
+ * ieee80211_restart_hw - restart hardware completely
+ *
+ * Call this function when the hardware was restarted for some reason
+ * (hardware error, ...) and the driver is unable to restore its state
+ * by itself. mac80211 assumes that at this point the driver/hardware
+ * is completely uninitialised and stopped, it starts the process by
+ * calling the ->start() operation. The driver will need to reset all
+ * internal state that it has prior to calling this function.
+ *
+ * @hw: the hardware to restart
+ */
+void ieee80211_restart_hw(struct ieee80211_hw *hw);
+
 /* trick to avoid symbol clashes with the ieee80211 subsystem */
 void __ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb,
                     struct ieee80211_rx_status *status);
@@ -1775,24 +1809,6 @@ struct sk_buff *
 ieee80211_get_buffered_bc(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
 
 /**
- * ieee80211_get_hdrlen_from_skb - get header length from data
- *
- * Given an skb with a raw 802.11 header at the data pointer this function
- * returns the 802.11 header length in bytes (not including encryption
- * headers). If the data in the sk_buff is too short to contain a valid 802.11
- * header the function returns 0.
- *
- * @skb: the frame
- */
-unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb);
-
-/**
- * ieee80211_hdrlen - get header length in bytes from frame control
- * @fc: frame control field in little-endian format
- */
-unsigned int ieee80211_hdrlen(__le16 fc);
-
-/**
  * ieee80211_get_tkip_key - get a TKIP rc4 for skb
  *
  * This function computes a TKIP rc4 key for an skb. It computes
diff --git a/include/net/netfilter/ipv4/nf_conntrack_icmp.h b/include/net/netfilter/ipv4/nf_conntrack_icmp.h
deleted file mode 100644
index 3dd22cff23ec..000000000000
--- a/include/net/netfilter/ipv4/nf_conntrack_icmp.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef _NF_CONNTRACK_ICMP_H
-#define _NF_CONNTRACK_ICMP_H
-/* ICMP tracking. */
-#include <asm/atomic.h>
-
-struct ip_ct_icmp
-{
-        /* Optimization: when number in == number out, forget immediately. */
-        atomic_t count;
-};
-#endif /* _NF_CONNTRACK_ICMP_H */
diff --git a/include/net/netfilter/ipv6/nf_conntrack_icmpv6.h b/include/net/netfilter/ipv6/nf_conntrack_icmpv6.h
index 86591afda29c..67edd50a398a 100644
--- a/include/net/netfilter/ipv6/nf_conntrack_icmpv6.h
+++ b/include/net/netfilter/ipv6/nf_conntrack_icmpv6.h
@@ -9,7 +9,6 @@
 
 #ifndef _NF_CONNTRACK_ICMPV6_H
 #define _NF_CONNTRACK_ICMPV6_H
-#include <asm/atomic.h>
 
 #ifndef ICMPV6_NI_QUERY
 #define ICMPV6_NI_QUERY 139
@@ -18,10 +17,4 @@
 #define ICMPV6_NI_REPLY 140
 #endif
 
-struct nf_ct_icmpv6
-{
-        /* Optimization: when number in == number out, forget immediately. */
-        atomic_t count;
-};
-
 #endif /* _NF_CONNTRACK_ICMPV6_H */
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index 6c3f964de9e1..cbdd6284996d 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -23,7 +23,6 @@
 #include <linux/netfilter/nf_conntrack_dccp.h>
 #include <linux/netfilter/nf_conntrack_sctp.h>
 #include <linux/netfilter/nf_conntrack_proto_gre.h>
-#include <net/netfilter/ipv4/nf_conntrack_icmp.h>
 #include <net/netfilter/ipv6/nf_conntrack_icmpv6.h>
 
 #include <net/netfilter/nf_conntrack_tuple.h>
@@ -34,8 +33,6 @@ union nf_conntrack_proto {
         struct nf_ct_dccp dccp;
         struct ip_ct_sctp sctp;
         struct ip_ct_tcp tcp;
-        struct ip_ct_icmp icmp;
-        struct nf_ct_icmpv6 icmpv6;
         struct nf_ct_gre gre;
 };
 
@@ -96,6 +93,8 @@ struct nf_conn {
            plus 1 for any connection(s) we are `master' for */
         struct nf_conntrack ct_general;
 
+        spinlock_t lock;
+
         /* XXX should I move this to the tail ? - Y.K */
         /* These are my tuples; original and reply */
         struct nf_conntrack_tuple_hash tuplehash[IP_CT_DIR_MAX];
@@ -144,6 +143,8 @@ static inline u_int8_t nf_ct_protonum(const struct nf_conn *ct)
         return ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.dst.protonum;
 }
 
+#define nf_ct_tuple(ct, dir) (&(ct)->tuplehash[dir].tuple)
+
 /* get master conntrack via master expectation */
 #define master_ct(conntr) (conntr->master)
 
@@ -200,8 +201,10 @@ extern struct nf_conntrack_tuple_hash *
 __nf_conntrack_find(struct net *net, const struct nf_conntrack_tuple *tuple);
 
 extern void nf_conntrack_hash_insert(struct nf_conn *ct);
+extern void nf_ct_delete_from_lists(struct nf_conn *ct);
+extern void nf_ct_insert_dying_list(struct nf_conn *ct);
 
-extern void nf_conntrack_flush(struct net *net, u32 pid, int report);
+extern void nf_conntrack_flush_report(struct net *net, u32 pid, int report);
 
 extern bool nf_ct_get_tuplepr(const struct sk_buff *skb,
                               unsigned int nhoff, u_int16_t l3num,
@@ -255,8 +258,8 @@ static inline bool nf_ct_kill(struct nf_conn *ct)
 /* Update TCP window tracking data when NAT mangles the packet */
 extern void nf_conntrack_tcp_update(const struct sk_buff *skb,
                                     unsigned int dataoff,
-                                    struct nf_conn *ct,
-                                    int dir);
+                                    struct nf_conn *ct, int dir,
+                                    s16 offset);
 
 /* Fake conntrack entry for untracked connections */
 extern struct nf_conn nf_conntrack_untracked;
diff --git a/include/net/netfilter/nf_conntrack_ecache.h b/include/net/netfilter/nf_conntrack_ecache.h
index 0ff0dc69ca4a..4f20d58e2ab7 100644
--- a/include/net/netfilter/nf_conntrack_ecache.h
+++ b/include/net/netfilter/nf_conntrack_ecache.h
@@ -6,17 +6,54 @@
 #define _NF_CONNTRACK_ECACHE_H
 #include <net/netfilter/nf_conntrack.h>
 
-#include <linux/notifier.h>
-#include <linux/interrupt.h>
 #include <net/net_namespace.h>
 #include <net/netfilter/nf_conntrack_expect.h>
+#include <linux/netfilter/nf_conntrack_common.h>
+#include <linux/netfilter/nf_conntrack_tuple_common.h>
+#include <net/netfilter/nf_conntrack_extend.h>
+
+/* Connection tracking event types */
+enum ip_conntrack_events
+{
+        IPCT_NEW                = 0,    /* new conntrack */
+        IPCT_RELATED            = 1,    /* related conntrack */
+        IPCT_DESTROY            = 2,    /* destroyed conntrack */
+        IPCT_STATUS             = 3,    /* status has changed */
+        IPCT_PROTOINFO          = 4,    /* protocol information has changed */
+        IPCT_HELPER             = 5,    /* new helper has been set */
+        IPCT_MARK               = 6,    /* new mark has been set */
+        IPCT_NATSEQADJ          = 7,    /* NAT is doing sequence adjustment */
+        IPCT_SECMARK            = 8,    /* new security mark has been set */
+};
+
+enum ip_conntrack_expect_events {
+        IPEXP_NEW               = 0,    /* new expectation */
+};
 
-#ifdef CONFIG_NF_CONNTRACK_EVENTS
 struct nf_conntrack_ecache {
-        struct nf_conn *ct;
-        unsigned int events;
+        unsigned long cache;            /* bitops want long */
+        unsigned long missed;           /* missed events */
+        u32 pid;                        /* netlink pid of destroyer */
+};
+
+static inline struct nf_conntrack_ecache *
+nf_ct_ecache_find(const struct nf_conn *ct)
+{
+        return nf_ct_ext_find(ct, NF_CT_EXT_ECACHE);
+}
+
+static inline struct nf_conntrack_ecache *
+nf_ct_ecache_ext_add(struct nf_conn *ct, gfp_t gfp)
+{
+        struct net *net = nf_ct_net(ct);
+
+        if (!net->ct.sysctl_events)
+                return NULL;
+
+        return nf_ct_ext_add(ct, NF_CT_EXT_ECACHE, gfp);
 };
 
+#ifdef CONFIG_NF_CONNTRACK_EVENTS
 /* This structure is passed to event handler */
 struct nf_ct_event {
         struct nf_conn *ct;
@@ -24,47 +61,96 @@ struct nf_ct_event {
         int report;
 };
 
-extern struct atomic_notifier_head nf_conntrack_chain;
-extern int nf_conntrack_register_notifier(struct notifier_block *nb);
-extern int nf_conntrack_unregister_notifier(struct notifier_block *nb);
+struct nf_ct_event_notifier {
+        int (*fcn)(unsigned int events, struct nf_ct_event *item);
+};
+
+extern struct nf_ct_event_notifier *nf_conntrack_event_cb;
+extern int nf_conntrack_register_notifier(struct nf_ct_event_notifier *nb);
+extern void nf_conntrack_unregister_notifier(struct nf_ct_event_notifier *nb);
 
-extern void nf_ct_deliver_cached_events(const struct nf_conn *ct);
-extern void __nf_ct_event_cache_init(struct nf_conn *ct);
-extern void nf_ct_event_cache_flush(struct net *net);
+extern void nf_ct_deliver_cached_events(struct nf_conn *ct);
 
 static inline void
 nf_conntrack_event_cache(enum ip_conntrack_events event, struct nf_conn *ct)
 {
+        struct nf_conntrack_ecache *e;
+
+        if (nf_conntrack_event_cb == NULL)
+                return;
+
+        e = nf_ct_ecache_find(ct);
+        if (e == NULL)
+                return;
+
+        set_bit(event, &e->cache);
+}
+
+static inline int
+nf_conntrack_eventmask_report(unsigned int eventmask,
+                              struct nf_conn *ct,
+                              u32 pid,
+                              int report)
+{
+        int ret = 0;
         struct net *net = nf_ct_net(ct);
-        struct nf_conntrack_ecache *ecache;
-
-        local_bh_disable();
-        ecache = per_cpu_ptr(net->ct.ecache, raw_smp_processor_id());
-        if (ct != ecache->ct)
-                __nf_ct_event_cache_init(ct);
-        ecache->events |= event;
-        local_bh_enable();
+        struct nf_ct_event_notifier *notify;
+        struct nf_conntrack_ecache *e;
+
+        rcu_read_lock();
+        notify = rcu_dereference(nf_conntrack_event_cb);
+        if (notify == NULL)
+                goto out_unlock;
+
+        if (!net->ct.sysctl_events)
+                goto out_unlock;
+
+        e = nf_ct_ecache_find(ct);
+        if (e == NULL)
+                goto out_unlock;
+
+        if (nf_ct_is_confirmed(ct) && !nf_ct_is_dying(ct)) {
+                struct nf_ct_event item = {
+                        .ct     = ct,
+                        .pid    = e->pid ? e->pid : pid,
+                        .report = report
+                };
+                /* This is a resent of a destroy event? If so, skip missed */
+                unsigned long missed = e->pid ? 0 : e->missed;
+
+                ret = notify->fcn(eventmask | missed, &item);
+                if (unlikely(ret < 0 || missed)) {
+                        spin_lock_bh(&ct->lock);
+                        if (ret < 0) {
+                                /* This is a destroy event that has been
+                                 * triggered by a process, we store the PID
+                                 * to include it in the retransmission. */
+                                if (eventmask & (1 << IPCT_DESTROY) &&
+                                    e->pid == 0 && pid != 0)
+                                        e->pid = pid;
+                                else
+                                        e->missed |= eventmask;
+                        } else
+                                e->missed &= ~missed;
+                        spin_unlock_bh(&ct->lock);
+                }
+        }
+out_unlock:
+        rcu_read_unlock();
+        return ret;
 }
 
-static inline void
-nf_conntrack_event_report(enum ip_conntrack_events event,
-                          struct nf_conn *ct,
-                          u32 pid,
-                          int report)
+static inline int
+nf_conntrack_event_report(enum ip_conntrack_events event, struct nf_conn *ct,
+                          u32 pid, int report)
 {
-        struct nf_ct_event item = {
-                .ct     = ct,
-                .pid    = pid,
-                .report = report
-        };
-        if (nf_ct_is_confirmed(ct) && !nf_ct_is_dying(ct))
-                atomic_notifier_call_chain(&nf_conntrack_chain, event, &item);
+        return nf_conntrack_eventmask_report(1 << event, ct, pid, report);
 }
 
-static inline void
+static inline int
 nf_conntrack_event(enum ip_conntrack_events event, struct nf_conn *ct)
 {
-        nf_conntrack_event_report(event, ct, 0, 0);
+        return nf_conntrack_eventmask_report(1 << event, ct, 0, 0);
 }
 
 struct nf_exp_event {
@@ -73,9 +159,13 @@ struct nf_exp_event {
         int report;
 };
 
-extern struct atomic_notifier_head nf_ct_expect_chain;
-extern int nf_ct_expect_register_notifier(struct notifier_block *nb);
-extern int nf_ct_expect_unregister_notifier(struct notifier_block *nb);
+struct nf_exp_event_notifier {
+        int (*fcn)(unsigned int events, struct nf_exp_event *item);
+};
+
+extern struct nf_exp_event_notifier *nf_expect_event_cb;
+extern int nf_ct_expect_register_notifier(struct nf_exp_event_notifier *nb);
+extern void nf_ct_expect_unregister_notifier(struct nf_exp_event_notifier *nb);
 
 static inline void
 nf_ct_expect_event_report(enum ip_conntrack_expect_events event,
@@ -83,12 +173,27 @@ nf_ct_expect_event_report(enum ip_conntrack_expect_events event,
                           u32 pid,
                           int report)
 {
-        struct nf_exp_event item = {
-                .exp    = exp,
-                .pid    = pid,
-                .report = report
-        };
-        atomic_notifier_call_chain(&nf_ct_expect_chain, event, &item);
+        struct net *net = nf_ct_exp_net(exp);
+        struct nf_exp_event_notifier *notify;
+
+        rcu_read_lock();
+        notify = rcu_dereference(nf_expect_event_cb);
+        if (notify == NULL)
+                goto out_unlock;
+
+        if (!net->ct.sysctl_events)
+                goto out_unlock;
+
+        {
+                struct nf_exp_event item = {
+                        .exp    = exp,
+                        .pid    = pid,
+                        .report = report
+                };
+                notify->fcn(1 << event, &item);
+        }
+out_unlock:
+        rcu_read_unlock();
 }
 
 static inline void
@@ -105,12 +210,16 @@ extern void nf_conntrack_ecache_fini(struct net *net);
 
 static inline void nf_conntrack_event_cache(enum ip_conntrack_events event,
                                             struct nf_conn *ct) {}
-static inline void nf_conntrack_event(enum ip_conntrack_events event,
-                                      struct nf_conn *ct) {}
-static inline void nf_conntrack_event_report(enum ip_conntrack_events event,
-                                             struct nf_conn *ct,
-                                             u32 pid,
-                                             int report) {}
+static inline int nf_conntrack_eventmask_report(unsigned int eventmask,
+                                                struct nf_conn *ct,
+                                                u32 pid,
+                                                int report) { return 0; }
+static inline int nf_conntrack_event(enum ip_conntrack_events event,
+                                     struct nf_conn *ct) { return 0; }
+static inline int nf_conntrack_event_report(enum ip_conntrack_events event,
+                                            struct nf_conn *ct,
+                                            u32 pid,
+                                            int report) { return 0; }
 static inline void nf_ct_deliver_cached_events(const struct nf_conn *ct) {}
 static inline void nf_ct_expect_event(enum ip_conntrack_expect_events event,
                                       struct nf_conntrack_expect *exp) {}
@@ -118,7 +227,6 @@ static inline void nf_ct_expect_event_report(enum ip_conntrack_expect_events e,
                                              struct nf_conntrack_expect *exp,
                                              u32 pid,
                                              int report) {}
-static inline void nf_ct_event_cache_flush(struct net *net) {}
 
 static inline int nf_conntrack_ecache_init(struct net *net)
 {
diff --git a/include/net/netfilter/nf_conntrack_extend.h b/include/net/netfilter/nf_conntrack_extend.h
index da8ee52613a5..7f8fc5d123c5 100644
--- a/include/net/netfilter/nf_conntrack_extend.h
+++ b/include/net/netfilter/nf_conntrack_extend.h
@@ -8,12 +8,14 @@ enum nf_ct_ext_id
         NF_CT_EXT_HELPER,
         NF_CT_EXT_NAT,
         NF_CT_EXT_ACCT,
+        NF_CT_EXT_ECACHE,
         NF_CT_EXT_NUM,
 };
 
 #define NF_CT_EXT_HELPER_TYPE struct nf_conn_help
 #define NF_CT_EXT_NAT_TYPE struct nf_conn_nat
 #define NF_CT_EXT_ACCT_TYPE struct nf_conn_counter
+#define NF_CT_EXT_ECACHE_TYPE struct nf_conntrack_ecache
 
 /* Extensions: optional stuff which isn't permanently in struct. */
 struct nf_ct_ext {
diff --git a/include/net/netfilter/nf_conntrack_helper.h b/include/net/netfilter/nf_conntrack_helper.h
index ee2a4b369a04..1b7068000927 100644
--- a/include/net/netfilter/nf_conntrack_helper.h
+++ b/include/net/netfilter/nf_conntrack_helper.h
@@ -50,6 +50,8 @@ extern struct nf_conn_help *nf_ct_helper_ext_add(struct nf_conn *ct, gfp_t gfp);
 
 extern int __nf_ct_try_assign_helper(struct nf_conn *ct, gfp_t flags);
 
+extern void nf_ct_helper_destroy(struct nf_conn *ct);
+
 static inline struct nf_conn_help *nfct_help(const struct nf_conn *ct)
 {
         return nf_ct_ext_find(ct, NF_CT_EXT_HELPER);
diff --git a/include/net/netfilter/nf_conntrack_l4proto.h b/include/net/netfilter/nf_conntrack_l4proto.h
index ba32ed7bdabe..3767fb41e541 100644
--- a/include/net/netfilter/nf_conntrack_l4proto.h
+++ b/include/net/netfilter/nf_conntrack_l4proto.h
@@ -59,11 +59,11 @@ struct nf_conntrack_l4proto
                            const struct nf_conntrack_tuple *);
 
         /* Print out the private part of the conntrack. */
-        int (*print_conntrack)(struct seq_file *s, const struct nf_conn *);
+        int (*print_conntrack)(struct seq_file *s, struct nf_conn *);
 
         /* convert protoinfo to nfnetink attributes */
         int (*to_nlattr)(struct sk_buff *skb, struct nlattr *nla,
-                         const struct nf_conn *ct);
+                         struct nf_conn *ct);
         /* Calculate protoinfo nlattr size */
         int (*nlattr_size)(void);
 
diff --git a/include/net/netlink.h b/include/net/netlink.h
index eddb50289d6d..007bdb07dabb 100644
--- a/include/net/netlink.h
+++ b/include/net/netlink.h
@@ -940,6 +940,15 @@ static inline u64 nla_get_u64(const struct nlattr *nla)
 }
 
 /**
+ * nla_get_be64 - return payload of __be64 attribute
+ * @nla: __be64 netlink attribute
+ */
+static inline __be64 nla_get_be64(const struct nlattr *nla)
+{
+        return *(__be64 *) nla_data(nla);
+}
+
+/**
  * nla_get_flag - return payload of flag attribute
  * @nla: flag netlink attribute
  */
diff --git a/include/net/netns/conntrack.h b/include/net/netns/conntrack.h
index 9dc58402bc09..ba1ba0c5efd1 100644
--- a/include/net/netns/conntrack.h
+++ b/include/net/netns/conntrack.h
@@ -14,16 +14,17 @@ struct netns_ct {
         struct hlist_nulls_head *hash;
         struct hlist_head       *expect_hash;
         struct hlist_nulls_head unconfirmed;
+        struct hlist_nulls_head dying;
         struct ip_conntrack_stat *stat;
-#ifdef CONFIG_NF_CONNTRACK_EVENTS
-        struct nf_conntrack_ecache *ecache;
-#endif
+        int                     sysctl_events;
+        unsigned int            sysctl_events_retry_timeout;
         int                     sysctl_acct;
         int                     sysctl_checksum;
         unsigned int            sysctl_log_invalid; /* Log invalid packets */
 #ifdef CONFIG_SYSCTL
         struct ctl_table_header *sysctl_header;
         struct ctl_table_header *acct_sysctl_header;
+        struct ctl_table_header *event_sysctl_header;
 #endif
         int                     hash_vmalloc;
         int                     expect_vmalloc;
diff --git a/include/net/phonet/pn_dev.h b/include/net/phonet/pn_dev.h
index 5054dc5ea2c2..29d126736611 100644
--- a/include/net/phonet/pn_dev.h
+++ b/include/net/phonet/pn_dev.h
@@ -45,6 +45,7 @@ int phonet_address_add(struct net_device *dev, u8 addr);
 int phonet_address_del(struct net_device *dev, u8 addr);
 u8 phonet_address_get(struct net_device *dev, u8 addr);
 int phonet_address_lookup(struct net *net, u8 addr);
+void phonet_address_notify(int event, struct net_device *dev, u8 addr);
 
 #define PN_NO_ADDR      0xff
 
diff --git a/include/net/pkt_sched.h b/include/net/pkt_sched.h
index e37fe3129c17..82a3191375f5 100644
--- a/include/net/pkt_sched.h
+++ b/include/net/pkt_sched.h
@@ -41,16 +41,17 @@ static inline void *qdisc_priv(struct Qdisc *q)
 typedef u64     psched_time_t;
 typedef long    psched_tdiff_t;
 
-/* Avoid doing 64 bit divide by 1000 */
-#define PSCHED_US2NS(x)                 ((s64)(x) << 10)
-#define PSCHED_NS2US(x)                 ((x) >> 10)
+/* Avoid doing 64 bit divide */
+#define PSCHED_SHIFT                    6
+#define PSCHED_TICKS2NS(x)              ((s64)(x) << PSCHED_SHIFT)
+#define PSCHED_NS2TICKS(x)              ((x) >> PSCHED_SHIFT)
 
-#define PSCHED_TICKS_PER_SEC            PSCHED_NS2US(NSEC_PER_SEC)
+#define PSCHED_TICKS_PER_SEC            PSCHED_NS2TICKS(NSEC_PER_SEC)
 #define PSCHED_PASTPERFECT              0
 
 static inline psched_time_t psched_get_time(void)
 {
-        return PSCHED_NS2US(ktime_to_ns(ktime_get()));
+        return PSCHED_NS2TICKS(ktime_to_ns(ktime_get()));
 }
 
 static inline psched_tdiff_t
diff --git a/include/net/protocol.h b/include/net/protocol.h
index ffa5b8b1f1df..1089d5aabd49 100644
--- a/include/net/protocol.h
+++ b/include/net/protocol.h
@@ -53,7 +53,7 @@ struct inet6_protocol
 
         void    (*err_handler)(struct sk_buff *skb,
                                struct inet6_skb_parm *opt,
-                               int type, int code, int offset,
+                               u8 type, u8 code, int offset,
                                __be32 info);
 
         int     (*gso_send_check)(struct sk_buff *skb);
diff --git a/include/net/rawv6.h b/include/net/rawv6.h
index 8a22599f26ba..f6b9b830df8c 100644
--- a/include/net/rawv6.h
+++ b/include/net/rawv6.h
@@ -6,7 +6,7 @@
 #include <net/protocol.h>
 
 void raw6_icmp_error(struct sk_buff *, int nexthdr,
-                int type, int code, int inner_offset, __be32);
+                u8 type, u8 code, int inner_offset, __be32);
 int raw6_local_deliver(struct sk_buff *, int);
 
 extern int                      rawv6_rcv(struct sock *sk,
diff --git a/include/net/regulatory.h b/include/net/regulatory.h
new file mode 100644
index 000000000000..47995b81c5d7
--- /dev/null
+++ b/include/net/regulatory.h
@@ -0,0 +1,101 @@
+#ifndef __NET_REGULATORY_H
+#define __NET_REGULATORY_H
+/*
+ * regulatory support structures
+ *
+ * Copyright 2008-2009  Luis R. Rodriguez <lrodriguez@atheros.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+
+/**
+ * enum environment_cap - Environment parsed from country IE
+ * @ENVIRON_ANY: indicates country IE applies to both indoor and
+ *      outdoor operation.
+ * @ENVIRON_INDOOR: indicates country IE applies only to indoor operation
+ * @ENVIRON_OUTDOOR: indicates country IE applies only to outdoor operation
+ */
+enum environment_cap {
+        ENVIRON_ANY,
+        ENVIRON_INDOOR,
+        ENVIRON_OUTDOOR,
+};
+
+/**
+ * struct regulatory_request - used to keep track of regulatory requests
+ *
+ * @wiphy_idx: this is set if this request's initiator is
+ *      %REGDOM_SET_BY_COUNTRY_IE or %REGDOM_SET_BY_DRIVER. This
+ *      can be used by the wireless core to deal with conflicts
+ *      and potentially inform users of which devices specifically
+ *      cased the conflicts.
+ * @initiator: indicates who sent this request, could be any of
+ *      of those set in nl80211_reg_initiator (%NL80211_REGDOM_SET_BY_*)
+ * @alpha2: the ISO / IEC 3166 alpha2 country code of the requested
+ *      regulatory domain. We have a few special codes:
+ *      00 - World regulatory domain
+ *      99 - built by driver but a specific alpha2 cannot be determined
+ *      98 - result of an intersection between two regulatory domains
+ * @intersect: indicates whether the wireless core should intersect
+ *      the requested regulatory domain with the presently set regulatory
+ *      domain.
+ * @country_ie_checksum: checksum of the last processed and accepted
+ *      country IE
+ * @country_ie_env: lets us know if the AP is telling us we are outdoor,
+ *      indoor, or if it doesn't matter
+ * @list: used to insert into the reg_requests_list linked list
+ */
+struct regulatory_request {
+        int wiphy_idx;
+        enum nl80211_reg_initiator initiator;
+        char alpha2[2];
+        bool intersect;
+        u32 country_ie_checksum;
+        enum environment_cap country_ie_env;
+        struct list_head list;
+};
+
+struct ieee80211_freq_range {
+        u32 start_freq_khz;
+        u32 end_freq_khz;
+        u32 max_bandwidth_khz;
+};
+
+struct ieee80211_power_rule {
+        u32 max_antenna_gain;
+        u32 max_eirp;
+};
+
+struct ieee80211_reg_rule {
+        struct ieee80211_freq_range freq_range;
+        struct ieee80211_power_rule power_rule;
+        u32 flags;
+};
+
+struct ieee80211_regdomain {
+        u32 n_reg_rules;
+        char alpha2[2];
+        struct ieee80211_reg_rule reg_rules[];
+};
+
+#define MHZ_TO_KHZ(freq) ((freq) * 1000)
+#define KHZ_TO_MHZ(freq) ((freq) / 1000)
+#define DBI_TO_MBI(gain) ((gain) * 100)
+#define MBI_TO_DBI(gain) ((gain) / 100)
+#define DBM_TO_MBM(gain) ((gain) * 100)
+#define MBM_TO_DBM(gain) ((gain) / 100)
+
+#define REG_RULE(start, end, bw, gain, eirp, reg_flags) \
+{                                                       \
+        .freq_range.start_freq_khz = MHZ_TO_KHZ(start), \
+        .freq_range.end_freq_khz = MHZ_TO_KHZ(end),     \
+        .freq_range.max_bandwidth_khz = MHZ_TO_KHZ(bw), \
+        .power_rule.max_antenna_gain = DBI_TO_MBI(gain),\
+        .power_rule.max_eirp = DBM_TO_MBM(eirp),        \
+        .flags = reg_flags,                             \
+}
+
+#endif
diff --git a/include/net/rose.h b/include/net/rose.h
index cbd5364b2c8a..5ba9f02731eb 100644
--- a/include/net/rose.h
+++ b/include/net/rose.h
@@ -156,7 +156,7 @@ extern int  sysctl_rose_maximum_vcs;
 extern int  sysctl_rose_window_size;
 extern int  rosecmp(rose_address *, rose_address *);
 extern int  rosecmpm(rose_address *, rose_address *, unsigned short);
-extern const char *rose2asc(const rose_address *);
+extern char *rose2asc(char *buf, const rose_address *);
 extern struct sock *rose_find_socket(unsigned int, struct rose_neigh *);
 extern void rose_kill_by_neigh(struct rose_neigh *);
 extern unsigned int rose_new_lci(struct rose_neigh *);
diff --git a/include/net/route.h b/include/net/route.h
index 4e8cae0e5841..40f6346ef496 100644
--- a/include/net/route.h
+++ b/include/net/route.h
@@ -210,7 +210,7 @@ static inline struct inet_peer *rt_get_peer(struct rtable *rt)
 
 static inline int inet_iif(const struct sk_buff *skb)
 {
-        return skb->rtable->rt_iif;
+        return skb_rtable(skb)->rt_iif;
 }
 
 #endif  /* _ROUTE_H */
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index 9f80a7668289..d16a304cbed4 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -448,6 +448,7 @@ static inline void sctp_skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
 {
         struct sctp_ulpevent *event = sctp_skb2event(skb);
 
+        skb_orphan(skb);
         skb->sk = sk;
         skb->destructor = sctp_sock_rfree;
         atomic_add(event->rmem_len, &sk->sk_rmem_alloc);
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index 23f08fe1d50a..edfcacf3250e 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -1939,10 +1939,8 @@ void sctp_association_free(struct sctp_association *);
 void sctp_association_put(struct sctp_association *);
 void sctp_association_hold(struct sctp_association *);
 
-struct sctp_transport *sctp_assoc_choose_init_transport(
-        struct sctp_association *);
-struct sctp_transport *sctp_assoc_choose_shutdown_transport(
-        struct sctp_association *);
+struct sctp_transport *sctp_assoc_choose_alter_transport(
+        struct sctp_association *, struct sctp_transport *);
 void sctp_assoc_update_retran_path(struct sctp_association *);
 struct sctp_transport *sctp_assoc_lookup_paddr(const struct sctp_association *,
                                           const union sctp_addr *);
diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
index b259fc5798fb..1580c04f68bc 100644
--- a/include/net/sctp/user.h
+++ b/include/net/sctp/user.h
@@ -147,6 +147,8 @@ enum sctp_optname {
 #define SCTP_GET_LOCAL_ADDRS    SCTP_GET_LOCAL_ADDRS
         SCTP_SOCKOPT_CONNECTX, /* CONNECTX requests. */
 #define SCTP_SOCKOPT_CONNECTX   SCTP_SOCKOPT_CONNECTX
+        SCTP_SOCKOPT_CONNECTX3, /* CONNECTX requests. (new implementation) */
+#define SCTP_SOCKOPT_CONNECTX3  SCTP_SOCKOPT_CONNECTX3
 };
 
 /*
diff --git a/include/net/snmp.h b/include/net/snmp.h
index 57c93628695f..8c842e06bec8 100644
--- a/include/net/snmp.h
+++ b/include/net/snmp.h
@@ -153,6 +153,11 @@ struct linux_xfrm_mib {
                 per_cpu_ptr(mib[!in_softirq()], get_cpu())->mibs[field]--; \
                 put_cpu(); \
         } while (0)
+#define SNMP_ADD_STATS(mib, field, addend)      \
+        do { \
+                per_cpu_ptr(mib[!in_softirq()], get_cpu())->mibs[field] += addend; \
+                put_cpu(); \
+        } while (0)
 #define SNMP_ADD_STATS_BH(mib, field, addend)   \
         (per_cpu_ptr(mib[0], raw_smp_processor_id())->mibs[field] += addend)
 #define SNMP_ADD_STATS_USER(mib, field, addend)         \
@@ -160,5 +165,17 @@ struct linux_xfrm_mib {
                 per_cpu_ptr(mib[1], get_cpu())->mibs[field] += addend; \
                 put_cpu(); \
         } while (0)
-
+#define SNMP_UPD_PO_STATS(mib, basefield, addend)       \
+        do { \
+                __typeof__(mib[0]) ptr = per_cpu_ptr(mib[!in_softirq()], get_cpu());\
+                ptr->mibs[basefield##PKTS]++; \
+                ptr->mibs[basefield##OCTETS] += addend;\
+                put_cpu(); \
+        } while (0)
+#define SNMP_UPD_PO_STATS_BH(mib, basefield, addend)    \
+        do { \
+                __typeof__(mib[0]) ptr = per_cpu_ptr(mib[!in_softirq()], raw_smp_processor_id());\
+                ptr->mibs[basefield##PKTS]++; \
+                ptr->mibs[basefield##OCTETS] += addend;\
+        } while (0)
 #endif
diff --git a/include/net/sock.h b/include/net/sock.h
index 4bb1ff9fd15b..950409dcec3d 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -54,6 +54,7 @@
 
 #include <linux/filter.h>
 #include <linux/rculist_nulls.h>
+#include <linux/poll.h>
 
 #include <asm/atomic.h>
 #include <net/dst.h>
@@ -103,15 +104,15 @@ struct net;
 
 /**
  *      struct sock_common - minimal network layer representation of sockets
+ *      @skc_node: main hash linkage for various protocol lookup tables
+ *      @skc_nulls_node: main hash linkage for UDP/UDP-Lite protocol
+ *      @skc_refcnt: reference count
+ *      @skc_hash: hash value used with various protocol lookup tables
  *      @skc_family: network address family
  *      @skc_state: Connection state
  *      @skc_reuse: %SO_REUSEADDR setting
  *      @skc_bound_dev_if: bound device index if != 0
- *      @skc_node: main hash linkage for various protocol lookup tables
- *      @skc_nulls_node: main hash linkage for UDP/UDP-Lite protocol
  *      @skc_bind_node: bind hash linkage for various protocol lookup tables
- *      @skc_refcnt: reference count
- *      @skc_hash: hash value used with various protocol lookup tables
  *      @skc_prot: protocol handlers inside a network family
  *      @skc_net: reference to the network namespace of this socket
  *
@@ -119,17 +120,21 @@ struct net;
  *      for struct sock and struct inet_timewait_sock.
  */
 struct sock_common {
-        unsigned short          skc_family;
-        volatile unsigned char  skc_state;
-        unsigned char           skc_reuse;
-        int                     skc_bound_dev_if;
+        /*
+         * first fields are not copied in sock_copy()
+         */
         union {
                 struct hlist_node       skc_node;
                 struct hlist_nulls_node skc_nulls_node;
         };
-        struct hlist_node       skc_bind_node;
         atomic_t                skc_refcnt;
+
         unsigned int            skc_hash;
+        unsigned short          skc_family;
+        volatile unsigned char  skc_state;
+        unsigned char           skc_reuse;
+        int                     skc_bound_dev_if;
+        struct hlist_node       skc_bind_node;
         struct proto            *skc_prot;
 #ifdef CONFIG_NET_NS
         struct net              *skc_net;
@@ -207,20 +212,24 @@ struct sock {
          * don't add nothing before this first member (__sk_common) --acme
          */
         struct sock_common      __sk_common;
+#define sk_node                 __sk_common.skc_node
+#define sk_nulls_node           __sk_common.skc_nulls_node
+#define sk_refcnt               __sk_common.skc_refcnt
+
+#define sk_copy_start           __sk_common.skc_hash
+#define sk_hash                 __sk_common.skc_hash
 #define sk_family               __sk_common.skc_family
 #define sk_state                __sk_common.skc_state
 #define sk_reuse                __sk_common.skc_reuse
 #define sk_bound_dev_if         __sk_common.skc_bound_dev_if
-#define sk_node                 __sk_common.skc_node
-#define sk_nulls_node           __sk_common.skc_nulls_node
 #define sk_bind_node            __sk_common.skc_bind_node
-#define sk_refcnt               __sk_common.skc_refcnt
-#define sk_hash                 __sk_common.skc_hash
 #define sk_prot                 __sk_common.skc_prot
 #define sk_net                  __sk_common.skc_net
+        kmemcheck_bitfield_begin(flags);
         unsigned char           sk_shutdown : 2,
                                 sk_no_check : 2,
                                 sk_userlocks : 4;
+        kmemcheck_bitfield_end(flags);
         unsigned char           sk_protocol;
         unsigned short          sk_type;
         int                     sk_rcvbuf;
@@ -1206,6 +1215,107 @@ static inline int skb_copy_to_page(struct sock *sk, char __user *from,
         return 0;
 }
 
+/**
+ * sk_wmem_alloc_get - returns write allocations
+ * @sk: socket
+ *
+ * Returns sk_wmem_alloc minus initial offset of one
+ */
+static inline int sk_wmem_alloc_get(const struct sock *sk)
+{
+        return atomic_read(&sk->sk_wmem_alloc) - 1;
+}
+
+/**
+ * sk_rmem_alloc_get - returns read allocations
+ * @sk: socket
+ *
+ * Returns sk_rmem_alloc
+ */
+static inline int sk_rmem_alloc_get(const struct sock *sk)
+{
+        return atomic_read(&sk->sk_rmem_alloc);
+}
+
+/**
+ * sk_has_allocations - check if allocations are outstanding
+ * @sk: socket
+ *
+ * Returns true if socket has write or read allocations
+ */
+static inline int sk_has_allocations(const struct sock *sk)
+{
+        return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
+}
+
+/**
+ * sk_has_sleeper - check if there are any waiting processes
+ * @sk: socket
+ *
+ * Returns true if socket has waiting processes
+ *
+ * The purpose of the sk_has_sleeper and sock_poll_wait is to wrap the memory
+ * barrier call. They were added due to the race found within the tcp code.
+ *
+ * Consider following tcp code paths:
+ *
+ * CPU1                  CPU2
+ *
+ * sys_select            receive packet
+ *   ...                 ...
+ *   __add_wait_queue    update tp->rcv_nxt
+ *   ...                 ...
+ *   tp->rcv_nxt check   sock_def_readable
+ *   ...                 {
+ *   schedule               ...
+ *                          if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
+ *                              wake_up_interruptible(sk->sk_sleep)
+ *                          ...
+ *                       }
+ *
+ * The race for tcp fires when the __add_wait_queue changes done by CPU1 stay
+ * in its cache, and so does the tp->rcv_nxt update on CPU2 side.  The CPU1
+ * could then endup calling schedule and sleep forever if there are no more
+ * data on the socket.
+ *
+ * The sk_has_sleeper is always called right after a call to read_lock, so we
+ * can use smp_mb__after_lock barrier.
+ */
+static inline int sk_has_sleeper(struct sock *sk)
+{
+        /*
+         * We need to be sure we are in sync with the
+         * add_wait_queue modifications to the wait queue.
+         *
+         * This memory barrier is paired in the sock_poll_wait.
+         */
+        smp_mb__after_lock();
+        return sk->sk_sleep && waitqueue_active(sk->sk_sleep);
+}
+
+/**
+ * sock_poll_wait - place memory barrier behind the poll_wait call.
+ * @filp:           file
+ * @wait_address:   socket wait queue
+ * @p:              poll_table
+ *
+ * See the comments in the sk_has_sleeper function.
+ */
+static inline void sock_poll_wait(struct file *filp,
+                wait_queue_head_t *wait_address, poll_table *p)
+{
+        if (p && wait_address) {
+                poll_wait(filp, wait_address, p);
+                /*
+                 * We need to be sure we are in sync with the
+                 * socket flags modification.
+                 *
+                 * This memory barrier is paired in the sk_has_sleeper.
+                */
+                smp_mb();
+        }
+}
+
 /*
  *      Queue a received datagram if it will fit. Stream and sequenced
  *      protocols can't normally use this as they need to fit buffers in
@@ -1217,14 +1327,20 @@ static inline int skb_copy_to_page(struct sock *sk, char __user *from,
 
 static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
 {
-        sock_hold(sk);
+        skb_orphan(skb);
         skb->sk = sk;
         skb->destructor = sock_wfree;
+        /*
+         * We used to take a refcount on sk, but following operation
+         * is enough to guarantee sk_free() wont free this sock until
+         * all in-flight packets are completed
+         */
         atomic_add(skb->truesize, &sk->sk_wmem_alloc);
 }
 
 static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
 {
+        skb_orphan(skb);
         skb->sk = sk;
         skb->destructor = sock_rfree;
         atomic_add(skb->truesize, &sk->sk_rmem_alloc);
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 646dbe3962ea..88af84306471 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -266,6 +266,19 @@ static inline int tcp_too_many_orphans(struct sock *sk, int num)
                  atomic_read(&tcp_memory_allocated) > sysctl_tcp_mem[2]);
 }
 
+/* syncookies: remember time of last synqueue overflow */
+static inline void tcp_synq_overflow(struct sock *sk)
+{
+        tcp_sk(sk)->rx_opt.ts_recent_stamp = jiffies;
+}
+
+/* syncookies: no recent synqueue overflow on this listening socket? */
+static inline int tcp_synq_no_recent_overflow(const struct sock *sk)
+{
+        unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp;
+        return time_after(jiffies, last_overflow + TCP_TIMEOUT_INIT);
+}
+
 extern struct proto tcp_prot;
 
 #define TCP_INC_STATS(net, field)       SNMP_INC_STATS((net)->mib.tcp_statistics, field)
@@ -889,30 +902,32 @@ static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
 {
         struct tcp_sock *tp = tcp_sk(sk);
 
-        if (!sysctl_tcp_low_latency && tp->ucopy.task) {
-                __skb_queue_tail(&tp->ucopy.prequeue, skb);
-                tp->ucopy.memory += skb->truesize;
-                if (tp->ucopy.memory > sk->sk_rcvbuf) {
-                        struct sk_buff *skb1;
-
-                        BUG_ON(sock_owned_by_user(sk));
-
-                        while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
-                                sk_backlog_rcv(sk, skb1);
-                                NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPPREQUEUEDROPPED);
-                        }
-
-                        tp->ucopy.memory = 0;
-                } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
-                        wake_up_interruptible(sk->sk_sleep);
-                        if (!inet_csk_ack_scheduled(sk))
-                                inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
-                                                          (3 * tcp_rto_min(sk)) / 4,
-                                                          TCP_RTO_MAX);
+        if (sysctl_tcp_low_latency || !tp->ucopy.task)
+                return 0;
+
+        __skb_queue_tail(&tp->ucopy.prequeue, skb);
+        tp->ucopy.memory += skb->truesize;
+        if (tp->ucopy.memory > sk->sk_rcvbuf) {
+                struct sk_buff *skb1;
+
+                BUG_ON(sock_owned_by_user(sk));
+
+                while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {
+                        sk_backlog_rcv(sk, skb1);
+                        NET_INC_STATS_BH(sock_net(sk),
+                                         LINUX_MIB_TCPPREQUEUEDROPPED);
                 }
-                return 1;
+
+                tp->ucopy.memory = 0;
+        } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
+                wake_up_interruptible_poll(sk->sk_sleep,
+                                           POLLIN | POLLRDNORM | POLLRDBAND);
+                if (!inet_csk_ack_scheduled(sk))
+                        inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
+                                                  (3 * tcp_rto_min(sk)) / 4,
+                                                  TCP_RTO_MAX);
         }
-        return 0;
+        return 1;
 }
 
 
@@ -1410,6 +1425,11 @@ struct tcp_request_sock_ops {
 #ifdef CONFIG_TCP_MD5SIG
         struct tcp_md5sig_key   *(*md5_lookup) (struct sock *sk,
                                                 struct request_sock *req);
+        int                     (*calc_md5_hash) (char *location,
+                                                  struct tcp_md5sig_key *md5,
+                                                  struct sock *sk,
+                                                  struct request_sock *req,
+                                                  struct sk_buff *skb);
 #endif
 };
 
diff --git a/include/net/wimax.h b/include/net/wimax.h
index 6b3824edb39e..2af7bf839f23 100644
--- a/include/net/wimax.h
+++ b/include/net/wimax.h
@@ -253,7 +253,6 @@
 struct net_device;
 struct genl_info;
 struct wimax_dev;
-struct input_dev;
 
 /**
  * struct wimax_dev - Generic WiMAX device
@@ -293,8 +292,8 @@ struct input_dev;
  *     See wimax_reset()'s documentation.
  *
  * @name: [fill] A way to identify this device. We need to register a
- *     name with many subsystems (input for RFKILL, workqueue
- *     creation, etc). We can't use the network device name as that
+ *     name with many subsystems (rfkill, workqueue creation, etc).
+ *     We can't use the network device name as that
  *     might change and in some instances we don't know it yet (until
  *     we don't call register_netdev()). So we generate an unique one
  *     using the driver name and device bus id, place it here and use
@@ -316,9 +315,6 @@ struct input_dev;
  *
  * @rfkill: [private] integration into the RF-Kill infrastructure.
  *
- * @rfkill_input: [private] virtual input device to process the
- *     hardware RF Kill switches.
- *
  * @rf_sw: [private] State of the software radio switch (OFF/ON)
  *
  * @rf_hw: [private] State of the hardware radio switch (OFF/ON)
diff --git a/include/net/wireless.h b/include/net/wireless.h
deleted file mode 100644
index 64a76208580c..000000000000
--- a/include/net/wireless.h
+++ /dev/null
@@ -1,472 +0,0 @@
-#ifndef __NET_WIRELESS_H
-#define __NET_WIRELESS_H
-
-/*
- * 802.11 device management
- *
- * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
- */
-
-#include <linux/netdevice.h>
-#include <linux/debugfs.h>
-#include <linux/list.h>
-#include <linux/ieee80211.h>
-#include <net/cfg80211.h>
-
-/**
- * enum ieee80211_band - supported frequency bands
- *
- * The bands are assigned this way because the supported
- * bitrates differ in these bands.
- *
- * @IEEE80211_BAND_2GHZ: 2.4GHz ISM band
- * @IEEE80211_BAND_5GHZ: around 5GHz band (4.9-5.7)
- */
-enum ieee80211_band {
-        IEEE80211_BAND_2GHZ,
-        IEEE80211_BAND_5GHZ,
-
-        /* keep last */
-        IEEE80211_NUM_BANDS
-};
-
-/**
- * enum ieee80211_channel_flags - channel flags
- *
- * Channel flags set by the regulatory control code.
- *
- * @IEEE80211_CHAN_DISABLED: This channel is disabled.
- * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted
- *      on this channel.
- * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel.
- * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel.
- * @IEEE80211_CHAN_NO_FAT_ABOVE: extension channel above this channel
- *      is not permitted.
- * @IEEE80211_CHAN_NO_FAT_BELOW: extension channel below this channel
- *      is not permitted.
- */
-enum ieee80211_channel_flags {
-        IEEE80211_CHAN_DISABLED         = 1<<0,
-        IEEE80211_CHAN_PASSIVE_SCAN     = 1<<1,
-        IEEE80211_CHAN_NO_IBSS          = 1<<2,
-        IEEE80211_CHAN_RADAR            = 1<<3,
-        IEEE80211_CHAN_NO_FAT_ABOVE     = 1<<4,
-        IEEE80211_CHAN_NO_FAT_BELOW     = 1<<5,
-};
-
-/**
- * struct ieee80211_channel - channel definition
- *
- * This structure describes a single channel for use
- * with cfg80211.
- *
- * @center_freq: center frequency in MHz
- * @max_bandwidth: maximum allowed bandwidth for this channel, in MHz
- * @hw_value: hardware-specific value for the channel
- * @flags: channel flags from &enum ieee80211_channel_flags.
- * @orig_flags: channel flags at registration time, used by regulatory
- *      code to support devices with additional restrictions
- * @band: band this channel belongs to.
- * @max_antenna_gain: maximum antenna gain in dBi
- * @max_power: maximum transmission power (in dBm)
- * @beacon_found: helper to regulatory code to indicate when a beacon
- *      has been found on this channel. Use regulatory_hint_found_beacon()
- *      to enable this, this is is useful only on 5 GHz band.
- * @orig_mag: internal use
- * @orig_mpwr: internal use
- */
-struct ieee80211_channel {
-        enum ieee80211_band band;
-        u16 center_freq;
-        u8 max_bandwidth;
-        u16 hw_value;
-        u32 flags;
-        int max_antenna_gain;
-        int max_power;
-        bool beacon_found;
-        u32 orig_flags;
-        int orig_mag, orig_mpwr;
-};
-
-/**
- * enum ieee80211_rate_flags - rate flags
- *
- * Hardware/specification flags for rates. These are structured
- * in a way that allows using the same bitrate structure for
- * different bands/PHY modes.
- *
- * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short
- *      preamble on this bitrate; only relevant in 2.4GHz band and
- *      with CCK rates.
- * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate
- *      when used with 802.11a (on the 5 GHz band); filled by the
- *      core code when registering the wiphy.
- * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate
- *      when used with 802.11b (on the 2.4 GHz band); filled by the
- *      core code when registering the wiphy.
- * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate
- *      when used with 802.11g (on the 2.4 GHz band); filled by the
- *      core code when registering the wiphy.
- * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode.
- */
-enum ieee80211_rate_flags {
-        IEEE80211_RATE_SHORT_PREAMBLE   = 1<<0,
-        IEEE80211_RATE_MANDATORY_A      = 1<<1,
-        IEEE80211_RATE_MANDATORY_B      = 1<<2,
-        IEEE80211_RATE_MANDATORY_G      = 1<<3,
-        IEEE80211_RATE_ERP_G            = 1<<4,
-};
-
-/**
- * struct ieee80211_rate - bitrate definition
- *
- * This structure describes a bitrate that an 802.11 PHY can
- * operate with. The two values @hw_value and @hw_value_short
- * are only for driver use when pointers to this structure are
- * passed around.
- *
- * @flags: rate-specific flags
- * @bitrate: bitrate in units of 100 Kbps
- * @hw_value: driver/hardware value for this rate
- * @hw_value_short: driver/hardware value for this rate when
- *      short preamble is used
- */
-struct ieee80211_rate {
-        u32 flags;
-        u16 bitrate;
-        u16 hw_value, hw_value_short;
-};
-
-/**
- * struct ieee80211_sta_ht_cap - STA's HT capabilities
- *
- * This structure describes most essential parameters needed
- * to describe 802.11n HT capabilities for an STA.
- *
- * @ht_supported: is HT supported by the STA
- * @cap: HT capabilities map as described in 802.11n spec
- * @ampdu_factor: Maximum A-MPDU length factor
- * @ampdu_density: Minimum A-MPDU spacing
- * @mcs: Supported MCS rates
- */
-struct ieee80211_sta_ht_cap {
-        u16 cap; /* use IEEE80211_HT_CAP_ */
-        bool ht_supported;
-        u8 ampdu_factor;
-        u8 ampdu_density;
-        struct ieee80211_mcs_info mcs;
-};
-
-/**
- * struct ieee80211_supported_band - frequency band definition
- *
- * This structure describes a frequency band a wiphy
- * is able to operate in.
- *
- * @channels: Array of channels the hardware can operate in
- *      in this band.
- * @band: the band this structure represents
- * @n_channels: Number of channels in @channels
- * @bitrates: Array of bitrates the hardware can operate with
- *      in this band. Must be sorted to give a valid "supported
- *      rates" IE, i.e. CCK rates first, then OFDM.
- * @n_bitrates: Number of bitrates in @bitrates
- */
-struct ieee80211_supported_band {
-        struct ieee80211_channel *channels;
-        struct ieee80211_rate *bitrates;
-        enum ieee80211_band band;
-        int n_channels;
-        int n_bitrates;
-        struct ieee80211_sta_ht_cap ht_cap;
-};
-
-/**
- * struct wiphy - wireless hardware description
- * @idx: the wiphy index assigned to this item
- * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name>
- * @custom_regulatory: tells us the driver for this device
- *      has its own custom regulatory domain and cannot identify the
- *      ISO / IEC 3166 alpha2 it belongs to. When this is enabled
- *      we will disregard the first regulatory hint (when the
- *      initiator is %REGDOM_SET_BY_CORE).
- * @strict_regulatory: tells us the driver for this device will ignore
- *      regulatory domain settings until it gets its own regulatory domain
- *      via its regulatory_hint(). After its gets its own regulatory domain
- *      it will only allow further regulatory domain settings to further
- *      enhance compliance. For example if channel 13 and 14 are disabled
- *      by this regulatory domain no user regulatory domain can enable these
- *      channels at a later time. This can be used for devices which do not
- *      have calibration information gauranteed for frequencies or settings
- *      outside of its regulatory domain.
- * @reg_notifier: the driver's regulatory notification callback
- * @regd: the driver's regulatory domain, if one was requested via
- *      the regulatory_hint() API. This can be used by the driver
- *      on the reg_notifier() if it chooses to ignore future
- *      regulatory domain changes caused by other drivers.
- * @signal_type: signal type reported in &struct cfg80211_bss.
- */
-struct wiphy {
-        /* assign these fields before you register the wiphy */
-
-        /* permanent MAC address */
-        u8 perm_addr[ETH_ALEN];
-
-        /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */
-        u16 interface_modes;
-
-        bool custom_regulatory;
-        bool strict_regulatory;
-
-        enum cfg80211_signal_type signal_type;
-
-        int bss_priv_size;
-        u8 max_scan_ssids;
-
-        /* If multiple wiphys are registered and you're handed e.g.
-         * a regular netdev with assigned ieee80211_ptr, you won't
-         * know whether it points to a wiphy your driver has registered
-         * or not. Assign this to something global to your driver to
-         * help determine whether you own this wiphy or not. */
-        void *privid;
-
-        struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS];
-
-        /* Lets us get back the wiphy on the callback */
-        int (*reg_notifier)(struct wiphy *wiphy,
-                            struct regulatory_request *request);
-
-        /* fields below are read-only, assigned by cfg80211 */
-
-        const struct ieee80211_regdomain *regd;
-
-        /* the item in /sys/class/ieee80211/ points to this,
-         * you need use set_wiphy_dev() (see below) */
-        struct device dev;
-
-        /* dir in debugfs: ieee80211/<wiphyname> */
-        struct dentry *debugfsdir;
-
-        char priv[0] __attribute__((__aligned__(NETDEV_ALIGN)));
-};
-
-/** struct wireless_dev - wireless per-netdev state
- *
- * This structure must be allocated by the driver/stack
- * that uses the ieee80211_ptr field in struct net_device
- * (this is intentional so it can be allocated along with
- * the netdev.)
- *
- * @wiphy: pointer to hardware description
- * @iftype: interface type
- */
-struct wireless_dev {
-        struct wiphy *wiphy;
-        enum nl80211_iftype iftype;
-
-        /* private to the generic wireless code */
-        struct list_head list;
-        struct net_device *netdev;
-};
-
-/**
- * wiphy_priv - return priv from wiphy
- */
-static inline void *wiphy_priv(struct wiphy *wiphy)
-{
-        BUG_ON(!wiphy);
-        return &wiphy->priv;
-}
-
-/**
- * set_wiphy_dev - set device pointer for wiphy
- */
-static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev)
-{
-        wiphy->dev.parent = dev;
-}
-
-/**
- * wiphy_dev - get wiphy dev pointer
- */
-static inline struct device *wiphy_dev(struct wiphy *wiphy)
-{
-        return wiphy->dev.parent;
-}
-
-/**
- * wiphy_name - get wiphy name
- */
-static inline const char *wiphy_name(struct wiphy *wiphy)
-{
-        return dev_name(&wiphy->dev);
-}
-
-/**
- * wdev_priv - return wiphy priv from wireless_dev
- */
-static inline void *wdev_priv(struct wireless_dev *wdev)
-{
-        BUG_ON(!wdev);
-        return wiphy_priv(wdev->wiphy);
-}
-
-/**
- * wiphy_new - create a new wiphy for use with cfg80211
- *
- * create a new wiphy and associate the given operations with it.
- * @sizeof_priv bytes are allocated for private use.
- *
- * the returned pointer must be assigned to each netdev's
- * ieee80211_ptr for proper operation.
- */
-struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv);
-
-/**
- * wiphy_register - register a wiphy with cfg80211
- *
- * register the given wiphy
- *
- * Returns a non-negative wiphy index or a negative error code.
- */
-extern int wiphy_register(struct wiphy *wiphy);
-
-/**
- * wiphy_unregister - deregister a wiphy from cfg80211
- *
- * unregister a device with the given priv pointer.
- * After this call, no more requests can be made with this priv
- * pointer, but the call may sleep to wait for an outstanding
- * request that is being handled.
- */
-extern void wiphy_unregister(struct wiphy *wiphy);
-
-/**
- * wiphy_free - free wiphy
- */
-extern void wiphy_free(struct wiphy *wiphy);
-
-/**
- * ieee80211_channel_to_frequency - convert channel number to frequency
- */
-extern int ieee80211_channel_to_frequency(int chan);
-
-/**
- * ieee80211_frequency_to_channel - convert frequency to channel number
- */
-extern int ieee80211_frequency_to_channel(int freq);
-
-/*
- * Name indirection necessary because the ieee80211 code also has
- * a function named "ieee80211_get_channel", so if you include
- * cfg80211's header file you get cfg80211's version, if you try
- * to include both header files you'll (rightfully!) get a symbol
- * clash.
- */
-extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy,
-                                                         int freq);
-/**
- * ieee80211_get_channel - get channel struct from wiphy for specified frequency
- */
-static inline struct ieee80211_channel *
-ieee80211_get_channel(struct wiphy *wiphy, int freq)
-{
-        return __ieee80211_get_channel(wiphy, freq);
-}
-
-/**
- * ieee80211_get_response_rate - get basic rate for a given rate
- *
- * @sband: the band to look for rates in
- * @basic_rates: bitmap of basic rates
- * @bitrate: the bitrate for which to find the basic rate
- *
- * This function returns the basic rate corresponding to a given
- * bitrate, that is the next lower bitrate contained in the basic
- * rate map, which is, for this function, given as a bitmap of
- * indices of rates in the band's bitrate table.
- */
-struct ieee80211_rate *
-ieee80211_get_response_rate(struct ieee80211_supported_band *sband,
-                            u32 basic_rates, int bitrate);
-
-/**
- * regulatory_hint - driver hint to the wireless core a regulatory domain
- * @wiphy: the wireless device giving the hint (used only for reporting
- *      conflicts)
- * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain
- *      should be in. If @rd is set this should be NULL. Note that if you
- *      set this to NULL you should still set rd->alpha2 to some accepted
- *      alpha2.
- *
- * Wireless drivers can use this function to hint to the wireless core
- * what it believes should be the current regulatory domain by
- * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory
- * domain should be in or by providing a completely build regulatory domain.
- * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried
- * for a regulatory domain structure for the respective country.
- *
- * The wiphy must have been registered to cfg80211 prior to this call.
- * For cfg80211 drivers this means you must first use wiphy_register(),
- * for mac80211 drivers you must first use ieee80211_register_hw().
- *
- * Drivers should check the return value, its possible you can get
- * an -ENOMEM.
- */
-extern int regulatory_hint(struct wiphy *wiphy, const char *alpha2);
-
-/**
- * regulatory_hint_11d - hints a country IE as a regulatory domain
- * @wiphy: the wireless device giving the hint (used only for reporting
- *      conflicts)
- * @country_ie: pointer to the country IE
- * @country_ie_len: length of the country IE
- *
- * We will intersect the rd with the what CRDA tells us should apply
- * for the alpha2 this country IE belongs to, this prevents APs from
- * sending us incorrect or outdated information against a country.
- */
-extern void regulatory_hint_11d(struct wiphy *wiphy,
-                                u8 *country_ie,
-                                u8 country_ie_len);
-/**
- * wiphy_apply_custom_regulatory - apply a custom driver regulatory domain
- * @wiphy: the wireless device we want to process the regulatory domain on
- * @regd: the custom regulatory domain to use for this wiphy
- *
- * Drivers can sometimes have custom regulatory domains which do not apply
- * to a specific country. Drivers can use this to apply such custom regulatory
- * domains. This routine must be called prior to wiphy registration. The
- * custom regulatory domain will be trusted completely and as such previous
- * default channel settings will be disregarded. If no rule is found for a
- * channel on the regulatory domain the channel will be disabled.
- */
-extern void wiphy_apply_custom_regulatory(
-        struct wiphy *wiphy,
-        const struct ieee80211_regdomain *regd);
-
-/**
- * freq_reg_info - get regulatory information for the given frequency
- * @wiphy: the wiphy for which we want to process this rule for
- * @center_freq: Frequency in KHz for which we want regulatory information for
- * @bandwidth: the bandwidth requirement you have in KHz, if you do not have one
- *      you can set this to 0. If this frequency is allowed we then set
- *      this value to the maximum allowed bandwidth.
- * @reg_rule: the regulatory rule which we have for this frequency
- *
- * Use this function to get the regulatory rule for a specific frequency on
- * a given wireless device. If the device has a specific regulatory domain
- * it wants to follow we respect that unless a country IE has been received
- * and processed already.
- *
- * Returns 0 if it was able to find a valid regulatory rule which does
- * apply to the given center_freq otherwise it returns non-zero. It will
- * also return -ERANGE if we determine the given center_freq does not even have
- * a regulatory rule for a frequency range in the center_freq's band. See
- * freq_in_rule_band() for our current definition of a band -- this is purely
- * subjective and right now its 802.11 specific.
- */
-extern int freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 *bandwidth,
-                         const struct ieee80211_reg_rule **reg_rule);
-
-#endif /* __NET_WIRELESS_H */
diff --git a/include/net/x25.h b/include/net/x25.h
index fc3f03d976f8..2cda04011568 100644
--- a/include/net/x25.h
+++ b/include/net/x25.h
@@ -187,7 +187,7 @@ extern int  x25_addr_ntoa(unsigned char *, struct x25_address *,
 extern int  x25_addr_aton(unsigned char *, struct x25_address *,
                           struct x25_address *);
 extern struct sock *x25_find_socket(unsigned int, struct x25_neigh *);
-extern void x25_destroy_socket(struct sock *);
+extern void x25_destroy_socket_from_timer(struct sock *);
 extern int  x25_rx_call_request(struct sk_buff *, struct x25_neigh *, unsigned int);
 extern void x25_kill_by_neigh(struct x25_neigh *);
 
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 2e9f5c0018ae..9e3a3f4c1f60 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -994,7 +994,7 @@ static inline int __xfrm_policy_check2(struct sock *sk, int dir,
                 return __xfrm_policy_check(sk, ndir, skb, family);
 
         return  (!net->xfrm.policy_count[dir] && !skb->sp) ||
-                (skb->dst->flags & DST_NOPOLICY) ||
+                (skb_dst(skb)->flags & DST_NOPOLICY) ||
                 __xfrm_policy_check(sk, ndir, skb, family);
 }
 
@@ -1048,7 +1048,7 @@ static inline int xfrm_route_forward(struct sk_buff *skb, unsigned short family)
         struct net *net = dev_net(skb->dev);
 
         return  !net->xfrm.policy_count[XFRM_POLICY_OUT] ||
-                (skb->dst->flags & DST_NOXFRM) ||
+                (skb_dst(skb)->flags & DST_NOXFRM) ||
                 __xfrm_route_forward(skb, family);
 }
 
@@ -1274,7 +1274,7 @@ struct xfrm_tunnel {
 struct xfrm6_tunnel {
         int (*handler)(struct sk_buff *skb);
         int (*err_handler)(struct sk_buff *skb, struct inet6_skb_parm *opt,
-                           int type, int code, int offset, __be32 info);
+                           u8 type, u8 code, int offset, __be32 info);
         struct xfrm6_tunnel *next;
         int priority;
 };
diff --git a/include/scsi/Kbuild b/include/scsi/Kbuild
new file mode 100644
index 000000000000..33b2750e9283
--- /dev/null
+++ b/include/scsi/Kbuild
@@ -0,0 +1,4 @@
+header-y += scsi.h
+header-y += scsi_netlink.h
+header-y += scsi_netlink_fc.h
+header-y += scsi_bsg_fc.h
diff --git a/include/scsi/fc/fc_fip.h b/include/scsi/fc/fc_fip.h
index 0627a9ae6347..3d138c1fcf8a 100644
--- a/include/scsi/fc/fc_fip.h
+++ b/include/scsi/fc/fc_fip.h
@@ -22,13 +22,6 @@
  * http://www.t11.org/ftp/t11/pub/fc/bb-5/08-543v1.pdf
  */
 
-/*
- * The FIP ethertype eventually goes in net/if_ether.h.
- */
-#ifndef ETH_P_FIP
-#define ETH_P_FIP       0x8914  /* FIP Ethertype */
-#endif
-
 #define FIP_DEF_PRI     128     /* default selection priority */
 #define FIP_DEF_FC_MAP  0x0efc00 /* default FCoE MAP (MAC OUI) value */
 #define FIP_DEF_FKA     8000    /* default FCF keep-alive/advert period (mS) */
diff --git a/include/scsi/fc_encode.h b/include/scsi/fc_encode.h
index 6300f556bce5..a0ff61c3e935 100644
--- a/include/scsi/fc_encode.h
+++ b/include/scsi/fc_encode.h
@@ -107,7 +107,6 @@ static inline int fc_ct_fill(struct fc_lport *lport, struct fc_frame *fp,
                 break;
 
         default:
-                FC_DBG("Invalid op code %x \n", op);
                 return -EINVAL;
         }
         *r_ctl = FC_RCTL_DD_UNSOL_CTL;
@@ -298,7 +297,6 @@ static inline int fc_els_fill(struct fc_lport *lport, struct fc_rport *rport,
                 break;
 
         default:
-                FC_DBG("Invalid op code %x \n", op);
                 return -EINVAL;
         }
 
diff --git a/include/scsi/iscsi_if.h b/include/scsi/iscsi_if.h
index d0ed5226f8c4..4426f00da5ff 100644
--- a/include/scsi/iscsi_if.h
+++ b/include/scsi/iscsi_if.h
@@ -22,6 +22,11 @@
 #define ISCSI_IF_H
 
 #include <scsi/iscsi_proto.h>
+#include <linux/in.h>
+#include <linux/in6.h>
+
+#define ISCSI_NL_GRP_ISCSID     1
+#define ISCSI_NL_GRP_UIP        2
 
 #define UEVENT_BASE                     10
 #define KEVENT_BASE                     100
@@ -50,7 +55,10 @@ enum iscsi_uevent_e {
         ISCSI_UEVENT_TGT_DSCVR          = UEVENT_BASE + 15,
         ISCSI_UEVENT_SET_HOST_PARAM     = UEVENT_BASE + 16,
         ISCSI_UEVENT_UNBIND_SESSION     = UEVENT_BASE + 17,
-        ISCSI_UEVENT_CREATE_BOUND_SESSION       = UEVENT_BASE + 18,
+        ISCSI_UEVENT_CREATE_BOUND_SESSION               = UEVENT_BASE + 18,
+        ISCSI_UEVENT_TRANSPORT_EP_CONNECT_THROUGH_HOST  = UEVENT_BASE + 19,
+
+        ISCSI_UEVENT_PATH_UPDATE        = UEVENT_BASE + 20,
 
         /* up events */
         ISCSI_KEVENT_RECV_PDU           = KEVENT_BASE + 1,
@@ -59,6 +67,9 @@ enum iscsi_uevent_e {
         ISCSI_KEVENT_DESTROY_SESSION    = KEVENT_BASE + 4,
         ISCSI_KEVENT_UNBIND_SESSION     = KEVENT_BASE + 5,
         ISCSI_KEVENT_CREATE_SESSION     = KEVENT_BASE + 6,
+
+        ISCSI_KEVENT_PATH_REQ           = KEVENT_BASE + 7,
+        ISCSI_KEVENT_IF_DOWN            = KEVENT_BASE + 8,
 };
 
 enum iscsi_tgt_dscvr {
@@ -131,6 +142,10 @@ struct iscsi_uevent {
                 struct msg_transport_connect {
                         uint32_t        non_blocking;
                 } ep_connect;
+                struct msg_transport_connect_through_host {
+                        uint32_t        host_no;
+                        uint32_t        non_blocking;
+                } ep_connect_through_host;
                 struct msg_transport_poll {
                         uint64_t        ep_handle;
                         uint32_t        timeout_ms;
@@ -154,6 +169,9 @@ struct iscsi_uevent {
                         uint32_t        param; /* enum iscsi_host_param */
                         uint32_t        len;
                 } set_host_param;
+                struct msg_set_path {
+                        uint32_t        host_no;
+                } set_path;
         } u;
         union {
                 /* messages k -> u */
@@ -187,10 +205,39 @@ struct iscsi_uevent {
                 struct msg_transport_connect_ret {
                         uint64_t        handle;
                 } ep_connect_ret;
+                struct msg_req_path {
+                        uint32_t        host_no;
+                } req_path;
+                struct msg_notify_if_down {
+                        uint32_t        host_no;
+                } notify_if_down;
         } r;
 } __attribute__ ((aligned (sizeof(uint64_t))));
 
 /*
+ * To keep the struct iscsi_uevent size the same for userspace code
+ * compatibility, the main structure for ISCSI_UEVENT_PATH_UPDATE and
+ * ISCSI_KEVENT_PATH_REQ is defined separately and comes after the
+ * struct iscsi_uevent in the NETLINK_ISCSI message.
+ */
+struct iscsi_path {
+        uint64_t        handle;
+        uint8_t         mac_addr[6];
+        uint8_t         mac_addr_old[6];
+        uint32_t        ip_addr_len;    /* 4 or 16 */
+        union {
+                struct in_addr  v4_addr;
+                struct in6_addr v6_addr;
+        } src;
+        union {
+                struct in_addr  v4_addr;
+                struct in6_addr v6_addr;
+        } dst;
+        uint16_t        vlan_id;
+        uint16_t        pmtu;
+} __attribute__ ((aligned (sizeof(uint64_t))));
+
+/*
  * Common error codes
  */
 enum iscsi_err {
diff --git a/include/scsi/libfc.h b/include/scsi/libfc.h
index 45f9cc642c46..b92584a8843a 100644
--- a/include/scsi/libfc.h
+++ b/include/scsi/libfc.h
@@ -34,17 +34,72 @@
 
 #include <scsi/fc_frame.h>
 
-#define LIBFC_DEBUG
-
-#ifdef LIBFC_DEBUG
-/* Log messages */
-#define FC_DBG(fmt, args...)                                            \
-        do {                                                            \
-                printk(KERN_INFO "%s " fmt, __func__, ##args);          \
-        } while (0)
-#else
-#define FC_DBG(fmt, args...)
-#endif
+#define FC_LIBFC_LOGGING 0x01 /* General logging, not categorized */
+#define FC_LPORT_LOGGING 0x02 /* lport layer logging */
+#define FC_DISC_LOGGING  0x04 /* discovery layer logging */
+#define FC_RPORT_LOGGING 0x08 /* rport layer logging */
+#define FC_FCP_LOGGING   0x10 /* I/O path logging */
+#define FC_EM_LOGGING    0x20 /* Exchange Manager logging */
+#define FC_EXCH_LOGGING  0x40 /* Exchange/Sequence logging */
+#define FC_SCSI_LOGGING  0x80 /* SCSI logging (mostly error handling) */
+
+extern unsigned int fc_debug_logging;
+
+#define FC_CHECK_LOGGING(LEVEL, CMD)                            \
+do {                                                            \
+        if (unlikely(fc_debug_logging & LEVEL))                 \
+                do {                                            \
+                        CMD;                                    \
+                } while (0);                                    \
+} while (0);
+
+#define FC_LIBFC_DBG(fmt, args...)                                      \
+        FC_CHECK_LOGGING(FC_LIBFC_LOGGING,                              \
+                         printk(KERN_INFO "libfc: " fmt, ##args);)
+
+#define FC_LPORT_DBG(lport, fmt, args...)                               \
+        FC_CHECK_LOGGING(FC_LPORT_LOGGING,                              \
+                         printk(KERN_INFO "lport: %6x: " fmt,           \
+                                fc_host_port_id(lport->host), ##args);)
+
+#define FC_DISC_DBG(disc, fmt, args...)                                 \
+        FC_CHECK_LOGGING(FC_DISC_LOGGING,                               \
+                         printk(KERN_INFO "disc: %6x: " fmt,            \
+                                fc_host_port_id(disc->lport->host),     \
+                                ##args);)
+
+#define FC_RPORT_DBG(rport, fmt, args...)                               \
+do {                                                                    \
+        struct fc_rport_libfc_priv *rdata = rport->dd_data;             \
+        struct fc_lport *lport = rdata->local_port;                     \
+        FC_CHECK_LOGGING(FC_RPORT_LOGGING,                              \
+                         printk(KERN_INFO "rport: %6x: %6x: " fmt,      \
+                                fc_host_port_id(lport->host),           \
+                                rport->port_id, ##args);)               \
+} while (0);
+
+#define FC_FCP_DBG(pkt, fmt, args...)                                   \
+        FC_CHECK_LOGGING(FC_FCP_LOGGING,                                \
+                         printk(KERN_INFO "fcp: %6x: %6x: " fmt,        \
+                                fc_host_port_id(pkt->lp->host),         \
+                                pkt->rport->port_id, ##args);)
+
+#define FC_EM_DBG(em, fmt, args...)                                     \
+        FC_CHECK_LOGGING(FC_EM_LOGGING,                                 \
+                         printk(KERN_INFO "em: %6x: " fmt,              \
+                                fc_host_port_id(em->lp->host),          \
+                                ##args);)
+
+#define FC_EXCH_DBG(exch, fmt, args...)                                 \
+        FC_CHECK_LOGGING(FC_EXCH_LOGGING,                               \
+                         printk(KERN_INFO "exch: %6x: %4x: " fmt,       \
+                                fc_host_port_id(exch->lp->host),        \
+                                exch->xid, ##args);)
+
+#define FC_SCSI_DBG(lport, fmt, args...)                                \
+        FC_CHECK_LOGGING(FC_SCSI_LOGGING,                               \
+                         printk(KERN_INFO "scsi: %6x: " fmt,            \
+                                fc_host_port_id(lport->host), ##args);)
 
 /*
  * libfc error codes
@@ -679,6 +734,7 @@ struct fc_lport {
         unsigned int            e_d_tov;
         unsigned int            r_a_tov;
         u8                      max_retry_count;
+        u8                      max_rport_retry_count;
         u16                     link_speed;
         u16                     link_supported_speeds;
         u16                     lro_xid;        /* max xid for fcoe lro */
diff --git a/include/scsi/libfcoe.h b/include/scsi/libfcoe.h
index 666cc131732e..b2410605b740 100644
--- a/include/scsi/libfcoe.h
+++ b/include/scsi/libfcoe.h
@@ -73,6 +73,7 @@ enum fip_state {
  * @link:       current link status for libfc.
  * @last_link:  last link state reported to libfc.
  * @map_dest:   use the FC_MAP mode for destination MAC addresses.
+ * @spma:       supports SPMA server-provided MACs mode
  * @dest_addr:  MAC address of the selected FC forwarder.
  * @ctl_src_addr: the native MAC address of our local port.
  * @data_src_addr: the assigned MAC address for the local port after FLOGI.
@@ -104,6 +105,7 @@ struct fcoe_ctlr {
         u8 link;
         u8 last_link;
         u8 map_dest;
+        u8 spma;
         u8 dest_addr[ETH_ALEN];
         u8 ctl_src_addr[ETH_ALEN];
         u8 data_src_addr[ETH_ALEN];
diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h
index 0289f5745fb9..61afeb59a836 100644
--- a/include/scsi/libiscsi.h
+++ b/include/scsi/libiscsi.h
@@ -82,9 +82,12 @@ enum {
 
 
 enum {
+        ISCSI_TASK_FREE,
         ISCSI_TASK_COMPLETED,
         ISCSI_TASK_PENDING,
         ISCSI_TASK_RUNNING,
+        ISCSI_TASK_ABRT_TMF,            /* aborted due to TMF */
+        ISCSI_TASK_ABRT_SESS_RECOV,     /* aborted due to session recovery */
 };
 
 struct iscsi_r2t_info {
@@ -122,6 +125,10 @@ struct iscsi_task {
         struct scsi_cmnd        *sc;            /* associated SCSI cmd*/
         struct iscsi_conn       *conn;          /* used connection    */
 
+        /* data processing tracking */
+        unsigned long           last_xfer;
+        unsigned long           last_timeout;
+        bool                    have_checked_conn;
         /* state set/tested under session->lock */
         int                     state;
         atomic_t                refcount;
@@ -181,9 +188,7 @@ struct iscsi_conn {
 
         /* xmit */
         struct list_head        mgmtqueue;      /* mgmt (control) xmit queue */
-        struct list_head        mgmt_run_list;  /* list of control tasks */
-        struct list_head        xmitqueue;      /* data-path cmd queue */
-        struct list_head        run_list;       /* list of cmds in progress */
+        struct list_head        cmdqueue;       /* data-path cmd queue */
         struct list_head        requeue;        /* tasks needing another run */
         struct work_struct      xmitwork;       /* per-conn. xmit workqueue */
         unsigned long           suspend_tx;     /* suspend Tx */
@@ -406,6 +411,7 @@ extern int __iscsi_complete_pdu(struct iscsi_conn *, struct iscsi_hdr *,
                                 char *, int);
 extern int iscsi_verify_itt(struct iscsi_conn *, itt_t);
 extern struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *, itt_t);
+extern struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *, itt_t);
 extern void iscsi_requeue_task(struct iscsi_task *task);
 extern void iscsi_put_task(struct iscsi_task *task);
 extern void __iscsi_get_task(struct iscsi_task *task);
diff --git a/include/scsi/osd_attributes.h b/include/scsi/osd_attributes.h
index f888a6fda073..56e920ade326 100644
--- a/include/scsi/osd_attributes.h
+++ b/include/scsi/osd_attributes.h
@@ -29,6 +29,7 @@ enum {
         OSD_APAGE_PARTITION_INFORMATION = OSD_APAGE_PARTITION_FIRST + 1,
         OSD_APAGE_PARTITION_QUOTAS      = OSD_APAGE_PARTITION_FIRST + 2,
         OSD_APAGE_PARTITION_TIMESTAMP   = OSD_APAGE_PARTITION_FIRST + 3,
+        OSD_APAGE_PARTITION_ATTR_ACCESS = OSD_APAGE_PARTITION_FIRST + 4,
         OSD_APAGE_PARTITION_SECURITY    = OSD_APAGE_PARTITION_FIRST + 5,
         OSD_APAGE_PARTITION_LAST        = 0x5FFFFFFF,
 
@@ -51,7 +52,9 @@ enum {
         OSD_APAGE_RESERVED_TYPE_LAST    = 0xEFFFFFFF,
 
         OSD_APAGE_COMMON_FIRST          = 0xF0000000,
-        OSD_APAGE_COMMON_LAST           = 0xFFFFFFFE,
+        OSD_APAGE_COMMON_LAST           = 0xFFFFFFFD,
+
+        OSD_APAGE_CURRENT_COMMAND       = 0xFFFFFFFE,
 
         OSD_APAGE_REQUEST_ALL           = 0xFFFFFFFF,
 };
@@ -106,10 +109,30 @@ enum {
         OSD_ATTR_RI_PRODUCT_REVISION_LEVEL   = 0x7,   /* 4        */
         OSD_ATTR_RI_PRODUCT_SERIAL_NUMBER    = 0x8,   /* variable */
         OSD_ATTR_RI_OSD_NAME                 = 0x9,   /* variable */
+        OSD_ATTR_RI_MAX_CDB_CONTINUATION_LEN = 0xA,   /* 4        */
         OSD_ATTR_RI_TOTAL_CAPACITY           = 0x80,  /* 8        */
         OSD_ATTR_RI_USED_CAPACITY            = 0x81,  /* 8        */
         OSD_ATTR_RI_NUMBER_OF_PARTITIONS     = 0xC0,  /* 8        */
         OSD_ATTR_RI_CLOCK                    = 0x100, /* 6        */
+        OARI_DEFAULT_ISOLATION_METHOD        = 0X110, /* 1        */
+        OARI_SUPPORTED_ISOLATION_METHODS     = 0X111, /* 32       */
+
+        OARI_DATA_ATOMICITY_GUARANTEE                   = 0X120,   /* 8       */
+        OARI_DATA_ATOMICITY_ALIGNMENT                   = 0X121,   /* 8       */
+        OARI_ATTRIBUTES_ATOMICITY_GUARANTEE             = 0X122,   /* 8       */
+        OARI_DATA_ATTRIBUTES_ATOMICITY_MULTIPLIER       = 0X123,   /* 1       */
+
+        OARI_MAXIMUM_SNAPSHOTS_COUNT                    = 0X1C1,    /* 0 or 4 */
+        OARI_MAXIMUM_CLONES_COUNT                       = 0X1C2,    /* 0 or 4 */
+        OARI_MAXIMUM_BRANCH_DEPTH                       = 0X1CC,    /* 0 or 4 */
+        OARI_SUPPORTED_OBJECT_DUPLICATION_METHOD_FIRST  = 0X200,    /* 0 or 4 */
+        OARI_SUPPORTED_OBJECT_DUPLICATION_METHOD_LAST   = 0X2ff,    /* 0 or 4 */
+        OARI_SUPPORTED_TIME_OF_DUPLICATION_METHOD_FIRST = 0X300,    /* 0 or 4 */
+        OARI_SUPPORTED_TIME_OF_DUPLICATION_METHOD_LAST  = 0X30F,    /* 0 or 4 */
+        OARI_SUPPORT_FOR_DUPLICATED_OBJECT_FREEZING     = 0X310,    /* 0 or 4 */
+        OARI_SUPPORT_FOR_SNAPSHOT_REFRESHING            = 0X311,    /* 0 or 1 */
+        OARI_SUPPORTED_CDB_CONTINUATION_DESC_TYPE_FIRST = 0X7000001,/* 0 or 4 */
+        OARI_SUPPORTED_CDB_CONTINUATION_DESC_TYPE_LAST  = 0X700FFFF,/* 0 or 4 */
 };
 /* Root_Information_attributes_page does not have a get_page structure */
 
@@ -120,7 +143,15 @@ enum {
         OSD_ATTR_PI_PARTITION_ID            = 0x1,     /* 8        */
         OSD_ATTR_PI_USERNAME                = 0x9,     /* variable */
         OSD_ATTR_PI_USED_CAPACITY           = 0x81,    /* 8        */
+        OSD_ATTR_PI_USED_CAPACITY_INCREMENT = 0x84,    /* 0 or 8   */
         OSD_ATTR_PI_NUMBER_OF_OBJECTS       = 0xC1,    /* 8        */
+
+        OSD_ATTR_PI_ACTUAL_DATA_SPACE                      = 0xD1, /* 0 or 8 */
+        OSD_ATTR_PI_RESERVED_DATA_SPACE                    = 0xD2, /* 0 or 8 */
+        OSD_ATTR_PI_DEFAULT_SNAPSHOT_DUPLICATION_METHOD    = 0x200,/* 0 or 4 */
+        OSD_ATTR_PI_DEFAULT_CLONE_DUPLICATION_METHOD       = 0x201,/* 0 or 4 */
+        OSD_ATTR_PI_DEFAULT_SP_TIME_OF_DUPLICATION         = 0x300,/* 0 or 4 */
+        OSD_ATTR_PI_DEFAULT_CLONE_TIME_OF_DUPLICATION      = 0x301,/* 0 or 4 */
 };
 /* Partition Information attributes page does not have a get_page structure */
 
@@ -131,6 +162,7 @@ enum {
         OSD_ATTR_CI_PARTITION_ID           = 0x1,       /* 8        */
         OSD_ATTR_CI_COLLECTION_OBJECT_ID   = 0x2,       /* 8        */
         OSD_ATTR_CI_USERNAME               = 0x9,       /* variable */
+        OSD_ATTR_CI_COLLECTION_TYPE        = 0xA,       /* 1        */
         OSD_ATTR_CI_USED_CAPACITY          = 0x81,      /* 8        */
 };
 /* Collection Information attributes page does not have a get_page structure */
@@ -144,6 +176,8 @@ enum {
         OSD_ATTR_OI_USERNAME             = 0x9,       /* variable */
         OSD_ATTR_OI_USED_CAPACITY        = 0x81,      /* 8        */
         OSD_ATTR_OI_LOGICAL_LENGTH       = 0x82,      /* 8        */
+        SD_ATTR_OI_ACTUAL_DATA_SPACE     = 0XD1,      /* 0 OR 8   */
+        SD_ATTR_OI_RESERVED_DATA_SPACE   = 0XD2,      /* 0 OR 8   */
 };
 /* Object Information attributes page does not have a get_page structure */
 
@@ -248,7 +282,18 @@ struct object_timestamps_attributes_page {
         struct osd_timestamp data_modified_time;
 }  __packed;
 
-/* 7.1.2.19 Collections attributes page */
+/* OSD2r05: 7.1.3.19 Attributes Access attributes page
+ * (OSD_APAGE_PARTITION_ATTR_ACCESS)
+ *
+ * each attribute is of the form below. Total array length is deduced
+ * from the attribute's length
+ * (See allowed_attributes_access of the struct osd_cap_object_descriptor)
+ */
+struct attributes_access_attr {
+        struct osd_attributes_list_attrid attr_list[0];
+} __packed;
+
+/* OSD2r05: 7.1.2.21 Collections attributes page */
 /* TBD */
 
 /* 7.1.2.20 Root Policy/Security attributes page (OSD_APAGE_ROOT_SECURITY) */
@@ -324,4 +369,29 @@ struct object_security_attributes_page {
         __be32 policy_access_tag;
 }  __packed;
 
+/* OSD2r05: 7.1.3.31 Current Command attributes page
+ * (OSD_APAGE_CURRENT_COMMAND)
+ */
+enum {
+        OSD_ATTR_CC_RESPONSE_INTEGRITY_CHECK_VALUE     = 0x1, /* 32  */
+        OSD_ATTR_CC_OBJECT_TYPE                        = 0x2, /* 1   */
+        OSD_ATTR_CC_PARTITION_ID                       = 0x3, /* 8   */
+        OSD_ATTR_CC_OBJECT_ID                          = 0x4, /* 8   */
+        OSD_ATTR_CC_STARTING_BYTE_ADDRESS_OF_APPEND    = 0x5, /* 8   */
+        OSD_ATTR_CC_CHANGE_IN_USED_CAPACITY            = 0x6, /* 8   */
+};
+
+/*TBD: osdv1_current_command_attributes_page */
+
+struct osdv2_current_command_attributes_page {
+        struct osd_attr_page_header hdr;  /* id=0xFFFFFFFE, size=0x44 */
+        u8 response_integrity_check_value[OSD_CRYPTO_KEYID_SIZE];
+        u8 object_type;
+        u8 reserved[3];
+        __be64 partition_id;
+        __be64 object_id;
+        __be64 starting_byte_address_of_append;
+        __be64 change_in_used_capacity;
+};
+
 #endif /*ndef __OSD_ATTRIBUTES_H__*/
diff --git a/include/scsi/osd_initiator.h b/include/scsi/osd_initiator.h
index b24d9616eb46..02bd9f716357 100644
--- a/include/scsi/osd_initiator.h
+++ b/include/scsi/osd_initiator.h
@@ -18,6 +18,7 @@
 #include "osd_types.h"
 
 #include <linux/blkdev.h>
+#include <scsi/scsi_device.h>
 
 /* Note: "NI" in comments below means "Not Implemented yet" */
 
@@ -47,6 +48,7 @@ enum osd_std_version {
  */
 struct osd_dev {
         struct scsi_device *scsi_device;
+        struct file *file;
         unsigned def_timeout;
 
 #ifdef OSD_VER1_SUPPORT
@@ -69,6 +71,10 @@ void osd_dev_fini(struct osd_dev *od);
 
 /* some hi level device operations */
 int osd_auto_detect_ver(struct osd_dev *od, void *caps);    /* GFP_KERNEL */
+static inline struct request_queue *osd_request_queue(struct osd_dev *od)
+{
+        return od->scsi_device->request_queue;
+}
 
 /* we might want to use function vector in the future */
 static inline void osd_dev_set_ver(struct osd_dev *od, enum osd_std_version v)
@@ -363,7 +369,9 @@ void osd_req_create_object(struct osd_request *or, struct osd_obj_id *);
 void osd_req_remove_object(struct osd_request *or, struct osd_obj_id *);
 
 void osd_req_write(struct osd_request *or,
-        const struct osd_obj_id *, struct bio *data_out, u64 offset);
+        const struct osd_obj_id *obj, u64 offset, struct bio *bio, u64 len);
+int osd_req_write_kern(struct osd_request *or,
+        const struct osd_obj_id *obj, u64 offset, void *buff, u64 len);
 void osd_req_append(struct osd_request *or,
         const struct osd_obj_id *, struct bio *data_out);/* NI */
 void osd_req_create_write(struct osd_request *or,
@@ -378,7 +386,9 @@ void osd_req_flush_object(struct osd_request *or,
         /*V2*/ u64 offset, /*V2*/ u64 len);
 
 void osd_req_read(struct osd_request *or,
-        const struct osd_obj_id *, struct bio *data_in, u64 offset);
+        const struct osd_obj_id *obj, u64 offset, struct bio *bio, u64 len);
+int osd_req_read_kern(struct osd_request *or,
+        const struct osd_obj_id *obj, u64 offset, void *buff, u64 len);
 
 /*
  * Root/Partition/Collection/Object Attributes commands
diff --git a/include/scsi/osd_protocol.h b/include/scsi/osd_protocol.h
index 62b2ab8c69d4..2cc8e8b1cc19 100644
--- a/include/scsi/osd_protocol.h
+++ b/include/scsi/osd_protocol.h
@@ -303,7 +303,15 @@ enum osd_service_actions {
         OSD_ACT_V2(REMOVE_MEMBER_OBJECTS,       0x21)
         OSD_ACT_V2(GET_MEMBER_ATTRIBUTES,       0x22)
         OSD_ACT_V2(SET_MEMBER_ATTRIBUTES,       0x23)
+
+        OSD_ACT_V2(CREATE_CLONE,                0x28)
+        OSD_ACT_V2(CREATE_SNAPSHOT,             0x29)
+        OSD_ACT_V2(DETACH_CLONE,                0x2A)
+        OSD_ACT_V2(REFRESH_SNAPSHOT_CLONE,      0x2B)
+        OSD_ACT_V2(RESTORE_PARTITION_FROM_SNAPSHOT, 0x2C)
+
         OSD_ACT_V2(READ_MAP,                    0x31)
+        OSD_ACT_V2(READ_MAPS_COMPARE,           0x32)
 
         OSD_ACT_V1_V2(PERFORM_SCSI_COMMAND,     0x8F7E, 0x8F7C)
         OSD_ACT_V1_V2(SCSI_TASK_MANAGEMENT,     0x8F7F, 0x8F7D)
diff --git a/include/scsi/scsi_bsg_fc.h b/include/scsi/scsi_bsg_fc.h
new file mode 100644
index 000000000000..a4b233318179
--- /dev/null
+++ b/include/scsi/scsi_bsg_fc.h
@@ -0,0 +1,322 @@
+/*
+ *  FC Transport BSG Interface
+ *
+ *  Copyright (C) 2008   James Smart, Emulex Corporation
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ifndef SCSI_BSG_FC_H
+#define SCSI_BSG_FC_H
+
+/*
+ * This file intended to be included by both kernel and user space
+ */
+
+#include <scsi/scsi.h>
+
+/*
+ * FC Transport SGIO v4 BSG Message Support
+ */
+
+/* Default BSG request timeout (in seconds) */
+#define FC_DEFAULT_BSG_TIMEOUT          (10 * HZ)
+
+
+/*
+ * Request Message Codes supported by the FC Transport
+ */
+
+/* define the class masks for the message codes */
+#define FC_BSG_CLS_MASK         0xF0000000      /* find object class */
+#define FC_BSG_HST_MASK         0x80000000      /* fc host class */
+#define FC_BSG_RPT_MASK         0x40000000      /* fc rport class */
+
+        /* fc_host Message Codes */
+#define FC_BSG_HST_ADD_RPORT            (FC_BSG_HST_MASK | 0x00000001)
+#define FC_BSG_HST_DEL_RPORT            (FC_BSG_HST_MASK | 0x00000002)
+#define FC_BSG_HST_ELS_NOLOGIN          (FC_BSG_HST_MASK | 0x00000003)
+#define FC_BSG_HST_CT                   (FC_BSG_HST_MASK | 0x00000004)
+#define FC_BSG_HST_VENDOR               (FC_BSG_HST_MASK | 0x000000FF)
+
+        /* fc_rport Message Codes */
+#define FC_BSG_RPT_ELS                  (FC_BSG_RPT_MASK | 0x00000001)
+#define FC_BSG_RPT_CT                   (FC_BSG_RPT_MASK | 0x00000002)
+
+
+
+/*
+ * FC Address Identifiers in Message Structures :
+ *
+ *   Whenever a command payload contains a FC Address Identifier
+ *   (aka port_id), the value is effectively in big-endian
+ *   order, thus the array elements are decoded as follows:
+ *     element [0] is bits 23:16 of the FC Address Identifier
+ *     element [1] is bits 15:8 of the FC Address Identifier
+ *     element [2] is bits 7:0 of the FC Address Identifier
+ */
+
+
+/*
+ * FC Host Messages
+ */
+
+/* FC_BSG_HST_ADDR_PORT : */
+
+/* Request:
+ * This message requests the FC host to login to the remote port
+ * at the specified N_Port_Id.  The remote port is to be enumerated
+ * with the transport upon completion of the login.
+ */
+struct fc_bsg_host_add_rport {
+        uint8_t         reserved;
+
+        /* FC Address Identier of the remote port to login to */
+        uint8_t         port_id[3];
+};
+
+/* Response:
+ * There is no additional response data - fc_bsg_reply->result is sufficient
+ */
+
+
+/* FC_BSG_HST_DEL_RPORT : */
+
+/* Request:
+ * This message requests the FC host to remove an enumerated
+ * remote port and to terminate the login to it.
+ *
+ * Note: The driver is free to reject this request if it desires to
+ * remain logged in with the remote port.
+ */
+struct fc_bsg_host_del_rport {
+        uint8_t         reserved;
+
+        /* FC Address Identier of the remote port to logout of */
+        uint8_t         port_id[3];
+};
+
+/* Response:
+ * There is no additional response data - fc_bsg_reply->result is sufficient
+ */
+
+
+/* FC_BSG_HST_ELS_NOLOGIN : */
+
+/* Request:
+ * This message requests the FC_Host to send an ELS to a specific
+ * N_Port_ID. The host does not need to log into the remote port,
+ * nor does it need to enumerate the rport for further traffic
+ * (although, the FC host is free to do so if it desires).
+ */
+struct fc_bsg_host_els {
+        /*
+         * ELS Command Code being sent (must be the same as byte 0
+         * of the payload)
+         */
+        uint8_t         command_code;
+
+        /* FC Address Identier of the remote port to send the ELS to */
+        uint8_t         port_id[3];
+};
+
+/* Response:
+ */
+/* fc_bsg_ctels_reply->status values */
+#define FC_CTELS_STATUS_OK      0x00000000
+#define FC_CTELS_STATUS_REJECT  0x00000001
+#define FC_CTELS_STATUS_P_RJT   0x00000002
+#define FC_CTELS_STATUS_F_RJT   0x00000003
+#define FC_CTELS_STATUS_P_BSY   0x00000004
+#define FC_CTELS_STATUS_F_BSY   0x00000006
+struct fc_bsg_ctels_reply {
+        /*
+         * Note: An ELS LS_RJT may be reported in 2 ways:
+         *  a) A status of FC_CTELS_STATUS_OK is returned. The caller
+         *     is to look into the ELS receive payload to determine
+         *     LS_ACC or LS_RJT (by contents of word 0). The reject
+         *     data will be in word 1.
+         *  b) A status of FC_CTELS_STATUS_REJECT is returned, The
+         *     rjt_data field will contain valid data.
+         *
+         * Note: ELS LS_ACC is determined by an FC_CTELS_STATUS_OK, and
+         *   the receive payload word 0 indicates LS_ACC
+         *   (e.g. value is 0x02xxxxxx).
+         *
+         * Note: Similarly, a CT Reject may be reported in 2 ways:
+         *  a) A status of FC_CTELS_STATUS_OK is returned. The caller
+         *     is to look into the CT receive payload to determine
+         *     Accept or Reject (by contents of word 2). The reject
+         *     data will be in word 3.
+         *  b) A status of FC_CTELS_STATUS_REJECT is returned, The
+         *     rjt_data field will contain valid data.
+         *
+         * Note: x_RJT/BSY status will indicae that the rjt_data field
+         *   is valid and contains the reason/explanation values.
+         */
+        uint32_t        status;         /* See FC_CTELS_STATUS_xxx */
+
+        /* valid if status is not FC_CTELS_STATUS_OK */
+        struct  {
+                uint8_t action;         /* fragment_id for CT REJECT */
+                uint8_t reason_code;
+                uint8_t reason_explanation;
+                uint8_t vendor_unique;
+        } rjt_data;
+};
+
+
+/* FC_BSG_HST_CT : */
+
+/* Request:
+ * This message requests that a CT Request be performed with the
+ * indicated N_Port_ID. The driver is responsible for logging in with
+ * the fabric and/or N_Port_ID, etc as per FC rules. This request does
+ * not mandate that the driver must enumerate the destination in the
+ * transport. The driver is allowed to decide whether to enumerate it,
+ * and whether to tear it down after the request.
+ */
+struct fc_bsg_host_ct {
+        uint8_t         reserved;
+
+        /* FC Address Identier of the remote port to send the ELS to */
+        uint8_t         port_id[3];
+
+        /*
+         * We need words 0-2 of the generic preamble for the LLD's
+         */
+        uint32_t        preamble_word0; /* revision & IN_ID */
+        uint32_t        preamble_word1; /* GS_Type, GS_SubType, Options, Rsvd */
+        uint32_t        preamble_word2; /* Cmd Code, Max Size */
+
+};
+/* Response:
+ *
+ * The reply structure is an fc_bsg_ctels_reply structure
+ */
+
+
+/* FC_BSG_HST_VENDOR : */
+
+/* Request:
+ * Note: When specifying vendor_id, be sure to read the Vendor Type and ID
+ *   formatting requirements specified in scsi_netlink.h
+ */
+struct fc_bsg_host_vendor {
+        /*
+         * Identifies the vendor that the message is formatted for. This
+         * should be the recipient of the message.
+         */
+        uint64_t vendor_id;
+
+        /* start of vendor command area */
+        uint32_t vendor_cmd[0];
+};
+
+/* Response:
+ */
+struct fc_bsg_host_vendor_reply {
+        /* start of vendor response area */
+        uint32_t vendor_rsp[0];
+};
+
+
+
+/*
+ * FC Remote Port Messages
+ */
+
+/* FC_BSG_RPT_ELS : */
+
+/* Request:
+ * This message requests that an ELS be performed with the rport.
+ */
+struct fc_bsg_rport_els {
+        /*
+         * ELS Command Code being sent (must be the same as
+         * byte 0 of the payload)
+         */
+        uint8_t els_code;
+};
+
+/* Response:
+ *
+ * The reply structure is an fc_bsg_ctels_reply structure
+ */
+
+
+/* FC_BSG_RPT_CT : */
+
+/* Request:
+ * This message requests that a CT Request be performed with the rport.
+ */
+struct fc_bsg_rport_ct {
+        /*
+         * We need words 0-2 of the generic preamble for the LLD's
+         */
+        uint32_t        preamble_word0; /* revision & IN_ID */
+        uint32_t        preamble_word1; /* GS_Type, GS_SubType, Options, Rsvd */
+        uint32_t        preamble_word2; /* Cmd Code, Max Size */
+};
+/* Response:
+ *
+ * The reply structure is an fc_bsg_ctels_reply structure
+ */
+
+
+
+
+/* request (CDB) structure of the sg_io_v4 */
+struct fc_bsg_request {
+        uint32_t msgcode;
+        union {
+                struct fc_bsg_host_add_rport    h_addrport;
+                struct fc_bsg_host_del_rport    h_delrport;
+                struct fc_bsg_host_els          h_els;
+                struct fc_bsg_host_ct           h_ct;
+                struct fc_bsg_host_vendor       h_vendor;
+
+                struct fc_bsg_rport_els         r_els;
+                struct fc_bsg_rport_ct          r_ct;
+        } rqst_data;
+};
+
+
+/* response (request sense data) structure of the sg_io_v4 */
+struct fc_bsg_reply {
+        /*
+         * The completion result. Result exists in two forms:
+         *  if negative, it is an -Exxx system errno value. There will
+         *    be no further reply information supplied.
+         *  else, it's the 4-byte scsi error result, with driver, host,
+         *    msg and status fields. The per-msgcode reply structure
+         *    will contain valid data.
+         */
+        uint32_t result;
+
+        /* If there was reply_payload, how much was recevied ? */
+        uint32_t reply_payload_rcv_len;
+
+        union {
+                struct fc_bsg_host_vendor_reply         vendor_reply;
+
+                struct fc_bsg_ctels_reply               ctels_reply;
+        } reply_data;
+};
+
+
+#endif /* SCSI_BSG_FC_H */
+
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index 43b50d36925c..3878d1dc7f59 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -270,7 +270,7 @@ static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
 
 static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
 {
-        return scmd->request->sector;
+        return blk_rq_pos(scmd->request);
 }
 
 static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
diff --git a/include/scsi/scsi_driver.h b/include/scsi/scsi_driver.h
index 1f5ca7f62116..9fd6702f02e2 100644
--- a/include/scsi/scsi_driver.h
+++ b/include/scsi/scsi_driver.h
@@ -32,5 +32,6 @@ int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req);
 int scsi_setup_fs_cmnd(struct scsi_device *sdev, struct request *req);
 int scsi_prep_state_check(struct scsi_device *sdev, struct request *req);
 int scsi_prep_return(struct request_queue *q, struct request *req, int ret);
+int scsi_prep_fn(struct request_queue *, struct request *);
 
 #endif /* _SCSI_SCSI_DRIVER_H */
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index d123ca84e732..b62a097b3ecb 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -478,6 +478,15 @@ struct scsi_host_template {
          * module_init/module_exit.
          */
         struct list_head legacy_hosts;
+
+        /*
+         * Vendor Identifier associated with the host
+         *
+         * Note: When specifying vendor_id, be sure to read the
+         *   Vendor Type and ID formatting requirements specified in
+         *   scsi_netlink.h
+         */
+        u64 vendor_id;
 };
 
 /*
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h
index 68a8d873bbd9..fc50bd64aa4e 100644
--- a/include/scsi/scsi_transport_fc.h
+++ b/include/scsi/scsi_transport_fc.h
@@ -33,7 +33,6 @@
 
 struct scsi_transport_template;
 
-
 /*
  * FC Port definitions - Following FC HBAAPI guidelines
  *
@@ -352,6 +351,7 @@ struct fc_rport {	/* aka fc_starget_attrs */
         struct delayed_work fail_io_work;
         struct work_struct stgt_delete_work;
         struct work_struct rport_delete_work;
+        struct request_queue *rqst_q;   /* bsg support */
 } __attribute__((aligned(sizeof(unsigned long))));
 
 /* bit field values for struct fc_rport "flags" field: */
@@ -514,6 +514,9 @@ struct fc_host_attrs {
         struct workqueue_struct *work_q;
         char devloss_work_q_name[20];
         struct workqueue_struct *devloss_work_q;
+
+        /* bsg support */
+        struct request_queue *rqst_q;
 };
 
 #define shost_to_fc_host(x) \
@@ -579,6 +582,47 @@ struct fc_host_attrs {
         (((struct fc_host_attrs *)(x)->shost_data)->devloss_work_q)
 
 
+struct fc_bsg_buffer {
+        unsigned int payload_len;
+        int sg_cnt;
+        struct scatterlist *sg_list;
+};
+
+/* Values for fc_bsg_job->state_flags (bitflags) */
+#define FC_RQST_STATE_INPROGRESS        0
+#define FC_RQST_STATE_DONE              1
+
+struct fc_bsg_job {
+        struct Scsi_Host *shost;
+        struct fc_rport *rport;
+        struct device *dev;
+        struct request *req;
+        spinlock_t job_lock;
+        unsigned int state_flags;
+        unsigned int ref_cnt;
+        void (*job_done)(struct fc_bsg_job *);
+
+        struct fc_bsg_request *request;
+        struct fc_bsg_reply *reply;
+        unsigned int request_len;
+        unsigned int reply_len;
+        /*
+         * On entry : reply_len indicates the buffer size allocated for
+         * the reply.
+         *
+         * Upon completion : the message handler must set reply_len
+         *  to indicates the size of the reply to be returned to the
+         *  caller.
+         */
+
+        /* DMA payloads for the request/response */
+        struct fc_bsg_buffer request_payload;
+        struct fc_bsg_buffer reply_payload;
+
+        void *dd_data;                  /* Used for driver-specific storage */
+};
+
+
 /* The functions by which the transport class and the driver communicate */
 struct fc_function_template {
         void    (*get_rport_dev_loss_tmo)(struct fc_rport *);
@@ -614,9 +658,14 @@ struct fc_function_template {
         int     (* tsk_mgmt_response)(struct Scsi_Host *, u64, u64, int);
         int     (* it_nexus_response)(struct Scsi_Host *, u64, int);
 
+        /* bsg support */
+        int     (*bsg_request)(struct fc_bsg_job *);
+        int     (*bsg_timeout)(struct fc_bsg_job *);
+
         /* allocation lengths for host-specific data */
         u32                             dd_fcrport_size;
         u32                             dd_fcvport_size;
+        u32                             dd_bsg_size;
 
         /*
          * The driver sets these to tell the transport class it
@@ -737,7 +786,6 @@ fc_vport_set_state(struct fc_vport *vport, enum fc_vport_state new_state)
         vport->vport_state = new_state;
 }
 
-
 struct scsi_transport_template *fc_attach_transport(
                         struct fc_function_template *);
 void fc_release_transport(struct scsi_transport_template *);
diff --git a/include/scsi/scsi_transport_iscsi.h b/include/scsi/scsi_transport_iscsi.h
index 457588e1119b..349c7f30720d 100644
--- a/include/scsi/scsi_transport_iscsi.h
+++ b/include/scsi/scsi_transport_iscsi.h
@@ -126,12 +126,14 @@ struct iscsi_transport {
                                int *index, int *age);
 
         void (*session_recovery_timedout) (struct iscsi_cls_session *session);
-        struct iscsi_endpoint *(*ep_connect) (struct sockaddr *dst_addr,
+        struct iscsi_endpoint *(*ep_connect) (struct Scsi_Host *shost,
+                                              struct sockaddr *dst_addr,
                                               int non_blocking);
         int (*ep_poll) (struct iscsi_endpoint *ep, int timeout_ms);
         void (*ep_disconnect) (struct iscsi_endpoint *ep);
         int (*tgt_dscvr) (struct Scsi_Host *shost, enum iscsi_tgt_dscvr type,
                           uint32_t enable, struct sockaddr *dst_addr);
+        int (*set_path) (struct Scsi_Host *shost, struct iscsi_path *params);
 };
 
 /*
@@ -148,6 +150,10 @@ extern void iscsi_conn_error_event(struct iscsi_cls_conn *conn,
 extern int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
                           char *data, uint32_t data_size);
 
+extern int iscsi_offload_mesg(struct Scsi_Host *shost,
+                              struct iscsi_transport *transport, uint32_t type,
+                              char *data, uint16_t data_size);
+
 struct iscsi_cls_conn {
         struct list_head conn_list;     /* item in connlist */
         void *dd_data;                  /* LLD private data */
diff --git a/include/scsi/scsi_transport_spi.h b/include/scsi/scsi_transport_spi.h
index 286e9628ed8b..7497a383b1a4 100644
--- a/include/scsi/scsi_transport_spi.h
+++ b/include/scsi/scsi_transport_spi.h
@@ -36,8 +36,10 @@ struct spi_transport_attrs {
         unsigned int width:1;   /* 0 - narrow, 1 - wide */
         unsigned int max_width:1;
         unsigned int iu:1;      /* Information Units enabled */
+        unsigned int max_iu:1;
         unsigned int dt:1;      /* DT clocking enabled */
         unsigned int qas:1;     /* Quick Arbitration and Selection enabled */
+        unsigned int max_qas:1;
         unsigned int wr_flow:1; /* Write Flow control enabled */
         unsigned int rd_strm:1; /* Read streaming enabled */
         unsigned int rti:1;     /* Retain Training Information */
@@ -77,8 +79,10 @@ struct spi_host_attrs {
 #define spi_width(x)    (((struct spi_transport_attrs *)&(x)->starget_data)->width)
 #define spi_max_width(x) (((struct spi_transport_attrs *)&(x)->starget_data)->max_width)
 #define spi_iu(x)       (((struct spi_transport_attrs *)&(x)->starget_data)->iu)
+#define spi_max_iu(x)   (((struct spi_transport_attrs *)&(x)->starget_data)->max_iu)
 #define spi_dt(x)       (((struct spi_transport_attrs *)&(x)->starget_data)->dt)
 #define spi_qas(x)      (((struct spi_transport_attrs *)&(x)->starget_data)->qas)
+#define spi_max_qas(x)  (((struct spi_transport_attrs *)&(x)->starget_data)->max_qas)
 #define spi_wr_flow(x)  (((struct spi_transport_attrs *)&(x)->starget_data)->wr_flow)
 #define spi_rd_strm(x)  (((struct spi_transport_attrs *)&(x)->starget_data)->rd_strm)
 #define spi_rti(x)      (((struct spi_transport_attrs *)&(x)->starget_data)->rti)
diff --git a/include/sound/asound.h b/include/sound/asound.h
index 6add80fc2512..82aed3f47534 100644
--- a/include/sound/asound.h
+++ b/include/sound/asound.h
@@ -255,6 +255,7 @@ typedef int __bitwise snd_pcm_subformat_t;
 #define SNDRV_PCM_INFO_HALF_DUPLEX      0x00100000      /* only half duplex */
 #define SNDRV_PCM_INFO_JOINT_DUPLEX     0x00200000      /* playback and capture stream are somewhat correlated */
 #define SNDRV_PCM_INFO_SYNC_START       0x00400000      /* pcm support some kind of sync go */
+#define SNDRV_PCM_INFO_FIFO_IN_FRAMES   0x80000000      /* internal kernel flag - FIFO size is in frames */
 
 typedef int __bitwise snd_pcm_state_t;
 #define SNDRV_PCM_STATE_OPEN            ((__force snd_pcm_state_t) 0) /* stream is open */
diff --git a/include/sound/core.h b/include/sound/core.h
index 3dea79829acc..309cb9659a05 100644
--- a/include/sound/core.h
+++ b/include/sound/core.h
@@ -300,19 +300,10 @@ int snd_card_create(int idx, const char *id,
                     struct module *module, int extra_size,
                     struct snd_card **card_ret);
 
-static inline __deprecated
-struct snd_card *snd_card_new(int idx, const char *id,
-                              struct module *module, int extra_size)
-{
-        struct snd_card *card;
-        if (snd_card_create(idx, id, module, extra_size, &card) < 0)
-                return NULL;
-        return card;
-}
-
 int snd_card_disconnect(struct snd_card *card);
 int snd_card_free(struct snd_card *card);
 int snd_card_free_when_closed(struct snd_card *card);
+void snd_card_set_id(struct snd_card *card, const char *id);
 int snd_card_register(struct snd_card *card);
 int snd_card_info_init(void);
 int snd_card_info_done(void);
diff --git a/include/sound/driver.h b/include/sound/driver.h
deleted file mode 100644
index f0359437d01a..000000000000
--- a/include/sound/driver.h
+++ /dev/null
@@ -1 +0,0 @@
-#warning "This file is deprecated"
diff --git a/include/sound/pcm.h b/include/sound/pcm.h
index c17296891617..23893523dc8c 100644
--- a/include/sound/pcm.h
+++ b/include/sound/pcm.h
@@ -98,6 +98,7 @@ struct snd_pcm_ops {
 #define SNDRV_PCM_IOCTL1_INFO           1
 #define SNDRV_PCM_IOCTL1_CHANNEL_INFO   2
 #define SNDRV_PCM_IOCTL1_GSTATE         3
+#define SNDRV_PCM_IOCTL1_FIFO_SIZE      4
 
 #define SNDRV_PCM_TRIGGER_STOP          0
 #define SNDRV_PCM_TRIGGER_START         1
@@ -270,6 +271,7 @@ struct snd_pcm_runtime {
         snd_pcm_uframes_t hw_ptr_base;  /* Position at buffer restart */
         snd_pcm_uframes_t hw_ptr_interrupt; /* Position at interrupt time */
         unsigned long hw_ptr_jiffies;   /* Time when hw_ptr is updated */
+        snd_pcm_sframes_t delay;        /* extra delay; typically FIFO size */
 
         /* -- HW params -- */
         snd_pcm_access_t access;        /* access mode */
@@ -486,80 +488,6 @@ void snd_pcm_detach_substream(struct snd_pcm_substream *substream);
 void snd_pcm_vma_notify_data(void *client, void *data);
 int snd_pcm_mmap_data(struct snd_pcm_substream *substream, struct file *file, struct vm_area_struct *area);
 
-#if BITS_PER_LONG >= 64
-
-static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
-{
-        *rem = *n % div;
-        *n /= div;
-}
-
-#elif defined(i386)
-
-static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
-{
-        u_int32_t low, high;
-        low = *n & 0xffffffff;
-        high = *n >> 32;
-        if (high) {
-                u_int32_t high1 = high % div;
-                high /= div;
-                asm("divl %2":"=a" (low), "=d" (*rem):"rm" (div), "a" (low), "d" (high1));
-                *n = (u_int64_t)high << 32 | low;
-        } else {
-                *n = low / div;
-                *rem = low % div;
-        }
-}
-#else
-
-static inline void divl(u_int32_t high, u_int32_t low,
-                        u_int32_t div,
-                        u_int32_t *q, u_int32_t *r)
-{
-        u_int64_t n = (u_int64_t)high << 32 | low;
-        u_int64_t d = (u_int64_t)div << 31;
-        u_int32_t q1 = 0;
-        int c = 32;
-        while (n > 0xffffffffU) {
-                q1 <<= 1;
-                if (n >= d) {
-                        n -= d;
-                        q1 |= 1;
-                }
-                d >>= 1;
-                c--;
-        }
-        q1 <<= c;
-        if (n) {
-                low = n;
-                *q = q1 | (low / div);
-                *r = low % div;
-        } else {
-                *r = 0;
-                *q = q1;
-        }
-        return;
-}
-
-static inline void div64_32(u_int64_t *n, u_int32_t div, u_int32_t *rem)
-{
-        u_int32_t low, high;
-        low = *n & 0xffffffff;
-        high = *n >> 32;
-        if (high) {
-                u_int32_t high1 = high % div;
-                u_int32_t low1 = low;
-                high /= div;
-                divl(high1, low1, div, &low, rem);
-                *n = (u_int64_t)high << 32 | low;
-        } else {
-                *n = low / div;
-                *rem = low % div;
-        }
-}
-#endif
-
 /*
  *  PCM library
  */
diff --git a/include/sound/soc-dai.h b/include/sound/soc-dai.h
index 13676472ddfc..352d7eee9b6d 100644
--- a/include/sound/soc-dai.h
+++ b/include/sound/soc-dai.h
@@ -45,24 +45,6 @@ struct snd_pcm_substream;
 #define SND_SOC_DAIFMT_GATED            (1 << 4) /* clock is gated */
 
 /*
- * DAI Left/Right Clocks.
- *
- * Specifies whether the DAI can support different samples for similtanious
- * playback and capture. This usually requires a seperate physical frame
- * clock for playback and capture.
- */
-#define SND_SOC_DAIFMT_SYNC             (0 << 5) /* Tx FRM = Rx FRM */
-#define SND_SOC_DAIFMT_ASYNC            (1 << 5) /* Tx FRM ~ Rx FRM */
-
-/*
- * TDM
- *
- * Time Division Multiplexing. Allows PCM data to be multplexed with other
- * data on the DAI.
- */
-#define SND_SOC_DAIFMT_TDM              (1 << 6)
-
-/*
  * DAI hardware signal inversions.
  *
  * Specifies whether the DAI can also support inverted clocks for the specified
@@ -96,6 +78,10 @@ struct snd_pcm_substream;
 #define SND_SOC_CLOCK_IN                0
 #define SND_SOC_CLOCK_OUT               1
 
+#define SND_SOC_STD_AC97_FMTS (SNDRV_PCM_FMTBIT_S16_LE |\
+                               SNDRV_PCM_FMTBIT_S32_LE |\
+                               SNDRV_PCM_FMTBIT_S32_BE)
+
 struct snd_soc_dai_ops;
 struct snd_soc_dai;
 struct snd_ac97_bus_ops;
@@ -208,6 +194,7 @@ struct snd_soc_dai {
         /* DAI capabilities */
         struct snd_soc_pcm_stream capture;
         struct snd_soc_pcm_stream playback;
+        unsigned int symmetric_rates:1;
 
         /* DAI runtime info */
         struct snd_pcm_runtime *runtime;
@@ -219,11 +206,8 @@ struct snd_soc_dai {
         /* DAI private data */
         void *private_data;
 
-        /* parent codec/platform */
-        union {
-                struct snd_soc_codec *codec;
-                struct snd_soc_platform *platform;
-        };
+        /* parent platform */
+        struct snd_soc_platform *platform;
 
         struct list_head list;
 };
diff --git a/include/sound/soc-dapm.h b/include/sound/soc-dapm.h
index a7def6a9a030..ec8a45f9a069 100644
--- a/include/sound/soc-dapm.h
+++ b/include/sound/soc-dapm.h
@@ -140,16 +140,30 @@
 #define SND_SOC_DAPM_DAC(wname, stname, wreg, wshift, winvert) \
 {       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, .reg = wreg, \
         .shift = wshift, .invert = winvert}
+#define SND_SOC_DAPM_DAC_E(wname, stname, wreg, wshift, winvert, \
+                           wevent, wflags)                              \
+{       .id = snd_soc_dapm_dac, .name = wname, .sname = stname, .reg = wreg, \
+        .shift = wshift, .invert = winvert, \
+        .event = wevent, .event_flags = wflags}
 #define SND_SOC_DAPM_ADC(wname, stname, wreg, wshift, winvert) \
 {       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \
         .shift = wshift, .invert = winvert}
+#define SND_SOC_DAPM_ADC_E(wname, stname, wreg, wshift, winvert, \
+                           wevent, wflags)                              \
+{       .id = snd_soc_dapm_adc, .name = wname, .sname = stname, .reg = wreg, \
+        .shift = wshift, .invert = winvert, \
+        .event = wevent, .event_flags = wflags}
 
-/* generic register modifier widget */
+/* generic widgets */
 #define SND_SOC_DAPM_REG(wid, wname, wreg, wshift, wmask, won_val, woff_val) \
 {       .id = wid, .name = wname, .kcontrols = NULL, .num_kcontrols = 0, \
         .reg = -((wreg) + 1), .shift = wshift, .mask = wmask, \
         .on_val = won_val, .off_val = woff_val, .event = dapm_reg_event, \
         .event_flags = SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD}
+#define SND_SOC_DAPM_SUPPLY(wname, wreg, wshift, winvert, wevent, wflags) \
+{       .id = snd_soc_dapm_supply, .name = wname, .reg = wreg,  \
+        .shift = wshift, .invert = winvert, .event = wevent, \
+        .event_flags = wflags}
 
 /* dapm kcontrol types */
 #define SOC_DAPM_SINGLE(xname, reg, shift, max, invert) \
@@ -265,8 +279,6 @@ int snd_soc_dapm_add_routes(struct snd_soc_codec *codec,
 /* dapm events */
 int snd_soc_dapm_stream_event(struct snd_soc_codec *codec, char *stream,
         int event);
-int snd_soc_dapm_set_bias_level(struct snd_soc_device *socdev,
-        enum snd_soc_bias_level level);
 
 /* dapm sys fs - used by the core */
 int snd_soc_dapm_sys_add(struct device *dev);
@@ -298,6 +310,7 @@ enum snd_soc_dapm_type {
         snd_soc_dapm_vmid,                      /* codec bias/vmid - to minimise pops */
         snd_soc_dapm_pre,                       /* machine specific pre widget - exec first */
         snd_soc_dapm_post,                      /* machine specific post widget - exec last */
+        snd_soc_dapm_supply,            /* power/clock supply */
 };
 
 /*
@@ -357,6 +370,8 @@ struct snd_soc_dapm_widget {
         unsigned char suspend:1;                /* was active before suspend */
         unsigned char pmdown:1;                 /* waiting for timeout */
 
+        int (*power_check)(struct snd_soc_dapm_widget *w);
+
         /* external events */
         unsigned short event_flags;             /* flags to specify event types */
         int (*event)(struct snd_soc_dapm_widget*, struct snd_kcontrol *, int);
@@ -368,6 +383,9 @@ struct snd_soc_dapm_widget {
         /* widget input and outputs */
         struct list_head sources;
         struct list_head sinks;
+
+        /* used during DAPM updates */
+        struct list_head power_list;
 };
 
 #endif
diff --git a/include/sound/soc.h b/include/sound/soc.h
index a40bc6f316fc..cf6111d72b17 100644
--- a/include/sound/soc.h
+++ b/include/sound/soc.h
@@ -118,6 +118,14 @@
         .info = snd_soc_info_volsw, \
         .get = xhandler_get, .put = xhandler_put, \
         .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
+#define SOC_DOUBLE_EXT(xname, xreg, shift_left, shift_right, xmax, xinvert,\
+         xhandler_get, xhandler_put) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
+        .info = snd_soc_info_volsw, \
+        .get = xhandler_get, .put = xhandler_put, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .shift = shift_left, .rshift = shift_right, \
+                 .max = xmax, .invert = xinvert} }
 #define SOC_SINGLE_EXT_TLV(xname, xreg, xshift, xmax, xinvert,\
          xhandler_get, xhandler_put, tlv_array) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
@@ -206,10 +214,6 @@ void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
                         struct snd_soc_jack_gpio *gpios);
 #endif
 
-/* codec IO */
-#define snd_soc_read(codec, reg) codec->read(codec, reg)
-#define snd_soc_write(codec, reg, value) codec->write(codec, reg, value)
-
 /* codec register bit access */
 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
                                 unsigned short mask, unsigned short value);
@@ -331,6 +335,7 @@ struct snd_soc_codec {
         struct module *owner;
         struct mutex mutex;
         struct device *dev;
+        struct snd_soc_device *socdev;
 
         struct list_head list;
 
@@ -364,6 +369,8 @@ struct snd_soc_codec {
         enum snd_soc_bias_level bias_level;
         enum snd_soc_bias_level suspend_bias_level;
         struct delayed_work delayed_work;
+        struct list_head up_list;
+        struct list_head down_list;
 
         /* codec DAI's */
         struct snd_soc_dai *dai;
@@ -417,6 +424,12 @@ struct snd_soc_dai_link  {
         /* codec/machine specific init - e.g. add machine controls */
         int (*init)(struct snd_soc_codec *codec);
 
+        /* Symmetry requirements */
+        unsigned int symmetric_rates:1;
+
+        /* Symmetry data - only valid if symmetry is being enforced */
+        unsigned int rate;
+
         /* DAI pcm */
         struct snd_pcm *pcm;
 };
@@ -490,6 +503,19 @@ struct soc_enum {
         void *dapm;
 };
 
+/* codec IO */
+static inline unsigned int snd_soc_read(struct snd_soc_codec *codec,
+                                        unsigned int reg)
+{
+        return codec->read(codec, reg);
+}
+
+static inline unsigned int snd_soc_write(struct snd_soc_codec *codec,
+                                         unsigned int reg, unsigned int val)
+{
+        return codec->write(codec, reg, val);
+}
+
 #include <sound/soc-dai.h>
 
 #endif
diff --git a/include/sound/wm9081.h b/include/sound/wm9081.h
new file mode 100644
index 000000000000..e173ddbf6bd4
--- /dev/null
+++ b/include/sound/wm9081.h
@@ -0,0 +1,25 @@
+/*
+ * linux/sound/wm9081.h -- Platform data for WM9081
+ *
+ * Copyright 2009 Wolfson Microelectronics. PLC.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_SND_WM_9081_H
+#define __LINUX_SND_WM_9081_H
+
+struct wm9081_retune_mobile_setting {
+        const char *name;
+        unsigned int rate;
+        u16 config[20];
+};
+
+struct wm9081_retune_mobile_config {
+        struct wm9081_retune_mobile_setting *configs;
+        int num_configs;
+};
+
+#endif
diff --git a/include/trace/block.h b/include/trace/block.h
deleted file mode 100644
index 25b7068b819e..000000000000
--- a/include/trace/block.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef _TRACE_BLOCK_H
-#define _TRACE_BLOCK_H
-
-#include <linux/blkdev.h>
-#include <linux/tracepoint.h>
-
-DECLARE_TRACE(block_rq_abort,
-        TP_PROTO(struct request_queue *q, struct request *rq),
-              TP_ARGS(q, rq));
-
-DECLARE_TRACE(block_rq_insert,
-        TP_PROTO(struct request_queue *q, struct request *rq),
-              TP_ARGS(q, rq));
-
-DECLARE_TRACE(block_rq_issue,
-        TP_PROTO(struct request_queue *q, struct request *rq),
-              TP_ARGS(q, rq));
-
-DECLARE_TRACE(block_rq_requeue,
-        TP_PROTO(struct request_queue *q, struct request *rq),
-              TP_ARGS(q, rq));
-
-DECLARE_TRACE(block_rq_complete,
-        TP_PROTO(struct request_queue *q, struct request *rq),
-              TP_ARGS(q, rq));
-
-DECLARE_TRACE(block_bio_bounce,
-        TP_PROTO(struct request_queue *q, struct bio *bio),
-              TP_ARGS(q, bio));
-
-DECLARE_TRACE(block_bio_complete,
-        TP_PROTO(struct request_queue *q, struct bio *bio),
-              TP_ARGS(q, bio));
-
-DECLARE_TRACE(block_bio_backmerge,
-        TP_PROTO(struct request_queue *q, struct bio *bio),
-              TP_ARGS(q, bio));
-
-DECLARE_TRACE(block_bio_frontmerge,
-        TP_PROTO(struct request_queue *q, struct bio *bio),
-              TP_ARGS(q, bio));
-
-DECLARE_TRACE(block_bio_queue,
-        TP_PROTO(struct request_queue *q, struct bio *bio),
-              TP_ARGS(q, bio));
-
-DECLARE_TRACE(block_getrq,
-        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
-              TP_ARGS(q, bio, rw));
-
-DECLARE_TRACE(block_sleeprq,
-        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
-              TP_ARGS(q, bio, rw));
-
-DECLARE_TRACE(block_plug,
-        TP_PROTO(struct request_queue *q),
-              TP_ARGS(q));
-
-DECLARE_TRACE(block_unplug_timer,
-        TP_PROTO(struct request_queue *q),
-              TP_ARGS(q));
-
-DECLARE_TRACE(block_unplug_io,
-        TP_PROTO(struct request_queue *q),
-              TP_ARGS(q));
-
-DECLARE_TRACE(block_split,
-        TP_PROTO(struct request_queue *q, struct bio *bio, unsigned int pdu),
-              TP_ARGS(q, bio, pdu));
-
-DECLARE_TRACE(block_remap,
-        TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
-                 sector_t from, sector_t to),
-              TP_ARGS(q, bio, dev, from, to));
-
-#endif
diff --git a/include/trace/define_trace.h b/include/trace/define_trace.h
new file mode 100644
index 000000000000..f7a7ae1e8f90
--- /dev/null
+++ b/include/trace/define_trace.h
@@ -0,0 +1,75 @@
+/*
+ * Trace files that want to automate creationg of all tracepoints defined
+ * in their file should include this file. The following are macros that the
+ * trace file may define:
+ *
+ * TRACE_SYSTEM defines the system the tracepoint is for
+ *
+ * TRACE_INCLUDE_FILE if the file name is something other than TRACE_SYSTEM.h
+ *     This macro may be defined to tell define_trace.h what file to include.
+ *     Note, leave off the ".h".
+ *
+ * TRACE_INCLUDE_PATH if the path is something other than core kernel include/trace
+ *     then this macro can define the path to use. Note, the path is relative to
+ *     define_trace.h, not the file including it. Full path names for out of tree
+ *     modules must be used.
+ */
+
+#ifdef CREATE_TRACE_POINTS
+
+/* Prevent recursion */
+#undef CREATE_TRACE_POINTS
+
+#include <linux/stringify.h>
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(name, proto, args, tstruct, assign, print)  \
+        DEFINE_TRACE(name)
+
+#undef DECLARE_TRACE
+#define DECLARE_TRACE(name, proto, args)        \
+        DEFINE_TRACE(name)
+
+#undef TRACE_INCLUDE
+#undef __TRACE_INCLUDE
+
+#ifndef TRACE_INCLUDE_FILE
+# define TRACE_INCLUDE_FILE TRACE_SYSTEM
+# define UNDEF_TRACE_INCLUDE_FILE
+#endif
+
+#ifndef TRACE_INCLUDE_PATH
+# define __TRACE_INCLUDE(system) <trace/events/system.h>
+# define UNDEF_TRACE_INCLUDE_PATH
+#else
+# define __TRACE_INCLUDE(system) __stringify(TRACE_INCLUDE_PATH/system.h)
+#endif
+
+# define TRACE_INCLUDE(system) __TRACE_INCLUDE(system)
+
+/* Let the trace headers be reread */
+#define TRACE_HEADER_MULTI_READ
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+#ifdef CONFIG_EVENT_TRACING
+#include <trace/ftrace.h>
+#endif
+
+#undef TRACE_HEADER_MULTI_READ
+
+/* Only undef what we defined in this file */
+#ifdef UNDEF_TRACE_INCLUDE_FILE
+# undef TRACE_INCLUDE_FILE
+# undef UNDEF_TRACE_INCLUDE_FILE
+#endif
+
+#ifdef UNDEF_TRACE_INCLUDE_PATH
+# undef TRACE_INCLUDE_PATH
+# undef UNDEF_TRACE_INCLUDE_PATH
+#endif
+
+/* We may be processing more files */
+#define CREATE_TRACE_POINTS
+
+#endif /* CREATE_TRACE_POINTS */
diff --git a/include/trace/events/block.h b/include/trace/events/block.h
new file mode 100644
index 000000000000..9a74b468a229
--- /dev/null
+++ b/include/trace/events/block.h
@@ -0,0 +1,493 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM block
+
+#if !defined(_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_BLOCK_H
+
+#include <linux/blktrace_api.h>
+#include <linux/blkdev.h>
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(block_rq_abort,
+
+        TP_PROTO(struct request_queue *q, struct request *rq),
+
+        TP_ARGS(q, rq),
+
+        TP_STRUCT__entry(
+                __field(  dev_t,        dev                     )
+                __field(  sector_t,     sector                  )
+                __field(  unsigned int, nr_sector               )
+                __field(  int,          errors                  )
+                __array(  char,         rwbs,   6               )
+                __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
+        ),
+
+        TP_fast_assign(
+                __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->errors    = rq->errors;
+
+                blk_fill_rwbs_rq(__entry->rwbs, rq);
+                blk_dump_cmd(__get_str(cmd), rq);
+        ),
+
+        TP_printk("%d,%d %s (%s) %llu + %u [%d]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->rwbs, __get_str(cmd),
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->errors)
+);
+
+TRACE_EVENT(block_rq_insert,
+
+        TP_PROTO(struct request_queue *q, struct request *rq),
+
+        TP_ARGS(q, rq),
+
+        TP_STRUCT__entry(
+                __field(  dev_t,        dev                     )
+                __field(  sector_t,     sector                  )
+                __field(  unsigned int, nr_sector               )
+                __field(  unsigned int, bytes                   )
+                __array(  char,         rwbs,   6               )
+                __array(  char,         comm,   TASK_COMM_LEN   )
+                __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
+        ),
+
+        TP_fast_assign(
+                __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->bytes     = blk_pc_request(rq) ? blk_rq_bytes(rq) : 0;
+
+                blk_fill_rwbs_rq(__entry->rwbs, rq);
+                blk_dump_cmd(__get_str(cmd), rq);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %u (%s) %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->rwbs, __entry->bytes, __get_str(cmd),
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
+);
+
+TRACE_EVENT(block_rq_issue,
+
+        TP_PROTO(struct request_queue *q, struct request *rq),
+
+        TP_ARGS(q, rq),
+
+        TP_STRUCT__entry(
+                __field(  dev_t,        dev                     )
+                __field(  sector_t,     sector                  )
+                __field(  unsigned int, nr_sector               )
+                __field(  unsigned int, bytes                   )
+                __array(  char,         rwbs,   6               )
+                __array(  char,         comm,   TASK_COMM_LEN   )
+                __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
+        ),
+
+        TP_fast_assign(
+                __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->bytes     = blk_pc_request(rq) ? blk_rq_bytes(rq) : 0;
+
+                blk_fill_rwbs_rq(__entry->rwbs, rq);
+                blk_dump_cmd(__get_str(cmd), rq);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %u (%s) %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->rwbs, __entry->bytes, __get_str(cmd),
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
+);
+
+TRACE_EVENT(block_rq_requeue,
+
+        TP_PROTO(struct request_queue *q, struct request *rq),
+
+        TP_ARGS(q, rq),
+
+        TP_STRUCT__entry(
+                __field(  dev_t,        dev                     )
+                __field(  sector_t,     sector                  )
+                __field(  unsigned int, nr_sector               )
+                __field(  int,          errors                  )
+                __array(  char,         rwbs,   6               )
+                __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
+        ),
+
+        TP_fast_assign(
+                __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->errors    = rq->errors;
+
+                blk_fill_rwbs_rq(__entry->rwbs, rq);
+                blk_dump_cmd(__get_str(cmd), rq);
+        ),
+
+        TP_printk("%d,%d %s (%s) %llu + %u [%d]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->rwbs, __get_str(cmd),
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->errors)
+);
+
+TRACE_EVENT(block_rq_complete,
+
+        TP_PROTO(struct request_queue *q, struct request *rq),
+
+        TP_ARGS(q, rq),
+
+        TP_STRUCT__entry(
+                __field(  dev_t,        dev                     )
+                __field(  sector_t,     sector                  )
+                __field(  unsigned int, nr_sector               )
+                __field(  int,          errors                  )
+                __array(  char,         rwbs,   6               )
+                __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
+        ),
+
+        TP_fast_assign(
+                __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->errors    = rq->errors;
+
+                blk_fill_rwbs_rq(__entry->rwbs, rq);
+                blk_dump_cmd(__get_str(cmd), rq);
+        ),
+
+        TP_printk("%d,%d %s (%s) %llu + %u [%d]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->rwbs, __get_str(cmd),
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->errors)
+);
+TRACE_EVENT(block_bio_bounce,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+
+        TP_ARGS(q, bio),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev                     )
+                __field( sector_t,      sector                  )
+                __field( unsigned int,  nr_sector               )
+                __array( char,          rwbs,   6               )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->sector         = bio->bi_sector;
+                __entry->nr_sector      = bio->bi_size >> 9;
+                blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
+);
+
+TRACE_EVENT(block_bio_complete,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+
+        TP_ARGS(q, bio),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev             )
+                __field( sector_t,      sector          )
+                __field( unsigned,      nr_sector       )
+                __field( int,           error           )
+                __array( char,          rwbs,   6       )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->sector         = bio->bi_sector;
+                __entry->nr_sector      = bio->bi_size >> 9;
+                blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u [%d]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->error)
+);
+
+TRACE_EVENT(block_bio_backmerge,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+
+        TP_ARGS(q, bio),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev                     )
+                __field( sector_t,      sector                  )
+                __field( unsigned int,  nr_sector               )
+                __array( char,          rwbs,   6               )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->sector         = bio->bi_sector;
+                __entry->nr_sector      = bio->bi_size >> 9;
+                blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
+);
+
+TRACE_EVENT(block_bio_frontmerge,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+
+        TP_ARGS(q, bio),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev                     )
+                __field( sector_t,      sector                  )
+                __field( unsigned,      nr_sector               )
+                __array( char,          rwbs,   6               )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->sector         = bio->bi_sector;
+                __entry->nr_sector      = bio->bi_size >> 9;
+                blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
+);
+
+TRACE_EVENT(block_bio_queue,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio),
+
+        TP_ARGS(q, bio),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev                     )
+                __field( sector_t,      sector                  )
+                __field( unsigned int,  nr_sector               )
+                __array( char,          rwbs,   6               )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->sector         = bio->bi_sector;
+                __entry->nr_sector      = bio->bi_size >> 9;
+                blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
+);
+
+TRACE_EVENT(block_getrq,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
+
+        TP_ARGS(q, bio, rw),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev                     )
+                __field( sector_t,      sector                  )
+                __field( unsigned int,  nr_sector               )
+                __array( char,          rwbs,   6               )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio ? bio->bi_bdev->bd_dev : 0;
+                __entry->sector         = bio ? bio->bi_sector : 0;
+                __entry->nr_sector      = bio ? bio->bi_size >> 9 : 0;
+                blk_fill_rwbs(__entry->rwbs,
+                              bio ? bio->bi_rw : 0, __entry->nr_sector);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
+);
+
+TRACE_EVENT(block_sleeprq,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
+
+        TP_ARGS(q, bio, rw),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev                     )
+                __field( sector_t,      sector                  )
+                __field( unsigned int,  nr_sector               )
+                __array( char,          rwbs,   6               )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio ? bio->bi_bdev->bd_dev : 0;
+                __entry->sector         = bio ? bio->bi_sector : 0;
+                __entry->nr_sector      = bio ? bio->bi_size >> 9 : 0;
+                blk_fill_rwbs(__entry->rwbs,
+                            bio ? bio->bi_rw : 0, __entry->nr_sector);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector, __entry->comm)
+);
+
+TRACE_EVENT(block_plug,
+
+        TP_PROTO(struct request_queue *q),
+
+        TP_ARGS(q),
+
+        TP_STRUCT__entry(
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("[%s]", __entry->comm)
+);
+
+TRACE_EVENT(block_unplug_timer,
+
+        TP_PROTO(struct request_queue *q),
+
+        TP_ARGS(q),
+
+        TP_STRUCT__entry(
+                __field( int,           nr_rq                   )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->nr_rq  = q->rq.count[READ] + q->rq.count[WRITE];
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
+);
+
+TRACE_EVENT(block_unplug_io,
+
+        TP_PROTO(struct request_queue *q),
+
+        TP_ARGS(q),
+
+        TP_STRUCT__entry(
+                __field( int,           nr_rq                   )
+                __array( char,          comm,   TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->nr_rq  = q->rq.count[READ] + q->rq.count[WRITE];
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
+);
+
+TRACE_EVENT(block_split,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio,
+                 unsigned int new_sector),
+
+        TP_ARGS(q, bio, new_sector),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev                             )
+                __field( sector_t,      sector                          )
+                __field( sector_t,      new_sector                      )
+                __array( char,          rwbs,           6               )
+                __array( char,          comm,           TASK_COMM_LEN   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->sector         = bio->bi_sector;
+                __entry->new_sector     = new_sector;
+                blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
+                memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
+        ),
+
+        TP_printk("%d,%d %s %llu / %llu [%s]",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  (unsigned long long)__entry->new_sector,
+                  __entry->comm)
+);
+
+TRACE_EVENT(block_remap,
+
+        TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
+                 sector_t from),
+
+        TP_ARGS(q, bio, dev, from),
+
+        TP_STRUCT__entry(
+                __field( dev_t,         dev             )
+                __field( sector_t,      sector          )
+                __field( unsigned int,  nr_sector       )
+                __field( dev_t,         old_dev         )
+                __field( sector_t,      old_sector      )
+                __array( char,          rwbs,   6       )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = bio->bi_bdev->bd_dev;
+                __entry->sector         = bio->bi_sector;
+                __entry->nr_sector      = bio->bi_size >> 9;
+                __entry->old_dev        = dev;
+                __entry->old_sector     = from;
+                blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
+        ),
+
+        TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
+                  MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
+                  (unsigned long long)__entry->sector,
+                  __entry->nr_sector,
+                  MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
+                  (unsigned long long)__entry->old_sector)
+);
+
+#endif /* _TRACE_BLOCK_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
+
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
new file mode 100644
index 000000000000..7d8b5bc74185
--- /dev/null
+++ b/include/trace/events/ext4.h
@@ -0,0 +1,677 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM ext4
+
+#if !defined(_TRACE_EXT4_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_EXT4_H
+
+#include <linux/writeback.h>
+#include "../../../fs/ext4/ext4.h"
+#include "../../../fs/ext4/mballoc.h"
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(ext4_free_inode,
+        TP_PROTO(struct inode *inode),
+
+        TP_ARGS(inode),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        umode_t, mode                   )
+                __field(        uid_t,  uid                     )
+                __field(        gid_t,  gid                     )
+                __field(        blkcnt_t, blocks                )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->mode   = inode->i_mode;
+                __entry->uid    = inode->i_uid;
+                __entry->gid    = inode->i_gid;
+                __entry->blocks = inode->i_blocks;
+        ),
+
+        TP_printk("dev %s ino %lu mode %d uid %u gid %u blocks %llu",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->mode,
+                  __entry->uid, __entry->gid,
+                  (unsigned long long) __entry->blocks)
+);
+
+TRACE_EVENT(ext4_request_inode,
+        TP_PROTO(struct inode *dir, int mode),
+
+        TP_ARGS(dir, mode),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  dir                     )
+                __field(        umode_t, mode                   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = dir->i_sb->s_dev;
+                __entry->dir    = dir->i_ino;
+                __entry->mode   = mode;
+        ),
+
+        TP_printk("dev %s dir %lu mode %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->dir, __entry->mode)
+);
+
+TRACE_EVENT(ext4_allocate_inode,
+        TP_PROTO(struct inode *inode, struct inode *dir, int mode),
+
+        TP_ARGS(inode, dir, mode),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        ino_t,  dir                     )
+                __field(        umode_t, mode                   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->dir    = dir->i_ino;
+                __entry->mode   = mode;
+        ),
+
+        TP_printk("dev %s ino %lu dir %lu mode %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->dir, __entry->mode)
+);
+
+TRACE_EVENT(ext4_write_begin,
+
+        TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
+                 unsigned int flags),
+
+        TP_ARGS(inode, pos, len, flags),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        loff_t, pos                     )
+                __field(        unsigned int, len               )
+                __field(        unsigned int, flags             )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->pos    = pos;
+                __entry->len    = len;
+                __entry->flags  = flags;
+        ),
+
+        TP_printk("dev %s ino %lu pos %llu len %u flags %u",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
+                  __entry->flags)
+);
+
+TRACE_EVENT(ext4_ordered_write_end,
+        TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
+                        unsigned int copied),
+
+        TP_ARGS(inode, pos, len, copied),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        loff_t, pos                     )
+                __field(        unsigned int, len               )
+                __field(        unsigned int, copied            )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->pos    = pos;
+                __entry->len    = len;
+                __entry->copied = copied;
+        ),
+
+        TP_printk("dev %s ino %lu pos %llu len %u copied %u",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
+                  __entry->copied)
+);
+
+TRACE_EVENT(ext4_writeback_write_end,
+        TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
+                 unsigned int copied),
+
+        TP_ARGS(inode, pos, len, copied),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        loff_t, pos                     )
+                __field(        unsigned int, len               )
+                __field(        unsigned int, copied            )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->pos    = pos;
+                __entry->len    = len;
+                __entry->copied = copied;
+        ),
+
+        TP_printk("dev %s ino %lu pos %llu len %u copied %u",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
+                  __entry->copied)
+);
+
+TRACE_EVENT(ext4_journalled_write_end,
+        TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
+                 unsigned int copied),
+        TP_ARGS(inode, pos, len, copied),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        loff_t, pos                     )
+                __field(        unsigned int, len               )
+                __field(        unsigned int, copied            )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->pos    = pos;
+                __entry->len    = len;
+                __entry->copied = copied;
+        ),
+
+        TP_printk("dev %s ino %lu pos %llu len %u copied %u",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
+                  __entry->copied)
+);
+
+TRACE_EVENT(ext4_writepage,
+        TP_PROTO(struct inode *inode, struct page *page),
+
+        TP_ARGS(inode, page),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        pgoff_t, index                  )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->index  = page->index;
+        ),
+
+        TP_printk("dev %s ino %lu page_index %lu",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->index)
+);
+
+TRACE_EVENT(ext4_da_writepages,
+        TP_PROTO(struct inode *inode, struct writeback_control *wbc),
+
+        TP_ARGS(inode, wbc),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        long,   nr_to_write             )
+                __field(        long,   pages_skipped           )
+                __field(        loff_t, range_start             )
+                __field(        loff_t, range_end               )
+                __field(        char,   nonblocking             )
+                __field(        char,   for_kupdate             )
+                __field(        char,   for_reclaim             )
+                __field(        char,   for_writepages          )
+                __field(        char,   range_cyclic            )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->ino            = inode->i_ino;
+                __entry->nr_to_write    = wbc->nr_to_write;
+                __entry->pages_skipped  = wbc->pages_skipped;
+                __entry->range_start    = wbc->range_start;
+                __entry->range_end      = wbc->range_end;
+                __entry->nonblocking    = wbc->nonblocking;
+                __entry->for_kupdate    = wbc->for_kupdate;
+                __entry->for_reclaim    = wbc->for_reclaim;
+                __entry->for_writepages = wbc->for_writepages;
+                __entry->range_cyclic   = wbc->range_cyclic;
+        ),
+
+        TP_printk("dev %s ino %lu nr_t_write %ld pages_skipped %ld range_start %llu range_end %llu nonblocking %d for_kupdate %d for_reclaim %d for_writepages %d range_cyclic %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->nr_to_write,
+                  __entry->pages_skipped, __entry->range_start,
+                  __entry->range_end, __entry->nonblocking,
+                  __entry->for_kupdate, __entry->for_reclaim,
+                  __entry->for_writepages, __entry->range_cyclic)
+);
+
+TRACE_EVENT(ext4_da_writepages_result,
+        TP_PROTO(struct inode *inode, struct writeback_control *wbc,
+                        int ret, int pages_written),
+
+        TP_ARGS(inode, wbc, ret, pages_written),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        int,    ret                     )
+                __field(        int,    pages_written           )
+                __field(        long,   pages_skipped           )
+                __field(        char,   encountered_congestion  )
+                __field(        char,   more_io                 )       
+                __field(        char,   no_nrwrite_index_update )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->ino            = inode->i_ino;
+                __entry->ret            = ret;
+                __entry->pages_written  = pages_written;
+                __entry->pages_skipped  = wbc->pages_skipped;
+                __entry->encountered_congestion = wbc->encountered_congestion;
+                __entry->more_io        = wbc->more_io;
+                __entry->no_nrwrite_index_update = wbc->no_nrwrite_index_update;
+        ),
+
+        TP_printk("dev %s ino %lu ret %d pages_written %d pages_skipped %ld congestion %d more_io %d no_nrwrite_index_update %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->ret,
+                  __entry->pages_written, __entry->pages_skipped,
+                  __entry->encountered_congestion, __entry->more_io,
+                  __entry->no_nrwrite_index_update)
+);
+
+TRACE_EVENT(ext4_da_write_begin,
+        TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
+                        unsigned int flags),
+
+        TP_ARGS(inode, pos, len, flags),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        loff_t, pos                     )
+                __field(        unsigned int, len               )
+                __field(        unsigned int, flags             )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->pos    = pos;
+                __entry->len    = len;
+                __entry->flags  = flags;
+        ),
+
+        TP_printk("dev %s ino %lu pos %llu len %u flags %u",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
+                  __entry->flags)
+);
+
+TRACE_EVENT(ext4_da_write_end,
+        TP_PROTO(struct inode *inode, loff_t pos, unsigned int len,
+                        unsigned int copied),
+
+        TP_ARGS(inode, pos, len, copied),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        loff_t, pos                     )
+                __field(        unsigned int, len               )
+                __field(        unsigned int, copied            )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+                __entry->pos    = pos;
+                __entry->len    = len;
+                __entry->copied = copied;
+        ),
+
+        TP_printk("dev %s ino %lu pos %llu len %u copied %u",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pos, __entry->len,
+                  __entry->copied)
+);
+
+TRACE_EVENT(ext4_discard_blocks,
+        TP_PROTO(struct super_block *sb, unsigned long long blk,
+                        unsigned long long count),
+
+        TP_ARGS(sb, blk, count),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        __u64,  blk                     )
+                __field(        __u64,  count                   )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = sb->s_dev;
+                __entry->blk    = blk;
+                __entry->count  = count;
+        ),
+
+        TP_printk("dev %s blk %llu count %llu",
+                  jbd2_dev_to_name(__entry->dev), __entry->blk, __entry->count)
+);
+
+TRACE_EVENT(ext4_mb_new_inode_pa,
+        TP_PROTO(struct ext4_allocation_context *ac,
+                 struct ext4_prealloc_space *pa),
+
+        TP_ARGS(ac, pa),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        __u64,  pa_pstart               )
+                __field(        __u32,  pa_len                  )
+                __field(        __u64,  pa_lstart               )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = ac->ac_sb->s_dev;
+                __entry->ino            = ac->ac_inode->i_ino;
+                __entry->pa_pstart      = pa->pa_pstart;
+                __entry->pa_len         = pa->pa_len;
+                __entry->pa_lstart      = pa->pa_lstart;
+        ),
+
+        TP_printk("dev %s ino %lu pstart %llu len %u lstart %llu",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pa_pstart,
+                  __entry->pa_len, __entry->pa_lstart)
+);
+
+TRACE_EVENT(ext4_mb_new_group_pa,
+        TP_PROTO(struct ext4_allocation_context *ac,
+                 struct ext4_prealloc_space *pa),
+
+        TP_ARGS(ac, pa),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        __u64,  pa_pstart               )
+                __field(        __u32,  pa_len                  )
+                __field(        __u64,  pa_lstart               )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = ac->ac_sb->s_dev;
+                __entry->ino            = ac->ac_inode->i_ino;
+                __entry->pa_pstart      = pa->pa_pstart;
+                __entry->pa_len         = pa->pa_len;
+                __entry->pa_lstart      = pa->pa_lstart;
+        ),
+
+        TP_printk("dev %s ino %lu pstart %llu len %u lstart %llu",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->pa_pstart,
+                  __entry->pa_len, __entry->pa_lstart)
+);
+
+TRACE_EVENT(ext4_mb_release_inode_pa,
+        TP_PROTO(struct ext4_allocation_context *ac,
+                 struct ext4_prealloc_space *pa,
+                 unsigned long long block, unsigned int count),
+
+        TP_ARGS(ac, pa, block, count),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        __u64,  block                   )
+                __field(        __u32,  count                   )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = ac->ac_sb->s_dev;
+                __entry->ino            = ac->ac_inode->i_ino;
+                __entry->block          = block;
+                __entry->count          = count;
+        ),
+
+        TP_printk("dev %s ino %lu block %llu count %u",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->block,
+                  __entry->count)
+);
+
+TRACE_EVENT(ext4_mb_release_group_pa,
+        TP_PROTO(struct ext4_allocation_context *ac,
+                 struct ext4_prealloc_space *pa),
+
+        TP_ARGS(ac, pa),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        __u64,  pa_pstart               )
+                __field(        __u32,  pa_len                  )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = ac->ac_sb->s_dev;
+                __entry->ino            = ac->ac_inode->i_ino;
+                __entry->pa_pstart      = pa->pa_pstart;
+                __entry->pa_len         = pa->pa_len;
+        ),
+
+        TP_printk("dev %s pstart %llu len %u",
+                  jbd2_dev_to_name(__entry->dev), __entry->pa_pstart, __entry->pa_len)
+);
+
+TRACE_EVENT(ext4_discard_preallocations,
+        TP_PROTO(struct inode *inode),
+
+        TP_ARGS(inode),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+        ),
+
+        TP_printk("dev %s ino %lu",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino)
+);
+
+TRACE_EVENT(ext4_mb_discard_preallocations,
+        TP_PROTO(struct super_block *sb, int needed),
+
+        TP_ARGS(sb, needed),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        int,    needed                  )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = sb->s_dev;
+                __entry->needed = needed;
+        ),
+
+        TP_printk("dev %s needed %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->needed)
+);
+
+TRACE_EVENT(ext4_request_blocks,
+        TP_PROTO(struct ext4_allocation_request *ar),
+
+        TP_ARGS(ar),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        unsigned int, flags             )
+                __field(        unsigned int, len               )
+                __field(        __u64,  logical                 )
+                __field(        __u64,  goal                    )
+                __field(        __u64,  lleft                   )
+                __field(        __u64,  lright                  )
+                __field(        __u64,  pleft                   )
+                __field(        __u64,  pright                  )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = ar->inode->i_sb->s_dev;
+                __entry->ino    = ar->inode->i_ino;
+                __entry->flags  = ar->flags;
+                __entry->len    = ar->len;
+                __entry->logical = ar->logical;
+                __entry->goal   = ar->goal;
+                __entry->lleft  = ar->lleft;
+                __entry->lright = ar->lright;
+                __entry->pleft  = ar->pleft;
+                __entry->pright = ar->pright;
+        ),
+
+        TP_printk("dev %s ino %lu flags %u len %u lblk %llu goal %llu lleft %llu lright %llu pleft %llu pright %llu ",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->flags,
+                  __entry->len,
+                  (unsigned long long) __entry->logical,
+                  (unsigned long long) __entry->goal,
+                  (unsigned long long) __entry->lleft,
+                  (unsigned long long) __entry->lright,
+                  (unsigned long long) __entry->pleft,
+                  (unsigned long long) __entry->pright)
+);
+
+TRACE_EVENT(ext4_allocate_blocks,
+        TP_PROTO(struct ext4_allocation_request *ar, unsigned long long block),
+
+        TP_ARGS(ar, block),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        __u64,  block                   )
+                __field(        unsigned int, flags             )
+                __field(        unsigned int, len               )
+                __field(        __u64,  logical                 )
+                __field(        __u64,  goal                    )
+                __field(        __u64,  lleft                   )
+                __field(        __u64,  lright                  )
+                __field(        __u64,  pleft                   )
+                __field(        __u64,  pright                  )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = ar->inode->i_sb->s_dev;
+                __entry->ino    = ar->inode->i_ino;
+                __entry->block  = block;
+                __entry->flags  = ar->flags;
+                __entry->len    = ar->len;
+                __entry->logical = ar->logical;
+                __entry->goal   = ar->goal;
+                __entry->lleft  = ar->lleft;
+                __entry->lright = ar->lright;
+                __entry->pleft  = ar->pleft;
+                __entry->pright = ar->pright;
+        ),
+
+        TP_printk("dev %s ino %lu flags %u len %u block %llu lblk %llu goal %llu lleft %llu lright %llu pleft %llu pright %llu ",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->flags,
+                  __entry->len, __entry->block,
+                  (unsigned long long) __entry->logical,
+                  (unsigned long long) __entry->goal,
+                  (unsigned long long) __entry->lleft,
+                  (unsigned long long) __entry->lright,
+                  (unsigned long long) __entry->pleft,
+                  (unsigned long long) __entry->pright)
+);
+
+TRACE_EVENT(ext4_free_blocks,
+        TP_PROTO(struct inode *inode, __u64 block, unsigned long count,
+                        int metadata),
+
+        TP_ARGS(inode, block, count, metadata),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        __u64,  block                   )
+                __field(        unsigned long,  count           )
+                __field(        int,    metadata                )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->ino            = inode->i_ino;
+                __entry->block          = block;
+                __entry->count          = count;
+                __entry->metadata       = metadata;
+        ),
+
+        TP_printk("dev %s ino %lu block %llu count %lu metadata %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->block,
+                  __entry->count, __entry->metadata)
+);
+
+TRACE_EVENT(ext4_sync_file,
+        TP_PROTO(struct file *file, struct dentry *dentry, int datasync),
+
+        TP_ARGS(file, dentry, datasync),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        ino_t,  parent                  )
+                __field(        int,    datasync                )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = dentry->d_inode->i_sb->s_dev;
+                __entry->ino            = dentry->d_inode->i_ino;
+                __entry->datasync       = datasync;
+                __entry->parent         = dentry->d_parent->d_inode->i_ino;
+        ),
+
+        TP_printk("dev %s ino %ld parent %ld datasync %d ",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino, __entry->parent,
+                  __entry->datasync)
+);
+
+TRACE_EVENT(ext4_sync_fs,
+        TP_PROTO(struct super_block *sb, int wait),
+
+        TP_ARGS(sb, wait),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        int,    wait                    )
+
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = sb->s_dev;
+                __entry->wait   = wait;
+        ),
+
+        TP_printk("dev %s wait %d", jbd2_dev_to_name(__entry->dev),
+                  __entry->wait)
+);
+
+#endif /* _TRACE_EXT4_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/irq.h b/include/trace/events/irq.h
new file mode 100644
index 000000000000..1cb0c3aa11e6
--- /dev/null
+++ b/include/trace/events/irq.h
@@ -0,0 +1,145 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM irq
+
+#if !defined(_TRACE_IRQ_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_IRQ_H
+
+#include <linux/tracepoint.h>
+#include <linux/interrupt.h>
+
+#define softirq_name(sirq) { sirq##_SOFTIRQ, #sirq }
+#define show_softirq_name(val)                  \
+        __print_symbolic(val,                   \
+                         softirq_name(HI),      \
+                         softirq_name(TIMER),   \
+                         softirq_name(NET_TX),  \
+                         softirq_name(NET_RX),  \
+                         softirq_name(BLOCK),   \
+                         softirq_name(TASKLET), \
+                         softirq_name(SCHED),   \
+                         softirq_name(HRTIMER), \
+                         softirq_name(RCU))
+
+/**
+ * irq_handler_entry - called immediately before the irq action handler
+ * @irq: irq number
+ * @action: pointer to struct irqaction
+ *
+ * The struct irqaction pointed to by @action contains various
+ * information about the handler, including the device name,
+ * @action->name, and the device id, @action->dev_id. When used in
+ * conjunction with the irq_handler_exit tracepoint, we can figure
+ * out irq handler latencies.
+ */
+TRACE_EVENT(irq_handler_entry,
+
+        TP_PROTO(int irq, struct irqaction *action),
+
+        TP_ARGS(irq, action),
+
+        TP_STRUCT__entry(
+                __field(        int,    irq             )
+                __string(       name,   action->name    )
+        ),
+
+        TP_fast_assign(
+                __entry->irq = irq;
+                __assign_str(name, action->name);
+        ),
+
+        TP_printk("irq=%d handler=%s", __entry->irq, __get_str(name))
+);
+
+/**
+ * irq_handler_exit - called immediately after the irq action handler returns
+ * @irq: irq number
+ * @action: pointer to struct irqaction
+ * @ret: return value
+ *
+ * If the @ret value is set to IRQ_HANDLED, then we know that the corresponding
+ * @action->handler scuccessully handled this irq. Otherwise, the irq might be
+ * a shared irq line, or the irq was not handled successfully. Can be used in
+ * conjunction with the irq_handler_entry to understand irq handler latencies.
+ */
+TRACE_EVENT(irq_handler_exit,
+
+        TP_PROTO(int irq, struct irqaction *action, int ret),
+
+        TP_ARGS(irq, action, ret),
+
+        TP_STRUCT__entry(
+                __field(        int,    irq     )
+                __field(        int,    ret     )
+        ),
+
+        TP_fast_assign(
+                __entry->irq    = irq;
+                __entry->ret    = ret;
+        ),
+
+        TP_printk("irq=%d return=%s",
+                  __entry->irq, __entry->ret ? "handled" : "unhandled")
+);
+
+/**
+ * softirq_entry - called immediately before the softirq handler
+ * @h: pointer to struct softirq_action
+ * @vec: pointer to first struct softirq_action in softirq_vec array
+ *
+ * The @h parameter, contains a pointer to the struct softirq_action
+ * which has a pointer to the action handler that is called. By subtracting
+ * the @vec pointer from the @h pointer, we can determine the softirq
+ * number. Also, when used in combination with the softirq_exit tracepoint
+ * we can determine the softirq latency.
+ */
+TRACE_EVENT(softirq_entry,
+
+        TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
+
+        TP_ARGS(h, vec),
+
+        TP_STRUCT__entry(
+                __field(        int,    vec                     )
+        ),
+
+        TP_fast_assign(
+                __entry->vec = (int)(h - vec);
+        ),
+
+        TP_printk("softirq=%d action=%s", __entry->vec,
+                  show_softirq_name(__entry->vec))
+);
+
+/**
+ * softirq_exit - called immediately after the softirq handler returns
+ * @h: pointer to struct softirq_action
+ * @vec: pointer to first struct softirq_action in softirq_vec array
+ *
+ * The @h parameter contains a pointer to the struct softirq_action
+ * that has handled the softirq. By subtracting the @vec pointer from
+ * the @h pointer, we can determine the softirq number. Also, when used in
+ * combination with the softirq_entry tracepoint we can determine the softirq
+ * latency.
+ */
+TRACE_EVENT(softirq_exit,
+
+        TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
+
+        TP_ARGS(h, vec),
+
+        TP_STRUCT__entry(
+                __field(        int,    vec                     )
+        ),
+
+        TP_fast_assign(
+                __entry->vec = (int)(h - vec);
+        ),
+
+        TP_printk("softirq=%d action=%s", __entry->vec,
+                  show_softirq_name(__entry->vec))
+);
+
+#endif /*  _TRACE_IRQ_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/jbd2.h b/include/trace/events/jbd2.h
new file mode 100644
index 000000000000..10813fa0c8d0
--- /dev/null
+++ b/include/trace/events/jbd2.h
@@ -0,0 +1,168 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM jbd2
+
+#if !defined(_TRACE_JBD2_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_JBD2_H
+
+#include <linux/jbd2.h>
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(jbd2_checkpoint,
+
+        TP_PROTO(journal_t *journal, int result),
+
+        TP_ARGS(journal, result),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        int,    result                  )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = journal->j_fs_dev->bd_dev;
+                __entry->result         = result;
+        ),
+
+        TP_printk("dev %s result %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->result)
+);
+
+TRACE_EVENT(jbd2_start_commit,
+
+        TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
+
+        TP_ARGS(journal, commit_transaction),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        char,   sync_commit               )
+                __field(        int,    transaction               )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = journal->j_fs_dev->bd_dev;
+                __entry->sync_commit = commit_transaction->t_synchronous_commit;
+                __entry->transaction    = commit_transaction->t_tid;
+        ),
+
+        TP_printk("dev %s transaction %d sync %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->transaction,
+                  __entry->sync_commit)
+);
+
+TRACE_EVENT(jbd2_commit_locking,
+
+        TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
+
+        TP_ARGS(journal, commit_transaction),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        char,   sync_commit               )
+                __field(        int,    transaction               )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = journal->j_fs_dev->bd_dev;
+                __entry->sync_commit = commit_transaction->t_synchronous_commit;
+                __entry->transaction    = commit_transaction->t_tid;
+        ),
+
+        TP_printk("dev %s transaction %d sync %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->transaction,
+                  __entry->sync_commit)
+);
+
+TRACE_EVENT(jbd2_commit_flushing,
+
+        TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
+
+        TP_ARGS(journal, commit_transaction),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        char,   sync_commit               )
+                __field(        int,    transaction               )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = journal->j_fs_dev->bd_dev;
+                __entry->sync_commit = commit_transaction->t_synchronous_commit;
+                __entry->transaction    = commit_transaction->t_tid;
+        ),
+
+        TP_printk("dev %s transaction %d sync %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->transaction,
+                  __entry->sync_commit)
+);
+
+TRACE_EVENT(jbd2_commit_logging,
+
+        TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
+
+        TP_ARGS(journal, commit_transaction),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        char,   sync_commit               )
+                __field(        int,    transaction               )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = journal->j_fs_dev->bd_dev;
+                __entry->sync_commit = commit_transaction->t_synchronous_commit;
+                __entry->transaction    = commit_transaction->t_tid;
+        ),
+
+        TP_printk("dev %s transaction %d sync %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->transaction,
+                  __entry->sync_commit)
+);
+
+TRACE_EVENT(jbd2_end_commit,
+        TP_PROTO(journal_t *journal, transaction_t *commit_transaction),
+
+        TP_ARGS(journal, commit_transaction),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        char,   sync_commit               )
+                __field(        int,    transaction               )
+                __field(        int,    head                      )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = journal->j_fs_dev->bd_dev;
+                __entry->sync_commit = commit_transaction->t_synchronous_commit;
+                __entry->transaction    = commit_transaction->t_tid;
+                __entry->head           = journal->j_tail_sequence;
+        ),
+
+        TP_printk("dev %s transaction %d sync %d head %d",
+                  jbd2_dev_to_name(__entry->dev), __entry->transaction,
+                  __entry->sync_commit, __entry->head)
+);
+
+TRACE_EVENT(jbd2_submit_inode_data,
+        TP_PROTO(struct inode *inode),
+
+        TP_ARGS(inode),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+        ),
+
+        TP_fast_assign(
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->ino    = inode->i_ino;
+        ),
+
+        TP_printk("dev %s ino %lu",
+                  jbd2_dev_to_name(__entry->dev), __entry->ino)
+);
+
+#endif /* _TRACE_JBD2_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/kmem.h b/include/trace/events/kmem.h
new file mode 100644
index 000000000000..1493c541f9c4
--- /dev/null
+++ b/include/trace/events/kmem.h
@@ -0,0 +1,231 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM kmem
+
+#if !defined(_TRACE_KMEM_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_KMEM_H
+
+#include <linux/types.h>
+#include <linux/tracepoint.h>
+
+/*
+ * The order of these masks is important. Matching masks will be seen
+ * first and the left over flags will end up showing by themselves.
+ *
+ * For example, if we have GFP_KERNEL before GFP_USER we wil get:
+ *
+ *  GFP_KERNEL|GFP_HARDWALL
+ *
+ * Thus most bits set go first.
+ */
+#define show_gfp_flags(flags)                                           \
+        (flags) ? __print_flags(flags, "|",                             \
+        {(unsigned long)GFP_HIGHUSER_MOVABLE,   "GFP_HIGHUSER_MOVABLE"}, \
+        {(unsigned long)GFP_HIGHUSER,           "GFP_HIGHUSER"},        \
+        {(unsigned long)GFP_USER,               "GFP_USER"},            \
+        {(unsigned long)GFP_TEMPORARY,          "GFP_TEMPORARY"},       \
+        {(unsigned long)GFP_KERNEL,             "GFP_KERNEL"},          \
+        {(unsigned long)GFP_NOFS,               "GFP_NOFS"},            \
+        {(unsigned long)GFP_ATOMIC,             "GFP_ATOMIC"},          \
+        {(unsigned long)GFP_NOIO,               "GFP_NOIO"},            \
+        {(unsigned long)__GFP_HIGH,             "GFP_HIGH"},            \
+        {(unsigned long)__GFP_WAIT,             "GFP_WAIT"},            \
+        {(unsigned long)__GFP_IO,               "GFP_IO"},              \
+        {(unsigned long)__GFP_COLD,             "GFP_COLD"},            \
+        {(unsigned long)__GFP_NOWARN,           "GFP_NOWARN"},          \
+        {(unsigned long)__GFP_REPEAT,           "GFP_REPEAT"},          \
+        {(unsigned long)__GFP_NOFAIL,           "GFP_NOFAIL"},          \
+        {(unsigned long)__GFP_NORETRY,          "GFP_NORETRY"},         \
+        {(unsigned long)__GFP_COMP,             "GFP_COMP"},            \
+        {(unsigned long)__GFP_ZERO,             "GFP_ZERO"},            \
+        {(unsigned long)__GFP_NOMEMALLOC,       "GFP_NOMEMALLOC"},      \
+        {(unsigned long)__GFP_HARDWALL,         "GFP_HARDWALL"},        \
+        {(unsigned long)__GFP_THISNODE,         "GFP_THISNODE"},        \
+        {(unsigned long)__GFP_RECLAIMABLE,      "GFP_RECLAIMABLE"},     \
+        {(unsigned long)__GFP_MOVABLE,          "GFP_MOVABLE"}          \
+        ) : "GFP_NOWAIT"
+
+TRACE_EVENT(kmalloc,
+
+        TP_PROTO(unsigned long call_site,
+                 const void *ptr,
+                 size_t bytes_req,
+                 size_t bytes_alloc,
+                 gfp_t gfp_flags),
+
+        TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  call_site       )
+                __field(        const void *,   ptr             )
+                __field(        size_t,         bytes_req       )
+                __field(        size_t,         bytes_alloc     )
+                __field(        gfp_t,          gfp_flags       )
+        ),
+
+        TP_fast_assign(
+                __entry->call_site      = call_site;
+                __entry->ptr            = ptr;
+                __entry->bytes_req      = bytes_req;
+                __entry->bytes_alloc    = bytes_alloc;
+                __entry->gfp_flags      = gfp_flags;
+        ),
+
+        TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s",
+                __entry->call_site,
+                __entry->ptr,
+                __entry->bytes_req,
+                __entry->bytes_alloc,
+                show_gfp_flags(__entry->gfp_flags))
+);
+
+TRACE_EVENT(kmem_cache_alloc,
+
+        TP_PROTO(unsigned long call_site,
+                 const void *ptr,
+                 size_t bytes_req,
+                 size_t bytes_alloc,
+                 gfp_t gfp_flags),
+
+        TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  call_site       )
+                __field(        const void *,   ptr             )
+                __field(        size_t,         bytes_req       )
+                __field(        size_t,         bytes_alloc     )
+                __field(        gfp_t,          gfp_flags       )
+        ),
+
+        TP_fast_assign(
+                __entry->call_site      = call_site;
+                __entry->ptr            = ptr;
+                __entry->bytes_req      = bytes_req;
+                __entry->bytes_alloc    = bytes_alloc;
+                __entry->gfp_flags      = gfp_flags;
+        ),
+
+        TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s",
+                __entry->call_site,
+                __entry->ptr,
+                __entry->bytes_req,
+                __entry->bytes_alloc,
+                show_gfp_flags(__entry->gfp_flags))
+);
+
+TRACE_EVENT(kmalloc_node,
+
+        TP_PROTO(unsigned long call_site,
+                 const void *ptr,
+                 size_t bytes_req,
+                 size_t bytes_alloc,
+                 gfp_t gfp_flags,
+                 int node),
+
+        TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  call_site       )
+                __field(        const void *,   ptr             )
+                __field(        size_t,         bytes_req       )
+                __field(        size_t,         bytes_alloc     )
+                __field(        gfp_t,          gfp_flags       )
+                __field(        int,            node            )
+        ),
+
+        TP_fast_assign(
+                __entry->call_site      = call_site;
+                __entry->ptr            = ptr;
+                __entry->bytes_req      = bytes_req;
+                __entry->bytes_alloc    = bytes_alloc;
+                __entry->gfp_flags      = gfp_flags;
+                __entry->node           = node;
+        ),
+
+        TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d",
+                __entry->call_site,
+                __entry->ptr,
+                __entry->bytes_req,
+                __entry->bytes_alloc,
+                show_gfp_flags(__entry->gfp_flags),
+                __entry->node)
+);
+
+TRACE_EVENT(kmem_cache_alloc_node,
+
+        TP_PROTO(unsigned long call_site,
+                 const void *ptr,
+                 size_t bytes_req,
+                 size_t bytes_alloc,
+                 gfp_t gfp_flags,
+                 int node),
+
+        TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  call_site       )
+                __field(        const void *,   ptr             )
+                __field(        size_t,         bytes_req       )
+                __field(        size_t,         bytes_alloc     )
+                __field(        gfp_t,          gfp_flags       )
+                __field(        int,            node            )
+        ),
+
+        TP_fast_assign(
+                __entry->call_site      = call_site;
+                __entry->ptr            = ptr;
+                __entry->bytes_req      = bytes_req;
+                __entry->bytes_alloc    = bytes_alloc;
+                __entry->gfp_flags      = gfp_flags;
+                __entry->node           = node;
+        ),
+
+        TP_printk("call_site=%lx ptr=%p bytes_req=%zu bytes_alloc=%zu gfp_flags=%s node=%d",
+                __entry->call_site,
+                __entry->ptr,
+                __entry->bytes_req,
+                __entry->bytes_alloc,
+                show_gfp_flags(__entry->gfp_flags),
+                __entry->node)
+);
+
+TRACE_EVENT(kfree,
+
+        TP_PROTO(unsigned long call_site, const void *ptr),
+
+        TP_ARGS(call_site, ptr),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  call_site       )
+                __field(        const void *,   ptr             )
+        ),
+
+        TP_fast_assign(
+                __entry->call_site      = call_site;
+                __entry->ptr            = ptr;
+        ),
+
+        TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
+);
+
+TRACE_EVENT(kmem_cache_free,
+
+        TP_PROTO(unsigned long call_site, const void *ptr),
+
+        TP_ARGS(call_site, ptr),
+
+        TP_STRUCT__entry(
+                __field(        unsigned long,  call_site       )
+                __field(        const void *,   ptr             )
+        ),
+
+        TP_fast_assign(
+                __entry->call_site      = call_site;
+                __entry->ptr            = ptr;
+        ),
+
+        TP_printk("call_site=%lx ptr=%p", __entry->call_site, __entry->ptr)
+);
+#endif /* _TRACE_KMEM_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/lockdep.h b/include/trace/events/lockdep.h
new file mode 100644
index 000000000000..bcf1d209a00d
--- /dev/null
+++ b/include/trace/events/lockdep.h
@@ -0,0 +1,96 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM lockdep
+
+#if !defined(_TRACE_LOCKDEP_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_LOCKDEP_H
+
+#include <linux/lockdep.h>
+#include <linux/tracepoint.h>
+
+#ifdef CONFIG_LOCKDEP
+
+TRACE_EVENT(lock_acquire,
+
+        TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
+                int trylock, int read, int check,
+                struct lockdep_map *next_lock, unsigned long ip),
+
+        TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip),
+
+        TP_STRUCT__entry(
+                __field(unsigned int, flags)
+                __string(name, lock->name)
+        ),
+
+        TP_fast_assign(
+                __entry->flags = (trylock ? 1 : 0) | (read ? 2 : 0);
+                __assign_str(name, lock->name);
+        ),
+
+        TP_printk("%s%s%s", (__entry->flags & 1) ? "try " : "",
+                  (__entry->flags & 2) ? "read " : "",
+                  __get_str(name))
+);
+
+TRACE_EVENT(lock_release,
+
+        TP_PROTO(struct lockdep_map *lock, int nested, unsigned long ip),
+
+        TP_ARGS(lock, nested, ip),
+
+        TP_STRUCT__entry(
+                __string(name, lock->name)
+        ),
+
+        TP_fast_assign(
+                __assign_str(name, lock->name);
+        ),
+
+        TP_printk("%s", __get_str(name))
+);
+
+#ifdef CONFIG_LOCK_STAT
+
+TRACE_EVENT(lock_contended,
+
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
+
+        TP_ARGS(lock, ip),
+
+        TP_STRUCT__entry(
+                __string(name, lock->name)
+        ),
+
+        TP_fast_assign(
+                __assign_str(name, lock->name);
+        ),
+
+        TP_printk("%s", __get_str(name))
+);
+
+TRACE_EVENT(lock_acquired,
+        TP_PROTO(struct lockdep_map *lock, unsigned long ip, s64 waittime),
+
+        TP_ARGS(lock, ip, waittime),
+
+        TP_STRUCT__entry(
+                __string(name, lock->name)
+                __field(unsigned long, wait_usec)
+                __field(unsigned long, wait_nsec_rem)
+        ),
+        TP_fast_assign(
+                __assign_str(name, lock->name);
+                __entry->wait_nsec_rem = do_div(waittime, NSEC_PER_USEC);
+                __entry->wait_usec = (unsigned long) waittime;
+        ),
+        TP_printk("%s (%lu.%03lu us)", __get_str(name), __entry->wait_usec,
+                                       __entry->wait_nsec_rem)
+);
+
+#endif
+#endif
+
+#endif /* _TRACE_LOCKDEP_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/napi.h b/include/trace/events/napi.h
new file mode 100644
index 000000000000..a8989c4547e7
--- /dev/null
+++ b/include/trace/events/napi.h
@@ -0,0 +1,11 @@
+#ifndef _TRACE_NAPI_H_
+#define _TRACE_NAPI_H_
+
+#include <linux/netdevice.h>
+#include <linux/tracepoint.h>
+
+DECLARE_TRACE(napi_poll,
+        TP_PROTO(struct napi_struct *napi),
+        TP_ARGS(napi));
+
+#endif
diff --git a/include/trace/sched_event_types.h b/include/trace/events/sched.h
index 63547dc1125f..8949bb7eb082 100644
--- a/include/trace/sched_event_types.h
+++ b/include/trace/events/sched.h
@@ -1,13 +1,12 @@
-
-/* use <trace/sched.h> instead */
-#ifndef TRACE_EVENT
-# error Do not include this file directly.
-# error Unless you know what you are doing.
-#endif
-
 #undef TRACE_SYSTEM
 #define TRACE_SYSTEM sched
 
+#if !defined(_TRACE_SCHED_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_SCHED_H
+
+#include <linux/sched.h>
+#include <linux/tracepoint.h>
+
 /*
  * Tracepoint for calling kthread_stop, performed to end a kthread:
  */
@@ -157,6 +156,7 @@ TRACE_EVENT(sched_switch,
                 __array(        char,   prev_comm,      TASK_COMM_LEN   )
                 __field(        pid_t,  prev_pid                        )
                 __field(        int,    prev_prio                       )
+                __field(        long,   prev_state                      )
                 __array(        char,   next_comm,      TASK_COMM_LEN   )
                 __field(        pid_t,  next_pid                        )
                 __field(        int,    next_prio                       )
@@ -166,13 +166,19 @@ TRACE_EVENT(sched_switch,
                 memcpy(__entry->next_comm, next->comm, TASK_COMM_LEN);
                 __entry->prev_pid       = prev->pid;
                 __entry->prev_prio      = prev->prio;
+                __entry->prev_state     = prev->state;
                 memcpy(__entry->prev_comm, prev->comm, TASK_COMM_LEN);
                 __entry->next_pid       = next->pid;
                 __entry->next_prio      = next->prio;
         ),
 
-        TP_printk("task %s:%d [%d] ==> %s:%d [%d]",
+        TP_printk("task %s:%d [%d] (%s) ==> %s:%d [%d]",
                 __entry->prev_comm, __entry->prev_pid, __entry->prev_prio,
+                __entry->prev_state ?
+                  __print_flags(__entry->prev_state, "|",
+                                { 1, "S"} , { 2, "D" }, { 4, "T" }, { 8, "t" },
+                                { 16, "Z" }, { 32, "X" }, { 64, "x" },
+                                { 128, "W" }) : "R",
                 __entry->next_comm, __entry->next_pid, __entry->next_prio)
 );
 
@@ -181,9 +187,9 @@ TRACE_EVENT(sched_switch,
  */
 TRACE_EVENT(sched_migrate_task,
 
-        TP_PROTO(struct task_struct *p, int orig_cpu, int dest_cpu),
+        TP_PROTO(struct task_struct *p, int dest_cpu),
 
-        TP_ARGS(p, orig_cpu, dest_cpu),
+        TP_ARGS(p, dest_cpu),
 
         TP_STRUCT__entry(
                 __array(        char,   comm,   TASK_COMM_LEN   )
@@ -197,7 +203,7 @@ TRACE_EVENT(sched_migrate_task,
                 memcpy(__entry->comm, p->comm, TASK_COMM_LEN);
                 __entry->pid            = p->pid;
                 __entry->prio           = p->prio;
-                __entry->orig_cpu       = orig_cpu;
+                __entry->orig_cpu       = task_cpu(p);
                 __entry->dest_cpu       = dest_cpu;
         ),
 
@@ -334,4 +340,7 @@ TRACE_EVENT(sched_signal_send,
                   __entry->sig, __entry->comm, __entry->pid)
 );
 
-#undef TRACE_SYSTEM
+#endif /* _TRACE_SCHED_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/skb.h b/include/trace/events/skb.h
new file mode 100644
index 000000000000..e499863b9669
--- /dev/null
+++ b/include/trace/events/skb.h
@@ -0,0 +1,40 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM skb
+
+#if !defined(_TRACE_SKB_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_SKB_H
+
+#include <linux/skbuff.h>
+#include <linux/tracepoint.h>
+
+/*
+ * Tracepoint for free an sk_buff:
+ */
+TRACE_EVENT(kfree_skb,
+
+        TP_PROTO(struct sk_buff *skb, void *location),
+
+        TP_ARGS(skb, location),
+
+        TP_STRUCT__entry(
+                __field(        void *,         skbaddr         )
+                __field(        unsigned short, protocol        )
+                __field(        void *,         location        )
+        ),
+
+        TP_fast_assign(
+                __entry->skbaddr = skb;
+                if (skb) {
+                        __entry->protocol = ntohs(skb->protocol);
+                }
+                __entry->location = location;
+        ),
+
+        TP_printk("skbaddr=%p protocol=%u location=%p",
+                __entry->skbaddr, __entry->protocol, __entry->location)
+);
+
+#endif /* _TRACE_SKB_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/events/workqueue.h b/include/trace/events/workqueue.h
new file mode 100644
index 000000000000..fcfd9a1e4b96
--- /dev/null
+++ b/include/trace/events/workqueue.h
@@ -0,0 +1,100 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM workqueue
+
+#if !defined(_TRACE_WORKQUEUE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_WORKQUEUE_H
+
+#include <linux/workqueue.h>
+#include <linux/sched.h>
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(workqueue_insertion,
+
+        TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
+
+        TP_ARGS(wq_thread, work),
+
+        TP_STRUCT__entry(
+                __array(char,           thread_comm,    TASK_COMM_LEN)
+                __field(pid_t,          thread_pid)
+                __field(work_func_t,    func)
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->thread_comm, wq_thread->comm, TASK_COMM_LEN);
+                __entry->thread_pid     = wq_thread->pid;
+                __entry->func           = work->func;
+        ),
+
+        TP_printk("thread=%s:%d func=%pF", __entry->thread_comm,
+                __entry->thread_pid, __entry->func)
+);
+
+TRACE_EVENT(workqueue_execution,
+
+        TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
+
+        TP_ARGS(wq_thread, work),
+
+        TP_STRUCT__entry(
+                __array(char,           thread_comm,    TASK_COMM_LEN)
+                __field(pid_t,          thread_pid)
+                __field(work_func_t,    func)
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->thread_comm, wq_thread->comm, TASK_COMM_LEN);
+                __entry->thread_pid     = wq_thread->pid;
+                __entry->func           = work->func;
+        ),
+
+        TP_printk("thread=%s:%d func=%pF", __entry->thread_comm,
+                __entry->thread_pid, __entry->func)
+);
+
+/* Trace the creation of one workqueue thread on a cpu */
+TRACE_EVENT(workqueue_creation,
+
+        TP_PROTO(struct task_struct *wq_thread, int cpu),
+
+        TP_ARGS(wq_thread, cpu),
+
+        TP_STRUCT__entry(
+                __array(char,   thread_comm,    TASK_COMM_LEN)
+                __field(pid_t,  thread_pid)
+                __field(int,    cpu)
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->thread_comm, wq_thread->comm, TASK_COMM_LEN);
+                __entry->thread_pid     = wq_thread->pid;
+                __entry->cpu            = cpu;
+        ),
+
+        TP_printk("thread=%s:%d cpu=%d", __entry->thread_comm,
+                __entry->thread_pid, __entry->cpu)
+);
+
+TRACE_EVENT(workqueue_destruction,
+
+        TP_PROTO(struct task_struct *wq_thread),
+
+        TP_ARGS(wq_thread),
+
+        TP_STRUCT__entry(
+                __array(char,   thread_comm,    TASK_COMM_LEN)
+                __field(pid_t,  thread_pid)
+        ),
+
+        TP_fast_assign(
+                memcpy(__entry->thread_comm, wq_thread->comm, TASK_COMM_LEN);
+                __entry->thread_pid     = wq_thread->pid;
+        ),
+
+        TP_printk("thread=%s:%d", __entry->thread_comm, __entry->thread_pid)
+);
+
+#endif /* _TRACE_WORKQUEUE_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
new file mode 100644
index 000000000000..1867553c61e5
--- /dev/null
+++ b/include/trace/ftrace.h
@@ -0,0 +1,591 @@
+/*
+ * Stage 1 of the trace events.
+ *
+ * Override the macros in <trace/trace_events.h> to include the following:
+ *
+ * struct ftrace_raw_<call> {
+ *      struct trace_entry              ent;
+ *      <type>                          <item>;
+ *      <type2>                         <item2>[<len>];
+ *      [...]
+ * };
+ *
+ * The <type> <item> is created by the __field(type, item) macro or
+ * the __array(type2, item2, len) macro.
+ * We simply do "type item;", and that will create the fields
+ * in the structure.
+ */
+
+#include <linux/ftrace_event.h>
+
+#undef __field
+#define __field(type, item)             type    item;
+
+#undef __array
+#define __array(type, item, len)        type    item[len];
+
+#undef __dynamic_array
+#define __dynamic_array(type, item, len) unsigned short __data_loc_##item;
+
+#undef __string
+#define __string(item, src) __dynamic_array(char, item, -1)
+
+#undef TP_STRUCT__entry
+#define TP_STRUCT__entry(args...) args
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(name, proto, args, tstruct, assign, print)  \
+        struct ftrace_raw_##name {                              \
+                struct trace_entry      ent;                    \
+                tstruct                                         \
+                char                    __data[0];              \
+        };                                                      \
+        static struct ftrace_event_call event_##name
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+
+/*
+ * Stage 2 of the trace events.
+ *
+ * Include the following:
+ *
+ * struct ftrace_data_offsets_<call> {
+ *      int                             <item1>;
+ *      int                             <item2>;
+ *      [...]
+ * };
+ *
+ * The __dynamic_array() macro will create each int <item>, this is
+ * to keep the offset of each array from the beginning of the event.
+ */
+
+#undef __field
+#define __field(type, item);
+
+#undef __array
+#define __array(type, item, len)
+
+#undef __dynamic_array
+#define __dynamic_array(type, item, len)        int item;
+
+#undef __string
+#define __string(item, src) __dynamic_array(char, item, -1)
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
+        struct ftrace_data_offsets_##call {                             \
+                tstruct;                                                \
+        };
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+/*
+ * Setup the showing format of trace point.
+ *
+ * int
+ * ftrace_format_##call(struct trace_seq *s)
+ * {
+ *      struct ftrace_raw_##call field;
+ *      int ret;
+ *
+ *      ret = trace_seq_printf(s, #type " " #item ";"
+ *                             " offset:%u; size:%u;\n",
+ *                             offsetof(struct ftrace_raw_##call, item),
+ *                             sizeof(field.type));
+ *
+ * }
+ */
+
+#undef TP_STRUCT__entry
+#define TP_STRUCT__entry(args...) args
+
+#undef __field
+#define __field(type, item)                                     \
+        ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"      \
+                               "offset:%u;\tsize:%u;\n",                \
+                               (unsigned int)offsetof(typeof(field), item), \
+                               (unsigned int)sizeof(field.item));       \
+        if (!ret)                                                       \
+                return 0;
+
+#undef __array
+#define __array(type, item, len)                                                \
+        ret = trace_seq_printf(s, "\tfield:" #type " " #item "[" #len "];\t"    \
+                               "offset:%u;\tsize:%u;\n",                \
+                               (unsigned int)offsetof(typeof(field), item), \
+                               (unsigned int)sizeof(field.item));       \
+        if (!ret)                                                       \
+                return 0;
+
+#undef __dynamic_array
+#define __dynamic_array(type, item, len)                                       \
+        ret = trace_seq_printf(s, "\tfield:__data_loc " #item ";\t"            \
+                               "offset:%u;\tsize:%u;\n",                       \
+                               (unsigned int)offsetof(typeof(field),           \
+                                        __data_loc_##item),                    \
+                               (unsigned int)sizeof(field.__data_loc_##item)); \
+        if (!ret)                                                              \
+                return 0;
+
+#undef __string
+#define __string(item, src) __dynamic_array(char, item, -1)
+
+#undef __entry
+#define __entry REC
+
+#undef __print_symbolic
+#undef __get_dynamic_array
+#undef __get_str
+
+#undef TP_printk
+#define TP_printk(fmt, args...) "%s, %s\n", #fmt, __stringify(args)
+
+#undef TP_fast_assign
+#define TP_fast_assign(args...) args
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
+static int                                                              \
+ftrace_format_##call(struct trace_seq *s)                               \
+{                                                                       \
+        struct ftrace_raw_##call field __attribute__((unused));         \
+        int ret = 0;                                                    \
+                                                                        \
+        tstruct;                                                        \
+                                                                        \
+        trace_seq_printf(s, "\nprint fmt: " print);                     \
+                                                                        \
+        return ret;                                                     \
+}
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+/*
+ * Stage 3 of the trace events.
+ *
+ * Override the macros in <trace/trace_events.h> to include the following:
+ *
+ * enum print_line_t
+ * ftrace_raw_output_<call>(struct trace_iterator *iter, int flags)
+ * {
+ *      struct trace_seq *s = &iter->seq;
+ *      struct ftrace_raw_<call> *field; <-- defined in stage 1
+ *      struct trace_entry *entry;
+ *      struct trace_seq *p;
+ *      int ret;
+ *
+ *      entry = iter->ent;
+ *
+ *      if (entry->type != event_<call>.id) {
+ *              WARN_ON_ONCE(1);
+ *              return TRACE_TYPE_UNHANDLED;
+ *      }
+ *
+ *      field = (typeof(field))entry;
+ *
+ *      p = get_cpu_var(ftrace_event_seq);
+ *      trace_seq_init(p);
+ *      ret = trace_seq_printf(s, <TP_printk> "\n");
+ *      put_cpu();
+ *      if (!ret)
+ *              return TRACE_TYPE_PARTIAL_LINE;
+ *
+ *      return TRACE_TYPE_HANDLED;
+ * }
+ *
+ * This is the method used to print the raw event to the trace
+ * output format. Note, this is not needed if the data is read
+ * in binary.
+ */
+
+#undef __entry
+#define __entry field
+
+#undef TP_printk
+#define TP_printk(fmt, args...) fmt "\n", args
+
+#undef __get_dynamic_array
+#define __get_dynamic_array(field)      \
+                ((void *)__entry + __entry->__data_loc_##field)
+
+#undef __get_str
+#define __get_str(field) (char *)__get_dynamic_array(field)
+
+#undef __print_flags
+#define __print_flags(flag, delim, flag_array...)                       \
+        ({                                                              \
+                static const struct trace_print_flags flags[] =         \
+                        { flag_array, { -1, NULL }};                    \
+                ftrace_print_flags_seq(p, delim, flag, flags);          \
+        })
+
+#undef __print_symbolic
+#define __print_symbolic(value, symbol_array...)                        \
+        ({                                                              \
+                static const struct trace_print_flags symbols[] =       \
+                        { symbol_array, { -1, NULL }};                  \
+                ftrace_print_symbols_seq(p, value, symbols);            \
+        })
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
+enum print_line_t                                                       \
+ftrace_raw_output_##call(struct trace_iterator *iter, int flags)        \
+{                                                                       \
+        struct trace_seq *s = &iter->seq;                               \
+        struct ftrace_raw_##call *field;                                \
+        struct trace_entry *entry;                                      \
+        struct trace_seq *p;                                            \
+        int ret;                                                        \
+                                                                        \
+        entry = iter->ent;                                              \
+                                                                        \
+        if (entry->type != event_##call.id) {                           \
+                WARN_ON_ONCE(1);                                        \
+                return TRACE_TYPE_UNHANDLED;                            \
+        }                                                               \
+                                                                        \
+        field = (typeof(field))entry;                                   \
+                                                                        \
+        p = &get_cpu_var(ftrace_event_seq);                             \
+        trace_seq_init(p);                                              \
+        ret = trace_seq_printf(s, #call ": " print);                    \
+        put_cpu();                                                      \
+        if (!ret)                                                       \
+                return TRACE_TYPE_PARTIAL_LINE;                         \
+                                                                        \
+        return TRACE_TYPE_HANDLED;                                      \
+}
+        
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+#undef __field
+#define __field(type, item)                                             \
+        ret = trace_define_field(event_call, #type, #item,              \
+                                 offsetof(typeof(field), item),         \
+                                 sizeof(field.item), is_signed_type(type));     \
+        if (ret)                                                        \
+                return ret;
+
+#undef __array
+#define __array(type, item, len)                                        \
+        BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);                         \
+        ret = trace_define_field(event_call, #type "[" #len "]", #item, \
+                                 offsetof(typeof(field), item),         \
+                                 sizeof(field.item), 0);                \
+        if (ret)                                                        \
+                return ret;
+
+#undef __dynamic_array
+#define __dynamic_array(type, item, len)                                       \
+        ret = trace_define_field(event_call, "__data_loc" "[" #type "]", #item,\
+                                offsetof(typeof(field), __data_loc_##item),    \
+                                 sizeof(field.__data_loc_##item), 0);
+
+#undef __string
+#define __string(item, src) __dynamic_array(char, item, -1)
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, func, print)            \
+int                                                                     \
+ftrace_define_fields_##call(void)                                       \
+{                                                                       \
+        struct ftrace_raw_##call field;                                 \
+        struct ftrace_event_call *event_call = &event_##call;           \
+        int ret;                                                        \
+                                                                        \
+        __common_field(int, type, 1);                                   \
+        __common_field(unsigned char, flags, 0);                        \
+        __common_field(unsigned char, preempt_count, 0);                \
+        __common_field(int, pid, 1);                                    \
+        __common_field(int, tgid, 1);                                   \
+                                                                        \
+        tstruct;                                                        \
+                                                                        \
+        return ret;                                                     \
+}
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+/*
+ * remember the offset of each array from the beginning of the event.
+ */
+
+#undef __entry
+#define __entry entry
+
+#undef __field
+#define __field(type, item)
+
+#undef __array
+#define __array(type, item, len)
+
+#undef __dynamic_array
+#define __dynamic_array(type, item, len)                                \
+        __data_offsets->item = __data_size +                            \
+                               offsetof(typeof(*entry), __data);        \
+        __data_size += (len) * sizeof(type);
+
+#undef __string
+#define __string(item, src) __dynamic_array(char, item, strlen(src) + 1)       \
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
+static inline int ftrace_get_offsets_##call(                            \
+        struct ftrace_data_offsets_##call *__data_offsets, proto)       \
+{                                                                       \
+        int __data_size = 0;                                            \
+        struct ftrace_raw_##call __maybe_unused *entry;                 \
+                                                                        \
+        tstruct;                                                        \
+                                                                        \
+        return __data_size;                                             \
+}
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+/*
+ * Stage 4 of the trace events.
+ *
+ * Override the macros in <trace/trace_events.h> to include the following:
+ *
+ * static void ftrace_event_<call>(proto)
+ * {
+ *      event_trace_printk(_RET_IP_, "<call>: " <fmt>);
+ * }
+ *
+ * static int ftrace_reg_event_<call>(void)
+ * {
+ *      int ret;
+ *
+ *      ret = register_trace_<call>(ftrace_event_<call>);
+ *      if (!ret)
+ *              pr_info("event trace: Could not activate trace point "
+ *                      "probe to  <call>");
+ *      return ret;
+ * }
+ *
+ * static void ftrace_unreg_event_<call>(void)
+ * {
+ *      unregister_trace_<call>(ftrace_event_<call>);
+ * }
+ *
+ *
+ * For those macros defined with TRACE_EVENT:
+ *
+ * static struct ftrace_event_call event_<call>;
+ *
+ * static void ftrace_raw_event_<call>(proto)
+ * {
+ *      struct ring_buffer_event *event;
+ *      struct ftrace_raw_<call> *entry; <-- defined in stage 1
+ *      unsigned long irq_flags;
+ *      int pc;
+ *
+ *      local_save_flags(irq_flags);
+ *      pc = preempt_count();
+ *
+ *      event = trace_current_buffer_lock_reserve(event_<call>.id,
+ *                                sizeof(struct ftrace_raw_<call>),
+ *                                irq_flags, pc);
+ *      if (!event)
+ *              return;
+ *      entry   = ring_buffer_event_data(event);
+ *
+ *      <assign>;  <-- Here we assign the entries by the __field and
+ *                      __array macros.
+ *
+ *      trace_current_buffer_unlock_commit(event, irq_flags, pc);
+ * }
+ *
+ * static int ftrace_raw_reg_event_<call>(void)
+ * {
+ *      int ret;
+ *
+ *      ret = register_trace_<call>(ftrace_raw_event_<call>);
+ *      if (!ret)
+ *              pr_info("event trace: Could not activate trace point "
+ *                      "probe to <call>");
+ *      return ret;
+ * }
+ *
+ * static void ftrace_unreg_event_<call>(void)
+ * {
+ *      unregister_trace_<call>(ftrace_raw_event_<call>);
+ * }
+ *
+ * static struct trace_event ftrace_event_type_<call> = {
+ *      .trace                  = ftrace_raw_output_<call>, <-- stage 2
+ * };
+ *
+ * static int ftrace_raw_init_event_<call>(void)
+ * {
+ *      int id;
+ *
+ *      id = register_ftrace_event(&ftrace_event_type_<call>);
+ *      if (!id)
+ *              return -ENODEV;
+ *      event_<call>.id = id;
+ *      return 0;
+ * }
+ *
+ * static struct ftrace_event_call __used
+ * __attribute__((__aligned__(4)))
+ * __attribute__((section("_ftrace_events"))) event_<call> = {
+ *      .name                   = "<call>",
+ *      .system                 = "<system>",
+ *      .raw_init               = ftrace_raw_init_event_<call>,
+ *      .regfunc                = ftrace_reg_event_<call>,
+ *      .unregfunc              = ftrace_unreg_event_<call>,
+ *      .show_format            = ftrace_format_<call>,
+ * }
+ *
+ */
+
+#undef TP_FMT
+#define TP_FMT(fmt, args...)    fmt "\n", ##args
+
+#ifdef CONFIG_EVENT_PROFILE
+#define _TRACE_PROFILE(call, proto, args)                               \
+static void ftrace_profile_##call(proto)                                \
+{                                                                       \
+        extern void perf_tpcounter_event(int);                          \
+        perf_tpcounter_event(event_##call.id);                          \
+}                                                                       \
+                                                                        \
+static int ftrace_profile_enable_##call(struct ftrace_event_call *event_call) \
+{                                                                       \
+        int ret = 0;                                                    \
+                                                                        \
+        if (!atomic_inc_return(&event_call->profile_count))             \
+                ret = register_trace_##call(ftrace_profile_##call);     \
+                                                                        \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static void ftrace_profile_disable_##call(struct ftrace_event_call *event_call)\
+{                                                                       \
+        if (atomic_add_negative(-1, &event_call->profile_count))        \
+                unregister_trace_##call(ftrace_profile_##call);         \
+}
+
+#define _TRACE_PROFILE_INIT(call)                                       \
+        .profile_count = ATOMIC_INIT(-1),                               \
+        .profile_enable = ftrace_profile_enable_##call,                 \
+        .profile_disable = ftrace_profile_disable_##call,
+
+#else
+#define _TRACE_PROFILE(call, proto, args)
+#define _TRACE_PROFILE_INIT(call)
+#endif
+
+#undef __entry
+#define __entry entry
+
+#undef __field
+#define __field(type, item)
+
+#undef __array
+#define __array(type, item, len)
+
+#undef __dynamic_array
+#define __dynamic_array(type, item, len)                                \
+        __entry->__data_loc_##item = __data_offsets.item;
+
+#undef __string
+#define __string(item, src) __dynamic_array(char, item, -1)             \
+
+#undef __assign_str
+#define __assign_str(dst, src)                                          \
+        strcpy(__get_str(dst), src);
+
+#undef TRACE_EVENT
+#define TRACE_EVENT(call, proto, args, tstruct, assign, print)          \
+_TRACE_PROFILE(call, PARAMS(proto), PARAMS(args))                       \
+                                                                        \
+static struct ftrace_event_call event_##call;                           \
+                                                                        \
+static void ftrace_raw_event_##call(proto)                              \
+{                                                                       \
+        struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\
+        struct ftrace_event_call *event_call = &event_##call;           \
+        struct ring_buffer_event *event;                                \
+        struct ftrace_raw_##call *entry;                                \
+        unsigned long irq_flags;                                        \
+        int __data_size;                                                \
+        int pc;                                                         \
+                                                                        \
+        local_save_flags(irq_flags);                                    \
+        pc = preempt_count();                                           \
+                                                                        \
+        __data_size = ftrace_get_offsets_##call(&__data_offsets, args); \
+                                                                        \
+        event = trace_current_buffer_lock_reserve(event_##call.id,      \
+                                 sizeof(*entry) + __data_size,          \
+                                 irq_flags, pc);                        \
+        if (!event)                                                     \
+                return;                                                 \
+        entry   = ring_buffer_event_data(event);                        \
+                                                                        \
+                                                                        \
+        tstruct                                                         \
+                                                                        \
+        { assign; }                                                     \
+                                                                        \
+        if (!filter_current_check_discard(event_call, entry, event))    \
+                trace_nowake_buffer_unlock_commit(event, irq_flags, pc); \
+}                                                                       \
+                                                                        \
+static int ftrace_raw_reg_event_##call(void)                            \
+{                                                                       \
+        int ret;                                                        \
+                                                                        \
+        ret = register_trace_##call(ftrace_raw_event_##call);           \
+        if (ret)                                                        \
+                pr_info("event trace: Could not activate trace point "  \
+                        "probe to " #call "\n");                        \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static void ftrace_raw_unreg_event_##call(void)                         \
+{                                                                       \
+        unregister_trace_##call(ftrace_raw_event_##call);               \
+}                                                                       \
+                                                                        \
+static struct trace_event ftrace_event_type_##call = {                  \
+        .trace                  = ftrace_raw_output_##call,             \
+};                                                                      \
+                                                                        \
+static int ftrace_raw_init_event_##call(void)                           \
+{                                                                       \
+        int id;                                                         \
+                                                                        \
+        id = register_ftrace_event(&ftrace_event_type_##call);          \
+        if (!id)                                                        \
+                return -ENODEV;                                         \
+        event_##call.id = id;                                           \
+        INIT_LIST_HEAD(&event_##call.fields);                           \
+        init_preds(&event_##call);                                      \
+        return 0;                                                       \
+}                                                                       \
+                                                                        \
+static struct ftrace_event_call __used                                  \
+__attribute__((__aligned__(4)))                                         \
+__attribute__((section("_ftrace_events"))) event_##call = {             \
+        .name                   = #call,                                \
+        .system                 = __stringify(TRACE_SYSTEM),            \
+        .event                  = &ftrace_event_type_##call,            \
+        .raw_init               = ftrace_raw_init_event_##call,         \
+        .regfunc                = ftrace_raw_reg_event_##call,          \
+        .unregfunc              = ftrace_raw_unreg_event_##call,        \
+        .show_format            = ftrace_format_##call,                 \
+        .define_fields          = ftrace_define_fields_##call,          \
+        _TRACE_PROFILE_INIT(call)                                       \
+}
+
+#include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
+
+#undef _TRACE_PROFILE
+#undef _TRACE_PROFILE_INIT
+
diff --git a/include/trace/irq.h b/include/trace/irq.h
deleted file mode 100644
index ff5d4495dc37..000000000000
--- a/include/trace/irq.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef _TRACE_IRQ_H
-#define _TRACE_IRQ_H
-
-#include <linux/interrupt.h>
-#include <linux/tracepoint.h>
-
-#include <trace/irq_event_types.h>
-
-#endif
diff --git a/include/trace/irq_event_types.h b/include/trace/irq_event_types.h
deleted file mode 100644
index 85964ebd47ec..000000000000
--- a/include/trace/irq_event_types.h
+++ /dev/null
@@ -1,55 +0,0 @@
-
-/* use <trace/irq.h> instead */
-#ifndef TRACE_FORMAT
-# error Do not include this file directly.
-# error Unless you know what you are doing.
-#endif
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM irq
-
-/*
- * Tracepoint for entry of interrupt handler:
- */
-TRACE_FORMAT(irq_handler_entry,
-        TP_PROTO(int irq, struct irqaction *action),
-        TP_ARGS(irq, action),
-        TP_FMT("irq=%d handler=%s", irq, action->name)
-        );
-
-/*
- * Tracepoint for return of an interrupt handler:
- */
-TRACE_EVENT(irq_handler_exit,
-
-        TP_PROTO(int irq, struct irqaction *action, int ret),
-
-        TP_ARGS(irq, action, ret),
-
-        TP_STRUCT__entry(
-                __field(        int,    irq     )
-                __field(        int,    ret     )
-        ),
-
-        TP_fast_assign(
-                __entry->irq    = irq;
-                __entry->ret    = ret;
-        ),
-
-        TP_printk("irq=%d return=%s",
-                  __entry->irq, __entry->ret ? "handled" : "unhandled")
-);
-
-TRACE_FORMAT(softirq_entry,
-        TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
-        TP_ARGS(h, vec),
-        TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
-        );
-
-TRACE_FORMAT(softirq_exit,
-        TP_PROTO(struct softirq_action *h, struct softirq_action *vec),
-        TP_ARGS(h, vec),
-        TP_FMT("softirq=%d action=%s", (int)(h - vec), softirq_to_name[h-vec])
-        );
-
-#undef TRACE_SYSTEM
diff --git a/include/trace/kmemtrace.h b/include/trace/kmemtrace.h
deleted file mode 100644
index 28ee69f9cd46..000000000000
--- a/include/trace/kmemtrace.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2008 Eduard - Gabriel Munteanu
- *
- * This file is released under GPL version 2.
- */
-
-#ifndef _LINUX_KMEMTRACE_H
-#define _LINUX_KMEMTRACE_H
-
-#ifdef __KERNEL__
-
-#include <linux/tracepoint.h>
-#include <linux/types.h>
-
-#ifdef CONFIG_KMEMTRACE
-extern void kmemtrace_init(void);
-#else
-static inline void kmemtrace_init(void)
-{
-}
-#endif
-
-DECLARE_TRACE(kmalloc,
-              TP_PROTO(unsigned long call_site,
-                      const void *ptr,
-                      size_t bytes_req,
-                      size_t bytes_alloc,
-                      gfp_t gfp_flags),
-              TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags));
-DECLARE_TRACE(kmem_cache_alloc,
-              TP_PROTO(unsigned long call_site,
-                      const void *ptr,
-                      size_t bytes_req,
-                      size_t bytes_alloc,
-                      gfp_t gfp_flags),
-              TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags));
-DECLARE_TRACE(kmalloc_node,
-              TP_PROTO(unsigned long call_site,
-                      const void *ptr,
-                      size_t bytes_req,
-                      size_t bytes_alloc,
-                      gfp_t gfp_flags,
-                      int node),
-              TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node));
-DECLARE_TRACE(kmem_cache_alloc_node,
-              TP_PROTO(unsigned long call_site,
-                      const void *ptr,
-                      size_t bytes_req,
-                      size_t bytes_alloc,
-                      gfp_t gfp_flags,
-                      int node),
-              TP_ARGS(call_site, ptr, bytes_req, bytes_alloc, gfp_flags, node));
-DECLARE_TRACE(kfree,
-              TP_PROTO(unsigned long call_site, const void *ptr),
-              TP_ARGS(call_site, ptr));
-DECLARE_TRACE(kmem_cache_free,
-              TP_PROTO(unsigned long call_site, const void *ptr),
-              TP_ARGS(call_site, ptr));
-
-#endif /* __KERNEL__ */
-
-#endif /* _LINUX_KMEMTRACE_H */
-
diff --git a/include/trace/lockdep.h b/include/trace/lockdep.h
deleted file mode 100644
index 5ca67df87f2a..000000000000
--- a/include/trace/lockdep.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef _TRACE_LOCKDEP_H
-#define _TRACE_LOCKDEP_H
-
-#include <linux/lockdep.h>
-#include <linux/tracepoint.h>
-
-#include <trace/lockdep_event_types.h>
-
-#endif
diff --git a/include/trace/lockdep_event_types.h b/include/trace/lockdep_event_types.h
deleted file mode 100644
index adccfcd2ec8f..000000000000
--- a/include/trace/lockdep_event_types.h
+++ /dev/null
@@ -1,44 +0,0 @@
-
-#ifndef TRACE_FORMAT
-# error Do not include this file directly.
-# error Unless you know what you are doing.
-#endif
-
-#undef TRACE_SYSTEM
-#define TRACE_SYSTEM lock
-
-#ifdef CONFIG_LOCKDEP
-
-TRACE_FORMAT(lock_acquire,
-        TP_PROTO(struct lockdep_map *lock, unsigned int subclass,
-                int trylock, int read, int check,
-                struct lockdep_map *next_lock, unsigned long ip),
-        TP_ARGS(lock, subclass, trylock, read, check, next_lock, ip),
-        TP_FMT("%s%s%s", trylock ? "try " : "",
-                read ? "read " : "", lock->name)
-        );
-
-TRACE_FORMAT(lock_release,
-        TP_PROTO(struct lockdep_map *lock, int nested, unsigned long ip),
-        TP_ARGS(lock, nested, ip),
-        TP_FMT("%s", lock->name)
-        );
-
-#ifdef CONFIG_LOCK_STAT
-
-TRACE_FORMAT(lock_contended,
-        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
-        TP_ARGS(lock, ip),
-        TP_FMT("%s", lock->name)
-        );
-
-TRACE_FORMAT(lock_acquired,
-        TP_PROTO(struct lockdep_map *lock, unsigned long ip),
-        TP_ARGS(lock, ip),
-        TP_FMT("%s", lock->name)
-        );
-
-#endif
-#endif
-
-#undef TRACE_SYSTEM
diff --git a/include/trace/sched.h b/include/trace/sched.h
deleted file mode 100644
index 4e372a1a29bf..000000000000
--- a/include/trace/sched.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifndef _TRACE_SCHED_H
-#define _TRACE_SCHED_H
-
-#include <linux/sched.h>
-#include <linux/tracepoint.h>
-
-#include <trace/sched_event_types.h>
-
-#endif
diff --git a/include/trace/skb.h b/include/trace/skb.h
deleted file mode 100644
index b66206d9be72..000000000000
--- a/include/trace/skb.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef _TRACE_SKB_H_
-#define _TRACE_SKB_H_
-
-#include <linux/skbuff.h>
-#include <linux/tracepoint.h>
-
-DECLARE_TRACE(kfree_skb,
-        TP_PROTO(struct sk_buff *skb, void *location),
-        TP_ARGS(skb, location));
-
-#endif
diff --git a/include/trace/trace_event_types.h b/include/trace/trace_event_types.h
deleted file mode 100644
index df56f5694be6..000000000000
--- a/include/trace/trace_event_types.h
+++ /dev/null
@@ -1,5 +0,0 @@
-/* trace/<type>_event_types.h here */
-
-#include <trace/sched_event_types.h>
-#include <trace/irq_event_types.h>
-#include <trace/lockdep_event_types.h>
diff --git a/include/trace/trace_events.h b/include/trace/trace_events.h
deleted file mode 100644
index fd13750ca4ba..000000000000
--- a/include/trace/trace_events.h
+++ /dev/null
@@ -1,5 +0,0 @@
-/* trace/<type>.h here */
-
-#include <trace/sched.h>
-#include <trace/irq.h>
-#include <trace/lockdep.h>
diff --git a/include/trace/workqueue.h b/include/trace/workqueue.h
deleted file mode 100644
index 7626523deeba..000000000000
--- a/include/trace/workqueue.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef __TRACE_WORKQUEUE_H
-#define __TRACE_WORKQUEUE_H
-
-#include <linux/tracepoint.h>
-#include <linux/workqueue.h>
-#include <linux/sched.h>
-
-DECLARE_TRACE(workqueue_insertion,
-           TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
-           TP_ARGS(wq_thread, work));
-
-DECLARE_TRACE(workqueue_execution,
-           TP_PROTO(struct task_struct *wq_thread, struct work_struct *work),
-           TP_ARGS(wq_thread, work));
-
-/* Trace the creation of one workqueue thread on a cpu */
-DECLARE_TRACE(workqueue_creation,
-           TP_PROTO(struct task_struct *wq_thread, int cpu),
-           TP_ARGS(wq_thread, cpu));
-
-DECLARE_TRACE(workqueue_destruction,
-           TP_PROTO(struct task_struct *wq_thread),
-           TP_ARGS(wq_thread));
-
-#endif /* __TRACE_WORKQUEUE_H */
diff --git a/include/video/pxa168fb.h b/include/video/pxa168fb.h
new file mode 100644
index 000000000000..b5cc72fe0461
--- /dev/null
+++ b/include/video/pxa168fb.h
@@ -0,0 +1,127 @@
+/*
+ * linux/arch/arm/mach-mmp/include/mach/pxa168fb.h
+ *
+ *  Copyright (C) 2009 Marvell International Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __ASM_MACH_PXA168FB_H
+#define __ASM_MACH_PXA168FB_H
+
+#include <linux/fb.h>
+#include <linux/interrupt.h>
+
+/* Dumb interface */
+#define PIN_MODE_DUMB_24                0
+#define PIN_MODE_DUMB_18_SPI            1
+#define PIN_MODE_DUMB_18_GPIO           2
+#define PIN_MODE_DUMB_16_SPI            3
+#define PIN_MODE_DUMB_16_GPIO           4
+#define PIN_MODE_DUMB_12_SPI_GPIO       5
+#define PIN_MODE_SMART_18_SPI           6
+#define PIN_MODE_SMART_16_SPI           7
+#define PIN_MODE_SMART_8_SPI_GPIO       8
+
+/* Dumb interface pin allocation */
+#define DUMB_MODE_RGB565                0
+#define DUMB_MODE_RGB565_UPPER          1
+#define DUMB_MODE_RGB666                2
+#define DUMB_MODE_RGB666_UPPER          3
+#define DUMB_MODE_RGB444                4
+#define DUMB_MODE_RGB444_UPPER          5
+#define DUMB_MODE_RGB888                6
+
+/* default fb buffer size WVGA-32bits */
+#define DEFAULT_FB_SIZE (800 * 480 * 4)
+
+/*
+ * Buffer pixel format
+ * bit0 is for rb swap.
+ * bit12 is for Y UorV swap
+ */
+#define PIX_FMT_RGB565          0
+#define PIX_FMT_BGR565          1
+#define PIX_FMT_RGB1555         2
+#define PIX_FMT_BGR1555         3
+#define PIX_FMT_RGB888PACK      4
+#define PIX_FMT_BGR888PACK      5
+#define PIX_FMT_RGB888UNPACK    6
+#define PIX_FMT_BGR888UNPACK    7
+#define PIX_FMT_RGBA888         8
+#define PIX_FMT_BGRA888         9
+#define PIX_FMT_YUV422PACK      10
+#define PIX_FMT_YVU422PACK      11
+#define PIX_FMT_YUV422PLANAR    12
+#define PIX_FMT_YVU422PLANAR    13
+#define PIX_FMT_YUV420PLANAR    14
+#define PIX_FMT_YVU420PLANAR    15
+#define PIX_FMT_PSEUDOCOLOR     20
+#define PIX_FMT_UYVY422PACK     (0x1000|PIX_FMT_YUV422PACK)
+
+/*
+ * PXA LCD controller private state.
+ */
+struct pxa168fb_info {
+        struct device           *dev;
+        struct clk              *clk;
+        struct fb_info          *info;
+
+        void __iomem            *reg_base;
+        dma_addr_t              fb_start_dma;
+        u32                     pseudo_palette[16];
+
+        int                     pix_fmt;
+        unsigned                is_blanked:1;
+        unsigned                panel_rbswap:1;
+        unsigned                active:1;
+};
+
+/*
+ * PXA fb machine information
+ */
+struct pxa168fb_mach_info {
+        char    id[16];
+
+        int             num_modes;
+        struct fb_videomode *modes;
+
+        /*
+         * Pix_fmt
+         */
+        unsigned        pix_fmt;
+
+        /*
+         * I/O pin allocation.
+         */
+        unsigned        io_pin_allocation_mode:4;
+
+        /*
+         * Dumb panel -- assignment of R/G/B component info to the 24
+         * available external data lanes.
+         */
+        unsigned        dumb_mode:4;
+        unsigned        panel_rgb_reverse_lanes:1;
+
+        /*
+         * Dumb panel -- GPIO output data.
+         */
+        unsigned        gpio_output_mask:8;
+        unsigned        gpio_output_data:8;
+
+        /*
+         * Dumb panel -- configurable output signal polarity.
+         */
+        unsigned        invert_composite_blank:1;
+        unsigned        invert_pix_val_ena:1;
+        unsigned        invert_pixclock:1;
+        unsigned        invert_vsync:1;
+        unsigned        invert_hsync:1;
+        unsigned        panel_rbswap:1;
+        unsigned        active:1;
+        unsigned        enable_lcd:1;
+};
+
+#endif /* __ASM_MACH_PXA168FB_H */
diff --git a/include/video/s1d13xxxfb.h b/include/video/s1d13xxxfb.h
index c3b2a2aa7140..f0736cff2ca3 100644
--- a/include/video/s1d13xxxfb.h
+++ b/include/video/s1d13xxxfb.h
@@ -136,6 +136,15 @@
 #define S1DREG_DELAYOFF                 0xFFFE
 #define S1DREG_DELAYON                  0xFFFF
 
+#define BBLT_FIFO_EMPTY                 0x00
+#define BBLT_FIFO_NOT_EMPTY             0x40
+#define BBLT_FIFO_NOT_FULL              0x30
+#define BBLT_FIFO_HALF_FULL             0x20
+#define BBLT_FIFO_FULL                  0x10
+
+#define BBLT_SOLID_FILL                 0x0c
+
+
 /* Note: all above defines should go in separate header files
    when implementing other S1D13xxx chip support. */
 
diff --git a/include/xen/Kbuild b/include/xen/Kbuild
new file mode 100644
index 000000000000..4e65c16a445b
--- /dev/null
+++ b/include/xen/Kbuild
@@ -0,0 +1 @@
+header-y += evtchn.h
diff --git a/include/xen/events.h b/include/xen/events.h
index 0d5f1adc0363..e68d59a90ca8 100644
--- a/include/xen/events.h
+++ b/include/xen/events.h
@@ -53,4 +53,7 @@ bool xen_test_irq_pending(int irq);
    irq will be disabled so it won't deliver an interrupt. */
 void xen_poll_irq(int irq);
 
+/* Determine the IRQ which is bound to an event channel */
+unsigned irq_from_evtchn(unsigned int evtchn);
+
 #endif  /* _XEN_EVENTS_H */
diff --git a/include/xen/evtchn.h b/include/xen/evtchn.h
new file mode 100644
index 000000000000..14e833ee4e0b
--- /dev/null
+++ b/include/xen/evtchn.h
@@ -0,0 +1,88 @@
+/******************************************************************************
+ * evtchn.h
+ *
+ * Interface to /dev/xen/evtchn.
+ *
+ * Copyright (c) 2003-2005, K A Fraser
+ *
+ * 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; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef __LINUX_PUBLIC_EVTCHN_H__
+#define __LINUX_PUBLIC_EVTCHN_H__
+
+/*
+ * Bind a fresh port to VIRQ @virq.
+ * Return allocated port.
+ */
+#define IOCTL_EVTCHN_BIND_VIRQ                          \
+        _IOC(_IOC_NONE, 'E', 0, sizeof(struct ioctl_evtchn_bind_virq))
+struct ioctl_evtchn_bind_virq {
+        unsigned int virq;
+};
+
+/*
+ * Bind a fresh port to remote <@remote_domain, @remote_port>.
+ * Return allocated port.
+ */
+#define IOCTL_EVTCHN_BIND_INTERDOMAIN                   \
+        _IOC(_IOC_NONE, 'E', 1, sizeof(struct ioctl_evtchn_bind_interdomain))
+struct ioctl_evtchn_bind_interdomain {
+        unsigned int remote_domain, remote_port;
+};
+
+/*
+ * Allocate a fresh port for binding to @remote_domain.
+ * Return allocated port.
+ */
+#define IOCTL_EVTCHN_BIND_UNBOUND_PORT                  \
+        _IOC(_IOC_NONE, 'E', 2, sizeof(struct ioctl_evtchn_bind_unbound_port))
+struct ioctl_evtchn_bind_unbound_port {
+        unsigned int remote_domain;
+};
+
+/*
+ * Unbind previously allocated @port.
+ */
+#define IOCTL_EVTCHN_UNBIND                             \
+        _IOC(_IOC_NONE, 'E', 3, sizeof(struct ioctl_evtchn_unbind))
+struct ioctl_evtchn_unbind {
+        unsigned int port;
+};
+
+/*
+ * Unbind previously allocated @port.
+ */
+#define IOCTL_EVTCHN_NOTIFY                             \
+        _IOC(_IOC_NONE, 'E', 4, sizeof(struct ioctl_evtchn_notify))
+struct ioctl_evtchn_notify {
+        unsigned int port;
+};
+
+/* Clear and reinitialise the event buffer. Clear error condition. */
+#define IOCTL_EVTCHN_RESET                              \
+        _IOC(_IOC_NONE, 'E', 5, 0)
+
+#endif /* __LINUX_PUBLIC_EVTCHN_H__ */
diff --git a/include/xen/interface/version.h b/include/xen/interface/version.h
index 453235e923f0..e8b6519d47e9 100644
--- a/include/xen/interface/version.h
+++ b/include/xen/interface/version.h
@@ -57,4 +57,7 @@ struct xen_feature_info {
 /* Declares the features reported by XENVER_get_features. */
 #include "features.h"
 
+/* arg == NULL; returns host memory page size. */
+#define XENVER_pagesize 7
+
 #endif /* __XEN_PUBLIC_VERSION_H__ */
diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h
index f87f9614844d..b9763badbd77 100644
--- a/include/xen/xenbus.h
+++ b/include/xen/xenbus.h
@@ -91,8 +91,7 @@ struct xenbus_driver {
         void (*otherend_changed)(struct xenbus_device *dev,
                                  enum xenbus_state backend_state);
         int (*remove)(struct xenbus_device *dev);
-        int (*suspend)(struct xenbus_device *dev);
-        int (*suspend_cancel)(struct xenbus_device *dev);
+        int (*suspend)(struct xenbus_device *dev, pm_message_t state);
         int (*resume)(struct xenbus_device *dev);
         int (*uevent)(struct xenbus_device *, char **, int, char *, int);
         struct device_driver driver;