561 files changed, 7065 insertions, 5447 deletions

diff --git a/arch/alpha/kernel/asm-offsets.c b/arch/alpha/kernel/asm-offsets.c
index 8f2e5c718b50..6c56c754a0b5 100644
--- a/arch/alpha/kernel/asm-offsets.c
+++ b/arch/alpha/kernel/asm-offsets.c
@@ -28,6 +28,7 @@ void foo(void)
         DEFINE(TASK_GID, offsetof(struct task_struct, gid));
         DEFINE(TASK_EGID, offsetof(struct task_struct, egid));
         DEFINE(TASK_REAL_PARENT, offsetof(struct task_struct, real_parent));
+        DEFINE(TASK_GROUP_LEADER, offsetof(struct task_struct, group_leader));
         DEFINE(TASK_TGID, offsetof(struct task_struct, tgid));
         BLANK();
 
diff --git a/arch/alpha/kernel/entry.S b/arch/alpha/kernel/entry.S
index e38671c922bc..7af15bf7e5ab 100644
--- a/arch/alpha/kernel/entry.S
+++ b/arch/alpha/kernel/entry.S
@@ -879,17 +879,19 @@ sys_getxpid:
 
         /* See linux/kernel/timer.c sys_getppid for discussion
            about this loop.  */
-        ldq     $3, TASK_REAL_PARENT($2)
-1:      ldl     $1, TASK_TGID($3)
+        ldq     $3, TASK_GROUP_LEADER($2)
+        ldq     $4, TASK_REAL_PARENT($3)
+        ldl     $0, TASK_TGID($2)
+1:      ldl     $1, TASK_TGID($4)
 #ifdef CONFIG_SMP
-        mov     $3, $4
+        mov     $4, $5
         mb
-        ldq     $3, TASK_REAL_PARENT($2)
-        cmpeq   $3, $4, $4
-        beq     $4, 1b
+        ldq     $3, TASK_GROUP_LEADER($2)
+        ldq     $4, TASK_REAL_PARENT($3)
+        cmpeq   $4, $5, $5
+        beq     $5, 1b
 #endif
         stq     $1, 80($sp)
-        ldl     $0, TASK_TGID($2)
         ret
 .end sys_getxpid
 
diff --git a/arch/alpha/kernel/irq.c b/arch/alpha/kernel/irq.c
index 76be5cf0de13..9006063e7369 100644
--- a/arch/alpha/kernel/irq.c
+++ b/arch/alpha/kernel/irq.c
@@ -68,34 +68,32 @@ show_interrupts(struct seq_file *p, void *v)
 #ifdef CONFIG_SMP
         int j;
 #endif
-        int i = *(loff_t *) v;
+        int irq = *(loff_t *) v;
         struct irqaction * action;
         unsigned long flags;
 
 #ifdef CONFIG_SMP
-        if (i == 0) {
+        if (irq == 0) {
                 seq_puts(p, "           ");
-                for (i = 0; i < NR_CPUS; i++)
-                        if (cpu_online(i))
-                                seq_printf(p, "CPU%d       ", i);
+                for_each_online_cpu(j)
+                        seq_printf(p, "CPU%d       ", j);
                 seq_putc(p, '\n');
         }
 #endif
 
-        if (i < ACTUAL_NR_IRQS) {
-                spin_lock_irqsave(&irq_desc[i].lock, flags);
-                action = irq_desc[i].action;
+        if (irq < ACTUAL_NR_IRQS) {
+                spin_lock_irqsave(&irq_desc[irq].lock, flags);
+                action = irq_desc[irq].action;
                 if (!action) 
                         goto unlock;
-                seq_printf(p, "%3d: ",i);
+                seq_printf(p, "%3d: ", irq);
 #ifndef CONFIG_SMP
-                seq_printf(p, "%10u ", kstat_irqs(i));
+                seq_printf(p, "%10u ", kstat_irqs(irq));
 #else
-                for (j = 0; j < NR_CPUS; j++)
-                        if (cpu_online(j))
-                                seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
+                for_each_online_cpu(j)
+                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[irq]);
 #endif
-                seq_printf(p, " %14s", irq_desc[i].handler->typename);
+                seq_printf(p, " %14s", irq_desc[irq].handler->typename);
                 seq_printf(p, "  %c%s",
                         (action->flags & SA_INTERRUPT)?'+':' ',
                         action->name);
@@ -108,13 +106,12 @@ show_interrupts(struct seq_file *p, void *v)
 
                 seq_putc(p, '\n');
 unlock:
-                spin_unlock_irqrestore(&irq_desc[i].lock, flags);
-        } else if (i == ACTUAL_NR_IRQS) {
+                spin_unlock_irqrestore(&irq_desc[irq].lock, flags);
+        } else if (irq == ACTUAL_NR_IRQS) {
 #ifdef CONFIG_SMP
                 seq_puts(p, "IPI: ");
-                for (i = 0; i < NR_CPUS; i++)
-                        if (cpu_online(i))
-                                seq_printf(p, "%10lu ", cpu_data[i].ipi_count);
+                for_each_online_cpu(j)
+                        seq_printf(p, "%10lu ", cpu_data[j].ipi_count);
                 seq_putc(p, '\n');
 #endif
                 seq_printf(p, "ERR: %10lu\n", irq_err_count);
@@ -122,7 +119,6 @@ unlock:
         return 0;
 }
 
-
 /*
  * handle_irq handles all normal device IRQ's (the special
  * SMP cross-CPU interrupts have their own specific
diff --git a/arch/alpha/kernel/osf_sys.c b/arch/alpha/kernel/osf_sys.c
index 01fe990d3e54..7fb14f42a125 100644
--- a/arch/alpha/kernel/osf_sys.c
+++ b/arch/alpha/kernel/osf_sys.c
@@ -960,7 +960,7 @@ osf_utimes(char __user *filename, struct timeval32 __user *tvs)
                         return -EFAULT;
         }
 
-        return do_utimes(filename, tvs ? ktvs : NULL);
+        return do_utimes(AT_FDCWD, filename, tvs ? ktvs : NULL);
 }
 
 #define MAX_SELECT_SECONDS \
diff --git a/arch/alpha/kernel/smp.c b/arch/alpha/kernel/smp.c
index 4b873527ce1c..02c2db08114a 100644
--- a/arch/alpha/kernel/smp.c
+++ b/arch/alpha/kernel/smp.c
@@ -73,9 +73,6 @@ cpumask_t cpu_online_map;
 
 EXPORT_SYMBOL(cpu_online_map);
 
-/* cpus reported in the hwrpb */
-static unsigned long hwrpb_cpu_present_mask __initdata = 0;
-
 int smp_num_probed;             /* Internal processor count */
 int smp_num_cpus = 1;           /* Number that came online.  */
 
@@ -442,7 +439,7 @@ setup_smp(void)
                         if ((cpu->flags & 0x1cc) == 0x1cc) {
                                 smp_num_probed++;
                                 /* Assume here that "whami" == index */
-                                hwrpb_cpu_present_mask |= (1UL << i);
+                                cpu_set(i, cpu_possible_map);
                                 cpu->pal_revision = boot_cpu_palrev;
                         }
 
@@ -453,12 +450,12 @@ setup_smp(void)
                 }
         } else {
                 smp_num_probed = 1;
-                hwrpb_cpu_present_mask = (1UL << boot_cpuid);
+                cpu_set(boot_cpuid, cpu_possible_map);
         }
         cpu_present_mask = cpumask_of_cpu(boot_cpuid);
 
         printk(KERN_INFO "SMP: %d CPUs probed -- cpu_present_mask = %lx\n",
-               smp_num_probed, hwrpb_cpu_present_mask);
+               smp_num_probed, cpu_possible_map.bits[0]);
 }
 
 /*
@@ -467,8 +464,6 @@ setup_smp(void)
 void __init
 smp_prepare_cpus(unsigned int max_cpus)
 {
-        int cpu_count, i;
-
         /* Take care of some initial bookkeeping.  */
         memset(ipi_data, 0, sizeof(ipi_data));
 
@@ -486,19 +481,7 @@ smp_prepare_cpus(unsigned int max_cpus)
 
         printk(KERN_INFO "SMP starting up secondaries.\n");
 
-        cpu_count = 1;
-        for (i = 0; (i < NR_CPUS) && (cpu_count < max_cpus); i++) {
-                if (i == boot_cpuid)
-                        continue;
-
-                if (((hwrpb_cpu_present_mask >> i) & 1) == 0)
-                        continue;
-
-                cpu_set(i, cpu_possible_map);
-                cpu_count++;
-        }
-
-        smp_num_cpus = cpu_count;
+        smp_num_cpus = smp_num_probed;
 }
 
 void __devinit
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 5959e36c3b4c..15dc1a0dffbb 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -10,9 +10,9 @@ config ARM
         default y
         help
           The ARM series is a line of low-power-consumption RISC chip designs
-          licensed by ARM ltd and targeted at embedded applications and
+          licensed by ARM Ltd and targeted at embedded applications and
           handhelds such as the Compaq IPAQ.  ARM-based PCs are no longer
-          manufactured, but  legacy ARM-based PC hardware remains popular in
+          manufactured, but legacy ARM-based PC hardware remains popular in
           Europe.  There is an ARM Linux project with a web page at
           <http://www.arm.linux.org.uk/>.
 
@@ -69,6 +69,9 @@ config GENERIC_ISA_DMA
 config FIQ
         bool
 
+config ARCH_MTD_XIP
+        bool
+
 source "init/Kconfig"
 
 menu "System Type"
@@ -81,45 +84,62 @@ config ARCH_CLPS7500
         bool "Cirrus-CL-PS7500FE"
         select TIMER_ACORN
         select ISA
+        help
+          Support for the Cirrus Logic PS7500FE system-on-a-chip.
 
 config ARCH_CLPS711X
         bool "CLPS711x/EP721x-based"
+        help
+          Support for Cirrus Logic 711x/721x based boards.
 
 config ARCH_CO285
         bool "Co-EBSA285"
         select FOOTBRIDGE
         select FOOTBRIDGE_ADDIN
+        help
+          Support for Intel's EBSA285 companion chip.
 
 config ARCH_EBSA110
         bool "EBSA-110"
         select ISA
         help
           This is an evaluation board for the StrongARM processor available
-          from Digital. It has limited hardware on-board, including an onboard
+          from Digital. It has limited hardware on-board, including an
           Ethernet interface, two PCMCIA sockets, two serial ports and a
           parallel port.
 
 config ARCH_FOOTBRIDGE
         bool "FootBridge"
         select FOOTBRIDGE
+        help
+          Support for systems based on the DC21285 companion chip
+          ("FootBridge"), such as the Simtec CATS and the Rebel NetWinder.
 
 config ARCH_INTEGRATOR
         bool "Integrator"
         select ARM_AMBA
         select ICST525
+        help
+          Support for ARM's Integrator platform.
 
 config ARCH_IOP3XX
         bool "IOP3xx-based"
         select PCI
+        help
+          Support for Intel's IOP3XX (XScale) family of processors.
 
 config ARCH_IXP4XX
         bool "IXP4xx-based"
         select DMABOUNCE
         select PCI
+        help
+          Support for Intel's IXP4XX (XScale) family of processors.
 
 config ARCH_IXP2000
         bool "IXP2400/2800-based"
         select PCI
+        help
+          Support for Intel's IXP2400/2800 (XScale) family of processors.
 
 config ARCH_L7200
         bool "LinkUp-L7200"
@@ -136,6 +156,9 @@ config ARCH_L7200
 
 config ARCH_PXA
         bool "PXA2xx-based"
+        select ARCH_MTD_XIP
+        help
+          Support for Intel's PXA2XX processor line.
 
 config ARCH_RPC
         bool "RiscPC"
@@ -152,19 +175,25 @@ config ARCH_SA1100
         bool "SA1100-based"
         select ISA
         select ARCH_DISCONTIGMEM_ENABLE
+        select ARCH_MTD_XIP
+        help
+          Support for StrongARM 11x0 based boards.
 
 config ARCH_S3C2410
         bool "Samsung S3C2410"
         help
           Samsung S3C2410X CPU based systems, such as the Simtec Electronics
           BAST (<http://www.simtec.co.uk/products/EB110ITX/>), the IPAQ 1940 or
-          the Samsung SMDK2410 development board (and derviatives).
+          the Samsung SMDK2410 development board (and derivatives).
 
 config ARCH_SHARK
         bool "Shark"
         select ISA
         select ISA_DMA
         select PCI
+        help
+          Support for the StrongARM based Digital DNARD machine, also known
+          as "Shark" (<http://www.shark-linux.de/shark.html>).
 
 config ARCH_LH7A40X
         bool "Sharp LH7A40X"
@@ -176,6 +205,8 @@ config ARCH_LH7A40X
 
 config ARCH_OMAP
         bool "TI OMAP"
+        help
+          Support for TI's OMAP platform (OMAP1 and OMAP2).
 
 config ARCH_VERSATILE
         bool "Versatile"
@@ -194,6 +225,8 @@ config ARCH_REALVIEW
 
 config ARCH_IMX
         bool "IMX"
+        help
+          Support for Motorola's i.MX family of processors (MX1, MXL).
 
 config ARCH_H720X
         bool "Hynix-HMS720x-based"
@@ -210,8 +243,8 @@ config ARCH_AAEC2000
 config ARCH_AT91RM9200
         bool "AT91RM9200"
         help
-          Say Y here if you intend to run this kernel on an AT91RM9200-based
-          board.
+          Say Y here if you intend to run this kernel on an Atmel
+          AT91RM9200-based board.
 
 endchoice
 
@@ -417,8 +450,8 @@ config AEABI
           To use this you need GCC version 4.0.0 or later.
 
 config OABI_COMPAT
-        bool "Allow old ABI binaries to run with this kernel"
-        depends on AEABI
+        bool "Allow old ABI binaries to run with this kernel (EXPERIMENTAL)"
+        depends on AEABI && EXPERIMENTAL
         default y
         help
           This option preserves the old syscall interface along with the
diff --git a/arch/arm/boot/compressed/head.S b/arch/arm/boot/compressed/head.S
index aaa47400eb9c..db3389d8e027 100644
--- a/arch/arm/boot/compressed/head.S
+++ b/arch/arm/boot/compressed/head.S
@@ -334,7 +334,7 @@ __setup_mmu:	sub	r3, r4, #16384		@ Page directory size
                 mov     r1, #0x12
                 orr     r1, r1, #3 << 10
                 add     r2, r3, #16384
-1:              cmp     r1, r8                  @ if virt > start of RAM
+1:              cmp     r1, r9                  @ if virt > start of RAM
                 orrhs   r1, r1, #0x0c           @ set cacheable, bufferable
                 cmp     r1, r10                 @ if virt > end of RAM
                 bichs   r1, r1, #0x0c           @ clear cacheable, bufferable
diff --git a/arch/arm/configs/at91rm9200dk_defconfig b/arch/arm/configs/at91rm9200dk_defconfig
index 5cdd13acf8ff..1fe73d198888 100644
--- a/arch/arm/configs/at91rm9200dk_defconfig
+++ b/arch/arm/configs/at91rm9200dk_defconfig
@@ -85,7 +85,6 @@ CONFIG_DEFAULT_IOSCHED="anticipatory"
 # CONFIG_ARCH_CLPS711X is not set
 # CONFIG_ARCH_CO285 is not set
 # CONFIG_ARCH_EBSA110 is not set
-# CONFIG_ARCH_CAMELOT is not set
 # CONFIG_ARCH_FOOTBRIDGE is not set
 # CONFIG_ARCH_INTEGRATOR is not set
 # CONFIG_ARCH_IOP3XX is not set
diff --git a/arch/arm/configs/at91rm9200ek_defconfig b/arch/arm/configs/at91rm9200ek_defconfig
index 20838ccf1da7..b7d934cdb1b7 100644
--- a/arch/arm/configs/at91rm9200ek_defconfig
+++ b/arch/arm/configs/at91rm9200ek_defconfig
@@ -85,7 +85,6 @@ CONFIG_DEFAULT_IOSCHED="anticipatory"
 # CONFIG_ARCH_CLPS711X is not set
 # CONFIG_ARCH_CO285 is not set
 # CONFIG_ARCH_EBSA110 is not set
-# CONFIG_ARCH_CAMELOT is not set
 # CONFIG_ARCH_FOOTBRIDGE is not set
 # CONFIG_ARCH_INTEGRATOR is not set
 # CONFIG_ARCH_IOP3XX is not set
diff --git a/arch/arm/configs/bast_defconfig b/arch/arm/configs/bast_defconfig
index 6886001b5366..4a8564f386af 100644
--- a/arch/arm/configs/bast_defconfig
+++ b/arch/arm/configs/bast_defconfig
@@ -14,8 +14,7 @@ CONFIG_GENERIC_IOMAP=y
 # Code maturity level options
 #
 CONFIG_EXPERIMENTAL=y
-# CONFIG_CLEAN_COMPILE is not set
-CONFIG_BROKEN=y
+CONFIG_CLEAN_COMPILE=y
 CONFIG_BROKEN_ON_SMP=y
 
 #
@@ -360,7 +359,6 @@ CONFIG_BLK_DEV_IDE_BAST=y
 #
 # IEEE 1394 (FireWire) support
 #
-# CONFIG_IEEE1394 is not set
 
 #
 # I2O device support
@@ -781,7 +779,6 @@ CONFIG_SYSFS=y
 # CONFIG_DEVFS_FS is not set
 # CONFIG_DEVPTS_FS_XATTR is not set
 # CONFIG_TMPFS is not set
-# CONFIG_HUGETLBFS is not set
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
 
diff --git a/arch/arm/configs/collie_defconfig b/arch/arm/configs/collie_defconfig
index 15468a0cf70e..c9aa878e610a 100644
--- a/arch/arm/configs/collie_defconfig
+++ b/arch/arm/configs/collie_defconfig
@@ -13,8 +13,7 @@ CONFIG_GENERIC_CALIBRATE_DELAY=y
 # Code maturity level options
 #
 CONFIG_EXPERIMENTAL=y
-# CONFIG_CLEAN_COMPILE is not set
-CONFIG_BROKEN=y
+CONFIG_CLEAN_COMPILE=y
 CONFIG_BROKEN_ON_SMP=y
 CONFIG_LOCK_KERNEL=y
 CONFIG_INIT_ENV_ARG_LIMIT=32
@@ -308,9 +307,7 @@ CONFIG_MTD_CFI_I2=y
 # CONFIG_MTD_ROM is not set
 # CONFIG_MTD_ABSENT is not set
 CONFIG_MTD_OBSOLETE_CHIPS=y
-# CONFIG_MTD_AMDSTD is not set
 CONFIG_MTD_SHARP=y
-# CONFIG_MTD_JEDEC is not set
 
 #
 # Mapping drivers for chip access
@@ -396,7 +393,6 @@ CONFIG_ATA_OVER_ETH=m
 #
 # IEEE 1394 (FireWire) support
 #
-# CONFIG_IEEE1394 is not set
 
 #
 # I2O device support
@@ -741,7 +737,6 @@ CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 CONFIG_PROC_FS=y
 CONFIG_SYSFS=y
 CONFIG_TMPFS=y
-# CONFIG_HUGETLBFS is not set
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
 # CONFIG_RELAYFS_FS is not set
diff --git a/arch/arm/configs/csb337_defconfig b/arch/arm/configs/csb337_defconfig
index 885a3184830a..94bd9932a402 100644
--- a/arch/arm/configs/csb337_defconfig
+++ b/arch/arm/configs/csb337_defconfig
@@ -85,7 +85,6 @@ CONFIG_DEFAULT_IOSCHED="anticipatory"
 # CONFIG_ARCH_CLPS711X is not set
 # CONFIG_ARCH_CO285 is not set
 # CONFIG_ARCH_EBSA110 is not set
-# CONFIG_ARCH_CAMELOT is not set
 # CONFIG_ARCH_FOOTBRIDGE is not set
 # CONFIG_ARCH_INTEGRATOR is not set
 # CONFIG_ARCH_IOP3XX is not set
diff --git a/arch/arm/configs/csb637_defconfig b/arch/arm/configs/csb637_defconfig
index 95a96a5462a0..1519124c5501 100644
--- a/arch/arm/configs/csb637_defconfig
+++ b/arch/arm/configs/csb637_defconfig
@@ -85,7 +85,6 @@ CONFIG_DEFAULT_IOSCHED="anticipatory"
 # CONFIG_ARCH_CLPS711X is not set
 # CONFIG_ARCH_CO285 is not set
 # CONFIG_ARCH_EBSA110 is not set
-# CONFIG_ARCH_CAMELOT is not set
 # CONFIG_ARCH_FOOTBRIDGE is not set
 # CONFIG_ARCH_INTEGRATOR is not set
 # CONFIG_ARCH_IOP3XX is not set
diff --git a/arch/arm/configs/enp2611_defconfig b/arch/arm/configs/enp2611_defconfig
index 9592e3925c79..5fdaf3ce9d56 100644
--- a/arch/arm/configs/enp2611_defconfig
+++ b/arch/arm/configs/enp2611_defconfig
@@ -171,7 +171,7 @@ CONFIG_ALIGNMENT_TRAP=y
 #
 CONFIG_ZBOOT_ROM_TEXT=0x0
 CONFIG_ZBOOT_ROM_BSS=0x0
-CONFIG_CMDLINE="console=ttyS0,57600 root=/dev/nfs ip=bootp mem=64M@0x0 pci=firmware"
+CONFIG_CMDLINE="console=ttyS0,57600 root=/dev/nfs ip=bootp mem=64M@0x0"
 # CONFIG_XIP_KERNEL is not set
 
 #
diff --git a/arch/arm/configs/ep80219_defconfig b/arch/arm/configs/ep80219_defconfig
index fbe312e757cb..3c73b707c2f3 100644
--- a/arch/arm/configs/ep80219_defconfig
+++ b/arch/arm/configs/ep80219_defconfig
@@ -522,6 +522,7 @@ CONFIG_E100=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/arm/configs/iq31244_defconfig b/arch/arm/configs/iq31244_defconfig
index c07628ceaf0c..32467160a6df 100644
--- a/arch/arm/configs/iq31244_defconfig
+++ b/arch/arm/configs/iq31244_defconfig
@@ -493,6 +493,7 @@ CONFIG_NETDEVICES=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/arm/configs/iq80321_defconfig b/arch/arm/configs/iq80321_defconfig
index 18fa1615fdfd..b000da753c41 100644
--- a/arch/arm/configs/iq80321_defconfig
+++ b/arch/arm/configs/iq80321_defconfig
@@ -415,6 +415,7 @@ CONFIG_NETDEVICES=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/arm/configs/iq80331_defconfig b/arch/arm/configs/iq80331_defconfig
index f50035de1fff..46c79e1efe07 100644
--- a/arch/arm/configs/iq80331_defconfig
+++ b/arch/arm/configs/iq80331_defconfig
@@ -496,6 +496,7 @@ CONFIG_NETDEVICES=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/arm/configs/iq80332_defconfig b/arch/arm/configs/iq80332_defconfig
index 18b3f372ed68..11959b705d82 100644
--- a/arch/arm/configs/iq80332_defconfig
+++ b/arch/arm/configs/iq80332_defconfig
@@ -496,6 +496,7 @@ CONFIG_NETDEVICES=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/arm/configs/ixdp2400_defconfig b/arch/arm/configs/ixdp2400_defconfig
index d9d6bb86a6fa..c67fc449a11f 100644
--- a/arch/arm/configs/ixdp2400_defconfig
+++ b/arch/arm/configs/ixdp2400_defconfig
@@ -172,7 +172,7 @@ CONFIG_ALIGNMENT_TRAP=y
 #
 CONFIG_ZBOOT_ROM_TEXT=0x0
 CONFIG_ZBOOT_ROM_BSS=0x0
-CONFIG_CMDLINE="console=ttyS0,57600 root=/dev/nfs ip=bootp mem=64M@0x0 pci=firmware"
+CONFIG_CMDLINE="console=ttyS0,57600 root=/dev/nfs ip=bootp mem=64M@0x0"
 # CONFIG_XIP_KERNEL is not set
 
 #
diff --git a/arch/arm/configs/ixdp2401_defconfig b/arch/arm/configs/ixdp2401_defconfig
index 2dc9d499c7d7..60d66e82c51f 100644
--- a/arch/arm/configs/ixdp2401_defconfig
+++ b/arch/arm/configs/ixdp2401_defconfig
@@ -172,7 +172,7 @@ CONFIG_ALIGNMENT_TRAP=y
 #
 CONFIG_ZBOOT_ROM_TEXT=0x0
 CONFIG_ZBOOT_ROM_BSS=0x0
-CONFIG_CMDLINE="console=ttyS0,115200 root=/dev/nfs ip=bootp mem=64M@0x0 pci=firmware"
+CONFIG_CMDLINE="console=ttyS0,115200 root=/dev/nfs ip=bootp mem=64M@0x0"
 # CONFIG_XIP_KERNEL is not set
 
 #
diff --git a/arch/arm/configs/ixdp2801_defconfig b/arch/arm/configs/ixdp2801_defconfig
index ea8f4b478fa3..f54f3dcc5b33 100644
--- a/arch/arm/configs/ixdp2801_defconfig
+++ b/arch/arm/configs/ixdp2801_defconfig
@@ -172,7 +172,7 @@ CONFIG_ALIGNMENT_TRAP=y
 #
 CONFIG_ZBOOT_ROM_TEXT=0x0
 CONFIG_ZBOOT_ROM_BSS=0x0
-CONFIG_CMDLINE="console=ttyS0,115200 root=/dev/nfs ip=bootp mem=64M@0x0 pci=firmware ixdp2x01_clock=50000000"
+CONFIG_CMDLINE="console=ttyS0,115200 root=/dev/nfs ip=bootp mem=64M@0x0"
 # CONFIG_XIP_KERNEL is not set
 
 #
diff --git a/arch/arm/configs/s3c2410_defconfig b/arch/arm/configs/s3c2410_defconfig
index 33f31080a98c..6695b07cf1ba 100644
--- a/arch/arm/configs/s3c2410_defconfig
+++ b/arch/arm/configs/s3c2410_defconfig
@@ -1,11 +1,10 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.15-rc1
-# Sun Nov 13 17:41:24 2005
+# Linux kernel version: 2.6.16-rc2
+# Mon Feb  6 11:17:23 2006
 #
 CONFIG_ARM=y
 CONFIG_MMU=y
-CONFIG_UID16=y
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
 
@@ -13,8 +12,7 @@ CONFIG_GENERIC_CALIBRATE_DELAY=y
 # Code maturity level options
 #
 CONFIG_EXPERIMENTAL=y
-# CONFIG_CLEAN_COMPILE is not set
-CONFIG_BROKEN=y
+CONFIG_CLEAN_COMPILE=y
 CONFIG_BROKEN_ON_SMP=y
 CONFIG_INIT_ENV_ARG_LIMIT=32
 
@@ -29,27 +27,31 @@ CONFIG_SYSVIPC=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
-# CONFIG_HOTPLUG is not set
-CONFIG_KOBJECT_UEVENT=y
 # CONFIG_IKCONFIG is not set
 CONFIG_INITRAMFS_SOURCE=""
+CONFIG_UID16=y
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
+CONFIG_ELF_CORE=y
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
-CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SHMEM=y
 CONFIG_CC_ALIGN_FUNCTIONS=0
 CONFIG_CC_ALIGN_LABELS=0
 CONFIG_CC_ALIGN_LOOPS=0
 CONFIG_CC_ALIGN_JUMPS=0
+CONFIG_SLAB=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
+CONFIG_OBSOLETE_INTERMODULE=y
 
 #
 # Loadable module support
@@ -103,6 +105,7 @@ CONFIG_ARCH_S3C2410=y
 # CONFIG_ARCH_IMX is not set
 # CONFIG_ARCH_H720X is not set
 # CONFIG_ARCH_AAEC2000 is not set
+# CONFIG_ARCH_AT91RM9200 is not set
 
 #
 # S3C24XX Implementations
@@ -161,7 +164,6 @@ CONFIG_CPU_TLB_V4WBI=y
 # Bus support
 #
 CONFIG_ISA=y
-CONFIG_ISA_DMA_API=y
 
 #
 # PCCARD (PCMCIA/CardBus) support
@@ -173,6 +175,7 @@ CONFIG_ISA_DMA_API=y
 #
 # CONFIG_PREEMPT is not set
 # CONFIG_NO_IDLE_HZ is not set
+# CONFIG_AEABI is not set
 # CONFIG_ARCH_DISCONTIGMEM_ENABLE is not set
 CONFIG_SELECT_MEMORY_MODEL=y
 CONFIG_FLATMEM_MANUAL=y
@@ -215,6 +218,8 @@ CONFIG_BINFMT_AOUT=y
 # Power management options
 #
 CONFIG_PM=y
+CONFIG_PM_LEGACY=y
+# CONFIG_PM_DEBUG is not set
 CONFIG_APM=y
 
 #
@@ -260,6 +265,11 @@ CONFIG_TCP_CONG_BIC=y
 # SCTP Configuration (EXPERIMENTAL)
 #
 # CONFIG_IP_SCTP is not set
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
 # CONFIG_ATM is not set
 # CONFIG_BRIDGE is not set
 # CONFIG_VLAN_8021Q is not set
@@ -277,7 +287,6 @@ CONFIG_TCP_CONG_BIC=y
 # QoS and/or fair queueing
 #
 # CONFIG_NET_SCHED is not set
-# CONFIG_NET_CLS_ROUTE is not set
 
 #
 # Network testing
@@ -301,6 +310,11 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 # CONFIG_DEBUG_DRIVER is not set
 
 #
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
 # Memory Technology Devices (MTD)
 #
 CONFIG_MTD=y
@@ -413,8 +427,6 @@ CONFIG_PARPORT_1284=y
 #
 # Block devices
 #
-# CONFIG_BLK_DEV_XD is not set
-# CONFIG_PARIDE is not set
 # CONFIG_BLK_DEV_COW_COMMON is not set
 CONFIG_BLK_DEV_LOOP=y
 # CONFIG_BLK_DEV_CRYPTOLOOP is not set
@@ -473,7 +485,6 @@ CONFIG_BLK_DEV_IDE_BAST=y
 #
 # IEEE 1394 (FireWire) support
 #
-# CONFIG_IEEE1394 is not set
 
 #
 # I2O device support
@@ -504,7 +515,6 @@ CONFIG_NETDEVICES=y
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=y
 # CONFIG_NET_VENDOR_3COM is not set
-# CONFIG_LANCE is not set
 # CONFIG_NET_VENDOR_SMC is not set
 # CONFIG_SMC91X is not set
 CONFIG_DM9000=y
@@ -609,11 +619,11 @@ CONFIG_SERIAL_NONSTANDARD=y
 # CONFIG_ROCKETPORT is not set
 # CONFIG_CYCLADES is not set
 # CONFIG_DIGIEPCA is not set
-# CONFIG_ESPSERIAL is not set
 # CONFIG_MOXA_INTELLIO is not set
 # CONFIG_MOXA_SMARTIO is not set
 # CONFIG_ISI is not set
 # CONFIG_SYNCLINKMP is not set
+# CONFIG_SYNCLINK_GT is not set
 # CONFIG_N_HDLC is not set
 # CONFIG_RISCOM8 is not set
 # CONFIG_SPECIALIX is not set
@@ -627,6 +637,7 @@ CONFIG_SERIAL_NONSTANDARD=y
 CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
 CONFIG_SERIAL_8250_NR_UARTS=8
+CONFIG_SERIAL_8250_RUNTIME_UARTS=4
 CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_MANY_PORTS=y
 CONFIG_SERIAL_8250_SHARE_IRQ=y
@@ -689,6 +700,7 @@ CONFIG_S3C2410_RTC=y
 #
 # TPM devices
 #
+# CONFIG_TCG_TPM is not set
 # CONFIG_TELCLOCK is not set
 
 #
@@ -733,6 +745,12 @@ CONFIG_SENSORS_EEPROM=m
 # CONFIG_I2C_DEBUG_CHIP is not set
 
 #
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
 # Hardware Monitoring support
 #
 CONFIG_HWMON=y
@@ -865,6 +883,7 @@ CONFIG_FS_MBCACHE=y
 # CONFIG_JFS_FS is not set
 # CONFIG_FS_POSIX_ACL is not set
 # CONFIG_XFS_FS is not set
+# CONFIG_OCFS2_FS is not set
 # CONFIG_MINIX_FS is not set
 CONFIG_ROMFS_FS=y
 CONFIG_INOTIFY=y
@@ -896,10 +915,10 @@ CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 CONFIG_PROC_FS=y
 CONFIG_SYSFS=y
 # CONFIG_TMPFS is not set
-# CONFIG_HUGETLBFS is not set
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
 # CONFIG_RELAYFS_FS is not set
+# CONFIG_CONFIGFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -968,6 +987,7 @@ CONFIG_SOLARIS_X86_PARTITION=y
 # CONFIG_SGI_PARTITION is not set
 # CONFIG_ULTRIX_PARTITION is not set
 # CONFIG_SUN_PARTITION is not set
+# CONFIG_KARMA_PARTITION is not set
 # CONFIG_EFI_PARTITION is not set
 
 #
@@ -1023,12 +1043,13 @@ CONFIG_NLS_DEFAULT="iso8859-1"
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
-CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
+CONFIG_DEBUG_KERNEL=y
 CONFIG_LOG_BUF_SHIFT=16
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
+CONFIG_DEBUG_MUTEXES=y
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_KOBJECT is not set
@@ -1037,6 +1058,7 @@ CONFIG_DEBUG_INFO=y
 # CONFIG_DEBUG_FS is not set
 # CONFIG_DEBUG_VM is not set
 CONFIG_FRAME_POINTER=y
+CONFIG_FORCED_INLINING=y
 # CONFIG_RCU_TORTURE_TEST is not set
 CONFIG_DEBUG_USER=y
 # CONFIG_DEBUG_WAITQ is not set
diff --git a/arch/arm/kernel/calls.S b/arch/arm/kernel/calls.S
index 75e6f9a94713..8c3035d5ffc9 100644
--- a/arch/arm/kernel/calls.S
+++ b/arch/arm/kernel/calls.S
@@ -7,337 +7,334 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- *  This file is included twice in entry-common.S
+ *  This file is included thrice in entry-common.S
  */
-#ifndef NR_syscalls
-#define NR_syscalls 328
-#else
-
-100:
-/* 0 */         .long   sys_restart_syscall
-                .long   sys_exit
-                .long   sys_fork_wrapper
-                .long   sys_read
-                .long   sys_write
-/* 5 */         .long   sys_open
-                .long   sys_close
-                .long   sys_ni_syscall          /* was sys_waitpid */
-                .long   sys_creat
-                .long   sys_link
-/* 10 */        .long   sys_unlink
-                .long   sys_execve_wrapper
-                .long   sys_chdir
-                .long   OBSOLETE(sys_time)      /* used by libc4 */
-                .long   sys_mknod
-/* 15 */        .long   sys_chmod
-                .long   sys_lchown16
-                .long   sys_ni_syscall          /* was sys_break */
-                .long   sys_ni_syscall          /* was sys_stat */
-                .long   sys_lseek
-/* 20 */        .long   sys_getpid
-                .long   sys_mount
-                .long   OBSOLETE(sys_oldumount) /* used by libc4 */
-                .long   sys_setuid16
-                .long   sys_getuid16
-/* 25 */        .long   OBSOLETE(sys_stime)
-                .long   sys_ptrace
-                .long   OBSOLETE(sys_alarm)     /* used by libc4 */
-                .long   sys_ni_syscall          /* was sys_fstat */
-                .long   sys_pause
-/* 30 */        .long   OBSOLETE(sys_utime)     /* used by libc4 */
-                .long   sys_ni_syscall          /* was sys_stty */
-                .long   sys_ni_syscall          /* was sys_getty */
-                .long   sys_access
-                .long   sys_nice
-/* 35 */        .long   sys_ni_syscall          /* was sys_ftime */
-                .long   sys_sync
-                .long   sys_kill
-                .long   sys_rename
-                .long   sys_mkdir
-/* 40 */        .long   sys_rmdir
-                .long   sys_dup
-                .long   sys_pipe
-                .long   sys_times
-                .long   sys_ni_syscall          /* was sys_prof */
-/* 45 */        .long   sys_brk
-                .long   sys_setgid16
-                .long   sys_getgid16
-                .long   sys_ni_syscall          /* was sys_signal */
-                .long   sys_geteuid16
-/* 50 */        .long   sys_getegid16
-                .long   sys_acct
-                .long   sys_umount
-                .long   sys_ni_syscall          /* was sys_lock */
-                .long   sys_ioctl
-/* 55 */        .long   sys_fcntl
-                .long   sys_ni_syscall          /* was sys_mpx */
-                .long   sys_setpgid
-                .long   sys_ni_syscall          /* was sys_ulimit */
-                .long   sys_ni_syscall          /* was sys_olduname */
-/* 60 */        .long   sys_umask
-                .long   sys_chroot
-                .long   sys_ustat
-                .long   sys_dup2
-                .long   sys_getppid
-/* 65 */        .long   sys_getpgrp
-                .long   sys_setsid
-                .long   sys_sigaction
-                .long   sys_ni_syscall          /* was sys_sgetmask */
-                .long   sys_ni_syscall          /* was sys_ssetmask */
-/* 70 */        .long   sys_setreuid16
-                .long   sys_setregid16
-                .long   sys_sigsuspend_wrapper
-                .long   sys_sigpending
-                .long   sys_sethostname
-/* 75 */        .long   sys_setrlimit
-                .long   OBSOLETE(sys_old_getrlimit) /* used by libc4 */
-                .long   sys_getrusage
-                .long   sys_gettimeofday
-                .long   sys_settimeofday
-/* 80 */        .long   sys_getgroups16
-                .long   sys_setgroups16
-                .long   OBSOLETE(old_select)    /* used by libc4 */
-                .long   sys_symlink
-                .long   sys_ni_syscall          /* was sys_lstat */
-/* 85 */        .long   sys_readlink
-                .long   sys_uselib
-                .long   sys_swapon
-                .long   sys_reboot
-                .long   OBSOLETE(old_readdir)   /* used by libc4 */
-/* 90 */        .long   OBSOLETE(old_mmap)      /* used by libc4 */
-                .long   sys_munmap
-                .long   sys_truncate
-                .long   sys_ftruncate
-                .long   sys_fchmod
-/* 95 */        .long   sys_fchown16
-                .long   sys_getpriority
-                .long   sys_setpriority
-                .long   sys_ni_syscall          /* was sys_profil */
-                .long   sys_statfs
-/* 100 */       .long   sys_fstatfs
-                .long   sys_ni_syscall
-                .long   OBSOLETE(sys_socketcall)
-                .long   sys_syslog
-                .long   sys_setitimer
-/* 105 */       .long   sys_getitimer
-                .long   sys_newstat
-                .long   sys_newlstat
-                .long   sys_newfstat
-                .long   sys_ni_syscall          /* was sys_uname */
-/* 110 */       .long   sys_ni_syscall          /* was sys_iopl */
-                .long   sys_vhangup
-                .long   sys_ni_syscall
-                .long   OBSOLETE(sys_syscall)   /* call a syscall */
-                .long   sys_wait4
-/* 115 */       .long   sys_swapoff
-                .long   sys_sysinfo
-                .long   OBSOLETE(ABI(sys_ipc, sys_oabi_ipc))
-                .long   sys_fsync
-                .long   sys_sigreturn_wrapper
-/* 120 */       .long   sys_clone_wrapper
-                .long   sys_setdomainname
-                .long   sys_newuname
-                .long   sys_ni_syscall
-                .long   sys_adjtimex
-/* 125 */       .long   sys_mprotect
-                .long   sys_sigprocmask
-                .long   sys_ni_syscall          /* was sys_create_module */
-                .long   sys_init_module
-                .long   sys_delete_module
-/* 130 */       .long   sys_ni_syscall          /* was sys_get_kernel_syms */
-                .long   sys_quotactl
-                .long   sys_getpgid
-                .long   sys_fchdir
-                .long   sys_bdflush
-/* 135 */       .long   sys_sysfs
-                .long   sys_personality
-                .long   sys_ni_syscall          /* .long        _sys_afs_syscall */
-                .long   sys_setfsuid16
-                .long   sys_setfsgid16
-/* 140 */       .long   sys_llseek
-                .long   sys_getdents
-                .long   sys_select
-                .long   sys_flock
-                .long   sys_msync
-/* 145 */       .long   sys_readv
-                .long   sys_writev
-                .long   sys_getsid
-                .long   sys_fdatasync
-                .long   sys_sysctl
-/* 150 */       .long   sys_mlock
-                .long   sys_munlock
-                .long   sys_mlockall
-                .long   sys_munlockall
-                .long   sys_sched_setparam
-/* 155 */       .long   sys_sched_getparam
-                .long   sys_sched_setscheduler
-                .long   sys_sched_getscheduler
-                .long   sys_sched_yield
-                .long   sys_sched_get_priority_max
-/* 160 */       .long   sys_sched_get_priority_min
-                .long   sys_sched_rr_get_interval
-                .long   sys_nanosleep
-                .long   sys_arm_mremap
-                .long   sys_setresuid16
-/* 165 */       .long   sys_getresuid16
-                .long   sys_ni_syscall
-                .long   sys_ni_syscall          /* was sys_query_module */
-                .long   sys_poll
-                .long   sys_nfsservctl
-/* 170 */       .long   sys_setresgid16
-                .long   sys_getresgid16
-                .long   sys_prctl
-                .long   sys_rt_sigreturn_wrapper
-                .long   sys_rt_sigaction
-/* 175 */       .long   sys_rt_sigprocmask
-                .long   sys_rt_sigpending
-                .long   sys_rt_sigtimedwait
-                .long   sys_rt_sigqueueinfo
-                .long   sys_rt_sigsuspend_wrapper
-/* 180 */       .long   ABI(sys_pread64, sys_oabi_pread64)
-                .long   ABI(sys_pwrite64, sys_oabi_pwrite64)
-                .long   sys_chown16
-                .long   sys_getcwd
-                .long   sys_capget
-/* 185 */       .long   sys_capset
-                .long   sys_sigaltstack_wrapper
-                .long   sys_sendfile
-                .long   sys_ni_syscall
-                .long   sys_ni_syscall
-/* 190 */       .long   sys_vfork_wrapper
-                .long   sys_getrlimit
-                .long   sys_mmap2
-                .long   ABI(sys_truncate64, sys_oabi_truncate64)
-                .long   ABI(sys_ftruncate64, sys_oabi_ftruncate64)
-/* 195 */       .long   ABI(sys_stat64, sys_oabi_stat64)
-                .long   ABI(sys_lstat64, sys_oabi_lstat64)
-                .long   ABI(sys_fstat64, sys_oabi_fstat64)
-                .long   sys_lchown
-                .long   sys_getuid
-/* 200 */       .long   sys_getgid
-                .long   sys_geteuid
-                .long   sys_getegid
-                .long   sys_setreuid
-                .long   sys_setregid
-/* 205 */       .long   sys_getgroups
-                .long   sys_setgroups
-                .long   sys_fchown
-                .long   sys_setresuid
-                .long   sys_getresuid
-/* 210 */       .long   sys_setresgid
-                .long   sys_getresgid
-                .long   sys_chown
-                .long   sys_setuid
-                .long   sys_setgid
-/* 215 */       .long   sys_setfsuid
-                .long   sys_setfsgid
-                .long   sys_getdents64
-                .long   sys_pivot_root
-                .long   sys_mincore
-/* 220 */       .long   sys_madvise
-                .long   ABI(sys_fcntl64, sys_oabi_fcntl64)
-                .long   sys_ni_syscall /* TUX */
-                .long   sys_ni_syscall
-                .long   sys_gettid
-/* 225 */       .long   ABI(sys_readahead, sys_oabi_readahead)
-                .long   sys_setxattr
-                .long   sys_lsetxattr
-                .long   sys_fsetxattr
-                .long   sys_getxattr
-/* 230 */       .long   sys_lgetxattr
-                .long   sys_fgetxattr
-                .long   sys_listxattr
-                .long   sys_llistxattr
-                .long   sys_flistxattr
-/* 235 */       .long   sys_removexattr
-                .long   sys_lremovexattr
-                .long   sys_fremovexattr
-                .long   sys_tkill
-                .long   sys_sendfile64
-/* 240 */       .long   sys_futex
-                .long   sys_sched_setaffinity
-                .long   sys_sched_getaffinity
-                .long   sys_io_setup
-                .long   sys_io_destroy
-/* 245 */       .long   sys_io_getevents
-                .long   sys_io_submit
-                .long   sys_io_cancel
-                .long   sys_exit_group
-                .long   sys_lookup_dcookie
-/* 250 */       .long   sys_epoll_create
-                .long   ABI(sys_epoll_ctl, sys_oabi_epoll_ctl)
-                .long   ABI(sys_epoll_wait, sys_oabi_epoll_wait)
-                .long   sys_remap_file_pages
-                .long   sys_ni_syscall  /* sys_set_thread_area */
-/* 255 */       .long   sys_ni_syscall  /* sys_get_thread_area */
-                .long   sys_set_tid_address
-                .long   sys_timer_create
-                .long   sys_timer_settime
-                .long   sys_timer_gettime
-/* 260 */       .long   sys_timer_getoverrun
-                .long   sys_timer_delete
-                .long   sys_clock_settime
-                .long   sys_clock_gettime
-                .long   sys_clock_getres
-/* 265 */       .long   sys_clock_nanosleep
-                .long   sys_statfs64_wrapper
-                .long   sys_fstatfs64_wrapper
-                .long   sys_tgkill
-                .long   sys_utimes
-/* 270 */       .long   sys_arm_fadvise64_64
-                .long   sys_pciconfig_iobase
-                .long   sys_pciconfig_read
-                .long   sys_pciconfig_write
-                .long   sys_mq_open
-/* 275 */       .long   sys_mq_unlink
-                .long   sys_mq_timedsend
-                .long   sys_mq_timedreceive
-                .long   sys_mq_notify
-                .long   sys_mq_getsetattr
-/* 280 */       .long   sys_waitid
-                .long   sys_socket
-                .long   sys_bind
-                .long   sys_connect
-                .long   sys_listen
-/* 285 */       .long   sys_accept
-                .long   sys_getsockname
-                .long   sys_getpeername
-                .long   sys_socketpair
-                .long   sys_send
-/* 290 */       .long   sys_sendto
-                .long   sys_recv
-                .long   sys_recvfrom
-                .long   sys_shutdown
-                .long   sys_setsockopt
-/* 295 */       .long   sys_getsockopt
-                .long   sys_sendmsg
-                .long   sys_recvmsg
-                .long   ABI(sys_semop, sys_oabi_semop)
-                .long   sys_semget
-/* 300 */       .long   sys_semctl
-                .long   sys_msgsnd
-                .long   sys_msgrcv
-                .long   sys_msgget
-                .long   sys_msgctl
-/* 305 */       .long   sys_shmat
-                .long   sys_shmdt
-                .long   sys_shmget
-                .long   sys_shmctl
-                .long   sys_add_key
-/* 310 */       .long   sys_request_key
-                .long   sys_keyctl
-                .long   ABI(sys_semtimedop, sys_oabi_semtimedop)
-/* vserver */   .long   sys_ni_syscall
-                .long   sys_ioprio_set
-/* 315 */       .long   sys_ioprio_get
-                .long   sys_inotify_init
-                .long   sys_inotify_add_watch
-                .long   sys_inotify_rm_watch
-                .long   sys_mbind
-/* 320 */       .long   sys_get_mempolicy
-                .long   sys_set_mempolicy
-
-                .rept   NR_syscalls - (. - 100b) / 4
-                        .long   sys_ni_syscall
-                .endr
+/* 0 */         CALL(sys_restart_syscall)
+                CALL(sys_exit)
+                CALL(sys_fork_wrapper)
+                CALL(sys_read)
+                CALL(sys_write)
+/* 5 */         CALL(sys_open)
+                CALL(sys_close)
+                CALL(sys_ni_syscall)            /* was sys_waitpid */
+                CALL(sys_creat)
+                CALL(sys_link)
+/* 10 */        CALL(sys_unlink)
+                CALL(sys_execve_wrapper)
+                CALL(sys_chdir)
+                CALL(OBSOLETE(sys_time))        /* used by libc4 */
+                CALL(sys_mknod)
+/* 15 */        CALL(sys_chmod)
+                CALL(sys_lchown16)
+                CALL(sys_ni_syscall)            /* was sys_break */
+                CALL(sys_ni_syscall)            /* was sys_stat */
+                CALL(sys_lseek)
+/* 20 */        CALL(sys_getpid)
+                CALL(sys_mount)
+                CALL(OBSOLETE(sys_oldumount))   /* used by libc4 */
+                CALL(sys_setuid16)
+                CALL(sys_getuid16)
+/* 25 */        CALL(OBSOLETE(sys_stime))
+                CALL(sys_ptrace)
+                CALL(OBSOLETE(sys_alarm))       /* used by libc4 */
+                CALL(sys_ni_syscall)            /* was sys_fstat */
+                CALL(sys_pause)
+/* 30 */        CALL(OBSOLETE(sys_utime))       /* used by libc4 */
+                CALL(sys_ni_syscall)            /* was sys_stty */
+                CALL(sys_ni_syscall)            /* was sys_getty */
+                CALL(sys_access)
+                CALL(sys_nice)
+/* 35 */        CALL(sys_ni_syscall)            /* was sys_ftime */
+                CALL(sys_sync)
+                CALL(sys_kill)
+                CALL(sys_rename)
+                CALL(sys_mkdir)
+/* 40 */        CALL(sys_rmdir)
+                CALL(sys_dup)
+                CALL(sys_pipe)
+                CALL(sys_times)
+                CALL(sys_ni_syscall)            /* was sys_prof */
+/* 45 */        CALL(sys_brk)
+                CALL(sys_setgid16)
+                CALL(sys_getgid16)
+                CALL(sys_ni_syscall)            /* was sys_signal */
+                CALL(sys_geteuid16)
+/* 50 */        CALL(sys_getegid16)
+                CALL(sys_acct)
+                CALL(sys_umount)
+                CALL(sys_ni_syscall)            /* was sys_lock */
+                CALL(sys_ioctl)
+/* 55 */        CALL(sys_fcntl)
+                CALL(sys_ni_syscall)            /* was sys_mpx */
+                CALL(sys_setpgid)
+                CALL(sys_ni_syscall)            /* was sys_ulimit */
+                CALL(sys_ni_syscall)            /* was sys_olduname */
+/* 60 */        CALL(sys_umask)
+                CALL(sys_chroot)
+                CALL(sys_ustat)
+                CALL(sys_dup2)
+                CALL(sys_getppid)
+/* 65 */        CALL(sys_getpgrp)
+                CALL(sys_setsid)
+                CALL(sys_sigaction)
+                CALL(sys_ni_syscall)            /* was sys_sgetmask */
+                CALL(sys_ni_syscall)            /* was sys_ssetmask */
+/* 70 */        CALL(sys_setreuid16)
+                CALL(sys_setregid16)
+                CALL(sys_sigsuspend_wrapper)
+                CALL(sys_sigpending)
+                CALL(sys_sethostname)
+/* 75 */        CALL(sys_setrlimit)
+                CALL(OBSOLETE(sys_old_getrlimit)) /* used by libc4 */
+                CALL(sys_getrusage)
+                CALL(sys_gettimeofday)
+                CALL(sys_settimeofday)
+/* 80 */        CALL(sys_getgroups16)
+                CALL(sys_setgroups16)
+                CALL(OBSOLETE(old_select))      /* used by libc4 */
+                CALL(sys_symlink)
+                CALL(sys_ni_syscall)            /* was sys_lstat */
+/* 85 */        CALL(sys_readlink)
+                CALL(sys_uselib)
+                CALL(sys_swapon)
+                CALL(sys_reboot)
+                CALL(OBSOLETE(old_readdir))     /* used by libc4 */
+/* 90 */        CALL(OBSOLETE(old_mmap))        /* used by libc4 */
+                CALL(sys_munmap)
+                CALL(sys_truncate)
+                CALL(sys_ftruncate)
+                CALL(sys_fchmod)
+/* 95 */        CALL(sys_fchown16)
+                CALL(sys_getpriority)
+                CALL(sys_setpriority)
+                CALL(sys_ni_syscall)            /* was sys_profil */
+                CALL(sys_statfs)
+/* 100 */       CALL(sys_fstatfs)
+                CALL(sys_ni_syscall)
+                CALL(OBSOLETE(sys_socketcall))
+                CALL(sys_syslog)
+                CALL(sys_setitimer)
+/* 105 */       CALL(sys_getitimer)
+                CALL(sys_newstat)
+                CALL(sys_newlstat)
+                CALL(sys_newfstat)
+                CALL(sys_ni_syscall)            /* was sys_uname */
+/* 110 */       CALL(sys_ni_syscall)            /* was sys_iopl */
+                CALL(sys_vhangup)
+                CALL(sys_ni_syscall)
+                CALL(OBSOLETE(sys_syscall))     /* call a syscall */
+                CALL(sys_wait4)
+/* 115 */       CALL(sys_swapoff)
+                CALL(sys_sysinfo)
+                CALL(OBSOLETE(ABI(sys_ipc, sys_oabi_ipc)))
+                CALL(sys_fsync)
+                CALL(sys_sigreturn_wrapper)
+/* 120 */       CALL(sys_clone_wrapper)
+                CALL(sys_setdomainname)
+                CALL(sys_newuname)
+                CALL(sys_ni_syscall)
+                CALL(sys_adjtimex)
+/* 125 */       CALL(sys_mprotect)
+                CALL(sys_sigprocmask)
+                CALL(sys_ni_syscall)            /* was sys_create_module */
+                CALL(sys_init_module)
+                CALL(sys_delete_module)
+/* 130 */       CALL(sys_ni_syscall)            /* was sys_get_kernel_syms */
+                CALL(sys_quotactl)
+                CALL(sys_getpgid)
+                CALL(sys_fchdir)
+                CALL(sys_bdflush)
+/* 135 */       CALL(sys_sysfs)
+                CALL(sys_personality)
+                CALL(sys_ni_syscall)            /* CALL(_sys_afs_syscall) */
+                CALL(sys_setfsuid16)
+                CALL(sys_setfsgid16)
+/* 140 */       CALL(sys_llseek)
+                CALL(sys_getdents)
+                CALL(sys_select)
+                CALL(sys_flock)
+                CALL(sys_msync)
+/* 145 */       CALL(sys_readv)
+                CALL(sys_writev)
+                CALL(sys_getsid)
+                CALL(sys_fdatasync)
+                CALL(sys_sysctl)
+/* 150 */       CALL(sys_mlock)
+                CALL(sys_munlock)
+                CALL(sys_mlockall)
+                CALL(sys_munlockall)
+                CALL(sys_sched_setparam)
+/* 155 */       CALL(sys_sched_getparam)
+                CALL(sys_sched_setscheduler)
+                CALL(sys_sched_getscheduler)
+                CALL(sys_sched_yield)
+                CALL(sys_sched_get_priority_max)
+/* 160 */       CALL(sys_sched_get_priority_min)
+                CALL(sys_sched_rr_get_interval)
+                CALL(sys_nanosleep)
+                CALL(sys_arm_mremap)
+                CALL(sys_setresuid16)
+/* 165 */       CALL(sys_getresuid16)
+                CALL(sys_ni_syscall)
+                CALL(sys_ni_syscall)            /* was sys_query_module */
+                CALL(sys_poll)
+                CALL(sys_nfsservctl)
+/* 170 */       CALL(sys_setresgid16)
+                CALL(sys_getresgid16)
+                CALL(sys_prctl)
+                CALL(sys_rt_sigreturn_wrapper)
+                CALL(sys_rt_sigaction)
+/* 175 */       CALL(sys_rt_sigprocmask)
+                CALL(sys_rt_sigpending)
+                CALL(sys_rt_sigtimedwait)
+                CALL(sys_rt_sigqueueinfo)
+                CALL(sys_rt_sigsuspend_wrapper)
+/* 180 */       CALL(ABI(sys_pread64, sys_oabi_pread64))
+                CALL(ABI(sys_pwrite64, sys_oabi_pwrite64))
+                CALL(sys_chown16)
+                CALL(sys_getcwd)
+                CALL(sys_capget)
+/* 185 */       CALL(sys_capset)
+                CALL(sys_sigaltstack_wrapper)
+                CALL(sys_sendfile)
+                CALL(sys_ni_syscall)
+                CALL(sys_ni_syscall)
+/* 190 */       CALL(sys_vfork_wrapper)
+                CALL(sys_getrlimit)
+                CALL(sys_mmap2)
+                CALL(ABI(sys_truncate64, sys_oabi_truncate64))
+                CALL(ABI(sys_ftruncate64, sys_oabi_ftruncate64))
+/* 195 */       CALL(ABI(sys_stat64, sys_oabi_stat64))
+                CALL(ABI(sys_lstat64, sys_oabi_lstat64))
+                CALL(ABI(sys_fstat64, sys_oabi_fstat64))
+                CALL(sys_lchown)
+                CALL(sys_getuid)
+/* 200 */       CALL(sys_getgid)
+                CALL(sys_geteuid)
+                CALL(sys_getegid)
+                CALL(sys_setreuid)
+                CALL(sys_setregid)
+/* 205 */       CALL(sys_getgroups)
+                CALL(sys_setgroups)
+                CALL(sys_fchown)
+                CALL(sys_setresuid)
+                CALL(sys_getresuid)
+/* 210 */       CALL(sys_setresgid)
+                CALL(sys_getresgid)
+                CALL(sys_chown)
+                CALL(sys_setuid)
+                CALL(sys_setgid)
+/* 215 */       CALL(sys_setfsuid)
+                CALL(sys_setfsgid)
+                CALL(sys_getdents64)
+                CALL(sys_pivot_root)
+                CALL(sys_mincore)
+/* 220 */       CALL(sys_madvise)
+                CALL(ABI(sys_fcntl64, sys_oabi_fcntl64))
+                CALL(sys_ni_syscall) /* TUX */
+                CALL(sys_ni_syscall)
+                CALL(sys_gettid)
+/* 225 */       CALL(ABI(sys_readahead, sys_oabi_readahead))
+                CALL(sys_setxattr)
+                CALL(sys_lsetxattr)
+                CALL(sys_fsetxattr)
+                CALL(sys_getxattr)
+/* 230 */       CALL(sys_lgetxattr)
+                CALL(sys_fgetxattr)
+                CALL(sys_listxattr)
+                CALL(sys_llistxattr)
+                CALL(sys_flistxattr)
+/* 235 */       CALL(sys_removexattr)
+                CALL(sys_lremovexattr)
+                CALL(sys_fremovexattr)
+                CALL(sys_tkill)
+                CALL(sys_sendfile64)
+/* 240 */       CALL(sys_futex)
+                CALL(sys_sched_setaffinity)
+                CALL(sys_sched_getaffinity)
+                CALL(sys_io_setup)
+                CALL(sys_io_destroy)
+/* 245 */       CALL(sys_io_getevents)
+                CALL(sys_io_submit)
+                CALL(sys_io_cancel)
+                CALL(sys_exit_group)
+                CALL(sys_lookup_dcookie)
+/* 250 */       CALL(sys_epoll_create)
+                CALL(ABI(sys_epoll_ctl, sys_oabi_epoll_ctl))
+                CALL(ABI(sys_epoll_wait, sys_oabi_epoll_wait))
+                CALL(sys_remap_file_pages)
+                CALL(sys_ni_syscall)    /* sys_set_thread_area */
+/* 255 */       CALL(sys_ni_syscall)    /* sys_get_thread_area */
+                CALL(sys_set_tid_address)
+                CALL(sys_timer_create)
+                CALL(sys_timer_settime)
+                CALL(sys_timer_gettime)
+/* 260 */       CALL(sys_timer_getoverrun)
+                CALL(sys_timer_delete)
+                CALL(sys_clock_settime)
+                CALL(sys_clock_gettime)
+                CALL(sys_clock_getres)
+/* 265 */       CALL(sys_clock_nanosleep)
+                CALL(sys_statfs64_wrapper)
+                CALL(sys_fstatfs64_wrapper)
+                CALL(sys_tgkill)
+                CALL(sys_utimes)
+/* 270 */       CALL(sys_arm_fadvise64_64)
+                CALL(sys_pciconfig_iobase)
+                CALL(sys_pciconfig_read)
+                CALL(sys_pciconfig_write)
+                CALL(sys_mq_open)
+/* 275 */       CALL(sys_mq_unlink)
+                CALL(sys_mq_timedsend)
+                CALL(sys_mq_timedreceive)
+                CALL(sys_mq_notify)
+                CALL(sys_mq_getsetattr)
+/* 280 */       CALL(sys_waitid)
+                CALL(sys_socket)
+                CALL(ABI(sys_bind, sys_oabi_bind))
+                CALL(ABI(sys_connect, sys_oabi_connect))
+                CALL(sys_listen)
+/* 285 */       CALL(sys_accept)
+                CALL(sys_getsockname)
+                CALL(sys_getpeername)
+                CALL(sys_socketpair)
+                CALL(sys_send)
+/* 290 */       CALL(ABI(sys_sendto, sys_oabi_sendto))
+                CALL(sys_recv)
+                CALL(sys_recvfrom)
+                CALL(sys_shutdown)
+                CALL(sys_setsockopt)
+/* 295 */       CALL(sys_getsockopt)
+                CALL(ABI(sys_sendmsg, sys_oabi_sendmsg))
+                CALL(sys_recvmsg)
+                CALL(ABI(sys_semop, sys_oabi_semop))
+                CALL(sys_semget)
+/* 300 */       CALL(sys_semctl)
+                CALL(sys_msgsnd)
+                CALL(sys_msgrcv)
+                CALL(sys_msgget)
+                CALL(sys_msgctl)
+/* 305 */       CALL(sys_shmat)
+                CALL(sys_shmdt)
+                CALL(sys_shmget)
+                CALL(sys_shmctl)
+                CALL(sys_add_key)
+/* 310 */       CALL(sys_request_key)
+                CALL(sys_keyctl)
+                CALL(ABI(sys_semtimedop, sys_oabi_semtimedop))
+/* vserver */   CALL(sys_ni_syscall)
+                CALL(sys_ioprio_set)
+/* 315 */       CALL(sys_ioprio_get)
+                CALL(sys_inotify_init)
+                CALL(sys_inotify_add_watch)
+                CALL(sys_inotify_rm_watch)
+                CALL(sys_mbind)
+/* 320 */       CALL(sys_get_mempolicy)
+                CALL(sys_set_mempolicy)
+#ifndef syscalls_counted
+.equ syscalls_padding, ((NR_syscalls + 3) & ~3) - NR_syscalls
+#define syscalls_counted
 #endif
+.rept syscalls_padding
+                CALL(sys_ni_syscall)
+.endr
diff --git a/arch/arm/kernel/entry-armv.S b/arch/arm/kernel/entry-armv.S
index 874e6bb79405..964cd717506b 100644
--- a/arch/arm/kernel/entry-armv.S
+++ b/arch/arm/kernel/entry-armv.S
@@ -333,10 +333,14 @@ __pabt_svc:
                                         @ from the exception stack
 
 #if __LINUX_ARM_ARCH__ < 6 && !defined(CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG)
+#ifndef CONFIG_MMU
+#warning "NPTL on non MMU needs fixing"
+#else
         @ make sure our user space atomic helper is aborted
         cmp     r2, #TASK_SIZE
         bichs   r3, r3, #PSR_Z_BIT
 #endif
+#endif
 
         @
         @ We are now ready to fill in the remaining blanks on the stack:
@@ -705,7 +709,12 @@ __kuser_memory_barrier:				@ 0xffff0fa0
  * The C flag is also set if *ptr was changed to allow for assembly
  * optimization in the calling code.
  *
- * Note: this routine already includes memory barriers as needed.
+ * Notes:
+ *
+ *    - This routine already includes memory barriers as needed.
+ *
+ *    - A failure might be transient, i.e. it is possible, although unlikely,
+ *      that "failure" be returned even if *ptr == oldval.
  *
  * For example, a user space atomic_add implementation could look like this:
  *
@@ -735,8 +744,11 @@ __kuser_cmpxchg:				@ 0xffff0fc0
          * The kernel itself must perform the operation.
          * A special ghost syscall is used for that (see traps.c).
          */
+        stmfd   sp!, {r7, lr}
+        mov     r7, #0xff00             @ 0xfff0 into r7 for EABI
+        orr     r7, r7, #0xf0
         swi     #0x9ffff0
-        mov     pc, lr
+        ldmfd   sp!, {r7, pc}
 
 #elif __LINUX_ARM_ARCH__ < 6
 
@@ -753,12 +765,18 @@ __kuser_cmpxchg:				@ 0xffff0fc0
          * exception happening just after the str instruction which would
          * clear the Z flag although the exchange was done.
          */
+#ifdef CONFIG_MMU
         teq     ip, ip                  @ set Z flag
         ldr     ip, [r2]                @ load current val
         add     r3, r2, #1              @ prepare store ptr
         teqeq   ip, r0                  @ compare with oldval if still allowed
         streq   r1, [r3, #-1]!          @ store newval if still allowed
         subs    r0, r2, r3              @ if r2 == r3 the str occured
+#else
+#warning "NPTL on non MMU needs fixing"
+        mov     r0, #-1
+        adds    r0, r0, #0
+#endif
         mov     pc, lr
 
 #else
diff --git a/arch/arm/kernel/entry-common.S b/arch/arm/kernel/entry-common.S
index 2b92ce85f97f..dbcb11a31f78 100644
--- a/arch/arm/kernel/entry-common.S
+++ b/arch/arm/kernel/entry-common.S
@@ -87,7 +87,11 @@ ENTRY(ret_from_fork)
         b       ret_slow_syscall
         
 
+        .equ NR_syscalls,0
+#define CALL(x) .equ NR_syscalls,NR_syscalls+1
 #include "calls.S"
+#undef CALL
+#define CALL(x) .long x
 
 /*=============================================================================
  * SWI handler
diff --git a/arch/arm/kernel/signal.c b/arch/arm/kernel/signal.c
index 765922bcf9e7..a0cd0a90a10d 100644
--- a/arch/arm/kernel/signal.c
+++ b/arch/arm/kernel/signal.c
@@ -30,15 +30,21 @@
 #define SWI_SYS_RT_SIGRETURN    (0xef000000|(__NR_rt_sigreturn))
 
 /*
+ * With EABI, the syscall number has to be loaded into r7.
+ */
+#define MOV_R7_NR_SIGRETURN     (0xe3a07000 | (__NR_sigreturn - __NR_SYSCALL_BASE))
+#define MOV_R7_NR_RT_SIGRETURN  (0xe3a07000 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
+
+/*
  * For Thumb syscalls, we pass the syscall number via r7.  We therefore
  * need two 16-bit instructions.
  */
 #define SWI_THUMB_SIGRETURN     (0xdf00 << 16 | 0x2700 | (__NR_sigreturn - __NR_SYSCALL_BASE))
 #define SWI_THUMB_RT_SIGRETURN  (0xdf00 << 16 | 0x2700 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
 
-const unsigned long sigreturn_codes[4] = {
-        SWI_SYS_SIGRETURN,      SWI_THUMB_SIGRETURN,
-        SWI_SYS_RT_SIGRETURN,   SWI_THUMB_RT_SIGRETURN
+const unsigned long sigreturn_codes[7] = {
+        MOV_R7_NR_SIGRETURN,    SWI_SYS_SIGRETURN,    SWI_THUMB_SIGRETURN,
+        MOV_R7_NR_RT_SIGRETURN, SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN,
 };
 
 static int do_signal(sigset_t *oldset, struct pt_regs * regs, int syscall);
@@ -189,7 +195,7 @@ struct aux_sigframe {
 struct sigframe {
         struct sigcontext sc;
         unsigned long extramask[_NSIG_WORDS-1];
-        unsigned long retcode;
+        unsigned long retcode[2];
         struct aux_sigframe aux __attribute__((aligned(8)));
 };
 
@@ -198,7 +204,7 @@ struct rt_sigframe {
         void __user *puc;
         struct siginfo info;
         struct ucontext uc;
-        unsigned long retcode;
+        unsigned long retcode[2];
         struct aux_sigframe aux __attribute__((aligned(8)));
 };
 
@@ -436,12 +442,13 @@ setup_return(struct pt_regs *regs, struct k_sigaction *ka,
         if (ka->sa.sa_flags & SA_RESTORER) {
                 retcode = (unsigned long)ka->sa.sa_restorer;
         } else {
-                unsigned int idx = thumb;
+                unsigned int idx = thumb << 1;
 
                 if (ka->sa.sa_flags & SA_SIGINFO)
-                        idx += 2;
+                        idx += 3;
 
-                if (__put_user(sigreturn_codes[idx], rc))
+                if (__put_user(sigreturn_codes[idx],   rc) ||
+                    __put_user(sigreturn_codes[idx+1], rc+1))
                         return 1;
 
                 if (cpsr & MODE32_BIT) {
@@ -456,7 +463,7 @@ setup_return(struct pt_regs *regs, struct k_sigaction *ka,
                          * the return code written onto the stack.
                          */
                         flush_icache_range((unsigned long)rc,
-                                           (unsigned long)(rc + 1));
+                                           (unsigned long)(rc + 2));
 
                         retcode = ((unsigned long)rc) + thumb;
                 }
@@ -488,7 +495,7 @@ setup_frame(int usig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *reg
         }
 
         if (err == 0)
-                err = setup_return(regs, ka, &frame->retcode, frame, usig);
+                err = setup_return(regs, ka, frame->retcode, frame, usig);
 
         return err;
 }
@@ -522,7 +529,7 @@ setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 
         if (err == 0)
-                err = setup_return(regs, ka, &frame->retcode, frame, usig);
+                err = setup_return(regs, ka, frame->retcode, frame, usig);
 
         if (err == 0) {
                 /*
diff --git a/arch/arm/kernel/signal.h b/arch/arm/kernel/signal.h
index 91d26faca62b..9991049c522d 100644
--- a/arch/arm/kernel/signal.h
+++ b/arch/arm/kernel/signal.h
@@ -9,4 +9,4 @@
  */
 #define KERN_SIGRETURN_CODE     0xffff0500
 
-extern const unsigned long sigreturn_codes[4];
+extern const unsigned long sigreturn_codes[7];
diff --git a/arch/arm/kernel/sys_oabi-compat.c b/arch/arm/kernel/sys_oabi-compat.c
index eafa8e5284af..9d4b76409c64 100644
--- a/arch/arm/kernel/sys_oabi-compat.c
+++ b/arch/arm/kernel/sys_oabi-compat.c
@@ -59,6 +59,16 @@
  *   struct sembuf loses its padding with EABI.  Since arrays of them are
  *   used they have to be copyed to remove the padding. Compatibility wrappers
  *   provided below.
+ *
+ * sys_bind:
+ * sys_connect:
+ * sys_sendmsg:
+ * sys_sendto:
+ *
+ *   struct sockaddr_un loses its padding with EABI.  Since the size of the
+ *   structure is used as a validation test in unix_mkname(), we need to
+ *   change the length argument to 110 whenever it is 112.  Compatibility
+ *   wrappers provided below.
  */
 
 #include <linux/syscalls.h>
@@ -67,6 +77,7 @@
 #include <linux/fcntl.h>
 #include <linux/eventpoll.h>
 #include <linux/sem.h>
+#include <linux/socket.h>
 #include <asm/ipc.h>
 #include <asm/uaccess.h>
 
@@ -337,3 +348,63 @@ asmlinkage int sys_oabi_ipc(uint call, int first, int second, int third,
                 return sys_ipc(call, first, second, third, ptr, fifth);
         }
 }
+
+asmlinkage long sys_oabi_bind(int fd, struct sockaddr __user *addr, int addrlen)
+{
+        sa_family_t sa_family;
+        if (addrlen == 112 &&
+            get_user(sa_family, &addr->sa_family) == 0 &&
+            sa_family == AF_UNIX)
+                        addrlen = 110;
+        return sys_bind(fd, addr, addrlen);
+}
+
+asmlinkage long sys_oabi_connect(int fd, struct sockaddr __user *addr, int addrlen)
+{
+        sa_family_t sa_family;
+        if (addrlen == 112 &&
+            get_user(sa_family, &addr->sa_family) == 0 &&
+            sa_family == AF_UNIX)
+                        addrlen = 110;
+        return sys_connect(fd, addr, addrlen);
+}
+
+asmlinkage long sys_oabi_sendto(int fd, void __user *buff,
+                                size_t len, unsigned flags,
+                                struct sockaddr __user *addr,
+                                int addrlen)
+{
+        sa_family_t sa_family;
+        if (addrlen == 112 &&
+            get_user(sa_family, &addr->sa_family) == 0 &&
+            sa_family == AF_UNIX)
+                        addrlen = 110;
+        return sys_sendto(fd, buff, len, flags, addr, addrlen);
+}
+
+asmlinkage long sys_oabi_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
+{
+        struct sockaddr __user *addr;
+        int msg_namelen;
+        sa_family_t sa_family;
+        if (msg &&
+            get_user(msg_namelen, &msg->msg_namelen) == 0 &&
+            msg_namelen == 112 &&
+            get_user(addr, &msg->msg_name) == 0 &&
+            get_user(sa_family, &addr->sa_family) == 0 &&
+            sa_family == AF_UNIX)
+        {
+                /*
+                 * HACK ALERT: there is a limit to how much backward bending
+                 * we should do for what is actually a transitional
+                 * compatibility layer.  This already has known flaws with
+                 * a few ioctls that we don't intend to fix.  Therefore
+                 * consider this blatent hack as another one... and take care
+                 * to run for cover.  In most cases it will "just work fine".
+                 * If it doesn't, well, tough.
+                 */
+                put_user(110, &msg->msg_namelen);
+        }
+        return sys_sendmsg(fd, msg, flags);
+}
+
diff --git a/arch/arm/mach-clps711x/Kconfig b/arch/arm/mach-clps711x/Kconfig
index 0793dcf54f2e..0e2b641268ad 100644
--- a/arch/arm/mach-clps711x/Kconfig
+++ b/arch/arm/mach-clps711x/Kconfig
@@ -24,6 +24,8 @@ config ARCH_CEIVA
 
 config ARCH_CLEP7312
         bool "CLEP7312"
+        help
+          Boards based on the Cirrus Logic 7212/7312 chips.
 
 config ARCH_EDB7211
         bool "EDB7211"
diff --git a/arch/arm/mach-imx/mx1ads.c b/arch/arm/mach-imx/mx1ads.c
index dc31e3fd6c57..8ab1b040288c 100644
--- a/arch/arm/mach-imx/mx1ads.c
+++ b/arch/arm/mach-imx/mx1ads.c
@@ -27,7 +27,6 @@
 #include <asm/mach/arch.h>
 #include <linux/interrupt.h>
 #include "generic.h"
-#include <asm/serial.h>
 
 static struct resource cs89x0_resources[] = {
         [0] = {
diff --git a/arch/arm/mach-integrator/integrator_cp.c b/arch/arm/mach-integrator/integrator_cp.c
index 31820170f306..a0724f2b24ce 100644
--- a/arch/arm/mach-integrator/integrator_cp.c
+++ b/arch/arm/mach-integrator/integrator_cp.c
@@ -469,7 +469,9 @@ static void cp_clcd_enable(struct clcd_fb *fb)
         if (fb->fb.var.bits_per_pixel <= 8)
                 val = CM_CTRL_LCDMUXSEL_VGA_8421BPP;
         else if (fb->fb.var.bits_per_pixel <= 16)
-                val = CM_CTRL_LCDMUXSEL_VGA_16BPP;
+                val = CM_CTRL_LCDMUXSEL_VGA_16BPP
+                        | CM_CTRL_LCDEN0 | CM_CTRL_LCDEN1
+                        | CM_CTRL_STATIC1 | CM_CTRL_STATIC2;
         else
                 val = 0; /* no idea for this, don't trust the docs */
 
diff --git a/arch/arm/mach-ixp2000/enp2611.c b/arch/arm/mach-ixp2000/enp2611.c
index 9e5a13bb39d0..52fac89e95b5 100644
--- a/arch/arm/mach-ixp2000/enp2611.c
+++ b/arch/arm/mach-ixp2000/enp2611.c
@@ -106,6 +106,7 @@ static void __init enp2611_pci_preinit(void)
 {
         ixp2000_reg_write(IXP2000_PCI_ADDR_EXT, 0x00100000);
         ixp2000_pci_preinit();
+        pcibios_setup("firmware");
 }
 
 static inline int enp2611_pci_valid_device(struct pci_bus *bus,
diff --git a/arch/arm/mach-ixp2000/ixdp2400.c b/arch/arm/mach-ixp2000/ixdp2400.c
index 7c782403042a..09101271298e 100644
--- a/arch/arm/mach-ixp2000/ixdp2400.c
+++ b/arch/arm/mach-ixp2000/ixdp2400.c
@@ -68,6 +68,7 @@ void __init ixdp2400_pci_preinit(void)
 {
         ixp2000_reg_write(IXP2000_PCI_ADDR_EXT, 0x00100000);
         ixp2000_pci_preinit();
+        pcibios_setup("firmware");
 }
 
 int ixdp2400_pci_setup(int nr, struct pci_sys_data *sys)
diff --git a/arch/arm/mach-ixp2000/ixdp2x01.c b/arch/arm/mach-ixp2000/ixdp2x01.c
index 10f06606d460..150519fb38ec 100644
--- a/arch/arm/mach-ixp2000/ixdp2x01.c
+++ b/arch/arm/mach-ixp2000/ixdp2x01.c
@@ -212,6 +212,7 @@ void __init ixdp2x01_pci_preinit(void)
 {
         ixp2000_reg_write(IXP2000_PCI_ADDR_EXT, 0x00000000);
         ixp2000_pci_preinit();
+        pcibios_setup("firmware");
 }
 
 #define DEVPIN(dev, pin) ((pin) | ((dev) << 3))
@@ -299,7 +300,9 @@ struct hw_pci ixdp2x01_pci __initdata = {
 
 int __init ixdp2x01_pci_init(void)
 {
-        pci_common_init(&ixdp2x01_pci);
+        if (machine_is_ixdp2401() || machine_is_ixdp2801())
+                pci_common_init(&ixdp2x01_pci);
+
         return 0;
 }
 
diff --git a/arch/arm/mach-ixp4xx/common.c b/arch/arm/mach-ixp4xx/common.c
index 6b393691d0e8..4bdc9d4526cd 100644
--- a/arch/arm/mach-ixp4xx/common.c
+++ b/arch/arm/mach-ixp4xx/common.c
@@ -333,6 +333,7 @@ static struct platform_device *ixp46x_devices[] __initdata = {
 };
 
 unsigned long ixp4xx_exp_bus_size;
+EXPORT_SYMBOL(ixp4xx_exp_bus_size);
 
 void __init ixp4xx_sys_init(void)
 {
@@ -352,7 +353,7 @@ void __init ixp4xx_sys_init(void)
                 }
         }
 
-        printk("IXP4xx: Using %uMiB expansion bus window size\n",
+        printk("IXP4xx: Using %luMiB expansion bus window size\n",
                         ixp4xx_exp_bus_size >> 20);
 }
 
diff --git a/arch/arm/mach-omap1/board-generic.c b/arch/arm/mach-omap1/board-generic.c
index bdc20b51b076..a177e78b2b87 100644
--- a/arch/arm/mach-omap1/board-generic.c
+++ b/arch/arm/mach-omap1/board-generic.c
@@ -30,6 +30,7 @@
 
 static void __init omap_generic_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
 }
 
@@ -104,7 +105,7 @@ static void __init omap_generic_init(void)
 
 static void __init omap_generic_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
 }
 
 MACHINE_START(OMAP_GENERIC, "Generic OMAP1510/1610/1710")
diff --git a/arch/arm/mach-omap1/board-h2.c b/arch/arm/mach-omap1/board-h2.c
index 9533c36a92df..89f0cc74a519 100644
--- a/arch/arm/mach-omap1/board-h2.c
+++ b/arch/arm/mach-omap1/board-h2.c
@@ -128,6 +128,7 @@ static void __init h2_init_smc91x(void)
 
 static void __init h2_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
         omap_gpio_init();
         h2_init_smc91x();
@@ -194,7 +195,7 @@ static void __init h2_init(void)
 
 static void __init h2_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
 }
 
 MACHINE_START(OMAP_H2, "TI-H2")
diff --git a/arch/arm/mach-omap1/board-h3.c b/arch/arm/mach-omap1/board-h3.c
index d665efc1c344..d9f386265996 100644
--- a/arch/arm/mach-omap1/board-h3.c
+++ b/arch/arm/mach-omap1/board-h3.c
@@ -203,6 +203,7 @@ static void __init h3_init_smc91x(void)
 
 void h3_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
         omap_gpio_init();
         h3_init_smc91x();
@@ -210,7 +211,7 @@ void h3_init_irq(void)
 
 static void __init h3_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
 }
 
 MACHINE_START(OMAP_H3, "TI OMAP1710 H3 board")
diff --git a/arch/arm/mach-omap1/board-innovator.c b/arch/arm/mach-omap1/board-innovator.c
index 652f37c7f906..a04e4332915e 100644
--- a/arch/arm/mach-omap1/board-innovator.c
+++ b/arch/arm/mach-omap1/board-innovator.c
@@ -181,6 +181,7 @@ static void __init innovator_init_smc91x(void)
 
 void innovator_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
         omap_gpio_init();
 #ifdef CONFIG_ARCH_OMAP15XX
@@ -285,7 +286,7 @@ static void __init innovator_init(void)
 
 static void __init innovator_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
 
 #ifdef CONFIG_ARCH_OMAP15XX
         if (cpu_is_omap1510()) {
diff --git a/arch/arm/mach-omap1/board-netstar.c b/arch/arm/mach-omap1/board-netstar.c
index 58f783930d45..60d5f8a3339c 100644
--- a/arch/arm/mach-omap1/board-netstar.c
+++ b/arch/arm/mach-omap1/board-netstar.c
@@ -65,6 +65,7 @@ static struct omap_board_config_kernel netstar_config[] = {
 
 static void __init netstar_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
         omap_gpio_init();
 }
@@ -108,7 +109,7 @@ static void __init netstar_init(void)
 
 static void __init netstar_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
 }
 
 #define MACHINE_PANICED         1
diff --git a/arch/arm/mach-omap1/board-osk.c b/arch/arm/mach-omap1/board-osk.c
index e5d126e8f276..543fa136106d 100644
--- a/arch/arm/mach-omap1/board-osk.c
+++ b/arch/arm/mach-omap1/board-osk.c
@@ -169,6 +169,7 @@ static void __init osk_init_cf(void)
 
 static void __init osk_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
         omap_gpio_init();
         osk_init_smc91x();
@@ -269,7 +270,7 @@ static void __init osk_init(void)
 
 static void __init osk_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
 }
 
 MACHINE_START(OMAP_OSK, "TI-OSK")
diff --git a/arch/arm/mach-omap1/board-palmte.c b/arch/arm/mach-omap1/board-palmte.c
index 67fada207622..e488f7236775 100644
--- a/arch/arm/mach-omap1/board-palmte.c
+++ b/arch/arm/mach-omap1/board-palmte.c
@@ -34,6 +34,7 @@
 
 static void __init omap_generic_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
 }
 
@@ -72,7 +73,7 @@ static void __init omap_generic_init(void)
 
 static void __init omap_generic_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
 }
 
 MACHINE_START(OMAP_PALMTE, "OMAP310 based Palm Tungsten E")
diff --git a/arch/arm/mach-omap1/board-perseus2.c b/arch/arm/mach-omap1/board-perseus2.c
index 88708a0c52a2..3913a3cc0ce6 100644
--- a/arch/arm/mach-omap1/board-perseus2.c
+++ b/arch/arm/mach-omap1/board-perseus2.c
@@ -144,6 +144,7 @@ static void __init perseus2_init_smc91x(void)
 
 void omap_perseus2_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
         omap_gpio_init();
         perseus2_init_smc91x();
@@ -160,7 +161,7 @@ static struct map_desc omap_perseus2_io_desc[] __initdata = {
 
 static void __init omap_perseus2_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
         iotable_init(omap_perseus2_io_desc,
                      ARRAY_SIZE(omap_perseus2_io_desc));
 
diff --git a/arch/arm/mach-omap1/board-voiceblue.c b/arch/arm/mach-omap1/board-voiceblue.c
index 959b4b847c87..bfd5fdd1a875 100644
--- a/arch/arm/mach-omap1/board-voiceblue.c
+++ b/arch/arm/mach-omap1/board-voiceblue.c
@@ -162,6 +162,7 @@ static struct omap_board_config_kernel voiceblue_config[] = {
 
 static void __init voiceblue_init_irq(void)
 {
+        omap1_init_common_hw();
         omap_init_irq();
         omap_gpio_init();
 }
@@ -206,7 +207,7 @@ static void __init voiceblue_init(void)
 
 static void __init voiceblue_map_io(void)
 {
-        omap_map_common_io();
+        omap1_map_common_io();
 }
 
 #define MACHINE_PANICED         1
diff --git a/arch/arm/mach-omap1/clock.c b/arch/arm/mach-omap1/clock.c
index 9d862f86bba6..75110ba10424 100644
--- a/arch/arm/mach-omap1/clock.c
+++ b/arch/arm/mach-omap1/clock.c
@@ -50,10 +50,10 @@ static int omap1_clk_enable_dsp_domain(struct clk *clk)
 {
         int retval;
 
-        retval = omap1_clk_use(&api_ck.clk);
+        retval = omap1_clk_enable(&api_ck.clk);
         if (!retval) {
-                retval = omap1_clk_enable(clk);
-                omap1_clk_unuse(&api_ck.clk);
+                retval = omap1_clk_enable_generic(clk);
+                omap1_clk_disable(&api_ck.clk);
         }
 
         return retval;
@@ -61,9 +61,9 @@ static int omap1_clk_enable_dsp_domain(struct clk *clk)
 
 static void omap1_clk_disable_dsp_domain(struct clk *clk)
 {
-        if (omap1_clk_use(&api_ck.clk) == 0) {
-                omap1_clk_disable(clk);
-                omap1_clk_unuse(&api_ck.clk);
+        if (omap1_clk_enable(&api_ck.clk) == 0) {
+                omap1_clk_disable_generic(clk);
+                omap1_clk_disable(&api_ck.clk);
         }
 }
 
@@ -72,7 +72,7 @@ static int omap1_clk_enable_uart_functional(struct clk *clk)
         int ret;
         struct uart_clk *uclk;
 
-        ret = omap1_clk_enable(clk);
+        ret = omap1_clk_enable_generic(clk);
         if (ret == 0) {
                 /* Set smart idle acknowledgement mode */
                 uclk = (struct uart_clk *)clk;
@@ -91,7 +91,7 @@ static void omap1_clk_disable_uart_functional(struct clk *clk)
         uclk = (struct uart_clk *)clk;
         omap_writeb((omap_readb(uclk->sysc_addr) & ~0x18), uclk->sysc_addr);
 
-        omap1_clk_disable(clk);
+        omap1_clk_disable_generic(clk);
 }
 
 static void omap1_clk_allow_idle(struct clk *clk)
@@ -230,9 +230,9 @@ static void omap1_ckctl_recalc_dsp_domain(struct clk * clk)
          * Note that DSP_CKCTL virt addr = phys addr, so
          * we must use __raw_readw() instead of omap_readw().
          */
-        omap1_clk_use(&api_ck.clk);
+        omap1_clk_enable(&api_ck.clk);
         dsor = 1 << (3 & (__raw_readw(DSP_CKCTL) >> clk->rate_offset));
-        omap1_clk_unuse(&api_ck.clk);
+        omap1_clk_disable(&api_ck.clk);
 
         if (unlikely(clk->rate == clk->parent->rate / dsor))
                 return; /* No change, quick exit */
@@ -412,12 +412,12 @@ static void omap1_init_ext_clk(struct clk * clk)
         clk-> rate = 96000000 / dsor;
 }
 
-static int omap1_clk_use(struct clk *clk)
+static int omap1_clk_enable(struct clk *clk)
 {
         int ret = 0;
         if (clk->usecount++ == 0) {
                 if (likely(clk->parent)) {
-                        ret = omap1_clk_use(clk->parent);
+                        ret = omap1_clk_enable(clk->parent);
 
                         if (unlikely(ret != 0)) {
                                 clk->usecount--;
@@ -432,7 +432,7 @@ static int omap1_clk_use(struct clk *clk)
                 ret = clk->enable(clk);
 
                 if (unlikely(ret != 0) && clk->parent) {
-                        omap1_clk_unuse(clk->parent);
+                        omap1_clk_disable(clk->parent);
                         clk->usecount--;
                 }
         }
@@ -440,12 +440,12 @@ static int omap1_clk_use(struct clk *clk)
         return ret;
 }
 
-static void omap1_clk_unuse(struct clk *clk)
+static void omap1_clk_disable(struct clk *clk)
 {
         if (clk->usecount > 0 && !(--clk->usecount)) {
                 clk->disable(clk);
                 if (likely(clk->parent)) {
-                        omap1_clk_unuse(clk->parent);
+                        omap1_clk_disable(clk->parent);
                         if (clk->flags & CLOCK_NO_IDLE_PARENT)
                                 if (!cpu_is_omap24xx())
                                         omap1_clk_allow_idle(clk->parent);
@@ -453,7 +453,7 @@ static void omap1_clk_unuse(struct clk *clk)
         }
 }
 
-static int omap1_clk_enable(struct clk *clk)
+static int omap1_clk_enable_generic(struct clk *clk)
 {
         __u16 regval16;
         __u32 regval32;
@@ -492,7 +492,7 @@ static int omap1_clk_enable(struct clk *clk)
         return 0;
 }
 
-static void omap1_clk_disable(struct clk *clk)
+static void omap1_clk_disable_generic(struct clk *clk)
 {
         __u16 regval16;
         __u32 regval32;
@@ -654,8 +654,8 @@ late_initcall(omap1_late_clk_reset);
 #endif
 
 static struct clk_functions omap1_clk_functions = {
-        .clk_use                = omap1_clk_use,
-        .clk_unuse              = omap1_clk_unuse,
+        .clk_enable             = omap1_clk_enable,
+        .clk_disable            = omap1_clk_disable,
         .clk_round_rate         = omap1_clk_round_rate,
         .clk_set_rate           = omap1_clk_set_rate,
 };
@@ -780,9 +780,9 @@ int __init omap1_clk_init(void)
          * Only enable those clocks we will need, let the drivers
          * enable other clocks as necessary
          */
-        clk_use(&armper_ck.clk);
-        clk_use(&armxor_ck.clk);
-        clk_use(&armtim_ck.clk); /* This should be done by timer code */
+        clk_enable(&armper_ck.clk);
+        clk_enable(&armxor_ck.clk);
+        clk_enable(&armtim_ck.clk); /* This should be done by timer code */
 
         if (cpu_is_omap1510())
                 clk_enable(&arm_gpio_ck);
diff --git a/arch/arm/mach-omap1/clock.h b/arch/arm/mach-omap1/clock.h
index f3bdfb50e01a..4f18d1b94449 100644
--- a/arch/arm/mach-omap1/clock.h
+++ b/arch/arm/mach-omap1/clock.h
@@ -13,8 +13,8 @@
 #ifndef __ARCH_ARM_MACH_OMAP1_CLOCK_H
 #define __ARCH_ARM_MACH_OMAP1_CLOCK_H
 
-static int omap1_clk_enable(struct clk * clk);
-static void omap1_clk_disable(struct clk * clk);
+static int omap1_clk_enable_generic(struct clk * clk);
+static void omap1_clk_disable_generic(struct clk * clk);
 static void omap1_ckctl_recalc(struct clk * clk);
 static void omap1_watchdog_recalc(struct clk * clk);
 static void omap1_ckctl_recalc_dsp_domain(struct clk * clk);
@@ -30,8 +30,8 @@ static long omap1_round_ext_clk_rate(struct clk * clk, unsigned long rate);
 static void omap1_init_ext_clk(struct clk * clk);
 static int omap1_select_table_rate(struct clk * clk, unsigned long rate);
 static long omap1_round_to_table_rate(struct clk * clk, unsigned long rate);
-static int omap1_clk_use(struct clk *clk);
-static void omap1_clk_unuse(struct clk *clk);
+static int omap1_clk_enable(struct clk *clk);
+static void omap1_clk_disable(struct clk *clk);
 
 struct mpu_rate {
         unsigned long           rate;
@@ -152,8 +152,8 @@ static struct clk ck_ref = {
         .rate           = 12000000,
         .flags          = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
                           ALWAYS_ENABLED,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk ck_dpll1 = {
@@ -161,8 +161,8 @@ static struct clk ck_dpll1 = {
         .parent         = &ck_ref,
         .flags          = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
                           RATE_PROPAGATES | ALWAYS_ENABLED,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct arm_idlect1_clk ck_dpll1out = {
@@ -173,8 +173,8 @@ static struct arm_idlect1_clk ck_dpll1out = {
                 .enable_reg     = (void __iomem *)ARM_IDLECT2,
                 .enable_bit     = EN_CKOUT_ARM,
                 .recalc         = &followparent_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 12,
 };
@@ -186,8 +186,8 @@ static struct clk arm_ck = {
                           RATE_CKCTL | RATE_PROPAGATES | ALWAYS_ENABLED,
         .rate_offset    = CKCTL_ARMDIV_OFFSET,
         .recalc         = &omap1_ckctl_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct arm_idlect1_clk armper_ck = {
@@ -200,8 +200,8 @@ static struct arm_idlect1_clk armper_ck = {
                 .enable_bit     = EN_PERCK,
                 .rate_offset    = CKCTL_PERDIV_OFFSET,
                 .recalc         = &omap1_ckctl_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 2,
 };
@@ -213,8 +213,8 @@ static struct clk arm_gpio_ck = {
         .enable_reg     = (void __iomem *)ARM_IDLECT2,
         .enable_bit     = EN_GPIOCK,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct arm_idlect1_clk armxor_ck = {
@@ -226,8 +226,8 @@ static struct arm_idlect1_clk armxor_ck = {
                 .enable_reg     = (void __iomem *)ARM_IDLECT2,
                 .enable_bit     = EN_XORPCK,
                 .recalc         = &followparent_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 1,
 };
@@ -241,8 +241,8 @@ static struct arm_idlect1_clk armtim_ck = {
                 .enable_reg     = (void __iomem *)ARM_IDLECT2,
                 .enable_bit     = EN_TIMCK,
                 .recalc         = &followparent_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 9,
 };
@@ -256,8 +256,8 @@ static struct arm_idlect1_clk armwdt_ck = {
                 .enable_reg     = (void __iomem *)ARM_IDLECT2,
                 .enable_bit     = EN_WDTCK,
                 .recalc         = &omap1_watchdog_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 0,
 };
@@ -272,8 +272,8 @@ static struct clk arminth_ck16xx = {
          *
          * 1510 version is in TC clocks.
          */
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk dsp_ck = {
@@ -285,8 +285,8 @@ static struct clk dsp_ck = {
         .enable_bit     = EN_DSPCK,
         .rate_offset    = CKCTL_DSPDIV_OFFSET,
         .recalc         = &omap1_ckctl_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk dspmmu_ck = {
@@ -296,8 +296,8 @@ static struct clk dspmmu_ck = {
                           RATE_CKCTL | ALWAYS_ENABLED,
         .rate_offset    = CKCTL_DSPMMUDIV_OFFSET,
         .recalc         = &omap1_ckctl_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk dspper_ck = {
@@ -349,8 +349,8 @@ static struct arm_idlect1_clk tc_ck = {
                                   CLOCK_IDLE_CONTROL,
                 .rate_offset    = CKCTL_TCDIV_OFFSET,
                 .recalc         = &omap1_ckctl_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 6,
 };
@@ -364,8 +364,8 @@ static struct clk arminth_ck1510 = {
          *
          * 16xx version is in MPU clocks.
          */
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk tipb_ck = {
@@ -374,8 +374,8 @@ static struct clk tipb_ck = {
         .parent         = &tc_ck.clk,
         .flags          = CLOCK_IN_OMAP1510 | ALWAYS_ENABLED,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk l3_ocpi_ck = {
@@ -386,8 +386,8 @@ static struct clk l3_ocpi_ck = {
         .enable_reg     = (void __iomem *)ARM_IDLECT3,
         .enable_bit     = EN_OCPI_CK,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk tc1_ck = {
@@ -397,8 +397,8 @@ static struct clk tc1_ck = {
         .enable_reg     = (void __iomem *)ARM_IDLECT3,
         .enable_bit     = EN_TC1_CK,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk tc2_ck = {
@@ -408,8 +408,8 @@ static struct clk tc2_ck = {
         .enable_reg     = (void __iomem *)ARM_IDLECT3,
         .enable_bit     = EN_TC2_CK,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk dma_ck = {
@@ -419,8 +419,8 @@ static struct clk dma_ck = {
         .flags          = CLOCK_IN_OMAP1510 | CLOCK_IN_OMAP16XX |
                           ALWAYS_ENABLED,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk dma_lcdfree_ck = {
@@ -428,8 +428,8 @@ static struct clk dma_lcdfree_ck = {
         .parent         = &tc_ck.clk,
         .flags          = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct arm_idlect1_clk api_ck = {
@@ -441,8 +441,8 @@ static struct arm_idlect1_clk api_ck = {
                 .enable_reg     = (void __iomem *)ARM_IDLECT2,
                 .enable_bit     = EN_APICK,
                 .recalc         = &followparent_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 8,
 };
@@ -455,8 +455,8 @@ static struct arm_idlect1_clk lb_ck = {
                 .enable_reg     = (void __iomem *)ARM_IDLECT2,
                 .enable_bit     = EN_LBCK,
                 .recalc         = &followparent_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 4,
 };
@@ -466,8 +466,8 @@ static struct clk rhea1_ck = {
         .parent         = &tc_ck.clk,
         .flags          = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk rhea2_ck = {
@@ -475,8 +475,8 @@ static struct clk rhea2_ck = {
         .parent         = &tc_ck.clk,
         .flags          = CLOCK_IN_OMAP16XX | ALWAYS_ENABLED,
         .recalc         = &followparent_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk lcd_ck_16xx = {
@@ -487,8 +487,8 @@ static struct clk lcd_ck_16xx = {
         .enable_bit     = EN_LCDCK,
         .rate_offset    = CKCTL_LCDDIV_OFFSET,
         .recalc         = &omap1_ckctl_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct arm_idlect1_clk lcd_ck_1510 = {
@@ -501,8 +501,8 @@ static struct arm_idlect1_clk lcd_ck_1510 = {
                 .enable_bit     = EN_LCDCK,
                 .rate_offset    = CKCTL_LCDDIV_OFFSET,
                 .recalc         = &omap1_ckctl_recalc,
-                .enable         = &omap1_clk_enable,
-                .disable        = &omap1_clk_disable,
+                .enable         = &omap1_clk_enable_generic,
+                .disable        = &omap1_clk_disable_generic,
         },
         .idlect_shift   = 3,
 };
@@ -518,8 +518,8 @@ static struct clk uart1_1510 = {
         .enable_bit     = 29,   /* Chooses between 12MHz and 48MHz */
         .set_rate       = &omap1_set_uart_rate,
         .recalc         = &omap1_uart_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct uart_clk uart1_16xx = {
@@ -550,8 +550,8 @@ static struct clk uart2_ck = {
         .enable_bit     = 30,   /* Chooses between 12MHz and 48MHz */
         .set_rate       = &omap1_set_uart_rate,
         .recalc         = &omap1_uart_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk uart3_1510 = {
@@ -565,8 +565,8 @@ static struct clk uart3_1510 = {
         .enable_bit     = 31,   /* Chooses between 12MHz and 48MHz */
         .set_rate       = &omap1_set_uart_rate,
         .recalc         = &omap1_uart_recalc,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct uart_clk uart3_16xx = {
@@ -593,8 +593,8 @@ static struct clk usb_clko = {	/* 6 MHz output on W4_USB_CLKO */
                           RATE_FIXED | ENABLE_REG_32BIT,
         .enable_reg     = (void __iomem *)ULPD_CLOCK_CTRL,
         .enable_bit     = USB_MCLK_EN_BIT,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk usb_hhc_ck1510 = {
@@ -605,8 +605,8 @@ static struct clk usb_hhc_ck1510 = {
                           RATE_FIXED | ENABLE_REG_32BIT,
         .enable_reg     = (void __iomem *)MOD_CONF_CTRL_0,
         .enable_bit     = USB_HOST_HHC_UHOST_EN,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk usb_hhc_ck16xx = {
@@ -618,8 +618,8 @@ static struct clk usb_hhc_ck16xx = {
                           RATE_FIXED | ENABLE_REG_32BIT,
         .enable_reg     = (void __iomem *)OTG_BASE + 0x08 /* OTG_SYSCON_2 */,
         .enable_bit     = 8 /* UHOST_EN */,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk usb_dc_ck = {
@@ -629,8 +629,8 @@ static struct clk usb_dc_ck = {
         .flags          = CLOCK_IN_OMAP16XX | RATE_FIXED,
         .enable_reg     = (void __iomem *)SOFT_REQ_REG,
         .enable_bit     = 4,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk mclk_1510 = {
@@ -638,8 +638,8 @@ static struct clk mclk_1510 = {
         /* Direct from ULPD, no parent. May be enabled by ext hardware. */
         .rate           = 12000000,
         .flags          = CLOCK_IN_OMAP1510 | RATE_FIXED,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk mclk_16xx = {
@@ -651,8 +651,8 @@ static struct clk mclk_16xx = {
         .set_rate       = &omap1_set_ext_clk_rate,
         .round_rate     = &omap1_round_ext_clk_rate,
         .init           = &omap1_init_ext_clk,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk bclk_1510 = {
@@ -660,8 +660,8 @@ static struct clk bclk_1510 = {
         /* Direct from ULPD, no parent. May be enabled by ext hardware. */
         .rate           = 12000000,
         .flags          = CLOCK_IN_OMAP1510 | RATE_FIXED,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk bclk_16xx = {
@@ -673,8 +673,8 @@ static struct clk bclk_16xx = {
         .set_rate       = &omap1_set_ext_clk_rate,
         .round_rate     = &omap1_round_ext_clk_rate,
         .init           = &omap1_init_ext_clk,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk mmc1_ck = {
@@ -686,8 +686,8 @@ static struct clk mmc1_ck = {
                           RATE_FIXED | ENABLE_REG_32BIT | CLOCK_NO_IDLE_PARENT,
         .enable_reg     = (void __iomem *)MOD_CONF_CTRL_0,
         .enable_bit     = 23,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk mmc2_ck = {
@@ -699,8 +699,8 @@ static struct clk mmc2_ck = {
                           RATE_FIXED | ENABLE_REG_32BIT | CLOCK_NO_IDLE_PARENT,
         .enable_reg     = (void __iomem *)MOD_CONF_CTRL_0,
         .enable_bit     = 20,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk virtual_ck_mpu = {
@@ -711,8 +711,8 @@ static struct clk virtual_ck_mpu = {
         .recalc         = &followparent_recalc,
         .set_rate       = &omap1_select_table_rate,
         .round_rate     = &omap1_round_to_table_rate,
-        .enable         = &omap1_clk_enable,
-        .disable        = &omap1_clk_disable,
+        .enable         = &omap1_clk_enable_generic,
+        .disable        = &omap1_clk_disable_generic,
 };
 
 static struct clk * onchip_clks[] = {
diff --git a/arch/arm/mach-omap1/io.c b/arch/arm/mach-omap1/io.c
index a7a19f75b9e1..82d556be79c5 100644
--- a/arch/arm/mach-omap1/io.c
+++ b/arch/arm/mach-omap1/io.c
@@ -13,6 +13,7 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 
+#include <asm/tlb.h>
 #include <asm/mach/map.h>
 #include <asm/io.h>
 #include <asm/arch/mux.h>
@@ -83,15 +84,24 @@ static struct map_desc omap16xx_io_desc[] __initdata = {
 };
 #endif
 
-static int initialized = 0;
-
-static void __init _omap_map_io(void)
+/*
+ * Maps common IO regions for omap1. This should only get called from
+ * board specific init.
+ */
+void __init omap1_map_common_io(void)
 {
-        initialized = 1;
-
-        /* We have to initialize the IO space mapping before we can run
-         * cpu_is_omapxxx() macros. */
         iotable_init(omap_io_desc, ARRAY_SIZE(omap_io_desc));
+
+        /* Normally devicemaps_init() would flush caches and tlb after
+         * mdesc->map_io(), but we must also do it here because of the CPU
+         * revision check below.
+         */
+        local_flush_tlb_all();
+        flush_cache_all();
+
+        /* We want to check CPU revision early for cpu_is_omapxxxx() macros.
+         * IO space mapping must be initialized before we can do that.
+         */
         omap_check_revision();
 
 #ifdef CONFIG_ARCH_OMAP730
@@ -111,7 +121,14 @@ static void __init _omap_map_io(void)
 #endif
 
         omap_sram_init();
+}
 
+/*
+ * Common low-level hardware init for omap1. This should only get called from
+ * board specific init.
+ */
+void __init omap1_init_common_hw()
+{
         /* REVISIT: Refer to OMAP5910 Errata, Advisory SYS_1: "Timeout Abort
          * on a Posted Write in the TIPB Bridge".
          */
@@ -121,16 +138,7 @@ static void __init _omap_map_io(void)
         /* Must init clocks early to assure that timer interrupt works
          */
         omap1_clk_init();
-}
 
-/*
- * This should only get called from board specific init
- */
-void __init omap_map_common_io(void)
-{
-        if (!initialized) {
-                _omap_map_io();
-                omap1_mux_init();
-        }
+        omap1_mux_init();
 }
 
diff --git a/arch/arm/mach-omap1/serial.c b/arch/arm/mach-omap1/serial.c
index 7a68f098a025..e924e0c6a4ce 100644
--- a/arch/arm/mach-omap1/serial.c
+++ b/arch/arm/mach-omap1/serial.c
@@ -146,7 +146,7 @@ void __init omap_serial_init(void)
                         if (IS_ERR(uart1_ck))
                                 printk("Could not get uart1_ck\n");
                         else {
-                                clk_use(uart1_ck);
+                                clk_enable(uart1_ck);
                                 if (cpu_is_omap1510())
                                         clk_set_rate(uart1_ck, 12000000);
                         }
@@ -166,7 +166,7 @@ void __init omap_serial_init(void)
                         if (IS_ERR(uart2_ck))
                                 printk("Could not get uart2_ck\n");
                         else {
-                                clk_use(uart2_ck);
+                                clk_enable(uart2_ck);
                                 if (cpu_is_omap1510())
                                         clk_set_rate(uart2_ck, 12000000);
                                 else
@@ -188,7 +188,7 @@ void __init omap_serial_init(void)
                         if (IS_ERR(uart3_ck))
                                 printk("Could not get uart3_ck\n");
                         else {
-                                clk_use(uart3_ck);
+                                clk_enable(uart3_ck);
                                 if (cpu_is_omap1510())
                                         clk_set_rate(uart3_ck, 12000000);
                         }
diff --git a/arch/arm/mach-omap2/board-generic.c b/arch/arm/mach-omap2/board-generic.c
index b937123e5c65..eaecbf422d8c 100644
--- a/arch/arm/mach-omap2/board-generic.c
+++ b/arch/arm/mach-omap2/board-generic.c
@@ -33,6 +33,7 @@
 
 static void __init omap_generic_init_irq(void)
 {
+        omap2_init_common_hw();
         omap_init_irq();
 }
 
@@ -64,7 +65,7 @@ static void __init omap_generic_init(void)
 
 static void __init omap_generic_map_io(void)
 {
-        omap_map_common_io();
+        omap2_map_common_io();
 }
 
 MACHINE_START(OMAP_GENERIC, "Generic OMAP24xx")
diff --git a/arch/arm/mach-omap2/board-h4.c b/arch/arm/mach-omap2/board-h4.c
index c3c35d40378a..a300d634d8a5 100644
--- a/arch/arm/mach-omap2/board-h4.c
+++ b/arch/arm/mach-omap2/board-h4.c
@@ -136,6 +136,7 @@ static inline void __init h4_init_smc91x(void)
 
 static void __init omap_h4_init_irq(void)
 {
+        omap2_init_common_hw();
         omap_init_irq();
         omap_gpio_init();
         h4_init_smc91x();
@@ -181,7 +182,7 @@ static void __init omap_h4_init(void)
 
 static void __init omap_h4_map_io(void)
 {
-        omap_map_common_io();
+        omap2_map_common_io();
 }
 
 MACHINE_START(OMAP_H4, "OMAP2420 H4 board")
diff --git a/arch/arm/mach-omap2/clock.c b/arch/arm/mach-omap2/clock.c
index 5407b9549150..180f675c9064 100644
--- a/arch/arm/mach-omap2/clock.c
+++ b/arch/arm/mach-omap2/clock.c
@@ -111,7 +111,7 @@ static void omap2_clk_fixed_enable(struct clk *clk)
 /* Enables clock without considering parent dependencies or use count
  * REVISIT: Maybe change this to use clk->enable like on omap1?
  */
-static int omap2_clk_enable(struct clk * clk)
+static int _omap2_clk_enable(struct clk * clk)
 {
         u32 regval32;
 
@@ -150,7 +150,7 @@ static void omap2_clk_fixed_disable(struct clk *clk)
 }
 
 /* Disables clock without considering parent dependencies or use count */
-static void omap2_clk_disable(struct clk *clk)
+static void _omap2_clk_disable(struct clk *clk)
 {
         u32 regval32;
 
@@ -167,23 +167,23 @@ static void omap2_clk_disable(struct clk *clk)
         __raw_writel(regval32, clk->enable_reg);
 }
 
-static int omap2_clk_use(struct clk *clk)
+static int omap2_clk_enable(struct clk *clk)
 {
         int ret = 0;
 
         if (clk->usecount++ == 0) {
                 if (likely((u32)clk->parent))
-                        ret = omap2_clk_use(clk->parent);
+                        ret = omap2_clk_enable(clk->parent);
 
                 if (unlikely(ret != 0)) {
                         clk->usecount--;
                         return ret;
                 }
 
-                ret = omap2_clk_enable(clk);
+                ret = _omap2_clk_enable(clk);
 
                 if (unlikely(ret != 0) && clk->parent) {
-                        omap2_clk_unuse(clk->parent);
+                        omap2_clk_disable(clk->parent);
                         clk->usecount--;
                 }
         }
@@ -191,12 +191,12 @@ static int omap2_clk_use(struct clk *clk)
         return ret;
 }
 
-static void omap2_clk_unuse(struct clk *clk)
+static void omap2_clk_disable(struct clk *clk)
 {
         if (clk->usecount > 0 && !(--clk->usecount)) {
-                omap2_clk_disable(clk);
+                _omap2_clk_disable(clk);
                 if (likely((u32)clk->parent))
-                        omap2_clk_unuse(clk->parent);
+                        omap2_clk_disable(clk->parent);
         }
 }
 
@@ -873,7 +873,7 @@ static int omap2_clk_set_parent(struct clk *clk, struct clk *new_parent)
                 reg = (void __iomem *)src_sel;
 
                 if (clk->usecount > 0)
-                        omap2_clk_disable(clk);
+                        _omap2_clk_disable(clk);
 
                 /* Set new source value (previous dividers if any in effect) */
                 reg_val = __raw_readl(reg) & ~(field_mask << src_off);
@@ -884,7 +884,7 @@ static int omap2_clk_set_parent(struct clk *clk, struct clk *new_parent)
                         __raw_writel(0x1, (void __iomem *)&PRCM_CLKCFG_CTRL);
 
                 if (clk->usecount > 0)
-                        omap2_clk_enable(clk);
+                        _omap2_clk_enable(clk);
 
                 clk->parent = new_parent;
 
@@ -999,8 +999,6 @@ static int omap2_select_table_rate(struct clk * clk, unsigned long rate)
 static struct clk_functions omap2_clk_functions = {
         .clk_enable             = omap2_clk_enable,
         .clk_disable            = omap2_clk_disable,
-        .clk_use                = omap2_clk_use,
-        .clk_unuse              = omap2_clk_unuse,
         .clk_round_rate         = omap2_clk_round_rate,
         .clk_set_rate           = omap2_clk_set_rate,
         .clk_set_parent         = omap2_clk_set_parent,
@@ -1045,7 +1043,7 @@ static void __init omap2_disable_unused_clocks(void)
                         continue;
 
                 printk(KERN_INFO "Disabling unused clock \"%s\"\n", ck->name);
-                omap2_clk_disable(ck);
+                _omap2_clk_disable(ck);
         }
 }
 late_initcall(omap2_disable_unused_clocks);
@@ -1120,10 +1118,10 @@ int __init omap2_clk_init(void)
          * Only enable those clocks we will need, let the drivers
          * enable other clocks as necessary
          */
-        clk_use(&sync_32k_ick);
-        clk_use(&omapctrl_ick);
+        clk_enable(&sync_32k_ick);
+        clk_enable(&omapctrl_ick);
         if (cpu_is_omap2430())
-                clk_use(&sdrc_ick);
+                clk_enable(&sdrc_ick);
 
         return 0;
 }
diff --git a/arch/arm/mach-omap2/clock.h b/arch/arm/mach-omap2/clock.h
index 4aeab5591bd3..6cab20b1d3c1 100644
--- a/arch/arm/mach-omap2/clock.h
+++ b/arch/arm/mach-omap2/clock.h
@@ -24,7 +24,7 @@ static void omap2_propagate_rate(struct clk * clk);
 static void omap2_mpu_recalc(struct clk * clk);
 static int omap2_select_table_rate(struct clk * clk, unsigned long rate);
 static long omap2_round_to_table_rate(struct clk * clk, unsigned long rate);
-static void omap2_clk_unuse(struct clk *clk);
+static void omap2_clk_disable(struct clk *clk);
 static void omap2_sys_clk_recalc(struct clk * clk);
 static u32 omap2_clksel_to_divisor(u32 div_sel, u32 field_val);
 static u32 omap2_clksel_get_divisor(struct clk *clk);
@@ -859,7 +859,7 @@ static struct clk core_l3_ck = {	/* Used for ick and fck, interconnect */
 
 static struct clk usb_l4_ick = {        /* FS-USB interface clock */
         .name           = "usb_l4_ick",
-        .parent         = &core_ck,
+        .parent         = &core_l3_ck,
         .flags          = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X |
                                 RATE_CKCTL | CM_CORE_SEL1 | DELAYED_APP |
                                 CONFIG_PARTICIPANT,
@@ -1045,7 +1045,7 @@ static struct clk gpt1_ick = {
         .name           = "gpt1_ick",
         .parent         = &l4_ck,
         .flags          = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
-        .enable_reg     = (void __iomem *)&CM_ICLKEN_WKUP,      /* Bit4 */
+        .enable_reg     = (void __iomem *)&CM_ICLKEN_WKUP,      /* Bit0 */
         .enable_bit     = 0,
         .recalc         = &omap2_followparent_recalc,
 };
@@ -1055,7 +1055,7 @@ static struct clk gpt1_fck = {
         .parent         = &func_32k_ck,
         .flags          = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X |
                                 CM_WKUP_SEL1,
-        .enable_reg     = (void __iomem *)&CM_FCLKEN_WKUP,
+        .enable_reg     = (void __iomem *)&CM_FCLKEN_WKUP,      /* Bit0 */
         .enable_bit     = 0,
         .src_offset     = 0,
         .recalc         = &omap2_followparent_recalc,
@@ -1065,7 +1065,7 @@ static struct clk gpt2_ick = {
         .name           = "gpt2_ick",
         .parent         = &l4_ck,
         .flags          = CLOCK_IN_OMAP242X | CLOCK_IN_OMAP243X,
-        .enable_reg     = (void __iomem *)&CM_ICLKEN1_CORE,     /* bit4 */
+        .enable_reg     = (void __iomem *)&CM_ICLKEN1_CORE,     /* Bit4 */
         .enable_bit     = 0,
         .recalc         = &omap2_followparent_recalc,
 };
@@ -1839,7 +1839,7 @@ static struct clk usb_fck = {
 
 static struct clk usbhs_ick = {
         .name           = "usbhs_ick",
-        .parent         = &l4_ck,
+        .parent         = &core_l3_ck,
         .flags          = CLOCK_IN_OMAP243X,
         .enable_reg     = (void __iomem *)&CM_ICLKEN2_CORE,
         .enable_bit     = 6,
diff --git a/arch/arm/mach-omap2/serial.c b/arch/arm/mach-omap2/serial.c
index e1bd46a96e11..24dd374224af 100644
--- a/arch/arm/mach-omap2/serial.c
+++ b/arch/arm/mach-omap2/serial.c
@@ -119,14 +119,14 @@ void __init omap_serial_init()
                         if (IS_ERR(uart1_ick))
                                 printk("Could not get uart1_ick\n");
                         else {
-                                clk_use(uart1_ick);
+                                clk_enable(uart1_ick);
                         }
 
                         uart1_fck = clk_get(NULL, "uart1_fck");
                         if (IS_ERR(uart1_fck))
                                 printk("Could not get uart1_fck\n");
                         else {
-                                clk_use(uart1_fck);
+                                clk_enable(uart1_fck);
                         }
                         break;
                 case 1:
@@ -134,14 +134,14 @@ void __init omap_serial_init()
                         if (IS_ERR(uart2_ick))
                                 printk("Could not get uart2_ick\n");
                         else {
-                                clk_use(uart2_ick);
+                                clk_enable(uart2_ick);
                         }
 
                         uart2_fck = clk_get(NULL, "uart2_fck");
                         if (IS_ERR(uart2_fck))
                                 printk("Could not get uart2_fck\n");
                         else {
-                                clk_use(uart2_fck);
+                                clk_enable(uart2_fck);
                         }
                         break;
                 case 2:
@@ -149,14 +149,14 @@ void __init omap_serial_init()
                         if (IS_ERR(uart3_ick))
                                 printk("Could not get uart3_ick\n");
                         else {
-                                clk_use(uart3_ick);
+                                clk_enable(uart3_ick);
                         }
 
                         uart3_fck = clk_get(NULL, "uart3_fck");
                         if (IS_ERR(uart3_fck))
                                 printk("Could not get uart3_fck\n");
                         else {
-                                clk_use(uart3_fck);
+                                clk_enable(uart3_fck);
                         }
                         break;
                 }
diff --git a/arch/arm/mach-omap2/timer-gp.c b/arch/arm/mach-omap2/timer-gp.c
index 23d36b1c40fe..1d2f5ac2f69b 100644
--- a/arch/arm/mach-omap2/timer-gp.c
+++ b/arch/arm/mach-omap2/timer-gp.c
@@ -104,7 +104,7 @@ static void __init omap2_gp_timer_init(void)
         if (IS_ERR(sys_ck))
                 printk(KERN_ERR "Could not get sys_ck\n");
         else {
-                clk_use(sys_ck);
+                clk_enable(sys_ck);
                 tick_period = clk_get_rate(sys_ck) / 100;
                 clk_put(sys_ck);
         }
diff --git a/arch/arm/mach-pxa/pxa27x.c b/arch/arm/mach-pxa/pxa27x.c
index b41b1efaa2cf..3baa70819f24 100644
--- a/arch/arm/mach-pxa/pxa27x.c
+++ b/arch/arm/mach-pxa/pxa27x.c
@@ -44,7 +44,7 @@ unsigned int get_clk_frequency_khz( int info)
 
         /* Read clkcfg register: it has turbo, b, half-turbo (and f) */
         asm( "mrc\tp14, 0, %0, c6, c0, 0" : "=r" (clkcfg) );
-        t  = clkcfg & (1 << 1);
+        t  = clkcfg & (1 << 0);
         ht = clkcfg & (1 << 2);
         b  = clkcfg & (1 << 3);
 
diff --git a/arch/arm/mach-realview/core.c b/arch/arm/mach-realview/core.c
index 4a222f59f2cf..4303d988c4bf 100644
--- a/arch/arm/mach-realview/core.c
+++ b/arch/arm/mach-realview/core.c
@@ -182,7 +182,7 @@ static const struct icst307_params realview_oscvco_params = {
 static void realview_oscvco_set(struct clk *clk, struct icst307_vco vco)
 {
         void __iomem *sys_lock = __io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_LOCK_OFFSET;
-        void __iomem *sys_osc = __io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_OSC1_OFFSET;
+        void __iomem *sys_osc = __io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_OSC4_OFFSET;
         u32 val;
 
         val = readl(sys_osc) & ~0x7ffff;
diff --git a/arch/arm/mach-s3c2410/Makefile b/arch/arm/mach-s3c2410/Makefile
index b4f1e051c768..1217bf00309c 100644
--- a/arch/arm/mach-s3c2410/Makefile
+++ b/arch/arm/mach-s3c2410/Makefile
@@ -10,9 +10,13 @@ obj-m			:=
 obj-n                   :=
 obj-                    :=
 
+# S3C2400 support files
+obj-$(CONFIG_CPU_S3C2400)  += s3c2400-gpio.o
+
 # S3C2410 support files
 
 obj-$(CONFIG_CPU_S3C2410)  += s3c2410.o
+obj-$(CONFIG_CPU_S3C2410)  += s3c2410-gpio.o
 obj-$(CONFIG_S3C2410_DMA)  += dma.o
 
 # Power Management support
@@ -25,6 +29,7 @@ obj-$(CONFIG_PM_SIMTEC)	   += pm-simtec.o
 obj-$(CONFIG_CPU_S3C2440)  += s3c2440.o s3c2440-dsc.o
 obj-$(CONFIG_CPU_S3C2440)  += s3c2440-irq.o
 obj-$(CONFIG_CPU_S3C2440)  += s3c2440-clock.o
+obj-$(CONFIG_CPU_S3C2440)  += s3c2410-gpio.o
 
 # bast extras
 
diff --git a/arch/arm/mach-s3c2410/clock.c b/arch/arm/mach-s3c2410/clock.c
index af2f3d52b61b..08489efdaf06 100644
--- a/arch/arm/mach-s3c2410/clock.c
+++ b/arch/arm/mach-s3c2410/clock.c
@@ -40,7 +40,6 @@
 #include <linux/mutex.h>
 
 #include <asm/hardware.h>
-#include <asm/atomic.h>
 #include <asm/irq.h>
 #include <asm/io.h>
 
@@ -59,22 +58,18 @@ static DEFINE_MUTEX(clocks_mutex);
 void inline s3c24xx_clk_enable(unsigned int clocks, unsigned int enable)
 {
         unsigned long clkcon;
-        unsigned long flags;
-
-        local_irq_save(flags);
 
         clkcon = __raw_readl(S3C2410_CLKCON);
-        clkcon &= ~clocks;
 
         if (enable)
                 clkcon |= clocks;
+        else
+                clkcon &= ~clocks;
 
         /* ensure none of the special function bits set */
         clkcon &= ~(S3C2410_CLKCON_IDLE|S3C2410_CLKCON_POWER);
 
         __raw_writel(clkcon, S3C2410_CLKCON);
-
-        local_irq_restore(flags);
 }
 
 /* enable and disable calls for use with the clk struct */
@@ -138,16 +133,32 @@ void clk_put(struct clk *clk)
 
 int clk_enable(struct clk *clk)
 {
-        if (IS_ERR(clk))
+        if (IS_ERR(clk) || clk == NULL)
                 return -EINVAL;
 
-        return (clk->enable)(clk, 1);
+        clk_enable(clk->parent);
+
+        mutex_lock(&clocks_mutex);
+
+        if ((clk->usage++) == 0)
+                (clk->enable)(clk, 1);
+
+        mutex_unlock(&clocks_mutex);
+        return 0;
 }
 
 void clk_disable(struct clk *clk)
 {
-        if (!IS_ERR(clk))
+        if (IS_ERR(clk) || clk == NULL)
+                return;
+
+        mutex_lock(&clocks_mutex);
+
+        if ((--clk->usage) == 0)
                 (clk->enable)(clk, 0);
+
+        mutex_unlock(&clocks_mutex);
+        clk_disable(clk->parent);
 }
 
 
@@ -361,6 +372,14 @@ int s3c24xx_register_clock(struct clk *clk)
         if (clk->enable == NULL)
                 clk->enable = clk_null_enable;
 
+        /* if this is a standard clock, set the usage state */
+
+        if (clk->ctrlbit) {
+                unsigned long clkcon = __raw_readl(S3C2410_CLKCON);
+
+                clk->usage = (clkcon & clk->ctrlbit) ? 1 : 0;
+        }
+
         /* add to the list of available clocks */
 
         mutex_lock(&clocks_mutex);
@@ -402,6 +421,8 @@ int __init s3c24xx_setup_clocks(unsigned long xtal,
          * the LCD clock if it is not needed.
         */
 
+        mutex_lock(&clocks_mutex);
+
         s3c24xx_clk_enable(S3C2410_CLKCON_NAND, 0);
         s3c24xx_clk_enable(S3C2410_CLKCON_USBH, 0);
         s3c24xx_clk_enable(S3C2410_CLKCON_USBD, 0);
@@ -409,6 +430,8 @@ int __init s3c24xx_setup_clocks(unsigned long xtal,
         s3c24xx_clk_enable(S3C2410_CLKCON_IIC, 0);
         s3c24xx_clk_enable(S3C2410_CLKCON_SPI, 0);
 
+        mutex_unlock(&clocks_mutex);
+
         /* assume uart clocks are correctly setup */
 
         /* register our clocks */
diff --git a/arch/arm/mach-s3c2410/clock.h b/arch/arm/mach-s3c2410/clock.h
index 177d5c8decf7..eb5c95d1e7f2 100644
--- a/arch/arm/mach-s3c2410/clock.h
+++ b/arch/arm/mach-s3c2410/clock.h
@@ -16,6 +16,7 @@ struct clk {
         struct clk           *parent;
         const char           *name;
         int                   id;
+        int                   usage;
         unsigned long         rate;
         unsigned long         ctrlbit;
         int                 (*enable)(struct clk *, int enable);
diff --git a/arch/arm/mach-s3c2410/cpu.c b/arch/arm/mach-s3c2410/cpu.c
index 687fe371369d..00a379334b60 100644
--- a/arch/arm/mach-s3c2410/cpu.c
+++ b/arch/arm/mach-s3c2410/cpu.c
@@ -40,6 +40,7 @@
 
 #include "cpu.h"
 #include "clock.h"
+#include "s3c2400.h"
 #include "s3c2410.h"
 #include "s3c2440.h"
 
@@ -55,6 +56,7 @@ struct cpu_table {
 
 /* table of supported CPUs */
 
+static const char name_s3c2400[]  = "S3C2400";
 static const char name_s3c2410[]  = "S3C2410";
 static const char name_s3c2440[]  = "S3C2440";
 static const char name_s3c2410a[] = "S3C2410A";
@@ -96,7 +98,16 @@ static struct cpu_table cpu_ids[] __initdata = {
                 .init_uarts     = s3c2440_init_uarts,
                 .init           = s3c2440_init,
                 .name           = name_s3c2440a
-        }
+        },
+        {
+                .idcode         = 0x0,   /* S3C2400 doesn't have an idcode */
+                .idmask         = 0xffffffff,
+                .map_io         = s3c2400_map_io,
+                .init_clocks    = s3c2400_init_clocks,
+                .init_uarts     = s3c2400_init_uarts,
+                .init           = s3c2400_init,
+                .name           = name_s3c2400
+        },
 };
 
 /* minimal IO mapping */
@@ -148,12 +159,15 @@ static struct cpu_table *cpu;
 
 void __init s3c24xx_init_io(struct map_desc *mach_desc, int size)
 {
-        unsigned long idcode;
+        unsigned long idcode = 0x0;
 
         /* initialise the io descriptors we need for initialisation */
         iotable_init(s3c_iodesc, ARRAY_SIZE(s3c_iodesc));
 
+#ifndef CONFIG_CPU_S3C2400
         idcode = __raw_readl(S3C2410_GSTATUS1);
+#endif
+
         cpu = s3c_lookup_cpu(idcode);
 
         if (cpu == NULL) {
diff --git a/arch/arm/mach-s3c2410/cpu.h b/arch/arm/mach-s3c2410/cpu.h
index 9cbe5eef492b..fc1067783f6d 100644
--- a/arch/arm/mach-s3c2410/cpu.h
+++ b/arch/arm/mach-s3c2410/cpu.h
@@ -17,11 +17,12 @@
  *     14-Jan-2005 BJD  Added s3c24xx_init_clocks() call
  *     10-Mar-2005 LCVR Changed S3C2410_{VA,SZ} to S3C24XX_{VA,SZ} & IODESC_ENT
  *     14-Mar-2005 BJD  Updated for __iomem
+ *     15-Jan-2006 LCVR Updated S3C2410_PA_##x to new S3C24XX_PA_##x macro
 */
 
 /* todo - fix when rmk changes iodescs to use `void __iomem *` */
 
-#define IODESC_ENT(x) { (unsigned long)S3C24XX_VA_##x, __phys_to_pfn(S3C2410_PA_##x), S3C24XX_SZ_##x, MT_DEVICE }
+#define IODESC_ENT(x) { (unsigned long)S3C24XX_VA_##x, __phys_to_pfn(S3C24XX_PA_##x), S3C24XX_SZ_##x, MT_DEVICE }
 
 #ifndef MHZ
 #define MHZ (1000*1000)
diff --git a/arch/arm/mach-s3c2410/devs.c b/arch/arm/mach-s3c2410/devs.c
index f58406e6ef5a..0a47d38789a5 100644
--- a/arch/arm/mach-s3c2410/devs.c
+++ b/arch/arm/mach-s3c2410/devs.c
@@ -10,6 +10,7 @@
  * published by the Free Software Foundation.
  *
  * Modifications:
+ *     15-Jan-2006 LCVR Using S3C24XX_PA_##x macro for common S3C24XX devices
  *     10-Mar-2005 LCVR Changed S3C2410_{VA,SZ} to S3C24XX_{VA,SZ}
  *     10-Feb-2005 BJD  Added camera from guillaume.gourat@nexvision.tv
  *     29-Aug-2004 BJD  Added timers 0 through 3
@@ -46,8 +47,8 @@ struct platform_device *s3c24xx_uart_devs[3];
 
 static struct resource s3c_usb_resource[] = {
         [0] = {
-                .start = S3C2410_PA_USBHOST,
-                .end   = S3C2410_PA_USBHOST + S3C24XX_SZ_USBHOST - 1,
+                .start = S3C24XX_PA_USBHOST,
+                .end   = S3C24XX_PA_USBHOST + S3C24XX_SZ_USBHOST - 1,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -76,8 +77,8 @@ EXPORT_SYMBOL(s3c_device_usb);
 
 static struct resource s3c_lcd_resource[] = {
         [0] = {
-                .start = S3C2410_PA_LCD,
-                .end   = S3C2410_PA_LCD + S3C24XX_SZ_LCD - 1,
+                .start = S3C24XX_PA_LCD,
+                .end   = S3C24XX_PA_LCD + S3C24XX_SZ_LCD - 1,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -139,8 +140,8 @@ EXPORT_SYMBOL(s3c_device_nand);
 
 static struct resource s3c_usbgadget_resource[] = {
         [0] = {
-                .start = S3C2410_PA_USBDEV,
-                .end   = S3C2410_PA_USBDEV + S3C24XX_SZ_USBDEV - 1,
+                .start = S3C24XX_PA_USBDEV,
+                .end   = S3C24XX_PA_USBDEV + S3C24XX_SZ_USBDEV - 1,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -164,8 +165,8 @@ EXPORT_SYMBOL(s3c_device_usbgadget);
 
 static struct resource s3c_wdt_resource[] = {
         [0] = {
-                .start = S3C2410_PA_WATCHDOG,
-                .end   = S3C2410_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,
+                .start = S3C24XX_PA_WATCHDOG,
+                .end   = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -189,8 +190,8 @@ EXPORT_SYMBOL(s3c_device_wdt);
 
 static struct resource s3c_i2c_resource[] = {
         [0] = {
-                .start = S3C2410_PA_IIC,
-                .end   = S3C2410_PA_IIC + S3C24XX_SZ_IIC - 1,
+                .start = S3C24XX_PA_IIC,
+                .end   = S3C24XX_PA_IIC + S3C24XX_SZ_IIC - 1,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -214,8 +215,8 @@ EXPORT_SYMBOL(s3c_device_i2c);
 
 static struct resource s3c_iis_resource[] = {
         [0] = {
-                .start = S3C2410_PA_IIS,
-                .end   = S3C2410_PA_IIS + S3C24XX_SZ_IIS -1,
+                .start = S3C24XX_PA_IIS,
+                .end   = S3C24XX_PA_IIS + S3C24XX_SZ_IIS -1,
                 .flags = IORESOURCE_MEM,
         }
 };
@@ -239,8 +240,8 @@ EXPORT_SYMBOL(s3c_device_iis);
 
 static struct resource s3c_rtc_resource[] = {
         [0] = {
-                .start = S3C2410_PA_RTC,
-                .end   = S3C2410_PA_RTC + 0xff,
+                .start = S3C24XX_PA_RTC,
+                .end   = S3C24XX_PA_RTC + 0xff,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -268,12 +269,17 @@ EXPORT_SYMBOL(s3c_device_rtc);
 
 static struct resource s3c_adc_resource[] = {
         [0] = {
-                .start = S3C2410_PA_ADC,
-                .end   = S3C2410_PA_ADC + S3C24XX_SZ_ADC - 1,
+                .start = S3C24XX_PA_ADC,
+                .end   = S3C24XX_PA_ADC + S3C24XX_SZ_ADC - 1,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
                 .start = IRQ_TC,
+                .end   = IRQ_TC,
+                .flags = IORESOURCE_IRQ,
+        },
+        [2] = {
+                .start = IRQ_ADC,
                 .end   = IRQ_ADC,
                 .flags = IORESOURCE_IRQ,
         }
@@ -316,8 +322,8 @@ EXPORT_SYMBOL(s3c_device_sdi);
 
 static struct resource s3c_spi0_resource[] = {
         [0] = {
-                .start = S3C2410_PA_SPI,
-                .end   = S3C2410_PA_SPI + 0x1f,
+                .start = S3C24XX_PA_SPI,
+                .end   = S3C24XX_PA_SPI + 0x1f,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -341,8 +347,8 @@ EXPORT_SYMBOL(s3c_device_spi0);
 
 static struct resource s3c_spi1_resource[] = {
         [0] = {
-                .start = S3C2410_PA_SPI + 0x20,
-                .end   = S3C2410_PA_SPI + 0x20 + 0x1f,
+                .start = S3C24XX_PA_SPI + 0x20,
+                .end   = S3C24XX_PA_SPI + 0x20 + 0x1f,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -366,8 +372,8 @@ EXPORT_SYMBOL(s3c_device_spi1);
 
 static struct resource s3c_timer0_resource[] = {
         [0] = {
-                .start = S3C2410_PA_TIMER + 0x0C,
-                .end   = S3C2410_PA_TIMER + 0x0C + 0xB,
+                .start = S3C24XX_PA_TIMER + 0x0C,
+                .end   = S3C24XX_PA_TIMER + 0x0C + 0xB,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -391,8 +397,8 @@ EXPORT_SYMBOL(s3c_device_timer0);
 
 static struct resource s3c_timer1_resource[] = {
         [0] = {
-                .start = S3C2410_PA_TIMER + 0x18,
-                .end   = S3C2410_PA_TIMER + 0x23,
+                .start = S3C24XX_PA_TIMER + 0x18,
+                .end   = S3C24XX_PA_TIMER + 0x23,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -416,8 +422,8 @@ EXPORT_SYMBOL(s3c_device_timer1);
 
 static struct resource s3c_timer2_resource[] = {
         [0] = {
-                .start = S3C2410_PA_TIMER + 0x24,
-                .end   = S3C2410_PA_TIMER + 0x2F,
+                .start = S3C24XX_PA_TIMER + 0x24,
+                .end   = S3C24XX_PA_TIMER + 0x2F,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
@@ -441,8 +447,8 @@ EXPORT_SYMBOL(s3c_device_timer2);
 
 static struct resource s3c_timer3_resource[] = {
         [0] = {
-                .start = S3C2410_PA_TIMER + 0x30,
-                .end   = S3C2410_PA_TIMER + 0x3B,
+                .start = S3C24XX_PA_TIMER + 0x30,
+                .end   = S3C24XX_PA_TIMER + 0x3B,
                 .flags = IORESOURCE_MEM,
         },
         [1] = {
diff --git a/arch/arm/mach-s3c2410/dma.c b/arch/arm/mach-s3c2410/dma.c
index 65feaf20d23e..4dbd8e758ea6 100644
--- a/arch/arm/mach-s3c2410/dma.c
+++ b/arch/arm/mach-s3c2410/dma.c
@@ -1152,7 +1152,7 @@ static int __init s3c2410_init_dma(void)
 
         printk("S3C2410 DMA Driver, (c) 2003-2004 Simtec Electronics\n");
 
-        dma_base = ioremap(S3C2410_PA_DMA, 0x200);
+        dma_base = ioremap(S3C24XX_PA_DMA, 0x200);
         if (dma_base == NULL) {
                 printk(KERN_ERR "dma failed to remap register block\n");
                 return -ENOMEM;
diff --git a/arch/arm/mach-s3c2410/gpio.c b/arch/arm/mach-s3c2410/gpio.c
index 23ea3d5fa09c..cd39e8684584 100644
--- a/arch/arm/mach-s3c2410/gpio.c
+++ b/arch/arm/mach-s3c2410/gpio.c
@@ -31,6 +31,7 @@
  *      05-Nov-2004  BJD  EXPORT_SYMBOL() added for all code
  *      13-Mar-2005  BJD  Updates for __iomem
  *      26-Oct-2005  BJD  Added generic configuration types
+ *      15-Jan-2006  LCVR Added support for the S3C2400
  */
 
 
@@ -48,7 +49,7 @@
 
 void s3c2410_gpio_cfgpin(unsigned int pin, unsigned int function)
 {
-        void __iomem *base = S3C2410_GPIO_BASE(pin);
+        void __iomem *base = S3C24XX_GPIO_BASE(pin);
         unsigned long mask;
         unsigned long con;
         unsigned long flags;
@@ -95,7 +96,7 @@ EXPORT_SYMBOL(s3c2410_gpio_cfgpin);
 
 unsigned int s3c2410_gpio_getcfg(unsigned int pin)
 {
-        void __iomem *base = S3C2410_GPIO_BASE(pin);
+        void __iomem *base = S3C24XX_GPIO_BASE(pin);
         unsigned long mask;
 
         if (pin < S3C2410_GPIO_BANKB) {
@@ -111,7 +112,7 @@ EXPORT_SYMBOL(s3c2410_gpio_getcfg);
 
 void s3c2410_gpio_pullup(unsigned int pin, unsigned int to)
 {
-        void __iomem *base = S3C2410_GPIO_BASE(pin);
+        void __iomem *base = S3C24XX_GPIO_BASE(pin);
         unsigned long offs = S3C2410_GPIO_OFFSET(pin);
         unsigned long flags;
         unsigned long up;
@@ -133,7 +134,7 @@ EXPORT_SYMBOL(s3c2410_gpio_pullup);
 
 void s3c2410_gpio_setpin(unsigned int pin, unsigned int to)
 {
-        void __iomem *base = S3C2410_GPIO_BASE(pin);
+        void __iomem *base = S3C24XX_GPIO_BASE(pin);
         unsigned long offs = S3C2410_GPIO_OFFSET(pin);
         unsigned long flags;
         unsigned long dat;
@@ -152,7 +153,7 @@ EXPORT_SYMBOL(s3c2410_gpio_setpin);
 
 unsigned int s3c2410_gpio_getpin(unsigned int pin)
 {
-        void __iomem *base = S3C2410_GPIO_BASE(pin);
+        void __iomem *base = S3C24XX_GPIO_BASE(pin);
         unsigned long offs = S3C2410_GPIO_OFFSET(pin);
 
         return __raw_readl(base + 0x04) & (1<< offs);
@@ -166,70 +167,13 @@ unsigned int s3c2410_modify_misccr(unsigned int clear, unsigned int change)
         unsigned long misccr;
 
         local_irq_save(flags);
-        misccr = __raw_readl(S3C2410_MISCCR);
+        misccr = __raw_readl(S3C24XX_MISCCR);
         misccr &= ~clear;
         misccr ^= change;
-        __raw_writel(misccr, S3C2410_MISCCR);
+        __raw_writel(misccr, S3C24XX_MISCCR);
         local_irq_restore(flags);
 
         return misccr;
 }
 
 EXPORT_SYMBOL(s3c2410_modify_misccr);
-
-int s3c2410_gpio_getirq(unsigned int pin)
-{
-        if (pin < S3C2410_GPF0 || pin > S3C2410_GPG15_EINT23)
-                return -1;      /* not valid interrupts */
-
-        if (pin < S3C2410_GPG0 && pin > S3C2410_GPF7)
-                return -1;      /* not valid pin */
-
-        if (pin < S3C2410_GPF4)
-                return (pin - S3C2410_GPF0) + IRQ_EINT0;
-
-        if (pin < S3C2410_GPG0)
-                return (pin - S3C2410_GPF4) + IRQ_EINT4;
-
-        return (pin - S3C2410_GPG0) + IRQ_EINT8;
-}
-
-EXPORT_SYMBOL(s3c2410_gpio_getirq);
-
-int s3c2410_gpio_irqfilter(unsigned int pin, unsigned int on,
-                           unsigned int config)
-{
-        void __iomem *reg = S3C2410_EINFLT0;
-        unsigned long flags;
-        unsigned long val;
-
-        if (pin < S3C2410_GPG8 || pin > S3C2410_GPG15)
-                return -1;
-
-        config &= 0xff;
-
-        pin -= S3C2410_GPG8_EINT16;
-        reg += pin & ~3;
-
-        local_irq_save(flags);
-
-        /* update filter width and clock source */
-
-        val = __raw_readl(reg);
-        val &= ~(0xff << ((pin & 3) * 8));
-        val |= config << ((pin & 3) * 8);
-        __raw_writel(val, reg);
-
-        /* update filter enable */
-
-        val = __raw_readl(S3C2410_EXTINT2);
-        val &= ~(1 << ((pin * 4) + 3));
-        val |= on << ((pin * 4) + 3);
-        __raw_writel(val, S3C2410_EXTINT2);
-
-        local_irq_restore(flags);
-
-        return 0;
-}
-
-EXPORT_SYMBOL(s3c2410_gpio_irqfilter);
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-gpio.c b/arch/arm/mach-s3c2410/s3c2400-gpio.c
new file mode 100644
index 000000000000..5127f39fa9bf
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c2400-gpio.c
@@ -0,0 +1,45 @@
+/* linux/arch/arm/mach-s3c2410/gpio.c
+ *
+ * Copyright (c) 2006 Lucas Correia Villa Real <lucasvr@gobolinux.org>
+ *
+ * S3C2400 GPIO support
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Changelog
+ *      15-Jan-2006  LCVR  Splitted from gpio.c, adding support for the S3C2400
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/io.h>
+
+#include <asm/arch/regs-gpio.h>
+
+int s3c2400_gpio_getirq(unsigned int pin)
+{
+        if (pin < S3C2410_GPE0 || pin > S3C2400_GPE7_EINT7)
+                return -1;  /* not valid interrupts */
+
+        return (pin - S3C2410_GPE0) + IRQ_EINT0;
+}
+
+EXPORT_SYMBOL(s3c2400_gpio_getirq);
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/arm/mach-s3c2410/s3c2410-gpio.c b/arch/arm/mach-s3c2410/s3c2410-gpio.c
new file mode 100644
index 000000000000..d5e1caea1d23
--- /dev/null
+++ b/arch/arm/mach-s3c2410/s3c2410-gpio.c
@@ -0,0 +1,93 @@
+/* linux/arch/arm/mach-s3c2410/gpio.c
+ *
+ * Copyright (c) 2004-2006 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * S3C2410 GPIO support
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Changelog
+ *      15-Jan-2006  LCVR  Splitted from gpio.c
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/io.h>
+
+#include <asm/arch/regs-gpio.h>
+
+int s3c2410_gpio_irqfilter(unsigned int pin, unsigned int on,
+                           unsigned int config)
+{
+        void __iomem *reg = S3C2410_EINFLT0;
+        unsigned long flags;
+        unsigned long val;
+
+        if (pin < S3C2410_GPG8 || pin > S3C2410_GPG15)
+                return -1;
+
+        config &= 0xff;
+
+        pin -= S3C2410_GPG8_EINT16;
+        reg += pin & ~3;
+
+        local_irq_save(flags);
+
+        /* update filter width and clock source */
+
+        val = __raw_readl(reg);
+        val &= ~(0xff << ((pin & 3) * 8));
+        val |= config << ((pin & 3) * 8);
+        __raw_writel(val, reg);
+
+        /* update filter enable */
+
+        val = __raw_readl(S3C2410_EXTINT2);
+        val &= ~(1 << ((pin * 4) + 3));
+        val |= on << ((pin * 4) + 3);
+        __raw_writel(val, S3C2410_EXTINT2);
+
+        local_irq_restore(flags);
+
+        return 0;
+}
+
+EXPORT_SYMBOL(s3c2410_gpio_irqfilter);
+
+int s3c2410_gpio_getirq(unsigned int pin)
+{
+        if (pin < S3C2410_GPF0 || pin > S3C2410_GPG15_EINT23)
+                return -1;      /* not valid interrupts */
+
+        if (pin < S3C2410_GPG0 && pin > S3C2410_GPF7)
+                return -1;      /* not valid pin */
+
+        if (pin < S3C2410_GPF4)
+                return (pin - S3C2410_GPF0) + IRQ_EINT0;
+
+        if (pin < S3C2410_GPG0)
+                return (pin - S3C2410_GPF4) + IRQ_EINT4;
+
+        return (pin - S3C2410_GPG0) + IRQ_EINT8;
+}
+
+EXPORT_SYMBOL(s3c2410_gpio_getirq);
diff --git a/arch/arm/mach-s3c2410/sleep.S b/arch/arm/mach-s3c2410/sleep.S
index 61768dac7fee..832fb86a03b4 100644
--- a/arch/arm/mach-s3c2410/sleep.S
+++ b/arch/arm/mach-s3c2410/sleep.S
@@ -72,7 +72,7 @@ ENTRY(s3c2410_cpu_suspend)
         @@ prepare cpu to sleep
 
         ldr     r4, =S3C2410_REFRESH
-        ldr     r5, =S3C2410_MISCCR
+        ldr     r5, =S3C24XX_MISCCR
         ldr     r6, =S3C2410_CLKCON
         ldr     r7, [ r4 ]              @ get REFRESH (and ensure in TLB)
         ldr     r8, [ r5 ]              @ get MISCCR (and ensure in TLB)
@@ -133,12 +133,12 @@ ENTRY(s3c2410_cpu_resume)
         @@ load UART to allow us to print the two characters for
         @@ resume debug
 
-        mov     r2, #S3C2410_PA_UART & 0xff000000
-        orr     r2, r2, #S3C2410_PA_UART & 0xff000
+        mov     r2, #S3C24XX_PA_UART & 0xff000000
+        orr     r2, r2, #S3C24XX_PA_UART & 0xff000
 
 #if 0
         /* SMDK2440 LED set */
-        mov     r14, #S3C2410_PA_GPIO
+        mov     r14, #S3C24XX_PA_GPIO
         ldr     r12, [ r14, #0x54 ]
         bic     r12, r12, #3<<4
         orr     r12, r12, #1<<7
diff --git a/arch/arm/mm/cache-v6.S b/arch/arm/mm/cache-v6.S
index 72966d90e956..d921c1024ae0 100644
--- a/arch/arm/mm/cache-v6.S
+++ b/arch/arm/mm/cache-v6.S
@@ -92,22 +92,16 @@ ENTRY(v6_coherent_kern_range)
  *      - the Icache does not read data from the write buffer
  */
 ENTRY(v6_coherent_user_range)
-        bic     r0, r0, #CACHE_LINE_SIZE - 1
-1:
+
 #ifdef HARVARD_CACHE
-        mcr     p15, 0, r0, c7, c10, 1          @ clean D line
+        bic     r0, r0, #CACHE_LINE_SIZE - 1
+1:      mcr     p15, 0, r0, c7, c10, 1          @ clean D line
         mcr     p15, 0, r0, c7, c5, 1           @ invalidate I line
-#endif
-        mcr     p15, 0, r0, c7, c5, 7           @ invalidate BTB entry
-        add     r0, r0, #BTB_FLUSH_SIZE
-        mcr     p15, 0, r0, c7, c5, 7           @ invalidate BTB entry
-        add     r0, r0, #BTB_FLUSH_SIZE
-        mcr     p15, 0, r0, c7, c5, 7           @ invalidate BTB entry
-        add     r0, r0, #BTB_FLUSH_SIZE
-        mcr     p15, 0, r0, c7, c5, 7           @ invalidate BTB entry
-        add     r0, r0, #BTB_FLUSH_SIZE
+        add     r0, r0, #CACHE_LINE_SIZE
         cmp     r0, r1
         blo     1b
+#endif
+        mcr     p15, 0, r0, c7, c5, 6           @ invalidate BTB
 #ifdef HARVARD_CACHE
         mov     r0, #0
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer
diff --git a/arch/arm/mm/ioremap.c b/arch/arm/mm/ioremap.c
index de3ce1eec2ec..da9b35974118 100644
--- a/arch/arm/mm/ioremap.c
+++ b/arch/arm/mm/ioremap.c
@@ -142,7 +142,7 @@ __ioremap_pfn(unsigned long pfn, unsigned long offset, size_t size,
                 return NULL;
         addr = (unsigned long)area->addr;
         if (remap_area_pages(addr, pfn, size, flags)) {
-                vfree(addr);
+                vfree((void *)addr);
                 return NULL;
         }
         return (void __iomem *) (offset + (char *)addr);
diff --git a/arch/arm/mm/mm-armv.c b/arch/arm/mm/mm-armv.c
index d0245a31d4dd..ef8d30a185a9 100644
--- a/arch/arm/mm/mm-armv.c
+++ b/arch/arm/mm/mm-armv.c
@@ -343,6 +343,12 @@ static struct mem_types mem_types[] __initdata = {
                                 PMD_SECT_AP_WRITE | PMD_SECT_BUFFERABLE |
                                 PMD_SECT_TEX(1),
                 .domain    = DOMAIN_IO,
+        },
+        [MT_NONSHARED_DEVICE] = {
+                .prot_l1   = PMD_TYPE_TABLE,
+                .prot_sect = PMD_TYPE_SECT | PMD_SECT_NONSHARED_DEV |
+                                PMD_SECT_AP_WRITE,
+                .domain    = DOMAIN_IO,
         }
 };
 
diff --git a/arch/arm/mm/proc-xscale.S b/arch/arm/mm/proc-xscale.S
index 861b35947280..2d3823ec3153 100644
--- a/arch/arm/mm/proc-xscale.S
+++ b/arch/arm/mm/proc-xscale.S
@@ -241,7 +241,15 @@ ENTRY(xscale_flush_user_cache_range)
  *      it also trashes the mini I-cache used by JTAG debuggers.
  */
 ENTRY(xscale_coherent_kern_range)
-        /* FALLTHROUGH */
+        bic     r0, r0, #CACHELINESIZE - 1
+1:      mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
+        add     r0, r0, #CACHELINESIZE
+        cmp     r0, r1
+        blo     1b
+        mov     r0, #0
+        mcr     p15, 0, r0, c7, c5, 0           @ Invalidate I cache & BTB
+        mcr     p15, 0, r0, c7, c10, 4          @ Drain Write (& Fill) Buffer
+        mov     pc, lr
 
 /*
  *      coherent_user_range(start, end)
@@ -252,18 +260,16 @@ ENTRY(xscale_coherent_kern_range)
  *
  *      - start  - virtual start address
  *      - end    - virtual end address
- *
- *      Note: single I-cache line invalidation isn't used here since
- *      it also trashes the mini I-cache used by JTAG debuggers.
  */
 ENTRY(xscale_coherent_user_range)
         bic     r0, r0, #CACHELINESIZE - 1
 1:      mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
+        mcr     p15, 0, r0, c7, c5, 1           @ Invalidate I cache entry
         add     r0, r0, #CACHELINESIZE
         cmp     r0, r1
         blo     1b
         mov     r0, #0
-        mcr     p15, 0, r0, c7, c5, 0           @ Invalidate I cache & BTB
+        mcr     p15, 0, r0, c7, c5, 6           @ Invalidate BTB
         mcr     p15, 0, r0, c7, c10, 4          @ Drain Write (& Fill) Buffer
         mov     pc, lr
 
diff --git a/arch/arm/oprofile/common.c b/arch/arm/oprofile/common.c
index 1415930ceee1..6f8bc1f0e6a1 100644
--- a/arch/arm/oprofile/common.c
+++ b/arch/arm/oprofile/common.c
@@ -137,8 +137,9 @@ int __init oprofile_arch_init(struct oprofile_operations *ops)
         if (spec) {
                 init_MUTEX(&op_arm_sem);
 
-                if (spec->init() < 0)
-                        return -ENODEV;
+                ret = spec->init();
+                if (ret < 0)
+                        return ret;
 
                 op_arm_model = spec;
                 init_driverfs();
diff --git a/arch/arm/plat-omap/clock.c b/arch/arm/plat-omap/clock.c
index 7ebc5a29db8d..3c2bfc0efdaf 100644
--- a/arch/arm/plat-omap/clock.c
+++ b/arch/arm/plat-omap/clock.c
@@ -34,7 +34,7 @@ DEFINE_SPINLOCK(clockfw_lock);
 static struct clk_functions *arch_clock;
 
 /*-------------------------------------------------------------------------
- * Standard clock functions defined in asm/hardware/clock.h
+ * Standard clock functions defined in include/linux/clk.h
  *-------------------------------------------------------------------------*/
 
 struct clk * clk_get(struct device *dev, const char *id)
@@ -60,12 +60,8 @@ int clk_enable(struct clk *clk)
         int ret = 0;
 
         spin_lock_irqsave(&clockfw_lock, flags);
-        if (clk->enable)
-                ret = clk->enable(clk);
-        else if (arch_clock->clk_enable)
+        if (arch_clock->clk_enable)
                 ret = arch_clock->clk_enable(clk);
-        else
-                printk(KERN_ERR "Could not enable clock %s\n", clk->name);
         spin_unlock_irqrestore(&clockfw_lock, flags);
 
         return ret;
@@ -77,41 +73,12 @@ void clk_disable(struct clk *clk)
         unsigned long flags;
 
         spin_lock_irqsave(&clockfw_lock, flags);
-        if (clk->disable)
-                clk->disable(clk);
-        else if (arch_clock->clk_disable)
+        if (arch_clock->clk_disable)
                 arch_clock->clk_disable(clk);
-        else
-                printk(KERN_ERR "Could not disable clock %s\n", clk->name);
         spin_unlock_irqrestore(&clockfw_lock, flags);
 }
 EXPORT_SYMBOL(clk_disable);
 
-int clk_use(struct clk *clk)
-{
-        unsigned long flags;
-        int ret = 0;
-
-        spin_lock_irqsave(&clockfw_lock, flags);
-        if (arch_clock->clk_use)
-                ret = arch_clock->clk_use(clk);
-        spin_unlock_irqrestore(&clockfw_lock, flags);
-
-        return ret;
-}
-EXPORT_SYMBOL(clk_use);
-
-void clk_unuse(struct clk *clk)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&clockfw_lock, flags);
-        if (arch_clock->clk_unuse)
-                arch_clock->clk_unuse(clk);
-        spin_unlock_irqrestore(&clockfw_lock, flags);
-}
-EXPORT_SYMBOL(clk_unuse);
-
 int clk_get_usecount(struct clk *clk)
 {
         unsigned long flags;
@@ -146,7 +113,7 @@ void clk_put(struct clk *clk)
 EXPORT_SYMBOL(clk_put);
 
 /*-------------------------------------------------------------------------
- * Optional clock functions defined in asm/hardware/clock.h
+ * Optional clock functions defined in include/linux/clk.h
  *-------------------------------------------------------------------------*/
 
 long clk_round_rate(struct clk *clk, unsigned long rate)
diff --git a/arch/arm/plat-omap/gpio.c b/arch/arm/plat-omap/gpio.c
index ca3681a824ac..b4d5b9e4bfce 100644
--- a/arch/arm/plat-omap/gpio.c
+++ b/arch/arm/plat-omap/gpio.c
@@ -853,19 +853,19 @@ static int __init _omap_gpio_init(void)
                 if (IS_ERR(gpio_ick))
                         printk("Could not get arm_gpio_ck\n");
                 else
-                        clk_use(gpio_ick);
+                        clk_enable(gpio_ick);
         }
         if (cpu_is_omap24xx()) {
                 gpio_ick = clk_get(NULL, "gpios_ick");
                 if (IS_ERR(gpio_ick))
                         printk("Could not get gpios_ick\n");
                 else
-                        clk_use(gpio_ick);
+                        clk_enable(gpio_ick);
                 gpio_fck = clk_get(NULL, "gpios_fck");
                 if (IS_ERR(gpio_ick))
                         printk("Could not get gpios_fck\n");
                 else
-                        clk_use(gpio_fck);
+                        clk_enable(gpio_fck);
         }
 
 #ifdef CONFIG_ARCH_OMAP15XX
diff --git a/arch/arm/plat-omap/mcbsp.c b/arch/arm/plat-omap/mcbsp.c
index be0e0f32a598..1cd2cace7e1b 100644
--- a/arch/arm/plat-omap/mcbsp.c
+++ b/arch/arm/plat-omap/mcbsp.c
@@ -190,11 +190,11 @@ static int omap_mcbsp_check(unsigned int id)
 static void omap_mcbsp_dsp_request(void)
 {
         if (cpu_is_omap1510() || cpu_is_omap16xx()) {
-                clk_use(mcbsp_dsp_ck);
-                clk_use(mcbsp_api_ck);
+                clk_enable(mcbsp_dsp_ck);
+                clk_enable(mcbsp_api_ck);
 
                 /* enable 12MHz clock to mcbsp 1 & 3 */
-                clk_use(mcbsp_dspxor_ck);
+                clk_enable(mcbsp_dspxor_ck);
 
                 /*
                  * DSP external peripheral reset
@@ -208,9 +208,9 @@ static void omap_mcbsp_dsp_request(void)
 static void omap_mcbsp_dsp_free(void)
 {
         if (cpu_is_omap1510() || cpu_is_omap16xx()) {
-                clk_unuse(mcbsp_dspxor_ck);
-                clk_unuse(mcbsp_dsp_ck);
-                clk_unuse(mcbsp_api_ck);
+                clk_disable(mcbsp_dspxor_ck);
+                clk_disable(mcbsp_dsp_ck);
+                clk_disable(mcbsp_api_ck);
         }
 }
 
diff --git a/arch/arm/plat-omap/ocpi.c b/arch/arm/plat-omap/ocpi.c
index e40fcc8b43d4..5cc6775c789c 100644
--- a/arch/arm/plat-omap/ocpi.c
+++ b/arch/arm/plat-omap/ocpi.c
@@ -88,7 +88,7 @@ static int __init omap_ocpi_init(void)
         if (IS_ERR(ocpi_ck))
                 return PTR_ERR(ocpi_ck);
 
-        clk_use(ocpi_ck);
+        clk_enable(ocpi_ck);
         ocpi_enable();
         printk("OMAP OCPI interconnect driver loaded\n");
 
@@ -102,7 +102,7 @@ static void __exit omap_ocpi_exit(void)
         if (!cpu_is_omap16xx())
                 return;
 
-        clk_unuse(ocpi_ck);
+        clk_disable(ocpi_ck);
         clk_put(ocpi_ck);
 }
 
diff --git a/arch/arm/plat-omap/sram.c b/arch/arm/plat-omap/sram.c
index 792f66375830..ee82763b02b8 100644
--- a/arch/arm/plat-omap/sram.c
+++ b/arch/arm/plat-omap/sram.c
@@ -17,6 +17,7 @@
 #include <linux/init.h>
 
 #include <asm/mach/map.h>
+#include <asm/tlb.h>
 #include <asm/io.h>
 #include <asm/cacheflush.h>
 
@@ -96,6 +97,14 @@ void __init omap_map_sram(void)
                omap_sram_io_desc[0].length);
 
         /*
+         * Normally devicemaps_init() would flush caches and tlb after
+         * mdesc->map_io(), but since we're called from map_io(), we
+         * must do it here.
+         */
+        local_flush_tlb_all();
+        flush_cache_all();
+
+        /*
          * Looks like we need to preserve some bootloader code at the
          * beginning of SRAM for jumping to flash for reboot to work...
          */
diff --git a/arch/arm26/Kconfig b/arch/arm26/Kconfig
index 274e07019b46..dee23d87fc5a 100644
--- a/arch/arm26/Kconfig
+++ b/arch/arm26/Kconfig
@@ -53,14 +53,14 @@ config GENERIC_ISA_DMA
 
 config ARCH_MAY_HAVE_PC_FDC
         bool
-        default y
 
 source "init/Kconfig"
 
 
 menu "System Type"
 
-comment "Archimedes/A5000 Implementations (select only ONE)"
+choice
+        prompt "Archimedes/A5000 Implementations"
 
 config ARCH_ARC
         bool "Archimedes"
@@ -73,6 +73,7 @@ config ARCH_ARC
 
 config ARCH_A5K
         bool "A5000"
+        select ARCH_MAY_HAVE_PC_FDC
         help
           Say Y here to to support the Acorn A5000.
 
@@ -87,6 +88,7 @@ config PAGESIZE_16
           Say Y here if your Archimedes or A5000 system has only 2MB of
           memory, otherwise say N.  The resulting kernel will not run on a
           machine with 4MB of memory.
+endchoice
 endmenu
 
 config ISA_DMA_API
diff --git a/arch/arm26/kernel/fiq.c b/arch/arm26/kernel/fiq.c
index 08a97c9498ff..a24272b61f30 100644
--- a/arch/arm26/kernel/fiq.c
+++ b/arch/arm26/kernel/fiq.c
@@ -104,14 +104,14 @@ void set_fiq_regs(struct pt_regs *regs)
 {
         register unsigned long tmp, tmp2;
         __asm__ volatile (
-        "mov    %0, pc
-        bic     %1, %0, #0x3
-        orr     %1, %1, %3
-        teqp    %1, #0          @ select FIQ mode
-        mov     r0, r0
-        ldmia   %2, {r8 - r14}
-        teqp    %0, #0          @ return to SVC mode
-        mov     r0, r0"
+        "mov    %0, pc                                  \n"
+        "bic    %1, %0, #0x3                            \n"
+        "orr    %1, %1, %3                              \n"
+        "teqp   %1, #0          @ select FIQ mode       \n"
+        "mov    r0, r0                                  \n"
+        "ldmia  %2, {r8 - r14}                          \n"
+        "teqp   %0, #0          @ return to SVC mode    \n"
+        "mov    r0, r0                                  "
         : "=&r" (tmp), "=&r" (tmp2)
         : "r" (&regs->ARM_r8), "I" (PSR_I_BIT | PSR_F_BIT | MODE_FIQ26)
         /* These registers aren't modified by the above code in a way
@@ -125,14 +125,14 @@ void get_fiq_regs(struct pt_regs *regs)
 {
         register unsigned long tmp, tmp2;
         __asm__ volatile (
-        "mov    %0, pc
-        bic     %1, %0, #0x3
-        orr     %1, %1, %3
-        teqp    %1, #0          @ select FIQ mode
-        mov     r0, r0
-        stmia   %2, {r8 - r14}
-        teqp    %0, #0          @ return to SVC mode
-        mov     r0, r0"
+        "mov    %0, pc                                  \n"
+        "bic    %1, %0, #0x3                            \n"
+        "orr    %1, %1, %3                              \n"
+        "teqp   %1, #0          @ select FIQ mode       \n"
+        "mov    r0, r0                                  \n"
+        "stmia  %2, {r8 - r14}                          \n"
+        "teqp   %0, #0          @ return to SVC mode    \n"
+        "mov    r0, r0                                  "
         : "=&r" (tmp), "=&r" (tmp2)
         : "r" (&regs->ARM_r8), "I" (PSR_I_BIT | PSR_F_BIT | MODE_FIQ26)
         /* These registers aren't modified by the above code in a way
diff --git a/arch/arm26/kernel/signal.c b/arch/arm26/kernel/signal.c
index ce2055bdc9ee..2a48c12100c0 100644
--- a/arch/arm26/kernel/signal.c
+++ b/arch/arm26/kernel/signal.c
@@ -480,6 +480,7 @@ static int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall)
 {
         siginfo_t info;
         int signr;
+        struct k_sigaction ka;
 
         /*
          * We want the common case to go fast, which
@@ -493,7 +494,7 @@ static int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall)
         if (current->ptrace & PT_SINGLESTEP)
                 ptrace_cancel_bpt(current);
         
-        signr = get_signal_to_deliver(&info, regs, NULL);
+        signr = get_signal_to_deliver(&info, &ka, regs, NULL);
         if (signr > 0) {
                 handle_signal(signr, &info, oldset, regs, syscall);
                 if (current->ptrace & PT_SINGLESTEP)
diff --git a/arch/cris/Makefile b/arch/cris/Makefile
index ea65d585cf5e..ee114699ef8e 100644
--- a/arch/cris/Makefile
+++ b/arch/cris/Makefile
@@ -119,7 +119,7 @@ $(SRC_ARCH)/.links:
         @ln -sfn $(SRC_ARCH)/$(SARCH)/lib $(SRC_ARCH)/lib
         @ln -sfn $(SRC_ARCH)/$(SARCH) $(SRC_ARCH)/arch
         @ln -sfn $(SRC_ARCH)/$(SARCH)/vmlinux.lds.S $(SRC_ARCH)/kernel/vmlinux.lds.S
-        @ln -sfn $(SRC_ARCH)/$(SARCH)/asm-offsets.c $(SRC_ARCH)/kernel/asm-offsets.c
+        @ln -sfn $(SRC_ARCH)/$(SARCH)/kernel/asm-offsets.c $(SRC_ARCH)/kernel/asm-offsets.c
         @touch $@
 
 # Create link to sub arch includes
diff --git a/arch/cris/arch-v10/kernel/ptrace.c b/arch/cris/arch-v10/kernel/ptrace.c
index f214f74f264e..961c0d58ded4 100644
--- a/arch/cris/arch-v10/kernel/ptrace.c
+++ b/arch/cris/arch-v10/kernel/ptrace.c
@@ -202,18 +202,18 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                         int i;
                         unsigned long tmp;
                         
+                        ret = 0;
                         for (i = 0; i <= PT_MAX; i++) {
                                 tmp = get_reg(child, i);
                                 
                                 if (put_user(tmp, datap)) {
                                         ret = -EFAULT;
-                                        goto out_tsk;
+                                        break;
                                 }
                                 
                                 data += sizeof(long);
                         }
 
-                        ret = 0;
                         break;
                 }
 
@@ -222,10 +222,11 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                         int i;
                         unsigned long tmp;
                         
+                        ret = 0;
                         for (i = 0; i <= PT_MAX; i++) {
                                 if (get_user(tmp, datap)) {
                                         ret = -EFAULT;
-                                        goto out_tsk;
+                                        break;
                                 }
                                 
                                 if (i == PT_DCCR) {
@@ -237,7 +238,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                                 data += sizeof(long);
                         }
                         
-                        ret = 0;
                         break;
                 }
 
diff --git a/arch/cris/kernel/setup.c b/arch/cris/kernel/setup.c
index d11206e467ab..1ba57efff60d 100644
--- a/arch/cris/kernel/setup.c
+++ b/arch/cris/kernel/setup.c
@@ -24,7 +24,6 @@
 /*
  * Setup options
  */
-struct drive_info_struct { char dummy[32]; } drive_info;
 struct screen_info screen_info;
 
 extern int root_mountflags;
diff --git a/arch/frv/kernel/signal.c b/arch/frv/kernel/signal.c
index 5b7146f54fd5..679c1d5cc958 100644
--- a/arch/frv/kernel/signal.c
+++ b/arch/frv/kernel/signal.c
@@ -35,74 +35,22 @@ struct fdpic_func_descriptor {
         unsigned long   GOT;
 };
 
-static int do_signal(sigset_t *oldset);
-
 /*
  * Atomically swap in the new signal mask, and wait for a signal.
  */
 asmlinkage int sys_sigsuspend(int history0, int history1, old_sigset_t mask)
 {
-        sigset_t saveset;
-
         mask &= _BLOCKABLE;
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         siginitset(&current->blocked, mask);
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        __frame->gr8 = -EINTR;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(&saveset))
-                        /* return the signal number as the return value of this function
-                         * - this is an utterly evil hack. syscalls should not invoke do_signal()
-                         *   as entry.S sets regs->gr8 to the return value of the system call
-                         * - we can't just use sigpending() as we'd have to discard SIG_IGN signals
-                         *   and call waitpid() if SIGCHLD needed discarding
-                         * - this only works on the i386 because it passes arguments to the signal
-                         *   handler on the stack, and the return value in EAX is effectively
-                         *   discarded
-                         */
-                        return __frame->gr8;
-        }
-}
-
-asmlinkage int sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
-{
-        sigset_t saveset, newset;
-
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(sigset_t))
-                return -EINVAL;
-
-        if (copy_from_user(&newset, unewset, sizeof(newset)))
-                return -EFAULT;
-        sigdelsetmask(&newset, ~_BLOCKABLE);
-
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        current->blocked = newset;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-
-        __frame->gr8 = -EINTR;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(&saveset))
-                        /* return the signal number as the return value of this function
-                         * - this is an utterly evil hack. syscalls should not invoke do_signal()
-                         *   as entry.S sets regs->gr8 to the return value of the system call
-                         * - we can't just use sigpending() as we'd have to discard SIG_IGN signals
-                         *   and call waitpid() if SIGCHLD needed discarding
-                         * - this only works on the i386 because it passes arguments to the signal
-                         *   handler on the stack, and the return value in EAX is effectively
-                         *   discarded
-                         */
-                        return __frame->gr8;
-        }
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        return -ERESTARTNOHAND;
 }
 
 asmlinkage int sys_sigaction(int sig,
@@ -372,11 +320,11 @@ static int setup_frame(int sig, struct k_sigaction *ka, sigset_t *set)
                frame->pretcode);
 #endif
 
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sig(SIGSEGV, current);
-        return 0;
+        return -EFAULT;
 
 } /* end setup_frame() */
 
@@ -471,11 +419,11 @@ static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
                frame->pretcode);
 #endif
 
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sig(SIGSEGV, current);
-        return 0;
+        return -EFAULT;
 
 } /* end setup_rt_frame() */
 
@@ -516,7 +464,7 @@ static int handle_signal(unsigned long sig, siginfo_t *info,
         else
                 ret = setup_frame(sig, ka, oldset);
 
-        if (ret) {
+        if (ret == 0) {
                 spin_lock_irq(&current->sighand->siglock);
                 sigorsets(&current->blocked, &current->blocked,
                           &ka->sa.sa_mask);
@@ -536,10 +484,11 @@ static int handle_signal(unsigned long sig, siginfo_t *info,
  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  * mistake.
  */
-static int do_signal(sigset_t *oldset)
+static void do_signal(void)
 {
         struct k_sigaction ka;
         siginfo_t info;
+        sigset_t *oldset;
         int signr;
 
         /*
@@ -549,43 +498,62 @@ static int do_signal(sigset_t *oldset)
          * if so.
          */
         if (!user_mode(__frame))
-                return 1;
+                return;
 
         if (try_to_freeze())
                 goto no_signal;
 
-        if (!oldset)
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
                 oldset = &current->blocked;
 
         signr = get_signal_to_deliver(&info, &ka, __frame, NULL);
-        if (signr > 0)
-                return handle_signal(signr, &info, &ka, oldset);
+        if (signr > 0) {
+                if (handle_signal(signr, &info, &ka, oldset) == 0) {
+                        /* a signal was successfully delivered; the saved
+                         * sigmask will have been stored in the signal frame,
+                         * and will be restored by sigreturn, so we can simply
+                         * clear the TIF_RESTORE_SIGMASK flag */
+                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                }
+
+                return;
+        }
 
 no_signal:
         /* Did we come from a system call? */
         if (__frame->syscallno >= 0) {
                 /* Restart the system call - no handlers present */
-                if (__frame->gr8 == -ERESTARTNOHAND ||
-                    __frame->gr8 == -ERESTARTSYS ||
-                    __frame->gr8 == -ERESTARTNOINTR) {
+                switch (__frame->gr8) {
+                case -ERESTARTNOHAND:
+                case -ERESTARTSYS:
+                case -ERESTARTNOINTR:
                         __frame->gr8 = __frame->orig_gr8;
                         __frame->pc -= 4;
-                }
+                        break;
 
-                if (__frame->gr8 == -ERESTART_RESTARTBLOCK){
+                case -ERESTART_RESTARTBLOCK:
                         __frame->gr8 = __NR_restart_syscall;
                         __frame->pc -= 4;
+                        break;
                 }
         }
 
-        return 0;
+        /* if there's no signal to deliver, we just put the saved sigmask
+         * back */
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 
 } /* end do_signal() */
 
 /*****************************************************************************/
 /*
  * notification of userspace execution resumption
- * - triggered by current->work.notify_resume
+ * - triggered by the TIF_WORK_MASK flags
  */
 asmlinkage void do_notify_resume(__u32 thread_info_flags)
 {
@@ -594,7 +562,7 @@ asmlinkage void do_notify_resume(__u32 thread_info_flags)
                 clear_thread_flag(TIF_SINGLESTEP);
 
         /* deal with pending signal delivery */
-        if (thread_info_flags & _TIF_SIGPENDING)
-                do_signal(NULL);
+        if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
+                do_signal();
 
 } /* end do_notify_resume() */
diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig
index cbde675bc95c..0afec8566e7b 100644
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -47,15 +47,6 @@ config DMI
 
 source "init/Kconfig"
 
-config DOUBLEFAULT
-        default y
-        bool "Enable doublefault exception handler" if EMBEDDED
-        help
-          This option allows trapping of rare doublefault exceptions that
-          would otherwise cause a system to silently reboot. Disabling this
-          option saves about 4k and might cause you much additional grey
-          hair.
-
 menu "Processor type and features"
 
 choice
@@ -451,12 +442,50 @@ config HIGHMEM4G
 
 config HIGHMEM64G
         bool "64GB"
+        depends on X86_CMPXCHG64
         help
           Select this if you have a 32-bit processor and more than 4
           gigabytes of physical RAM.
 
 endchoice
 
+choice
+        depends on EXPERIMENTAL && !X86_PAE
+        prompt "Memory split"
+        default VMSPLIT_3G
+        help
+          Select the desired split between kernel and user memory.
+
+          If the address range available to the kernel is less than the
+          physical memory installed, the remaining memory will be available
+          as "high memory". Accessing high memory is a little more costly
+          than low memory, as it needs to be mapped into the kernel first.
+          Note that increasing the kernel address space limits the range
+          available to user programs, making the address space there
+          tighter.  Selecting anything other than the default 3G/1G split
+          will also likely make your kernel incompatible with binary-only
+          kernel modules.
+
+          If you are not absolutely sure what you are doing, leave this
+          option alone!
+
+        config VMSPLIT_3G
+                bool "3G/1G user/kernel split"
+        config VMSPLIT_3G_OPT
+                bool "3G/1G user/kernel split (for full 1G low memory)"
+        config VMSPLIT_2G
+                bool "2G/2G user/kernel split"
+        config VMSPLIT_1G
+                bool "1G/3G user/kernel split"
+endchoice
+
+config PAGE_OFFSET
+        hex
+        default 0xB0000000 if VMSPLIT_3G_OPT
+        default 0x78000000 if VMSPLIT_2G
+        default 0x40000000 if VMSPLIT_1G
+        default 0xC0000000
+
 config HIGHMEM
         bool
         depends on HIGHMEM64G || HIGHMEM4G
@@ -711,6 +740,15 @@ config HOTPLUG_CPU
 
           Say N.
 
+config DOUBLEFAULT
+        default y
+        bool "Enable doublefault exception handler" if EMBEDDED
+        help
+          This option allows trapping of rare doublefault exceptions that
+          would otherwise cause a system to silently reboot. Disabling this
+          option saves about 4k and might cause you much additional grey
+          hair.
+
 endmenu
 
 
diff --git a/arch/i386/defconfig b/arch/i386/defconfig
index 6a431b926019..3cbe6e9cb9fc 100644
--- a/arch/i386/defconfig
+++ b/arch/i386/defconfig
@@ -644,6 +644,8 @@ CONFIG_8139TOO_PIO=y
 # CONFIG_ACENIC is not set
 # CONFIG_DL2K is not set
 # CONFIG_E1000 is not set
+# CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/i386/kernel/acpi/Makefile b/arch/i386/kernel/acpi/Makefile
index 267ca48e1b6c..d51c7313cae8 100644
--- a/arch/i386/kernel/acpi/Makefile
+++ b/arch/i386/kernel/acpi/Makefile
@@ -3,6 +3,6 @@ obj-$(CONFIG_X86_IO_APIC)	+= earlyquirk.o
 obj-$(CONFIG_ACPI_SLEEP)        += sleep.o wakeup.o
 
 ifneq ($(CONFIG_ACPI_PROCESSOR),)
-obj-y                           += cstate.o
+obj-y                           += cstate.o processor.o
 endif
 
diff --git a/arch/i386/kernel/acpi/boot.c b/arch/i386/kernel/acpi/boot.c
index 2111529dea77..79577f0ace98 100644
--- a/arch/i386/kernel/acpi/boot.c
+++ b/arch/i386/kernel/acpi/boot.c
@@ -248,10 +248,17 @@ acpi_parse_lapic(acpi_table_entry_header * header, const unsigned long end)
 
         acpi_table_print_madt_entry(header);
 
-        /* Register even disabled CPUs for cpu hotplug */
-
-        x86_acpiid_to_apicid[processor->acpi_id] = processor->id;
+        /* Record local apic id only when enabled */
+        if (processor->flags.enabled)
+                x86_acpiid_to_apicid[processor->acpi_id] = processor->id;
 
+        /*
+         * We need to register disabled CPU as well to permit
+         * counting disabled CPUs. This allows us to size
+         * cpus_possible_map more accurately, to permit
+         * to not preallocating memory for all NR_CPUS
+         * when we use CPU hotplug.
+         */
         mp_register_lapic(processor->id,        /* APIC ID */
                           processor->flags.enabled);    /* Enabled? */
 
@@ -464,7 +471,7 @@ int acpi_gsi_to_irq(u32 gsi, unsigned int *irq)
  * success: return IRQ number (>=0)
  * failure: return < 0
  */
-int acpi_register_gsi(u32 gsi, int edge_level, int active_high_low)
+int acpi_register_gsi(u32 gsi, int triggering, int polarity)
 {
         unsigned int irq;
         unsigned int plat_gsi = gsi;
@@ -476,14 +483,14 @@ int acpi_register_gsi(u32 gsi, int edge_level, int active_high_low)
         if (acpi_irq_model == ACPI_IRQ_MODEL_PIC) {
                 extern void eisa_set_level_irq(unsigned int irq);
 
-                if (edge_level == ACPI_LEVEL_SENSITIVE)
+                if (triggering == ACPI_LEVEL_SENSITIVE)
                         eisa_set_level_irq(gsi);
         }
 #endif
 
 #ifdef CONFIG_X86_IO_APIC
         if (acpi_irq_model == ACPI_IRQ_MODEL_IOAPIC) {
-                plat_gsi = mp_register_gsi(gsi, edge_level, active_high_low);
+                plat_gsi = mp_register_gsi(gsi, triggering, polarity);
         }
 #endif
         acpi_gsi_to_irq(plat_gsi, &irq);
diff --git a/arch/i386/kernel/acpi/cstate.c b/arch/i386/kernel/acpi/cstate.c
index 4c3036ba65df..25db49ef1770 100644
--- a/arch/i386/kernel/acpi/cstate.c
+++ b/arch/i386/kernel/acpi/cstate.c
@@ -14,64 +14,6 @@
 #include <acpi/processor.h>
 #include <asm/acpi.h>
 
-static void acpi_processor_power_init_intel_pdc(struct acpi_processor_power
-                                                *pow)
-{
-        struct acpi_object_list *obj_list;
-        union acpi_object *obj;
-        u32 *buf;
-
-        /* allocate and initialize pdc. It will be used later. */
-        obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
-        if (!obj_list) {
-                printk(KERN_ERR "Memory allocation error\n");
-                return;
-        }
-
-        obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
-        if (!obj) {
-                printk(KERN_ERR "Memory allocation error\n");
-                kfree(obj_list);
-                return;
-        }
-
-        buf = kmalloc(12, GFP_KERNEL);
-        if (!buf) {
-                printk(KERN_ERR "Memory allocation error\n");
-                kfree(obj);
-                kfree(obj_list);
-                return;
-        }
-
-        buf[0] = ACPI_PDC_REVISION_ID;
-        buf[1] = 1;
-        buf[2] = ACPI_PDC_C_CAPABILITY_SMP;
-
-        obj->type = ACPI_TYPE_BUFFER;
-        obj->buffer.length = 12;
-        obj->buffer.pointer = (u8 *) buf;
-        obj_list->count = 1;
-        obj_list->pointer = obj;
-        pow->pdc = obj_list;
-
-        return;
-}
-
-/* Initialize _PDC data based on the CPU vendor */
-void acpi_processor_power_init_pdc(struct acpi_processor_power *pow,
-                                   unsigned int cpu)
-{
-        struct cpuinfo_x86 *c = cpu_data + cpu;
-
-        pow->pdc = NULL;
-        if (c->x86_vendor == X86_VENDOR_INTEL)
-                acpi_processor_power_init_intel_pdc(pow);
-
-        return;
-}
-
-EXPORT_SYMBOL(acpi_processor_power_init_pdc);
-
 /*
  * Initialize bm_flags based on the CPU cache properties
  * On SMP it depends on cache configuration
diff --git a/arch/i386/kernel/acpi/processor.c b/arch/i386/kernel/acpi/processor.c
new file mode 100644
index 000000000000..9f4cc02717ec
--- /dev/null
+++ b/arch/i386/kernel/acpi/processor.c
@@ -0,0 +1,75 @@
+/*
+ * arch/i386/kernel/acpi/processor.c
+ *
+ * Copyright (C) 2005 Intel Corporation
+ *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *      - Added _PDC for platforms with Intel CPUs
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+
+#include <acpi/processor.h>
+#include <asm/acpi.h>
+
+static void init_intel_pdc(struct acpi_processor *pr, struct cpuinfo_x86 *c)
+{
+        struct acpi_object_list *obj_list;
+        union acpi_object *obj;
+        u32 *buf;
+
+        /* allocate and initialize pdc. It will be used later. */
+        obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
+        if (!obj_list) {
+                printk(KERN_ERR "Memory allocation error\n");
+                return;
+        }
+
+        obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
+        if (!obj) {
+                printk(KERN_ERR "Memory allocation error\n");
+                kfree(obj_list);
+                return;
+        }
+
+        buf = kmalloc(12, GFP_KERNEL);
+        if (!buf) {
+                printk(KERN_ERR "Memory allocation error\n");
+                kfree(obj);
+                kfree(obj_list);
+                return;
+        }
+
+        buf[0] = ACPI_PDC_REVISION_ID;
+        buf[1] = 1;
+        buf[2] = ACPI_PDC_C_CAPABILITY_SMP;
+
+        if (cpu_has(c, X86_FEATURE_EST))
+                buf[2] |= ACPI_PDC_EST_CAPABILITY_SMP;
+
+        obj->type = ACPI_TYPE_BUFFER;
+        obj->buffer.length = 12;
+        obj->buffer.pointer = (u8 *) buf;
+        obj_list->count = 1;
+        obj_list->pointer = obj;
+        pr->pdc = obj_list;
+
+        return;
+}
+
+/* Initialize _PDC data based on the CPU vendor */
+void arch_acpi_processor_init_pdc(struct acpi_processor *pr)
+{
+        unsigned int cpu = pr->id;
+        struct cpuinfo_x86 *c = cpu_data + cpu;
+
+        pr->pdc = NULL;
+        if (c->x86_vendor == X86_VENDOR_INTEL)
+                init_intel_pdc(pr, c);
+
+        return;
+}
+
+EXPORT_SYMBOL(arch_acpi_processor_init_pdc);
diff --git a/arch/i386/kernel/apic.c b/arch/i386/kernel/apic.c
index acd3f1e34ca6..f39e09ef64ec 100644
--- a/arch/i386/kernel/apic.c
+++ b/arch/i386/kernel/apic.c
@@ -75,8 +75,10 @@ void ack_bad_irq(unsigned int irq)
          * holds up an irq slot - in excessive cases (when multiple
          * unexpected vectors occur) that might lock up the APIC
          * completely.
+         * But only ack when the APIC is enabled -AK
          */
-        ack_APIC_irq();
+        if (cpu_has_apic)
+                ack_APIC_irq();
 }
 
 void __init apic_intr_init(void)
@@ -1303,6 +1305,7 @@ int __init APIC_init_uniprocessor (void)
         if (!cpu_has_apic && APIC_INTEGRATED(apic_version[boot_cpu_physical_apicid])) {
                 printk(KERN_ERR "BIOS bug, local APIC #%d not detected!...\n",
                         boot_cpu_physical_apicid);
+                clear_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
                 return -1;
         }
 
diff --git a/arch/i386/kernel/cpu/amd.c b/arch/i386/kernel/cpu/amd.c
index 333578a4e91a..0810f81f2a05 100644
--- a/arch/i386/kernel/cpu/amd.c
+++ b/arch/i386/kernel/cpu/amd.c
@@ -282,3 +282,11 @@ int __init amd_init_cpu(void)
 }
 
 //early_arch_initcall(amd_init_cpu);
+
+static int __init amd_exit_cpu(void)
+{
+        cpu_devs[X86_VENDOR_AMD] = NULL;
+        return 0;
+}
+
+late_initcall(amd_exit_cpu);
diff --git a/arch/i386/kernel/cpu/centaur.c b/arch/i386/kernel/cpu/centaur.c
index 394814e57672..f52669ecb93f 100644
--- a/arch/i386/kernel/cpu/centaur.c
+++ b/arch/i386/kernel/cpu/centaur.c
@@ -405,10 +405,6 @@ static void __init init_centaur(struct cpuinfo_x86 *c)
                                 winchip2_protect_mcr();
 #endif
                                 break;
-                        case 10:
-                                name="4";
-                                /* no info on the WC4 yet */
-                                break;
                         default:
                                 name="??";
                         }
@@ -474,3 +470,11 @@ int __init centaur_init_cpu(void)
 }
 
 //early_arch_initcall(centaur_init_cpu);
+
+static int __init centaur_exit_cpu(void)
+{
+        cpu_devs[X86_VENDOR_CENTAUR] = NULL;
+        return 0;
+}
+
+late_initcall(centaur_exit_cpu);
diff --git a/arch/i386/kernel/cpu/common.c b/arch/i386/kernel/cpu/common.c
index 15aee26ec2b6..7eb9213734a3 100644
--- a/arch/i386/kernel/cpu/common.c
+++ b/arch/i386/kernel/cpu/common.c
@@ -44,6 +44,7 @@ static void default_init(struct cpuinfo_x86 * c)
 
 static struct cpu_dev default_cpu = {
         .c_init = default_init,
+        .c_vendor = "Unknown",
 };
 static struct cpu_dev * this_cpu = &default_cpu;
 
@@ -150,6 +151,7 @@ static void __devinit get_cpu_vendor(struct cpuinfo_x86 *c, int early)
 {
         char *v = c->x86_vendor_id;
         int i;
+        static int printed;
 
         for (i = 0; i < X86_VENDOR_NUM; i++) {
                 if (cpu_devs[i]) {
@@ -159,10 +161,17 @@ static void __devinit get_cpu_vendor(struct cpuinfo_x86 *c, int early)
                                 c->x86_vendor = i;
                                 if (!early)
                                         this_cpu = cpu_devs[i];
-                                break;
+                                return;
                         }
                 }
         }
+        if (!printed) {
+                printed++;
+                printk(KERN_ERR "CPU: Vendor unknown, using generic init.\n");
+                printk(KERN_ERR "CPU: Your system may be unstable.\n");
+        }
+        c->x86_vendor = X86_VENDOR_UNKNOWN;
+        this_cpu = &default_cpu;
 }
 
 
diff --git a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
index 7975e79d5fa4..3852d0a4c1b5 100644
--- a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -295,68 +295,6 @@ acpi_cpufreq_guess_freq (
 }
 
 
-/* 
- * acpi_processor_cpu_init_pdc_est - let BIOS know about the SMP capabilities
- * of this driver
- * @perf: processor-specific acpi_io_data struct
- * @cpu: CPU being initialized
- *
- * To avoid issues with legacy OSes, some BIOSes require to be informed of
- * the SMP capabilities of OS P-state driver. Here we set the bits in _PDC 
- * accordingly, for Enhanced Speedstep. Actual call to _PDC is done in
- * driver/acpi/processor.c
- */
-static void 
-acpi_processor_cpu_init_pdc_est(
-                struct acpi_processor_performance *perf, 
-                unsigned int cpu,
-                struct acpi_object_list *obj_list
-                )
-{
-        union acpi_object *obj;
-        u32 *buf;
-        struct cpuinfo_x86 *c = cpu_data + cpu;
-        dprintk("acpi_processor_cpu_init_pdc_est\n");
-
-        if (!cpu_has(c, X86_FEATURE_EST))
-                return;
-
-        /* Initialize pdc. It will be used later. */
-        if (!obj_list)
-                return;
-                
-        if (!(obj_list->count && obj_list->pointer))
-                return;
-
-        obj = obj_list->pointer;
-        if ((obj->buffer.length == 12) && obj->buffer.pointer) {
-                buf = (u32 *)obj->buffer.pointer;
-                buf[0] = ACPI_PDC_REVISION_ID;
-                buf[1] = 1;
-                buf[2] = ACPI_PDC_EST_CAPABILITY_SMP;
-                perf->pdc = obj_list;
-        }
-        return;
-}
- 
-
-/* CPU specific PDC initialization */
-static void 
-acpi_processor_cpu_init_pdc(
-                struct acpi_processor_performance *perf, 
-                unsigned int cpu,
-                struct acpi_object_list *obj_list
-                )
-{
-        struct cpuinfo_x86 *c = cpu_data + cpu;
-        dprintk("acpi_processor_cpu_init_pdc\n");
-        perf->pdc = NULL;
-        if (cpu_has(c, X86_FEATURE_EST))
-                acpi_processor_cpu_init_pdc_est(perf, cpu, obj_list);
-        return;
-}
-
-
 static int
 acpi_cpufreq_cpu_init (
         struct cpufreq_policy   *policy)
@@ -367,14 +305,7 @@ acpi_cpufreq_cpu_init (
         unsigned int            result = 0;
         struct cpuinfo_x86 *c = &cpu_data[policy->cpu];
 
-        union acpi_object               arg0 = {ACPI_TYPE_BUFFER};
-        u32                             arg0_buf[3];
-        struct acpi_object_list         arg_list = {1, &arg0};
-
         dprintk("acpi_cpufreq_cpu_init\n");
-        /* setup arg_list for _PDC settings */
-        arg0.buffer.length = 12;
-        arg0.buffer.pointer = (u8 *) arg0_buf;
 
         data = kzalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
         if (!data)
@@ -382,9 +313,7 @@ acpi_cpufreq_cpu_init (
 
         acpi_io_data[cpu] = data;
 
-        acpi_processor_cpu_init_pdc(&data->acpi_data, cpu, &arg_list);
         result = acpi_processor_register_performance(&data->acpi_data, cpu);
-        data->acpi_data.pdc = NULL;
 
         if (result)
                 goto err_free;
diff --git a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
index 9a826cde4fd1..c173c0fa117a 100644
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -362,22 +362,10 @@ static struct acpi_processor_performance p;
  */
 static int centrino_cpu_init_acpi(struct cpufreq_policy *policy)
 {
-        union acpi_object               arg0 = {ACPI_TYPE_BUFFER};
-        u32                             arg0_buf[3];
-        struct acpi_object_list         arg_list = {1, &arg0};
         unsigned long                   cur_freq;
         int                             result = 0, i;
         unsigned int                    cpu = policy->cpu;
 
-        /* _PDC settings */
-        arg0.buffer.length = 12;
-        arg0.buffer.pointer = (u8 *) arg0_buf;
-        arg0_buf[0] = ACPI_PDC_REVISION_ID;
-        arg0_buf[1] = 1;
-        arg0_buf[2] = ACPI_PDC_EST_CAPABILITY_SMP_MSR;
-
-        p.pdc = &arg_list;
-
         /* register with ACPI core */
         if (acpi_processor_register_performance(&p, cpu)) {
                 dprintk(KERN_INFO PFX "obtaining ACPI data failed\n");
diff --git a/arch/i386/kernel/cpu/cyrix.c b/arch/i386/kernel/cpu/cyrix.c
index 75015975d038..00f2e058797c 100644
--- a/arch/i386/kernel/cpu/cyrix.c
+++ b/arch/i386/kernel/cpu/cyrix.c
@@ -345,7 +345,7 @@ static void __init init_cyrix(struct cpuinfo_x86 *c)
 /*
  * Handle National Semiconductor branded processors
  */
-static void __devinit init_nsc(struct cpuinfo_x86 *c)
+static void __init init_nsc(struct cpuinfo_x86 *c)
 {
         /* There may be GX1 processors in the wild that are branded
          * NSC and not Cyrix.
@@ -444,6 +444,14 @@ int __init cyrix_init_cpu(void)
 
 //early_arch_initcall(cyrix_init_cpu);
 
+static int __init cyrix_exit_cpu(void)
+{
+        cpu_devs[X86_VENDOR_CYRIX] = NULL;
+        return 0;
+}
+
+late_initcall(cyrix_exit_cpu);
+
 static struct cpu_dev nsc_cpu_dev __initdata = {
         .c_vendor       = "NSC",
         .c_ident        = { "Geode by NSC" },
@@ -458,3 +466,11 @@ int __init nsc_init_cpu(void)
 }
 
 //early_arch_initcall(nsc_init_cpu);
+
+static int __init nsc_exit_cpu(void)
+{
+        cpu_devs[X86_VENDOR_NSC] = NULL;
+        return 0;
+}
+
+late_initcall(nsc_exit_cpu);
diff --git a/arch/i386/kernel/cpu/intel_cacheinfo.c b/arch/i386/kernel/cpu/intel_cacheinfo.c
index fbfd374aa336..ffe58cee0c48 100644
--- a/arch/i386/kernel/cpu/intel_cacheinfo.c
+++ b/arch/i386/kernel/cpu/intel_cacheinfo.c
@@ -43,13 +43,23 @@ static struct _cache_table cache_table[] __cpuinitdata =
         { 0x2c, LVL_1_DATA, 32 },       /* 8-way set assoc, 64 byte line size */
         { 0x30, LVL_1_INST, 32 },       /* 8-way set assoc, 64 byte line size */
         { 0x39, LVL_2,      128 },      /* 4-way set assoc, sectored cache, 64 byte line size */
+        { 0x3a, LVL_2,      192 },      /* 6-way set assoc, sectored cache, 64 byte line size */
         { 0x3b, LVL_2,      128 },      /* 2-way set assoc, sectored cache, 64 byte line size */
         { 0x3c, LVL_2,      256 },      /* 4-way set assoc, sectored cache, 64 byte line size */
+        { 0x3d, LVL_2,      384 },      /* 6-way set assoc, sectored cache, 64 byte line size */
+        { 0x3e, LVL_2,      512 },      /* 4-way set assoc, sectored cache, 64 byte line size */
         { 0x41, LVL_2,      128 },      /* 4-way set assoc, 32 byte line size */
         { 0x42, LVL_2,      256 },      /* 4-way set assoc, 32 byte line size */
         { 0x43, LVL_2,      512 },      /* 4-way set assoc, 32 byte line size */
         { 0x44, LVL_2,      1024 },     /* 4-way set assoc, 32 byte line size */
         { 0x45, LVL_2,      2048 },     /* 4-way set assoc, 32 byte line size */
+        { 0x46, LVL_3,      4096 },     /* 4-way set assoc, 64 byte line size */
+        { 0x47, LVL_3,      8192 },     /* 8-way set assoc, 64 byte line size */
+        { 0x49, LVL_3,      4096 },     /* 16-way set assoc, 64 byte line size */
+        { 0x4a, LVL_3,      6144 },     /* 12-way set assoc, 64 byte line size */
+        { 0x4b, LVL_3,      8192 },     /* 16-way set assoc, 64 byte line size */
+        { 0x4c, LVL_3,     12288 },     /* 12-way set assoc, 64 byte line size */
+        { 0x4d, LVL_3,     16384 },     /* 16-way set assoc, 64 byte line size */
         { 0x60, LVL_1_DATA, 16 },       /* 8-way set assoc, sectored cache, 64 byte line size */
         { 0x66, LVL_1_DATA, 8 },        /* 4-way set assoc, sectored cache, 64 byte line size */
         { 0x67, LVL_1_DATA, 16 },       /* 4-way set assoc, sectored cache, 64 byte line size */
@@ -57,6 +67,7 @@ static struct _cache_table cache_table[] __cpuinitdata =
         { 0x70, LVL_TRACE,  12 },       /* 8-way set assoc */
         { 0x71, LVL_TRACE,  16 },       /* 8-way set assoc */
         { 0x72, LVL_TRACE,  32 },       /* 8-way set assoc */
+        { 0x73, LVL_TRACE,  64 },       /* 8-way set assoc */
         { 0x78, LVL_2,    1024 },       /* 4-way set assoc, 64 byte line size */
         { 0x79, LVL_2,     128 },       /* 8-way set assoc, sectored cache, 64 byte line size */
         { 0x7a, LVL_2,     256 },       /* 8-way set assoc, sectored cache, 64 byte line size */
@@ -141,6 +152,7 @@ static int __cpuinit cpuid4_cache_lookup(int index, struct _cpuid4_info *this_le
         return 0;
 }
 
+/* will only be called once; __init is safe here */
 static int __init find_num_cache_leaves(void)
 {
         unsigned int            eax, ebx, ecx, edx;
diff --git a/arch/i386/kernel/cpu/mtrr/main.c b/arch/i386/kernel/cpu/mtrr/main.c
index 1e9db198c440..3b4618bed70d 100644
--- a/arch/i386/kernel/cpu/mtrr/main.c
+++ b/arch/i386/kernel/cpu/mtrr/main.c
@@ -44,12 +44,10 @@
 #include <asm/msr.h>
 #include "mtrr.h"
 
-#define MTRR_VERSION            "2.0 (20020519)"
-
 u32 num_var_ranges = 0;
 
 unsigned int *usage_table;
-static DECLARE_MUTEX(main_lock);
+static DECLARE_MUTEX(mtrr_sem);
 
 u32 size_or_mask, size_and_mask;
 
@@ -335,7 +333,7 @@ int mtrr_add_page(unsigned long base, unsigned long size,
         /* No CPU hotplug when we change MTRR entries */
         lock_cpu_hotplug();
         /*  Search for existing MTRR  */
-        down(&main_lock);
+        down(&mtrr_sem);
         for (i = 0; i < num_var_ranges; ++i) {
                 mtrr_if->get(i, &lbase, &lsize, &ltype);
                 if (base >= lbase + lsize)
@@ -373,7 +371,7 @@ int mtrr_add_page(unsigned long base, unsigned long size,
                 printk(KERN_INFO "mtrr: no more MTRRs available\n");
         error = i;
  out:
-        up(&main_lock);
+        up(&mtrr_sem);
         unlock_cpu_hotplug();
         return error;
 }
@@ -466,7 +464,7 @@ int mtrr_del_page(int reg, unsigned long base, unsigned long size)
         max = num_var_ranges;
         /* No CPU hotplug when we change MTRR entries */
         lock_cpu_hotplug();
-        down(&main_lock);
+        down(&mtrr_sem);
         if (reg < 0) {
                 /*  Search for existing MTRR  */
                 for (i = 0; i < max; ++i) {
@@ -505,7 +503,7 @@ int mtrr_del_page(int reg, unsigned long base, unsigned long size)
                 set_mtrr(reg, 0, 0, 0);
         error = reg;
  out:
-        up(&main_lock);
+        up(&mtrr_sem);
         unlock_cpu_hotplug();
         return error;
 }
@@ -671,7 +669,6 @@ void __init mtrr_bp_init(void)
                         break;
                 }
         }
-        printk(KERN_INFO "mtrr: v%s\n",MTRR_VERSION);
 
         if (mtrr_if) {
                 set_num_var_ranges();
@@ -688,7 +685,7 @@ void mtrr_ap_init(void)
         if (!mtrr_if || !use_intel())
                 return;
         /*
-         * Ideally we should hold main_lock here to avoid mtrr entries changed,
+         * Ideally we should hold mtrr_sem here to avoid mtrr entries changed,
          * but this routine will be called in cpu boot time, holding the lock
          * breaks it. This routine is called in two cases: 1.very earily time
          * of software resume, when there absolutely isn't mtrr entry changes;
diff --git a/arch/i386/kernel/cpu/nexgen.c b/arch/i386/kernel/cpu/nexgen.c
index 30898a260a5c..ad87fa58058d 100644
--- a/arch/i386/kernel/cpu/nexgen.c
+++ b/arch/i386/kernel/cpu/nexgen.c
@@ -61,3 +61,11 @@ int __init nexgen_init_cpu(void)
 }
 
 //early_arch_initcall(nexgen_init_cpu);
+
+static int __init nexgen_exit_cpu(void)
+{
+        cpu_devs[X86_VENDOR_NEXGEN] = NULL;
+        return 0;
+}
+
+late_initcall(nexgen_exit_cpu);
diff --git a/arch/i386/kernel/cpu/rise.c b/arch/i386/kernel/cpu/rise.c
index 8602425628ca..d08d5a2811c8 100644
--- a/arch/i386/kernel/cpu/rise.c
+++ b/arch/i386/kernel/cpu/rise.c
@@ -51,3 +51,11 @@ int __init rise_init_cpu(void)
 }
 
 //early_arch_initcall(rise_init_cpu);
+
+static int __init rise_exit_cpu(void)
+{
+        cpu_devs[X86_VENDOR_RISE] = NULL;
+        return 0;
+}
+
+late_initcall(rise_exit_cpu);
diff --git a/arch/i386/kernel/cpu/transmeta.c b/arch/i386/kernel/cpu/transmeta.c
index fc426380366b..bdbeb77f4e22 100644
--- a/arch/i386/kernel/cpu/transmeta.c
+++ b/arch/i386/kernel/cpu/transmeta.c
@@ -84,7 +84,7 @@ static void __init init_transmeta(struct cpuinfo_x86 *c)
 #endif
 }
 
-static void transmeta_identify(struct cpuinfo_x86 * c)
+static void __init transmeta_identify(struct cpuinfo_x86 * c)
 {
         u32 xlvl;
         generic_identify(c);
@@ -111,3 +111,11 @@ int __init transmeta_init_cpu(void)
 }
 
 //early_arch_initcall(transmeta_init_cpu);
+
+static int __init transmeta_exit_cpu(void)
+{
+        cpu_devs[X86_VENDOR_TRANSMETA] = NULL;
+        return 0;
+}
+
+late_initcall(transmeta_exit_cpu);
diff --git a/arch/i386/kernel/cpu/umc.c b/arch/i386/kernel/cpu/umc.c
index 264fcad559d5..2cd988f6dc55 100644
--- a/arch/i386/kernel/cpu/umc.c
+++ b/arch/i386/kernel/cpu/umc.c
@@ -31,3 +31,11 @@ int __init umc_init_cpu(void)
 }
 
 //early_arch_initcall(umc_init_cpu);
+
+static int __init umc_exit_cpu(void)
+{
+        cpu_devs[X86_VENDOR_UMC] = NULL;
+        return 0;
+}
+
+late_initcall(umc_exit_cpu);
diff --git a/arch/i386/kernel/head.S b/arch/i386/kernel/head.S
index 5884469f6bfe..2bee6499edd9 100644
--- a/arch/i386/kernel/head.S
+++ b/arch/i386/kernel/head.S
@@ -398,7 +398,11 @@ ignore_int:
         pushl 32(%esp)
         pushl 40(%esp)
         pushl $int_msg
+#ifdef CONFIG_EARLY_PRINTK
+        call early_printk
+#else
         call printk
+#endif
         addl $(5*4),%esp
         popl %ds
         popl %es
diff --git a/arch/i386/kernel/mpparse.c b/arch/i386/kernel/mpparse.c
index 91a64016956e..0102f3d50e57 100644
--- a/arch/i386/kernel/mpparse.c
+++ b/arch/i386/kernel/mpparse.c
@@ -1080,7 +1080,7 @@ void __init mp_config_acpi_legacy_irqs (void)
 
 #define MAX_GSI_NUM     4096
 
-int mp_register_gsi (u32 gsi, int edge_level, int active_high_low)
+int mp_register_gsi (u32 gsi, int triggering, int polarity)
 {
         int                     ioapic = -1;
         int                     ioapic_pin = 0;
@@ -1129,7 +1129,7 @@ int mp_register_gsi (u32 gsi, int edge_level, int active_high_low)
 
         mp_ioapic_routing[ioapic].pin_programmed[idx] |= (1<<bit);
 
-        if (edge_level) {
+        if (triggering == ACPI_LEVEL_SENSITIVE) {
                 /*
                  * For PCI devices assign IRQs in order, avoiding gaps
                  * due to unused I/O APIC pins.
@@ -1151,8 +1151,8 @@ int mp_register_gsi (u32 gsi, int edge_level, int active_high_low)
         }
 
         io_apic_set_pci_routing(ioapic, ioapic_pin, gsi,
-                    edge_level == ACPI_EDGE_SENSITIVE ? 0 : 1,
-                    active_high_low == ACPI_ACTIVE_HIGH ? 0 : 1);
+                    triggering == ACPI_EDGE_SENSITIVE ? 0 : 1,
+                    polarity == ACPI_ACTIVE_HIGH ? 0 : 1);
         return gsi;
 }
 
diff --git a/arch/i386/kernel/nmi.c b/arch/i386/kernel/nmi.c
index d661703ac1cb..63f39a7e2c96 100644
--- a/arch/i386/kernel/nmi.c
+++ b/arch/i386/kernel/nmi.c
@@ -138,7 +138,7 @@ static int __init check_nmi_watchdog(void)
         if (nmi_watchdog == NMI_LOCAL_APIC)
                 smp_call_function(nmi_cpu_busy, (void *)&endflag, 0, 0);
 
-        for (cpu = 0; cpu < NR_CPUS; cpu++)
+        for_each_cpu(cpu)
                 prev_nmi_count[cpu] = per_cpu(irq_stat, cpu).__nmi_count;
         local_irq_enable();
         mdelay((10*1000)/nmi_hz); // wait 10 ticks
diff --git a/arch/i386/kernel/process.c b/arch/i386/kernel/process.c
index 2185377fdde1..0480454ebffa 100644
--- a/arch/i386/kernel/process.c
+++ b/arch/i386/kernel/process.c
@@ -297,8 +297,10 @@ void show_regs(struct pt_regs * regs)
 
         if (user_mode(regs))
                 printk(" ESP: %04x:%08lx",0xffff & regs->xss,regs->esp);
-        printk(" EFLAGS: %08lx    %s  (%s)\n",
-               regs->eflags, print_tainted(), system_utsname.release);
+        printk(" EFLAGS: %08lx    %s  (%s %.*s)\n",
+               regs->eflags, print_tainted(), system_utsname.release,
+               (int)strcspn(system_utsname.version, " "),
+               system_utsname.version);
         printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n",
                 regs->eax,regs->ebx,regs->ecx,regs->edx);
         printk("ESI: %08lx EDI: %08lx EBP: %08lx",
diff --git a/arch/i386/kernel/quirks.c b/arch/i386/kernel/quirks.c
index aaf89cb2bc51..87ccdac84928 100644
--- a/arch/i386/kernel/quirks.c
+++ b/arch/i386/kernel/quirks.c
@@ -25,8 +25,7 @@ static void __devinit quirk_intel_irqbalance(struct pci_dev *dev)
 
         /* enable access to config space*/
         pci_read_config_byte(dev, 0xf4, &config);
-        config |= 0x2;
-        pci_write_config_byte(dev, 0xf4, config);
+        pci_write_config_byte(dev, 0xf4, config|0x2);
 
         /* read xTPR register */
         raw_pci_ops->read(0, 0, 0x40, 0x4c, 2, &word);
@@ -42,9 +41,9 @@ static void __devinit quirk_intel_irqbalance(struct pci_dev *dev)
 #endif
         }
 
-        config &= ~0x2;
-        /* disable access to config space*/
-        pci_write_config_byte(dev, 0xf4, config);
+        /* put back the original value for config space*/
+        if (!(config & 0x2))
+                pci_write_config_byte(dev, 0xf4, config);
 }
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_E7320_MCH,  quirk_intel_irqbalance);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,    PCI_DEVICE_ID_INTEL_E7525_MCH,  quirk_intel_irqbalance);
diff --git a/arch/i386/kernel/signal.c b/arch/i386/kernel/signal.c
index adcd069db91e..963616d364ec 100644
--- a/arch/i386/kernel/signal.c
+++ b/arch/i386/kernel/signal.c
@@ -37,51 +37,17 @@
 asmlinkage int
 sys_sigsuspend(int history0, int history1, old_sigset_t mask)
 {
-        struct pt_regs * regs = (struct pt_regs *) &history0;
-        sigset_t saveset;
-
         mask &= _BLOCKABLE;
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         siginitset(&current->blocked, mask);
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        regs->eax = -EINTR;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(regs, &saveset))
-                        return -EINTR;
-        }
-}
-
-asmlinkage int
-sys_rt_sigsuspend(struct pt_regs regs)
-{
-        sigset_t saveset, newset;
-
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (regs.ecx != sizeof(sigset_t))
-                return -EINVAL;
-
-        if (copy_from_user(&newset, (sigset_t __user *)regs.ebx, sizeof(newset)))
-                return -EFAULT;
-        sigdelsetmask(&newset, ~_BLOCKABLE);
-
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        current->blocked = newset;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-
-        regs.eax = -EINTR;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(&regs, &saveset))
-                        return -EINTR;
-        }
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        return -ERESTARTNOHAND;
 }
 
 asmlinkage int 
@@ -433,11 +399,11 @@ static int setup_frame(int sig, struct k_sigaction *ka,
                 current->comm, current->pid, frame, regs->eip, frame->pretcode);
 #endif
 
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(sig, current);
-        return 0;
+        return -EFAULT;
 }
 
 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
@@ -527,11 +493,11 @@ static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
                 current->comm, current->pid, frame, regs->eip, frame->pretcode);
 #endif
 
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(sig, current);
-        return 0;
+        return -EFAULT;
 }
 
 /*
@@ -581,7 +547,7 @@ handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
         else
                 ret = setup_frame(sig, ka, oldset, regs);
 
-        if (ret) {
+        if (ret == 0) {
                 spin_lock_irq(&current->sighand->siglock);
                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                 if (!(ka->sa.sa_flags & SA_NODEFER))
@@ -598,11 +564,12 @@ handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  * mistake.
  */
-int fastcall do_signal(struct pt_regs *regs, sigset_t *oldset)
+static void fastcall do_signal(struct pt_regs *regs)
 {
         siginfo_t info;
         int signr;
         struct k_sigaction ka;
+        sigset_t *oldset;
 
         /*
          * We want the common case to go fast, which
@@ -613,12 +580,14 @@ int fastcall do_signal(struct pt_regs *regs, sigset_t *oldset)
          * CS suffices.
          */
         if (!user_mode(regs))
-                return 1;
+                return;
 
         if (try_to_freeze())
                 goto no_signal;
 
-        if (!oldset)
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
                 oldset = &current->blocked;
 
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
@@ -628,38 +597,55 @@ int fastcall do_signal(struct pt_regs *regs, sigset_t *oldset)
                  * have been cleared if the watchpoint triggered
                  * inside the kernel.
                  */
-                if (unlikely(current->thread.debugreg[7])) {
+                if (unlikely(current->thread.debugreg[7]))
                         set_debugreg(current->thread.debugreg[7], 7);
-                }
 
                 /* Whee!  Actually deliver the signal.  */
-                return handle_signal(signr, &info, &ka, oldset, regs);
+                if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
+                        /* a signal was successfully delivered; the saved
+                         * sigmask will have been stored in the signal frame,
+                         * and will be restored by sigreturn, so we can simply
+                         * clear the TIF_RESTORE_SIGMASK flag */
+                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                }
+
+                return;
         }
 
- no_signal:
+no_signal:
         /* Did we come from a system call? */
         if (regs->orig_eax >= 0) {
                 /* Restart the system call - no handlers present */
-                if (regs->eax == -ERESTARTNOHAND ||
-                    regs->eax == -ERESTARTSYS ||
-                    regs->eax == -ERESTARTNOINTR) {
+                switch (regs->eax) {
+                case -ERESTARTNOHAND:
+                case -ERESTARTSYS:
+                case -ERESTARTNOINTR:
                         regs->eax = regs->orig_eax;
                         regs->eip -= 2;
-                }
-                if (regs->eax == -ERESTART_RESTARTBLOCK){
+                        break;
+
+                case -ERESTART_RESTARTBLOCK:
                         regs->eax = __NR_restart_syscall;
                         regs->eip -= 2;
+                        break;
                 }
         }
-        return 0;
+
+        /* if there's no signal to deliver, we just put the saved sigmask
+         * back */
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
 
 /*
  * notification of userspace execution resumption
- * - triggered by current->work.notify_resume
+ * - triggered by the TIF_WORK_MASK flags
  */
 __attribute__((regparm(3)))
-void do_notify_resume(struct pt_regs *regs, sigset_t *oldset,
+void do_notify_resume(struct pt_regs *regs, void *_unused,
                       __u32 thread_info_flags)
 {
         /* Pending single-step? */
@@ -667,9 +653,10 @@ void do_notify_resume(struct pt_regs *regs, sigset_t *oldset,
                 regs->eflags |= TF_MASK;
                 clear_thread_flag(TIF_SINGLESTEP);
         }
+
         /* deal with pending signal delivery */
-        if (thread_info_flags & _TIF_SIGPENDING)
-                do_signal(regs,oldset);
+        if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
+                do_signal(regs);
         
         clear_thread_flag(TIF_IRET);
 }
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/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index 6ff3e5243226..ac687d00a1ce 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -294,3 +294,19 @@ ENTRY(sys_call_table)
         .long sys_inotify_add_watch
         .long sys_inotify_rm_watch
         .long sys_migrate_pages
+        .long sys_openat                /* 295 */
+        .long sys_mkdirat
+        .long sys_mknodat
+        .long sys_fchownat
+        .long sys_futimesat
+        .long sys_fstatat64             /* 300 */
+        .long sys_unlinkat
+        .long sys_renameat
+        .long sys_linkat
+        .long sys_symlinkat
+        .long sys_readlinkat            /* 305 */
+        .long sys_fchmodat
+        .long sys_faccessat
+        .long sys_pselect6
+        .long sys_ppoll
+        .long sys_unshare               /* 310 */
diff --git a/arch/i386/kernel/timers/timer_tsc.c b/arch/i386/kernel/timers/timer_tsc.c
index 591a642af884..a7f5a2aceba2 100644
--- a/arch/i386/kernel/timers/timer_tsc.c
+++ b/arch/i386/kernel/timers/timer_tsc.c
@@ -45,6 +45,15 @@ static unsigned long last_tsc_high; /* msb 32 bits of Time Stamp Counter */
 static unsigned long long monotonic_base;
 static seqlock_t monotonic_lock = SEQLOCK_UNLOCKED;
 
+/* Avoid compensating for lost ticks before TSCs are synched */
+static int detect_lost_ticks;
+static int __init start_lost_tick_compensation(void)
+{
+        detect_lost_ticks = 1;
+        return 0;
+}
+late_initcall(start_lost_tick_compensation);
+
 /* convert from cycles(64bits) => nanoseconds (64bits)
  *  basic equation:
  *              ns = cycles / (freq / ns_per_sec)
@@ -196,7 +205,8 @@ static void mark_offset_tsc_hpet(void)
 
         /* lost tick compensation */
         offset = hpet_readl(HPET_T0_CMP) - hpet_tick;
-        if (unlikely(((offset - hpet_last) > hpet_tick) && (hpet_last != 0))) {
+        if (unlikely(((offset - hpet_last) > hpet_tick) && (hpet_last != 0))
+                                        && detect_lost_ticks) {
                 int lost_ticks = (offset - hpet_last) / hpet_tick;
                 jiffies_64 += lost_ticks;
         }
@@ -426,7 +436,7 @@ static void mark_offset_tsc(void)
         delta += delay_at_last_interrupt;
         lost = delta/(1000000/HZ);
         delay = delta%(1000000/HZ);
-        if (lost >= 2) {
+        if (lost >= 2 && detect_lost_ticks) {
                 jiffies_64 += lost-1;
 
                 /* sanity check to ensure we're not always losing ticks */
diff --git a/arch/i386/kernel/traps.c b/arch/i386/kernel/traps.c
index 0aaebf3e1cfa..b814dbdcc91e 100644
--- a/arch/i386/kernel/traps.c
+++ b/arch/i386/kernel/traps.c
@@ -166,7 +166,8 @@ static void show_trace_log_lvl(struct task_struct *task,
                 stack = (unsigned long*)context->previous_esp;
                 if (!stack)
                         break;
-                printk(KERN_EMERG " =======================\n");
+                printk(log_lvl);
+                printk(" =======================\n");
         }
 }
 
@@ -239,9 +240,11 @@ void show_registers(struct pt_regs *regs)
         }
         print_modules();
         printk(KERN_EMERG "CPU:    %d\nEIP:    %04x:[<%08lx>]    %s VLI\n"
-                        "EFLAGS: %08lx   (%s) \n",
+                        "EFLAGS: %08lx   (%s %.*s) \n",
                 smp_processor_id(), 0xffff & regs->xcs, regs->eip,
-                print_tainted(), regs->eflags, system_utsname.release);
+                print_tainted(), regs->eflags, system_utsname.release,
+                (int)strcspn(system_utsname.version, " "),
+                system_utsname.version);
         print_symbol(KERN_EMERG "EIP is at %s\n", regs->eip);
         printk(KERN_EMERG "eax: %08lx   ebx: %08lx   ecx: %08lx   edx: %08lx\n",
                 regs->eax, regs->ebx, regs->ecx, regs->edx);
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/i386/oprofile/backtrace.c b/arch/i386/oprofile/backtrace.c
index 21654be3f73f..acc18138fb22 100644
--- a/arch/i386/oprofile/backtrace.c
+++ b/arch/i386/oprofile/backtrace.c
@@ -49,7 +49,9 @@ dump_backtrace(struct frame_head * head)
  * |    stack    |
  * --------------- saved regs->ebp value if valid (frame_head address)
  * .             .
- * --------------- struct pt_regs stored on stack (struct pt_regs *)
+ * --------------- saved regs->rsp value if x86_64
+ * |             |
+ * --------------- struct pt_regs * stored on stack if 32-bit
  * |             |
  * .             .
  * |             |
@@ -57,13 +59,26 @@ dump_backtrace(struct frame_head * head)
  * |             |
  * |             | \/ Lower addresses
  *
- * Thus, &pt_regs <-> stack base restricts the valid(ish) ebp values
+ * Thus, regs (or regs->rsp for x86_64) <-> stack base restricts the
+ * valid(ish) ebp values. Note: (1) for x86_64, NMI and several other
+ * exceptions use special stacks, maintained by the interrupt stack table
+ * (IST). These stacks are set up in trap_init() in
+ * arch/x86_64/kernel/traps.c. Thus, for x86_64, regs now does not point
+ * to the kernel stack; instead, it points to some location on the NMI
+ * stack. On the other hand, regs->rsp is the stack pointer saved when the
+ * NMI occurred. (2) For 32-bit, regs->esp is not valid because the
+ * processor does not save %esp on the kernel stack when interrupts occur
+ * in the kernel mode.
  */
 #ifdef CONFIG_FRAME_POINTER
 static int valid_kernel_stack(struct frame_head * head, struct pt_regs * regs)
 {
         unsigned long headaddr = (unsigned long)head;
+#ifdef CONFIG_X86_64
+        unsigned long stack = (unsigned long)regs->rsp;
+#else
         unsigned long stack = (unsigned long)regs;
+#endif
         unsigned long stack_base = (stack & ~(THREAD_SIZE - 1)) + THREAD_SIZE;
 
         return headaddr > stack && headaddr < stack_base;
diff --git a/arch/i386/pci/irq.c b/arch/i386/pci/irq.c
index e715aa930036..3ca59cad05f3 100644
--- a/arch/i386/pci/irq.c
+++ b/arch/i386/pci/irq.c
@@ -539,6 +539,11 @@ static __init int intel_router_probe(struct irq_router *r, struct pci_dev *route
                 case PCI_DEVICE_ID_INTEL_ICH7_30:
                 case PCI_DEVICE_ID_INTEL_ICH7_31:
                 case PCI_DEVICE_ID_INTEL_ESB2_0:
+                case PCI_DEVICE_ID_INTEL_ICH8_0:
+                case PCI_DEVICE_ID_INTEL_ICH8_1:
+                case PCI_DEVICE_ID_INTEL_ICH8_2:
+                case PCI_DEVICE_ID_INTEL_ICH8_3:
+                case PCI_DEVICE_ID_INTEL_ICH8_4:
                         r->name = "PIIX/ICH";
                         r->get = pirq_piix_get;
                         r->set = pirq_piix_set;
diff --git a/arch/i386/pci/mmconfig.c b/arch/i386/pci/mmconfig.c
index 4bb4d4b0f73a..0ee8a983708c 100644
--- a/arch/i386/pci/mmconfig.c
+++ b/arch/i386/pci/mmconfig.c
@@ -36,8 +36,7 @@ static u32 get_base_addr(unsigned int seg, int bus, unsigned devfn)
         while (1) {
                 ++cfg_num;
                 if (cfg_num >= pci_mmcfg_config_num) {
-                        /* Not found - fallback to type 1 */
-                        return 0;
+                        break;
                 }
                 cfg = &pci_mmcfg_config[cfg_num];
                 if (cfg->pci_segment_group_number != seg)
@@ -46,6 +45,18 @@ static u32 get_base_addr(unsigned int seg, int bus, unsigned devfn)
                     (cfg->end_bus_number >= bus))
                         return cfg->base_address;
         }
+
+        /* Handle more broken MCFG tables on Asus etc.
+           They only contain a single entry for bus 0-0. Assume
+           this applies to all busses. */
+        cfg = &pci_mmcfg_config[0];
+        if (pci_mmcfg_config_num == 1 &&
+                cfg->pci_segment_group_number == 0 &&
+                (cfg->start_bus_number | cfg->end_bus_number) == 0)
+                return cfg->base_address;
+
+        /* Fall back to type 0 */
+        return 0;
 }
 
 static inline void pci_exp_set_dev_base(unsigned int base, int bus, int devfn)
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index 199eeaf0f4e3..845cd0902a50 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -194,7 +194,6 @@ config IA64_L1_CACHE_SHIFT
         default "7" if MCKINLEY
         default "6" if ITANIUM
 
-# align cache-sensitive data to 64 bytes
 config IA64_CYCLONE
         bool "Cyclone (EXA) Time Source support"
         help
@@ -374,6 +373,9 @@ config IA64_PALINFO
           To use this option, you have to ensure that the "/proc file system
           support" (CONFIG_PROC_FS) is enabled, too.
 
+config SGI_SN
+        def_bool y if (IA64_SGI_SN2 || IA64_GENERIC)
+
 source "drivers/firmware/Kconfig"
 
 source "fs/Kconfig.binfmt"
diff --git a/arch/ia64/configs/gensparse_defconfig b/arch/ia64/configs/gensparse_defconfig
index 1d07d8072ec2..991c07b57c24 100644
--- a/arch/ia64/configs/gensparse_defconfig
+++ b/arch/ia64/configs/gensparse_defconfig
@@ -557,6 +557,7 @@ CONFIG_E100=m
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/ia64/configs/tiger_defconfig b/arch/ia64/configs/tiger_defconfig
index b1e8f09e9fd5..6859119bc9dd 100644
--- a/arch/ia64/configs/tiger_defconfig
+++ b/arch/ia64/configs/tiger_defconfig
@@ -565,6 +565,7 @@ CONFIG_E100=m
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/ia64/configs/zx1_defconfig b/arch/ia64/configs/zx1_defconfig
index 0856ca67dd50..53899dc8eb53 100644
--- a/arch/ia64/configs/zx1_defconfig
+++ b/arch/ia64/configs/zx1_defconfig
@@ -548,6 +548,7 @@ CONFIG_E100=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/ia64/defconfig b/arch/ia64/defconfig
index 275a26c6e5aa..dcbc78a4cfa4 100644
--- a/arch/ia64/defconfig
+++ b/arch/ia64/defconfig
@@ -565,6 +565,7 @@ CONFIG_E100=m
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/ia64/dig/setup.c b/arch/ia64/dig/setup.c
index d58003f1ad02..c9104bfff667 100644
--- a/arch/ia64/dig/setup.c
+++ b/arch/ia64/dig/setup.c
@@ -25,16 +25,6 @@
 #include <asm/machvec.h>
 #include <asm/system.h>
 
-/*
- * This is here so we can use the CMOS detection in ide-probe.c to
- * determine what drives are present.  In theory, we don't need this
- * as the auto-detection could be done via ide-probe.c:do_probe() but
- * in practice that would be much slower, which is painful when
- * running in the simulator.  Note that passing zeroes in DRIVE_INFO
- * is sufficient (the IDE driver will autodetect the drive geometry).
- */
-char drive_info[4*16];
-
 void __init
 dig_setup (char **cmdline_p)
 {
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/ia32/sys_ia32.c b/arch/ia64/ia32/sys_ia32.c
index 3945d378bd7e..70dba1f0e2ee 100644
--- a/arch/ia64/ia32/sys_ia32.c
+++ b/arch/ia64/ia32/sys_ia32.c
@@ -52,9 +52,9 @@
 #include <linux/compat.h>
 #include <linux/vfs.h>
 #include <linux/mman.h>
+#include <linux/mutex.h>
 
 #include <asm/intrinsics.h>
-#include <asm/semaphore.h>
 #include <asm/types.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -86,7 +86,7 @@
  * while doing so.
  */
 /* XXX make per-mm: */
-static DECLARE_MUTEX(ia32_mmap_sem);
+static DEFINE_MUTEX(ia32_mmap_mutex);
 
 asmlinkage long
 sys32_execve (char __user *name, compat_uptr_t __user *argv, compat_uptr_t __user *envp,
@@ -895,11 +895,11 @@ ia32_do_mmap (struct file *file, unsigned long addr, unsigned long len, int prot
         prot = get_prot32(prot);
 
 #if PAGE_SHIFT > IA32_PAGE_SHIFT
-        down(&ia32_mmap_sem);
+        mutex_lock(&ia32_mmap_mutex);
         {
                 addr = emulate_mmap(file, addr, len, prot, flags, offset);
         }
-        up(&ia32_mmap_sem);
+        mutex_unlock(&ia32_mmap_mutex);
 #else
         down_write(&current->mm->mmap_sem);
         {
@@ -1000,11 +1000,9 @@ sys32_munmap (unsigned int start, unsigned int len)
         if (start >= end)
                 return 0;
 
-        down(&ia32_mmap_sem);
-        {
-                ret = sys_munmap(start, end - start);
-        }
-        up(&ia32_mmap_sem);
+        mutex_lock(&ia32_mmap_mutex);
+        ret = sys_munmap(start, end - start);
+        mutex_unlock(&ia32_mmap_mutex);
 #endif
         return ret;
 }
@@ -1056,7 +1054,7 @@ sys32_mprotect (unsigned int start, unsigned int len, int prot)
         if (retval < 0)
                 return retval;
 
-        down(&ia32_mmap_sem);
+        mutex_lock(&ia32_mmap_mutex);
         {
                 if (offset_in_page(start)) {
                         /* start address is 4KB aligned but not page aligned. */
@@ -1080,7 +1078,7 @@ sys32_mprotect (unsigned int start, unsigned int len, int prot)
                 retval = sys_mprotect(start, end - start, prot);
         }
   out:
-        up(&ia32_mmap_sem);
+        mutex_unlock(&ia32_mmap_mutex);
         return retval;
 #endif
 }
@@ -1124,11 +1122,9 @@ sys32_mremap (unsigned int addr, unsigned int old_len, unsigned int new_len,
         old_len = PAGE_ALIGN(old_end) - addr;
         new_len = PAGE_ALIGN(new_end) - addr;
 
-        down(&ia32_mmap_sem);
-        {
-                ret = sys_mremap(addr, old_len, new_len, flags, new_addr);
-        }
-        up(&ia32_mmap_sem);
+        mutex_lock(&ia32_mmap_mutex);
+        ret = sys_mremap(addr, old_len, new_len, flags, new_addr);
+        mutex_unlock(&ia32_mmap_mutex);
 
         if ((ret >= 0) && (old_len < new_len)) {
                 /* mremap expanded successfully */
diff --git a/arch/ia64/kernel/Makefile b/arch/ia64/kernel/Makefile
index 307514f7a282..09a0dbc17fb6 100644
--- a/arch/ia64/kernel/Makefile
+++ b/arch/ia64/kernel/Makefile
@@ -13,6 +13,11 @@ obj-$(CONFIG_IA64_BRL_EMU)	+= brl_emu.o
 obj-$(CONFIG_IA64_GENERIC)      += acpi-ext.o
 obj-$(CONFIG_IA64_HP_ZX1)       += acpi-ext.o
 obj-$(CONFIG_IA64_HP_ZX1_SWIOTLB) += acpi-ext.o
+
+ifneq ($(CONFIG_ACPI_PROCESSOR),)
+obj-y                           += acpi-processor.o
+endif
+
 obj-$(CONFIG_IA64_PALINFO)      += palinfo.o
 obj-$(CONFIG_IOSAPIC)           += iosapic.o
 obj-$(CONFIG_MODULES)           += module.o
diff --git a/arch/ia64/kernel/acpi-ext.c b/arch/ia64/kernel/acpi-ext.c
index 13a5b3b49bf8..4a5574ff007b 100644
--- a/arch/ia64/kernel/acpi-ext.c
+++ b/arch/ia64/kernel/acpi-ext.c
@@ -33,33 +33,33 @@ acpi_vendor_resource_match(struct acpi_resource *resource, void *context)
         struct acpi_vendor_info *info = (struct acpi_vendor_info *)context;
         struct acpi_resource_vendor *vendor;
         struct acpi_vendor_descriptor *descriptor;
-        u32 length;
+        u32 byte_length;
 
-        if (resource->id != ACPI_RSTYPE_VENDOR)
+        if (resource->type != ACPI_RESOURCE_TYPE_VENDOR)
                 return AE_OK;
 
         vendor = (struct acpi_resource_vendor *)&resource->data;
-        descriptor = (struct acpi_vendor_descriptor *)vendor->reserved;
-        if (vendor->length <= sizeof(*info->descriptor) ||
+        descriptor = (struct acpi_vendor_descriptor *)vendor->byte_data;
+        if (vendor->byte_length <= sizeof(*info->descriptor) ||
             descriptor->guid_id != info->descriptor->guid_id ||
             efi_guidcmp(descriptor->guid, info->descriptor->guid))
                 return AE_OK;
 
-        length = vendor->length - sizeof(struct acpi_vendor_descriptor);
-        info->data = acpi_os_allocate(length);
+        byte_length = vendor->byte_length - sizeof(struct acpi_vendor_descriptor);
+        info->data = acpi_os_allocate(byte_length);
         if (!info->data)
                 return AE_NO_MEMORY;
 
         memcpy(info->data,
-               vendor->reserved + sizeof(struct acpi_vendor_descriptor),
-               length);
-        info->length = length;
+               vendor->byte_data + sizeof(struct acpi_vendor_descriptor),
+               byte_length);
+        info->length = byte_length;
         return AE_CTRL_TERMINATE;
 }
 
 acpi_status
 acpi_find_vendor_resource(acpi_handle obj, struct acpi_vendor_descriptor * id,
-                          u8 ** data, u32 * length)
+                          u8 ** data, u32 * byte_length)
 {
         struct acpi_vendor_info info;
 
@@ -72,7 +72,7 @@ acpi_find_vendor_resource(acpi_handle obj, struct acpi_vendor_descriptor * id,
                 return AE_NOT_FOUND;
 
         *data = info.data;
-        *length = info.length;
+        *byte_length = info.length;
         return AE_OK;
 }
 
diff --git a/arch/ia64/kernel/acpi-processor.c b/arch/ia64/kernel/acpi-processor.c
new file mode 100644
index 000000000000..e683630c8ce2
--- /dev/null
+++ b/arch/ia64/kernel/acpi-processor.c
@@ -0,0 +1,67 @@
+/*
+ * arch/ia64/kernel/cpufreq/processor.c
+ *
+ * Copyright (C) 2005 Intel Corporation
+ *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *      - Added _PDC for platforms with Intel CPUs
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+
+#include <acpi/processor.h>
+#include <asm/acpi.h>
+
+static void init_intel_pdc(struct acpi_processor *pr)
+{
+        struct acpi_object_list *obj_list;
+        union acpi_object *obj;
+        u32 *buf;
+
+        /* allocate and initialize pdc. It will be used later. */
+        obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
+        if (!obj_list) {
+                printk(KERN_ERR "Memory allocation error\n");
+                return;
+        }
+
+        obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
+        if (!obj) {
+                printk(KERN_ERR "Memory allocation error\n");
+                kfree(obj_list);
+                return;
+        }
+
+        buf = kmalloc(12, GFP_KERNEL);
+        if (!buf) {
+                printk(KERN_ERR "Memory allocation error\n");
+                kfree(obj);
+                kfree(obj_list);
+                return;
+        }
+
+        buf[0] = ACPI_PDC_REVISION_ID;
+        buf[1] = 1;
+        buf[2] |= ACPI_PDC_EST_CAPABILITY_SMP;
+
+        obj->type = ACPI_TYPE_BUFFER;
+        obj->buffer.length = 12;
+        obj->buffer.pointer = (u8 *) buf;
+        obj_list->count = 1;
+        obj_list->pointer = obj;
+        pr->pdc = obj_list;
+
+        return;
+}
+
+/* Initialize _PDC data based on the CPU vendor */
+void arch_acpi_processor_init_pdc(struct acpi_processor *pr)
+{
+        pr->pdc = NULL;
+        init_intel_pdc(pr);
+        return;
+}
+
+EXPORT_SYMBOL(arch_acpi_processor_init_pdc);
diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 9ad94ddf6687..d2702c419cf8 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -567,16 +567,16 @@ void __init acpi_numa_arch_fixup(void)
  * success: return IRQ number (>=0)
  * failure: return < 0
  */
-int acpi_register_gsi(u32 gsi, int edge_level, int active_high_low)
+int acpi_register_gsi(u32 gsi, int triggering, int polarity)
 {
         if (has_8259 && gsi < 16)
                 return isa_irq_to_vector(gsi);
 
         return iosapic_register_intr(gsi,
-                                     (active_high_low ==
+                                     (polarity ==
                                       ACPI_ACTIVE_HIGH) ? IOSAPIC_POL_HIGH :
                                      IOSAPIC_POL_LOW,
-                                     (edge_level ==
+                                     (triggering ==
                                       ACPI_EDGE_SENSITIVE) ? IOSAPIC_EDGE :
                                      IOSAPIC_LEVEL);
 }
diff --git a/arch/ia64/kernel/cpufreq/Makefile b/arch/ia64/kernel/cpufreq/Makefile
index f748d34c02f0..4838f2a57c7a 100644
--- a/arch/ia64/kernel/cpufreq/Makefile
+++ b/arch/ia64/kernel/cpufreq/Makefile
@@ -1 +1,2 @@
 obj-$(CONFIG_IA64_ACPI_CPUFREQ)         += acpi-cpufreq.o
+
diff --git a/arch/ia64/kernel/cpufreq/acpi-cpufreq.c b/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
index da4d5cf80a48..5a1bf815282d 100644
--- a/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
+++ b/arch/ia64/kernel/cpufreq/acpi-cpufreq.c
@@ -269,48 +269,6 @@ acpi_cpufreq_verify (
 }
 
 
-/*
- * processor_init_pdc - let BIOS know about the SMP capabilities
- * of this driver
- * @perf: processor-specific acpi_io_data struct
- * @cpu: CPU being initialized
- *
- * To avoid issues with legacy OSes, some BIOSes require to be informed of
- * the SMP capabilities of OS P-state driver. Here we set the bits in _PDC
- * accordingly. Actual call to _PDC is done in driver/acpi/processor.c
- */
-static void
-processor_init_pdc (
-                struct acpi_processor_performance *perf,
-                unsigned int cpu,
-                struct acpi_object_list *obj_list
-                )
-{
-        union acpi_object *obj;
-        u32 *buf;
-
-        dprintk("processor_init_pdc\n");
-
-        perf->pdc = NULL;
-        /* Initialize pdc. It will be used later. */
-        if (!obj_list)
-                return;
-
-        if (!(obj_list->count && obj_list->pointer))
-                return;
-
-        obj = obj_list->pointer;
-        if ((obj->buffer.length == 12) && obj->buffer.pointer) {
-                buf = (u32 *)obj->buffer.pointer;
-                buf[0] = ACPI_PDC_REVISION_ID;
-                buf[1] = 1;
-                buf[2] = ACPI_PDC_EST_CAPABILITY_SMP;
-                perf->pdc = obj_list;
-        }
-        return;
-}
-
-
 static int
 acpi_cpufreq_cpu_init (
         struct cpufreq_policy   *policy)
@@ -320,14 +278,7 @@ acpi_cpufreq_cpu_init (
         struct cpufreq_acpi_io  *data;
         unsigned int            result = 0;
 
-        union acpi_object               arg0 = {ACPI_TYPE_BUFFER};
-        u32                             arg0_buf[3];
-        struct acpi_object_list         arg_list = {1, &arg0};
-
         dprintk("acpi_cpufreq_cpu_init\n");
-        /* setup arg_list for _PDC settings */
-        arg0.buffer.length = 12;
-        arg0.buffer.pointer = (u8 *) arg0_buf;
 
         data = kmalloc(sizeof(struct cpufreq_acpi_io), GFP_KERNEL);
         if (!data)
@@ -337,9 +288,7 @@ acpi_cpufreq_cpu_init (
 
         acpi_io_data[cpu] = data;
 
-        processor_init_pdc(&data->acpi_data, cpu, &arg_list);
         result = acpi_processor_register_performance(&data->acpi_data, cpu);
-        data->acpi_data.pdc = NULL;
 
         if (result)
                 goto err_free;
diff --git a/arch/ia64/kernel/efi.c b/arch/ia64/kernel/efi.c
index c485a3b32ba8..9990320b6f9a 100644
--- a/arch/ia64/kernel/efi.c
+++ b/arch/ia64/kernel/efi.c
@@ -410,24 +410,16 @@ efi_init (void)
         efi_config_table_t *config_tables;
         efi_char16_t *c16;
         u64 efi_desc_size;
-        char *cp, *end, vendor[100] = "unknown";
+        char *cp, vendor[100] = "unknown";
         extern char saved_command_line[];
         int i;
 
         /* it's too early to be able to use the standard kernel command line support... */
         for (cp = saved_command_line; *cp; ) {
                 if (memcmp(cp, "mem=", 4) == 0) {
-                        cp += 4;
-                        mem_limit = memparse(cp, &end);
-                        if (end != cp)
-                                break;
-                        cp = end;
+                        mem_limit = memparse(cp + 4, &cp);
                 } else if (memcmp(cp, "max_addr=", 9) == 0) {
-                        cp += 9;
-                        max_addr = GRANULEROUNDDOWN(memparse(cp, &end));
-                        if (end != cp)
-                                break;
-                        cp = end;
+                        max_addr = GRANULEROUNDDOWN(memparse(cp + 9, &cp));
                 } else {
                         while (*cp != ' ' && *cp)
                                 ++cp;
@@ -458,7 +450,7 @@ efi_init (void)
         /* Show what we know for posterity */
         c16 = __va(efi.systab->fw_vendor);
         if (c16) {
-                for (i = 0;i < (int) sizeof(vendor) && *c16; ++i)
+                for (i = 0;i < (int) sizeof(vendor) - 1 && *c16; ++i)
                         vendor[i] = *c16++;
                 vendor[i] = '\0';
         }
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/head.S b/arch/ia64/kernel/head.S
index fbc7ea35dd57..f1778a84ea61 100644
--- a/arch/ia64/kernel/head.S
+++ b/arch/ia64/kernel/head.S
@@ -352,6 +352,7 @@ start_ap:
         mov ar.rsc=0            // place RSE in enforced lazy mode
         ;;
         loadrs                  // clear the dirty partition
+        mov IA64_KR(PER_CPU_DATA)=r0    // clear physical per-CPU base
         ;;
         mov ar.bspstore=r2      // establish the new RSE stack
         ;;
diff --git a/arch/ia64/kernel/mca_asm.S b/arch/ia64/kernel/mca_asm.S
index 403a80a58c13..60a464bfd9e2 100644
--- a/arch/ia64/kernel/mca_asm.S
+++ b/arch/ia64/kernel/mca_asm.S
@@ -512,7 +512,7 @@ ia64_state_save:
         st8 [temp1]=r12         // os_status, default is cold boot
         mov r6=IA64_MCA_SAME_CONTEXT
         ;;
-        st8 [temp1]=r6          // context, default is same context
+        st8 [temp2]=r6          // context, default is same context
 
         // Save the pt_regs data that is not in minstate.  The previous code
         // left regs at sos.
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/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index 2ea4b39efffa..9c5194b385da 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -40,6 +40,7 @@
 #include <linux/bitops.h>
 #include <linux/capability.h>
 #include <linux/rcupdate.h>
+#include <linux/completion.h>
 
 #include <asm/errno.h>
 #include <asm/intrinsics.h>
@@ -286,7 +287,7 @@ typedef struct pfm_context {
 
         unsigned long           ctx_ovfl_regs[4];       /* which registers overflowed (notification) */
 
-        struct semaphore        ctx_restart_sem;        /* use for blocking notification mode */
+        struct completion       ctx_restart_done;       /* use for blocking notification mode */
 
         unsigned long           ctx_used_pmds[4];       /* bitmask of PMD used            */
         unsigned long           ctx_all_pmds[4];        /* bitmask of all accessible PMDs */
@@ -1991,7 +1992,7 @@ pfm_close(struct inode *inode, struct file *filp)
                 /*
                  * force task to wake up from MASKED state
                  */
-                up(&ctx->ctx_restart_sem);
+                complete(&ctx->ctx_restart_done);
 
                 DPRINT(("waking up ctx_state=%d\n", state));
 
@@ -2706,7 +2707,7 @@ pfm_context_create(pfm_context_t *ctx, void *arg, int count, struct pt_regs *reg
         /*
          * init restart semaphore to locked
          */
-        sema_init(&ctx->ctx_restart_sem, 0);
+        init_completion(&ctx->ctx_restart_done);
 
         /*
          * activation is used in SMP only
@@ -3687,7 +3688,7 @@ pfm_restart(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
          */
         if (CTX_OVFL_NOBLOCK(ctx) == 0 && state == PFM_CTX_MASKED) {
                 DPRINT(("unblocking [%d] \n", task->pid));
-                up(&ctx->ctx_restart_sem);
+                complete(&ctx->ctx_restart_done);
         } else {
                 DPRINT(("[%d] armed exit trap\n", task->pid));
 
@@ -5089,7 +5090,7 @@ pfm_handle_work(void)
          * may go through without blocking on SMP systems
          * if restart has been received already by the time we call down()
          */
-        ret = down_interruptible(&ctx->ctx_restart_sem);
+        ret = wait_for_completion_interruptible(&ctx->ctx_restart_done);
 
         DPRINT(("after block sleeping ret=%d\n", ret));
 
diff --git a/arch/ia64/kernel/sal.c b/arch/ia64/kernel/sal.c
index acc0f132f86c..056f7a6eedc7 100644
--- a/arch/ia64/kernel/sal.c
+++ b/arch/ia64/kernel/sal.c
@@ -14,6 +14,7 @@
 #include <linux/spinlock.h>
 #include <linux/string.h>
 
+#include <asm/delay.h>
 #include <asm/page.h>
 #include <asm/sal.h>
 #include <asm/pal.h>
@@ -214,6 +215,78 @@ chk_nointroute_opt(void)
 static void __init sal_desc_ap_wakeup(void *p) { }
 #endif
 
+/*
+ * HP rx5670 firmware polls for interrupts during SAL_CACHE_FLUSH by reading
+ * cr.ivr, but it never writes cr.eoi.  This leaves any interrupt marked as
+ * "in-service" and masks other interrupts of equal or lower priority.
+ *
+ * HP internal defect reports: F1859, F2775, F3031.
+ */
+static int sal_cache_flush_drops_interrupts;
+
+static void __init
+check_sal_cache_flush (void)
+{
+        unsigned long flags, itv;
+        int cpu;
+        u64 vector;
+
+        cpu = get_cpu();
+        local_irq_save(flags);
+
+        /*
+         * Schedule a timer interrupt, wait until it's reported, and see if
+         * SAL_CACHE_FLUSH drops it.
+         */
+        itv = ia64_get_itv();
+        BUG_ON((itv & (1 << 16)) == 0);
+
+        ia64_set_itv(IA64_TIMER_VECTOR);
+        ia64_set_itm(ia64_get_itc() + 1000);
+
+        while (!ia64_get_irr(IA64_TIMER_VECTOR))
+                cpu_relax();
+
+        ia64_sal_cache_flush(3);
+
+        if (ia64_get_irr(IA64_TIMER_VECTOR)) {
+                vector = ia64_get_ivr();
+                ia64_eoi();
+                WARN_ON(vector != IA64_TIMER_VECTOR);
+        } else {
+                sal_cache_flush_drops_interrupts = 1;
+                printk(KERN_ERR "SAL: SAL_CACHE_FLUSH drops interrupts; "
+                        "PAL_CACHE_FLUSH will be used instead\n");
+                ia64_eoi();
+        }
+
+        ia64_set_itv(itv);
+        local_irq_restore(flags);
+        put_cpu();
+}
+
+s64
+ia64_sal_cache_flush (u64 cache_type)
+{
+        struct ia64_sal_retval isrv;
+
+        if (sal_cache_flush_drops_interrupts) {
+                unsigned long flags;
+                u64 progress;
+                s64 rc;
+
+                progress = 0;
+                local_irq_save(flags);
+                rc = ia64_pal_cache_flush(cache_type,
+                        PAL_CACHE_FLUSH_INVALIDATE, &progress, NULL);
+                local_irq_restore(flags);
+                return rc;
+        }
+
+        SAL_CALL(isrv, SAL_CACHE_FLUSH, cache_type, 0, 0, 0, 0, 0, 0);
+        return isrv.status;
+}
+
 void __init
 ia64_sal_init (struct ia64_sal_systab *systab)
 {
@@ -262,6 +335,8 @@ ia64_sal_init (struct ia64_sal_systab *systab)
                 }
                 p += SAL_DESC_SIZE(*p);
         }
+
+        check_sal_cache_flush();
 }
 
 int
diff --git a/arch/ia64/kernel/setup.c b/arch/ia64/kernel/setup.c
index c0766575a3a2..35f7835294a3 100644
--- a/arch/ia64/kernel/setup.c
+++ b/arch/ia64/kernel/setup.c
@@ -71,6 +71,8 @@ unsigned long __per_cpu_offset[NR_CPUS];
 EXPORT_SYMBOL(__per_cpu_offset);
 #endif
 
+extern void ia64_setup_printk_clock(void);
+
 DEFINE_PER_CPU(struct cpuinfo_ia64, cpu_info);
 DEFINE_PER_CPU(unsigned long, local_per_cpu_offset);
 DEFINE_PER_CPU(unsigned long, ia64_phys_stacked_size_p8);
@@ -445,6 +447,8 @@ setup_arch (char **cmdline_p)
         /* process SAL system table: */
         ia64_sal_init(efi.sal_systab);
 
+        ia64_setup_printk_clock();
+
 #ifdef CONFIG_SMP
         cpu_physical_id(0) = hard_smp_processor_id();
 
diff --git a/arch/ia64/kernel/time.c b/arch/ia64/kernel/time.c
index 028a2b95936c..a094ec49ccfa 100644
--- a/arch/ia64/kernel/time.c
+++ b/arch/ia64/kernel/time.c
@@ -278,3 +278,30 @@ udelay (unsigned long usecs)
         }
 }
 EXPORT_SYMBOL(udelay);
+
+static unsigned long long ia64_itc_printk_clock(void)
+{
+        if (ia64_get_kr(IA64_KR_PER_CPU_DATA))
+                return sched_clock();
+        return 0;
+}
+
+static unsigned long long ia64_default_printk_clock(void)
+{
+        return (unsigned long long)(jiffies_64 - INITIAL_JIFFIES) *
+                (1000000000/HZ);
+}
+
+unsigned long long (*ia64_printk_clock)(void) = &ia64_default_printk_clock;
+
+unsigned long long printk_clock(void)
+{
+        return ia64_printk_clock();
+}
+
+void __init
+ia64_setup_printk_clock(void)
+{
+        if (!(sal_platform_features & IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT))
+                ia64_printk_clock = ia64_itc_printk_clock;
+}
diff --git a/arch/ia64/kernel/topology.c b/arch/ia64/kernel/topology.c
index 706b7734e191..6e5eea19fa67 100644
--- a/arch/ia64/kernel/topology.c
+++ b/arch/ia64/kernel/topology.c
@@ -71,31 +71,33 @@ static int __init topology_init(void)
         int i, err = 0;
 
 #ifdef CONFIG_NUMA
-        sysfs_nodes = kmalloc(sizeof(struct node) * MAX_NUMNODES, GFP_KERNEL);
+        sysfs_nodes = kzalloc(sizeof(struct node) * MAX_NUMNODES, GFP_KERNEL);
         if (!sysfs_nodes) {
                 err = -ENOMEM;
                 goto out;
         }
-        memset(sysfs_nodes, 0, sizeof(struct node) * MAX_NUMNODES);
 
-        /* MCD - Do we want to register all ONLINE nodes, or all POSSIBLE nodes? */
-        for_each_online_node(i)
+        /*
+         * MCD - Do we want to register all ONLINE nodes, or all POSSIBLE nodes?
+         */
+        for_each_online_node(i) {
                 if ((err = register_node(&sysfs_nodes[i], i, 0)))
                         goto out;
+        }
 #endif
 
-        sysfs_cpus = kmalloc(sizeof(struct ia64_cpu) * NR_CPUS, GFP_KERNEL);
+        sysfs_cpus = kzalloc(sizeof(struct ia64_cpu) * NR_CPUS, GFP_KERNEL);
         if (!sysfs_cpus) {
                 err = -ENOMEM;
                 goto out;
         }
-        memset(sysfs_cpus, 0, sizeof(struct ia64_cpu) * NR_CPUS);
 
-        for_each_present_cpu(i)
+        for_each_present_cpu(i) {
                 if((err = arch_register_cpu(i)))
                         goto out;
+        }
 out:
         return err;
 }
 
-__initcall(topology_init);
+subsys_initcall(topology_init);
diff --git a/arch/ia64/kernel/unaligned.c b/arch/ia64/kernel/unaligned.c
index 43b45b65ee5a..f9e0ae936d1a 100644
--- a/arch/ia64/kernel/unaligned.c
+++ b/arch/ia64/kernel/unaligned.c
@@ -1283,8 +1283,9 @@ within_logging_rate_limit (void)
 
         if (jiffies - last_time > 5*HZ)
                 count = 0;
-        if (++count < 5) {
+        if (count < 5) {
                 last_time = jiffies;
+                count++;
                 return 1;
         }
         return 0;
diff --git a/arch/ia64/kernel/uncached.c b/arch/ia64/kernel/uncached.c
index b631cf86ed44..fcd2bad0286f 100644
--- a/arch/ia64/kernel/uncached.c
+++ b/arch/ia64/kernel/uncached.c
@@ -210,6 +210,7 @@ uncached_build_memmap(unsigned long start, unsigned long end, void *arg)
 
         dprintk(KERN_ERR "uncached_build_memmap(%lx %lx)\n", start, end);
 
+        touch_softlockup_watchdog();
         memset((char *)start, 0, length);
 
         node = paddr_to_nid(start - __IA64_UNCACHED_OFFSET);
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index d27ecdcb6fca..0b30ca006286 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -193,12 +193,12 @@ add_io_space (struct pci_root_info *info, struct acpi_resource_address64 *addr)
                 goto free_resource;
         }
 
-        min = addr->min_address_range;
+        min = addr->minimum;
         max = min + addr->address_length - 1;
-        if (addr->attribute.io.translation_attribute == ACPI_SPARSE_TRANSLATION)
+        if (addr->info.io.translation_type == ACPI_SPARSE_TRANSLATION)
                 sparse = 1;
 
-        space_nr = new_space(addr->address_translation_offset, sparse);
+        space_nr = new_space(addr->translation_offset, sparse);
         if (space_nr == ~0)
                 goto free_name;
 
@@ -285,7 +285,7 @@ static __devinit acpi_status add_window(struct acpi_resource *res, void *data)
         if (addr.resource_type == ACPI_MEMORY_RANGE) {
                 flags = IORESOURCE_MEM;
                 root = &iomem_resource;
-                offset = addr.address_translation_offset;
+                offset = addr.translation_offset;
         } else if (addr.resource_type == ACPI_IO_RANGE) {
                 flags = IORESOURCE_IO;
                 root = &ioport_resource;
@@ -298,7 +298,7 @@ static __devinit acpi_status add_window(struct acpi_resource *res, void *data)
         window = &info->controller->window[info->controller->windows++];
         window->resource.name = info->name;
         window->resource.flags = flags;
-        window->resource.start = addr.min_address_range + offset;
+        window->resource.start = addr.minimum + offset;
         window->resource.end = window->resource.start + addr.address_length - 1;
         window->resource.child = NULL;
         window->offset = offset;
diff --git a/arch/ia64/sn/Makefile b/arch/ia64/sn/Makefile
index a269f6d84c29..79a7df02e812 100644
--- a/arch/ia64/sn/Makefile
+++ b/arch/ia64/sn/Makefile
@@ -9,6 +9,4 @@
 # Makefile for the sn ia64 subplatform
 #
 
-CPPFLAGS += -I$(srctree)/arch/ia64/sn/include
-
 obj-y += kernel/ pci/
diff --git a/arch/ia64/sn/include/xtalk/hubdev.h b/arch/ia64/sn/include/xtalk/hubdev.h
index 7c88e9a58516..8182583c762c 100644
--- a/arch/ia64/sn/include/xtalk/hubdev.h
+++ b/arch/ia64/sn/include/xtalk/hubdev.h
@@ -51,6 +51,15 @@ struct sn_flush_device_kernel {
         struct sn_flush_device_common *common;
 };
 
+/* 01/16/06 This struct is the old PROM/kernel struct and needs to be included
+ * for older official PROMs to function on the new kernel base.  This struct
+ * will be removed when the next official PROM release occurs. */
+
+struct sn_flush_device_war {
+        struct sn_flush_device_common common;
+        u32 filler; /* older PROMs expect the default size of a spinlock_t */
+};
+
 /*
  * **widget_p - Used as an array[wid_num][device] of sn_flush_device_kernel.
  */
diff --git a/arch/ia64/sn/kernel/Makefile b/arch/ia64/sn/kernel/Makefile
index 4351c4ff9845..3e9b4eea7418 100644
--- a/arch/ia64/sn/kernel/Makefile
+++ b/arch/ia64/sn/kernel/Makefile
@@ -7,6 +7,8 @@
 # Copyright (C) 1999,2001-2005 Silicon Graphics, Inc.  All Rights Reserved.
 #
 
+CPPFLAGS += -I$(srctree)/arch/ia64/sn/include
+
 obj-y                           += setup.o bte.o bte_error.o irq.o mca.o idle.o \
                                    huberror.o io_init.o iomv.o klconflib.o sn2/
 obj-$(CONFIG_IA64_GENERIC)      += machvec.o
diff --git a/arch/ia64/sn/kernel/bte.c b/arch/ia64/sn/kernel/bte.c
index dd73c0cb754b..1f11db470d90 100644
--- a/arch/ia64/sn/kernel/bte.c
+++ b/arch/ia64/sn/kernel/bte.c
@@ -3,7 +3,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.  All Rights Reserved.
  */
 
 #include <linux/config.h>
@@ -186,18 +186,13 @@ retry_bteop:
 
         /* Initialize the notification to a known value. */
         *bte->most_rcnt_na = BTE_WORD_BUSY;
-        notif_phys_addr = TO_PHYS(ia64_tpa((unsigned long)bte->most_rcnt_na));
+        notif_phys_addr = (u64)bte->most_rcnt_na;
 
-        if (is_shub2()) {
-                src = SH2_TIO_PHYS_TO_DMA(src);
-                dest = SH2_TIO_PHYS_TO_DMA(dest);
-                notif_phys_addr = SH2_TIO_PHYS_TO_DMA(notif_phys_addr);
-        }
         /* Set the source and destination registers */
-        BTE_PRINTKV(("IBSA = 0x%lx)\n", (TO_PHYS(src))));
-        BTE_SRC_STORE(bte, TO_PHYS(src));
-        BTE_PRINTKV(("IBDA = 0x%lx)\n", (TO_PHYS(dest))));
-        BTE_DEST_STORE(bte, TO_PHYS(dest));
+        BTE_PRINTKV(("IBSA = 0x%lx)\n", src));
+        BTE_SRC_STORE(bte, src);
+        BTE_PRINTKV(("IBDA = 0x%lx)\n", dest));
+        BTE_DEST_STORE(bte, dest);
 
         /* Set the notification register */
         BTE_PRINTKV(("IBNA = 0x%lx)\n", notif_phys_addr));
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index 233d55115d33..3437c2390429 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -10,6 +10,7 @@
 #include <linux/nodemask.h>
 #include <asm/sn/types.h>
 #include <asm/sn/addrs.h>
+#include <asm/sn/sn_feature_sets.h>
 #include <asm/sn/geo.h>
 #include <asm/sn/io.h>
 #include <asm/sn/pcibr_provider.h>
@@ -165,11 +166,49 @@ sn_pcidev_info_get(struct pci_dev *dev)
         return NULL;
 }
 
+/* Older PROM flush WAR
+ *
+ * 01/16/06 -- This war will be in place until a new official PROM is released.
+ * Additionally note that the struct sn_flush_device_war also has to be
+ * removed from arch/ia64/sn/include/xtalk/hubdev.h
+ */
+static u8 war_implemented = 0;
+
+static s64 sn_device_fixup_war(u64 nasid, u64 widget, int device,
+                               struct sn_flush_device_common *common)
+{
+        struct sn_flush_device_war *war_list;
+        struct sn_flush_device_war *dev_entry;
+        struct ia64_sal_retval isrv = {0,0,0,0};
+
+        if (!war_implemented) {
+                printk(KERN_WARNING "PROM version < 4.50 -- implementing old "
+                       "PROM flush WAR\n");
+                war_implemented = 1;
+        }
+
+        war_list = kzalloc(DEV_PER_WIDGET * sizeof(*war_list), GFP_KERNEL);
+        if (!war_list)
+                BUG();
+
+        SAL_CALL_NOLOCK(isrv, SN_SAL_IOIF_GET_WIDGET_DMAFLUSH_LIST,
+                        nasid, widget, __pa(war_list), 0, 0, 0 ,0);
+        if (isrv.status)
+                panic("sn_device_fixup_war failed: %s\n",
+                      ia64_sal_strerror(isrv.status));
+
+        dev_entry = war_list + device;
+        memcpy(common,dev_entry, sizeof(*common));
+        kfree(war_list);
+
+        return isrv.status;
+}
+
 /*
- * sn_fixup_ionodes() - This routine initializes the HUB data strcuture for 
+ * sn_fixup_ionodes() - This routine initializes the HUB data strcuture for
  *      each node in the system.
  */
-static void sn_fixup_ionodes(void)
+static void __init sn_fixup_ionodes(void)
 {
         struct sn_flush_device_kernel *sn_flush_device_kernel;
         struct sn_flush_device_kernel *dev_entry;
@@ -242,12 +281,21 @@ static void sn_fixup_ionodes(void)
                                 memset(dev_entry->common, 0x0, sizeof(struct
                                                        sn_flush_device_common));
 
-                                status = sal_get_device_dmaflush_list(nasid,
-                                                                        widget,
-                                                                        device,
+                                if (sn_prom_feature_available(
+                                                       PRF_DEVICE_FLUSH_LIST))
+                                        status = sal_get_device_dmaflush_list(
+                                                                          nasid,
+                                                                         widget,
+                                                                         device,
                                                       (u64)(dev_entry->common));
-                                if (status)
-                                        BUG();
+                                else
+                                        status = sn_device_fixup_war(nasid,
+                                                                     widget,
+                                                                     device,
+                                                             dev_entry->common);
+                                if (status != SALRET_OK)
+                                        panic("SAL call failed: %s\n",
+                                              ia64_sal_strerror(status));
 
                                 spin_lock_init(&dev_entry->sfdl_flush_lock);
                         }
@@ -419,6 +467,13 @@ void sn_pci_fixup_slot(struct pci_dev *dev)
                 pcidev_info->pdi_sn_irq_info = NULL;
                 kfree(sn_irq_info);
         }
+
+        /*
+         * MSI currently not supported on altix.  Remove this when
+         * the MSI abstraction patches are integrated into the kernel
+         * (sometime after 2.6.16 releases)
+         */
+        dev->no_msi = 1;
 }
 
 /*
@@ -562,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 ec37084bdc17..c373113d073a 100644
--- a/arch/ia64/sn/kernel/irq.c
+++ b/arch/ia64/sn/kernel/irq.c
@@ -5,11 +5,12 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.  All Rights Reserved.
  */
 
 #include <linux/irq.h>
 #include <linux/spinlock.h>
+#include <linux/init.h>
 #include <asm/sn/addrs.h>
 #include <asm/sn/arch.h>
 #include <asm/sn/intr.h>
@@ -76,17 +77,15 @@ static void sn_enable_irq(unsigned int irq)
 
 static void sn_ack_irq(unsigned int irq)
 {
-        u64 event_occurred, mask = 0;
+        u64 event_occurred, mask;
 
         irq = irq & 0xff;
-        event_occurred =
-            HUB_L((u64*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED));
+        event_occurred = HUB_L((u64*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED));
         mask = event_occurred & SH_ALL_INT_MASK;
-        HUB_S((u64*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED_ALIAS),
-              mask);
+        HUB_S((u64*)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED_ALIAS), mask);
         __set_bit(irq, (volatile void *)pda->sn_in_service_ivecs);
 
-        move_irq(irq);
+        move_native_irq(irq);
 }
 
 static void sn_end_irq(unsigned int irq)
@@ -219,9 +218,8 @@ static void register_intr_pda(struct sn_irq_info *sn_irq_info)
                 pdacpu(cpu)->sn_last_irq = irq;
         }
 
-        if (pdacpu(cpu)->sn_first_irq == 0 || pdacpu(cpu)->sn_first_irq > irq) {
+        if (pdacpu(cpu)->sn_first_irq == 0 || pdacpu(cpu)->sn_first_irq > irq)
                 pdacpu(cpu)->sn_first_irq = irq;
-        }
 }
 
 static void unregister_intr_pda(struct sn_irq_info *sn_irq_info)
@@ -289,7 +287,7 @@ void sn_irq_fixup(struct pci_dev *pci_dev, struct sn_irq_info *sn_irq_info)
         list_add_rcu(&sn_irq_info->list, sn_irq_lh[sn_irq_info->irq_irq]);
         spin_unlock(&sn_irq_info_lock);
 
-        (void)register_intr_pda(sn_irq_info);
+        register_intr_pda(sn_irq_info);
 }
 
 void sn_irq_unfixup(struct pci_dev *pci_dev)
@@ -301,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;
         }
@@ -419,7 +419,7 @@ void sn_lb_int_war_check(void)
         rcu_read_unlock();
 }
 
-void sn_irq_lh_init(void)
+void __init sn_irq_lh_init(void)
 {
         int i;
 
@@ -434,5 +434,4 @@ void sn_irq_lh_init(void)
 
                 INIT_LIST_HEAD(sn_irq_lh[i]);
         }
-
 }
diff --git a/arch/ia64/sn/kernel/klconflib.c b/arch/ia64/sn/kernel/klconflib.c
index 0f11a3299cd2..87682b48ef83 100644
--- a/arch/ia64/sn/kernel/klconflib.c
+++ b/arch/ia64/sn/kernel/klconflib.c
@@ -78,31 +78,30 @@ format_module_id(char *buffer, moduleid_t m, int fmt)
         position = MODULE_GET_BPOS(m);
 
         if ((fmt == MODULE_FORMAT_BRIEF) || (fmt == MODULE_FORMAT_LCD)) {
-            /* Brief module number format, eg. 002c15 */
+                /* Brief module number format, eg. 002c15 */
 
-            /* Decompress the rack number */
-            *buffer++ = '0' + RACK_GET_CLASS(rack);
-            *buffer++ = '0' + RACK_GET_GROUP(rack);
-            *buffer++ = '0' + RACK_GET_NUM(rack);
+                /* Decompress the rack number */
+                *buffer++ = '0' + RACK_GET_CLASS(rack);
+                *buffer++ = '0' + RACK_GET_GROUP(rack);
+                *buffer++ = '0' + RACK_GET_NUM(rack);
 
-            /* Add the brick type */
-            *buffer++ = brickchar;
+                /* Add the brick type */
+                *buffer++ = brickchar;
         }
         else if (fmt == MODULE_FORMAT_LONG) {
-            /* Fuller hwgraph format, eg. rack/002/bay/15 */
+                /* Fuller hwgraph format, eg. rack/002/bay/15 */
 
-            strcpy(buffer, "rack" "/");  buffer += strlen(buffer);
+                strcpy(buffer, "rack" "/");  buffer += strlen(buffer);
 
-            *buffer++ = '0' + RACK_GET_CLASS(rack);
-            *buffer++ = '0' + RACK_GET_GROUP(rack);
-            *buffer++ = '0' + RACK_GET_NUM(rack);
+                *buffer++ = '0' + RACK_GET_CLASS(rack);
+                *buffer++ = '0' + RACK_GET_GROUP(rack);
+                *buffer++ = '0' + RACK_GET_NUM(rack);
 
-            strcpy(buffer, "/" "bay" "/");  buffer += strlen(buffer);
+                strcpy(buffer, "/" "bay" "/");  buffer += strlen(buffer);
         }
 
         /* Add the bay position, using at least two digits */
         if (position < 10)
-            *buffer++ = '0';
+                *buffer++ = '0';
         sprintf(buffer, "%d", position);
-
 }
diff --git a/arch/ia64/sn/kernel/mca.c b/arch/ia64/sn/kernel/mca.c
index 6546db6abdba..3db62f24596c 100644
--- a/arch/ia64/sn/kernel/mca.c
+++ b/arch/ia64/sn/kernel/mca.c
@@ -3,13 +3,14 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (c) 2000-2004 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.  All Rights Reserved.
  */
 
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/timer.h>
 #include <linux/vmalloc.h>
+#include <linux/mutex.h>
 #include <asm/mca.h>
 #include <asm/sal.h>
 #include <asm/sn/sn_sal.h>
@@ -27,7 +28,7 @@ void sn_init_cpei_timer(void);
 /* Printing oemdata from mca uses data that is not passed through SAL, it is
  * global.  Only one user at a time.
  */
-static DECLARE_MUTEX(sn_oemdata_mutex);
+static DEFINE_MUTEX(sn_oemdata_mutex);
 static u8 **sn_oemdata;
 static u64 *sn_oemdata_size, sn_oemdata_bufsize;
 
@@ -89,7 +90,7 @@ static int
 sn_platform_plat_specific_err_print(const u8 * sect_header, u8 ** oemdata,
                                     u64 * oemdata_size)
 {
-        down(&sn_oemdata_mutex);
+        mutex_lock(&sn_oemdata_mutex);
         sn_oemdata = oemdata;
         sn_oemdata_size = oemdata_size;
         sn_oemdata_bufsize = 0;
@@ -107,7 +108,7 @@ sn_platform_plat_specific_err_print(const u8 * sect_header, u8 ** oemdata,
                 *sn_oemdata_size = 0;
                 ia64_sn_plat_specific_err_print(print_hook, (char *)sect_header);
         }
-        up(&sn_oemdata_mutex);
+        mutex_unlock(&sn_oemdata_mutex);
         return 0;
 }
 
@@ -136,7 +137,8 @@ int sn_salinfo_platform_oemdata(const u8 *sect_header, u8 **oemdata, u64 *oemdat
 
 static int __init sn_salinfo_init(void)
 {
-        salinfo_platform_oemdata = &sn_salinfo_platform_oemdata;
+        if (ia64_platform_is("sn2"))
+                salinfo_platform_oemdata = &sn_salinfo_platform_oemdata;
         return 0;
 }
 
diff --git a/arch/ia64/sn/kernel/setup.c b/arch/ia64/sn/kernel/setup.c
index e510dce9971f..48645ac120fc 100644
--- a/arch/ia64/sn/kernel/setup.c
+++ b/arch/ia64/sn/kernel/setup.c
@@ -67,6 +67,7 @@ extern unsigned long last_time_offset;
 extern void (*ia64_mark_idle) (int);
 extern void snidle(int);
 extern unsigned char acpi_kbd_controller_present;
+extern unsigned long long (*ia64_printk_clock)(void);
 
 unsigned long sn_rtc_cycles_per_second;
 EXPORT_SYMBOL(sn_rtc_cycles_per_second);
@@ -125,20 +126,6 @@ struct screen_info sn_screen_info = {
 };
 
 /*
- * This is here so we can use the CMOS detection in ide-probe.c to
- * determine what drives are present.  In theory, we don't need this
- * as the auto-detection could be done via ide-probe.c:do_probe() but
- * in practice that would be much slower, which is painful when
- * running in the simulator.  Note that passing zeroes in DRIVE_INFO
- * is sufficient (the IDE driver will autodetect the drive geometry).
- */
-#ifdef CONFIG_IA64_GENERIC
-extern char drive_info[4 * 16];
-#else
-char drive_info[4 * 16];
-#endif
-
-/*
  * This routine can only be used during init, since
  * smp_boot_data is an init data structure.
  * We have to use smp_boot_data.cpu_phys_id to find
@@ -209,7 +196,7 @@ void __init early_sn_setup(void)
 }
 
 extern int platform_intr_list[];
-static int __initdata shub_1_1_found = 0;
+static int __initdata shub_1_1_found;
 
 /*
  * sn_check_for_wars
@@ -372,6 +359,16 @@ sn_scan_pcdp(void)
         }
 }
 
+static unsigned long sn2_rtc_initial;
+
+static unsigned long long ia64_sn2_printk_clock(void)
+{
+        unsigned long rtc_now = rtc_time();
+
+        return (rtc_now - sn2_rtc_initial) *
+                (1000000000 / sn_rtc_cycles_per_second);
+}
+
 /**
  * sn_setup - SN platform setup routine
  * @cmdline_p: kernel command line
@@ -386,6 +383,7 @@ void __init sn_setup(char **cmdline_p)
         u32 version = sn_sal_rev();
         extern void sn_cpu_init(void);
 
+        sn2_rtc_initial = rtc_time();
         ia64_sn_plat_set_error_handling_features();     // obsolete
         ia64_sn_set_os_feature(OSF_MCA_SLV_TO_OS_INIT_SLV);
         ia64_sn_set_os_feature(OSF_FEAT_LOG_SBES);
@@ -437,19 +435,6 @@ void __init sn_setup(char **cmdline_p)
          */
         build_cnode_tables();
 
-        /*
-         * Old PROMs do not provide an ACPI FADT. Disable legacy keyboard
-         * support here so we don't have to listen to failed keyboard probe
-         * messages.
-         */
-        if (version <= 0x0209 && acpi_kbd_controller_present) {
-                printk(KERN_INFO "Disabling legacy keyboard support as prom "
-                       "is too old and doesn't provide FADT\n");
-                acpi_kbd_controller_present = 0;
-        }
-
-        printk("SGI SAL version %x.%02x\n", version >> 8, version & 0x00FF);
-
         status =
             ia64_sal_freq_base(SAL_FREQ_BASE_REALTIME_CLOCK, &ticks_per_sec,
                                &drift);
@@ -463,6 +448,21 @@ void __init sn_setup(char **cmdline_p)
 
         platform_intr_list[ACPI_INTERRUPT_CPEI] = IA64_CPE_VECTOR;
 
+        ia64_printk_clock = ia64_sn2_printk_clock;
+
+        /*
+         * Old PROMs do not provide an ACPI FADT. Disable legacy keyboard
+         * support here so we don't have to listen to failed keyboard probe
+         * messages.
+         */
+        if (version <= 0x0209 && acpi_kbd_controller_present) {
+                printk(KERN_INFO "Disabling legacy keyboard support as prom "
+                       "is too old and doesn't provide FADT\n");
+                acpi_kbd_controller_present = 0;
+        }
+
+        printk("SGI SAL version %x.%02x\n", version >> 8, version & 0x00FF);
+
         /*
          * we set the default root device to /dev/hda
          * to make simulation easy
@@ -578,13 +578,17 @@ void __init sn_cpu_init(void)
                         sn_prom_type = 2;
                 else
                         sn_prom_type = 1;
-                printk("Running on medusa with %s PROM\n", (sn_prom_type == 1) ? "real" : "fake");
+                printk(KERN_INFO "Running on medusa with %s PROM\n",
+                       (sn_prom_type == 1) ? "real" : "fake");
         }
 
         memset(pda, 0, sizeof(pda));
-        if (ia64_sn_get_sn_info(0, &sn_hub_info->shub2, &sn_hub_info->nasid_bitmask, &sn_hub_info->nasid_shift,
-                                &sn_system_size, &sn_sharing_domain_size, &sn_partition_id,
-                                &sn_coherency_id, &sn_region_size))
+        if (ia64_sn_get_sn_info(0, &sn_hub_info->shub2,
+                                &sn_hub_info->nasid_bitmask,
+                                &sn_hub_info->nasid_shift,
+                                &sn_system_size, &sn_sharing_domain_size,
+                                &sn_partition_id, &sn_coherency_id,
+                                &sn_region_size))
                 BUG();
         sn_hub_info->as_shift = sn_hub_info->nasid_shift - 2;
 
@@ -716,7 +720,8 @@ void __init build_cnode_tables(void)
         for_each_online_node(node) {
                 kl_config_hdr_t *klgraph_header;
                 nasid = cnodeid_to_nasid(node);
-                if ((klgraph_header = ia64_sn_get_klconfig_addr(nasid)) == NULL)
+                klgraph_header = ia64_sn_get_klconfig_addr(nasid);
+                if (klgraph_header == NULL)
                         BUG();
                 brd = NODE_OFFSET_TO_LBOARD(nasid, klgraph_header->ch_board_info);
                 while (brd) {
@@ -734,7 +739,7 @@ nasid_slice_to_cpuid(int nasid, int slice)
 {
         long cpu;
 
-        for (cpu=0; cpu < NR_CPUS; cpu++)
+        for (cpu = 0; cpu < NR_CPUS; cpu++)
                 if (cpuid_to_nasid(cpu) == nasid &&
                                         cpuid_to_slice(cpu) == slice)
                         return cpu;
diff --git a/arch/ia64/sn/kernel/sn2/Makefile b/arch/ia64/sn/kernel/sn2/Makefile
index 170bde4549da..99e177693234 100644
--- a/arch/ia64/sn/kernel/sn2/Makefile
+++ b/arch/ia64/sn/kernel/sn2/Makefile
@@ -9,5 +9,7 @@
 # sn2 specific kernel files
 #
 
+CPPFLAGS += -I$(srctree)/arch/ia64/sn/include
+
 obj-y += cache.o io.o ptc_deadlock.o sn2_smp.o sn_proc_fs.o \
          prominfo_proc.o timer.o timer_interrupt.o sn_hwperf.o
diff --git a/arch/ia64/sn/kernel/sn2/sn2_smp.c b/arch/ia64/sn/kernel/sn2/sn2_smp.c
index 471bbaa65d1b..f153a4c35c70 100644
--- a/arch/ia64/sn/kernel/sn2/sn2_smp.c
+++ b/arch/ia64/sn/kernel/sn2/sn2_smp.c
@@ -5,7 +5,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2000-2005 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2000-2006 Silicon Graphics, Inc. All rights reserved.
  */
 
 #include <linux/init.h>
@@ -46,104 +46,28 @@ DECLARE_PER_CPU(struct ptc_stats, ptcstats);
 
 static  __cacheline_aligned DEFINE_SPINLOCK(sn2_global_ptc_lock);
 
-void sn2_ptc_deadlock_recovery(short *, short, int, volatile unsigned long *, unsigned long data0,
-        volatile unsigned long *, unsigned long data1);
+void sn2_ptc_deadlock_recovery(short *, short, short, int, volatile unsigned long *, unsigned long,
+        volatile unsigned long *, unsigned long);
 
-#ifdef DEBUG_PTC
 /*
- * ptctest:
- *
- *      xyz - 3 digit hex number:
- *              x - Force PTC purges to use shub:
- *                      0 - no force
- *                      1 - force
- *              y - interupt enable
- *                      0 - disable interrupts
- *                      1 - leave interuupts enabled
- *              z - type of lock:
- *                      0 - global lock
- *                      1 - node local lock
- *                      2 - no lock
- *
- *      Note: on shub1, only ptctest == 0 is supported. Don't try other values!
+ * Note: some is the following is captured here to make degugging easier
+ * (the macros make more sense if you see the debug patch - not posted)
  */
-
-static unsigned int sn2_ptctest = 0;
-
-static int __init ptc_test(char *str)
-{
-        get_option(&str, &sn2_ptctest);
-        return 1;
-}
-__setup("ptctest=", ptc_test);
-
-static inline int ptc_lock(unsigned long *flagp)
-{
-        unsigned long opt = sn2_ptctest & 255;
-
-        switch (opt) {
-        case 0x00:
-                spin_lock_irqsave(&sn2_global_ptc_lock, *flagp);
-                break;
-        case 0x01:
-                spin_lock_irqsave(&sn_nodepda->ptc_lock, *flagp);
-                break;
-        case 0x02:
-                local_irq_save(*flagp);
-                break;
-        case 0x10:
-                spin_lock(&sn2_global_ptc_lock);
-                break;
-        case 0x11:
-                spin_lock(&sn_nodepda->ptc_lock);
-                break;
-        case 0x12:
-                break;
-        default:
-                BUG();
-        }
-        return opt;
-}
-
-static inline void ptc_unlock(unsigned long flags, int opt)
-{
-        switch (opt) {
-        case 0x00:
-                spin_unlock_irqrestore(&sn2_global_ptc_lock, flags);
-                break;
-        case 0x01:
-                spin_unlock_irqrestore(&sn_nodepda->ptc_lock, flags);
-                break;
-        case 0x02:
-                local_irq_restore(flags);
-                break;
-        case 0x10:
-                spin_unlock(&sn2_global_ptc_lock);
-                break;
-        case 0x11:
-                spin_unlock(&sn_nodepda->ptc_lock);
-                break;
-        case 0x12:
-                break;
-        default:
-                BUG();
-        }
-}
-#else
-
 #define sn2_ptctest     0
+#define local_node_uses_ptc_ga(sh1)     ((sh1) ? 1 : 0)
+#define max_active_pio(sh1)             ((sh1) ? 32 : 7)
+#define reset_max_active_on_deadlock()  1
+#define PTC_LOCK(sh1)                   ((sh1) ? &sn2_global_ptc_lock : &sn_nodepda->ptc_lock)
 
-static inline int ptc_lock(unsigned long *flagp)
+static inline void ptc_lock(int sh1, unsigned long *flagp)
 {
-        spin_lock_irqsave(&sn2_global_ptc_lock, *flagp);
-        return 0;
+        spin_lock_irqsave(PTC_LOCK(sh1), *flagp);
 }
 
-static inline void ptc_unlock(unsigned long flags, int opt)
+static inline void ptc_unlock(int sh1, unsigned long flags)
 {
-        spin_unlock_irqrestore(&sn2_global_ptc_lock, flags);
+        spin_unlock_irqrestore(PTC_LOCK(sh1), flags);
 }
-#endif
 
 struct ptc_stats {
         unsigned long ptc_l;
@@ -151,27 +75,30 @@ struct ptc_stats {
         unsigned long shub_ptc_flushes;
         unsigned long nodes_flushed;
         unsigned long deadlocks;
+        unsigned long deadlocks2;
         unsigned long lock_itc_clocks;
         unsigned long shub_itc_clocks;
         unsigned long shub_itc_clocks_max;
+        unsigned long shub_ptc_flushes_not_my_mm;
 };
 
 static inline unsigned long wait_piowc(void)
 {
-        volatile unsigned long *piows, zeroval;
-        unsigned long ws;
+        volatile unsigned long *piows;
+        unsigned long zeroval, ws;
 
         piows = pda->pio_write_status_addr;
         zeroval = pda->pio_write_status_val;
         do {
                 cpu_relax();
         } while (((ws = *piows) & SH_PIO_WRITE_STATUS_PENDING_WRITE_COUNT_MASK) != zeroval);
-        return ws;
+        return (ws & SH_PIO_WRITE_STATUS_WRITE_DEADLOCK_MASK) != 0;
 }
 
 void sn_tlb_migrate_finish(struct mm_struct *mm)
 {
-        if (mm == current->mm)
+        /* flush_tlb_mm is inefficient if more than 1 users of mm */
+        if (mm == current->mm && mm && atomic_read(&mm->mm_users) == 1)
                 flush_tlb_mm(mm);
 }
 
@@ -201,12 +128,14 @@ void
 sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
                      unsigned long end, unsigned long nbits)
 {
-        int i, opt, shub1, cnode, mynasid, cpu, lcpu = 0, nasid, flushed = 0;
-        int mymm = (mm == current->active_mm && current->mm);
+        int i, ibegin, shub1, cnode, mynasid, cpu, lcpu = 0, nasid;
+        int mymm = (mm == current->active_mm && mm == current->mm);
+        int use_cpu_ptcga;
         volatile unsigned long *ptc0, *ptc1;
-        unsigned long itc, itc2, flags, data0 = 0, data1 = 0, rr_value;
+        unsigned long itc, itc2, flags, data0 = 0, data1 = 0, rr_value, old_rr = 0;
         short nasids[MAX_NUMNODES], nix;
         nodemask_t nodes_flushed;
+        int active, max_active, deadlock;
 
         nodes_clear(nodes_flushed);
         i = 0;
@@ -267,41 +196,56 @@ sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
         
 
         mynasid = get_nasid();
+        use_cpu_ptcga = local_node_uses_ptc_ga(shub1);
+        max_active = max_active_pio(shub1);
 
         itc = ia64_get_itc();
-        opt = ptc_lock(&flags);
+        ptc_lock(shub1, &flags);
         itc2 = ia64_get_itc();
+
         __get_cpu_var(ptcstats).lock_itc_clocks += itc2 - itc;
         __get_cpu_var(ptcstats).shub_ptc_flushes++;
         __get_cpu_var(ptcstats).nodes_flushed += nix;
+        if (!mymm)
+                 __get_cpu_var(ptcstats).shub_ptc_flushes_not_my_mm++;
 
+        if (use_cpu_ptcga && !mymm) {
+                old_rr = ia64_get_rr(start);
+                ia64_set_rr(start, (old_rr & 0xff) | (rr_value << 8));
+                ia64_srlz_d();
+        }
+
+        wait_piowc();
         do {
                 if (shub1)
                         data1 = start | (1UL << SH1_PTC_1_START_SHFT);
                 else
                         data0 = (data0 & ~SH2_PTC_ADDR_MASK) | (start & SH2_PTC_ADDR_MASK);
-                for (i = 0; i < nix; i++) {
+                deadlock = 0;
+                active = 0;
+                for (ibegin = 0, i = 0; i < nix; i++) {
                         nasid = nasids[i];
-                        if ((!(sn2_ptctest & 3)) && unlikely(nasid == mynasid && mymm)) {
+                        if (use_cpu_ptcga && unlikely(nasid == mynasid)) {
                                 ia64_ptcga(start, nbits << 2);
                                 ia64_srlz_i();
                         } else {
                                 ptc0 = CHANGE_NASID(nasid, ptc0);
                                 if (ptc1)
                                         ptc1 = CHANGE_NASID(nasid, ptc1);
-                                pio_atomic_phys_write_mmrs(ptc0, data0, ptc1,
-                                                           data1);
-                                flushed = 1;
+                                pio_atomic_phys_write_mmrs(ptc0, data0, ptc1, data1);
+                                active++;
+                        }
+                        if (active >= max_active || i == (nix - 1)) {
+                                if ((deadlock = wait_piowc())) {
+                                        sn2_ptc_deadlock_recovery(nasids, ibegin, i, mynasid, ptc0, data0, ptc1, data1);
+                                        if (reset_max_active_on_deadlock())
+                                                max_active = 1;
+                                }
+                                active = 0;
+                                ibegin = i + 1;
                         }
                 }
-                if (flushed
-                    && (wait_piowc() &
-                                (SH_PIO_WRITE_STATUS_WRITE_DEADLOCK_MASK))) {
-                        sn2_ptc_deadlock_recovery(nasids, nix, mynasid, ptc0, data0, ptc1, data1);
-                }
-
                 start += (1UL << nbits);
-
         } while (start < end);
 
         itc2 = ia64_get_itc() - itc2;
@@ -309,7 +253,12 @@ sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
         if (itc2 > __get_cpu_var(ptcstats).shub_itc_clocks_max)
                 __get_cpu_var(ptcstats).shub_itc_clocks_max = itc2;
 
-        ptc_unlock(flags, opt);
+        if (old_rr) {
+                ia64_set_rr(start, old_rr);
+                ia64_srlz_d();
+        }
+
+        ptc_unlock(shub1, flags);
 
         preempt_enable();
 }
@@ -321,27 +270,30 @@ sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
  * TLB flush transaction.  The recovery sequence is somewhat tricky & is
  * coded in assembly language.
  */
-void sn2_ptc_deadlock_recovery(short *nasids, short nix, int mynasid, volatile unsigned long *ptc0, unsigned long data0,
+void sn2_ptc_deadlock_recovery(short *nasids, short ib, short ie, int mynasid, volatile unsigned long *ptc0, unsigned long data0,
         volatile unsigned long *ptc1, unsigned long data1)
 {
-        extern void sn2_ptc_deadlock_recovery_core(volatile unsigned long *, unsigned long,
+        extern unsigned long sn2_ptc_deadlock_recovery_core(volatile unsigned long *, unsigned long,
                 volatile unsigned long *, unsigned long, volatile unsigned long *, unsigned long);
         short nasid, i;
-        unsigned long *piows, zeroval;
+        unsigned long *piows, zeroval, n;
 
         __get_cpu_var(ptcstats).deadlocks++;
 
         piows = (unsigned long *) pda->pio_write_status_addr;
         zeroval = pda->pio_write_status_val;
 
-        for (i=0; i < nix; i++) {
+
+        for (i=ib; i <= ie; i++) {
                 nasid = nasids[i];
-                if (!(sn2_ptctest & 3) && nasid == mynasid)
+                if (local_node_uses_ptc_ga(is_shub1()) && nasid == mynasid)
                         continue;
                 ptc0 = CHANGE_NASID(nasid, ptc0);
                 if (ptc1)
                         ptc1 = CHANGE_NASID(nasid, ptc1);
-                sn2_ptc_deadlock_recovery_core(ptc0, data0, ptc1, data1, piows, zeroval);
+
+                n = sn2_ptc_deadlock_recovery_core(ptc0, data0, ptc1, data1, piows, zeroval);
+                __get_cpu_var(ptcstats).deadlocks2 += n;
         }
 
 }
@@ -452,20 +404,22 @@ static int sn2_ptc_seq_show(struct seq_file *file, void *data)
         cpu = *(loff_t *) data;
 
         if (!cpu) {
-                seq_printf(file, "# ptc_l change_rid shub_ptc_flushes shub_nodes_flushed deadlocks lock_nsec shub_nsec shub_nsec_max\n");
+                seq_printf(file,
+                           "# cpu ptc_l newrid ptc_flushes nodes_flushed deadlocks lock_nsec shub_nsec shub_nsec_max not_my_mm deadlock2\n");
                 seq_printf(file, "# ptctest %d\n", sn2_ptctest);
         }
 
         if (cpu < NR_CPUS && cpu_online(cpu)) {
                 stat = &per_cpu(ptcstats, cpu);
-                seq_printf(file, "cpu %d %ld %ld %ld %ld %ld %ld %ld %ld\n", cpu, stat->ptc_l,
+                seq_printf(file, "cpu %d %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld\n", cpu, stat->ptc_l,
                                 stat->change_rid, stat->shub_ptc_flushes, stat->nodes_flushed,
                                 stat->deadlocks,
                                 1000 * stat->lock_itc_clocks / per_cpu(cpu_info, cpu).cyc_per_usec,
                                 1000 * stat->shub_itc_clocks / per_cpu(cpu_info, cpu).cyc_per_usec,
-                                1000 * stat->shub_itc_clocks_max / per_cpu(cpu_info, cpu).cyc_per_usec);
+                                1000 * stat->shub_itc_clocks_max / per_cpu(cpu_info, cpu).cyc_per_usec,
+                                stat->shub_ptc_flushes_not_my_mm,
+                                stat->deadlocks2);
         }
-
         return 0;
 }
 
@@ -476,7 +430,7 @@ static struct seq_operations sn2_ptc_seq_ops = {
         .show = sn2_ptc_seq_show
 };
 
-int sn2_ptc_proc_open(struct inode *inode, struct file *file)
+static int sn2_ptc_proc_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &sn2_ptc_seq_ops);
 }
diff --git a/arch/ia64/sn/kernel/sn2/sn_hwperf.c b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
index 19b54fbcd7ea..70db21f3df21 100644
--- a/arch/ia64/sn/kernel/sn2/sn_hwperf.c
+++ b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
@@ -3,7 +3,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2004-2005 Silicon Graphics, Inc. All rights reserved.
+ * Copyright (C) 2004-2006 Silicon Graphics, Inc. All rights reserved.
  *
  * SGI Altix topology and hardware performance monitoring API.
  * Mark Goodwin <markgw@sgi.com>. 
@@ -973,6 +973,9 @@ static int __devinit sn_hwperf_misc_register_init(void)
 {
         int e;
 
+        if (!ia64_platform_is("sn2"))
+                return 0;
+
         sn_hwperf_init();
 
         /*
diff --git a/arch/ia64/sn/kernel/xp_main.c b/arch/ia64/sn/kernel/xp_main.c
index 3be52a34c80f..b7ea46645e12 100644
--- a/arch/ia64/sn/kernel/xp_main.c
+++ b/arch/ia64/sn/kernel/xp_main.c
@@ -19,6 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <asm/sn/intr.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/sn/xp.h>
@@ -136,13 +137,13 @@ xpc_connect(int ch_number, xpc_channel_func func, void *key, u16 payload_size,
 
         registration = &xpc_registrations[ch_number];
 
-        if (down_interruptible(&registration->sema) != 0) {
+        if (mutex_lock_interruptible(&registration->mutex) != 0) {
                 return xpcInterrupted;
         }
 
         /* if XPC_CHANNEL_REGISTERED(ch_number) */
         if (registration->func != NULL) {
-                up(&registration->sema);
+                mutex_unlock(&registration->mutex);
                 return xpcAlreadyRegistered;
         }
 
@@ -154,7 +155,7 @@ xpc_connect(int ch_number, xpc_channel_func func, void *key, u16 payload_size,
         registration->key = key;
         registration->func = func;
 
-        up(&registration->sema);
+        mutex_unlock(&registration->mutex);
 
         xpc_interface.connect(ch_number);
 
@@ -190,11 +191,11 @@ xpc_disconnect(int ch_number)
          * figured XPC's users will just turn around and call xpc_disconnect()
          * again anyways, so we might as well wait, if need be.
          */
-        down(&registration->sema);
+        mutex_lock(&registration->mutex);
 
         /* if !XPC_CHANNEL_REGISTERED(ch_number) */
         if (registration->func == NULL) {
-                up(&registration->sema);
+                mutex_unlock(&registration->mutex);
                 return;
         }
 
@@ -208,7 +209,7 @@ xpc_disconnect(int ch_number)
 
         xpc_interface.disconnect(ch_number);
 
-        up(&registration->sema);
+        mutex_unlock(&registration->mutex);
 
         return;
 }
@@ -250,9 +251,9 @@ xp_init(void)
                 xp_nofault_PIOR_target = SH1_IPI_ACCESS;
         }
 
-        /* initialize the connection registration semaphores */
+        /* initialize the connection registration mutex */
         for (ch_number = 0; ch_number < XPC_NCHANNELS; ch_number++) {
-                sema_init(&xpc_registrations[ch_number].sema, 1);  /* mutex */
+                mutex_init(&xpc_registrations[ch_number].mutex);
         }
 
         return 0;
diff --git a/arch/ia64/sn/kernel/xpc_channel.c b/arch/ia64/sn/kernel/xpc_channel.c
index 0c0a68902409..36e5437a0fb6 100644
--- a/arch/ia64/sn/kernel/xpc_channel.c
+++ b/arch/ia64/sn/kernel/xpc_channel.c
@@ -22,6 +22,8 @@
 #include <linux/cache.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
+#include <linux/completion.h>
 #include <asm/sn/bte.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/sn/xpc.h>
@@ -56,8 +58,8 @@ xpc_initialize_channels(struct xpc_partition *part, partid_t partid)
                 atomic_set(&ch->n_to_notify, 0);
 
                 spin_lock_init(&ch->lock);
-                sema_init(&ch->msg_to_pull_sema, 1);    /* mutex */
-                sema_init(&ch->wdisconnect_sema, 0);    /* event wait */
+                mutex_init(&ch->msg_to_pull_mutex);
+                init_completion(&ch->wdisconnect_wait);
 
                 atomic_set(&ch->n_on_msg_allocate_wq, 0);
                 init_waitqueue_head(&ch->msg_allocate_wq);
@@ -445,7 +447,7 @@ xpc_allocate_local_msgqueue(struct xpc_channel *ch)
 
                 nbytes = nentries * ch->msg_size;
                 ch->local_msgqueue = xpc_kmalloc_cacheline_aligned(nbytes,
-                                                (GFP_KERNEL | GFP_DMA),
+                                                GFP_KERNEL,
                                                 &ch->local_msgqueue_base);
                 if (ch->local_msgqueue == NULL) {
                         continue;
@@ -453,7 +455,7 @@ xpc_allocate_local_msgqueue(struct xpc_channel *ch)
                 memset(ch->local_msgqueue, 0, nbytes);
 
                 nbytes = nentries * sizeof(struct xpc_notify);
-                ch->notify_queue = kmalloc(nbytes, (GFP_KERNEL | GFP_DMA));
+                ch->notify_queue = kmalloc(nbytes, GFP_KERNEL);
                 if (ch->notify_queue == NULL) {
                         kfree(ch->local_msgqueue_base);
                         ch->local_msgqueue = NULL;
@@ -500,7 +502,7 @@ xpc_allocate_remote_msgqueue(struct xpc_channel *ch)
 
                 nbytes = nentries * ch->msg_size;
                 ch->remote_msgqueue = xpc_kmalloc_cacheline_aligned(nbytes,
-                                                (GFP_KERNEL | GFP_DMA),
+                                                GFP_KERNEL,
                                                 &ch->remote_msgqueue_base);
                 if (ch->remote_msgqueue == NULL) {
                         continue;
@@ -534,7 +536,6 @@ static enum xpc_retval
 xpc_allocate_msgqueues(struct xpc_channel *ch)
 {
         unsigned long irq_flags;
-        int i;
         enum xpc_retval ret;
 
 
@@ -552,11 +553,6 @@ xpc_allocate_msgqueues(struct xpc_channel *ch)
                 return ret;
         }
 
-        for (i = 0; i < ch->local_nentries; i++) {
-                /* use a semaphore as an event wait queue */
-                sema_init(&ch->notify_queue[i].sema, 0);
-        }
-
         spin_lock_irqsave(&ch->lock, irq_flags);
         ch->flags |= XPC_C_SETUP;
         spin_unlock_irqrestore(&ch->lock, irq_flags);
@@ -799,10 +795,8 @@ xpc_process_disconnect(struct xpc_channel *ch, unsigned long *irq_flags)
         }
 
         if (ch->flags & XPC_C_WDISCONNECT) {
-                spin_unlock_irqrestore(&ch->lock, *irq_flags);
-                up(&ch->wdisconnect_sema);
-                spin_lock_irqsave(&ch->lock, *irq_flags);
-
+                /* we won't lose the CPU since we're holding ch->lock */
+                complete(&ch->wdisconnect_wait);
         } else if (ch->delayed_IPI_flags) {
                 if (part->act_state != XPC_P_DEACTIVATING) {
                         /* time to take action on any delayed IPI flags */
@@ -1092,12 +1086,12 @@ xpc_connect_channel(struct xpc_channel *ch)
         struct xpc_registration *registration = &xpc_registrations[ch->number];
 
 
-        if (down_trylock(&registration->sema) != 0) {
+        if (mutex_trylock(&registration->mutex) == 0) {
                 return xpcRetry;
         }
 
         if (!XPC_CHANNEL_REGISTERED(ch->number)) {
-                up(&registration->sema);
+                mutex_unlock(&registration->mutex);
                 return xpcUnregistered;
         }
 
@@ -1108,7 +1102,7 @@ xpc_connect_channel(struct xpc_channel *ch)
 
         if (ch->flags & XPC_C_DISCONNECTING) {
                 spin_unlock_irqrestore(&ch->lock, irq_flags);
-                up(&registration->sema);
+                mutex_unlock(&registration->mutex);
                 return ch->reason;
         }
 
@@ -1140,7 +1134,7 @@ xpc_connect_channel(struct xpc_channel *ch)
                          * channel lock be locked and will unlock and relock
                          * the channel lock as needed.
                          */
-                        up(&registration->sema);
+                        mutex_unlock(&registration->mutex);
                         XPC_DISCONNECT_CHANNEL(ch, xpcUnequalMsgSizes,
                                                                 &irq_flags);
                         spin_unlock_irqrestore(&ch->lock, irq_flags);
@@ -1155,7 +1149,7 @@ xpc_connect_channel(struct xpc_channel *ch)
                 atomic_inc(&xpc_partitions[ch->partid].nchannels_active);
         }
 
-        up(&registration->sema);
+        mutex_unlock(&registration->mutex);
 
 
         /* initiate the connection */
@@ -2089,7 +2083,7 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
         enum xpc_retval ret;
 
 
-        if (down_interruptible(&ch->msg_to_pull_sema) != 0) {
+        if (mutex_lock_interruptible(&ch->msg_to_pull_mutex) != 0) {
                 /* we were interrupted by a signal */
                 return NULL;
         }
@@ -2125,7 +2119,7 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
 
                         XPC_DEACTIVATE_PARTITION(part, ret);
 
-                        up(&ch->msg_to_pull_sema);
+                        mutex_unlock(&ch->msg_to_pull_mutex);
                         return NULL;
                 }
 
@@ -2134,7 +2128,7 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
                 ch->next_msg_to_pull += nmsgs;
         }
 
-        up(&ch->msg_to_pull_sema);
+        mutex_unlock(&ch->msg_to_pull_mutex);
 
         /* return the message we were looking for */
         msg_offset = (get % ch->remote_nentries) * ch->msg_size;
diff --git a/arch/ia64/sn/kernel/xpc_main.c b/arch/ia64/sn/kernel/xpc_main.c
index 8930586e0eb4..9cd460dfe27e 100644
--- a/arch/ia64/sn/kernel/xpc_main.c
+++ b/arch/ia64/sn/kernel/xpc_main.c
@@ -55,6 +55,7 @@
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/reboot.h>
+#include <linux/completion.h>
 #include <asm/sn/intr.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/kdebug.h>
@@ -177,10 +178,10 @@ static DECLARE_WAIT_QUEUE_HEAD(xpc_act_IRQ_wq);
 static unsigned long xpc_hb_check_timeout;
 
 /* notification that the xpc_hb_checker thread has exited */
-static DECLARE_MUTEX_LOCKED(xpc_hb_checker_exited);
+static DECLARE_COMPLETION(xpc_hb_checker_exited);
 
 /* notification that the xpc_discovery thread has exited */
-static DECLARE_MUTEX_LOCKED(xpc_discovery_exited);
+static DECLARE_COMPLETION(xpc_discovery_exited);
 
 
 static struct timer_list xpc_hb_timer;
@@ -321,7 +322,7 @@ xpc_hb_checker(void *ignore)
 
 
         /* mark this thread as having exited */
-        up(&xpc_hb_checker_exited);
+        complete(&xpc_hb_checker_exited);
         return 0;
 }
 
@@ -341,7 +342,7 @@ xpc_initiate_discovery(void *ignore)
         dev_dbg(xpc_part, "discovery thread is exiting\n");
 
         /* mark this thread as having exited */
-        up(&xpc_discovery_exited);
+        complete(&xpc_discovery_exited);
         return 0;
 }
 
@@ -574,18 +575,21 @@ xpc_activate_partition(struct xpc_partition *part)
 
         spin_lock_irqsave(&part->act_lock, irq_flags);
 
-        pid = kernel_thread(xpc_activating, (void *) ((u64) partid), 0);
-
         DBUG_ON(part->act_state != XPC_P_INACTIVE);
 
-        if (pid > 0) {
-                part->act_state = XPC_P_ACTIVATION_REQ;
-                XPC_SET_REASON(part, xpcCloneKThread, __LINE__);
-        } else {
-                XPC_SET_REASON(part, xpcCloneKThreadFailed, __LINE__);
-        }
+        part->act_state = XPC_P_ACTIVATION_REQ;
+        XPC_SET_REASON(part, xpcCloneKThread, __LINE__);
 
         spin_unlock_irqrestore(&part->act_lock, irq_flags);
+
+        pid = kernel_thread(xpc_activating, (void *) ((u64) partid), 0);
+
+        if (unlikely(pid <= 0)) {
+                spin_lock_irqsave(&part->act_lock, irq_flags);
+                part->act_state = XPC_P_INACTIVE;
+                XPC_SET_REASON(part, xpcCloneKThreadFailed, __LINE__);
+                spin_unlock_irqrestore(&part->act_lock, irq_flags);
+        }
 }
 
 
@@ -893,7 +897,7 @@ xpc_disconnect_wait(int ch_number)
                         continue;
                 }
 
-                (void) down(&ch->wdisconnect_sema);
+                wait_for_completion(&ch->wdisconnect_wait);
 
                 spin_lock_irqsave(&ch->lock, irq_flags);
                 DBUG_ON(!(ch->flags & XPC_C_DISCONNECTED));
@@ -946,10 +950,10 @@ xpc_do_exit(enum xpc_retval reason)
         free_irq(SGI_XPC_ACTIVATE, NULL);
 
         /* wait for the discovery thread to exit */
-        down(&xpc_discovery_exited);
+        wait_for_completion(&xpc_discovery_exited);
 
         /* wait for the heartbeat checker thread to exit */
-        down(&xpc_hb_checker_exited);
+        wait_for_completion(&xpc_hb_checker_exited);
 
 
         /* sleep for a 1/3 of a second or so */
@@ -1367,7 +1371,7 @@ xpc_init(void)
                 dev_err(xpc_part, "failed while forking discovery thread\n");
 
                 /* mark this new thread as a non-starter */
-                up(&xpc_discovery_exited);
+                complete(&xpc_discovery_exited);
 
                 xpc_do_exit(xpcUnloading);
                 return -EBUSY;
diff --git a/arch/ia64/sn/pci/Makefile b/arch/ia64/sn/pci/Makefile
index 321576b1b425..c6946784a6a8 100644
--- a/arch/ia64/sn/pci/Makefile
+++ b/arch/ia64/sn/pci/Makefile
@@ -7,4 +7,6 @@
 #
 # Makefile for the sn pci general routines.
 
+CPPFLAGS += -I$(srctree)/arch/ia64/sn/include
+
 obj-y := pci_dma.o tioca_provider.o tioce_provider.o pcibr/
diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index 9bf9f23b9a1f..5a36292388eb 100644
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -90,14 +90,14 @@ void *sn_dma_alloc_coherent(struct device *dev, size_t size,
          */
         node = pcibus_to_node(pdev->bus);
         if (likely(node >=0)) {
-                struct page *p = alloc_pages_node(node, GFP_ATOMIC, get_order(size));
+                struct page *p = alloc_pages_node(node, flags, get_order(size));
 
                 if (likely(p))
                         cpuaddr = page_address(p);
                 else
                         return NULL;
         } else
-                cpuaddr = (void *)__get_free_pages(GFP_ATOMIC, get_order(size));
+                cpuaddr = (void *)__get_free_pages(flags, get_order(size));
 
         if (unlikely(!cpuaddr))
                 return NULL;
diff --git a/arch/ia64/sn/pci/pcibr/Makefile b/arch/ia64/sn/pci/pcibr/Makefile
index 1850c4a94c41..3b403ea456f9 100644
--- a/arch/ia64/sn/pci/pcibr/Makefile
+++ b/arch/ia64/sn/pci/pcibr/Makefile
@@ -7,5 +7,7 @@
 #
 # Makefile for the sn2 io routines.
 
+CPPFLAGS += -I$(srctree)/arch/ia64/sn/include
+
 obj-y                           +=  pcibr_dma.o pcibr_reg.o \
                                     pcibr_ate.o pcibr_provider.o
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_provider.c b/arch/ia64/sn/pci/pcibr/pcibr_provider.c
index 77a1262751d3..2fac27049bf6 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_provider.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_provider.c
@@ -24,13 +24,15 @@ sal_pcibr_slot_enable(struct pcibus_info *soft, int device, void *resp)
 {
         struct ia64_sal_retval ret_stuff;
         u64 busnum;
+        u64 segment;
 
         ret_stuff.status = 0;
         ret_stuff.v0 = 0;
 
+        segment = soft->pbi_buscommon.bs_persist_segment;
         busnum = soft->pbi_buscommon.bs_persist_busnum;
-        SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_SLOT_ENABLE, (u64) busnum,
-                        (u64) device, (u64) resp, 0, 0, 0, 0);
+        SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_SLOT_ENABLE, segment,
+                        busnum, (u64) device, (u64) resp, 0, 0, 0);
 
         return (int)ret_stuff.v0;
 }
@@ -41,14 +43,16 @@ sal_pcibr_slot_disable(struct pcibus_info *soft, int device, int action,
 {
         struct ia64_sal_retval ret_stuff;
         u64 busnum;
+        u64 segment;
 
         ret_stuff.status = 0;
         ret_stuff.v0 = 0;
 
+        segment = soft->pbi_buscommon.bs_persist_segment;
         busnum = soft->pbi_buscommon.bs_persist_busnum;
         SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_SLOT_DISABLE,
-                        (u64) busnum, (u64) device, (u64) action,
-                        (u64) resp, 0, 0, 0);
+                        segment, busnum, (u64) device, (u64) action,
+                        (u64) resp, 0, 0);
 
         return (int)ret_stuff.v0;
 }
diff --git a/arch/m32r/kernel/m32r_ksyms.c b/arch/m32r/kernel/m32r_ksyms.c
index dbc8a392105f..be8b711367ec 100644
--- a/arch/m32r/kernel/m32r_ksyms.c
+++ b/arch/m32r/kernel/m32r_ksyms.c
@@ -18,11 +18,6 @@
 #include <asm/irq.h>
 #include <asm/tlbflush.h>
 
-#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD) || defined(CONFIG_BLK_DEV_IDE_MODULE) || defined(CONFIG_BLK_DEV_HD_MODULE)
-extern struct drive_info_struct drive_info;
-EXPORT_SYMBOL(drive_info);
-#endif
-
 /* platform dependent support */
 EXPORT_SYMBOL(boot_cpu_data);
 EXPORT_SYMBOL(dump_fpu);
diff --git a/arch/m32r/kernel/setup.c b/arch/m32r/kernel/setup.c
index c2e4dccf0112..d742037a7ccb 100644
--- a/arch/m32r/kernel/setup.c
+++ b/arch/m32r/kernel/setup.c
@@ -37,12 +37,6 @@
 extern void init_mmu(void);
 #endif
 
-#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD)   \
-        || defined(CONFIG_BLK_DEV_IDE_MODULE)                   \
-        || defined(CONFIG_BLK_DEV_HD_MODULE)
-struct drive_info_struct { char dummy[32]; } drive_info;
-#endif
-
 extern char _end[];
 
 /*
diff --git a/arch/m68k/fpsp040/bindec.S b/arch/m68k/fpsp040/bindec.S
index 3ba446a99a12..72f1159cb804 100644
--- a/arch/m68k/fpsp040/bindec.S
+++ b/arch/m68k/fpsp040/bindec.S
@@ -131,9 +131,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |BINDEC    idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/binstr.S b/arch/m68k/fpsp040/binstr.S
index d53555c0a2b6..8a05ba92a8a0 100644
--- a/arch/m68k/fpsp040/binstr.S
+++ b/arch/m68k/fpsp040/binstr.S
@@ -60,9 +60,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |BINSTR    idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/bugfix.S b/arch/m68k/fpsp040/bugfix.S
index 942c4f6f4fd1..3bb9c84bb058 100644
--- a/arch/m68k/fpsp040/bugfix.S
+++ b/arch/m68k/fpsp040/bugfix.S
@@ -152,9 +152,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |BUGFIX    idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/decbin.S b/arch/m68k/fpsp040/decbin.S
index 2160609e328d..16ed796bad87 100644
--- a/arch/m68k/fpsp040/decbin.S
+++ b/arch/m68k/fpsp040/decbin.S
@@ -69,9 +69,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |DECBIN    idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/do_func.S b/arch/m68k/fpsp040/do_func.S
index 81f6a9856dce..3eff99a80413 100644
--- a/arch/m68k/fpsp040/do_func.S
+++ b/arch/m68k/fpsp040/do_func.S
@@ -22,9 +22,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 DO_FUNC:        |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/fpsp.h b/arch/m68k/fpsp040/fpsp.h
index 984a4eb8010a..5df4cd772934 100644
--- a/arch/m68k/fpsp040/fpsp.h
+++ b/arch/m68k/fpsp040/fpsp.h
@@ -5,9 +5,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |       fpsp.h --- stack frame offsets during FPSP exception handling
 |
diff --git a/arch/m68k/fpsp040/gen_except.S b/arch/m68k/fpsp040/gen_except.S
index 401d06f39f73..3642cb7e3641 100644
--- a/arch/m68k/fpsp040/gen_except.S
+++ b/arch/m68k/fpsp040/gen_except.S
@@ -29,9 +29,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 GEN_EXCEPT:    |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/get_op.S b/arch/m68k/fpsp040/get_op.S
index c7c2f3727425..64c36d79ef83 100644
--- a/arch/m68k/fpsp040/get_op.S
+++ b/arch/m68k/fpsp040/get_op.S
@@ -54,9 +54,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 GET_OP:    |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/kernel_ex.S b/arch/m68k/fpsp040/kernel_ex.S
index 476b711967ce..45bcf3455d34 100644
--- a/arch/m68k/fpsp040/kernel_ex.S
+++ b/arch/m68k/fpsp040/kernel_ex.S
@@ -12,9 +12,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 KERNEL_EX:    |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/res_func.S b/arch/m68k/fpsp040/res_func.S
index 8f6b95217865..d9cdf4383545 100644
--- a/arch/m68k/fpsp040/res_func.S
+++ b/arch/m68k/fpsp040/res_func.S
@@ -16,9 +16,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 RES_FUNC:    |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/round.S b/arch/m68k/fpsp040/round.S
index 00f98068783f..f84ae0dd4358 100644
--- a/arch/m68k/fpsp040/round.S
+++ b/arch/m68k/fpsp040/round.S
@@ -8,9 +8,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |ROUND  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/sacos.S b/arch/m68k/fpsp040/sacos.S
index 83b00ab1c48f..513c7cca7318 100644
--- a/arch/m68k/fpsp040/sacos.S
+++ b/arch/m68k/fpsp040/sacos.S
@@ -38,9 +38,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SACOS  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/sasin.S b/arch/m68k/fpsp040/sasin.S
index 5647a6043903..2a269a58ceaa 100644
--- a/arch/m68k/fpsp040/sasin.S
+++ b/arch/m68k/fpsp040/sasin.S
@@ -38,9 +38,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SASIN  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/satan.S b/arch/m68k/fpsp040/satan.S
index 20dae222d51e..c8a664998f92 100644
--- a/arch/m68k/fpsp040/satan.S
+++ b/arch/m68k/fpsp040/satan.S
@@ -43,9 +43,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |satan  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/satanh.S b/arch/m68k/fpsp040/satanh.S
index 20f07810bcda..ba91f77a7571 100644
--- a/arch/m68k/fpsp040/satanh.S
+++ b/arch/m68k/fpsp040/satanh.S
@@ -45,9 +45,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |satanh idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/scale.S b/arch/m68k/fpsp040/scale.S
index 5c9b805265f2..04829dd4f1f4 100644
--- a/arch/m68k/fpsp040/scale.S
+++ b/arch/m68k/fpsp040/scale.S
@@ -21,9 +21,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SCALE    idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/scosh.S b/arch/m68k/fpsp040/scosh.S
index e81edbb87642..07d3a4d7c86d 100644
--- a/arch/m68k/fpsp040/scosh.S
+++ b/arch/m68k/fpsp040/scosh.S
@@ -49,9 +49,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SCOSH  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/setox.S b/arch/m68k/fpsp040/setox.S
index 0aa75f9bf7d1..145af5447581 100644
--- a/arch/m68k/fpsp040/setox.S
+++ b/arch/m68k/fpsp040/setox.S
@@ -331,9 +331,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |setox  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/sgetem.S b/arch/m68k/fpsp040/sgetem.S
index 0fcbd045ba75..d9234f4aed57 100644
--- a/arch/m68k/fpsp040/sgetem.S
+++ b/arch/m68k/fpsp040/sgetem.S
@@ -24,9 +24,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SGETEM idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/sint.S b/arch/m68k/fpsp040/sint.S
index 0f9bd28e55a0..0e92d4e5d231 100644
--- a/arch/m68k/fpsp040/sint.S
+++ b/arch/m68k/fpsp040/sint.S
@@ -51,9 +51,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SINT    idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/skeleton.S b/arch/m68k/fpsp040/skeleton.S
index a1629194e3fd..a8f41615d94a 100644
--- a/arch/m68k/fpsp040/skeleton.S
+++ b/arch/m68k/fpsp040/skeleton.S
@@ -30,9 +30,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |
 |       Modified for Linux-1.3.x by Jes Sorensen (jds@kom.auc.dk)
diff --git a/arch/m68k/fpsp040/slog2.S b/arch/m68k/fpsp040/slog2.S
index 517fa4563246..fac2c738382e 100644
--- a/arch/m68k/fpsp040/slog2.S
+++ b/arch/m68k/fpsp040/slog2.S
@@ -96,9 +96,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SLOG2    idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/slogn.S b/arch/m68k/fpsp040/slogn.S
index 2aaa0725c035..d98eaf641ec4 100644
--- a/arch/m68k/fpsp040/slogn.S
+++ b/arch/m68k/fpsp040/slogn.S
@@ -63,9 +63,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |slogn  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/smovecr.S b/arch/m68k/fpsp040/smovecr.S
index a0127fa55e9c..73c36512081b 100644
--- a/arch/m68k/fpsp040/smovecr.S
+++ b/arch/m68k/fpsp040/smovecr.S
@@ -15,9 +15,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SMOVECR        idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/srem_mod.S b/arch/m68k/fpsp040/srem_mod.S
index 8c8d7f50cc68..a27e70c9a0eb 100644
--- a/arch/m68k/fpsp040/srem_mod.S
+++ b/arch/m68k/fpsp040/srem_mod.S
@@ -66,9 +66,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 SREM_MOD:    |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/ssin.S b/arch/m68k/fpsp040/ssin.S
index 043c91cdd657..a1ef8e01bf06 100644
--- a/arch/m68k/fpsp040/ssin.S
+++ b/arch/m68k/fpsp040/ssin.S
@@ -83,9 +83,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SSIN   idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/ssinh.S b/arch/m68k/fpsp040/ssinh.S
index c8b3308bb143..8a560edc7653 100644
--- a/arch/m68k/fpsp040/ssinh.S
+++ b/arch/m68k/fpsp040/ssinh.S
@@ -49,9 +49,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |SSINH  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/stan.S b/arch/m68k/fpsp040/stan.S
index b5c2a196e617..f8553aaececb 100644
--- a/arch/m68k/fpsp040/stan.S
+++ b/arch/m68k/fpsp040/stan.S
@@ -50,9 +50,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |STAN   idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/stanh.S b/arch/m68k/fpsp040/stanh.S
index 33b009802243..7e12e59ee8c7 100644
--- a/arch/m68k/fpsp040/stanh.S
+++ b/arch/m68k/fpsp040/stanh.S
@@ -49,9 +49,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |STANH  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/sto_res.S b/arch/m68k/fpsp040/sto_res.S
index 0cdca3b060ad..484b47d4eaad 100644
--- a/arch/m68k/fpsp040/sto_res.S
+++ b/arch/m68k/fpsp040/sto_res.S
@@ -19,9 +19,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 STO_RES:        |idnt   2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/stwotox.S b/arch/m68k/fpsp040/stwotox.S
index 4e3c1407d3df..0d5e6a1436a6 100644
--- a/arch/m68k/fpsp040/stwotox.S
+++ b/arch/m68k/fpsp040/stwotox.S
@@ -76,9 +76,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |STWOTOX        idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/tbldo.S b/arch/m68k/fpsp040/tbldo.S
index fe60cf4d20d7..fd5c37a5a2b9 100644
--- a/arch/m68k/fpsp040/tbldo.S
+++ b/arch/m68k/fpsp040/tbldo.S
@@ -17,9 +17,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |TBLDO  idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/util.S b/arch/m68k/fpsp040/util.S
index 452f3d65857b..65b26fa88c60 100644
--- a/arch/m68k/fpsp040/util.S
+++ b/arch/m68k/fpsp040/util.S
@@ -16,9 +16,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 |UTIL   idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_bsun.S b/arch/m68k/fpsp040/x_bsun.S
index 039247b09c8b..d5a576bfac79 100644
--- a/arch/m68k/fpsp040/x_bsun.S
+++ b/arch/m68k/fpsp040/x_bsun.S
@@ -13,9 +13,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_BSUN: |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_fline.S b/arch/m68k/fpsp040/x_fline.S
index 3917710b0fde..264e126d1db7 100644
--- a/arch/m68k/fpsp040/x_fline.S
+++ b/arch/m68k/fpsp040/x_fline.S
@@ -13,9 +13,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_FLINE:        |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_operr.S b/arch/m68k/fpsp040/x_operr.S
index b0f54bcb49a7..e2c371c3a45d 100644
--- a/arch/m68k/fpsp040/x_operr.S
+++ b/arch/m68k/fpsp040/x_operr.S
@@ -43,9 +43,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_OPERR:        |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_ovfl.S b/arch/m68k/fpsp040/x_ovfl.S
index 22cb8b42c7b6..6fe4989ee31f 100644
--- a/arch/m68k/fpsp040/x_ovfl.S
+++ b/arch/m68k/fpsp040/x_ovfl.S
@@ -35,9 +35,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_OVFL: |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_snan.S b/arch/m68k/fpsp040/x_snan.S
index 039af573312e..4ed766416378 100644
--- a/arch/m68k/fpsp040/x_snan.S
+++ b/arch/m68k/fpsp040/x_snan.S
@@ -22,9 +22,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_SNAN: |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_store.S b/arch/m68k/fpsp040/x_store.S
index 4282fa67d449..402dc0c0ebc0 100644
--- a/arch/m68k/fpsp040/x_store.S
+++ b/arch/m68k/fpsp040/x_store.S
@@ -11,9 +11,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_STORE:        |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_unfl.S b/arch/m68k/fpsp040/x_unfl.S
index 077fcc230fcc..eb772ff3b812 100644
--- a/arch/m68k/fpsp040/x_unfl.S
+++ b/arch/m68k/fpsp040/x_unfl.S
@@ -21,9 +21,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_UNFL: |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_unimp.S b/arch/m68k/fpsp040/x_unimp.S
index 920cb9410e9e..6f382b21228b 100644
--- a/arch/m68k/fpsp040/x_unimp.S
+++ b/arch/m68k/fpsp040/x_unimp.S
@@ -22,9 +22,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_UNIMP:        |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68k/fpsp040/x_unsupp.S b/arch/m68k/fpsp040/x_unsupp.S
index 4ec57285b683..d7cf46208c62 100644
--- a/arch/m68k/fpsp040/x_unsupp.S
+++ b/arch/m68k/fpsp040/x_unsupp.S
@@ -23,9 +23,8 @@
 |               Copyright (C) Motorola, Inc. 1990
 |                       All Rights Reserved
 |
-|       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
-|       The copyright notice above does not evidence any
-|       actual or intended publication of such source code.
+|       For details on the license for this file, please see the
+|       file, README, in this same directory.
 
 X_UNSUPP:       |idnt    2,1 | Motorola 040 Floating Point Software Package
 
diff --git a/arch/m68knommu/kernel/process.c b/arch/m68knommu/kernel/process.c
index 99bf43824795..63c117dae0c3 100644
--- a/arch/m68knommu/kernel/process.c
+++ b/arch/m68knommu/kernel/process.c
@@ -39,6 +39,14 @@
 
 asmlinkage void ret_from_fork(void);
 
+/*
+ * The following aren't currently used.
+ */
+void (*pm_idle)(void);
+EXPORT_SYMBOL(pm_idle);
+
+void (*pm_power_off)(void);
+EXPORT_SYMBOL(pm_power_off);
 
 /*
  * The idle loop on an m68knommu..
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index c3e852e9953e..767de847b4ab 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -595,6 +595,7 @@ config SGI_IP32
         select SYS_HAS_CPU_R5000
         select SYS_HAS_CPU_R10000 if BROKEN
         select SYS_HAS_CPU_RM7000
+        select SYS_HAS_CPU_NEVADA
         select SYS_SUPPORTS_64BIT_KERNEL
         select SYS_SUPPORTS_BIG_ENDIAN
         help
diff --git a/arch/mips/Makefile b/arch/mips/Makefile
index 2a9f2ef27b29..6a57407df1bc 100644
--- a/arch/mips/Makefile
+++ b/arch/mips/Makefile
@@ -53,14 +53,17 @@ CROSS_COMPILE		:= $(tool-prefix)
 endif
 
 CHECKFLAGS-y                            += -D__linux__ -D__mips__ \
+                                           -D_MIPS_SZINT=32 \
                                            -D_ABIO32=1 \
                                            -D_ABIN32=2 \
                                            -D_ABI64=3
 CHECKFLAGS-$(CONFIG_32BIT)              += -D_MIPS_SIM=_ABIO32 \
                                            -D_MIPS_SZLONG=32 \
+                                           -D_MIPS_SZPTR=32 \
                                            -D__PTRDIFF_TYPE__=int
 CHECKFLAGS-$(CONFIG_64BIT)              += -m64 -D_MIPS_SIM=_ABI64 \
                                            -D_MIPS_SZLONG=64 \
+                                           -D_MIPS_SZPTR=64 \
                                            -D__PTRDIFF_TYPE__="long int"
 CHECKFLAGS-$(CONFIG_CPU_BIG_ENDIAN)     += -D__MIPSEB__
 CHECKFLAGS-$(CONFIG_CPU_LITTLE_ENDIAN)  += -D__MIPSEL__
@@ -166,79 +169,97 @@ echo $$gcc_abi $$gcc_opt$$gcc_cpu $$gcc_isa $$gas_abi $$gas_opt$$gas_cpu $$gas_i
 #
 cflags-$(CONFIG_CPU_R3000)      += \
                         $(call set_gccflags,r3000,mips1,r3000,mips1,mips1)
+CHECKFLAGS-$(CONFIG_CPU_R3000)  += -D_MIPS_ISA=_MIPS_ISA_MIPS1
 
 cflags-$(CONFIG_CPU_TX39XX)     += \
                         $(call set_gccflags,r3900,mips1,r3000,mips1,mips1)
+CHECKFLAGS-$(CONFIG_CPU_TX39XX) += -D_MIPS_ISA=_MIPS_ISA_MIPS1
 
 cflags-$(CONFIG_CPU_R6000)      += \
                         $(call set_gccflags,r6000,mips2,r6000,mips2,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_R6000)  += -D_MIPS_ISA=_MIPS_ISA_MIPS2
 
 cflags-$(CONFIG_CPU_R4300)      += \
                         $(call set_gccflags,r4300,mips3,r4300,mips3,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_R4300)  += -D_MIPS_ISA=_MIPS_ISA_MIPS3
 
 cflags-$(CONFIG_CPU_VR41XX)     += \
                         $(call set_gccflags,r4100,mips3,r4600,mips3,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_VR41XX) += -D_MIPS_ISA=_MIPS_ISA_MIPS3
 
 cflags-$(CONFIG_CPU_R4X00)      += \
                         $(call set_gccflags,r4600,mips3,r4600,mips3,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_R4X00)  += -D_MIPS_ISA=_MIPS_ISA_MIPS3
 
 cflags-$(CONFIG_CPU_TX49XX)     += \
                         $(call set_gccflags,r4600,mips3,r4600,mips3,mips2)  \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_TX49XX) += -D_MIPS_ISA=_MIPS_ISA_MIPS3
 
 cflags-$(CONFIG_CPU_MIPS32_R1)  += \
                         $(call set_gccflags,mips32,mips32,r4600,mips3,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_MIPS32_R1)      += -D_MIPS_ISA=_MIPS_ISA_MIPS32
 
 cflags-$(CONFIG_CPU_MIPS32_R2)  += \
                         $(call set_gccflags,mips32r2,mips32r2,r4600,mips3,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_MIPS32_R2)      += -D_MIPS_ISA=_MIPS_ISA_MIPS32
 
 cflags-$(CONFIG_CPU_MIPS64_R1)  += \
                         $(call set_gccflags,mips64,mips64,r4600,mips3,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_MIPS64_R1)      += -D_MIPS_ISA=_MIPS_ISA_MIPS64
 
 cflags-$(CONFIG_CPU_MIPS64_R2)  += \
                         $(call set_gccflags,mips64r2,mips64r2,r4600,mips3,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_MIPS64_R2)      += -D_MIPS_ISA=_MIPS_ISA_MIPS64
 
 cflags-$(CONFIG_CPU_R5000)      += \
                         $(call set_gccflags,r5000,mips4,r5000,mips4,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_R5000)  += -D_MIPS_ISA=_MIPS_ISA_MIPS4
 
 cflags-$(CONFIG_CPU_R5432)      += \
                         $(call set_gccflags,r5400,mips4,r5000,mips4,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_R5432)  += -D_MIPS_ISA=_MIPS_ISA_MIPS4
 
 cflags-$(CONFIG_CPU_NEVADA)     += \
                         $(call set_gccflags,rm5200,mips4,r5000,mips4,mips2) \
                         -Wa,--trap
-#                       $(call cc-option,-mmad)
+CHECKFLAGS-$(CONFIG_CPU_NEVADA) += -D_MIPS_ISA=_MIPS_ISA_MIPS4
 
 cflags-$(CONFIG_CPU_RM7000)     += \
                         $(call set_gccflags,rm7000,mips4,r5000,mips4,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_RM7000) += -D_MIPS_ISA=_MIPS_ISA_MIPS4
 
 cflags-$(CONFIG_CPU_RM9000)     += \
                         $(call set_gccflags,rm9000,mips4,r5000,mips4,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_RM9000) += -D_MIPS_ISA=_MIPS_ISA_MIPS4
 
 
 cflags-$(CONFIG_CPU_SB1)        += \
                         $(call set_gccflags,sb1,mips64,r5000,mips4,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_SB1)    += -D_MIPS_ISA=_MIPS_ISA_MIPS64
 
 cflags-$(CONFIG_CPU_R8000)      += \
                         $(call set_gccflags,r8000,mips4,r8000,mips4,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_R8000)  += -D_MIPS_ISA=_MIPS_ISA_MIPS4
 
 cflags-$(CONFIG_CPU_R10000)     += \
                         $(call set_gccflags,r10000,mips4,r8000,mips4,mips2) \
                         -Wa,--trap
+CHECKFLAGS-$(CONFIG_CPU_R10000) += -D_MIPS_ISA=_MIPS_ISA_MIPS4
 
 ifdef CONFIG_CPU_SB1
 ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
@@ -369,7 +390,7 @@ load-$(CONFIG_MIPS_XXS1500)	+= 0xffffffff80100000
 # Cobalt Server
 #
 core-$(CONFIG_MIPS_COBALT)      += arch/mips/cobalt/
-cflags-$(CONFIG_MIPS_COBALT)    += -Iinclude/asm-mips/cobalt
+cflags-$(CONFIG_MIPS_COBALT)    += -Iinclude/asm-mips/mach-cobalt
 load-$(CONFIG_MIPS_COBALT)      += 0xffffffff80080000
 
 #
diff --git a/arch/mips/au1000/common/reset.c b/arch/mips/au1000/common/reset.c
index 65b84db800e4..4ffccedf5967 100644
--- a/arch/mips/au1000/common/reset.c
+++ b/arch/mips/au1000/common/reset.c
@@ -151,7 +151,7 @@ void au1000_restart(char *command)
         }
 
         set_c0_status(ST0_BEV | ST0_ERL);
-        set_c0_config(CONF_CM_UNCACHED);
+        change_c0_config(CONF_CM_CMASK, CONF_CM_UNCACHED);
         flush_cache_all();
         write_c0_wired(0);
 
diff --git a/arch/mips/au1000/common/setup.c b/arch/mips/au1000/common/setup.c
index 08c8c855cc9c..eb155c071aa6 100644
--- a/arch/mips/au1000/common/setup.c
+++ b/arch/mips/au1000/common/setup.c
@@ -33,6 +33,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
+#include <linux/pm.h>
 
 #include <asm/cpu.h>
 #include <asm/bootinfo.h>
@@ -125,7 +126,7 @@ void __init plat_setup(void)
 #endif
         _machine_restart = au1000_restart;
         _machine_halt = au1000_halt;
-        _machine_power_off = au1000_power_off;
+        pm_power_off = au1000_power_off;
         board_time_init = au1xxx_time_init;
         board_timer_setup = au1xxx_timer_setup;
 
diff --git a/arch/mips/cobalt/int-handler.S b/arch/mips/cobalt/int-handler.S
index f92608e8d84f..e75d5e3ca868 100644
--- a/arch/mips/cobalt/int-handler.S
+++ b/arch/mips/cobalt/int-handler.S
@@ -8,7 +8,7 @@
  */
 #include <asm/asm.h>
 #include <asm/mipsregs.h>
-#include <asm/cobalt/cobalt.h>
+#include <asm/mach-cobalt/cobalt.h>
 #include <asm/regdef.h>
 #include <asm/stackframe.h>
 
diff --git a/arch/mips/cobalt/irq.c b/arch/mips/cobalt/irq.c
index 0d90851f925e..f9a108820d6e 100644
--- a/arch/mips/cobalt/irq.c
+++ b/arch/mips/cobalt/irq.c
@@ -18,7 +18,7 @@
 #include <asm/gt64120.h>
 #include <asm/ptrace.h>
 
-#include <asm/cobalt/cobalt.h>
+#include <asm/mach-cobalt/cobalt.h>
 
 extern void cobalt_handle_int(void);
 
diff --git a/arch/mips/cobalt/reset.c b/arch/mips/cobalt/reset.c
index 805a0e88507b..753dfccae6fa 100644
--- a/arch/mips/cobalt/reset.c
+++ b/arch/mips/cobalt/reset.c
@@ -16,7 +16,7 @@
 #include <asm/reboot.h>
 #include <asm/system.h>
 #include <asm/mipsregs.h>
-#include <asm/cobalt/cobalt.h>
+#include <asm/mach-cobalt/cobalt.h>
 
 void cobalt_machine_halt(void)
 {
diff --git a/arch/mips/cobalt/setup.c b/arch/mips/cobalt/setup.c
index d358a118fa31..b9713a723053 100644
--- a/arch/mips/cobalt/setup.c
+++ b/arch/mips/cobalt/setup.c
@@ -5,7 +5,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 1996, 1997, 2004 by Ralf Baechle (ralf@linux-mips.org)
+ * Copyright (C) 1996, 1997, 2004, 05 by Ralf Baechle (ralf@linux-mips.org)
  * Copyright (C) 2001, 2002, 2003 by Liam Davies (ldavies@agile.tv)
  *
  */
@@ -13,6 +13,7 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/pm.h>
 #include <linux/serial.h>
 #include <linux/serial_core.h>
 
@@ -25,7 +26,7 @@
 #include <asm/gt64120.h>
 #include <asm/serial.h>
 
-#include <asm/cobalt/cobalt.h>
+#include <asm/mach-cobalt/cobalt.h>
 
 extern void cobalt_machine_restart(char *command);
 extern void cobalt_machine_halt(void);
@@ -99,7 +100,7 @@ void __init plat_setup(void)
 
         _machine_restart = cobalt_machine_restart;
         _machine_halt = cobalt_machine_halt;
-        _machine_power_off = cobalt_machine_power_off;
+        pm_power_off = cobalt_machine_power_off;
 
         board_timer_setup = cobalt_timer_setup;
 
@@ -139,7 +140,7 @@ void __init plat_setup(void)
                 uart.type       = PORT_UNKNOWN;
                 uart.uartclk    = 18432000;
                 uart.irq        = COBALT_SERIAL_IRQ;
-                uart.flags      = STD_COM_FLAGS;
+                uart.flags      = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
                 uart.iobase     = 0xc800000;
                 uart.iotype     = UPIO_PORT;
 
diff --git a/arch/mips/configs/ip32_defconfig b/arch/mips/configs/ip32_defconfig
index 967e7acd8e1f..a34db6e82b27 100644
--- a/arch/mips/configs/ip32_defconfig
+++ b/arch/mips/configs/ip32_defconfig
@@ -102,6 +102,7 @@ CONFIG_CPU_R5000=y
 # CONFIG_CPU_RM9000 is not set
 # CONFIG_CPU_SB1 is not set
 CONFIG_SYS_HAS_CPU_R5000=y
+CONFIG_SYS_HAS_CPU_NEVADA=y
 CONFIG_SYS_HAS_CPU_RM7000=y
 CONFIG_SYS_SUPPORTS_64BIT_KERNEL=y
 CONFIG_CPU_SUPPORTS_32BIT_KERNEL=y
diff --git a/arch/mips/configs/qemu_defconfig b/arch/mips/configs/qemu_defconfig
index dee44606164c..c02becab850b 100644
--- a/arch/mips/configs/qemu_defconfig
+++ b/arch/mips/configs/qemu_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.15-rc2
-# Thu Nov 24 01:07:00 2005
+# Linux kernel version: 2.6.16-rc2
+# Fri Feb  3 17:14:27 2006
 #
 CONFIG_MIPS=y
 
@@ -147,26 +147,27 @@ CONFIG_LOCALVERSION_AUTO=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_SYSCTL is not set
 # CONFIG_AUDIT is not set
-# CONFIG_HOTPLUG is not set
-CONFIG_KOBJECT_UEVENT=y
 # CONFIG_IKCONFIG is not set
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_EMBEDDED=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 # CONFIG_BUG is not set
+CONFIG_ELF_CORE=y
 # CONFIG_BASE_FULL is not set
 # CONFIG_FUTEX is not set
 # CONFIG_EPOLL is not set
-# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 # CONFIG_SHMEM is not set
 CONFIG_CC_ALIGN_FUNCTIONS=0
 CONFIG_CC_ALIGN_LABELS=0
 CONFIG_CC_ALIGN_LOOPS=0
 CONFIG_CC_ALIGN_JUMPS=0
+CONFIG_SLAB=y
 CONFIG_TINY_SHMEM=y
 CONFIG_BASE_SMALL=1
+# CONFIG_SLOB is not set
 
 #
 # Loadable module support
@@ -266,11 +267,7 @@ CONFIG_TCP_CONG_BIC=y
 # CONFIG_HAMRADIO is not set
 # CONFIG_IRDA is not set
 # CONFIG_BT is not set
-CONFIG_IEEE80211=y
-# CONFIG_IEEE80211_DEBUG is not set
-CONFIG_IEEE80211_CRYPT_WEP=y
-CONFIG_IEEE80211_CRYPT_CCMP=y
-CONFIG_IEEE80211_CRYPT_TKIP=y
+# CONFIG_IEEE80211 is not set
 
 #
 # Device Drivers
@@ -323,7 +320,7 @@ CONFIG_BLK_DEV_RAM_COUNT=16
 #
 # SCSI device support
 #
-CONFIG_RAID_ATTRS=y
+# CONFIG_RAID_ATTRS is not set
 # CONFIG_SCSI is not set
 
 #
@@ -366,24 +363,16 @@ CONFIG_NETDEVICES=y
 #
 # PHY device support
 #
-CONFIG_PHYLIB=y
-
-#
-# MII PHY device drivers
-#
-CONFIG_MARVELL_PHY=y
-CONFIG_DAVICOM_PHY=y
-CONFIG_QSEMI_PHY=y
-CONFIG_LXT_PHY=y
-CONFIG_CICADA_PHY=y
+# CONFIG_PHYLIB is not set
 
 #
 # Ethernet (10 or 100Mbit)
 #
 CONFIG_NET_ETHERNET=y
-CONFIG_MII=y
+# CONFIG_MII is not set
 # CONFIG_NET_VENDOR_3COM is not set
 # CONFIG_NET_VENDOR_SMC is not set
+# CONFIG_DM9000 is not set
 # CONFIG_NET_VENDOR_RACAL is not set
 # CONFIG_DEPCA is not set
 # CONFIG_HP100 is not set
@@ -479,6 +468,7 @@ CONFIG_HW_CONSOLE=y
 CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
 CONFIG_SERIAL_8250_NR_UARTS=4
+CONFIG_SERIAL_8250_RUNTIME_UARTS=4
 # CONFIG_SERIAL_8250_EXTENDED is not set
 
 #
@@ -518,6 +508,12 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 # CONFIG_I2C is not set
 
 #
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
 # Dallas's 1-wire bus
 #
 # CONFIG_W1 is not set
@@ -592,11 +588,14 @@ CONFIG_DUMMY_CONSOLE=y
 #
 
 #
+# EDAC - error detection and reporting (RAS)
+#
+
+#
 # File systems
 #
 # CONFIG_EXT2_FS is not set
 # CONFIG_EXT3_FS is not set
-# CONFIG_JBD is not set
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
 # CONFIG_FS_POSIX_ACL is not set
@@ -677,6 +676,7 @@ CONFIG_MSDOS_PARTITION=y
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
+# CONFIG_MAGIC_SYSRQ is not set
 # CONFIG_DEBUG_KERNEL is not set
 CONFIG_LOG_BUF_SHIFT=14
 CONFIG_CROSSCOMPILE=y
@@ -690,31 +690,7 @@ CONFIG_CMDLINE="console=ttyS0 debug ip=172.20.0.2:172.20.0.1::255.255.0.0"
 #
 # Cryptographic options
 #
-CONFIG_CRYPTO=y
-CONFIG_CRYPTO_HMAC=y
-CONFIG_CRYPTO_NULL=y
-CONFIG_CRYPTO_MD4=y
-CONFIG_CRYPTO_MD5=y
-CONFIG_CRYPTO_SHA1=y
-CONFIG_CRYPTO_SHA256=y
-CONFIG_CRYPTO_SHA512=y
-CONFIG_CRYPTO_WP512=y
-CONFIG_CRYPTO_TGR192=y
-CONFIG_CRYPTO_DES=y
-CONFIG_CRYPTO_BLOWFISH=y
-CONFIG_CRYPTO_TWOFISH=y
-CONFIG_CRYPTO_SERPENT=y
-CONFIG_CRYPTO_AES=y
-CONFIG_CRYPTO_CAST5=y
-CONFIG_CRYPTO_CAST6=y
-CONFIG_CRYPTO_TEA=y
-CONFIG_CRYPTO_ARC4=y
-CONFIG_CRYPTO_KHAZAD=y
-CONFIG_CRYPTO_ANUBIS=y
-CONFIG_CRYPTO_DEFLATE=y
-CONFIG_CRYPTO_MICHAEL_MIC=y
-CONFIG_CRYPTO_CRC32C=y
-# CONFIG_CRYPTO_TEST is not set
+# CONFIG_CRYPTO is not set
 
 #
 # Hardware crypto devices
@@ -724,8 +700,6 @@ CONFIG_CRYPTO_CRC32C=y
 # Library routines
 #
 # CONFIG_CRC_CCITT is not set
-CONFIG_CRC16=y
+# CONFIG_CRC16 is not set
 CONFIG_CRC32=y
-CONFIG_LIBCRC32C=y
-CONFIG_ZLIB_INFLATE=y
-CONFIG_ZLIB_DEFLATE=y
+# CONFIG_LIBCRC32C is not set
diff --git a/arch/mips/ddb5xxx/ddb5074/setup.c b/arch/mips/ddb5xxx/ddb5074/setup.c
index 11535be265b9..91456b068c2e 100644
--- a/arch/mips/ddb5xxx/ddb5074/setup.c
+++ b/arch/mips/ddb5xxx/ddb5074/setup.c
@@ -14,6 +14,7 @@
 #include <linux/ide.h>
 #include <linux/ioport.h>
 #include <linux/irq.h>
+#include <linux/pm.h>
 
 #include <asm/addrspace.h>
 #include <asm/bcache.h>
@@ -95,7 +96,7 @@ void __init plat_setup(void)
 
         _machine_restart = ddb_machine_restart;
         _machine_halt = ddb_machine_halt;
-        _machine_power_off = ddb_machine_power_off;
+        pm_power_off = ddb_machine_power_off;
 
         ddb_out32(DDB_BAR0, 0);
 
diff --git a/arch/mips/ddb5xxx/ddb5476/setup.c b/arch/mips/ddb5xxx/ddb5476/setup.c
index f4e480a74edf..c902adef5942 100644
--- a/arch/mips/ddb5xxx/ddb5476/setup.c
+++ b/arch/mips/ddb5xxx/ddb5476/setup.c
@@ -11,6 +11,7 @@
 #include <linux/types.h>
 #include <linux/sched.h>
 #include <linux/pci.h>
+#include <linux/pm.h>
 
 #include <asm/addrspace.h>
 #include <asm/bcache.h>
@@ -133,7 +134,7 @@ void __init plat_setup(void)
 
         _machine_restart = ddb_machine_restart;
         _machine_halt = ddb_machine_halt;
-        _machine_power_off = ddb_machine_power_off;
+        pm_power_off = ddb_machine_power_off;
 
         /* request io port/mem resources  */
         if (request_resource(&ioport_resource, &ddb5476_ioport.dma1) ||
diff --git a/arch/mips/ddb5xxx/ddb5477/setup.c b/arch/mips/ddb5xxx/ddb5477/setup.c
index 81163353c4a8..2f566034cc44 100644
--- a/arch/mips/ddb5xxx/ddb5477/setup.c
+++ b/arch/mips/ddb5xxx/ddb5477/setup.c
@@ -26,6 +26,7 @@
 #include <linux/major.h>
 #include <linux/kdev_t.h>
 #include <linux/root_dev.h>
+#include <linux/pm.h>
 
 #include <asm/cpu.h>
 #include <asm/bootinfo.h>
@@ -182,7 +183,7 @@ void __init plat_setup(void)
 
         _machine_restart = ddb_machine_restart;
         _machine_halt = ddb_machine_halt;
-        _machine_power_off = ddb_machine_power_off;
+        pm_power_off = ddb_machine_power_off;
 
         /* setup resource limits */
         ioport_resource.end = DDB_PCI0_IO_SIZE + DDB_PCI1_IO_SIZE - 1;
diff --git a/arch/mips/dec/setup.c b/arch/mips/dec/setup.c
index 9ef54fe1feaa..7c1ca8f6330e 100644
--- a/arch/mips/dec/setup.c
+++ b/arch/mips/dec/setup.c
@@ -17,6 +17,7 @@
 #include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <linux/types.h>
+#include <linux/pm.h>
 
 #include <asm/bootinfo.h>
 #include <asm/cpu.h>
@@ -158,7 +159,7 @@ void __init plat_setup(void)
 
         _machine_restart = dec_machine_restart;
         _machine_halt = dec_machine_halt;
-        _machine_power_off = dec_machine_power_off;
+        pm_power_off = dec_machine_power_off;
 
         ioport_resource.start = ~0UL;
         ioport_resource.end = 0UL;
diff --git a/arch/mips/gt64120/ev64120/setup.c b/arch/mips/gt64120/ev64120/setup.c
index 98b5a96cc039..6d859d1e7a2d 100644
--- a/arch/mips/gt64120/ev64120/setup.c
+++ b/arch/mips/gt64120/ev64120/setup.c
@@ -34,6 +34,8 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/timex.h>
+#include <linux/pm.h>
+
 #include <asm/bootinfo.h>
 #include <asm/page.h>
 #include <asm/io.h>
@@ -73,7 +75,7 @@ void __init plat_setup(void)
 {
         _machine_restart = galileo_machine_restart;
         _machine_halt = galileo_machine_halt;
-        _machine_power_off = galileo_machine_power_off;
+        pm_power_off = galileo_machine_power_off;
 
         board_time_init = gt64120_time_init;
         set_io_port_base(KSEG1);
diff --git a/arch/mips/gt64120/momenco_ocelot/setup.c b/arch/mips/gt64120/momenco_ocelot/setup.c
index 0d07c33112d0..20b65d3d2151 100644
--- a/arch/mips/gt64120/momenco_ocelot/setup.c
+++ b/arch/mips/gt64120/momenco_ocelot/setup.c
@@ -4,7 +4,7 @@
  * BRIEF MODULE DESCRIPTION
  * Momentum Computer Ocelot (CP7000) - board dependent boot routines
  *
- * Copyright (C) 1996, 1997, 2001  Ralf Baechle
+ * Copyright (C) 1996, 1997, 2001, 06  Ralf Baechle (ralf@linux-mips.org)
  * Copyright (C) 2000 RidgeRun, Inc.
  * Copyright (C) 2001 Red Hat, Inc.
  * Copyright (C) 2002 Momentum Computer
@@ -47,6 +47,8 @@
 #include <linux/pci.h>
 #include <linux/timex.h>
 #include <linux/vmalloc.h>
+#include <linux/pm.h>
+
 #include <asm/time.h>
 #include <asm/bootinfo.h>
 #include <asm/page.h>
@@ -159,7 +161,7 @@ void __init plat_setup(void)
 
         _machine_restart = momenco_ocelot_restart;
         _machine_halt = momenco_ocelot_halt;
-        _machine_power_off = momenco_ocelot_power_off;
+        pm_power_off = momenco_ocelot_power_off;
 
         /*
          * initrd_start = (ulong)ocelot_initrd_start;
diff --git a/arch/mips/ite-boards/generic/it8172_setup.c b/arch/mips/ite-boards/generic/it8172_setup.c
index 062429dd7ca0..fc73c8d69df7 100644
--- a/arch/mips/ite-boards/generic/it8172_setup.c
+++ b/arch/mips/ite-boards/generic/it8172_setup.c
@@ -34,6 +34,7 @@
 #include <linux/major.h>
 #include <linux/kdev_t.h>
 #include <linux/root_dev.h>
+#include <linux/pm.h>
 
 #include <asm/cpu.h>
 #include <asm/time.h>
@@ -125,7 +126,7 @@ void __init plat_setup(void)
 
         _machine_restart = it8172_restart;
         _machine_halt = it8172_halt;
-        _machine_power_off = it8172_power_off;
+        pm_power_off = it8172_power_off;
 
         /*
          * IO/MEM resources.
diff --git a/arch/mips/jazz/setup.c b/arch/mips/jazz/setup.c
index 044df9d4ab7c..4036dc434551 100644
--- a/arch/mips/jazz/setup.c
+++ b/arch/mips/jazz/setup.c
@@ -19,6 +19,8 @@
 #include <linux/console.h>
 #include <linux/fb.h>
 #include <linux/ide.h>
+#include <linux/pm.h>
+
 #include <asm/bootinfo.h>
 #include <asm/irq.h>
 #include <asm/jazz.h>
@@ -79,7 +81,7 @@ void __init plat_setup(void)
 
         _machine_restart = jazz_machine_restart;
         _machine_halt = jazz_machine_halt;
-        _machine_power_off = jazz_machine_power_off;
+        pm_power_off = jazz_machine_power_off;
 
 #warning "Somebody should check if screen_info is ok for Jazz."
 
diff --git a/arch/mips/jmr3927/rbhma3100/setup.c b/arch/mips/jmr3927/rbhma3100/setup.c
index 4763957df8fc..9359cc413494 100644
--- a/arch/mips/jmr3927/rbhma3100/setup.c
+++ b/arch/mips/jmr3927/rbhma3100/setup.c
@@ -44,6 +44,7 @@
 #include <linux/ioport.h>
 #include <linux/param.h>        /* for HZ */
 #include <linux/delay.h>
+#include <linux/pm.h>
 #ifdef CONFIG_SERIAL_TXX9
 #include <linux/tty.h>
 #include <linux/serial.h>
@@ -211,7 +212,7 @@ void __init plat_setup(void)
 
         _machine_restart = jmr3927_machine_restart;
         _machine_halt = jmr3927_machine_halt;
-        _machine_power_off = jmr3927_machine_power_off;
+        pm_power_off = jmr3927_machine_power_off;
 
         /*
          * IO/MEM resources.
diff --git a/arch/mips/kernel/cpu-probe.c b/arch/mips/kernel/cpu-probe.c
index fac48ad27b34..292f8b243a5e 100644
--- a/arch/mips/kernel/cpu-probe.c
+++ b/arch/mips/kernel/cpu-probe.c
@@ -2,8 +2,8 @@
  * Processor capabilities determination functions.
  *
  * Copyright (C) xxxx  the Anonymous
+ * Copyright (C) 1994 - 2006 Ralf Baechle
  * Copyright (C) 2003, 2004  Maciej W. Rozycki
- * Copyright (C) 1994 - 2003 Ralf Baechle
  * Copyright (C) 2001, 2004  MIPS Inc.
  *
  * This program is free software; you can redistribute it and/or
@@ -641,10 +641,9 @@ static inline void cpu_probe_sibyte(struct cpuinfo_mips *c)
         switch (c->processor_id & 0xff00) {
         case PRID_IMP_SB1:
                 c->cputype = CPU_SB1;
-#ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
                 /* FPU in pass1 is known to have issues. */
-                c->options &= ~(MIPS_CPU_FPU | MIPS_CPU_32FPR);
-#endif
+                if ((c->processor_id & 0xff) < 0x20)
+                        c->options &= ~(MIPS_CPU_FPU | MIPS_CPU_32FPR);
                 break;
         case PRID_IMP_SB1A:
                 c->cputype = CPU_SB1A;
diff --git a/arch/mips/kernel/gdb-stub.c b/arch/mips/kernel/gdb-stub.c
index 96d18c43dca0..d4f88e0af24c 100644
--- a/arch/mips/kernel/gdb-stub.c
+++ b/arch/mips/kernel/gdb-stub.c
@@ -178,7 +178,7 @@ int kgdb_enabled;
  */
 static DEFINE_SPINLOCK(kgdb_lock);
 static raw_spinlock_t kgdb_cpulock[NR_CPUS] = {
-        [0 ... NR_CPUS-1] = __RAW_SPIN_LOCK_UNLOCKED;
+        [0 ... NR_CPUS-1] = __RAW_SPIN_LOCK_UNLOCKED,
 };
 
 /*
diff --git a/arch/mips/kernel/genex.S b/arch/mips/kernel/genex.S
index aa18a8b7b380..13f22d1d0e8b 100644
--- a/arch/mips/kernel/genex.S
+++ b/arch/mips/kernel/genex.S
@@ -233,11 +233,11 @@ NESTED(except_vec_nmi, 0, sp)
 NESTED(nmi_handler, PT_SIZE, sp)
         .set    push
         .set    noat
-        .set    mips3
         SAVE_ALL
         move    a0, sp
         jal     nmi_exception_handler
         RESTORE_ALL
+        .set    mips3
         eret
         .set    pop
         END(nmi_handler)
diff --git a/arch/mips/kernel/process.c b/arch/mips/kernel/process.c
index fa98f10d0132..5232fc752935 100644
--- a/arch/mips/kernel/process.c
+++ b/arch/mips/kernel/process.c
@@ -4,6 +4,7 @@
  * for more details.
  *
  * Copyright (C) 1994 - 1999, 2000 by Ralf Baechle and others.
+ * Copyright (C) 2005, 2006 by Ralf Baechle (ralf@linux-mips.org)
  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  * Copyright (C) 2004 Thiemo Seufer
  */
@@ -58,8 +59,8 @@ ATTRIB_NORET void cpu_idle(void)
         }
 }
 
-extern int do_signal(sigset_t *oldset, struct pt_regs *regs);
-extern int do_signal32(sigset_t *oldset, struct pt_regs *regs);
+extern void do_signal(struct pt_regs *regs);
+extern void do_signal32(struct pt_regs *regs);
 
 /*
  * Native o32 and N64 ABI without DSP ASE
diff --git a/arch/mips/kernel/ptrace32.c b/arch/mips/kernel/ptrace32.c
index 0c82b25d8c6d..0d5cf97af727 100644
--- a/arch/mips/kernel/ptrace32.c
+++ b/arch/mips/kernel/ptrace32.c
@@ -88,7 +88,7 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                 ret = -EIO;
                 if (copied != sizeof(tmp))
                         break;
-                ret = put_user(tmp, (unsigned int *) (unsigned long) data);
+                ret = put_user(tmp, (unsigned int __user *) (unsigned long) data);
                 break;
         }
 
@@ -174,8 +174,10 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                 case FPC_EIR: { /* implementation / version register */
                         unsigned int flags;
 
-                        if (!cpu_has_fpu)
+                        if (!cpu_has_fpu) {
+                                tmp = 0;
                                 break;
+                        }
 
                         preempt_disable();
                         if (cpu_has_mipsmt) {
@@ -194,15 +196,18 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                         preempt_enable();
                         break;
                 }
-                case DSP_BASE ... DSP_BASE + 5:
+                case DSP_BASE ... DSP_BASE + 5: {
+                        dspreg_t *dregs;
+
                         if (!cpu_has_dsp) {
                                 tmp = 0;
                                 ret = -EIO;
                                 goto out_tsk;
                         }
-                        dspreg_t *dregs = __get_dsp_regs(child);
+                        dregs = __get_dsp_regs(child);
                         tmp = (unsigned long) (dregs[addr - DSP_BASE]);
                         break;
+                }
                 case DSP_CONTROL:
                         if (!cpu_has_dsp) {
                                 tmp = 0;
@@ -216,7 +221,7 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                         ret = -EIO;
                         goto out_tsk;
                 }
-                ret = put_user(tmp, (unsigned *) (unsigned long) data);
+                ret = put_user(tmp, (unsigned __user *) (unsigned long) data);
                 break;
         }
 
@@ -304,15 +309,18 @@ asmlinkage int sys32_ptrace(int request, int pid, int addr, int data)
                         else
                                 child->thread.fpu.soft.fcr31 = data;
                         break;
-                case DSP_BASE ... DSP_BASE + 5:
+                case DSP_BASE ... DSP_BASE + 5: {
+                        dspreg_t *dregs;
+
                         if (!cpu_has_dsp) {
                                 ret = -EIO;
                                 break;
                         }
 
-                        dspreg_t *dregs = __get_dsp_regs(child);
+                        dregs = __get_dsp_regs(child);
                         dregs[addr - DSP_BASE] = data;
                         break;
+                }
                 case DSP_CONTROL:
                         if (!cpu_has_dsp) {
                                 ret = -EIO;
diff --git a/arch/mips/kernel/reset.c b/arch/mips/kernel/reset.c
index 5e37df3111ad..621037db2290 100644
--- a/arch/mips/kernel/reset.c
+++ b/arch/mips/kernel/reset.c
@@ -3,17 +3,16 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 2001 by Ralf Baechle
+ * Copyright (C) 2001, 06 by Ralf Baechle (ralf@linux-mips.org)
  * Copyright (C) 2001 MIPS Technologies, Inc.
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/pm.h>
 #include <linux/types.h>
 #include <linux/reboot.h>
-#include <asm/reboot.h>
 
-void (*pm_power_off)(void);
-EXPORT_SYMBOL(pm_power_off);
+#include <asm/reboot.h>
 
 /*
  * Urgs ...  Too many MIPS machines to handle this in a generic way.
@@ -22,23 +21,22 @@ EXPORT_SYMBOL(pm_power_off);
  */
 void (*_machine_restart)(char *command);
 void (*_machine_halt)(void);
-void (*_machine_power_off)(void);
+void (*pm_power_off)(void);
 
 void machine_restart(char *command)
 {
-        _machine_restart(command);
+        if (_machine_restart)
+                _machine_restart(command);
 }
 
 void machine_halt(void)
 {
-        _machine_halt();
+        if (_machine_halt)
+                _machine_halt();
 }
 
 void machine_power_off(void)
 {
         if (pm_power_off)
                 pm_power_off();
-
-        _machine_power_off();
 }
-
diff --git a/arch/mips/kernel/rtlx.c b/arch/mips/kernel/rtlx.c
index 1d855112bac2..986a9cf23067 100644
--- a/arch/mips/kernel/rtlx.c
+++ b/arch/mips/kernel/rtlx.c
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2005 MIPS Technologies, Inc.  All rights reserved.
+ * Copyright (C) 2005, 06 Ralf Baechle (ralf@linux-mips.org)
  *
  *  This program is free software; you can distribute it and/or modify it
  *  under the terms of the GNU General Public License (Version 2) as
@@ -20,9 +21,12 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
 #include <linux/poll.h>
 #include <linux/sched.h>
 #include <linux/wait.h>
+
 #include <asm/mipsmtregs.h>
 #include <asm/bitops.h>
 #include <asm/cpu.h>
diff --git a/arch/mips/kernel/scall32-o32.S b/arch/mips/kernel/scall32-o32.S
index a42e0e8caa7b..d83e033dbc87 100644
--- a/arch/mips/kernel/scall32-o32.S
+++ b/arch/mips/kernel/scall32-o32.S
@@ -617,6 +617,23 @@ einval:	li	v0, -EINVAL
         sys     sys_inotify_init        0
         sys     sys_inotify_add_watch   3       /* 4285 */
         sys     sys_inotify_rm_watch    2
+        sys     sys_migrate_pages       4
+        sys     sys_openat              4
+        sys     sys_mkdirat             3
+        sys     sys_mknodat             4       /* 4290 */
+        sys     sys_fchownat            5
+        sys     sys_futimesat           3
+        sys     sys_fstatat64           4
+        sys     sys_unlinkat            3
+        sys     sys_renameat            4       /* 4295 */
+        sys     sys_linkat              4
+        sys     sys_symlinkat           3
+        sys     sys_readlinkat          4
+        sys     sys_fchmodat            3
+        sys     sys_faccessat           3       /* 4300 */
+        sys     sys_pselect6            6
+        sys     sys_ppoll               5
+        sys     sys_unshare             1
         .endm
 
         /* We pre-compute the number of _instruction_ bytes needed to
diff --git a/arch/mips/kernel/scall64-64.S b/arch/mips/kernel/scall64-64.S
index 47bfbd416709..98bf25df56f3 100644
--- a/arch/mips/kernel/scall64-64.S
+++ b/arch/mips/kernel/scall64-64.S
@@ -443,3 +443,20 @@ sys_call_table:
         PTR     sys_inotify_init
         PTR     sys_inotify_add_watch
         PTR     sys_inotify_rm_watch            /* 5245 */
+        PTR     sys_migrate_pages
+        PTR     sys_openat
+        PTR     sys_mkdirat
+        PTR     sys_mknodat
+        PTR     sys_fchownat                    /* 5250 */
+        PTR     sys_futimesat
+        PTR     sys_newfstatat
+        PTR     sys_unlinkat
+        PTR     sys_renameat
+        PTR     sys_linkat                      /* 5255 */
+        PTR     sys_symlinkat
+        PTR     sys_readlinkat
+        PTR     sys_fchmodat
+        PTR     sys_faccessat
+        PTR     sys_pselect6                    /* 5260 */
+        PTR     sys_ppoll
+        PTR     sys_unshare
diff --git a/arch/mips/kernel/scall64-n32.S b/arch/mips/kernel/scall64-n32.S
index b465ced1758f..bc4980cefc8b 100644
--- a/arch/mips/kernel/scall64-n32.S
+++ b/arch/mips/kernel/scall64-n32.S
@@ -369,3 +369,20 @@ EXPORT(sysn32_call_table)
         PTR     sys_inotify_init
         PTR     sys_inotify_add_watch
         PTR     sys_inotify_rm_watch
+        PTR     sys_migrate_pages               /* 6250 */
+        PTR     sys_openat
+        PTR     sys_mkdirat
+        PTR     sys_mknodat
+        PTR     sys_fchownat
+        PTR     sys_futimesat                   /* 6255 */
+        PTR     sys_newfstatat
+        PTR     sys_unlinkat
+        PTR     sys_renameat
+        PTR     sys_linkat
+        PTR     sys_symlinkat                   /* 6260 */
+        PTR     sys_readlinkat
+        PTR     sys_fchmodat
+        PTR     sys_faccessat
+        PTR     sys_pselect6
+        PTR     sys_ppoll                       /* 6265 */
+        PTR     sys_unshare
diff --git a/arch/mips/kernel/scall64-o32.S b/arch/mips/kernel/scall64-o32.S
index 3d338ca7eeeb..5b0414018c9a 100644
--- a/arch/mips/kernel/scall64-o32.S
+++ b/arch/mips/kernel/scall64-o32.S
@@ -491,4 +491,21 @@ sys_call_table:
         PTR     sys_inotify_init
         PTR     sys_inotify_add_watch           /* 4285 */
         PTR     sys_inotify_rm_watch
+        PTR     sys_migrate_pages
+        PTR     compat_sys_openat
+        PTR     sys_mkdirat
+        PTR     sys_mknodat                     /* 4290 */
+        PTR     sys_fchownat
+        PTR     compat_sys_futimesat
+        PTR     compat_sys_newfstatat
+        PTR     sys_unlinkat
+        PTR     sys_renameat                    /* 4295 */
+        PTR     sys_linkat
+        PTR     sys_symlinkat
+        PTR     sys_readlinkat
+        PTR     sys_fchmodat
+        PTR     sys_faccessat                   /* 4300 */
+        PTR     sys_pselect6
+        PTR     sys_ppoll
+        PTR     sys_unshare
         .size   sys_call_table,.-sys_call_table
diff --git a/arch/mips/kernel/signal-common.h b/arch/mips/kernel/signal-common.h
index 0f66ae5838b9..0fbc492d24b4 100644
--- a/arch/mips/kernel/signal-common.h
+++ b/arch/mips/kernel/signal-common.h
@@ -11,7 +11,7 @@
 #include <linux/config.h>
 
 static inline int
-setup_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
+setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
 {
         int err = 0;
 
@@ -82,7 +82,7 @@ out:
 }
 
 static inline int
-restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
+restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
 {
         unsigned int used_math;
         unsigned long treg;
@@ -157,7 +157,7 @@ restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
 /*
  * Determine which stack to use..
  */
-static inline void *
+static inline void __user *
 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 {
         unsigned long sp;
@@ -176,7 +176,7 @@ get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
         if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
                 sp = current->sas_ss_sp + current->sas_ss_size;
 
-        return (void *)((sp - frame_size) & (ICACHE_REFILLS_WORKAROUND_WAR ? 32 : ALMASK));
+        return (void __user *)((sp - frame_size) & (ICACHE_REFILLS_WORKAROUND_WAR ? 32 : ALMASK));
 }
 
 static inline int install_sigtramp(unsigned int __user *tramp,
diff --git a/arch/mips/kernel/signal.c b/arch/mips/kernel/signal.c
index 7d1800fe7038..c974cc9b30eb 100644
--- a/arch/mips/kernel/signal.c
+++ b/arch/mips/kernel/signal.c
@@ -39,8 +39,6 @@
 
 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 
-int do_signal(sigset_t *oldset, struct pt_regs *regs);
-
 /*
  * Atomically swap in the new signal mask, and wait for a signal.
  */
@@ -50,7 +48,7 @@ save_static_function(sys_sigsuspend);
 __attribute_used__ noinline static int
 _sys_sigsuspend(nabi_no_regargs struct pt_regs regs)
 {
-        sigset_t saveset, newset;
+        sigset_t newset;
         sigset_t __user *uset;
 
         uset = (sigset_t __user *) regs.regs[4];
@@ -59,19 +57,15 @@ _sys_sigsuspend(nabi_no_regargs struct pt_regs regs)
         sigdelsetmask(&newset, ~_BLOCKABLE);
 
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         current->blocked = newset;
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        regs.regs[2] = EINTR;
-        regs.regs[7] = 1;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(&saveset, &regs))
-                        return -EINTR;
-        }
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        return -ERESTARTNOHAND;
 }
 #endif
 
@@ -79,7 +73,7 @@ save_static_function(sys_rt_sigsuspend);
 __attribute_used__ noinline static int
 _sys_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
 {
-        sigset_t saveset, newset;
+        sigset_t newset;
         sigset_t __user *unewset;
         size_t sigsetsize;
 
@@ -94,19 +88,15 @@ _sys_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
         sigdelsetmask(&newset, ~_BLOCKABLE);
 
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         current->blocked = newset;
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        regs.regs[2] = EINTR;
-        regs.regs[7] = 1;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(&saveset, &regs))
-                        return -EINTR;
-        }
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        return -ERESTARTNOHAND;
 }
 
 #ifdef CONFIG_TRAD_SIGNALS
@@ -199,10 +189,10 @@ save_static_function(sys_sigreturn);
 __attribute_used__ noinline static void
 _sys_sigreturn(nabi_no_regargs struct pt_regs regs)
 {
-        struct sigframe *frame;
+        struct sigframe __user *frame;
         sigset_t blocked;
 
-        frame = (struct sigframe *) regs.regs[29];
+        frame = (struct sigframe __user *) regs.regs[29];
         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
@@ -236,11 +226,11 @@ save_static_function(sys_rt_sigreturn);
 __attribute_used__ noinline static void
 _sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 {
-        struct rt_sigframe *frame;
+        struct rt_sigframe __user *frame;
         sigset_t set;
         stack_t st;
 
-        frame = (struct rt_sigframe *) regs.regs[29];
+        frame = (struct rt_sigframe __user *) regs.regs[29];
         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
@@ -259,7 +249,7 @@ _sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
                 goto badframe;
         /* It is more difficult to avoid calling this function than to
            call it and ignore errors.  */
-        do_sigaltstack(&st, NULL, regs.regs[29]);
+        do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
 
         /*
          * Don't let your children do this ...
@@ -279,7 +269,7 @@ badframe:
 int setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
         int signr, sigset_t *set)
 {
-        struct sigframe *frame;
+        struct sigframe __user *frame;
         int err = 0;
 
         frame = get_sigframe(ka, regs, sizeof(*frame));
@@ -315,18 +305,18 @@ int setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
                current->comm, current->pid,
                frame, regs->cp0_epc, frame->regs[31]);
 #endif
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(signr, current);
-        return 0;
+        return -EFAULT;
 }
 #endif
 
 int setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
         int signr, sigset_t *set, siginfo_t *info)
 {
-        struct rt_sigframe *frame;
+        struct rt_sigframe __user *frame;
         int err = 0;
 
         frame = get_sigframe(ka, regs, sizeof(*frame));
@@ -340,7 +330,7 @@ int setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
 
         /* Create the ucontext.  */
         err |= __put_user(0, &frame->rs_uc.uc_flags);
-        err |= __put_user(0, &frame->rs_uc.uc_link);
+        err |= __put_user(NULL, &frame->rs_uc.uc_link);
         err |= __put_user((void *)current->sas_ss_sp,
                           &frame->rs_uc.uc_stack.ss_sp);
         err |= __put_user(sas_ss_flags(regs->regs[29]),
@@ -375,11 +365,11 @@ int setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
                current->comm, current->pid,
                frame, regs->cp0_epc, regs->regs[31]);
 #endif
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(signr, current);
-        return 0;
+        return -EFAULT;
 }
 
 static inline int handle_signal(unsigned long sig, siginfo_t *info,
@@ -393,7 +383,7 @@ static inline int handle_signal(unsigned long sig, siginfo_t *info,
                 regs->regs[2] = EINTR;
                 break;
         case ERESTARTSYS:
-                if(!(ka->sa.sa_flags & SA_RESTART)) {
+                if (!(ka->sa.sa_flags & SA_RESTART)) {
                         regs->regs[2] = EINTR;
                         break;
                 }
@@ -420,9 +410,10 @@ static inline int handle_signal(unsigned long sig, siginfo_t *info,
         return ret;
 }
 
-int do_signal(sigset_t *oldset, struct pt_regs *regs)
+void do_signal(struct pt_regs *regs)
 {
         struct k_sigaction ka;
+        sigset_t *oldset;
         siginfo_t info;
         int signr;
 
@@ -432,17 +423,31 @@ int do_signal(sigset_t *oldset, struct pt_regs *regs)
          * if so.
          */
         if (!user_mode(regs))
-                return 1;
+                return;
 
         if (try_to_freeze())
                 goto no_signal;
 
-        if (!oldset)
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
                 oldset = &current->blocked;
 
+
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
-        if (signr > 0)
-                return handle_signal(signr, &info, &ka, oldset, regs);
+        if (signr > 0) {
+                /* Whee!  Actually deliver the signal.  */
+                if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
+                        /*
+                         * A signal was successfully delivered; the saved
+                         * sigmask will have been stored in the signal frame,
+                         * and will be restored by sigreturn, so we can simply
+                         * clear the TIF_RESTORE_SIGMASK flag.
+                         */
+                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                }
+        }
 
 no_signal:
         /*
@@ -463,18 +468,25 @@ no_signal:
                         regs->cp0_epc -= 4;
                 }
         }
-        return 0;
+
+        /*
+         * If there's no signal to deliver, we just put the saved sigmask
+         * back
+         */
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
 
 /*
  * notification of userspace execution resumption
- * - triggered by current->work.notify_resume
+ * - triggered by the TIF_WORK_MASK flags
  */
-asmlinkage void do_notify_resume(struct pt_regs *regs, sigset_t *oldset,
+asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
         __u32 thread_info_flags)
 {
         /* deal with pending signal delivery */
-        if (thread_info_flags & _TIF_SIGPENDING) {
-                current->thread.abi->do_signal(oldset, regs);
-        }
+        if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
+                current->thread.abi->do_signal(regs);
 }
diff --git a/arch/mips/kernel/signal32.c b/arch/mips/kernel/signal32.c
index 98b185bbc947..da3271e1fdac 100644
--- a/arch/mips/kernel/signal32.c
+++ b/arch/mips/kernel/signal32.c
@@ -144,7 +144,7 @@ struct ucontext32 {
 extern void __put_sigset_unknown_nsig(void);
 extern void __get_sigset_unknown_nsig(void);
 
-static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t *ubuf)
+static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
 {
         int err = 0;
 
@@ -269,7 +269,7 @@ asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
                         return -EFAULT;
                 err |= __get_user(handler, &act->sa_handler);
-                new_ka.sa.sa_handler = (void*)(s64)handler;
+                new_ka.sa.sa_handler = (void __user *)(s64)handler;
                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
                 err |= __get_user(mask, &act->sa_mask.sig[0]);
                 if (err)
@@ -299,8 +299,8 @@ asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
 
 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
 {
-        const stack32_t *uss = (const stack32_t *) regs.regs[4];
-        stack32_t *uoss = (stack32_t *) regs.regs[5];
+        const stack32_t __user *uss = (const stack32_t __user *) regs.regs[4];
+        stack32_t __user *uoss = (stack32_t __user *) regs.regs[5];
         unsigned long usp = regs.regs[29];
         stack_t kss, koss;
         int ret, err = 0;
@@ -319,7 +319,8 @@ asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
         }
 
         set_fs (KERNEL_DS);
-        ret = do_sigaltstack(uss ? &kss : NULL , uoss ? &koss : NULL, usp);
+        ret = do_sigaltstack(uss ? (stack_t __user *)&kss : NULL,
+                             uoss ? (stack_t __user *)&koss : NULL, usp);
         set_fs (old_fs);
 
         if (!ret && uoss) {
@@ -335,7 +336,7 @@ asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
         return ret;
 }
 
-static int restore_sigcontext32(struct pt_regs *regs, struct sigcontext32 *sc)
+static int restore_sigcontext32(struct pt_regs *regs, struct sigcontext32 __user *sc)
 {
         u32 used_math;
         int err = 0;
@@ -420,7 +421,7 @@ struct rt_sigframe32 {
 #endif
 };
 
-int copy_siginfo_to_user32(compat_siginfo_t *to, siginfo_t *from)
+int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
 {
         int err;
 
@@ -455,7 +456,7 @@ int copy_siginfo_to_user32(compat_siginfo_t *to, siginfo_t *from)
                         err |= __put_user(from->si_uid, &to->si_uid);
                         break;
                 case __SI_FAULT >> 16:
-                        err |= __put_user((long)from->si_addr, &to->si_addr);
+                        err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
                         break;
                 case __SI_POLL >> 16:
                         err |= __put_user(from->si_band, &to->si_band);
@@ -476,10 +477,10 @@ save_static_function(sys32_sigreturn);
 __attribute_used__ noinline static void
 _sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
 {
-        struct sigframe *frame;
+        struct sigframe __user *frame;
         sigset_t blocked;
 
-        frame = (struct sigframe *) regs.regs[29];
+        frame = (struct sigframe __user *) regs.regs[29];
         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
@@ -512,13 +513,13 @@ save_static_function(sys32_rt_sigreturn);
 __attribute_used__ noinline static void
 _sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 {
-        struct rt_sigframe32 *frame;
+        struct rt_sigframe32 __user *frame;
         mm_segment_t old_fs;
         sigset_t set;
         stack_t st;
         s32 sp;
 
-        frame = (struct rt_sigframe32 *) regs.regs[29];
+        frame = (struct rt_sigframe32 __user *) regs.regs[29];
         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
@@ -546,7 +547,7 @@ _sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
            call it and ignore errors.  */
         old_fs = get_fs();
         set_fs (KERNEL_DS);
-        do_sigaltstack(&st, NULL, regs.regs[29]);
+        do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
         set_fs (old_fs);
 
         /*
@@ -564,7 +565,7 @@ badframe:
 }
 
 static inline int setup_sigcontext32(struct pt_regs *regs,
-                                     struct sigcontext32 *sc)
+                                     struct sigcontext32 __user *sc)
 {
         int err = 0;
 
@@ -623,8 +624,9 @@ out:
 /*
  * Determine which stack to use..
  */
-static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
-                                 size_t frame_size)
+static inline void __user *get_sigframe(struct k_sigaction *ka,
+                                        struct pt_regs *regs,
+                                        size_t frame_size)
 {
         unsigned long sp;
 
@@ -642,13 +644,13 @@ static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
         if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
                 sp = current->sas_ss_sp + current->sas_ss_size;
 
-        return (void *)((sp - frame_size) & ALMASK);
+        return (void __user *)((sp - frame_size) & ALMASK);
 }
 
 int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
         int signr, sigset_t *set)
 {
-        struct sigframe *frame;
+        struct sigframe __user *frame;
         int err = 0;
 
         frame = get_sigframe(ka, regs, sizeof(*frame));
@@ -692,17 +694,17 @@ int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
                current->comm, current->pid,
                frame, regs->cp0_epc, frame->sf_code);
 #endif
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(signr, current);
-        return 0;
+        return -EFAULT;
 }
 
 int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
         int signr, sigset_t *set, siginfo_t *info)
 {
-        struct rt_sigframe32 *frame;
+        struct rt_sigframe32 __user *frame;
         int err = 0;
         s32 sp;
 
@@ -763,11 +765,11 @@ int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
                current->comm, current->pid,
                frame, regs->cp0_epc, frame->rs_code);
 #endif
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(signr, current);
-        return 0;
+        return -EFAULT;
 }
 
 static inline int handle_signal(unsigned long sig, siginfo_t *info,
@@ -855,7 +857,7 @@ no_signal:
 }
 
 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
-                                  struct sigaction32 *oact,
+                                  struct sigaction32 __user *oact,
                                   unsigned int sigsetsize)
 {
         struct k_sigaction new_sa, old_sa;
@@ -872,7 +874,7 @@ asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
                         return -EFAULT;
                 err |= __get_user(handler, &act->sa_handler);
-                new_sa.sa.sa_handler = (void*)(s64)handler;
+                new_sa.sa.sa_handler = (void __user *)(s64)handler;
                 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
                 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
                 if (err)
@@ -899,7 +901,7 @@ out:
 }
 
 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
-        compat_sigset_t *oset, unsigned int sigsetsize)
+        compat_sigset_t __user *oset, unsigned int sigsetsize)
 {
         sigset_t old_set, new_set;
         int ret;
@@ -909,8 +911,9 @@ asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
                 return -EFAULT;
 
         set_fs (KERNEL_DS);
-        ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
-                                 oset ? &old_set : NULL, sigsetsize);
+        ret = sys_rt_sigprocmask(how, set ? (sigset_t __user *)&new_set : NULL,
+                                 oset ? (sigset_t __user *)&old_set : NULL,
+                                 sigsetsize);
         set_fs (old_fs);
 
         if (!ret && oset && put_sigset(&old_set, oset))
@@ -919,7 +922,7 @@ asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
         return ret;
 }
 
-asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
+asmlinkage int sys32_rt_sigpending(compat_sigset_t __user *uset,
         unsigned int sigsetsize)
 {
         int ret;
@@ -927,7 +930,7 @@ asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
         mm_segment_t old_fs = get_fs();
 
         set_fs (KERNEL_DS);
-        ret = sys_rt_sigpending(&set, sigsetsize);
+        ret = sys_rt_sigpending((sigset_t __user *)&set, sigsetsize);
         set_fs (old_fs);
 
         if (!ret && put_sigset(&set, uset))
@@ -936,7 +939,7 @@ asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
         return ret;
 }
 
-asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t *uinfo)
+asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo)
 {
         siginfo_t info;
         int ret;
@@ -946,7 +949,7 @@ asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t *uinfo)
             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
                 return -EFAULT;
         set_fs (KERNEL_DS);
-        ret = sys_rt_sigqueueinfo(pid, sig, &info);
+        ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
         set_fs (old_fs);
         return ret;
 }
diff --git a/arch/mips/kernel/signal_n32.c b/arch/mips/kernel/signal_n32.c
index ec61b2670ba6..384fc4a639a4 100644
--- a/arch/mips/kernel/signal_n32.c
+++ b/arch/mips/kernel/signal_n32.c
@@ -48,6 +48,8 @@
 #define __NR_N32_rt_sigreturn           6211
 #define __NR_N32_restart_syscall        6214
 
+#define DEBUG_SIG 0
+
 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 
 /* IRIX compatible stack_t  */
@@ -83,12 +85,12 @@ save_static_function(sysn32_rt_sigreturn);
 __attribute_used__ noinline static void
 _sysn32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 {
-        struct rt_sigframe_n32 *frame;
+        struct rt_sigframe_n32 __user *frame;
         sigset_t set;
         stack_t st;
         s32 sp;
 
-        frame = (struct rt_sigframe_n32 *) regs.regs[29];
+        frame = (struct rt_sigframe_n32 __user *) regs.regs[29];
         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                 goto badframe;
         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
@@ -114,7 +116,7 @@ _sysn32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 
         /* It is more difficult to avoid calling this function than to
            call it and ignore errors.  */
-        do_sigaltstack(&st, NULL, regs.regs[29]);
+        do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
 
         /*
          * Don't let your children do this ...
@@ -133,7 +135,7 @@ badframe:
 int setup_rt_frame_n32(struct k_sigaction * ka,
         struct pt_regs *regs, int signr, sigset_t *set, siginfo_t *info)
 {
-        struct rt_sigframe_n32 *frame;
+        struct rt_sigframe_n32 __user *frame;
         int err = 0;
         s32 sp;
 
@@ -184,9 +186,9 @@ int setup_rt_frame_n32(struct k_sigaction * ka,
                current->comm, current->pid,
                frame, regs->cp0_epc, regs->regs[31]);
 #endif
-        return 1;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(signr, current);
-        return 0;
+        return -EFAULT;
 }
diff --git a/arch/mips/kernel/syscall.c b/arch/mips/kernel/syscall.c
index 332358430ff5..1da2eeb3ef9e 100644
--- a/arch/mips/kernel/syscall.c
+++ b/arch/mips/kernel/syscall.c
@@ -212,12 +212,12 @@ asmlinkage int sys_execve(nabi_no_regargs struct pt_regs regs)
         int error;
         char * filename;
 
-        filename = getname((char *) (long)regs.regs[4]);
+        filename = getname((char __user *) (long)regs.regs[4]);
         error = PTR_ERR(filename);
         if (IS_ERR(filename))
                 goto out;
-        error = do_execve(filename, (char **) (long)regs.regs[5],
-                          (char **) (long)regs.regs[6], &regs);
+        error = do_execve(filename, (char __user *__user *) (long)regs.regs[5],
+                          (char __user *__user *) (long)regs.regs[6], &regs);
         putname(filename);
 
 out:
@@ -227,7 +227,7 @@ out:
 /*
  * Compacrapability ...
  */
-asmlinkage int sys_uname(struct old_utsname * name)
+asmlinkage int sys_uname(struct old_utsname __user * name)
 {
         if (name && !copy_to_user(name, &system_utsname, sizeof (*name)))
                 return 0;
@@ -237,7 +237,7 @@ asmlinkage int sys_uname(struct old_utsname * name)
 /*
  * Compacrapability ...
  */
-asmlinkage int sys_olduname(struct oldold_utsname * name)
+asmlinkage int sys_olduname(struct oldold_utsname __user * name)
 {
         int error;
 
@@ -274,7 +274,7 @@ void sys_set_thread_area(unsigned long addr)
 asmlinkage int _sys_sysmips(int cmd, long arg1, int arg2, int arg3)
 {
         int     tmp, len;
-        char    *name;
+        char    __user *name;
 
         switch(cmd) {
         case SETNAME: {
@@ -283,7 +283,7 @@ asmlinkage int _sys_sysmips(int cmd, long arg1, int arg2, int arg3)
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
 
-                name = (char *) arg1;
+                name = (char __user *) arg1;
 
                 len = strncpy_from_user(nodename, name, __NEW_UTS_LEN);
                 if (len < 0)
@@ -324,7 +324,7 @@ asmlinkage int _sys_sysmips(int cmd, long arg1, int arg2, int arg3)
  * This is really horribly ugly.
  */
 asmlinkage int sys_ipc (uint call, int first, int second,
-                        unsigned long third, void *ptr, long fifth)
+                        unsigned long third, void __user *ptr, long fifth)
 {
         int version, ret;
 
@@ -333,24 +333,25 @@ asmlinkage int sys_ipc (uint call, int first, int second,
 
         switch (call) {
         case SEMOP:
-                return sys_semtimedop (first, (struct sembuf *)ptr, second,
-                                       NULL);
+                return sys_semtimedop (first, (struct sembuf __user *)ptr,
+                                       second, NULL);
         case SEMTIMEDOP:
-                return sys_semtimedop (first, (struct sembuf *)ptr, second,
-                                       (const struct timespec __user *)fifth);
+                return sys_semtimedop (first, (struct sembuf __user *)ptr,
+                                       second,
+                                       (const struct timespec __user *)fifth);
         case SEMGET:
                 return sys_semget (first, second, third);
         case SEMCTL: {
                 union semun fourth;
                 if (!ptr)
                         return -EINVAL;
-                if (get_user(fourth.__pad, (void **) ptr))
+                if (get_user(fourth.__pad, (void *__user *) ptr))
                         return -EFAULT;
                 return sys_semctl (first, second, third, fourth);
         }
 
         case MSGSND:
-                return sys_msgsnd (first, (struct msgbuf *) ptr,
+                return sys_msgsnd (first, (struct msgbuf __user *) ptr,
                                    second, third);
         case MSGRCV:
                 switch (version) {
@@ -360,7 +361,7 @@ asmlinkage int sys_ipc (uint call, int first, int second,
                                 return -EINVAL;
 
                         if (copy_from_user(&tmp,
-                                           (struct ipc_kludge *) ptr,
+                                           (struct ipc_kludge __user *) ptr,
                                            sizeof (tmp)))
                                 return -EFAULT;
                         return sys_msgrcv (first, tmp.msgp, second,
@@ -368,35 +369,38 @@ asmlinkage int sys_ipc (uint call, int first, int second,
                 }
                 default:
                         return sys_msgrcv (first,
-                                           (struct msgbuf *) ptr,
+                                           (struct msgbuf __user *) ptr,
                                            second, fifth, third);
                 }
         case MSGGET:
                 return sys_msgget ((key_t) first, second);
         case MSGCTL:
-                return sys_msgctl (first, second, (struct msqid_ds *) ptr);
+                return sys_msgctl (first, second,
+                                   (struct msqid_ds __user *) ptr);
 
         case SHMAT:
                 switch (version) {
                 default: {
                         ulong raddr;
-                        ret = do_shmat (first, (char *) ptr, second, &raddr);
+                        ret = do_shmat (first, (char __user *) ptr, second,
+                                        &raddr);
                         if (ret)
                                 return ret;
-                        return put_user (raddr, (ulong *) third);
+                        return put_user (raddr, (ulong __user *) third);
                 }
                 case 1: /* iBCS2 emulator entry point */
                         if (!segment_eq(get_fs(), get_ds()))
                                 return -EINVAL;
-                        return do_shmat (first, (char *) ptr, second, (ulong *) third);
+                        return do_shmat (first, (char __user *) ptr, second,
+                                         (ulong *) third);
                 }
         case SHMDT:
-                return sys_shmdt ((char *)ptr);
+                return sys_shmdt ((char __user *)ptr);
         case SHMGET:
                 return sys_shmget (first, second, third);
         case SHMCTL:
                 return sys_shmctl (first, second,
-                                   (struct shmid_ds *) ptr);
+                                   (struct shmid_ds __user *) ptr);
         default:
                 return -ENOSYS;
         }
diff --git a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c
index 59a187956de0..c9d2b5147ca3 100644
--- a/arch/mips/kernel/traps.c
+++ b/arch/mips/kernel/traps.c
@@ -1168,7 +1168,7 @@ void __init per_cpu_trap_init(void)
 #endif
         if (current_cpu_data.isa_level == MIPS_CPU_ISA_IV)
                 status_set |= ST0_XX;
-        change_c0_status(ST0_CU|ST0_MX|ST0_FR|ST0_BEV|ST0_TS|ST0_KX|ST0_SX|ST0_UX,
+        change_c0_status(ST0_CU|ST0_MX|ST0_RE|ST0_FR|ST0_BEV|ST0_TS|ST0_KX|ST0_SX|ST0_UX,
                          status_set);
 
         if (cpu_has_dsp)
diff --git a/arch/mips/kernel/vmlinux.lds.S b/arch/mips/kernel/vmlinux.lds.S
index 25cc856d8e7e..ff699dbb99f7 100644
--- a/arch/mips/kernel/vmlinux.lds.S
+++ b/arch/mips/kernel/vmlinux.lds.S
@@ -1,4 +1,5 @@
 #include <linux/config.h>
+#include <asm/asm-offsets.h>
 #include <asm-generic/vmlinux.lds.h>
 
 #undef mips             /* CPP really sucks for this job  */
@@ -64,10 +65,10 @@ SECTIONS
      we can shorten the on-disk segment size.  */
   .sdata     : { *(.sdata) }
 
-  . = ALIGN(4096);
+  . = ALIGN(_PAGE_SIZE);
   __nosave_begin = .;
   .data_nosave : { *(.data.nosave) }
-  . = ALIGN(4096);
+  . = ALIGN(_PAGE_SIZE);
   __nosave_end = .;
 
   . = ALIGN(32);
@@ -76,7 +77,7 @@ SECTIONS
   _edata =  .;                  /* End of data section */
 
   /* will be freed after init */
-  . = ALIGN(4096);              /* Init code and data */
+  . = ALIGN(_PAGE_SIZE);                /* Init code and data */
   __init_begin = .;
   .init.text : {
         _sinittext = .;
@@ -105,7 +106,7 @@ SECTIONS
   .con_initcall.init : { *(.con_initcall.init) }
   __con_initcall_end = .;
   SECURITY_INIT
-  . = ALIGN(4096);
+  . = ALIGN(_PAGE_SIZE);
   __initramfs_start = .;
   .init.ramfs : { *(.init.ramfs) }
   __initramfs_end = .;
@@ -113,7 +114,7 @@ SECTIONS
   __per_cpu_start = .;
   .data.percpu  : { *(.data.percpu) }
   __per_cpu_end = .;
-  . = ALIGN(4096);
+  . = ALIGN(_PAGE_SIZE);
   __init_end = .;
   /* freed after init ends here */
 
diff --git a/arch/mips/lasat/reset.c b/arch/mips/lasat/reset.c
index 8d7d7a454f9a..181bf68175fc 100644
--- a/arch/mips/lasat/reset.c
+++ b/arch/mips/lasat/reset.c
@@ -19,9 +19,12 @@
  */
 #include <linux/config.h>
 #include <linux/kernel.h>
+#include <linux/pm.h>
+
 #include <asm/reboot.h>
 #include <asm/system.h>
 #include <asm/lasat/lasat.h>
+
 #include "picvue.h"
 #include "prom.h"
 
@@ -63,5 +66,5 @@ void lasat_reboot_setup(void)
 {
         _machine_restart = lasat_machine_restart;
         _machine_halt = lasat_machine_halt;
-        _machine_power_off = lasat_machine_halt;
+        pm_power_off = lasat_machine_halt;
 }
diff --git a/arch/mips/lasat/setup.c b/arch/mips/lasat/setup.c
index dcd819d57dae..83eb08b7a072 100644
--- a/arch/mips/lasat/setup.c
+++ b/arch/mips/lasat/setup.c
@@ -134,8 +134,8 @@ void __init serial_init(void)
 
         memset(&s, 0, sizeof(s));
 
-        s.flags = STD_COM_FLAGS;
-        s.iotype = SERIAL_IO_MEM;
+        s.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
+        s.iotype = UPIO_MEM;
 
         if (mips_machtype == MACH_LASAT_100) {
                 s.uartclk = LASAT_BASE_BAUD_100 * 16;
diff --git a/arch/mips/lib-32/dump_tlb.c b/arch/mips/lib-32/dump_tlb.c
index 46519f4331eb..c49a925d0169 100644
--- a/arch/mips/lib-32/dump_tlb.c
+++ b/arch/mips/lib-32/dump_tlb.c
@@ -158,29 +158,26 @@ void dump_list_process(struct task_struct *t, void *address)
         printk("task->mm             == %8p\n", t->mm);
         //printk("tasks->mm.pgd        == %08x\n", (unsigned int) t->mm->pgd);
 
-        if (addr > KSEG0)
+        if (addr > KSEG0) {
                 page_dir = pgd_offset_k(0);
-        else if (t->mm) {
-                page_dir = pgd_offset(t->mm, 0);
-                printk("page_dir == %08x\n", (unsigned int) page_dir);
-        } else
-                printk("Current thread has no mm\n");
-
-        if (addr > KSEG0)
                 pgd = pgd_offset_k(addr);
-        else if (t->mm) {
+        } else if (t->mm) {
+                page_dir = pgd_offset(t->mm, 0);
                 pgd = pgd_offset(t->mm, addr);
-                printk("pgd == %08x, ", (unsigned int) pgd);
-                pud = pud_offset(pgd, addr);
-                printk("pud == %08x, ", (unsigned int) pud);
+        } else {
+                printk("Current thread has no mm\n");
+                return;
+        }
+        printk("page_dir == %08x\n", (unsigned int) page_dir);
+        printk("pgd == %08x, ", (unsigned int) pgd);
+        pud = pud_offset(pgd, addr);
+        printk("pud == %08x, ", (unsigned int) pud);
 
-                pmd = pmd_offset(pud, addr);
-                printk("pmd == %08x, ", (unsigned int) pmd);
+        pmd = pmd_offset(pud, addr);
+        printk("pmd == %08x, ", (unsigned int) pmd);
 
-                pte = pte_offset(pmd, addr);
-                printk("pte == %08x, ", (unsigned int) pte);
-        } else
-                printk("Current thread has no mm\n");
+        pte = pte_offset(pmd, addr);
+        printk("pte == %08x, ", (unsigned int) pte);
 
         page = *pte;
 #ifdef CONFIG_64BIT_PHYS_ADDR
diff --git a/arch/mips/math-emu/dp_simple.c b/arch/mips/math-emu/dp_simple.c
index 495c1ac94298..1c555e6c6a9f 100644
--- a/arch/mips/math-emu/dp_simple.c
+++ b/arch/mips/math-emu/dp_simple.c
@@ -48,16 +48,22 @@ ieee754dp ieee754dp_neg(ieee754dp x)
         CLEARCX;
         FLUSHXDP;
 
+        /*
+         * Invert the sign ALWAYS to prevent an endless recursion on
+         * pow() in libc.
+         */
+        /* quick fix up */
+        DPSIGN(x) ^= 1;
+
         if (xc == IEEE754_CLASS_SNAN) {
+                ieee754dp y = ieee754dp_indef();
                 SETCX(IEEE754_INVALID_OPERATION);
-                return ieee754dp_nanxcpt(ieee754dp_indef(), "neg");
+                DPSIGN(y) = DPSIGN(x);
+                return ieee754dp_nanxcpt(y, "neg");
         }
 
         if (ieee754dp_isnan(x)) /* but not infinity */
                 return ieee754dp_nanxcpt(x, "neg", x);
-
-        /* quick fix up */
-        DPSIGN(x) ^= 1;
         return x;
 }
 
diff --git a/arch/mips/math-emu/sp_simple.c b/arch/mips/math-emu/sp_simple.c
index c809830dffb4..770f0f4677cd 100644
--- a/arch/mips/math-emu/sp_simple.c
+++ b/arch/mips/math-emu/sp_simple.c
@@ -48,16 +48,22 @@ ieee754sp ieee754sp_neg(ieee754sp x)
         CLEARCX;
         FLUSHXSP;
 
+        /*
+         * Invert the sign ALWAYS to prevent an endless recursion on
+         * pow() in libc.
+         */
+        /* quick fix up */
+        SPSIGN(x) ^= 1;
+
         if (xc == IEEE754_CLASS_SNAN) {
+                ieee754sp y = ieee754sp_indef();
                 SETCX(IEEE754_INVALID_OPERATION);
-                return ieee754sp_nanxcpt(ieee754sp_indef(), "neg");
+                SPSIGN(y) = SPSIGN(x);
+                return ieee754sp_nanxcpt(y, "neg");
         }
 
         if (ieee754sp_isnan(x)) /* but not infinity */
                 return ieee754sp_nanxcpt(x, "neg", x);
-
-        /* quick fix up */
-        SPSIGN(x) ^= 1;
         return x;
 }
 
diff --git a/arch/mips/mips-boards/atlas/atlas_setup.c b/arch/mips/mips-boards/atlas/atlas_setup.c
index 625843b30bed..873cf3141a31 100644
--- a/arch/mips/mips-boards/atlas/atlas_setup.c
+++ b/arch/mips/mips-boards/atlas/atlas_setup.c
@@ -82,8 +82,8 @@ static void __init serial_init(void)
 #endif
         s.irq = ATLASINT_UART;
         s.uartclk = ATLAS_BASE_BAUD * 16;
-        s.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
-        s.iotype = SERIAL_IO_PORT;
+        s.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_AUTO_IRQ;
+        s.iotype = UPIO_PORT;
         s.regshift = 3;
 
         if (early_serial_setup(&s) != 0) {
diff --git a/arch/mips/mips-boards/generic/reset.c b/arch/mips/mips-boards/generic/reset.c
index 9fdec743bd95..7213c395fb6b 100644
--- a/arch/mips/mips-boards/generic/reset.c
+++ b/arch/mips/mips-boards/generic/reset.c
@@ -23,6 +23,7 @@
  *
  */
 #include <linux/config.h>
+#include <linux/pm.h>
 
 #include <asm/io.h>
 #include <asm/reboot.h>
@@ -65,9 +66,9 @@ void mips_reboot_setup(void)
         _machine_restart = mips_machine_restart;
         _machine_halt = mips_machine_halt;
 #if defined(CONFIG_MIPS_ATLAS)
-        _machine_power_off = atlas_machine_power_off;
+        pm_power_off = atlas_machine_power_off;
 #endif
 #if defined(CONFIG_MIPS_MALTA) || defined(CONFIG_MIPS_SEAD)
-        _machine_power_off = mips_machine_halt;
+        pm_power_off = mips_machine_halt;
 #endif
 }
diff --git a/arch/mips/mips-boards/sead/sead_setup.c b/arch/mips/mips-boards/sead/sead_setup.c
index f966bc161dfa..4266ce445174 100644
--- a/arch/mips/mips-boards/sead/sead_setup.c
+++ b/arch/mips/mips-boards/sead/sead_setup.c
@@ -71,8 +71,8 @@ static void __init serial_init(void)
 #endif
         s.irq = MIPSCPU_INT_BASE + MIPSCPU_INT_UART0;
         s.uartclk = SEAD_BASE_BAUD * 16;
-        s.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST | ASYNC_AUTO_IRQ;
-        s.iotype = 0;
+        s.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_AUTO_IRQ;
+        s.iotype = UPIO_PORT;
         s.regshift = 3;
 
         if (early_serial_setup(&s) != 0) {
diff --git a/arch/mips/mips-boards/sim/sim_setup.c b/arch/mips/mips-boards/sim/sim_setup.c
index 485d5a58d9cf..a2fd62997ca3 100644
--- a/arch/mips/mips-boards/sim/sim_setup.c
+++ b/arch/mips/mips-boards/sim/sim_setup.c
@@ -88,8 +88,8 @@ static void __init serial_init(void)
          but poll for now */
         s.irq =  0;
         s.uartclk = BASE_BAUD * 16;
-        s.flags = ASYNC_BOOT_AUTOCONF | UPF_SKIP_TEST;
-        s.iotype = SERIAL_IO_PORT | ASYNC_SKIP_TEST;
+        s.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
+        s.iotype = UPIO_PORT;
         s.regshift = 0;
         s.timeout = 4;
 
diff --git a/arch/mips/mm/c-r4k.c b/arch/mips/mm/c-r4k.c
index 422b55fab07a..e51c38cef88e 100644
--- a/arch/mips/mm/c-r4k.c
+++ b/arch/mips/mm/c-r4k.c
@@ -464,8 +464,8 @@ static void r4k_flush_data_cache_page(unsigned long addr)
 }
 
 struct flush_icache_range_args {
-        unsigned long __user start;
-        unsigned long __user end;
+        unsigned long start;
+        unsigned long end;
 };
 
 static inline void local_r4k_flush_icache_range(void *args)
@@ -528,8 +528,7 @@ static inline void local_r4k_flush_icache_range(void *args)
         }
 }
 
-static void r4k_flush_icache_range(unsigned long __user start,
-        unsigned long __user end)
+static void r4k_flush_icache_range(unsigned long start, unsigned long end)
 {
         struct flush_icache_range_args args;
 
diff --git a/arch/mips/mm/cache.c b/arch/mips/mm/cache.c
index 314701a66b13..591c22b080e4 100644
--- a/arch/mips/mm/cache.c
+++ b/arch/mips/mm/cache.c
@@ -25,8 +25,7 @@ void (*flush_cache_range)(struct vm_area_struct *vma, unsigned long start,
         unsigned long end);
 void (*flush_cache_page)(struct vm_area_struct *vma, unsigned long page,
         unsigned long pfn);
-void (*flush_icache_range)(unsigned long __user start,
-        unsigned long __user end);
+void (*flush_icache_range)(unsigned long start, unsigned long end);
 void (*flush_icache_page)(struct vm_area_struct *vma, struct page *page);
 
 /* MIPS specific cache operations */
@@ -53,7 +52,7 @@ EXPORT_SYMBOL(_dma_cache_inv);
  * We could optimize the case where the cache argument is not BCACHE but
  * that seems very atypical use ...
  */
-asmlinkage int sys_cacheflush(unsigned long __user addr,
+asmlinkage int sys_cacheflush(unsigned long addr,
         unsigned long bytes, unsigned int cache)
 {
         if (bytes == 0)
diff --git a/arch/mips/mm/init.c b/arch/mips/mm/init.c
index 4ee91c9a556f..0ff9a348b843 100644
--- a/arch/mips/mm/init.c
+++ b/arch/mips/mm/init.c
@@ -24,6 +24,7 @@
 #include <linux/bootmem.h>
 #include <linux/highmem.h>
 #include <linux/swap.h>
+#include <linux/proc_fs.h>
 
 #include <asm/bootinfo.h>
 #include <asm/cachectl.h>
@@ -200,6 +201,11 @@ static inline int page_is_ram(unsigned long pagenr)
         return 0;
 }
 
+static struct kcore_list kcore_mem, kcore_vmalloc;
+#ifdef CONFIG_64BIT
+static struct kcore_list kcore_kseg0;
+#endif
+
 void __init mem_init(void)
 {
         unsigned long codesize, reservedpages, datasize, initsize;
@@ -249,6 +255,16 @@ void __init mem_init(void)
         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
 
+#ifdef CONFIG_64BIT
+        if ((unsigned long) &_text > (unsigned long) CKSEG0)
+                /* The -4 is a hack so that user tools don't have to handle
+                   the overflow.  */
+                kclist_add(&kcore_kseg0, (void *) CKSEG0, 0x80000000 - 4);
+#endif
+        kclist_add(&kcore_mem, __va(0), max_low_pfn << PAGE_SHIFT);
+        kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
+                   VMALLOC_END-VMALLOC_START);
+
         printk(KERN_INFO "Memory: %luk/%luk available (%ldk kernel code, "
                "%ldk reserved, %ldk data, %ldk init, %ldk highmem)\n",
                (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
diff --git a/arch/mips/momentum/jaguar_atx/ja-console.c b/arch/mips/momentum/jaguar_atx/ja-console.c
index da6e1ed34db1..2292d0ec47fc 100644
--- a/arch/mips/momentum/jaguar_atx/ja-console.c
+++ b/arch/mips/momentum/jaguar_atx/ja-console.c
@@ -93,7 +93,7 @@ static void inline ja_console_probe(void)
         up.uartclk      = JAGUAR_ATX_UART_CLK;
         up.regshift     = 2;
         up.iotype       = UPIO_MEM;
-        up.flags        = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+        up.flags        = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
         up.line         = 0;
 
         if (early_serial_setup(&up))
diff --git a/arch/mips/momentum/jaguar_atx/setup.c b/arch/mips/momentum/jaguar_atx/setup.c
index bab192ddc185..301d67226d72 100644
--- a/arch/mips/momentum/jaguar_atx/setup.c
+++ b/arch/mips/momentum/jaguar_atx/setup.c
@@ -50,6 +50,7 @@
 #include <linux/pci.h>
 #include <linux/swap.h>
 #include <linux/ioport.h>
+#include <linux/pm.h>
 #include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/timex.h>
@@ -365,7 +366,7 @@ void __init plat_setup(void)
 
         _machine_restart = momenco_jaguar_restart;
         _machine_halt = momenco_jaguar_halt;
-        _machine_power_off = momenco_jaguar_power_off;
+        pm_power_off = momenco_jaguar_power_off;
 
         /*
          * initrd_start = (ulong)jaguar_initrd_start;
diff --git a/arch/mips/momentum/ocelot_3/setup.c b/arch/mips/momentum/ocelot_3/setup.c
index c9b7ff8148ec..f95677f4f06f 100644
--- a/arch/mips/momentum/ocelot_3/setup.c
+++ b/arch/mips/momentum/ocelot_3/setup.c
@@ -57,6 +57,8 @@
 #include <linux/timex.h>
 #include <linux/bootmem.h>
 #include <linux/mv643xx.h>
+#include <linux/pm.h>
+
 #include <asm/time.h>
 #include <asm/page.h>
 #include <asm/bootinfo.h>
@@ -321,7 +323,7 @@ void __init plat_setup(void)
 
         _machine_restart = momenco_ocelot_restart;
         _machine_halt = momenco_ocelot_halt;
-        _machine_power_off = momenco_ocelot_power_off;
+        pm_power_off = momenco_ocelot_power_off;
 
         /* Wired TLB entries */
         setup_wired_tlb_entries();
diff --git a/arch/mips/momentum/ocelot_c/setup.c b/arch/mips/momentum/ocelot_c/setup.c
index 2755c1547473..15998d8a9341 100644
--- a/arch/mips/momentum/ocelot_c/setup.c
+++ b/arch/mips/momentum/ocelot_c/setup.c
@@ -51,8 +51,10 @@
 #include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
+#include <linux/pm.h>
 #include <linux/timex.h>
 #include <linux/vmalloc.h>
+
 #include <asm/time.h>
 #include <asm/bootinfo.h>
 #include <asm/page.h>
@@ -236,7 +238,7 @@ void __init plat_setup(void)
 
         _machine_restart = momenco_ocelot_restart;
         _machine_halt = momenco_ocelot_halt;
-        _machine_power_off = momenco_ocelot_power_off;
+        pm_power_off = momenco_ocelot_power_off;
 
         /*
          * initrd_start = (ulong)ocelot_initrd_start;
diff --git a/arch/mips/momentum/ocelot_g/setup.c b/arch/mips/momentum/ocelot_g/setup.c
index 6336751391c3..fed4e8eee116 100644
--- a/arch/mips/momentum/ocelot_g/setup.c
+++ b/arch/mips/momentum/ocelot_g/setup.c
@@ -47,8 +47,10 @@
 #include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
+#include <linux/pm.h>
 #include <linux/timex.h>
 #include <linux/vmalloc.h>
+
 #include <asm/time.h>
 #include <asm/bootinfo.h>
 #include <asm/page.h>
@@ -169,7 +171,7 @@ void __init plat_setup(void)
 
         _machine_restart = momenco_ocelot_restart;
         _machine_halt = momenco_ocelot_halt;
-        _machine_power_off = momenco_ocelot_power_off;
+        pm_power_off = momenco_ocelot_power_off;
 
         /*
          * initrd_start = (ulong)ocelot_initrd_start;
diff --git a/arch/mips/oprofile/Makefile b/arch/mips/oprofile/Makefile
index 354261d37d62..0a50aad5bbe4 100644
--- a/arch/mips/oprofile/Makefile
+++ b/arch/mips/oprofile/Makefile
@@ -12,4 +12,5 @@ oprofile-y				:= $(DRIVER_OBJS) common.o
 
 oprofile-$(CONFIG_CPU_MIPS32)           += op_model_mipsxx.o
 oprofile-$(CONFIG_CPU_MIPS64)           += op_model_mipsxx.o
+oprofile-$(CONFIG_CPU_SB1)              += op_model_mipsxx.o
 oprofile-$(CONFIG_CPU_RM9000)           += op_model_rm9000.o
diff --git a/arch/mips/oprofile/common.c b/arch/mips/oprofile/common.c
index 53f9889b30ed..935dd851f480 100644
--- a/arch/mips/oprofile/common.c
+++ b/arch/mips/oprofile/common.c
@@ -79,6 +79,9 @@ int __init oprofile_arch_init(struct oprofile_operations *ops)
         case CPU_20KC:
         case CPU_24K:
         case CPU_25KF:
+        case CPU_34K:
+        case CPU_SB1:
+        case CPU_SB1A:
                 lmodel = &op_model_mipsxx;
                 break;
 
diff --git a/arch/mips/oprofile/op_model_mipsxx.c b/arch/mips/oprofile/op_model_mipsxx.c
index 1d1eee407faf..95d488ca0754 100644
--- a/arch/mips/oprofile/op_model_mipsxx.c
+++ b/arch/mips/oprofile/op_model_mipsxx.c
@@ -201,10 +201,21 @@ static int __init mipsxx_init(void)
                 op_model_mipsxx.cpu_type = "mips/25K";
                 break;
 
+#ifndef CONFIG_SMP
+        case CPU_34K:
+                op_model_mipsxx.cpu_type = "mips/34K";
+                break;
+#endif
+
         case CPU_5KC:
                 op_model_mipsxx.cpu_type = "mips/5K";
                 break;
 
+        case CPU_SB1:
+        case CPU_SB1A:
+                op_model_mipsxx.cpu_type = "mips/sb1";
+                break;
+
         default:
                 printk(KERN_ERR "Profiling unsupported for this CPU\n");
 
diff --git a/arch/mips/pci/Makefile b/arch/mips/pci/Makefile
index 741e67c9195a..16205b587338 100644
--- a/arch/mips/pci/Makefile
+++ b/arch/mips/pci/Makefile
@@ -46,6 +46,7 @@ obj-$(CONFIG_PMC_YOSEMITE)	+= fixup-yosemite.o ops-titan.o ops-titan-ht.o \
 obj-$(CONFIG_SGI_IP27)          += pci-ip27.o
 obj-$(CONFIG_SGI_IP32)          += fixup-ip32.o ops-mace.o pci-ip32.o
 obj-$(CONFIG_SIBYTE_SB1250)     += fixup-sb1250.o pci-sb1250.o
+obj-$(CONFIG_SIBYTE_BCM112X)    += fixup-sb1250.o pci-sb1250.o
 obj-$(CONFIG_SIBYTE_BCM1x80)    += pci-bcm1480.o pci-bcm1480ht.o
 obj-$(CONFIG_SNI_RM200_PCI)     += fixup-sni.o ops-sni.o
 obj-$(CONFIG_TANBAC_TB0219)     += fixup-tb0219.o
diff --git a/arch/mips/pci/fixup-cobalt.c b/arch/mips/pci/fixup-cobalt.c
index 909292f50d06..75a01e764898 100644
--- a/arch/mips/pci/fixup-cobalt.c
+++ b/arch/mips/pci/fixup-cobalt.c
@@ -17,7 +17,7 @@
 #include <asm/io.h>
 #include <asm/gt64120.h>
 
-#include <asm/cobalt/cobalt.h>
+#include <asm/mach-cobalt/cobalt.h>
 
 extern int cobalt_board_id;
 
@@ -52,7 +52,7 @@ static void qube_raq_via_bmIDE_fixup(struct pci_dev *dev)
         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lt);
         if (lt < 64)
                 pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
-        pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, 7);
+        pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, 8);
 }
 
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_1,
@@ -69,7 +69,7 @@ static void qube_raq_galileo_fixup(struct pci_dev *dev)
          * host bridge.
          */
         pci_write_config_byte(dev, PCI_LATENCY_TIMER, 64);
-        pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, 7);
+        pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, 8);
 
         /*
          * The code described by the comment below has been removed
diff --git a/arch/mips/pci/ops-gt64111.c b/arch/mips/pci/ops-gt64111.c
index c1807934768d..13de45940b19 100644
--- a/arch/mips/pci/ops-gt64111.c
+++ b/arch/mips/pci/ops-gt64111.c
@@ -15,7 +15,7 @@
 #include <asm/io.h>
 #include <asm/gt64120.h>
 
-#include <asm/cobalt/cobalt.h>
+#include <asm/mach-cobalt/cobalt.h>
 
 /*
  * Device 31 on the GT64111 is used to generate PCI special
diff --git a/arch/mips/pci/pci-bcm1480.c b/arch/mips/pci/pci-bcm1480.c
index f194b4e4f86a..ca975e7d32ff 100644
--- a/arch/mips/pci/pci-bcm1480.c
+++ b/arch/mips/pci/pci-bcm1480.c
@@ -234,11 +234,9 @@ static int __init bcm1480_pcibios_init(void)
 
         /* turn on ExpMemEn */
         cmdreg = READCFG32(CFGOFFSET(0, PCI_DEVFN(PCI_BRIDGE_DEVICE, 0), 0x40));
-        printk("PCIFeatureCtrl = %x\n", cmdreg);
         WRITECFG32(CFGOFFSET(0, PCI_DEVFN(PCI_BRIDGE_DEVICE, 0), 0x40),
                         cmdreg | 0x10);
         cmdreg = READCFG32(CFGOFFSET(0, PCI_DEVFN(PCI_BRIDGE_DEVICE, 0), 0x40));
-        printk("PCIFeatureCtrl = %x\n", cmdreg);
 
         /*
          * Establish mappings in KSEG2 (kernel virtual) to PCI I/O
diff --git a/arch/mips/philips/pnx8550/common/platform.c b/arch/mips/philips/pnx8550/common/platform.c
index 8aa9bd65b45e..a592260fd673 100644
--- a/arch/mips/philips/pnx8550/common/platform.c
+++ b/arch/mips/philips/pnx8550/common/platform.c
@@ -66,28 +66,28 @@ struct ip3106_port ip3106_ports[] = {
         [0] = {
                 .port   = {
                         .type           = PORT_IP3106,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .membase        = (void __iomem *)PNX8550_UART_PORT0,
                         .mapbase        = PNX8550_UART_PORT0,
                         .irq            = PNX8550_UART_INT(0),
                         .uartclk        = 3692300,
                         .fifosize       = 16,
                         .ops            = &ip3106_pops,
-                        .flags          = ASYNC_BOOT_AUTOCONF,
+                        .flags          = UPF_BOOT_AUTOCONF,
                         .line           = 0,
                 },
         },
         [1] = {
                 .port   = {
                         .type           = PORT_IP3106,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .membase        = (void __iomem *)PNX8550_UART_PORT1,
                         .mapbase        = PNX8550_UART_PORT1,
                         .irq            = PNX8550_UART_INT(1),
                         .uartclk        = 3692300,
                         .fifosize       = 16,
                         .ops            = &ip3106_pops,
-                        .flags          = ASYNC_BOOT_AUTOCONF,
+                        .flags          = UPF_BOOT_AUTOCONF,
                         .line           = 1,
                 },
         },
diff --git a/arch/mips/philips/pnx8550/common/setup.c b/arch/mips/philips/pnx8550/common/setup.c
index ee6bf72094f6..0d8a77619391 100644
--- a/arch/mips/philips/pnx8550/common/setup.c
+++ b/arch/mips/philips/pnx8550/common/setup.c
@@ -25,6 +25,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/serial_ip3106.h>
+#include <linux/pm.h>
 
 #include <asm/cpu.h>
 #include <asm/bootinfo.h>
@@ -90,7 +91,7 @@ void __init plat_setup(void)
 
         _machine_restart = pnx8550_machine_restart;
         _machine_halt = pnx8550_machine_halt;
-        _machine_power_off = pnx8550_machine_power_off;
+        pm_power_off = pnx8550_machine_power_off;
 
         board_time_init = pnx8550_time_init;
         board_timer_setup = pnx8550_timer_setup;
diff --git a/arch/mips/pmc-sierra/yosemite/prom.c b/arch/mips/pmc-sierra/yosemite/prom.c
index 555bfacf7647..165275c00cbb 100644
--- a/arch/mips/pmc-sierra/yosemite/prom.c
+++ b/arch/mips/pmc-sierra/yosemite/prom.c
@@ -13,6 +13,7 @@
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/delay.h>
+#include <linux/pm.h>
 #include <linux/smp.h>
 
 #include <asm/io.h>
@@ -92,7 +93,7 @@ void __init prom_init(void)
         /* Callbacks for halt, restart */
         _machine_restart = (void (*)(char *)) prom_exit;
         _machine_halt = prom_halt;
-        _machine_power_off = prom_halt;
+        pm_power_off = prom_halt;
 
         debug_vectors = cv;
         arcs_cmdline[0] = '\0';
diff --git a/arch/mips/pmc-sierra/yosemite/setup.c b/arch/mips/pmc-sierra/yosemite/setup.c
index 059755b5ed57..8bce711575de 100644
--- a/arch/mips/pmc-sierra/yosemite/setup.c
+++ b/arch/mips/pmc-sierra/yosemite/setup.c
@@ -185,7 +185,7 @@ static void __init py_uart_setup(void)
         up.uartclk      = TITAN_UART_CLK;
         up.regshift     = 0;
         up.iotype       = UPIO_MEM;
-        up.flags        = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+        up.flags        = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
         up.line         = 0;
 
         if (early_serial_setup(&up))
diff --git a/arch/mips/sgi-ip22/ip22-reset.c b/arch/mips/sgi-ip22/ip22-reset.c
index 214ffd2e98a3..92a3b3c15ed3 100644
--- a/arch/mips/sgi-ip22/ip22-reset.c
+++ b/arch/mips/sgi-ip22/ip22-reset.c
@@ -3,8 +3,9 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 1997, 1998, 2001, 2003 by Ralf Baechle
+ * Copyright (C) 1997, 1998, 2001, 03, 05, 06 by Ralf Baechle
  */
+#include <linux/linkage.h>
 #include <linux/init.h>
 #include <linux/ds1286.h>
 #include <linux/module.h>
@@ -12,6 +13,7 @@
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/notifier.h>
+#include <linux/pm.h>
 #include <linux/timer.h>
 
 #include <asm/io.h>
@@ -41,28 +43,10 @@ static struct timer_list power_timer, blink_timer, debounce_timer, volume_timer;
 
 #define MACHINE_PANICED         1
 #define MACHINE_SHUTTING_DOWN   2
-static int machine_state = 0;
 
-static void sgi_machine_restart(char *command) __attribute__((noreturn));
-static void sgi_machine_halt(void) __attribute__((noreturn));
-static void sgi_machine_power_off(void) __attribute__((noreturn));
+static int machine_state;
 
-static void sgi_machine_restart(char *command)
-{
-        if (machine_state & MACHINE_SHUTTING_DOWN)
-                sgi_machine_power_off();
-        sgimc->cpuctrl0 |= SGIMC_CCTRL0_SYSINIT;
-        while (1);
-}
-
-static void sgi_machine_halt(void)
-{
-        if (machine_state & MACHINE_SHUTTING_DOWN)
-                sgi_machine_power_off();
-        ArcEnterInteractiveMode();
-}
-
-static void sgi_machine_power_off(void)
+static void ATTRIB_NORET sgi_machine_power_off(void)
 {
         unsigned int tmp;
 
@@ -84,6 +68,21 @@ static void sgi_machine_power_off(void)
         }
 }
 
+static void ATTRIB_NORET sgi_machine_restart(char *command)
+{
+        if (machine_state & MACHINE_SHUTTING_DOWN)
+                sgi_machine_power_off();
+        sgimc->cpuctrl0 |= SGIMC_CCTRL0_SYSINIT;
+        while (1);
+}
+
+static void ATTRIB_NORET sgi_machine_halt(void)
+{
+        if (machine_state & MACHINE_SHUTTING_DOWN)
+                sgi_machine_power_off();
+        ArcEnterInteractiveMode();
+}
+
 static void power_timeout(unsigned long data)
 {
         sgi_machine_power_off();
@@ -95,7 +94,7 @@ static void blink_timeout(unsigned long data)
         sgi_ioc_reset ^= (SGIOC_RESET_LC0OFF|SGIOC_RESET_LC1OFF);
         sgioc->reset = sgi_ioc_reset;
 
-        mod_timer(&blink_timer, jiffies+data);
+        mod_timer(&blink_timer, jiffies + data);
 }
 
 static void debounce(unsigned long data)
@@ -103,7 +102,7 @@ static void debounce(unsigned long data)
         del_timer(&debounce_timer);
         if (sgint->istat1 & SGINT_ISTAT1_PWR) {
                 /* Interrupt still being sent. */
-                debounce_timer.expires = jiffies + 5; /* 0.05s  */
+                debounce_timer.expires = jiffies + (HZ / 20); /* 0.05s  */
                 add_timer(&debounce_timer);
 
                 sgioc->panel = SGIOC_PANEL_POWERON | SGIOC_PANEL_POWERINTR |
@@ -151,7 +150,7 @@ static inline void volume_up_button(unsigned long data)
                 indy_volume_button(1);
 
         if (sgint->istat1 & SGINT_ISTAT1_PWR) {
-                volume_timer.expires = jiffies + 1;
+                volume_timer.expires = jiffies + (HZ / 100);
                 add_timer(&volume_timer);
         }
 }
@@ -164,7 +163,7 @@ static inline void volume_down_button(unsigned long data)
                 indy_volume_button(-1);
 
         if (sgint->istat1 & SGINT_ISTAT1_PWR) {
-                volume_timer.expires = jiffies + 1;
+                volume_timer.expires = jiffies + (HZ / 100);
                 add_timer(&volume_timer);
         }
 }
@@ -199,14 +198,14 @@ static irqreturn_t panel_int(int irq, void *dev_id, struct pt_regs *regs)
         if (!(buttons & SGIOC_PANEL_VOLUPINTR)) {
                 init_timer(&volume_timer);
                 volume_timer.function = volume_up_button;
-                volume_timer.expires = jiffies + 1;
+                volume_timer.expires = jiffies + (HZ / 100);
                 add_timer(&volume_timer);
         }
         /* Volume down button was pressed */
         if (!(buttons & SGIOC_PANEL_VOLDNINTR)) {
                 init_timer(&volume_timer);
                 volume_timer.function = volume_down_button;
-                volume_timer.expires = jiffies + 1;
+                volume_timer.expires = jiffies + (HZ / 100);
                 add_timer(&volume_timer);
         }
 
@@ -234,7 +233,7 @@ static int __init reboot_setup(void)
 {
         _machine_restart = sgi_machine_restart;
         _machine_halt = sgi_machine_halt;
-        _machine_power_off = sgi_machine_power_off;
+        pm_power_off = sgi_machine_power_off;
 
         request_irq(SGI_PANEL_IRQ, panel_int, 0, "Front Panel", NULL);
         init_timer(&blink_timer);
diff --git a/arch/mips/sgi-ip22/ip22-setup.c b/arch/mips/sgi-ip22/ip22-setup.c
index 5e59b4c8876b..7018e1833e85 100644
--- a/arch/mips/sgi-ip22/ip22-setup.c
+++ b/arch/mips/sgi-ip22/ip22-setup.c
@@ -56,6 +56,7 @@ extern void ip22_time_init(void) __init;
 void __init plat_setup(void)
 {
         char *ctype;
+        char *cserial;
 
         board_be_init = ip22_be_init;
         ip22_time_init();
@@ -81,9 +82,14 @@ void __init plat_setup(void)
         /* ARCS console environment variable is set to "g?" for
          * graphics console, it is set to "d" for the first serial
          * line and "d2" for the second serial line.
+         *
+         * Need to check if the case is 'g' but no keyboard:
+         * (ConsoleIn/Out = serial)
          */
         ctype = ArcGetEnvironmentVariable("console");
-        if (ctype && *ctype == 'd') {
+        cserial = ArcGetEnvironmentVariable("ConsoleOut");
+
+        if ((ctype && *ctype == 'd') || (cserial && *cserial == 's')) {
                 static char options[8];
                 char *baud = ArcGetEnvironmentVariable("dbaud");
                 if (baud)
@@ -91,7 +97,7 @@ void __init plat_setup(void)
                 add_preferred_console("ttyS", *(ctype + 1) == '2' ? 1 : 0,
                                       baud ? options : NULL);
         } else if (!ctype || *ctype != 'g') {
-                /* Use ARC if we don't want serial ('d') or Newport ('g'). */
+                /* Use ARC if we don't want serial ('d') or graphics ('g'). */
                 prom_flags |= PROM_FLAG_USE_AS_CONSOLE;
                 add_preferred_console("arc", 0, NULL);
         }
diff --git a/arch/mips/sgi-ip27/ip27-reset.c b/arch/mips/sgi-ip27/ip27-reset.c
index 2e16be94c78b..4322db57d3c1 100644
--- a/arch/mips/sgi-ip27/ip27-reset.c
+++ b/arch/mips/sgi-ip27/ip27-reset.c
@@ -5,7 +5,7 @@
  *
  * Reset an IP27.
  *
- * Copyright (C) 1997, 1998, 1999, 2000 by Ralf Baechle
+ * Copyright (C) 1997, 1998, 1999, 2000, 06 by Ralf Baechle
  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  */
 #include <linux/config.h>
@@ -15,6 +15,7 @@
 #include <linux/smp.h>
 #include <linux/mmzone.h>
 #include <linux/nodemask.h>
+#include <linux/pm.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -77,5 +78,5 @@ void ip27_reboot_setup(void)
 {
         _machine_restart = ip27_machine_restart;
         _machine_halt = ip27_machine_halt;
-        _machine_power_off = ip27_machine_power_off;
+        pm_power_off = ip27_machine_power_off;
 }
diff --git a/arch/mips/sgi-ip32/ip32-reset.c b/arch/mips/sgi-ip32/ip32-reset.c
index 88e1f52059ff..0c948008b023 100644
--- a/arch/mips/sgi-ip32/ip32-reset.c
+++ b/arch/mips/sgi-ip32/ip32-reset.c
@@ -15,6 +15,7 @@
 #include <linux/delay.h>
 #include <linux/ds17287rtc.h>
 #include <linux/interrupt.h>
+#include <linux/pm.h>
 
 #include <asm/addrspace.h>
 #include <asm/irq.h>
@@ -188,7 +189,7 @@ static __init int ip32_reboot_setup(void)
 
         _machine_restart = ip32_machine_restart;
         _machine_halt = ip32_machine_halt;
-        _machine_power_off = ip32_machine_power_off;
+        pm_power_off = ip32_machine_power_off;
 
         init_timer(&blink_timer);
         blink_timer.function = blink_timeout;
diff --git a/arch/mips/sgi-ip32/ip32-setup.c b/arch/mips/sgi-ip32/ip32-setup.c
index d10a269aeae1..2c38770b1e1b 100644
--- a/arch/mips/sgi-ip32/ip32-setup.c
+++ b/arch/mips/sgi-ip32/ip32-setup.c
@@ -66,11 +66,6 @@ static inline void str2eaddr(unsigned char *ea, unsigned char *str)
 #include <linux/tty.h>
 #include <linux/serial.h>
 #include <linux/serial_core.h>
-extern int early_serial_setup(struct uart_port *port);
-
-#define STD_COM_FLAGS (ASYNC_SKIP_TEST)
-#define BASE_BAUD (1843200 / 16)
-
 #endif /* CONFIG_SERIAL_8250 */
 
 /* An arbitrary time; this can be decreased if reliability looks good */
@@ -110,8 +105,8 @@ void __init plat_setup(void)
                 o2_serial[0].type       = PORT_16550A;
                 o2_serial[0].line       = 0;
                 o2_serial[0].irq        = MACEISA_SERIAL1_IRQ;
-                o2_serial[0].flags      = STD_COM_FLAGS;
-                o2_serial[0].uartclk    = BASE_BAUD * 16;
+                o2_serial[0].flags      = UPF_SKIP_TEST;
+                o2_serial[0].uartclk    = 1843200;
                 o2_serial[0].iotype     = UPIO_MEM;
                 o2_serial[0].membase    = (char *)&mace->isa.serial1;
                 o2_serial[0].fifosize   = 14;
@@ -121,8 +116,8 @@ void __init plat_setup(void)
                 o2_serial[1].type       = PORT_16550A;
                 o2_serial[1].line       = 1;
                 o2_serial[1].irq        = MACEISA_SERIAL2_IRQ;
-                o2_serial[1].flags      = STD_COM_FLAGS;
-                o2_serial[1].uartclk    = BASE_BAUD * 16;
+                o2_serial[1].flags      = UPF_SKIP_TEST;
+                o2_serial[1].uartclk    = 1843200;
                 o2_serial[1].iotype     = UPIO_MEM;
                 o2_serial[1].membase    = (char *)&mace->isa.serial2;
                 o2_serial[1].fifosize   = 14;
diff --git a/arch/mips/sibyte/cfe/setup.c b/arch/mips/sibyte/cfe/setup.c
index 7a2c7a8510d4..ea308029450e 100644
--- a/arch/mips/sibyte/cfe/setup.c
+++ b/arch/mips/sibyte/cfe/setup.c
@@ -23,6 +23,7 @@
 #include <linux/mm.h>
 #include <linux/blkdev.h>
 #include <linux/bootmem.h>
+#include <linux/pm.h>
 #include <linux/smp.h>
 
 #include <asm/bootinfo.h>
@@ -248,7 +249,7 @@ void __init prom_init(void)
 
         _machine_restart   = cfe_linux_restart;
         _machine_halt      = cfe_linux_halt;
-        _machine_power_off = cfe_linux_halt;
+        pm_power_off = cfe_linux_halt;
 
         /*
          * Check if a loader was used; if NOT, the 4 arguments are
diff --git a/arch/mips/sibyte/sb1250/prom.c b/arch/mips/sibyte/sb1250/prom.c
index de62ab0f55a2..742043f8d755 100644
--- a/arch/mips/sibyte/sb1250/prom.c
+++ b/arch/mips/sibyte/sb1250/prom.c
@@ -24,6 +24,7 @@
 #include <linux/bootmem.h>
 #include <linux/smp.h>
 #include <linux/initrd.h>
+#include <linux/pm.h>
 
 #include <asm/bootinfo.h>
 #include <asm/reboot.h>
@@ -79,7 +80,7 @@ void __init prom_init(void)
 {
         _machine_restart   = (void (*)(char *))prom_linux_exit;
         _machine_halt      = prom_linux_exit;
-        _machine_power_off = prom_linux_exit;
+        pm_power_off = prom_linux_exit;
 
         strcpy(arcs_cmdline, "root=/dev/ram0 ");
 
diff --git a/arch/mips/sibyte/sb1250/setup.c b/arch/mips/sibyte/sb1250/setup.c
index df2e266c700c..fde4751c84fe 100644
--- a/arch/mips/sibyte/sb1250/setup.c
+++ b/arch/mips/sibyte/sb1250/setup.c
@@ -16,6 +16,7 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 #include <linux/config.h>
+#include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/string.h>
@@ -42,7 +43,7 @@ static inline int setup_bcm112x(void);
 
 /* Setup code likely to be common to all SiByte platforms */
 
-static inline int sys_rev_decode(void)
+static int __init sys_rev_decode(void)
 {
         int ret = 0;
 
@@ -74,7 +75,7 @@ static inline int sys_rev_decode(void)
         return ret;
 }
 
-static inline int setup_bcm1250(void)
+static int __init setup_bcm1250(void)
 {
         int ret = 0;
 
@@ -120,7 +121,7 @@ static inline int setup_bcm1250(void)
         return ret;
 }
 
-static inline int setup_bcm112x(void)
+static int __init setup_bcm112x(void)
 {
         int ret = 0;
 
@@ -146,7 +147,7 @@ static inline int setup_bcm112x(void)
         return ret;
 }
 
-void sb1250_setup(void)
+void __init sb1250_setup(void)
 {
         uint64_t sys_rev;
         int plldiv;
@@ -169,31 +170,42 @@ void sb1250_setup(void)
                     soc_str, pass_str, zbbus_mhz * 2, sb1_pass);
         prom_printf("Board type: %s\n", get_system_type());
 
-        switch(war_pass) {
+        switch (war_pass) {
         case K_SYS_REVISION_BCM1250_PASS1:
 #ifndef CONFIG_SB1_PASS_1_WORKAROUNDS
-                prom_printf("@@@@ This is a BCM1250 A0-A2 (Pass 1) board, and the kernel doesn't have the proper workarounds compiled in. @@@@\n");
+                prom_printf("@@@@ This is a BCM1250 A0-A2 (Pass 1) board, "
+                            "and the kernel doesn't have the proper "
+                            "workarounds compiled in. @@@@\n");
                 bad_config = 1;
 #endif
                 break;
         case K_SYS_REVISION_BCM1250_PASS2:
                 /* Pass 2 - easiest as default for now - so many numbers */
-#if !defined(CONFIG_SB1_PASS_2_WORKAROUNDS) || !defined(CONFIG_SB1_PASS_2_1_WORKAROUNDS)
-                prom_printf("@@@@ This is a BCM1250 A3-A10 board, and the kernel doesn't have the proper workarounds compiled in. @@@@\n");
+#if !defined(CONFIG_SB1_PASS_2_WORKAROUNDS) || \
+    !defined(CONFIG_SB1_PASS_2_1_WORKAROUNDS)
+                prom_printf("@@@@ This is a BCM1250 A3-A10 board, and the "
+                            "kernel doesn't have the proper workarounds "
+                            "compiled in. @@@@\n");
                 bad_config = 1;
 #endif
 #ifdef CONFIG_CPU_HAS_PREFETCH
-                prom_printf("@@@@ Prefetches may be enabled in this kernel, but are buggy on this board.  @@@@\n");
+                prom_printf("@@@@ Prefetches may be enabled in this kernel, "
+                            "but are buggy on this board.  @@@@\n");
                 bad_config = 1;
 #endif
                 break;
         case K_SYS_REVISION_BCM1250_PASS2_2:
 #ifndef CONFIG_SB1_PASS_2_WORKAROUNDS
-                prom_printf("@@@@ This is a BCM1250 B1/B2. board, and the kernel doesn't have the proper workarounds compiled in. @@@@\n");
+                prom_printf("@@@@ This is a BCM1250 B1/B2. board, and the "
+                            "kernel doesn't have the proper workarounds "
+                            "compiled in. @@@@\n");
                 bad_config = 1;
 #endif
-#if defined(CONFIG_SB1_PASS_2_1_WORKAROUNDS) || !defined(CONFIG_CPU_HAS_PREFETCH)
-                prom_printf("@@@@ This is a BCM1250 B1/B2, but the kernel is conservatively configured for an 'A' stepping. @@@@\n");
+#if defined(CONFIG_SB1_PASS_2_1_WORKAROUNDS) || \
+    !defined(CONFIG_CPU_HAS_PREFETCH)
+                prom_printf("@@@@ This is a BCM1250 B1/B2, but the kernel is "
+                            "conservatively configured for an 'A' stepping. "
+                            "@@@@\n");
 #endif
                 break;
         default:
diff --git a/arch/mips/sni/setup.c b/arch/mips/sni/setup.c
index 262c85680709..1141fcd13a59 100644
--- a/arch/mips/sni/setup.c
+++ b/arch/mips/sni/setup.c
@@ -5,7 +5,7 @@
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
- * Copyright (C) 1996, 97, 98, 2000, 03, 04 Ralf Baechle (ralf@linux-mips.org)
+ * Copyright (C) 1996, 97, 98, 2000, 03, 04, 06 Ralf Baechle (ralf@linux-mips.org)
  */
 #include <linux/config.h>
 #include <linux/eisa.h>
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/mc146818rtc.h>
+#include <linux/pm.h>
 #include <linux/pci.h>
 #include <linux/console.h>
 #include <linux/fb.h>
@@ -189,7 +190,7 @@ void __init plat_setup(void)
 
         _machine_restart = sni_machine_restart;
         _machine_halt = sni_machine_halt;
-        _machine_power_off = sni_machine_power_off;
+        pm_power_off = sni_machine_power_off;
 
         sni_display_setup();
 
diff --git a/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_prom.c b/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_prom.c
index e4d095d3e192..e19e2be70f76 100644
--- a/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_prom.c
+++ b/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_prom.c
@@ -60,7 +60,6 @@ void __init prom_init_cmdline(void)
 
 void __init prom_init(void)
 {
-        const char* toshiba_name_list[] = GROUP_TOSHIBA_NAMES;
         extern int tx4927_get_mem_size(void);
         extern char* toshiba_name;
         int msize;
@@ -69,12 +68,13 @@ void __init prom_init(void)
 
         mips_machgroup = MACH_GROUP_TOSHIBA;
 
-        if ((read_c0_prid() & 0xff) == PRID_REV_TX4927)
+        if ((read_c0_prid() & 0xff) == PRID_REV_TX4927) {
                 mips_machtype = MACH_TOSHIBA_RBTX4927;
-        else
+                toshiba_name  = "TX4927";
+        } else {
                 mips_machtype = MACH_TOSHIBA_RBTX4937;
-
-        toshiba_name = toshiba_name_list[mips_machtype];
+                toshiba_name  = "TX4937";
+        }
 
         msize = tx4927_get_mem_size();
         add_memory_region(0, msize << 20, BOOT_MEM_RAM);
diff --git a/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c b/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c
index 990fcb294bab..2ad6401d2af4 100644
--- a/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c
+++ b/arch/mips/tx4927/toshiba_rbtx4927/toshiba_rbtx4927_setup.c
@@ -53,6 +53,8 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/timex.h>
+#include <linux/pm.h>
+
 #include <asm/bootinfo.h>
 #include <asm/page.h>
 #include <asm/io.h>
@@ -537,19 +539,10 @@ void tx4927_pci_setup(void)
         TOSHIBA_RBTX4927_SETUP_DPRINTK(TOSHIBA_RBTX4927_SETUP_PCI2,
                                        "0x%08lx=mips_io_port_base",
                                        mips_io_port_base);
-
-        TOSHIBA_RBTX4927_SETUP_DPRINTK(TOSHIBA_RBTX4927_SETUP_PCI2,
-                                       "setup pci_io_resource  to 0x%08lx 0x%08lx\n",
-                                       pci_io_resource.start,
-                                       pci_io_resource.end);
-        TOSHIBA_RBTX4927_SETUP_DPRINTK(TOSHIBA_RBTX4927_SETUP_PCI2,
-                                       "setup pci_mem_resource to 0x%08lx 0x%08lx\n",
-                                       pci_mem_resource.start,
-                                       pci_mem_resource.end);
-
         if (!called) {
                 printk
-                    ("TX4927 PCIC -- DID:%04x VID:%04x RID:%02x Arbiter:%s\n",
+                    ("%s PCIC -- DID:%04x VID:%04x RID:%02x Arbiter:%s\n",
+                     toshiba_name,
                      (unsigned short) (tx4927_pcicptr->pciid >> 16),
                      (unsigned short) (tx4927_pcicptr->pciid & 0xffff),
                      (unsigned short) (tx4927_pcicptr->pciccrev & 0xff),
@@ -562,21 +555,52 @@ void tx4927_pci_setup(void)
                (tx4927_ccfgptr->ccfg & TX4927_CCFG_PCI66) ? " PCI66" : "");
         if (tx4927_ccfgptr->pcfg & TX4927_PCFG_PCICLKEN_ALL) {
                 int pciclk = 0;
-                switch ((unsigned long) tx4927_ccfgptr->
-                        ccfg & TX4927_CCFG_PCIDIVMODE_MASK) {
-                case TX4927_CCFG_PCIDIVMODE_2_5:
-                        pciclk = tx4927_cpu_clock * 2 / 5;
-                        break;
-                case TX4927_CCFG_PCIDIVMODE_3:
-                        pciclk = tx4927_cpu_clock / 3;
-                        break;
-                case TX4927_CCFG_PCIDIVMODE_5:
-                        pciclk = tx4927_cpu_clock / 5;
-                        break;
-                case TX4927_CCFG_PCIDIVMODE_6:
-                        pciclk = tx4927_cpu_clock / 6;
-                        break;
-                }
+                if (mips_machtype == MACH_TOSHIBA_RBTX4937)
+                        switch ((unsigned long) tx4927_ccfgptr->
+                                ccfg & TX4937_CCFG_PCIDIVMODE_MASK) {
+                        case TX4937_CCFG_PCIDIVMODE_4:
+                                pciclk = tx4927_cpu_clock / 4;
+                                break;
+                        case TX4937_CCFG_PCIDIVMODE_4_5:
+                                pciclk = tx4927_cpu_clock * 2 / 9;
+                                break;
+                        case TX4937_CCFG_PCIDIVMODE_5:
+                                pciclk = tx4927_cpu_clock / 5;
+                                break;
+                        case TX4937_CCFG_PCIDIVMODE_5_5:
+                                pciclk = tx4927_cpu_clock * 2 / 11;
+                                break;
+                        case TX4937_CCFG_PCIDIVMODE_8:
+                                pciclk = tx4927_cpu_clock / 8;
+                                break;
+                        case TX4937_CCFG_PCIDIVMODE_9:
+                                pciclk = tx4927_cpu_clock / 9;
+                                break;
+                        case TX4937_CCFG_PCIDIVMODE_10:
+                                pciclk = tx4927_cpu_clock / 10;
+                                break;
+                        case TX4937_CCFG_PCIDIVMODE_11:
+                                pciclk = tx4927_cpu_clock / 11;
+                                break;
+                        }
+
+                else
+                        switch ((unsigned long) tx4927_ccfgptr->
+                                ccfg & TX4927_CCFG_PCIDIVMODE_MASK) {
+                        case TX4927_CCFG_PCIDIVMODE_2_5:
+                                pciclk = tx4927_cpu_clock * 2 / 5;
+                                break;
+                        case TX4927_CCFG_PCIDIVMODE_3:
+                                pciclk = tx4927_cpu_clock / 3;
+                                break;
+                        case TX4927_CCFG_PCIDIVMODE_5:
+                                pciclk = tx4927_cpu_clock / 5;
+                                break;
+                        case TX4927_CCFG_PCIDIVMODE_6:
+                                pciclk = tx4927_cpu_clock / 6;
+                                break;
+                        }
+
                 printk("Internal(%dMHz)", pciclk / 1000000);
         } else {
                 int pciclk = 0;
@@ -814,24 +838,40 @@ void __init toshiba_rbtx4927_setup(void)
                                        ":ResetRoutines\n");
         _machine_restart = toshiba_rbtx4927_restart;
         _machine_halt = toshiba_rbtx4927_halt;
-        _machine_power_off = toshiba_rbtx4927_power_off;
+        pm_power_off = toshiba_rbtx4927_power_off;
 
 #ifdef CONFIG_PCI
 
         /* PCIC */
         /*
            * ASSUMPTION: PCIDIVMODE is configured for PCI 33MHz or 66MHz.
-           * PCIDIVMODE[12:11]'s initial value are given by S9[4:3] (ON:0, OFF:1).
+           *
+           * For TX4927:
+           * PCIDIVMODE[12:11]'s initial value is given by S9[4:3] (ON:0, OFF:1).
            * CPU 166MHz: PCI 66MHz : PCIDIVMODE: 00 (1/2.5)
            * CPU 200MHz: PCI 66MHz : PCIDIVMODE: 01 (1/3)
            * CPU 166MHz: PCI 33MHz : PCIDIVMODE: 10 (1/5)
            * CPU 200MHz: PCI 33MHz : PCIDIVMODE: 11 (1/6)
            * i.e. S9[3]: ON (83MHz), OFF (100MHz)
+           *
+           * For TX4937:
+           * PCIDIVMODE[12:11]'s initial value is given by S1[5:4] (ON:0, OFF:1)
+           * PCIDIVMODE[10] is 0.
+           * CPU 266MHz: PCI 33MHz : PCIDIVMODE: 000 (1/8)
+           * CPU 266MHz: PCI 66MHz : PCIDIVMODE: 001 (1/4)
+           * CPU 300MHz: PCI 33MHz : PCIDIVMODE: 010 (1/9)
+           * CPU 300MHz: PCI 66MHz : PCIDIVMODE: 011 (1/4.5)
+           * CPU 333MHz: PCI 33MHz : PCIDIVMODE: 100 (1/10)
+           * CPU 333MHz: PCI 66MHz : PCIDIVMODE: 101 (1/5)
+           *
          */
         TOSHIBA_RBTX4927_SETUP_DPRINTK(TOSHIBA_RBTX4927_SETUP_PCI1,
-                                       "ccfg is %lx, DIV is %x\n",
-                                       (unsigned long) tx4927_ccfgptr->
-                                       ccfg, TX4927_CCFG_PCIDIVMODE_MASK);
+                                       "ccfg is %lx, PCIDIVMODE is %x\n",
+                                       (unsigned long) tx4927_ccfgptr->ccfg,
+                                       (unsigned long) tx4927_ccfgptr->ccfg &
+                                       (mips_machtype == MACH_TOSHIBA_RBTX4937 ?
+                                        TX4937_CCFG_PCIDIVMODE_MASK :
+                                        TX4927_CCFG_PCIDIVMODE_MASK));
 
         TOSHIBA_RBTX4927_SETUP_DPRINTK(TOSHIBA_RBTX4927_SETUP_PCI1,
                                        "PCI66 mode is %lx, PCI mode is %lx, pci arb is %lx\n",
@@ -842,20 +882,30 @@ void __init toshiba_rbtx4927_setup(void)
                                        (unsigned long) tx4927_ccfgptr->
                                        ccfg & TX4927_CCFG_PCIXARB);
 
-        TOSHIBA_RBTX4927_SETUP_DPRINTK(TOSHIBA_RBTX4927_SETUP_PCI1,
-                                       "PCIDIVMODE is %lx\n",
-                                       (unsigned long) tx4927_ccfgptr->
-                                       ccfg & TX4927_CCFG_PCIDIVMODE_MASK);
-
-        switch ((unsigned long) tx4927_ccfgptr->
-                ccfg & TX4927_CCFG_PCIDIVMODE_MASK) {
-        case TX4927_CCFG_PCIDIVMODE_2_5:
-        case TX4927_CCFG_PCIDIVMODE_5:
-                tx4927_cpu_clock = 166000000;   /* 166MHz */
-                break;
-        default:
-                tx4927_cpu_clock = 200000000;   /* 200MHz */
-        }
+        if (mips_machtype == MACH_TOSHIBA_RBTX4937)
+                switch ((unsigned long)tx4927_ccfgptr->
+                        ccfg & TX4937_CCFG_PCIDIVMODE_MASK) {
+                case TX4937_CCFG_PCIDIVMODE_8:
+                case TX4937_CCFG_PCIDIVMODE_4:
+                        tx4927_cpu_clock = 266666666;   /* 266MHz */
+                        break;
+                case TX4937_CCFG_PCIDIVMODE_9:
+                case TX4937_CCFG_PCIDIVMODE_4_5:
+                        tx4927_cpu_clock = 300000000;   /* 300MHz */
+                        break;
+                default:
+                        tx4927_cpu_clock = 333333333;   /* 333MHz */
+                }
+        else
+                switch ((unsigned long)tx4927_ccfgptr->
+                        ccfg & TX4927_CCFG_PCIDIVMODE_MASK) {
+                case TX4927_CCFG_PCIDIVMODE_2_5:
+                case TX4927_CCFG_PCIDIVMODE_5:
+                        tx4927_cpu_clock = 166666666;   /* 166MHz */
+                        break;
+                default:
+                        tx4927_cpu_clock = 200000000;   /* 200MHz */
+                }
 
         /* CCFG */
         /* enable Timeout BusError */
diff --git a/arch/mips/tx4938/toshiba_rbtx4938/setup.c b/arch/mips/tx4938/toshiba_rbtx4938/setup.c
index 9f1dcc8ca5a3..5c7ace982a49 100644
--- a/arch/mips/tx4938/toshiba_rbtx4938/setup.c
+++ b/arch/mips/tx4938/toshiba_rbtx4938/setup.c
@@ -20,6 +20,8 @@
 #include <linux/interrupt.h>
 #include <linux/console.h>
 #include <linux/pci.h>
+#include <linux/pm.h>
+
 #include <asm/wbflush.h>
 #include <asm/reboot.h>
 #include <asm/irq.h>
@@ -1003,7 +1005,7 @@ void __init toshiba_rbtx4938_setup(void)
 
         _machine_restart = rbtx4938_machine_restart;
         _machine_halt = rbtx4938_machine_halt;
-        _machine_power_off = rbtx4938_machine_power_off;
+        pm_power_off = rbtx4938_machine_power_off;
 
         *rbtx4938_led_ptr = 0xff;
         printk("RBTX4938 --- FPGA(Rev %02x)", *rbtx4938_fpga_rev_ptr);
diff --git a/arch/mips/vr41xx/common/pmu.c b/arch/mips/vr41xx/common/pmu.c
index 02bf4f7d06ba..5e469796413f 100644
--- a/arch/mips/vr41xx/common/pmu.c
+++ b/arch/mips/vr41xx/common/pmu.c
@@ -21,6 +21,7 @@
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/kernel.h>
+#include <linux/pm.h>
 #include <linux/smp.h>
 #include <linux/types.h>
 
@@ -114,7 +115,7 @@ static int __init vr41xx_pmu_init(void)
 
         _machine_restart = vr41xx_restart;
         _machine_halt = vr41xx_halt;
-        _machine_power_off = vr41xx_power_off;
+        pm_power_off = vr41xx_power_off;
 
         return 0;
 }
diff --git a/arch/parisc/Kconfig b/arch/parisc/Kconfig
index e77a06e9621e..7c914a4c67c3 100644
--- a/arch/parisc/Kconfig
+++ b/arch/parisc/Kconfig
@@ -149,14 +149,20 @@ config HOTPLUG_CPU
         default y if SMP
         select HOTPLUG
 
+config ARCH_SELECT_MEMORY_MODEL
+        def_bool y
+        depends on 64BIT
+
 config ARCH_DISCONTIGMEM_ENABLE
-        bool "Discontiguous memory support (EXPERIMENTAL)"
-        depends on 64BIT && EXPERIMENTAL
-        help
-          Say Y to support efficient handling of discontiguous physical memory,
-          for architectures which are either NUMA (Non-Uniform Memory Access)
-          or have huge holes in the physical address space for other reasons.
-          See <file:Documentation/vm/numa> for more.
+        def_bool y
+        depends on 64BIT
+
+config ARCH_FLATMEM_ENABLE
+        def_bool y
+
+config ARCH_DISCONTIGMEM_DEFAULT
+        def_bool y
+        depends on ARCH_DISCONTIGMEM_ENABLE
 
 source "kernel/Kconfig.hz"
 source "mm/Kconfig"
diff --git a/arch/parisc/Kconfig.debug b/arch/parisc/Kconfig.debug
index 8caaed187a1f..9166bd117267 100644
--- a/arch/parisc/Kconfig.debug
+++ b/arch/parisc/Kconfig.debug
@@ -11,4 +11,14 @@ config DEBUG_RWLOCK
           too many attempts.  If you suspect a rwlock problem or a kernel
           hacker asks for this option then say Y.  Otherwise say N.
 
+config DEBUG_RODATA
+       bool "Write protect kernel read-only data structures"
+       depends on DEBUG_KERNEL
+       help
+         Mark the kernel read-only data as write-protected in the pagetables,
+         in order to catch accidental (and incorrect) writes to such const
+         data. This option may have a slight performance impact because a
+         portion of the kernel code won't be covered by a TLB anymore.
+         If in doubt, say "N".
+
 endmenu
diff --git a/arch/parisc/configs/a500_defconfig b/arch/parisc/configs/a500_defconfig
index 955ef5084f3e..959ad3c4e372 100644
--- a/arch/parisc/configs/a500_defconfig
+++ b/arch/parisc/configs/a500_defconfig
@@ -602,6 +602,7 @@ CONFIG_ACENIC_OMIT_TIGON_I=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=m
 CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/parisc/configs/b180_defconfig b/arch/parisc/configs/b180_defconfig
index 8819e7e6ae3f..37e98241ce4b 100644
--- a/arch/parisc/configs/b180_defconfig
+++ b/arch/parisc/configs/b180_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.14-rc5-pa1
-# Fri Oct 21 23:06:10 2005
+# Linux kernel version: 2.6.16-rc1-pa0
+# Tue Jan 17 08:21:01 2006
 #
 CONFIG_PARISC=y
 CONFIG_MMU=y
@@ -29,8 +29,6 @@ CONFIG_SYSVIPC=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
-# CONFIG_HOTPLUG is not set
-CONFIG_KOBJECT_UEVENT=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_INITRAMFS_SOURCE=""
@@ -38,8 +36,10 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
+CONFIG_ELF_CORE=y
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
@@ -48,8 +48,10 @@ CONFIG_CC_ALIGN_FUNCTIONS=0
 CONFIG_CC_ALIGN_LABELS=0
 CONFIG_CC_ALIGN_LOOPS=0
 CONFIG_CC_ALIGN_JUMPS=0
+CONFIG_SLAB=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
 
 #
 # Loadable module support
@@ -57,10 +59,28 @@ CONFIG_BASE_SMALL=0
 CONFIG_MODULES=y
 # CONFIG_MODULE_UNLOAD is not set
 CONFIG_OBSOLETE_MODPARM=y
+CONFIG_MODVERSIONS=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 # CONFIG_KMOD is not set
 
 #
+# Block layer
+#
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+# CONFIG_DEFAULT_AS is not set
+# CONFIG_DEFAULT_DEADLINE is not set
+CONFIG_DEFAULT_CFQ=y
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="cfq"
+
+#
 # Processor type and features
 #
 # CONFIG_PA7000 is not set
@@ -77,6 +97,7 @@ CONFIG_HZ=250
 CONFIG_FLATMEM=y
 CONFIG_FLAT_NODE_MEM_MAP=y
 # CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPLIT_PTLOCK_CPUS=4096
 # CONFIG_PREEMPT is not set
 # CONFIG_HPUX is not set
 
@@ -84,8 +105,8 @@ CONFIG_FLAT_NODE_MEM_MAP=y
 # Bus options (PCI, PCMCIA, EISA, GSC, ISA)
 #
 CONFIG_GSC=y
-# CONFIG_HPPB is not set
-# CONFIG_IOMMU_CCIO is not set
+CONFIG_HPPB=y
+CONFIG_IOMMU_CCIO=y
 CONFIG_GSC_LASI=y
 CONFIG_GSC_WAX=y
 CONFIG_EISA=y
@@ -165,8 +186,11 @@ CONFIG_IPV6=y
 # CONFIG_LLC2 is not set
 # CONFIG_IPX is not set
 # CONFIG_ATALK is not set
+
+#
+# QoS and/or fair queueing
+#
 # CONFIG_NET_SCHED is not set
-# CONFIG_NET_CLS_ROUTE is not set
 
 #
 # Network testing
@@ -205,6 +229,7 @@ CONFIG_STANDALONE=y
 CONFIG_PARPORT=y
 CONFIG_PARPORT_PC=y
 # CONFIG_PARPORT_SERIAL is not set
+CONFIG_PARPORT_NOT_PC=y
 CONFIG_PARPORT_GSC=y
 # CONFIG_PARPORT_1284 is not set
 
@@ -230,14 +255,6 @@ CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_CDROM_PKTCDVD=m
 CONFIG_CDROM_PKTCDVD_BUFFERS=8
 # CONFIG_CDROM_PKTCDVD_WCACHE is not set
-
-#
-# IO Schedulers
-#
-CONFIG_IOSCHED_NOOP=y
-CONFIG_IOSCHED_AS=y
-CONFIG_IOSCHED_DEADLINE=y
-CONFIG_IOSCHED_CFQ=y
 CONFIG_ATA_OVER_ETH=y
 
 #
@@ -281,6 +298,7 @@ CONFIG_SCSI_SPI_ATTRS=y
 #
 # SCSI low-level drivers
 #
+# CONFIG_ISCSI_TCP is not set
 # CONFIG_BLK_DEV_3W_XXXX_RAID is not set
 # CONFIG_SCSI_3W_9XXX is not set
 # CONFIG_SCSI_ACARD is not set
@@ -313,21 +331,19 @@ CONFIG_SCSI_SYM53C8XX_2=y
 CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=0
 CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16
 CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
-# CONFIG_SCSI_SYM53C8XX_IOMAPPED is not set
+CONFIG_SCSI_SYM53C8XX_MMIO=y
 # CONFIG_SCSI_IPR is not set
-# CONFIG_SCSI_ZALON is not set
+CONFIG_SCSI_ZALON=y
+CONFIG_SCSI_NCR53C8XX_DEFAULT_TAGS=8
+CONFIG_SCSI_NCR53C8XX_MAX_TAGS=32
+CONFIG_SCSI_NCR53C8XX_SYNC=40
+# CONFIG_SCSI_NCR53C8XX_PROFILE is not set
 # CONFIG_SCSI_PAS16 is not set
 # CONFIG_SCSI_PSI240I is not set
 # CONFIG_SCSI_QLOGIC_FAS is not set
 # CONFIG_SCSI_QLOGIC_FC is not set
 # CONFIG_SCSI_QLOGIC_1280 is not set
-CONFIG_SCSI_QLA2XXX=y
-# CONFIG_SCSI_QLA21XX is not set
-# CONFIG_SCSI_QLA22XX is not set
-# CONFIG_SCSI_QLA2300 is not set
-# CONFIG_SCSI_QLA2322 is not set
-# CONFIG_SCSI_QLA6312 is not set
-# CONFIG_SCSI_QLA24XX is not set
+# CONFIG_SCSI_QLA_FC is not set
 # CONFIG_SCSI_LPFC is not set
 # CONFIG_SCSI_SIM710 is not set
 # CONFIG_SCSI_SYM53C416 is not set
@@ -397,7 +413,7 @@ CONFIG_NETDEVICES=y
 #
 CONFIG_NET_ETHERNET=y
 # CONFIG_MII is not set
-# CONFIG_LASI_82596 is not set
+CONFIG_LASI_82596=y
 # CONFIG_HAPPYMEAL is not set
 # CONFIG_SUNGEM is not set
 # CONFIG_CASSINI is not set
@@ -464,6 +480,7 @@ CONFIG_NET_RADIO=y
 # Wireless 802.11b ISA/PCI cards support
 #
 # CONFIG_HERMES is not set
+# CONFIG_ATMEL is not set
 
 #
 # Prism GT/Duette 802.11(a/b/g) PCI/Cardbus support
@@ -527,7 +544,7 @@ CONFIG_KEYBOARD_ATKBD_HP_KEYCODES=y
 # CONFIG_KEYBOARD_XTKBD is not set
 # CONFIG_KEYBOARD_NEWTON is not set
 # CONFIG_KEYBOARD_HIL_OLD is not set
-# CONFIG_KEYBOARD_HIL is not set
+CONFIG_KEYBOARD_HIL=y
 CONFIG_INPUT_MOUSE=y
 CONFIG_MOUSE_PS2=y
 # CONFIG_MOUSE_SERIAL is not set
@@ -535,7 +552,7 @@ CONFIG_MOUSE_PS2=y
 # CONFIG_MOUSE_LOGIBM is not set
 # CONFIG_MOUSE_PC110PAD is not set
 # CONFIG_MOUSE_VSXXXAA is not set
-# CONFIG_MOUSE_HIL is not set
+CONFIG_MOUSE_HIL=y
 # CONFIG_INPUT_JOYSTICK is not set
 # CONFIG_INPUT_TOUCHSCREEN is not set
 CONFIG_INPUT_MISC=y
@@ -549,7 +566,8 @@ CONFIG_SERIO=y
 # CONFIG_SERIO_SERPORT is not set
 # CONFIG_SERIO_PARKBD is not set
 CONFIG_SERIO_GSCPS2=y
-# CONFIG_HP_SDC is not set
+CONFIG_HP_SDC=y
+CONFIG_HIL_MLC=y
 # CONFIG_SERIO_PCIPS2 is not set
 CONFIG_SERIO_LIBPS2=y
 # CONFIG_SERIO_RAW is not set
@@ -569,6 +587,7 @@ CONFIG_HW_CONSOLE=y
 CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
 CONFIG_SERIAL_8250_NR_UARTS=13
+CONFIG_SERIAL_8250_RUNTIME_UARTS=4
 CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_MANY_PORTS=y
 CONFIG_SERIAL_8250_SHARE_IRQ=y
@@ -582,11 +601,10 @@ CONFIG_SERIAL_8250_SHARE_IRQ=y
 #
 # Non-8250 serial port support
 #
-# CONFIG_SERIAL_MUX is not set
-# CONFIG_PDC_CONSOLE is not set
+CONFIG_SERIAL_MUX=y
+CONFIG_SERIAL_MUX_CONSOLE=y
 CONFIG_SERIAL_CORE=y
 CONFIG_SERIAL_CORE_CONSOLE=y
-# CONFIG_SERIAL_JSM is not set
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -626,6 +644,12 @@ CONFIG_GEN_RTC=y
 # CONFIG_I2C is not set
 
 #
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
 # Dallas's 1-wire bus
 #
 # CONFIG_W1 is not set
@@ -661,7 +685,6 @@ CONFIG_FB=y
 CONFIG_FB_CFB_FILLRECT=y
 CONFIG_FB_CFB_COPYAREA=y
 CONFIG_FB_CFB_IMAGEBLIT=y
-CONFIG_FB_SOFT_CURSOR=y
 # CONFIG_FB_MACMODES is not set
 # CONFIG_FB_MODE_HELPERS is not set
 # CONFIG_FB_TILEBLITTING is not set
@@ -671,6 +694,7 @@ CONFIG_FB_SOFT_CURSOR=y
 # CONFIG_FB_ASILIANT is not set
 # CONFIG_FB_IMSTT is not set
 CONFIG_FB_STI=y
+# CONFIG_FB_S1D13XXX is not set
 # CONFIG_FB_NVIDIA is not set
 # CONFIG_FB_RIVA is not set
 # CONFIG_FB_MATROX is not set
@@ -683,9 +707,7 @@ CONFIG_FB_STI=y
 # CONFIG_FB_KYRO is not set
 # CONFIG_FB_3DFX is not set
 # CONFIG_FB_VOODOO1 is not set
-# CONFIG_FB_CYBLA is not set
 # CONFIG_FB_TRIDENT is not set
-# CONFIG_FB_S1D13XXX is not set
 # CONFIG_FB_VIRTUAL is not set
 
 #
@@ -695,6 +717,7 @@ CONFIG_DUMMY_CONSOLE=y
 CONFIG_DUMMY_CONSOLE_COLUMNS=160
 CONFIG_DUMMY_CONSOLE_ROWS=64
 CONFIG_FRAMEBUFFER_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
 CONFIG_STI_CONSOLE=y
 # CONFIG_FONTS is not set
 CONFIG_FONT_8x8=y
@@ -713,7 +736,85 @@ CONFIG_LOGO_PARISC_CLUT224=y
 #
 # Sound
 #
-# CONFIG_SOUND is not set
+CONFIG_SOUND=y
+
+#
+# Advanced Linux Sound Architecture
+#
+CONFIG_SND=y
+CONFIG_SND_TIMER=y
+CONFIG_SND_PCM=y
+CONFIG_SND_SEQUENCER=y
+# CONFIG_SND_SEQ_DUMMY is not set
+CONFIG_SND_OSSEMUL=y
+CONFIG_SND_MIXER_OSS=y
+CONFIG_SND_PCM_OSS=y
+CONFIG_SND_SEQUENCER_OSS=y
+CONFIG_SND_SUPPORT_OLD_API=y
+# CONFIG_SND_VERBOSE_PRINTK is not set
+# CONFIG_SND_DEBUG is not set
+
+#
+# Generic devices
+#
+# CONFIG_SND_DUMMY is not set
+# CONFIG_SND_VIRMIDI is not set
+# CONFIG_SND_MTPAV is not set
+# CONFIG_SND_SERIAL_U16550 is not set
+# CONFIG_SND_MPU401 is not set
+
+#
+# PCI devices
+#
+# CONFIG_SND_AD1889 is not set
+# CONFIG_SND_ALI5451 is not set
+# CONFIG_SND_ATIIXP is not set
+# CONFIG_SND_ATIIXP_MODEM is not set
+# CONFIG_SND_AU8810 is not set
+# CONFIG_SND_AU8820 is not set
+# CONFIG_SND_AU8830 is not set
+# CONFIG_SND_BT87X is not set
+# CONFIG_SND_CA0106 is not set
+# CONFIG_SND_CMIPCI is not set
+# CONFIG_SND_CS4281 is not set
+# CONFIG_SND_CS46XX is not set
+# CONFIG_SND_EMU10K1 is not set
+# CONFIG_SND_EMU10K1X is not set
+# CONFIG_SND_ENS1370 is not set
+# CONFIG_SND_ENS1371 is not set
+# CONFIG_SND_ES1938 is not set
+# CONFIG_SND_ES1968 is not set
+# CONFIG_SND_FM801 is not set
+# CONFIG_SND_HDA_INTEL is not set
+# CONFIG_SND_HDSP is not set
+# CONFIG_SND_HDSPM is not set
+# CONFIG_SND_ICE1712 is not set
+# CONFIG_SND_ICE1724 is not set
+# CONFIG_SND_INTEL8X0 is not set
+# CONFIG_SND_KORG1212 is not set
+# CONFIG_SND_MAESTRO3 is not set
+# CONFIG_SND_MIXART is not set
+# CONFIG_SND_NM256 is not set
+# CONFIG_SND_PCXHR is not set
+# CONFIG_SND_RME32 is not set
+# CONFIG_SND_RME96 is not set
+# CONFIG_SND_RME9652 is not set
+# CONFIG_SND_SONICVIBES is not set
+# CONFIG_SND_TRIDENT is not set
+# CONFIG_SND_VIA82XX is not set
+# CONFIG_SND_VIA82XX_MODEM is not set
+# CONFIG_SND_VX222 is not set
+# CONFIG_SND_YMFPCI is not set
+
+#
+# GSC devices
+#
+CONFIG_SND_HARMONY=y
+
+#
+# Open Sound System
+#
+# CONFIG_SOUND_PRIME is not set
 
 #
 # USB support
@@ -723,6 +824,10 @@ CONFIG_USB_ARCH_HAS_OHCI=y
 # CONFIG_USB is not set
 
 #
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
+#
+
+#
 # USB Gadget Support
 #
 # CONFIG_USB_GADGET is not set
@@ -877,18 +982,23 @@ CONFIG_NLS_DEFAULT="iso8859-1"
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
-CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
+CONFIG_DEBUG_KERNEL=y
 CONFIG_LOG_BUF_SHIFT=16
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
+# CONFIG_DEBUG_MUTEXES is not set
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_KOBJECT is not set
 # CONFIG_DEBUG_INFO is not set
 # CONFIG_DEBUG_IOREMAP is not set
 # CONFIG_DEBUG_FS is not set
+# CONFIG_DEBUG_VM is not set
+CONFIG_FORCED_INLINING=y
+# CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_DEBUG_RODATA is not set
 
 #
 # Security options
diff --git a/arch/parisc/configs/c3000_defconfig b/arch/parisc/configs/c3000_defconfig
index 9d86b6b1ebd1..0b1c8c1fa8a3 100644
--- a/arch/parisc/configs/c3000_defconfig
+++ b/arch/parisc/configs/c3000_defconfig
@@ -626,6 +626,7 @@ CONFIG_ACENIC=m
 # CONFIG_DL2K is not set
 CONFIG_E1000=m
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/parisc/hpux/entry_hpux.S b/arch/parisc/hpux/entry_hpux.S
index fa9bf38787e7..31c8cccfba31 100644
--- a/arch/parisc/hpux/entry_hpux.S
+++ b/arch/parisc/hpux/entry_hpux.S
@@ -22,10 +22,9 @@
 #include <linux/linkage.h>
 #include <asm/unistd.h>
 
-        .text
-
 #define ENTRY_NAME(_name_) .word _name_
 
+        .section .rodata,"a"
         .align 4
         .export hpux_call_table
         .import hpux_unimplemented_wrapper
diff --git a/arch/parisc/hpux/sys_hpux.c b/arch/parisc/hpux/sys_hpux.c
index 29b4d61898f2..05273ccced0e 100644
--- a/arch/parisc/hpux/sys_hpux.c
+++ b/arch/parisc/hpux/sys_hpux.c
@@ -468,19 +468,23 @@ int hpux_sysfs(int opcode, unsigned long arg1, unsigned long arg2)
         if ( opcode == 1 ) { /* GETFSIND */     
                 len = strlen_user((char *)arg1);
                 printk(KERN_DEBUG "len of arg1 = %d\n", len);
-
-                fsname = (char *) kmalloc(len+1, GFP_KERNEL);
+                if (len == 0)
+                        return 0;
+                fsname = (char *) kmalloc(len, GFP_KERNEL);
                 if ( !fsname ) {
                         printk(KERN_DEBUG "failed to kmalloc fsname\n");
                         return 0;
                 }
 
-                if ( copy_from_user(fsname, (char *)arg1, len+1) ) {
+                if ( copy_from_user(fsname, (char *)arg1, len) ) {
                         printk(KERN_DEBUG "failed to copy_from_user fsname\n");
                         kfree(fsname);
                         return 0;
                 }
 
+                /* String could be altered by userspace after strlen_user() */
+                fsname[len] = '\0';
+
                 printk(KERN_DEBUG "that is '%s' as (char *)\n", fsname);
                 if ( !strcmp(fsname, "hfs") ) {
                         fstype = 0;
diff --git a/arch/parisc/kernel/drivers.c b/arch/parisc/kernel/drivers.c
index 2d804e2d16d1..3d569a485a1a 100644
--- a/arch/parisc/kernel/drivers.c
+++ b/arch/parisc/kernel/drivers.c
@@ -408,11 +408,10 @@ static void setup_bus_id(struct parisc_device *padev)
 
 struct parisc_device * create_tree_node(char id, struct device *parent)
 {
-        struct parisc_device *dev = kmalloc(sizeof(*dev), GFP_KERNEL);
+        struct parisc_device *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (!dev)
                 return NULL;
 
-        memset(dev, 0, sizeof(*dev));
         dev->hw_path = id;
         dev->id.hw_type = HPHW_FAULTY;
 
diff --git a/arch/parisc/kernel/parisc_ksyms.c b/arch/parisc/kernel/parisc_ksyms.c
index f40a777dd388..1d00c365f2b1 100644
--- a/arch/parisc/kernel/parisc_ksyms.c
+++ b/arch/parisc/kernel/parisc_ksyms.c
@@ -48,9 +48,6 @@ EXPORT_SYMBOL(strrchr);
 EXPORT_SYMBOL(strstr);
 EXPORT_SYMBOL(strpbrk);
 
-#include <linux/pm.h>
-EXPORT_SYMBOL(pm_power_off);
-
 #include <asm/atomic.h>
 EXPORT_SYMBOL(__xchg8);
 EXPORT_SYMBOL(__xchg32);
diff --git a/arch/parisc/kernel/pci.c b/arch/parisc/kernel/pci.c
index 88cba49c5301..79c7db2705fd 100644
--- a/arch/parisc/kernel/pci.c
+++ b/arch/parisc/kernel/pci.c
@@ -47,18 +47,17 @@
  * this makes the boot time much longer than necessary.
  * 20ms seems to work for all the HP PCI implementations to date.
  *
- * XXX: turn into a #defined constant in <asm/pci.h> ?
+ * #define pci_post_reset_delay 50
  */
-int pci_post_reset_delay = 50;
 
-struct pci_port_ops *pci_port;
-struct pci_bios_ops *pci_bios;
+struct pci_port_ops *pci_port __read_mostly;
+struct pci_bios_ops *pci_bios __read_mostly;
 
-int pci_hba_count = 0;
+static int pci_hba_count __read_mostly;
 
 /* parisc_pci_hba used by pci_port->in/out() ops to lookup bus data.  */
 #define PCI_HBA_MAX 32
-struct pci_hba_data *parisc_pci_hba[PCI_HBA_MAX];
+static struct pci_hba_data *parisc_pci_hba[PCI_HBA_MAX] __read_mostly;
 
 
 /********************************************************************
@@ -259,8 +258,10 @@ void __devinit pcibios_resource_to_bus(struct pci_dev *dev,
 void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
                               struct pci_bus_region *region)
 {
+#ifdef CONFIG_64BIT
         struct pci_bus *bus = dev->bus;
         struct pci_hba_data *hba = HBA_DATA(bus->bridge->platform_data);
+#endif
 
         if (res->flags & IORESOURCE_MEM) {
                 res->start = PCI_HOST_ADDR(hba, region->start);
diff --git a/arch/parisc/kernel/perf.c b/arch/parisc/kernel/perf.c
index 11d406cd0b3e..53f861c82f93 100644
--- a/arch/parisc/kernel/perf.c
+++ b/arch/parisc/kernel/perf.c
@@ -68,20 +68,20 @@ struct rdr_tbl_ent {
 };
 
 static int perf_processor_interface __read_mostly = UNKNOWN_INTF;
-static int perf_enabled __read_mostly = 0;
+static int perf_enabled __read_mostly;
 static spinlock_t perf_lock;
-struct parisc_device *cpu_device __read_mostly = NULL;
+struct parisc_device *cpu_device __read_mostly;
 
 /* RDRs to write for PCX-W */
-static int perf_rdrs_W[] = 
+static const int perf_rdrs_W[] =
         { 0, 1, 4, 5, 6, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, -1 };
 
 /* RDRs to write for PCX-U */
-static int perf_rdrs_U[] =
+static const int perf_rdrs_U[] =
         { 0, 1, 4, 5, 6, 7, 16, 17, 18, 20, 21, 22, 23, 24, 25, -1 };
 
 /* RDR register descriptions for PCX-W */
-static struct rdr_tbl_ent perf_rdr_tbl_W[] = {
+static const struct rdr_tbl_ent perf_rdr_tbl_W[] = {
         { 19,   1,      8 },   /* RDR 0 */
         { 16,   1,      16 },  /* RDR 1 */
         { 72,   2,      0 },   /* RDR 2 */
@@ -117,7 +117,7 @@ static struct rdr_tbl_ent perf_rdr_tbl_W[] = {
 };
 
 /* RDR register descriptions for PCX-U */
-static struct rdr_tbl_ent perf_rdr_tbl_U[] = {
+static const struct rdr_tbl_ent perf_rdr_tbl_U[] = {
         { 19,   1,      8 },              /* RDR 0 */
         { 32,   1,      16 },             /* RDR 1 */
         { 20,   1,      0 },              /* RDR 2 */
@@ -156,7 +156,7 @@ static struct rdr_tbl_ent perf_rdr_tbl_U[] = {
  * A non-zero write_control in the above tables is a byte offset into
  * this array.
  */
-static uint64_t perf_bitmasks[] = {
+static const uint64_t perf_bitmasks[] = {
         0x0000000000000000ul,     /* first dbl word must be zero */
         0xfdffe00000000000ul,     /* RDR0 bitmask */
         0x003f000000000000ul,     /* RDR1 bitmask */
@@ -173,7 +173,7 @@ static uint64_t perf_bitmasks[] = {
  * Write control bitmasks for Pa-8700 processor given
  * somethings have changed slightly.
  */
-static uint64_t perf_bitmasks_piranha[] = {
+static const uint64_t perf_bitmasks_piranha[] = {
         0x0000000000000000ul,     /* first dbl word must be zero */
         0xfdffe00000000000ul,     /* RDR0 bitmask */
         0x003f000000000000ul,     /* RDR1 bitmask */
@@ -186,7 +186,7 @@ static uint64_t perf_bitmasks_piranha[] = {
         0xfffc000000000000ul
 };
 
-static uint64_t *bitmask_array;   /* array of bitmasks to use */
+static const uint64_t *bitmask_array;   /* array of bitmasks to use */
 
 /******************************************************************************
  * Function Prototypes
@@ -200,7 +200,7 @@ static ssize_t perf_write(struct file *file, const char __user *buf, size_t coun
 static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 static void perf_start_counters(void);
 static int perf_stop_counters(uint32_t *raddr);
-static struct rdr_tbl_ent * perf_rdr_get_entry(uint32_t rdr_num);
+static const struct rdr_tbl_ent * perf_rdr_get_entry(uint32_t rdr_num);
 static int perf_rdr_read_ubuf(uint32_t  rdr_num, uint64_t *buffer);
 static int perf_rdr_clear(uint32_t rdr_num);
 static int perf_write_image(uint64_t *memaddr);
@@ -444,7 +444,6 @@ static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         uint32_t raddr[4];
         int error = 0;
 
-        lock_kernel();
         switch (cmd) {
 
             case PA_PERF_ON:
@@ -477,8 +476,6 @@ static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                         error = -ENOTTY;
         }
 
-        unlock_kernel();
-
         return error;
 }
 
@@ -655,7 +652,7 @@ static int perf_stop_counters(uint32_t *raddr)
  * Retrieve a pointer to the description of what this
  * RDR contains.
  */
-static struct rdr_tbl_ent * perf_rdr_get_entry(uint32_t rdr_num)
+static const struct rdr_tbl_ent * perf_rdr_get_entry(uint32_t rdr_num)
 {
         if (perf_processor_interface == ONYX_INTF) {
                 return &perf_rdr_tbl_U[rdr_num];
@@ -673,7 +670,7 @@ static int perf_rdr_read_ubuf(uint32_t	rdr_num, uint64_t *buffer)
 {
         uint64_t        data, data_mask = 0;
         uint32_t        width, xbits, i;
-        struct rdr_tbl_ent *tentry;
+        const struct rdr_tbl_ent *tentry;
 
         tentry = perf_rdr_get_entry(rdr_num);
         if ((width = tentry->width) == 0)
@@ -721,7 +718,7 @@ static int perf_rdr_read_ubuf(uint32_t	rdr_num, uint64_t *buffer)
  */
 static int perf_rdr_clear(uint32_t      rdr_num)
 {
-        struct rdr_tbl_ent *tentry;
+        const struct rdr_tbl_ent *tentry;
         int32_t         i;
 
         tentry = perf_rdr_get_entry(rdr_num);
@@ -753,10 +750,11 @@ static int perf_write_image(uint64_t *memaddr)
         uint64_t buffer[MAX_RDR_WORDS];
         uint64_t *bptr;
         uint32_t dwords;
-        uint32_t *intrigue_rdr;
-        uint64_t *intrigue_bitmask, tmp64;
+        const uint32_t *intrigue_rdr;
+        const uint64_t *intrigue_bitmask;
+        uint64_t tmp64;
         void __iomem *runway;
-        struct rdr_tbl_ent *tentry;
+        const struct rdr_tbl_ent *tentry;
         int i;
 
         /* Clear out counters */
@@ -830,7 +828,7 @@ static int perf_write_image(uint64_t *memaddr)
  */
 static void perf_rdr_write(uint32_t rdr_num, uint64_t *buffer)
 {
-        struct rdr_tbl_ent *tentry;
+        const struct rdr_tbl_ent *tentry;
         int32_t         i;
 
 printk("perf_rdr_write\n");
diff --git a/arch/parisc/kernel/perf_images.h b/arch/parisc/kernel/perf_images.h
index d9562fe3f75c..7fef9644df47 100644
--- a/arch/parisc/kernel/perf_images.h
+++ b/arch/parisc/kernel/perf_images.h
@@ -25,7 +25,7 @@
 
 #define PCXU_IMAGE_SIZE 584
 
-static uint32_t onyx_images[][PCXU_IMAGE_SIZE/sizeof(uint32_t)] = {
+static uint32_t onyx_images[][PCXU_IMAGE_SIZE/sizeof(uint32_t)] __read_mostly = {
 /*
  * CPI:
  *
@@ -2093,7 +2093,7 @@ static uint32_t onyx_images[][PCXU_IMAGE_SIZE/sizeof(uint32_t)] = {
 };
 #define PCXW_IMAGE_SIZE 576
 
-static uint32_t cuda_images[][PCXW_IMAGE_SIZE/sizeof(uint32_t)] = {
+static uint32_t cuda_images[][PCXW_IMAGE_SIZE/sizeof(uint32_t)] __read_mostly = {
 /*
  * CPI:     FROM CPI.IDF (Image 0)
  *
diff --git a/arch/parisc/kernel/process.c b/arch/parisc/kernel/process.c
index 5da41677e70b..e8dea4177113 100644
--- a/arch/parisc/kernel/process.c
+++ b/arch/parisc/kernel/process.c
@@ -54,27 +54,6 @@
 #include <asm/uaccess.h>
 #include <asm/unwind.h>
 
-static int hlt_counter __read_mostly;
-
-/*
- * Power off function, if any
- */ 
-void (*pm_power_off)(void);
-
-void disable_hlt(void)
-{
-        hlt_counter++;
-}
-
-EXPORT_SYMBOL(disable_hlt);
-
-void enable_hlt(void)
-{
-        hlt_counter--;
-}
-
-EXPORT_SYMBOL(enable_hlt);
-
 void default_idle(void)
 {
         barrier();
@@ -102,12 +81,7 @@ void cpu_idle(void)
 }
 
 
-#ifdef __LP64__
-#define COMMAND_GLOBAL  0xfffffffffffe0030UL
-#else
-#define COMMAND_GLOBAL  0xfffe0030
-#endif
-
+#define COMMAND_GLOBAL  F_EXTEND(0xfffe0030)
 #define CMD_RESET       5       /* reset any module */
 
 /*
@@ -162,6 +136,7 @@ void machine_halt(void)
         */
 }
 
+void (*chassis_power_off)(void);
 
 /*
  * This routine is called from sys_reboot to actually turn off the
@@ -170,8 +145,8 @@ void machine_halt(void)
 void machine_power_off(void)
 {
         /* If there is a registered power off handler, call it. */
-        if(pm_power_off)
-                pm_power_off();
+        if (chassis_power_off)
+                chassis_power_off();
 
         /* Put the soft power button back under hardware control.
          * If the user had already pressed the power button, the
@@ -187,6 +162,8 @@ void machine_power_off(void)
                KERN_EMERG "Please power this system off now.");
 }
 
+void (*pm_power_off)(void) = machine_power_off;
+EXPORT_SYMBOL(pm_power_off);
 
 /*
  * Create a kernel thread
diff --git a/arch/parisc/kernel/ptrace.c b/arch/parisc/kernel/ptrace.c
index 27160e8bf15b..413292f1a4a3 100644
--- a/arch/parisc/kernel/ptrace.c
+++ b/arch/parisc/kernel/ptrace.c
@@ -91,7 +91,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 int copied;
 
 #ifdef __LP64__
-                if (is_compat_task(child)) {
+                if (personality(child->personality) == PER_LINUX32) {
                         unsigned int tmp;
 
                         addr &= 0xffffffffL;
@@ -123,7 +123,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         case PTRACE_POKEDATA:
                 ret = 0;
 #ifdef __LP64__
-                if (is_compat_task(child)) {
+                if (personality(child->personality) == PER_LINUX32) {
                         unsigned int tmp = (unsigned int)data;
                         DBG("sys_ptrace(POKE%s, %d, %lx, %lx)\n",
                                 request == PTRACE_POKETEXT ? "TEXT" : "DATA",
@@ -146,7 +146,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         case PTRACE_PEEKUSR: {
                 ret = -EIO;
 #ifdef __LP64__
-                if (is_compat_task(child)) {
+                if (personality(child->personality) == PER_LINUX32) {
                         unsigned int tmp;
 
                         if (addr & (sizeof(int)-1))
@@ -205,7 +205,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                         goto out_tsk;
                 }
 #ifdef __LP64__
-                if (is_compat_task(child)) {
+                if (personality(child->personality) == PER_LINUX32) {
                         if (addr & (sizeof(int)-1))
                                 goto out_tsk;
                         if ((addr = translate_usr_offset(addr)) < 0)
diff --git a/arch/parisc/kernel/signal.c b/arch/parisc/kernel/signal.c
index 3a25a7bd673e..05767e83cf2d 100644
--- a/arch/parisc/kernel/signal.c
+++ b/arch/parisc/kernel/signal.c
@@ -317,7 +317,7 @@ setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
         
         if(personality(current->personality) == PER_LINUX32) {
                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
-                err |= compat_copy_siginfo_to_user(&compat_frame->info, info);
+                err |= copy_siginfo_to_user32(&compat_frame->info, info);
                 DBG(1,"SETUP_RT_FRAME: 1\n");
                 compat_val = (compat_int_t)current->sas_ss_sp;
                 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
diff --git a/arch/parisc/kernel/signal32.c b/arch/parisc/kernel/signal32.c
index 0792e20efef3..a6b4231cafa1 100644
--- a/arch/parisc/kernel/signal32.c
+++ b/arch/parisc/kernel/signal32.c
@@ -31,7 +31,6 @@
 #include <linux/types.h>
 #include <linux/errno.h>
 
-#include <asm/compat_signal.h>
 #include <asm/uaccess.h>
 
 #include "signal32.h"
@@ -398,3 +397,104 @@ setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __
 
         return err;
 }
+
+int
+copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from)
+{
+        unsigned long tmp;
+        int err;
+
+        if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
+                return -EFAULT;
+
+        err = __get_user(to->si_signo, &from->si_signo);
+        err |= __get_user(to->si_errno, &from->si_errno);
+        err |= __get_user(to->si_code, &from->si_code);
+
+        if (to->si_code < 0)
+                err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
+        else {
+                switch (to->si_code >> 16) {
+                      case __SI_CHLD >> 16:
+                        err |= __get_user(to->si_utime, &from->si_utime);
+                        err |= __get_user(to->si_stime, &from->si_stime);
+                        err |= __get_user(to->si_status, &from->si_status);
+                      default:
+                        err |= __get_user(to->si_pid, &from->si_pid);
+                        err |= __get_user(to->si_uid, &from->si_uid);
+                        break;
+                      case __SI_FAULT >> 16:
+                        err |= __get_user(tmp, &from->si_addr);
+                        to->si_addr = (void __user *) tmp;
+                        break;
+                      case __SI_POLL >> 16:
+                        err |= __get_user(to->si_band, &from->si_band);
+                        err |= __get_user(to->si_fd, &from->si_fd);
+                        break;
+                      case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
+                      case __SI_MESGQ >> 16:
+                        err |= __get_user(to->si_pid, &from->si_pid);
+                        err |= __get_user(to->si_uid, &from->si_uid);
+                        err |= __get_user(to->si_int, &from->si_int);
+                        break;
+                }
+        }
+        return err;
+}
+
+int
+copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from)
+{
+        unsigned int addr;
+        int err;
+
+        if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
+                return -EFAULT;
+
+        /* If you change siginfo_t structure, please be sure
+           this code is fixed accordingly.
+           It should never copy any pad contained in the structure
+           to avoid security leaks, but must copy the generic
+           3 ints plus the relevant union member.
+           This routine must convert siginfo from 64bit to 32bit as well
+           at the same time.  */
+        err = __put_user(from->si_signo, &to->si_signo);
+        err |= __put_user(from->si_errno, &to->si_errno);
+        err |= __put_user((short)from->si_code, &to->si_code);
+        if (from->si_code < 0)
+                err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
+        else {
+                switch (from->si_code >> 16) {
+                case __SI_CHLD >> 16:
+                        err |= __put_user(from->si_utime, &to->si_utime);
+                        err |= __put_user(from->si_stime, &to->si_stime);
+                        err |= __put_user(from->si_status, &to->si_status);
+                default:
+                        err |= __put_user(from->si_pid, &to->si_pid);
+                        err |= __put_user(from->si_uid, &to->si_uid);
+                        break;
+                case __SI_FAULT >> 16:
+                        /* avoid type-checking warnings by copying _pad[0] in lieu of si_addr... */
+                        err |= __put_user(from->_sifields._pad[0], &to->si_addr);
+                        break;
+                case __SI_POLL >> 16:
+                        err |= __put_user(from->si_band, &to->si_band);
+                        err |= __put_user(from->si_fd, &to->si_fd);
+                        break;
+                case __SI_TIMER >> 16:
+                        err |= __put_user(from->si_tid, &to->si_tid);
+                        err |= __put_user(from->si_overrun, &to->si_overrun);
+                        addr = (unsigned long) from->si_ptr;
+                        err |= __put_user(addr, &to->si_ptr);
+                        break;
+                case __SI_RT >> 16:     /* Not generated by the kernel as of now.  */
+                case __SI_MESGQ >> 16:
+                        err |= __put_user(from->si_uid, &to->si_uid);
+                        err |= __put_user(from->si_pid, &to->si_pid);
+                        addr = (unsigned long) from->si_ptr;
+                        err |= __put_user(addr, &to->si_ptr);
+                        break;
+                }
+        }
+        return err;
+}
diff --git a/arch/parisc/kernel/signal32.h b/arch/parisc/kernel/signal32.h
index 4d1569e717cc..e39b38a67a87 100644
--- a/arch/parisc/kernel/signal32.h
+++ b/arch/parisc/kernel/signal32.h
@@ -20,8 +20,34 @@
 #define _PARISC64_KERNEL_SIGNAL32_H
 
 #include <linux/compat.h>
-#include <asm/compat_signal.h>
-#include <asm/compat_rt_sigframe.h>
+
+typedef compat_uptr_t compat_sighandler_t;
+
+typedef struct compat_sigaltstack {
+        compat_uptr_t ss_sp;
+        compat_int_t ss_flags;
+        compat_size_t ss_size;
+} compat_stack_t;
+
+/* Most things should be clean enough to redefine this at will, if care
+   is taken to make libc match.  */
+
+struct compat_sigaction {
+        compat_sighandler_t sa_handler;
+        compat_uint_t sa_flags;
+        compat_sigset_t sa_mask;               /* mask last for extensibility */
+};
+
+/* 32-bit ucontext as seen from an 64-bit kernel */
+struct compat_ucontext {
+        compat_uint_t uc_flags;
+        compat_uptr_t uc_link;
+        compat_stack_t uc_stack;        /* struct compat_sigaltstack (12 bytes)*/
+        /* FIXME: Pad out to get uc_mcontext to start at an 8-byte aligned boundary */
+        compat_uint_t pad[1];
+        struct compat_sigcontext uc_mcontext;
+        compat_sigset_t uc_sigmask;     /* mask last for extensibility */
+};
 
 /* ELF32 signal handling */
 
@@ -29,6 +55,103 @@ struct k_sigaction32 {
         struct compat_sigaction sa;
 };
 
+typedef struct compat_siginfo {
+        int si_signo;
+        int si_errno;
+        int si_code;
+
+        union {
+                int _pad[((128/sizeof(int)) - 3)];
+
+                /* kill() */
+                struct {
+                        unsigned int _pid;      /* sender's pid */
+                        unsigned int _uid;      /* sender's uid */
+                } _kill;
+
+                /* POSIX.1b timers */
+                struct {
+                        compat_timer_t _tid;            /* timer id */
+                        int _overrun;           /* overrun count */
+                        char _pad[sizeof(unsigned int) - sizeof(int)];
+                        compat_sigval_t _sigval;        /* same as below */
+                        int _sys_private;       /* not to be passed to user */
+                } _timer;
+
+                /* POSIX.1b signals */
+                struct {
+                        unsigned int _pid;      /* sender's pid */
+                        unsigned int _uid;      /* sender's uid */
+                        compat_sigval_t _sigval;
+                } _rt;
+
+                /* SIGCHLD */
+                struct {
+                        unsigned int _pid;      /* which child */
+                        unsigned int _uid;      /* sender's uid */
+                        int _status;            /* exit code */
+                        compat_clock_t _utime;
+                        compat_clock_t _stime;
+                } _sigchld;
+
+                /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
+                struct {
+                        unsigned int _addr;     /* faulting insn/memory ref. */
+                } _sigfault;
+
+                /* SIGPOLL */
+                struct {
+                        int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
+                        int _fd;
+                } _sigpoll;
+        } _sifields;
+} compat_siginfo_t;
+
+int copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from);
+int copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from);
+
+/* In a deft move of uber-hackery, we decide to carry the top half of all
+ * 64-bit registers in a non-portable, non-ABI, hidden structure.
+ * Userspace can read the hidden structure if it *wants* but is never
+ * guaranteed to be in the same place. Infact the uc_sigmask from the
+ * ucontext_t structure may push the hidden register file downards
+ */
+struct compat_regfile {
+        /* Upper half of all the 64-bit registers that were truncated
+           on a copy to a 32-bit userspace */
+        compat_int_t rf_gr[32];
+        compat_int_t rf_iasq[2];
+        compat_int_t rf_iaoq[2];
+        compat_int_t rf_sar;
+};
+
+#define COMPAT_SIGRETURN_TRAMP 4
+#define COMPAT_SIGRESTARTBLOCK_TRAMP 5
+#define COMPAT_TRAMP_SIZE (COMPAT_SIGRETURN_TRAMP + \
+                                COMPAT_SIGRESTARTBLOCK_TRAMP)
+
+struct compat_rt_sigframe {
+        /* XXX: Must match trampoline size in arch/parisc/kernel/signal.c
+                Secondary to that it must protect the ERESTART_RESTARTBLOCK
+                trampoline we left on the stack (we were bad and didn't
+                change sp so we could run really fast.) */
+        compat_uint_t tramp[COMPAT_TRAMP_SIZE];
+        compat_siginfo_t info;
+        struct compat_ucontext uc;
+        /* Hidden location of truncated registers, *must* be last. */
+        struct compat_regfile regs;
+};
+
+/*
+ * The 32-bit ABI wants at least 48 bytes for a function call frame:
+ * 16 bytes for arg0-arg3, and 32 bytes for magic (the only part of
+ * which Linux/parisc uses is sp-20 for the saved return pointer...)
+ * Then, the stack pointer must be rounded to a cache line (64 bytes).
+ */
+#define SIGFRAME32              64
+#define FUNCTIONCALLFRAME32     48
+#define PARISC_RT_SIGFRAME_SIZE32 (((sizeof(struct compat_rt_sigframe) + FUNCTIONCALLFRAME32) + SIGFRAME32) & -SIGFRAME32)
+
 void sigset_32to64(sigset_t *s64, compat_sigset_t *s32);
 void sigset_64to32(compat_sigset_t *s32, sigset_t *s64);
 int do_sigaltstack32 (const compat_stack_t __user *uss32, 
diff --git a/arch/parisc/kernel/syscall.S b/arch/parisc/kernel/syscall.S
index d66163492890..af88afef41bd 100644
--- a/arch/parisc/kernel/syscall.S
+++ b/arch/parisc/kernel/syscall.S
@@ -650,6 +650,8 @@ end_linux_gateway_page:
 #define LWS_ENTRY(_name_) .word  (lws_##_name_ - linux_gateway_page)
 #endif
 
+        .section .rodata,"a"
+
         .align 4096
         /* Light-weight-syscall table */
         /* Start of lws table. */
diff --git a/arch/parisc/kernel/syscall_table.S b/arch/parisc/kernel/syscall_table.S
index 32cbc0489324..51d2480627d1 100644
--- a/arch/parisc/kernel/syscall_table.S
+++ b/arch/parisc/kernel/syscall_table.S
@@ -374,5 +374,24 @@
         ENTRY_SAME(keyctl)
         ENTRY_SAME(ioprio_set)
         ENTRY_SAME(ioprio_get)
+        ENTRY_SAME(inotify_init)
+        ENTRY_SAME(inotify_add_watch)   /* 270 */
+        ENTRY_SAME(inotify_rm_watch)
+        ENTRY_COMP(pselect6)
+        ENTRY_COMP(ppoll)
+        ENTRY_SAME(migrate_pages)
+        ENTRY_COMP(openat)              /* 275 */
+        ENTRY_SAME(mkdirat)
+        ENTRY_SAME(mknodat)
+        ENTRY_SAME(fchownat)
+        ENTRY_COMP(futimesat)
+        ENTRY_COMP(newfstatat)          /* 280 */
+        ENTRY_SAME(unlinkat)
+        ENTRY_SAME(renameat)
+        ENTRY_SAME(linkat)
+        ENTRY_SAME(symlinkat)
+        ENTRY_SAME(readlinkat)          /* 285 */
+        ENTRY_SAME(fchmodat)
+        ENTRY_SAME(faccessat)
         /* Nothing yet */
 
diff --git a/arch/parisc/kernel/traps.c b/arch/parisc/kernel/traps.c
index 15914f0235a0..ff200608c851 100644
--- a/arch/parisc/kernel/traps.c
+++ b/arch/parisc/kernel/traps.c
@@ -193,10 +193,9 @@ void show_stack(struct task_struct *task, unsigned long *s)
 
 HERE:
                 asm volatile ("copy %%r30, %0" : "=r"(sp));
-                r = (struct pt_regs *)kmalloc(sizeof(struct pt_regs), GFP_KERNEL);
+                r = kzalloc(sizeof(struct pt_regs), GFP_KERNEL);
                 if (!r)
                         return;
-                memset(r, 0, sizeof(struct pt_regs));
                 r->iaoq[0] = (unsigned long)&&HERE;
                 r->gr[2] = (unsigned long)__builtin_return_address(0);
                 r->gr[30] = sp;
diff --git a/arch/parisc/math-emu/decode_exc.c b/arch/parisc/math-emu/decode_exc.c
index f84f2586672b..66c8a9f6a27e 100644
--- a/arch/parisc/math-emu/decode_exc.c
+++ b/arch/parisc/math-emu/decode_exc.c
@@ -337,6 +337,7 @@ decode_fpu(unsigned int Fpu_register[], unsigned int trap_counts[])
                 }
                 break;
           case INVALIDEXCEPTION:
+          case OPC_2E_INVALIDEXCEPTION:
                 update_trap_counts(Fpu_register, aflags, bflags, trap_counts);
                 return SIGNALCODE(SIGFPE, FPE_FLTINV);
           case DIVISIONBYZEROEXCEPTION:
diff --git a/arch/parisc/mm/init.c b/arch/parisc/mm/init.c
index 720287d46e55..7847ca13d6c2 100644
--- a/arch/parisc/mm/init.c
+++ b/arch/parisc/mm/init.c
@@ -371,17 +371,11 @@ static void __init setup_bootmem(void)
 
 void free_initmem(void)
 {
-        /* FIXME: */
-#if 0
-        printk(KERN_INFO "NOT FREEING INITMEM (%dk)\n",
-                        (&__init_end - &__init_begin) >> 10);
-        return;
-#else
         unsigned long addr;
         
         printk(KERN_INFO "Freeing unused kernel memory: ");
 
-#if 1
+#ifdef CONFIG_DEBUG_KERNEL
         /* Attempt to catch anyone trying to execute code here
          * by filling the page with BRK insns.
          * 
@@ -414,9 +408,21 @@ void free_initmem(void)
         pdc_chassis_send_status(PDC_CHASSIS_DIRECT_BCOMPLETE);
         
         printk("%luk freed\n", (unsigned long)(&__init_end - &__init_begin) >> 10);
-#endif
 }
 
+
+#ifdef CONFIG_DEBUG_RODATA
+void mark_rodata_ro(void)
+{
+        extern char __start_rodata, __end_rodata;
+        /* rodata memory was already mapped with KERNEL_RO access rights by
+           pagetable_init() and map_pages(). No need to do additional stuff here */
+        printk (KERN_INFO "Write protecting the kernel read-only data: %luk\n",
+                (unsigned long)(&__end_rodata - &__start_rodata) >> 10);
+}
+#endif
+
+
 /*
  * Just an arbitrary offset to serve as a "hole" between mapping areas
  * (between top of physical memory and a potential pcxl dma mapping
@@ -477,11 +483,6 @@ void __init mem_init(void)
 
 }
 
-int do_check_pgt_cache(int low, int high)
-{
-        return 0;
-}
-
 unsigned long *empty_zero_page __read_mostly;
 
 void show_mem(void)
@@ -690,7 +691,7 @@ static void __init pagetable_init(void)
 
 #ifdef CONFIG_BLK_DEV_INITRD
         if (initrd_end && initrd_end > mem_limit) {
-                printk("initrd: mapping %08lx-%08lx\n", initrd_start, initrd_end);
+                printk(KERN_INFO "initrd: mapping %08lx-%08lx\n", initrd_start, initrd_end);
                 map_pages(initrd_start, __pa(initrd_start),
                         initrd_end - initrd_start, PAGE_KERNEL);
         }
@@ -792,8 +793,6 @@ map_hpux_gateway_page(struct task_struct *tsk, struct mm_struct *mm)
 EXPORT_SYMBOL(map_hpux_gateway_page);
 #endif
 
-extern void flush_tlb_all_local(void);
-
 void __init paging_init(void)
 {
         int i;
@@ -802,7 +801,7 @@ void __init paging_init(void)
         pagetable_init();
         gateway_init();
         flush_cache_all_local(); /* start with known state */
-        flush_tlb_all_local();
+        flush_tlb_all_local(NULL);
 
         for (i = 0; i < npmem_ranges; i++) {
                 unsigned long zones_size[MAX_NR_ZONES] = { 0, 0, 0 };
@@ -993,7 +992,7 @@ void flush_tlb_all(void)
             do_recycle++;
         }
         spin_unlock(&sid_lock);
-        on_each_cpu((void (*)(void *))flush_tlb_all_local, NULL, 1, 1);
+        on_each_cpu(flush_tlb_all_local, NULL, 1, 1);
         if (do_recycle) {
             spin_lock(&sid_lock);
             recycle_sids(recycle_ndirty,recycle_dirty_array);
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/configs/cell_defconfig b/arch/powerpc/configs/cell_defconfig
index b657f7e44762..063b84f2cbea 100644
--- a/arch/powerpc/configs/cell_defconfig
+++ b/arch/powerpc/configs/cell_defconfig
@@ -533,6 +533,7 @@ CONFIG_MII=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=m
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/powerpc/configs/g5_defconfig b/arch/powerpc/configs/g5_defconfig
index 3c22ccb18519..d6fed3f56580 100644
--- a/arch/powerpc/configs/g5_defconfig
+++ b/arch/powerpc/configs/g5_defconfig
@@ -675,6 +675,7 @@ CONFIG_ACENIC_OMIT_TIGON_I=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/powerpc/configs/iseries_defconfig b/arch/powerpc/configs/iseries_defconfig
index 751a622fb7a7..c775027947f9 100644
--- a/arch/powerpc/configs/iseries_defconfig
+++ b/arch/powerpc/configs/iseries_defconfig
@@ -567,6 +567,7 @@ CONFIG_ACENIC=m
 # CONFIG_DL2K is not set
 CONFIG_E1000=m
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/powerpc/configs/maple_defconfig b/arch/powerpc/configs/maple_defconfig
index 07b6d3d23360..68194c03f6d1 100644
--- a/arch/powerpc/configs/maple_defconfig
+++ b/arch/powerpc/configs/maple_defconfig
@@ -454,6 +454,7 @@ CONFIG_AMD8111_ETH=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/powerpc/configs/ppc64_defconfig b/arch/powerpc/configs/ppc64_defconfig
index 0b2b55a79c3c..6f6c6bed1aa5 100644
--- a/arch/powerpc/configs/ppc64_defconfig
+++ b/arch/powerpc/configs/ppc64_defconfig
@@ -724,6 +724,7 @@ CONFIG_ACENIC_OMIT_TIGON_I=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/powerpc/configs/pseries_defconfig b/arch/powerpc/configs/pseries_defconfig
index a50ce0fa9243..aa9893a1f6e8 100644
--- a/arch/powerpc/configs/pseries_defconfig
+++ b/arch/powerpc/configs/pseries_defconfig
@@ -671,6 +671,7 @@ CONFIG_ACENIC_OMIT_TIGON_I=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
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/entry_32.S b/arch/powerpc/kernel/entry_32.S
index d8da2a35c0a4..f20a67261ec7 100644
--- a/arch/powerpc/kernel/entry_32.S
+++ b/arch/powerpc/kernel/entry_32.S
@@ -227,7 +227,7 @@ ret_from_syscall:
         MTMSRD(r10)
         lwz     r9,TI_FLAGS(r12)
         li      r8,-_LAST_ERRNO
-        andi.   r0,r9,(_TIF_SYSCALL_T_OR_A|_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_RESTOREALL)
+        andi.   r0,r9,(_TIF_SYSCALL_T_OR_A|_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_RESTOREALL|_TIF_RESTORE_SIGMASK)
         bne-    syscall_exit_work
         cmplw   0,r3,r8
         blt+    syscall_exit_cont
@@ -357,7 +357,7 @@ save_user_nvgprs_cont:
         lwz     r5,_MSR(r1)
         andi.   r5,r5,MSR_PR
         beq     ret_from_except
-        andi.   r0,r9,_TIF_SIGPENDING
+        andi.   r0,r9,_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK
         beq     ret_from_except
         b       do_user_signal
 8:
@@ -683,7 +683,7 @@ user_exc_return:		/* r10 contains MSR_KERNEL here */
         /* Check current_thread_info()->flags */
         rlwinm  r9,r1,0,0,(31-THREAD_SHIFT)
         lwz     r9,TI_FLAGS(r9)
-        andi.   r0,r9,(_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_RESTOREALL)
+        andi.   r0,r9,(_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_RESTOREALL|_TIF_RESTORE_SIGMASK)
         bne     do_work
 
 restore_user:
@@ -917,7 +917,7 @@ recheck:
         lwz     r9,TI_FLAGS(r9)
         andi.   r0,r9,_TIF_NEED_RESCHED
         bne-    do_resched
-        andi.   r0,r9,_TIF_SIGPENDING
+        andi.   r0,r9,_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK
         beq     restore_user
 do_user_signal:                 /* r10 contains MSR_KERNEL here */
         ori     r10,r10,MSR_EE
diff --git a/arch/powerpc/kernel/entry_64.S b/arch/powerpc/kernel/entry_64.S
index 542036318866..388f861b8ed1 100644
--- a/arch/powerpc/kernel/entry_64.S
+++ b/arch/powerpc/kernel/entry_64.S
@@ -160,7 +160,7 @@ syscall_exit:
         mtmsrd  r10,1
         ld      r9,TI_FLAGS(r12)
         li      r11,-_LAST_ERRNO
-        andi.   r0,r9,(_TIF_SYSCALL_T_OR_A|_TIF_SINGLESTEP|_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_RESTOREALL|_TIF_SAVE_NVGPRS|_TIF_NOERROR)
+        andi.   r0,r9,(_TIF_SYSCALL_T_OR_A|_TIF_SINGLESTEP|_TIF_SIGPENDING|_TIF_NEED_RESCHED|_TIF_RESTOREALL|_TIF_SAVE_NVGPRS|_TIF_NOERROR|_TIF_RESTORE_SIGMASK)
         bne-    syscall_exit_work
         cmpld   r3,r11
         ld      r5,_CCR(r1)
diff --git a/arch/powerpc/kernel/fpu.S b/arch/powerpc/kernel/fpu.S
index e4362dfa37fb..340730fb8c91 100644
--- a/arch/powerpc/kernel/fpu.S
+++ b/arch/powerpc/kernel/fpu.S
@@ -66,7 +66,7 @@ _GLOBAL(load_up_fpu)
 #else
         ld      r4,PACACURRENT(r13)
         addi    r5,r4,THREAD            /* Get THREAD */
-        ld      r4,THREAD_FPEXC_MODE(r5)
+        lwz     r4,THREAD_FPEXC_MODE(r5)
         ori     r12,r12,MSR_FP
         or      r12,r12,r4
         std     r12,_MSR(r1)
diff --git a/arch/powerpc/kernel/head_64.S b/arch/powerpc/kernel/head_64.S
index 308268466342..415659629394 100644
--- a/arch/powerpc/kernel/head_64.S
+++ b/arch/powerpc/kernel/head_64.S
@@ -749,11 +749,12 @@ iSeries_secondary_smp_loop:
 
         .globl decrementer_iSeries_masked
 decrementer_iSeries_masked:
+        /* We may not have a valid TOC pointer in here. */
         li      r11,1
         ld      r12,PACALPPACAPTR(r13)
         stb     r11,LPPACADECRINT(r12)
-        LOAD_REG_ADDRBASE(r12,tb_ticks_per_jiffy)
-        lwz     r12,ADDROFF(tb_ticks_per_jiffy)(r12)
+        LOAD_REG_IMMEDIATE(r12, tb_ticks_per_jiffy)
+        lwz     r12,0(r12)
         mtspr   SPRN_DEC,r12
         /* fall through */
 
diff --git a/arch/powerpc/kernel/iommu.c b/arch/powerpc/kernel/iommu.c
index 4d9b4388918b..946f3219fd29 100644
--- a/arch/powerpc/kernel/iommu.c
+++ b/arch/powerpc/kernel/iommu.c
@@ -334,9 +334,6 @@ int iommu_map_sg(struct device *dev, struct iommu_table *tbl,
 
         spin_unlock_irqrestore(&(tbl->it_lock), flags);
 
-        /* Make sure updates are seen by hardware */
-        mb();
-
         DBG("mapped %d elements:\n", outcount);
 
         /* For the sake of iommu_unmap_sg, we clear out the length in the
@@ -347,6 +344,10 @@ int iommu_map_sg(struct device *dev, struct iommu_table *tbl,
                 outs->dma_address = DMA_ERROR_CODE;
                 outs->dma_length = 0;
         }
+
+        /* Make sure updates are seen by hardware */
+        mb();
+
         return outcount;
 
  failure:
@@ -358,6 +359,8 @@ int iommu_map_sg(struct device *dev, struct iommu_table *tbl,
                         npages = (PAGE_ALIGN(s->dma_address + s->dma_length) - vaddr)
                                 >> PAGE_SHIFT;
                         __iommu_free(tbl, vaddr, npages);
+                        s->dma_address = DMA_ERROR_CODE;
+                        s->dma_length = 0;
                 }
         }
         spin_unlock_irqrestore(&(tbl->it_lock), flags);
diff --git a/arch/powerpc/kernel/legacy_serial.c b/arch/powerpc/kernel/legacy_serial.c
index f970ace208d3..c7a799a09516 100644
--- a/arch/powerpc/kernel/legacy_serial.c
+++ b/arch/powerpc/kernel/legacy_serial.c
@@ -134,7 +134,6 @@ static int __init add_legacy_soc_port(struct device_node *np,
         return add_legacy_port(np, -1, UPIO_MEM, addr, addr, NO_IRQ, flags);
 }
 
-#ifdef CONFIG_ISA
 static int __init add_legacy_isa_port(struct device_node *np,
                                       struct device_node *isa_brg)
 {
@@ -168,7 +167,6 @@ static int __init add_legacy_isa_port(struct device_node *np,
         return add_legacy_port(np, index, UPIO_PORT, reg[1], taddr, NO_IRQ, UPF_BOOT_AUTOCONF);
 
 }
-#endif
 
 #ifdef CONFIG_PCI
 static int __init add_legacy_pci_port(struct device_node *np,
@@ -276,7 +274,6 @@ void __init find_legacy_serial_ports(void)
                 of_node_put(soc);
         }
 
-#ifdef CONFIG_ISA
         /* First fill our array with ISA ports */
         for (np = NULL; (np = of_find_node_by_type(np, "serial"));) {
                 struct device_node *isa = of_get_parent(np);
@@ -287,7 +284,6 @@ void __init find_legacy_serial_ports(void)
                 }
                 of_node_put(isa);
         }
-#endif
 
 #ifdef CONFIG_PCI
         /* Next, try to locate PCI ports */
diff --git a/arch/powerpc/kernel/prom.c b/arch/powerpc/kernel/prom.c
index d50c8df0183e..294832a7e0a6 100644
--- a/arch/powerpc/kernel/prom.c
+++ b/arch/powerpc/kernel/prom.c
@@ -491,7 +491,12 @@ void __init finish_device_tree(void)
         size = 16;
         finish_node(allnodes, &size, 1);
         size -= 16;
-        end = start = (unsigned long) __va(lmb_alloc(size, 128));
+
+        if (0 == size)
+                end = start = 0;
+        else
+                end = start = (unsigned long)__va(lmb_alloc(size, 128));
+
         finish_node(allnodes, &end, 0);
         BUG_ON(end != start + size);
 
@@ -1398,8 +1403,8 @@ struct device_node *of_find_node_by_name(struct device_node *from,
 
         read_lock(&devtree_lock);
         np = from ? from->allnext : allnodes;
-        for (; np != 0; np = np->allnext)
-                if (np->name != 0 && strcasecmp(np->name, name) == 0
+        for (; np != NULL; np = np->allnext)
+                if (np->name != NULL && strcasecmp(np->name, name) == 0
                     && of_node_get(np))
                         break;
         if (from)
@@ -1917,3 +1922,30 @@ int prom_update_property(struct device_node *np,
 
         return 0;
 }
+
+#ifdef CONFIG_KEXEC
+/* We may have allocated the flat device tree inside the crash kernel region
+ * in prom_init. If so we need to move it out into regular memory. */
+void kdump_move_device_tree(void)
+{
+        unsigned long start, end;
+        struct boot_param_header *new;
+
+        start = __pa((unsigned long)initial_boot_params);
+        end = start + initial_boot_params->totalsize;
+
+        if (end < crashk_res.start || start > crashk_res.end)
+                return;
+
+        new = (struct boot_param_header*)
+                __va(lmb_alloc(initial_boot_params->totalsize, PAGE_SIZE));
+
+        memcpy(new, initial_boot_params, initial_boot_params->totalsize);
+
+        initial_boot_params = new;
+
+        DBG("Flat device tree blob moved to %p\n", initial_boot_params);
+
+        /* XXX should we unreserve the old DT? */
+}
+#endif /* CONFIG_KEXEC */
diff --git a/arch/powerpc/kernel/prom_init.c b/arch/powerpc/kernel/prom_init.c
index 7881ec96ef11..ec7153f4d47c 100644
--- a/arch/powerpc/kernel/prom_init.c
+++ b/arch/powerpc/kernel/prom_init.c
@@ -2098,6 +2098,10 @@ unsigned long __init prom_init(unsigned long r3, unsigned long r4,
          */
         prom_init_stdout();
 
+        /* Bail if this is a kdump kernel. */
+        if (PHYSICAL_START > 0)
+                prom_panic("Error: You can't boot a kdump kernel from OF!\n");
+
         /*
          * Check for an initrd
          */
diff --git a/arch/powerpc/kernel/prom_parse.c b/arch/powerpc/kernel/prom_parse.c
index a8099c806150..3934c227549b 100644
--- a/arch/powerpc/kernel/prom_parse.c
+++ b/arch/powerpc/kernel/prom_parse.c
@@ -465,8 +465,10 @@ u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
         if (parent == NULL)
                 return NULL;
         bus = of_match_bus(parent);
-        if (strcmp(bus->name, "pci"))
+        if (strcmp(bus->name, "pci")) {
+                of_node_put(parent);
                 return NULL;
+        }
         bus->count_cells(dev, &na, &ns);
         of_node_put(parent);
         if (!OF_CHECK_COUNTS(na, ns))
diff --git a/arch/powerpc/kernel/rtas.c b/arch/powerpc/kernel/rtas.c
index 7fe4a5c944c9..b5b2add7ad1e 100644
--- a/arch/powerpc/kernel/rtas.c
+++ b/arch/powerpc/kernel/rtas.c
@@ -22,6 +22,7 @@
 
 #include <asm/prom.h>
 #include <asm/rtas.h>
+#include <asm/hvcall.h>
 #include <asm/semaphore.h>
 #include <asm/machdep.h>
 #include <asm/page.h>
@@ -565,6 +566,7 @@ static int ibm_suspend_me_token = RTAS_UNKNOWN_SERVICE;
 #ifdef CONFIG_PPC_PSERIES
 static void rtas_percpu_suspend_me(void *info)
 {
+        int i;
         long rc;
         long flags;
         struct rtas_suspend_me_data *data =
@@ -587,18 +589,16 @@ static void rtas_percpu_suspend_me(void *info)
 
         if (rc == H_Continue) {
                 data->waiting = 0;
-                rtas_call(ibm_suspend_me_token, 0, 1,
-                          data->args->args);
+                data->args->args[data->args->nargs] =
+                        rtas_call(ibm_suspend_me_token, 0, 1, NULL);
+                for_each_cpu(i)
+                        plpar_hcall_norets(H_PROD,i);
         } else {
                 data->waiting = -EBUSY;
                 printk(KERN_ERR "Error on H_Join hypervisor call\n");
         }
 
 out:
-        /* before we restore interrupts, make sure we don't
-         * generate a spurious soft lockup errors
-         */
-        touch_softlockup_watchdog();
         local_irq_restore(flags);
         return;
 }
diff --git a/arch/powerpc/kernel/rtas_flash.c b/arch/powerpc/kernel/rtas_flash.c
index 50500093c97f..aaf384c3f04a 100644
--- a/arch/powerpc/kernel/rtas_flash.c
+++ b/arch/powerpc/kernel/rtas_flash.c
@@ -672,8 +672,7 @@ static void rtas_flash_firmware(int reboot_type)
 static void remove_flash_pde(struct proc_dir_entry *dp)
 {
         if (dp) {
-                if (dp->data != NULL)
-                        kfree(dp->data);
+                kfree(dp->data);
                 dp->owner = NULL;
                 remove_proc_entry(dp->name, dp->parent);
         }
diff --git a/arch/powerpc/kernel/setup_64.c b/arch/powerpc/kernel/setup_64.c
index e29b275e09e0..a717dff695ef 100644
--- a/arch/powerpc/kernel/setup_64.c
+++ b/arch/powerpc/kernel/setup_64.c
@@ -398,6 +398,9 @@ void __init setup_system(void)
 {
         DBG(" -> setup_system()\n");
 
+#ifdef CONFIG_KEXEC
+        kdump_move_device_tree();
+#endif
         /*
          * Unflatten the device-tree passed by prom_init or kexec
          */
diff --git a/arch/powerpc/kernel/signal_32.c b/arch/powerpc/kernel/signal_32.c
index 177bba78fb0b..bd837b5dbf06 100644
--- a/arch/powerpc/kernel/signal_32.c
+++ b/arch/powerpc/kernel/signal_32.c
@@ -142,11 +142,7 @@ static inline int get_old_sigaction(struct k_sigaction *new_ka,
         return 0;
 }
 
-static inline compat_uptr_t to_user_ptr(void *kp)
-{
-        return (compat_uptr_t)(u64)kp;
-}
-
+#define to_user_ptr(p)          ptr_to_compat(p)
 #define from_user_ptr(p)        compat_ptr(p)
 
 static inline int save_general_regs(struct pt_regs *regs,
@@ -213,8 +209,8 @@ static inline int get_old_sigaction(struct k_sigaction *new_ka,
         return 0;
 }
 
-#define to_user_ptr(p)          (p)
-#define from_user_ptr(p)        (p)
+#define to_user_ptr(p)          ((unsigned long)(p))
+#define from_user_ptr(p)        ((void __user *)(p))
 
 static inline int save_general_regs(struct pt_regs *regs,
                 struct mcontext __user *frame)
@@ -252,67 +248,19 @@ int do_signal(sigset_t *oldset, struct pt_regs *regs);
 /*
  * Atomically swap in the new signal mask, and wait for a signal.
  */
-long sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,
-               struct pt_regs *regs)
+long sys_sigsuspend(old_sigset_t mask)
 {
-        sigset_t saveset;
-
         mask &= _BLOCKABLE;
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         siginitset(&current->blocked, mask);
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        regs->result = -EINTR;
-        regs->gpr[3] = EINTR;
-        regs->ccr |= 0x10000000;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(&saveset, regs)) {
-                        set_thread_flag(TIF_RESTOREALL);
-                        return 0;
-                }
-        }
-}
-
-long sys_rt_sigsuspend(
-#ifdef CONFIG_PPC64
-                compat_sigset_t __user *unewset,
-#else
-                sigset_t __user *unewset,
-#endif
-                size_t sigsetsize, int p3, int p4,
-                int p6, int p7, struct pt_regs *regs)
-{
-        sigset_t saveset, newset;
-
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(sigset_t))
-                return -EINVAL;
-
-        if (get_sigset_t(&newset, unewset))
-                return -EFAULT;
-        sigdelsetmask(&newset, ~_BLOCKABLE);
-
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        current->blocked = newset;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-
-        regs->result = -EINTR;
-        regs->gpr[3] = EINTR;
-        regs->ccr |= 0x10000000;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(&saveset, regs)) {
-                        set_thread_flag(TIF_RESTOREALL);
-                        return 0;
-                }
-        }
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        return -ERESTARTNOHAND;
 }
 
 #ifdef CONFIG_PPC32
@@ -574,7 +522,7 @@ long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
 
         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
         if (!ret && oact) {
-                ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
+                ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
                 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
         }
@@ -723,8 +671,8 @@ long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo
 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
                       int r6, int r7, int r8, struct pt_regs *regs)
 {
-        stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
-        stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
+        stack_32_t __user * newstack = compat_ptr(__new);
+        stack_32_t __user * oldstack = compat_ptr(__old);
         stack_t uss, uoss;
         int ret;
         mm_segment_t old_fs;
@@ -756,7 +704,7 @@ int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
         set_fs(old_fs);
         /* Copy the stack information to the user output buffer */
         if (!ret && oldstack  &&
-                (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
+                (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
                  __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
                  __put_user(uoss.ss_size, &oldstack->ss_size)))
                 return -EFAULT;
@@ -1174,7 +1122,7 @@ int do_signal(sigset_t *oldset, struct pt_regs *regs)
 {
         siginfo_t info;
         struct k_sigaction ka;
-        unsigned int frame, newsp;
+        unsigned int newsp;
         int signr, ret;
 
 #ifdef CONFIG_PPC32
@@ -1185,11 +1133,11 @@ int do_signal(sigset_t *oldset, struct pt_regs *regs)
         }
 #endif
 
-        if (!oldset)
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else if (!oldset)
                 oldset = &current->blocked;
 
-        newsp = frame = 0;
-
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 #ifdef CONFIG_PPC32
 no_signal:
@@ -1219,8 +1167,14 @@ no_signal:
                 }
         }
 
-        if (signr == 0)
+        if (signr == 0) {
+                /* No signal to deliver -- put the saved sigmask back */
+                if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
+                        sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+                }
                 return 0;               /* no signals delivered */
+        }
 
         if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
             && !on_sig_stack(regs->gpr[1]))
@@ -1253,6 +1207,10 @@ no_signal:
                         sigaddset(&current->blocked, signr);
                 recalc_sigpending();
                 spin_unlock_irq(&current->sighand->siglock);
+                /* A signal was successfully delivered; the saved sigmask is in
+                   its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
+                if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
         }
 
         return ret;
diff --git a/arch/powerpc/kernel/signal_64.c b/arch/powerpc/kernel/signal_64.c
index 7b9d999e2115..497a5d3df359 100644
--- a/arch/powerpc/kernel/signal_64.c
+++ b/arch/powerpc/kernel/signal_64.c
@@ -60,49 +60,13 @@ struct rt_sigframe {
         struct ucontext uc;
         unsigned long _unused[2];
         unsigned int tramp[TRAMP_SIZE];
-        struct siginfo *pinfo;
-        void *puc;
+        struct siginfo __user *pinfo;
+        void __user *puc;
         struct siginfo info;
         /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
         char abigap[288];
 } __attribute__ ((aligned (16)));
 
-
-/*
- * Atomically swap in the new signal mask, and wait for a signal.
- */
-long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize, int p3, int p4,
-                       int p6, int p7, struct pt_regs *regs)
-{
-        sigset_t saveset, newset;
-
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(sigset_t))
-                return -EINVAL;
-
-        if (copy_from_user(&newset, unewset, sizeof(newset)))
-                return -EFAULT;
-        sigdelsetmask(&newset, ~_BLOCKABLE);
-
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        current->blocked = newset;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-
-        regs->result = -EINTR;
-        regs->gpr[3] = EINTR;
-        regs->ccr |= 0x10000000;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (do_signal(&saveset, regs)) {
-                        set_thread_flag(TIF_RESTOREALL);
-                        return 0;
-                }
-        }
-}
-
 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, unsigned long r5,
                      unsigned long r6, unsigned long r7, unsigned long r8,
                      struct pt_regs *regs)
@@ -556,11 +520,15 @@ int do_signal(sigset_t *oldset, struct pt_regs *regs)
         if (test_thread_flag(TIF_32BIT))
                 return do_signal32(oldset, regs);
 
-        if (!oldset)
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else if (!oldset)
                 oldset = &current->blocked;
 
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
         if (signr > 0) {
+                int ret;
+
                 /* Whee!  Actually deliver the signal.  */
                 if (TRAP(regs) == 0x0C00)
                         syscall_restart(regs, &ka);
@@ -573,7 +541,14 @@ int do_signal(sigset_t *oldset, struct pt_regs *regs)
                 if (current->thread.dabr)
                         set_dabr(current->thread.dabr);
 
-                return handle_signal(signr, &ka, &info, oldset, regs);
+                ret = handle_signal(signr, &ka, &info, oldset, regs);
+
+                /* If a signal was successfully delivered, the saved sigmask is in
+                   its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
+                if (ret && test_thread_flag(TIF_RESTORE_SIGMASK))
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
+
+                return ret;
         }
 
         if (TRAP(regs) == 0x0C00) {     /* System Call! */
@@ -589,6 +564,11 @@ int do_signal(sigset_t *oldset, struct pt_regs *regs)
                         regs->result = 0;
                 }
         }
+        /* No signal to deliver -- put the saved sigmask back */
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 
         return 0;
 }
diff --git a/arch/powerpc/kernel/smp.c b/arch/powerpc/kernel/smp.c
index c8458c531b25..13595a64f013 100644
--- a/arch/powerpc/kernel/smp.c
+++ b/arch/powerpc/kernel/smp.c
@@ -540,6 +540,9 @@ int __devinit start_secondary(void *unused)
         if (smp_ops->take_timebase)
                 smp_ops->take_timebase();
 
+        if (system_state > SYSTEM_BOOTING)
+                per_cpu(last_jiffy, cpu) = get_tb();
+
         spin_lock(&call_lock);
         cpu_set(cpu, cpu_online_map);
         spin_unlock(&call_lock);
diff --git a/arch/powerpc/kernel/systbl.S b/arch/powerpc/kernel/systbl.S
index 68013179a503..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)
@@ -321,3 +319,6 @@ SYSCALL(inotify_add_watch)
 SYSCALL(inotify_rm_watch)
 SYSCALL(spu_run)
 SYSCALL(spu_create)
+COMPAT_SYS(pselect6)
+COMPAT_SYS(ppoll)
+SYSCALL(unshare)
diff --git a/arch/powerpc/kernel/time.c b/arch/powerpc/kernel/time.c
index c4a294d657b9..1886045a2fd8 100644
--- a/arch/powerpc/kernel/time.c
+++ b/arch/powerpc/kernel/time.c
@@ -612,10 +612,10 @@ void __init generic_calibrate_decr(void)
 
         ppc_tb_freq = DEFAULT_TB_FREQ;          /* hardcoded default */
         node_found = 0;
-        if (cpu != 0) {
+        if (cpu) {
                 fp = (unsigned int *)get_property(cpu, "timebase-frequency",
                                                   NULL);
-                if (fp != 0) {
+                if (fp) {
                         node_found = 1;
                         ppc_tb_freq = *fp;
                 }
@@ -626,10 +626,10 @@ void __init generic_calibrate_decr(void)
 
         ppc_proc_freq = DEFAULT_PROC_FREQ;
         node_found = 0;
-        if (cpu != 0) {
+        if (cpu) {
                 fp = (unsigned int *)get_property(cpu, "clock-frequency",
                                                   NULL);
-                if (fp != 0) {
+                if (fp) {
                         node_found = 1;
                         ppc_proc_freq = *fp;
                 }
diff --git a/arch/powerpc/kernel/udbg_16550.c b/arch/powerpc/kernel/udbg_16550.c
index 2da65a9c93f6..5d29dcca523c 100644
--- a/arch/powerpc/kernel/udbg_16550.c
+++ b/arch/powerpc/kernel/udbg_16550.c
@@ -144,7 +144,7 @@ unsigned int udbg_probe_uart_speed(void __iomem *comport, unsigned int clock)
 }
 
 #ifdef CONFIG_PPC_MAPLE
-void udbg_maple_real_putc(unsigned char c)
+void udbg_maple_real_putc(char c)
 {
         if (udbg_comport) {
                 while ((real_readb(&udbg_comport->lsr) & LSR_THRE) == 0)
diff --git a/arch/powerpc/mm/lmb.c b/arch/powerpc/mm/lmb.c
index 9584608fd768..bbe3eac918e8 100644
--- a/arch/powerpc/mm/lmb.c
+++ b/arch/powerpc/mm/lmb.c
@@ -197,6 +197,8 @@ long __init lmb_reserve(unsigned long base, unsigned long size)
 {
         struct lmb_region *_rgn = &(lmb.reserved);
 
+        BUG_ON(0 == size);
+
         return lmb_add_region(_rgn, base, size);
 }
 
@@ -227,6 +229,8 @@ unsigned long __init lmb_alloc_base(unsigned long size, unsigned long align,
         long i, j;
         unsigned long base = 0;
 
+        BUG_ON(0 == size);
+
 #ifdef CONFIG_PPC32
         /* On 32-bit, make sure we allocate lowmem */
         if (max_addr == LMB_ALLOC_ANYWHERE)
diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c
index 15aac0d78dfa..550517c2dd42 100644
--- a/arch/powerpc/mm/mem.c
+++ b/arch/powerpc/mm/mem.c
@@ -435,17 +435,12 @@ void clear_user_page(void *page, unsigned long vaddr, struct page *pg)
 {
         clear_page(page);
 
-        if (cpu_has_feature(CPU_FTR_COHERENT_ICACHE))
-                return;
         /*
          * We shouldnt have to do this, but some versions of glibc
          * require it (ld.so assumes zero filled pages are icache clean)
          * - Anton
          */
-
-        /* avoid an atomic op if possible */
-        if (test_bit(PG_arch_1, &pg->flags))
-                clear_bit(PG_arch_1, &pg->flags);
+        flush_dcache_page(pg);
 }
 EXPORT_SYMBOL(clear_user_page);
 
@@ -469,12 +464,7 @@ void copy_user_page(void *vto, void *vfrom, unsigned long vaddr,
                 return;
 #endif
 
-        if (cpu_has_feature(CPU_FTR_COHERENT_ICACHE))
-                return;
-
-        /* avoid an atomic op if possible */
-        if (test_bit(PG_arch_1, &pg->flags))
-                clear_bit(PG_arch_1, &pg->flags);
+        flush_dcache_page(pg);
 }
 
 void flush_icache_user_range(struct vm_area_struct *vma, struct page *page,
diff --git a/arch/powerpc/platforms/cell/Makefile b/arch/powerpc/platforms/cell/Makefile
index 16031b565be4..3b998a393e3f 100644
--- a/arch/powerpc/platforms/cell/Makefile
+++ b/arch/powerpc/platforms/cell/Makefile
@@ -2,7 +2,7 @@ obj-y			+= interrupt.o iommu.o setup.o spider-pic.o
 obj-y                   += pervasive.o
 
 obj-$(CONFIG_SMP)       += smp.o
-obj-$(CONFIG_SPU_FS)    += spufs/ spu-base.o
+obj-$(CONFIG_SPU_FS)    += spu-base.o spufs/
 
 spu-base-y              += spu_base.o spu_priv1.o
 
diff --git a/arch/powerpc/platforms/chrp/chrp.h b/arch/powerpc/platforms/chrp/chrp.h
index 3a2057fa314a..814f54742e0f 100644
--- a/arch/powerpc/platforms/chrp/chrp.h
+++ b/arch/powerpc/platforms/chrp/chrp.h
@@ -5,7 +5,6 @@
 extern void chrp_nvram_init(void);
 extern void chrp_get_rtc_time(struct rtc_time *);
 extern int chrp_set_rtc_time(struct rtc_time *);
-extern void chrp_calibrate_decr(void);
 extern long chrp_time_init(void);
 
 extern void chrp_find_bridges(void);
diff --git a/arch/powerpc/platforms/chrp/pci.c b/arch/powerpc/platforms/chrp/pci.c
index 00c52f27ef4f..8ef279ad36ad 100644
--- a/arch/powerpc/platforms/chrp/pci.c
+++ b/arch/powerpc/platforms/chrp/pci.c
@@ -204,9 +204,11 @@ static void __init setup_peg2(struct pci_controller *hose, struct device_node *d
         struct device_node *root = find_path_device("/");
         struct device_node *rtas;
 
+        of_node_get(root);
         rtas = of_find_node_by_name (root, "rtas");
         if (rtas) {
                 hose->ops = &rtas_pci_ops;
+                of_node_put(rtas);
         } else {
                 printk ("RTAS supporting Pegasos OF not found, please upgrade"
                         " your firmware\n");
diff --git a/arch/powerpc/platforms/chrp/setup.c b/arch/powerpc/platforms/chrp/setup.c
index 2dc87aa5962f..e1fadbf49150 100644
--- a/arch/powerpc/platforms/chrp/setup.c
+++ b/arch/powerpc/platforms/chrp/setup.c
@@ -506,7 +506,7 @@ void __init chrp_init(void)
         ppc_md.halt           = rtas_halt;
 
         ppc_md.time_init      = chrp_time_init;
-        ppc_md.calibrate_decr = chrp_calibrate_decr;
+        ppc_md.calibrate_decr = generic_calibrate_decr;
 
         /* this may get overridden with rtas routines later... */
         ppc_md.set_rtc_time   = chrp_set_rtc_time;
diff --git a/arch/powerpc/platforms/chrp/time.c b/arch/powerpc/platforms/chrp/time.c
index 36a0f97bb7b1..78df2e7ca88a 100644
--- a/arch/powerpc/platforms/chrp/time.c
+++ b/arch/powerpc/platforms/chrp/time.c
@@ -167,24 +167,3 @@ void chrp_get_rtc_time(struct rtc_time *tm)
         tm->tm_mon = mon;
         tm->tm_year = year;
 }
-
-
-void __init chrp_calibrate_decr(void)
-{
-        struct device_node *cpu;
-        unsigned int freq, *fp;
-
-        /*
-         * The cpu node should have a timebase-frequency property
-         * to tell us the rate at which the decrementer counts.
-         */
-        freq = 16666000;                /* hardcoded default */
-        cpu = find_type_devices("cpu");
-        if (cpu != 0) {
-                fp = (unsigned int *)
-                        get_property(cpu, "timebase-frequency", NULL);
-                if (fp != 0)
-                        freq = *fp;
-        }
-        ppc_tb_freq = freq;
-}
diff --git a/arch/powerpc/platforms/powermac/low_i2c.c b/arch/powerpc/platforms/powermac/low_i2c.c
index 535c802b369f..87eb6bb7f0e7 100644
--- a/arch/powerpc/platforms/powermac/low_i2c.c
+++ b/arch/powerpc/platforms/powermac/low_i2c.c
@@ -1052,8 +1052,7 @@ struct pmac_i2c_bus *pmac_i2c_adapter_to_bus(struct i2c_adapter *adapter)
 }
 EXPORT_SYMBOL_GPL(pmac_i2c_adapter_to_bus);
 
-extern int pmac_i2c_match_adapter(struct device_node *dev,
-                                  struct i2c_adapter *adapter)
+int pmac_i2c_match_adapter(struct device_node *dev, struct i2c_adapter *adapter)
 {
         struct pmac_i2c_bus *bus = pmac_i2c_find_bus(dev);
 
diff --git a/arch/powerpc/platforms/powermac/pci.c b/arch/powerpc/platforms/powermac/pci.c
index f671ed253901..de3f30e6b333 100644
--- a/arch/powerpc/platforms/powermac/pci.c
+++ b/arch/powerpc/platforms/powermac/pci.c
@@ -136,14 +136,14 @@ static void __init fixup_bus_range(struct device_node *bridge)
         |(((unsigned int)(off)) & 0xFCUL) \
         |1UL)
 
-static unsigned long macrisc_cfg_access(struct pci_controller* hose,
+static volatile void __iomem *macrisc_cfg_access(struct pci_controller* hose,
                                                u8 bus, u8 dev_fn, u8 offset)
 {
         unsigned int caddr;
 
         if (bus == hose->first_busno) {
                 if (dev_fn < (11 << 3))
-                        return 0;
+                        return NULL;
                 caddr = MACRISC_CFA0(dev_fn, offset);
         } else
                 caddr = MACRISC_CFA1(bus, dev_fn, offset);
@@ -154,14 +154,14 @@ static unsigned long macrisc_cfg_access(struct pci_controller* hose,
         } while (in_le32(hose->cfg_addr) != caddr);
 
         offset &= has_uninorth ? 0x07 : 0x03;
-        return ((unsigned long)hose->cfg_data) + offset;
+        return hose->cfg_data + offset;
 }
 
 static int macrisc_read_config(struct pci_bus *bus, unsigned int devfn,
                                       int offset, int len, u32 *val)
 {
         struct pci_controller *hose;
-        unsigned long addr;
+        volatile void __iomem *addr;
 
         hose = pci_bus_to_host(bus);
         if (hose == NULL)
@@ -177,13 +177,13 @@ static int macrisc_read_config(struct pci_bus *bus, unsigned int devfn,
          */
         switch (len) {
         case 1:
-                *val = in_8((u8 *)addr);
+                *val = in_8(addr);
                 break;
         case 2:
-                *val = in_le16((u16 *)addr);
+                *val = in_le16(addr);
                 break;
         default:
-                *val = in_le32((u32 *)addr);
+                *val = in_le32(addr);
                 break;
         }
         return PCIBIOS_SUCCESSFUL;
@@ -193,7 +193,7 @@ static int macrisc_write_config(struct pci_bus *bus, unsigned int devfn,
                                        int offset, int len, u32 val)
 {
         struct pci_controller *hose;
-        unsigned long addr;
+        volatile void __iomem *addr;
 
         hose = pci_bus_to_host(bus);
         if (hose == NULL)
@@ -209,16 +209,16 @@ static int macrisc_write_config(struct pci_bus *bus, unsigned int devfn,
          */
         switch (len) {
         case 1:
-                out_8((u8 *)addr, val);
-                (void) in_8((u8 *)addr);
+                out_8(addr, val);
+                (void) in_8(addr);
                 break;
         case 2:
-                out_le16((u16 *)addr, val);
-                (void) in_le16((u16 *)addr);
+                out_le16(addr, val);
+                (void) in_le16(addr);
                 break;
         default:
-                out_le32((u32 *)addr, val);
-                (void) in_le32((u32 *)addr);
+                out_le32(addr, val);
+                (void) in_le32(addr);
                 break;
         }
         return PCIBIOS_SUCCESSFUL;
@@ -348,25 +348,23 @@ static int u3_ht_skip_device(struct pci_controller *hose,
                 + (((unsigned int)bus) << 16) \
                 + 0x01000000UL)
 
-static unsigned long u3_ht_cfg_access(struct pci_controller* hose,
+static volatile void __iomem *u3_ht_cfg_access(struct pci_controller* hose,
                                              u8 bus, u8 devfn, u8 offset)
 {
         if (bus == hose->first_busno) {
                 /* For now, we don't self probe U3 HT bridge */
                 if (PCI_SLOT(devfn) == 0)
-                        return 0;
-                return ((unsigned long)hose->cfg_data) +
-                        U3_HT_CFA0(devfn, offset);
+                        return NULL;
+                return hose->cfg_data + U3_HT_CFA0(devfn, offset);
         } else
-                return ((unsigned long)hose->cfg_data) +
-                        U3_HT_CFA1(bus, devfn, offset);
+                return hose->cfg_data + U3_HT_CFA1(bus, devfn, offset);
 }
 
 static int u3_ht_read_config(struct pci_bus *bus, unsigned int devfn,
                                     int offset, int len, u32 *val)
 {
         struct pci_controller *hose;
-        unsigned long addr;
+        volatile void __iomem *addr;
 
         hose = pci_bus_to_host(bus);
         if (hose == NULL)
@@ -400,13 +398,13 @@ static int u3_ht_read_config(struct pci_bus *bus, unsigned int devfn,
          */
         switch (len) {
         case 1:
-                *val = in_8((u8 *)addr);
+                *val = in_8(addr);
                 break;
         case 2:
-                *val = in_le16((u16 *)addr);
+                *val = in_le16(addr);
                 break;
         default:
-                *val = in_le32((u32 *)addr);
+                *val = in_le32(addr);
                 break;
         }
         return PCIBIOS_SUCCESSFUL;
@@ -416,7 +414,7 @@ static int u3_ht_write_config(struct pci_bus *bus, unsigned int devfn,
                                      int offset, int len, u32 val)
 {
         struct pci_controller *hose;
-        unsigned long addr;
+        volatile void __iomem *addr;
 
         hose = pci_bus_to_host(bus);
         if (hose == NULL)
@@ -442,16 +440,16 @@ static int u3_ht_write_config(struct pci_bus *bus, unsigned int devfn,
          */
         switch (len) {
         case 1:
-                out_8((u8 *)addr, val);
-                (void) in_8((u8 *)addr);
+                out_8(addr, val);
+                (void) in_8(addr);
                 break;
         case 2:
-                out_le16((u16 *)addr, val);
-                (void) in_le16((u16 *)addr);
+                out_le16(addr, val);
+                (void) in_le16(addr);
                 break;
         default:
-                out_le32((u32 *)addr, val);
-                (void) in_le32((u32 *)addr);
+                out_le32((u32 __iomem *)addr, val);
+                (void) in_le32(addr);
                 break;
         }
         return PCIBIOS_SUCCESSFUL;
@@ -476,7 +474,7 @@ static struct pci_ops u3_ht_pci_ops =
          |(((unsigned int)(off)) & 0xfcU)       \
          |1UL)
 
-static unsigned long u4_pcie_cfg_access(struct pci_controller* hose,
+static volatile void __iomem *u4_pcie_cfg_access(struct pci_controller* hose,
                                         u8 bus, u8 dev_fn, int offset)
 {
         unsigned int caddr;
@@ -492,14 +490,14 @@ static unsigned long u4_pcie_cfg_access(struct pci_controller* hose,
         } while (in_le32(hose->cfg_addr) != caddr);
 
         offset &= 0x03;
-        return ((unsigned long)hose->cfg_data) + offset;
+        return hose->cfg_data + offset;
 }
 
 static int u4_pcie_read_config(struct pci_bus *bus, unsigned int devfn,
                                int offset, int len, u32 *val)
 {
         struct pci_controller *hose;
-        unsigned long addr;
+        volatile void __iomem *addr;
 
         hose = pci_bus_to_host(bus);
         if (hose == NULL)
@@ -515,13 +513,13 @@ static int u4_pcie_read_config(struct pci_bus *bus, unsigned int devfn,
          */
         switch (len) {
         case 1:
-                *val = in_8((u8 *)addr);
+                *val = in_8(addr);
                 break;
         case 2:
-                *val = in_le16((u16 *)addr);
+                *val = in_le16(addr);
                 break;
         default:
-                *val = in_le32((u32 *)addr);
+                *val = in_le32(addr);
                 break;
         }
         return PCIBIOS_SUCCESSFUL;
@@ -531,7 +529,7 @@ static int u4_pcie_write_config(struct pci_bus *bus, unsigned int devfn,
                                 int offset, int len, u32 val)
 {
         struct pci_controller *hose;
-        unsigned long addr;
+        volatile void __iomem *addr;
 
         hose = pci_bus_to_host(bus);
         if (hose == NULL)
@@ -547,16 +545,16 @@ static int u4_pcie_write_config(struct pci_bus *bus, unsigned int devfn,
          */
         switch (len) {
         case 1:
-                out_8((u8 *)addr, val);
-                (void) in_8((u8 *)addr);
+                out_8(addr, val);
+                (void) in_8(addr);
                 break;
         case 2:
-                out_le16((u16 *)addr, val);
-                (void) in_le16((u16 *)addr);
+                out_le16(addr, val);
+                (void) in_le16(addr);
                 break;
         default:
-                out_le32((u32 *)addr, val);
-                (void) in_le32((u32 *)addr);
+                out_le32(addr, val);
+                (void) in_le32(addr);
                 break;
         }
         return PCIBIOS_SUCCESSFUL;
@@ -773,8 +771,7 @@ static void __init setup_u3_ht(struct pci_controller* hose)
          * the reg address cell, we shall fix that by killing struct
          * reg_property and using some accessor functions instead
          */
-        hose->cfg_data = (volatile unsigned char *)ioremap(0xf2000000,
-                                                           0x02000000);
+        hose->cfg_data = ioremap(0xf2000000, 0x02000000);
 
         /*
          * /ht node doesn't expose a "ranges" property, so we "remove"
diff --git a/arch/powerpc/platforms/powermac/pfunc_core.c b/arch/powerpc/platforms/powermac/pfunc_core.c
index c32c623001dc..356a739e52b2 100644
--- a/arch/powerpc/platforms/powermac/pfunc_core.c
+++ b/arch/powerpc/platforms/powermac/pfunc_core.c
@@ -862,21 +862,28 @@ int pmf_register_irq_client(struct device_node *target,
                 spin_unlock_irqrestore(&pmf_lock, flags);
                 return -ENODEV;
         }
+        if (list_empty(&func->irq_clients))
+                func->dev->handlers->irq_enable(func);
         list_add(&client->link, &func->irq_clients);
+        client->func = func;
         spin_unlock_irqrestore(&pmf_lock, flags);
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(pmf_register_irq_client);
 
-void pmf_unregister_irq_client(struct device_node *np,
-                              const char *name,
-                              struct pmf_irq_client *client)
+void pmf_unregister_irq_client(struct pmf_irq_client *client)
 {
+        struct pmf_function *func = client->func;
         unsigned long flags;
 
+        BUG_ON(func == NULL);
+
         spin_lock_irqsave(&pmf_lock, flags);
+        client->func = NULL;
         list_del(&client->link);
+        if (list_empty(&func->irq_clients))
+                func->dev->handlers->irq_disable(func);
         spin_unlock_irqrestore(&pmf_lock, flags);
 }
 EXPORT_SYMBOL_GPL(pmf_unregister_irq_client);
diff --git a/arch/powerpc/platforms/powermac/setup.c b/arch/powerpc/platforms/powermac/setup.c
index 89c4c3636161..1955462f4082 100644
--- a/arch/powerpc/platforms/powermac/setup.c
+++ b/arch/powerpc/platforms/powermac/setup.c
@@ -82,8 +82,6 @@
 
 #undef SHOW_GATWICK_IRQS
 
-unsigned char drive_info;
-
 int ppc_override_l2cr = 0;
 int ppc_override_l2cr_value;
 int has_l2cache = 0;
diff --git a/arch/powerpc/platforms/pseries/eeh_driver.c b/arch/powerpc/platforms/pseries/eeh_driver.c
index 6373372932ba..e3cbba49fd6e 100644
--- a/arch/powerpc/platforms/pseries/eeh_driver.c
+++ b/arch/powerpc/platforms/pseries/eeh_driver.c
@@ -333,7 +333,7 @@ void handle_eeh_events (struct eeh_event *event)
                 rc = eeh_reset_device(frozen_pdn, NULL);
                 if (rc)
                         goto hard_fail;
-                pci_walk_bus(frozen_bus, eeh_report_reset, 0);
+                pci_walk_bus(frozen_bus, eeh_report_reset, NULL);
         }
 
         /* If all devices reported they can proceed, the re-enable PIO */
@@ -342,11 +342,11 @@ void handle_eeh_events (struct eeh_event *event)
                 rc = eeh_reset_device(frozen_pdn, NULL);
                 if (rc)
                         goto hard_fail;
-                pci_walk_bus(frozen_bus, eeh_report_reset, 0);
+                pci_walk_bus(frozen_bus, eeh_report_reset, NULL);
         }
 
         /* Tell all device drivers that they can resume operations */
-        pci_walk_bus(frozen_bus, eeh_report_resume, 0);
+        pci_walk_bus(frozen_bus, eeh_report_resume, NULL);
 
         return;
         
@@ -367,7 +367,7 @@ hard_fail:
         eeh_slot_error_detail(frozen_pdn, 2 /* Permanent Error */);
 
         /* Notify all devices that they're about to go down. */
-        pci_walk_bus(frozen_bus, eeh_report_failure, 0);
+        pci_walk_bus(frozen_bus, eeh_report_failure, NULL);
 
         /* Shut down the device drivers for good. */
         pcibios_remove_pci_devices(frozen_bus);
diff --git a/arch/powerpc/platforms/pseries/pci_dlpar.c b/arch/powerpc/platforms/pseries/pci_dlpar.c
index 21934784f936..bdaa8aabdaa6 100644
--- a/arch/powerpc/platforms/pseries/pci_dlpar.c
+++ b/arch/powerpc/platforms/pseries/pci_dlpar.c
@@ -58,6 +58,7 @@ pcibios_find_pci_bus(struct device_node *dn)
 
         return find_bus_among_children(pdn->phb->bus, dn);
 }
+EXPORT_SYMBOL_GPL(pcibios_find_pci_bus);
 
 /**
  * pcibios_remove_pci_devices - remove all devices under this bus
@@ -106,6 +107,7 @@ pcibios_fixup_new_pci_devices(struct pci_bus *bus, int fix_bus)
                 }
         }
 }
+EXPORT_SYMBOL_GPL(pcibios_fixup_new_pci_devices);
 
 static int
 pcibios_pci_config_bridge(struct pci_dev *dev)
@@ -172,3 +174,4 @@ pcibios_add_pci_devices(struct pci_bus * bus)
                         pcibios_pci_config_bridge(dev);
         }
 }
+EXPORT_SYMBOL_GPL(pcibios_add_pci_devices);
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index da6cebaf72cd..9edeca83f434 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -585,7 +585,7 @@ static int pSeries_pci_probe_mode(struct pci_bus *bus)
 static void pseries_kexec_cpu_down(int crash_shutdown, int secondary)
 {
         /* Don't risk a hypervisor call if we're crashing */
-        if (!crash_shutdown) {
+        if (firmware_has_feature(FW_FEATURE_SPLPAR) && !crash_shutdown) {
                 unsigned long vpa = __pa(get_lppaca());
 
                 if (unregister_vpa(hard_smp_processor_id(), vpa)) {
diff --git a/arch/powerpc/sysdev/dart_iommu.c b/arch/powerpc/sysdev/dart_iommu.c
index 977de9db8754..6298264efe36 100644
--- a/arch/powerpc/sysdev/dart_iommu.c
+++ b/arch/powerpc/sysdev/dart_iommu.c
@@ -59,7 +59,7 @@ static unsigned long dart_tablesize;
 static u32 *dart_vbase;
 
 /* Mapped base address for the dart */
-static unsigned int *__iomem dart;
+static unsigned int __iomem *dart;
 
 /* Dummy val that entries are set to when unused */
 static unsigned int dart_emptyval;
diff --git a/arch/ppc/configs/bamboo_defconfig b/arch/ppc/configs/bamboo_defconfig
index 0ba4e70d50b6..41fd3938fa5c 100644
--- a/arch/ppc/configs/bamboo_defconfig
+++ b/arch/ppc/configs/bamboo_defconfig
@@ -499,6 +499,7 @@ CONFIG_NATSEMI=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/ppc/configs/katana_defconfig b/arch/ppc/configs/katana_defconfig
index 0f3bb9af9c22..7311fe6b42de 100644
--- a/arch/ppc/configs/katana_defconfig
+++ b/arch/ppc/configs/katana_defconfig
@@ -488,6 +488,7 @@ CONFIG_E100=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/ppc/configs/mpc834x_sys_defconfig b/arch/ppc/configs/mpc834x_sys_defconfig
index 673dc64ebcb1..b96a6d6dad0e 100644
--- a/arch/ppc/configs/mpc834x_sys_defconfig
+++ b/arch/ppc/configs/mpc834x_sys_defconfig
@@ -402,6 +402,7 @@ CONFIG_E100=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/ppc/configs/power3_defconfig b/arch/ppc/configs/power3_defconfig
index 93da595a4738..a1ef929bca59 100644
--- a/arch/ppc/configs/power3_defconfig
+++ b/arch/ppc/configs/power3_defconfig
@@ -442,6 +442,7 @@ CONFIG_E100=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
diff --git a/arch/ppc/kernel/head_8xx.S b/arch/ppc/kernel/head_8xx.S
index 3e6ca7f5843f..c1e89ad0684d 100644
--- a/arch/ppc/kernel/head_8xx.S
+++ b/arch/ppc/kernel/head_8xx.S
@@ -810,13 +810,16 @@ initial_mmu:
         mtspr   SPRN_MD_TWC, r9
         li      r11, MI_BOOTINIT        /* Create RPN for address 0 */
         addis   r11, r11, 0x0080        /* Add 8M */
-        mtspr   SPRN_MD_RPN, r8
+        mtspr   SPRN_MD_RPN, r11
+
+        addi    r10, r10, 0x0100
+        mtspr   SPRN_MD_CTR, r10
 
         addis   r8, r8, 0x0080          /* Add 8M */
         mtspr   SPRN_MD_EPN, r8
         mtspr   SPRN_MD_TWC, r9
         addis   r11, r11, 0x0080        /* Add 8M */
-        mtspr   SPRN_MD_RPN, r8
+        mtspr   SPRN_MD_RPN, r11
 #endif
 
         /* Since the cache is enabled according to the information we
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/ppc/kernel/ppc_ksyms.c b/arch/ppc/kernel/ppc_ksyms.c
index 3a6e4bcb3c53..15bd9b448a48 100644
--- a/arch/ppc/kernel/ppc_ksyms.c
+++ b/arch/ppc/kernel/ppc_ksyms.c
@@ -186,11 +186,15 @@ EXPORT_SYMBOL(flush_tlb_kernel_range);
 EXPORT_SYMBOL(flush_tlb_page);
 EXPORT_SYMBOL(_tlbie);
 #ifdef CONFIG_ALTIVEC
+#ifndef CONFIG_SMP
 EXPORT_SYMBOL(last_task_used_altivec);
+#endif
 EXPORT_SYMBOL(giveup_altivec);
 #endif /* CONFIG_ALTIVEC */
 #ifdef CONFIG_SPE
+#ifndef CONFIG_SMP
 EXPORT_SYMBOL(last_task_used_spe);
+#endif
 EXPORT_SYMBOL(giveup_spe);
 #endif /* CONFIG_SPE */
 #ifdef CONFIG_SMP
diff --git a/arch/ppc/platforms/4xx/bamboo.c b/arch/ppc/platforms/4xx/bamboo.c
index 159b228eca1e..0ec53f049338 100644
--- a/arch/ppc/platforms/4xx/bamboo.c
+++ b/arch/ppc/platforms/4xx/bamboo.c
@@ -332,8 +332,8 @@ bamboo_early_serial_map(void)
         port.irq = 0;
         port.uartclk = clocks.uart0;
         port.regshift = 0;
-        port.iotype = SERIAL_IO_MEM;
-        port.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+        port.iotype = UPIO_MEM;
+        port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
         port.line = 0;
 
         if (early_serial_setup(&port) != 0) {
diff --git a/arch/ppc/platforms/4xx/bubinga.c b/arch/ppc/platforms/4xx/bubinga.c
index 8110f55668c5..ce48a4f08cbb 100644
--- a/arch/ppc/platforms/4xx/bubinga.c
+++ b/arch/ppc/platforms/4xx/bubinga.c
@@ -97,8 +97,8 @@ bubinga_early_serial_map(void)
         port.irq = ACTING_UART0_INT;
         port.uartclk = uart_clock;
         port.regshift = 0;
-        port.iotype = SERIAL_IO_MEM;
-        port.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+        port.iotype = UPIO_MEM;
+        port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
         port.line = 0;
 
         if (early_serial_setup(&port) != 0) {
diff --git a/arch/ppc/platforms/4xx/ebony.c b/arch/ppc/platforms/4xx/ebony.c
index 64ebae19cdbb..9a828b623417 100644
--- a/arch/ppc/platforms/4xx/ebony.c
+++ b/arch/ppc/platforms/4xx/ebony.c
@@ -225,8 +225,8 @@ ebony_early_serial_map(void)
         port.irq = 0;
         port.uartclk = clocks.uart0;
         port.regshift = 0;
-        port.iotype = SERIAL_IO_MEM;
-        port.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+        port.iotype = UPIO_MEM;
+        port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
         port.line = 0;
 
         if (early_serial_setup(&port) != 0) {
diff --git a/arch/ppc/platforms/4xx/luan.c b/arch/ppc/platforms/4xx/luan.c
index d810b736d9bf..21d29132aebd 100644
--- a/arch/ppc/platforms/4xx/luan.c
+++ b/arch/ppc/platforms/4xx/luan.c
@@ -279,8 +279,8 @@ luan_early_serial_map(void)
         port.irq = UART0_INT;
         port.uartclk = clocks.uart0;
         port.regshift = 0;
-        port.iotype = SERIAL_IO_MEM;
-        port.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+        port.iotype = UPIO_MEM;
+        port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
         port.line = 0;
 
         if (early_serial_setup(&port) != 0) {
diff --git a/arch/ppc/platforms/4xx/ocotea.c b/arch/ppc/platforms/4xx/ocotea.c
index 73b2c98158f6..4f355b6acab2 100644
--- a/arch/ppc/platforms/4xx/ocotea.c
+++ b/arch/ppc/platforms/4xx/ocotea.c
@@ -248,8 +248,8 @@ ocotea_early_serial_map(void)
         port.irq = UART0_INT;
         port.uartclk = clocks.uart0;
         port.regshift = 0;
-        port.iotype = SERIAL_IO_MEM;
-        port.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+        port.iotype = UPIO_MEM;
+        port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
         port.line = 0;
 
         if (early_serial_setup(&port) != 0) {
diff --git a/arch/ppc/platforms/4xx/xilinx_ml300.c b/arch/ppc/platforms/4xx/xilinx_ml300.c
index 0b1b77d986bf..e90d97f64f76 100644
--- a/arch/ppc/platforms/4xx/xilinx_ml300.c
+++ b/arch/ppc/platforms/4xx/xilinx_ml300.c
@@ -95,8 +95,8 @@ ml300_early_serial_map(void)
                 port.irq = old_ports[i].irq;
                 port.uartclk = old_ports[i].baud_base * 16;
                 port.regshift = old_ports[i].iomem_reg_shift;
-                port.iotype = SERIAL_IO_MEM;
-                port.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+                port.iotype = UPIO_MEM;
+                port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
                 port.line = i;
 
                 if (early_serial_setup(&port) != 0) {
diff --git a/arch/ppc/platforms/4xx/yucca.c b/arch/ppc/platforms/4xx/yucca.c
index e60f4bd437ec..b065b8babcd3 100644
--- a/arch/ppc/platforms/4xx/yucca.c
+++ b/arch/ppc/platforms/4xx/yucca.c
@@ -305,8 +305,8 @@ yucca_early_serial_map(void)
         port.irq = UART0_INT;
         port.uartclk = clocks.uart0;
         port.regshift = 0;
-        port.iotype = SERIAL_IO_MEM;
-        port.flags = ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST;
+        port.iotype = UPIO_MEM;
+        port.flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST;
         port.line = 0;
 
         if (early_serial_setup(&port) != 0) {
diff --git a/arch/ppc/platforms/83xx/mpc834x_sys.c b/arch/ppc/platforms/83xx/mpc834x_sys.c
index 012e1e652c03..1a659bbc1860 100644
--- a/arch/ppc/platforms/83xx/mpc834x_sys.c
+++ b/arch/ppc/platforms/83xx/mpc834x_sys.c
@@ -301,14 +301,14 @@ platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
                 struct uart_port p;
 
                 memset(&p, 0, sizeof (p));
-                p.iotype = SERIAL_IO_MEM;
+                p.iotype = UPIO_MEM;
                 p.membase = (unsigned char __iomem *)(VIRT_IMMRBAR + 0x4500);
                 p.uartclk = binfo->bi_busfreq;
 
                 gen550_init(0, &p);
 
                 memset(&p, 0, sizeof (p));
-                p.iotype = SERIAL_IO_MEM;
+                p.iotype = UPIO_MEM;
                 p.membase = (unsigned char __iomem *)(VIRT_IMMRBAR + 0x4600);
                 p.uartclk = binfo->bi_busfreq;
 
diff --git a/arch/ppc/platforms/85xx/mpc8540_ads.c b/arch/ppc/platforms/85xx/mpc8540_ads.c
index 2eceb1e6f4eb..408d64f18e1a 100644
--- a/arch/ppc/platforms/85xx/mpc8540_ads.c
+++ b/arch/ppc/platforms/85xx/mpc8540_ads.c
@@ -162,14 +162,14 @@ platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
                           binfo->bi_immr_base, MPC85xx_CCSRBAR_SIZE, _PAGE_IO, 0);
 
                 memset(&p, 0, sizeof (p));
-                p.iotype = SERIAL_IO_MEM;
+                p.iotype = UPIO_MEM;
                 p.membase = (void *) binfo->bi_immr_base + MPC85xx_UART0_OFFSET;
                 p.uartclk = binfo->bi_busfreq;
 
                 gen550_init(0, &p);
 
                 memset(&p, 0, sizeof (p));
-                p.iotype = SERIAL_IO_MEM;
+                p.iotype = UPIO_MEM;
                 p.membase = (void *) binfo->bi_immr_base + MPC85xx_UART1_OFFSET;
                 p.uartclk = binfo->bi_busfreq;
 
diff --git a/arch/ppc/platforms/85xx/mpc85xx_cds_common.c b/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
index b332ebae6bd3..1801ab392e22 100644
--- a/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
+++ b/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
@@ -534,14 +534,14 @@ platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
                                 binfo->bi_immr_base, MPC85xx_CCSRBAR_SIZE, _PAGE_IO, 0);
 
                 memset(&p, 0, sizeof (p));
-                p.iotype = SERIAL_IO_MEM;
+                p.iotype = UPIO_MEM;
                 p.membase = (void *) binfo->bi_immr_base + MPC85xx_UART0_OFFSET;
                 p.uartclk = binfo->bi_busfreq;
 
                 gen550_init(0, &p);
 
                 memset(&p, 0, sizeof (p));
-                p.iotype = SERIAL_IO_MEM;
+                p.iotype = UPIO_MEM;
                 p.membase = (void *) binfo->bi_immr_base + MPC85xx_UART1_OFFSET;
                 p.uartclk = binfo->bi_busfreq;
 
diff --git a/arch/ppc/platforms/85xx/sbc8560.c b/arch/ppc/platforms/85xx/sbc8560.c
index e777ba824aa9..8a72221f816c 100644
--- a/arch/ppc/platforms/85xx/sbc8560.c
+++ b/arch/ppc/platforms/85xx/sbc8560.c
@@ -64,7 +64,7 @@ sbc8560_early_serial_map(void)
         uart_req.irq = MPC85xx_IRQ_EXT9;
         uart_req.flags = STD_COM_FLAGS;
         uart_req.uartclk = BASE_BAUD * 16;
-        uart_req.iotype = SERIAL_IO_MEM;
+        uart_req.iotype = UPIO_MEM;
         uart_req.mapbase = UARTA_ADDR;
         uart_req.membase = ioremap(uart_req.mapbase, MPC85xx_UART0_SIZE);
         uart_req.type = PORT_16650;
diff --git a/arch/ppc/platforms/85xx/tqm85xx.c b/arch/ppc/platforms/85xx/tqm85xx.c
index b436f4d0a3fa..a5e38ba62732 100644
--- a/arch/ppc/platforms/85xx/tqm85xx.c
+++ b/arch/ppc/platforms/85xx/tqm85xx.c
@@ -346,14 +346,14 @@ platform_init(unsigned long r3, unsigned long r4, unsigned long r5,
                           binfo->bi_immr_base, MPC85xx_CCSRBAR_SIZE, _PAGE_IO, 0);
 
                 memset(&p, 0, sizeof (p));
-                p.iotype = SERIAL_IO_MEM;
+                p.iotype = UPIO_MEM;
                 p.membase = (void *) binfo->bi_immr_base + MPC85xx_UART0_OFFSET;
                 p.uartclk = binfo->bi_busfreq;
 
                 gen550_init(0, &p);
 
                 memset(&p, 0, sizeof (p));
-                p.iotype = SERIAL_IO_MEM;
+                p.iotype = UPIO_MEM;
                 p.membase = (void *) binfo->bi_immr_base + MPC85xx_UART1_OFFSET;
                 p.uartclk = binfo->bi_busfreq;
 
diff --git a/arch/ppc/platforms/chestnut.c b/arch/ppc/platforms/chestnut.c
index 48a4a510d598..aefcc0e7be57 100644
--- a/arch/ppc/platforms/chestnut.c
+++ b/arch/ppc/platforms/chestnut.c
@@ -116,7 +116,7 @@ chestnut_early_serial_map(void)
         port.uartclk = BASE_BAUD * 16;
         port.irq = UART0_INT;
         port.flags = STD_COM_FLAGS | UPF_IOREMAP;
-        port.iotype = SERIAL_IO_MEM;
+        port.iotype = UPIO_MEM;
         port.mapbase = CHESTNUT_UART0_IO_BASE;
         port.regshift = 0;
 
diff --git a/arch/ppc/platforms/ev64260.c b/arch/ppc/platforms/ev64260.c
index 32358b3fb236..ffde8f6f6302 100644
--- a/arch/ppc/platforms/ev64260.c
+++ b/arch/ppc/platforms/ev64260.c
@@ -330,7 +330,7 @@ ev64260_early_serial_map(void)
                 port.irq = EV64260_UART_0_IRQ;
                 port.uartclk = BASE_BAUD * 16;
                 port.regshift = 2;
-                port.iotype = SERIAL_IO_MEM;
+                port.iotype = UPIO_MEM;
                 port.flags = STD_COM_FLAGS;
 
 #if defined(CONFIG_SERIAL_TEXT_DEBUG) || defined(CONFIG_KGDB)
diff --git a/arch/ppc/platforms/radstone_ppc7d.c b/arch/ppc/platforms/radstone_ppc7d.c
index 708b8739ecdd..872c0a3ba3c7 100644
--- a/arch/ppc/platforms/radstone_ppc7d.c
+++ b/arch/ppc/platforms/radstone_ppc7d.c
@@ -100,7 +100,7 @@ static void __init ppc7d_early_serial_map(void)
         serial_req.uartclk = UART_CLK;
         serial_req.irq = 4;
         serial_req.flags = STD_COM_FLAGS;
-        serial_req.iotype = SERIAL_IO_MEM;
+        serial_req.iotype = UPIO_MEM;
         serial_req.membase = (u_char *) PPC7D_SERIAL_0;
 
         gen550_init(0, &serial_req);
diff --git a/arch/ppc/platforms/spruce.c b/arch/ppc/platforms/spruce.c
index 5ad70d357cb9..69e1de7971f2 100644
--- a/arch/ppc/platforms/spruce.c
+++ b/arch/ppc/platforms/spruce.c
@@ -176,8 +176,8 @@ spruce_early_serial_map(void)
         memset(&serial_req, 0, sizeof(serial_req));
         serial_req.uartclk = uart_clk;
         serial_req.irq = UART0_INT;
-        serial_req.flags = ASYNC_BOOT_AUTOCONF;
-        serial_req.iotype = SERIAL_IO_MEM;
+        serial_req.flags = UPF_BOOT_AUTOCONF;
+        serial_req.iotype = UPIO_MEM;
         serial_req.membase = (u_char *)UART0_IO_BASE;
         serial_req.regshift = 0;
 
diff --git a/arch/ppc/syslib/mv64x60.c b/arch/ppc/syslib/mv64x60.c
index 94ea346b7b4b..1f01b7e2376b 100644
--- a/arch/ppc/syslib/mv64x60.c
+++ b/arch/ppc/syslib/mv64x60.c
@@ -313,7 +313,7 @@ static struct platform_device mpsc1_device = {
 };
 #endif
 
-#ifdef CONFIG_MV643XX_ETH
+#if defined(CONFIG_MV643XX_ETH) || defined(CONFIG_MV643XX_ETH_MODULE)
 static struct resource mv64x60_eth_shared_resources[] = {
         [0] = {
                 .name   = "ethernet shared base",
@@ -456,7 +456,7 @@ static struct platform_device *mv64x60_pd_devs[] __initdata = {
         &mpsc0_device,
         &mpsc1_device,
 #endif
-#ifdef CONFIG_MV643XX_ETH
+#if defined(CONFIG_MV643XX_ETH) || defined(CONFIG_MV643XX_ETH_MODULE)
         &mv64x60_eth_shared_device,
 #endif
 #ifdef CONFIG_MV643XX_ETH_0
diff --git a/arch/ppc/syslib/ocp.c b/arch/ppc/syslib/ocp.c
index ab34b1d6072f..2fe28ded2c60 100644
--- a/arch/ppc/syslib/ocp.c
+++ b/arch/ppc/syslib/ocp.c
@@ -189,8 +189,8 @@ ocp_device_resume(struct device *dev)
 struct bus_type ocp_bus_type = {
         .name = "ocp",
         .match = ocp_device_match,
-        .probe = ocp_driver_probe,
-        .remove = ocp_driver_remove,
+        .probe = ocp_device_probe,
+        .remove = ocp_device_remove,
         .suspend = ocp_device_suspend,
         .resume = ocp_device_resume,
 };
diff --git a/arch/ppc/syslib/ppc83xx_setup.c b/arch/ppc/syslib/ppc83xx_setup.c
index 1b5fe9e398d4..7bada82527a8 100644
--- a/arch/ppc/syslib/ppc83xx_setup.c
+++ b/arch/ppc/syslib/ppc83xx_setup.c
@@ -108,7 +108,7 @@ mpc83xx_early_serial_map(void)
 
 #if defined(CONFIG_SERIAL_TEXT_DEBUG) || defined(CONFIG_KGDB)
         memset(&serial_req, 0, sizeof (serial_req));
-        serial_req.iotype = SERIAL_IO_MEM;
+        serial_req.iotype = UPIO_MEM;
         serial_req.mapbase = pdata[0].mapbase;
         serial_req.membase = pdata[0].membase;
         serial_req.regshift = 0;
diff --git a/arch/ppc/syslib/ppc85xx_setup.c b/arch/ppc/syslib/ppc85xx_setup.c
index 1a47ff4b831d..e4dda43fdaa7 100644
--- a/arch/ppc/syslib/ppc85xx_setup.c
+++ b/arch/ppc/syslib/ppc85xx_setup.c
@@ -90,7 +90,7 @@ mpc85xx_early_serial_map(void)
 
 #if defined(CONFIG_SERIAL_TEXT_DEBUG) || defined(CONFIG_KGDB)
         memset(&serial_req, 0, sizeof (serial_req));
-        serial_req.iotype = SERIAL_IO_MEM;
+        serial_req.iotype = UPIO_MEM;
         serial_req.mapbase = pdata[0].mapbase;
         serial_req.membase = pdata[0].membase;
         serial_req.regshift = 0;
diff --git a/arch/s390/defconfig b/arch/s390/defconfig
index 7d23edc6facb..f8d0cd540a06 100644
--- a/arch/s390/defconfig
+++ b/arch/s390/defconfig
@@ -1,19 +1,17 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.15-rc2
-# Mon Nov 21 13:51:30 2005
+# Linux kernel version: 2.6.16-rc2
+# Wed Feb  8 10:44:39 2006
 #
 CONFIG_MMU=y
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
 CONFIG_S390=y
-CONFIG_UID16=y
 
 #
 # Code maturity level options
 #
 CONFIG_EXPERIMENTAL=y
-CONFIG_CLEAN_COMPILE=y
 CONFIG_LOCK_KERNEL=y
 CONFIG_INIT_ENV_ARG_LIMIT=32
 
@@ -29,18 +27,20 @@ CONFIG_POSIX_MQUEUE=y
 CONFIG_SYSCTL=y
 CONFIG_AUDIT=y
 # CONFIG_AUDITSYSCALL is not set
-CONFIG_HOTPLUG=y
-CONFIG_KOBJECT_UEVENT=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 # CONFIG_CPUSETS is not set
 CONFIG_INITRAMFS_SOURCE=""
+CONFIG_UID16=y
+# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
+CONFIG_ELF_CORE=y
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
@@ -49,8 +49,10 @@ CONFIG_CC_ALIGN_FUNCTIONS=0
 CONFIG_CC_ALIGN_LABELS=0
 CONFIG_CC_ALIGN_LOOPS=0
 CONFIG_CC_ALIGN_JUMPS=0
+CONFIG_SLAB=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
 
 #
 # Loadable module support
@@ -76,11 +78,11 @@ CONFIG_IOSCHED_NOOP=y
 CONFIG_IOSCHED_AS=y
 CONFIG_IOSCHED_DEADLINE=y
 CONFIG_IOSCHED_CFQ=y
-CONFIG_DEFAULT_AS=y
-# CONFIG_DEFAULT_DEADLINE is not set
+# CONFIG_DEFAULT_AS is not set
+CONFIG_DEFAULT_DEADLINE=y
 # CONFIG_DEFAULT_CFQ is not set
 # CONFIG_DEFAULT_NOOP is not set
-CONFIG_DEFAULT_IOSCHED="anticipatory"
+CONFIG_DEFAULT_IOSCHED="deadline"
 
 #
 # Base setup
@@ -151,6 +153,7 @@ CONFIG_NET=y
 #
 # Networking options
 #
+# CONFIG_NETDEBUG is not set
 CONFIG_PACKET=y
 # CONFIG_PACKET_MMAP is not set
 CONFIG_UNIX=y
@@ -193,6 +196,11 @@ CONFIG_IPV6=y
 # SCTP Configuration (EXPERIMENTAL)
 #
 # CONFIG_IP_SCTP is not set
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
 # CONFIG_ATM is not set
 # CONFIG_BRIDGE is not set
 # CONFIG_VLAN_8021Q is not set
@@ -362,6 +370,7 @@ CONFIG_DM_MULTIPATH=y
 #
 CONFIG_UNIX98_PTYS=y
 CONFIG_UNIX98_PTY_COUNT=2048
+# CONFIG_HANGCHECK_TIMER is not set
 
 #
 # Watchdog Cards
@@ -488,6 +497,7 @@ CONFIG_FS_MBCACHE=y
 # CONFIG_JFS_FS is not set
 # CONFIG_FS_POSIX_ACL is not set
 # CONFIG_XFS_FS is not set
+# CONFIG_OCFS2_FS is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
 CONFIG_INOTIFY=y
@@ -520,6 +530,7 @@ CONFIG_TMPFS=y
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
 # CONFIG_RELAYFS_FS is not set
+# CONFIG_CONFIGFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -584,6 +595,7 @@ CONFIG_MSDOS_PARTITION=y
 # CONFIG_SGI_PARTITION is not set
 # CONFIG_ULTRIX_PARTITION is not set
 # CONFIG_SUN_PARTITION is not set
+# CONFIG_KARMA_PARTITION is not set
 # CONFIG_EFI_PARTITION is not set
 
 #
@@ -592,27 +604,30 @@ CONFIG_MSDOS_PARTITION=y
 # CONFIG_NLS is not set
 
 #
-# Profiling support
+# Instrumentation Support
 #
 # CONFIG_PROFILING is not set
+# CONFIG_STATISTICS is not set
 
 #
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
-CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
+CONFIG_DEBUG_KERNEL=y
 CONFIG_LOG_BUF_SHIFT=17
-CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_DETECT_SOFTLOCKUP is not set
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
-CONFIG_DEBUG_PREEMPT=y
+# CONFIG_DEBUG_PREEMPT is not set
+CONFIG_DEBUG_MUTEXES=y
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_KOBJECT is not set
 # CONFIG_DEBUG_INFO is not set
 CONFIG_DEBUG_FS=y
 # CONFIG_DEBUG_VM is not set
+CONFIG_FORCED_INLINING=y
 # CONFIG_RCU_TORTURE_TEST is not set
 
 #
diff --git a/arch/s390/kernel/compat_linux.c b/arch/s390/kernel/compat_linux.c
index bf9a7a361b34..2d021626c1a6 100644
--- a/arch/s390/kernel/compat_linux.c
+++ b/arch/s390/kernel/compat_linux.c
@@ -100,12 +100,12 @@
 #define SET_STAT_UID(stat, uid)         (stat).st_uid = high2lowuid(uid)
 #define SET_STAT_GID(stat, gid)         (stat).st_gid = high2lowgid(gid)
 
-asmlinkage long sys32_chown16(const char * filename, u16 user, u16 group)
+asmlinkage long sys32_chown16(const char __user * filename, u16 user, u16 group)
 {
         return sys_chown(filename, low2highuid(user), low2highgid(group));
 }
 
-asmlinkage long sys32_lchown16(const char * filename, u16 user, u16 group)
+asmlinkage long sys32_lchown16(const char __user * filename, u16 user, u16 group)
 {
         return sys_lchown(filename, low2highuid(user), low2highgid(group));
 }
@@ -141,7 +141,7 @@ asmlinkage long sys32_setresuid16(u16 ruid, u16 euid, u16 suid)
                 low2highuid(suid));
 }
 
-asmlinkage long sys32_getresuid16(u16 *ruid, u16 *euid, u16 *suid)
+asmlinkage long sys32_getresuid16(u16 __user *ruid, u16 __user *euid, u16 __user *suid)
 {
         int retval;
 
@@ -158,7 +158,7 @@ asmlinkage long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid)
                 low2highgid(sgid));
 }
 
-asmlinkage long sys32_getresgid16(u16 *rgid, u16 *egid, u16 *sgid)
+asmlinkage long sys32_getresgid16(u16 __user *rgid, u16 __user *egid, u16 __user *sgid)
 {
         int retval;
 
@@ -179,7 +179,7 @@ asmlinkage long sys32_setfsgid16(u16 gid)
         return sys_setfsgid((gid_t)gid);
 }
 
-static int groups16_to_user(u16 *grouplist, struct group_info *group_info)
+static int groups16_to_user(u16 __user *grouplist, struct group_info *group_info)
 {
         int i;
         u16 group;
@@ -193,7 +193,7 @@ static int groups16_to_user(u16 *grouplist, struct group_info *group_info)
         return 0;
 }
 
-static int groups16_from_user(struct group_info *group_info, u16 *grouplist)
+static int groups16_from_user(struct group_info *group_info, u16 __user *grouplist)
 {
         int i;
         u16 group;
@@ -207,7 +207,7 @@ static int groups16_from_user(struct group_info *group_info, u16 *grouplist)
         return 0;
 }
 
-asmlinkage long sys32_getgroups16(int gidsetsize, u16 *grouplist)
+asmlinkage long sys32_getgroups16(int gidsetsize, u16 __user *grouplist)
 {
         int i;
 
@@ -231,7 +231,7 @@ out:
         return i;
 }
 
-asmlinkage long sys32_setgroups16(int gidsetsize, u16 *grouplist)
+asmlinkage long sys32_setgroups16(int gidsetsize, u16 __user *grouplist)
 {
         struct group_info *group_info;
         int retval;
@@ -278,14 +278,14 @@ asmlinkage long sys32_getegid16(void)
 
 /* 32-bit timeval and related flotsam.  */
 
-static inline long get_tv32(struct timeval *o, struct compat_timeval *i)
+static inline long get_tv32(struct timeval *o, struct compat_timeval __user *i)
 {
         return (!access_ok(VERIFY_READ, o, sizeof(*o)) ||
                 (__get_user(o->tv_sec, &i->tv_sec) ||
                  __get_user(o->tv_usec, &i->tv_usec)));
 }
 
-static inline long put_tv32(struct compat_timeval *o, struct timeval *i)
+static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i)
 {
         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
                 (__put_user(i->tv_sec, &o->tv_sec) ||
@@ -341,7 +341,7 @@ asmlinkage long sys32_ipc(u32 call, int first, int second, int third, u32 ptr)
         return -ENOSYS;
 }
 
-asmlinkage long sys32_truncate64(const char * path, unsigned long high, unsigned long low)
+asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low)
 {
         if ((int)high < 0)
                 return -EINVAL;
@@ -357,7 +357,7 @@ asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned
                 return sys_ftruncate(fd, (high << 32) | low);
 }
 
-int cp_compat_stat(struct kstat *stat, struct compat_stat *statbuf)
+int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
 {
         int err;
 
@@ -591,7 +591,7 @@ sys32_delete_module(const char __user *name_user, unsigned int flags)
 
 extern struct timezone sys_tz;
 
-asmlinkage long sys32_gettimeofday(struct compat_timeval *tv, struct timezone *tz)
+asmlinkage long sys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
 {
         if (tv) {
                 struct timeval ktv;
@@ -606,7 +606,7 @@ asmlinkage long sys32_gettimeofday(struct compat_timeval *tv, struct timezone *t
         return 0;
 }
 
-static inline long get_ts32(struct timespec *o, struct compat_timeval *i)
+static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i)
 {
         long usec;
 
@@ -620,7 +620,7 @@ static inline long get_ts32(struct timespec *o, struct compat_timeval *i)
         return 0;
 }
 
-asmlinkage long sys32_settimeofday(struct compat_timeval *tv, struct timezone *tz)
+asmlinkage long sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
 {
         struct timespec kts;
         struct timezone ktz;
@@ -645,7 +645,7 @@ asmlinkage long sys32_pause(void)
         return -ERESTARTNOHAND;
 }
 
-asmlinkage long sys32_pread64(unsigned int fd, char *ubuf,
+asmlinkage long sys32_pread64(unsigned int fd, char __user *ubuf,
                                 size_t count, u32 poshi, u32 poslo)
 {
         if ((compat_ssize_t) count < 0)
@@ -653,7 +653,7 @@ asmlinkage long sys32_pread64(unsigned int fd, char *ubuf,
         return sys_pread64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo));
 }
 
-asmlinkage long sys32_pwrite64(unsigned int fd, const char *ubuf,
+asmlinkage long sys32_pwrite64(unsigned int fd, const char __user *ubuf,
                                 size_t count, u32 poshi, u32 poslo)
 {
         if ((compat_ssize_t) count < 0)
@@ -666,7 +666,7 @@ asmlinkage compat_ssize_t sys32_readahead(int fd, u32 offhi, u32 offlo, s32 coun
         return sys_readahead(fd, ((loff_t)AA(offhi) << 32) | AA(offlo), count);
 }
 
-asmlinkage long sys32_sendfile(int out_fd, int in_fd, compat_off_t *offset, size_t count)
+asmlinkage long sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, size_t count)
 {
         mm_segment_t old_fs = get_fs();
         int ret;
@@ -686,7 +686,7 @@ asmlinkage long sys32_sendfile(int out_fd, int in_fd, compat_off_t *offset, size
 }
 
 asmlinkage long sys32_sendfile64(int out_fd, int in_fd,
-                                compat_loff_t *offset, s32 count)
+                                compat_loff_t __user *offset, s32 count)
 {
         mm_segment_t old_fs = get_fs();
         int ret;
@@ -722,7 +722,7 @@ struct timex32 {
 
 extern int do_adjtimex(struct timex *);
 
-asmlinkage long sys32_adjtimex(struct timex32 *utp)
+asmlinkage long sys32_adjtimex(struct timex32 __user *utp)
 {
         struct timex txc;
         int ret;
@@ -789,12 +789,13 @@ struct __sysctl_args32 {
         u32 __unused[4];
 };
 
-asmlinkage long sys32_sysctl(struct __sysctl_args32 *args)
+asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args)
 {
         struct __sysctl_args32 tmp;
         int error;
-        size_t oldlen, *oldlenp = NULL;
-        unsigned long addr = (((long)&args->__unused[0]) + 7) & ~7;
+        size_t oldlen;
+        size_t __user *oldlenp = NULL;
+        unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7;
 
         if (copy_from_user(&tmp, args, sizeof(tmp)))
                 return -EFAULT;
@@ -806,20 +807,20 @@ asmlinkage long sys32_sysctl(struct __sysctl_args32 *args)
                    basically copy the whole sysctl.c here, and
                    glibc's __sysctl uses rw memory for the structure
                    anyway.  */
-                if (get_user(oldlen, (u32 *)A(tmp.oldlenp)) ||
-                    put_user(oldlen, (size_t *)addr))
+                if (get_user(oldlen, (u32 __user *)compat_ptr(tmp.oldlenp)) ||
+                    put_user(oldlen, (size_t __user *)addr))
                         return -EFAULT;
-                oldlenp = (size_t *)addr;
+                oldlenp = (size_t __user *)addr;
         }
 
         lock_kernel();
-        error = do_sysctl((int *)A(tmp.name), tmp.nlen, (void *)A(tmp.oldval),
-                          oldlenp, (void *)A(tmp.newval), tmp.newlen);
+        error = do_sysctl(compat_ptr(tmp.name), tmp.nlen, compat_ptr(tmp.oldval),
+                          oldlenp, compat_ptr(tmp.newval), tmp.newlen);
         unlock_kernel();
         if (oldlenp) {
                 if (!error) {
-                        if (get_user(oldlen, (size_t *)addr) ||
-                            put_user(oldlen, (u32 *)A(tmp.oldlenp)))
+                        if (get_user(oldlen, (size_t __user *)addr) ||
+                            put_user(oldlen, (u32 __user *)compat_ptr(tmp.oldlenp)))
                                 error = -EFAULT;
                 }
                 copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused));
@@ -853,7 +854,7 @@ struct stat64_emu31 {
         unsigned long   st_ino;
 };      
 
-static int cp_stat64(struct stat64_emu31 *ubuf, struct kstat *stat)
+static int cp_stat64(struct stat64_emu31 __user *ubuf, struct kstat *stat)
 {
         struct stat64_emu31 tmp;
 
@@ -877,7 +878,7 @@ static int cp_stat64(struct stat64_emu31 *ubuf, struct kstat *stat)
         return copy_to_user(ubuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 
 }
 
-asmlinkage long sys32_stat64(char * filename, struct stat64_emu31 * statbuf)
+asmlinkage long sys32_stat64(char __user * filename, struct stat64_emu31 __user * statbuf)
 {
         struct kstat stat;
         int ret = vfs_stat(filename, &stat);
@@ -886,7 +887,7 @@ asmlinkage long sys32_stat64(char * filename, struct stat64_emu31 * statbuf)
         return ret;
 }
 
-asmlinkage long sys32_lstat64(char * filename, struct stat64_emu31 * statbuf)
+asmlinkage long sys32_lstat64(char __user * filename, struct stat64_emu31 __user * statbuf)
 {
         struct kstat stat;
         int ret = vfs_lstat(filename, &stat);
@@ -895,7 +896,7 @@ asmlinkage long sys32_lstat64(char * filename, struct stat64_emu31 * statbuf)
         return ret;
 }
 
-asmlinkage long sys32_fstat64(unsigned long fd, struct stat64_emu31 * statbuf)
+asmlinkage long sys32_fstat64(unsigned long fd, struct stat64_emu31 __user * statbuf)
 {
         struct kstat stat;
         int ret = vfs_fstat(fd, &stat);
@@ -904,6 +905,26 @@ asmlinkage long sys32_fstat64(unsigned long fd, struct stat64_emu31 * statbuf)
         return ret;
 }
 
+asmlinkage long sys32_fstatat(unsigned int dfd, char __user *filename,
+                              struct stat64_emu31 __user* statbuf, int flag)
+{
+        struct kstat stat;
+        int error = -EINVAL;
+
+        if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
+                goto out;
+
+        if (flag & AT_SYMLINK_NOFOLLOW)
+                error = vfs_lstat_fd(dfd, filename, &stat);
+        else
+                error = vfs_stat_fd(dfd, filename, &stat);
+
+        if (!error)
+                error = cp_stat64(statbuf, &stat);
+out:
+        return error;
+}
+
 /*
  * Linux/i386 didn't use to be able to handle more than
  * 4 system call parameters, so these system calls used a memory
@@ -952,7 +973,7 @@ out:
 
 
 asmlinkage unsigned long
-old32_mmap(struct mmap_arg_struct_emu31 *arg)
+old32_mmap(struct mmap_arg_struct_emu31 __user *arg)
 {
         struct mmap_arg_struct_emu31 a;
         int error = -EFAULT;
@@ -970,7 +991,7 @@ out:
 }
 
 asmlinkage long 
-sys32_mmap2(struct mmap_arg_struct_emu31 *arg)
+sys32_mmap2(struct mmap_arg_struct_emu31 __user *arg)
 {
         struct mmap_arg_struct_emu31 a;
         int error = -EFAULT;
@@ -982,7 +1003,7 @@ out:
         return error;
 }
 
-asmlinkage long sys32_read(unsigned int fd, char * buf, size_t count)
+asmlinkage long sys32_read(unsigned int fd, char __user * buf, size_t count)
 {
         if ((compat_ssize_t) count < 0)
                 return -EINVAL; 
@@ -990,7 +1011,7 @@ asmlinkage long sys32_read(unsigned int fd, char * buf, size_t count)
         return sys_read(fd, buf, count);
 }
 
-asmlinkage long sys32_write(unsigned int fd, char * buf, size_t count)
+asmlinkage long sys32_write(unsigned int fd, char __user * buf, size_t count)
 {
         if ((compat_ssize_t) count < 0)
                 return -EINVAL; 
@@ -1002,12 +1023,12 @@ asmlinkage long sys32_clone(struct pt_regs regs)
 {
         unsigned long clone_flags;
         unsigned long newsp;
-        int *parent_tidptr, *child_tidptr;
+        int __user *parent_tidptr, *child_tidptr;
 
         clone_flags = regs.gprs[3] & 0xffffffffUL;
         newsp = regs.orig_gpr2 & 0x7fffffffUL;
-        parent_tidptr = (int *) (regs.gprs[4] & 0x7fffffffUL);
-        child_tidptr = (int *) (regs.gprs[5] & 0x7fffffffUL);
+        parent_tidptr = compat_ptr(regs.gprs[4]);
+        child_tidptr = compat_ptr(regs.gprs[5]);
         if (!newsp)
                 newsp = regs.gprs[15];
         return do_fork(clone_flags, newsp, &regs, 0,
diff --git a/arch/s390/kernel/compat_signal.c b/arch/s390/kernel/compat_signal.c
index fa2b3bc22f20..5291b5f8788d 100644
--- a/arch/s390/kernel/compat_signal.c
+++ b/arch/s390/kernel/compat_signal.c
@@ -1,8 +1,7 @@
 /*
- *  arch/s390/kernel/signal32.c
+ *  arch/s390/kernel/compat_signal.c
  *
- *  S390 version
- *    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright (C) IBM Corp. 2000,2006
  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  *               Gerhard Tonn (ton@de.ibm.com)                  
  *
@@ -52,8 +51,6 @@ typedef struct
         struct ucontext32 uc;
 } rt_sigframe32;
 
-asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
-
 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
 {
         int err;
@@ -161,66 +158,6 @@ int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
         return err;
 }
 
-/*
- * Atomically swap in the new signal mask, and wait for a signal.
- */
-asmlinkage int
-sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask)
-{
-        sigset_t saveset;
-
-        mask &= _BLOCKABLE;
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        siginitset(&current->blocked, mask);
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        regs->gprs[2] = -EINTR;
-
-        while (1) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                schedule();
-                if (do_signal(regs, &saveset))
-                        return -EINTR;
-        }
-}
-
-asmlinkage int
-sys32_rt_sigsuspend(struct pt_regs * regs, compat_sigset_t __user *unewset,
-                                                                size_t sigsetsize)
-{
-        sigset_t saveset, newset;
-        compat_sigset_t set32;
-
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(sigset_t))
-                return -EINVAL;
-
-        if (copy_from_user(&set32, unewset, sizeof(set32)))
-                return -EFAULT;
-        switch (_NSIG_WORDS) {
-        case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
-        case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
-        case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
-        case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
-        }
-        sigdelsetmask(&newset, ~_BLOCKABLE);
-
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        current->blocked = newset;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        regs->gprs[2] = -EINTR;
-
-        while (1) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                schedule();
-                if (do_signal(regs, &saveset))
-                        return -EINTR;
-        }
-}
-
 asmlinkage long
 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
                  struct old_sigaction32 __user *oact)
@@ -258,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)
@@ -520,7 +454,7 @@ static inline int map_signal(int sig)
                 return sig;
 }
 
-static void setup_frame32(int sig, struct k_sigaction *ka,
+static int setup_frame32(int sig, struct k_sigaction *ka,
                         sigset_t *set, struct pt_regs * regs)
 {
         sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
@@ -565,13 +499,14 @@ static void setup_frame32(int sig, struct k_sigaction *ka,
         /* Place signal number on stack to allow backtrace from handler.  */
         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
                 goto give_sigsegv;
-        return;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(sig, current);
+        return -EFAULT;
 }
 
-static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
+static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
                            sigset_t *set, struct pt_regs * regs)
 {
         int err = 0;
@@ -615,31 +550,37 @@ static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
         regs->gprs[2] = map_signal(sig);
         regs->gprs[3] = (__u64) &frame->info;
         regs->gprs[4] = (__u64) &frame->uc;
-        return;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(sig, current);
+        return -EFAULT;
 }
 
 /*
  * OK, we're invoking a handler
  */     
 
-void
+int
 handle_signal32(unsigned long sig, struct k_sigaction *ka,
                 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
 {
+        int ret;
+
         /* Set up the stack frame */
         if (ka->sa.sa_flags & SA_SIGINFO)
-                setup_rt_frame32(sig, ka, info, oldset, regs);
+                ret = setup_rt_frame32(sig, ka, info, oldset, regs);
         else
-                setup_frame32(sig, ka, oldset, regs);
-
-        spin_lock_irq(&current->sighand->siglock);
-        sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
-        if (!(ka->sa.sa_flags & SA_NODEFER))
-                sigaddset(&current->blocked,sig);
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
+                ret = setup_frame32(sig, ka, oldset, regs);
+
+        if (ret == 0) {
+                spin_lock_irq(&current->sighand->siglock);
+                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
+                if (!(ka->sa.sa_flags & SA_NODEFER))
+                        sigaddset(&current->blocked,sig);
+                recalc_sigpending();
+                spin_unlock_irq(&current->sighand->siglock);
+        }
+        return ret;
 }
 
diff --git a/arch/s390/kernel/compat_wrapper.S b/arch/s390/kernel/compat_wrapper.S
index cfde1905d07d..dd2d6c3e8df8 100644
--- a/arch/s390/kernel/compat_wrapper.S
+++ b/arch/s390/kernel/compat_wrapper.S
@@ -1,9 +1,8 @@
 /*
-*  arch/s390/kernel/sys_wrapper31.S
+*  arch/s390/kernel/compat_wrapper.S
 *    wrapper for 31 bit compatible system calls.
 *
-*  S390 version
-*    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
+*    Copyright (C) IBM Corp. 2000,2006
 *    Author(s): Gerhard Tonn (ton@de.ibm.com),
 *               Thomas Spatzier (tspat@de.ibm.com)
 */ 
@@ -288,7 +287,12 @@ sys32_setregid16_wrapper:
         llgfr   %r3,%r3                 # __kernel_old_gid_emu31_t 
         jg      sys32_setregid16        # branch to system call
 
-#sys32_sigsuspend_wrapper               # done in sigsuspend_glue 
+        .globl sys_sigsuspend_wrapper
+sys_sigsuspend_wrapper:
+        lgfr    %r2,%r2                 # int
+        lgfr    %r3,%r3                 # int
+        llgfr   %r4,%r4                 # old_sigset_t
+        jg      sys_sigsuspend
 
         .globl  compat_sys_sigpending_wrapper 
 compat_sys_sigpending_wrapper:
@@ -855,7 +859,11 @@ sys32_rt_sigqueueinfo_wrapper:
         llgtr   %r4,%r4                 # siginfo_emu31_t *
         jg      sys32_rt_sigqueueinfo   # branch to system call
 
-#sys32_rt_sigsuspend_wrapper            # done in rt_sigsuspend_glue 
+        .globl compat_sys_rt_sigsuspend_wrapper
+compat_sys_rt_sigsuspend_wrapper:
+        llgtr   %r2,%r2                 # compat_sigset_t *
+        llgfr   %r3,%r3                 # compat_size_t
+        jg      compat_sys_rt_sigsuspend
 
         .globl  sys32_pread64_wrapper 
 sys32_pread64_wrapper:
@@ -1475,3 +1483,127 @@ sys_inotify_rm_watch_wrapper:
         lgfr    %r2,%r2                 # int
         llgfr   %r3,%r3                 # u32
         jg      sys_inotify_rm_watch
+
+        .globl compat_sys_openat_wrapper
+compat_sys_openat_wrapper:
+        llgfr   %r2,%r2                 # unsigned int
+        llgtr   %r3,%r3                 # const char *
+        lgfr    %r4,%r4                 # int
+        lgfr    %r5,%r5                 # int
+        jg      compat_sys_openat
+
+        .globl sys_mkdirat_wrapper
+sys_mkdirat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        lgfr    %r4,%r4                 # int
+        jg      sys_mkdirat
+
+        .globl sys_mknodat_wrapper
+sys_mknodat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        lgfr    %r4,%r4                 # int
+        llgfr   %r5,%r5                 # unsigned int
+        jg      sys_mknodat
+
+        .globl sys_fchownat_wrapper
+sys_fchownat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        llgfr   %r4,%r4                 # uid_t
+        llgfr   %r5,%r5                 # gid_t
+        lgfr    %r6,%r6                 # int
+        jg      sys_fchownat
+
+        .globl compat_sys_futimesat_wrapper
+compat_sys_futimesat_wrapper:
+        llgfr   %r2,%r2                 # unsigned int
+        llgtr   %r3,%r3                 # char *
+        llgtr   %r4,%r4                 # struct timeval *
+        jg      compat_sys_futimesat
+
+        .globl sys32_fstatat_wrapper
+sys32_fstatat_wrapper:
+        llgfr   %r2,%r2                 # unsigned int
+        llgtr   %r3,%r3                 # char *
+        llgtr   %r4,%r4                 # struct stat64 *
+        lgfr    %r5,%r5                 # int
+        jg      sys32_fstatat
+
+        .globl sys_unlinkat_wrapper
+sys_unlinkat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        lgfr    %r4,%r4                 # int
+        jg      sys_unlinkat
+
+        .globl sys_renameat_wrapper
+sys_renameat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        lgfr    %r4,%r4                 # int
+        llgtr   %r5,%r5                 # const char *
+        jg      sys_renameat
+
+        .globl sys_linkat_wrapper
+sys_linkat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        lgfr    %r4,%r4                 # int
+        llgtr   %r5,%r5                 # const char *
+        jg      sys_linkat
+
+        .globl sys_symlinkat_wrapper
+sys_symlinkat_wrapper:
+        llgtr   %r2,%r2                 # const char *
+        lgfr    %r3,%r3                 # int
+        llgtr   %r4,%r4                 # const char *
+        jg      sys_symlinkat
+
+        .globl sys_readlinkat_wrapper
+sys_readlinkat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        llgtr   %r4,%r4                 # char *
+        lgfr    %r5,%r5                 # int
+        jg      sys_readlinkat
+
+        .globl sys_fchmodat_wrapper
+sys_fchmodat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        llgfr   %r4,%r4                 # mode_t
+        jg      sys_fchmodat
+
+        .globl sys_faccessat_wrapper
+sys_faccessat_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # const char *
+        lgfr    %r4,%r4                 # int
+        jg      sys_faccessat
+
+        .globl compat_sys_pselect6_wrapper
+compat_sys_pselect6_wrapper:
+        lgfr    %r2,%r2                 # int
+        llgtr   %r3,%r3                 # fd_set *
+        llgtr   %r4,%r4                 # fd_set *
+        llgtr   %r5,%r5                 # fd_set *
+        llgtr   %r6,%r6                 # struct timespec *
+        llgt    %r0,164(%r15)           # void *
+        stg     %r0,160(%r15)
+        jg      compat_sys_pselect6
+
+        .globl compat_sys_ppoll_wrapper
+compat_sys_ppoll_wrapper:
+        llgtr   %r2,%r2                 # struct pollfd *
+        llgfr   %r3,%r3                 # unsigned int
+        llgtr   %r4,%r4                 # struct timespec *
+        llgtr   %r5,%r5                 # const sigset_t *
+        llgfr   %r6,%r6                 # size_t
+        jg      compat_sys_ppoll
+
+        .globl sys_unshare_wrapper
+sys_unshare_wrapper:
+        llgfr   %r2,%r2                 # unsigned long
+        jg      sys_unshare
diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S
index 27b07730b7b8..b2448487854c 100644
--- a/arch/s390/kernel/entry.S
+++ b/arch/s390/kernel/entry.S
@@ -2,8 +2,7 @@
  *  arch/s390/kernel/entry.S
  *    S390 low-level entry points.
  *
- *  S390 version
- *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright (C) IBM Corp. 1999,2006
  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  *               Hartmut Penner (hp@de.ibm.com),
  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
@@ -50,9 +49,10 @@ SP_ILC       =  STACK_FRAME_OVERHEAD + __PT_ILC
 SP_TRAP      =  STACK_FRAME_OVERHEAD + __PT_TRAP
 SP_SIZE      =  STACK_FRAME_OVERHEAD + __PT_SIZE
 
-_TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_NEED_RESCHED | _TIF_MCCK_PENDING | \
-                 _TIF_RESTART_SVC | _TIF_SINGLE_STEP )
-_TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NEED_RESCHED | _TIF_MCCK_PENDING)
+_TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK | _TIF_NEED_RESCHED | \
+                 _TIF_MCCK_PENDING | _TIF_RESTART_SVC | _TIF_SINGLE_STEP )
+_TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK | _TIF_NEED_RESCHED | \
+                 _TIF_MCCK_PENDING)
 
 STACK_SHIFT = PAGE_SHIFT + THREAD_ORDER
 STACK_SIZE  = 1 << STACK_SHIFT
@@ -251,8 +251,8 @@ sysc_work:
         bo      BASED(sysc_mcck_pending)
         tm      __TI_flags+3(%r9),_TIF_NEED_RESCHED
         bo      BASED(sysc_reschedule)
-        tm      __TI_flags+3(%r9),_TIF_SIGPENDING
-        bo      BASED(sysc_sigpending)
+        tm      __TI_flags+3(%r9),(_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK)
+        bnz     BASED(sysc_sigpending)
         tm      __TI_flags+3(%r9),_TIF_RESTART_SVC
         bo      BASED(sysc_restart)
         tm      __TI_flags+3(%r9),_TIF_SINGLE_STEP
@@ -276,12 +276,11 @@ sysc_mcck_pending:
         br      %r1                     # TIF bit will be cleared by handler
 
 #
-# _TIF_SIGPENDING is set, call do_signal
+# _TIF_SIGPENDING or _TIF_RESTORE_SIGMASK is set, call do_signal
 #
 sysc_sigpending:     
         ni      __TI_flags+3(%r9),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP
         la      %r2,SP_PTREGS(%r15)    # load pt_regs
-        sr      %r3,%r3                # clear *oldset
         l       %r1,BASED(.Ldo_signal)
         basr    %r14,%r1               # call do_signal
         tm      __TI_flags+3(%r9),_TIF_RESTART_SVC
@@ -397,30 +396,6 @@ sys_rt_sigreturn_glue:
         l       %r1,BASED(.Lrt_sigreturn)
         br      %r1                   # branch to sys_sigreturn
 
-#
-# sigsuspend and rt_sigsuspend need pt_regs as an additional
-# parameter and they have to skip the store of %r2 into the
-# user register %r2 because the return value was set in 
-# sigsuspend and rt_sigsuspend already and must not be overwritten!
-#
-
-sys_sigsuspend_glue:    
-        lr      %r5,%r4               # move mask back
-        lr      %r4,%r3               # move history1 parameter
-        lr      %r3,%r2               # move history0 parameter
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter
-        l       %r1,BASED(.Lsigsuspend)
-        la      %r14,4(%r14)          # skip store of return value
-        br      %r1                   # branch to sys_sigsuspend
-
-sys_rt_sigsuspend_glue: 
-        lr      %r4,%r3               # move sigsetsize parameter
-        lr      %r3,%r2               # move unewset parameter
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter
-        l       %r1,BASED(.Lrt_sigsuspend)
-        la      %r14,4(%r14)          # skip store of return value
-        br      %r1                   # branch to sys_rt_sigsuspend
-
 sys_sigaltstack_glue:
         la      %r4,SP_PTREGS(%r15)   # load pt_regs as parameter
         l       %r1,BASED(.Lsigaltstack)
@@ -604,15 +579,16 @@ io_work:
         lr      %r15,%r1
 #
 # One of the work bits is on. Find out which one.
-# Checked are: _TIF_SIGPENDING, _TIF_NEED_RESCHED and _TIF_MCCK_PENDING
+# Checked are: _TIF_SIGPENDING, _TIF_RESTORE_SIGMASK, _TIF_NEED_RESCHED
+#               and _TIF_MCCK_PENDING
 #
 io_work_loop:
         tm      __TI_flags+3(%r9),_TIF_MCCK_PENDING
         bo      BASED(io_mcck_pending)
         tm      __TI_flags+3(%r9),_TIF_NEED_RESCHED
         bo      BASED(io_reschedule)
-        tm      __TI_flags+3(%r9),_TIF_SIGPENDING
-        bo      BASED(io_sigpending)
+        tm      __TI_flags+3(%r9),(_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK)
+        bnz     BASED(io_sigpending)
         b       BASED(io_leave)
 
 #
@@ -636,12 +612,11 @@ io_reschedule:
         b       BASED(io_work_loop)
 
 #
-# _TIF_SIGPENDING is set, call do_signal
+# _TIF_SIGPENDING or _TIF_RESTORE_SIGMASK is set, call do_signal
 #
 io_sigpending:     
         stosm   __SF_EMPTY(%r15),0x03  # reenable interrupts
         la      %r2,SP_PTREGS(%r15)    # load pt_regs
-        sr      %r3,%r3                # clear *oldset
         l       %r1,BASED(.Ldo_signal)
         basr    %r14,%r1               # call do_signal
         stnsm   __SF_EMPTY(%r15),0xfc  # disable I/O and ext. interrupts
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S
index 369ab4413ec7..2ac095bc0e25 100644
--- a/arch/s390/kernel/entry64.S
+++ b/arch/s390/kernel/entry64.S
@@ -1,9 +1,8 @@
 /*
- *  arch/s390/kernel/entry.S
+ *  arch/s390/kernel/entry64.S
  *    S390 low-level entry points.
  *
- *  S390 version
- *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright (C) IBM Corp. 1999,2006
  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  *               Hartmut Penner (hp@de.ibm.com),
  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
@@ -53,9 +52,10 @@ SP_SIZE      =  STACK_FRAME_OVERHEAD + __PT_SIZE
 STACK_SHIFT = PAGE_SHIFT + THREAD_ORDER
 STACK_SIZE  = 1 << STACK_SHIFT
 
-_TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_NEED_RESCHED | _TIF_MCCK_PENDING | \
-                 _TIF_RESTART_SVC | _TIF_SINGLE_STEP )
-_TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_NEED_RESCHED | _TIF_MCCK_PENDING)
+_TIF_WORK_SVC = (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK | _TIF_NEED_RESCHED | \
+                 _TIF_MCCK_PENDING | _TIF_RESTART_SVC | _TIF_SINGLE_STEP )
+_TIF_WORK_INT = (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK | _TIF_NEED_RESCHED | \
+                 _TIF_MCCK_PENDING)
 
 #define BASED(name) name-system_call(%r13)
 
@@ -249,8 +249,8 @@ sysc_work:
         jo      sysc_mcck_pending
         tm      __TI_flags+7(%r9),_TIF_NEED_RESCHED
         jo      sysc_reschedule
-        tm      __TI_flags+7(%r9),_TIF_SIGPENDING
-        jo      sysc_sigpending
+        tm      __TI_flags+7(%r9),(_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK)
+        jnz     sysc_sigpending
         tm      __TI_flags+7(%r9),_TIF_RESTART_SVC
         jo      sysc_restart
         tm      __TI_flags+7(%r9),_TIF_SINGLE_STEP
@@ -272,12 +272,11 @@ sysc_mcck_pending:
         jg      s390_handle_mcck    # TIF bit will be cleared by handler
 
 #
-# _TIF_SIGPENDING is set, call do_signal
+# _TIF_SIGPENDING or _TIF_RESTORE_SIGMASK is set, call do_signal
 #
 sysc_sigpending:     
         ni      __TI_flags+7(%r9),255-_TIF_SINGLE_STEP # clear TIF_SINGLE_STEP
         la      %r2,SP_PTREGS(%r15) # load pt_regs
-        sgr     %r3,%r3           # clear *oldset
         brasl   %r14,do_signal    # call do_signal
         tm      __TI_flags+7(%r9),_TIF_RESTART_SVC
         jo      sysc_restart
@@ -414,52 +413,6 @@ sys32_rt_sigreturn_glue:
         jg      sys32_rt_sigreturn    # branch to sys32_sigreturn
 #endif
 
-#
-# sigsuspend and rt_sigsuspend need pt_regs as an additional
-# parameter and they have to skip the store of %r2 into the
-# user register %r2 because the return value was set in 
-# sigsuspend and rt_sigsuspend already and must not be overwritten!
-#
-
-sys_sigsuspend_glue:    
-        lgr     %r5,%r4               # move mask back
-        lgr     %r4,%r3               # move history1 parameter
-        lgr     %r3,%r2               # move history0 parameter
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter
-        la      %r14,6(%r14)          # skip store of return value
-        jg      sys_sigsuspend        # branch to sys_sigsuspend
-
-#ifdef CONFIG_COMPAT
-sys32_sigsuspend_glue:    
-        llgfr   %r4,%r4               # unsigned long                   
-        lgr     %r5,%r4               # move mask back
-        lgfr    %r3,%r3               # int                     
-        lgr     %r4,%r3               # move history1 parameter
-        lgfr    %r2,%r2               # int                     
-        lgr     %r3,%r2               # move history0 parameter
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter
-        la      %r14,6(%r14)          # skip store of return value
-        jg      sys32_sigsuspend      # branch to sys32_sigsuspend
-#endif
-
-sys_rt_sigsuspend_glue: 
-        lgr     %r4,%r3               # move sigsetsize parameter
-        lgr     %r3,%r2               # move unewset parameter
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter
-        la      %r14,6(%r14)          # skip store of return value
-        jg      sys_rt_sigsuspend     # branch to sys_rt_sigsuspend
-
-#ifdef CONFIG_COMPAT
-sys32_rt_sigsuspend_glue: 
-        llgfr   %r3,%r3               # size_t                  
-        lgr     %r4,%r3               # move sigsetsize parameter
-        llgtr   %r2,%r2               # sigset_emu31_t *
-        lgr     %r3,%r2               # move unewset parameter
-        la      %r2,SP_PTREGS(%r15)   # load pt_regs as first parameter
-        la      %r14,6(%r14)          # skip store of return value
-        jg      sys32_rt_sigsuspend   # branch to sys32_rt_sigsuspend
-#endif
-
 sys_sigaltstack_glue:
         la      %r4,SP_PTREGS(%r15)   # load pt_regs as parameter
         jg      sys_sigaltstack       # branch to sys_sigreturn
@@ -646,15 +599,16 @@ io_work:
         lgr     %r15,%r1
 #
 # One of the work bits is on. Find out which one.
-# Checked are: _TIF_SIGPENDING, _TIF_NEED_RESCHED and _TIF_MCCK_PENDING
+# Checked are: _TIF_SIGPENDING, _TIF_RESTORE_SIGPENDING, _TIF_NEED_RESCHED
+#              and _TIF_MCCK_PENDING
 #
 io_work_loop:
         tm      __TI_flags+7(%r9),_TIF_MCCK_PENDING
         jo      io_mcck_pending
         tm      __TI_flags+7(%r9),_TIF_NEED_RESCHED
         jo      io_reschedule
-        tm      __TI_flags+7(%r9),_TIF_SIGPENDING
-        jo      io_sigpending
+        tm      __TI_flags+7(%r9),(_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK)
+        jnz     io_sigpending
         j       io_leave
 
 #
@@ -676,12 +630,11 @@ io_reschedule:
         j       io_work_loop
 
 #
-# _TIF_SIGPENDING is set, call do_signal
+# _TIF_SIGPENDING or _TIF_RESTORE_SIGMASK is set, call do_signal
 #
 io_sigpending:     
         stosm   __SF_EMPTY(%r15),0x03   # reenable interrupts
         la      %r2,SP_PTREGS(%r15)     # load pt_regs
-        slgr    %r3,%r3                 # clear *oldset
         brasl   %r14,do_signal          # call do_signal
         stnsm   __SF_EMPTY(%r15),0xfc   # disable I/O and ext. interrupts
         j       io_work_loop
diff --git a/arch/s390/kernel/machine_kexec.c b/arch/s390/kernel/machine_kexec.c
index f0ed5c642c74..bad81b5832db 100644
--- a/arch/s390/kernel/machine_kexec.c
+++ b/arch/s390/kernel/machine_kexec.c
@@ -12,15 +12,16 @@
  * on the S390 architecture.
  */
 
-#include <asm/cio.h>
-#include <asm/setup.h>
 #include <linux/device.h>
 #include <linux/mm.h>
 #include <linux/kexec.h>
 #include <linux/delay.h>
+#include <asm/cio.h>
+#include <asm/setup.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/system.h>
+#include <asm/smp.h>
 
 static void kexec_halt_all_cpus(void *);
 
diff --git a/arch/s390/kernel/signal.c b/arch/s390/kernel/signal.c
index 6ae4a77270b5..ae1927e48cfb 100644
--- a/arch/s390/kernel/signal.c
+++ b/arch/s390/kernel/signal.c
@@ -1,8 +1,7 @@
 /*
  *  arch/s390/kernel/signal.c
  *
- *  S390 version
- *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
+ *    Copyright (C) IBM Corp. 1999,2006
  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  *
  *    Based on Intel version
@@ -51,60 +50,24 @@ typedef struct
         struct ucontext uc;
 } rt_sigframe;
 
-int do_signal(struct pt_regs *regs, sigset_t *oldset);
-
 /*
  * Atomically swap in the new signal mask, and wait for a signal.
  */
 asmlinkage int
-sys_sigsuspend(struct pt_regs * regs, int history0, int history1,
-               old_sigset_t mask)
+sys_sigsuspend(int history0, int history1, old_sigset_t mask)
 {
-        sigset_t saveset;
-
         mask &= _BLOCKABLE;
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         siginitset(&current->blocked, mask);
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
-        regs->gprs[2] = -EINTR;
-
-        while (1) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                schedule();
-                if (do_signal(regs, &saveset))
-                        return -EINTR;
-        }
-}
-
-asmlinkage long
-sys_rt_sigsuspend(struct pt_regs *regs, sigset_t __user *unewset,
-                                                size_t sigsetsize)
-{
-        sigset_t saveset, newset;
 
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(sigset_t))
-                return -EINVAL;
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
 
-        if (copy_from_user(&newset, unewset, sizeof(newset)))
-                return -EFAULT;
-        sigdelsetmask(&newset, ~_BLOCKABLE);
-
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        current->blocked = newset;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        regs->gprs[2] = -EINTR;
-
-        while (1) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                schedule();
-                if (do_signal(regs, &saveset))
-                        return -EINTR;
-        }
+        return -ERESTARTNOHAND;
 }
 
 asmlinkage long
@@ -306,8 +269,8 @@ static inline int map_signal(int sig)
                 return sig;
 }
 
-static void setup_frame(int sig, struct k_sigaction *ka,
-                        sigset_t *set, struct pt_regs * regs)
+static int setup_frame(int sig, struct k_sigaction *ka,
+                       sigset_t *set, struct pt_regs * regs)
 {
         sigframe __user *frame;
 
@@ -355,13 +318,14 @@ static void setup_frame(int sig, struct k_sigaction *ka,
         /* Place signal number on stack to allow backtrace from handler.  */
         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
                 goto give_sigsegv;
-        return;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(sig, current);
+        return -EFAULT;
 }
 
-static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
+static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
                            sigset_t *set, struct pt_regs * regs)
 {
         int err = 0;
@@ -409,32 +373,39 @@ static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
         regs->gprs[2] = map_signal(sig);
         regs->gprs[3] = (unsigned long) &frame->info;
         regs->gprs[4] = (unsigned long) &frame->uc;
-        return;
+        return 0;
 
 give_sigsegv:
         force_sigsegv(sig, current);
+        return -EFAULT;
 }
 
 /*
  * OK, we're invoking a handler
  */     
 
-static void
+static int
 handle_signal(unsigned long sig, struct k_sigaction *ka,
               siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
 {
+        int ret;
+
         /* Set up the stack frame */
         if (ka->sa.sa_flags & SA_SIGINFO)
-                setup_rt_frame(sig, ka, info, oldset, regs);
+                ret = setup_rt_frame(sig, ka, info, oldset, regs);
         else
-                setup_frame(sig, ka, oldset, regs);
+                ret = setup_frame(sig, ka, oldset, regs);
+
+        if (ret == 0) {
+                spin_lock_irq(&current->sighand->siglock);
+                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
+                if (!(ka->sa.sa_flags & SA_NODEFER))
+                        sigaddset(&current->blocked,sig);
+                recalc_sigpending();
+                spin_unlock_irq(&current->sighand->siglock);
+        }
 
-        spin_lock_irq(&current->sighand->siglock);
-        sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
-        if (!(ka->sa.sa_flags & SA_NODEFER))
-                sigaddset(&current->blocked,sig);
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
+        return ret;
 }
 
 /*
@@ -446,12 +417,13 @@ handle_signal(unsigned long sig, struct k_sigaction *ka,
  * the kernel can handle, and then we build all the user-level signal handling
  * stack-frames in one go after that.
  */
-int do_signal(struct pt_regs *regs, sigset_t *oldset)
+void do_signal(struct pt_regs *regs)
 {
         unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
         siginfo_t info;
         int signr;
         struct k_sigaction ka;
+        sigset_t *oldset;
 
         /*
          * We want the common case to go fast, which
@@ -460,9 +432,11 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset)
          * if so.
          */
         if (!user_mode(regs))
-                return 1;
+                return;
 
-        if (!oldset)
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
                 oldset = &current->blocked;
 
         /* Are we from a system call? */
@@ -473,12 +447,14 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset)
 
                 /* Prepare for system call restart.  We do this here so that a
                    debugger will see the already changed PSW. */
-                if (retval == -ERESTARTNOHAND ||
-                    retval == -ERESTARTSYS ||
-                    retval == -ERESTARTNOINTR) {
+                switch (retval) {
+                case -ERESTARTNOHAND:
+                case -ERESTARTSYS:
+                case -ERESTARTNOINTR:
                         regs->gprs[2] = regs->orig_gpr2;
                         regs->psw.addr = restart_addr;
-                } else if (retval == -ERESTART_RESTARTBLOCK) {
+                        break;
+                case -ERESTART_RESTARTBLOCK:
                         regs->gprs[2] = -EINTR;
                 }
         }
@@ -503,17 +479,38 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset)
                 /* Whee!  Actually deliver the signal.  */
 #ifdef CONFIG_COMPAT
                 if (test_thread_flag(TIF_31BIT)) {
-                        extern void handle_signal32(unsigned long sig,
-                                                    struct k_sigaction *ka,
-                                                    siginfo_t *info,
-                                                    sigset_t *oldset,
-                                                    struct pt_regs *regs);
-                        handle_signal32(signr, &ka, &info, oldset, regs);
-                        return 1;
+                        extern int handle_signal32(unsigned long sig,
+                                                   struct k_sigaction *ka,
+                                                   siginfo_t *info,
+                                                   sigset_t *oldset,
+                                                   struct pt_regs *regs);
+                        if (handle_signal32(
+                                    signr, &ka, &info, oldset, regs) == 0) {
+                                if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                                        clear_thread_flag(TIF_RESTORE_SIGMASK);
+                        }
+                        return;
                 }
 #endif
-                handle_signal(signr, &ka, &info, oldset, regs);
-                return 1;
+                if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
+                        /*
+                         * A signal was successfully delivered; the saved
+                         * sigmask will have been stored in the signal frame,
+                         * and will be restored by sigreturn, so we can simply
+                         * clear the TIF_RESTORE_SIGMASK flag.
+                         */
+                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                }
+                return;
+        }
+
+        /*
+         * If there's no signal to deliver, we just put the saved sigmask back.
+         */
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
         }
 
         /* Restart a different system call. */
@@ -522,5 +519,4 @@ int do_signal(struct pt_regs *regs, sigset_t *oldset)
                 regs->gprs[2] = __NR_restart_syscall;
                 set_thread_flag(TIF_RESTART_SVC);
         }
-        return 0;
 }
diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
index cbfcfd02a43a..0d1ad5dbe2b1 100644
--- a/arch/s390/kernel/smp.c
+++ b/arch/s390/kernel/smp.c
@@ -52,7 +52,7 @@ extern volatile int __cpu_logical_map[];
 struct _lowcore *lowcore_ptr[NR_CPUS];
 
 cpumask_t cpu_online_map;
-cpumask_t cpu_possible_map;
+cpumask_t cpu_possible_map = CPU_MASK_ALL;
 
 static struct task_struct *current_set[NR_CPUS];
 
@@ -514,9 +514,6 @@ __init smp_check_cpus(unsigned int max_cpus)
                 num_cpus++;
         }
 
-        for (cpu = 1; cpu < max_cpus; cpu++)
-                cpu_set(cpu, cpu_possible_map);
-
         printk("Detected %d CPU's\n",(int) num_cpus);
         printk("Boot cpu address %2X\n", boot_cpu_addr);
 }
@@ -810,7 +807,6 @@ void __devinit smp_prepare_boot_cpu(void)
 
         cpu_set(0, cpu_online_map);
         cpu_set(0, cpu_present_map);
-        cpu_set(0, cpu_possible_map);
         S390_lowcore.percpu_offset = __per_cpu_offset[0];
         current_set[0] = current;
 }
diff --git a/arch/s390/kernel/sys_s390.c b/arch/s390/kernel/sys_s390.c
index 6a63553493c5..e351780bb660 100644
--- a/arch/s390/kernel/sys_s390.c
+++ b/arch/s390/kernel/sys_s390.c
@@ -122,8 +122,8 @@ out:
 #ifndef CONFIG_64BIT
 struct sel_arg_struct {
         unsigned long n;
-        fd_set *inp, *outp, *exp;
-        struct timeval *tvp;
+        fd_set __user *inp, *outp, *exp;
+        struct timeval __user *tvp;
 };
 
 asmlinkage long old_select(struct sel_arg_struct __user *arg)
diff --git a/arch/s390/kernel/syscalls.S b/arch/s390/kernel/syscalls.S
index 426d7cafdab3..84921fe8d266 100644
--- a/arch/s390/kernel/syscalls.S
+++ b/arch/s390/kernel/syscalls.S
@@ -80,7 +80,7 @@ NI_SYSCALL							/* old sgetmask syscall*/
 NI_SYSCALL                                                      /* old ssetmask syscall*/
 SYSCALL(sys_setreuid16,sys_ni_syscall,sys32_setreuid16_wrapper) /* old setreuid16 syscall */
 SYSCALL(sys_setregid16,sys_ni_syscall,sys32_setregid16_wrapper) /* old setregid16 syscall */
-SYSCALL(sys_sigsuspend_glue,sys_sigsuspend_glue,sys32_sigsuspend_glue)
+SYSCALL(sys_sigsuspend,sys_sigsuspend,sys_sigsuspend_wrapper)
 SYSCALL(sys_sigpending,sys_sigpending,compat_sys_sigpending_wrapper)
 SYSCALL(sys_sethostname,sys_sethostname,sys32_sethostname_wrapper)
 SYSCALL(sys_setrlimit,sys_setrlimit,compat_sys_setrlimit_wrapper)       /* 75 */
@@ -187,7 +187,7 @@ SYSCALL(sys_rt_sigprocmask,sys_rt_sigprocmask,sys32_rt_sigprocmask_wrapper)	/* 1
 SYSCALL(sys_rt_sigpending,sys_rt_sigpending,sys32_rt_sigpending_wrapper)
 SYSCALL(sys_rt_sigtimedwait,sys_rt_sigtimedwait,compat_sys_rt_sigtimedwait_wrapper)
 SYSCALL(sys_rt_sigqueueinfo,sys_rt_sigqueueinfo,sys32_rt_sigqueueinfo_wrapper)
-SYSCALL(sys_rt_sigsuspend_glue,sys_rt_sigsuspend_glue,sys32_rt_sigsuspend_glue)
+SYSCALL(sys_rt_sigsuspend,sys_rt_sigsuspend,compat_sys_rt_sigsuspend_wrapper)
 SYSCALL(sys_pread64,sys_pread64,sys32_pread64_wrapper)          /* 180 */
 SYSCALL(sys_pwrite64,sys_pwrite64,sys32_pwrite64_wrapper)
 SYSCALL(sys_chown16,sys_ni_syscall,sys32_chown16_wrapper)       /* old chown16 syscall */
@@ -293,5 +293,22 @@ SYSCALL(sys_waitid,sys_waitid,compat_sys_waitid_wrapper)
 SYSCALL(sys_ioprio_set,sys_ioprio_set,sys_ioprio_set_wrapper)
 SYSCALL(sys_ioprio_get,sys_ioprio_get,sys_ioprio_get_wrapper)
 SYSCALL(sys_inotify_init,sys_inotify_init,sys_inotify_init)
-SYSCALL(sys_inotify_add_watch,sys_inotify_add_watch,sys_inotify_add_watch_wrapper)
+SYSCALL(sys_inotify_add_watch,sys_inotify_add_watch,sys_inotify_add_watch_wrapper)      /* 285 */
 SYSCALL(sys_inotify_rm_watch,sys_inotify_rm_watch,sys_inotify_rm_watch_wrapper)
+NI_SYSCALL                                                      /* 287 sys_migrate_pages */
+SYSCALL(sys_openat,sys_openat,compat_sys_openat_wrapper)
+SYSCALL(sys_mkdirat,sys_mkdirat,sys_mkdirat_wrapper)
+SYSCALL(sys_mknodat,sys_mknodat,sys_mknodat_wrapper)    /* 290 */
+SYSCALL(sys_fchownat,sys_fchownat,sys_fchownat_wrapper)
+SYSCALL(sys_futimesat,sys_futimesat,compat_sys_futimesat_wrapper)
+SYSCALL(sys_fstatat64,sys_newfstatat,sys32_fstatat_wrapper)
+SYSCALL(sys_unlinkat,sys_unlinkat,sys_unlinkat_wrapper)
+SYSCALL(sys_renameat,sys_renameat,sys_renameat_wrapper) /* 295 */
+SYSCALL(sys_linkat,sys_linkat,sys_linkat_wrapper)
+SYSCALL(sys_symlinkat,sys_symlinkat,sys_symlinkat_wrapper)
+SYSCALL(sys_readlinkat,sys_readlinkat,sys_readlinkat_wrapper)
+SYSCALL(sys_fchmodat,sys_fchmodat,sys_fchmodat_wrapper)
+SYSCALL(sys_faccessat,sys_faccessat,sys_faccessat_wrapper)      /* 300 */
+SYSCALL(sys_pselect6,sys_pselect6,compat_sys_pselect6_wrapper)
+SYSCALL(sys_ppoll,sys_ppoll,compat_sys_ppoll_wrapper)
+SYSCALL(sys_unshare,sys_unshare,sys_unshare_wrapper)
diff --git a/arch/s390/kernel/time.c b/arch/s390/kernel/time.c
index 7c0fe152a111..fea043b69b91 100644
--- a/arch/s390/kernel/time.c
+++ b/arch/s390/kernel/time.c
@@ -61,9 +61,18 @@ extern unsigned long wall_jiffies;
  */
 unsigned long long sched_clock(void)
 {
-        return ((get_clock() - jiffies_timer_cc) * 1000) >> 12;
+        return ((get_clock() - jiffies_timer_cc) * 125) >> 9;
 }
 
+/*
+ * Monotonic_clock - returns # of nanoseconds passed since time_init()
+ */
+unsigned long long monotonic_clock(void)
+{
+        return sched_clock();
+}
+EXPORT_SYMBOL(monotonic_clock);
+
 void tod_to_timeval(__u64 todval, struct timespec *xtime)
 {
         unsigned long long sec;
diff --git a/arch/s390/kernel/traps.c b/arch/s390/kernel/traps.c
index 5d21e9e6e7b4..a46793beeddd 100644
--- a/arch/s390/kernel/traps.c
+++ b/arch/s390/kernel/traps.c
@@ -486,7 +486,7 @@ asmlinkage void illegal_op(struct pt_regs * regs, long interruption_code)
                 info.si_signo = signal;
                 info.si_errno = 0;
                 info.si_code = ILL_ILLOPC;
-                info.si_addr = (void *) location;
+                info.si_addr = (void __user *) location;
                 do_trap(interruption_code, signal,
                         "illegal operation", regs, &info);
         }
diff --git a/arch/s390/lib/Makefile b/arch/s390/lib/Makefile
index f20b51ff1d86..e05d087a6eae 100644
--- a/arch/s390/lib/Makefile
+++ b/arch/s390/lib/Makefile
@@ -6,4 +6,4 @@ EXTRA_AFLAGS := -traditional
 
 lib-y += delay.o string.o
 lib-y += $(if $(CONFIG_64BIT),uaccess64.o,uaccess.o)
-lib-$(CONFIG_SMP) += spinlock.o
\ No newline at end of file
+lib-$(CONFIG_SMP) += spinlock.o
diff --git a/arch/s390/mm/cmm.c b/arch/s390/mm/cmm.c
index 2d5cb1385753..b075ab499d05 100644
--- a/arch/s390/mm/cmm.c
+++ b/arch/s390/mm/cmm.c
@@ -42,8 +42,8 @@ static volatile long cmm_timed_pages_target = 0;
 static long cmm_timeout_pages = 0;
 static long cmm_timeout_seconds = 0;
 
-static struct cmm_page_array *cmm_page_list = 0;
-static struct cmm_page_array *cmm_timed_page_list = 0;
+static struct cmm_page_array *cmm_page_list = NULL;
+static struct cmm_page_array *cmm_timed_page_list = NULL;
 
 static unsigned long cmm_thread_active = 0;
 static struct work_struct cmm_thread_starter;
@@ -259,7 +259,7 @@ static struct ctl_table cmm_table[];
 
 static int
 cmm_pages_handler(ctl_table *ctl, int write, struct file *filp,
-                  void *buffer, size_t *lenp, loff_t *ppos)
+                  void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         char buf[16], *p;
         long pages;
@@ -300,7 +300,7 @@ cmm_pages_handler(ctl_table *ctl, int write, struct file *filp,
 
 static int
 cmm_timeout_handler(ctl_table *ctl, int write, struct file *filp,
-                    void *buffer, size_t *lenp, loff_t *ppos)
+                    void __user *buffer, size_t *lenp, loff_t *ppos)
 {
         char buf[64], *p;
         long pages, seconds;
@@ -419,7 +419,7 @@ cmm_init (void)
 #ifdef CONFIG_CMM_IUCV
         smsg_register_callback(SMSG_PREFIX, cmm_smsg_target);
 #endif
-        INIT_WORK(&cmm_thread_starter, (void *) cmm_start_thread, 0);
+        INIT_WORK(&cmm_thread_starter, (void *) cmm_start_thread, NULL);
         init_waitqueue_head(&cmm_thread_wait);
         init_timer(&cmm_timer);
         return 0;
diff --git a/arch/sh/Kconfig b/arch/sh/Kconfig
index 01bc7d589afe..504d56f8ca7f 100644
--- a/arch/sh/Kconfig
+++ b/arch/sh/Kconfig
@@ -396,14 +396,8 @@ source "arch/sh/boards/renesas/hs7751rvoip/Kconfig"
 
 source "arch/sh/boards/renesas/rts7751r2d/Kconfig"
 
-config SH_PCLK_FREQ_BOOL
-        bool "Set default pclk frequency"
-        default y if !SH_RTC
-        default n
-
 config SH_PCLK_FREQ
         int "Peripheral clock frequency (in Hz)"
-        depends on SH_PCLK_FREQ_BOOL
         default "50000000" if CPU_SUBTYPE_SH7750 || CPU_SUBTYPE_SH7780
         default "60000000" if CPU_SUBTYPE_SH7751
         default "33333333" if CPU_SUBTYPE_SH7300 || CPU_SUBTYPE_SH7770 || CPU_SUBTYPE_SH7760
diff --git a/arch/sh/boards/renesas/rts7751r2d/io.c b/arch/sh/boards/renesas/rts7751r2d/io.c
index c46f9154cfd5..123abbbc91e0 100644
--- a/arch/sh/boards/renesas/rts7751r2d/io.c
+++ b/arch/sh/boards/renesas/rts7751r2d/io.c
@@ -216,24 +216,26 @@ void rts7751r2d_insb(unsigned long port, void *addr, unsigned long count)
 {
         volatile __u8 *bp;
         volatile __u16 *p;
+        unsigned char *s = addr;
 
         if (CHECK_AX88796L_PORT(port)) {
                 p = (volatile unsigned short *)port88796l(port, 0);
-                while (count--) *((unsigned char *) addr)++ = *p & 0xff;
+                while (count--) *s++ = *p & 0xff;
         } else if (PXSEG(port))
-                while (count--) *((unsigned char *) addr)++ = *(volatile unsigned char *)port;
+                while (count--) *s++ = *(volatile unsigned char *)port;
         else if (CHECK_SH7751_PCIIO(port) || shifted_port(port)) {
                 bp = (__u8 *)PCI_IOMAP(port);
-                while (count--) *((volatile unsigned char *) addr)++ = *bp;
+                while (count--) *s++ = *bp;
         } else {
                 p = (volatile unsigned short *)port2adr(port);
-                while (count--) *((unsigned char *) addr)++ = *p & 0xff;
+                while (count--) *s++ = *p & 0xff;
         }
 }
 
 void rts7751r2d_insw(unsigned long port, void *addr, unsigned long count)
 {
         volatile __u16 *p;
+        __u16 *s = addr;
 
         if (CHECK_AX88796L_PORT(port))
                 p = (volatile unsigned short *)port88796l(port, 1);
@@ -243,7 +245,7 @@ void rts7751r2d_insw(unsigned long port, void *addr, unsigned long count)
                 p = (volatile unsigned short *)PCI_IOMAP(port);
         else
                 p = (volatile unsigned short *)port2adr(port);
-        while (count--) *((__u16 *) addr)++ = *p;
+        while (count--) *s++ = *p;
 }
 
 void rts7751r2d_insl(unsigned long port, void *addr, unsigned long count)
@@ -252,8 +254,9 @@ void rts7751r2d_insl(unsigned long port, void *addr, unsigned long count)
                 maybebadio(insl, port);
         else if (CHECK_SH7751_PCIIO(port) || shifted_port(port)) {
                 volatile __u32 *p = (__u32 *)PCI_IOMAP(port);
+                __u32 *s = addr;
 
-                while (count--) *((__u32 *) addr)++ = *p;
+                while (count--) *s++ = *p;
         } else
                 maybebadio(insl, port);
 }
@@ -262,24 +265,26 @@ void rts7751r2d_outsb(unsigned long port, const void *addr, unsigned long count)
 {
         volatile __u8 *bp;
         volatile __u16 *p;
+        const __u8 *s = addr;
 
         if (CHECK_AX88796L_PORT(port)) {
                 p = (volatile unsigned short *)port88796l(port, 0);
-                while (count--) *p = *((unsigned char *) addr)++;
+                while (count--) *p = *s++;
         } else if (PXSEG(port))
-                while (count--) *(volatile unsigned char *)port = *((unsigned char *) addr)++;
+                while (count--) *(volatile unsigned char *)port = *s++;
         else if (CHECK_SH7751_PCIIO(port) || shifted_port(port)) {
                 bp = (__u8 *)PCI_IOMAP(port);
-                while (count--) *bp = *((volatile unsigned char *) addr)++;
+                while (count--) *bp = *s++;
         } else {
                 p = (volatile unsigned short *)port2adr(port);
-                while (count--) *p = *((unsigned char *) addr)++;
+                while (count--) *p = *s++;
         }
 }
 
 void rts7751r2d_outsw(unsigned long port, const void *addr, unsigned long count)
 {
         volatile __u16 *p;
+        const __u16 *s = addr;
 
         if (CHECK_AX88796L_PORT(port))
                 p = (volatile unsigned short *)port88796l(port, 1);
@@ -289,7 +294,7 @@ void rts7751r2d_outsw(unsigned long port, const void *addr, unsigned long count)
                 p = (volatile unsigned short *)PCI_IOMAP(port);
         else
                 p = (volatile unsigned short *)port2adr(port);
-        while (count--) *p = *((__u16 *) addr)++;
+        while (count--) *p = *s++;
 }
 
 void rts7751r2d_outsl(unsigned long port, const void *addr, unsigned long count)
@@ -298,8 +303,9 @@ void rts7751r2d_outsl(unsigned long port, const void *addr, unsigned long count)
                 maybebadio(outsl, port);
         else if (CHECK_SH7751_PCIIO(port) || shifted_port(port)) {
                 volatile __u32 *p = (__u32 *)PCI_IOMAP(port);
+                const __u32 *s = addr;
 
-                while (count--) *p = *((__u32 *) addr)++;
+                while (count--) *p = *s++;
         } else
                 maybebadio(outsl, port);
 }
diff --git a/arch/sh/boards/superh/microdev/io.c b/arch/sh/boards/superh/microdev/io.c
index fe83b2c03076..1ed7f880b8c7 100644
--- a/arch/sh/boards/superh/microdev/io.c
+++ b/arch/sh/boards/superh/microdev/io.c
@@ -16,7 +16,7 @@
 #include <linux/pci.h>
 #include <linux/wait.h>
 #include <asm/io.h>
-#include <asm/mach/io.h>
+#include <asm/microdev.h>
 
         /*
          *      we need to have a 'safe' address to re-direct all I/O requests
@@ -52,8 +52,90 @@
 #define IO_ISP1161_PHYS         0xa7700000ul    /* Physical address of Philips ISP1161x USB chip */
 #define IO_SUPERIO_PHYS         0xa7800000ul    /* Physical address of SMSC FDC37C93xAPM SuperIO chip */
 
-#define PORT2ADDR(x) (microdev_isa_port2addr(x))
+/*
+ * map I/O ports to memory-mapped addresses
+ */
+static unsigned long microdev_isa_port2addr(unsigned long offset)
+{
+        unsigned long result;
+
+        if ((offset >= IO_LAN91C111_BASE) &&
+            (offset <  IO_LAN91C111_BASE + IO_LAN91C111_EXTENT)) {
+                        /*
+                         *      SMSC LAN91C111 Ethernet chip
+                         */
+                result = IO_LAN91C111_PHYS + offset - IO_LAN91C111_BASE;
+        } else if ((offset >= IO_SUPERIO_BASE) &&
+                   (offset <  IO_SUPERIO_BASE + IO_SUPERIO_EXTENT)) {
+                        /*
+                         *      SMSC FDC37C93xAPM SuperIO chip
+                         *
+                         *      Configuration Registers
+                         */
+                result = IO_SUPERIO_PHYS + (offset << 1);
+#if 0
+        } else if (offset == KBD_DATA_REG || offset == KBD_CNTL_REG ||
+                   offset == KBD_STATUS_REG) {
+                        /*
+                         *      SMSC FDC37C93xAPM SuperIO chip
+                         *
+                         *      PS/2 Keyboard + Mouse (ports 0x60 and 0x64).
+                         */
+                result = IO_SUPERIO_PHYS + (offset << 1);
+#endif
+        } else if (((offset >= IO_IDE1_BASE) &&
+                    (offset <  IO_IDE1_BASE + IO_IDE_EXTENT)) ||
+                    (offset == IO_IDE1_MISC)) {
+                        /*
+                         *      SMSC FDC37C93xAPM SuperIO chip
+                         *
+                         *      IDE #1
+                         */
+                result = IO_SUPERIO_PHYS + (offset << 1);
+        } else if (((offset >= IO_IDE2_BASE) &&
+                    (offset <  IO_IDE2_BASE + IO_IDE_EXTENT)) ||
+                    (offset == IO_IDE2_MISC)) {
+                        /*
+                         *      SMSC FDC37C93xAPM SuperIO chip
+                         *
+                         *      IDE #2
+                         */
+                result = IO_SUPERIO_PHYS + (offset << 1);
+        } else if ((offset >= IO_SERIAL1_BASE) &&
+                   (offset <  IO_SERIAL1_BASE + IO_SERIAL_EXTENT)) {
+                        /*
+                         *      SMSC FDC37C93xAPM SuperIO chip
+                         *
+                         *      Serial #1
+                         */
+                result = IO_SUPERIO_PHYS + (offset << 1);
+        } else if ((offset >= IO_SERIAL2_BASE) &&
+                   (offset <  IO_SERIAL2_BASE + IO_SERIAL_EXTENT)) {
+                        /*
+                         *      SMSC FDC37C93xAPM SuperIO chip
+                         *
+                         *      Serial #2
+                         */
+                result = IO_SUPERIO_PHYS + (offset << 1);
+        } else if ((offset >= IO_ISP1161_BASE) &&
+                   (offset < IO_ISP1161_BASE + IO_ISP1161_EXTENT)) {
+                        /*
+                         *      Philips USB ISP1161x chip
+                         */
+                result = IO_ISP1161_PHYS + offset - IO_ISP1161_BASE;
+        } else {
+                        /*
+                         *      safe default.
+                         */
+                printk("Warning: unexpected port in %s( offset = 0x%lx )\n",
+                       __FUNCTION__, offset);
+                result = PVR;
+        }
+
+        return result;
+}
 
+#define PORT2ADDR(x) (microdev_isa_port2addr(x))
 
 static inline void delay(void)
 {
@@ -94,6 +176,17 @@ unsigned int microdev_inl(unsigned long port)
         return *(volatile unsigned int*)PORT2ADDR(port);
 }
 
+void microdev_outw(unsigned short b, unsigned long port)
+{
+#ifdef CONFIG_PCI
+        if (port >= PCIBIOS_MIN_IO) {
+                microdev_pci_outw(b, port);
+                return;
+        }
+#endif
+        *(volatile unsigned short*)PORT2ADDR(port) = b;
+}
+
 void microdev_outb(unsigned char b, unsigned long port)
 {
 #ifdef CONFIG_PCI
@@ -158,17 +251,6 @@ void microdev_outb(unsigned char b, unsigned long port)
         }
 }
 
-void microdev_outw(unsigned short b, unsigned long port)
-{
-#ifdef CONFIG_PCI
-        if (port >= PCIBIOS_MIN_IO) {
-                microdev_pci_outw(b, port);
-                return;
-        }
-#endif
-        *(volatile unsigned short*)PORT2ADDR(port) = b;
-}
-
 void microdev_outl(unsigned int b, unsigned long port)
 {
 #ifdef CONFIG_PCI
@@ -284,87 +366,3 @@ void microdev_outsl(unsigned long port, const void *buffer, unsigned long count)
         while (count--)
                 *port_addr = *buf++;
 }
-
-/*
- * map I/O ports to memory-mapped addresses
- */
-unsigned long microdev_isa_port2addr(unsigned long offset)
-{
-        unsigned long result;
-
-        if ((offset >= IO_LAN91C111_BASE) &&
-            (offset <  IO_LAN91C111_BASE + IO_LAN91C111_EXTENT)) {
-                        /*
-                         *      SMSC LAN91C111 Ethernet chip
-                         */
-                result = IO_LAN91C111_PHYS + offset - IO_LAN91C111_BASE;
-        } else if ((offset >= IO_SUPERIO_BASE) &&
-                   (offset <  IO_SUPERIO_BASE + IO_SUPERIO_EXTENT)) {
-                        /*
-                         *      SMSC FDC37C93xAPM SuperIO chip
-                         *
-                         *      Configuration Registers
-                         */
-                result = IO_SUPERIO_PHYS + (offset << 1);
-#if 0
-        } else if (offset == KBD_DATA_REG || offset == KBD_CNTL_REG ||
-                   offset == KBD_STATUS_REG) {
-                        /*
-                         *      SMSC FDC37C93xAPM SuperIO chip
-                         *
-                         *      PS/2 Keyboard + Mouse (ports 0x60 and 0x64).
-                         */
-                result = IO_SUPERIO_PHYS + (offset << 1);
-#endif
-        } else if (((offset >= IO_IDE1_BASE) &&
-                    (offset <  IO_IDE1_BASE + IO_IDE_EXTENT)) ||
-                    (offset == IO_IDE1_MISC)) {
-                        /*
-                         *      SMSC FDC37C93xAPM SuperIO chip
-                         *
-                         *      IDE #1
-                         */
-                result = IO_SUPERIO_PHYS + (offset << 1);
-        } else if (((offset >= IO_IDE2_BASE) &&
-                    (offset <  IO_IDE2_BASE + IO_IDE_EXTENT)) ||
-                    (offset == IO_IDE2_MISC)) {
-                        /*
-                         *      SMSC FDC37C93xAPM SuperIO chip
-                         *
-                         *      IDE #2
-                         */
-                result = IO_SUPERIO_PHYS + (offset << 1);
-        } else if ((offset >= IO_SERIAL1_BASE) &&
-                   (offset <  IO_SERIAL1_BASE + IO_SERIAL_EXTENT)) {
-                        /*
-                         *      SMSC FDC37C93xAPM SuperIO chip
-                         *
-                         *      Serial #1
-                         */
-                result = IO_SUPERIO_PHYS + (offset << 1);
-        } else if ((offset >= IO_SERIAL2_BASE) &&
-                   (offset <  IO_SERIAL2_BASE + IO_SERIAL_EXTENT)) {
-                        /*
-                         *      SMSC FDC37C93xAPM SuperIO chip
-                         *
-                         *      Serial #2
-                         */
-                result = IO_SUPERIO_PHYS + (offset << 1);
-        } else if ((offset >= IO_ISP1161_BASE) &&
-                   (offset < IO_ISP1161_BASE + IO_ISP1161_EXTENT)) {
-                        /*
-                         *      Philips USB ISP1161x chip
-                         */
-                result = IO_ISP1161_PHYS + offset - IO_ISP1161_BASE;
-        } else {
-                        /*
-                         *      safe default.
-                         */
-                printk("Warning: unexpected port in %s( offset = 0x%lx )\n",
-                       __FUNCTION__, offset);
-                result = PVR;
-        }
-
-        return result;
-}
-
diff --git a/arch/sh/boards/superh/microdev/irq.c b/arch/sh/boards/superh/microdev/irq.c
index 1395c1e65da4..efcbd86b7cd2 100644
--- a/arch/sh/boards/superh/microdev/irq.c
+++ b/arch/sh/boards/superh/microdev/irq.c
@@ -15,7 +15,7 @@
 
 #include <asm/system.h>
 #include <asm/io.h>
-#include <asm/mach/irq.h>
+#include <asm/microdev.h>
 
 #define NUM_EXTERNAL_IRQS 16    /* IRL0 .. IRL15 */
 
diff --git a/arch/sh/boards/superh/microdev/setup.c b/arch/sh/boards/superh/microdev/setup.c
index 1c1d65fb12df..892b14d31405 100644
--- a/arch/sh/boards/superh/microdev/setup.c
+++ b/arch/sh/boards/superh/microdev/setup.c
@@ -3,7 +3,7 @@
  *
  * Copyright (C) 2003 Sean McGoogan (Sean.McGoogan@superh.com)
  * Copyright (C) 2003, 2004 SuperH, Inc.
- * Copyright (C) 2004 Paul Mundt
+ * Copyright (C) 2004, 2005 Paul Mundt
  *
  * SuperH SH4-202 MicroDev board support.
  *
@@ -15,11 +15,10 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/ioport.h>
+#include <video/s1d13xxxfb.h>
+#include <asm/microdev.h>
 #include <asm/io.h>
-#include <asm/mach/irq.h>
-#include <asm/mach/io.h>
 #include <asm/machvec.h>
-#include <asm/machvec_init.h>
 
 extern void microdev_heartbeat(void);
 
@@ -51,8 +50,6 @@ struct sh_machine_vector mv_sh4202_microdev __initmv = {
         .mv_outsw               = microdev_outsw,
         .mv_outsl               = microdev_outsl,
 
-        .mv_isa_port2addr       = microdev_isa_port2addr,
-
         .mv_init_irq            = init_microdev_irq,
 
 #ifdef CONFIG_HEARTBEAT
@@ -142,16 +139,161 @@ static struct platform_device smc91x_device = {
         .resource       = smc91x_resources,
 };
 
-static int __init smc91x_setup(void)
+#ifdef CONFIG_FB_S1D13XXX
+static struct s1d13xxxfb_regval s1d13806_initregs[] = {
+        { S1DREG_MISC,                  0x00 },
+        { S1DREG_COM_DISP_MODE,         0x00 },
+        { S1DREG_GPIO_CNF0,             0x00 },
+        { S1DREG_GPIO_CNF1,             0x00 },
+        { S1DREG_GPIO_CTL0,             0x00 },
+        { S1DREG_GPIO_CTL1,             0x00 },
+        { S1DREG_CLK_CNF,               0x02 },
+        { S1DREG_LCD_CLK_CNF,           0x01 },
+        { S1DREG_CRT_CLK_CNF,           0x03 },
+        { S1DREG_MPLUG_CLK_CNF,         0x03 },
+        { S1DREG_CPU2MEM_WST_SEL,       0x02 },
+        { S1DREG_SDRAM_REF_RATE,        0x03 },
+        { S1DREG_SDRAM_TC0,             0x00 },
+        { S1DREG_SDRAM_TC1,             0x01 },
+        { S1DREG_MEM_CNF,               0x80 },
+        { S1DREG_PANEL_TYPE,            0x25 },
+        { S1DREG_MOD_RATE,              0x00 },
+        { S1DREG_LCD_DISP_HWIDTH,       0x63 },
+        { S1DREG_LCD_NDISP_HPER,        0x1e },
+        { S1DREG_TFT_FPLINE_START,      0x06 },
+        { S1DREG_TFT_FPLINE_PWIDTH,     0x03 },
+        { S1DREG_LCD_DISP_VHEIGHT0,     0x57 },
+        { S1DREG_LCD_DISP_VHEIGHT1,     0x02 },
+        { S1DREG_LCD_NDISP_VPER,        0x00 },
+        { S1DREG_TFT_FPFRAME_START,     0x0a },
+        { S1DREG_TFT_FPFRAME_PWIDTH,    0x81 },
+        { S1DREG_LCD_DISP_MODE,         0x03 },
+        { S1DREG_LCD_MISC,              0x00 },
+        { S1DREG_LCD_DISP_START0,       0x00 },
+        { S1DREG_LCD_DISP_START1,       0x00 },
+        { S1DREG_LCD_DISP_START2,       0x00 },
+        { S1DREG_LCD_MEM_OFF0,          0x90 },
+        { S1DREG_LCD_MEM_OFF1,          0x01 },
+        { S1DREG_LCD_PIX_PAN,           0x00 },
+        { S1DREG_LCD_DISP_FIFO_HTC,     0x00 },
+        { S1DREG_LCD_DISP_FIFO_LTC,     0x00 },
+        { S1DREG_CRT_DISP_HWIDTH,       0x63 },
+        { S1DREG_CRT_NDISP_HPER,        0x1f },
+        { S1DREG_CRT_HRTC_START,        0x04 },
+        { S1DREG_CRT_HRTC_PWIDTH,       0x8f },
+        { S1DREG_CRT_DISP_VHEIGHT0,     0x57 },
+        { S1DREG_CRT_DISP_VHEIGHT1,     0x02 },
+        { S1DREG_CRT_NDISP_VPER,        0x1b },
+        { S1DREG_CRT_VRTC_START,        0x00 },
+        { S1DREG_CRT_VRTC_PWIDTH,       0x83 },
+        { S1DREG_TV_OUT_CTL,            0x10 },
+        { S1DREG_CRT_DISP_MODE,         0x05 },
+        { S1DREG_CRT_DISP_START0,       0x00 },
+        { S1DREG_CRT_DISP_START1,       0x00 },
+        { S1DREG_CRT_DISP_START2,       0x00 },
+        { S1DREG_CRT_MEM_OFF0,          0x20 },
+        { S1DREG_CRT_MEM_OFF1,          0x03 },
+        { S1DREG_CRT_PIX_PAN,           0x00 },
+        { S1DREG_CRT_DISP_FIFO_HTC,     0x00 },
+        { S1DREG_CRT_DISP_FIFO_LTC,     0x00 },
+        { S1DREG_LCD_CUR_CTL,           0x00 },
+        { S1DREG_LCD_CUR_START,         0x01 },
+        { S1DREG_LCD_CUR_XPOS0,         0x00 },
+        { S1DREG_LCD_CUR_XPOS1,         0x00 },
+        { S1DREG_LCD_CUR_YPOS0,         0x00 },
+        { S1DREG_LCD_CUR_YPOS1,         0x00 },
+        { S1DREG_LCD_CUR_BCTL0,         0x00 },
+        { S1DREG_LCD_CUR_GCTL0,         0x00 },
+        { S1DREG_LCD_CUR_RCTL0,         0x00 },
+        { S1DREG_LCD_CUR_BCTL1,         0x1f },
+        { S1DREG_LCD_CUR_GCTL1,         0x3f },
+        { S1DREG_LCD_CUR_RCTL1,         0x1f },
+        { S1DREG_LCD_CUR_FIFO_HTC,      0x00 },
+        { S1DREG_CRT_CUR_CTL,           0x00 },
+        { S1DREG_CRT_CUR_START,         0x01 },
+        { S1DREG_CRT_CUR_XPOS0,         0x00 },
+        { S1DREG_CRT_CUR_XPOS1,         0x00 },
+        { S1DREG_CRT_CUR_YPOS0,         0x00 },
+        { S1DREG_CRT_CUR_YPOS1,         0x00 },
+        { S1DREG_CRT_CUR_BCTL0,         0x00 },
+        { S1DREG_CRT_CUR_GCTL0,         0x00 },
+        { S1DREG_CRT_CUR_RCTL0,         0x00 },
+        { S1DREG_CRT_CUR_BCTL1,         0x1f },
+        { S1DREG_CRT_CUR_GCTL1,         0x3f },
+        { S1DREG_CRT_CUR_RCTL1,         0x1f },
+        { S1DREG_CRT_CUR_FIFO_HTC,      0x00 },
+        { S1DREG_BBLT_CTL0,             0x00 },
+        { S1DREG_BBLT_CTL1,             0x00 },
+        { S1DREG_BBLT_CC_EXP,           0x00 },
+        { S1DREG_BBLT_OP,               0x00 },
+        { S1DREG_BBLT_SRC_START0,       0x00 },
+        { S1DREG_BBLT_SRC_START1,       0x00 },
+        { S1DREG_BBLT_SRC_START2,       0x00 },
+        { S1DREG_BBLT_DST_START0,       0x00 },
+        { S1DREG_BBLT_DST_START1,       0x00 },
+        { S1DREG_BBLT_DST_START2,       0x00 },
+        { S1DREG_BBLT_MEM_OFF0,         0x00 },
+        { S1DREG_BBLT_MEM_OFF1,         0x00 },
+        { S1DREG_BBLT_WIDTH0,           0x00 },
+        { S1DREG_BBLT_WIDTH1,           0x00 },
+        { S1DREG_BBLT_HEIGHT0,          0x00 },
+        { S1DREG_BBLT_HEIGHT1,          0x00 },
+        { S1DREG_BBLT_BGC0,             0x00 },
+        { S1DREG_BBLT_BGC1,             0x00 },
+        { S1DREG_BBLT_FGC0,             0x00 },
+        { S1DREG_BBLT_FGC1,             0x00 },
+        { S1DREG_LKUP_MODE,             0x00 },
+        { S1DREG_LKUP_ADDR,             0x00 },
+        { S1DREG_PS_CNF,                0x10 },
+        { S1DREG_PS_STATUS,             0x00 },
+        { S1DREG_CPU2MEM_WDOGT,         0x00 },
+        { S1DREG_COM_DISP_MODE,         0x02 },
+};
+
+static struct s1d13xxxfb_pdata s1d13806_platform_data = {
+        .initregs       = s1d13806_initregs,
+        .initregssize   = ARRAY_SIZE(s1d13806_initregs),
+};
+
+static struct resource s1d13806_resources[] = {
+        [0] = {
+                .start          = 0x07200000,
+                .end            = 0x07200000 + 0x00200000 - 1,
+                .flags          = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start          = 0x07000000,
+                .end            = 0x07000000 + 0x00200000 - 1,
+                .flags          = IORESOURCE_MEM,
+        },
+};
+
+static struct platform_device s1d13806_device = {
+        .name           = "s1d13806fb",
+        .id             = -1,
+        .num_resources  = ARRAY_SIZE(s1d13806_resources),
+        .resource       = s1d13806_resources,
+
+        .dev = {
+                .platform_data  = &s1d13806_platform_data,
+        },
+};
+#endif
+
+static struct platform_device *microdev_devices[] __initdata = {
+        &smc91x_device,
+#ifdef CONFIG_FB_S1D13XXX
+        &s1d13806_device,
+#endif
+};
+
+static int __init microdev_devices_setup(void)
 {
-        return platform_device_register(&smc91x_device);
+        return platform_add_devices(microdev_devices, ARRAY_SIZE(microdev_devices));
 }
 
-__initcall(smc91x_setup);
+__initcall(microdev_devices_setup);
 
-        /*
-         * Initialize the board
-         */
 void __init platform_setup(void)
 {
         int * const fpgaRevisionRegister = (int*)(MICRODEV_FPGA_GP_BASE + 0x8ul);
diff --git a/arch/sh/boards/unknown/Makefile b/arch/sh/boards/unknown/Makefile
index cffc21031e71..7d18f408b0c5 100644
--- a/arch/sh/boards/unknown/Makefile
+++ b/arch/sh/boards/unknown/Makefile
@@ -2,5 +2,5 @@
 # Makefile for unknown SH boards 
 #
 
-obj-y    := mach.o io.o setup.o
+obj-y    := setup.o
 
diff --git a/arch/sh/boards/unknown/io.c b/arch/sh/boards/unknown/io.c
deleted file mode 100644
index 8f3f17267bd9..000000000000
--- a/arch/sh/boards/unknown/io.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * linux/arch/sh/kernel/io_unknown.c
- *
- * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com)
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * I/O routine for unknown hardware.
- */
-
-static unsigned int unknown_handler(void)
-{
-        return 0;
-}
-
-#define UNKNOWN_ALIAS(fn) \
-        void unknown_##fn(void) __attribute__ ((alias ("unknown_handler")));
-
-UNKNOWN_ALIAS(inb)
-UNKNOWN_ALIAS(inw)
-UNKNOWN_ALIAS(inl)
-UNKNOWN_ALIAS(outb)
-UNKNOWN_ALIAS(outw)
-UNKNOWN_ALIAS(outl)
-UNKNOWN_ALIAS(inb_p)
-UNKNOWN_ALIAS(inw_p)
-UNKNOWN_ALIAS(inl_p)
-UNKNOWN_ALIAS(outb_p)
-UNKNOWN_ALIAS(outw_p)
-UNKNOWN_ALIAS(outl_p)
-UNKNOWN_ALIAS(insb)
-UNKNOWN_ALIAS(insw)
-UNKNOWN_ALIAS(insl)
-UNKNOWN_ALIAS(outsb)
-UNKNOWN_ALIAS(outsw)
-UNKNOWN_ALIAS(outsl)
-UNKNOWN_ALIAS(readb)
-UNKNOWN_ALIAS(readw)
-UNKNOWN_ALIAS(readl)
-UNKNOWN_ALIAS(writeb)
-UNKNOWN_ALIAS(writew)
-UNKNOWN_ALIAS(writel)
-UNKNOWN_ALIAS(isa_port2addr)
-UNKNOWN_ALIAS(ioremap)
-UNKNOWN_ALIAS(iounmap)
diff --git a/arch/sh/boards/unknown/mach.c b/arch/sh/boards/unknown/mach.c
deleted file mode 100644
index ad0bcc60a640..000000000000
--- a/arch/sh/boards/unknown/mach.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * linux/arch/sh/kernel/mach_unknown.c
- *
- * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com)
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * Machine specific code for an unknown machine (internal peripherials only)
- */
-
-#include <linux/config.h>
-#include <linux/init.h>
-
-#include <asm/machvec.h>
-#include <asm/machvec_init.h>
-
-#include <asm/io_unknown.h>
-
-#include <asm/rtc.h>
-/*
- * The Machine Vector
- */
-
-struct sh_machine_vector mv_unknown __initmv = {
-#if defined(CONFIG_CPU_SH4)
-        .mv_nr_irqs             = 48,
-#elif defined(CONFIG_CPU_SUBTYPE_SH7708)
-        .mv_nr_irqs             = 32,
-#elif defined(CONFIG_CPU_SUBTYPE_SH7709)
-        .mv_nr_irqs             = 61,
-#endif
-
-        .mv_inb                 = unknown_inb,
-        .mv_inw                 = unknown_inw,
-        .mv_inl                 = unknown_inl,
-        .mv_outb                = unknown_outb,
-        .mv_outw                = unknown_outw,
-        .mv_outl                = unknown_outl,
-
-        .mv_inb_p               = unknown_inb_p,
-        .mv_inw_p               = unknown_inw_p,
-        .mv_inl_p               = unknown_inl_p,
-        .mv_outb_p              = unknown_outb_p,
-        .mv_outw_p              = unknown_outw_p,
-        .mv_outl_p              = unknown_outl_p,
-
-        .mv_insb                = unknown_insb,
-        .mv_insw                = unknown_insw,
-        .mv_insl                = unknown_insl,
-        .mv_outsb               = unknown_outsb,
-        .mv_outsw               = unknown_outsw,
-        .mv_outsl               = unknown_outsl,
-
-        .mv_readb               = unknown_readb,
-        .mv_readw               = unknown_readw,
-        .mv_readl               = unknown_readl,
-        .mv_writeb              = unknown_writeb,
-        .mv_writew              = unknown_writew,
-        .mv_writel              = unknown_writel,
-
-        .mv_ioremap             = unknown_ioremap,
-        .mv_iounmap             = unknown_iounmap,
-
-        .mv_isa_port2addr       = unknown_isa_port2addr,
-};
-ALIAS_MV(unknown)
diff --git a/arch/sh/boards/unknown/setup.c b/arch/sh/boards/unknown/setup.c
index 7d772a6f8865..02e84f03f45c 100644
--- a/arch/sh/boards/unknown/setup.c
+++ b/arch/sh/boards/unknown/setup.c
@@ -7,10 +7,20 @@
  * License.  See linux/COPYING for more information.
  *
  * Setup code for an unknown machine (internal peripherials only)
+ *
+ * This is the simplest of all boards, and serves only as a quick and dirty
+ * method to start debugging a new board during bring-up until proper board
+ * setup code is written.
  */
-
 #include <linux/config.h>
 #include <linux/init.h>
+#include <asm/machvec.h>
+#include <asm/irq.h>
+
+struct sh_machine_vector mv_unknown __initmv = {
+        .mv_nr_irqs             = NR_IRQS,
+};
+ALIAS_MV(unknown)
 
 const char *get_system_type(void)
 {
diff --git a/arch/sh/cchips/voyagergx/consistent.c b/arch/sh/cchips/voyagergx/consistent.c
index 3d9a02c093a3..07e8b9c5a531 100644
--- a/arch/sh/cchips/voyagergx/consistent.c
+++ b/arch/sh/cchips/voyagergx/consistent.c
@@ -15,7 +15,7 @@
 #include <linux/module.h>
 #include <linux/device.h>
 #include <asm/io.h>
-#include <asm/bus-sh.h>
+
 
 struct voya_alloc_entry {
         struct list_head list;
@@ -30,12 +30,13 @@ static LIST_HEAD(voya_alloc_list);
 #define OHCI_HCCA_SIZE  0x100
 #define OHCI_SRAM_SIZE  0x10000
 
+#define VOYAGER_OHCI_NAME       "voyager-ohci"
+
 void *voyagergx_consistent_alloc(struct device *dev, size_t size,
                                  dma_addr_t *handle, gfp_t flag)
 {
         struct list_head *list = &voya_alloc_list;
         struct voya_alloc_entry *entry;
-        struct sh_dev *shdev = to_sh_dev(dev);
         unsigned long start, end;
         unsigned long flags;
 
@@ -46,9 +47,7 @@ void *voyagergx_consistent_alloc(struct device *dev, size_t size,
          *
          * Everything else goes through consistent_alloc().
          */
-        if (!dev || dev->bus != &sh_bus_types[SH_BUS_VIRT] ||
-                   (dev->bus == &sh_bus_types[SH_BUS_VIRT] &&
-                    shdev->dev_id != SH_DEV_ID_USB_OHCI))
+        if (!dev || strcmp(dev->driver->name, VOYAGER_OHCI_NAME))
                 return NULL;
 
         start = OHCI_SRAM_START + OHCI_HCCA_SIZE;
@@ -98,12 +97,9 @@ int voyagergx_consistent_free(struct device *dev, size_t size,
                               void *vaddr, dma_addr_t handle)
 {
         struct voya_alloc_entry *entry;
-        struct sh_dev *shdev = to_sh_dev(dev);
         unsigned long flags;
 
-        if (!dev || dev->bus != &sh_bus_types[SH_BUS_VIRT] ||
-                   (dev->bus == &sh_bus_types[SH_BUS_VIRT] &&
-                    shdev->dev_id != SH_DEV_ID_USB_OHCI))
+        if (!dev || strcmp(dev->driver->name, VOYAGER_OHCI_NAME))
                 return -EINVAL;
 
         spin_lock_irqsave(&voya_list_lock, flags);
@@ -123,4 +119,3 @@ int voyagergx_consistent_free(struct device *dev, size_t size,
 
 EXPORT_SYMBOL(voyagergx_consistent_alloc);
 EXPORT_SYMBOL(voyagergx_consistent_free);
-
diff --git a/arch/sh/cchips/voyagergx/irq.c b/arch/sh/cchips/voyagergx/irq.c
index 1b6ac523b458..2ee330b3c38f 100644
--- a/arch/sh/cchips/voyagergx/irq.c
+++ b/arch/sh/cchips/voyagergx/irq.c
@@ -163,7 +163,12 @@ int voyagergx_irq_demux(int irq)
         return irq;
 }
 
-static struct irqaction irq0  = { voyagergx_interrupt, SA_INTERRUPT, 0, "VOYAGERGX", NULL, NULL};
+static struct irqaction irq0  = {
+        .name           = "voyagergx",
+        .handler        = voyagergx_interrupt,
+        .flags          = SA_INTERRUPT,
+        .mask           = CPU_MASK_NONE,
+};
 
 void __init setup_voyagergx_irq(void)
 {
diff --git a/arch/sh/configs/microdev_defconfig b/arch/sh/configs/microdev_defconfig
index a3bd280b53d6..ab3db76d1e51 100644
--- a/arch/sh/configs/microdev_defconfig
+++ b/arch/sh/configs/microdev_defconfig
@@ -1,10 +1,9 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.11-sh
-# Wed Mar  2 15:09:41 2005
+# Linux kernel version: 2.6.16-rc1
+# Fri Jan 27 19:43:20 2006
 #
 CONFIG_SUPERH=y
-CONFIG_UID16=y
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_HARDIRQS=y
 CONFIG_GENERIC_IRQ_PROBE=y
@@ -17,11 +16,13 @@ CONFIG_EXPERIMENTAL=y
 CONFIG_CLEAN_COMPILE=y
 CONFIG_BROKEN_ON_SMP=y
 CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
 
 #
 # General setup
 #
 CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 # CONFIG_SYSVIPC is not set
 # CONFIG_POSIX_MQUEUE is not set
@@ -29,22 +30,29 @@ CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
-CONFIG_LOG_BUF_SHIFT=14
-CONFIG_HOTPLUG=y
-CONFIG_KOBJECT_UEVENT=y
 # CONFIG_IKCONFIG is not set
+CONFIG_INITRAMFS_SOURCE=""
+CONFIG_UID16=y
+# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_EMBEDDED=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_ELF_CORE=y
+CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
-# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SHMEM=y
 CONFIG_CC_ALIGN_FUNCTIONS=0
 CONFIG_CC_ALIGN_LABELS=0
 CONFIG_CC_ALIGN_LOOPS=0
 CONFIG_CC_ALIGN_JUMPS=0
+CONFIG_SLAB=y
 # CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
+# CONFIG_SLOB is not set
 
 #
 # Loadable module support
@@ -52,6 +60,24 @@ CONFIG_CC_ALIGN_JUMPS=0
 # CONFIG_MODULES is not set
 
 #
+# Block layer
+#
+# CONFIG_LBD is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_DEFAULT_AS=y
+# CONFIG_DEFAULT_DEADLINE is not set
+# CONFIG_DEFAULT_CFQ is not set
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="anticipatory"
+
+#
 # System type
 #
 # CONFIG_SH_SOLUTION_ENGINE is not set
@@ -61,9 +87,7 @@ CONFIG_CC_ALIGN_JUMPS=0
 # CONFIG_SH_7751_SYSTEMH is not set
 # CONFIG_SH_STB1_HARP is not set
 # CONFIG_SH_STB1_OVERDRIVE is not set
-# CONFIG_SH_HP620 is not set
-# CONFIG_SH_HP680 is not set
-# CONFIG_SH_HP690 is not set
+# CONFIG_SH_HP6XX is not set
 # CONFIG_SH_CQREEK is not set
 # CONFIG_SH_DMIDA is not set
 # CONFIG_SH_EC3104 is not set
@@ -78,45 +102,94 @@ CONFIG_CC_ALIGN_JUMPS=0
 # CONFIG_SH_SECUREEDGE5410 is not set
 # CONFIG_SH_HS7751RVOIP is not set
 # CONFIG_SH_RTS7751R2D is not set
+# CONFIG_SH_R7780RP is not set
 # CONFIG_SH_EDOSK7705 is not set
 CONFIG_SH_SH4202_MICRODEV=y
+# CONFIG_SH_LANDISK is not set
+# CONFIG_SH_TITAN is not set
 # CONFIG_SH_UNKNOWN is not set
-# CONFIG_CPU_SH2 is not set
-# CONFIG_CPU_SH3 is not set
+
+#
+# Processor selection
+#
 CONFIG_CPU_SH4=y
+
+#
+# SH-2 Processor Support
+#
 # CONFIG_CPU_SUBTYPE_SH7604 is not set
+
+#
+# SH-3 Processor Support
+#
 # CONFIG_CPU_SUBTYPE_SH7300 is not set
 # CONFIG_CPU_SUBTYPE_SH7705 is not set
 # CONFIG_CPU_SUBTYPE_SH7707 is not set
 # CONFIG_CPU_SUBTYPE_SH7708 is not set
 # CONFIG_CPU_SUBTYPE_SH7709 is not set
+
+#
+# SH-4 Processor Support
+#
 # CONFIG_CPU_SUBTYPE_SH7750 is not set
+# CONFIG_CPU_SUBTYPE_SH7091 is not set
+# CONFIG_CPU_SUBTYPE_SH7750R is not set
+# CONFIG_CPU_SUBTYPE_SH7750S is not set
 # CONFIG_CPU_SUBTYPE_SH7751 is not set
+# CONFIG_CPU_SUBTYPE_SH7751R is not set
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
-# CONFIG_CPU_SUBTYPE_SH73180 is not set
+CONFIG_CPU_SUBTYPE_SH4_202=y
+
+#
+# ST40 Processor Support
+#
 # CONFIG_CPU_SUBTYPE_ST40STB1 is not set
 # CONFIG_CPU_SUBTYPE_ST40GX1 is not set
-CONFIG_CPU_SUBTYPE_SH4_202=y
+
+#
+# SH-4A Processor Support
+#
+# CONFIG_CPU_SUBTYPE_SH73180 is not set
+# CONFIG_CPU_SUBTYPE_SH7770 is not set
+# CONFIG_CPU_SUBTYPE_SH7780 is not set
+
+#
+# Memory management options
+#
 CONFIG_MMU=y
-CONFIG_CMDLINE_BOOL=y
-CONFIG_CMDLINE="console=ttySC0,115200"
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPLIT_PTLOCK_CPUS=4
+
+#
+# Cache configuration
+#
+# CONFIG_SH_DIRECT_MAPPED is not set
+# CONFIG_SH_WRITETHROUGH is not set
+# CONFIG_SH_OCRAM is not set
 CONFIG_MEMORY_START=0x08000000
 CONFIG_MEMORY_SIZE=0x04000000
-CONFIG_MEMORY_SET=y
-# CONFIG_MEMORY_OVERRIDE is not set
+
+#
+# Processor features
+#
+CONFIG_CPU_LITTLE_ENDIAN=y
 CONFIG_SH_RTC=y
 CONFIG_SH_FPU=y
-CONFIG_ZERO_PAGE_OFFSET=0x00001000
-CONFIG_BOOT_LINK_OFFSET=0x00800000
-CONFIG_CPU_LITTLE_ENDIAN=y
-CONFIG_PREEMPT=y
-# CONFIG_UBC_WAKEUP is not set
-# CONFIG_SH_WRITETHROUGH is not set
-# CONFIG_SH_OCRAM is not set
 # CONFIG_SH_STORE_QUEUES is not set
-# CONFIG_SMP is not set
-CONFIG_SH_PCLK_CALC=y
-CONFIG_SH_PCLK_FREQ=65986048
+CONFIG_CPU_HAS_INTEVT=y
+CONFIG_CPU_HAS_SR_RB=y
+
+#
+# Timer support
+#
+CONFIG_SH_TMU=y
+CONFIG_SH_PCLK_FREQ=66000000
 
 #
 # CPU Frequency scaling
@@ -137,20 +210,31 @@ CONFIG_NR_ONCHIP_DMA_CHANNELS=4
 CONFIG_HEARTBEAT=y
 
 #
-# Bus options (PCI, PCMCIA, EISA, MCA, ISA)
+# Kernel features
 #
-CONFIG_ISA=y
-# CONFIG_PCI is not set
+# CONFIG_KEXEC is not set
+CONFIG_PREEMPT=y
+# CONFIG_SMP is not set
 
 #
-# PCCARD (PCMCIA/CardBus) support
+# Boot options
 #
-# CONFIG_PCCARD is not set
+CONFIG_ZERO_PAGE_OFFSET=0x00001000
+CONFIG_BOOT_LINK_OFFSET=0x00800000
+# CONFIG_UBC_WAKEUP is not set
+CONFIG_CMDLINE_BOOL=y
+CONFIG_CMDLINE="console=ttySC0,115200"
 
 #
-# PC-card bridges
+# Bus options
 #
-CONFIG_PCMCIA_PROBE=y
+# CONFIG_SUPERHYWAY is not set
+# CONFIG_PCI is not set
+
+#
+# PCCARD (PCMCIA/CardBus) support
+#
+# CONFIG_PCCARD is not set
 
 #
 # PCI Hotplug Support
@@ -164,9 +248,79 @@ CONFIG_BINFMT_ELF=y
 # CONFIG_BINFMT_MISC is not set
 
 #
-# SH initrd options
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+# CONFIG_PACKET is not set
+# CONFIG_UNIX is not set
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+CONFIG_IP_PNP=y
+CONFIG_IP_PNP_DHCP=y
+# CONFIG_IP_PNP_BOOTP is not set
+# CONFIG_IP_PNP_RARP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+# CONFIG_IPV6 is not set
+# CONFIG_NETFILTER is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
 #
-# CONFIG_EMBEDDED_RAMDISK is not set
+# CONFIG_IP_SCTP is not set
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+
+#
+# QoS and/or fair queueing
+#
+# CONFIG_NET_SCHED is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
 
 #
 # Device Drivers
@@ -180,6 +334,11 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 # CONFIG_FW_LOADER is not set
 
 #
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
 # Memory Technology Devices (MTD)
 #
 # CONFIG_MTD is not set
@@ -192,13 +351,10 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 #
 # Plug and Play support
 #
-# CONFIG_PNP is not set
 
 #
 # Block devices
 #
-# CONFIG_BLK_DEV_FD is not set
-# CONFIG_BLK_DEV_XD is not set
 # CONFIG_BLK_DEV_COW_COMMON is not set
 # CONFIG_BLK_DEV_LOOP is not set
 # CONFIG_BLK_DEV_NBD is not set
@@ -206,17 +362,7 @@ CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
 CONFIG_BLK_DEV_INITRD=y
-CONFIG_INITRAMFS_SOURCE=""
-# CONFIG_LBD is not set
 # CONFIG_CDROM_PKTCDVD is not set
-
-#
-# IO Schedulers
-#
-CONFIG_IOSCHED_NOOP=y
-CONFIG_IOSCHED_AS=y
-CONFIG_IOSCHED_DEADLINE=y
-CONFIG_IOSCHED_CFQ=y
 # CONFIG_ATA_OVER_ETH is not set
 
 #
@@ -241,9 +387,7 @@ CONFIG_BLK_DEV_IDECD=y
 # IDE chipset support/bugfixes
 #
 CONFIG_IDE_GENERIC=y
-CONFIG_IDE_SH=y
 # CONFIG_IDE_ARM is not set
-# CONFIG_IDE_CHIPSETS is not set
 # CONFIG_BLK_DEV_IDEDMA is not set
 # CONFIG_IDEDMA_AUTO is not set
 # CONFIG_BLK_DEV_HD is not set
@@ -251,14 +395,10 @@ CONFIG_IDE_SH=y
 #
 # SCSI device support
 #
+# CONFIG_RAID_ATTRS is not set
 # CONFIG_SCSI is not set
 
 #
-# Old CD-ROM drivers (not SCSI, not IDE)
-#
-# CONFIG_CD_NO_IDESCSI is not set
-
-#
 # Multi-device support (RAID and LVM)
 #
 # CONFIG_MD is not set
@@ -266,6 +406,7 @@ CONFIG_IDE_SH=y
 #
 # Fusion MPT device support
 #
+# CONFIG_FUSION is not set
 
 #
 # IEEE 1394 (FireWire) support
@@ -276,69 +417,8 @@ CONFIG_IDE_SH=y
 #
 
 #
-# Networking support
-#
-CONFIG_NET=y
-
-#
-# Networking options
-#
-# CONFIG_PACKET is not set
-# CONFIG_NETLINK_DEV is not set
-# CONFIG_UNIX is not set
-# CONFIG_NET_KEY is not set
-CONFIG_INET=y
-# CONFIG_IP_MULTICAST is not set
-# CONFIG_IP_ADVANCED_ROUTER is not set
-CONFIG_IP_PNP=y
-CONFIG_IP_PNP_DHCP=y
-# CONFIG_IP_PNP_BOOTP is not set
-# CONFIG_IP_PNP_RARP is not set
-# CONFIG_NET_IPIP is not set
-# CONFIG_NET_IPGRE is not set
-# CONFIG_ARPD is not set
-# CONFIG_SYN_COOKIES is not set
-# CONFIG_INET_AH is not set
-# CONFIG_INET_ESP is not set
-# CONFIG_INET_IPCOMP is not set
-# CONFIG_INET_TUNNEL is not set
-CONFIG_IP_TCPDIAG=y
-# CONFIG_IP_TCPDIAG_IPV6 is not set
-# CONFIG_IPV6 is not set
-# CONFIG_NETFILTER is not set
-
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
-# CONFIG_IP_SCTP is not set
-# CONFIG_ATM is not set
-# CONFIG_BRIDGE is not set
-# CONFIG_VLAN_8021Q is not set
-# CONFIG_DECNET is not set
-# CONFIG_LLC2 is not set
-# CONFIG_IPX is not set
-# CONFIG_ATALK is not set
-# CONFIG_X25 is not set
-# CONFIG_LAPB is not set
-# CONFIG_NET_DIVERT is not set
-# CONFIG_ECONET is not set
-# CONFIG_WAN_ROUTER is not set
-
-#
-# QoS and/or fair queueing
-#
-# CONFIG_NET_SCHED is not set
-# CONFIG_NET_CLS_ROUTE is not set
-
-#
-# Network testing
+# Network device support
 #
-# CONFIG_NET_PKTGEN is not set
-# CONFIG_NETPOLL is not set
-# CONFIG_NET_POLL_CONTROLLER is not set
-# CONFIG_HAMRADIO is not set
-# CONFIG_IRDA is not set
-# CONFIG_BT is not set
 CONFIG_NETDEVICES=y
 # CONFIG_DUMMY is not set
 # CONFIG_BONDING is not set
@@ -346,9 +426,9 @@ CONFIG_NETDEVICES=y
 # CONFIG_TUN is not set
 
 #
-# ARCnet devices
+# PHY device support
 #
-# CONFIG_ARCNET is not set
+# CONFIG_PHYLIB is not set
 
 #
 # Ethernet (10 or 100Mbit)
@@ -356,17 +436,7 @@ CONFIG_NETDEVICES=y
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=y
 # CONFIG_STNIC is not set
-# CONFIG_NET_VENDOR_3COM is not set
-# CONFIG_LANCE is not set
-# CONFIG_NET_VENDOR_SMC is not set
 CONFIG_SMC91X=y
-# CONFIG_NET_VENDOR_RACAL is not set
-# CONFIG_AT1700 is not set
-# CONFIG_DEPCA is not set
-# CONFIG_HP100 is not set
-# CONFIG_NET_ISA is not set
-# CONFIG_NET_PCI is not set
-# CONFIG_NET_POCKET is not set
 
 #
 # Ethernet (1000 Mbit)
@@ -379,7 +449,6 @@ CONFIG_SMC91X=y
 #
 # Token Ring devices
 #
-# CONFIG_TR is not set
 
 #
 # Wireless LAN (non-hamradio)
@@ -394,6 +463,8 @@ CONFIG_SMC91X=y
 # CONFIG_SLIP is not set
 # CONFIG_SHAPER is not set
 # CONFIG_NETCONSOLE is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
 
 #
 # ISDN subsystem
@@ -411,20 +482,10 @@ CONFIG_SMC91X=y
 # CONFIG_INPUT is not set
 
 #
-# Userland interfaces
-#
-
-#
-# Input I/O drivers
+# Hardware I/O ports
 #
-# CONFIG_GAMEPORT is not set
-CONFIG_SOUND_GAMEPORT=y
 # CONFIG_SERIO is not set
-# CONFIG_SERIO_I8042 is not set
-
-#
-# Input Device Drivers
-#
+# CONFIG_GAMEPORT is not set
 
 #
 # Character devices
@@ -464,24 +525,46 @@ CONFIG_RTC=y
 #
 # Ftape, the floppy tape device driver
 #
-# CONFIG_DRM is not set
 # CONFIG_RAW_DRIVER is not set
 
 #
+# TPM devices
+#
+# CONFIG_TCG_TPM is not set
+# CONFIG_TELCLOCK is not set
+
+#
 # I2C support
 #
 # CONFIG_I2C is not set
 
 #
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
 # Dallas's 1-wire bus
 #
 # CONFIG_W1 is not set
 
 #
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
 # Misc devices
 #
 
 #
+# Multimedia Capabilities Port drivers
+#
+
+#
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
@@ -508,7 +591,7 @@ CONFIG_RTC=y
 # CONFIG_USB_ARCH_HAS_OHCI is not set
 
 #
-# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' may also be needed; see USB_STORAGE Help for more information
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
 #
 
 #
@@ -524,13 +607,21 @@ CONFIG_RTC=y
 #
 # InfiniBand support
 #
-# CONFIG_INFINIBAND is not set
+
+#
+# SN Devices
+#
+
+#
+# EDAC - error detection and reporting (RAS)
+#
 
 #
 # File systems
 #
 CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
+# CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
@@ -540,17 +631,17 @@ CONFIG_JBD=y
 CONFIG_FS_MBCACHE=y
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
-
-#
-# XFS support
-#
+# CONFIG_FS_POSIX_ACL is not set
 # CONFIG_XFS_FS is not set
+# CONFIG_OCFS2_FS is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
+CONFIG_INOTIFY=y
 # CONFIG_QUOTA is not set
 CONFIG_DNOTIFY=y
 # CONFIG_AUTOFS_FS is not set
 # CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
 
 #
 # CD-ROM/DVD Filesystems
@@ -574,16 +665,12 @@ CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 CONFIG_PROC_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_SYSFS=y
-CONFIG_DEVFS_FS=y
-CONFIG_DEVFS_MOUNT=y
-# CONFIG_DEVFS_DEBUG is not set
-CONFIG_DEVPTS_FS_XATTR=y
-# CONFIG_DEVPTS_FS_SECURITY is not set
 CONFIG_TMPFS=y
-# CONFIG_TMPFS_XATTR is not set
 # CONFIG_HUGETLBFS is not set
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
+# CONFIG_CONFIGFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -607,12 +694,14 @@ CONFIG_RAMFS=y
 #
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
 CONFIG_NFS_V4=y
 # CONFIG_NFS_DIRECTIO is not set
 # CONFIG_NFSD is not set
 CONFIG_ROOT_NFS=y
 CONFIG_LOCKD=y
 CONFIG_LOCKD_V4=y
+CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=y
 CONFIG_SUNRPC_GSS=y
 CONFIG_RPCSEC_GSS_KRB5=y
@@ -622,6 +711,7 @@ CONFIG_RPCSEC_GSS_KRB5=y
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
 
 #
 # Partition Types
@@ -681,8 +771,10 @@ CONFIG_NLS_DEFAULT="iso8859-1"
 #
 # Kernel hacking
 #
+# CONFIG_PRINTK_TIME is not set
+# CONFIG_MAGIC_SYSRQ is not set
 # CONFIG_DEBUG_KERNEL is not set
-CONFIG_DEBUG_PREEMPT=y
+CONFIG_LOG_BUF_SHIFT=14
 # CONFIG_FRAME_POINTER is not set
 # CONFIG_SH_STANDARD_BIOS is not set
 # CONFIG_EARLY_SCIF_CONSOLE is not set
@@ -706,6 +798,7 @@ CONFIG_CRYPTO_MD5=y
 # CONFIG_CRYPTO_SHA256 is not set
 # CONFIG_CRYPTO_SHA512 is not set
 # CONFIG_CRYPTO_WP512 is not set
+# CONFIG_CRYPTO_TGR192 is not set
 CONFIG_CRYPTO_DES=y
 # CONFIG_CRYPTO_BLOWFISH is not set
 # CONFIG_CRYPTO_TWOFISH is not set
@@ -730,5 +823,6 @@ CONFIG_CRYPTO_DES=y
 # Library routines
 #
 # CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
 CONFIG_CRC32=y
 # CONFIG_LIBCRC32C is not set
diff --git a/arch/sh/kernel/Makefile b/arch/sh/kernel/Makefile
index 7a86eeb22655..f05cd96f8867 100644
--- a/arch/sh/kernel/Makefile
+++ b/arch/sh/kernel/Makefile
@@ -8,7 +8,7 @@ obj-y	:= process.o signal.o entry.o traps.o irq.o \
         ptrace.o setup.o time.o sys_sh.o semaphore.o \
         io.o io_generic.o sh_ksyms.o
 
-obj-y                           += cpu/
+obj-y                           += cpu/ timers/
 
 obj-$(CONFIG_SMP)               += smp.o
 obj-$(CONFIG_CF_ENABLER)        += cf-enabler.o
diff --git a/arch/sh/kernel/cpu/Makefile b/arch/sh/kernel/cpu/Makefile
index 5bfc33bec5d0..59d5b748752f 100644
--- a/arch/sh/kernel/cpu/Makefile
+++ b/arch/sh/kernel/cpu/Makefile
@@ -2,7 +2,7 @@
 # Makefile for the Linux/SuperH CPU-specifc backends.
 #
 
-obj-y   += irq/ init.o bus.o clock.o
+obj-y   += irq/ init.o clock.o
 
 obj-$(CONFIG_CPU_SH2)           += sh2/
 obj-$(CONFIG_CPU_SH3)           += sh3/
diff --git a/arch/sh/kernel/cpu/bus.c b/arch/sh/kernel/cpu/bus.c
deleted file mode 100644
index fc6c4bd40c65..000000000000
--- a/arch/sh/kernel/cpu/bus.c
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * arch/sh/kernel/cpu/bus.c
- *
- * Virtual bus for SuperH.
- *
- * Copyright (C) 2004 Paul Mundt
- *
- * Shamelessly cloned from arch/arm/mach-omap/bus.c, which was written
- * by:
- *
- *      Copyright (C) 2003 - 2004 Nokia Corporation
- *      Written by Tony Lindgren <tony@atomide.com>
- *      Portions of code based on sa1111.c.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- */
-#include <linux/kernel.h>
-#include <linux/device.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <asm/bus-sh.h>
-
-static int sh_bus_match(struct device *dev, struct device_driver *drv)
-{
-        struct sh_driver *shdrv = to_sh_driver(drv);
-        struct sh_dev *shdev = to_sh_dev(dev);
-
-        return shdev->dev_id == shdrv->dev_id;
-}
-
-static int sh_bus_suspend(struct device *dev, pm_message_t state)
-{
-        struct sh_dev *shdev = to_sh_dev(dev);
-        struct sh_driver *shdrv = to_sh_driver(dev->driver);
-
-        if (shdrv && shdrv->suspend)
-                return shdrv->suspend(shdev, state);
-
-        return 0;
-}
-
-static int sh_bus_resume(struct device *dev)
-{
-        struct sh_dev *shdev = to_sh_dev(dev);
-        struct sh_driver *shdrv = to_sh_driver(dev->driver);
-
-        if (shdrv && shdrv->resume)
-                return shdrv->resume(shdev);
-
-        return 0;
-}
-
-static int sh_device_probe(struct device *dev)
-{
-        struct sh_dev *shdev = to_sh_dev(dev);
-        struct sh_driver *shdrv = to_sh_driver(dev->driver);
-
-        if (shdrv && shdrv->probe)
-                return shdrv->probe(shdev);
-
-        return -ENODEV;
-}
-
-static int sh_device_remove(struct device *dev)
-{
-        struct sh_dev *shdev = to_sh_dev(dev);
-        struct sh_driver *shdrv = to_sh_driver(dev->driver);
-
-        if (shdrv && shdrv->remove)
-                return shdrv->remove(shdev);
-
-        return 0;
-}
-
-static struct device sh_bus_devices[SH_NR_BUSES] = {
-        {
-                .bus_id         = SH_BUS_NAME_VIRT,
-        },
-};
-
-struct bus_type sh_bus_types[SH_NR_BUSES] = {
-        {
-                .name           = SH_BUS_NAME_VIRT,
-                .match          = sh_bus_match,
-                .probe          = sh_bus_probe,
-                .remove         = sh_bus_remove,
-                .suspend        = sh_bus_suspend,
-                .resume         = sh_bus_resume,
-        },
-};
-
-int sh_device_register(struct sh_dev *dev)
-{
-        if (!dev)
-                return -EINVAL;
-
-        if (dev->bus_id < 0 || dev->bus_id >= SH_NR_BUSES) {
-                printk(KERN_ERR "%s: bus_id invalid: %s bus: %d\n",
-                       __FUNCTION__, dev->name, dev->bus_id);
-                return -EINVAL;
-        }
-
-        dev->dev.parent = &sh_bus_devices[dev->bus_id];
-        dev->dev.bus    = &sh_bus_types[dev->bus_id];
-
-        /* This is needed for USB OHCI to work */
-        if (dev->dma_mask)
-                dev->dev.dma_mask = dev->dma_mask;
-        if (dev->coherent_dma_mask)
-                dev->dev.coherent_dma_mask = dev->coherent_dma_mask;
-
-        snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%s%u",
-                 dev->name, dev->dev_id);
-
-        printk(KERN_INFO "Registering SH device '%s'. Parent at %s\n",
-               dev->dev.bus_id, dev->dev.parent->bus_id);
-
-        return device_register(&dev->dev);
-}
-
-void sh_device_unregister(struct sh_dev *dev)
-{
-        device_unregister(&dev->dev);
-}
-
-int sh_driver_register(struct sh_driver *drv)
-{
-        if (!drv)
-                return -EINVAL;
-
-        if (drv->bus_id < 0 || drv->bus_id >= SH_NR_BUSES) {
-                printk(KERN_ERR "%s: bus_id invalid: bus: %d device %d\n",
-                       __FUNCTION__, drv->bus_id, drv->dev_id);
-                return -EINVAL;
-        }
-
-        drv->drv.bus    = &sh_bus_types[drv->bus_id];
-
-        return driver_register(&drv->drv);
-}
-
-void sh_driver_unregister(struct sh_driver *drv)
-{
-        driver_unregister(&drv->drv);
-}
-
-static int __init sh_bus_init(void)
-{
-        int i, ret = 0;
-
-        for (i = 0; i < SH_NR_BUSES; i++) {
-                ret = device_register(&sh_bus_devices[i]);
-                if (ret != 0) {
-                        printk(KERN_ERR "Unable to register bus device %s\n",
-                               sh_bus_devices[i].bus_id);
-                        continue;
-                }
-
-                ret = bus_register(&sh_bus_types[i]);
-                if (ret != 0) {
-                        printk(KERN_ERR "Unable to register bus %s\n",
-                               sh_bus_types[i].name);
-                        device_unregister(&sh_bus_devices[i]);
-                }
-        }
-
-        printk(KERN_INFO "SH Virtual Bus initialized\n");
-
-        return ret;
-}
-
-static void __exit sh_bus_exit(void)
-{
-        int i;
-
-        for (i = 0; i < SH_NR_BUSES; i++) {
-                bus_unregister(&sh_bus_types[i]);
-                device_unregister(&sh_bus_devices[i]);
-        }
-}
-
-module_init(sh_bus_init);
-module_exit(sh_bus_exit);
-
-MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
-MODULE_DESCRIPTION("SH Virtual Bus");
-MODULE_LICENSE("GPL");
-
-EXPORT_SYMBOL(sh_bus_types);
-EXPORT_SYMBOL(sh_device_register);
-EXPORT_SYMBOL(sh_device_unregister);
-EXPORT_SYMBOL(sh_driver_register);
-EXPORT_SYMBOL(sh_driver_unregister);
-
diff --git a/arch/sh/kernel/cpu/clock.c b/arch/sh/kernel/cpu/clock.c
index 989e7fdd524d..97fa37f42b84 100644
--- a/arch/sh/kernel/cpu/clock.c
+++ b/arch/sh/kernel/cpu/clock.c
@@ -38,9 +38,7 @@ static DECLARE_MUTEX(clock_list_sem);
 static struct clk master_clk = {
         .name           = "master_clk",
         .flags          = CLK_ALWAYS_ENABLED | CLK_RATE_PROPAGATES,
-#ifdef CONFIG_SH_PCLK_FREQ_BOOL
         .rate           = CONFIG_SH_PCLK_FREQ,
-#endif
 };
 
 static struct clk module_clk = {
@@ -227,16 +225,7 @@ int __init clk_init(void)
 {
         int i, ret = 0;
 
-        if (unlikely(!master_clk.rate))
-                /*
-                 * NOTE: This will break if the default divisor has been
-                 * changed.
-                 *
-                 * No one should be changing the default on us however,
-                 * expect that a sane value for CONFIG_SH_PCLK_FREQ will
-                 * be defined in the event of a different divisor.
-                 */
-                master_clk.rate = get_timer_frequency() * 4;
+        BUG_ON(unlikely(!master_clk.rate));
 
         for (i = 0; i < ARRAY_SIZE(onchip_clocks); i++) {
                 struct clk *clk = onchip_clocks[i];
diff --git a/arch/sh/kernel/cpu/irq/ipr.c b/arch/sh/kernel/cpu/irq/ipr.c
index fdbd718ae5c6..e55150ed0856 100644
--- a/arch/sh/kernel/cpu/irq/ipr.c
+++ b/arch/sh/kernel/cpu/irq/ipr.c
@@ -108,8 +108,7 @@ static void end_ipr_irq(unsigned int irq)
                 enable_ipr_irq(irq);
 }
 
-void make_ipr_irq(unsigned int irq, unsigned int addr, int pos,
-                  int priority, int maskpos)
+void make_ipr_irq(unsigned int irq, unsigned int addr, int pos, int priority)
 {
         disable_irq_nosync(irq);
         ipr_data[irq].addr = addr;
@@ -123,44 +122,44 @@ void make_ipr_irq(unsigned int irq, unsigned int addr, int pos,
 void __init init_IRQ(void)
 {
 #ifndef CONFIG_CPU_SUBTYPE_SH7780
-        make_ipr_irq(TIMER_IRQ, TIMER_IPR_ADDR, TIMER_IPR_POS, TIMER_PRIORITY, 0);
-        make_ipr_irq(TIMER1_IRQ, TIMER1_IPR_ADDR, TIMER1_IPR_POS, TIMER1_PRIORITY, 0);
+        make_ipr_irq(TIMER_IRQ, TIMER_IPR_ADDR, TIMER_IPR_POS, TIMER_PRIORITY);
+        make_ipr_irq(TIMER1_IRQ, TIMER1_IPR_ADDR, TIMER1_IPR_POS, TIMER1_PRIORITY);
 #if defined(CONFIG_SH_RTC)
-        make_ipr_irq(RTC_IRQ, RTC_IPR_ADDR, RTC_IPR_POS, RTC_PRIORITY, 0);
+        make_ipr_irq(RTC_IRQ, RTC_IPR_ADDR, RTC_IPR_POS, RTC_PRIORITY);
 #endif
 
 #ifdef SCI_ERI_IRQ
-        make_ipr_irq(SCI_ERI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY, 0);
-        make_ipr_irq(SCI_RXI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY, 0);
-        make_ipr_irq(SCI_TXI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY, 0);
+        make_ipr_irq(SCI_ERI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY);
+        make_ipr_irq(SCI_RXI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY);
+        make_ipr_irq(SCI_TXI_IRQ, SCI_IPR_ADDR, SCI_IPR_POS, SCI_PRIORITY);
 #endif
 
 #ifdef SCIF1_ERI_IRQ
-        make_ipr_irq(SCIF1_ERI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY, 0);
-        make_ipr_irq(SCIF1_RXI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY, 0);
-        make_ipr_irq(SCIF1_BRI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY, 0);
-        make_ipr_irq(SCIF1_TXI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY, 0);
+        make_ipr_irq(SCIF1_ERI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY);
+        make_ipr_irq(SCIF1_RXI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY);
+        make_ipr_irq(SCIF1_BRI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY);
+        make_ipr_irq(SCIF1_TXI_IRQ, SCIF1_IPR_ADDR, SCIF1_IPR_POS, SCIF1_PRIORITY);
 #endif
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7300)
-        make_ipr_irq(SCIF0_IRQ, SCIF0_IPR_ADDR, SCIF0_IPR_POS, SCIF0_PRIORITY, 0);
-        make_ipr_irq(DMTE2_IRQ, DMA1_IPR_ADDR, DMA1_IPR_POS, DMA1_PRIORITY, 0);
-        make_ipr_irq(DMTE3_IRQ, DMA1_IPR_ADDR, DMA1_IPR_POS, DMA1_PRIORITY, 0);
-        make_ipr_irq(VIO_IRQ, VIO_IPR_ADDR, VIO_IPR_POS, VIO_PRIORITY, 0);
+        make_ipr_irq(SCIF0_IRQ, SCIF0_IPR_ADDR, SCIF0_IPR_POS, SCIF0_PRIORITY);
+        make_ipr_irq(DMTE2_IRQ, DMA1_IPR_ADDR, DMA1_IPR_POS, DMA1_PRIORITY);
+        make_ipr_irq(DMTE3_IRQ, DMA1_IPR_ADDR, DMA1_IPR_POS, DMA1_PRIORITY);
+        make_ipr_irq(VIO_IRQ, VIO_IPR_ADDR, VIO_IPR_POS, VIO_PRIORITY);
 #endif
 
 #ifdef SCIF_ERI_IRQ
-        make_ipr_irq(SCIF_ERI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY, 0);
-        make_ipr_irq(SCIF_RXI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY, 0);
-        make_ipr_irq(SCIF_BRI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY, 0);
-        make_ipr_irq(SCIF_TXI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY, 0);
+        make_ipr_irq(SCIF_ERI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY);
+        make_ipr_irq(SCIF_RXI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY);
+        make_ipr_irq(SCIF_BRI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY);
+        make_ipr_irq(SCIF_TXI_IRQ, SCIF_IPR_ADDR, SCIF_IPR_POS, SCIF_PRIORITY);
 #endif
 
 #ifdef IRDA_ERI_IRQ
-        make_ipr_irq(IRDA_ERI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY, 0);
-        make_ipr_irq(IRDA_RXI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY, 0);
-        make_ipr_irq(IRDA_BRI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY, 0);
-        make_ipr_irq(IRDA_TXI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY, 0);
+        make_ipr_irq(IRDA_ERI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY);
+        make_ipr_irq(IRDA_RXI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY);
+        make_ipr_irq(IRDA_BRI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY);
+        make_ipr_irq(IRDA_TXI_IRQ, IRDA_IPR_ADDR, IRDA_IPR_POS, IRDA_PRIORITY);
 #endif
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7707) || defined(CONFIG_CPU_SUBTYPE_SH7709) || \
@@ -175,12 +174,12 @@ void __init init_IRQ(void)
          * You should set corresponding bits of PFC to "00"
          * to enable these interrupts.
          */
-        make_ipr_irq(IRQ0_IRQ, IRQ0_IPR_ADDR, IRQ0_IPR_POS, IRQ0_PRIORITY, 0);
-        make_ipr_irq(IRQ1_IRQ, IRQ1_IPR_ADDR, IRQ1_IPR_POS, IRQ1_PRIORITY, 0);
-        make_ipr_irq(IRQ2_IRQ, IRQ2_IPR_ADDR, IRQ2_IPR_POS, IRQ2_PRIORITY, 0);
-        make_ipr_irq(IRQ3_IRQ, IRQ3_IPR_ADDR, IRQ3_IPR_POS, IRQ3_PRIORITY, 0);
-        make_ipr_irq(IRQ4_IRQ, IRQ4_IPR_ADDR, IRQ4_IPR_POS, IRQ4_PRIORITY, 0);
-        make_ipr_irq(IRQ5_IRQ, IRQ5_IPR_ADDR, IRQ5_IPR_POS, IRQ5_PRIORITY, 0);
+        make_ipr_irq(IRQ0_IRQ, IRQ0_IPR_ADDR, IRQ0_IPR_POS, IRQ0_PRIORITY);
+        make_ipr_irq(IRQ1_IRQ, IRQ1_IPR_ADDR, IRQ1_IPR_POS, IRQ1_PRIORITY);
+        make_ipr_irq(IRQ2_IRQ, IRQ2_IPR_ADDR, IRQ2_IPR_POS, IRQ2_PRIORITY);
+        make_ipr_irq(IRQ3_IRQ, IRQ3_IPR_ADDR, IRQ3_IPR_POS, IRQ3_PRIORITY);
+        make_ipr_irq(IRQ4_IRQ, IRQ4_IPR_ADDR, IRQ4_IPR_POS, IRQ4_PRIORITY);
+        make_ipr_irq(IRQ5_IRQ, IRQ5_IPR_ADDR, IRQ5_IPR_POS, IRQ5_PRIORITY);
 #endif
 #endif
 
diff --git a/arch/sh/kernel/entry.S b/arch/sh/kernel/entry.S
index fb6368159dd0..a440d36ee618 100644
--- a/arch/sh/kernel/entry.S
+++ b/arch/sh/kernel/entry.S
@@ -16,6 +16,7 @@
 #include <linux/config.h>
 #include <asm/asm-offsets.h>
 #include <asm/thread_info.h>
+#include <asm/cpu/mmu_context.h>
 #include <asm/unistd.h>
 
 #if !defined(CONFIG_NFSD) && !defined(CONFIG_NFSD_MODULE)
@@ -75,23 +76,6 @@
 ENOSYS = 38
 EINVAL = 22
 
-#if defined(CONFIG_CPU_SH3)
-TRA     = 0xffffffd0
-EXPEVT  = 0xffffffd4
-#if defined(CONFIG_CPU_SUBTYPE_SH7707) || defined(CONFIG_CPU_SUBTYPE_SH7709) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7300) || defined(CONFIG_CPU_SUBTYPE_SH7705)
-INTEVT  = 0xa4000000            ! INTEVTE2(0xa4000000)
-#else
-INTEVT  = 0xffffffd8
-#endif
-MMU_TEA = 0xfffffffc            ! TLB Exception Address Register
-#elif defined(CONFIG_CPU_SH4)
-TRA     = 0xff000020
-EXPEVT  = 0xff000024
-INTEVT  = 0xff000028
-MMU_TEA = 0xff00000c            ! TLB Exception Address Register
-#endif
-
 #if defined(CONFIG_KGDB_NMI)
 NMI_VEC = 0x1c0                 ! Must catch early for debounce
 #endif
diff --git a/arch/sh/kernel/process.c b/arch/sh/kernel/process.c
index a4dc2b532e10..9fd1723e6219 100644
--- a/arch/sh/kernel/process.c
+++ b/arch/sh/kernel/process.c
@@ -15,21 +15,18 @@
 #include <linux/unistd.h>
 #include <linux/mm.h>
 #include <linux/elfcore.h>
-#include <linux/slab.h>
 #include <linux/a.out.h>
+#include <linux/slab.h>
+#include <linux/pm.h>
 #include <linux/ptrace.h>
 #include <linux/platform.h>
 #include <linux/kallsyms.h>
+#include <linux/kexec.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
 #include <asm/elf.h>
-#if defined(CONFIG_SH_HS7751RVOIP)
-#include <asm/hs7751rvoip/hs7751rvoip.h>
-#elif defined(CONFIG_SH_RTS7751R2D)
-#include <asm/rts7751r2d/rts7751r2d.h>
-#endif
 
 static int hlt_counter=0;
 
@@ -37,6 +34,11 @@ int ubc_usercnt = 0;
 
 #define HARD_IDLE_TIMEOUT (HZ / 3)
 
+void (*pm_idle)(void);
+
+void (*pm_power_off)(void);
+EXPORT_SYMBOL(pm_power_off);
+
 void disable_hlt(void)
 {
         hlt_counter++;
@@ -51,17 +53,25 @@ void enable_hlt(void)
 
 EXPORT_SYMBOL(enable_hlt);
 
+void default_idle(void)
+{
+        if (!hlt_counter)
+                cpu_sleep();
+        else
+                cpu_relax();
+}
+
 void cpu_idle(void)
 {
         /* endless idle loop with no priority at all */
         while (1) {
-                if (hlt_counter) {
-                        while (!need_resched())
-                                cpu_relax();
-                } else {
-                        while (!need_resched())
-                                cpu_sleep();
-                }
+                void (*idle)(void) = pm_idle;
+
+                if (!idle)
+                        idle = default_idle;
+
+                while (!need_resched())
+                        idle();
 
                 preempt_enable_no_resched();
                 schedule();
@@ -88,28 +98,16 @@ void machine_restart(char * __unused)
 
 void machine_halt(void)
 {
-#if defined(CONFIG_SH_HS7751RVOIP)
-        unsigned short value;
+        local_irq_disable();
 
-        value = ctrl_inw(PA_OUTPORTR);
-        ctrl_outw((value & 0xffdf), PA_OUTPORTR);
-#elif defined(CONFIG_SH_RTS7751R2D)
-        ctrl_outw(0x0001, PA_POWOFF);
-#endif
         while (1)
                 cpu_sleep();
 }
 
 void machine_power_off(void)
 {
-#if defined(CONFIG_SH_HS7751RVOIP)
-        unsigned short value;
-
-        value = ctrl_inw(PA_OUTPORTR);
-        ctrl_outw((value & 0xffdf), PA_OUTPORTR);
-#elif defined(CONFIG_SH_RTS7751R2D)
-        ctrl_outw(0x0001, PA_POWOFF);
-#endif
+        if (pm_power_off)
+                pm_power_off();
 }
 
 void show_regs(struct pt_regs * regs)
diff --git a/arch/sh/kernel/setup.c b/arch/sh/kernel/setup.c
index 036050b377cd..a067a34e0b64 100644
--- a/arch/sh/kernel/setup.c
+++ b/arch/sh/kernel/setup.c
@@ -22,10 +22,10 @@
 #include <linux/cpu.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
-#include <asm/io_generic.h>
 #include <asm/sections.h>
 #include <asm/irq.h>
 #include <asm/setup.h>
+#include <asm/clock.h>
 
 #ifdef CONFIG_SH_KGDB
 #include <asm/kgdb.h>
@@ -41,7 +41,7 @@ extern void * __rd_start, * __rd_end;
  * This value will be used at the very early stage of serial setup.
  * The bigger value means no problem.
  */
-struct sh_cpuinfo boot_cpu_data = { CPU_SH_NONE, 0, 10000000, };
+struct sh_cpuinfo boot_cpu_data = { CPU_SH_NONE, 10000000, };
 struct screen_info screen_info;
 
 #if defined(CONFIG_SH_UNKNOWN)
@@ -186,7 +186,7 @@ static inline void parse_cmdline (char ** cmdline_p, char mv_name[MV_NAME_SIZE],
 
 static int __init sh_mv_setup(char **cmdline_p)
 {
-#if defined(CONFIG_SH_UNKNOWN)
+#ifdef CONFIG_SH_UNKNOWN
         extern struct sh_machine_vector mv_unknown;
 #endif
         struct sh_machine_vector *mv = NULL;
@@ -196,7 +196,7 @@ static int __init sh_mv_setup(char **cmdline_p)
 
         parse_cmdline(cmdline_p, mv_name, &mv, &mv_io_base, &mv_mmio_enable);
 
-#ifdef CONFIG_SH_GENERIC
+#ifdef CONFIG_SH_UNKNOWN
         if (mv == NULL) {
                 mv = &mv_unknown;
                 if (*mv_name != '\0') {
@@ -206,9 +206,6 @@ static int __init sh_mv_setup(char **cmdline_p)
         }
         sh_mv = *mv;
 #endif
-#ifdef CONFIG_SH_UNKNOWN
-        sh_mv = mv_unknown;
-#endif
 
         /*
          * Manually walk the vec, fill in anything that the board hasn't yet
@@ -231,10 +228,8 @@ static int __init sh_mv_setup(char **cmdline_p)
         mv_set(readb);  mv_set(readw);  mv_set(readl);
         mv_set(writeb); mv_set(writew); mv_set(writel);
 
-        mv_set(ioremap);
-        mv_set(iounmap);
-
-        mv_set(isa_port2addr);
+        mv_set(ioport_map);
+        mv_set(ioport_unmap);
         mv_set(irq_demux);
 
 #ifdef CONFIG_SH_UNKNOWN
@@ -273,10 +268,10 @@ void __init setup_arch(char **cmdline_p)
         init_mm.end_data = (unsigned long) _edata;
         init_mm.brk = (unsigned long) _end;
 
-        code_resource.start = virt_to_bus(_text);
-        code_resource.end = virt_to_bus(_etext)-1;
-        data_resource.start = virt_to_bus(_etext);
-        data_resource.end = virt_to_bus(_edata)-1;
+        code_resource.start = (unsigned long)virt_to_phys(_text);
+        code_resource.end = (unsigned long)virt_to_phys(_etext)-1;
+        data_resource.start = (unsigned long)virt_to_phys(_etext);
+        data_resource.end = (unsigned long)virt_to_phys(_edata)-1;
 
         sh_mv_setup(cmdline_p);
 
@@ -435,6 +430,9 @@ static const char *cpu_name[] = {
         [CPU_ST40GX1]   = "ST40GX1",
         [CPU_SH4_202]   = "SH4-202",
         [CPU_SH4_501]   = "SH4-501",
+        [CPU_SH7770]    = "SH7770",
+        [CPU_SH7780]    = "SH7780",
+        [CPU_SH7781]    = "SH7781",
         [CPU_SH_NONE]   = "Unknown"
 };
 
@@ -445,7 +443,7 @@ const char *get_cpu_subtype(void)
 
 #ifdef CONFIG_PROC_FS
 static const char *cpu_flags[] = {
-        "none", "fpu", "p2flush", "mmuassoc", "dsp", "perfctr",
+        "none", "fpu", "p2flush", "mmuassoc", "dsp", "perfctr", "ptea", NULL
 };
 
 static void show_cpuflags(struct seq_file *m)
@@ -459,7 +457,7 @@ static void show_cpuflags(struct seq_file *m)
                 return;
         }
 
-        for (i = 0; i < cpu_data->flags; i++)
+        for (i = 0; cpu_flags[i]; i++)
                 if ((cpu_data->flags & (1 << i)))
                         seq_printf(m, " %s", cpu_flags[i+1]);
 
@@ -472,7 +470,8 @@ static void show_cacheinfo(struct seq_file *m, const char *type, struct cache_in
 
         cache_size = info.ways * info.sets * info.linesz;
 
-        seq_printf(m, "%s size\t: %dKiB\n", type, cache_size >> 10);
+        seq_printf(m, "%s size\t: %2dKiB (%d-way)\n",
+                   type, cache_size >> 10, info.ways);
 }
 
 /*
@@ -511,21 +510,9 @@ static int show_cpuinfo(struct seq_file *m, void *v)
                      boot_cpu_data.loops_per_jiffy/(500000/HZ),
                      (boot_cpu_data.loops_per_jiffy/(5000/HZ)) % 100);
 
-#define PRINT_CLOCK(name, value) \
-        seq_printf(m, name " clock\t: %d.%02dMHz\n", \
-                     ((value) / 1000000), ((value) % 1000000)/10000)
-        
-        PRINT_CLOCK("cpu", boot_cpu_data.cpu_clock);
-        PRINT_CLOCK("bus", boot_cpu_data.bus_clock);
-#ifdef CONFIG_CPU_SUBTYPE_ST40STB1
-        PRINT_CLOCK("memory", boot_cpu_data.memory_clock);
-#endif
-        PRINT_CLOCK("module", boot_cpu_data.module_clock);
-
-        return 0;
+        return show_clocks(m);
 }
 
-
 static void *c_start(struct seq_file *m, loff_t *pos)
 {
         return *pos < NR_CPUS ? cpu_data + *pos : NULL;
@@ -596,7 +583,7 @@ static int __init kgdb_parse_options(char *options)
                 options += map->namelen + 1;
 
                 options = (*options == ',') ? options+1 : options;
-                
+
                 /* Read optional parameters (baud/parity/bits) */
                 baud = simple_strtoul(options, &options, 10);
                 if (baud != 0) {
diff --git a/arch/sh64/kernel/sh_ksyms.c b/arch/sh64/kernel/sh_ksyms.c
index 472b450e61be..de29c45f23a7 100644
--- a/arch/sh64/kernel/sh_ksyms.c
+++ b/arch/sh64/kernel/sh_ksyms.c
@@ -31,14 +31,6 @@
 
 extern int dump_fpu(struct pt_regs *, elf_fpregset_t *);
 
-#if 0
-/* Not yet - there's no declaration of drive_info anywhere. */
-#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD) || defined(CONFIG_BLK_DEV_IDE_MODULE) || defined(CONFIG_BLK_DEV_HD_MODULE)
-extern struct drive_info_struct drive_info;
-EXPORT_SYMBOL(drive_info);
-#endif
-#endif
-
 /* platform dependent support */
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(iounmap);
diff --git a/arch/sh64/kernel/time.c b/arch/sh64/kernel/time.c
index 1195af37ee5a..0773c9f389f3 100644
--- a/arch/sh64/kernel/time.c
+++ b/arch/sh64/kernel/time.c
@@ -29,6 +29,7 @@
 #include <linux/init.h>
 #include <linux/profile.h>
 #include <linux/smp.h>
+#include <linux/module.h>
 
 #include <asm/registers.h>       /* required by inline __asm__ stmt. */
 
diff --git a/arch/sparc/kernel/entry.S b/arch/sparc/kernel/entry.S
index 03ecb4e4614e..887f6a160c58 100644
--- a/arch/sparc/kernel/entry.S
+++ b/arch/sparc/kernel/entry.S
@@ -38,7 +38,7 @@
 
 #define curptr      g6
 
-#define NR_SYSCALLS 284      /* Each OS is different... */
+#define NR_SYSCALLS 300      /* Each OS is different... */
 
 /* These are just handy. */
 #define _SV     save    %sp, -STACKFRAME_SZ, %sp
@@ -1277,62 +1277,6 @@ sys_sigstack:
          mov    %l5, %o7
 
         .align  4
-        .globl  sys_sigpause
-sys_sigpause:
-        /* Note: %o0 already has correct value... */
-        call    do_sigpause
-         add    %sp, STACKFRAME_SZ, %o1
-
-        ld      [%curptr + TI_FLAGS], %l5
-        andcc   %l5, _TIF_SYSCALL_TRACE, %g0
-        be      1f
-         nop
-
-        call    syscall_trace
-         nop
-
-1:
-        /* We are returning to a signal handler. */
-        RESTORE_ALL
-
-        .align  4
-        .globl  sys_sigsuspend
-sys_sigsuspend:
-        call    do_sigsuspend
-         add    %sp, STACKFRAME_SZ, %o0
-
-        ld      [%curptr + TI_FLAGS], %l5
-        andcc   %l5, _TIF_SYSCALL_TRACE, %g0
-        be      1f
-         nop
-
-        call    syscall_trace
-         nop
-
-1:
-        /* We are returning to a signal handler. */
-        RESTORE_ALL
-
-        .align  4
-        .globl  sys_rt_sigsuspend
-sys_rt_sigsuspend:
-        /* Note: %o0, %o1 already have correct value... */
-        call    do_rt_sigsuspend
-         add    %sp, STACKFRAME_SZ, %o2
-
-        ld      [%curptr + TI_FLAGS], %l5
-        andcc   %l5, _TIF_SYSCALL_TRACE, %g0
-        be      1f
-         nop
-
-        call    syscall_trace
-         nop
-
-1:
-        /* We are returning to a signal handler. */
-        RESTORE_ALL
-
-        .align  4
         .globl  sys_sigreturn
 sys_sigreturn:
         call    do_sigreturn
diff --git a/arch/sparc/kernel/process.c b/arch/sparc/kernel/process.c
index fbb05a452e51..118cac84a0f5 100644
--- a/arch/sparc/kernel/process.c
+++ b/arch/sparc/kernel/process.c
@@ -54,7 +54,7 @@ void (*pm_idle)(void);
  * This is done via auxio, but could be used as a fallback
  * handler when auxio is not present-- unused for now...
  */
-void (*pm_power_off)(void);
+void (*pm_power_off)(void) = machine_power_off;
 
 /*
  * sysctl - toggle power-off restriction for serial console 
diff --git a/arch/sparc/kernel/rtrap.S b/arch/sparc/kernel/rtrap.S
index f7460d897e79..77ca6fd81253 100644
--- a/arch/sparc/kernel/rtrap.S
+++ b/arch/sparc/kernel/rtrap.S
@@ -68,15 +68,14 @@ ret_trap_lockless_ipi:
 
         ld      [%curptr + TI_FLAGS], %g2
 signal_p:
-        andcc   %g2, (_TIF_NOTIFY_RESUME|_TIF_SIGPENDING), %g0
+        andcc   %g2, (_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK), %g0
         bz,a    ret_trap_continue
          ld     [%sp + STACKFRAME_SZ + PT_PSR], %t_psr
 
-        clr     %o0
-        mov     %l5, %o2
-        mov     %l6, %o3
+        mov     %l5, %o1
+        mov     %l6, %o2
         call    do_signal
-         add    %sp, STACKFRAME_SZ, %o1 ! pt_regs ptr
+         add    %sp, STACKFRAME_SZ, %o0 ! pt_regs ptr
 
         /* Fall through. */
         ld      [%sp + STACKFRAME_SZ + PT_PSR], %t_psr
diff --git a/arch/sparc/kernel/signal.c b/arch/sparc/kernel/signal.c
index 5f34d7dc2b89..0748d8147bbf 100644
--- a/arch/sparc/kernel/signal.c
+++ b/arch/sparc/kernel/signal.c
@@ -35,9 +35,6 @@ extern void fpsave(unsigned long *fpregs, unsigned long *fsr,
                    void *fpqueue, unsigned long *fpqdepth);
 extern void fpload(unsigned long *fpregs, unsigned long *fsr);
 
-asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
-                         unsigned long orig_o0, int restart_syscall);
-
 /* Signal frames: the original one (compatible with SunOS):
  *
  * Set up a signal frame... Make the stack look the way SunOS
@@ -95,98 +92,30 @@ struct rt_signal_frame {
 #define NF_ALIGNEDSZ  (((sizeof(struct new_signal_frame) + 7) & (~7)))
 #define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame) + 7) & (~7)))
 
-/*
- * atomically swap in the new signal mask, and wait for a signal.
- * This is really tricky on the Sparc, watch out...
- */
-asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
+static int _sigpause_common(old_sigset_t set)
 {
-        sigset_t saveset;
-
         set &= _BLOCKABLE;
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         siginitset(&current->blocked, set);
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        regs->pc = regs->npc;
-        regs->npc += 4;
-
-        /* Condition codes and return value where set here for sigpause,
-         * and so got used by setup_frame, which again causes sigreturn()
-         * to return -EINTR.
-         */
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                /*
-                 * Return -EINTR and set condition code here,
-                 * so the interrupted system call actually returns
-                 * these.
-                 */
-                regs->psr |= PSR_C;
-                regs->u_regs[UREG_I0] = EINTR;
-                if (do_signal(&saveset, regs, 0, 0))
-                        return;
-        }
-}
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
 
-asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)
-{
-        _sigpause_common(set, regs);
+        return -ERESTARTNOHAND;
 }
 
-asmlinkage void do_sigsuspend (struct pt_regs *regs)
+asmlinkage int sys_sigpause(unsigned int set)
 {
-        _sigpause_common(regs->u_regs[UREG_I0], regs);
+        return _sigpause_common(set);
 }
 
-asmlinkage void do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize,
-                                 struct pt_regs *regs)
+asmlinkage int sys_sigsuspend(old_sigset_t set)
 {
-        sigset_t oldset, set;
-
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(sigset_t)) {
-                regs->psr |= PSR_C;
-                regs->u_regs[UREG_I0] = EINVAL;
-                return;
-        }
-
-        if (copy_from_user(&set, uset, sizeof(set))) {
-                regs->psr |= PSR_C;
-                regs->u_regs[UREG_I0] = EFAULT;
-                return;
-        }
-
-        sigdelsetmask(&set, ~_BLOCKABLE);
-        spin_lock_irq(&current->sighand->siglock);
-        oldset = current->blocked;
-        current->blocked = set;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-
-        regs->pc = regs->npc;
-        regs->npc += 4;
-
-        /* Condition codes and return value where set here for sigpause,
-         * and so got used by setup_frame, which again causes sigreturn()
-         * to return -EINTR.
-         */
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                /*
-                 * Return -EINTR and set condition code here,
-                 * so the interrupted system call actually returns
-                 * these.
-                 */
-                regs->psr |= PSR_C;
-                regs->u_regs[UREG_I0] = EINTR;
-                if (do_signal(&oldset, regs, 0, 0))
-                        return;
-        }
+        return _sigpause_common(set);
 }
 
 static inline int
@@ -1067,13 +996,13 @@ static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  * mistake.
  */
-asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
-                         unsigned long orig_i0, int restart_syscall)
+asmlinkage void do_signal(struct pt_regs * regs, unsigned long orig_i0, int restart_syscall)
 {
         siginfo_t info;
         struct sparc_deliver_cookie cookie;
         struct k_sigaction ka;
         int signr;
+        sigset_t *oldset;
 
         /*
          * XXX Disable svr4 signal handling until solaris emulation works.
@@ -1089,7 +1018,9 @@ asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
         cookie.restart_syscall = restart_syscall;
         cookie.orig_i0 = orig_i0;
 
-        if (!oldset)
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
                 oldset = &current->blocked;
 
         signr = get_signal_to_deliver(&info, &ka, regs, &cookie);
@@ -1098,7 +1029,14 @@ asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
                         syscall_restart(cookie.orig_i0, regs, &ka.sa);
                 handle_signal(signr, &ka, &info, oldset,
                               regs, svr4_signal);
-                return 1;
+                /* a signal was successfully delivered; the saved
+                 * sigmask will have been stored in the signal frame,
+                 * and will be restored by sigreturn, so we can simply
+                 * clear the TIF_RESTORE_SIGMASK flag.
+                 */
+                if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
+                return;
         }
         if (cookie.restart_syscall &&
             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
@@ -1115,7 +1053,14 @@ asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
                 regs->pc -= 4;
                 regs->npc -= 4;
         }
-        return 0;
+
+        /* if there's no signal to deliver, we just put the saved sigmask
+         * back
+         */
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
 
 asmlinkage int
diff --git a/arch/sparc/kernel/sparc_ksyms.c b/arch/sparc/kernel/sparc_ksyms.c
index 0b0d492c953b..19b25399d7e4 100644
--- a/arch/sparc/kernel/sparc_ksyms.c
+++ b/arch/sparc/kernel/sparc_ksyms.c
@@ -66,7 +66,6 @@ struct poll {
 
 extern int svr4_getcontext (svr4_ucontext_t *, struct pt_regs *);
 extern int svr4_setcontext (svr4_ucontext_t *, struct pt_regs *);
-void _sigpause_common (unsigned int set, struct pt_regs *);
 extern void (*__copy_1page)(void *, const void *);
 extern void __memmove(void *, const void *, __kernel_size_t);
 extern void (*bzero_1page)(void *);
@@ -227,7 +226,6 @@ EXPORT_SYMBOL(kunmap_atomic);
 /* Solaris/SunOS binary compatibility */
 EXPORT_SYMBOL(svr4_setcontext);
 EXPORT_SYMBOL(svr4_getcontext);
-EXPORT_SYMBOL(_sigpause_common);
 
 EXPORT_SYMBOL(dump_thread);
 
diff --git a/arch/sparc/kernel/systbls.S b/arch/sparc/kernel/systbls.S
index e457a40838fc..768de64b371f 100644
--- a/arch/sparc/kernel/systbls.S
+++ b/arch/sparc/kernel/systbls.S
@@ -75,7 +75,10 @@ sys_call_table:
 /*265*/ .long sys_timer_delete, sys_timer_create, sys_nis_syscall, sys_io_setup, sys_io_destroy
 /*270*/ .long sys_io_submit, sys_io_cancel, sys_io_getevents, sys_mq_open, sys_mq_unlink
 /*275*/ .long sys_mq_timedsend, sys_mq_timedreceive, sys_mq_notify, sys_mq_getsetattr, sys_waitid
-/*280*/ .long sys_ni_syscall, sys_add_key, sys_request_key, sys_keyctl
+/*280*/ .long sys_ni_syscall, sys_add_key, sys_request_key, sys_keyctl, sys_openat
+/*285*/ .long sys_mkdirat, sys_mknodat, sys_fchownat, sys_futimesat, sys_fstatat64
+/*290*/ .long sys_unlinkat, sys_renameat, sys_linkat, sys_symlinkat, sys_readlinkat
+/*295*/ .long sys_fchmodat, sys_faccessat, sys_pselect6, sys_ppoll, sys_unshare
 
 #ifdef CONFIG_SUNOS_EMUL
         /* Now the SunOS syscall table. */
@@ -181,6 +184,12 @@ sunos_sys_table:
         .long sunos_nosys, sunos_nosys, sunos_nosys
         .long sunos_nosys
 /*280*/ .long sunos_nosys, sunos_nosys, sunos_nosys
+        .long sunos_nosys, sunos_nosys, sunos_nosys
+        .long sunos_nosys, sunos_nosys, sunos_nosys
+        .long sunos_nosys
+/*290*/ .long sunos_nosys, sunos_nosys, sunos_nosys
+        .long sunos_nosys, sunos_nosys, sunos_nosys
+        .long sunos_nosys, sunos_nosys, sunos_nosys
         .long sunos_nosys
 
 #endif
diff --git a/arch/sparc/math-emu/math.c b/arch/sparc/math-emu/math.c
index be2c80932e26..8613b3eb877c 100644
--- a/arch/sparc/math-emu/math.c
+++ b/arch/sparc/math-emu/math.c
@@ -323,11 +323,6 @@ static int do_one_mathemu(u32 insn, unsigned long *pfsr, unsigned long *fregs)
                 case FMOVS:
                 case FABSS:
                 case FNEGS: TYPE(2,1,0,1,0,0,0); break;
-                default:
-#ifdef DEBUG_MATHEMU
-                        printk("unknown FPop1: %03lx\n",(insn>>5)&0x1ff);
-#endif
-                        break;
                 }
         } else if ((insn & 0xc1f80000) == 0x81a80000)   /* FPOP2 */ {
                 switch ((insn >> 5) & 0x1ff) {
@@ -337,11 +332,6 @@ static int do_one_mathemu(u32 insn, unsigned long *pfsr, unsigned long *fregs)
                 case FCMPED: TYPE(3,0,0,2,1,2,1); break;
                 case FCMPQ: TYPE(3,0,0,3,1,3,1); break;
                 case FCMPEQ: TYPE(3,0,0,3,1,3,1); break;
-                default:
-#ifdef DEBUG_MATHEMU
-                        printk("unknown FPop2: %03lx\n",(insn>>5)&0x1ff);
-#endif
-                        break;
                 }
         }
 
diff --git a/arch/sparc64/boot/.gitignore b/arch/sparc64/boot/.gitignore
new file mode 100644
index 000000000000..36356f9d498e
--- /dev/null
+++ b/arch/sparc64/boot/.gitignore
@@ -0,0 +1,4 @@
+image
+tftpboot.img
+vmlinux.aout
+piggyback
diff --git a/arch/sparc64/defconfig b/arch/sparc64/defconfig
index a3fb3376ffa0..069d49777b2a 100644
--- a/arch/sparc64/defconfig
+++ b/arch/sparc64/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.15
-# Mon Jan  9 14:36:29 2006
+# Linux kernel version: 2.6.16-rc2
+# Tue Feb  7 17:47:18 2006
 #
 CONFIG_SPARC=y
 CONFIG_SPARC64=y
@@ -23,7 +23,6 @@ CONFIG_HZ=250
 # Code maturity level options
 #
 CONFIG_EXPERIMENTAL=y
-CONFIG_CLEAN_COMPILE=y
 CONFIG_BROKEN_ON_SMP=y
 CONFIG_INIT_ENV_ARG_LIMIT=32
 
@@ -31,7 +30,7 @@ CONFIG_INIT_ENV_ARG_LIMIT=32
 # General setup
 #
 CONFIG_LOCALVERSION=""
-CONFIG_LOCALVERSION_AUTO=y
+# CONFIG_LOCALVERSION_AUTO is not set
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
@@ -155,6 +154,7 @@ CONFIG_NET=y
 #
 # Networking options
 #
+# CONFIG_NETDEBUG is not set
 CONFIG_PACKET=y
 CONFIG_PACKET_MMAP=y
 CONFIG_UNIX=y
@@ -224,6 +224,11 @@ CONFIG_IP_DCCP_TFRC_LIB=m
 # SCTP Configuration (EXPERIMENTAL)
 #
 # CONFIG_IP_SCTP is not set
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
 # CONFIG_ATM is not set
 # CONFIG_BRIDGE is not set
 CONFIG_VLAN_8021Q=m
@@ -420,8 +425,7 @@ CONFIG_ISCSI_TCP=m
 # CONFIG_SCSI_QLOGIC_FC is not set
 # CONFIG_SCSI_QLOGIC_1280 is not set
 # CONFIG_SCSI_QLOGICPTI is not set
-CONFIG_SCSI_QLA2XXX=y
-# CONFIG_SCSI_QLA2XXX_EMBEDDED_FIRMWARE is not set
+# CONFIG_SCSI_QLA_FC is not set
 # CONFIG_SCSI_LPFC is not set
 # CONFIG_SCSI_DC395x is not set
 # CONFIG_SCSI_DC390T is not set
@@ -529,6 +533,7 @@ CONFIG_NET_PCI=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=m
 CONFIG_E1000_NAPI=y
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_MYRI_SBUS is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
@@ -738,6 +743,12 @@ CONFIG_I2C_ALGOBIT=y
 # CONFIG_I2C_DEBUG_CHIP is not set
 
 #
+# SPI support
+#
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+
+#
 # Dallas's 1-wire bus
 #
 # CONFIG_W1 is not set
@@ -755,6 +766,7 @@ CONFIG_HWMON=y
 # CONFIG_SENSORS_ASB100 is not set
 # CONFIG_SENSORS_ATXP1 is not set
 # CONFIG_SENSORS_DS1621 is not set
+# CONFIG_SENSORS_F71805F is not set
 # CONFIG_SENSORS_FSCHER is not set
 # CONFIG_SENSORS_FSCPOS is not set
 # CONFIG_SENSORS_GL518SM is not set
@@ -1014,6 +1026,7 @@ CONFIG_USB_UHCI_HCD=m
 #
 CONFIG_USB_HID=y
 CONFIG_USB_HIDINPUT=y
+# CONFIG_USB_HIDINPUT_POWERBOOK is not set
 # CONFIG_HID_FF is not set
 CONFIG_USB_HIDDEV=y
 # CONFIG_USB_AIPTEK is not set
@@ -1107,6 +1120,10 @@ CONFIG_USB_HIDDEV=y
 #
 
 #
+# EDAC - error detection and reporting (RAS)
+#
+
+#
 # Misc Linux/SPARC drivers
 #
 CONFIG_SUN_OPENPROMIO=m
@@ -1268,12 +1285,13 @@ CONFIG_KPROBES=y
 # Kernel hacking
 #
 CONFIG_PRINTK_TIME=y
-CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
+CONFIG_DEBUG_KERNEL=y
 CONFIG_LOG_BUF_SHIFT=18
 CONFIG_DETECT_SOFTLOCKUP=y
 CONFIG_SCHEDSTATS=y
 # CONFIG_DEBUG_SLAB is not set
+# CONFIG_DEBUG_MUTEXES is not set
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_KOBJECT is not set
@@ -1281,6 +1299,7 @@ CONFIG_DEBUG_BUGVERBOSE=y
 # CONFIG_DEBUG_INFO is not set
 CONFIG_DEBUG_FS=y
 # CONFIG_DEBUG_VM is not set
+CONFIG_FORCED_INLINING=y
 # CONFIG_RCU_TORTURE_TEST is not set
 # CONFIG_DEBUG_STACK_USAGE is not set
 # CONFIG_DEBUG_DCFLUSH is not set
diff --git a/arch/sparc64/kernel/entry.S b/arch/sparc64/kernel/entry.S
index 710002991888..a73553ae7e53 100644
--- a/arch/sparc64/kernel/entry.S
+++ b/arch/sparc64/kernel/entry.S
@@ -25,7 +25,7 @@
 
 #define curptr      g6
 
-#define NR_SYSCALLS 284      /* Each OS is different... */
+#define NR_SYSCALLS 300      /* Each OS is different... */
 
         .text
         .align          32
@@ -1416,7 +1416,6 @@ execve_merge:
          add            %sp, PTREGS_OFF, %o0
 
         .globl  sys_pipe, sys_sigpause, sys_nis_syscall
-        .globl  sys_sigsuspend, sys_rt_sigsuspend
         .globl  sys_rt_sigreturn
         .globl  sys_ptrace
         .globl  sys_sigaltstack
@@ -1440,28 +1439,6 @@ sys32_sigaltstack:
                  mov            %i6, %o2
 #endif
                 .align          32
-sys_sigsuspend: add             %sp, PTREGS_OFF, %o0
-                call            do_sigsuspend
-                 add            %o7, 1f-.-4, %o7
-                nop
-sys_rt_sigsuspend: /* NOTE: %o0,%o1 have a correct value already */
-                add             %sp, PTREGS_OFF, %o2
-                call            do_rt_sigsuspend
-                 add            %o7, 1f-.-4, %o7
-                nop
-#ifdef CONFIG_COMPAT
-        .globl  sys32_rt_sigsuspend
-sys32_rt_sigsuspend: /* NOTE: %o0,%o1 have a correct value already */
-                srl             %o0, 0, %o0
-                add             %sp, PTREGS_OFF, %o2
-                call            do_rt_sigsuspend32
-                 add            %o7, 1f-.-4, %o7
-#endif
-                /* NOTE: %o0 has a correct value already */
-sys_sigpause:   add             %sp, PTREGS_OFF, %o1
-                call            do_sigpause
-                 add            %o7, 1f-.-4, %o7
-                nop
 #ifdef CONFIG_COMPAT
         .globl  sys32_sigreturn
 sys32_sigreturn:
diff --git a/arch/sparc64/kernel/process.c b/arch/sparc64/kernel/process.c
index 1dc3650c5cae..059b0d025224 100644
--- a/arch/sparc64/kernel/process.c
+++ b/arch/sparc64/kernel/process.c
@@ -164,6 +164,7 @@ void machine_restart(char * cmd)
         panic("Reboot failed!");
 }
 
+#ifdef CONFIG_COMPAT
 static void show_regwindow32(struct pt_regs *regs)
 {
         struct reg_window32 __user *rw;
@@ -189,6 +190,9 @@ static void show_regwindow32(struct pt_regs *regs)
                r_w.ins[0], r_w.ins[1], r_w.ins[2], r_w.ins[3],
                r_w.ins[4], r_w.ins[5], r_w.ins[6], r_w.ins[7]);
 }
+#else
+#define show_regwindow32(regs)  do { } while (0)
+#endif
 
 static void show_regwindow(struct pt_regs *regs)
 {
diff --git a/arch/sparc64/kernel/rtrap.S b/arch/sparc64/kernel/rtrap.S
index 090dcca00d2a..b80eba0081ca 100644
--- a/arch/sparc64/kernel/rtrap.S
+++ b/arch/sparc64/kernel/rtrap.S
@@ -53,14 +53,13 @@ __handle_user_windows:
                 wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
                 ldx                     [%g6 + TI_FLAGS], %l0
 
-1:              andcc                   %l0, (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING), %g0
+1:              andcc                   %l0, (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK), %g0
                 be,pt                   %xcc, __handle_user_windows_continue
                  nop
-                clr                     %o0
-                mov                     %l5, %o2
-                mov                     %l6, %o3
-                add                     %sp, PTREGS_OFF, %o1
-                mov                     %l0, %o4
+                mov                     %l5, %o1
+                mov                     %l6, %o2
+                add                     %sp, PTREGS_OFF, %o0
+                mov                     %l0, %o3
 
                 call                    do_notify_resume
                  wrpr                   %g0, RTRAP_PSTATE, %pstate
@@ -96,15 +95,14 @@ __handle_perfctrs:
                  wrpr                   %g0, RTRAP_PSTATE, %pstate
                 wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
                 ldx                     [%g6 + TI_FLAGS], %l0
-1:              andcc                   %l0, (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING), %g0
+1:              andcc                   %l0, (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK), %g0
 
                 be,pt                   %xcc, __handle_perfctrs_continue
                  sethi                  %hi(TSTATE_PEF), %o0
-                clr                     %o0
-                mov                     %l5, %o2
-                mov                     %l6, %o3
-                add                     %sp, PTREGS_OFF, %o1
-                mov                     %l0, %o4
+                mov                     %l5, %o1
+                mov                     %l6, %o2
+                add                     %sp, PTREGS_OFF, %o0
+                mov                     %l0, %o3
                 call                    do_notify_resume
 
                  wrpr                   %g0, RTRAP_PSTATE, %pstate
@@ -129,11 +127,10 @@ __handle_userfpu:
                 ba,a,pt                 %xcc, __handle_userfpu_continue
 
 __handle_signal:
-                clr                     %o0
-                mov                     %l5, %o2
-                mov                     %l6, %o3
-                add                     %sp, PTREGS_OFF, %o1
-                mov                     %l0, %o4
+                mov                     %l5, %o1
+                mov                     %l6, %o2
+                add                     %sp, PTREGS_OFF, %o0
+                mov                     %l0, %o3
                 call                    do_notify_resume
                  wrpr                   %g0, RTRAP_PSTATE, %pstate
                 wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
@@ -200,7 +197,7 @@ __handle_preemption_continue:
                  andcc                  %l1, %o0, %g0
                 andcc                   %l0, _TIF_NEED_RESCHED, %g0
                 bne,pn                  %xcc, __handle_preemption
-                 andcc                  %l0, (_TIF_NOTIFY_RESUME | _TIF_SIGPENDING), %g0
+                 andcc                  %l0, (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK), %g0
                 bne,pn                  %xcc, __handle_signal
 __handle_signal_continue:
                  ldub                   [%g6 + TI_WSAVED], %o2
diff --git a/arch/sparc64/kernel/setup.c b/arch/sparc64/kernel/setup.c
index 250745896aee..054461e6946d 100644
--- a/arch/sparc64/kernel/setup.c
+++ b/arch/sparc64/kernel/setup.c
@@ -561,6 +561,8 @@ static int __init set_preferred_console(void)
                 serial_console = 1;
         } else if (idev == PROMDEV_ITTYB && odev == PROMDEV_OTTYB) {
                 serial_console = 2;
+        } else if (idev == PROMDEV_IRSC && odev == PROMDEV_ORSC) {
+                serial_console = 3;
         } else {
                 prom_printf("Inconsistent console: "
                             "input %d, output %d\n",
diff --git a/arch/sparc64/kernel/signal.c b/arch/sparc64/kernel/signal.c
index 60f5dfabb1e1..ca11a4c457d4 100644
--- a/arch/sparc64/kernel/signal.c
+++ b/arch/sparc64/kernel/signal.c
@@ -36,9 +36,6 @@
 
 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 
-static int do_signal(sigset_t *oldset, struct pt_regs * regs,
-                     unsigned long orig_o0, int ret_from_syscall);
-
 /* {set, get}context() needed for 64-bit SparcLinux userland. */
 asmlinkage void sparc64_set_context(struct pt_regs *regs)
 {
@@ -242,114 +239,29 @@ struct rt_signal_frame {
 /* Align macros */
 #define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame) + 7) & (~7)))
 
-/*
- * atomically swap in the new signal mask, and wait for a signal.
- * This is really tricky on the Sparc, watch out...
- */
-asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
+static long _sigpause_common(old_sigset_t set)
 {
-        sigset_t saveset;
-
-#ifdef CONFIG_SPARC32_COMPAT
-        if (test_thread_flag(TIF_32BIT)) {
-                extern asmlinkage void _sigpause32_common(compat_old_sigset_t,
-                                                          struct pt_regs *);
-                _sigpause32_common(set, regs);
-                return;
-        }
-#endif
         set &= _BLOCKABLE;
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         siginitset(&current->blocked, set);
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
-        
-        if (test_thread_flag(TIF_32BIT)) {
-                regs->tpc = (regs->tnpc & 0xffffffff);
-                regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
-        } else {
-                regs->tpc = regs->tnpc;
-                regs->tnpc += 4;
-        }
 
-        /* Condition codes and return value where set here for sigpause,
-         * and so got used by setup_frame, which again causes sigreturn()
-         * to return -EINTR.
-         */
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                /*
-                 * Return -EINTR and set condition code here,
-                 * so the interrupted system call actually returns
-                 * these.
-                 */
-                regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
-                regs->u_regs[UREG_I0] = EINTR;
-                if (do_signal(&saveset, regs, 0, 0))
-                        return;
-        }
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        return -ERESTARTNOHAND;
 }
 
-asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)
+asmlinkage long sys_sigpause(unsigned int set)
 {
-        _sigpause_common(set, regs);
+        return _sigpause_common(set);
 }
 
-asmlinkage void do_sigsuspend(struct pt_regs *regs)
+asmlinkage long sys_sigsuspend(old_sigset_t set)
 {
-        _sigpause_common(regs->u_regs[UREG_I0], regs);
-}
-
-asmlinkage void do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize, struct pt_regs *regs)
-{
-        sigset_t oldset, set;
-        
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(sigset_t)) {
-                regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
-                regs->u_regs[UREG_I0] = EINVAL;
-                return;
-        }
-        if (copy_from_user(&set, uset, sizeof(set))) {
-                regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
-                regs->u_regs[UREG_I0] = EFAULT;
-                return;
-        }
-                                                                
-        sigdelsetmask(&set, ~_BLOCKABLE);
-        spin_lock_irq(&current->sighand->siglock);
-        oldset = current->blocked;
-        current->blocked = set;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        
-        if (test_thread_flag(TIF_32BIT)) {
-                regs->tpc = (regs->tnpc & 0xffffffff);
-                regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
-        } else {
-                regs->tpc = regs->tnpc;
-                regs->tnpc += 4;
-        }
-
-        /* Condition codes and return value where set here for sigpause,
-         * and so got used by setup_frame, which again causes sigreturn()
-         * to return -EINTR.
-         */
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                /*
-                 * Return -EINTR and set condition code here,
-                 * so the interrupted system call actually returns
-                 * these.
-                 */
-                regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
-                regs->u_regs[UREG_I0] = EINTR;
-                if (do_signal(&oldset, regs, 0, 0))
-                        return;
-        }
+        return _sigpause_common(set);
 }
 
 static inline int
@@ -607,26 +519,29 @@ static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  * mistake.
  */
-static int do_signal(sigset_t *oldset, struct pt_regs * regs,
-                     unsigned long orig_i0, int restart_syscall)
+static void do_signal(struct pt_regs *regs, unsigned long orig_i0, int restart_syscall)
 {
         siginfo_t info;
         struct signal_deliver_cookie cookie;
         struct k_sigaction ka;
         int signr;
+        sigset_t *oldset;
         
         cookie.restart_syscall = restart_syscall;
         cookie.orig_i0 = orig_i0;
 
-        if (!oldset)
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
                 oldset = &current->blocked;
 
 #ifdef CONFIG_SPARC32_COMPAT
         if (test_thread_flag(TIF_32BIT)) {
-                extern int do_signal32(sigset_t *, struct pt_regs *,
-                                       unsigned long, int);
-                return do_signal32(oldset, regs, orig_i0,
-                                   cookie.restart_syscall);
+                extern void do_signal32(sigset_t *, struct pt_regs *,
+                                        unsigned long, int);
+                do_signal32(oldset, regs, orig_i0,
+                            cookie.restart_syscall);
+                return;
         }
 #endif  
 
@@ -635,7 +550,15 @@ static int do_signal(sigset_t *oldset, struct pt_regs * regs,
                 if (cookie.restart_syscall)
                         syscall_restart(orig_i0, regs, &ka.sa);
                 handle_signal(signr, &ka, &info, oldset, regs);
-                return 1;
+
+                /* a signal was successfully delivered; the saved
+                 * sigmask will have been stored in the signal frame,
+                 * and will be restored by sigreturn, so we can simply
+                 * clear the TIF_RESTORE_SIGMASK flag.
+                 */
+                if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
+                return;
         }
         if (cookie.restart_syscall &&
             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
@@ -652,15 +575,21 @@ static int do_signal(sigset_t *oldset, struct pt_regs * regs,
                 regs->tpc -= 4;
                 regs->tnpc -= 4;
         }
-        return 0;
+
+        /* if there's no signal to deliver, we just put the saved sigmask
+         * back
+         */
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
 
-void do_notify_resume(sigset_t *oldset, struct pt_regs *regs,
-                      unsigned long orig_i0, int restart_syscall,
+void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, int restart_syscall,
                       unsigned long thread_info_flags)
 {
-        if (thread_info_flags & _TIF_SIGPENDING)
-                do_signal(oldset, regs, orig_i0, restart_syscall);
+        if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
+                do_signal(regs, orig_i0, restart_syscall);
 }
 
 void ptrace_signal_deliver(struct pt_regs *regs, void *cookie)
diff --git a/arch/sparc64/kernel/signal32.c b/arch/sparc64/kernel/signal32.c
index 009a86e5ded4..708ba9b42cda 100644
--- a/arch/sparc64/kernel/signal32.c
+++ b/arch/sparc64/kernel/signal32.c
@@ -32,9 +32,6 @@
 
 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 
-int do_signal32(sigset_t *oldset, struct pt_regs *regs,
-                unsigned long orig_o0, int ret_from_syscall);
-
 /* Signal frames: the original one (compatible with SunOS):
  *
  * Set up a signal frame... Make the stack look the way SunOS
@@ -226,102 +223,6 @@ int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
         return 0;
 }
 
-/*
- * atomically swap in the new signal mask, and wait for a signal.
- * This is really tricky on the Sparc, watch out...
- */
-asmlinkage void _sigpause32_common(compat_old_sigset_t set, struct pt_regs *regs)
-{
-        sigset_t saveset;
-
-        set &= _BLOCKABLE;
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        siginitset(&current->blocked, set);
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        
-        regs->tpc = regs->tnpc;
-        regs->tnpc += 4;
-        if (test_thread_flag(TIF_32BIT)) {
-                regs->tpc &= 0xffffffff;
-                regs->tnpc &= 0xffffffff;
-        }
-
-        /* Condition codes and return value where set here for sigpause,
-         * and so got used by setup_frame, which again causes sigreturn()
-         * to return -EINTR.
-         */
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                /*
-                 * Return -EINTR and set condition code here,
-                 * so the interrupted system call actually returns
-                 * these.
-                 */
-                regs->tstate |= TSTATE_ICARRY;
-                regs->u_regs[UREG_I0] = EINTR;
-                if (do_signal32(&saveset, regs, 0, 0))
-                        return;
-        }
-}
-
-asmlinkage void do_rt_sigsuspend32(u32 uset, size_t sigsetsize, struct pt_regs *regs)
-{
-        sigset_t oldset, set;
-        compat_sigset_t set32;
-        
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (((compat_size_t)sigsetsize) != sizeof(sigset_t)) {
-                regs->tstate |= TSTATE_ICARRY;
-                regs->u_regs[UREG_I0] = EINVAL;
-                return;
-        }
-        if (copy_from_user(&set32, compat_ptr(uset), sizeof(set32))) {
-                regs->tstate |= TSTATE_ICARRY;
-                regs->u_regs[UREG_I0] = EFAULT;
-                return;
-        }
-        switch (_NSIG_WORDS) {
-        case 4: set.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
-        case 3: set.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
-        case 2: set.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
-        case 1: set.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
-        }
-        sigdelsetmask(&set, ~_BLOCKABLE);
-        spin_lock_irq(&current->sighand->siglock);
-        oldset = current->blocked;
-        current->blocked = set;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-        
-        regs->tpc = regs->tnpc;
-        regs->tnpc += 4;
-        if (test_thread_flag(TIF_32BIT)) {
-                regs->tpc &= 0xffffffff;
-                regs->tnpc &= 0xffffffff;
-        }
-
-        /* Condition codes and return value where set here for sigpause,
-         * and so got used by setup_frame, which again causes sigreturn()
-         * to return -EINTR.
-         */
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                /*
-                 * Return -EINTR and set condition code here,
-                 * so the interrupted system call actually returns
-                 * these.
-                 */
-                regs->tstate |= TSTATE_ICARRY;
-                regs->u_regs[UREG_I0] = EINTR;
-                if (do_signal32(&oldset, regs, 0, 0))
-                        return;
-        }
-}
-
 static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
 {
         unsigned long *fpregs = current_thread_info()->fpregs;
@@ -1362,8 +1263,8 @@ static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs
  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  * mistake.
  */
-int do_signal32(sigset_t *oldset, struct pt_regs * regs,
-                unsigned long orig_i0, int restart_syscall)
+void do_signal32(sigset_t *oldset, struct pt_regs * regs,
+                 unsigned long orig_i0, int restart_syscall)
 {
         siginfo_t info;
         struct signal_deliver_cookie cookie;
@@ -1380,7 +1281,15 @@ int do_signal32(sigset_t *oldset, struct pt_regs * regs,
                         syscall_restart32(orig_i0, regs, &ka.sa);
                 handle_signal32(signr, &ka, &info, oldset,
                                 regs, svr4_signal);
-                return 1;
+
+                /* a signal was successfully delivered; the saved
+                 * sigmask will have been stored in the signal frame,
+                 * and will be restored by sigreturn, so we can simply
+                 * clear the TIF_RESTORE_SIGMASK flag.
+                 */
+                if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
+                return;
         }
         if (cookie.restart_syscall &&
             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
@@ -1397,7 +1306,14 @@ int do_signal32(sigset_t *oldset, struct pt_regs * regs,
                 regs->tpc -= 4;
                 regs->tnpc -= 4;
         }
-        return 0;
+
+        /* if there's no signal to deliver, we just put the saved sigmask
+         * back
+         */
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
 
 struct sigstack32 {
diff --git a/arch/sparc64/kernel/sparc64_ksyms.c b/arch/sparc64/kernel/sparc64_ksyms.c
index d177d7e5c9d3..3c06bfb92a8c 100644
--- a/arch/sparc64/kernel/sparc64_ksyms.c
+++ b/arch/sparc64/kernel/sparc64_ksyms.c
@@ -69,7 +69,6 @@ struct poll {
 
 extern void die_if_kernel(char *str, struct pt_regs *regs);
 extern pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
-void _sigpause_common (unsigned int set, struct pt_regs *);
 extern void *__bzero(void *, size_t);
 extern void *__memscan_zero(void *, size_t);
 extern void *__memscan_generic(void *, int, size_t);
@@ -236,9 +235,10 @@ EXPORT_SYMBOL(pci_dma_supported);
 /* I/O device mmaping on Sparc64. */
 EXPORT_SYMBOL(io_remap_pfn_range);
 
+#ifdef CONFIG_COMPAT
 /* Solaris/SunOS binary compatibility */
-EXPORT_SYMBOL(_sigpause_common);
 EXPORT_SYMBOL(verify_compat_iovec);
+#endif
 
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(pte_alloc_one_kernel);
diff --git a/arch/sparc64/kernel/sys32.S b/arch/sparc64/kernel/sys32.S
index 9cd272ac3ac1..60b59375aa78 100644
--- a/arch/sparc64/kernel/sys32.S
+++ b/arch/sparc64/kernel/sys32.S
@@ -84,7 +84,6 @@ SIGN2(sys32_fadvise64_64, compat_sys_fadvise64_64, %o0, %o5)
 SIGN2(sys32_bdflush, sys_bdflush, %o0, %o1)
 SIGN1(sys32_mlockall, sys_mlockall, %o0)
 SIGN1(sys32_nfsservctl, compat_sys_nfsservctl, %o0)
-SIGN1(sys32_clock_settime, compat_sys_clock_settime, %o1)
 SIGN1(sys32_clock_nanosleep, compat_sys_clock_nanosleep, %o1)
 SIGN1(sys32_timer_settime, compat_sys_timer_settime, %o1)
 SIGN1(sys32_io_submit, compat_sys_io_submit, %o1)
diff --git a/arch/sparc64/kernel/sys_sparc32.c b/arch/sparc64/kernel/sys_sparc32.c
index d4b7a100cb8a..417727bd87ba 100644
--- a/arch/sparc64/kernel/sys_sparc32.c
+++ b/arch/sparc64/kernel/sys_sparc32.c
@@ -428,6 +428,27 @@ asmlinkage long compat_sys_fstat64(unsigned int fd,
         return error;
 }
 
+asmlinkage long compat_sys_fstatat64(unsigned int dfd, char __user *filename,
+                struct compat_stat64 __user * statbuf, int flag)
+{
+        struct kstat stat;
+        int error = -EINVAL;
+
+        if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
+                goto out;
+
+        if (flag & AT_SYMLINK_NOFOLLOW)
+                error = vfs_lstat_fd(dfd, filename, &stat);
+        else
+                error = vfs_stat_fd(dfd, filename, &stat);
+
+        if (!error)
+                error = cp_compat_stat64(&stat, statbuf);
+
+out:
+        return error;
+}
+
 asmlinkage long compat_sys_sysfs(int option, u32 arg1, u32 arg2)
 {
         return sys_sysfs(option, arg1, arg2);
@@ -821,7 +842,7 @@ asmlinkage long sys32_utimes(char __user *filename,
                         return -EFAULT;
         }
 
-        return do_utimes(filename, (tvs ? &ktvs[0] : NULL));
+        return do_utimes(AT_FDCWD, filename, (tvs ? &ktvs[0] : NULL));
 }
 
 /* These are here just in case some old sparc32 binary calls it. */
@@ -1003,7 +1024,7 @@ asmlinkage long sys32_adjtimex(struct timex32 __user *utp)
 asmlinkage long sparc32_open(const char __user *filename,
                              int flags, int mode)
 {
-        return do_sys_open(filename, flags, mode);
+        return do_sys_open(AT_FDCWD, filename, flags, mode);
 }
 
 extern unsigned long do_mremap(unsigned long addr,
diff --git a/arch/sparc64/kernel/systbls.S b/arch/sparc64/kernel/systbls.S
index 98d24bc00044..c3adb7ac167d 100644
--- a/arch/sparc64/kernel/systbls.S
+++ b/arch/sparc64/kernel/systbls.S
@@ -41,7 +41,7 @@ sys_call_table32:
 /*90*/  .word sys_dup2, sys_setfsuid, compat_sys_fcntl, sys32_select, sys_setfsgid
         .word sys_fsync, sys32_setpriority, sys_nis_syscall, sys_nis_syscall, sys_nis_syscall
 /*100*/ .word sys32_getpriority, sys32_rt_sigreturn, sys32_rt_sigaction, sys32_rt_sigprocmask, sys32_rt_sigpending
-        .word compat_sys_rt_sigtimedwait, sys32_rt_sigqueueinfo, sys32_rt_sigsuspend, sys_setresuid, sys_getresuid
+        .word compat_sys_rt_sigtimedwait, sys32_rt_sigqueueinfo, compat_sys_rt_sigsuspend, sys_setresuid, sys_getresuid
 /*110*/ .word sys_setresgid, sys_getresgid, sys_setregid, sys_nis_syscall, sys_nis_syscall
         .word sys32_getgroups, sys32_gettimeofday, sys32_getrusage, sys_nis_syscall, sys_getcwd
 /*120*/ .word compat_sys_readv, compat_sys_writev, sys32_settimeofday, sys32_fchown16, sys_fchmod
@@ -71,12 +71,15 @@ sys_call_table32:
 /*240*/ .word sys_munlockall, sys32_sched_setparam, sys32_sched_getparam, sys32_sched_setscheduler, sys32_sched_getscheduler
         .word sys_sched_yield, sys32_sched_get_priority_max, sys32_sched_get_priority_min, sys32_sched_rr_get_interval, compat_sys_nanosleep
 /*250*/ .word sys32_mremap, sys32_sysctl, sys32_getsid, sys_fdatasync, sys32_nfsservctl
-        .word sys_ni_syscall, sys32_clock_settime, compat_sys_clock_gettime, compat_sys_clock_getres, sys32_clock_nanosleep
+        .word sys_ni_syscall, compat_sys_clock_settime, compat_sys_clock_gettime, compat_sys_clock_getres, sys32_clock_nanosleep
 /*260*/ .word compat_sys_sched_getaffinity, compat_sys_sched_setaffinity, sys32_timer_settime, compat_sys_timer_gettime, sys_timer_getoverrun
         .word sys_timer_delete, compat_sys_timer_create, sys_ni_syscall, compat_sys_io_setup, sys_io_destroy
 /*270*/ .word sys32_io_submit, sys_io_cancel, compat_sys_io_getevents, sys32_mq_open, sys_mq_unlink
         .word compat_sys_mq_timedsend, compat_sys_mq_timedreceive, compat_sys_mq_notify, compat_sys_mq_getsetattr, compat_sys_waitid
-/*280*/ .word sys_ni_syscall, sys_add_key, sys_request_key, sys_keyctl
+/*280*/ .word sys_ni_syscall, sys_add_key, sys_request_key, sys_keyctl, compat_sys_openat
+        .word sys_mkdirat, sys_mknodat, sys_fchownat, compat_sys_futimesat, compat_sys_fstatat64
+/*285*/ .word sys_unlinkat, sys_renameat, sys_linkat, sys_symlinkat, sys_readlinkat
+        .word sys_fchmodat, sys_faccessat, compat_sys_pselect6, compat_sys_ppoll, sys_unshare
 
 #endif /* CONFIG_COMPAT */
 
@@ -142,7 +145,10 @@ sys_call_table:
         .word sys_timer_delete, sys_timer_create, sys_ni_syscall, sys_io_setup, sys_io_destroy
 /*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
+/*280*/ .word sys_nis_syscall, sys_add_key, sys_request_key, sys_keyctl, sys_openat
+        .word sys_mkdirat, sys_mknodat, sys_fchownat, sys_futimesat, sys_fstatat64
+/*285*/ .word sys_unlinkat, sys_renameat, sys_linkat, sys_symlinkat, sys_readlinkat
+        .word sys_fchmodat, sys_faccessat, sys_pselect6, sys_ppoll, sys_unshare
 
 #if defined(CONFIG_SUNOS_EMUL) || defined(CONFIG_SOLARIS_EMUL) || \
     defined(CONFIG_SOLARIS_EMUL_MODULE)
@@ -239,12 +245,20 @@ sunos_sys_table:
 /*250*/ .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
+        .word sunos_nosys
+/*260*/ .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
+        .word sunos_nosys
+/*270*/ .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
+        .word sunos_nosys
+/*280*/ .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
+        .word sunos_nosys
+/*290*/ .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys, sunos_nosys, sunos_nosys
         .word sunos_nosys
diff --git a/arch/sparc64/prom/console.c b/arch/sparc64/prom/console.c
index eae5db8dda56..ac6d035dd150 100644
--- a/arch/sparc64/prom/console.c
+++ b/arch/sparc64/prom/console.c
@@ -99,8 +99,12 @@ prom_query_input_device(void)
         if (!strncmp(propb, "keyboard", 8))
                 return PROMDEV_ITTYA;
 
+        if (!strncmp (propb, "rsc", 3))
+                return PROMDEV_IRSC;
+
         if (strncmp (propb, "tty", 3) || !propb[3])
                 return PROMDEV_I_UNK;
+
         switch (propb[3]) {
                 case 'a': return PROMDEV_ITTYA;
                 case 'b': return PROMDEV_ITTYB;
@@ -136,8 +140,12 @@ prom_query_output_device(void)
         if (!strncmp(propb, "screen", 6))
                 return PROMDEV_OTTYA;
 
+        if (!strncmp (propb, "rsc", 3))
+                return PROMDEV_ORSC;
+
         if (strncmp (propb, "tty", 3) || !propb[3])
                 return PROMDEV_O_UNK;
+
         switch (propb[3]) {
                 case 'a': return PROMDEV_OTTYA;
                 case 'b': return PROMDEV_OTTYB;
diff --git a/arch/sparc64/solaris/entry64.S b/arch/sparc64/solaris/entry64.S
index 4b6ae583c0a3..eb314ed23cdb 100644
--- a/arch/sparc64/solaris/entry64.S
+++ b/arch/sparc64/solaris/entry64.S
@@ -180,6 +180,8 @@ solaris_sigsuspend:
          nop
         call            sys_sigsuspend
          stx            %o0, [%sp + PTREGS_OFF + PT_V9_I0]
+        b,pt            %xcc, ret_from_solaris
+         nop
 
         .globl          solaris_getpid
 solaris_getpid:
diff --git a/arch/sparc64/solaris/systbl.S b/arch/sparc64/solaris/systbl.S
index d25667eeae10..7043ca18caf9 100644
--- a/arch/sparc64/solaris/systbl.S
+++ b/arch/sparc64/solaris/systbl.S
@@ -283,32 +283,3 @@ solaris_sys_table:
         .word solaris_unimplemented     /*                      253     */
         .word solaris_unimplemented     /*                      254     */
         .word solaris_unimplemented     /*                      255     */
-        .word solaris_unimplemented     /*                      256     */
-        .word solaris_unimplemented     /*                      257     */
-        .word solaris_unimplemented     /*                      258     */
-        .word solaris_unimplemented     /*                      259     */
-        .word solaris_unimplemented     /*                      260     */
-        .word solaris_unimplemented     /*                      261     */
-        .word solaris_unimplemented     /*                      262     */
-        .word solaris_unimplemented     /*                      263     */
-        .word solaris_unimplemented     /*                      264     */
-        .word solaris_unimplemented     /*                      265     */
-        .word solaris_unimplemented     /*                      266     */
-        .word solaris_unimplemented     /*                      267     */
-        .word solaris_unimplemented     /*                      268     */
-        .word solaris_unimplemented     /*                      269     */
-        .word solaris_unimplemented     /*                      270     */
-        .word solaris_unimplemented     /*                      271     */
-        .word solaris_unimplemented     /*                      272     */
-        .word solaris_unimplemented     /*                      273     */
-        .word solaris_unimplemented     /*                      274     */
-        .word solaris_unimplemented     /*                      275     */
-        .word solaris_unimplemented     /*                      276     */
-        .word solaris_unimplemented     /*                      277     */
-        .word solaris_unimplemented     /*                      278     */
-        .word solaris_unimplemented     /*                      279     */
-        .word solaris_unimplemented     /*                      280     */
-        .word solaris_unimplemented     /*                      281     */
-        .word solaris_unimplemented     /*                      282     */
-        .word solaris_unimplemented     /*                      283     */
-
diff --git a/arch/um/Kconfig b/arch/um/Kconfig
index 8ff3bcbce5fc..5982fe2753e0 100644
--- a/arch/um/Kconfig
+++ b/arch/um/Kconfig
@@ -143,6 +143,7 @@ config HOSTFS
 
 config HPPFS
         tristate "HoneyPot ProcFS (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
         help
         hppfs (HoneyPot ProcFS) is a filesystem which allows UML /proc
         entries to be overridden, removed, or fabricated from the host.
@@ -155,10 +156,6 @@ config HPPFS
         You only need this if you are setting up a UML honeypot.  Otherwise,
         it is safe to say 'N' here.
 
-        If you are actively using it, please report any problems, since it's
-        getting fixed. In this moment, it is experimental on 2.6 (it works on
-        2.4).
-
 config MCONSOLE
         bool "Management console"
         default y
@@ -243,8 +240,16 @@ config NEST_LEVEL
         Only change this if you are running nested UMLs.
 
 config HIGHMEM
-        bool "Highmem support"
-        depends on !64BIT
+        bool "Highmem support (EXPERIMENTAL)"
+        depends on !64BIT && EXPERIMENTAL
+        default n
+        help
+        This was used to allow UML to run with big amounts of memory.
+        Currently it is unstable, so if unsure say N.
+
+        To use big amounts of memory, it is recommended to disable TT mode (i.e.
+        CONFIG_MODE_TT) and enable static linking (i.e. CONFIG_STATIC_LINK) -
+        this should allow the guest to use up to 2.75G of memory.
 
 config KERNEL_STACK_ORDER
         int "Kernel stack size order"
@@ -269,17 +274,13 @@ endmenu
 
 source "init/Kconfig"
 
-source "net/Kconfig"
-
-source "drivers/base/Kconfig"
+source "drivers/block/Kconfig"
 
 source "arch/um/Kconfig.char"
 
-source "drivers/block/Kconfig"
+source "drivers/base/Kconfig"
 
-config NETDEVICES
-        bool
-        default NET
+source "net/Kconfig"
 
 source "arch/um/Kconfig.net"
 
diff --git a/arch/um/Kconfig.i386 b/arch/um/Kconfig.i386
index c71b39a677aa..ef79ed25aecd 100644
--- a/arch/um/Kconfig.i386
+++ b/arch/um/Kconfig.i386
@@ -22,13 +22,17 @@ config TOP_ADDR
         default 0x80000000 if HOST_2G_2G
 
 config 3_LEVEL_PGTABLES
-        bool "Three-level pagetables"
+        bool "Three-level pagetables (EXPERIMENTAL)"
         default n
+        depends on EXPERIMENTAL
         help
         Three-level pagetables will let UML have more than 4G of physical
         memory.  All the memory that can't be mapped directly will be treated
         as high memory.
 
+        However, this it experimental on 32-bit architectures, so if unsure say
+        N (on x86-64 it's automatically enabled, instead, as it's safe there).
+
 config STUB_CODE
         hex
         default 0xbfffe000
diff --git a/arch/um/Makefile b/arch/um/Makefile
index 45435ff589c1..c58b657f0097 100644
--- a/arch/um/Makefile
+++ b/arch/um/Makefile
@@ -32,7 +32,7 @@ um-modes-$(CONFIG_MODE_TT) += tt
 um-modes-$(CONFIG_MODE_SKAS) += skas
 
 MODE_INCLUDE    += $(foreach mode,$(um-modes-y),\
-                   -I$(srctree)/$(ARCH_DIR)/kernel/$(mode)/include)
+                   -I$(srctree)/$(ARCH_DIR)/include/$(mode))
 
 MAKEFILES-INCL  += $(foreach mode,$(um-modes-y),\
                    $(srctree)/$(ARCH_DIR)/Makefile-$(mode))
@@ -47,13 +47,16 @@ ARCH_INCLUDE	+= -I$(srctree)/$(ARCH_DIR)/include
 endif
 SYS_DIR         := $(ARCH_DIR)/include/sysdep-$(SUBARCH)
 
-# -Dvmap=kernel_vmap affects everything, and prevents anything from
-# referencing the libpcap.o symbol so named.
+# -Dvmap=kernel_vmap prevents anything from referencing the libpcap.o symbol so
+# named - it's a common symbol in libpcap, so we get a binary which crashes.
 #
-# Same things for in6addr_loopback - found in libc.
+# Same things for in6addr_loopback and mktime - found in libc. For these two we
+# only get link-time error, luckily.
+#
+# These apply to USER_CFLAGS to.
 
-CFLAGS += $(CFLAGS-y) -D__arch_um__ -DSUBARCH=\"$(SUBARCH)\" \
-        $(ARCH_INCLUDE) $(MODE_INCLUDE) -Dvmap=kernel_vmap \
+CFLAGS += $(CFLAGS-y) -D__arch_um__ -DSUBARCH=\"$(SUBARCH)\"    \
+        $(ARCH_INCLUDE) $(MODE_INCLUDE) -Dvmap=kernel_vmap      \
         -Din6addr_loopback=kernel_in6addr_loopback
 
 AFLAGS += $(ARCH_INCLUDE)
@@ -66,6 +69,7 @@ USER_CFLAGS := $(patsubst -D__KERNEL__,,$(USER_CFLAGS)) $(ARCH_INCLUDE) \
 # kernel_errno to separate them from the libc errno.  This allows -fno-common
 # in CFLAGS.  Otherwise, it would cause ld to complain about the two different
 # errnos.
+# These apply to kernelspace only.
 
 CFLAGS += -Derrno=kernel_errno -Dsigprocmask=kernel_sigprocmask \
         -Dmktime=kernel_mktime
@@ -168,10 +172,13 @@ else
         $(Q)cd $(TOPDIR)/include/asm-um && ln -sf ../asm-$(SUBARCH) arch
 endif
 
-$(ARCH_DIR)/include/sysdep:
+$(objtree)/$(ARCH_DIR)/include:
+        @echo '  MKDIR $@'
+        $(Q)mkdir -p $@
+
+$(ARCH_DIR)/include/sysdep: $(objtree)/$(ARCH_DIR)/include
         @echo '  SYMLINK $@'
 ifneq ($(KBUILD_SRC),)
-        $(Q)mkdir -p $(ARCH_DIR)/include
         $(Q)ln -fsn $(srctree)/$(ARCH_DIR)/include/sysdep-$(SUBARCH) $(ARCH_DIR)/include/sysdep
 else
         $(Q)cd $(ARCH_DIR)/include && ln -sf sysdep-$(SUBARCH) sysdep
@@ -214,7 +221,7 @@ $(ARCH_DIR)/include/user_constants.h: $(ARCH_DIR)/user-offsets.s
 
 CLEAN_FILES += $(ARCH_DIR)/user-offsets.s
 
-$(ARCH_DIR)/include/kern_constants.h:
+$(ARCH_DIR)/include/kern_constants.h: $(objtree)/$(ARCH_DIR)/include
         @echo '  SYMLINK $@'
         $(Q) ln -sf ../../../include/asm-um/asm-offsets.h $@
 
diff --git a/arch/um/drivers/chan_kern.c b/arch/um/drivers/chan_kern.c
index ab0d0b170816..7218c754505b 100644
--- a/arch/um/drivers/chan_kern.c
+++ b/arch/um/drivers/chan_kern.c
@@ -403,7 +403,7 @@ int chan_window_size(struct list_head *chans, unsigned short *rows_out,
         return 0;
 }
 
-void free_one_chan(struct chan *chan, int delay_free_irq)
+static void free_one_chan(struct chan *chan, int delay_free_irq)
 {
         list_del(&chan->list);
 
@@ -416,7 +416,7 @@ void free_one_chan(struct chan *chan, int delay_free_irq)
         kfree(chan);
 }
 
-void free_chan(struct list_head *chans, int delay_free_irq)
+static void free_chan(struct list_head *chans, int delay_free_irq)
 {
         struct list_head *ele, *next;
         struct chan *chan;
@@ -497,7 +497,7 @@ struct chan_type {
         struct chan_ops *ops;
 };
 
-struct chan_type chan_table[] = {
+static struct chan_type chan_table[] = {
         { "fd", &fd_ops },
 
 #ifdef CONFIG_NULL_CHAN
diff --git a/arch/um/drivers/chan_user.c b/arch/um/drivers/chan_user.c
index 5d50d4a44abf..2f880cb167a5 100644
--- a/arch/um/drivers/chan_user.c
+++ b/arch/um/drivers/chan_user.c
@@ -9,6 +9,7 @@
 #include <termios.h>
 #include <string.h>
 #include <signal.h>
+#include <sched.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
@@ -73,7 +74,6 @@ static void winch_handler(int sig)
 struct winch_data {
         int pty_fd;
         int pipe_fd;
-        int close_me;
 };
 
 static int winch_thread(void *arg)
@@ -84,7 +84,6 @@ static int winch_thread(void *arg)
         int count, err;
         char c = 1;
 
-        os_close_file(data->close_me);
         pty_fd = data->pty_fd;
         pipe_fd = data->pipe_fd;
         count = os_write_file(pipe_fd, &c, sizeof(c));
@@ -153,15 +152,16 @@ static int winch_tramp(int fd, struct tty_struct *tty, int *fd_out)
         }
 
         data = ((struct winch_data) { .pty_fd           = fd,
-                                      .pipe_fd          = fds[1],
-                                      .close_me         = fds[0] } );
-        err = run_helper_thread(winch_thread, &data, 0, &stack, 0);
+                                      .pipe_fd          = fds[1] } );
+        /* CLONE_FILES so this thread doesn't hold open files which are open
+         * now, but later closed.  This is a problem with /dev/net/tun.
+         */
+        err = run_helper_thread(winch_thread, &data, CLONE_FILES, &stack, 0);
         if(err < 0){
                 printk("fork of winch_thread failed - errno = %d\n", errno);
                 goto out_close;
         }
 
-        os_close_file(fds[1]);
         *fd_out = fds[0];
         n = os_read_file(fds[0], &c, sizeof(c));
         if(n != sizeof(c)){
@@ -169,13 +169,12 @@ static int winch_tramp(int fd, struct tty_struct *tty, int *fd_out)
                 printk("read failed, err = %d\n", -n);
                 printk("fd %d will not support SIGWINCH\n", fd);
                 err = -EINVAL;
-                goto out_close1;
+                goto out_close;
         }
         return err ;
 
  out_close:
         os_close_file(fds[1]);
- out_close1:
         os_close_file(fds[0]);
  out:
         return err;
diff --git a/arch/um/drivers/daemon_kern.c b/arch/um/drivers/daemon_kern.c
index 30d285b266af..a61b7b46bc02 100644
--- a/arch/um/drivers/daemon_kern.c
+++ b/arch/um/drivers/daemon_kern.c
@@ -18,7 +18,7 @@ struct daemon_init {
         char *ctl_sock;
 };
 
-void daemon_init(struct net_device *dev, void *data)
+static void daemon_init(struct net_device *dev, void *data)
 {
         struct uml_net_private *pri;
         struct daemon_data *dpri;
@@ -31,6 +31,10 @@ void daemon_init(struct net_device *dev, void *data)
         dpri->fd = -1;
         dpri->control = -1;
         dpri->dev = dev;
+        /* We will free this pointer. If it contains crap we're burned. */
+        dpri->ctl_addr = NULL;
+        dpri->data_addr = NULL;
+        dpri->local_addr = NULL;
 
         printk("daemon backend (uml_switch version %d) - %s:%s", 
                SWITCH_VERSION, dpri->sock_type, dpri->ctl_sock);
@@ -60,7 +64,7 @@ static struct net_kern_info daemon_kern_info = {
         .write                  = daemon_write,
 };
 
-int daemon_setup(char *str, char **mac_out, void *data)
+static int daemon_setup(char *str, char **mac_out, void *data)
 {
         struct daemon_init *init = data;
         char *remain;
diff --git a/arch/um/drivers/daemon_user.c b/arch/um/drivers/daemon_user.c
index 1bb085b2824d..c944265955e2 100644
--- a/arch/um/drivers/daemon_user.c
+++ b/arch/um/drivers/daemon_user.c
@@ -158,10 +158,16 @@ static void daemon_remove(void *data)
         struct daemon_data *pri = data;
 
         os_close_file(pri->fd);
+        pri->fd = -1;
         os_close_file(pri->control);
+        pri->control = -1;
+
         kfree(pri->data_addr);
+        pri->data_addr = NULL;
         kfree(pri->ctl_addr);
+        pri->ctl_addr = NULL;
         kfree(pri->local_addr);
+        pri->local_addr = NULL;
 }
 
 int daemon_user_write(int fd, void *buf, int len, struct daemon_data *pri)
diff --git a/arch/um/drivers/fd.c b/arch/um/drivers/fd.c
index 3296e86a03a5..c41f75e4acb5 100644
--- a/arch/um/drivers/fd.c
+++ b/arch/um/drivers/fd.c
@@ -11,6 +11,7 @@
 #include "user.h"
 #include "user_util.h"
 #include "chan_user.h"
+#include "os.h"
 
 struct fd_chan {
         int fd;
diff --git a/arch/um/drivers/line.c b/arch/um/drivers/line.c
index 46ceb25a9959..6c2d4ccaf20f 100644
--- a/arch/um/drivers/line.c
+++ b/arch/um/drivers/line.c
@@ -714,7 +714,7 @@ struct winch {
         struct tty_struct *tty;
 };
 
-irqreturn_t winch_interrupt(int irq, void *data, struct pt_regs *unused)
+static irqreturn_t winch_interrupt(int irq, void *data, struct pt_regs *unused)
 {
         struct winch *winch = data;
         struct tty_struct *tty;
diff --git a/arch/um/drivers/mcast_kern.c b/arch/um/drivers/mcast_kern.c
index 217438cdef33..c9b078fba03e 100644
--- a/arch/um/drivers/mcast_kern.c
+++ b/arch/um/drivers/mcast_kern.c
@@ -26,7 +26,7 @@ struct mcast_init {
         int ttl;
 };
 
-void mcast_init(struct net_device *dev, void *data)
+static void mcast_init(struct net_device *dev, void *data)
 {
         struct uml_net_private *pri;
         struct mcast_data *dpri;
@@ -40,7 +40,7 @@ void mcast_init(struct net_device *dev, void *data)
         dpri->dev = dev;
 
         printk("mcast backend ");
-        printk("multicast adddress: %s:%u, TTL:%u ",
+        printk("multicast address: %s:%u, TTL:%u ",
                dpri->addr, dpri->port, dpri->ttl);
 
         printk("\n");
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
index e3d576567172..54388d10bcf9 100644
--- a/arch/um/drivers/mconsole_kern.c
+++ b/arch/um/drivers/mconsole_kern.c
@@ -273,7 +273,7 @@ void mconsole_proc(struct mc_request *req)
     config <dev> - Query the configuration of a device \n\
     remove <dev> - Remove a device from UML \n\
     sysrq <letter> - Performs the SysRq action controlled by the letter \n\
-    cad - invoke the Ctl-Alt-Del handler \n\
+    cad - invoke the Ctrl-Alt-Del handler \n\
     stop - pause the UML; it will do nothing until it receives a 'go' \n\
     go - continue the UML after a 'stop' \n\
     log <string> - make UML enter <string> into the kernel log\n\
@@ -327,7 +327,7 @@ void mconsole_stop(struct mc_request *req)
 
 /* This list is populated by __initcall routines. */
 
-LIST_HEAD(mconsole_devices);
+static LIST_HEAD(mconsole_devices);
 
 void mconsole_register_dev(struct mc_device *new)
 {
@@ -561,6 +561,8 @@ void mconsole_sysrq(struct mc_request *req)
 }
 #endif
 
+#ifdef CONFIG_MODE_SKAS
+
 static void stack_proc(void *arg)
 {
         struct task_struct *from = current, *to = arg;
@@ -574,7 +576,7 @@ static void stack_proc(void *arg)
  *  Dumps a stacks registers to the linux console.
  *  Usage stack <pid>.
  */
-void do_stack(struct mc_request *req)
+static void do_stack_trace(struct mc_request *req)
 {
         char *ptr = req->request.data;
         int pid_requested= -1;
@@ -605,6 +607,7 @@ void do_stack(struct mc_request *req)
         }
         with_console(req, stack_proc, to);
 }
+#endif /* CONFIG_MODE_SKAS */
 
 void mconsole_stack(struct mc_request *req)
 {
@@ -613,7 +616,7 @@ void mconsole_stack(struct mc_request *req)
          */
         CHOOSE_MODE(mconsole_reply(req, "Sorry, this doesn't work in TT mode",
                                    1, 0),
-                    do_stack(req));
+                    do_stack_trace(req));
 }
 
 /* Changed by mconsole_setup, which is __setup, and called before SMP is
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
index fb1f9fb9b871..8c7279bb353b 100644
--- a/arch/um/drivers/net_kern.c
+++ b/arch/um/drivers/net_kern.c
@@ -68,6 +68,11 @@ static int uml_net_rx(struct net_device *dev)
         return pkt_len;
 }
 
+static void uml_dev_close(void* dev)
+{
+        dev_close( (struct net_device *) dev);
+}
+
 irqreturn_t uml_net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         struct net_device *dev = dev_id;
@@ -80,15 +85,21 @@ irqreturn_t uml_net_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         spin_lock(&lp->lock);
         while((err = uml_net_rx(dev)) > 0) ;
         if(err < 0) {
+                DECLARE_WORK(close_work, uml_dev_close, dev);
                 printk(KERN_ERR 
                        "Device '%s' read returned %d, shutting it down\n", 
                        dev->name, err);
-                dev_close(dev);
+                /* dev_close can't be called in interrupt context, and takes
+                 * again lp->lock.
+                 * And dev_close() can be safely called multiple times on the
+                 * same device, since it tests for (dev->flags & IFF_UP). So
+                 * there's no harm in delaying the device shutdown. */
+                schedule_work(&close_work);
                 goto out;
         }
         reactivate_fd(lp->fd, UM_ETH_IRQ);
 
- out:
+out:
         spin_unlock(&lp->lock);
         return(IRQ_HANDLED);
 }
@@ -120,9 +131,8 @@ static int uml_net_open(struct net_device *dev)
                              SA_INTERRUPT | SA_SHIRQ, dev->name, dev);
         if(err != 0){
                 printk(KERN_ERR "uml_net_open: failed to get irq(%d)\n", err);
-                if(lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
-                lp->fd = -1;
                 err = -ENETUNREACH;
+                goto out_close;
         }
 
         lp->tl.data = (unsigned long) &lp->user;
@@ -134,9 +144,19 @@ static int uml_net_open(struct net_device *dev)
          */
         while((err = uml_net_rx(dev)) > 0) ;
 
- out:
         spin_unlock(&lp->lock);
-        return(err);
+
+        spin_lock(&opened_lock);
+        list_add(&lp->list, &opened);
+        spin_unlock(&opened_lock);
+
+        return 0;
+out_close:
+        if(lp->close != NULL) (*lp->close)(lp->fd, &lp->user);
+        lp->fd = -1;
+out:
+        spin_unlock(&lp->lock);
+        return err;
 }
 
 static int uml_net_close(struct net_device *dev)
@@ -150,9 +170,13 @@ static int uml_net_close(struct net_device *dev)
         if(lp->close != NULL)
                 (*lp->close)(lp->fd, &lp->user);
         lp->fd = -1;
-        list_del(&lp->list);
 
         spin_unlock(&lp->lock);
+
+        spin_lock(&opened_lock);
+        list_del(&lp->list);
+        spin_unlock(&opened_lock);
+
         return 0;
 }
 
@@ -317,6 +341,11 @@ static int eth_configure(int n, void *init, char *mac,
                 return 1;
         }
 
+        lp = dev->priv;
+        /* This points to the transport private data. It's still clear, but we
+         * must memset it to 0 *now*. Let's help the drivers. */
+        memset(lp, 0, size);
+
         /* sysfs register */
         if (!driver_registered) {
                 platform_driver_register(&uml_net_driver);
@@ -358,7 +387,6 @@ static int eth_configure(int n, void *init, char *mac,
                 free_netdev(dev);
                 return 1;
         }
-        lp = dev->priv;
 
         /* lp.user is the first four bytes of the transport data, which
          * has already been initialized.  This structure assignment will
@@ -395,11 +423,7 @@ static int eth_configure(int n, void *init, char *mac,
         if (device->have_mac)
                 set_ether_mac(dev, device->mac);
 
-        spin_lock(&opened_lock);
-        list_add(&lp->list, &opened);
-        spin_unlock(&opened_lock);
-
-        return(0);
+        return 0;
 }
 
 static struct uml_net *find_device(int n)
diff --git a/arch/um/drivers/slip_common.h b/arch/um/drivers/slip_common.h
index 2ae76d8f1be1..d574e0a9dc13 100644
--- a/arch/um/drivers/slip_common.h
+++ b/arch/um/drivers/slip_common.h
@@ -88,12 +88,13 @@ struct slip_proto {
         int esc;
 };
 
-#define SLIP_PROTO_INIT { \
-        .ibuf   = { '\0' }, \
-        .obuf   = { '\0' }, \
-        .more   = 0, \
-        .pos    = 0, \
-        .esc    = 0 \
+static inline void slip_proto_init(struct slip_proto * slip)
+{
+        memset(slip->ibuf, 0, sizeof(slip->ibuf));
+        memset(slip->obuf, 0, sizeof(slip->obuf));
+        slip->more = 0;
+        slip->pos = 0;
+        slip->esc = 0;
 }
 
 extern int slip_proto_read(int fd, void *buf, int len,
diff --git a/arch/um/drivers/slip_kern.c b/arch/um/drivers/slip_kern.c
index 9a6f5c85f902..a62f5ef445cf 100644
--- a/arch/um/drivers/slip_kern.c
+++ b/arch/um/drivers/slip_kern.c
@@ -21,13 +21,14 @@ void slip_init(struct net_device *dev, void *data)
 
         private = dev->priv;
         spri = (struct slip_data *) private->user;
-        *spri = ((struct slip_data)
-                { .name         = { '\0' },
-                  .addr         = NULL,
-                  .gate_addr    = init->gate_addr,
-                  .slave        = -1,
-                  .slip         = SLIP_PROTO_INIT,
-                  .dev          = dev });
+
+        memset(spri->name, 0, sizeof(spri->name));
+        spri->addr = NULL;
+        spri->gate_addr = init->gate_addr;
+        spri->slave = -1;
+        spri->dev = dev;
+
+        slip_proto_init(&spri->slip);
 
         dev->init = NULL;
         dev->header_cache_update = NULL;
diff --git a/arch/um/drivers/slirp_kern.c b/arch/um/drivers/slirp_kern.c
index 9864d27afdbe..33d7982be5d3 100644
--- a/arch/um/drivers/slirp_kern.c
+++ b/arch/um/drivers/slirp_kern.c
@@ -21,12 +21,13 @@ void slirp_init(struct net_device *dev, void *data)
 
         private = dev->priv;
         spri = (struct slirp_data *) private->user;
-        *spri = ((struct slirp_data)
-                { .argw         = init->argw,
-                  .pid          = -1,
-                  .slave        = -1,
-                  .slip         = SLIP_PROTO_INIT,
-                  .dev          = dev });
+
+        spri->argw = init->argw;
+        spri->pid = -1;
+        spri->slave = -1;
+        spri->dev = dev;
+
+        slip_proto_init(&spri->slip);
 
         dev->init = NULL;
         dev->hard_header_len = 0;
diff --git a/arch/um/drivers/ssl.c b/arch/um/drivers/ssl.c
index a32ef55cb244..a4d6415bc8c4 100644
--- a/arch/um/drivers/ssl.c
+++ b/arch/um/drivers/ssl.c
@@ -33,7 +33,7 @@ static struct tty_driver *ssl_driver;
 
 #define NR_PORTS 64
 
-void ssl_announce(char *dev_name, int dev)
+static void ssl_announce(char *dev_name, int dev)
 {
         printk(KERN_INFO "Serial line %d assigned device '%s'\n", dev,
                dev_name);
@@ -98,7 +98,7 @@ static int ssl_remove(int n)
         return line_remove(serial_lines, ARRAY_SIZE(serial_lines), n);
 }
 
-int ssl_open(struct tty_struct *tty, struct file *filp)
+static int ssl_open(struct tty_struct *tty, struct file *filp)
 {
         return line_open(serial_lines, tty);
 }
@@ -182,7 +182,7 @@ static struct console ssl_cons = {
         .index          = -1,
 };
 
-int ssl_init(void)
+static int ssl_init(void)
 {
         char *new_title;
 
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index 7696f8d2d89c..101efd26d467 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -1103,31 +1103,33 @@ static int ubd_ioctl(struct inode * inode, struct file * file,
         return(-EINVAL);
 }
 
-static int same_backing_files(char *from_cmdline, char *from_cow, char *cow)
+static int path_requires_switch(char *from_cmdline, char *from_cow, char *cow)
 {
         struct uml_stat buf1, buf2;
         int err;
 
-        if(from_cmdline == NULL) return(1);
-        if(!strcmp(from_cmdline, from_cow)) return(1);
+        if(from_cmdline == NULL)
+                return 0;
+        if(!strcmp(from_cmdline, from_cow))
+                return 0;
 
         err = os_stat_file(from_cmdline, &buf1);
         if(err < 0){
                 printk("Couldn't stat '%s', err = %d\n", from_cmdline, -err);
-                return(1);
+                return 0;
         }
         err = os_stat_file(from_cow, &buf2);
         if(err < 0){
                 printk("Couldn't stat '%s', err = %d\n", from_cow, -err);
-                return(1);
+                return 1;
         }
         if((buf1.ust_dev == buf2.ust_dev) && (buf1.ust_ino == buf2.ust_ino))
-                return(1);
+                return 0;
 
         printk("Backing file mismatch - \"%s\" requested,\n"
                "\"%s\" specified in COW header of \"%s\"\n",
                from_cmdline, from_cow, cow);
-        return(0);
+        return 1;
 }
 
 static int backing_file_mismatch(char *file, __u64 size, time_t mtime)
@@ -1189,18 +1191,19 @@ int open_ubd_file(char *file, struct openflags *openflags,
         unsigned long long size;
         __u32 version, align;
         char *backing_file;
-        int fd, err, sectorsize, same, mode = 0644;
+        int fd, err, sectorsize, asked_switch, mode = 0644;
 
         fd = os_open_file(file, *openflags, mode);
-        if(fd < 0){
-                if((fd == -ENOENT) && (create_cow_out != NULL))
+        if (fd < 0) {
+                if ((fd == -ENOENT) && (create_cow_out != NULL))
                         *create_cow_out = 1;
-                if(!openflags->w ||
-                   ((fd != -EROFS) && (fd != -EACCES))) return(fd);
+                if (!openflags->w ||
+                   ((fd != -EROFS) && (fd != -EACCES)))
+                        return fd;
                 openflags->w = 0;
                 fd = os_open_file(file, *openflags, mode);
-                if(fd < 0)
-                        return(fd);
+                if (fd < 0)
+                        return fd;
         }
 
         err = os_lock_file(fd, openflags->w);
@@ -1209,7 +1212,9 @@ int open_ubd_file(char *file, struct openflags *openflags,
                 goto out_close;
         }
 
-        if(backing_file_out == NULL) return(fd);
+        /* Succesful return case! */
+        if(backing_file_out == NULL)
+                return(fd);
 
         err = read_cow_header(file_reader, &fd, &version, &backing_file, &mtime,
                               &size, &sectorsize, &align, bitmap_offset_out);
@@ -1218,34 +1223,34 @@ int open_ubd_file(char *file, struct openflags *openflags,
                        "errno = %d\n", file, -err);
                 goto out_close;
         }
-        if(err) return(fd);
-
-        if(backing_file_out == NULL) return(fd);
+        if(err)
+                return(fd);
 
-        same = same_backing_files(*backing_file_out, backing_file, file);
+        asked_switch = path_requires_switch(*backing_file_out, backing_file, file);
 
-        if(!same && !backing_file_mismatch(*backing_file_out, size, mtime)){
+        /* Allow switching only if no mismatch. */
+        if (asked_switch && !backing_file_mismatch(*backing_file_out, size, mtime)) {
                 printk("Switching backing file to '%s'\n", *backing_file_out);
                 err = write_cow_header(file, fd, *backing_file_out,
                                        sectorsize, align, &size);
-                if(err){
+                if (err) {
                         printk("Switch failed, errno = %d\n", -err);
-                        return(err);
+                        goto out_close;
                 }
-        }
-        else {
+        } else {
                 *backing_file_out = backing_file;
                 err = backing_file_mismatch(*backing_file_out, size, mtime);
-                if(err) goto out_close;
+                if (err)
+                        goto out_close;
         }
 
         cow_sizes(version, size, sectorsize, align, *bitmap_offset_out,
                   bitmap_len_out, data_offset_out);
 
-        return(fd);
+        return fd;
  out_close:
         os_close_file(fd);
-        return(err);
+        return err;
 }
 
 int create_cow_file(char *cow_file, char *backing_file, struct openflags flags,
diff --git a/arch/um/include/kern_util.h b/arch/um/include/kern_util.h
index 8f4e46d677ab..07176d92e1c9 100644
--- a/arch/um/include/kern_util.h
+++ b/arch/um/include/kern_util.h
@@ -31,8 +31,6 @@ extern int timer_irq_inited;
 extern int jail;
 extern int nsyscalls;
 
-extern struct task_struct *idle_threads[NR_CPUS];
-
 #define UML_ROUND_DOWN(addr) ((void *)(((unsigned long) addr) & PAGE_MASK))
 #define UML_ROUND_UP(addr) \
         UML_ROUND_DOWN(((unsigned long) addr) + PAGE_SIZE - 1)
@@ -120,8 +118,10 @@ extern void machine_halt(void);
 extern int is_syscall(unsigned long addr);
 extern void arch_switch(void);
 extern void free_irq(unsigned int, void *);
-extern int um_in_interrupt(void);
 extern int cpu(void);
+
+/* Are we disallowed to sleep? Used to choose between GFP_KERNEL and GFP_ATOMIC. */
+extern int __cant_sleep(void);
 extern void segv_handler(int sig, union uml_pt_regs *regs);
 extern void sigio_handler(int sig, union uml_pt_regs *regs);
 
diff --git a/arch/um/include/longjmp.h b/arch/um/include/longjmp.h
new file mode 100644
index 000000000000..018b3819ab0b
--- /dev/null
+++ b/arch/um/include/longjmp.h
@@ -0,0 +1,19 @@
+#ifndef __UML_LONGJMP_H
+#define __UML_LONGJMP_H
+
+#include <setjmp.h>
+#include "os.h"
+
+#define UML_SIGLONGJMP(buf, val) do { \
+        longjmp(*buf, val);     \
+} while(0)
+
+#define UML_SIGSETJMP(buf, enable) ({ \
+        int n; \
+        enable = get_signals(); \
+        n = setjmp(*buf); \
+        if(n != 0) \
+                set_signals(enable); \
+        n; })
+
+#endif
diff --git a/arch/um/include/mode_kern.h b/arch/um/include/mode_kern.h
index 2d88afd0cf16..e7539a8451ef 100644
--- a/arch/um/include/mode_kern.h
+++ b/arch/um/include/mode_kern.h
@@ -9,22 +9,11 @@
 #include "linux/config.h"
 
 #ifdef CONFIG_MODE_TT
-#include "mode_kern-tt.h"
+#include "mode_kern_tt.h"
 #endif
 
 #ifdef CONFIG_MODE_SKAS
-#include "mode_kern-skas.h"
+#include "mode_kern_skas.h"
 #endif
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/include/os.h b/arch/um/include/os.h
index dd72d66cf0ed..eb1710b81255 100644
--- a/arch/um/include/os.h
+++ b/arch/um/include/os.h
@@ -11,6 +11,7 @@
 #include "../os/include/file.h"
 #include "sysdep/ptrace.h"
 #include "kern_util.h"
+#include "skas/mm_id.h"
 
 #define OS_TYPE_FILE 1 
 #define OS_TYPE_DIR 2 
@@ -190,11 +191,12 @@ extern int os_protect_memory(void *addr, unsigned long len,
                              int r, int w, int x);
 extern int os_unmap_memory(void *addr, int len);
 extern void os_flush_stdout(void);
-extern unsigned long long os_usecs(void);
 
 /* tt.c
  * for tt mode only (will be deleted in future...)
  */
+extern void stop(void);
+extern int wait_for_stop(int pid, int sig, int cont_type, void *relay);
 extern int protect_memory(unsigned long addr, unsigned long len,
                           int r, int w, int x, int must_succeed);
 extern void forward_pending_sigio(int target);
@@ -230,9 +232,63 @@ extern void block_signals(void);
 extern void unblock_signals(void);
 extern int get_signals(void);
 extern int set_signals(int enable);
+extern void os_usr1_signal(int on);
 
 /* trap.c */
 extern void os_fill_handlinfo(struct kern_handlers h);
 extern void do_longjmp(void *p, int val);
 
+/* util.c */
+extern void stack_protections(unsigned long address);
+extern void task_protections(unsigned long address);
+extern int raw(int fd);
+extern void setup_machinename(char *machine_out);
+extern void setup_hostinfo(void);
+extern int setjmp_wrapper(void (*proc)(void *, void *), ...);
+
+/* time.c */
+#define BILLION (1000 * 1000 * 1000)
+
+extern void switch_timers(int to_real);
+extern void idle_sleep(int secs);
+extern void enable_timer(void);
+extern void disable_timer(void);
+extern void user_time_init(void);
+extern void uml_idle_timer(void);
+extern unsigned long long os_nsecs(void);
+
+/* skas/mem.c */
+extern long run_syscall_stub(struct mm_id * mm_idp,
+                             int syscall, unsigned long *args, long expected,
+                             void **addr, int done);
+extern long syscall_stub_data(struct mm_id * mm_idp,
+                              unsigned long *data, int data_count,
+                              void **addr, void **stub_addr);
+extern int map(struct mm_id * mm_idp, unsigned long virt,
+               unsigned long len, int r, int w, int x, int phys_fd,
+               unsigned long long offset, int done, void **data);
+extern int unmap(struct mm_id * mm_idp, void *addr, unsigned long len,
+                 int done, void **data);
+extern int protect(struct mm_id * mm_idp, unsigned long addr,
+                   unsigned long len, int r, int w, int x, int done,
+                   void **data);
+
+/* skas/process.c */
+extern int is_skas_winch(int pid, int fd, void *data);
+extern int start_userspace(unsigned long stub_stack);
+extern int copy_context_skas0(unsigned long stack, int pid);
+extern void userspace(union uml_pt_regs *regs);
+extern void map_stub_pages(int fd, unsigned long code,
+                           unsigned long data, unsigned long stack);
+extern void new_thread(void *stack, void **switch_buf_ptr,
+                         void **fork_buf_ptr, void (*handler)(int));
+extern void thread_wait(void *sw, void *fb);
+extern void switch_threads(void *me, void *next);
+extern int start_idle_thread(void *stack, void *switch_buf_ptr,
+                             void **fork_buf_ptr);
+extern void initial_thread_cb_skas(void (*proc)(void *),
+                                 void *arg);
+extern void halt_skas(void);
+extern void reboot_skas(void);
+
 #endif
diff --git a/arch/um/include/registers.h b/arch/um/include/registers.h
index 4892e5fcef07..83b688ca198f 100644
--- a/arch/um/include/registers.h
+++ b/arch/um/include/registers.h
@@ -14,7 +14,7 @@ extern int restore_fp_registers(int pid, unsigned long *fp_regs);
 extern void save_registers(int pid, union uml_pt_regs *regs);
 extern void restore_registers(int pid, union uml_pt_regs *regs);
 extern void init_registers(int pid);
-extern void get_safe_registers(unsigned long * regs);
+extern void get_safe_registers(unsigned long * regs, unsigned long * fp_regs);
 extern void get_thread_regs(union uml_pt_regs *uml_regs, void *buffer);
 
 #endif
diff --git a/arch/um/kernel/skas/include/mm_id.h b/arch/um/include/skas/mm_id.h
index 48dd0989ddaa..48dd0989ddaa 100644
--- a/arch/um/kernel/skas/include/mm_id.h
+++ b/arch/um/include/skas/mm_id.h
diff --git a/arch/um/include/skas/mmu-skas.h b/arch/um/include/skas/mmu-skas.h
new file mode 100644
index 000000000000..d8869a6ef1b4
--- /dev/null
+++ b/arch/um/include/skas/mmu-skas.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_MMU_H
+#define __SKAS_MMU_H
+
+#include "linux/config.h"
+#include "mm_id.h"
+#include "asm/ldt.h"
+
+struct mmu_context_skas {
+        struct mm_id id;
+        unsigned long last_page_table;
+#ifdef CONFIG_3_LEVEL_PGTABLES
+        unsigned long last_pmd;
+#endif
+        uml_ldt_t ldt;
+};
+
+extern void switch_mm_skas(struct mm_id * mm_idp);
+
+#endif
diff --git a/arch/um/include/skas/mode-skas.h b/arch/um/include/skas/mode-skas.h
new file mode 100644
index 000000000000..260065cfeef1
--- /dev/null
+++ b/arch/um/include/skas/mode-skas.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MODE_SKAS_H__
+#define __MODE_SKAS_H__
+
+#include <sysdep/ptrace.h>
+
+extern unsigned long exec_regs[];
+extern unsigned long exec_fp_regs[];
+extern unsigned long exec_fpx_regs[];
+extern int have_fpx_regs;
+
+extern void sig_handler_common_skas(int sig, void *sc_ptr);
+extern void kill_off_processes_skas(void);
+
+#endif
diff --git a/arch/um/kernel/skas/include/mode_kern-skas.h b/arch/um/include/skas/mode_kern_skas.h
index c97a80dfe370..63c58739bde0 100644
--- a/arch/um/kernel/skas/include/mode_kern-skas.h
+++ b/arch/um/include/skas/mode_kern_skas.h
@@ -18,7 +18,6 @@ extern int copy_thread_skas(int nr, unsigned long clone_flags,
                             unsigned long sp, unsigned long stack_top,
                             struct task_struct *p, struct pt_regs *regs);
 extern void release_thread_skas(struct task_struct *task);
-extern void initial_thread_cb_skas(void (*proc)(void *), void *arg);
 extern void init_idle_skas(void);
 extern void flush_tlb_kernel_range_skas(unsigned long start,
                                         unsigned long end);
@@ -39,14 +38,3 @@ extern int thread_pid_skas(struct task_struct *task);
 #define kmem_end_skas (host_task_size - 1024 * 1024)
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/skas/include/proc_mm.h b/arch/um/include/skas/proc_mm.h
index cce61a679052..902809209603 100644
--- a/arch/um/kernel/skas/include/proc_mm.h
+++ b/arch/um/include/skas/proc_mm.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -22,13 +22,13 @@ struct mm_mmap {
 
 struct mm_munmap {
         unsigned long addr;
-        unsigned long len;      
+        unsigned long len;
 };
 
 struct mm_mprotect {
         unsigned long addr;
         unsigned long len;
-        unsigned int prot;
+        unsigned int prot;
 };
 
 struct proc_mm_op {
@@ -42,14 +42,3 @@ struct proc_mm_op {
 };
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/include/skas/skas.h b/arch/um/include/skas/skas.h
new file mode 100644
index 000000000000..86357282d681
--- /dev/null
+++ b/arch/um/include/skas/skas.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __SKAS_H
+#define __SKAS_H
+
+#include "mm_id.h"
+#include "sysdep/ptrace.h"
+
+extern int userspace_pid[];
+extern int proc_mm, ptrace_faultinfo, ptrace_ldt;
+extern int skas_needs_stub;
+
+extern int user_thread(unsigned long stack, int flags);
+extern void new_thread_proc(void *stack, void (*handler)(int sig));
+extern void new_thread_handler(int sig);
+extern void handle_syscall(union uml_pt_regs *regs);
+extern void user_signal(int sig, union uml_pt_regs *regs, int pid);
+extern int new_mm(unsigned long stack);
+extern void get_skas_faultinfo(int pid, struct faultinfo * fi);
+extern long execute_syscall_skas(void *r);
+extern unsigned long current_stub_stack(void);
+
+#endif
diff --git a/arch/um/kernel/skas/include/stub-data.h b/arch/um/include/skas/stub-data.h
index f6ed92c3727d..f6ed92c3727d 100644
--- a/arch/um/kernel/skas/include/stub-data.h
+++ b/arch/um/include/skas/stub-data.h
diff --git a/arch/um/kernel/skas/include/uaccess-skas.h b/arch/um/include/skas/uaccess-skas.h
index 64516c556cdf..224a75f4c025 100644
--- a/arch/um/kernel/skas/include/uaccess-skas.h
+++ b/arch/um/include/skas/uaccess-skas.h
@@ -19,14 +19,3 @@ extern int clear_user_skas(void __user *mem, int len);
 extern int strnlen_user_skas(const void __user *str, int len);
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/include/time_user.h b/arch/um/include/time_user.h
deleted file mode 100644
index 17d7ef2141f4..000000000000
--- a/arch/um/include/time_user.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/* 
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __TIME_USER_H__
-#define __TIME_USER_H__
-
-extern void timer(void);
-extern void switch_timers(int to_real);
-extern void idle_sleep(int secs);
-extern void enable_timer(void);
-extern void prepare_timer(void * ptr);
-extern void disable_timer(void);
-extern unsigned long time_lock(void);
-extern void time_unlock(unsigned long);
-extern void user_time_init(void);
-
-#endif
diff --git a/arch/um/kernel/tt/include/debug.h b/arch/um/include/tt/debug.h
index 738435461e13..9778fa838296 100644
--- a/arch/um/kernel/tt/include/debug.h
+++ b/arch/um/include/tt/debug.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2000, 2001, 2002  Jeff Dike (jdike@karaya.com) and
  * Lars Brinkhoff.
  * Licensed under the GPL
diff --git a/arch/um/include/tt/mmu-tt.h b/arch/um/include/tt/mmu-tt.h
new file mode 100644
index 000000000000..572a78b22587
--- /dev/null
+++ b/arch/um/include/tt/mmu-tt.h
@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TT_MMU_H
+#define __TT_MMU_H
+
+struct mmu_context_tt {
+};
+
+#endif
diff --git a/arch/um/include/tt/mode-tt.h b/arch/um/include/tt/mode-tt.h
new file mode 100644
index 000000000000..2823cd56eea2
--- /dev/null
+++ b/arch/um/include/tt/mode-tt.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __MODE_TT_H__
+#define __MODE_TT_H__
+
+#include "sysdep/ptrace.h"
+
+enum { OP_NONE, OP_EXEC, OP_FORK, OP_TRACE_ON, OP_REBOOT, OP_HALT, OP_CB };
+
+extern int tracing_pid;
+
+extern int tracer(int (*init_proc)(void *), void *sp);
+extern void sig_handler_common_tt(int sig, void *sc);
+extern void syscall_handler_tt(int sig, union uml_pt_regs *regs);
+extern void reboot_tt(void);
+extern void halt_tt(void);
+extern int is_tracer_winch(int pid, int fd, void *data);
+extern void kill_off_processes_tt(void);
+
+#endif
diff --git a/arch/um/include/tt/mode_kern_tt.h b/arch/um/include/tt/mode_kern_tt.h
new file mode 100644
index 000000000000..efa0012550d0
--- /dev/null
+++ b/arch/um/include/tt/mode_kern_tt.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#ifndef __TT_MODE_KERN_H__
+#define __TT_MODE_KERN_H__
+
+#include "linux/sched.h"
+#include "asm/page.h"
+#include "asm/ptrace.h"
+#include "asm/uaccess.h"
+
+extern void switch_to_tt(void *prev, void *next);
+extern void flush_thread_tt(void);
+extern void start_thread_tt(struct pt_regs *regs, unsigned long eip,
+                           unsigned long esp);
+extern int copy_thread_tt(int nr, unsigned long clone_flags, unsigned long sp,
+                          unsigned long stack_top, struct task_struct *p,
+                          struct pt_regs *regs);
+extern void release_thread_tt(struct task_struct *task);
+extern void initial_thread_cb_tt(void (*proc)(void *), void *arg);
+extern void init_idle_tt(void);
+extern void flush_tlb_kernel_range_tt(unsigned long start, unsigned long end);
+extern void flush_tlb_kernel_vm_tt(void);
+extern void __flush_tlb_one_tt(unsigned long addr);
+extern void flush_tlb_range_tt(struct vm_area_struct *vma,
+                               unsigned long start, unsigned long end);
+extern void flush_tlb_mm_tt(struct mm_struct *mm);
+extern void force_flush_all_tt(void);
+extern long execute_syscall_tt(void *r);
+extern void before_mem_tt(unsigned long brk_start);
+extern unsigned long set_task_sizes_tt(int arg, unsigned long *host_size_out,
+                                       unsigned long *task_size_out);
+extern int start_uml_tt(void);
+extern int external_pid_tt(struct task_struct *task);
+extern int thread_pid_tt(struct task_struct *task);
+
+#define kmem_end_tt (host_task_size - ABOVE_KMEM)
+
+#endif
diff --git a/arch/um/kernel/tt/include/tt.h b/arch/um/include/tt/tt.h
index c667b67af405..808521980186 100644
--- a/arch/um/kernel/tt/include/tt.h
+++ b/arch/um/include/tt/tt.h
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -34,13 +34,3 @@ extern long execute_syscall_tt(void *r);
 
 #endif
 
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/tt/include/uaccess-tt.h b/arch/um/include/tt/uaccess-tt.h
index b9bfe9c481c4..b19645f32f24 100644
--- a/arch/um/kernel/tt/include/uaccess-tt.h
+++ b/arch/um/include/tt/uaccess-tt.h
@@ -46,14 +46,3 @@ extern int clear_user_tt(void __user *mem, int len);
 extern int strnlen_user_tt(const void __user *str, int len);
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/include/user.h b/arch/um/include/user.h
index 0f865ef46918..91b0ac4ad88c 100644
--- a/arch/um/include/user.h
+++ b/arch/um/include/user.h
@@ -18,6 +18,7 @@ extern int open_gdb_chan(void);
 extern unsigned long strlcpy(char *, const char *, unsigned long);
 extern unsigned long strlcat(char *, const char *, unsigned long);
 extern void *um_vmalloc(int size);
+extern void *um_vmalloc_atomic(int size);
 extern void vfree(void *ptr);
 
 #endif
diff --git a/arch/um/include/user_util.h b/arch/um/include/user_util.h
index c1dbd77b073f..a6f1f176cf84 100644
--- a/arch/um/include/user_util.h
+++ b/arch/um/include/user_util.h
@@ -44,10 +44,6 @@ extern unsigned long brk_start;
 extern int pty_output_sigio;
 extern int pty_close_sigio;
 
-extern void stop(void);
-extern void stack_protections(unsigned long address);
-extern void task_protections(unsigned long address);
-extern int wait_for_stop(int pid, int sig, int cont_type, void *relay);
 extern void *add_signal_handler(int sig, void (*handler)(int));
 extern int linux_main(int argc, char **argv);
 extern void set_cmdline(char *cmd);
@@ -55,8 +51,6 @@ extern void input_cb(void (*proc)(void *), void *arg, int arg_len);
 extern int get_pty(void);
 extern void *um_kmalloc(int size);
 extern int switcheroo(int fd, int prot, void *from, void *to, int size);
-extern void setup_machinename(char *machine_out);
-extern void setup_hostinfo(void);
 extern void do_exec(int old_pid, int new_pid);
 extern void tracer_panic(char *msg, ...);
 extern int detach(int pid, int sig);
@@ -70,18 +64,6 @@ extern int cpu_feature(char *what, char *buf, int len);
 extern int arch_handle_signal(int sig, union uml_pt_regs *regs);
 extern int arch_fixup(unsigned long address, void *sc_ptr);
 extern void arch_init_thread(void);
-extern int setjmp_wrapper(void (*proc)(void *, void *), ...);
 extern int raw(int fd);
 
 #endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/Makefile b/arch/um/kernel/Makefile
index 193cc2b7448d..693018ba80f1 100644
--- a/arch/um/kernel/Makefile
+++ b/arch/um/kernel/Makefile
@@ -9,9 +9,8 @@ clean-files :=
 obj-y = config.o exec_kern.o exitcode.o \
         init_task.o irq.o irq_user.o ksyms.o mem.o physmem.o \
         process_kern.o ptrace.o reboot.o resource.o sigio_user.o sigio_kern.o \
-        signal_kern.o smp.o syscall_kern.o sysrq.o time.o \
-        time_kern.o tlb.o trap_kern.o uaccess.o um_arch.o umid.o \
-        user_util.o
+        signal_kern.o smp.o syscall_kern.o sysrq.o \
+        time_kern.o tlb.o trap_kern.o uaccess.o um_arch.o umid.o
 
 obj-$(CONFIG_BLK_DEV_INITRD) += initrd.o
 obj-$(CONFIG_GPROF)     += gprof_syms.o
@@ -24,7 +23,7 @@ obj-$(CONFIG_MODE_SKAS) += skas/
 
 user-objs-$(CONFIG_TTY_LOG) += tty_log.o
 
-USER_OBJS := $(user-objs-y) config.o time.o tty_log.o user_util.o
+USER_OBJS := $(user-objs-y) config.o tty_log.o
 
 include arch/um/scripts/Makefile.rules
 
diff --git a/arch/um/kernel/exec_kern.c b/arch/um/kernel/exec_kern.c
index efd222ffe20e..c264e1c05ab3 100644
--- a/arch/um/kernel/exec_kern.c
+++ b/arch/um/kernel/exec_kern.c
@@ -17,7 +17,6 @@
 #include "irq_user.h"
 #include "tlb.h"
 #include "os.h"
-#include "time_user.h"
 #include "choose-mode.h"
 #include "mode_kern.h"
 
@@ -34,7 +33,7 @@ void start_thread(struct pt_regs *regs, unsigned long eip, unsigned long esp)
 extern void log_exec(char **argv, void *tty);
 
 static long execve1(char *file, char __user * __user *argv,
-                    char *__user __user *env)
+                    char __user *__user *env)
 {
         long error;
 
diff --git a/arch/um/kernel/physmem.c b/arch/um/kernel/physmem.c
index f3b583a878a6..544665e04513 100644
--- a/arch/um/kernel/physmem.c
+++ b/arch/um/kernel/physmem.c
@@ -265,7 +265,7 @@ int init_maps(unsigned long physmem, unsigned long iomem, unsigned long highmem)
         highmem_len = highmem_pages * sizeof(struct page);
 
         total_pages = phys_pages + iomem_pages + highmem_pages;
-        total_len = phys_len + iomem_pages + highmem_len;
+        total_len = phys_len + iomem_len + highmem_len;
 
         if(kmalloc_ok){
                 map = kmalloc(total_len, GFP_KERNEL);
diff --git a/arch/um/kernel/process_kern.c b/arch/um/kernel/process_kern.c
index 7f13b85d2656..3113cab8675e 100644
--- a/arch/um/kernel/process_kern.c
+++ b/arch/um/kernel/process_kern.c
@@ -39,7 +39,6 @@
 #include "init.h"
 #include "irq_user.h"
 #include "mem_user.h"
-#include "time_user.h"
 #include "tlb.h"
 #include "frame_kern.h"
 #include "sigcontext.h"
@@ -288,17 +287,27 @@ EXPORT_SYMBOL(disable_hlt);
 
 void *um_kmalloc(int size)
 {
-        return(kmalloc(size, GFP_KERNEL));
+        return kmalloc(size, GFP_KERNEL);
 }
 
 void *um_kmalloc_atomic(int size)
 {
-        return(kmalloc(size, GFP_ATOMIC));
+        return kmalloc(size, GFP_ATOMIC);
 }
 
 void *um_vmalloc(int size)
 {
-        return(vmalloc(size));
+        return vmalloc(size);
+}
+
+void *um_vmalloc_atomic(int size)
+{
+        return __vmalloc(size, GFP_ATOMIC | __GFP_HIGHMEM, PAGE_KERNEL);
+}
+
+int __cant_sleep(void) {
+        return in_atomic() || irqs_disabled() || in_interrupt();
+        /* Is in_interrupt() really needed? */
 }
 
 unsigned long get_fault_addr(void)
@@ -370,11 +379,6 @@ int smp_sigio_handler(void)
         return(0);
 }
 
-int um_in_interrupt(void)
-{
-        return(in_interrupt());
-}
-
 int cpu(void)
 {
         return(current_thread->cpu);
diff --git a/arch/um/kernel/reboot.c b/arch/um/kernel/reboot.c
index 6f1a3a288117..3ef73bf2e781 100644
--- a/arch/um/kernel/reboot.c
+++ b/arch/um/kernel/reboot.c
@@ -5,6 +5,7 @@
 
 #include "linux/module.h"
 #include "linux/sched.h"
+#include "asm/smp.h"
 #include "user_util.h"
 #include "kern_util.h"
 #include "kern.h"
diff --git a/arch/um/kernel/sigio_user.c b/arch/um/kernel/sigio_user.c
index 62e5cfdf2188..f7b18e157d35 100644
--- a/arch/um/kernel/sigio_user.c
+++ b/arch/um/kernel/sigio_user.c
@@ -337,70 +337,103 @@ int ignore_sigio_fd(int fd)
         return(err);
 }
 
-static int setup_initial_poll(int fd)
+static struct pollfd* setup_initial_poll(int fd)
 {
         struct pollfd *p;
 
-        p = um_kmalloc_atomic(sizeof(struct pollfd));
-        if(p == NULL){
+        p = um_kmalloc(sizeof(struct pollfd));
+        if (p == NULL) {
                 printk("setup_initial_poll : failed to allocate poll\n");
-                return(-1);
+                return NULL;
         }
         *p = ((struct pollfd) { .fd     = fd,
                                 .events         = POLLIN,
                                 .revents        = 0 });
-        current_poll = ((struct pollfds) { .poll        = p,
-                                           .used        = 1,
-                                           .size        = 1 });
-        return(0);
+        return p;
 }
 
 void write_sigio_workaround(void)
 {
         unsigned long stack;
+        struct pollfd *p;
         int err;
+        int l_write_sigio_fds[2];
+        int l_sigio_private[2];
+        int l_write_sigio_pid;
 
+        /* We call this *tons* of times - and most ones we must just fail. */
         sigio_lock();
-        if(write_sigio_pid != -1)
-                goto out;
+        l_write_sigio_pid = write_sigio_pid;
+        sigio_unlock();
 
-        err = os_pipe(write_sigio_fds, 1, 1);
+        if (l_write_sigio_pid != -1)
+                return;
+
+        err = os_pipe(l_write_sigio_fds, 1, 1);
         if(err < 0){
                 printk("write_sigio_workaround - os_pipe 1 failed, "
                        "err = %d\n", -err);
-                goto out;
+                return;
         }
-        err = os_pipe(sigio_private, 1, 1);
+        err = os_pipe(l_sigio_private, 1, 1);
         if(err < 0){
-                printk("write_sigio_workaround - os_pipe 2 failed, "
+                printk("write_sigio_workaround - os_pipe 1 failed, "
                        "err = %d\n", -err);
                 goto out_close1;
         }
-        if(setup_initial_poll(sigio_private[1]))
+
+        p = setup_initial_poll(l_sigio_private[1]);
+        if(!p)
                 goto out_close2;
 
-        write_sigio_pid = run_helper_thread(write_sigio_thread, NULL, 
+        sigio_lock();
+
+        /* Did we race? Don't try to optimize this, please, it's not so likely
+         * to happen, and no more than once at the boot. */
+        if(write_sigio_pid != -1)
+                goto out_unlock;
+
+        write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
                                             CLONE_FILES | CLONE_VM, &stack, 0);
 
-        if(write_sigio_pid < 0) goto out_close2;
+        if (write_sigio_pid < 0)
+                goto out_clear;
 
-        if(write_sigio_irq(write_sigio_fds[0])) 
+        if (write_sigio_irq(l_write_sigio_fds[0]))
                 goto out_kill;
 
- out:
+        /* Success, finally. */
+        memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds));
+        memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private));
+
+        current_poll = ((struct pollfds) { .poll        = p,
+                                           .used        = 1,
+                                           .size        = 1 });
+
         sigio_unlock();
         return;
 
  out_kill:
-        os_kill_process(write_sigio_pid, 1);
+        l_write_sigio_pid = write_sigio_pid;
         write_sigio_pid = -1;
+        sigio_unlock();
+        /* Going to call waitpid, avoid holding the lock. */
+        os_kill_process(l_write_sigio_pid, 1);
+        goto out_free;
+
+ out_clear:
+        write_sigio_pid = -1;
+ out_unlock:
+        sigio_unlock();
+ out_free:
+        kfree(p);
  out_close2:
-        os_close_file(sigio_private[0]);
-        os_close_file(sigio_private[1]);
+        os_close_file(l_sigio_private[0]);
+        os_close_file(l_sigio_private[1]);
  out_close1:
-        os_close_file(write_sigio_fds[0]);
-        os_close_file(write_sigio_fds[1]);
-        sigio_unlock();
+        os_close_file(l_write_sigio_fds[0]);
+        os_close_file(l_write_sigio_fds[1]);
+        return;
 }
 
 int read_sigio_fd(int fd)
diff --git a/arch/um/kernel/signal_kern.c b/arch/um/kernel/signal_kern.c
index 7b0e0e81c161..da17b7541e08 100644
--- a/arch/um/kernel/signal_kern.c
+++ b/arch/um/kernel/signal_kern.c
@@ -99,31 +99,46 @@ static int handle_signal(struct pt_regs *regs, unsigned long signr,
         return err;
 }
 
-static int kern_do_signal(struct pt_regs *regs, sigset_t *oldset)
+static int kern_do_signal(struct pt_regs *regs)
 {
         struct k_sigaction ka_copy;
         siginfo_t info;
+        sigset_t *oldset;
         int sig, handled_sig = 0;
 
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
+                oldset = &current->blocked;
+
         while((sig = get_signal_to_deliver(&info, &ka_copy, regs, NULL)) > 0){
                 handled_sig = 1;
                 /* Whee!  Actually deliver the signal.  */
-                if(!handle_signal(regs, sig, &ka_copy, &info, oldset))
+                if(!handle_signal(regs, sig, &ka_copy, &info, oldset)){
+                        /* a signal was successfully delivered; the saved
+                         * sigmask will have been stored in the signal frame,
+                         * and will be restored by sigreturn, so we can simply
+                         * clear the TIF_RESTORE_SIGMASK flag */
+                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                                clear_thread_flag(TIF_RESTORE_SIGMASK);
                         break;
+                }
         }
 
         /* Did we come from a system call? */
         if(!handled_sig && (PT_REGS_SYSCALL_NR(regs) >= 0)){
                 /* Restart the system call - no handlers present */
-                if(PT_REGS_SYSCALL_RET(regs) == -ERESTARTNOHAND ||
-                   PT_REGS_SYSCALL_RET(regs) == -ERESTARTSYS ||
-                   PT_REGS_SYSCALL_RET(regs) == -ERESTARTNOINTR){
+                switch(PT_REGS_SYSCALL_RET(regs)){
+                case -ERESTARTNOHAND:
+                case -ERESTARTSYS:
+                case -ERESTARTNOINTR:
                         PT_REGS_ORIG_SYSCALL(regs) = PT_REGS_SYSCALL_NR(regs);
                         PT_REGS_RESTART_SYSCALL(regs);
-                }
-                else if(PT_REGS_SYSCALL_RET(regs) == -ERESTART_RESTARTBLOCK){
+                        break;
+                case -ERESTART_RESTARTBLOCK:
                         PT_REGS_SYSCALL_RET(regs) = __NR_restart_syscall;
                         PT_REGS_RESTART_SYSCALL(regs);
+                        break;
                 }
         }
 
@@ -137,12 +152,19 @@ static int kern_do_signal(struct pt_regs *regs, sigset_t *oldset)
         if(current->ptrace & PT_DTRACE)
                 current->thread.singlestep_syscall =
                         is_syscall(PT_REGS_IP(&current->thread.regs));
+
+        /* if there's no signal to deliver, we just put the saved sigmask
+         * back */
+        if (!handled_sig && test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
         return(handled_sig);
 }
 
 int do_signal(void)
 {
-        return(kern_do_signal(&current->thread.regs, &current->blocked));
+        return(kern_do_signal(&current->thread.regs));
 }
 
 /*
@@ -150,63 +172,20 @@ int do_signal(void)
  */
 long sys_sigsuspend(int history0, int history1, old_sigset_t mask)
 {
-        sigset_t saveset;
-
         mask &= _BLOCKABLE;
         spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
+        current->saved_sigmask = current->blocked;
         siginitset(&current->blocked, mask);
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        PT_REGS_SYSCALL_RET(&current->thread.regs) = -EINTR;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if(kern_do_signal(&current->thread.regs, &saveset))
-                        return(-EINTR);
-        }
-}
-
-long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
-{
-        sigset_t saveset, newset;
-
-        /* XXX: Don't preclude handling different sized sigset_t's.  */
-        if (sigsetsize != sizeof(sigset_t))
-                return -EINVAL;
-
-        if (copy_from_user(&newset, unewset, sizeof(newset)))
-                return -EFAULT;
-        sigdelsetmask(&newset, ~_BLOCKABLE);
-
-        spin_lock_irq(&current->sighand->siglock);
-        saveset = current->blocked;
-        current->blocked = newset;
-        recalc_sigpending();
-        spin_unlock_irq(&current->sighand->siglock);
-
-        PT_REGS_SYSCALL_RET(&current->thread.regs) = -EINTR;
-        while (1) {
-                current->state = TASK_INTERRUPTIBLE;
-                schedule();
-                if (kern_do_signal(&current->thread.regs, &saveset))
-                        return(-EINTR);
-        }
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        return -ERESTARTNOHAND;
 }
 
 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
 {
         return(do_sigaltstack(uss, uoss, PT_REGS_SP(&current->thread.regs)));
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/skas/Makefile b/arch/um/kernel/skas/Makefile
index 7a9fc16d71d4..57181a920d48 100644
--- a/arch/um/kernel/skas/Makefile
+++ b/arch/um/kernel/skas/Makefile
@@ -1,12 +1,12 @@
-# 
+#
 # Copyright (C) 2002 - 2004 Jeff Dike (jdike@addtoit.com)
 # Licensed under the GPL
 #
 
-obj-y := clone.o exec_kern.o mem.o mem_user.o mmu.o process.o process_kern.o \
+obj-y := clone.o exec_kern.o mem.o mmu.o process_kern.o \
         syscall.o tlb.o uaccess.o
 
-USER_OBJS := process.o clone.o
+USER_OBJS := clone.o
 
 include arch/um/scripts/Makefile.rules
 
diff --git a/arch/um/kernel/skas/include/mmu-skas.h b/arch/um/kernel/skas/include/mmu-skas.h
deleted file mode 100644
index 44110c521e49..000000000000
--- a/arch/um/kernel/skas/include/mmu-skas.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __SKAS_MMU_H
-#define __SKAS_MMU_H
-
-#include "linux/config.h"
-#include "mm_id.h"
-#include "asm/ldt.h"
-
-struct mmu_context_skas {
-        struct mm_id id;
-        unsigned long last_page_table;
-#ifdef CONFIG_3_LEVEL_PGTABLES
-        unsigned long last_pmd;
-#endif
-        uml_ldt_t ldt;
-};
-
-extern void switch_mm_skas(struct mm_id * mm_idp);
-
-#endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/skas/include/mode-skas.h b/arch/um/kernel/skas/include/mode-skas.h
deleted file mode 100644
index bcd26a6a3888..000000000000
--- a/arch/um/kernel/skas/include/mode-skas.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __MODE_SKAS_H__
-#define __MODE_SKAS_H__
-
-#include <sysdep/ptrace.h>
-
-extern unsigned long exec_regs[];
-extern unsigned long exec_fp_regs[];
-extern unsigned long exec_fpx_regs[];
-extern int have_fpx_regs;
-
-extern void sig_handler_common_skas(int sig, void *sc_ptr);
-extern void halt_skas(void);
-extern void reboot_skas(void);
-extern void kill_off_processes_skas(void);
-extern int is_skas_winch(int pid, int fd, void *data);
-
-#endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/skas/include/skas.h b/arch/um/kernel/skas/include/skas.h
deleted file mode 100644
index 01d489de3986..000000000000
--- a/arch/um/kernel/skas/include/skas.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* 
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __SKAS_H
-#define __SKAS_H
-
-#include "mm_id.h"
-#include "sysdep/ptrace.h"
-
-extern int userspace_pid[];
-extern int proc_mm, ptrace_faultinfo, ptrace_ldt;
-extern int skas_needs_stub;
-
-extern void switch_threads(void *me, void *next);
-extern void thread_wait(void *sw, void *fb);
-extern void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
-                       void (*handler)(int));
-extern int start_idle_thread(void *stack, void *switch_buf_ptr, 
-                             void **fork_buf_ptr);
-extern int user_thread(unsigned long stack, int flags);
-extern void userspace(union uml_pt_regs *regs);
-extern void new_thread_proc(void *stack, void (*handler)(int sig));
-extern void new_thread_handler(int sig);
-extern void handle_syscall(union uml_pt_regs *regs);
-extern int map(struct mm_id * mm_idp, unsigned long virt,
-               unsigned long len, int r, int w, int x, int phys_fd,
-               unsigned long long offset, int done, void **data);
-extern int unmap(struct mm_id * mm_idp, void *addr, unsigned long len,
-                 int done, void **data);
-extern int protect(struct mm_id * mm_idp, unsigned long addr,
-                   unsigned long len, int r, int w, int x, int done,
-                   void **data);
-extern void user_signal(int sig, union uml_pt_regs *regs, int pid);
-extern int new_mm(int from, unsigned long stack);
-extern int start_userspace(unsigned long stub_stack);
-extern int copy_context_skas0(unsigned long stack, int pid);
-extern void get_skas_faultinfo(int pid, struct faultinfo * fi);
-extern long execute_syscall_skas(void *r);
-extern unsigned long current_stub_stack(void);
-extern long run_syscall_stub(struct mm_id * mm_idp,
-                             int syscall, unsigned long *args, long expected,
-                             void **addr, int done);
-extern long syscall_stub_data(struct mm_id * mm_idp,
-                              unsigned long *data, int data_count,
-                              void **addr, void **stub_addr);
-
-#endif
diff --git a/arch/um/kernel/skas/mmu.c b/arch/um/kernel/skas/mmu.c
index 677871f1b37c..c5c9885a8297 100644
--- a/arch/um/kernel/skas/mmu.c
+++ b/arch/um/kernel/skas/mmu.c
@@ -78,7 +78,7 @@ int init_new_context_skas(struct task_struct *task, struct mm_struct *mm)
         struct mmu_context_skas *from_mm = NULL;
         struct mmu_context_skas *to_mm = &mm->context.skas;
         unsigned long stack = 0;
-        int from_fd, ret = -ENOMEM;
+        int ret = -ENOMEM;
 
         if(skas_needs_stub){
                 stack = get_zeroed_page(GFP_KERNEL);
@@ -108,11 +108,7 @@ int init_new_context_skas(struct task_struct *task, struct mm_struct *mm)
                 from_mm = &current->mm->context.skas;
 
         if(proc_mm){
-                if(from_mm)
-                        from_fd = from_mm->id.u.mm_fd;
-                else from_fd = -1;
-
-                ret = new_mm(from_fd, stack);
+                ret = new_mm(stack);
                 if(ret < 0){
                         printk("init_new_context_skas - new_mm failed, "
                                "errno = %d\n", ret);
diff --git a/arch/um/kernel/skas/process_kern.c b/arch/um/kernel/skas/process_kern.c
index dc41c6dc2f34..3f70a2e12f06 100644
--- a/arch/um/kernel/skas/process_kern.c
+++ b/arch/um/kernel/skas/process_kern.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -13,14 +13,12 @@
 #include "asm/uaccess.h"
 #include "asm/atomic.h"
 #include "kern_util.h"
-#include "time_user.h"
 #include "skas.h"
 #include "os.h"
 #include "user_util.h"
 #include "tlb.h"
 #include "kern.h"
 #include "mode.h"
-#include "proc_mm.h"
 #include "registers.h"
 
 void switch_to_skas(void *prev, void *next)
@@ -34,7 +32,7 @@ void switch_to_skas(void *prev, void *next)
         if(current->pid == 0)
                 switch_timers(0);
 
-        switch_threads(&from->thread.mode.skas.switch_buf, 
+        switch_threads(&from->thread.mode.skas.switch_buf,
                        to->thread.mode.skas.switch_buf);
 
         if(current->pid == 0)
@@ -50,8 +48,8 @@ void new_thread_handler(int sig)
 
         fn = current->thread.request.u.thread.proc;
         arg = current->thread.request.u.thread.arg;
-        change_sig(SIGUSR1, 1);
-        thread_wait(&current->thread.mode.skas.switch_buf, 
+        os_usr1_signal(1);
+        thread_wait(&current->thread.mode.skas.switch_buf,
                     current->thread.mode.skas.fork_buf);
 
         if(current->thread.prev_sched != NULL)
@@ -82,8 +80,8 @@ void release_thread_skas(struct task_struct *task)
 
 void fork_handler(int sig)
 {
-        change_sig(SIGUSR1, 1);
-        thread_wait(&current->thread.mode.skas.switch_buf, 
+        os_usr1_signal(1);
+        thread_wait(&current->thread.mode.skas.switch_buf,
                     current->thread.mode.skas.fork_buf);
         
         force_flush_all();
@@ -93,13 +91,13 @@ void fork_handler(int sig)
         schedule_tail(current->thread.prev_sched);
         current->thread.prev_sched = NULL;
 
-        /* Handle any immediate reschedules or signals */
+/* Handle any immediate reschedules or signals */
         interrupt_end();
         userspace(&current->thread.regs.regs);
 }
 
 int copy_thread_skas(int nr, unsigned long clone_flags, unsigned long sp,
-                     unsigned long stack_top, struct task_struct * p, 
+                     unsigned long stack_top, struct task_struct * p,
                      struct pt_regs *regs)
 {
         void (*handler)(int);
@@ -123,27 +121,14 @@ int copy_thread_skas(int nr, unsigned long clone_flags, unsigned long sp,
         return(0);
 }
 
-extern void map_stub_pages(int fd, unsigned long code,
-                           unsigned long data, unsigned long stack);
-int new_mm(int from, unsigned long stack)
+int new_mm(unsigned long stack)
 {
-        struct proc_mm_op copy;
-        int n, fd;
+        int fd;
 
         fd = os_open_file("/proc/mm", of_cloexec(of_write(OPENFLAGS())), 0);
         if(fd < 0)
                 return(fd);
 
-        if(from != -1){
-                copy = ((struct proc_mm_op) { .op       = MM_COPY_SEGMENTS,
-                                              .u        =
-                                              { .copy_segments  = from } } );
-                n = os_write_file(fd, &copy, sizeof(copy));
-                if(n != sizeof(copy))
-                        printk("new_mm : /proc/mm copy_segments failed, "
-                               "err = %d\n", -n);
-        }
-
         if(skas_needs_stub)
                 map_stub_pages(fd, CONFIG_STUB_CODE, CONFIG_STUB_DATA, stack);
 
diff --git a/arch/um/kernel/skas/uaccess.c b/arch/um/kernel/skas/uaccess.c
index a5a47528dec7..5992c3257167 100644
--- a/arch/um/kernel/skas/uaccess.c
+++ b/arch/um/kernel/skas/uaccess.c
@@ -13,7 +13,7 @@
 #include "asm/pgtable.h"
 #include "asm/uaccess.h"
 #include "kern_util.h"
-#include "user_util.h"
+#include "os.h"
 
 extern void *um_virt_to_phys(struct task_struct *task, unsigned long addr,
                              pte_t *pte_out);
diff --git a/arch/um/kernel/syscall.c b/arch/um/kernel/syscall.c
index 1429c131879d..1731d90e6850 100644
--- a/arch/um/kernel/syscall.c
+++ b/arch/um/kernel/syscall.c
@@ -25,12 +25,12 @@ int record_syscall_start(int syscall)
         syscall_record[index].syscall = syscall;
         syscall_record[index].pid = current_pid();
         syscall_record[index].result = 0xdeadbeef;
-        syscall_record[index].start = os_usecs();
+        syscall_record[index].start = os_nsecs();
         return(index);
 }
 
 void record_syscall_end(int index, long result)
 {
         syscall_record[index].result = result;
-        syscall_record[index].end = os_usecs();
+        syscall_record[index].end = os_nsecs();
 }
diff --git a/arch/um/kernel/time_kern.c b/arch/um/kernel/time_kern.c
index 020ca79b8d33..3c7626cdba4b 100644
--- a/arch/um/kernel/time_kern.c
+++ b/arch/um/kernel/time_kern.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -13,12 +13,12 @@
 #include "linux/interrupt.h"
 #include "linux/init.h"
 #include "linux/delay.h"
+#include "linux/hrtimer.h"
 #include "asm/irq.h"
 #include "asm/param.h"
 #include "asm/current.h"
 #include "kern_util.h"
 #include "user_util.h"
-#include "time_user.h"
 #include "mode.h"
 #include "os.h"
 
@@ -39,7 +39,7 @@ unsigned long long sched_clock(void)
 int timer_irq_inited = 0;
 
 static int first_tick;
-static unsigned long long prev_usecs;
+static unsigned long long prev_nsecs;
 #ifdef CONFIG_UML_REAL_TIME_CLOCK
 static long long delta;                 /* Deviation per interval */
 #endif
@@ -58,23 +58,23 @@ void timer_irq(union uml_pt_regs *regs)
         if(first_tick){
 #ifdef CONFIG_UML_REAL_TIME_CLOCK
                 /* We've had 1 tick */
-                unsigned long long usecs = os_usecs();
+                unsigned long long nsecs = os_nsecs();
 
-                delta += usecs - prev_usecs;
-                prev_usecs = usecs;
+                delta += nsecs - prev_nsecs;
+                prev_nsecs = nsecs;
 
                 /* Protect against the host clock being set backwards */
                 if(delta < 0)
                         delta = 0;
 
-                ticks += (delta * HZ) / MILLION;
-                delta -= (ticks * MILLION) / HZ;
+                ticks += (delta * HZ) / BILLION;
+                delta -= (ticks * BILLION) / HZ;
 #else
                 ticks = 1;
 #endif
         }
         else {
-                prev_usecs = os_usecs();
+                prev_nsecs = os_nsecs();
                 first_tick = 1;
         }
 
@@ -84,49 +84,102 @@ void timer_irq(union uml_pt_regs *regs)
         }
 }
 
-void boot_timer_handler(int sig)
+void do_boot_timer_handler(struct sigcontext * sc)
 {
         struct pt_regs regs;
 
-        CHOOSE_MODE((void) 
-                    (UPT_SC(&regs.regs) = (struct sigcontext *) (&sig + 1)),
+        CHOOSE_MODE((void) (UPT_SC(&regs.regs) = sc),
                     (void) (regs.regs.skas.is_user = 0));
         do_timer(&regs);
 }
 
+static DEFINE_SPINLOCK(timer_spinlock);
+
+static unsigned long long local_offset = 0;
+
+static inline unsigned long long get_time(void)
+{
+        unsigned long long nsecs;
+        unsigned long flags;
+
+        spin_lock_irqsave(&timer_spinlock, flags);
+        nsecs = os_nsecs();
+        nsecs += local_offset;
+        spin_unlock_irqrestore(&timer_spinlock, flags);
+
+        return nsecs;
+}
+
 irqreturn_t um_timer(int irq, void *dev, struct pt_regs *regs)
 {
+        unsigned long long nsecs;
         unsigned long flags;
 
         do_timer(regs);
+
         write_seqlock_irqsave(&xtime_lock, flags);
-        timer();
+        nsecs = get_time() + local_offset;
+        xtime.tv_sec = nsecs / NSEC_PER_SEC;
+        xtime.tv_nsec = nsecs - xtime.tv_sec * NSEC_PER_SEC;
         write_sequnlock_irqrestore(&xtime_lock, flags);
+
         return(IRQ_HANDLED);
 }
 
 long um_time(int __user *tloc)
 {
-        struct timeval now;
+        long ret = get_time() / NSEC_PER_SEC;
 
-        do_gettimeofday(&now);
-        if (tloc) {
-                if (put_user(now.tv_sec, tloc))
-                        now.tv_sec = -EFAULT;
-        }
-        return now.tv_sec;
+        if((tloc != NULL) && put_user(ret, tloc))
+                return -EFAULT;
+
+        return ret;
+}
+
+void do_gettimeofday(struct timeval *tv)
+{
+        unsigned long long nsecs = get_time();
+
+        tv->tv_sec = nsecs / NSEC_PER_SEC;
+        /* Careful about calculations here - this was originally done as
+         * (nsecs - tv->tv_sec * NSEC_PER_SEC) / NSEC_PER_USEC
+         * which gave bogus (> 1000000) values.  Dunno why, suspect gcc
+         * (4.0.0) miscompiled it, or there's a subtle 64/32-bit conversion
+         * problem that I missed.
+         */
+        nsecs -= tv->tv_sec * NSEC_PER_SEC;
+        tv->tv_usec = (unsigned long) nsecs / NSEC_PER_USEC;
+}
+
+static inline void set_time(unsigned long long nsecs)
+{
+        unsigned long long now;
+        unsigned long flags;
+
+        spin_lock_irqsave(&timer_spinlock, flags);
+        now = os_nsecs();
+        local_offset = nsecs - now;
+        spin_unlock_irqrestore(&timer_spinlock, flags);
+
+        clock_was_set();
 }
 
 long um_stime(int __user *tptr)
 {
         int value;
-        struct timespec new;
 
         if (get_user(value, tptr))
                 return -EFAULT;
-        new.tv_sec = value;
-        new.tv_nsec = 0;
-        do_settimeofday(&new);
+
+        set_time((unsigned long long) value * NSEC_PER_SEC);
+
+        return 0;
+}
+
+int do_settimeofday(struct timespec *tv)
+{
+        set_time((unsigned long long) tv->tv_sec * NSEC_PER_SEC + tv->tv_nsec);
+
         return 0;
 }
 
@@ -134,29 +187,15 @@ void timer_handler(int sig, union uml_pt_regs *regs)
 {
         local_irq_disable();
         irq_enter();
-        update_process_times(CHOOSE_MODE(user_context(UPT_SP(regs)),
-                                         (regs)->skas.is_user));
+        update_process_times(CHOOSE_MODE(
+                             (UPT_SC(regs) && user_context(UPT_SP(regs))),
+                             (regs)->skas.is_user));
         irq_exit();
         local_irq_enable();
         if(current_thread->cpu == 0)
                 timer_irq(regs);
 }
 
-static DEFINE_SPINLOCK(timer_spinlock);
-
-unsigned long time_lock(void)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&timer_spinlock, flags);
-        return(flags);
-}
-
-void time_unlock(unsigned long flags)
-{
-        spin_unlock_irqrestore(&timer_spinlock, flags);
-}
-
 int __init timer_init(void)
 {
         int err;
@@ -171,14 +210,3 @@ int __init timer_init(void)
 }
 
 __initcall(timer_init);
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/tt/exec_kern.c b/arch/um/kernel/tt/exec_kern.c
index 8f40e4838736..5c1e4cc1c049 100644
--- a/arch/um/kernel/tt/exec_kern.c
+++ b/arch/um/kernel/tt/exec_kern.c
@@ -13,7 +13,6 @@
 #include "user_util.h"
 #include "kern_util.h"
 #include "irq_user.h"
-#include "time_user.h"
 #include "mem_user.h"
 #include "os.h"
 #include "tlb.h"
diff --git a/arch/um/kernel/tt/gdb.c b/arch/um/kernel/tt/gdb.c
index 37e22d71a0d9..786e4edd86c5 100644
--- a/arch/um/kernel/tt/gdb.c
+++ b/arch/um/kernel/tt/gdb.c
@@ -20,6 +20,7 @@
 #include "user_util.h"
 #include "tt.h"
 #include "sysdep/thread.h"
+#include "os.h"
 
 extern int debugger_pid;
 extern int debugger_fd;
diff --git a/arch/um/kernel/tt/include/mmu-tt.h b/arch/um/kernel/tt/include/mmu-tt.h
deleted file mode 100644
index 0440510ab3fe..000000000000
--- a/arch/um/kernel/tt/include/mmu-tt.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __TT_MMU_H
-#define __TT_MMU_H
-
-struct mmu_context_tt {
-};
-
-#endif
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/kernel/tt/process_kern.c b/arch/um/kernel/tt/process_kern.c
index 62535303aa27..295c1ac817b3 100644
--- a/arch/um/kernel/tt/process_kern.c
+++ b/arch/um/kernel/tt/process_kern.c
@@ -18,7 +18,6 @@
 #include "os.h"
 #include "kern.h"
 #include "sigcontext.h"
-#include "time_user.h"
 #include "mem_user.h"
 #include "tlb.h"
 #include "mode.h"
diff --git a/arch/um/kernel/tt/ptproxy/ptrace.c b/arch/um/kernel/tt/ptproxy/ptrace.c
index 528a5fc8d887..03774427d468 100644
--- a/arch/um/kernel/tt/ptproxy/ptrace.c
+++ b/arch/um/kernel/tt/ptproxy/ptrace.c
@@ -20,6 +20,7 @@ Jeff Dike (jdike@karaya.com) : Modified for integration into uml
 #include "kern_util.h"
 #include "ptrace_user.h"
 #include "tt.h"
+#include "os.h"
 
 long proxy_ptrace(struct debugger *debugger, int arg1, pid_t arg2,
                   long arg3, long arg4, pid_t child, int *ret)
diff --git a/arch/um/kernel/tt/ptproxy/sysdep.c b/arch/um/kernel/tt/ptproxy/sysdep.c
index a5f0e01e214e..99f178319d03 100644
--- a/arch/um/kernel/tt/ptproxy/sysdep.c
+++ b/arch/um/kernel/tt/ptproxy/sysdep.c
@@ -15,6 +15,7 @@ terms and conditions.
 #include "ptrace_user.h"
 #include "user_util.h"
 #include "user.h"
+#include "os.h"
 
 int get_syscall(pid_t pid, long *arg1, long *arg2, long *arg3, long *arg4, 
                 long *arg5)
diff --git a/arch/um/kernel/tt/syscall_kern.c b/arch/um/kernel/tt/syscall_kern.c
index 3d29c90514cc..3fda9a03c59a 100644
--- a/arch/um/kernel/tt/syscall_kern.c
+++ b/arch/um/kernel/tt/syscall_kern.c
@@ -23,16 +23,20 @@ void syscall_handler_tt(int sig, struct pt_regs *regs)
         int syscall;
 #ifdef CONFIG_SYSCALL_DEBUG
         int index;
-        index = record_syscall_start(syscall);
 #endif
         sc = UPT_SC(&regs->regs);
         SC_START_SYSCALL(sc);
 
+        syscall = UPT_SYSCALL_NR(&regs->regs);
+
+#ifdef CONFIG_SYSCALL_DEBUG
+        index = record_syscall_start(syscall);
+#endif
+
         syscall_trace(&regs->regs, 0);
 
         current->thread.nsyscalls++;
         nsyscalls++;
-        syscall = UPT_SYSCALL_NR(&regs->regs);
 
         if((syscall >= NR_syscalls) || (syscall < 0))
                 result = -ENOSYS;
diff --git a/arch/um/kernel/tt/trap_user.c b/arch/um/kernel/tt/trap_user.c
index a414c529fbcd..b5d9d64d91e4 100644
--- a/arch/um/kernel/tt/trap_user.c
+++ b/arch/um/kernel/tt/trap_user.c
@@ -18,7 +18,7 @@ void sig_handler_common_tt(int sig, void *sc_ptr)
 {
         struct sigcontext *sc = sc_ptr;
         struct tt_regs save_regs, *r;
-        int save_errno = errno, is_user;
+        int save_errno = errno, is_user = 0;
         void (*handler)(int, union uml_pt_regs *);
 
         /* This is done because to allow SIGSEGV to be delivered inside a SEGV
@@ -35,7 +35,8 @@ void sig_handler_common_tt(int sig, void *sc_ptr)
                 GET_FAULTINFO_FROM_SC(r->faultinfo, sc);
         }
         save_regs = *r;
-        is_user = user_context(SC_SP(sc));
+        if (sc)
+                is_user = user_context(SC_SP(sc));
         r->sc = sc;
         if(sig != SIGUSR2) 
                 r->syscall = -1;
diff --git a/arch/um/kernel/um_arch.c b/arch/um/kernel/um_arch.c
index e2d3ca445ef5..27cdf9164422 100644
--- a/arch/um/kernel/um_arch.c
+++ b/arch/um/kernel/um_arch.c
@@ -193,6 +193,24 @@ __uml_setup("root=", uml_root_setup,
 "        root=/dev/ubd5\n\n"
 );
 
+#ifndef CONFIG_MODE_TT
+
+static int __init no_skas_debug_setup(char *line, int *add)
+{
+        printf("'debug' is not necessary to gdb UML in skas mode - run \n");
+        printf("'gdb linux' and disable CONFIG_CMDLINE_ON_HOST if gdb \n");
+        printf("doesn't work as expected\n");
+
+        return 0;
+}
+
+__uml_setup("debug", no_skas_debug_setup,
+"debug\n"
+"    this flag is not needed to run gdb on UML in skas mode\n\n"
+);
+
+#endif
+
 #ifdef CONFIG_SMP
 static int __init uml_ncpus_setup(char *line, int *add)
 {
diff --git a/arch/um/os-Linux/Makefile b/arch/um/os-Linux/Makefile
index 40c7d6b1df68..08a4e628b24c 100644
--- a/arch/um/os-Linux/Makefile
+++ b/arch/um/os-Linux/Makefile
@@ -5,12 +5,12 @@
 
 obj-y = aio.o elf_aux.o file.o helper.o main.o mem.o process.o signal.o \
         start_up.o time.o trap.o tt.o tty.o uaccess.o umid.o user_syms.o \
-        drivers/ sys-$(SUBARCH)/
+        util.o drivers/ sys-$(SUBARCH)/
 
 obj-$(CONFIG_MODE_SKAS) += skas/
 
 USER_OBJS := aio.o elf_aux.o file.o helper.o main.o mem.o process.o signal.o \
-        start_up.o time.o trap.o tt.o tty.o uaccess.o umid.o
+        start_up.o time.o trap.o tt.o tty.o uaccess.o umid.o util.o
 
 elf_aux.o: $(ARCH_DIR)/kernel-offsets.h
 CFLAGS_elf_aux.o += -I$(objtree)/arch/um
diff --git a/arch/um/os-Linux/drivers/tuntap_user.c b/arch/um/os-Linux/drivers/tuntap_user.c
index 52945338b64d..87c3aa0252db 100644
--- a/arch/um/os-Linux/drivers/tuntap_user.c
+++ b/arch/um/os-Linux/drivers/tuntap_user.c
@@ -122,6 +122,7 @@ static int tuntap_open_tramp(char *gate, int *fd_out, int me, int remote,
                 return(-EINVAL);
         }
         *fd_out = ((int *) CMSG_DATA(cmsg))[0];
+        os_set_exec_close(*fd_out, 1);
         return(0);
 }
 
@@ -137,7 +138,8 @@ static int tuntap_open(void *data)
                 return(err);
 
         if(pri->fixed_config){
-                pri->fd = os_open_file("/dev/net/tun", of_rdwr(OPENFLAGS()), 0);
+                pri->fd = os_open_file("/dev/net/tun",
+                                       of_cloexec(of_rdwr(OPENFLAGS())), 0);
                 if(pri->fd < 0){
                         printk("Failed to open /dev/net/tun, err = %d\n",
                                -pri->fd);
diff --git a/arch/um/os-Linux/helper.c b/arch/um/os-Linux/helper.c
index 36cc8475bcda..6490a4ff40ac 100644
--- a/arch/um/os-Linux/helper.c
+++ b/arch/um/os-Linux/helper.c
@@ -60,7 +60,7 @@ int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv,
 
         if((stack_out != NULL) && (*stack_out != 0))
                 stack = *stack_out;
-        else stack = alloc_stack(0, um_in_interrupt());
+        else stack = alloc_stack(0, __cant_sleep());
         if(stack == 0)
                 return(-ENOMEM);
 
@@ -124,7 +124,7 @@ int run_helper_thread(int (*proc)(void *), void *arg, unsigned int flags,
         unsigned long stack, sp;
         int pid, status, err;
 
-        stack = alloc_stack(stack_order, um_in_interrupt());
+        stack = alloc_stack(stack_order, __cant_sleep());
         if(stack == 0) return(-ENOMEM);
 
         sp = stack + (page_size() << stack_order) - sizeof(void *);
diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c
index 172c8474453c..2878e89a674f 100644
--- a/arch/um/os-Linux/main.c
+++ b/arch/um/os-Linux/main.c
@@ -16,7 +16,6 @@
 #include "user_util.h"
 #include "kern_util.h"
 #include "mem_user.h"
-#include "time_user.h"
 #include "irq_user.h"
 #include "user.h"
 #include "init.h"
@@ -82,20 +81,8 @@ extern void scan_elf_aux( char **envp);
 int main(int argc, char **argv, char **envp)
 {
         char **new_argv;
-        sigset_t mask;
         int ret, i, err;
 
-        /* Enable all signals except SIGIO - in some environments, we can
-         * enter with some signals blocked
-         */
-
-        sigemptyset(&mask);
-        sigaddset(&mask, SIGIO);
-        if(sigprocmask(SIG_SETMASK, &mask, NULL) < 0){
-                perror("sigprocmask");
-                exit(1);
-        }
-
 #ifdef UML_CONFIG_CMDLINE_ON_HOST
         /* Allocate memory for thread command lines */
         if(argc < 2 || strlen(argv[1]) < THREAD_NAME_LEN - 1){
diff --git a/arch/um/os-Linux/process.c b/arch/um/os-Linux/process.c
index 39815c6b5e45..7f5e2dac2a35 100644
--- a/arch/um/os-Linux/process.c
+++ b/arch/um/os-Linux/process.c
@@ -18,6 +18,7 @@
 #include "process.h"
 #include "irq_user.h"
 #include "kern_util.h"
+#include "longjmp.h"
 
 #define ARBITRARY_ADDR -1
 #define FAILURE_PID    -1
@@ -205,24 +206,13 @@ void init_new_thread_signals(int altstack)
 
 int run_kernel_thread(int (*fn)(void *), void *arg, void **jmp_ptr)
 {
-       sigjmp_buf buf;
-       int n;
-
-       *jmp_ptr = &buf;
-       n = sigsetjmp(buf, 1);
-       if(n != 0)
-               return(n);
-       (*fn)(arg);
-       return(0);
+        sigjmp_buf buf;
+        int n, enable;
+
+        *jmp_ptr = &buf;
+        n = UML_SIGSETJMP(&buf, enable);
+        if(n != 0)
+                return(n);
+        (*fn)(arg);
+        return(0);
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c
index c1f46a0fef13..f11b3124a0c8 100644
--- a/arch/um/os-Linux/signal.c
+++ b/arch/um/os-Linux/signal.c
@@ -12,32 +12,66 @@
 #include <string.h>
 #include <sys/mman.h>
 #include "user_util.h"
-#include "kern_util.h"
 #include "user.h"
 #include "signal_kern.h"
 #include "sysdep/sigcontext.h"
 #include "sysdep/signal.h"
 #include "sigcontext.h"
-#include "time_user.h"
 #include "mode.h"
+#include "os.h"
+
+/* These are the asynchronous signals.  SIGVTALRM and SIGARLM are handled
+ * together under SIGVTALRM_BIT.  SIGPROF is excluded because we want to
+ * be able to profile all of UML, not just the non-critical sections.  If
+ * profiling is not thread-safe, then that is not my problem.  We can disable
+ * profiling when SMP is enabled in that case.
+ */
+#define SIGIO_BIT 0
+#define SIGIO_MASK (1 << SIGIO_BIT)
+
+#define SIGVTALRM_BIT 1
+#define SIGVTALRM_MASK (1 << SIGVTALRM_BIT)
+
+#define SIGALRM_BIT 2
+#define SIGALRM_MASK (1 << SIGALRM_BIT)
+
+static int signals_enabled = 1;
+static int pending = 0;
 
 void sig_handler(ARCH_SIGHDLR_PARAM)
 {
         struct sigcontext *sc;
+        int enabled;
+
+        /* Must be the first thing that this handler does - x86_64 stores
+         * the sigcontext in %rdx, and we need to save it before it has a
+         * chance to get trashed.
+         */
 
         ARCH_GET_SIGCONTEXT(sc, sig);
+
+        enabled = signals_enabled;
+        if(!enabled && (sig == SIGIO)){
+                pending |= SIGIO_MASK;
+                return;
+        }
+
+        block_signals();
+
         CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas,
                          sig, sc);
+
+        set_signals(enabled);
 }
 
 extern int timer_irq_inited;
 
-void alarm_handler(ARCH_SIGHDLR_PARAM)
+static void real_alarm_handler(int sig, struct sigcontext *sc)
 {
-        struct sigcontext *sc;
-
-        ARCH_GET_SIGCONTEXT(sc, sig);
-        if(!timer_irq_inited) return;
+        if(!timer_irq_inited){
+                signals_enabled = 1;
+                return;
+        }
 
         if(sig == SIGALRM)
                 switch_timers(0);
@@ -47,6 +81,52 @@ void alarm_handler(ARCH_SIGHDLR_PARAM)
 
         if(sig == SIGALRM)
                 switch_timers(1);
+
+}
+
+void alarm_handler(ARCH_SIGHDLR_PARAM)
+{
+        struct sigcontext *sc;
+        int enabled;
+
+        ARCH_GET_SIGCONTEXT(sc, sig);
+
+        enabled = signals_enabled;
+        if(!signals_enabled){
+                if(sig == SIGVTALRM)
+                        pending |= SIGVTALRM_MASK;
+                else pending |= SIGALRM_MASK;
+
+                return;
+        }
+
+        block_signals();
+
+        real_alarm_handler(sig, sc);
+        set_signals(enabled);
+}
+
+extern void do_boot_timer_handler(struct sigcontext * sc);
+
+void boot_timer_handler(ARCH_SIGHDLR_PARAM)
+{
+        struct sigcontext *sc;
+        int enabled;
+
+        ARCH_GET_SIGCONTEXT(sc, sig);
+
+        enabled = signals_enabled;
+        if(!enabled){
+                if(sig == SIGVTALRM)
+                        pending |= SIGVTALRM_MASK;
+                else pending |= SIGALRM_MASK;
+                return;
+        }
+
+        block_signals();
+
+        do_boot_timer_handler(sc);
+        set_signals(enabled);
 }
 
 void set_sigstack(void *sig_stack, int size)
@@ -73,6 +153,7 @@ void set_handler(int sig, void (*handler)(int), int flags, ...)
 {
         struct sigaction action;
         va_list ap;
+        sigset_t sig_mask;
         int mask;
 
         va_start(ap, flags);
@@ -85,7 +166,12 @@ void set_handler(int sig, void (*handler)(int), int flags, ...)
         action.sa_flags = flags;
         action.sa_restorer = NULL;
         if(sigaction(sig, &action, NULL) < 0)
-                panic("sigaction failed");
+                panic("sigaction failed - errno = %d\n", errno);
+
+        sigemptyset(&sig_mask);
+        sigaddset(&sig_mask, sig);
+        if(sigprocmask(SIG_UNBLOCK, &sig_mask, NULL) < 0)
+                panic("sigprocmask failed - errno = %d\n", errno);
 }
 
 int change_sig(int signal, int on)
@@ -98,89 +184,77 @@ int change_sig(int signal, int on)
         return(!sigismember(&old, signal));
 }
 
-/* Both here and in set/get_signal we don't touch SIGPROF, because we must not
- * disable profiling; it's safe because the profiling code does not interact
- * with the kernel code at all.*/
-
-static void change_signals(int type)
-{
-        sigset_t mask;
-
-        sigemptyset(&mask);
-        sigaddset(&mask, SIGVTALRM);
-        sigaddset(&mask, SIGALRM);
-        sigaddset(&mask, SIGIO);
-        if(sigprocmask(type, &mask, NULL) < 0)
-                panic("Failed to change signal mask - errno = %d", errno);
-}
-
 void block_signals(void)
 {
-        change_signals(SIG_BLOCK);
+        signals_enabled = 0;
 }
 
 void unblock_signals(void)
 {
-        change_signals(SIG_UNBLOCK);
-}
+        int save_pending;
 
-/* These are the asynchronous signals.  SIGVTALRM and SIGARLM are handled
- * together under SIGVTALRM_BIT.  SIGPROF is excluded because we want to
- * be able to profile all of UML, not just the non-critical sections.  If
- * profiling is not thread-safe, then that is not my problem.  We can disable
- * profiling when SMP is enabled in that case.
- */
-#define SIGIO_BIT 0
-#define SIGVTALRM_BIT 1
+        if(signals_enabled == 1)
+                return;
 
-static int enable_mask(sigset_t *mask)
-{
-        int sigs;
+        /* We loop because the IRQ handler returns with interrupts off.  So,
+         * interrupts may have arrived and we need to re-enable them and
+         * recheck pending.
+         */
+        while(1){
+                /* Save and reset save_pending after enabling signals.  This
+                 * way, pending won't be changed while we're reading it.
+                 */
+                signals_enabled = 1;
+
+                save_pending = pending;
+                if(save_pending == 0)
+                        return;
+
+                pending = 0;
+
+                /* We have pending interrupts, so disable signals, as the
+                 * handlers expect them off when they are called.  They will
+                 * be enabled again above.
+                 */
+
+                signals_enabled = 0;
 
-        sigs = sigismember(mask, SIGIO) ? 0 : 1 << SIGIO_BIT;
-        sigs |= sigismember(mask, SIGVTALRM) ? 0 : 1 << SIGVTALRM_BIT;
-        sigs |= sigismember(mask, SIGALRM) ? 0 : 1 << SIGVTALRM_BIT;
-        return(sigs);
+                /* Deal with SIGIO first because the alarm handler might
+                 * schedule, leaving the pending SIGIO stranded until we come
+                 * back here.
+                 */
+                if(save_pending & SIGIO_MASK)
+                        CHOOSE_MODE_PROC(sig_handler_common_tt,
+                                         sig_handler_common_skas, SIGIO, NULL);
+
+                if(save_pending & SIGALRM_MASK)
+                        real_alarm_handler(SIGALRM, NULL);
+
+                if(save_pending & SIGVTALRM_MASK)
+                        real_alarm_handler(SIGVTALRM, NULL);
+        }
 }
 
 int get_signals(void)
 {
-        sigset_t mask;
-
-        if(sigprocmask(SIG_SETMASK, NULL, &mask) < 0)
-                panic("Failed to get signal mask");
-        return(enable_mask(&mask));
+        return signals_enabled;
 }
 
 int set_signals(int enable)
 {
-        sigset_t mask;
         int ret;
+        if(signals_enabled == enable)
+                return enable;
 
-        sigemptyset(&mask);
-        if(enable & (1 << SIGIO_BIT))
-                sigaddset(&mask, SIGIO);
-        if(enable & (1 << SIGVTALRM_BIT)){
-                sigaddset(&mask, SIGVTALRM);
-                sigaddset(&mask, SIGALRM);
-        }
+        ret = signals_enabled;
+        if(enable)
+                unblock_signals();
+        else block_signals();
 
-        /* This is safe - sigprocmask is guaranteed to copy locally the
-         * value of new_set, do his work and then, at the end, write to
-         * old_set.
-         */
-        if(sigprocmask(SIG_UNBLOCK, &mask, &mask) < 0)
-                panic("Failed to enable signals");
-        ret = enable_mask(&mask);
-        sigemptyset(&mask);
-        if((enable & (1 << SIGIO_BIT)) == 0)
-                sigaddset(&mask, SIGIO);
-        if((enable & (1 << SIGVTALRM_BIT)) == 0){
-                sigaddset(&mask, SIGVTALRM);
-                sigaddset(&mask, SIGALRM);
-        }
-        if(sigprocmask(SIG_BLOCK, &mask, NULL) < 0)
-                panic("Failed to block signals");
+        return ret;
+}
 
-        return(ret);
+void os_usr1_signal(int on)
+{
+        change_sig(SIGUSR1, on);
 }
diff --git a/arch/um/os-Linux/skas/Makefile b/arch/um/os-Linux/skas/Makefile
index eab5386d60a7..5fd8d4dad66a 100644
--- a/arch/um/os-Linux/skas/Makefile
+++ b/arch/um/os-Linux/skas/Makefile
@@ -3,8 +3,8 @@
 # Licensed under the GPL
 #
 
-obj-y := trap.o
+obj-y := mem.o process.o trap.o
 
-USER_OBJS := trap.o
+USER_OBJS := mem.o process.o trap.o
 
 include arch/um/scripts/Makefile.rules
diff --git a/arch/um/kernel/skas/mem_user.c b/arch/um/os-Linux/skas/mem.c
index 1d89640bd502..fbb080c2fc26 100644
--- a/arch/um/kernel/skas/mem_user.c
+++ b/arch/um/os-Linux/skas/mem.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -32,7 +32,7 @@ extern void wait_stub_done(int pid, int sig, char * fname);
 static inline unsigned long *check_init_stack(struct mm_id * mm_idp,
                                               unsigned long *stack)
 {
-        if(stack == NULL){
+        if(stack == NULL) {
                 stack = (unsigned long *) mm_idp->stack + 2;
                 *stack = 0;
         }
@@ -45,13 +45,14 @@ int single_count = 0;
 int multi_count = 0;
 int multi_op_count = 0;
 
-static long do_syscall_stub(struct mm_id *mm_idp, void **addr)
+static inline long do_syscall_stub(struct mm_id * mm_idp, void **addr)
 {
         unsigned long regs[MAX_REG_NR];
-        unsigned long *data;
-        unsigned long *syscall;
+        int n;
         long ret, offset;
-        int n, pid = mm_idp->u.pid;
+        unsigned long * data;
+        unsigned long * syscall;
+        int pid = mm_idp->u.pid;
 
         if(proc_mm)
 #warning Need to look up userspace_pid by cpu
@@ -59,10 +60,11 @@ static long do_syscall_stub(struct mm_id *mm_idp, void **addr)
 
         multi_count++;
 
-        get_safe_registers(regs);
-        regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
+        get_safe_registers(regs, NULL);
+        regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
                 ((unsigned long) &batch_syscall_stub -
-                 (unsigned long) &__syscall_stub_start);
+                 (unsigned long) &__syscall_stub_start);
+
         n = ptrace_setregs(pid, regs);
         if(n < 0)
                 panic("do_syscall_stub : PTRACE_SETREGS failed, errno = %d\n",
@@ -80,6 +82,8 @@ static long do_syscall_stub(struct mm_id *mm_idp, void **addr)
         if (offset) {
                 data = (unsigned long *)(mm_idp->stack +
                                          offset - UML_CONFIG_STUB_DATA);
+                printk("do_syscall_stub : ret = %d, offset = %d, "
+                       "data = 0x%x\n", ret, offset, data);
                 syscall = (unsigned long *)((unsigned long)data + data[0]);
                 printk("do_syscall_stub: syscall %ld failed, return value = "
                        "0x%lx, expected return value = 0x%lx\n",
@@ -107,32 +111,32 @@ static long do_syscall_stub(struct mm_id *mm_idp, void **addr)
 
 long run_syscall_stub(struct mm_id * mm_idp, int syscall,
                       unsigned long *args, long expected, void **addr,
-                      int done)
+                      int done)
 {
-        unsigned long *stack = check_init_stack(mm_idp, *addr);
+        unsigned long *stack = check_init_stack(mm_idp, *addr);
 
         if(done && *addr == NULL)
                 single_count++;
 
-        *stack += sizeof(long);
+        *stack += sizeof(long);
         stack += *stack / sizeof(long);
 
-        *stack++ = syscall;
-        *stack++ = args[0];
-        *stack++ = args[1];
-        *stack++ = args[2];
-        *stack++ = args[3];
-        *stack++ = args[4];
-        *stack++ = args[5];
+        *stack++ = syscall;
+        *stack++ = args[0];
+        *stack++ = args[1];
+        *stack++ = args[2];
+        *stack++ = args[3];
+        *stack++ = args[4];
+        *stack++ = args[5];
         *stack++ = expected;
-        *stack = 0;
-        multi_op_count++;
+        *stack = 0;
+        multi_op_count++;
 
-        if(!done && ((((unsigned long) stack) & ~PAGE_MASK) <
+        if(!done && ((((unsigned long) stack) & ~PAGE_MASK) <
                      PAGE_SIZE - 10 * sizeof(long))){
                 *addr = stack;
-                return 0;
-        }
+                return 0;
+        }
 
         return do_syscall_stub(mm_idp, addr);
 }
@@ -150,7 +154,7 @@ long syscall_stub_data(struct mm_id * mm_idp,
         if((((unsigned long) *addr) & ~PAGE_MASK) >=
            PAGE_SIZE - (10 + data_count) * sizeof(long)) {
                 ret = do_syscall_stub(mm_idp, addr);
-                /* in case of error, don't overwrite data on stack */
+                /* in case of error, don't overwrite data on stack */
                 if(ret)
                         return ret;
         }
@@ -172,39 +176,39 @@ int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len,
         int r, int w, int x, int phys_fd, unsigned long long offset,
         int done, void **data)
 {
-        int prot, ret;
-
-        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
-                (x ? PROT_EXEC : 0);
-
-        if(proc_mm){
-                struct proc_mm_op map;
-                int fd = mm_idp->u.mm_fd;
-
-                map = ((struct proc_mm_op) { .op        = MM_MMAP,
-                                             .u         =
-                                             { .mmap    =
-                                               { .addr  = virt,
-                                                 .len   = len,
-                                                 .prot  = prot,
-                                                 .flags = MAP_SHARED |
-                                                 MAP_FIXED,
-                                                 .fd    = phys_fd,
-                                                 .offset= offset
-                                               } } } );
+        int prot, ret;
+
+        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
+                (x ? PROT_EXEC : 0);
+
+        if(proc_mm){
+                struct proc_mm_op map;
+                int fd = mm_idp->u.mm_fd;
+
+                map = ((struct proc_mm_op) { .op        = MM_MMAP,
+                                       .u               =
+                                       { .mmap  =
+                                         { .addr        = virt,
+                                           .len = len,
+                                           .prot        = prot,
+                                           .flags       = MAP_SHARED |
+                                           MAP_FIXED,
+                                           .fd  = phys_fd,
+                                           .offset= offset
+                                         } } } );
                 ret = os_write_file(fd, &map, sizeof(map));
                 if(ret != sizeof(map))
                         printk("map : /proc/mm map failed, err = %d\n", -ret);
                 else ret = 0;
-        }
-        else {
-                unsigned long args[] = { virt, len, prot,
-                                         MAP_SHARED | MAP_FIXED, phys_fd,
-                                         MMAP_OFFSET(offset) };
+        }
+        else {
+                unsigned long args[] = { virt, len, prot,
+                                         MAP_SHARED | MAP_FIXED, phys_fd,
+                                         MMAP_OFFSET(offset) };
 
                 ret = run_syscall_stub(mm_idp, STUB_MMAP_NR, args, virt,
                                        data, done);
-        }
+        }
 
         return ret;
 }
@@ -212,68 +216,66 @@ int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len,
 int unmap(struct mm_id * mm_idp, void *addr, unsigned long len, int done,
           void **data)
 {
-        int ret;
-
-        if(proc_mm){
-                struct proc_mm_op unmap;
-                int fd = mm_idp->u.mm_fd;
-
-                unmap = ((struct proc_mm_op) { .op      = MM_MUNMAP,
-                                               .u       =
-                                               { .munmap        =
-                                                 { .addr        =
-                                                   (unsigned long) addr,
-                                                   .len         = len } } } );
+        int ret;
+
+        if(proc_mm){
+                struct proc_mm_op unmap;
+                int fd = mm_idp->u.mm_fd;
+
+                unmap = ((struct proc_mm_op) { .op      = MM_MUNMAP,
+                                         .u     =
+                                         { .munmap      =
+                                           { .addr      =
+                                             (unsigned long) addr,
+                                             .len               = len } } } );
                 ret = os_write_file(fd, &unmap, sizeof(unmap));
                 if(ret != sizeof(unmap))
                         printk("unmap - proc_mm write returned %d\n", ret);
                 else ret = 0;
-        }
-        else {
-                unsigned long args[] = { (unsigned long) addr, len, 0, 0, 0,
-                                         0 };
+        }
+        else {
+                unsigned long args[] = { (unsigned long) addr, len, 0, 0, 0,
+                                         0 };
 
                 ret = run_syscall_stub(mm_idp, __NR_munmap, args, 0,
                                        data, done);
-                if(ret < 0)
-                        printk("munmap stub failed, errno = %d\n", ret);
-        }
+        }
 
-        return ret;
+        return ret;
 }
 
 int protect(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
             int r, int w, int x, int done, void **data)
 {
-        struct proc_mm_op protect;
-        int prot, ret;
-
-        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
-                (x ? PROT_EXEC : 0);
-
-        if(proc_mm){
-                int fd = mm_idp->u.mm_fd;
-                protect = ((struct proc_mm_op) { .op    = MM_MPROTECT,
-                                                 .u     =
-                                                 { .mprotect    =
-                                                   { .addr      =
-                                                     (unsigned long) addr,
-                                                     .len       = len,
-                                                     .prot      = prot } } } );
-
-                ret = os_write_file(fd, &protect, sizeof(protect));
-                if(ret != sizeof(protect))
-                        printk("protect failed, err = %d", -ret);
-                else ret = 0;
-        }
-        else {
-                unsigned long args[] = { addr, len, prot, 0, 0, 0 };
-
-                ret = run_syscall_stub(mm_idp, __NR_mprotect, args, 0,
-                                       data, done);
-        }
-
-        return ret;
+        struct proc_mm_op protect;
+        int prot, ret;
+
+        prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
+                (x ? PROT_EXEC : 0);
+        if(proc_mm){
+                int fd = mm_idp->u.mm_fd;
+
+                protect = ((struct proc_mm_op) { .op    = MM_MPROTECT,
+                                           .u   =
+                                           { .mprotect  =
+                                             { .addr    =
+                                               (unsigned long) addr,
+                                               .len     = len,
+                                               .prot    = prot } } } );
+
+                ret = os_write_file(fd, &protect, sizeof(protect));
+                if(ret != sizeof(protect))
+                        printk("protect failed, err = %d", -ret);
+                else ret = 0;
+        }
+        else {
+                unsigned long args[] = { addr, len, prot, 0, 0, 0 };
+
+                ret = run_syscall_stub(mm_idp, __NR_mprotect, args, 0,
+                                       data, done);
+        }
+
+        return ret;
 }
 
 void before_mem_skas(unsigned long unused)
diff --git a/arch/um/kernel/skas/process.c b/arch/um/os-Linux/skas/process.c
index 3b3955d84407..bbf34cb91ce1 100644
--- a/arch/um/kernel/skas/process.c
+++ b/arch/um/os-Linux/skas/process.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2002- 2004 Jeff Dike (jdike@addtoit.com)
  * Licensed under the GPL
  */
@@ -10,6 +10,7 @@
 #include <signal.h>
 #include <setjmp.h>
 #include <sched.h>
+#include "ptrace_user.h"
 #include <sys/wait.h>
 #include <sys/mman.h>
 #include <sys/user.h>
@@ -17,8 +18,6 @@
 #include <asm/unistd.h>
 #include <asm/types.h>
 #include "user.h"
-#include "ptrace_user.h"
-#include "time_user.h"
 #include "sysdep/ptrace.h"
 #include "user_util.h"
 #include "kern_util.h"
@@ -35,10 +34,11 @@
 #include "mem.h"
 #include "uml-config.h"
 #include "process.h"
+#include "longjmp.h"
 
 int is_skas_winch(int pid, int fd, void *data)
 {
-        if(pid != os_getpgrp())
+        if(pid != os_getpgrp())
                 return(0);
 
         register_winch_irq(-1, fd, -1, data);
@@ -47,28 +47,29 @@ int is_skas_winch(int pid, int fd, void *data)
 
 void wait_stub_done(int pid, int sig, char * fname)
 {
-        int n, status, err;
-
-        do {
-                if ( sig != -1 ) {
-                        err = ptrace(PTRACE_CONT, pid, 0, sig);
-                        if(err)
-                                panic("%s : continue failed, errno = %d\n",
-                                      fname, errno);
-                }
-                sig = 0;
-
-                CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
-        } while((n >= 0) && WIFSTOPPED(status) &&
-                ((WSTOPSIG(status) == SIGVTALRM) ||
+        int n, status, err;
+
+        do {
+                if ( sig != -1 ) {
+                        err = ptrace(PTRACE_CONT, pid, 0, sig);
+                        if(err)
+                                panic("%s : continue failed, errno = %d\n",
+                                      fname, errno);
+                }
+                sig = 0;
+
+                CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
+        } while((n >= 0) && WIFSTOPPED(status) &&
+                ((WSTOPSIG(status) == SIGVTALRM) ||
                  /* running UML inside a detached screen can cause
                   * SIGWINCHes
                   */
                  (WSTOPSIG(status) == SIGWINCH)));
 
-        if((n < 0) || !WIFSTOPPED(status) ||
-           (WSTOPSIG(status) != SIGUSR1 && WSTOPSIG(status) != SIGTRAP)){
+        if((n < 0) || !WIFSTOPPED(status) ||
+           (WSTOPSIG(status) != SIGUSR1 && WSTOPSIG(status) != SIGTRAP)){
                 unsigned long regs[HOST_FRAME_SIZE];
+
                 if(ptrace(PTRACE_GETREGS, pid, 0, regs) < 0)
                         printk("Failed to get registers from stub, "
                                "errno = %d\n", errno);
@@ -79,42 +80,44 @@ void wait_stub_done(int pid, int sig, char * fname)
                         for(i = 0; i < HOST_FRAME_SIZE; i++)
                                 printk("\t%d - %lx\n", i, regs[i]);
                 }
-                panic("%s : failed to wait for SIGUSR1/SIGTRAP, "
-                      "pid = %d, n = %d, errno = %d, status = 0x%x\n",
-                      fname, pid, n, errno, status);
-        }
+                panic("%s : failed to wait for SIGUSR1/SIGTRAP, "
+                      "pid = %d, n = %d, errno = %d, status = 0x%x\n",
+                      fname, pid, n, errno, status);
+        }
 }
 
+extern unsigned long current_stub_stack(void);
+
 void get_skas_faultinfo(int pid, struct faultinfo * fi)
 {
-        int err;
-
-        if(ptrace_faultinfo){
-                err = ptrace(PTRACE_FAULTINFO, pid, 0, fi);
-                if(err)
-                        panic("get_skas_faultinfo - PTRACE_FAULTINFO failed, "
-                              "errno = %d\n", errno);
-
-                /* Special handling for i386, which has different structs */
-                if (sizeof(struct ptrace_faultinfo) < sizeof(struct faultinfo))
-                        memset((char *)fi + sizeof(struct ptrace_faultinfo), 0,
-                               sizeof(struct faultinfo) -
-                               sizeof(struct ptrace_faultinfo));
-        }
-        else {
-                wait_stub_done(pid, SIGSEGV, "get_skas_faultinfo");
-
-                /* faultinfo is prepared by the stub-segv-handler at start of
-                 * the stub stack page. We just have to copy it.
-                 */
-                memcpy(fi, (void *)current_stub_stack(), sizeof(*fi));
-        }
+        int err;
+
+        if(ptrace_faultinfo){
+                err = ptrace(PTRACE_FAULTINFO, pid, 0, fi);
+                if(err)
+                        panic("get_skas_faultinfo - PTRACE_FAULTINFO failed, "
+                              "errno = %d\n", errno);
+
+                /* Special handling for i386, which has different structs */
+                if (sizeof(struct ptrace_faultinfo) < sizeof(struct faultinfo))
+                        memset((char *)fi + sizeof(struct ptrace_faultinfo), 0,
+                               sizeof(struct faultinfo) -
+                               sizeof(struct ptrace_faultinfo));
+        }
+        else {
+                wait_stub_done(pid, SIGSEGV, "get_skas_faultinfo");
+
+                /* faultinfo is prepared by the stub-segv-handler at start of
+                 * the stub stack page. We just have to copy it.
+                 */
+                memcpy(fi, (void *)current_stub_stack(), sizeof(*fi));
+        }
 }
 
 static void handle_segv(int pid, union uml_pt_regs * regs)
 {
-        get_skas_faultinfo(pid, &regs->skas.faultinfo);
-        segv(regs->skas.faultinfo, 0, 1, NULL);
+        get_skas_faultinfo(pid, &regs->skas.faultinfo);
+        segv(regs->skas.faultinfo, 0, 1, NULL);
 }
 
 /*To use the same value of using_sysemu as the caller, ask it that value (in local_using_sysemu)*/
@@ -127,7 +130,8 @@ static void handle_trap(int pid, union uml_pt_regs *regs, int local_using_sysemu
 
         if (!local_using_sysemu)
         {
-                err = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET, __NR_getpid);
+                err = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET,
+                             __NR_getpid);
                 if(err < 0)
                         panic("handle_trap - nullifying syscall failed errno = %d\n",
                               errno);
@@ -148,8 +152,6 @@ static void handle_trap(int pid, union uml_pt_regs *regs, int local_using_sysemu
 }
 
 extern int __syscall_stub_start;
-int stub_code_fd = -1;
-__u64 stub_code_offset;
 
 static int userspace_tramp(void *stack)
 {
@@ -164,31 +166,30 @@ static int userspace_tramp(void *stack)
                 /* This has a pte, but it can't be mapped in with the usual
                  * tlb_flush mechanism because this is part of that mechanism
                  */
+                int fd;
+                __u64 offset;
+                fd = phys_mapping(to_phys(&__syscall_stub_start), &offset);
                 addr = mmap64((void *) UML_CONFIG_STUB_CODE, page_size(),
-                              PROT_EXEC, MAP_FIXED | MAP_PRIVATE,
-                              stub_code_fd, stub_code_offset);
+                              PROT_EXEC, MAP_FIXED | MAP_PRIVATE, fd, offset);
                 if(addr == MAP_FAILED){
-                        printk("mapping stub code failed, errno = %d\n",
+                        printk("mapping mmap stub failed, errno = %d\n",
                                errno);
                         exit(1);
                 }
 
                 if(stack != NULL){
-                        int fd;
-                        __u64 offset;
-
                         fd = phys_mapping(to_phys(stack), &offset);
                         addr = mmap((void *) UML_CONFIG_STUB_DATA, page_size(),
                                     PROT_READ | PROT_WRITE,
                                     MAP_FIXED | MAP_SHARED, fd, offset);
                         if(addr == MAP_FAILED){
-                                printk("mapping stub stack failed, "
+                                printk("mapping segfault stack failed, "
                                        "errno = %d\n", errno);
                                 exit(1);
                         }
                 }
         }
-        if(!ptrace_faultinfo){
+        if(!ptrace_faultinfo && (stack != NULL)){
                 unsigned long v = UML_CONFIG_STUB_CODE +
                                   (unsigned long) stub_segv_handler -
                                   (unsigned long) &__syscall_stub_start;
@@ -214,10 +215,6 @@ int start_userspace(unsigned long stub_stack)
         unsigned long sp;
         int pid, status, n, flags;
 
-        if ( stub_code_fd == -1 )
-                stub_code_fd = phys_mapping(to_phys(&__syscall_stub_start),
-                                            &stub_code_offset);
-
         stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
         if(stack == MAP_FAILED)
@@ -233,7 +230,7 @@ int start_userspace(unsigned long stub_stack)
         do {
                 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
                 if(n < 0)
-                        panic("start_userspace : wait failed, errno = %d", 
+                        panic("start_userspace : wait failed, errno = %d",
                               errno);
         } while(WIFSTOPPED(status) && (WSTOPSIG(status) == SIGVTALRM));
 
@@ -242,7 +239,7 @@ int start_userspace(unsigned long stub_stack)
                       status);
 
         if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL, (void *)PTRACE_O_TRACESYSGOOD) < 0)
-                panic("start_userspace : PTRACE_SETOPTIONS failed, errno=%d\n",
+                panic("start_userspace : PTRACE_OLDSETOPTIONS failed, errno=%d\n",
                       errno);
 
         if(munmap(stack, PAGE_SIZE) < 0)
@@ -272,7 +269,7 @@ void userspace(union uml_pt_regs *regs)
 
                 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED));
                 if(err < 0)
-                        panic("userspace - waitpid failed, errno = %d\n", 
+                        panic("userspace - waitpid failed, errno = %d\n",
                               errno);
 
                 regs->skas.is_user = 1;
@@ -282,9 +279,9 @@ void userspace(union uml_pt_regs *regs)
                 if(WIFSTOPPED(status)){
                         switch(WSTOPSIG(status)){
                         case SIGSEGV:
-                                if(PTRACE_FULL_FAULTINFO || !ptrace_faultinfo)
-                                        user_signal(SIGSEGV, regs, pid);
-                                else handle_segv(pid, regs);
+                                if(PTRACE_FULL_FAULTINFO || !ptrace_faultinfo)
+                                        user_signal(SIGSEGV, regs, pid);
+                                else handle_segv(pid, regs);
                                 break;
                         case SIGTRAP + 0x80:
                                 handle_trap(pid, regs, local_using_sysemu);
@@ -298,7 +295,7 @@ void userspace(union uml_pt_regs *regs)
                         case SIGBUS:
                         case SIGFPE:
                         case SIGWINCH:
-                                user_signal(WSTOPSIG(status), regs, pid);
+                                user_signal(WSTOPSIG(status), regs, pid);
                                 break;
                         default:
                                 printk("userspace - child stopped with signal "
@@ -308,21 +305,17 @@ void userspace(union uml_pt_regs *regs)
                         interrupt_end();
 
                         /* Avoid -ERESTARTSYS handling in host */
-                        PT_SYSCALL_NR(regs->skas.regs) = -1;
+                        if(PT_SYSCALL_NR_OFFSET != PT_SYSCALL_RET_OFFSET)
+                                PT_SYSCALL_NR(regs->skas.regs) = -1;
                 }
         }
 }
-#define INIT_JMP_NEW_THREAD 0
-#define INIT_JMP_REMOVE_SIGSTACK 1
-#define INIT_JMP_CALLBACK 2
-#define INIT_JMP_HALT 3
-#define INIT_JMP_REBOOT 4
-
 
 int copy_context_skas0(unsigned long new_stack, int pid)
 {
         int err;
-        unsigned long regs[MAX_REG_NR];
+        unsigned long regs[HOST_FRAME_SIZE];
+        unsigned long fp_regs[HOST_FP_SIZE];
         unsigned long current_stack = current_stub_stack();
         struct stub_data *data = (struct stub_data *) current_stack;
         struct stub_data *child_data = (struct stub_data *) new_stack;
@@ -334,10 +327,10 @@ int copy_context_skas0(unsigned long new_stack, int pid)
          */
         *data = ((struct stub_data) { .offset   = MMAP_OFFSET(new_offset),
                                       .fd       = new_fd,
-                                      .timer    = ((struct itimerval)
-                                                   { { 0, 1000000 / hz() },
-                                                     { 0, 1000000 / hz() }})});
-        get_safe_registers(regs);
+                                      .timer    = ((struct itimerval)
+                                                    { { 0, 1000000 / hz() },
+                                                      { 0, 1000000 / hz() }})});
+        get_safe_registers(regs, fp_regs);
 
         /* Set parent's instruction pointer to start of clone-stub */
         regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
@@ -345,11 +338,19 @@ int copy_context_skas0(unsigned long new_stack, int pid)
                                 (unsigned long) &__syscall_stub_start;
         regs[REGS_SP_INDEX] = UML_CONFIG_STUB_DATA + PAGE_SIZE -
                 sizeof(void *);
+#ifdef __SIGNAL_FRAMESIZE
+        regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE;
+#endif
         err = ptrace_setregs(pid, regs);
         if(err < 0)
                 panic("copy_context_skas0 : PTRACE_SETREGS failed, "
                       "pid = %d, errno = %d\n", pid, errno);
 
+        err = ptrace_setfpregs(pid, fp_regs);
+        if(err < 0)
+                panic("copy_context_skas0 : PTRACE_SETFPREGS failed, "
+                      "pid = %d, errno = %d\n", pid, errno);
+
         /* set a well known return code for detection of child write failure */
         child_data->err = 12345678;
 
@@ -373,7 +374,7 @@ int copy_context_skas0(unsigned long new_stack, int pid)
 
         if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL,
                    (void *)PTRACE_O_TRACESYSGOOD) < 0)
-                panic("copy_context_skas0 : PTRACE_SETOPTIONS failed, "
+                panic("copy_context_skas0 : PTRACE_OLDSETOPTIONS failed, "
                       "errno = %d\n", errno);
 
         return pid;
@@ -389,6 +390,9 @@ void map_stub_pages(int fd, unsigned long code,
 {
         struct proc_mm_op mmop;
         int n;
+        __u64 code_offset;
+        int code_fd = phys_mapping(to_phys((void *) &__syscall_stub_start),
+                                   &code_offset);
 
         mmop = ((struct proc_mm_op) { .op        = MM_MMAP,
                                       .u         =
@@ -397,8 +401,8 @@ void map_stub_pages(int fd, unsigned long code,
                                           .len     = PAGE_SIZE,
                                           .prot    = PROT_EXEC,
                                           .flags   = MAP_FIXED | MAP_PRIVATE,
-                                          .fd      = stub_code_fd,
-                                          .offset  = stub_code_offset
+                                          .fd      = code_fd,
+                                          .offset  = code_offset
         } } });
         n = os_write_file(fd, &mmop, sizeof(mmop));
         if(n != sizeof(mmop))
@@ -431,6 +435,7 @@ void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
 {
         unsigned long flags;
         sigjmp_buf switch_buf, fork_buf;
+        int enable;
 
         *switch_buf_ptr = &switch_buf;
         *fork_buf_ptr = &fork_buf;
@@ -445,7 +450,7 @@ void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
          */
         flags = get_signals();
         block_signals();
-        if(sigsetjmp(fork_buf, 1) == 0)
+        if(UML_SIGSETJMP(&fork_buf, enable) == 0)
                 new_thread_proc(stack, handler);
 
         remove_sigstack();
@@ -453,23 +458,31 @@ void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
         set_signals(flags);
 }
 
+#define INIT_JMP_NEW_THREAD 0
+#define INIT_JMP_REMOVE_SIGSTACK 1
+#define INIT_JMP_CALLBACK 2
+#define INIT_JMP_HALT 3
+#define INIT_JMP_REBOOT 4
+
 void thread_wait(void *sw, void *fb)
 {
         sigjmp_buf buf, **switch_buf = sw, *fork_buf;
+        int enable;
 
         *switch_buf = &buf;
         fork_buf = fb;
-        if(sigsetjmp(buf, 1) == 0)
+        if(UML_SIGSETJMP(&buf, enable) == 0)
                 siglongjmp(*fork_buf, INIT_JMP_REMOVE_SIGSTACK);
 }
 
 void switch_threads(void *me, void *next)
 {
         sigjmp_buf my_buf, **me_ptr = me, *next_buf = next;
-        
+        int enable;
+
         *me_ptr = &my_buf;
-        if(sigsetjmp(my_buf, 1) == 0)
-                siglongjmp(*next_buf, 1);
+        if(UML_SIGSETJMP(&my_buf, enable) == 0)
+                UML_SIGLONGJMP(next_buf, 1);
 }
 
 static sigjmp_buf initial_jmpbuf;
@@ -482,48 +495,49 @@ static sigjmp_buf *cb_back;
 int start_idle_thread(void *stack, void *switch_buf_ptr, void **fork_buf_ptr)
 {
         sigjmp_buf **switch_buf = switch_buf_ptr;
-        int n;
+        int n, enable;
 
         set_handler(SIGWINCH, (__sighandler_t) sig_handler,
                     SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGALRM,
                     SIGVTALRM, -1);
 
         *fork_buf_ptr = &initial_jmpbuf;
-        n = sigsetjmp(initial_jmpbuf, 1);
-        switch(n){
-        case INIT_JMP_NEW_THREAD:
-                new_thread_proc((void *) stack, new_thread_handler);
-                break;
-        case INIT_JMP_REMOVE_SIGSTACK:
-                remove_sigstack();
-                break;
-        case INIT_JMP_CALLBACK:
+        n = UML_SIGSETJMP(&initial_jmpbuf, enable);
+        switch(n){
+        case INIT_JMP_NEW_THREAD:
+                new_thread_proc((void *) stack, new_thread_handler);
+                break;
+        case INIT_JMP_REMOVE_SIGSTACK:
+                remove_sigstack();
+                break;
+        case INIT_JMP_CALLBACK:
                 (*cb_proc)(cb_arg);
-                siglongjmp(*cb_back, 1);
-                break;
-        case INIT_JMP_HALT:
+                UML_SIGLONGJMP(cb_back, 1);
+                break;
+        case INIT_JMP_HALT:
                 kmalloc_ok = 0;
                 return(0);
-        case INIT_JMP_REBOOT:
+        case INIT_JMP_REBOOT:
                 kmalloc_ok = 0;
                 return(1);
-        default:
-                panic("Bad sigsetjmp return in start_idle_thread - %d\n", n);
+        default:
+                panic("Bad sigsetjmp return in start_idle_thread - %d\n", n);
         }
-        siglongjmp(**switch_buf, 1);
+        UML_SIGLONGJMP(*switch_buf, 1);
 }
 
 void initial_thread_cb_skas(void (*proc)(void *), void *arg)
 {
         sigjmp_buf here;
+        int enable;
 
         cb_proc = proc;
         cb_arg = arg;
         cb_back = &here;
 
         block_signals();
-        if(sigsetjmp(here, 1) == 0)
-                siglongjmp(initial_jmpbuf, INIT_JMP_CALLBACK);
+        if(UML_SIGSETJMP(&here, enable) == 0)
+                UML_SIGLONGJMP(&initial_jmpbuf, INIT_JMP_CALLBACK);
         unblock_signals();
 
         cb_proc = NULL;
@@ -534,13 +548,13 @@ void initial_thread_cb_skas(void (*proc)(void *), void *arg)
 void halt_skas(void)
 {
         block_signals();
-        siglongjmp(initial_jmpbuf, INIT_JMP_HALT);
+        UML_SIGLONGJMP(&initial_jmpbuf, INIT_JMP_HALT);
 }
 
 void reboot_skas(void)
 {
         block_signals();
-        siglongjmp(initial_jmpbuf, INIT_JMP_REBOOT);
+        UML_SIGLONGJMP(&initial_jmpbuf, INIT_JMP_REBOOT);
 }
 
 void switch_mm_skas(struct mm_id *mm_idp)
@@ -557,14 +571,3 @@ void switch_mm_skas(struct mm_id *mm_idp)
         }
         else userspace_pid[0] = mm_idp->u.pid;
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/os-Linux/start_up.c b/arch/um/os-Linux/start_up.c
index b47e5e71d1a5..829d6b0d8b02 100644
--- a/arch/um/os-Linux/start_up.c
+++ b/arch/um/os-Linux/start_up.c
@@ -29,7 +29,6 @@
 #include "irq_user.h"
 #include "ptrace_user.h"
 #include "mem_user.h"
-#include "time_user.h"
 #include "init.h"
 #include "os.h"
 #include "uml-config.h"
@@ -50,6 +49,7 @@ static int ptrace_child(void *arg)
         int pid = os_getpid(), ppid = getppid();
         int sc_result;
 
+        change_sig(SIGWINCH, 0);
         if(ptrace(PTRACE_TRACEME, 0, 0, 0) < 0){
                 perror("ptrace");
                 os_kill_process(pid, 0);
diff --git a/arch/um/os-Linux/sys-i386/registers.c b/arch/um/os-Linux/sys-i386/registers.c
index aee4812333c6..7a6f6b99ceff 100644
--- a/arch/um/os-Linux/sys-i386/registers.c
+++ b/arch/um/os-Linux/sys-i386/registers.c
@@ -122,9 +122,12 @@ void init_registers(int pid)
                       err);
 }
 
-void get_safe_registers(unsigned long *regs)
+void get_safe_registers(unsigned long *regs, unsigned long *fp_regs)
 {
         memcpy(regs, exec_regs, HOST_FRAME_SIZE * sizeof(unsigned long));
+        if(fp_regs != NULL)
+                memcpy(fp_regs, exec_fp_regs,
+                       HOST_FP_SIZE * sizeof(unsigned long));
 }
 
 void get_thread_regs(union uml_pt_regs *uml_regs, void *buffer)
diff --git a/arch/um/os-Linux/sys-x86_64/registers.c b/arch/um/os-Linux/sys-x86_64/registers.c
index 4b638dfb52b0..001941fa1a1e 100644
--- a/arch/um/os-Linux/sys-x86_64/registers.c
+++ b/arch/um/os-Linux/sys-x86_64/registers.c
@@ -70,9 +70,12 @@ void init_registers(int pid)
                       err);
 }
 
-void get_safe_registers(unsigned long *regs)
+void get_safe_registers(unsigned long *regs, unsigned long *fp_regs)
 {
         memcpy(regs, exec_regs, HOST_FRAME_SIZE * sizeof(unsigned long));
+        if(fp_regs != NULL)
+                memcpy(fp_regs, exec_fp_regs,
+                       HOST_FP_SIZE * sizeof(unsigned long));
 }
 
 void get_thread_regs(union uml_pt_regs *uml_regs, void *buffer)
diff --git a/arch/um/os-Linux/time.c b/arch/um/os-Linux/time.c
index cf30a39bc484..6f7626775acb 100644
--- a/arch/um/os-Linux/time.c
+++ b/arch/um/os-Linux/time.c
@@ -1,21 +1,128 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Licensed under the GPL
+ */
+
+#include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
 #include <sys/time.h>
+#include <signal.h>
+#include <errno.h>
+#include "user_util.h"
+#include "kern_util.h"
+#include "user.h"
+#include "process.h"
+#include "kern_constants.h"
+#include "os.h"
+
+/* XXX This really needs to be declared and initialized in a kernel file since
+ * it's in <linux/time.h>
+ */
+extern struct timespec wall_to_monotonic;
+
+static void set_interval(int timer_type)
+{
+        int usec = 1000000/hz();
+        struct itimerval interval = ((struct itimerval) { { 0, usec },
+                                                          { 0, usec } });
+
+        if(setitimer(timer_type, &interval, NULL) == -1)
+                panic("setitimer failed - errno = %d\n", errno);
+}
+
+void enable_timer(void)
+{
+        set_interval(ITIMER_VIRTUAL);
+}
+
+void disable_timer(void)
+{
+        struct itimerval disable = ((struct itimerval) { { 0, 0 }, { 0, 0 }});
+        if((setitimer(ITIMER_VIRTUAL, &disable, NULL) < 0) ||
+           (setitimer(ITIMER_REAL, &disable, NULL) < 0))
+                printk("disnable_timer - setitimer failed, errno = %d\n",
+                       errno);
+        /* If there are signals already queued, after unblocking ignore them */
+        set_handler(SIGALRM, SIG_IGN, 0, -1);
+        set_handler(SIGVTALRM, SIG_IGN, 0, -1);
+}
+
+void switch_timers(int to_real)
+{
+        struct itimerval disable = ((struct itimerval) { { 0, 0 }, { 0, 0 }});
+        struct itimerval enable = ((struct itimerval) { { 0, 1000000/hz() },
+                                                        { 0, 1000000/hz() }});
+        int old, new;
+
+        if(to_real){
+                old = ITIMER_VIRTUAL;
+                new = ITIMER_REAL;
+        }
+        else {
+                old = ITIMER_REAL;
+                new = ITIMER_VIRTUAL;
+        }
+
+        if((setitimer(old, &disable, NULL) < 0) ||
+           (setitimer(new, &enable, NULL)))
+                printk("switch_timers - setitimer failed, errno = %d\n",
+                       errno);
+}
 
-unsigned long long os_usecs(void)
+void uml_idle_timer(void)
+{
+        if(signal(SIGVTALRM, SIG_IGN) == SIG_ERR)
+                panic("Couldn't unset SIGVTALRM handler");
+
+        set_handler(SIGALRM, (__sighandler_t) alarm_handler,
+                    SA_RESTART, SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
+        set_interval(ITIMER_REAL);
+}
+
+extern void ktime_get_ts(struct timespec *ts);
+#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
+
+void time_init(void)
+{
+        struct timespec now;
+
+        if(signal(SIGVTALRM, boot_timer_handler) == SIG_ERR)
+                panic("Couldn't set SIGVTALRM handler");
+        set_interval(ITIMER_VIRTUAL);
+
+        do_posix_clock_monotonic_gettime(&now);
+        wall_to_monotonic.tv_sec = -now.tv_sec;
+        wall_to_monotonic.tv_nsec = -now.tv_nsec;
+}
+
+unsigned long long os_nsecs(void)
 {
         struct timeval tv;
 
         gettimeofday(&tv, NULL);
-        return((unsigned long long) tv.tv_sec * 1000000 + tv.tv_usec);
+        return((unsigned long long) tv.tv_sec * BILLION + tv.tv_usec * 1000);
 }
 
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
+void idle_sleep(int secs)
+{
+        struct timespec ts;
+
+        ts.tv_sec = secs;
+        ts.tv_nsec = 0;
+        nanosleep(&ts, NULL);
+}
+
+/* XXX This partly duplicates init_irq_signals */
+
+void user_time_init(void)
+{
+        set_handler(SIGVTALRM, (__sighandler_t) alarm_handler,
+                    SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGWINCH,
+                    SIGALRM, SIGUSR2, -1);
+        set_handler(SIGALRM, (__sighandler_t) alarm_handler,
+                    SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGWINCH,
+                    SIGVTALRM, SIGUSR2, -1);
+        set_interval(ITIMER_VIRTUAL);
+}
diff --git a/arch/um/os-Linux/trap.c b/arch/um/os-Linux/trap.c
index 321e1c8e227d..a9f6b26f9828 100644
--- a/arch/um/os-Linux/trap.c
+++ b/arch/um/os-Linux/trap.c
@@ -10,6 +10,7 @@
 #include "user_util.h"
 #include "os.h"
 #include "mode.h"
+#include "longjmp.h"
 
 void usr2_handler(int sig, union uml_pt_regs *regs)
 {
@@ -36,5 +37,5 @@ void do_longjmp(void *b, int val)
 {
         sigjmp_buf *buf = b;
 
-        siglongjmp(*buf, val);
+        UML_SIGLONGJMP(buf, val);
 }
diff --git a/arch/um/os-Linux/tt.c b/arch/um/os-Linux/tt.c
index cb2648b79d0f..919d19f11537 100644
--- a/arch/um/os-Linux/tt.c
+++ b/arch/um/os-Linux/tt.c
@@ -27,7 +27,6 @@
 #include "sysdep/sigcontext.h"
 #include "irq_user.h"
 #include "ptrace_user.h"
-#include "time_user.h"
 #include "init.h"
 #include "os.h"
 #include "uml-config.h"
@@ -63,6 +62,54 @@ void kill_child_dead(int pid)
         } while(1);
 }
 
+void stop(void)
+{
+        while(1) sleep(1000000);
+}
+
+int wait_for_stop(int pid, int sig, int cont_type, void *relay)
+{
+        sigset_t *relay_signals = relay;
+        int status, ret;
+
+        while(1){
+                CATCH_EINTR(ret = waitpid(pid, &status, WUNTRACED));
+                if((ret < 0) ||
+                   !WIFSTOPPED(status) || (WSTOPSIG(status) != sig)){
+                        if(ret < 0){
+                                printk("wait failed, errno = %d\n",
+                                       errno);
+                        }
+                        else if(WIFEXITED(status))
+                                printk("process %d exited with status %d\n",
+                                       pid, WEXITSTATUS(status));
+                        else if(WIFSIGNALED(status))
+                                printk("process %d exited with signal %d\n",
+                                       pid, WTERMSIG(status));
+                        else if((WSTOPSIG(status) == SIGVTALRM) ||
+                                (WSTOPSIG(status) == SIGALRM) ||
+                                (WSTOPSIG(status) == SIGIO) ||
+                                (WSTOPSIG(status) == SIGPROF) ||
+                                (WSTOPSIG(status) == SIGCHLD) ||
+                                (WSTOPSIG(status) == SIGWINCH) ||
+                                (WSTOPSIG(status) == SIGINT)){
+                                ptrace(cont_type, pid, 0, WSTOPSIG(status));
+                                continue;
+                        }
+                        else if((relay_signals != NULL) &&
+                                sigismember(relay_signals, WSTOPSIG(status))){
+                                ptrace(cont_type, pid, 0, WSTOPSIG(status));
+                                continue;
+                        }
+                        else printk("process %d stopped with signal %d\n",
+                                    pid, WSTOPSIG(status));
+                        panic("wait_for_stop failed to wait for %d to stop "
+                              "with %d\n", pid, sig);
+                }
+                return(status);
+        }
+}
+
 /*
  *-------------------------
  * only for tt mode (will be deleted in future...)
diff --git a/arch/um/os-Linux/uaccess.c b/arch/um/os-Linux/uaccess.c
index 38d710158c3d..166fb66995df 100644
--- a/arch/um/os-Linux/uaccess.c
+++ b/arch/um/os-Linux/uaccess.c
@@ -6,6 +6,7 @@
 
 #include <setjmp.h>
 #include <string.h>
+#include "longjmp.h"
 
 unsigned long __do_user_copy(void *to, const void *from, int n,
                              void **fault_addr, void **fault_catcher,
@@ -13,10 +14,11 @@ unsigned long __do_user_copy(void *to, const void *from, int n,
                                         int n), int *faulted_out)
 {
         unsigned long *faddrp = (unsigned long *) fault_addr, ret;
+        int enable;
 
         sigjmp_buf jbuf;
         *fault_catcher = &jbuf;
-        if(sigsetjmp(jbuf, 1) == 0){
+        if(UML_SIGSETJMP(&jbuf, enable) == 0){
                 (*op)(to, from, n);
                 ret = 0;
                 *faulted_out = 0;
diff --git a/arch/um/kernel/user_util.c b/arch/um/os-Linux/util.c
index 4c231161f257..e32065e2fdc8 100644
--- a/arch/um/kernel/user_util.c
+++ b/arch/um/os-Linux/util.c
@@ -1,4 +1,4 @@
-/* 
+/*
  * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
  * Licensed under the GPL
  */
@@ -29,17 +29,14 @@
 #include "init.h"
 #include "ptrace_user.h"
 #include "uml-config.h"
-
-void stop(void)
-{
-        while(1) sleep(1000000);
-}
+#include "os.h"
+#include "longjmp.h"
 
 void stack_protections(unsigned long address)
 {
         int prot = PROT_READ | PROT_WRITE | PROT_EXEC;
 
-        if(mprotect((void *) address, page_size(), prot) < 0)
+        if(mprotect((void *) address, page_size(), prot) < 0)
                 panic("protecting stack failed, errno = %d", errno);
 }
 
@@ -59,49 +56,6 @@ void task_protections(unsigned long address)
                 panic("protecting stack failed, errno = %d", errno);
 }
 
-int wait_for_stop(int pid, int sig, int cont_type, void *relay)
-{
-        sigset_t *relay_signals = relay;
-        int status, ret;
-
-        while(1){
-                CATCH_EINTR(ret = waitpid(pid, &status, WUNTRACED));
-                if((ret < 0) ||
-                   !WIFSTOPPED(status) || (WSTOPSIG(status) != sig)){
-                        if(ret < 0){
-                                printk("wait failed, errno = %d\n",
-                                       errno);
-                        }
-                        else if(WIFEXITED(status)) 
-                                printk("process %d exited with status %d\n",
-                                       pid, WEXITSTATUS(status));
-                        else if(WIFSIGNALED(status))
-                                printk("process %d exited with signal %d\n",
-                                       pid, WTERMSIG(status));
-                        else if((WSTOPSIG(status) == SIGVTALRM) ||
-                                (WSTOPSIG(status) == SIGALRM) ||
-                                (WSTOPSIG(status) == SIGIO) ||
-                                (WSTOPSIG(status) == SIGPROF) ||
-                                (WSTOPSIG(status) == SIGCHLD) ||
-                                (WSTOPSIG(status) == SIGWINCH) ||
-                                (WSTOPSIG(status) == SIGINT)){
-                                ptrace(cont_type, pid, 0, WSTOPSIG(status));
-                                continue;
-                        }
-                        else if((relay_signals != NULL) &&
-                                sigismember(relay_signals, WSTOPSIG(status))){
-                                ptrace(cont_type, pid, 0, WSTOPSIG(status));
-                                continue;
-                        }
-                        else printk("process %d stopped with signal %d\n",
-                                    pid, WSTOPSIG(status));
-                        panic("wait_for_stop failed to wait for %d to stop "
-                              "with %d\n", pid, sig);
-                }
-                return(status);
-        }
-}
-
 int raw(int fd)
 {
         struct termios tt;
@@ -113,7 +67,7 @@ int raw(int fd)
 
         cfmakeraw(&tt);
 
-        CATCH_EINTR(err = tcsetattr(fd, TCSADRAIN, &tt));
+        CATCH_EINTR(err = tcsetattr(fd, TCSADRAIN, &tt));
         if(err < 0)
                 return -errno;
 
@@ -149,7 +103,7 @@ void setup_hostinfo(void)
 
 int setjmp_wrapper(void (*proc)(void *, void *), ...)
 {
-        va_list args;
+        va_list args;
         sigjmp_buf buf;
         int n;
 
@@ -161,14 +115,3 @@ int setjmp_wrapper(void (*proc)(void *, void *), ...)
         va_end(args);
         return(n);
 }
-
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/sys-i386/ldt.c b/arch/um/sys-i386/ldt.c
index 17746b4c08ff..1fa09a79a10b 100644
--- a/arch/um/sys-i386/ldt.c
+++ b/arch/um/sys-i386/ldt.c
@@ -16,6 +16,7 @@
 #include "choose-mode.h"
 #include "kern.h"
 #include "mode_kern.h"
+#include "os.h"
 
 extern int modify_ldt(int func, void *ptr, unsigned long bytecount);
 
@@ -88,6 +89,7 @@ out:
 #include "skas.h"
 #include "skas_ptrace.h"
 #include "asm/mmu_context.h"
+#include "proc_mm.h"
 
 long write_ldt_entry(struct mm_id * mm_idp, int func, struct user_desc * desc,
                      void **addr, int done)
@@ -456,13 +458,14 @@ long init_new_ldt(struct mmu_context_skas * new_mm,
         int i;
         long page, err=0;
         void *addr = NULL;
+        struct proc_mm_op copy;
 
-        memset(&desc, 0, sizeof(desc));
 
         if(!ptrace_ldt)
                 init_MUTEX(&new_mm->ldt.semaphore);
 
         if(!from_mm){
+                memset(&desc, 0, sizeof(desc));
                 /*
                  * We have to initialize a clean ldt.
                  */
@@ -494,8 +497,26 @@ long init_new_ldt(struct mmu_context_skas * new_mm,
                         }
                 }
                 new_mm->ldt.entry_count = 0;
+
+                goto out;
         }
-        else if (!ptrace_ldt) {
+
+        if(proc_mm){
+                /* We have a valid from_mm, so we now have to copy the LDT of
+                 * from_mm to new_mm, because using proc_mm an new mm with
+                 * an empty/default LDT was created in new_mm()
+                 */
+                copy = ((struct proc_mm_op) { .op       = MM_COPY_SEGMENTS,
+                                              .u        =
+                                              { .copy_segments =
+                                                        from_mm->id.u.mm_fd } } );
+                i = os_write_file(new_mm->id.u.mm_fd, &copy, sizeof(copy));
+                if(i != sizeof(copy))
+                        printk("new_mm : /proc/mm copy_segments failed, "
+                               "err = %d\n", -i);
+        }
+
+        if(!ptrace_ldt) {
                 /* Our local LDT is used to supply the data for
                  * modify_ldt(READLDT), if PTRACE_LDT isn't available,
                  * i.e., we have to use the stub for modify_ldt, which
@@ -524,6 +545,7 @@ long init_new_ldt(struct mmu_context_skas * new_mm,
                 up(&from_mm->ldt.semaphore);
         }
 
+    out:
         return err;
 }
 
diff --git a/arch/um/sys-x86_64/ptrace_user.c b/arch/um/sys-x86_64/ptrace_user.c
index 12e404c6fa46..b5f9c33e311e 100644
--- a/arch/um/sys-x86_64/ptrace_user.c
+++ b/arch/um/sys-x86_64/ptrace_user.c
@@ -24,6 +24,13 @@ int ptrace_setregs(long pid, unsigned long *regs)
         return(0);
 }
 
+int ptrace_setfpregs(long pid, unsigned long *regs)
+{
+        if (ptrace(PTRACE_SETFPREGS, pid, 0, regs) < 0)
+                return -errno;
+        return 0;
+}
+
 void ptrace_pokeuser(unsigned long addr, unsigned long data)
 {
         panic("ptrace_pokeuser");
diff --git a/arch/um/sys-x86_64/user-offsets.c b/arch/um/sys-x86_64/user-offsets.c
index 5a585bfbb8c2..7bd54a921cf7 100644
--- a/arch/um/sys-x86_64/user-offsets.c
+++ b/arch/um/sys-x86_64/user-offsets.c
@@ -57,7 +57,7 @@ void foo(void)
 #endif
 
         DEFINE_LONGS(HOST_FRAME_SIZE, FRAME_SIZE);
-        DEFINE(HOST_FP_SIZE, 0);
+        DEFINE(HOST_FP_SIZE, sizeof(struct _fpstate) / sizeof(unsigned long));
         DEFINE(HOST_XFP_SIZE, 0);
         DEFINE_LONGS(HOST_RBX, RBX);
         DEFINE_LONGS(HOST_RCX, RCX);
diff --git a/arch/v850/kernel/simcons.c b/arch/v850/kernel/simcons.c
index 7f0efaa025c9..3975aa02cef8 100644
--- a/arch/v850/kernel/simcons.c
+++ b/arch/v850/kernel/simcons.c
@@ -117,6 +117,7 @@ late_initcall(simcons_tty_init);
    tty driver.  */
 void simcons_poll_tty (struct tty_struct *tty)
 {
+        char buf[32];   /* Not the nicest way to do it but I need it correct first */
         int flip = 0, send_break = 0;
         struct pollfd pfd;
         pfd.fd = 0;
@@ -124,21 +125,15 @@ void simcons_poll_tty (struct tty_struct *tty)
 
         if (V850_SIM_SYSCALL (poll, &pfd, 1, 0) > 0) {
                 if (pfd.revents & POLLIN) {
-                        int left = TTY_FLIPBUF_SIZE - tty->flip.count;
-
-                        if (left > 0) {
-                                unsigned char *buf = tty->flip.char_buf_ptr;
-                                int rd = V850_SIM_SYSCALL (read, 0, buf, left);
-
-                                if (rd > 0) {
-                                        tty->flip.count += rd;
-                                        tty->flip.char_buf_ptr += rd;
-                                        memset (tty->flip.flag_buf_ptr, 0, rd);
-                                        tty->flip.flag_buf_ptr += rd;
-                                        flip = 1;
-                                } else
-                                        send_break = 1;
-                        }
+                        /* Real block hardware knows the transfer size before
+                           transfer so the new tty buffering doesn't try to handle
+                           this rather weird simulator specific case well */
+                        int rd = V850_SIM_SYSCALL (read, 0, buf, 32);
+                        if (rd > 0) {
+                                tty_insert_flip_string(tty, buf, rd);
+                                flip = 1;
+                        } else
+                                send_break = 1;
                 } else if (pfd.revents & POLLERR)
                         send_break = 1;
         }
diff --git a/arch/x86_64/Kconfig.debug b/arch/x86_64/Kconfig.debug
index fcb06a50fdd2..ea31b4c62105 100644
--- a/arch/x86_64/Kconfig.debug
+++ b/arch/x86_64/Kconfig.debug
@@ -2,13 +2,6 @@ menu "Kernel hacking"
 
 source "lib/Kconfig.debug"
 
-config INIT_DEBUG
-        bool "Debug __init statements"
-        depends on DEBUG_KERNEL
-        help
-          Fill __init and __initdata at the end of boot. This helps debugging
-          illegal uses of __init and __initdata after initialization.
-
 config DEBUG_RODATA
        bool "Write protect kernel read-only data structures"
        depends on DEBUG_KERNEL
diff --git a/arch/x86_64/defconfig b/arch/x86_64/defconfig
index 5231fe83ea4b..56832929a543 100644
--- a/arch/x86_64/defconfig
+++ b/arch/x86_64/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.15-git12
-# Mon Jan 16 13:09:08 2006
+# Linux kernel version: 2.6.16-rc1-git2
+# Thu Jan 19 10:05:21 2006
 #
 CONFIG_X86_64=y
 CONFIG_64BIT=y
@@ -310,6 +310,11 @@ CONFIG_IPV6=y
 # SCTP Configuration (EXPERIMENTAL)
 #
 # CONFIG_IP_SCTP is not set
+
+#
+# TIPC Configuration (EXPERIMENTAL)
+#
+# CONFIG_TIPC is not set
 # CONFIG_ATM is not set
 # CONFIG_BRIDGE is not set
 # CONFIG_VLAN_8021Q is not set
@@ -319,11 +324,6 @@ CONFIG_IPV6=y
 # CONFIG_ATALK is not set
 # CONFIG_X25 is not set
 # CONFIG_LAPB is not set
-
-#
-# TIPC Configuration (EXPERIMENTAL)
-#
-# CONFIG_TIPC is not set
 # CONFIG_NET_DIVERT is not set
 # CONFIG_ECONET is not set
 # CONFIG_WAN_ROUTER is not set
@@ -646,6 +646,7 @@ CONFIG_8139TOO=y
 # CONFIG_DL2K is not set
 CONFIG_E1000=y
 # CONFIG_E1000_NAPI is not set
+# CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -1097,6 +1098,12 @@ CONFIG_USB_MON=y
 #
 
 #
+# EDAC - error detection and reporting (RAS)
+#
+# CONFIG_EDAC is not set
+# CONFIG_EDAC_POLL is not set
+
+#
 # Firmware Drivers
 #
 # CONFIG_EDD is not set
@@ -1289,6 +1296,7 @@ CONFIG_DEBUG_FS=y
 # CONFIG_DEBUG_VM is not set
 # CONFIG_FRAME_POINTER is not set
 # CONFIG_FORCED_INLINING is not set
+# CONFIG_UNWIND_INFO is not set
 # CONFIG_RCU_TORTURE_TEST is not set
 CONFIG_INIT_DEBUG=y
 # CONFIG_DEBUG_RODATA is not set
diff --git a/arch/x86_64/ia32/ia32entry.S b/arch/x86_64/ia32/ia32entry.S
index 58f5bfb52c63..00dee176c08e 100644
--- a/arch/x86_64/ia32/ia32entry.S
+++ b/arch/x86_64/ia32/ia32entry.S
@@ -672,6 +672,22 @@ ia32_sys_call_table:
         .quad sys_inotify_add_watch
         .quad sys_inotify_rm_watch
         .quad sys_migrate_pages
+        .quad compat_sys_openat         /* 295 */
+        .quad sys_mkdirat
+        .quad sys_mknodat
+        .quad sys_fchownat
+        .quad compat_sys_futimesat
+        .quad sys32_fstatat             /* 300 */
+        .quad sys_unlinkat
+        .quad sys_renameat
+        .quad sys_linkat
+        .quad sys_symlinkat
+        .quad sys_readlinkat            /* 305 */
+        .quad sys_fchmodat
+        .quad sys_faccessat
+        .quad sys_ni_syscall            /* pselect6 for now */
+        .quad sys_ni_syscall            /* ppoll for now */
+        .quad sys_unshare               /* 310 */
 ia32_syscall_end:               
         .rept IA32_NR_syscalls-(ia32_syscall_end-ia32_sys_call_table)/8
                 .quad ni_syscall
diff --git a/arch/x86_64/ia32/sys_ia32.c b/arch/x86_64/ia32/sys_ia32.c
index 54481af5344a..2bc55af95419 100644
--- a/arch/x86_64/ia32/sys_ia32.c
+++ b/arch/x86_64/ia32/sys_ia32.c
@@ -180,6 +180,28 @@ sys32_fstat64(unsigned int fd, struct stat64 __user *statbuf)
         return ret;
 }
 
+asmlinkage long
+sys32_fstatat(unsigned int dfd, char __user *filename,
+              struct stat64 __user* statbuf, int flag)
+{
+        struct kstat stat;
+        int error = -EINVAL;
+
+        if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
+                goto out;
+
+        if (flag & AT_SYMLINK_NOFOLLOW)
+                error = vfs_lstat_fd(dfd, filename, &stat);
+        else
+                error = vfs_stat_fd(dfd, filename, &stat);
+
+        if (!error)
+                error = cp_stat64(statbuf, &stat);
+
+out:
+        return error;
+}
+
 /*
  * Linux/i386 didn't use to be able to handle more than
  * 4 system call parameters, so these system calls used a memory
diff --git a/arch/x86_64/kernel/acpi/Makefile b/arch/x86_64/kernel/acpi/Makefile
index 7da9ace890bd..4fe97071f297 100644
--- a/arch/x86_64/kernel/acpi/Makefile
+++ b/arch/x86_64/kernel/acpi/Makefile
@@ -1,3 +1,8 @@
 obj-y                   := boot.o
 boot-y                  := ../../../i386/kernel/acpi/boot.o
 obj-$(CONFIG_ACPI_SLEEP)        += sleep.o wakeup.o
+
+ifneq ($(CONFIG_ACPI_PROCESSOR),)
+obj-y                   += processor.o
+endif
+
diff --git a/arch/x86_64/kernel/acpi/processor.c b/arch/x86_64/kernel/acpi/processor.c
new file mode 100644
index 000000000000..3bdc2baa5bb1
--- /dev/null
+++ b/arch/x86_64/kernel/acpi/processor.c
@@ -0,0 +1,72 @@
+/*
+ * arch/x86_64/kernel/acpi/processor.c
+ *
+ * Copyright (C) 2005 Intel Corporation
+ *      Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
+ *      - Added _PDC for platforms with Intel CPUs
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+
+#include <acpi/processor.h>
+#include <asm/acpi.h>
+
+static void init_intel_pdc(struct acpi_processor *pr, struct cpuinfo_x86 *c)
+{
+        struct acpi_object_list *obj_list;
+        union acpi_object *obj;
+        u32 *buf;
+
+        /* allocate and initialize pdc. It will be used later. */
+        obj_list = kmalloc(sizeof(struct acpi_object_list), GFP_KERNEL);
+        if (!obj_list) {
+                printk(KERN_ERR "Memory allocation error\n");
+                return;
+        }
+
+        obj = kmalloc(sizeof(union acpi_object), GFP_KERNEL);
+        if (!obj) {
+                printk(KERN_ERR "Memory allocation error\n");
+                kfree(obj_list);
+                return;
+        }
+
+        buf = kmalloc(12, GFP_KERNEL);
+        if (!buf) {
+                printk(KERN_ERR "Memory allocation error\n");
+                kfree(obj);
+                kfree(obj_list);
+                return;
+        }
+
+        buf[0] = ACPI_PDC_REVISION_ID;
+        buf[1] = 1;
+        buf[2] = ACPI_PDC_EST_CAPABILITY_SMP;
+
+        obj->type = ACPI_TYPE_BUFFER;
+        obj->buffer.length = 12;
+        obj->buffer.pointer = (u8 *) buf;
+        obj_list->count = 1;
+        obj_list->pointer = obj;
+        pr->pdc = obj_list;
+
+        return;
+}
+
+/* Initialize _PDC data based on the CPU vendor */
+void arch_acpi_processor_init_pdc(struct acpi_processor *pr)
+{
+        unsigned int cpu = pr->id;
+        struct cpuinfo_x86 *c = cpu_data + cpu;
+
+        pr->pdc = NULL;
+        if (c->x86_vendor == X86_VENDOR_INTEL && cpu_has(c, X86_FEATURE_EST))
+                init_intel_pdc(pr, c);
+
+        return;
+}
+
+EXPORT_SYMBOL(arch_acpi_processor_init_pdc);
diff --git a/arch/x86_64/kernel/apic.c b/arch/x86_64/kernel/apic.c
index 5d3c5b07b8db..7a0a3e8d5d72 100644
--- a/arch/x86_64/kernel/apic.c
+++ b/arch/x86_64/kernel/apic.c
@@ -35,8 +35,12 @@
 #include <asm/mach_apic.h>
 #include <asm/nmi.h>
 #include <asm/idle.h>
+#include <asm/proto.h>
+#include <asm/timex.h>
 
 int apic_verbosity;
+int apic_runs_main_timer;
+int apic_calibrate_pmtmr __initdata;
 
 int disable_apic_timer __initdata;
 
@@ -68,6 +72,26 @@ int get_maxlvt(void)
         return maxlvt;
 }
 
+/*
+ * 'what should we do if we get a hw irq event on an illegal vector'.
+ * each architecture has to answer this themselves.
+ */
+void ack_bad_irq(unsigned int irq)
+{
+        printk("unexpected IRQ trap at vector %02x\n", irq);
+        /*
+         * Currently unexpected vectors happen only on SMP and APIC.
+         * We _must_ ack these because every local APIC has only N
+         * irq slots per priority level, and a 'hanging, unacked' IRQ
+         * holds up an irq slot - in excessive cases (when multiple
+         * unexpected vectors occur) that might lock up the APIC
+         * completely.
+         * But don't ack when the APIC is disabled. -AK
+         */
+        if (!disable_apic)
+                ack_APIC_irq();
+}
+
 void clear_local_APIC(void)
 {
         int maxlvt;
@@ -684,7 +708,7 @@ static void setup_APIC_timer(unsigned int clocks)
         local_irq_save(flags);
 
         /* wait for irq slice */
-        if (vxtime.hpet_address) {
+        if (vxtime.hpet_address && hpet_use_timer) {
                 int trigger = hpet_readl(HPET_T0_CMP);
                 while (hpet_readl(HPET_COUNTER) >= trigger)
                         /* do nothing */ ;
@@ -702,9 +726,17 @@ static void setup_APIC_timer(unsigned int clocks)
                         c2 |= inb_p(0x40) << 8;
                 } while (c2 - c1 < 300);
         }
-
         __setup_APIC_LVTT(clocks);
-
+        /* Turn off PIT interrupt if we use APIC timer as main timer.
+           Only works with the PM timer right now
+           TBD fix it for HPET too. */
+        if (vxtime.mode == VXTIME_PMTMR &&
+                smp_processor_id() == boot_cpu_id &&
+                apic_runs_main_timer == 1 &&
+                !cpu_isset(boot_cpu_id, timer_interrupt_broadcast_ipi_mask)) {
+                stop_timer_interrupt();
+                apic_runs_main_timer++;
+        }
         local_irq_restore(flags);
 }
 
@@ -735,14 +767,27 @@ static int __init calibrate_APIC_clock(void)
         __setup_APIC_LVTT(1000000000);
 
         apic_start = apic_read(APIC_TMCCT);
-        rdtscl(tsc_start);
-
-        do {
+#ifdef CONFIG_X86_PM_TIMER
+        if (apic_calibrate_pmtmr && pmtmr_ioport) {
+                pmtimer_wait(5000);  /* 5ms wait */
                 apic = apic_read(APIC_TMCCT);
-                rdtscl(tsc);
-        } while ((tsc - tsc_start) < TICK_COUNT && (apic - apic_start) < TICK_COUNT);
+                result = (apic_start - apic) * 1000L / 5;
+        } else
+#endif
+        {
+                rdtscl(tsc_start);
+
+                do {
+                        apic = apic_read(APIC_TMCCT);
+                        rdtscl(tsc);
+                } while ((tsc - tsc_start) < TICK_COUNT &&
+                                (apic - apic_start) < TICK_COUNT);
+
+                result = (apic_start - apic) * 1000L * cpu_khz /
+                                        (tsc - tsc_start);
+        }
+        printk("result %d\n", result);
 
-        result = (apic_start - apic) * 1000L * cpu_khz / (tsc - tsc_start);
 
         printk(KERN_INFO "Detected %d.%03d MHz APIC timer.\n",
                 result / 1000 / 1000, result / 1000 % 1000);
@@ -872,6 +917,8 @@ void smp_local_timer_interrupt(struct pt_regs *regs)
 #ifdef CONFIG_SMP
         update_process_times(user_mode(regs));
 #endif
+        if (apic_runs_main_timer > 1 && smp_processor_id() == boot_cpu_id)
+                main_timer_handler(regs);
         /*
          * We take the 'long' return path, and there every subsystem
          * grabs the appropriate locks (kernel lock/ irq lock).
@@ -924,7 +971,7 @@ void smp_apic_timer_interrupt(struct pt_regs *regs)
  * multi-chassis. Use available data to take a good guess.
  * If in doubt, go HPET.
  */
-__init int oem_force_hpet_timer(void)
+__cpuinit int oem_force_hpet_timer(void)
 {
         int i, clusters, zeros;
         unsigned id;
@@ -1081,10 +1128,34 @@ static __init int setup_nolapic(char *str)
 
 static __init int setup_noapictimer(char *str) 
 { 
+        if (str[0] != ' ' && str[0] != 0)
+                return -1;
         disable_apic_timer = 1;
         return 0;
 } 
 
+static __init int setup_apicmaintimer(char *str)
+{
+        apic_runs_main_timer = 1;
+        nohpet = 1;
+        return 0;
+}
+__setup("apicmaintimer", setup_apicmaintimer);
+
+static __init int setup_noapicmaintimer(char *str)
+{
+        apic_runs_main_timer = -1;
+        return 0;
+}
+__setup("noapicmaintimer", setup_noapicmaintimer);
+
+static __init int setup_apicpmtimer(char *s)
+{
+        apic_calibrate_pmtmr = 1;
+        return setup_apicmaintimer(NULL);
+}
+__setup("apicpmtimer", setup_apicpmtimer);
+
 /* dummy parsing: see setup.c */
 
 __setup("disableapic", setup_disableapic); 
diff --git a/arch/x86_64/kernel/entry.S b/arch/x86_64/kernel/entry.S
index dbdba56e8faa..b150c87a08c6 100644
--- a/arch/x86_64/kernel/entry.S
+++ b/arch/x86_64/kernel/entry.S
@@ -499,7 +499,9 @@ ENTRY(stub_rt_sigreturn)
         movq %gs:pda_irqstackptr,%rax
         cmoveq %rax,%rsp /*todo This needs CFI annotation! */
         pushq %rdi                      # save old stack        
+#ifndef CONFIG_DEBUG_INFO
         CFI_ADJUST_CFA_OFFSET   8
+#endif
         call \func
         .endm
 
@@ -509,7 +511,9 @@ ENTRY(common_interrupt)
         /* 0(%rsp): oldrsp-ARGOFFSET */
 ret_from_intr:
         popq  %rdi
+#ifndef CONFIG_DEBUG_INFO
         CFI_ADJUST_CFA_OFFSET   -8
+#endif
         cli     
         decl %gs:pda_irqcount
 #ifdef CONFIG_DEBUG_INFO
@@ -922,7 +926,7 @@ KPROBE_ENTRY(debug)
         .previous .text
 
         /* runs on exception stack */   
-ENTRY(nmi)
+KPROBE_ENTRY(nmi)
         INTR_FRAME
         pushq $-1
         CFI_ADJUST_CFA_OFFSET 8
@@ -969,6 +973,7 @@ paranoid_schedule:
         cli
         jmp paranoid_userspace
         CFI_ENDPROC
+        .previous .text
 
 KPROBE_ENTRY(int3)
         INTR_FRAME
diff --git a/arch/x86_64/kernel/io_apic.c b/arch/x86_64/kernel/io_apic.c
index e8cf44ef8778..4282d72b2a26 100644
--- a/arch/x86_64/kernel/io_apic.c
+++ b/arch/x86_64/kernel/io_apic.c
@@ -304,6 +304,14 @@ void __init check_ioapic(void)
 #endif
                                         /* RED-PEN skip them on mptables too? */
                                         return;
+                                case PCI_VENDOR_ID_ATI:
+                                        if (apic_runs_main_timer != 0)
+                                                break;
+                                        printk(KERN_INFO
+             "ATI board detected. Using APIC/PM timer.\n");
+                                        apic_runs_main_timer = 1;
+                                        nohpet = 1;
+                                        return;
                                 } 
 
                                 /* No multi-function device? */
@@ -2027,7 +2035,7 @@ int __init io_apic_get_redir_entries (int ioapic)
 }
 
 
-int io_apic_set_pci_routing (int ioapic, int pin, int irq, int edge_level, int active_high_low)
+int io_apic_set_pci_routing (int ioapic, int pin, int irq, int triggering, int polarity)
 {
         struct IO_APIC_route_entry entry;
         unsigned long flags;
@@ -2049,8 +2057,8 @@ int io_apic_set_pci_routing (int ioapic, int pin, int irq, int edge_level, int a
         entry.delivery_mode = INT_DELIVERY_MODE;
         entry.dest_mode = INT_DEST_MODE;
         entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS);
-        entry.trigger = edge_level;
-        entry.polarity = active_high_low;
+        entry.trigger = triggering;
+        entry.polarity = polarity;
         entry.mask = 1;                                  /* Disabled (masked) */
 
         irq = gsi_irq_sharing(irq);
@@ -2065,9 +2073,9 @@ int io_apic_set_pci_routing (int ioapic, int pin, int irq, int edge_level, int a
         apic_printk(APIC_VERBOSE,KERN_DEBUG "IOAPIC[%d]: Set PCI routing entry (%d-%d -> 0x%x -> "
                 "IRQ %d Mode:%i Active:%i)\n", ioapic, 
                mp_ioapics[ioapic].mpc_apicid, pin, entry.vector, irq,
-               edge_level, active_high_low);
+               triggering, polarity);
 
-        ioapic_register_intr(irq, entry.vector, edge_level);
+        ioapic_register_intr(irq, entry.vector, triggering);
 
         if (!ioapic && (irq < 16))
                 disable_8259A_irq(irq);
diff --git a/arch/x86_64/kernel/mce.c b/arch/x86_64/kernel/mce.c
index 13a2eada6c95..b8b9529fa89e 100644
--- a/arch/x86_64/kernel/mce.c
+++ b/arch/x86_64/kernel/mce.c
@@ -380,7 +380,7 @@ static void __cpuinit mce_cpu_features(struct cpuinfo_x86 *c)
  */
 void __cpuinit mcheck_init(struct cpuinfo_x86 *c)
 {
-        static cpumask_t mce_cpus __initdata = CPU_MASK_NONE;
+        static cpumask_t mce_cpus = CPU_MASK_NONE;
 
         mce_cpu_quirks(c); 
 
diff --git a/arch/x86_64/kernel/mpparse.c b/arch/x86_64/kernel/mpparse.c
index 1105250bf02c..dc49bfb6db0a 100644
--- a/arch/x86_64/kernel/mpparse.c
+++ b/arch/x86_64/kernel/mpparse.c
@@ -915,7 +915,7 @@ void __init mp_config_acpi_legacy_irqs (void)
 
 #define MAX_GSI_NUM     4096
 
-int mp_register_gsi(u32 gsi, int edge_level, int active_high_low)
+int mp_register_gsi(u32 gsi, int triggering, int polarity)
 {
         int                     ioapic = -1;
         int                     ioapic_pin = 0;
@@ -964,7 +964,7 @@ int mp_register_gsi(u32 gsi, int edge_level, int active_high_low)
 
         mp_ioapic_routing[ioapic].pin_programmed[idx] |= (1<<bit);
 
-        if (edge_level) {
+        if (triggering == ACPI_LEVEL_SENSITIVE) {
                 /*
                  * For PCI devices assign IRQs in order, avoiding gaps
                  * due to unused I/O APIC pins.
@@ -986,8 +986,8 @@ int mp_register_gsi(u32 gsi, int edge_level, int active_high_low)
         }
 
         io_apic_set_pci_routing(ioapic, ioapic_pin, gsi,
-                edge_level == ACPI_EDGE_SENSITIVE ? 0 : 1,
-                active_high_low == ACPI_ACTIVE_HIGH ? 0 : 1);
+                triggering == ACPI_EDGE_SENSITIVE ? 0 : 1,
+                polarity == ACPI_ACTIVE_HIGH ? 0 : 1);
         return gsi;
 }
 
diff --git a/arch/x86_64/kernel/nmi.c b/arch/x86_64/kernel/nmi.c
index 5fae6f0cd994..8be407a1f62d 100644
--- a/arch/x86_64/kernel/nmi.c
+++ b/arch/x86_64/kernel/nmi.c
@@ -24,6 +24,7 @@
 #include <linux/sysdev.h>
 #include <linux/nmi.h>
 #include <linux/sysctl.h>
+#include <linux/kprobes.h>
 
 #include <asm/smp.h>
 #include <asm/mtrr.h>
@@ -468,7 +469,7 @@ void touch_nmi_watchdog (void)
         touch_softlockup_watchdog();
 }
 
-void nmi_watchdog_tick (struct pt_regs * regs, unsigned reason)
+void __kprobes nmi_watchdog_tick(struct pt_regs * regs, unsigned reason)
 {
         int sum;
         int touched = 0;
@@ -512,14 +513,14 @@ void nmi_watchdog_tick (struct pt_regs * regs, unsigned reason)
         }
 }
 
-static int dummy_nmi_callback(struct pt_regs * regs, int cpu)
+static __kprobes int dummy_nmi_callback(struct pt_regs * regs, int cpu)
 {
         return 0;
 }
  
 static nmi_callback_t nmi_callback = dummy_nmi_callback;
  
-asmlinkage void do_nmi(struct pt_regs * regs, long error_code)
+asmlinkage __kprobes void do_nmi(struct pt_regs * regs, long error_code)
 {
         int cpu = safe_smp_processor_id();
 
diff --git a/arch/x86_64/kernel/pci-dma.c b/arch/x86_64/kernel/pci-dma.c
index 2f5d8328e2b9..4ed391edd47a 100644
--- a/arch/x86_64/kernel/pci-dma.c
+++ b/arch/x86_64/kernel/pci-dma.c
@@ -107,6 +107,9 @@ dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
                                 goto again;
                         }
 
+                        /* Let low level make its own zone decisions */
+                        gfp &= ~(GFP_DMA32|GFP_DMA);
+
                         if (dma_ops->alloc_coherent)
                                 return dma_ops->alloc_coherent(dev, size,
                                                            dma_handle, gfp);
diff --git a/arch/x86_64/kernel/pci-gart.c b/arch/x86_64/kernel/pci-gart.c
index c37fc7726ba6..dd0718dc178b 100644
--- a/arch/x86_64/kernel/pci-gart.c
+++ b/arch/x86_64/kernel/pci-gart.c
@@ -310,7 +310,7 @@ void gart_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, int di
 
         for (i = 0; i < nents; i++) {
                 struct scatterlist *s = &sg[i];
-                if (!s->dma_length || !s->length)
+                if (!s->dma_length)
                         break;
                 dma_unmap_single(dev, s->dma_address, s->dma_length, dir);
         }
@@ -364,7 +364,6 @@ static int __dma_map_cont(struct scatterlist *sg, int start, int stopat,
                 
                 BUG_ON(i > start && s->offset);
                 if (i == start) {
-                        *sout = *s; 
                         sout->dma_address = iommu_bus_base;
                         sout->dma_address += iommu_page*PAGE_SIZE + s->offset;
                         sout->dma_length = s->length;
@@ -379,7 +378,7 @@ static int __dma_map_cont(struct scatterlist *sg, int start, int stopat,
                         SET_LEAK(iommu_page);
                         addr += PAGE_SIZE;
                         iommu_page++;
-        } 
+                }
         } 
         BUG_ON(iommu_page - iommu_start != pages);      
         return 0;
@@ -391,7 +390,6 @@ static inline int dma_map_cont(struct scatterlist *sg, int start, int stopat,
 {
         if (!need) { 
                 BUG_ON(stopat - start != 1);
-                *sout = sg[start]; 
                 sout->dma_length = sg[start].length; 
                 return 0;
         } 
@@ -457,9 +455,12 @@ int gart_map_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
 error:
         flush_gart(NULL);
         gart_unmap_sg(dev, sg, nents, dir);
-        /* When it was forced try again unforced */
-        if (force_iommu) 
-                return dma_map_sg_nonforce(dev, sg, nents, dir);
+        /* When it was forced or merged try again in a dumb way */
+        if (force_iommu || iommu_merge) {
+                out = dma_map_sg_nonforce(dev, sg, nents, dir);
+                if (out > 0)
+                        return out;
+        }
         if (panic_on_overflow)
                 panic("dma_map_sg: overflow on %lu pages\n", pages);
         iommu_full(dev, pages << PAGE_SHIFT, dir);
@@ -642,9 +643,18 @@ static int __init pci_iommu_init(void)
             (no_agp && init_k8_gatt(&info) < 0)) {
                 no_iommu = 1;
                 no_iommu_init();
+                printk(KERN_INFO "PCI-DMA: Disabling IOMMU.\n");
+                if (end_pfn > MAX_DMA32_PFN) {
+                        printk(KERN_ERR "WARNING more than 4GB of memory "
+                                        "but IOMMU not compiled in.\n"
+                               KERN_ERR "WARNING 32bit PCI may malfunction.\n"
+                               KERN_ERR "You might want to enable "
+                                        "CONFIG_GART_IOMMU\n");
+                }
                 return -1;
         }
 
+        printk(KERN_INFO "PCI-DMA: using GART IOMMU.\n");
         aper_size = info.aper_size * 1024 * 1024;       
         iommu_size = check_iommu_size(info.aper_base, aper_size); 
         iommu_pages = iommu_size >> PAGE_SHIFT; 
@@ -718,7 +728,6 @@ static int __init pci_iommu_init(void)
                      
         flush_gart(NULL);
 
-        printk(KERN_INFO "PCI-DMA: using GART IOMMU.\n");
         dma_ops = &gart_dma_ops;
 
         return 0;
diff --git a/arch/x86_64/kernel/pci-nommu.c b/arch/x86_64/kernel/pci-nommu.c
index e41564975195..44adcc2d5e5b 100644
--- a/arch/x86_64/kernel/pci-nommu.c
+++ b/arch/x86_64/kernel/pci-nommu.c
@@ -88,12 +88,5 @@ void __init no_iommu_init(void)
 {
         if (dma_ops)
                 return;
-        printk(KERN_INFO "PCI-DMA: Disabling IOMMU.\n");
         dma_ops = &nommu_dma_ops;
-        if (end_pfn > MAX_DMA32_PFN) {
-                printk(KERN_ERR
-                       "WARNING more than 4GB of memory but IOMMU not compiled in.\n"
-                       KERN_ERR "WARNING 32bit PCI may malfunction.\n"
-                       KERN_ERR "You might want to enable CONFIG_GART_IOMMU\n");
-        }
 }
diff --git a/arch/x86_64/kernel/pci-swiotlb.c b/arch/x86_64/kernel/pci-swiotlb.c
index 3569a25ad7fb..990ed67896f2 100644
--- a/arch/x86_64/kernel/pci-swiotlb.c
+++ b/arch/x86_64/kernel/pci-swiotlb.c
@@ -35,8 +35,8 @@ void pci_swiotlb_init(void)
             (end_pfn > MAX_DMA32_PFN || force_iommu))
                swiotlb = 1;
         if (swiotlb) {
-                swiotlb_init();
                 printk(KERN_INFO "PCI-DMA: Using software bounce buffering for IO (SWIOTLB)\n");
+                swiotlb_init();
                 dma_ops = &swiotlb_dma_ops;
         }
 }
diff --git a/arch/x86_64/kernel/pmtimer.c b/arch/x86_64/kernel/pmtimer.c
index feb5f108dd26..5c51d10408a6 100644
--- a/arch/x86_64/kernel/pmtimer.c
+++ b/arch/x86_64/kernel/pmtimer.c
@@ -80,6 +80,31 @@ int pmtimer_mark_offset(void)
         return lost - 1;
 }
 
+static unsigned pmtimer_wait_tick(void)
+{
+        u32 a, b;
+        for (a = b = inl(pmtmr_ioport) & ACPI_PM_MASK;
+             a == b;
+             b = inl(pmtmr_ioport) & ACPI_PM_MASK)
+                ;
+        return b;
+}
+
+/* note: wait time is rounded up to one tick */
+void pmtimer_wait(unsigned us)
+{
+        u32 a, b;
+        a = pmtimer_wait_tick();
+        do {
+                b = inl(pmtmr_ioport);
+        } while (cyc2us(b - a) < us);
+}
+
+void pmtimer_resume(void)
+{
+        last_pmtmr_tick = inl(pmtmr_ioport);
+}
+
 unsigned int do_gettimeoffset_pm(void)
 {
         u32 now, offset, delta = 0;
diff --git a/arch/x86_64/kernel/process.c b/arch/x86_64/kernel/process.c
index 8ded407e4a94..22a05dec81a2 100644
--- a/arch/x86_64/kernel/process.c
+++ b/arch/x86_64/kernel/process.c
@@ -516,8 +516,10 @@ out:
  * This could still be optimized: 
  * - fold all the options into a flag word and test it with a single test.
  * - could test fs/gs bitsliced
+ *
+ * Kprobes not supported here. Set the probe on schedule instead.
  */
-struct task_struct *
+__kprobes struct task_struct *
 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 {
         struct thread_struct *prev = &prev_p->thread,
diff --git a/arch/x86_64/kernel/setup.c b/arch/x86_64/kernel/setup.c
index 28895c03cb11..9435ab7d6fb8 100644
--- a/arch/x86_64/kernel/setup.c
+++ b/arch/x86_64/kernel/setup.c
@@ -94,7 +94,6 @@ unsigned long saved_video_mode;
 /*
  * Setup options
  */
-struct drive_info_struct { char dummy[32]; } drive_info;
 struct screen_info screen_info;
 struct sys_desc_table_struct {
         unsigned short length;
@@ -572,7 +571,6 @@ void __init setup_arch(char **cmdline_p)
         unsigned long kernel_end;
 
         ROOT_DEV = old_decode_dev(ORIG_ROOT_DEV);
-        drive_info = DRIVE_INFO;
         screen_info = SCREEN_INFO;
         edid_info = EDID_INFO;
         saved_video_mode = SAVED_VIDEO_MODE;
@@ -741,7 +739,7 @@ void __init setup_arch(char **cmdline_p)
         e820_setup_gap();
 
 #ifdef CONFIG_GART_IOMMU
-       iommu_hole_init();
+        iommu_hole_init();
 #endif
 
 #ifdef CONFIG_VT
@@ -877,6 +875,7 @@ static void __init amd_detect_cmp(struct cpuinfo_x86 *c)
 static int __init init_amd(struct cpuinfo_x86 *c)
 {
         int r;
+        unsigned level;
 
 #ifdef CONFIG_SMP
         unsigned long value;
@@ -899,6 +898,11 @@ static int __init init_amd(struct cpuinfo_x86 *c)
            3DNow is IDd by bit 31 in extended CPUID (1*32+31) anyway */
         clear_bit(0*32+31, &c->x86_capability);
         
+        /* On C+ stepping K8 rep microcode works well for copy/memset */
+        level = cpuid_eax(1);
+        if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58))
+                set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
+
         r = get_model_name(c);
         if (!r) { 
                 switch (c->x86) { 
diff --git a/arch/x86_64/kernel/setup64.c b/arch/x86_64/kernel/setup64.c
index 8ac4db09610a..70f1bb808a20 100644
--- a/arch/x86_64/kernel/setup64.c
+++ b/arch/x86_64/kernel/setup64.c
@@ -146,7 +146,7 @@ void pda_init(int cpu)
         pda->irqstackptr += IRQSTACKSIZE-64;
 } 
 
-char boot_exception_stacks[(N_EXCEPTION_STACKS - 2) * EXCEPTION_STKSZ + DEBUG_STKSZ]
+char boot_exception_stacks[(N_EXCEPTION_STACKS - 1) * EXCEPTION_STKSZ + DEBUG_STKSZ]
 __attribute__((section(".bss.page_aligned")));
 
 /* May not be marked __init: used by software suspend */
diff --git a/arch/x86_64/kernel/smpboot.c b/arch/x86_64/kernel/smpboot.c
index a28756ef7cef..67e4e28f4df8 100644
--- a/arch/x86_64/kernel/smpboot.c
+++ b/arch/x86_64/kernel/smpboot.c
@@ -59,6 +59,7 @@
 #include <asm/nmi.h>
 #include <asm/irq.h>
 #include <asm/hw_irq.h>
+#include <asm/numa.h>
 
 /* Number of siblings per CPU package */
 int smp_num_siblings = 1;
@@ -890,6 +891,7 @@ do_rest:
         if (boot_error) {
                 cpu_clear(cpu, cpu_callout_map); /* was set here (do_boot_cpu()) */
                 clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
+                clear_node_cpumask(cpu); /* was set by numa_add_cpu */
                 cpu_clear(cpu, cpu_present_map);
                 cpu_clear(cpu, cpu_possible_map);
                 x86_cpu_to_apicid[cpu] = BAD_APICID;
@@ -1187,6 +1189,7 @@ void remove_cpu_from_maps(void)
         cpu_clear(cpu, cpu_callout_map);
         cpu_clear(cpu, cpu_callin_map);
         clear_bit(cpu, &cpu_initialized); /* was set by cpu_init() */
+        clear_node_cpumask(cpu);
 }
 
 int __cpu_disable(void)
diff --git a/arch/x86_64/kernel/time.c b/arch/x86_64/kernel/time.c
index f8c47c688443..3c58c30506a1 100644
--- a/arch/x86_64/kernel/time.c
+++ b/arch/x86_64/kernel/time.c
@@ -51,7 +51,7 @@ extern int using_apic_timer;
 DEFINE_SPINLOCK(rtc_lock);
 DEFINE_SPINLOCK(i8253_lock);
 
-static int nohpet __initdata = 0;
+int nohpet __initdata = 0;
 static int notsc __initdata = 0;
 
 #undef HPET_HACK_ENABLE_DANGEROUS
@@ -59,7 +59,7 @@ static int notsc __initdata = 0;
 unsigned int cpu_khz;                                   /* TSC clocks / usec, not used here */
 static unsigned long hpet_period;                       /* fsecs / HPET clock */
 unsigned long hpet_tick;                                /* HPET clocks / interrupt */
-static int hpet_use_timer;                              /* Use counter of hpet for time keeping, otherwise PIT */
+int hpet_use_timer;                             /* Use counter of hpet for time keeping, otherwise PIT */
 unsigned long vxtime_hz = PIT_TICK_RATE;
 int report_lost_ticks;                          /* command line option */
 unsigned long long monotonic_base;
@@ -326,7 +326,10 @@ static noinline void handle_lost_ticks(int lost, struct pt_regs *regs)
             print_symbol("rip %s\n", regs->rip);
             if (vxtime.mode == VXTIME_TSC && vxtime.hpet_address) {
                     printk(KERN_WARNING "Falling back to HPET\n");
-                    vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
+                    if (hpet_use_timer)
+                        vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
+                    else
+                        vxtime.last = hpet_readl(HPET_COUNTER);
                     vxtime.mode = VXTIME_HPET;
                     do_gettimeoffset = do_gettimeoffset_hpet;
             }
@@ -345,7 +348,7 @@ static noinline void handle_lost_ticks(int lost, struct pt_regs *regs)
 #endif
 }
 
-static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+void main_timer_handler(struct pt_regs *regs)
 {
         static unsigned long rtc_update = 0;
         unsigned long tsc;
@@ -458,12 +461,17 @@ static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         }
  
         write_sequnlock(&xtime_lock);
+}
 
+static irqreturn_t timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        if (apic_runs_main_timer > 1)
+                return IRQ_HANDLED;
+        main_timer_handler(regs);
 #ifdef CONFIG_X86_LOCAL_APIC
         if (using_apic_timer)
                 smp_send_timer_broadcast_ipi();
 #endif
-
         return IRQ_HANDLED;
 }
 
@@ -743,7 +751,7 @@ static __init int late_hpet_init(void)
          * Timer0 and Timer1 is used by platform.
          */
         hd.hd_phys_address = vxtime.hpet_address;
-        hd.hd_address = (void *)fix_to_virt(FIX_HPET_BASE);
+        hd.hd_address = (void __iomem *)fix_to_virt(FIX_HPET_BASE);
         hd.hd_nirqs = ntimer;
         hd.hd_flags = HPET_DATA_PLATFORM;
         hpet_reserve_timer(&hd, 0);
@@ -843,17 +851,43 @@ static int hpet_reenable(void)
         return hpet_timer_stop_set_go(hpet_tick);
 }
 
-void __init pit_init(void)
+#define PIT_MODE 0x43
+#define PIT_CH0  0x40
+
+static void __init __pit_init(int val, u8 mode)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&i8253_lock, flags);
-        outb_p(0x34, 0x43);             /* binary, mode 2, LSB/MSB, ch 0 */
-        outb_p(LATCH & 0xff, 0x40);     /* LSB */
-        outb_p(LATCH >> 8, 0x40);       /* MSB */
+        outb_p(mode, PIT_MODE);
+        outb_p(val & 0xff, PIT_CH0);    /* LSB */
+        outb_p(val >> 8, PIT_CH0);      /* MSB */
         spin_unlock_irqrestore(&i8253_lock, flags);
 }
 
+void __init pit_init(void)
+{
+        __pit_init(LATCH, 0x34); /* binary, mode 2, LSB/MSB, ch 0 */
+}
+
+void __init pit_stop_interrupt(void)
+{
+        __pit_init(0, 0x30); /* mode 0 */
+}
+
+void __init stop_timer_interrupt(void)
+{
+        char *name;
+        if (vxtime.hpet_address) {
+                name = "HPET";
+                hpet_timer_stop_set_go(0);
+        } else {
+                name = "PIT";
+                pit_stop_interrupt();
+        }
+        printk(KERN_INFO "timer: %s interrupt stopped.\n", name);
+}
+
 int __init time_setup(char *str)
 {
         report_lost_ticks = 1;
@@ -932,7 +966,7 @@ void __init time_init(void)
  * Make an educated guess if the TSC is trustworthy and synchronized
  * over all CPUs.
  */
-__init int unsynchronized_tsc(void)
+__cpuinit int unsynchronized_tsc(void)
 {
 #ifdef CONFIG_SMP
         if (oem_force_hpet_timer())
@@ -957,7 +991,10 @@ void __init time_init_gtod(void)
                 notsc = 1;
         if (vxtime.hpet_address && notsc) {
                 timetype = hpet_use_timer ? "HPET" : "PIT/HPET";
-                vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
+                if (hpet_use_timer)
+                        vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
+                else
+                        vxtime.last = hpet_readl(HPET_COUNTER);
                 vxtime.mode = VXTIME_HPET;
                 do_gettimeoffset = do_gettimeoffset_hpet;
 #ifdef CONFIG_X86_PM_TIMER
@@ -1016,9 +1053,21 @@ static int timer_resume(struct sys_device *dev)
         write_seqlock_irqsave(&xtime_lock,flags);
         xtime.tv_sec = sec;
         xtime.tv_nsec = 0;
+        if (vxtime.mode == VXTIME_HPET) {
+                if (hpet_use_timer)
+                        vxtime.last = hpet_readl(HPET_T0_CMP) - hpet_tick;
+                else
+                        vxtime.last = hpet_readl(HPET_COUNTER);
+#ifdef CONFIG_X86_PM_TIMER
+        } else if (vxtime.mode == VXTIME_PMTMR) {
+                pmtimer_resume();
+#endif
+        } else
+                vxtime.last_tsc = get_cycles_sync();
         write_sequnlock_irqrestore(&xtime_lock,flags);
         jiffies += sleep_length;
         wall_jiffies += sleep_length;
+        monotonic_base += sleep_length * (NSEC_PER_SEC/HZ);
         touch_softlockup_watchdog();
         return 0;
 }
diff --git a/arch/x86_64/kernel/traps.c b/arch/x86_64/kernel/traps.c
index 8bb0aeda78b9..28d50dc540e8 100644
--- a/arch/x86_64/kernel/traps.c
+++ b/arch/x86_64/kernel/traps.c
@@ -90,6 +90,20 @@ static inline void conditional_sti(struct pt_regs *regs)
                 local_irq_enable();
 }
 
+static inline void preempt_conditional_sti(struct pt_regs *regs)
+{
+        preempt_disable();
+        if (regs->eflags & X86_EFLAGS_IF)
+                local_irq_enable();
+}
+
+static inline void preempt_conditional_cli(struct pt_regs *regs)
+{
+        if (regs->eflags & X86_EFLAGS_IF)
+                local_irq_disable();
+        preempt_enable_no_resched();
+}
+
 static int kstack_depth_to_print = 10;
 
 #ifdef CONFIG_KALLSYMS
@@ -372,7 +386,7 @@ void out_of_line_bug(void)
 static DEFINE_SPINLOCK(die_lock);
 static int die_owner = -1;
 
-unsigned long oops_begin(void)
+unsigned __kprobes long oops_begin(void)
 {
         int cpu = safe_smp_processor_id();
         unsigned long flags;
@@ -391,7 +405,7 @@ unsigned long oops_begin(void)
         return flags;
 }
 
-void oops_end(unsigned long flags)
+void __kprobes oops_end(unsigned long flags)
 { 
         die_owner = -1;
         bust_spinlocks(0);
@@ -400,7 +414,7 @@ void oops_end(unsigned long flags)
                 panic("Oops");
 }
 
-void __die(const char * str, struct pt_regs * regs, long err)
+void __kprobes __die(const char * str, struct pt_regs * regs, long err)
 {
         static int die_counter;
         printk(KERN_EMERG "%s: %04lx [%u] ", str, err & 0xffff,++die_counter);
@@ -432,7 +446,7 @@ void die(const char * str, struct pt_regs * regs, long err)
         do_exit(SIGSEGV); 
 }
 
-void die_nmi(char *str, struct pt_regs *regs)
+void __kprobes die_nmi(char *str, struct pt_regs *regs)
 {
         unsigned long flags = oops_begin();
 
@@ -575,7 +589,8 @@ asmlinkage void __kprobes do_general_protection(struct pt_regs * regs,
         }
 }
 
-static void mem_parity_error(unsigned char reason, struct pt_regs * regs)
+static __kprobes void
+mem_parity_error(unsigned char reason, struct pt_regs * regs)
 {
         printk("Uhhuh. NMI received. Dazed and confused, but trying to continue\n");
         printk("You probably have a hardware problem with your RAM chips\n");
@@ -585,7 +600,8 @@ static void mem_parity_error(unsigned char reason, struct pt_regs * regs)
         outb(reason, 0x61);
 }
 
-static void io_check_error(unsigned char reason, struct pt_regs * regs)
+static __kprobes void
+io_check_error(unsigned char reason, struct pt_regs * regs)
 {
         printk("NMI: IOCK error (debug interrupt?)\n");
         show_registers(regs);
@@ -598,7 +614,8 @@ static void io_check_error(unsigned char reason, struct pt_regs * regs)
         outb(reason, 0x61);
 }
 
-static void unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
+static __kprobes void
+unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
 {       printk("Uhhuh. NMI received for unknown reason %02x.\n", reason);
         printk("Dazed and confused, but trying to continue\n");
         printk("Do you have a strange power saving mode enabled?\n");
@@ -606,7 +623,7 @@ static void unknown_nmi_error(unsigned char reason, struct pt_regs * regs)
 
 /* Runs on IST stack. This code must keep interrupts off all the time.
    Nested NMIs are prevented by the CPU. */
-asmlinkage void default_do_nmi(struct pt_regs *regs)
+asmlinkage __kprobes void default_do_nmi(struct pt_regs *regs)
 {
         unsigned char reason = 0;
         int cpu;
@@ -658,7 +675,7 @@ asmlinkage void __kprobes do_int3(struct pt_regs * regs, long error_code)
 /* Help handler running on IST stack to switch back to user stack
    for scheduling or signal handling. The actual stack switch is done in
    entry.S */
-asmlinkage struct pt_regs *sync_regs(struct pt_regs *eregs)
+asmlinkage __kprobes struct pt_regs *sync_regs(struct pt_regs *eregs)
 {
         struct pt_regs *regs = eregs;
         /* Did already sync */
@@ -690,7 +707,7 @@ asmlinkage void __kprobes do_debug(struct pt_regs * regs,
                                                 SIGTRAP) == NOTIFY_STOP)
                 return;
 
-        conditional_sti(regs);
+        preempt_conditional_sti(regs);
 
         /* Mask out spurious debug traps due to lazy DR7 setting */
         if (condition & (DR_TRAP0|DR_TRAP1|DR_TRAP2|DR_TRAP3)) {
@@ -735,11 +752,13 @@ asmlinkage void __kprobes do_debug(struct pt_regs * regs,
 
 clear_dr7:
         set_debugreg(0UL, 7);
+        preempt_conditional_cli(regs);
         return;
 
 clear_TF_reenable:
         set_tsk_thread_flag(tsk, TIF_SINGLESTEP);
         regs->eflags &= ~TF_MASK;
+        preempt_conditional_cli(regs);
 }
 
 static int kernel_math_error(struct pt_regs *regs, const char *str, int trapnr)
diff --git a/arch/x86_64/kernel/vmlinux.lds.S b/arch/x86_64/kernel/vmlinux.lds.S
index b0eed1faf740..74db0062d4a2 100644
--- a/arch/x86_64/kernel/vmlinux.lds.S
+++ b/arch/x86_64/kernel/vmlinux.lds.S
@@ -172,13 +172,15 @@ SECTIONS
   . = ALIGN(4096);
   __initramfs_start = .;
   .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) { *(.init.ramfs) }
-  __initramfs_end = .;  
-  . = ALIGN(32);
+  __initramfs_end = .;
+  /* temporary here to work around NR_CPUS. If you see this comment in 2.6.17+
+   complain */
+  . = ALIGN(4096);      
+  __init_end = .;       
+  . = ALIGN(CONFIG_X86_L1_CACHE_BYTES);
   __per_cpu_start = .;
   .data.percpu  : AT(ADDR(.data.percpu) - LOAD_OFFSET) { *(.data.percpu) }
   __per_cpu_end = .;
-  . = ALIGN(4096);
-  __init_end = .;
 
   . = ALIGN(4096);
   __nosave_begin = .;
diff --git a/arch/x86_64/kernel/x8664_ksyms.c b/arch/x86_64/kernel/x8664_ksyms.c
index b614d54d2ae4..3496abc8d372 100644
--- a/arch/x86_64/kernel/x8664_ksyms.c
+++ b/arch/x86_64/kernel/x8664_ksyms.c
@@ -39,11 +39,6 @@ extern void __write_lock_failed(rwlock_t *rw);
 extern void __read_lock_failed(rwlock_t *rw);
 #endif
 
-#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD) || defined(CONFIG_BLK_DEV_IDE_MODULE) || defined(CONFIG_BLK_DEV_HD_MODULE)
-extern struct drive_info_struct drive_info;
-EXPORT_SYMBOL(drive_info);
-#endif
-
 /* platform dependent support */
 EXPORT_SYMBOL(boot_cpu_data);
 //EXPORT_SYMBOL(dump_fpu);
diff --git a/arch/x86_64/lib/Makefile b/arch/x86_64/lib/Makefile
index bba5db6cebd6..ccef6ae747a3 100644
--- a/arch/x86_64/lib/Makefile
+++ b/arch/x86_64/lib/Makefile
@@ -4,7 +4,7 @@
 
 CFLAGS_csum-partial.o := -funroll-loops
 
-obj-y := io.o
+obj-y := io.o iomap_copy.o
 
 lib-y := csum-partial.o csum-copy.o csum-wrappers.o delay.o \
         usercopy.o getuser.o putuser.o  \
diff --git a/arch/x86_64/lib/clear_page.S b/arch/x86_64/lib/clear_page.S
index 43d9fa136180..1f81b79b796c 100644
--- a/arch/x86_64/lib/clear_page.S
+++ b/arch/x86_64/lib/clear_page.S
@@ -5,8 +5,46 @@
         .globl clear_page
         .p2align 4
 clear_page:
+        xorl   %eax,%eax
+        movl   $4096/64,%ecx
+        .p2align 4
+.Lloop:
+        decl    %ecx
+#define PUT(x) movq %rax,x*8(%rdi)
+        movq %rax,(%rdi)
+        PUT(1)
+        PUT(2)
+        PUT(3)
+        PUT(4)
+        PUT(5)
+        PUT(6)
+        PUT(7)
+        leaq    64(%rdi),%rdi
+        jnz     .Lloop
+        nop
+        ret
+clear_page_end:
+
+        /* Some CPUs run faster using the string instructions.
+           It is also a lot simpler. Use this when possible */
+
+#include <asm/cpufeature.h>
+
+        .section .altinstructions,"a"
+        .align 8
+        .quad  clear_page
+        .quad  clear_page_c
+        .byte  X86_FEATURE_REP_GOOD
+        .byte  clear_page_end-clear_page
+        .byte  clear_page_c_end-clear_page_c
+        .previous
+
+        .section .altinstr_replacement,"ax"
+clear_page_c:
         movl $4096/8,%ecx
         xorl %eax,%eax
         rep 
         stosq
         ret
+clear_page_c_end:
+        .previous
diff --git a/arch/x86_64/lib/copy_page.S b/arch/x86_64/lib/copy_page.S
index 621a19769406..8fa19d96a7ee 100644
--- a/arch/x86_64/lib/copy_page.S
+++ b/arch/x86_64/lib/copy_page.S
@@ -8,7 +8,94 @@
         .globl copy_page
         .p2align 4
 copy_page:
+        subq    $3*8,%rsp
+        movq    %rbx,(%rsp)
+        movq    %r12,1*8(%rsp)
+        movq    %r13,2*8(%rsp)
+
+        movl    $(4096/64)-5,%ecx
+        .p2align 4
+.Loop64:
+        dec     %rcx
+
+        movq        (%rsi), %rax
+        movq      8 (%rsi), %rbx
+        movq     16 (%rsi), %rdx
+        movq     24 (%rsi), %r8
+        movq     32 (%rsi), %r9
+        movq     40 (%rsi), %r10
+        movq     48 (%rsi), %r11
+        movq     56 (%rsi), %r12
+
+        prefetcht0 5*64(%rsi)
+
+        movq     %rax,    (%rdi)
+        movq     %rbx,  8 (%rdi)
+        movq     %rdx, 16 (%rdi)
+        movq     %r8,  24 (%rdi)
+        movq     %r9,  32 (%rdi)
+        movq     %r10, 40 (%rdi)
+        movq     %r11, 48 (%rdi)
+        movq     %r12, 56 (%rdi)
+
+        leaq    64 (%rsi), %rsi
+        leaq    64 (%rdi), %rdi
+
+        jnz     .Loop64
+
+        movl    $5,%ecx
+        .p2align 4
+.Loop2:
+        decl   %ecx
+
+        movq        (%rsi), %rax
+        movq      8 (%rsi), %rbx
+        movq     16 (%rsi), %rdx
+        movq     24 (%rsi), %r8
+        movq     32 (%rsi), %r9
+        movq     40 (%rsi), %r10
+        movq     48 (%rsi), %r11
+        movq     56 (%rsi), %r12
+
+        movq     %rax,    (%rdi)
+        movq     %rbx,  8 (%rdi)
+        movq     %rdx, 16 (%rdi)
+        movq     %r8,  24 (%rdi)
+        movq     %r9,  32 (%rdi)
+        movq     %r10, 40 (%rdi)
+        movq     %r11, 48 (%rdi)
+        movq     %r12, 56 (%rdi)
+
+        leaq    64(%rdi),%rdi
+        leaq    64(%rsi),%rsi
+
+        jnz     .Loop2
+
+        movq    (%rsp),%rbx
+        movq    1*8(%rsp),%r12
+        movq    2*8(%rsp),%r13
+        addq    $3*8,%rsp
+        ret
+
+        /* Some CPUs run faster using the string copy instructions.
+           It is also a lot simpler. Use this when possible */
+
+#include <asm/cpufeature.h>
+
+        .section .altinstructions,"a"
+        .align 8
+        .quad  copy_page
+        .quad  copy_page_c
+        .byte  X86_FEATURE_REP_GOOD
+        .byte  copy_page_c_end-copy_page_c
+        .byte  copy_page_c_end-copy_page_c
+        .previous
+
+        .section .altinstr_replacement,"ax"
+copy_page_c:
         movl $4096/8,%ecx
         rep 
         movsq 
         ret
+copy_page_c_end:
+        .previous
diff --git a/arch/x86_64/lib/copy_user.S b/arch/x86_64/lib/copy_user.S
index 79422b6559c3..f64569b83b54 100644
--- a/arch/x86_64/lib/copy_user.S
+++ b/arch/x86_64/lib/copy_user.S
@@ -4,9 +4,12 @@
  * Functions to copy from and to user space.            
  */              
 
+#define FIX_ALIGNMENT 1
+
         #include <asm/current.h>
         #include <asm/asm-offsets.h>
         #include <asm/thread_info.h>
+        #include <asm/cpufeature.h>
 
 /* Standard copy_to_user with segment limit checking */         
         .globl copy_to_user
@@ -18,7 +21,23 @@ copy_to_user:
         jc  bad_to_user
         cmpq threadinfo_addr_limit(%rax),%rcx
         jae bad_to_user
-        jmp copy_user_generic
+2:
+        .byte 0xe9      /* 32bit jump */
+        .long .Lcug-1f
+1:
+
+        .section .altinstr_replacement,"ax"
+3:      .byte 0xe9                      /* replacement jmp with 8 bit immediate */
+        .long copy_user_generic_c-1b    /* offset */
+        .previous
+        .section .altinstructions,"a"
+        .align 8
+        .quad  2b
+        .quad  3b
+        .byte  X86_FEATURE_REP_GOOD
+        .byte  5
+        .byte  5
+        .previous
 
 /* Standard copy_from_user with segment limit checking */       
         .globl copy_from_user
@@ -53,44 +72,230 @@ bad_to_user:
  * rsi source
  * rdx count
  *
- * Only 4GB of copy is supported. This shouldn't be a problem
- * because the kernel normally only writes from/to page sized chunks
- * even if user space passed a longer buffer.
- * And more would be dangerous because both Intel and AMD have
- * errata with rep movsq > 4GB. If someone feels the need to fix
- * this please consider this.
- *
  * Output:              
  * eax uncopied bytes or 0 if successful.
  */
-
         .globl copy_user_generic
+        .p2align 4
 copy_user_generic:
+        .byte 0x66,0x66,0x90    /* 5 byte nop for replacement jump */
+        .byte 0x66,0x90
+1:
+        .section .altinstr_replacement,"ax"
+2:      .byte 0xe9                   /* near jump with 32bit immediate */
+        .long copy_user_generic_c-1b /* offset */
+        .previous
+        .section .altinstructions,"a"
+        .align 8
+        .quad  copy_user_generic
+        .quad  2b
+        .byte  X86_FEATURE_REP_GOOD
+        .byte  5
+        .byte  5
+        .previous
+.Lcug:
+        pushq %rbx
+        xorl %eax,%eax          /*zero for the exception handler */
+
+#ifdef FIX_ALIGNMENT
+        /* check for bad alignment of destination */
+        movl %edi,%ecx
+        andl $7,%ecx
+        jnz  .Lbad_alignment
+.Lafter_bad_alignment:
+#endif
+
+        movq %rdx,%rcx
+
+        movl $64,%ebx
+        shrq $6,%rdx
+        decq %rdx
+        js   .Lhandle_tail
+
+        .p2align 4
+.Lloop:
+.Ls1:   movq (%rsi),%r11
+.Ls2:   movq 1*8(%rsi),%r8
+.Ls3:   movq 2*8(%rsi),%r9
+.Ls4:   movq 3*8(%rsi),%r10
+.Ld1:   movq %r11,(%rdi)
+.Ld2:   movq %r8,1*8(%rdi)
+.Ld3:   movq %r9,2*8(%rdi)
+.Ld4:   movq %r10,3*8(%rdi)
+
+.Ls5:   movq 4*8(%rsi),%r11
+.Ls6:   movq 5*8(%rsi),%r8
+.Ls7:   movq 6*8(%rsi),%r9
+.Ls8:   movq 7*8(%rsi),%r10
+.Ld5:   movq %r11,4*8(%rdi)
+.Ld6:   movq %r8,5*8(%rdi)
+.Ld7:   movq %r9,6*8(%rdi)
+.Ld8:   movq %r10,7*8(%rdi)
+
+        decq %rdx
+
+        leaq 64(%rsi),%rsi
+        leaq 64(%rdi),%rdi
+
+        jns  .Lloop
+
+        .p2align 4
+.Lhandle_tail:
+        movl %ecx,%edx
+        andl $63,%ecx
+        shrl $3,%ecx
+        jz   .Lhandle_7
+        movl $8,%ebx
+        .p2align 4
+.Lloop_8:
+.Ls9:   movq (%rsi),%r8
+.Ld9:   movq %r8,(%rdi)
+        decl %ecx
+        leaq 8(%rdi),%rdi
+        leaq 8(%rsi),%rsi
+        jnz .Lloop_8
+
+.Lhandle_7:
+        movl %edx,%ecx
+        andl $7,%ecx
+        jz   .Lende
+        .p2align 4
+.Lloop_1:
+.Ls10:  movb (%rsi),%bl
+.Ld10:  movb %bl,(%rdi)
+        incq %rdi
+        incq %rsi
+        decl %ecx
+        jnz .Lloop_1
+
+.Lende:
+        popq %rbx
+        ret
+
+#ifdef FIX_ALIGNMENT
+        /* align destination */
+        .p2align 4
+.Lbad_alignment:
+        movl $8,%r9d
+        subl %ecx,%r9d
+        movl %r9d,%ecx
+        cmpq %r9,%rdx
+        jz   .Lhandle_7
+        js   .Lhandle_7
+.Lalign_1:
+.Ls11:  movb (%rsi),%bl
+.Ld11:  movb %bl,(%rdi)
+        incq %rsi
+        incq %rdi
+        decl %ecx
+        jnz .Lalign_1
+        subq %r9,%rdx
+        jmp .Lafter_bad_alignment
+#endif
+
+        /* table sorted by exception address */
+        .section __ex_table,"a"
+        .align 8
+        .quad .Ls1,.Ls1e
+        .quad .Ls2,.Ls2e
+        .quad .Ls3,.Ls3e
+        .quad .Ls4,.Ls4e
+        .quad .Ld1,.Ls1e
+        .quad .Ld2,.Ls2e
+        .quad .Ld3,.Ls3e
+        .quad .Ld4,.Ls4e
+        .quad .Ls5,.Ls5e
+        .quad .Ls6,.Ls6e
+        .quad .Ls7,.Ls7e
+        .quad .Ls8,.Ls8e
+        .quad .Ld5,.Ls5e
+        .quad .Ld6,.Ls6e
+        .quad .Ld7,.Ls7e
+        .quad .Ld8,.Ls8e
+        .quad .Ls9,.Le_quad
+        .quad .Ld9,.Le_quad
+        .quad .Ls10,.Le_byte
+        .quad .Ld10,.Le_byte
+#ifdef FIX_ALIGNMENT
+        .quad .Ls11,.Lzero_rest
+        .quad .Ld11,.Lzero_rest
+#endif
+        .quad .Le5,.Le_zero
+        .previous
+
+        /* compute 64-offset for main loop. 8 bytes accuracy with error on the
+           pessimistic side. this is gross. it would be better to fix the
+           interface. */
+        /* eax: zero, ebx: 64 */
+.Ls1e:  addl $8,%eax
+.Ls2e:  addl $8,%eax
+.Ls3e:  addl $8,%eax
+.Ls4e:  addl $8,%eax
+.Ls5e:  addl $8,%eax
+.Ls6e:  addl $8,%eax
+.Ls7e:  addl $8,%eax
+.Ls8e:  addl $8,%eax
+        addq %rbx,%rdi  /* +64 */
+        subq %rax,%rdi  /* correct destination with computed offset */
+
+        shlq $6,%rdx    /* loop counter * 64 (stride length) */
+        addq %rax,%rdx  /* add offset to loopcnt */
+        andl $63,%ecx   /* remaining bytes */
+        addq %rcx,%rdx  /* add them */
+        jmp .Lzero_rest
+
+        /* exception on quad word loop in tail handling */
+        /* ecx: loopcnt/8, %edx: length, rdi: correct */
+.Le_quad:
+        shll $3,%ecx
+        andl $7,%edx
+        addl %ecx,%edx
+        /* edx: bytes to zero, rdi: dest, eax:zero */
+.Lzero_rest:
+        movq %rdx,%rcx
+.Le_byte:
+        xorl %eax,%eax
+.Le5:   rep
+        stosb
+        /* when there is another exception while zeroing the rest just return */
+.Le_zero:
+        movq %rdx,%rax
+        jmp .Lende
+
+        /* Some CPUs run faster using the string copy instructions.
+           This is also a lot simpler. Use them when possible.
+           Patch in jmps to this code instead of copying it fully
+           to avoid unwanted aliasing in the exception tables. */
+
+ /* rdi destination
+  * rsi source
+  * rdx count
+  *
+  * Output:
+  * eax uncopied bytes or 0 if successfull.
+  *
+  * Only 4GB of copy is supported. This shouldn't be a problem
+  * because the kernel normally only writes from/to page sized chunks
+  * even if user space passed a longer buffer.
+  * And more would be dangerous because both Intel and AMD have
+  * errata with rep movsq > 4GB. If someone feels the need to fix
+  * this please consider this.
+   */
+copy_user_generic_c:
         movl %edx,%ecx
         shrl $3,%ecx
         andl $7,%edx    
-        jz   5f
 1:      rep 
         movsq 
         movl %edx,%ecx
-        xor %eax,%eax
 2:      rep
         movsb
+4:      movl %ecx,%eax
         ret
-        /* align here? */
-5:      xorl %eax,%eax
-6:      rep movsq
-        ret
-
-        .section .fixup,"ax"
 3:      lea (%rdx,%rcx,8),%rax
         ret
-4:      movl %ecx,%eax
-        ret
-        .previous
 
         .section __ex_table,"a"
         .quad 1b,3b
         .quad 2b,4b
-        .quad 6b,4b
         .previous
diff --git a/arch/x86_64/lib/iomap_copy.S b/arch/x86_64/lib/iomap_copy.S
new file mode 100644
index 000000000000..8bbade5fea05
--- /dev/null
+++ b/arch/x86_64/lib/iomap_copy.S
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2006 PathScale, Inc.  All Rights Reserved.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/*
+ * override generic version in lib/iomap_copy.c
+ */
+        .globl __iowrite32_copy
+        .p2align 4
+__iowrite32_copy:
+        movl %edx,%ecx
+        rep movsd
+        ret
diff --git a/arch/x86_64/lib/memcpy.S b/arch/x86_64/lib/memcpy.S
index 92dd80544602..5554948b5554 100644
--- a/arch/x86_64/lib/memcpy.S
+++ b/arch/x86_64/lib/memcpy.S
@@ -11,8 +11,6 @@
  * 
  * Output:
  * rax original destination
- * 
- * TODO: check best memcpy for PSC
  */     
 
         .globl __memcpy
@@ -20,6 +18,95 @@
         .p2align 4
 __memcpy:
 memcpy:         
+        pushq %rbx
+        movq %rdi,%rax
+
+        movl %edx,%ecx
+        shrl $6,%ecx
+        jz .Lhandle_tail
+
+        .p2align 4
+.Lloop_64:
+        decl %ecx
+
+        movq (%rsi),%r11
+        movq 8(%rsi),%r8
+
+        movq %r11,(%rdi)
+        movq %r8,1*8(%rdi)
+
+        movq 2*8(%rsi),%r9
+        movq 3*8(%rsi),%r10
+
+        movq %r9,2*8(%rdi)
+        movq %r10,3*8(%rdi)
+
+        movq 4*8(%rsi),%r11
+        movq 5*8(%rsi),%r8
+
+        movq %r11,4*8(%rdi)
+        movq %r8,5*8(%rdi)
+
+        movq 6*8(%rsi),%r9
+        movq 7*8(%rsi),%r10
+
+        movq %r9,6*8(%rdi)
+        movq %r10,7*8(%rdi)
+
+        leaq 64(%rsi),%rsi
+        leaq 64(%rdi),%rdi
+        jnz  .Lloop_64
+
+.Lhandle_tail:
+        movl %edx,%ecx
+        andl $63,%ecx
+        shrl $3,%ecx
+        jz   .Lhandle_7
+        .p2align 4
+.Lloop_8:
+        decl %ecx
+        movq (%rsi),%r8
+        movq %r8,(%rdi)
+        leaq 8(%rdi),%rdi
+        leaq 8(%rsi),%rsi
+        jnz  .Lloop_8
+
+.Lhandle_7:
+        movl %edx,%ecx
+        andl $7,%ecx
+        jz .Lende
+        .p2align 4
+.Lloop_1:
+        movb (%rsi),%r8b
+        movb %r8b,(%rdi)
+        incq %rdi
+        incq %rsi
+        decl %ecx
+        jnz .Lloop_1
+
+.Lende:
+        popq %rbx
+        ret
+.Lfinal:
+
+        /* Some CPUs run faster using the string copy instructions.
+           It is also a lot simpler. Use this when possible */
+
+        .section .altinstructions,"a"
+        .align 8
+        .quad  memcpy
+        .quad  memcpy_c
+        .byte  X86_FEATURE_REP_GOOD
+        .byte  .Lfinal-memcpy
+        .byte  memcpy_c_end-memcpy_c
+        .previous
+
+        .section .altinstr_replacement,"ax"
+ /* rdi destination
+  * rsi source
+  * rdx count
+  */
+memcpy_c:
         movq %rdi,%rax
         movl %edx,%ecx
         shrl $3,%ecx
@@ -30,3 +117,5 @@ memcpy:
         rep
         movsb
         ret
+memcpy_c_end:
+        .previous
diff --git a/arch/x86_64/lib/memset.S b/arch/x86_64/lib/memset.S
index 2aa48f24ed1e..ad397f2c7de8 100644
--- a/arch/x86_64/lib/memset.S
+++ b/arch/x86_64/lib/memset.S
@@ -13,6 +13,98 @@
         .p2align 4
 memset: 
 __memset:
+        movq %rdi,%r10
+        movq %rdx,%r11
+
+        /* expand byte value  */
+        movzbl %sil,%ecx
+        movabs $0x0101010101010101,%rax
+        mul    %rcx             /* with rax, clobbers rdx */
+
+        /* align dst */
+        movl  %edi,%r9d
+        andl  $7,%r9d
+        jnz  .Lbad_alignment
+.Lafter_bad_alignment:
+
+        movl %r11d,%ecx
+        shrl $6,%ecx
+        jz       .Lhandle_tail
+
+        .p2align 4
+.Lloop_64:
+        decl   %ecx
+        movq  %rax,(%rdi)
+        movq  %rax,8(%rdi)
+        movq  %rax,16(%rdi)
+        movq  %rax,24(%rdi)
+        movq  %rax,32(%rdi)
+        movq  %rax,40(%rdi)
+        movq  %rax,48(%rdi)
+        movq  %rax,56(%rdi)
+        leaq  64(%rdi),%rdi
+        jnz    .Lloop_64
+
+        /* Handle tail in loops. The loops should be faster than hard
+           to predict jump tables. */
+        .p2align 4
+.Lhandle_tail:
+        movl    %r11d,%ecx
+        andl    $63&(~7),%ecx
+        jz              .Lhandle_7
+        shrl    $3,%ecx
+        .p2align 4
+.Lloop_8:
+        decl   %ecx
+        movq  %rax,(%rdi)
+        leaq  8(%rdi),%rdi
+        jnz    .Lloop_8
+
+.Lhandle_7:
+        movl    %r11d,%ecx
+        andl    $7,%ecx
+        jz      .Lende
+        .p2align 4
+.Lloop_1:
+        decl    %ecx
+        movb    %al,(%rdi)
+        leaq    1(%rdi),%rdi
+        jnz     .Lloop_1
+
+.Lende:
+        movq    %r10,%rax
+        ret
+
+.Lbad_alignment:
+        cmpq $7,%r11
+        jbe     .Lhandle_7
+        movq %rax,(%rdi)        /* unaligned store */
+        movq $8,%r8
+        subq %r9,%r8
+        addq %r8,%rdi
+        subq %r8,%r11
+        jmp .Lafter_bad_alignment
+
+        /* Some CPUs run faster using the string instructions.
+           It is also a lot simpler. Use this when possible */
+
+#include <asm/cpufeature.h>
+
+        .section .altinstructions,"a"
+        .align 8
+        .quad  memset
+        .quad  memset_c
+        .byte  X86_FEATURE_REP_GOOD
+        .byte  memset_c_end-memset_c
+        .byte  memset_c_end-memset_c
+        .previous
+
+        .section .altinstr_replacement,"ax"
+ /* rdi destination
+  * rsi value
+  * rdx count
+  */
+memset_c:
         movq %rdi,%r9
         movl %edx,%r8d
         andl $7,%r8d            
@@ -29,3 +121,5 @@ __memset:
         stosb
         movq %r9,%rax
         ret
+memset_c_end:
+        .previous
diff --git a/arch/x86_64/mm/fault.c b/arch/x86_64/mm/fault.c
index 26eac194064b..2e7c3c8ffe03 100644
--- a/arch/x86_64/mm/fault.c
+++ b/arch/x86_64/mm/fault.c
@@ -33,7 +33,6 @@
 #include <asm/proto.h>
 #include <asm/kdebug.h>
 #include <asm-generic/sections.h>
-#include <asm/kdebug.h>
 
 /* Page fault error code bits */
 #define PF_PROT (1<<0)          /* or no page found */
@@ -157,8 +156,8 @@ void dump_pagetable(unsigned long address)
 
         pgd = __va((unsigned long)pgd & PHYSICAL_PAGE_MASK); 
         pgd += pgd_index(address);
-        printk("PGD %lx ", pgd_val(*pgd));
         if (bad_address(pgd)) goto bad;
+        printk("PGD %lx ", pgd_val(*pgd));
         if (!pgd_present(*pgd)) goto ret; 
 
         pud = __pud_offset_k((pud_t *)pgd_page(*pgd), address);
diff --git a/arch/x86_64/mm/srat.c b/arch/x86_64/mm/srat.c
index 8b7f85608fa8..cd25300726fc 100644
--- a/arch/x86_64/mm/srat.c
+++ b/arch/x86_64/mm/srat.c
@@ -26,6 +26,10 @@ static nodemask_t nodes_found __initdata;
 static struct node nodes[MAX_NUMNODES] __initdata;
 static u8 pxm2node[256] = { [0 ... 255] = 0xff };
 
+/* Too small nodes confuse the VM badly. Usually they result
+   from BIOS bugs. */
+#define NODE_MIN_SIZE (4*1024*1024)
+
 static int node_to_pxm(int n);
 
 int pxm_to_node(int pxm)
@@ -131,7 +135,12 @@ void __init
 acpi_numa_processor_affinity_init(struct acpi_table_processor_affinity *pa)
 {
         int pxm, node;
-        if (srat_disabled() || pa->flags.enabled == 0)
+        if (srat_disabled())
+                return;
+        if (pa->header.length != sizeof(struct acpi_table_processor_affinity)) {                bad_srat();
+                return;
+        }
+        if (pa->flags.enabled == 0)
                 return;
         pxm = pa->proximity_domain;
         node = setup_node(pxm);
@@ -155,8 +164,16 @@ acpi_numa_memory_affinity_init(struct acpi_table_memory_affinity *ma)
         int node, pxm;
         int i;
 
-        if (srat_disabled() || ma->flags.enabled == 0)
+        if (srat_disabled())
+                return;
+        if (ma->header.length != sizeof(struct acpi_table_memory_affinity)) {
+                bad_srat();
                 return;
+        }
+        if (ma->flags.enabled == 0)
+                return;
+        start = ma->base_addr_lo | ((u64)ma->base_addr_hi << 32);
+        end = start + (ma->length_lo | ((u64)ma->length_hi << 32));
         pxm = ma->proximity_domain;
         node = setup_node(pxm);
         if (node < 0) {
@@ -164,8 +181,6 @@ acpi_numa_memory_affinity_init(struct acpi_table_memory_affinity *ma)
                 bad_srat();
                 return;
         }
-        start = ma->base_addr_lo | ((u64)ma->base_addr_hi << 32);
-        end = start + (ma->length_lo | ((u64)ma->length_hi << 32));
         /* It is fine to add this area to the nodes data it will be used later*/
         if (ma->flags.hot_pluggable == 1)
                 printk(KERN_INFO "SRAT: hot plug zone found %lx - %lx \n",
@@ -223,6 +238,16 @@ static int nodes_cover_memory(void)
         return 1;
 }
 
+static void unparse_node(int node)
+{
+        int i;
+        node_clear(node, nodes_parsed);
+        for (i = 0; i < MAX_LOCAL_APIC; i++) {
+                if (apicid_to_node[i] == node)
+                        apicid_to_node[i] = NUMA_NO_NODE;
+        }
+}
+
 void __init acpi_numa_arch_fixup(void) {}
 
 /* Use the information discovered above to actually set up the nodes. */
@@ -230,16 +255,16 @@ int __init acpi_scan_nodes(unsigned long start, unsigned long end)
 {
         int i;
 
-        if (acpi_numa <= 0)
-                return -1;
-
         /* First clean up the node list */
-        for_each_node_mask(i, nodes_parsed) {
+        for (i = 0; i < MAX_NUMNODES; i++) {
                 cutoff_node(i, start, end);
-                if (nodes[i].start == nodes[i].end)
-                        node_clear(i, nodes_parsed);
+                if ((nodes[i].end - nodes[i].start) < NODE_MIN_SIZE)
+                        unparse_node(i);
         }
 
+        if (acpi_numa <= 0)
+                return -1;
+
         if (!nodes_cover_memory()) {
                 bad_srat();
                 return -1;
diff --git a/arch/x86_64/pci/mmconfig.c b/arch/x86_64/pci/mmconfig.c
index f16c0d57c552..18f371fe37f8 100644
--- a/arch/x86_64/pci/mmconfig.c
+++ b/arch/x86_64/pci/mmconfig.c
@@ -29,11 +29,8 @@ static char __iomem *get_virt(unsigned int seg, unsigned bus)
 
         while (1) {
                 ++cfg_num;
-                if (cfg_num >= pci_mmcfg_config_num) {
-                        /* Not found - fall back to type 1. This happens
-                           e.g. on the internal devices of a K8 northbridge. */
-                        return NULL;
-                }
+                if (cfg_num >= pci_mmcfg_config_num)
+                        break;
                 cfg = pci_mmcfg_virt[cfg_num].cfg;
                 if (cfg->pci_segment_group_number != seg)
                         continue;
@@ -41,6 +38,18 @@ static char __iomem *get_virt(unsigned int seg, unsigned bus)
                     (cfg->end_bus_number >= bus))
                         return pci_mmcfg_virt[cfg_num].virt;
         }
+
+        /* Handle more broken MCFG tables on Asus etc.
+           They only contain a single entry for bus 0-0. Assume
+           this applies to all busses. */
+        cfg = &pci_mmcfg_config[0];
+        if (pci_mmcfg_config_num == 1 &&
+                cfg->pci_segment_group_number == 0 &&
+                (cfg->start_bus_number | cfg->end_bus_number) == 0)
+                return pci_mmcfg_virt[0].virt;
+
+        /* Fall back to type 0 */
+        return NULL;
 }
 
 static char __iomem *pci_dev_base(unsigned int seg, unsigned int bus, unsigned int devfn)
diff --git a/arch/xtensa/platform-iss/console.c b/arch/xtensa/platform-iss/console.c
index 4fbddf92a921..94fdfe474ac1 100644
--- a/arch/xtensa/platform-iss/console.c
+++ b/arch/xtensa/platform-iss/console.c
@@ -128,9 +128,7 @@ static void rs_poll(unsigned long priv)
 
         while (__simc(SYS_select_one, 0, XTISS_SELECT_ONE_READ, (int)&tv,0,0)){
                 __simc (SYS_read, 0, (unsigned long)&c, 1, 0, 0);
-                tty->flip.count++;
-                *tty->flip.char_buf_ptr++ = c;
-                *tty->flip.flag_buf_ptr++ = TTY_NORMAL;
+                tty_insert_flip_char(tty, c, TTY_NORMAL);
                 i++;
         }