107 files changed, 2729 insertions, 1129 deletions
diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index 19c3ead2a90b..fb7171b1bd22 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -168,7 +168,8 @@ struct acpi_device_flags {
        u32 power_manageable:1;
        u32 performance_manageable:1;
        u32 wake_capable:1;     /* Wakeup(_PRW) supported? */
-        u32 reserved:20;
+        u32 force_power_state:1;
+        u32 reserved:19;
 };
 /* File System */
@@ -318,7 +319,7 @@ struct acpi_bus_event {
        u32 data;
 };
-extern struct kset acpi_subsys;
+extern struct kobject *acpi_kobj;
 extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
 /*
 * External Functions
diff --git a/include/asm-arm/arch-pxa/hardware.h b/include/asm-arm/arch-pxa/hardware.h
index ab2d963e742a..e25558faa5a4 100644
--- a/include/asm-arm/arch-pxa/hardware.h
+++ b/include/asm-arm/arch-pxa/hardware.h
@@ -121,38 +121,32 @@
 #define cpu_is_pxa21x()                                 \
        ({                                              \
-                unsigned int id = read_cpuid(CPUID_ID); \
+                __cpu_is_pxa21x(read_cpuid_id());       \
-                __cpu_is_pxa21x(id);                    \
        })
 #define cpu_is_pxa25x()                                 \
        ({                                              \
-                unsigned int id = read_cpuid(CPUID_ID); \
+                __cpu_is_pxa25x(read_cpuid_id());       \
-                __cpu_is_pxa25x(id);                    \
        })
 #define cpu_is_pxa27x()                                 \
        ({                                              \
-                unsigned int id = read_cpuid(CPUID_ID); \
+                __cpu_is_pxa27x(read_cpuid_id());       \
-                __cpu_is_pxa27x(id);                    \
        })
 #define cpu_is_pxa300()                                 \
        ({                                              \
-                unsigned int id = read_cpuid(CPUID_ID); \
+                __cpu_is_pxa300(read_cpuid_id());       \
-                __cpu_is_pxa300(id);                    \
         })
 #define cpu_is_pxa310()                                 \
        ({                                              \
-                unsigned int id = read_cpuid(CPUID_ID); \
+                __cpu_is_pxa310(read_cpuid_id());       \
-                __cpu_is_pxa310(id);                    \
         })
 #define cpu_is_pxa320()                                 \
        ({                                              \
-                unsigned int id = read_cpuid(CPUID_ID); \
+                __cpu_is_pxa320(read_cpuid_id());       \
-                __cpu_is_pxa320(id);                    \
         })
 /*
@@ -174,14 +168,12 @@
 #define cpu_is_pxa2xx()                                 \
        ({                                              \
-                unsigned int id = read_cpuid(CPUID_ID); \
+                __cpu_is_pxa2xx(read_cpuid_id());       \
-                __cpu_is_pxa2xx(id);                    \
         })
 #define cpu_is_pxa3xx()                                 \
        ({                                              \
-                unsigned int id = read_cpuid(CPUID_ID); \
+                __cpu_is_pxa3xx(read_cpuid_id());       \
-                __cpu_is_pxa3xx(id);                    \
         })
 /*
diff --git a/include/asm-arm/system.h b/include/asm-arm/system.h
index 94ea8c6dc1a4..28425c473e71 100644
--- a/include/asm-arm/system.h
+++ b/include/asm-arm/system.h
@@ -75,8 +75,21 @@
 #ifndef __ASSEMBLY__
 #include <linux/linkage.h>
+#include <linux/stringify.h>
 #include <linux/irqflags.h>
+/*
+ * The CPU ID never changes at run time, so we might as well tell the
+ * compiler that it's constant.  Use this function to read the CPU ID
+ * rather than directly reading processor_id or read_cpuid() directly.
+ */
+static inline unsigned int read_cpuid_id(void) __attribute_const__;
+static inline unsigned int read_cpuid_id(void)
+{
+        return read_cpuid(CPUID_ID);
+}
 #define __exception     __attribute__((section(".exception.text")))
 struct thread_info;
diff --git a/include/asm-avr32/arch-at32ap/at32ap7000.h b/include/asm-avr32/arch-at32ap/at32ap700x.h
index 3914d7b94ff4..99684d6f3967 100644
--- a/include/asm-avr32/arch-at32ap/at32ap7000.h
+++ b/include/asm-avr32/arch-at32ap/at32ap700x.h
@@ -7,8 +7,8 @@
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
-#ifndef __ASM_ARCH_AT32AP7000_H__
+#ifndef __ASM_ARCH_AT32AP700X_H__
-#define __ASM_ARCH_AT32AP7000_H__
+#define __ASM_ARCH_AT32AP700X_H__
 #define GPIO_PERIPH_A   0
 #define GPIO_PERIPH_B   1
@@ -32,4 +32,4 @@
 #define GPIO_PIN_PD(N)  (GPIO_PIOD_BASE + (N))
 #define GPIO_PIN_PE(N)  (GPIO_PIOE_BASE + (N))
-#endif /* __ASM_ARCH_AT32AP7000_H__ */
+#endif /* __ASM_ARCH_AT32AP700X_H__ */
diff --git a/include/asm-avr32/arch-at32ap/cpu.h b/include/asm-avr32/arch-at32ap/cpu.h
index a762f42cbb71..0dc20261c1ea 100644
--- a/include/asm-avr32/arch-at32ap/cpu.h
+++ b/include/asm-avr32/arch-at32ap/cpu.h
@@ -14,7 +14,7 @@
 * Only AT32AP7000 is defined for now. We can identify the specific
 * chip at runtime, but I'm not sure if it's really worth it.
 */
-#ifdef CONFIG_CPU_AT32AP7000
+#ifdef CONFIG_CPU_AT32AP700X
 # define cpu_is_at32ap7000()    (1)
 #else
 # define cpu_is_at32ap7000()    (0)
diff --git a/include/asm-avr32/arch-at32ap/io.h b/include/asm-avr32/arch-at32ap/io.h
index ee59e401f041..4ec6abc68ea3 100644
--- a/include/asm-avr32/arch-at32ap/io.h
+++ b/include/asm-avr32/arch-at32ap/io.h
@@ -4,7 +4,7 @@
 /* For "bizarre" halfword swapping */
 #include <linux/byteorder/swabb.h>
-#if defined(CONFIG_AP7000_32_BIT_SMC)
+#if defined(CONFIG_AP700X_32_BIT_SMC)
 # define __swizzle_addr_b(addr) (addr ^ 3UL)
 # define __swizzle_addr_w(addr) (addr ^ 2UL)
 # define __swizzle_addr_l(addr) (addr)
@@ -14,7 +14,7 @@
 # define __mem_ioswabb(a, x)    (x)
 # define __mem_ioswabw(a, x)    swab16(x)
 # define __mem_ioswabl(a, x)    swab32(x)
-#elif defined(CONFIG_AP7000_16_BIT_SMC)
+#elif defined(CONFIG_AP700X_16_BIT_SMC)
 # define __swizzle_addr_b(addr) (addr ^ 1UL)
 # define __swizzle_addr_w(addr) (addr)
 # define __swizzle_addr_l(addr) (addr)
diff --git a/include/asm-avr32/irq.h b/include/asm-avr32/irq.h
index 83e6549d7783..9315724c0596 100644
--- a/include/asm-avr32/irq.h
+++ b/include/asm-avr32/irq.h
@@ -11,4 +11,9 @@
 #define irq_canonicalize(i)     (i)
+#ifndef __ASSEMBLER__
+int nmi_enable(void);
+void nmi_disable(void);
+#endif
 #endif /* __ASM_AVR32_IOCTLS_H */
diff --git a/include/asm-avr32/kdebug.h b/include/asm-avr32/kdebug.h
index fd7e99046b2f..ca4f9542365a 100644
--- a/include/asm-avr32/kdebug.h
+++ b/include/asm-avr32/kdebug.h
@@ -5,6 +5,7 @@
 enum die_val {
        DIE_BREAKPOINT,
        DIE_SSTEP,
+        DIE_NMI,
 };
 #endif /* __ASM_AVR32_KDEBUG_H */
diff --git a/include/asm-avr32/ocd.h b/include/asm-avr32/ocd.h
index 996405e0393f..6bef09490235 100644
--- a/include/asm-avr32/ocd.h
+++ b/include/asm-avr32/ocd.h
@@ -533,6 +533,11 @@ static inline void __ocd_write(unsigned int reg, unsigned long value)
 #define ocd_read(reg)                   __ocd_read(OCD_##reg)
 #define ocd_write(reg, value)           __ocd_write(OCD_##reg, value)
+struct task_struct;
+void ocd_enable(struct task_struct *child);
+void ocd_disable(struct task_struct *child);
 #endif /* !__ASSEMBLER__ */
 #endif /* __ASM_AVR32_OCD_H */
diff --git a/include/asm-avr32/processor.h b/include/asm-avr32/processor.h
index a52576b25afe..4212551c1cd9 100644
--- a/include/asm-avr32/processor.h
+++ b/include/asm-avr32/processor.h
@@ -57,11 +57,25 @@ struct avr32_cpuinfo {
        unsigned short cpu_revision;
        enum tlb_config tlb_config;
        unsigned long features;
+        u32 device_id;
        struct cache_info icache;
        struct cache_info dcache;
 };
+static inline unsigned int avr32_get_manufacturer_id(struct avr32_cpuinfo *cpu)
+{
+        return (cpu->device_id >> 1) & 0x7f;
+}
+static inline unsigned int avr32_get_product_number(struct avr32_cpuinfo *cpu)
+{
+        return (cpu->device_id >> 12) & 0xffff;
+}
+static inline unsigned int avr32_get_chip_revision(struct avr32_cpuinfo *cpu)
+{
+        return (cpu->device_id >> 28) & 0x0f;
+}
 extern struct avr32_cpuinfo boot_cpu_data;
 #ifdef CONFIG_SMP
diff --git a/include/asm-avr32/ptrace.h b/include/asm-avr32/ptrace.h
index 8c5dba5e33df..9e2d44f4e0fe 100644
--- a/include/asm-avr32/ptrace.h
+++ b/include/asm-avr32/ptrace.h
@@ -121,7 +121,15 @@ struct pt_regs {
 };
 #ifdef __KERNEL__
-# define user_mode(regs) (((regs)->sr & MODE_MASK) == MODE_USER)
+#include <asm/ocd.h>
+#define arch_ptrace_attach(child)       ocd_enable(child)
+#define user_mode(regs)                 (((regs)->sr & MODE_MASK) == MODE_USER)
+#define instruction_pointer(regs)       ((regs)->pc)
+#define profile_pc(regs)                instruction_pointer(regs)
 extern void show_regs (struct pt_regs *);
 static __inline__ int valid_user_regs(struct pt_regs *regs)
@@ -141,9 +149,6 @@ static __inline__ int valid_user_regs(struct pt_regs *regs)
        return 0;
 }
-#define instruction_pointer(regs) ((regs)->pc)
-#define profile_pc(regs) instruction_pointer(regs)
 #endif /* __KERNEL__ */
diff --git a/include/asm-avr32/thread_info.h b/include/asm-avr32/thread_info.h
index 184b574289b4..07049f6c0d41 100644
--- a/include/asm-avr32/thread_info.h
+++ b/include/asm-avr32/thread_info.h
@@ -88,6 +88,7 @@ static inline struct thread_info *current_thread_info(void)
 #define TIF_MEMDIE              6
 #define TIF_RESTORE_SIGMASK     7       /* restore signal mask in do_signal */
 #define TIF_CPU_GOING_TO_SLEEP  8       /* CPU is entering sleep 0 mode */
+#define TIF_DEBUG               30      /* debugging enabled */
 #define TIF_USERSPACE           31      /* true if FS sets userspace */
 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)
diff --git a/include/asm-cris/arch-v10/ide.h b/include/asm-cris/arch-v10/ide.h
index 78b301ed7b12..ea34e0d0a388 100644
--- a/include/asm-cris/arch-v10/ide.h
+++ b/include/asm-cris/arch-v10/ide.h
@@ -89,11 +89,6 @@ static inline void ide_init_default_hwifs(void)
        }
 }
-/* some configuration options we don't need */
-#undef SUPPORT_VLB_SYNC
-#define SUPPORT_VLB_SYNC 0
 #endif /* __KERNEL__ */
 #endif /* __ASMCRIS_IDE_H */
diff --git a/include/asm-cris/arch-v32/ide.h b/include/asm-cris/arch-v32/ide.h
index 11296170d057..fb9c3627a5b4 100644
--- a/include/asm-cris/arch-v32/ide.h
+++ b/include/asm-cris/arch-v32/ide.h
@@ -48,11 +48,6 @@ static inline unsigned long ide_default_io_base(int index)
        return REG_TYPE_CONV(unsigned long, reg_ata_rw_ctrl2, ctrl2);
 }
-/* some configuration options we don't need */
-#undef SUPPORT_VLB_SYNC
-#define SUPPORT_VLB_SYNC 0
 #define IDE_ARCH_ACK_INTR
 #define ide_ack_intr(hwif)      ((hwif)->ack_intr(hwif))
diff --git a/include/asm-cris/page.h b/include/asm-cris/page.h
index 0648e3153f81..b84353ef6998 100644
--- a/include/asm-cris/page.h
+++ b/include/asm-cris/page.h
@@ -4,14 +4,11 @@
 #ifdef __KERNEL__
 #include <asm/arch/page.h>
+#include <linux/const.h>
 /* PAGE_SHIFT determines the page size */
 #define PAGE_SHIFT      13
-#ifndef __ASSEMBLY__
+#define PAGE_SIZE       (_AC(1, UL) << PAGE_SHIFT)
-#define PAGE_SIZE       (1UL << PAGE_SHIFT)
-#else
-#define PAGE_SIZE       (1 << PAGE_SHIFT)
-#endif
 #define PAGE_MASK       (~(PAGE_SIZE-1))
 #define clear_page(page)        memset((void *)(page), 0, PAGE_SIZE)
diff --git a/include/asm-cris/unistd.h b/include/asm-cris/unistd.h
index 6f2d924f4fd6..bd57a7949170 100644
--- a/include/asm-cris/unistd.h
+++ b/include/asm-cris/unistd.h
@@ -358,6 +358,7 @@
 #define __ARCH_WANT_SYS_SIGPENDING
 #define __ARCH_WANT_SYS_SIGPROCMASK
 #define __ARCH_WANT_SYS_RT_SIGACTION
+#define __ARCH_WANT_SYS_RT_SIGSUSPEND
 /*
 * "Conditional" syscalls
diff --git a/include/asm-frv/ide.h b/include/asm-frv/ide.h
index f0bd2cb250c1..8c9a540d4344 100644
--- a/include/asm-frv/ide.h
+++ b/include/asm-frv/ide.h
@@ -18,12 +18,6 @@
 #include <asm/io.h>
 #include <asm/irq.h>
-#undef SUPPORT_SLOW_DATA_PORTS
-#define SUPPORT_SLOW_DATA_PORTS 0
-#undef SUPPORT_VLB_SYNC
-#define SUPPORT_VLB_SYNC 0
 #ifndef MAX_HWIFS
 #define MAX_HWIFS 8
 #endif
diff --git a/include/asm-generic/resource.h b/include/asm-generic/resource.h
index a4a22cc35898..587566f95f6c 100644
--- a/include/asm-generic/resource.h
+++ b/include/asm-generic/resource.h
@@ -44,8 +44,8 @@
 #define RLIMIT_NICE             13      /* max nice prio allowed to raise to
                                           0-39 for nice level 19 .. -20 */
 #define RLIMIT_RTPRIO           14      /* maximum realtime priority */
+#define RLIMIT_RTTIME           15      /* timeout for RT tasks in us */
-#define RLIM_NLIMITS            15
+#define RLIM_NLIMITS            16
 /*
 * SuS says limits have to be unsigned.
@@ -86,6 +86,7 @@
        [RLIMIT_MSGQUEUE]       = {   MQ_BYTES_MAX,   MQ_BYTES_MAX },   \
        [RLIMIT_NICE]           = { 0, 0 },                             \
        [RLIMIT_RTPRIO]         = { 0, 0 },                             \
+        [RLIMIT_RTTIME]         = {  RLIM_INFINITY,  RLIM_INFINITY },   \
 }
 #endif  /* __KERNEL__ */
diff --git a/include/asm-mips/cacheops.h b/include/asm-mips/cacheops.h
index df7f2deb3b56..256ad2cc6eb8 100644
--- a/include/asm-mips/cacheops.h
+++ b/include/asm-mips/cacheops.h
@@ -64,7 +64,7 @@
 #define Page_Invalidate_T       0x16
 /*
- * R1000-specific cacheops
+ * R10000-specific cacheops
 *
 * Cacheops 0x02, 0x06, 0x0a, 0x0c-0x0e, 0x16, 0x1a and 0x1e are unused.
 * Most of the _S cacheops are identical to the R4000SC _SD cacheops.
diff --git a/include/asm-mips/smtc_ipi.h b/include/asm-mips/smtc_ipi.h
index e09131a6127d..8ce517574340 100644
--- a/include/asm-mips/smtc_ipi.h
+++ b/include/asm-mips/smtc_ipi.h
@@ -49,7 +49,7 @@ struct smtc_ipi_q {
 static inline void smtc_ipi_nq(struct smtc_ipi_q *q, struct smtc_ipi *p)
 {
-        long flags;
+        unsigned long flags;
        spin_lock_irqsave(&q->lock, flags);
        if (q->head == NULL)
@@ -98,7 +98,7 @@ static inline struct smtc_ipi *smtc_ipi_dq(struct smtc_ipi_q *q)
 static inline void smtc_ipi_req(struct smtc_ipi_q *q, struct smtc_ipi *p)
 {
-        long flags;
+        unsigned long flags;
        spin_lock_irqsave(&q->lock, flags);
        if (q->head == NULL) {
@@ -114,7 +114,7 @@ static inline void smtc_ipi_req(struct smtc_ipi_q *q, struct smtc_ipi *p)
 static inline int smtc_ipi_qdepth(struct smtc_ipi_q *q)
 {
-        long flags;
+        unsigned long flags;
        int retval;
        spin_lock_irqsave(&q->lock, flags);
diff --git a/include/asm-powerpc/ide.h b/include/asm-powerpc/ide.h
index fd7f5a430f0a..6d50310ecaea 100644
--- a/include/asm-powerpc/ide.h
+++ b/include/asm-powerpc/ide.h
@@ -42,9 +42,6 @@ struct ide_machdep_calls {
 extern struct ide_machdep_calls ppc_ide_md;
-#undef  SUPPORT_SLOW_DATA_PORTS
-#define SUPPORT_SLOW_DATA_PORTS 0
 #define IDE_ARCH_OBSOLETE_DEFAULTS
 static __inline__ int ide_default_irq(unsigned long base)
diff --git a/include/asm-x86/msr.h b/include/asm-x86/msr.h
index 664a2fa7adc9..80b027081b3c 100644
--- a/include/asm-x86/msr.h
+++ b/include/asm-x86/msr.h
@@ -3,6 +3,10 @@
 #include <asm/msr-index.h>
+#ifndef __ASSEMBLY__
+# include <linux/types.h>
+#endif
 #ifdef __i386__
 #ifdef __KERNEL__
diff --git a/include/asm-x86/thread_info_32.h b/include/asm-x86/thread_info_32.h
index 22a8cbcd35e2..ef58fd2a6eb0 100644
--- a/include/asm-x86/thread_info_32.h
+++ b/include/asm-x86/thread_info_32.h
@@ -132,6 +132,7 @@ static inline struct thread_info *current_thread_info(void)
 #define TIF_SYSCALL_AUDIT       6       /* syscall auditing active */
 #define TIF_SECCOMP             7       /* secure computing */
 #define TIF_RESTORE_SIGMASK     8       /* restore signal mask in do_signal() */
+#define TIF_HRTICK_RESCHED      9       /* reprogram hrtick timer */
 #define TIF_MEMDIE              16
 #define TIF_DEBUG               17      /* uses debug registers */
 #define TIF_IO_BITMAP           18      /* uses I/O bitmap */
@@ -147,6 +148,7 @@ static inline struct thread_info *current_thread_info(void)
 #define _TIF_SYSCALL_AUDIT      (1<<TIF_SYSCALL_AUDIT)
 #define _TIF_SECCOMP            (1<<TIF_SECCOMP)
 #define _TIF_RESTORE_SIGMASK    (1<<TIF_RESTORE_SIGMASK)
+#define _TIF_HRTICK_RESCHED     (1<<TIF_HRTICK_RESCHED)
 #define _TIF_DEBUG              (1<<TIF_DEBUG)
 #define _TIF_IO_BITMAP          (1<<TIF_IO_BITMAP)
 #define _TIF_FREEZE             (1<<TIF_FREEZE)
diff --git a/include/asm-x86/thread_info_64.h b/include/asm-x86/thread_info_64.h
index beae2bfb62ca..7f6ee68f0002 100644
--- a/include/asm-x86/thread_info_64.h
+++ b/include/asm-x86/thread_info_64.h
@@ -115,6 +115,7 @@ static inline struct thread_info *stack_thread_info(void)
 #define TIF_SECCOMP             8       /* secure computing */
 #define TIF_RESTORE_SIGMASK     9       /* restore signal mask in do_signal */
 #define TIF_MCE_NOTIFY          10      /* notify userspace of an MCE */
+#define TIF_HRTICK_RESCHED      11      /* reprogram hrtick timer */
 /* 16 free */
 #define TIF_IA32                17      /* 32bit process */ 
 #define TIF_FORK                18      /* ret_from_fork */
@@ -133,6 +134,7 @@ static inline struct thread_info *stack_thread_info(void)
 #define _TIF_SECCOMP            (1<<TIF_SECCOMP)
 #define _TIF_RESTORE_SIGMASK    (1<<TIF_RESTORE_SIGMASK)
 #define _TIF_MCE_NOTIFY         (1<<TIF_MCE_NOTIFY)
+#define _TIF_HRTICK_RESCHED     (1<<TIF_HRTICK_RESCHED)
 #define _TIF_IA32               (1<<TIF_IA32)
 #define _TIF_FORK               (1<<TIF_FORK)
 #define _TIF_ABI_PENDING        (1<<TIF_ABI_PENDING)
@@ -146,6 +148,9 @@ static inline struct thread_info *stack_thread_info(void)
 /* work to do on any return to user space */
 #define _TIF_ALLWORK_MASK (0x0000FFFF & ~_TIF_SECCOMP)
+#define _TIF_DO_NOTIFY_MASK \
+        (_TIF_SIGPENDING|_TIF_SINGLESTEP|_TIF_MCE_NOTIFY|_TIF_HRTICK_RESCHED)
 /* flags to check in __switch_to() */
 #define _TIF_WORK_CTXSW (_TIF_DEBUG|_TIF_IO_BITMAP)
diff --git a/include/crypto/aead.h b/include/crypto/aead.h
new file mode 100644
index 000000000000..0edf949f6369
--- /dev/null
+++ b/include/crypto/aead.h
@@ -0,0 +1,105 @@
+/*
+ * AEAD: Authenticated Encryption with Associated Data
+ * 
+ * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * 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 _CRYPTO_AEAD_H
+#define _CRYPTO_AEAD_H
+#include <linux/crypto.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+/**
+ *      struct aead_givcrypt_request - AEAD request with IV generation
+ *      @seq: Sequence number for IV generation
+ *      @giv: Space for generated IV
+ *      @areq: The AEAD request itself
+ */
+struct aead_givcrypt_request {
+        u64 seq;
+        u8 *giv;
+        struct aead_request areq;
+};
+static inline struct crypto_aead *aead_givcrypt_reqtfm(
+        struct aead_givcrypt_request *req)
+{
+        return crypto_aead_reqtfm(&req->areq);
+}
+static inline int crypto_aead_givencrypt(struct aead_givcrypt_request *req)
+{
+        struct aead_tfm *crt = crypto_aead_crt(aead_givcrypt_reqtfm(req));
+        return crt->givencrypt(req);
+};
+static inline int crypto_aead_givdecrypt(struct aead_givcrypt_request *req)
+{
+        struct aead_tfm *crt = crypto_aead_crt(aead_givcrypt_reqtfm(req));
+        return crt->givdecrypt(req);
+};
+static inline void aead_givcrypt_set_tfm(struct aead_givcrypt_request *req,
+                                         struct crypto_aead *tfm)
+{
+        req->areq.base.tfm = crypto_aead_tfm(tfm);
+}
+static inline struct aead_givcrypt_request *aead_givcrypt_alloc(
+        struct crypto_aead *tfm, gfp_t gfp)
+{
+        struct aead_givcrypt_request *req;
+        req = kmalloc(sizeof(struct aead_givcrypt_request) +
+                      crypto_aead_reqsize(tfm), gfp);
+        if (likely(req))
+                aead_givcrypt_set_tfm(req, tfm);
+        return req;
+}
+static inline void aead_givcrypt_free(struct aead_givcrypt_request *req)
+{
+        kfree(req);
+}
+static inline void aead_givcrypt_set_callback(
+        struct aead_givcrypt_request *req, u32 flags,
+        crypto_completion_t complete, void *data)
+{
+        aead_request_set_callback(&req->areq, flags, complete, data);
+}
+static inline void aead_givcrypt_set_crypt(struct aead_givcrypt_request *req,
+                                           struct scatterlist *src,
+                                           struct scatterlist *dst,
+                                           unsigned int nbytes, void *iv)
+{
+        aead_request_set_crypt(&req->areq, src, dst, nbytes, iv);
+}
+static inline void aead_givcrypt_set_assoc(struct aead_givcrypt_request *req,
+                                           struct scatterlist *assoc,
+                                           unsigned int assoclen)
+{
+        aead_request_set_assoc(&req->areq, assoc, assoclen);
+}
+static inline void aead_givcrypt_set_giv(struct aead_givcrypt_request *req,
+                                         u8 *giv, u64 seq)
+{
+        req->giv = giv;
+        req->seq = seq;
+}
+#endif  /* _CRYPTO_AEAD_H */
diff --git a/include/crypto/aes.h b/include/crypto/aes.h
new file mode 100644
index 000000000000..d480b76715a8
--- /dev/null
+++ b/include/crypto/aes.h
@@ -0,0 +1,31 @@
+/*
+ * Common values for AES algorithms
+ */
+#ifndef _CRYPTO_AES_H
+#define _CRYPTO_AES_H
+#include <linux/types.h>
+#include <linux/crypto.h>
+#define AES_MIN_KEY_SIZE        16
+#define AES_MAX_KEY_SIZE        32
+#define AES_KEYSIZE_128         16
+#define AES_KEYSIZE_192         24
+#define AES_KEYSIZE_256         32
+#define AES_BLOCK_SIZE          16
+struct crypto_aes_ctx {
+        u32 key_length;
+        u32 key_enc[60];
+        u32 key_dec[60];
+};
+extern u32 crypto_ft_tab[4][256];
+extern u32 crypto_fl_tab[4][256];
+extern u32 crypto_it_tab[4][256];
+extern u32 crypto_il_tab[4][256];
+int crypto_aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
+                unsigned int key_len);
+#endif
diff --git a/include/crypto/algapi.h b/include/crypto/algapi.h
index b9b05d399d2b..60d06e784be3 100644
--- a/include/crypto/algapi.h
+++ b/include/crypto/algapi.h
@@ -111,8 +111,15 @@ void crypto_drop_spawn(struct crypto_spawn *spawn);
 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
                                    u32 mask);
+static inline void crypto_set_spawn(struct crypto_spawn *spawn,
+                                    struct crypto_instance *inst)
+{
+        spawn->inst = inst;
+}
 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb);
 int crypto_check_attr_type(struct rtattr **tb, u32 type);
+const char *crypto_attr_alg_name(struct rtattr *rta);
 struct crypto_alg *crypto_attr_alg(struct rtattr *rta, u32 type, u32 mask);
 int crypto_attr_u32(struct rtattr *rta, u32 *num);
 struct crypto_instance *crypto_alloc_instance(const char *name,
@@ -124,6 +131,10 @@ int crypto_enqueue_request(struct crypto_queue *queue,
 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue);
 int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm);
+/* These functions require the input/output to be aligned as u32. */
+void crypto_inc(u8 *a, unsigned int size);
+void crypto_xor(u8 *dst, const u8 *src, unsigned int size);
 int blkcipher_walk_done(struct blkcipher_desc *desc,
                        struct blkcipher_walk *walk, int err);
 int blkcipher_walk_virt(struct blkcipher_desc *desc,
@@ -187,20 +198,11 @@ static inline struct crypto_instance *crypto_aead_alg_instance(
        return crypto_tfm_alg_instance(&aead->base);
 }
-static inline struct crypto_ablkcipher *crypto_spawn_ablkcipher(
-        struct crypto_spawn *spawn)
-{
-        u32 type = CRYPTO_ALG_TYPE_BLKCIPHER;
-        u32 mask = CRYPTO_ALG_TYPE_MASK;
-        return __crypto_ablkcipher_cast(crypto_spawn_tfm(spawn, type, mask));
-}
 static inline struct crypto_blkcipher *crypto_spawn_blkcipher(
        struct crypto_spawn *spawn)
 {
        u32 type = CRYPTO_ALG_TYPE_BLKCIPHER;
-        u32 mask = CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC;
+        u32 mask = CRYPTO_ALG_TYPE_MASK;
        return __crypto_blkcipher_cast(crypto_spawn_tfm(spawn, type, mask));
 }
@@ -303,5 +305,14 @@ static inline struct crypto_alg *crypto_get_attr_alg(struct rtattr **tb,
        return crypto_attr_alg(tb[1], type, mask);
 }
+/*
+ * Returns CRYPTO_ALG_ASYNC if type/mask requires the use of sync algorithms.
+ * Otherwise returns zero.
+ */
+static inline int crypto_requires_sync(u32 type, u32 mask)
+{
+        return (type ^ CRYPTO_ALG_ASYNC) & mask & CRYPTO_ALG_ASYNC;
+}
 #endif  /* _CRYPTO_ALGAPI_H */
diff --git a/include/crypto/authenc.h b/include/crypto/authenc.h
new file mode 100644
index 000000000000..e47b044929a8
--- /dev/null
+++ b/include/crypto/authenc.h
@@ -0,0 +1,27 @@
+/*
+ * Authenc: Simple AEAD wrapper for IPsec
+ *
+ * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * 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 _CRYPTO_AUTHENC_H
+#define _CRYPTO_AUTHENC_H
+#include <linux/types.h>
+enum {
+        CRYPTO_AUTHENC_KEYA_UNSPEC,
+        CRYPTO_AUTHENC_KEYA_PARAM,
+};
+struct crypto_authenc_key_param {
+        __be32 enckeylen;
+};
+#endif  /* _CRYPTO_AUTHENC_H */
diff --git a/include/crypto/ctr.h b/include/crypto/ctr.h
new file mode 100644
index 000000000000..4180fc080e3b
--- /dev/null
+++ b/include/crypto/ctr.h
@@ -0,0 +1,20 @@
+/*
+ * CTR: Counter mode
+ *
+ * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * 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 _CRYPTO_CTR_H
+#define _CRYPTO_CTR_H
+#define CTR_RFC3686_NONCE_SIZE 4
+#define CTR_RFC3686_IV_SIZE 8
+#define CTR_RFC3686_BLOCK_SIZE 16
+#endif  /* _CRYPTO_CTR_H */
diff --git a/include/crypto/des.h b/include/crypto/des.h
new file mode 100644
index 000000000000..2971c6304ade
--- /dev/null
+++ b/include/crypto/des.h
@@ -0,0 +1,19 @@
+/* 
+ * DES & Triple DES EDE Cipher Algorithms.
+ */
+#ifndef __CRYPTO_DES_H
+#define __CRYPTO_DES_H
+#define DES_KEY_SIZE            8
+#define DES_EXPKEY_WORDS        32
+#define DES_BLOCK_SIZE          8
+#define DES3_EDE_KEY_SIZE       (3 * DES_KEY_SIZE)
+#define DES3_EDE_EXPKEY_WORDS   (3 * DES_EXPKEY_WORDS)
+#define DES3_EDE_BLOCK_SIZE     DES_BLOCK_SIZE
+extern unsigned long des_ekey(u32 *pe, const u8 *k);
+#endif /* __CRYPTO_DES_H */
diff --git a/include/crypto/internal/aead.h b/include/crypto/internal/aead.h
new file mode 100644
index 000000000000..d838c945575a
--- /dev/null
+++ b/include/crypto/internal/aead.h
@@ -0,0 +1,80 @@
+/*
+ * AEAD: Authenticated Encryption with Associated Data
+ * 
+ * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * 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 _CRYPTO_INTERNAL_AEAD_H
+#define _CRYPTO_INTERNAL_AEAD_H
+#include <crypto/aead.h>
+#include <crypto/algapi.h>
+#include <linux/types.h>
+struct rtattr;
+struct crypto_aead_spawn {
+        struct crypto_spawn base;
+};
+extern const struct crypto_type crypto_nivaead_type;
+static inline void crypto_set_aead_spawn(
+        struct crypto_aead_spawn *spawn, struct crypto_instance *inst)
+{
+        crypto_set_spawn(&spawn->base, inst);
+}
+int crypto_grab_aead(struct crypto_aead_spawn *spawn, const char *name,
+                     u32 type, u32 mask);
+static inline void crypto_drop_aead(struct crypto_aead_spawn *spawn)
+{
+        crypto_drop_spawn(&spawn->base);
+}
+static inline struct crypto_alg *crypto_aead_spawn_alg(
+        struct crypto_aead_spawn *spawn)
+{
+        return spawn->base.alg;
+}
+static inline struct crypto_aead *crypto_spawn_aead(
+        struct crypto_aead_spawn *spawn)
+{
+        return __crypto_aead_cast(
+                crypto_spawn_tfm(&spawn->base, CRYPTO_ALG_TYPE_AEAD,
+                                 CRYPTO_ALG_TYPE_MASK));
+}
+struct crypto_instance *aead_geniv_alloc(struct crypto_template *tmpl,
+                                         struct rtattr **tb, u32 type,
+                                         u32 mask);
+void aead_geniv_free(struct crypto_instance *inst);
+int aead_geniv_init(struct crypto_tfm *tfm);
+void aead_geniv_exit(struct crypto_tfm *tfm);
+static inline struct crypto_aead *aead_geniv_base(struct crypto_aead *geniv)
+{
+        return crypto_aead_crt(geniv)->base;
+}
+static inline void *aead_givcrypt_reqctx(struct aead_givcrypt_request *req)
+{
+        return aead_request_ctx(&req->areq);
+}
+static inline void aead_givcrypt_complete(struct aead_givcrypt_request *req,
+                                          int err)
+{
+        aead_request_complete(&req->areq, err);
+}
+#endif  /* _CRYPTO_INTERNAL_AEAD_H */
diff --git a/include/crypto/internal/skcipher.h b/include/crypto/internal/skcipher.h
new file mode 100644
index 000000000000..2ba42cd7d6aa
--- /dev/null
+++ b/include/crypto/internal/skcipher.h
@@ -0,0 +1,110 @@
+/*
+ * Symmetric key ciphers.
+ * 
+ * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * 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 _CRYPTO_INTERNAL_SKCIPHER_H
+#define _CRYPTO_INTERNAL_SKCIPHER_H
+#include <crypto/algapi.h>
+#include <crypto/skcipher.h>
+#include <linux/types.h>
+struct rtattr;
+struct crypto_skcipher_spawn {
+        struct crypto_spawn base;
+};
+extern const struct crypto_type crypto_givcipher_type;
+static inline void crypto_set_skcipher_spawn(
+        struct crypto_skcipher_spawn *spawn, struct crypto_instance *inst)
+{
+        crypto_set_spawn(&spawn->base, inst);
+}
+int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name,
+                         u32 type, u32 mask);
+static inline void crypto_drop_skcipher(struct crypto_skcipher_spawn *spawn)
+{
+        crypto_drop_spawn(&spawn->base);
+}
+static inline struct crypto_alg *crypto_skcipher_spawn_alg(
+        struct crypto_skcipher_spawn *spawn)
+{
+        return spawn->base.alg;
+}
+static inline struct crypto_ablkcipher *crypto_spawn_skcipher(
+        struct crypto_skcipher_spawn *spawn)
+{
+        return __crypto_ablkcipher_cast(
+                crypto_spawn_tfm(&spawn->base, crypto_skcipher_type(0),
+                                 crypto_skcipher_mask(0)));
+}
+int skcipher_null_givencrypt(struct skcipher_givcrypt_request *req);
+int skcipher_null_givdecrypt(struct skcipher_givcrypt_request *req);
+const char *crypto_default_geniv(const struct crypto_alg *alg);
+struct crypto_instance *skcipher_geniv_alloc(struct crypto_template *tmpl,
+                                             struct rtattr **tb, u32 type,
+                                             u32 mask);
+void skcipher_geniv_free(struct crypto_instance *inst);
+int skcipher_geniv_init(struct crypto_tfm *tfm);
+void skcipher_geniv_exit(struct crypto_tfm *tfm);
+static inline struct crypto_ablkcipher *skcipher_geniv_cipher(
+        struct crypto_ablkcipher *geniv)
+{
+        return crypto_ablkcipher_crt(geniv)->base;
+}
+static inline int skcipher_enqueue_givcrypt(
+        struct crypto_queue *queue, struct skcipher_givcrypt_request *request)
+{
+        return ablkcipher_enqueue_request(queue, &request->creq);
+}
+static inline struct skcipher_givcrypt_request *skcipher_dequeue_givcrypt(
+        struct crypto_queue *queue)
+{
+        return container_of(ablkcipher_dequeue_request(queue),
+                            struct skcipher_givcrypt_request, creq);
+}
+static inline void *skcipher_givcrypt_reqctx(
+        struct skcipher_givcrypt_request *req)
+{
+        return ablkcipher_request_ctx(&req->creq);
+}
+static inline void ablkcipher_request_complete(struct ablkcipher_request *req,
+                                               int err)
+{
+        req->base.complete(&req->base, err);
+}
+static inline void skcipher_givcrypt_complete(
+        struct skcipher_givcrypt_request *req, int err)
+{
+        ablkcipher_request_complete(&req->creq, err);
+}
+static inline u32 ablkcipher_request_flags(struct ablkcipher_request *req)
+{
+        return req->base.flags;
+}
+#endif  /* _CRYPTO_INTERNAL_SKCIPHER_H */
diff --git a/include/crypto/scatterwalk.h b/include/crypto/scatterwalk.h
new file mode 100644
index 000000000000..224658b8d806
--- /dev/null
+++ b/include/crypto/scatterwalk.h
@@ -0,0 +1,119 @@
+/*
+ * Cryptographic scatter and gather helpers.
+ *
+ * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
+ * Copyright (c) 2002 Adam J. Richter <adam@yggdrasil.com>
+ * Copyright (c) 2004 Jean-Luc Cooke <jlcooke@certainkey.com>
+ * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * 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 _CRYPTO_SCATTERWALK_H
+#define _CRYPTO_SCATTERWALK_H
+#include <asm/kmap_types.h>
+#include <crypto/algapi.h>
+#include <linux/hardirq.h>
+#include <linux/highmem.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/scatterlist.h>
+#include <linux/sched.h>
+static inline enum km_type crypto_kmap_type(int out)
+{
+        enum km_type type;
+        if (in_softirq())
+                type = out * (KM_SOFTIRQ1 - KM_SOFTIRQ0) + KM_SOFTIRQ0;
+        else
+                type = out * (KM_USER1 - KM_USER0) + KM_USER0;
+        return type;
+}
+static inline void *crypto_kmap(struct page *page, int out)
+{
+        return kmap_atomic(page, crypto_kmap_type(out));
+}
+static inline void crypto_kunmap(void *vaddr, int out)
+{
+        kunmap_atomic(vaddr, crypto_kmap_type(out));
+}
+static inline void crypto_yield(u32 flags)
+{
+        if (flags & CRYPTO_TFM_REQ_MAY_SLEEP)
+                cond_resched();
+}
+static inline void scatterwalk_sg_chain(struct scatterlist *sg1, int num,
+                                        struct scatterlist *sg2)
+{
+        sg_set_page(&sg1[num - 1], (void *)sg2, 0, 0);
+}
+static inline struct scatterlist *scatterwalk_sg_next(struct scatterlist *sg)
+{
+        return (++sg)->length ? sg : (void *)sg_page(sg);
+}
+static inline unsigned long scatterwalk_samebuf(struct scatter_walk *walk_in,
+                                                struct scatter_walk *walk_out)
+{
+        return !(((sg_page(walk_in->sg) - sg_page(walk_out->sg)) << PAGE_SHIFT) +
+                 (int)(walk_in->offset - walk_out->offset));
+}
+static inline unsigned int scatterwalk_pagelen(struct scatter_walk *walk)
+{
+        unsigned int len = walk->sg->offset + walk->sg->length - walk->offset;
+        unsigned int len_this_page = offset_in_page(~walk->offset) + 1;
+        return len_this_page > len ? len : len_this_page;
+}
+static inline unsigned int scatterwalk_clamp(struct scatter_walk *walk,
+                                             unsigned int nbytes)
+{
+        unsigned int len_this_page = scatterwalk_pagelen(walk);
+        return nbytes > len_this_page ? len_this_page : nbytes;
+}
+static inline void scatterwalk_advance(struct scatter_walk *walk,
+                                       unsigned int nbytes)
+{
+        walk->offset += nbytes;
+}
+static inline unsigned int scatterwalk_aligned(struct scatter_walk *walk,
+                                               unsigned int alignmask)
+{
+        return !(walk->offset & alignmask);
+}
+static inline struct page *scatterwalk_page(struct scatter_walk *walk)
+{
+        return sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
+}
+static inline void scatterwalk_unmap(void *vaddr, int out)
+{
+        crypto_kunmap(vaddr, out);
+}
+void scatterwalk_start(struct scatter_walk *walk, struct scatterlist *sg);
+void scatterwalk_copychunks(void *buf, struct scatter_walk *walk,
+                            size_t nbytes, int out);
+void *scatterwalk_map(struct scatter_walk *walk, int out);
+void scatterwalk_done(struct scatter_walk *walk, int out, int more);
+void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,
+                              unsigned int start, unsigned int nbytes, int out);
+#endif  /* _CRYPTO_SCATTERWALK_H */
diff --git a/include/crypto/sha.h b/include/crypto/sha.h
index 0686e1f7a24b..c0ccc2b1a2d8 100644
--- a/include/crypto/sha.h
+++ b/include/crypto/sha.h
@@ -8,6 +8,9 @@
 #define SHA1_DIGEST_SIZE        20
 #define SHA1_BLOCK_SIZE         64
+#define SHA224_DIGEST_SIZE      28
+#define SHA224_BLOCK_SIZE       64
 #define SHA256_DIGEST_SIZE      32
 #define SHA256_BLOCK_SIZE       64
@@ -23,6 +26,15 @@
 #define SHA1_H3         0x10325476UL
 #define SHA1_H4         0xc3d2e1f0UL
+#define SHA224_H0       0xc1059ed8UL
+#define SHA224_H1       0x367cd507UL
+#define SHA224_H2       0x3070dd17UL
+#define SHA224_H3       0xf70e5939UL
+#define SHA224_H4       0xffc00b31UL
+#define SHA224_H5       0x68581511UL
+#define SHA224_H6       0x64f98fa7UL
+#define SHA224_H7       0xbefa4fa4UL
 #define SHA256_H0       0x6a09e667UL
 #define SHA256_H1       0xbb67ae85UL
 #define SHA256_H2       0x3c6ef372UL
diff --git a/include/crypto/skcipher.h b/include/crypto/skcipher.h
new file mode 100644
index 000000000000..25fd6126522d
--- /dev/null
+++ b/include/crypto/skcipher.h
@@ -0,0 +1,110 @@
+/*
+ * Symmetric key ciphers.
+ * 
+ * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
+ *
+ * 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 _CRYPTO_SKCIPHER_H
+#define _CRYPTO_SKCIPHER_H
+#include <linux/crypto.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+/**
+ *      struct skcipher_givcrypt_request - Crypto request with IV generation
+ *      @seq: Sequence number for IV generation
+ *      @giv: Space for generated IV
+ *      @creq: The crypto request itself
+ */
+struct skcipher_givcrypt_request {
+        u64 seq;
+        u8 *giv;
+        struct ablkcipher_request creq;
+};
+static inline struct crypto_ablkcipher *skcipher_givcrypt_reqtfm(
+        struct skcipher_givcrypt_request *req)
+{
+        return crypto_ablkcipher_reqtfm(&req->creq);
+}
+static inline int crypto_skcipher_givencrypt(
+        struct skcipher_givcrypt_request *req)
+{
+        struct ablkcipher_tfm *crt =
+                crypto_ablkcipher_crt(skcipher_givcrypt_reqtfm(req));
+        return crt->givencrypt(req);
+};
+static inline int crypto_skcipher_givdecrypt(
+        struct skcipher_givcrypt_request *req)
+{
+        struct ablkcipher_tfm *crt =
+                crypto_ablkcipher_crt(skcipher_givcrypt_reqtfm(req));
+        return crt->givdecrypt(req);
+};
+static inline void skcipher_givcrypt_set_tfm(
+        struct skcipher_givcrypt_request *req, struct crypto_ablkcipher *tfm)
+{
+        req->creq.base.tfm = crypto_ablkcipher_tfm(tfm);
+}
+static inline struct skcipher_givcrypt_request *skcipher_givcrypt_cast(
+        struct crypto_async_request *req)
+{
+        return container_of(ablkcipher_request_cast(req),
+                            struct skcipher_givcrypt_request, creq);
+}
+static inline struct skcipher_givcrypt_request *skcipher_givcrypt_alloc(
+        struct crypto_ablkcipher *tfm, gfp_t gfp)
+{
+        struct skcipher_givcrypt_request *req;
+        req = kmalloc(sizeof(struct skcipher_givcrypt_request) +
+                      crypto_ablkcipher_reqsize(tfm), gfp);
+        if (likely(req))
+                skcipher_givcrypt_set_tfm(req, tfm);
+        return req;
+}
+static inline void skcipher_givcrypt_free(struct skcipher_givcrypt_request *req)
+{
+        kfree(req);
+}
+static inline void skcipher_givcrypt_set_callback(
+        struct skcipher_givcrypt_request *req, u32 flags,
+        crypto_completion_t complete, void *data)
+{
+        ablkcipher_request_set_callback(&req->creq, flags, complete, data);
+}
+static inline void skcipher_givcrypt_set_crypt(
+        struct skcipher_givcrypt_request *req,
+        struct scatterlist *src, struct scatterlist *dst,
+        unsigned int nbytes, void *iv)
+{
+        ablkcipher_request_set_crypt(&req->creq, src, dst, nbytes, iv);
+}
+static inline void skcipher_givcrypt_set_giv(
+        struct skcipher_givcrypt_request *req, u8 *giv, u64 seq)
+{
+        req->giv = giv;
+        req->seq = seq;
+}
+#endif  /* _CRYPTO_SKCIPHER_H */
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index f30fa92a44a1..bd694f779346 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -49,6 +49,7 @@ header-y += comstats.h
 header-y += const.h
 header-y += cgroupstats.h
 header-y += cycx_cfm.h
+header-y += dlmconstants.h
 header-y += dlm_device.h
 header-y += dlm_netlink.h
 header-y += dm-ioctl.h
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index e3c16c981e46..63f2e6ed698f 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -40,6 +40,7 @@
 #include <acpi/acpi_drivers.h>
 #include <acpi/acpi_numa.h>
 #include <asm/acpi.h>
+#include <linux/dmi.h>
 #ifdef CONFIG_ACPI
@@ -192,7 +193,9 @@ extern int ec_transaction(u8 command,
 #endif /*CONFIG_ACPI_EC*/
 extern int acpi_blacklisted(void);
-extern void acpi_bios_year(char *s);
+#ifdef CONFIG_DMI
+extern void acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d);
+#endif
 #ifdef CONFIG_ACPI_NUMA
 int acpi_get_pxm(acpi_handle handle);
@@ -226,5 +229,5 @@ static inline int acpi_boot_table_init(void)
        return 0;
 }
-#endif  /* CONFIG_ACPI */
+#endif  /* !CONFIG_ACPI */
 #endif  /*_LINUX_ACPI_H*/
diff --git a/include/linux/ata.h b/include/linux/ata.h
index 72ab80801ef6..78bbacaed8c4 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -286,9 +286,10 @@ enum {
        ATA_CBL_NONE            = 0,
        ATA_CBL_PATA40          = 1,
        ATA_CBL_PATA80          = 2,
-        ATA_CBL_PATA40_SHORT    = 3,            /* 40 wire cable to high UDMA spec */
+        ATA_CBL_PATA40_SHORT    = 3,    /* 40 wire cable to high UDMA spec */
-        ATA_CBL_PATA_UNK        = 4,
+        ATA_CBL_PATA_UNK        = 4,    /* don't know, maybe 80c? */
-        ATA_CBL_SATA            = 5,
+        ATA_CBL_PATA_IGN        = 5,    /* don't know, ignore cable handling */
+        ATA_CBL_SATA            = 6,
        /* SATA Status and Control Registers */
        SCR_STATUS              = 0,
@@ -324,6 +325,13 @@ enum {
        ATA_TFLAG_LBA           = (1 << 4), /* enable LBA */
        ATA_TFLAG_FUA           = (1 << 5), /* enable FUA */
        ATA_TFLAG_POLLING       = (1 << 6), /* set nIEN to 1 and use polling */
+        /* protocol flags */
+        ATA_PROT_FLAG_PIO       = (1 << 0), /* is PIO */
+        ATA_PROT_FLAG_DMA       = (1 << 1), /* is DMA */
+        ATA_PROT_FLAG_DATA      = ATA_PROT_FLAG_PIO | ATA_PROT_FLAG_DMA,
+        ATA_PROT_FLAG_NCQ       = (1 << 2), /* is NCQ */
+        ATA_PROT_FLAG_ATAPI     = (1 << 3), /* is ATAPI */
 };
 enum ata_tf_protocols {
@@ -333,9 +341,9 @@ enum ata_tf_protocols {
        ATA_PROT_PIO,           /* PIO data xfer */
        ATA_PROT_DMA,           /* DMA */
        ATA_PROT_NCQ,           /* NCQ */
-        ATA_PROT_ATAPI,         /* packet command, PIO data xfer*/
+        ATAPI_PROT_NODATA,      /* packet command, no data */
-        ATA_PROT_ATAPI_NODATA,  /* packet command, no data */
+        ATAPI_PROT_PIO,         /* packet command, PIO data xfer*/
-        ATA_PROT_ATAPI_DMA,     /* packet command with special DMA sauce */
+        ATAPI_PROT_DMA,         /* packet command with special DMA sauce */
 };
 enum ata_ioctls {
@@ -346,8 +354,8 @@ enum ata_ioctls {
 /* core structures */
 struct ata_prd {
-        u32                     addr;
+        __le32                  addr;
-        u32                     flags_len;
+        __le32                  flags_len;
 };
 struct ata_taskfile {
@@ -373,13 +381,69 @@ struct ata_taskfile {
        u8                      command;        /* IO operation */
 };
+/*
+ * protocol tests
+ */
+static inline unsigned int ata_prot_flags(u8 prot)
+{
+        switch (prot) {
+        case ATA_PROT_NODATA:
+                return 0;
+        case ATA_PROT_PIO:
+                return ATA_PROT_FLAG_PIO;
+        case ATA_PROT_DMA:
+                return ATA_PROT_FLAG_DMA;
+        case ATA_PROT_NCQ:
+                return ATA_PROT_FLAG_DMA | ATA_PROT_FLAG_NCQ;
+        case ATAPI_PROT_NODATA:
+                return ATA_PROT_FLAG_ATAPI;
+        case ATAPI_PROT_PIO:
+                return ATA_PROT_FLAG_ATAPI | ATA_PROT_FLAG_PIO;
+        case ATAPI_PROT_DMA:
+                return ATA_PROT_FLAG_ATAPI | ATA_PROT_FLAG_DMA;
+        }
+        return 0;
+}
+static inline int ata_is_atapi(u8 prot)
+{
+        return ata_prot_flags(prot) & ATA_PROT_FLAG_ATAPI;
+}
+static inline int ata_is_nodata(u8 prot)
+{
+        return !(ata_prot_flags(prot) & ATA_PROT_FLAG_DATA);
+}
+static inline int ata_is_pio(u8 prot)
+{
+        return ata_prot_flags(prot) & ATA_PROT_FLAG_PIO;
+}
+static inline int ata_is_dma(u8 prot)
+{
+        return ata_prot_flags(prot) & ATA_PROT_FLAG_DMA;
+}
+static inline int ata_is_ncq(u8 prot)
+{
+        return ata_prot_flags(prot) & ATA_PROT_FLAG_NCQ;
+}
+static inline int ata_is_data(u8 prot)
+{
+        return ata_prot_flags(prot) & ATA_PROT_FLAG_DATA;
+}
+/*
+ * id tests
+ */
 #define ata_id_is_ata(id)       (((id)[0] & (1 << 15)) == 0)
 #define ata_id_has_lba(id)      ((id)[49] & (1 << 9))
 #define ata_id_has_dma(id)      ((id)[49] & (1 << 8))
 #define ata_id_has_ncq(id)      ((id)[76] & (1 << 8))
 #define ata_id_queue_depth(id)  (((id)[75] & 0x1f) + 1)
 #define ata_id_removeable(id)   ((id)[0] & (1 << 7))
-#define ata_id_has_dword_io(id) ((id)[48] & (1 << 0))
 #define ata_id_has_atapi_AN(id) \
        ( (((id)[76] != 0x0000) && ((id)[76] != 0xffff)) && \
          ((id)[78] & (1 << 5)) )
@@ -415,6 +479,7 @@ static inline bool ata_id_has_dipm(const u16 *id)
        return val & (1 << 3);
 }
 static inline int ata_id_has_fua(const u16 *id)
 {
        if ((id[84] & 0xC000) != 0x4000)
@@ -519,6 +584,26 @@ static inline int ata_id_is_sata(const u16 *id)
        return ata_id_major_version(id) >= 5 && id[93] == 0;
 }
+static inline int ata_id_has_tpm(const u16 *id)
+{
+        /* The TPM bits are only valid on ATA8 */
+        if (ata_id_major_version(id) < 8)
+                return 0;
+        if ((id[48] & 0xC000) != 0x4000)
+                return 0;
+        return id[48] & (1 << 0);
+}
+static inline int ata_id_has_dword_io(const u16 *id)
+{
+        /* ATA 8 reuses this flag for "trusted" computing */
+        if (ata_id_major_version(id) > 7)
+                return 0;
+        if (id[48] & (1 << 0))
+                return 1;
+        return 0;
+}
 static inline int ata_id_current_chs_valid(const u16 *id)
 {
        /* For ATA-1 devices, if the INITIALIZE DEVICE PARAMETERS command
@@ -554,8 +639,6 @@ static inline int ata_drive_40wire(const u16 *dev_id)
 static inline int ata_drive_40wire_relaxed(const u16 *dev_id)
 {
-        if (ata_id_is_sata(dev_id))
-                return 0;       /* SATA */
        if ((dev_id[93] & 0x2000) == 0x2000)
                return 0;       /* 80 wire */
        return 1;
@@ -576,13 +659,6 @@ static inline int atapi_command_packet_set(const u16 *dev_id)
        return (dev_id[0] >> 8) & 0x1f;
 }
-static inline int is_atapi_taskfile(const struct ata_taskfile *tf)
-{
-        return (tf->protocol == ATA_PROT_ATAPI) ||
-               (tf->protocol == ATA_PROT_ATAPI_NODATA) ||
-               (tf->protocol == ATA_PROT_ATAPI_DMA);
-}
 static inline int is_multi_taskfile(struct ata_taskfile *tf)
 {
        return (tf->command == ATA_CMD_READ_MULTI) ||
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 81e99e516302..bd20a4e8663a 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -144,7 +144,6 @@ enum rq_cmd_type_bits {
         * private REQ_LB opcodes to differentiate what type of request this is
         */
        REQ_TYPE_ATA_CMD,
-        REQ_TYPE_ATA_TASK,
        REQ_TYPE_ATA_TASKFILE,
        REQ_TYPE_ATA_PC,
 };
diff --git a/include/linux/cdrom.h b/include/linux/cdrom.h
index c6d3e22c0624..fcdc11b9609b 100644
--- a/include/linux/cdrom.h
+++ b/include/linux/cdrom.h
@@ -451,6 +451,7 @@ struct cdrom_generic_command
 #define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL  0x1e
 #define GPCMD_READ_10                       0x28
 #define GPCMD_READ_12                       0xa8
+#define GPCMD_READ_BUFFER                   0x3c
 #define GPCMD_READ_BUFFER_CAPACITY          0x5c
 #define GPCMD_READ_CDVD_CAPACITY            0x25
 #define GPCMD_READ_CD                       0xbe
@@ -480,7 +481,9 @@ struct cdrom_generic_command
 #define GPCMD_TEST_UNIT_READY               0x00
 #define GPCMD_VERIFY_10                     0x2f
 #define GPCMD_WRITE_10                      0x2a
+#define GPCMD_WRITE_12                      0xaa
 #define GPCMD_WRITE_AND_VERIFY_10           0x2e
+#define GPCMD_WRITE_BUFFER                  0x3b
 /* This is listed as optional in ATAPI 2.6, but is (curiously) 
 * missing from Mt. Fuji, Table 57.  It _is_ mentioned in Mt. Fuji
 * Table 377 as an MMC command for SCSi devices though...  Most ATAPI
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 92f2029a34f3..0be8d65bc3c8 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -71,18 +71,27 @@ static inline void unregister_cpu_notifier(struct notifier_block *nb)
 int cpu_up(unsigned int cpu);
+extern void cpu_hotplug_init(void);
 #else
 static inline int register_cpu_notifier(struct notifier_block *nb)
 {
        return 0;
 }
 static inline void unregister_cpu_notifier(struct notifier_block *nb)
 {
 }
+static inline void cpu_hotplug_init(void)
+{
+}
 #endif /* CONFIG_SMP */
 extern struct sysdev_class cpu_sysdev_class;
+extern void cpu_maps_update_begin(void);
+extern void cpu_maps_update_done(void);
 #ifdef CONFIG_HOTPLUG_CPU
 /* Stop CPUs going up and down. */
@@ -97,8 +106,8 @@ static inline void cpuhotplug_mutex_unlock(struct mutex *cpu_hp_mutex)
        mutex_unlock(cpu_hp_mutex);
 }
-extern void lock_cpu_hotplug(void);
+extern void get_online_cpus(void);
-extern void unlock_cpu_hotplug(void);
+extern void put_online_cpus(void);
 #define hotcpu_notifier(fn, pri) {                              \
        static struct notifier_block fn##_nb =                  \
                { .notifier_call = fn, .priority = pri };       \
@@ -115,8 +124,8 @@ static inline void cpuhotplug_mutex_lock(struct mutex *cpu_hp_mutex)
 static inline void cpuhotplug_mutex_unlock(struct mutex *cpu_hp_mutex)
 { }
-#define lock_cpu_hotplug()      do { } while (0)
+#define get_online_cpus()       do { } while (0)
-#define unlock_cpu_hotplug()    do { } while (0)
+#define put_online_cpus()       do { } while (0)
 #define hotcpu_notifier(fn, pri)        do { (void)(fn); } while (0)
 /* These aren't inline functions due to a GCC bug. */
 #define register_hotcpu_notifier(nb)    ({ (void)(nb); 0; })
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index f3110ebe894a..5e02d1b46370 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -33,10 +33,13 @@
 #define CRYPTO_ALG_TYPE_DIGEST          0x00000002
 #define CRYPTO_ALG_TYPE_HASH            0x00000003
 #define CRYPTO_ALG_TYPE_BLKCIPHER       0x00000004
-#define CRYPTO_ALG_TYPE_COMPRESS        0x00000005
+#define CRYPTO_ALG_TYPE_ABLKCIPHER      0x00000005
-#define CRYPTO_ALG_TYPE_AEAD            0x00000006
+#define CRYPTO_ALG_TYPE_GIVCIPHER       0x00000006
+#define CRYPTO_ALG_TYPE_COMPRESS        0x00000008
+#define CRYPTO_ALG_TYPE_AEAD            0x00000009
 #define CRYPTO_ALG_TYPE_HASH_MASK       0x0000000e
+#define CRYPTO_ALG_TYPE_BLKCIPHER_MASK  0x0000000c
 #define CRYPTO_ALG_LARVAL               0x00000010
 #define CRYPTO_ALG_DEAD                 0x00000020
@@ -50,6 +53,12 @@
 #define CRYPTO_ALG_NEED_FALLBACK        0x00000100
 /*
+ * This bit is set for symmetric key ciphers that have already been wrapped
+ * with a generic IV generator to prevent them from being wrapped again.
+ */
+#define CRYPTO_ALG_GENIV                0x00000200
+/*
 * Transform masks and values (for crt_flags).
 */
 #define CRYPTO_TFM_REQ_MASK             0x000fff00
@@ -81,13 +90,11 @@
 #define CRYPTO_MINALIGN ARCH_KMALLOC_MINALIGN
 #elif defined(ARCH_SLAB_MINALIGN)
 #define CRYPTO_MINALIGN ARCH_SLAB_MINALIGN
+#else
+#define CRYPTO_MINALIGN __alignof__(unsigned long long)
 #endif
-#ifdef CRYPTO_MINALIGN
 #define CRYPTO_MINALIGN_ATTR __attribute__ ((__aligned__(CRYPTO_MINALIGN)))
-#else
-#define CRYPTO_MINALIGN_ATTR
-#endif
 struct scatterlist;
 struct crypto_ablkcipher;
@@ -97,6 +104,8 @@ struct crypto_blkcipher;
 struct crypto_hash;
 struct crypto_tfm;
 struct crypto_type;
+struct aead_givcrypt_request;
+struct skcipher_givcrypt_request;
 typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
@@ -176,6 +185,10 @@ struct ablkcipher_alg {
                      unsigned int keylen);
        int (*encrypt)(struct ablkcipher_request *req);
        int (*decrypt)(struct ablkcipher_request *req);
+        int (*givencrypt)(struct skcipher_givcrypt_request *req);
+        int (*givdecrypt)(struct skcipher_givcrypt_request *req);
+        const char *geniv;
        unsigned int min_keysize;
        unsigned int max_keysize;
@@ -185,11 +198,16 @@ struct ablkcipher_alg {
 struct aead_alg {
        int (*setkey)(struct crypto_aead *tfm, const u8 *key,
                      unsigned int keylen);
+        int (*setauthsize)(struct crypto_aead *tfm, unsigned int authsize);
        int (*encrypt)(struct aead_request *req);
        int (*decrypt)(struct aead_request *req);
+        int (*givencrypt)(struct aead_givcrypt_request *req);
+        int (*givdecrypt)(struct aead_givcrypt_request *req);
+        const char *geniv;
        unsigned int ivsize;
-        unsigned int authsize;
+        unsigned int maxauthsize;
 };
 struct blkcipher_alg {
@@ -202,6 +220,8 @@ struct blkcipher_alg {
                       struct scatterlist *dst, struct scatterlist *src,
                       unsigned int nbytes);
+        const char *geniv;
        unsigned int min_keysize;
        unsigned int max_keysize;
        unsigned int ivsize;
@@ -317,6 +337,11 @@ struct ablkcipher_tfm {
                      unsigned int keylen);
        int (*encrypt)(struct ablkcipher_request *req);
        int (*decrypt)(struct ablkcipher_request *req);
+        int (*givencrypt)(struct skcipher_givcrypt_request *req);
+        int (*givdecrypt)(struct skcipher_givcrypt_request *req);
+        struct crypto_ablkcipher *base;
        unsigned int ivsize;
        unsigned int reqsize;
 };
@@ -326,6 +351,11 @@ struct aead_tfm {
                      unsigned int keylen);
        int (*encrypt)(struct aead_request *req);
        int (*decrypt)(struct aead_request *req);
+        int (*givencrypt)(struct aead_givcrypt_request *req);
+        int (*givdecrypt)(struct aead_givcrypt_request *req);
+        struct crypto_aead *base;
        unsigned int ivsize;
        unsigned int authsize;
        unsigned int reqsize;
@@ -525,17 +555,23 @@ static inline struct crypto_ablkcipher *__crypto_ablkcipher_cast(
        return (struct crypto_ablkcipher *)tfm;
 }
-static inline struct crypto_ablkcipher *crypto_alloc_ablkcipher(
+static inline u32 crypto_skcipher_type(u32 type)
-        const char *alg_name, u32 type, u32 mask)
 {
-        type &= ~CRYPTO_ALG_TYPE_MASK;
+        type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
        type |= CRYPTO_ALG_TYPE_BLKCIPHER;
-        mask |= CRYPTO_ALG_TYPE_MASK;
+        return type;
+}
-        return __crypto_ablkcipher_cast(
+static inline u32 crypto_skcipher_mask(u32 mask)
-                crypto_alloc_base(alg_name, type, mask));
+{
+        mask &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_GENIV);
+        mask |= CRYPTO_ALG_TYPE_BLKCIPHER_MASK;
+        return mask;
 }
+struct crypto_ablkcipher *crypto_alloc_ablkcipher(const char *alg_name,
+                                                  u32 type, u32 mask);
 static inline struct crypto_tfm *crypto_ablkcipher_tfm(
        struct crypto_ablkcipher *tfm)
 {
@@ -550,11 +586,8 @@ static inline void crypto_free_ablkcipher(struct crypto_ablkcipher *tfm)
 static inline int crypto_has_ablkcipher(const char *alg_name, u32 type,
                                        u32 mask)
 {
-        type &= ~CRYPTO_ALG_TYPE_MASK;
+        return crypto_has_alg(alg_name, crypto_skcipher_type(type),
-        type |= CRYPTO_ALG_TYPE_BLKCIPHER;
+                              crypto_skcipher_mask(mask));
-        mask |= CRYPTO_ALG_TYPE_MASK;
-        return crypto_has_alg(alg_name, type, mask);
 }
 static inline struct ablkcipher_tfm *crypto_ablkcipher_crt(
@@ -601,7 +634,9 @@ static inline void crypto_ablkcipher_clear_flags(struct crypto_ablkcipher *tfm,
 static inline int crypto_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
                                           const u8 *key, unsigned int keylen)
 {
-        return crypto_ablkcipher_crt(tfm)->setkey(tfm, key, keylen);
+        struct ablkcipher_tfm *crt = crypto_ablkcipher_crt(tfm);
+        return crt->setkey(crt->base, key, keylen);
 }
 static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
@@ -633,7 +668,7 @@ static inline unsigned int crypto_ablkcipher_reqsize(
 static inline void ablkcipher_request_set_tfm(
        struct ablkcipher_request *req, struct crypto_ablkcipher *tfm)
 {
-        req->base.tfm = crypto_ablkcipher_tfm(tfm);
+        req->base.tfm = crypto_ablkcipher_tfm(crypto_ablkcipher_crt(tfm)->base);
 }
 static inline struct ablkcipher_request *ablkcipher_request_cast(
@@ -686,15 +721,7 @@ static inline struct crypto_aead *__crypto_aead_cast(struct crypto_tfm *tfm)
        return (struct crypto_aead *)tfm;
 }
-static inline struct crypto_aead *crypto_alloc_aead(const char *alg_name,
+struct crypto_aead *crypto_alloc_aead(const char *alg_name, u32 type, u32 mask);
-                                                    u32 type, u32 mask)
-{
-        type &= ~CRYPTO_ALG_TYPE_MASK;
-        type |= CRYPTO_ALG_TYPE_AEAD;
-        mask |= CRYPTO_ALG_TYPE_MASK;
-        return __crypto_aead_cast(crypto_alloc_base(alg_name, type, mask));
-}
 static inline struct crypto_tfm *crypto_aead_tfm(struct crypto_aead *tfm)
 {
@@ -749,9 +776,13 @@ static inline void crypto_aead_clear_flags(struct crypto_aead *tfm, u32 flags)
 static inline int crypto_aead_setkey(struct crypto_aead *tfm, const u8 *key,
                                     unsigned int keylen)
 {
-        return crypto_aead_crt(tfm)->setkey(tfm, key, keylen);
+        struct aead_tfm *crt = crypto_aead_crt(tfm);
+        return crt->setkey(crt->base, key, keylen);
 }
+int crypto_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize);
 static inline struct crypto_aead *crypto_aead_reqtfm(struct aead_request *req)
 {
        return __crypto_aead_cast(req->base.tfm);
@@ -775,7 +806,7 @@ static inline unsigned int crypto_aead_reqsize(struct crypto_aead *tfm)
 static inline void aead_request_set_tfm(struct aead_request *req,
                                        struct crypto_aead *tfm)
 {
-        req->base.tfm = crypto_aead_tfm(tfm);
+        req->base.tfm = crypto_aead_tfm(crypto_aead_crt(tfm)->base);
 }
 static inline struct aead_request *aead_request_alloc(struct crypto_aead *tfm,
@@ -841,9 +872,9 @@ static inline struct crypto_blkcipher *crypto_blkcipher_cast(
 static inline struct crypto_blkcipher *crypto_alloc_blkcipher(
        const char *alg_name, u32 type, u32 mask)
 {
-        type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);
+        type &= ~CRYPTO_ALG_TYPE_MASK;
        type |= CRYPTO_ALG_TYPE_BLKCIPHER;
-        mask |= CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC;
+        mask |= CRYPTO_ALG_TYPE_MASK;
        return __crypto_blkcipher_cast(crypto_alloc_base(alg_name, type, mask));
 }
@@ -861,9 +892,9 @@ static inline void crypto_free_blkcipher(struct crypto_blkcipher *tfm)
 static inline int crypto_has_blkcipher(const char *alg_name, u32 type, u32 mask)
 {
-        type &= ~(CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);
+        type &= ~CRYPTO_ALG_TYPE_MASK;
        type |= CRYPTO_ALG_TYPE_BLKCIPHER;
-        mask |= CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC;
+        mask |= CRYPTO_ALG_TYPE_MASK;
        return crypto_has_alg(alg_name, type, mask);
 }
@@ -1081,6 +1112,7 @@ static inline struct crypto_hash *crypto_alloc_hash(const char *alg_name,
                                                    u32 type, u32 mask)
 {
        type &= ~CRYPTO_ALG_TYPE_MASK;
+        mask &= ~CRYPTO_ALG_TYPE_MASK;
        type |= CRYPTO_ALG_TYPE_HASH;
        mask |= CRYPTO_ALG_TYPE_HASH_MASK;
@@ -1100,6 +1132,7 @@ static inline void crypto_free_hash(struct crypto_hash *tfm)
 static inline int crypto_has_hash(const char *alg_name, u32 type, u32 mask)
 {
        type &= ~CRYPTO_ALG_TYPE_MASK;
+        mask &= ~CRYPTO_ALG_TYPE_MASK;
        type |= CRYPTO_ALG_TYPE_HASH;
        mask |= CRYPTO_ALG_TYPE_HASH_MASK;
diff --git a/include/linux/debug_locks.h b/include/linux/debug_locks.h
index 1678a5de7013..f4a5871767f5 100644
--- a/include/linux/debug_locks.h
+++ b/include/linux/debug_locks.h
@@ -47,6 +47,7 @@ struct task_struct;
 #ifdef CONFIG_LOCKDEP
 extern void debug_show_all_locks(void);
+extern void __debug_show_held_locks(struct task_struct *task);
 extern void debug_show_held_locks(struct task_struct *task);
 extern void debug_check_no_locks_freed(const void *from, unsigned long len);
 extern void debug_check_no_locks_held(struct task_struct *task);
@@ -55,6 +56,10 @@ static inline void debug_show_all_locks(void)
 {
 }
+static inline void __debug_show_held_locks(struct task_struct *task)
+{
+}
 static inline void debug_show_held_locks(struct task_struct *task)
 {
 }
diff --git a/include/linux/device.h b/include/linux/device.h
index 2e15822fe409..1880208964d6 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -25,75 +25,69 @@
 #include <asm/device.h>
 #define DEVICE_NAME_SIZE        50
-#define DEVICE_NAME_HALF        __stringify(20) /* Less than half to accommodate slop */
+/* DEVICE_NAME_HALF is really less than half to accommodate slop */
+#define DEVICE_NAME_HALF        __stringify(20)
 #define DEVICE_ID_SIZE          32
 #define BUS_ID_SIZE             KOBJ_NAME_LEN
 struct device;
 struct device_driver;
+struct driver_private;
 struct class;
 struct class_device;
 struct bus_type;
+struct bus_type_private;
 struct bus_attribute {
        struct attribute        attr;
-        ssize_t (*show)(struct bus_type *, char * buf);
+        ssize_t (*show)(struct bus_type *bus, char *buf);
-        ssize_t (*store)(struct bus_type *, const char * buf, size_t count);
+        ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
 };
-#define BUS_ATTR(_name,_mode,_show,_store)      \
+#define BUS_ATTR(_name, _mode, _show, _store)   \
-struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store)
+struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
 extern int __must_check bus_create_file(struct bus_type *,
                                        struct bus_attribute *);
 extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
 struct bus_type {
-        const char              * name;
+        const char              *name;
-        struct module           * owner;
+        struct bus_attribute    *bus_attrs;
+        struct device_attribute *dev_attrs;
+        struct driver_attribute *drv_attrs;
-        struct kset             subsys;
+        int (*match)(struct device *dev, struct device_driver *drv);
-        struct kset             drivers;
+        int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
-        struct kset             devices;
+        int (*probe)(struct device *dev);
-        struct klist            klist_devices;
+        int (*remove)(struct device *dev);
-        struct klist            klist_drivers;
+        void (*shutdown)(struct device *dev);
-        struct blocking_notifier_head bus_notifier;
-        struct bus_attribute    * bus_attrs;
-        struct device_attribute * dev_attrs;
-        struct driver_attribute * drv_attrs;
-        int             (*match)(struct device * dev, struct device_driver * drv);
-        int             (*uevent)(struct device *dev, struct kobj_uevent_env *env);
-        int             (*probe)(struct device * dev);
-        int             (*remove)(struct device * dev);
-        void            (*shutdown)(struct device * dev);
-        int (*suspend)(struct device * dev, pm_message_t state);
+        int (*suspend)(struct device *dev, pm_message_t state);
-        int (*suspend_late)(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_early)(struct device *dev);
-        int (*resume)(struct device * dev);
+        int (*resume)(struct device *dev);
-        unsigned int drivers_autoprobe:1;
+        struct bus_type_private *p;
 };
-extern int __must_check bus_register(struct bus_type * bus);
+extern int __must_check bus_register(struct bus_type *bus);
-extern void bus_unregister(struct bus_type * bus);
+extern void bus_unregister(struct bus_type *bus);
-extern int __must_check bus_rescan_devices(struct bus_type * bus);
+extern int __must_check bus_rescan_devices(struct bus_type *bus);
 /* iterator helpers for buses */
-int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,
+int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
-                     int (*fn)(struct device *, void *));
+                     int (*fn)(struct device *dev, void *data));
-struct device * bus_find_device(struct bus_type *bus, struct device *start,
+struct device *bus_find_device(struct bus_type *bus, struct device *start,
-                                void *data, int (*match)(struct device *, void *));
+                               void *data,
+                               int (*match)(struct device *dev, void *data));
 int __must_check bus_for_each_drv(struct bus_type *bus,
-                struct device_driver *start, void *data,
+                                  struct device_driver *start, void *data,
-                int (*fn)(struct device_driver *, void *));
+                                  int (*fn)(struct device_driver *, void *));
 /*
 * Bus notifiers: Get notified of addition/removal of devices
@@ -118,111 +112,128 @@ extern int bus_unregister_notifier(struct bus_type *bus,
 #define BUS_NOTIFY_UNBIND_DRIVER        0x00000004 /* driver about to be
                                                      unbound */
+extern struct kset *bus_get_kset(struct bus_type *bus);
+extern struct klist *bus_get_device_klist(struct bus_type *bus);
 struct device_driver {
-        const char              * name;
+        const char              *name;
-        struct bus_type         * bus;
+        struct bus_type         *bus;
-        struct kobject          kobj;
+        struct module           *owner;
-        struct klist            klist_devices;
+        const char              *mod_name;      /* used for built-in modules */
-        struct klist_node       knode_bus;
-        struct module           * owner;
+        int (*probe) (struct device *dev);
-        const char              * mod_name;     /* used for built-in modules */
+        int (*remove) (struct device *dev);
-        struct module_kobject   * mkobj;
+        void (*shutdown) (struct device *dev);
+        int (*suspend) (struct device *dev, pm_message_t state);
+        int (*resume) (struct device *dev);
+        struct attribute_group **groups;
-        int     (*probe)        (struct device * dev);
+        struct driver_private *p;
-        int     (*remove)       (struct device * dev);
-        void    (*shutdown)     (struct device * dev);
-        int     (*suspend)      (struct device * dev, pm_message_t state);
-        int     (*resume)       (struct device * dev);
 };
-extern int __must_check driver_register(struct device_driver * drv);
+extern int __must_check driver_register(struct device_driver *drv);
-extern void driver_unregister(struct device_driver * drv);
+extern void driver_unregister(struct device_driver *drv);
-extern struct device_driver * get_driver(struct device_driver * drv);
+extern struct device_driver *get_driver(struct device_driver *drv);
-extern void put_driver(struct device_driver * drv);
+extern void put_driver(struct device_driver *drv);
-extern struct device_driver *driver_find(const char *name, struct bus_type *bus);
+extern struct device_driver *driver_find(const char *name,
+                                         struct bus_type *bus);
 extern int driver_probe_done(void);
 /* sysfs interface for exporting driver attributes */
 struct driver_attribute {
-        struct attribute        attr;
+        struct attribute attr;
-        ssize_t (*show)(struct device_driver *, char * buf);
+        ssize_t (*show)(struct device_driver *driver, char *buf);
-        ssize_t (*store)(struct device_driver *, const char * buf, size_t count);
+        ssize_t (*store)(struct device_driver *driver, const char *buf,
+                         size_t count);
 };
-#define DRIVER_ATTR(_name,_mode,_show,_store)   \
+#define DRIVER_ATTR(_name, _mode, _show, _store)        \
-struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store)
+struct driver_attribute driver_attr_##_name =           \
+        __ATTR(_name, _mode, _show, _store)
-extern int __must_check driver_create_file(struct device_driver *,
+extern int __must_check driver_create_file(struct device_driver *driver,
-                                        struct driver_attribute *);
+                                           struct driver_attribute *attr);
-extern void driver_remove_file(struct device_driver *, struct driver_attribute *);
+extern void driver_remove_file(struct device_driver *driver,
+                               struct driver_attribute *attr);
-extern int __must_check driver_for_each_device(struct device_driver * drv,
+extern int __must_check driver_add_kobj(struct device_driver *drv,
-                struct device *start, void *data,
+                                        struct kobject *kobj,
-                int (*fn)(struct device *, void *));
+                                        const char *fmt, ...);
-struct device * driver_find_device(struct device_driver *drv,
-                                   struct device *start, void *data,
+extern int __must_check driver_for_each_device(struct device_driver *drv,
-                                   int (*match)(struct device *, void *));
+                                               struct device *start,
+                                               void *data,
+                                               int (*fn)(struct device *dev,
+                                                         void *));
+struct device *driver_find_device(struct device_driver *drv,
+                                  struct device *start, void *data,
+                                  int (*match)(struct device *dev, void *data));
 /*
 * device classes
 */
 struct class {
-        const char              * name;
+        const char              *name;
-        struct module           * owner;
+        struct module           *owner;
        struct kset             subsys;
        struct list_head        children;
        struct list_head        devices;
        struct list_head        interfaces;
        struct kset             class_dirs;
-        struct semaphore        sem;    /* locks both the children and interfaces lists */
+        struct semaphore        sem; /* locks children, devices, interfaces */
+        struct class_attribute          *class_attrs;
-        struct class_attribute          * class_attrs;
+        struct class_device_attribute   *class_dev_attrs;
-        struct class_device_attribute   * class_dev_attrs;
+        struct device_attribute         *dev_attrs;
-        struct device_attribute         * dev_attrs;
-        int     (*uevent)(struct class_device *dev, struct kobj_uevent_env *env);
+        int (*uevent)(struct class_device *dev, struct kobj_uevent_env *env);
-        int     (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
+        int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
-        void    (*release)(struct class_device *dev);
+        void (*release)(struct class_device *dev);
-        void    (*class_release)(struct class *class);
+        void (*class_release)(struct class *class);
-        void    (*dev_release)(struct device *dev);
+        void (*dev_release)(struct device *dev);
-        int     (*suspend)(struct device *, pm_message_t state);
+        int (*suspend)(struct device *dev, pm_message_t state);
-        int     (*resume)(struct device *);
+        int (*resume)(struct device *dev);
 };
-extern int __must_check class_register(struct class *);
+extern int __must_check class_register(struct class *class);
-extern void class_unregister(struct class *);
+extern void class_unregister(struct class *class);
+extern int class_for_each_device(struct class *class, void *data,
+                                 int (*fn)(struct device *dev, void *data));
+extern struct device *class_find_device(struct class *class, void *data,
+                                        int (*match)(struct device *, void *));
+extern struct class_device *class_find_child(struct class *class, void *data,
+                                   int (*match)(struct class_device *, void *));
 struct class_attribute {
-        struct attribute        attr;
+        struct attribute attr;
-        ssize_t (*show)(struct class *, char * buf);
+        ssize_t (*show)(struct class *class, char *buf);
-        ssize_t (*store)(struct class *, const char * buf, size_t count);
+        ssize_t (*store)(struct class *class, const char *buf, size_t count);
 };
-#define CLASS_ATTR(_name,_mode,_show,_store)                    \
+#define CLASS_ATTR(_name, _mode, _show, _store)                 \
-struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store) 
+struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
-extern int __must_check class_create_file(struct class *,
+extern int __must_check class_create_file(struct class *class,
-                                        const struct class_attribute *);
+                                          const struct class_attribute *attr);
-extern void class_remove_file(struct class *, const struct class_attribute *);
+extern void class_remove_file(struct class *class,
+                              const struct class_attribute *attr);
 struct class_device_attribute {
-        struct attribute        attr;
+        struct attribute attr;
-        ssize_t (*show)(struct class_device *, char * buf);
+        ssize_t (*show)(struct class_device *, char *buf);
-        ssize_t (*store)(struct class_device *, const char * buf, size_t count);
+        ssize_t (*store)(struct class_device *, const char *buf, size_t count);
 };
-#define CLASS_DEVICE_ATTR(_name,_mode,_show,_store)             \
+#define CLASS_DEVICE_ATTR(_name, _mode, _show, _store)          \
 struct class_device_attribute class_device_attr_##_name =       \
-        __ATTR(_name,_mode,_show,_store)
+        __ATTR(_name, _mode, _show, _store)
 extern int __must_check class_device_create_file(struct class_device *,
                                    const struct class_device_attribute *);
@@ -255,26 +266,24 @@ struct class_device {
        struct list_head        node;
        struct kobject          kobj;
-        struct class            * class;        /* required */
+        struct class            *class;
-        dev_t                   devt;           /* dev_t, creates the sysfs "dev" */
+        dev_t                   devt;
-        struct device           * dev;          /* not necessary, but nice to have */
+        struct device           *dev;
-        void                    * class_data;   /* class-specific data */
+        void                    *class_data;
-        struct class_device     *parent;        /* parent of this child device, if there is one */
+        struct class_device     *parent;
-        struct attribute_group  ** groups;      /* optional groups */
+        struct attribute_group  **groups;
-        void    (*release)(struct class_device *dev);
+        void (*release)(struct class_device *dev);
-        int     (*uevent)(struct class_device *dev, struct kobj_uevent_env *env);
+        int (*uevent)(struct class_device *dev, struct kobj_uevent_env *env);
-        char    class_id[BUS_ID_SIZE];  /* unique to this class */
+        char class_id[BUS_ID_SIZE];
 };
-static inline void *
+static inline void *class_get_devdata(struct class_device *dev)
-class_get_devdata (struct class_device *dev)
 {
        return dev->class_data;
 }
-static inline void
+static inline void class_set_devdata(struct class_device *dev, void *data)
-class_set_devdata (struct class_device *dev, void *data)
 {
        dev->class_data = data;
 }
@@ -286,10 +295,10 @@ extern void class_device_initialize(struct class_device *);
 extern int __must_check class_device_add(struct class_device *);
 extern void class_device_del(struct class_device *);
-extern struct class_device * class_device_get(struct class_device *);
+extern struct class_device *class_device_get(struct class_device *);
 extern void class_device_put(struct class_device *);
-extern void class_device_remove_file(struct class_device *, 
+extern void class_device_remove_file(struct class_device *,
                                     const struct class_device_attribute *);
 extern int __must_check class_device_create_bin_file(struct class_device *,
                                        struct bin_attribute *);
@@ -316,7 +325,7 @@ extern struct class_device *class_device_create(struct class *cls,
                                                dev_t devt,
                                                struct device *device,
                                                const char *fmt, ...)
-                                        __attribute__((format(printf,5,6)));
+                                        __attribute__((format(printf, 5, 6)));
 extern void class_device_destroy(struct class *cls, dev_t devt);
 /*
@@ -333,8 +342,8 @@ struct device_type {
        struct attribute_group **groups;
        int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
        void (*release)(struct device *dev);
-        int (*suspend)(struct device * dev, pm_message_t state);
+        int (*suspend)(struct device *dev, pm_message_t state);
-        int (*resume)(struct device * dev);
+        int (*resume)(struct device *dev);
 };
 /* interface for exporting device attributes */
@@ -346,18 +355,19 @@ struct device_attribute {
                         const char *buf, size_t count);
 };
-#define DEVICE_ATTR(_name,_mode,_show,_store) \
+#define DEVICE_ATTR(_name, _mode, _show, _store) \
-struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
+struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
 extern int __must_check device_create_file(struct device *device,
-                                        struct device_attribute * entry);
+                                           struct device_attribute *entry);
-extern void device_remove_file(struct device * dev, struct device_attribute * attr);
+extern void device_remove_file(struct device *dev,
+                               struct device_attribute *attr);
 extern int __must_check device_create_bin_file(struct device *dev,
                                               struct bin_attribute *attr);
 extern void device_remove_bin_file(struct device *dev,
                                   struct bin_attribute *attr);
 extern int device_schedule_callback_owner(struct device *dev,
-                void (*func)(struct device *), struct module *owner);
+                void (*func)(struct device *dev), struct module *owner);
 /* This is a macro to avoid include problems with THIS_MODULE */
 #define device_schedule_callback(dev, func)                     \
@@ -368,21 +378,21 @@ typedef void (*dr_release_t)(struct device *dev, void *res);
 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
 #ifdef CONFIG_DEBUG_DEVRES
-extern void * __devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
+extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
                             const char *name);
 #define devres_alloc(release, size, gfp) \
        __devres_alloc(release, size, gfp, #release)
 #else
-extern void * devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
+extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
 #endif
 extern void devres_free(void *res);
 extern void devres_add(struct device *dev, void *res);
-extern void * devres_find(struct device *dev, dr_release_t release,
+extern void *devres_find(struct device *dev, dr_release_t release,
-                          dr_match_t match, void *match_data);
-extern void * devres_get(struct device *dev, void *new_res,
                         dr_match_t match, void *match_data);
-extern void * devres_remove(struct device *dev, dr_release_t release,
+extern void *devres_get(struct device *dev, void *new_res,
-                            dr_match_t match, void *match_data);
+                        dr_match_t match, void *match_data);
+extern void *devres_remove(struct device *dev, dr_release_t release,
+                           dr_match_t match, void *match_data);
 extern int devres_destroy(struct device *dev, dr_release_t release,
                          dr_match_t match, void *match_data);
@@ -399,7 +409,7 @@ extern void devm_kfree(struct device *dev, void *p);
 struct device {
        struct klist            klist_children;
-        struct klist_node       knode_parent;           /* node in sibling list */
+        struct klist_node       knode_parent;   /* node in sibling list */
        struct klist_node       knode_driver;
        struct klist_node       knode_bus;
        struct device           *parent;
@@ -414,7 +424,7 @@ struct device {
                                         * its driver.
                                         */
-        struct bus_type * bus;          /* type of bus device is on */
+        struct bus_type *bus;           /* type of bus device is on */
        struct device_driver *driver;   /* which driver has allocated this
                                           device */
        void            *driver_data;   /* data private to the driver */
@@ -445,10 +455,10 @@ struct device {
        /* class_device migration path */
        struct list_head        node;
        struct class            *class;
-        dev_t                   devt;           /* dev_t, creates the sysfs "dev" */
+        dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
        struct attribute_group  **groups;       /* optional groups */
-        void    (*release)(struct device * dev);
+        void    (*release)(struct device *dev);
 };
 #ifdef CONFIG_NUMA
@@ -470,14 +480,12 @@ static inline void set_dev_node(struct device *dev, int node)
 }
 #endif
-static inline void *
+static inline void *dev_get_drvdata(struct device *dev)
-dev_get_drvdata (struct device *dev)
 {
        return dev->driver_data;
 }
-static inline void
+static inline void dev_set_drvdata(struct device *dev, void *data)
-dev_set_drvdata (struct device *dev, void *data)
 {
        dev->driver_data = data;
 }
@@ -492,15 +500,15 @@ void driver_init(void);
 /*
 * High level routines for use by the bus drivers
 */
-extern int __must_check device_register(struct device * dev);
+extern int __must_check device_register(struct device *dev);
-extern void device_unregister(struct device * dev);
+extern void device_unregister(struct device *dev);
-extern void device_initialize(struct device * dev);
+extern void device_initialize(struct device *dev);
-extern int __must_check device_add(struct device * dev);
+extern int __must_check device_add(struct device *dev);
-extern void device_del(struct device * dev);
+extern void device_del(struct device *dev);
-extern int device_for_each_child(struct device *, void *,
+extern int device_for_each_child(struct device *dev, void *data,
-                     int (*fn)(struct device *, void *));
+                     int (*fn)(struct device *dev, void *data));
-extern struct device *device_find_child(struct device *, void *data,
+extern struct device *device_find_child(struct device *dev, void *data,
-                                        int (*match)(struct device *, void *));
+                                int (*match)(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);
@@ -509,8 +517,8 @@ extern int device_move(struct device *dev, struct device *new_parent);
 * for information on use.
 */
 extern int __must_check device_bind_driver(struct device *dev);
-extern void device_release_driver(struct device * dev);
+extern void device_release_driver(struct device *dev);
-extern int  __must_check device_attach(struct device * dev);
+extern int  __must_check device_attach(struct device *dev);
 extern int __must_check driver_attach(struct device_driver *drv);
 extern int __must_check device_reprobe(struct device *dev);
@@ -519,8 +527,16 @@ extern int __must_check device_reprobe(struct device *dev);
 */
 extern struct device *device_create(struct class *cls, struct device *parent,
                                    dev_t devt, const char *fmt, ...)
-                                    __attribute__((format(printf,4,5)));
+                                    __attribute__((format(printf, 4, 5)));
 extern void device_destroy(struct class *cls, dev_t devt);
+#ifdef CONFIG_PM_SLEEP
+extern void destroy_suspended_device(struct class *cls, dev_t devt);
+#else /* !CONFIG_PM_SLEEP */
+static inline void destroy_suspended_device(struct class *cls, dev_t devt)
+{
+        device_destroy(cls, devt);
+}
+#endif /* !CONFIG_PM_SLEEP */
 /*
 * Platform "fixup" functions - allow the platform to have their say
@@ -528,17 +544,17 @@ extern void device_destroy(struct class *cls, dev_t devt);
 * know about.
 */
 /* Notify platform of device discovery */
-extern int (*platform_notify)(struct device * dev);
+extern int (*platform_notify)(struct device *dev);
-extern int (*platform_notify_remove)(struct device * dev);
+extern int (*platform_notify_remove)(struct device *dev);
 /**
 * get_device - atomically increment the reference count for the device.
 *
 */
-extern struct device * get_device(struct device * dev);
+extern struct device *get_device(struct device *dev);
-extern void put_device(struct device * dev);
+extern void put_device(struct device *dev);
 /* drivers/base/power/shutdown.c */
@@ -547,22 +563,33 @@ extern void device_shutdown(void);
 /* drivers/base/sys.c */
 extern void sysdev_shutdown(void);
-/* drivers/base/firmware.c */
-extern int __must_check firmware_register(struct kset *);
-extern void firmware_unregister(struct kset *);
 /* debugging and troubleshooting/diagnostic helpers. */
 extern const char *dev_driver_string(struct device *dev);
 #define dev_printk(level, dev, format, arg...)  \
-        printk(level "%s %s: " format , dev_driver_string(dev) , (dev)->bus_id , ## arg)
+        printk(level "%s %s: " format , dev_driver_string(dev) , \
+               (dev)->bus_id , ## arg)
+#define dev_emerg(dev, format, arg...)          \
+        dev_printk(KERN_EMERG , dev , format , ## arg)
+#define dev_alert(dev, format, arg...)          \
+        dev_printk(KERN_ALERT , dev , format , ## arg)
+#define dev_crit(dev, format, arg...)           \
+        dev_printk(KERN_CRIT , dev , format , ## arg)
+#define dev_err(dev, format, arg...)            \
+        dev_printk(KERN_ERR , dev , format , ## arg)
+#define dev_warn(dev, format, arg...)           \
+        dev_printk(KERN_WARNING , dev , format , ## arg)
+#define dev_notice(dev, format, arg...)         \
+        dev_printk(KERN_NOTICE , dev , format , ## arg)
+#define dev_info(dev, format, arg...)           \
+        dev_printk(KERN_INFO , dev , format , ## arg)
 #ifdef DEBUG
 #define dev_dbg(dev, format, arg...)            \
        dev_printk(KERN_DEBUG , dev , format , ## arg)
 #else
 static inline int __attribute__ ((format (printf, 2, 3)))
-dev_dbg(struct device * dev, const char * fmt, ...)
+dev_dbg(struct device *dev, const char *fmt, ...)
 {
        return 0;
 }
@@ -572,21 +599,12 @@ dev_dbg(struct device * dev, const char * fmt, ...)
 #define dev_vdbg        dev_dbg
 #else
 static inline int __attribute__ ((format (printf, 2, 3)))
-dev_vdbg(struct device * dev, const char * fmt, ...)
+dev_vdbg(struct device *dev, const char *fmt, ...)
 {
        return 0;
 }
 #endif
-#define dev_err(dev, format, arg...)            \
-        dev_printk(KERN_ERR , dev , format , ## arg)
-#define dev_info(dev, format, arg...)           \
-        dev_printk(KERN_INFO , dev , format , ## arg)
-#define dev_warn(dev, format, arg...)           \
-        dev_printk(KERN_WARNING , dev , format , ## arg)
-#define dev_notice(dev, format, arg...)         \
-        dev_printk(KERN_NOTICE , dev , format , ## arg)
 /* Create alias, so I can be autoloaded. */
 #define MODULE_ALIAS_CHARDEV(major,minor) \
        MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
diff --git a/include/linux/dlm.h b/include/linux/dlm.h
index be9d278761e0..c743fbc769db 100644
--- a/include/linux/dlm.h
+++ b/include/linux/dlm.h
@@ -19,148 +19,12 @@
 * routines and structures to use DLM lockspaces
 */
-/*
+/* Lock levels and flags are here */
- * Lock Modes
+#include <linux/dlmconstants.h>
- */
-#define DLM_LOCK_IV             -1      /* invalid */
-#define DLM_LOCK_NL             0       /* null */
-#define DLM_LOCK_CR             1       /* concurrent read */
-#define DLM_LOCK_CW             2       /* concurrent write */
-#define DLM_LOCK_PR             3       /* protected read */
-#define DLM_LOCK_PW             4       /* protected write */
-#define DLM_LOCK_EX             5       /* exclusive */
-/*
- * Maximum size in bytes of a dlm_lock name
- */
 #define DLM_RESNAME_MAXLEN      64
-/*
- * Flags to dlm_lock
- *
- * DLM_LKF_NOQUEUE
- *
- * Do not queue the lock request on the wait queue if it cannot be granted
- * immediately.  If the lock cannot be granted because of this flag, DLM will
- * either return -EAGAIN from the dlm_lock call or will return 0 from
- * dlm_lock and -EAGAIN in the lock status block when the AST is executed.
- *
- * DLM_LKF_CANCEL
- *
- * Used to cancel a pending lock request or conversion.  A converting lock is
- * returned to its previously granted mode.
- *
- * DLM_LKF_CONVERT
- *
- * Indicates a lock conversion request.  For conversions the name and namelen
- * are ignored and the lock ID in the LKSB is used to identify the lock.
- *
- * DLM_LKF_VALBLK
- *
- * Requests DLM to return the current contents of the lock value block in the
- * lock status block.  When this flag is set in a lock conversion from PW or EX
- * modes, DLM assigns the value specified in the lock status block to the lock
- * value block of the lock resource.  The LVB is a DLM_LVB_LEN size array
- * containing application-specific information.
- *
- * DLM_LKF_QUECVT
- *
- * Force a conversion request to be queued, even if it is compatible with
- * the granted modes of other locks on the same resource.
- *
- * DLM_LKF_IVVALBLK
- *
- * Invalidate the lock value block.
- *
- * DLM_LKF_CONVDEADLK
- *
- * Allows the dlm to resolve conversion deadlocks internally by demoting the
- * granted mode of a converting lock to NL.  The DLM_SBF_DEMOTED flag is
- * returned for a conversion that's been effected by this.
- *
- * DLM_LKF_PERSISTENT
- *
- * Only relevant to locks originating in userspace.  A persistent lock will not
- * be removed if the process holding the lock exits.
- *
- * DLM_LKF_NODLCKWT
- *
- * Do not cancel the lock if it gets into conversion deadlock.
- * Exclude this lock from being monitored due to DLM_LSFL_TIMEWARN.
- *
- * DLM_LKF_NODLCKBLK
- *
- * net yet implemented
- *
- * DLM_LKF_EXPEDITE
- *
- * Used only with new requests for NL mode locks.  Tells the lock manager
- * to grant the lock, ignoring other locks in convert and wait queues.
- *
- * DLM_LKF_NOQUEUEBAST
- *
- * Send blocking AST's before returning -EAGAIN to the caller.  It is only
- * used along with the NOQUEUE flag.  Blocking AST's are not sent for failed
- * NOQUEUE requests otherwise.
- *
- * DLM_LKF_HEADQUE
- *
- * Add a lock to the head of the convert or wait queue rather than the tail.
- *
- * DLM_LKF_NOORDER
- *
- * Disregard the standard grant order rules and grant a lock as soon as it
- * is compatible with other granted locks.
- *
- * DLM_LKF_ORPHAN
- *
- * not yet implemented
- *
- * DLM_LKF_ALTPR
- *
- * If the requested mode cannot be granted immediately, try to grant the lock
- * in PR mode instead.  If this alternate mode is granted instead of the
- * requested mode, DLM_SBF_ALTMODE is returned in the lksb.
- *
- * DLM_LKF_ALTCW
- *
- * The same as ALTPR, but the alternate mode is CW.
- *
- * DLM_LKF_FORCEUNLOCK
- *
- * Unlock the lock even if it is converting or waiting or has sublocks.
- * Only really for use by the userland device.c code.
- *
- */
-#define DLM_LKF_NOQUEUE         0x00000001
-#define DLM_LKF_CANCEL          0x00000002
-#define DLM_LKF_CONVERT         0x00000004
-#define DLM_LKF_VALBLK          0x00000008
-#define DLM_LKF_QUECVT          0x00000010
-#define DLM_LKF_IVVALBLK        0x00000020
-#define DLM_LKF_CONVDEADLK      0x00000040
-#define DLM_LKF_PERSISTENT      0x00000080
-#define DLM_LKF_NODLCKWT        0x00000100
-#define DLM_LKF_NODLCKBLK       0x00000200
-#define DLM_LKF_EXPEDITE        0x00000400
-#define DLM_LKF_NOQUEUEBAST     0x00000800
-#define DLM_LKF_HEADQUE         0x00001000
-#define DLM_LKF_NOORDER         0x00002000
-#define DLM_LKF_ORPHAN          0x00004000
-#define DLM_LKF_ALTPR           0x00008000
-#define DLM_LKF_ALTCW           0x00010000
-#define DLM_LKF_FORCEUNLOCK     0x00020000
-#define DLM_LKF_TIMEOUT         0x00040000
-/*
- * Some return codes that are not in errno.h
- */
-#define DLM_ECANCEL             0x10001
-#define DLM_EUNLOCK             0x10002
 typedef void dlm_lockspace_t;
diff --git a/include/linux/dlmconstants.h b/include/linux/dlmconstants.h
new file mode 100644
index 000000000000..fddb3d3ff321
--- /dev/null
+++ b/include/linux/dlmconstants.h
@@ -0,0 +1,159 @@
+/******************************************************************************
+*******************************************************************************
+**
+**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
+**  Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
+**
+**  This copyrighted material is made available to anyone wishing to use,
+**  modify, copy, or redistribute it subject to the terms and conditions
+**  of the GNU General Public License v.2.
+**
+*******************************************************************************
+******************************************************************************/
+#ifndef __DLMCONSTANTS_DOT_H__
+#define __DLMCONSTANTS_DOT_H__
+/*
+ * Constants used by DLM interface.
+ */
+/*
+ * Lock Modes
+ */
+#define DLM_LOCK_IV             (-1)    /* invalid */
+#define DLM_LOCK_NL             0       /* null */
+#define DLM_LOCK_CR             1       /* concurrent read */
+#define DLM_LOCK_CW             2       /* concurrent write */
+#define DLM_LOCK_PR             3       /* protected read */
+#define DLM_LOCK_PW             4       /* protected write */
+#define DLM_LOCK_EX             5       /* exclusive */
+/*
+ * Flags to dlm_lock
+ *
+ * DLM_LKF_NOQUEUE
+ *
+ * Do not queue the lock request on the wait queue if it cannot be granted
+ * immediately.  If the lock cannot be granted because of this flag, DLM will
+ * either return -EAGAIN from the dlm_lock call or will return 0 from
+ * dlm_lock and -EAGAIN in the lock status block when the AST is executed.
+ *
+ * DLM_LKF_CANCEL
+ *
+ * Used to cancel a pending lock request or conversion.  A converting lock is
+ * returned to its previously granted mode.
+ *
+ * DLM_LKF_CONVERT
+ *
+ * Indicates a lock conversion request.  For conversions the name and namelen
+ * are ignored and the lock ID in the LKSB is used to identify the lock.
+ *
+ * DLM_LKF_VALBLK
+ *
+ * Requests DLM to return the current contents of the lock value block in the
+ * lock status block.  When this flag is set in a lock conversion from PW or EX
+ * modes, DLM assigns the value specified in the lock status block to the lock
+ * value block of the lock resource.  The LVB is a DLM_LVB_LEN size array
+ * containing application-specific information.
+ *
+ * DLM_LKF_QUECVT
+ *
+ * Force a conversion request to be queued, even if it is compatible with
+ * the granted modes of other locks on the same resource.
+ *
+ * DLM_LKF_IVVALBLK
+ *
+ * Invalidate the lock value block.
+ *
+ * DLM_LKF_CONVDEADLK
+ *
+ * Allows the dlm to resolve conversion deadlocks internally by demoting the
+ * granted mode of a converting lock to NL.  The DLM_SBF_DEMOTED flag is
+ * returned for a conversion that's been effected by this.
+ *
+ * DLM_LKF_PERSISTENT
+ *
+ * Only relevant to locks originating in userspace.  A persistent lock will not
+ * be removed if the process holding the lock exits.
+ *
+ * DLM_LKF_NODLCKWT
+ *
+ * Do not cancel the lock if it gets into conversion deadlock.
+ * Exclude this lock from being monitored due to DLM_LSFL_TIMEWARN.
+ *
+ * DLM_LKF_NODLCKBLK
+ *
+ * net yet implemented
+ *
+ * DLM_LKF_EXPEDITE
+ *
+ * Used only with new requests for NL mode locks.  Tells the lock manager
+ * to grant the lock, ignoring other locks in convert and wait queues.
+ *
+ * DLM_LKF_NOQUEUEBAST
+ *
+ * Send blocking AST's before returning -EAGAIN to the caller.  It is only
+ * used along with the NOQUEUE flag.  Blocking AST's are not sent for failed
+ * NOQUEUE requests otherwise.
+ *
+ * DLM_LKF_HEADQUE
+ *
+ * Add a lock to the head of the convert or wait queue rather than the tail.
+ *
+ * DLM_LKF_NOORDER
+ *
+ * Disregard the standard grant order rules and grant a lock as soon as it
+ * is compatible with other granted locks.
+ *
+ * DLM_LKF_ORPHAN
+ *
+ * not yet implemented
+ *
+ * DLM_LKF_ALTPR
+ *
+ * If the requested mode cannot be granted immediately, try to grant the lock
+ * in PR mode instead.  If this alternate mode is granted instead of the
+ * requested mode, DLM_SBF_ALTMODE is returned in the lksb.
+ *
+ * DLM_LKF_ALTCW
+ *
+ * The same as ALTPR, but the alternate mode is CW.
+ *
+ * DLM_LKF_FORCEUNLOCK
+ *
+ * Unlock the lock even if it is converting or waiting or has sublocks.
+ * Only really for use by the userland device.c code.
+ *
+ */
+#define DLM_LKF_NOQUEUE         0x00000001
+#define DLM_LKF_CANCEL          0x00000002
+#define DLM_LKF_CONVERT         0x00000004
+#define DLM_LKF_VALBLK          0x00000008
+#define DLM_LKF_QUECVT          0x00000010
+#define DLM_LKF_IVVALBLK        0x00000020
+#define DLM_LKF_CONVDEADLK      0x00000040
+#define DLM_LKF_PERSISTENT      0x00000080
+#define DLM_LKF_NODLCKWT        0x00000100
+#define DLM_LKF_NODLCKBLK       0x00000200
+#define DLM_LKF_EXPEDITE        0x00000400
+#define DLM_LKF_NOQUEUEBAST     0x00000800
+#define DLM_LKF_HEADQUE         0x00001000
+#define DLM_LKF_NOORDER         0x00002000
+#define DLM_LKF_ORPHAN          0x00004000
+#define DLM_LKF_ALTPR           0x00008000
+#define DLM_LKF_ALTCW           0x00010000
+#define DLM_LKF_FORCEUNLOCK     0x00020000
+#define DLM_LKF_TIMEOUT         0x00040000
+/*
+ * Some return codes that are not in errno.h
+ */
+#define DLM_ECANCEL             0x10001
+#define DLM_EUNLOCK             0x10002
+#endif  /* __DLMCONSTANTS_DOT_H__ */
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index a3b6035b6c86..55c9a6952f44 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -132,7 +132,7 @@ struct dma_chan {
        /* sysfs */
        int chan_id;
-        struct class_device class_dev;
+        struct device dev;
        struct kref refcount;
        int slow_ref;
@@ -142,6 +142,7 @@ struct dma_chan {
        struct dma_chan_percpu *local;
 };
+#define to_dma_chan(p) container_of(p, struct dma_chan, dev)
 void dma_chan_cleanup(struct kref *kref);
diff --git a/include/linux/dmi.h b/include/linux/dmi.h
index 00fc7a9c35ec..5b42a659a308 100644
--- a/include/linux/dmi.h
+++ b/include/linux/dmi.h
@@ -78,6 +78,8 @@ extern const struct dmi_device * dmi_find_device(int type, const char *name,
 extern void dmi_scan_machine(void);
 extern int dmi_get_year(int field);
 extern int dmi_name_in_vendors(const char *str);
+extern int dmi_available;
+extern char *dmi_get_slot(int slot);
 #else
@@ -87,6 +89,8 @@ static inline const struct dmi_device * dmi_find_device(int type, const char *na
        const struct dmi_device *from) { return NULL; }
 static inline int dmi_get_year(int year) { return 0; }
 static inline int dmi_name_in_vendors(const char *s) { return 0; }
+#define dmi_available 0
+static inline char *dmi_get_slot(int slot) { return NULL; }
 #endif
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b3ec4a496d64..21398a5d688d 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1476,7 +1476,7 @@ extern void drop_collected_mounts(struct vfsmount *);
 extern int vfs_statfs(struct dentry *, struct kstatfs *);
 /* /sys/fs */
-extern struct kset fs_subsys;
+extern struct kobject *fs_kobj;
 #define FLOCK_VERIFY_READ  1
 #define FLOCK_VERIFY_WRITE 2
diff --git a/include/linux/futex.h b/include/linux/futex.h
index 92d420fe03f8..1a15f8e237a7 100644
--- a/include/linux/futex.h
+++ b/include/linux/futex.h
@@ -1,8 +1,12 @@
 #ifndef _LINUX_FUTEX_H
 #define _LINUX_FUTEX_H
-#include <linux/sched.h>
+#include <linux/compiler.h>
+#include <linux/types.h>
+struct inode;
+struct mm_struct;
+struct task_struct;
 union ktime;
 /* Second argument to futex syscall */
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index a47b8025d399..1dbea0ac5693 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -10,9 +10,19 @@
 */
 #include <linux/types.h>
+#include <linux/kdev_t.h>
 #ifdef CONFIG_BLOCK
+#define kobj_to_dev(k) container_of(k, struct device, kobj)
+#define dev_to_disk(device) container_of(device, struct gendisk, dev)
+#define dev_to_part(device) container_of(device, struct hd_struct, dev)
+extern struct device_type disk_type;
+extern struct device_type part_type;
+extern struct kobject *block_depr;
+extern struct class block_class;
 enum {
 /* These three have identical behaviour; use the second one if DOS FDISK gets
   confused about extended/logical partitions starting past cylinder 1023. */
@@ -84,7 +94,7 @@ struct partition {
 struct hd_struct {
        sector_t start_sect;
        sector_t nr_sects;
-        struct kobject kobj;
+        struct device dev;
        struct kobject *holder_dir;
        unsigned ios[2], sectors[2];    /* READs and WRITEs */
        int policy, partno;
@@ -117,15 +127,14 @@ struct gendisk {
                                         * disks that can't be partitioned. */
        char disk_name[32];             /* name of major driver */
        struct hd_struct **part;        /* [indexed by minor] */
-        int part_uevent_suppress;
        struct block_device_operations *fops;
        struct request_queue *queue;
        void *private_data;
        sector_t capacity;
        int flags;
-        struct device *driverfs_dev;
+        struct device *driverfs_dev;  // FIXME: remove
-        struct kobject kobj;
+        struct device dev;
        struct kobject *holder_dir;
        struct kobject *slave_dir;
@@ -143,13 +152,6 @@ struct gendisk {
        struct work_struct async_notify;
 };
-/* Structure for sysfs attributes on block devices */
-struct disk_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct gendisk *, char *);
-        ssize_t (*store)(struct gendisk *, const char *, size_t);
-};
 /* 
 * Macros to operate on percpu disk statistics:
 *
@@ -411,7 +413,8 @@ struct unixware_disklabel {
 #define ADDPART_FLAG_RAID       1
 #define ADDPART_FLAG_WHOLEDISK  2
-char *disk_name (struct gendisk *hd, int part, char *buf);
+extern dev_t blk_lookup_devt(const char *name);
+extern char *disk_name (struct gendisk *hd, int part, char *buf);
 extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
 extern void add_partition(struct gendisk *, int, sector_t, sector_t, int);
@@ -423,12 +426,12 @@ extern struct gendisk *alloc_disk(int minors);
 extern struct kobject *get_disk(struct gendisk *disk);
 extern void put_disk(struct gendisk *disk);
 extern void genhd_media_change_notify(struct gendisk *disk);
-extern void blk_register_region(dev_t dev, unsigned long range,
+extern void blk_register_region(dev_t devt, unsigned long range,
                        struct module *module,
                        struct kobject *(*probe)(dev_t, int *, void *),
                        int (*lock)(dev_t, void *),
                        void *data);
-extern void blk_unregister_region(dev_t dev, unsigned long range);
+extern void blk_unregister_region(dev_t devt, unsigned long range);
 static inline struct block_device *bdget_disk(struct gendisk *disk, int index)
 {
@@ -441,6 +444,12 @@ static inline struct block_device *bdget_disk(struct gendisk *disk, int index)
 static inline void printk_all_partitions(void) { }
+static inline dev_t blk_lookup_devt(const char *name)
+{
+        dev_t devt = MKDEV(0, 0);
+        return devt;
+}
 #endif /* CONFIG_BLOCK */
 #endif
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 8d302298a161..2961ec788046 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -72,11 +72,7 @@
 #define in_softirq()            (softirq_count())
 #define in_interrupt()          (irq_count())
-#if defined(CONFIG_PREEMPT) && !defined(CONFIG_PREEMPT_BKL)
+#define in_atomic()             ((preempt_count() & ~PREEMPT_ACTIVE) != 0)
-# define in_atomic()    ((preempt_count() & ~PREEMPT_ACTIVE) != kernel_locked())
-#else
-# define in_atomic()    ((preempt_count() & ~PREEMPT_ACTIVE) != 0)
-#endif
 #ifdef CONFIG_PREEMPT
 # define PREEMPT_CHECK_OFFSET 1
diff --git a/include/linux/hdreg.h b/include/linux/hdreg.h
index 818c6afc1091..ff43f8d6b5b3 100644
--- a/include/linux/hdreg.h
+++ b/include/linux/hdreg.h
@@ -44,7 +44,9 @@
 /* Bits for HD_ERROR */
 #define MARK_ERR                0x01    /* Bad address mark */
+#define ILI_ERR                 0x01    /* Illegal Length Indication (ATAPI) */
 #define TRK0_ERR                0x02    /* couldn't find track 0 */
+#define EOM_ERR                 0x02    /* End Of Media (ATAPI) */
 #define ABRT_ERR                0x04    /* Command aborted */
 #define MCR_ERR                 0x08    /* media change request */
 #define ID_ERR                  0x10    /* ID field not found */
@@ -52,6 +54,7 @@
 #define ECC_ERR                 0x40    /* Uncorrectable ECC error */
 #define BBD_ERR                 0x80    /* pre-EIDE meaning:  block marked bad */
 #define ICRC_ERR                0x80    /* new meaning:  CRC error during transfer */
+#define LFS_ERR                 0xf0    /* Last Failed Sense (ATAPI) */
 /* Bits of HD_NSECTOR */
 #define CD                      0x01
@@ -70,13 +73,13 @@
 #define HDIO_DRIVE_HOB_HDR_SIZE         (8 * sizeof(__u8))
 #define HDIO_DRIVE_TASK_HDR_SIZE        (8 * sizeof(__u8))
-#define IDE_DRIVE_TASK_INVALID          -1
 #define IDE_DRIVE_TASK_NO_DATA          0
+#ifndef __KERNEL__
+#define IDE_DRIVE_TASK_INVALID          -1
 #define IDE_DRIVE_TASK_SET_XFER         1
 #define IDE_DRIVE_TASK_IN               2
 #define IDE_DRIVE_TASK_OUT              3
+#endif
 #define IDE_DRIVE_TASK_RAW_WRITE        4
 /*
@@ -87,10 +90,10 @@
 #ifndef __KERNEL__
 #define IDE_TASKFILE_STD_OUT_FLAGS      0xFE
 #define IDE_HOB_STD_OUT_FLAGS           0x3C
-#endif
 typedef unsigned char task_ioreg_t;
 typedef unsigned long sata_ioreg_t;
+#endif
 typedef union ide_reg_valid_s {
        unsigned all                            : 16;
@@ -116,8 +119,8 @@ typedef union ide_reg_valid_s {
 } ide_reg_valid_t;
 typedef struct ide_task_request_s {
-        task_ioreg_t    io_ports[8];
+        __u8            io_ports[8];
-        task_ioreg_t    hob_ports[8];
+        __u8            hob_ports[8]; /* bytes 6 and 7 are unused */
        ide_reg_valid_t out_flags;
        ide_reg_valid_t in_flags;
        int             data_phase;
@@ -133,36 +136,35 @@ typedef struct ide_ioctl_request_s {
 } ide_ioctl_request_t;
 struct hd_drive_cmd_hdr {
-        task_ioreg_t command;
+        __u8 command;
-        task_ioreg_t sector_number;
+        __u8 sector_number;
-        task_ioreg_t feature;
+        __u8 feature;
-        task_ioreg_t sector_count;
+        __u8 sector_count;
 };
+#ifndef __KERNEL__
 typedef struct hd_drive_task_hdr {
-        task_ioreg_t data;
+        __u8 data;
-        task_ioreg_t feature;
+        __u8 feature;
-        task_ioreg_t sector_count;
+        __u8 sector_count;
-        task_ioreg_t sector_number;
+        __u8 sector_number;
-        task_ioreg_t low_cylinder;
+        __u8 low_cylinder;
-        task_ioreg_t high_cylinder;
+        __u8 high_cylinder;
-        task_ioreg_t device_head;
+        __u8 device_head;
-        task_ioreg_t command;
+        __u8 command;
 } task_struct_t;
 typedef struct hd_drive_hob_hdr {
-        task_ioreg_t data;
+        __u8 data;
-        task_ioreg_t feature;
+        __u8 feature;
-        task_ioreg_t sector_count;
+        __u8 sector_count;
-        task_ioreg_t sector_number;
+        __u8 sector_number;
-        task_ioreg_t low_cylinder;
+        __u8 low_cylinder;
-        task_ioreg_t high_cylinder;
+        __u8 high_cylinder;
-        task_ioreg_t device_head;
+        __u8 device_head;
-        task_ioreg_t control;
+        __u8 control;
 } hob_struct_t;
+#endif
-#define TASKFILE_INVALID                0x7fff
-#define TASKFILE_48                     0x8000
 #define TASKFILE_NO_DATA                0x0000
@@ -178,12 +180,16 @@ typedef struct hd_drive_hob_hdr {
 #define TASKFILE_IN_DMAQ                0x0080
 #define TASKFILE_OUT_DMAQ               0x0100
+#ifndef __KERNEL__
 #define TASKFILE_P_IN                   0x0200
 #define TASKFILE_P_OUT                  0x0400
 #define TASKFILE_P_IN_DMA               0x0800
 #define TASKFILE_P_OUT_DMA              0x1000
 #define TASKFILE_P_IN_DMAQ              0x2000
 #define TASKFILE_P_OUT_DMAQ             0x4000
+#define TASKFILE_48                     0x8000
+#define TASKFILE_INVALID                0x7fff
+#endif
 /* ATA/ATAPI Commands pre T13 Spec */
 #define WIN_NOP                         0x00
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 7a9398e19704..49067f14fac1 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -115,10 +115,8 @@ struct hrtimer {
        enum hrtimer_restart            (*function)(struct hrtimer *);
        struct hrtimer_clock_base       *base;
        unsigned long                   state;
-#ifdef CONFIG_HIGH_RES_TIMERS
        enum hrtimer_cb_mode            cb_mode;
        struct list_head                cb_entry;
-#endif
 #ifdef CONFIG_TIMER_STATS
        void                            *start_site;
        char                            start_comm[16];
@@ -194,10 +192,10 @@ struct hrtimer_cpu_base {
        spinlock_t                      lock;
        struct lock_class_key           lock_key;
        struct hrtimer_clock_base       clock_base[HRTIMER_MAX_CLOCK_BASES];
+        struct list_head                cb_pending;
 #ifdef CONFIG_HIGH_RES_TIMERS
        ktime_t                         expires_next;
        int                             hres_active;
-        struct list_head                cb_pending;
        unsigned long                   nr_events;
 #endif
 };
@@ -217,6 +215,11 @@ static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
        return timer->base->get_time();
 }
+static inline int hrtimer_is_hres_active(struct hrtimer *timer)
+{
+        return timer->base->cpu_base->hres_active;
+}
 /*
 * The resolution of the clocks. The resolution value is returned in
 * the clock_getres() system call to give application programmers an
@@ -248,6 +251,10 @@ static inline ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
        return timer->base->softirq_time;
 }
+static inline int hrtimer_is_hres_active(struct hrtimer *timer)
+{
+        return 0;
+}
 #endif
 extern ktime_t ktime_get(void);
@@ -310,6 +317,7 @@ extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
 /* Soft interrupt function to run the hrtimer queues: */
 extern void hrtimer_run_queues(void);
+extern void hrtimer_run_pending(void);
 /* Bootup initialization: */
 extern void __init hrtimers_init(void);
diff --git a/include/linux/hw_random.h b/include/linux/hw_random.h
index 21ea7610e177..85d11916e9ea 100644
--- a/include/linux/hw_random.h
+++ b/include/linux/hw_random.h
@@ -33,7 +33,7 @@ struct hwrng {
        const char *name;
        int (*init)(struct hwrng *rng);
        void (*cleanup)(struct hwrng *rng);
-        int (*data_present)(struct hwrng *rng);
+        int (*data_present)(struct hwrng *rng, int wait);
        int (*data_read)(struct hwrng *rng, u32 *data);
        unsigned long priv;
diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
index 88c81403eb3f..c7a51a196f51 100644
--- a/include/linux/i2c-id.h
+++ b/include/linux/i2c-id.h
@@ -23,6 +23,10 @@
 #ifndef LINUX_I2C_ID_H
 #define LINUX_I2C_ID_H
+/* Please note that I2C driver IDs are optional. They are only needed if a
+   legacy chip driver needs to identify a bus or a bus driver needs to
+   identify a legacy client. If you don't need them, just don't set them. */
 /*
 * ---- Driver types -----------------------------------------------------
 */
@@ -121,6 +125,8 @@
 #define I2C_DRIVERID_LM4857     92      /* LM4857 Audio Amplifier */
 #define I2C_DRIVERID_VP27SMPX   93      /* Panasonic VP27s tuner internal MPX */
 #define I2C_DRIVERID_CS4270     94      /* Cirrus Logic 4270 audio codec */
+#define I2C_DRIVERID_M52790     95      /* Mitsubishi M52790SP/FP AV switch */
+#define I2C_DRIVERID_CS5345     96      /* cs5345 audio processor       */
 #define I2C_DRIVERID_I2CDEV     900
 #define I2C_DRIVERID_ARP        902    /* SMBus ARP Client              */
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 9a6a41e7079f..1e4409937ec3 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -27,25 +27,10 @@
 #include <asm/semaphore.h>
 #include <asm/mutex.h>
-/******************************************************************************
+#if defined(CRIS) || defined(FRV)
- * IDE driver configuration options (play with these as desired):
+# define SUPPORT_VLB_SYNC 0
- *
+#else
- * REALLY_SLOW_IO can be defined in ide.c and ide-cd.c, if necessary
+# define SUPPORT_VLB_SYNC 1
- */
-#define INITIAL_MULT_COUNT      0       /* off=0; on=2,4,8,16,32, etc.. */
-#ifndef SUPPORT_SLOW_DATA_PORTS         /* 1 to support slow data ports */
-#define SUPPORT_SLOW_DATA_PORTS 1       /* 0 to reduce kernel size */
-#endif
-#ifndef SUPPORT_VLB_SYNC                /* 1 to support weird 32-bit chips */
-#define SUPPORT_VLB_SYNC        1       /* 0 to reduce kernel size */
-#endif
-#ifndef OK_TO_RESET_CONTROLLER          /* 1 needed for good error recovery */
-#define OK_TO_RESET_CONTROLLER  1       /* 0 for use with AH2372A/B interface */
-#endif
-#ifndef DISABLE_IRQ_NOSYNC
-#define DISABLE_IRQ_NOSYNC      0
 #endif
 /*
@@ -55,10 +40,6 @@
 
 #define IDE_NO_IRQ              (-1)
-/*
- *  "No user-serviceable parts" beyond this point  :)
- *****************************************************************************/
 typedef unsigned char   byte;   /* used everywhere */
 /*
@@ -103,8 +84,6 @@ typedef unsigned char	byte;	/* used everywhere */
 #define IDE_FEATURE_OFFSET      IDE_ERROR_OFFSET
 #define IDE_COMMAND_OFFSET      IDE_STATUS_OFFSET
-#define IDE_CONTROL_OFFSET_HOB  (7)
 #define IDE_DATA_REG            (HWIF(drive)->io_ports[IDE_DATA_OFFSET])
 #define IDE_ERROR_REG           (HWIF(drive)->io_ports[IDE_ERROR_OFFSET])
 #define IDE_NSECTOR_REG         (HWIF(drive)->io_ports[IDE_NSECTOR_OFFSET])
@@ -327,47 +306,16 @@ static inline void ide_init_hwif_ports(hw_regs_t *hw,
 typedef union {
        unsigned all                    : 8;
        struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
                unsigned set_geometry   : 1;
                unsigned recalibrate    : 1;
                unsigned set_multmode   : 1;
                unsigned set_tune       : 1;
                unsigned serviced       : 1;
                unsigned reserved       : 3;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                unsigned reserved       : 3;
-                unsigned serviced       : 1;
-                unsigned set_tune       : 1;
-                unsigned set_multmode   : 1;
-                unsigned recalibrate    : 1;
-                unsigned set_geometry   : 1;
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
        } b;
 } special_t;
 /*
- * ATA DATA Register Special.
- * ATA NSECTOR Count Register().
- * ATAPI Byte Count Register.
- */
-typedef union {
-        unsigned all                    :16;
-        struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-                unsigned low            :8;     /* LSB */
-                unsigned high           :8;     /* MSB */
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                unsigned high           :8;     /* MSB */
-                unsigned low            :8;     /* LSB */
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
-        } b;
-} ata_nsector_t, ata_data_t, atapi_bcount_t;
-/*
 * ATA-IDE Select Register, aka Device-Head
 *
 * head         : always zeros here
@@ -398,131 +346,6 @@ typedef union {
 } select_t, ata_select_t;
 /*
- * The ATA-IDE Status Register.
- * The ATAPI Status Register.
- *
- * check        : Error occurred
- * idx          : Index Error
- * corr         : Correctable error occurred
- * drq          : Data is request by the device
- * dsc          : Disk Seek Complete                    : ata
- *              : Media access command finished         : atapi
- * df           : Device Fault                          : ata
- *              : Reserved                              : atapi
- * drdy         : Ready, Command Mode Capable           : ata
- *              : Ignored for ATAPI commands            : atapi
- * bsy          : Disk is Busy
- *              : The device has access to the command block
- */
-typedef union {
-        unsigned all                    :8;
-        struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-                unsigned check          :1;
-                unsigned idx            :1;
-                unsigned corr           :1;
-                unsigned drq            :1;
-                unsigned dsc            :1;
-                unsigned df             :1;
-                unsigned drdy           :1;
-                unsigned bsy            :1;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                unsigned bsy            :1;
-                unsigned drdy           :1;
-                unsigned df             :1;
-                unsigned dsc            :1;
-                unsigned drq            :1;
-                unsigned corr           :1;
-                unsigned idx            :1;
-                unsigned check          :1;
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
-        } b;
-} ata_status_t, atapi_status_t;
-/*
- * ATAPI Feature Register
- *
- * dma          : Using DMA or PIO
- * reserved321  : Reserved
- * reserved654  : Reserved (Tag Type)
- * reserved7    : Reserved
- */
-typedef union {
-        unsigned all                    :8;
-        struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-                unsigned dma            :1;
-                unsigned reserved321    :3;
-                unsigned reserved654    :3;
-                unsigned reserved7      :1;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                unsigned reserved7      :1;
-                unsigned reserved654    :3;
-                unsigned reserved321    :3;
-                unsigned dma            :1;
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
-        } b;
-} atapi_feature_t;
-/*
- * ATAPI Interrupt Reason Register.
- *
- * cod          : Information transferred is command (1) or data (0)
- * io           : The device requests us to read (1) or write (0)
- * reserved     : Reserved
- */
-typedef union {
-        unsigned all                    :8;
-        struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-                unsigned cod            :1;
-                unsigned io             :1;
-                unsigned reserved       :6;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                unsigned reserved       :6;
-                unsigned io             :1;
-                unsigned cod            :1;
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
-        } b;
-} atapi_ireason_t;
-/*
- * The ATAPI error register.
- *
- * ili          : Illegal Length Indication
- * eom          : End Of Media Detected
- * abrt         : Aborted command - As defined by ATA
- * mcr          : Media Change Requested - As defined by ATA
- * sense_key    : Sense key of the last failed packet command
- */
-typedef union {
-        unsigned all                    :8;
-        struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-                unsigned ili            :1;
-                unsigned eom            :1;
-                unsigned abrt           :1;
-                unsigned mcr            :1;
-                unsigned sense_key      :4;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                unsigned sense_key      :4;
-                unsigned mcr            :1;
-                unsigned abrt           :1;
-                unsigned eom            :1;
-                unsigned ili            :1;
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
-        } b;
-} atapi_error_t;
-/*
 * Status returned from various ide_ functions
 */
 typedef enum {
@@ -701,8 +524,6 @@ typedef struct hwif_s {
        void    (*pre_reset)(ide_drive_t *);
        /* routine to reset controller after a disk reset */
        void    (*resetproc)(ide_drive_t *);
-        /* special interrupt handling for shared pci interrupts */
-        void    (*intrproc)(ide_drive_t *);
        /* special host masking for drive selection */
        void    (*maskproc)(ide_drive_t *, int);
        /* check host's drive quirk list */
@@ -766,7 +587,6 @@ typedef struct hwif_s {
        int             rqsize;         /* max sectors per request */
        int             irq;            /* our irq number */
-        unsigned long   dma_master;     /* reference base addr dmabase */
        unsigned long   dma_base;       /* base addr for dma ports */
        unsigned long   dma_command;    /* dma command register */
        unsigned long   dma_vendor1;    /* dma vendor 1 register */
@@ -806,7 +626,6 @@ typedef struct hwif_s {
 /*
 *  internal ide interrupt handler type
 */
-typedef ide_startstop_t (ide_pre_handler_t)(ide_drive_t *, struct request *);
 typedef ide_startstop_t (ide_handler_t)(ide_drive_t *);
 typedef int (ide_expiry_t)(ide_drive_t *);
@@ -1020,7 +839,8 @@ int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
 extern void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry);
-extern void ide_execute_command(ide_drive_t *, task_ioreg_t cmd, ide_handler_t *, unsigned int, ide_expiry_t *);
+void ide_execute_command(ide_drive_t *, u8, ide_handler_t *, unsigned int,
+                         ide_expiry_t *);
 ide_startstop_t __ide_error(ide_drive_t *, struct request *, u8, u8);
@@ -1062,52 +882,114 @@ extern void ide_end_drive_cmd(ide_drive_t *, u8, u8);
 */
 extern int ide_wait_cmd(ide_drive_t *, u8, u8, u8, u8, u8 *);
+enum {
+        IDE_TFLAG_LBA48                 = (1 << 0),
+        IDE_TFLAG_NO_SELECT_MASK        = (1 << 1),
+        IDE_TFLAG_FLAGGED               = (1 << 2),
+        IDE_TFLAG_OUT_DATA              = (1 << 3),
+        IDE_TFLAG_OUT_HOB_FEATURE       = (1 << 4),
+        IDE_TFLAG_OUT_HOB_NSECT         = (1 << 5),
+        IDE_TFLAG_OUT_HOB_LBAL          = (1 << 6),
+        IDE_TFLAG_OUT_HOB_LBAM          = (1 << 7),
+        IDE_TFLAG_OUT_HOB_LBAH          = (1 << 8),
+        IDE_TFLAG_OUT_HOB               = IDE_TFLAG_OUT_HOB_FEATURE |
+                                          IDE_TFLAG_OUT_HOB_NSECT |
+                                          IDE_TFLAG_OUT_HOB_LBAL |
+                                          IDE_TFLAG_OUT_HOB_LBAM |
+                                          IDE_TFLAG_OUT_HOB_LBAH,
+        IDE_TFLAG_OUT_FEATURE           = (1 << 9),
+        IDE_TFLAG_OUT_NSECT             = (1 << 10),
+        IDE_TFLAG_OUT_LBAL              = (1 << 11),
+        IDE_TFLAG_OUT_LBAM              = (1 << 12),
+        IDE_TFLAG_OUT_LBAH              = (1 << 13),
+        IDE_TFLAG_OUT_TF                = IDE_TFLAG_OUT_FEATURE |
+                                          IDE_TFLAG_OUT_NSECT |
+                                          IDE_TFLAG_OUT_LBAL |
+                                          IDE_TFLAG_OUT_LBAM |
+                                          IDE_TFLAG_OUT_LBAH,
+        IDE_TFLAG_OUT_DEVICE            = (1 << 14),
+        IDE_TFLAG_WRITE                 = (1 << 15),
+        IDE_TFLAG_FLAGGED_SET_IN_FLAGS  = (1 << 16),
+        IDE_TFLAG_IN_DATA               = (1 << 17),
+        IDE_TFLAG_CUSTOM_HANDLER        = (1 << 18),
+        IDE_TFLAG_DMA_PIO_FALLBACK      = (1 << 19),
+        IDE_TFLAG_IN_HOB_FEATURE        = (1 << 20),
+        IDE_TFLAG_IN_HOB_NSECT          = (1 << 21),
+        IDE_TFLAG_IN_HOB_LBAL           = (1 << 22),
+        IDE_TFLAG_IN_HOB_LBAM           = (1 << 23),
+        IDE_TFLAG_IN_HOB_LBAH           = (1 << 24),
+        IDE_TFLAG_IN_HOB_LBA            = IDE_TFLAG_IN_HOB_LBAL |
+                                          IDE_TFLAG_IN_HOB_LBAM |
+                                          IDE_TFLAG_IN_HOB_LBAH,
+        IDE_TFLAG_IN_HOB                = IDE_TFLAG_IN_HOB_FEATURE |
+                                          IDE_TFLAG_IN_HOB_NSECT |
+                                          IDE_TFLAG_IN_HOB_LBA,
+        IDE_TFLAG_IN_NSECT              = (1 << 25),
+        IDE_TFLAG_IN_LBAL               = (1 << 26),
+        IDE_TFLAG_IN_LBAM               = (1 << 27),
+        IDE_TFLAG_IN_LBAH               = (1 << 28),
+        IDE_TFLAG_IN_LBA                = IDE_TFLAG_IN_LBAL |
+                                          IDE_TFLAG_IN_LBAM |
+                                          IDE_TFLAG_IN_LBAH,
+        IDE_TFLAG_IN_TF                 = IDE_TFLAG_IN_NSECT |
+                                          IDE_TFLAG_IN_LBA,
+        IDE_TFLAG_IN_DEVICE             = (1 << 29),
+};
+struct ide_taskfile {
+        u8      hob_data;       /*  0: high data byte (for TASKFILE IOCTL) */
+        u8      hob_feature;    /*  1-5: additional data to support LBA48 */
+        u8      hob_nsect;
+        u8      hob_lbal;
+        u8      hob_lbam;
+        u8      hob_lbah;
+        u8      data;           /*  6: low data byte (for TASKFILE IOCTL) */
+        union {                 /*  7: */
+                u8 error;       /*   read:  error */
+                u8 feature;     /*  write: feature */
+        };
+        u8      nsect;          /*  8: number of sectors */
+        u8      lbal;           /*  9: LBA low */
+        u8      lbam;           /* 10: LBA mid */
+        u8      lbah;           /* 11: LBA high */
+        u8      device;         /* 12: device select */
+        union {                 /* 13: */
+                u8 status;      /*  read: status  */
+                u8 command;     /* write: command */
+        };
+};
 typedef struct ide_task_s {
-/*
+        union {
- *      struct hd_drive_task_hdr        tf;
+                struct ide_taskfile     tf;
- *      task_struct_t           tf;
+                u8                      tf_array[14];
- *      struct hd_drive_hob_hdr         hobf;
+        };
- *      hob_struct_t            hobf;
+        u32                     tf_flags;
- */
-        task_ioreg_t            tfRegister[8];
-        task_ioreg_t            hobRegister[8];
-        ide_reg_valid_t         tf_out_flags;
-        ide_reg_valid_t         tf_in_flags;
        int                     data_phase;
-        int                     command_type;
-        ide_pre_handler_t       *prehandler;
-        ide_handler_t           *handler;
        struct request          *rq;            /* copy of request */
        void                    *special;       /* valid_t generally */
 } ide_task_t;
-extern u32 ide_read_24(ide_drive_t *);
+void ide_tf_load(ide_drive_t *, ide_task_t *);
+void ide_tf_read(ide_drive_t *, ide_task_t *);
 extern void SELECT_DRIVE(ide_drive_t *);
-extern void SELECT_INTERRUPT(ide_drive_t *);
 extern void SELECT_MASK(ide_drive_t *, int);
-extern void QUIRK_LIST(ide_drive_t *);
 extern int drive_is_ready(ide_drive_t *);
-/*
+void ide_pktcmd_tf_load(ide_drive_t *, u32, u16, u8);
- * taskfile io for disks for now...and builds request from ide_ioctl
- */
-extern ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
-/*
- * Special Flagged Register Validation Caller
- */
-extern ide_startstop_t flagged_taskfile(ide_drive_t *, ide_task_t *);
-extern ide_startstop_t set_multmode_intr(ide_drive_t *);
+ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
-extern ide_startstop_t set_geometry_intr(ide_drive_t *);
-extern ide_startstop_t recal_intr(ide_drive_t *);
-extern ide_startstop_t task_no_data_intr(ide_drive_t *);
-extern ide_startstop_t task_in_intr(ide_drive_t *);
-extern ide_startstop_t pre_task_out_intr(ide_drive_t *, struct request *);
-extern int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *);
+int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *, u16);
+int ide_no_data_taskfile(ide_drive_t *, ide_task_t *);
 int ide_taskfile_ioctl(ide_drive_t *, unsigned int, unsigned long);
 int ide_cmd_ioctl(ide_drive_t *, unsigned int, unsigned long);
@@ -1212,6 +1094,7 @@ enum {
        IDE_HFLAG_IO_32BIT              = (1 << 24),
        /* unmask IRQs */
        IDE_HFLAG_UNMASK_IRQS           = (1 << 25),
+        IDE_HFLAG_ABUSE_SET_DMA_MODE    = (1 << 26),
 };
 #ifdef CONFIG_BLK_DEV_OFFBOARD
@@ -1229,7 +1112,7 @@ struct ide_port_info {
        void                    (*fixup)(ide_hwif_t *);
        ide_pci_enablebit_t     enablebits[2];
        hwif_chipset_t          chipset;
-        unsigned int            extra;
+        u8                      extra;
        u32                     host_flags;
        u8                      pio_mask;
        u8                      swdma_mask;
@@ -1356,6 +1239,7 @@ static inline int ide_dev_is_sata(struct hd_driveid *id)
        return 0;
 }
+u64 ide_get_lba_addr(struct ide_taskfile *, int);
 u8 ide_dump_status(ide_drive_t *, const char *, u8);
 typedef struct ide_pio_timings_s {
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index cae35b6b9aec..796019b22b6f 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -132,9 +132,12 @@ extern struct group_info init_groups;
        .cpus_allowed   = CPU_MASK_ALL,                                 \
        .mm             = NULL,                                         \
        .active_mm      = &init_mm,                                     \
-        .run_list       = LIST_HEAD_INIT(tsk.run_list),                 \
+        .rt             = {                                             \
+                .run_list       = LIST_HEAD_INIT(tsk.rt.run_list),      \
+                .time_slice     = HZ,                                   \
+                .nr_cpus_allowed = NR_CPUS,                             \
+        },                                                              \
        .ioprio         = 0,                                            \
-        .time_slice     = HZ,                                           \
        .tasks          = LIST_HEAD_INIT(tsk.tasks),                    \
        .ptrace_children= LIST_HEAD_INIT(tsk.ptrace_children),          \
        .ptrace_list    = LIST_HEAD_INIT(tsk.ptrace_list),              \
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index 2306920fa388..c3db4a00f1fa 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -256,6 +256,7 @@ enum
 #ifdef CONFIG_HIGH_RES_TIMERS
        HRTIMER_SOFTIRQ,
 #endif
+        RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
 };
 /* softirq mask and active fields moved to irq_cpustat_t in
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index 8b080024bbc1..7ba9e47bf061 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -29,6 +29,12 @@
 # define SHIFT_HZ       9
 #elif HZ >= 768 && HZ < 1536
 # define SHIFT_HZ       10
+#elif HZ >= 1536 && HZ < 3072
+# define SHIFT_HZ       11
+#elif HZ >= 3072 && HZ < 6144
+# define SHIFT_HZ       12
+#elif HZ >= 6144 && HZ < 12288
+# define SHIFT_HZ       13
 #else
 # error You lose.
 #endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 94bc99656963..a7283c9beadf 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -105,8 +105,8 @@ struct user;
 * supposed to.
 */
 #ifdef CONFIG_PREEMPT_VOLUNTARY
-extern int cond_resched(void);
+extern int _cond_resched(void);
-# define might_resched() cond_resched()
+# define might_resched() _cond_resched()
 #else
 # define might_resched() do { } while (0)
 #endif
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 4a0d27f475d7..caa3f411f15d 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -3,15 +3,14 @@
 *
 * Copyright (c) 2002-2003 Patrick Mochel
 * Copyright (c) 2002-2003 Open Source Development Labs
- * Copyright (c) 2006-2007 Greg Kroah-Hartman <greg@kroah.com>
+ * Copyright (c) 2006-2008 Greg Kroah-Hartman <greg@kroah.com>
- * Copyright (c) 2006-2007 Novell Inc.
+ * Copyright (c) 2006-2008 Novell Inc.
 *
 * This file is released under the GPLv2.
 *
- * 
 * Please read Documentation/kobject.txt before using the kobject
 * interface, ESPECIALLY the parts about reference counts and object
- * destructors. 
+ * destructors.
 */
 #ifndef _KOBJECT_H_
@@ -61,48 +60,54 @@ enum kobject_action {
 };
 struct kobject {
-        const char              * k_name;
+        const char              *name;
        struct kref             kref;
        struct list_head        entry;
-        struct kobject          * parent;
+        struct kobject          *parent;
-        struct kset             * kset;
+        struct kset             *kset;
-        struct kobj_type        * ktype;
+        struct kobj_type        *ktype;
-        struct sysfs_dirent     * sd;
+        struct sysfs_dirent     *sd;
+        unsigned int state_initialized:1;
+        unsigned int state_in_sysfs:1;
+        unsigned int state_add_uevent_sent:1;
+        unsigned int state_remove_uevent_sent:1;
 };
-extern int kobject_set_name(struct kobject *, const char *, ...)
+extern int kobject_set_name(struct kobject *kobj, const char *name, ...)
-        __attribute__((format(printf,2,3)));
+                            __attribute__((format(printf, 2, 3)));
-static inline const char * kobject_name(const struct kobject * kobj)
+static inline const char *kobject_name(const struct kobject *kobj)
 {
-        return kobj->k_name;
+        return kobj->name;
 }
-extern void kobject_init(struct kobject *);
+extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
-extern void kobject_cleanup(struct kobject *);
+extern int __must_check kobject_add(struct kobject *kobj,
+                                    struct kobject *parent,
+                                    const char *fmt, ...);
+extern int __must_check kobject_init_and_add(struct kobject *kobj,
+                                             struct kobj_type *ktype,
+                                             struct kobject *parent,
+                                             const char *fmt, ...);
+extern void kobject_del(struct kobject *kobj);
-extern int __must_check kobject_add(struct kobject *);
+extern struct kobject * __must_check kobject_create(void);
-extern void kobject_del(struct kobject *);
+extern struct kobject * __must_check kobject_create_and_add(const char *name,
+                                                struct kobject *parent);
 extern int __must_check kobject_rename(struct kobject *, const char *new_name);
 extern int __must_check kobject_move(struct kobject *, struct kobject *);
-extern int __must_check kobject_register(struct kobject *);
+extern struct kobject *kobject_get(struct kobject *kobj);
-extern void kobject_unregister(struct kobject *);
+extern void kobject_put(struct kobject *kobj);
-extern struct kobject * kobject_get(struct kobject *);
-extern void kobject_put(struct kobject *);
-extern struct kobject *kobject_kset_add_dir(struct kset *kset,
-                                            struct kobject *, const char *);
-extern struct kobject *kobject_add_dir(struct kobject *, const char *);
-extern char * kobject_get_path(struct kobject *, gfp_t);
+extern char *kobject_get_path(struct kobject *kobj, gfp_t flag);
 struct kobj_type {
-        void (*release)(struct kobject *);
+        void (*release)(struct kobject *kobj);
-        struct sysfs_ops        * sysfs_ops;
+        struct sysfs_ops *sysfs_ops;
-        struct attribute        ** default_attrs;
+        struct attribute **default_attrs;
 };
 struct kobj_uevent_env {
@@ -119,6 +124,16 @@ struct kset_uevent_ops {
                      struct kobj_uevent_env *env);
 };
+struct kobj_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
+                        char *buf);
+        ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
+                         const char *buf, size_t count);
+};
+extern struct sysfs_ops kobj_sysfs_ops;
 /**
 * struct kset - a set of kobjects of a specific type, belonging to a specific subsystem.
 *
@@ -128,7 +143,6 @@ struct kset_uevent_ops {
 * define the attribute callbacks and other common events that happen to
 * a kobject.
 *
- * @ktype: the struct kobj_type for this specific kset
 * @list: the list of all kobjects for this kset
 * @list_lock: a lock for iterating over the kobjects
 * @kobj: the embedded kobject for this kset (recursion, isn't it fun...)
@@ -138,99 +152,49 @@ struct kset_uevent_ops {
 * desired.
 */
 struct kset {
-        struct kobj_type        *ktype;
+        struct list_head list;
-        struct list_head        list;
+        spinlock_t list_lock;
-        spinlock_t              list_lock;
+        struct kobject kobj;
-        struct kobject          kobj;
+        struct kset_uevent_ops *uevent_ops;
-        struct kset_uevent_ops  *uevent_ops;
 };
+extern void kset_init(struct kset *kset);
+extern int __must_check kset_register(struct kset *kset);
+extern void kset_unregister(struct kset *kset);
+extern struct kset * __must_check kset_create_and_add(const char *name,
+                                                struct kset_uevent_ops *u,
+                                                struct kobject *parent_kobj);
-extern void kset_init(struct kset * k);
+static inline struct kset *to_kset(struct kobject *kobj)
-extern int __must_check kset_add(struct kset * k);
-extern int __must_check kset_register(struct kset * k);
-extern void kset_unregister(struct kset * k);
-static inline struct kset * to_kset(struct kobject * kobj)
 {
-        return kobj ? container_of(kobj,struct kset,kobj) : NULL;
+        return kobj ? container_of(kobj, struct kset, kobj) : NULL;
 }
-static inline struct kset * kset_get(struct kset * k)
+static inline struct kset *kset_get(struct kset *k)
 {
        return k ? to_kset(kobject_get(&k->kobj)) : NULL;
 }
-static inline void kset_put(struct kset * k)
+static inline void kset_put(struct kset *k)
 {
        kobject_put(&k->kobj);
 }
-static inline struct kobj_type * get_ktype(struct kobject * k)
+static inline struct kobj_type *get_ktype(struct kobject *kobj)
 {
-        if (k->kset && k->kset->ktype)
+        return kobj->ktype;
-                return k->kset->ktype;
-        else 
-                return k->ktype;
 }
-extern struct kobject * kset_find_obj(struct kset *, const char *);
+extern struct kobject *kset_find_obj(struct kset *, const char *);
-/*
- * Use this when initializing an embedded kset with no other 
- * fields to initialize.
- */
-#define set_kset_name(str)      .kset = { .kobj = { .k_name = str } }
-#define decl_subsys(_name,_type,_uevent_ops) \
-struct kset _name##_subsys = { \
-        .kobj = { .k_name = __stringify(_name) }, \
-        .ktype = _type, \
-        .uevent_ops =_uevent_ops, \
-}
-#define decl_subsys_name(_varname,_name,_type,_uevent_ops) \
-struct kset _varname##_subsys = { \
-        .kobj = { .k_name = __stringify(_name) }, \
-        .ktype = _type, \
-        .uevent_ops =_uevent_ops, \
-}
-/* The global /sys/kernel/ subsystem for people to chain off of */
-extern struct kset kernel_subsys;
-/* The global /sys/hypervisor/ subsystem  */
-extern struct kset hypervisor_subsys;
-/*
- * Helpers for setting the kset of registered objects.
- * Often, a registered object belongs to a kset embedded in a 
- * subsystem. These do no magic, just make the resulting code
- * easier to follow. 
- */
-/**
- *      kobj_set_kset_s(obj,subsys) - set kset for embedded kobject.
- *      @obj:           ptr to some object type.
- *      @subsys:        a subsystem object (not a ptr).
- *
- *      Can be used for any object type with an embedded ->kobj.
- */
-#define kobj_set_kset_s(obj,subsys) \
-        (obj)->kobj.kset = &(subsys)
-extern int __must_check subsystem_register(struct kset *);
-extern void subsystem_unregister(struct kset *);
-struct subsys_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct kset *, char *);
-        ssize_t (*store)(struct kset *, const char *, size_t);
-};
-extern int __must_check subsys_create_file(struct kset *,
+/* The global /sys/kernel/ kobject for people to chain off of */
-                                        struct subsys_attribute *);
+extern struct kobject *kernel_kobj;
+/* The global /sys/hypervisor/ kobject for people to chain off of */
+extern struct kobject *hypervisor_kobj;
+/* The global /sys/power/ kobject for people to chain off of */
+extern struct kobject *power_kobj;
+/* The global /sys/firmware/ kobject for people to chain off of */
+extern struct kobject *firmware_kobj;
 #if defined(CONFIG_HOTPLUG)
 int kobject_uevent(struct kobject *kobj, enum kobject_action action);
@@ -243,18 +207,20 @@ int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
 int kobject_action_type(const char *buf, size_t count,
                        enum kobject_action *type);
 #else
-static inline int kobject_uevent(struct kobject *kobj, enum kobject_action action)
+static inline int kobject_uevent(struct kobject *kobj,
+                                 enum kobject_action action)
 { return 0; }
 static inline int kobject_uevent_env(struct kobject *kobj,
                                      enum kobject_action action,
                                      char *envp[])
 { return 0; }
-static inline int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
+static inline int add_uevent_var(struct kobj_uevent_env *env,
+                                 const char *format, ...)
 { return 0; }
 static inline int kobject_action_type(const char *buf, size_t count,
-                        enum kobject_action *type)
+                                      enum kobject_action *type)
 { return -EINVAL; }
 #endif
diff --git a/include/linux/kref.h b/include/linux/kref.h
index 6fee3539893f..5d185635786e 100644
--- a/include/linux/kref.h
+++ b/include/linux/kref.h
@@ -24,6 +24,7 @@ struct kref {
        atomic_t refcount;
 };
+void kref_set(struct kref *kref, int num);
 void kref_init(struct kref *kref);
 void kref_get(struct kref *kref);
 int kref_put(struct kref *kref, void (*release) (struct kref *kref));
diff --git a/include/linux/latencytop.h b/include/linux/latencytop.h
new file mode 100644
index 000000000000..901c2d6377a8
--- /dev/null
+++ b/include/linux/latencytop.h
@@ -0,0 +1,44 @@
+/*
+ * latencytop.h: Infrastructure for displaying latency
+ *
+ * (C) Copyright 2008 Intel Corporation
+ * Author: Arjan van de Ven <arjan@linux.intel.com>
+ *
+ */
+#ifndef _INCLUDE_GUARD_LATENCYTOP_H_
+#define _INCLUDE_GUARD_LATENCYTOP_H_
+#ifdef CONFIG_LATENCYTOP
+#define LT_SAVECOUNT            32
+#define LT_BACKTRACEDEPTH       12
+struct latency_record {
+        unsigned long   backtrace[LT_BACKTRACEDEPTH];
+        unsigned int    count;
+        unsigned long   time;
+        unsigned long   max;
+};
+struct task_struct;
+void account_scheduler_latency(struct task_struct *task, int usecs, int inter);
+void clear_all_latency_tracing(struct task_struct *p);
+#else
+static inline void
+account_scheduler_latency(struct task_struct *task, int usecs, int inter)
+{
+}
+static inline void clear_all_latency_tracing(struct task_struct *p)
+{
+}
+#endif
+#endif
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 124033cb5e9b..4374c4277780 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -35,6 +35,7 @@
 #include <linux/workqueue.h>
 #include <scsi/scsi_host.h>
 #include <linux/acpi.h>
+#include <linux/cdrom.h>
 /*
 * Define if arch has non-standard setup.  This is a _PCI_ standard
@@ -143,10 +144,11 @@ enum {
        ATA_DFLAG_NCQ_OFF       = (1 << 13), /* device limited to non-NCQ mode */
        ATA_DFLAG_SPUNDOWN      = (1 << 14), /* XXX: for spindown_compat */
        ATA_DFLAG_SLEEPING      = (1 << 15), /* device is sleeping */
-        ATA_DFLAG_INIT_MASK     = (1 << 16) - 1,
+        ATA_DFLAG_DUBIOUS_XFER  = (1 << 16), /* data transfer not verified */
+        ATA_DFLAG_INIT_MASK     = (1 << 24) - 1,
-        ATA_DFLAG_DETACH        = (1 << 16),
+        ATA_DFLAG_DETACH        = (1 << 24),
-        ATA_DFLAG_DETACHED      = (1 << 17),
+        ATA_DFLAG_DETACHED      = (1 << 25),
        ATA_DEV_UNKNOWN         = 0,    /* unknown device */
        ATA_DEV_ATA             = 1,    /* ATA device */
@@ -217,9 +219,7 @@ enum {
        /* struct ata_queued_cmd flags */
        ATA_QCFLAG_ACTIVE       = (1 << 0), /* cmd not yet ack'd to scsi lyer */
-        ATA_QCFLAG_SG           = (1 << 1), /* have s/g table? */
+        ATA_QCFLAG_DMAMAP       = (1 << 1), /* SG table is DMA mapped */
-        ATA_QCFLAG_SINGLE       = (1 << 2), /* no s/g, just a single buffer */
-        ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
        ATA_QCFLAG_IO           = (1 << 3), /* standard IO command */
        ATA_QCFLAG_RESULT_TF    = (1 << 4), /* result TF requested */
        ATA_QCFLAG_CLEAR_EXCL   = (1 << 5), /* clear excl_link on completion */
@@ -266,19 +266,15 @@ enum {
        PORT_DISABLED           = 2,
        /* encoding various smaller bitmaps into a single
-         * unsigned int bitmap
+         * unsigned long bitmap
         */
-        ATA_BITS_PIO            = 7,
+        ATA_NR_PIO_MODES        = 7,
-        ATA_BITS_MWDMA          = 5,
+        ATA_NR_MWDMA_MODES      = 5,
-        ATA_BITS_UDMA           = 8,
+        ATA_NR_UDMA_MODES       = 8,
        ATA_SHIFT_PIO           = 0,
-        ATA_SHIFT_MWDMA         = ATA_SHIFT_PIO + ATA_BITS_PIO,
+        ATA_SHIFT_MWDMA         = ATA_SHIFT_PIO + ATA_NR_PIO_MODES,
-        ATA_SHIFT_UDMA          = ATA_SHIFT_MWDMA + ATA_BITS_MWDMA,
+        ATA_SHIFT_UDMA          = ATA_SHIFT_MWDMA + ATA_NR_MWDMA_MODES,
-        ATA_MASK_PIO            = ((1 << ATA_BITS_PIO) - 1) << ATA_SHIFT_PIO,
-        ATA_MASK_MWDMA          = ((1 << ATA_BITS_MWDMA) - 1) << ATA_SHIFT_MWDMA,
-        ATA_MASK_UDMA           = ((1 << ATA_BITS_UDMA) - 1) << ATA_SHIFT_UDMA,
        /* size of buffer to pad xfers ending on unaligned boundaries */
        ATA_DMA_PAD_SZ          = 4,
@@ -349,6 +345,21 @@ enum {
        ATA_DMA_MASK_ATA        = (1 << 0),     /* DMA on ATA Disk */
        ATA_DMA_MASK_ATAPI      = (1 << 1),     /* DMA on ATAPI */
        ATA_DMA_MASK_CFA        = (1 << 2),     /* DMA on CF Card */
+        /* ATAPI command types */
+        ATAPI_READ              = 0,            /* READs */
+        ATAPI_WRITE             = 1,            /* WRITEs */
+        ATAPI_READ_CD           = 2,            /* READ CD [MSF] */
+        ATAPI_MISC              = 3,            /* the rest */
+};
+enum ata_xfer_mask {
+        ATA_MASK_PIO            = ((1LU << ATA_NR_PIO_MODES) - 1)
+                                        << ATA_SHIFT_PIO,
+        ATA_MASK_MWDMA          = ((1LU << ATA_NR_MWDMA_MODES) - 1)
+                                        << ATA_SHIFT_MWDMA,
+        ATA_MASK_UDMA           = ((1LU << ATA_NR_UDMA_MODES) - 1)
+                                        << ATA_SHIFT_UDMA,
 };
 enum hsm_task_states {
@@ -447,7 +458,7 @@ struct ata_queued_cmd {
        unsigned int            tag;
        unsigned int            n_elem;
        unsigned int            n_iter;
-        unsigned int            orig_n_elem;
+        unsigned int            mapped_n_elem;
        int                     dma_dir;
@@ -455,17 +466,18 @@ struct ata_queued_cmd {
        unsigned int            sect_size;
        unsigned int            nbytes;
+        unsigned int            raw_nbytes;
        unsigned int            curbytes;
        struct scatterlist      *cursg;
        unsigned int            cursg_ofs;
+        struct scatterlist      *last_sg;
+        struct scatterlist      saved_last_sg;
        struct scatterlist      sgent;
-        struct scatterlist      pad_sgent;
+        struct scatterlist      extra_sg[2];
-        void                    *buf_virt;
-        /* DO NOT iterate over __sg manually, use ata_for_each_sg() */
+        struct scatterlist      *sg;
-        struct scatterlist      *__sg;
        unsigned int            err_mask;
        struct ata_taskfile     result_tf;
@@ -482,7 +494,7 @@ struct ata_port_stats {
 };
 struct ata_ering_entry {
-        int                     is_io;
+        unsigned int            eflags;
        unsigned int            err_mask;
        u64                     timestamp;
 };
@@ -522,9 +534,9 @@ struct ata_device {
        unsigned int            cdb_len;
        /* per-dev xfer mask */
-        unsigned int            pio_mask;
+        unsigned long           pio_mask;
-        unsigned int            mwdma_mask;
+        unsigned long           mwdma_mask;
-        unsigned int            udma_mask;
+        unsigned long           udma_mask;
        /* for CHS addressing */
        u16                     cylinders;      /* Number of cylinders */
@@ -560,6 +572,8 @@ struct ata_eh_context {
        int                     tries[ATA_MAX_DEVICES];
        unsigned int            classes[ATA_MAX_DEVICES];
        unsigned int            did_probe_mask;
+        unsigned int            saved_ncq_enabled;
+        u8                      saved_xfer_mode[ATA_MAX_DEVICES];
 };
 struct ata_acpi_drive
@@ -686,7 +700,8 @@ struct ata_port_operations {
        void (*bmdma_setup) (struct ata_queued_cmd *qc);
        void (*bmdma_start) (struct ata_queued_cmd *qc);
-        void (*data_xfer) (struct ata_device *, unsigned char *, unsigned int, int);
+        unsigned int (*data_xfer) (struct ata_device *dev, unsigned char *buf,
+                                   unsigned int buflen, int rw);
        int (*qc_defer) (struct ata_queued_cmd *qc);
        void (*qc_prep) (struct ata_queued_cmd *qc);
@@ -832,8 +847,6 @@ extern int ata_busy_sleep(struct ata_port *ap,
                          unsigned long timeout_pat, unsigned long timeout);
 extern void ata_wait_after_reset(struct ata_port *ap, unsigned long deadline);
 extern int ata_wait_ready(struct ata_port *ap, unsigned long deadline);
-extern void ata_port_queue_task(struct ata_port *ap, work_func_t fn,
-                                void *data, unsigned long delay);
 extern u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
                             unsigned long interval_msec,
                             unsigned long timeout_msec);
@@ -848,6 +861,16 @@ extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
 extern void ata_tf_to_fis(const struct ata_taskfile *tf,
                          u8 pmp, int is_cmd, u8 *fis);
 extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
+extern unsigned long ata_pack_xfermask(unsigned long pio_mask,
+                        unsigned long mwdma_mask, unsigned long udma_mask);
+extern void ata_unpack_xfermask(unsigned long xfer_mask,
+                        unsigned long *pio_mask, unsigned long *mwdma_mask,
+                        unsigned long *udma_mask);
+extern u8 ata_xfer_mask2mode(unsigned long xfer_mask);
+extern unsigned long ata_xfer_mode2mask(u8 xfer_mode);
+extern int ata_xfer_mode2shift(unsigned long xfer_mode);
+extern const char *ata_mode_string(unsigned long xfer_mask);
+extern unsigned long ata_id_xfermask(const u16 *id);
 extern void ata_noop_dev_select(struct ata_port *ap, unsigned int device);
 extern void ata_std_dev_select(struct ata_port *ap, unsigned int device);
 extern u8 ata_check_status(struct ata_port *ap);
@@ -856,17 +879,15 @@ extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf)
 extern int ata_port_start(struct ata_port *ap);
 extern int ata_sff_port_start(struct ata_port *ap);
 extern irqreturn_t ata_interrupt(int irq, void *dev_instance);
-extern void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
+extern unsigned int ata_data_xfer(struct ata_device *dev,
-                          unsigned int buflen, int write_data);
+                        unsigned char *buf, unsigned int buflen, int rw);
-extern void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
+extern unsigned int ata_data_xfer_noirq(struct ata_device *dev,
-                                unsigned int buflen, int write_data);
+                        unsigned char *buf, unsigned int buflen, int rw);
 extern int ata_std_qc_defer(struct ata_queued_cmd *qc);
 extern void ata_dumb_qc_prep(struct ata_queued_cmd *qc);
 extern void ata_qc_prep(struct ata_queued_cmd *qc);
 extern void ata_noop_qc_prep(struct ata_queued_cmd *qc);
 extern unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc);
-extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
-                unsigned int buflen);
 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
                 unsigned int n_elem);
 extern unsigned int ata_dev_classify(const struct ata_taskfile *tf);
@@ -875,7 +896,6 @@ extern void ata_id_string(const u16 *id, unsigned char *s,
                          unsigned int ofs, unsigned int len);
 extern void ata_id_c_string(const u16 *id, unsigned char *s,
                            unsigned int ofs, unsigned int len);
-extern void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown);
 extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
 extern void ata_bmdma_start(struct ata_queued_cmd *qc);
 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
@@ -910,6 +930,7 @@ extern u8 ata_irq_on(struct ata_port *ap);
 extern int ata_cable_40wire(struct ata_port *ap);
 extern int ata_cable_80wire(struct ata_port *ap);
 extern int ata_cable_sata(struct ata_port *ap);
+extern int ata_cable_ignore(struct ata_port *ap);
 extern int ata_cable_unknown(struct ata_port *ap);
 /*
@@ -917,11 +938,13 @@ extern int ata_cable_unknown(struct ata_port *ap);
 */
 extern unsigned int ata_pio_need_iordy(const struct ata_device *);
+extern const struct ata_timing *ata_timing_find_mode(u8 xfer_mode);
 extern int ata_timing_compute(struct ata_device *, unsigned short,
                              struct ata_timing *, int, int);
 extern void ata_timing_merge(const struct ata_timing *,
                             const struct ata_timing *, struct ata_timing *,
                             unsigned int);
+extern u8 ata_timing_cycle2mode(unsigned int xfer_shift, int cycle);
 enum {
        ATA_TIMING_SETUP        = (1 << 0),
@@ -948,15 +971,40 @@ static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
                return &ap->__acpi_init_gtm;
        return NULL;
 }
-extern int ata_acpi_cbl_80wire(struct ata_port *ap);
 int ata_acpi_stm(struct ata_port *ap, const struct ata_acpi_gtm *stm);
 int ata_acpi_gtm(struct ata_port *ap, struct ata_acpi_gtm *stm);
+unsigned long ata_acpi_gtm_xfermask(struct ata_device *dev,
+                                    const struct ata_acpi_gtm *gtm);
+int ata_acpi_cbl_80wire(struct ata_port *ap, const struct ata_acpi_gtm *gtm);
 #else
 static inline const struct ata_acpi_gtm *ata_acpi_init_gtm(struct ata_port *ap)
 {
        return NULL;
 }
-static inline int ata_acpi_cbl_80wire(struct ata_port *ap) { return 0; }
+static inline int ata_acpi_stm(const struct ata_port *ap,
+                               struct ata_acpi_gtm *stm)
+{
+        return -ENOSYS;
+}
+static inline int ata_acpi_gtm(const struct ata_port *ap,
+                               struct ata_acpi_gtm *stm)
+{
+        return -ENOSYS;
+}
+static inline unsigned int ata_acpi_gtm_xfermask(struct ata_device *dev,
+                                        const struct ata_acpi_gtm *gtm)
+{
+        return 0;
+}
+static inline int ata_acpi_cbl_80wire(struct ata_port *ap,
+                                      const struct ata_acpi_gtm *gtm)
+{
+        return 0;
+}
 #endif
 #ifdef CONFIG_PCI
@@ -985,8 +1033,12 @@ extern int ata_pci_init_bmdma(struct ata_host *host);
 extern int ata_pci_prepare_sff_host(struct pci_dev *pdev,
                                    const struct ata_port_info * const * ppi,
                                    struct ata_host **r_host);
+extern int ata_pci_activate_sff_host(struct ata_host *host,
+                                     irq_handler_t irq_handler,
+                                     struct scsi_host_template *sht);
 extern int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits);
-extern unsigned long ata_pci_default_filter(struct ata_device *, unsigned long);
+extern unsigned long ata_pci_default_filter(struct ata_device *dev,
+                                            unsigned long xfer_mask);
 #endif /* CONFIG_PCI */
 /*
@@ -1074,35 +1126,6 @@ extern void ata_port_pbar_desc(struct ata_port *ap, int bar, ssize_t offset,
                               const char *name);
 #endif
-/*
- * qc helpers
- */
-static inline struct scatterlist *
-ata_qc_first_sg(struct ata_queued_cmd *qc)
-{
-        qc->n_iter = 0;
-        if (qc->n_elem)
-                return qc->__sg;
-        if (qc->pad_len)
-                return &qc->pad_sgent;
-        return NULL;
-}
-static inline struct scatterlist *
-ata_qc_next_sg(struct scatterlist *sg, struct ata_queued_cmd *qc)
-{
-        if (sg == &qc->pad_sgent)
-                return NULL;
-        if (++qc->n_iter < qc->n_elem)
-                return sg_next(sg);
-        if (qc->pad_len)
-                return &qc->pad_sgent;
-        return NULL;
-}
-#define ata_for_each_sg(sg, qc) \
-        for (sg = ata_qc_first_sg(qc); sg; sg = ata_qc_next_sg(sg, qc))
 static inline unsigned int ata_tag_valid(unsigned int tag)
 {
        return (tag < ATA_MAX_QUEUE) ? 1 : 0;
@@ -1337,15 +1360,17 @@ static inline void ata_tf_init(struct ata_device *dev, struct ata_taskfile *tf)
 static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
 {
        qc->dma_dir = DMA_NONE;
-        qc->__sg = NULL;
+        qc->sg = NULL;
        qc->flags = 0;
        qc->cursg = NULL;
        qc->cursg_ofs = 0;
-        qc->nbytes = qc->curbytes = 0;
+        qc->nbytes = qc->raw_nbytes = qc->curbytes = 0;
        qc->n_elem = 0;
+        qc->mapped_n_elem = 0;
        qc->n_iter = 0;
        qc->err_mask = 0;
        qc->pad_len = 0;
+        qc->last_sg = NULL;
        qc->sect_size = ATA_SECT_SIZE;
        ata_tf_init(qc->dev, &qc->tf);
@@ -1362,6 +1387,27 @@ static inline int ata_try_flush_cache(const struct ata_device *dev)
               ata_id_has_flush_ext(dev->id);
 }
+static inline int atapi_cmd_type(u8 opcode)
+{
+        switch (opcode) {
+        case GPCMD_READ_10:
+        case GPCMD_READ_12:
+                return ATAPI_READ;
+        case GPCMD_WRITE_10:
+        case GPCMD_WRITE_12:
+        case GPCMD_WRITE_AND_VERIFY_10:
+                return ATAPI_WRITE;
+        case GPCMD_READ_CD:
+        case GPCMD_READ_CD_MSF:
+                return ATAPI_READ_CD;
+        default:
+                return ATAPI_MISC;
+        }
+}
 static inline unsigned int ac_err_mask(u8 status)
 {
        if (status & (ATA_BUSY | ATA_DRQ))
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 1b7b95c67aca..1897ca223eca 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -12,7 +12,6 @@
 #include <linux/prio_tree.h>
 #include <linux/debug_locks.h>
 #include <linux/mm_types.h>
-#include <linux/security.h>
 struct mempolicy;
 struct anon_vma;
@@ -34,6 +33,8 @@ extern int sysctl_legacy_va_layout;
 #define sysctl_legacy_va_layout 0
 #endif
+extern unsigned long mmap_min_addr;
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/processor.h>
diff --git a/include/linux/module.h b/include/linux/module.h
index 2cbc0b87e329..c97bdb7eb957 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -574,7 +574,9 @@ struct device_driver;
 #ifdef CONFIG_SYSFS
 struct module;
-extern struct kset module_subsys;
+extern struct kset *module_kset;
+extern struct kobj_type module_ktype;
+extern int module_sysfs_initialized;
 int mod_sysfs_init(struct module *mod);
 int mod_sysfs_setup(struct module *mod,
@@ -607,21 +609,6 @@ static inline void module_remove_modinfo_attrs(struct module *mod)
 #endif /* CONFIG_SYSFS */
-#if defined(CONFIG_SYSFS) && defined(CONFIG_MODULES)
-void module_add_driver(struct module *mod, struct device_driver *drv);
-void module_remove_driver(struct device_driver *drv);
-#else /* not both CONFIG_SYSFS && CONFIG_MODULES */
-static inline void module_add_driver(struct module *mod, struct device_driver *drv)
-{ }
-static inline void module_remove_driver(struct device_driver *drv)
-{ }
-#endif
 #define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
 /* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
diff --git a/include/linux/notifier.h b/include/linux/notifier.h
index 0c40cc0b4a36..5dfbc684ce7d 100644
--- a/include/linux/notifier.h
+++ b/include/linux/notifier.h
@@ -207,9 +207,7 @@ static inline int notifier_to_errno(int ret)
 #define CPU_DOWN_PREPARE        0x0005 /* CPU (unsigned)v going down */
 #define CPU_DOWN_FAILED         0x0006 /* CPU (unsigned)v NOT going down */
 #define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
-#define CPU_LOCK_ACQUIRE        0x0008 /* Acquire all hotcpu locks */
+#define CPU_DYING               0x0008 /* CPU (unsigned)v not running any task,
-#define CPU_LOCK_RELEASE        0x0009 /* Release all hotcpu locks */
-#define CPU_DYING               0x000A /* CPU (unsigned)v not running any task,
                                        * not handling interrupts, soon dead */
 /* Used for CPU hotplug events occuring while tasks are frozen due to a suspend
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index ab4cb6ecd47c..8f67e8f2a3cc 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -174,7 +174,7 @@ extern int pci_hp_register		(struct hotplug_slot *slot);
 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);
-extern struct kset pci_hotplug_slots_subsys;
+extern struct kset *pci_hotplug_slots_kset;
 /* PCI Setting Record (Type 0) */
 struct hpp_type0 {
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 023656d2f1da..1fbd0256e86b 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2066,6 +2066,9 @@
 #define PCI_VENDOR_ID_NETCELL           0x169c
 #define PCI_DEVICE_ID_REVOLUTION        0x0044
+#define PCI_VENDOR_ID_CENATEK           0x16CA
+#define PCI_DEVICE_ID_CENATEK_IDE       0x0001
 #define PCI_VENDOR_ID_VITESSE           0x1725
 #define PCI_DEVICE_ID_VITESSE_VSC7174   0x7174
@@ -2322,6 +2325,8 @@
 #define PCI_DEVICE_ID_INTEL_ICH9_4      0x2914
 #define PCI_DEVICE_ID_INTEL_ICH9_5      0x2919
 #define PCI_DEVICE_ID_INTEL_ICH9_6      0x2930
+#define PCI_DEVICE_ID_INTEL_ICH9_7      0x2916
+#define PCI_DEVICE_ID_INTEL_ICH9_8      0x2918
 #define PCI_DEVICE_ID_INTEL_82855PM_HB  0x3340
 #define PCI_DEVICE_ID_INTEL_82830_HB    0x3575
 #define PCI_DEVICE_ID_INTEL_82830_CGC   0x3577
diff --git a/include/linux/pktcdvd.h b/include/linux/pktcdvd.h
index 5ea4f05683f6..04b4d7330e6d 100644
--- a/include/linux/pktcdvd.h
+++ b/include/linux/pktcdvd.h
@@ -290,7 +290,7 @@ struct pktcdvd_device
        int                     write_congestion_off;
        int                     write_congestion_on;
-        struct class_device     *clsdev;        /* sysfs pktcdvd[0-7] class dev */
+        struct device           *dev;           /* sysfs pktcdvd[0-7] dev */
        struct pktcdvd_kobj     *kobj_stat;     /* sysfs pktcdvd[0-7]/stat/     */
        struct pktcdvd_kobj     *kobj_wqueue;   /* sysfs pktcdvd[0-7]/write_queue/ */
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index e80804316cdb..3261681c82a4 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -35,7 +35,7 @@ extern struct resource *platform_get_resource_byname(struct platform_device *, u
 extern int platform_get_irq_byname(struct platform_device *, char *);
 extern int platform_add_devices(struct platform_device **, int);
-extern struct platform_device *platform_device_register_simple(char *, int id,
+extern struct platform_device *platform_device_register_simple(const char *, int id,
                                        struct resource *, unsigned int);
 extern struct platform_device *platform_device_alloc(const char *name, int id);
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 09a309b7b5d2..b78e0295adf4 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -246,6 +246,15 @@ static inline int call_platform_enable_wakeup(struct device *dev, int is_on)
                device_set_wakeup_enable(dev,val); \
        } while(0)
+/*
+ * Global Power Management flags
+ * Used to keep APM and ACPI from both being active
+ */
+extern unsigned int     pm_flags;
+#define PM_APM  1
+#define PM_ACPI 2
 #endif /* __KERNEL__ */
 #endif /* _LINUX_PM_H */
diff --git a/include/linux/pm_legacy.h b/include/linux/pm_legacy.h
index 514729a44688..446f4f42b952 100644
--- a/include/linux/pm_legacy.h
+++ b/include/linux/pm_legacy.h
@@ -4,10 +4,6 @@
 #ifdef CONFIG_PM_LEGACY
-extern int pm_active;
-#define PM_IS_ACTIVE() (pm_active != 0)
 /*
 * Register a device with power management
 */
@@ -21,8 +17,6 @@ int __deprecated pm_send_all(pm_request_t rqst, void *data);
 #else /* CONFIG_PM_LEGACY */
-#define PM_IS_ACTIVE() 0
 static inline struct pm_dev *pm_register(pm_dev_t type,
                                         unsigned long id,
                                         pm_callback callback)
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
index 0a0426c2867d..2a6d62c7d2d1 100644
--- a/include/linux/pnp.h
+++ b/include/linux/pnp.h
@@ -13,7 +13,7 @@
 #include <linux/errno.h>
 #include <linux/mod_devicetable.h>
-#define PNP_MAX_PORT            24
+#define PNP_MAX_PORT            40
 #define PNP_MAX_MEM             12
 #define PNP_MAX_IRQ             2
 #define PNP_MAX_DMA             2
diff --git a/include/linux/rcuclassic.h b/include/linux/rcuclassic.h
new file mode 100644
index 000000000000..4d6624260b4c
--- /dev/null
+++ b/include/linux/rcuclassic.h
@@ -0,0 +1,164 @@
+/*
+ * Read-Copy Update mechanism for mutual exclusion (classic version)
+ *
+ * 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.
+ *
+ * Copyright IBM Corporation, 2001
+ *
+ * Author: Dipankar Sarma <dipankar@in.ibm.com>
+ *
+ * Based on the original work by Paul McKenney <paulmck@us.ibm.com>
+ * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
+ * Papers:
+ * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
+ * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
+ *
+ * For detailed explanation of Read-Copy Update mechanism see -
+ *              Documentation/RCU
+ *
+ */
+#ifndef __LINUX_RCUCLASSIC_H
+#define __LINUX_RCUCLASSIC_H
+#ifdef __KERNEL__
+#include <linux/cache.h>
+#include <linux/spinlock.h>
+#include <linux/threads.h>
+#include <linux/percpu.h>
+#include <linux/cpumask.h>
+#include <linux/seqlock.h>
+/* Global control variables for rcupdate callback mechanism. */
+struct rcu_ctrlblk {
+        long    cur;            /* Current batch number.                      */
+        long    completed;      /* Number of the last completed batch         */
+        int     next_pending;   /* Is the next batch already waiting?         */
+        int     signaled;
+        spinlock_t      lock    ____cacheline_internodealigned_in_smp;
+        cpumask_t       cpumask; /* CPUs that need to switch in order    */
+                                 /* for current batch to proceed.        */
+} ____cacheline_internodealigned_in_smp;
+/* Is batch a before batch b ? */
+static inline int rcu_batch_before(long a, long b)
+{
+        return (a - b) < 0;
+}
+/* Is batch a after batch b ? */
+static inline int rcu_batch_after(long a, long b)
+{
+        return (a - b) > 0;
+}
+/*
+ * Per-CPU data for Read-Copy UPdate.
+ * nxtlist - new callbacks are added here
+ * curlist - current batch for which quiescent cycle started if any
+ */
+struct rcu_data {
+        /* 1) quiescent state handling : */
+        long            quiescbatch;     /* Batch # for grace period */
+        int             passed_quiesc;   /* User-mode/idle loop etc. */
+        int             qs_pending;      /* core waits for quiesc state */
+        /* 2) batch handling */
+        long            batch;           /* Batch # for current RCU batch */
+        struct rcu_head *nxtlist;
+        struct rcu_head **nxttail;
+        long            qlen;            /* # of queued callbacks */
+        struct rcu_head *curlist;
+        struct rcu_head **curtail;
+        struct rcu_head *donelist;
+        struct rcu_head **donetail;
+        long            blimit;          /* Upper limit on a processed batch */
+        int cpu;
+        struct rcu_head barrier;
+};
+DECLARE_PER_CPU(struct rcu_data, rcu_data);
+DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
+/*
+ * Increment the quiescent state counter.
+ * The counter is a bit degenerated: We do not need to know
+ * how many quiescent states passed, just if there was at least
+ * one since the start of the grace period. Thus just a flag.
+ */
+static inline void rcu_qsctr_inc(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
+        rdp->passed_quiesc = 1;
+}
+static inline void rcu_bh_qsctr_inc(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
+        rdp->passed_quiesc = 1;
+}
+extern int rcu_pending(int cpu);
+extern int rcu_needs_cpu(int cpu);
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+extern struct lockdep_map rcu_lock_map;
+# define rcu_read_acquire()     \
+                        lock_acquire(&rcu_lock_map, 0, 0, 2, 1, _THIS_IP_)
+# define rcu_read_release()     lock_release(&rcu_lock_map, 1, _THIS_IP_)
+#else
+# define rcu_read_acquire()     do { } while (0)
+# define rcu_read_release()     do { } while (0)
+#endif
+#define __rcu_read_lock() \
+        do { \
+                preempt_disable(); \
+                __acquire(RCU); \
+                rcu_read_acquire(); \
+        } while (0)
+#define __rcu_read_unlock() \
+        do { \
+                rcu_read_release(); \
+                __release(RCU); \
+                preempt_enable(); \
+        } while (0)
+#define __rcu_read_lock_bh() \
+        do { \
+                local_bh_disable(); \
+                __acquire(RCU_BH); \
+                rcu_read_acquire(); \
+        } while (0)
+#define __rcu_read_unlock_bh() \
+        do { \
+                rcu_read_release(); \
+                __release(RCU_BH); \
+                local_bh_enable(); \
+        } while (0)
+#define __synchronize_sched() synchronize_rcu()
+extern void __rcu_init(void);
+extern void rcu_check_callbacks(int cpu, int user);
+extern void rcu_restart_cpu(int cpu);
+extern long rcu_batches_completed(void);
+extern long rcu_batches_completed_bh(void);
+#endif /* __KERNEL__ */
+#endif /* __LINUX_RCUCLASSIC_H */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index cc24a01df940..d32c14de270e 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -15,7 +15,7 @@
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
- * Copyright (C) IBM Corporation, 2001
+ * Copyright IBM Corporation, 2001
 *
 * Author: Dipankar Sarma <dipankar@in.ibm.com>
 * 
@@ -53,96 +53,18 @@ struct rcu_head {
        void (*func)(struct rcu_head *head);
 };
+#ifdef CONFIG_CLASSIC_RCU
+#include <linux/rcuclassic.h>
+#else /* #ifdef CONFIG_CLASSIC_RCU */
+#include <linux/rcupreempt.h>
+#endif /* #else #ifdef CONFIG_CLASSIC_RCU */
 #define RCU_HEAD_INIT   { .next = NULL, .func = NULL }
 #define RCU_HEAD(head) struct rcu_head head = RCU_HEAD_INIT
 #define INIT_RCU_HEAD(ptr) do { \
       (ptr)->next = NULL; (ptr)->func = NULL; \
 } while (0)
-/* Global control variables for rcupdate callback mechanism. */
-struct rcu_ctrlblk {
-        long    cur;            /* Current batch number.                      */
-        long    completed;      /* Number of the last completed batch         */
-        int     next_pending;   /* Is the next batch already waiting?         */
-        int     signaled;
-        spinlock_t      lock    ____cacheline_internodealigned_in_smp;
-        cpumask_t       cpumask; /* CPUs that need to switch in order    */
-                                 /* for current batch to proceed.        */
-} ____cacheline_internodealigned_in_smp;
-/* Is batch a before batch b ? */
-static inline int rcu_batch_before(long a, long b)
-{
-        return (a - b) < 0;
-}
-/* Is batch a after batch b ? */
-static inline int rcu_batch_after(long a, long b)
-{
-        return (a - b) > 0;
-}
-/*
- * Per-CPU data for Read-Copy UPdate.
- * nxtlist - new callbacks are added here
- * curlist - current batch for which quiescent cycle started if any
- */
-struct rcu_data {
-        /* 1) quiescent state handling : */
-        long            quiescbatch;     /* Batch # for grace period */
-        int             passed_quiesc;   /* User-mode/idle loop etc. */
-        int             qs_pending;      /* core waits for quiesc state */
-        /* 2) batch handling */
-        long            batch;           /* Batch # for current RCU batch */
-        struct rcu_head *nxtlist;
-        struct rcu_head **nxttail;
-        long            qlen;            /* # of queued callbacks */
-        struct rcu_head *curlist;
-        struct rcu_head **curtail;
-        struct rcu_head *donelist;
-        struct rcu_head **donetail;
-        long            blimit;          /* Upper limit on a processed batch */
-        int cpu;
-        struct rcu_head barrier;
-};
-DECLARE_PER_CPU(struct rcu_data, rcu_data);
-DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
-/*
- * Increment the quiescent state counter.
- * The counter is a bit degenerated: We do not need to know
- * how many quiescent states passed, just if there was at least
- * one since the start of the grace period. Thus just a flag.
- */
-static inline void rcu_qsctr_inc(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
-        rdp->passed_quiesc = 1;
-}
-static inline void rcu_bh_qsctr_inc(int cpu)
-{
-        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
-        rdp->passed_quiesc = 1;
-}
-extern int rcu_pending(int cpu);
-extern int rcu_needs_cpu(int cpu);
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-extern struct lockdep_map rcu_lock_map;
-# define rcu_read_acquire()     lock_acquire(&rcu_lock_map, 0, 0, 2, 1, _THIS_IP_)
-# define rcu_read_release()     lock_release(&rcu_lock_map, 1, _THIS_IP_)
-#else
-# define rcu_read_acquire()     do { } while (0)
-# define rcu_read_release()     do { } while (0)
-#endif
 /**
 * rcu_read_lock - mark the beginning of an RCU read-side critical section.
 *
@@ -172,24 +94,13 @@ extern struct lockdep_map rcu_lock_map;
 *
 * It is illegal to block while in an RCU read-side critical section.
 */
-#define rcu_read_lock() \
+#define rcu_read_lock() __rcu_read_lock()
-        do { \
-                preempt_disable(); \
-                __acquire(RCU); \
-                rcu_read_acquire(); \
-        } while(0)
 /**
 * rcu_read_unlock - marks the end of an RCU read-side critical section.
 *
 * See rcu_read_lock() for more information.
 */
-#define rcu_read_unlock() \
-        do { \
-                rcu_read_release(); \
-                __release(RCU); \
-                preempt_enable(); \
-        } while(0)
 /*
 * So where is rcu_write_lock()?  It does not exist, as there is no
@@ -200,6 +111,7 @@ extern struct lockdep_map rcu_lock_map;
 * used as well.  RCU does not care how the writers keep out of each
 * others' way, as long as they do so.
 */
+#define rcu_read_unlock() __rcu_read_unlock()
 /**
 * rcu_read_lock_bh - mark the beginning of a softirq-only RCU critical section
@@ -212,24 +124,14 @@ extern struct lockdep_map rcu_lock_map;
 * can use just rcu_read_lock().
 *
 */
-#define rcu_read_lock_bh() \
+#define rcu_read_lock_bh() __rcu_read_lock_bh()
-        do { \
-                local_bh_disable(); \
-                __acquire(RCU_BH); \
-                rcu_read_acquire(); \
-        } while(0)
 /*
 * rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section
 *
 * See rcu_read_lock_bh() for more information.
 */
-#define rcu_read_unlock_bh() \
+#define rcu_read_unlock_bh() __rcu_read_unlock_bh()
-        do { \
-                rcu_read_release(); \
-                __release(RCU_BH); \
-                local_bh_enable(); \
-        } while(0)
 /*
 * Prevent the compiler from merging or refetching accesses.  The compiler
@@ -293,21 +195,52 @@ extern struct lockdep_map rcu_lock_map;
 * In "classic RCU", these two guarantees happen to be one and
 * the same, but can differ in realtime RCU implementations.
 */
-#define synchronize_sched() synchronize_rcu()
+#define synchronize_sched() __synchronize_sched()
-extern void rcu_init(void);
+/**
-extern void rcu_check_callbacks(int cpu, int user);
+ * call_rcu - Queue an RCU callback for invocation after a grace period.
-extern void rcu_restart_cpu(int cpu);
+ * @head: structure to be used for queueing the RCU updates.
-extern long rcu_batches_completed(void);
+ * @func: actual update function to be invoked after the grace period
-extern long rcu_batches_completed_bh(void);
+ *
+ * The update function will be invoked some time after a full grace
+ * period elapses, in other words after all currently executing RCU
+ * read-side critical sections have completed.  RCU read-side critical
+ * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
+ * and may be nested.
+ */
+extern void call_rcu(struct rcu_head *head,
+                              void (*func)(struct rcu_head *head));
-/* Exported interfaces */
+/**
-extern void FASTCALL(call_rcu(struct rcu_head *head, 
+ * call_rcu_bh - Queue an RCU for invocation after a quicker grace period.
-                                void (*func)(struct rcu_head *head)));
+ * @head: structure to be used for queueing the RCU updates.
-extern void FASTCALL(call_rcu_bh(struct rcu_head *head,
+ * @func: actual update function to be invoked after the grace period
-                                void (*func)(struct rcu_head *head)));
+ *
+ * The update function will be invoked some time after a full grace
+ * period elapses, in other words after all currently executing RCU
+ * read-side critical sections have completed. call_rcu_bh() assumes
+ * that the read-side critical sections end on completion of a softirq
+ * handler. This means that read-side critical sections in process
+ * context must not be interrupted by softirqs. This interface is to be
+ * used when most of the read-side critical sections are in softirq context.
+ * RCU read-side critical sections are delimited by :
+ *  - rcu_read_lock() and  rcu_read_unlock(), if in interrupt context.
+ *  OR
+ *  - rcu_read_lock_bh() and rcu_read_unlock_bh(), if in process context.
+ *  These may be nested.
+ */
+extern void call_rcu_bh(struct rcu_head *head,
+                        void (*func)(struct rcu_head *head));
+/* Exported common interfaces */
 extern void synchronize_rcu(void);
 extern void rcu_barrier(void);
+extern long rcu_batches_completed(void);
+extern long rcu_batches_completed_bh(void);
+/* Internal to kernel */
+extern void rcu_init(void);
+extern int rcu_needs_cpu(int cpu);
 #endif /* __KERNEL__ */
 #endif /* __LINUX_RCUPDATE_H */
diff --git a/include/linux/rcupreempt.h b/include/linux/rcupreempt.h
new file mode 100644
index 000000000000..ece8eb3e4151
--- /dev/null
+++ b/include/linux/rcupreempt.h
@@ -0,0 +1,86 @@
+/*
+ * Read-Copy Update mechanism for mutual exclusion (RT implementation)
+ *
+ * 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.
+ *
+ * Copyright (C) IBM Corporation, 2006
+ *
+ * Author:  Paul McKenney <paulmck@us.ibm.com>
+ *
+ * Based on the original work by Paul McKenney <paul.mckenney@us.ibm.com>
+ * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
+ * Papers:
+ * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
+ * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
+ *
+ * For detailed explanation of Read-Copy Update mechanism see -
+ *              Documentation/RCU
+ *
+ */
+#ifndef __LINUX_RCUPREEMPT_H
+#define __LINUX_RCUPREEMPT_H
+#ifdef __KERNEL__
+#include <linux/cache.h>
+#include <linux/spinlock.h>
+#include <linux/threads.h>
+#include <linux/percpu.h>
+#include <linux/cpumask.h>
+#include <linux/seqlock.h>
+#define rcu_qsctr_inc(cpu)
+#define rcu_bh_qsctr_inc(cpu)
+#define call_rcu_bh(head, rcu) call_rcu(head, rcu)
+extern void __rcu_read_lock(void);
+extern void __rcu_read_unlock(void);
+extern int rcu_pending(int cpu);
+extern int rcu_needs_cpu(int cpu);
+#define __rcu_read_lock_bh()    { rcu_read_lock(); local_bh_disable(); }
+#define __rcu_read_unlock_bh()  { local_bh_enable(); rcu_read_unlock(); }
+extern void __synchronize_sched(void);
+extern void __rcu_init(void);
+extern void rcu_check_callbacks(int cpu, int user);
+extern void rcu_restart_cpu(int cpu);
+extern long rcu_batches_completed(void);
+/*
+ * Return the number of RCU batches processed thus far. Useful for debug
+ * and statistic. The _bh variant is identifcal to straight RCU
+ */
+static inline long rcu_batches_completed_bh(void)
+{
+        return rcu_batches_completed();
+}
+#ifdef CONFIG_RCU_TRACE
+struct rcupreempt_trace;
+extern long *rcupreempt_flipctr(int cpu);
+extern long rcupreempt_data_completed(void);
+extern int rcupreempt_flip_flag(int cpu);
+extern int rcupreempt_mb_flag(int cpu);
+extern char *rcupreempt_try_flip_state_name(void);
+extern struct rcupreempt_trace *rcupreempt_trace_cpu(int cpu);
+#endif
+struct softirq_action;
+#endif /* __KERNEL__ */
+#endif /* __LINUX_RCUPREEMPT_H */
diff --git a/include/linux/rcupreempt_trace.h b/include/linux/rcupreempt_trace.h
new file mode 100644
index 000000000000..21cd6b2a5c42
--- /dev/null
+++ b/include/linux/rcupreempt_trace.h
@@ -0,0 +1,99 @@
+/*
+ * Read-Copy Update mechanism for mutual exclusion (RT implementation)
+ *
+ * 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.
+ *
+ * Copyright (C) IBM Corporation, 2006
+ *
+ * Author:  Paul McKenney <paulmck@us.ibm.com>
+ *
+ * Based on the original work by Paul McKenney <paul.mckenney@us.ibm.com>
+ * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
+ * Papers:
+ * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
+ * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
+ *
+ * For detailed explanation of the Preemptible Read-Copy Update mechanism see -
+ *               http://lwn.net/Articles/253651/
+ */
+#ifndef __LINUX_RCUPREEMPT_TRACE_H
+#define __LINUX_RCUPREEMPT_TRACE_H
+#ifdef __KERNEL__
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <asm/atomic.h>
+/*
+ * PREEMPT_RCU data structures.
+ */
+struct rcupreempt_trace {
+        long            next_length;
+        long            next_add;
+        long            wait_length;
+        long            wait_add;
+        long            done_length;
+        long            done_add;
+        long            done_remove;
+        atomic_t        done_invoked;
+        long            rcu_check_callbacks;
+        atomic_t        rcu_try_flip_1;
+        atomic_t        rcu_try_flip_e1;
+        long            rcu_try_flip_i1;
+        long            rcu_try_flip_ie1;
+        long            rcu_try_flip_g1;
+        long            rcu_try_flip_a1;
+        long            rcu_try_flip_ae1;
+        long            rcu_try_flip_a2;
+        long            rcu_try_flip_z1;
+        long            rcu_try_flip_ze1;
+        long            rcu_try_flip_z2;
+        long            rcu_try_flip_m1;
+        long            rcu_try_flip_me1;
+        long            rcu_try_flip_m2;
+};
+#ifdef CONFIG_RCU_TRACE
+#define RCU_TRACE(fn, arg)      fn(arg);
+#else
+#define RCU_TRACE(fn, arg)
+#endif
+extern void rcupreempt_trace_move2done(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_move2wait(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_e1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_i1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_ie1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_g1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_a1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_ae1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_a2(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_z1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_ze1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_z2(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_m1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_me1(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_try_flip_m2(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_check_callbacks(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_done_remove(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_invoke(struct rcupreempt_trace *trace);
+extern void rcupreempt_trace_next_add(struct rcupreempt_trace *trace);
+#endif /* __KERNEL__ */
+#endif /* __LINUX_RCUPREEMPT_TRACE_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index ac3d496fbd20..df5b24ee80b3 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -78,7 +78,6 @@ struct sched_param {
 #include <linux/proportions.h>
 #include <linux/seccomp.h>
 #include <linux/rcupdate.h>
-#include <linux/futex.h>
 #include <linux/rtmutex.h>
 #include <linux/time.h>
@@ -88,11 +87,13 @@ struct sched_param {
 #include <linux/hrtimer.h>
 #include <linux/task_io_accounting.h>
 #include <linux/kobject.h>
+#include <linux/latencytop.h>
 #include <asm/processor.h>
 struct exec_domain;
 struct futex_pi_state;
+struct robust_list_head;
 struct bio;
 /*
@@ -230,6 +231,8 @@ static inline int select_nohz_load_balancer(int cpu)
 }
 #endif
+extern unsigned long rt_needs_cpu(int cpu);
 /*
 * Only dump TASK_* tasks. (0 for all tasks)
 */
@@ -257,13 +260,19 @@ extern void trap_init(void);
 extern void account_process_tick(struct task_struct *task, int user);
 extern void update_process_times(int user);
 extern void scheduler_tick(void);
+extern void hrtick_resched(void);
+extern void sched_show_task(struct task_struct *p);
 #ifdef CONFIG_DETECT_SOFTLOCKUP
 extern void softlockup_tick(void);
 extern void spawn_softlockup_task(void);
 extern void touch_softlockup_watchdog(void);
 extern void touch_all_softlockup_watchdogs(void);
-extern int softlockup_thresh;
+extern unsigned long  softlockup_thresh;
+extern unsigned long sysctl_hung_task_check_count;
+extern unsigned long sysctl_hung_task_timeout_secs;
+extern unsigned long sysctl_hung_task_warnings;
 #else
 static inline void softlockup_tick(void)
 {
@@ -552,18 +561,13 @@ struct user_struct {
 #ifdef CONFIG_FAIR_USER_SCHED
        struct task_group *tg;
 #ifdef CONFIG_SYSFS
-        struct kset kset;
+        struct kobject kobj;
-        struct subsys_attribute user_attr;
        struct work_struct work;
 #endif
 #endif
 };
-#ifdef CONFIG_FAIR_USER_SCHED
+extern int uids_sysfs_init(void);
-extern int uids_kobject_init(void);
-#else
-static inline int uids_kobject_init(void) { return 0; }
-#endif
 extern struct user_struct *find_user(uid_t);
@@ -827,6 +831,7 @@ struct sched_class {
        void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
        void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
        void (*yield_task) (struct rq *rq);
+        int  (*select_task_rq)(struct task_struct *p, int sync);
        void (*check_preempt_curr) (struct rq *rq, struct task_struct *p);
@@ -842,11 +847,25 @@ struct sched_class {
        int (*move_one_task) (struct rq *this_rq, int this_cpu,
                              struct rq *busiest, struct sched_domain *sd,
                              enum cpu_idle_type idle);
+        void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
+        void (*post_schedule) (struct rq *this_rq);
+        void (*task_wake_up) (struct rq *this_rq, struct task_struct *task);
 #endif
        void (*set_curr_task) (struct rq *rq);
-        void (*task_tick) (struct rq *rq, struct task_struct *p);
+        void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
        void (*task_new) (struct rq *rq, struct task_struct *p);
+        void (*set_cpus_allowed)(struct task_struct *p, cpumask_t *newmask);
+        void (*join_domain)(struct rq *rq);
+        void (*leave_domain)(struct rq *rq);
+        void (*switched_from) (struct rq *this_rq, struct task_struct *task,
+                               int running);
+        void (*switched_to) (struct rq *this_rq, struct task_struct *task,
+                             int running);
+        void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
+                             int oldprio, int running);
 };
 struct load_weight {
@@ -876,6 +895,8 @@ struct sched_entity {
 #ifdef CONFIG_SCHEDSTATS
        u64                     wait_start;
        u64                     wait_max;
+        u64                     wait_count;
+        u64                     wait_sum;
        u64                     sleep_start;
        u64                     sleep_max;
@@ -914,6 +935,21 @@ struct sched_entity {
 #endif
 };
+struct sched_rt_entity {
+        struct list_head run_list;
+        unsigned int time_slice;
+        unsigned long timeout;
+        int nr_cpus_allowed;
+#ifdef CONFIG_FAIR_GROUP_SCHED
+        struct sched_rt_entity  *parent;
+        /* rq on which this entity is (to be) queued: */
+        struct rt_rq            *rt_rq;
+        /* rq "owned" by this entity/group: */
+        struct rt_rq            *my_q;
+#endif
+};
 struct task_struct {
        volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
        void *stack;
@@ -930,9 +966,9 @@ struct task_struct {
 #endif
        int prio, static_prio, normal_prio;
-        struct list_head run_list;
        const struct sched_class *sched_class;
        struct sched_entity se;
+        struct sched_rt_entity rt;
 #ifdef CONFIG_PREEMPT_NOTIFIERS
        /* list of struct preempt_notifier: */
@@ -956,7 +992,11 @@ struct task_struct {
        unsigned int policy;
        cpumask_t cpus_allowed;
-        unsigned int time_slice;
+#ifdef CONFIG_PREEMPT_RCU
+        int rcu_read_lock_nesting;
+        int rcu_flipctr_idx;
+#endif /* #ifdef CONFIG_PREEMPT_RCU */
 #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
        struct sched_info sched_info;
@@ -1046,6 +1086,11 @@ struct task_struct {
 /* ipc stuff */
        struct sysv_sem sysvsem;
 #endif
+#ifdef CONFIG_DETECT_SOFTLOCKUP
+/* hung task detection */
+        unsigned long last_switch_timestamp;
+        unsigned long last_switch_count;
+#endif
 /* CPU-specific state of this task */
        struct thread_struct thread;
 /* filesystem information */
@@ -1178,6 +1223,10 @@ struct task_struct {
        int make_it_fail;
 #endif
        struct prop_local_single dirties;
+#ifdef CONFIG_LATENCYTOP
+        int latency_record_count;
+        struct latency_record latency_record[LT_SAVECOUNT];
+#endif
 };
 /*
@@ -1255,13 +1304,6 @@ struct pid_namespace;
 *
 * set_task_vxid()   : assigns a virtual id to a task;
 *
- * task_ppid_nr_ns() : the parent's id as seen from the namespace specified.
- *                     the result depends on the namespace and whether the
- *                     task in question is the namespace's init. e.g. for the
- *                     namespace's init this will return 0 when called from
- *                     the namespace of this init, or appropriate id otherwise.
- *
- *
 * see also pid_nr() etc in include/linux/pid.h
 */
@@ -1317,12 +1359,6 @@ static inline pid_t task_session_vnr(struct task_struct *tsk)
 }
-static inline pid_t task_ppid_nr_ns(struct task_struct *tsk,
-                struct pid_namespace *ns)
-{
-        return pid_nr_ns(task_pid(rcu_dereference(tsk->real_parent)), ns);
-}
 /**
 * pid_alive - check that a task structure is not stale
 * @p: Task structure to be checked.
@@ -1471,6 +1507,12 @@ 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_sched_rt_period;
+extern unsigned int sysctl_sched_rt_ratio;
+#if defined(CONFIG_FAIR_GROUP_SCHED) && defined(CONFIG_SMP)
+extern unsigned int sysctl_sched_min_bal_int_shares;
+extern unsigned int sysctl_sched_max_bal_int_shares;
+#endif
 int sched_nr_latency_handler(struct ctl_table *table, int write,
                struct file *file, void __user *buffer, size_t *length,
@@ -1863,7 +1905,18 @@ static inline int need_resched(void)
 * cond_resched_lock() will drop the spinlock before scheduling,
 * cond_resched_softirq() will enable bhs before scheduling.
 */
-extern int cond_resched(void);
+#ifdef CONFIG_PREEMPT
+static inline int cond_resched(void)
+{
+        return 0;
+}
+#else
+extern int _cond_resched(void);
+static inline int cond_resched(void)
+{
+        return _cond_resched();
+}
+#endif
 extern int cond_resched_lock(spinlock_t * lock);
 extern int cond_resched_softirq(void);
diff --git a/include/linux/security.h b/include/linux/security.h
index ac050830a873..d24974262dc6 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -34,6 +34,12 @@
 #include <linux/xfrm.h>
 #include <net/flow.h>
+/* only a char in selinux superblock security struct flags */
+#define FSCONTEXT_MNT           0x01
+#define CONTEXT_MNT             0x02
+#define ROOTCONTEXT_MNT         0x04
+#define DEFCONTEXT_MNT          0x08
 /*
 * Bounding set
 */
@@ -243,9 +249,6 @@ struct request_sock;
 *      @mnt contains the mounted file system.
 *      @flags contains the new filesystem flags.
 *      @data contains the filesystem-specific data.
- * @sb_post_mountroot:
- *      Update the security module's state when the root filesystem is mounted.
- *      This hook is only called if the mount was successful.
 * @sb_post_addmount:
 *      Update the security module's state when a filesystem is mounted.
 *      This hook is called any time a mount is successfully grafetd to
@@ -261,6 +264,22 @@ struct request_sock;
 *      Update module state after a successful pivot.
 *      @old_nd contains the nameidata structure for the old root.
 *      @new_nd contains the nameidata structure for the new root.
+ * @sb_get_mnt_opts:
+ *      Get the security relevant mount options used for a superblock
+ *      @sb the superblock to get security mount options from
+ *      @mount_options array for pointers to mount options
+ *      @mount_flags array of ints specifying what each mount options is
+ *      @num_opts number of options in the arrays
+ * @sb_set_mnt_opts:
+ *      Set the security relevant mount options used for a superblock
+ *      @sb the superblock to set security mount options for
+ *      @mount_options array for pointers to mount options
+ *      @mount_flags array of ints specifying what each mount options is
+ *      @num_opts number of options in the arrays
+ * @sb_clone_mnt_opts:
+ *      Copy all security options from a given superblock to another
+ *      @oldsb old superblock which contain information to clone
+ *      @newsb new superblock which needs filled in
 *
 * Security hooks for inode operations.
 *
@@ -1183,6 +1202,10 @@ struct request_sock;
 *      Convert secid to security context.
 *      @secid contains the security ID.
 *      @secdata contains the pointer that stores the converted security context.
+ * @secctx_to_secid:
+ *      Convert security context to secid.
+ *      @secid contains the pointer to the generated security ID.
+ *      @secdata contains the security context.
 *
 * @release_secctx:
 *      Release the security context.
@@ -1235,13 +1258,19 @@ struct security_operations {
        void (*sb_umount_busy) (struct vfsmount * mnt);
        void (*sb_post_remount) (struct vfsmount * mnt,
                                 unsigned long flags, void *data);
-        void (*sb_post_mountroot) (void);
        void (*sb_post_addmount) (struct vfsmount * mnt,
                                  struct nameidata * mountpoint_nd);
        int (*sb_pivotroot) (struct nameidata * old_nd,
                             struct nameidata * new_nd);
        void (*sb_post_pivotroot) (struct nameidata * old_nd,
                                   struct nameidata * new_nd);
+        int (*sb_get_mnt_opts) (const struct super_block *sb,
+                                char ***mount_options, int **flags,
+                                int *num_opts);
+        int (*sb_set_mnt_opts) (struct super_block *sb, char **mount_options,
+                                int *flags, int num_opts);
+        void (*sb_clone_mnt_opts) (const struct super_block *oldsb,
+                                   struct super_block *newsb);
        int (*inode_alloc_security) (struct inode *inode);      
        void (*inode_free_security) (struct inode *inode);
@@ -1371,6 +1400,7 @@ struct security_operations {
        int (*getprocattr)(struct task_struct *p, char *name, char **value);
        int (*setprocattr)(struct task_struct *p, char *name, void *value, size_t size);
        int (*secid_to_secctx)(u32 secid, char **secdata, u32 *seclen);
+        int (*secctx_to_secid)(char *secdata, u32 seclen, u32 *secid);
        void (*release_secctx)(char *secdata, u32 seclen);
 #ifdef CONFIG_SECURITY_NETWORK
@@ -1495,10 +1525,16 @@ int security_sb_umount(struct vfsmount *mnt, int flags);
 void security_sb_umount_close(struct vfsmount *mnt);
 void security_sb_umount_busy(struct vfsmount *mnt);
 void security_sb_post_remount(struct vfsmount *mnt, unsigned long flags, void *data);
-void security_sb_post_mountroot(void);
 void security_sb_post_addmount(struct vfsmount *mnt, struct nameidata *mountpoint_nd);
 int security_sb_pivotroot(struct nameidata *old_nd, struct nameidata *new_nd);
 void security_sb_post_pivotroot(struct nameidata *old_nd, struct nameidata *new_nd);
+int security_sb_get_mnt_opts(const struct super_block *sb, char ***mount_options,
+                             int **flags, int *num_opts);
+int security_sb_set_mnt_opts(struct super_block *sb, char **mount_options,
+                             int *flags, int num_opts);
+void security_sb_clone_mnt_opts(const struct super_block *oldsb,
+                                struct super_block *newsb);
 int security_inode_alloc(struct inode *inode);
 void security_inode_free(struct inode *inode);
 int security_inode_init_security(struct inode *inode, struct inode *dir,
@@ -1603,6 +1639,7 @@ int security_setprocattr(struct task_struct *p, char *name, void *value, size_t
 int security_netlink_send(struct sock *sk, struct sk_buff *skb);
 int security_netlink_recv(struct sk_buff *skb, int cap);
 int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen);
+int security_secctx_to_secid(char *secdata, u32 seclen, u32 *secid);
 void security_release_secctx(char *secdata, u32 seclen);
 #else /* CONFIG_SECURITY */
@@ -1777,9 +1814,6 @@ static inline void security_sb_post_remount (struct vfsmount *mnt,
                                             unsigned long flags, void *data)
 { }
-static inline void security_sb_post_mountroot (void)
-{ }
 static inline void security_sb_post_addmount (struct vfsmount *mnt,
                                              struct nameidata *mountpoint_nd)
 { }
@@ -2266,7 +2300,7 @@ static inline struct dentry *securityfs_create_file(const char *name,
                                                mode_t mode,
                                                struct dentry *parent,
                                                void *data,
-                                                struct file_operations *fops)
+                                                const struct file_operations *fops)
 {
        return ERR_PTR(-ENODEV);
 }
@@ -2280,6 +2314,13 @@ static inline int security_secid_to_secctx(u32 secid, char **secdata, u32 *secle
        return -EOPNOTSUPP;
 }
+static inline int security_secctx_to_secid(char *secdata,
+                                           u32 seclen,
+                                           u32 *secid)
+{
+        return -EOPNOTSUPP;
+}
 static inline void security_release_secctx(char *secdata, u32 seclen)
 {
 }
diff --git a/include/linux/smp_lock.h b/include/linux/smp_lock.h
index 58962c51dee1..aab3a4cff4e1 100644
--- a/include/linux/smp_lock.h
+++ b/include/linux/smp_lock.h
@@ -17,22 +17,10 @@ extern void __lockfunc __release_kernel_lock(void);
                __release_kernel_lock();        \
 } while (0)
-/*
- * Non-SMP kernels will never block on the kernel lock,
- * so we are better off returning a constant zero from
- * reacquire_kernel_lock() so that the compiler can see
- * it at compile-time.
- */
-#if defined(CONFIG_SMP) && !defined(CONFIG_PREEMPT_BKL)
-# define return_value_on_smp return
-#else
-# define return_value_on_smp
-#endif
 static inline int reacquire_kernel_lock(struct task_struct *task)
 {
        if (unlikely(task->lock_depth >= 0))
-                return_value_on_smp __reacquire_kernel_lock();
+                return __reacquire_kernel_lock();
        return 0;
 }
diff --git a/include/linux/stacktrace.h b/include/linux/stacktrace.h
index e7fa657d0c49..5da9794b2d78 100644
--- a/include/linux/stacktrace.h
+++ b/include/linux/stacktrace.h
@@ -9,10 +9,13 @@ struct stack_trace {
 };
 extern void save_stack_trace(struct stack_trace *trace);
+extern void save_stack_trace_tsk(struct task_struct *tsk,
+                                struct stack_trace *trace);
 extern void print_stack_trace(struct stack_trace *trace, int spaces);
 #else
 # define save_stack_trace(trace)                        do { } while (0)
+# define save_stack_trace_tsk(tsk, trace)               do { } while (0)
 # define print_stack_trace(trace, spaces)               do { } while (0)
 #endif
diff --git a/include/linux/sysdev.h b/include/linux/sysdev.h
index e285746588d6..f752e73bf977 100644
--- a/include/linux/sysdev.h
+++ b/include/linux/sysdev.h
@@ -29,6 +29,7 @@
 struct sys_device;
 struct sysdev_class {
+        const char *name;
        struct list_head        drivers;
        /* Default operations for these types of devices */
diff --git a/include/linux/tifm.h b/include/linux/tifm.h
index 6b3a31805c72..2096b76d0cee 100644
--- a/include/linux/tifm.h
+++ b/include/linux/tifm.h
@@ -120,7 +120,7 @@ struct tifm_adapter {
        struct completion   *finish_me;
        struct work_struct  media_switcher;
-        struct class_device cdev;
+        struct device       dev;
        void                (*eject)(struct tifm_adapter *fm,
                                     struct tifm_dev *sock);
diff --git a/include/linux/topology.h b/include/linux/topology.h
index 47729f18bfdf..2352f46160d3 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -5,7 +5,7 @@
 *
 * Copyright (C) 2002, IBM Corp.
 *
- * All rights reserved.          
+ * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -103,6 +103,7 @@
        .forkexec_idx           = 0,                    \
        .flags                  = SD_LOAD_BALANCE       \
                                | SD_BALANCE_NEWIDLE    \
+                                | SD_BALANCE_FORK       \
                                | SD_BALANCE_EXEC       \
                                | SD_WAKE_AFFINE        \
                                | SD_WAKE_IDLE          \
@@ -134,6 +135,7 @@
        .forkexec_idx           = 1,                    \
        .flags                  = SD_LOAD_BALANCE       \
                                | SD_BALANCE_NEWIDLE    \
+                                | SD_BALANCE_FORK       \
                                | SD_BALANCE_EXEC       \
                                | SD_WAKE_AFFINE        \
                                | SD_WAKE_IDLE          \
@@ -165,6 +167,7 @@
        .forkexec_idx           = 1,                    \
        .flags                  = SD_LOAD_BALANCE       \
                                | SD_BALANCE_NEWIDLE    \
+                                | SD_BALANCE_FORK       \
                                | SD_BALANCE_EXEC       \
                                | SD_WAKE_AFFINE        \
                                | BALANCE_FOR_PKG_POWER,\
diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h
index 44c28e94df50..973386d439da 100644
--- a/include/linux/uio_driver.h
+++ b/include/linux/uio_driver.h
@@ -18,20 +18,22 @@
 #include <linux/fs.h>
 #include <linux/interrupt.h>
+struct uio_map;
 /**
 * struct uio_mem - description of a UIO memory region
- * @kobj:               kobject for this mapping
 * @addr:               address of the device's memory
 * @size:               size of IO
 * @memtype:            type of memory addr points to
 * @internal_addr:      ioremap-ped version of addr, for driver internal use
+ * @map:                for use by the UIO core only.
 */
 struct uio_mem {
-        struct kobject          kobj;
        unsigned long           addr;
        unsigned long           size;
        int                     memtype;
        void __iomem            *internal_addr;
+        struct uio_map          *map;
 };
 #define MAX_UIO_MAPS    5
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 7daafdc2514b..7f28c32d9aca 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -149,19 +149,27 @@ struct execute_work {
 extern struct workqueue_struct *
 __create_workqueue_key(const char *name, int singlethread,
-                       int freezeable, struct lock_class_key *key);
+                       int freezeable, struct lock_class_key *key,
+                       const char *lock_name);
 #ifdef CONFIG_LOCKDEP
 #define __create_workqueue(name, singlethread, freezeable)      \
 ({                                                              \
        static struct lock_class_key __key;                     \
+        const char *__lock_name;                                \
+                                                                \
+        if (__builtin_constant_p(name))                         \
+                __lock_name = (name);                           \
+        else                                                    \
+                __lock_name = #name;                            \
                                                                \
        __create_workqueue_key((name), (singlethread),          \
-                               (freezeable), &__key);           \
+                               (freezeable), &__key,            \
+                               __lock_name);                    \
 })
 #else
 #define __create_workqueue(name, singlethread, freezeable)      \
-        __create_workqueue_key((name), (singlethread), (freezeable), NULL)
+        __create_workqueue_key((name), (singlethread), (freezeable), NULL, NULL)
 #endif
 #define create_workqueue(name) __create_workqueue((name), 0, 0)
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index bef7d66601cb..c6148bbf1250 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -62,7 +62,6 @@ struct writeback_control {
        unsigned for_reclaim:1;         /* Invoked from the page allocator */
        unsigned for_writepages:1;      /* This is a writepages() call */
        unsigned range_cyclic:1;        /* range_start is cyclic */
-        unsigned more_io:1;             /* more io to be dispatched */
 };
 /*
diff --git a/include/media/cs5345.h b/include/media/cs5345.h
new file mode 100644
index 000000000000..6ccae24e65ed
--- /dev/null
+++ b/include/media/cs5345.h
@@ -0,0 +1,39 @@
+/*
+    cs5345.h - definition for cs5345 inputs and outputs
+    Copyright (C) 2007 Hans Verkuil (hverkuil@xs4all.nl)
+    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 _CS5345_H_
+#define _CS5345_H_
+/* CS5345 HW inputs */
+#define CS5345_IN_MIC 0
+#define CS5345_IN_1   1
+#define CS5345_IN_2   2
+#define CS5345_IN_3   3
+#define CS5345_IN_4   4
+#define CS5345_IN_5   5
+#define CS5345_IN_6   6
+#define CS5345_MCLK_1   0x00
+#define CS5345_MCLK_1_5 0x10
+#define CS5345_MCLK_2   0x20
+#define CS5345_MCLK_3   0x30
+#define CS5345_MCLK_4   0x40
+#endif
diff --git a/include/media/cx2341x.h b/include/media/cx2341x.h
index af8071d7620d..5f4608e88476 100644
--- a/include/media/cx2341x.h
+++ b/include/media/cx2341x.h
@@ -83,7 +83,7 @@ struct cx2341x_mpeg_params {
 #define CX2341X_MBOX_MAX_DATA 16
 extern const u32 cx2341x_mpeg_ctrls[];
-typedef int (*cx2341x_mbox_func)(void *priv, int cmd, int in, int out,
+typedef int (*cx2341x_mbox_func)(void *priv, u32 cmd, int in, int out,
                u32 data[CX2341X_MBOX_MAX_DATA]);
 int cx2341x_update(void *priv, cx2341x_mbox_func func,
                const struct cx2341x_mpeg_params *old,
diff --git a/include/media/cx25840.h b/include/media/cx25840.h
index 8e7e52d659a0..cd599ad29fb2 100644
--- a/include/media/cx25840.h
+++ b/include/media/cx25840.h
@@ -49,6 +49,25 @@ enum cx25840_video_input {
        CX25840_SVIDEO2 = 0x620,
        CX25840_SVIDEO3 = 0x730,
        CX25840_SVIDEO4 = 0x840,
+        /* Allow frames to specify specific input configurations */
+        CX25840_VIN1_CH1  = 0x80000000,
+        CX25840_VIN2_CH1  = 0x80000001,
+        CX25840_VIN3_CH1  = 0x80000002,
+        CX25840_VIN4_CH1  = 0x80000003,
+        CX25840_VIN5_CH1  = 0x80000004,
+        CX25840_VIN6_CH1  = 0x80000005,
+        CX25840_VIN7_CH1  = 0x80000006,
+        CX25840_VIN8_CH1  = 0x80000007,
+        CX25840_VIN4_CH2  = 0x80000000,
+        CX25840_VIN5_CH2  = 0x80000010,
+        CX25840_VIN6_CH2  = 0x80000020,
+        CX25840_NONE_CH2  = 0x80000030,
+        CX25840_VIN7_CH3  = 0x80000000,
+        CX25840_VIN8_CH3  = 0x80000040,
+        CX25840_NONE0_CH3 = 0x80000080,
+        CX25840_NONE1_CH3 = 0x800000c0,
+        CX25840_SVIDEO_ON = 0x80000100,
 };
 enum cx25840_audio_input {
diff --git a/include/media/ir-common.h b/include/media/ir-common.h
index 7a785fa77212..831547d79683 100644
--- a/include/media/ir-common.h
+++ b/include/media/ir-common.h
@@ -97,7 +97,6 @@ int  ir_dump_samples(u32 *samples, int count);
 int  ir_decode_biphase(u32 *samples, int count, int low, int high);
 int  ir_decode_pulsedistance(u32 *samples, int count, int low, int high);
-u32 ir_rc5_decode(unsigned int code);
 void ir_rc5_timer_end(unsigned long data);
 void ir_rc5_timer_keyup(unsigned long data);
@@ -141,6 +140,8 @@ extern IR_KEYTAB_TYPE ir_codes_asus_pc39[IR_KEYTAB_SIZE];
 extern IR_KEYTAB_TYPE ir_codes_encore_enltv[IR_KEYTAB_SIZE];
 extern IR_KEYTAB_TYPE ir_codes_tt_1500[IR_KEYTAB_SIZE];
 extern IR_KEYTAB_TYPE ir_codes_fusionhdtv_mce[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_behold[IR_KEYTAB_SIZE];
+extern IR_KEYTAB_TYPE ir_codes_pinnacle_pctv_hd[IR_KEYTAB_SIZE];
 #endif
diff --git a/include/media/m52790.h b/include/media/m52790.h
new file mode 100644
index 000000000000..7ddffae31a67
--- /dev/null
+++ b/include/media/m52790.h
@@ -0,0 +1,93 @@
+/*
+    m52790.h - definition for m52790 inputs and outputs
+    Copyright (C) 2007 Hans Verkuil (hverkuil@xs4all.nl)
+    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 _M52790_H_
+#define _M52790_H_
+/* Input routing switch 1 */
+#define M52790_SW1_IN_MASK      0x0003
+#define M52790_SW1_IN_TUNER     0x0000
+#define M52790_SW1_IN_V2        0x0001
+#define M52790_SW1_IN_V3        0x0002
+#define M52790_SW1_IN_V4        0x0003
+/* Selects component input instead of composite */
+#define M52790_SW1_YCMIX        0x0004
+/* Input routing switch 2 */
+#define M52790_SW2_IN_MASK      0x0300
+#define M52790_SW2_IN_TUNER     0x0000
+#define M52790_SW2_IN_V2        0x0100
+#define M52790_SW2_IN_V3        0x0200
+#define M52790_SW2_IN_V4        0x0300
+/* Selects component input instead of composite */
+#define M52790_SW2_YCMIX        0x0400
+/* Output routing switch 1 */
+/* Enable 6dB amplifier for composite out */
+#define M52790_SW1_V_AMP        0x0008
+/* Enable 6dB amplifier for component out */
+#define M52790_SW1_YC_AMP       0x0010
+/* Audio output mode */
+#define M52790_SW1_AUDIO_MASK   0x00c0
+#define M52790_SW1_AUDIO_MUTE   0x0000
+#define M52790_SW1_AUDIO_R      0x0040
+#define M52790_SW1_AUDIO_L      0x0080
+#define M52790_SW1_AUDIO_STEREO 0x00c0
+/* Output routing switch 2 */
+/* Enable 6dB amplifier for composite out */
+#define M52790_SW2_V_AMP        0x0800
+/* Enable 6dB amplifier for component out */
+#define M52790_SW2_YC_AMP       0x1000
+/* Audio output mode */
+#define M52790_SW2_AUDIO_MASK   0xc000
+#define M52790_SW2_AUDIO_MUTE   0x0000
+#define M52790_SW2_AUDIO_R      0x4000
+#define M52790_SW2_AUDIO_L      0x8000
+#define M52790_SW2_AUDIO_STEREO 0xc000
+/* Common values */
+#define M52790_IN_TUNER (M52790_SW1_IN_TUNER | M52790_SW2_IN_TUNER)
+#define M52790_IN_V2    (M52790_SW1_IN_V2 | M52790_SW2_IN_V2)
+#define M52790_IN_V3    (M52790_SW1_IN_V3 | M52790_SW2_IN_V3)
+#define M52790_IN_V4    (M52790_SW1_IN_V4 | M52790_SW2_IN_V4)
+#define M52790_OUT_STEREO       (M52790_SW1_AUDIO_STEREO | \
+                                 M52790_SW2_AUDIO_STEREO)
+#define M52790_OUT_AMP_STEREO   (M52790_SW1_AUDIO_STEREO | \
+                                 M52790_SW1_V_AMP | \
+                                 M52790_SW2_AUDIO_STEREO | \
+                                 M52790_SW2_V_AMP)
+#endif
diff --git a/include/media/saa7146_vv.h b/include/media/saa7146_vv.h
index e49f7e156061..89c442eb8849 100644
--- a/include/media/saa7146_vv.h
+++ b/include/media/saa7146_vv.h
@@ -1,7 +1,6 @@
 #ifndef __SAA7146_VV__
 #define __SAA7146_VV__
-#include <linux/videodev.h>
 #include <media/v4l2-common.h>
 #include <media/saa7146.h>
 #include <media/videobuf-dma-sg.h>
diff --git a/include/media/tuner.h b/include/media/tuner.h
index c03dceb92605..1bf24a6ed8f1 100644
--- a/include/media/tuner.h
+++ b/include/media/tuner.h
@@ -24,8 +24,6 @@
 #include <linux/videodev2.h>
-extern int tuner_debug;
 #define ADDR_UNSET (255)
 #define TUNER_TEMIC_PAL                 0        /* 4002 FH5 (3X 7756, 9483) */
@@ -117,12 +115,13 @@ extern int tuner_debug;
 #define TUNER_PHILIPS_TUV1236D          68      /* ATI HDTV Wonder */
 #define TUNER_TNF_5335MF                69      /* Sabrent Bt848   */
 #define TUNER_SAMSUNG_TCPN_2121P30A     70      /* Hauppauge PVR-500MCE NTSC */
-#define TUNER_XCEIVE_XC3028             71
+#define TUNER_XC2028                    71
 #define TUNER_THOMSON_FE6600            72      /* DViCO FusionHDTV DVB-T Hybrid */
 #define TUNER_SAMSUNG_TCPG_6121P30A     73      /* Hauppauge PVR-500 PAL */
 #define TUNER_TDA9887                   74      /* This tuner should be used only internally */
 #define TUNER_TEA5761                   75      /* Only FM Radio Tuner */
+#define TUNER_XC5000                    76      /* Xceive Silicon Tuner */
 /* 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 8ae42c41dd08..032bb75f69c2 100644
--- a/include/media/v4l2-chip-ident.h
+++ b/include/media/v4l2-chip-ident.h
@@ -68,6 +68,9 @@ enum {
        /* module vp27smpx: just ident 2700 */
        V4L2_IDENT_VP27SMPX = 2700,
+        /* module cs5345: just ident 5345 */
+        V4L2_IDENT_CS5345 = 5345,
        /* module wm8739: just ident 8739 */
        V4L2_IDENT_WM8739 = 8739,
@@ -83,6 +86,9 @@ enum {
        /* module upd64083: just ident 64083 */
        V4L2_IDENT_UPD64083 = 64083,
+        /* module m52790: just ident 52790 */
+        V4L2_IDENT_M52790 = 52790,
        /* module msp34xx: reserved range 34000-34999 */
        V4L2_IDENT_MSP3400B = 34002,
        V4L2_IDENT_MSP3410B = 34102,
diff --git a/include/media/v4l2-common.h b/include/media/v4l2-common.h
index 181a40c46a52..475d0d8275e0 100644
--- a/include/media/v4l2-common.h
+++ b/include/media/v4l2-common.h
@@ -104,6 +104,17 @@ int v4l2_chip_match_host(u32 id_type, u32 chip_id);
 /* ------------------------------------------------------------------------- */
+/* Helper function for I2C legacy drivers */
+struct i2c_driver;
+struct i2c_adapter;
+struct i2c_client;
+int v4l2_i2c_attach(struct i2c_adapter *adapter, int address, struct i2c_driver *driver,
+                const char *name, int (*probe)(struct i2c_client *));
+/* ------------------------------------------------------------------------- */
 /* Internal ioctls */
 /* VIDIOC_INT_DECODE_VBI_LINE */
@@ -116,6 +127,11 @@ struct v4l2_decode_vbi_line {
        u32 type;               /* VBI service type (V4L2_SLICED_*). 0 if no service found */
 };
+struct v4l2_priv_tun_config {
+        int tuner;
+        void *priv;
+};
 /* audio ioctls */
 /* v4l device was opened in Radio mode, to be replaced by VIDIOC_INT_S_TUNER_MODE */
@@ -131,7 +147,7 @@ struct v4l2_decode_vbi_line {
 #define TUNER_SET_STANDBY            _IOW('d', 91, int)
 /* Sets tda9887 specific stuff, like port1, port2 and qss */
-#define TDA9887_SET_CONFIG           _IOW('d', 92, int)
+#define TUNER_SET_CONFIG           _IOW('d', 92, struct v4l2_priv_tun_config)
 /* Switch the tuner to a specific tuner mode. Replacement of AUDC_SET_RADIO */
 #define VIDIOC_INT_S_TUNER_MODE      _IOW('d', 93, enum v4l2_tuner_type)
diff --git a/include/media/v4l2-i2c-drv-legacy.h b/include/media/v4l2-i2c-drv-legacy.h
new file mode 100644
index 000000000000..241854229d6f
--- /dev/null
+++ b/include/media/v4l2-i2c-drv-legacy.h
@@ -0,0 +1,140 @@
+/*
+ * v4l2-i2c-drv-legacy.h - contains I2C handling code that's identical
+ *                  for all V4L2 I2C drivers. Use this header if the
+ *                  I2C driver is used by both legacy drivers and
+ *                  drivers converted to the bus-based I2C API.
+ *
+ * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
+ *
+ * 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.
+ */
+struct v4l2_i2c_driver_data {
+        const char * const name;
+        int driverid;
+        int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
+        int (*probe)(struct i2c_client *client);
+        int (*remove)(struct i2c_client *client);
+        int (*suspend)(struct i2c_client *client, pm_message_t state);
+        int (*resume)(struct i2c_client *client);
+        int (*legacy_probe)(struct i2c_adapter *adapter);
+        int legacy_class;
+};
+static struct v4l2_i2c_driver_data v4l2_i2c_data;
+static struct i2c_client_address_data addr_data;
+static struct i2c_driver v4l2_i2c_driver_legacy;
+static char v4l2_i2c_drv_name_legacy[32];
+static int v4l2_i2c_drv_attach_legacy(struct i2c_adapter *adapter, int address, int kind)
+{
+        return v4l2_i2c_attach(adapter, address, &v4l2_i2c_driver_legacy,
+                        v4l2_i2c_drv_name_legacy, v4l2_i2c_data.probe);
+}
+static int v4l2_i2c_drv_probe_legacy(struct i2c_adapter *adapter)
+{
+        if (v4l2_i2c_data.legacy_probe) {
+                if (v4l2_i2c_data.legacy_probe(adapter))
+                        return i2c_probe(adapter, &addr_data, v4l2_i2c_drv_attach_legacy);
+                return 0;
+        }
+        if (adapter->class & v4l2_i2c_data.legacy_class)
+                return i2c_probe(adapter, &addr_data, v4l2_i2c_drv_attach_legacy);
+        return 0;
+}
+static int v4l2_i2c_drv_detach_legacy(struct i2c_client *client)
+{
+        int err;
+        if (v4l2_i2c_data.remove)
+                v4l2_i2c_data.remove(client);
+        err = i2c_detach_client(client);
+        if (err)
+                return err;
+        kfree(client);
+        return 0;
+}
+static int v4l2_i2c_drv_suspend_helper(struct i2c_client *client, pm_message_t state)
+{
+        return v4l2_i2c_data.suspend ? v4l2_i2c_data.suspend(client, state) : 0;
+}
+static int v4l2_i2c_drv_resume_helper(struct i2c_client *client)
+{
+        return v4l2_i2c_data.resume ? v4l2_i2c_data.resume(client) : 0;
+}
+/* ----------------------------------------------------------------------- */
+/* i2c implementation */
+static struct i2c_driver v4l2_i2c_driver_legacy = {
+        .driver = {
+                .owner = THIS_MODULE,
+        },
+        .attach_adapter = v4l2_i2c_drv_probe_legacy,
+        .detach_client = v4l2_i2c_drv_detach_legacy,
+        .suspend = v4l2_i2c_drv_suspend_helper,
+        .resume  = v4l2_i2c_drv_resume_helper,
+};
+/* ----------------------------------------------------------------------- */
+/* i2c implementation */
+static struct i2c_driver v4l2_i2c_driver = {
+        .suspend        = v4l2_i2c_drv_suspend_helper,
+        .resume         = v4l2_i2c_drv_resume_helper,
+};
+static int __init v4l2_i2c_drv_init(void)
+{
+        int err;
+        strlcpy(v4l2_i2c_drv_name_legacy, v4l2_i2c_data.name, sizeof(v4l2_i2c_drv_name_legacy));
+        strlcat(v4l2_i2c_drv_name_legacy, "'", sizeof(v4l2_i2c_drv_name_legacy));
+        if (v4l2_i2c_data.legacy_class == 0)
+                v4l2_i2c_data.legacy_class = I2C_CLASS_TV_ANALOG;
+        v4l2_i2c_driver_legacy.driver.name = v4l2_i2c_drv_name_legacy;
+        v4l2_i2c_driver_legacy.id = v4l2_i2c_data.driverid;
+        v4l2_i2c_driver_legacy.command = v4l2_i2c_data.command;
+        err = i2c_add_driver(&v4l2_i2c_driver_legacy);
+        if (err)
+                return err;
+        v4l2_i2c_driver.driver.name = v4l2_i2c_data.name;
+        v4l2_i2c_driver.id = v4l2_i2c_data.driverid;
+        v4l2_i2c_driver.command = v4l2_i2c_data.command;
+        v4l2_i2c_driver.probe = v4l2_i2c_data.probe;
+        v4l2_i2c_driver.remove = v4l2_i2c_data.remove;
+        err = i2c_add_driver(&v4l2_i2c_driver);
+        if (err)
+                i2c_del_driver(&v4l2_i2c_driver_legacy);
+        return err;
+}
+static void __exit v4l2_i2c_drv_cleanup(void)
+{
+        i2c_del_driver(&v4l2_i2c_driver_legacy);
+        i2c_del_driver(&v4l2_i2c_driver);
+}
+module_init(v4l2_i2c_drv_init);
+module_exit(v4l2_i2c_drv_cleanup);
diff --git a/include/media/v4l2-i2c-drv.h b/include/media/v4l2-i2c-drv.h
new file mode 100644
index 000000000000..9e4bab276915
--- /dev/null
+++ b/include/media/v4l2-i2c-drv.h
@@ -0,0 +1,68 @@
+/*
+ * v4l2-i2c-drv.h - contains I2C handling code that's identical for
+ *                  all V4L2 I2C drivers. Use this header if the
+ *                  I2C driver is only used by drivers converted
+ *                  to the bus-based I2C API.
+ *
+ * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
+ *
+ * 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 __V4L2_I2C_DRV_H__
+#define __V4L2_I2C_DRV_H__
+#include <media/v4l2-common.h>
+struct v4l2_i2c_driver_data {
+        const char * const name;
+        int driverid;
+        int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
+        int (*probe)(struct i2c_client *client);
+        int (*remove)(struct i2c_client *client);
+        int (*suspend)(struct i2c_client *client, pm_message_t state);
+        int (*resume)(struct i2c_client *client);
+        int (*legacy_probe)(struct i2c_adapter *adapter);
+        int legacy_class;
+};
+static struct v4l2_i2c_driver_data v4l2_i2c_data;
+static struct i2c_driver v4l2_i2c_driver;
+/* Bus-based I2C implementation for kernels >= 2.6.22 */
+static int __init v4l2_i2c_drv_init(void)
+{
+        v4l2_i2c_driver.driver.name = v4l2_i2c_data.name;
+        v4l2_i2c_driver.id = v4l2_i2c_data.driverid;
+        v4l2_i2c_driver.command = v4l2_i2c_data.command;
+        v4l2_i2c_driver.probe = v4l2_i2c_data.probe;
+        v4l2_i2c_driver.remove = v4l2_i2c_data.remove;
+        v4l2_i2c_driver.suspend = v4l2_i2c_data.suspend;
+        v4l2_i2c_driver.resume = v4l2_i2c_data.resume;
+        return i2c_add_driver(&v4l2_i2c_driver);
+}
+static void __exit v4l2_i2c_drv_cleanup(void)
+{
+        i2c_del_driver(&v4l2_i2c_driver);
+}
+module_init(v4l2_i2c_drv_init);
+module_exit(v4l2_i2c_drv_cleanup);
+#endif /* __V4L2_I2C_DRV_H__ */
diff --git a/include/media/v4l2-int-device.h b/include/media/v4l2-int-device.h
index 066ebfc4f983..c8b80e0f0651 100644
--- a/include/media/v4l2-int-device.h
+++ b/include/media/v4l2-int-device.h
@@ -44,9 +44,8 @@ enum v4l2_int_type {
 struct v4l2_int_device;
 struct v4l2_int_master {
-        int (*attach)(struct v4l2_int_device *master,
+        int (*attach)(struct v4l2_int_device *slave);
-                      struct v4l2_int_device *slave);
+        void (*detach)(struct v4l2_int_device *slave);
-        void (*detach)(struct v4l2_int_device *master);
 };
 typedef int (v4l2_int_ioctl_func)(struct v4l2_int_device *);
diff --git a/include/media/videobuf-core.h b/include/media/videobuf-core.h
index 4fd5d0eaa935..97f14d469595 100644
--- a/include/media/videobuf-core.h
+++ b/include/media/videobuf-core.h
@@ -56,13 +56,13 @@ struct videobuf_mapping {
 };
 enum videobuf_state {
-        STATE_NEEDS_INIT = 0,
+        VIDEOBUF_NEEDS_INIT = 0,
-        STATE_PREPARED   = 1,
+        VIDEOBUF_PREPARED   = 1,
-        STATE_QUEUED     = 2,
+        VIDEOBUF_QUEUED     = 2,
-        STATE_ACTIVE     = 3,
+        VIDEOBUF_ACTIVE     = 3,
-        STATE_DONE       = 4,
+        VIDEOBUF_DONE       = 4,
-        STATE_ERROR      = 5,
+        VIDEOBUF_ERROR      = 5,
-        STATE_IDLE       = 6,
+        VIDEOBUF_IDLE       = 6,
 };
 struct videobuf_buffer {
@@ -162,12 +162,14 @@ struct videobuf_queue {
        struct videobuf_queue_ops  *ops;
        struct videobuf_qtype_ops  *int_ops;
+        unsigned int               streaming:1;
+        unsigned int               reading:1;
+        unsigned int               is_mmapped:1;
        /* capture via mmap() + ioctl(QBUF/DQBUF) */
-        unsigned int               streaming;
        struct list_head           stream;
        /* capture via read() */
-        unsigned int               reading;
        unsigned int               read_off;
        struct videobuf_buffer     *read_buf;
diff --git a/include/net/if_inet6.h b/include/net/if_inet6.h
index 448eccb20638..b24508abb850 100644
--- a/include/net/if_inet6.h
+++ b/include/net/if_inet6.h
@@ -269,18 +269,21 @@ static inline void ipv6_arcnet_mc_map(const struct in6_addr *addr, char *buf)
        buf[0] = 0x00;
 }
-static inline void ipv6_ib_mc_map(struct in6_addr *addr, char *buf)
+static inline void ipv6_ib_mc_map(const struct in6_addr *addr,
+                                  const unsigned char *broadcast, char *buf)
 {
+        unsigned char scope = broadcast[5] & 0xF;
        buf[0]  = 0;            /* Reserved */
        buf[1]  = 0xff;         /* Multicast QPN */
        buf[2]  = 0xff;
        buf[3]  = 0xff;
        buf[4]  = 0xff;
-        buf[5]  = 0x12;         /* link local scope */
+        buf[5]  = 0x10 | scope; /* scope from broadcast address */
        buf[6]  = 0x60;         /* IPv6 signature */
        buf[7]  = 0x1b;
-        buf[8]  = 0;            /* P_Key */
+        buf[8]  = broadcast[8]; /* P_Key */
-        buf[9]  = 0;
+        buf[9]  = broadcast[9];
        memcpy(buf + 10, addr->s6_addr + 6, 10);
 }
 #endif
diff --git a/include/net/ip.h b/include/net/ip.h
index 840dd91b513b..50c8889b1b8d 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -266,20 +266,22 @@ static inline void ip_eth_mc_map(__be32 naddr, char *buf)
 *      Leave P_Key as 0 to be filled in by driver.
 */
-static inline void ip_ib_mc_map(__be32 naddr, char *buf)
+static inline void ip_ib_mc_map(__be32 naddr, const unsigned char *broadcast, char *buf)
 {
        __u32 addr;
+        unsigned char scope = broadcast[5] & 0xF;
        buf[0]  = 0;            /* Reserved */
        buf[1]  = 0xff;         /* Multicast QPN */
        buf[2]  = 0xff;
        buf[3]  = 0xff;
        addr    = ntohl(naddr);
        buf[4]  = 0xff;
-        buf[5]  = 0x12;         /* link local scope */
+        buf[5]  = 0x10 | scope; /* scope from broadcast address */
        buf[6]  = 0x40;         /* IPv4 signature */
        buf[7]  = 0x1b;
-        buf[8]  = 0;            /* P_Key */
+        buf[8]  = broadcast[8];         /* P_Key */
-        buf[9]  = 0;
+        buf[9]  = broadcast[9];
        buf[10] = 0;
        buf[11] = 0;
        buf[12] = 0;
diff --git a/include/rdma/ib_mad.h b/include/rdma/ib_mad.h
index 8ec3799e42e1..7228c056b9e9 100644
--- a/include/rdma/ib_mad.h
+++ b/include/rdma/ib_mad.h
@@ -230,7 +230,9 @@ struct ib_class_port_info
 * @seg_count: The number of RMPP segments allocated for this send.
 * @seg_size: Size of each RMPP segment.
 * @timeout_ms: Time to wait for a response.
- * @retries: Number of times to retry a request for a response.
+ * @retries: Number of times to retry a request for a response.  For MADs
+ *   using RMPP, this applies per window.  On completion, returns the number
+ *   of retries needed to complete the transfer.
 *
 * Users are responsible for initializing the MAD buffer itself, with the
 * exception of any RMPP header.  Additional segment buffer space allocated
diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h
index 11f39606e7d9..cfbd38fe2998 100644
--- a/include/rdma/ib_verbs.h
+++ b/include/rdma/ib_verbs.h
@@ -1026,7 +1026,7 @@ struct ib_device {
        struct module               *owner;
        struct class_device          class_dev;
-        struct kobject               ports_parent;
+        struct kobject               *ports_parent;
        struct list_head             port_list;
        enum {
diff --git a/include/rdma/rdma_user_cm.h b/include/rdma/rdma_user_cm.h
index 9749c1b34d00..c55705460b87 100644
--- a/include/rdma/rdma_user_cm.h
+++ b/include/rdma/rdma_user_cm.h
@@ -60,7 +60,8 @@ enum {
        RDMA_USER_CM_CMD_SET_OPTION,
        RDMA_USER_CM_CMD_NOTIFY,
        RDMA_USER_CM_CMD_JOIN_MCAST,
-        RDMA_USER_CM_CMD_LEAVE_MCAST
+        RDMA_USER_CM_CMD_LEAVE_MCAST,
+        RDMA_USER_CM_CMD_MIGRATE_ID
 };
 /*
@@ -230,4 +231,14 @@ struct rdma_ucm_set_option {
        __u32 optlen;
 };
+struct rdma_ucm_migrate_id {
+        __u64 response;
+        __u32 id;
+        __u32 fd;
+};
+struct rdma_ucm_migrate_resp {
+        __u32 events_reported;
+};
 #endif /* RDMA_USER_CM_H */