* [gentoo-commits] linux-patches r1515 - genpatches-2.6/trunk/2.6.28
@ 2009-03-17 12:48 Mike Pagano (mpagano)
0 siblings, 0 replies; only message in thread
From: Mike Pagano (mpagano) @ 2009-03-17 12:48 UTC (permalink / raw
To: gentoo-commits
Author: mpagano
Date: 2009-03-17 12:48:37 +0000 (Tue, 17 Mar 2009)
New Revision: 1515
Added:
genpatches-2.6/trunk/2.6.28/1007_linux-2.6.28.8.patch
Removed:
genpatches-2.6/trunk/2.6.28/1500_algo-test-race-fix-aead-init.patch
Modified:
genpatches-2.6/trunk/2.6.28/0000_README
Log:
Linux patch version 2.6.28.8 and removal of redundant patches
Modified: genpatches-2.6/trunk/2.6.28/0000_README
===================================================================
--- genpatches-2.6/trunk/2.6.28/0000_README 2009-03-15 00:03:13 UTC (rev 1514)
+++ genpatches-2.6/trunk/2.6.28/0000_README 2009-03-17 12:48:37 UTC (rev 1515)
@@ -67,9 +67,9 @@
From: http://www.kernel.org
Desc: Linux 2.6.28.7
-Patch: 1500_algo-test-race-fix-aead-init.patch
-From: http://bugs.gentoo.org/show_bug.cgi?id=259332
-Desc: crypto: api - Fix algorithm test race that broke aead init
+Patch: 1007_linux-2.6.28.8.patch
+From: http://www.kernel.org
+Desc: Linux 2.6.28.8
Patch: 1900_revert-ext3-wait-on-pending-commits.patch
From: http://bugs.gentoo.org/show_bug.cgi?id=257738
Added: genpatches-2.6/trunk/2.6.28/1007_linux-2.6.28.8.patch
===================================================================
--- genpatches-2.6/trunk/2.6.28/1007_linux-2.6.28.8.patch (rev 0)
+++ genpatches-2.6/trunk/2.6.28/1007_linux-2.6.28.8.patch 2009-03-17 12:48:37 UTC (rev 1515)
@@ -0,0 +1,4229 @@
+diff --git a/arch/arm/mach-rpc/riscpc.c b/arch/arm/mach-rpc/riscpc.c
+index e88d417..c7fc01e 100644
+--- a/arch/arm/mach-rpc/riscpc.c
++++ b/arch/arm/mach-rpc/riscpc.c
+@@ -19,6 +19,7 @@
+ #include <linux/serial_8250.h>
+ #include <linux/ata_platform.h>
+ #include <linux/io.h>
++#include <linux/i2c.h>
+
+ #include <asm/elf.h>
+ #include <asm/mach-types.h>
+@@ -201,8 +202,13 @@ static struct platform_device *devs[] __initdata = {
+ &pata_device,
+ };
+
++static struct i2c_board_info i2c_rtc = {
++ I2C_BOARD_INFO("pcf8583", 0x50)
++};
++
+ static int __init rpc_init(void)
+ {
++ i2c_register_board_info(0, &i2c_rtc, 1);
+ return platform_add_devices(devs, ARRAY_SIZE(devs));
+ }
+
+diff --git a/arch/ia64/include/asm/mmzone.h b/arch/ia64/include/asm/mmzone.h
+index 34efe88..f2ca320 100644
+--- a/arch/ia64/include/asm/mmzone.h
++++ b/arch/ia64/include/asm/mmzone.h
+@@ -31,10 +31,6 @@ static inline int pfn_to_nid(unsigned long pfn)
+ #endif
+ }
+
+-#ifdef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
+-extern int early_pfn_to_nid(unsigned long pfn);
+-#endif
+-
+ #ifdef CONFIG_IA64_DIG /* DIG systems are small */
+ # define MAX_PHYSNODE_ID 8
+ # define NR_NODE_MEMBLKS (MAX_NUMNODES * 8)
+diff --git a/arch/ia64/mm/numa.c b/arch/ia64/mm/numa.c
+index b73bf18..3efea7d 100644
+--- a/arch/ia64/mm/numa.c
++++ b/arch/ia64/mm/numa.c
+@@ -58,7 +58,7 @@ paddr_to_nid(unsigned long paddr)
+ * SPARSEMEM to allocate the SPARSEMEM sectionmap on the NUMA node where
+ * the section resides.
+ */
+-int early_pfn_to_nid(unsigned long pfn)
++int __meminit __early_pfn_to_nid(unsigned long pfn)
+ {
+ int i, section = pfn >> PFN_SECTION_SHIFT, ssec, esec;
+
+@@ -70,7 +70,7 @@ int early_pfn_to_nid(unsigned long pfn)
+ return node_memblk[i].nid;
+ }
+
+- return 0;
++ return -1;
+ }
+
+ #ifdef CONFIG_MEMORY_HOTPLUG
+diff --git a/arch/mips/include/asm/compat.h b/arch/mips/include/asm/compat.h
+index ac5d541..6c5b409 100644
+--- a/arch/mips/include/asm/compat.h
++++ b/arch/mips/include/asm/compat.h
+@@ -3,6 +3,8 @@
+ /*
+ * Architecture specific compatibility types
+ */
++#include <linux/seccomp.h>
++#include <linux/thread_info.h>
+ #include <linux/types.h>
+ #include <asm/page.h>
+ #include <asm/ptrace.h>
+@@ -218,4 +220,9 @@ struct compat_shmid64_ds {
+ compat_ulong_t __unused2;
+ };
+
++static inline int is_compat_task(void)
++{
++ return test_thread_flag(TIF_32BIT);
++}
++
+ #endif /* _ASM_COMPAT_H */
+diff --git a/arch/mips/include/asm/seccomp.h b/arch/mips/include/asm/seccomp.h
+index 36ed440..a6772e9 100644
+--- a/arch/mips/include/asm/seccomp.h
++++ b/arch/mips/include/asm/seccomp.h
+@@ -1,6 +1,5 @@
+ #ifndef __ASM_SECCOMP_H
+
+-#include <linux/thread_info.h>
+ #include <linux/unistd.h>
+
+ #define __NR_seccomp_read __NR_read
+diff --git a/arch/powerpc/include/asm/compat.h b/arch/powerpc/include/asm/compat.h
+index d811a8c..4774c2f 100644
+--- a/arch/powerpc/include/asm/compat.h
++++ b/arch/powerpc/include/asm/compat.h
+@@ -210,5 +210,10 @@ struct compat_shmid64_ds {
+ compat_ulong_t __unused6;
+ };
+
++static inline int is_compat_task(void)
++{
++ return test_thread_flag(TIF_32BIT);
++}
++
+ #endif /* __KERNEL__ */
+ #endif /* _ASM_POWERPC_COMPAT_H */
+diff --git a/arch/powerpc/include/asm/seccomp.h b/arch/powerpc/include/asm/seccomp.h
+index 853765e..00c1d91 100644
+--- a/arch/powerpc/include/asm/seccomp.h
++++ b/arch/powerpc/include/asm/seccomp.h
+@@ -1,10 +1,6 @@
+ #ifndef _ASM_POWERPC_SECCOMP_H
+ #define _ASM_POWERPC_SECCOMP_H
+
+-#ifdef __KERNEL__
+-#include <linux/thread_info.h>
+-#endif
+-
+ #include <linux/unistd.h>
+
+ #define __NR_seccomp_read __NR_read
+diff --git a/arch/powerpc/kernel/align.c b/arch/powerpc/kernel/align.c
+index ada0692..73cb6a3 100644
+--- a/arch/powerpc/kernel/align.c
++++ b/arch/powerpc/kernel/align.c
+@@ -367,27 +367,24 @@ static int emulate_multiple(struct pt_regs *regs, unsigned char __user *addr,
+ static int emulate_fp_pair(unsigned char __user *addr, unsigned int reg,
+ unsigned int flags)
+ {
+- char *ptr = (char *) ¤t->thread.TS_FPR(reg);
+- int i, ret;
++ char *ptr0 = (char *) ¤t->thread.TS_FPR(reg);
++ char *ptr1 = (char *) ¤t->thread.TS_FPR(reg+1);
++ int i, ret, sw = 0;
+
+ if (!(flags & F))
+ return 0;
+ if (reg & 1)
+ return 0; /* invalid form: FRS/FRT must be even */
+- if (!(flags & SW)) {
+- /* not byte-swapped - easy */
+- if (!(flags & ST))
+- ret = __copy_from_user(ptr, addr, 16);
+- else
+- ret = __copy_to_user(addr, ptr, 16);
+- } else {
+- /* each FPR value is byte-swapped separately */
+- ret = 0;
+- for (i = 0; i < 16; ++i) {
+- if (!(flags & ST))
+- ret |= __get_user(ptr[i^7], addr + i);
+- else
+- ret |= __put_user(ptr[i^7], addr + i);
++ if (flags & SW)
++ sw = 7;
++ ret = 0;
++ for (i = 0; i < 8; ++i) {
++ if (!(flags & ST)) {
++ ret |= __get_user(ptr0[i^sw], addr + i);
++ ret |= __get_user(ptr1[i^sw], addr + i + 8);
++ } else {
++ ret |= __put_user(ptr0[i^sw], addr + i);
++ ret |= __put_user(ptr1[i^sw], addr + i + 8);
+ }
+ }
+ if (ret)
+diff --git a/arch/sparc/include/asm/compat.h b/arch/sparc/include/asm/compat.h
+index f260b58..0e70625 100644
+--- a/arch/sparc/include/asm/compat.h
++++ b/arch/sparc/include/asm/compat.h
+@@ -240,4 +240,9 @@ struct compat_shmid64_ds {
+ unsigned int __unused2;
+ };
+
++static inline int is_compat_task(void)
++{
++ return test_thread_flag(TIF_32BIT);
++}
++
+ #endif /* _ASM_SPARC64_COMPAT_H */
+diff --git a/arch/sparc/include/asm/seccomp.h b/arch/sparc/include/asm/seccomp.h
+index 7fcd996..adca1bc 100644
+--- a/arch/sparc/include/asm/seccomp.h
++++ b/arch/sparc/include/asm/seccomp.h
+@@ -1,11 +1,5 @@
+ #ifndef _ASM_SECCOMP_H
+
+-#include <linux/thread_info.h> /* already defines TIF_32BIT */
+-
+-#ifndef TIF_32BIT
+-#error "unexpected TIF_32BIT on sparc64"
+-#endif
+-
+ #include <linux/unistd.h>
+
+ #define __NR_seccomp_read __NR_read
+diff --git a/arch/sparc64/kernel/chmc.c b/arch/sparc64/kernel/chmc.c
+index 3b9f4d6..e1a9598 100644
+--- a/arch/sparc64/kernel/chmc.c
++++ b/arch/sparc64/kernel/chmc.c
+@@ -306,6 +306,7 @@ static int jbusmc_print_dimm(int syndrome_code,
+ buf[1] = '?';
+ buf[2] = '?';
+ buf[3] = '\0';
++ return 0;
+ }
+ p = dp->controller;
+ prop = &p->layout;
+diff --git a/arch/sparc64/kernel/traps.c b/arch/sparc64/kernel/traps.c
+index 81ccd22..356e80b 100644
+--- a/arch/sparc64/kernel/traps.c
++++ b/arch/sparc64/kernel/traps.c
+@@ -1,6 +1,6 @@
+ /* arch/sparc64/kernel/traps.c
+ *
+- * Copyright (C) 1995,1997,2008 David S. Miller (davem@davemloft.net)
++ * Copyright (C) 1995,1997,2008,2009 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 1997,1999,2000 Jakub Jelinek (jakub@redhat.com)
+ */
+
+@@ -313,6 +313,21 @@ void sun4v_data_access_exception(struct pt_regs *regs, unsigned long addr, unsig
+ return;
+
+ if (regs->tstate & TSTATE_PRIV) {
++ /* Test if this comes from uaccess places. */
++ const struct exception_table_entry *entry;
++
++ entry = search_exception_tables(regs->tpc);
++ if (entry) {
++ /* Ouch, somebody is trying VM hole tricks on us... */
++#ifdef DEBUG_EXCEPTIONS
++ printk("Exception: PC<%016lx> faddr<UNKNOWN>\n", regs->tpc);
++ printk("EX_TABLE: insn<%016lx> fixup<%016lx>\n",
++ regs->tpc, entry->fixup);
++#endif
++ regs->tpc = entry->fixup;
++ regs->tnpc = regs->tpc + 4;
++ return;
++ }
+ printk("sun4v_data_access_exception: ADDR[%016lx] "
+ "CTX[%04x] TYPE[%04x], going.\n",
+ addr, ctx, type);
+diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S
+index 256b00b..5a0d76d 100644
+--- a/arch/x86/ia32/ia32entry.S
++++ b/arch/x86/ia32/ia32entry.S
+@@ -418,9 +418,9 @@ ENTRY(ia32_syscall)
+ orl $TS_COMPAT,TI_status(%r10)
+ testl $_TIF_WORK_SYSCALL_ENTRY,TI_flags(%r10)
+ jnz ia32_tracesys
+-ia32_do_syscall:
+ cmpl $(IA32_NR_syscalls-1),%eax
+- ja int_ret_from_sys_call /* ia32_tracesys has set RAX(%rsp) */
++ ja ia32_badsys
++ia32_do_call:
+ IA32_ARG_FIXUP
+ call *ia32_sys_call_table(,%rax,8) # xxx: rip relative
+ ia32_sysret:
+@@ -435,7 +435,9 @@ ia32_tracesys:
+ call syscall_trace_enter
+ LOAD_ARGS32 ARGOFFSET /* reload args from stack in case ptrace changed it */
+ RESTORE_REST
+- jmp ia32_do_syscall
++ cmpl $(IA32_NR_syscalls-1),%eax
++ ja int_ret_from_sys_call /* ia32_tracesys has set RAX(%rsp) */
++ jmp ia32_do_call
+ END(ia32_syscall)
+
+ ia32_badsys:
+diff --git a/arch/x86/include/asm/math_emu.h b/arch/x86/include/asm/math_emu.h
+index 5a65b10..031f626 100644
+--- a/arch/x86/include/asm/math_emu.h
++++ b/arch/x86/include/asm/math_emu.h
+@@ -1,31 +1,18 @@
+ #ifndef _ASM_X86_MATH_EMU_H
+ #define _ASM_X86_MATH_EMU_H
+
++#include <asm/ptrace.h>
++#include <asm/vm86.h>
++
+ /* This structure matches the layout of the data saved to the stack
+ following a device-not-present interrupt, part of it saved
+ automatically by the 80386/80486.
+ */
+-struct info {
++struct math_emu_info {
+ long ___orig_eip;
+- long ___ebx;
+- long ___ecx;
+- long ___edx;
+- long ___esi;
+- long ___edi;
+- long ___ebp;
+- long ___eax;
+- long ___ds;
+- long ___es;
+- long ___fs;
+- long ___orig_eax;
+- long ___eip;
+- long ___cs;
+- long ___eflags;
+- long ___esp;
+- long ___ss;
+- long ___vm86_es; /* This and the following only in vm86 mode */
+- long ___vm86_ds;
+- long ___vm86_fs;
+- long ___vm86_gs;
++ union {
++ struct pt_regs *regs;
++ struct kernel_vm86_regs *vm86;
++ };
+ };
+ #endif /* _ASM_X86_MATH_EMU_H */
+diff --git a/arch/x86/include/asm/mmzone_32.h b/arch/x86/include/asm/mmzone_32.h
+index 07f1af4..105fb90 100644
+--- a/arch/x86/include/asm/mmzone_32.h
++++ b/arch/x86/include/asm/mmzone_32.h
+@@ -32,8 +32,6 @@ static inline void get_memcfg_numa(void)
+ get_memcfg_numa_flat();
+ }
+
+-extern int early_pfn_to_nid(unsigned long pfn);
+-
+ extern void resume_map_numa_kva(pgd_t *pgd);
+
+ #else /* !CONFIG_NUMA */
+diff --git a/arch/x86/include/asm/mmzone_64.h b/arch/x86/include/asm/mmzone_64.h
+index a5b3817..a29f48c 100644
+--- a/arch/x86/include/asm/mmzone_64.h
++++ b/arch/x86/include/asm/mmzone_64.h
+@@ -40,8 +40,6 @@ static inline __attribute__((pure)) int phys_to_nid(unsigned long addr)
+ #define node_end_pfn(nid) (NODE_DATA(nid)->node_start_pfn + \
+ NODE_DATA(nid)->node_spanned_pages)
+
+-extern int early_pfn_to_nid(unsigned long pfn);
+-
+ #ifdef CONFIG_NUMA_EMU
+ #define FAKE_NODE_MIN_SIZE (64 * 1024 * 1024)
+ #define FAKE_NODE_MIN_HASH_MASK (~(FAKE_NODE_MIN_SIZE - 1UL))
+diff --git a/arch/x86/include/asm/paravirt.h b/arch/x86/include/asm/paravirt.h
+index ba3e2ff..a660ece 100644
+--- a/arch/x86/include/asm/paravirt.h
++++ b/arch/x86/include/asm/paravirt.h
+@@ -1352,14 +1352,7 @@ static inline void arch_leave_lazy_cpu_mode(void)
+ PVOP_VCALL0(pv_cpu_ops.lazy_mode.leave);
+ }
+
+-static inline void arch_flush_lazy_cpu_mode(void)
+-{
+- if (unlikely(paravirt_get_lazy_mode() == PARAVIRT_LAZY_CPU)) {
+- arch_leave_lazy_cpu_mode();
+- arch_enter_lazy_cpu_mode();
+- }
+-}
+-
++void arch_flush_lazy_cpu_mode(void);
+
+ #define __HAVE_ARCH_ENTER_LAZY_MMU_MODE
+ static inline void arch_enter_lazy_mmu_mode(void)
+@@ -1372,13 +1365,7 @@ static inline void arch_leave_lazy_mmu_mode(void)
+ PVOP_VCALL0(pv_mmu_ops.lazy_mode.leave);
+ }
+
+-static inline void arch_flush_lazy_mmu_mode(void)
+-{
+- if (unlikely(paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU)) {
+- arch_leave_lazy_mmu_mode();
+- arch_enter_lazy_mmu_mode();
+- }
+-}
++void arch_flush_lazy_mmu_mode(void);
+
+ static inline void __set_fixmap(unsigned /* enum fixed_addresses */ idx,
+ unsigned long phys, pgprot_t flags)
+diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h
+index 5ca01e3..06d6f30 100644
+--- a/arch/x86/include/asm/processor.h
++++ b/arch/x86/include/asm/processor.h
+@@ -349,7 +349,7 @@ struct i387_soft_struct {
+ u8 no_update;
+ u8 rm;
+ u8 alimit;
+- struct info *info;
++ struct math_emu_info *info;
+ u32 entry_eip;
+ };
+
+diff --git a/arch/x86/include/asm/seccomp_32.h b/arch/x86/include/asm/seccomp_32.h
+index a6ad87b..b811d6f 100644
+--- a/arch/x86/include/asm/seccomp_32.h
++++ b/arch/x86/include/asm/seccomp_32.h
+@@ -1,12 +1,6 @@
+ #ifndef _ASM_X86_SECCOMP_32_H
+ #define _ASM_X86_SECCOMP_32_H
+
+-#include <linux/thread_info.h>
+-
+-#ifdef TIF_32BIT
+-#error "unexpected TIF_32BIT on i386"
+-#endif
+-
+ #include <linux/unistd.h>
+
+ #define __NR_seccomp_read __NR_read
+diff --git a/arch/x86/include/asm/seccomp_64.h b/arch/x86/include/asm/seccomp_64.h
+index 4171bb7..84ec1bd 100644
+--- a/arch/x86/include/asm/seccomp_64.h
++++ b/arch/x86/include/asm/seccomp_64.h
+@@ -1,14 +1,6 @@
+ #ifndef _ASM_X86_SECCOMP_64_H
+ #define _ASM_X86_SECCOMP_64_H
+
+-#include <linux/thread_info.h>
+-
+-#ifdef TIF_32BIT
+-#error "unexpected TIF_32BIT on x86_64"
+-#else
+-#define TIF_32BIT TIF_IA32
+-#endif
+-
+ #include <linux/unistd.h>
+ #include <asm/ia32_unistd.h>
+
+diff --git a/arch/x86/include/asm/traps.h b/arch/x86/include/asm/traps.h
+index 45dee28..6941aa7 100644
+--- a/arch/x86/include/asm/traps.h
++++ b/arch/x86/include/asm/traps.h
+@@ -41,7 +41,7 @@ dotraplinkage void do_int3(struct pt_regs *, long);
+ dotraplinkage void do_overflow(struct pt_regs *, long);
+ dotraplinkage void do_bounds(struct pt_regs *, long);
+ dotraplinkage void do_invalid_op(struct pt_regs *, long);
+-dotraplinkage void do_device_not_available(struct pt_regs *, long);
++dotraplinkage void do_device_not_available(struct pt_regs);
+ dotraplinkage void do_coprocessor_segment_overrun(struct pt_regs *, long);
+ dotraplinkage void do_invalid_TSS(struct pt_regs *, long);
+ dotraplinkage void do_segment_not_present(struct pt_regs *, long);
+@@ -74,8 +74,8 @@ extern int kstack_depth_to_print;
+
+ #ifdef CONFIG_X86_32
+ void math_error(void __user *);
++void math_emulate(struct math_emu_info *);
+ unsigned long patch_espfix_desc(unsigned long, unsigned long);
+-asmlinkage void math_emulate(long);
+ #endif
+
+ #endif /* _ASM_X86_TRAPS_H */
+diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c
+index c78c048..18f41b5 100644
+--- a/arch/x86/kernel/cpu/mtrr/main.c
++++ b/arch/x86/kernel/cpu/mtrr/main.c
+@@ -1600,8 +1600,7 @@ int __init mtrr_trim_uncached_memory(unsigned long end_pfn)
+
+ /* kvm/qemu doesn't have mtrr set right, don't trim them all */
+ if (!highest_pfn) {
+- WARN(!kvm_para_available(), KERN_WARNING
+- "WARNING: strange, CPU MTRRs all blank?\n");
++ printk(KERN_INFO "CPU MTRRs all blank - virtualized system.\n");
+ return 0;
+ }
+
+diff --git a/arch/x86/kernel/hpet.c b/arch/x86/kernel/hpet.c
+index 067d8de..d82891c 100644
+--- a/arch/x86/kernel/hpet.c
++++ b/arch/x86/kernel/hpet.c
+@@ -267,6 +267,8 @@ static void hpet_set_mode(enum clock_event_mode mode,
+ now = hpet_readl(HPET_COUNTER);
+ cmp = now + (unsigned long) delta;
+ cfg = hpet_readl(HPET_Tn_CFG(timer));
++ /* Make sure we use edge triggered interrupts */
++ cfg &= ~HPET_TN_LEVEL;
+ cfg |= HPET_TN_ENABLE | HPET_TN_PERIODIC |
+ HPET_TN_SETVAL | HPET_TN_32BIT;
+ hpet_writel(cfg, HPET_Tn_CFG(timer));
+diff --git a/arch/x86/kernel/paravirt.c b/arch/x86/kernel/paravirt.c
+index e4c8fb6..dcba6c5 100644
+--- a/arch/x86/kernel/paravirt.c
++++ b/arch/x86/kernel/paravirt.c
+@@ -268,6 +268,30 @@ enum paravirt_lazy_mode paravirt_get_lazy_mode(void)
+ return __get_cpu_var(paravirt_lazy_mode);
+ }
+
++void arch_flush_lazy_mmu_mode(void)
++{
++ preempt_disable();
++
++ if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_MMU) {
++ arch_leave_lazy_mmu_mode();
++ arch_enter_lazy_mmu_mode();
++ }
++
++ preempt_enable();
++}
++
++void arch_flush_lazy_cpu_mode(void)
++{
++ preempt_disable();
++
++ if (paravirt_get_lazy_mode() == PARAVIRT_LAZY_CPU) {
++ arch_leave_lazy_cpu_mode();
++ arch_enter_lazy_cpu_mode();
++ }
++
++ preempt_enable();
++}
++
+ struct pv_info pv_info = {
+ .name = "bare hardware",
+ .paravirt_enabled = 0,
+diff --git a/arch/x86/kernel/ptrace.c b/arch/x86/kernel/ptrace.c
+index 0a6d8c1..17fde52 100644
+--- a/arch/x86/kernel/ptrace.c
++++ b/arch/x86/kernel/ptrace.c
+@@ -1512,7 +1512,7 @@ void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs,
+ #ifdef CONFIG_X86_32
+ # define IS_IA32 1
+ #elif defined CONFIG_IA32_EMULATION
+-# define IS_IA32 test_thread_flag(TIF_IA32)
++# define IS_IA32 is_compat_task()
+ #else
+ # define IS_IA32 0
+ #endif
+diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
+index cc5a254..4e0afee 100644
+--- a/arch/x86/kernel/reboot.c
++++ b/arch/x86/kernel/reboot.c
+@@ -202,6 +202,14 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
+ DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"),
+ },
+ },
++ { /* Handle problems with rebooting on Dell XPS710 */
++ .callback = set_bios_reboot,
++ .ident = "Dell XPS710",
++ .matches = {
++ DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
++ DMI_MATCH(DMI_PRODUCT_NAME, "Dell XPS710"),
++ },
++ },
+ { }
+ };
+
+diff --git a/arch/x86/kernel/traps.c b/arch/x86/kernel/traps.c
+index 662f1b4..70bdbb5 100644
+--- a/arch/x86/kernel/traps.c
++++ b/arch/x86/kernel/traps.c
+@@ -912,7 +912,7 @@ asmlinkage void math_state_restore(void)
+ EXPORT_SYMBOL_GPL(math_state_restore);
+
+ #ifndef CONFIG_MATH_EMULATION
+-asmlinkage void math_emulate(long arg)
++void math_emulate(struct math_emu_info *info)
+ {
+ printk(KERN_EMERG
+ "math-emulation not enabled and no coprocessor found.\n");
+@@ -922,16 +922,19 @@ asmlinkage void math_emulate(long arg)
+ }
+ #endif /* CONFIG_MATH_EMULATION */
+
+-dotraplinkage void __kprobes
+-do_device_not_available(struct pt_regs *regs, long error)
++dotraplinkage void __kprobes do_device_not_available(struct pt_regs regs)
+ {
+ #ifdef CONFIG_X86_32
+ if (read_cr0() & X86_CR0_EM) {
+- conditional_sti(regs);
+- math_emulate(0);
++ struct math_emu_info info = { };
++
++ conditional_sti(®s);
++
++ info.regs = ®s;
++ math_emulate(&info);
+ } else {
+ math_state_restore(); /* interrupts still off */
+- conditional_sti(regs);
++ conditional_sti(®s);
+ }
+ #else
+ math_state_restore();
+diff --git a/arch/x86/kernel/vmiclock_32.c b/arch/x86/kernel/vmiclock_32.c
+index 254ee07..8f92321 100644
+--- a/arch/x86/kernel/vmiclock_32.c
++++ b/arch/x86/kernel/vmiclock_32.c
+@@ -283,10 +283,13 @@ void __devinit vmi_time_ap_init(void)
+ #endif
+
+ /** vmi clocksource */
++static struct clocksource clocksource_vmi;
+
+ static cycle_t read_real_cycles(void)
+ {
+- return vmi_timer_ops.get_cycle_counter(VMI_CYCLES_REAL);
++ cycle_t ret = (cycle_t)vmi_timer_ops.get_cycle_counter(VMI_CYCLES_REAL);
++ return ret >= clocksource_vmi.cycle_last ?
++ ret : clocksource_vmi.cycle_last;
+ }
+
+ static struct clocksource clocksource_vmi = {
+diff --git a/arch/x86/math-emu/fpu_entry.c b/arch/x86/math-emu/fpu_entry.c
+index c7b06fe..5d87f58 100644
+--- a/arch/x86/math-emu/fpu_entry.c
++++ b/arch/x86/math-emu/fpu_entry.c
+@@ -131,7 +131,7 @@ u_char emulating = 0;
+ static int valid_prefix(u_char *Byte, u_char __user ** fpu_eip,
+ overrides * override);
+
+-asmlinkage void math_emulate(long arg)
++void math_emulate(struct math_emu_info *info)
+ {
+ u_char FPU_modrm, byte1;
+ unsigned short code;
+@@ -161,7 +161,7 @@ asmlinkage void math_emulate(long arg)
+ RE_ENTRANT_CHECK_ON;
+ #endif /* RE_ENTRANT_CHECKING */
+
+- SETUP_DATA_AREA(arg);
++ FPU_info = info;
+
+ FPU_ORIG_EIP = FPU_EIP;
+
+@@ -659,7 +659,7 @@ static int valid_prefix(u_char *Byte, u_char __user **fpu_eip,
+ }
+ }
+
+-void math_abort(struct info *info, unsigned int signal)
++void math_abort(struct math_emu_info *info, unsigned int signal)
+ {
+ FPU_EIP = FPU_ORIG_EIP;
+ current->thread.trap_no = 16;
+diff --git a/arch/x86/math-emu/fpu_proto.h b/arch/x86/math-emu/fpu_proto.h
+index aa49b6a..9779df4 100644
+--- a/arch/x86/math-emu/fpu_proto.h
++++ b/arch/x86/math-emu/fpu_proto.h
+@@ -51,8 +51,8 @@ extern void ffreep(void);
+ extern void fst_i_(void);
+ extern void fstp_i(void);
+ /* fpu_entry.c */
+-asmlinkage extern void math_emulate(long arg);
+-extern void math_abort(struct info *info, unsigned int signal);
++extern void math_emulate(struct math_emu_info *info);
++extern void math_abort(struct math_emu_info *info, unsigned int signal);
+ /* fpu_etc.c */
+ extern void FPU_etc(void);
+ /* fpu_tags.c */
+diff --git a/arch/x86/math-emu/fpu_system.h b/arch/x86/math-emu/fpu_system.h
+index 13488fa..50fa0ec 100644
+--- a/arch/x86/math-emu/fpu_system.h
++++ b/arch/x86/math-emu/fpu_system.h
+@@ -16,10 +16,6 @@
+ #include <linux/kernel.h>
+ #include <linux/mm.h>
+
+-/* This sets the pointer FPU_info to point to the argument part
+- of the stack frame of math_emulate() */
+-#define SETUP_DATA_AREA(arg) FPU_info = (struct info *) &arg
+-
+ /* s is always from a cpu register, and the cpu does bounds checking
+ * during register load --> no further bounds checks needed */
+ #define LDT_DESCRIPTOR(s) (((struct desc_struct *)current->mm->context.ldt)[(s) >> 3])
+@@ -38,12 +34,12 @@
+ #define I387 (current->thread.xstate)
+ #define FPU_info (I387->soft.info)
+
+-#define FPU_CS (*(unsigned short *) &(FPU_info->___cs))
+-#define FPU_SS (*(unsigned short *) &(FPU_info->___ss))
+-#define FPU_DS (*(unsigned short *) &(FPU_info->___ds))
+-#define FPU_EAX (FPU_info->___eax)
+-#define FPU_EFLAGS (FPU_info->___eflags)
+-#define FPU_EIP (FPU_info->___eip)
++#define FPU_CS (*(unsigned short *) &(FPU_info->regs->cs))
++#define FPU_SS (*(unsigned short *) &(FPU_info->regs->ss))
++#define FPU_DS (*(unsigned short *) &(FPU_info->regs->ds))
++#define FPU_EAX (FPU_info->regs->ax)
++#define FPU_EFLAGS (FPU_info->regs->flags)
++#define FPU_EIP (FPU_info->regs->ip)
+ #define FPU_ORIG_EIP (FPU_info->___orig_eip)
+
+ #define FPU_lookahead (I387->soft.lookahead)
+diff --git a/arch/x86/math-emu/get_address.c b/arch/x86/math-emu/get_address.c
+index d701e2b..420b3b6 100644
+--- a/arch/x86/math-emu/get_address.c
++++ b/arch/x86/math-emu/get_address.c
+@@ -29,46 +29,43 @@
+ #define FPU_WRITE_BIT 0x10
+
+ static int reg_offset[] = {
+- offsetof(struct info, ___eax),
+- offsetof(struct info, ___ecx),
+- offsetof(struct info, ___edx),
+- offsetof(struct info, ___ebx),
+- offsetof(struct info, ___esp),
+- offsetof(struct info, ___ebp),
+- offsetof(struct info, ___esi),
+- offsetof(struct info, ___edi)
++ offsetof(struct pt_regs, ax),
++ offsetof(struct pt_regs, cx),
++ offsetof(struct pt_regs, dx),
++ offsetof(struct pt_regs, bx),
++ offsetof(struct pt_regs, sp),
++ offsetof(struct pt_regs, bp),
++ offsetof(struct pt_regs, si),
++ offsetof(struct pt_regs, di)
+ };
+
+-#define REG_(x) (*(long *)(reg_offset[(x)]+(u_char *) FPU_info))
++#define REG_(x) (*(long *)(reg_offset[(x)] + (u_char *)FPU_info->regs))
+
+ static int reg_offset_vm86[] = {
+- offsetof(struct info, ___cs),
+- offsetof(struct info, ___vm86_ds),
+- offsetof(struct info, ___vm86_es),
+- offsetof(struct info, ___vm86_fs),
+- offsetof(struct info, ___vm86_gs),
+- offsetof(struct info, ___ss),
+- offsetof(struct info, ___vm86_ds)
++ offsetof(struct pt_regs, cs),
++ offsetof(struct kernel_vm86_regs, ds),
++ offsetof(struct kernel_vm86_regs, es),
++ offsetof(struct kernel_vm86_regs, fs),
++ offsetof(struct kernel_vm86_regs, gs),
++ offsetof(struct pt_regs, ss),
++ offsetof(struct kernel_vm86_regs, ds)
+ };
+
+ #define VM86_REG_(x) (*(unsigned short *) \
+- (reg_offset_vm86[((unsigned)x)]+(u_char *) FPU_info))
+-
+-/* This dummy, gs is not saved on the stack. */
+-#define ___GS ___ds
++ (reg_offset_vm86[((unsigned)x)] + (u_char *)FPU_info->regs))
+
+ static int reg_offset_pm[] = {
+- offsetof(struct info, ___cs),
+- offsetof(struct info, ___ds),
+- offsetof(struct info, ___es),
+- offsetof(struct info, ___fs),
+- offsetof(struct info, ___GS),
+- offsetof(struct info, ___ss),
+- offsetof(struct info, ___ds)
++ offsetof(struct pt_regs, cs),
++ offsetof(struct pt_regs, ds),
++ offsetof(struct pt_regs, es),
++ offsetof(struct pt_regs, fs),
++ offsetof(struct pt_regs, ds), /* dummy, not saved on stack */
++ offsetof(struct pt_regs, ss),
++ offsetof(struct pt_regs, ds)
+ };
+
+ #define PM_REG_(x) (*(unsigned short *) \
+- (reg_offset_pm[((unsigned)x)]+(u_char *) FPU_info))
++ (reg_offset_pm[((unsigned)x)] + (u_char *)FPU_info->regs))
+
+ /* Decode the SIB byte. This function assumes mod != 0 */
+ static int sib(int mod, unsigned long *fpu_eip)
+@@ -349,34 +346,34 @@ void __user *FPU_get_address_16(u_char FPU_modrm, unsigned long *fpu_eip,
+ }
+ switch (rm) {
+ case 0:
+- address += FPU_info->___ebx + FPU_info->___esi;
++ address += FPU_info->regs->bx + FPU_info->regs->si;
+ break;
+ case 1:
+- address += FPU_info->___ebx + FPU_info->___edi;
++ address += FPU_info->regs->bx + FPU_info->regs->di;
+ break;
+ case 2:
+- address += FPU_info->___ebp + FPU_info->___esi;
++ address += FPU_info->regs->bp + FPU_info->regs->si;
+ if (addr_modes.override.segment == PREFIX_DEFAULT)
+ addr_modes.override.segment = PREFIX_SS_;
+ break;
+ case 3:
+- address += FPU_info->___ebp + FPU_info->___edi;
++ address += FPU_info->regs->bp + FPU_info->regs->di;
+ if (addr_modes.override.segment == PREFIX_DEFAULT)
+ addr_modes.override.segment = PREFIX_SS_;
+ break;
+ case 4:
+- address += FPU_info->___esi;
++ address += FPU_info->regs->si;
+ break;
+ case 5:
+- address += FPU_info->___edi;
++ address += FPU_info->regs->di;
+ break;
+ case 6:
+- address += FPU_info->___ebp;
++ address += FPU_info->regs->bp;
+ if (addr_modes.override.segment == PREFIX_DEFAULT)
+ addr_modes.override.segment = PREFIX_SS_;
+ break;
+ case 7:
+- address += FPU_info->___ebx;
++ address += FPU_info->regs->bx;
+ break;
+ }
+
+diff --git a/arch/x86/mm/numa_64.c b/arch/x86/mm/numa_64.c
+index cebcbf1..eefd445 100644
+--- a/arch/x86/mm/numa_64.c
++++ b/arch/x86/mm/numa_64.c
+@@ -145,7 +145,7 @@ int __init compute_hash_shift(struct bootnode *nodes, int numnodes,
+ return shift;
+ }
+
+-int early_pfn_to_nid(unsigned long pfn)
++int __meminit __early_pfn_to_nid(unsigned long pfn)
+ {
+ return phys_to_nid(pfn << PAGE_SHIFT);
+ }
+diff --git a/arch/x86/oprofile/op_model_ppro.c b/arch/x86/oprofile/op_model_ppro.c
+index e9f80c7..10131fb 100644
+--- a/arch/x86/oprofile/op_model_ppro.c
++++ b/arch/x86/oprofile/op_model_ppro.c
+@@ -78,8 +78,18 @@ static void ppro_setup_ctrs(struct op_msrs const * const msrs)
+ if (cpu_has_arch_perfmon) {
+ union cpuid10_eax eax;
+ eax.full = cpuid_eax(0xa);
+- if (counter_width < eax.split.bit_width)
+- counter_width = eax.split.bit_width;
++
++ /*
++ * For Core2 (family 6, model 15), don't reset the
++ * counter width:
++ */
++ if (!(eax.split.version_id == 0 &&
++ current_cpu_data.x86 == 6 &&
++ current_cpu_data.x86_model == 15)) {
++
++ if (counter_width < eax.split.bit_width)
++ counter_width = eax.split.bit_width;
++ }
+ }
+
+ /* clear all counters */
+diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
+index 5e4686d..59439c4 100644
+--- a/arch/x86/xen/enlighten.c
++++ b/arch/x86/xen/enlighten.c
+@@ -1669,6 +1669,9 @@ asmlinkage void __init xen_start_kernel(void)
+ possible map and a non-dummy shared_info. */
+ per_cpu(xen_vcpu, 0) = &HYPERVISOR_shared_info->vcpu_info[0];
+
++ local_irq_disable();
++ early_boot_irqs_off();
++
+ xen_raw_console_write("mapping kernel into physical memory\n");
+ pgd = xen_setup_kernel_pagetable(pgd, xen_start_info->nr_pages);
+
+diff --git a/crypto/algapi.c b/crypto/algapi.c
+index 7c41e74..56c62e2 100644
+--- a/crypto/algapi.c
++++ b/crypto/algapi.c
+@@ -149,6 +149,9 @@ static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg)
+ if (q == alg)
+ goto err;
+
++ if (crypto_is_moribund(q))
++ continue;
++
+ if (crypto_is_larval(q)) {
+ if (!strcmp(alg->cra_driver_name, q->cra_driver_name))
+ goto err;
+@@ -197,7 +200,7 @@ void crypto_alg_tested(const char *name, int err)
+
+ down_write(&crypto_alg_sem);
+ list_for_each_entry(q, &crypto_alg_list, cra_list) {
+- if (!crypto_is_larval(q))
++ if (crypto_is_moribund(q) || !crypto_is_larval(q))
+ continue;
+
+ test = (struct crypto_larval *)q;
+@@ -210,6 +213,7 @@ void crypto_alg_tested(const char *name, int err)
+ goto unlock;
+
+ found:
++ q->cra_flags |= CRYPTO_ALG_DEAD;
+ alg = test->adult;
+ if (err || list_empty(&alg->cra_list))
+ goto complete;
+diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
+index 30f3ef2..4aa9477 100644
+--- a/drivers/acpi/ec.c
++++ b/drivers/acpi/ec.c
+@@ -759,9 +759,10 @@ acpi_ec_register_query_methods(acpi_handle handle, u32 level,
+ struct acpi_namespace_node *node = handle;
+ struct acpi_ec *ec = context;
+ int value = 0;
+- if (sscanf(node->name.ascii, "_Q%x", &value) == 1) {
++
++ if (sscanf(node->name.ascii, "_Q%2x", &value) == 1)
+ acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
+- }
++
+ return AE_OK;
+ }
+
+diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
+index bb7d50d..ad55db1 100644
+--- a/drivers/acpi/power.c
++++ b/drivers/acpi/power.c
+@@ -151,7 +151,7 @@ static int acpi_power_get_state(acpi_handle handle, int *state)
+ *state = (sta & 0x01)?ACPI_POWER_RESOURCE_STATE_ON:
+ ACPI_POWER_RESOURCE_STATE_OFF;
+
+- ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%s] is %s\n",
++ ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Resource [%4.4s] is %s\n",
+ acpi_ut_get_node_name(handle),
+ *state ? "on" : "off"));
+
+diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
+index bc6695e..b07b2ff 100644
+--- a/drivers/ata/libata-core.c
++++ b/drivers/ata/libata-core.c
+@@ -1251,14 +1251,16 @@ static u64 ata_id_n_sectors(const u16 *id)
+ {
+ if (ata_id_has_lba(id)) {
+ if (ata_id_has_lba48(id))
+- return ata_id_u64(id, 100);
++ return ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
+ else
+- return ata_id_u32(id, 60);
++ return ata_id_u32(id, ATA_ID_LBA_CAPACITY);
+ } else {
+ if (ata_id_current_chs_valid(id))
+- return ata_id_u32(id, 57);
++ return id[ATA_ID_CUR_CYLS] * id[ATA_ID_CUR_HEADS] *
++ id[ATA_ID_CUR_SECTORS];
+ else
+- return id[1] * id[3] * id[6];
++ return id[ATA_ID_CYLS] * id[ATA_ID_HEADS] *
++ id[ATA_ID_SECTORS];
+ }
+ }
+
+diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
+index 4de18d0..97a7dbc 100644
+--- a/drivers/ata/libata-eh.c
++++ b/drivers/ata/libata-eh.c
+@@ -2366,11 +2366,14 @@ int ata_eh_reset(struct ata_link *link, int classify,
+ }
+
+ /* prereset() might have cleared ATA_EH_RESET. If so,
+- * bang classes and return.
++ * bang classes, thaw and return.
+ */
+ if (reset && !(ehc->i.action & ATA_EH_RESET)) {
+ ata_link_for_each_dev(dev, link)
+ classes[dev->devno] = ATA_DEV_NONE;
++ if ((ap->pflags & ATA_PFLAG_FROZEN) &&
++ ata_is_host_link(link))
++ ata_eh_thaw_port(ap);
+ rc = 0;
+ goto out;
+ }
+diff --git a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c
+index 937c9c0..10f000d 100644
+--- a/drivers/atm/fore200e.c
++++ b/drivers/atm/fore200e.c
+@@ -2519,8 +2519,8 @@ fore200e_load_and_start_fw(struct fore200e* fore200e)
+ return err;
+
+ sprintf(buf, "%s%s", fore200e->bus->proc_name, FW_EXT);
+- if (request_firmware(&firmware, buf, device) == 1) {
+- printk(FORE200E "missing %s firmware image\n", fore200e->bus->model_name);
++ if ((err = request_firmware(&firmware, buf, device)) < 0) {
++ printk(FORE200E "problem loading firmware image %s\n", fore200e->bus->model_name);
+ return err;
+ }
+
+diff --git a/drivers/block/aoe/aoe.h b/drivers/block/aoe/aoe.h
+index 93f3690..8e54c1f 100644
+--- a/drivers/block/aoe/aoe.h
++++ b/drivers/block/aoe/aoe.h
+@@ -18,6 +18,7 @@
+ enum {
+ AOECMD_ATA,
+ AOECMD_CFG,
++ AOECMD_VEND_MIN = 0xf0,
+
+ AOEFL_RSP = (1<<3),
+ AOEFL_ERR = (1<<2),
+diff --git a/drivers/block/aoe/aoenet.c b/drivers/block/aoe/aoenet.c
+index 9157d64..b67629a 100644
+--- a/drivers/block/aoe/aoenet.c
++++ b/drivers/block/aoe/aoenet.c
+@@ -153,6 +153,8 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
+ aoecmd_cfg_rsp(skb);
+ break;
+ default:
++ if (h->cmd >= AOECMD_VEND_MIN)
++ break; /* don't complain about vendor commands */
+ printk(KERN_INFO "aoe: unknown cmd %d\n", h->cmd);
+ }
+ exit:
+diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
+index 2d19f0c..676278e 100644
+--- a/drivers/block/xen-blkfront.c
++++ b/drivers/block/xen-blkfront.c
+@@ -40,6 +40,7 @@
+ #include <linux/hdreg.h>
+ #include <linux/cdrom.h>
+ #include <linux/module.h>
++#include <linux/scatterlist.h>
+
+ #include <xen/xenbus.h>
+ #include <xen/grant_table.h>
+@@ -82,6 +83,7 @@ struct blkfront_info
+ enum blkif_state connected;
+ int ring_ref;
+ struct blkif_front_ring ring;
++ struct scatterlist sg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
+ unsigned int evtchn, irq;
+ struct request_queue *rq;
+ struct work_struct work;
+@@ -204,12 +206,11 @@ static int blkif_queue_request(struct request *req)
+ struct blkfront_info *info = req->rq_disk->private_data;
+ unsigned long buffer_mfn;
+ struct blkif_request *ring_req;
+- struct req_iterator iter;
+- struct bio_vec *bvec;
+ unsigned long id;
+ unsigned int fsect, lsect;
+- int ref;
++ int i, ref;
+ grant_ref_t gref_head;
++ struct scatterlist *sg;
+
+ if (unlikely(info->connected != BLKIF_STATE_CONNECTED))
+ return 1;
+@@ -238,12 +239,13 @@ static int blkif_queue_request(struct request *req)
+ if (blk_barrier_rq(req))
+ ring_req->operation = BLKIF_OP_WRITE_BARRIER;
+
+- ring_req->nr_segments = 0;
+- rq_for_each_segment(bvec, req, iter) {
+- BUG_ON(ring_req->nr_segments == BLKIF_MAX_SEGMENTS_PER_REQUEST);
+- buffer_mfn = pfn_to_mfn(page_to_pfn(bvec->bv_page));
+- fsect = bvec->bv_offset >> 9;
+- lsect = fsect + (bvec->bv_len >> 9) - 1;
++ ring_req->nr_segments = blk_rq_map_sg(req->q, req, info->sg);
++ BUG_ON(ring_req->nr_segments > BLKIF_MAX_SEGMENTS_PER_REQUEST);
++
++ for_each_sg(info->sg, sg, ring_req->nr_segments, i) {
++ buffer_mfn = pfn_to_mfn(page_to_pfn(sg_page(sg)));
++ fsect = sg->offset >> 9;
++ lsect = fsect + (sg->length >> 9) - 1;
+ /* install a grant reference. */
+ ref = gnttab_claim_grant_reference(&gref_head);
+ BUG_ON(ref == -ENOSPC);
+@@ -254,16 +256,12 @@ static int blkif_queue_request(struct request *req)
+ buffer_mfn,
+ rq_data_dir(req) );
+
+- info->shadow[id].frame[ring_req->nr_segments] =
+- mfn_to_pfn(buffer_mfn);
+-
+- ring_req->seg[ring_req->nr_segments] =
++ info->shadow[id].frame[i] = mfn_to_pfn(buffer_mfn);
++ ring_req->seg[i] =
+ (struct blkif_request_segment) {
+ .gref = ref,
+ .first_sect = fsect,
+ .last_sect = lsect };
+-
+- ring_req->nr_segments++;
+ }
+
+ info->ring.req_prod_pvt++;
+@@ -628,6 +626,8 @@ static int setup_blkring(struct xenbus_device *dev,
+ SHARED_RING_INIT(sring);
+ FRONT_RING_INIT(&info->ring, sring, PAGE_SIZE);
+
++ sg_init_table(info->sg, BLKIF_MAX_SEGMENTS_PER_REQUEST);
++
+ err = xenbus_grant_ring(dev, virt_to_mfn(info->ring.sring));
+ if (err < 0) {
+ free_page((unsigned long)sring);
+diff --git a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c
+index c771418..4373adb 100644
+--- a/drivers/char/agp/intel-agp.c
++++ b/drivers/char/agp/intel-agp.c
+@@ -633,13 +633,15 @@ static void intel_i830_init_gtt_entries(void)
+ break;
+ }
+ }
+- if (gtt_entries > 0)
++ if (gtt_entries > 0) {
+ dev_info(&agp_bridge->dev->dev, "detected %dK %s memory\n",
+ gtt_entries / KB(1), local ? "local" : "stolen");
+- else
++ gtt_entries /= KB(4);
++ } else {
+ dev_info(&agp_bridge->dev->dev,
+ "no pre-allocated video memory detected\n");
+- gtt_entries /= KB(4);
++ gtt_entries = 0;
++ }
+
+ intel_private.gtt_entries = gtt_entries;
+ }
+diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
+index 40df3e1..fab7ca2 100644
+--- a/drivers/hid/hid-core.c
++++ b/drivers/hid/hid-core.c
+@@ -1302,6 +1302,12 @@ static const struct hid_device_id hid_blacklist[] = {
+ { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
++ { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
++ { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
++ { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
++ { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
++ { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
++ { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
+
+ { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c) },
+ { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT) },
+@@ -1529,10 +1535,6 @@ static const struct hid_device_id hid_ignore_list[] = {
+ { HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD3) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY1) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY2) },
+- { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
+- { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
+- { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
+- { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
+@@ -1543,8 +1545,6 @@ static const struct hid_device_id hid_ignore_list[] = {
+ { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_1_PHIDGETSERVO_20) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_WISEGROUP, USB_DEVICE_ID_8_8_4_IF_KIT) },
+ { HID_USB_DEVICE(USB_VENDOR_ID_YEALINK, USB_DEVICE_ID_YEALINK_P1K_P4K_B2K) },
+- { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
+- { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
+ { }
+ };
+
+diff --git a/drivers/hwmon/f71882fg.c b/drivers/hwmon/f71882fg.c
+index 67067e9..71556e6 100644
+--- a/drivers/hwmon/f71882fg.c
++++ b/drivers/hwmon/f71882fg.c
+@@ -837,7 +837,7 @@ static int __init f71882fg_find(int sioaddr, unsigned short *address)
+
+ devid = superio_inw(sioaddr, SIO_REG_MANID);
+ if (devid != SIO_FINTEK_ID) {
+- printk(KERN_INFO DRVNAME ": Not a Fintek device\n");
++ pr_debug(DRVNAME ": Not a Fintek device\n");
+ goto exit;
+ }
+
+diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
+index b74c957..7601cc2 100644
+--- a/drivers/hwmon/it87.c
++++ b/drivers/hwmon/it87.c
+@@ -207,7 +207,7 @@ static inline u16 FAN16_TO_REG(long rpm)
+
+ #define TEMP_TO_REG(val) (SENSORS_LIMIT(((val)<0?(((val)-500)/1000):\
+ ((val)+500)/1000),-128,127))
+-#define TEMP_FROM_REG(val) (((val)>0x80?(val)-0x100:(val))*1000)
++#define TEMP_FROM_REG(val) ((val) * 1000)
+
+ #define PWM_TO_REG(val) ((val) >> 1)
+ #define PWM_FROM_REG(val) (((val)&0x7f) << 1)
+@@ -261,9 +261,9 @@ struct it87_data {
+ u8 has_fan; /* Bitfield, fans enabled */
+ u16 fan[5]; /* Register values, possibly combined */
+ u16 fan_min[5]; /* Register values, possibly combined */
+- u8 temp[3]; /* Register value */
+- u8 temp_high[3]; /* Register value */
+- u8 temp_low[3]; /* Register value */
++ s8 temp[3]; /* Register value */
++ s8 temp_high[3]; /* Register value */
++ s8 temp_low[3]; /* Register value */
+ u8 sensor; /* Register value */
+ u8 fan_div[3]; /* Register encoding, shifted right */
+ u8 vid; /* Register encoding, combined */
+diff --git a/drivers/i2c/busses/i2c-acorn.c b/drivers/i2c/busses/i2c-acorn.c
+index 75089fe..c9a8d6f 100644
+--- a/drivers/i2c/busses/i2c-acorn.c
++++ b/drivers/i2c/busses/i2c-acorn.c
+@@ -84,6 +84,7 @@ static struct i2c_algo_bit_data ioc_data = {
+
+ static struct i2c_adapter ioc_ops = {
+ .id = I2C_HW_B_IOC,
++ .nr = 0,
+ .algo_data = &ioc_data,
+ };
+
+@@ -91,7 +92,7 @@ static int __init i2c_ioc_init(void)
+ {
+ force_ones = FORCE_ONES | SCL | SDA;
+
+- return i2c_bit_add_bus(&ioc_ops);
++ return i2c_bit_add_numbered_bus(&ioc_ops);
+ }
+
+ module_init(i2c_ioc_init);
+diff --git a/drivers/i2c/busses/i2c-amd8111.c b/drivers/i2c/busses/i2c-amd8111.c
+index 3972208..c688237 100644
+--- a/drivers/i2c/busses/i2c-amd8111.c
++++ b/drivers/i2c/busses/i2c-amd8111.c
+@@ -72,7 +72,7 @@ static unsigned int amd_ec_wait_write(struct amd_smbus *smbus)
+ {
+ int timeout = 500;
+
+- while (timeout-- && (inb(smbus->base + AMD_EC_SC) & AMD_EC_SC_IBF))
++ while ((inb(smbus->base + AMD_EC_SC) & AMD_EC_SC_IBF) && --timeout)
+ udelay(1);
+
+ if (!timeout) {
+@@ -88,7 +88,7 @@ static unsigned int amd_ec_wait_read(struct amd_smbus *smbus)
+ {
+ int timeout = 500;
+
+- while (timeout-- && (~inb(smbus->base + AMD_EC_SC) & AMD_EC_SC_OBF))
++ while ((~inb(smbus->base + AMD_EC_SC) & AMD_EC_SC_OBF) && --timeout)
+ udelay(1);
+
+ if (!timeout) {
+diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
+index 906f9b9..7f80d51 100644
+--- a/drivers/i2c/busses/i2c-pxa.c
++++ b/drivers/i2c/busses/i2c-pxa.c
+@@ -644,7 +644,7 @@ static int i2c_pxa_do_pio_xfer(struct pxa_i2c *i2c,
+
+ i2c_pxa_start_message(i2c);
+
+- while (timeout-- && i2c->msg_num > 0) {
++ while (i2c->msg_num > 0 && --timeout) {
+ i2c_pxa_handler(0, i2c);
+ udelay(10);
+ }
+diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
+index c6a63f4..feb00df 100644
+--- a/drivers/i2c/i2c-core.c
++++ b/drivers/i2c/i2c-core.c
+@@ -1831,7 +1831,8 @@ static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
+ case I2C_SMBUS_QUICK:
+ msg[0].len = 0;
+ /* Special case: The read/write field is used as data */
+- msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
++ msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
++ I2C_M_RD : 0);
+ num = 1;
+ break;
+ case I2C_SMBUS_BYTE:
+diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
+index c41c3b9..e60fc63 100644
+--- a/drivers/ide/ide-iops.c
++++ b/drivers/ide/ide-iops.c
+@@ -324,6 +324,8 @@ void ide_output_data(ide_drive_t *drive, struct request *rq, void *buf,
+ u8 io_32bit = drive->io_32bit;
+ u8 mmio = (hwif->host_flags & IDE_HFLAG_MMIO) ? 1 : 0;
+
++ len++;
++
+ if (io_32bit) {
+ unsigned long uninitialized_var(flags);
+
+diff --git a/drivers/infiniband/hw/nes/nes_cm.c b/drivers/infiniband/hw/nes/nes_cm.c
+index 2caf9da..7890be3 100644
+--- a/drivers/infiniband/hw/nes/nes_cm.c
++++ b/drivers/infiniband/hw/nes/nes_cm.c
+@@ -2495,12 +2495,14 @@ static int nes_disconnect(struct nes_qp *nesqp, int abrupt)
+ int ret = 0;
+ struct nes_vnic *nesvnic;
+ struct nes_device *nesdev;
++ struct nes_ib_device *nesibdev;
+
+ nesvnic = to_nesvnic(nesqp->ibqp.device);
+ if (!nesvnic)
+ return -EINVAL;
+
+ nesdev = nesvnic->nesdev;
++ nesibdev = nesvnic->nesibdev;
+
+ nes_debug(NES_DBG_CM, "netdev refcnt = %u.\n",
+ atomic_read(&nesvnic->netdev->refcnt));
+@@ -2512,6 +2514,8 @@ static int nes_disconnect(struct nes_qp *nesqp, int abrupt)
+ } else {
+ /* Need to free the Last Streaming Mode Message */
+ if (nesqp->ietf_frame) {
++ if (nesqp->lsmm_mr)
++ nesibdev->ibdev.dereg_mr(nesqp->lsmm_mr);
+ pci_free_consistent(nesdev->pcidev,
+ nesqp->private_data_len+sizeof(struct ietf_mpa_frame),
+ nesqp->ietf_frame, nesqp->ietf_frame_pbase);
+@@ -2545,6 +2549,10 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
+ struct iw_cm_event cm_event;
+ struct nes_hw_qp_wqe *wqe;
+ struct nes_v4_quad nes_quad;
++ struct nes_ib_device *nesibdev;
++ struct ib_mr *ibmr = NULL;
++ struct ib_phys_buf ibphysbuf;
++ struct nes_pd *nespd;
+ u32 crc_value;
+ int ret;
+
+@@ -2605,6 +2613,26 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
+ if (cm_id->remote_addr.sin_addr.s_addr !=
+ cm_id->local_addr.sin_addr.s_addr) {
+ u64temp = (unsigned long)nesqp;
++ nesibdev = nesvnic->nesibdev;
++ nespd = nesqp->nespd;
++ ibphysbuf.addr = nesqp->ietf_frame_pbase;
++ ibphysbuf.size = conn_param->private_data_len +
++ sizeof(struct ietf_mpa_frame);
++ ibmr = nesibdev->ibdev.reg_phys_mr((struct ib_pd *)nespd,
++ &ibphysbuf, 1,
++ IB_ACCESS_LOCAL_WRITE,
++ (u64 *)&nesqp->ietf_frame);
++ if (!ibmr) {
++ nes_debug(NES_DBG_CM, "Unable to register memory region"
++ "for lSMM for cm_node = %p \n",
++ cm_node);
++ return -ENOMEM;
++ }
++
++ ibmr->pd = &nespd->ibpd;
++ ibmr->device = nespd->ibpd.device;
++ nesqp->lsmm_mr = ibmr;
++
+ u64temp |= NES_SW_CONTEXT_ALIGN>>1;
+ set_wqe_64bit_value(wqe->wqe_words,
+ NES_IWARP_SQ_WQE_COMP_CTX_LOW_IDX,
+@@ -2615,14 +2643,13 @@ int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
+ wqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX] =
+ cpu_to_le32(conn_param->private_data_len +
+ sizeof(struct ietf_mpa_frame));
+- wqe->wqe_words[NES_IWARP_SQ_WQE_FRAG0_LOW_IDX] =
+- cpu_to_le32((u32)nesqp->ietf_frame_pbase);
+- wqe->wqe_words[NES_IWARP_SQ_WQE_FRAG0_HIGH_IDX] =
+- cpu_to_le32((u32)((u64)nesqp->ietf_frame_pbase >> 32));
++ set_wqe_64bit_value(wqe->wqe_words,
++ NES_IWARP_SQ_WQE_FRAG0_LOW_IDX,
++ (u64)nesqp->ietf_frame);
+ wqe->wqe_words[NES_IWARP_SQ_WQE_LENGTH0_IDX] =
+ cpu_to_le32(conn_param->private_data_len +
+ sizeof(struct ietf_mpa_frame));
+- wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = 0;
++ wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = ibmr->lkey;
+
+ nesqp->nesqp_context->ird_ord_sizes |=
+ cpu_to_le32(NES_QPCONTEXT_ORDIRD_LSMM_PRESENT |
+diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
+index d36c9a0..e0f658d 100644
+--- a/drivers/infiniband/hw/nes/nes_verbs.c
++++ b/drivers/infiniband/hw/nes/nes_verbs.c
+@@ -1360,8 +1360,10 @@ static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
+ NES_QPCONTEXT_MISC_RQ_SIZE_SHIFT);
+ nesqp->nesqp_context->misc |= cpu_to_le32((u32)nesqp->hwqp.sq_encoded_size <<
+ NES_QPCONTEXT_MISC_SQ_SIZE_SHIFT);
++ if (!udata) {
+ nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_PRIV_EN);
+ nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_FAST_REGISTER_EN);
++ }
+ nesqp->nesqp_context->cqs = cpu_to_le32(nesqp->nesscq->hw_cq.cq_number +
+ ((u32)nesqp->nesrcq->hw_cq.cq_number << 16));
+ u64temp = (u64)nesqp->hwqp.sq_pbase;
+diff --git a/drivers/infiniband/hw/nes/nes_verbs.h b/drivers/infiniband/hw/nes/nes_verbs.h
+index 6c6b4da..ae0ca9b 100644
+--- a/drivers/infiniband/hw/nes/nes_verbs.h
++++ b/drivers/infiniband/hw/nes/nes_verbs.h
+@@ -134,6 +134,7 @@ struct nes_qp {
+ struct ietf_mpa_frame *ietf_frame;
+ dma_addr_t ietf_frame_pbase;
+ wait_queue_head_t state_waitq;
++ struct ib_mr *lsmm_mr;
+ unsigned long socket;
+ struct nes_hw_qp hwqp;
+ struct work_struct work;
+diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
+index 9c788e2..4101bf0 100644
+--- a/drivers/md/raid1.c
++++ b/drivers/md/raid1.c
+@@ -1233,8 +1233,9 @@ static void end_sync_write(struct bio *bio, int error)
+ update_head_pos(mirror, r1_bio);
+
+ if (atomic_dec_and_test(&r1_bio->remaining)) {
+- md_done_sync(mddev, r1_bio->sectors, uptodate);
++ sector_t s = r1_bio->sectors;
+ put_buf(r1_bio);
++ md_done_sync(mddev, s, uptodate);
+ }
+ }
+
+diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
+index 970a96e..b2fde77 100644
+--- a/drivers/md/raid10.c
++++ b/drivers/md/raid10.c
+@@ -1236,6 +1236,7 @@ static void end_sync_read(struct bio *bio, int error)
+ /* for reconstruct, we always reschedule after a read.
+ * for resync, only after all reads
+ */
++ rdev_dec_pending(conf->mirrors[d].rdev, conf->mddev);
+ if (test_bit(R10BIO_IsRecover, &r10_bio->state) ||
+ atomic_dec_and_test(&r10_bio->remaining)) {
+ /* we have read all the blocks,
+@@ -1243,7 +1244,6 @@ static void end_sync_read(struct bio *bio, int error)
+ */
+ reschedule_retry(r10_bio);
+ }
+- rdev_dec_pending(conf->mirrors[d].rdev, conf->mddev);
+ }
+
+ static void end_sync_write(struct bio *bio, int error)
+@@ -1264,11 +1264,13 @@ static void end_sync_write(struct bio *bio, int error)
+
+ update_head_pos(i, r10_bio);
+
++ rdev_dec_pending(conf->mirrors[d].rdev, mddev);
+ while (atomic_dec_and_test(&r10_bio->remaining)) {
+ if (r10_bio->master_bio == NULL) {
+ /* the primary of several recovery bios */
+- md_done_sync(mddev, r10_bio->sectors, 1);
++ sector_t s = r10_bio->sectors;
+ put_buf(r10_bio);
++ md_done_sync(mddev, s, 1);
+ break;
+ } else {
+ r10bio_t *r10_bio2 = (r10bio_t *)r10_bio->master_bio;
+@@ -1276,7 +1278,6 @@ static void end_sync_write(struct bio *bio, int error)
+ r10_bio = r10_bio2;
+ }
+ }
+- rdev_dec_pending(conf->mirrors[d].rdev, mddev);
+ }
+
+ /*
+@@ -1749,8 +1750,6 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
+ if (!go_faster && conf->nr_waiting)
+ msleep_interruptible(1000);
+
+- bitmap_cond_end_sync(mddev->bitmap, sector_nr);
+-
+ /* Again, very different code for resync and recovery.
+ * Both must result in an r10bio with a list of bios that
+ * have bi_end_io, bi_sector, bi_bdev set,
+@@ -1886,6 +1885,8 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
+ /* resync. Schedule a read for every block at this virt offset */
+ int count = 0;
+
++ bitmap_cond_end_sync(mddev->bitmap, sector_nr);
++
+ if (!bitmap_start_sync(mddev->bitmap, sector_nr,
+ &sync_blocks, mddev->degraded) &&
+ !conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
+@@ -2010,13 +2011,13 @@ static sector_t sync_request(mddev_t *mddev, sector_t sector_nr, int *skipped, i
+ /* There is nowhere to write, so all non-sync
+ * drives must be failed, so try the next chunk...
+ */
+- {
+- sector_t sec = max_sector - sector_nr;
+- sectors_skipped += sec;
++ if (sector_nr + max_sync < max_sector)
++ max_sector = sector_nr + max_sync;
++
++ sectors_skipped += (max_sector - sector_nr);
+ chunks_skipped ++;
+ sector_nr = max_sector;
+ goto skipped;
+- }
+ }
+
+ static int run(mddev_t *mddev)
+diff --git a/drivers/media/common/tuners/tda8290.c b/drivers/media/common/tuners/tda8290.c
+index c112bdd..edfd41f 100644
+--- a/drivers/media/common/tuners/tda8290.c
++++ b/drivers/media/common/tuners/tda8290.c
+@@ -724,7 +724,8 @@ struct dvb_frontend *tda829x_attach(struct dvb_frontend *fe,
+ fe->ops.analog_ops.info.name = name;
+
+ if (priv->ver & TDA8290) {
+- tda8290_init_tuner(fe);
++ if (priv->ver & (TDA8275 | TDA8275A))
++ tda8290_init_tuner(fe);
+ tda8290_init_if(fe);
+ } else if (priv->ver & TDA8295)
+ tda8295_init_if(fe);
+diff --git a/drivers/media/dvb/frontends/s5h1409.c b/drivers/media/dvb/frontends/s5h1409.c
+index cf4d893..3e08d98 100644
+--- a/drivers/media/dvb/frontends/s5h1409.c
++++ b/drivers/media/dvb/frontends/s5h1409.c
+@@ -545,9 +545,6 @@ static int s5h1409_set_frontend(struct dvb_frontend *fe,
+
+ s5h1409_enable_modulation(fe, p->u.vsb.modulation);
+
+- /* Allow the demod to settle */
+- msleep(100);
+-
+ if (fe->ops.tuner_ops.set_params) {
+ if (fe->ops.i2c_gate_ctrl)
+ fe->ops.i2c_gate_ctrl(fe, 1);
+@@ -562,6 +559,10 @@ static int s5h1409_set_frontend(struct dvb_frontend *fe,
+ s5h1409_set_qam_interleave_mode(fe);
+ }
+
++ /* Issue a reset to the demod so it knows to resync against the
++ newly tuned frequency */
++ s5h1409_softreset(fe);
++
+ return 0;
+ }
+
+diff --git a/drivers/media/video/ivtv/ivtv-ioctl.c b/drivers/media/video/ivtv/ivtv-ioctl.c
+index 4bae38d..999f037 100644
+--- a/drivers/media/video/ivtv/ivtv-ioctl.c
++++ b/drivers/media/video/ivtv/ivtv-ioctl.c
+@@ -1750,6 +1750,18 @@ static int ivtv_default(struct file *file, void *fh, int cmd, void *arg)
+ break;
+ }
+
++ case IVTV_IOC_DMA_FRAME:
++ case VIDEO_GET_PTS:
++ case VIDEO_GET_FRAME_COUNT:
++ case VIDEO_GET_EVENT:
++ case VIDEO_PLAY:
++ case VIDEO_STOP:
++ case VIDEO_FREEZE:
++ case VIDEO_CONTINUE:
++ case VIDEO_COMMAND:
++ case VIDEO_TRY_COMMAND:
++ return ivtv_decoder_ioctls(file, cmd, (void *)arg);
++
+ default:
+ return -EINVAL;
+ }
+@@ -1792,18 +1804,6 @@ static long ivtv_serialized_ioctl(struct ivtv *itv, struct file *filp,
+ ivtv_vapi(itv, CX2341X_DEC_SET_AUDIO_MODE, 2, itv->audio_bilingual_mode, itv->audio_stereo_mode);
+ return 0;
+
+- case IVTV_IOC_DMA_FRAME:
+- case VIDEO_GET_PTS:
+- case VIDEO_GET_FRAME_COUNT:
+- case VIDEO_GET_EVENT:
+- case VIDEO_PLAY:
+- case VIDEO_STOP:
+- case VIDEO_FREEZE:
+- case VIDEO_CONTINUE:
+- case VIDEO_COMMAND:
+- case VIDEO_TRY_COMMAND:
+- return ivtv_decoder_ioctls(filp, cmd, (void *)arg);
+-
+ default:
+ break;
+ }
+diff --git a/drivers/media/video/saa7127.c b/drivers/media/video/saa7127.c
+index cc02fb1..8e7976a 100644
+--- a/drivers/media/video/saa7127.c
++++ b/drivers/media/video/saa7127.c
+@@ -149,7 +149,7 @@ static const struct i2c_reg_value saa7127_init_config_common[] = {
+ { SAA7127_REG_COPYGEN_0, 0x77 },
+ { SAA7127_REG_COPYGEN_1, 0x41 },
+ { SAA7127_REG_COPYGEN_2, 0x00 }, /* Macrovision enable/disable */
+- { SAA7127_REG_OUTPUT_PORT_CONTROL, 0x9e },
++ { SAA7127_REG_OUTPUT_PORT_CONTROL, 0xbf },
+ { SAA7127_REG_GAIN_LUMINANCE_RGB, 0x00 },
+ { SAA7127_REG_GAIN_COLORDIFF_RGB, 0x00 },
+ { SAA7127_REG_INPUT_PORT_CONTROL_1, 0x80 }, /* for color bars */
+@@ -479,12 +479,18 @@ static int saa7127_set_output_type(struct i2c_client *client, int output)
+ break;
+
+ case SAA7127_OUTPUT_TYPE_COMPOSITE:
+- state->reg_2d = 0x08; /* 00001000 CVBS only, RGB DAC's off (high impedance mode) */
++ if (state->ident == V4L2_IDENT_SAA7129)
++ state->reg_2d = 0x20; /* CVBS only */
++ else
++ state->reg_2d = 0x08; /* 00001000 CVBS only, RGB DAC's off (high impedance mode) */
+ state->reg_3a = 0x13; /* by default switch YUV to RGB-matrix on */
+ break;
+
+ case SAA7127_OUTPUT_TYPE_SVIDEO:
+- state->reg_2d = 0xff; /* 11111111 croma -> R, luma -> CVBS + G + B */
++ if (state->ident == V4L2_IDENT_SAA7129)
++ state->reg_2d = 0x18; /* Y + C */
++ else
++ state->reg_2d = 0xff; /*11111111 croma -> R, luma -> CVBS + G + B */
+ state->reg_3a = 0x13; /* by default switch YUV to RGB-matrix on */
+ break;
+
+@@ -499,7 +505,10 @@ static int saa7127_set_output_type(struct i2c_client *client, int output)
+ break;
+
+ case SAA7127_OUTPUT_TYPE_BOTH:
+- state->reg_2d = 0xbf;
++ if (state->ident == V4L2_IDENT_SAA7129)
++ state->reg_2d = 0x38;
++ else
++ state->reg_2d = 0xbf;
+ state->reg_3a = 0x13; /* by default switch YUV to RGB-matrix on */
+ break;
+
+@@ -691,24 +700,6 @@ static int saa7127_probe(struct i2c_client *client,
+
+ i2c_set_clientdata(client, state);
+
+- /* Configure Encoder */
+-
+- v4l_dbg(1, debug, client, "Configuring encoder\n");
+- saa7127_write_inittab(client, saa7127_init_config_common);
+- saa7127_set_std(client, V4L2_STD_NTSC);
+- saa7127_set_output_type(client, SAA7127_OUTPUT_TYPE_BOTH);
+- saa7127_set_vps(client, &vbi);
+- saa7127_set_wss(client, &vbi);
+- saa7127_set_cc(client, &vbi);
+- saa7127_set_xds(client, &vbi);
+- if (test_image == 1)
+- /* The Encoder has an internal Colorbar generator */
+- /* This can be used for debugging */
+- saa7127_set_input_type(client, SAA7127_INPUT_TYPE_TEST_IMAGE);
+- else
+- saa7127_set_input_type(client, SAA7127_INPUT_TYPE_NORMAL);
+- saa7127_set_video_enable(client, 1);
+-
+ if (id->driver_data) { /* Chip type is already known */
+ state->ident = id->driver_data;
+ } else { /* Needs detection */
+@@ -730,6 +721,23 @@ static int saa7127_probe(struct i2c_client *client,
+
+ v4l_info(client, "%s found @ 0x%x (%s)\n", client->name,
+ client->addr << 1, client->adapter->name);
++
++ v4l_dbg(1, debug, client, "Configuring encoder\n");
++ saa7127_write_inittab(client, saa7127_init_config_common);
++ saa7127_set_std(client, V4L2_STD_NTSC);
++ saa7127_set_output_type(client, SAA7127_OUTPUT_TYPE_BOTH);
++ saa7127_set_vps(client, &vbi);
++ saa7127_set_wss(client, &vbi);
++ saa7127_set_cc(client, &vbi);
++ saa7127_set_xds(client, &vbi);
++ if (test_image == 1)
++ /* The Encoder has an internal Colorbar generator */
++ /* This can be used for debugging */
++ saa7127_set_input_type(client, SAA7127_INPUT_TYPE_TEST_IMAGE);
++ else
++ saa7127_set_input_type(client, SAA7127_INPUT_TYPE_NORMAL);
++ saa7127_set_video_enable(client, 1);
++
+ if (state->ident == V4L2_IDENT_SAA7129)
+ saa7127_write_inittab(client, saa7129_init_config_extra);
+ return 0;
+diff --git a/drivers/misc/acer-wmi.c b/drivers/misc/acer-wmi.c
+index 94c9f91..6bcca61 100644
+--- a/drivers/misc/acer-wmi.c
++++ b/drivers/misc/acer-wmi.c
+@@ -1297,7 +1297,7 @@ static int __init acer_wmi_init(void)
+
+ set_quirks();
+
+- if (!acpi_video_backlight_support() && has_cap(ACER_CAP_BRIGHTNESS)) {
++ if (acpi_video_backlight_support() && has_cap(ACER_CAP_BRIGHTNESS)) {
+ interface->capability &= ~ACER_CAP_BRIGHTNESS;
+ printk(ACER_INFO "Brightness must be controlled by "
+ "generic video driver\n");
+diff --git a/drivers/misc/hpilo.c b/drivers/misc/hpilo.c
+index 05e2982..174a35f 100644
+--- a/drivers/misc/hpilo.c
++++ b/drivers/misc/hpilo.c
+@@ -710,6 +710,7 @@ out:
+
+ static struct pci_device_id ilo_devices[] = {
+ { PCI_DEVICE(PCI_VENDOR_ID_COMPAQ, 0xB204) },
++ { PCI_DEVICE(PCI_VENDOR_ID_HP, 0x3307) },
+ { }
+ };
+ MODULE_DEVICE_TABLE(pci, ilo_devices);
+diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
+index 3d067c3..db7e4c4 100644
+--- a/drivers/mmc/card/block.c
++++ b/drivers/mmc/card/block.c
+@@ -514,7 +514,7 @@ static int mmc_blk_probe(struct mmc_card *card)
+ if (err)
+ goto out;
+
+- string_get_size(get_capacity(md->disk) << 9, STRING_UNITS_2,
++ string_get_size((u64)get_capacity(md->disk) << 9, STRING_UNITS_2,
+ cap_str, sizeof(cap_str));
+ printk(KERN_INFO "%s: %s %s %s %s\n",
+ md->disk->disk_name, mmc_card_id(card), mmc_card_name(card),
+diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c
+index b92b172..b9f1e84 100644
+--- a/drivers/mmc/card/mmc_test.c
++++ b/drivers/mmc/card/mmc_test.c
+@@ -494,7 +494,7 @@ static int mmc_test_basic_read(struct mmc_test_card *test)
+
+ sg_init_one(&sg, test->buffer, 512);
+
+- ret = mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 1);
++ ret = mmc_test_simple_transfer(test, &sg, 1, 0, 1, 512, 0);
+ if (ret)
+ return ret;
+
+diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c
+index 9c50e6f..34ce270 100644
+--- a/drivers/mmc/core/mmc_ops.c
++++ b/drivers/mmc/core/mmc_ops.c
+@@ -248,12 +248,15 @@ mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
+
+ sg_init_one(&sg, data_buf, len);
+
+- /*
+- * The spec states that CSR and CID accesses have a timeout
+- * of 64 clock cycles.
+- */
+- data.timeout_ns = 0;
+- data.timeout_clks = 64;
++ if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
++ /*
++ * The spec states that CSR and CID accesses have a timeout
++ * of 64 clock cycles.
++ */
++ data.timeout_ns = 0;
++ data.timeout_clks = 64;
++ } else
++ mmc_set_data_timeout(&data, card);
+
+ mmc_wait_for_req(host, &mrq);
+
+diff --git a/drivers/mmc/host/s3cmci.c b/drivers/mmc/host/s3cmci.c
+index 3b2085b..c6e5539 100644
+--- a/drivers/mmc/host/s3cmci.c
++++ b/drivers/mmc/host/s3cmci.c
+@@ -329,7 +329,7 @@ static void do_pio_write(struct s3cmci_host *host)
+
+ to_ptr = host->base + host->sdidata;
+
+- while ((fifo = fifo_free(host))) {
++ while ((fifo = fifo_free(host)) > 3) {
+ if (!host->pio_bytes) {
+ res = get_data_buffer(host, &host->pio_bytes,
+ &host->pio_ptr);
+@@ -793,8 +793,7 @@ static void s3cmci_dma_setup(struct s3cmci_host *host,
+ host->mem->start + host->sdidata);
+
+ if (!setup_ok) {
+- s3c2410_dma_config(host->dma, 4,
+- (S3C2410_DCON_HWTRIG | S3C2410_DCON_CH0_SDI));
++ s3c2410_dma_config(host->dma, 4, 0);
+ s3c2410_dma_set_buffdone_fn(host->dma,
+ s3cmci_dma_done_callback);
+ s3c2410_dma_setflags(host->dma, S3C2410_DMAF_AUTOSTART);
+diff --git a/drivers/mmc/host/sdhci-pci.c b/drivers/mmc/host/sdhci-pci.c
+index 9bd7026..51e89e0 100644
+--- a/drivers/mmc/host/sdhci-pci.c
++++ b/drivers/mmc/host/sdhci-pci.c
+@@ -107,6 +107,7 @@ static const struct sdhci_pci_fixes sdhci_ene_714 = {
+
+ static const struct sdhci_pci_fixes sdhci_cafe = {
+ .quirks = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER |
++ SDHCI_QUIRK_NO_BUSY_IRQ |
+ SDHCI_QUIRK_BROKEN_TIMEOUT_VAL,
+ };
+
+diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
+index 4d010a9..b4f6b3c 100644
+--- a/drivers/mmc/host/sdhci.c
++++ b/drivers/mmc/host/sdhci.c
+@@ -1286,8 +1286,11 @@ static void sdhci_cmd_irq(struct sdhci_host *host, u32 intmask)
+ if (host->cmd->data)
+ DBG("Cannot wait for busy signal when also "
+ "doing a data transfer");
+- else
++ else if (!(host->quirks & SDHCI_QUIRK_NO_BUSY_IRQ))
+ return;
++
++ /* The controller does not support the end-of-busy IRQ,
++ * fall through and take the SDHCI_INT_RESPONSE */
+ }
+
+ if (intmask & SDHCI_INT_RESPONSE)
+@@ -1718,7 +1721,9 @@ int sdhci_add_host(struct sdhci_host *host)
+ #endif
+
+ #ifdef CONFIG_LEDS_CLASS
+- host->led.name = mmc_hostname(mmc);
++ snprintf(host->led_name, sizeof(host->led_name),
++ "%s::", mmc_hostname(mmc));
++ host->led.name = host->led_name;
+ host->led.brightness = LED_OFF;
+ host->led.default_trigger = mmc_hostname(mmc);
+ host->led.brightness_set = sdhci_led_control;
+diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
+index 31f4b15..04c02ac 100644
+--- a/drivers/mmc/host/sdhci.h
++++ b/drivers/mmc/host/sdhci.h
+@@ -210,6 +210,8 @@ struct sdhci_host {
+ #define SDHCI_QUIRK_BROKEN_SMALL_PIO (1<<13)
+ /* Controller supports high speed but doesn't have the caps bit set */
+ #define SDHCI_QUIRK_FORCE_HIGHSPEED (1<<14)
++/* Controller does not provide transfer-complete interrupt when not busy */
++#define SDHCI_QUIRK_NO_BUSY_IRQ (1<<15)
+
+ int irq; /* Device IRQ */
+ void __iomem * ioaddr; /* Mapped address */
+@@ -222,6 +224,7 @@ struct sdhci_host {
+
+ #ifdef CONFIG_LEDS_CLASS
+ struct led_classdev led; /* LED control */
++ char led_name[32];
+ #endif
+
+ spinlock_t lock; /* Mutex */
+diff --git a/drivers/mtd/devices/mtd_dataflash.c b/drivers/mtd/devices/mtd_dataflash.c
+index 6dd9aff..18cba9e 100644
+--- a/drivers/mtd/devices/mtd_dataflash.c
++++ b/drivers/mtd/devices/mtd_dataflash.c
+@@ -815,7 +815,8 @@ static struct flash_info *__devinit jedec_probe(struct spi_device *spi)
+ if (!(info->flags & IS_POW2PS))
+ return info;
+ }
+- }
++ } else
++ return info;
+ }
+ }
+
+diff --git a/drivers/net/usb/asix.c b/drivers/net/usb/asix.c
+index de57490..aee6f1a 100644
+--- a/drivers/net/usb/asix.c
++++ b/drivers/net/usb/asix.c
+@@ -1450,6 +1450,14 @@ static const struct usb_device_id products [] = {
+ // Cables-to-Go USB Ethernet Adapter
+ USB_DEVICE(0x0b95, 0x772a),
+ .driver_info = (unsigned long) &ax88772_info,
++}, {
++ // ABOCOM for pci
++ USB_DEVICE(0x14ea, 0xab11),
++ .driver_info = (unsigned long) &ax88178_info,
++}, {
++ // ASIX 88772a
++ USB_DEVICE(0x0db0, 0xa877),
++ .driver_info = (unsigned long) &ax88772_info,
+ },
+ { }, // END
+ };
+diff --git a/drivers/net/usb/cdc_ether.c b/drivers/net/usb/cdc_ether.c
+index 0e061df..55e8ecc 100644
+--- a/drivers/net/usb/cdc_ether.c
++++ b/drivers/net/usb/cdc_ether.c
+@@ -559,6 +559,11 @@ static const struct usb_device_id products [] = {
+ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
+ USB_CDC_PROTO_NONE),
+ .driver_info = (unsigned long) &cdc_info,
++}, {
++ /* Ericsson F3507g */
++ USB_DEVICE_AND_INTERFACE_INFO(0x0bdb, 0x1900, USB_CLASS_COMM,
++ USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
++ .driver_info = (unsigned long) &cdc_info,
+ },
+ { }, // END
+ };
+diff --git a/drivers/net/usb/zaurus.c b/drivers/net/usb/zaurus.c
+index e24f7b3..04882c8 100644
+--- a/drivers/net/usb/zaurus.c
++++ b/drivers/net/usb/zaurus.c
+@@ -341,6 +341,11 @@ static const struct usb_device_id products [] = {
+ USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
+ USB_CDC_PROTO_NONE),
+ .driver_info = (unsigned long) &bogus_mdlm_info,
++}, {
++ /* Motorola MOTOMAGX phones */
++ USB_DEVICE_AND_INTERFACE_INFO(0x22b8, 0x6425, USB_CLASS_COMM,
++ USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
++ .driver_info = (unsigned long) &bogus_mdlm_info,
+ },
+
+ /* Olympus has some models with a Zaurus-compatible option.
+diff --git a/drivers/net/wireless/rtl8187_dev.c b/drivers/net/wireless/rtl8187_dev.c
+index 47c1c48..6c0e347 100644
+--- a/drivers/net/wireless/rtl8187_dev.c
++++ b/drivers/net/wireless/rtl8187_dev.c
+@@ -40,6 +40,10 @@ static struct usb_device_id rtl8187_table[] __devinitdata = {
+ {USB_DEVICE(0x0bda, 0x8189), .driver_info = DEVICE_RTL8187B},
+ {USB_DEVICE(0x0bda, 0x8197), .driver_info = DEVICE_RTL8187B},
+ {USB_DEVICE(0x0bda, 0x8198), .driver_info = DEVICE_RTL8187B},
++ /* Surecom */
++ {USB_DEVICE(0x0769, 0x11F2), .driver_info = DEVICE_RTL8187},
++ /* Logitech */
++ {USB_DEVICE(0x0789, 0x010C), .driver_info = DEVICE_RTL8187},
+ /* Netgear */
+ {USB_DEVICE(0x0846, 0x6100), .driver_info = DEVICE_RTL8187},
+ {USB_DEVICE(0x0846, 0x6a00), .driver_info = DEVICE_RTL8187},
+@@ -49,8 +53,16 @@ static struct usb_device_id rtl8187_table[] __devinitdata = {
+ /* Sitecom */
+ {USB_DEVICE(0x0df6, 0x000d), .driver_info = DEVICE_RTL8187},
+ {USB_DEVICE(0x0df6, 0x0028), .driver_info = DEVICE_RTL8187B},
++ /* Sphairon Access Systems GmbH */
++ {USB_DEVICE(0x114B, 0x0150), .driver_info = DEVICE_RTL8187},
++ /* Dick Smith Electronics */
++ {USB_DEVICE(0x1371, 0x9401), .driver_info = DEVICE_RTL8187},
+ /* Abocom */
+ {USB_DEVICE(0x13d1, 0xabe6), .driver_info = DEVICE_RTL8187},
++ /* Qcom */
++ {USB_DEVICE(0x18E8, 0x6232), .driver_info = DEVICE_RTL8187},
++ /* AirLive */
++ {USB_DEVICE(0x1b75, 0x8187), .driver_info = DEVICE_RTL8187},
+ {}
+ };
+
+diff --git a/drivers/pci/pcie/aer/aerdrv_core.c b/drivers/pci/pcie/aer/aerdrv_core.c
+index aac7006..d0c9736 100644
+--- a/drivers/pci/pcie/aer/aerdrv_core.c
++++ b/drivers/pci/pcie/aer/aerdrv_core.c
+@@ -108,6 +108,34 @@ int pci_cleanup_aer_correct_error_status(struct pci_dev *dev)
+ }
+ #endif /* 0 */
+
++
++static void set_device_error_reporting(struct pci_dev *dev, void *data)
++{
++ bool enable = *((bool *)data);
++
++ if (dev->pcie_type != PCIE_RC_PORT &&
++ dev->pcie_type != PCIE_SW_UPSTREAM_PORT &&
++ dev->pcie_type != PCIE_SW_DOWNSTREAM_PORT)
++ return;
++
++ if (enable)
++ pci_enable_pcie_error_reporting(dev);
++ else
++ pci_disable_pcie_error_reporting(dev);
++}
++
++/**
++ * set_downstream_devices_error_reporting - enable/disable the error reporting bits on the root port and its downstream ports.
++ * @dev: pointer to root port's pci_dev data structure
++ * @enable: true = enable error reporting, false = disable error reporting.
++ */
++static void set_downstream_devices_error_reporting(struct pci_dev *dev,
++ bool enable)
++{
++ set_device_error_reporting(dev, &enable);
++ pci_walk_bus(dev->subordinate, set_device_error_reporting, &enable);
++}
++
+ static int find_device_iter(struct device *device, void *data)
+ {
+ struct pci_dev *dev;
+@@ -525,15 +553,11 @@ void aer_enable_rootport(struct aer_rpc *rpc)
+ pci_read_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, ®32);
+ pci_write_config_dword(pdev, aer_pos + PCI_ERR_UNCOR_STATUS, reg32);
+
+- /* Enable Root Port device reporting error itself */
+- pci_read_config_word(pdev, pos+PCI_EXP_DEVCTL, ®16);
+- reg16 = reg16 |
+- PCI_EXP_DEVCTL_CERE |
+- PCI_EXP_DEVCTL_NFERE |
+- PCI_EXP_DEVCTL_FERE |
+- PCI_EXP_DEVCTL_URRE;
+- pci_write_config_word(pdev, pos+PCI_EXP_DEVCTL,
+- reg16);
++ /*
++ * Enable error reporting for the root port device and downstream port
++ * devices.
++ */
++ set_downstream_devices_error_reporting(pdev, true);
+
+ /* Enable Root Port's interrupt in response to error messages */
+ pci_write_config_dword(pdev,
+@@ -553,6 +577,12 @@ static void disable_root_aer(struct aer_rpc *rpc)
+ u32 reg32;
+ int pos;
+
++ /*
++ * Disable error reporting for the root port device and downstream port
++ * devices.
++ */
++ set_downstream_devices_error_reporting(pdev, false);
++
+ pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_ERR);
+ /* Disable Root's interrupt in response to error messages */
+ pci_write_config_dword(pdev, pos + PCI_ERR_ROOT_COMMAND, 0);
+diff --git a/drivers/pci/pcie/portdrv_pci.c b/drivers/pci/pcie/portdrv_pci.c
+index 584422d..e22e7fb 100644
+--- a/drivers/pci/pcie/portdrv_pci.c
++++ b/drivers/pci/pcie/portdrv_pci.c
+@@ -101,14 +101,13 @@ static int __devinit pcie_portdrv_probe (struct pci_dev *dev,
+
+ pcie_portdrv_save_config(dev);
+
+- pci_enable_pcie_error_reporting(dev);
+-
+ return 0;
+ }
+
+ static void pcie_portdrv_remove (struct pci_dev *dev)
+ {
+ pcie_port_device_remove(dev);
++ pci_disable_device(dev);
+ kfree(pci_get_drvdata(dev));
+ }
+
+diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
+index 5f4f85f..4fafcec 100644
+--- a/drivers/pci/quirks.c
++++ b/drivers/pci/quirks.c
+@@ -23,6 +23,7 @@
+ #include <linux/acpi.h>
+ #include <linux/kallsyms.h>
+ #include <linux/dmi.h>
++#include <linux/pci-aspm.h>
+ #include "pci.h"
+
+ int isa_dma_bridge_buggy;
+@@ -1543,6 +1544,30 @@ static void __devinit quirk_e100_interrupt(struct pci_dev *dev)
+ }
+ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, PCI_ANY_ID, quirk_e100_interrupt);
+
++/*
++ * The 82575 and 82598 may experience data corruption issues when transitioning
++ * out of L0S. To prevent this we need to disable L0S on the pci-e link
++ */
++static void __devinit quirk_disable_aspm_l0s(struct pci_dev *dev)
++{
++ dev_info(&dev->dev, "Disabling L0s\n");
++ pci_disable_link_state(dev, PCIE_LINK_STATE_L0S);
++}
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10a7, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10a9, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10b6, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10c6, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10c7, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10c8, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10d6, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10db, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10dd, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10e1, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10ec, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10f1, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x10f4, quirk_disable_aspm_l0s);
++DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x1508, quirk_disable_aspm_l0s);
++
+ static void __devinit fixup_rev1_53c810(struct pci_dev* dev)
+ {
+ /* rev 1 ncr53c810 chips don't set the class at all which means
+@@ -1778,7 +1803,6 @@ static void __devinit quirk_msi_ht_cap(struct pci_dev *dev)
+ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT2000_PCIE,
+ quirk_msi_ht_cap);
+
+-
+ /* The nVidia CK804 chipset may have 2 HT MSI mappings.
+ * MSI are supported if the MSI capability set in any of these mappings.
+ */
+@@ -1829,6 +1853,9 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SERVERWORKS,
+ PCI_DEVICE_ID_SERVERWORKS_HT1000_PXB,
+ ht_enable_msi_mapping);
+
++DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_8132_BRIDGE,
++ ht_enable_msi_mapping);
++
+ /* The P5N32-SLI Premium motherboard from Asus has a problem with msi
+ * for the MCP55 NIC. It is not yet determined whether the msi problem
+ * also affects other devices. As for now, turn off msi for this device.
+diff --git a/drivers/scsi/hptiop.c b/drivers/scsi/hptiop.c
+index a48e499..34be88d 100644
+--- a/drivers/scsi/hptiop.c
++++ b/drivers/scsi/hptiop.c
+@@ -1251,6 +1251,7 @@ static struct pci_device_id hptiop_id_table[] = {
+ { PCI_VDEVICE(TTI, 0x3530), (kernel_ulong_t)&hptiop_itl_ops },
+ { PCI_VDEVICE(TTI, 0x3560), (kernel_ulong_t)&hptiop_itl_ops },
+ { PCI_VDEVICE(TTI, 0x4322), (kernel_ulong_t)&hptiop_itl_ops },
++ { PCI_VDEVICE(TTI, 0x4321), (kernel_ulong_t)&hptiop_itl_ops },
+ { PCI_VDEVICE(TTI, 0x4210), (kernel_ulong_t)&hptiop_itl_ops },
+ { PCI_VDEVICE(TTI, 0x4211), (kernel_ulong_t)&hptiop_itl_ops },
+ { PCI_VDEVICE(TTI, 0x4310), (kernel_ulong_t)&hptiop_itl_ops },
+diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
+index 5081b39..726d147 100644
+--- a/drivers/scsi/sd.c
++++ b/drivers/scsi/sd.c
+@@ -106,6 +106,7 @@ static void scsi_disk_release(struct device *cdev);
+ static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
+ static void sd_print_result(struct scsi_disk *, int);
+
++static DEFINE_SPINLOCK(sd_index_lock);
+ static DEFINE_IDA(sd_index_ida);
+
+ /* This semaphore is used to mediate the 0->1 reference get in the
+@@ -1847,7 +1848,9 @@ static int sd_probe(struct device *dev)
+ if (!ida_pre_get(&sd_index_ida, GFP_KERNEL))
+ goto out_put;
+
++ spin_lock(&sd_index_lock);
+ error = ida_get_new(&sd_index_ida, &index);
++ spin_unlock(&sd_index_lock);
+ } while (error == -EAGAIN);
+
+ if (error)
+@@ -1910,7 +1913,9 @@ static int sd_probe(struct device *dev)
+ return 0;
+
+ out_free_index:
++ spin_lock(&sd_index_lock);
+ ida_remove(&sd_index_ida, index);
++ spin_unlock(&sd_index_lock);
+ out_put:
+ put_disk(gd);
+ out_free:
+@@ -1960,7 +1965,9 @@ static void scsi_disk_release(struct device *dev)
+ struct scsi_disk *sdkp = to_scsi_disk(dev);
+ struct gendisk *disk = sdkp->disk;
+
++ spin_lock(&sd_index_lock);
+ ida_remove(&sd_index_ida, sdkp->index);
++ spin_unlock(&sd_index_lock);
+
+ disk->private_data = NULL;
+ put_disk(disk);
+diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
+index 303272a..a181ccf 100644
+--- a/drivers/serial/8250.c
++++ b/drivers/serial/8250.c
+@@ -2014,6 +2014,20 @@ static int serial8250_startup(struct uart_port *port)
+
+ serial8250_set_mctrl(&up->port, up->port.mctrl);
+
++ /* Serial over Lan (SoL) hack:
++ Intel 8257x Gigabit ethernet chips have a
++ 16550 emulation, to be used for Serial Over Lan.
++ Those chips take a longer time than a normal
++ serial device to signalize that a transmission
++ data was queued. Due to that, the above test generally
++ fails. One solution would be to delay the reading of
++ iir. However, this is not reliable, since the timeout
++ is variable. So, let's just don't test if we receive
++ TX irq. This way, we'll never enable UART_BUG_TXEN.
++ */
++ if (up->port.flags & UPF_NO_TXEN_TEST)
++ goto dont_test_tx_en;
++
+ /*
+ * Do a quick test to see if we receive an
+ * interrupt when we enable the TX irq.
+@@ -2033,6 +2047,7 @@ static int serial8250_startup(struct uart_port *port)
+ up->bugs &= ~UART_BUG_TXEN;
+ }
+
++dont_test_tx_en:
+ spin_unlock_irqrestore(&up->port.lock, flags);
+
+ /*
+diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
+index c4fbd9e..f2662a2 100644
+--- a/drivers/serial/8250_pci.c
++++ b/drivers/serial/8250_pci.c
+@@ -758,6 +758,21 @@ pci_default_setup(struct serial_private *priv, struct pciserial_board *board,
+ return setup_port(priv, port, bar, offset, board->reg_shift);
+ }
+
++static int skip_tx_en_setup(struct serial_private *priv,
++ const struct pciserial_board *board,
++ struct uart_port *port, int idx)
++{
++ port->flags |= UPF_NO_TXEN_TEST;
++ printk(KERN_DEBUG "serial8250: skipping TxEn test for device "
++ "[%04x:%04x] subsystem [%04x:%04x]\n",
++ priv->dev->vendor,
++ priv->dev->device,
++ priv->dev->subsystem_vendor,
++ priv->dev->subsystem_device);
++
++ return pci_default_setup(priv, board, port, idx);
++}
++
+ /* This should be in linux/pci_ids.h */
+ #define PCI_VENDOR_ID_SBSMODULARIO 0x124B
+ #define PCI_SUBVENDOR_ID_SBSMODULARIO 0x124B
+@@ -824,6 +839,27 @@ static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
+ .init = pci_inteli960ni_init,
+ .setup = pci_default_setup,
+ },
++ {
++ .vendor = PCI_VENDOR_ID_INTEL,
++ .device = PCI_DEVICE_ID_INTEL_8257X_SOL,
++ .subvendor = PCI_ANY_ID,
++ .subdevice = PCI_ANY_ID,
++ .setup = skip_tx_en_setup,
++ },
++ {
++ .vendor = PCI_VENDOR_ID_INTEL,
++ .device = PCI_DEVICE_ID_INTEL_82573L_SOL,
++ .subvendor = PCI_ANY_ID,
++ .subdevice = PCI_ANY_ID,
++ .setup = skip_tx_en_setup,
++ },
++ {
++ .vendor = PCI_VENDOR_ID_INTEL,
++ .device = PCI_DEVICE_ID_INTEL_82573E_SOL,
++ .subvendor = PCI_ANY_ID,
++ .subdevice = PCI_ANY_ID,
++ .setup = skip_tx_en_setup,
++ },
+ /*
+ * ITE
+ */
+diff --git a/drivers/serial/jsm/jsm_driver.c b/drivers/serial/jsm/jsm_driver.c
+index 338cf8a..edec3a9 100644
+--- a/drivers/serial/jsm/jsm_driver.c
++++ b/drivers/serial/jsm/jsm_driver.c
+@@ -84,6 +84,8 @@ static int jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
+ brd->pci_dev = pdev;
+ if (pdev->device == PCIE_DEVICE_ID_NEO_4_IBM)
+ brd->maxports = 4;
++ else if (pdev->device == PCI_DEVICE_ID_DIGI_NEO_8)
++ brd->maxports = 8;
+ else
+ brd->maxports = 2;
+
+@@ -212,6 +214,7 @@ static struct pci_device_id jsm_pci_tbl[] = {
+ { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45), 0, 0, 2 },
+ { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45PRI), 0, 0, 3 },
+ { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4_IBM), 0, 0, 4 },
++ { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_NEO_8), 0, 0, 5 },
+ { 0, }
+ };
+ MODULE_DEVICE_TABLE(pci, jsm_pci_tbl);
+diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
+index d50a99f..4b3549b 100644
+--- a/drivers/usb/class/cdc-acm.c
++++ b/drivers/usb/class/cdc-acm.c
+@@ -1370,6 +1370,8 @@ static struct usb_device_id acm_ids[] = {
+ { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
+ .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
+ },
++ { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
++ },
+
+ /* control interfaces with various AT-command sets */
+ { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
+diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
+index 8497f63..e00127c 100644
+--- a/drivers/usb/core/message.c
++++ b/drivers/usb/core/message.c
+@@ -651,7 +651,7 @@ int usb_get_descriptor(struct usb_device *dev, unsigned char type,
+ if (result <= 0 && result != -ETIMEDOUT)
+ continue;
+ if (result > 1 && ((u8 *)buf)[1] != type) {
+- result = -EPROTO;
++ result = -ENODATA;
+ continue;
+ }
+ break;
+@@ -694,8 +694,13 @@ static int usb_get_string(struct usb_device *dev, unsigned short langid,
+ USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
+ (USB_DT_STRING << 8) + index, langid, buf, size,
+ USB_CTRL_GET_TIMEOUT);
+- if (!(result == 0 || result == -EPIPE))
+- break;
++ if (result == 0 || result == -EPIPE)
++ continue;
++ if (result > 1 && ((u8 *) buf)[1] != USB_DT_STRING) {
++ result = -ENODATA;
++ continue;
++ }
++ break;
+ }
+ return result;
+ }
+diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
+index 4725d15..e551bb3 100644
+--- a/drivers/usb/host/ehci-hcd.c
++++ b/drivers/usb/host/ehci-hcd.c
+@@ -485,6 +485,7 @@ static int ehci_init(struct usb_hcd *hcd)
+ * periodic_size can shrink by USBCMD update if hcc_params allows.
+ */
+ ehci->periodic_size = DEFAULT_I_TDPS;
++ INIT_LIST_HEAD(&ehci->cached_itd_list);
+ if ((retval = ehci_mem_init(ehci, GFP_KERNEL)) < 0)
+ return retval;
+
+@@ -497,6 +498,7 @@ static int ehci_init(struct usb_hcd *hcd)
+
+ ehci->reclaim = NULL;
+ ehci->next_uframe = -1;
++ ehci->clock_frame = -1;
+
+ /*
+ * dedicate a qh for the async ring head, since we couldn't unlink
+diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
+index 0431397..10d5291 100644
+--- a/drivers/usb/host/ehci-mem.c
++++ b/drivers/usb/host/ehci-mem.c
+@@ -128,6 +128,7 @@ static inline void qh_put (struct ehci_qh *qh)
+
+ static void ehci_mem_cleanup (struct ehci_hcd *ehci)
+ {
++ free_cached_itd_list(ehci);
+ if (ehci->async)
+ qh_put (ehci->async);
+ ehci->async = NULL;
+diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
+index a081ee6..07bcb93 100644
+--- a/drivers/usb/host/ehci-sched.c
++++ b/drivers/usb/host/ehci-sched.c
+@@ -1004,7 +1004,8 @@ iso_stream_put(struct ehci_hcd *ehci, struct ehci_iso_stream *stream)
+
+ is_in = (stream->bEndpointAddress & USB_DIR_IN) ? 0x10 : 0;
+ stream->bEndpointAddress &= 0x0f;
+- stream->ep->hcpriv = NULL;
++ if (stream->ep)
++ stream->ep->hcpriv = NULL;
+
+ if (stream->rescheduled) {
+ ehci_info (ehci, "ep%d%s-iso rescheduled "
+@@ -1653,14 +1654,28 @@ itd_complete (
+ (stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out");
+ }
+ iso_stream_put (ehci, stream);
+- /* OK to recycle this ITD now that its completion callback ran. */
++
+ done:
+ usb_put_urb(urb);
+ itd->urb = NULL;
+- itd->stream = NULL;
+- list_move(&itd->itd_list, &stream->free_list);
+- iso_stream_put(ehci, stream);
+-
++ if (ehci->clock_frame != itd->frame || itd->index[7] != -1) {
++ /* OK to recycle this ITD now. */
++ itd->stream = NULL;
++ list_move(&itd->itd_list, &stream->free_list);
++ iso_stream_put(ehci, stream);
++ } else {
++ /* HW might remember this ITD, so we can't recycle it yet.
++ * Move it to a safe place until a new frame starts.
++ */
++ list_move(&itd->itd_list, &ehci->cached_itd_list);
++ if (stream->refcount == 2) {
++ /* If iso_stream_put() were called here, stream
++ * would be freed. Instead, just prevent reuse.
++ */
++ stream->ep->hcpriv = NULL;
++ stream->ep = NULL;
++ }
++ }
+ return retval;
+ }
+
+@@ -2101,6 +2116,20 @@ done:
+
+ /*-------------------------------------------------------------------------*/
+
++static void free_cached_itd_list(struct ehci_hcd *ehci)
++{
++ struct ehci_itd *itd, *n;
++
++ list_for_each_entry_safe(itd, n, &ehci->cached_itd_list, itd_list) {
++ struct ehci_iso_stream *stream = itd->stream;
++ itd->stream = NULL;
++ list_move(&itd->itd_list, &stream->free_list);
++ iso_stream_put(ehci, stream);
++ }
++}
++
++/*-------------------------------------------------------------------------*/
++
+ static void
+ scan_periodic (struct ehci_hcd *ehci)
+ {
+@@ -2115,10 +2144,17 @@ scan_periodic (struct ehci_hcd *ehci)
+ * Touches as few pages as possible: cache-friendly.
+ */
+ now_uframe = ehci->next_uframe;
+- if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state))
++ if (HC_IS_RUNNING(ehci_to_hcd(ehci)->state)) {
+ clock = ehci_readl(ehci, &ehci->regs->frame_index);
+- else
++ clock_frame = (clock >> 3) % ehci->periodic_size;
++ } else {
+ clock = now_uframe + mod - 1;
++ clock_frame = -1;
++ }
++ if (ehci->clock_frame != clock_frame) {
++ free_cached_itd_list(ehci);
++ ehci->clock_frame = clock_frame;
++ }
+ clock %= mod;
+ clock_frame = clock >> 3;
+
+@@ -2277,6 +2313,10 @@ restart:
+ /* rescan the rest of this frame, then ... */
+ clock = now;
+ clock_frame = clock >> 3;
++ if (ehci->clock_frame != clock_frame) {
++ free_cached_itd_list(ehci);
++ ehci->clock_frame = clock_frame;
++ }
+ } else {
+ now_uframe++;
+ now_uframe %= mod;
+diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
+index c7d4b5a..fe97688 100644
+--- a/drivers/usb/host/ehci.h
++++ b/drivers/usb/host/ehci.h
+@@ -87,6 +87,10 @@ struct ehci_hcd { /* one per controller */
+ int next_uframe; /* scan periodic, start here */
+ unsigned periodic_sched; /* periodic activity count */
+
++ /* list of itds completed while clock_frame was still active */
++ struct list_head cached_itd_list;
++ unsigned clock_frame;
++
+ /* per root hub port */
+ unsigned long reset_done [EHCI_MAX_ROOT_PORTS];
+
+@@ -210,6 +214,8 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
+ }
+ }
+
++static void free_cached_itd_list(struct ehci_hcd *ehci);
++
+ /*-------------------------------------------------------------------------*/
+
+ #include <linux/usb/ehci_def.h>
+diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
+index d0ed63d..5c3da3f 100644
+--- a/drivers/usb/serial/option.c
++++ b/drivers/usb/serial/option.c
+@@ -289,6 +289,9 @@ static int option_send_setup(struct tty_struct *tty, struct usb_serial_port *po
+ #define ERICSSON_VENDOR_ID 0x0bdb
+ #define ERICSSON_PRODUCT_F3507G 0x1900
+
++#define BENQ_VENDOR_ID 0x04a5
++#define BENQ_PRODUCT_H10 0x4068
++
+ static struct usb_device_id option_ids[] = {
+ { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_COLT) },
+ { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_RICOLA) },
+@@ -498,6 +501,8 @@ static struct usb_device_id option_ids[] = {
+ { USB_DEVICE(ZTE_VENDOR_ID, ZTE_PRODUCT_MF628) },
+ { USB_DEVICE(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH) },
+ { USB_DEVICE(ERICSSON_VENDOR_ID, ERICSSON_PRODUCT_F3507G) },
++ { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_H10) },
++ { USB_DEVICE(0x1da5, 0x4515) }, /* BenQ H20 */
+ { } /* Terminating entry */
+ };
+ MODULE_DEVICE_TABLE(usb, option_ids);
+diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
+index 729a256..781d581 100644
+--- a/drivers/usb/storage/unusual_devs.h
++++ b/drivers/usb/storage/unusual_devs.h
+@@ -876,13 +876,13 @@ UNUSUAL_DEV( 0x05e3, 0x0701, 0x0000, 0xffff,
+ "Genesys Logic",
+ "USB to IDE Optical",
+ US_SC_DEVICE, US_PR_DEVICE, NULL,
+- US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 ),
++ US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ),
+
+ UNUSUAL_DEV( 0x05e3, 0x0702, 0x0000, 0xffff,
+ "Genesys Logic",
+ "USB to IDE Disk",
+ US_SC_DEVICE, US_PR_DEVICE, NULL,
+- US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 ),
++ US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 | US_FL_IGNORE_RESIDUE ),
+
+ /* Reported by Hanno Boeck <hanno@gmx.de>
+ * Taken from the Lycoris Kernel */
+diff --git a/drivers/watchdog/ks8695_wdt.c b/drivers/watchdog/ks8695_wdt.c
+index 0b798fd..74c92d3 100644
+--- a/drivers/watchdog/ks8695_wdt.c
++++ b/drivers/watchdog/ks8695_wdt.c
+@@ -21,6 +21,7 @@
+ #include <linux/watchdog.h>
+ #include <linux/io.h>
+ #include <linux/uaccess.h>
++#include <mach/timex.h>
+ #include <mach/regs-timer.h>
+
+ #define WDT_DEFAULT_TIME 5 /* seconds */
+diff --git a/drivers/watchdog/rc32434_wdt.c b/drivers/watchdog/rc32434_wdt.c
+index 57027f4..f3553fa 100644
+--- a/drivers/watchdog/rc32434_wdt.c
++++ b/drivers/watchdog/rc32434_wdt.c
+@@ -34,104 +34,89 @@
+ #include <asm/time.h>
+ #include <asm/mach-rc32434/integ.h>
+
+-#define MAX_TIMEOUT 20
+-#define RC32434_WDT_INTERVAL (15 * HZ)
+-
+-#define VERSION "0.2"
++#define VERSION "0.4"
+
+ static struct {
+- struct completion stop;
+- int running;
+- struct timer_list timer;
+- int queue;
+- int default_ticks;
+ unsigned long inuse;
+ } rc32434_wdt_device;
+
+ static struct integ __iomem *wdt_reg;
+-static int ticks = 100 * HZ;
+
+ static int expect_close;
+-static int timeout;
++
++/* Board internal clock speed in Hz,
++ * the watchdog timer ticks at. */
++extern unsigned int idt_cpu_freq;
++
++/* translate wtcompare value to seconds and vice versa */
++#define WTCOMP2SEC(x) (x / idt_cpu_freq)
++#define SEC2WTCOMP(x) (x * idt_cpu_freq)
++
++/* Use a default timeout of 20s. This should be
++ * safe for CPU clock speeds up to 400MHz, as
++ * ((2 ^ 32) - 1) / (400MHz / 2) = 21s. */
++#define WATCHDOG_TIMEOUT 20
++
++static int timeout = WATCHDOG_TIMEOUT;
+
+ static int nowayout = WATCHDOG_NOWAYOUT;
+ module_param(nowayout, int, 0);
+ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+ __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
++/* apply or and nand masks to data read from addr and write back */
++#define SET_BITS(addr, or, nand) \
++ writel((readl(&addr) | or) & ~nand, &addr)
+
+ static void rc32434_wdt_start(void)
+ {
+- u32 val;
+-
+- if (!rc32434_wdt_device.inuse) {
+- writel(0, &wdt_reg->wtcount);
++ u32 or, nand;
+
+- val = RC32434_ERR_WRE;
+- writel(readl(&wdt_reg->errcs) | val, &wdt_reg->errcs);
++ /* zero the counter before enabling */
++ writel(0, &wdt_reg->wtcount);
+
+- val = RC32434_WTC_EN;
+- writel(readl(&wdt_reg->wtc) | val, &wdt_reg->wtc);
+- }
+- rc32434_wdt_device.running++;
+-}
++ /* don't generate a non-maskable interrupt,
++ * do a warm reset instead */
++ nand = 1 << RC32434_ERR_WNE;
++ or = 1 << RC32434_ERR_WRE;
+
+-static void rc32434_wdt_stop(void)
+-{
+- u32 val;
++ /* reset the ERRCS timeout bit in case it's set */
++ nand |= 1 << RC32434_ERR_WTO;
+
+- if (rc32434_wdt_device.running) {
++ SET_BITS(wdt_reg->errcs, or, nand);
+
+- val = ~RC32434_WTC_EN;
+- writel(readl(&wdt_reg->wtc) & val, &wdt_reg->wtc);
++ /* reset WTC timeout bit and enable WDT */
++ nand = 1 << RC32434_WTC_TO;
++ or = 1 << RC32434_WTC_EN;
+
+- val = ~RC32434_ERR_WRE;
+- writel(readl(&wdt_reg->errcs) & val, &wdt_reg->errcs);
++ SET_BITS(wdt_reg->wtc, or, nand);
++}
+
+- rc32434_wdt_device.running = 0;
+- }
++static void rc32434_wdt_stop(void)
++{
++ /* Disable WDT */
++ SET_BITS(wdt_reg->wtc, 0, 1 << RC32434_WTC_EN);
+ }
+
+-static void rc32434_wdt_set(int new_timeout)
++static int rc32434_wdt_set(int new_timeout)
+ {
+- u32 cmp = new_timeout * HZ;
+- u32 state, val;
++ int max_to = WTCOMP2SEC((u32)-1);
+
++ if (new_timeout < 0 || new_timeout > max_to) {
++ printk(KERN_ERR KBUILD_MODNAME
++ ": timeout value must be between 0 and %d",
++ max_to);
++ return -EINVAL;
++ }
+ timeout = new_timeout;
+- /*
+- * store and disable WTC
+- */
+- state = (u32)(readl(&wdt_reg->wtc) & RC32434_WTC_EN);
+- val = ~RC32434_WTC_EN;
+- writel(readl(&wdt_reg->wtc) & val, &wdt_reg->wtc);
+-
+- writel(0, &wdt_reg->wtcount);
+- writel(cmp, &wdt_reg->wtcompare);
+-
+- /*
+- * restore WTC
+- */
+-
+- writel(readl(&wdt_reg->wtc) | state, &wdt_reg);
+-}
++ writel(SEC2WTCOMP(timeout), &wdt_reg->wtcompare);
+
+-static void rc32434_wdt_reset(void)
+-{
+- ticks = rc32434_wdt_device.default_ticks;
++ return 0;
+ }
+
+-static void rc32434_wdt_update(unsigned long unused)
++static void rc32434_wdt_ping(void)
+ {
+- if (rc32434_wdt_device.running)
+- ticks--;
+-
+ writel(0, &wdt_reg->wtcount);
+-
+- if (rc32434_wdt_device.queue && ticks)
+- mod_timer(&rc32434_wdt_device.timer,
+- jiffies + RC32434_WDT_INTERVAL);
+- else
+- complete(&rc32434_wdt_device.stop);
+ }
+
+ static int rc32434_wdt_open(struct inode *inode, struct file *file)
+@@ -142,19 +127,23 @@ static int rc32434_wdt_open(struct inode *inode, struct file *file)
+ if (nowayout)
+ __module_get(THIS_MODULE);
+
++ rc32434_wdt_start();
++ rc32434_wdt_ping();
++
+ return nonseekable_open(inode, file);
+ }
+
+ static int rc32434_wdt_release(struct inode *inode, struct file *file)
+ {
+- if (expect_close && nowayout == 0) {
++ if (expect_close == 42) {
+ rc32434_wdt_stop();
+ printk(KERN_INFO KBUILD_MODNAME ": disabling watchdog timer\n");
+ module_put(THIS_MODULE);
+- } else
++ } else {
+ printk(KERN_CRIT KBUILD_MODNAME
+ ": device closed unexpectedly. WDT will not stop !\n");
+-
++ rc32434_wdt_ping();
++ }
+ clear_bit(0, &rc32434_wdt_device.inuse);
+ return 0;
+ }
+@@ -174,10 +163,10 @@ static ssize_t rc32434_wdt_write(struct file *file, const char *data,
+ if (get_user(c, data + i))
+ return -EFAULT;
+ if (c == 'V')
+- expect_close = 1;
++ expect_close = 42;
+ }
+ }
+- rc32434_wdt_update(0);
++ rc32434_wdt_ping();
+ return len;
+ }
+ return 0;
+@@ -197,11 +186,11 @@ static long rc32434_wdt_ioctl(struct file *file, unsigned int cmd,
+ };
+ switch (cmd) {
+ case WDIOC_KEEPALIVE:
+- rc32434_wdt_reset();
++ rc32434_wdt_ping();
+ break;
+ case WDIOC_GETSTATUS:
+ case WDIOC_GETBOOTSTATUS:
+- value = readl(&wdt_reg->wtcount);
++ value = 0;
+ if (copy_to_user(argp, &value, sizeof(int)))
+ return -EFAULT;
+ break;
+@@ -218,6 +207,7 @@ static long rc32434_wdt_ioctl(struct file *file, unsigned int cmd,
+ break;
+ case WDIOS_DISABLECARD:
+ rc32434_wdt_stop();
++ break;
+ default:
+ return -EINVAL;
+ }
+@@ -225,11 +215,9 @@ static long rc32434_wdt_ioctl(struct file *file, unsigned int cmd,
+ case WDIOC_SETTIMEOUT:
+ if (copy_from_user(&new_timeout, argp, sizeof(int)))
+ return -EFAULT;
+- if (new_timeout < 1)
++ if (rc32434_wdt_set(new_timeout))
+ return -EINVAL;
+- if (new_timeout > MAX_TIMEOUT)
+- return -EINVAL;
+- rc32434_wdt_set(new_timeout);
++ /* Fall through */
+ case WDIOC_GETTIMEOUT:
+ return copy_to_user(argp, &timeout, sizeof(int));
+ default:
+@@ -254,15 +242,15 @@ static struct miscdevice rc32434_wdt_miscdev = {
+ .fops = &rc32434_wdt_fops,
+ };
+
+-static char banner[] = KERN_INFO KBUILD_MODNAME
++static char banner[] __devinitdata = KERN_INFO KBUILD_MODNAME
+ ": Watchdog Timer version " VERSION ", timer margin: %d sec\n";
+
+-static int rc32434_wdt_probe(struct platform_device *pdev)
++static int __devinit rc32434_wdt_probe(struct platform_device *pdev)
+ {
+ int ret;
+ struct resource *r;
+
+- r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rb500_wdt_res");
++ r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "rb532_wdt_res");
+ if (!r) {
+ printk(KERN_ERR KBUILD_MODNAME
+ "failed to retrieve resources\n");
+@@ -277,24 +265,12 @@ static int rc32434_wdt_probe(struct platform_device *pdev)
+ }
+
+ ret = misc_register(&rc32434_wdt_miscdev);
+-
+ if (ret < 0) {
+ printk(KERN_ERR KBUILD_MODNAME
+ "failed to register watchdog device\n");
+ goto unmap;
+ }
+
+- init_completion(&rc32434_wdt_device.stop);
+- rc32434_wdt_device.queue = 0;
+-
+- clear_bit(0, &rc32434_wdt_device.inuse);
+-
+- setup_timer(&rc32434_wdt_device.timer, rc32434_wdt_update, 0L);
+-
+- rc32434_wdt_device.default_ticks = ticks;
+-
+- rc32434_wdt_start();
+-
+ printk(banner, timeout);
+
+ return 0;
+@@ -304,23 +280,17 @@ unmap:
+ return ret;
+ }
+
+-static int rc32434_wdt_remove(struct platform_device *pdev)
++static int __devexit rc32434_wdt_remove(struct platform_device *pdev)
+ {
+- if (rc32434_wdt_device.queue) {
+- rc32434_wdt_device.queue = 0;
+- wait_for_completion(&rc32434_wdt_device.stop);
+- }
+ misc_deregister(&rc32434_wdt_miscdev);
+-
+ iounmap(wdt_reg);
+-
+ return 0;
+ }
+
+ static struct platform_driver rc32434_wdt = {
+ .probe = rc32434_wdt_probe,
+- .remove = rc32434_wdt_remove,
+- .driver = {
++ .remove = __devexit_p(rc32434_wdt_remove),
++ .driver = {
+ .name = "rc32434_wdt",
+ }
+ };
+diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
+index e078b7a..4c1cb9a 100644
+--- a/fs/cifs/CHANGES
++++ b/fs/cifs/CHANGES
+@@ -1,3 +1,5 @@
++Fix oops in cifs_dfs_ref.c when prefixpath is not reachable when using DFS.
++
+ Version 1.55
+ ------------
+ Various fixes to make delete of open files behavior more predictable
+diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
+index 2851d5d..3cfa452 100644
+--- a/fs/cifs/sess.c
++++ b/fs/cifs/sess.c
+@@ -228,7 +228,7 @@ static int decode_unicode_ssetup(char **pbcc_area, int bleft,
+
+ kfree(ses->serverOS);
+ /* UTF-8 string will not grow more than four times as big as UCS-16 */
+- ses->serverOS = kzalloc(4 * len, GFP_KERNEL);
++ ses->serverOS = kzalloc((4 * len) + 2 /* trailing null */, GFP_KERNEL);
+ if (ses->serverOS != NULL)
+ cifs_strfromUCS_le(ses->serverOS, (__le16 *)data, len, nls_cp);
+ data += 2 * (len + 1);
+@@ -241,7 +241,7 @@ static int decode_unicode_ssetup(char **pbcc_area, int bleft,
+ return rc;
+
+ kfree(ses->serverNOS);
+- ses->serverNOS = kzalloc(4 * len, GFP_KERNEL); /* BB this is wrong length FIXME BB */
++ ses->serverNOS = kzalloc((4 * len) + 2 /* trailing null */, GFP_KERNEL);
+ if (ses->serverNOS != NULL) {
+ cifs_strfromUCS_le(ses->serverNOS, (__le16 *)data, len,
+ nls_cp);
+diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
+index c8f8d59..61cb48f 100644
+--- a/fs/compat_ioctl.c
++++ b/fs/compat_ioctl.c
+@@ -1938,6 +1938,8 @@ ULONG_IOCTL(SET_BITMAP_FILE)
+ /* Big K */
+ COMPATIBLE_IOCTL(PIO_FONT)
+ COMPATIBLE_IOCTL(GIO_FONT)
++COMPATIBLE_IOCTL(PIO_CMAP)
++COMPATIBLE_IOCTL(GIO_CMAP)
+ ULONG_IOCTL(KDSIGACCEPT)
+ COMPATIBLE_IOCTL(KDGETKEYCODE)
+ COMPATIBLE_IOCTL(KDSETKEYCODE)
+diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
+index dfccef5..0b0c0fa 100644
+--- a/fs/ext4/ext4.h
++++ b/fs/ext4/ext4.h
+@@ -862,7 +862,7 @@ static inline unsigned ext4_rec_len_from_disk(__le16 dlen)
+ {
+ unsigned len = le16_to_cpu(dlen);
+
+- if (len == EXT4_MAX_REC_LEN)
++ if (len == EXT4_MAX_REC_LEN || len == 0)
+ return 1 << 16;
+ return len;
+ }
+diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
+index b363c49..03c0819 100644
+--- a/fs/ext4/ialloc.c
++++ b/fs/ext4/ialloc.c
+@@ -703,6 +703,13 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode)
+
+ if (sbi->s_log_groups_per_flex) {
+ ret2 = find_group_flex(sb, dir, &group);
++ if (ret2 == -1) {
++ ret2 = find_group_other(sb, dir, &group);
++ if (ret2 == 0 && printk_ratelimit())
++ printk(KERN_NOTICE "ext4: find_group_flex "
++ "failed, fallback succeeded dir %lu\n",
++ dir->i_ino);
++ }
+ goto got_group;
+ }
+
+diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
+index ccb6947..b7f20b0 100644
+--- a/fs/ext4/inode.c
++++ b/fs/ext4/inode.c
+@@ -46,8 +46,10 @@
+ static inline int ext4_begin_ordered_truncate(struct inode *inode,
+ loff_t new_size)
+ {
+- return jbd2_journal_begin_ordered_truncate(&EXT4_I(inode)->jinode,
+- new_size);
++ return jbd2_journal_begin_ordered_truncate(
++ EXT4_SB(inode->i_sb)->s_journal,
++ &EXT4_I(inode)->jinode,
++ new_size);
+ }
+
+ static void ext4_invalidatepage(struct page *page, unsigned long offset);
+@@ -1345,6 +1347,10 @@ retry:
+ goto out;
+ }
+
++ /* We cannot recurse into the filesystem as the transaction is already
++ * started */
++ flags |= AOP_FLAG_NOFS;
++
+ page = grab_cache_page_write_begin(mapping, index, flags);
+ if (!page) {
+ ext4_journal_stop(handle);
+@@ -1354,7 +1360,7 @@ retry:
+ *pagep = page;
+
+ ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
+- ext4_get_block);
++ ext4_get_block);
+
+ if (!ret && ext4_should_journal_data(inode)) {
+ ret = walk_page_buffers(handle, page_buffers(page),
+@@ -2400,6 +2406,7 @@ static int ext4_da_writepages(struct address_space *mapping,
+ struct inode *inode = mapping->host;
+ int no_nrwrite_index_update;
+ long pages_written = 0, pages_skipped;
++ int range_cyclic, cycled = 1, io_done = 0;
+ int needed_blocks, ret = 0, nr_to_writebump = 0;
+ struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
+
+@@ -2437,9 +2444,15 @@ static int ext4_da_writepages(struct address_space *mapping,
+ if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
+ range_whole = 1;
+
+- if (wbc->range_cyclic)
++ range_cyclic = wbc->range_cyclic;
++ if (wbc->range_cyclic) {
+ index = mapping->writeback_index;
+- else
++ if (index)
++ cycled = 0;
++ wbc->range_start = index << PAGE_CACHE_SHIFT;
++ wbc->range_end = LLONG_MAX;
++ wbc->range_cyclic = 0;
++ } else
+ index = wbc->range_start >> PAGE_CACHE_SHIFT;
+
+ mpd.wbc = wbc;
+@@ -2453,6 +2466,7 @@ static int ext4_da_writepages(struct address_space *mapping,
+ wbc->no_nrwrite_index_update = 1;
+ pages_skipped = wbc->pages_skipped;
+
++retry:
+ while (!ret && wbc->nr_to_write > 0) {
+
+ /*
+@@ -2495,6 +2509,7 @@ static int ext4_da_writepages(struct address_space *mapping,
+ pages_written += mpd.pages_written;
+ wbc->pages_skipped = pages_skipped;
+ ret = 0;
++ io_done = 1;
+ } else if (wbc->nr_to_write)
+ /*
+ * There is no more writeout needed
+@@ -2503,6 +2518,13 @@ static int ext4_da_writepages(struct address_space *mapping,
+ */
+ break;
+ }
++ if (!io_done && !cycled) {
++ cycled = 1;
++ index = 0;
++ wbc->range_start = index << PAGE_CACHE_SHIFT;
++ wbc->range_end = mapping->writeback_index - 1;
++ goto retry;
++ }
+ if (pages_skipped != wbc->pages_skipped)
+ printk(KERN_EMERG "This should not happen leaving %s "
+ "with nr_to_write = %ld ret = %d\n",
+@@ -2510,6 +2532,7 @@ static int ext4_da_writepages(struct address_space *mapping,
+
+ /* Update index */
+ index += pages_written;
++ wbc->range_cyclic = range_cyclic;
+ if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
+ /*
+ * set the writeback_index so that range_cyclic
+@@ -2584,6 +2607,9 @@ retry:
+ ret = PTR_ERR(handle);
+ goto out;
+ }
++ /* We cannot recurse into the filesystem as the transaction is already
++ * started */
++ flags |= AOP_FLAG_NOFS;
+
+ page = grab_cache_page_write_begin(mapping, index, flags);
+ if (!page) {
+diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
+index 775ef32..f8e923f 100644
+--- a/fs/ext4/mballoc.c
++++ b/fs/ext4/mballoc.c
+@@ -3690,6 +3690,8 @@ ext4_mb_new_inode_pa(struct ext4_allocation_context *ac)
+ pa->pa_free = pa->pa_len;
+ atomic_set(&pa->pa_count, 1);
+ spin_lock_init(&pa->pa_lock);
++ INIT_LIST_HEAD(&pa->pa_inode_list);
++ INIT_LIST_HEAD(&pa->pa_group_list);
+ pa->pa_deleted = 0;
+ pa->pa_linear = 0;
+
+@@ -3748,6 +3750,7 @@ ext4_mb_new_group_pa(struct ext4_allocation_context *ac)
+ atomic_set(&pa->pa_count, 1);
+ spin_lock_init(&pa->pa_lock);
+ INIT_LIST_HEAD(&pa->pa_inode_list);
++ INIT_LIST_HEAD(&pa->pa_group_list);
+ pa->pa_deleted = 0;
+ pa->pa_linear = 1;
+
+@@ -4456,23 +4459,26 @@ static int ext4_mb_release_context(struct ext4_allocation_context *ac)
+ pa->pa_free -= ac->ac_b_ex.fe_len;
+ pa->pa_len -= ac->ac_b_ex.fe_len;
+ spin_unlock(&pa->pa_lock);
+- /*
+- * We want to add the pa to the right bucket.
+- * Remove it from the list and while adding
+- * make sure the list to which we are adding
+- * doesn't grow big.
+- */
+- if (likely(pa->pa_free)) {
+- spin_lock(pa->pa_obj_lock);
+- list_del_rcu(&pa->pa_inode_list);
+- spin_unlock(pa->pa_obj_lock);
+- ext4_mb_add_n_trim(ac);
+- }
+ }
+- ext4_mb_put_pa(ac, ac->ac_sb, pa);
+ }
+ if (ac->alloc_semp)
+ up_read(ac->alloc_semp);
++ if (pa) {
++ /*
++ * We want to add the pa to the right bucket.
++ * Remove it from the list and while adding
++ * make sure the list to which we are adding
++ * doesn't grow big. We need to release
++ * alloc_semp before calling ext4_mb_add_n_trim()
++ */
++ if (pa->pa_linear && likely(pa->pa_free)) {
++ spin_lock(pa->pa_obj_lock);
++ list_del_rcu(&pa->pa_inode_list);
++ spin_unlock(pa->pa_obj_lock);
++ ext4_mb_add_n_trim(ac);
++ }
++ ext4_mb_put_pa(ac, ac->ac_sb, pa);
++ }
+ if (ac->ac_bitmap_page)
+ page_cache_release(ac->ac_bitmap_page);
+ if (ac->ac_buddy_page)
+diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c
+index f2a9cf4..9aa0fbe 100644
+--- a/fs/ext4/migrate.c
++++ b/fs/ext4/migrate.c
+@@ -480,7 +480,7 @@ int ext4_ext_migrate(struct inode *inode)
+ + 1);
+ if (IS_ERR(handle)) {
+ retval = PTR_ERR(handle);
+- goto err_out;
++ return retval;
+ }
+ tmp_inode = ext4_new_inode(handle,
+ inode->i_sb->s_root->d_inode,
+@@ -488,8 +488,7 @@ int ext4_ext_migrate(struct inode *inode)
+ if (IS_ERR(tmp_inode)) {
+ retval = -ENOMEM;
+ ext4_journal_stop(handle);
+- tmp_inode = NULL;
+- goto err_out;
++ return retval;
+ }
+ i_size_write(tmp_inode, i_size_read(inode));
+ /*
+@@ -617,8 +616,7 @@ err_out:
+
+ ext4_journal_stop(handle);
+
+- if (tmp_inode)
+- iput(tmp_inode);
++ iput(tmp_inode);
+
+ return retval;
+ }
+diff --git a/fs/ext4/super.c b/fs/ext4/super.c
+index d38e3e1..e522b8c 100644
+--- a/fs/ext4/super.c
++++ b/fs/ext4/super.c
+@@ -2914,15 +2914,15 @@ static void ext4_write_super(struct super_block *sb)
+
+ static int ext4_sync_fs(struct super_block *sb, int wait)
+ {
+- int ret = 0;
++ tid_t target;
+
+ trace_mark(ext4_sync_fs, "dev %s wait %d", sb->s_id, wait);
+ sb->s_dirt = 0;
+- if (wait)
+- ret = ext4_force_commit(sb);
+- else
+- jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, NULL);
+- return ret;
++ if (jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, &target)) {
++ if (wait)
++ jbd2_log_wait_commit(EXT4_SB(sb)->s_journal, target);
++ }
++ return 0;
+ }
+
+ /*
+diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
+index e5eaa62..e3fe991 100644
+--- a/fs/fs-writeback.c
++++ b/fs/fs-writeback.c
+@@ -274,6 +274,7 @@ __sync_single_inode(struct inode *inode, struct writeback_control *wbc)
+ int ret;
+
+ BUG_ON(inode->i_state & I_SYNC);
++ WARN_ON(inode->i_state & I_NEW);
+
+ /* Set I_SYNC, reset I_DIRTY */
+ dirty = inode->i_state & I_DIRTY;
+@@ -298,6 +299,7 @@ __sync_single_inode(struct inode *inode, struct writeback_control *wbc)
+ }
+
+ spin_lock(&inode_lock);
++ WARN_ON(inode->i_state & I_NEW);
+ inode->i_state &= ~I_SYNC;
+ if (!(inode->i_state & I_FREEING)) {
+ if (!(inode->i_state & I_DIRTY) &&
+@@ -470,6 +472,11 @@ void generic_sync_sb_inodes(struct super_block *sb,
+ break;
+ }
+
++ if (inode->i_state & I_NEW) {
++ requeue_io(inode);
++ continue;
++ }
++
+ if (wbc->nonblocking && bdi_write_congested(bdi)) {
+ wbc->encountered_congestion = 1;
+ if (!sb_is_blkdev_sb(sb))
+@@ -531,7 +538,7 @@ void generic_sync_sb_inodes(struct super_block *sb,
+ list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
+ struct address_space *mapping;
+
+- if (inode->i_state & (I_FREEING|I_WILL_FREE))
++ if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW))
+ continue;
+ mapping = inode->i_mapping;
+ if (mapping->nrpages == 0)
+diff --git a/fs/inode.c b/fs/inode.c
+index 0487ddb..7b2acc1 100644
+--- a/fs/inode.c
++++ b/fs/inode.c
+@@ -339,6 +339,7 @@ static int invalidate_list(struct list_head *head, struct list_head *dispose)
+ invalidate_inode_buffers(inode);
+ if (!atomic_read(&inode->i_count)) {
+ list_move(&inode->i_list, dispose);
++ WARN_ON(inode->i_state & I_NEW);
+ inode->i_state |= I_FREEING;
+ count++;
+ continue;
+@@ -440,6 +441,7 @@ static void prune_icache(int nr_to_scan)
+ continue;
+ }
+ list_move(&inode->i_list, &freeable);
++ WARN_ON(inode->i_state & I_NEW);
+ inode->i_state |= I_FREEING;
+ nr_pruned++;
+ }
+@@ -595,6 +597,7 @@ void unlock_new_inode(struct inode *inode)
+ * just created it (so there can be no old holders
+ * that haven't tested I_LOCK).
+ */
++ WARN_ON((inode->i_state & (I_LOCK|I_NEW)) != (I_LOCK|I_NEW));
+ inode->i_state &= ~(I_LOCK|I_NEW);
+ wake_up_inode(inode);
+ }
+@@ -1041,6 +1044,7 @@ void generic_delete_inode(struct inode *inode)
+
+ list_del_init(&inode->i_list);
+ list_del_init(&inode->i_sb_list);
++ WARN_ON(inode->i_state & I_NEW);
+ inode->i_state |= I_FREEING;
+ inodes_stat.nr_inodes--;
+ spin_unlock(&inode_lock);
+@@ -1082,16 +1086,19 @@ static void generic_forget_inode(struct inode *inode)
+ spin_unlock(&inode_lock);
+ return;
+ }
++ WARN_ON(inode->i_state & I_NEW);
+ inode->i_state |= I_WILL_FREE;
+ spin_unlock(&inode_lock);
+ write_inode_now(inode, 1);
+ spin_lock(&inode_lock);
++ WARN_ON(inode->i_state & I_NEW);
+ inode->i_state &= ~I_WILL_FREE;
+ inodes_stat.nr_unused--;
+ hlist_del_init(&inode->i_hash);
+ }
+ list_del_init(&inode->i_list);
+ list_del_init(&inode->i_sb_list);
++ WARN_ON(inode->i_state & I_NEW);
+ inode->i_state |= I_FREEING;
+ inodes_stat.nr_inodes--;
+ spin_unlock(&inode_lock);
+diff --git a/fs/inotify.c b/fs/inotify.c
+index dae3f28..331f2e8 100644
+--- a/fs/inotify.c
++++ b/fs/inotify.c
+@@ -156,7 +156,7 @@ static int inotify_handle_get_wd(struct inotify_handle *ih,
+ int ret;
+
+ do {
+- if (unlikely(!idr_pre_get(&ih->idr, GFP_KERNEL)))
++ if (unlikely(!idr_pre_get(&ih->idr, GFP_NOFS)))
+ return -ENOSPC;
+ ret = idr_get_new_above(&ih->idr, watch, ih->last_wd+1, &watch->wd);
+ } while (ret == -EAGAIN);
+diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
+index e70d657..a8fb64d 100644
+--- a/fs/jbd2/journal.c
++++ b/fs/jbd2/journal.c
+@@ -430,7 +430,7 @@ int __jbd2_log_space_left(journal_t *journal)
+ }
+
+ /*
+- * Called under j_state_lock. Returns true if a transaction was started.
++ * Called under j_state_lock. Returns true if a transaction commit was started.
+ */
+ int __jbd2_log_start_commit(journal_t *journal, tid_t target)
+ {
+@@ -498,7 +498,8 @@ int jbd2_journal_force_commit_nested(journal_t *journal)
+
+ /*
+ * Start a commit of the current running transaction (if any). Returns true
+- * if a transaction was started, and fills its tid in at *ptid
++ * if a transaction is going to be committed (or is currently already
++ * committing), and fills its tid in at *ptid
+ */
+ int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
+ {
+@@ -508,15 +509,19 @@ int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
+ if (journal->j_running_transaction) {
+ tid_t tid = journal->j_running_transaction->t_tid;
+
+- ret = __jbd2_log_start_commit(journal, tid);
+- if (ret && ptid)
++ __jbd2_log_start_commit(journal, tid);
++ /* There's a running transaction and we've just made sure
++ * it's commit has been scheduled. */
++ if (ptid)
+ *ptid = tid;
+- } else if (journal->j_committing_transaction && ptid) {
++ ret = 1;
++ } else if (journal->j_committing_transaction) {
+ /*
+ * If ext3_write_super() recently started a commit, then we
+ * have to wait for completion of that transaction
+ */
+- *ptid = journal->j_committing_transaction->t_tid;
++ if (ptid)
++ *ptid = journal->j_committing_transaction->t_tid;
+ ret = 1;
+ }
+ spin_unlock(&journal->j_state_lock);
+diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
+index 39b7805..89f63ba 100644
+--- a/fs/jbd2/transaction.c
++++ b/fs/jbd2/transaction.c
+@@ -2050,26 +2050,46 @@ done:
+ }
+
+ /*
+- * This function must be called when inode is journaled in ordered mode
+- * before truncation happens. It starts writeout of truncated part in
+- * case it is in the committing transaction so that we stand to ordered
+- * mode consistency guarantees.
++ * File truncate and transaction commit interact with each other in a
++ * non-trivial way. If a transaction writing data block A is
++ * committing, we cannot discard the data by truncate until we have
++ * written them. Otherwise if we crashed after the transaction with
++ * write has committed but before the transaction with truncate has
++ * committed, we could see stale data in block A. This function is a
++ * helper to solve this problem. It starts writeout of the truncated
++ * part in case it is in the committing transaction.
++ *
++ * Filesystem code must call this function when inode is journaled in
++ * ordered mode before truncation happens and after the inode has been
++ * placed on orphan list with the new inode size. The second condition
++ * avoids the race that someone writes new data and we start
++ * committing the transaction after this function has been called but
++ * before a transaction for truncate is started (and furthermore it
++ * allows us to optimize the case where the addition to orphan list
++ * happens in the same transaction as write --- we don't have to write
++ * any data in such case).
+ */
+-int jbd2_journal_begin_ordered_truncate(struct jbd2_inode *inode,
++int jbd2_journal_begin_ordered_truncate(journal_t *journal,
++ struct jbd2_inode *jinode,
+ loff_t new_size)
+ {
+- journal_t *journal;
+- transaction_t *commit_trans;
++ transaction_t *inode_trans, *commit_trans;
+ int ret = 0;
+
+- if (!inode->i_transaction && !inode->i_next_transaction)
++ /* This is a quick check to avoid locking if not necessary */
++ if (!jinode->i_transaction)
+ goto out;
+- journal = inode->i_transaction->t_journal;
++ /* Locks are here just to force reading of recent values, it is
++ * enough that the transaction was not committing before we started
++ * a transaction adding the inode to orphan list */
+ spin_lock(&journal->j_state_lock);
+ commit_trans = journal->j_committing_transaction;
+ spin_unlock(&journal->j_state_lock);
+- if (inode->i_transaction == commit_trans) {
+- ret = filemap_fdatawrite_range(inode->i_vfs_inode->i_mapping,
++ spin_lock(&journal->j_list_lock);
++ inode_trans = jinode->i_transaction;
++ spin_unlock(&journal->j_list_lock);
++ if (inode_trans == commit_trans) {
++ ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping,
+ new_size, LLONG_MAX);
+ if (ret)
+ jbd2_journal_abort(journal, ret);
+diff --git a/fs/jffs2/readinode.c b/fs/jffs2/readinode.c
+index 6ca08ad..1fc1e92 100644
+--- a/fs/jffs2/readinode.c
++++ b/fs/jffs2/readinode.c
+@@ -220,7 +220,7 @@ static int jffs2_add_tn_to_tree(struct jffs2_sb_info *c,
+ struct jffs2_tmp_dnode_info *tn)
+ {
+ uint32_t fn_end = tn->fn->ofs + tn->fn->size;
+- struct jffs2_tmp_dnode_info *this;
++ struct jffs2_tmp_dnode_info *this, *ptn;
+
+ dbg_readinode("insert fragment %#04x-%#04x, ver %u at %08x\n", tn->fn->ofs, fn_end, tn->version, ref_offset(tn->fn->raw));
+
+@@ -251,11 +251,18 @@ static int jffs2_add_tn_to_tree(struct jffs2_sb_info *c,
+ if (this) {
+ /* If the node is coincident with another at a lower address,
+ back up until the other node is found. It may be relevant */
+- while (this->overlapped)
+- this = tn_prev(this);
+-
+- /* First node should never be marked overlapped */
+- BUG_ON(!this);
++ while (this->overlapped) {
++ ptn = tn_prev(this);
++ if (!ptn) {
++ /*
++ * We killed a node which set the overlapped
++ * flags during the scan. Fix it up.
++ */
++ this->overlapped = 0;
++ break;
++ }
++ this = ptn;
++ }
+ dbg_readinode("'this' found %#04x-%#04x (%s)\n", this->fn->ofs, this->fn->ofs + this->fn->size, this->fn ? "data" : "hole");
+ }
+
+@@ -360,7 +367,17 @@ static int jffs2_add_tn_to_tree(struct jffs2_sb_info *c,
+ }
+ if (!this->overlapped)
+ break;
+- this = tn_prev(this);
++
++ ptn = tn_prev(this);
++ if (!ptn) {
++ /*
++ * We killed a node which set the overlapped
++ * flags during the scan. Fix it up.
++ */
++ this->overlapped = 0;
++ break;
++ }
++ this = ptn;
+ }
+ }
+
+@@ -456,8 +473,15 @@ static int jffs2_build_inode_fragtree(struct jffs2_sb_info *c,
+ eat_last(&rii->tn_root, &last->rb);
+ ver_insert(&ver_root, last);
+
+- if (unlikely(last->overlapped))
+- continue;
++ if (unlikely(last->overlapped)) {
++ if (pen)
++ continue;
++ /*
++ * We killed a node which set the overlapped
++ * flags during the scan. Fix it up.
++ */
++ last->overlapped = 0;
++ }
+
+ /* Now we have a bunch of nodes in reverse version
+ order, in the tree at ver_root. Most of the time,
+diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
+index d4d14e9..3657926 100644
+--- a/fs/ocfs2/journal.h
++++ b/fs/ocfs2/journal.h
+@@ -445,8 +445,10 @@ static inline int ocfs2_jbd2_file_inode(handle_t *handle, struct inode *inode)
+ static inline int ocfs2_begin_ordered_truncate(struct inode *inode,
+ loff_t new_size)
+ {
+- return jbd2_journal_begin_ordered_truncate(&OCFS2_I(inode)->ip_jinode,
+- new_size);
++ return jbd2_journal_begin_ordered_truncate(
++ OCFS2_SB(inode->i_sb)->journal->j_journal,
++ &OCFS2_I(inode)->ip_jinode,
++ new_size);
+ }
+
+ #endif /* OCFS2_JOURNAL_H */
+diff --git a/fs/pipe.c b/fs/pipe.c
+index 47b34d2..01f8b78 100644
+--- a/fs/pipe.c
++++ b/fs/pipe.c
+@@ -699,12 +699,12 @@ pipe_rdwr_fasync(int fd, struct file *filp, int on)
+ int retval;
+
+ mutex_lock(&inode->i_mutex);
+-
+ retval = fasync_helper(fd, filp, on, &pipe->fasync_readers);
+-
+- if (retval >= 0)
++ if (retval >= 0) {
+ retval = fasync_helper(fd, filp, on, &pipe->fasync_writers);
+-
++ if (retval < 0) /* this can happen only if on == T */
++ fasync_helper(-1, filp, 0, &pipe->fasync_readers);
++ }
+ mutex_unlock(&inode->i_mutex);
+
+ if (retval < 0)
+diff --git a/fs/proc/page.c b/fs/proc/page.c
+index 767d95a..e998383 100644
+--- a/fs/proc/page.c
++++ b/fs/proc/page.c
+@@ -80,7 +80,7 @@ static const struct file_operations proc_kpagecount_operations = {
+ #define KPF_RECLAIM 9
+ #define KPF_BUDDY 10
+
+-#define kpf_copy_bit(flags, srcpos, dstpos) (((flags >> srcpos) & 1) << dstpos)
++#define kpf_copy_bit(flags, dstpos, srcpos) (((flags >> srcpos) & 1) << dstpos)
+
+ static ssize_t kpageflags_read(struct file *file, char __user *buf,
+ size_t count, loff_t *ppos)
+@@ -107,7 +107,7 @@ static ssize_t kpageflags_read(struct file *file, char __user *buf,
+ else
+ kflags = ppage->flags;
+
+- uflags = kpf_copy_bit(KPF_LOCKED, PG_locked, kflags) |
++ uflags = kpf_copy_bit(kflags, KPF_LOCKED, PG_locked) |
+ kpf_copy_bit(kflags, KPF_ERROR, PG_error) |
+ kpf_copy_bit(kflags, KPF_REFERENCED, PG_referenced) |
+ kpf_copy_bit(kflags, KPF_UPTODATE, PG_uptodate) |
+diff --git a/fs/seq_file.c b/fs/seq_file.c
+index 3404ec8..a3a61f9 100644
+--- a/fs/seq_file.c
++++ b/fs/seq_file.c
+@@ -48,8 +48,16 @@ int seq_open(struct file *file, const struct seq_operations *op)
+ */
+ file->f_version = 0;
+
+- /* SEQ files support lseek, but not pread/pwrite */
+- file->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
++ /*
++ * seq_files support lseek() and pread(). They do not implement
++ * write() at all, but we clear FMODE_PWRITE here for historical
++ * reasons.
++ *
++ * If a client of seq_files a) implements file.write() and b) wishes to
++ * support pwrite() then that client will need to implement its own
++ * file.open() which calls seq_open() and then sets FMODE_PWRITE.
++ */
++ file->f_mode &= ~FMODE_PWRITE;
+ return 0;
+ }
+ EXPORT_SYMBOL(seq_open);
+@@ -131,6 +139,22 @@ ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
+ int err = 0;
+
+ mutex_lock(&m->lock);
++
++ /* Don't assume *ppos is where we left it */
++ if (unlikely(*ppos != m->read_pos)) {
++ m->read_pos = *ppos;
++ while ((err = traverse(m, *ppos)) == -EAGAIN)
++ ;
++ if (err) {
++ /* With prejudice... */
++ m->read_pos = 0;
++ m->version = 0;
++ m->index = 0;
++ m->count = 0;
++ goto Done;
++ }
++ }
++
+ /*
+ * seq_file->op->..m_start/m_stop/m_next may do special actions
+ * or optimisations based on the file->f_version, so we want to
+@@ -230,8 +254,10 @@ Fill:
+ Done:
+ if (!copied)
+ copied = err;
+- else
++ else {
+ *ppos += copied;
++ m->read_pos += copied;
++ }
+ file->f_version = m->version;
+ mutex_unlock(&m->lock);
+ return copied;
+@@ -266,16 +292,18 @@ loff_t seq_lseek(struct file *file, loff_t offset, int origin)
+ if (offset < 0)
+ break;
+ retval = offset;
+- if (offset != file->f_pos) {
++ if (offset != m->read_pos) {
+ while ((retval=traverse(m, offset)) == -EAGAIN)
+ ;
+ if (retval) {
+ /* with extreme prejudice... */
+ file->f_pos = 0;
++ m->read_pos = 0;
+ m->version = 0;
+ m->index = 0;
+ m->count = 0;
+ } else {
++ m->read_pos = offset;
+ retval = file->f_pos = offset;
+ }
+ }
+diff --git a/fs/timerfd.c b/fs/timerfd.c
+index 6a123b8..b042bd7 100644
+--- a/fs/timerfd.c
++++ b/fs/timerfd.c
+@@ -186,10 +186,9 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags)
+ BUILD_BUG_ON(TFD_CLOEXEC != O_CLOEXEC);
+ BUILD_BUG_ON(TFD_NONBLOCK != O_NONBLOCK);
+
+- if (flags & ~(TFD_CLOEXEC | TFD_NONBLOCK))
+- return -EINVAL;
+- if (clockid != CLOCK_MONOTONIC &&
+- clockid != CLOCK_REALTIME)
++ if ((flags & ~TFD_CREATE_FLAGS) ||
++ (clockid != CLOCK_MONOTONIC &&
++ clockid != CLOCK_REALTIME))
+ return -EINVAL;
+
+ ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
+@@ -201,7 +200,7 @@ SYSCALL_DEFINE2(timerfd_create, int, clockid, int, flags)
+ hrtimer_init(&ctx->tmr, clockid, HRTIMER_MODE_ABS);
+
+ ufd = anon_inode_getfd("[timerfd]", &timerfd_fops, ctx,
+- flags & (O_CLOEXEC | O_NONBLOCK));
++ flags & TFD_SHARED_FCNTL_FLAGS);
+ if (ufd < 0)
+ kfree(ctx);
+
+@@ -219,7 +218,8 @@ SYSCALL_DEFINE4(timerfd_settime, int, ufd, int, flags,
+ if (copy_from_user(&ktmr, utmr, sizeof(ktmr)))
+ return -EFAULT;
+
+- if (!timespec_valid(&ktmr.it_value) ||
++ if ((flags & ~TFD_SETTIME_FLAGS) ||
++ !timespec_valid(&ktmr.it_value) ||
+ !timespec_valid(&ktmr.it_interval))
+ return -EINVAL;
+
+diff --git a/include/drm/i915_drm.h b/include/drm/i915_drm.h
+index 152b34d..4986239 100644
+--- a/include/drm/i915_drm.h
++++ b/include/drm/i915_drm.h
+@@ -177,6 +177,8 @@ typedef struct _drm_i915_sarea {
+ #define DRM_IOCTL_I915_SET_VBLANK_PIPE DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
+ #define DRM_IOCTL_I915_GET_VBLANK_PIPE DRM_IOR( DRM_COMMAND_BASE + DRM_I915_GET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
+ #define DRM_IOCTL_I915_VBLANK_SWAP DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_VBLANK_SWAP, drm_i915_vblank_swap_t)
++#define DRM_IOCTL_I915_GEM_INIT DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_INIT, struct drm_i915_gem_init)
++#define DRM_IOCTL_I915_GEM_EXECBUFFER DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_EXECBUFFER, struct drm_i915_gem_execbuffer)
+ #define DRM_IOCTL_I915_GEM_PIN DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_PIN, struct drm_i915_gem_pin)
+ #define DRM_IOCTL_I915_GEM_UNPIN DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_UNPIN, struct drm_i915_gem_unpin)
+ #define DRM_IOCTL_I915_GEM_BUSY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_BUSY, struct drm_i915_gem_busy)
+diff --git a/include/linux/fs.h b/include/linux/fs.h
+index 4b91924..7e413d3 100644
+--- a/include/linux/fs.h
++++ b/include/linux/fs.h
+@@ -63,24 +63,30 @@ extern int dir_notify_enable;
+ #define MAY_ACCESS 16
+ #define MAY_OPEN 32
+
++/*
++ * flags in file.f_mode. Note that FMODE_READ and FMODE_WRITE must correspond
++ * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
++ */
++
+ /* file is open for reading */
+ #define FMODE_READ ((__force fmode_t)1)
+ /* file is open for writing */
+ #define FMODE_WRITE ((__force fmode_t)2)
+ /* file is seekable */
+ #define FMODE_LSEEK ((__force fmode_t)4)
+-/* file can be accessed using pread/pwrite */
++/* file can be accessed using pread */
+ #define FMODE_PREAD ((__force fmode_t)8)
+-#define FMODE_PWRITE FMODE_PREAD /* These go hand in hand */
++/* file can be accessed using pwrite */
++#define FMODE_PWRITE ((__force fmode_t)16)
+ /* File is opened for execution with sys_execve / sys_uselib */
+-#define FMODE_EXEC ((__force fmode_t)16)
++#define FMODE_EXEC ((__force fmode_t)32)
+ /* File is opened with O_NDELAY (only set for block devices) */
+-#define FMODE_NDELAY ((__force fmode_t)32)
++#define FMODE_NDELAY ((__force fmode_t)64)
+ /* File is opened with O_EXCL (only set for block devices) */
+-#define FMODE_EXCL ((__force fmode_t)64)
++#define FMODE_EXCL ((__force fmode_t)128)
+ /* File is opened using open(.., 3, ..) and is writeable only for ioctls
+ (specialy hack for floppy.c) */
+-#define FMODE_WRITE_IOCTL ((__force fmode_t)128)
++#define FMODE_WRITE_IOCTL ((__force fmode_t)256)
+
+ #define RW_MASK 1
+ #define RWA_MASK 2
+diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
+index 7c31d67..56593cb 100644
+--- a/include/linux/jbd2.h
++++ b/include/linux/jbd2.h
+@@ -1087,7 +1087,8 @@ extern int jbd2_journal_clear_err (journal_t *);
+ extern int jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
+ extern int jbd2_journal_force_commit(journal_t *);
+ extern int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
+-extern int jbd2_journal_begin_ordered_truncate(struct jbd2_inode *inode, loff_t new_size);
++extern int jbd2_journal_begin_ordered_truncate(journal_t *journal,
++ struct jbd2_inode *inode, loff_t new_size);
+ extern void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode);
+ extern void jbd2_journal_release_jbd_inode(journal_t *journal, struct jbd2_inode *jinode);
+
+diff --git a/include/linux/mm.h b/include/linux/mm.h
+index 86b836d..5c7f5f5 100644
+--- a/include/linux/mm.h
++++ b/include/linux/mm.h
+@@ -1027,10 +1027,23 @@ extern void free_bootmem_with_active_regions(int nid,
+ typedef int (*work_fn_t)(unsigned long, unsigned long, void *);
+ extern void work_with_active_regions(int nid, work_fn_t work_fn, void *data);
+ extern void sparse_memory_present_with_active_regions(int nid);
+-#ifndef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
+-extern int early_pfn_to_nid(unsigned long pfn);
+-#endif /* CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID */
+ #endif /* CONFIG_ARCH_POPULATES_NODE_MAP */
++
++#if !defined(CONFIG_ARCH_POPULATES_NODE_MAP) && \
++ !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID)
++static inline int __early_pfn_to_nid(unsigned long pfn)
++{
++ return 0;
++}
++#else
++/* please see mm/page_alloc.c */
++extern int __meminit early_pfn_to_nid(unsigned long pfn);
++#ifdef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
++/* there is a per-arch backend function. */
++extern int __meminit __early_pfn_to_nid(unsigned long pfn);
++#endif /* CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID */
++#endif
++
+ extern void set_dma_reserve(unsigned long new_dma_reserve);
+ extern void memmap_init_zone(unsigned long, int, unsigned long,
+ unsigned long, enum memmap_context);
+diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
+index 35a7b5e..796f1e5 100644
+--- a/include/linux/mmzone.h
++++ b/include/linux/mmzone.h
+@@ -1067,7 +1067,7 @@ void sparse_init(void);
+ #endif /* CONFIG_SPARSEMEM */
+
+ #ifdef CONFIG_NODES_SPAN_OTHER_NODES
+-#define early_pfn_in_nid(pfn, nid) (early_pfn_to_nid(pfn) == (nid))
++bool early_pfn_in_nid(unsigned long pfn, int nid);
+ #else
+ #define early_pfn_in_nid(pfn, nid) (1)
+ #endif
+diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
+index c525afc..d81bc13 100644
+--- a/include/linux/pci_ids.h
++++ b/include/linux/pci_ids.h
+@@ -1445,6 +1445,7 @@
+ #define PCI_DEVICE_ID_DIGI_DF_M_E 0x0071
+ #define PCI_DEVICE_ID_DIGI_DF_M_IOM2_A 0x0072
+ #define PCI_DEVICE_ID_DIGI_DF_M_A 0x0073
++#define PCI_DEVICE_ID_DIGI_NEO_8 0x00B1
+ #define PCI_DEVICE_ID_NEO_2DB9 0x00C8
+ #define PCI_DEVICE_ID_NEO_2DB9PRI 0x00C9
+ #define PCI_DEVICE_ID_NEO_2RJ45 0x00CA
+@@ -2317,6 +2318,9 @@
+ #define PCI_DEVICE_ID_INTEL_82378 0x0484
+ #define PCI_DEVICE_ID_INTEL_I960 0x0960
+ #define PCI_DEVICE_ID_INTEL_I960RM 0x0962
++#define PCI_DEVICE_ID_INTEL_8257X_SOL 0x1062
++#define PCI_DEVICE_ID_INTEL_82573E_SOL 0x1085
++#define PCI_DEVICE_ID_INTEL_82573L_SOL 0x108F
+ #define PCI_DEVICE_ID_INTEL_82815_MC 0x1130
+ #define PCI_DEVICE_ID_INTEL_82815_CGC 0x1132
+ #define PCI_DEVICE_ID_INTEL_82092AA_0 0x1221
+diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
+index dc50bcc..cbb25fc 100644
+--- a/include/linux/seq_file.h
++++ b/include/linux/seq_file.h
+@@ -19,6 +19,7 @@ struct seq_file {
+ size_t from;
+ size_t count;
+ loff_t index;
++ loff_t read_pos;
+ u64 version;
+ struct mutex lock;
+ const struct seq_operations *op;
+diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
+index 4e4f127..a551e97 100644
+--- a/include/linux/serial_core.h
++++ b/include/linux/serial_core.h
+@@ -288,6 +288,7 @@ struct uart_port {
+ #define UPF_HARDPPS_CD ((__force upf_t) (1 << 11))
+ #define UPF_LOW_LATENCY ((__force upf_t) (1 << 13))
+ #define UPF_BUGGY_UART ((__force upf_t) (1 << 14))
++#define UPF_NO_TXEN_TEST ((__force upf_t) (1 << 15))
+ #define UPF_MAGIC_MULTIPLIER ((__force upf_t) (1 << 16))
+ #define UPF_CONS_FLOW ((__force upf_t) (1 << 23))
+ #define UPF_SHARE_IRQ ((__force upf_t) (1 << 24))
+diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
+index 2725f4e..37af3d5 100644
+--- a/include/linux/skbuff.h
++++ b/include/linux/skbuff.h
+@@ -411,15 +411,6 @@ extern void skb_over_panic(struct sk_buff *skb, int len,
+ void *here);
+ extern void skb_under_panic(struct sk_buff *skb, int len,
+ void *here);
+-extern void skb_truesize_bug(struct sk_buff *skb);
+-
+-static inline void skb_truesize_check(struct sk_buff *skb)
+-{
+- int len = sizeof(struct sk_buff) + skb->len;
+-
+- if (unlikely((int)skb->truesize < len))
+- skb_truesize_bug(skb);
+-}
+
+ extern int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
+ int getfrag(void *from, char *to, int offset,
+diff --git a/include/linux/timerfd.h b/include/linux/timerfd.h
+index 86cb050..2d07929 100644
+--- a/include/linux/timerfd.h
++++ b/include/linux/timerfd.h
+@@ -11,13 +11,21 @@
+ /* For O_CLOEXEC and O_NONBLOCK */
+ #include <linux/fcntl.h>
+
+-/* Flags for timerfd_settime. */
++/*
++ * CAREFUL: Check include/asm-generic/fcntl.h when defining
++ * new flags, since they might collide with O_* ones. We want
++ * to re-use O_* flags that couldn't possibly have a meaning
++ * from eventfd, in order to leave a free define-space for
++ * shared O_* flags.
++ */
+ #define TFD_TIMER_ABSTIME (1 << 0)
+-
+-/* Flags for timerfd_create. */
+ #define TFD_CLOEXEC O_CLOEXEC
+ #define TFD_NONBLOCK O_NONBLOCK
+
++#define TFD_SHARED_FCNTL_FLAGS (TFD_CLOEXEC | TFD_NONBLOCK)
++/* Flags for timerfd_create. */
++#define TFD_CREATE_FLAGS TFD_SHARED_FCNTL_FLAGS
++/* Flags for timerfd_settime. */
++#define TFD_SETTIME_FLAGS TFD_TIMER_ABSTIME
+
+ #endif /* _LINUX_TIMERFD_H */
+-
+diff --git a/include/net/sock.h b/include/net/sock.h
+index 2f47107..4ae672f 100644
+--- a/include/net/sock.h
++++ b/include/net/sock.h
+@@ -784,7 +784,6 @@ static inline void sk_mem_uncharge(struct sock *sk, int size)
+
+ static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
+ {
+- skb_truesize_check(skb);
+ sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
+ sk->sk_wmem_queued -= skb->truesize;
+ sk_mem_uncharge(sk, skb->truesize);
+diff --git a/kernel/fork.c b/kernel/fork.c
+index f2c9c60..8f753e5 100644
+--- a/kernel/fork.c
++++ b/kernel/fork.c
+@@ -1176,10 +1176,6 @@ static struct task_struct *copy_process(unsigned long clone_flags,
+ #endif
+ clear_all_latency_tracing(p);
+
+- /* Our parent execution domain becomes current domain
+- These must match for thread signalling to apply */
+- p->parent_exec_id = p->self_exec_id;
+-
+ /* ok, now we should be set up.. */
+ p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL);
+ p->pdeath_signal = 0;
+@@ -1217,10 +1213,13 @@ static struct task_struct *copy_process(unsigned long clone_flags,
+ set_task_cpu(p, smp_processor_id());
+
+ /* CLONE_PARENT re-uses the old parent */
+- if (clone_flags & (CLONE_PARENT|CLONE_THREAD))
++ if (clone_flags & (CLONE_PARENT|CLONE_THREAD)) {
+ p->real_parent = current->real_parent;
+- else
++ p->parent_exec_id = current->parent_exec_id;
++ } else {
+ p->real_parent = current;
++ p->parent_exec_id = current->self_exec_id;
++ }
+
+ spin_lock(¤t->sighand->siglock);
+
+diff --git a/kernel/seccomp.c b/kernel/seccomp.c
+index ad64fcb..57d4b13 100644
+--- a/kernel/seccomp.c
++++ b/kernel/seccomp.c
+@@ -8,6 +8,7 @@
+
+ #include <linux/seccomp.h>
+ #include <linux/sched.h>
++#include <linux/compat.h>
+
+ /* #define SECCOMP_DEBUG 1 */
+ #define NR_SECCOMP_MODES 1
+@@ -22,7 +23,7 @@ static int mode1_syscalls[] = {
+ 0, /* null terminated */
+ };
+
+-#ifdef TIF_32BIT
++#ifdef CONFIG_COMPAT
+ static int mode1_syscalls_32[] = {
+ __NR_seccomp_read_32, __NR_seccomp_write_32, __NR_seccomp_exit_32, __NR_seccomp_sigreturn_32,
+ 0, /* null terminated */
+@@ -37,8 +38,8 @@ void __secure_computing(int this_syscall)
+ switch (mode) {
+ case 1:
+ syscall = mode1_syscalls;
+-#ifdef TIF_32BIT
+- if (test_thread_flag(TIF_32BIT))
++#ifdef CONFIG_COMPAT
++ if (is_compat_task())
+ syscall = mode1_syscalls_32;
+ #endif
+ do {
+diff --git a/kernel/tsacct.c b/kernel/tsacct.c
+index 8ebcd85..5275fba 100644
+--- a/kernel/tsacct.c
++++ b/kernel/tsacct.c
+@@ -120,8 +120,10 @@ void acct_update_integrals(struct task_struct *tsk)
+ if (likely(tsk->mm)) {
+ cputime_t time, dtime;
+ struct timeval value;
++ unsigned long flags;
+ u64 delta;
+
++ local_irq_save(flags);
+ time = tsk->stime + tsk->utime;
+ dtime = cputime_sub(time, tsk->acct_timexpd);
+ jiffies_to_timeval(cputime_to_jiffies(dtime), &value);
+@@ -129,10 +131,12 @@ void acct_update_integrals(struct task_struct *tsk)
+ delta = delta * USEC_PER_SEC + value.tv_usec;
+
+ if (delta == 0)
+- return;
++ goto out;
+ tsk->acct_timexpd = time;
+ tsk->acct_rss_mem1 += delta * get_mm_rss(tsk->mm);
+ tsk->acct_vm_mem1 += delta * tsk->mm->total_vm;
++ out:
++ local_irq_restore(flags);
+ }
+ }
+
+diff --git a/mm/page_alloc.c b/mm/page_alloc.c
+index d8ac014..566ee21 100644
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -2974,7 +2974,7 @@ static int __meminit next_active_region_index_in_nid(int index, int nid)
+ * was used and there are no special requirements, this is a convenient
+ * alternative
+ */
+-int __meminit early_pfn_to_nid(unsigned long pfn)
++int __meminit __early_pfn_to_nid(unsigned long pfn)
+ {
+ int i;
+
+@@ -2985,10 +2985,33 @@ int __meminit early_pfn_to_nid(unsigned long pfn)
+ if (start_pfn <= pfn && pfn < end_pfn)
+ return early_node_map[i].nid;
+ }
++ /* This is a memory hole */
++ return -1;
++}
++#endif /* CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID */
++
++int __meminit early_pfn_to_nid(unsigned long pfn)
++{
++ int nid;
+
++ nid = __early_pfn_to_nid(pfn);
++ if (nid >= 0)
++ return nid;
++ /* just returns 0 */
+ return 0;
+ }
+-#endif /* CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID */
++
++#ifdef CONFIG_NODES_SPAN_OTHER_NODES
++bool __meminit early_pfn_in_nid(unsigned long pfn, int node)
++{
++ int nid;
++
++ nid = __early_pfn_to_nid(pfn);
++ if (nid >= 0 && nid != node)
++ return false;
++ return true;
++}
++#endif
+
+ /* Basic iterator support to walk early_node_map[] */
+ #define for_each_active_range_index_in_nid(i, nid) \
+diff --git a/mm/vmalloc.c b/mm/vmalloc.c
+index 0380ea5..4172ce4 100644
+--- a/mm/vmalloc.c
++++ b/mm/vmalloc.c
+@@ -323,6 +323,7 @@ static struct vmap_area *alloc_vmap_area(unsigned long size,
+ unsigned long addr;
+ int purged = 0;
+
++ BUG_ON(!size);
+ BUG_ON(size & ~PAGE_MASK);
+
+ va = kmalloc_node(sizeof(struct vmap_area),
+@@ -334,6 +335,9 @@ retry:
+ addr = ALIGN(vstart, align);
+
+ spin_lock(&vmap_area_lock);
++ if (addr + size - 1 < addr)
++ goto overflow;
++
+ /* XXX: could have a last_hole cache */
+ n = vmap_area_root.rb_node;
+ if (n) {
+@@ -365,6 +369,8 @@ retry:
+
+ while (addr + size > first->va_start && addr + size <= vend) {
+ addr = ALIGN(first->va_end + PAGE_SIZE, align);
++ if (addr + size - 1 < addr)
++ goto overflow;
+
+ n = rb_next(&first->rb_node);
+ if (n)
+@@ -375,6 +381,7 @@ retry:
+ }
+ found:
+ if (addr + size > vend) {
++overflow:
+ spin_unlock(&vmap_area_lock);
+ if (!purged) {
+ purge_vmap_area_lazy();
+@@ -476,6 +483,7 @@ static void __purge_vmap_area_lazy(unsigned long *start, unsigned long *end,
+ static DEFINE_SPINLOCK(purge_lock);
+ LIST_HEAD(valist);
+ struct vmap_area *va;
++ struct vmap_area *n_va;
+ int nr = 0;
+
+ /*
+@@ -515,7 +523,7 @@ static void __purge_vmap_area_lazy(unsigned long *start, unsigned long *end,
+
+ if (nr) {
+ spin_lock(&vmap_area_lock);
+- list_for_each_entry(va, &valist, purge_list)
++ list_for_each_entry_safe(va, n_va, &valist, purge_list)
+ __free_vmap_area(va);
+ spin_unlock(&vmap_area_lock);
+ }
+@@ -989,6 +997,8 @@ void __init vmalloc_init(void)
+ void unmap_kernel_range(unsigned long addr, unsigned long size)
+ {
+ unsigned long end = addr + size;
++
++ flush_cache_vunmap(addr, end);
+ vunmap_page_range(addr, end);
+ flush_tlb_kernel_range(addr, end);
+ }
+diff --git a/net/core/skbuff.c b/net/core/skbuff.c
+index d61aa52..aa89c30 100644
+--- a/net/core/skbuff.c
++++ b/net/core/skbuff.c
+@@ -143,14 +143,6 @@ void skb_under_panic(struct sk_buff *skb, int sz, void *here)
+ BUG();
+ }
+
+-void skb_truesize_bug(struct sk_buff *skb)
+-{
+- WARN(net_ratelimit(), KERN_ERR "SKB BUG: Invalid truesize (%u) "
+- "len=%u, sizeof(sk_buff)=%Zd\n",
+- skb->truesize, skb->len, sizeof(struct sk_buff));
+-}
+-EXPORT_SYMBOL(skb_truesize_bug);
+-
+ /* Allocate a new skbuff. We do this ourselves so we can fill in a few
+ * 'private' fields and also do memory statistics to find all the
+ * [BEEP] leaks.
+diff --git a/net/core/sock.c b/net/core/sock.c
+index a7a0975..1b0f74c 100644
+--- a/net/core/sock.c
++++ b/net/core/sock.c
+@@ -696,7 +696,7 @@ int sock_getsockopt(struct socket *sock, int level, int optname,
+ if (len < 0)
+ return -EINVAL;
+
+- v.val = 0;
++ memset(&v, 0, sizeof(v));
+
+ switch(optname) {
+ case SO_DEBUG:
+@@ -1137,7 +1137,6 @@ void sock_rfree(struct sk_buff *skb)
+ {
+ struct sock *sk = skb->sk;
+
+- skb_truesize_check(skb);
+ atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
+ sk_mem_uncharge(skb->sk, skb->truesize);
+ }
+diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
+index d4dc222..0d34372 100644
+--- a/scripts/mod/file2alias.c
++++ b/scripts/mod/file2alias.c
+@@ -210,6 +210,7 @@ static void do_usb_table(void *symval, unsigned long size,
+ static int do_hid_entry(const char *filename,
+ struct hid_device_id *id, char *alias)
+ {
++ id->bus = TO_NATIVE(id->bus);
+ id->vendor = TO_NATIVE(id->vendor);
+ id->product = TO_NATIVE(id->product);
+
+diff --git a/security/selinux/netlabel.c b/security/selinux/netlabel.c
+index f58701a..350794a 100644
+--- a/security/selinux/netlabel.c
++++ b/security/selinux/netlabel.c
+@@ -386,11 +386,12 @@ int selinux_netlbl_inode_permission(struct inode *inode, int mask)
+ if (!S_ISSOCK(inode->i_mode) ||
+ ((mask & (MAY_WRITE | MAY_APPEND)) == 0))
+ return 0;
+-
+ sock = SOCKET_I(inode);
+ sk = sock->sk;
++ if (sk == NULL)
++ return 0;
+ sksec = sk->sk_security;
+- if (sksec->nlbl_state != NLBL_REQUIRE)
++ if (sksec == NULL || sksec->nlbl_state != NLBL_REQUIRE)
+ return 0;
+
+ local_bh_disable();
+@@ -490,8 +491,10 @@ int selinux_netlbl_socket_setsockopt(struct socket *sock,
+ lock_sock(sk);
+ rc = netlbl_sock_getattr(sk, &secattr);
+ release_sock(sk);
+- if (rc == 0 && secattr.flags != NETLBL_SECATTR_NONE)
++ if (rc == 0)
+ rc = -EACCES;
++ else if (rc == -ENOMSG)
++ rc = 0;
+ netlbl_secattr_destroy(&secattr);
+ }
+
+diff --git a/sound/core/oss/rate.c b/sound/core/oss/rate.c
+index a466443..2fa9299 100644
+--- a/sound/core/oss/rate.c
++++ b/sound/core/oss/rate.c
+@@ -157,7 +157,7 @@ static void resample_shrink(struct snd_pcm_plugin *plugin,
+ while (dst_frames1 > 0) {
+ S1 = S2;
+ if (src_frames1-- > 0) {
+- S1 = *src;
++ S2 = *src;
+ src += src_step;
+ }
+ if (pos & ~R_MASK) {
+diff --git a/sound/pci/aw2/aw2-alsa.c b/sound/pci/aw2/aw2-alsa.c
+index 3f00ddf..c7c54e7 100644
+--- a/sound/pci/aw2/aw2-alsa.c
++++ b/sound/pci/aw2/aw2-alsa.c
+@@ -165,7 +165,7 @@ module_param_array(enable, bool, NULL, 0444);
+ MODULE_PARM_DESC(enable, "Enable Audiowerk2 soundcard.");
+
+ static struct pci_device_id snd_aw2_ids[] = {
+- {PCI_VENDOR_ID_SAA7146, PCI_DEVICE_ID_SAA7146, PCI_ANY_ID, PCI_ANY_ID,
++ {PCI_VENDOR_ID_SAA7146, PCI_DEVICE_ID_SAA7146, 0, 0,
+ 0, 0, 0},
+ {0}
+ };
+diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
+index 4c8961a..7123a6e 100644
+--- a/sound/pci/hda/patch_realtek.c
++++ b/sound/pci/hda/patch_realtek.c
+@@ -6778,6 +6778,7 @@ static int patch_alc882(struct hda_codec *codec)
+ case 0x106b2800: /* AppleTV */
+ board_config = ALC885_IMAC24;
+ break;
++ case 0x106b00a0: /* MacBookPro3,1 - Another revision */
+ case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
+ case 0x106b00a4: /* MacbookPro4,1 */
+ case 0x106b2c00: /* Macbook Pro rev3 */
+diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
+index 1f9fcfe..96f4c8d 100644
+--- a/sound/pci/hda/patch_sigmatel.c
++++ b/sound/pci/hda/patch_sigmatel.c
+@@ -4668,7 +4668,7 @@ again:
+ case STAC_DELL_M4_3:
+ spec->num_dmics = 1;
+ spec->num_smuxes = 0;
+- spec->num_dmuxes = 0;
++ spec->num_dmuxes = 1;
+ break;
+ default:
+ spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
+diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c
+index a962166..d74cc25 100644
+--- a/sound/pci/oxygen/virtuoso.c
++++ b/sound/pci/oxygen/virtuoso.c
+@@ -26,7 +26,7 @@
+ * SPI 0 -> 1st PCM1796 (front)
+ * SPI 1 -> 2nd PCM1796 (surround)
+ * SPI 2 -> 3rd PCM1796 (center/LFE)
+- * SPI 4 -> 4th PCM1796 (back) and EEPROM self-destruct (do not use!)
++ * SPI 4 -> 4th PCM1796 (back)
+ *
+ * GPIO 2 -> M0 of CS5381
+ * GPIO 3 -> M1 of CS5381
+@@ -207,12 +207,6 @@ static void xonar_gpio_changed(struct oxygen *chip);
+ static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
+ u8 reg, u8 value)
+ {
+- /*
+- * We don't want to do writes on SPI 4 because the EEPROM, which shares
+- * the same pin, might get confused and broken. We'd better take care
+- * that the driver works with the default register values ...
+- */
+-#if 0
+ /* maps ALSA channel pair number to SPI output */
+ static const u8 codec_map[4] = {
+ 0, 1, 2, 4
+@@ -223,7 +217,6 @@ static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
+ (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
+ OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
+ (reg << 8) | value);
+-#endif
+ }
+
+ static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec,
+@@ -757,9 +750,6 @@ static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -12700, 100, 0);
+
+ static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
+ {
+- if (!strncmp(template->name, "Master Playback ", 16))
+- /* disable volume/mute because they would require SPI writes */
+- return 1;
+ if (!strncmp(template->name, "CD Capture ", 11))
+ /* CD in is actually connected to the video in pin */
+ template->private_value ^= AC97_CD ^ AC97_VIDEO;
+@@ -850,8 +840,9 @@ static const struct oxygen_model model_xonar_d2 = {
+ .dac_volume_min = 0x0f,
+ .dac_volume_max = 0xff,
+ .misc_flags = OXYGEN_MISC_MIDI,
+- .function_flags = OXYGEN_FUNCTION_SPI,
+- .dac_i2s_format = OXYGEN_I2S_FORMAT_I2S,
++ .function_flags = OXYGEN_FUNCTION_SPI |
++ OXYGEN_FUNCTION_ENABLE_SPI_4_5,
++ .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+ .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+ };
+
+diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
+index f44c153..a51190e 100644
+--- a/sound/usb/usbaudio.c
++++ b/sound/usb/usbaudio.c
+@@ -2524,7 +2524,6 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform
+ * build the rate table and bitmap flags
+ */
+ int r, idx;
+- unsigned int nonzero_rates = 0;
+
+ fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
+ if (fp->rate_table == NULL) {
+@@ -2532,24 +2531,27 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform
+ return -1;
+ }
+
+- fp->nr_rates = nr_rates;
+- fp->rate_min = fp->rate_max = combine_triple(&fmt[8]);
++ fp->nr_rates = 0;
++ fp->rate_min = fp->rate_max = 0;
+ for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) {
+ unsigned int rate = combine_triple(&fmt[idx]);
++ if (!rate)
++ continue;
+ /* C-Media CM6501 mislabels its 96 kHz altsetting */
+ if (rate == 48000 && nr_rates == 1 &&
+- chip->usb_id == USB_ID(0x0d8c, 0x0201) &&
++ (chip->usb_id == USB_ID(0x0d8c, 0x0201) ||
++ chip->usb_id == USB_ID(0x0d8c, 0x0102)) &&
+ fp->altsetting == 5 && fp->maxpacksize == 392)
+ rate = 96000;
+- fp->rate_table[r] = rate;
+- nonzero_rates |= rate;
+- if (rate < fp->rate_min)
++ fp->rate_table[fp->nr_rates] = rate;
++ if (!fp->rate_min || rate < fp->rate_min)
+ fp->rate_min = rate;
+- else if (rate > fp->rate_max)
++ if (!fp->rate_max || rate > fp->rate_max)
+ fp->rate_max = rate;
+ fp->rates |= snd_pcm_rate_to_rate_bit(rate);
++ fp->nr_rates++;
+ }
+- if (!nonzero_rates) {
++ if (!fp->nr_rates) {
+ hwc_debug("All rates were zero. Skipping format!\n");
+ return -1;
+ }
+diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
+index 5962e4b..343f896 100644
+--- a/sound/usb/usbmidi.c
++++ b/sound/usb/usbmidi.c
+@@ -1628,6 +1628,7 @@ static int snd_usbmidi_create_endpoints_midiman(struct snd_usb_midi* umidi,
+ }
+
+ ep_info.out_ep = get_endpoint(hostif, 2)->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
++ ep_info.out_interval = 0;
+ ep_info.out_cables = endpoint->out_cables & 0x5555;
+ err = snd_usbmidi_out_endpoint_create(umidi, &ep_info, &umidi->endpoints[0]);
+ if (err < 0)
Deleted: genpatches-2.6/trunk/2.6.28/1500_algo-test-race-fix-aead-init.patch
===================================================================
--- genpatches-2.6/trunk/2.6.28/1500_algo-test-race-fix-aead-init.patch 2009-03-15 00:03:13 UTC (rev 1514)
+++ genpatches-2.6/trunk/2.6.28/1500_algo-test-race-fix-aead-init.patch 2009-03-17 12:48:37 UTC (rev 1515)
@@ -1,59 +0,0 @@
-From: Herbert Xu <herbert@gondor.apana.org.au>
-Date: Wed, 28 Jan 2009 03:09:59 +0000 (+1100)
-Subject: crypto: api - Fix algorithm test race that broke aead initialisation
-X-Git-Tag: v2.6.29-rc5~51^2~4
-X-Git-Url: http://git.kernel.org/?p=linux%2Fkernel%2Fgit%2Ftorvalds%2Flinux-2.6.git;a=commitdiff_plain;h=b8e15992b420d09dae831125a623c474c8637cee
-
-crypto: api - Fix algorithm test race that broke aead initialisation
-
-When we complete a test we'll notify everyone waiting on it, drop
-the mutex, and then remove the test larval (after reacquiring the
-mutex). If one of the notified parties tries to register another
-algorithm with the same driver name prior to the removal of the
-test larval, they will fail with EEXIST as only one algorithm of
-a given name can be tested at any time.
-
-This broke the initialisation of aead and givcipher algorithms as
-they will register two algorithms with the same driver name, in
-sequence.
-
-This patch fixes the problem by marking the larval as dead before
-we drop the mutex, and also ignoring all dead or dying algorithms
-on the registration path.
-
-Tested-by: Andreas Steffen <andreas.steffen@strongswan.org>
-Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
----
-
-diff --git a/crypto/algapi.c b/crypto/algapi.c
-index 7c41e74..56c62e2 100644
---- a/crypto/algapi.c
-+++ b/crypto/algapi.c
-@@ -149,6 +149,9 @@ static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg)
- if (q == alg)
- goto err;
-
-+ if (crypto_is_moribund(q))
-+ continue;
-+
- if (crypto_is_larval(q)) {
- if (!strcmp(alg->cra_driver_name, q->cra_driver_name))
- goto err;
-@@ -197,7 +200,7 @@ void crypto_alg_tested(const char *name, int err)
-
- down_write(&crypto_alg_sem);
- list_for_each_entry(q, &crypto_alg_list, cra_list) {
-- if (!crypto_is_larval(q))
-+ if (crypto_is_moribund(q) || !crypto_is_larval(q))
- continue;
-
- test = (struct crypto_larval *)q;
-@@ -210,6 +213,7 @@ void crypto_alg_tested(const char *name, int err)
- goto unlock;
-
- found:
-+ q->cra_flags |= CRYPTO_ALG_DEAD;
- alg = test->adult;
- if (err || list_empty(&alg->cra_list))
- goto complete;
-
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2009-03-17 12:48 UTC | newest]
Thread overview: (only message) (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2009-03-17 12:48 [gentoo-commits] linux-patches r1515 - genpatches-2.6/trunk/2.6.28 Mike Pagano (mpagano)
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox