Merge branch 'upstream'

65 files changed, 689 insertions, 788 deletions

diff --git a/Documentation/powerpc/booting-without-of.txt b/Documentation/powerpc/booting-without-of.txt
index 54e5f9b1536d..d02c64953dcd 100644
--- a/Documentation/powerpc/booting-without-of.txt
+++ b/Documentation/powerpc/booting-without-of.txt
@@ -44,7 +44,6 @@
                            compiler and the textural representation of
                            the tree that can be "compiled" by dtc.
 
-
    November 21, 2005: Rev 0.5
                          - Additions/generalizations for 32-bit
                          - Changed to reflect the new arch/powerpc
@@ -1307,6 +1306,65 @@ platforms are moved over to use the flattened-device-tree model.
         };
 
 
+   f) Freescale SOC USB controllers
+
+   The device node for a USB controller that is part of a Freescale
+   SOC is as described in the document "Open Firmware Recommended
+   Practice : Universal Serial Bus" with the following modifications
+   and additions :  
+
+   Required properties :
+    - compatible : Should be "fsl-usb2-mph" for multi port host usb
+      controllers, or "fsl-usb2-dr" for dual role usb controllers
+    - phy_type : For multi port host usb controllers, should be one of
+      "ulpi", or "serial". For dual role usb controllers, should be
+      one of "ulpi", "utmi", "utmi_wide", or "serial".
+    - reg : Offset and length of the register set for the device
+    - port0 : boolean; if defined, indicates port0 is connected for
+      fsl-usb2-mph compatible controllers.  Either this property or
+      "port1" (or both) must be defined for "fsl-usb2-mph" compatible 
+      controllers.
+    - port1 : boolean; if defined, indicates port1 is connected for
+      fsl-usb2-mph compatible controllers.  Either this property or
+      "port0" (or both) must be defined for "fsl-usb2-mph" compatible 
+      controllers.
+
+   Recommended properties :
+    - interrupts : <a b> where a is the interrupt number and b is a
+      field that represents an encoding of the sense and level
+      information for the interrupt.  This should be encoded based on
+      the information in section 2) depending on the type of interrupt
+      controller you have.
+    - interrupt-parent : the phandle for the interrupt controller that
+      services interrupts for this device.
+
+   Example multi port host usb controller device node : 
+        usb@22000 {
+                device_type = "usb";
+                compatible = "fsl-usb2-mph";
+                reg = <22000 1000>;
+                #address-cells = <1>;
+                #size-cells = <0>;
+                interrupt-parent = <700>;
+                interrupts = <27 1>;
+                phy_type = "ulpi";
+                port0;
+                port1;
+        };
+
+   Example dual role usb controller device node : 
+        usb@23000 {
+                device_type = "usb";
+                compatible = "fsl-usb2-dr";
+                reg = <23000 1000>;
+                #address-cells = <1>;
+                #size-cells = <0>;
+                interrupt-parent = <700>;
+                interrupts = <26 1>;
+                phy = "ulpi";
+        };
+
+
    More devices will be defined as this spec matures.
 
 
diff --git a/arch/arm/mach-s3c2410/mach-h1940.c b/arch/arm/mach-s3c2410/mach-h1940.c
index 1c316f14ed94..646a3a5d33a5 100644
--- a/arch/arm/mach-s3c2410/mach-h1940.c
+++ b/arch/arm/mach-s3c2410/mach-h1940.c
@@ -46,10 +46,11 @@
 #include <asm/irq.h>
 #include <asm/mach-types.h>
 
-//#include <asm/debug-ll.h>
+
 #include <asm/arch/regs-serial.h>
 #include <asm/arch/regs-lcd.h>
 
+#include <asm/arch/h1940-latch.h>
 #include <asm/arch/fb.h>
 
 #include <linux/serial_core.h>
@@ -59,7 +60,12 @@
 #include "cpu.h"
 
 static struct map_desc h1940_iodesc[] __initdata = {
-        /* nothing here yet */
+        [0] = {
+                .virtual        = (unsigned long)H1940_LATCH,
+                .pfn            = __phys_to_pfn(H1940_PA_LATCH),
+                .length         = SZ_16K,
+                .type           = MT_DEVICE
+        },
 };
 
 #define UCON S3C2410_UCON_DEFAULT | S3C2410_UCON_UCLK
@@ -92,6 +98,25 @@ static struct s3c2410_uartcfg h1940_uartcfgs[] = {
         }
 };
 
+/* Board control latch control */
+
+static unsigned int latch_state = H1940_LATCH_DEFAULT;
+
+void h1940_latch_control(unsigned int clear, unsigned int set)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        latch_state &= ~clear;
+        latch_state |= set;
+
+        __raw_writel(latch_state, H1940_LATCH);
+
+        local_irq_restore(flags);
+}
+
+EXPORT_SYMBOL_GPL(h1940_latch_control);
 
 
 /**
diff --git a/arch/arm/mach-s3c2410/s3c2400.h b/arch/arm/mach-s3c2410/s3c2400.h
new file mode 100644
index 000000000000..8b2394e1ed40
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c2400.h
@@ -0,0 +1,31 @@
+/* arch/arm/mach-s3c2410/s3c2400.h
+ *
+ * Copyright (c) 2004 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * Header file for S3C2400 cpu support
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Modifications:
+ *     09-Fev-2006 LCVR  First version, based on s3c2410.h
+*/
+
+#ifdef CONFIG_CPU_S3C2400
+
+extern  int s3c2400_init(void);
+
+extern void s3c2400_map_io(struct map_desc *mach_desc, int size);
+
+extern void s3c2400_init_uarts(struct s3c2410_uartcfg *cfg, int no);
+
+extern void s3c2400_init_clocks(int xtal);
+
+#else
+#define s3c2400_init_clocks NULL
+#define s3c2400_init_uarts NULL
+#define s3c2400_map_io NULL
+#define s3c2400_init NULL
+#endif
diff --git a/arch/i386/kernel/smpboot.c b/arch/i386/kernel/smpboot.c
index 255adb498268..fb00ab7b7612 100644
--- a/arch/i386/kernel/smpboot.c
+++ b/arch/i386/kernel/smpboot.c
@@ -87,11 +87,7 @@ EXPORT_SYMBOL(cpu_online_map);
 cpumask_t cpu_callin_map;
 cpumask_t cpu_callout_map;
 EXPORT_SYMBOL(cpu_callout_map);
-#ifdef CONFIG_HOTPLUG_CPU
-cpumask_t cpu_possible_map = CPU_MASK_ALL;
-#else
 cpumask_t cpu_possible_map;
-#endif
 EXPORT_SYMBOL(cpu_possible_map);
 static cpumask_t smp_commenced_mask;
 
diff --git a/arch/i386/mach-voyager/voyager_smp.c b/arch/i386/mach-voyager/voyager_smp.c
index 72a1b9cae2e4..6e4c3baef6cc 100644
--- a/arch/i386/mach-voyager/voyager_smp.c
+++ b/arch/i386/mach-voyager/voyager_smp.c
@@ -240,7 +240,7 @@ static cpumask_t smp_commenced_mask = CPU_MASK_NONE;
 cpumask_t cpu_callin_map = CPU_MASK_NONE;
 cpumask_t cpu_callout_map = CPU_MASK_NONE;
 EXPORT_SYMBOL(cpu_callout_map);
-cpumask_t cpu_possible_map = CPU_MASK_ALL;
+cpumask_t cpu_possible_map = CPU_MASK_NONE;
 EXPORT_SYMBOL(cpu_possible_map);
 
 /* The per processor IRQ masks (these are usually kept in sync) */
diff --git a/arch/ia64/ia32/ia32_signal.c b/arch/ia64/ia32/ia32_signal.c
index 5856510210fa..b3355a9ca2c3 100644
--- a/arch/ia64/ia32/ia32_signal.c
+++ b/arch/ia64/ia32/ia32_signal.c
@@ -515,6 +515,7 @@ sys32_signal (int sig, unsigned int handler)
 
         sigact_set_handler(&new_sa, handler, 0);
         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
+        sigemptyset(&new_sa.sa.sa_mask);
 
         ret = do_sigaction(sig, &new_sa, &old_sa);
 
diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S
index 7a6ffd613789..27b222c277e4 100644
--- a/arch/ia64/kernel/entry.S
+++ b/arch/ia64/kernel/entry.S
@@ -1601,5 +1601,21 @@ sys_call_table:
         data8 sys_inotify_add_watch
         data8 sys_inotify_rm_watch
         data8 sys_migrate_pages                 // 1280
+        data8 sys_openat
+        data8 sys_mkdirat
+        data8 sys_mknodat
+        data8 sys_fchownat
+        data8 sys_futimesat                     // 1285
+        data8 sys_newfstatat
+        data8 sys_unlinkat
+        data8 sys_renameat
+        data8 sys_linkat
+        data8 sys_symlinkat                     // 1290
+        data8 sys_readlinkat
+        data8 sys_fchmodat
+        data8 sys_faccessat
+        data8 sys_ni_syscall                    // reserved for pselect
+        data8 sys_ni_syscall                    // 1295 reserved for ppoll
+        data8 sys_unshare
 
         .org sys_call_table + 8*NR_syscalls     // guard against failures to increase NR_syscalls
diff --git a/arch/ia64/kernel/fsys.S b/arch/ia64/kernel/fsys.S
index ce423910ca97..ac6055c83115 100644
--- a/arch/ia64/kernel/fsys.S
+++ b/arch/ia64/kernel/fsys.S
@@ -878,31 +878,8 @@ fsyscall_table:
         data8 0                         // timer_delete
         data8 0                         // clock_settime
         data8 fsys_clock_gettime        // clock_gettime
-        data8 0                         // clock_getres         // 1255
-        data8 0                         // clock_nanosleep
-        data8 0                         // fstatfs64
-        data8 0                         // statfs64
-        data8 0
-        data8 0                                                 // 1260
-        data8 0
-        data8 0                         // mq_open
-        data8 0                         // mq_unlink
-        data8 0                         // mq_timedsend
-        data8 0                         // mq_timedreceive      // 1265
-        data8 0                         // mq_notify
-        data8 0                         // mq_getsetattr
-        data8 0                         // kexec_load
-        data8 0
-        data8 0                                                 // 1270
-        data8 0
-        data8 0
-        data8 0
-        data8 0
-        data8 0                                                 // 1275
-        data8 0
-        data8 0
-        data8 0
-        data8 0
-        data8 0                                                 // 1280
+        #define __NR_syscall_last       1255
+
+        .space 8*(NR_syscalls + 1024 - __NR_syscall_last), 0
 
         .org fsyscall_table + 8*NR_syscalls     // guard against failures to increase NR_syscalls
diff --git a/arch/ia64/kernel/mca_drv.c b/arch/ia64/kernel/mca_drv.c
index 3492e3211a44..8fd93afa75a7 100644
--- a/arch/ia64/kernel/mca_drv.c
+++ b/arch/ia64/kernel/mca_drv.c
@@ -437,6 +437,9 @@ recover_from_read_error(slidx_table_t *slidx,
          *    the process not have any locks of kernel.
          */
 
+        /* Is minstate valid? */
+        if (!peidx_bottom(peidx) || !(peidx_bottom(peidx)->valid.minstate))
+                return 0;
         psr1 =(struct ia64_psr *)&(peidx_minstate_area(peidx)->pmsa_ipsr);
 
         /*
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index d7e4d79e16a8..3437c2390429 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -617,15 +617,15 @@ void sn_bus_store_sysdata(struct pci_dev *dev)
 void sn_bus_free_sysdata(void)
 {
         struct sysdata_el *element;
-        struct list_head *list;
+        struct list_head *list, *safe;
 
-sn_sysdata_free_start:
-        list_for_each(list, &sn_sysdata_list) {
+        list_for_each_safe(list, safe, &sn_sysdata_list) {
                 element = list_entry(list, struct sysdata_el, entry);
                 list_del(&element->entry);
+                list_del(&(((struct pcidev_info *)
+                             (element->sysdata))->pdi_list));
                 kfree(element->sysdata);
                 kfree(element);
-                goto sn_sysdata_free_start;
         }
         return;
 }
diff --git a/arch/ia64/sn/kernel/irq.c b/arch/ia64/sn/kernel/irq.c
index 74d87d903d5d..c373113d073a 100644
--- a/arch/ia64/sn/kernel/irq.c
+++ b/arch/ia64/sn/kernel/irq.c
@@ -299,7 +299,9 @@ void sn_irq_unfixup(struct pci_dev *pci_dev)
                 return;
 
         sn_irq_info = SN_PCIDEV_INFO(pci_dev)->pdi_sn_irq_info;
-        if (!sn_irq_info || !sn_irq_info->irq_irq) {
+        if (!sn_irq_info)
+                return;
+        if (!sn_irq_info->irq_irq) {
                 kfree(sn_irq_info);
                 return;
         }
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index df338c5cc910..80d114a3a837 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -83,6 +83,12 @@ config GENERIC_TBSYNC
         default y if PPC32 && SMP
         default n
 
+config DEFAULT_UIMAGE
+        bool
+        help
+          Used to allow a board to specify it wants a uImage built by default
+        default n
+
 menu "Processor support"
 choice
         prompt "Processor Type"
diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile
index 44dd82b791d1..5500ab55d042 100644
--- a/arch/powerpc/Makefile
+++ b/arch/powerpc/Makefile
@@ -142,6 +142,7 @@ drivers-$(CONFIG_OPROFILE)	+= arch/powerpc/oprofile/
 # Default to zImage, override when needed
 defaultimage-y                  := zImage
 defaultimage-$(CONFIG_PPC_ISERIES) := vmlinux
+defaultimage-$(CONFIG_DEFAULT_UIMAGE) := uImage
 KBUILD_IMAGE := $(defaultimage-y)
 all: $(KBUILD_IMAGE)
 
@@ -167,6 +168,8 @@ endef
 
 archclean:
         $(Q)$(MAKE) $(clean)=$(boot)
+
+archmrproper:
         $(Q)rm -rf arch/$(ARCH)/include
 
 archprepare: checkbin
diff --git a/arch/powerpc/kernel/Makefile b/arch/powerpc/kernel/Makefile
index c287980b7e65..80e9fe2632b8 100644
--- a/arch/powerpc/kernel/Makefile
+++ b/arch/powerpc/kernel/Makefile
@@ -12,10 +12,10 @@ endif
 
 obj-y                           := semaphore.o cputable.o ptrace.o syscalls.o \
                                    irq.o align.o signal_32.o pmc.o vdso.o \
-                                   init_task.o process.o
+                                   init_task.o process.o systbl.o
 obj-y                           += vdso32/
 obj-$(CONFIG_PPC64)             += setup_64.o binfmt_elf32.o sys_ppc32.o \
-                                   signal_64.o ptrace32.o systbl.o \
+                                   signal_64.o ptrace32.o \
                                    paca.o cpu_setup_power4.o \
                                    firmware.o sysfs.o idle_64.o
 obj-$(CONFIG_PPC64)             += vdso64/
@@ -46,7 +46,7 @@ extra-$(CONFIG_8xx)		:= head_8xx.o
 extra-y                         += vmlinux.lds
 
 obj-y                           += time.o prom.o traps.o setup-common.o udbg.o
-obj-$(CONFIG_PPC32)             += entry_32.o setup_32.o misc_32.o systbl.o
+obj-$(CONFIG_PPC32)             += entry_32.o setup_32.o misc_32.o
 obj-$(CONFIG_PPC64)             += misc_64.o dma_64.o iommu.o
 obj-$(CONFIG_PPC_MULTIPLATFORM) += prom_init.o
 obj-$(CONFIG_MODULES)           += ppc_ksyms.o
diff --git a/arch/powerpc/kernel/systbl.S b/arch/powerpc/kernel/systbl.S
index 007b15ee36d2..8a9f994ed917 100644
--- a/arch/powerpc/kernel/systbl.S
+++ b/arch/powerpc/kernel/systbl.S
@@ -36,8 +36,6 @@
 #ifdef CONFIG_PPC64
 #define sys_sigpending  sys_ni_syscall
 #define sys_old_getrlimit sys_ni_syscall
-#else
-#define ppc_rtas        sys_ni_syscall
 #endif
 
 _GLOBAL(sys_call_table)
@@ -323,3 +321,4 @@ SYSCALL(spu_run)
 SYSCALL(spu_create)
 COMPAT_SYS(pselect6)
 COMPAT_SYS(ppoll)
+SYSCALL(unshare)
diff --git a/arch/ppc/kernel/misc.S b/arch/ppc/kernel/misc.S
index c3427eed8345..5a936566fd61 100644
--- a/arch/ppc/kernel/misc.S
+++ b/arch/ppc/kernel/misc.S
@@ -1048,286 +1048,3 @@ _GLOBAL(name) \
         blr
 
 SYSCALL(execve)
-
-/* Why isn't this a) automatic, b) written in 'C'? */
-        .data
-        .align 4
-_GLOBAL(sys_call_table)
-        .long sys_restart_syscall /* 0 */
-        .long sys_exit
-        .long ppc_fork
-        .long sys_read
-        .long sys_write
-        .long sys_open          /* 5 */
-        .long sys_close
-        .long sys_waitpid
-        .long sys_creat
-        .long sys_link
-        .long sys_unlink        /* 10 */
-        .long sys_execve
-        .long sys_chdir
-        .long sys_time
-        .long sys_mknod
-        .long sys_chmod         /* 15 */
-        .long sys_lchown
-        .long sys_ni_syscall                    /* old break syscall holder */
-        .long sys_stat
-        .long sys_lseek
-        .long sys_getpid        /* 20 */
-        .long sys_mount
-        .long sys_oldumount
-        .long sys_setuid
-        .long sys_getuid
-        .long sys_stime         /* 25 */
-        .long sys_ptrace
-        .long sys_alarm
-        .long sys_fstat
-        .long sys_pause
-        .long sys_utime         /* 30 */
-        .long sys_ni_syscall                    /* old stty syscall holder */
-        .long sys_ni_syscall                    /* old gtty syscall holder */
-        .long sys_access
-        .long sys_nice
-        .long sys_ni_syscall    /* 35 */        /* old ftime syscall holder */
-        .long sys_sync
-        .long sys_kill
-        .long sys_rename
-        .long sys_mkdir
-        .long sys_rmdir         /* 40 */
-        .long sys_dup
-        .long sys_pipe
-        .long sys_times
-        .long sys_ni_syscall                    /* old prof syscall holder */
-        .long sys_brk           /* 45 */
-        .long sys_setgid
-        .long sys_getgid
-        .long sys_signal
-        .long sys_geteuid
-        .long sys_getegid       /* 50 */
-        .long sys_acct
-        .long sys_umount                        /* recycled never used phys() */
-        .long sys_ni_syscall                    /* old lock syscall holder */
-        .long sys_ioctl
-        .long sys_fcntl         /* 55 */
-        .long sys_ni_syscall                    /* old mpx syscall holder */
-        .long sys_setpgid
-        .long sys_ni_syscall                    /* old ulimit syscall holder */
-        .long sys_olduname
-        .long sys_umask         /* 60 */
-        .long sys_chroot
-        .long sys_ustat
-        .long sys_dup2
-        .long sys_getppid
-        .long sys_getpgrp       /* 65 */
-        .long sys_setsid
-        .long sys_sigaction
-        .long sys_sgetmask
-        .long sys_ssetmask
-        .long sys_setreuid      /* 70 */
-        .long sys_setregid
-        .long sys_sigsuspend
-        .long sys_sigpending
-        .long sys_sethostname
-        .long sys_setrlimit     /* 75 */
-        .long sys_old_getrlimit
-        .long sys_getrusage
-        .long sys_gettimeofday
-        .long sys_settimeofday
-        .long sys_getgroups     /* 80 */
-        .long sys_setgroups
-        .long ppc_select
-        .long sys_symlink
-        .long sys_lstat
-        .long sys_readlink      /* 85 */
-        .long sys_uselib
-        .long sys_swapon
-        .long sys_reboot
-        .long old_readdir
-        .long sys_mmap          /* 90 */
-        .long sys_munmap
-        .long sys_truncate
-        .long sys_ftruncate
-        .long sys_fchmod
-        .long sys_fchown        /* 95 */
-        .long sys_getpriority
-        .long sys_setpriority
-        .long sys_ni_syscall                    /* old profil syscall holder */
-        .long sys_statfs
-        .long sys_fstatfs       /* 100 */
-        .long sys_ni_syscall
-        .long sys_socketcall
-        .long sys_syslog
-        .long sys_setitimer
-        .long sys_getitimer     /* 105 */
-        .long sys_newstat
-        .long sys_newlstat
-        .long sys_newfstat
-        .long sys_uname
-        .long sys_ni_syscall    /* 110 */
-        .long sys_vhangup
-        .long sys_ni_syscall    /* old 'idle' syscall */
-        .long sys_ni_syscall
-        .long sys_wait4
-        .long sys_swapoff       /* 115 */
-        .long sys_sysinfo
-        .long sys_ipc
-        .long sys_fsync
-        .long sys_sigreturn
-        .long ppc_clone         /* 120 */
-        .long sys_setdomainname
-        .long sys_newuname
-        .long sys_ni_syscall
-        .long sys_adjtimex
-        .long sys_mprotect      /* 125 */
-        .long sys_sigprocmask
-        .long sys_ni_syscall    /* old sys_create_module */
-        .long sys_init_module
-        .long sys_delete_module
-        .long sys_ni_syscall    /* old sys_get_kernel_syms */   /* 130 */
-        .long sys_quotactl
-        .long sys_getpgid
-        .long sys_fchdir
-        .long sys_bdflush
-        .long sys_sysfs         /* 135 */
-        .long sys_personality
-        .long sys_ni_syscall    /* for afs_syscall */
-        .long sys_setfsuid
-        .long sys_setfsgid
-        .long sys_llseek        /* 140 */
-        .long sys_getdents
-        .long ppc_select
-        .long sys_flock
-        .long sys_msync
-        .long sys_readv         /* 145 */
-        .long sys_writev
-        .long sys_getsid
-        .long sys_fdatasync
-        .long sys_sysctl
-        .long sys_mlock         /* 150 */
-        .long sys_munlock
-        .long sys_mlockall
-        .long sys_munlockall
-        .long sys_sched_setparam
-        .long sys_sched_getparam        /* 155 */
-        .long sys_sched_setscheduler
-        .long sys_sched_getscheduler
-        .long sys_sched_yield
-        .long sys_sched_get_priority_max
-        .long sys_sched_get_priority_min  /* 160 */
-        .long sys_sched_rr_get_interval
-        .long sys_nanosleep
-        .long sys_mremap
-        .long sys_setresuid
-        .long sys_getresuid     /* 165 */
-        .long sys_ni_syscall            /* old sys_query_module */
-        .long sys_poll
-        .long sys_nfsservctl
-        .long sys_setresgid
-        .long sys_getresgid     /* 170 */
-        .long sys_prctl
-        .long sys_rt_sigreturn
-        .long sys_rt_sigaction
-        .long sys_rt_sigprocmask
-        .long sys_rt_sigpending /* 175 */
-        .long sys_rt_sigtimedwait
-        .long sys_rt_sigqueueinfo
-        .long sys_rt_sigsuspend
-        .long sys_pread64
-        .long sys_pwrite64      /* 180 */
-        .long sys_chown
-        .long sys_getcwd
-        .long sys_capget
-        .long sys_capset
-        .long sys_sigaltstack   /* 185 */
-        .long sys_sendfile
-        .long sys_ni_syscall            /* streams1 */
-        .long sys_ni_syscall            /* streams2 */
-        .long ppc_vfork
-        .long sys_getrlimit     /* 190 */
-        .long sys_readahead
-        .long sys_mmap2
-        .long sys_truncate64
-        .long sys_ftruncate64
-        .long sys_stat64        /* 195 */
-        .long sys_lstat64
-        .long sys_fstat64
-        .long sys_pciconfig_read
-        .long sys_pciconfig_write
-        .long sys_pciconfig_iobase      /* 200 */
-        .long sys_ni_syscall            /* 201 - reserved - MacOnLinux - new */
-        .long sys_getdents64
-        .long sys_pivot_root
-        .long sys_fcntl64
-        .long sys_madvise       /* 205 */
-        .long sys_mincore
-        .long sys_gettid
-        .long sys_tkill
-        .long sys_setxattr
-        .long sys_lsetxattr     /* 210 */
-        .long sys_fsetxattr
-        .long sys_getxattr
-        .long sys_lgetxattr
-        .long sys_fgetxattr
-        .long sys_listxattr     /* 215 */
-        .long sys_llistxattr
-        .long sys_flistxattr
-        .long sys_removexattr
-        .long sys_lremovexattr
-        .long sys_fremovexattr  /* 220 */
-        .long sys_futex
-        .long sys_sched_setaffinity
-        .long sys_sched_getaffinity
-        .long sys_ni_syscall
-        .long sys_ni_syscall    /* 225 - reserved for Tux */
-        .long sys_sendfile64
-        .long sys_io_setup
-        .long sys_io_destroy
-        .long sys_io_getevents
-        .long sys_io_submit     /* 230 */
-        .long sys_io_cancel
-        .long sys_set_tid_address
-        .long sys_fadvise64
-        .long sys_exit_group
-        .long sys_lookup_dcookie /* 235 */
-        .long sys_epoll_create
-        .long sys_epoll_ctl
-        .long sys_epoll_wait
-        .long sys_remap_file_pages
-        .long sys_timer_create  /* 240 */
-        .long sys_timer_settime
-        .long sys_timer_gettime
-        .long sys_timer_getoverrun
-        .long sys_timer_delete
-        .long sys_clock_settime /* 245 */
-        .long sys_clock_gettime
-        .long sys_clock_getres
-        .long sys_clock_nanosleep
-        .long sys_swapcontext
-        .long sys_tgkill        /* 250 */
-        .long sys_utimes
-        .long sys_statfs64
-        .long sys_fstatfs64
-        .long ppc_fadvise64_64
-        .long sys_ni_syscall            /* 255 - rtas (used on ppc64) */
-        .long sys_debug_setcontext
-        .long sys_ni_syscall            /* 257 reserved for vserver */
-        .long sys_ni_syscall            /* 258 reserved for new sys_remap_file_pages */
-        .long sys_ni_syscall            /* 259 reserved for new sys_mbind */
-        .long sys_ni_syscall            /* 260 reserved for new sys_get_mempolicy */
-        .long sys_ni_syscall            /* 261 reserved for new sys_set_mempolicy */
-        .long sys_mq_open
-        .long sys_mq_unlink
-        .long sys_mq_timedsend
-        .long sys_mq_timedreceive       /* 265 */
-        .long sys_mq_notify
-        .long sys_mq_getsetattr
-        .long sys_kexec_load
-        .long sys_add_key
-        .long sys_request_key           /* 270 */
-        .long sys_keyctl
-        .long sys_waitid
-        .long sys_ioprio_set
-        .long sys_ioprio_get
-        .long sys_inotify_init          /* 275 */
-        .long sys_inotify_add_watch
-        .long sys_inotify_rm_watch
diff --git a/arch/s390/kernel/compat_signal.c b/arch/s390/kernel/compat_signal.c
index ef706694a0c1..5291b5f8788d 100644
--- a/arch/s390/kernel/compat_signal.c
+++ b/arch/s390/kernel/compat_signal.c
@@ -195,9 +195,6 @@ sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
         return ret;
 }
 
-int
-do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
-
 asmlinkage long
 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
            struct sigaction32 __user *oact,  size_t sigsetsize)
diff --git a/arch/sparc64/kernel/systbls.S b/arch/sparc64/kernel/systbls.S
index 5928b3c33e27..a19168510be2 100644
--- a/arch/sparc64/kernel/systbls.S
+++ b/arch/sparc64/kernel/systbls.S
@@ -146,7 +146,7 @@ sys_call_table:
 /*270*/ .word sys_io_submit, sys_io_cancel, sys_io_getevents, sys_mq_open, sys_mq_unlink
         .word sys_mq_timedsend, sys_mq_timedreceive, sys_mq_notify, sys_mq_getsetattr, sys_waitid
 /*280*/ .word sys_nis_syscall, sys_add_key, sys_request_key, sys_keyctl, sys_openat
-        .word sys_mkdirat, sys_mknodat, sys_fchownat, sys_futimesat, compat_sys_newfstatat
+        .word sys_mkdirat, sys_mknodat, sys_fchownat, sys_futimesat, sys_newfstatat
 /*285*/ .word sys_unlinkat, sys_renameat, sys_linkat, sys_symlinkat, sys_readlinkat
         .word sys_fchmodat, sys_faccessat, sys_pselect6, sys_ppoll, sys_unshare
 
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 076e07c1da38..a23816d3e9a1 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -268,6 +268,8 @@ static struct tty_buffer *tty_buffer_alloc(size_t size)
         p->size = size;
         p->next = NULL;
         p->active = 0;
+        p->commit = 0;
+        p->read = 0;
         p->char_buf_ptr = (char *)(p->data);
         p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
 /*      printk("Flip create %p\n", p); */
@@ -298,6 +300,8 @@ static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
                         *tbh = t->next;
                         t->next = NULL;
                         t->used = 0;
+                        t->commit = 0;
+                        t->read = 0;
                         /* DEBUG ONLY */
                         memset(t->data, '*', size);
 /*                      printk("Flip recycle %p\n", t); */
@@ -335,6 +339,7 @@ int tty_buffer_request_room(struct tty_struct *tty, size_t size)
                         if (b != NULL) {
                                 b->next = n;
                                 b->active = 0;
+                                b->commit = b->used;
                         } else
                                 tty->buf.head = n;
                         tty->buf.tail = n;
@@ -2752,6 +2757,9 @@ static void flush_to_ldisc(void *private_)
         unsigned long   flags;
         struct tty_ldisc *disc;
         struct tty_buffer *tbuf;
+        int count;
+        char *char_buf;
+        unsigned char *flag_buf;
 
         disc = tty_ldisc_ref(tty);
         if (disc == NULL)       /*  !TTY_LDISC */
@@ -2765,16 +2773,20 @@ static void flush_to_ldisc(void *private_)
                 goto out;
         }
         spin_lock_irqsave(&tty->buf.lock, flags);
-        while((tbuf = tty->buf.head) != NULL && !tbuf->active) {
+        while((tbuf = tty->buf.head) != NULL) {
+                while ((count = tbuf->commit - tbuf->read) != 0) {
+                        char_buf = tbuf->char_buf_ptr + tbuf->read;
+                        flag_buf = tbuf->flag_buf_ptr + tbuf->read;
+                        tbuf->read += count;
+                        spin_unlock_irqrestore(&tty->buf.lock, flags);
+                        disc->receive_buf(tty, char_buf, flag_buf, count);
+                        spin_lock_irqsave(&tty->buf.lock, flags);
+                }
+                if (tbuf->active)
+                        break;
                 tty->buf.head = tbuf->next;
                 if (tty->buf.head == NULL)
                         tty->buf.tail = NULL;
-                spin_unlock_irqrestore(&tty->buf.lock, flags);
-                /* printk("Process buffer %p for %d\n", tbuf, tbuf->used); */
-                disc->receive_buf(tty, tbuf->char_buf_ptr,
-                                       tbuf->flag_buf_ptr,
-                                       tbuf->used);
-                spin_lock_irqsave(&tty->buf.lock, flags);
                 tty_buffer_free(tty, tbuf);
         }
         spin_unlock_irqrestore(&tty->buf.lock, flags);
@@ -2871,8 +2883,10 @@ void tty_flip_buffer_push(struct tty_struct *tty)
 {
         unsigned long flags;
         spin_lock_irqsave(&tty->buf.lock, flags);
-        if (tty->buf.tail != NULL)
+        if (tty->buf.tail != NULL) {
                 tty->buf.tail->active = 0;
+                tty->buf.tail->commit = tty->buf.tail->used;
+        }
         spin_unlock_irqrestore(&tty->buf.lock, flags);
 
         if (tty->low_latency)
diff --git a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig
index 233a4f608084..ef85d76575a2 100644
--- a/drivers/net/wireless/Kconfig
+++ b/drivers/net/wireless/Kconfig
@@ -148,7 +148,7 @@ config IPW2100
           In order to use this driver, you will need a firmware image for it.
           You can obtain the firmware from
           <http://ipw2100.sf.net/>.  Once you have the firmware image, you 
-          will need to place it in /etc/firmware.
+          will need to place it in /lib/firmware.
 
           You will also very likely need the Wireless Tools in order to
           configure your card:
diff --git a/drivers/scsi/ahci.c b/drivers/scsi/ahci.c
index 98ce6bb62ff8..24a54a5a91b8 100644
--- a/drivers/scsi/ahci.c
+++ b/drivers/scsi/ahci.c
@@ -190,7 +190,7 @@ static void ahci_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc);
 static irqreturn_t ahci_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
-static void ahci_phy_reset(struct ata_port *ap);
+static int ahci_probe_reset(struct ata_port *ap, unsigned int *classes);
 static void ahci_irq_clear(struct ata_port *ap);
 static void ahci_eng_timeout(struct ata_port *ap);
 static int ahci_port_start(struct ata_port *ap);
@@ -230,7 +230,7 @@ static const struct ata_port_operations ahci_ops = {
 
         .tf_read                = ahci_tf_read,
 
-        .phy_reset              = ahci_phy_reset,
+        .probe_reset            = ahci_probe_reset,
 
         .qc_prep                = ahci_qc_prep,
         .qc_issue               = ahci_qc_issue,
@@ -252,8 +252,7 @@ static const struct ata_port_info ahci_port_info[] = {
         {
                 .sht            = &ahci_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SATA_RESET | ATA_FLAG_MMIO |
-                                  ATA_FLAG_PIO_DMA,
+                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
                 .pio_mask       = 0x1f, /* pio0-4 */
                 .udma_mask      = 0x7f, /* udma0-6 ; FIXME */
                 .port_ops       = &ahci_ops,
@@ -507,37 +506,43 @@ static unsigned int ahci_dev_classify(struct ata_port *ap)
         return ata_dev_classify(&tf);
 }
 
-static void ahci_fill_cmd_slot(struct ata_port *ap, u32 opts)
+static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, u32 opts)
 {
-        struct ahci_port_priv *pp = ap->private_data;
         pp->cmd_slot[0].opts = cpu_to_le32(opts);
         pp->cmd_slot[0].status = 0;
         pp->cmd_slot[0].tbl_addr = cpu_to_le32(pp->cmd_tbl_dma & 0xffffffff);
         pp->cmd_slot[0].tbl_addr_hi = cpu_to_le32((pp->cmd_tbl_dma >> 16) >> 16);
 }
 
-static void ahci_phy_reset(struct ata_port *ap)
+static int ahci_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
 {
-        void __iomem *port_mmio = (void __iomem *) ap->ioaddr.cmd_addr;
-        struct ata_device *dev = &ap->device[0];
-        u32 new_tmp, tmp;
+        int rc;
+
+        DPRINTK("ENTER\n");
 
         ahci_stop_engine(ap);
-        __sata_phy_reset(ap);
+        rc = sata_std_hardreset(ap, verbose, class);
         ahci_start_engine(ap);
 
-        if (ap->flags & ATA_FLAG_PORT_DISABLED)
-                return;
+        if (rc == 0)
+                *class = ahci_dev_classify(ap);
+        if (*class == ATA_DEV_UNKNOWN)
+                *class = ATA_DEV_NONE;
 
-        dev->class = ahci_dev_classify(ap);
-        if (!ata_dev_present(dev)) {
-                ata_port_disable(ap);
-                return;
-        }
+        DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class);
+        return rc;
+}
+
+static void ahci_postreset(struct ata_port *ap, unsigned int *class)
+{
+        void __iomem *port_mmio = (void __iomem *) ap->ioaddr.cmd_addr;
+        u32 new_tmp, tmp;
+
+        ata_std_postreset(ap, class);
 
         /* Make sure port's ATAPI bit is set appropriately */
         new_tmp = tmp = readl(port_mmio + PORT_CMD);
-        if (dev->class == ATA_DEV_ATAPI)
+        if (*class == ATA_DEV_ATAPI)
                 new_tmp |= PORT_CMD_ATAPI;
         else
                 new_tmp &= ~PORT_CMD_ATAPI;
@@ -547,6 +552,12 @@ static void ahci_phy_reset(struct ata_port *ap)
         }
 }
 
+static int ahci_probe_reset(struct ata_port *ap, unsigned int *classes)
+{
+        return ata_drive_probe_reset(ap, NULL, NULL, ahci_hardreset,
+                                     ahci_postreset, classes);
+}
+
 static u8 ahci_check_status(struct ata_port *ap)
 {
         void __iomem *mmio = (void __iomem *) ap->ioaddr.cmd_addr;
@@ -622,7 +633,7 @@ static void ahci_qc_prep(struct ata_queued_cmd *qc)
         if (is_atapi)
                 opts |= AHCI_CMD_ATAPI;
 
-        ahci_fill_cmd_slot(ap, opts);
+        ahci_fill_cmd_slot(pp, opts);
 }
 
 static void ahci_restart_port(struct ata_port *ap, u32 irq_stat)
@@ -703,7 +714,7 @@ static inline int ahci_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc)
         ci = readl(port_mmio + PORT_CMD_ISSUE);
         if (likely((ci & 0x1) == 0)) {
                 if (qc) {
-                        assert(qc->err_mask == 0);
+                        WARN_ON(qc->err_mask);
                         ata_qc_complete(qc);
                         qc = NULL;
                 }
diff --git a/drivers/scsi/libata-core.c b/drivers/scsi/libata-core.c
index 592d3a86c840..3fd55ef5410f 100644
--- a/drivers/scsi/libata-core.c
+++ b/drivers/scsi/libata-core.c
@@ -897,8 +897,8 @@ static void ata_dev_identify(struct ata_port *ap, unsigned int device)
 
         DPRINTK("ENTER, host %u, dev %u\n", ap->id, device);
 
-        assert (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ATAPI ||
-                dev->class == ATA_DEV_NONE);
+        WARN_ON(dev->class != ATA_DEV_ATA && dev->class != ATA_DEV_ATAPI &&
+                dev->class != ATA_DEV_NONE);
 
         ata_dev_select(ap, device, 1, 1); /* select device 0/1 */
 
@@ -1926,11 +1926,20 @@ static int sata_phy_resume(struct ata_port *ap)
  *
  *      @ap is about to be probed.  Initialize it.  This function is
  *      to be used as standard callback for ata_drive_probe_reset().
+ *
+ *      NOTE!!! Do not use this function as probeinit if a low level
+ *      driver implements only hardreset.  Just pass NULL as probeinit
+ *      in that case.  Using this function is probably okay but doing
+ *      so makes reset sequence different from the original
+ *      ->phy_reset implementation and Jeff nervous.  :-P
  */
 extern void ata_std_probeinit(struct ata_port *ap)
 {
-        if (ap->flags & ATA_FLAG_SATA && ap->ops->scr_read)
+        if (ap->flags & ATA_FLAG_SATA && ap->ops->scr_read) {
                 sata_phy_resume(ap);
+                if (sata_dev_present(ap))
+                        ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
+        }
 }
 
 /**
@@ -1956,20 +1965,17 @@ int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
 
         DPRINTK("ENTER\n");
 
+        if (ap->ops->scr_read && !sata_dev_present(ap)) {
+                classes[0] = ATA_DEV_NONE;
+                goto out;
+        }
+
         /* determine if device 0/1 are present */
         if (ata_devchk(ap, 0))
                 devmask |= (1 << 0);
         if (slave_possible && ata_devchk(ap, 1))
                 devmask |= (1 << 1);
 
-        /* devchk reports device presence without actual device on
-         * most SATA controllers.  Check SStatus and turn devmask off
-         * if link is offline.  Note that we should continue resetting
-         * even when it seems like there's no device.
-         */
-        if (ap->ops->scr_read && !sata_dev_present(ap))
-                devmask = 0;
-
         /* select device 0 again */
         ap->ops->dev_select(ap, 0);
 
@@ -1991,6 +1997,7 @@ int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
         if (slave_possible && err != 0x81)
                 classes[1] = ata_dev_try_classify(ap, 1, &err);
 
+ out:
         DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
         return 0;
 }
@@ -2013,8 +2020,6 @@ int ata_std_softreset(struct ata_port *ap, int verbose, unsigned int *classes)
  */
 int sata_std_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
 {
-        u32 serror;
-
         DPRINTK("ENTER\n");
 
         /* Issue phy wake/reset */
@@ -2029,10 +2034,6 @@ int sata_std_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
         /* Bring phy back */
         sata_phy_resume(ap);
 
-        /* Clear SError */
-        serror = scr_read(ap, SCR_ERROR);
-        scr_write(ap, SCR_ERROR, serror);
-
         /* TODO: phy layer with polling, timeouts, etc. */
         if (!sata_dev_present(ap)) {
                 *class = ATA_DEV_NONE;
@@ -2049,6 +2050,8 @@ int sata_std_hardreset(struct ata_port *ap, int verbose, unsigned int *class)
                 return -EIO;
         }
 
+        ap->ops->dev_select(ap, 0);     /* probably unnecessary */
+
         *class = ata_dev_try_classify(ap, 0, NULL);
 
         DPRINTK("EXIT, class=%u\n", *class);
@@ -2083,11 +2086,9 @@ void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
         if (ap->cbl == ATA_CBL_SATA)
                 sata_print_link_status(ap);
 
-        /* bail out if no device is present */
-        if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
-                DPRINTK("EXIT, no device\n");
-                return;
-        }
+        /* re-enable interrupts */
+        if (ap->ioaddr.ctl_addr)        /* FIXME: hack. create a hook instead */
+                ata_irq_on(ap);
 
         /* is double-select really necessary? */
         if (classes[0] != ATA_DEV_NONE)
@@ -2095,9 +2096,19 @@ void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
         if (classes[1] != ATA_DEV_NONE)
                 ap->ops->dev_select(ap, 0);
 
-        /* re-enable interrupts & set up device control */
-        if (ap->ioaddr.ctl_addr)        /* FIXME: hack. create a hook instead */
-                ata_irq_on(ap);
+        /* bail out if no device is present */
+        if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
+                DPRINTK("EXIT, no device\n");
+                return;
+        }
+
+        /* set up device control */
+        if (ap->ioaddr.ctl_addr) {
+                if (ap->flags & ATA_FLAG_MMIO)
+                        writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
+                else
+                        outb(ap->ctl, ap->ioaddr.ctl_addr);
+        }
 
         DPRINTK("EXIT\n");
 }
@@ -2292,7 +2303,7 @@ static unsigned int ata_get_mode_mask(const struct ata_port *ap, int shift)
         master = &ap->device[0];
         slave = &ap->device[1];
 
-        assert (ata_dev_present(master) || ata_dev_present(slave));
+        WARN_ON(!ata_dev_present(master) && !ata_dev_present(slave));
 
         if (shift == ATA_SHIFT_UDMA) {
                 mask = ap->udma_mask;
@@ -2538,11 +2549,11 @@ static void ata_sg_clean(struct ata_queued_cmd *qc)
         int dir = qc->dma_dir;
         void *pad_buf = NULL;
 
-        assert(qc->flags & ATA_QCFLAG_DMAMAP);
-        assert(sg != NULL);
+        WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
+        WARN_ON(sg == NULL);
 
         if (qc->flags & ATA_QCFLAG_SINGLE)
-                assert(qc->n_elem == 1);
+                WARN_ON(qc->n_elem != 1);
 
         VPRINTK("unmapping %u sg elements\n", qc->n_elem);
 
@@ -2597,8 +2608,8 @@ static void ata_fill_sg(struct ata_queued_cmd *qc)
         struct scatterlist *sg;
         unsigned int idx;
 
-        assert(qc->__sg != NULL);
-        assert(qc->n_elem > 0);
+        WARN_ON(qc->__sg == NULL);
+        WARN_ON(qc->n_elem == 0);
 
         idx = 0;
         ata_for_each_sg(sg, qc) {
@@ -2750,7 +2761,7 @@ static int ata_sg_setup_one(struct ata_queued_cmd *qc)
                 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
                 struct scatterlist *psg = &qc->pad_sgent;
 
-                assert(qc->dev->class == ATA_DEV_ATAPI);
+                WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
 
                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
 
@@ -2812,7 +2823,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
         int n_elem, pre_n_elem, dir, trim_sg = 0;
 
         VPRINTK("ENTER, ata%u\n", ap->id);
-        assert(qc->flags & ATA_QCFLAG_SG);
+        WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
 
         /* we must lengthen transfers to end on a 32-bit boundary */
         qc->pad_len = lsg->length & 3;
@@ -2821,7 +2832,7 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
                 struct scatterlist *psg = &qc->pad_sgent;
                 unsigned int offset;
 
-                assert(qc->dev->class == ATA_DEV_ATAPI);
+                WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
 
                 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
 
@@ -2914,7 +2925,7 @@ static unsigned long ata_pio_poll(struct ata_port *ap)
         unsigned int reg_state = HSM_ST_UNKNOWN;
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
-        assert(qc != NULL);
+        WARN_ON(qc == NULL);
 
         switch (ap->hsm_task_state) {
         case HSM_ST:
@@ -2983,7 +2994,7 @@ static int ata_pio_complete (struct ata_port *ap)
         }
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
-        assert(qc != NULL);
+        WARN_ON(qc == NULL);
 
         drv_stat = ata_wait_idle(ap);
         if (!ata_ok(drv_stat)) {
@@ -2994,7 +3005,7 @@ static int ata_pio_complete (struct ata_port *ap)
 
         ap->hsm_task_state = HSM_ST_IDLE;
 
-        assert(qc->err_mask == 0);
+        WARN_ON(qc->err_mask);
         ata_poll_qc_complete(qc);
 
         /* another command may start at this point */
@@ -3517,7 +3528,7 @@ static void ata_pio_block(struct ata_port *ap)
         }
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
-        assert(qc != NULL);
+        WARN_ON(qc == NULL);
 
         /* check error */
         if (status & (ATA_ERR | ATA_DF)) {
@@ -3554,7 +3565,7 @@ static void ata_pio_error(struct ata_port *ap)
         struct ata_queued_cmd *qc;
 
         qc = ata_qc_from_tag(ap, ap->active_tag);
-        assert(qc != NULL);
+        WARN_ON(qc == NULL);
 
         if (qc->tf.command != ATA_CMD_PACKET)
                 printk(KERN_WARNING "ata%u: PIO error\n", ap->id);
@@ -3562,7 +3573,7 @@ static void ata_pio_error(struct ata_port *ap)
         /* make sure qc->err_mask is available to 
          * know what's wrong and recover
          */
-        assert(qc->err_mask);
+        WARN_ON(qc->err_mask == 0);
 
         ap->hsm_task_state = HSM_ST_IDLE;
 
@@ -3776,7 +3787,7 @@ void ata_qc_free(struct ata_queued_cmd *qc)
         struct ata_port *ap = qc->ap;
         unsigned int tag;
 
-        assert(qc != NULL);     /* ata_qc_from_tag _might_ return NULL */
+        WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
 
         qc->flags = 0;
         tag = qc->tag;
@@ -3788,10 +3799,10 @@ void ata_qc_free(struct ata_queued_cmd *qc)
         }
 }
 
-inline void __ata_qc_complete(struct ata_queued_cmd *qc)
+void __ata_qc_complete(struct ata_queued_cmd *qc)
 {
-        assert(qc != NULL);     /* ata_qc_from_tag _might_ return NULL */
-        assert(qc->flags & ATA_QCFLAG_ACTIVE);
+        WARN_ON(qc == NULL);    /* ata_qc_from_tag _might_ return NULL */
+        WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
 
         if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
                 ata_sg_clean(qc);
@@ -3806,25 +3817,6 @@ inline void __ata_qc_complete(struct ata_queued_cmd *qc)
         qc->complete_fn(qc);
 }
 
-/**
- *      ata_qc_complete - Complete an active ATA command
- *      @qc: Command to complete
- *      @err_mask: ATA Status register contents
- *
- *      Indicate to the mid and upper layers that an ATA
- *      command has completed, with either an ok or not-ok status.
- *
- *      LOCKING:
- *      spin_lock_irqsave(host_set lock)
- */
-void ata_qc_complete(struct ata_queued_cmd *qc)
-{
-        if (unlikely(qc->flags & ATA_QCFLAG_EH_SCHEDULED))
-                return;
-
-        __ata_qc_complete(qc);
-}
-
 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
@@ -5143,7 +5135,7 @@ EXPORT_SYMBOL_GPL(ata_device_add);
 EXPORT_SYMBOL_GPL(ata_host_set_remove);
 EXPORT_SYMBOL_GPL(ata_sg_init);
 EXPORT_SYMBOL_GPL(ata_sg_init_one);
-EXPORT_SYMBOL_GPL(ata_qc_complete);
+EXPORT_SYMBOL_GPL(__ata_qc_complete);
 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
 EXPORT_SYMBOL_GPL(ata_eng_timeout);
 EXPORT_SYMBOL_GPL(ata_tf_load);
diff --git a/drivers/scsi/libata-scsi.c b/drivers/scsi/libata-scsi.c
index 9d67c6768335..26f07a2617f9 100644
--- a/drivers/scsi/libata-scsi.c
+++ b/drivers/scsi/libata-scsi.c
@@ -553,7 +553,7 @@ void ata_gen_ata_desc_sense(struct ata_queued_cmd *qc)
         /*
          * Read the controller registers.
          */
-        assert(NULL != qc->ap->ops->tf_read);
+        WARN_ON(qc->ap->ops->tf_read == NULL);
         qc->ap->ops->tf_read(qc->ap, tf);
 
         /*
@@ -628,7 +628,7 @@ void ata_gen_fixed_sense(struct ata_queued_cmd *qc)
         /*
          * Read the controller registers.
          */
-        assert(NULL != qc->ap->ops->tf_read);
+        WARN_ON(qc->ap->ops->tf_read == NULL);
         qc->ap->ops->tf_read(qc->ap, tf);
 
         /*
@@ -746,7 +746,7 @@ enum scsi_eh_timer_return ata_scsi_timed_out(struct scsi_cmnd *cmd)
         spin_lock_irqsave(&ap->host_set->lock, flags);
         qc = ata_qc_from_tag(ap, ap->active_tag);
         if (qc) {
-                assert(qc->scsicmd == cmd);
+                WARN_ON(qc->scsicmd != cmd);
                 qc->flags |= ATA_QCFLAG_EH_SCHEDULED;
                 qc->err_mask |= AC_ERR_TIMEOUT;
                 ret = EH_NOT_HANDLED;
@@ -780,14 +780,14 @@ int ata_scsi_error(struct Scsi_Host *host)
         ap = (struct ata_port *) &host->hostdata[0];
 
         spin_lock_irqsave(&ap->host_set->lock, flags);
-        assert(!(ap->flags & ATA_FLAG_IN_EH));
+        WARN_ON(ap->flags & ATA_FLAG_IN_EH);
         ap->flags |= ATA_FLAG_IN_EH;
-        assert(ata_qc_from_tag(ap, ap->active_tag) != NULL);
+        WARN_ON(ata_qc_from_tag(ap, ap->active_tag) == NULL);
         spin_unlock_irqrestore(&ap->host_set->lock, flags);
 
         ap->ops->eng_timeout(ap);
 
-        assert(host->host_failed == 0 && list_empty(&host->eh_cmd_q));
+        WARN_ON(host->host_failed || !list_empty(&host->eh_cmd_q));
 
         scsi_eh_flush_done_q(&ap->eh_done_q);
 
@@ -813,7 +813,7 @@ static void __ata_eh_qc_complete(struct ata_queued_cmd *qc)
         spin_lock_irqsave(&ap->host_set->lock, flags);
         qc->scsidone = ata_eh_scsidone;
         __ata_qc_complete(qc);
-        assert(!ata_tag_valid(qc->tag));
+        WARN_ON(ata_tag_valid(qc->tag));
         spin_unlock_irqrestore(&ap->host_set->lock, flags);
 
         scsi_eh_finish_cmd(scmd, &ap->eh_done_q);
diff --git a/drivers/scsi/libata.h b/drivers/scsi/libata.h
index 1cd071a32e93..9d76923a2253 100644
--- a/drivers/scsi/libata.h
+++ b/drivers/scsi/libata.h
@@ -46,7 +46,6 @@ extern struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
 extern int ata_rwcmd_protocol(struct ata_queued_cmd *qc);
 extern void ata_qc_free(struct ata_queued_cmd *qc);
 extern unsigned int ata_qc_issue(struct ata_queued_cmd *qc);
-extern void __ata_qc_complete(struct ata_queued_cmd *qc);
 extern int ata_check_atapi_dma(struct ata_queued_cmd *qc);
 extern void ata_dev_select(struct ata_port *ap, unsigned int device,
                            unsigned int wait, unsigned int can_sleep);
diff --git a/drivers/scsi/sata_mv.c b/drivers/scsi/sata_mv.c
index cda4c495c10f..d35460ff5275 100644
--- a/drivers/scsi/sata_mv.c
+++ b/drivers/scsi/sata_mv.c
@@ -632,8 +632,8 @@ static void mv_irq_clear(struct ata_port *ap)
  *      @base: port base address
  *      @pp: port private data
  *
- *      Verify the local cache of the eDMA state is accurate with an
- *      assert.
+ *      Verify the local cache of the eDMA state is accurate with a
+ *      WARN_ON.
  *
  *      LOCKING:
  *      Inherited from caller.
@@ -644,15 +644,15 @@ static void mv_start_dma(void __iomem *base, struct mv_port_priv *pp)
                 writelfl(EDMA_EN, base + EDMA_CMD_OFS);
                 pp->pp_flags |= MV_PP_FLAG_EDMA_EN;
         }
-        assert(EDMA_EN & readl(base + EDMA_CMD_OFS));
+        WARN_ON(!(EDMA_EN & readl(base + EDMA_CMD_OFS)));
 }
 
 /**
  *      mv_stop_dma - Disable eDMA engine
  *      @ap: ATA channel to manipulate
  *
- *      Verify the local cache of the eDMA state is accurate with an
- *      assert.
+ *      Verify the local cache of the eDMA state is accurate with a
+ *      WARN_ON.
  *
  *      LOCKING:
  *      Inherited from caller.
@@ -670,7 +670,7 @@ static void mv_stop_dma(struct ata_port *ap)
                 writelfl(EDMA_DS, port_mmio + EDMA_CMD_OFS);
                 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
         } else {
-                assert(!(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS)));
+                WARN_ON(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS));
         }
 
         /* now properly wait for the eDMA to stop */
@@ -1061,15 +1061,15 @@ static void mv_qc_prep(struct ata_queued_cmd *qc)
                 return;
 
         /* the req producer index should be the same as we remember it */
-        assert(((readl(mv_ap_base(qc->ap) + EDMA_REQ_Q_IN_PTR_OFS) >>
-                 EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
-               pp->req_producer);
+        WARN_ON(((readl(mv_ap_base(qc->ap) + EDMA_REQ_Q_IN_PTR_OFS) >>
+                  EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) !=
+                pp->req_producer);
 
         /* Fill in command request block
          */
         if (!(qc->tf.flags & ATA_TFLAG_WRITE))
                 flags |= CRQB_FLAG_READ;
-        assert(MV_MAX_Q_DEPTH > qc->tag);
+        WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
         flags |= qc->tag << CRQB_TAG_SHIFT;
 
         pp->crqb[pp->req_producer].sg_addr =
@@ -1152,16 +1152,16 @@ static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
                 return;
 
         /* the req producer index should be the same as we remember it */
-        assert(((readl(mv_ap_base(qc->ap) + EDMA_REQ_Q_IN_PTR_OFS) >>
-                 EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
-               pp->req_producer);
+        WARN_ON(((readl(mv_ap_base(qc->ap) + EDMA_REQ_Q_IN_PTR_OFS) >>
+                  EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) !=
+                pp->req_producer);
 
         /* Fill in Gen IIE command request block
          */
         if (!(qc->tf.flags & ATA_TFLAG_WRITE))
                 flags |= CRQB_FLAG_READ;
 
-        assert(MV_MAX_Q_DEPTH > qc->tag);
+        WARN_ON(MV_MAX_Q_DEPTH <= qc->tag);
         flags |= qc->tag << CRQB_TAG_SHIFT;
 
         crqb = (struct mv_crqb_iie *) &pp->crqb[pp->req_producer];
@@ -1226,12 +1226,12 @@ static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
         in_ptr = readl(port_mmio + EDMA_REQ_Q_IN_PTR_OFS);
 
         /* the req producer index should be the same as we remember it */
-        assert(((in_ptr >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
-               pp->req_producer);
+        WARN_ON(((in_ptr >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) !=
+                pp->req_producer);
         /* until we do queuing, the queue should be empty at this point */
-        assert(((in_ptr >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
-               ((readl(port_mmio + EDMA_REQ_Q_OUT_PTR_OFS) >>
-                 EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK));
+        WARN_ON(((in_ptr >> EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) !=
+                ((readl(port_mmio + EDMA_REQ_Q_OUT_PTR_OFS) >>
+                  EDMA_REQ_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK));
 
         mv_inc_q_index(&pp->req_producer);      /* now incr producer index */
 
@@ -1251,7 +1251,7 @@ static unsigned int mv_qc_issue(struct ata_queued_cmd *qc)
  *
  *      This routine is for use when the port is in DMA mode, when it
  *      will be using the CRPB (command response block) method of
- *      returning command completion information.  We assert indices
+ *      returning command completion information.  We check indices
  *      are good, grab status, and bump the response consumer index to
  *      prove that we're up to date.
  *
@@ -1267,16 +1267,16 @@ static u8 mv_get_crpb_status(struct ata_port *ap)
         out_ptr = readl(port_mmio + EDMA_RSP_Q_OUT_PTR_OFS);
 
         /* the response consumer index should be the same as we remember it */
-        assert(((out_ptr >> EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
-               pp->rsp_consumer);
+        WARN_ON(((out_ptr >> EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) !=
+                pp->rsp_consumer);
 
         /* increment our consumer index... */
         pp->rsp_consumer = mv_inc_q_index(&pp->rsp_consumer);
 
         /* and, until we do NCQ, there should only be 1 CRPB waiting */
-        assert(((readl(port_mmio + EDMA_RSP_Q_IN_PTR_OFS) >>
-                 EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) ==
-               pp->rsp_consumer);
+        WARN_ON(((readl(port_mmio + EDMA_RSP_Q_IN_PTR_OFS) >>
+                  EDMA_RSP_Q_PTR_SHIFT) & MV_MAX_Q_DEPTH_MASK) !=
+                pp->rsp_consumer);
 
         /* write out our inc'd consumer index so EDMA knows we're caught up */
         out_ptr &= EDMA_RSP_Q_BASE_LO_MASK;
diff --git a/drivers/scsi/sata_qstor.c b/drivers/scsi/sata_qstor.c
index d5c912763d0c..5730167d2e74 100644
--- a/drivers/scsi/sata_qstor.c
+++ b/drivers/scsi/sata_qstor.c
@@ -277,8 +277,8 @@ static unsigned int qs_fill_sg(struct ata_queued_cmd *qc)
         unsigned int nelem;
         u8 *prd = pp->pkt + QS_CPB_BYTES;
 
-        assert(qc->__sg != NULL);
-        assert(qc->n_elem > 0);
+        WARN_ON(qc->__sg == NULL);
+        WARN_ON(qc->n_elem == 0);
 
         nelem = 0;
         ata_for_each_sg(sg, qc) {
diff --git a/drivers/scsi/sata_sil.c b/drivers/scsi/sata_sil.c
index f40f25edbb11..bd2887741d78 100644
--- a/drivers/scsi/sata_sil.c
+++ b/drivers/scsi/sata_sil.c
@@ -158,7 +158,7 @@ static const struct ata_port_operations sil_ops = {
         .check_status           = ata_check_status,
         .exec_command           = ata_exec_command,
         .dev_select             = ata_std_dev_select,
-        .phy_reset              = sata_phy_reset,
+        .probe_reset            = ata_std_probe_reset,
         .post_set_mode          = sil_post_set_mode,
         .bmdma_setup            = ata_bmdma_setup,
         .bmdma_start            = ata_bmdma_start,
@@ -181,7 +181,7 @@ static const struct ata_port_info sil_port_info[] = {
         {
                 .sht            = &sil_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO,
+                                  ATA_FLAG_MMIO,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
@@ -190,8 +190,7 @@ static const struct ata_port_info sil_port_info[] = {
         {
                 .sht            = &sil_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
-                                  SIL_FLAG_MOD15WRITE,
+                                  ATA_FLAG_MMIO | SIL_FLAG_MOD15WRITE,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
@@ -200,7 +199,7 @@ static const struct ata_port_info sil_port_info[] = {
         {
                 .sht            = &sil_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO,
+                                  ATA_FLAG_MMIO,
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
diff --git a/drivers/scsi/sata_sil24.c b/drivers/scsi/sata_sil24.c
index 962396b36f61..228a7fabffff 100644
--- a/drivers/scsi/sata_sil24.c
+++ b/drivers/scsi/sata_sil24.c
@@ -249,7 +249,7 @@ static u8 sil24_check_status(struct ata_port *ap);
 static u32 sil24_scr_read(struct ata_port *ap, unsigned sc_reg);
 static void sil24_scr_write(struct ata_port *ap, unsigned sc_reg, u32 val);
 static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
-static void sil24_phy_reset(struct ata_port *ap);
+static int sil24_probe_reset(struct ata_port *ap, unsigned int *classes);
 static void sil24_qc_prep(struct ata_queued_cmd *qc);
 static unsigned int sil24_qc_issue(struct ata_queued_cmd *qc);
 static void sil24_irq_clear(struct ata_port *ap);
@@ -306,7 +306,7 @@ static const struct ata_port_operations sil24_ops = {
 
         .tf_read                = sil24_tf_read,
 
-        .phy_reset              = sil24_phy_reset,
+        .probe_reset            = sil24_probe_reset,
 
         .qc_prep                = sil24_qc_prep,
         .qc_issue               = sil24_qc_issue,
@@ -336,8 +336,8 @@ static struct ata_port_info sil24_port_info[] = {
         {
                 .sht            = &sil24_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
-                                  ATA_FLAG_PIO_DMA | SIL24_NPORTS2FLAG(4),
+                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
+                                  SIL24_NPORTS2FLAG(4),
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
@@ -347,8 +347,8 @@ static struct ata_port_info sil24_port_info[] = {
         {
                 .sht            = &sil24_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
-                                  ATA_FLAG_PIO_DMA | SIL24_NPORTS2FLAG(2),
+                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
+                                  SIL24_NPORTS2FLAG(2),
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
@@ -358,8 +358,8 @@ static struct ata_port_info sil24_port_info[] = {
         {
                 .sht            = &sil24_sht,
                 .host_flags     = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
-                                  ATA_FLAG_SRST | ATA_FLAG_MMIO |
-                                  ATA_FLAG_PIO_DMA | SIL24_NPORTS2FLAG(1),
+                                  ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
+                                  SIL24_NPORTS2FLAG(1),
                 .pio_mask       = 0x1f,                 /* pio0-4 */
                 .mwdma_mask     = 0x07,                 /* mwdma0-2 */
                 .udma_mask      = 0x3f,                 /* udma0-5 */
@@ -428,7 +428,8 @@ static void sil24_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
         *tf = pp->tf;
 }
 
-static int sil24_issue_SRST(struct ata_port *ap)
+static int sil24_softreset(struct ata_port *ap, int verbose,
+                           unsigned int *class)
 {
         void __iomem *port = (void __iomem *)ap->ioaddr.cmd_addr;
         struct sil24_port_priv *pp = ap->private_data;
@@ -437,6 +438,8 @@ static int sil24_issue_SRST(struct ata_port *ap)
         u32 irq_enable, irq_stat;
         int cnt;
 
+        DPRINTK("ENTER\n");
+
         /* temporarily turn off IRQs during SRST */
         irq_enable = readl(port + PORT_IRQ_ENABLE_SET);
         writel(irq_enable, port + PORT_IRQ_ENABLE_CLR);
@@ -466,30 +469,36 @@ static int sil24_issue_SRST(struct ata_port *ap)
         /* restore IRQs */
         writel(irq_enable, port + PORT_IRQ_ENABLE_SET);
 
-        if (!(irq_stat & PORT_IRQ_COMPLETE))
-                return -1;
+        if (sata_dev_present(ap)) {
+                if (!(irq_stat & PORT_IRQ_COMPLETE)) {
+                        DPRINTK("EXIT, srst failed\n");
+                        return -EIO;
+                }
 
-        /* update TF */
-        sil24_update_tf(ap);
+                sil24_update_tf(ap);
+                *class = ata_dev_classify(&pp->tf);
+        }
+        if (*class == ATA_DEV_UNKNOWN)
+                *class = ATA_DEV_NONE;
+
+        DPRINTK("EXIT, class=%u\n", *class);
         return 0;
 }
 
-static void sil24_phy_reset(struct ata_port *ap)
+static int sil24_hardreset(struct ata_port *ap, int verbose,
+                           unsigned int *class)
 {
-        struct sil24_port_priv *pp = ap->private_data;
+        unsigned int dummy_class;
 
-        __sata_phy_reset(ap);
-        if (ap->flags & ATA_FLAG_PORT_DISABLED)
-                return;
-
-        if (sil24_issue_SRST(ap) < 0) {
-                printk(KERN_ERR DRV_NAME
-                       " ata%u: SRST failed, disabling port\n", ap->id);
-                ap->ops->port_disable(ap);
-                return;
-        }
+        /* sil24 doesn't report device signature after hard reset */
+        return sata_std_hardreset(ap, verbose, &dummy_class);
+}
 
-        ap->device->class = ata_dev_classify(&pp->tf);
+static int sil24_probe_reset(struct ata_port *ap, unsigned int *classes)
+{
+        return ata_drive_probe_reset(ap, ata_std_probeinit,
+                                     sil24_softreset, sil24_hardreset,
+                                     ata_std_postreset, classes);
 }
 
 static inline void sil24_fill_sg(struct ata_queued_cmd *qc,
diff --git a/drivers/scsi/sata_sx4.c b/drivers/scsi/sata_sx4.c
index b7cf279deeb2..04465fb86e1d 100644
--- a/drivers/scsi/sata_sx4.c
+++ b/drivers/scsi/sata_sx4.c
@@ -461,7 +461,7 @@ static void pdc20621_dma_prep(struct ata_queued_cmd *qc)
         unsigned int i, idx, total_len = 0, sgt_len;
         u32 *buf = (u32 *) &pp->dimm_buf[PDC_DIMM_HEADER_SZ];
 
-        assert(qc->flags & ATA_QCFLAG_DMAMAP);
+        WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
 
         VPRINTK("ata%u: ENTER\n", ap->id);
 
diff --git a/drivers/serial/ioc4_serial.c b/drivers/serial/ioc4_serial.c
index 1d85533d46d2..f3763d2ccb86 100644
--- a/drivers/serial/ioc4_serial.c
+++ b/drivers/serial/ioc4_serial.c
@@ -1717,11 +1717,9 @@ ioc4_change_speed(struct uart_port *the_port,
         }
 
         if (cflag & CRTSCTS) {
-                info->flags |= ASYNC_CTS_FLOW;
                 port->ip_sscr |= IOC4_SSCR_HFC_EN;
         }
         else {
-                info->flags &= ~ASYNC_CTS_FLOW;
                 port->ip_sscr &= ~IOC4_SSCR_HFC_EN;
         }
         writel(port->ip_sscr, &port->ip_serial_regs->sscr);
@@ -1760,18 +1758,6 @@ static inline int ic4_startup_local(struct uart_port *the_port)
 
         info = the_port->info;
 
-        if (info->tty) {
-                set_bit(TTY_IO_ERROR, &info->tty->flags);
-                clear_bit(TTY_IO_ERROR, &info->tty->flags);
-                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                        info->tty->alt_speed = 57600;
-                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                        info->tty->alt_speed = 115200;
-                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
-                        info->tty->alt_speed = 230400;
-                if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
-                        info->tty->alt_speed = 460800;
-        }
         local_open(port);
 
         /* set the speed of the serial port */
diff --git a/include/asm-arm/arch-s3c2410/h1940-latch.h b/include/asm-arm/arch-s3c2410/h1940-latch.h
new file mode 100644
index 000000000000..c5802411f43d
--- /dev/null
+++ b/include/asm-arm/arch-s3c2410/h1940-latch.h
@@ -0,0 +1,64 @@
+/* linux/include/asm-arm/arch-s3c2410/h1940-latch.h
+ *
+ * (c) 2005 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ *  iPAQ H1940 series - latch definitions
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#ifndef __ASM_ARCH_H1940_LATCH_H
+#define __ASM_ARCH_H1940_LATCH_H
+
+
+#ifndef __ASSEMBLY__
+#define H1940_LATCH             ((void __iomem *)0xF8000000)
+#else
+#define H1940_LATCH             0xF8000000
+#endif
+
+#define H1940_PA_LATCH          (S3C2410_CS2)
+
+/* SD layer latch */
+
+#define H1940_LATCH_SDQ1                (1<<16)
+#define H1940_LATCH_LCD_P1              (1<<17)
+#define H1940_LATCH_LCD_P2              (1<<18)
+#define H1940_LATCH_LCD_P3              (1<<19)
+#define H1940_LATCH_MAX1698_nSHUTDOWN   (1<<20)         /* LCD backlight */
+#define H1940_LATCH_LED_RED             (1<<21)
+#define H1940_LATCH_SDQ7                (1<<22)
+#define H1940_LATCH_USB_DP              (1<<23)
+
+/* CPU layer latch */
+
+#define H1940_LATCH_UDA_POWER           (1<<24)
+#define H1940_LATCH_AUDIO_POWER         (1<<25)
+#define H1940_LATCH_SM803_ENABLE        (1<<26)
+#define H1940_LATCH_LCD_P4              (1<<27)
+#define H1940_LATCH_CPUQ5               (1<<28)         /* untraced */
+#define H1940_LATCH_BLUETOOTH_POWER     (1<<29)         /* active high */
+#define H1940_LATCH_LED_GREEN           (1<<30)
+#define H1940_LATCH_LED_FLASH           (1<<31)
+
+/* default settings */
+
+#define H1940_LATCH_DEFAULT             \
+        H1940_LATCH_LCD_P4              | \
+        H1940_LATCH_SM803_ENABLE        | \
+        H1940_LATCH_SDQ1                | \
+        H1940_LATCH_LCD_P1              | \
+        H1940_LATCH_LCD_P2              | \
+        H1940_LATCH_LCD_P3              | \
+        H1940_LATCH_MAX1698_nSHUTDOWN   | \
+        H1940_LATCH_CPUQ5
+
+/* control functions */
+
+extern void h1940_latch_control(unsigned int clear, unsigned int set);
+
+#endif /* __ASM_ARCH_H1940_LATCH_H */
diff --git a/include/asm-ia64/unistd.h b/include/asm-ia64/unistd.h
index 962f9bd1bdff..019956c613e4 100644
--- a/include/asm-ia64/unistd.h
+++ b/include/asm-ia64/unistd.h
@@ -270,12 +270,27 @@
 #define __NR_inotify_add_watch          1278
 #define __NR_inotify_rm_watch           1279
 #define __NR_migrate_pages              1280
+#define __NR_openat                     1281
+#define __NR_mkdirat                    1282
+#define __NR_mknodat                    1283
+#define __NR_fchownat                   1284
+#define __NR_futimesat                  1285
+#define __NR_newfstatat                 1286
+#define __NR_unlinkat                   1287
+#define __NR_renameat                   1288
+#define __NR_linkat                     1289
+#define __NR_symlinkat                  1290
+#define __NR_readlinkat                 1291
+#define __NR_fchmodat                   1292
+#define __NR_faccessat                  1293
+/* 1294, 1295 reserved for pselect/ppoll */
+#define __NR_unshare                    1296
 
 #ifdef __KERNEL__
 
 #include <linux/config.h>
 
-#define NR_syscalls                     270 /* length of syscall table */
+#define NR_syscalls                     273 /* length of syscall table */
 
 #define __ARCH_WANT_SYS_RT_SIGACTION
 
diff --git a/include/asm-powerpc/unistd.h b/include/asm-powerpc/unistd.h
index a40cdff21a88..35556993f066 100644
--- a/include/asm-powerpc/unistd.h
+++ b/include/asm-powerpc/unistd.h
@@ -300,8 +300,9 @@
 #define __NR_spu_create         279
 #define __NR_pselect6           280
 #define __NR_ppoll              281
+#define __NR_unshare            282
 
-#define __NR_syscalls           282
+#define __NR_syscalls           283
 
 #ifdef __KERNEL__
 #define __NR__exit __NR_exit
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 20b446f26ecd..60e56c6e03dd 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -328,7 +328,7 @@ static inline void __cpus_remap(cpumask_t *dstp, const cpumask_t *srcp,
  * bitmap of size NR_CPUS.
  *
  *  #ifdef CONFIG_HOTPLUG_CPU
- *     cpu_possible_map - all NR_CPUS bits set
+ *     cpu_possible_map - has bit 'cpu' set iff cpu is populatable
  *     cpu_present_map  - has bit 'cpu' set iff cpu is populated
  *     cpu_online_map   - has bit 'cpu' set iff cpu available to scheduler
  *  #else
diff --git a/include/linux/kbd_kern.h b/include/linux/kbd_kern.h
index 3aed37314ab8..e87c32a5c86a 100644
--- a/include/linux/kbd_kern.h
+++ b/include/linux/kbd_kern.h
@@ -153,8 +153,10 @@ static inline void con_schedule_flip(struct tty_struct *t)
 {
         unsigned long flags;
         spin_lock_irqsave(&t->buf.lock, flags);
-        if (t->buf.tail != NULL)
+        if (t->buf.tail != NULL) {
                 t->buf.tail->active = 0;
+                t->buf.tail->commit = t->buf.tail->used;
+        }
         spin_unlock_irqrestore(&t->buf.lock, flags);
         schedule_work(&t->buf.work);
 }
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index a311f58c8a7c..cfb3410e32b1 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -6,6 +6,7 @@
 #include <linux/list.h>
 #include <linux/linkage.h>
 #include <linux/compat.h>
+#include <linux/ioport.h>
 #include <asm/kexec.h>
 
 /* Verify architecture specific macros are defined */
diff --git a/include/linux/libata.h b/include/linux/libata.h
index b169f9098649..9873f4c54f1e 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -62,16 +62,6 @@
 
 #define BPRINTK(fmt, args...) if (ap->flags & ATA_FLAG_DEBUGMSG) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
 
-#ifdef ATA_NDEBUG
-#define assert(expr)
-#else
-#define assert(expr) \
-        if(unlikely(!(expr))) {                                   \
-        printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
-        #expr,__FILE__,__FUNCTION__,__LINE__);          \
-        }
-#endif
-
 /* NEW: debug levels */
 #define HAVE_LIBATA_MSG 1
 
@@ -559,7 +549,7 @@ extern void ata_bmdma_start (struct ata_queued_cmd *qc);
 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
 extern u8   ata_bmdma_status(struct ata_port *ap);
 extern void ata_bmdma_irq_clear(struct ata_port *ap);
-extern void ata_qc_complete(struct ata_queued_cmd *qc);
+extern void __ata_qc_complete(struct ata_queued_cmd *qc);
 extern void ata_eng_timeout(struct ata_port *ap);
 extern void ata_scsi_simulate(struct ata_port *ap, struct ata_device *dev,
                               struct scsi_cmnd *cmd,
@@ -759,6 +749,24 @@ static inline void ata_qc_reinit(struct ata_queued_cmd *qc)
         ata_tf_init(qc->ap, &qc->tf, qc->dev->devno);
 }
 
+/**
+ *      ata_qc_complete - Complete an active ATA command
+ *      @qc: Command to complete
+ *      @err_mask: ATA Status register contents
+ *
+ *      Indicate to the mid and upper layers that an ATA
+ *      command has completed, with either an ok or not-ok status.
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host_set lock)
+ */
+static inline void ata_qc_complete(struct ata_queued_cmd *qc)
+{
+        if (unlikely(qc->flags & ATA_QCFLAG_EH_SCHEDULED))
+                return;
+
+        __ata_qc_complete(qc);
+}
 
 /**
  *      ata_irq_on - Enable interrupts on a port.
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 6a2ccf78a356..c256ebe2a7b4 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -160,7 +160,8 @@ extern int netlink_unregister_notifier(struct notifier_block *nb);
 
 /* finegrained unicast helpers: */
 struct sock *netlink_getsockbyfilp(struct file *filp);
-int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock, long timeo);
+int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
+                long timeo, struct sock *ssk);
 void netlink_detachskb(struct sock *sk, struct sk_buff *skb);
 int netlink_sendskb(struct sock *sk, struct sk_buff *skb, int protocol);
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 0cfcd1c7865e..9c1da0269a18 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1098,7 +1098,7 @@ extern struct sigqueue *sigqueue_alloc(void);
 extern void sigqueue_free(struct sigqueue *);
 extern int send_sigqueue(int, struct sigqueue *,  struct task_struct *);
 extern int send_group_sigqueue(int, struct sigqueue *,  struct task_struct *);
-extern int do_sigaction(int, const struct k_sigaction *, struct k_sigaction *);
+extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
 extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
 
 /* These can be the second arg to send_sig_info/send_group_sig_info.  */
diff --git a/include/linux/tty.h b/include/linux/tty.h
index a7bd3b4558d2..f45cd74e6f24 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -58,6 +58,8 @@ struct tty_buffer {
         int used;
         int size;
         int active;
+        int commit;
+        int read;
         /* Data points here */
         unsigned long data[0];
 };
diff --git a/include/linux/tty_flip.h b/include/linux/tty_flip.h
index 82961eb19888..222faf97d5f9 100644
--- a/include/linux/tty_flip.h
+++ b/include/linux/tty_flip.h
@@ -29,8 +29,10 @@ _INLINE_ void tty_schedule_flip(struct tty_struct *tty)
 {
         unsigned long flags;
         spin_lock_irqsave(&tty->buf.lock, flags);
-        if (tty->buf.tail != NULL)
+        if (tty->buf.tail != NULL) {
                 tty->buf.tail->active = 0;
+                tty->buf.tail->commit = tty->buf.tail->used;
+        }
         spin_unlock_irqrestore(&tty->buf.lock, flags);
         schedule_delayed_work(&tty->buf.work, 1);
 }
diff --git a/include/net/irda/irlap.h b/include/net/irda/irlap.h
index f55e86e75030..2127cae1e0a6 100644
--- a/include/net/irda/irlap.h
+++ b/include/net/irda/irlap.h
@@ -50,6 +50,9 @@
 /* May be different when we get VFIR */
 #define LAP_MAX_HEADER (LAP_ADDR_HEADER + LAP_CTRL_HEADER)
 
+/* Each IrDA device gets a random 32 bits IRLAP device address */
+#define LAP_ALEN 4
+
 #define BROADCAST  0xffffffff /* Broadcast device address */
 #define CBROADCAST 0xfe       /* Connection broadcast address */
 #define XID_FORMAT 0x01       /* Discovery XID format */
diff --git a/init/initramfs.c b/init/initramfs.c
index 0c5d9a3f951b..637344b05981 100644
--- a/init/initramfs.c
+++ b/init/initramfs.c
@@ -466,10 +466,32 @@ static char * __init unpack_to_rootfs(char *buf, unsigned len, int check_only)
 extern char __initramfs_start[], __initramfs_end[];
 #ifdef CONFIG_BLK_DEV_INITRD
 #include <linux/initrd.h>
+#include <linux/kexec.h>
 
 static void __init free_initrd(void)
 {
-        free_initrd_mem(initrd_start, initrd_end);
+#ifdef CONFIG_KEXEC
+        unsigned long crashk_start = (unsigned long)__va(crashk_res.start);
+        unsigned long crashk_end   = (unsigned long)__va(crashk_res.end);
+
+        /*
+         * If the initrd region is overlapped with crashkernel reserved region,
+         * free only memory that is not part of crashkernel region.
+         */
+        if (initrd_start < crashk_end && initrd_end > crashk_start) {
+                /*
+                 * Initialize initrd memory region since the kexec boot does
+                 * not do.
+                 */
+                memset((void *)initrd_start, 0, initrd_end - initrd_start);
+                if (initrd_start < crashk_start)
+                        free_initrd_mem(initrd_start, crashk_start);
+                if (initrd_end > crashk_end)
+                        free_initrd_mem(crashk_end, initrd_end);
+        } else
+#endif
+                free_initrd_mem(initrd_start, initrd_end);
+
         initrd_start = 0;
         initrd_end = 0;
 }
diff --git a/init/main.c b/init/main.c
index 7c79da57d3a2..4c194c47395f 100644
--- a/init/main.c
+++ b/init/main.c
@@ -668,7 +668,6 @@ static int init(void * unused)
          */
         child_reaper = current;
 
-        /* Sets up cpus_possible() */
         smp_prepare_cpus(max_cpus);
 
         do_pre_smp_initcalls();
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 59302fc3643b..fd2e26b6f966 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -1018,7 +1018,8 @@ retry:
                                 goto out;
                         }
 
-                        ret = netlink_attachskb(sock, nc, 0, MAX_SCHEDULE_TIMEOUT);
+                        ret = netlink_attachskb(sock, nc, 0,
+                                        MAX_SCHEDULE_TIMEOUT, NULL);
                         if (ret == 1)
                                 goto retry;
                         if (ret) {
diff --git a/ipc/shm.c b/ipc/shm.c
index 4c28d2d8e305..9162123a7b23 100644
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -870,6 +870,7 @@ asmlinkage long sys_shmdt(char __user *shmaddr)
          * could possibly have landed at. Also cast things to loff_t to
          * prevent overflows and make comparisions vs. equal-width types.
          */
+        size = PAGE_ALIGN(size);
         while (vma && (loff_t)(vma->vm_end - addr) <= size) {
                 next = vma->vm_next;
 
diff --git a/kernel/panic.c b/kernel/panic.c
index c5c4ab255834..126dc43f1c74 100644
--- a/kernel/panic.c
+++ b/kernel/panic.c
@@ -130,6 +130,7 @@ NORET_TYPE void panic(const char * fmt, ...)
 #endif
         local_irq_enable();
         for (i = 0;;) {
+                touch_softlockup_watchdog();
                 i += panic_blink(i);
                 mdelay(1);
                 i++;
diff --git a/kernel/sched.c b/kernel/sched.c
index bc38804e40dd..87d93be336a1 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -215,7 +215,6 @@ struct runqueue {
          */
         unsigned long nr_running;
 #ifdef CONFIG_SMP
-        unsigned long prio_bias;
         unsigned long cpu_load[3];
 #endif
         unsigned long long nr_switches;
@@ -669,68 +668,13 @@ static int effective_prio(task_t *p)
         return prio;
 }
 
-#ifdef CONFIG_SMP
-static inline void inc_prio_bias(runqueue_t *rq, int prio)
-{
-        rq->prio_bias += MAX_PRIO - prio;
-}
-
-static inline void dec_prio_bias(runqueue_t *rq, int prio)
-{
-        rq->prio_bias -= MAX_PRIO - prio;
-}
-
-static inline void inc_nr_running(task_t *p, runqueue_t *rq)
-{
-        rq->nr_running++;
-        if (rt_task(p)) {
-                if (p != rq->migration_thread)
-                        /*
-                         * The migration thread does the actual balancing. Do
-                         * not bias by its priority as the ultra high priority
-                         * will skew balancing adversely.
-                         */
-                        inc_prio_bias(rq, p->prio);
-        } else
-                inc_prio_bias(rq, p->static_prio);
-}
-
-static inline void dec_nr_running(task_t *p, runqueue_t *rq)
-{
-        rq->nr_running--;
-        if (rt_task(p)) {
-                if (p != rq->migration_thread)
-                        dec_prio_bias(rq, p->prio);
-        } else
-                dec_prio_bias(rq, p->static_prio);
-}
-#else
-static inline void inc_prio_bias(runqueue_t *rq, int prio)
-{
-}
-
-static inline void dec_prio_bias(runqueue_t *rq, int prio)
-{
-}
-
-static inline void inc_nr_running(task_t *p, runqueue_t *rq)
-{
-        rq->nr_running++;
-}
-
-static inline void dec_nr_running(task_t *p, runqueue_t *rq)
-{
-        rq->nr_running--;
-}
-#endif
-
 /*
  * __activate_task - move a task to the runqueue.
  */
 static inline void __activate_task(task_t *p, runqueue_t *rq)
 {
         enqueue_task(p, rq->active);
-        inc_nr_running(p, rq);
+        rq->nr_running++;
 }
 
 /*
@@ -739,7 +683,7 @@ static inline void __activate_task(task_t *p, runqueue_t *rq)
 static inline void __activate_idle_task(task_t *p, runqueue_t *rq)
 {
         enqueue_task_head(p, rq->active);
-        inc_nr_running(p, rq);
+        rq->nr_running++;
 }
 
 static int recalc_task_prio(task_t *p, unsigned long long now)
@@ -863,7 +807,7 @@ static void activate_task(task_t *p, runqueue_t *rq, int local)
  */
 static void deactivate_task(struct task_struct *p, runqueue_t *rq)
 {
-        dec_nr_running(p, rq);
+        rq->nr_running--;
         dequeue_task(p, p->array);
         p->array = NULL;
 }
@@ -1007,61 +951,27 @@ void kick_process(task_t *p)
  * We want to under-estimate the load of migration sources, to
  * balance conservatively.
  */
-static unsigned long __source_load(int cpu, int type, enum idle_type idle)
+static inline unsigned long source_load(int cpu, int type)
 {
         runqueue_t *rq = cpu_rq(cpu);
-        unsigned long running = rq->nr_running;
-        unsigned long source_load, cpu_load = rq->cpu_load[type-1],
-                load_now = running * SCHED_LOAD_SCALE;
-
+        unsigned long load_now = rq->nr_running * SCHED_LOAD_SCALE;
         if (type == 0)
-                source_load = load_now;
-        else
-                source_load = min(cpu_load, load_now);
-
-        if (running > 1 || (idle == NOT_IDLE && running))
-                /*
-                 * If we are busy rebalancing the load is biased by
-                 * priority to create 'nice' support across cpus. When
-                 * idle rebalancing we should only bias the source_load if
-                 * there is more than one task running on that queue to
-                 * prevent idle rebalance from trying to pull tasks from a
-                 * queue with only one running task.
-                 */
-                source_load = source_load * rq->prio_bias / running;
+                return load_now;
 
-        return source_load;
-}
-
-static inline unsigned long source_load(int cpu, int type)
-{
-        return __source_load(cpu, type, NOT_IDLE);
+        return min(rq->cpu_load[type-1], load_now);
 }
 
 /*
  * Return a high guess at the load of a migration-target cpu
  */
-static inline unsigned long __target_load(int cpu, int type, enum idle_type idle)
+static inline unsigned long target_load(int cpu, int type)
 {
         runqueue_t *rq = cpu_rq(cpu);
-        unsigned long running = rq->nr_running;
-        unsigned long target_load, cpu_load = rq->cpu_load[type-1],
-                load_now = running * SCHED_LOAD_SCALE;
-
+        unsigned long load_now = rq->nr_running * SCHED_LOAD_SCALE;
         if (type == 0)
-                target_load = load_now;
-        else
-                target_load = max(cpu_load, load_now);
+                return load_now;
 
-        if (running > 1 || (idle == NOT_IDLE && running))
-                target_load = target_load * rq->prio_bias / running;
-
-        return target_load;
-}
-
-static inline unsigned long target_load(int cpu, int type)
-{
-        return __target_load(cpu, type, NOT_IDLE);
+        return max(rq->cpu_load[type-1], load_now);
 }
 
 /*
@@ -1530,7 +1440,7 @@ void fastcall wake_up_new_task(task_t *p, unsigned long clone_flags)
                                 list_add_tail(&p->run_list, &current->run_list);
                                 p->array = current->array;
                                 p->array->nr_active++;
-                                inc_nr_running(p, rq);
+                                rq->nr_running++;
                         }
                         set_need_resched();
                 } else
@@ -1875,9 +1785,9 @@ void pull_task(runqueue_t *src_rq, prio_array_t *src_array, task_t *p,
                runqueue_t *this_rq, prio_array_t *this_array, int this_cpu)
 {
         dequeue_task(p, src_array);
-        dec_nr_running(p, src_rq);
+        src_rq->nr_running--;
         set_task_cpu(p, this_cpu);
-        inc_nr_running(p, this_rq);
+        this_rq->nr_running++;
         enqueue_task(p, this_array);
         p->timestamp = (p->timestamp - src_rq->timestamp_last_tick)
                                 + this_rq->timestamp_last_tick;
@@ -2056,9 +1966,9 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
 
                         /* Bias balancing toward cpus of our domain */
                         if (local_group)
-                                load = __target_load(i, load_idx, idle);
+                                load = target_load(i, load_idx);
                         else
-                                load = __source_load(i, load_idx, idle);
+                                load = source_load(i, load_idx);
 
                         avg_load += load;
                 }
@@ -2171,7 +2081,7 @@ static runqueue_t *find_busiest_queue(struct sched_group *group,
         int i;
 
         for_each_cpu_mask(i, group->cpumask) {
-                load = __source_load(i, 0, idle);
+                load = source_load(i, 0);
 
                 if (load > max_load) {
                         max_load = load;
@@ -3571,10 +3481,8 @@ void set_user_nice(task_t *p, long nice)
                 goto out_unlock;
         }
         array = p->array;
-        if (array) {
+        if (array)
                 dequeue_task(p, array);
-                dec_prio_bias(rq, p->static_prio);
-        }
 
         old_prio = p->prio;
         new_prio = NICE_TO_PRIO(nice);
@@ -3584,7 +3492,6 @@ void set_user_nice(task_t *p, long nice)
 
         if (array) {
                 enqueue_task(p, array);
-                inc_prio_bias(rq, p->static_prio);
                 /*
                  * If the task increased its priority or is running and
                  * lowered its priority, then reschedule its CPU:
diff --git a/kernel/signal.c b/kernel/signal.c
index b373fc2420da..ea154104a00b 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -2430,7 +2430,7 @@ sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
 }
 
 int
-do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
+do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
 {
         struct k_sigaction *k;
         sigset_t mask;
@@ -2454,6 +2454,8 @@ do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
                 *oact = *k;
 
         if (act) {
+                sigdelsetmask(&act->sa.sa_mask,
+                              sigmask(SIGKILL) | sigmask(SIGSTOP));
                 /*
                  * POSIX 3.3.1.3:
                  *  "Setting a signal action to SIG_IGN for a signal that is
@@ -2479,8 +2481,6 @@ do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
                         read_lock(&tasklist_lock);
                         spin_lock_irq(&t->sighand->siglock);
                         *k = *act;
-                        sigdelsetmask(&k->sa.sa_mask,
-                                      sigmask(SIGKILL) | sigmask(SIGSTOP));
                         sigemptyset(&mask);
                         sigaddset(&mask, sig);
                         rm_from_queue_full(&mask, &t->signal->shared_pending);
@@ -2495,8 +2495,6 @@ do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
                 }
 
                 *k = *act;
-                sigdelsetmask(&k->sa.sa_mask,
-                              sigmask(SIGKILL) | sigmask(SIGSTOP));
         }
 
         spin_unlock_irq(&current->sighand->siglock);
@@ -2702,6 +2700,7 @@ sys_signal(int sig, __sighandler_t handler)
 
         new_sa.sa.sa_handler = handler;
         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
+        sigemptyset(&new_sa.sa.sa_mask);
 
         ret = do_sigaction(sig, &new_sa, &old_sa);
 
diff --git a/mm/slab.c b/mm/slab.c
index d66c2b0d9715..add05d808a4a 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1717,6 +1717,12 @@ kmem_cache_create (const char *name, size_t size, size_t align,
                 BUG();
         }
 
+        /*
+         * Prevent CPUs from coming and going.
+         * lock_cpu_hotplug() nests outside cache_chain_mutex
+         */
+        lock_cpu_hotplug();
+
         mutex_lock(&cache_chain_mutex);
 
         list_for_each(p, &cache_chain) {
@@ -1918,8 +1924,6 @@ kmem_cache_create (const char *name, size_t size, size_t align,
         cachep->dtor = dtor;
         cachep->name = name;
 
-        /* Don't let CPUs to come and go */
-        lock_cpu_hotplug();
 
         if (g_cpucache_up == FULL) {
                 enable_cpucache(cachep);
@@ -1978,12 +1982,12 @@ kmem_cache_create (const char *name, size_t size, size_t align,
 
         /* cache setup completed, link it into the list */
         list_add(&cachep->next, &cache_chain);
-        unlock_cpu_hotplug();
       oops:
         if (!cachep && (flags & SLAB_PANIC))
                 panic("kmem_cache_create(): failed to create slab `%s'\n",
                       name);
         mutex_unlock(&cache_chain_mutex);
+        unlock_cpu_hotplug();
         return cachep;
 }
 EXPORT_SYMBOL(kmem_cache_create);
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 5a610804cd06..5db32fdfaf39 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -632,7 +632,7 @@ static int swap_page(struct page *page)
         struct address_space *mapping = page_mapping(page);
 
         if (page_mapped(page) && mapping)
-                if (try_to_unmap(page, 0) != SWAP_SUCCESS)
+                if (try_to_unmap(page, 1) != SWAP_SUCCESS)
                         goto unlock_retry;
 
         if (PageDirty(page)) {
@@ -839,7 +839,7 @@ EXPORT_SYMBOL(migrate_page);
  * pages are swapped out.
  *
  * The function returns after 10 attempts or if no pages
- * are movable anymore because t has become empty
+ * are movable anymore because to has become empty
  * or no retryable pages exist anymore.
  *
  * Return: Number of pages not migrated when "to" ran empty.
@@ -928,12 +928,21 @@ redo:
                         goto unlock_both;
 
                 if (mapping->a_ops->migratepage) {
+                        /*
+                         * Most pages have a mapping and most filesystems
+                         * should provide a migration function. Anonymous
+                         * pages are part of swap space which also has its
+                         * own migration function. This is the most common
+                         * path for page migration.
+                         */
                         rc = mapping->a_ops->migratepage(newpage, page);
                         goto unlock_both;
                 }
 
                 /*
-                 * Trigger writeout if page is dirty
+                 * Default handling if a filesystem does not provide
+                 * a migration function. We can only migrate clean
+                 * pages so try to write out any dirty pages first.
                  */
                 if (PageDirty(page)) {
                         switch (pageout(page, mapping)) {
@@ -949,9 +958,10 @@ redo:
                                 ; /* try to migrate the page below */
                         }
                 }
+
                 /*
-                 * If we have no buffer or can release the buffer
-                 * then do a simple migration.
+                 * Buffers are managed in a filesystem specific way.
+                 * We must have no buffers or drop them.
                  */
                 if (!page_has_buffers(page) ||
                     try_to_release_page(page, GFP_KERNEL)) {
@@ -966,6 +976,11 @@ redo:
                  * swap them out.
                  */
                 if (pass > 4) {
+                        /*
+                         * Persistently unable to drop buffers..... As a
+                         * measure of last resort we fall back to
+                         * swap_page().
+                         */
                         unlock_page(newpage);
                         newpage = NULL;
                         rc = swap_page(page);
diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index da687c8dc6ff..7fa3a5a9971f 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -79,9 +79,14 @@ static int port_cost(struct net_device *dev)
  */
 static void port_carrier_check(void *arg)
 {
-        struct net_bridge_port *p = arg;
+        struct net_device *dev = arg;
+        struct net_bridge_port *p;
 
         rtnl_lock();
+        p = dev->br_port;
+        if (!p)
+                goto done;
+
         if (netif_carrier_ok(p->dev)) {
                 u32 cost = port_cost(p->dev);
 
@@ -97,19 +102,33 @@ static void port_carrier_check(void *arg)
                         br_stp_disable_port(p);
                 spin_unlock_bh(&p->br->lock);
         }
+done:
         rtnl_unlock();
 }
 
+static void release_nbp(struct kobject *kobj)
+{
+        struct net_bridge_port *p
+                = container_of(kobj, struct net_bridge_port, kobj);
+        kfree(p);
+}
+
+static struct kobj_type brport_ktype = {
+#ifdef CONFIG_SYSFS
+        .sysfs_ops = &brport_sysfs_ops,
+#endif
+        .release = release_nbp,
+};
+
 static void destroy_nbp(struct net_bridge_port *p)
 {
         struct net_device *dev = p->dev;
 
-        dev->br_port = NULL;
         p->br = NULL;
         p->dev = NULL;
         dev_put(dev);
 
-        br_sysfs_freeif(p);
+        kobject_put(&p->kobj);
 }
 
 static void destroy_nbp_rcu(struct rcu_head *head)
@@ -133,24 +152,24 @@ static void del_nbp(struct net_bridge_port *p)
         struct net_bridge *br = p->br;
         struct net_device *dev = p->dev;
 
-        /* Race between RTNL notify and RCU callback */
-        if (p->deleted)
-                return;
+        sysfs_remove_link(&br->ifobj, dev->name);
 
         dev_set_promiscuity(dev, -1);
 
         cancel_delayed_work(&p->carrier_check);
-        flush_scheduled_work();
 
         spin_lock_bh(&br->lock);
         br_stp_disable_port(p);
-        p->deleted = 1;
         spin_unlock_bh(&br->lock);
 
         br_fdb_delete_by_port(br, p);
 
         list_del_rcu(&p->list);
 
+        rcu_assign_pointer(dev->br_port, NULL);
+
+        kobject_del(&p->kobj);
+
         call_rcu(&p->rcu, destroy_nbp_rcu);
 }
 
@@ -160,7 +179,6 @@ static void del_br(struct net_bridge *br)
         struct net_bridge_port *p, *n;
 
         list_for_each_entry_safe(p, n, &br->port_list, list) {
-                br_sysfs_removeif(p);
                 del_nbp(p);
         }
 
@@ -254,13 +272,17 @@ static struct net_bridge_port *new_nbp(struct net_bridge *br,
         p->dev = dev;
         p->path_cost = port_cost(dev);
         p->priority = 0x8000 >> BR_PORT_BITS;
-        dev->br_port = p;
         p->port_no = index;
         br_init_port(p);
         p->state = BR_STATE_DISABLED;
-        INIT_WORK(&p->carrier_check, port_carrier_check, p);
+        INIT_WORK(&p->carrier_check, port_carrier_check, dev);
         kobject_init(&p->kobj);
 
+        kobject_set_name(&p->kobj, SYSFS_BRIDGE_PORT_ATTR);
+        p->kobj.ktype = &brport_ktype;
+        p->kobj.parent = &(dev->class_dev.kobj);
+        p->kobj.kset = NULL;
+
         return p;
 }
 
@@ -388,30 +410,43 @@ int br_add_if(struct net_bridge *br, struct net_device *dev)
         if (dev->br_port != NULL)
                 return -EBUSY;
 
-        if (IS_ERR(p = new_nbp(br, dev)))
+        p = new_nbp(br, dev);
+        if (IS_ERR(p))
                 return PTR_ERR(p);
 
-        if ((err = br_fdb_insert(br, p, dev->dev_addr)))
-                destroy_nbp(p);
- 
-        else if ((err = br_sysfs_addif(p)))
-                del_nbp(p);
-        else {
-                dev_set_promiscuity(dev, 1);
+        err = kobject_add(&p->kobj);
+        if (err)
+                goto err0;
 
-                list_add_rcu(&p->list, &br->port_list);
+        err = br_fdb_insert(br, p, dev->dev_addr);
+        if (err)
+                goto err1;
 
-                spin_lock_bh(&br->lock);
-                br_stp_recalculate_bridge_id(br);
-                br_features_recompute(br);
-                if ((br->dev->flags & IFF_UP) 
-                    && (dev->flags & IFF_UP) && netif_carrier_ok(dev))
-                        br_stp_enable_port(p);
-                spin_unlock_bh(&br->lock);
+        err = br_sysfs_addif(p);
+        if (err)
+                goto err2;
 
-                dev_set_mtu(br->dev, br_min_mtu(br));
-        }
+        rcu_assign_pointer(dev->br_port, p);
+        dev_set_promiscuity(dev, 1);
+
+        list_add_rcu(&p->list, &br->port_list);
 
+        spin_lock_bh(&br->lock);
+        br_stp_recalculate_bridge_id(br);
+        br_features_recompute(br);
+        schedule_delayed_work(&p->carrier_check, BR_PORT_DEBOUNCE);
+        spin_unlock_bh(&br->lock);
+
+        dev_set_mtu(br->dev, br_min_mtu(br));
+        kobject_uevent(&p->kobj, KOBJ_ADD);
+
+        return 0;
+err2:
+        br_fdb_delete_by_port(br, p);
+err1:
+        kobject_del(&p->kobj);
+err0:
+        kobject_put(&p->kobj);
         return err;
 }
 
@@ -423,7 +458,6 @@ int br_del_if(struct net_bridge *br, struct net_device *dev)
         if (!p || p->br != br) 
                 return -EINVAL;
 
-        br_sysfs_removeif(p);
         del_nbp(p);
 
         spin_lock_bh(&br->lock);
diff --git a/net/bridge/br_input.c b/net/bridge/br_input.c
index e3a73cead6b6..4eef83755315 100644
--- a/net/bridge/br_input.c
+++ b/net/bridge/br_input.c
@@ -45,18 +45,20 @@ static void br_pass_frame_up(struct net_bridge *br, struct sk_buff *skb)
 int br_handle_frame_finish(struct sk_buff *skb)
 {
         const unsigned char *dest = eth_hdr(skb)->h_dest;
-        struct net_bridge_port *p = skb->dev->br_port;
-        struct net_bridge *br = p->br;
+        struct net_bridge_port *p = rcu_dereference(skb->dev->br_port);
+        struct net_bridge *br;
         struct net_bridge_fdb_entry *dst;
         int passedup = 0;
 
+        if (!p || p->state == BR_STATE_DISABLED)
+                goto drop;
+
         /* insert into forwarding database after filtering to avoid spoofing */
-        br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
+        br = p->br;
+        br_fdb_update(br, p, eth_hdr(skb)->h_source);
 
-        if (p->state == BR_STATE_LEARNING) {
-                kfree_skb(skb);
-                goto out;
-        }
+        if (p->state == BR_STATE_LEARNING)
+                goto drop;
 
         if (br->dev->flags & IFF_PROMISC) {
                 struct sk_buff *skb2;
@@ -93,6 +95,9 @@ int br_handle_frame_finish(struct sk_buff *skb)
 
 out:
         return 0;
+drop:
+        kfree_skb(skb);
+        goto out;
 }
 
 /*
diff --git a/net/bridge/br_netfilter.c b/net/bridge/br_netfilter.c
index 7cac3fb9f809..b5018166b0e5 100644
--- a/net/bridge/br_netfilter.c
+++ b/net/bridge/br_netfilter.c
@@ -51,9 +51,6 @@
 #define store_orig_dstaddr(skb)  (skb_origaddr(skb) = (skb)->nh.iph->daddr)
 #define dnat_took_place(skb)     (skb_origaddr(skb) != (skb)->nh.iph->daddr)
 
-#define has_bridge_parent(device)       ((device)->br_port != NULL)
-#define bridge_parent(device)           ((device)->br_port->br->dev)
-
 #ifdef CONFIG_SYSCTL
 static struct ctl_table_header *brnf_sysctl_header;
 static int brnf_call_iptables = 1;
@@ -98,6 +95,12 @@ static struct rtable __fake_rtable = {
         .rt_flags       = 0,
 };
 
+static inline struct net_device *bridge_parent(const struct net_device *dev)
+{
+        struct net_bridge_port *port = rcu_dereference(dev->br_port);
+
+        return port ? port->br->dev : NULL;
+}
 
 /* PF_BRIDGE/PRE_ROUTING *********************************************/
 /* Undo the changes made for ip6tables PREROUTING and continue the
@@ -189,11 +192,15 @@ static int br_nf_pre_routing_finish_bridge(struct sk_buff *skb)
         skb->nf_bridge->mask ^= BRNF_NF_BRIDGE_PREROUTING;
 
         skb->dev = bridge_parent(skb->dev);
-        if (skb->protocol == __constant_htons(ETH_P_8021Q)) {
-                skb_pull(skb, VLAN_HLEN);
-                skb->nh.raw += VLAN_HLEN;
+        if (!skb->dev)
+                kfree_skb(skb);
+        else {
+                if (skb->protocol == __constant_htons(ETH_P_8021Q)) {
+                        skb_pull(skb, VLAN_HLEN);
+                        skb->nh.raw += VLAN_HLEN;
+                }
+                skb->dst->output(skb);
         }
-        skb->dst->output(skb);
         return 0;
 }
 
@@ -270,7 +277,7 @@ bridged_dnat:
 }
 
 /* Some common code for IPv4/IPv6 */
-static void setup_pre_routing(struct sk_buff *skb)
+static struct net_device *setup_pre_routing(struct sk_buff *skb)
 {
         struct nf_bridge_info *nf_bridge = skb->nf_bridge;
 
@@ -282,6 +289,8 @@ static void setup_pre_routing(struct sk_buff *skb)
         nf_bridge->mask |= BRNF_NF_BRIDGE_PREROUTING;
         nf_bridge->physindev = skb->dev;
         skb->dev = bridge_parent(skb->dev);
+
+        return skb->dev;
 }
 
 /* We only check the length. A bridge shouldn't do any hop-by-hop stuff anyway */
@@ -376,7 +385,8 @@ static unsigned int br_nf_pre_routing_ipv6(unsigned int hook,
         nf_bridge_put(skb->nf_bridge);
         if ((nf_bridge = nf_bridge_alloc(skb)) == NULL)
                 return NF_DROP;
-        setup_pre_routing(skb);
+        if (!setup_pre_routing(skb))
+                return NF_DROP;
 
         NF_HOOK(PF_INET6, NF_IP6_PRE_ROUTING, skb, skb->dev, NULL,
                 br_nf_pre_routing_finish_ipv6);
@@ -465,7 +475,8 @@ static unsigned int br_nf_pre_routing(unsigned int hook, struct sk_buff **pskb,
         nf_bridge_put(skb->nf_bridge);
         if ((nf_bridge = nf_bridge_alloc(skb)) == NULL)
                 return NF_DROP;
-        setup_pre_routing(skb);
+        if (!setup_pre_routing(skb))
+                return NF_DROP;
         store_orig_dstaddr(skb);
 
         NF_HOOK(PF_INET, NF_IP_PRE_ROUTING, skb, skb->dev, NULL,
@@ -539,11 +550,16 @@ static unsigned int br_nf_forward_ip(unsigned int hook, struct sk_buff **pskb,
         struct sk_buff *skb = *pskb;
         struct nf_bridge_info *nf_bridge;
         struct vlan_ethhdr *hdr = vlan_eth_hdr(skb);
+        struct net_device *parent;
         int pf;
 
         if (!skb->nf_bridge)
                 return NF_ACCEPT;
 
+        parent = bridge_parent(out);
+        if (!parent)
+                return NF_DROP;
+
         if (skb->protocol == __constant_htons(ETH_P_IP) || IS_VLAN_IP)
                 pf = PF_INET;
         else
@@ -564,8 +580,8 @@ static unsigned int br_nf_forward_ip(unsigned int hook, struct sk_buff **pskb,
         nf_bridge->mask |= BRNF_BRIDGED;
         nf_bridge->physoutdev = skb->dev;
 
-        NF_HOOK(pf, NF_IP_FORWARD, skb, bridge_parent(in),
-                bridge_parent(out), br_nf_forward_finish);
+        NF_HOOK(pf, NF_IP_FORWARD, skb, bridge_parent(in), parent,
+                br_nf_forward_finish);
 
         return NF_STOLEN;
 }
@@ -688,6 +704,8 @@ static unsigned int br_nf_local_out(unsigned int hook, struct sk_buff **pskb,
                 goto out;
         }
         realoutdev = bridge_parent(skb->dev);
+        if (!realoutdev)
+                return NF_DROP;
 
 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
         /* iptables should match -o br0.x */
@@ -701,9 +719,11 @@ static unsigned int br_nf_local_out(unsigned int hook, struct sk_buff **pskb,
         /* IP forwarded traffic has a physindev, locally
          * generated traffic hasn't. */
         if (realindev != NULL) {
-                if (!(nf_bridge->mask & BRNF_DONT_TAKE_PARENT) &&
-                    has_bridge_parent(realindev))
-                        realindev = bridge_parent(realindev);
+                if (!(nf_bridge->mask & BRNF_DONT_TAKE_PARENT) ) {
+                        struct net_device *parent = bridge_parent(realindev);
+                        if (parent)
+                                realindev = parent;
+                }
 
                 NF_HOOK_THRESH(pf, NF_IP_FORWARD, skb, realindev,
                                realoutdev, br_nf_local_out_finish,
@@ -743,6 +763,9 @@ static unsigned int br_nf_post_routing(unsigned int hook, struct sk_buff **pskb,
         if (!nf_bridge)
                 return NF_ACCEPT;
 
+        if (!realoutdev)
+                return NF_DROP;
+
         if (skb->protocol == __constant_htons(ETH_P_IP) || IS_VLAN_IP)
                 pf = PF_INET;
         else
diff --git a/net/bridge/br_private.h b/net/bridge/br_private.h
index e330b17b6d81..8f10e09f251b 100644
--- a/net/bridge/br_private.h
+++ b/net/bridge/br_private.h
@@ -68,7 +68,6 @@ struct net_bridge_port
         /* STP */
         u8                              priority;
         u8                              state;
-        u8                              deleted;
         u16                             port_no;
         unsigned char                   topology_change_ack;
         unsigned char                   config_pending;
@@ -233,9 +232,8 @@ extern void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent);
 
 #ifdef CONFIG_SYSFS
 /* br_sysfs_if.c */
+extern struct sysfs_ops brport_sysfs_ops;
 extern int br_sysfs_addif(struct net_bridge_port *p);
-extern void br_sysfs_removeif(struct net_bridge_port *p);
-extern void br_sysfs_freeif(struct net_bridge_port *p);
 
 /* br_sysfs_br.c */
 extern int br_sysfs_addbr(struct net_device *dev);
@@ -244,8 +242,6 @@ extern void br_sysfs_delbr(struct net_device *dev);
 #else
 
 #define br_sysfs_addif(p)       (0)
-#define br_sysfs_removeif(p)    do { } while(0)
-#define br_sysfs_freeif(p)      kfree(p)
 #define br_sysfs_addbr(dev)     (0)
 #define br_sysfs_delbr(dev)     do { } while(0)
 #endif /* CONFIG_SYSFS */
diff --git a/net/bridge/br_stp_bpdu.c b/net/bridge/br_stp_bpdu.c
index d071f1c9ad0b..296f6a487c52 100644
--- a/net/bridge/br_stp_bpdu.c
+++ b/net/bridge/br_stp_bpdu.c
@@ -133,29 +133,35 @@ void br_send_tcn_bpdu(struct net_bridge_port *p)
 
 static const unsigned char header[6] = {0x42, 0x42, 0x03, 0x00, 0x00, 0x00};
 
-/* NO locks */
+/* NO locks, but rcu_read_lock (preempt_disabled)  */
 int br_stp_handle_bpdu(struct sk_buff *skb)
 {
-        struct net_bridge_port *p = skb->dev->br_port;
-        struct net_bridge *br = p->br;
+        struct net_bridge_port *p = rcu_dereference(skb->dev->br_port);
+        struct net_bridge *br;
         unsigned char *buf;
 
+        if (!p)
+                goto err;
+
+        br = p->br;
+        spin_lock(&br->lock);
+
+        if (p->state == BR_STATE_DISABLED || !(br->dev->flags & IFF_UP))
+                goto out;
+
         /* insert into forwarding database after filtering to avoid spoofing */
-        br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
+        br_fdb_update(br, p, eth_hdr(skb)->h_source);
+
+        if (!br->stp_enabled)
+                goto out;
 
         /* need at least the 802 and STP headers */
         if (!pskb_may_pull(skb, sizeof(header)+1) ||
             memcmp(skb->data, header, sizeof(header)))
-                goto err;
+                goto out;
 
         buf = skb_pull(skb, sizeof(header));
 
-        spin_lock_bh(&br->lock);
-        if (p->state == BR_STATE_DISABLED 
-            || !(br->dev->flags & IFF_UP)
-            || !br->stp_enabled)
-                goto out;
-
         if (buf[0] == BPDU_TYPE_CONFIG) {
                 struct br_config_bpdu bpdu;
 
@@ -201,7 +207,7 @@ int br_stp_handle_bpdu(struct sk_buff *skb)
                 br_received_tcn_bpdu(p);
         }
  out:
-        spin_unlock_bh(&br->lock);
+        spin_unlock(&br->lock);
  err:
         kfree_skb(skb);
         return 0;
diff --git a/net/bridge/br_sysfs_if.c b/net/bridge/br_sysfs_if.c
index 0ac0355d16dd..c51c9e42aeb3 100644
--- a/net/bridge/br_sysfs_if.c
+++ b/net/bridge/br_sysfs_if.c
@@ -195,23 +195,11 @@ static ssize_t brport_store(struct kobject * kobj,
         return ret;
 }
 
-/* called from kobject_put when port ref count goes to zero. */
-static void brport_release(struct kobject *kobj)
-{
-        kfree(container_of(kobj, struct net_bridge_port, kobj));
-}
-
-static struct sysfs_ops brport_sysfs_ops = {
+struct sysfs_ops brport_sysfs_ops = {
         .show = brport_show,
         .store = brport_store,
 };
 
-static struct kobj_type brport_ktype = {
-        .sysfs_ops = &brport_sysfs_ops,
-        .release = brport_release,
-};
-
-
 /*
  * Add sysfs entries to ethernet device added to a bridge.
  * Creates a brport subdirectory with bridge attributes.
@@ -223,17 +211,6 @@ int br_sysfs_addif(struct net_bridge_port *p)
         struct brport_attribute **a;
         int err;
 
-        ASSERT_RTNL();
-
-        kobject_set_name(&p->kobj, SYSFS_BRIDGE_PORT_ATTR);
-        p->kobj.ktype = &brport_ktype;
-        p->kobj.parent = &(p->dev->class_dev.kobj);
-        p->kobj.kset = NULL;
-
-        err = kobject_add(&p->kobj);
-        if(err)
-                goto out1;
-
         err = sysfs_create_link(&p->kobj, &br->dev->class_dev.kobj, 
                                 SYSFS_BRIDGE_PORT_LINK);
         if (err)
@@ -245,28 +222,7 @@ int br_sysfs_addif(struct net_bridge_port *p)
                         goto out2;
         }
 
-        err = sysfs_create_link(&br->ifobj, &p->kobj, p->dev->name);
-        if (err)
-                goto out2;
-
-        kobject_uevent(&p->kobj, KOBJ_ADD);
-        return 0;
- out2:
-        kobject_del(&p->kobj);
- out1:
+        err= sysfs_create_link(&br->ifobj, &p->kobj, p->dev->name);
+out2:
         return err;
 }
-
-void br_sysfs_removeif(struct net_bridge_port *p)
-{
-        pr_debug("br_sysfs_removeif\n");
-        sysfs_remove_link(&p->br->ifobj, p->dev->name);
-        kobject_uevent(&p->kobj, KOBJ_REMOVE);
-        kobject_del(&p->kobj);
-}
-
-void br_sysfs_freeif(struct net_bridge_port *p)
-{
-        pr_debug("br_sysfs_freeif\n");
-        kobject_put(&p->kobj);
-}
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index 8700379685e0..eca2976abb25 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -455,7 +455,7 @@ void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change)
         if (!skb)
                 return;
 
-        if (rtnetlink_fill_ifinfo(skb, dev, type, current->pid, 0, change, 0) < 0) {
+        if (rtnetlink_fill_ifinfo(skb, dev, type, 0, 0, change, 0) < 0) {
                 kfree_skb(skb);
                 return;
         }
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 95b9d81ac488..3ffa60dadc0c 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -1135,7 +1135,7 @@ static void rtmsg_ifa(int event, struct in_ifaddr* ifa)
 
         if (!skb)
                 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, ENOBUFS);
-        else if (inet_fill_ifaddr(skb, ifa, current->pid, 0, event, 0) < 0) {
+        else if (inet_fill_ifaddr(skb, ifa, 0, 0, event, 0) < 0) {
                 kfree_skb(skb);
                 netlink_set_err(rtnl, 0, RTNLGRP_IPV4_IFADDR, EINVAL);
         } else {
diff --git a/net/ipv4/fib_semantics.c b/net/ipv4/fib_semantics.c
index ef4724de7350..0f4145babb14 100644
--- a/net/ipv4/fib_semantics.c
+++ b/net/ipv4/fib_semantics.c
@@ -1045,7 +1045,7 @@ fib_convert_rtentry(int cmd, struct nlmsghdr *nl, struct rtmsg *rtm,
         }
 
         nl->nlmsg_flags = NLM_F_REQUEST;
-        nl->nlmsg_pid = current->pid;
+        nl->nlmsg_pid = 0;
         nl->nlmsg_seq = 0;
         nl->nlmsg_len = NLMSG_LENGTH(sizeof(*rtm));
         if (cmd == SIOCDELRT) {
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index a97ed5416c28..e9a54ae7d690 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -456,7 +456,8 @@ void tcp_rcv_space_adjust(struct sock *sk)
 
                 tp->rcvq_space.space = space;
 
-                if (sysctl_tcp_moderate_rcvbuf) {
+                if (sysctl_tcp_moderate_rcvbuf &&
+                    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
                         int new_clamp = space;
 
                         /* Receive space grows, normalize in order to
diff --git a/net/irda/irda_device.c b/net/irda/irda_device.c
index 890bac0d4a56..e3debbdb67f5 100644
--- a/net/irda/irda_device.c
+++ b/net/irda/irda_device.c
@@ -343,12 +343,12 @@ static void irda_task_timer_expired(void *data)
 static void irda_device_setup(struct net_device *dev)
 {
         dev->hard_header_len = 0;
-        dev->addr_len        = 0;
+        dev->addr_len        = LAP_ALEN;
 
         dev->type            = ARPHRD_IRDA;
         dev->tx_queue_len    = 8; /* Window size + 1 s-frame */
 
-        memset(dev->broadcast, 0xff, 4);
+        memset(dev->broadcast, 0xff, LAP_ALEN);
 
         dev->mtu = 2048;
         dev->flags = IFF_NOARP;
diff --git a/net/irda/irnet/irnet_irda.c b/net/irda/irnet/irnet_irda.c
index 07ec326c71f5..f65c7a83bc5c 100644
--- a/net/irda/irnet/irnet_irda.c
+++ b/net/irda/irnet/irnet_irda.c
@@ -696,7 +696,7 @@ irnet_daddr_to_dname(irnet_socket *	self)
         {
           /* Yes !!! Get it.. */
           strlcpy(self->rname, discoveries[i].info, sizeof(self->rname));
-          self->rname[NICKNAME_MAX_LEN + 1] = '\0';
+          self->rname[sizeof(self->rname) - 1] = '\0';
           DEBUG(IRDA_SERV_INFO, "Device 0x%08x is in fact ``%s''.\n",
                 self->daddr, self->rname);
           kfree(discoveries);
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index 2101b45d2ec6..6b9772d95872 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -702,7 +702,8 @@ struct sock *netlink_getsockbyfilp(struct file *filp)
  * 0: continue
  * 1: repeat lookup - reference dropped while waiting for socket memory.
  */
-int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock, long timeo)
+int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
+                long timeo, struct sock *ssk)
 {
         struct netlink_sock *nlk;
 
@@ -712,7 +713,7 @@ int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock, long t
             test_bit(0, &nlk->state)) {
                 DECLARE_WAITQUEUE(wait, current);
                 if (!timeo) {
-                        if (!nlk->pid)
+                        if (!ssk || nlk_sk(ssk)->pid == 0)
                                 netlink_overrun(sk);
                         sock_put(sk);
                         kfree_skb(skb);
@@ -797,7 +798,7 @@ retry:
                 kfree_skb(skb);
                 return PTR_ERR(sk);
         }
-        err = netlink_attachskb(sk, skb, nonblock, timeo);
+        err = netlink_attachskb(sk, skb, nonblock, timeo, ssk);
         if (err == 1)
                 goto retry;
         if (err)
diff --git a/scripts/kconfig/Makefile b/scripts/kconfig/Makefile
index d64aae85c378..5760e057ecba 100644
--- a/scripts/kconfig/Makefile
+++ b/scripts/kconfig/Makefile
@@ -123,17 +123,7 @@ KBUILD_HAVE_NLS := $(shell \
      then echo yes ; \
      else echo no ; fi)
 ifeq ($(KBUILD_HAVE_NLS),no)
-  HOSTCFLAGS   += -DKBUILD_NO_NLS
-else
-  KBUILD_NEED_LINTL := $(shell \
-    if echo -e "\#include <libintl.h>\nint main(int a, char** b) { gettext(\"\"); return 0; }\n" | \
-      $(HOSTCC) $(HOSTCFLAGS) -x c - -o /dev/null> /dev/null 2>&1 ; \
-    then echo no ; \
-    else echo yes ; fi)
-  ifeq ($(KBUILD_NEED_LINTL),yes)
-    HOSTLOADLIBES_conf += -lintl
-    HOSTLOADLIBES_mconf        += -lintl
-  endif
+HOSTCFLAGS      += -DKBUILD_NO_NLS
 endif
 
 # generated files seem to need this to find local include files