455 files changed, 9567 insertions, 6447 deletions

diff --git a/arch/Kconfig b/arch/Kconfig
new file mode 100644
index 000000000000..3d72dc3fc8f5
--- /dev/null
+++ b/arch/Kconfig
@@ -0,0 +1,31 @@
+#
+# General architecture dependent options
+#
+
+config OPROFILE
+        tristate "OProfile system profiling (EXPERIMENTAL)"
+        depends on PROFILING
+        depends on HAVE_OPROFILE
+        help
+          OProfile is a profiling system capable of profiling the
+          whole system, include the kernel, kernel modules, libraries,
+          and applications.
+
+          If unsure, say N.
+
+config HAVE_OPROFILE
+        def_bool n
+
+config KPROBES
+        bool "Kprobes"
+        depends on KALLSYMS && MODULES
+        depends on HAVE_KPROBES
+        help
+          Kprobes allows you to trap at almost any kernel address and
+          execute a callback function.  register_kprobe() establishes
+          a probepoint and specifies the callback.  Kprobes is useful
+          for kernel debugging, non-intrusive instrumentation and testing.
+          If in doubt, say "N".
+
+config HAVE_KPROBES
+        def_bool n
diff --git a/arch/alpha/Kconfig b/arch/alpha/Kconfig
index 4c002ba37e50..01b10ab588a6 100644
--- a/arch/alpha/Kconfig
+++ b/arch/alpha/Kconfig
@@ -5,6 +5,7 @@
 config ALPHA
         bool
         default y
+        select HAVE_OPROFILE
         help
           The Alpha is a 64-bit general-purpose processor designed and
           marketed by the Digital Equipment Corporation of blessed memory,
@@ -318,11 +319,6 @@ config PCI
           your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
           VESA. If you have PCI, say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 config PCI_DOMAINS
         bool
         default y
@@ -536,8 +532,8 @@ config SMP
           singleprocessor machines. On a singleprocessor machine, the kernel
           will run faster if you say N here.
 
-          See also the <file:Documentation/smp.txt>, and the SMP-HOWTO
-          available at <http://www.tldp.org/docs.html#howto>.
+          See also the SMP-HOWTO available at
+          <http://www.tldp.org/docs.html#howto>.
 
           If you don't know what to do here, say N.
 
@@ -654,8 +650,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/alpha/Kconfig.debug"
 
 # DUMMY_CONSOLE may be defined in drivers/video/console/Kconfig
diff --git a/arch/alpha/kernel/pci-noop.c b/arch/alpha/kernel/pci-noop.c
index 468b76ce66a1..8ac08311f5a5 100644
--- a/arch/alpha/kernel/pci-noop.c
+++ b/arch/alpha/kernel/pci-noop.c
@@ -165,7 +165,7 @@ dma_alloc_coherent(struct device *dev, size_t size,
         ret = (void *)__get_free_pages(gfp, get_order(size));
         if (ret) {
                 memset(ret, 0, size);
-                *dma_handle = virt_to_bus(ret);
+                *dma_handle = virt_to_phys(ret);
         }
         return ret;
 }
@@ -184,7 +184,7 @@ dma_map_sg(struct device *dev, struct scatterlist *sgl, int nents,
 
                 BUG_ON(!sg_page(sg));
                 va = sg_virt(sg);
-                sg_dma_address(sg) = (dma_addr_t)virt_to_bus(va);
+                sg_dma_address(sg) = (dma_addr_t)virt_to_phys(va);
                 sg_dma_len(sg) = sg->length;
         }
 
diff --git a/arch/alpha/kernel/pci_iommu.c b/arch/alpha/kernel/pci_iommu.c
index 2d00a08d3f08..26d3789dfdd0 100644
--- a/arch/alpha/kernel/pci_iommu.c
+++ b/arch/alpha/kernel/pci_iommu.c
@@ -9,6 +9,7 @@
 #include <linux/bootmem.h>
 #include <linux/scatterlist.h>
 #include <linux/log2.h>
+#include <linux/dma-mapping.h>
 
 #include <asm/io.h>
 #include <asm/hwrpb.h>
@@ -470,22 +471,29 @@ EXPORT_SYMBOL(pci_free_consistent);
 #define SG_ENT_PHYS_ADDRESS(SG) __pa(SG_ENT_VIRT_ADDRESS(SG))
 
 static void
-sg_classify(struct scatterlist *sg, struct scatterlist *end, int virt_ok)
+sg_classify(struct device *dev, struct scatterlist *sg, struct scatterlist *end,
+            int virt_ok)
 {
         unsigned long next_paddr;
         struct scatterlist *leader;
         long leader_flag, leader_length;
+        unsigned int max_seg_size;
 
         leader = sg;
         leader_flag = 0;
         leader_length = leader->length;
         next_paddr = SG_ENT_PHYS_ADDRESS(leader) + leader_length;
 
+        /* we will not marge sg without device. */
+        max_seg_size = dev ? dma_get_max_seg_size(dev) : 0;
         for (++sg; sg < end; ++sg) {
                 unsigned long addr, len;
                 addr = SG_ENT_PHYS_ADDRESS(sg);
                 len = sg->length;
 
+                if (leader_length + len > max_seg_size)
+                        goto new_segment;
+
                 if (next_paddr == addr) {
                         sg->dma_address = -1;
                         leader_length += len;
@@ -494,6 +502,7 @@ sg_classify(struct scatterlist *sg, struct scatterlist *end, int virt_ok)
                         leader_flag = 1;
                         leader_length += len;
                 } else {
+new_segment:
                         leader->dma_address = leader_flag;
                         leader->dma_length = leader_length;
                         leader = sg;
@@ -512,7 +521,7 @@ sg_classify(struct scatterlist *sg, struct scatterlist *end, int virt_ok)
    in the blanks.  */
 
 static int
-sg_fill(struct scatterlist *leader, struct scatterlist *end,
+sg_fill(struct device *dev, struct scatterlist *leader, struct scatterlist *end,
         struct scatterlist *out, struct pci_iommu_arena *arena,
         dma_addr_t max_dma, int dac_allowed)
 {
@@ -562,8 +571,8 @@ sg_fill(struct scatterlist *leader, struct scatterlist *end,
 
                 /* Otherwise, break up the remaining virtually contiguous
                    hunks into individual direct maps and retry.  */
-                sg_classify(leader, end, 0);
-                return sg_fill(leader, end, out, arena, max_dma, dac_allowed);
+                sg_classify(dev, leader, end, 0);
+                return sg_fill(dev, leader, end, out, arena, max_dma, dac_allowed);
         }
 
         out->dma_address = arena->dma_base + dma_ofs*PAGE_SIZE + paddr;
@@ -619,12 +628,15 @@ pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
         struct pci_iommu_arena *arena;
         dma_addr_t max_dma;
         int dac_allowed;
+        struct device *dev;
 
         if (direction == PCI_DMA_NONE)
                 BUG();
 
         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;
 
+        dev = pdev ? &pdev->dev : NULL;
+
         /* Fast path single entry scatterlists.  */
         if (nents == 1) {
                 sg->dma_length = sg->length;
@@ -638,7 +650,7 @@ pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
         end = sg + nents;
 
         /* First, prepare information about the entries.  */
-        sg_classify(sg, end, alpha_mv.mv_pci_tbi != 0);
+        sg_classify(dev, sg, end, alpha_mv.mv_pci_tbi != 0);
 
         /* Second, figure out where we're going to map things.  */
         if (alpha_mv.mv_pci_tbi) {
@@ -658,7 +670,7 @@ pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
         for (out = sg; sg < end; ++sg) {
                 if ((int) sg->dma_address < 0)
                         continue;
-                if (sg_fill(sg, end, out, arena, max_dma, dac_allowed) < 0)
+                if (sg_fill(dev, sg, end, out, arena, max_dma, dac_allowed) < 0)
                         goto error;
                 out++;
         }
diff --git a/arch/alpha/kernel/setup.c b/arch/alpha/kernel/setup.c
index bd5e68cd61e8..beff6297f788 100644
--- a/arch/alpha/kernel/setup.c
+++ b/arch/alpha/kernel/setup.c
@@ -58,7 +58,6 @@ static struct notifier_block alpha_panic_block = {
 #include <asm/system.h>
 #include <asm/hwrpb.h>
 #include <asm/dma.h>
-#include <asm/io.h>
 #include <asm/mmu_context.h>
 #include <asm/console.h>
 
diff --git a/arch/alpha/kernel/systbls.S b/arch/alpha/kernel/systbls.S
index 79de99e32c35..ba914af18c4f 100644
--- a/arch/alpha/kernel/systbls.S
+++ b/arch/alpha/kernel/systbls.S
@@ -495,7 +495,7 @@ sys_call_table:
         .quad sys_epoll_pwait
         .quad sys_utimensat                     /* 475 */
         .quad sys_signalfd
-        .quad sys_timerfd
+        .quad sys_ni_syscall
         .quad sys_eventfd
 
         .size sys_call_table, . - sys_call_table
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 77201d3f7479..e19e7744e366 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -10,6 +10,8 @@ config ARM
         default y
         select RTC_LIB
         select SYS_SUPPORTS_APM_EMULATION
+        select HAVE_OPROFILE
+        select HAVE_KPROBES if (!XIP_KERNEL)
         help
           The ARM series is a line of low-power-consumption RISC chip designs
           licensed by ARM Ltd and targeted at embedded applications and
@@ -33,6 +35,11 @@ config GENERIC_CLOCKEVENTS
         bool
         default n
 
+config GENERIC_CLOCKEVENTS_BROADCAST
+        bool
+        depends on GENERIC_CLOCKEVENTS
+        default y if SMP && !LOCAL_TIMERS
+
 config MMU
         bool
         default y
@@ -135,6 +142,23 @@ config FIQ
 config ARCH_MTD_XIP
         bool
 
+if OPROFILE
+
+config OPROFILE_ARMV6
+        def_bool y
+        depends on CPU_V6 && !SMP
+        select OPROFILE_ARM11_CORE
+
+config OPROFILE_MPCORE
+        def_bool y
+        depends on CPU_V6 && SMP
+        select OPROFILE_ARM11_CORE
+
+config OPROFILE_ARM11_CORE
+        bool
+
+endif
+
 config VECTORS_BASE
         hex
         default 0xffff0000 if MMU || CPU_HIGH_VECTOR
@@ -168,6 +192,8 @@ config ARCH_REALVIEW
         bool "ARM Ltd. RealView family"
         select ARM_AMBA
         select ICST307
+        select GENERIC_TIME
+        select GENERIC_CLOCKEVENTS
         help
           This enables support for ARM Ltd RealView boards.
 
@@ -359,6 +385,7 @@ config ARCH_PXA
         depends on MMU
         select ARCH_MTD_XIP
         select GENERIC_GPIO
+        select HAVE_GPIO_LIB
         select GENERIC_TIME
         select GENERIC_CLOCKEVENTS
         select TICK_ONESHOT
@@ -577,11 +604,6 @@ config PCI
           your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
           VESA. If you have PCI, say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 config PCI_SYSCALL
         def_bool PCI
 
@@ -609,7 +631,7 @@ source "kernel/time/Kconfig"
 
 config SMP
         bool "Symmetric Multi-Processing (EXPERIMENTAL)"
-        depends on EXPERIMENTAL && REALVIEW_MPCORE
+        depends on EXPERIMENTAL && REALVIEW_EB_ARM11MP
         help
           This enables support for systems with more than one CPU. If you have
           a system with only one CPU, like most personal computers, say N. If
@@ -621,8 +643,7 @@ config SMP
           processor machines. On a single processor machine, the kernel will
           run faster if you say N here.
 
-          See also the <file:Documentation/smp.txt>,
-          <file:Documentation/i386/IO-APIC.txt>,
+          See also <file:Documentation/i386/IO-APIC.txt>,
           <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO available at
           <http://www.linuxdoc.org/docs.html#howto>.
 
@@ -643,7 +664,7 @@ config HOTPLUG_CPU
 
 config LOCAL_TIMERS
         bool "Use local timer interrupts"
-        depends on SMP && REALVIEW_MPCORE
+        depends on SMP && REALVIEW_EB_ARM11MP
         default y
         help
           Enable support for local timers on SMP platforms, rather then the
@@ -899,6 +920,13 @@ config KEXEC
           initially work for you.  It may help to enable device hotplugging
           support.
 
+config ATAGS_PROC
+        bool "Export atags in procfs"
+        default n
+        help
+          Should the atags used to boot the kernel be exported in an "atags"
+          file in procfs. Useful with kexec.
+
 endmenu
 
 if (ARCH_SA1100 || ARCH_INTEGRATOR || ARCH_OMAP || ARCH_IMX || ARCH_PXA)
@@ -1035,6 +1063,9 @@ menu "Power management options"
 
 source "kernel/power/Kconfig"
 
+config ARCH_SUSPEND_POSSIBLE
+        def_bool y
+
 endmenu
 
 source "net/Kconfig"
@@ -1092,6 +1123,8 @@ source "drivers/i2c/Kconfig"
 
 source "drivers/spi/Kconfig"
 
+source "drivers/gpio/Kconfig"
+
 source "drivers/w1/Kconfig"
 
 source "drivers/power/Kconfig"
@@ -1130,8 +1163,6 @@ endmenu
 
 source "fs/Kconfig"
 
-source "arch/arm/Kconfig.instrumentation"
-
 source "arch/arm/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/arm/Kconfig.instrumentation b/arch/arm/Kconfig.instrumentation
deleted file mode 100644
index 453ad8e15d69..000000000000
--- a/arch/arm/Kconfig.instrumentation
+++ /dev/null
@@ -1,62 +0,0 @@
-menuconfig INSTRUMENTATION
-        bool "Instrumentation Support"
-        default y
-        ---help---
-          Say Y here to get to see options related to performance measurement,
-          system-wide debugging, and testing. This option alone does not add any
-          kernel code.
-
-          If you say N, all options in this submenu will be skipped and
-          disabled. If you're trying to debug the kernel itself, go see the
-          Kernel Hacking menu.
-
-if INSTRUMENTATION
-
-config PROFILING
-        bool "Profiling support (EXPERIMENTAL)"
-        help
-          Say Y here to enable the extended profiling support mechanisms used
-          by profilers such as OProfile.
-
-config OPROFILE
-        tristate "OProfile system profiling (EXPERIMENTAL)"
-        depends on PROFILING && !UML
-        help
-          OProfile is a profiling system capable of profiling the
-          whole system, include the kernel, kernel modules, libraries,
-          and applications.
-
-          If unsure, say N.
-
-config OPROFILE_ARMV6
-        bool
-        depends on OPROFILE && CPU_V6 && !SMP
-        default y
-        select OPROFILE_ARM11_CORE
-
-config OPROFILE_MPCORE
-        bool
-        depends on OPROFILE && CPU_V6 && SMP
-        default y
-        select OPROFILE_ARM11_CORE
-
-config OPROFILE_ARM11_CORE
-        bool
-
-config KPROBES
-        bool "Kprobes"
-        depends on KALLSYMS && MODULES && !UML && !XIP_KERNEL
-        help
-          Kprobes allows you to trap at almost any kernel address and
-          execute a callback function.  register_kprobe() establishes
-          a probepoint and specifies the callback.  Kprobes is useful
-          for kernel debugging, non-intrusive instrumentation and testing.
-          If in doubt, say "N".
-
-config MARKERS
-        bool "Activate markers"
-        help
-          Place an empty function call at each marker site. Can be
-          dynamically changed for a probe function.
-
-endif # INSTRUMENTATION
diff --git a/arch/arm/common/time-acorn.c b/arch/arm/common/time-acorn.c
index 34038eccbba9..d544da414731 100644
--- a/arch/arm/common/time-acorn.c
+++ b/arch/arm/common/time-acorn.c
@@ -69,9 +69,7 @@ void __init ioctime_init(void)
 static irqreturn_t
 ioc_timer_interrupt(int irq, void *dev_id)
 {
-        write_seqlock(&xtime_lock);
         timer_tick();
-        write_sequnlock(&xtime_lock);
         return IRQ_HANDLED;
 }
 
diff --git a/arch/arm/configs/ixp4xx_defconfig b/arch/arm/configs/ixp4xx_defconfig
index db850a5689eb..efa0485d2f7e 100644
--- a/arch/arm/configs/ixp4xx_defconfig
+++ b/arch/arm/configs/ixp4xx_defconfig
@@ -1,69 +1,96 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.15
-# Tue Jan  3 03:20:40 2006
+# Linux kernel version: 2.6.24
+# Sun Jan 27 07:33:38 2008
 #
 CONFIG_ARM=y
+CONFIG_SYS_SUPPORTS_APM_EMULATION=y
+CONFIG_GENERIC_GPIO=y
+CONFIG_GENERIC_TIME=y
+CONFIG_GENERIC_CLOCKEVENTS=y
 CONFIG_MMU=y
-CONFIG_UID16=y
+# CONFIG_NO_IOPORT is not set
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_STACKTRACE_SUPPORT=y
+CONFIG_LOCKDEP_SUPPORT=y
+CONFIG_TRACE_IRQFLAGS_SUPPORT=y
+CONFIG_HARDIRQS_SW_RESEND=y
+CONFIG_GENERIC_IRQ_PROBE=y
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
+# CONFIG_ARCH_HAS_ILOG2_U32 is not set
+# CONFIG_ARCH_HAS_ILOG2_U64 is not set
+CONFIG_GENERIC_HWEIGHT=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_ZONE_DMA=y
+CONFIG_VECTORS_BASE=0xffff0000
+CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
 
 #
-# Code maturity level options
+# General setup
 #
 CONFIG_EXPERIMENTAL=y
-CONFIG_CLEAN_COMPILE=y
 CONFIG_BROKEN_ON_SMP=y
 CONFIG_INIT_ENV_ARG_LIMIT=32
-
-#
-# General setup
-#
 CONFIG_LOCALVERSION=""
 CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
+CONFIG_SYSVIPC_SYSCTL=y
 # CONFIG_POSIX_MQUEUE is not set
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
-CONFIG_SYSCTL=y
+# CONFIG_TASKSTATS is not set
+# CONFIG_USER_NS is not set
+# CONFIG_PID_NS is not set
 # CONFIG_AUDIT is not set
-# CONFIG_HOTPLUG is not set
-CONFIG_KOBJECT_UEVENT=y
 # CONFIG_IKCONFIG is not set
+CONFIG_LOG_BUF_SHIFT=14
+# CONFIG_CGROUPS is not set
+CONFIG_FAIR_GROUP_SCHED=y
+CONFIG_FAIR_USER_SCHED=y
+# CONFIG_FAIR_CGROUP_SCHED is not set
+CONFIG_SYSFS_DEPRECATED=y
+# CONFIG_RELAY is not set
+CONFIG_BLK_DEV_INITRD=y
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_SYSCTL=y
 CONFIG_EMBEDDED=y
+CONFIG_UID16=y
+CONFIG_SYSCTL_SYSCALL=y
 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_ANON_INODES=y
 CONFIG_EPOLL=y
+CONFIG_SIGNALFD=y
+CONFIG_EVENTFD=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_VM_EVENT_COUNTERS=y
+CONFIG_SLUB_DEBUG=y
+# CONFIG_SLAB is not set
+CONFIG_SLUB=y
+# CONFIG_SLOB is not set
+CONFIG_SLABINFO=y
+CONFIG_RT_MUTEXES=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
-
-#
-# Loadable module support
-#
 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=y
-
-#
-# Block layer
-#
+CONFIG_BLOCK=y
+# CONFIG_LBD is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_LSF is not set
+# CONFIG_BLK_DEV_BSG is not set
 
 #
 # IO Schedulers
@@ -81,28 +108,39 @@ CONFIG_DEFAULT_IOSCHED="anticipatory"
 #
 # System Type
 #
+# CONFIG_ARCH_AAEC2000 is not set
+# CONFIG_ARCH_INTEGRATOR is not set
+# CONFIG_ARCH_REALVIEW is not set
+# CONFIG_ARCH_VERSATILE is not set
+# CONFIG_ARCH_AT91 is not set
 # CONFIG_ARCH_CLPS7500 is not set
 # CONFIG_ARCH_CLPS711X is not set
 # CONFIG_ARCH_CO285 is not set
 # CONFIG_ARCH_EBSA110 is not set
+# CONFIG_ARCH_EP93XX is not set
 # CONFIG_ARCH_FOOTBRIDGE is not set
-# CONFIG_ARCH_INTEGRATOR is not set
-# CONFIG_ARCH_IOP3XX is not set
-CONFIG_ARCH_IXP4XX=y
+# CONFIG_ARCH_NETX is not set
+# CONFIG_ARCH_H720X is not set
+# CONFIG_ARCH_IMX is not set
+# CONFIG_ARCH_IOP13XX is not set
+# CONFIG_ARCH_IOP32X is not set
+# CONFIG_ARCH_IOP33X is not set
+# CONFIG_ARCH_IXP23XX is not set
 # CONFIG_ARCH_IXP2000 is not set
+CONFIG_ARCH_IXP4XX=y
 # CONFIG_ARCH_L7200 is not set
+# CONFIG_ARCH_KS8695 is not set
+# CONFIG_ARCH_NS9XXX is not set
+# CONFIG_ARCH_MXC is not set
+# CONFIG_ARCH_PNX4008 is not set
 # CONFIG_ARCH_PXA is not set
 # CONFIG_ARCH_RPC is not set
 # CONFIG_ARCH_SA1100 is not set
 # CONFIG_ARCH_S3C2410 is not set
 # CONFIG_ARCH_SHARK is not set
 # CONFIG_ARCH_LH7A40X is not set
+# CONFIG_ARCH_DAVINCI is not set
 # CONFIG_ARCH_OMAP is not set
-# CONFIG_ARCH_VERSATILE is not set
-# CONFIG_ARCH_REALVIEW is not set
-# CONFIG_ARCH_IMX is not set
-# CONFIG_ARCH_H720X is not set
-# CONFIG_ARCH_AAEC2000 is not set
 CONFIG_ARCH_SUPPORTS_BIG_ENDIAN=y
 
 #
@@ -112,8 +150,12 @@ CONFIG_ARCH_SUPPORTS_BIG_ENDIAN=y
 #
 # IXP4xx Platforms
 #
-CONFIG_ARCH_AVILA=y
+CONFIG_MACH_NSLU2=y
+CONFIG_MACH_AVILA=y
+CONFIG_MACH_LOFT=y
 CONFIG_ARCH_ADI_COYOTE=y
+CONFIG_MACH_GATEWAY7001=y
+CONFIG_MACH_WG302V2=y
 CONFIG_ARCH_IXDP425=y
 CONFIG_MACH_IXDPG425=y
 CONFIG_MACH_IXDP465=y
@@ -121,15 +163,27 @@ CONFIG_MACH_KIXRP435=y
 CONFIG_ARCH_IXCDP1100=y
 CONFIG_ARCH_PRPMC1100=y
 CONFIG_MACH_NAS100D=y
+CONFIG_MACH_DSMG600=y
 CONFIG_ARCH_IXDP4XX=y
 CONFIG_CPU_IXP46X=y
 CONFIG_CPU_IXP43X=y
-# CONFIG_MACH_GTWX5715 is not set
+CONFIG_MACH_GTWX5715=y
 
 #
 # IXP4xx Options
 #
+CONFIG_DMABOUNCE=y
 # CONFIG_IXP4XX_INDIRECT_PCI is not set
+CONFIG_IXP4XX_QMGR=y
+CONFIG_IXP4XX_NPE=y
+
+#
+# Boot options
+#
+
+#
+# Power management
+#
 
 #
 # Processor Type
@@ -140,33 +194,40 @@ CONFIG_CPU_32v5=y
 CONFIG_CPU_ABRT_EV5T=y
 CONFIG_CPU_CACHE_VIVT=y
 CONFIG_CPU_TLB_V4WBI=y
+CONFIG_CPU_CP15=y
+CONFIG_CPU_CP15_MMU=y
 
 #
 # Processor Features
 #
 # CONFIG_ARM_THUMB is not set
 CONFIG_CPU_BIG_ENDIAN=y
+# CONFIG_CPU_DCACHE_DISABLE is not set
+# CONFIG_OUTER_CACHE is not set
+# CONFIG_IWMMXT is not set
 CONFIG_XSCALE_PMU=y
-CONFIG_DMABOUNCE=y
 
 #
 # Bus support
 #
-CONFIG_ISA_DMA_API=y
 CONFIG_PCI=y
-CONFIG_PCI_LEGACY_PROC=y
+CONFIG_PCI_SYSCALL=y
+# CONFIG_ARCH_SUPPORTS_MSI is not set
+CONFIG_PCI_LEGACY=y
 # CONFIG_PCI_DEBUG is not set
-
-#
-# PCCARD (PCMCIA/CardBus) support
-#
 # CONFIG_PCCARD is not set
 
 #
 # Kernel Features
 #
+# CONFIG_TICK_ONESHOT is not set
+# CONFIG_NO_HZ is not set
+# CONFIG_HIGH_RES_TIMERS is not set
+CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
 # CONFIG_PREEMPT is not set
-# CONFIG_NO_IDLE_HZ is not set
+CONFIG_HZ=100
+CONFIG_AEABI=y
+CONFIG_OABI_COMPAT=y
 # CONFIG_ARCH_DISCONTIGMEM_ENABLE is not set
 CONFIG_SELECT_MEMORY_MODEL=y
 CONFIG_FLATMEM_MANUAL=y
@@ -175,7 +236,12 @@ CONFIG_FLATMEM_MANUAL=y
 CONFIG_FLATMEM=y
 CONFIG_FLAT_NODE_MEM_MAP=y
 # CONFIG_SPARSEMEM_STATIC is not set
+# CONFIG_SPARSEMEM_VMEMMAP_ENABLE is not set
 CONFIG_SPLIT_PTLOCK_CPUS=4096
+# CONFIG_RESOURCES_64BIT is not set
+CONFIG_ZONE_DMA_FLAG=1
+CONFIG_BOUNCE=y
+CONFIG_VIRT_TO_BUS=y
 CONFIG_ALIGNMENT_TRAP=y
 
 #
@@ -185,6 +251,7 @@ CONFIG_ZBOOT_ROM_TEXT=0x0
 CONFIG_ZBOOT_ROM_BSS=0x0
 CONFIG_CMDLINE="console=ttyS0,115200 ip=bootp root=/dev/nfs"
 # CONFIG_XIP_KERNEL is not set
+# CONFIG_KEXEC is not set
 
 #
 # Floating point emulation
@@ -203,13 +270,12 @@ CONFIG_FPE_NWFPE=y
 CONFIG_BINFMT_ELF=y
 # CONFIG_BINFMT_AOUT is not set
 # CONFIG_BINFMT_MISC is not set
-# CONFIG_ARTHUR is not set
 
 #
 # Power management options
 #
 # CONFIG_PM is not set
-# CONFIG_APM is not set
+CONFIG_SUSPEND_UP_POSSIBLE=y
 
 #
 # Networking
@@ -219,11 +285,13 @@ CONFIG_NET=y
 #
 # Networking options
 #
-CONFIG_PACKET=m
+CONFIG_PACKET=y
 CONFIG_PACKET_MMAP=y
 CONFIG_UNIX=y
 CONFIG_XFRM=y
 # CONFIG_XFRM_USER is not set
+# CONFIG_XFRM_SUB_POLICY is not set
+# CONFIG_XFRM_MIGRATE is not set
 # CONFIG_NET_KEY is not set
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
@@ -232,9 +300,7 @@ CONFIG_ASK_IP_FIB_HASH=y
 # CONFIG_IP_FIB_TRIE is not set
 CONFIG_IP_FIB_HASH=y
 CONFIG_IP_MULTIPLE_TABLES=y
-CONFIG_IP_ROUTE_FWMARK=y
 CONFIG_IP_ROUTE_MULTIPATH=y
-# CONFIG_IP_ROUTE_MULTIPATH_CACHED is not set
 CONFIG_IP_ROUTE_VERBOSE=y
 CONFIG_IP_PNP=y
 CONFIG_IP_PNP_DHCP=y
@@ -251,15 +317,18 @@ CONFIG_SYN_COOKIES=y
 # CONFIG_INET_AH is not set
 # CONFIG_INET_ESP is not set
 # CONFIG_INET_IPCOMP is not set
-CONFIG_INET_TUNNEL=m
+# CONFIG_INET_XFRM_TUNNEL is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_XFRM_MODE_TRANSPORT=y
+CONFIG_INET_XFRM_MODE_TUNNEL=y
+CONFIG_INET_XFRM_MODE_BEET=y
+# CONFIG_INET_LRO is not set
 CONFIG_INET_DIAG=y
 CONFIG_INET_TCP_DIAG=y
 # CONFIG_TCP_CONG_ADVANCED is not set
-CONFIG_TCP_CONG_BIC=y
-
-#
-# IP: Virtual Server Configuration
-#
+CONFIG_TCP_CONG_CUBIC=y
+CONFIG_DEFAULT_TCP_CONG="cubic"
+# CONFIG_TCP_MD5SIG is not set
 CONFIG_IP_VS=m
 CONFIG_IP_VS_DEBUG=y
 CONFIG_IP_VS_TAB_BITS=12
@@ -290,6 +359,9 @@ CONFIG_IP_VS_SH=m
 # IPVS application helper
 #
 # CONFIG_IPV6 is not set
+# CONFIG_INET6_XFRM_TUNNEL is not set
+# CONFIG_INET6_TUNNEL is not set
+# CONFIG_NETWORK_SECMARK is not set
 CONFIG_NETFILTER=y
 # CONFIG_NETFILTER_DEBUG is not set
 CONFIG_BRIDGE_NETFILTER=y
@@ -298,70 +370,57 @@ CONFIG_BRIDGE_NETFILTER=y
 # Core Netfilter Configuration
 #
 # CONFIG_NETFILTER_NETLINK is not set
+# CONFIG_NF_CONNTRACK_ENABLED is not set
+# CONFIG_NF_CONNTRACK is not set
+CONFIG_NETFILTER_XTABLES=m
+# CONFIG_NETFILTER_XT_TARGET_CLASSIFY is not set
+# CONFIG_NETFILTER_XT_TARGET_DSCP is not set
+# CONFIG_NETFILTER_XT_TARGET_MARK is not set
+# CONFIG_NETFILTER_XT_TARGET_NFQUEUE is not set
+# CONFIG_NETFILTER_XT_TARGET_NFLOG is not set
+# CONFIG_NETFILTER_XT_TARGET_TCPMSS is not set
+# CONFIG_NETFILTER_XT_MATCH_COMMENT is not set
+# CONFIG_NETFILTER_XT_MATCH_DCCP is not set
+# CONFIG_NETFILTER_XT_MATCH_DSCP is not set
+# CONFIG_NETFILTER_XT_MATCH_ESP is not set
+# CONFIG_NETFILTER_XT_MATCH_LENGTH is not set
+# CONFIG_NETFILTER_XT_MATCH_LIMIT is not set
+# CONFIG_NETFILTER_XT_MATCH_MAC is not set
+# CONFIG_NETFILTER_XT_MATCH_MARK is not set
+# CONFIG_NETFILTER_XT_MATCH_POLICY is not set
+# CONFIG_NETFILTER_XT_MATCH_MULTIPORT is not set
+# CONFIG_NETFILTER_XT_MATCH_PHYSDEV is not set
+# CONFIG_NETFILTER_XT_MATCH_PKTTYPE is not set
+# CONFIG_NETFILTER_XT_MATCH_QUOTA is not set
+# CONFIG_NETFILTER_XT_MATCH_REALM is not set
+# CONFIG_NETFILTER_XT_MATCH_SCTP is not set
+# CONFIG_NETFILTER_XT_MATCH_STATISTIC is not set
+# CONFIG_NETFILTER_XT_MATCH_STRING is not set
+# CONFIG_NETFILTER_XT_MATCH_TCPMSS is not set
+# CONFIG_NETFILTER_XT_MATCH_TIME is not set
+# CONFIG_NETFILTER_XT_MATCH_U32 is not set
+# CONFIG_NETFILTER_XT_MATCH_HASHLIMIT is not set
 
 #
 # IP: Netfilter Configuration
 #
-CONFIG_IP_NF_CONNTRACK=m
-# CONFIG_IP_NF_CT_ACCT is not set
-# CONFIG_IP_NF_CONNTRACK_MARK is not set
-# CONFIG_IP_NF_CONNTRACK_EVENTS is not set
-# CONFIG_IP_NF_CT_PROTO_SCTP is not set
-CONFIG_IP_NF_FTP=m
-CONFIG_IP_NF_IRC=m
-# CONFIG_IP_NF_NETBIOS_NS is not set
-# CONFIG_IP_NF_TFTP is not set
-# CONFIG_IP_NF_AMANDA is not set
-# CONFIG_IP_NF_PPTP is not set
 CONFIG_IP_NF_QUEUE=m
 CONFIG_IP_NF_IPTABLES=m
-CONFIG_IP_NF_MATCH_LIMIT=m
 # CONFIG_IP_NF_MATCH_IPRANGE is not set
-CONFIG_IP_NF_MATCH_MAC=m
-# CONFIG_IP_NF_MATCH_PKTTYPE is not set
-CONFIG_IP_NF_MATCH_MARK=m
-CONFIG_IP_NF_MATCH_MULTIPORT=m
 CONFIG_IP_NF_MATCH_TOS=m
 # CONFIG_IP_NF_MATCH_RECENT is not set
 # CONFIG_IP_NF_MATCH_ECN is not set
-# CONFIG_IP_NF_MATCH_DSCP is not set
-CONFIG_IP_NF_MATCH_AH_ESP=m
-CONFIG_IP_NF_MATCH_LENGTH=m
+# CONFIG_IP_NF_MATCH_AH is not set
 CONFIG_IP_NF_MATCH_TTL=m
-CONFIG_IP_NF_MATCH_TCPMSS=m
-# CONFIG_IP_NF_MATCH_HELPER is not set
-CONFIG_IP_NF_MATCH_STATE=m
-# CONFIG_IP_NF_MATCH_CONNTRACK is not set
 CONFIG_IP_NF_MATCH_OWNER=m
-# CONFIG_IP_NF_MATCH_PHYSDEV is not set
 # CONFIG_IP_NF_MATCH_ADDRTYPE is not set
-# CONFIG_IP_NF_MATCH_REALM is not set
-# CONFIG_IP_NF_MATCH_SCTP is not set
-# CONFIG_IP_NF_MATCH_DCCP is not set
-# CONFIG_IP_NF_MATCH_COMMENT is not set
-# CONFIG_IP_NF_MATCH_HASHLIMIT is not set
-# CONFIG_IP_NF_MATCH_STRING is not set
 CONFIG_IP_NF_FILTER=m
 CONFIG_IP_NF_TARGET_REJECT=m
 CONFIG_IP_NF_TARGET_LOG=m
 CONFIG_IP_NF_TARGET_ULOG=m
-CONFIG_IP_NF_TARGET_TCPMSS=m
-# CONFIG_IP_NF_TARGET_NFQUEUE is not set
-CONFIG_IP_NF_NAT=m
-CONFIG_IP_NF_NAT_NEEDED=y
-CONFIG_IP_NF_TARGET_MASQUERADE=m
-CONFIG_IP_NF_TARGET_REDIRECT=m
-# CONFIG_IP_NF_TARGET_NETMAP is not set
-# CONFIG_IP_NF_TARGET_SAME is not set
-CONFIG_IP_NF_NAT_SNMP_BASIC=m
-CONFIG_IP_NF_NAT_IRC=m
-CONFIG_IP_NF_NAT_FTP=m
 CONFIG_IP_NF_MANGLE=m
 CONFIG_IP_NF_TARGET_TOS=m
 # CONFIG_IP_NF_TARGET_ECN is not set
-# CONFIG_IP_NF_TARGET_DSCP is not set
-CONFIG_IP_NF_TARGET_MARK=m
-# CONFIG_IP_NF_TARGET_CLASSIFY is not set
 # CONFIG_IP_NF_TARGET_TTL is not set
 # CONFIG_IP_NF_RAW is not set
 CONFIG_IP_NF_ARPTABLES=m
@@ -372,16 +431,9 @@ CONFIG_IP_NF_ARPFILTER=m
 # Bridge: Netfilter Configuration
 #
 # CONFIG_BRIDGE_NF_EBTABLES is not set
-
-#
-# DCCP Configuration (EXPERIMENTAL)
-#
 # CONFIG_IP_DCCP is not set
-
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
 # CONFIG_IP_SCTP is not set
+# CONFIG_TIPC is not set
 CONFIG_ATM=y
 CONFIG_ATM_CLIP=y
 # CONFIG_ATM_CLIP_NO_ICMP is not set
@@ -397,25 +449,17 @@ CONFIG_LLC=m
 CONFIG_IPX=m
 # CONFIG_IPX_INTERN is not set
 CONFIG_ATALK=m
-CONFIG_DEV_APPLETALK=y
+CONFIG_DEV_APPLETALK=m
 CONFIG_IPDDP=m
 CONFIG_IPDDP_ENCAP=y
 CONFIG_IPDDP_DECAP=y
 CONFIG_X25=m
 CONFIG_LAPB=m
-# CONFIG_NET_DIVERT is not set
 CONFIG_ECONET=m
 CONFIG_ECONET_AUNUDP=y
 CONFIG_ECONET_NATIVE=y
 CONFIG_WAN_ROUTER=m
-
-#
-# QoS and/or fair queueing
-#
 CONFIG_NET_SCHED=y
-CONFIG_NET_SCH_CLK_JIFFIES=y
-# CONFIG_NET_SCH_CLK_GETTIMEOFDAY is not set
-# CONFIG_NET_SCH_CLK_CPU is not set
 
 #
 # Queueing/Scheduling
@@ -425,6 +469,7 @@ CONFIG_NET_SCH_HTB=m
 # CONFIG_NET_SCH_HFSC is not set
 # CONFIG_NET_SCH_ATM is not set
 CONFIG_NET_SCH_PRIO=m
+# CONFIG_NET_SCH_RR is not set
 CONFIG_NET_SCH_RED=m
 CONFIG_NET_SCH_SFQ=m
 CONFIG_NET_SCH_TEQL=m
@@ -449,10 +494,17 @@ CONFIG_NET_CLS_U32=m
 CONFIG_NET_CLS_RSVP=m
 CONFIG_NET_CLS_RSVP6=m
 # CONFIG_NET_EMATCH is not set
-# CONFIG_NET_CLS_ACT is not set
+CONFIG_NET_CLS_ACT=y
+CONFIG_NET_ACT_POLICE=y
+# CONFIG_NET_ACT_GACT is not set
+# CONFIG_NET_ACT_MIRRED is not set
+# CONFIG_NET_ACT_IPT is not set
+# CONFIG_NET_ACT_NAT is not set
+# CONFIG_NET_ACT_PEDIT is not set
+# CONFIG_NET_ACT_SIMP is not set
 CONFIG_NET_CLS_POLICE=y
 # CONFIG_NET_CLS_IND is not set
-CONFIG_NET_ESTIMATOR=y
+CONFIG_NET_SCH_FIFO=y
 
 #
 # Network testing
@@ -461,7 +513,18 @@ CONFIG_NET_PKTGEN=m
 # CONFIG_HAMRADIO is not set
 # CONFIG_IRDA is not set
 # CONFIG_BT is not set
+# CONFIG_AF_RXRPC is not set
+CONFIG_FIB_RULES=y
+
+#
+# Wireless
+#
+# CONFIG_CFG80211 is not set
+# CONFIG_WIRELESS_EXT is not set
+# CONFIG_MAC80211 is not set
 # CONFIG_IEEE80211 is not set
+# CONFIG_RFKILL is not set
+# CONFIG_NET_9P is not set
 
 #
 # Device Drivers
@@ -470,19 +533,14 @@ CONFIG_NET_PKTGEN=m
 #
 # Generic Driver Options
 #
+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
 CONFIG_STANDALONE=y
 CONFIG_PREVENT_FIRMWARE_BUILD=y
-# CONFIG_FW_LOADER is not set
+CONFIG_FW_LOADER=y
 # CONFIG_DEBUG_DRIVER is not set
-
-#
-# Connector - unified userspace <-> kernelspace linker
-#
+# CONFIG_DEBUG_DEVRES is not set
+# CONFIG_SYS_HYPERVISOR is not set
 # CONFIG_CONNECTOR is not set
-
-#
-# Memory Technology Devices (MTD)
-#
 CONFIG_MTD=y
 # CONFIG_MTD_DEBUG is not set
 # CONFIG_MTD_CONCAT is not set
@@ -498,11 +556,14 @@ CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-1
 # User Modules And Translation Layers
 #
 CONFIG_MTD_CHAR=y
+CONFIG_MTD_BLKDEVS=y
 CONFIG_MTD_BLOCK=y
 # CONFIG_FTL is not set
 # CONFIG_NFTL is not set
 # CONFIG_INFTL is not set
 # CONFIG_RFD_FTL is not set
+# CONFIG_SSFDC is not set
+# CONFIG_MTD_OOPS is not set
 
 #
 # RAM/ROM/Flash chip drivers
@@ -528,7 +589,6 @@ CONFIG_MTD_CFI_UTIL=y
 # CONFIG_MTD_RAM is not set
 # CONFIG_MTD_ROM is not set
 # CONFIG_MTD_ABSENT is not set
-# CONFIG_MTD_XIP is not set
 
 #
 # Mapping drivers for chip access
@@ -538,6 +598,7 @@ CONFIG_MTD_COMPLEX_MAPPINGS=y
 # CONFIG_MTD_ARM_INTEGRATOR is not set
 CONFIG_MTD_IXP4XX=y
 # CONFIG_MTD_PCI is not set
+# CONFIG_MTD_INTEL_VR_NOR is not set
 # CONFIG_MTD_PLATRAM is not set
 
 #
@@ -547,7 +608,6 @@ CONFIG_MTD_IXP4XX=y
 # CONFIG_MTD_SLRAM is not set
 # CONFIG_MTD_PHRAM is not set
 # CONFIG_MTD_MTDRAM is not set
-# CONFIG_MTD_BLKMTD is not set
 # CONFIG_MTD_BLOCK2MTD is not set
 
 #
@@ -556,33 +616,24 @@ CONFIG_MTD_IXP4XX=y
 # CONFIG_MTD_DOC2000 is not set
 # CONFIG_MTD_DOC2001 is not set
 # CONFIG_MTD_DOC2001PLUS is not set
-
-#
-# NAND Flash Device Drivers
-#
 CONFIG_MTD_NAND=m
 # CONFIG_MTD_NAND_VERIFY_WRITE is not set
+# CONFIG_MTD_NAND_ECC_SMC is not set
+# CONFIG_MTD_NAND_MUSEUM_IDS is not set
 CONFIG_MTD_NAND_IDS=m
 # CONFIG_MTD_NAND_DISKONCHIP is not set
+# CONFIG_MTD_NAND_CAFE is not set
 # CONFIG_MTD_NAND_NANDSIM is not set
-
-#
-# OneNAND Flash Device Drivers
-#
+# CONFIG_MTD_NAND_PLATFORM is not set
+# CONFIG_MTD_ALAUDA is not set
 # CONFIG_MTD_ONENAND is not set
 
 #
-# Parallel port support
+# UBI - Unsorted block images
 #
+# CONFIG_MTD_UBI is not set
 # CONFIG_PARPORT is not set
-
-#
-# Plug and Play support
-#
-
-#
-# Block devices
-#
+CONFIG_BLK_DEV=y
 # CONFIG_BLK_CPQ_DA is not set
 # CONFIG_BLK_CPQ_CISS_DA is not set
 # CONFIG_BLK_DEV_DAC960 is not set
@@ -592,17 +643,20 @@ CONFIG_BLK_DEV_LOOP=y
 # CONFIG_BLK_DEV_CRYPTOLOOP is not set
 # CONFIG_BLK_DEV_NBD is not set
 # CONFIG_BLK_DEV_SX8 is not set
+# CONFIG_BLK_DEV_UB is not set
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=8192
-CONFIG_BLK_DEV_INITRD=y
+CONFIG_BLK_DEV_RAM_BLOCKSIZE=1024
 # CONFIG_CDROM_PKTCDVD is not set
 # CONFIG_ATA_OVER_ETH is not set
-
-#
-# ATA/ATAPI/MFM/RLL support
-#
+CONFIG_MISC_DEVICES=y
+# CONFIG_PHANTOM is not set
+# CONFIG_EEPROM_93CX6 is not set
+# CONFIG_SGI_IOC4 is not set
+# CONFIG_TIFM_CORE is not set
 CONFIG_IDE=y
+CONFIG_IDE_MAX_HWIFS=4
 CONFIG_BLK_DEV_IDE=y
 
 #
@@ -614,24 +668,28 @@ CONFIG_BLK_DEV_IDEDISK=y
 # CONFIG_BLK_DEV_IDECD is not set
 # CONFIG_BLK_DEV_IDETAPE is not set
 # CONFIG_BLK_DEV_IDEFLOPPY is not set
+# CONFIG_BLK_DEV_IDESCSI is not set
 # CONFIG_IDE_TASK_IOCTL is not set
+CONFIG_IDE_PROC_FS=y
 
 #
 # IDE chipset support/bugfixes
 #
 CONFIG_IDE_GENERIC=y
+# CONFIG_BLK_DEV_PLATFORM is not set
+
+#
+# PCI IDE chipsets support
+#
 CONFIG_BLK_DEV_IDEPCI=y
 # CONFIG_IDEPCI_SHARE_IRQ is not set
+CONFIG_IDEPCI_PCIBUS_ORDER=y
 # CONFIG_BLK_DEV_OFFBOARD is not set
 # CONFIG_BLK_DEV_GENERIC is not set
 # CONFIG_BLK_DEV_OPTI621 is not set
-# CONFIG_BLK_DEV_SL82C105 is not set
 CONFIG_BLK_DEV_IDEDMA_PCI=y
-# CONFIG_BLK_DEV_IDEDMA_FORCED is not set
-# CONFIG_IDEDMA_PCI_AUTO is not set
 # CONFIG_BLK_DEV_AEC62XX is not set
 # CONFIG_BLK_DEV_ALI15X3 is not set
-# CONFIG_BLK_DEV_AMD74XX is not set
 CONFIG_BLK_DEV_CMD64X=y
 # CONFIG_BLK_DEV_TRIFLEX is not set
 # CONFIG_BLK_DEV_CY82C693 is not set
@@ -639,93 +697,163 @@ CONFIG_BLK_DEV_CMD64X=y
 # CONFIG_BLK_DEV_CS5530 is not set
 # CONFIG_BLK_DEV_HPT34X is not set
 CONFIG_BLK_DEV_HPT366=y
+# CONFIG_BLK_DEV_JMICRON is not set
 # CONFIG_BLK_DEV_SC1200 is not set
 # CONFIG_BLK_DEV_PIIX is not set
+# CONFIG_BLK_DEV_IT8213 is not set
 # CONFIG_BLK_DEV_IT821X is not set
 # CONFIG_BLK_DEV_NS87415 is not set
 # CONFIG_BLK_DEV_PDC202XX_OLD is not set
 CONFIG_BLK_DEV_PDC202XX_NEW=y
-# CONFIG_PDC202XX_FORCE is not set
 # CONFIG_BLK_DEV_SVWKS is not set
 # CONFIG_BLK_DEV_SIIMAGE is not set
+# CONFIG_BLK_DEV_SL82C105 is not set
 # CONFIG_BLK_DEV_SLC90E66 is not set
 # CONFIG_BLK_DEV_TRM290 is not set
 # CONFIG_BLK_DEV_VIA82CXXX is not set
+# CONFIG_BLK_DEV_TC86C001 is not set
 # CONFIG_IDE_ARM is not set
 CONFIG_BLK_DEV_IDEDMA=y
-# CONFIG_IDEDMA_IVB is not set
-# CONFIG_IDEDMA_AUTO is not set
+CONFIG_IDE_ARCH_OBSOLETE_INIT=y
 # CONFIG_BLK_DEV_HD is not set
 
 #
 # SCSI device support
 #
 # CONFIG_RAID_ATTRS is not set
-# CONFIG_SCSI is not set
-
-#
-# Multi-device support (RAID and LVM)
-#
+CONFIG_SCSI=y
+CONFIG_SCSI_DMA=y
+# CONFIG_SCSI_TGT is not set
+# CONFIG_SCSI_NETLINK is not set
+# CONFIG_SCSI_PROC_FS is not set
+
+#
+# SCSI support type (disk, tape, CD-ROM)
+#
+CONFIG_BLK_DEV_SD=y
+# CONFIG_CHR_DEV_ST is not set
+# CONFIG_CHR_DEV_OSST is not set
+# CONFIG_BLK_DEV_SR is not set
+# CONFIG_CHR_DEV_SG is not set
+# CONFIG_CHR_DEV_SCH is not set
+
+#
+# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
+#
+# CONFIG_SCSI_MULTI_LUN is not set
+# CONFIG_SCSI_CONSTANTS is not set
+# CONFIG_SCSI_LOGGING is not set
+# CONFIG_SCSI_SCAN_ASYNC is not set
+CONFIG_SCSI_WAIT_SCAN=m
+
+#
+# SCSI Transports
+#
+# CONFIG_SCSI_SPI_ATTRS is not set
+# CONFIG_SCSI_FC_ATTRS is not set
+# CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_LIBSAS is not set
+# CONFIG_SCSI_SRP_ATTRS is not set
+# CONFIG_SCSI_LOWLEVEL is not set
+CONFIG_ATA=y
+# CONFIG_ATA_NONSTANDARD is not set
+# CONFIG_SATA_AHCI is not set
+# CONFIG_SATA_SVW is not set
+# CONFIG_ATA_PIIX is not set
+# CONFIG_SATA_MV is not set
+# CONFIG_SATA_NV is not set
+# CONFIG_PDC_ADMA is not set
+# CONFIG_SATA_QSTOR is not set
+# CONFIG_SATA_PROMISE is not set
+# CONFIG_SATA_SX4 is not set
+# CONFIG_SATA_SIL is not set
+# CONFIG_SATA_SIL24 is not set
+# CONFIG_SATA_SIS is not set
+# CONFIG_SATA_ULI is not set
+# CONFIG_SATA_VIA is not set
+# CONFIG_SATA_VITESSE is not set
+# CONFIG_SATA_INIC162X is not set
+# CONFIG_PATA_ALI is not set
+# CONFIG_PATA_AMD is not set
+CONFIG_PATA_ARTOP=y
+# CONFIG_PATA_ATIIXP is not set
+# CONFIG_PATA_CMD640_PCI is not set
+# CONFIG_PATA_CMD64X is not set
+# CONFIG_PATA_CS5520 is not set
+# CONFIG_PATA_CS5530 is not set
+# CONFIG_PATA_CYPRESS is not set
+# CONFIG_PATA_EFAR is not set
+# CONFIG_ATA_GENERIC is not set
+# CONFIG_PATA_HPT366 is not set
+# CONFIG_PATA_HPT37X is not set
+# CONFIG_PATA_HPT3X2N is not set
+# CONFIG_PATA_HPT3X3 is not set
+# CONFIG_PATA_IT821X is not set
+# CONFIG_PATA_IT8213 is not set
+# CONFIG_PATA_JMICRON is not set
+# CONFIG_PATA_TRIFLEX is not set
+# CONFIG_PATA_MARVELL is not set
+# CONFIG_PATA_MPIIX is not set
+# CONFIG_PATA_OLDPIIX is not set
+# CONFIG_PATA_NETCELL is not set
+# CONFIG_PATA_NS87410 is not set
+# CONFIG_PATA_NS87415 is not set
+# CONFIG_PATA_OPTI is not set
+# CONFIG_PATA_OPTIDMA is not set
+# CONFIG_PATA_PDC_OLD is not set
+# CONFIG_PATA_RADISYS is not set
+# CONFIG_PATA_RZ1000 is not set
+# CONFIG_PATA_SC1200 is not set
+# CONFIG_PATA_SERVERWORKS is not set
+# CONFIG_PATA_PDC2027X is not set
+# CONFIG_PATA_SIL680 is not set
+# CONFIG_PATA_SIS is not set
+# CONFIG_PATA_VIA is not set
+# CONFIG_PATA_WINBOND is not set
+# CONFIG_PATA_PLATFORM is not set
+CONFIG_PATA_IXP4XX_CF=y
 # CONFIG_MD is not set
-
-#
-# Fusion MPT device support
-#
 # CONFIG_FUSION is not set
 
 #
 # IEEE 1394 (FireWire) support
 #
+# CONFIG_FIREWIRE is not set
 # CONFIG_IEEE1394 is not set
-
-#
-# I2O device support
-#
 # CONFIG_I2O is not set
-
-#
-# Network device support
-#
 CONFIG_NETDEVICES=y
+# CONFIG_NETDEVICES_MULTIQUEUE is not set
+# CONFIG_IFB is not set
 CONFIG_DUMMY=y
 # CONFIG_BONDING is not set
+# CONFIG_MACVLAN is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
-
-#
-# ARCnet devices
-#
+# CONFIG_VETH is not set
 # CONFIG_ARCNET is not set
-
-#
-# PHY device support
-#
 # CONFIG_PHYLIB is not set
-
-#
-# Ethernet (10 or 100Mbit)
-#
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=y
+CONFIG_IXP4XX_ETH=y
+# CONFIG_AX88796 is not set
 # CONFIG_HAPPYMEAL is not set
 # CONFIG_SUNGEM is not set
 # CONFIG_CASSINI is not set
 # CONFIG_NET_VENDOR_3COM is not set
 # CONFIG_SMC91X is not set
 # CONFIG_DM9000 is not set
-
-#
-# Tulip family network device support
-#
 # CONFIG_NET_TULIP is not set
 # CONFIG_HP100 is not set
+# CONFIG_IBM_NEW_EMAC_ZMII is not set
+# CONFIG_IBM_NEW_EMAC_RGMII is not set
+# CONFIG_IBM_NEW_EMAC_TAH is not set
+# CONFIG_IBM_NEW_EMAC_EMAC4 is not set
 CONFIG_NET_PCI=y
 # CONFIG_PCNET32 is not set
 # CONFIG_AMD8111_ETH is not set
 # CONFIG_ADAPTEC_STARFIRE is not set
 # CONFIG_B44 is not set
 # CONFIG_FORCEDETH is not set
-# CONFIG_DGRS is not set
 CONFIG_EEPRO100=y
 # CONFIG_E100 is not set
 # CONFIG_FEALNX is not set
@@ -738,93 +866,76 @@ CONFIG_EEPRO100=y
 # CONFIG_SUNDANCE is not set
 # CONFIG_TLAN is not set
 # CONFIG_VIA_RHINE is not set
-
-#
-# Ethernet (1000 Mbit)
-#
+# CONFIG_SC92031 is not set
+CONFIG_NETDEV_1000=y
 # CONFIG_ACENIC is not set
 # CONFIG_DL2K is not set
 # CONFIG_E1000 is not set
+# CONFIG_E1000E is not set
+# CONFIG_IP1000 is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
 # CONFIG_R8169 is not set
 # CONFIG_SIS190 is not set
 # CONFIG_SKGE is not set
+# CONFIG_SKY2 is not set
 # CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
 # CONFIG_TIGON3 is not set
 # CONFIG_BNX2 is not set
-
-#
-# Ethernet (10000 Mbit)
-#
+# CONFIG_QLA3XXX is not set
+# CONFIG_ATL1 is not set
+CONFIG_NETDEV_10000=y
 # CONFIG_CHELSIO_T1 is not set
+# CONFIG_CHELSIO_T3 is not set
+# CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
-
-#
-# Token Ring devices
-#
+# CONFIG_MYRI10GE is not set
+# CONFIG_NETXEN_NIC is not set
+# CONFIG_NIU is not set
+# CONFIG_MLX4_CORE is not set
+# CONFIG_TEHUTI is not set
 # CONFIG_TR is not set
 
 #
-# Wireless LAN (non-hamradio)
-#
-CONFIG_NET_RADIO=y
-
-#
-# Obsolete Wireless cards support (pre-802.11)
-#
-# CONFIG_STRIP is not set
-
-#
-# Wireless 802.11b ISA/PCI cards support
-#
-# CONFIG_AIRO is not set
-CONFIG_HERMES=y
-# CONFIG_PLX_HERMES is not set
-# CONFIG_TMD_HERMES is not set
-# CONFIG_NORTEL_HERMES is not set
-CONFIG_PCI_HERMES=y
-# CONFIG_ATMEL is not set
-
-#
-# Prism GT/Duette 802.11(a/b/g) PCI/Cardbus support
+# Wireless LAN
 #
-# CONFIG_PRISM54 is not set
-# CONFIG_HOSTAP is not set
-CONFIG_NET_WIRELESS=y
+# CONFIG_WLAN_PRE80211 is not set
+# CONFIG_WLAN_80211 is not set
 
 #
-# Wan interfaces
+# USB Network Adapters
 #
+# CONFIG_USB_CATC is not set
+# CONFIG_USB_KAWETH is not set
+# CONFIG_USB_PEGASUS is not set
+# CONFIG_USB_RTL8150 is not set
+# CONFIG_USB_USBNET is not set
 CONFIG_WAN=y
-# CONFIG_DSCC4 is not set
 # CONFIG_LANMEDIA is not set
-# CONFIG_SYNCLINK_SYNCPPP is not set
 CONFIG_HDLC=m
-CONFIG_HDLC_RAW=y
+CONFIG_HDLC_RAW=m
 # CONFIG_HDLC_RAW_ETH is not set
-CONFIG_HDLC_CISCO=y
-CONFIG_HDLC_FR=y
-CONFIG_HDLC_PPP=y
-CONFIG_HDLC_X25=y
+CONFIG_HDLC_CISCO=m
+CONFIG_HDLC_FR=m
+CONFIG_HDLC_PPP=m
+CONFIG_HDLC_X25=m
 # CONFIG_PCI200SYN is not set
 # CONFIG_WANXL is not set
 # CONFIG_PC300 is not set
+# CONFIG_PC300TOO is not set
 # CONFIG_FARSYNC is not set
+# CONFIG_DSCC4 is not set
+# CONFIG_IXP4XX_HSS is not set
 CONFIG_DLCI=m
-CONFIG_DLCI_COUNT=24
 CONFIG_DLCI_MAX=8
-CONFIG_WAN_ROUTER_DRIVERS=y
+CONFIG_WAN_ROUTER_DRIVERS=m
 # CONFIG_CYCLADES_SYNC is not set
 # CONFIG_LAPBETHER is not set
 # CONFIG_X25_ASY is not set
-
-#
-# ATM drivers
-#
+CONFIG_ATM_DRIVERS=y
 # CONFIG_ATM_DUMMY is not set
 CONFIG_ATM_TCP=m
 # CONFIG_ATM_LANAI is not set
@@ -842,20 +953,19 @@ CONFIG_ATM_TCP=m
 # CONFIG_HIPPI is not set
 # CONFIG_PPP is not set
 # CONFIG_SLIP is not set
+# CONFIG_NET_FC 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
-#
 # CONFIG_ISDN is not set
 
 #
 # Input device support
 #
 CONFIG_INPUT=y
+# CONFIG_INPUT_FF_MEMLESS is not set
+# CONFIG_INPUT_POLLDEV is not set
 
 #
 # Userland interfaces
@@ -865,7 +975,6 @@ CONFIG_INPUT_MOUSEDEV_PSAUX=y
 CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
 CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 # CONFIG_INPUT_JOYDEV is not set
-# CONFIG_INPUT_TSDEV is not set
 # CONFIG_INPUT_EVDEV is not set
 # CONFIG_INPUT_EVBUG is not set
 
@@ -875,8 +984,16 @@ CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 # CONFIG_INPUT_KEYBOARD is not set
 # CONFIG_INPUT_MOUSE is not set
 # CONFIG_INPUT_JOYSTICK is not set
+# CONFIG_INPUT_TABLET is not set
 # CONFIG_INPUT_TOUCHSCREEN is not set
-# CONFIG_INPUT_MISC is not set
+CONFIG_INPUT_MISC=y
+CONFIG_INPUT_IXP4XX_BEEPER=y
+# CONFIG_INPUT_ATI_REMOTE is not set
+# CONFIG_INPUT_ATI_REMOTE2 is not set
+# CONFIG_INPUT_KEYSPAN_REMOTE is not set
+# CONFIG_INPUT_POWERMATE is not set
+# CONFIG_INPUT_YEALINK is not set
+# CONFIG_INPUT_UINPUT is not set
 
 #
 # Hardware I/O ports
@@ -895,7 +1012,9 @@ CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 #
 CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_PCI=y
 CONFIG_SERIAL_8250_NR_UARTS=2
+CONFIG_SERIAL_8250_RUNTIME_UARTS=2
 # CONFIG_SERIAL_8250_EXTENDED is not set
 
 #
@@ -907,51 +1026,17 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
-
-#
-# IPMI
-#
 # CONFIG_IPMI_HANDLER is not set
-
-#
-# Watchdog Cards
-#
-CONFIG_WATCHDOG=y
-# CONFIG_WATCHDOG_NOWAYOUT is not set
-
-#
-# Watchdog Device Drivers
-#
-# CONFIG_SOFT_WATCHDOG is not set
-CONFIG_IXP4XX_WATCHDOG=y
-
-#
-# PCI-based Watchdog Cards
-#
-# CONFIG_PCIPCWATCHDOG is not set
-# CONFIG_WDTPCI is not set
+CONFIG_HW_RANDOM=m
+CONFIG_HW_RANDOM_IXP4XX=m
 # CONFIG_NVRAM is not set
-# CONFIG_RTC is not set
-# CONFIG_DTLK is not set
 # CONFIG_R3964 is not set
 # CONFIG_APPLICOM is not set
-
-#
-# 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_DEVPORT=y
 CONFIG_I2C=y
+CONFIG_I2C_BOARDINFO=y
 CONFIG_I2C_CHARDEV=y
 
 #
@@ -969,57 +1054,68 @@ CONFIG_I2C_ALGOBIT=y
 # CONFIG_I2C_ALI15X3 is not set
 # CONFIG_I2C_AMD756 is not set
 # CONFIG_I2C_AMD8111 is not set
+# CONFIG_I2C_GPIO is not set
 # CONFIG_I2C_I801 is not set
 # CONFIG_I2C_I810 is not set
 # CONFIG_I2C_PIIX4 is not set
 # CONFIG_I2C_IOP3XX is not set
 CONFIG_I2C_IXP4XX=y
 # CONFIG_I2C_NFORCE2 is not set
+# CONFIG_I2C_OCORES is not set
 # CONFIG_I2C_PARPORT_LIGHT is not set
 # CONFIG_I2C_PROSAVAGE is not set
 # CONFIG_I2C_SAVAGE4 is not set
-# CONFIG_SCx200_ACB is not set
+# CONFIG_I2C_SIMTEC is not set
 # CONFIG_I2C_SIS5595 is not set
 # CONFIG_I2C_SIS630 is not set
 # CONFIG_I2C_SIS96X is not set
+# CONFIG_I2C_TAOS_EVM is not set
 # CONFIG_I2C_STUB is not set
+# CONFIG_I2C_TINY_USB is not set
 # CONFIG_I2C_VIA is not set
 # CONFIG_I2C_VIAPRO is not set
 # CONFIG_I2C_VOODOO3 is not set
-# CONFIG_I2C_PCA_ISA is not set
 
 #
 # Miscellaneous I2C Chip support
 #
 # CONFIG_SENSORS_DS1337 is not set
 # CONFIG_SENSORS_DS1374 is not set
+# CONFIG_DS1682 is not set
 CONFIG_SENSORS_EEPROM=y
 # CONFIG_SENSORS_PCF8574 is not set
 # CONFIG_SENSORS_PCA9539 is not set
 # CONFIG_SENSORS_PCF8591 is not set
-# CONFIG_SENSORS_RTC8564 is not set
 # CONFIG_SENSORS_MAX6875 is not set
-# CONFIG_RTC_X1205_I2C is not set
+# CONFIG_SENSORS_TSL2550 is not set
 # CONFIG_I2C_DEBUG_CORE is not set
 # CONFIG_I2C_DEBUG_ALGO is not set
 # CONFIG_I2C_DEBUG_BUS is not set
 # CONFIG_I2C_DEBUG_CHIP is not set
 
 #
-# Hardware Monitoring support
+# SPI support
 #
+# CONFIG_SPI is not set
+# CONFIG_SPI_MASTER is not set
+# CONFIG_W1 is not set
+# CONFIG_POWER_SUPPLY is not set
 CONFIG_HWMON=y
 # CONFIG_HWMON_VID is not set
+# CONFIG_SENSORS_AD7418 is not set
 # CONFIG_SENSORS_ADM1021 is not set
 # CONFIG_SENSORS_ADM1025 is not set
 # CONFIG_SENSORS_ADM1026 is not set
+# CONFIG_SENSORS_ADM1029 is not set
 # CONFIG_SENSORS_ADM1031 is not set
 # CONFIG_SENSORS_ADM9240 is not set
-# CONFIG_SENSORS_ASB100 is not set
+# CONFIG_SENSORS_ADT7470 is not set
 # CONFIG_SENSORS_ATXP1 is not set
 # CONFIG_SENSORS_DS1621 is not set
-# CONFIG_SENSORS_FSCHER is not set
-# CONFIG_SENSORS_FSCPOS is not set
+# CONFIG_SENSORS_I5K_AMB is not set
+# CONFIG_SENSORS_F71805F is not set
+# CONFIG_SENSORS_F71882FG is not set
+# CONFIG_SENSORS_F75375S is not set
 # CONFIG_SENSORS_GL518SM is not set
 # CONFIG_SENSORS_GL520SM is not set
 # CONFIG_SENSORS_IT87 is not set
@@ -1033,67 +1129,268 @@ CONFIG_HWMON=y
 # CONFIG_SENSORS_LM87 is not set
 # CONFIG_SENSORS_LM90 is not set
 # CONFIG_SENSORS_LM92 is not set
+# CONFIG_SENSORS_LM93 is not set
 # CONFIG_SENSORS_MAX1619 is not set
+# CONFIG_SENSORS_MAX6650 is not set
 # CONFIG_SENSORS_PC87360 is not set
+# CONFIG_SENSORS_PC87427 is not set
 # CONFIG_SENSORS_SIS5595 is not set
+# CONFIG_SENSORS_DME1737 is not set
 # CONFIG_SENSORS_SMSC47M1 is not set
+# CONFIG_SENSORS_SMSC47M192 is not set
 # CONFIG_SENSORS_SMSC47B397 is not set
+# CONFIG_SENSORS_THMC50 is not set
 # CONFIG_SENSORS_VIA686A is not set
+# CONFIG_SENSORS_VT1211 is not set
+# CONFIG_SENSORS_VT8231 is not set
 # CONFIG_SENSORS_W83781D is not set
+# CONFIG_SENSORS_W83791D is not set
 # CONFIG_SENSORS_W83792D is not set
+# CONFIG_SENSORS_W83793 is not set
 # CONFIG_SENSORS_W83L785TS is not set
 # CONFIG_SENSORS_W83627HF is not set
 # CONFIG_SENSORS_W83627EHF is not set
 # CONFIG_HWMON_DEBUG_CHIP is not set
+CONFIG_WATCHDOG=y
+# CONFIG_WATCHDOG_NOWAYOUT is not set
 
 #
-# Misc devices
+# Watchdog Device Drivers
 #
+# CONFIG_SOFT_WATCHDOG is not set
+CONFIG_IXP4XX_WATCHDOG=y
 
 #
-# Multimedia Capabilities Port drivers
+# PCI-based Watchdog Cards
 #
+# CONFIG_PCIPCWATCHDOG is not set
+# CONFIG_WDTPCI is not set
 
 #
-# Multimedia devices
+# USB-based Watchdog Cards
 #
-# CONFIG_VIDEO_DEV is not set
+# CONFIG_USBPCWATCHDOG is not set
 
 #
-# Digital Video Broadcasting Devices
+# Sonics Silicon Backplane
 #
-# CONFIG_DVB is not set
+CONFIG_SSB_POSSIBLE=y
+# CONFIG_SSB is not set
+
+#
+# Multifunction device drivers
+#
+# CONFIG_MFD_SM501 is not set
+
+#
+# Multimedia devices
+#
+# CONFIG_VIDEO_DEV is not set
+# CONFIG_DVB_CORE is not set
+CONFIG_DAB=y
+# CONFIG_USB_DABUSB is not set
 
 #
 # Graphics support
 #
+# CONFIG_DRM is not set
+# CONFIG_VGASTATE is not set
+# CONFIG_VIDEO_OUTPUT_CONTROL is not set
 # CONFIG_FB is not set
+# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
+
+#
+# Display device support
+#
+# CONFIG_DISPLAY_SUPPORT is not set
 
 #
 # Sound
 #
 # CONFIG_SOUND is not set
+CONFIG_HID_SUPPORT=y
+CONFIG_HID=y
+# CONFIG_HID_DEBUG is not set
+# CONFIG_HIDRAW is not set
 
 #
-# USB support
+# USB Input Devices
 #
+CONFIG_USB_HID=y
+# CONFIG_USB_HIDINPUT_POWERBOOK is not set
+# CONFIG_HID_FF is not set
+# CONFIG_USB_HIDDEV is not set
+CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
-# CONFIG_USB is not set
+CONFIG_USB_ARCH_HAS_EHCI=y
+CONFIG_USB=y
+# CONFIG_USB_DEBUG is not set
+
+#
+# Miscellaneous USB options
+#
+CONFIG_USB_DEVICEFS=y
+# CONFIG_USB_DEVICE_CLASS is not set
+# CONFIG_USB_DYNAMIC_MINORS is not set
+# CONFIG_USB_OTG is not set
+
+#
+# USB Host Controller Drivers
+#
+CONFIG_USB_EHCI_HCD=y
+# CONFIG_USB_EHCI_SPLIT_ISO is not set
+# CONFIG_USB_EHCI_ROOT_HUB_TT is not set
+# CONFIG_USB_EHCI_TT_NEWSCHED is not set
+# CONFIG_USB_ISP116X_HCD is not set
+CONFIG_USB_OHCI_HCD=y
+# CONFIG_USB_OHCI_BIG_ENDIAN_DESC is not set
+# CONFIG_USB_OHCI_BIG_ENDIAN_MMIO is not set
+CONFIG_USB_OHCI_LITTLE_ENDIAN=y
+CONFIG_USB_UHCI_HCD=y
+# CONFIG_USB_SL811_HCD is not set
+# CONFIG_USB_R8A66597_HCD is not set
+
+#
+# USB Device Class drivers
+#
+# CONFIG_USB_ACM is not set
+# CONFIG_USB_PRINTER is not set
 
 #
 # NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
 #
 
 #
+# may also be needed; see USB_STORAGE Help for more information
+#
+CONFIG_USB_STORAGE=y
+# CONFIG_USB_STORAGE_DEBUG is not set
+# CONFIG_USB_STORAGE_DATAFAB is not set
+# CONFIG_USB_STORAGE_FREECOM is not set
+# CONFIG_USB_STORAGE_ISD200 is not set
+# CONFIG_USB_STORAGE_DPCM is not set
+# CONFIG_USB_STORAGE_USBAT is not set
+# CONFIG_USB_STORAGE_SDDR09 is not set
+# CONFIG_USB_STORAGE_SDDR55 is not set
+# CONFIG_USB_STORAGE_JUMPSHOT is not set
+# CONFIG_USB_STORAGE_ALAUDA is not set
+# CONFIG_USB_STORAGE_KARMA is not set
+# CONFIG_USB_LIBUSUAL is not set
+
+#
+# USB Imaging devices
+#
+# CONFIG_USB_MDC800 is not set
+# CONFIG_USB_MICROTEK is not set
+# CONFIG_USB_MON is not set
+
+#
+# USB port drivers
+#
+
+#
+# USB Serial Converter support
+#
+# CONFIG_USB_SERIAL is not set
+
+#
+# USB Miscellaneous drivers
+#
+# CONFIG_USB_EMI62 is not set
+# CONFIG_USB_EMI26 is not set
+# CONFIG_USB_ADUTUX is not set
+# CONFIG_USB_AUERSWALD is not set
+# CONFIG_USB_RIO500 is not set
+# CONFIG_USB_LEGOTOWER is not set
+# CONFIG_USB_LCD is not set
+# CONFIG_USB_BERRY_CHARGE is not set
+# CONFIG_USB_LED is not set
+# CONFIG_USB_CYPRESS_CY7C63 is not set
+# CONFIG_USB_CYTHERM is not set
+# CONFIG_USB_PHIDGET is not set
+# CONFIG_USB_IDMOUSE is not set
+# CONFIG_USB_FTDI_ELAN is not set
+# CONFIG_USB_APPLEDISPLAY is not set
+# CONFIG_USB_SISUSBVGA is not set
+# CONFIG_USB_LD is not set
+# CONFIG_USB_TRANCEVIBRATOR is not set
+# CONFIG_USB_IOWARRIOR is not set
+# CONFIG_USB_TEST is not set
+
+#
+# USB DSL modem support
+#
+# CONFIG_USB_ATM is not set
+
+#
 # USB Gadget Support
 #
 # CONFIG_USB_GADGET is not set
+# CONFIG_MMC is not set
+CONFIG_NEW_LEDS=y
+CONFIG_LEDS_CLASS=y
 
 #
-# MMC/SD Card support
+# LED drivers
+#
+# CONFIG_LEDS_IXP4XX is not set
+CONFIG_LEDS_GPIO=y
+
+#
+# LED Triggers
+#
+CONFIG_LEDS_TRIGGERS=y
+CONFIG_LEDS_TRIGGER_TIMER=y
+CONFIG_LEDS_TRIGGER_IDE_DISK=y
+CONFIG_LEDS_TRIGGER_HEARTBEAT=y
+CONFIG_RTC_LIB=y
+CONFIG_RTC_CLASS=y
+CONFIG_RTC_HCTOSYS=y
+CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
+# CONFIG_RTC_DEBUG is not set
+
+#
+# RTC interfaces
+#
+CONFIG_RTC_INTF_SYSFS=y
+CONFIG_RTC_INTF_PROC=y
+CONFIG_RTC_INTF_DEV=y
+# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set
+# CONFIG_RTC_DRV_TEST is not set
+
+#
+# I2C RTC drivers
+#
+# CONFIG_RTC_DRV_DS1307 is not set
+# CONFIG_RTC_DRV_DS1374 is not set
+# CONFIG_RTC_DRV_DS1672 is not set
+# CONFIG_RTC_DRV_MAX6900 is not set
+# CONFIG_RTC_DRV_RS5C372 is not set
+# CONFIG_RTC_DRV_ISL1208 is not set
+CONFIG_RTC_DRV_X1205=y
+CONFIG_RTC_DRV_PCF8563=y
+# CONFIG_RTC_DRV_PCF8583 is not set
+# CONFIG_RTC_DRV_M41T80 is not set
+
+#
+# SPI RTC drivers
+#
+
+#
+# Platform RTC drivers
+#
+# CONFIG_RTC_DRV_CMOS is not set
+# CONFIG_RTC_DRV_DS1553 is not set
+# CONFIG_RTC_DRV_STK17TA8 is not set
+# CONFIG_RTC_DRV_DS1742 is not set
+# CONFIG_RTC_DRV_M48T86 is not set
+# CONFIG_RTC_DRV_M48T59 is not set
+# CONFIG_RTC_DRV_V3020 is not set
+
+#
+# on-CPU RTC drivers
 #
-# CONFIG_MMC is not set
 
 #
 # File systems
@@ -1107,16 +1404,19 @@ CONFIG_EXT3_FS=y
 CONFIG_EXT3_FS_XATTR=y
 CONFIG_EXT3_FS_POSIX_ACL=y
 # CONFIG_EXT3_FS_SECURITY is not set
+# CONFIG_EXT4DEV_FS is not set
 CONFIG_JBD=y
-# CONFIG_JBD_DEBUG is not set
 CONFIG_FS_MBCACHE=y
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
 CONFIG_FS_POSIX_ACL=y
 # CONFIG_XFS_FS is not set
+# CONFIG_GFS2_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_INOTIFY_USER=y
 # CONFIG_QUOTA is not set
 CONFIG_DNOTIFY=y
 # CONFIG_AUTOFS_FS is not set
@@ -1140,11 +1440,12 @@ CONFIG_DNOTIFY=y
 # Pseudo filesystems
 #
 CONFIG_PROC_FS=y
+CONFIG_PROC_SYSCTL=y
 CONFIG_SYSFS=y
 CONFIG_TMPFS=y
+# CONFIG_TMPFS_POSIX_ACL 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
@@ -1156,13 +1457,15 @@ CONFIG_RAMFS=y
 # CONFIG_BEFS_FS is not set
 # CONFIG_BFS_FS is not set
 # CONFIG_EFS_FS is not set
-# CONFIG_JFFS_FS is not set
 CONFIG_JFFS2_FS=y
 CONFIG_JFFS2_FS_DEBUG=0
 CONFIG_JFFS2_FS_WRITEBUFFER=y
+# CONFIG_JFFS2_FS_WBUF_VERIFY is not set
 # CONFIG_JFFS2_SUMMARY is not set
+# CONFIG_JFFS2_FS_XATTR is not set
 # CONFIG_JFFS2_COMPRESSION_OPTIONS is not set
 CONFIG_JFFS2_ZLIB=y
+# CONFIG_JFFS2_LZO is not set
 CONFIG_JFFS2_RTIME=y
 # CONFIG_JFFS2_RUBIN is not set
 # CONFIG_CRAMFS is not set
@@ -1171,10 +1474,7 @@ CONFIG_JFFS2_RTIME=y
 # CONFIG_QNX4FS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
-
-#
-# Network File Systems
-#
+CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
 # CONFIG_NFS_V3_ACL is not set
@@ -1186,6 +1486,7 @@ CONFIG_LOCKD=y
 CONFIG_LOCKD_V4=y
 CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=y
+# CONFIG_SUNRPC_BIND34 is not set
 # CONFIG_RPCSEC_GSS_KRB5 is not set
 # CONFIG_RPCSEC_GSS_SPKM3 is not set
 # CONFIG_SMB_FS is not set
@@ -1193,7 +1494,6 @@ CONFIG_SUNRPC=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
@@ -1213,37 +1513,53 @@ 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
-
-#
-# Native Language Support
-#
+# CONFIG_SYSV68_PARTITION is not set
 # CONFIG_NLS is not set
-
-#
-# Profiling support
-#
+# CONFIG_DLM is not set
+CONFIG_INSTRUMENTATION=y
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 
 #
 # Kernel hacking
 #
 # CONFIG_PRINTK_TIME is not set
-CONFIG_DEBUG_KERNEL=y
+CONFIG_ENABLE_WARN_DEPRECATED=y
+CONFIG_ENABLE_MUST_CHECK=y
 CONFIG_MAGIC_SYSRQ=y
-CONFIG_LOG_BUF_SHIFT=14
+# CONFIG_UNUSED_SYMBOLS is not set
+# CONFIG_DEBUG_FS is not set
+# CONFIG_HEADERS_CHECK is not set
+CONFIG_DEBUG_KERNEL=y
+# CONFIG_DEBUG_SHIRQ is not set
 CONFIG_DETECT_SOFTLOCKUP=y
+CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
-# CONFIG_DEBUG_SLAB is not set
+# CONFIG_TIMER_STATS is not set
+# CONFIG_SLUB_DEBUG_ON is not set
+# CONFIG_DEBUG_RT_MUTEXES is not set
+# CONFIG_RT_MUTEX_TESTER is not set
 # CONFIG_DEBUG_SPINLOCK is not set
+# CONFIG_DEBUG_MUTEXES is not set
+# CONFIG_DEBUG_LOCK_ALLOC is not set
+# CONFIG_PROVE_LOCKING is not set
+# CONFIG_LOCK_STAT is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
+# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
 # CONFIG_DEBUG_KOBJECT is not set
 CONFIG_DEBUG_BUGVERBOSE=y
 # CONFIG_DEBUG_INFO is not set
-# CONFIG_DEBUG_FS is not set
 # CONFIG_DEBUG_VM is not set
+# CONFIG_DEBUG_LIST is not set
+# CONFIG_DEBUG_SG is not set
 CONFIG_FRAME_POINTER=y
+CONFIG_FORCED_INLINING=y
+# CONFIG_BOOT_PRINTK_DELAY is not set
 # CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_FAULT_INJECTION is not set
+# CONFIG_SAMPLES is not set
 # CONFIG_DEBUG_USER is not set
 CONFIG_DEBUG_ERRORS=y
 CONFIG_DEBUG_LL=y
@@ -1254,22 +1570,22 @@ CONFIG_DEBUG_LL=y
 #
 # CONFIG_KEYS is not set
 # CONFIG_SECURITY is not set
-
-#
-# Cryptographic options
-#
+# CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
 
 #
-# Hardware crypto devices
-#
-
-#
 # Library routines
 #
+CONFIG_BITREVERSE=y
 # CONFIG_CRC_CCITT is not set
 # CONFIG_CRC16 is not set
+# CONFIG_CRC_ITU_T is not set
 CONFIG_CRC32=y
+# CONFIG_CRC7 is not set
 # CONFIG_LIBCRC32C is not set
 CONFIG_ZLIB_INFLATE=y
 CONFIG_ZLIB_DEFLATE=y
+CONFIG_PLIST=y
+CONFIG_HAS_IOMEM=y
+CONFIG_HAS_IOPORT=y
+CONFIG_HAS_DMA=y
diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile
index faa761921153..00d44c6fbfe9 100644
--- a/arch/arm/kernel/Makefile
+++ b/arch/arm/kernel/Makefile
@@ -20,6 +20,7 @@ obj-$(CONFIG_PCI)		+= bios32.o isa.o
 obj-$(CONFIG_SMP)               += smp.o
 obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
 obj-$(CONFIG_KPROBES)           += kprobes.o kprobes-decode.o
+obj-$(CONFIG_ATAGS_PROC)        += atags.o
 obj-$(CONFIG_OABI_COMPAT)       += sys_oabi-compat.o
 
 obj-$(CONFIG_CRUNCH)            += crunch.o crunch-bits.o
diff --git a/arch/arm/kernel/atags.c b/arch/arm/kernel/atags.c
new file mode 100644
index 000000000000..e2e934c38080
--- /dev/null
+++ b/arch/arm/kernel/atags.c
@@ -0,0 +1,86 @@
+#include <linux/slab.h>
+#include <linux/kexec.h>
+#include <linux/proc_fs.h>
+#include <asm/setup.h>
+#include <asm/types.h>
+#include <asm/page.h>
+
+struct buffer {
+        size_t size;
+        char *data;
+};
+static struct buffer tags_buffer;
+
+static int
+read_buffer(char* page, char** start, off_t off, int count,
+        int* eof, void* data)
+{
+        struct buffer *buffer = (struct buffer *)data;
+
+        if (off >= buffer->size) {
+                *eof = 1;
+                return 0;
+        }
+
+        count = min((int) (buffer->size - off), count);
+
+        memcpy(page, &buffer->data[off], count);
+
+        return count;
+}
+
+
+static int
+create_proc_entries(void)
+{
+        struct proc_dir_entry* tags_entry;
+
+        tags_entry = create_proc_read_entry("atags", 0400, &proc_root, read_buffer, &tags_buffer);
+        if (!tags_entry)
+                return -ENOMEM;
+
+        return 0;
+}
+
+
+static char __initdata atags_copy_buf[KEXEC_BOOT_PARAMS_SIZE];
+static char __initdata *atags_copy;
+
+void __init save_atags(const struct tag *tags)
+{
+        atags_copy = atags_copy_buf;
+        memcpy(atags_copy, tags, KEXEC_BOOT_PARAMS_SIZE);
+}
+
+
+static int __init init_atags_procfs(void)
+{
+        struct tag *tag;
+        int error;
+
+        if (!atags_copy) {
+                printk(KERN_WARNING "Exporting ATAGs: No saved tags found\n");
+                return -EIO;
+        }
+
+        for (tag = (struct tag *) atags_copy; tag->hdr.size; tag = tag_next(tag))
+                ;
+
+        tags_buffer.size = ((char *) tag - atags_copy) + sizeof(tag->hdr);
+        tags_buffer.data = kmalloc(tags_buffer.size, GFP_KERNEL);
+        if (tags_buffer.data == NULL)
+                return -ENOMEM;
+        memcpy(tags_buffer.data, atags_copy, tags_buffer.size);
+
+        error = create_proc_entries();
+        if (error) {
+                printk(KERN_ERR "Exporting ATAGs: not enough memory\n");
+                kfree(tags_buffer.data);
+                tags_buffer.size = 0;
+                tags_buffer.data = NULL;
+        }
+
+        return error;
+}
+
+arch_initcall(init_atags_procfs);
diff --git a/arch/arm/kernel/atags.h b/arch/arm/kernel/atags.h
new file mode 100644
index 000000000000..e5f028d214a1
--- /dev/null
+++ b/arch/arm/kernel/atags.h
@@ -0,0 +1,5 @@
+#ifdef CONFIG_ATAGS_PROC
+extern void save_atags(struct tag *tags);
+#else
+static inline void save_atags(struct tag *tags) { }
+#endif
diff --git a/arch/arm/kernel/calls.S b/arch/arm/kernel/calls.S
index cecf658e3625..283e14fff993 100644
--- a/arch/arm/kernel/calls.S
+++ b/arch/arm/kernel/calls.S
@@ -359,7 +359,7 @@
                 CALL(sys_kexec_load)
                 CALL(sys_utimensat)
                 CALL(sys_signalfd)
-/* 350 */       CALL(sys_timerfd)
+/* 350 */       CALL(sys_ni_syscall)
                 CALL(sys_eventfd)
                 CALL(sys_fallocate)
 #ifndef syscalls_counted
diff --git a/arch/arm/kernel/machine_kexec.c b/arch/arm/kernel/machine_kexec.c
index 863c66454f2b..db8f54a3451f 100644
--- a/arch/arm/kernel/machine_kexec.c
+++ b/arch/arm/kernel/machine_kexec.c
@@ -21,6 +21,7 @@ extern void setup_mm_for_reboot(char mode);
 extern unsigned long kexec_start_address;
 extern unsigned long kexec_indirection_page;
 extern unsigned long kexec_mach_type;
+extern unsigned long kexec_boot_atags;
 
 /*
  * Provide a dummy crash_notes definition while crash dump arrives to arm.
@@ -62,6 +63,7 @@ void machine_kexec(struct kimage *image)
         kexec_start_address = image->start;
         kexec_indirection_page = page_list;
         kexec_mach_type = machine_arch_type;
+        kexec_boot_atags = image->start - KEXEC_ARM_ZIMAGE_OFFSET + KEXEC_ARM_ATAGS_OFFSET;
 
         /* copy our kernel relocation code to the control code page */
         memcpy(reboot_code_buffer,
diff --git a/arch/arm/kernel/relocate_kernel.S b/arch/arm/kernel/relocate_kernel.S
index 062c111c572f..61930eb09029 100644
--- a/arch/arm/kernel/relocate_kernel.S
+++ b/arch/arm/kernel/relocate_kernel.S
@@ -7,23 +7,6 @@
         .globl relocate_new_kernel
 relocate_new_kernel:
 
-        /* Move boot params back to where the kernel expects them */
-
-        ldr     r0,kexec_boot_params_address
-        teq     r0,#0
-        beq     8f
-
-        ldr     r1,kexec_boot_params_copy
-        mov     r6,#KEXEC_BOOT_PARAMS_SIZE/4
-7:
-        ldr     r5,[r1],#4
-        str     r5,[r0],#4
-        subs    r6,r6,#1
-        bne     7b
-
-8:
-        /* Boot params moved, now go on with the kernel */
-
         ldr     r0,kexec_indirection_page
         ldr     r1,kexec_start_address
 
@@ -67,7 +50,7 @@ relocate_new_kernel:
         mov lr,r1
         mov r0,#0
         ldr r1,kexec_mach_type
-        ldr r2,kexec_boot_params_address
+        ldr r2,kexec_boot_atags
         mov pc,lr
 
         .globl kexec_start_address
@@ -82,14 +65,9 @@ kexec_indirection_page:
 kexec_mach_type:
         .long   0x0
 
-        /* phy addr where new kernel will expect to find boot params */
-        .globl kexec_boot_params_address
-kexec_boot_params_address:
-        .long   0x0
-
-        /* phy addr where old kernel put a copy of orig boot params */
-        .globl kexec_boot_params_copy
-kexec_boot_params_copy:
+        /* phy addr of the atags for the new kernel */
+        .globl kexec_boot_atags
+kexec_boot_atags:
         .long   0x0
 
 relocate_new_kernel_end:
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index bf56eb337df1..d3941a7b0455 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -24,7 +24,6 @@
 #include <linux/interrupt.h>
 #include <linux/smp.h>
 #include <linux/fs.h>
-#include <linux/kexec.h>
 
 #include <asm/cpu.h>
 #include <asm/elf.h>
@@ -39,6 +38,7 @@
 #include <asm/mach/time.h>
 
 #include "compat.h"
+#include "atags.h"
 
 #ifndef MEM_SIZE
 #define MEM_SIZE        (16*1024*1024)
@@ -62,6 +62,7 @@ extern int root_mountflags;
 extern void _stext, _text, _etext, __data_start, _edata, _end;
 
 unsigned int processor_id;
+EXPORT_SYMBOL(processor_id);
 unsigned int __machine_arch_type;
 EXPORT_SYMBOL(__machine_arch_type);
 
@@ -784,23 +785,6 @@ static int __init customize_machine(void)
 }
 arch_initcall(customize_machine);
 
-#ifdef CONFIG_KEXEC
-
-/* Physical addr of where the boot params should be for this machine */
-extern unsigned long kexec_boot_params_address;
-
-/* Physical addr of the buffer into which the boot params are copied */
-extern unsigned long kexec_boot_params_copy;
-
-/* Pointer to the boot params buffer, for manipulation and display */
-unsigned long kexec_boot_params;
-EXPORT_SYMBOL(kexec_boot_params);
-
-/* The buffer itself - make sure it is sized correctly */
-static unsigned long kexec_boot_params_buf[(KEXEC_BOOT_PARAMS_SIZE + 3) / 4];
-
-#endif
-
 void __init setup_arch(char **cmdline_p)
 {
         struct tag *tags = (struct tag *)&init_tags;
@@ -819,18 +803,6 @@ void __init setup_arch(char **cmdline_p)
         else if (mdesc->boot_params)
                 tags = phys_to_virt(mdesc->boot_params);
 
-#ifdef CONFIG_KEXEC
-        kexec_boot_params_copy = virt_to_phys(kexec_boot_params_buf);
-        kexec_boot_params = (unsigned long)kexec_boot_params_buf;
-        if (__atags_pointer) {
-                kexec_boot_params_address = __atags_pointer;
-                memcpy((void *)kexec_boot_params, tags, KEXEC_BOOT_PARAMS_SIZE);
-        } else if (mdesc->boot_params) {
-                kexec_boot_params_address = mdesc->boot_params;
-                memcpy((void *)kexec_boot_params, tags, KEXEC_BOOT_PARAMS_SIZE);
-        }
-#endif
-
         /*
          * If we have the old style parameters, convert them to
          * a tag list.
@@ -846,6 +818,7 @@ void __init setup_arch(char **cmdline_p)
         if (tags->hdr.tag == ATAG_CORE) {
                 if (meminfo.nr_banks != 0)
                         squash_mem_tags(tags);
+                save_atags(tags);
                 parse_tags(tags);
         }
 
diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c
index eafbb2b05eb8..eefae1de334c 100644
--- a/arch/arm/kernel/smp.c
+++ b/arch/arm/kernel/smp.c
@@ -150,7 +150,7 @@ int __cpuinit __cpu_up(unsigned int cpu)
         secondary_data.pgdir = 0;
 
         *pmd_offset(pgd, PHYS_OFFSET) = __pmd(0);
-        pgd_free(pgd);
+        pgd_free(&init_mm, pgd);
 
         if (ret) {
                 printk(KERN_CRIT "CPU%u: processor failed to boot\n", cpu);
@@ -290,6 +290,11 @@ asmlinkage void __cpuinit secondary_start_kernel(void)
         local_irq_enable();
         local_fiq_enable();
 
+        /*
+         * Setup local timer for this CPU.
+         */
+        local_timer_setup(cpu);
+
         calibrate_delay();
 
         smp_store_cpu_info(cpu);
@@ -300,11 +305,6 @@ asmlinkage void __cpuinit secondary_start_kernel(void)
         cpu_set(cpu, cpu_online_map);
 
         /*
-         * Setup local timer for this CPU.
-         */
-        local_timer_setup(cpu);
-
-        /*
          * OK, it's off to the idle thread for us
          */
         cpu_idle();
@@ -454,6 +454,27 @@ int smp_call_function(void (*func)(void *info), void *info, int retry,
 }
 EXPORT_SYMBOL_GPL(smp_call_function);
 
+int smp_call_function_single(int cpu, void (*func)(void *info), void *info,
+                             int retry, int wait)
+{
+        /* prevent preemption and reschedule on another processor */
+        int current_cpu = get_cpu();
+        int ret = 0;
+
+        if (cpu == current_cpu) {
+                local_irq_disable();
+                func(info);
+                local_irq_enable();
+        } else
+                ret = smp_call_function_on_cpu(func, info, retry, wait,
+                                               cpumask_of_cpu(cpu));
+
+        put_cpu();
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(smp_call_function_single);
+
 void show_ipi_list(struct seq_file *p)
 {
         unsigned int cpu;
@@ -481,8 +502,7 @@ void show_local_irqs(struct seq_file *p)
 static void ipi_timer(void)
 {
         irq_enter();
-        profile_tick(CPU_PROFILING);
-        update_process_times(user_mode(get_irq_regs()));
+        local_timer_interrupt();
         irq_exit();
 }
 
@@ -621,6 +641,11 @@ void smp_send_timer(void)
         send_ipi_message(mask, IPI_TIMER);
 }
 
+void smp_timer_broadcast(cpumask_t mask)
+{
+        send_ipi_message(mask, IPI_TIMER);
+}
+
 void smp_send_stop(void)
 {
         cpumask_t mask = cpu_online_map;
diff --git a/arch/arm/mach-at91/Kconfig b/arch/arm/mach-at91/Kconfig
index 5b0422cdde76..074dcd5d9a7e 100644
--- a/arch/arm/mach-at91/Kconfig
+++ b/arch/arm/mach-at91/Kconfig
@@ -253,6 +253,36 @@ config AT91_TIMER_HZ
           system clock (of at least several MHz), rounding is less of a
           problem so it can be safer to use a decimal values like 100.
 
+choice
+        prompt "Select a UART for early kernel messages"
+
+config AT91_EARLY_DBGU
+        bool "DBGU"
+
+config AT91_EARLY_USART0
+        bool "USART0"
+
+config AT91_EARLY_USART1
+        bool "USART1"
+
+config AT91_EARLY_USART2
+        bool "USART2"
+        depends on ! ARCH_AT91X40
+
+config AT91_EARLY_USART3
+        bool "USART3"
+        depends on (ARCH_AT91RM9200 || ARCH_AT91SAM9RL || ARCH_AT91SAM9260)
+
+config AT91_EARLY_USART4
+        bool "USART4"
+        depends on ARCH_AT91SAM9260
+
+config AT91_EARLY_USART5
+        bool "USART5"
+        depends on ARCH_AT91SAM9260
+
+endchoice
+
 endmenu
 
 endif
diff --git a/arch/arm/mach-at91/at91sam926x_time.c b/arch/arm/mach-at91/at91sam926x_time.c
index 5c090c9442f5..e38d23770992 100644
--- a/arch/arm/mach-at91/at91sam926x_time.c
+++ b/arch/arm/mach-at91/at91sam926x_time.c
@@ -49,8 +49,6 @@ static irqreturn_t at91sam926x_timer_interrupt(int irq, void *dev_id)
         volatile long nr_ticks;
 
         if (at91_sys_read(AT91_PIT_SR) & AT91_PIT_PITS) {       /* This is a shared interrupt */
-                write_seqlock(&xtime_lock);
-
                 /* Get number to ticks performed before interrupt and clear PIT interrupt */
                 nr_ticks = PIT_PICNT(at91_sys_read(AT91_PIT_PIVR));
                 do {
@@ -58,7 +56,6 @@ static irqreturn_t at91sam926x_timer_interrupt(int irq, void *dev_id)
                         nr_ticks--;
                 } while (nr_ticks);
 
-                write_sequnlock(&xtime_lock);
                 return IRQ_HANDLED;
         } else
                 return IRQ_NONE;                /* not handled */
diff --git a/arch/arm/mach-at91/generic.h b/arch/arm/mach-at91/generic.h
index b5daf7f5e011..7b9ce7a336b0 100644
--- a/arch/arm/mach-at91/generic.h
+++ b/arch/arm/mach-at91/generic.h
@@ -47,6 +47,9 @@ extern void at91_irq_resume(void);
 #define AT91RM9200_BGA          4       /* AT91RM9200 BGA package has 4 banks */
 
 struct at91_gpio_bank {
+        unsigned chipbase;              /* bank's first GPIO number */
+        void __iomem *regbase;          /* base of register bank */
+        struct at91_gpio_bank *next;    /* bank sharing same IRQ/clock/... */
         unsigned short id;              /* peripheral ID */
         unsigned long offset;           /* offset from system peripheral base */
         struct clk *clock;              /* associated clock */
diff --git a/arch/arm/mach-at91/gpio.c b/arch/arm/mach-at91/gpio.c
index 6aeddd68d8af..f629c2b5f0c5 100644
--- a/arch/arm/mach-at91/gpio.c
+++ b/arch/arm/mach-at91/gpio.c
@@ -33,12 +33,10 @@ static int gpio_banks;
 
 static inline void __iomem *pin_to_controller(unsigned pin)
 {
-        void __iomem *sys_base = (void __iomem *) AT91_VA_BASE_SYS;
-
         pin -= PIN_BASE;
         pin /= 32;
         if (likely(pin < gpio_banks))
-                return sys_base + gpio[pin].offset;
+                return gpio[pin].regbase;
 
         return NULL;
 }
@@ -294,11 +292,11 @@ void at91_gpio_suspend(void)
         int i;
 
         for (i = 0; i < gpio_banks; i++) {
-                u32 pio = gpio[i].offset;
+                void __iomem    *pio = gpio[i].regbase;
 
-                backups[i] = at91_sys_read(pio + PIO_IMR);
-                at91_sys_write(pio + PIO_IDR, backups[i]);
-                at91_sys_write(pio + PIO_IER, wakeups[i]);
+                backups[i] = __raw_readl(pio + PIO_IMR);
+                __raw_writel(backups[i], pio + PIO_IDR);
+                __raw_writel(wakeups[i], pio + PIO_IER);
 
                 if (!wakeups[i])
                         clk_disable(gpio[i].clock);
@@ -315,13 +313,13 @@ void at91_gpio_resume(void)
         int i;
 
         for (i = 0; i < gpio_banks; i++) {
-                u32 pio = gpio[i].offset;
+                void __iomem    *pio = gpio[i].regbase;
 
                 if (!wakeups[i])
                         clk_enable(gpio[i].clock);
 
-                at91_sys_write(pio + PIO_IDR, wakeups[i]);
-                at91_sys_write(pio + PIO_IER, backups[i]);
+                __raw_writel(wakeups[i], pio + PIO_IDR);
+                __raw_writel(backups[i], pio + PIO_IER);
         }
 }
 
@@ -361,7 +359,13 @@ static void gpio_irq_unmask(unsigned pin)
 
 static int gpio_irq_type(unsigned pin, unsigned type)
 {
-        return (type == IRQT_BOTHEDGE) ? 0 : -EINVAL;
+        switch (type) {
+        case IRQ_TYPE_NONE:
+        case IRQ_TYPE_EDGE_BOTH:
+                return 0;
+        default:
+                return -EINVAL;
+        }
 }
 
 static struct irq_chip gpio_irqchip = {
@@ -376,20 +380,30 @@ static void gpio_irq_handler(unsigned irq, struct irq_desc *desc)
 {
         unsigned        pin;
         struct irq_desc *gpio;
+        struct at91_gpio_bank *bank;
         void __iomem    *pio;
         u32             isr;
 
-        pio = get_irq_chip_data(irq);
+        bank = get_irq_chip_data(irq);
+        pio = bank->regbase;
 
         /* temporarily mask (level sensitive) parent IRQ */
         desc->chip->ack(irq);
         for (;;) {
-                /* reading ISR acks the pending (edge triggered) GPIO interrupt */
+                /* Reading ISR acks pending (edge triggered) GPIO interrupts.
+                 * When there none are pending, we're finished unless we need
+                 * to process multiple banks (like ID_PIOCDE on sam9263).
+                 */
                 isr = __raw_readl(pio + PIO_ISR) & __raw_readl(pio + PIO_IMR);
-                if (!isr)
-                        break;
+                if (!isr) {
+                        if (!bank->next)
+                                break;
+                        bank = bank->next;
+                        pio = bank->regbase;
+                        continue;
+                }
 
-                pin = (unsigned) get_irq_data(irq);
+                pin = bank->chipbase;
                 gpio = &irq_desc[pin];
 
                 while (isr) {
@@ -481,24 +495,21 @@ postcore_initcall(at91_gpio_debugfs_init);
  */
 void __init at91_gpio_irq_setup(void)
 {
-        unsigned        pioc, pin;
+        unsigned                pioc, pin;
+        struct at91_gpio_bank   *this, *prev;
 
-        for (pioc = 0, pin = PIN_BASE;
-                        pioc < gpio_banks;
-                        pioc++) {
-                void __iomem    *controller;
-                unsigned        id = gpio[pioc].id;
+        for (pioc = 0, pin = PIN_BASE, this = gpio, prev = NULL;
+                        pioc++ < gpio_banks;
+                        prev = this, this++) {
+                unsigned        id = this->id;
                 unsigned        i;
 
-                clk_enable(gpio[pioc].clock);   /* enable PIO controller's clock */
-
-                controller = (void __iomem *) AT91_VA_BASE_SYS + gpio[pioc].offset;
-                __raw_writel(~0, controller + PIO_IDR);
+                /* enable PIO controller's clock */
+                clk_enable(this->clock);
 
-                set_irq_data(id, (void *) pin);
-                set_irq_chip_data(id, controller);
+                __raw_writel(~0, this->regbase + PIO_IDR);
 
-                for (i = 0; i < 32; i++, pin++) {
+                for (i = 0, pin = this->chipbase; i < 32; i++, pin++) {
                         /*
                          * Can use the "simple" and not "edge" handler since it's
                          * shorter, and the AIC handles interrupts sanely.
@@ -508,6 +519,14 @@ void __init at91_gpio_irq_setup(void)
                         set_irq_flags(pin, IRQF_VALID);
                 }
 
+                /* The toplevel handler handles one bank of GPIOs, except
+                 * AT91SAM9263_ID_PIOCDE handles three... PIOC is first in
+                 * the list, so we only set up that handler.
+                 */
+                if (prev && prev->next == this)
+                        continue;
+
+                set_irq_chip_data(id, this);
                 set_irq_chained_handler(id, gpio_irq_handler);
         }
         pr_info("AT91: %d gpio irqs in %d banks\n", pin - PIN_BASE, gpio_banks);
@@ -518,8 +537,20 @@ void __init at91_gpio_irq_setup(void)
  */
 void __init at91_gpio_init(struct at91_gpio_bank *data, int nr_banks)
 {
+        unsigned                i;
+        struct at91_gpio_bank   *last;
+
         BUG_ON(nr_banks > MAX_GPIO_BANKS);
 
         gpio = data;
         gpio_banks = nr_banks;
+
+        for (i = 0, last = NULL; i < nr_banks; i++, last = data, data++) {
+                data->chipbase = PIN_BASE + i * 32;
+                data->regbase = data->offset + (void __iomem *)AT91_VA_BASE_SYS;
+
+                /* AT91SAM9263_ID_PIOCDE groups PIOC, PIOD, PIOE */
+                if (last && last->id == data->id)
+                        last->next = data;
+        }
 }
diff --git a/arch/arm/mach-at91/pm.c b/arch/arm/mach-at91/pm.c
index 4b120cc36135..a67defd50438 100644
--- a/arch/arm/mach-at91/pm.c
+++ b/arch/arm/mach-at91/pm.c
@@ -52,7 +52,7 @@ static suspend_state_t target_state;
 /*
  * Called after processes are frozen, but before we shutdown devices.
  */
-static int at91_pm_set_target(suspend_state_t state)
+static int at91_pm_begin(suspend_state_t state)
 {
         target_state = state;
         return 0;
@@ -202,11 +202,20 @@ error:
         return 0;
 }
 
+/*
+ * Called right prior to thawing processes.
+ */
+static void at91_pm_end(void)
+{
+        target_state = PM_SUSPEND_ON;
+}
+
 
 static struct platform_suspend_ops at91_pm_ops ={
-        .valid          = at91_pm_valid_state,
-        .set_target     = at91_pm_set_target,
-        .enter          = at91_pm_enter,
+        .valid  = at91_pm_valid_state,
+        .begin  = at91_pm_begin,
+        .enter  = at91_pm_enter,
+        .end    = at91_pm_end,
 };
 
 static int __init at91_pm_init(void)
diff --git a/arch/arm/mach-ixp4xx/Kconfig b/arch/arm/mach-ixp4xx/Kconfig
index 61b2dfcb89d6..e774447c0592 100644
--- a/arch/arm/mach-ixp4xx/Kconfig
+++ b/arch/arm/mach-ixp4xx/Kconfig
@@ -189,6 +189,20 @@ config IXP4XX_INDIRECT_PCI
           need to use the indirect method instead. If you don't know
           what you need, leave this option unselected.
 
+config IXP4XX_QMGR
+        tristate "IXP4xx Queue Manager support"
+        help
+          This driver supports IXP4xx built-in hardware queue manager
+          and is automatically selected by Ethernet and HSS drivers.
+
+config IXP4XX_NPE
+        tristate "IXP4xx Network Processor Engine support"
+        select HOTPLUG
+        select FW_LOADER
+        help
+          This driver supports IXP4xx built-in network coprocessors
+          and is automatically selected by Ethernet and HSS drivers.
+
 endmenu
 
 endif
diff --git a/arch/arm/mach-ixp4xx/Makefile b/arch/arm/mach-ixp4xx/Makefile
index 77e00ade5585..c1956882c48b 100644
--- a/arch/arm/mach-ixp4xx/Makefile
+++ b/arch/arm/mach-ixp4xx/Makefile
@@ -23,10 +23,12 @@ obj-$(CONFIG_MACH_AVILA)	+= avila-setup.o
 obj-$(CONFIG_MACH_IXDPG425)     += coyote-setup.o
 obj-$(CONFIG_ARCH_ADI_COYOTE)   += coyote-setup.o
 obj-$(CONFIG_MACH_GTWX5715)     += gtwx5715-setup.o
-obj-$(CONFIG_MACH_NSLU2)        += nslu2-setup.o nslu2-power.o
-obj-$(CONFIG_MACH_NAS100D)      += nas100d-setup.o nas100d-power.o
-obj-$(CONFIG_MACH_DSMG600)      += dsmg600-setup.o dsmg600-power.o
+obj-$(CONFIG_MACH_NSLU2)        += nslu2-setup.o
+obj-$(CONFIG_MACH_NAS100D)      += nas100d-setup.o
+obj-$(CONFIG_MACH_DSMG600)      += dsmg600-setup.o
 obj-$(CONFIG_MACH_GATEWAY7001)  += gateway7001-setup.o
 obj-$(CONFIG_MACH_WG302V2)      += wg302v2-setup.o
 
 obj-$(CONFIG_PCI)               += $(obj-pci-$(CONFIG_PCI)) common-pci.o
+obj-$(CONFIG_IXP4XX_QMGR)       += ixp4xx_qmgr.o
+obj-$(CONFIG_IXP4XX_NPE)        += ixp4xx_npe.o
diff --git a/arch/arm/mach-ixp4xx/dsmg600-power.c b/arch/arm/mach-ixp4xx/dsmg600-power.c
deleted file mode 100644
index 34717872d076..000000000000
--- a/arch/arm/mach-ixp4xx/dsmg600-power.c
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * arch/arm/mach-ixp4xx/dsmg600-power.c
- *
- * DSM-G600 Power/Reset driver
- * Author: Michael Westerhof <mwester@dls.net>
- *
- * Based on nslu2-power.c
- *  Copyright (C) 2005 Tower Technologies
- *  Author: Alessandro Zummo <a.zummo@towertech.it>
- *
- * which was based on nslu2-io.c
- *  Copyright (C) 2004 Karen Spearel
- *
- * Maintainers: http://www.nslu2-linux.org/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/module.h>
-#include <linux/reboot.h>
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/jiffies.h>
-#include <linux/timer.h>
-
-#include <asm/mach-types.h>
-
-extern void ctrl_alt_del(void);
-
-/* This is used to make sure the power-button pusher is serious.  The button
- * must be held until the value of this counter reaches zero.
- */
-static volatile int power_button_countdown;
-
-/* Must hold the button down for at least this many counts to be processed */
-#define PBUTTON_HOLDDOWN_COUNT 4 /* 2 secs */
-
-static void dsmg600_power_handler(unsigned long data);
-static DEFINE_TIMER(dsmg600_power_timer, dsmg600_power_handler, 0, 0);
-
-static void dsmg600_power_handler(unsigned long data)
-{
-        /* This routine is called twice per second to check the
-         * state of the power button.
-         */
-
-        if (*IXP4XX_GPIO_GPINR & DSMG600_PB_BM) {
-
-                /* IO Pin is 1 (button pushed) */
-                if (power_button_countdown == 0) {
-                        /* Signal init to do the ctrlaltdel action, this will bypass
-                         * init if it hasn't started and do a kernel_restart.
-                         */
-                        ctrl_alt_del();
-
-                        /* Change the state of the power LED to "blink" */
-                        gpio_line_set(DSMG600_LED_PWR_GPIO, IXP4XX_GPIO_LOW);
-                }
-                power_button_countdown--;
-
-        } else {
-                power_button_countdown = PBUTTON_HOLDDOWN_COUNT;
-        }
-
-        mod_timer(&dsmg600_power_timer, jiffies + msecs_to_jiffies(500));
-}
-
-static irqreturn_t dsmg600_reset_handler(int irq, void *dev_id)
-{
-        /* This is the paper-clip reset, it shuts the machine down directly. */
-        machine_power_off();
-
-        return IRQ_HANDLED;
-}
-
-static int __init dsmg600_power_init(void)
-{
-        if (!(machine_is_dsmg600()))
-                return 0;
-
-        if (request_irq(DSMG600_RB_IRQ, &dsmg600_reset_handler,
-                IRQF_DISABLED | IRQF_TRIGGER_LOW, "DSM-G600 reset button",
-                NULL) < 0) {
-
-                printk(KERN_DEBUG "Reset Button IRQ %d not available\n",
-                        DSMG600_RB_IRQ);
-
-                return -EIO;
-        }
-
-        /* The power button on the D-Link DSM-G600 is on GPIO 15, but
-         * it cannot handle interrupts on that GPIO line.  So we'll
-         * have to poll it with a kernel timer.
-         */
-
-        /* Make sure that the power button GPIO is set up as an input */
-        gpio_line_config(DSMG600_PB_GPIO, IXP4XX_GPIO_IN);
-
-        /* Set the initial value for the power button IRQ handler */
-        power_button_countdown = PBUTTON_HOLDDOWN_COUNT;
-
-        mod_timer(&dsmg600_power_timer, jiffies + msecs_to_jiffies(500));
-
-        return 0;
-}
-
-static void __exit dsmg600_power_exit(void)
-{
-        if (!(machine_is_dsmg600()))
-                return;
-
-        del_timer_sync(&dsmg600_power_timer);
-
-        free_irq(DSMG600_RB_IRQ, NULL);
-}
-
-module_init(dsmg600_power_init);
-module_exit(dsmg600_power_exit);
-
-MODULE_AUTHOR("Michael Westerhof <mwester@dls.net>");
-MODULE_DESCRIPTION("DSM-G600 Power/Reset driver");
-MODULE_LICENSE("GPL");
diff --git a/arch/arm/mach-ixp4xx/dsmg600-setup.c b/arch/arm/mach-ixp4xx/dsmg600-setup.c
index c473d408aa7c..688659668bdf 100644
--- a/arch/arm/mach-ixp4xx/dsmg600-setup.c
+++ b/arch/arm/mach-ixp4xx/dsmg600-setup.c
@@ -1,25 +1,37 @@
 /*
  * DSM-G600 board-setup
  *
+ * Copyright (C) 2008 Rod Whitby <rod@whitby.id.au>
  * Copyright (C) 2006 Tower Technologies
- * Author: Alessandro Zummo <a.zummo@towertech.it>
  *
- * based ixdp425-setup.c:
+ * based on ixdp425-setup.c:
  *      Copyright (C) 2003-2004 MontaVista Software, Inc.
+ * based on nslu2-power.c:
+ *      Copyright (C) 2005 Tower Technologies
+ * based on nslu2-io.c:
+ *      Copyright (C) 2004 Karen Spearel
  *
  * Author: Alessandro Zummo <a.zummo@towertech.it>
+ * Author: Michael Westerhof <mwester@dls.net>
+ * Author: Rod Whitby <rod@whitby.id.au>
  * Maintainers: http://www.nslu2-linux.org/
  */
 
-#include <linux/kernel.h>
+#include <linux/irq.h>
+#include <linux/jiffies.h>
+#include <linux/timer.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
+#include <linux/leds.h>
+#include <linux/reboot.h>
+#include <linux/i2c.h>
 #include <linux/i2c-gpio.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/flash.h>
 #include <asm/mach/time.h>
+#include <asm/gpio.h>
 
 static struct flash_platform_data dsmg600_flash_data = {
         .map_name               = "cfi_probe",
@@ -51,29 +63,34 @@ static struct platform_device dsmg600_i2c_gpio = {
         },
 };
 
-#ifdef CONFIG_LEDS_CLASS
-static struct resource dsmg600_led_resources[] = {
+static struct i2c_board_info __initdata dsmg600_i2c_board_info [] = {
+        {
+                I2C_BOARD_INFO("rtc-pcf8563", 0x51),
+        },
+};
+
+static struct gpio_led dsmg600_led_pins[] = {
         {
-                .name           = "power",
-                .start          = DSMG600_LED_PWR_GPIO,
-                .end            = DSMG600_LED_PWR_GPIO,
-                .flags          = IXP4XX_GPIO_HIGH,
+                .name           = "power",
+                .gpio           = DSMG600_LED_PWR_GPIO,
         },
         {
-                .name           = "wlan",
-                .start          = DSMG600_LED_WLAN_GPIO,
-                .end            = DSMG600_LED_WLAN_GPIO,
-                .flags          = IXP4XX_GPIO_LOW,
+                .name           = "wlan",
+                .gpio           = DSMG600_LED_WLAN_GPIO,
+                .active_low     = true,
         },
 };
 
+static struct gpio_led_platform_data dsmg600_led_data = {
+        .num_leds               = ARRAY_SIZE(dsmg600_led_pins),
+        .leds                   = dsmg600_led_pins,
+};
+
 static struct platform_device dsmg600_leds = {
-        .name                   = "IXP4XX-GPIO-LED",
-        .id                     = -1,
-        .num_resources          = ARRAY_SIZE(dsmg600_led_resources),
-        .resource               = dsmg600_led_resources,
+        .name                   = "leds-gpio",
+        .id                     = -1,
+        .dev.platform_data      = &dsmg600_led_data,
 };
-#endif
 
 static struct resource dsmg600_uart_resources[] = {
         {
@@ -121,6 +138,7 @@ static struct platform_device dsmg600_uart = {
 static struct platform_device *dsmg600_devices[] __initdata = {
         &dsmg600_i2c_gpio,
         &dsmg600_flash,
+        &dsmg600_leds,
 };
 
 static void dsmg600_power_off(void)
@@ -132,6 +150,57 @@ static void dsmg600_power_off(void)
         gpio_line_set(DSMG600_PO_GPIO, IXP4XX_GPIO_HIGH);
 }
 
+/* This is used to make sure the power-button pusher is serious.  The button
+ * must be held until the value of this counter reaches zero.
+ */
+static int power_button_countdown;
+
+/* Must hold the button down for at least this many counts to be processed */
+#define PBUTTON_HOLDDOWN_COUNT 4 /* 2 secs */
+
+static void dsmg600_power_handler(unsigned long data);
+static DEFINE_TIMER(dsmg600_power_timer, dsmg600_power_handler, 0, 0);
+
+static void dsmg600_power_handler(unsigned long data)
+{
+        /* This routine is called twice per second to check the
+         * state of the power button.
+         */
+
+        if (gpio_get_value(DSMG600_PB_GPIO)) {
+
+                /* IO Pin is 1 (button pushed) */
+                if (power_button_countdown > 0)
+                        power_button_countdown--;
+
+        } else {
+
+                /* Done on button release, to allow for auto-power-on mods. */
+                if (power_button_countdown == 0) {
+                        /* Signal init to do the ctrlaltdel action,
+                         * this will bypass init if it hasn't started
+                         * and do a kernel_restart.
+                         */
+                        ctrl_alt_del();
+
+                        /* Change the state of the power LED to "blink" */
+                        gpio_line_set(DSMG600_LED_PWR_GPIO, IXP4XX_GPIO_LOW);
+                } else {
+                        power_button_countdown = PBUTTON_HOLDDOWN_COUNT;
+                }
+        }
+
+        mod_timer(&dsmg600_power_timer, jiffies + msecs_to_jiffies(500));
+}
+
+static irqreturn_t dsmg600_reset_handler(int irq, void *dev_id)
+{
+        /* This is the paper-clip reset, it shuts the machine down directly. */
+        machine_power_off();
+
+        return IRQ_HANDLED;
+}
+
 static void __init dsmg600_timer_init(void)
 {
     /* The xtal on this machine is non-standard. */
@@ -156,7 +225,8 @@ static void __init dsmg600_init(void)
         dsmg600_flash_resource.end =
                 IXP4XX_EXP_BUS_BASE(0) + ixp4xx_exp_bus_size - 1;
 
-        pm_power_off = dsmg600_power_off;
+        i2c_register_board_info(0, dsmg600_i2c_board_info,
+                                ARRAY_SIZE(dsmg600_i2c_board_info));
 
         /* The UART is required on the DSM-G600 (Redboot cannot use the
          * NIC) -- do it here so that it does *not* get removed if
@@ -166,10 +236,28 @@ static void __init dsmg600_init(void)
 
         platform_add_devices(dsmg600_devices, ARRAY_SIZE(dsmg600_devices));
 
-#ifdef CONFIG_LEDS_CLASS
-        /* We don't care whether or not this works. */
-        (void)platform_device_register(&dsmg600_leds);
-#endif
+        pm_power_off = dsmg600_power_off;
+
+        if (request_irq(gpio_to_irq(DSMG600_RB_GPIO), &dsmg600_reset_handler,
+                IRQF_DISABLED | IRQF_TRIGGER_LOW,
+                "DSM-G600 reset button", NULL) < 0) {
+
+                printk(KERN_DEBUG "Reset Button IRQ %d not available\n",
+                        gpio_to_irq(DSMG600_RB_GPIO));
+        }
+
+        /* The power button on the D-Link DSM-G600 is on GPIO 15, but
+         * it cannot handle interrupts on that GPIO line.  So we'll
+         * have to poll it with a kernel timer.
+         */
+
+        /* Make sure that the power button GPIO is set up as an input */
+        gpio_line_config(DSMG600_PB_GPIO, IXP4XX_GPIO_IN);
+
+        /* Set the initial value for the power button IRQ handler */
+        power_button_countdown = PBUTTON_HOLDDOWN_COUNT;
+
+        mod_timer(&dsmg600_power_timer, jiffies + msecs_to_jiffies(500));
 }
 
 MACHINE_START(DSMG600, "D-Link DSM-G600 RevA")
diff --git a/arch/arm/mach-ixp4xx/ixdp425-setup.c b/arch/arm/mach-ixp4xx/ixdp425-setup.c
index e89070da28bf..44584afb34a3 100644
--- a/arch/arm/mach-ixp4xx/ixdp425-setup.c
+++ b/arch/arm/mach-ixp4xx/ixdp425-setup.c
@@ -177,6 +177,31 @@ static struct platform_device ixdp425_uart = {
         .resource               = ixdp425_uart_resources
 };
 
+/* Built-in 10/100 Ethernet MAC interfaces */
+static struct eth_plat_info ixdp425_plat_eth[] = {
+        {
+                .phy            = 0,
+                .rxq            = 3,
+                .txreadyq       = 20,
+        }, {
+                .phy            = 1,
+                .rxq            = 4,
+                .txreadyq       = 21,
+        }
+};
+
+static struct platform_device ixdp425_eth[] = {
+        {
+                .name                   = "ixp4xx_eth",
+                .id                     = IXP4XX_ETH_NPEB,
+                .dev.platform_data      = ixdp425_plat_eth,
+        }, {
+                .name                   = "ixp4xx_eth",
+                .id                     = IXP4XX_ETH_NPEC,
+                .dev.platform_data      = ixdp425_plat_eth + 1,
+        }
+};
+
 static struct platform_device *ixdp425_devices[] __initdata = {
         &ixdp425_i2c_gpio,
         &ixdp425_flash,
@@ -184,7 +209,9 @@ static struct platform_device *ixdp425_devices[] __initdata = {
     defined(CONFIG_MTD_NAND_PLATFORM_MODULE)
         &ixdp425_flash_nand,
 #endif
-        &ixdp425_uart
+        &ixdp425_uart,
+        &ixdp425_eth[0],
+        &ixdp425_eth[1],
 };
 
 static void __init ixdp425_init(void)
diff --git a/arch/arm/mach-ixp4xx/ixp4xx_npe.c b/arch/arm/mach-ixp4xx/ixp4xx_npe.c
new file mode 100644
index 000000000000..83c137ec582c
--- /dev/null
+++ b/arch/arm/mach-ixp4xx/ixp4xx_npe.c
@@ -0,0 +1,741 @@
+/*
+ * Intel IXP4xx Network Processor Engine driver for Linux
+ *
+ * Copyright (C) 2007 Krzysztof Halasa <khc@pm.waw.pl>
+ *
+ * This program 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.
+ *
+ * The code is based on publicly available information:
+ * - Intel IXP4xx Developer's Manual and other e-papers
+ * - Intel IXP400 Access Library Software (BSD license)
+ * - previous works by Christian Hohnstaedt <chohnstaedt@innominate.com>
+ *   Thanks, Christian.
+ */
+
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/firmware.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <asm/arch/npe.h>
+
+#define DEBUG_MSG                       0
+#define DEBUG_FW                        0
+
+#define NPE_COUNT                       3
+#define MAX_RETRIES                     1000    /* microseconds */
+#define NPE_42X_DATA_SIZE               0x800   /* in dwords */
+#define NPE_46X_DATA_SIZE               0x1000
+#define NPE_A_42X_INSTR_SIZE            0x1000
+#define NPE_B_AND_C_42X_INSTR_SIZE      0x800
+#define NPE_46X_INSTR_SIZE              0x1000
+#define REGS_SIZE                       0x1000
+
+#define NPE_PHYS_REG                    32
+
+#define FW_MAGIC                        0xFEEDF00D
+#define FW_BLOCK_TYPE_INSTR             0x0
+#define FW_BLOCK_TYPE_DATA              0x1
+#define FW_BLOCK_TYPE_EOF               0xF
+
+/* NPE exec status (read) and command (write) */
+#define CMD_NPE_STEP                    0x01
+#define CMD_NPE_START                   0x02
+#define CMD_NPE_STOP                    0x03
+#define CMD_NPE_CLR_PIPE                0x04
+#define CMD_CLR_PROFILE_CNT             0x0C
+#define CMD_RD_INS_MEM                  0x10 /* instruction memory */
+#define CMD_WR_INS_MEM                  0x11
+#define CMD_RD_DATA_MEM                 0x12 /* data memory */
+#define CMD_WR_DATA_MEM                 0x13
+#define CMD_RD_ECS_REG                  0x14 /* exec access register */
+#define CMD_WR_ECS_REG                  0x15
+
+#define STAT_RUN                        0x80000000
+#define STAT_STOP                       0x40000000
+#define STAT_CLEAR                      0x20000000
+#define STAT_ECS_K                      0x00800000 /* pipeline clean */
+
+#define NPE_STEVT                       0x1B
+#define NPE_STARTPC                     0x1C
+#define NPE_REGMAP                      0x1E
+#define NPE_CINDEX                      0x1F
+
+#define INSTR_WR_REG_SHORT              0x0000C000
+#define INSTR_WR_REG_BYTE               0x00004000
+#define INSTR_RD_FIFO                   0x0F888220
+#define INSTR_RESET_MBOX                0x0FAC8210
+
+#define ECS_BG_CTXT_REG_0               0x00 /* Background Executing Context */
+#define ECS_BG_CTXT_REG_1               0x01 /*         Stack level */
+#define ECS_BG_CTXT_REG_2               0x02
+#define ECS_PRI_1_CTXT_REG_0            0x04 /* Priority 1 Executing Context */
+#define ECS_PRI_1_CTXT_REG_1            0x05 /*         Stack level */
+#define ECS_PRI_1_CTXT_REG_2            0x06
+#define ECS_PRI_2_CTXT_REG_0            0x08 /* Priority 2 Executing Context */
+#define ECS_PRI_2_CTXT_REG_1            0x09 /*         Stack level */
+#define ECS_PRI_2_CTXT_REG_2            0x0A
+#define ECS_DBG_CTXT_REG_0              0x0C /* Debug Executing Context */
+#define ECS_DBG_CTXT_REG_1              0x0D /*         Stack level */
+#define ECS_DBG_CTXT_REG_2              0x0E
+#define ECS_INSTRUCT_REG                0x11 /* NPE Instruction Register */
+
+#define ECS_REG_0_ACTIVE                0x80000000 /* all levels */
+#define ECS_REG_0_NEXTPC_MASK           0x1FFF0000 /* BG/PRI1/PRI2 levels */
+#define ECS_REG_0_LDUR_BITS             8
+#define ECS_REG_0_LDUR_MASK             0x00000700 /* all levels */
+#define ECS_REG_1_CCTXT_BITS            16
+#define ECS_REG_1_CCTXT_MASK            0x000F0000 /* all levels */
+#define ECS_REG_1_SELCTXT_BITS          0
+#define ECS_REG_1_SELCTXT_MASK          0x0000000F /* all levels */
+#define ECS_DBG_REG_2_IF                0x00100000 /* debug level */
+#define ECS_DBG_REG_2_IE                0x00080000 /* debug level */
+
+/* NPE watchpoint_fifo register bit */
+#define WFIFO_VALID                     0x80000000
+
+/* NPE messaging_status register bit definitions */
+#define MSGSTAT_OFNE    0x00010000 /* OutFifoNotEmpty */
+#define MSGSTAT_IFNF    0x00020000 /* InFifoNotFull */
+#define MSGSTAT_OFNF    0x00040000 /* OutFifoNotFull */
+#define MSGSTAT_IFNE    0x00080000 /* InFifoNotEmpty */
+#define MSGSTAT_MBINT   0x00100000 /* Mailbox interrupt */
+#define MSGSTAT_IFINT   0x00200000 /* InFifo interrupt */
+#define MSGSTAT_OFINT   0x00400000 /* OutFifo interrupt */
+#define MSGSTAT_WFINT   0x00800000 /* WatchFifo interrupt */
+
+/* NPE messaging_control register bit definitions */
+#define MSGCTL_OUT_FIFO                 0x00010000 /* enable output FIFO */
+#define MSGCTL_IN_FIFO                  0x00020000 /* enable input FIFO */
+#define MSGCTL_OUT_FIFO_WRITE           0x01000000 /* enable FIFO + WRITE */
+#define MSGCTL_IN_FIFO_WRITE            0x02000000
+
+/* NPE mailbox_status value for reset */
+#define RESET_MBOX_STAT                 0x0000F0F0
+
+const char *npe_names[] = { "NPE-A", "NPE-B", "NPE-C" };
+
+#define print_npe(pri, npe, fmt, ...)                                   \
+        printk(pri "%s: " fmt, npe_name(npe), ## __VA_ARGS__)
+
+#if DEBUG_MSG
+#define debug_msg(npe, fmt, ...)                                        \
+        print_npe(KERN_DEBUG, npe, fmt, ## __VA_ARGS__)
+#else
+#define debug_msg(npe, fmt, ...)
+#endif
+
+static struct {
+        u32 reg, val;
+} ecs_reset[] = {
+        { ECS_BG_CTXT_REG_0,    0xA0000000 },
+        { ECS_BG_CTXT_REG_1,    0x01000000 },
+        { ECS_BG_CTXT_REG_2,    0x00008000 },
+        { ECS_PRI_1_CTXT_REG_0, 0x20000080 },
+        { ECS_PRI_1_CTXT_REG_1, 0x01000000 },
+        { ECS_PRI_1_CTXT_REG_2, 0x00008000 },
+        { ECS_PRI_2_CTXT_REG_0, 0x20000080 },
+        { ECS_PRI_2_CTXT_REG_1, 0x01000000 },
+        { ECS_PRI_2_CTXT_REG_2, 0x00008000 },
+        { ECS_DBG_CTXT_REG_0,   0x20000000 },
+        { ECS_DBG_CTXT_REG_1,   0x00000000 },
+        { ECS_DBG_CTXT_REG_2,   0x001E0000 },
+        { ECS_INSTRUCT_REG,     0x1003C00F },
+};
+
+static struct npe npe_tab[NPE_COUNT] = {
+        {
+                .id     = 0,
+                .regs   = (struct npe_regs __iomem *)IXP4XX_NPEA_BASE_VIRT,
+                .regs_phys = IXP4XX_NPEA_BASE_PHYS,
+        }, {
+                .id     = 1,
+                .regs   = (struct npe_regs __iomem *)IXP4XX_NPEB_BASE_VIRT,
+                .regs_phys = IXP4XX_NPEB_BASE_PHYS,
+        }, {
+                .id     = 2,
+                .regs   = (struct npe_regs __iomem *)IXP4XX_NPEC_BASE_VIRT,
+                .regs_phys = IXP4XX_NPEC_BASE_PHYS,
+        }
+};
+
+int npe_running(struct npe *npe)
+{
+        return (__raw_readl(&npe->regs->exec_status_cmd) & STAT_RUN) != 0;
+}
+
+static void npe_cmd_write(struct npe *npe, u32 addr, int cmd, u32 data)
+{
+        __raw_writel(data, &npe->regs->exec_data);
+        __raw_writel(addr, &npe->regs->exec_addr);
+        __raw_writel(cmd, &npe->regs->exec_status_cmd);
+}
+
+static u32 npe_cmd_read(struct npe *npe, u32 addr, int cmd)
+{
+        __raw_writel(addr, &npe->regs->exec_addr);
+        __raw_writel(cmd, &npe->regs->exec_status_cmd);
+        /* Iintroduce extra read cycles after issuing read command to NPE
+           so that we read the register after the NPE has updated it.
+           This is to overcome race condition between XScale and NPE */
+        __raw_readl(&npe->regs->exec_data);
+        __raw_readl(&npe->regs->exec_data);
+        return __raw_readl(&npe->regs->exec_data);
+}
+
+static void npe_clear_active(struct npe *npe, u32 reg)
+{
+        u32 val = npe_cmd_read(npe, reg, CMD_RD_ECS_REG);
+        npe_cmd_write(npe, reg, CMD_WR_ECS_REG, val & ~ECS_REG_0_ACTIVE);
+}
+
+static void npe_start(struct npe *npe)
+{
+        /* ensure only Background Context Stack Level is active */
+        npe_clear_active(npe, ECS_PRI_1_CTXT_REG_0);
+        npe_clear_active(npe, ECS_PRI_2_CTXT_REG_0);
+        npe_clear_active(npe, ECS_DBG_CTXT_REG_0);
+
+        __raw_writel(CMD_NPE_CLR_PIPE, &npe->regs->exec_status_cmd);
+        __raw_writel(CMD_NPE_START, &npe->regs->exec_status_cmd);
+}
+
+static void npe_stop(struct npe *npe)
+{
+        __raw_writel(CMD_NPE_STOP, &npe->regs->exec_status_cmd);
+        __raw_writel(CMD_NPE_CLR_PIPE, &npe->regs->exec_status_cmd); /*FIXME?*/
+}
+
+static int __must_check npe_debug_instr(struct npe *npe, u32 instr, u32 ctx,
+                                        u32 ldur)
+{
+        u32 wc;
+        int i;
+
+        /* set the Active bit, and the LDUR, in the debug level */
+        npe_cmd_write(npe, ECS_DBG_CTXT_REG_0, CMD_WR_ECS_REG,
+                      ECS_REG_0_ACTIVE | (ldur << ECS_REG_0_LDUR_BITS));
+
+        /* set CCTXT at ECS DEBUG L3 to specify in which context to execute
+           the instruction, and set SELCTXT at ECS DEBUG Level to specify
+           which context store to access.
+           Debug ECS Level Reg 1 has form 0x000n000n, where n = context number
+        */
+        npe_cmd_write(npe, ECS_DBG_CTXT_REG_1, CMD_WR_ECS_REG,
+                      (ctx << ECS_REG_1_CCTXT_BITS) |
+                      (ctx << ECS_REG_1_SELCTXT_BITS));
+
+        /* clear the pipeline */
+        __raw_writel(CMD_NPE_CLR_PIPE, &npe->regs->exec_status_cmd);
+
+        /* load NPE instruction into the instruction register */
+        npe_cmd_write(npe, ECS_INSTRUCT_REG, CMD_WR_ECS_REG, instr);
+
+        /* we need this value later to wait for completion of NPE execution
+           step */
+        wc = __raw_readl(&npe->regs->watch_count);
+
+        /* issue a Step One command via the Execution Control register */
+        __raw_writel(CMD_NPE_STEP, &npe->regs->exec_status_cmd);
+
+        /* Watch Count register increments when NPE completes an instruction */
+        for (i = 0; i < MAX_RETRIES; i++) {
+                if (wc != __raw_readl(&npe->regs->watch_count))
+                        return 0;
+                udelay(1);
+        }
+
+        print_npe(KERN_ERR, npe, "reset: npe_debug_instr(): timeout\n");
+        return -ETIMEDOUT;
+}
+
+static int __must_check npe_logical_reg_write8(struct npe *npe, u32 addr,
+                                               u8 val, u32 ctx)
+{
+        /* here we build the NPE assembler instruction: mov8 d0, #0 */
+        u32 instr = INSTR_WR_REG_BYTE | /* OpCode */
+                addr << 9 |             /* base Operand */
+                (val & 0x1F) << 4 |     /* lower 5 bits to immediate data */
+                (val & ~0x1F) << (18 - 5);/* higher 3 bits to CoProc instr. */
+        return npe_debug_instr(npe, instr, ctx, 1); /* execute it */
+}
+
+static int __must_check npe_logical_reg_write16(struct npe *npe, u32 addr,
+                                                u16 val, u32 ctx)
+{
+        /* here we build the NPE assembler instruction: mov16 d0, #0 */
+        u32 instr = INSTR_WR_REG_SHORT | /* OpCode */
+                addr << 9 |             /* base Operand */
+                (val & 0x1F) << 4 |     /* lower 5 bits to immediate data */
+                (val & ~0x1F) << (18 - 5);/* higher 11 bits to CoProc instr. */
+        return npe_debug_instr(npe, instr, ctx, 1); /* execute it */
+}
+
+static int __must_check npe_logical_reg_write32(struct npe *npe, u32 addr,
+                                                u32 val, u32 ctx)
+{
+        /* write in 16 bit steps first the high and then the low value */
+        if (npe_logical_reg_write16(npe, addr, val >> 16, ctx))
+                return -ETIMEDOUT;
+        return npe_logical_reg_write16(npe, addr + 2, val & 0xFFFF, ctx);
+}
+
+static int npe_reset(struct npe *npe)
+{
+        u32 val, ctl, exec_count, ctx_reg2;
+        int i;
+
+        ctl = (__raw_readl(&npe->regs->messaging_control) | 0x3F000000) &
+                0x3F3FFFFF;
+
+        /* disable parity interrupt */
+        __raw_writel(ctl & 0x3F00FFFF, &npe->regs->messaging_control);
+
+        /* pre exec - debug instruction */
+        /* turn off the halt bit by clearing Execution Count register. */
+        exec_count = __raw_readl(&npe->regs->exec_count);
+        __raw_writel(0, &npe->regs->exec_count);
+        /* ensure that IF and IE are on (temporarily), so that we don't end up
+           stepping forever */
+        ctx_reg2 = npe_cmd_read(npe, ECS_DBG_CTXT_REG_2, CMD_RD_ECS_REG);
+        npe_cmd_write(npe, ECS_DBG_CTXT_REG_2, CMD_WR_ECS_REG, ctx_reg2 |
+                      ECS_DBG_REG_2_IF | ECS_DBG_REG_2_IE);
+
+        /* clear the FIFOs */
+        while (__raw_readl(&npe->regs->watchpoint_fifo) & WFIFO_VALID)
+                ;
+        while (__raw_readl(&npe->regs->messaging_status) & MSGSTAT_OFNE)
+                /* read from the outFIFO until empty */
+                print_npe(KERN_DEBUG, npe, "npe_reset: read FIFO = 0x%X\n",
+                          __raw_readl(&npe->regs->in_out_fifo));
+
+        while (__raw_readl(&npe->regs->messaging_status) & MSGSTAT_IFNE)
+                /* step execution of the NPE intruction to read inFIFO using
+                   the Debug Executing Context stack */
+                if (npe_debug_instr(npe, INSTR_RD_FIFO, 0, 0))
+                        return -ETIMEDOUT;
+
+        /* reset the mailbox reg from the XScale side */
+        __raw_writel(RESET_MBOX_STAT, &npe->regs->mailbox_status);
+        /* from NPE side */
+        if (npe_debug_instr(npe, INSTR_RESET_MBOX, 0, 0))
+                return -ETIMEDOUT;
+
+        /* Reset the physical registers in the NPE register file */
+        for (val = 0; val < NPE_PHYS_REG; val++) {
+                if (npe_logical_reg_write16(npe, NPE_REGMAP, val >> 1, 0))
+                        return -ETIMEDOUT;
+                /* address is either 0 or 4 */
+                if (npe_logical_reg_write32(npe, (val & 1) * 4, 0, 0))
+                        return -ETIMEDOUT;
+        }
+
+        /* Reset the context store = each context's Context Store registers */
+
+        /* Context 0 has no STARTPC. Instead, this value is used to set NextPC
+           for Background ECS, to set where NPE starts executing code */
+        val = npe_cmd_read(npe, ECS_BG_CTXT_REG_0, CMD_RD_ECS_REG);
+        val &= ~ECS_REG_0_NEXTPC_MASK;
+        val |= (0 /* NextPC */ << 16) & ECS_REG_0_NEXTPC_MASK;
+        npe_cmd_write(npe, ECS_BG_CTXT_REG_0, CMD_WR_ECS_REG, val);
+
+        for (i = 0; i < 16; i++) {
+                if (i) {        /* Context 0 has no STEVT nor STARTPC */
+                        /* STEVT = off, 0x80 */
+                        if (npe_logical_reg_write8(npe, NPE_STEVT, 0x80, i))
+                                return -ETIMEDOUT;
+                        if (npe_logical_reg_write16(npe, NPE_STARTPC, 0, i))
+                                return -ETIMEDOUT;
+                }
+                /* REGMAP = d0->p0, d8->p2, d16->p4 */
+                if (npe_logical_reg_write16(npe, NPE_REGMAP, 0x820, i))
+                        return -ETIMEDOUT;
+                if (npe_logical_reg_write8(npe, NPE_CINDEX, 0, i))
+                        return -ETIMEDOUT;
+        }
+
+        /* post exec */
+        /* clear active bit in debug level */
+        npe_cmd_write(npe, ECS_DBG_CTXT_REG_0, CMD_WR_ECS_REG, 0);
+        /* clear the pipeline */
+        __raw_writel(CMD_NPE_CLR_PIPE, &npe->regs->exec_status_cmd);
+        /* restore previous values */
+        __raw_writel(exec_count, &npe->regs->exec_count);
+        npe_cmd_write(npe, ECS_DBG_CTXT_REG_2, CMD_WR_ECS_REG, ctx_reg2);
+
+        /* write reset values to Execution Context Stack registers */
+        for (val = 0; val < ARRAY_SIZE(ecs_reset); val++)
+                npe_cmd_write(npe, ecs_reset[val].reg, CMD_WR_ECS_REG,
+                              ecs_reset[val].val);
+
+        /* clear the profile counter */
+        __raw_writel(CMD_CLR_PROFILE_CNT, &npe->regs->exec_status_cmd);
+
+        __raw_writel(0, &npe->regs->exec_count);
+        __raw_writel(0, &npe->regs->action_points[0]);
+        __raw_writel(0, &npe->regs->action_points[1]);
+        __raw_writel(0, &npe->regs->action_points[2]);
+        __raw_writel(0, &npe->regs->action_points[3]);
+        __raw_writel(0, &npe->regs->watch_count);
+
+        val = ixp4xx_read_feature_bits();
+        /* reset the NPE */
+        ixp4xx_write_feature_bits(val &
+                                  ~(IXP4XX_FEATURE_RESET_NPEA << npe->id));
+        for (i = 0; i < MAX_RETRIES; i++) {
+                if (!(ixp4xx_read_feature_bits() &
+                      (IXP4XX_FEATURE_RESET_NPEA << npe->id)))
+                        break;  /* reset completed */
+                udelay(1);
+        }
+        if (i == MAX_RETRIES)
+                return -ETIMEDOUT;
+
+        /* deassert reset */
+        ixp4xx_write_feature_bits(val |
+                                  (IXP4XX_FEATURE_RESET_NPEA << npe->id));
+        for (i = 0; i < MAX_RETRIES; i++) {
+                if (ixp4xx_read_feature_bits() &
+                    (IXP4XX_FEATURE_RESET_NPEA << npe->id))
+                        break;  /* NPE is back alive */
+                udelay(1);
+        }
+        if (i == MAX_RETRIES)
+                return -ETIMEDOUT;
+
+        npe_stop(npe);
+
+        /* restore NPE configuration bus Control Register - parity settings */
+        __raw_writel(ctl, &npe->regs->messaging_control);
+        return 0;
+}
+
+
+int npe_send_message(struct npe *npe, const void *msg, const char *what)
+{
+        const u32 *send = msg;
+        int cycles = 0;
+
+        debug_msg(npe, "Trying to send message %s [%08X:%08X]\n",
+                  what, send[0], send[1]);
+
+        if (__raw_readl(&npe->regs->messaging_status) & MSGSTAT_IFNE) {
+                debug_msg(npe, "NPE input FIFO not empty\n");
+                return -EIO;
+        }
+
+        __raw_writel(send[0], &npe->regs->in_out_fifo);
+
+        if (!(__raw_readl(&npe->regs->messaging_status) & MSGSTAT_IFNF)) {
+                debug_msg(npe, "NPE input FIFO full\n");
+                return -EIO;
+        }
+
+        __raw_writel(send[1], &npe->regs->in_out_fifo);
+
+        while ((cycles < MAX_RETRIES) &&
+               (__raw_readl(&npe->regs->messaging_status) & MSGSTAT_IFNE)) {
+                udelay(1);
+                cycles++;
+        }
+
+        if (cycles == MAX_RETRIES) {
+                debug_msg(npe, "Timeout sending message\n");
+                return -ETIMEDOUT;
+        }
+
+        debug_msg(npe, "Sending a message took %i cycles\n", cycles);
+        return 0;
+}
+
+int npe_recv_message(struct npe *npe, void *msg, const char *what)
+{
+        u32 *recv = msg;
+        int cycles = 0, cnt = 0;
+
+        debug_msg(npe, "Trying to receive message %s\n", what);
+
+        while (cycles < MAX_RETRIES) {
+                if (__raw_readl(&npe->regs->messaging_status) & MSGSTAT_OFNE) {
+                        recv[cnt++] = __raw_readl(&npe->regs->in_out_fifo);
+                        if (cnt == 2)
+                                break;
+                } else {
+                        udelay(1);
+                        cycles++;
+                }
+        }
+
+        switch(cnt) {
+        case 1:
+                debug_msg(npe, "Received [%08X]\n", recv[0]);
+                break;
+        case 2:
+                debug_msg(npe, "Received [%08X:%08X]\n", recv[0], recv[1]);
+                break;
+        }
+
+        if (cycles == MAX_RETRIES) {
+                debug_msg(npe, "Timeout waiting for message\n");
+                return -ETIMEDOUT;
+        }
+
+        debug_msg(npe, "Receiving a message took %i cycles\n", cycles);
+        return 0;
+}
+
+int npe_send_recv_message(struct npe *npe, void *msg, const char *what)
+{
+        int result;
+        u32 *send = msg, recv[2];
+
+        if ((result = npe_send_message(npe, msg, what)) != 0)
+                return result;
+        if ((result = npe_recv_message(npe, recv, what)) != 0)
+                return result;
+
+        if ((recv[0] != send[0]) || (recv[1] != send[1])) {
+                debug_msg(npe, "Message %s: unexpected message received\n",
+                          what);
+                return -EIO;
+        }
+        return 0;
+}
+
+
+int npe_load_firmware(struct npe *npe, const char *name, struct device *dev)
+{
+        const struct firmware *fw_entry;
+
+        struct dl_block {
+                u32 type;
+                u32 offset;
+        } *blk;
+
+        struct dl_image {
+                u32 magic;
+                u32 id;
+                u32 size;
+                union {
+                        u32 data[0];
+                        struct dl_block blocks[0];
+                };
+        } *image;
+
+        struct dl_codeblock {
+                u32 npe_addr;
+                u32 size;
+                u32 data[0];
+        } *cb;
+
+        int i, j, err, data_size, instr_size, blocks, table_end;
+        u32 cmd;
+
+        if ((err = request_firmware(&fw_entry, name, dev)) != 0)
+                return err;
+
+        err = -EINVAL;
+        if (fw_entry->size < sizeof(struct dl_image)) {
+                print_npe(KERN_ERR, npe, "incomplete firmware file\n");
+                goto err;
+        }
+        image = (struct dl_image*)fw_entry->data;
+
+#if DEBUG_FW
+        print_npe(KERN_DEBUG, npe, "firmware: %08X %08X %08X (0x%X bytes)\n",
+                  image->magic, image->id, image->size, image->size * 4);
+#endif
+
+        if (image->magic == swab32(FW_MAGIC)) { /* swapped file */
+                image->id = swab32(image->id);
+                image->size = swab32(image->size);
+        } else if (image->magic != FW_MAGIC) {
+                print_npe(KERN_ERR, npe, "bad firmware file magic: 0x%X\n",
+                          image->magic);
+                goto err;
+        }
+        if ((image->size * 4 + sizeof(struct dl_image)) != fw_entry->size) {
+                print_npe(KERN_ERR, npe,
+                          "inconsistent size of firmware file\n");
+                goto err;
+        }
+        if (((image->id >> 24) & 0xF /* NPE ID */) != npe->id) {
+                print_npe(KERN_ERR, npe, "firmware file NPE ID mismatch\n");
+                goto err;
+        }
+        if (image->magic == swab32(FW_MAGIC))
+                for (i = 0; i < image->size; i++)
+                        image->data[i] = swab32(image->data[i]);
+
+        if (!cpu_is_ixp46x() && ((image->id >> 28) & 0xF /* device ID */)) {
+                print_npe(KERN_INFO, npe, "IXP46x firmware ignored on "
+                          "IXP42x\n");
+                goto err;
+        }
+
+        if (npe_running(npe)) {
+                print_npe(KERN_INFO, npe, "unable to load firmware, NPE is "
+                          "already running\n");
+                err = -EBUSY;
+                goto err;
+        }
+#if 0
+        npe_stop(npe);
+        npe_reset(npe);
+#endif
+
+        print_npe(KERN_INFO, npe, "firmware functionality 0x%X, "
+                  "revision 0x%X:%X\n", (image->id >> 16) & 0xFF,
+                  (image->id >> 8) & 0xFF, image->id & 0xFF);
+
+        if (!cpu_is_ixp46x()) {
+                if (!npe->id)
+                        instr_size = NPE_A_42X_INSTR_SIZE;
+                else
+                        instr_size = NPE_B_AND_C_42X_INSTR_SIZE;
+                data_size = NPE_42X_DATA_SIZE;
+        } else {
+                instr_size = NPE_46X_INSTR_SIZE;
+                data_size = NPE_46X_DATA_SIZE;
+        }
+
+        for (blocks = 0; blocks * sizeof(struct dl_block) / 4 < image->size;
+             blocks++)
+                if (image->blocks[blocks].type == FW_BLOCK_TYPE_EOF)
+                        break;
+        if (blocks * sizeof(struct dl_block) / 4 >= image->size) {
+                print_npe(KERN_INFO, npe, "firmware EOF block marker not "
+                          "found\n");
+                goto err;
+        }
+
+#if DEBUG_FW
+        print_npe(KERN_DEBUG, npe, "%i firmware blocks found\n", blocks);
+#endif
+
+        table_end = blocks * sizeof(struct dl_block) / 4 + 1 /* EOF marker */;
+        for (i = 0, blk = image->blocks; i < blocks; i++, blk++) {
+                if (blk->offset > image->size - sizeof(struct dl_codeblock) / 4
+                    || blk->offset < table_end) {
+                        print_npe(KERN_INFO, npe, "invalid offset 0x%X of "
+                                  "firmware block #%i\n", blk->offset, i);
+                        goto err;
+                }
+
+                cb = (struct dl_codeblock*)&image->data[blk->offset];
+                if (blk->type == FW_BLOCK_TYPE_INSTR) {
+                        if (cb->npe_addr + cb->size > instr_size)
+                                goto too_big;
+                        cmd = CMD_WR_INS_MEM;
+                } else if (blk->type == FW_BLOCK_TYPE_DATA) {
+                        if (cb->npe_addr + cb->size > data_size)
+                                goto too_big;
+                        cmd = CMD_WR_DATA_MEM;
+                } else {
+                        print_npe(KERN_INFO, npe, "invalid firmware block #%i "
+                                  "type 0x%X\n", i, blk->type);
+                        goto err;
+                }
+                if (blk->offset + sizeof(*cb) / 4 + cb->size > image->size) {
+                        print_npe(KERN_INFO, npe, "firmware block #%i doesn't "
+                                  "fit in firmware image: type %c, start 0x%X,"
+                                  " length 0x%X\n", i,
+                                  blk->type == FW_BLOCK_TYPE_INSTR ? 'I' : 'D',
+                                  cb->npe_addr, cb->size);
+                        goto err;
+                }
+
+                for (j = 0; j < cb->size; j++)
+                        npe_cmd_write(npe, cb->npe_addr + j, cmd, cb->data[j]);
+        }
+
+        npe_start(npe);
+        if (!npe_running(npe))
+                print_npe(KERN_ERR, npe, "unable to start\n");
+        release_firmware(fw_entry);
+        return 0;
+
+too_big:
+        print_npe(KERN_INFO, npe, "firmware block #%i doesn't fit in NPE "
+                  "memory: type %c, start 0x%X, length 0x%X\n", i,
+                  blk->type == FW_BLOCK_TYPE_INSTR ? 'I' : 'D',
+                  cb->npe_addr, cb->size);
+err:
+        release_firmware(fw_entry);
+        return err;
+}
+
+
+struct npe *npe_request(int id)
+{
+        if (id < NPE_COUNT)
+                if (npe_tab[id].valid)
+                        if (try_module_get(THIS_MODULE))
+                                return &npe_tab[id];
+        return NULL;
+}
+
+void npe_release(struct npe *npe)
+{
+        module_put(THIS_MODULE);
+}
+
+
+static int __init npe_init_module(void)
+{
+
+        int i, found = 0;
+
+        for (i = 0; i < NPE_COUNT; i++) {
+                struct npe *npe = &npe_tab[i];
+                if (!(ixp4xx_read_feature_bits() &
+                      (IXP4XX_FEATURE_RESET_NPEA << i)))
+                        continue; /* NPE already disabled or not present */
+                if (!(npe->mem_res = request_mem_region(npe->regs_phys,
+                                                        REGS_SIZE,
+                                                        npe_name(npe)))) {
+                        print_npe(KERN_ERR, npe,
+                                  "failed to request memory region\n");
+                        continue;
+                }
+
+                if (npe_reset(npe))
+                        continue;
+                npe->valid = 1;
+                found++;
+        }
+
+        if (!found)
+                return -ENOSYS;
+        return 0;
+}
+
+static void __exit npe_cleanup_module(void)
+{
+        int i;
+
+        for (i = 0; i < NPE_COUNT; i++)
+                if (npe_tab[i].mem_res) {
+                        npe_reset(&npe_tab[i]);
+                        release_resource(npe_tab[i].mem_res);
+                }
+}
+
+module_init(npe_init_module);
+module_exit(npe_cleanup_module);
+
+MODULE_AUTHOR("Krzysztof Halasa");
+MODULE_LICENSE("GPL v2");
+
+EXPORT_SYMBOL(npe_names);
+EXPORT_SYMBOL(npe_running);
+EXPORT_SYMBOL(npe_request);
+EXPORT_SYMBOL(npe_release);
+EXPORT_SYMBOL(npe_load_firmware);
+EXPORT_SYMBOL(npe_send_message);
+EXPORT_SYMBOL(npe_recv_message);
+EXPORT_SYMBOL(npe_send_recv_message);
diff --git a/arch/arm/mach-ixp4xx/ixp4xx_qmgr.c b/arch/arm/mach-ixp4xx/ixp4xx_qmgr.c
new file mode 100644
index 000000000000..e83301325301
--- /dev/null
+++ b/arch/arm/mach-ixp4xx/ixp4xx_qmgr.c
@@ -0,0 +1,274 @@
+/*
+ * Intel IXP4xx Queue Manager driver for Linux
+ *
+ * Copyright (C) 2007 Krzysztof Halasa <khc@pm.waw.pl>
+ *
+ * This program 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.
+ */
+
+#include <linux/ioport.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <asm/arch/qmgr.h>
+
+#define DEBUG           0
+
+struct qmgr_regs __iomem *qmgr_regs;
+static struct resource *mem_res;
+static spinlock_t qmgr_lock;
+static u32 used_sram_bitmap[4]; /* 128 16-dword pages */
+static void (*irq_handlers[HALF_QUEUES])(void *pdev);
+static void *irq_pdevs[HALF_QUEUES];
+
+void qmgr_set_irq(unsigned int queue, int src,
+                  void (*handler)(void *pdev), void *pdev)
+{
+        u32 __iomem *reg = &qmgr_regs->irqsrc[queue / 8]; /* 8 queues / u32 */
+        int bit = (queue % 8) * 4; /* 3 bits + 1 reserved bit per queue */
+        unsigned long flags;
+
+        src &= 7;
+        spin_lock_irqsave(&qmgr_lock, flags);
+        __raw_writel((__raw_readl(reg) & ~(7 << bit)) | (src << bit), reg);
+        irq_handlers[queue] = handler;
+        irq_pdevs[queue] = pdev;
+        spin_unlock_irqrestore(&qmgr_lock, flags);
+}
+
+
+static irqreturn_t qmgr_irq1(int irq, void *pdev)
+{
+        int i;
+        u32 val = __raw_readl(&qmgr_regs->irqstat[0]);
+        __raw_writel(val, &qmgr_regs->irqstat[0]); /* ACK */
+
+        for (i = 0; i < HALF_QUEUES; i++)
+                if (val & (1 << i))
+                        irq_handlers[i](irq_pdevs[i]);
+
+        return val ? IRQ_HANDLED : 0;
+}
+
+
+void qmgr_enable_irq(unsigned int queue)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&qmgr_lock, flags);
+        __raw_writel(__raw_readl(&qmgr_regs->irqen[0]) | (1 << queue),
+                     &qmgr_regs->irqen[0]);
+        spin_unlock_irqrestore(&qmgr_lock, flags);
+}
+
+void qmgr_disable_irq(unsigned int queue)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&qmgr_lock, flags);
+        __raw_writel(__raw_readl(&qmgr_regs->irqen[0]) & ~(1 << queue),
+                     &qmgr_regs->irqen[0]);
+        spin_unlock_irqrestore(&qmgr_lock, flags);
+}
+
+static inline void shift_mask(u32 *mask)
+{
+        mask[3] = mask[3] << 1 | mask[2] >> 31;
+        mask[2] = mask[2] << 1 | mask[1] >> 31;
+        mask[1] = mask[1] << 1 | mask[0] >> 31;
+        mask[0] <<= 1;
+}
+
+int qmgr_request_queue(unsigned int queue, unsigned int len /* dwords */,
+                       unsigned int nearly_empty_watermark,
+                       unsigned int nearly_full_watermark)
+{
+        u32 cfg, addr = 0, mask[4]; /* in 16-dwords */
+        int err;
+
+        if (queue >= HALF_QUEUES)
+                return -ERANGE;
+
+        if ((nearly_empty_watermark | nearly_full_watermark) & ~7)
+                return -EINVAL;
+
+        switch (len) {
+        case  16:
+                cfg = 0 << 24;
+                mask[0] = 0x1;
+                break;
+        case  32:
+                cfg = 1 << 24;
+                mask[0] = 0x3;
+                break;
+        case  64:
+                cfg = 2 << 24;
+                mask[0] = 0xF;
+                break;
+        case 128:
+                cfg = 3 << 24;
+                mask[0] = 0xFF;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        cfg |= nearly_empty_watermark << 26;
+        cfg |= nearly_full_watermark << 29;
+        len /= 16;              /* in 16-dwords: 1, 2, 4 or 8 */
+        mask[1] = mask[2] = mask[3] = 0;
+
+        if (!try_module_get(THIS_MODULE))
+                return -ENODEV;
+
+        spin_lock_irq(&qmgr_lock);
+        if (__raw_readl(&qmgr_regs->sram[queue])) {
+                err = -EBUSY;
+                goto err;
+        }
+
+        while (1) {
+                if (!(used_sram_bitmap[0] & mask[0]) &&
+                    !(used_sram_bitmap[1] & mask[1]) &&
+                    !(used_sram_bitmap[2] & mask[2]) &&
+                    !(used_sram_bitmap[3] & mask[3]))
+                        break; /* found free space */
+
+                addr++;
+                shift_mask(mask);
+                if (addr + len > ARRAY_SIZE(qmgr_regs->sram)) {
+                        printk(KERN_ERR "qmgr: no free SRAM space for"
+                               " queue %i\n", queue);
+                        err = -ENOMEM;
+                        goto err;
+                }
+        }
+
+        used_sram_bitmap[0] |= mask[0];
+        used_sram_bitmap[1] |= mask[1];
+        used_sram_bitmap[2] |= mask[2];
+        used_sram_bitmap[3] |= mask[3];
+        __raw_writel(cfg | (addr << 14), &qmgr_regs->sram[queue]);
+        spin_unlock_irq(&qmgr_lock);
+
+#if DEBUG
+        printk(KERN_DEBUG "qmgr: requested queue %i, addr = 0x%02X\n",
+               queue, addr);
+#endif
+        return 0;
+
+err:
+        spin_unlock_irq(&qmgr_lock);
+        module_put(THIS_MODULE);
+        return err;
+}
+
+void qmgr_release_queue(unsigned int queue)
+{
+        u32 cfg, addr, mask[4];
+
+        BUG_ON(queue >= HALF_QUEUES); /* not in valid range */
+
+        spin_lock_irq(&qmgr_lock);
+        cfg = __raw_readl(&qmgr_regs->sram[queue]);
+        addr = (cfg >> 14) & 0xFF;
+
+        BUG_ON(!addr);          /* not requested */
+
+        switch ((cfg >> 24) & 3) {
+        case 0: mask[0] = 0x1; break;
+        case 1: mask[0] = 0x3; break;
+        case 2: mask[0] = 0xF; break;
+        case 3: mask[0] = 0xFF; break;
+        }
+
+        while (addr--)
+                shift_mask(mask);
+
+        __raw_writel(0, &qmgr_regs->sram[queue]);
+
+        used_sram_bitmap[0] &= ~mask[0];
+        used_sram_bitmap[1] &= ~mask[1];
+        used_sram_bitmap[2] &= ~mask[2];
+        used_sram_bitmap[3] &= ~mask[3];
+        irq_handlers[queue] = NULL; /* catch IRQ bugs */
+        spin_unlock_irq(&qmgr_lock);
+
+        module_put(THIS_MODULE);
+#if DEBUG
+        printk(KERN_DEBUG "qmgr: released queue %i\n", queue);
+#endif
+}
+
+static int qmgr_init(void)
+{
+        int i, err;
+        mem_res = request_mem_region(IXP4XX_QMGR_BASE_PHYS,
+                                     IXP4XX_QMGR_REGION_SIZE,
+                                     "IXP4xx Queue Manager");
+        if (mem_res == NULL)
+                return -EBUSY;
+
+        qmgr_regs = ioremap(IXP4XX_QMGR_BASE_PHYS, IXP4XX_QMGR_REGION_SIZE);
+        if (qmgr_regs == NULL) {
+                err = -ENOMEM;
+                goto error_map;
+        }
+
+        /* reset qmgr registers */
+        for (i = 0; i < 4; i++) {
+                __raw_writel(0x33333333, &qmgr_regs->stat1[i]);
+                __raw_writel(0, &qmgr_regs->irqsrc[i]);
+        }
+        for (i = 0; i < 2; i++) {
+                __raw_writel(0, &qmgr_regs->stat2[i]);
+                __raw_writel(0xFFFFFFFF, &qmgr_regs->irqstat[i]); /* clear */
+                __raw_writel(0, &qmgr_regs->irqen[i]);
+        }
+
+        for (i = 0; i < QUEUES; i++)
+                __raw_writel(0, &qmgr_regs->sram[i]);
+
+        err = request_irq(IRQ_IXP4XX_QM1, qmgr_irq1, 0,
+                          "IXP4xx Queue Manager", NULL);
+        if (err) {
+                printk(KERN_ERR "qmgr: failed to request IRQ%i\n",
+                       IRQ_IXP4XX_QM1);
+                goto error_irq;
+        }
+
+        used_sram_bitmap[0] = 0xF; /* 4 first pages reserved for config */
+        spin_lock_init(&qmgr_lock);
+
+        printk(KERN_INFO "IXP4xx Queue Manager initialized.\n");
+        return 0;
+
+error_irq:
+        iounmap(qmgr_regs);
+error_map:
+        release_mem_region(IXP4XX_QMGR_BASE_PHYS, IXP4XX_QMGR_REGION_SIZE);
+        return err;
+}
+
+static void qmgr_remove(void)
+{
+        free_irq(IRQ_IXP4XX_QM1, NULL);
+        synchronize_irq(IRQ_IXP4XX_QM1);
+        iounmap(qmgr_regs);
+        release_mem_region(IXP4XX_QMGR_BASE_PHYS, IXP4XX_QMGR_REGION_SIZE);
+}
+
+module_init(qmgr_init);
+module_exit(qmgr_remove);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Krzysztof Halasa");
+
+EXPORT_SYMBOL(qmgr_regs);
+EXPORT_SYMBOL(qmgr_set_irq);
+EXPORT_SYMBOL(qmgr_enable_irq);
+EXPORT_SYMBOL(qmgr_disable_irq);
+EXPORT_SYMBOL(qmgr_request_queue);
+EXPORT_SYMBOL(qmgr_release_queue);
diff --git a/arch/arm/mach-ixp4xx/nas100d-power.c b/arch/arm/mach-ixp4xx/nas100d-power.c
deleted file mode 100644
index 29aa98d3a7fa..000000000000
--- a/arch/arm/mach-ixp4xx/nas100d-power.c
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * arch/arm/mach-ixp4xx/nas100d-power.c
- *
- * NAS 100d Power/Reset driver
- *
- * Copyright (C) 2005 Tower Technologies
- *
- * based on nas100d-io.c
- *  Copyright (C) 2004 Karen Spearel
- *
- * Author: Alessandro Zummo <a.zummo@towertech.it>
- * Maintainers: http://www.nslu2-linux.org/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/interrupt.h>
-#include <linux/irq.h>
-#include <linux/module.h>
-#include <linux/reboot.h>
-
-#include <asm/mach-types.h>
-
-static irqreturn_t nas100d_reset_handler(int irq, void *dev_id)
-{
-        /* Signal init to do the ctrlaltdel action, this will bypass init if
-         * it hasn't started and do a kernel_restart.
-         */
-        ctrl_alt_del();
-
-        return IRQ_HANDLED;
-}
-
-static int __init nas100d_power_init(void)
-{
-        if (!(machine_is_nas100d()))
-                return 0;
-
-        set_irq_type(NAS100D_RB_IRQ, IRQT_LOW);
-
-        if (request_irq(NAS100D_RB_IRQ, &nas100d_reset_handler,
-                IRQF_DISABLED, "NAS100D reset button", NULL) < 0) {
-
-                printk(KERN_DEBUG "Reset Button IRQ %d not available\n",
-                        NAS100D_RB_IRQ);
-
-                return -EIO;
-        }
-
-        return 0;
-}
-
-static void __exit nas100d_power_exit(void)
-{
-        if (!(machine_is_nas100d()))
-                return;
-
-        free_irq(NAS100D_RB_IRQ, NULL);
-}
-
-module_init(nas100d_power_init);
-module_exit(nas100d_power_exit);
-
-MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
-MODULE_DESCRIPTION("NAS100D Power/Reset driver");
-MODULE_LICENSE("GPL");
diff --git a/arch/arm/mach-ixp4xx/nas100d-setup.c b/arch/arm/mach-ixp4xx/nas100d-setup.c
index 54d884fb2517..4cecae84837b 100644
--- a/arch/arm/mach-ixp4xx/nas100d-setup.c
+++ b/arch/arm/mach-ixp4xx/nas100d-setup.c
@@ -3,8 +3,14 @@
  *
  * NAS 100d board-setup
  *
- * based ixdp425-setup.c:
+ * Copyright (C) 2008 Rod Whitby <rod@whitby.id.au>
+ *
+ * based on ixdp425-setup.c:
  *      Copyright (C) 2003-2004 MontaVista Software, Inc.
+ * based on nas100d-power.c:
+ *      Copyright (C) 2005 Tower Technologies
+ * based on nas100d-io.c
+ *      Copyright (C) 2004 Karen Spearel
  *
  * Author: Alessandro Zummo <a.zummo@towertech.it>
  * Author: Rod Whitby <rod@whitby.id.au>
@@ -12,15 +18,22 @@
  *
  */
 
-#include <linux/kernel.h>
+#include <linux/if_ether.h>
+#include <linux/irq.h>
+#include <linux/jiffies.h>
+#include <linux/timer.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
 #include <linux/leds.h>
+#include <linux/reboot.h>
+#include <linux/i2c.h>
 #include <linux/i2c-gpio.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/flash.h>
+#include <asm/io.h>
+#include <asm/gpio.h>
 
 static struct flash_platform_data nas100d_flash_data = {
         .map_name               = "cfi_probe",
@@ -39,35 +52,40 @@ static struct platform_device nas100d_flash = {
         .resource               = &nas100d_flash_resource,
 };
 
-#ifdef CONFIG_LEDS_IXP4XX
-static struct resource nas100d_led_resources[] = {
+static struct i2c_board_info __initdata nas100d_i2c_board_info [] = {
+        {
+                I2C_BOARD_INFO("rtc-pcf8563", 0x51),
+        },
+};
+
+static struct gpio_led nas100d_led_pins[] = {
         {
                 .name           = "wlan",   /* green led */
-                .start          = 0,
-                .end            = 0,
-                .flags          = IXP4XX_GPIO_LOW,
+                .gpio           = NAS100D_LED_WLAN_GPIO,
+                .active_low     = true,
         },
         {
-                .name           = "ready",  /* blue power led (off is flashing!) */
-                .start          = 15,
-                .end            = 15,
-                .flags          = IXP4XX_GPIO_LOW,
+                .name           = "power",  /* blue power led (off=flashing) */
+                .gpio           = NAS100D_LED_PWR_GPIO,
+                .active_low     = true,
         },
         {
                 .name           = "disk",   /* yellow led */
-                .start          = 3,
-                .end            = 3,
-                .flags          = IXP4XX_GPIO_LOW,
+                .gpio           = NAS100D_LED_DISK_GPIO,
+                .active_low     = true,
         },
 };
 
+static struct gpio_led_platform_data nas100d_led_data = {
+        .num_leds               = ARRAY_SIZE(nas100d_led_pins),
+        .leds                   = nas100d_led_pins,
+};
+
 static struct platform_device nas100d_leds = {
-        .name                   = "IXP4XX-GPIO-LED",
+        .name                   = "leds-gpio",
         .id                     = -1,
-        .num_resources          = ARRAY_SIZE(nas100d_led_resources),
-        .resource               = nas100d_led_resources,
+        .dev.platform_data      = &nas100d_led_data,
 };
-#endif
 
 static struct i2c_gpio_platform_data nas100d_i2c_gpio_data = {
         .sda_pin                = NAS100D_SDA_PIN,
@@ -125,12 +143,28 @@ static struct platform_device nas100d_uart = {
         .resource               = nas100d_uart_resources,
 };
 
+/* Built-in 10/100 Ethernet MAC interfaces */
+static struct eth_plat_info nas100d_plat_eth[] = {
+        {
+                .phy            = 0,
+                .rxq            = 3,
+                .txreadyq       = 20,
+        }
+};
+
+static struct platform_device nas100d_eth[] = {
+        {
+                .name                   = "ixp4xx_eth",
+                .id                     = IXP4XX_ETH_NPEB,
+                .dev.platform_data      = nas100d_plat_eth,
+        }
+};
+
 static struct platform_device *nas100d_devices[] __initdata = {
         &nas100d_i2c_gpio,
         &nas100d_flash,
-#ifdef CONFIG_LEDS_IXP4XX
         &nas100d_leds,
-#endif
+        &nas100d_eth[0],
 };
 
 static void nas100d_power_off(void)
@@ -144,8 +178,63 @@ static void nas100d_power_off(void)
         gpio_line_set(NAS100D_PO_GPIO, IXP4XX_GPIO_HIGH);
 }
 
+/* This is used to make sure the power-button pusher is serious.  The button
+ * must be held until the value of this counter reaches zero.
+ */
+static int power_button_countdown;
+
+/* Must hold the button down for at least this many counts to be processed */
+#define PBUTTON_HOLDDOWN_COUNT 4 /* 2 secs */
+
+static void nas100d_power_handler(unsigned long data);
+static DEFINE_TIMER(nas100d_power_timer, nas100d_power_handler, 0, 0);
+
+static void nas100d_power_handler(unsigned long data)
+{
+        /* This routine is called twice per second to check the
+         * state of the power button.
+         */
+
+        if (gpio_get_value(NAS100D_PB_GPIO)) {
+
+                /* IO Pin is 1 (button pushed) */
+                if (power_button_countdown > 0)
+                        power_button_countdown--;
+
+        } else {
+
+                /* Done on button release, to allow for auto-power-on mods. */
+                if (power_button_countdown == 0) {
+                        /* Signal init to do the ctrlaltdel action,
+                         * this will bypass init if it hasn't started
+                         * and do a kernel_restart.
+                         */
+                        ctrl_alt_del();
+
+                        /* Change the state of the power LED to "blink" */
+                        gpio_line_set(NAS100D_LED_PWR_GPIO, IXP4XX_GPIO_LOW);
+                } else {
+                        power_button_countdown = PBUTTON_HOLDDOWN_COUNT;
+                }
+        }
+
+        mod_timer(&nas100d_power_timer, jiffies + msecs_to_jiffies(500));
+}
+
+static irqreturn_t nas100d_reset_handler(int irq, void *dev_id)
+{
+        /* This is the paper-clip reset, it shuts the machine down directly. */
+        machine_power_off();
+
+        return IRQ_HANDLED;
+}
+
 static void __init nas100d_init(void)
 {
+        DECLARE_MAC_BUF(mac_buf);
+        uint8_t __iomem *f;
+        int i;
+
         ixp4xx_sys_init();
 
         /* gpio 14 and 15 are _not_ clocks */
@@ -155,7 +244,8 @@ static void __init nas100d_init(void)
         nas100d_flash_resource.end =
                 IXP4XX_EXP_BUS_BASE(0) + ixp4xx_exp_bus_size - 1;
 
-        pm_power_off = nas100d_power_off;
+        i2c_register_board_info(0, nas100d_i2c_board_info,
+                                ARRAY_SIZE(nas100d_i2c_board_info));
 
         /*
          * This is only useful on a modified machine, but it is valuable
@@ -165,6 +255,48 @@ static void __init nas100d_init(void)
         (void)platform_device_register(&nas100d_uart);
 
         platform_add_devices(nas100d_devices, ARRAY_SIZE(nas100d_devices));
+
+        pm_power_off = nas100d_power_off;
+
+        if (request_irq(gpio_to_irq(NAS100D_RB_GPIO), &nas100d_reset_handler,
+                IRQF_DISABLED | IRQF_TRIGGER_LOW,
+                "NAS100D reset button", NULL) < 0) {
+
+                printk(KERN_DEBUG "Reset Button IRQ %d not available\n",
+                        gpio_to_irq(NAS100D_RB_GPIO));
+        }
+
+        /* The power button on the Iomega NAS100d is on GPIO 14, but
+         * it cannot handle interrupts on that GPIO line.  So we'll
+         * have to poll it with a kernel timer.
+         */
+
+        /* Make sure that the power button GPIO is set up as an input */
+        gpio_line_config(NAS100D_PB_GPIO, IXP4XX_GPIO_IN);
+
+        /* Set the initial value for the power button IRQ handler */
+        power_button_countdown = PBUTTON_HOLDDOWN_COUNT;
+
+        mod_timer(&nas100d_power_timer, jiffies + msecs_to_jiffies(500));
+
+        /*
+         * Map in a portion of the flash and read the MAC address.
+         * Since it is stored in BE in the flash itself, we need to
+         * byteswap it if we're in LE mode.
+         */
+        f = ioremap(IXP4XX_EXP_BUS_BASE(0), 0x1000000);
+        if (f) {
+                for (i = 0; i < 6; i++)
+#ifdef __ARMEB__
+                        nas100d_plat_eth[0].hwaddr[i] = readb(f + 0xFC0FD8 + i);
+#else
+                        nas100d_plat_eth[0].hwaddr[i] = readb(f + 0xFC0FD8 + (i^3));
+#endif
+                iounmap(f);
+        }
+        printk(KERN_INFO "NAS100D: Using MAC address %s for port 0\n",
+               print_mac(mac_buf, nas100d_plat_eth[0].hwaddr));
+
 }
 
 MACHINE_START(NAS100D, "Iomega NAS 100d")
diff --git a/arch/arm/mach-ixp4xx/nslu2-power.c b/arch/arm/mach-ixp4xx/nslu2-power.c
deleted file mode 100644
index 6f10dc208320..000000000000
--- a/arch/arm/mach-ixp4xx/nslu2-power.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * arch/arm/mach-ixp4xx/nslu2-power.c
- *
- * NSLU2 Power/Reset driver
- *
- * Copyright (C) 2005 Tower Technologies
- *
- * based on nslu2-io.c
- *  Copyright (C) 2004 Karen Spearel
- *
- * Author: Alessandro Zummo <a.zummo@towertech.it>
- * Maintainers: http://www.nslu2-linux.org/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/module.h>
-#include <linux/reboot.h>
-#include <linux/irq.h>
-#include <linux/interrupt.h>
-
-#include <asm/mach-types.h>
-
-static irqreturn_t nslu2_power_handler(int irq, void *dev_id)
-{
-        /* Signal init to do the ctrlaltdel action, this will bypass init if
-         * it hasn't started and do a kernel_restart.
-         */
-        ctrl_alt_del();
-
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t nslu2_reset_handler(int irq, void *dev_id)
-{
-        /* This is the paper-clip reset, it shuts the machine down directly.
-         */
-        machine_power_off();
-
-        return IRQ_HANDLED;
-}
-
-static int __init nslu2_power_init(void)
-{
-        if (!(machine_is_nslu2()))
-                return 0;
-
-        *IXP4XX_GPIO_GPISR = 0x20400000;        /* read the 2 irqs to clr */
-
-        set_irq_type(NSLU2_RB_IRQ, IRQT_LOW);
-        set_irq_type(NSLU2_PB_IRQ, IRQT_HIGH);
-
-        if (request_irq(NSLU2_RB_IRQ, &nslu2_reset_handler,
-                IRQF_DISABLED, "NSLU2 reset button", NULL) < 0) {
-
-                printk(KERN_DEBUG "Reset Button IRQ %d not available\n",
-                        NSLU2_RB_IRQ);
-
-                return -EIO;
-        }
-
-        if (request_irq(NSLU2_PB_IRQ, &nslu2_power_handler,
-                IRQF_DISABLED, "NSLU2 power button", NULL) < 0) {
-
-                printk(KERN_DEBUG "Power Button IRQ %d not available\n",
-                        NSLU2_PB_IRQ);
-
-                return -EIO;
-        }
-
-        return 0;
-}
-
-static void __exit nslu2_power_exit(void)
-{
-        if (!(machine_is_nslu2()))
-                return;
-
-        free_irq(NSLU2_RB_IRQ, NULL);
-        free_irq(NSLU2_PB_IRQ, NULL);
-}
-
-module_init(nslu2_power_init);
-module_exit(nslu2_power_exit);
-
-MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
-MODULE_DESCRIPTION("NSLU2 Power/Reset driver");
-MODULE_LICENSE("GPL");
diff --git a/arch/arm/mach-ixp4xx/nslu2-setup.c b/arch/arm/mach-ixp4xx/nslu2-setup.c
index 77277d27fcc5..acaebcbce53a 100644
--- a/arch/arm/mach-ixp4xx/nslu2-setup.c
+++ b/arch/arm/mach-ixp4xx/nslu2-setup.c
@@ -3,27 +3,35 @@
  *
  * NSLU2 board-setup
  *
- * based ixdp425-setup.c:
+ * Copyright (C) 2008 Rod Whitby <rod@whitby.id.au>
+ *
+ * based on ixdp425-setup.c:
  *      Copyright (C) 2003-2004 MontaVista Software, Inc.
+ * based on nslu2-power.c:
+ *      Copyright (C) 2005 Tower Technologies
  *
  * Author: Mark Rakes <mrakes at mac.com>
  * Author: Rod Whitby <rod@whitby.id.au>
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
  * Maintainers: http://www.nslu2-linux.org/
  *
- * Fixed missing init_time in MACHINE_START kas11 10/22/04
- * Changed to conform to new style __init ixdp425 kas11 10/22/04
  */
 
-#include <linux/kernel.h>
+#include <linux/if_ether.h>
+#include <linux/irq.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
 #include <linux/leds.h>
+#include <linux/reboot.h>
+#include <linux/i2c.h>
 #include <linux/i2c-gpio.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/flash.h>
 #include <asm/mach/time.h>
+#include <asm/io.h>
+#include <asm/gpio.h>
 
 static struct flash_platform_data nslu2_flash_data = {
         .map_name               = "cfi_probe",
@@ -47,41 +55,43 @@ static struct i2c_gpio_platform_data nslu2_i2c_gpio_data = {
         .scl_pin                = NSLU2_SCL_PIN,
 };
 
-#ifdef CONFIG_LEDS_IXP4XX
-static struct resource nslu2_led_resources[] = {
+static struct i2c_board_info __initdata nslu2_i2c_board_info [] = {
+        {
+                I2C_BOARD_INFO("rtc-x1205", 0x6f),
+        },
+};
+
+static struct gpio_led nslu2_led_pins[] = {
         {
                 .name           = "ready",  /* green led */
-                .start          = NSLU2_LED_GRN_GPIO,
-                .end            = NSLU2_LED_GRN_GPIO,
-                .flags          = IXP4XX_GPIO_HIGH,
+                .gpio           = NSLU2_LED_GRN_GPIO,
         },
         {
                 .name           = "status", /* red led */
-                .start          = NSLU2_LED_RED_GPIO,
-                .end            = NSLU2_LED_RED_GPIO,
-                .flags          = IXP4XX_GPIO_HIGH,
+                .gpio           = NSLU2_LED_RED_GPIO,
         },
         {
                 .name           = "disk-1",
-                .start          = NSLU2_LED_DISK1_GPIO,
-                .end            = NSLU2_LED_DISK1_GPIO,
-                .flags          = IXP4XX_GPIO_LOW,
+                .gpio           = NSLU2_LED_DISK1_GPIO,
+                .active_low     = true,
         },
         {
                 .name           = "disk-2",
-                .start          = NSLU2_LED_DISK2_GPIO,
-                .end            = NSLU2_LED_DISK2_GPIO,
-                .flags          = IXP4XX_GPIO_LOW,
+                .gpio           = NSLU2_LED_DISK2_GPIO,
+                .active_low     = true,
         },
 };
 
+static struct gpio_led_platform_data nslu2_led_data = {
+        .num_leds               = ARRAY_SIZE(nslu2_led_pins),
+        .leds                   = nslu2_led_pins,
+};
+
 static struct platform_device nslu2_leds = {
-        .name                   = "IXP4XX-GPIO-LED",
+        .name                   = "leds-gpio",
         .id                     = -1,
-        .num_resources          = ARRAY_SIZE(nslu2_led_resources),
-        .resource               = nslu2_led_resources,
+        .dev.platform_data      = &nslu2_led_data,
 };
-#endif
 
 static struct platform_device nslu2_i2c_gpio = {
         .name                   = "i2c-gpio",
@@ -140,13 +150,29 @@ static struct platform_device nslu2_uart = {
         .resource               = nslu2_uart_resources,
 };
 
+/* Built-in 10/100 Ethernet MAC interfaces */
+static struct eth_plat_info nslu2_plat_eth[] = {
+        {
+                .phy            = 1,
+                .rxq            = 3,
+                .txreadyq       = 20,
+        }
+};
+
+static struct platform_device nslu2_eth[] = {
+        {
+                .name                   = "ixp4xx_eth",
+                .id                     = IXP4XX_ETH_NPEB,
+                .dev.platform_data      = nslu2_plat_eth,
+        }
+};
+
 static struct platform_device *nslu2_devices[] __initdata = {
         &nslu2_i2c_gpio,
         &nslu2_flash,
         &nslu2_beeper,
-#ifdef CONFIG_LEDS_IXP4XX
         &nslu2_leds,
-#endif
+        &nslu2_eth[0],
 };
 
 static void nslu2_power_off(void)
@@ -160,6 +186,25 @@ static void nslu2_power_off(void)
         gpio_line_set(NSLU2_PO_GPIO, IXP4XX_GPIO_HIGH);
 }
 
+static irqreturn_t nslu2_power_handler(int irq, void *dev_id)
+{
+        /* Signal init to do the ctrlaltdel action, this will bypass init if
+         * it hasn't started and do a kernel_restart.
+         */
+        ctrl_alt_del();
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t nslu2_reset_handler(int irq, void *dev_id)
+{
+        /* This is the paper-clip reset, it shuts the machine down directly.
+         */
+        machine_power_off();
+
+        return IRQ_HANDLED;
+}
+
 static void __init nslu2_timer_init(void)
 {
     /* The xtal on this machine is non-standard. */
@@ -175,13 +220,18 @@ static struct sys_timer nslu2_timer = {
 
 static void __init nslu2_init(void)
 {
+        DECLARE_MAC_BUF(mac_buf);
+        uint8_t __iomem *f;
+        int i;
+
         ixp4xx_sys_init();
 
         nslu2_flash_resource.start = IXP4XX_EXP_BUS_BASE(0);
         nslu2_flash_resource.end =
                 IXP4XX_EXP_BUS_BASE(0) + ixp4xx_exp_bus_size - 1;
 
-        pm_power_off = nslu2_power_off;
+        i2c_register_board_info(0, nslu2_i2c_board_info,
+                                ARRAY_SIZE(nslu2_i2c_board_info));
 
         /*
          * This is only useful on a modified machine, but it is valuable
@@ -191,6 +241,43 @@ static void __init nslu2_init(void)
         (void)platform_device_register(&nslu2_uart);
 
         platform_add_devices(nslu2_devices, ARRAY_SIZE(nslu2_devices));
+
+        pm_power_off = nslu2_power_off;
+
+        if (request_irq(gpio_to_irq(NSLU2_RB_GPIO), &nslu2_reset_handler,
+                IRQF_DISABLED | IRQF_TRIGGER_LOW,
+                "NSLU2 reset button", NULL) < 0) {
+
+                printk(KERN_DEBUG "Reset Button IRQ %d not available\n",
+                        gpio_to_irq(NSLU2_RB_GPIO));
+        }
+
+        if (request_irq(gpio_to_irq(NSLU2_PB_GPIO), &nslu2_power_handler,
+                IRQF_DISABLED | IRQF_TRIGGER_HIGH,
+                "NSLU2 power button", NULL) < 0) {
+
+                printk(KERN_DEBUG "Power Button IRQ %d not available\n",
+                        gpio_to_irq(NSLU2_PB_GPIO));
+        }
+
+        /*
+         * Map in a portion of the flash and read the MAC address.
+         * Since it is stored in BE in the flash itself, we need to
+         * byteswap it if we're in LE mode.
+         */
+        f = ioremap(IXP4XX_EXP_BUS_BASE(0), 0x40000);
+        if (f) {
+                for (i = 0; i < 6; i++)
+#ifdef __ARMEB__
+                        nslu2_plat_eth[0].hwaddr[i] = readb(f + 0x3FFB0 + i);
+#else
+                        nslu2_plat_eth[0].hwaddr[i] = readb(f + 0x3FFB0 + (i^3));
+#endif
+                iounmap(f);
+        }
+        printk(KERN_INFO "NSLU2: Using MAC address %s for port 0\n",
+               print_mac(mac_buf, nslu2_plat_eth[0].hwaddr));
+
 }
 
 MACHINE_START(NSLU2, "Linksys NSLU2")
diff --git a/arch/arm/mach-pxa/Makefile b/arch/arm/mach-pxa/Makefile
index b5c916c0747d..6e0c4f5b5ae6 100644
--- a/arch/arm/mach-pxa/Makefile
+++ b/arch/arm/mach-pxa/Makefile
@@ -3,10 +3,11 @@
 #
 
 # Common support (must be linked before board specific support)
-obj-y                           += clock.o devices.o generic.o irq.o dma.o time.o
+obj-y                           += clock.o devices.o generic.o irq.o dma.o \
+                                   time.o gpio.o
 obj-$(CONFIG_PXA25x)            += pxa25x.o
 obj-$(CONFIG_PXA27x)            += pxa27x.o
-obj-$(CONFIG_PXA3xx)            += pxa3xx.o mfp.o
+obj-$(CONFIG_PXA3xx)            += pxa3xx.o mfp.o smemc.o
 obj-$(CONFIG_CPU_PXA300)        += pxa300.o
 obj-$(CONFIG_CPU_PXA320)        += pxa320.o
 
diff --git a/arch/arm/mach-pxa/cm-x270.c b/arch/arm/mach-pxa/cm-x270.c
index 28cfd71c032d..6012177a29a3 100644
--- a/arch/arm/mach-pxa/cm-x270.c
+++ b/arch/arm/mach-pxa/cm-x270.c
@@ -29,6 +29,7 @@
 #include <asm/mach/map.h>
 
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-regs.h>
 #include <asm/arch/pxafb.h>
 #include <asm/arch/ohci.h>
 #include <asm/arch/mmc.h>
diff --git a/arch/arm/mach-pxa/corgi_ssp.c b/arch/arm/mach-pxa/corgi_ssp.c
index efba65edcd51..31706224a04c 100644
--- a/arch/arm/mach-pxa/corgi_ssp.c
+++ b/arch/arm/mach-pxa/corgi_ssp.c
@@ -32,7 +32,7 @@ static struct corgissp_machinfo *ssp_machinfo;
 /*
  * There are three devices connected to the SSP interface:
  *   1. A touchscreen controller (TI ADS7846 compatible)
- *   2. An LCD contoller (with some Backlight functionality)
+ *   2. An LCD controller (with some Backlight functionality)
  *   3. A battery monitoring IC (Maxim MAX1111)
  *
  * Each device uses a different speed/mode of communication.
diff --git a/arch/arm/mach-pxa/devices.c b/arch/arm/mach-pxa/devices.c
index 50ff453ad370..bfccb80ac8ef 100644
--- a/arch/arm/mach-pxa/devices.c
+++ b/arch/arm/mach-pxa/devices.c
@@ -10,6 +10,7 @@
 #include <asm/arch/mmc.h>
 #include <asm/arch/irda.h>
 #include <asm/arch/i2c.h>
+#include <asm/arch/ohci.h>
 
 #include "devices.h"
 
diff --git a/arch/arm/mach-pxa/generic.c b/arch/arm/mach-pxa/generic.c
index 698aeec52961..80721c610d41 100644
--- a/arch/arm/mach-pxa/generic.c
+++ b/arch/arm/mach-pxa/generic.c
@@ -23,6 +23,7 @@
 #include <linux/ioport.h>
 #include <linux/pm.h>
 #include <linux/string.h>
+#include <linux/sysdev.h>
 
 #include <asm/hardware.h>
 #include <asm/irq.h>
@@ -31,7 +32,6 @@
 #include <asm/mach/map.h>
 
 #include <asm/arch/pxa-regs.h>
-#include <asm/arch/gpio.h>
 
 #include "generic.h"
 
@@ -66,97 +66,6 @@ unsigned int get_memclk_frequency_10khz(void)
 EXPORT_SYMBOL(get_memclk_frequency_10khz);
 
 /*
- * Handy function to set GPIO alternate functions
- */
-int pxa_last_gpio;
-
-int pxa_gpio_mode(int gpio_mode)
-{
-        unsigned long flags;
-        int gpio = gpio_mode & GPIO_MD_MASK_NR;
-        int fn = (gpio_mode & GPIO_MD_MASK_FN) >> 8;
-        int gafr;
-
-        if (gpio > pxa_last_gpio)
-                return -EINVAL;
-
-        local_irq_save(flags);
-        if (gpio_mode & GPIO_DFLT_LOW)
-                GPCR(gpio) = GPIO_bit(gpio);
-        else if (gpio_mode & GPIO_DFLT_HIGH)
-                GPSR(gpio) = GPIO_bit(gpio);
-        if (gpio_mode & GPIO_MD_MASK_DIR)
-                GPDR(gpio) |= GPIO_bit(gpio);
-        else
-                GPDR(gpio) &= ~GPIO_bit(gpio);
-        gafr = GAFR(gpio) & ~(0x3 << (((gpio) & 0xf)*2));
-        GAFR(gpio) = gafr |  (fn  << (((gpio) & 0xf)*2));
-        local_irq_restore(flags);
-
-        return 0;
-}
-
-EXPORT_SYMBOL(pxa_gpio_mode);
-
-int gpio_direction_input(unsigned gpio)
-{
-        unsigned long flags;
-        u32 mask;
-
-        if (gpio > pxa_last_gpio)
-                return -EINVAL;
-
-        mask = GPIO_bit(gpio);
-        local_irq_save(flags);
-        GPDR(gpio) &= ~mask;
-        local_irq_restore(flags);
-
-        return 0;
-}
-EXPORT_SYMBOL(gpio_direction_input);
-
-int gpio_direction_output(unsigned gpio, int value)
-{
-        unsigned long flags;
-        u32 mask;
-
-        if (gpio > pxa_last_gpio)
-                return -EINVAL;
-
-        mask = GPIO_bit(gpio);
-        local_irq_save(flags);
-        if (value)
-                GPSR(gpio) = mask;
-        else
-                GPCR(gpio) = mask;
-        GPDR(gpio) |= mask;
-        local_irq_restore(flags);
-
-        return 0;
-}
-EXPORT_SYMBOL(gpio_direction_output);
-
-/*
- * Return GPIO level
- */
-int pxa_gpio_get_value(unsigned gpio)
-{
-        return __gpio_get_value(gpio);
-}
-
-EXPORT_SYMBOL(pxa_gpio_get_value);
-
-/*
- * Set output GPIO level
- */
-void pxa_gpio_set_value(unsigned gpio, int value)
-{
-        __gpio_set_value(gpio, value);
-}
-
-EXPORT_SYMBOL(pxa_gpio_set_value);
-
-/*
  * Routine to safely enable or disable a clock in the CKEN
  */
 void __pxa_set_cken(int clock, int enable)
@@ -171,7 +80,6 @@ void __pxa_set_cken(int clock, int enable)
 
         local_irq_restore(flags);
 }
-
 EXPORT_SYMBOL(__pxa_set_cken);
 
 /*
@@ -226,3 +134,59 @@ void __init pxa_map_io(void)
         iotable_init(standard_io_desc, ARRAY_SIZE(standard_io_desc));
         get_clk_frequency_khz(1);
 }
+
+#ifdef CONFIG_PM
+
+static unsigned long saved_gplr[4];
+static unsigned long saved_gpdr[4];
+static unsigned long saved_grer[4];
+static unsigned long saved_gfer[4];
+
+static int pxa_gpio_suspend(struct sys_device *dev, pm_message_t state)
+{
+        int i, gpio;
+
+        for (gpio = 0, i = 0; gpio < pxa_last_gpio; gpio += 32, i++) {
+                saved_gplr[i] = GPLR(gpio);
+                saved_gpdr[i] = GPDR(gpio);
+                saved_grer[i] = GRER(gpio);
+                saved_gfer[i] = GFER(gpio);
+
+                /* Clear GPIO transition detect bits */
+                GEDR(gpio) = GEDR(gpio);
+        }
+        return 0;
+}
+
+static int pxa_gpio_resume(struct sys_device *dev)
+{
+        int i, gpio;
+
+        for (gpio = 0, i = 0; gpio < pxa_last_gpio; gpio += 32, i++) {
+                /* restore level with set/clear */
+                GPSR(gpio) = saved_gplr[i];
+                GPCR(gpio) = ~saved_gplr[i];
+
+                GRER(gpio) = saved_grer[i];
+                GFER(gpio) = saved_gfer[i];
+                GPDR(gpio) = saved_gpdr[i];
+        }
+        return 0;
+}
+#else
+#define pxa_gpio_suspend        NULL
+#define pxa_gpio_resume         NULL
+#endif
+
+struct sysdev_class pxa_gpio_sysclass = {
+        .name           = "gpio",
+        .suspend        = pxa_gpio_suspend,
+        .resume         = pxa_gpio_resume,
+};
+
+static int __init pxa_gpio_init(void)
+{
+        return sysdev_class_register(&pxa_gpio_sysclass);
+}
+
+core_initcall(pxa_gpio_init);
diff --git a/arch/arm/mach-pxa/generic.h b/arch/arm/mach-pxa/generic.h
index b30f240a16c7..b3d10b0e52a0 100644
--- a/arch/arm/mach-pxa/generic.h
+++ b/arch/arm/mach-pxa/generic.h
@@ -16,6 +16,7 @@ extern void __init pxa_init_irq_low(void);
 extern void __init pxa_init_irq_high(void);
 extern void __init pxa_init_irq_gpio(int gpio_nr);
 extern void __init pxa_init_irq_set_wake(int (*set_wake)(unsigned int, unsigned int));
+extern void __init pxa_init_gpio(int gpio_nr);
 extern void __init pxa25x_init_irq(void);
 extern void __init pxa27x_init_irq(void);
 extern void __init pxa3xx_init_irq(void);
@@ -52,3 +53,6 @@ extern unsigned pxa3xx_get_memclk_frequency_10khz(void);
 #define pxa3xx_get_clk_frequency_khz(x)         (0)
 #define pxa3xx_get_memclk_frequency_10khz()     (0)
 #endif
+
+extern struct sysdev_class pxa_irq_sysclass;
+extern struct sysdev_class pxa_gpio_sysclass;
diff --git a/arch/arm/mach-pxa/gpio.c b/arch/arm/mach-pxa/gpio.c
new file mode 100644
index 000000000000..8638dd7dd076
--- /dev/null
+++ b/arch/arm/mach-pxa/gpio.c
@@ -0,0 +1,197 @@
+/*
+ *  linux/arch/arm/mach-pxa/gpio.c
+ *
+ *  Generic PXA GPIO handling
+ *
+ *  Author:     Nicolas Pitre
+ *  Created:    Jun 15, 2001
+ *  Copyright:  MontaVista Software Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+
+#include <asm/gpio.h>
+#include <asm/hardware.h>
+#include <asm/io.h>
+#include <asm/arch/pxa-regs.h>
+
+#include "generic.h"
+
+
+struct pxa_gpio_chip {
+        struct gpio_chip chip;
+        void __iomem     *regbase;
+};
+
+int pxa_last_gpio;
+
+/*
+ * Configure pins for GPIO or other functions
+ */
+int pxa_gpio_mode(int gpio_mode)
+{
+        unsigned long flags;
+        int gpio = gpio_mode & GPIO_MD_MASK_NR;
+        int fn = (gpio_mode & GPIO_MD_MASK_FN) >> 8;
+        int gafr;
+
+        if (gpio > pxa_last_gpio)
+                return -EINVAL;
+
+        local_irq_save(flags);
+        if (gpio_mode & GPIO_DFLT_LOW)
+                GPCR(gpio) = GPIO_bit(gpio);
+        else if (gpio_mode & GPIO_DFLT_HIGH)
+                GPSR(gpio) = GPIO_bit(gpio);
+        if (gpio_mode & GPIO_MD_MASK_DIR)
+                GPDR(gpio) |= GPIO_bit(gpio);
+        else
+                GPDR(gpio) &= ~GPIO_bit(gpio);
+        gafr = GAFR(gpio) & ~(0x3 << (((gpio) & 0xf)*2));
+        GAFR(gpio) = gafr |  (fn  << (((gpio) & 0xf)*2));
+        local_irq_restore(flags);
+
+        return 0;
+}
+EXPORT_SYMBOL(pxa_gpio_mode);
+
+static int pxa_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        unsigned long        flags;
+        u32                  mask = 1 << offset;
+        u32                  value;
+        struct pxa_gpio_chip *pxa;
+        void __iomem         *gpdr;
+
+        pxa = container_of(chip, struct pxa_gpio_chip, chip);
+        gpdr = pxa->regbase + GPDR_OFFSET;
+        local_irq_save(flags);
+        value = __raw_readl(gpdr);
+        value &= ~mask;
+        __raw_writel(value, gpdr);
+        local_irq_restore(flags);
+
+        return 0;
+}
+
+static int pxa_gpio_direction_output(struct gpio_chip *chip,
+                                        unsigned offset, int value)
+{
+        unsigned long        flags;
+        u32                  mask = 1 << offset;
+        u32                  tmp;
+        struct pxa_gpio_chip *pxa;
+        void __iomem         *gpdr;
+
+        pxa = container_of(chip, struct pxa_gpio_chip, chip);
+        __raw_writel(mask,
+                        pxa->regbase + (value ? GPSR_OFFSET : GPCR_OFFSET));
+        gpdr = pxa->regbase + GPDR_OFFSET;
+        local_irq_save(flags);
+        tmp = __raw_readl(gpdr);
+        tmp |= mask;
+        __raw_writel(tmp, gpdr);
+        local_irq_restore(flags);
+
+        return 0;
+}
+
+/*
+ * Return GPIO level
+ */
+static int pxa_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        u32                  mask = 1 << offset;
+        struct pxa_gpio_chip *pxa;
+
+        pxa = container_of(chip, struct pxa_gpio_chip, chip);
+        return __raw_readl(pxa->regbase + GPLR_OFFSET) & mask;
+}
+
+/*
+ * Set output GPIO level
+ */
+static void pxa_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        u32                  mask = 1 << offset;
+        struct pxa_gpio_chip *pxa;
+
+        pxa = container_of(chip, struct pxa_gpio_chip, chip);
+
+        if (value)
+                __raw_writel(mask, pxa->regbase + GPSR_OFFSET);
+        else
+                __raw_writel(mask, pxa->regbase + GPCR_OFFSET);
+}
+
+static struct pxa_gpio_chip pxa_gpio_chip[] = {
+        [0] = {
+                .regbase = GPIO0_BASE,
+                .chip = {
+                        .label            = "gpio-0",
+                        .direction_input  = pxa_gpio_direction_input,
+                        .direction_output = pxa_gpio_direction_output,
+                        .get              = pxa_gpio_get,
+                        .set              = pxa_gpio_set,
+                        .base             = 0,
+                        .ngpio            = 32,
+                },
+        },
+        [1] = {
+                .regbase = GPIO1_BASE,
+                .chip = {
+                        .label            = "gpio-1",
+                        .direction_input  = pxa_gpio_direction_input,
+                        .direction_output = pxa_gpio_direction_output,
+                        .get              = pxa_gpio_get,
+                        .set              = pxa_gpio_set,
+                        .base             = 32,
+                        .ngpio            = 32,
+                },
+        },
+        [2] = {
+                .regbase = GPIO2_BASE,
+                .chip = {
+                        .label            = "gpio-2",
+                        .direction_input  = pxa_gpio_direction_input,
+                        .direction_output = pxa_gpio_direction_output,
+                        .get              = pxa_gpio_get,
+                        .set              = pxa_gpio_set,
+                        .base             = 64,
+                        .ngpio            = 32, /* 21 for PXA25x */
+                },
+        },
+#if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
+        [3] = {
+                .regbase = GPIO3_BASE,
+                .chip = {
+                        .label            = "gpio-3",
+                        .direction_input  = pxa_gpio_direction_input,
+                        .direction_output = pxa_gpio_direction_output,
+                        .get              = pxa_gpio_get,
+                        .set              = pxa_gpio_set,
+                        .base             = 96,
+                        .ngpio            = 32,
+                },
+        },
+#endif
+};
+
+void __init pxa_init_gpio(int gpio_nr)
+{
+        int i;
+
+        /* add a GPIO chip for each register bank.
+         * the last PXA25x register only contains 21 GPIOs
+         */
+        for (i = 0; i < gpio_nr; i += 32) {
+                if (i+32 > gpio_nr)
+                        pxa_gpio_chip[i/32].chip.ngpio = gpio_nr - i;
+                gpiochip_add(&pxa_gpio_chip[i/32].chip);
+        }
+}
diff --git a/arch/arm/mach-pxa/irq.c b/arch/arm/mach-pxa/irq.c
index 07acb45b16ea..36c6a68beca2 100644
--- a/arch/arm/mach-pxa/irq.c
+++ b/arch/arm/mach-pxa/irq.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/interrupt.h>
+#include <linux/sysdev.h>
 
 #include <asm/hardware.h>
 #include <asm/irq.h>
@@ -310,6 +311,8 @@ void __init pxa_init_irq_gpio(int gpio_nr)
         /* Install handler for GPIO>=2 edge detect interrupts */
         set_irq_chip(IRQ_GPIO_2_x, &pxa_internal_chip_low);
         set_irq_chained_handler(IRQ_GPIO_2_x, pxa_gpio_demux_handler);
+
+        pxa_init_gpio(gpio_nr);
 }
 
 void __init pxa_init_irq_set_wake(int (*set_wake)(unsigned int, unsigned int))
@@ -321,3 +324,64 @@ void __init pxa_init_irq_set_wake(int (*set_wake)(unsigned int, unsigned int))
         pxa_low_gpio_chip.set_wake = set_wake;
         pxa_muxed_gpio_chip.set_wake = set_wake;
 }
+
+#ifdef CONFIG_PM
+static unsigned long saved_icmr[2];
+
+static int pxa_irq_suspend(struct sys_device *dev, pm_message_t state)
+{
+        switch (dev->id) {
+        case 0:
+                saved_icmr[0] = ICMR;
+                ICMR = 0;
+                break;
+#if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
+        case 1:
+                saved_icmr[1] = ICMR2;
+                ICMR2 = 0;
+                break;
+#endif
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int pxa_irq_resume(struct sys_device *dev)
+{
+        switch (dev->id) {
+        case 0:
+                ICMR = saved_icmr[0];
+                ICLR = 0;
+                ICCR = 1;
+                break;
+#if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
+        case 1:
+                ICMR2 = saved_icmr[1];
+                ICLR2 = 0;
+                break;
+#endif
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+#else
+#define pxa_irq_suspend         NULL
+#define pxa_irq_resume          NULL
+#endif
+
+struct sysdev_class pxa_irq_sysclass = {
+        .name           = "irq",
+        .suspend        = pxa_irq_suspend,
+        .resume         = pxa_irq_resume,
+};
+
+static int __init pxa_irq_init(void)
+{
+        return sysdev_class_register(&pxa_irq_sysclass);
+}
+
+core_initcall(pxa_irq_init);
diff --git a/arch/arm/mach-pxa/mfp.c b/arch/arm/mach-pxa/mfp.c
index ec1b2d8f61c4..f5809adce298 100644
--- a/arch/arm/mach-pxa/mfp.c
+++ b/arch/arm/mach-pxa/mfp.c
@@ -22,6 +22,7 @@
 #include <asm/hardware.h>
 #include <asm/arch/mfp.h>
 #include <asm/arch/mfp-pxa3xx.h>
+#include <asm/arch/pxa3xx-regs.h>
 
 /* mfp_spin_lock is used to ensure that MFP register configuration
  * (most likely a read-modify-write operation) is atomic, and that
@@ -223,11 +224,19 @@ static int pxa3xx_mfp_resume(struct sys_device *d)
                 struct pxa3xx_mfp_pin *p = &mfp_table[pin];
                 __mfp_config_run(p);
         }
+
+        /* clear RDH bit when MFP settings are restored
+         *
+         * NOTE: the last 3 bits DxS are write-1-to-clear so carefully
+         * preserve them here in case they will be referenced later
+         */
+        ASCR &= ~(ASCR_RDH | ASCR_D1S | ASCR_D2S | ASCR_D3S);
+
         return 0;
 }
 
 static struct sysdev_class mfp_sysclass = {
-        set_kset_name("mfp"),
+        .name           = "mfp",
         .suspend        = pxa3xx_mfp_suspend,
         .resume         = pxa3xx_mfp_resume,
 };
diff --git a/arch/arm/mach-pxa/pcm027.c b/arch/arm/mach-pxa/pcm027.c
index 540c3bba5f9a..c14696b9979d 100644
--- a/arch/arm/mach-pxa/pcm027.c
+++ b/arch/arm/mach-pxa/pcm027.c
@@ -29,6 +29,7 @@
 #include <asm/mach/arch.h>
 #include <asm/arch/hardware.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-regs.h>
 #include <asm/arch/pxa2xx_spi.h>
 #include <asm/arch/pcm027.h>
 #include "generic.h"
diff --git a/arch/arm/mach-pxa/poodle.c b/arch/arm/mach-pxa/poodle.c
index dd54496083cb..209eabf0ed3e 100644
--- a/arch/arm/mach-pxa/poodle.c
+++ b/arch/arm/mach-pxa/poodle.c
@@ -164,7 +164,7 @@ static struct resource poodlets_resources[] = {
         },
 };
 
-static unsigned long poodle_get_hsync_len(void)
+static unsigned long poodle_get_hsync_invperiod(void)
 {
         return 0;
 }
@@ -174,9 +174,9 @@ static void poodle_null_hsync(void)
 }
 
 static struct corgits_machinfo  poodle_ts_machinfo = {
-        .get_hsync_len   = poodle_get_hsync_len,
-        .put_hsync       = poodle_null_hsync,
-        .wait_hsync      = poodle_null_hsync,
+        .get_hsync_invperiod    = poodle_get_hsync_invperiod,
+        .put_hsync              = poodle_null_hsync,
+        .wait_hsync             = poodle_null_hsync,
 };
 
 static struct platform_device poodle_ts_device = {
diff --git a/arch/arm/mach-pxa/pxa25x.c b/arch/arm/mach-pxa/pxa25x.c
index ddd05bf78e02..599e53fcc2c5 100644
--- a/arch/arm/mach-pxa/pxa25x.c
+++ b/arch/arm/mach-pxa/pxa25x.c
@@ -21,6 +21,7 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/suspend.h>
+#include <linux/sysdev.h>
 
 #include <asm/hardware.h>
 #include <asm/arch/irqs.h>
@@ -141,11 +142,6 @@ static struct clk pxa25x_clks[] = {
 #define SAVE(x)         sleep_save[SLEEP_SAVE_##x] = x
 #define RESTORE(x)      x = sleep_save[SLEEP_SAVE_##x]
 
-#define RESTORE_GPLEVEL(n) do { \
-        GPSR##n = sleep_save[SLEEP_SAVE_GPLR##n]; \
-        GPCR##n = ~sleep_save[SLEEP_SAVE_GPLR##n]; \
-} while (0)
-
 /*
  * List of global PXA peripheral registers to preserve.
  * More ones like CP and general purpose register values are preserved
@@ -153,10 +149,6 @@ static struct clk pxa25x_clks[] = {
  */
 enum {  SLEEP_SAVE_START = 0,
 
-        SLEEP_SAVE_GPLR0, SLEEP_SAVE_GPLR1, SLEEP_SAVE_GPLR2,
-        SLEEP_SAVE_GPDR0, SLEEP_SAVE_GPDR1, SLEEP_SAVE_GPDR2,
-        SLEEP_SAVE_GRER0, SLEEP_SAVE_GRER1, SLEEP_SAVE_GRER2,
-        SLEEP_SAVE_GFER0, SLEEP_SAVE_GFER1, SLEEP_SAVE_GFER2,
         SLEEP_SAVE_PGSR0, SLEEP_SAVE_PGSR1, SLEEP_SAVE_PGSR2,
 
         SLEEP_SAVE_GAFR0_L, SLEEP_SAVE_GAFR0_U,
@@ -165,7 +157,6 @@ enum {	SLEEP_SAVE_START = 0,
 
         SLEEP_SAVE_PSTR,
 
-        SLEEP_SAVE_ICMR,
         SLEEP_SAVE_CKEN,
 
         SLEEP_SAVE_SIZE
@@ -174,17 +165,12 @@ enum {	SLEEP_SAVE_START = 0,
 
 static void pxa25x_cpu_pm_save(unsigned long *sleep_save)
 {
-        SAVE(GPLR0); SAVE(GPLR1); SAVE(GPLR2);
-        SAVE(GPDR0); SAVE(GPDR1); SAVE(GPDR2);
-        SAVE(GRER0); SAVE(GRER1); SAVE(GRER2);
-        SAVE(GFER0); SAVE(GFER1); SAVE(GFER2);
         SAVE(PGSR0); SAVE(PGSR1); SAVE(PGSR2);
 
         SAVE(GAFR0_L); SAVE(GAFR0_U);
         SAVE(GAFR1_L); SAVE(GAFR1_U);
         SAVE(GAFR2_L); SAVE(GAFR2_U);
 
-        SAVE(ICMR); ICMR = 0;
         SAVE(CKEN);
         SAVE(PSTR);
 
@@ -198,22 +184,14 @@ static void pxa25x_cpu_pm_restore(unsigned long *sleep_save)
         PSPR = 0;
 
         /* restore registers */
-        RESTORE_GPLEVEL(0); RESTORE_GPLEVEL(1); RESTORE_GPLEVEL(2);
-        RESTORE(GPDR0); RESTORE(GPDR1); RESTORE(GPDR2);
         RESTORE(GAFR0_L); RESTORE(GAFR0_U);
         RESTORE(GAFR1_L); RESTORE(GAFR1_U);
         RESTORE(GAFR2_L); RESTORE(GAFR2_U);
-        RESTORE(GRER0); RESTORE(GRER1); RESTORE(GRER2);
-        RESTORE(GFER0); RESTORE(GFER1); RESTORE(GFER2);
         RESTORE(PGSR0); RESTORE(PGSR1); RESTORE(PGSR2);
 
         PSSR = PSSR_RDH | PSSR_PH;
 
         RESTORE(CKEN);
-
-        ICLR = 0;
-        ICCR = 1;
-        RESTORE(ICMR);
         RESTORE(PSTR);
 }
 
@@ -304,9 +282,17 @@ static struct platform_device *pxa25x_devices[] __initdata = {
         &pxa25x_device_assp,
 };
 
+static struct sys_device pxa25x_sysdev[] = {
+        {
+                .cls    = &pxa_irq_sysclass,
+        }, {
+                .cls    = &pxa_gpio_sysclass,
+        },
+};
+
 static int __init pxa25x_init(void)
 {
-        int ret = 0;
+        int i, ret = 0;
 
         /* Only add HWUART for PXA255/26x; PXA210/250/27x do not have it. */
         if (cpu_is_pxa25x())
@@ -320,9 +306,18 @@ static int __init pxa25x_init(void)
 
                 pxa25x_init_pm();
 
+                for (i = 0; i < ARRAY_SIZE(pxa25x_sysdev); i++) {
+                        ret = sysdev_register(&pxa25x_sysdev[i]);
+                        if (ret)
+                                pr_err("failed to register sysdev[%d]\n", i);
+                }
+
                 ret = platform_add_devices(pxa25x_devices,
                                            ARRAY_SIZE(pxa25x_devices));
+                if (ret)
+                        return ret;
         }
+
         /* Only add HWUART for PXA255/26x; PXA210/250/27x do not have it. */
         if (cpu_is_pxa25x())
                 ret = platform_device_register(&pxa_device_hwuart);
diff --git a/arch/arm/mach-pxa/pxa27x.c b/arch/arm/mach-pxa/pxa27x.c
index 96cf274ec7cb..46a951c3e5a0 100644
--- a/arch/arm/mach-pxa/pxa27x.c
+++ b/arch/arm/mach-pxa/pxa27x.c
@@ -16,6 +16,7 @@
 #include <linux/init.h>
 #include <linux/suspend.h>
 #include <linux/platform_device.h>
+#include <linux/sysdev.h>
 
 #include <asm/hardware.h>
 #include <asm/irq.h>
@@ -171,11 +172,6 @@ static struct clk pxa27x_clks[] = {
 #define SAVE(x)         sleep_save[SLEEP_SAVE_##x] = x
 #define RESTORE(x)      x = sleep_save[SLEEP_SAVE_##x]
 
-#define RESTORE_GPLEVEL(n) do { \
-        GPSR##n = sleep_save[SLEEP_SAVE_GPLR##n]; \
-        GPCR##n = ~sleep_save[SLEEP_SAVE_GPLR##n]; \
-} while (0)
-
 /*
  * List of global PXA peripheral registers to preserve.
  * More ones like CP and general purpose register values are preserved
@@ -183,10 +179,6 @@ static struct clk pxa27x_clks[] = {
  */
 enum {  SLEEP_SAVE_START = 0,
 
-        SLEEP_SAVE_GPLR0, SLEEP_SAVE_GPLR1, SLEEP_SAVE_GPLR2, SLEEP_SAVE_GPLR3,
-        SLEEP_SAVE_GPDR0, SLEEP_SAVE_GPDR1, SLEEP_SAVE_GPDR2, SLEEP_SAVE_GPDR3,
-        SLEEP_SAVE_GRER0, SLEEP_SAVE_GRER1, SLEEP_SAVE_GRER2, SLEEP_SAVE_GRER3,
-        SLEEP_SAVE_GFER0, SLEEP_SAVE_GFER1, SLEEP_SAVE_GFER2, SLEEP_SAVE_GFER3,
         SLEEP_SAVE_PGSR0, SLEEP_SAVE_PGSR1, SLEEP_SAVE_PGSR2, SLEEP_SAVE_PGSR3,
 
         SLEEP_SAVE_GAFR0_L, SLEEP_SAVE_GAFR0_U,
@@ -196,7 +188,6 @@ enum {	SLEEP_SAVE_START = 0,
 
         SLEEP_SAVE_PSTR,
 
-        SLEEP_SAVE_ICMR,
         SLEEP_SAVE_CKEN,
 
         SLEEP_SAVE_MDREFR,
@@ -208,10 +199,6 @@ enum {	SLEEP_SAVE_START = 0,
 
 void pxa27x_cpu_pm_save(unsigned long *sleep_save)
 {
-        SAVE(GPLR0); SAVE(GPLR1); SAVE(GPLR2); SAVE(GPLR3);
-        SAVE(GPDR0); SAVE(GPDR1); SAVE(GPDR2); SAVE(GPDR3);
-        SAVE(GRER0); SAVE(GRER1); SAVE(GRER2); SAVE(GRER3);
-        SAVE(GFER0); SAVE(GFER1); SAVE(GFER2); SAVE(GFER3);
         SAVE(PGSR0); SAVE(PGSR1); SAVE(PGSR2); SAVE(PGSR3);
 
         SAVE(GAFR0_L); SAVE(GAFR0_U);
@@ -223,12 +210,8 @@ void pxa27x_cpu_pm_save(unsigned long *sleep_save)
         SAVE(PWER); SAVE(PCFR); SAVE(PRER);
         SAVE(PFER); SAVE(PKWR);
 
-        SAVE(ICMR); ICMR = 0;
         SAVE(CKEN);
         SAVE(PSTR);
-
-        /* Clear GPIO transition detect bits */
-        GEDR0 = GEDR0; GEDR1 = GEDR1; GEDR2 = GEDR2; GEDR3 = GEDR3;
 }
 
 void pxa27x_cpu_pm_restore(unsigned long *sleep_save)
@@ -237,15 +220,10 @@ void pxa27x_cpu_pm_restore(unsigned long *sleep_save)
         PSPR = 0;
 
         /* restore registers */
-        RESTORE_GPLEVEL(0); RESTORE_GPLEVEL(1);
-        RESTORE_GPLEVEL(2); RESTORE_GPLEVEL(3);
-        RESTORE(GPDR0); RESTORE(GPDR1); RESTORE(GPDR2); RESTORE(GPDR3);
         RESTORE(GAFR0_L); RESTORE(GAFR0_U);
         RESTORE(GAFR1_L); RESTORE(GAFR1_U);
         RESTORE(GAFR2_L); RESTORE(GAFR2_U);
         RESTORE(GAFR3_L); RESTORE(GAFR3_U);
-        RESTORE(GRER0); RESTORE(GRER1); RESTORE(GRER2); RESTORE(GRER3);
-        RESTORE(GFER0); RESTORE(GFER1); RESTORE(GFER2); RESTORE(GFER3);
         RESTORE(PGSR0); RESTORE(PGSR1); RESTORE(PGSR2); RESTORE(PGSR3);
 
         RESTORE(MDREFR);
@@ -256,9 +234,6 @@ void pxa27x_cpu_pm_restore(unsigned long *sleep_save)
 
         RESTORE(CKEN);
 
-        ICLR = 0;
-        ICCR = 1;
-        RESTORE(ICMR);
         RESTORE(PSTR);
 }
 
@@ -409,9 +384,22 @@ static struct platform_device *devices[] __initdata = {
         &pxa27x_device_ssp3,
 };
 
+static struct sys_device pxa27x_sysdev[] = {
+        {
+                .id     = 0,
+                .cls    = &pxa_irq_sysclass,
+        }, {
+                .id     = 1,
+                .cls    = &pxa_irq_sysclass,
+        }, {
+                .cls    = &pxa_gpio_sysclass,
+        },
+};
+
 static int __init pxa27x_init(void)
 {
-        int ret = 0;
+        int i, ret = 0;
+
         if (cpu_is_pxa27x()) {
                 clks_register(pxa27x_clks, ARRAY_SIZE(pxa27x_clks));
 
@@ -420,8 +408,15 @@ static int __init pxa27x_init(void)
 
                 pxa27x_init_pm();
 
+                for (i = 0; i < ARRAY_SIZE(pxa27x_sysdev); i++) {
+                        ret = sysdev_register(&pxa27x_sysdev[i]);
+                        if (ret)
+                                pr_err("failed to register sysdev[%d]\n", i);
+                }
+
                 ret = platform_add_devices(devices, ARRAY_SIZE(devices));
         }
+
         return ret;
 }
 
diff --git a/arch/arm/mach-pxa/pxa3xx.c b/arch/arm/mach-pxa/pxa3xx.c
index 5cbf057a1b32..e47e67c11afe 100644
--- a/arch/arm/mach-pxa/pxa3xx.c
+++ b/arch/arm/mach-pxa/pxa3xx.c
@@ -20,6 +20,7 @@
 #include <linux/platform_device.h>
 #include <linux/irq.h>
 #include <linux/io.h>
+#include <linux/sysdev.h>
 
 #include <asm/hardware.h>
 #include <asm/arch/pxa3xx-regs.h>
@@ -39,6 +40,7 @@
 #define RO_CLK          60000000
 
 #define ACCR_D0CS       (1 << 26)
+#define ACCR_PCCE       (1 << 11)
 
 /* crystal frequency to static memory controller multiplier (SMCFS) */
 static unsigned char smcfs_mult[8] = { 6, 0, 8, 0, 0, 16, };
@@ -203,7 +205,6 @@ static struct clk pxa3xx_clks[] = {
 };
 
 #ifdef CONFIG_PM
-#define SLEEP_SAVE_SIZE 4
 
 #define ISRAM_START     0x5c000000
 #define ISRAM_SIZE      SZ_256K
@@ -211,25 +212,29 @@ static struct clk pxa3xx_clks[] = {
 static void __iomem *sram;
 static unsigned long wakeup_src;
 
-static void pxa3xx_cpu_pm_save(unsigned long *sleep_save)
-{
-        pr_debug("PM: CKENA=%08x CKENB=%08x\n", CKENA, CKENB);
+#define SAVE(x)         sleep_save[SLEEP_SAVE_##x] = x
+#define RESTORE(x)      x = sleep_save[SLEEP_SAVE_##x]
 
-        if (CKENA & (1 << CKEN_USBH)) {
-                printk(KERN_ERR "PM: USB host clock not stopped?\n");
-                CKENA &= ~(1 << CKEN_USBH);
-        }
-//      CKENA |= 1 << (CKEN_ISC & 31);
+enum {  SLEEP_SAVE_START = 0,
+        SLEEP_SAVE_CKENA,
+        SLEEP_SAVE_CKENB,
+        SLEEP_SAVE_ACCR,
 
-        /*
-         * Low power modes require the HSIO2 clock to be enabled.
-         */
-        CKENB |= 1 << (CKEN_HSIO2 & 31);
+        SLEEP_SAVE_SIZE,
+};
+
+static void pxa3xx_cpu_pm_save(unsigned long *sleep_save)
+{
+        SAVE(CKENA);
+        SAVE(CKENB);
+        SAVE(ACCR);
 }
 
 static void pxa3xx_cpu_pm_restore(unsigned long *sleep_save)
 {
-        CKENB &= ~(1 << (CKEN_HSIO2 & 31));
+        RESTORE(ACCR);
+        RESTORE(CKENA);
+        RESTORE(CKENB);
 }
 
 /*
@@ -265,6 +270,46 @@ static void pxa3xx_cpu_standby(unsigned int pwrmode)
         printk("PM: AD2D0SR=%08x ASCR=%08x\n", AD2D0SR, ASCR);
 }
 
+/*
+ * NOTE:  currently, the OBM (OEM Boot Module) binary comes along with
+ * PXA3xx development kits assumes that the resuming process continues
+ * with the address stored within the first 4 bytes of SDRAM. The PSPR
+ * register is used privately by BootROM and OBM, and _must_ be set to
+ * 0x5c014000 for the moment.
+ */
+static void pxa3xx_cpu_pm_suspend(void)
+{
+        volatile unsigned long *p = (volatile void *)0xc0000000;
+        unsigned long saved_data = *p;
+
+        extern void pxa3xx_cpu_suspend(void);
+        extern void pxa3xx_cpu_resume(void);
+
+        /* resuming from D2 requires the HSIO2/BOOT/TPM clocks enabled */
+        CKENA |= (1 << CKEN_BOOT) | (1 << CKEN_TPM);
+        CKENB |= 1 << (CKEN_HSIO2 & 0x1f);
+
+        /* clear and setup wakeup source */
+        AD3SR = ~0;
+        AD3ER = wakeup_src;
+        ASCR = ASCR;
+        ARSR = ARSR;
+
+        PCFR |= (1u << 13);                     /* L1_DIS */
+        PCFR &= ~((1u << 12) | (1u << 1));      /* L0_EN | SL_ROD */
+
+        PSPR = 0x5c014000;
+
+        /* overwrite with the resume address */
+        *p = virt_to_phys(pxa3xx_cpu_resume);
+
+        pxa3xx_cpu_suspend();
+
+        *p = saved_data;
+
+        AD3ER = 0;
+}
+
 static void pxa3xx_cpu_pm_enter(suspend_state_t state)
 {
         /*
@@ -279,6 +324,7 @@ static void pxa3xx_cpu_pm_enter(suspend_state_t state)
                 break;
 
         case PM_SUSPEND_MEM:
+                pxa3xx_cpu_pm_suspend();
                 break;
         }
 }
@@ -452,9 +498,21 @@ static struct platform_device *devices[] __initdata = {
         &pxa3xx_device_ssp4,
 };
 
+static struct sys_device pxa3xx_sysdev[] = {
+        {
+                .id     = 0,
+                .cls    = &pxa_irq_sysclass,
+        }, {
+                .id     = 1,
+                .cls    = &pxa_irq_sysclass,
+        }, {
+                .cls    = &pxa_gpio_sysclass,
+        },
+};
+
 static int __init pxa3xx_init(void)
 {
-        int ret = 0;
+        int i, ret = 0;
 
         if (cpu_is_pxa3xx()) {
                 clks_register(pxa3xx_clks, ARRAY_SIZE(pxa3xx_clks));
@@ -464,9 +522,16 @@ static int __init pxa3xx_init(void)
 
                 pxa3xx_init_pm();
 
-                return platform_add_devices(devices, ARRAY_SIZE(devices));
+                for (i = 0; i < ARRAY_SIZE(pxa3xx_sysdev); i++) {
+                        ret = sysdev_register(&pxa3xx_sysdev[i]);
+                        if (ret)
+                                pr_err("failed to register sysdev[%d]\n", i);
+                }
+
+                ret = platform_add_devices(devices, ARRAY_SIZE(devices));
         }
-        return 0;
+
+        return ret;
 }
 
 subsys_initcall(pxa3xx_init);
diff --git a/arch/arm/mach-pxa/sleep.S b/arch/arm/mach-pxa/sleep.S
index 14bb4a93ea52..784716eb7fc5 100644
--- a/arch/arm/mach-pxa/sleep.S
+++ b/arch/arm/mach-pxa/sleep.S
@@ -50,6 +50,108 @@ pxa_cpu_save_sp:
         str     r0, [r1]
         ldr     pc, [sp], #4
 
+#ifdef CONFIG_PXA3xx
+/*
+ * pxa3xx_cpu_suspend() - forces CPU into sleep state (S2D3C4)
+ *
+ * NOTE:  unfortunately, pxa_cpu_save_cp can not be reused here since
+ * the auxiliary control register address is different between pxa3xx
+ * and pxa{25x,27x}
+ */
+
+ENTRY(pxa3xx_cpu_suspend)
+
+#ifndef CONFIG_IWMMXT
+        mra     r2, r3, acc0
+#endif
+        stmfd   sp!, {r2 - r12, lr}     @ save registers on stack
+
+        mrc     p14, 0, r3, c6, c0, 0           @ clock configuration, for turbo mode
+        mrc     p15, 0, r4, c15, c1, 0          @ CP access reg
+        mrc     p15, 0, r5, c13, c0, 0          @ PID
+        mrc     p15, 0, r6, c3, c0, 0           @ domain ID
+        mrc     p15, 0, r7, c2, c0, 0           @ translation table base addr
+        mrc     p15, 0, r8, c1, c0, 1           @ auxiliary control reg
+        mrc     p15, 0, r9, c1, c0, 0           @ control reg
+
+        bic     r3, r3, #2                      @ clear frequency change bit
+
+        @ store them plus current virtual stack ptr on stack
+        mov     r10, sp
+        stmfd   sp!, {r3 - r10}
+
+        @ store physical address of stack pointer
+        mov     r0, sp
+        bl      sleep_phys_sp
+        ldr     r1, =sleep_save_sp
+        str     r0, [r1]
+
+        @ clean data cache
+        bl      xsc3_flush_kern_cache_all
+
+        mov     r0, #0x06               @ S2D3C4 mode
+        mcr     p14, 0, r0, c7, c0, 0   @ enter sleep
+
+20:     b       20b                     @ waiting for sleep
+
+        .data
+        .align 5
+/*
+ * pxa3xx_cpu_resume
+ */
+
+ENTRY(pxa3xx_cpu_resume)
+
+        mov     r0, #PSR_I_BIT | PSR_F_BIT | SVC_MODE   @ set SVC, irqs off
+        msr     cpsr_c, r0
+
+        ldr     r0, sleep_save_sp               @ stack phys addr
+        ldmfd   r0, {r3 - r9, sp}               @ CP regs + virt stack ptr
+
+        mov     r1, #0
+        mcr     p15, 0, r1, c7, c7, 0           @ invalidate I & D caches, BTB
+        mcr     p15, 0, r1, c7, c10, 4          @ drain write (&fill) buffer
+        mcr     p15, 0, r1, c7, c5, 4           @ flush prefetch buffer
+        mcr     p15, 0, r1, c8, c7, 0           @ invalidate I & D TLBs
+
+        mcr     p14, 0, r3, c6, c0, 0           @ clock configuration, turbo mode.
+        mcr     p15, 0, r4, c15, c1, 0          @ CP access reg
+        mcr     p15, 0, r5, c13, c0, 0          @ PID
+        mcr     p15, 0, r6, c3, c0, 0           @ domain ID
+        mcr     p15, 0, r7, c2, c0, 0           @ translation table base addr
+        mcr     p15, 0, r8, c1, c0, 1           @ auxiliary control reg
+
+        @ temporarily map resume_turn_on_mmu into the page table,
+        @ otherwise prefetch abort occurs after MMU is turned on
+        mov     r1, r7
+        bic     r1, r1, #0x00ff
+        bic     r1, r1, #0x3f00
+        ldr     r2, =0x542e
+
+        adr     r3, resume_turn_on_mmu
+        mov     r3, r3, lsr #20
+        orr     r4, r2, r3, lsl #20
+        ldr     r5, [r1, r3, lsl #2]
+        str     r4, [r1, r3, lsl #2]
+
+        @ Mapping page table address in the page table
+        mov     r6, r1, lsr #20
+        orr     r7, r2, r6, lsl #20
+        ldr     r8, [r1, r6, lsl #2]
+        str     r7, [r1, r6, lsl #2]
+
+        ldr     r2, =pxa3xx_resume_after_mmu    @ absolute virtual address
+        b       resume_turn_on_mmu              @ cache align execution
+
+        .text
+pxa3xx_resume_after_mmu:
+        /* restore the temporary mapping */
+        str     r5, [r1, r3, lsl #2]
+        str     r8, [r1, r6, lsl #2]
+        b       resume_after_mmu
+
+#endif /* CONFIG_PXA3xx */
+
 #ifdef CONFIG_PXA27x
 /*
  * pxa27x_cpu_suspend()
diff --git a/arch/arm/mach-pxa/smemc.c b/arch/arm/mach-pxa/smemc.c
new file mode 100644
index 000000000000..ad346addc028
--- /dev/null
+++ b/arch/arm/mach-pxa/smemc.c
@@ -0,0 +1,88 @@
+/*
+ * Static Memory Controller
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/sysdev.h>
+
+#define SMEMC_PHYS_BASE (0x4A000000)
+#define SMEMC_PHYS_SIZE (0x90)
+
+#define MSC0            (0x08)  /* Static Memory Controller Register 0 */
+#define MSC1            (0x0C)  /* Static Memory Controller Register 1 */
+#define SXCNFG          (0x1C)  /* Synchronous Static Memory Control Register */
+#define MEMCLKCFG       (0x68)  /* Clock Configuration */
+#define CSADRCFG0       (0x80)  /* Address Configuration Register for CS0 */
+#define CSADRCFG1       (0x84)  /* Address Configuration Register for CS1 */
+#define CSADRCFG2       (0x88)  /* Address Configuration Register for CS2 */
+#define CSADRCFG3       (0x8C)  /* Address Configuration Register for CS3 */
+
+#ifdef CONFIG_PM
+static void __iomem *smemc_mmio_base;
+
+static unsigned long msc[2];
+static unsigned long sxcnfg, memclkcfg;
+static unsigned long csadrcfg[4];
+
+static int pxa3xx_smemc_suspend(struct sys_device *dev, pm_message_t state)
+{
+        msc[0] = __raw_readl(smemc_mmio_base + MSC0);
+        msc[1] = __raw_readl(smemc_mmio_base + MSC1);
+        sxcnfg = __raw_readl(smemc_mmio_base + SXCNFG);
+        memclkcfg = __raw_readl(smemc_mmio_base + MEMCLKCFG);
+        csadrcfg[0] = __raw_readl(smemc_mmio_base + CSADRCFG0);
+        csadrcfg[1] = __raw_readl(smemc_mmio_base + CSADRCFG1);
+        csadrcfg[2] = __raw_readl(smemc_mmio_base + CSADRCFG2);
+        csadrcfg[3] = __raw_readl(smemc_mmio_base + CSADRCFG3);
+
+        return 0;
+}
+
+static int pxa3xx_smemc_resume(struct sys_device *dev)
+{
+        __raw_writel(msc[0], smemc_mmio_base + MSC0);
+        __raw_writel(msc[1], smemc_mmio_base + MSC1);
+        __raw_writel(sxcnfg, smemc_mmio_base + SXCNFG);
+        __raw_writel(memclkcfg, smemc_mmio_base + MEMCLKCFG);
+        __raw_writel(csadrcfg[0], smemc_mmio_base + CSADRCFG0);
+        __raw_writel(csadrcfg[1], smemc_mmio_base + CSADRCFG1);
+        __raw_writel(csadrcfg[2], smemc_mmio_base + CSADRCFG2);
+        __raw_writel(csadrcfg[3], smemc_mmio_base + CSADRCFG3);
+
+        return 0;
+}
+
+static struct sysdev_class smemc_sysclass = {
+        .name           = "smemc",
+        .suspend        = pxa3xx_smemc_suspend,
+        .resume         = pxa3xx_smemc_resume,
+};
+
+static struct sys_device smemc_sysdev = {
+        .id             = 0,
+        .cls            = &smemc_sysclass,
+};
+
+static int __init smemc_init(void)
+{
+        int ret = 0;
+
+        if (cpu_is_pxa3xx()) {
+                smemc_mmio_base = ioremap(SMEMC_PHYS_BASE, SMEMC_PHYS_SIZE);
+                if (smemc_mmio_base == NULL)
+                        return -ENODEV;
+
+                ret = sysdev_class_register(&smemc_sysclass);
+                if (ret)
+                        return ret;
+
+                ret = sysdev_register(&smemc_sysdev);
+        }
+
+        return ret;
+}
+subsys_initcall(smemc_init);
+#endif
diff --git a/arch/arm/mach-pxa/spitz.c b/arch/arm/mach-pxa/spitz.c
index 5078edeadf96..9e7773fca01c 100644
--- a/arch/arm/mach-pxa/spitz.c
+++ b/arch/arm/mach-pxa/spitz.c
@@ -36,6 +36,7 @@
 #include <asm/mach/irq.h>
 
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-regs.h>
 #include <asm/arch/irda.h>
 #include <asm/arch/mmc.h>
 #include <asm/arch/ohci.h>
diff --git a/arch/arm/mach-pxa/tosa.c b/arch/arm/mach-pxa/tosa.c
index 1919756900f4..9b26fa5edad6 100644
--- a/arch/arm/mach-pxa/tosa.c
+++ b/arch/arm/mach-pxa/tosa.c
@@ -29,6 +29,7 @@
 #include <asm/irq.h>
 #include <asm/system.h>
 #include <asm/arch/pxa-regs.h>
+#include <asm/arch/pxa2xx-regs.h>
 #include <asm/arch/irda.h>
 #include <asm/arch/mmc.h>
 #include <asm/arch/udc.h>
@@ -157,15 +158,10 @@ static void tosa_udc_command(int cmd)
         }
 }
 
-static int tosa_udc_is_connected(void)
-{
-        return ((GPLR(TOSA_GPIO_USB_IN) & GPIO_bit(TOSA_GPIO_USB_IN)) == 0);
-}
-
-
 static struct pxa2xx_udc_mach_info udc_info __initdata = {
         .udc_command            = tosa_udc_command,
-        .udc_is_connected       = tosa_udc_is_connected,
+        .gpio_vbus              = TOSA_GPIO_USB_IN,
+        .gpio_vbus_inverted     = 1,
 };
 
 /*
diff --git a/arch/arm/mach-realview/Kconfig b/arch/arm/mach-realview/Kconfig
index 35156ca39df7..39b3bb7f1020 100644
--- a/arch/arm/mach-realview/Kconfig
+++ b/arch/arm/mach-realview/Kconfig
@@ -7,24 +7,21 @@ config MACH_REALVIEW_EB
         help
           Include support for the ARM(R) RealView Emulation Baseboard platform.
 
-config REALVIEW_MPCORE
-        bool "Support MPcore tile"
+config REALVIEW_EB_ARM11MP
+        bool "Support ARM11MPCore tile"
         depends on MACH_REALVIEW_EB
         select CACHE_L2X0
         help
-          Enable support for the MPCore tile on the Realview platform.
-          Since there are device address and interrupt differences, a
-          kernel built with this option enabled is not compatible with
-          other tiles.
+          Enable support for the ARM11MPCore tile on the Realview platform.
 
-config REALVIEW_MPCORE_REVB
-        bool "Support MPcore RevB tile"
-        depends on REALVIEW_MPCORE
+config REALVIEW_EB_ARM11MP_REVB
+        bool "Support ARM11MPCore RevB tile"
+        depends on REALVIEW_EB_ARM11MP
         default n
         help
-          Enable support for the MPCore RevB tile on the Realview platform.
-          Since there are device address differences, a
+          Enable support for the ARM11MPCore RevB tile on the Realview
+          platform. Since there are device address differences, a
           kernel built with this option enabled is not compatible with
-          other tiles.
+          other revisions of the ARM11MPCore tile.
 
 endmenu
diff --git a/arch/arm/mach-realview/Makefile b/arch/arm/mach-realview/Makefile
index 36e76ba937fc..ca1e390c3c28 100644
--- a/arch/arm/mach-realview/Makefile
+++ b/arch/arm/mach-realview/Makefile
@@ -4,6 +4,5 @@
 
 obj-y                                   := core.o clock.o
 obj-$(CONFIG_MACH_REALVIEW_EB)          += realview_eb.o
-obj-$(CONFIG_SMP)                       += platsmp.o headsmp.o
+obj-$(CONFIG_SMP)                       += platsmp.o headsmp.o localtimer.o
 obj-$(CONFIG_HOTPLUG_CPU)               += hotplug.o
-obj-$(CONFIG_LOCAL_TIMERS)              += localtimer.o
diff --git a/arch/arm/mach-realview/core.c b/arch/arm/mach-realview/core.c
index 61d70218f1e8..98aefc9f4df3 100644
--- a/arch/arm/mach-realview/core.c
+++ b/arch/arm/mach-realview/core.c
@@ -25,6 +25,8 @@
 #include <linux/interrupt.h>
 #include <linux/amba/bus.h>
 #include <linux/amba/clcd.h>
+#include <linux/clocksource.h>
+#include <linux/clockchips.h>
 
 #include <asm/system.h>
 #include <asm/hardware.h>
@@ -37,7 +39,6 @@
 #include <asm/mach/arch.h>
 #include <asm/mach/flash.h>
 #include <asm/mach/irq.h>
-#include <asm/mach/time.h>
 #include <asm/mach/map.h>
 #include <asm/mach/mmc.h>
 
@@ -48,6 +49,9 @@
 
 #define REALVIEW_REFCOUNTER     (__io_address(REALVIEW_SYS_BASE) + REALVIEW_SYS_24MHz_OFFSET)
 
+/* used by entry-macro.S */
+void __iomem *gic_cpu_base_addr;
+
 /*
  * This is the RealView sched_clock implementation.  This has
  * a resolution of 41.7ns, and a maximum value of about 179s.
@@ -121,26 +125,6 @@ struct platform_device realview_flash_device = {
         .resource               = &realview_flash_resource,
 };
 
-static struct resource realview_smc91x_resources[] = {
-        [0] = {
-                .start          = REALVIEW_ETH_BASE,
-                .end            = REALVIEW_ETH_BASE + SZ_64K - 1,
-                .flags          = IORESOURCE_MEM,
-        },
-        [1] = {
-                .start          = IRQ_ETH,
-                .end            = IRQ_ETH,
-                .flags          = IORESOURCE_IRQ,
-        },
-};
-
-struct platform_device realview_smc91x_device = {
-        .name           = "smc91x",
-        .id             = 0,
-        .num_resources  = ARRAY_SIZE(realview_smc91x_resources),
-        .resource       = realview_smc91x_resources,
-};
-
 static struct resource realview_i2c_resource = {
         .start          = REALVIEW_I2C_BASE,
         .end            = REALVIEW_I2C_BASE + SZ_4K - 1,
@@ -484,45 +468,64 @@ void realview_leds_event(led_event_t ledevt)
 #define TICKS2USECS(x)  ((x) / TICKS_PER_uSEC)
 #endif
 
-/*
- * Returns number of ms since last clock interrupt.  Note that interrupts
- * will have been disabled by do_gettimeoffset()
- */
-static unsigned long realview_gettimeoffset(void)
+static void timer_set_mode(enum clock_event_mode mode,
+                           struct clock_event_device *clk)
 {
-        unsigned long ticks1, ticks2, status;
+        unsigned long ctrl;
 
-        /*
-         * Get the current number of ticks.  Note that there is a race
-         * condition between us reading the timer and checking for
-         * an interrupt.  We get around this by ensuring that the
-         * counter has not reloaded between our two reads.
-         */
-        ticks2 = readl(TIMER0_VA_BASE + TIMER_VALUE) & 0xffff;
-        do {
-                ticks1 = ticks2;
-                status = __raw_readl(__io_address(REALVIEW_GIC_DIST_BASE + GIC_DIST_PENDING_SET)
-                                     + ((IRQ_TIMERINT0_1 >> 5) << 2));
-                ticks2 = readl(TIMER0_VA_BASE + TIMER_VALUE) & 0xffff;
-        } while (ticks2 > ticks1);
+        switch(mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+                writel(TIMER_RELOAD, TIMER0_VA_BASE + TIMER_LOAD);
 
-        /*
-         * Number of ticks since last interrupt.
-         */
-        ticks1 = TIMER_RELOAD - ticks2;
+                ctrl = TIMER_CTRL_PERIODIC;
+                ctrl |= TIMER_CTRL_32BIT | TIMER_CTRL_IE | TIMER_CTRL_ENABLE;
+                break;
+        case CLOCK_EVT_MODE_ONESHOT:
+                /* period set, and timer enabled in 'next_event' hook */
+                ctrl = TIMER_CTRL_ONESHOT;
+                ctrl |= TIMER_CTRL_32BIT | TIMER_CTRL_IE;
+                break;
+        case CLOCK_EVT_MODE_UNUSED:
+        case CLOCK_EVT_MODE_SHUTDOWN:
+        default:
+                ctrl = 0;
+        }
 
-        /*
-         * Interrupt pending?  If so, we've reloaded once already.
-         *
-         * FIXME: Need to check this is effectively timer 0 that expires
-         */
-        if (status & IRQMASK_TIMERINT0_1)
-                ticks1 += TIMER_RELOAD;
+        writel(ctrl, TIMER0_VA_BASE + TIMER_CTRL);
+}
 
-        /*
-         * Convert the ticks to usecs
-         */
-        return TICKS2USECS(ticks1);
+static int timer_set_next_event(unsigned long evt,
+                                struct clock_event_device *unused)
+{
+        unsigned long ctrl = readl(TIMER0_VA_BASE + TIMER_CTRL);
+
+        writel(evt, TIMER0_VA_BASE + TIMER_LOAD);
+        writel(ctrl | TIMER_CTRL_ENABLE, TIMER0_VA_BASE + TIMER_CTRL);
+
+        return 0;
+}
+
+static struct clock_event_device timer0_clockevent =     {
+        .name           = "timer0",
+        .shift          = 32,
+        .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
+        .set_mode       = timer_set_mode,
+        .set_next_event = timer_set_next_event,
+        .rating         = 300,
+        .cpumask        = CPU_MASK_ALL,
+};
+
+static void __init realview_clockevents_init(unsigned int timer_irq)
+{
+        timer0_clockevent.irq = timer_irq;
+        timer0_clockevent.mult =
+                div_sc(1000000, NSEC_PER_SEC, timer0_clockevent.shift);
+        timer0_clockevent.max_delta_ns =
+                clockevent_delta2ns(0xffffffff, &timer0_clockevent);
+        timer0_clockevent.min_delta_ns =
+                clockevent_delta2ns(0xf, &timer0_clockevent);
+
+        clockevents_register_device(&timer0_clockevent);
 }
 
 /*
@@ -530,15 +533,12 @@ static unsigned long realview_gettimeoffset(void)
  */
 static irqreturn_t realview_timer_interrupt(int irq, void *dev_id)
 {
-        // ...clear the interrupt
+        struct clock_event_device *evt = &timer0_clockevent;
+
+        /* clear the interrupt */
         writel(1, TIMER0_VA_BASE + TIMER_INTCLR);
 
-        timer_tick();
-
-#if defined(CONFIG_SMP) && !defined(CONFIG_LOCAL_TIMERS)
-        smp_send_timer();
-        update_process_times(user_mode(get_irq_regs()));
-#endif
+        evt->event_handler(evt);
 
         return IRQ_HANDLED;
 }
@@ -549,13 +549,49 @@ static struct irqaction realview_timer_irq = {
         .handler        = realview_timer_interrupt,
 };
 
+static cycle_t realview_get_cycles(void)
+{
+        return ~readl(TIMER3_VA_BASE + TIMER_VALUE);
+}
+
+static struct clocksource clocksource_realview = {
+        .name   = "timer3",
+        .rating = 200,
+        .read   = realview_get_cycles,
+        .mask   = CLOCKSOURCE_MASK(32),
+        .shift  = 20,
+        .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
+static void __init realview_clocksource_init(void)
+{
+        /* setup timer 0 as free-running clocksource */
+        writel(0, TIMER3_VA_BASE + TIMER_CTRL);
+        writel(0xffffffff, TIMER3_VA_BASE + TIMER_LOAD);
+        writel(0xffffffff, TIMER3_VA_BASE + TIMER_VALUE);
+        writel(TIMER_CTRL_32BIT | TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC,
+                TIMER3_VA_BASE + TIMER_CTRL);
+
+        clocksource_realview.mult =
+                clocksource_khz2mult(1000, clocksource_realview.shift);
+        clocksource_register(&clocksource_realview);
+}
+
 /*
- * Set up timer interrupt, and return the current time in seconds.
+ * Set up the clock source and clock events devices
  */
-static void __init realview_timer_init(void)
+void __init realview_timer_init(unsigned int timer_irq)
 {
         u32 val;
 
+#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
+        /*
+         * The dummy clock device has to be registered before the main device
+         * so that the latter will broadcast the clock events
+         */
+        local_timer_setup(smp_processor_id());
+#endif
+
         /* 
          * set clock frequency: 
          *      REALVIEW_REFCLK is 32KHz
@@ -576,18 +612,11 @@ static void __init realview_timer_init(void)
         writel(0, TIMER2_VA_BASE + TIMER_CTRL);
         writel(0, TIMER3_VA_BASE + TIMER_CTRL);
 
-        writel(TIMER_RELOAD, TIMER0_VA_BASE + TIMER_LOAD);
-        writel(TIMER_RELOAD, TIMER0_VA_BASE + TIMER_VALUE);
-        writel(TIMER_DIVISOR | TIMER_CTRL_ENABLE | TIMER_CTRL_PERIODIC |
-               TIMER_CTRL_IE, TIMER0_VA_BASE + TIMER_CTRL);
-
         /* 
          * Make irqs happen for the system timer
          */
-        setup_irq(IRQ_TIMERINT0_1, &realview_timer_irq);
-}
+        setup_irq(timer_irq, &realview_timer_irq);
 
-struct sys_timer realview_timer = {
-        .init           = realview_timer_init,
-        .offset         = realview_gettimeoffset,
-};
+        realview_clocksource_init();
+        realview_clockevents_init(timer_irq);
+}
diff --git a/arch/arm/mach-realview/core.h b/arch/arm/mach-realview/core.h
index 2b53420f9c1b..492a14c0d604 100644
--- a/arch/arm/mach-realview/core.h
+++ b/arch/arm/mach-realview/core.h
@@ -27,8 +27,6 @@
 #include <asm/leds.h>
 #include <asm/io.h>
 
-extern struct sys_timer realview_timer;
-
 #define AMBA_DEVICE(name,busid,base,plat)                       \
 static struct amba_device name##_device = {                     \
         .dev            = {                                     \
@@ -38,7 +36,7 @@ static struct amba_device name##_device = {			\
         },                                                      \
         .res            = {                                     \
                 .start  = REALVIEW_##base##_BASE,               \
-                .end    = (REALVIEW_##base##_BASE) + SZ_4K - 1,\
+                .end    = (REALVIEW_##base##_BASE) + SZ_4K - 1, \
                 .flags  = IORESOURCE_MEM,                       \
         },                                                      \
         .dma_mask       = ~0,                                   \
@@ -46,74 +44,19 @@ static struct amba_device name##_device = {			\
         /* .dma         = base##_DMA,*/                         \
 }
 
-/*
- * These devices are connected via the core APB bridge
- */
-#define GPIO2_IRQ       { IRQ_GPIOINT2, NO_IRQ }
-#define GPIO2_DMA       { 0, 0 }
-#define GPIO3_IRQ       { IRQ_GPIOINT3, NO_IRQ }
-#define GPIO3_DMA       { 0, 0 }
-
-#define AACI_IRQ        { IRQ_AACI, NO_IRQ }
-#define AACI_DMA        { 0x80, 0x81 }
-#define MMCI0_IRQ       { IRQ_MMCI0A,IRQ_MMCI0B }
-#define MMCI0_DMA       { 0x84, 0 }
-#define KMI0_IRQ        { IRQ_KMI0, NO_IRQ }
-#define KMI0_DMA        { 0, 0 }
-#define KMI1_IRQ        { IRQ_KMI1, NO_IRQ }
-#define KMI1_DMA        { 0, 0 }
-
-/*
- * These devices are connected directly to the multi-layer AHB switch
- */
-#define SMC_IRQ         { NO_IRQ, NO_IRQ }
-#define SMC_DMA         { 0, 0 }
-#define MPMC_IRQ        { NO_IRQ, NO_IRQ }
-#define MPMC_DMA        { 0, 0 }
-#define CLCD_IRQ        { IRQ_CLCDINT, NO_IRQ }
-#define CLCD_DMA        { 0, 0 }
-#define DMAC_IRQ        { IRQ_DMAINT, NO_IRQ }
-#define DMAC_DMA        { 0, 0 }
-
-/*
- * These devices are connected via the core APB bridge
- */
-#define SCTL_IRQ        { NO_IRQ, NO_IRQ }
-#define SCTL_DMA        { 0, 0 }
-#define WATCHDOG_IRQ    { IRQ_WDOGINT, NO_IRQ }
-#define WATCHDOG_DMA    { 0, 0 }
-#define GPIO0_IRQ       { IRQ_GPIOINT0, NO_IRQ }
-#define GPIO0_DMA       { 0, 0 }
-#define GPIO1_IRQ       { IRQ_GPIOINT1, NO_IRQ }
-#define GPIO1_DMA       { 0, 0 }
-#define RTC_IRQ         { IRQ_RTCINT, NO_IRQ }
-#define RTC_DMA         { 0, 0 }
-
-/*
- * These devices are connected via the DMA APB bridge
- */
-#define SCI_IRQ         { IRQ_SCIINT, NO_IRQ }
-#define SCI_DMA         { 7, 6 }
-#define UART0_IRQ       { IRQ_UARTINT0, NO_IRQ }
-#define UART0_DMA       { 15, 14 }
-#define UART1_IRQ       { IRQ_UARTINT1, NO_IRQ }
-#define UART1_DMA       { 13, 12 }
-#define UART2_IRQ       { IRQ_UARTINT2, NO_IRQ }
-#define UART2_DMA       { 11, 10 }
-#define UART3_IRQ       { IRQ_UART3, NO_IRQ }
-#define UART3_DMA       { 0x86, 0x87 }
-#define SSP_IRQ         { IRQ_SSPINT, NO_IRQ }
-#define SSP_DMA         { 9, 8 }
-
-
 extern struct platform_device realview_flash_device;
-extern struct platform_device realview_smc91x_device;
 extern struct platform_device realview_i2c_device;
 extern struct mmc_platform_data realview_mmc0_plat_data;
 extern struct mmc_platform_data realview_mmc1_plat_data;
 extern struct clk realview_clcd_clk;
 extern struct clcd_board clcd_plat_data;
+extern void __iomem *gic_cpu_base_addr;
+#ifdef CONFIG_LOCAL_TIMERS
+extern void __iomem *twd_base_addr;
+extern unsigned int twd_size;
+#endif
 
 extern void realview_leds_event(led_event_t ledevt);
+extern void realview_timer_init(unsigned int timer_irq);
 
 #endif
diff --git a/arch/arm/mach-realview/localtimer.c b/arch/arm/mach-realview/localtimer.c
index c7bdf04ab094..50604360479f 100644
--- a/arch/arm/mach-realview/localtimer.c
+++ b/arch/arm/mach-realview/localtimer.c
@@ -14,19 +14,75 @@
 #include <linux/device.h>
 #include <linux/smp.h>
 #include <linux/jiffies.h>
+#include <linux/percpu.h>
+#include <linux/clockchips.h>
+#include <linux/irq.h>
 
-#include <asm/mach/time.h>
 #include <asm/hardware/arm_twd.h>
 #include <asm/hardware/gic.h>
 #include <asm/hardware.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 
-#define TWD_BASE(cpu)   (__io_address(REALVIEW_TWD_BASE) + \
-                         ((cpu) * REALVIEW_TWD_SIZE))
+static DEFINE_PER_CPU(struct clock_event_device, local_clockevent);
+
+/*
+ * Used on SMP for either the local timer or IPI_TIMER
+ */
+void local_timer_interrupt(void)
+{
+        struct clock_event_device *clk = &__get_cpu_var(local_clockevent);
+
+        clk->event_handler(clk);
+}
+
+#ifdef CONFIG_LOCAL_TIMERS
+
+#define TWD_BASE(cpu)   (twd_base_addr + (cpu) * twd_size)
+
+/* set up by the platform code */
+void __iomem *twd_base_addr;
+unsigned int twd_size;
 
 static unsigned long mpcore_timer_rate;
 
+static void local_timer_set_mode(enum clock_event_mode mode,
+                                 struct clock_event_device *clk)
+{
+        void __iomem *base = TWD_BASE(smp_processor_id());
+        unsigned long ctrl;
+
+        switch(mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+                /* timer load already set up */
+                ctrl = TWD_TIMER_CONTROL_ENABLE | TWD_TIMER_CONTROL_IT_ENABLE
+                        | TWD_TIMER_CONTROL_PERIODIC;
+                break;
+        case CLOCK_EVT_MODE_ONESHOT:
+                /* period set, and timer enabled in 'next_event' hook */
+                ctrl = TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT;
+                break;
+        case CLOCK_EVT_MODE_UNUSED:
+        case CLOCK_EVT_MODE_SHUTDOWN:
+        default:
+                ctrl = 0;
+        }
+
+        __raw_writel(ctrl, base + TWD_TIMER_CONTROL);
+}
+
+static int local_timer_set_next_event(unsigned long evt,
+                                      struct clock_event_device *unused)
+{
+        void __iomem *base = TWD_BASE(smp_processor_id());
+        unsigned long ctrl = __raw_readl(base + TWD_TIMER_CONTROL);
+
+        __raw_writel(evt, base + TWD_TIMER_COUNTER);
+        __raw_writel(ctrl | TWD_TIMER_CONTROL_ENABLE, base + TWD_TIMER_CONTROL);
+
+        return 0;
+}
+
 /*
  * local_timer_ack: checks for a local timer interrupt.
  *
@@ -45,12 +101,11 @@ int local_timer_ack(void)
         return 0;
 }
 
-void __cpuinit local_timer_setup(unsigned int cpu)
+static void __cpuinit twd_calibrate_rate(unsigned int cpu)
 {
         void __iomem *base = TWD_BASE(cpu);
-        unsigned int load, offset;
+        unsigned long load, count;
         u64 waitjiffies;
-        unsigned int count;
 
         /*
          * If this is the first time round, we need to work out how fast
@@ -88,36 +143,36 @@ void __cpuinit local_timer_setup(unsigned int cpu)
         load = mpcore_timer_rate / HZ;
 
         __raw_writel(load, base + TWD_TIMER_LOAD);
-        __raw_writel(0x7,  base + TWD_TIMER_CONTROL);
-
-        /*
-         * Now maneuver our local tick into the right part of the jiffy.
-         * Start by working out where within the tick our local timer
-         * interrupt should go.
-         */
-        offset = ((mpcore_timer_rate / HZ) / (NR_CPUS + 1)) * (cpu + 1);
-
-        /*
-         * gettimeoffset() will return a number of us since the last tick.
-         * Convert this number of us to a local timer tick count.
-         * Be careful of integer overflow whilst keeping maximum precision.
-         *
-         * with HZ=100 and 1MHz (fpga) ~ 1GHz processor:
-         * load = 1 ~ 10,000
-         * mpcore_timer_rate/10000 = 100 ~ 100,000
-         *
-         * so the multiply value will be less than 10^9 always.
-         */
-        load = (system_timer->offset() * (mpcore_timer_rate / 10000)) / 100;
-
-        /* Add on our offset to get the load value */
-        load = (load + offset) % (mpcore_timer_rate / HZ);
+}
 
-        __raw_writel(load, base + TWD_TIMER_COUNTER);
+/*
+ * Setup the local clock events for a CPU.
+ */
+void __cpuinit local_timer_setup(unsigned int cpu)
+{
+        struct clock_event_device *clk = &per_cpu(local_clockevent, cpu);
+        unsigned long flags;
+
+        twd_calibrate_rate(cpu);
+
+        clk->name               = "local_timer";
+        clk->features           = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
+        clk->rating             = 350;
+        clk->set_mode           = local_timer_set_mode;
+        clk->set_next_event     = local_timer_set_next_event;
+        clk->irq                = IRQ_LOCALTIMER;
+        clk->cpumask            = cpumask_of_cpu(cpu);
+        clk->shift              = 20;
+        clk->mult               = div_sc(mpcore_timer_rate, NSEC_PER_SEC, clk->shift);
+        clk->max_delta_ns       = clockevent_delta2ns(0xffffffff, clk);
+        clk->min_delta_ns       = clockevent_delta2ns(0xf, clk);
 
         /* Make sure our local interrupt controller has this enabled */
-        __raw_writel(1 << IRQ_LOCALTIMER,
-                     __io_address(REALVIEW_GIC_DIST_BASE) + GIC_DIST_ENABLE_SET);
+        local_irq_save(flags);
+        get_irq_chip(IRQ_LOCALTIMER)->unmask(IRQ_LOCALTIMER);
+        local_irq_restore(flags);
+
+        clockevents_register_device(clk);
 }
 
 /*
@@ -127,3 +182,26 @@ void __cpuexit local_timer_stop(unsigned int cpu)
 {
         __raw_writel(0, TWD_BASE(cpu) + TWD_TIMER_CONTROL);
 }
+
+#else   /* CONFIG_LOCAL_TIMERS */
+
+static void dummy_timer_set_mode(enum clock_event_mode mode,
+                                 struct clock_event_device *clk)
+{
+}
+
+void __cpuinit local_timer_setup(unsigned int cpu)
+{
+        struct clock_event_device *clk = &per_cpu(local_clockevent, cpu);
+
+        clk->name               = "dummy_timer";
+        clk->features           = CLOCK_EVT_FEAT_DUMMY;
+        clk->rating             = 200;
+        clk->set_mode           = dummy_timer_set_mode;
+        clk->broadcast          = smp_timer_broadcast;
+        clk->cpumask            = cpumask_of_cpu(cpu);
+
+        clockevents_register_device(clk);
+}
+
+#endif  /* !CONFIG_LOCAL_TIMERS */
diff --git a/arch/arm/mach-realview/platsmp.c b/arch/arm/mach-realview/platsmp.c
index fce3596f9950..de2b7159557d 100644
--- a/arch/arm/mach-realview/platsmp.c
+++ b/arch/arm/mach-realview/platsmp.c
@@ -18,6 +18,7 @@
 #include <asm/hardware/arm_scu.h>
 #include <asm/hardware.h>
 #include <asm/io.h>
+#include <asm/mach-types.h>
 
 extern void realview_secondary_startup(void);
 
@@ -31,9 +32,13 @@ static unsigned int __init get_core_count(void)
 {
         unsigned int ncores;
 
-        ncores = __raw_readl(__io_address(REALVIEW_MPCORE_SCU_BASE) + SCU_CONFIG);
+        if (machine_is_realview_eb() && core_tile_eb11mp()) {
+                ncores = __raw_readl(__io_address(REALVIEW_EB11MP_SCU_BASE) + SCU_CONFIG);
+                ncores = (ncores & 0x03) + 1;
+        } else
+                ncores = 1;
 
-        return (ncores & 0x03) + 1;
+        return ncores;
 }
 
 static DEFINE_SPINLOCK(boot_lock);
@@ -52,7 +57,7 @@ void __cpuinit platform_secondary_init(unsigned int cpu)
          * core (e.g. timer irq), then they will not have been enabled
          * for us: do so
          */
-        gic_cpu_init(0, __io_address(REALVIEW_GIC_CPU_BASE));
+        gic_cpu_init(0, __io_address(REALVIEW_EB11MP_GIC_CPU_BASE));
 
         /*
          * let the primary processor know we're out of the
@@ -187,10 +192,15 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
         if (max_cpus > ncores)
                 max_cpus = ncores;
 
+#ifdef CONFIG_LOCAL_TIMERS
         /*
-         * Enable the local timer for primary CPU
+         * Enable the local timer for primary CPU. If the device is
+         * dummy (!CONFIG_LOCAL_TIMERS), it was already registers in
+         * realview_timer_init
          */
-        local_timer_setup(cpu);
+        if (machine_is_realview_eb() && core_tile_eb11mp())
+                local_timer_setup(cpu);
+#endif
 
         /*
          * Initialise the present map, which describes the set of CPUs
diff --git a/arch/arm/mach-realview/realview_eb.c b/arch/arm/mach-realview/realview_eb.c
index ecec2f85c4cd..60d9eb810246 100644
--- a/arch/arm/mach-realview/realview_eb.c
+++ b/arch/arm/mach-realview/realview_eb.c
@@ -36,7 +36,9 @@
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 #include <asm/mach/mmc.h>
+#include <asm/mach/time.h>
 
+#include <asm/arch/board-eb.h>
 #include <asm/arch/irqs.h>
 
 #include "core.h"
@@ -58,26 +60,7 @@ static struct map_desc realview_eb_io_desc[] __initdata = {
                 .pfn            = __phys_to_pfn(REALVIEW_GIC_DIST_BASE),
                 .length         = SZ_4K,
                 .type           = MT_DEVICE,
-        },
-#ifdef CONFIG_REALVIEW_MPCORE
-        {
-                .virtual        = IO_ADDRESS(REALVIEW_GIC1_CPU_BASE),
-                .pfn            = __phys_to_pfn(REALVIEW_GIC1_CPU_BASE),
-                .length         = SZ_4K,
-                .type           = MT_DEVICE,
         }, {
-                .virtual        = IO_ADDRESS(REALVIEW_GIC1_DIST_BASE),
-                .pfn            = __phys_to_pfn(REALVIEW_GIC1_DIST_BASE),
-                .length         = SZ_4K,
-                .type           = MT_DEVICE,
-        }, {
-                .virtual        = IO_ADDRESS(REALVIEW_MPCORE_L220_BASE),
-                .pfn            = __phys_to_pfn(REALVIEW_MPCORE_L220_BASE),
-                .length         = SZ_8K,
-                .type           = MT_DEVICE,
-        },
-#endif
-        {
                 .virtual        = IO_ADDRESS(REALVIEW_SCTL_BASE),
                 .pfn            = __phys_to_pfn(REALVIEW_SCTL_BASE),
                 .length         = SZ_4K,
@@ -103,11 +86,95 @@ static struct map_desc realview_eb_io_desc[] __initdata = {
 #endif
 };
 
+static struct map_desc realview_eb11mp_io_desc[] __initdata = {
+        {
+                .virtual        = IO_ADDRESS(REALVIEW_EB11MP_GIC_CPU_BASE),
+                .pfn            = __phys_to_pfn(REALVIEW_EB11MP_GIC_CPU_BASE),
+                .length         = SZ_4K,
+                .type           = MT_DEVICE,
+        }, {
+                .virtual        = IO_ADDRESS(REALVIEW_EB11MP_GIC_DIST_BASE),
+                .pfn            = __phys_to_pfn(REALVIEW_EB11MP_GIC_DIST_BASE),
+                .length         = SZ_4K,
+                .type           = MT_DEVICE,
+        }, {
+                .virtual        = IO_ADDRESS(REALVIEW_EB11MP_L220_BASE),
+                .pfn            = __phys_to_pfn(REALVIEW_EB11MP_L220_BASE),
+                .length         = SZ_8K,
+                .type           = MT_DEVICE,
+        }
+};
+
 static void __init realview_eb_map_io(void)
 {
         iotable_init(realview_eb_io_desc, ARRAY_SIZE(realview_eb_io_desc));
+        if (core_tile_eb11mp())
+                iotable_init(realview_eb11mp_io_desc, ARRAY_SIZE(realview_eb11mp_io_desc));
 }
 
+/*
+ * RealView EB AMBA devices
+ */
+
+/*
+ * These devices are connected via the core APB bridge
+ */
+#define GPIO2_IRQ       { IRQ_EB_GPIO2, NO_IRQ }
+#define GPIO2_DMA       { 0, 0 }
+#define GPIO3_IRQ       { IRQ_EB_GPIO3, NO_IRQ }
+#define GPIO3_DMA       { 0, 0 }
+
+#define AACI_IRQ        { IRQ_EB_AACI, NO_IRQ }
+#define AACI_DMA        { 0x80, 0x81 }
+#define MMCI0_IRQ       { IRQ_EB_MMCI0A, IRQ_EB_MMCI0B }
+#define MMCI0_DMA       { 0x84, 0 }
+#define KMI0_IRQ        { IRQ_EB_KMI0, NO_IRQ }
+#define KMI0_DMA        { 0, 0 }
+#define KMI1_IRQ        { IRQ_EB_KMI1, NO_IRQ }
+#define KMI1_DMA        { 0, 0 }
+
+/*
+ * These devices are connected directly to the multi-layer AHB switch
+ */
+#define SMC_IRQ         { NO_IRQ, NO_IRQ }
+#define SMC_DMA         { 0, 0 }
+#define MPMC_IRQ        { NO_IRQ, NO_IRQ }
+#define MPMC_DMA        { 0, 0 }
+#define CLCD_IRQ        { IRQ_EB_CLCD, NO_IRQ }
+#define CLCD_DMA        { 0, 0 }
+#define DMAC_IRQ        { IRQ_EB_DMA, NO_IRQ }
+#define DMAC_DMA        { 0, 0 }
+
+/*
+ * These devices are connected via the core APB bridge
+ */
+#define SCTL_IRQ        { NO_IRQ, NO_IRQ }
+#define SCTL_DMA        { 0, 0 }
+#define WATCHDOG_IRQ    { IRQ_EB_WDOG, NO_IRQ }
+#define WATCHDOG_DMA    { 0, 0 }
+#define GPIO0_IRQ       { IRQ_EB_GPIO0, NO_IRQ }
+#define GPIO0_DMA       { 0, 0 }
+#define GPIO1_IRQ       { IRQ_EB_GPIO1, NO_IRQ }
+#define GPIO1_DMA       { 0, 0 }
+#define RTC_IRQ         { IRQ_EB_RTC, NO_IRQ }
+#define RTC_DMA         { 0, 0 }
+
+/*
+ * These devices are connected via the DMA APB bridge
+ */
+#define SCI_IRQ         { IRQ_EB_SCI, NO_IRQ }
+#define SCI_DMA         { 7, 6 }
+#define UART0_IRQ       { IRQ_EB_UART0, NO_IRQ }
+#define UART0_DMA       { 15, 14 }
+#define UART1_IRQ       { IRQ_EB_UART1, NO_IRQ }
+#define UART1_DMA       { 13, 12 }
+#define UART2_IRQ       { IRQ_EB_UART2, NO_IRQ }
+#define UART2_DMA       { 11, 10 }
+#define UART3_IRQ       { IRQ_EB_UART3, NO_IRQ }
+#define UART3_DMA       { 0x86, 0x87 }
+#define SSP_IRQ         { IRQ_EB_SSP, NO_IRQ }
+#define SSP_DMA         { 9, 8 }
+
 /* FPGA Primecells */
 AMBA_DEVICE(aaci,  "fpga:04", AACI,     NULL);
 AMBA_DEVICE(mmc0,  "fpga:05", MMCI0,    &realview_mmc0_plat_data);
@@ -153,38 +220,127 @@ static struct amba_device *amba_devs[] __initdata = {
         &kmi1_device,
 };
 
+/*
+ * RealView EB platform devices
+ */
+
+static struct resource realview_eb_smc91x_resources[] = {
+        [0] = {
+                .start          = REALVIEW_ETH_BASE,
+                .end            = REALVIEW_ETH_BASE + SZ_64K - 1,
+                .flags          = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start          = IRQ_EB_ETH,
+                .end            = IRQ_EB_ETH,
+                .flags          = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device realview_eb_smc91x_device = {
+        .name           = "smc91x",
+        .id             = 0,
+        .num_resources  = ARRAY_SIZE(realview_eb_smc91x_resources),
+        .resource       = realview_eb_smc91x_resources,
+};
+
 static void __init gic_init_irq(void)
 {
-#ifdef CONFIG_REALVIEW_MPCORE
-        unsigned int pldctrl;
-        writel(0x0000a05f, __io_address(REALVIEW_SYS_LOCK));
-        pldctrl = readl(__io_address(REALVIEW_SYS_BASE) + REALVIEW_MPCORE_SYS_PLD_CTRL1);
-        pldctrl |= 0x00800000;  /* New irq mode */
-        writel(pldctrl, __io_address(REALVIEW_SYS_BASE) + REALVIEW_MPCORE_SYS_PLD_CTRL1);
-        writel(0x00000000, __io_address(REALVIEW_SYS_LOCK));
+        if (core_tile_eb11mp()) {
+                unsigned int pldctrl;
+
+                /* new irq mode */
+                writel(0x0000a05f, __io_address(REALVIEW_SYS_LOCK));
+                pldctrl = readl(__io_address(REALVIEW_SYS_BASE) + REALVIEW_EB11MP_SYS_PLD_CTRL1);
+                pldctrl |= 0x00800000;
+                writel(pldctrl, __io_address(REALVIEW_SYS_BASE) + REALVIEW_EB11MP_SYS_PLD_CTRL1);
+                writel(0x00000000, __io_address(REALVIEW_SYS_LOCK));
+
+                /* core tile GIC, primary */
+                gic_cpu_base_addr = __io_address(REALVIEW_EB11MP_GIC_CPU_BASE);
+                gic_dist_init(0, __io_address(REALVIEW_EB11MP_GIC_DIST_BASE), 29);
+                gic_cpu_init(0, gic_cpu_base_addr);
+
+#ifndef CONFIG_REALVIEW_EB_ARM11MP_REVB
+                /* board GIC, secondary */
+                gic_dist_init(1, __io_address(REALVIEW_GIC_DIST_BASE), 64);
+                gic_cpu_init(1, __io_address(REALVIEW_GIC_CPU_BASE));
+                gic_cascade_irq(1, IRQ_EB11MP_EB_IRQ1);
 #endif
-        gic_dist_init(0, __io_address(REALVIEW_GIC_DIST_BASE), 29);
-        gic_cpu_init(0, __io_address(REALVIEW_GIC_CPU_BASE));
-#if defined(CONFIG_REALVIEW_MPCORE) && !defined(CONFIG_REALVIEW_MPCORE_REVB)
-        gic_dist_init(1, __io_address(REALVIEW_GIC1_DIST_BASE), 64);
-        gic_cpu_init(1, __io_address(REALVIEW_GIC1_CPU_BASE));
-        gic_cascade_irq(1, IRQ_EB_IRQ1);
+        } else {
+                /* board GIC, primary */
+                gic_cpu_base_addr = __io_address(REALVIEW_GIC_CPU_BASE);
+                gic_dist_init(0, __io_address(REALVIEW_GIC_DIST_BASE), 29);
+                gic_cpu_init(0, gic_cpu_base_addr);
+        }
+}
+
+/*
+ * Fix up the IRQ numbers for the RealView EB/ARM11MPCore tile
+ */
+static void realview_eb11mp_fixup(void)
+{
+        /* AMBA devices */
+        dmac_device.irq[0]      = IRQ_EB11MP_DMA;
+        uart0_device.irq[0]     = IRQ_EB11MP_UART0;
+        uart1_device.irq[0]     = IRQ_EB11MP_UART1;
+        uart2_device.irq[0]     = IRQ_EB11MP_UART2;
+        uart3_device.irq[0]     = IRQ_EB11MP_UART3;
+        clcd_device.irq[0]      = IRQ_EB11MP_CLCD;
+        wdog_device.irq[0]      = IRQ_EB11MP_WDOG;
+        gpio0_device.irq[0]     = IRQ_EB11MP_GPIO0;
+        gpio1_device.irq[0]     = IRQ_EB11MP_GPIO1;
+        gpio2_device.irq[0]     = IRQ_EB11MP_GPIO2;
+        rtc_device.irq[0]       = IRQ_EB11MP_RTC;
+        sci0_device.irq[0]      = IRQ_EB11MP_SCI;
+        ssp0_device.irq[0]      = IRQ_EB11MP_SSP;
+        aaci_device.irq[0]      = IRQ_EB11MP_AACI;
+        mmc0_device.irq[0]      = IRQ_EB11MP_MMCI0A;
+        mmc0_device.irq[1]      = IRQ_EB11MP_MMCI0B;
+        kmi0_device.irq[0]      = IRQ_EB11MP_KMI0;
+        kmi1_device.irq[0]      = IRQ_EB11MP_KMI1;
+
+        /* platform devices */
+        realview_eb_smc91x_resources[1].start   = IRQ_EB11MP_ETH;
+        realview_eb_smc91x_resources[1].end     = IRQ_EB11MP_ETH;
+}
+
+static void __init realview_eb_timer_init(void)
+{
+        unsigned int timer_irq;
+
+        if (core_tile_eb11mp()) {
+#ifdef CONFIG_LOCAL_TIMERS
+                twd_base_addr = __io_address(REALVIEW_EB11MP_TWD_BASE);
+                twd_size = REALVIEW_EB11MP_TWD_SIZE;
 #endif
+                timer_irq = IRQ_EB11MP_TIMER0_1;
+        } else
+                timer_irq = IRQ_EB_TIMER0_1;
+
+        realview_timer_init(timer_irq);
 }
 
+static struct sys_timer realview_eb_timer = {
+        .init           = realview_eb_timer_init,
+};
+
 static void __init realview_eb_init(void)
 {
         int i;
 
-#ifdef CONFIG_REALVIEW_MPCORE
-        /* 1MB (128KB/way), 8-way associativity, evmon/parity/share enabled
-         * Bits:  .... ...0 0111 1001 0000 .... .... .... */
-        l2x0_init(__io_address(REALVIEW_MPCORE_L220_BASE), 0x00790000, 0xfe000fff);
-#endif
+        if (core_tile_eb11mp()) {
+                realview_eb11mp_fixup();
+
+                /* 1MB (128KB/way), 8-way associativity, evmon/parity/share enabled
+                 * Bits:  .... ...0 0111 1001 0000 .... .... .... */
+                l2x0_init(__io_address(REALVIEW_EB11MP_L220_BASE), 0x00790000, 0xfe000fff);
+        }
+
         clk_register(&realview_clcd_clk);
 
         platform_device_register(&realview_flash_device);
-        platform_device_register(&realview_smc91x_device);
+        platform_device_register(&realview_eb_smc91x_device);
         platform_device_register(&realview_i2c_device);
 
         for (i = 0; i < ARRAY_SIZE(amba_devs); i++) {
@@ -204,6 +360,6 @@ MACHINE_START(REALVIEW_EB, "ARM-RealView EB")
         .boot_params    = 0x00000100,
         .map_io         = realview_eb_map_io,
         .init_irq       = gic_init_irq,
-        .timer          = &realview_timer,
+        .timer          = &realview_eb_timer,
         .init_machine   = realview_eb_init,
 MACHINE_END
diff --git a/arch/arm/mach-sa1100/collie_pm.c b/arch/arm/mach-sa1100/collie_pm.c
index 1e25b1d19fce..94620be7bfac 100644
--- a/arch/arm/mach-sa1100/collie_pm.c
+++ b/arch/arm/mach-sa1100/collie_pm.c
@@ -165,7 +165,7 @@ int collie_read_temp(void)
 
         ucb1x00_adc_enable(ucb);
         ucb1x00_io_write(ucb, COLLIE_TC35143_GPIO_TMP_ON, 0);
-        /* >1010 = battery removed, 460 = 22C ?, higer = lower temp ? */
+        /* >1010 = battery removed, 460 = 22C ?, higher = lower temp ? */
         voltage = ucb1x00_adc_read(ucb, UCB_ADC_INP_AD0, UCB_SYNC);
         ucb1x00_io_write(ucb, 0, COLLIE_TC35143_GPIO_TMP_ON);
         ucb1x00_adc_disable(ucb);
diff --git a/arch/arm/mach-sa1100/generic.c b/arch/arm/mach-sa1100/generic.c
index 9e13c8358ea7..5c84c604ed86 100644
--- a/arch/arm/mach-sa1100/generic.c
+++ b/arch/arm/mach-sa1100/generic.c
@@ -470,7 +470,7 @@ void __init sa1110_mb_disable(void)
  * If the system is going to use the SA-1111 DMA engines, set up
  * the memory bus request/grant pins.
  */
-void __init sa1110_mb_enable(void)
+void __devinit sa1110_mb_enable(void)
 {
         unsigned long flags;
 
diff --git a/arch/arm/mm/ioremap.c b/arch/arm/mm/ioremap.c
index 75952779ce19..303a7ff6bfd2 100644
--- a/arch/arm/mm/ioremap.c
+++ b/arch/arm/mm/ioremap.c
@@ -162,7 +162,7 @@ static void unmap_area_sections(unsigned long virt, unsigned long size)
                          * Free the page table, if there was one.
                          */
                         if ((pmd_val(pmd) & PMD_TYPE_MASK) == PMD_TYPE_TABLE)
-                                pte_free_kernel(pmd_page_vaddr(pmd));
+                                pte_free_kernel(&init_mm, pmd_page_vaddr(pmd));
                 }
 
                 addr += PGDIR_SIZE;
diff --git a/arch/arm/mm/pgd.c b/arch/arm/mm/pgd.c
index 50b9aed6000d..500c9610ab30 100644
--- a/arch/arm/mm/pgd.c
+++ b/arch/arm/mm/pgd.c
@@ -65,14 +65,14 @@ pgd_t *get_pgd_slow(struct mm_struct *mm)
         return new_pgd;
 
 no_pte:
-        pmd_free(new_pmd);
+        pmd_free(mm, new_pmd);
 no_pmd:
         free_pages((unsigned long)new_pgd, 2);
 no_pgd:
         return NULL;
 }
 
-void free_pgd_slow(pgd_t *pgd)
+void free_pgd_slow(struct mm_struct *mm, pgd_t *pgd)
 {
         pmd_t *pmd;
         struct page *pte;
@@ -94,8 +94,8 @@ void free_pgd_slow(pgd_t *pgd)
         pmd_clear(pmd);
         dec_zone_page_state(virt_to_page((unsigned long *)pgd), NR_PAGETABLE);
         pte_lock_deinit(pte);
-        pte_free(pte);
-        pmd_free(pmd);
+        pte_free(mm, pte);
+        pmd_free(mm, pmd);
 free:
         free_pages((unsigned long) pgd, 2);
 }
diff --git a/arch/arm/plat-iop/time.c b/arch/arm/plat-iop/time.c
index ba3d21d8fba3..6fe481ff4fdf 100644
--- a/arch/arm/plat-iop/time.c
+++ b/arch/arm/plat-iop/time.c
@@ -57,8 +57,6 @@ unsigned long iop_gettimeoffset(void)
 static irqreturn_t
 iop_timer_interrupt(int irq, void *dev_id)
 {
-        write_seqlock(&xtime_lock);
-
         write_tisr(1);
 
         while ((signed long)(next_jiffy_time - read_tcr1())
@@ -67,8 +65,6 @@ iop_timer_interrupt(int irq, void *dev_id)
                 next_jiffy_time -= ticks_per_jiffy;
         }
 
-        write_sequnlock(&xtime_lock);
-
         return IRQ_HANDLED;
 }
 
diff --git a/arch/arm/plat-s3c24xx/irq.c b/arch/arm/plat-s3c24xx/irq.c
index d486f5112569..ae2c5d7efc9d 100644
--- a/arch/arm/plat-s3c24xx/irq.c
+++ b/arch/arm/plat-s3c24xx/irq.c
@@ -47,7 +47,7 @@
  *                Mark IRQ_LCD valid
  *
  *   25-Jul-2005  Ben Dooks
- *                Split the S3C2440 IRQ code to seperate file
+ *                Split the S3C2440 IRQ code to separate file
 */
 
 #include <linux/init.h>
diff --git a/arch/arm/plat-s3c24xx/time.c b/arch/arm/plat-s3c24xx/time.c
index 2ec1daaa0e53..766473b3f98b 100644
--- a/arch/arm/plat-s3c24xx/time.c
+++ b/arch/arm/plat-s3c24xx/time.c
@@ -130,9 +130,7 @@ static unsigned long s3c2410_gettimeoffset (void)
 static irqreturn_t
 s3c2410_timer_interrupt(int irq, void *dev_id)
 {
-        write_seqlock(&xtime_lock);
         timer_tick();
-        write_sequnlock(&xtime_lock);
         return IRQ_HANDLED;
 }
 
diff --git a/arch/avr32/Kconfig b/arch/avr32/Kconfig
index e34e2c9c94cb..28e0caf4156c 100644
--- a/arch/avr32/Kconfig
+++ b/arch/avr32/Kconfig
@@ -10,6 +10,8 @@ config AVR32
         # With EMBEDDED=n, we get lots of stuff automatically selected
         # that we usually don't need on AVR32.
         select EMBEDDED
+        select HAVE_OPROFILE
+        select HAVE_KPROBES
         help
           AVR32 is a high-performance 32-bit RISC microprocessor core,
           designed for cost-sensitive embedded applications, with particular
@@ -54,9 +56,6 @@ config ARCH_HAS_ILOG2_U32
 config ARCH_HAS_ILOG2_U64
         def_bool n
 
-config ARCH_SUPPORTS_OPROFILE
-        def_bool y
-
 config GENERIC_HWEIGHT
         def_bool y
 
@@ -83,6 +82,7 @@ config PLATFORM_AT32AP
         select SUBARCH_AVR32B
         select MMU
         select PERFORMANCE_COUNTERS
+        select HAVE_GPIO_LIB
 
 #
 # CPU types
@@ -236,8 +236,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/avr32/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/avr32/kernel/syscall_table.S b/arch/avr32/kernel/syscall_table.S
index 75c81f2dd0b3..478bda4c4a09 100644
--- a/arch/avr32/kernel/syscall_table.S
+++ b/arch/avr32/kernel/syscall_table.S
@@ -293,6 +293,6 @@ sys_call_table:
         .long   sys_shmctl
         .long   sys_utimensat
         .long   sys_signalfd
-        .long   sys_timerfd             /* 280 */
+        .long   sys_ni_syscall          /* 280, was sys_timerfd */
         .long   sys_eventfd
         .long   sys_ni_syscall          /* r8 is saturated at nr_syscalls */
diff --git a/arch/avr32/mach-at32ap/pio.c b/arch/avr32/mach-at32ap/pio.c
index d61a02da898c..38a8fa31c0b5 100644
--- a/arch/avr32/mach-at32ap/pio.c
+++ b/arch/avr32/mach-at32ap/pio.c
@@ -24,11 +24,11 @@
 #define MAX_NR_PIO_DEVICES              8
 
 struct pio_device {
+        struct gpio_chip chip;
         void __iomem *regs;
         const struct platform_device *pdev;
         struct clk *clk;
         u32 pinmux_mask;
-        u32 gpio_mask;
         char name[8];
 };
 
@@ -64,7 +64,8 @@ void __init at32_select_periph(unsigned int pin, unsigned int periph,
                 goto fail;
         }
 
-        if (unlikely(test_and_set_bit(pin_index, &pio->pinmux_mask))) {
+        if (unlikely(test_and_set_bit(pin_index, &pio->pinmux_mask)
+                         || gpiochip_is_requested(&pio->chip, pin_index))) {
                 printk("%s: pin %u is busy\n", pio->name, pin_index);
                 goto fail;
         }
@@ -79,9 +80,6 @@ void __init at32_select_periph(unsigned int pin, unsigned int periph,
         if (!(flags & AT32_GPIOF_PULLUP))
                 pio_writel(pio, PUDR, mask);
 
-        /* gpio_request NOT allowed */
-        set_bit(pin_index, &pio->gpio_mask);
-
         return;
 
 fail:
@@ -130,9 +128,6 @@ void __init at32_select_gpio(unsigned int pin, unsigned long flags)
 
         pio_writel(pio, PER, mask);
 
-        /* gpio_request now allowed */
-        clear_bit(pin_index, &pio->gpio_mask);
-
         return;
 
 fail:
@@ -166,96 +161,50 @@ fail:
 
 /* GPIO API */
 
-int gpio_request(unsigned int gpio, const char *label)
+static int direction_input(struct gpio_chip *chip, unsigned offset)
 {
-        struct pio_device *pio;
-        unsigned int pin;
-
-        pio = gpio_to_pio(gpio);
-        if (!pio)
-                return -ENODEV;
+        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        u32 mask = 1 << offset;
 
-        pin = gpio & 0x1f;
-        if (test_and_set_bit(pin, &pio->gpio_mask))
-                return -EBUSY;
+        if (!(pio_readl(pio, PSR) & mask))
+                return -EINVAL;
 
+        pio_writel(pio, ODR, mask);
         return 0;
 }
-EXPORT_SYMBOL(gpio_request);
 
-void gpio_free(unsigned int gpio)
+static int gpio_get(struct gpio_chip *chip, unsigned offset)
 {
-        struct pio_device *pio;
-        unsigned int pin;
+        struct pio_device *pio = container_of(chip, struct pio_device, chip);
 
-        pio = gpio_to_pio(gpio);
-        if (!pio) {
-                printk(KERN_ERR
-                       "gpio: attempted to free invalid pin %u\n", gpio);
-                return;
-        }
-
-        pin = gpio & 0x1f;
-        if (!test_and_clear_bit(pin, &pio->gpio_mask))
-                printk(KERN_ERR "gpio: freeing free or non-gpio pin %s-%u\n",
-                       pio->name, pin);
+        return (pio_readl(pio, PDSR) >> offset) & 1;
 }
-EXPORT_SYMBOL(gpio_free);
 
-int gpio_direction_input(unsigned int gpio)
-{
-        struct pio_device *pio;
-        unsigned int pin;
-
-        pio = gpio_to_pio(gpio);
-        if (!pio)
-                return -ENODEV;
-
-        pin = gpio & 0x1f;
-        pio_writel(pio, ODR, 1 << pin);
-
-        return 0;
-}
-EXPORT_SYMBOL(gpio_direction_input);
+static void gpio_set(struct gpio_chip *chip, unsigned offset, int value);
 
-int gpio_direction_output(unsigned int gpio, int value)
+static int direction_output(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct pio_device *pio;
-        unsigned int pin;
-
-        pio = gpio_to_pio(gpio);
-        if (!pio)
-                return -ENODEV;
+        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        u32 mask = 1 << offset;
 
-        gpio_set_value(gpio, value);
-
-        pin = gpio & 0x1f;
-        pio_writel(pio, OER, 1 << pin);
+        if (!(pio_readl(pio, PSR) & mask))
+                return -EINVAL;
 
+        gpio_set(chip, offset, value);
+        pio_writel(pio, OER, mask);
         return 0;
 }
-EXPORT_SYMBOL(gpio_direction_output);
 
-int gpio_get_value(unsigned int gpio)
+static void gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 {
-        struct pio_device *pio = &pio_dev[gpio >> 5];
+        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        u32 mask = 1 << offset;
 
-        return (pio_readl(pio, PDSR) >> (gpio & 0x1f)) & 1;
-}
-EXPORT_SYMBOL(gpio_get_value);
-
-void gpio_set_value(unsigned int gpio, int value)
-{
-        struct pio_device *pio = &pio_dev[gpio >> 5];
-        u32 mask;
-
-        mask = 1 << (gpio & 0x1f);
         if (value)
                 pio_writel(pio, SODR, mask);
         else
                 pio_writel(pio, CODR, mask);
 }
-EXPORT_SYMBOL(gpio_set_value);
 
 /*--------------------------------------------------------------------------*/
 
@@ -339,6 +288,63 @@ gpio_irq_setup(struct pio_device *pio, int irq, int gpio_irq)
 
 /*--------------------------------------------------------------------------*/
 
+#ifdef CONFIG_DEBUG_FS
+
+#include <linux/seq_file.h>
+
+/*
+ * This shows more info than the generic gpio dump code:
+ * pullups, deglitching, open drain drive.
+ */
+static void pio_bank_show(struct seq_file *s, struct gpio_chip *chip)
+{
+        struct pio_device *pio = container_of(chip, struct pio_device, chip);
+        u32                     psr, osr, imr, pdsr, pusr, ifsr, mdsr;
+        unsigned                i;
+        u32                     mask;
+        char                    bank;
+
+        psr = pio_readl(pio, PSR);
+        osr = pio_readl(pio, OSR);
+        imr = pio_readl(pio, IMR);
+        pdsr = pio_readl(pio, PDSR);
+        pusr = pio_readl(pio, PUSR);
+        ifsr = pio_readl(pio, IFSR);
+        mdsr = pio_readl(pio, MDSR);
+
+        bank = 'A' + pio->pdev->id;
+
+        for (i = 0, mask = 1; i < 32; i++, mask <<= 1) {
+                const char *label;
+
+                label = gpiochip_is_requested(chip, i);
+                if (!label)
+                        continue;
+
+                seq_printf(s, " gpio-%-3d P%c%-2d (%-12s) %s %s %s",
+                        chip->base + i, bank, i,
+                        label,
+                        (osr & mask) ? "out" : "in ",
+                        (mask & pdsr) ? "hi" : "lo",
+                        (mask & pusr) ? "  " : "up");
+                if (ifsr & mask)
+                        seq_printf(s, " deglitch");
+                if ((osr & mdsr) & mask)
+                        seq_printf(s, " open-drain");
+                if (imr & mask)
+                        seq_printf(s, " irq-%d edge-both",
+                                gpio_to_irq(chip->base + i));
+                seq_printf(s, "\n");
+        }
+}
+
+#else
+#define pio_bank_show   NULL
+#endif
+
+
+/*--------------------------------------------------------------------------*/
+
 static int __init pio_probe(struct platform_device *pdev)
 {
         struct pio_device *pio = NULL;
@@ -349,6 +355,18 @@ static int __init pio_probe(struct platform_device *pdev)
         pio = &pio_dev[pdev->id];
         BUG_ON(!pio->regs);
 
+        pio->chip.label = pio->name;
+        pio->chip.base = pdev->id * 32;
+        pio->chip.ngpio = 32;
+
+        pio->chip.direction_input = direction_input;
+        pio->chip.get = gpio_get;
+        pio->chip.direction_output = direction_output;
+        pio->chip.set = gpio_set;
+        pio->chip.dbg_show = pio_bank_show;
+
+        gpiochip_add(&pio->chip);
+
         gpio_irq_setup(pio, irq, gpio_irq_base);
 
         platform_set_drvdata(pdev, pio);
@@ -406,12 +424,6 @@ void __init at32_init_pio(struct platform_device *pdev)
         pio->pdev = pdev;
         pio->regs = ioremap(regs->start, regs->end - regs->start + 1);
 
-        /*
-         * request_gpio() is only valid for pins that have been
-         * explicitly configured as GPIO and not previously requested
-         */
-        pio->gpio_mask = ~0UL;
-
         /* start with irqs disabled and acked */
         pio_writel(pio, IDR, ~0UL);
         (void) pio_readl(pio, ISR);
diff --git a/arch/avr32/mach-at32ap/pio.h b/arch/avr32/mach-at32ap/pio.h
index 50fa3aca32c5..7795116a483a 100644
--- a/arch/avr32/mach-at32ap/pio.h
+++ b/arch/avr32/mach-at32ap/pio.h
@@ -19,7 +19,7 @@
 #define PIO_OSR                                0x0018
 #define PIO_IFER                               0x0020
 #define PIO_IFDR                               0x0024
-#define PIO_ISFR                               0x0028
+#define PIO_IFSR                               0x0028
 #define PIO_SODR                               0x0030
 #define PIO_CODR                               0x0034
 #define PIO_ODSR                               0x0038
diff --git a/arch/blackfin/Kconfig b/arch/blackfin/Kconfig
index fc7ca86ac8bf..ba21e33b8b1f 100644
--- a/arch/blackfin/Kconfig
+++ b/arch/blackfin/Kconfig
@@ -24,6 +24,7 @@ config RWSEM_XCHGADD_ALGORITHM
 config BLACKFIN
         bool
         default y
+        select HAVE_OPROFILE
 
 config ZONE_DMA
         bool
@@ -898,6 +899,10 @@ endmenu
 menu "Power management options"
 source "kernel/power/Kconfig"
 
+config ARCH_SUSPEND_POSSIBLE
+        def_bool y
+        depends on !SMP
+
 choice
         prompt "Select PM Wakeup Event Source"
         default PM_WAKEUP_GPIO_BY_SIC_IWR
@@ -969,8 +974,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/blackfin/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/blackfin/mach-common/entry.S b/arch/blackfin/mach-common/entry.S
index 56ff51bc8c21..fdd9bf43361e 100644
--- a/arch/blackfin/mach-common/entry.S
+++ b/arch/blackfin/mach-common/entry.S
@@ -1373,7 +1373,7 @@ ENTRY(_sys_call_table)
         .long _sys_epoll_pwait
         .long _sys_utimensat
         .long _sys_signalfd
-        .long _sys_timerfd
+        .long _sys_ni_syscall
         .long _sys_eventfd      /* 350 */
         .long _sys_pread64
         .long _sys_pwrite64
diff --git a/arch/cris/Kconfig b/arch/cris/Kconfig
index 222da1501f47..27b082ac7f11 100644
--- a/arch/cris/Kconfig
+++ b/arch/cris/Kconfig
@@ -150,6 +150,7 @@ config ETRAX_FLASH_BUSWIDTH
           Width in bytes of the Flash bus (1, 2 or 4). Is usually 2.
 
 source arch/cris/arch-v10/Kconfig
+source arch/cris/arch-v32/Kconfig
 
 endmenu
 
@@ -157,8 +158,8 @@ source "net/Kconfig"
 
 # bring in ETRAX built-in drivers
 menu "Drivers for built-in interfaces"
-# arch/cris/arch is a symlink to correct arch (arch-v10 or arch-v32)
-source arch/cris/arch/drivers/Kconfig
+source arch/cris/arch-v10/drivers/Kconfig
+source arch/cris/arch-v32/drivers/Kconfig
 
 endmenu
 
@@ -213,8 +214,6 @@ source "drivers/pci/Kconfig"
 
 source "drivers/usb/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/cris/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/cris/arch-v10/Kconfig b/arch/cris/arch-v10/Kconfig
index f1ce6f64401d..1d61faec77cd 100644
--- a/arch/cris/arch-v10/Kconfig
+++ b/arch/cris/arch-v10/Kconfig
@@ -1,3 +1,5 @@
+if ETRAX_ARCH_V10
+
 # ETRAX 100LX v1 has a MMU "feature" requiring a low mapping
 config CRIS_LOW_MAP
         bool
@@ -451,3 +453,5 @@ config ETRAX_POWERBUTTON_BIT
         default "25"
         help
           Configure where power button is connected.
+
+endif
diff --git a/arch/cris/arch-v10/drivers/Kconfig b/arch/cris/arch-v10/drivers/Kconfig
index e3c0f2928149..96740ef497d4 100644
--- a/arch/cris/arch-v10/drivers/Kconfig
+++ b/arch/cris/arch-v10/drivers/Kconfig
@@ -1,3 +1,5 @@
+if ETRAX_ARCH_V10
+
 config ETRAX_ETHERNET
         bool "Ethernet support"
         depends on ETRAX_ARCH_V10
@@ -806,3 +808,5 @@ config ETRAX_DS1302_TRICKLE_CHARGE
           1 = 2kohm, 2 = 4kohm, 3 = 4kohm
           4 = 1 diode, 8 = 2 diodes
           Allowed values are (increasing current): 0, 11, 10, 9, 7, 6, 5
+
+endif
diff --git a/arch/cris/arch-v10/kernel/entry.S b/arch/cris/arch-v10/kernel/entry.S
index ec62c951fa3c..d1361dc119e2 100644
--- a/arch/cris/arch-v10/kernel/entry.S
+++ b/arch/cris/arch-v10/kernel/entry.S
@@ -1167,7 +1167,7 @@ sys_call_table:
         .long sys_epoll_pwait
         .long sys_utimensat             /* 320 */
         .long sys_signalfd
-        .long sys_timerfd
+        .long sys_ni_syscall
         .long sys_eventfd
         .long sys_fallocate
 
diff --git a/arch/cris/arch-v32/Kconfig b/arch/cris/arch-v32/Kconfig
index 4f79d8ed3e1c..d8acaa920e1c 100644
--- a/arch/cris/arch-v32/Kconfig
+++ b/arch/cris/arch-v32/Kconfig
@@ -1,3 +1,5 @@
+if ETRAX_ARCH_V32
+
 config ETRAX_DRAM_VIRTUAL_BASE
         hex
         depends on ETRAX_ARCH_V32
@@ -294,3 +296,5 @@ config ETRAX_DEF_GIO_PE_OUT
         help
           Configures the initial data for the general port E bits.  Most
           products should use 00000 here.
+
+endif
diff --git a/arch/cris/arch-v32/drivers/Kconfig b/arch/cris/arch-v32/drivers/Kconfig
index 9bccb5e2a960..c329cce2a0c3 100644
--- a/arch/cris/arch-v32/drivers/Kconfig
+++ b/arch/cris/arch-v32/drivers/Kconfig
@@ -1,3 +1,5 @@
+if ETRAX_ARCH_V32
+
 config ETRAX_ETHERNET
         bool "Ethernet support"
         depends on ETRAX_ARCH_V32
@@ -610,3 +612,5 @@ config ETRAX_STREAMCOPROC
         help
           This option enables a driver for the stream co-processor
           for cryptographic operations.
+
+endif
diff --git a/arch/cris/arch-v32/drivers/pci/dma.c b/arch/cris/arch-v32/drivers/pci/dma.c
index 66f9500fbc02..e0364654fc44 100644
--- a/arch/cris/arch-v32/drivers/pci/dma.c
+++ b/arch/cris/arch-v32/drivers/pci/dma.c
@@ -93,7 +93,7 @@ int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
 
         dev->dma_mem = kzalloc(sizeof(struct dma_coherent_mem), GFP_KERNEL);
         if (!dev->dma_mem)
-                goto out;
+                goto iounmap_out;
         dev->dma_mem->bitmap = kzalloc(bitmap_size, GFP_KERNEL);
         if (!dev->dma_mem->bitmap)
                 goto free1_out;
@@ -110,6 +110,8 @@ int dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
 
  free1_out:
         kfree(dev->dma_mem);
+ iounmap_out:
+        iounmap(mem_base);
  out:
         return 0;
 }
diff --git a/arch/frv/Kconfig b/arch/frv/Kconfig
index 43153e767bb1..96f7d70f4473 100644
--- a/arch/frv/Kconfig
+++ b/arch/frv/Kconfig
@@ -79,7 +79,7 @@ config FRV_OUTOFLINE_ATOMIC_OPS
           Setting this option causes the FR-V atomic operations to be mostly
           implemented out-of-line.
 
-          See Documentation/fujitsu/frv/atomic-ops.txt for more information.
+          See Documentation/frv/atomic-ops.txt for more information.
 
 config HIGHMEM
         bool "High memory support"
@@ -138,6 +138,15 @@ config UCPAGE_OFFSET_C0000000
 
 endchoice
 
+config PAGE_OFFSET
+        hex
+        default 0x20000000 if UCPAGE_OFFSET_20000000
+        default 0x40000000 if UCPAGE_OFFSET_40000000
+        default 0x60000000 if UCPAGE_OFFSET_60000000
+        default 0x80000000 if UCPAGE_OFFSET_80000000
+        default 0xA0000000 if UCPAGE_OFFSET_A0000000
+        default 0xC0000000
+
 config PROTECT_KERNEL
         bool "Protect core kernel against userspace"
         depends on !MMU
@@ -322,11 +331,6 @@ config PCI
           onboard. If you have one of these boards and you wish to use the PCI
           facilities, say Y here.
 
-          The PCI-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 config RESERVE_DMA_COHERENT
         bool "Reserve DMA coherent memory"
         depends on PCI && !MMU
@@ -357,6 +361,11 @@ source "drivers/pcmcia/Kconfig"
 #         should probably wait a while.
 
 menu "Power management options"
+
+config ARCH_SUSPEND_POSSIBLE
+        def_bool y
+        depends on !SMP
+
 source kernel/power/Kconfig
 endmenu
 
@@ -375,8 +384,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/frv/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/frv/kernel/entry.S b/arch/frv/kernel/entry.S
index f926c7094776..ca6a345b87e4 100644
--- a/arch/frv/kernel/entry.S
+++ b/arch/frv/kernel/entry.S
@@ -253,7 +253,7 @@ __entry_kernel_external_interrupt_reentry:
         andi.p          gr5,#~PSR_ET,gr5
 
         # set CCCR.CC3 to Undefined to abort atomic-modify completion inside the kernel
-        # - for an explanation of how it works, see: Documentation/fujitsu/frv/atomic-ops.txt
+        # - for an explanation of how it works, see: Documentation/frv/atomic-ops.txt
         andi            gr25,#~0xc0,gr25
 
         sti             gr20,@(gr28,#REG_TBR)
@@ -445,7 +445,7 @@ __entry_kernel_softprog_interrupt_reentry:
         sti             gr22,@(sp,#REG_SP)
 
         # set CCCR.CC3 to Undefined to abort atomic-modify completion inside the kernel
-        # - for an explanation of how it works, see: Documentation/fujitsu/frv/atomic-ops.txt
+        # - for an explanation of how it works, see: Documentation/frv/atomic-ops.txt
         movsg           cccr,gr20
         andi            gr20,#~0xc0,gr20
         movgs           gr20,cccr
@@ -1494,7 +1494,7 @@ sys_call_table:
         .long sys_epoll_pwait
         .long sys_utimensat             /* 320 */
         .long sys_signalfd
-        .long sys_timerfd
+        .long sys_ni_syscall
         .long sys_eventfd
         .long sys_fallocate
 
diff --git a/arch/frv/kernel/vmlinux.lds.S b/arch/frv/kernel/vmlinux.lds.S
index f42b328b1dd0..ef7527b8b0c7 100644
--- a/arch/frv/kernel/vmlinux.lds.S
+++ b/arch/frv/kernel/vmlinux.lds.S
@@ -13,7 +13,7 @@ ENTRY(_start)
 
 jiffies = jiffies_64 + 4;
 
-__page_offset = 0xc0000000;             /* start of area covered by struct pages */
+__page_offset = CONFIG_PAGE_OFFSET;     /* start of area covered by struct pages */
 __kernel_image_start = __page_offset;   /* address at which kernel image resides */
 
 SECTIONS
diff --git a/arch/frv/lib/atomic-ops.S b/arch/frv/lib/atomic-ops.S
index 545cd325ac57..ee0ac905fb08 100644
--- a/arch/frv/lib/atomic-ops.S
+++ b/arch/frv/lib/atomic-ops.S
@@ -1,7 +1,7 @@
 /* atomic-ops.S: kernel atomic operations
  *
  * For an explanation of how atomic ops work in this arch, see:
- *   Documentation/fujitsu/frv/atomic-ops.txt
+ *   Documentation/frv/atomic-ops.txt
  *
  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
diff --git a/arch/frv/mm/mmu-context.c b/arch/frv/mm/mmu-context.c
index 1530a4111e6d..81757d55a5b5 100644
--- a/arch/frv/mm/mmu-context.c
+++ b/arch/frv/mm/mmu-context.c
@@ -181,7 +181,7 @@ int cxn_pin_by_pid(pid_t pid)
 
         /* get a handle on the mm_struct */
         read_lock(&tasklist_lock);
-        tsk = find_task_by_pid(pid);
+        tsk = find_task_by_vpid(pid);
         if (tsk) {
                 ret = -EINVAL;
 
diff --git a/arch/frv/mm/pgalloc.c b/arch/frv/mm/pgalloc.c
index 7787c3cc52c6..1a2e5c8d03a9 100644
--- a/arch/frv/mm/pgalloc.c
+++ b/arch/frv/mm/pgalloc.c
@@ -140,7 +140,7 @@ pgd_t *pgd_alloc(struct mm_struct *mm)
         return pgd;
 }
 
-void pgd_free(pgd_t *pgd)
+void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 {
         /* in the non-PAE case, clear_page_tables() clears user pgd entries */
         quicklist_free(0, pgd_dtor, pgd);
diff --git a/arch/h8300/Kconfig b/arch/h8300/Kconfig
index ff6a8712bd6d..dc61222e1120 100644
--- a/arch/h8300/Kconfig
+++ b/arch/h8300/Kconfig
@@ -223,8 +223,6 @@ endmenu
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/h8300/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/h8300/platform/h8s/ints.c b/arch/h8300/platform/h8s/ints.c
index 551fd5f30d82..ac10b9783850 100644
--- a/arch/h8300/platform/h8s/ints.c
+++ b/arch/h8300/platform/h8s/ints.c
@@ -121,7 +121,7 @@ void __init init_IRQ(void)
                 printk("virtual vector at 0x%08lx\n",(unsigned long)ramvec);
 
 #if defined(CONFIG_GDB_DEBUG)
-        /* save orignal break vector */
+        /* save original break vector */
         break_vec = ramvec[TRAP3_VEC];
 #else
         break_vec = VECTOR(trace_break);
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index 5a41e75ae1fe..b0de1132dfc0 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -15,6 +15,8 @@ config IA64
         select ACPI if (!IA64_HP_SIM)
         select PM if (!IA64_HP_SIM)
         select ARCH_SUPPORTS_MSI
+        select HAVE_OPROFILE
+        select HAVE_KPROBES
         default y
         help
           The Itanium Processor Family is Intel's 64-bit successor to
@@ -80,7 +82,7 @@ config GENERIC_TIME_VSYSCALL
         bool
         default y
 
-config ARCH_SETS_UP_PER_CPU_AREA
+config HAVE_SETUP_PER_CPU_AREA
         def_bool y
 
 config DMI
@@ -283,8 +285,8 @@ config SMP
           single processor systems.  On a single processor system, the kernel
           will run faster if you say N here.
 
-          See also the <file:Documentation/smp.txt> and the SMP-HOWTO
-          available at <http://www.tldp.org/docs.html#howto>.
+          See also the SMP-HOWTO available at
+          <http://www.tldp.org/docs.html#howto>.
 
           If you don't know what to do here, say N.
 
@@ -600,8 +602,6 @@ config IRQ_PER_CPU
 
 source "arch/ia64/hp/sim/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/ia64/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/ia64/hp/common/sba_iommu.c b/arch/ia64/hp/common/sba_iommu.c
index 45bf04eb7d70..a94445422cc6 100644
--- a/arch/ia64/hp/common/sba_iommu.c
+++ b/arch/ia64/hp/common/sba_iommu.c
@@ -1265,7 +1265,7 @@ sba_fill_pdir(
  * the sglist do both.
  */
 static SBA_INLINE int
-sba_coalesce_chunks( struct ioc *ioc,
+sba_coalesce_chunks(struct ioc *ioc, struct device *dev,
         struct scatterlist *startsg,
         int nents)
 {
@@ -1275,6 +1275,7 @@ sba_coalesce_chunks( struct ioc *ioc,
         struct scatterlist *dma_sg;        /* next DMA stream head */
         unsigned long dma_offset, dma_len; /* start/len of DMA stream */
         int n_mappings = 0;
+        unsigned int max_seg_size = dma_get_max_seg_size(dev);
 
         while (nents > 0) {
                 unsigned long vaddr = (unsigned long) sba_sg_address(startsg);
@@ -1314,6 +1315,9 @@ sba_coalesce_chunks( struct ioc *ioc,
                             > DMA_CHUNK_SIZE)
                                 break;
 
+                        if (dma_len + startsg->length > max_seg_size)
+                                break;
+
                         /*
                         ** Then look for virtually contiguous blocks.
                         **
@@ -1441,7 +1445,7 @@ int sba_map_sg(struct device *dev, struct scatterlist *sglist, int nents, int di
         ** w/o this association, we wouldn't have coherent DMA!
         ** Access to the virtual address is what forces a two pass algorithm.
         */
-        coalesced = sba_coalesce_chunks(ioc, sglist, nents);
+        coalesced = sba_coalesce_chunks(ioc, dev, sglist, nents);
 
         /*
         ** Program the I/O Pdir
@@ -1871,7 +1875,7 @@ ioc_show(struct seq_file *s, void *v)
         return 0;
 }
 
-static struct seq_operations ioc_seq_ops = {
+static const struct seq_operations ioc_seq_ops = {
         .start = ioc_start,
         .next  = ioc_next,
         .stop  = ioc_stop,
diff --git a/arch/ia64/ia32/ia32_support.c b/arch/ia64/ia32/ia32_support.c
index d1d50cd1c38a..896b1ebbfb26 100644
--- a/arch/ia64/ia32/ia32_support.c
+++ b/arch/ia64/ia32/ia32_support.c
@@ -27,7 +27,7 @@
 
 #include "ia32priv.h"
 
-extern void die_if_kernel (char *str, struct pt_regs *regs, long err);
+extern int die_if_kernel (char *str, struct pt_regs *regs, long err);
 
 struct exec_domain ia32_exec_domain;
 struct page *ia32_shared_page[NR_CPUS];
@@ -217,7 +217,8 @@ ia32_bad_interrupt (unsigned long int_num, struct pt_regs *regs)
 {
         siginfo_t siginfo;
 
-        die_if_kernel("Bad IA-32 interrupt", regs, int_num);
+        if (die_if_kernel("Bad IA-32 interrupt", regs, int_num))
+                return;
 
         siginfo.si_signo = SIGTRAP;
         siginfo.si_errno = int_num;     /* XXX is it OK to abuse si_errno like this? */
diff --git a/arch/ia64/kernel/efi.c b/arch/ia64/kernel/efi.c
index 242d79341120..919070a9aed7 100644
--- a/arch/ia64/kernel/efi.c
+++ b/arch/ia64/kernel/efi.c
@@ -1,7 +1,8 @@
 /*
  * Extensible Firmware Interface
  *
- * Based on Extensible Firmware Interface Specification version 0.9 April 30, 1999
+ * Based on Extensible Firmware Interface Specification version 0.9
+ * April 30, 1999
  *
  * Copyright (C) 1999 VA Linux Systems
  * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
@@ -48,145 +49,157 @@ static unsigned long mem_limit = ~0UL, max_addr = ~0UL, min_addr = 0UL;
 
 #define efi_call_virt(f, args...)       (*(f))(args)
 
-#define STUB_GET_TIME(prefix, adjust_arg)                                                         \
-static efi_status_t                                                                               \
-prefix##_get_time (efi_time_t *tm, efi_time_cap_t *tc)                                            \
-{                                                                                                 \
-        struct ia64_fpreg fr[6];                                                                  \
-        efi_time_cap_t *atc = NULL;                                                               \
-        efi_status_t ret;                                                                         \
-                                                                                                  \
-        if (tc)                                                                                   \
-                atc = adjust_arg(tc);                                                             \
-        ia64_save_scratch_fpregs(fr);                                                             \
-        ret = efi_call_##prefix((efi_get_time_t *) __va(runtime->get_time), adjust_arg(tm), atc); \
-        ia64_load_scratch_fpregs(fr);                                                             \
-        return ret;                                                                               \
+#define STUB_GET_TIME(prefix, adjust_arg)                                      \
+static efi_status_t                                                            \
+prefix##_get_time (efi_time_t *tm, efi_time_cap_t *tc)                         \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        efi_time_cap_t *atc = NULL;                                            \
+        efi_status_t ret;                                                      \
+                                                                               \
+        if (tc)                                                                \
+                atc = adjust_arg(tc);                                          \
+        ia64_save_scratch_fpregs(fr);                                          \
+        ret = efi_call_##prefix((efi_get_time_t *) __va(runtime->get_time),    \
+                                adjust_arg(tm), atc);                          \
+        ia64_load_scratch_fpregs(fr);                                          \
+        return ret;                                                            \
 }
 
-#define STUB_SET_TIME(prefix, adjust_arg)                                                       \
-static efi_status_t                                                                             \
-prefix##_set_time (efi_time_t *tm)                                                              \
-{                                                                                               \
-        struct ia64_fpreg fr[6];                                                                \
-        efi_status_t ret;                                                                       \
-                                                                                                \
-        ia64_save_scratch_fpregs(fr);                                                           \
-        ret = efi_call_##prefix((efi_set_time_t *) __va(runtime->set_time), adjust_arg(tm));    \
-        ia64_load_scratch_fpregs(fr);                                                           \
-        return ret;                                                                             \
+#define STUB_SET_TIME(prefix, adjust_arg)                                      \
+static efi_status_t                                                            \
+prefix##_set_time (efi_time_t *tm)                                             \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        efi_status_t ret;                                                      \
+                                                                               \
+        ia64_save_scratch_fpregs(fr);                                          \
+        ret = efi_call_##prefix((efi_set_time_t *) __va(runtime->set_time),    \
+                                adjust_arg(tm));                               \
+        ia64_load_scratch_fpregs(fr);                                          \
+        return ret;                                                            \
 }
 
-#define STUB_GET_WAKEUP_TIME(prefix, adjust_arg)                                                \
-static efi_status_t                                                                             \
-prefix##_get_wakeup_time (efi_bool_t *enabled, efi_bool_t *pending, efi_time_t *tm)             \
-{                                                                                               \
-        struct ia64_fpreg fr[6];                                                                \
-        efi_status_t ret;                                                                       \
-                                                                                                \
-        ia64_save_scratch_fpregs(fr);                                                           \
-        ret = efi_call_##prefix((efi_get_wakeup_time_t *) __va(runtime->get_wakeup_time),       \
-                                adjust_arg(enabled), adjust_arg(pending), adjust_arg(tm));      \
-        ia64_load_scratch_fpregs(fr);                                                           \
-        return ret;                                                                             \
+#define STUB_GET_WAKEUP_TIME(prefix, adjust_arg)                               \
+static efi_status_t                                                            \
+prefix##_get_wakeup_time (efi_bool_t *enabled, efi_bool_t *pending,            \
+                          efi_time_t *tm)                                      \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        efi_status_t ret;                                                      \
+                                                                               \
+        ia64_save_scratch_fpregs(fr);                                          \
+        ret = efi_call_##prefix(                                               \
+                (efi_get_wakeup_time_t *) __va(runtime->get_wakeup_time),      \
+                adjust_arg(enabled), adjust_arg(pending), adjust_arg(tm));     \
+        ia64_load_scratch_fpregs(fr);                                          \
+        return ret;                                                            \
 }
 
-#define STUB_SET_WAKEUP_TIME(prefix, adjust_arg)                                                \
-static efi_status_t                                                                             \
-prefix##_set_wakeup_time (efi_bool_t enabled, efi_time_t *tm)                                   \
-{                                                                                               \
-        struct ia64_fpreg fr[6];                                                                \
-        efi_time_t *atm = NULL;                                                                 \
-        efi_status_t ret;                                                                       \
-                                                                                                \
-        if (tm)                                                                                 \
-                atm = adjust_arg(tm);                                                           \
-        ia64_save_scratch_fpregs(fr);                                                           \
-        ret = efi_call_##prefix((efi_set_wakeup_time_t *) __va(runtime->set_wakeup_time),       \
-                                enabled, atm);                                                  \
-        ia64_load_scratch_fpregs(fr);                                                           \
-        return ret;                                                                             \
+#define STUB_SET_WAKEUP_TIME(prefix, adjust_arg)                               \
+static efi_status_t                                                            \
+prefix##_set_wakeup_time (efi_bool_t enabled, efi_time_t *tm)                  \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        efi_time_t *atm = NULL;                                                \
+        efi_status_t ret;                                                      \
+                                                                               \
+        if (tm)                                                                \
+                atm = adjust_arg(tm);                                          \
+        ia64_save_scratch_fpregs(fr);                                          \
+        ret = efi_call_##prefix(                                               \
+                (efi_set_wakeup_time_t *) __va(runtime->set_wakeup_time),      \
+                enabled, atm);                                                 \
+        ia64_load_scratch_fpregs(fr);                                          \
+        return ret;                                                            \
 }
 
-#define STUB_GET_VARIABLE(prefix, adjust_arg)                                           \
-static efi_status_t                                                                     \
-prefix##_get_variable (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,               \
-                       unsigned long *data_size, void *data)                            \
-{                                                                                       \
-        struct ia64_fpreg fr[6];                                                        \
-        u32 *aattr = NULL;                                                                      \
-        efi_status_t ret;                                                               \
-                                                                                        \
-        if (attr)                                                                       \
-                aattr = adjust_arg(attr);                                               \
-        ia64_save_scratch_fpregs(fr);                                                   \
-        ret = efi_call_##prefix((efi_get_variable_t *) __va(runtime->get_variable),     \
-                                adjust_arg(name), adjust_arg(vendor), aattr,            \
-                                adjust_arg(data_size), adjust_arg(data));               \
-        ia64_load_scratch_fpregs(fr);                                                   \
-        return ret;                                                                     \
+#define STUB_GET_VARIABLE(prefix, adjust_arg)                                  \
+static efi_status_t                                                            \
+prefix##_get_variable (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,      \
+                       unsigned long *data_size, void *data)                   \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        u32 *aattr = NULL;                                                     \
+        efi_status_t ret;                                                      \
+                                                                               \
+        if (attr)                                                              \
+                aattr = adjust_arg(attr);                                      \
+        ia64_save_scratch_fpregs(fr);                                          \
+        ret = efi_call_##prefix(                                               \
+                (efi_get_variable_t *) __va(runtime->get_variable),            \
+                adjust_arg(name), adjust_arg(vendor), aattr,                   \
+                adjust_arg(data_size), adjust_arg(data));                      \
+        ia64_load_scratch_fpregs(fr);                                          \
+        return ret;                                                            \
 }
 
-#define STUB_GET_NEXT_VARIABLE(prefix, adjust_arg)                                              \
-static efi_status_t                                                                             \
-prefix##_get_next_variable (unsigned long *name_size, efi_char16_t *name, efi_guid_t *vendor)   \
-{                                                                                               \
-        struct ia64_fpreg fr[6];                                                                \
-        efi_status_t ret;                                                                       \
-                                                                                                \
-        ia64_save_scratch_fpregs(fr);                                                           \
-        ret = efi_call_##prefix((efi_get_next_variable_t *) __va(runtime->get_next_variable),   \
-                                adjust_arg(name_size), adjust_arg(name), adjust_arg(vendor));   \
-        ia64_load_scratch_fpregs(fr);                                                           \
-        return ret;                                                                             \
+#define STUB_GET_NEXT_VARIABLE(prefix, adjust_arg)                             \
+static efi_status_t                                                            \
+prefix##_get_next_variable (unsigned long *name_size, efi_char16_t *name,      \
+                            efi_guid_t *vendor)                                \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        efi_status_t ret;                                                      \
+                                                                               \
+        ia64_save_scratch_fpregs(fr);                                          \
+        ret = efi_call_##prefix(                                               \
+                (efi_get_next_variable_t *) __va(runtime->get_next_variable),  \
+                adjust_arg(name_size), adjust_arg(name), adjust_arg(vendor));  \
+        ia64_load_scratch_fpregs(fr);                                          \
+        return ret;                                                            \
 }
 
-#define STUB_SET_VARIABLE(prefix, adjust_arg)                                           \
-static efi_status_t                                                                     \
-prefix##_set_variable (efi_char16_t *name, efi_guid_t *vendor, unsigned long attr,      \
-                       unsigned long data_size, void *data)                             \
-{                                                                                       \
-        struct ia64_fpreg fr[6];                                                        \
-        efi_status_t ret;                                                               \
-                                                                                        \
-        ia64_save_scratch_fpregs(fr);                                                   \
-        ret = efi_call_##prefix((efi_set_variable_t *) __va(runtime->set_variable),     \
-                                adjust_arg(name), adjust_arg(vendor), attr, data_size,  \
-                                adjust_arg(data));                                      \
-        ia64_load_scratch_fpregs(fr);                                                   \
-        return ret;                                                                     \
+#define STUB_SET_VARIABLE(prefix, adjust_arg)                                  \
+static efi_status_t                                                            \
+prefix##_set_variable (efi_char16_t *name, efi_guid_t *vendor,                 \
+                       unsigned long attr, unsigned long data_size,            \
+                       void *data)                                             \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        efi_status_t ret;                                                      \
+                                                                               \
+        ia64_save_scratch_fpregs(fr);                                          \
+        ret = efi_call_##prefix(                                               \
+                (efi_set_variable_t *) __va(runtime->set_variable),            \
+                adjust_arg(name), adjust_arg(vendor), attr, data_size,         \
+                adjust_arg(data));                                             \
+        ia64_load_scratch_fpregs(fr);                                          \
+        return ret;                                                            \
 }
 
-#define STUB_GET_NEXT_HIGH_MONO_COUNT(prefix, adjust_arg)                                       \
-static efi_status_t                                                                             \
-prefix##_get_next_high_mono_count (u32 *count)                                                  \
-{                                                                                               \
-        struct ia64_fpreg fr[6];                                                                \
-        efi_status_t ret;                                                                       \
-                                                                                                \
-        ia64_save_scratch_fpregs(fr);                                                           \
-        ret = efi_call_##prefix((efi_get_next_high_mono_count_t *)                              \
-                                __va(runtime->get_next_high_mono_count), adjust_arg(count));    \
-        ia64_load_scratch_fpregs(fr);                                                           \
-        return ret;                                                                             \
+#define STUB_GET_NEXT_HIGH_MONO_COUNT(prefix, adjust_arg)                      \
+static efi_status_t                                                            \
+prefix##_get_next_high_mono_count (u32 *count)                                 \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        efi_status_t ret;                                                      \
+                                                                               \
+        ia64_save_scratch_fpregs(fr);                                          \
+        ret = efi_call_##prefix((efi_get_next_high_mono_count_t *)             \
+                                __va(runtime->get_next_high_mono_count),       \
+                                adjust_arg(count));                            \
+        ia64_load_scratch_fpregs(fr);                                          \
+        return ret;                                                            \
 }
 
-#define STUB_RESET_SYSTEM(prefix, adjust_arg)                                   \
-static void                                                                     \
-prefix##_reset_system (int reset_type, efi_status_t status,                     \
-                       unsigned long data_size, efi_char16_t *data)             \
-{                                                                               \
-        struct ia64_fpreg fr[6];                                                \
-        efi_char16_t *adata = NULL;                                             \
-                                                                                \
-        if (data)                                                               \
-                adata = adjust_arg(data);                                       \
-                                                                                \
-        ia64_save_scratch_fpregs(fr);                                           \
-        efi_call_##prefix((efi_reset_system_t *) __va(runtime->reset_system),   \
-                          reset_type, status, data_size, adata);                \
-        /* should not return, but just in case... */                            \
-        ia64_load_scratch_fpregs(fr);                                           \
+#define STUB_RESET_SYSTEM(prefix, adjust_arg)                                  \
+static void                                                                    \
+prefix##_reset_system (int reset_type, efi_status_t status,                    \
+                       unsigned long data_size, efi_char16_t *data)            \
+{                                                                              \
+        struct ia64_fpreg fr[6];                                               \
+        efi_char16_t *adata = NULL;                                            \
+                                                                               \
+        if (data)                                                              \
+                adata = adjust_arg(data);                                      \
+                                                                               \
+        ia64_save_scratch_fpregs(fr);                                          \
+        efi_call_##prefix(                                                     \
+                (efi_reset_system_t *) __va(runtime->reset_system),            \
+                reset_type, status, data_size, adata);                         \
+        /* should not return, but just in case... */                           \
+        ia64_load_scratch_fpregs(fr);                                          \
 }
 
 #define phys_ptr(arg)   ((__typeof__(arg)) ia64_tpa(arg))
@@ -223,7 +236,8 @@ efi_gettimeofday (struct timespec *ts)
                 return;
         }
 
-        ts->tv_sec = mktime(tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
+        ts->tv_sec = mktime(tm.year, tm.month, tm.day,
+                            tm.hour, tm.minute, tm.second);
         ts->tv_nsec = tm.nanosecond;
 }
 
@@ -297,8 +311,8 @@ walk (efi_freemem_callback_t callback, void *arg, u64 attr)
 }
 
 /*
- * Walks the EFI memory map and calls CALLBACK once for each EFI memory descriptor that
- * has memory that is available for OS use.
+ * Walk the EFI memory map and call CALLBACK once for each EFI memory
+ * descriptor that has memory that is available for OS use.
  */
 void
 efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
@@ -307,8 +321,8 @@ efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
 }
 
 /*
- * Walks the EFI memory map and calls CALLBACK once for each EFI memory descriptor that
- * has memory that is available for uncached allocator.
+ * Walk the EFI memory map and call CALLBACK once for each EFI memory
+ * descriptor that has memory that is available for uncached allocator.
  */
 void
 efi_memmap_walk_uc (efi_freemem_callback_t callback, void *arg)
@@ -317,11 +331,10 @@ efi_memmap_walk_uc (efi_freemem_callback_t callback, void *arg)
 }
 
 /*
- * Look for the PAL_CODE region reported by EFI and maps it using an
+ * Look for the PAL_CODE region reported by EFI and map it using an
  * ITR to enable safe PAL calls in virtual mode.  See IA-64 Processor
  * Abstraction Layer chapter 11 in ADAG
  */
-
 void *
 efi_get_pal_addr (void)
 {
@@ -341,45 +354,47 @@ efi_get_pal_addr (void)
                         continue;
 
                 if (++pal_code_count > 1) {
-                        printk(KERN_ERR "Too many EFI Pal Code memory ranges, dropped @ %lx\n",
-                               md->phys_addr);
+                        printk(KERN_ERR "Too many EFI Pal Code memory ranges, "
+                               "dropped @ %lx\n", md->phys_addr);
                         continue;
                 }
                 /*
-                 * The only ITLB entry in region 7 that is used is the one installed by
-                 * __start().  That entry covers a 64MB range.
+                 * The only ITLB entry in region 7 that is used is the one
+                 * installed by __start().  That entry covers a 64MB range.
                  */
                 mask  = ~((1 << KERNEL_TR_PAGE_SHIFT) - 1);
                 vaddr = PAGE_OFFSET + md->phys_addr;
 
                 /*
-                 * We must check that the PAL mapping won't overlap with the kernel
-                 * mapping.
+                 * We must check that the PAL mapping won't overlap with the
+                 * kernel mapping.
                  *
-                 * PAL code is guaranteed to be aligned on a power of 2 between 4k and
-                 * 256KB and that only one ITR is needed to map it. This implies that the
-                 * PAL code is always aligned on its size, i.e., the closest matching page
-                 * size supported by the TLB. Therefore PAL code is guaranteed never to
-                 * cross a 64MB unless it is bigger than 64MB (very unlikely!).  So for
-                 * now the following test is enough to determine whether or not we need a
-                 * dedicated ITR for the PAL code.
+                 * PAL code is guaranteed to be aligned on a power of 2 between
+                 * 4k and 256KB and that only one ITR is needed to map it. This
+                 * implies that the PAL code is always aligned on its size,
+                 * i.e., the closest matching page size supported by the TLB.
+                 * Therefore PAL code is guaranteed never to cross a 64MB unless
+                 * it is bigger than 64MB (very unlikely!).  So for now the
+                 * following test is enough to determine whether or not we need
+                 * a dedicated ITR for the PAL code.
                  */
                 if ((vaddr & mask) == (KERNEL_START & mask)) {
-                        printk(KERN_INFO "%s: no need to install ITR for PAL code\n",
-                               __FUNCTION__);
+                        printk(KERN_INFO "%s: no need to install ITR for "
+                               "PAL code\n", __FUNCTION__);
                         continue;
                 }
 
                 if (efi_md_size(md) > IA64_GRANULE_SIZE)
-                        panic("Woah!  PAL code size bigger than a granule!");
+                        panic("Whoa!  PAL code size bigger than a granule!");
 
 #if EFI_DEBUG
                 mask  = ~((1 << IA64_GRANULE_SHIFT) - 1);
 
-                printk(KERN_INFO "CPU %d: mapping PAL code [0x%lx-0x%lx) into [0x%lx-0x%lx)\n",
-                        smp_processor_id(), md->phys_addr,
-                        md->phys_addr + efi_md_size(md),
-                        vaddr & mask, (vaddr & mask) + IA64_GRANULE_SIZE);
+                printk(KERN_INFO "CPU %d: mapping PAL code "
+                       "[0x%lx-0x%lx) into [0x%lx-0x%lx)\n",
+                       smp_processor_id(), md->phys_addr,
+                       md->phys_addr + efi_md_size(md),
+                       vaddr & mask, (vaddr & mask) + IA64_GRANULE_SIZE);
 #endif
                 return __va(md->phys_addr);
         }
@@ -401,11 +416,11 @@ efi_map_pal_code (void)
          * Cannot write to CRx with PSR.ic=1
          */
         psr = ia64_clear_ic();
-        ia64_itr(0x1, IA64_TR_PALCODE, GRANULEROUNDDOWN((unsigned long) pal_vaddr),
+        ia64_itr(0x1, IA64_TR_PALCODE,
+                 GRANULEROUNDDOWN((unsigned long) pal_vaddr),
                  pte_val(pfn_pte(__pa(pal_vaddr) >> PAGE_SHIFT, PAGE_KERNEL)),
                  IA64_GRANULE_SHIFT);
         ia64_set_psr(psr);              /* restore psr */
-        ia64_srlz_i();
 }
 
 void __init
@@ -418,7 +433,10 @@ efi_init (void)
         char *cp, vendor[100] = "unknown";
         int i;
 
-        /* it's too early to be able to use the standard kernel command line support... */
+        /*
+         * It's too early to be able to use the standard kernel command line
+         * support...
+         */
         for (cp = boot_command_line; *cp; ) {
                 if (memcmp(cp, "mem=", 4) == 0) {
                         mem_limit = memparse(cp + 4, &cp);
@@ -434,9 +452,11 @@ efi_init (void)
                 }
         }
         if (min_addr != 0UL)
-                printk(KERN_INFO "Ignoring memory below %luMB\n", min_addr >> 20);
+                printk(KERN_INFO "Ignoring memory below %luMB\n",
+                       min_addr >> 20);
         if (max_addr != ~0UL)
-                printk(KERN_INFO "Ignoring memory above %luMB\n", max_addr >> 20);
+                printk(KERN_INFO "Ignoring memory above %luMB\n",
+                       max_addr >> 20);
 
         efi.systab = __va(ia64_boot_param->efi_systab);
 
@@ -444,9 +464,9 @@ efi_init (void)
          * Verify the EFI Table
          */
         if (efi.systab == NULL)
-                panic("Woah! Can't find EFI system table.\n");
+                panic("Whoa! Can't find EFI system table.\n");
         if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
-                panic("Woah! EFI system table signature incorrect\n");
+                panic("Whoa! EFI system table signature incorrect\n");
         if ((efi.systab->hdr.revision >> 16) == 0)
                 printk(KERN_WARNING "Warning: EFI system table version "
                        "%d.%02d, expected 1.00 or greater\n",
@@ -464,7 +484,8 @@ efi_init (void)
         }
 
         printk(KERN_INFO "EFI v%u.%.02u by %s:",
-               efi.systab->hdr.revision >> 16, efi.systab->hdr.revision & 0xffff, vendor);
+               efi.systab->hdr.revision >> 16,
+               efi.systab->hdr.revision & 0xffff, vendor);
 
         efi.mps        = EFI_INVALID_TABLE_ADDR;
         efi.acpi       = EFI_INVALID_TABLE_ADDR;
@@ -519,9 +540,12 @@ efi_init (void)
                 efi_memory_desc_t *md;
                 void *p;
 
-                for (i = 0, p = efi_map_start; p < efi_map_end; ++i, p += efi_desc_size) {
+                for (i = 0, p = efi_map_start; p < efi_map_end;
+                     ++i, p += efi_desc_size)
+                {
                         md = p;
-                        printk("mem%02u: type=%u, attr=0x%lx, range=[0x%016lx-0x%016lx) (%luMB)\n",
+                        printk("mem%02u: type=%u, attr=0x%lx, "
+                               "range=[0x%016lx-0x%016lx) (%luMB)\n",
                                i, md->type, md->attribute, md->phys_addr,
                                md->phys_addr + efi_md_size(md),
                                md->num_pages >> (20 - EFI_PAGE_SHIFT));
@@ -549,8 +573,8 @@ efi_enter_virtual_mode (void)
                 md = p;
                 if (md->attribute & EFI_MEMORY_RUNTIME) {
                         /*
-                         * Some descriptors have multiple bits set, so the order of
-                         * the tests is relevant.
+                         * Some descriptors have multiple bits set, so the
+                         * order of the tests is relevant.
                          */
                         if (md->attribute & EFI_MEMORY_WB) {
                                 md->virt_addr = (u64) __va(md->phys_addr);
@@ -558,21 +582,26 @@ efi_enter_virtual_mode (void)
                                 md->virt_addr = (u64) ioremap(md->phys_addr, 0);
                         } else if (md->attribute & EFI_MEMORY_WC) {
 #if 0
-                                md->virt_addr = ia64_remap(md->phys_addr, (_PAGE_A | _PAGE_P
-                                                                           | _PAGE_D
-                                                                           | _PAGE_MA_WC
-                                                                           | _PAGE_PL_0
-                                                                           | _PAGE_AR_RW));
+                                md->virt_addr = ia64_remap(md->phys_addr,
+                                                           (_PAGE_A |
+                                                            _PAGE_P |
+                                                            _PAGE_D |
+                                                            _PAGE_MA_WC |
+                                                            _PAGE_PL_0 |
+                                                            _PAGE_AR_RW));
 #else
                                 printk(KERN_INFO "EFI_MEMORY_WC mapping\n");
                                 md->virt_addr = (u64) ioremap(md->phys_addr, 0);
 #endif
                         } else if (md->attribute & EFI_MEMORY_WT) {
 #if 0
-                                md->virt_addr = ia64_remap(md->phys_addr, (_PAGE_A | _PAGE_P
-                                                                           | _PAGE_D | _PAGE_MA_WT
-                                                                           | _PAGE_PL_0
-                                                                           | _PAGE_AR_RW));
+                                md->virt_addr = ia64_remap(md->phys_addr,
+                                                           (_PAGE_A |
+                                                            _PAGE_P |
+                                                            _PAGE_D |
+                                                            _PAGE_MA_WT |
+                                                            _PAGE_PL_0 |
+                                                            _PAGE_AR_RW));
 #else
                                 printk(KERN_INFO "EFI_MEMORY_WT mapping\n");
                                 md->virt_addr = (u64) ioremap(md->phys_addr, 0);
@@ -583,16 +612,18 @@ efi_enter_virtual_mode (void)
 
         status = efi_call_phys(__va(runtime->set_virtual_address_map),
                                ia64_boot_param->efi_memmap_size,
-                               efi_desc_size, ia64_boot_param->efi_memdesc_version,
+                               efi_desc_size,
+                               ia64_boot_param->efi_memdesc_version,
                                ia64_boot_param->efi_memmap);
         if (status != EFI_SUCCESS) {
-                printk(KERN_WARNING "warning: unable to switch EFI into virtual mode "
-                       "(status=%lu)\n", status);
+                printk(KERN_WARNING "warning: unable to switch EFI into "
+                       "virtual mode (status=%lu)\n", status);
                 return;
         }
 
         /*
-         * Now that EFI is in virtual mode, we call the EFI functions more efficiently:
+         * Now that EFI is in virtual mode, we call the EFI functions more
+         * efficiently:
          */
         efi.get_time = virt_get_time;
         efi.set_time = virt_set_time;
@@ -606,8 +637,8 @@ efi_enter_virtual_mode (void)
 }
 
 /*
- * Walk the EFI memory map looking for the I/O port range.  There can only be one entry of
- * this type, other I/O port ranges should be described via ACPI.
+ * Walk the EFI memory map looking for the I/O port range.  There can only be
+ * one entry of this type, other I/O port ranges should be described via ACPI.
  */
 u64
 efi_get_iobase (void)
@@ -678,7 +709,6 @@ efi_memmap_intersects (unsigned long phys_addr, unsigned long size)
 
         for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
                 md = p;
-
                 if (md->phys_addr < end && efi_md_end(md) > phys_addr)
                         return 1;
         }
@@ -731,7 +761,7 @@ efi_mem_attribute (unsigned long phys_addr, unsigned long size)
                 if (!md || (md->attribute & ~EFI_MEMORY_RUNTIME) != attr)
                         return 0;
         } while (md);
-        return 0;
+        return 0;       /* never reached */
 }
 
 u64
@@ -767,7 +797,7 @@ kern_mem_attribute (unsigned long phys_addr, unsigned long size)
                 if (!md || md->attribute != attr)
                         return 0;
         } while (md);
-        return 0;
+        return 0;       /* never reached */
 }
 EXPORT_SYMBOL(kern_mem_attribute);
 
@@ -883,7 +913,7 @@ efi_uart_console_only(void)
                                 return 1;
                         uart = 0;
                 }
-                hdr = (struct efi_generic_dev_path *) ((u8 *) hdr + hdr->length);
+                hdr = (struct efi_generic_dev_path *)((u8 *) hdr + hdr->length);
         }
         printk(KERN_ERR "Malformed %s value\n", name);
         return 0;
@@ -921,10 +951,12 @@ find_memmap_space (void)
                 if (!efi_wb(md)) {
                         continue;
                 }
-                if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) != md->phys_addr) {
+                if (pmd == NULL || !efi_wb(pmd) ||
+                    efi_md_end(pmd) != md->phys_addr) {
                         contig_low = GRANULEROUNDUP(md->phys_addr);
                         contig_high = efi_md_end(md);
-                        for (q = p + efi_desc_size; q < efi_map_end; q += efi_desc_size) {
+                        for (q = p + efi_desc_size; q < efi_map_end;
+                             q += efi_desc_size) {
                                 check_md = q;
                                 if (!efi_wb(check_md))
                                         break;
@@ -988,8 +1020,9 @@ efi_memmap_init(unsigned long *s, unsigned long *e)
         for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) {
                 md = p;
                 if (!efi_wb(md)) {
-                        if (efi_uc(md) && (md->type == EFI_CONVENTIONAL_MEMORY ||
-                                           md->type == EFI_BOOT_SERVICES_DATA)) {
+                        if (efi_uc(md) &&
+                            (md->type == EFI_CONVENTIONAL_MEMORY ||
+                             md->type == EFI_BOOT_SERVICES_DATA)) {
                                 k->attribute = EFI_MEMORY_UC;
                                 k->start = md->phys_addr;
                                 k->num_pages = md->num_pages;
@@ -997,10 +1030,12 @@ efi_memmap_init(unsigned long *s, unsigned long *e)
                         }
                         continue;
                 }
-                if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) != md->phys_addr) {
+                if (pmd == NULL || !efi_wb(pmd) ||
+                    efi_md_end(pmd) != md->phys_addr) {
                         contig_low = GRANULEROUNDUP(md->phys_addr);
                         contig_high = efi_md_end(md);
-                        for (q = p + efi_desc_size; q < efi_map_end; q += efi_desc_size) {
+                        for (q = p + efi_desc_size; q < efi_map_end;
+                             q += efi_desc_size) {
                                 check_md = q;
                                 if (!efi_wb(check_md))
                                         break;
@@ -1025,13 +1060,17 @@ efi_memmap_init(unsigned long *s, unsigned long *e)
                 if (md->phys_addr < contig_low) {
                         lim = min(efi_md_end(md), contig_low);
                         if (efi_uc(md)) {
-                                if (k > kern_memmap && (k-1)->attribute == EFI_MEMORY_UC &&
+                                if (k > kern_memmap &&
+                                    (k-1)->attribute == EFI_MEMORY_UC &&
                                     kmd_end(k-1) == md->phys_addr) {
-                                        (k-1)->num_pages += (lim - md->phys_addr) >> EFI_PAGE_SHIFT;
+                                        (k-1)->num_pages +=
+                                                (lim - md->phys_addr)
+                                                >> EFI_PAGE_SHIFT;
                                 } else {
                                         k->attribute = EFI_MEMORY_UC;
                                         k->start = md->phys_addr;
-                                        k->num_pages = (lim - md->phys_addr) >> EFI_PAGE_SHIFT;
+                                        k->num_pages = (lim - md->phys_addr)
+                                                >> EFI_PAGE_SHIFT;
                                         k++;
                                 }
                         }
@@ -1049,7 +1088,8 @@ efi_memmap_init(unsigned long *s, unsigned long *e)
                                 } else {
                                         k->attribute = EFI_MEMORY_UC;
                                         k->start = lim;
-                                        k->num_pages = (efi_md_end(md) - lim) >> EFI_PAGE_SHIFT;
+                                        k->num_pages = (efi_md_end(md) - lim)
+                                                >> EFI_PAGE_SHIFT;
                                         k++;
                                 }
                         }
@@ -1151,8 +1191,10 @@ efi_initialize_iomem_resources(struct resource *code_resource,
                                 break;
                 }
 
-                if ((res = kzalloc(sizeof(struct resource), GFP_KERNEL)) == NULL) {
-                        printk(KERN_ERR "failed to alocate resource for iomem\n");
+                if ((res = kzalloc(sizeof(struct resource),
+                                   GFP_KERNEL)) == NULL) {
+                        printk(KERN_ERR
+                               "failed to allocate resource for iomem\n");
                         return;
                 }
 
@@ -1187,44 +1229,44 @@ efi_initialize_iomem_resources(struct resource *code_resource,
    rsvd_regions are sorted
  */
 unsigned long __init
-kdump_find_rsvd_region (unsigned long size,
-                struct rsvd_region *r, int n)
+kdump_find_rsvd_region (unsigned long size, struct rsvd_region *r, int n)
 {
-  int i;
-  u64 start, end;
-  u64 alignment = 1UL << _PAGE_SIZE_64M;
-  void *efi_map_start, *efi_map_end, *p;
-  efi_memory_desc_t *md;
-  u64 efi_desc_size;
-
-  efi_map_start = __va(ia64_boot_param->efi_memmap);
-  efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
-  efi_desc_size = ia64_boot_param->efi_memdesc_size;
-
-  for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
-          md = p;
-          if (!efi_wb(md))
-                  continue;
-          start = ALIGN(md->phys_addr, alignment);
-          end = efi_md_end(md);
-          for (i = 0; i < n; i++) {
-                if (__pa(r[i].start) >= start && __pa(r[i].end) < end) {
-                        if (__pa(r[i].start) > start + size)
-                                return start;
-                        start = ALIGN(__pa(r[i].end), alignment);
-                        if (i < n-1 && __pa(r[i+1].start) < start + size)
-                                continue;
-                        else
-                                break;
+        int i;
+        u64 start, end;
+        u64 alignment = 1UL << _PAGE_SIZE_64M;
+        void *efi_map_start, *efi_map_end, *p;
+        efi_memory_desc_t *md;
+        u64 efi_desc_size;
+
+        efi_map_start = __va(ia64_boot_param->efi_memmap);
+        efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
+        efi_desc_size = ia64_boot_param->efi_memdesc_size;
+
+        for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
+                md = p;
+                if (!efi_wb(md))
+                        continue;
+                start = ALIGN(md->phys_addr, alignment);
+                end = efi_md_end(md);
+                for (i = 0; i < n; i++) {
+                        if (__pa(r[i].start) >= start && __pa(r[i].end) < end) {
+                                if (__pa(r[i].start) > start + size)
+                                        return start;
+                                start = ALIGN(__pa(r[i].end), alignment);
+                                if (i < n-1 &&
+                                    __pa(r[i+1].start) < start + size)
+                                        continue;
+                                else
+                                        break;
+                        }
                 }
-          }
-          if (end > start + size)
-                return start;
-  }
-
-  printk(KERN_WARNING "Cannot reserve 0x%lx byte of memory for crashdump\n",
-        size);
-  return ~0UL;
+                if (end > start + size)
+                        return start;
+        }
+
+        printk(KERN_WARNING
+               "Cannot reserve 0x%lx byte of memory for crashdump\n", size);
+        return ~0UL;
 }
 #endif
 
diff --git a/arch/ia64/kernel/entry.S b/arch/ia64/kernel/entry.S
index c36f43c94600..f5d3efbfbeda 100644
--- a/arch/ia64/kernel/entry.S
+++ b/arch/ia64/kernel/entry.S
@@ -1586,7 +1586,7 @@ sys_call_table:
         data8 sys_epoll_pwait                   // 1305
         data8 sys_utimensat
         data8 sys_signalfd
-        data8 sys_timerfd
+        data8 sys_ni_syscall
         data8 sys_eventfd
 
         .org sys_call_table + 8*NR_syscalls     // guard against failures to increase NR_syscalls
diff --git a/arch/ia64/kernel/fsyscall_gtod_data.h b/arch/ia64/kernel/fsyscall_gtod_data.h
index 490dab55fba3..57d2ee6c83e1 100644
--- a/arch/ia64/kernel/fsyscall_gtod_data.h
+++ b/arch/ia64/kernel/fsyscall_gtod_data.h
@@ -14,10 +14,10 @@ struct fsyscall_gtod_data_t {
         u32             clk_shift;
         void            *clk_fsys_mmio;
         cycle_t         clk_cycle_last;
-} __attribute__ ((aligned (L1_CACHE_BYTES)));
+} ____cacheline_aligned;
 
 struct itc_jitter_data_t {
         int             itc_jitter;
         cycle_t         itc_lastcycle;
-} __attribute__ ((aligned (L1_CACHE_BYTES)));
+} ____cacheline_aligned;
 
diff --git a/arch/ia64/kernel/ia64_ksyms.c b/arch/ia64/kernel/ia64_ksyms.c
index c3b4412ccc67..8e7193d55528 100644
--- a/arch/ia64/kernel/ia64_ksyms.c
+++ b/arch/ia64/kernel/ia64_ksyms.c
@@ -12,6 +12,9 @@ EXPORT_SYMBOL(memset);
 EXPORT_SYMBOL(memcpy);
 EXPORT_SYMBOL(strlen);
 
+#include<asm/pgtable.h>
+EXPORT_SYMBOL_GPL(empty_zero_page);
+
 #include <asm/checksum.h>
 EXPORT_SYMBOL(ip_fast_csum);            /* hand-coded assembly */
 EXPORT_SYMBOL(csum_ipv6_magic);
diff --git a/arch/ia64/kernel/kprobes.c b/arch/ia64/kernel/kprobes.c
index fc4d2676264f..b618487cdc85 100644
--- a/arch/ia64/kernel/kprobes.c
+++ b/arch/ia64/kernel/kprobes.c
@@ -381,9 +381,10 @@ static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb)
 static void __kprobes restore_previous_kprobe(struct kprobe_ctlblk *kcb)
 {
         unsigned int i;
-        i = atomic_sub_return(1, &kcb->prev_kprobe_index);
-        __get_cpu_var(current_kprobe) = kcb->prev_kprobe[i].kp;
-        kcb->kprobe_status = kcb->prev_kprobe[i].status;
+        i = atomic_read(&kcb->prev_kprobe_index);
+        __get_cpu_var(current_kprobe) = kcb->prev_kprobe[i-1].kp;
+        kcb->kprobe_status = kcb->prev_kprobe[i-1].status;
+        atomic_sub(1, &kcb->prev_kprobe_index);
 }
 
 static void __kprobes set_current_kprobe(struct kprobe *p,
diff --git a/arch/ia64/kernel/mca.c b/arch/ia64/kernel/mca.c
index 6dbf5919d2d0..846e7e036b13 100644
--- a/arch/ia64/kernel/mca.c
+++ b/arch/ia64/kernel/mca.c
@@ -2,61 +2,69 @@
  * File:        mca.c
  * Purpose:     Generic MCA handling layer
  *
- * Updated for latest kernel
  * Copyright (C) 2003 Hewlett-Packard Co
  *      David Mosberger-Tang <davidm@hpl.hp.com>
  *
  * Copyright (C) 2002 Dell Inc.
- * Copyright (C) Matt Domsch (Matt_Domsch@dell.com)
+ * Copyright (C) Matt Domsch <Matt_Domsch@dell.com>
  *
  * Copyright (C) 2002 Intel
- * Copyright (C) Jenna Hall (jenna.s.hall@intel.com)
+ * Copyright (C) Jenna Hall <jenna.s.hall@intel.com>
  *
  * Copyright (C) 2001 Intel
- * Copyright (C) Fred Lewis (frederick.v.lewis@intel.com)
+ * Copyright (C) Fred Lewis <frederick.v.lewis@intel.com>
  *
  * Copyright (C) 2000 Intel
- * Copyright (C) Chuck Fleckenstein (cfleck@co.intel.com)
+ * Copyright (C) Chuck Fleckenstein <cfleck@co.intel.com>
  *
  * Copyright (C) 1999, 2004 Silicon Graphics, Inc.
- * Copyright (C) Vijay Chander(vijay@engr.sgi.com)
+ * Copyright (C) Vijay Chander <vijay@engr.sgi.com>
  *
- * 03/04/15 D. Mosberger Added INIT backtrace support.
- * 02/03/25 M. Domsch   GUID cleanups
+ * Copyright (C) 2006 FUJITSU LIMITED
+ * Copyright (C) Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
  *
- * 02/01/04 J. Hall     Aligned MCA stack to 16 bytes, added platform vs. CPU
- *                      error flag, set SAL default return values, changed
- *                      error record structure to linked list, added init call
- *                      to sal_get_state_info_size().
+ * 2000-03-29 Chuck Fleckenstein <cfleck@co.intel.com>
+ *            Fixed PAL/SAL update issues, began MCA bug fixes, logging issues,
+ *            added min save state dump, added INIT handler.
  *
- * 01/01/03 F. Lewis    Added setup of CMCI and CPEI IRQs, logging of corrected
- *                      platform errors, completed code for logging of
- *                      corrected & uncorrected machine check errors, and
- *                      updated for conformance with Nov. 2000 revision of the
- *                      SAL 3.0 spec.
- * 00/03/29 C. Fleckenstein  Fixed PAL/SAL update issues, began MCA bug fixes, logging issues,
- *                           added min save state dump, added INIT handler.
+ * 2001-01-03 Fred Lewis <frederick.v.lewis@intel.com>
+ *            Added setup of CMCI and CPEI IRQs, logging of corrected platform
+ *            errors, completed code for logging of corrected & uncorrected
+ *            machine check errors, and updated for conformance with Nov. 2000
+ *            revision of the SAL 3.0 spec.
+ *
+ * 2002-01-04 Jenna Hall <jenna.s.hall@intel.com>
+ *            Aligned MCA stack to 16 bytes, added platform vs. CPU error flag,
+ *            set SAL default return values, changed error record structure to
+ *            linked list, added init call to sal_get_state_info_size().
+ *
+ * 2002-03-25 Matt Domsch <Matt_Domsch@dell.com>
+ *            GUID cleanups.
+ *
+ * 2003-04-15 David Mosberger-Tang <davidm@hpl.hp.com>
+ *            Added INIT backtrace support.
  *
  * 2003-12-08 Keith Owens <kaos@sgi.com>
- *            smp_call_function() must not be called from interrupt context (can
- *            deadlock on tasklist_lock).  Use keventd to call smp_call_function().
+ *            smp_call_function() must not be called from interrupt context
+ *            (can deadlock on tasklist_lock).
+ *            Use keventd to call smp_call_function().
  *
  * 2004-02-01 Keith Owens <kaos@sgi.com>
- *            Avoid deadlock when using printk() for MCA and INIT records.
- *            Delete all record printing code, moved to salinfo_decode in user space.
- *            Mark variables and functions static where possible.
- *            Delete dead variables and functions.
- *            Reorder to remove the need for forward declarations and to consolidate
- *            related code.
+ *            Avoid deadlock when using printk() for MCA and INIT records.
+ *            Delete all record printing code, moved to salinfo_decode in user
+ *            space.  Mark variables and functions static where possible.
+ *            Delete dead variables and functions.  Reorder to remove the need
+ *            for forward declarations and to consolidate related code.
  *
  * 2005-08-12 Keith Owens <kaos@sgi.com>
- *            Convert MCA/INIT handlers to use per event stacks and SAL/OS state.
+ *            Convert MCA/INIT handlers to use per event stacks and SAL/OS
+ *            state.
  *
  * 2005-10-07 Keith Owens <kaos@sgi.com>
  *            Add notify_die() hooks.
  *
  * 2006-09-15 Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
- *            Add printing support for MCA/INIT.
+ *            Add printing support for MCA/INIT.
  *
  * 2007-04-27 Russ Anderson <rja@sgi.com>
  *            Support multiple cpus going through OS_MCA in the same event.
diff --git a/arch/ia64/kernel/mca_asm.S b/arch/ia64/kernel/mca_asm.S
index 0f5965fcdf85..8bc7d259e0c6 100644
--- a/arch/ia64/kernel/mca_asm.S
+++ b/arch/ia64/kernel/mca_asm.S
@@ -1,24 +1,28 @@
-//
-// assembly portion of the IA64 MCA handling
-//
-// Mods by cfleck to integrate into kernel build
-// 00/03/15 davidm Added various stop bits to get a clean compile
-//
-// 00/03/29 cfleck Added code to save INIT handoff state in pt_regs format, switch to temp
-//                 kstack, switch modes, jump to C INIT handler
-//
-// 02/01/04 J.Hall <jenna.s.hall@intel.com>
-//                 Before entering virtual mode code:
-//                 1. Check for TLB CPU error
-//                 2. Restore current thread pointer to kr6
-//                 3. Move stack ptr 16 bytes to conform to C calling convention
-//
-// 04/11/12 Russ Anderson <rja@sgi.com>
-//                 Added per cpu MCA/INIT stack save areas.
-//
-// 12/08/05 Keith Owens <kaos@sgi.com>
-//                 Use per cpu MCA/INIT stacks for all data.
-//
+/*
+ * File:        mca_asm.S
+ * Purpose:     assembly portion of the IA64 MCA handling
+ *
+ * Mods by cfleck to integrate into kernel build
+ *
+ * 2000-03-15 David Mosberger-Tang <davidm@hpl.hp.com>
+ *              Added various stop bits to get a clean compile
+ *
+ * 2000-03-29 Chuck Fleckenstein <cfleck@co.intel.com>
+ *              Added code to save INIT handoff state in pt_regs format,
+ *              switch to temp kstack, switch modes, jump to C INIT handler
+ *
+ * 2002-01-04 J.Hall <jenna.s.hall@intel.com>
+ *              Before entering virtual mode code:
+ *               1. Check for TLB CPU error
+ *               2. Restore current thread pointer to kr6
+ *               3. Move stack ptr 16 bytes to conform to C calling convention
+ *
+ * 2004-11-12 Russ Anderson <rja@sgi.com>
+ *              Added per cpu MCA/INIT stack save areas.
+ *
+ * 2005-12-08 Keith Owens <kaos@sgi.com>
+ *              Use per cpu MCA/INIT stacks for all data.
+ */
 #include <linux/threads.h>
 
 #include <asm/asmmacro.h>
diff --git a/arch/ia64/kernel/mca_drv.c b/arch/ia64/kernel/mca_drv.c
index aba813c2c150..fab1d21a4f2c 100644
--- a/arch/ia64/kernel/mca_drv.c
+++ b/arch/ia64/kernel/mca_drv.c
@@ -3,7 +3,7 @@
  * Purpose:     Generic MCA handling layer
  *
  * Copyright (C) 2004 FUJITSU LIMITED
- * Copyright (C) Hidetoshi Seto (seto.hidetoshi@jp.fujitsu.com)
+ * Copyright (C) 2004 Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
  * Copyright (C) 2005 Silicon Graphics, Inc
  * Copyright (C) 2005 Keith Owens <kaos@sgi.com>
  * Copyright (C) 2006 Russ Anderson <rja@sgi.com>
diff --git a/arch/ia64/kernel/mca_drv.h b/arch/ia64/kernel/mca_drv.h
index 485e34d0b199..53b8ecb5b4b9 100644
--- a/arch/ia64/kernel/mca_drv.h
+++ b/arch/ia64/kernel/mca_drv.h
@@ -3,7 +3,7 @@
  * Purpose:     Define helpers for Generic MCA handling
  *
  * Copyright (C) 2004 FUJITSU LIMITED
- * Copyright (C) Hidetoshi Seto (seto.hidetoshi@jp.fujitsu.com)
+ * Copyright (C) 2004 Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
  */
 /*
  * Processor error section:
diff --git a/arch/ia64/kernel/mca_drv_asm.S b/arch/ia64/kernel/mca_drv_asm.S
index 3bccb06c8d21..767ac2c20d16 100644
--- a/arch/ia64/kernel/mca_drv_asm.S
+++ b/arch/ia64/kernel/mca_drv_asm.S
@@ -3,7 +3,7 @@
  * Purpose:     Assembly portion of Generic MCA handling
  *
  * Copyright (C) 2004 FUJITSU LIMITED
- * Copyright (C) Hidetoshi Seto (seto.hidetoshi@jp.fujitsu.com)
+ * Copyright (C) 2004 Hidetoshi Seto <seto.hidetoshi@jp.fujitsu.com>
  */
 #include <linux/threads.h>
 
diff --git a/arch/ia64/kernel/module.c b/arch/ia64/kernel/module.c
index e699eb6c44be..e58f4367cf11 100644
--- a/arch/ia64/kernel/module.c
+++ b/arch/ia64/kernel/module.c
@@ -940,14 +940,3 @@ module_arch_cleanup (struct module *mod)
         if (mod->arch.core_unw_table)
                 unw_remove_unwind_table(mod->arch.core_unw_table);
 }
-
-#ifdef CONFIG_SMP
-void
-percpu_modcopy (void *pcpudst, const void *src, unsigned long size)
-{
-        unsigned int i;
-        for_each_possible_cpu(i) {
-                memcpy(pcpudst + per_cpu_offset(i), src, size);
-        }
-}
-#endif /* CONFIG_SMP */
diff --git a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c
index 73e7c2e40b54..78acd9fe97e9 100644
--- a/arch/ia64/kernel/perfmon.c
+++ b/arch/ia64/kernel/perfmon.c
@@ -2631,7 +2631,7 @@ pfm_task_incompatible(pfm_context_t *ctx, struct task_struct *task)
          */
         if (task == current) return 0;
 
-        if ((task->state != TASK_STOPPED) && (task->state != TASK_TRACED)) {
+        if (!task_is_stopped_or_traced(task)) {
                 DPRINT(("cannot attach to non-stopped task [%d] state=%ld\n", task_pid_nr(task), task->state));
                 return -EBUSY;
         }
@@ -2654,11 +2654,11 @@ pfm_get_task(pfm_context_t *ctx, pid_t pid, struct task_struct **task)
         /* XXX: need to add more checks here */
         if (pid < 2) return -EPERM;
 
-        if (pid != current->pid) {
+        if (pid != task_pid_vnr(current)) {
 
                 read_lock(&tasklist_lock);
 
-                p = find_task_by_pid(pid);
+                p = find_task_by_vpid(pid);
 
                 /* make sure task cannot go away while we operate on it */
                 if (p) get_task_struct(p);
@@ -4792,7 +4792,7 @@ recheck:
          * the task must be stopped.
          */
         if (PFM_CMD_STOPPED(cmd)) {
-                if ((task->state != TASK_STOPPED) && (task->state != TASK_TRACED)) {
+                if (!task_is_stopped_or_traced(task)) {
                         DPRINT(("[%d] task not in stopped state\n", task_pid_nr(task)));
                         return -EBUSY;
                 }
@@ -5795,7 +5795,7 @@ pfm_proc_show(struct seq_file *m, void *v)
         return 0;
 }
 
-struct seq_operations pfm_seq_ops = {
+const struct seq_operations pfm_seq_ops = {
         .start =        pfm_proc_start,
         .next =         pfm_proc_next,
         .stop =         pfm_proc_stop,
diff --git a/arch/ia64/kernel/sal.c b/arch/ia64/kernel/sal.c
index 27c2ef445a56..f44fe8412162 100644
--- a/arch/ia64/kernel/sal.c
+++ b/arch/ia64/kernel/sal.c
@@ -284,6 +284,7 @@ ia64_sal_cache_flush (u64 cache_type)
         SAL_CALL(isrv, SAL_CACHE_FLUSH, cache_type, 0, 0, 0, 0, 0, 0);
         return isrv.status;
 }
+EXPORT_SYMBOL_GPL(ia64_sal_cache_flush);
 
 void __init
 ia64_sal_init (struct ia64_sal_systab *systab)
@@ -372,3 +373,16 @@ ia64_sal_oemcall_reentrant(struct ia64_sal_retval *isrvp, u64 oemfunc,
         return 0;
 }
 EXPORT_SYMBOL(ia64_sal_oemcall_reentrant);
+
+long
+ia64_sal_freq_base (unsigned long which, unsigned long *ticks_per_second,
+                    unsigned long *drift_info)
+{
+        struct ia64_sal_retval isrv;
+
+        SAL_CALL(isrv, SAL_FREQ_BASE, which, 0, 0, 0, 0, 0, 0);
+        *ticks_per_second = isrv.v0;
+        *drift_info = isrv.v1;
+        return isrv.status;
+}
+EXPORT_SYMBOL_GPL(ia64_sal_freq_base);
diff --git a/arch/ia64/kernel/setup.c b/arch/ia64/kernel/setup.c
index 86028c69861e..ebd1a09f3201 100644
--- a/arch/ia64/kernel/setup.c
+++ b/arch/ia64/kernel/setup.c
@@ -654,7 +654,7 @@ c_stop (struct seq_file *m, void *v)
 {
 }
 
-struct seq_operations cpuinfo_op = {
+const struct seq_operations cpuinfo_op = {
         .start =        c_start,
         .next =         c_next,
         .stop =         c_stop,
diff --git a/arch/ia64/kernel/smpboot.c b/arch/ia64/kernel/smpboot.c
index f0fc4d8465ad..480b1a5085d5 100644
--- a/arch/ia64/kernel/smpboot.c
+++ b/arch/ia64/kernel/smpboot.c
@@ -767,17 +767,6 @@ void __cpu_die(unsigned int cpu)
         }
         printk(KERN_ERR "CPU %u didn't die...\n", cpu);
 }
-#else /* !CONFIG_HOTPLUG_CPU */
-int __cpu_disable(void)
-{
-        return -ENOSYS;
-}
-
-void __cpu_die(unsigned int cpu)
-{
-        /* We said "no" in __cpu_disable */
-        BUG();
-}
 #endif /* CONFIG_HOTPLUG_CPU */
 
 void
diff --git a/arch/ia64/kernel/traps.c b/arch/ia64/kernel/traps.c
index 78d65cb947d2..f0cda765e681 100644
--- a/arch/ia64/kernel/traps.c
+++ b/arch/ia64/kernel/traps.c
@@ -35,7 +35,7 @@ trap_init (void)
                 fpswa_interface = __va(ia64_boot_param->fpswa);
 }
 
-void
+int
 die (const char *str, struct pt_regs *regs, long err)
 {
         static struct {
@@ -62,8 +62,11 @@ die (const char *str, struct pt_regs *regs, long err)
         if (++die.lock_owner_depth < 3) {
                 printk("%s[%d]: %s %ld [%d]\n",
                 current->comm, task_pid_nr(current), str, err, ++die_counter);
-                (void) notify_die(DIE_OOPS, (char *)str, regs, err, 255, SIGSEGV);
-                show_regs(regs);
+                if (notify_die(DIE_OOPS, str, regs, err, 255, SIGSEGV)
+                    != NOTIFY_STOP)
+                        show_regs(regs);
+                else
+                        regs = NULL;
         } else
                 printk(KERN_ERR "Recursive die() failure, output suppressed\n");
 
@@ -72,17 +75,22 @@ die (const char *str, struct pt_regs *regs, long err)
         add_taint(TAINT_DIE);
         spin_unlock_irq(&die.lock);
 
+        if (!regs)
+                return 1;
+
         if (panic_on_oops)
                 panic("Fatal exception");
 
         do_exit(SIGSEGV);
+        return 0;
 }
 
-void
+int
 die_if_kernel (char *str, struct pt_regs *regs, long err)
 {
         if (!user_mode(regs))
-                die(str, regs, err);
+                return die(str, regs, err);
+        return 0;
 }
 
 void
@@ -102,7 +110,8 @@ __kprobes ia64_bad_break (unsigned long break_num, struct pt_regs *regs)
                 if (notify_die(DIE_BREAK, "break 0", regs, break_num, TRAP_BRKPT, SIGTRAP)
                                 == NOTIFY_STOP)
                         return;
-                die_if_kernel("bugcheck!", regs, break_num);
+                if (die_if_kernel("bugcheck!", regs, break_num))
+                        return;
                 sig = SIGILL; code = ILL_ILLOPC;
                 break;
 
@@ -155,8 +164,9 @@ __kprobes ia64_bad_break (unsigned long break_num, struct pt_regs *regs)
                 break;
 
               default:
-                if (break_num < 0x40000 || break_num > 0x100000)
-                        die_if_kernel("Bad break", regs, break_num);
+                if ((break_num < 0x40000 || break_num > 0x100000)
+                    && die_if_kernel("Bad break", regs, break_num))
+                        return;
 
                 if (break_num < 0x80000) {
                         sig = SIGILL; code = __ILL_BREAK;
@@ -402,14 +412,15 @@ ia64_illegal_op_fault (unsigned long ec, long arg1, long arg2, long arg3,
 #endif
 
         sprintf(buf, "IA-64 Illegal operation fault");
-        die_if_kernel(buf, &regs, 0);
+        rv.fkt = 0;
+        if (die_if_kernel(buf, &regs, 0))
+                return rv;
 
         memset(&si, 0, sizeof(si));
         si.si_signo = SIGILL;
         si.si_code = ILL_ILLOPC;
         si.si_addr = (void __user *) (regs.cr_iip + ia64_psr(&regs)->ri);
         force_sig_info(SIGILL, &si, current);
-        rv.fkt = 0;
         return rv;
 }
 
@@ -644,6 +655,6 @@ ia64_fault (unsigned long vector, unsigned long isr, unsigned long ifa,
                 sprintf(buf, "Fault %lu", vector);
                 break;
         }
-        die_if_kernel(buf, &regs, error);
-        force_sig(SIGILL, current);
+        if (!die_if_kernel(buf, &regs, error))
+                force_sig(SIGILL, current);
 }
diff --git a/arch/ia64/kernel/unaligned.c b/arch/ia64/kernel/unaligned.c
index f6a1aeb742b3..52f70bbc192a 100644
--- a/arch/ia64/kernel/unaligned.c
+++ b/arch/ia64/kernel/unaligned.c
@@ -23,7 +23,7 @@
 #include <asm/uaccess.h>
 #include <asm/unaligned.h>
 
-extern void die_if_kernel(char *str, struct pt_regs *regs, long err);
+extern int die_if_kernel(char *str, struct pt_regs *regs, long err);
 
 #undef DEBUG_UNALIGNED_TRAP
 
@@ -675,8 +675,9 @@ emulate_load_updates (update_t type, load_store_t ld, struct pt_regs *regs, unsi
          */
         if (ld.x6_op == 1 || ld.x6_op == 3) {
                 printk(KERN_ERR "%s: register update on speculative load, error\n", __FUNCTION__);
-                die_if_kernel("unaligned reference on speculative load with register update\n",
-                              regs, 30);
+                if (die_if_kernel("unaligned reference on speculative load with register update\n",
+                                  regs, 30))
+                        return;
         }
 
 
@@ -1317,7 +1318,8 @@ ia64_handle_unaligned (unsigned long ifa, struct pt_regs *regs)
 
         if (ia64_psr(regs)->be) {
                 /* we don't support big-endian accesses */
-                die_if_kernel("big-endian unaligned accesses are not supported", regs, 0);
+                if (die_if_kernel("big-endian unaligned accesses are not supported", regs, 0))
+                        return;
                 goto force_sigbus;
         }
 
@@ -1534,7 +1536,8 @@ ia64_handle_unaligned (unsigned long ifa, struct pt_regs *regs)
                         ia64_handle_exception(regs, eh);
                         goto done;
                 }
-                die_if_kernel("error during unaligned kernel access\n", regs, ret);
+                if (die_if_kernel("error during unaligned kernel access\n", regs, ret))
+                        return;
                 /* NOT_REACHED */
         }
   force_sigbus:
diff --git a/arch/ia64/mm/fault.c b/arch/ia64/mm/fault.c
index 7571076a16a1..3e69881648a3 100644
--- a/arch/ia64/mm/fault.c
+++ b/arch/ia64/mm/fault.c
@@ -16,7 +16,7 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 
-extern void die (char *, struct pt_regs *, long);
+extern int die(char *, struct pt_regs *, long);
 
 #ifdef CONFIG_KPROBES
 static inline int notify_page_fault(struct pt_regs *regs, int trap)
@@ -267,9 +267,11 @@ ia64_do_page_fault (unsigned long address, unsigned long isr, struct pt_regs *re
         else
                 printk(KERN_ALERT "Unable to handle kernel paging request at "
                        "virtual address %016lx\n", address);
-        die("Oops", regs, isr);
+        if (die("Oops", regs, isr))
+                regs = NULL;
         bust_spinlocks(0);
-        do_exit(SIGKILL);
+        if (regs)
+                do_exit(SIGKILL);
         return;
 
   out_of_memory:
diff --git a/arch/ia64/sn/kernel/sn2/sn2_smp.c b/arch/ia64/sn/kernel/sn2/sn2_smp.c
index f3c69329e145..dfc6bf1c7b41 100644
--- a/arch/ia64/sn/kernel/sn2/sn2_smp.c
+++ b/arch/ia64/sn/kernel/sn2/sn2_smp.c
@@ -523,7 +523,7 @@ static ssize_t sn2_ptc_proc_write(struct file *file, const char __user *user, si
         return count;
 }
 
-static struct seq_operations sn2_ptc_seq_ops = {
+static const struct seq_operations sn2_ptc_seq_ops = {
         .start = sn2_ptc_seq_start,
         .next = sn2_ptc_seq_next,
         .stop = sn2_ptc_seq_stop,
diff --git a/arch/ia64/sn/kernel/sn2/sn_hwperf.c b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
index 1a8e49607f11..4b0d1538e7e5 100644
--- a/arch/ia64/sn/kernel/sn2/sn_hwperf.c
+++ b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
@@ -33,6 +33,7 @@
 #include <linux/smp_lock.h>
 #include <linux/nodemask.h>
 #include <linux/smp.h>
+#include <linux/mutex.h>
 
 #include <asm/processor.h>
 #include <asm/topology.h>
@@ -50,7 +51,7 @@ static void *sn_hwperf_salheap = NULL;
 static int sn_hwperf_obj_cnt = 0;
 static nasid_t sn_hwperf_master_nasid = INVALID_NASID;
 static int sn_hwperf_init(void);
-static DECLARE_MUTEX(sn_hwperf_init_mutex);
+static DEFINE_MUTEX(sn_hwperf_init_mutex);
 
 #define cnode_possible(n)       ((n) < num_cnodes)
 
@@ -577,7 +578,7 @@ static void sn_topology_stop(struct seq_file *m, void *v)
 /*
  * /proc/sgi_sn/sn_topology, read-only using seq_file
  */
-static struct seq_operations sn_topology_seq_ops = {
+static const struct seq_operations sn_topology_seq_ops = {
         .start = sn_topology_start,
         .next = sn_topology_next,
         .stop = sn_topology_stop,
@@ -884,10 +885,10 @@ static int sn_hwperf_init(void)
         int e = 0;
 
         /* single threaded, once-only initialization */
-        down(&sn_hwperf_init_mutex);
+        mutex_lock(&sn_hwperf_init_mutex);
 
         if (sn_hwperf_salheap) {
-                up(&sn_hwperf_init_mutex);
+                mutex_unlock(&sn_hwperf_init_mutex);
                 return e;
         }
 
@@ -936,7 +937,7 @@ out:
                 sn_hwperf_salheap = NULL;
                 sn_hwperf_obj_cnt = 0;
         }
-        up(&sn_hwperf_init_mutex);
+        mutex_unlock(&sn_hwperf_init_mutex);
         return e;
 }
 
diff --git a/arch/m32r/Kconfig b/arch/m32r/Kconfig
index f7237c5f531e..795180b8fd8e 100644
--- a/arch/m32r/Kconfig
+++ b/arch/m32r/Kconfig
@@ -8,6 +8,7 @@ mainmenu "Linux/M32R Kernel Configuration"
 config M32R
         bool
         default y
+        select HAVE_OPROFILE
 
 config SBUS
         bool
@@ -302,8 +303,7 @@ config SMP
           Y to "Enhanced Real Time Clock Support", below. The "Advanced Power
           Management" code will be disabled if you say Y here.
 
-          See also the <file:Documentation/smp.txt>,
-          and the SMP-HOWTO available at
+          See also the SMP-HOWTO available at
           <http://www.linuxdoc.org/docs.html#howto>.
 
           If you don't know what to do here, say N.
@@ -359,11 +359,6 @@ config PCI
           your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
           VESA. If you have PCI, say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.linuxdoc.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 choice
         prompt "PCI access mode"
         depends on PCI
@@ -431,8 +426,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/m32r/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/m32r/boot/compressed/m32r_sio.c b/arch/m32r/boot/compressed/m32r_sio.c
index ee3c8be12fa0..01d877c6868f 100644
--- a/arch/m32r/boot/compressed/m32r_sio.c
+++ b/arch/m32r/boot/compressed/m32r_sio.c
@@ -17,7 +17,7 @@ static int puts(const char *s)
         return 0;
 }
 
-#if defined(CONFIG_PLAT_M32700UT_Alpha) || defined(CONFIG_PLAT_M32700UT) || defined(CONFIG_PLAT_OPSPUT)
+#if defined(CONFIG_PLAT_M32700UT) || defined(CONFIG_PLAT_OPSPUT)
 #include <asm/m32r.h>
 #include <asm/io.h>
 
@@ -52,7 +52,7 @@ static void putc(char c)
         }
         *BOOT_SIO0TXB = c;
 }
-#else /* !(CONFIG_PLAT_M32700UT_Alpha) && !(CONFIG_PLAT_M32700UT) */
+#else /* !(CONFIG_PLAT_M32700UT) */
 #if defined(CONFIG_PLAT_MAPPI2)
 #define SIO0STS (volatile unsigned short *)(0xa0efd000 + 14)
 #define SIO0TXB (volatile unsigned short *)(0xa0efd000 + 30)
diff --git a/arch/m32r/kernel/ptrace.c b/arch/m32r/kernel/ptrace.c
index ed4d0756c5db..9aa615d3a5b2 100644
--- a/arch/m32r/kernel/ptrace.c
+++ b/arch/m32r/kernel/ptrace.c
@@ -476,7 +476,7 @@ unregister_debug_trap(struct task_struct *child, unsigned long addr,
                 return 0;
         }
 
-        /* Recover orignal instruction code. */
+        /* Recover original instruction code. */
         *code = p->insn[i];
 
         /* Shift debug trap entries. */
diff --git a/arch/m32r/kernel/syscall_table.S b/arch/m32r/kernel/syscall_table.S
index 95aa79874847..aa3bf4cfab37 100644
--- a/arch/m32r/kernel/syscall_table.S
+++ b/arch/m32r/kernel/syscall_table.S
@@ -321,6 +321,6 @@ ENTRY(sys_call_table)
         .long sys_epoll_pwait
         .long sys_utimensat             /* 320 */
         .long sys_signalfd
-        .long sys_timerfd
+        .long sys_ni_syscall
         .long sys_eventfd
         .long sys_fallocate
diff --git a/arch/m68k/Kconfig b/arch/m68k/Kconfig
index 01dee84f840a..ffabd01c45eb 100644
--- a/arch/m68k/Kconfig
+++ b/arch/m68k/Kconfig
@@ -145,11 +145,6 @@ config PCI
           your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
           VESA. If you have PCI, say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 config MAC
         bool "Macintosh support"
         depends on !MMU_SUN3
@@ -582,20 +577,6 @@ config MAC_HID
         depends on INPUT_ADBHID
         default y
 
-config MAC_ADBKEYCODES
-        bool "Support for ADB raw keycodes"
-        depends on INPUT_ADBHID
-        help
-          This provides support for sending raw ADB keycodes to console
-          devices.  This is the default up to 2.4.0, but in future this may be
-          phased out in favor of generic Linux keycodes.  If you say Y here,
-          you can dynamically switch via the
-          /proc/sys/dev/mac_hid/keyboard_sends_linux_keycodes
-          sysctl and with the "keyboard_sends_linux_keycodes=" kernel
-          argument.
-
-          If unsure, say Y here.
-
 config ADB_KEYBOARD
         bool "Support for ADB keyboard (old driver)"
         depends on MAC && !INPUT_ADBHID
@@ -683,8 +664,6 @@ endmenu
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/m68k/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/m68k/Makefile b/arch/m68k/Makefile
index 4a1bd44ff162..2cba605cb59d 100644
--- a/arch/m68k/Makefile
+++ b/arch/m68k/Makefile
@@ -13,16 +13,15 @@
 # Copyright (C) 1994 by Hamish Macdonald
 #
 
-# test for cross compiling
-COMPILE_ARCH = $(shell uname -m)
-
 # override top level makefile
 AS += -m68020
 LDFLAGS := -m m68kelf
 LDFLAGS_MODULE += -T $(srctree)/arch/m68k/kernel/module.lds
-ifneq ($(COMPILE_ARCH),$(ARCH))
-        # prefix for cross-compiling binaries
-        CROSS_COMPILE = m68k-linux-gnu-
+ifneq ($(SUBARCH),$(ARCH))
+        ifeq ($(CROSS_COMPILE),)
+                CROSS_COMPILE := $(call cc-cross-prefix, \
+                        m68k-linux-gnu- m68k-linux- m68k-unknown-linux-gnu-)
+        endif
 endif
 
 ifdef CONFIG_SUN3
diff --git a/arch/m68k/amiga/Makefile b/arch/m68k/amiga/Makefile
index 8b415651edee..6a0d7650f980 100644
--- a/arch/m68k/amiga/Makefile
+++ b/arch/m68k/amiga/Makefile
@@ -2,6 +2,6 @@
 # Makefile for Linux arch/m68k/amiga source directory
 #
 
-obj-y           := config.o amiints.o cia.o chipram.o amisound.o amiga_ksyms.o
+obj-y           := config.o amiints.o cia.o chipram.o amisound.o
 
 obj-$(CONFIG_AMIGA_PCMCIA)      += pcmcia.o
diff --git a/arch/m68k/amiga/amiga_ksyms.c b/arch/m68k/amiga/amiga_ksyms.c
deleted file mode 100644
index 7fdcf6bf3ada..000000000000
--- a/arch/m68k/amiga/amiga_ksyms.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <linux/module.h>
-#include <linux/types.h>
-#include <asm/ptrace.h>
-#include <asm/amigahw.h>
-#include <asm/amigaints.h>
-#include <asm/amipcmcia.h>
-
-extern volatile u_short amiga_audio_min_period;
-extern u_short amiga_audio_period;
-
-/*
- * Add things here when you find the need for it.
- */
-EXPORT_SYMBOL(amiga_model);
-EXPORT_SYMBOL(amiga_chipset);
-EXPORT_SYMBOL(amiga_hw_present);
-EXPORT_SYMBOL(amiga_eclock);
-EXPORT_SYMBOL(amiga_colorclock);
-EXPORT_SYMBOL(amiga_chip_alloc);
-EXPORT_SYMBOL(amiga_chip_free);
-EXPORT_SYMBOL(amiga_chip_avail);
-EXPORT_SYMBOL(amiga_chip_size);
-EXPORT_SYMBOL(amiga_audio_period);
-EXPORT_SYMBOL(amiga_audio_min_period);
-
-#ifdef CONFIG_AMIGA_PCMCIA
-  EXPORT_SYMBOL(pcmcia_reset);
-  EXPORT_SYMBOL(pcmcia_copy_tuple);
-  EXPORT_SYMBOL(pcmcia_program_voltage);
-  EXPORT_SYMBOL(pcmcia_access_speed);
-  EXPORT_SYMBOL(pcmcia_write_enable);
-  EXPORT_SYMBOL(pcmcia_write_disable);
-#endif
diff --git a/arch/m68k/amiga/amisound.c b/arch/m68k/amiga/amisound.c
index 1f5bfb584297..61e5c54625ae 100644
--- a/arch/m68k/amiga/amisound.c
+++ b/arch/m68k/amiga/amisound.c
@@ -12,6 +12,7 @@
 #include <linux/timer.h>
 #include <linux/init.h>
 #include <linux/string.h>
+#include <linux/module.h>
 
 #include <asm/system.h>
 #include <asm/amigahw.h>
@@ -21,7 +22,7 @@ static const signed char sine_data[] = {
         0,  39,  75,  103,  121,  127,  121,  103,  75,  39,
         0, -39, -75, -103, -121, -127, -121, -103, -75, -39
 };
-#define DATA_SIZE       (sizeof(sine_data)/sizeof(sine_data[0]))
+#define DATA_SIZE       ARRAY_SIZE(sine_data)
 
 #define custom amiga_custom
 
@@ -31,6 +32,7 @@ static const signed char sine_data[] = {
      */
 
 volatile unsigned short amiga_audio_min_period = 124; /* Default for pre-OCS */
+EXPORT_SYMBOL(amiga_audio_min_period);
 
 #define MAX_PERIOD      (65535)
 
@@ -40,6 +42,7 @@ volatile unsigned short amiga_audio_min_period = 124; /* Default for pre-OCS */
      */
 
 unsigned short amiga_audio_period = MAX_PERIOD;
+EXPORT_SYMBOL(amiga_audio_period);
 
 static unsigned long clock_constant;
 
diff --git a/arch/m68k/amiga/chipram.c b/arch/m68k/amiga/chipram.c
index fa015d801617..d10726f9038b 100644
--- a/arch/m68k/amiga/chipram.c
+++ b/arch/m68k/amiga/chipram.c
@@ -13,10 +13,13 @@
 #include <linux/ioport.h>
 #include <linux/slab.h>
 #include <linux/string.h>
+#include <linux/module.h>
+
 #include <asm/page.h>
 #include <asm/amigahw.h>
 
 unsigned long amiga_chip_size;
+EXPORT_SYMBOL(amiga_chip_size);
 
 static struct resource chipram_res = {
     .name = "Chip RAM", .start = CHIP_PHYSADDR
@@ -67,6 +70,7 @@ void *amiga_chip_alloc(unsigned long size, const char *name)
 #endif
     return (void *)ZTWO_VADDR(res->start);
 }
+EXPORT_SYMBOL(amiga_chip_alloc);
 
 
     /*
@@ -120,6 +124,7 @@ void amiga_chip_free(void *ptr)
     }
     printk("amiga_chip_free: trying to free nonexistent region at %p\n", ptr);
 }
+EXPORT_SYMBOL(amiga_chip_free);
 
 
 unsigned long amiga_chip_avail(void)
@@ -129,3 +134,5 @@ unsigned long amiga_chip_avail(void)
 #endif
         return chipavail;
 }
+EXPORT_SYMBOL(amiga_chip_avail);
+
diff --git a/arch/m68k/amiga/config.c b/arch/m68k/amiga/config.c
index 35748531327d..50f5daab46b7 100644
--- a/arch/m68k/amiga/config.c
+++ b/arch/m68k/amiga/config.c
@@ -23,6 +23,7 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/zorro.h>
+#include <linux/module.h>
 
 #include <asm/bootinfo.h>
 #include <asm/setup.h>
@@ -36,13 +37,24 @@
 #include <asm/io.h>
 
 unsigned long amiga_model;
+EXPORT_SYMBOL(amiga_model);
+
 unsigned long amiga_eclock;
+EXPORT_SYMBOL(amiga_eclock);
+
 unsigned long amiga_masterclock;
+
 unsigned long amiga_colorclock;
+EXPORT_SYMBOL(amiga_colorclock);
+
 unsigned long amiga_chipset;
+EXPORT_SYMBOL(amiga_chipset);
+
 unsigned char amiga_vblank;
 unsigned char amiga_psfreq;
+
 struct amiga_hw_present amiga_hw_present;
+EXPORT_SYMBOL(amiga_hw_present);
 
 static char s_a500[] __initdata = "A500";
 static char s_a500p[] __initdata = "A500+";
diff --git a/arch/m68k/amiga/pcmcia.c b/arch/m68k/amiga/pcmcia.c
index 186662ca1a89..7106f0c3639b 100644
--- a/arch/m68k/amiga/pcmcia.c
+++ b/arch/m68k/amiga/pcmcia.c
@@ -15,6 +15,8 @@
 #include <linux/types.h>
 #include <linux/jiffies.h>
 #include <linux/timer.h>
+#include <linux/module.h>
+
 #include <asm/amigayle.h>
 #include <asm/amipcmcia.h>
 
@@ -30,6 +32,7 @@ void pcmcia_reset(void)
         while (time_before(jiffies, reset_start_time + 1*HZ/100));
         b = gayle_reset;
 }
+EXPORT_SYMBOL(pcmcia_reset);
 
 
 /* copy a tuple, including tuple header. return nb bytes copied */
@@ -61,6 +64,7 @@ int pcmcia_copy_tuple(unsigned char tuple_id, void *tuple, int max_len)
 
         return 0;
 }
+EXPORT_SYMBOL(pcmcia_copy_tuple);
 
 void pcmcia_program_voltage(int voltage)
 {
@@ -84,6 +88,7 @@ void pcmcia_program_voltage(int voltage)
         gayle.config = cfg_byte;
 
 }
+EXPORT_SYMBOL(pcmcia_program_voltage);
 
 void pcmcia_access_speed(int speed)
 {
@@ -101,13 +106,17 @@ void pcmcia_access_speed(int speed)
         cfg_byte = (cfg_byte & 0xf3) | s;
         gayle.config = cfg_byte;
 }
+EXPORT_SYMBOL(pcmcia_access_speed);
 
 void pcmcia_write_enable(void)
 {
         gayle.cardstatus = GAYLE_CS_WR|GAYLE_CS_DA;
 }
+EXPORT_SYMBOL(pcmcia_write_enable);
 
 void pcmcia_write_disable(void)
 {
         gayle.cardstatus = 0;
 }
+EXPORT_SYMBOL(pcmcia_write_disable);
+
diff --git a/arch/m68k/atari/Makefile b/arch/m68k/atari/Makefile
index 2cb86191f0aa..2cd905efe63a 100644
--- a/arch/m68k/atari/Makefile
+++ b/arch/m68k/atari/Makefile
@@ -3,7 +3,7 @@
 #
 
 obj-y           := config.o time.o debug.o ataints.o stdma.o \
-                        atasound.o stram.o atari_ksyms.o
+                        atasound.o stram.o
 
 ifeq ($(CONFIG_PCI),y)
 obj-$(CONFIG_HADES)     += hades-pci.o
diff --git a/arch/m68k/atari/ataints.c b/arch/m68k/atari/ataints.c
index b85ca22024c1..b45593a60bdd 100644
--- a/arch/m68k/atari/ataints.c
+++ b/arch/m68k/atari/ataints.c
@@ -40,6 +40,7 @@
 #include <linux/kernel_stat.h>
 #include <linux/init.h>
 #include <linux/seq_file.h>
+#include <linux/module.h>
 
 #include <asm/system.h>
 #include <asm/traps.h>
@@ -446,6 +447,7 @@ unsigned long atari_register_vme_int(void)
         free_vme_vec_bitmap |= 1 << i;
         return VME_SOURCE_BASE + i;
 }
+EXPORT_SYMBOL(atari_register_vme_int);
 
 
 void atari_unregister_vme_int(unsigned long irq)
@@ -455,5 +457,6 @@ void atari_unregister_vme_int(unsigned long irq)
                 free_vme_vec_bitmap &= ~(1 << irq);
         }
 }
+EXPORT_SYMBOL(atari_unregister_vme_int);
 
 
diff --git a/arch/m68k/atari/atari_ksyms.c b/arch/m68k/atari/atari_ksyms.c
deleted file mode 100644
index a04757151538..000000000000
--- a/arch/m68k/atari/atari_ksyms.c
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <linux/module.h>
-
-#include <asm/ptrace.h>
-#include <asm/traps.h>
-#include <asm/atarihw.h>
-#include <asm/atariints.h>
-#include <asm/atarikb.h>
-#include <asm/atari_joystick.h>
-#include <asm/atari_stdma.h>
-#include <asm/atari_stram.h>
-
-extern void atari_microwire_cmd( int cmd );
-extern int atari_MFP_init_done;
-extern int atari_SCC_init_done;
-extern int atari_SCC_reset_done;
-
-EXPORT_SYMBOL(atari_mch_cookie);
-EXPORT_SYMBOL(atari_mch_type);
-EXPORT_SYMBOL(atari_hw_present);
-EXPORT_SYMBOL(atari_switches);
-EXPORT_SYMBOL(atari_dont_touch_floppy_select);
-EXPORT_SYMBOL(atari_register_vme_int);
-EXPORT_SYMBOL(atari_unregister_vme_int);
-EXPORT_SYMBOL(stdma_lock);
-EXPORT_SYMBOL(stdma_release);
-EXPORT_SYMBOL(stdma_others_waiting);
-EXPORT_SYMBOL(stdma_islocked);
-EXPORT_SYMBOL(atari_stram_alloc);
-EXPORT_SYMBOL(atari_stram_free);
-
-EXPORT_SYMBOL(atari_MFP_init_done);
-EXPORT_SYMBOL(atari_SCC_init_done);
-EXPORT_SYMBOL(atari_SCC_reset_done);
-
-EXPORT_SYMBOL(atari_microwire_cmd);
diff --git a/arch/m68k/atari/atasound.c b/arch/m68k/atari/atasound.c
index ee04250eb56b..d266fe89c125 100644
--- a/arch/m68k/atari/atasound.c
+++ b/arch/m68k/atari/atasound.c
@@ -22,6 +22,7 @@
 #include <linux/fcntl.h>
 #include <linux/errno.h>
 #include <linux/mm.h>
+#include <linux/module.h>
 
 #include <asm/atarihw.h>
 #include <asm/system.h>
@@ -43,6 +44,7 @@ void atari_microwire_cmd (int cmd)
         while( tt_microwire.mask != 0x7ff)
                 ;
 }
+EXPORT_SYMBOL(atari_microwire_cmd);
 
 
 /* PSG base frequency */
diff --git a/arch/m68k/atari/config.c b/arch/m68k/atari/config.c
index e40e5dcaa347..5945e1505558 100644
--- a/arch/m68k/atari/config.c
+++ b/arch/m68k/atari/config.c
@@ -31,6 +31,7 @@
 #include <linux/delay.h>
 #include <linux/ioport.h>
 #include <linux/vt_kern.h>
+#include <linux/module.h>
 
 #include <asm/bootinfo.h>
 #include <asm/setup.h>
@@ -43,10 +44,20 @@
 #include <asm/io.h>
 
 u_long atari_mch_cookie;
+EXPORT_SYMBOL(atari_mch_cookie);
+
 u_long atari_mch_type;
+EXPORT_SYMBOL(atari_mch_type);
+
 struct atari_hw_present atari_hw_present;
+EXPORT_SYMBOL(atari_hw_present);
+
 u_long atari_switches;
+EXPORT_SYMBOL(atari_switches);
+
 int atari_dont_touch_floppy_select;
+EXPORT_SYMBOL(atari_dont_touch_floppy_select);
+
 int atari_rtc_year_offset;
 
 /* local function prototypes */
diff --git a/arch/m68k/atari/debug.c b/arch/m68k/atari/debug.c
index fbeed8c8ecbc..043ddbc61c7b 100644
--- a/arch/m68k/atari/debug.c
+++ b/arch/m68k/atari/debug.c
@@ -15,17 +15,23 @@
 #include <linux/console.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#include <linux/module.h>
 
 #include <asm/atarihw.h>
 #include <asm/atariints.h>
 
 /* Flag that Modem1 port is already initialized and used */
 int atari_MFP_init_done;
+EXPORT_SYMBOL(atari_MFP_init_done);
+
 /* Flag that Modem1 port is already initialized and used */
 int atari_SCC_init_done;
+EXPORT_SYMBOL(atari_SCC_init_done);
+
 /* Can be set somewhere, if a SCC master reset has already be done and should
  * not be repeated; used by kgdb */
 int atari_SCC_reset_done;
+EXPORT_SYMBOL(atari_SCC_reset_done);
 
 static struct console atari_console_driver = {
         .name   = "debug",
diff --git a/arch/m68k/atari/hades-pci.c b/arch/m68k/atari/hades-pci.c
index bee2b1443e36..2bbabc008708 100644
--- a/arch/m68k/atari/hades-pci.c
+++ b/arch/m68k/atari/hades-pci.c
@@ -376,8 +376,8 @@ struct pci_bus_info * __init init_hades_pci(void)
          */
 
         bus = kzalloc(sizeof(struct pci_bus_info), GFP_KERNEL);
-        if (!bus)
-                return NULL;
+        if (unlikely(!bus))
+                goto iounmap_base_virt;
 
         /*
          * Claim resources. The m68k has no separate I/O space, both
@@ -385,43 +385,25 @@ struct pci_bus_info * __init init_hades_pci(void)
          * the I/O resources are requested in memory space as well.
          */
 
-        if (request_resource(&iomem_resource, &config_space) != 0)
-        {
-                kfree(bus);
-                return NULL;
-        }
+        if (unlikely(request_resource(&iomem_resource, &config_space) != 0))
+                goto free_bus;
 
-        if (request_resource(&iomem_resource, &io_space) != 0)
-        {
-                release_resource(&config_space);
-                kfree(bus);
-                return NULL;
-        }
+        if (unlikely(request_resource(&iomem_resource, &io_space) != 0))
+                goto release_config_space;
 
         bus->mem_space.start = HADES_MEM_BASE;
         bus->mem_space.end = HADES_MEM_BASE + HADES_MEM_SIZE - 1;
         bus->mem_space.name = pci_mem_name;
 #if 1
-        if (request_resource(&iomem_resource, &bus->mem_space) != 0)
-        {
-                release_resource(&io_space);
-                release_resource(&config_space);
-                kfree(bus);
-                return NULL;
-        }
+        if (unlikely(request_resource(&iomem_resource, &bus->mem_space) != 0))
+                goto release_io_space;
 #endif
         bus->io_space.start = pci_io_base_virt;
         bus->io_space.end = pci_io_base_virt + HADES_VIRT_IO_SIZE - 1;
         bus->io_space.name = pci_io_name;
 #if 1
-        if (request_resource(&ioport_resource, &bus->io_space) != 0)
-        {
-                release_resource(&bus->mem_space);
-                release_resource(&io_space);
-                release_resource(&config_space);
-                kfree(bus);
-                return NULL;
-        }
+        if (unlikely(request_resource(&ioport_resource, &bus->io_space) != 0))
+                goto release_bus_mem_space;
 #endif
         /*
          * Set hardware dependent functions.
@@ -438,5 +420,21 @@ struct pci_bus_info * __init init_hades_pci(void)
         tt_mfp.active_edge &= ~0x27;
 
         return bus;
+
+release_bus_mem_space:
+        release_resource(&bus->mem_space);
+release_io_space:
+        release_resource(&io_space);
+release_config_space:
+        release_resource(&config_space);
+free_bus:
+        kfree(bus);
+iounmap_base_virt:
+        iounmap((void *)pci_io_base_virt);
+
+        for (i = 0; i < N_SLOTS; i++)
+                iounmap((void *)pci_conf_base_virt[i]);
+
+        return NULL;
 }
 #endif
diff --git a/arch/m68k/atari/stdma.c b/arch/m68k/atari/stdma.c
index ab3fd5202b24..d1bd029a34ac 100644
--- a/arch/m68k/atari/stdma.c
+++ b/arch/m68k/atari/stdma.c
@@ -35,6 +35,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/wait.h>
+#include <linux/module.h>
 
 #include <asm/atari_stdma.h>
 #include <asm/atariints.h>
@@ -91,6 +92,7 @@ void stdma_lock(irq_handler_t handler, void *data)
         stdma_isr_data = data;
         local_irq_restore(flags);
 }
+EXPORT_SYMBOL(stdma_lock);
 
 
 /*
@@ -117,6 +119,7 @@ void stdma_release(void)
 
         local_irq_restore(flags);
 }
+EXPORT_SYMBOL(stdma_release);
 
 
 /*
@@ -134,6 +137,7 @@ int stdma_others_waiting(void)
 {
         return waitqueue_active(&stdma_wait);
 }
+EXPORT_SYMBOL(stdma_others_waiting);
 
 
 /*
@@ -155,6 +159,7 @@ int stdma_islocked(void)
 {
         return stdma_locked;
 }
+EXPORT_SYMBOL(stdma_islocked);
 
 
 /*
diff --git a/arch/m68k/atari/stram.c b/arch/m68k/atari/stram.c
index bf4588cbe371..8dda6515887a 100644
--- a/arch/m68k/atari/stram.c
+++ b/arch/m68k/atari/stram.c
@@ -20,6 +20,7 @@
 #include <linux/bootmem.h>
 #include <linux/mount.h>
 #include <linux/blkdev.h>
+#include <linux/module.h>
 
 #include <asm/setup.h>
 #include <asm/machdep.h>
@@ -208,6 +209,7 @@ void *atari_stram_alloc(long size, const char *owner)
         }
         return( addr );
 }
+EXPORT_SYMBOL(atari_stram_alloc);
 
 void atari_stram_free( void *addr )
 
@@ -237,6 +239,7 @@ void atari_stram_free( void *addr )
         printk( KERN_ERR "atari_stram_free: cannot free block at %p "
                         "(called from %p)\n", addr, __builtin_return_address(0) );
 }
+EXPORT_SYMBOL(atari_stram_free);
 
 
 /* ------------------------------------------------------------------------ */
diff --git a/arch/m68k/configs/mac_defconfig b/arch/m68k/configs/mac_defconfig
index 15b80abfe94a..ff9dffa5b860 100644
--- a/arch/m68k/configs/mac_defconfig
+++ b/arch/m68k/configs/mac_defconfig
@@ -678,7 +678,6 @@ CONFIG_LOGO_MAC_CLUT224=y
 #
 CONFIG_MAC_SCC=y
 CONFIG_MAC_HID=y
-CONFIG_MAC_ADBKEYCODES=y
 CONFIG_SERIAL_CONSOLE=y
 
 #
diff --git a/arch/m68k/hp300/Makefile b/arch/m68k/hp300/Makefile
index 288b9c67c9bf..96d4244c82fd 100644
--- a/arch/m68k/hp300/Makefile
+++ b/arch/m68k/hp300/Makefile
@@ -2,4 +2,4 @@
 # Makefile for Linux arch/m68k/hp300 source directory
 #
 
-obj-y           := ksyms.o config.o time.o reboot.o
+obj-y           := config.o time.o reboot.o
diff --git a/arch/m68k/hp300/ksyms.c b/arch/m68k/hp300/ksyms.c
deleted file mode 100644
index 8202830763d1..000000000000
--- a/arch/m68k/hp300/ksyms.c
+++ /dev/null
@@ -1,9 +0,0 @@
-/*
- *  linux/arch/m68k/hp300/ksyms.c
- *
- *  Copyright (C) 1998 Philip Blundell <philb@gnu.org>
- *
- *  This file contains the HP300-specific kernel symbols.  None yet. :-)
- */
-
-#include <linux/module.h>
diff --git a/arch/m68k/kernel/entry.S b/arch/m68k/kernel/entry.S
index 918f5dbeaef6..6dfa3b3c0e2a 100644
--- a/arch/m68k/kernel/entry.S
+++ b/arch/m68k/kernel/entry.S
@@ -742,7 +742,7 @@ sys_call_table:
         .long sys_epoll_pwait           /* 315 */
         .long sys_utimensat
         .long sys_signalfd
-        .long sys_timerfd
+        .long sys_ni_syscall
         .long sys_eventfd
         .long sys_fallocate             /* 320 */
 
diff --git a/arch/m68k/mac/Makefile b/arch/m68k/mac/Makefile
index 995a09d912f5..1d265ba365ad 100644
--- a/arch/m68k/mac/Makefile
+++ b/arch/m68k/mac/Makefile
@@ -3,4 +3,4 @@
 #
 
 obj-y           := config.o bootparse.o macints.o iop.o via.o oss.o psc.o \
-                        baboon.o macboing.o debug.o misc.o mac_ksyms.o
+                        baboon.o macboing.o debug.o misc.o
diff --git a/arch/m68k/mac/config.c b/arch/m68k/mac/config.c
index 01b468b9392e..735a49b4b936 100644
--- a/arch/m68k/mac/config.c
+++ b/arch/m68k/mac/config.c
@@ -58,8 +58,6 @@ extern struct mem_info m68k_memory[NUM_MEMINFO];
 
 extern struct mem_info m68k_ramdisk;
 
-extern char m68k_command_line[CL_SIZE];
-
 void *mac_env;                                  /* Loaded by the boot asm */
 
 /* The phys. video addr. - might be bogus on some machines */
diff --git a/arch/m68k/mac/mac_ksyms.c b/arch/m68k/mac/mac_ksyms.c
deleted file mode 100644
index 6e37ceb0f3b5..000000000000
--- a/arch/m68k/mac/mac_ksyms.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <linux/module.h>
-#include <asm/ptrace.h>
-#include <asm/traps.h>
-
-/* Says whether we're using A/UX interrupts or not */
-extern int via_alt_mapping;
-
-EXPORT_SYMBOL(via_alt_mapping);
diff --git a/arch/m68k/mac/via.c b/arch/m68k/mac/via.c
index 8df270e950fa..fa485df4160e 100644
--- a/arch/m68k/mac/via.c
+++ b/arch/m68k/mac/via.c
@@ -28,6 +28,7 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/ide.h>
+#include <linux/module.h>
 
 #include <asm/bootinfo.h>
 #include <asm/macintosh.h>
@@ -41,7 +42,9 @@ volatile __u8 *via1, *via2;
 /* See note in mac_via.h about how this is possibly not useful */
 volatile long *via_memory_bogon=(long *)&via_memory_bogon;
 #endif
-int rbv_present, via_alt_mapping;
+int rbv_present;
+int via_alt_mapping;
+EXPORT_SYMBOL(via_alt_mapping);
 __u8 rbv_clear;
 
 /*
diff --git a/arch/m68k/mvme16x/Makefile b/arch/m68k/mvme16x/Makefile
index 950e82f21640..edb3f6e6ee6a 100644
--- a/arch/m68k/mvme16x/Makefile
+++ b/arch/m68k/mvme16x/Makefile
@@ -2,4 +2,4 @@
 # Makefile for Linux arch/m68k/mvme16x source directory
 #
 
-obj-y           := config.o rtc.o mvme16x_ksyms.o
+obj-y           := config.o rtc.o
diff --git a/arch/m68k/mvme16x/config.c b/arch/m68k/mvme16x/config.c
index daa785161401..24cbc3030454 100644
--- a/arch/m68k/mvme16x/config.c
+++ b/arch/m68k/mvme16x/config.c
@@ -25,6 +25,7 @@
 #include <linux/genhd.h>
 #include <linux/rtc.h>
 #include <linux/interrupt.h>
+#include <linux/module.h>
 
 #include <asm/bootinfo.h>
 #include <asm/system.h>
@@ -58,6 +59,7 @@ static irq_handler_t tick_handler;
 
 
 unsigned short mvme16x_config;
+EXPORT_SYMBOL(mvme16x_config);
 
 
 int mvme16x_parse_bootinfo(const struct bi_record *bi)
diff --git a/arch/m68k/mvme16x/mvme16x_ksyms.c b/arch/m68k/mvme16x/mvme16x_ksyms.c
deleted file mode 100644
index 4a8a3634bb47..000000000000
--- a/arch/m68k/mvme16x/mvme16x_ksyms.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <linux/module.h>
-#include <linux/types.h>
-#include <asm/ptrace.h>
-#include <asm/mvme16xhw.h>
-
-EXPORT_SYMBOL(mvme16x_config);
diff --git a/arch/m68knommu/Kconfig b/arch/m68knommu/Kconfig
index f4b582cbb567..6abbbb8aac5e 100644
--- a/arch/m68knommu/Kconfig
+++ b/arch/m68knommu/Kconfig
@@ -53,6 +53,10 @@ config GENERIC_CALIBRATE_DELAY
         bool
         default y
 
+config GENERIC_TIME
+        bool
+        default y
+
 config TIME_LOW_RES
         bool
         default y
@@ -707,8 +711,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/m68knommu/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/m68knommu/Kconfig.debug b/arch/m68knommu/Kconfig.debug
index 9ff47bd09aee..ed6d9a83bfdb 100644
--- a/arch/m68knommu/Kconfig.debug
+++ b/arch/m68knommu/Kconfig.debug
@@ -21,13 +21,6 @@ config BOOTPARAM_STRING
         default 'console=ttyS0,19200'
         depends on BOOTPARAM
 
-config DUMPTOFLASH
-        bool "Panic/Dump to FLASH"
-        depends on COLDFIRE
-        help
-          Dump any panic of trap output into a flash memory segment
-          for later analysis.
-
 config NO_KERNEL_MSG
         bool "Suppress Kernel BUG Messages"
         help
diff --git a/arch/m68knommu/Makefile b/arch/m68knommu/Makefile
index 30aa2553693d..e0b5f62e395c 100644
--- a/arch/m68knommu/Makefile
+++ b/arch/m68knommu/Makefile
@@ -61,17 +61,17 @@ MODEL := $(model-y)
 # for the selected cpu. ONLY need to define this for the non-base member
 # of the family.
 #
-cpuclass-$(CONFIG_M5206)        := 5307
-cpuclass-$(CONFIG_M5206e)       := 5307
-cpuclass-$(CONFIG_M520x)        := 5307
-cpuclass-$(CONFIG_M523x)        := 5307
-cpuclass-$(CONFIG_M5249)        := 5307
-cpuclass-$(CONFIG_M527x)        := 5307
-cpuclass-$(CONFIG_M5272)        := 5307
-cpuclass-$(CONFIG_M528x)        := 5307
-cpuclass-$(CONFIG_M5307)        := 5307
-cpuclass-$(CONFIG_M532x)        := 5307
-cpuclass-$(CONFIG_M5407)        := 5307
+cpuclass-$(CONFIG_M5206)        := coldfire
+cpuclass-$(CONFIG_M5206e)       := coldfire
+cpuclass-$(CONFIG_M520x)        := coldfire
+cpuclass-$(CONFIG_M523x)        := coldfire
+cpuclass-$(CONFIG_M5249)        := coldfire
+cpuclass-$(CONFIG_M527x)        := coldfire
+cpuclass-$(CONFIG_M5272)        := coldfire
+cpuclass-$(CONFIG_M528x)        := coldfire
+cpuclass-$(CONFIG_M5307)        := coldfire
+cpuclass-$(CONFIG_M532x)        := coldfire
+cpuclass-$(CONFIG_M5407)        := coldfire
 cpuclass-$(CONFIG_M68328)       := 68328
 cpuclass-$(CONFIG_M68EZ328)     := 68328
 cpuclass-$(CONFIG_M68VZ328)     := 68328
diff --git a/arch/m68knommu/defconfig b/arch/m68knommu/defconfig
index 5a0ecaaee3b0..648113075f97 100644
--- a/arch/m68knommu/defconfig
+++ b/arch/m68knommu/defconfig
@@ -597,7 +597,6 @@ CONFIG_MSDOS_PARTITION=y
 # CONFIG_FULLDEBUG is not set
 # CONFIG_HIGHPROFILE is not set
 # CONFIG_BOOTPARAM is not set
-# CONFIG_DUMPTOFLASH is not set
 # CONFIG_NO_KERNEL_MSG is not set
 # CONFIG_BDM_DISABLE is not set
 
diff --git a/arch/m68knommu/kernel/m68k_ksyms.c b/arch/m68knommu/kernel/m68k_ksyms.c
index f795062aba1e..53fad1490282 100644
--- a/arch/m68knommu/kernel/m68k_ksyms.c
+++ b/arch/m68knommu/kernel/m68k_ksyms.c
@@ -24,14 +24,6 @@ extern int dump_fpu(struct pt_regs *, elf_fpregset_t *);
 EXPORT_SYMBOL(__ioremap);
 EXPORT_SYMBOL(iounmap);
 EXPORT_SYMBOL(dump_fpu);
-EXPORT_SYMBOL(strnlen);
-EXPORT_SYMBOL(strrchr);
-EXPORT_SYMBOL(strstr);
-EXPORT_SYMBOL(strchr);
-EXPORT_SYMBOL(strcat);
-EXPORT_SYMBOL(strlen);
-EXPORT_SYMBOL(strcmp);
-EXPORT_SYMBOL(strncmp);
 
 EXPORT_SYMBOL(ip_fast_csum);
 
@@ -46,9 +38,6 @@ EXPORT_SYMBOL(csum_partial_copy_nocheck);
    it's OK to leave it out of version control.  */
 EXPORT_SYMBOL(memcpy);
 EXPORT_SYMBOL(memset);
-EXPORT_SYMBOL(memcmp);
-EXPORT_SYMBOL(memscan);
-EXPORT_SYMBOL(memmove);
 
 EXPORT_SYMBOL(__down_failed);
 EXPORT_SYMBOL(__down_failed_interruptible);
diff --git a/arch/m68knommu/kernel/setup.c b/arch/m68knommu/kernel/setup.c
index 332345d7675d..81507c53d4a9 100644
--- a/arch/m68knommu/kernel/setup.c
+++ b/arch/m68knommu/kernel/setup.c
@@ -64,9 +64,6 @@ void (*mach_power_off)(void);
 #ifdef CONFIG_M68VZ328
         #define CPU "MC68VZ328"
 #endif
-#ifdef CONFIG_M68332
-        #define CPU "MC68332"
-#endif
 #ifdef CONFIG_M68360
         #define CPU "MC68360"
 #endif
diff --git a/arch/m68knommu/kernel/syscalltable.S b/arch/m68knommu/kernel/syscalltable.S
index 9620093514bc..1b02b8820068 100644
--- a/arch/m68knommu/kernel/syscalltable.S
+++ b/arch/m68knommu/kernel/syscalltable.S
@@ -336,7 +336,7 @@ ENTRY(sys_call_table)
         .long sys_epoll_pwait           /* 315 */
         .long sys_utimensat
         .long sys_signalfd
-        .long sys_timerfd
+        .long sys_ni_syscall
         .long sys_eventfd
         .long sys_fallocate             /* 320 */
 
diff --git a/arch/m68knommu/kernel/time.c b/arch/m68knommu/kernel/time.c
index 77e5375a2dd5..89cdbcaeb45f 100644
--- a/arch/m68knommu/kernel/time.c
+++ b/arch/m68knommu/kernel/time.c
@@ -22,7 +22,6 @@
 #include <linux/timex.h>
 
 #include <asm/machdep.h>
-#include <asm/io.h>
 #include <asm/irq_regs.h>
 
 #define TICK_SIZE (tick_nsec / 1000)
@@ -66,29 +65,6 @@ irqreturn_t arch_timer_interrupt(int irq, void *dummy)
           else
             last_rtc_update = xtime.tv_sec - 600; /* do it again in 60 s */
         }
-#ifdef CONFIG_HEARTBEAT
-        /* use power LED as a heartbeat instead -- much more useful
-           for debugging -- based on the version for PReP by Cort */
-        /* acts like an actual heart beat -- ie thump-thump-pause... */
-        if (mach_heartbeat) {
-            static unsigned cnt = 0, period = 0, dist = 0;
-
-            if (cnt == 0 || cnt == dist)
-                mach_heartbeat( 1 );
-            else if (cnt == 7 || cnt == dist+7)
-                mach_heartbeat( 0 );
-
-            if (++cnt > period) {
-                cnt = 0;
-                /* The hyperbolic function below modifies the heartbeat period
-                 * length in dependency of the current (5min) load. It goes
-                 * through the points f(0)=126, f(1)=86, f(5)=51,
-                 * f(inf)->30. */
-                period = ((672<<FSHIFT)/(5*avenrun[0]+(7<<FSHIFT))) + 30;
-                dist = period / 4;
-            }
-        }
-#endif /* CONFIG_HEARTBEAT */
 
         write_sequnlock(&xtime_lock);
         return(IRQ_HANDLED);
@@ -112,60 +88,3 @@ void time_init(void)
         hw_timer_init();
 }
 
-/*
- * This version of gettimeofday has near microsecond resolution.
- */
-void do_gettimeofday(struct timeval *tv)
-{
-        unsigned long flags;
-        unsigned long seq;
-        unsigned long usec, sec;
-
-        do {
-                seq = read_seqbegin_irqsave(&xtime_lock, flags);
-                usec = hw_timer_offset();
-                sec = xtime.tv_sec;
-                usec += (xtime.tv_nsec / 1000);
-        } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
-
-        while (usec >= 1000000) {
-                usec -= 1000000;
-                sec++;
-        }
-
-        tv->tv_sec = sec;
-        tv->tv_usec = usec;
-}
-
-EXPORT_SYMBOL(do_gettimeofday);
-
-int do_settimeofday(struct timespec *tv)
-{
-        time_t wtm_sec, sec = tv->tv_sec;
-        long wtm_nsec, nsec = tv->tv_nsec;
-
-        if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
-                return -EINVAL;
-
-        write_seqlock_irq(&xtime_lock);
-        /*
-         * This is revolting. We need to set the xtime.tv_usec
-         * correctly. However, the value in this location is
-         * is value at the last tick.
-         * Discover what correction gettimeofday
-         * would have done, and then undo it!
-         */
-        nsec -= (hw_timer_offset() * 1000);
-
-        wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
-        wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
-
-        set_normalized_timespec(&xtime, sec, nsec);
-        set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
-
-        ntp_clear();
-        write_sequnlock_irq(&xtime_lock);
-        clock_was_set();
-        return 0;
-}
-EXPORT_SYMBOL(do_settimeofday);
diff --git a/arch/m68knommu/platform/5206/config.c b/arch/m68knommu/platform/5206/config.c
index b3c4dd4cc135..53a5920c2b71 100644
--- a/arch/m68knommu/platform/5206/config.c
+++ b/arch/m68knommu/platform/5206/config.c
@@ -13,12 +13,11 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
-#include <asm/mcftimer.h>
 #include <asm/mcfsim.h>
-#include <asm/mcfdma.h>
+#include <asm/mcfuart.h>
 
 /***************************************************************************/
 
@@ -26,15 +25,51 @@ void coldfire_reset(void);
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
-        MCF_MBAR + MCFDMA_BASE1,
+static struct mcf_platform_uart m5206_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = 73,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = 74,
+        },
+        { },
+};
+
+static struct platform_device m5206_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m5206_uart_platform,
+};
+
+static struct platform_device *m5206_devices[] __initdata = {
+        &m5206_uart,
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+/***************************************************************************/
+
+static void __init m5206_uart_init_line(int line, int irq)
+{
+        if (line == 0) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI1, MCF_MBAR + MCFSIM_UART1ICR);
+                writeb(irq, MCFUART_BASE1 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART1);
+        } else if (line == 1) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI2, MCF_MBAR + MCFSIM_UART2ICR);
+                writeb(irq, MCFUART_BASE2 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART2);
+        }
+}
+
+static void __init m5206_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m5206_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m5206_uart_init_line(line, m5206_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -74,24 +109,21 @@ void mcf_settimericr(unsigned int timer, unsigned int level)
 
 /***************************************************************************/
 
-int mcf_timerirqpending(int timer)
+void __init config_BSP(char *commandp, int size)
 {
-        unsigned int imr = 0;
-
-        switch (timer) {
-        case 1:  imr = MCFSIM_IMR_TIMER1; break;
-        case 2:  imr = MCFSIM_IMR_TIMER2; break;
-        default: break;
-        }
-        return (mcf_getipr() & imr);
+        mcf_setimr(MCFSIM_IMR_MASKALL);
+        mach_reset = coldfire_reset;
 }
 
 /***************************************************************************/
 
-void config_BSP(char *commandp, int size)
+static int __init init_BSP(void)
 {
-        mcf_setimr(MCFSIM_IMR_MASKALL);
-        mach_reset = coldfire_reset;
+        m5206_uarts_init();
+        platform_add_devices(m5206_devices, ARRAY_SIZE(m5206_devices));
+        return 0;
 }
 
+arch_initcall(init_BSP);
+
 /***************************************************************************/
diff --git a/arch/m68knommu/platform/5206e/config.c b/arch/m68knommu/platform/5206e/config.c
index f84a4aea8cb6..a6692e958f6b 100644
--- a/arch/m68knommu/platform/5206e/config.c
+++ b/arch/m68knommu/platform/5206e/config.c
@@ -10,8 +10,9 @@
 
 #include <linux/kernel.h>
 #include <linux/param.h>
+#include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
@@ -23,15 +24,51 @@ void coldfire_reset(void);
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
-        MCF_MBAR + MCFDMA_BASE1,
+static struct mcf_platform_uart m5206e_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = 73,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = 74,
+        },
+        { },
+};
+
+static struct platform_device m5206e_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m5206e_uart_platform,
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+static struct platform_device *m5206e_devices[] __initdata = {
+        &m5206e_uart,
+};
+
+/***************************************************************************/
+
+static void __init m5206_uart_init_line(int line, int irq)
+{
+        if (line == 0) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI1, MCF_MBAR + MCFSIM_UART1ICR);
+                writeb(irq, MCFUART_BASE1 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART1);
+        } else if (line == 1) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI2, MCF_MBAR + MCFSIM_UART2ICR);
+                writeb(irq, MCFUART_BASE2 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART2);
+        }
+}
+
+static void __init m5206e_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m5206e_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m5206e_uart_init_line(line, m5206e_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -71,21 +108,7 @@ void mcf_settimericr(unsigned int timer, unsigned int level)
 
 /***************************************************************************/
 
-int mcf_timerirqpending(int timer)
-{
-        unsigned int imr = 0;
-
-        switch (timer) {
-        case 1:  imr = MCFSIM_IMR_TIMER1; break;
-        case 2:  imr = MCFSIM_IMR_TIMER2; break;
-        default: break;
-        }
-        return (mcf_getipr() & imr);
-}
-
-/***************************************************************************/
-
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
         mcf_setimr(MCFSIM_IMR_MASKALL);
 
@@ -99,3 +122,14 @@ void config_BSP(char *commandp, int size)
 }
 
 /***************************************************************************/
+
+static int __init init_BSP(void)
+{
+        m5206e_uarts_init();
+        platform_add_devices(m5206e_devices, ARRAY_SIZE(m5206e_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/520x/config.c b/arch/m68knommu/platform/520x/config.c
index 6edbd41261cc..06d887cdcbfb 100644
--- a/arch/m68knommu/platform/520x/config.c
+++ b/arch/m68knommu/platform/520x/config.c
@@ -5,7 +5,7 @@
  *
  *  Copyright (C) 2005,      Freescale (www.freescale.com)
  *  Copyright (C) 2005,      Intec Automation (mike@steroidmicros.com)
- *  Copyright (C) 1999-2003, Greg Ungerer (gerg@snapgear.com)
+ *  Copyright (C) 1999-2007, Greg Ungerer (gerg@snapgear.com)
  *  Copyright (C) 2001-2003, SnapGear Inc. (www.snapgear.com)
  */
 
@@ -13,21 +13,93 @@
 
 #include <linux/kernel.h>
 #include <linux/param.h>
+#include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
-#include <asm/dma.h>
+#include <asm/coldfire.h>
+#include <asm/mcfsim.h>
+#include <asm/mcfuart.h>
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int dma_base_addr[MAX_M68K_DMA_CHANNELS];
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+void coldfire_reset(void);
 
 /***************************************************************************/
 
-void coldfire_reset(void);
+static struct mcf_platform_uart m520x_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = MCFINT_VECBASE + MCFINT_UART1,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE3,
+                .irq            = MCFINT_VECBASE + MCFINT_UART2,
+        },
+        { },
+};
+
+static struct platform_device m520x_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m520x_uart_platform,
+};
+
+static struct platform_device *m520x_devices[] __initdata = {
+        &m520x_uart,
+};
+
+/***************************************************************************/
+
+#define INTC0   (MCF_MBAR + MCFICM_INTC0)
+
+static void __init m520x_uart_init_line(int line, int irq)
+{
+        u32 imr;
+        u16 par;
+        u8 par2;
+
+        writeb(0x03, INTC0 + MCFINTC_ICR0 + MCFINT_UART0 + line);
+
+        imr = readl(INTC0 + MCFINTC_IMRL);
+        imr &= ~((1 << (irq - MCFINT_VECBASE)) | 1);
+        writel(imr, INTC0 + MCFINTC_IMRL);
+
+        switch (line) {
+        case 0:
+                par = readw(MCF_IPSBAR + MCF_GPIO_PAR_UART);
+                par |= MCF_GPIO_PAR_UART_PAR_UTXD0 |
+                       MCF_GPIO_PAR_UART_PAR_URXD0;
+                writew(par, MCF_IPSBAR + MCF_GPIO_PAR_UART);
+                break;
+        case 1:
+                par = readw(MCF_IPSBAR + MCF_GPIO_PAR_UART);
+                par |= MCF_GPIO_PAR_UART_PAR_UTXD1 |
+                       MCF_GPIO_PAR_UART_PAR_URXD1;
+                writew(par, MCF_IPSBAR + MCF_GPIO_PAR_UART);
+                break;
+        case 2:
+                par2 = readb(MCF_IPSBAR + MCF_GPIO_PAR_FECI2C);
+                par2 &= ~0x0F;
+                par2 |= MCF_GPIO_PAR_FECI2C_PAR_SCL_UTXD2 |
+                        MCF_GPIO_PAR_FECI2C_PAR_SDA_URXD2;
+                writeb(par2, MCF_IPSBAR + MCF_GPIO_PAR_FECI2C);
+                break;
+        }
+}
+
+static void __init m520x_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m520x_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m520x_uart_init_line(line, m520x_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -42,9 +114,20 @@ void mcf_autovector(unsigned int vec)
 
 /***************************************************************************/
 
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
         mach_reset = coldfire_reset;
+        m520x_uarts_init();
 }
 
 /***************************************************************************/
+
+static int __init init_BSP(void)
+{
+        platform_add_devices(m520x_devices, ARRAY_SIZE(m520x_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/523x/config.c b/arch/m68knommu/platform/523x/config.c
index e7f80c8e8636..13f02611ea23 100644
--- a/arch/m68knommu/platform/523x/config.c
+++ b/arch/m68knommu/platform/523x/config.c
@@ -16,11 +16,11 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
-#include <asm/mcfdma.h>
+#include <asm/mcfuart.h>
 
 /***************************************************************************/
 
@@ -28,14 +28,58 @@ void coldfire_reset(void);
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
+static struct mcf_platform_uart m523x_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0 + 1,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE3,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0 + 2,
+        },
+        { },
+};
+
+static struct platform_device m523x_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m523x_uart_platform,
+};
+
+static struct platform_device *m523x_devices[] __initdata = {
+        &m523x_uart,
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+/***************************************************************************/
+
+#define INTC0   (MCF_MBAR + MCFICM_INTC0)
+
+static void __init m523x_uart_init_line(int line, int irq)
+{
+        u32 imr;
+
+        if ((line < 0) || (line > 2))
+                return;
+
+        writeb(0x30+line, (INTC0 + MCFINTC_ICR0 + MCFINT_UART0 + line));
+
+        imr = readl(INTC0 + MCFINTC_IMRL);
+        imr &= ~((1 << (irq - MCFINT_VECBASE)) | 1);
+        writel(imr, INTC0 + MCFINTC_IMRL);
+}
+
+static void __init m523x_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m523x_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m523x_uart_init_line(line, m523x_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -49,15 +93,26 @@ void mcf_disableall(void)
 
 void mcf_autovector(unsigned int vec)
 {
-        /* Everything is auto-vectored on the 5272 */
+        /* Everything is auto-vectored on the 523x */
 }
 
 /***************************************************************************/
 
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
         mcf_disableall();
         mach_reset = coldfire_reset;
+        m523x_uarts_init();
 }
 
 /***************************************************************************/
+
+static int __init init_BSP(void)
+{
+        platform_add_devices(m523x_devices, ARRAY_SIZE(m523x_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/5249/config.c b/arch/m68knommu/platform/5249/config.c
index d4d39435cb15..d299f7b8768a 100644
--- a/arch/m68knommu/platform/5249/config.c
+++ b/arch/m68knommu/platform/5249/config.c
@@ -12,11 +12,11 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
-#include <asm/mcfdma.h>
+#include <asm/mcfuart.h>
 
 /***************************************************************************/
 
@@ -24,17 +24,51 @@ void coldfire_reset(void);
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
-        MCF_MBAR + MCFDMA_BASE1,
-        MCF_MBAR + MCFDMA_BASE2,
-        MCF_MBAR + MCFDMA_BASE3,
+static struct mcf_platform_uart m5249_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = 73,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = 74,
+        }
+};
+
+static struct platform_device m5249_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m5249_uart_platform,
+};
+
+static struct platform_device *m5249_devices[] __initdata = {
+        &m5249_uart,
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+/***************************************************************************/
+
+static void __init m5249_uart_init_line(int line, int irq)
+{
+        if (line == 0) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI1, MCF_MBAR + MCFSIM_UART1ICR);
+                writeb(irq, MCFUART_BASE1 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART1);
+        } else if (line == 1) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI2, MCF_MBAR + MCFSIM_UART2ICR);
+                writeb(irq, MCFUART_BASE2 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART2);
+        }
+}
+
+static void __init m5249_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m5249_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m5249_uart_init_line(line, m5249_uart_platform[line].irq);
+}
+
 
 /***************************************************************************/
 
@@ -71,24 +105,21 @@ void mcf_settimericr(unsigned int timer, unsigned int level)
 
 /***************************************************************************/
 
-int mcf_timerirqpending(int timer)
+void __init config_BSP(char *commandp, int size)
 {
-        unsigned int imr = 0;
-
-        switch (timer) {
-        case 1:  imr = MCFSIM_IMR_TIMER1; break;
-        case 2:  imr = MCFSIM_IMR_TIMER2; break;
-        default: break;
-        }
-        return (mcf_getipr() & imr);
+        mcf_setimr(MCFSIM_IMR_MASKALL);
+        mach_reset = coldfire_reset;
 }
 
 /***************************************************************************/
 
-void config_BSP(char *commandp, int size)
+static int __init init_BSP(void)
 {
-        mcf_setimr(MCFSIM_IMR_MASKALL);
-        mach_reset = coldfire_reset;
+        m5249_uarts_init();
+        platform_add_devices(m5249_devices, ARRAY_SIZE(m5249_devices));
+        return 0;
 }
 
+arch_initcall(init_BSP);
+
 /***************************************************************************/
diff --git a/arch/m68knommu/platform/5272/config.c b/arch/m68knommu/platform/5272/config.c
index 634a6375e4a5..2aca599a1ca7 100644
--- a/arch/m68knommu/platform/5272/config.c
+++ b/arch/m68knommu/platform/5272/config.c
@@ -13,11 +13,11 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
-#include <asm/mcfdma.h>
+#include <asm/mcfuart.h>
 
 /***************************************************************************/
 
@@ -37,14 +37,57 @@ unsigned char ledbank = 0xff;
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
+static struct mcf_platform_uart m5272_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = 73,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = 74,
+        },
+        { },
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+static struct platform_device m5272_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m5272_uart_platform,
+};
+
+static struct platform_device *m5272_devices[] __initdata = {
+        &m5272_uart,
+};
+
+/***************************************************************************/
+
+static void __init m5272_uart_init_line(int line, int irq)
+{
+        u32 v;
+
+        if ((line >= 0) && (line < 2)) {
+                v = (line) ? 0x0e000000 : 0xe0000000;
+                writel(v, MCF_MBAR + MCFSIM_ICR2);
+
+                /* Enable the output lines for the serial ports */
+                v = readl(MCF_MBAR + MCFSIM_PBCNT);
+                v = (v & ~0x000000ff) | 0x00000055;
+                writel(v, MCF_MBAR + MCFSIM_PBCNT);
+
+                v = readl(MCF_MBAR + MCFSIM_PDCNT);
+                v = (v & ~0x000003fc) | 0x000002a8;
+                writel(v, MCF_MBAR + MCFSIM_PDCNT);
+        }
+}
+
+static void __init m5272_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m5272_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m5272_uart_init_line(line, m5272_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -80,20 +123,7 @@ void mcf_settimericr(int timer, int level)
 
 /***************************************************************************/
 
-int mcf_timerirqpending(int timer)
-{
-        volatile unsigned long *icrp;
-
-        if ((timer >= 1 ) && (timer <= 4)) {
-                icrp = (volatile unsigned long *) (MCF_MBAR + MCFSIM_ICR1);
-                return (*icrp & (0x8 << ((4 - timer) * 4)));
-        }
-        return 0;
-}
-
-/***************************************************************************/
-
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
 #if defined (CONFIG_MOD5272)
         volatile unsigned char  *pivrp;
@@ -125,3 +155,14 @@ void config_BSP(char *commandp, int size)
 }
 
 /***************************************************************************/
+
+static int __init init_BSP(void)
+{
+        m5272_uarts_init();
+        platform_add_devices(m5272_devices, ARRAY_SIZE(m5272_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/527x/config.c b/arch/m68knommu/platform/527x/config.c
index 9cbfbc68ae4f..73cd1aef4a90 100644
--- a/arch/m68knommu/platform/527x/config.c
+++ b/arch/m68knommu/platform/527x/config.c
@@ -16,11 +16,11 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
-#include <asm/mcfdma.h>
+#include <asm/mcfuart.h>
 
 /***************************************************************************/
 
@@ -28,14 +28,72 @@ void coldfire_reset(void);
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
+static struct mcf_platform_uart m527x_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = MCFINT_VECBASE + MCFINT_UART1,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE3,
+                .irq            = MCFINT_VECBASE + MCFINT_UART2,
+        },
+        { },
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+static struct platform_device m527x_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m527x_uart_platform,
+};
+
+static struct platform_device *m527x_devices[] __initdata = {
+        &m527x_uart,
+};
+
+/***************************************************************************/
+
+#define INTC0   (MCF_MBAR + MCFICM_INTC0)
+
+static void __init m527x_uart_init_line(int line, int irq)
+{
+        u16 sepmask;
+        u32 imr;
+
+        if ((line < 0) || (line > 2))
+                return;
+
+        /* level 6, line based priority */
+        writeb(0x30+line, INTC0 + MCFINTC_ICR0 + MCFINT_UART0 + line);
+
+        imr = readl(INTC0 + MCFINTC_IMRL);
+        imr &= ~((1 << (irq - MCFINT_VECBASE)) | 1);
+        writel(imr, INTC0 + MCFINTC_IMRL);
+
+        /*
+         * External Pin Mask Setting & Enable External Pin for Interface
+         */
+        sepmask = readw(MCF_IPSBAR + MCF_GPIO_PAR_UART);
+        if (line == 0)
+                sepmask |= UART0_ENABLE_MASK;
+        else if (line == 1)
+                sepmask |= UART1_ENABLE_MASK;
+        else if (line == 2)
+                sepmask |= UART2_ENABLE_MASK;
+        writew(sepmask, MCF_IPSBAR + MCF_GPIO_PAR_UART);
+}
+
+static void __init m527x_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m527x_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m527x_uart_init_line(line, m527x_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -54,10 +112,21 @@ void mcf_autovector(unsigned int vec)
 
 /***************************************************************************/
 
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
         mcf_disableall();
         mach_reset = coldfire_reset;
 }
 
 /***************************************************************************/
+
+static int __init init_BSP(void)
+{
+        m527x_uarts_init();
+        platform_add_devices(m527x_devices, ARRAY_SIZE(m527x_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/528x/config.c b/arch/m68knommu/platform/528x/config.c
index acbd43486d97..036e1b73d944 100644
--- a/arch/m68knommu/platform/528x/config.c
+++ b/arch/m68knommu/platform/528x/config.c
@@ -16,11 +16,15 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/platform_device.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/flash.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
-#include <asm/mcfdma.h>
+#include <asm/mcfuart.h>
+#include <asm/mcfqspi.h>
 
 /***************************************************************************/
 
@@ -28,14 +32,67 @@ void coldfire_reset(void);
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
+static struct mcf_platform_uart m528x_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0 + 1,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE3,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0 + 2,
+        },
+        { },
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+static struct platform_device m528x_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m528x_uart_platform,
+};
+
+static struct platform_device *m528x_devices[] __initdata = {
+        &m528x_uart,
+};
+
+/***************************************************************************/
+
+#define INTC0   (MCF_MBAR + MCFICM_INTC0)
+
+static void __init m528x_uart_init_line(int line, int irq)
+{
+        u8 port;
+        u32 imr;
+
+        if ((line < 0) || (line > 2))
+                return;
+
+        /* level 6, line based priority */
+        writeb(0x30+line, INTC0 + MCFINTC_ICR0 + MCFINT_UART0 + line);
+
+        imr = readl(INTC0 + MCFINTC_IMRL);
+        imr &= ~((1 << (irq - MCFINT_VECBASE)) | 1);
+        writel(imr, INTC0 + MCFINTC_IMRL);
+
+        /* make sure PUAPAR is set for UART0 and UART1 */
+        if (line < 2) {
+                port = readb(MCF_MBAR + MCF5282_GPIO_PUAPAR);
+                port |= (0x03 << (line * 2));
+                writeb(port, MCF_MBAR + MCF5282_GPIO_PUAPAR);
+        }
+}
+
+static void __init m528x_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m528x_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m528x_uart_init_line(line, m528x_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -54,10 +111,21 @@ void mcf_autovector(unsigned int vec)
 
 /***************************************************************************/
 
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
         mcf_disableall();
         mach_reset = coldfire_reset;
 }
 
 /***************************************************************************/
+
+static int __init init_BSP(void)
+{
+        m528x_uarts_init();
+        platform_add_devices(m528x_devices, ARRAY_SIZE(m528x_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/5307/Makefile b/arch/m68knommu/platform/5307/Makefile
index 5b600530c8d2..580fd6658d7c 100644
--- a/arch/m68knommu/platform/5307/Makefile
+++ b/arch/m68knommu/platform/5307/Makefile
@@ -16,17 +16,5 @@ ifdef CONFIG_FULLDEBUG
 EXTRA_AFLAGS += -DDEBUGGER_COMPATIBLE_CACHE=1
 endif
 
-obj-$(CONFIG_COLDFIRE)  += entry.o vectors.o
-obj-$(CONFIG_M5206)     += timers.o
-obj-$(CONFIG_M5206e)    += timers.o
-obj-$(CONFIG_M520x)     += pit.o
-obj-$(CONFIG_M523x)     += pit.o
-obj-$(CONFIG_M5249)     += timers.o
-obj-$(CONFIG_M527x)     += pit.o
-obj-$(CONFIG_M5272)     += timers.o
-obj-$(CONFIG_M5307)     += config.o timers.o
-obj-$(CONFIG_M532x)     += timers.o
-obj-$(CONFIG_M528x)     += pit.o
-obj-$(CONFIG_M5407)     += timers.o
+obj-y   += config.o
 
-extra-y := head.o
diff --git a/arch/m68knommu/platform/5307/config.c b/arch/m68knommu/platform/5307/config.c
index 6040821e637d..92dc862fa826 100644
--- a/arch/m68knommu/platform/5307/config.c
+++ b/arch/m68knommu/platform/5307/config.c
@@ -13,11 +13,11 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
-#include <asm/mcfdma.h>
+#include <asm/mcfuart.h>
 #include <asm/mcfwdebug.h>
 
 /***************************************************************************/
@@ -38,17 +38,51 @@ unsigned char ledbank = 0xff;
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
-        MCF_MBAR + MCFDMA_BASE1,
-        MCF_MBAR + MCFDMA_BASE2,
-        MCF_MBAR + MCFDMA_BASE3,
+static struct mcf_platform_uart m5307_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = 73,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = 74,
+        },
+        { },
+};
+
+static struct platform_device m5307_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m5307_uart_platform,
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+static struct platform_device *m5307_devices[] __initdata = {
+        &m5307_uart,
+};
+
+/***************************************************************************/
+
+static void __init m5307_uart_init_line(int line, int irq)
+{
+        if (line == 0) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI1, MCF_MBAR + MCFSIM_UART1ICR);
+                writeb(irq, MCFUART_BASE1 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART1);
+        } else if (line == 1) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI2, MCF_MBAR + MCFSIM_UART2ICR);
+                writeb(irq, MCFUART_BASE2 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART2);
+        }
+}
+
+static void __init m5307_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m5307_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m5307_uart_init_line(line, m5307_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -85,21 +119,7 @@ void mcf_settimericr(unsigned int timer, unsigned int level)
 
 /***************************************************************************/
 
-int mcf_timerirqpending(int timer)
-{
-        unsigned int imr = 0;
-
-        switch (timer) {
-        case 1:  imr = MCFSIM_IMR_TIMER1; break;
-        case 2:  imr = MCFSIM_IMR_TIMER2; break;
-        default: break;
-        }
-        return (mcf_getipr() & imr);
-}
-
-/***************************************************************************/
-
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
         mcf_setimr(MCFSIM_IMR_MASKALL);
 
@@ -117,7 +137,7 @@ void config_BSP(char *commandp, int size)
 
         mach_reset = coldfire_reset;
 
-#ifdef MCF_BDM_DISABLE
+#ifdef CONFIG_BDM_DISABLE
         /*
          * Disable the BDM clocking.  This also turns off most of the rest of
          * the BDM device.  This is good for EMC reasons. This option is not
@@ -128,3 +148,14 @@ void config_BSP(char *commandp, int size)
 }
 
 /***************************************************************************/
+
+static int __init init_BSP(void)
+{
+        m5307_uarts_init();
+        platform_add_devices(m5307_devices, ARRAY_SIZE(m5307_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/532x/config.c b/arch/m68knommu/platform/532x/config.c
index f77328b7b6db..4f44b632045b 100644
--- a/arch/m68knommu/platform/532x/config.c
+++ b/arch/m68knommu/platform/532x/config.c
@@ -21,10 +21,11 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
+#include <asm/mcfuart.h>
 #include <asm/mcfdma.h>
 #include <asm/mcfwdebug.h>
 
@@ -38,11 +39,60 @@ extern unsigned int mcf_timerlevel;
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int dma_base_addr[MAX_M68K_DMA_CHANNELS] = { };
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+static struct mcf_platform_uart m532x_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = MCFINT_VECBASE + MCFINT_UART0,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = MCFINT_VECBASE + MCFINT_UART1,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE3,
+                .irq            = MCFINT_VECBASE + MCFINT_UART2,
+        },
+        { },
+};
+
+static struct platform_device m532x_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m532x_uart_platform,
+};
+
+static struct platform_device *m532x_devices[] __initdata = {
+        &m532x_uart,
+};
+
+/***************************************************************************/
+
+static void __init m532x_uart_init_line(int line, int irq)
+{
+        if (line == 0) {
+                MCF_INTC0_ICR26 = 0x3;
+                MCF_INTC0_CIMR = 26;
+                /* GPIO initialization */
+                MCF_GPIO_PAR_UART |= 0x000F;
+        } else if (line == 1) {
+                MCF_INTC0_ICR27 = 0x3;
+                MCF_INTC0_CIMR = 27;
+                /* GPIO initialization */
+                MCF_GPIO_PAR_UART |= 0x0FF0;
+        } else if (line == 2) {
+                MCF_INTC0_ICR28 = 0x3;
+                MCF_INTC0_CIMR = 28;
+        }
+}
+
+static void __init m532x_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m532x_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m532x_uart_init_line(line, m532x_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -66,21 +116,7 @@ void mcf_settimericr(unsigned int timer, unsigned int level)
 
 /***************************************************************************/
 
-int mcf_timerirqpending(int timer)
-{
-        unsigned int imr = 0;
-
-        switch (timer) {
-        case 1:  imr = 0x1; break;
-        case 2:  imr = 0x2; break;
-        default: break;
-        }
-        return (mcf_getiprh() & imr);
-}
-
-/***************************************************************************/
-
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
         mcf_setimr(MCFSIM_IMR_MASKALL);
 
@@ -99,7 +135,7 @@ void config_BSP(char *commandp, int size)
         mcf_profilevector = 64+33;
         mach_reset = coldfire_reset;
 
-#ifdef MCF_BDM_DISABLE
+#ifdef CONFIG_BDM_DISABLE
         /*
          * Disable the BDM clocking.  This also turns off most of the rest of
          * the BDM device.  This is good for EMC reasons. This option is not
@@ -110,9 +146,19 @@ void config_BSP(char *commandp, int size)
 }
 
 /***************************************************************************/
-/* Board initialization */
 
-/********************************************************************/
+static int __init init_BSP(void)
+{
+        m532x_uarts_init();
+        platform_add_devices(m532x_devices, ARRAY_SIZE(m532x_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
+/* Board initialization */
+/***************************************************************************/
 /* 
  * PLL min/max specifications
  */
diff --git a/arch/m68knommu/platform/5407/config.c b/arch/m68knommu/platform/5407/config.c
index 2d3b62eba7ca..648b8b778211 100644
--- a/arch/m68knommu/platform/5407/config.c
+++ b/arch/m68knommu/platform/5407/config.c
@@ -13,11 +13,11 @@
 #include <linux/param.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>
+#include <linux/io.h>
 #include <asm/machdep.h>
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
-#include <asm/mcfdma.h>
+#include <asm/mcfuart.h>
 
 /***************************************************************************/
 
@@ -29,17 +29,51 @@ extern unsigned int mcf_timerlevel;
 
 /***************************************************************************/
 
-/*
- *      DMA channel base address table.
- */
-unsigned int   dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
-        MCF_MBAR + MCFDMA_BASE0,
-        MCF_MBAR + MCFDMA_BASE1,
-        MCF_MBAR + MCFDMA_BASE2,
-        MCF_MBAR + MCFDMA_BASE3,
+static struct mcf_platform_uart m5407_uart_platform[] = {
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE1,
+                .irq            = 73,
+        },
+        {
+                .mapbase        = MCF_MBAR + MCFUART_BASE2,
+                .irq            = 74,
+        },
+        { },
+};
+
+static struct platform_device m5407_uart = {
+        .name                   = "mcfuart",
+        .id                     = 0,
+        .dev.platform_data      = m5407_uart_platform,
 };
 
-unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+static struct platform_device *m5407_devices[] __initdata = {
+        &m5407_uart,
+};
+
+/***************************************************************************/
+
+static void __init m5407_uart_init_line(int line, int irq)
+{
+        if (line == 0) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI1, MCF_MBAR + MCFSIM_UART1ICR);
+                writeb(irq, MCFUART_BASE1 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART1);
+        } else if (line == 1) {
+                writel(MCFSIM_ICR_LEVEL6 | MCFSIM_ICR_PRI2, MCF_MBAR + MCFSIM_UART2ICR);
+                writeb(irq, MCFUART_BASE2 + MCFUART_UIVR);
+                mcf_setimr(mcf_getimr() & ~MCFSIM_IMR_UART2);
+        }
+}
+
+static void __init m5407_uarts_init(void)
+{
+        const int nrlines = ARRAY_SIZE(m5407_uart_platform);
+        int line;
+
+        for (line = 0; (line < nrlines); line++)
+                m5407_uart_init_line(line, m5407_uart_platform[line].irq);
+}
 
 /***************************************************************************/
 
@@ -76,21 +110,7 @@ void mcf_settimericr(unsigned int timer, unsigned int level)
 
 /***************************************************************************/
 
-int mcf_timerirqpending(int timer)
-{
-        unsigned int imr = 0;
-
-        switch (timer) {
-        case 1:  imr = MCFSIM_IMR_TIMER1; break;
-        case 2:  imr = MCFSIM_IMR_TIMER2; break;
-        default: break;
-        }
-        return (mcf_getipr() & imr);
-}
-
-/***************************************************************************/
-
-void config_BSP(char *commandp, int size)
+void __init config_BSP(char *commandp, int size)
 {
         mcf_setimr(MCFSIM_IMR_MASKALL);
 
@@ -105,3 +125,14 @@ void config_BSP(char *commandp, int size)
 }
 
 /***************************************************************************/
+
+static int __init init_BSP(void)
+{
+        m5407_uarts_init();
+        platform_add_devices(m5407_devices, ARRAY_SIZE(m5407_devices));
+        return 0;
+}
+
+arch_initcall(init_BSP);
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/68328/timers.c b/arch/m68knommu/platform/68328/timers.c
index 04cbc661d4bd..9159fd05c9ac 100644
--- a/arch/m68knommu/platform/68328/timers.c
+++ b/arch/m68knommu/platform/68328/timers.c
@@ -19,6 +19,7 @@
 #include <linux/mm.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
+#include <linux/clocksource.h>
 #include <asm/setup.h>
 #include <asm/system.h>
 #include <asm/pgtable.h>
@@ -51,6 +52,19 @@
 #define TICKS_PER_JIFFY 10
 #endif
 
+static u32 m68328_tick_cnt;
+
+/***************************************************************************/
+
+static irqreturn_t hw_tick(int irq, void *dummy)
+{
+        /* Reset Timer1 */
+        TSTAT &= 0;
+
+        m68328_tick_cnt += TICKS_PER_JIFFY;
+        return arch_timer_interrupt(irq, dummy);
+}
+
 /***************************************************************************/
 
 static irqreturn_t hw_tick(int irq, void *dummy)
@@ -69,6 +83,33 @@ static struct irqaction m68328_timer_irq = {
         .handler = hw_tick,
 };
 
+/***************************************************************************/
+
+static cycle_t m68328_read_clk(void)
+{
+        unsigned long flags;
+        u32 cycles;
+
+        local_irq_save(flags);
+        cycles = m68328_tick_cnt + TCN;
+        local_irq_restore(flags);
+
+        return cycles;
+}
+
+/***************************************************************************/
+
+static struct clocksource m68328_clk = {
+        .name   = "timer",
+        .rating = 250,
+        .read   = m68328_read_clk,
+        .shift  = 20,
+        .mask   = CLOCKSOURCE_MASK(32),
+        .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
+/***************************************************************************/
+
 void hw_timer_init(void)
 {
         /* disable timer 1 */
@@ -84,19 +125,8 @@ void hw_timer_init(void)
 
         /* Enable timer 1 */
         TCTL |= TCTL_TEN;
-}
-
-/***************************************************************************/
-
-unsigned long hw_timer_offset(void)
-{
-        unsigned long ticks = TCN, offset = 0;
-
-        /* check for pending interrupt */
-        if (ticks < (TICKS_PER_JIFFY >> 1) && (ISR & (1 << TMR_IRQ_NUM)))
-                offset = 1000000 / HZ;
-        ticks = (ticks * 1000000 / HZ) / TICKS_PER_JIFFY;
-        return ticks + offset;
+        m68328_clk.mult = clocksource_hz2mult(TICKS_PER_JIFFY*HZ, m68328_clk.shift);
+        clocksource_register(&m68328_clk);
 }
 
 /***************************************************************************/
diff --git a/arch/m68knommu/platform/68360/config.c b/arch/m68knommu/platform/68360/config.c
index 2b3196af811f..ac629fa30099 100644
--- a/arch/m68knommu/platform/68360/config.c
+++ b/arch/m68knommu/platform/68360/config.c
@@ -103,11 +103,6 @@ void hw_timer_init(void)
   pquicc->timer_tgcr  = tgcr_save;
 }
 
-unsigned long hw_timer_offset(void)
-{
-  return 0;
-}
-
 void BSP_gettod (int *yearp, int *monp, int *dayp,
                    int *hourp, int *minp, int *secp)
 {
diff --git a/arch/m68knommu/platform/coldfire/Makefile b/arch/m68knommu/platform/coldfire/Makefile
new file mode 100644
index 000000000000..e5fff297ae01
--- /dev/null
+++ b/arch/m68knommu/platform/coldfire/Makefile
@@ -0,0 +1,32 @@
+#
+# Makefile for the m68knommu kernel.
+#
+
+#
+# If you want to play with the HW breakpoints then you will
+# need to add define this,  which will give you a stack backtrace
+# on the console port whenever a DBG interrupt occurs. You have to
+# set up you HW breakpoints to trigger a DBG interrupt:
+#
+# EXTRA_CFLAGS += -DTRAP_DBG_INTERRUPT
+# EXTRA_AFLAGS += -DTRAP_DBG_INTERRUPT
+#
+
+ifdef CONFIG_FULLDEBUG
+AFLAGS += -DDEBUGGER_COMPATIBLE_CACHE=1
+endif
+
+obj-$(CONFIG_COLDFIRE)  += dma.o entry.o vectors.o
+obj-$(CONFIG_M5206)     += timers.o
+obj-$(CONFIG_M5206e)    += timers.o
+obj-$(CONFIG_M520x)     += pit.o
+obj-$(CONFIG_M523x)     += pit.o
+obj-$(CONFIG_M5249)     += timers.o
+obj-$(CONFIG_M527x)     += pit.o
+obj-$(CONFIG_M5272)     += timers.o
+obj-$(CONFIG_M528x)     += pit.o
+obj-$(CONFIG_M5307)     += timers.o
+obj-$(CONFIG_M532x)     += timers.o
+obj-$(CONFIG_M5407)     += timers.o
+
+extra-y := head.o
diff --git a/arch/m68knommu/platform/coldfire/dma.c b/arch/m68knommu/platform/coldfire/dma.c
new file mode 100644
index 000000000000..2b30cf1b8f77
--- /dev/null
+++ b/arch/m68knommu/platform/coldfire/dma.c
@@ -0,0 +1,39 @@
+/***************************************************************************/
+
+/*
+ *      dma.c -- Freescale ColdFire DMA support
+ *
+ *      Copyright (C) 2007, Greg Ungerer (gerg@snapgear.com)
+ */
+
+/***************************************************************************/
+
+#include <linux/kernel.h>
+#include <asm/dma.h>
+#include <asm/coldfire.h>
+#include <asm/mcfsim.h>
+#include <asm/mcfdma.h>
+
+/***************************************************************************/
+
+/*
+ *      DMA channel base address table.
+ */
+unsigned int dma_base_addr[MAX_M68K_DMA_CHANNELS] = {
+#ifdef MCFDMA_BASE0
+        MCF_MBAR + MCFDMA_BASE0,
+#endif
+#ifdef MCFDMA_BASE1
+        MCF_MBAR + MCFDMA_BASE1,
+#endif
+#ifdef MCFDMA_BASE2
+        MCF_MBAR + MCFDMA_BASE2,
+#endif
+#ifdef MCFDMA_BASE3
+        MCF_MBAR + MCFDMA_BASE3,
+#endif
+};
+
+unsigned int dma_device_address[MAX_M68K_DMA_CHANNELS];
+
+/***************************************************************************/
diff --git a/arch/m68knommu/platform/5307/entry.S b/arch/m68knommu/platform/coldfire/entry.S
index b333731b875a..b333731b875a 100644
--- a/arch/m68knommu/platform/5307/entry.S
+++ b/arch/m68knommu/platform/coldfire/entry.S
diff --git a/arch/m68knommu/platform/5307/head.S b/arch/m68knommu/platform/coldfire/head.S
index b9aa0ca29bfb..b9aa0ca29bfb 100644
--- a/arch/m68knommu/platform/5307/head.S
+++ b/arch/m68knommu/platform/coldfire/head.S
diff --git a/arch/m68knommu/platform/5307/pit.c b/arch/m68knommu/platform/coldfire/pit.c
index 173b754d1cda..4290638012e0 100644
--- a/arch/m68knommu/platform/5307/pit.c
+++ b/arch/m68knommu/platform/coldfire/pit.c
@@ -3,9 +3,10 @@
 /*
  *      pit.c -- Freescale ColdFire PIT timer. Currently this type of
  *               hardware timer only exists in the Freescale ColdFire
- *               5270/5271, 5282 and other CPUs.
+ *               5270/5271, 5282 and 5208 CPUs. No doubt newer ColdFire
+ *               family members will probably use it too.
  *
- *      Copyright (C) 1999-2007, Greg Ungerer (gerg@snapgear.com)
+ *      Copyright (C) 1999-2008, Greg Ungerer (gerg@snapgear.com)
  *      Copyright (C) 2001-2004, SnapGear Inc. (www.snapgear.com)
  */
 
@@ -17,6 +18,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
+#include <linux/clocksource.h>
 #include <asm/machdep.h>
 #include <asm/io.h>
 #include <asm/coldfire.h>
@@ -28,70 +30,84 @@
 /*
  *      By default use timer1 as the system clock timer.
  */
+#define FREQ    ((MCF_CLK / 2) / 64)
 #define TA(a)   (MCF_IPSBAR + MCFPIT_BASE1 + (a))
+#define INTC0   (MCF_IPSBAR + MCFICM_INTC0)
+
+static u32 pit_cycles_per_jiffy;
+static u32 pit_cnt;
 
 /***************************************************************************/
 
-static irqreturn_t hw_tick(int irq, void *dummy)
+static irqreturn_t pit_tick(int irq, void *dummy)
 {
-        unsigned short pcsr;
+        u16 pcsr;
 
         /* Reset the ColdFire timer */
         pcsr = __raw_readw(TA(MCFPIT_PCSR));
         __raw_writew(pcsr | MCFPIT_PCSR_PIF, TA(MCFPIT_PCSR));
 
+        pit_cnt += pit_cycles_per_jiffy;
         return arch_timer_interrupt(irq, dummy);
 }
 
 /***************************************************************************/
 
-static struct irqaction coldfire_pit_irq = {
+static struct irqaction pit_irq = {
         .name    = "timer",
         .flags   = IRQF_DISABLED | IRQF_TIMER,
-        .handler = hw_tick,
+        .handler = pit_tick,
 };
 
-void hw_timer_init(void)
+/***************************************************************************/
+
+static cycle_t pit_read_clk(void)
 {
-        volatile unsigned char *icrp;
-        volatile unsigned long *imrp;
+        unsigned long flags;
+        u32 cycles;
+        u16 pcntr;
 
-        setup_irq(MCFINT_VECBASE + MCFINT_PIT1, &coldfire_pit_irq);
+        local_irq_save(flags);
+        pcntr = __raw_readw(TA(MCFPIT_PCNTR));
+        cycles = pit_cnt;
+        local_irq_restore(flags);
 
-        icrp = (volatile unsigned char *) (MCF_IPSBAR + MCFICM_INTC0 +
-                MCFINTC_ICR0 + MCFINT_PIT1);
-        *icrp = ICR_INTRCONF;
+        return cycles + pit_cycles_per_jiffy - pcntr;
+}
 
-        imrp = (volatile unsigned long *) (MCF_IPSBAR + MCFICM_INTC0 + MCFPIT_IMR);
-        *imrp &= ~MCFPIT_IMR_IBIT;
+/***************************************************************************/
 
-        /* Set up PIT timer 1 as poll clock */
-        __raw_writew(MCFPIT_PCSR_DISABLE, TA(MCFPIT_PCSR));
-        __raw_writew(((MCF_CLK / 2) / 64) / HZ, TA(MCFPIT_PMR));
-        __raw_writew(MCFPIT_PCSR_EN | MCFPIT_PCSR_PIE | MCFPIT_PCSR_OVW |
-                MCFPIT_PCSR_RLD | MCFPIT_PCSR_CLK64, TA(MCFPIT_PCSR));
-}
+static struct clocksource pit_clk = {
+        .name   = "pit",
+        .rating = 250,
+        .read   = pit_read_clk,
+        .shift  = 20,
+        .mask   = CLOCKSOURCE_MASK(32),
+        .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
+};
 
 /***************************************************************************/
 
-unsigned long hw_timer_offset(void)
+void hw_timer_init(void)
 {
-        volatile unsigned long *ipr;
-        unsigned long pmr, pcntr, offset;
+        u32 imr;
 
-        ipr = (volatile unsigned long *) (MCF_IPSBAR + MCFICM_INTC0 + MCFPIT_IMR);
+        setup_irq(MCFINT_VECBASE + MCFINT_PIT1, &pit_irq);
 
-        pmr = __raw_readw(TA(MCFPIT_PMR));
-        pcntr = __raw_readw(TA(MCFPIT_PCNTR));
+        __raw_writeb(ICR_INTRCONF, INTC0 + MCFINTC_ICR0 + MCFINT_PIT1);
+        imr = __raw_readl(INTC0 + MCFPIT_IMR);
+        imr &= ~MCFPIT_IMR_IBIT;
+        __raw_writel(imr, INTC0 + MCFPIT_IMR);
+
+        /* Set up PIT timer 1 as poll clock */
+        pit_cycles_per_jiffy = FREQ / HZ;
+        __raw_writew(MCFPIT_PCSR_DISABLE, TA(MCFPIT_PCSR));
+        __raw_writew(pit_cycles_per_jiffy, TA(MCFPIT_PMR));
+        __raw_writew(MCFPIT_PCSR_EN | MCFPIT_PCSR_PIE | MCFPIT_PCSR_OVW |
+                MCFPIT_PCSR_RLD | MCFPIT_PCSR_CLK64, TA(MCFPIT_PCSR));
 
-        /*
-         * If we are still in the first half of the upcount and a
-         * timer interrupt is pending, then add on a ticks worth of time.
-         */
-        offset = ((pmr - pcntr) * (1000000 / HZ)) / pmr;
-        if ((offset < (1000000 / HZ / 2)) && (*ipr & MCFPIT_IMR_IBIT))
-                offset += 1000000 / HZ;
-        return offset;  
+        pit_clk.mult = clocksource_hz2mult(FREQ, pit_clk.shift);
+        clocksource_register(&pit_clk);
 }
 
 /***************************************************************************/
diff --git a/arch/m68knommu/platform/5307/timers.c b/arch/m68knommu/platform/coldfire/timers.c
index 489dec85c859..a60213e877ef 100644
--- a/arch/m68knommu/platform/5307/timers.c
+++ b/arch/m68knommu/platform/coldfire/timers.c
@@ -3,7 +3,7 @@
 /*
  *      timers.c -- generic ColdFire hardware timer support.
  *
- *      Copyright (C) 1999-2007, Greg Ungerer (gerg@snapgear.com)
+ *      Copyright (C) 1999-2008, Greg Ungerer <gerg@snapgear.com>
  */
 
 /***************************************************************************/
@@ -13,6 +13,8 @@
 #include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
+#include <linux/profile.h>
+#include <linux/clocksource.h>
 #include <asm/io.h>
 #include <asm/traps.h>
 #include <asm/machdep.h>
@@ -25,6 +27,7 @@
 /*
  *      By default use timer1 as the system clock timer.
  */
+#define FREQ    (MCF_BUSCLK / 16)
 #define TA(a)   (MCF_MBAR + MCFTIMER_BASE1 + (a))
 
 /*
@@ -41,7 +44,7 @@ unsigned int	mcf_timerlevel = 5;
  *      Unfortunately it is a little different on each ColdFire.
  */
 extern void mcf_settimericr(int timer, int level);
-extern int mcf_timerirqpending(int timer);
+void coldfire_profile_init(void);
 
 #if defined(CONFIG_M532x)
 #define __raw_readtrr   __raw_readl
@@ -51,38 +54,70 @@ extern int mcf_timerirqpending(int timer);
 #define __raw_writetrr  __raw_writew
 #endif
 
+static u32 mcftmr_cycles_per_jiffy;
+static u32 mcftmr_cnt;
+
 /***************************************************************************/
 
-static irqreturn_t hw_tick(int irq, void *dummy)
+static irqreturn_t mcftmr_tick(int irq, void *dummy)
 {
         /* Reset the ColdFire timer */
         __raw_writeb(MCFTIMER_TER_CAP | MCFTIMER_TER_REF, TA(MCFTIMER_TER));
 
+        mcftmr_cnt += mcftmr_cycles_per_jiffy;
         return arch_timer_interrupt(irq, dummy);
 }
 
 /***************************************************************************/
 
-static struct irqaction coldfire_timer_irq = {
+static struct irqaction mcftmr_timer_irq = {
         .name    = "timer",
         .flags   = IRQF_DISABLED | IRQF_TIMER,
-        .handler = hw_tick,
+        .handler = mcftmr_tick,
 };
 
 /***************************************************************************/
 
-static int ticks_per_intr;
+static cycle_t mcftmr_read_clk(void)
+{
+        unsigned long flags;
+        u32 cycles;
+        u16 tcn;
+
+        local_irq_save(flags);
+        tcn = __raw_readw(TA(MCFTIMER_TCN));
+        cycles = mcftmr_cnt;
+        local_irq_restore(flags);
+
+        return cycles + tcn;
+}
+
+/***************************************************************************/
+
+static struct clocksource mcftmr_clk = {
+        .name   = "tmr",
+        .rating = 250,
+        .read   = mcftmr_read_clk,
+        .shift  = 20,
+        .mask   = CLOCKSOURCE_MASK(32),
+        .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
+/***************************************************************************/
 
 void hw_timer_init(void)
 {
-        setup_irq(mcf_timervector, &coldfire_timer_irq);
+        setup_irq(mcf_timervector, &mcftmr_timer_irq);
 
         __raw_writew(MCFTIMER_TMR_DISABLE, TA(MCFTIMER_TMR));
-        ticks_per_intr = (MCF_BUSCLK / 16) / HZ;
-        __raw_writetrr(ticks_per_intr - 1, TA(MCFTIMER_TRR));
+        mcftmr_cycles_per_jiffy = FREQ / HZ;
+        __raw_writetrr(mcftmr_cycles_per_jiffy, TA(MCFTIMER_TRR));
         __raw_writew(MCFTIMER_TMR_ENORI | MCFTIMER_TMR_CLK16 |
                 MCFTIMER_TMR_RESTART | MCFTIMER_TMR_ENABLE, TA(MCFTIMER_TMR));
 
+        mcftmr_clk.mult = clocksource_hz2mult(FREQ, mcftmr_clk.shift);
+        clocksource_register(&mcftmr_clk);
+
         mcf_settimericr(1, mcf_timerlevel);
 
 #ifdef CONFIG_HIGHPROFILE
@@ -91,21 +126,6 @@ void hw_timer_init(void)
 }
 
 /***************************************************************************/
-
-unsigned long hw_timer_offset(void)
-{
-        unsigned long tcn, offset;
-
-        tcn = __raw_readw(TA(MCFTIMER_TCN));
-        offset = ((tcn + 1) * (1000000 / HZ)) / ticks_per_intr;
-
-        /* Check if we just wrapped the counters and maybe missed a tick */
-        if ((offset < (1000000 / HZ / 2)) && mcf_timerirqpending(1))
-                offset += 1000000 / HZ;
-        return offset;
-}
-
-/***************************************************************************/
 #ifdef CONFIG_HIGHPROFILE
 /***************************************************************************/
 
diff --git a/arch/m68knommu/platform/5307/vectors.c b/arch/m68knommu/platform/coldfire/vectors.c
index 6cf894620234..6cf894620234 100644
--- a/arch/m68knommu/platform/5307/vectors.c
+++ b/arch/m68knommu/platform/coldfire/vectors.c
diff --git a/arch/mips/Kconfig b/arch/mips/Kconfig
index 4fad0a34b997..ec78a5762e9e 100644
--- a/arch/mips/Kconfig
+++ b/arch/mips/Kconfig
@@ -1,6 +1,7 @@
 config MIPS
         bool
         default y
+        select HAVE_OPROFILE
         # Horrible source of confusion.  Die, die, die ...
         select EMBEDDED
         select RTC_LIB
@@ -1754,8 +1755,8 @@ config SMP
           People using multiprocessor machines who say Y here should also say
           Y to "Enhanced Real Time Clock Support", below.
 
-          See also the <file:Documentation/smp.txt> and the SMP-HOWTO
-          available at <http://www.tldp.org/docs.html#howto>.
+          See also the SMP-HOWTO available at
+          <http://www.tldp.org/docs.html#howto>.
 
           If you don't know what to do here, say N.
 
@@ -1961,11 +1962,6 @@ config PCI
           your box. Other bus systems are ISA, EISA, or VESA. If you have PCI,
           say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 config PCI_DOMAINS
         bool
 
@@ -2086,6 +2082,10 @@ endmenu
 
 menu "Power management options"
 
+config ARCH_SUSPEND_POSSIBLE
+        def_bool y
+        depends on !SMP
+
 source "kernel/power/Kconfig"
 
 endmenu
@@ -2096,8 +2096,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/mips/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/mips/au1000/mtx-1/board_setup.c b/arch/mips/au1000/mtx-1/board_setup.c
index abfc4bcddf7a..310d5dff89fc 100644
--- a/arch/mips/au1000/mtx-1/board_setup.c
+++ b/arch/mips/au1000/mtx-1/board_setup.c
@@ -99,7 +99,7 @@ mtx1_pci_idsel(unsigned int devsel, int assert)
 #endif
 
        if (assert && devsel != 0) {
-               // supress signal to cardbus
+               // suppress signal to cardbus
                au_writel( 0x00000002, SYS_OUTPUTCLR ); // set EXT_IO3 OFF
        }
        else {
diff --git a/arch/mips/kernel/binfmt_elfn32.c b/arch/mips/kernel/binfmt_elfn32.c
index 9b34238d41c0..77db3473deab 100644
--- a/arch/mips/kernel/binfmt_elfn32.c
+++ b/arch/mips/kernel/binfmt_elfn32.c
@@ -98,7 +98,7 @@ static __inline__ void
 jiffies_to_compat_timeval(unsigned long jiffies, struct compat_timeval *value)
 {
         /*
-         * Convert jiffies to nanoseconds and seperate with
+         * Convert jiffies to nanoseconds and separate with
          * one divide.
          */
         u64 nsec = (u64)jiffies * TICK_NSEC;
diff --git a/arch/mips/kernel/binfmt_elfo32.c b/arch/mips/kernel/binfmt_elfo32.c
index da41eac195ca..08f4cd781ee3 100644
--- a/arch/mips/kernel/binfmt_elfo32.c
+++ b/arch/mips/kernel/binfmt_elfo32.c
@@ -100,7 +100,7 @@ static inline void
 jiffies_to_compat_timeval(unsigned long jiffies, struct compat_timeval *value)
 {
         /*
-         * Convert jiffies to nanoseconds and seperate with
+         * Convert jiffies to nanoseconds and separate with
          * one divide.
          */
         u64 nsec = (u64)jiffies * TICK_NSEC;
diff --git a/arch/mips/kernel/head.S b/arch/mips/kernel/head.S
index 50be56c9e9ef..a24fb7900901 100644
--- a/arch/mips/kernel/head.S
+++ b/arch/mips/kernel/head.S
@@ -140,7 +140,7 @@ FEXPORT(__kernel_entry)
         j       kernel_entry
 #endif
 
-        __INIT_REFOK
+        __REF
 
 NESTED(kernel_entry, 16, sp)                    # kernel entry point
 
diff --git a/arch/mips/kernel/kspd.c b/arch/mips/kernel/kspd.c
index f6704ab16306..998c4efcce88 100644
--- a/arch/mips/kernel/kspd.c
+++ b/arch/mips/kernel/kspd.c
@@ -221,7 +221,7 @@ void sp_work_handle_request(void)
                 }
         }
 
-        /* Run the syscall at the priviledge of the user who loaded the
+        /* Run the syscall at the privilege of the user who loaded the
            SP program */
 
         if (vpe_getuid(tclimit))
diff --git a/arch/mips/kernel/scall32-o32.S b/arch/mips/kernel/scall32-o32.S
index 82480a1717d8..f798139e888e 100644
--- a/arch/mips/kernel/scall32-o32.S
+++ b/arch/mips/kernel/scall32-o32.S
@@ -660,7 +660,7 @@ einval:	li	v0, -EINVAL
         sys     sys_ioprio_get          2       /* 4315 */
         sys     sys_utimensat           4
         sys     sys_signalfd            3
-        sys     sys_timerfd             4
+        sys     sys_ni_syscall          0
         sys     sys_eventfd             1
         sys     sys_fallocate           6       /* 4320 */
         .endm
diff --git a/arch/mips/kernel/scall64-64.S b/arch/mips/kernel/scall64-64.S
index c2c10876da2e..a626be6baea3 100644
--- a/arch/mips/kernel/scall64-64.S
+++ b/arch/mips/kernel/scall64-64.S
@@ -475,7 +475,7 @@ sys_call_table:
         PTR     sys_ioprio_get
         PTR     sys_utimensat                   /* 5275 */
         PTR     sys_signalfd
-        PTR     sys_timerfd
+        PTR     sys_ni_syscall
         PTR     sys_eventfd
         PTR     sys_fallocate
         .size   sys_call_table,.-sys_call_table
diff --git a/arch/mips/kernel/scall64-n32.S b/arch/mips/kernel/scall64-n32.S
index 01993ec3368b..9d5bcaf1b389 100644
--- a/arch/mips/kernel/scall64-n32.S
+++ b/arch/mips/kernel/scall64-n32.S
@@ -401,7 +401,7 @@ EXPORT(sysn32_call_table)
         PTR     sys_ioprio_get
         PTR     compat_sys_utimensat
         PTR     compat_sys_signalfd             /* 5280 */
-        PTR     compat_sys_timerfd
+        PTR     sys_ni_syscall
         PTR     sys_eventfd
         PTR     sys_fallocate
         .size   sysn32_call_table,.-sysn32_call_table
diff --git a/arch/mips/kernel/scall64-o32.S b/arch/mips/kernel/scall64-o32.S
index dd68afce7da5..fd2019c1ec2d 100644
--- a/arch/mips/kernel/scall64-o32.S
+++ b/arch/mips/kernel/scall64-o32.S
@@ -523,7 +523,7 @@ sys_call_table:
         PTR     sys_ioprio_get                  /* 4315 */
         PTR     compat_sys_utimensat
         PTR     compat_sys_signalfd
-        PTR     compat_sys_timerfd
+        PTR     sys_ni_syscall
         PTR     sys_eventfd
         PTR     sys32_fallocate                 /* 4320 */
         .size   sys_call_table,.-sys_call_table
diff --git a/arch/mips/kernel/setup.c b/arch/mips/kernel/setup.c
index 269c252d956f..c032409cba9b 100644
--- a/arch/mips/kernel/setup.c
+++ b/arch/mips/kernel/setup.c
@@ -424,13 +424,13 @@ static void __init bootmem_init(void)
 #endif  /* CONFIG_SGI_IP27 */
 
 /*
- * arch_mem_init - initialize memory managment subsystem
+ * arch_mem_init - initialize memory management subsystem
  *
  *  o plat_mem_setup() detects the memory configuration and will record detected
  *    memory areas using add_memory_region.
  *
  * At this stage the memory configuration of the system is known to the
- * kernel but generic memory managment system is still entirely uninitialized.
+ * kernel but generic memory management system is still entirely uninitialized.
  *
  *  o bootmem_init()
  *  o sparse_init()
diff --git a/arch/mips/kernel/smtc.c b/arch/mips/kernel/smtc.c
index 85f700e58131..b42e71c71119 100644
--- a/arch/mips/kernel/smtc.c
+++ b/arch/mips/kernel/smtc.c
@@ -65,7 +65,7 @@ asiduse smtc_live_asid[MAX_SMTC_TLBS][MAX_SMTC_ASIDS];
 static atomic_t ipi_timer_latch[NR_CPUS];
 
 /*
- * Number of InterProcessor Interupt (IPI) message buffers to allocate
+ * Number of InterProcessor Interrupt (IPI) message buffers to allocate
  */
 
 #define IPIBUF_PER_CPU 4
@@ -780,7 +780,7 @@ void smtc_send_ipi(int cpu, int type, unsigned int action)
         if (cpu_data[cpu].vpe_id != cpu_data[smp_processor_id()].vpe_id) {
                 if (type == SMTC_CLOCK_TICK)
                         atomic_inc(&ipi_timer_latch[cpu]);
-                /* If not on same VPE, enqueue and send cross-VPE interupt */
+                /* If not on same VPE, enqueue and send cross-VPE interrupt */
                 smtc_ipi_nq(&IPIQ[cpu], pipi);
                 LOCK_CORE_PRA();
                 settc(cpu_data[cpu].tc_id);
@@ -1063,7 +1063,7 @@ static void setup_cross_vpe_interrupts(unsigned int nvpe)
                 return;
 
         if (!cpu_has_vint)
-                panic("SMTC Kernel requires Vectored Interupt support");
+                panic("SMTC Kernel requires Vectored Interrupt support");
 
         set_vi_handler(MIPS_CPU_IPI_IRQ, ipi_irq_dispatch);
 
diff --git a/arch/mips/mm/Makefile b/arch/mips/mm/Makefile
index 32fd5db95774..c6f832e0f41c 100644
--- a/arch/mips/mm/Makefile
+++ b/arch/mips/mm/Makefile
@@ -3,7 +3,8 @@
 #
 
 obj-y                           += cache.o dma-default.o extable.o fault.o \
-                                   init.o pgtable.o tlbex.o tlbex-fault.o
+                                   init.o pgtable.o tlbex.o tlbex-fault.o \
+                                   uasm.o
 
 obj-$(CONFIG_32BIT)             += ioremap.o pgtable-32.o
 obj-$(CONFIG_64BIT)             += pgtable-64.o
diff --git a/arch/mips/mm/c-r4k.c b/arch/mips/mm/c-r4k.c
index 02bd180f0e02..53ec05267a98 100644
--- a/arch/mips/mm/c-r4k.c
+++ b/arch/mips/mm/c-r4k.c
@@ -1101,7 +1101,7 @@ static void __init setup_scache(void)
         /*
          * Do the probing thing on R4000SC and R4400SC processors.  Other
          * processors don't have a S-cache that would be relevant to the
-         * Linux memory managment.
+         * Linux memory management.
          */
         switch (c->cputype) {
         case CPU_R4000SC:
diff --git a/arch/mips/mm/tlbex.c b/arch/mips/mm/tlbex.c
index d026302e0ecc..218a6cc415e8 100644
--- a/arch/mips/mm/tlbex.c
+++ b/arch/mips/mm/tlbex.c
@@ -5,7 +5,7 @@
  *
  * Synthesize TLB refill handlers at runtime.
  *
- * Copyright (C) 2004,2005,2006 by Thiemo Seufer
+ * Copyright (C) 2004, 2005, 2006, 2008  Thiemo Seufer
  * Copyright (C) 2005, 2007  Maciej W. Rozycki
  * Copyright (C) 2006  Ralf Baechle (ralf@linux-mips.org)
  *
@@ -24,12 +24,11 @@
 #include <linux/string.h>
 #include <linux/init.h>
 
-#include <asm/bugs.h>
 #include <asm/mmu_context.h>
-#include <asm/inst.h>
-#include <asm/elf.h>
 #include <asm/war.h>
 
+#include "uasm.h"
+
 static inline int r45k_bvahwbug(void)
 {
         /* XXX: We should probe for the presence of this bug, but we don't. */
@@ -67,371 +66,9 @@ static int __init m4kc_tlbp_war(void)
                (PRID_COMP_MIPS | PRID_IMP_4KC);
 }
 
-/*
- * A little micro-assembler, intended for TLB refill handler
- * synthesizing. It is intentionally kept simple, does only support
- * a subset of instructions, and does not try to hide pipeline effects
- * like branch delay slots.
- */
-
-enum fields
-{
-        RS = 0x001,
-        RT = 0x002,
-        RD = 0x004,
-        RE = 0x008,
-        SIMM = 0x010,
-        UIMM = 0x020,
-        BIMM = 0x040,
-        JIMM = 0x080,
-        FUNC = 0x100,
-        SET = 0x200
-};
-
-#define OP_MASK         0x3f
-#define OP_SH           26
-#define RS_MASK         0x1f
-#define RS_SH           21
-#define RT_MASK         0x1f
-#define RT_SH           16
-#define RD_MASK         0x1f
-#define RD_SH           11
-#define RE_MASK         0x1f
-#define RE_SH           6
-#define IMM_MASK        0xffff
-#define IMM_SH          0
-#define JIMM_MASK       0x3ffffff
-#define JIMM_SH         0
-#define FUNC_MASK       0x3f
-#define FUNC_SH         0
-#define SET_MASK        0x7
-#define SET_SH          0
-
-enum opcode {
-        insn_invalid,
-        insn_addu, insn_addiu, insn_and, insn_andi, insn_beq,
-        insn_beql, insn_bgez, insn_bgezl, insn_bltz, insn_bltzl,
-        insn_bne, insn_daddu, insn_daddiu, insn_dmfc0, insn_dmtc0,
-        insn_dsll, insn_dsll32, insn_dsra, insn_dsrl, insn_dsrl32,
-        insn_dsubu, insn_eret, insn_j, insn_jal, insn_jr, insn_ld,
-        insn_ll, insn_lld, insn_lui, insn_lw, insn_mfc0, insn_mtc0,
-        insn_ori, insn_rfe, insn_sc, insn_scd, insn_sd, insn_sll,
-        insn_sra, insn_srl, insn_subu, insn_sw, insn_tlbp, insn_tlbwi,
-        insn_tlbwr, insn_xor, insn_xori
-};
-
-struct insn {
-        enum opcode opcode;
-        u32 match;
-        enum fields fields;
-};
-
-/* This macro sets the non-variable bits of an instruction. */
-#define M(a, b, c, d, e, f)                                     \
-        ((a) << OP_SH                                           \
-         | (b) << RS_SH                                         \
-         | (c) << RT_SH                                         \
-         | (d) << RD_SH                                         \
-         | (e) << RE_SH                                         \
-         | (f) << FUNC_SH)
-
-static struct insn insn_table[] __initdata = {
-        { insn_addiu, M(addiu_op, 0, 0, 0, 0, 0), RS | RT | SIMM },
-        { insn_addu, M(spec_op, 0, 0, 0, 0, addu_op), RS | RT | RD },
-        { insn_and, M(spec_op, 0, 0, 0, 0, and_op), RS | RT | RD },
-        { insn_andi, M(andi_op, 0, 0, 0, 0, 0), RS | RT | UIMM },
-        { insn_beq, M(beq_op, 0, 0, 0, 0, 0), RS | RT | BIMM },
-        { insn_beql, M(beql_op, 0, 0, 0, 0, 0), RS | RT | BIMM },
-        { insn_bgez, M(bcond_op, 0, bgez_op, 0, 0, 0), RS | BIMM },
-        { insn_bgezl, M(bcond_op, 0, bgezl_op, 0, 0, 0), RS | BIMM },
-        { insn_bltz, M(bcond_op, 0, bltz_op, 0, 0, 0), RS | BIMM },
-        { insn_bltzl, M(bcond_op, 0, bltzl_op, 0, 0, 0), RS | BIMM },
-        { insn_bne, M(bne_op, 0, 0, 0, 0, 0), RS | RT | BIMM },
-        { insn_daddiu, M(daddiu_op, 0, 0, 0, 0, 0), RS | RT | SIMM },
-        { insn_daddu, M(spec_op, 0, 0, 0, 0, daddu_op), RS | RT | RD },
-        { insn_dmfc0, M(cop0_op, dmfc_op, 0, 0, 0, 0), RT | RD | SET},
-        { insn_dmtc0, M(cop0_op, dmtc_op, 0, 0, 0, 0), RT | RD | SET},
-        { insn_dsll, M(spec_op, 0, 0, 0, 0, dsll_op), RT | RD | RE },
-        { insn_dsll32, M(spec_op, 0, 0, 0, 0, dsll32_op), RT | RD | RE },
-        { insn_dsra, M(spec_op, 0, 0, 0, 0, dsra_op), RT | RD | RE },
-        { insn_dsrl, M(spec_op, 0, 0, 0, 0, dsrl_op), RT | RD | RE },
-        { insn_dsrl32, M(spec_op, 0, 0, 0, 0, dsrl32_op), RT | RD | RE },
-        { insn_dsubu, M(spec_op, 0, 0, 0, 0, dsubu_op), RS | RT | RD },
-        { insn_eret,  M(cop0_op, cop_op, 0, 0, 0, eret_op),  0 },
-        { insn_j,  M(j_op, 0, 0, 0, 0, 0),  JIMM },
-        { insn_jal,  M(jal_op, 0, 0, 0, 0, 0),  JIMM },
-        { insn_jr,  M(spec_op, 0, 0, 0, 0, jr_op),  RS },
-        { insn_ld,  M(ld_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
-        { insn_ll,  M(ll_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
-        { insn_lld,  M(lld_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
-        { insn_lui,  M(lui_op, 0, 0, 0, 0, 0),  RT | SIMM },
-        { insn_lw,  M(lw_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
-        { insn_mfc0,  M(cop0_op, mfc_op, 0, 0, 0, 0),  RT | RD | SET},
-        { insn_mtc0,  M(cop0_op, mtc_op, 0, 0, 0, 0),  RT | RD | SET},
-        { insn_ori,  M(ori_op, 0, 0, 0, 0, 0),  RS | RT | UIMM },
-        { insn_rfe,  M(cop0_op, cop_op, 0, 0, 0, rfe_op),  0 },
-        { insn_sc,  M(sc_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
-        { insn_scd,  M(scd_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
-        { insn_sd,  M(sd_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
-        { insn_sll,  M(spec_op, 0, 0, 0, 0, sll_op),  RT | RD | RE },
-        { insn_sra,  M(spec_op, 0, 0, 0, 0, sra_op),  RT | RD | RE },
-        { insn_srl,  M(spec_op, 0, 0, 0, 0, srl_op),  RT | RD | RE },
-        { insn_subu,  M(spec_op, 0, 0, 0, 0, subu_op),  RS | RT | RD },
-        { insn_sw,  M(sw_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
-        { insn_tlbp,  M(cop0_op, cop_op, 0, 0, 0, tlbp_op),  0 },
-        { insn_tlbwi,  M(cop0_op, cop_op, 0, 0, 0, tlbwi_op),  0 },
-        { insn_tlbwr,  M(cop0_op, cop_op, 0, 0, 0, tlbwr_op),  0 },
-        { insn_xor,  M(spec_op, 0, 0, 0, 0, xor_op),  RS | RT | RD },
-        { insn_xori,  M(xori_op, 0, 0, 0, 0, 0),  RS | RT | UIMM },
-        { insn_invalid, 0, 0 }
-};
-
-#undef M
-
-static u32 __init build_rs(u32 arg)
-{
-        if (arg & ~RS_MASK)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return (arg & RS_MASK) << RS_SH;
-}
-
-static u32 __init build_rt(u32 arg)
-{
-        if (arg & ~RT_MASK)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return (arg & RT_MASK) << RT_SH;
-}
-
-static u32 __init build_rd(u32 arg)
-{
-        if (arg & ~RD_MASK)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return (arg & RD_MASK) << RD_SH;
-}
-
-static u32 __init build_re(u32 arg)
-{
-        if (arg & ~RE_MASK)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return (arg & RE_MASK) << RE_SH;
-}
-
-static u32 __init build_simm(s32 arg)
-{
-        if (arg > 0x7fff || arg < -0x8000)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return arg & 0xffff;
-}
-
-static u32 __init build_uimm(u32 arg)
-{
-        if (arg & ~IMM_MASK)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return arg & IMM_MASK;
-}
-
-static u32 __init build_bimm(s32 arg)
-{
-        if (arg > 0x1ffff || arg < -0x20000)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        if (arg & 0x3)
-                printk(KERN_WARNING "Invalid TLB synthesizer branch target\n");
-
-        return ((arg < 0) ? (1 << 15) : 0) | ((arg >> 2) & 0x7fff);
-}
-
-static u32 __init build_jimm(u32 arg)
-{
-        if (arg & ~((JIMM_MASK) << 2))
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return (arg >> 2) & JIMM_MASK;
-}
-
-static u32 __init build_func(u32 arg)
-{
-        if (arg & ~FUNC_MASK)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return arg & FUNC_MASK;
-}
-
-static u32 __init build_set(u32 arg)
-{
-        if (arg & ~SET_MASK)
-                printk(KERN_WARNING "TLB synthesizer field overflow\n");
-
-        return arg & SET_MASK;
-}
-
-/*
- * The order of opcode arguments is implicitly left to right,
- * starting with RS and ending with FUNC or IMM.
- */
-static void __init build_insn(u32 **buf, enum opcode opc, ...)
-{
-        struct insn *ip = NULL;
-        unsigned int i;
-        va_list ap;
-        u32 op;
-
-        for (i = 0; insn_table[i].opcode != insn_invalid; i++)
-                if (insn_table[i].opcode == opc) {
-                        ip = &insn_table[i];
-                        break;
-                }
-
-        if (!ip || (opc == insn_daddiu && r4k_daddiu_bug()))
-                panic("Unsupported TLB synthesizer instruction %d", opc);
-
-        op = ip->match;
-        va_start(ap, opc);
-        if (ip->fields & RS) op |= build_rs(va_arg(ap, u32));
-        if (ip->fields & RT) op |= build_rt(va_arg(ap, u32));
-        if (ip->fields & RD) op |= build_rd(va_arg(ap, u32));
-        if (ip->fields & RE) op |= build_re(va_arg(ap, u32));
-        if (ip->fields & SIMM) op |= build_simm(va_arg(ap, s32));
-        if (ip->fields & UIMM) op |= build_uimm(va_arg(ap, u32));
-        if (ip->fields & BIMM) op |= build_bimm(va_arg(ap, s32));
-        if (ip->fields & JIMM) op |= build_jimm(va_arg(ap, u32));
-        if (ip->fields & FUNC) op |= build_func(va_arg(ap, u32));
-        if (ip->fields & SET) op |= build_set(va_arg(ap, u32));
-        va_end(ap);
-
-        **buf = op;
-        (*buf)++;
-}
-
-#define I_u1u2u3(op)                                            \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a, \
-                unsigned int b, unsigned int c)                 \
-        {                                                       \
-                build_insn(buf, insn##op, a, b, c);             \
-        }
-
-#define I_u2u1u3(op)                                            \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a, \
-                unsigned int b, unsigned int c)                 \
-        {                                                       \
-                build_insn(buf, insn##op, b, a, c);             \
-        }
-
-#define I_u3u1u2(op)                                            \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a, \
-                unsigned int b, unsigned int c)                 \
-        {                                                       \
-                build_insn(buf, insn##op, b, c, a);             \
-        }
-
-#define I_u1u2s3(op)                                            \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a, \
-                unsigned int b, signed int c)                   \
-        {                                                       \
-                build_insn(buf, insn##op, a, b, c);             \
-        }
-
-#define I_u2s3u1(op)                                            \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a, \
-                signed int b, unsigned int c)                   \
-        {                                                       \
-                build_insn(buf, insn##op, c, a, b);             \
-        }
-
-#define I_u2u1s3(op)                                            \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a, \
-                unsigned int b, signed int c)                   \
-        {                                                       \
-                build_insn(buf, insn##op, b, a, c);             \
-        }
-
-#define I_u1u2(op)                                              \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a, \
-                unsigned int b)                                 \
-        {                                                       \
-                build_insn(buf, insn##op, a, b);                \
-        }
-
-#define I_u1s2(op)                                              \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a, \
-                signed int b)                                   \
-        {                                                       \
-                build_insn(buf, insn##op, a, b);                \
-        }
-
-#define I_u1(op)                                                \
-        static void __init __maybe_unused i##op(u32 **buf, unsigned int a) \
-        {                                                       \
-                build_insn(buf, insn##op, a);                   \
-        }
-
-#define I_0(op)                                                 \
-        static void __init __maybe_unused i##op(u32 **buf)      \
-        {                                                       \
-                build_insn(buf, insn##op);                      \
-        }
-
-I_u2u1s3(_addiu);
-I_u3u1u2(_addu);
-I_u2u1u3(_andi);
-I_u3u1u2(_and);
-I_u1u2s3(_beq);
-I_u1u2s3(_beql);
-I_u1s2(_bgez);
-I_u1s2(_bgezl);
-I_u1s2(_bltz);
-I_u1s2(_bltzl);
-I_u1u2s3(_bne);
-I_u1u2u3(_dmfc0);
-I_u1u2u3(_dmtc0);
-I_u2u1s3(_daddiu);
-I_u3u1u2(_daddu);
-I_u2u1u3(_dsll);
-I_u2u1u3(_dsll32);
-I_u2u1u3(_dsra);
-I_u2u1u3(_dsrl);
-I_u2u1u3(_dsrl32);
-I_u3u1u2(_dsubu);
-I_0(_eret);
-I_u1(_j);
-I_u1(_jal);
-I_u1(_jr);
-I_u2s3u1(_ld);
-I_u2s3u1(_ll);
-I_u2s3u1(_lld);
-I_u1s2(_lui);
-I_u2s3u1(_lw);
-I_u1u2u3(_mfc0);
-I_u1u2u3(_mtc0);
-I_u2u1u3(_ori);
-I_0(_rfe);
-I_u2s3u1(_sc);
-I_u2s3u1(_scd);
-I_u2s3u1(_sd);
-I_u2u1u3(_sll);
-I_u2u1u3(_sra);
-I_u2u1u3(_srl);
-I_u3u1u2(_subu);
-I_u2s3u1(_sw);
-I_0(_tlbp);
-I_0(_tlbwi);
-I_0(_tlbwr);
-I_u3u1u2(_xor)
-I_u2u1u3(_xori);
-
-/*
- * handling labels
- */
-
+/* Handle labels (which must be positive integers). */
 enum label_id {
-        label_invalid,
-        label_second_part,
+        label_second_part = 1,
         label_leave,
 #ifdef MODULE_START
         label_module_alloc,
@@ -447,278 +84,20 @@ enum label_id {
         label_r3000_write_probe_fail,
 };
 
-struct label {
-        u32 *addr;
-        enum label_id lab;
-};
-
-static void __init build_label(struct label **lab, u32 *addr,
-                               enum label_id l)
-{
-        (*lab)->addr = addr;
-        (*lab)->lab = l;
-        (*lab)++;
-}
-
-#define L_LA(lb)                                                \
-        static inline void __init l##lb(struct label **lab, u32 *addr) \
-        {                                                       \
-                build_label(lab, addr, label##lb);              \
-        }
-
-L_LA(_second_part)
-L_LA(_leave)
+UASM_L_LA(_second_part)
+UASM_L_LA(_leave)
 #ifdef MODULE_START
-L_LA(_module_alloc)
-#endif
-L_LA(_vmalloc)
-L_LA(_vmalloc_done)
-L_LA(_tlbw_hazard)
-L_LA(_split)
-L_LA(_nopage_tlbl)
-L_LA(_nopage_tlbs)
-L_LA(_nopage_tlbm)
-L_LA(_smp_pgtable_change)
-L_LA(_r3000_write_probe_fail)
-
-/* convenience macros for instructions */
-#ifdef CONFIG_64BIT
-# define i_LW(buf, rs, rt, off) i_ld(buf, rs, rt, off)
-# define i_SW(buf, rs, rt, off) i_sd(buf, rs, rt, off)
-# define i_SLL(buf, rs, rt, sh) i_dsll(buf, rs, rt, sh)
-# define i_SRA(buf, rs, rt, sh) i_dsra(buf, rs, rt, sh)
-# define i_SRL(buf, rs, rt, sh) i_dsrl(buf, rs, rt, sh)
-# define i_MFC0(buf, rt, rd...) i_dmfc0(buf, rt, rd)
-# define i_MTC0(buf, rt, rd...) i_dmtc0(buf, rt, rd)
-# define i_ADDIU(buf, rs, rt, val) i_daddiu(buf, rs, rt, val)
-# define i_ADDU(buf, rs, rt, rd) i_daddu(buf, rs, rt, rd)
-# define i_SUBU(buf, rs, rt, rd) i_dsubu(buf, rs, rt, rd)
-# define i_LL(buf, rs, rt, off) i_lld(buf, rs, rt, off)
-# define i_SC(buf, rs, rt, off) i_scd(buf, rs, rt, off)
-#else
-# define i_LW(buf, rs, rt, off) i_lw(buf, rs, rt, off)
-# define i_SW(buf, rs, rt, off) i_sw(buf, rs, rt, off)
-# define i_SLL(buf, rs, rt, sh) i_sll(buf, rs, rt, sh)
-# define i_SRA(buf, rs, rt, sh) i_sra(buf, rs, rt, sh)
-# define i_SRL(buf, rs, rt, sh) i_srl(buf, rs, rt, sh)
-# define i_MFC0(buf, rt, rd...) i_mfc0(buf, rt, rd)
-# define i_MTC0(buf, rt, rd...) i_mtc0(buf, rt, rd)
-# define i_ADDIU(buf, rs, rt, val) i_addiu(buf, rs, rt, val)
-# define i_ADDU(buf, rs, rt, rd) i_addu(buf, rs, rt, rd)
-# define i_SUBU(buf, rs, rt, rd) i_subu(buf, rs, rt, rd)
-# define i_LL(buf, rs, rt, off) i_ll(buf, rs, rt, off)
-# define i_SC(buf, rs, rt, off) i_sc(buf, rs, rt, off)
-#endif
-
-#define i_b(buf, off) i_beq(buf, 0, 0, off)
-#define i_beqz(buf, rs, off) i_beq(buf, rs, 0, off)
-#define i_beqzl(buf, rs, off) i_beql(buf, rs, 0, off)
-#define i_bnez(buf, rs, off) i_bne(buf, rs, 0, off)
-#define i_bnezl(buf, rs, off) i_bnel(buf, rs, 0, off)
-#define i_move(buf, a, b) i_ADDU(buf, a, 0, b)
-#define i_nop(buf) i_sll(buf, 0, 0, 0)
-#define i_ssnop(buf) i_sll(buf, 0, 0, 1)
-#define i_ehb(buf) i_sll(buf, 0, 0, 3)
-
-static int __init __maybe_unused in_compat_space_p(long addr)
-{
-        /* Is this address in 32bit compat space? */
-#ifdef CONFIG_64BIT
-        return (((addr) & 0xffffffff00000000L) == 0xffffffff00000000L);
-#else
-        return 1;
+UASM_L_LA(_module_alloc)
 #endif
-}
-
-static int __init __maybe_unused rel_highest(long val)
-{
-#ifdef CONFIG_64BIT
-        return ((((val + 0x800080008000L) >> 48) & 0xffff) ^ 0x8000) - 0x8000;
-#else
-        return 0;
-#endif
-}
-
-static int __init __maybe_unused rel_higher(long val)
-{
-#ifdef CONFIG_64BIT
-        return ((((val + 0x80008000L) >> 32) & 0xffff) ^ 0x8000) - 0x8000;
-#else
-        return 0;
-#endif
-}
-
-static int __init rel_hi(long val)
-{
-        return ((((val + 0x8000L) >> 16) & 0xffff) ^ 0x8000) - 0x8000;
-}
-
-static int __init rel_lo(long val)
-{
-        return ((val & 0xffff) ^ 0x8000) - 0x8000;
-}
-
-static void __init i_LA_mostly(u32 **buf, unsigned int rs, long addr)
-{
-        if (!in_compat_space_p(addr)) {
-                i_lui(buf, rs, rel_highest(addr));
-                if (rel_higher(addr))
-                        i_daddiu(buf, rs, rs, rel_higher(addr));
-                if (rel_hi(addr)) {
-                        i_dsll(buf, rs, rs, 16);
-                        i_daddiu(buf, rs, rs, rel_hi(addr));
-                        i_dsll(buf, rs, rs, 16);
-                } else
-                        i_dsll32(buf, rs, rs, 0);
-        } else
-                i_lui(buf, rs, rel_hi(addr));
-}
-
-static void __init __maybe_unused i_LA(u32 **buf, unsigned int rs, long addr)
-{
-        i_LA_mostly(buf, rs, addr);
-        if (rel_lo(addr)) {
-                if (!in_compat_space_p(addr))
-                        i_daddiu(buf, rs, rs, rel_lo(addr));
-                else
-                        i_addiu(buf, rs, rs, rel_lo(addr));
-        }
-}
-
-/*
- * handle relocations
- */
-
-struct reloc {
-        u32 *addr;
-        unsigned int type;
-        enum label_id lab;
-};
-
-static void __init r_mips_pc16(struct reloc **rel, u32 *addr,
-                               enum label_id l)
-{
-        (*rel)->addr = addr;
-        (*rel)->type = R_MIPS_PC16;
-        (*rel)->lab = l;
-        (*rel)++;
-}
-
-static inline void __resolve_relocs(struct reloc *rel, struct label *lab)
-{
-        long laddr = (long)lab->addr;
-        long raddr = (long)rel->addr;
-
-        switch (rel->type) {
-        case R_MIPS_PC16:
-                *rel->addr |= build_bimm(laddr - (raddr + 4));
-                break;
-
-        default:
-                panic("Unsupported TLB synthesizer relocation %d",
-                      rel->type);
-        }
-}
-
-static void __init resolve_relocs(struct reloc *rel, struct label *lab)
-{
-        struct label *l;
-
-        for (; rel->lab != label_invalid; rel++)
-                for (l = lab; l->lab != label_invalid; l++)
-                        if (rel->lab == l->lab)
-                                __resolve_relocs(rel, l);
-}
-
-static void __init move_relocs(struct reloc *rel, u32 *first, u32 *end,
-                               long off)
-{
-        for (; rel->lab != label_invalid; rel++)
-                if (rel->addr >= first && rel->addr < end)
-                        rel->addr += off;
-}
-
-static void __init move_labels(struct label *lab, u32 *first, u32 *end,
-                               long off)
-{
-        for (; lab->lab != label_invalid; lab++)
-                if (lab->addr >= first && lab->addr < end)
-                        lab->addr += off;
-}
-
-static void __init copy_handler(struct reloc *rel, struct label *lab,
-                                u32 *first, u32 *end, u32 *target)
-{
-        long off = (long)(target - first);
-
-        memcpy(target, first, (end - first) * sizeof(u32));
-
-        move_relocs(rel, first, end, off);
-        move_labels(lab, first, end, off);
-}
-
-static int __init __maybe_unused insn_has_bdelay(struct reloc *rel,
-                                                       u32 *addr)
-{
-        for (; rel->lab != label_invalid; rel++) {
-                if (rel->addr == addr
-                    && (rel->type == R_MIPS_PC16
-                        || rel->type == R_MIPS_26))
-                        return 1;
-        }
-
-        return 0;
-}
-
-/* convenience functions for labeled branches */
-static void __init __maybe_unused
-        il_bltz(u32 **p, struct reloc **r, unsigned int reg, enum label_id l)
-{
-        r_mips_pc16(r, *p, l);
-        i_bltz(p, reg, 0);
-}
-
-static void __init __maybe_unused il_b(u32 **p, struct reloc **r,
-                                             enum label_id l)
-{
-        r_mips_pc16(r, *p, l);
-        i_b(p, 0);
-}
-
-static void __init il_beqz(u32 **p, struct reloc **r, unsigned int reg,
-                    enum label_id l)
-{
-        r_mips_pc16(r, *p, l);
-        i_beqz(p, reg, 0);
-}
-
-static void __init __maybe_unused
-il_beqzl(u32 **p, struct reloc **r, unsigned int reg, enum label_id l)
-{
-        r_mips_pc16(r, *p, l);
-        i_beqzl(p, reg, 0);
-}
-
-static void __init il_bnez(u32 **p, struct reloc **r, unsigned int reg,
-                    enum label_id l)
-{
-        r_mips_pc16(r, *p, l);
-        i_bnez(p, reg, 0);
-}
-
-static void __init il_bgezl(u32 **p, struct reloc **r, unsigned int reg,
-                     enum label_id l)
-{
-        r_mips_pc16(r, *p, l);
-        i_bgezl(p, reg, 0);
-}
-
-static void __init __maybe_unused
-il_bgez(u32 **p, struct reloc **r, unsigned int reg, enum label_id l)
-{
-        r_mips_pc16(r, *p, l);
-        i_bgez(p, reg, 0);
-}
+UASM_L_LA(_vmalloc)
+UASM_L_LA(_vmalloc_done)
+UASM_L_LA(_tlbw_hazard)
+UASM_L_LA(_split)
+UASM_L_LA(_nopage_tlbl)
+UASM_L_LA(_nopage_tlbs)
+UASM_L_LA(_nopage_tlbm)
+UASM_L_LA(_smp_pgtable_change)
+UASM_L_LA(_r3000_write_probe_fail)
 
 /*
  * For debug purposes.
@@ -752,9 +131,9 @@ static inline void dump_handler(const u32 *handler, int count)
 #define C0_XCONTEXT     20, 0
 
 #ifdef CONFIG_64BIT
-# define GET_CONTEXT(buf, reg) i_MFC0(buf, reg, C0_XCONTEXT)
+# define GET_CONTEXT(buf, reg) UASM_i_MFC0(buf, reg, C0_XCONTEXT)
 #else
-# define GET_CONTEXT(buf, reg) i_MFC0(buf, reg, C0_CONTEXT)
+# define GET_CONTEXT(buf, reg) UASM_i_MFC0(buf, reg, C0_CONTEXT)
 #endif
 
 /* The worst case length of the handler is around 18 instructions for
@@ -768,8 +147,8 @@ static inline void dump_handler(const u32 *handler, int count)
 static u32 tlb_handler[128] __initdata;
 
 /* simply assume worst case size for labels and relocs */
-static struct label labels[128] __initdata;
-static struct reloc relocs[128] __initdata;
+static struct uasm_label labels[128] __initdata;
+static struct uasm_reloc relocs[128] __initdata;
 
 /*
  * The R3000 TLB handler is simple.
@@ -782,29 +161,29 @@ static void __init build_r3000_tlb_refill_handler(void)
         memset(tlb_handler, 0, sizeof(tlb_handler));
         p = tlb_handler;
 
-        i_mfc0(&p, K0, C0_BADVADDR);
-        i_lui(&p, K1, rel_hi(pgdc)); /* cp0 delay */
-        i_lw(&p, K1, rel_lo(pgdc), K1);
-        i_srl(&p, K0, K0, 22); /* load delay */
-        i_sll(&p, K0, K0, 2);
-        i_addu(&p, K1, K1, K0);
-        i_mfc0(&p, K0, C0_CONTEXT);
-        i_lw(&p, K1, 0, K1); /* cp0 delay */
-        i_andi(&p, K0, K0, 0xffc); /* load delay */
-        i_addu(&p, K1, K1, K0);
-        i_lw(&p, K0, 0, K1);
-        i_nop(&p); /* load delay */
-        i_mtc0(&p, K0, C0_ENTRYLO0);
-        i_mfc0(&p, K1, C0_EPC); /* cp0 delay */
-        i_tlbwr(&p); /* cp0 delay */
-        i_jr(&p, K1);
-        i_rfe(&p); /* branch delay */
+        uasm_i_mfc0(&p, K0, C0_BADVADDR);
+        uasm_i_lui(&p, K1, uasm_rel_hi(pgdc)); /* cp0 delay */
+        uasm_i_lw(&p, K1, uasm_rel_lo(pgdc), K1);
+        uasm_i_srl(&p, K0, K0, 22); /* load delay */
+        uasm_i_sll(&p, K0, K0, 2);
+        uasm_i_addu(&p, K1, K1, K0);
+        uasm_i_mfc0(&p, K0, C0_CONTEXT);
+        uasm_i_lw(&p, K1, 0, K1); /* cp0 delay */
+        uasm_i_andi(&p, K0, K0, 0xffc); /* load delay */
+        uasm_i_addu(&p, K1, K1, K0);
+        uasm_i_lw(&p, K0, 0, K1);
+        uasm_i_nop(&p); /* load delay */
+        uasm_i_mtc0(&p, K0, C0_ENTRYLO0);
+        uasm_i_mfc0(&p, K1, C0_EPC); /* cp0 delay */
+        uasm_i_tlbwr(&p); /* cp0 delay */
+        uasm_i_jr(&p, K1);
+        uasm_i_rfe(&p); /* branch delay */
 
         if (p > tlb_handler + 32)
                 panic("TLB refill handler space exceeded");
 
-        pr_info("Synthesized TLB refill handler (%u instructions).\n",
-                (unsigned int)(p - tlb_handler));
+        pr_debug("Wrote TLB refill handler (%u instructions).\n",
+                 (unsigned int)(p - tlb_handler));
 
         memcpy((void *)ebase, tlb_handler, 0x80);
 
@@ -850,12 +229,12 @@ static void __init __maybe_unused build_tlb_probe_entry(u32 **p)
         case CPU_R5000:
         case CPU_R5000A:
         case CPU_NEVADA:
-                i_nop(p);
-                i_tlbp(p);
+                uasm_i_nop(p);
+                uasm_i_tlbp(p);
                 break;
 
         default:
-                i_tlbp(p);
+                uasm_i_tlbp(p);
                 break;
         }
 }
@@ -866,19 +245,19 @@ static void __init __maybe_unused build_tlb_probe_entry(u32 **p)
  */
 enum tlb_write_entry { tlb_random, tlb_indexed };
 
-static void __init build_tlb_write_entry(u32 **p, struct label **l,
-                                         struct reloc **r,
+static void __init build_tlb_write_entry(u32 **p, struct uasm_label **l,
+                                         struct uasm_reloc **r,
                                          enum tlb_write_entry wmode)
 {
         void(*tlbw)(u32 **) = NULL;
 
         switch (wmode) {
-        case tlb_random: tlbw = i_tlbwr; break;
-        case tlb_indexed: tlbw = i_tlbwi; break;
+        case tlb_random: tlbw = uasm_i_tlbwr; break;
+        case tlb_indexed: tlbw = uasm_i_tlbwi; break;
         }
 
         if (cpu_has_mips_r2) {
-                i_ehb(p);
+                uasm_i_ehb(p);
                 tlbw(p);
                 return;
         }
@@ -894,19 +273,19 @@ static void __init build_tlb_write_entry(u32 **p, struct label **l,
                  * This branch uses up a mtc0 hazard nop slot and saves
                  * two nops after the tlbw instruction.
                  */
-                il_bgezl(p, r, 0, label_tlbw_hazard);
+                uasm_il_bgezl(p, r, 0, label_tlbw_hazard);
                 tlbw(p);
-                l_tlbw_hazard(l, *p);
-                i_nop(p);
+                uasm_l_tlbw_hazard(l, *p);
+                uasm_i_nop(p);
                 break;
 
         case CPU_R4600:
         case CPU_R4700:
         case CPU_R5000:
         case CPU_R5000A:
-                i_nop(p);
+                uasm_i_nop(p);
                 tlbw(p);
-                i_nop(p);
+                uasm_i_nop(p);
                 break;
 
         case CPU_R4300:
@@ -920,7 +299,7 @@ static void __init build_tlb_write_entry(u32 **p, struct label **l,
         case CPU_AU1210:
         case CPU_AU1250:
         case CPU_PR4450:
-                i_nop(p);
+                uasm_i_nop(p);
                 tlbw(p);
                 break;
 
@@ -937,26 +316,26 @@ static void __init build_tlb_write_entry(u32 **p, struct label **l,
         case CPU_BCM4710:
         case CPU_LOONGSON2:
                 if (m4kc_tlbp_war())
-                        i_nop(p);
+                        uasm_i_nop(p);
                 tlbw(p);
                 break;
 
         case CPU_NEVADA:
-                i_nop(p); /* QED specifies 2 nops hazard */
+                uasm_i_nop(p); /* QED specifies 2 nops hazard */
                 /*
                  * This branch uses up a mtc0 hazard nop slot and saves
                  * a nop after the tlbw instruction.
                  */
-                il_bgezl(p, r, 0, label_tlbw_hazard);
+                uasm_il_bgezl(p, r, 0, label_tlbw_hazard);
                 tlbw(p);
-                l_tlbw_hazard(l, *p);
+                uasm_l_tlbw_hazard(l, *p);
                 break;
 
         case CPU_RM7000:
-                i_nop(p);
-                i_nop(p);
-                i_nop(p);
-                i_nop(p);
+                uasm_i_nop(p);
+                uasm_i_nop(p);
+                uasm_i_nop(p);
+                uasm_i_nop(p);
                 tlbw(p);
                 break;
 
@@ -967,15 +346,15 @@ static void __init build_tlb_write_entry(u32 **p, struct label **l,
                  * cpu cycles and use for data translations should not occur
                  * for 3 cpu cycles.
                  */
-                i_ssnop(p);
-                i_ssnop(p);
-                i_ssnop(p);
-                i_ssnop(p);
+                uasm_i_ssnop(p);
+                uasm_i_ssnop(p);
+                uasm_i_ssnop(p);
+                uasm_i_ssnop(p);
                 tlbw(p);
-                i_ssnop(p);
-                i_ssnop(p);
-                i_ssnop(p);
-                i_ssnop(p);
+                uasm_i_ssnop(p);
+                uasm_i_ssnop(p);
+                uasm_i_ssnop(p);
+                uasm_i_ssnop(p);
                 break;
 
         case CPU_VR4111:
@@ -983,18 +362,18 @@ static void __init build_tlb_write_entry(u32 **p, struct label **l,
         case CPU_VR4122:
         case CPU_VR4181:
         case CPU_VR4181A:
-                i_nop(p);
-                i_nop(p);
+                uasm_i_nop(p);
+                uasm_i_nop(p);
                 tlbw(p);
-                i_nop(p);
-                i_nop(p);
+                uasm_i_nop(p);
+                uasm_i_nop(p);
                 break;
 
         case CPU_VR4131:
         case CPU_VR4133:
         case CPU_R5432:
-                i_nop(p);
-                i_nop(p);
+                uasm_i_nop(p);
+                uasm_i_nop(p);
                 tlbw(p);
                 break;
 
@@ -1011,7 +390,7 @@ static void __init build_tlb_write_entry(u32 **p, struct label **l,
  * TMP will be clobbered, PTR will hold the pmd entry.
  */
 static void __init
-build_get_pmde64(u32 **p, struct label **l, struct reloc **r,
+build_get_pmde64(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
                  unsigned int tmp, unsigned int ptr)
 {
         long pgdc = (long)pgd_current;
@@ -1019,52 +398,52 @@ build_get_pmde64(u32 **p, struct label **l, struct reloc **r,
         /*
          * The vmalloc handling is not in the hotpath.
          */
-        i_dmfc0(p, tmp, C0_BADVADDR);
+        uasm_i_dmfc0(p, tmp, C0_BADVADDR);
 #ifdef MODULE_START
-        il_bltz(p, r, tmp, label_module_alloc);
+        uasm_il_bltz(p, r, tmp, label_module_alloc);
 #else
-        il_bltz(p, r, tmp, label_vmalloc);
+        uasm_il_bltz(p, r, tmp, label_vmalloc);
 #endif
-        /* No i_nop needed here, since the next insn doesn't touch TMP. */
+        /* No uasm_i_nop needed here, since the next insn doesn't touch TMP. */
 
 #ifdef CONFIG_SMP
 # ifdef  CONFIG_MIPS_MT_SMTC
         /*
          * SMTC uses TCBind value as "CPU" index
          */
-        i_mfc0(p, ptr, C0_TCBIND);
-        i_dsrl(p, ptr, ptr, 19);
+        uasm_i_mfc0(p, ptr, C0_TCBIND);
+        uasm_i_dsrl(p, ptr, ptr, 19);
 # else
         /*
          * 64 bit SMP running in XKPHYS has smp_processor_id() << 3
          * stored in CONTEXT.
          */
-        i_dmfc0(p, ptr, C0_CONTEXT);
-        i_dsrl(p, ptr, ptr, 23);
+        uasm_i_dmfc0(p, ptr, C0_CONTEXT);
+        uasm_i_dsrl(p, ptr, ptr, 23);
 #endif
-        i_LA_mostly(p, tmp, pgdc);
-        i_daddu(p, ptr, ptr, tmp);
-        i_dmfc0(p, tmp, C0_BADVADDR);
-        i_ld(p, ptr, rel_lo(pgdc), ptr);
+        UASM_i_LA_mostly(p, tmp, pgdc);
+        uasm_i_daddu(p, ptr, ptr, tmp);
+        uasm_i_dmfc0(p, tmp, C0_BADVADDR);
+        uasm_i_ld(p, ptr, uasm_rel_lo(pgdc), ptr);
 #else
-        i_LA_mostly(p, ptr, pgdc);
-        i_ld(p, ptr, rel_lo(pgdc), ptr);
+        UASM_i_LA_mostly(p, ptr, pgdc);
+        uasm_i_ld(p, ptr, uasm_rel_lo(pgdc), ptr);
 #endif
 
-        l_vmalloc_done(l, *p);
+        uasm_l_vmalloc_done(l, *p);
 
         if (PGDIR_SHIFT - 3 < 32)               /* get pgd offset in bytes */
-                i_dsrl(p, tmp, tmp, PGDIR_SHIFT-3);
+                uasm_i_dsrl(p, tmp, tmp, PGDIR_SHIFT-3);
         else
-                i_dsrl32(p, tmp, tmp, PGDIR_SHIFT - 3 - 32);
-
-        i_andi(p, tmp, tmp, (PTRS_PER_PGD - 1)<<3);
-        i_daddu(p, ptr, ptr, tmp); /* add in pgd offset */
-        i_dmfc0(p, tmp, C0_BADVADDR); /* get faulting address */
-        i_ld(p, ptr, 0, ptr); /* get pmd pointer */
-        i_dsrl(p, tmp, tmp, PMD_SHIFT-3); /* get pmd offset in bytes */
-        i_andi(p, tmp, tmp, (PTRS_PER_PMD - 1)<<3);
-        i_daddu(p, ptr, ptr, tmp); /* add in pmd offset */
+                uasm_i_dsrl32(p, tmp, tmp, PGDIR_SHIFT - 3 - 32);
+
+        uasm_i_andi(p, tmp, tmp, (PTRS_PER_PGD - 1)<<3);
+        uasm_i_daddu(p, ptr, ptr, tmp); /* add in pgd offset */
+        uasm_i_dmfc0(p, tmp, C0_BADVADDR); /* get faulting address */
+        uasm_i_ld(p, ptr, 0, ptr); /* get pmd pointer */
+        uasm_i_dsrl(p, tmp, tmp, PMD_SHIFT-3); /* get pmd offset in bytes */
+        uasm_i_andi(p, tmp, tmp, (PTRS_PER_PMD - 1)<<3);
+        uasm_i_daddu(p, ptr, ptr, tmp); /* add in pmd offset */
 }
 
 /*
@@ -1072,7 +451,7 @@ build_get_pmde64(u32 **p, struct label **l, struct reloc **r,
  * PTR will hold the pgd for vmalloc.
  */
 static void __init
-build_get_pgd_vmalloc64(u32 **p, struct label **l, struct reloc **r,
+build_get_pgd_vmalloc64(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
                         unsigned int bvaddr, unsigned int ptr)
 {
         long swpd = (long)swapper_pg_dir;
@@ -1080,58 +459,60 @@ build_get_pgd_vmalloc64(u32 **p, struct label **l, struct reloc **r,
 #ifdef MODULE_START
         long modd = (long)module_pg_dir;
 
-        l_module_alloc(l, *p);
+        uasm_l_module_alloc(l, *p);
         /*
          * Assumption:
          * VMALLOC_START >= 0xc000000000000000UL
          * MODULE_START >= 0xe000000000000000UL
          */
-        i_SLL(p, ptr, bvaddr, 2);
-        il_bgez(p, r, ptr, label_vmalloc);
+        UASM_i_SLL(p, ptr, bvaddr, 2);
+        uasm_il_bgez(p, r, ptr, label_vmalloc);
 
-        if (in_compat_space_p(MODULE_START) && !rel_lo(MODULE_START)) {
-                i_lui(p, ptr, rel_hi(MODULE_START)); /* delay slot */
+        if (uasm_in_compat_space_p(MODULE_START) &&
+            !uasm_rel_lo(MODULE_START)) {
+                uasm_i_lui(p, ptr, uasm_rel_hi(MODULE_START)); /* delay slot */
         } else {
                 /* unlikely configuration */
-                i_nop(p); /* delay slot */
-                i_LA(p, ptr, MODULE_START);
+                uasm_i_nop(p); /* delay slot */
+                UASM_i_LA(p, ptr, MODULE_START);
         }
-        i_dsubu(p, bvaddr, bvaddr, ptr);
+        uasm_i_dsubu(p, bvaddr, bvaddr, ptr);
 
-        if (in_compat_space_p(modd) && !rel_lo(modd)) {
-                il_b(p, r, label_vmalloc_done);
-                i_lui(p, ptr, rel_hi(modd));
+        if (uasm_in_compat_space_p(modd) && !uasm_rel_lo(modd)) {
+                uasm_il_b(p, r, label_vmalloc_done);
+                uasm_i_lui(p, ptr, uasm_rel_hi(modd));
         } else {
-                i_LA_mostly(p, ptr, modd);
-                il_b(p, r, label_vmalloc_done);
-                if (in_compat_space_p(modd))
-                        i_addiu(p, ptr, ptr, rel_lo(modd));
+                UASM_i_LA_mostly(p, ptr, modd);
+                uasm_il_b(p, r, label_vmalloc_done);
+                if (uasm_in_compat_space_p(modd))
+                        uasm_i_addiu(p, ptr, ptr, uasm_rel_lo(modd));
                 else
-                        i_daddiu(p, ptr, ptr, rel_lo(modd));
+                        uasm_i_daddiu(p, ptr, ptr, uasm_rel_lo(modd));
         }
 
-        l_vmalloc(l, *p);
-        if (in_compat_space_p(MODULE_START) && !rel_lo(MODULE_START) &&
+        uasm_l_vmalloc(l, *p);
+        if (uasm_in_compat_space_p(MODULE_START) &&
+            !uasm_rel_lo(MODULE_START) &&
             MODULE_START << 32 == VMALLOC_START)
-                i_dsll32(p, ptr, ptr, 0);       /* typical case */
+                uasm_i_dsll32(p, ptr, ptr, 0);  /* typical case */
         else
-                i_LA(p, ptr, VMALLOC_START);
+                UASM_i_LA(p, ptr, VMALLOC_START);
 #else
-        l_vmalloc(l, *p);
-        i_LA(p, ptr, VMALLOC_START);
+        uasm_l_vmalloc(l, *p);
+        UASM_i_LA(p, ptr, VMALLOC_START);
 #endif
-        i_dsubu(p, bvaddr, bvaddr, ptr);
+        uasm_i_dsubu(p, bvaddr, bvaddr, ptr);
 
-        if (in_compat_space_p(swpd) && !rel_lo(swpd)) {
-                il_b(p, r, label_vmalloc_done);
-                i_lui(p, ptr, rel_hi(swpd));
+        if (uasm_in_compat_space_p(swpd) && !uasm_rel_lo(swpd)) {
+                uasm_il_b(p, r, label_vmalloc_done);
+                uasm_i_lui(p, ptr, uasm_rel_hi(swpd));
         } else {
-                i_LA_mostly(p, ptr, swpd);
-                il_b(p, r, label_vmalloc_done);
-                if (in_compat_space_p(swpd))
-                        i_addiu(p, ptr, ptr, rel_lo(swpd));
+                UASM_i_LA_mostly(p, ptr, swpd);
+                uasm_il_b(p, r, label_vmalloc_done);
+                if (uasm_in_compat_space_p(swpd))
+                        uasm_i_addiu(p, ptr, ptr, uasm_rel_lo(swpd));
                 else
-                        i_daddiu(p, ptr, ptr, rel_lo(swpd));
+                        uasm_i_daddiu(p, ptr, ptr, uasm_rel_lo(swpd));
         }
 }
 
@@ -1152,26 +533,26 @@ build_get_pgde32(u32 **p, unsigned int tmp, unsigned int ptr)
         /*
          * SMTC uses TCBind value as "CPU" index
          */
-        i_mfc0(p, ptr, C0_TCBIND);
-        i_LA_mostly(p, tmp, pgdc);
-        i_srl(p, ptr, ptr, 19);
+        uasm_i_mfc0(p, ptr, C0_TCBIND);
+        UASM_i_LA_mostly(p, tmp, pgdc);
+        uasm_i_srl(p, ptr, ptr, 19);
 #else
         /*
          * smp_processor_id() << 3 is stored in CONTEXT.
          */
-        i_mfc0(p, ptr, C0_CONTEXT);
-        i_LA_mostly(p, tmp, pgdc);
-        i_srl(p, ptr, ptr, 23);
+        uasm_i_mfc0(p, ptr, C0_CONTEXT);
+        UASM_i_LA_mostly(p, tmp, pgdc);
+        uasm_i_srl(p, ptr, ptr, 23);
 #endif
-        i_addu(p, ptr, tmp, ptr);
+        uasm_i_addu(p, ptr, tmp, ptr);
 #else
-        i_LA_mostly(p, ptr, pgdc);
+        UASM_i_LA_mostly(p, ptr, pgdc);
 #endif
-        i_mfc0(p, tmp, C0_BADVADDR); /* get faulting address */
-        i_lw(p, ptr, rel_lo(pgdc), ptr);
-        i_srl(p, tmp, tmp, PGDIR_SHIFT); /* get pgd only bits */
-        i_sll(p, tmp, tmp, PGD_T_LOG2);
-        i_addu(p, ptr, ptr, tmp); /* add in pgd offset */
+        uasm_i_mfc0(p, tmp, C0_BADVADDR); /* get faulting address */
+        uasm_i_lw(p, ptr, uasm_rel_lo(pgdc), ptr);
+        uasm_i_srl(p, tmp, tmp, PGDIR_SHIFT); /* get pgd only bits */
+        uasm_i_sll(p, tmp, tmp, PGD_T_LOG2);
+        uasm_i_addu(p, ptr, ptr, tmp); /* add in pgd offset */
 }
 
 #endif /* !CONFIG_64BIT */
@@ -1198,8 +579,8 @@ static void __init build_adjust_context(u32 **p, unsigned int ctx)
         }
 
         if (shift)
-                i_SRL(p, ctx, ctx, shift);
-        i_andi(p, ctx, ctx, mask);
+                UASM_i_SRL(p, ctx, ctx, shift);
+        uasm_i_andi(p, ctx, ctx, mask);
 }
 
 static void __init build_get_ptep(u32 **p, unsigned int tmp, unsigned int ptr)
@@ -1213,18 +594,18 @@ static void __init build_get_ptep(u32 **p, unsigned int tmp, unsigned int ptr)
          */
         switch (current_cpu_type()) {
         case CPU_NEVADA:
-                i_LW(p, ptr, 0, ptr);
+                UASM_i_LW(p, ptr, 0, ptr);
                 GET_CONTEXT(p, tmp); /* get context reg */
                 break;
 
         default:
                 GET_CONTEXT(p, tmp); /* get context reg */
-                i_LW(p, ptr, 0, ptr);
+                UASM_i_LW(p, ptr, 0, ptr);
                 break;
         }
 
         build_adjust_context(p, tmp);
-        i_ADDU(p, ptr, ptr, tmp); /* add in offset */
+        UASM_i_ADDU(p, ptr, ptr, tmp); /* add in offset */
 }
 
 static void __init build_update_entries(u32 **p, unsigned int tmp,
@@ -1236,45 +617,45 @@ static void __init build_update_entries(u32 **p, unsigned int tmp,
          */
 #ifdef CONFIG_64BIT_PHYS_ADDR
         if (cpu_has_64bits) {
-                i_ld(p, tmp, 0, ptep); /* get even pte */
-                i_ld(p, ptep, sizeof(pte_t), ptep); /* get odd pte */
-                i_dsrl(p, tmp, tmp, 6); /* convert to entrylo0 */
-                i_mtc0(p, tmp, C0_ENTRYLO0); /* load it */
-                i_dsrl(p, ptep, ptep, 6); /* convert to entrylo1 */
-                i_mtc0(p, ptep, C0_ENTRYLO1); /* load it */
+                uasm_i_ld(p, tmp, 0, ptep); /* get even pte */
+                uasm_i_ld(p, ptep, sizeof(pte_t), ptep); /* get odd pte */
+                uasm_i_dsrl(p, tmp, tmp, 6); /* convert to entrylo0 */
+                uasm_i_mtc0(p, tmp, C0_ENTRYLO0); /* load it */
+                uasm_i_dsrl(p, ptep, ptep, 6); /* convert to entrylo1 */
+                uasm_i_mtc0(p, ptep, C0_ENTRYLO1); /* load it */
         } else {
                 int pte_off_even = sizeof(pte_t) / 2;
                 int pte_off_odd = pte_off_even + sizeof(pte_t);
 
                 /* The pte entries are pre-shifted */
-                i_lw(p, tmp, pte_off_even, ptep); /* get even pte */
-                i_mtc0(p, tmp, C0_ENTRYLO0); /* load it */
-                i_lw(p, ptep, pte_off_odd, ptep); /* get odd pte */
-                i_mtc0(p, ptep, C0_ENTRYLO1); /* load it */
+                uasm_i_lw(p, tmp, pte_off_even, ptep); /* get even pte */
+                uasm_i_mtc0(p, tmp, C0_ENTRYLO0); /* load it */
+                uasm_i_lw(p, ptep, pte_off_odd, ptep); /* get odd pte */
+                uasm_i_mtc0(p, ptep, C0_ENTRYLO1); /* load it */
         }
 #else
-        i_LW(p, tmp, 0, ptep); /* get even pte */
-        i_LW(p, ptep, sizeof(pte_t), ptep); /* get odd pte */
+        UASM_i_LW(p, tmp, 0, ptep); /* get even pte */
+        UASM_i_LW(p, ptep, sizeof(pte_t), ptep); /* get odd pte */
         if (r45k_bvahwbug())
                 build_tlb_probe_entry(p);
-        i_SRL(p, tmp, tmp, 6); /* convert to entrylo0 */
+        UASM_i_SRL(p, tmp, tmp, 6); /* convert to entrylo0 */
         if (r4k_250MHZhwbug())
-                i_mtc0(p, 0, C0_ENTRYLO0);
-        i_mtc0(p, tmp, C0_ENTRYLO0); /* load it */
-        i_SRL(p, ptep, ptep, 6); /* convert to entrylo1 */
+                uasm_i_mtc0(p, 0, C0_ENTRYLO0);
+        uasm_i_mtc0(p, tmp, C0_ENTRYLO0); /* load it */
+        UASM_i_SRL(p, ptep, ptep, 6); /* convert to entrylo1 */
         if (r45k_bvahwbug())
-                i_mfc0(p, tmp, C0_INDEX);
+                uasm_i_mfc0(p, tmp, C0_INDEX);
         if (r4k_250MHZhwbug())
-                i_mtc0(p, 0, C0_ENTRYLO1);
-        i_mtc0(p, ptep, C0_ENTRYLO1); /* load it */
+                uasm_i_mtc0(p, 0, C0_ENTRYLO1);
+        uasm_i_mtc0(p, ptep, C0_ENTRYLO1); /* load it */
 #endif
 }
 
 static void __init build_r4000_tlb_refill_handler(void)
 {
         u32 *p = tlb_handler;
-        struct label *l = labels;
-        struct reloc *r = relocs;
+        struct uasm_label *l = labels;
+        struct uasm_reloc *r = relocs;
         u32 *f;
         unsigned int final_len;
 
@@ -1287,12 +668,12 @@ static void __init build_r4000_tlb_refill_handler(void)
          * create the plain linear handler
          */
         if (bcm1250_m3_war()) {
-                i_MFC0(&p, K0, C0_BADVADDR);
-                i_MFC0(&p, K1, C0_ENTRYHI);
-                i_xor(&p, K0, K0, K1);
-                i_SRL(&p, K0, K0, PAGE_SHIFT + 1);
-                il_bnez(&p, &r, K0, label_leave);
-                /* No need for i_nop */
+                UASM_i_MFC0(&p, K0, C0_BADVADDR);
+                UASM_i_MFC0(&p, K1, C0_ENTRYHI);
+                uasm_i_xor(&p, K0, K0, K1);
+                UASM_i_SRL(&p, K0, K0, PAGE_SHIFT + 1);
+                uasm_il_bnez(&p, &r, K0, label_leave);
+                /* No need for uasm_i_nop */
         }
 
 #ifdef CONFIG_64BIT
@@ -1304,8 +685,8 @@ static void __init build_r4000_tlb_refill_handler(void)
         build_get_ptep(&p, K0, K1);
         build_update_entries(&p, K0, K1);
         build_tlb_write_entry(&p, &l, &r, tlb_random);
-        l_leave(&l, p);
-        i_eret(&p); /* return from trap */
+        uasm_l_leave(&l, p);
+        uasm_i_eret(&p); /* return from trap */
 
 #ifdef CONFIG_64BIT
         build_get_pgd_vmalloc64(&p, &l, &r, K0, K1);
@@ -1325,7 +706,7 @@ static void __init build_r4000_tlb_refill_handler(void)
 #else
         if (((p - tlb_handler) > 63)
             || (((p - tlb_handler) > 61)
-                && insn_has_bdelay(relocs, tlb_handler + 29)))
+                && uasm_insn_has_bdelay(relocs, tlb_handler + 29)))
                 panic("TLB refill handler space exceeded");
 #endif
 
@@ -1335,13 +716,13 @@ static void __init build_r4000_tlb_refill_handler(void)
 #if defined(CONFIG_32BIT) || defined(CONFIG_CPU_LOONGSON2)
         f = final_handler;
         /* Simplest case, just copy the handler. */
-        copy_handler(relocs, labels, tlb_handler, p, f);
+        uasm_copy_handler(relocs, labels, tlb_handler, p, f);
         final_len = p - tlb_handler;
 #else /* CONFIG_64BIT */
         f = final_handler + 32;
         if ((p - tlb_handler) <= 32) {
                 /* Just copy the handler. */
-                copy_handler(relocs, labels, tlb_handler, p, f);
+                uasm_copy_handler(relocs, labels, tlb_handler, p, f);
                 final_len = p - tlb_handler;
         } else {
                 u32 *split = tlb_handler + 30;
@@ -1349,34 +730,34 @@ static void __init build_r4000_tlb_refill_handler(void)
                 /*
                  * Find the split point.
                  */
-                if (insn_has_bdelay(relocs, split - 1))
+                if (uasm_insn_has_bdelay(relocs, split - 1))
                         split--;
 
                 /* Copy first part of the handler. */
-                copy_handler(relocs, labels, tlb_handler, split, f);
+                uasm_copy_handler(relocs, labels, tlb_handler, split, f);
                 f += split - tlb_handler;
 
                 /* Insert branch. */
-                l_split(&l, final_handler);
-                il_b(&f, &r, label_split);
-                if (insn_has_bdelay(relocs, split))
-                        i_nop(&f);
+                uasm_l_split(&l, final_handler);
+                uasm_il_b(&f, &r, label_split);
+                if (uasm_insn_has_bdelay(relocs, split))
+                        uasm_i_nop(&f);
                 else {
-                        copy_handler(relocs, labels, split, split + 1, f);
-                        move_labels(labels, f, f + 1, -1);
+                        uasm_copy_handler(relocs, labels, split, split + 1, f);
+                        uasm_move_labels(labels, f, f + 1, -1);
                         f++;
                         split++;
                 }
 
                 /* Copy the rest of the handler. */
-                copy_handler(relocs, labels, split, p, final_handler);
+                uasm_copy_handler(relocs, labels, split, p, final_handler);
                 final_len = (f - (final_handler + 32)) + (p - split);
         }
 #endif /* CONFIG_64BIT */
 
-        resolve_relocs(relocs, labels);
-        pr_info("Synthesized TLB refill handler (%u instructions).\n",
-                final_len);
+        uasm_resolve_relocs(relocs, labels);
+        pr_debug("Wrote TLB refill handler (%u instructions).\n",
+                 final_len);
 
         memcpy((void *)ebase, final_handler, 0x100);
 
@@ -1403,75 +784,75 @@ u32 handle_tlbs[FASTPATH_SIZE] __cacheline_aligned;
 u32 handle_tlbm[FASTPATH_SIZE] __cacheline_aligned;
 
 static void __init
-iPTE_LW(u32 **p, struct label **l, unsigned int pte, unsigned int ptr)
+iPTE_LW(u32 **p, struct uasm_label **l, unsigned int pte, unsigned int ptr)
 {
 #ifdef CONFIG_SMP
 # ifdef CONFIG_64BIT_PHYS_ADDR
         if (cpu_has_64bits)
-                i_lld(p, pte, 0, ptr);
+                uasm_i_lld(p, pte, 0, ptr);
         else
 # endif
-                i_LL(p, pte, 0, ptr);
+                UASM_i_LL(p, pte, 0, ptr);
 #else
 # ifdef CONFIG_64BIT_PHYS_ADDR
         if (cpu_has_64bits)
-                i_ld(p, pte, 0, ptr);
+                uasm_i_ld(p, pte, 0, ptr);
         else
 # endif
-                i_LW(p, pte, 0, ptr);
+                UASM_i_LW(p, pte, 0, ptr);
 #endif
 }
 
 static void __init
-iPTE_SW(u32 **p, struct reloc **r, unsigned int pte, unsigned int ptr,
+iPTE_SW(u32 **p, struct uasm_reloc **r, unsigned int pte, unsigned int ptr,
         unsigned int mode)
 {
 #ifdef CONFIG_64BIT_PHYS_ADDR
         unsigned int hwmode = mode & (_PAGE_VALID | _PAGE_DIRTY);
 #endif
 
-        i_ori(p, pte, pte, mode);
+        uasm_i_ori(p, pte, pte, mode);
 #ifdef CONFIG_SMP
 # ifdef CONFIG_64BIT_PHYS_ADDR
         if (cpu_has_64bits)
-                i_scd(p, pte, 0, ptr);
+                uasm_i_scd(p, pte, 0, ptr);
         else
 # endif
-                i_SC(p, pte, 0, ptr);
+                UASM_i_SC(p, pte, 0, ptr);
 
         if (r10000_llsc_war())
-                il_beqzl(p, r, pte, label_smp_pgtable_change);
+                uasm_il_beqzl(p, r, pte, label_smp_pgtable_change);
         else
-                il_beqz(p, r, pte, label_smp_pgtable_change);
+                uasm_il_beqz(p, r, pte, label_smp_pgtable_change);
 
 # ifdef CONFIG_64BIT_PHYS_ADDR
         if (!cpu_has_64bits) {
-                /* no i_nop needed */
-                i_ll(p, pte, sizeof(pte_t) / 2, ptr);
-                i_ori(p, pte, pte, hwmode);
-                i_sc(p, pte, sizeof(pte_t) / 2, ptr);
-                il_beqz(p, r, pte, label_smp_pgtable_change);
-                /* no i_nop needed */
-                i_lw(p, pte, 0, ptr);
+                /* no uasm_i_nop needed */
+                uasm_i_ll(p, pte, sizeof(pte_t) / 2, ptr);
+                uasm_i_ori(p, pte, pte, hwmode);
+                uasm_i_sc(p, pte, sizeof(pte_t) / 2, ptr);
+                uasm_il_beqz(p, r, pte, label_smp_pgtable_change);
+                /* no uasm_i_nop needed */
+                uasm_i_lw(p, pte, 0, ptr);
         } else
-                i_nop(p);
+                uasm_i_nop(p);
 # else
-        i_nop(p);
+        uasm_i_nop(p);
 # endif
 #else
 # ifdef CONFIG_64BIT_PHYS_ADDR
         if (cpu_has_64bits)
-                i_sd(p, pte, 0, ptr);
+                uasm_i_sd(p, pte, 0, ptr);
         else
 # endif
-                i_SW(p, pte, 0, ptr);
+                UASM_i_SW(p, pte, 0, ptr);
 
 # ifdef CONFIG_64BIT_PHYS_ADDR
         if (!cpu_has_64bits) {
-                i_lw(p, pte, sizeof(pte_t) / 2, ptr);
-                i_ori(p, pte, pte, hwmode);
-                i_sw(p, pte, sizeof(pte_t) / 2, ptr);
-                i_lw(p, pte, 0, ptr);
+                uasm_i_lw(p, pte, sizeof(pte_t) / 2, ptr);
+                uasm_i_ori(p, pte, pte, hwmode);
+                uasm_i_sw(p, pte, sizeof(pte_t) / 2, ptr);
+                uasm_i_lw(p, pte, 0, ptr);
         }
 # endif
 #endif
@@ -1483,18 +864,18 @@ iPTE_SW(u32 **p, struct reloc **r, unsigned int pte, unsigned int ptr,
  * with it's original value.
  */
 static void __init
-build_pte_present(u32 **p, struct label **l, struct reloc **r,
+build_pte_present(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
                   unsigned int pte, unsigned int ptr, enum label_id lid)
 {
-        i_andi(p, pte, pte, _PAGE_PRESENT | _PAGE_READ);
-        i_xori(p, pte, pte, _PAGE_PRESENT | _PAGE_READ);
-        il_bnez(p, r, pte, lid);
+        uasm_i_andi(p, pte, pte, _PAGE_PRESENT | _PAGE_READ);
+        uasm_i_xori(p, pte, pte, _PAGE_PRESENT | _PAGE_READ);
+        uasm_il_bnez(p, r, pte, lid);
         iPTE_LW(p, l, pte, ptr);
 }
 
 /* Make PTE valid, store result in PTR. */
 static void __init
-build_make_valid(u32 **p, struct reloc **r, unsigned int pte,
+build_make_valid(u32 **p, struct uasm_reloc **r, unsigned int pte,
                  unsigned int ptr)
 {
         unsigned int mode = _PAGE_VALID | _PAGE_ACCESSED;
@@ -1507,12 +888,12 @@ build_make_valid(u32 **p, struct reloc **r, unsigned int pte,
  * restore PTE with value from PTR when done.
  */
 static void __init
-build_pte_writable(u32 **p, struct label **l, struct reloc **r,
+build_pte_writable(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
                    unsigned int pte, unsigned int ptr, enum label_id lid)
 {
-        i_andi(p, pte, pte, _PAGE_PRESENT | _PAGE_WRITE);
-        i_xori(p, pte, pte, _PAGE_PRESENT | _PAGE_WRITE);
-        il_bnez(p, r, pte, lid);
+        uasm_i_andi(p, pte, pte, _PAGE_PRESENT | _PAGE_WRITE);
+        uasm_i_xori(p, pte, pte, _PAGE_PRESENT | _PAGE_WRITE);
+        uasm_il_bnez(p, r, pte, lid);
         iPTE_LW(p, l, pte, ptr);
 }
 
@@ -1520,7 +901,7 @@ build_pte_writable(u32 **p, struct label **l, struct reloc **r,
  * at PTR.
  */
 static void __init
-build_make_write(u32 **p, struct reloc **r, unsigned int pte,
+build_make_write(u32 **p, struct uasm_reloc **r, unsigned int pte,
                  unsigned int ptr)
 {
         unsigned int mode = (_PAGE_ACCESSED | _PAGE_MODIFIED | _PAGE_VALID
@@ -1534,11 +915,11 @@ build_make_write(u32 **p, struct reloc **r, unsigned int pte,
  * restore PTE with value from PTR when done.
  */
 static void __init
-build_pte_modifiable(u32 **p, struct label **l, struct reloc **r,
+build_pte_modifiable(u32 **p, struct uasm_label **l, struct uasm_reloc **r,
                      unsigned int pte, unsigned int ptr, enum label_id lid)
 {
-        i_andi(p, pte, pte, _PAGE_WRITE);
-        il_beqz(p, r, pte, lid);
+        uasm_i_andi(p, pte, pte, _PAGE_WRITE);
+        uasm_il_beqz(p, r, pte, lid);
         iPTE_LW(p, l, pte, ptr);
 }
 
@@ -1553,11 +934,11 @@ build_pte_modifiable(u32 **p, struct label **l, struct reloc **r,
 static void __init
 build_r3000_pte_reload_tlbwi(u32 **p, unsigned int pte, unsigned int tmp)
 {
-        i_mtc0(p, pte, C0_ENTRYLO0); /* cp0 delay */
-        i_mfc0(p, tmp, C0_EPC); /* cp0 delay */
-        i_tlbwi(p);
-        i_jr(p, tmp);
-        i_rfe(p); /* branch delay */
+        uasm_i_mtc0(p, pte, C0_ENTRYLO0); /* cp0 delay */
+        uasm_i_mfc0(p, tmp, C0_EPC); /* cp0 delay */
+        uasm_i_tlbwi(p);
+        uasm_i_jr(p, tmp);
+        uasm_i_rfe(p); /* branch delay */
 }
 
 /*
@@ -1567,20 +948,21 @@ build_r3000_pte_reload_tlbwi(u32 **p, unsigned int pte, unsigned int tmp)
  * kseg2 access, i.e. without refill.  Then it returns.
  */
 static void __init
-build_r3000_tlb_reload_write(u32 **p, struct label **l, struct reloc **r,
-                             unsigned int pte, unsigned int tmp)
-{
-        i_mfc0(p, tmp, C0_INDEX);
-        i_mtc0(p, pte, C0_ENTRYLO0); /* cp0 delay */
-        il_bltz(p, r, tmp, label_r3000_write_probe_fail); /* cp0 delay */
-        i_mfc0(p, tmp, C0_EPC); /* branch delay */
-        i_tlbwi(p); /* cp0 delay */
-        i_jr(p, tmp);
-        i_rfe(p); /* branch delay */
-        l_r3000_write_probe_fail(l, *p);
-        i_tlbwr(p); /* cp0 delay */
-        i_jr(p, tmp);
-        i_rfe(p); /* branch delay */
+build_r3000_tlb_reload_write(u32 **p, struct uasm_label **l,
+                             struct uasm_reloc **r, unsigned int pte,
+                             unsigned int tmp)
+{
+        uasm_i_mfc0(p, tmp, C0_INDEX);
+        uasm_i_mtc0(p, pte, C0_ENTRYLO0); /* cp0 delay */
+        uasm_il_bltz(p, r, tmp, label_r3000_write_probe_fail); /* cp0 delay */
+        uasm_i_mfc0(p, tmp, C0_EPC); /* branch delay */
+        uasm_i_tlbwi(p); /* cp0 delay */
+        uasm_i_jr(p, tmp);
+        uasm_i_rfe(p); /* branch delay */
+        uasm_l_r3000_write_probe_fail(l, *p);
+        uasm_i_tlbwr(p); /* cp0 delay */
+        uasm_i_jr(p, tmp);
+        uasm_i_rfe(p); /* branch delay */
 }
 
 static void __init
@@ -1589,25 +971,25 @@ build_r3000_tlbchange_handler_head(u32 **p, unsigned int pte,
 {
         long pgdc = (long)pgd_current;
 
-        i_mfc0(p, pte, C0_BADVADDR);
-        i_lui(p, ptr, rel_hi(pgdc)); /* cp0 delay */
-        i_lw(p, ptr, rel_lo(pgdc), ptr);
-        i_srl(p, pte, pte, 22); /* load delay */
-        i_sll(p, pte, pte, 2);
-        i_addu(p, ptr, ptr, pte);
-        i_mfc0(p, pte, C0_CONTEXT);
-        i_lw(p, ptr, 0, ptr); /* cp0 delay */
-        i_andi(p, pte, pte, 0xffc); /* load delay */
-        i_addu(p, ptr, ptr, pte);
-        i_lw(p, pte, 0, ptr);
-        i_tlbp(p); /* load delay */
+        uasm_i_mfc0(p, pte, C0_BADVADDR);
+        uasm_i_lui(p, ptr, uasm_rel_hi(pgdc)); /* cp0 delay */
+        uasm_i_lw(p, ptr, uasm_rel_lo(pgdc), ptr);
+        uasm_i_srl(p, pte, pte, 22); /* load delay */
+        uasm_i_sll(p, pte, pte, 2);
+        uasm_i_addu(p, ptr, ptr, pte);
+        uasm_i_mfc0(p, pte, C0_CONTEXT);
+        uasm_i_lw(p, ptr, 0, ptr); /* cp0 delay */
+        uasm_i_andi(p, pte, pte, 0xffc); /* load delay */
+        uasm_i_addu(p, ptr, ptr, pte);
+        uasm_i_lw(p, pte, 0, ptr);
+        uasm_i_tlbp(p); /* load delay */
 }
 
 static void __init build_r3000_tlb_load_handler(void)
 {
         u32 *p = handle_tlbl;
-        struct label *l = labels;
-        struct reloc *r = relocs;
+        struct uasm_label *l = labels;
+        struct uasm_reloc *r = relocs;
 
         memset(handle_tlbl, 0, sizeof(handle_tlbl));
         memset(labels, 0, sizeof(labels));
@@ -1615,20 +997,20 @@ static void __init build_r3000_tlb_load_handler(void)
 
         build_r3000_tlbchange_handler_head(&p, K0, K1);
         build_pte_present(&p, &l, &r, K0, K1, label_nopage_tlbl);
-        i_nop(&p); /* load delay */
+        uasm_i_nop(&p); /* load delay */
         build_make_valid(&p, &r, K0, K1);
         build_r3000_tlb_reload_write(&p, &l, &r, K0, K1);
 
-        l_nopage_tlbl(&l, p);
-        i_j(&p, (unsigned long)tlb_do_page_fault_0 & 0x0fffffff);
-        i_nop(&p);
+        uasm_l_nopage_tlbl(&l, p);
+        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_0 & 0x0fffffff);
+        uasm_i_nop(&p);
 
         if ((p - handle_tlbl) > FASTPATH_SIZE)
                 panic("TLB load handler fastpath space exceeded");
 
-        resolve_relocs(relocs, labels);
-        pr_info("Synthesized TLB load handler fastpath (%u instructions).\n",
-                (unsigned int)(p - handle_tlbl));
+        uasm_resolve_relocs(relocs, labels);
+        pr_debug("Wrote TLB load handler fastpath (%u instructions).\n",
+                 (unsigned int)(p - handle_tlbl));
 
         dump_handler(handle_tlbl, ARRAY_SIZE(handle_tlbl));
 }
@@ -1636,8 +1018,8 @@ static void __init build_r3000_tlb_load_handler(void)
 static void __init build_r3000_tlb_store_handler(void)
 {
         u32 *p = handle_tlbs;
-        struct label *l = labels;
-        struct reloc *r = relocs;
+        struct uasm_label *l = labels;
+        struct uasm_reloc *r = relocs;
 
         memset(handle_tlbs, 0, sizeof(handle_tlbs));
         memset(labels, 0, sizeof(labels));
@@ -1645,20 +1027,20 @@ static void __init build_r3000_tlb_store_handler(void)
 
         build_r3000_tlbchange_handler_head(&p, K0, K1);
         build_pte_writable(&p, &l, &r, K0, K1, label_nopage_tlbs);
-        i_nop(&p); /* load delay */
+        uasm_i_nop(&p); /* load delay */
         build_make_write(&p, &r, K0, K1);
         build_r3000_tlb_reload_write(&p, &l, &r, K0, K1);
 
-        l_nopage_tlbs(&l, p);
-        i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
-        i_nop(&p);
+        uasm_l_nopage_tlbs(&l, p);
+        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
+        uasm_i_nop(&p);
 
         if ((p - handle_tlbs) > FASTPATH_SIZE)
                 panic("TLB store handler fastpath space exceeded");
 
-        resolve_relocs(relocs, labels);
-        pr_info("Synthesized TLB store handler fastpath (%u instructions).\n",
-                (unsigned int)(p - handle_tlbs));
+        uasm_resolve_relocs(relocs, labels);
+        pr_debug("Wrote TLB store handler fastpath (%u instructions).\n",
+                 (unsigned int)(p - handle_tlbs));
 
         dump_handler(handle_tlbs, ARRAY_SIZE(handle_tlbs));
 }
@@ -1666,8 +1048,8 @@ static void __init build_r3000_tlb_store_handler(void)
 static void __init build_r3000_tlb_modify_handler(void)
 {
         u32 *p = handle_tlbm;
-        struct label *l = labels;
-        struct reloc *r = relocs;
+        struct uasm_label *l = labels;
+        struct uasm_reloc *r = relocs;
 
         memset(handle_tlbm, 0, sizeof(handle_tlbm));
         memset(labels, 0, sizeof(labels));
@@ -1675,20 +1057,20 @@ static void __init build_r3000_tlb_modify_handler(void)
 
         build_r3000_tlbchange_handler_head(&p, K0, K1);
         build_pte_modifiable(&p, &l, &r, K0, K1, label_nopage_tlbm);
-        i_nop(&p); /* load delay */
+        uasm_i_nop(&p); /* load delay */
         build_make_write(&p, &r, K0, K1);
         build_r3000_pte_reload_tlbwi(&p, K0, K1);
 
-        l_nopage_tlbm(&l, p);
-        i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
-        i_nop(&p);
+        uasm_l_nopage_tlbm(&l, p);
+        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
+        uasm_i_nop(&p);
 
         if ((p - handle_tlbm) > FASTPATH_SIZE)
                 panic("TLB modify handler fastpath space exceeded");
 
-        resolve_relocs(relocs, labels);
-        pr_info("Synthesized TLB modify handler fastpath (%u instructions).\n",
-                (unsigned int)(p - handle_tlbm));
+        uasm_resolve_relocs(relocs, labels);
+        pr_debug("Wrote TLB modify handler fastpath (%u instructions).\n",
+                 (unsigned int)(p - handle_tlbm));
 
         dump_handler(handle_tlbm, ARRAY_SIZE(handle_tlbm));
 }
@@ -1697,8 +1079,8 @@ static void __init build_r3000_tlb_modify_handler(void)
  * R4000 style TLB load/store/modify handlers.
  */
 static void __init
-build_r4000_tlbchange_handler_head(u32 **p, struct label **l,
-                                   struct reloc **r, unsigned int pte,
+build_r4000_tlbchange_handler_head(u32 **p, struct uasm_label **l,
+                                   struct uasm_reloc **r, unsigned int pte,
                                    unsigned int ptr)
 {
 #ifdef CONFIG_64BIT
@@ -1707,31 +1089,31 @@ build_r4000_tlbchange_handler_head(u32 **p, struct label **l,
         build_get_pgde32(p, pte, ptr); /* get pgd in ptr */
 #endif
 
-        i_MFC0(p, pte, C0_BADVADDR);
-        i_LW(p, ptr, 0, ptr);
-        i_SRL(p, pte, pte, PAGE_SHIFT + PTE_ORDER - PTE_T_LOG2);
-        i_andi(p, pte, pte, (PTRS_PER_PTE - 1) << PTE_T_LOG2);
-        i_ADDU(p, ptr, ptr, pte);
+        UASM_i_MFC0(p, pte, C0_BADVADDR);
+        UASM_i_LW(p, ptr, 0, ptr);
+        UASM_i_SRL(p, pte, pte, PAGE_SHIFT + PTE_ORDER - PTE_T_LOG2);
+        uasm_i_andi(p, pte, pte, (PTRS_PER_PTE - 1) << PTE_T_LOG2);
+        UASM_i_ADDU(p, ptr, ptr, pte);
 
 #ifdef CONFIG_SMP
-        l_smp_pgtable_change(l, *p);
-# endif
+        uasm_l_smp_pgtable_change(l, *p);
+#endif
         iPTE_LW(p, l, pte, ptr); /* get even pte */
         if (!m4kc_tlbp_war())
                 build_tlb_probe_entry(p);
 }
 
 static void __init
-build_r4000_tlbchange_handler_tail(u32 **p, struct label **l,
-                                   struct reloc **r, unsigned int tmp,
+build_r4000_tlbchange_handler_tail(u32 **p, struct uasm_label **l,
+                                   struct uasm_reloc **r, unsigned int tmp,
                                    unsigned int ptr)
 {
-        i_ori(p, ptr, ptr, sizeof(pte_t));
-        i_xori(p, ptr, ptr, sizeof(pte_t));
+        uasm_i_ori(p, ptr, ptr, sizeof(pte_t));
+        uasm_i_xori(p, ptr, ptr, sizeof(pte_t));
         build_update_entries(p, tmp, ptr);
         build_tlb_write_entry(p, l, r, tlb_indexed);
-        l_leave(l, *p);
-        i_eret(p); /* return from trap */
+        uasm_l_leave(l, *p);
+        uasm_i_eret(p); /* return from trap */
 
 #ifdef CONFIG_64BIT
         build_get_pgd_vmalloc64(p, l, r, tmp, ptr);
@@ -1741,20 +1123,20 @@ build_r4000_tlbchange_handler_tail(u32 **p, struct label **l,
 static void __init build_r4000_tlb_load_handler(void)
 {
         u32 *p = handle_tlbl;
-        struct label *l = labels;
-        struct reloc *r = relocs;
+        struct uasm_label *l = labels;
+        struct uasm_reloc *r = relocs;
 
         memset(handle_tlbl, 0, sizeof(handle_tlbl));
         memset(labels, 0, sizeof(labels));
         memset(relocs, 0, sizeof(relocs));
 
         if (bcm1250_m3_war()) {
-                i_MFC0(&p, K0, C0_BADVADDR);
-                i_MFC0(&p, K1, C0_ENTRYHI);
-                i_xor(&p, K0, K0, K1);
-                i_SRL(&p, K0, K0, PAGE_SHIFT + 1);
-                il_bnez(&p, &r, K0, label_leave);
-                /* No need for i_nop */
+                UASM_i_MFC0(&p, K0, C0_BADVADDR);
+                UASM_i_MFC0(&p, K1, C0_ENTRYHI);
+                uasm_i_xor(&p, K0, K0, K1);
+                UASM_i_SRL(&p, K0, K0, PAGE_SHIFT + 1);
+                uasm_il_bnez(&p, &r, K0, label_leave);
+                /* No need for uasm_i_nop */
         }
 
         build_r4000_tlbchange_handler_head(&p, &l, &r, K0, K1);
@@ -1764,16 +1146,16 @@ static void __init build_r4000_tlb_load_handler(void)
         build_make_valid(&p, &r, K0, K1);
         build_r4000_tlbchange_handler_tail(&p, &l, &r, K0, K1);
 
-        l_nopage_tlbl(&l, p);
-        i_j(&p, (unsigned long)tlb_do_page_fault_0 & 0x0fffffff);
-        i_nop(&p);
+        uasm_l_nopage_tlbl(&l, p);
+        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_0 & 0x0fffffff);
+        uasm_i_nop(&p);
 
         if ((p - handle_tlbl) > FASTPATH_SIZE)
                 panic("TLB load handler fastpath space exceeded");
 
-        resolve_relocs(relocs, labels);
-        pr_info("Synthesized TLB load handler fastpath (%u instructions).\n",
-                (unsigned int)(p - handle_tlbl));
+        uasm_resolve_relocs(relocs, labels);
+        pr_debug("Wrote TLB load handler fastpath (%u instructions).\n",
+                 (unsigned int)(p - handle_tlbl));
 
         dump_handler(handle_tlbl, ARRAY_SIZE(handle_tlbl));
 }
@@ -1781,8 +1163,8 @@ static void __init build_r4000_tlb_load_handler(void)
 static void __init build_r4000_tlb_store_handler(void)
 {
         u32 *p = handle_tlbs;
-        struct label *l = labels;
-        struct reloc *r = relocs;
+        struct uasm_label *l = labels;
+        struct uasm_reloc *r = relocs;
 
         memset(handle_tlbs, 0, sizeof(handle_tlbs));
         memset(labels, 0, sizeof(labels));
@@ -1795,16 +1177,16 @@ static void __init build_r4000_tlb_store_handler(void)
         build_make_write(&p, &r, K0, K1);
         build_r4000_tlbchange_handler_tail(&p, &l, &r, K0, K1);
 
-        l_nopage_tlbs(&l, p);
-        i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
-        i_nop(&p);
+        uasm_l_nopage_tlbs(&l, p);
+        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
+        uasm_i_nop(&p);
 
         if ((p - handle_tlbs) > FASTPATH_SIZE)
                 panic("TLB store handler fastpath space exceeded");
 
-        resolve_relocs(relocs, labels);
-        pr_info("Synthesized TLB store handler fastpath (%u instructions).\n",
-                (unsigned int)(p - handle_tlbs));
+        uasm_resolve_relocs(relocs, labels);
+        pr_debug("Wrote TLB store handler fastpath (%u instructions).\n",
+                 (unsigned int)(p - handle_tlbs));
 
         dump_handler(handle_tlbs, ARRAY_SIZE(handle_tlbs));
 }
@@ -1812,8 +1194,8 @@ static void __init build_r4000_tlb_store_handler(void)
 static void __init build_r4000_tlb_modify_handler(void)
 {
         u32 *p = handle_tlbm;
-        struct label *l = labels;
-        struct reloc *r = relocs;
+        struct uasm_label *l = labels;
+        struct uasm_reloc *r = relocs;
 
         memset(handle_tlbm, 0, sizeof(handle_tlbm));
         memset(labels, 0, sizeof(labels));
@@ -1827,16 +1209,16 @@ static void __init build_r4000_tlb_modify_handler(void)
         build_make_write(&p, &r, K0, K1);
         build_r4000_tlbchange_handler_tail(&p, &l, &r, K0, K1);
 
-        l_nopage_tlbm(&l, p);
-        i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
-        i_nop(&p);
+        uasm_l_nopage_tlbm(&l, p);
+        uasm_i_j(&p, (unsigned long)tlb_do_page_fault_1 & 0x0fffffff);
+        uasm_i_nop(&p);
 
         if ((p - handle_tlbm) > FASTPATH_SIZE)
                 panic("TLB modify handler fastpath space exceeded");
 
-        resolve_relocs(relocs, labels);
-        pr_info("Synthesized TLB modify handler fastpath (%u instructions).\n",
-                (unsigned int)(p - handle_tlbm));
+        uasm_resolve_relocs(relocs, labels);
+        pr_debug("Wrote TLB modify handler fastpath (%u instructions).\n",
+                 (unsigned int)(p - handle_tlbm));
 
         dump_handler(handle_tlbm, ARRAY_SIZE(handle_tlbm));
 }
diff --git a/arch/mips/mm/uasm.c b/arch/mips/mm/uasm.c
new file mode 100644
index 000000000000..e3f74ed5f704
--- /dev/null
+++ b/arch/mips/mm/uasm.c
@@ -0,0 +1,576 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * A small micro-assembler. It is intentionally kept simple, does only
+ * support a subset of instructions, and does not try to hide pipeline
+ * effects like branch delay slots.
+ *
+ * Copyright (C) 2004, 2005, 2006, 2008  Thiemo Seufer
+ * Copyright (C) 2005, 2007  Maciej W. Rozycki
+ * Copyright (C) 2006  Ralf Baechle (ralf@linux-mips.org)
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/init.h>
+
+#include <asm/inst.h>
+#include <asm/elf.h>
+#include <asm/bugs.h>
+
+#include "uasm.h"
+
+enum fields {
+        RS = 0x001,
+        RT = 0x002,
+        RD = 0x004,
+        RE = 0x008,
+        SIMM = 0x010,
+        UIMM = 0x020,
+        BIMM = 0x040,
+        JIMM = 0x080,
+        FUNC = 0x100,
+        SET = 0x200
+};
+
+#define OP_MASK         0x3f
+#define OP_SH           26
+#define RS_MASK         0x1f
+#define RS_SH           21
+#define RT_MASK         0x1f
+#define RT_SH           16
+#define RD_MASK         0x1f
+#define RD_SH           11
+#define RE_MASK         0x1f
+#define RE_SH           6
+#define IMM_MASK        0xffff
+#define IMM_SH          0
+#define JIMM_MASK       0x3ffffff
+#define JIMM_SH         0
+#define FUNC_MASK       0x3f
+#define FUNC_SH         0
+#define SET_MASK        0x7
+#define SET_SH          0
+
+enum opcode {
+        insn_invalid,
+        insn_addu, insn_addiu, insn_and, insn_andi, insn_beq,
+        insn_beql, insn_bgez, insn_bgezl, insn_bltz, insn_bltzl,
+        insn_bne, insn_daddu, insn_daddiu, insn_dmfc0, insn_dmtc0,
+        insn_dsll, insn_dsll32, insn_dsra, insn_dsrl, insn_dsrl32,
+        insn_dsubu, insn_eret, insn_j, insn_jal, insn_jr, insn_ld,
+        insn_ll, insn_lld, insn_lui, insn_lw, insn_mfc0, insn_mtc0,
+        insn_ori, insn_rfe, insn_sc, insn_scd, insn_sd, insn_sll,
+        insn_sra, insn_srl, insn_subu, insn_sw, insn_tlbp, insn_tlbwi,
+        insn_tlbwr, insn_xor, insn_xori
+};
+
+struct insn {
+        enum opcode opcode;
+        u32 match;
+        enum fields fields;
+};
+
+/* This macro sets the non-variable bits of an instruction. */
+#define M(a, b, c, d, e, f)                                     \
+        ((a) << OP_SH                                           \
+         | (b) << RS_SH                                         \
+         | (c) << RT_SH                                         \
+         | (d) << RD_SH                                         \
+         | (e) << RE_SH                                         \
+         | (f) << FUNC_SH)
+
+static struct insn insn_table[] __initdata = {
+        { insn_addiu, M(addiu_op, 0, 0, 0, 0, 0), RS | RT | SIMM },
+        { insn_addu, M(spec_op, 0, 0, 0, 0, addu_op), RS | RT | RD },
+        { insn_and, M(spec_op, 0, 0, 0, 0, and_op), RS | RT | RD },
+        { insn_andi, M(andi_op, 0, 0, 0, 0, 0), RS | RT | UIMM },
+        { insn_beq, M(beq_op, 0, 0, 0, 0, 0), RS | RT | BIMM },
+        { insn_beql, M(beql_op, 0, 0, 0, 0, 0), RS | RT | BIMM },
+        { insn_bgez, M(bcond_op, 0, bgez_op, 0, 0, 0), RS | BIMM },
+        { insn_bgezl, M(bcond_op, 0, bgezl_op, 0, 0, 0), RS | BIMM },
+        { insn_bltz, M(bcond_op, 0, bltz_op, 0, 0, 0), RS | BIMM },
+        { insn_bltzl, M(bcond_op, 0, bltzl_op, 0, 0, 0), RS | BIMM },
+        { insn_bne, M(bne_op, 0, 0, 0, 0, 0), RS | RT | BIMM },
+        { insn_daddiu, M(daddiu_op, 0, 0, 0, 0, 0), RS | RT | SIMM },
+        { insn_daddu, M(spec_op, 0, 0, 0, 0, daddu_op), RS | RT | RD },
+        { insn_dmfc0, M(cop0_op, dmfc_op, 0, 0, 0, 0), RT | RD | SET},
+        { insn_dmtc0, M(cop0_op, dmtc_op, 0, 0, 0, 0), RT | RD | SET},
+        { insn_dsll, M(spec_op, 0, 0, 0, 0, dsll_op), RT | RD | RE },
+        { insn_dsll32, M(spec_op, 0, 0, 0, 0, dsll32_op), RT | RD | RE },
+        { insn_dsra, M(spec_op, 0, 0, 0, 0, dsra_op), RT | RD | RE },
+        { insn_dsrl, M(spec_op, 0, 0, 0, 0, dsrl_op), RT | RD | RE },
+        { insn_dsrl32, M(spec_op, 0, 0, 0, 0, dsrl32_op), RT | RD | RE },
+        { insn_dsubu, M(spec_op, 0, 0, 0, 0, dsubu_op), RS | RT | RD },
+        { insn_eret,  M(cop0_op, cop_op, 0, 0, 0, eret_op),  0 },
+        { insn_j,  M(j_op, 0, 0, 0, 0, 0),  JIMM },
+        { insn_jal,  M(jal_op, 0, 0, 0, 0, 0),  JIMM },
+        { insn_jr,  M(spec_op, 0, 0, 0, 0, jr_op),  RS },
+        { insn_ld,  M(ld_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
+        { insn_ll,  M(ll_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
+        { insn_lld,  M(lld_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
+        { insn_lui,  M(lui_op, 0, 0, 0, 0, 0),  RT | SIMM },
+        { insn_lw,  M(lw_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
+        { insn_mfc0,  M(cop0_op, mfc_op, 0, 0, 0, 0),  RT | RD | SET},
+        { insn_mtc0,  M(cop0_op, mtc_op, 0, 0, 0, 0),  RT | RD | SET},
+        { insn_ori,  M(ori_op, 0, 0, 0, 0, 0),  RS | RT | UIMM },
+        { insn_rfe,  M(cop0_op, cop_op, 0, 0, 0, rfe_op),  0 },
+        { insn_sc,  M(sc_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
+        { insn_scd,  M(scd_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
+        { insn_sd,  M(sd_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
+        { insn_sll,  M(spec_op, 0, 0, 0, 0, sll_op),  RT | RD | RE },
+        { insn_sra,  M(spec_op, 0, 0, 0, 0, sra_op),  RT | RD | RE },
+        { insn_srl,  M(spec_op, 0, 0, 0, 0, srl_op),  RT | RD | RE },
+        { insn_subu,  M(spec_op, 0, 0, 0, 0, subu_op),  RS | RT | RD },
+        { insn_sw,  M(sw_op, 0, 0, 0, 0, 0),  RS | RT | SIMM },
+        { insn_tlbp,  M(cop0_op, cop_op, 0, 0, 0, tlbp_op),  0 },
+        { insn_tlbwi,  M(cop0_op, cop_op, 0, 0, 0, tlbwi_op),  0 },
+        { insn_tlbwr,  M(cop0_op, cop_op, 0, 0, 0, tlbwr_op),  0 },
+        { insn_xor,  M(spec_op, 0, 0, 0, 0, xor_op),  RS | RT | RD },
+        { insn_xori,  M(xori_op, 0, 0, 0, 0, 0),  RS | RT | UIMM },
+        { insn_invalid, 0, 0 }
+};
+
+#undef M
+
+static inline __init u32 build_rs(u32 arg)
+{
+        if (arg & ~RS_MASK)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return (arg & RS_MASK) << RS_SH;
+}
+
+static inline __init u32 build_rt(u32 arg)
+{
+        if (arg & ~RT_MASK)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return (arg & RT_MASK) << RT_SH;
+}
+
+static inline __init u32 build_rd(u32 arg)
+{
+        if (arg & ~RD_MASK)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return (arg & RD_MASK) << RD_SH;
+}
+
+static inline __init u32 build_re(u32 arg)
+{
+        if (arg & ~RE_MASK)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return (arg & RE_MASK) << RE_SH;
+}
+
+static inline __init u32 build_simm(s32 arg)
+{
+        if (arg > 0x7fff || arg < -0x8000)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return arg & 0xffff;
+}
+
+static inline __init u32 build_uimm(u32 arg)
+{
+        if (arg & ~IMM_MASK)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return arg & IMM_MASK;
+}
+
+static inline __init u32 build_bimm(s32 arg)
+{
+        if (arg > 0x1ffff || arg < -0x20000)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        if (arg & 0x3)
+                printk(KERN_WARNING "Invalid micro-assembler branch target\n");
+
+        return ((arg < 0) ? (1 << 15) : 0) | ((arg >> 2) & 0x7fff);
+}
+
+static inline __init u32 build_jimm(u32 arg)
+{
+        if (arg & ~((JIMM_MASK) << 2))
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return (arg >> 2) & JIMM_MASK;
+}
+
+static inline __init u32 build_func(u32 arg)
+{
+        if (arg & ~FUNC_MASK)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return arg & FUNC_MASK;
+}
+
+static inline __init u32 build_set(u32 arg)
+{
+        if (arg & ~SET_MASK)
+                printk(KERN_WARNING "Micro-assembler field overflow\n");
+
+        return arg & SET_MASK;
+}
+
+/*
+ * The order of opcode arguments is implicitly left to right,
+ * starting with RS and ending with FUNC or IMM.
+ */
+static void __init build_insn(u32 **buf, enum opcode opc, ...)
+{
+        struct insn *ip = NULL;
+        unsigned int i;
+        va_list ap;
+        u32 op;
+
+        for (i = 0; insn_table[i].opcode != insn_invalid; i++)
+                if (insn_table[i].opcode == opc) {
+                        ip = &insn_table[i];
+                        break;
+                }
+
+        if (!ip || (opc == insn_daddiu && r4k_daddiu_bug()))
+                panic("Unsupported Micro-assembler instruction %d", opc);
+
+        op = ip->match;
+        va_start(ap, opc);
+        if (ip->fields & RS)
+                op |= build_rs(va_arg(ap, u32));
+        if (ip->fields & RT)
+                op |= build_rt(va_arg(ap, u32));
+        if (ip->fields & RD)
+                op |= build_rd(va_arg(ap, u32));
+        if (ip->fields & RE)
+                op |= build_re(va_arg(ap, u32));
+        if (ip->fields & SIMM)
+                op |= build_simm(va_arg(ap, s32));
+        if (ip->fields & UIMM)
+                op |= build_uimm(va_arg(ap, u32));
+        if (ip->fields & BIMM)
+                op |= build_bimm(va_arg(ap, s32));
+        if (ip->fields & JIMM)
+                op |= build_jimm(va_arg(ap, u32));
+        if (ip->fields & FUNC)
+                op |= build_func(va_arg(ap, u32));
+        if (ip->fields & SET)
+                op |= build_set(va_arg(ap, u32));
+        va_end(ap);
+
+        **buf = op;
+        (*buf)++;
+}
+
+#define I_u1u2u3(op)                                    \
+Ip_u1u2u3(op)                                           \
+{                                                       \
+        build_insn(buf, insn##op, a, b, c);             \
+}
+
+#define I_u2u1u3(op)                                    \
+Ip_u2u1u3(op)                                           \
+{                                                       \
+        build_insn(buf, insn##op, b, a, c);             \
+}
+
+#define I_u3u1u2(op)                                    \
+Ip_u3u1u2(op)                                           \
+{                                                       \
+        build_insn(buf, insn##op, b, c, a);             \
+}
+
+#define I_u1u2s3(op)                                    \
+Ip_u1u2s3(op)                                           \
+{                                                       \
+        build_insn(buf, insn##op, a, b, c);             \
+}
+
+#define I_u2s3u1(op)                                    \
+Ip_u2s3u1(op)                                           \
+{                                                       \
+        build_insn(buf, insn##op, c, a, b);             \
+}
+
+#define I_u2u1s3(op)                                    \
+Ip_u2u1s3(op)                                           \
+{                                                       \
+        build_insn(buf, insn##op, b, a, c);             \
+}
+
+#define I_u1u2(op)                                      \
+Ip_u1u2(op)                                             \
+{                                                       \
+        build_insn(buf, insn##op, a, b);                \
+}
+
+#define I_u1s2(op)                                      \
+Ip_u1s2(op)                                             \
+{                                                       \
+        build_insn(buf, insn##op, a, b);                \
+}
+
+#define I_u1(op)                                        \
+Ip_u1(op)                                               \
+{                                                       \
+        build_insn(buf, insn##op, a);                   \
+}
+
+#define I_0(op)                                         \
+Ip_0(op)                                                \
+{                                                       \
+        build_insn(buf, insn##op);                      \
+}
+
+I_u2u1s3(_addiu)
+I_u3u1u2(_addu)
+I_u2u1u3(_andi)
+I_u3u1u2(_and)
+I_u1u2s3(_beq)
+I_u1u2s3(_beql)
+I_u1s2(_bgez)
+I_u1s2(_bgezl)
+I_u1s2(_bltz)
+I_u1s2(_bltzl)
+I_u1u2s3(_bne)
+I_u1u2u3(_dmfc0)
+I_u1u2u3(_dmtc0)
+I_u2u1s3(_daddiu)
+I_u3u1u2(_daddu)
+I_u2u1u3(_dsll)
+I_u2u1u3(_dsll32)
+I_u2u1u3(_dsra)
+I_u2u1u3(_dsrl)
+I_u2u1u3(_dsrl32)
+I_u3u1u2(_dsubu)
+I_0(_eret)
+I_u1(_j)
+I_u1(_jal)
+I_u1(_jr)
+I_u2s3u1(_ld)
+I_u2s3u1(_ll)
+I_u2s3u1(_lld)
+I_u1s2(_lui)
+I_u2s3u1(_lw)
+I_u1u2u3(_mfc0)
+I_u1u2u3(_mtc0)
+I_u2u1u3(_ori)
+I_0(_rfe)
+I_u2s3u1(_sc)
+I_u2s3u1(_scd)
+I_u2s3u1(_sd)
+I_u2u1u3(_sll)
+I_u2u1u3(_sra)
+I_u2u1u3(_srl)
+I_u3u1u2(_subu)
+I_u2s3u1(_sw)
+I_0(_tlbp)
+I_0(_tlbwi)
+I_0(_tlbwr)
+I_u3u1u2(_xor)
+I_u2u1u3(_xori)
+
+/* Handle labels. */
+void __init uasm_build_label(struct uasm_label **lab, u32 *addr, int lid)
+{
+        (*lab)->addr = addr;
+        (*lab)->lab = lid;
+        (*lab)++;
+}
+
+int __init uasm_in_compat_space_p(long addr)
+{
+        /* Is this address in 32bit compat space? */
+#ifdef CONFIG_64BIT
+        return (((addr) & 0xffffffff00000000L) == 0xffffffff00000000L);
+#else
+        return 1;
+#endif
+}
+
+int __init uasm_rel_highest(long val)
+{
+#ifdef CONFIG_64BIT
+        return ((((val + 0x800080008000L) >> 48) & 0xffff) ^ 0x8000) - 0x8000;
+#else
+        return 0;
+#endif
+}
+
+int __init uasm_rel_higher(long val)
+{
+#ifdef CONFIG_64BIT
+        return ((((val + 0x80008000L) >> 32) & 0xffff) ^ 0x8000) - 0x8000;
+#else
+        return 0;
+#endif
+}
+
+int __init uasm_rel_hi(long val)
+{
+        return ((((val + 0x8000L) >> 16) & 0xffff) ^ 0x8000) - 0x8000;
+}
+
+int __init uasm_rel_lo(long val)
+{
+        return ((val & 0xffff) ^ 0x8000) - 0x8000;
+}
+
+void __init UASM_i_LA_mostly(u32 **buf, unsigned int rs, long addr)
+{
+        if (!uasm_in_compat_space_p(addr)) {
+                uasm_i_lui(buf, rs, uasm_rel_highest(addr));
+                if (uasm_rel_higher(addr))
+                        uasm_i_daddiu(buf, rs, rs, uasm_rel_higher(addr));
+                if (uasm_rel_hi(addr)) {
+                        uasm_i_dsll(buf, rs, rs, 16);
+                        uasm_i_daddiu(buf, rs, rs, uasm_rel_hi(addr));
+                        uasm_i_dsll(buf, rs, rs, 16);
+                } else
+                        uasm_i_dsll32(buf, rs, rs, 0);
+        } else
+                uasm_i_lui(buf, rs, uasm_rel_hi(addr));
+}
+
+void __init UASM_i_LA(u32 **buf, unsigned int rs, long addr)
+{
+        UASM_i_LA_mostly(buf, rs, addr);
+        if (uasm_rel_lo(addr)) {
+                if (!uasm_in_compat_space_p(addr))
+                        uasm_i_daddiu(buf, rs, rs, uasm_rel_lo(addr));
+                else
+                        uasm_i_addiu(buf, rs, rs, uasm_rel_lo(addr));
+        }
+}
+
+/* Handle relocations. */
+void __init
+uasm_r_mips_pc16(struct uasm_reloc **rel, u32 *addr, int lid)
+{
+        (*rel)->addr = addr;
+        (*rel)->type = R_MIPS_PC16;
+        (*rel)->lab = lid;
+        (*rel)++;
+}
+
+static inline void __init
+__resolve_relocs(struct uasm_reloc *rel, struct uasm_label *lab)
+{
+        long laddr = (long)lab->addr;
+        long raddr = (long)rel->addr;
+
+        switch (rel->type) {
+        case R_MIPS_PC16:
+                *rel->addr |= build_bimm(laddr - (raddr + 4));
+                break;
+
+        default:
+                panic("Unsupported Micro-assembler relocation %d",
+                      rel->type);
+        }
+}
+
+void __init
+uasm_resolve_relocs(struct uasm_reloc *rel, struct uasm_label *lab)
+{
+        struct uasm_label *l;
+
+        for (; rel->lab != UASM_LABEL_INVALID; rel++)
+                for (l = lab; l->lab != UASM_LABEL_INVALID; l++)
+                        if (rel->lab == l->lab)
+                                __resolve_relocs(rel, l);
+}
+
+void __init
+uasm_move_relocs(struct uasm_reloc *rel, u32 *first, u32 *end, long off)
+{
+        for (; rel->lab != UASM_LABEL_INVALID; rel++)
+                if (rel->addr >= first && rel->addr < end)
+                        rel->addr += off;
+}
+
+void __init
+uasm_move_labels(struct uasm_label *lab, u32 *first, u32 *end, long off)
+{
+        for (; lab->lab != UASM_LABEL_INVALID; lab++)
+                if (lab->addr >= first && lab->addr < end)
+                        lab->addr += off;
+}
+
+void __init
+uasm_copy_handler(struct uasm_reloc *rel, struct uasm_label *lab, u32 *first,
+                  u32 *end, u32 *target)
+{
+        long off = (long)(target - first);
+
+        memcpy(target, first, (end - first) * sizeof(u32));
+
+        uasm_move_relocs(rel, first, end, off);
+        uasm_move_labels(lab, first, end, off);
+}
+
+int __init uasm_insn_has_bdelay(struct uasm_reloc *rel, u32 *addr)
+{
+        for (; rel->lab != UASM_LABEL_INVALID; rel++) {
+                if (rel->addr == addr
+                    && (rel->type == R_MIPS_PC16
+                        || rel->type == R_MIPS_26))
+                        return 1;
+        }
+
+        return 0;
+}
+
+/* Convenience functions for labeled branches. */
+void __init
+uasm_il_bltz(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid)
+{
+        uasm_r_mips_pc16(r, *p, lid);
+        uasm_i_bltz(p, reg, 0);
+}
+
+void __init
+uasm_il_b(u32 **p, struct uasm_reloc **r, int lid)
+{
+        uasm_r_mips_pc16(r, *p, lid);
+        uasm_i_b(p, 0);
+}
+
+void __init
+uasm_il_beqz(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid)
+{
+        uasm_r_mips_pc16(r, *p, lid);
+        uasm_i_beqz(p, reg, 0);
+}
+
+void __init
+uasm_il_beqzl(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid)
+{
+        uasm_r_mips_pc16(r, *p, lid);
+        uasm_i_beqzl(p, reg, 0);
+}
+
+void __init
+uasm_il_bnez(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid)
+{
+        uasm_r_mips_pc16(r, *p, lid);
+        uasm_i_bnez(p, reg, 0);
+}
+
+void __init
+uasm_il_bgezl(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid)
+{
+        uasm_r_mips_pc16(r, *p, lid);
+        uasm_i_bgezl(p, reg, 0);
+}
+
+void __init
+uasm_il_bgez(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid)
+{
+        uasm_r_mips_pc16(r, *p, lid);
+        uasm_i_bgez(p, reg, 0);
+}
diff --git a/arch/mips/mm/uasm.h b/arch/mips/mm/uasm.h
new file mode 100644
index 000000000000..a10fc1135c76
--- /dev/null
+++ b/arch/mips/mm/uasm.h
@@ -0,0 +1,192 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2004, 2005, 2006, 2008  Thiemo Seufer
+ * Copyright (C) 2005  Maciej W. Rozycki
+ * Copyright (C) 2006  Ralf Baechle (ralf@linux-mips.org)
+ */
+
+#include <linux/types.h>
+
+#define Ip_u1u2u3(op)                                                   \
+void __init                                                             \
+uasm_i##op(u32 **buf, unsigned int a, unsigned int b, unsigned int c)
+
+#define Ip_u2u1u3(op)                                                   \
+void __init                                                             \
+uasm_i##op(u32 **buf, unsigned int a, unsigned int b, unsigned int c)
+
+#define Ip_u3u1u2(op)                                                   \
+void __init                                                             \
+uasm_i##op(u32 **buf, unsigned int a, unsigned int b, unsigned int c)
+
+#define Ip_u1u2s3(op)                                                   \
+void __init                                                             \
+uasm_i##op(u32 **buf, unsigned int a, unsigned int b, signed int c)
+
+#define Ip_u2s3u1(op)                                                   \
+void __init                                                             \
+uasm_i##op(u32 **buf, unsigned int a, signed int b, unsigned int c)
+
+#define Ip_u2u1s3(op)                                                   \
+void __init                                                             \
+uasm_i##op(u32 **buf, unsigned int a, unsigned int b, signed int c)
+
+#define Ip_u1u2(op)                                                     \
+void __init uasm_i##op(u32 **buf, unsigned int a, unsigned int b)
+
+#define Ip_u1s2(op)                                                     \
+void __init uasm_i##op(u32 **buf, unsigned int a, signed int b)
+
+#define Ip_u1(op) void __init uasm_i##op(u32 **buf, unsigned int a)
+
+#define Ip_0(op) void __init uasm_i##op(u32 **buf)
+
+Ip_u2u1s3(_addiu);
+Ip_u3u1u2(_addu);
+Ip_u2u1u3(_andi);
+Ip_u3u1u2(_and);
+Ip_u1u2s3(_beq);
+Ip_u1u2s3(_beql);
+Ip_u1s2(_bgez);
+Ip_u1s2(_bgezl);
+Ip_u1s2(_bltz);
+Ip_u1s2(_bltzl);
+Ip_u1u2s3(_bne);
+Ip_u1u2u3(_dmfc0);
+Ip_u1u2u3(_dmtc0);
+Ip_u2u1s3(_daddiu);
+Ip_u3u1u2(_daddu);
+Ip_u2u1u3(_dsll);
+Ip_u2u1u3(_dsll32);
+Ip_u2u1u3(_dsra);
+Ip_u2u1u3(_dsrl);
+Ip_u2u1u3(_dsrl32);
+Ip_u3u1u2(_dsubu);
+Ip_0(_eret);
+Ip_u1(_j);
+Ip_u1(_jal);
+Ip_u1(_jr);
+Ip_u2s3u1(_ld);
+Ip_u2s3u1(_ll);
+Ip_u2s3u1(_lld);
+Ip_u1s2(_lui);
+Ip_u2s3u1(_lw);
+Ip_u1u2u3(_mfc0);
+Ip_u1u2u3(_mtc0);
+Ip_u2u1u3(_ori);
+Ip_0(_rfe);
+Ip_u2s3u1(_sc);
+Ip_u2s3u1(_scd);
+Ip_u2s3u1(_sd);
+Ip_u2u1u3(_sll);
+Ip_u2u1u3(_sra);
+Ip_u2u1u3(_srl);
+Ip_u3u1u2(_subu);
+Ip_u2s3u1(_sw);
+Ip_0(_tlbp);
+Ip_0(_tlbwi);
+Ip_0(_tlbwr);
+Ip_u3u1u2(_xor);
+Ip_u2u1u3(_xori);
+
+/* Handle labels. */
+struct uasm_label {
+        u32 *addr;
+        int lab;
+};
+
+void __init uasm_build_label(struct uasm_label **lab, u32 *addr, int lid);
+#ifdef CONFIG_64BIT
+int __init uasm_in_compat_space_p(long addr);
+int __init uasm_rel_highest(long val);
+int __init uasm_rel_higher(long val);
+#endif
+int __init uasm_rel_hi(long val);
+int __init uasm_rel_lo(long val);
+void __init UASM_i_LA_mostly(u32 **buf, unsigned int rs, long addr);
+void __init UASM_i_LA(u32 **buf, unsigned int rs, long addr);
+
+#define UASM_L_LA(lb)                                                   \
+static inline void __init uasm_l##lb(struct uasm_label **lab, u32 *addr) \
+{                                                                       \
+        uasm_build_label(lab, addr, label##lb);                         \
+}
+
+/* convenience macros for instructions */
+#ifdef CONFIG_64BIT
+# define UASM_i_LW(buf, rs, rt, off) uasm_i_ld(buf, rs, rt, off)
+# define UASM_i_SW(buf, rs, rt, off) uasm_i_sd(buf, rs, rt, off)
+# define UASM_i_SLL(buf, rs, rt, sh) uasm_i_dsll(buf, rs, rt, sh)
+# define UASM_i_SRA(buf, rs, rt, sh) uasm_i_dsra(buf, rs, rt, sh)
+# define UASM_i_SRL(buf, rs, rt, sh) uasm_i_dsrl(buf, rs, rt, sh)
+# define UASM_i_MFC0(buf, rt, rd...) uasm_i_dmfc0(buf, rt, rd)
+# define UASM_i_MTC0(buf, rt, rd...) uasm_i_dmtc0(buf, rt, rd)
+# define UASM_i_ADDIU(buf, rs, rt, val) uasm_i_daddiu(buf, rs, rt, val)
+# define UASM_i_ADDU(buf, rs, rt, rd) uasm_i_daddu(buf, rs, rt, rd)
+# define UASM_i_SUBU(buf, rs, rt, rd) uasm_i_dsubu(buf, rs, rt, rd)
+# define UASM_i_LL(buf, rs, rt, off) uasm_i_lld(buf, rs, rt, off)
+# define UASM_i_SC(buf, rs, rt, off) uasm_i_scd(buf, rs, rt, off)
+#else
+# define UASM_i_LW(buf, rs, rt, off) uasm_i_lw(buf, rs, rt, off)
+# define UASM_i_SW(buf, rs, rt, off) uasm_i_sw(buf, rs, rt, off)
+# define UASM_i_SLL(buf, rs, rt, sh) uasm_i_sll(buf, rs, rt, sh)
+# define UASM_i_SRA(buf, rs, rt, sh) uasm_i_sra(buf, rs, rt, sh)
+# define UASM_i_SRL(buf, rs, rt, sh) uasm_i_srl(buf, rs, rt, sh)
+# define UASM_i_MFC0(buf, rt, rd...) uasm_i_mfc0(buf, rt, rd)
+# define UASM_i_MTC0(buf, rt, rd...) uasm_i_mtc0(buf, rt, rd)
+# define UASM_i_ADDIU(buf, rs, rt, val) uasm_i_addiu(buf, rs, rt, val)
+# define UASM_i_ADDU(buf, rs, rt, rd) uasm_i_addu(buf, rs, rt, rd)
+# define UASM_i_SUBU(buf, rs, rt, rd) uasm_i_subu(buf, rs, rt, rd)
+# define UASM_i_LL(buf, rs, rt, off) uasm_i_ll(buf, rs, rt, off)
+# define UASM_i_SC(buf, rs, rt, off) uasm_i_sc(buf, rs, rt, off)
+#endif
+
+#define uasm_i_b(buf, off) uasm_i_beq(buf, 0, 0, off)
+#define uasm_i_beqz(buf, rs, off) uasm_i_beq(buf, rs, 0, off)
+#define uasm_i_beqzl(buf, rs, off) uasm_i_beql(buf, rs, 0, off)
+#define uasm_i_bnez(buf, rs, off) uasm_i_bne(buf, rs, 0, off)
+#define uasm_i_bnezl(buf, rs, off) uasm_i_bnel(buf, rs, 0, off)
+#define uasm_i_move(buf, a, b) UASM_i_ADDU(buf, a, 0, b)
+#define uasm_i_nop(buf) uasm_i_sll(buf, 0, 0, 0)
+#define uasm_i_ssnop(buf) uasm_i_sll(buf, 0, 0, 1)
+#define uasm_i_ehb(buf) uasm_i_sll(buf, 0, 0, 3)
+
+/* Handle relocations. */
+struct uasm_reloc {
+        u32 *addr;
+        unsigned int type;
+        int lab;
+};
+
+/* This is zero so we can use zeroed label arrays. */
+#define UASM_LABEL_INVALID 0
+
+void __init uasm_r_mips_pc16(struct uasm_reloc **rel, u32 *addr, int lid);
+void __init
+uasm_resolve_relocs(struct uasm_reloc *rel, struct uasm_label *lab);
+void __init
+uasm_move_relocs(struct uasm_reloc *rel, u32 *first, u32 *end, long off);
+void __init
+uasm_move_labels(struct uasm_label *lab, u32 *first, u32 *end, long off);
+void __init
+uasm_copy_handler(struct uasm_reloc *rel, struct uasm_label *lab, u32 *first,
+                  u32 *end, u32 *target);
+int __init uasm_insn_has_bdelay(struct uasm_reloc *rel, u32 *addr);
+
+/* Convenience functions for labeled branches. */
+void __init
+uasm_il_bltz(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid);
+void __init uasm_il_b(u32 **p, struct uasm_reloc **r, int lid);
+void __init
+uasm_il_beqz(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid);
+void __init
+uasm_il_beqzl(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid);
+void __init
+uasm_il_bnez(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid);
+void __init
+uasm_il_bgezl(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid);
+void __init
+uasm_il_bgez(u32 **p, struct uasm_reloc **r, unsigned int reg, int lid);
diff --git a/arch/mips/sgi-ip27/ip27-hubio.c b/arch/mips/sgi-ip27/ip27-hubio.c
index 524b371f9397..a1fa4abb3f6a 100644
--- a/arch/mips/sgi-ip27/ip27-hubio.c
+++ b/arch/mips/sgi-ip27/ip27-hubio.c
@@ -168,7 +168,7 @@ static void hub_set_piomode(nasid_t nasid)
 }
 
 /*
- * hub_pio_init  -  PIO-related hub initalization
+ * hub_pio_init  -  PIO-related hub initialization
  *
  * @hub:        hubinfo structure for our hub
  */
diff --git a/arch/parisc/Kconfig b/arch/parisc/Kconfig
index 2b649c46631c..028d8a0fdbfd 100644
--- a/arch/parisc/Kconfig
+++ b/arch/parisc/Kconfig
@@ -7,6 +7,7 @@ mainmenu "Linux/PA-RISC Kernel Configuration"
 
 config PARISC
         def_bool y
+        select HAVE_OPROFILE
         help
           The PA-RISC microprocessor is designed by Hewlett-Packard and used
           in many of their workstations & servers (HP9000 700 and 800 series,
@@ -205,9 +206,8 @@ config SMP
           singleprocessor machines. On a singleprocessor machine, the kernel
           will run faster if you say N here.
 
-          See also the <file:Documentation/smp.txt>,
-          <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO available
-          at <http://www.tldp.org/docs.html#howto>.
+          See also <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO
+          available at <http://www.tldp.org/docs.html#howto>.
 
           If you don't know what to do here, say N.
 
@@ -272,8 +272,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/parisc/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/parisc/kernel/cache.c b/arch/parisc/kernel/cache.c
index 395bbce64993..e10d25d2d9c9 100644
--- a/arch/parisc/kernel/cache.c
+++ b/arch/parisc/kernel/cache.c
@@ -305,7 +305,7 @@ flush_user_cache_page_non_current(struct vm_area_struct *vma,
         /* save the current process space and pgd */
         unsigned long space = mfsp(3), pgd = mfctl(25);
 
-        /* we don't mind taking interrups since they may not
+        /* we don't mind taking interrupts since they may not
          * do anything with user space, but we can't
          * be preempted here */
         preempt_disable();
diff --git a/arch/parisc/kernel/hardware.c b/arch/parisc/kernel/hardware.c
index 04848b2b381c..84b9611a9228 100644
--- a/arch/parisc/kernel/hardware.c
+++ b/arch/parisc/kernel/hardware.c
@@ -1187,7 +1187,7 @@ static struct hp_hardware hp_hardware_list[] __devinitdata = {
         {HPHW_FIO, 0x005, 0x000A9, 0x00, "AllegroLow Core PCI USB KB"}, 
         {HPHW_FIO, 0x006, 0x000A9, 0x00, "AllegroHigh Core PCI SuperIO RS-232"}, 
         {HPHW_FIO, 0x006, 0x000A9, 0x00, "AllegroHigh Core PCI USB KB"}, 
-        {HPHW_FIO, 0x007, 0x000A9, 0x0, "Miscelaneous PCI Plug-in"}, 
+        {HPHW_FIO, 0x007, 0x000A9, 0x0, "Miscellaneous PCI Plug-in"},
         {HPHW_FIO, 0x00A, 0x000A9, 0x0, "Lego 360 Core PCI SuperIO RS-232"}, 
         {HPHW_FIO, 0x00A, 0x000A9, 0x0, "Lego 360 Core PCI USB KB"}, 
         {HPHW_FIO, 0x004, 0x00320, 0x0, "Metheus Frame Buffer"}, 
diff --git a/arch/parisc/kernel/signal.c b/arch/parisc/kernel/signal.c
index 2ce3806f02e1..58fccc96d003 100644
--- a/arch/parisc/kernel/signal.c
+++ b/arch/parisc/kernel/signal.c
@@ -333,7 +333,7 @@ setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
         flush_user_icache_range((unsigned long) &frame->tramp[0],
                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
 
-        /* TRAMP Words 0-4, Lenght 5 = SIGRESTARTBLOCK_TRAMP
+        /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
          * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
          * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
          */
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 88ea64bd991a..1348bbc92510 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -42,7 +42,7 @@ config GENERIC_HARDIRQS
         bool
         default y
 
-config ARCH_SETS_UP_PER_CPU_AREA
+config HAVE_SETUP_PER_CPU_AREA
         def_bool PPC64
 
 config IRQ_PER_CPU
@@ -87,6 +87,8 @@ config ARCH_NO_VIRT_TO_BUS
 config PPC
         bool
         default y
+        select HAVE_OPROFILE
+        select HAVE_KPROBES
 
 config EARLY_PRINTK
         bool
@@ -151,11 +153,25 @@ config DEFAULT_UIMAGE
 config REDBOOT
         bool
 
-config PPC64_SWSUSP
+config HIBERNATE_32
         bool
-        depends on PPC64 && (BROKEN || (PPC_PMAC64 && EXPERIMENTAL))
+        depends on (PPC_PMAC && !SMP) || BROKEN
         default y
 
+config HIBERNATE_64
+        bool
+        depends on BROKEN || (PPC_PMAC64 && EXPERIMENTAL)
+        default y
+
+config ARCH_HIBERNATION_POSSIBLE
+        bool
+        depends on (PPC64 && HIBERNATE_64) || (PPC32 && HIBERNATE_32)
+        default y
+
+config ARCH_SUSPEND_POSSIBLE
+        def_bool y
+        depends on ADB_PMU || PPC_EFIKA || PPC_LITE5200
+
 config PPC_DCR_NATIVE
         bool
         default n
@@ -240,6 +256,9 @@ config IOMMU_VMERGE
 
           Most drivers don't have this problem; it is safe to say Y here.
 
+config IOMMU_HELPER
+        def_bool PPC64
+
 config HOTPLUG_CPU
         bool "Support for enabling/disabling CPUs"
         depends on SMP && HOTPLUG && EXPERIMENTAL && (PPC_PSERIES || PPC_PMAC)
@@ -391,6 +410,10 @@ config CMDLINE
           most cases you will need to specify the root device here.
 
 if !44x || BROKEN
+config ARCH_WANTS_FREEZER_CONTROL
+        def_bool y
+        depends on ADB_PMU
+
 source kernel/power/Kconfig
 endif
 
@@ -695,8 +718,6 @@ source "arch/powerpc/sysdev/qe_lib/Kconfig"
 
 source "lib/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/powerpc/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/powerpc/boot/dts/adder875-redboot.dts b/arch/powerpc/boot/dts/adder875-redboot.dts
index 930bfb3894eb..28e9cd3d7a21 100644
--- a/arch/powerpc/boot/dts/adder875-redboot.dts
+++ b/arch/powerpc/boot/dts/adder875-redboot.dts
@@ -151,6 +151,7 @@
                                 compatible = "fsl,mpc875-brg",
                                              "fsl,cpm1-brg",
                                              "fsl,cpm-brg";
+                                clock-frequency = <50000000>;
                                 reg = <0x9f0 0x10>;
                         };
 
diff --git a/arch/powerpc/boot/dts/adder875-uboot.dts b/arch/powerpc/boot/dts/adder875-uboot.dts
index 0197242dacfb..54fb60ec03e5 100644
--- a/arch/powerpc/boot/dts/adder875-uboot.dts
+++ b/arch/powerpc/boot/dts/adder875-uboot.dts
@@ -150,6 +150,7 @@
                                 compatible = "fsl,mpc875-brg",
                                              "fsl,cpm1-brg",
                                              "fsl,cpm-brg";
+                                clock-frequency = <50000000>;
                                 reg = <0x9f0 0x10>;
                         };
 
diff --git a/arch/powerpc/boot/dts/mpc8313erdb.dts b/arch/powerpc/boot/dts/mpc8313erdb.dts
index 2d6653fe72ff..e1f0dca8ac39 100644
--- a/arch/powerpc/boot/dts/mpc8313erdb.dts
+++ b/arch/powerpc/boot/dts/mpc8313erdb.dts
@@ -118,6 +118,10 @@
                         interrupts = <14 0x8>;
                         interrupt-parent = <&ipic>;
                         dfsrr;
+                        rtc@68 {
+                                compatible = "dallas,ds1339";
+                                reg = <0x68>;
+                        };
                 };
 
                 i2c@3100 {
diff --git a/arch/powerpc/boot/dts/mpc8315erdb.dts b/arch/powerpc/boot/dts/mpc8315erdb.dts
index b582032ba3d6..d7a1ececa30f 100644
--- a/arch/powerpc/boot/dts/mpc8315erdb.dts
+++ b/arch/powerpc/boot/dts/mpc8315erdb.dts
@@ -96,7 +96,7 @@
                 #address-cells = <1>;
                 #size-cells = <1>;
                 device_type = "soc";
-                compatible = "simple-bus";
+                compatible = "fsl,mpc8315-immr", "simple-bus";
                 ranges = <0 0xe0000000 0x00100000>;
                 reg = <0xe0000000 0x00000200>;
                 bus-frequency = <0>;
diff --git a/arch/powerpc/boot/dts/mpc834x_mds.dts b/arch/powerpc/boot/dts/mpc834x_mds.dts
index 7480edae85ed..0199c5c548d8 100644
--- a/arch/powerpc/boot/dts/mpc834x_mds.dts
+++ b/arch/powerpc/boot/dts/mpc834x_mds.dts
@@ -332,7 +332,7 @@
                                  0xc000 0x0 0x0 0x3 &ipic 23 0x8
                                  0xc000 0x0 0x0 0x4 &ipic 20 0x8>;
                 interrupt-parent = <&ipic>;
-                interrupts = <66 0x8>;
+                interrupts = <67 0x8>;
                 bus-range = <0 0>;
                 ranges = <0x02000000 0x0 0xb0000000 0xb0000000 0x0 0x10000000
                           0x42000000 0x0 0xa0000000 0xa0000000 0x0 0x10000000
diff --git a/arch/powerpc/boot/dts/mpc8572ds.dts b/arch/powerpc/boot/dts/mpc8572ds.dts
index 813c259abbe5..db37214aee37 100644
--- a/arch/powerpc/boot/dts/mpc8572ds.dts
+++ b/arch/powerpc/boot/dts/mpc8572ds.dts
@@ -42,6 +42,18 @@
                         bus-frequency = <0>;
                         clock-frequency = <0>;
                 };
+
+                PowerPC,8572@1 {
+                        device_type = "cpu";
+                        reg = <1>;
+                        d-cache-line-size = <20>;       // 32 bytes
+                        i-cache-line-size = <20>;       // 32 bytes
+                        d-cache-size = <8000>;          // L1, 32K
+                        i-cache-size = <8000>;          // L1, 32K
+                        timebase-frequency = <0>;
+                        bus-frequency = <0>;
+                        clock-frequency = <0>;
+                };
         };
 
         memory {
diff --git a/arch/powerpc/boot/dts/mpc885ads.dts b/arch/powerpc/boot/dts/mpc885ads.dts
index 8848e637293e..d84a012c2aaf 100644
--- a/arch/powerpc/boot/dts/mpc885ads.dts
+++ b/arch/powerpc/boot/dts/mpc885ads.dts
@@ -166,6 +166,7 @@
                                 compatible = "fsl,mpc885-brg",
                                              "fsl,cpm1-brg",
                                              "fsl,cpm-brg";
+                                clock-frequency = <0>;
                                 reg = <9f0 10>;
                         };
 
diff --git a/arch/powerpc/boot/dts/storcenter.dts b/arch/powerpc/boot/dts/storcenter.dts
index 2204874ac5f3..5893816c0bce 100644
--- a/arch/powerpc/boot/dts/storcenter.dts
+++ b/arch/powerpc/boot/dts/storcenter.dts
@@ -15,7 +15,7 @@
 
 / {
         model = "StorCenter";
-        compatible = "storcenter";
+        compatible = "iomega,storcenter";
         #address-cells = <1>;
         #size-cells = <1>;
 
@@ -62,12 +62,12 @@
                         #size-cells = <0>;
                         compatible = "fsl-i2c";
                         reg = <0x3000 0x100>;
-                        interrupts = <5 2>;
+                        interrupts = <17 2>;
                         interrupt-parent = <&mpic>;
 
                         rtc@68 {
                                 compatible = "dallas,ds1337";
-                                reg = <68>;
+                                reg = <0x68>;
                         };
                 };
 
@@ -78,7 +78,7 @@
                         reg = <0x4500 0x20>;
                         clock-frequency = <97553800>; /* Hz */
                         current-speed = <115200>;
-                        interrupts = <9 2>;
+                        interrupts = <25 2>;
                         interrupt-parent = <&mpic>;
                 };
 
@@ -89,7 +89,7 @@
                         reg = <0x4600 0x20>;
                         clock-frequency = <97553800>; /* Hz */
                         current-speed = <9600>;
-                        interrupts = <10 2>;
+                        interrupts = <26 2>;
                         interrupt-parent = <&mpic>;
                 };
 
@@ -136,6 +136,6 @@
         };
 
         chosen {
-                linux,stdout-path = "/soc/serial@4500";
+                linux,stdout-path = &serial0;
         };
 };
diff --git a/arch/powerpc/configs/mpc83xx_defconfig b/arch/powerpc/configs/mpc83xx_defconfig
index 31bdbf3f7566..a9807f083bc4 100644
--- a/arch/powerpc/configs/mpc83xx_defconfig
+++ b/arch/powerpc/configs/mpc83xx_defconfig
@@ -186,7 +186,7 @@ CONFIG_PREEMPT_NONE=y
 # CONFIG_PREEMPT is not set
 CONFIG_BINFMT_ELF=y
 # CONFIG_BINFMT_MISC is not set
-# CONFIG_MATH_EMULATION is not set
+CONFIG_MATH_EMULATION=y
 CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
 CONFIG_ARCH_FLATMEM_ENABLE=y
 CONFIG_ARCH_POPULATES_NODE_MAP=y
@@ -416,14 +416,14 @@ CONFIG_PHYLIB=y
 # MII PHY device drivers
 #
 CONFIG_MARVELL_PHY=y
-# CONFIG_DAVICOM_PHY is not set
+CONFIG_DAVICOM_PHY=y
 # CONFIG_QSEMI_PHY is not set
 # CONFIG_LXT_PHY is not set
 # CONFIG_CICADA_PHY is not set
-# CONFIG_VITESSE_PHY is not set
+CONFIG_VITESSE_PHY=y
 # CONFIG_SMSC_PHY is not set
 # CONFIG_BROADCOM_PHY is not set
-# CONFIG_ICPLUS_PHY is not set
+CONFIG_ICPLUS_PHY=y
 # CONFIG_FIXED_PHY is not set
 # CONFIG_MDIO_BITBANG is not set
 CONFIG_NET_ETHERNET=y
@@ -436,7 +436,7 @@ CONFIG_MII=y
 CONFIG_NETDEV_1000=y
 CONFIG_GIANFAR=y
 # CONFIG_GFAR_NAPI is not set
-# CONFIG_UCC_GETH is not set
+CONFIG_UCC_GETH=y
 CONFIG_NETDEV_10000=y
 
 #
diff --git a/arch/powerpc/kernel/asm-offsets.c b/arch/powerpc/kernel/asm-offsets.c
index ed083feaf6f9..e6e49289f788 100644
--- a/arch/powerpc/kernel/asm-offsets.c
+++ b/arch/powerpc/kernel/asm-offsets.c
@@ -22,6 +22,7 @@
 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <linux/suspend.h>
+#include <linux/hrtimer.h>
 #ifdef CONFIG_PPC64
 #include <linux/time.h>
 #include <linux/hardirq.h>
@@ -312,7 +313,7 @@ int main(void)
         DEFINE(CLOCK_REALTIME, CLOCK_REALTIME);
         DEFINE(CLOCK_MONOTONIC, CLOCK_MONOTONIC);
         DEFINE(NSEC_PER_SEC, NSEC_PER_SEC);
-        DEFINE(CLOCK_REALTIME_RES, TICK_NSEC);
+        DEFINE(CLOCK_REALTIME_RES, (KTIME_MONOTONIC_RES).tv64);
 
 #ifdef CONFIG_BUG
         DEFINE(BUG_ENTRY_SIZE, sizeof(struct bug_entry));
diff --git a/arch/powerpc/kernel/cputable.c b/arch/powerpc/kernel/cputable.c
index a4c2771b5e62..2a8f5cc5184f 100644
--- a/arch/powerpc/kernel/cputable.c
+++ b/arch/powerpc/kernel/cputable.c
@@ -959,6 +959,9 @@ static struct cpu_spec __initdata cpu_specs[] = {
                 .icache_bsize           = 32,
                 .dcache_bsize           = 32,
                 .cpu_setup              = __setup_cpu_603,
+                .num_pmcs               = 4,
+                .oprofile_cpu_type      = "ppc/e300",
+                .oprofile_type          = PPC_OPROFILE_FSL_EMB,
                 .platform               = "ppc603",
         },
         {       /* e300c4 (e300c1, plus one IU) */
@@ -971,6 +974,9 @@ static struct cpu_spec __initdata cpu_specs[] = {
                 .dcache_bsize           = 32,
                 .cpu_setup              = __setup_cpu_603,
                 .machine_check          = machine_check_generic,
+                .num_pmcs               = 4,
+                .oprofile_cpu_type      = "ppc/e300",
+                .oprofile_type          = PPC_OPROFILE_FSL_EMB,
                 .platform               = "ppc603",
         },
         {       /* default match, we assume split I/D cache & TB (non-601)... */
@@ -1435,7 +1441,7 @@ static struct cpu_spec __initdata cpu_specs[] = {
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
                 .oprofile_cpu_type      = "ppc/e500",
-                .oprofile_type          = PPC_OPROFILE_BOOKE,
+                .oprofile_type          = PPC_OPROFILE_FSL_EMB,
                 .machine_check          = machine_check_e500,
                 .platform               = "ppc8540",
         },
@@ -1453,7 +1459,7 @@ static struct cpu_spec __initdata cpu_specs[] = {
                 .dcache_bsize           = 32,
                 .num_pmcs               = 4,
                 .oprofile_cpu_type      = "ppc/e500",
-                .oprofile_type          = PPC_OPROFILE_BOOKE,
+                .oprofile_type          = PPC_OPROFILE_FSL_EMB,
                 .machine_check          = machine_check_e500,
                 .platform               = "ppc8548",
         },
diff --git a/arch/powerpc/kernel/dma_64.c b/arch/powerpc/kernel/dma_64.c
index 84239076a5b8..3a317cb0636a 100644
--- a/arch/powerpc/kernel/dma_64.c
+++ b/arch/powerpc/kernel/dma_64.c
@@ -31,8 +31,8 @@ static inline unsigned long device_to_mask(struct device *dev)
 static void *dma_iommu_alloc_coherent(struct device *dev, size_t size,
                                       dma_addr_t *dma_handle, gfp_t flag)
 {
-        return iommu_alloc_coherent(dev->archdata.dma_data, size, dma_handle,
-                                    device_to_mask(dev), flag,
+        return iommu_alloc_coherent(dev, dev->archdata.dma_data, size,
+                                    dma_handle, device_to_mask(dev), flag,
                                     dev->archdata.numa_node);
 }
 
@@ -52,7 +52,7 @@ static dma_addr_t dma_iommu_map_single(struct device *dev, void *vaddr,
                                        size_t size,
                                        enum dma_data_direction direction)
 {
-        return iommu_map_single(dev->archdata.dma_data, vaddr, size,
+        return iommu_map_single(dev, dev->archdata.dma_data, vaddr, size,
                                 device_to_mask(dev), direction);
 }
 
@@ -68,7 +68,7 @@ static void dma_iommu_unmap_single(struct device *dev, dma_addr_t dma_handle,
 static int dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,
                             int nelems, enum dma_data_direction direction)
 {
-        return iommu_map_sg(dev->archdata.dma_data, sglist, nelems,
+        return iommu_map_sg(dev, sglist, nelems,
                             device_to_mask(dev), direction);
 }
 
diff --git a/arch/powerpc/kernel/iommu.c b/arch/powerpc/kernel/iommu.c
index a3c406aca664..8f1f4e539c4b 100644
--- a/arch/powerpc/kernel/iommu.c
+++ b/arch/powerpc/kernel/iommu.c
@@ -31,6 +31,7 @@
 #include <linux/string.h>
 #include <linux/dma-mapping.h>
 #include <linux/bitops.h>
+#include <linux/iommu-helper.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/iommu.h>
@@ -81,17 +82,19 @@ static int __init setup_iommu(char *str)
 __setup("protect4gb=", setup_protect4gb);
 __setup("iommu=", setup_iommu);
 
-static unsigned long iommu_range_alloc(struct iommu_table *tbl,
+static unsigned long iommu_range_alloc(struct device *dev,
+                                       struct iommu_table *tbl,
                                        unsigned long npages,
                                        unsigned long *handle,
                                        unsigned long mask,
                                        unsigned int align_order)
 { 
-        unsigned long n, end, i, start;
+        unsigned long n, end, start;
         unsigned long limit;
         int largealloc = npages > 15;
         int pass = 0;
         unsigned long align_mask;
+        unsigned long boundary_size;
 
         align_mask = 0xffffffffffffffffl >> (64 - align_order);
 
@@ -136,14 +139,17 @@ static unsigned long iommu_range_alloc(struct iommu_table *tbl,
                         start &= mask;
         }
 
-        n = find_next_zero_bit(tbl->it_map, limit, start);
-
-        /* Align allocation */
-        n = (n + align_mask) & ~align_mask;
-
-        end = n + npages;
+        if (dev)
+                boundary_size = ALIGN(dma_get_seg_boundary(dev) + 1,
+                                      1 << IOMMU_PAGE_SHIFT);
+        else
+                boundary_size = ALIGN(1UL << 32, 1 << IOMMU_PAGE_SHIFT);
+        /* 4GB boundary for iseries_hv_alloc and iseries_hv_map */
 
-        if (unlikely(end >= limit)) {
+        n = iommu_area_alloc(tbl->it_map, limit, start, npages,
+                             tbl->it_offset, boundary_size >> IOMMU_PAGE_SHIFT,
+                             align_mask);
+        if (n == -1) {
                 if (likely(pass < 2)) {
                         /* First failure, just rescan the half of the table.
                          * Second failure, rescan the other half of the table.
@@ -158,14 +164,7 @@ static unsigned long iommu_range_alloc(struct iommu_table *tbl,
                 }
         }
 
-        for (i = n; i < end; i++)
-                if (test_bit(i, tbl->it_map)) {
-                        start = i+1;
-                        goto again;
-                }
-
-        for (i = n; i < end; i++)
-                __set_bit(i, tbl->it_map);
+        end = n + npages;
 
         /* Bump the hint to a new block for small allocs. */
         if (largealloc) {
@@ -184,16 +183,17 @@ static unsigned long iommu_range_alloc(struct iommu_table *tbl,
         return n;
 }
 
-static dma_addr_t iommu_alloc(struct iommu_table *tbl, void *page,
-                       unsigned int npages, enum dma_data_direction direction,
-                       unsigned long mask, unsigned int align_order)
+static dma_addr_t iommu_alloc(struct device *dev, struct iommu_table *tbl,
+                              void *page, unsigned int npages,
+                              enum dma_data_direction direction,
+                              unsigned long mask, unsigned int align_order)
 {
         unsigned long entry, flags;
         dma_addr_t ret = DMA_ERROR_CODE;
 
         spin_lock_irqsave(&(tbl->it_lock), flags);
 
-        entry = iommu_range_alloc(tbl, npages, NULL, mask, align_order);
+        entry = iommu_range_alloc(dev, tbl, npages, NULL, mask, align_order);
 
         if (unlikely(entry == DMA_ERROR_CODE)) {
                 spin_unlock_irqrestore(&(tbl->it_lock), flags);
@@ -224,7 +224,6 @@ static void __iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
                          unsigned int npages)
 {
         unsigned long entry, free_entry;
-        unsigned long i;
 
         entry = dma_addr >> IOMMU_PAGE_SHIFT;
         free_entry = entry - tbl->it_offset;
@@ -246,9 +245,7 @@ static void __iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
         }
 
         ppc_md.tce_free(tbl, entry, npages);
-        
-        for (i = 0; i < npages; i++)
-                __clear_bit(free_entry+i, tbl->it_map);
+        iommu_area_free(tbl->it_map, free_entry, npages);
 }
 
 static void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
@@ -270,16 +267,18 @@ static void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
         spin_unlock_irqrestore(&(tbl->it_lock), flags);
 }
 
-int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist,
+int iommu_map_sg(struct device *dev, struct scatterlist *sglist,
                  int nelems, unsigned long mask,
                  enum dma_data_direction direction)
 {
+        struct iommu_table *tbl = dev->archdata.dma_data;
         dma_addr_t dma_next = 0, dma_addr;
         unsigned long flags;
         struct scatterlist *s, *outs, *segstart;
         int outcount, incount, i;
         unsigned int align;
         unsigned long handle;
+        unsigned int max_seg_size;
 
         BUG_ON(direction == DMA_NONE);
 
@@ -298,6 +297,7 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist,
 
         spin_lock_irqsave(&(tbl->it_lock), flags);
 
+        max_seg_size = dma_get_max_seg_size(dev);
         for_each_sg(sglist, s, nelems, i) {
                 unsigned long vaddr, npages, entry, slen;
 
@@ -314,7 +314,7 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist,
                 if (IOMMU_PAGE_SHIFT < PAGE_SHIFT && slen >= PAGE_SIZE &&
                     (vaddr & ~PAGE_MASK) == 0)
                         align = PAGE_SHIFT - IOMMU_PAGE_SHIFT;
-                entry = iommu_range_alloc(tbl, npages, &handle,
+                entry = iommu_range_alloc(dev, tbl, npages, &handle,
                                           mask >> IOMMU_PAGE_SHIFT, align);
 
                 DBG("  - vaddr: %lx, size: %lx\n", vaddr, slen);
@@ -344,7 +344,8 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist,
                         /* We cannot merge if:
                          * - allocated dma_addr isn't contiguous to previous allocation
                          */
-                        if (novmerge || (dma_addr != dma_next)) {
+                        if (novmerge || (dma_addr != dma_next) ||
+                            (outs->dma_length + s->length > max_seg_size)) {
                                 /* Can't merge: create a new segment */
                                 segstart = s;
                                 outcount++;
@@ -452,9 +453,6 @@ void iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist,
 struct iommu_table *iommu_init_table(struct iommu_table *tbl, int nid)
 {
         unsigned long sz;
-        unsigned long start_index, end_index;
-        unsigned long entries_per_4g;
-        unsigned long index;
         static int welcomed = 0;
         struct page *page;
 
@@ -476,6 +474,7 @@ struct iommu_table *iommu_init_table(struct iommu_table *tbl, int nid)
 
 #ifdef CONFIG_CRASH_DUMP
         if (ppc_md.tce_get) {
+                unsigned long index;
                 unsigned long tceval;
                 unsigned long tcecount = 0;
 
@@ -506,23 +505,6 @@ struct iommu_table *iommu_init_table(struct iommu_table *tbl, int nid)
         ppc_md.tce_free(tbl, tbl->it_offset, tbl->it_size);
 #endif
 
-        /*
-         * DMA cannot cross 4 GB boundary.  Mark last entry of each 4
-         * GB chunk as reserved.
-         */
-        if (protect4gb) {
-                entries_per_4g = 0x100000000l >> IOMMU_PAGE_SHIFT;
-
-                /* Mark the last bit before a 4GB boundary as used */
-                start_index = tbl->it_offset | (entries_per_4g - 1);
-                start_index -= tbl->it_offset;
-
-                end_index = tbl->it_size;
-
-                for (index = start_index; index < end_index - 1; index += entries_per_4g)
-                        __set_bit(index, tbl->it_map);
-        }
-
         if (!welcomed) {
                 printk(KERN_INFO "IOMMU table initialized, virtual merging %s\n",
                        novmerge ? "disabled" : "enabled");
@@ -570,9 +552,9 @@ void iommu_free_table(struct iommu_table *tbl, const char *node_name)
  * need not be page aligned, the dma_addr_t returned will point to the same
  * byte within the page as vaddr.
  */
-dma_addr_t iommu_map_single(struct iommu_table *tbl, void *vaddr,
-                size_t size, unsigned long mask,
-                enum dma_data_direction direction)
+dma_addr_t iommu_map_single(struct device *dev, struct iommu_table *tbl,
+                            void *vaddr, size_t size, unsigned long mask,
+                            enum dma_data_direction direction)
 {
         dma_addr_t dma_handle = DMA_ERROR_CODE;
         unsigned long uaddr;
@@ -589,7 +571,7 @@ dma_addr_t iommu_map_single(struct iommu_table *tbl, void *vaddr,
                     ((unsigned long)vaddr & ~PAGE_MASK) == 0)
                         align = PAGE_SHIFT - IOMMU_PAGE_SHIFT;
 
-                dma_handle = iommu_alloc(tbl, vaddr, npages, direction,
+                dma_handle = iommu_alloc(dev, tbl, vaddr, npages, direction,
                                          mask >> IOMMU_PAGE_SHIFT, align);
                 if (dma_handle == DMA_ERROR_CODE) {
                         if (printk_ratelimit())  {
@@ -621,8 +603,9 @@ void iommu_unmap_single(struct iommu_table *tbl, dma_addr_t dma_handle,
  * Returns the virtual address of the buffer and sets dma_handle
  * to the dma address (mapping) of the first page.
  */
-void *iommu_alloc_coherent(struct iommu_table *tbl, size_t size,
-                dma_addr_t *dma_handle, unsigned long mask, gfp_t flag, int node)
+void *iommu_alloc_coherent(struct device *dev, struct iommu_table *tbl,
+                           size_t size, dma_addr_t *dma_handle,
+                           unsigned long mask, gfp_t flag, int node)
 {
         void *ret = NULL;
         dma_addr_t mapping;
@@ -656,7 +639,7 @@ void *iommu_alloc_coherent(struct iommu_table *tbl, size_t size,
         /* Set up tces to cover the allocated range */
         nio_pages = size >> IOMMU_PAGE_SHIFT;
         io_order = get_iommu_order(size);
-        mapping = iommu_alloc(tbl, ret, nio_pages, DMA_BIDIRECTIONAL,
+        mapping = iommu_alloc(dev, tbl, ret, nio_pages, DMA_BIDIRECTIONAL,
                               mask >> IOMMU_PAGE_SHIFT, io_order);
         if (mapping == DMA_ERROR_CODE) {
                 free_pages((unsigned long)ret, order);
diff --git a/arch/powerpc/kernel/legacy_serial.c b/arch/powerpc/kernel/legacy_serial.c
index 76b862bd1fe9..61dd17449ddc 100644
--- a/arch/powerpc/kernel/legacy_serial.c
+++ b/arch/powerpc/kernel/legacy_serial.c
@@ -36,7 +36,8 @@ static struct legacy_serial_info {
 static struct __initdata of_device_id parents[] = {
         {.type = "soc",},
         {.type = "tsi-bridge",},
-        {.type = "opb", .compatible = "ibm,opb",},
+        {.type = "opb", },
+        {.compatible = "ibm,opb",},
         {.compatible = "simple-bus",},
         {.compatible = "wrs,epld-localbus",},
 };
diff --git a/arch/powerpc/kernel/pmc.c b/arch/powerpc/kernel/pmc.c
index ea04e0ab3f2f..0516e2d3e02e 100644
--- a/arch/powerpc/kernel/pmc.c
+++ b/arch/powerpc/kernel/pmc.c
@@ -26,7 +26,7 @@
 
 static void dummy_perf(struct pt_regs *regs)
 {
-#if defined(CONFIG_FSL_BOOKE) && !defined(CONFIG_E200)
+#if defined(CONFIG_FSL_EMB_PERFMON)
         mtpmr(PMRN_PMGC0, mfpmr(PMRN_PMGC0) & ~PMGC0_PMIE);
 #elif defined(CONFIG_PPC64) || defined(CONFIG_6xx)
         if (cur_cpu_spec->pmc_type == PPC_PMC_IBM)
diff --git a/arch/powerpc/kernel/vio.c b/arch/powerpc/kernel/vio.c
index f0bad7070fb5..f98867252ee2 100644
--- a/arch/powerpc/kernel/vio.c
+++ b/arch/powerpc/kernel/vio.c
@@ -176,7 +176,7 @@ static void __devinit vio_dev_release(struct device *dev)
  * Returns a pointer to the created vio_dev or NULL if node has
  * NULL device_type or compatible fields.
  */
-struct vio_dev * __devinit vio_register_device_node(struct device_node *of_node)
+struct vio_dev *vio_register_device_node(struct device_node *of_node)
 {
         struct vio_dev *viodev;
         const unsigned int *unit_address;
diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c
index e8122447f019..c7d7bd43a251 100644
--- a/arch/powerpc/mm/mem.c
+++ b/arch/powerpc/mm/mem.c
@@ -483,7 +483,12 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address,
                  */
                 _tlbie(address, 0 /* 8xx doesn't care about PID */);
 #endif
-                if (!PageReserved(page)
+                /* The _PAGE_USER test should really be _PAGE_EXEC, but
+                 * older glibc versions execute some code from no-exec
+                 * pages, which for now we are supporting.  If exec-only
+                 * pages are ever implemented, this will have to change.
+                 */
+                if (!PageReserved(page) && (pte_val(pte) & _PAGE_USER)
                     && !test_bit(PG_arch_1, &page->flags)) {
                         if (vma->vm_mm == current->active_mm) {
                                 __flush_dcache_icache((void *) address);
diff --git a/arch/powerpc/mm/pgtable_32.c b/arch/powerpc/mm/pgtable_32.c
index 64488723162a..f80f90c4d58b 100644
--- a/arch/powerpc/mm/pgtable_32.c
+++ b/arch/powerpc/mm/pgtable_32.c
@@ -86,7 +86,7 @@ pgd_t *pgd_alloc(struct mm_struct *mm)
         return ret;
 }
 
-void pgd_free(pgd_t *pgd)
+void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 {
         free_pages((unsigned long)pgd, PGDIR_ORDER);
 }
@@ -123,7 +123,7 @@ struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
         return ptepage;
 }
 
-void pte_free_kernel(pte_t *pte)
+void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
 {
 #ifdef CONFIG_SMP
         hash_page_sync();
@@ -131,7 +131,7 @@ void pte_free_kernel(pte_t *pte)
         free_page((unsigned long)pte);
 }
 
-void pte_free(struct page *ptepage)
+void pte_free(struct mm_struct *mm, struct page *ptepage)
 {
 #ifdef CONFIG_SMP
         hash_page_sync();
diff --git a/arch/powerpc/oprofile/Makefile b/arch/powerpc/oprofile/Makefile
index c5f64c3bd668..2ef6b0dddd8c 100644
--- a/arch/powerpc/oprofile/Makefile
+++ b/arch/powerpc/oprofile/Makefile
@@ -15,5 +15,5 @@ oprofile-$(CONFIG_OPROFILE_CELL) += op_model_cell.o \
                 cell/spu_profiler.o cell/vma_map.o \
                 cell/spu_task_sync.o
 oprofile-$(CONFIG_PPC64) += op_model_rs64.o op_model_power4.o op_model_pa6t.o
-oprofile-$(CONFIG_FSL_BOOKE) += op_model_fsl_booke.o
+oprofile-$(CONFIG_FSL_EMB_PERFMON) += op_model_fsl_emb.o
 oprofile-$(CONFIG_6xx) += op_model_7450.o
diff --git a/arch/powerpc/oprofile/common.c b/arch/powerpc/oprofile/common.c
index a28cce1d6c24..4908dc98f9ca 100644
--- a/arch/powerpc/oprofile/common.c
+++ b/arch/powerpc/oprofile/common.c
@@ -202,9 +202,9 @@ int __init oprofile_arch_init(struct oprofile_operations *ops)
                         model = &op_model_7450;
                         break;
 #endif
-#ifdef CONFIG_FSL_BOOKE
-                case PPC_OPROFILE_BOOKE:
-                        model = &op_model_fsl_booke;
+#if defined(CONFIG_FSL_EMB_PERFMON)
+                case PPC_OPROFILE_FSL_EMB:
+                        model = &op_model_fsl_emb;
                         break;
 #endif
                 default:
diff --git a/arch/powerpc/oprofile/op_model_fsl_booke.c b/arch/powerpc/oprofile/op_model_fsl_emb.c
index 183a28bb1812..91596f6ba1f4 100644
--- a/arch/powerpc/oprofile/op_model_fsl_booke.c
+++ b/arch/powerpc/oprofile/op_model_fsl_emb.c
@@ -1,7 +1,5 @@
 /*
- * arch/powerpc/oprofile/op_model_fsl_booke.c
- *
- * Freescale Book-E oprofile support, based on ppc64 oprofile support
+ * Freescale Embedded oprofile support, based on ppc64 oprofile support
  * Copyright (C) 2004 Anton Blanchard <anton@au.ibm.com>, IBM
  *
  * Copyright (c) 2004 Freescale Semiconductor, Inc
@@ -22,7 +20,7 @@
 #include <asm/system.h>
 #include <asm/processor.h>
 #include <asm/cputable.h>
-#include <asm/reg_booke.h>
+#include <asm/reg_fsl_emb.h>
 #include <asm/page.h>
 #include <asm/pmc.h>
 #include <asm/oprofile_impl.h>
@@ -244,7 +242,7 @@ static void dump_pmcs(void)
                         mfpmr(PMRN_PMLCA3), mfpmr(PMRN_PMLCB3));
 }
 
-static int fsl_booke_cpu_setup(struct op_counter_config *ctr)
+static int fsl_emb_cpu_setup(struct op_counter_config *ctr)
 {
         int i;
 
@@ -262,7 +260,7 @@ static int fsl_booke_cpu_setup(struct op_counter_config *ctr)
         return 0;
 }
 
-static int fsl_booke_reg_setup(struct op_counter_config *ctr,
+static int fsl_emb_reg_setup(struct op_counter_config *ctr,
                              struct op_system_config *sys,
                              int num_ctrs)
 {
@@ -281,7 +279,7 @@ static int fsl_booke_reg_setup(struct op_counter_config *ctr,
         return 0;
 }
 
-static int fsl_booke_start(struct op_counter_config *ctr)
+static int fsl_emb_start(struct op_counter_config *ctr)
 {
         int i;
 
@@ -315,7 +313,7 @@ static int fsl_booke_start(struct op_counter_config *ctr)
         return 0;
 }
 
-static void fsl_booke_stop(void)
+static void fsl_emb_stop(void)
 {
         /* freeze counters */
         pmc_stop_ctrs();
@@ -329,7 +327,7 @@ static void fsl_booke_stop(void)
 }
 
 
-static void fsl_booke_handle_interrupt(struct pt_regs *regs,
+static void fsl_emb_handle_interrupt(struct pt_regs *regs,
                                     struct op_counter_config *ctr)
 {
         unsigned long pc;
@@ -362,10 +360,10 @@ static void fsl_booke_handle_interrupt(struct pt_regs *regs,
         pmc_start_ctrs(1);
 }
 
-struct op_powerpc_model op_model_fsl_booke = {
-        .reg_setup              = fsl_booke_reg_setup,
-        .cpu_setup              = fsl_booke_cpu_setup,
-        .start                  = fsl_booke_start,
-        .stop                   = fsl_booke_stop,
-        .handle_interrupt       = fsl_booke_handle_interrupt,
+struct op_powerpc_model op_model_fsl_emb = {
+        .reg_setup              = fsl_emb_reg_setup,
+        .cpu_setup              = fsl_emb_cpu_setup,
+        .start                  = fsl_emb_start,
+        .stop                   = fsl_emb_stop,
+        .handle_interrupt       = fsl_emb_handle_interrupt,
 };
diff --git a/arch/powerpc/platforms/52xx/lite5200_pm.c b/arch/powerpc/platforms/52xx/lite5200_pm.c
index c0f13e8deb0b..41c7fd91e99e 100644
--- a/arch/powerpc/platforms/52xx/lite5200_pm.c
+++ b/arch/powerpc/platforms/52xx/lite5200_pm.c
@@ -31,7 +31,7 @@ static int lite5200_pm_valid(suspend_state_t state)
         }
 }
 
-static int lite5200_pm_set_target(suspend_state_t state)
+static int lite5200_pm_begin(suspend_state_t state)
 {
         if (lite5200_pm_valid(state)) {
                 lite5200_pm_target_state = state;
@@ -219,12 +219,18 @@ static void lite5200_pm_finish(void)
                 mpc52xx_pm_finish();
 }
 
+static void lite5200_pm_end(void)
+{
+        lite5200_pm_target_state = PM_SUSPEND_ON;
+}
+
 static struct platform_suspend_ops lite5200_pm_ops = {
         .valid          = lite5200_pm_valid,
-        .set_target     = lite5200_pm_set_target,
+        .begin          = lite5200_pm_begin,
         .prepare        = lite5200_pm_prepare,
         .enter          = lite5200_pm_enter,
         .finish         = lite5200_pm_finish,
+        .end            = lite5200_pm_end,
 };
 
 int __init lite5200_pm_init(void)
diff --git a/arch/powerpc/platforms/82xx/mpc8272_ads.c b/arch/powerpc/platforms/82xx/mpc8272_ads.c
index 3fce6b375dbc..7d3018751988 100644
--- a/arch/powerpc/platforms/82xx/mpc8272_ads.c
+++ b/arch/powerpc/platforms/82xx/mpc8272_ads.c
@@ -134,13 +134,12 @@ static void __init mpc8272_ads_setup_arch(void)
         }
 
         bcsr = of_iomap(np, 0);
+        of_node_put(np);
         if (!bcsr) {
                 printk(KERN_ERR "Cannot map BCSR registers\n");
                 return;
         }
 
-        of_node_put(np);
-
         clrbits32(&bcsr[1], BCSR1_RS232_EN1 | BCSR1_RS232_EN2 | BCSR1_FETHIEN);
         setbits32(&bcsr[1], BCSR1_FETH_RST);
 
diff --git a/arch/powerpc/platforms/82xx/pq2fads.c b/arch/powerpc/platforms/82xx/pq2fads.c
index 68196e349994..e1dceeec4994 100644
--- a/arch/powerpc/platforms/82xx/pq2fads.c
+++ b/arch/powerpc/platforms/82xx/pq2fads.c
@@ -130,13 +130,12 @@ static void __init pq2fads_setup_arch(void)
         }
 
         bcsr = of_iomap(np, 0);
+        of_node_put(np);
         if (!bcsr) {
                 printk(KERN_ERR "Cannot map BCSR registers\n");
                 return;
         }
 
-        of_node_put(np);
-
         /* Enable the serial and ethernet ports */
 
         clrbits32(&bcsr[1], BCSR1_RS232_EN1 | BCSR1_RS232_EN2 | BCSR1_FETHIEN);
diff --git a/arch/powerpc/platforms/83xx/mpc832x_rdb.c b/arch/powerpc/platforms/83xx/mpc832x_rdb.c
index 9f0fd88b2b1f..e7f706b624fe 100644
--- a/arch/powerpc/platforms/83xx/mpc832x_rdb.c
+++ b/arch/powerpc/platforms/83xx/mpc832x_rdb.c
@@ -101,7 +101,7 @@ static void __init mpc832x_rdb_setup_arch(void)
 #ifdef CONFIG_QUICC_ENGINE
         qe_reset();
 
-        if ((np = of_find_node_by_name(np, "par_io")) != NULL) {
+        if ((np = of_find_node_by_name(NULL, "par_io")) != NULL) {
                 par_io_init(np);
                 of_node_put(np);
 
diff --git a/arch/powerpc/platforms/83xx/mpc83xx.h b/arch/powerpc/platforms/83xx/mpc83xx.h
index 88bb748aff0d..68065e62fc3d 100644
--- a/arch/powerpc/platforms/83xx/mpc83xx.h
+++ b/arch/powerpc/platforms/83xx/mpc83xx.h
@@ -14,6 +14,8 @@
 #define MPC83XX_SCCR_USB_DRCM_11   0x00300000
 #define MPC83XX_SCCR_USB_DRCM_01   0x00100000
 #define MPC83XX_SCCR_USB_DRCM_10   0x00200000
+#define MPC8315_SCCR_USB_MASK      0x00c00000
+#define MPC8315_SCCR_USB_DRCM_11   0x00c00000
 #define MPC837X_SCCR_USB_DRCM_11   0x00c00000
 
 /* system i/o configuration register low */
diff --git a/arch/powerpc/platforms/83xx/usb.c b/arch/powerpc/platforms/83xx/usb.c
index 681230a30acd..471fdd8f4108 100644
--- a/arch/powerpc/platforms/83xx/usb.c
+++ b/arch/powerpc/platforms/83xx/usb.c
@@ -104,6 +104,7 @@ int mpc831x_usb_cfg(void)
         u32 temp;
         void __iomem *immap, *usb_regs;
         struct device_node *np = NULL;
+        struct device_node *immr_node = NULL;
         const void *prop;
         struct resource res;
         int ret = 0;
@@ -124,10 +125,15 @@ int mpc831x_usb_cfg(void)
         }
 
         /* Configure clock */
-        temp = in_be32(immap + MPC83XX_SCCR_OFFS);
-        temp &= ~MPC83XX_SCCR_USB_MASK;
-        temp |= MPC83XX_SCCR_USB_DRCM_11;  /* 1:3 */
-        out_be32(immap + MPC83XX_SCCR_OFFS, temp);
+        immr_node = of_get_parent(np);
+        if (immr_node && of_device_is_compatible(immr_node, "fsl,mpc8315-immr"))
+                clrsetbits_be32(immap + MPC83XX_SCCR_OFFS,
+                                MPC8315_SCCR_USB_MASK,
+                                MPC8315_SCCR_USB_DRCM_11);
+        else
+                clrsetbits_be32(immap + MPC83XX_SCCR_OFFS,
+                                MPC83XX_SCCR_USB_MASK,
+                                MPC83XX_SCCR_USB_DRCM_11);
 
         /* Configure pin mux for ULPI.  There is no pin mux for UTMI */
         if (prop && !strcmp(prop, "ulpi")) {
@@ -144,6 +150,9 @@ int mpc831x_usb_cfg(void)
 
         iounmap(immap);
 
+        if (immr_node)
+                of_node_put(immr_node);
+
         /* Map USB SOC space */
         ret = of_address_to_resource(np, 0, &res);
         if (ret) {
diff --git a/arch/powerpc/platforms/8xx/adder875.c b/arch/powerpc/platforms/8xx/adder875.c
index c6bc0783c3b0..82363e98f50e 100644
--- a/arch/powerpc/platforms/8xx/adder875.c
+++ b/arch/powerpc/platforms/8xx/adder875.c
@@ -15,12 +15,12 @@
 
 #include <asm/time.h>
 #include <asm/machdep.h>
-#include <asm/commproc.h>
+#include <asm/cpm1.h>
 #include <asm/fs_pd.h>
 #include <asm/udbg.h>
 #include <asm/prom.h>
 
-#include <sysdev/commproc.h>
+#include "mpc8xx.h"
 
 struct cpm_pin {
         int port, pin, flags;
@@ -108,7 +108,7 @@ define_machine(adder875) {
         .name = "Adder MPC875",
         .probe = adder875_probe,
         .setup_arch = adder875_setup,
-        .init_IRQ = m8xx_pic_init,
+        .init_IRQ = mpc8xx_pics_init,
         .get_irq = mpc8xx_get_irq,
         .restart = mpc8xx_restart,
         .calibrate_decr = generic_calibrate_decr,
diff --git a/arch/powerpc/platforms/8xx/ep88xc.c b/arch/powerpc/platforms/8xx/ep88xc.c
index a8dffa005775..7d9ac6040d63 100644
--- a/arch/powerpc/platforms/8xx/ep88xc.c
+++ b/arch/powerpc/platforms/8xx/ep88xc.c
@@ -15,7 +15,6 @@
 #include <asm/machdep.h>
 #include <asm/io.h>
 #include <asm/udbg.h>
-#include <asm/commproc.h>
 #include <asm/cpm1.h>
 
 #include "mpc8xx.h"
diff --git a/arch/powerpc/platforms/Kconfig b/arch/powerpc/platforms/Kconfig
index e2c952619805..fcedbec07f94 100644
--- a/arch/powerpc/platforms/Kconfig
+++ b/arch/powerpc/platforms/Kconfig
@@ -24,6 +24,7 @@ config PPC_83xx
         select MPC83xx
         select IPIC
         select WANT_DEVICE_TREE
+        select FSL_EMB_PERFMON
 
 config PPC_86xx
         bool "Freescale 86xx"
diff --git a/arch/powerpc/platforms/Kconfig.cputype b/arch/powerpc/platforms/Kconfig.cputype
index 51030ab2a023..69941ba70975 100644
--- a/arch/powerpc/platforms/Kconfig.cputype
+++ b/arch/powerpc/platforms/Kconfig.cputype
@@ -94,6 +94,7 @@ config 8xx
         bool
 
 config E500
+        select FSL_EMB_PERFMON
         bool
 
 config PPC_FPU
@@ -115,6 +116,9 @@ config FSL_BOOKE
         depends on E200 || E500
         default y
 
+config FSL_EMB_PERFMON
+        bool
+
 config PTE_64BIT
         bool
         depends on 44x || E500
diff --git a/arch/powerpc/platforms/cell/Kconfig b/arch/powerpc/platforms/cell/Kconfig
index 3a963b4a9be0..2f169991896d 100644
--- a/arch/powerpc/platforms/cell/Kconfig
+++ b/arch/powerpc/platforms/cell/Kconfig
@@ -54,6 +54,13 @@ config SPU_FS_64K_LS
           uses 4K pages. This can improve performances of applications
           using multiple SPEs by lowering the TLB pressure on them.
 
+config SPU_TRACE
+        tristate "SPU event tracing support"
+        depends on SPU_FS && MARKERS
+        help
+          This option allows reading a trace of spu-related events through
+          the sputrace file in procfs.
+
 config SPU_BASE
         bool
         default n
diff --git a/arch/powerpc/platforms/cell/axon_msi.c b/arch/powerpc/platforms/cell/axon_msi.c
index 095988f13bf4..d95e71dee91f 100644
--- a/arch/powerpc/platforms/cell/axon_msi.c
+++ b/arch/powerpc/platforms/cell/axon_msi.c
@@ -13,7 +13,7 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/msi.h>
-#include <linux/reboot.h>
+#include <linux/of_platform.h>
 
 #include <asm/dcr.h>
 #include <asm/machdep.h>
@@ -65,14 +65,12 @@
 
 struct axon_msic {
         struct irq_host *irq_host;
-        __le32 *fifo;
+        __le32 *fifo_virt;
+        dma_addr_t fifo_phys;
         dcr_host_t dcr_host;
-        struct list_head list;
         u32 read_offset;
 };
 
-static LIST_HEAD(axon_msic_list);
-
 static void msic_dcr_write(struct axon_msic *msic, unsigned int dcr_n, u32 val)
 {
         pr_debug("axon_msi: dcr_write(0x%x, 0x%x)\n", val, dcr_n);
@@ -94,7 +92,7 @@ static void axon_msi_cascade(unsigned int irq, struct irq_desc *desc)
 
         while (msic->read_offset != write_offset) {
                 idx  = msic->read_offset / sizeof(__le32);
-                msi  = le32_to_cpu(msic->fifo[idx]);
+                msi  = le32_to_cpu(msic->fifo_virt[idx]);
                 msi &= 0xFFFF;
 
                 pr_debug("axon_msi: woff %x roff %x msi %x\n",
@@ -139,6 +137,7 @@ static struct axon_msic *find_msi_translator(struct pci_dev *dev)
 
         tmp = dn;
         dn = of_find_node_by_phandle(*ph);
+        of_node_put(tmp);
         if (!dn) {
                 dev_dbg(&dev->dev,
                         "axon_msi: msi-translator doesn't point to a node\n");
@@ -156,7 +155,6 @@ static struct axon_msic *find_msi_translator(struct pci_dev *dev)
 
 out_error:
         of_node_put(dn);
-        of_node_put(tmp);
 
         return msic;
 }
@@ -292,30 +290,24 @@ static struct irq_host_ops msic_host_ops = {
         .map    = msic_host_map,
 };
 
-static int axon_msi_notify_reboot(struct notifier_block *nb,
-                                  unsigned long code, void *data)
+static int axon_msi_shutdown(struct of_device *device)
 {
-        struct axon_msic *msic;
+        struct axon_msic *msic = device->dev.platform_data;
         u32 tmp;
 
-        list_for_each_entry(msic, &axon_msic_list, list) {
-                pr_debug("axon_msi: disabling %s\n",
-                          msic->irq_host->of_node->full_name);
-                tmp  = dcr_read(msic->dcr_host, MSIC_CTRL_REG);
-                tmp &= ~MSIC_CTRL_ENABLE & ~MSIC_CTRL_IRQ_ENABLE;
-                msic_dcr_write(msic, MSIC_CTRL_REG, tmp);
-        }
+        pr_debug("axon_msi: disabling %s\n",
+                  msic->irq_host->of_node->full_name);
+        tmp  = dcr_read(msic->dcr_host, MSIC_CTRL_REG);
+        tmp &= ~MSIC_CTRL_ENABLE & ~MSIC_CTRL_IRQ_ENABLE;
+        msic_dcr_write(msic, MSIC_CTRL_REG, tmp);
 
         return 0;
 }
 
-static struct notifier_block axon_msi_reboot_notifier = {
-        .notifier_call = axon_msi_notify_reboot
-};
-
-static int axon_msi_setup_one(struct device_node *dn)
+static int axon_msi_probe(struct of_device *device,
+                          const struct of_device_id *device_id)
 {
-        struct page *page;
+        struct device_node *dn = device->node;
         struct axon_msic *msic;
         unsigned int virq;
         int dcr_base, dcr_len;
@@ -346,16 +338,14 @@ static int axon_msi_setup_one(struct device_node *dn)
                 goto out_free_msic;
         }
 
-        page = alloc_pages_node(of_node_to_nid(dn), GFP_KERNEL,
-                                get_order(MSIC_FIFO_SIZE_BYTES));
-        if (!page) {
+        msic->fifo_virt = dma_alloc_coherent(&device->dev, MSIC_FIFO_SIZE_BYTES,
+                                             &msic->fifo_phys, GFP_KERNEL);
+        if (!msic->fifo_virt) {
                 printk(KERN_ERR "axon_msi: couldn't allocate fifo for %s\n",
                        dn->full_name);
                 goto out_free_msic;
         }
 
-        msic->fifo = page_address(page);
-
         msic->irq_host = irq_alloc_host(of_node_get(dn), IRQ_HOST_MAP_NOMAP,
                                         NR_IRQS, &msic_host_ops, 0);
         if (!msic->irq_host) {
@@ -378,14 +368,18 @@ static int axon_msi_setup_one(struct device_node *dn)
         pr_debug("axon_msi: irq 0x%x setup for axon_msi\n", virq);
 
         /* Enable the MSIC hardware */
-        msic_dcr_write(msic, MSIC_BASE_ADDR_HI_REG, (u64)msic->fifo >> 32);
+        msic_dcr_write(msic, MSIC_BASE_ADDR_HI_REG, msic->fifo_phys >> 32);
         msic_dcr_write(msic, MSIC_BASE_ADDR_LO_REG,
-                                  (u64)msic->fifo & 0xFFFFFFFF);
+                                  msic->fifo_phys & 0xFFFFFFFF);
         msic_dcr_write(msic, MSIC_CTRL_REG,
                         MSIC_CTRL_IRQ_ENABLE | MSIC_CTRL_ENABLE |
                         MSIC_CTRL_FIFO_SIZE);
 
-        list_add(&msic->list, &axon_msic_list);
+        device->dev.platform_data = msic;
+
+        ppc_md.setup_msi_irqs = axon_msi_setup_msi_irqs;
+        ppc_md.teardown_msi_irqs = axon_msi_teardown_msi_irqs;
+        ppc_md.msi_check_device = axon_msi_check_device;
 
         printk(KERN_DEBUG "axon_msi: setup MSIC on %s\n", dn->full_name);
 
@@ -394,7 +388,8 @@ static int axon_msi_setup_one(struct device_node *dn)
 out_free_host:
         kfree(msic->irq_host);
 out_free_fifo:
-        __free_pages(virt_to_page(msic->fifo), get_order(MSIC_FIFO_SIZE_BYTES));
+        dma_free_coherent(&device->dev, MSIC_FIFO_SIZE_BYTES, msic->fifo_virt,
+                          msic->fifo_phys);
 out_free_msic:
         kfree(msic);
 out:
@@ -402,28 +397,24 @@ out:
         return -1;
 }
 
-static int axon_msi_init(void)
-{
-        struct device_node *dn;
-        int found = 0;
-
-        pr_debug("axon_msi: initialising ...\n");
-
-        for_each_compatible_node(dn, NULL, "ibm,axon-msic") {
-                if (axon_msi_setup_one(dn) == 0)
-                        found++;
-        }
-
-        if (found) {
-                ppc_md.setup_msi_irqs = axon_msi_setup_msi_irqs;
-                ppc_md.teardown_msi_irqs = axon_msi_teardown_msi_irqs;
-                ppc_md.msi_check_device = axon_msi_check_device;
-
-                register_reboot_notifier(&axon_msi_reboot_notifier);
+static const struct of_device_id axon_msi_device_id[] = {
+        {
+                .compatible     = "ibm,axon-msic"
+        },
+        {}
+};
 
-                pr_debug("axon_msi: registered callbacks!\n");
-        }
+static struct of_platform_driver axon_msi_driver = {
+        .match_table    = axon_msi_device_id,
+        .probe          = axon_msi_probe,
+        .shutdown       = axon_msi_shutdown,
+        .driver         = {
+                .name   = "axon-msi"
+        },
+};
 
-        return 0;
+static int __init axon_msi_init(void)
+{
+        return of_register_platform_driver(&axon_msi_driver);
 }
-arch_initcall(axon_msi_init);
+subsys_initcall(axon_msi_init);
diff --git a/arch/powerpc/platforms/cell/setup.c b/arch/powerpc/platforms/cell/setup.c
index e6534b519c9a..a7f609b3b876 100644
--- a/arch/powerpc/platforms/cell/setup.c
+++ b/arch/powerpc/platforms/cell/setup.c
@@ -98,7 +98,7 @@ static int __init cell_publish_devices(void)
         }
         return 0;
 }
-machine_device_initcall(cell, cell_publish_devices);
+machine_subsys_initcall(cell, cell_publish_devices);
 
 static void cell_mpic_cascade(unsigned int irq, struct irq_desc *desc)
 {
diff --git a/arch/powerpc/platforms/cell/spufs/Makefile b/arch/powerpc/platforms/cell/spufs/Makefile
index d3a349fb42e5..99610a6361f2 100644
--- a/arch/powerpc/platforms/cell/spufs/Makefile
+++ b/arch/powerpc/platforms/cell/spufs/Makefile
@@ -4,6 +4,8 @@ spufs-y += inode.o file.o context.o syscalls.o coredump.o
 spufs-y += sched.o backing_ops.o hw_ops.o run.o gang.o
 spufs-y += switch.o fault.o lscsa_alloc.o
 
+obj-$(CONFIG_SPU_TRACE) += sputrace.o
+
 # Rules to build switch.o with the help of SPU tool chain
 SPU_CROSS       := spu-
 SPU_CC          := $(SPU_CROSS)gcc
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 3fcd06418b01..1018acd1746b 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -29,6 +29,7 @@
 #include <linux/poll.h>
 #include <linux/ptrace.h>
 #include <linux/seq_file.h>
+#include <linux/marker.h>
 
 #include <asm/io.h>
 #include <asm/semaphore.h>
@@ -358,6 +359,8 @@ static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
         struct spu_context *ctx = vma->vm_file->private_data;
         unsigned long area, offset = address - vma->vm_start;
 
+        spu_context_nospu_trace(spufs_ps_nopfn__enter, ctx);
+
         offset += vma->vm_pgoff << PAGE_SHIFT;
         if (offset >= ps_size)
                 return NOPFN_SIGBUS;
@@ -375,11 +378,14 @@ static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
 
         if (ctx->state == SPU_STATE_SAVED) {
                 up_read(&current->mm->mmap_sem);
+                spu_context_nospu_trace(spufs_ps_nopfn__sleep, ctx);
                 spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE);
+                spu_context_trace(spufs_ps_nopfn__wake, ctx, ctx->spu);
                 down_read(&current->mm->mmap_sem);
         } else {
                 area = ctx->spu->problem_phys + ps_offs;
                 vm_insert_pfn(vma, address, (area + offset) >> PAGE_SHIFT);
+                spu_context_trace(spufs_ps_nopfn__insert, ctx, ctx->spu);
         }
 
         spu_release(ctx);
diff --git a/arch/powerpc/platforms/cell/spufs/inode.c b/arch/powerpc/platforms/cell/spufs/inode.c
index c0e968a4c211..90784c029f25 100644
--- a/arch/powerpc/platforms/cell/spufs/inode.c
+++ b/arch/powerpc/platforms/cell/spufs/inode.c
@@ -322,7 +322,7 @@ static struct spu_context *
 spufs_assert_affinity(unsigned int flags, struct spu_gang *gang,
                                                 struct file *filp)
 {
-        struct spu_context *tmp, *neighbor;
+        struct spu_context *tmp, *neighbor, *err;
         int count, node;
         int aff_supp;
 
@@ -354,11 +354,15 @@ spufs_assert_affinity(unsigned int flags, struct spu_gang *gang,
                 if (!list_empty(&neighbor->aff_list) && !(neighbor->aff_head) &&
                     !list_is_last(&neighbor->aff_list, &gang->aff_list_head) &&
                     !list_entry(neighbor->aff_list.next, struct spu_context,
-                    aff_list)->aff_head)
-                        return ERR_PTR(-EEXIST);
+                    aff_list)->aff_head) {
+                        err = ERR_PTR(-EEXIST);
+                        goto out_put_neighbor;
+                }
 
-                if (gang != neighbor->gang)
-                        return ERR_PTR(-EINVAL);
+                if (gang != neighbor->gang) {
+                        err = ERR_PTR(-EINVAL);
+                        goto out_put_neighbor;
+                }
 
                 count = 1;
                 list_for_each_entry(tmp, &gang->aff_list_head, aff_list)
@@ -372,11 +376,17 @@ spufs_assert_affinity(unsigned int flags, struct spu_gang *gang,
                                 break;
                 }
 
-                if (node == MAX_NUMNODES)
-                        return ERR_PTR(-EEXIST);
+                if (node == MAX_NUMNODES) {
+                        err = ERR_PTR(-EEXIST);
+                        goto out_put_neighbor;
+                }
         }
 
         return neighbor;
+
+out_put_neighbor:
+        put_spu_context(neighbor);
+        return err;
 }
 
 static void
@@ -454,9 +464,12 @@ spufs_create_context(struct inode *inode, struct dentry *dentry,
         if (ret)
                 goto out_aff_unlock;
 
-        if (affinity)
+        if (affinity) {
                 spufs_set_affinity(flags, SPUFS_I(dentry->d_inode)->i_ctx,
                                                                 neighbor);
+                if (neighbor)
+                        put_spu_context(neighbor);
+        }
 
         /*
          * get references for dget and mntget, will be released
diff --git a/arch/powerpc/platforms/cell/spufs/run.c b/arch/powerpc/platforms/cell/spufs/run.c
index c01a09da1e56..b4814c740d8a 100644
--- a/arch/powerpc/platforms/cell/spufs/run.c
+++ b/arch/powerpc/platforms/cell/spufs/run.c
@@ -410,8 +410,11 @@ long spufs_run_spu(struct spu_context *ctx, u32 *npc, u32 *event)
          * since we have TIF_SINGLESTEP set, thus the kernel will do
          * it upon return from the syscall anyawy
          */
-        if ((status & SPU_STATUS_STOPPED_BY_STOP)
-            && (status >> SPU_STOP_STATUS_SHIFT) == 0x3fff) {
+        if (unlikely(status & SPU_STATUS_SINGLE_STEP))
+                ret = -ERESTARTSYS;
+
+        else if (unlikely((status & SPU_STATUS_STOPPED_BY_STOP)
+            && (status >> SPU_STOP_STATUS_SHIFT) == 0x3fff)) {
                 force_sig(SIGTRAP, current);
                 ret = -ERESTARTSYS;
         }
diff --git a/arch/powerpc/platforms/cell/spufs/sched.c b/arch/powerpc/platforms/cell/spufs/sched.c
index 00d914232af1..5915343e2599 100644
--- a/arch/powerpc/platforms/cell/spufs/sched.c
+++ b/arch/powerpc/platforms/cell/spufs/sched.c
@@ -39,6 +39,7 @@
 #include <linux/pid_namespace.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/marker.h>
 
 #include <asm/io.h>
 #include <asm/mmu_context.h>
@@ -216,8 +217,8 @@ void do_notify_spus_active(void)
  */
 static void spu_bind_context(struct spu *spu, struct spu_context *ctx)
 {
-        pr_debug("%s: pid=%d SPU=%d NODE=%d\n", __FUNCTION__, current->pid,
-                 spu->number, spu->node);
+        spu_context_trace(spu_bind_context__enter, ctx, spu);
+
         spuctx_switch_state(ctx, SPU_UTIL_SYSTEM);
 
         if (ctx->flags & SPU_CREATE_NOSCHED)
@@ -399,8 +400,8 @@ static int has_affinity(struct spu_context *ctx)
  */
 static void spu_unbind_context(struct spu *spu, struct spu_context *ctx)
 {
-        pr_debug("%s: unbind pid=%d SPU=%d NODE=%d\n", __FUNCTION__,
-                 spu->pid, spu->number, spu->node);
+        spu_context_trace(spu_unbind_context__enter, ctx, spu);
+
         spuctx_switch_state(ctx, SPU_UTIL_SYSTEM);
 
         if (spu->ctx->flags & SPU_CREATE_NOSCHED)
@@ -528,6 +529,8 @@ static struct spu *spu_get_idle(struct spu_context *ctx)
         struct spu *spu, *aff_ref_spu;
         int node, n;
 
+        spu_context_nospu_trace(spu_get_idle__enter, ctx);
+
         if (ctx->gang) {
                 mutex_lock(&ctx->gang->aff_mutex);
                 if (has_affinity(ctx)) {
@@ -546,8 +549,7 @@ static struct spu *spu_get_idle(struct spu_context *ctx)
                         if (atomic_dec_and_test(&ctx->gang->aff_sched_count))
                                 ctx->gang->aff_ref_spu = NULL;
                         mutex_unlock(&ctx->gang->aff_mutex);
-
-                        return NULL;
+                        goto not_found;
                 }
                 mutex_unlock(&ctx->gang->aff_mutex);
         }
@@ -565,12 +567,14 @@ static struct spu *spu_get_idle(struct spu_context *ctx)
                 mutex_unlock(&cbe_spu_info[node].list_mutex);
         }
 
+ not_found:
+        spu_context_nospu_trace(spu_get_idle__not_found, ctx);
         return NULL;
 
  found:
         spu->alloc_state = SPU_USED;
         mutex_unlock(&cbe_spu_info[node].list_mutex);
-        pr_debug("Got SPU %d %d\n", spu->number, spu->node);
+        spu_context_trace(spu_get_idle__found, ctx, spu);
         spu_init_channels(spu);
         return spu;
 }
@@ -587,6 +591,8 @@ static struct spu *find_victim(struct spu_context *ctx)
         struct spu *spu;
         int node, n;
 
+        spu_context_nospu_trace(spu_find_vitim__enter, ctx);
+
         /*
          * Look for a possible preemption candidate on the local node first.
          * If there is no candidate look at the other nodes.  This isn't
@@ -640,6 +646,8 @@ static struct spu *find_victim(struct spu_context *ctx)
                                 goto restart;
                         }
 
+                        spu_context_trace(__spu_deactivate__unload, ctx, spu);
+
                         mutex_lock(&cbe_spu_info[node].list_mutex);
                         cbe_spu_info[node].nr_active--;
                         spu_unbind_context(spu, victim);
@@ -822,6 +830,7 @@ static int __spu_deactivate(struct spu_context *ctx, int force, int max_prio)
  */
 void spu_deactivate(struct spu_context *ctx)
 {
+        spu_context_nospu_trace(spu_deactivate__enter, ctx);
         __spu_deactivate(ctx, 1, MAX_PRIO);
 }
 
@@ -835,6 +844,7 @@ void spu_deactivate(struct spu_context *ctx)
  */
 void spu_yield(struct spu_context *ctx)
 {
+        spu_context_nospu_trace(spu_yield__enter, ctx);
         if (!(ctx->flags & SPU_CREATE_NOSCHED)) {
                 mutex_lock(&ctx->state_mutex);
                 __spu_deactivate(ctx, 0, MAX_PRIO);
@@ -864,11 +874,15 @@ static noinline void spusched_tick(struct spu_context *ctx)
                 goto out;
 
         spu = ctx->spu;
+
+        spu_context_trace(spusched_tick__preempt, ctx, spu);
+
         new = grab_runnable_context(ctx->prio + 1, spu->node);
         if (new) {
                 spu_unschedule(spu, ctx);
                 spu_add_to_rq(ctx);
         } else {
+                spu_context_nospu_trace(spusched_tick__newslice, ctx);
                 ctx->time_slice++;
         }
 out:
diff --git a/arch/powerpc/platforms/cell/spufs/spufs.h b/arch/powerpc/platforms/cell/spufs/spufs.h
index 0e114038ea6f..795a1b52538b 100644
--- a/arch/powerpc/platforms/cell/spufs/spufs.h
+++ b/arch/powerpc/platforms/cell/spufs/spufs.h
@@ -325,4 +325,9 @@ extern void spu_free_lscsa(struct spu_state *csa);
 extern void spuctx_switch_state(struct spu_context *ctx,
                 enum spu_utilization_state new_state);
 
+#define spu_context_trace(name, ctx, spu) \
+        trace_mark(name, "%p %p", ctx, spu);
+#define spu_context_nospu_trace(name, ctx) \
+        trace_mark(name, "%p", ctx);
+
 #endif
diff --git a/arch/powerpc/platforms/cell/spufs/sputrace.c b/arch/powerpc/platforms/cell/spufs/sputrace.c
new file mode 100644
index 000000000000..2b1953f6f12e
--- /dev/null
+++ b/arch/powerpc/platforms/cell/spufs/sputrace.c
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2007 IBM Deutschland Entwicklung GmbH
+ *      Released under GPL v2.
+ *
+ * Partially based on net/ipv4/tcp_probe.c.
+ *
+ * Simple tracing facility for spu contexts.
+ */
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/marker.h>
+#include <linux/proc_fs.h>
+#include <linux/wait.h>
+#include <asm/atomic.h>
+#include <asm/uaccess.h>
+#include "spufs.h"
+
+struct spu_probe {
+        const char *name;
+        const char *format;
+        marker_probe_func *probe_func;
+};
+
+struct sputrace {
+        ktime_t tstamp;
+        int owner_tid; /* owner */
+        int curr_tid;
+        const char *name;
+        int number;
+};
+
+static int bufsize __read_mostly = 16384;
+MODULE_PARM_DESC(bufsize, "Log buffer size (number of records)");
+module_param(bufsize, int, 0);
+
+
+static DEFINE_SPINLOCK(sputrace_lock);
+static DECLARE_WAIT_QUEUE_HEAD(sputrace_wait);
+static ktime_t sputrace_start;
+static unsigned long sputrace_head, sputrace_tail;
+static struct sputrace *sputrace_log;
+
+static int sputrace_used(void)
+{
+        return (sputrace_head - sputrace_tail) % bufsize;
+}
+
+static inline int sputrace_avail(void)
+{
+        return bufsize - sputrace_used();
+}
+
+static int sputrace_sprint(char *tbuf, int n)
+{
+        const struct sputrace *t = sputrace_log + sputrace_tail % bufsize;
+        struct timespec tv =
+                ktime_to_timespec(ktime_sub(t->tstamp, sputrace_start));
+
+        return snprintf(tbuf, n,
+                "[%lu.%09lu] %d: %s (thread = %d, spu = %d)\n",
+                (unsigned long) tv.tv_sec,
+                (unsigned long) tv.tv_nsec,
+                t->owner_tid,
+                t->name,
+                t->curr_tid,
+                t->number);
+}
+
+static ssize_t sputrace_read(struct file *file, char __user *buf,
+                size_t len, loff_t *ppos)
+{
+        int error = 0, cnt = 0;
+
+        if (!buf || len < 0)
+                return -EINVAL;
+
+        while (cnt < len) {
+                char tbuf[128];
+                int width;
+
+                error = wait_event_interruptible(sputrace_wait,
+                                                 sputrace_used() > 0);
+                if (error)
+                        break;
+
+                spin_lock(&sputrace_lock);
+                if (sputrace_head == sputrace_tail) {
+                        spin_unlock(&sputrace_lock);
+                        continue;
+                }
+
+                width = sputrace_sprint(tbuf, sizeof(tbuf));
+                if (width < len)
+                        sputrace_tail = (sputrace_tail + 1) % bufsize;
+                spin_unlock(&sputrace_lock);
+
+                if (width >= len)
+                        break;
+
+                error = copy_to_user(buf + cnt, tbuf, width);
+                if (error)
+                        break;
+                cnt += width;
+        }
+
+        return cnt == 0 ? error : cnt;
+}
+
+static int sputrace_open(struct inode *inode, struct file *file)
+{
+        spin_lock(&sputrace_lock);
+        sputrace_head = sputrace_tail = 0;
+        sputrace_start = ktime_get();
+        spin_unlock(&sputrace_lock);
+
+        return 0;
+}
+
+static const struct file_operations sputrace_fops = {
+        .owner  = THIS_MODULE,
+        .open   = sputrace_open,
+        .read   = sputrace_read,
+};
+
+static void sputrace_log_item(const char *name, struct spu_context *ctx,
+                struct spu *spu)
+{
+        spin_lock(&sputrace_lock);
+        if (sputrace_avail() > 1) {
+                struct sputrace *t = sputrace_log + sputrace_head;
+
+                t->tstamp = ktime_get();
+                t->owner_tid = ctx->tid;
+                t->name = name;
+                t->curr_tid = current->pid;
+                t->number = spu ? spu->number : -1;
+
+                sputrace_head = (sputrace_head + 1) % bufsize;
+        } else {
+                printk(KERN_WARNING
+                       "sputrace: lost samples due to full buffer.\n");
+        }
+        spin_unlock(&sputrace_lock);
+
+        wake_up(&sputrace_wait);
+}
+
+static void spu_context_event(const struct marker *mdata,
+                void *private, const char *format, ...)
+{
+        struct spu_probe *p = mdata->private;
+        va_list ap;
+        struct spu_context *ctx;
+        struct spu *spu;
+
+        va_start(ap, format);
+        ctx = va_arg(ap, struct spu_context *);
+        spu = va_arg(ap, struct spu *);
+
+        sputrace_log_item(p->name, ctx, spu);
+        va_end(ap);
+}
+
+static void spu_context_nospu_event(const struct marker *mdata,
+                void *private, const char *format, ...)
+{
+        struct spu_probe *p = mdata->private;
+        va_list ap;
+        struct spu_context *ctx;
+
+        va_start(ap, format);
+        ctx = va_arg(ap, struct spu_context *);
+
+        sputrace_log_item(p->name, ctx, NULL);
+        va_end(ap);
+}
+
+struct spu_probe spu_probes[] = {
+        { "spu_bind_context__enter", "%p %p", spu_context_event },
+        { "spu_unbind_context__enter", "%p %p", spu_context_event },
+        { "spu_get_idle__enter", "%p", spu_context_nospu_event },
+        { "spu_get_idle__found", "%p %p", spu_context_event },
+        { "spu_get_idle__not_found", "%p", spu_context_nospu_event },
+        { "spu_find_victim__enter", "%p", spu_context_nospu_event },
+        { "spusched_tick__preempt", "%p %p", spu_context_event },
+        { "spusched_tick__newslice", "%p", spu_context_nospu_event },
+        { "spu_yield__enter", "%p", spu_context_nospu_event },
+        { "spu_deactivate__enter", "%p", spu_context_nospu_event },
+        { "__spu_deactivate__unload", "%p %p", spu_context_event },
+        { "spufs_ps_nopfn__enter", "%p", spu_context_nospu_event },
+        { "spufs_ps_nopfn__sleep", "%p", spu_context_nospu_event },
+        { "spufs_ps_nopfn__wake", "%p %p", spu_context_event },
+        { "spufs_ps_nopfn__insert", "%p %p", spu_context_event },
+        { "spu_acquire_saved__enter", "%p", spu_context_nospu_event },
+        { "destroy_spu_context__enter", "%p", spu_context_nospu_event },
+};
+
+static int __init sputrace_init(void)
+{
+        struct proc_dir_entry *entry;
+        int i, error = -ENOMEM;
+
+        sputrace_log = kcalloc(sizeof(struct sputrace),
+                                bufsize, GFP_KERNEL);
+        if (!sputrace_log)
+                goto out;
+
+        entry = create_proc_entry("sputrace", S_IRUSR, NULL);
+        if (!entry)
+                goto out_free_log;
+        entry->proc_fops = &sputrace_fops;
+
+        for (i = 0; i < ARRAY_SIZE(spu_probes); i++) {
+                struct spu_probe *p = &spu_probes[i];
+
+                error = marker_probe_register(p->name, p->format,
+                                              p->probe_func, p);
+                if (error)
+                        printk(KERN_INFO "Unable to register probe %s\n",
+                                        p->name);
+
+                error = marker_arm(p->name);
+                if (error)
+                        printk(KERN_INFO "Unable to arm probe %s\n", p->name);
+        }
+
+        return 0;
+
+out_free_log:
+        kfree(sputrace_log);
+out:
+        return -ENOMEM;
+}
+
+static void __exit sputrace_exit(void)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(spu_probes); i++)
+                marker_probe_unregister(spu_probes[i].name);
+
+        remove_proc_entry("sputrace", NULL);
+        kfree(sputrace_log);
+}
+
+module_init(sputrace_init);
+module_exit(sputrace_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/arch/powerpc/platforms/embedded6xx/storcenter.c b/arch/powerpc/platforms/embedded6xx/storcenter.c
index e12e9d298716..8864e4884980 100644
--- a/arch/powerpc/platforms/embedded6xx/storcenter.c
+++ b/arch/powerpc/platforms/embedded6xx/storcenter.c
@@ -132,33 +132,18 @@ static void __init storcenter_init_IRQ(void)
 
         paddr = (phys_addr_t)of_translate_address(dnp, prop);
         mpic = mpic_alloc(dnp, paddr, MPIC_PRIMARY | MPIC_WANTS_RESET,
-                        4, 32, " EPIC     ");
+                        16, 32, " OpenPIC  ");
 
         of_node_put(dnp);
 
         BUG_ON(mpic == NULL);
 
-        /* PCI IRQs */
         /*
-         * 2.6.12 patch:
-         *         openpic_set_sources(0, 5, OpenPIC_Addr + 0x10200);
-         *         openpic_set_sources(5, 2, OpenPIC_Addr + 0x11120);
-         *         first_irq, num_irqs, __iomem first_ISR
-         *         o_ss: i, src: 0, fdf50200
-         *         o_ss: i, src: 1, fdf50220
-         *         o_ss: i, src: 2, fdf50240
-         *         o_ss: i, src: 3, fdf50260
-         *         o_ss: i, src: 4, fdf50280
-         *         o_ss: i, src: 5, fdf51120
-         *         o_ss: i, src: 6, fdf51140
+         * 16 Serial Interrupts followed by 16 Internal Interrupts.
+         * I2C is the second internal, so it is at 17, 0x11020.
          */
         mpic_assign_isu(mpic, 0, paddr + 0x10200);
-        mpic_assign_isu(mpic, 1, paddr + 0x10220);
-        mpic_assign_isu(mpic, 2, paddr + 0x10240);
-        mpic_assign_isu(mpic, 3, paddr + 0x10260);
-        mpic_assign_isu(mpic, 4, paddr + 0x10280);
-        mpic_assign_isu(mpic, 5, paddr + 0x11120);
-        mpic_assign_isu(mpic, 6, paddr + 0x11140);
+        mpic_assign_isu(mpic, 1, paddr + 0x11000);
 
         mpic_init(mpic);
 }
@@ -178,7 +163,7 @@ static int __init storcenter_probe(void)
 {
         unsigned long root = of_get_flat_dt_root();
 
-        return of_flat_dt_is_compatible(root, "storcenter");
+        return of_flat_dt_is_compatible(root, "iomega,storcenter");
 }
 
 define_machine(storcenter){
diff --git a/arch/powerpc/platforms/iseries/iommu.c b/arch/powerpc/platforms/iseries/iommu.c
index 6a0c6f6675cd..11fa3c772ed5 100644
--- a/arch/powerpc/platforms/iseries/iommu.c
+++ b/arch/powerpc/platforms/iseries/iommu.c
@@ -199,7 +199,7 @@ static struct iommu_table vio_iommu_table;
 
 void *iseries_hv_alloc(size_t size, dma_addr_t *dma_handle, gfp_t flag)
 {
-        return iommu_alloc_coherent(&vio_iommu_table, size, dma_handle,
+        return iommu_alloc_coherent(NULL, &vio_iommu_table, size, dma_handle,
                                 DMA_32BIT_MASK, flag, -1);
 }
 EXPORT_SYMBOL_GPL(iseries_hv_alloc);
@@ -213,7 +213,7 @@ EXPORT_SYMBOL_GPL(iseries_hv_free);
 dma_addr_t iseries_hv_map(void *vaddr, size_t size,
                         enum dma_data_direction direction)
 {
-        return iommu_map_single(&vio_iommu_table, vaddr, size,
+        return iommu_map_single(NULL, &vio_iommu_table, vaddr, size,
                                 DMA_32BIT_MASK, direction);
 }
 
diff --git a/arch/powerpc/platforms/pasemi/iommu.c b/arch/powerpc/platforms/pasemi/iommu.c
index 9916a0f3e431..5803f11c77fc 100644
--- a/arch/powerpc/platforms/pasemi/iommu.c
+++ b/arch/powerpc/platforms/pasemi/iommu.c
@@ -182,8 +182,10 @@ static void pci_dma_dev_setup_pasemi(struct pci_dev *dev)
          * CONFIG_PPC_PASEMI_IOMMU_DMA_FORCE at build time.
          */
         if (dev->vendor == 0x1959 && dev->device == 0xa007 &&
-            !firmware_has_feature(FW_FEATURE_LPAR))
+            !firmware_has_feature(FW_FEATURE_LPAR)) {
                 dev->dev.archdata.dma_ops = &dma_direct_ops;
+                return;
+        }
 #endif
 
         dev->dev.archdata.dma_data = &iommu_table_iobmap;
diff --git a/arch/powerpc/platforms/pseries/reconfig.c b/arch/powerpc/platforms/pseries/reconfig.c
index c02f8742c54d..2800fced8c7c 100644
--- a/arch/powerpc/platforms/pseries/reconfig.c
+++ b/arch/powerpc/platforms/pseries/reconfig.c
@@ -167,6 +167,7 @@ static int pSeries_reconfig_remove_node(struct device_node *np)
 
         if ((child = of_get_next_child(np, NULL))) {
                 of_node_put(child);
+                of_node_put(parent);
                 return -EBUSY;
         }
 
diff --git a/arch/powerpc/sysdev/fsl_soc.c b/arch/powerpc/sysdev/fsl_soc.c
index e48b20e934ca..2c5388ce902a 100644
--- a/arch/powerpc/sysdev/fsl_soc.c
+++ b/arch/powerpc/sysdev/fsl_soc.c
@@ -1342,7 +1342,7 @@ static int __init of_fsl_spi_probe(char *type, char *compatible, u32 sysclk,
                 if (ret)
                         goto unreg;
 
-                ret = platform_device_register(pdev);
+                ret = platform_device_add(pdev);
                 if (ret)
                         goto unreg;
 
diff --git a/arch/powerpc/sysdev/mpc8xx_pic.c b/arch/powerpc/sysdev/mpc8xx_pic.c
index 0e74a4bd9827..5d2d5522ef41 100644
--- a/arch/powerpc/sysdev/mpc8xx_pic.c
+++ b/arch/powerpc/sysdev/mpc8xx_pic.c
@@ -174,15 +174,19 @@ int mpc8xx_pic_init(void)
                 goto out;
 
         siu_reg = ioremap(res.start, res.end - res.start + 1);
-        if (siu_reg == NULL)
-                return -EINVAL;
+        if (siu_reg == NULL) {
+                ret = -EINVAL;
+                goto out;
+        }
 
-        mpc8xx_pic_host = irq_alloc_host(of_node_get(np), IRQ_HOST_MAP_LINEAR,
+        mpc8xx_pic_host = irq_alloc_host(np, IRQ_HOST_MAP_LINEAR,
                                          64, &mpc8xx_pic_host_ops, 64);
         if (mpc8xx_pic_host == NULL) {
                 printk(KERN_ERR "MPC8xx PIC: failed to allocate irq host!\n");
                 ret = -ENOMEM;
+                goto out;
         }
+        return 0;
 
 out:
         of_node_put(np);
diff --git a/arch/powerpc/sysdev/qe_lib/qe.c b/arch/powerpc/sysdev/qe_lib/qe.c
index 5ef844da9355..6efbd5e5bb1b 100644
--- a/arch/powerpc/sysdev/qe_lib/qe.c
+++ b/arch/powerpc/sysdev/qe_lib/qe.c
@@ -66,7 +66,7 @@ phys_addr_t get_qe_base(void)
 {
         struct device_node *qe;
         unsigned int size;
-        const void *prop;
+        const u32 *prop;
 
         if (qebase != -1)
                 return qebase;
@@ -79,7 +79,8 @@ phys_addr_t get_qe_base(void)
         }
 
         prop = of_get_property(qe, "reg", &size);
-        qebase = of_translate_address(qe, prop);
+        if (prop && size >= sizeof(*prop))
+                qebase = of_translate_address(qe, prop);
         of_node_put(qe);
 
         return qebase;
@@ -172,10 +173,9 @@ unsigned int get_brg_clk(void)
         }
 
         prop = of_get_property(qe, "brg-frequency", &size);
-        if (!prop || size != sizeof(*prop))
-                return brg_clk;
+        if (prop && size == sizeof(*prop))
+                brg_clk = *prop;
 
-        brg_clk = *prop;
         of_node_put(qe);
 
         return brg_clk;
diff --git a/arch/ppc/Kconfig b/arch/ppc/Kconfig
index db5934cdafb3..531156f8919c 100644
--- a/arch/ppc/Kconfig
+++ b/arch/ppc/Kconfig
@@ -42,6 +42,8 @@ config GENERIC_CALIBRATE_DELAY
 config PPC
         bool
         default y
+        select HAVE_OPROFILE
+        select HAVE_KPROBES
 
 config PPC32
         bool
@@ -1256,8 +1258,6 @@ endmenu
 
 source "lib/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/ppc/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/ppc/mm/pgtable.c b/arch/ppc/mm/pgtable.c
index fadacfd18806..409fcaa4994a 100644
--- a/arch/ppc/mm/pgtable.c
+++ b/arch/ppc/mm/pgtable.c
@@ -74,7 +74,7 @@ pgd_t *pgd_alloc(struct mm_struct *mm)
         return ret;
 }
 
-void pgd_free(pgd_t *pgd)
+void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 {
         free_pages((unsigned long)pgd, PGDIR_ORDER);
 }
@@ -111,7 +111,7 @@ struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
         return ptepage;
 }
 
-void pte_free_kernel(pte_t *pte)
+void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
 {
 #ifdef CONFIG_SMP
         hash_page_sync();
@@ -119,7 +119,7 @@ void pte_free_kernel(pte_t *pte)
         free_page((unsigned long)pte);
 }
 
-void pte_free(struct page *ptepage)
+void pte_free(struct mm_struct *mm, struct page *ptepage)
 {
 #ifdef CONFIG_SMP
         hash_page_sync();
diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig
index 6ef54d27fc00..92a4f7b4323a 100644
--- a/arch/s390/Kconfig
+++ b/arch/s390/Kconfig
@@ -16,6 +16,9 @@ config LOCKDEP_SUPPORT
 config STACKTRACE_SUPPORT
         def_bool y
 
+config HAVE_LATENCYTOP_SUPPORT
+        def_bool y
+
 config RWSEM_GENERIC_SPINLOCK
         bool
 
@@ -47,10 +50,17 @@ config NO_IOMEM
 config NO_DMA
         def_bool y
 
+config GENERIC_LOCKBREAK
+        bool
+        default y
+        depends on SMP && PREEMPT
+
 mainmenu "Linux Kernel Configuration"
 
 config S390
         def_bool y
+        select HAVE_OPROFILE
+        select HAVE_KPROBES
 
 source "init/Kconfig"
 
@@ -81,8 +91,8 @@ config SMP
           singleprocessor machines. On a singleprocessor machine, the kernel
           will run faster if you say N here.
 
-          See also the <file:Documentation/smp.txt> and the SMP-HOWTO
-          available at <http://www.tldp.org/docs.html#howto>.
+          See also the SMP-HOWTO available at
+          <http://www.tldp.org/docs.html#howto>.
 
           Even if you don't know what to do here, say Y.
 
@@ -526,8 +536,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/s390/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/s390/Kconfig.debug b/arch/s390/Kconfig.debug
index 2283933a9a93..4599fa06bd82 100644
--- a/arch/s390/Kconfig.debug
+++ b/arch/s390/Kconfig.debug
@@ -6,4 +6,12 @@ config TRACE_IRQFLAGS_SUPPORT
 
 source "lib/Kconfig.debug"
 
+config DEBUG_PAGEALLOC
+        bool "Debug page memory allocations"
+        depends on DEBUG_KERNEL
+        help
+          Unmap pages from the kernel linear mapping after free_pages().
+          This results in a slowdown, but helps to find certain types of
+          memory corruptions.
+
 endmenu
diff --git a/arch/s390/kernel/compat_wrapper.S b/arch/s390/kernel/compat_wrapper.S
index 6ee1bedbd1bf..062c3d4c0394 100644
--- a/arch/s390/kernel/compat_wrapper.S
+++ b/arch/s390/kernel/compat_wrapper.S
@@ -1698,14 +1698,6 @@ compat_sys_signalfd_wrapper:
         llgfr   %r4,%r4                 # compat_size_t
         jg      compat_sys_signalfd
 
-        .globl  compat_sys_timerfd_wrapper
-compat_sys_timerfd_wrapper:
-        lgfr    %r2,%r2                 # int
-        lgfr    %r3,%r3                 # int
-        lgfr    %r4,%r4                 # int
-        llgtr   %r5,%r5                 # struct compat_itimerspec *
-        jg      compat_sys_timerfd
-
         .globl  sys_eventfd_wrapper
 sys_eventfd_wrapper:
         llgfr   %r2,%r2                 # unsigned int
diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S
index 1a6dac8df6fb..6766e37fe8ea 100644
--- a/arch/s390/kernel/entry.S
+++ b/arch/s390/kernel/entry.S
@@ -11,6 +11,7 @@
 
 #include <linux/sys.h>
 #include <linux/linkage.h>
+#include <linux/init.h>
 #include <asm/cache.h>
 #include <asm/lowcore.h>
 #include <asm/errno.h>
@@ -830,9 +831,7 @@ mcck_return:
  * Restart interruption handler, kick starter for additional CPUs
  */
 #ifdef CONFIG_SMP
-#ifndef CONFIG_HOTPLUG_CPU
-        .section .init.text,"ax"
-#endif
+        __CPUINIT
         .globl restart_int_handler
 restart_int_handler:
         l       %r15,__LC_SAVE_AREA+60  # load ksp
@@ -845,9 +844,7 @@ restart_int_handler:
         br      %r14                    # branch to start_secondary
 restart_addr:
         .long   start_secondary
-#ifndef CONFIG_HOTPLUG_CPU
         .previous
-#endif
 #else
 /*
  * If we do not run with SMP enabled, let the new CPU crash ...
diff --git a/arch/s390/kernel/entry64.S b/arch/s390/kernel/entry64.S
index a3e47b893f07..efde6e178f6c 100644
--- a/arch/s390/kernel/entry64.S
+++ b/arch/s390/kernel/entry64.S
@@ -11,6 +11,7 @@
 
 #include <linux/sys.h>
 #include <linux/linkage.h>
+#include <linux/init.h>
 #include <asm/cache.h>
 #include <asm/lowcore.h>
 #include <asm/errno.h>
@@ -801,9 +802,7 @@ mcck_return:
  * Restart interruption handler, kick starter for additional CPUs
  */
 #ifdef CONFIG_SMP
-#ifndef CONFIG_HOTPLUG_CPU
-        .section .init.text,"ax"
-#endif
+        __CPUINIT
         .globl restart_int_handler
 restart_int_handler:
         lg      %r15,__LC_SAVE_AREA+120 # load ksp
@@ -814,9 +813,7 @@ restart_int_handler:
         lmg     %r6,%r15,__SF_GPRS(%r15) # load registers from clone
         stosm   __SF_EMPTY(%r15),0x04   # now we can turn dat on
         jg      start_secondary
-#ifndef CONFIG_HOTPLUG_CPU
         .previous
-#endif
 #else
 /*
  * If we do not run with SMP enabled, let the new CPU crash ...
diff --git a/arch/s390/kernel/ipl.c b/arch/s390/kernel/ipl.c
index db28cca81fef..60acdc266db1 100644
--- a/arch/s390/kernel/ipl.c
+++ b/arch/s390/kernel/ipl.c
@@ -439,7 +439,7 @@ static void ipl_run(struct shutdown_trigger *trigger)
                 reipl_ccw_dev(&ipl_info.data.ccw.dev_id);
 }
 
-static int ipl_init(void)
+static int __init ipl_init(void)
 {
         int rc;
 
@@ -471,8 +471,11 @@ out:
         return 0;
 }
 
-static struct shutdown_action ipl_action = {SHUTDOWN_ACTION_IPL_STR, ipl_run,
-                                            ipl_init};
+static struct shutdown_action __refdata ipl_action = {
+        .name   = SHUTDOWN_ACTION_IPL_STR,
+        .fn     = ipl_run,
+        .init   = ipl_init,
+};
 
 /*
  * reipl shutdown action: Reboot Linux on shutdown.
@@ -792,7 +795,7 @@ static int __init reipl_fcp_init(void)
         return 0;
 }
 
-static int reipl_init(void)
+static int __init reipl_init(void)
 {
         int rc;
 
@@ -819,8 +822,11 @@ static int reipl_init(void)
         return 0;
 }
 
-static struct shutdown_action reipl_action = {SHUTDOWN_ACTION_REIPL_STR,
-                                              reipl_run, reipl_init};
+static struct shutdown_action __refdata reipl_action = {
+        .name   = SHUTDOWN_ACTION_REIPL_STR,
+        .fn     = reipl_run,
+        .init   = reipl_init,
+};
 
 /*
  * dump shutdown action: Dump Linux on shutdown.
@@ -998,7 +1004,7 @@ static int __init dump_fcp_init(void)
         return 0;
 }
 
-static int dump_init(void)
+static int __init dump_init(void)
 {
         int rc;
 
@@ -1020,8 +1026,11 @@ static int dump_init(void)
         return 0;
 }
 
-static struct shutdown_action dump_action = {SHUTDOWN_ACTION_DUMP_STR,
-                                             dump_run, dump_init};
+static struct shutdown_action __refdata dump_action = {
+        .name   = SHUTDOWN_ACTION_DUMP_STR,
+        .fn     = dump_run,
+        .init   = dump_init,
+};
 
 /*
  * vmcmd shutdown action: Trigger vm command on shutdown.
diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c
index 766c783bd7a7..29ae165d1749 100644
--- a/arch/s390/kernel/setup.c
+++ b/arch/s390/kernel/setup.c
@@ -77,7 +77,7 @@ unsigned long machine_flags = 0;
 unsigned long elf_hwcap = 0;
 char elf_platform[ELF_PLATFORM_SIZE];
 
-struct mem_chunk __initdata memory_chunk[MEMORY_CHUNKS];
+struct mem_chunk __meminitdata memory_chunk[MEMORY_CHUNKS];
 volatile int __cpu_logical_map[NR_CPUS]; /* logical cpu to cpu address */
 static unsigned long __initdata memory_end;
 
@@ -145,7 +145,7 @@ __setup("condev=", condev_setup);
 
 static int __init conmode_setup(char *str)
 {
-#if defined(CONFIG_SCLP_CONSOLE)
+#if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
         if (strncmp(str, "hwc", 4) == 0 || strncmp(str, "sclp", 5) == 0)
                 SET_CONSOLE_SCLP;
 #endif
@@ -183,7 +183,7 @@ static void __init conmode_default(void)
                  */
                 cpcmd("TERM CONMODE 3215", NULL, 0, NULL);
                 if (ptr == NULL) {
-#if defined(CONFIG_SCLP_CONSOLE)
+#if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
                         SET_CONSOLE_SCLP;
 #endif
                         return;
@@ -193,7 +193,7 @@ static void __init conmode_default(void)
                         SET_CONSOLE_3270;
 #elif defined(CONFIG_TN3215_CONSOLE)
                         SET_CONSOLE_3215;
-#elif defined(CONFIG_SCLP_CONSOLE)
+#elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
                         SET_CONSOLE_SCLP;
 #endif
                 } else if (strncmp(ptr + 8, "3215", 4) == 0) {
@@ -201,7 +201,7 @@ static void __init conmode_default(void)
                         SET_CONSOLE_3215;
 #elif defined(CONFIG_TN3270_CONSOLE)
                         SET_CONSOLE_3270;
-#elif defined(CONFIG_SCLP_CONSOLE)
+#elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
                         SET_CONSOLE_SCLP;
 #endif
                 }
@@ -212,7 +212,7 @@ static void __init conmode_default(void)
                 SET_CONSOLE_3270;
 #endif
         } else {
-#if defined(CONFIG_SCLP_CONSOLE)
+#if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
                 SET_CONSOLE_SCLP;
 #endif
         }
@@ -528,7 +528,7 @@ static void __init setup_memory_end(void)
         memory_size = 0;
         memory_end &= PAGE_MASK;
 
-        max_mem = memory_end ? min(VMALLOC_START, memory_end) : VMALLOC_START;
+        max_mem = memory_end ? min(VMEM_MAX_PHYS, memory_end) : VMEM_MAX_PHYS;
         memory_end = min(max_mem, memory_end);
 
         /*
diff --git a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c
index aa37fa154512..85060659fb12 100644
--- a/arch/s390/kernel/smp.c
+++ b/arch/s390/kernel/smp.c
@@ -225,12 +225,11 @@ EXPORT_SYMBOL(smp_call_function_single);
  * You must not call this function with disabled interrupts or from a
  * hardware interrupt handler or from a bottom half handler.
  */
-int
-smp_call_function_mask(cpumask_t mask,
-                        void (*func)(void *), void *info,
-                        int wait)
+int smp_call_function_mask(cpumask_t mask, void (*func)(void *), void *info,
+                           int wait)
 {
         preempt_disable();
+        cpu_clear(smp_processor_id(), mask);
         __smp_call_function_map(func, info, 0, wait, mask);
         preempt_enable();
         return 0;
@@ -1008,7 +1007,7 @@ static struct notifier_block __cpuinitdata smp_cpu_nb = {
         .notifier_call = smp_cpu_notify,
 };
 
-static int smp_add_present_cpu(int cpu)
+static int __devinit smp_add_present_cpu(int cpu)
 {
         struct cpu *c = &per_cpu(cpu_devices, cpu);
         struct sys_device *s = &c->sysdev;
@@ -1036,8 +1035,8 @@ out:
 }
 
 #ifdef CONFIG_HOTPLUG_CPU
-static ssize_t rescan_store(struct sys_device *dev, const char *buf,
-                            size_t count)
+static ssize_t __ref rescan_store(struct sys_device *dev,
+                                  const char *buf, size_t count)
 {
         cpumask_t newcpus;
         int cpu;
diff --git a/arch/s390/kernel/stacktrace.c b/arch/s390/kernel/stacktrace.c
index da6924729964..85e46a5d0e08 100644
--- a/arch/s390/kernel/stacktrace.c
+++ b/arch/s390/kernel/stacktrace.c
@@ -14,7 +14,8 @@
 static unsigned long save_context_stack(struct stack_trace *trace,
                                         unsigned long sp,
                                         unsigned long low,
-                                        unsigned long high)
+                                        unsigned long high,
+                                        int savesched)
 {
         struct stack_frame *sf;
         struct pt_regs *regs;
@@ -47,10 +48,12 @@ static unsigned long save_context_stack(struct stack_trace *trace,
                         return sp;
                 regs = (struct pt_regs *)sp;
                 addr = regs->psw.addr & PSW_ADDR_INSN;
-                if (!trace->skip)
-                        trace->entries[trace->nr_entries++] = addr;
-                else
-                        trace->skip--;
+                if (savesched || !in_sched_functions(addr)) {
+                        if (!trace->skip)
+                                trace->entries[trace->nr_entries++] = addr;
+                        else
+                                trace->skip--;
+                }
                 if (trace->nr_entries >= trace->max_entries)
                         return sp;
                 low = sp;
@@ -66,15 +69,27 @@ void save_stack_trace(struct stack_trace *trace)
         orig_sp = sp & PSW_ADDR_INSN;
         new_sp = save_context_stack(trace, orig_sp,
                                     S390_lowcore.panic_stack - PAGE_SIZE,
-                                    S390_lowcore.panic_stack);
+                                    S390_lowcore.panic_stack, 1);
         if (new_sp != orig_sp)
                 return;
         new_sp = save_context_stack(trace, new_sp,
                                     S390_lowcore.async_stack - ASYNC_SIZE,
-                                    S390_lowcore.async_stack);
+                                    S390_lowcore.async_stack, 1);
         if (new_sp != orig_sp)
                 return;
         save_context_stack(trace, new_sp,
                            S390_lowcore.thread_info,
-                           S390_lowcore.thread_info + THREAD_SIZE);
+                           S390_lowcore.thread_info + THREAD_SIZE, 1);
+}
+
+void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
+{
+        unsigned long sp, low, high;
+
+        sp = tsk->thread.ksp & PSW_ADDR_INSN;
+        low = (unsigned long) task_stack_page(tsk);
+        high = (unsigned long) task_pt_regs(tsk);
+        save_context_stack(trace, sp, low, high, 0);
+        if (trace->nr_entries < trace->max_entries)
+                trace->entries[trace->nr_entries++] = ULONG_MAX;
 }
diff --git a/arch/s390/kernel/syscalls.S b/arch/s390/kernel/syscalls.S
index 9e26ed9fe4e7..25eac7802fc4 100644
--- a/arch/s390/kernel/syscalls.S
+++ b/arch/s390/kernel/syscalls.S
@@ -325,5 +325,5 @@ SYSCALL(sys_utimes,sys_utimes,compat_sys_utimes_wrapper)
 SYSCALL(s390_fallocate,sys_fallocate,sys_fallocate_wrapper)
 SYSCALL(sys_utimensat,sys_utimensat,compat_sys_utimensat_wrapper)       /* 315 */
 SYSCALL(sys_signalfd,sys_signalfd,compat_sys_signalfd_wrapper)
-SYSCALL(sys_timerfd,sys_timerfd,compat_sys_timerfd_wrapper)
+NI_SYSCALL                                              /* 317 old sys_timer_fd */
 SYSCALL(sys_eventfd,sys_eventfd,sys_eventfd_wrapper)
diff --git a/arch/s390/kernel/traps.c b/arch/s390/kernel/traps.c
index 52b8342c6bf2..1a2fdb6991df 100644
--- a/arch/s390/kernel/traps.c
+++ b/arch/s390/kernel/traps.c
@@ -271,7 +271,10 @@ void die(const char * str, struct pt_regs * regs, long err)
         printk("PREEMPT ");
 #endif
 #ifdef CONFIG_SMP
-        printk("SMP");
+        printk("SMP ");
+#endif
+#ifdef CONFIG_DEBUG_PAGEALLOC
+        printk("DEBUG_PAGEALLOC");
 #endif
         printk("\n");
         notify_die(DIE_OOPS, str, regs, err, current->thread.trap_no, SIGSEGV);
diff --git a/arch/s390/kernel/vmlinux.lds.S b/arch/s390/kernel/vmlinux.lds.S
index 7d43c3cd3ef3..b4607155e8d0 100644
--- a/arch/s390/kernel/vmlinux.lds.S
+++ b/arch/s390/kernel/vmlinux.lds.S
@@ -35,7 +35,7 @@ SECTIONS
                 KPROBES_TEXT
                 *(.fixup)
                 *(.gnu.warning)
-        } = 0x0700
+        } :text = 0x0700
 
         _etext = .;             /* End of text section */
 
diff --git a/arch/s390/mm/init.c b/arch/s390/mm/init.c
index b234bb4a6da7..983ec6ec0e7c 100644
--- a/arch/s390/mm/init.c
+++ b/arch/s390/mm/init.c
@@ -167,6 +167,33 @@ void __init mem_init(void)
                PFN_ALIGN((unsigned long)&_eshared) - 1);
 }
 
+#ifdef CONFIG_DEBUG_PAGEALLOC
+void kernel_map_pages(struct page *page, int numpages, int enable)
+{
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
+        unsigned long address;
+        int i;
+
+        for (i = 0; i < numpages; i++) {
+                address = page_to_phys(page + i);
+                pgd = pgd_offset_k(address);
+                pud = pud_offset(pgd, address);
+                pmd = pmd_offset(pud, address);
+                pte = pte_offset_kernel(pmd, address);
+                if (!enable) {
+                        ptep_invalidate(address, pte);
+                        continue;
+                }
+                *pte = mk_pte_phys(address, __pgprot(_PAGE_TYPE_RW));
+                /* Flush cpu write queue. */
+                mb();
+        }
+}
+#endif
+
 void free_initmem(void)
 {
         unsigned long addr;
diff --git a/arch/s390/mm/vmem.c b/arch/s390/mm/vmem.c
index 79d13a166a3d..7c1287ccf788 100644
--- a/arch/s390/mm/vmem.c
+++ b/arch/s390/mm/vmem.c
@@ -62,7 +62,7 @@ void __meminit memmap_init(unsigned long size, int nid, unsigned long zone,
         }
 }
 
-static void __init_refok *vmem_alloc_pages(unsigned int order)
+static void __ref *vmem_alloc_pages(unsigned int order)
 {
         if (slab_is_available())
                 return (void *)__get_free_pages(GFP_KERNEL, order);
@@ -250,7 +250,7 @@ static int insert_memory_segment(struct memory_segment *seg)
 {
         struct memory_segment *tmp;
 
-        if (seg->start + seg->size >= VMALLOC_START ||
+        if (seg->start + seg->size >= VMEM_MAX_PHYS ||
             seg->start + seg->size < seg->start)
                 return -ERANGE;
 
@@ -360,7 +360,6 @@ void __init vmem_map_init(void)
 {
         int i;
 
-        BUILD_BUG_ON((unsigned long)VMEM_MAP + VMEM_MAP_SIZE > VMEM_MAP_MAX);
         NODE_DATA(0)->node_mem_map = VMEM_MAP;
         for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++)
                 vmem_add_mem(memory_chunk[i].addr, memory_chunk[i].size);
diff --git a/arch/sh/Kconfig b/arch/sh/Kconfig
index 1cd9c8fd927d..1c3a90835c7e 100644
--- a/arch/sh/Kconfig
+++ b/arch/sh/Kconfig
@@ -8,6 +8,7 @@ mainmenu "Linux/SuperH Kernel Configuration"
 config SUPERH
         def_bool y
         select EMBEDDED
+        select HAVE_OPROFILE
         help
           The SuperH is a RISC processor targeted for use in embedded systems
           and consumer electronics; it was also used in the Sega Dreamcast
@@ -672,9 +673,8 @@ config SMP
           People using multiprocessor machines who say Y here should also say
           Y to "Enhanced Real Time Clock Support", below.
 
-          See also the <file:Documentation/smp.txt>,
-          <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO available
-          at <http://www.tldp.org/docs.html#howto>.
+          See also <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO
+          available at <http://www.tldp.org/docs.html#howto>.
 
           If you don't know what to do here, say N.
 
@@ -882,6 +882,10 @@ endmenu
 menu "Power management options (EXPERIMENTAL)"
 depends on EXPERIMENTAL && SYS_SUPPORTS_PM
 
+config ARCH_SUSPEND_POSSIBLE
+        def_bool y
+        depends on !SMP
+
 source kernel/power/Kconfig
 
 endmenu
@@ -892,8 +896,6 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/sh/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/sh/drivers/pci/Kconfig b/arch/sh/drivers/pci/Kconfig
index fbc6f2c8649f..7e816ededed7 100644
--- a/arch/sh/drivers/pci/Kconfig
+++ b/arch/sh/drivers/pci/Kconfig
@@ -6,11 +6,6 @@ config PCI
           bus system, i.e. the way the CPU talks to the other stuff inside
           your box. If you have PCI, say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 config SH_PCIDMA_NONCOHERENT
         bool "Cache and PCI noncoherent"
         depends on PCI
diff --git a/arch/sh/kernel/syscalls_32.S b/arch/sh/kernel/syscalls_32.S
index 10bec45415ba..719e127a7c05 100644
--- a/arch/sh/kernel/syscalls_32.S
+++ b/arch/sh/kernel/syscalls_32.S
@@ -338,6 +338,6 @@ ENTRY(sys_call_table)
         .long sys_epoll_pwait
         .long sys_utimensat             /* 320 */
         .long sys_signalfd
-        .long sys_timerfd
+        .long sys_ni_syscall
         .long sys_eventfd
         .long sys_fallocate
diff --git a/arch/sh/kernel/syscalls_64.S b/arch/sh/kernel/syscalls_64.S
index 98a93efe3691..12c7340356ae 100644
--- a/arch/sh/kernel/syscalls_64.S
+++ b/arch/sh/kernel/syscalls_64.S
@@ -376,6 +376,6 @@ sys_call_table:
         .long sys_epoll_pwait
         .long sys_utimensat
         .long sys_signalfd
-        .long sys_timerfd               /* 350 */
+        .long sys_ni_syscall            /* 350 */
         .long sys_eventfd
         .long sys_fallocate
diff --git a/arch/sparc/Kconfig b/arch/sparc/Kconfig
index 527adc808ad6..99f8971716d2 100644
--- a/arch/sparc/Kconfig
+++ b/arch/sparc/Kconfig
@@ -48,9 +48,8 @@ config SMP
           Y to "Enhanced Real Time Clock Support", below. The "Advanced Power
           Management" code will be disabled if you say Y here.
 
-          See also the <file:Documentation/smp.txt>,
-          <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO available at
-          <http://www.tldp.org/docs.html#howto>.
+          See also <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO
+          available at <http://www.tldp.org/docs.html#howto>.
 
           If you don't know what to do here, say N.
 
@@ -63,6 +62,7 @@ config NR_CPUS
 config SPARC
         bool
         default y
+        select HAVE_OPROFILE
 
 # Identify this as a Sparc32 build
 config SPARC32
@@ -320,8 +320,6 @@ endmenu
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/sparc/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
index 97aa50d1e4ae..ad0ede24ca1d 100644
--- a/arch/sparc/kernel/ioport.c
+++ b/arch/sparc/kernel/ioport.c
@@ -305,7 +305,7 @@ void *sbus_alloc_consistent(struct sbus_dev *sdev, long len, u32 *dma_addrp)
         struct resource *res;
         int order;
 
-        /* XXX why are some lenghts signed, others unsigned? */
+        /* XXX why are some lengths signed, others unsigned? */
         if (len <= 0) {
                 return NULL;
         }
@@ -393,7 +393,7 @@ void sbus_free_consistent(struct sbus_dev *sdev, long n, void *p, u32 ba)
  */
 dma_addr_t sbus_map_single(struct sbus_dev *sdev, void *va, size_t len, int direction)
 {
-        /* XXX why are some lenghts signed, others unsigned? */
+        /* XXX why are some lengths signed, others unsigned? */
         if (len <= 0) {
                 return 0;
         }
diff --git a/arch/sparc/kernel/systbls.S b/arch/sparc/kernel/systbls.S
index 55722840859c..ee010f4532a0 100644
--- a/arch/sparc/kernel/systbls.S
+++ b/arch/sparc/kernel/systbls.S
@@ -79,7 +79,7 @@ sys_call_table:
 /*295*/ .long sys_fchmodat, sys_faccessat, sys_pselect6, sys_ppoll, sys_unshare
 /*300*/ .long sys_set_robust_list, sys_get_robust_list, sys_migrate_pages, sys_mbind, sys_get_mempolicy
 /*305*/ .long sys_set_mempolicy, sys_kexec_load, sys_move_pages, sys_getcpu, sys_epoll_pwait
-/*310*/ .long sys_utimensat, sys_signalfd, sys_timerfd, sys_eventfd, sys_fallocate
+/*310*/ .long sys_utimensat, sys_signalfd, sys_ni_syscall, sys_eventfd, sys_fallocate
 
 #ifdef CONFIG_SUNOS_EMUL
         /* Now the SunOS syscall table. */
diff --git a/arch/sparc/lib/rwsem.S b/arch/sparc/lib/rwsem.S
index 20657744c864..f406b1f22791 100644
--- a/arch/sparc/lib/rwsem.S
+++ b/arch/sparc/lib/rwsem.S
@@ -7,7 +7,7 @@
 #include <asm/ptrace.h>
 #include <asm/psr.h>
 
-        .section .sched.text
+        .section .sched.text, "ax"
         .align  4
 
         .globl          ___down_read
diff --git a/arch/sparc64/Kconfig b/arch/sparc64/Kconfig
index 26f5791baa33..a8c6366f05a1 100644
--- a/arch/sparc64/Kconfig
+++ b/arch/sparc64/Kconfig
@@ -8,6 +8,8 @@ mainmenu "Linux/UltraSPARC Kernel Configuration"
 config SPARC
         bool
         default y
+        select HAVE_OPROFILE
+        select HAVE_KPROBES
 
 config SPARC64
         bool
@@ -66,7 +68,7 @@ config AUDIT_ARCH
         bool
         default y
 
-config ARCH_SETS_UP_PER_CPU_AREA
+config HAVE_SETUP_PER_CPU_AREA
         def_bool y
 
 config ARCH_NO_VIRT_TO_BUS
@@ -166,9 +168,8 @@ config SMP
           Y to "Enhanced Real Time Clock Support", below. The "Advanced Power
           Management" code will be disabled if you say Y here.
 
-          See also the <file:Documentation/smp.txt>,
-          <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO available at
-          <http://www.tldp.org/docs.html#howto>.
+          See also <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO
+          available at <http://www.tldp.org/docs.html#howto>.
 
           If you don't know what to do here, say N.
 
@@ -351,11 +352,6 @@ config PCI
           your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
           VESA. If you have PCI, say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 config PCI_DOMAINS
         def_bool PCI
 
@@ -470,8 +466,6 @@ source "drivers/sbus/char/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/sparc64/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/sparc64/kernel/iommu.c b/arch/sparc64/kernel/iommu.c
index 070a4846c0cb..4b9115a4d92e 100644
--- a/arch/sparc64/kernel/iommu.c
+++ b/arch/sparc64/kernel/iommu.c
@@ -580,7 +580,7 @@ static int dma_4u_map_sg(struct device *dev, struct scatterlist *sglist,
 
         /* Step 1: Prepare scatter list. */
 
-        npages = prepare_sg(sglist, nelems);
+        npages = prepare_sg(dev, sglist, nelems);
 
         /* Step 2: Allocate a cluster and context, if necessary. */
 
diff --git a/arch/sparc64/kernel/iommu_common.c b/arch/sparc64/kernel/iommu_common.c
index efd5dff85f60..72a4acfe8c7b 100644
--- a/arch/sparc64/kernel/iommu_common.c
+++ b/arch/sparc64/kernel/iommu_common.c
@@ -4,6 +4,7 @@
  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
  */
 
+#include <linux/dma-mapping.h>
 #include "iommu_common.h"
 
 /* You are _strongly_ advised to enable the following debugging code
@@ -201,21 +202,24 @@ void verify_sglist(struct scatterlist *sglist, int nents, iopte_t *iopte, int np
 }
 #endif
 
-unsigned long prepare_sg(struct scatterlist *sg, int nents)
+unsigned long prepare_sg(struct device *dev, struct scatterlist *sg, int nents)
 {
         struct scatterlist *dma_sg = sg;
         unsigned long prev;
         u32 dent_addr, dent_len;
+        unsigned int max_seg_size;
 
         prev  = (unsigned long) sg_virt(sg);
         prev += (unsigned long) (dent_len = sg->length);
         dent_addr = (u32) ((unsigned long)(sg_virt(sg)) & (IO_PAGE_SIZE - 1UL));
+        max_seg_size = dma_get_max_seg_size(dev);
         while (--nents) {
                 unsigned long addr;
 
                 sg = sg_next(sg);
                 addr = (unsigned long) sg_virt(sg);
-                if (! VCONTIG(prev, addr)) {
+                if (! VCONTIG(prev, addr) ||
+                        dent_len + sg->length > max_seg_size) {
                         dma_sg->dma_address = dent_addr;
                         dma_sg->dma_length = dent_len;
                         dma_sg = sg_next(dma_sg);
diff --git a/arch/sparc64/kernel/iommu_common.h b/arch/sparc64/kernel/iommu_common.h
index 75b5a5814522..a90d046e8024 100644
--- a/arch/sparc64/kernel/iommu_common.h
+++ b/arch/sparc64/kernel/iommu_common.h
@@ -9,6 +9,7 @@
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/scatterlist.h>
+#include <linux/device.h>
 
 #include <asm/iommu.h>
 #include <asm/scatterlist.h>
@@ -46,4 +47,4 @@ extern void verify_sglist(struct scatterlist *sg, int nents, iopte_t *iopte, int
 #define VCONTIG(__X, __Y)       (((__X) == (__Y)) || \
                                  (((__X) | (__Y)) << (64UL - PAGE_SHIFT)) == 0UL)
 
-extern unsigned long prepare_sg(struct scatterlist *sg, int nents);
+extern unsigned long prepare_sg(struct device *dev, struct scatterlist *sg, int nents);
diff --git a/arch/sparc64/kernel/pci_sun4v.c b/arch/sparc64/kernel/pci_sun4v.c
index 1aa8e044b105..5ea2eab1ccda 100644
--- a/arch/sparc64/kernel/pci_sun4v.c
+++ b/arch/sparc64/kernel/pci_sun4v.c
@@ -490,7 +490,7 @@ static int dma_4v_map_sg(struct device *dev, struct scatterlist *sglist,
                 goto bad;
 
         /* Step 1: Prepare scatter list. */
-        npages = prepare_sg(sglist, nelems);
+        npages = prepare_sg(dev, sglist, nelems);
 
         /* Step 2: Allocate a cluster and context, if necessary. */
         spin_lock_irqsave(&iommu->lock, flags);
@@ -625,8 +625,8 @@ static void __init pci_sun4v_scan_bus(struct pci_pbm_info *pbm)
         /* XXX register error interrupt handlers XXX */
 }
 
-static unsigned long probe_existing_entries(struct pci_pbm_info *pbm,
-                                            struct iommu *iommu)
+static unsigned long __init probe_existing_entries(struct pci_pbm_info *pbm,
+                                                   struct iommu *iommu)
 {
         struct iommu_arena *arena = &iommu->arena;
         unsigned long i, cnt = 0;
@@ -653,7 +653,7 @@ static unsigned long probe_existing_entries(struct pci_pbm_info *pbm,
         return cnt;
 }
 
-static void pci_sun4v_iommu_init(struct pci_pbm_info *pbm)
+static void __init pci_sun4v_iommu_init(struct pci_pbm_info *pbm)
 {
         struct iommu *iommu = pbm->iommu;
         struct property *prop;
diff --git a/arch/sparc64/kernel/systbls.S b/arch/sparc64/kernel/systbls.S
index 06d10907d8ce..b8058906e727 100644
--- a/arch/sparc64/kernel/systbls.S
+++ b/arch/sparc64/kernel/systbls.S
@@ -80,7 +80,7 @@ sys_call_table32:
         .word sys_fchmodat, sys_faccessat, compat_sys_pselect6, compat_sys_ppoll, sys_unshare
 /*300*/ .word compat_sys_set_robust_list, compat_sys_get_robust_list, compat_sys_migrate_pages, compat_sys_mbind, compat_sys_get_mempolicy
         .word compat_sys_set_mempolicy, compat_sys_kexec_load, compat_sys_move_pages, sys_getcpu, compat_sys_epoll_pwait
-/*310*/ .word compat_sys_utimensat, compat_sys_signalfd, compat_sys_timerfd, sys_eventfd, compat_sys_fallocate
+/*310*/ .word compat_sys_utimensat, compat_sys_signalfd, sys_ni_syscall, sys_eventfd, compat_sys_fallocate
 
 #endif /* CONFIG_COMPAT */
 
@@ -152,7 +152,7 @@ sys_call_table:
         .word sys_fchmodat, sys_faccessat, sys_pselect6, sys_ppoll, sys_unshare
 /*300*/ .word sys_set_robust_list, sys_get_robust_list, sys_migrate_pages, sys_mbind, sys_get_mempolicy
         .word sys_set_mempolicy, sys_kexec_load, sys_move_pages, sys_getcpu, sys_epoll_pwait
-/*310*/ .word sys_utimensat, sys_signalfd, sys_timerfd, sys_eventfd, sys_fallocate
+/*310*/ .word sys_utimensat, sys_signalfd, sys_ni_syscall, sys_eventfd, sys_fallocate
 
 #if defined(CONFIG_SUNOS_EMUL) || defined(CONFIG_SOLARIS_EMUL) || \
     defined(CONFIG_SOLARIS_EMUL_MODULE)
diff --git a/arch/sparc64/lib/GENbzero.S b/arch/sparc64/lib/GENbzero.S
index f9c71d64eba1..6a4f956a2f7a 100644
--- a/arch/sparc64/lib/GENbzero.S
+++ b/arch/sparc64/lib/GENbzero.S
@@ -10,7 +10,7 @@
         .align 4;               \
 99:     retl;                   \
          mov    %o1, %o0;       \
-        .section __ex_table;    \
+        .section __ex_table,"a";\
         .align 4;               \
         .word 98b, 99b;         \
         .text;                  \
diff --git a/arch/sparc64/lib/NGbzero.S b/arch/sparc64/lib/NGbzero.S
index f10e4529ee37..814d5f7a45e1 100644
--- a/arch/sparc64/lib/NGbzero.S
+++ b/arch/sparc64/lib/NGbzero.S
@@ -10,7 +10,7 @@
         .align 4;               \
 99:     retl;                   \
          mov    %o1, %o0;       \
-        .section __ex_table;    \
+        .section __ex_table,"a";\
         .align 4;               \
         .word 98b, 99b;         \
         .text;                  \
diff --git a/arch/sparc64/lib/rwsem.S b/arch/sparc64/lib/rwsem.S
index 75f0e6b951d6..1a4cc5654de4 100644
--- a/arch/sparc64/lib/rwsem.S
+++ b/arch/sparc64/lib/rwsem.S
@@ -6,7 +6,7 @@
 
 #include <asm/rwsem-const.h>
 
-        .section        .sched.text
+        .section        .sched.text, "ax"
 
         .globl          __down_read
 __down_read:
diff --git a/arch/sparc64/mm/init.c b/arch/sparc64/mm/init.c
index fbeb55d71e76..523e993ee90c 100644
--- a/arch/sparc64/mm/init.c
+++ b/arch/sparc64/mm/init.c
@@ -1328,6 +1328,11 @@ pgd_t swapper_pg_dir[2048];
 static void sun4u_pgprot_init(void);
 static void sun4v_pgprot_init(void);
 
+/* Dummy function */
+void __init setup_per_cpu_areas(void)
+{
+}
+
 void __init paging_init(void)
 {
         unsigned long end_pfn, pages_avail, shift, phys_base;
diff --git a/arch/um/Kconfig b/arch/um/Kconfig
index dd1689b814cb..99e51d059a02 100644
--- a/arch/um/Kconfig
+++ b/arch/um/Kconfig
@@ -68,6 +68,10 @@ config IRQ_RELEASE_METHOD
         bool
         default y
 
+config HZ
+        int
+        default 100
+
 menu "UML-specific options"
 
 config STATIC_LINK
@@ -95,23 +99,6 @@ config LD_SCRIPT_DYN
         default y
         depends on !LD_SCRIPT_STATIC
 
-config NET
-        bool "Networking support"
-        help
-          Unless you really know what you are doing, you should say Y here.
-          The reason is that some programs need kernel networking support even
-          when running on a stand-alone machine that isn't connected to any
-          other computer. If you are upgrading from an older kernel, you
-          should consider updating your networking tools too because changes
-          in the kernel and the tools often go hand in hand. The tools are
-          contained in the package net-tools, the location and version number
-          of which are given in <file:Documentation/Changes>.
-
-          For a general introduction to Linux networking, it is highly
-          recommended to read the NET-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>.
-
-
 source "fs/Kconfig.binfmt"
 
 config HOSTFS
@@ -145,7 +132,7 @@ config HPPFS
           by removing or changing anything in /proc which gives away the
           identity of a UML.
 
-          See <http://user-mode-linux.sf.net/hppfs.html> for more information.
+          See <http://user-mode-linux.sf.net/old/hppfs.html> for more information.
 
           You only need this if you are setting up a UML honeypot.  Otherwise,
           it is safe to say 'N' here.
@@ -189,8 +176,7 @@ config MAGIC_SYSRQ
 config SMP
         bool "Symmetric multi-processing support (EXPERIMENTAL)"
         default n
-        #SMP_BROKEN is for x86_64.
-        depends on EXPERIMENTAL && (!SMP_BROKEN || (BROKEN && SMP_BROKEN))
+        depends on BROKEN
         help
           This option enables UML SMP support.
           It is NOT related to having a real SMP box. Not directly, at least.
@@ -289,6 +275,4 @@ config INPUT
         bool
         default n
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/um/Kconfig.debug"
diff --git a/arch/um/Kconfig.char b/arch/um/Kconfig.char
index 9a78d354f0b4..3a4b396d7979 100644
--- a/arch/um/Kconfig.char
+++ b/arch/um/Kconfig.char
@@ -18,7 +18,7 @@ config SSL
           lines on the UML that are usually made to show up on the host as
           ttys or ptys.
 
-          See <http://user-mode-linux.sourceforge.net/input.html> for more
+          See <http://user-mode-linux.sourceforge.net/old/input.html> for more
           information and command line examples of how to use this facility.
 
           Unless you have a specific reason for disabling this, say Y.
diff --git a/arch/um/Kconfig.debug b/arch/um/Kconfig.debug
index 1f6462ffd3e8..8fce5e536b0f 100644
--- a/arch/um/Kconfig.debug
+++ b/arch/um/Kconfig.debug
@@ -4,12 +4,12 @@ source "lib/Kconfig.debug"
 
 config GPROF
         bool "Enable gprof support"
-        depends on DEBUG_INFO
+        depends on DEBUG_INFO && FRAME_POINTER
         help
           This allows profiling of a User-Mode Linux kernel with the gprof
           utility.
 
-          See <http://user-mode-linux.sourceforge.net/gprof.html> for more
+          See <http://user-mode-linux.sourceforge.net/old/gprof.html> for more
           details.
 
           If you're involved in UML kernel development and want to use gprof,
@@ -22,7 +22,7 @@ config GCOV
           This option allows developers to retrieve coverage data from a UML
           session.
 
-          See <http://user-mode-linux.sourceforge.net/gprof.html> for more
+          See <http://user-mode-linux.sourceforge.net/old/gprof.html> for more
           details.
 
           If you're involved in UML kernel development and want to use gcov,
diff --git a/arch/um/Kconfig.net b/arch/um/Kconfig.net
index 66e50026ade9..9e9a4aaa703d 100644
--- a/arch/um/Kconfig.net
+++ b/arch/um/Kconfig.net
@@ -14,7 +14,7 @@ config UML_NET
 
         For more information, including explanations of the networking and
         sample configurations, see
-        <http://user-mode-linux.sourceforge.net/networking.html>.
+        <http://user-mode-linux.sourceforge.net/old/networking.html>.
 
         If you'd like to be able to enable networking in the User-Mode
         linux environment, say Y; otherwise say N.  Note that you must
@@ -38,7 +38,7 @@ config UML_NET_ETHERTAP
         CONFIG_NETLINK_DEV configured as Y or M.
 
         For more information, see
-        <http://user-mode-linux.sourceforge.net/networking.html>  That site
+        <http://user-mode-linux.sourceforge.net/old/networking.html>  That site
         has examples of the UML command line to use to enable Ethertap
         networking.
 
@@ -72,7 +72,7 @@ config UML_NET_SLIP
         To use this, your host must support slip devices.
 
         For more information, see
-        <http://user-mode-linux.sourceforge.net/networking.html>.  That site
+        <http://user-mode-linux.sourceforge.net/old/networking.html>.
         has examples of the UML command line to use to enable slip
         networking, and details of a few quirks with it.
 
@@ -96,7 +96,7 @@ config UML_NET_DAEMON
         networking daemon on the host.
 
         For more information, see
-        <http://user-mode-linux.sourceforge.net/networking.html>  That site
+        <http://user-mode-linux.sourceforge.net/old/networking.html>  That site
         has examples of the UML command line to use to enable Daemon
         networking.
 
@@ -144,7 +144,7 @@ config UML_NET_MCAST
         To use this, your host kernel(s) must support IP Multicasting.
 
         For more information, see
-        <http://user-mode-linux.sourceforge.net/networking.html>  That site
+        <http://user-mode-linux.sourceforge.net/old/networking.html>  That site
         has examples of the UML command line to use to enable Multicast
         networking, and notes about the security of this approach.
 
@@ -165,7 +165,7 @@ config UML_NET_PCAP
         installed in order to build the pcap transport into UML.
 
         For more information, see
-        <http://user-mode-linux.sourceforge.net/networking.html>  That site
+        <http://user-mode-linux.sourceforge.net/old/networking.html>  That site
         has examples of the UML command line to use to enable this option.
 
         If you intend to use UML as a network monitor for the host, say
diff --git a/arch/um/Makefile b/arch/um/Makefile
index ba6813a4aa37..cb4af9bf2074 100644
--- a/arch/um/Makefile
+++ b/arch/um/Makefile
@@ -49,7 +49,7 @@ SYS_DIR		:= $(ARCH_DIR)/include/sysdep-$(SUBARCH)
 #
 # These apply to USER_CFLAGS to.
 
-KBUILD_CFLAGS += $(CFLAGS-y) -D__arch_um__ -DSUBARCH=\"$(SUBARCH)\"     \
+KBUILD_CFLAGS += $(CFLAGS) $(CFLAGS-y) -D__arch_um__ -DSUBARCH=\"$(SUBARCH)\" \
         $(ARCH_INCLUDE) $(MODE_INCLUDE) -Dvmap=kernel_vmap      \
         -Din6addr_loopback=kernel_in6addr_loopback \
         -Din6addr_any=kernel_in6addr_any
@@ -58,7 +58,7 @@ KBUILD_AFLAGS += $(ARCH_INCLUDE)
 
 USER_CFLAGS = $(patsubst $(KERNEL_DEFINES),,$(patsubst -D__KERNEL__,,\
         $(patsubst -I%,,$(KBUILD_CFLAGS)))) $(ARCH_INCLUDE) $(MODE_INCLUDE) \
-        -D_FILE_OFFSET_BITS=64
+        $(filter -I%,$(CFLAGS)) -D_FILE_OFFSET_BITS=64
 
 include $(srctree)/$(ARCH_DIR)/Makefile-$(SUBARCH)
 
@@ -130,7 +130,9 @@ CPPFLAGS_vmlinux.lds = -U$(SUBARCH) -DSTART=$(START) -DELF_ARCH=$(ELF_ARCH) \
 # The wrappers will select whether using "malloc" or the kernel allocator.
 LINK_WRAPS = -Wl,--wrap,malloc -Wl,--wrap,free -Wl,--wrap,calloc
 
-CFLAGS_vmlinux := $(LINK-y) $(LINK_WRAPS)
+LD_FLAGS_CMDLINE = $(foreach opt,$(LDFLAGS),-Wl,$(opt))
+
+CFLAGS_vmlinux := $(LINK-y) $(LINK_WRAPS) $(LD_FLAGS_CMDLINE)
 define cmd_vmlinux__
         $(CC) $(CFLAGS_vmlinux) -o $@ \
         -Wl,-T,$(vmlinux-lds) $(vmlinux-init) \
@@ -158,7 +160,7 @@ ifneq ($(KBUILD_SRC),)
         $(Q)mkdir -p $(objtree)/include/asm-um
         $(Q)ln -fsn $(srctree)/include/asm-um/$(basename $(notdir $@))-$(SUBARCH)$(suffix $@) $@
 else
-        $(Q)cd $(TOPDIR)/$(dir $@) ; \
+        $(Q)cd $(srctree)/$(dir $@) ; \
         ln -sf $(basename $(notdir $@))-$(SUBARCH)$(suffix $@) $(notdir $@)
 endif
 
@@ -168,7 +170,7 @@ ifneq ($(KBUILD_SRC),)
         $(Q)mkdir -p $(objtree)/include/asm-um
         $(Q)ln -fsn $(srctree)/include/asm-$(HEADER_ARCH) include/asm-um/arch
 else
-        $(Q)cd $(TOPDIR)/include/asm-um && ln -fsn ../asm-$(HEADER_ARCH) arch
+        $(Q)cd $(srctree)/include/asm-um && ln -fsn ../asm-$(HEADER_ARCH) arch
 endif
 
 $(objtree)/$(ARCH_DIR)/include:
diff --git a/arch/um/Makefile-tt b/arch/um/Makefile-tt
deleted file mode 100644
index 03f7b10cfd0b..000000000000
--- a/arch/um/Makefile-tt
+++ /dev/null
@@ -1,5 +0,0 @@
-# 
-# Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
-# Licensed under the GPL
-#
-
diff --git a/arch/um/defconfig b/arch/um/defconfig
index f609edede065..86db2862f222 100644
--- a/arch/um/defconfig
+++ b/arch/um/defconfig
@@ -77,7 +77,7 @@ CONFIG_LD_SCRIPT_DYN=y
 CONFIG_NET=y
 CONFIG_BINFMT_ELF=y
 CONFIG_BINFMT_MISC=m
-# CONFIG_HOSTFS is not set
+CONFIG_HOSTFS=y
 # CONFIG_HPPFS is not set
 CONFIG_MCONSOLE=y
 CONFIG_MAGIC_SYSRQ=y
@@ -188,7 +188,7 @@ CONFIG_CON_CHAN="xterm"
 CONFIG_SSL_CHAN="pts"
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
-CONFIG_LEGACY_PTY_COUNT=256
+CONFIG_LEGACY_PTY_COUNT=32
 # CONFIG_WATCHDOG is not set
 CONFIG_UML_SOUND=m
 CONFIG_SOUND=m
@@ -508,7 +508,7 @@ CONFIG_DEBUG_KERNEL=y
 CONFIG_LOG_BUF_SHIFT=14
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
-CONFIG_DEBUG_SLAB=y
+# CONFIG_DEBUG_SLAB is not set
 # CONFIG_DEBUG_SLAB_LEAK is not set
 # CONFIG_DEBUG_MUTEXES is not set
 # CONFIG_DEBUG_SPINLOCK is not set
diff --git a/arch/um/drivers/line.c b/arch/um/drivers/line.c
index 83bf15a3dda8..2c898c4d6b6a 100644
--- a/arch/um/drivers/line.c
+++ b/arch/um/drivers/line.c
@@ -8,6 +8,7 @@
 #include "chan_kern.h"
 #include "irq_kern.h"
 #include "irq_user.h"
+#include "kern_util.h"
 #include "os.h"
 
 #define LINE_BUFSIZE 4096
@@ -48,7 +49,7 @@ static int write_room(struct line *line)
         n = line->head - line->tail;
 
         if (n <= 0)
-                n = LINE_BUFSIZE + n; /* The other case */
+                n += LINE_BUFSIZE; /* The other case */
         return n - 1;
 }
 
@@ -58,17 +59,10 @@ int line_write_room(struct tty_struct *tty)
         unsigned long flags;
         int room;
 
-        if (tty->stopped)
-                return 0;
-
         spin_lock_irqsave(&line->lock, flags);
         room = write_room(line);
         spin_unlock_irqrestore(&line->lock, flags);
 
-        /*XXX: Warning to remove */
-        if (0 == room)
-                printk(KERN_DEBUG "%s: %s: no room left in buffer\n",
-                       __FUNCTION__,tty->name);
         return room;
 }
 
@@ -79,8 +73,7 @@ int line_chars_in_buffer(struct tty_struct *tty)
         int ret;
 
         spin_lock_irqsave(&line->lock, flags);
-
-        /*write_room subtracts 1 for the needed NULL, so we readd it.*/
+        /* write_room subtracts 1 for the needed NULL, so we readd it.*/
         ret = LINE_BUFSIZE - (write_room(line) + 1);
         spin_unlock_irqrestore(&line->lock, flags);
 
@@ -184,10 +177,6 @@ void line_flush_buffer(struct tty_struct *tty)
         unsigned long flags;
         int err;
 
-        /*XXX: copied from line_write, verify if it is correct!*/
-        if (tty->stopped)
-                return;
-
         spin_lock_irqsave(&line->lock, flags);
         err = flush_buffer(line);
         spin_unlock_irqrestore(&line->lock, flags);
@@ -213,9 +202,6 @@ int line_write(struct tty_struct *tty, const unsigned char *buf, int len)
         unsigned long flags;
         int n, ret = 0;
 
-        if (tty->stopped)
-                return 0;
-
         spin_lock_irqsave(&line->lock, flags);
         if (line->head != line->tail)
                 ret = buffer_data(line, buf, len);
@@ -788,9 +774,11 @@ static irqreturn_t winch_interrupt(int irq, void *data)
         tty = winch->tty;
         if (tty != NULL) {
                 line = tty->driver_data;
-                chan_window_size(&line->chan_list, &tty->winsize.ws_row,
-                                 &tty->winsize.ws_col);
-                kill_pgrp(tty->pgrp, SIGWINCH, 1);
+                if (line != NULL) {
+                        chan_window_size(&line->chan_list, &tty->winsize.ws_row,
+                                         &tty->winsize.ws_col);
+                        kill_pgrp(tty->pgrp, SIGWINCH, 1);
+                }
         }
  out:
         if (winch->fd != -1)
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
index 0f3c7d14a6e3..ebb265c07e4d 100644
--- a/arch/um/drivers/mconsole_kern.c
+++ b/arch/um/drivers/mconsole_kern.c
@@ -1,23 +1,25 @@
 /*
  * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org)
- * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+ * Copyright (C) 2001 - 2008 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include "linux/console.h"
-#include "linux/ctype.h"
-#include "linux/interrupt.h"
-#include "linux/list.h"
-#include "linux/mm.h"
-#include "linux/module.h"
-#include "linux/notifier.h"
-#include "linux/reboot.h"
-#include "linux/proc_fs.h"
-#include "linux/slab.h"
-#include "linux/syscalls.h"
-#include "linux/utsname.h"
-#include "linux/workqueue.h"
-#include "asm/uaccess.h"
+#include <linux/console.h>
+#include <linux/ctype.h>
+#include <linux/interrupt.h>
+#include <linux/list.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/proc_fs.h>
+#include <linux/slab.h>
+#include <linux/syscalls.h>
+#include <linux/utsname.h>
+#include <linux/workqueue.h>
+#include <linux/mutex.h>
+#include <asm/uaccess.h>
+
 #include "init.h"
 #include "irq_kern.h"
 #include "irq_user.h"
@@ -305,7 +307,9 @@ void mconsole_stop(struct mc_request *req)
         deactivate_fd(req->originating_fd, MCONSOLE_IRQ);
         os_set_fd_block(req->originating_fd, 1);
         mconsole_reply(req, "stopped", 0, 0);
-        while (mconsole_get_request(req->originating_fd, req)) {
+        for (;;) {
+                if (!mconsole_get_request(req->originating_fd, req))
+                        continue;
                 if (req->cmd->handler == mconsole_go)
                         break;
                 if (req->cmd->handler == mconsole_stop) {
@@ -358,7 +362,7 @@ struct unplugged_pages {
         void *pages[UNPLUGGED_PER_PAGE];
 };
 
-static DECLARE_MUTEX(plug_mem_mutex);
+static DEFINE_MUTEX(plug_mem_mutex);
 static unsigned long long unplugged_pages_count = 0;
 static LIST_HEAD(unplugged_pages);
 static int unplug_index = UNPLUGGED_PER_PAGE;
@@ -394,7 +398,7 @@ static int mem_config(char *str, char **error_out)
 
         diff /= PAGE_SIZE;
 
-        down(&plug_mem_mutex);
+        mutex_lock(&plug_mem_mutex);
         for (i = 0; i < diff; i++) {
                 struct unplugged_pages *unplugged;
                 void *addr;
@@ -451,7 +455,7 @@ static int mem_config(char *str, char **error_out)
 
         err = 0;
 out_unlock:
-        up(&plug_mem_mutex);
+        mutex_unlock(&plug_mem_mutex);
 out:
         return err;
 }
@@ -741,7 +745,6 @@ void mconsole_stack(struct mc_request *req)
 {
         char *ptr = req->request.data;
         int pid_requested= -1;
-        struct task_struct *from = NULL;
         struct task_struct *to = NULL;
 
         /*
@@ -763,9 +766,7 @@ void mconsole_stack(struct mc_request *req)
                 return;
         }
 
-        from = current;
-
-        to = find_task_by_pid(pid_requested);
+        to = find_task_by_pid_ns(pid_requested, &init_pid_ns);
         if ((to == NULL) || (pid_requested == 0)) {
                 mconsole_reply(req, "Couldn't find that pid", 1, 0);
                 return;
@@ -795,6 +796,8 @@ static int __init mconsole_init(void)
                 printk(KERN_ERR "Failed to initialize management console\n");
                 return 1;
         }
+        if (os_set_fd_block(sock, 0))
+                goto out;
 
         register_reboot_notifier(&reboot_notifier);
 
@@ -803,7 +806,7 @@ static int __init mconsole_init(void)
                              "mconsole", (void *)sock);
         if (err) {
                 printk(KERN_ERR "Failed to get IRQ for management console\n");
-                return 1;
+                goto out;
         }
 
         if (notify_socket != NULL) {
@@ -819,6 +822,10 @@ static int __init mconsole_init(void)
         printk(KERN_INFO "mconsole (version %d) initialized on %s\n",
                MCONSOLE_VERSION, mconsole_socket_name);
         return 0;
+
+ out:
+        os_close_file(sock);
+        return 1;
 }
 
 __initcall(mconsole_init);
diff --git a/arch/um/drivers/mconsole_user.c b/arch/um/drivers/mconsole_user.c
index 430c024a19b0..13af2f03ed84 100644
--- a/arch/um/drivers/mconsole_user.c
+++ b/arch/um/drivers/mconsole_user.c
@@ -83,9 +83,8 @@ int mconsole_get_request(int fd, struct mc_request *req)
         int len;
 
         req->originlen = sizeof(req->origin);
-        req->len = recvfrom(fd, &req->request, sizeof(req->request),
-                            MSG_DONTWAIT, (struct sockaddr *) req->origin,
-                            &req->originlen);
+        req->len = recvfrom(fd, &req->request, sizeof(req->request), 0,
+                            (struct sockaddr *) req->origin, &req->originlen);
         if (req->len < 0)
                 return 0;
 
diff --git a/arch/um/drivers/net_kern.c b/arch/um/drivers/net_kern.c
index 3c6c44ca1ffa..1e8f41a99511 100644
--- a/arch/um/drivers/net_kern.c
+++ b/arch/um/drivers/net_kern.c
@@ -318,7 +318,7 @@ static void setup_etheraddr(char *str, unsigned char *addr, char *name)
         if (str == NULL)
                 goto random;
 
-        for (i = 0;i < 6; i++) {
+        for (i = 0; i < 6; i++) {
                 addr[i] = simple_strtoul(str, &end, 16);
                 if ((end == str) ||
                    ((*end != ':') && (*end != ',') && (*end != '\0'))) {
@@ -343,14 +343,13 @@ static void setup_etheraddr(char *str, unsigned char *addr, char *name)
         }
         if (!is_local_ether_addr(addr)) {
                 printk(KERN_WARNING
-                       "Warning: attempt to assign a globally valid ethernet "
+                       "Warning: Assigning a globally valid ethernet "
                        "address to a device\n");
-                printk(KERN_WARNING "You should better enable the 2nd "
-                       "rightmost bit in the first byte of the MAC,\n");
+                printk(KERN_WARNING "You should set the 2nd rightmost bit in "
+                       "the first byte of the MAC,\n");
                 printk(KERN_WARNING "i.e. %02x:%02x:%02x:%02x:%02x:%02x\n",
                        addr[0] | 0x02, addr[1], addr[2], addr[3], addr[4],
                        addr[5]);
-                goto random;
         }
         return;
 
@@ -368,7 +367,6 @@ static struct platform_driver uml_net_driver = {
                 .name  = DRIVER_NAME,
         },
 };
-static int driver_registered;
 
 static void net_device_release(struct device *dev)
 {
@@ -383,6 +381,12 @@ static void net_device_release(struct device *dev)
         free_netdev(netdev);
 }
 
+/*
+ * Ensures that platform_driver_register is called only once by
+ * eth_configure.  Will be set in an initcall.
+ */
+static int driver_registered;
+
 static void eth_configure(int n, void *init, char *mac,
                           struct transport *transport)
 {
diff --git a/arch/um/drivers/net_user.c b/arch/um/drivers/net_user.c
index 29185cad9fff..abf2653f5517 100644
--- a/arch/um/drivers/net_user.c
+++ b/arch/um/drivers/net_user.c
@@ -201,7 +201,7 @@ static int change_tramp(char **argv, char *output, int output_len)
         close(fds[1]);
 
         if (pid > 0)
-                helper_wait(pid, 0, "change_tramp");
+                helper_wait(pid);
         return pid;
 }
 
diff --git a/arch/um/drivers/port_kern.c b/arch/um/drivers/port_kern.c
index 330543b3129b..19930081d3d8 100644
--- a/arch/um/drivers/port_kern.c
+++ b/arch/um/drivers/port_kern.c
@@ -6,6 +6,7 @@
 #include "linux/completion.h"
 #include "linux/interrupt.h"
 #include "linux/list.h"
+#include "linux/mutex.h"
 #include "asm/atomic.h"
 #include "init.h"
 #include "irq_kern.h"
@@ -120,7 +121,7 @@ static int port_accept(struct port_list *port)
         return 0;
 }
 
-static DECLARE_MUTEX(ports_sem);
+static DEFINE_MUTEX(ports_mutex);
 static LIST_HEAD(ports);
 
 static void port_work_proc(struct work_struct *unused)
@@ -161,7 +162,7 @@ void *port_data(int port_num)
         struct port_dev *dev = NULL;
         int fd;
 
-        down(&ports_sem);
+        mutex_lock(&ports_mutex);
         list_for_each(ele, &ports) {
                 port = list_entry(ele, struct port_list, list);
                 if (port->port == port_num)
@@ -216,7 +217,7 @@ void *port_data(int port_num)
  out_free:
         kfree(port);
  out:
-        up(&ports_sem);
+        mutex_unlock(&ports_mutex);
         return dev;
 }
 
diff --git a/arch/um/drivers/random.c b/arch/um/drivers/random.c
index e942e836f995..71f0959c1535 100644
--- a/arch/um/drivers/random.c
+++ b/arch/um/drivers/random.c
@@ -5,6 +5,7 @@
  * This software may be used and distributed according to the terms
  * of the GNU General Public License, incorporated herein by reference.
  */
+#include <linux/sched.h>
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/miscdevice.h>
diff --git a/arch/um/drivers/slip_user.c b/arch/um/drivers/slip_user.c
index b8711e50da80..8b80505a3fb0 100644
--- a/arch/um/drivers/slip_user.c
+++ b/arch/um/drivers/slip_user.c
@@ -109,7 +109,7 @@ static int slip_tramp(char **argv, int fd)
         read_output(fds[0], output, output_len);
         printk("%s", output);
 
-        err = helper_wait(pid, 0, argv[0]);
+        err = helper_wait(pid);
         close(fds[0]);
 
 out_free:
diff --git a/arch/um/drivers/slirp_user.c b/arch/um/drivers/slirp_user.c
index 89c1be225fda..a0ada8fec72a 100644
--- a/arch/um/drivers/slirp_user.c
+++ b/arch/um/drivers/slirp_user.c
@@ -98,7 +98,7 @@ static void slirp_close(int fd, void *data)
                        "(%d)\n", pri->pid, errno);
         }
 #endif
-        err = helper_wait(pri->pid, 1, "slirp_close");
+        err = helper_wait(pri->pid);
         if (err < 0)
                 return;
 
diff --git a/arch/um/drivers/ssl.c b/arch/um/drivers/ssl.c
index 875d60d0c6a2..f1786e64607f 100644
--- a/arch/um/drivers/ssl.c
+++ b/arch/um/drivers/ssl.c
@@ -15,7 +15,6 @@
 #include "line.h"
 #include "ssl.h"
 #include "chan_kern.h"
-#include "kern_util.h"
 #include "kern.h"
 #include "init.h"
 #include "irq_user.h"
diff --git a/arch/um/drivers/stdio_console.c b/arch/um/drivers/stdio_console.c
index 656036e90b19..cec0c33cdd39 100644
--- a/arch/um/drivers/stdio_console.c
+++ b/arch/um/drivers/stdio_console.c
@@ -22,7 +22,6 @@
 #include "stdio_console.h"
 #include "line.h"
 #include "chan_kern.h"
-#include "kern_util.h"
 #include "irq_user.h"
 #include "mconsole_kern.h"
 #include "init.h"
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index 99f9f9605e9c..be3a2797dac4 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -49,6 +49,7 @@
 #include "irq_user.h"
 #include "irq_kern.h"
 #include "ubd_user.h"
+#include "kern_util.h"
 #include "os.h"
 #include "mem.h"
 #include "mem_kern.h"
@@ -229,7 +230,7 @@ static int proc_ide_read_media(char *page, char **start, off_t off, int count,
         return len;
 }
 
-static void make_ide_entries(char *dev_name)
+static void make_ide_entries(const char *dev_name)
 {
         struct proc_dir_entry *dir, *ent;
         char name[64];
@@ -244,7 +245,7 @@ static void make_ide_entries(char *dev_name)
         ent->data = NULL;
         ent->read_proc = proc_ide_read_media;
         ent->write_proc = NULL;
-        sprintf(name,"ide0/%s", dev_name);
+        snprintf(name, sizeof(name), "ide0/%s", dev_name);
         proc_symlink(dev_name, proc_ide_root, name);
 }
 
@@ -437,7 +438,10 @@ __uml_help(ubd_setup,
 "    machine by running 'dd' on the device. <n> must be in the range\n"
 "    0 to 7. Appending an 'r' to the number will cause that device\n"
 "    to be mounted read-only. For example ubd1r=./ext_fs. Appending\n"
-"    an 's' will cause data to be written to disk on the host immediately.\n\n"
+"    an 's' will cause data to be written to disk on the host immediately.\n"
+"    'c' will cause the device to be treated as being shared between multiple\n"
+"    UMLs and file locking will be turned off - this is appropriate for a\n"
+"    cluster filesystem and inappropriate at almost all other times.\n\n"
 );
 
 static int udb_setup(char *str)
@@ -456,20 +460,6 @@ __uml_help(udb_setup,
 "    in the boot output.\n\n"
 );
 
-static int fakehd_set = 0;
-static int fakehd(char *str)
-{
-        printk(KERN_INFO "fakehd : Changing ubd name to \"hd\".\n");
-        fakehd_set = 1;
-        return 1;
-}
-
-__setup("fakehd", fakehd);
-__uml_help(fakehd,
-"fakehd\n"
-"    Change the ubd device name to \"hd\".\n\n"
-);
-
 static void do_ubd_request(struct request_queue * q);
 
 /* Only changed by ubd_init, which is an initcall. */
@@ -718,8 +708,10 @@ static int ubd_add(int n, char **error_out)
                 ubd_disk_register(fake_major, ubd_dev->size, n,
                                   &fake_gendisk[n]);
 
-        /* perhaps this should also be under the "if (fake_major)" above */
-        /* using the fake_disk->disk_name and also the fakehd_set name */
+        /*
+         * Perhaps this should also be under the "if (fake_major)" above
+         * using the fake_disk->disk_name
+         */
         if (fake_ide)
                 make_ide_entries(ubd_gendisk[n]->disk_name);
 
diff --git a/arch/um/drivers/ubd_user.c b/arch/um/drivers/ubd_user.c
index 48fc7452bc1d..b591bb9c41dd 100644
--- a/arch/um/drivers/ubd_user.c
+++ b/arch/um/drivers/ubd_user.c
@@ -16,7 +16,6 @@
 #include <sys/mman.h>
 #include <sys/param.h>
 #include "asm/types.h"
-#include "kern_util.h"
 #include "user.h"
 #include "ubd_user.h"
 #include "os.h"
diff --git a/arch/um/drivers/vde_user.c b/arch/um/drivers/vde_user.c
index d9941fe5f931..56533db25343 100644
--- a/arch/um/drivers/vde_user.c
+++ b/arch/um/drivers/vde_user.c
@@ -80,7 +80,7 @@ void vde_init_libstuff(struct vde_data *vpri, struct vde_init *init)
 
         vpri->args = kmalloc(sizeof(struct vde_open_args), UM_GFP_KERNEL);
         if (vpri->args == NULL) {
-                printk(UM_KERN_ERR "vde_init_libstuff - vde_open_args"
+                printk(UM_KERN_ERR "vde_init_libstuff - vde_open_args "
                        "allocation failed");
                 return;
         }
diff --git a/arch/um/include/arch.h b/arch/um/include/arch.h
index 49c601ff2bac..2de92a08a76b 100644
--- a/arch/um/include/arch.h
+++ b/arch/um/include/arch.h
@@ -10,6 +10,6 @@
 
 extern void arch_check_bugs(void);
 extern int arch_fixup(unsigned long address, struct uml_pt_regs *regs);
-extern int arch_handle_signal(int sig, struct uml_pt_regs *regs);
+extern void arch_examine_signal(int sig, struct uml_pt_regs *regs);
 
 #endif
diff --git a/arch/um/include/as-layout.h b/arch/um/include/as-layout.h
index a5cdf953e04a..606bb5c7fdf6 100644
--- a/arch/um/include/as-layout.h
+++ b/arch/um/include/as-layout.h
@@ -10,23 +10,31 @@
 #include "kern_constants.h"
 
 /*
- * Assembly doesn't want any casting, but C does, so define these
- * without casts here, and define new symbols with casts inside the C
- * section.
+ * Stolen from linux/const.h, which can't be directly included since
+ * this is used in userspace code, which has no access to the kernel
+ * headers.  Changed to be suitable for adding casts to the start,
+ * rather than "UL" to the end.
  */
-#define ASM_STUB_CODE (UML_CONFIG_TOP_ADDR - 2 * UM_KERN_PAGE_SIZE)
-#define ASM_STUB_DATA (UML_CONFIG_TOP_ADDR - UM_KERN_PAGE_SIZE)
-#define ASM_STUB_START ASM_STUB_CODE
 
-/*
- * This file is included by the assembly stubs, which just want the
- * definitions above.
+/* Some constant macros are used in both assembler and
+ * C code.  Therefore we cannot annotate them always with
+ * 'UL' and other type specifiers unilaterally.  We
+ * use the following macros to deal with this.
  */
-#ifndef __ASSEMBLY__
 
-#define STUB_CODE ((unsigned long) ASM_STUB_CODE)
-#define STUB_DATA ((unsigned long) ASM_STUB_DATA)
-#define STUB_START ((unsigned long) ASM_STUB_START)
+#ifdef __ASSEMBLY__
+#define _AC(X, Y)       (Y)
+#else
+#define __AC(X, Y)      (X (Y))
+#define _AC(X, Y)       __AC(X, Y)
+#endif
+
+#define STUB_START _AC(, 0x100000)
+#define STUB_CODE _AC((unsigned long), STUB_START)
+#define STUB_DATA _AC((unsigned long), STUB_CODE + UM_KERN_PAGE_SIZE)
+#define STUB_END _AC((unsigned long), STUB_DATA + UM_KERN_PAGE_SIZE)
+
+#ifndef __ASSEMBLY__
 
 #include "sysdep/ptrace.h"
 
diff --git a/arch/um/include/chan_user.h b/arch/um/include/chan_user.h
index 5a2263e05bb2..9b9ced85b703 100644
--- a/arch/um/include/chan_user.h
+++ b/arch/um/include/chan_user.h
@@ -48,7 +48,7 @@ extern void register_winch_irq(int fd, int tty_fd, int pid,
 #define __channel_help(fn, prefix) \
 __uml_help(fn, prefix "[0-9]*=<channel description>\n" \
 "    Attach a console or serial line to a host channel.  See\n" \
-"    http://user-mode-linux.sourceforge.net/input.html for a complete\n" \
+"    http://user-mode-linux.sourceforge.net/old/input.html for a complete\n" \
 "    description of this switch.\n\n" \
 );
 
diff --git a/arch/um/include/common-offsets.h b/arch/um/include/common-offsets.h
index 0edab695ed4e..b54bd35585c2 100644
--- a/arch/um/include/common-offsets.h
+++ b/arch/um/include/common-offsets.h
@@ -18,6 +18,7 @@ DEFINE_STR(UM_KERN_WARNING, KERN_WARNING);
 DEFINE_STR(UM_KERN_NOTICE, KERN_NOTICE);
 DEFINE_STR(UM_KERN_INFO, KERN_INFO);
 DEFINE_STR(UM_KERN_DEBUG, KERN_DEBUG);
+DEFINE_STR(UM_KERN_CONT, KERN_CONT);
 
 DEFINE(UM_ELF_CLASS, ELF_CLASS);
 DEFINE(UM_ELFCLASS32, ELFCLASS32);
diff --git a/arch/um/include/init.h b/arch/um/include/init.h
index cebc6cae9190..b00a95741d41 100644
--- a/arch/um/include/init.h
+++ b/arch/um/include/init.h
@@ -40,6 +40,20 @@
 typedef int (*initcall_t)(void);
 typedef void (*exitcall_t)(void);
 
+#ifndef __KERNEL__
+#ifndef __section
+# define __section(S) __attribute__ ((__section__(#S)))
+#endif
+
+#if __GNUC_MINOR__ >= 3
+# define __used                 __attribute__((__used__))
+#else
+# define __used                 __attribute__((__unused__))
+#endif
+
+#else
+#include <linux/compiler.h>
+#endif
 /* These are for everybody (although not all archs will actually
    discard it in modules) */
 #define __init          __section(.init.text)
@@ -127,14 +141,3 @@ extern struct uml_param __uml_setup_start, __uml_setup_end;
 #endif
 
 #endif /* _LINUX_UML_INIT_H */
-
-/*
- * 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/irq_user.h b/arch/um/include/irq_user.h
index 884a9c17eea0..e60b31873de1 100644
--- a/arch/um/include/irq_user.h
+++ b/arch/um/include/irq_user.h
@@ -14,7 +14,6 @@ struct irq_fd {
         int fd;
         int type;
         int irq;
-        int pid;
         int events;
         int current_events;
 };
diff --git a/arch/um/include/kern_util.h b/arch/um/include/kern_util.h
index 74ce8e5370a6..3c341222d252 100644
--- a/arch/um/include/kern_util.h
+++ b/arch/um/include/kern_util.h
@@ -9,107 +9,61 @@
 #include "sysdep/ptrace.h"
 #include "sysdep/faultinfo.h"
 
-typedef void (*kern_hndl)(int, struct uml_pt_regs *);
-
-struct kern_handlers {
-        kern_hndl relay_signal;
-        kern_hndl winch;
-        kern_hndl bus_handler;
-        kern_hndl page_fault;
-        kern_hndl sigio_handler;
-        kern_hndl timer_handler;
-};
-
-extern const struct kern_handlers handlinfo_kern;
+extern int uml_exitcode;
 
 extern int ncpus;
-extern char *gdb_init;
 extern int kmalloc_ok;
-extern int jail;
-extern int nsyscalls;
 
-#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)
+        ((((unsigned long) addr) + PAGE_SIZE - 1) & PAGE_MASK)
 
-extern int kernel_fork(unsigned long flags, int (*fn)(void *), void * arg);
-extern int kernel_thread_proc(void *data);
-extern void syscall_segv(int sig);
-extern int current_pid(void);
 extern unsigned long alloc_stack(int order, int atomic);
+extern void free_stack(unsigned long stack, int order);
+
 extern int do_signal(void);
-extern int is_stack_fault(unsigned long sp);
+extern void copy_sc(struct uml_pt_regs *regs, void *from);
+extern void interrupt_end(void);
+extern void relay_signal(int sig, struct uml_pt_regs *regs);
+
 extern unsigned long segv(struct faultinfo fi, unsigned long ip,
                           int is_user, struct uml_pt_regs *regs);
 extern int handle_page_fault(unsigned long address, unsigned long ip,
                              int is_write, int is_user, int *code_out);
-extern void syscall_ready(void);
-extern void set_tracing(void *t, int tracing);
-extern int is_tracing(void *task);
-extern int segv_syscall(void);
-extern void kern_finish_exec(void *task, int new_pid, unsigned long stack);
-extern unsigned long page_mask(void);
-extern int need_finish_fork(void);
-extern void free_stack(unsigned long stack, int order);
-extern void add_input_request(int op, void (*proc)(int), void *arg);
-extern char *current_cmd(void);
-extern void timer_handler(int sig, struct uml_pt_regs *regs);
-extern int set_signals(int enable);
-extern int pid_to_processor_id(int pid);
-extern void deliver_signals(void *t);
-extern int next_trap_index(int max);
-extern void default_idle(void);
-extern void finish_fork(void);
-extern void paging_init(void);
-extern void init_flush_vm(void);
-extern void *syscall_sp(void *t);
-extern void syscall_trace(struct uml_pt_regs *regs, int entryexit);
+
 extern unsigned int do_IRQ(int irq, struct uml_pt_regs *regs);
-extern void interrupt_end(void);
-extern void initial_thread_cb(void (*proc)(void *), void *arg);
-extern int debugger_signal(int status, int pid);
-extern void debugger_parent_signal(int status, int pid);
-extern void child_signal(int pid, int status);
-extern int init_ptrace_proxy(int idle_pid, int startup, int stop);
-extern int init_parent_proxy(int pid);
-extern int singlestepping(void *t);
-extern void check_stack_overflow(void *ptr);
-extern void relay_signal(int sig, struct uml_pt_regs *regs);
-extern int user_context(unsigned long sp);
-extern void timer_irq(struct uml_pt_regs *regs);
-extern void do_uml_exitcalls(void);
-extern int attach_debugger(int idle_pid, int pid, int stop);
-extern int config_gdb(char *str);
-extern int remove_gdb(void);
-extern char *uml_strdup(char *string);
-extern void unprotect_kernel_mem(void);
-extern void protect_kernel_mem(void);
-extern void uml_cleanup(void);
-extern void lock_signalled_task(void *t);
-extern void IPI_handler(int cpu);
-extern int jail_setup(char *line, int *add);
-extern void *get_init_task(void);
-extern int clear_user_proc(void *buf, int size);
-extern int copy_to_user_proc(void *to, void *from, int size);
-extern int copy_from_user_proc(void *to, void *from, int size);
-extern int strlen_user_proc(char *str);
-extern long execute_syscall(void *r);
 extern int smp_sigio_handler(void);
-extern void *get_current(void);
-extern struct task_struct *get_task(int pid, int require);
-extern void machine_halt(void);
+extern void initial_thread_cb(void (*proc)(void *), void *arg);
 extern int is_syscall(unsigned long addr);
+extern void timer_handler(int sig, struct uml_pt_regs *regs);
 
-extern void free_irq(unsigned int, void *);
-extern int cpu(void);
+extern void timer_handler(int sig, struct uml_pt_regs *regs);
 
-extern void time_init_kern(void);
+extern int start_uml(void);
+extern void paging_init(void);
 
-/* Are we disallowed to sleep? Used to choose between GFP_KERNEL and GFP_ATOMIC. */
+extern void uml_cleanup(void);
+extern void do_uml_exitcalls(void);
+
+/*
+ * Are we disallowed to sleep? Used to choose between GFP_KERNEL and
+ * GFP_ATOMIC.
+ */
 extern int __cant_sleep(void);
-extern void sigio_handler(int sig, struct uml_pt_regs *regs);
-extern void copy_sc(struct uml_pt_regs *regs, void *from);
+extern void *get_current(void);
+extern int copy_from_user_proc(void *to, void *from, int size);
+extern int cpu(void);
+extern char *uml_strdup(const char *string);
+
 extern unsigned long to_irq_stack(unsigned long *mask_out);
-unsigned long from_irq_stack(int nested);
-extern int start_uml(void);
+extern unsigned long from_irq_stack(int nested);
+
+extern void syscall_trace(struct uml_pt_regs *regs, int entryexit);
+extern int singlestepping(void *t);
+
+extern void segv_handler(int sig, struct uml_pt_regs *regs);
+extern void bus_handler(int sig, struct uml_pt_regs *regs);
+extern void winch(int sig, struct uml_pt_regs *regs);
+extern void fatal_sigsegv(void) __attribute__ ((noreturn));
+
+
 #endif
diff --git a/arch/um/include/mem_user.h b/arch/um/include/mem_user.h
index a54514d2cc3a..46384acd547b 100644
--- a/arch/um/include/mem_user.h
+++ b/arch/um/include/mem_user.h
@@ -46,9 +46,6 @@ extern int iomem_size;
 
 #define ROUND_4M(n) ((((unsigned long) (n)) + (1 << 22)) & ~((1 << 22) - 1))
 
-extern unsigned long host_task_size;
-extern unsigned long task_size;
-
 extern int init_mem_user(void);
 extern void setup_memory(void *entry);
 extern unsigned long find_iomem(char *driver, unsigned long *len_out);
@@ -59,9 +56,7 @@ extern void setup_physmem(unsigned long start, unsigned long usable,
                           unsigned long len, unsigned long long highmem);
 extern void add_iomem(char *name, int fd, unsigned long size);
 extern unsigned long phys_offset(unsigned long phys);
-extern void unmap_physmem(void);
 extern void map_memory(unsigned long virt, unsigned long phys,
                        unsigned long len, int r, int w, int x);
-extern unsigned long get_kmem_end(void);
 
 #endif
diff --git a/arch/um/include/misc_constants.h b/arch/um/include/misc_constants.h
deleted file mode 100644
index 989bc08de36e..000000000000
--- a/arch/um/include/misc_constants.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef __MISC_CONSTANT_H_
-#define __MISC_CONSTANT_H_
-
-#include <user_constants.h>
-
-#endif
diff --git a/arch/um/include/os.h b/arch/um/include/os.h
index 6f0d1c741bca..0b6b62733303 100644
--- a/arch/um/include/os.h
+++ b/arch/um/include/os.h
@@ -8,7 +8,6 @@
 
 #include <stdarg.h>
 #include "irq_user.h"
-#include "kern_util.h"
 #include "longjmp.h"
 #include "mm_id.h"
 #include "sysdep/tls.h"
@@ -128,33 +127,31 @@ static inline struct openflags of_cloexec(struct openflags flags)
 extern int os_stat_file(const char *file_name, struct uml_stat *buf);
 extern int os_stat_fd(const int fd, struct uml_stat *buf);
 extern int os_access(const char *file, int mode);
-extern int os_get_exec_close(int fd, int *close_on_exec);
 extern int os_set_exec_close(int fd);
 extern int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg);
 extern int os_get_ifname(int fd, char *namebuf);
 extern int os_set_slip(int fd);
-extern int os_set_owner(int fd, int pid);
 extern int os_mode_fd(int fd, int mode);
 
 extern int os_seek_file(int fd, unsigned long long offset);
-extern int os_open_file(char *file, struct openflags flags, int mode);
+extern int os_open_file(const char *file, struct openflags flags, int mode);
 extern int os_read_file(int fd, void *buf, int len);
 extern int os_write_file(int fd, const void *buf, int count);
-extern int os_file_size(char *file, unsigned long long *size_out);
-extern int os_file_modtime(char *file, unsigned long *modtime);
+extern int os_file_size(const char *file, unsigned long long *size_out);
+extern int os_file_modtime(const char *file, unsigned long *modtime);
 extern int os_pipe(int *fd, int stream, int close_on_exec);
-extern int os_set_fd_async(int fd, int owner);
+extern int os_set_fd_async(int fd);
 extern int os_clear_fd_async(int fd);
 extern int os_set_fd_block(int fd, int blocking);
 extern int os_accept_connection(int fd);
-extern int os_create_unix_socket(char *file, int len, int close_on_exec);
+extern int os_create_unix_socket(const char *file, int len, int close_on_exec);
 extern int os_shutdown_socket(int fd, int r, int w);
 extern void os_close_file(int fd);
 extern int os_rcv_fd(int fd, int *helper_pid_out);
 extern int create_unix_socket(char *file, int len, int close_on_exec);
-extern int os_connect_socket(char *name);
+extern int os_connect_socket(const char *name);
 extern int os_file_type(char *file);
-extern int os_file_mode(char *file, struct openflags *mode_out);
+extern int os_file_mode(const char *file, struct openflags *mode_out);
 extern int os_lock_file(int fd, int excl);
 extern void os_flush_stdout(void);
 extern int os_stat_filesystem(char *path, long *bsize_out,
@@ -168,14 +165,10 @@ extern int os_fchange_dir(int fd);
 
 /* start_up.c */
 extern void os_early_checks(void);
-extern int can_do_skas(void);
+extern void can_do_skas(void);
 extern void os_check_bugs(void);
 extern void check_host_supports_tls(int *supports_tls, int *tls_min);
 
-/* Make sure they are clear when running in TT mode. Required by
- * SEGV_MAYBE_FIXABLE */
-#define clear_can_do_skas() do { ptrace_faultinfo = proc_mm = 0; } while (0)
-
 /* mem.c */
 extern int create_mem_file(unsigned long long len);
 
@@ -214,7 +207,7 @@ extern int execvp_noalloc(char *buf, const char *file, char *const argv[]);
 extern int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv);
 extern int run_helper_thread(int (*proc)(void *), void *arg,
                              unsigned int flags, unsigned long *stack_out);
-extern int helper_wait(int pid, int nohang, char *pname);
+extern int helper_wait(int pid);
 
 
 /* tls.c */
@@ -237,16 +230,12 @@ extern void unblock_signals(void);
 extern int get_signals(void);
 extern int set_signals(int enable);
 
-/* trap.c */
-extern void os_fill_handlinfo(struct kern_handlers h);
-
 /* util.c */
 extern void stack_protections(unsigned long address);
 extern int raw(int fd);
 extern void setup_machinename(char *machine_out);
 extern void setup_hostinfo(char *buf, int len);
-extern int setjmp_wrapper(void (*proc)(void *, void *), ...);
-extern void os_dump_core(void);
+extern void os_dump_core(void) __attribute__ ((noreturn));
 
 /* time.c */
 extern void idle_sleep(unsigned long long nsecs);
@@ -275,11 +264,9 @@ extern int protect(struct mm_id * mm_idp, unsigned long addr,
 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 save_registers(int pid, struct uml_pt_regs *regs);
-extern void restore_registers(int pid, struct uml_pt_regs *regs);
 extern void userspace(struct uml_pt_regs *regs);
-extern void map_stub_pages(int fd, unsigned long code,
-                           unsigned long data, unsigned long stack);
+extern int map_stub_pages(int fd, unsigned long code, unsigned long data,
+                          unsigned long stack);
 extern void new_thread(void *stack, jmp_buf *buf, void (*handler)(void));
 extern void switch_threads(jmp_buf *me, jmp_buf *you);
 extern int start_idle_thread(void *stack, jmp_buf *switch_buf);
@@ -298,16 +285,12 @@ extern void os_free_irq_later(struct irq_fd *active_fds,
 extern int os_get_pollfd(int i);
 extern void os_set_pollfd(int i, int fd);
 extern void os_set_ioignore(void);
-extern void init_irq_signals(int on_sigstack);
 
 /* sigio.c */
 extern int add_sigio_fd(int fd);
 extern int ignore_sigio_fd(int fd);
 extern void maybe_sigio_broken(int fd, int read);
 
-/* skas/trap */
-extern void sig_handler_common_skas(int sig, void *sc_ptr);
-
 /* sys-x86_64/prctl.c */
 extern int os_arch_prctl(int pid, int code, unsigned long *addr);
 
diff --git a/arch/um/include/ptrace_user.h b/arch/um/include/ptrace_user.h
index f3450e6bc18d..4bce6e012889 100644
--- a/arch/um/include/ptrace_user.h
+++ b/arch/um/include/ptrace_user.h
@@ -1,5 +1,5 @@
 /* 
- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
@@ -10,12 +10,6 @@
 
 extern int ptrace_getregs(long pid, unsigned long *regs_out);
 extern int ptrace_setregs(long pid, unsigned long *regs_in);
-extern int ptrace_getfpregs(long pid, unsigned long *regs_out);
-extern int ptrace_setfpregs(long pid, unsigned long *regs);
-extern void arch_enter_kernel(void *task, int pid);
-extern void arch_leave_kernel(void *task, int pid);
-extern void ptrace_pokeuser(unsigned long addr, unsigned long data);
-
 
 /* syscall emulation path in ptrace */
 
@@ -54,7 +48,8 @@ extern int sysemu_supported;
         (((int[3][3] ) { \
                 { PTRACE_SYSCALL, PTRACE_SYSCALL, PTRACE_SINGLESTEP }, \
                 { PTRACE_SYSEMU, PTRACE_SYSEMU, PTRACE_SINGLESTEP }, \
-                { PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP, PTRACE_SYSEMU_SINGLESTEP }}) \
+                { PTRACE_SYSEMU, PTRACE_SYSEMU_SINGLESTEP, \
+                  PTRACE_SYSEMU_SINGLESTEP } }) \
                 [sysemu_mode][singlestep_mode])
 
 #endif
diff --git a/arch/um/include/registers.h b/arch/um/include/registers.h
index 0e27406a43a4..9ea1ae3c8f46 100644
--- a/arch/um/include/registers.h
+++ b/arch/um/include/registers.h
@@ -9,14 +9,13 @@
 #include "sysdep/ptrace.h"
 #include "sysdep/archsetjmp.h"
 
-extern void init_thread_registers(struct uml_pt_regs *to);
 extern int save_fp_registers(int pid, unsigned long *fp_regs);
 extern int restore_fp_registers(int pid, unsigned long *fp_regs);
 extern int save_fpx_registers(int pid, unsigned long *fp_regs);
 extern int restore_fpx_registers(int pid, unsigned long *fp_regs);
-extern void save_registers(int pid, struct uml_pt_regs *regs);
-extern void restore_registers(int pid, struct uml_pt_regs *regs);
-extern void init_registers(int pid);
+extern int save_registers(int pid, struct uml_pt_regs *regs);
+extern int restore_registers(int pid, struct uml_pt_regs *regs);
+extern int init_registers(int pid);
 extern void get_safe_registers(unsigned long *regs);
 extern unsigned long get_thread_reg(int reg, jmp_buf *buf);
 
diff --git a/arch/um/include/signal_kern.h b/arch/um/include/signal_kern.h
deleted file mode 100644
index aeb5d5ab1dfd..000000000000
--- a/arch/um/include/signal_kern.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/* 
- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
- * Licensed under the GPL
- */
-
-#ifndef __SIGNAL_KERN_H__
-#define __SIGNAL_KERN_H__
-
-extern int have_signals(void *t);
-
-#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/mode-skas.h b/arch/um/include/skas/mode-skas.h
deleted file mode 100644
index e065feb000df..000000000000
--- a/arch/um/include/skas/mode-skas.h
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{linux.intel,addtoit}.com)
- * Licensed under the GPL
- */
-
-#ifndef __MODE_SKAS_H__
-#define __MODE_SKAS_H__
-
-extern void kill_off_processes_skas(void);
-
-#endif
diff --git a/arch/um/include/sysdep-i386/syscalls.h b/arch/um/include/sysdep-i386/syscalls.h
index 57bd79efbee3..905698197e35 100644
--- a/arch/um/include/sysdep-i386/syscalls.h
+++ b/arch/um/include/sysdep-i386/syscalls.h
@@ -1,5 +1,5 @@
 /* 
- * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2000 - 2008 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
@@ -18,7 +18,8 @@ extern syscall_handler_t old_mmap_i386;
 extern syscall_handler_t *sys_call_table[];
 
 #define EXECUTE_SYSCALL(syscall, regs) \
-        ((long (*)(struct syscall_args)) (*sys_call_table[syscall]))(SYSCALL_ARGS(&regs->regs))
+        ((long (*)(struct syscall_args)) \
+         (*sys_call_table[syscall]))(SYSCALL_ARGS(&regs->regs))
 
 extern long sys_mmap2(unsigned long addr, unsigned long len,
                       unsigned long prot, unsigned long flags,
diff --git a/arch/um/include/sysdep-x86_64/kernel-offsets.h b/arch/um/include/sysdep-x86_64/kernel-offsets.h
index c978b589df41..a307237b7964 100644
--- a/arch/um/include/sysdep-x86_64/kernel-offsets.h
+++ b/arch/um/include/sysdep-x86_64/kernel-offsets.h
@@ -17,16 +17,7 @@
 #define OFFSET(sym, str, mem) \
         DEFINE(sym, offsetof(struct str, mem));
 
-#define __NO_STUBS 1
-#undef __SYSCALL
-#undef _ASM_X86_64_UNISTD_H_
-#define __SYSCALL(nr, sym) [nr] = 1,
-static char syscalls[] = {
-#include <asm/arch/unistd.h>
-};
-
 void foo(void)
 {
 #include <common-offsets.h>
-DEFINE(UM_NR_syscall_max, sizeof(syscalls) - 1);
 }
diff --git a/arch/um/include/sysdep-x86_64/syscalls.h b/arch/um/include/sysdep-x86_64/syscalls.h
index cf72256609e4..7cfb0b085655 100644
--- a/arch/um/include/sysdep-x86_64/syscalls.h
+++ b/arch/um/include/sysdep-x86_64/syscalls.h
@@ -30,6 +30,4 @@ extern long old_mmap(unsigned long addr, unsigned long len,
 extern syscall_handler_t sys_modify_ldt;
 extern syscall_handler_t sys_arch_prctl;
 
-#define NR_syscalls (UM_NR_syscall_max + 1)
-
 #endif
diff --git a/arch/um/include/um_mmu.h b/arch/um/include/um_mmu.h
index 8855d8df512f..82865fcf6872 100644
--- a/arch/um/include/um_mmu.h
+++ b/arch/um/include/um_mmu.h
@@ -12,10 +12,6 @@
 
 typedef struct mm_context {
         struct mm_id id;
-        unsigned long last_page_table;
-#ifdef CONFIG_3_LEVEL_PGTABLES
-        unsigned long last_pmd;
-#endif
         struct uml_ldt ldt;
 } mm_context_t;
 
diff --git a/arch/um/include/um_uaccess.h b/arch/um/include/um_uaccess.h
index fdfc06b85605..2b6fc8e0f071 100644
--- a/arch/um/include/um_uaccess.h
+++ b/arch/um/include/um_uaccess.h
@@ -6,7 +6,9 @@
 #ifndef __ARCH_UM_UACCESS_H
 #define __ARCH_UM_UACCESS_H
 
-#include "asm/fixmap.h"
+#include <asm/elf.h>
+#include <asm/fixmap.h>
+#include "sysdep/archsetjmp.h"
 
 #define __under_task_size(addr, size) \
         (((unsigned long) (addr) < TASK_SIZE) && \
diff --git a/arch/um/kernel/exec.c b/arch/um/kernel/exec.c
index 8196450451cd..76a62c0cb2bc 100644
--- a/arch/um/kernel/exec.c
+++ b/arch/um/kernel/exec.c
@@ -19,12 +19,13 @@
 void flush_thread(void)
 {
         void *data = NULL;
-        unsigned long end = proc_mm ? task_size : STUB_START;
         int ret;
 
         arch_flush_thread(&current->thread.arch);
 
-        ret = unmap(&current->mm->context.id, 0, end, 1, &data);
+        ret = unmap(&current->mm->context.id, 0, STUB_START, 0, &data);
+        ret = ret || unmap(&current->mm->context.id, STUB_END,
+                           TASK_SIZE - STUB_END, 1, &data);
         if (ret) {
                 printk(KERN_ERR "flush_thread - clearing address space failed, "
                        "err = %d\n", ret);
diff --git a/arch/um/kernel/exitcode.c b/arch/um/kernel/exitcode.c
index c716b5a6db13..984f80e668ca 100644
--- a/arch/um/kernel/exitcode.c
+++ b/arch/um/kernel/exitcode.c
@@ -1,15 +1,17 @@
 /*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include "linux/kernel.h"
-#include "linux/init.h"
-#include "linux/ctype.h"
-#include "linux/proc_fs.h"
-#include "asm/uaccess.h"
+#include <linux/ctype.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <linux/types.h>
+#include <asm/uaccess.h>
 
-/* If read and write race, the read will still atomically read a valid
+/*
+ * If read and write race, the read will still atomically read a valid
  * value.
  */
 int uml_exitcode = 0;
@@ -19,18 +21,19 @@ static int read_proc_exitcode(char *page, char **start, off_t off,
 {
         int len, val;
 
-        /* Save uml_exitcode in a local so that we don't need to guarantee
+        /*
+         * Save uml_exitcode in a local so that we don't need to guarantee
          * that sprintf accesses it atomically.
          */
         val = uml_exitcode;
         len = sprintf(page, "%d\n", val);
         len -= off;
-        if(len <= off+count)
+        if (len <= off+count)
                 *eof = 1;
         *start = page + off;
-        if(len > count)
+        if (len > count)
                 len = count;
-        if(len < 0)
+        if (len < 0)
                 len = 0;
         return len;
 }
@@ -41,11 +44,11 @@ static int write_proc_exitcode(struct file *file, const char __user *buffer,
         char *end, buf[sizeof("nnnnn\0")];
         int tmp;
 
-        if(copy_from_user(buf, buffer, count))
+        if (copy_from_user(buf, buffer, count))
                 return -EFAULT;
 
         tmp = simple_strtol(buf, &end, 0);
-        if((*end != '\0') && !isspace(*end))
+        if ((*end != '\0') && !isspace(*end))
                 return -EINVAL;
 
         uml_exitcode = tmp;
@@ -57,7 +60,7 @@ static int make_proc_exitcode(void)
         struct proc_dir_entry *ent;
 
         ent = create_proc_entry("exitcode", 0600, &proc_root);
-        if(ent == NULL){
+        if (ent == NULL) {
                 printk(KERN_WARNING "make_proc_exitcode : Failed to register "
                        "/proc/exitcode\n");
                 return 0;
diff --git a/arch/um/kernel/gmon_syms.c b/arch/um/kernel/gmon_syms.c
index 734f873cab12..72eccd2a4113 100644
--- a/arch/um/kernel/gmon_syms.c
+++ b/arch/um/kernel/gmon_syms.c
@@ -1,5 +1,5 @@
-/* 
- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+/*
+ * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
@@ -8,12 +8,13 @@
 extern void __bb_init_func(void *)  __attribute__((weak));
 EXPORT_SYMBOL(__bb_init_func);
 
-/* This is defined (and referred to in profiling stub code) only by some GCC
+/*
+ * This is defined (and referred to in profiling stub code) only by some GCC
  * versions in libgcov.
  *
  * Since SuSE backported the fix, we cannot handle it depending on GCC version.
- * So, unconditionally export it. But also give it a weak declaration, which will
- * be overridden by any other one.
+ * So, unconditionally export it. But also give it a weak declaration, which
+ * will be overridden by any other one.
  */
 
 extern void __gcov_init(void *) __attribute__((weak));
diff --git a/arch/um/kernel/gprof_syms.c b/arch/um/kernel/gprof_syms.c
index 9244f018d44c..e2f043d0de6c 100644
--- a/arch/um/kernel/gprof_syms.c
+++ b/arch/um/kernel/gprof_syms.c
@@ -1,5 +1,5 @@
 /* 
- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
@@ -7,14 +7,3 @@
 
 extern void mcount(void);
 EXPORT_SYMBOL(mcount);
-
-/*
- * 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/initrd.c b/arch/um/kernel/initrd.c
index 16dc43e9d940..fa015565001b 100644
--- a/arch/um/kernel/initrd.c
+++ b/arch/um/kernel/initrd.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
@@ -7,7 +7,6 @@
 #include "linux/bootmem.h"
 #include "linux/initrd.h"
 #include "asm/types.h"
-#include "kern_util.h"
 #include "initrd.h"
 #include "init.h"
 #include "os.h"
@@ -21,18 +20,27 @@ static int __init read_initrd(void)
         long long size;
         int err;
 
-        if(initrd == NULL)
+        if (initrd == NULL)
                 return 0;
 
         err = os_file_size(initrd, &size);
-        if(err)
+        if (err)
                 return 0;
 
+        /*
+         * This is necessary because alloc_bootmem craps out if you
+         * ask for no memory.
+         */
+        if (size == 0) {
+                printk(KERN_ERR "\"%\" is a zero-size initrd\n");
+                return 0;
+        }
+
         area = alloc_bootmem(size);
-        if(area == NULL)
+        if (area == NULL)
                 return 0;
 
-        if(load_initrd(initrd, area, size) == -1)
+        if (load_initrd(initrd, area, size) == -1)
                 return 0;
 
         initrd_start = (unsigned long) area;
@@ -59,13 +67,15 @@ int load_initrd(char *filename, void *buf, int size)
         int fd, n;
 
         fd = os_open_file(filename, of_read(OPENFLAGS()), 0);
-        if(fd < 0){
-                printk("Opening '%s' failed - err = %d\n", filename, -fd);
+        if (fd < 0) {
+                printk(KERN_ERR "Opening '%s' failed - err = %d\n", filename,
+                       -fd);
                 return -1;
         }
         n = os_read_file(fd, buf, size);
-        if(n != size){
-                printk("Read of %d bytes from '%s' failed, err = %d\n", size,
+        if (n != size) {
+                printk(KERN_ERR "Read of %d bytes from '%s' failed, "
+                       "err = %d\n", size,
                        filename, -n);
                 return -1;
         }
diff --git a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c
index ba11ccd6a8a3..91587f8db340 100644
--- a/arch/um/kernel/irq.c
+++ b/arch/um/kernel/irq.c
@@ -107,10 +107,9 @@ int activate_fd(int irq, int fd, int type, void *dev_id)
         struct pollfd *tmp_pfd;
         struct irq_fd *new_fd, *irq_fd;
         unsigned long flags;
-        int pid, events, err, n;
+        int events, err, n;
 
-        pid = os_getpid();
-        err = os_set_fd_async(fd, pid);
+        err = os_set_fd_async(fd);
         if (err < 0)
                 goto out;
 
@@ -127,7 +126,6 @@ int activate_fd(int irq, int fd, int type, void *dev_id)
                                      .fd                = fd,
                                      .type              = type,
                                      .irq               = irq,
-                                     .pid               = pid,
                                      .events            = events,
                                      .current_events    = 0 } );
 
diff --git a/arch/um/kernel/ksyms.c b/arch/um/kernel/ksyms.c
index 7c7142ba3bd7..5311ee93ede3 100644
--- a/arch/um/kernel/ksyms.c
+++ b/arch/um/kernel/ksyms.c
@@ -18,15 +18,11 @@ EXPORT_SYMBOL(set_signals);
 EXPORT_SYMBOL(get_signals);
 EXPORT_SYMBOL(kernel_thread);
 EXPORT_SYMBOL(sys_waitpid);
-EXPORT_SYMBOL(task_size);
 EXPORT_SYMBOL(flush_tlb_range);
-EXPORT_SYMBOL(host_task_size);
 EXPORT_SYMBOL(arch_validate);
-EXPORT_SYMBOL(get_kmem_end);
 
 EXPORT_SYMBOL(high_physmem);
 EXPORT_SYMBOL(empty_zero_page);
-EXPORT_SYMBOL(um_virt_to_phys);
 EXPORT_SYMBOL(handle_page_fault);
 EXPORT_SYMBOL(find_iomem);
 
@@ -40,7 +36,6 @@ EXPORT_SYMBOL(uml_strdup);
 EXPORT_SYMBOL(os_stat_fd);
 EXPORT_SYMBOL(os_stat_file);
 EXPORT_SYMBOL(os_access);
-EXPORT_SYMBOL(os_get_exec_close);
 EXPORT_SYMBOL(os_set_exec_close);
 EXPORT_SYMBOL(os_getpid);
 EXPORT_SYMBOL(os_open_file);
diff --git a/arch/um/kernel/mem.c b/arch/um/kernel/mem.c
index 59822dee438a..d872fdce1d7e 100644
--- a/arch/um/kernel/mem.c
+++ b/arch/um/kernel/mem.c
@@ -1,49 +1,41 @@
 /*
- * Copyright (C) 2000 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include "linux/stddef.h"
-#include "linux/kernel.h"
-#include "linux/mm.h"
-#include "linux/bootmem.h"
-#include "linux/swap.h"
-#include "linux/highmem.h"
-#include "linux/gfp.h"
-#include "asm/page.h"
-#include "asm/fixmap.h"
-#include "asm/pgalloc.h"
-#include "kern_util.h"
+#include <linux/stddef.h>
+#include <linux/bootmem.h>
+#include <linux/gfp.h>
+#include <linux/highmem.h>
+#include <linux/mm.h>
+#include <linux/swap.h>
+#include <asm/fixmap.h>
+#include <asm/page.h>
 #include "as-layout.h"
+#include "init.h"
 #include "kern.h"
+#include "kern_util.h"
 #include "mem_user.h"
-#include "um_uaccess.h"
 #include "os.h"
-#include "linux/types.h"
-#include "linux/string.h"
-#include "init.h"
-#include "kern_constants.h"
 
 /* allocated in paging_init, zeroed in mem_init, and unchanged thereafter */
 unsigned long *empty_zero_page = NULL;
 /* allocated in paging_init and unchanged thereafter */
 unsigned long *empty_bad_page = NULL;
+
+/*
+ * Initialized during boot, and readonly for initializing page tables
+ * afterwards
+ */
 pgd_t swapper_pg_dir[PTRS_PER_PGD];
+
+/* Initialized at boot time, and readonly after that */
 unsigned long long highmem;
 int kmalloc_ok = 0;
 
+/* Used during early boot */
 static unsigned long brk_end;
 
-void unmap_physmem(void)
-{
-        os_unmap_memory((void *) brk_end, uml_reserved - brk_end);
-}
-
-static void map_cb(void *unused)
-{
-        map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
-}
-
 #ifdef CONFIG_HIGHMEM
 static void setup_highmem(unsigned long highmem_start,
                           unsigned long highmem_len)
@@ -53,7 +45,7 @@ static void setup_highmem(unsigned long highmem_start,
         int i;
 
         highmem_pfn = __pa(highmem_start) >> PAGE_SHIFT;
-        for(i = 0; i < highmem_len >> PAGE_SHIFT; i++){
+        for (i = 0; i < highmem_len >> PAGE_SHIFT; i++) {
                 page = &mem_map[highmem_pfn + i];
                 ClearPageReserved(page);
                 init_page_count(page);
@@ -65,14 +57,13 @@ static void setup_highmem(unsigned long highmem_start,
 void __init mem_init(void)
 {
         /* clear the zero-page */
-        memset((void *) empty_zero_page, 0, PAGE_SIZE);
+        memset(empty_zero_page, 0, PAGE_SIZE);
 
         /* Map in the area just after the brk now that kmalloc is about
          * to be turned on.
          */
         brk_end = (unsigned long) UML_ROUND_UP(sbrk(0));
-        map_cb(NULL);
-        initial_thread_cb(map_cb, NULL);
+        map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
         free_bootmem(__pa(brk_end), uml_reserved - brk_end);
         uml_reserved = brk_end;
 
@@ -85,7 +76,7 @@ void __init mem_init(void)
 #endif
         num_physpages = totalram_pages;
         max_pfn = totalram_pages;
-        printk(KERN_INFO "Memory: %luk available\n", 
+        printk(KERN_INFO "Memory: %luk available\n",
                (unsigned long) nr_free_pages() << (PAGE_SHIFT-10));
         kmalloc_ok = 1;
 
@@ -119,7 +110,7 @@ static void __init one_md_table_init(pud_t *pud)
 #endif
 }
 
-static void __init fixrange_init(unsigned long start, unsigned long end, 
+static void __init fixrange_init(unsigned long start, unsigned long end,
                                  pgd_t *pgd_base)
 {
         pgd_t *pgd;
@@ -138,7 +129,7 @@ static void __init fixrange_init(unsigned long start, unsigned long end,
                 if (pud_none(*pud))
                         one_md_table_init(pud);
                 pmd = pmd_offset(pud, vaddr);
-                for (; (j < PTRS_PER_PMD) && (vaddr != end); pmd++, j++) {
+                for (; (j < PTRS_PER_PMD) && (vaddr < end); pmd++, j++) {
                         one_page_table_init(pmd);
                         vaddr += PMD_SIZE;
                 }
@@ -152,7 +143,7 @@ pgprot_t kmap_prot;
 
 #define kmap_get_fixmap_pte(vaddr)                                      \
         pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)),\
-                          (vaddr)), (vaddr))
+                                     (vaddr)), (vaddr))
 
 static void __init kmap_init(void)
 {
@@ -197,21 +188,23 @@ static void __init fixaddr_user_init( void)
         pud_t *pud;
         pmd_t *pmd;
         pte_t *pte;
-        unsigned long paddr, vaddr = FIXADDR_USER_START;
+        phys_t p;
+        unsigned long v, vaddr = FIXADDR_USER_START;
 
-        if (  ! size )
+        if (!size)
                 return;
 
         fixrange_init( FIXADDR_USER_START, FIXADDR_USER_END, swapper_pg_dir);
-        paddr = (unsigned long)alloc_bootmem_low_pages( size);
-        memcpy( (void *)paddr, (void *)FIXADDR_USER_START, size);
-        paddr = __pa(paddr);
-        for ( ; size > 0; size-=PAGE_SIZE, vaddr+=PAGE_SIZE, paddr+=PAGE_SIZE){
+        v = (unsigned long) alloc_bootmem_low_pages(size);
+        memcpy((void *) v , (void *) FIXADDR_USER_START, size);
+        p = __pa(v);
+        for ( ; size > 0; size -= PAGE_SIZE, vaddr += PAGE_SIZE,
+                      p += PAGE_SIZE) {
                 pgd = swapper_pg_dir + pgd_index(vaddr);
                 pud = pud_offset(pgd, vaddr);
                 pmd = pmd_offset(pud, vaddr);
                 pte = pte_offset_kernel(pmd, vaddr);
-                pte_set_val( (*pte), paddr, PAGE_READONLY);
+                pte_set_val(*pte, p, PAGE_READONLY);
         }
 #endif
 }
@@ -223,7 +216,7 @@ void __init paging_init(void)
 
         empty_zero_page = (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE);
         empty_bad_page = (unsigned long *) alloc_bootmem_low_pages(PAGE_SIZE);
-        for(i = 0; i < ARRAY_SIZE(zones_size); i++)
+        for (i = 0; i < ARRAY_SIZE(zones_size); i++)
                 zones_size[i] = 0;
 
         zones_size[ZONE_NORMAL] = (end_iomem >> PAGE_SHIFT) -
@@ -253,32 +246,33 @@ struct page *arch_validate(struct page *page, gfp_t mask, int order)
         int i;
 
  again:
-        if(page == NULL)
+        if (page == NULL)
                 return page;
-        if(PageHighMem(page))
+        if (PageHighMem(page))
                 return page;
 
         addr = (unsigned long) page_address(page);
-        for(i = 0; i < (1 << order); i++){
+        for (i = 0; i < (1 << order); i++) {
                 current->thread.fault_addr = (void *) addr;
-                if(__do_copy_to_user((void __user *) addr, &zero,
+                if (__do_copy_to_user((void __user *) addr, &zero,
                                      sizeof(zero),
                                      &current->thread.fault_addr,
-                                     &current->thread.fault_catcher)){
-                        if(!(mask & __GFP_WAIT))
+                                     &current->thread.fault_catcher)) {
+                        if (!(mask & __GFP_WAIT))
                                 return NULL;
                         else break;
                 }
                 addr += PAGE_SIZE;
         }
 
-        if(i == (1 << order))
+        if (i == (1 << order))
                 return page;
         page = alloc_pages(mask, order);
         goto again;
 }
 
-/* This can't do anything because nothing in the kernel image can be freed
+/*
+ * This can't do anything because nothing in the kernel image can be freed
  * since it's not in kernel physical memory.
  */
 
@@ -290,8 +284,8 @@ void free_initmem(void)
 void free_initrd_mem(unsigned long start, unsigned long end)
 {
         if (start < end)
-                printk ("Freeing initrd memory: %ldk freed\n", 
-                        (end - start) >> 10);
+                printk(KERN_INFO "Freeing initrd memory: %ldk freed\n",
+                       (end - start) >> 10);
         for (; start < end; start += PAGE_SIZE) {
                 ClearPageReserved(virt_to_page(start));
                 init_page_count(virt_to_page(start));
@@ -308,32 +302,31 @@ void show_mem(void)
         int highmem = 0;
         struct page *page;
 
-        printk("Mem-info:\n");
+        printk(KERN_INFO "Mem-info:\n");
         show_free_areas();
-        printk("Free swap:       %6ldkB\n", nr_swap_pages<<(PAGE_SHIFT-10));
+        printk(KERN_INFO "Free swap:       %6ldkB\n",
+               nr_swap_pages<<(PAGE_SHIFT-10));
         pfn = max_mapnr;
-        while(pfn-- > 0) {
+        while (pfn-- > 0) {
                 page = pfn_to_page(pfn);
                 total++;
-                if(PageHighMem(page))
+                if (PageHighMem(page))
                         highmem++;
-                if(PageReserved(page))
+                if (PageReserved(page))
                         reserved++;
-                else if(PageSwapCache(page))
+                else if (PageSwapCache(page))
                         cached++;
-                else if(page_count(page))
+                else if (page_count(page))
                         shared += page_count(page) - 1;
         }
-        printk("%d pages of RAM\n", total);
-        printk("%d pages of HIGHMEM\n", highmem);
-        printk("%d reserved pages\n", reserved);
-        printk("%d pages shared\n", shared);
-        printk("%d pages swap cached\n", cached);
+        printk(KERN_INFO "%d pages of RAM\n", total);
+        printk(KERN_INFO "%d pages of HIGHMEM\n", highmem);
+        printk(KERN_INFO "%d reserved pages\n", reserved);
+        printk(KERN_INFO "%d pages shared\n", shared);
+        printk(KERN_INFO "%d pages swap cached\n", cached);
 }
 
-/*
- * Allocate and free page tables.
- */
+/* Allocate and free page tables. */
 
 pgd_t *pgd_alloc(struct mm_struct *mm)
 {
@@ -341,14 +334,14 @@ pgd_t *pgd_alloc(struct mm_struct *mm)
 
         if (pgd) {
                 memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
-                memcpy(pgd + USER_PTRS_PER_PGD, 
-                       swapper_pg_dir + USER_PTRS_PER_PGD, 
+                memcpy(pgd + USER_PTRS_PER_PGD,
+                       swapper_pg_dir + USER_PTRS_PER_PGD,
                        (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
         }
         return pgd;
 }
 
-void pgd_free(pgd_t *pgd)
+void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 {
         free_page((unsigned long) pgd);
 }
@@ -368,3 +361,15 @@ struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
         pte = alloc_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
         return pte;
 }
+
+#ifdef CONFIG_3_LEVEL_PGTABLES
+pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
+{
+        pmd_t *pmd = (pmd_t *) __get_free_page(GFP_KERNEL);
+
+        if (pmd)
+                memset(pmd, 0, PAGE_SIZE);
+
+        return pmd;
+}
+#endif
diff --git a/arch/um/kernel/physmem.c b/arch/um/kernel/physmem.c
index e66432f42485..9757085a0220 100644
--- a/arch/um/kernel/physmem.c
+++ b/arch/um/kernel/physmem.c
@@ -55,16 +55,6 @@ int __init init_maps(unsigned long physmem, unsigned long iomem,
         return 0;
 }
 
-/* Changed during early boot */
-static unsigned long kmem_top = 0;
-
-unsigned long get_kmem_end(void)
-{
-        if (kmem_top == 0)
-                kmem_top = host_task_size - 1024 * 1024;
-        return kmem_top;
-}
-
 void map_memory(unsigned long virt, unsigned long phys, unsigned long len,
                 int r, int w, int x)
 {
@@ -174,10 +164,10 @@ __uml_setup("iomem=", parse_iomem,
  * setup_iomem, both of which run during early boot.  Afterwards, it's
  * unchanged.
  */
-struct iomem_region *iomem_regions = NULL;
+struct iomem_region *iomem_regions;
 
-/* Initialized in parse_iomem */
-int iomem_size = 0;
+/* Initialized in parse_iomem and unchanged thereafter */
+int iomem_size;
 
 unsigned long find_iomem(char *driver, unsigned long *len_out)
 {
diff --git a/arch/um/kernel/process.c b/arch/um/kernel/process.c
index 0eae00b3e588..c07961bedb75 100644
--- a/arch/um/kernel/process.c
+++ b/arch/um/kernel/process.c
@@ -4,19 +4,21 @@
  * Licensed under the GPL
  */
 
-#include "linux/stddef.h"
-#include "linux/err.h"
-#include "linux/hardirq.h"
-#include "linux/mm.h"
-#include "linux/personality.h"
-#include "linux/proc_fs.h"
-#include "linux/ptrace.h"
-#include "linux/random.h"
-#include "linux/sched.h"
-#include "linux/tick.h"
-#include "linux/threads.h"
-#include "asm/pgtable.h"
-#include "asm/uaccess.h"
+#include <linux/stddef.h>
+#include <linux/err.h>
+#include <linux/hardirq.h>
+#include <linux/gfp.h>
+#include <linux/mm.h>
+#include <linux/personality.h>
+#include <linux/proc_fs.h>
+#include <linux/ptrace.h>
+#include <linux/random.h>
+#include <linux/sched.h>
+#include <linux/tick.h>
+#include <linux/threads.h>
+#include <asm/current.h>
+#include <asm/pgtable.h>
+#include <asm/uaccess.h>
 #include "as-layout.h"
 #include "kern_util.h"
 #include "os.h"
@@ -30,7 +32,7 @@
  */
 struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
 
-static inline int external_pid(struct task_struct *task)
+static inline int external_pid(void)
 {
         /* FIXME: Need to look up userspace_pid by cpu */
         return userspace_pid[0];
@@ -40,7 +42,7 @@ int pid_to_processor_id(int pid)
 {
         int i;
 
-        for(i = 0; i < ncpus; i++) {
+        for (i = 0; i < ncpus; i++) {
                 if (cpu_tasks[i].pid == pid)
                         return i;
         }
@@ -60,8 +62,6 @@ unsigned long alloc_stack(int order, int atomic)
         if (atomic)
                 flags = GFP_ATOMIC;
         page = __get_free_pages(flags, order);
-        if (page == 0)
-                return 0;
 
         return page;
 }
@@ -80,15 +80,15 @@ int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 static inline void set_current(struct task_struct *task)
 {
         cpu_tasks[task_thread_info(task)->cpu] = ((struct cpu_task)
-                { external_pid(task), task });
+                { external_pid(), task });
 }
 
-extern void arch_switch_to(struct task_struct *from, struct task_struct *to);
+extern void arch_switch_to(struct task_struct *to);
 
 void *_switch_to(void *prev, void *next, void *last)
 {
         struct task_struct *from = prev;
-        struct task_struct *to= next;
+        struct task_struct *to = next;
 
         to->thread.prev_sched = from;
         set_current(to);
@@ -99,13 +99,13 @@ void *_switch_to(void *prev, void *next, void *last)
                 switch_threads(&from->thread.switch_buf,
                                &to->thread.switch_buf);
 
-                arch_switch_to(current->thread.prev_sched, current);
+                arch_switch_to(current);
 
                 if (current->thread.saved_task)
                         show_regs(&(current->thread.regs));
-                next= current->thread.saved_task;
-                prev= current;
-        } while(current->thread.saved_task);
+                to = current->thread.saved_task;
+                from = current;
+        } while (current->thread.saved_task);
 
         return current->thread.prev_sched;
 
@@ -163,8 +163,6 @@ void new_thread_handler(void)
 void fork_handler(void)
 {
         force_flush_all();
-        if (current->thread.prev_sched == NULL)
-                panic("blech");
 
         schedule_tail(current->thread.prev_sched);
 
@@ -173,7 +171,7 @@ void fork_handler(void)
          * arch_switch_to isn't needed. We could want to apply this to
          * improve performance. -bb
          */
-        arch_switch_to(current->thread.prev_sched, current);
+        arch_switch_to(current);
 
         current->thread.prev_sched = NULL;
 
@@ -204,7 +202,7 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
                 arch_copy_thread(&current->thread.arch, &p->thread.arch);
         }
         else {
-                init_thread_registers(&p->thread.regs.regs);
+                get_safe_registers(p->thread.regs.regs.gp);
                 p->thread.request.u.thread = current->thread.request.u.thread;
                 handler = new_thread_handler;
         }
@@ -237,7 +235,7 @@ void default_idle(void)
 {
         unsigned long long nsecs;
 
-        while(1) {
+        while (1) {
                 /* endless idle loop with no priority at all */
 
                 /*
@@ -256,53 +254,10 @@ void default_idle(void)
 
 void cpu_idle(void)
 {
-        cpu_tasks[current_thread->cpu].pid = os_getpid();
+        cpu_tasks[current_thread_info()->cpu].pid = os_getpid();
         default_idle();
 }
 
-void *um_virt_to_phys(struct task_struct *task, unsigned long addr,
-                      pte_t *pte_out)
-{
-        pgd_t *pgd;
-        pud_t *pud;
-        pmd_t *pmd;
-        pte_t *pte;
-        pte_t ptent;
-
-        if (task->mm == NULL)
-                return ERR_PTR(-EINVAL);
-        pgd = pgd_offset(task->mm, addr);
-        if (!pgd_present(*pgd))
-                return ERR_PTR(-EINVAL);
-
-        pud = pud_offset(pgd, addr);
-        if (!pud_present(*pud))
-                return ERR_PTR(-EINVAL);
-
-        pmd = pmd_offset(pud, addr);
-        if (!pmd_present(*pmd))
-                return ERR_PTR(-EINVAL);
-
-        pte = pte_offset_kernel(pmd, addr);
-        ptent = *pte;
-        if (!pte_present(ptent))
-                return ERR_PTR(-EINVAL);
-
-        if (pte_out != NULL)
-                *pte_out = ptent;
-        return (void *) (pte_val(ptent) & PAGE_MASK) + (addr & ~PAGE_MASK);
-}
-
-char *current_cmd(void)
-{
-#if defined(CONFIG_SMP) || defined(CONFIG_HIGHMEM)
-        return "(Unknown)";
-#else
-        void *addr = um_virt_to_phys(current, current->mm->arg_start, NULL);
-        return IS_ERR(addr) ? "(Unknown)": __va((unsigned long) addr);
-#endif
-}
-
 void dump_thread(struct pt_regs *regs, struct user *u)
 {
 }
@@ -317,7 +272,7 @@ int user_context(unsigned long sp)
         unsigned long stack;
 
         stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
-        return stack != (unsigned long) current_thread;
+        return stack != (unsigned long) current_thread_info();
 }
 
 extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
@@ -331,7 +286,7 @@ void do_uml_exitcalls(void)
                 (*call)();
 }
 
-char *uml_strdup(char *string)
+char *uml_strdup(const char *string)
 {
         return kstrdup(string, GFP_KERNEL);
 }
@@ -359,7 +314,7 @@ int strlen_user_proc(char __user *str)
 int smp_sigio_handler(void)
 {
 #ifdef CONFIG_SMP
-        int cpu = current_thread->cpu;
+        int cpu = current_thread_info()->cpu;
         IPI_handler(cpu);
         if (cpu != 0)
                 return 1;
@@ -369,7 +324,7 @@ int smp_sigio_handler(void)
 
 int cpu(void)
 {
-        return current_thread->cpu;
+        return current_thread_info()->cpu;
 }
 
 static atomic_t using_sysemu = ATOMIC_INIT(0);
@@ -435,7 +390,7 @@ int singlestepping(void * t)
 {
         struct task_struct *task = t ? t : current;
 
-        if ( ! (task->ptrace & PT_DTRACE) )
+        if (!(task->ptrace & PT_DTRACE))
                 return 0;
 
         if (task->thread.singlestep_syscall)
@@ -459,3 +414,46 @@ unsigned long arch_align_stack(unsigned long sp)
         return sp & ~0xf;
 }
 #endif
+
+unsigned long get_wchan(struct task_struct *p)
+{
+        unsigned long stack_page, sp, ip;
+        bool seen_sched = 0;
+
+        if ((p == NULL) || (p == current) || (p->state == TASK_RUNNING))
+                return 0;
+
+        stack_page = (unsigned long) task_stack_page(p);
+        /* Bail if the process has no kernel stack for some reason */
+        if (stack_page == 0)
+                return 0;
+
+        sp = p->thread.switch_buf->JB_SP;
+        /*
+         * Bail if the stack pointer is below the bottom of the kernel
+         * stack for some reason
+         */
+        if (sp < stack_page)
+                return 0;
+
+        while (sp < stack_page + THREAD_SIZE) {
+                ip = *((unsigned long *) sp);
+                if (in_sched_functions(ip))
+                        /* Ignore everything until we're above the scheduler */
+                        seen_sched = 1;
+                else if (kernel_text_address(ip) && seen_sched)
+                        return ip;
+
+                sp += sizeof(unsigned long);
+        }
+
+        return 0;
+}
+
+int elf_core_copy_fpregs(struct task_struct *t, elf_fpregset_t *fpu)
+{
+        int cpu = current_thread_info()->cpu;
+
+        return save_fp_registers(userspace_pid[cpu], (unsigned long *) fpu);
+}
+
diff --git a/arch/um/kernel/reboot.c b/arch/um/kernel/reboot.c
index 04cebcf0679f..00197d3d21ec 100644
--- a/arch/um/kernel/reboot.c
+++ b/arch/um/kernel/reboot.c
@@ -4,6 +4,7 @@
  */
 
 #include "linux/sched.h"
+#include "kern_util.h"
 #include "os.h"
 #include "skas.h"
 
@@ -11,7 +12,7 @@ void (*pm_power_off)(void);
 
 static void kill_off_processes(void)
 {
-        if(proc_mm)
+        if (proc_mm)
                 /*
                  * FIXME: need to loop over userspace_pids
                  */
@@ -21,8 +22,8 @@ static void kill_off_processes(void)
                 int pid, me;
 
                 me = os_getpid();
-                for_each_process(p){
-                        if(p->mm == NULL)
+                for_each_process(p) {
+                        if (p->mm == NULL)
                                 continue;
 
                         pid = p->mm->context.id.u.pid;
diff --git a/arch/um/kernel/sigio.c b/arch/um/kernel/sigio.c
index 89f9866a1354..2b272b63b514 100644
--- a/arch/um/kernel/sigio.c
+++ b/arch/um/kernel/sigio.c
@@ -1,18 +1,12 @@
 /*
- * Copyright (C) 2002 - 2003 Jeff Dike (jdike@addtoit.com)
+ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{linux.intel,addtoit}.com)
  * Licensed under the GPL
  */
 
-#include "linux/kernel.h"
-#include "linux/list.h"
-#include "linux/slab.h"
-#include "linux/signal.h"
-#include "linux/interrupt.h"
-#include "init.h"
-#include "sigio.h"
-#include "irq_user.h"
+#include <linux/interrupt.h>
 #include "irq_kern.h"
 #include "os.h"
+#include "sigio.h"
 
 /* Protected by sigio_lock() called from write_sigio_workaround */
 static int sigio_irq_fd = -1;
@@ -33,9 +27,9 @@ int write_sigio_irq(int fd)
         err = um_request_irq(SIGIO_WRITE_IRQ, fd, IRQ_READ, sigio_interrupt,
                              IRQF_DISABLED|IRQF_SAMPLE_RANDOM, "write sigio",
                              NULL);
-        if(err){
-                printk("write_sigio_irq : um_request_irq failed, err = %d\n",
-                       err);
+        if (err) {
+                printk(KERN_ERR "write_sigio_irq : um_request_irq failed, "
+                       "err = %d\n", err);
                 return -1;
         }
         sigio_irq_fd = fd;
diff --git a/arch/um/kernel/signal.c b/arch/um/kernel/signal.c
index 19cb97733937..b0fce720c4d0 100644
--- a/arch/um/kernel/signal.c
+++ b/arch/um/kernel/signal.c
@@ -3,12 +3,12 @@
  * Licensed under the GPL
  */
 
-#include "linux/module.h"
-#include "linux/ptrace.h"
-#include "linux/sched.h"
-#include "asm/siginfo.h"
-#include "asm/signal.h"
-#include "asm/unistd.h"
+#include <linux/module.h>
+#include <linux/ptrace.h>
+#include <linux/sched.h>
+#include <asm/siginfo.h>
+#include <asm/signal.h>
+#include <asm/unistd.h>
 #include "frame_kern.h"
 #include "kern_util.h"
 #include "sigcontext.h"
@@ -36,7 +36,7 @@ static int handle_signal(struct pt_regs *regs, unsigned long signr,
         /* Did we come from a system call? */
         if (PT_REGS_SYSCALL_NR(regs) >= 0) {
                 /* If so, check system call restarting.. */
-                switch(PT_REGS_SYSCALL_RET(regs)) {
+                switch (PT_REGS_SYSCALL_RET(regs)) {
                 case -ERESTART_RESTARTBLOCK:
                 case -ERESTARTNOHAND:
                         PT_REGS_SYSCALL_RET(regs) = -EINTR;
@@ -116,7 +116,7 @@ static int kern_do_signal(struct pt_regs *regs)
         /* Did we come from a system call? */
         if (!handled_sig && (PT_REGS_SYSCALL_NR(regs) >= 0)) {
                 /* Restart the system call - no handlers present */
-                switch(PT_REGS_SYSCALL_RET(regs)) {
+                switch (PT_REGS_SYSCALL_RET(regs)) {
                 case -ERESTARTNOHAND:
                 case -ERESTARTSYS:
                 case -ERESTARTNOINTR:
diff --git a/arch/um/kernel/skas/clone.c b/arch/um/kernel/skas/clone.c
index 8d07a7acb909..2c8583c1a344 100644
--- a/arch/um/kernel/skas/clone.c
+++ b/arch/um/kernel/skas/clone.c
@@ -1,17 +1,20 @@
-#include <sched.h>
+/*
+ * Copyright (C) 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
+ * Licensed under the GPL
+ */
+
 #include <signal.h>
-#include <sys/mman.h>
-#include <sys/time.h>
+#include <sched.h>
 #include <asm/unistd.h>
+#include <sys/time.h>
 #include "as-layout.h"
+#include "kern_constants.h"
 #include "ptrace_user.h"
-#include "skas.h"
 #include "stub-data.h"
-#include "uml-config.h"
 #include "sysdep/stub.h"
-#include "kern_constants.h"
 
-/* This is in a separate file because it needs to be compiled with any
+/*
+ * This is in a separate file because it needs to be compiled with any
  * extraneous gcc flags (-pg, -fprofile-arcs, -ftest-coverage) disabled
  *
  * Use UM_KERN_PAGE_SIZE instead of PAGE_SIZE because that calls getpagesize
@@ -26,25 +29,26 @@ stub_clone_handler(void)
 
         err = stub_syscall2(__NR_clone, CLONE_PARENT | CLONE_FILES | SIGCHLD,
                             STUB_DATA + UM_KERN_PAGE_SIZE / 2 - sizeof(void *));
-        if(err != 0)
+        if (err != 0)
                 goto out;
 
         err = stub_syscall4(__NR_ptrace, PTRACE_TRACEME, 0, 0, 0);
-        if(err)
+        if (err)
                 goto out;
 
-        err = stub_syscall3(__NR_setitimer, ITIMER_VIRTUAL, 
+        err = stub_syscall3(__NR_setitimer, ITIMER_VIRTUAL,
                             (long) &data->timer, 0);
-        if(err)
+        if (err)
                 goto out;
 
         remap_stack(data->fd, data->offset);
         goto done;
 
  out:
-        /* save current result. 
-         * Parent: pid; 
-         * child: retcode of mmap already saved and it jumps around this 
+        /*
+         * save current result.
+         * Parent: pid;
+         * child: retcode of mmap already saved and it jumps around this
          * assignment
          */
         data->err = err;
diff --git a/arch/um/kernel/skas/mmu.c b/arch/um/kernel/skas/mmu.c
index f859ec306cd5..78b3e9f69d57 100644
--- a/arch/um/kernel/skas/mmu.c
+++ b/arch/um/kernel/skas/mmu.c
@@ -34,33 +34,14 @@ static int init_stub_pte(struct mm_struct *mm, unsigned long proc,
         if (!pte)
                 goto out_pte;
 
-        /*
-         * There's an interaction between the skas0 stub pages, stack
-         * randomization, and the BUG at the end of exit_mmap.  exit_mmap
-         * checks that the number of page tables freed is the same as had
-         * been allocated.  If the stack is on the last page table page,
-         * then the stack pte page will be freed, and if not, it won't.  To
-         * avoid having to know where the stack is, or if the process mapped
-         * something at the top of its address space for some other reason,
-         * we set TASK_SIZE to end at the start of the last page table.
-         * This keeps exit_mmap off the last page, but introduces a leak
-         * of that page.  So, we hang onto it here and free it in
-         * destroy_context_skas.
-         */
-
-        mm->context.last_page_table = pmd_page_vaddr(*pmd);
-#ifdef CONFIG_3_LEVEL_PGTABLES
-        mm->context.last_pmd = (unsigned long) __va(pud_val(*pud));
-#endif
-
         *pte = mk_pte(virt_to_page(kernel), __pgprot(_PAGE_PRESENT));
         *pte = pte_mkread(*pte);
         return 0;
 
  out_pmd:
-        pud_free(pud);
+        pud_free(mm, pud);
  out_pte:
-        pmd_free(pmd);
+        pmd_free(mm, pmd);
  out:
         return -ENOMEM;
 }
@@ -76,24 +57,6 @@ int init_new_context(struct task_struct *task, struct mm_struct *mm)
                 stack = get_zeroed_page(GFP_KERNEL);
                 if (stack == 0)
                         goto out;
-
-                /*
-                 * This zeros the entry that pgd_alloc didn't, needed since
-                 * we are about to reinitialize it, and want mm.nr_ptes to
-                 * be accurate.
-                 */
-                mm->pgd[USER_PTRS_PER_PGD] = __pgd(0);
-
-                ret = init_stub_pte(mm, STUB_CODE,
-                                    (unsigned long) &__syscall_stub_start);
-                if (ret)
-                        goto out_free;
-
-                ret = init_stub_pte(mm, STUB_DATA, stack);
-                if (ret)
-                        goto out_free;
-
-                mm->nr_ptes--;
         }
 
         to_mm->id.stack = stack;
@@ -114,6 +77,11 @@ int init_new_context(struct task_struct *task, struct mm_struct *mm)
                         to_mm->id.u.pid = copy_context_skas0(stack,
                                                              from_mm->id.u.pid);
                 else to_mm->id.u.pid = start_userspace(stack);
+
+                if (to_mm->id.u.pid < 0) {
+                        ret = to_mm->id.u.pid;
+                        goto out_free;
+                }
         }
 
         ret = init_new_ldt(to_mm, from_mm);
@@ -132,24 +100,87 @@ int init_new_context(struct task_struct *task, struct mm_struct *mm)
         return ret;
 }
 
+void arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
+{
+        struct page **pages;
+        int err, ret;
+
+        if (!skas_needs_stub)
+                return;
+
+        ret = init_stub_pte(mm, STUB_CODE,
+                            (unsigned long) &__syscall_stub_start);
+        if (ret)
+                goto out;
+
+        ret = init_stub_pte(mm, STUB_DATA, mm->context.id.stack);
+        if (ret)
+                goto out;
+
+        pages = kmalloc(2 * sizeof(struct page *), GFP_KERNEL);
+        if (pages == NULL) {
+                printk(KERN_ERR "arch_dup_mmap failed to allocate 2 page "
+                       "pointers\n");
+                goto out;
+        }
+
+        pages[0] = virt_to_page(&__syscall_stub_start);
+        pages[1] = virt_to_page(mm->context.id.stack);
+
+        /* dup_mmap already holds mmap_sem */
+        err = install_special_mapping(mm, STUB_START, STUB_END - STUB_START,
+                                      VM_READ | VM_MAYREAD | VM_EXEC |
+                                      VM_MAYEXEC | VM_DONTCOPY, pages);
+        if (err) {
+                printk(KERN_ERR "install_special_mapping returned %d\n", err);
+                goto out_free;
+        }
+        return;
+
+out_free:
+        kfree(pages);
+out:
+        force_sigsegv(SIGSEGV, current);
+}
+
+void arch_exit_mmap(struct mm_struct *mm)
+{
+        pte_t *pte;
+
+        pte = virt_to_pte(mm, STUB_CODE);
+        if (pte != NULL)
+                pte_clear(mm, STUB_CODE, pte);
+
+        pte = virt_to_pte(mm, STUB_DATA);
+        if (pte == NULL)
+                return;
+
+        pte_clear(mm, STUB_DATA, pte);
+}
+
 void destroy_context(struct mm_struct *mm)
 {
         struct mm_context *mmu = &mm->context;
 
         if (proc_mm)
                 os_close_file(mmu->id.u.mm_fd);
-        else
+        else {
+                /*
+                 * If init_new_context wasn't called, this will be
+                 * zero, resulting in a kill(0), which will result in the
+                 * whole UML suddenly dying.  Also, cover negative and
+                 * 1 cases, since they shouldn't happen either.
+                 */
+                if (mmu->id.u.pid < 2) {
+                        printk(KERN_ERR "corrupt mm_context - pid = %d\n",
+                               mmu->id.u.pid);
+                        return;
+                }
                 os_kill_ptraced_process(mmu->id.u.pid, 1);
+        }
 
-        if (!proc_mm || !ptrace_faultinfo) {
+        if (skas_needs_stub)
                 free_page(mmu->id.stack);
-                pte_lock_deinit(virt_to_page(mmu->last_page_table));
-                pte_free_kernel((pte_t *) mmu->last_page_table);
-                dec_zone_page_state(virt_to_page(mmu->last_page_table), NR_PAGETABLE);
-#ifdef CONFIG_3_LEVEL_PGTABLES
-                pmd_free((pmd_t *) mmu->last_pmd);
-#endif
-        }
 
         free_ldt(mmu);
 }
diff --git a/arch/um/kernel/skas/process.c b/arch/um/kernel/skas/process.c
index fce389c2342f..2e9852c0d487 100644
--- a/arch/um/kernel/skas/process.c
+++ b/arch/um/kernel/skas/process.c
@@ -6,19 +6,25 @@
 #include "linux/init.h"
 #include "linux/sched.h"
 #include "as-layout.h"
+#include "kern.h"
 #include "os.h"
 #include "skas.h"
 
 int new_mm(unsigned long stack)
 {
-        int fd;
+        int fd, err;
 
         fd = os_open_file("/proc/mm", of_cloexec(of_write(OPENFLAGS())), 0);
         if (fd < 0)
                 return fd;
 
-        if (skas_needs_stub)
-                map_stub_pages(fd, STUB_CODE, STUB_DATA, stack);
+        if (skas_needs_stub) {
+                err = map_stub_pages(fd, STUB_CODE, STUB_DATA, stack);
+                if (err) {
+                        os_close_file(fd);
+                        return err;
+                }
+        }
 
         return fd;
 }
@@ -49,8 +55,14 @@ int __init start_uml(void)
 {
         stack_protections((unsigned long) &cpu0_irqstack);
         set_sigstack(cpu0_irqstack, THREAD_SIZE);
-        if (proc_mm)
+        if (proc_mm) {
                 userspace_pid[0] = start_userspace(0);
+                if (userspace_pid[0] < 0) {
+                        printf("start_uml - start_userspace returned %d\n",
+                               userspace_pid[0]);
+                        exit(1);
+                }
+        }
 
         init_new_thread_signals();
 
diff --git a/arch/um/kernel/skas/syscall.c b/arch/um/kernel/skas/syscall.c
index 50b476f2b38d..4e3b820bd2be 100644
--- a/arch/um/kernel/skas/syscall.c
+++ b/arch/um/kernel/skas/syscall.c
@@ -9,6 +9,9 @@
 #include "sysdep/ptrace.h"
 #include "sysdep/syscalls.h"
 
+extern int syscall_table_size;
+#define NR_syscalls (syscall_table_size / sizeof(void *))
+
 void handle_syscall(struct uml_pt_regs *r)
 {
         struct pt_regs *regs = container_of(r, struct pt_regs, regs);
@@ -17,9 +20,6 @@ void handle_syscall(struct uml_pt_regs *r)
 
         syscall_trace(r, 0);
 
-        current->thread.nsyscalls++;
-        nsyscalls++;
-
         /*
          * This should go in the declaration of syscall, but when I do that,
          * strace -f -c bash -c 'ls ; ls' breaks, sometimes not tracing
diff --git a/arch/um/kernel/skas/uaccess.c b/arch/um/kernel/skas/uaccess.c
index 1d8b119f2d0e..e22c96993db3 100644
--- a/arch/um/kernel/skas/uaccess.c
+++ b/arch/um/kernel/skas/uaccess.c
@@ -3,128 +3,130 @@
  * Licensed under the GPL
  */
 
-#include "linux/err.h"
-#include "linux/highmem.h"
-#include "linux/mm.h"
-#include "asm/current.h"
-#include "asm/page.h"
-#include "asm/pgtable.h"
+#include <linux/err.h>
+#include <linux/highmem.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <asm/current.h>
+#include <asm/page.h>
+#include <asm/pgtable.h>
 #include "kern_util.h"
 #include "os.h"
 
-extern void *um_virt_to_phys(struct task_struct *task, unsigned long addr,
-                             pte_t *pte_out);
-
-static unsigned long maybe_map(unsigned long virt, int is_write)
+pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr)
 {
-        pte_t pte;
-        int err;
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+
+        if (mm == NULL)
+                return NULL;
+
+        pgd = pgd_offset(mm, addr);
+        if (!pgd_present(*pgd))
+                return NULL;
+
+        pud = pud_offset(pgd, addr);
+        if (!pud_present(*pud))
+                return NULL;
 
-        void *phys = um_virt_to_phys(current, virt, &pte);
-        int dummy_code;
+        pmd = pmd_offset(pud, addr);
+        if (!pmd_present(*pmd))
+                return NULL;
+
+        return pte_offset_kernel(pmd, addr);
+}
+
+static pte_t *maybe_map(unsigned long virt, int is_write)
+{
+        pte_t *pte = virt_to_pte(current->mm, virt);
+        int err, dummy_code;
 
-        if (IS_ERR(phys) || (is_write && !pte_write(pte))) {
+        if ((pte == NULL) || !pte_present(*pte) ||
+            (is_write && !pte_write(*pte))) {
                 err = handle_page_fault(virt, 0, is_write, 1, &dummy_code);
                 if (err)
-                        return -1UL;
-                phys = um_virt_to_phys(current, virt, NULL);
+                        return NULL;
+                pte = virt_to_pte(current->mm, virt);
         }
-        if (IS_ERR(phys))
-                phys = (void *) -1;
+        if (!pte_present(*pte))
+                pte = NULL;
 
-        return (unsigned long) phys;
+        return pte;
 }
 
 static int do_op_one_page(unsigned long addr, int len, int is_write,
                  int (*op)(unsigned long addr, int len, void *arg), void *arg)
 {
+        jmp_buf buf;
         struct page *page;
-        int n;
+        pte_t *pte;
+        int n, faulted;
 
-        addr = maybe_map(addr, is_write);
-        if (addr == -1UL)
+        pte = maybe_map(addr, is_write);
+        if (pte == NULL)
                 return -1;
 
-        page = phys_to_page(addr);
+        page = pte_page(*pte);
         addr = (unsigned long) kmap_atomic(page, KM_UML_USERCOPY) +
                 (addr & ~PAGE_MASK);
 
-        n = (*op)(addr, len, arg);
+        current->thread.fault_catcher = &buf;
+
+        faulted = UML_SETJMP(&buf);
+        if (faulted == 0)
+                n = (*op)(addr, len, arg);
+        else
+                n = -1;
+
+        current->thread.fault_catcher = NULL;
 
         kunmap_atomic(page, KM_UML_USERCOPY);
 
         return n;
 }
 
-static void do_buffer_op(void *jmpbuf, void *arg_ptr)
+static int buffer_op(unsigned long addr, int len, int is_write,
+                     int (*op)(unsigned long, int, void *), void *arg)
 {
-        va_list args;
-        unsigned long addr;
-        int len, is_write, size, remain, n;
-        int (*op)(unsigned long, int, void *);
-        void *arg;
-        int *res;
-
-        va_copy(args, *(va_list *)arg_ptr);
-        addr = va_arg(args, unsigned long);
-        len = va_arg(args, int);
-        is_write = va_arg(args, int);
-        op = va_arg(args, void *);
-        arg = va_arg(args, void *);
-        res = va_arg(args, int *);
-        va_end(args);
+        int size, remain, n;
+
         size = min(PAGE_ALIGN(addr) - addr, (unsigned long) len);
         remain = len;
 
-        current->thread.fault_catcher = jmpbuf;
         n = do_op_one_page(addr, size, is_write, op, arg);
         if (n != 0) {
-                *res = (n < 0 ? remain : 0);
+                remain = (n < 0 ? remain : 0);
                 goto out;
         }
 
         addr += size;
         remain -= size;
-        if (remain == 0) {
-                *res = 0;
+        if (remain == 0)
                 goto out;
-        }
 
-        while(addr < ((addr + remain) & PAGE_MASK)) {
+        while (addr < ((addr + remain) & PAGE_MASK)) {
                 n = do_op_one_page(addr, PAGE_SIZE, is_write, op, arg);
                 if (n != 0) {
-                        *res = (n < 0 ? remain : 0);
+                        remain = (n < 0 ? remain : 0);
                         goto out;
                 }
 
                 addr += PAGE_SIZE;
                 remain -= PAGE_SIZE;
         }
-        if (remain == 0) {
-                *res = 0;
+        if (remain == 0)
                 goto out;
-        }
 
         n = do_op_one_page(addr, remain, is_write, op, arg);
-        if (n != 0)
-                *res = (n < 0 ? remain : 0);
-        else *res = 0;
- out:
-        current->thread.fault_catcher = NULL;
-}
-
-static int buffer_op(unsigned long addr, int len, int is_write,
-                     int (*op)(unsigned long addr, int len, void *arg),
-                     void *arg)
-{
-        int faulted, res;
-
-        faulted = setjmp_wrapper(do_buffer_op, addr, len, is_write, op, arg,
-                                 &res);
-        if (!faulted)
-                return res;
+        if (n != 0) {
+                remain = (n < 0 ? remain : 0);
+                goto out;
+        }
 
-        return addr + len - (unsigned long) current->thread.fault_addr;
+        return 0;
+ out:
+        return remain;
 }
 
 static int copy_chunk_from_user(unsigned long from, int len, void *arg)
diff --git a/arch/um/kernel/smp.c b/arch/um/kernel/smp.c
index 36d89cf8d20b..e1062ec36d40 100644
--- a/arch/um/kernel/smp.c
+++ b/arch/um/kernel/smp.c
@@ -21,7 +21,6 @@ DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
 #include "asm/smp.h"
 #include "asm/processor.h"
 #include "asm/spinlock.h"
-#include "kern_util.h"
 #include "kern.h"
 #include "irq_user.h"
 #include "os.h"
@@ -61,7 +60,7 @@ void smp_send_stop(void)
                         continue;
                 os_write_file(cpu_data[i].ipi_pipe[1], "S", 1);
         }
-        printk(KERN_INFO "done\n");
+        printk(KERN_CONT "done\n");
 }
 
 static cpumask_t smp_commenced_mask = CPU_MASK_NONE;
@@ -75,8 +74,7 @@ static int idle_proc(void *cpup)
         if (err < 0)
                 panic("CPU#%d failed to create IPI pipe, err = %d", cpu, -err);
 
-        os_set_fd_async(cpu_data[cpu].ipi_pipe[0],
-                     current->thread.mode.tt.extern_pid);
+        os_set_fd_async(cpu_data[cpu].ipi_pipe[0]);
 
         wmb();
         if (cpu_test_and_set(cpu, cpu_callin_map)) {
@@ -129,8 +127,7 @@ void smp_prepare_cpus(unsigned int maxcpus)
         if (err < 0)
                 panic("CPU#0 failed to create IPI pipe, errno = %d", -err);
 
-        os_set_fd_async(cpu_data[me].ipi_pipe[0],
-                     current->thread.mode.tt.extern_pid);
+        os_set_fd_async(cpu_data[me].ipi_pipe[0]);
 
         for (cpu = 1; cpu < ncpus; cpu++) {
                 printk(KERN_INFO "Booting processor %d...\n", cpu);
@@ -143,9 +140,8 @@ void smp_prepare_cpus(unsigned int maxcpus)
                 while (waittime-- && !cpu_isset(cpu, cpu_callin_map))
                         cpu_relax();
 
-                if (cpu_isset(cpu, cpu_callin_map))
-                        printk(KERN_INFO "done\n");
-                else printk(KERN_INFO "failed\n");
+                printk(KERN_INFO "%s\n",
+                       cpu_isset(cpu, cpu_calling_map) ? "done" : "failed");
         }
 }
 
diff --git a/arch/um/kernel/syscall.c b/arch/um/kernel/syscall.c
index b9d92b2089ae..9cffc628a37e 100644
--- a/arch/um/kernel/syscall.c
+++ b/arch/um/kernel/syscall.c
@@ -13,9 +13,6 @@
 #include "asm/uaccess.h"
 #include "asm/unistd.h"
 
-/*  Unlocked, I don't care if this is a bit off */
-int nsyscalls = 0;
-
 long sys_fork(void)
 {
         long ret;
diff --git a/arch/um/kernel/sysrq.c b/arch/um/kernel/sysrq.c
index 93263571d813..56d43d0a3960 100644
--- a/arch/um/kernel/sysrq.c
+++ b/arch/um/kernel/sysrq.c
@@ -1,38 +1,37 @@
-/* 
- * Copyright (C) 2001 Jeff Dike (jdike@karaya.com)
+/*
+ * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include "linux/sched.h"
-#include "linux/kernel.h"
-#include "linux/module.h"
-#include "linux/kallsyms.h"
-#include "asm/page.h"
-#include "asm/processor.h"
+#include <linux/kallsyms.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/sched.h>
 #include "sysrq.h"
 
 /* Catch non-i386 SUBARCH's. */
 #if !defined(CONFIG_UML_X86) || defined(CONFIG_64BIT)
 void show_trace(struct task_struct *task, unsigned long * stack)
 {
-        unsigned long addr;
+        unsigned long addr;
 
-        if (!stack) {
+        if (!stack) {
                 stack = (unsigned long*) &stack;
                 WARN_ON(1);
         }
 
-        printk("Call Trace: \n");
-        while (((long) stack & (THREAD_SIZE-1)) != 0) {
-                addr = *stack;
+        printk(KERN_INFO "Call Trace: \n");
+        while (((long) stack & (THREAD_SIZE-1)) != 0) {
+                addr = *stack;
                 if (__kernel_text_address(addr)) {
-                        printk("%08lx:  [<%08lx>]", (unsigned long) stack, addr);
-                        print_symbol(" %s", addr);
-                        printk("\n");
-                }
-                stack++;
-        }
-        printk("\n");
+                        printk(KERN_INFO "%08lx:  [<%08lx>]",
+                               (unsigned long) stack, addr);
+                        print_symbol(KERN_CONT " %s", addr);
+                        printk(KERN_CONT "\n");
+                }
+                stack++;
+        }
+        printk(KERN_INFO "\n");
 }
 #endif
 
@@ -67,14 +66,13 @@ void show_stack(struct task_struct *task, unsigned long *esp)
         }
 
         stack = esp;
-        for(i = 0; i < kstack_depth_to_print; i++) {
+        for (i = 0; i < kstack_depth_to_print; i++) {
                 if (kstack_end(stack))
                         break;
                 if (i && ((i % 8) == 0))
-                        printk("\n       ");
+                        printk("\n" KERN_INFO "       ");
                 printk("%08lx ", *stack++);
         }
 
-        printk("Call Trace: \n");
         show_trace(task, esp);
 }
diff --git a/arch/um/kernel/time.c b/arch/um/kernel/time.c
index 1ac746a9eae1..e066e84493b1 100644
--- a/arch/um/kernel/time.c
+++ b/arch/um/kernel/time.c
@@ -3,12 +3,12 @@
  * Licensed under the GPL
  */
 
-#include "linux/clockchips.h"
-#include "linux/interrupt.h"
-#include "linux/jiffies.h"
-#include "linux/threads.h"
-#include "asm/irq.h"
-#include "asm/param.h"
+#include <linux/clockchips.h>
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/threads.h>
+#include <asm/irq.h>
+#include <asm/param.h>
 #include "kern_util.h"
 #include "os.h"
 
@@ -32,7 +32,7 @@ void timer_handler(int sig, struct uml_pt_regs *regs)
 static void itimer_set_mode(enum clock_event_mode mode,
                             struct clock_event_device *evt)
 {
-        switch(mode) {
+        switch (mode) {
         case CLOCK_EVT_MODE_PERIODIC:
                 set_interval();
                 break;
diff --git a/arch/um/kernel/tlb.c b/arch/um/kernel/tlb.c
index f4a0e407eee4..d175d0566af0 100644
--- a/arch/um/kernel/tlb.c
+++ b/arch/um/kernel/tlb.c
@@ -3,9 +3,10 @@
  * Licensed under the GPL
  */
 
-#include "linux/mm.h"
-#include "asm/pgtable.h"
-#include "asm/tlbflush.h"
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <asm/pgtable.h>
+#include <asm/tlbflush.h>
 #include "as-layout.h"
 #include "mem_user.h"
 #include "os.h"
@@ -56,7 +57,7 @@ static int do_ops(struct host_vm_change *hvc, int end,
 
         for (i = 0; i < end && !ret; i++) {
                 op = &hvc->ops[i];
-                switch(op->type) {
+                switch (op->type) {
                 case MMAP:
                         ret = map(hvc->id, op->u.mmap.addr, op->u.mmap.len,
                                   op->u.mmap.prot, op->u.mmap.fd,
@@ -183,27 +184,30 @@ static inline int update_pte_range(pmd_t *pmd, unsigned long addr,
 
         pte = pte_offset_kernel(pmd, addr);
         do {
+                if ((addr >= STUB_START) && (addr < STUB_END))
+                        continue;
+
                 r = pte_read(*pte);
                 w = pte_write(*pte);
                 x = pte_exec(*pte);
                 if (!pte_young(*pte)) {
                         r = 0;
                         w = 0;
-                } else if (!pte_dirty(*pte)) {
+                } else if (!pte_dirty(*pte))
                         w = 0;
-                }
+
                 prot = ((r ? UM_PROT_READ : 0) | (w ? UM_PROT_WRITE : 0) |
                         (x ? UM_PROT_EXEC : 0));
                 if (hvc->force || pte_newpage(*pte)) {
                         if (pte_present(*pte))
                                 ret = add_mmap(addr, pte_val(*pte) & PAGE_MASK,
                                                PAGE_SIZE, prot, hvc);
-                        else ret = add_munmap(addr, PAGE_SIZE, hvc);
-                }
-                else if (pte_newprot(*pte))
+                        else
+                                ret = add_munmap(addr, PAGE_SIZE, hvc);
+                } else if (pte_newprot(*pte))
                         ret = add_mprotect(addr, PAGE_SIZE, prot, hvc);
                 *pte = pte_mkuptodate(*pte);
-        } while (pte++, addr += PAGE_SIZE, ((addr != end) && !ret));
+        } while (pte++, addr += PAGE_SIZE, ((addr < end) && !ret));
         return ret;
 }
 
@@ -225,7 +229,7 @@ static inline int update_pmd_range(pud_t *pud, unsigned long addr,
                         }
                 }
                 else ret = update_pte_range(pmd, addr, next, hvc);
-        } while (pmd++, addr = next, ((addr != end) && !ret));
+        } while (pmd++, addr = next, ((addr < end) && !ret));
         return ret;
 }
 
@@ -247,7 +251,7 @@ static inline int update_pud_range(pgd_t *pgd, unsigned long addr,
                         }
                 }
                 else ret = update_pmd_range(pud, addr, next, hvc);
-        } while (pud++, addr = next, ((addr != end) && !ret));
+        } while (pud++, addr = next, ((addr < end) && !ret));
         return ret;
 }
 
@@ -270,7 +274,7 @@ void fix_range_common(struct mm_struct *mm, unsigned long start_addr,
                         }
                 }
                 else ret = update_pud_range(pgd, addr, next, &hvc);
-        } while (pgd++, addr = next, ((addr != end_addr) && !ret));
+        } while (pgd++, addr = next, ((addr < end_addr) && !ret));
 
         if (!ret)
                 ret = do_ops(&hvc, hvc.index, 1);
@@ -485,9 +489,6 @@ void __flush_tlb_one(unsigned long addr)
 static void fix_range(struct mm_struct *mm, unsigned long start_addr,
                       unsigned long end_addr, int force)
 {
-        if (!proc_mm && (end_addr > STUB_START))
-                end_addr = STUB_START;
-
         fix_range_common(mm, start_addr, end_addr, force);
 }
 
@@ -499,10 +500,9 @@ void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
         else fix_range(vma->vm_mm, start, end, 0);
 }
 
-void flush_tlb_mm(struct mm_struct *mm)
+void flush_tlb_mm_range(struct mm_struct *mm, unsigned long start,
+                        unsigned long end)
 {
-        unsigned long end;
-
         /*
          * Don't bother flushing if this address space is about to be
          * destroyed.
@@ -510,8 +510,17 @@ void flush_tlb_mm(struct mm_struct *mm)
         if (atomic_read(&mm->mm_users) == 0)
                 return;
 
-        end = proc_mm ? task_size : STUB_START;
-        fix_range(mm, 0, end, 0);
+        fix_range(mm, start, end, 0);
+}
+
+void flush_tlb_mm(struct mm_struct *mm)
+{
+        struct vm_area_struct *vma = mm->mmap;
+
+        while (vma != NULL) {
+                fix_range(mm, vma->vm_start, vma->vm_end, 0);
+                vma = vma->vm_next;
+        }
 }
 
 void force_flush_all(void)
diff --git a/arch/um/kernel/trap.c b/arch/um/kernel/trap.c
index cb3321f8e0a9..44e490419495 100644
--- a/arch/um/kernel/trap.c
+++ b/arch/um/kernel/trap.c
@@ -13,6 +13,7 @@
 #include "as-layout.h"
 #include "kern_util.h"
 #include "os.h"
+#include "skas.h"
 #include "sysdep/sigcontext.h"
 
 /*
@@ -128,7 +129,19 @@ static void bad_segv(struct faultinfo fi, unsigned long ip)
         force_sig_info(SIGSEGV, &si, current);
 }
 
-static void segv_handler(int sig, struct uml_pt_regs *regs)
+void fatal_sigsegv(void)
+{
+        force_sigsegv(SIGSEGV, current);
+        do_signal();
+        /*
+         * This is to tell gcc that we're not returning - do_signal
+         * can, in general, return, but in this case, it's not, since
+         * we just got a fatal SIGSEGV queued.
+         */
+        os_dump_core();
+}
+
+void segv_handler(int sig, struct uml_pt_regs *regs)
 {
         struct faultinfo * fi = UPT_FAULTINFO(regs);
 
@@ -216,9 +229,6 @@ unsigned long segv(struct faultinfo fi, unsigned long ip, int is_user,
 
 void relay_signal(int sig, struct uml_pt_regs *regs)
 {
-        if (arch_handle_signal(sig, regs))
-                return;
-
         if (!UPT_IS_USER(regs)) {
                 if (sig == SIGBUS)
                         printk(KERN_ERR "Bus error - the host /dev/shm or /tmp "
@@ -226,31 +236,24 @@ void relay_signal(int sig, struct uml_pt_regs *regs)
                 panic("Kernel mode signal %d", sig);
         }
 
+        arch_examine_signal(sig, regs);
+
         current->thread.arch.faultinfo = *UPT_FAULTINFO(regs);
         force_sig(sig, current);
 }
 
-static void bus_handler(int sig, struct uml_pt_regs *regs)
+void bus_handler(int sig, struct uml_pt_regs *regs)
 {
         if (current->thread.fault_catcher != NULL)
                 UML_LONGJMP(current->thread.fault_catcher, 1);
         else relay_signal(sig, regs);
 }
 
-static void winch(int sig, struct uml_pt_regs *regs)
+void winch(int sig, struct uml_pt_regs *regs)
 {
         do_IRQ(WINCH_IRQ, regs);
 }
 
-const struct kern_handlers handlinfo_kern = {
-        .relay_signal = relay_signal,
-        .winch = winch,
-        .bus_handler = bus_handler,
-        .page_fault = segv_handler,
-        .sigio_handler = sigio_handler,
-        .timer_handler = timer_handler
-};
-
 void trap_init(void)
 {
 }
diff --git a/arch/um/kernel/uaccess.c b/arch/um/kernel/uaccess.c
index d7436aacd26f..f0f4b040d7c5 100644
--- a/arch/um/kernel/uaccess.c
+++ b/arch/um/kernel/uaccess.c
@@ -1,10 +1,11 @@
 /*
  * Copyright (C) 2001 Chris Emerson (cemerson@chiark.greenend.org.uk)
- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-/* These are here rather than tt/uaccess.c because skas mode needs them in
+/*
+ * These are here rather than tt/uaccess.c because skas mode needs them in
  * order to do SIGBUS recovery when a tmpfs mount runs out of room.
  */
 
@@ -25,6 +26,8 @@ int __do_copy_to_user(void *to, const void *from, int n,
 
         fault = __do_user_copy(to, from, n, fault_addr, fault_catcher,
                                __do_copy, &faulted);
-        if(!faulted) return(0);
-        else return(n - (fault - (unsigned long) to));
+        if (!faulted)
+                return 0;
+        else
+                return n - (fault - (unsigned long) to);
 }
diff --git a/arch/um/kernel/um_arch.c b/arch/um/kernel/um_arch.c
index f1c71393f578..468aba990dbd 100644
--- a/arch/um/kernel/um_arch.c
+++ b/arch/um/kernel/um_arch.c
@@ -3,22 +3,23 @@
  * Licensed under the GPL
  */
 
-#include "linux/delay.h"
-#include "linux/mm.h"
-#include "linux/module.h"
-#include "linux/seq_file.h"
-#include "linux/string.h"
-#include "linux/utsname.h"
-#include "asm/pgtable.h"
-#include "asm/processor.h"
-#include "asm/setup.h"
-#include "arch.h"
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/seq_file.h>
+#include <linux/string.h>
+#include <linux/utsname.h>
+#include <asm/pgtable.h>
+#include <asm/processor.h>
+#include <asm/setup.h>
 #include "as-layout.h"
+#include "arch.h"
 #include "init.h"
 #include "kern.h"
+#include "kern_util.h"
 #include "mem_user.h"
 #include "os.h"
-#include "skas.h"
 
 #define DEFAULT_COMMAND_LINE "root=98:0"
 
@@ -100,8 +101,6 @@ const struct seq_operations cpuinfo_op = {
 };
 
 /* Set in linux_main */
-unsigned long host_task_size;
-unsigned long task_size;
 unsigned long uml_physmem;
 unsigned long uml_reserved; /* Also modified in mem_init */
 unsigned long start_vm;
@@ -197,20 +196,19 @@ __uml_setup("--help", Usage,
 "    Prints this message.\n\n"
 );
 
-static int __init uml_checksetup(char *line, int *add)
+static void __init uml_checksetup(char *line, int *add)
 {
         struct uml_param *p;
 
         p = &__uml_setup_start;
-        while(p < &__uml_setup_end) {
+        while (p < &__uml_setup_end) {
                 int n;
 
                 n = strlen(p->str);
                 if (!strncmp(line, p->str, n) && p->setup_func(line + n, add))
-                        return 1;
+                        return;
                 p++;
         }
-        return 0;
 }
 
 static void __init uml_postsetup(void)
@@ -218,13 +216,30 @@ static void __init uml_postsetup(void)
         initcall_t *p;
 
         p = &__uml_postsetup_start;
-        while(p < &__uml_postsetup_end) {
+        while (p < &__uml_postsetup_end) {
                 (*p)();
                 p++;
         }
         return;
 }
 
+static int panic_exit(struct notifier_block *self, unsigned long unused1,
+                      void *unused2)
+{
+        bust_spinlocks(1);
+        show_regs(&(current->thread.regs));
+        bust_spinlocks(0);
+        uml_exitcode = 1;
+        os_dump_core();
+        return 0;
+}
+
+static struct notifier_block panic_exit_notifier = {
+        .notifier_call          = panic_exit,
+        .next                   = NULL,
+        .priority               = 0
+};
+
 /* Set during early boot */
 unsigned long brk_start;
 unsigned long end_iomem;
@@ -234,20 +249,6 @@ EXPORT_SYMBOL(end_iomem);
 
 extern char __binary_start;
 
-static unsigned long set_task_sizes_skas(unsigned long *task_size_out)
-{
-        /* Round up to the nearest 4M */
-        unsigned long host_task_size = ROUND_4M((unsigned long)
-                                                &host_task_size);
-
-        if (!skas_needs_stub)
-                *task_size_out = host_task_size;
-        else
-                *task_size_out = STUB_START & PGDIR_MASK;
-
-        return host_task_size;
-}
-
 int __init linux_main(int argc, char **argv)
 {
         unsigned long avail, diff;
@@ -278,13 +279,6 @@ int __init linux_main(int argc, char **argv)
 
         printf("UML running in %s mode\n", mode);
 
-        host_task_size = set_task_sizes_skas(&task_size);
-
-        /*
-         * Setting up handlers to 'sig_info' struct
-         */
-        os_fill_handlinfo(handlinfo_kern);
-
         brk_start = (unsigned long) sbrk(0);
 
         /*
@@ -309,7 +303,7 @@ int __init linux_main(int argc, char **argv)
 
         highmem = 0;
         iomem_size = (iomem_size + PAGE_SIZE - 1) & PAGE_MASK;
-        max_physmem = get_kmem_end() - uml_physmem - iomem_size - MIN_VMALLOC;
+        max_physmem = CONFIG_TOP_ADDR - uml_physmem - iomem_size - MIN_VMALLOC;
 
         /*
          * Zones have to begin on a 1 << MAX_ORDER page boundary,
@@ -341,7 +335,7 @@ int __init linux_main(int argc, char **argv)
         }
 
         virtmem_size = physmem_size;
-        avail = get_kmem_end() - start_vm;
+        avail = CONFIG_TOP_ADDR - start_vm;
         if (physmem_size > avail)
                 virtmem_size = avail;
         end_vm = start_vm + virtmem_size;
@@ -350,6 +344,9 @@ int __init linux_main(int argc, char **argv)
                 printf("Kernel virtual memory size shrunk to %lu bytes\n",
                        virtmem_size);
 
+        atomic_notifier_chain_register(&panic_notifier_list,
+                                       &panic_exit_notifier);
+
         uml_postsetup();
 
         stack_protections((unsigned long) &init_thread_info);
@@ -358,29 +355,8 @@ int __init linux_main(int argc, char **argv)
         return start_uml();
 }
 
-extern int uml_exitcode;
-
-static int panic_exit(struct notifier_block *self, unsigned long unused1,
-                      void *unused2)
-{
-        bust_spinlocks(1);
-        show_regs(&(current->thread.regs));
-        bust_spinlocks(0);
-        uml_exitcode = 1;
-        os_dump_core();
-        return 0;
-}
-
-static struct notifier_block panic_exit_notifier = {
-        .notifier_call          = panic_exit,
-        .next                   = NULL,
-        .priority               = 0
-};
-
 void __init setup_arch(char **cmdline_p)
 {
-        atomic_notifier_chain_register(&panic_notifier_list,
-                        &panic_exit_notifier);
         paging_init();
         strlcpy(boot_command_line, command_line, COMMAND_LINE_SIZE);
         *cmdline_p = command_line;
diff --git a/arch/um/kernel/umid.c b/arch/um/kernel/umid.c
index 039e16efcd55..81e07e2be3ae 100644
--- a/arch/um/kernel/umid.c
+++ b/arch/um/kernel/umid.c
@@ -1,13 +1,12 @@
-/* 
- * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com)
+/*
+ * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include "asm/errno.h"
+#include <asm/errno.h>
 #include "init.h"
-#include "os.h"
 #include "kern.h"
-#include "linux/kernel.h"
+#include "os.h"
 
 /* Changed by set_umid_arg */
 static int umid_inited = 0;
@@ -16,16 +15,16 @@ static int __init set_umid_arg(char *name, int *add)
 {
         int err;
 
-        if(umid_inited){
+        if (umid_inited) {
                 printf("umid already set\n");
                 return 0;
         }
 
         *add = 0;
         err = set_umid(name);
-        if(err == -EEXIST)
+        if (err == -EEXIST)
                 printf("umid '%s' already in use\n", name);
-        else if(!err)
+        else if (!err)
                 umid_inited = 1;
 
         return 0;
diff --git a/arch/um/os-Linux/Makefile b/arch/um/os-Linux/Makefile
index 8e129af8170d..8a48d6a30064 100644
--- a/arch/um/os-Linux/Makefile
+++ b/arch/um/os-Linux/Makefile
@@ -4,7 +4,7 @@
 #
 
 obj-y = aio.o elf_aux.o execvp.o file.o helper.o irq.o main.o mem.o process.o \
-        registers.o sigio.o signal.o start_up.o time.o trap.o tty.o uaccess.o \
+        registers.o sigio.o signal.o start_up.o time.o tty.o uaccess.o \
         umid.o tls.o user_syms.o util.o drivers/ sys-$(SUBARCH)/ skas/
 
 obj-$(CONFIG_TTY_LOG) += tty_log.o
@@ -12,7 +12,7 @@ user-objs-$(CONFIG_TTY_LOG) += tty_log.o
 
 USER_OBJS := $(user-objs-y) aio.o elf_aux.o execvp.o file.o helper.o irq.o \
         main.o mem.o process.o registers.o sigio.o signal.o start_up.o time.o \
-        trap.o tty.o tls.o uaccess.o umid.o util.o
+        tty.o tls.o uaccess.o umid.o util.o
 
 CFLAGS_user_syms.o += -DSUBARCH_$(SUBARCH)
 
diff --git a/arch/um/os-Linux/aio.c b/arch/um/os-Linux/aio.c
index 93dc0c80ebaf..b8d8c9ca8d4a 100644
--- a/arch/um/os-Linux/aio.c
+++ b/arch/um/os-Linux/aio.c
@@ -12,6 +12,7 @@
 #include "aio.h"
 #include "init.h"
 #include "kern_constants.h"
+#include "kern_util.h"
 #include "os.h"
 #include "user.h"
 
diff --git a/arch/um/os-Linux/drivers/ethertap_user.c b/arch/um/os-Linux/drivers/ethertap_user.c
index 07ca0cb472ac..6fb0b174f538 100644
--- a/arch/um/os-Linux/drivers/ethertap_user.c
+++ b/arch/um/os-Linux/drivers/ethertap_user.c
@@ -131,7 +131,7 @@ static int etap_tramp(char *dev, char *gate, int control_me,
         }
         if (c != 1) {
                 printk(UM_KERN_ERR "etap_tramp : uml_net failed\n");
-                err = helper_wait(pid, 0, "uml_net");
+                err = helper_wait(pid);
         }
         return err;
 }
diff --git a/arch/um/os-Linux/drivers/tuntap_user.c b/arch/um/os-Linux/drivers/tuntap_user.c
index 1037a3b6386e..2448be03fd7a 100644
--- a/arch/um/os-Linux/drivers/tuntap_user.c
+++ b/arch/um/os-Linux/drivers/tuntap_user.c
@@ -14,6 +14,7 @@
 #include <sys/wait.h>
 #include <sys/uio.h>
 #include "kern_constants.h"
+#include "kern_util.h"
 #include "os.h"
 #include "tuntap.h"
 #include "user.h"
@@ -107,7 +108,7 @@ static int tuntap_open_tramp(char *gate, int *fd_out, int me, int remote,
                        "errno = %d\n", errno);
                 return err;
         }
-        helper_wait(pid, 0, "tuntap_open_tramp");
+        helper_wait(pid);
 
         cmsg = CMSG_FIRSTHDR(&msg);
         if (cmsg == NULL) {
@@ -148,7 +149,7 @@ static int tuntap_open(void *data)
                 memset(&ifr, 0, sizeof(ifr));
                 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
                 strlcpy(ifr.ifr_name, pri->dev_name, sizeof(ifr.ifr_name));
-                if (ioctl(pri->fd, TUNSETIFF, (void *) &ifr) < 0) {
+                if (ioctl(pri->fd, TUNSETIFF, &ifr) < 0) {
                         err = -errno;
                         printk(UM_KERN_ERR "TUNSETIFF failed, errno = %d\n",
                                errno);
diff --git a/arch/um/os-Linux/file.c b/arch/um/os-Linux/file.c
index f83462758627..b5afcfd0f861 100644
--- a/arch/um/os-Linux/file.c
+++ b/arch/um/os-Linux/file.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
@@ -8,18 +8,16 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/socket.h>
-#include <sys/un.h>
 #include <sys/ioctl.h>
 #include <sys/mount.h>
-#include <sys/uio.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+#include "kern_constants.h"
 #include "os.h"
 #include "user.h"
-#include "kern_util.h"
 
-static void copy_stat(struct uml_stat *dst, struct stat64 *src)
+static void copy_stat(struct uml_stat *dst, const struct stat64 *src)
 {
         *dst = ((struct uml_stat) {
                 .ust_dev     = src->st_dev,     /* device */
@@ -43,10 +41,10 @@ int os_stat_fd(const int fd, struct uml_stat *ubuf)
         int err;
 
         CATCH_EINTR(err = fstat64(fd, &sbuf));
-        if(err < 0)
+        if (err < 0)
                 return -errno;
 
-        if(ubuf != NULL)
+        if (ubuf != NULL)
                 copy_stat(ubuf, &sbuf);
         return err;
 }
@@ -56,27 +54,26 @@ int os_stat_file(const char *file_name, struct uml_stat *ubuf)
         struct stat64 sbuf;
         int err;
 
-        do {
-                err = stat64(file_name, &sbuf);
-        } while((err < 0) && (errno == EINTR)) ;
-
-        if(err < 0)
+        CATCH_EINTR(err = stat64(file_name, &sbuf));
+        if (err < 0)
                 return -errno;
 
-        if(ubuf != NULL)
+        if (ubuf != NULL)
                 copy_stat(ubuf, &sbuf);
         return err;
 }
 
-int os_access(const char* file, int mode)
+int os_access(const char *file, int mode)
 {
         int amode, err;
 
-        amode=(mode&OS_ACC_R_OK ? R_OK : 0) | (mode&OS_ACC_W_OK ? W_OK : 0) |
-              (mode&OS_ACC_X_OK ? X_OK : 0) | (mode&OS_ACC_F_OK ? F_OK : 0) ;
+        amode = (mode & OS_ACC_R_OK ? R_OK : 0) |
+                (mode & OS_ACC_W_OK ? W_OK : 0) |
+                (mode & OS_ACC_X_OK ? X_OK : 0) |
+                (mode & OS_ACC_F_OK ? F_OK : 0);
 
         err = access(file, amode);
-        if(err < 0)
+        if (err < 0)
                 return -errno;
 
         return 0;
@@ -88,7 +85,7 @@ int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg)
         int err;
 
         err = ioctl(fd, cmd, arg);
-        if(err < 0)
+        if (err < 0)
                 return -errno;
 
         return err;
@@ -97,7 +94,7 @@ int os_ioctl_generic(int fd, unsigned int cmd, unsigned long arg)
 /* FIXME: ensure namebuf in os_get_if_name is big enough */
 int os_get_ifname(int fd, char* namebuf)
 {
-        if(ioctl(fd, SIOCGIFNAME, namebuf) < 0)
+        if (ioctl(fd, SIOCGIFNAME, namebuf) < 0)
                 return -errno;
 
         return 0;
@@ -108,37 +105,22 @@ int os_set_slip(int fd)
         int disc, sencap;
 
         disc = N_SLIP;
-        if(ioctl(fd, TIOCSETD, &disc) < 0)
+        if (ioctl(fd, TIOCSETD, &disc) < 0)
                 return -errno;
 
         sencap = 0;
-        if(ioctl(fd, SIOCSIFENCAP, &sencap) < 0)
+        if (ioctl(fd, SIOCSIFENCAP, &sencap) < 0)
                 return -errno;
 
         return 0;
 }
 
-int os_set_owner(int fd, int pid)
-{
-        if(fcntl(fd, F_SETOWN, pid) < 0){
-                int save_errno = errno;
-
-                if(fcntl(fd, F_GETOWN, 0) != pid)
-                        return -save_errno;
-        }
-
-        return 0;
-}
-
 int os_mode_fd(int fd, int mode)
 {
         int err;
 
-        do {
-                err = fchmod(fd, mode);
-        } while((err < 0) && (errno==EINTR)) ;
-
-        if(err < 0)
+        CATCH_EINTR(err = fchmod(fd, mode));
+        if (err < 0)
                 return -errno;
 
         return 0;
@@ -150,64 +132,73 @@ int os_file_type(char *file)
         int err;
 
         err = os_stat_file(file, &buf);
-        if(err < 0)
+        if (err < 0)
                 return err;
 
-        if(S_ISDIR(buf.ust_mode))
+        if (S_ISDIR(buf.ust_mode))
                 return OS_TYPE_DIR;
-        else if(S_ISLNK(buf.ust_mode))
+        else if (S_ISLNK(buf.ust_mode))
                 return OS_TYPE_SYMLINK;
-        else if(S_ISCHR(buf.ust_mode))
+        else if (S_ISCHR(buf.ust_mode))
                 return OS_TYPE_CHARDEV;
-        else if(S_ISBLK(buf.ust_mode))
+        else if (S_ISBLK(buf.ust_mode))
                 return OS_TYPE_BLOCKDEV;
-        else if(S_ISFIFO(buf.ust_mode))
+        else if (S_ISFIFO(buf.ust_mode))
                 return OS_TYPE_FIFO;
-        else if(S_ISSOCK(buf.ust_mode))
+        else if (S_ISSOCK(buf.ust_mode))
                 return OS_TYPE_SOCK;
         else return OS_TYPE_FILE;
 }
 
-int os_file_mode(char *file, struct openflags *mode_out)
+int os_file_mode(const char *file, struct openflags *mode_out)
 {
         int err;
 
         *mode_out = OPENFLAGS();
 
         err = access(file, W_OK);
-        if(err && (errno != EACCES))
+        if (err && (errno != EACCES))
                 return -errno;
-        else if(!err)
+        else if (!err)
                 *mode_out = of_write(*mode_out);
 
         err = access(file, R_OK);
-        if(err && (errno != EACCES))
+        if (err && (errno != EACCES))
                 return -errno;
-        else if(!err)
+        else if (!err)
                 *mode_out = of_read(*mode_out);
 
         return err;
 }
 
-int os_open_file(char *file, struct openflags flags, int mode)
+int os_open_file(const char *file, struct openflags flags, int mode)
 {
         int fd, err, f = 0;
 
-        if(flags.r && flags.w) f = O_RDWR;
-        else if(flags.r) f = O_RDONLY;
-        else if(flags.w) f = O_WRONLY;
+        if (flags.r && flags.w)
+                f = O_RDWR;
+        else if (flags.r)
+                f = O_RDONLY;
+        else if (flags.w)
+                f = O_WRONLY;
         else f = 0;
 
-        if(flags.s) f |= O_SYNC;
-        if(flags.c) f |= O_CREAT;
-        if(flags.t) f |= O_TRUNC;
-        if(flags.e) f |= O_EXCL;
+        if (flags.s)
+                f |= O_SYNC;
+        if (flags.c)
+                f |= O_CREAT;
+        if (flags.t)
+                f |= O_TRUNC;
+        if (flags.e)
+                f |= O_EXCL;
+        if (flags.a)
+                f |= O_APPEND;
 
         fd = open64(file, f, mode);
-        if(fd < 0)
+        if (fd < 0)
                 return -errno;
 
-        if(flags.cl && fcntl(fd, F_SETFD, 1)){
+        if (flags.cl && fcntl(fd, F_SETFD, 1)) {
                 err = -errno;
                 close(fd);
                 return err;
@@ -216,7 +207,7 @@ int os_open_file(char *file, struct openflags flags, int mode)
         return fd;
 }
 
-int os_connect_socket(char *name)
+int os_connect_socket(const char *name)
 {
         struct sockaddr_un sock;
         int fd, err;
@@ -225,13 +216,13 @@ int os_connect_socket(char *name)
         snprintf(sock.sun_path, sizeof(sock.sun_path), "%s", name);
 
         fd = socket(AF_UNIX, SOCK_STREAM, 0);
-        if(fd < 0) {
+        if (fd < 0) {
                 err = -errno;
                 goto out;
         }
 
         err = connect(fd, (struct sockaddr *) &sock, sizeof(sock));
-        if(err) {
+        if (err) {
                 err = -errno;
                 goto out_close;
         }
@@ -254,7 +245,7 @@ int os_seek_file(int fd, unsigned long long offset)
         unsigned long long actual;
 
         actual = lseek64(fd, offset, SEEK_SET);
-        if(actual != offset)
+        if (actual != offset)
                 return -errno;
         return 0;
 }
@@ -263,7 +254,7 @@ int os_read_file(int fd, void *buf, int len)
 {
         int n = read(fd, buf, len);
 
-        if(n < 0)
+        if (n < 0)
                 return -errno;
         return n;
 }
@@ -272,37 +263,38 @@ int os_write_file(int fd, const void *buf, int len)
 {
         int n = write(fd, (void *) buf, len);
 
-        if(n < 0)
+        if (n < 0)
                 return -errno;
         return n;
 }
 
-int os_file_size(char *file, unsigned long long *size_out)
+int os_file_size(const char *file, unsigned long long *size_out)
 {
         struct uml_stat buf;
         int err;
 
         err = os_stat_file(file, &buf);
-        if(err < 0){
-                printk("Couldn't stat \"%s\" : err = %d\n", file, -err);
+        if (err < 0) {
+                printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file,
+                       -err);
                 return err;
         }
 
-        if(S_ISBLK(buf.ust_mode)){
+        if (S_ISBLK(buf.ust_mode)) {
                 int fd;
                 long blocks;
 
                 fd = open(file, O_RDONLY, 0);
-                if(fd < 0) {
+                if (fd < 0) {
                         err = -errno;
-                        printk("Couldn't open \"%s\", errno = %d\n", file,
-                               errno);
+                        printk(UM_KERN_ERR "Couldn't open \"%s\", "
+                               "errno = %d\n", file, errno);
                         return err;
                 }
-                if(ioctl(fd, BLKGETSIZE, &blocks) < 0){
+                if (ioctl(fd, BLKGETSIZE, &blocks) < 0) {
                         err = -errno;
-                        printk("Couldn't get the block size of \"%s\", "
-                               "errno = %d\n", file, errno);
+                        printk(UM_KERN_ERR "Couldn't get the block size of "
+                               "\"%s\", errno = %d\n", file, errno);
                         close(fd);
                         return err;
                 }
@@ -314,14 +306,15 @@ int os_file_size(char *file, unsigned long long *size_out)
         return 0;
 }
 
-int os_file_modtime(char *file, unsigned long *modtime)
+int os_file_modtime(const char *file, unsigned long *modtime)
 {
         struct uml_stat buf;
         int err;
 
         err = os_stat_file(file, &buf);
-        if(err < 0){
-                printk("Couldn't stat \"%s\" : err = %d\n", file, -err);
+        if (err < 0) {
+                printk(UM_KERN_ERR "Couldn't stat \"%s\" : err = %d\n", file,
+                       -err);
                 return err;
         }
 
@@ -329,26 +322,13 @@ int os_file_modtime(char *file, unsigned long *modtime)
         return 0;
 }
 
-int os_get_exec_close(int fd, int *close_on_exec)
-{
-        int ret;
-
-        CATCH_EINTR(ret = fcntl(fd, F_GETFD));
-
-        if(ret < 0)
-                return -errno;
-
-        *close_on_exec = (ret & FD_CLOEXEC) ? 1 : 0;
-        return ret;
-}
-
 int os_set_exec_close(int fd)
 {
         int err;
 
         CATCH_EINTR(err = fcntl(fd, F_SETFD, FD_CLOEXEC));
 
-        if(err < 0)
+        if (err < 0)
                 return -errno;
         return err;
 }
@@ -358,53 +338,51 @@ int os_pipe(int *fds, int stream, int close_on_exec)
         int err, type = stream ? SOCK_STREAM : SOCK_DGRAM;
 
         err = socketpair(AF_UNIX, type, 0, fds);
-        if(err < 0)
+        if (err < 0)
                 return -errno;
 
-        if(!close_on_exec)
+        if (!close_on_exec)
                 return 0;
 
         err = os_set_exec_close(fds[0]);
-        if(err < 0)
+        if (err < 0)
                 goto error;
 
         err = os_set_exec_close(fds[1]);
-        if(err < 0)
+        if (err < 0)
                 goto error;
 
         return 0;
 
  error:
-        printk("os_pipe : Setting FD_CLOEXEC failed, err = %d\n", -err);
+        printk(UM_KERN_ERR "os_pipe : Setting FD_CLOEXEC failed, err = %d\n",
+               -err);
         close(fds[1]);
         close(fds[0]);
         return err;
 }
 
-int os_set_fd_async(int fd, int owner)
+int os_set_fd_async(int fd)
 {
-        int err;
+        int err, flags;
+
+        flags = fcntl(fd, F_GETFL);
+        if (flags < 0)
+                return -errno;
 
-        /* XXX This should do F_GETFL first */
-        if(fcntl(fd, F_SETFL, O_ASYNC | O_NONBLOCK) < 0){
+        flags |= O_ASYNC | O_NONBLOCK;
+        if (fcntl(fd, F_SETFL, flags) < 0) {
                 err = -errno;
-                printk("os_set_fd_async : failed to set O_ASYNC and "
-                       "O_NONBLOCK on fd # %d, errno = %d\n", fd, errno);
+                printk(UM_KERN_ERR "os_set_fd_async : failed to set O_ASYNC "
+                       "and O_NONBLOCK on fd # %d, errno = %d\n", fd, errno);
                 return err;
         }
-#ifdef notdef
-        if(fcntl(fd, F_SETFD, 1) < 0){
-                printk("os_set_fd_async : Setting FD_CLOEXEC failed, "
-                       "errno = %d\n", errno);
-        }
-#endif
 
-        if((fcntl(fd, F_SETSIG, SIGIO) < 0) ||
-           (fcntl(fd, F_SETOWN, owner) < 0)){
+        if ((fcntl(fd, F_SETSIG, SIGIO) < 0) ||
+            (fcntl(fd, F_SETOWN, os_getpid()) < 0)) {
                 err = -errno;
-                printk("os_set_fd_async : Failed to fcntl F_SETOWN "
-                       "(or F_SETSIG) fd %d to pid %d, errno = %d\n", fd,
-                       owner, errno);
+                printk(UM_KERN_ERR "os_set_fd_async : Failed to fcntl F_SETOWN "
+                       "(or F_SETSIG) fd %d, errno = %d\n", fd, errno);
                 return err;
         }
 
@@ -413,10 +391,14 @@ int os_set_fd_async(int fd, int owner)
 
 int os_clear_fd_async(int fd)
 {
-        int flags = fcntl(fd, F_GETFL);
+        int flags;
+
+        flags = fcntl(fd, F_GETFL);
+        if (flags < 0)
+                return -errno;
 
         flags &= ~(O_ASYNC | O_NONBLOCK);
-        if(fcntl(fd, F_SETFL, flags) < 0)
+        if (fcntl(fd, F_SETFL, flags) < 0)
                 return -errno;
         return 0;
 }
@@ -426,11 +408,15 @@ int os_set_fd_block(int fd, int blocking)
         int flags;
 
         flags = fcntl(fd, F_GETFL);
+        if (flags < 0)
+                return -errno;
 
-        if(blocking) flags &= ~O_NONBLOCK;
-        else flags |= O_NONBLOCK;
+        if (blocking)
+                flags &= ~O_NONBLOCK;
+        else
+                flags |= O_NONBLOCK;
 
-        if(fcntl(fd, F_SETFL, flags) < 0)
+        if (fcntl(fd, F_SETFL, flags) < 0)
                 return -errno;
 
         return 0;
@@ -441,7 +427,7 @@ int os_accept_connection(int fd)
         int new;
 
         new = accept(fd, NULL, 0);
-        if(new < 0)
+        if (new < 0)
                 return -errno;
         return new;
 }
@@ -462,15 +448,17 @@ int os_shutdown_socket(int fd, int r, int w)
 {
         int what, err;
 
-        if(r && w) what = SHUT_RDWR;
-        else if(r) what = SHUT_RD;
-        else if(w) what = SHUT_WR;
-        else {
-                printk("os_shutdown_socket : neither r or w was set\n");
+        if (r && w)
+                what = SHUT_RDWR;
+        else if (r)
+                what = SHUT_RD;
+        else if (w)
+                what = SHUT_WR;
+        else
                 return -EINVAL;
-        }
+
         err = shutdown(fd, what);
-        if(err < 0)
+        if (err < 0)
                 return -errno;
         return 0;
 }
@@ -494,19 +482,20 @@ int os_rcv_fd(int fd, int *helper_pid_out)
         msg.msg_flags = 0;
 
         n = recvmsg(fd, &msg, 0);
-        if(n < 0)
+        if (n < 0)
                 return -errno;
-        else if(n != iov.iov_len)
+        else if (n != iov.iov_len)
                 *helper_pid_out = -1;
 
         cmsg = CMSG_FIRSTHDR(&msg);
-        if(cmsg == NULL){
-                printk("rcv_fd didn't receive anything, error = %d\n", errno);
+        if (cmsg == NULL) {
+                printk(UM_KERN_ERR "rcv_fd didn't receive anything, "
+                       "error = %d\n", errno);
                 return -1;
         }
-        if((cmsg->cmsg_level != SOL_SOCKET) ||
-           (cmsg->cmsg_type != SCM_RIGHTS)){
-                printk("rcv_fd didn't receive a descriptor\n");
+        if ((cmsg->cmsg_level != SOL_SOCKET) ||
+            (cmsg->cmsg_type != SCM_RIGHTS)) {
+                printk(UM_KERN_ERR "rcv_fd didn't receive a descriptor\n");
                 return -1;
         }
 
@@ -514,29 +503,28 @@ int os_rcv_fd(int fd, int *helper_pid_out)
         return new;
 }
 
-int os_create_unix_socket(char *file, int len, int close_on_exec)
+int os_create_unix_socket(const char *file, int len, int close_on_exec)
 {
         struct sockaddr_un addr;
         int sock, err;
 
         sock = socket(PF_UNIX, SOCK_DGRAM, 0);
-        if(sock < 0)
+        if (sock < 0)
                 return -errno;
 
-        if(close_on_exec) {
+        if (close_on_exec) {
                 err = os_set_exec_close(sock);
-                if(err < 0)
-                        printk("create_unix_socket : close_on_exec failed, "
-                       "err = %d", -err);
+                if (err < 0)
+                        printk(UM_KERN_ERR "create_unix_socket : "
+                               "close_on_exec failed, err = %d", -err);
         }
 
         addr.sun_family = AF_UNIX;
 
-        /* XXX Be more careful about overflow */
         snprintf(addr.sun_path, len, "%s", file);
 
         err = bind(sock, (struct sockaddr *) &addr, sizeof(addr));
-        if(err < 0)
+        if (err < 0)
                 return -errno;
 
         return sock;
@@ -557,17 +545,18 @@ int os_lock_file(int fd, int excl)
         int err, save;
 
         err = fcntl(fd, F_SETLK, &lock);
-        if(!err)
+        if (!err)
                 goto out;
 
         save = -errno;
         err = fcntl(fd, F_GETLK, &lock);
-        if(err){
+        if (err) {
                 err = -errno;
                 goto out;
         }
 
-        printk("F_SETLK failed, file already locked by pid %d\n", lock.l_pid);
+        printk(UM_KERN_ERR "F_SETLK failed, file already locked by pid %d\n",
+               lock.l_pid);
         err = save;
  out:
         return err;
diff --git a/arch/um/os-Linux/helper.c b/arch/um/os-Linux/helper.c
index fba3f0fefeef..f4bd349d4412 100644
--- a/arch/um/os-Linux/helper.c
+++ b/arch/um/os-Linux/helper.c
@@ -1,22 +1,19 @@
 /*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sched.h>
-#include <limits.h>
-#include <sys/signal.h>
-#include <sys/wait.h>
 #include <sys/socket.h>
-#include "user.h"
+#include <sys/wait.h>
+#include "kern_constants.h"
 #include "kern_util.h"
 #include "os.h"
 #include "um_malloc.h"
-#include "kern_constants.h"
+#include "user.h"
 
 struct helper_data {
         void (*pre_exec)(void*);
@@ -30,21 +27,19 @@ static int helper_child(void *arg)
 {
         struct helper_data *data = arg;
         char **argv = data->argv;
-        int errval;
+        int err;
 
         if (data->pre_exec != NULL)
                 (*data->pre_exec)(data->pre_data);
-        errval = execvp_noalloc(data->buf, argv[0], argv);
-        printk("helper_child - execvp of '%s' failed - errno = %d\n", argv[0],
-               -errval);
-        write(data->fd, &errval, sizeof(errval));
-        kill(os_getpid(), SIGKILL);
+        err = execvp_noalloc(data->buf, argv[0], argv);
+
+        /* If the exec succeeds, we don't get here */
+        write(data->fd, &err, sizeof(err));
+
         return 0;
 }
 
-/* Returns either the pid of the child process we run or -E* on failure.
- * XXX The alloc_stack here breaks if this is called in the tracing thread, so
- * we need to receive a preallocated stack (a local buffer is ok). */
+/* Returns either the pid of the child process we run or -E* on failure. */
 int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv)
 {
         struct helper_data data;
@@ -58,14 +53,15 @@ int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv)
         ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
         if (ret < 0) {
                 ret = -errno;
-                printk("run_helper : pipe failed, errno = %d\n", errno);
+                printk(UM_KERN_ERR "run_helper : pipe failed, errno = %d\n",
+                       errno);
                 goto out_free;
         }
 
         ret = os_set_exec_close(fds[1]);
         if (ret < 0) {
-                printk("run_helper : setting FD_CLOEXEC failed, ret = %d\n",
-                       -ret);
+                printk(UM_KERN_ERR "run_helper : setting FD_CLOEXEC failed, "
+                       "ret = %d\n", -ret);
                 goto out_close;
         }
 
@@ -79,7 +75,8 @@ int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv)
         pid = clone(helper_child, (void *) sp, CLONE_VM, &data);
         if (pid < 0) {
                 ret = -errno;
-                printk("run_helper : clone failed, errno = %d\n", errno);
+                printk(UM_KERN_ERR "run_helper : clone failed, errno = %d\n",
+                       errno);
                 goto out_free2;
         }
 
@@ -96,10 +93,9 @@ int run_helper(void (*pre_exec)(void *), void *pre_data, char **argv)
         } else {
                 if (n < 0) {
                         n = -errno;
-                        printk("run_helper : read on pipe failed, ret = %d\n",
-                               -n);
+                        printk(UM_KERN_ERR "run_helper : read on pipe failed, "
+                               "ret = %d\n", -n);
                         ret = n;
-                        kill(pid, SIGKILL);
                 }
                 CATCH_EINTR(waitpid(pid, NULL, __WCLONE));
         }
@@ -129,50 +125,40 @@ int run_helper_thread(int (*proc)(void *), void *arg, unsigned int flags,
         pid = clone(proc, (void *) sp, flags, arg);
         if (pid < 0) {
                 err = -errno;
-                printk("run_helper_thread : clone failed, errno = %d\n",
-                       errno);
+                printk(UM_KERN_ERR "run_helper_thread : clone failed, "
+                       "errno = %d\n", errno);
                 return err;
         }
         if (stack_out == NULL) {
                 CATCH_EINTR(pid = waitpid(pid, &status, __WCLONE));
                 if (pid < 0) {
                         err = -errno;
-                        printk("run_helper_thread - wait failed, errno = %d\n",
-                               errno);
+                        printk(UM_KERN_ERR "run_helper_thread - wait failed, "
+                               "errno = %d\n", errno);
                         pid = err;
                 }
                 if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0))
-                        printk("run_helper_thread - thread returned status "
-                               "0x%x\n", status);
+                        printk(UM_KERN_ERR "run_helper_thread - thread "
+                               "returned status 0x%x\n", status);
                 free_stack(stack, 0);
         } else
                 *stack_out = stack;
         return pid;
 }
 
-int helper_wait(int pid, int nohang, char *pname)
+int helper_wait(int pid)
 {
         int ret, status;
         int wflags = __WCLONE;
 
-        if (nohang)
-                wflags |= WNOHANG;
-
-        if (!pname)
-                pname = "helper_wait";
-
         CATCH_EINTR(ret = waitpid(pid, &status, wflags));
         if (ret < 0) {
-                printk(UM_KERN_ERR "%s : waitpid process %d failed, "
-                       "errno = %d\n", pname, pid, errno);
+                printk(UM_KERN_ERR "helper_wait : waitpid process %d failed, "
+                       "errno = %d\n", pid, errno);
                 return -errno;
-        } else if (nohang && ret == 0) {
-                printk(UM_KERN_ERR "%s : process %d has not exited\n",
-                       pname, pid);
-                return -ECHILD;
         } else if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
-                printk(UM_KERN_ERR "%s : process %d didn't exit with "
-                       "status 0\n", pname, pid);
+                printk(UM_KERN_ERR "helper_wait : process %d exited with "
+                       "status 0x%x\n", pid, status);
                 return -ECHILD;
         } else
                 return 0;
diff --git a/arch/um/os-Linux/irq.c b/arch/um/os-Linux/irq.c
index 6aa6f95d6524..0348b975e81c 100644
--- a/arch/um/os-Linux/irq.c
+++ b/arch/um/os-Linux/irq.c
@@ -1,23 +1,19 @@
 /*
- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
 #include <stdlib.h>
-#include <unistd.h>
 #include <errno.h>
+#include <poll.h>
 #include <signal.h>
 #include <string.h>
-#include <sys/poll.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include "kern_util.h"
-#include "user.h"
-#include "process.h"
-#include "sigio.h"
 #include "irq_user.h"
+#include "kern_constants.h"
 #include "os.h"
+#include "process.h"
 #include "um_malloc.h"
+#include "user.h"
 
 /*
  * Locked by irq_lock in arch/um/kernel/irq.c.  Changed by os_create_pollfd
@@ -36,7 +32,7 @@ int os_waiting_for_events(struct irq_fd *active_fds)
         if (n < 0) {
                 err = -errno;
                 if (errno != EINTR)
-                        printk("sigio_handler: os_waiting_for_events:"
+                        printk(UM_KERN_ERR "os_waiting_for_events:"
                                " poll returned %d, errno = %d\n", n, errno);
                 return err;
         }
@@ -95,24 +91,26 @@ void os_free_irq_by_cb(int (*test)(struct irq_fd *, void *), void *arg,
                         struct irq_fd *old_fd = *prev;
                         if ((pollfds[i].fd != -1) &&
                             (pollfds[i].fd != (*prev)->fd)) {
-                                printk("os_free_irq_by_cb - mismatch between "
-                                       "active_fds and pollfds, fd %d vs %d\n",
+                                printk(UM_KERN_ERR "os_free_irq_by_cb - "
+                                       "mismatch between active_fds and "
+                                       "pollfds, fd %d vs %d\n",
                                        (*prev)->fd, pollfds[i].fd);
                                 goto out;
                         }
 
                         pollfds_num--;
 
-                        /* This moves the *whole* array after pollfds[i]
+                        /*
+                         * This moves the *whole* array after pollfds[i]
                          * (though it doesn't spot as such)!
                          */
                         memmove(&pollfds[i], &pollfds[i + 1],
                                (pollfds_num - i) * sizeof(pollfds[0]));
-                        if(*last_irq_ptr2 == &old_fd->next)
+                        if (*last_irq_ptr2 == &old_fd->next)
                                 *last_irq_ptr2 = prev;
 
                         *prev = (*prev)->next;
-                        if(old_fd->type == IRQ_WRITE)
+                        if (old_fd->type == IRQ_WRITE)
                                 ignore_sigio_fd(old_fd->fd);
                         kfree(old_fd);
                         continue;
@@ -138,14 +136,3 @@ void os_set_ioignore(void)
 {
         signal(SIGIO, SIG_IGN);
 }
-
-void init_irq_signals(int on_sigstack)
-{
-        int flags;
-
-        flags = on_sigstack ? SA_ONSTACK : 0;
-
-        set_handler(SIGIO, (__sighandler_t) sig_handler, flags | SA_RESTART,
-                    SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
-        signal(SIGWINCH, SIG_IGN);
-}
diff --git a/arch/um/os-Linux/main.c b/arch/um/os-Linux/main.c
index 82c3778627b8..abb9b0ffd960 100644
--- a/arch/um/os-Linux/main.c
+++ b/arch/um/os-Linux/main.c
@@ -73,7 +73,7 @@ static void install_fatal_handler(int sig)
         action.sa_handler = last_ditch_exit;
         if (sigaction(sig, &action, NULL) < 0) {
                 printf("failed to install handler for signal %d - errno = %d\n",
-                       errno);
+                       sig, errno);
                 exit(1);
         }
 }
@@ -92,7 +92,8 @@ static void setup_env_path(void)
          * just use the default + /usr/lib/uml
          */
         if (!old_path || (path_len = strlen(old_path)) == 0) {
-                putenv("PATH=:/bin:/usr/bin/" UML_LIB_PATH);
+                if (putenv("PATH=:/bin:/usr/bin/" UML_LIB_PATH))
+                        perror("couldn't putenv");
                 return;
         }
 
@@ -100,15 +101,16 @@ static void setup_env_path(void)
         path_len += strlen("PATH=" UML_LIB_PATH) + 1;
         new_path = malloc(path_len);
         if (!new_path) {
-                perror("coudn't malloc to set a new PATH");
+                perror("couldn't malloc to set a new PATH");
                 return;
         }
         snprintf(new_path, path_len, "PATH=%s" UML_LIB_PATH, old_path);
-        putenv(new_path);
+        if (putenv(new_path)) {
+                perror("couldn't putenv to set a new PATH");
+                free(new_path);
+        }
 }
 
-extern int uml_exitcode;
-
 extern void scan_elf_aux( char **envp);
 
 int __init main(int argc, char **argv, char **envp)
diff --git a/arch/um/os-Linux/mem.c b/arch/um/os-Linux/mem.c
index 436f8d20b20f..eedc2d88ef8a 100644
--- a/arch/um/os-Linux/mem.c
+++ b/arch/um/os-Linux/mem.c
@@ -9,7 +9,6 @@
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/statfs.h>
-#include "kern_util.h"
 #include "user.h"
 #include "mem_user.h"
 #include "init.h"
@@ -30,7 +29,7 @@ static char *tempdir = NULL;
 
 static void __init find_tempdir(void)
 {
-        char *dirs[] = { "TMP", "TEMP", "TMPDIR", NULL };
+        const char *dirs[] = { "TMP", "TEMP", "TMPDIR", NULL };
         int i;
         char *dir = NULL;
 
@@ -59,9 +58,10 @@ static void __init find_tempdir(void)
  * read the file as needed.  If there's an error, -errno is returned;
  * if the end of the file is reached, 0 is returned.
  */
-static int next(int fd, char *buf, int size, char c)
+static int next(int fd, char *buf, size_t size, char c)
 {
-        int n, len;
+        ssize_t n;
+        size_t len;
         char *ptr;
 
         while((ptr = strchr(buf, c)) == NULL){
@@ -172,13 +172,15 @@ int __init make_tempfile(const char *template, char **out_tempname,
 
         which_tmpdir();
         tempname = malloc(MAXPATHLEN);
+        if (!tempname)
+                goto out;
 
         find_tempdir();
         if (template[0] != '/')
                 strcpy(tempname, tempdir);
         else
                 tempname[0] = '\0';
-        strcat(tempname, template);
+        strncat(tempname, template, MAXPATHLEN-1-strlen(tempname));
         fd = mkstemp(tempname);
         if(fd < 0){
                 fprintf(stderr, "open - cannot create %s: %s\n", tempname,
@@ -268,6 +270,7 @@ void __init check_tmpexec(void)
         if(addr == MAP_FAILED){
                 err = errno;
                 perror("failed");
+                close(fd);
                 if(err == EPERM)
                         printf("%s must be not mounted noexec\n",tempdir);
                 exit(1);
diff --git a/arch/um/os-Linux/process.c b/arch/um/os-Linux/process.c
index bda5c3150d6c..abf6beae3df1 100644
--- a/arch/um/os-Linux/process.c
+++ b/arch/um/os-Linux/process.c
@@ -249,7 +249,10 @@ void init_new_thread_signals(void)
                     SIGUSR1, SIGIO, SIGWINCH, SIGVTALRM, -1);
         signal(SIGHUP, SIG_IGN);
 
-        init_irq_signals(1);
+        set_handler(SIGIO, (__sighandler_t) sig_handler,
+                    SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGWINCH, SIGALRM,
+                    SIGVTALRM, -1);
+        signal(SIGWINCH, SIG_IGN);
 }
 
 int run_kernel_thread(int (*fn)(void *), void *arg, jmp_buf **jmp_ptr)
diff --git a/arch/um/os-Linux/registers.c b/arch/um/os-Linux/registers.c
index a32ba6ab1211..830fe6a1518a 100644
--- a/arch/um/os-Linux/registers.c
+++ b/arch/um/os-Linux/registers.c
@@ -8,47 +8,41 @@
 #include <string.h>
 #include <sys/ptrace.h>
 #include "sysdep/ptrace.h"
-#include "user.h"
 
-/* This is set once at boot time and not changed thereafter */
-
-static unsigned long exec_regs[MAX_REG_NR];
-
-void init_thread_registers(struct uml_pt_regs *to)
-{
-        memcpy(to->gp, exec_regs, sizeof(to->gp));
-}
-
-void save_registers(int pid, struct uml_pt_regs *regs)
+int save_registers(int pid, struct uml_pt_regs *regs)
 {
         int err;
 
         err = ptrace(PTRACE_GETREGS, pid, 0, regs->gp);
         if (err < 0)
-                panic("save_registers - saving registers failed, errno = %d\n",
-                      errno);
+                return -errno;
+        return 0;
 }
 
-void restore_registers(int pid, struct uml_pt_regs *regs)
+int restore_registers(int pid, struct uml_pt_regs *regs)
 {
         int err;
 
         err = ptrace(PTRACE_SETREGS, pid, 0, regs->gp);
         if (err < 0)
-                panic("restore_registers - saving registers failed, "
-                      "errno = %d\n", errno);
+                return -errno;
+        return 0;
 }
 
-void init_registers(int pid)
+/* This is set once at boot time and not changed thereafter */
+
+static unsigned long exec_regs[MAX_REG_NR];
+
+int init_registers(int pid)
 {
         int err;
 
         err = ptrace(PTRACE_GETREGS, pid, 0, exec_regs);
-        if (err)
-                panic("check_ptrace : PTRACE_GETREGS failed, errno = %d",
-                      errno);
+        if (err < 0)
+                return -errno;
 
         arch_init_registers(pid);
+        return 0;
 }
 
 void get_safe_registers(unsigned long *regs)
diff --git a/arch/um/os-Linux/sigio.c b/arch/um/os-Linux/sigio.c
index dc03e9cccb63..abf47a7c4abd 100644
--- a/arch/um/os-Linux/sigio.c
+++ b/arch/um/os-Linux/sigio.c
@@ -1,34 +1,33 @@
 /*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
 #include <unistd.h>
-#include <stdlib.h>
-#include <termios.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
 #include <pty.h>
+#include <sched.h>
 #include <signal.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <string.h>
-#include <sched.h>
-#include <sys/socket.h>
-#include <sys/poll.h>
-#include "init.h"
-#include "user.h"
+#include "kern_constants.h"
 #include "kern_util.h"
-#include "sigio.h"
+#include "init.h"
 #include "os.h"
+#include "sigio.h"
 #include "um_malloc.h"
-#include "init.h"
+#include "user.h"
 
-/* Protected by sigio_lock(), also used by sigio_cleanup, which is an
+/*
+ * Protected by sigio_lock(), also used by sigio_cleanup, which is an
  * exitcall.
  */
 static int write_sigio_pid = -1;
 static unsigned long write_sigio_stack;
 
-/* These arrays are initialized before the sigio thread is started, and
+/*
+ * These arrays are initialized before the sigio thread is started, and
  * the descriptors closed after it is killed.  So, it can't see them change.
  * On the UML side, they are changed under the sigio_lock.
  */
@@ -43,7 +42,8 @@ struct pollfds {
         int used;
 };
 
-/* Protected by sigio_lock().  Used by the sigio thread, but the UML thread
+/*
+ * Protected by sigio_lock().  Used by the sigio thread, but the UML thread
  * synchronizes with it.
  */
 static struct pollfds current_poll;
@@ -57,23 +57,26 @@ static int write_sigio_thread(void *unused)
         int i, n, respond_fd;
         char c;
 
-        signal(SIGWINCH, SIG_IGN);
+        signal(SIGWINCH, SIG_IGN);
         fds = &current_poll;
-        while(1){
+        while (1) {
                 n = poll(fds->poll, fds->used, -1);
-                if(n < 0){
-                        if(errno == EINTR) continue;
-                        printk("write_sigio_thread : poll returned %d, "
-                               "errno = %d\n", n, errno);
+                if (n < 0) {
+                        if (errno == EINTR)
+                                continue;
+                        printk(UM_KERN_ERR "write_sigio_thread : poll returned "
+                               "%d, errno = %d\n", n, errno);
                 }
-                for(i = 0; i < fds->used; i++){
+                for (i = 0; i < fds->used; i++) {
                         p = &fds->poll[i];
-                        if(p->revents == 0) continue;
-                        if(p->fd == sigio_private[1]){
+                        if (p->revents == 0)
+                                continue;
+                        if (p->fd == sigio_private[1]) {
                                 CATCH_EINTR(n = read(sigio_private[1], &c,
                                                      sizeof(c)));
-                                if(n != sizeof(c))
-                                        printk("write_sigio_thread : "
+                                if (n != sizeof(c))
+                                        printk(UM_KERN_ERR
+                                               "write_sigio_thread : "
                                                "read on socket failed, "
                                                "err = %d\n", errno);
                                 tmp = current_poll;
@@ -89,9 +92,10 @@ static int write_sigio_thread(void *unused)
                         }
 
                         CATCH_EINTR(n = write(respond_fd, &c, sizeof(c)));
-                        if(n != sizeof(c))
-                                printk("write_sigio_thread : write on socket "
-                                       "failed, err = %d\n", errno);
+                        if (n != sizeof(c))
+                                printk(UM_KERN_ERR "write_sigio_thread : "
+                                       "write on socket failed, err = %d\n",
+                                       errno);
                 }
         }
 
@@ -102,12 +106,13 @@ static int need_poll(struct pollfds *polls, int n)
 {
         struct pollfd *new;
 
-        if(n <= polls->size)
+        if (n <= polls->size)
                 return 0;
 
         new = kmalloc(n * sizeof(struct pollfd), UM_GFP_ATOMIC);
-        if(new == NULL){
-                printk("need_poll : failed to allocate new pollfds\n");
+        if (new == NULL) {
+                printk(UM_KERN_ERR "need_poll : failed to allocate new "
+                       "pollfds\n");
                 return -ENOMEM;
         }
 
@@ -119,7 +124,8 @@ static int need_poll(struct pollfds *polls, int n)
         return 0;
 }
 
-/* Must be called with sigio_lock held, because it's needed by the marked
+/*
+ * Must be called with sigio_lock held, because it's needed by the marked
  * critical section.
  */
 static void update_thread(void)
@@ -129,15 +135,17 @@ static void update_thread(void)
         char c;
 
         flags = set_signals(0);
-        n = write(sigio_private[0], &c, sizeof(c));
-        if(n != sizeof(c)){
-                printk("update_thread : write failed, err = %d\n", errno);
+        CATCH_EINTR(n = write(sigio_private[0], &c, sizeof(c)));
+        if (n != sizeof(c)) {
+                printk(UM_KERN_ERR "update_thread : write failed, err = %d\n",
+                       errno);
                 goto fail;
         }
 
         CATCH_EINTR(n = read(sigio_private[0], &c, sizeof(c)));
-        if(n != sizeof(c)){
-                printk("update_thread : read failed, err = %d\n", errno);
+        if (n != sizeof(c)) {
+                printk(UM_KERN_ERR "update_thread : read failed, err = %d\n",
+                       errno);
                 goto fail;
         }
 
@@ -164,23 +172,23 @@ int add_sigio_fd(int fd)
         int err = 0, i, n;
 
         sigio_lock();
-        for(i = 0; i < all_sigio_fds.used; i++){
-                if(all_sigio_fds.poll[i].fd == fd)
+        for (i = 0; i < all_sigio_fds.used; i++) {
+                if (all_sigio_fds.poll[i].fd == fd)
                         break;
         }
-        if(i == all_sigio_fds.used)
+        if (i == all_sigio_fds.used)
                 goto out;
 
         p = &all_sigio_fds.poll[i];
 
-        for(i = 0; i < current_poll.used; i++){
-                if(current_poll.poll[i].fd == fd)
+        for (i = 0; i < current_poll.used; i++) {
+                if (current_poll.poll[i].fd == fd)
                         goto out;
         }
 
         n = current_poll.used;
         err = need_poll(&next_poll, n + 1);
-        if(err)
+        if (err)
                 goto out;
 
         memcpy(next_poll.poll, current_poll.poll,
@@ -198,27 +206,29 @@ int ignore_sigio_fd(int fd)
         struct pollfd *p;
         int err = 0, i, n = 0;
 
-        /* This is called from exitcalls elsewhere in UML - if
+        /*
+         * This is called from exitcalls elsewhere in UML - if
          * sigio_cleanup has already run, then update_thread will hang
          * or fail because the thread is no longer running.
          */
-        if(write_sigio_pid == -1)
+        if (write_sigio_pid == -1)
                 return -EIO;
 
         sigio_lock();
-        for(i = 0; i < current_poll.used; i++){
-                if(current_poll.poll[i].fd == fd) break;
+        for (i = 0; i < current_poll.used; i++) {
+                if (current_poll.poll[i].fd == fd)
+                        break;
         }
-        if(i == current_poll.used)
+        if (i == current_poll.used)
                 goto out;
 
         err = need_poll(&next_poll, current_poll.used - 1);
-        if(err)
+        if (err)
                 goto out;
 
-        for(i = 0; i < current_poll.used; i++){
+        for (i = 0; i < current_poll.used; i++) {
                 p = &current_poll.poll[i];
-                if(p->fd != fd)
+                if (p->fd != fd)
                         next_poll.poll[n++] = *p;
         }
         next_poll.used = current_poll.used - 1;
@@ -235,7 +245,8 @@ static struct pollfd *setup_initial_poll(int fd)
 
         p = kmalloc(sizeof(struct pollfd), UM_GFP_KERNEL);
         if (p == NULL) {
-                printk("setup_initial_poll : failed to allocate poll\n");
+                printk(UM_KERN_ERR "setup_initial_poll : failed to allocate "
+                       "poll\n");
                 return NULL;
         }
         *p = ((struct pollfd) { .fd             = fd,
@@ -261,27 +272,29 @@ static void write_sigio_workaround(void)
                 return;
 
         err = os_pipe(l_write_sigio_fds, 1, 1);
-        if(err < 0){
-                printk("write_sigio_workaround - os_pipe 1 failed, "
+        if (err < 0) {
+                printk(UM_KERN_ERR "write_sigio_workaround - os_pipe 1 failed, "
                        "err = %d\n", -err);
                 return;
         }
         err = os_pipe(l_sigio_private, 1, 1);
-        if(err < 0){
-                printk("write_sigio_workaround - os_pipe 2 failed, "
+        if (err < 0) {
+                printk(UM_KERN_ERR "write_sigio_workaround - os_pipe 2 failed, "
                        "err = %d\n", -err);
                 goto out_close1;
         }
 
         p = setup_initial_poll(l_sigio_private[1]);
-        if(!p)
+        if (!p)
                 goto out_close2;
 
         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)
+        /*
+         * 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_free;
 
         current_poll = ((struct pollfds) { .poll        = p,
@@ -333,19 +346,19 @@ void maybe_sigio_broken(int fd, int read)
 {
         int err;
 
-        if(!isatty(fd))
+        if (!isatty(fd))
                 return;
 
-        if((read || pty_output_sigio) && (!read || pty_close_sigio))
+        if ((read || pty_output_sigio) && (!read || pty_close_sigio))
                 return;
 
         write_sigio_workaround();
 
         sigio_lock();
         err = need_poll(&all_sigio_fds, all_sigio_fds.used + 1);
-        if(err){
-                printk("maybe_sigio_broken - failed to add pollfd for "
-                       "descriptor %d\n", fd);
+        if (err) {
+                printk(UM_KERN_ERR "maybe_sigio_broken - failed to add pollfd "
+                       "for descriptor %d\n", fd);
                 goto out;
         }
 
@@ -388,7 +401,7 @@ static void openpty_cb(void *arg)
         struct openpty_arg *info = arg;
 
         info->err = 0;
-        if(openpty(&info->master, &info->slave, NULL, NULL, NULL))
+        if (openpty(&info->master, &info->slave, NULL, NULL, NULL))
                 info->err = -errno;
 }
 
@@ -397,17 +410,17 @@ static int async_pty(int master, int slave)
         int flags;
 
         flags = fcntl(master, F_GETFL);
-        if(flags < 0)
+        if (flags < 0)
                 return -errno;
 
-        if((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
-           (fcntl(master, F_SETOWN, os_getpid()) < 0))
+        if ((fcntl(master, F_SETFL, flags | O_NONBLOCK | O_ASYNC) < 0) ||
+            (fcntl(master, F_SETOWN, os_getpid()) < 0))
                 return -errno;
 
-        if((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0))
+        if ((fcntl(slave, F_SETFL, flags | O_NONBLOCK) < 0))
                 return -errno;
 
-        return(0);
+        return 0;
 }
 
 static void __init check_one_sigio(void (*proc)(int, int))
@@ -417,34 +430,49 @@ static void __init check_one_sigio(void (*proc)(int, int))
         int master, slave, err;
 
         initial_thread_cb(openpty_cb, &pty);
-        if(pty.err){
-                printk("openpty failed, errno = %d\n", -pty.err);
+        if (pty.err) {
+                printk(UM_KERN_ERR "check_one_sigio failed, errno = %d\n",
+                       -pty.err);
                 return;
         }
 
         master = pty.master;
         slave = pty.slave;
 
-        if((master == -1) || (slave == -1)){
-                printk("openpty failed to allocate a pty\n");
+        if ((master == -1) || (slave == -1)) {
+                printk(UM_KERN_ERR "check_one_sigio failed to allocate a "
+                       "pty\n");
                 return;
         }
 
         /* Not now, but complain so we now where we failed. */
         err = raw(master);
-        if (err < 0)
-                panic("check_sigio : __raw failed, errno = %d\n", -err);
+        if (err < 0) {
+                printk(UM_KERN_ERR "check_one_sigio : raw failed, errno = %d\n",
+                      -err);
+                return;
+        }
 
         err = async_pty(master, slave);
-        if(err < 0)
-                panic("tty_fds : sigio_async failed, err = %d\n", -err);
+        if (err < 0) {
+                printk(UM_KERN_ERR "check_one_sigio : sigio_async failed, "
+                       "err = %d\n", -err);
+                return;
+        }
+
+        if (sigaction(SIGIO, NULL, &old) < 0) {
+                printk(UM_KERN_ERR "check_one_sigio : sigaction 1 failed, "
+                       "errno = %d\n", errno);
+                return;
+        }
 
-        if(sigaction(SIGIO, NULL, &old) < 0)
-                panic("check_sigio : sigaction 1 failed, errno = %d\n", errno);
         new = old;
         new.sa_handler = handler;
-        if(sigaction(SIGIO, &new, NULL) < 0)
-                panic("check_sigio : sigaction 2 failed, errno = %d\n", errno);
+        if (sigaction(SIGIO, &new, NULL) < 0) {
+                printk(UM_KERN_ERR "check_one_sigio : sigaction 2 failed, "
+                       "errno = %d\n", errno);
+                return;
+        }
 
         got_sigio = 0;
         (*proc)(master, slave);
@@ -452,8 +480,9 @@ static void __init check_one_sigio(void (*proc)(int, int))
         close(master);
         close(slave);
 
-        if(sigaction(SIGIO, &old, NULL) < 0)
-                panic("check_sigio : sigaction 3 failed, errno = %d\n", errno);
+        if (sigaction(SIGIO, &old, NULL) < 0)
+                printk(UM_KERN_ERR "check_one_sigio : sigaction 3 failed, "
+                       "errno = %d\n", errno);
 }
 
 static void tty_output(int master, int slave)
@@ -461,42 +490,45 @@ static void tty_output(int master, int slave)
         int n;
         char buf[512];
 
-        printk("Checking that host ptys support output SIGIO...");
+        printk(UM_KERN_INFO "Checking that host ptys support output SIGIO...");
 
         memset(buf, 0, sizeof(buf));
 
-        while(write(master, buf, sizeof(buf)) > 0) ;
-        if(errno != EAGAIN)
-                panic("tty_output : write failed, errno = %d\n", errno);
-        while(((n = read(slave, buf, sizeof(buf))) > 0) && !got_sigio) ;
+        while (write(master, buf, sizeof(buf)) > 0) ;
+        if (errno != EAGAIN)
+                printk(UM_KERN_ERR "tty_output : write failed, errno = %d\n",
+                       errno);
+        while (((n = read(slave, buf, sizeof(buf))) > 0) && !got_sigio)
+                ;
 
-        if(got_sigio){
-                printk("Yes\n");
+        if (got_sigio) {
+                printk(UM_KERN_CONT "Yes\n");
                 pty_output_sigio = 1;
-        }
-        else if(n == -EAGAIN)
-                printk("No, enabling workaround\n");
-        else panic("tty_output : read failed, err = %d\n", n);
+        } else if (n == -EAGAIN)
+                printk(UM_KERN_CONT "No, enabling workaround\n");
+        else
+                printk(UM_KERN_CONT "tty_output : read failed, err = %d\n", n);
 }
 
 static void tty_close(int master, int slave)
 {
-        printk("Checking that host ptys support SIGIO on close...");
+        printk(UM_KERN_INFO "Checking that host ptys support SIGIO on "
+               "close...");
 
         close(slave);
-        if(got_sigio){
-                printk("Yes\n");
+        if (got_sigio) {
+                printk(UM_KERN_CONT "Yes\n");
                 pty_close_sigio = 1;
-        }
-        else printk("No, enabling workaround\n");
+        } else
+                printk(UM_KERN_CONT "No, enabling workaround\n");
 }
 
 void __init check_sigio(void)
 {
-        if((os_access("/dev/ptmx", OS_ACC_R_OK) < 0) &&
-           (os_access("/dev/ptyp0", OS_ACC_R_OK) < 0)){
-                printk("No pseudo-terminals available - skipping pty SIGIO "
-                       "check\n");
+        if ((access("/dev/ptmx", R_OK) < 0) &&
+            (access("/dev/ptyp0", R_OK) < 0)) {
+                printk(UM_KERN_WARNING "No pseudo-terminals available - "
+                       "skipping pty SIGIO check\n");
                 return;
         }
         check_one_sigio(tty_output);
diff --git a/arch/um/os-Linux/signal.c b/arch/um/os-Linux/signal.c
index e9800b0b5689..0fb0cc8d4757 100644
--- a/arch/um/os-Linux/signal.c
+++ b/arch/um/os-Linux/signal.c
@@ -9,11 +9,47 @@
 #include <errno.h>
 #include <signal.h>
 #include <strings.h>
+#include "as-layout.h"
+#include "kern_util.h"
 #include "os.h"
 #include "sysdep/barrier.h"
 #include "sysdep/sigcontext.h"
 #include "user.h"
 
+/* Copied from linux/compiler-gcc.h since we can't include it directly */
+#define barrier() __asm__ __volatile__("": : :"memory")
+
+void (*sig_info[NSIG])(int, struct uml_pt_regs *) = {
+        [SIGTRAP]       = relay_signal,
+        [SIGFPE]        = relay_signal,
+        [SIGILL]        = relay_signal,
+        [SIGWINCH]      = winch,
+        [SIGBUS]        = bus_handler,
+        [SIGSEGV]       = segv_handler,
+        [SIGIO]         = sigio_handler,
+        [SIGVTALRM]     = timer_handler };
+
+static void sig_handler_common(int sig, struct sigcontext *sc)
+{
+        struct uml_pt_regs r;
+        int save_errno = errno;
+
+        r.is_user = 0;
+        if (sig == SIGSEGV) {
+                /* For segfaults, we want the data from the sigcontext. */
+                copy_sc(&r, sc);
+                GET_FAULTINFO_FROM_SC(r.faultinfo, sc);
+        }
+
+        /* enable signals if sig isn't IRQ signal */
+        if ((sig != SIGIO) && (sig != SIGWINCH) && (sig != SIGVTALRM))
+                unblock_signals();
+
+        (*sig_info[sig])(sig, &r);
+
+        errno = save_errno;
+}
+
 /*
  * These are the asynchronous signals.  SIGPROF is excluded because we want to
  * be able to profile all of UML, not just the non-critical sections.  If
@@ -26,13 +62,8 @@
 #define SIGVTALRM_BIT 1
 #define SIGVTALRM_MASK (1 << SIGVTALRM_BIT)
 
-/*
- * These are used by both the signal handlers and
- * block/unblock_signals.  I don't want modifications cached in a
- * register - they must go straight to memory.
- */
-static volatile int signals_enabled = 1;
-static volatile int pending = 0;
+static int signals_enabled;
+static unsigned int signals_pending;
 
 void sig_handler(int sig, struct sigcontext *sc)
 {
@@ -40,13 +71,13 @@ void sig_handler(int sig, struct sigcontext *sc)
 
         enabled = signals_enabled;
         if (!enabled && (sig == SIGIO)) {
-                pending |= SIGIO_MASK;
+                signals_pending |= SIGIO_MASK;
                 return;
         }
 
         block_signals();
 
-        sig_handler_common_skas(sig, sc);
+        sig_handler_common(sig, sc);
 
         set_signals(enabled);
 }
@@ -68,7 +99,7 @@ void alarm_handler(int sig, struct sigcontext *sc)
 
         enabled = signals_enabled;
         if (!signals_enabled) {
-                pending |= SIGVTALRM_MASK;
+                signals_pending |= SIGVTALRM_MASK;
                 return;
         }
 
@@ -94,16 +125,6 @@ void set_sigstack(void *sig_stack, int size)
                 panic("enabling signal stack failed, errno = %d\n", errno);
 }
 
-void remove_sigstack(void)
-{
-        stack_t stack = ((stack_t) { .ss_flags  = SS_DISABLE,
-                                     .ss_sp     = NULL,
-                                     .ss_size   = 0 });
-
-        if (sigaltstack(&stack, NULL) != 0)
-                panic("disabling signal stack failed, errno = %d\n", errno);
-}
-
 void (*handlers[_NSIG])(int sig, struct sigcontext *sc);
 
 void handle_signal(int sig, struct sigcontext *sc)
@@ -166,6 +187,9 @@ void set_handler(int sig, void (*handler)(int), int flags, ...)
                 sigaddset(&action.sa_mask, mask);
         va_end(ap);
 
+        if (sig == SIGSEGV)
+                flags |= SA_NODEFER;
+
         action.sa_flags = flags;
         action.sa_restorer = NULL;
         if (sigaction(sig, &action, NULL) < 0)
@@ -179,12 +203,14 @@ void set_handler(int sig, void (*handler)(int), int flags, ...)
 
 int change_sig(int signal, int on)
 {
-        sigset_t sigset, old;
+        sigset_t sigset;
 
         sigemptyset(&sigset);
         sigaddset(&sigset, signal);
-        sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, &old);
-        return !sigismember(&old, signal);
+        if (sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, NULL) < 0)
+                return -errno;
+
+        return 0;
 }
 
 void block_signals(void)
@@ -196,7 +222,7 @@ void block_signals(void)
          * This might matter if gcc figures out how to inline this and
          * decides to shuffle this code into the caller.
          */
-        mb();
+        barrier();
 }
 
 void unblock_signals(void)
@@ -209,36 +235,26 @@ void unblock_signals(void)
         /*
          * 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.
+         * recheck signals_pending.
          */
         while(1) {
                 /*
                  * Save and reset save_pending after enabling signals.  This
-                 * way, pending won't be changed while we're reading it.
+                 * way, signals_pending won't be changed while we're reading it.
                  */
                 signals_enabled = 1;
 
                 /*
-                 * Setting signals_enabled and reading pending must
+                 * Setting signals_enabled and reading signals_pending must
                  * happen in this order.
                  */
-                mb();
-
-                save_pending = pending;
-                if (save_pending == 0) {
-                        /*
-                         * This must return with signals enabled, so
-                         * this barrier ensures that writes are
-                         * flushed out before the return.  This might
-                         * matter if gcc figures out how to inline
-                         * this (unlikely, given its size) and decides
-                         * to shuffle this code into the caller.
-                         */
-                        mb();
+                barrier();
+
+                save_pending = signals_pending;
+                if (save_pending == 0)
                         return;
-                }
 
-                pending = 0;
+                signals_pending = 0;
 
                 /*
                  * We have pending interrupts, so disable signals, as the
@@ -254,7 +270,7 @@ void unblock_signals(void)
                  * back here.
                  */
                 if (save_pending & SIGIO_MASK)
-                        sig_handler_common_skas(SIGIO, NULL);
+                        sig_handler_common(SIGIO, NULL);
 
                 if (save_pending & SIGVTALRM_MASK)
                         real_alarm_handler(NULL);
diff --git a/arch/um/os-Linux/skas/Makefile b/arch/um/os-Linux/skas/Makefile
index 5fd8d4dad66a..d2ea3409e072 100644
--- a/arch/um/os-Linux/skas/Makefile
+++ b/arch/um/os-Linux/skas/Makefile
@@ -1,10 +1,10 @@
 #
-# Copyright (C) 2002 - 2004 Jeff Dike (jdike@addtoit.com)
+# Copyright (C) 2002 - 2007 Jeff Dike (jdike@{linux.intel,addtoit}.com)
 # Licensed under the GPL
 #
 
-obj-y := mem.o process.o trap.o
+obj-y := mem.o process.o
 
-USER_OBJS := mem.o process.o trap.o
+USER_OBJS := $(obj-y)
 
 include arch/um/scripts/Makefile.rules
diff --git a/arch/um/os-Linux/skas/process.c b/arch/um/os-Linux/skas/process.c
index e8b7a97e83d3..d36c89c24a45 100644
--- a/arch/um/os-Linux/skas/process.c
+++ b/arch/um/os-Linux/skas/process.c
@@ -15,6 +15,7 @@
 #include "as-layout.h"
 #include "chan_user.h"
 #include "kern_constants.h"
+#include "kern_util.h"
 #include "mem.h"
 #include "os.h"
 #include "process.h"
@@ -37,27 +38,27 @@ int is_skas_winch(int pid, int fd, void *data)
 
 static int ptrace_dump_regs(int pid)
 {
-        unsigned long regs[MAX_REG_NR];
-        int i;
+        unsigned long regs[MAX_REG_NR];
+        int i;
 
-        if (ptrace(PTRACE_GETREGS, pid, 0, regs) < 0)
-                return -errno;
+        if (ptrace(PTRACE_GETREGS, pid, 0, regs) < 0)
+                return -errno;
 
         printk(UM_KERN_ERR "Stub registers -\n");
         for (i = 0; i < ARRAY_SIZE(regs); i++)
                 printk(UM_KERN_ERR "\t%d - %lx\n", i, regs[i]);
 
-        return 0;
+        return 0;
 }
 
 /*
  * Signals that are OK to receive in the stub - we'll just continue it.
  * SIGWINCH will happen when UML is inside a detached screen.
  */
-#define STUB_SIG_MASK ((1 << SIGVTALRM) | (1 << SIGWINCH))
+#define STUB_SIG_MASK (1 << SIGVTALRM)
 
 /* Signals that the stub will finish with - anything else is an error */
-#define STUB_DONE_MASK ((1 << SIGUSR1) | (1 << SIGTRAP))
+#define STUB_DONE_MASK (1 << SIGTRAP)
 
 void wait_stub_done(int pid)
 {
@@ -72,9 +73,11 @@ void wait_stub_done(int pid)
                         break;
 
                 err = ptrace(PTRACE_CONT, pid, 0, 0);
-                if (err)
-                        panic("wait_stub_done : continue failed, errno = %d\n",
-                              errno);
+                if (err) {
+                        printk(UM_KERN_ERR "wait_stub_done : continue failed, "
+                               "errno = %d\n", errno);
+                        fatal_sigsegv();
+                }
         }
 
         if (((1 << WSTOPSIG(status)) & STUB_DONE_MASK) != 0)
@@ -85,8 +88,10 @@ bad_wait:
         if (err)
                 printk(UM_KERN_ERR "Failed to get registers from stub, "
                        "errno = %d\n", -err);
-        panic("wait_stub_done : failed to wait for SIGUSR1/SIGTRAP, pid = %d, "
-              "n = %d, errno = %d, status = 0x%x\n", pid, n, errno, status);
+        printk(UM_KERN_ERR "wait_stub_done : failed to wait for SIGTRAP, "
+               "pid = %d, n = %d, errno = %d, status = 0x%x\n", pid, n, errno,
+               status);
+        fatal_sigsegv();
 }
 
 extern unsigned long current_stub_stack(void);
@@ -97,9 +102,11 @@ void get_skas_faultinfo(int pid, struct faultinfo * fi)
 
         if (ptrace_faultinfo) {
                 err = ptrace(PTRACE_FAULTINFO, pid, 0, fi);
-                if (err)
-                        panic("get_skas_faultinfo - PTRACE_FAULTINFO failed, "
-                              "errno = %d\n", errno);
+                if (err) {
+                        printk(UM_KERN_ERR "get_skas_faultinfo - "
+                               "PTRACE_FAULTINFO failed, errno = %d\n", errno);
+                        fatal_sigsegv();
+                }
 
                 /* Special handling for i386, which has different structs */
                 if (sizeof(struct ptrace_faultinfo) < sizeof(struct faultinfo))
@@ -109,9 +116,11 @@ void get_skas_faultinfo(int pid, struct faultinfo * fi)
         }
         else {
                 err = ptrace(PTRACE_CONT, pid, 0, SIGSEGV);
-                if (err)
-                        panic("Failed to continue stub, pid = %d, errno = %d\n",
-                              pid, errno);
+                if (err) {
+                        printk(UM_KERN_ERR "Failed to continue stub, pid = %d, "
+                               "errno = %d\n", pid, errno);
+                        fatal_sigsegv();
+                }
                 wait_stub_done(pid);
 
                 /*
@@ -137,6 +146,9 @@ static void handle_trap(int pid, struct uml_pt_regs *regs,
 {
         int err, status;
 
+        if ((UPT_IP(regs) >= STUB_START) && (UPT_IP(regs) < STUB_END))
+                fatal_sigsegv();
+
         /* Mark this as a syscall */
         UPT_SYSCALL_NR(regs) = PT_SYSCALL_NR(regs->gp);
 
@@ -144,25 +156,31 @@ static void handle_trap(int pid, struct uml_pt_regs *regs,
         {
                 err = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET,
                              __NR_getpid);
-                if (err < 0)
-                        panic("handle_trap - nullifying syscall failed, "
-                              "errno = %d\n", errno);
+                if (err < 0) {
+                        printk(UM_KERN_ERR "handle_trap - nullifying syscall "
+                               "failed, errno = %d\n", errno);
+                        fatal_sigsegv();
+                }
 
                 err = ptrace(PTRACE_SYSCALL, pid, 0, 0);
-                if (err < 0)
-                        panic("handle_trap - continuing to end of syscall "
-                              "failed, errno = %d\n", errno);
+                if (err < 0) {
+                        printk(UM_KERN_ERR "handle_trap - continuing to end of "
+                               "syscall failed, errno = %d\n", errno);
+                        fatal_sigsegv();
+                }
 
                 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED | __WALL));
                 if ((err < 0) || !WIFSTOPPED(status) ||
-                   (WSTOPSIG(status) != SIGTRAP + 0x80)) {
-                        err = ptrace_dump_regs(pid);
-                        if (err)
-                                printk(UM_KERN_ERR "Failed to get registers "
+                    (WSTOPSIG(status) != SIGTRAP + 0x80)) {
+                        err = ptrace_dump_regs(pid);
+                        if (err)
+                                printk(UM_KERN_ERR "Failed to get registers "
                                        "from process, errno = %d\n", -err);
-                        panic("handle_trap - failed to wait at end of syscall, "
-                              "errno = %d, status = %d\n", errno, status);
-                }
+                        printk(UM_KERN_ERR "handle_trap - failed to wait at "
+                               "end of syscall, errno = %d, status = %d\n",
+                               errno, status);
+                        fatal_sigsegv();
+                }
         }
 
         handle_syscall(regs);
@@ -178,10 +196,13 @@ static int userspace_tramp(void *stack)
         ptrace(PTRACE_TRACEME, 0, 0, 0);
 
         signal(SIGTERM, SIG_DFL);
+        signal(SIGWINCH, SIG_IGN);
         err = set_interval();
-        if (err)
-                panic("userspace_tramp - setting timer failed, errno = %d\n",
-                      err);
+        if (err) {
+                printk(UM_KERN_ERR "userspace_tramp - setting timer failed, "
+                       "errno = %d\n", err);
+                exit(1);
+        }
 
         if (!proc_mm) {
                 /*
@@ -221,16 +242,14 @@ static int userspace_tramp(void *stack)
 
                 set_sigstack((void *) STUB_DATA, UM_KERN_PAGE_SIZE);
                 sigemptyset(&sa.sa_mask);
-                sigaddset(&sa.sa_mask, SIGIO);
-                sigaddset(&sa.sa_mask, SIGWINCH);
-                sigaddset(&sa.sa_mask, SIGVTALRM);
-                sigaddset(&sa.sa_mask, SIGUSR1);
-                sa.sa_flags = SA_ONSTACK;
+                sa.sa_flags = SA_ONSTACK | SA_NODEFER;
                 sa.sa_handler = (void *) v;
                 sa.sa_restorer = NULL;
-                if (sigaction(SIGSEGV, &sa, NULL) < 0)
-                        panic("userspace_tramp - setting SIGSEGV handler "
-                              "failed - errno = %d\n", errno);
+                if (sigaction(SIGSEGV, &sa, NULL) < 0) {
+                        printk(UM_KERN_ERR "userspace_tramp - setting SIGSEGV "
+                               "handler failed - errno = %d\n", errno);
+                        exit(1);
+                }
         }
 
         kill(os_getpid(), SIGSTOP);
@@ -246,13 +265,18 @@ int start_userspace(unsigned long stub_stack)
 {
         void *stack;
         unsigned long sp;
-        int pid, status, n, flags;
+        int pid, status, n, flags, err;
 
         stack = mmap(NULL, UM_KERN_PAGE_SIZE,
                      PROT_READ | PROT_WRITE | PROT_EXEC,
                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-        if (stack == MAP_FAILED)
-                panic("start_userspace : mmap failed, errno = %d", errno);
+        if (stack == MAP_FAILED) {
+                err = -errno;
+                printk(UM_KERN_ERR "start_userspace : mmap failed, "
+                       "errno = %d\n", errno);
+                return err;
+        }
+
         sp = (unsigned long) stack + UM_KERN_PAGE_SIZE - sizeof(void *);
 
         flags = CLONE_FILES;
@@ -262,29 +286,50 @@ int start_userspace(unsigned long stub_stack)
                 flags |= SIGCHLD;
 
         pid = clone(userspace_tramp, (void *) sp, flags, (void *) stub_stack);
-        if (pid < 0)
-                panic("start_userspace : clone failed, errno = %d", errno);
+        if (pid < 0) {
+                err = -errno;
+                printk(UM_KERN_ERR "start_userspace : clone failed, "
+                       "errno = %d\n", errno);
+                return err;
+        }
 
         do {
                 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED | __WALL));
-                if (n < 0)
-                        panic("start_userspace : wait failed, errno = %d",
-                              errno);
+                if (n < 0) {
+                        err = -errno;
+                        printk(UM_KERN_ERR "start_userspace : wait failed, "
+                               "errno = %d\n", errno);
+                        goto out_kill;
+                }
         } while (WIFSTOPPED(status) && (WSTOPSIG(status) == SIGVTALRM));
 
-        if (!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP))
-                panic("start_userspace : expected SIGSTOP, got status = %d",
-                      status);
+        if (!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP)) {
+                err = -EINVAL;
+                printk(UM_KERN_ERR "start_userspace : expected SIGSTOP, got "
+                       "status = %d\n", status);
+                goto out_kill;
+        }
 
         if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL,
-                   (void *) PTRACE_O_TRACESYSGOOD) < 0)
-                panic("start_userspace : PTRACE_OLDSETOPTIONS failed, "
-                      "errno = %d\n", errno);
+                   (void *) PTRACE_O_TRACESYSGOOD) < 0) {
+                err = -errno;
+                printk(UM_KERN_ERR "start_userspace : PTRACE_OLDSETOPTIONS "
+                       "failed, errno = %d\n", errno);
+                goto out_kill;
+        }
 
-        if (munmap(stack, UM_KERN_PAGE_SIZE) < 0)
-                panic("start_userspace : munmap failed, errno = %d\n", errno);
+        if (munmap(stack, UM_KERN_PAGE_SIZE) < 0) {
+                err = -errno;
+                printk(UM_KERN_ERR "start_userspace : munmap failed, "
+                       "errno = %d\n", errno);
+                goto out_kill;
+        }
 
         return pid;
+
+ out_kill:
+        os_kill_ptraced_process(pid, 1);
+        return err;
 }
 
 void userspace(struct uml_pt_regs *regs)
@@ -302,7 +347,16 @@ void userspace(struct uml_pt_regs *regs)
         nsecs += os_nsecs();
 
         while (1) {
-                restore_registers(pid, regs);
+                /*
+                 * This can legitimately fail if the process loads a
+                 * bogus value into a segment register.  It will
+                 * segfault and PTRACE_GETREGS will read that value
+                 * out of the process.  However, PTRACE_SETREGS will
+                 * fail.  In this case, there is nothing to do but
+                 * just kill the process.
+                 */
+                if (ptrace(PTRACE_SETREGS, pid, 0, regs->gp))
+                        fatal_sigsegv();
 
                 /* Now we set local_using_sysemu to be used for one loop */
                 local_using_sysemu = get_using_sysemu();
@@ -310,19 +364,26 @@ void userspace(struct uml_pt_regs *regs)
                 op = SELECT_PTRACE_OPERATION(local_using_sysemu,
                                              singlestepping(NULL));
 
-                err = ptrace(op, pid, 0, 0);
-                if (err)
-                        panic("userspace - could not resume userspace process, "
-                              "pid=%d, ptrace operation = %d, errno = %d\n",
-                              pid, op, errno);
+                if (ptrace(op, pid, 0, 0)) {
+                        printk(UM_KERN_ERR "userspace - ptrace continue "
+                               "failed, op = %d, errno = %d\n", op, errno);
+                        fatal_sigsegv();
+                }
 
                 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED | __WALL));
-                if (err < 0)
-                        panic("userspace - waitpid failed, errno = %d\n",
-                              errno);
+                if (err < 0) {
+                        printk(UM_KERN_ERR "userspace - wait failed, "
+                               "errno = %d\n", errno);
+                        fatal_sigsegv();
+                }
 
                 regs->is_user = 1;
-                save_registers(pid, regs);
+                if (ptrace(PTRACE_GETREGS, pid, 0, regs->gp)) {
+                        printk(UM_KERN_ERR "userspace - PTRACE_GETREGS failed, "
+                               "errno = %d\n", errno);
+                        fatal_sigsegv();
+                }
+
                 UPT_SYSCALL_NR(regs) = -1; /* Assume: It's not a syscall */
 
                 if (WIFSTOPPED(status)) {
@@ -345,7 +406,7 @@ void userspace(struct uml_pt_regs *regs)
                                 break;
                         case SIGVTALRM:
                                 now = os_nsecs();
-                                if(now < nsecs)
+                                if (now < nsecs)
                                         break;
                                 block_signals();
                                 (*sig_info[sig])(sig, regs);
@@ -368,6 +429,7 @@ void userspace(struct uml_pt_regs *regs)
                         default:
                                 printk(UM_KERN_ERR "userspace - child stopped "
                                        "with signal %d\n", sig);
+                                fatal_sigsegv();
                         }
                         pid = userspace_pid[0];
                         interrupt_end();
@@ -419,9 +481,12 @@ int copy_context_skas0(unsigned long new_stack, int pid)
                                                      .it_interval = tv }) });
 
         err = ptrace_setregs(pid, thread_regs);
-        if (err < 0)
-                panic("copy_context_skas0 : PTRACE_SETREGS failed, "
-                      "pid = %d, errno = %d\n", pid, -err);
+        if (err < 0) {
+                err = -errno;
+                printk(UM_KERN_ERR "copy_context_skas0 : PTRACE_SETREGS "
+                       "failed, pid = %d, errno = %d\n", pid, -err);
+                return err;
+        }
 
         /* set a well known return code for detection of child write failure */
         child_data->err = 12345678;
@@ -431,31 +496,47 @@ int copy_context_skas0(unsigned long new_stack, int pid)
          * parent's stack, and check, if bad result.
          */
         err = ptrace(PTRACE_CONT, pid, 0, 0);
-        if (err)
-                panic("Failed to continue new process, pid = %d, "
-                      "errno = %d\n", pid, errno);
+        if (err) {
+                err = -errno;
+                printk(UM_KERN_ERR "Failed to continue new process, pid = %d, "
+                       "errno = %d\n", pid, errno);
+                return err;
+        }
+
         wait_stub_done(pid);
 
         pid = data->err;
-        if (pid < 0)
-                panic("copy_context_skas0 - stub-parent reports error %d\n",
-                      -pid);
+        if (pid < 0) {
+                printk(UM_KERN_ERR "copy_context_skas0 - stub-parent reports "
+                       "error %d\n", -pid);
+                return pid;
+        }
 
         /*
          * Wait, until child has finished too: read child's result from
          * child's stack and check it.
          */
         wait_stub_done(pid);
-        if (child_data->err != STUB_DATA)
-                panic("copy_context_skas0 - stub-child reports error %ld\n",
-                      child_data->err);
+        if (child_data->err != STUB_DATA) {
+                printk(UM_KERN_ERR "copy_context_skas0 - stub-child reports "
+                       "error %ld\n", child_data->err);
+                err = child_data->err;
+                goto out_kill;
+        }
 
         if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL,
-                   (void *)PTRACE_O_TRACESYSGOOD) < 0)
-                panic("copy_context_skas0 : PTRACE_OLDSETOPTIONS failed, "
-                      "errno = %d\n", errno);
+                   (void *)PTRACE_O_TRACESYSGOOD) < 0) {
+                err = -errno;
+                printk(UM_KERN_ERR "copy_context_skas0 : PTRACE_OLDSETOPTIONS "
+                       "failed, errno = %d\n", errno);
+                goto out_kill;
+        }
 
         return pid;
+
+ out_kill:
+        os_kill_ptraced_process(pid, 1);
+        return err;
 }
 
 /*
@@ -463,8 +544,8 @@ int copy_context_skas0(unsigned long new_stack, int pid)
  * available. Opening /proc/mm creates a new mm_context, which lacks
  * the stub-pages. Thus, we map them using /proc/mm-fd
  */
-void map_stub_pages(int fd, unsigned long code,
-                    unsigned long data, unsigned long stack)
+int map_stub_pages(int fd, unsigned long code, unsigned long data,
+                   unsigned long stack)
 {
         struct proc_mm_op mmop;
         int n;
@@ -488,8 +569,9 @@ void map_stub_pages(int fd, unsigned long code,
                 printk(UM_KERN_ERR "mmap args - addr = 0x%lx, fd = %d, "
                        "offset = %llx\n", code, code_fd,
                        (unsigned long long) code_offset);
-                panic("map_stub_pages : /proc/mm map for code failed, "
-                      "err = %d\n", n);
+                printk(UM_KERN_ERR "map_stub_pages : /proc/mm map for code "
+                       "failed, err = %d\n", n);
+                return -n;
         }
 
         if (stack) {
@@ -507,10 +589,15 @@ void map_stub_pages(int fd, unsigned long code,
                                       .offset  = map_offset
                 } } });
                 CATCH_EINTR(n = write(fd, &mmop, sizeof(mmop)));
-                if (n != sizeof(mmop))
-                        panic("map_stub_pages : /proc/mm map for data failed, "
-                              "err = %d\n", errno);
+                if (n != sizeof(mmop)) {
+                        n = errno;
+                        printk(UM_KERN_ERR "map_stub_pages : /proc/mm map for "
+                               "data failed, err = %d\n", n);
+                        return -n;
+                }
         }
+
+        return 0;
 }
 
 void new_thread(void *stack, jmp_buf *buf, void (*handler)(void))
@@ -571,7 +658,9 @@ int start_idle_thread(void *stack, jmp_buf *switch_buf)
                 kmalloc_ok = 0;
                 return 1;
         default:
-                panic("Bad sigsetjmp return in start_idle_thread - %d\n", n);
+                printk(UM_KERN_ERR "Bad sigsetjmp return in "
+                       "start_idle_thread - %d\n", n);
+                fatal_sigsegv();
         }
         longjmp(*switch_buf, 1);
 }
@@ -614,9 +703,11 @@ void __switch_mm(struct mm_id *mm_idp)
         if (proc_mm) {
                 err = ptrace(PTRACE_SWITCH_MM, userspace_pid[0], 0,
                              mm_idp->u.mm_fd);
-                if (err)
-                        panic("__switch_mm - PTRACE_SWITCH_MM failed, "
-                              "errno = %d\n", errno);
+                if (err) {
+                        printk(UM_KERN_ERR "__switch_mm - PTRACE_SWITCH_MM "
+                               "failed, errno = %d\n", errno);
+                        fatal_sigsegv();
+                }
         }
         else userspace_pid[0] = mm_idp->u.pid;
 }
diff --git a/arch/um/os-Linux/skas/trap.c b/arch/um/os-Linux/skas/trap.c
deleted file mode 100644
index 3b1b9244f468..000000000000
--- a/arch/um/os-Linux/skas/trap.c
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
- * Licensed under the GPL
- */
-
-#if 0
-#include "kern_util.h"
-#include "skas.h"
-#include "ptrace_user.h"
-#include "sysdep/ptrace_user.h"
-#endif
-
-#include <errno.h>
-#include <signal.h>
-#include "sysdep/ptrace.h"
-#include "kern_constants.h"
-#include "as-layout.h"
-#include "os.h"
-#include "sigcontext.h"
-#include "task.h"
-
-static struct uml_pt_regs ksig_regs[UM_NR_CPUS];
-
-void sig_handler_common_skas(int sig, void *sc_ptr)
-{
-        struct sigcontext *sc = sc_ptr;
-        struct uml_pt_regs *r;
-        void (*handler)(int, struct uml_pt_regs *);
-        int save_user, save_errno = errno;
-
-        /*
-         * This is done because to allow SIGSEGV to be delivered inside a SEGV
-         * handler.  This can happen in copy_user, and if SEGV is disabled,
-         * the process will die.
-         * XXX Figure out why this is better than SA_NODEFER
-         */
-        if (sig == SIGSEGV) {
-                change_sig(SIGSEGV, 1);
-                /*
-                 * For segfaults, we want the data from the
-                 * sigcontext.  In this case, we don't want to mangle
-                 * the process registers, so use a static set of
-                 * registers.  For other signals, the process
-                 * registers are OK.
-                 */
-                r = &ksig_regs[cpu()];
-                copy_sc(r, sc_ptr);
-        }
-        else r = TASK_REGS(get_current());
-
-        save_user = r->is_user;
-        r->is_user = 0;
-        if ((sig == SIGFPE) || (sig == SIGSEGV) || (sig == SIGBUS) ||
-            (sig == SIGILL) || (sig == SIGTRAP))
-                GET_FAULTINFO_FROM_SC(r->faultinfo, sc);
-
-        change_sig(SIGUSR1, 1);
-
-        handler = sig_info[sig];
-
-        /* unblock SIGVTALRM, SIGIO if sig isn't IRQ signal */
-        if ((sig != SIGIO) && (sig != SIGWINCH) && (sig != SIGVTALRM))
-                unblock_signals();
-
-        handler(sig, r);
-
-        errno = save_errno;
-        r->is_user = save_user;
-}
diff --git a/arch/um/os-Linux/start_up.c b/arch/um/os-Linux/start_up.c
index 7b81f6c08a5e..b616e15638fb 100644
--- a/arch/um/os-Linux/start_up.c
+++ b/arch/um/os-Linux/start_up.c
@@ -60,10 +60,11 @@ static int ptrace_child(void)
                  * the UML code itself.
                  */
                 ret = 2;
-        _exit(ret);
+
+        exit(ret);
 }
 
-static void fatal_perror(char *str)
+static void fatal_perror(const char *str)
 {
         perror(str);
         exit(1);
@@ -341,6 +342,8 @@ static void __init check_coredump_limit(void)
 
 void __init os_early_checks(void)
 {
+        int pid;
+
         /* Print out the core dump limits early */
         check_coredump_limit();
 
@@ -350,6 +353,11 @@ void __init os_early_checks(void)
          * kernel is running.
          */
         check_tmpexec();
+
+        pid = start_ptraced_child();
+        if (init_registers(pid))
+                fatal("Failed to initialize default registers");
+        stop_ptraced_child(pid, 1, 1);
 }
 
 static int __init noprocmm_cmd_param(char *str, int* add)
@@ -411,7 +419,6 @@ static inline void check_skas3_ptrace_faultinfo(void)
                         non_fatal("found\n");
         }
 
-        init_registers(pid);
         stop_ptraced_child(pid, 1, 1);
 }
 
@@ -466,7 +473,7 @@ static inline void check_skas3_proc_mm(void)
         else non_fatal("found\n");
 }
 
-int can_do_skas(void)
+void can_do_skas(void)
 {
         non_fatal("Checking for the skas3 patch in the host:\n");
 
@@ -476,8 +483,6 @@ int can_do_skas(void)
 
         if (!proc_mm || !ptrace_faultinfo || !ptrace_ldt)
                 skas_needs_stub = 1;
-
-        return 1;
 }
 
 int __init parse_iomem(char *str, int *add)
diff --git a/arch/um/os-Linux/trap.c b/arch/um/os-Linux/trap.c
deleted file mode 100644
index 2a1c9843e32e..000000000000
--- a/arch/um/os-Linux/trap.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
- * Licensed under the GPL
- */
-
-#include <signal.h>
-#include "os.h"
-#include "sysdep/ptrace.h"
-
-/* Initialized from linux_main() */
-void (*sig_info[NSIG])(int, struct uml_pt_regs *);
-
-void os_fill_handlinfo(struct kern_handlers h)
-{
-        sig_info[SIGTRAP] = h.relay_signal;
-        sig_info[SIGFPE] = h.relay_signal;
-        sig_info[SIGILL] = h.relay_signal;
-        sig_info[SIGWINCH] = h.winch;
-        sig_info[SIGBUS] = h.bus_handler;
-        sig_info[SIGSEGV] = h.page_fault;
-        sig_info[SIGIO] = h.sigio_handler;
-        sig_info[SIGVTALRM] = h.timer_handler;
-}
diff --git a/arch/um/os-Linux/tty.c b/arch/um/os-Linux/tty.c
index 4cfdd18ea1ef..b09ff66a77ee 100644
--- a/arch/um/os-Linux/tty.c
+++ b/arch/um/os-Linux/tty.c
@@ -1,13 +1,16 @@
-/* 
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+/*
+ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
 #include <stdlib.h>
+#include <unistd.h>
 #include <errno.h>
+#include <fcntl.h>
+#include "kern_constants.h"
+#include "kern_util.h"
 #include "os.h"
 #include "user.h"
-#include "kern_util.h"
 
 struct grantpt_info {
         int fd;
@@ -26,36 +29,34 @@ static void grantpt_cb(void *arg)
 int get_pty(void)
 {
         struct grantpt_info info;
-        int fd;
-
-        fd = os_open_file("/dev/ptmx", of_rdwr(OPENFLAGS()), 0);
-        if(fd < 0){
-                printk("get_pty : Couldn't open /dev/ptmx - err = %d\n", -fd);
-                return(fd);
+        int fd, err;
+
+        fd = open("/dev/ptmx", O_RDWR);
+        if (fd < 0) {
+                err = -errno;
+                printk(UM_KERN_ERR "get_pty : Couldn't open /dev/ptmx - "
+                       "err = %d\n", errno);
+                return err;
         }
 
         info.fd = fd;
         initial_thread_cb(grantpt_cb, &info);
 
-        if(info.res < 0){
-                printk("get_pty : Couldn't grant pty - errno = %d\n", 
-                       -info.err);
-                return(-1);
+        if (info.res < 0) {
+                err = -info.err;
+                printk(UM_KERN_ERR "get_pty : Couldn't grant pty - "
+                       "errno = %d\n", -info.err);
+                goto out;
         }
-        if(unlockpt(fd) < 0){
-                printk("get_pty : Couldn't unlock pty - errno = %d\n", errno);
-                return(-1);
+
+        if (unlockpt(fd) < 0) {
+                err = -errno;
+                printk(UM_KERN_ERR "get_pty : Couldn't unlock pty - "
+                       "errno = %d\n", errno);
+                goto out;
         }
-        return(fd);
+        return fd;
+out:
+        close(fd);
+        return err;
 }
-
-/*
- * 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/tty_log.c b/arch/um/os-Linux/tty_log.c
index d11a55baa6bd..cc648e6fd3a2 100644
--- a/arch/um/os-Linux/tty_log.c
+++ b/arch/um/os-Linux/tty_log.c
@@ -12,7 +12,6 @@
 #include <sys/time.h>
 #include "init.h"
 #include "user.h"
-#include "kern_util.h"
 #include "os.h"
 
 #define TTY_LOG_DIR "./"
diff --git a/arch/um/os-Linux/util.c b/arch/um/os-Linux/util.c
index 3e058ce9ffb6..a6f31d476993 100644
--- a/arch/um/os-Linux/util.c
+++ b/arch/um/os-Linux/util.c
@@ -88,21 +88,6 @@ void setup_hostinfo(char *buf, int len)
                  host.release, host.version, host.machine);
 }
 
-int setjmp_wrapper(void (*proc)(void *, void *), ...)
-{
-        va_list args;
-        jmp_buf buf;
-        int n;
-
-        n = UML_SETJMP(&buf);
-        if(n == 0){
-                va_start(args, proc);
-                (*proc)(&buf, &args);
-        }
-        va_end(args);
-        return n;
-}
-
 void os_dump_core(void)
 {
         int pid;
diff --git a/arch/um/sys-i386/bug.c b/arch/um/sys-i386/bug.c
index a4360b5207db..8d4f273f1219 100644
--- a/arch/um/sys-i386/bug.c
+++ b/arch/um/sys-i386/bug.c
@@ -4,6 +4,7 @@
  */
 
 #include <linux/uaccess.h>
+#include <asm/errno.h>
 
 /* Mostly copied from i386/x86_86 - eliminated the eip < PAGE_OFFSET because
  * that's not relevant in skas mode.
diff --git a/arch/um/sys-i386/bugs.c b/arch/um/sys-i386/bugs.c
index 806895d73bcc..a74442d13762 100644
--- a/arch/um/sys-i386/bugs.c
+++ b/arch/um/sys-i386/bugs.c
@@ -3,171 +3,47 @@
  * Licensed under the GPL
  */
 
-#include <errno.h>
 #include <signal.h>
-#include <string.h>
 #include "kern_constants.h"
-#include "os.h"
+#include "kern_util.h"
+#include "longjmp.h"
 #include "task.h"
 #include "user.h"
-
-#define MAXTOKEN 64
+#include "sysdep/ptrace.h"
 
 /* Set during early boot */
 int host_has_cmov = 1;
-int host_has_xmm = 0;
+static jmp_buf cmov_test_return;
 
-static char token(int fd, char *buf, int len, char stop)
+static void cmov_sigill_test_handler(int sig)
 {
-        int n;
-        char *ptr, *end, c;
-
-        ptr = buf;
-        end = &buf[len];
-        do {
-                n = os_read_file(fd, ptr, sizeof(*ptr));
-                c = *ptr++;
-                if (n != sizeof(*ptr)) {
-                        if (n == 0)
-                                return 0;
-                        printk(UM_KERN_ERR "Reading /proc/cpuinfo failed, "
-                               "err = %d\n", -n);
-                        if (n < 0)
-                                return n;
-                        else return -EIO;
-                }
-        } while ((c != '\n') && (c != stop) && (ptr < end));
-
-        if (ptr == end) {
-                printk(UM_KERN_ERR "Failed to find '%c' in /proc/cpuinfo\n",
-                       stop);
-                return -1;
-        }
-        *(ptr - 1) = '\0';
-        return c;
-}
-
-static int find_cpuinfo_line(int fd, char *key, char *scratch, int len)
-{
-        int n;
-        char c;
-
-        scratch[len - 1] = '\0';
-        while (1) {
-                c = token(fd, scratch, len - 1, ':');
-                if (c <= 0)
-                        return 0;
-                else if (c != ':') {
-                        printk(UM_KERN_ERR "Failed to find ':' in "
-                               "/proc/cpuinfo\n");
-                        return 0;
-                }
-
-                if (!strncmp(scratch, key, strlen(key)))
-                        return 1;
-
-                do {
-                        n = os_read_file(fd, &c, sizeof(c));
-                        if (n != sizeof(c)) {
-                                printk(UM_KERN_ERR "Failed to find newline in "
-                                       "/proc/cpuinfo, err = %d\n", -n);
-                                return 0;
-                        }
-                } while (c != '\n');
-        }
-        return 0;
+        host_has_cmov = 0;
+        longjmp(cmov_test_return, 1);
 }
 
-static int check_cpu_flag(char *feature, int *have_it)
-{
-        char buf[MAXTOKEN], c;
-        int fd, len = ARRAY_SIZE(buf);
-
-        printk(UM_KERN_INFO "Checking for host processor %s support...",
-               feature);
-        fd = os_open_file("/proc/cpuinfo", of_read(OPENFLAGS()), 0);
-        if (fd < 0) {
-                printk(UM_KERN_ERR "Couldn't open /proc/cpuinfo, err = %d\n",
-                       -fd);
-                return 0;
-        }
-
-        *have_it = 0;
-        if (!find_cpuinfo_line(fd, "flags", buf, ARRAY_SIZE(buf)))
-                goto out;
-
-        c = token(fd, buf, len - 1, ' ');
-        if (c < 0)
-                goto out;
-        else if (c != ' ') {
-                printk(UM_KERN_ERR "Failed to find ' ' in /proc/cpuinfo\n");
-                goto out;
-        }
-
-        while (1) {
-                c = token(fd, buf, len - 1, ' ');
-                if (c < 0)
-                        goto out;
-                else if (c == '\n')
-                        break;
-
-                if (!strcmp(buf, feature)) {
-                        *have_it = 1;
-                        goto out;
-                }
-        }
- out:
-        if (*have_it == 0)
-                printk("No\n");
-        else if (*have_it == 1)
-                printk("Yes\n");
-        os_close_file(fd);
-        return 1;
-}
-
-#if 0 /*
-       * This doesn't work in tt mode, plus it's causing compilation problems
-       * for some people.
-       */
-static void disable_lcall(void)
+void arch_check_bugs(void)
 {
-        struct modify_ldt_ldt_s ldt;
-        int err;
+        struct sigaction old, new;
 
-        bzero(&ldt, sizeof(ldt));
-        ldt.entry_number = 7;
-        ldt.base_addr = 0;
-        ldt.limit = 0;
-        err = modify_ldt(1, &ldt, sizeof(ldt));
-        if (err)
-                printk(UM_KERN_ERR "Failed to disable lcall7 - errno = %d\n",
-                       errno);
-}
-#endif
+        printk(UM_KERN_INFO "Checking for host processor cmov support...");
+        new.sa_handler = cmov_sigill_test_handler;
 
-void arch_init_thread(void)
-{
-#if 0
-        disable_lcall();
-#endif
-}
+        /* Make sure that SIGILL is enabled after the handler longjmps back */
+        new.sa_flags = SA_NODEFER;
+        sigemptyset(&new.sa_mask);
+        sigaction(SIGILL, &new, &old);
 
-void arch_check_bugs(void)
-{
-        int have_it;
+        if (setjmp(cmov_test_return) == 0) {
+                unsigned long foo = 0;
+                __asm__ __volatile__("cmovz %0, %1" : "=r" (foo) : "0" (foo));
+                printk(UM_KERN_CONT "Yes\n");
+        } else
+                printk(UM_KERN_CONT "No\n");
 
-        if (os_access("/proc/cpuinfo", OS_ACC_R_OK) < 0) {
-                printk(UM_KERN_ERR "/proc/cpuinfo not available - skipping CPU "
-                       "capability checks\n");
-                return;
-        }
-        if (check_cpu_flag("cmov", &have_it))
-                host_has_cmov = have_it;
-        if (check_cpu_flag("xmm", &have_it))
-                host_has_xmm = have_it;
+        sigaction(SIGILL, &old, &new);
 }
 
-int arch_handle_signal(int sig, struct uml_pt_regs *regs)
+void arch_examine_signal(int sig, struct uml_pt_regs *regs)
 {
         unsigned char tmp[2];
 
@@ -176,24 +52,25 @@ int arch_handle_signal(int sig, struct uml_pt_regs *regs)
          * SIGILL in init.
          */
         if ((sig != SIGILL) || (TASK_PID(get_current()) != 1))
-                return 0;
+                return;
+
+        if (copy_from_user_proc(tmp, (void *) UPT_IP(regs), 2)) {
+                printk(UM_KERN_ERR "SIGILL in init, could not read "
+                       "instructions!\n");
+                return;
+        }
 
-        if (copy_from_user_proc(tmp, (void *) UPT_IP(regs), 2))
-                panic("SIGILL in init, could not read instructions!\n");
         if ((tmp[0] != 0x0f) || ((tmp[1] & 0xf0) != 0x40))
-                return 0;
+                return;
 
         if (host_has_cmov == 0)
-                panic("SIGILL caused by cmov, which this processor doesn't "
-                      "implement, boot a filesystem compiled for older "
-                      "processors");
+                printk(UM_KERN_ERR "SIGILL caused by cmov, which this "
+                       "processor doesn't implement.  Boot a filesystem "
+                       "compiled for older processors");
         else if (host_has_cmov == 1)
-                panic("SIGILL caused by cmov, which this processor claims to "
-                      "implement");
-        else if (host_has_cmov == -1)
-                panic("SIGILL caused by cmov, couldn't tell if this processor "
-                      "implements it, boot a filesystem compiled for older "
-                      "processors");
-        else panic("Bad value for host_has_cmov (%d)", host_has_cmov);
-        return 0;
+                printk(UM_KERN_ERR "SIGILL caused by cmov, which this "
+                       "processor claims to implement");
+        else
+                printk(UM_KERN_ERR "Bad value for host_has_cmov (%d)",
+                        host_has_cmov);
 }
diff --git a/arch/um/sys-i386/ldt.c b/arch/um/sys-i386/ldt.c
index 67c0958eb984..a34263e6b08d 100644
--- a/arch/um/sys-i386/ldt.c
+++ b/arch/um/sys-i386/ldt.c
@@ -3,8 +3,9 @@
  * Licensed under the GPL
  */
 
-#include "linux/mm.h"
-#include "asm/unistd.h"
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <asm/unistd.h>
 #include "os.h"
 #include "proc_mm.h"
 #include "skas.h"
@@ -146,7 +147,7 @@ static int read_ldt(void __user * ptr, unsigned long bytecount)
         if (ptrace_ldt)
                 return read_ldt_from_host(ptr, bytecount);
 
-        down(&ldt->semaphore);
+        mutex_lock(&ldt->lock);
         if (ldt->entry_count <= LDT_DIRECT_ENTRIES) {
                 size = LDT_ENTRY_SIZE*LDT_DIRECT_ENTRIES;
                 if (size > bytecount)
@@ -170,7 +171,7 @@ static int read_ldt(void __user * ptr, unsigned long bytecount)
                         ptr += size;
                 }
         }
-        up(&ldt->semaphore);
+        mutex_unlock(&ldt->lock);
 
         if (bytecount == 0 || err == -EFAULT)
                 goto out;
@@ -228,7 +229,7 @@ static int write_ldt(void __user * ptr, unsigned long bytecount, int func)
         }
 
         if (!ptrace_ldt)
-                down(&ldt->semaphore);
+                mutex_lock(&ldt->lock);
 
         err = write_ldt_entry(mm_idp, func, &ldt_info, &addr, 1);
         if (err)
@@ -288,7 +289,7 @@ static int write_ldt(void __user * ptr, unsigned long bytecount, int func)
         err = 0;
 
 out_unlock:
-        up(&ldt->semaphore);
+        mutex_unlock(&ldt->lock);
 out:
         return err;
 }
@@ -395,7 +396,7 @@ long init_new_ldt(struct mm_context *new_mm, struct mm_context *from_mm)
 
 
         if (!ptrace_ldt)
-                init_MUTEX(&new_mm->ldt.semaphore);
+                mutex_init(&new_mm->ldt.lock);
 
         if (!from_mm) {
                 memset(&desc, 0, sizeof(desc));
@@ -455,7 +456,7 @@ long init_new_ldt(struct mm_context *new_mm, struct mm_context *from_mm)
                  * i.e., we have to use the stub for modify_ldt, which
                  * can't handle the big read buffer of up to 64kB.
                  */
-                down(&from_mm->ldt.semaphore);
+                mutex_lock(&from_mm->ldt.lock);
                 if (from_mm->ldt.entry_count <= LDT_DIRECT_ENTRIES)
                         memcpy(new_mm->ldt.u.entries, from_mm->ldt.u.entries,
                                sizeof(new_mm->ldt.u.entries));
@@ -474,7 +475,7 @@ long init_new_ldt(struct mm_context *new_mm, struct mm_context *from_mm)
                         }
                 }
                 new_mm->ldt.entry_count = from_mm->ldt.entry_count;
-                up(&from_mm->ldt.semaphore);
+                mutex_unlock(&from_mm->ldt.lock);
         }
 
     out:
diff --git a/arch/um/sys-i386/ptrace.c b/arch/um/sys-i386/ptrace.c
index bd3da8a61f64..6b4499906a6c 100644
--- a/arch/um/sys-i386/ptrace.c
+++ b/arch/um/sys-i386/ptrace.c
@@ -8,11 +8,11 @@
 #include "asm/uaccess.h"
 #include "skas.h"
 
-extern int arch_switch_tls(struct task_struct *from, struct task_struct *to);
+extern int arch_switch_tls(struct task_struct *to);
 
-void arch_switch_to(struct task_struct *from, struct task_struct *to)
+void arch_switch_to(struct task_struct *to)
 {
-        int err = arch_switch_tls(from, to);
+        int err = arch_switch_tls(to);
         if (!err)
                 return;
 
diff --git a/arch/um/sys-i386/ptrace_user.c b/arch/um/sys-i386/ptrace_user.c
index 5cf97bc229b9..0b10c3e74028 100644
--- a/arch/um/sys-i386/ptrace_user.c
+++ b/arch/um/sys-i386/ptrace_user.c
@@ -19,17 +19,3 @@ int ptrace_setregs(long pid, unsigned long *regs)
                 return -errno;
         return 0;
 }
-
-int ptrace_getfpregs(long pid, unsigned long *regs)
-{
-        if (ptrace(PTRACE_GETFPREGS, pid, 0, regs) < 0)
-                return -errno;
-        return 0;
-}
-
-int ptrace_setfpregs(long pid, unsigned long *regs)
-{
-        if (ptrace(PTRACE_SETFPREGS, pid, 0, regs) < 0)
-                return -errno;
-        return 0;
-}
diff --git a/arch/um/sys-i386/signal.c b/arch/um/sys-i386/signal.c
index 19053d46cb60..fd0c25ad6af3 100644
--- a/arch/um/sys-i386/signal.c
+++ b/arch/um/sys-i386/signal.c
@@ -168,12 +168,13 @@ static int copy_sc_from_user(struct pt_regs *regs,
                              struct sigcontext __user *from)
 {
         struct sigcontext sc;
-        int err;
+        int err, pid;
 
         err = copy_from_user(&sc, from, sizeof(sc));
         if (err)
                 return err;
 
+        pid = userspace_pid[current_thread_info()->cpu];
         copy_sc(&regs->regs, &sc);
         if (have_fpx_regs) {
                 struct user_fxsr_struct fpx;
@@ -187,8 +188,7 @@ static int copy_sc_from_user(struct pt_regs *regs,
                 if (err)
                         return 1;
 
-                err = restore_fpx_registers(userspace_pid[current_thread->cpu],
-                                            (unsigned long *) &fpx);
+                err = restore_fpx_registers(pid, (unsigned long *) &fpx);
                 if (err < 0) {
                         printk(KERN_ERR "copy_sc_from_user - "
                                "restore_fpx_registers failed, errno = %d\n",
@@ -204,8 +204,7 @@ static int copy_sc_from_user(struct pt_regs *regs,
                 if (err)
                         return 1;
 
-                err = restore_fp_registers(userspace_pid[current_thread->cpu],
-                                           (unsigned long *) &fp);
+                err = restore_fp_registers(pid, (unsigned long *) &fp);
                 if (err < 0) {
                         printk(KERN_ERR "copy_sc_from_user - "
                                "restore_fp_registers failed, errno = %d\n",
@@ -223,7 +222,7 @@ static int copy_sc_to_user(struct sigcontext __user *to,
 {
         struct sigcontext sc;
         struct faultinfo * fi = &current->thread.arch.faultinfo;
-        int err;
+        int err, pid;
 
         sc.gs = REGS_GS(regs->regs.gp);
         sc.fs = REGS_FS(regs->regs.gp);
@@ -249,11 +248,11 @@ static int copy_sc_to_user(struct sigcontext __user *to,
         to_fp = (to_fp ? to_fp : (struct _fpstate __user *) (to + 1));
         sc.fpstate = to_fp;
 
+        pid = userspace_pid[current_thread_info()->cpu];
         if (have_fpx_regs) {
                 struct user_fxsr_struct fpx;
 
-                err = save_fpx_registers(userspace_pid[current_thread->cpu],
-                                         (unsigned long *) &fpx);
+                err = save_fpx_registers(pid, (unsigned long *) &fpx);
                 if (err < 0){
                         printk(KERN_ERR "copy_sc_to_user - save_fpx_registers "
                                "failed, errno = %d\n", err);
@@ -276,8 +275,7 @@ static int copy_sc_to_user(struct sigcontext __user *to,
         else {
                 struct user_i387_struct fp;
 
-                err = save_fp_registers(userspace_pid[current_thread->cpu],
-                                        (unsigned long *) &fp);
+                err = save_fp_registers(pid, (unsigned long *) &fp);
                 if (copy_to_user(to_fp, &fp, sizeof(struct user_i387_struct)))
                         return 1;
         }
diff --git a/arch/um/sys-i386/stub.S b/arch/um/sys-i386/stub.S
index e730772c401b..7699e89f660f 100644
--- a/arch/um/sys-i386/stub.S
+++ b/arch/um/sys-i386/stub.S
@@ -7,7 +7,7 @@
         .globl batch_syscall_stub
 batch_syscall_stub:
         /* load pointer to first operation */
-        mov     $(ASM_STUB_DATA+8), %esp
+        mov     $(STUB_DATA+8), %esp
 
 again:
         /* load length of additional data */
@@ -15,12 +15,12 @@ again:
 
         /* if(length == 0) : end of list */
         /* write possible 0 to header */
-        mov     %eax, ASM_STUB_DATA+4
+        mov     %eax, STUB_DATA+4
         cmpl    $0, %eax
         jz      done
 
         /* save current pointer */
-        mov     %esp, ASM_STUB_DATA+4
+        mov     %esp, STUB_DATA+4
 
         /* skip additional data */
         add     %eax, %esp
@@ -46,7 +46,7 @@ again:
 
 done:
         /* save return value */
-        mov     %eax, ASM_STUB_DATA
+        mov     %eax, STUB_DATA
 
         /* stop */
         int3
diff --git a/arch/um/sys-i386/stub_segv.c b/arch/um/sys-i386/stub_segv.c
index b3999cb76bfd..28ccf737a79f 100644
--- a/arch/um/sys-i386/stub_segv.c
+++ b/arch/um/sys-i386/stub_segv.c
@@ -1,32 +1,17 @@
 /*
- * Copyright (C) 2004 Jeff Dike (jdike@addtoit.com)
+ * Copyright (C) 2004 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include <signal.h>
-#include <sys/select.h> /* The only way I can see to get sigset_t */
-#include <asm/unistd.h>
-#include "as-layout.h"
-#include "uml-config.h"
 #include "sysdep/stub.h"
 #include "sysdep/sigcontext.h"
-#include "sysdep/faultinfo.h"
 
 void __attribute__ ((__section__ (".__syscall_stub")))
 stub_segv_handler(int sig)
 {
         struct sigcontext *sc = (struct sigcontext *) (&sig + 1);
-        int pid;
 
         GET_FAULTINFO_FROM_SC(*((struct faultinfo *) STUB_DATA), sc);
 
-        pid = stub_syscall0(__NR_getpid);
-        stub_syscall2(__NR_kill, pid, SIGUSR1);
-
-        /* Load pointer to sigcontext into esp, since we need to leave
-         * the stack in its original form when we do the sigreturn here, by
-         * hand.
-         */
-        __asm__ __volatile__("mov %0,%%esp ; movl %1, %%eax ; "
-                             "int $0x80" : : "a" (sc), "g" (__NR_sigreturn));
+        trap_myself();
 }
diff --git a/arch/um/sys-i386/sys_call_table.S b/arch/um/sys-i386/sys_call_table.S
index 12d4148dba39..00e5f5203eea 100644
--- a/arch/um/sys-i386/sys_call_table.S
+++ b/arch/um/sys-i386/sys_call_table.S
@@ -9,4 +9,9 @@
 
 #define old_mmap old_mmap_i386
 
+.section .rodata,"a"
+
 #include "../../x86/kernel/syscall_table_32.S"
+
+ENTRY(syscall_table_size)
+.long .-sys_call_table
diff --git a/arch/um/sys-i386/tls.c b/arch/um/sys-i386/tls.c
index fcaff86b000c..c6c7131e563b 100644
--- a/arch/um/sys-i386/tls.c
+++ b/arch/um/sys-i386/tls.c
@@ -26,6 +26,11 @@ int do_set_thread_area(struct user_desc *info)
         cpu = get_cpu();
         ret = os_set_thread_area(info, userspace_pid[cpu]);
         put_cpu();
+
+        if (ret)
+                printk(KERN_ERR "PTRACE_SET_THREAD_AREA failed, err = %d, "
+                       "index = %d\n", ret, info->entry_number);
+
         return ret;
 }
 
@@ -37,6 +42,11 @@ int do_get_thread_area(struct user_desc *info)
         cpu = get_cpu();
         ret = os_get_thread_area(info, userspace_pid[cpu]);
         put_cpu();
+
+        if (ret)
+                printk(KERN_ERR "PTRACE_GET_THREAD_AREA failed, err = %d, "
+                       "index = %d\n", ret, info->entry_number);
+
         return ret;
 }
 
@@ -172,7 +182,7 @@ void clear_flushed_tls(struct task_struct *task)
  * SKAS patch.
  */
 
-int arch_switch_tls(struct task_struct *from, struct task_struct *to)
+int arch_switch_tls(struct task_struct *to)
 {
         if (!host_supports_tls)
                 return 0;
@@ -225,7 +235,8 @@ out:
 }
 
 /* XXX: use do_get_thread_area to read the host value? I'm not at all sure! */
-static int get_tls_entry(struct task_struct* task, struct user_desc *info, int idx)
+static int get_tls_entry(struct task_struct *task, struct user_desc *info,
+                         int idx)
 {
         struct thread_struct *t = &task->thread;
 
@@ -263,7 +274,7 @@ clear:
         goto out;
 }
 
-asmlinkage int sys_set_thread_area(struct user_desc __user *user_desc)
+int sys_set_thread_area(struct user_desc __user *user_desc)
 {
         struct user_desc info;
         int idx, ret;
@@ -298,7 +309,7 @@ asmlinkage int sys_set_thread_area(struct user_desc __user *user_desc)
  * i386. However the only possible error are caused by bugs.
  */
 int ptrace_set_thread_area(struct task_struct *child, int idx,
-                struct user_desc __user *user_desc)
+                           struct user_desc __user *user_desc)
 {
         struct user_desc info;
 
@@ -311,7 +322,7 @@ int ptrace_set_thread_area(struct task_struct *child, int idx,
         return set_tls_entry(child, &info, idx, 0);
 }
 
-asmlinkage int sys_get_thread_area(struct user_desc __user *user_desc)
+int sys_get_thread_area(struct user_desc __user *user_desc)
 {
         struct user_desc info;
         int idx, ret;
@@ -355,10 +366,9 @@ out:
         return ret;
 }
 
-
 /*
- * XXX: This part is probably common to i386 and x86-64. Don't create a common
- * file for now, do that when implementing x86-64 support.
+ * This code is really i386-only, but it detects and logs x86_64 GDT indexes
+ * if a 32-bit UML is running on a 64-bit host.
  */
 static int __init __setup_host_supports_tls(void)
 {
@@ -367,13 +377,16 @@ static int __init __setup_host_supports_tls(void)
                 printk(KERN_INFO "Host TLS support detected\n");
                 printk(KERN_INFO "Detected host type: ");
                 switch (host_gdt_entry_tls_min) {
-                        case GDT_ENTRY_TLS_MIN_I386:
-                                printk("i386\n");
-                                break;
-                        case GDT_ENTRY_TLS_MIN_X86_64:
-                                printk("x86_64\n");
-                                break;
+                case GDT_ENTRY_TLS_MIN_I386:
+                        printk(KERN_CONT "i386");
+                        break;
+                case GDT_ENTRY_TLS_MIN_X86_64:
+                        printk(KERN_CONT "x86_64");
+                        break;
                 }
+                printk(KERN_CONT " (GDT indexes %d to %d)\n",
+                       host_gdt_entry_tls_min,
+                       host_gdt_entry_tls_min + GDT_ENTRY_TLS_ENTRIES);
         } else
                 printk(KERN_ERR "  Host TLS support NOT detected! "
                                 "TLS support inside UML will not work\n");
diff --git a/arch/um/sys-ppc/Makefile b/arch/um/sys-ppc/Makefile
index a9814a7ae60e..08901526e893 100644
--- a/arch/um/sys-ppc/Makefile
+++ b/arch/um/sys-ppc/Makefile
@@ -6,7 +6,7 @@ OBJ = built-in.o
 OBJS = ptrace.o sigcontext.o semaphore.o checksum.o miscthings.o misc.o \
         ptrace_user.o sysrq.o
 
-EXTRA_AFLAGS := -DCONFIG_PPC32 -I. -I$(TOPDIR)/arch/ppc/kernel
+EXTRA_AFLAGS := -DCONFIG_PPC32 -I. -I$(srctree)/arch/ppc/kernel
 
 all: $(OBJ)
 
@@ -22,25 +22,25 @@ sigcontext.o: sigcontext.c
 
 semaphore.c:
         rm -f $@
-        ln -s $(TOPDIR)/arch/ppc/kernel/$@ $@
+        ln -s $(srctree)/arch/ppc/kernel/$@ $@
 
 checksum.S:
         rm -f $@
-        ln -s $(TOPDIR)/arch/ppc/lib/$@ $@
+        ln -s $(srctree)/arch/ppc/lib/$@ $@
 
 mk_defs.c:
         rm -f $@
-        ln -s $(TOPDIR)/arch/ppc/kernel/$@ $@
+        ln -s $(srctree)/arch/ppc/kernel/$@ $@
 
 ppc_defs.head:
         rm -f $@
-        ln -s $(TOPDIR)/arch/ppc/kernel/$@ $@
+        ln -s $(srctree)/arch/ppc/kernel/$@ $@
 
 ppc_defs.h: mk_defs.c ppc_defs.head \
-                $(TOPDIR)/include/asm-ppc/mmu.h \
-                $(TOPDIR)/include/asm-ppc/processor.h \
-                $(TOPDIR)/include/asm-ppc/pgtable.h \
-                $(TOPDIR)/include/asm-ppc/ptrace.h
+                $(srctree)/include/asm-ppc/mmu.h \
+                $(srctree)/include/asm-ppc/processor.h \
+                $(srctree)/include/asm-ppc/pgtable.h \
+                $(srctree)/include/asm-ppc/ptrace.h
 #       $(CC) $(CFLAGS) -S mk_defs.c
         cp ppc_defs.head ppc_defs.h
 # for bk, this way we can write to the file even if it's not checked out
@@ -56,13 +56,13 @@ ppc_defs.h: mk_defs.c ppc_defs.head \
 
 checksum.o: checksum.S
         rm -f asm
-        ln -s $(TOPDIR)/include/asm-ppc asm
+        ln -s $(srctree)/include/asm-ppc asm
         $(CC) $(EXTRA_AFLAGS) $(KBUILD_AFLAGS) -D__ASSEMBLY__ -D__UM_PPC__ -c $< -o $*.o
         rm -f asm
 
 misc.o: misc.S ppc_defs.h
         rm -f asm
-        ln -s $(TOPDIR)/include/asm-ppc asm
+        ln -s $(srctree)/include/asm-ppc asm
         $(CC) $(EXTRA_AFLAGS) $(KBUILD_AFLAGS) -D__ASSEMBLY__ -D__UM_PPC__ -c $< -o $*.o
         rm -f asm
 
diff --git a/arch/um/sys-x86_64/bug.c b/arch/um/sys-x86_64/bug.c
index a4360b5207db..e8034e363d83 100644
--- a/arch/um/sys-x86_64/bug.c
+++ b/arch/um/sys-x86_64/bug.c
@@ -5,7 +5,8 @@
 
 #include <linux/uaccess.h>
 
-/* Mostly copied from i386/x86_86 - eliminated the eip < PAGE_OFFSET because
+/*
+ * Mostly copied from i386/x86_86 - eliminated the eip < PAGE_OFFSET because
  * that's not relevant in skas mode.
  */
 
diff --git a/arch/um/sys-x86_64/bugs.c b/arch/um/sys-x86_64/bugs.c
index 506b6765bbcb..44e02ba2a265 100644
--- a/arch/um/sys-x86_64/bugs.c
+++ b/arch/um/sys-x86_64/bugs.c
@@ -6,15 +6,10 @@
 
 #include "sysdep/ptrace.h"
 
-void arch_init_thread(void)
-{
-}
-
 void arch_check_bugs(void)
 {
 }
 
-int arch_handle_signal(int sig, struct uml_pt_regs *regs)
+void arch_examine_signal(int sig, struct uml_pt_regs *regs)
 {
-        return 0;
 }
diff --git a/arch/um/sys-x86_64/ptrace.c b/arch/um/sys-x86_64/ptrace.c
index b7631b0e9ddc..f3458d7d1c5a 100644
--- a/arch/um/sys-x86_64/ptrace.c
+++ b/arch/um/sys-x86_64/ptrace.c
@@ -5,13 +5,12 @@
  * Licensed under the GPL
  */
 
-#define __FRAME_OFFSETS
-#include <asm/ptrace.h>
+#include <linux/mm.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
-#include <linux/mm.h>
+#define __FRAME_OFFSETS
+#include <asm/ptrace.h>
 #include <asm/uaccess.h>
-#include <asm/elf.h>
 
 /*
  * determines which flags the user has access to.
@@ -24,12 +23,14 @@ int putreg(struct task_struct *child, int regno, unsigned long value)
         unsigned long tmp;
 
 #ifdef TIF_IA32
-        /* Some code in the 64bit emulation may not be 64bit clean.
-           Don't take any chances. */
+        /*
+         * Some code in the 64bit emulation may not be 64bit clean.
+         * Don't take any chances.
+         */
         if (test_tsk_thread_flag(child, TIF_IA32))
                 value &= 0xffffffff;
 #endif
-        switch (regno){
+        switch (regno) {
         case FS:
         case GS:
         case DS:
@@ -66,7 +67,7 @@ int poke_user(struct task_struct *child, long addr, long data)
         if (addr < MAX_REG_OFFSET)
                 return putreg(child, addr, data);
         else if ((addr >= offsetof(struct user, u_debugreg[0])) &&
-                (addr <= offsetof(struct user, u_debugreg[7]))){
+                (addr <= offsetof(struct user, u_debugreg[7]))) {
                 addr -= offsetof(struct user, u_debugreg[0]);
                 addr = addr >> 2;
                 if ((addr == 4) || (addr == 5))
@@ -108,11 +109,10 @@ int peek_user(struct task_struct *child, long addr, long data)
                 return -EIO;
 
         tmp = 0;  /* Default return condition */
-        if (addr < MAX_REG_OFFSET){
+        if (addr < MAX_REG_OFFSET)
                 tmp = getreg(child, addr);
-        }
         else if ((addr >= offsetof(struct user, u_debugreg[0])) &&
-                (addr <= offsetof(struct user, u_debugreg[7]))){
+                (addr <= offsetof(struct user, u_debugreg[7]))) {
                 addr -= offsetof(struct user, u_debugreg[0]);
                 addr = addr >> 2;
                 tmp = child->thread.arch.debugregs[addr];
@@ -127,8 +127,9 @@ int is_syscall(unsigned long addr)
         int n;
 
         n = copy_from_user(&instr, (void __user *) addr, sizeof(instr));
-        if (n){
-                /* access_process_vm() grants access to vsyscall and stub,
+        if (n) {
+                /*
+                 * access_process_vm() grants access to vsyscall and stub,
                  * while copy_from_user doesn't. Maybe access_process_vm is
                  * slow, but that doesn't matter, since it will be called only
                  * in case of singlestepping, if copy_from_user failed.
@@ -155,7 +156,7 @@ int get_fpregs(struct user_i387_struct __user *buf, struct task_struct *child)
                 return err;
 
         n = copy_to_user(buf, fpregs, sizeof(fpregs));
-        if(n > 0)
+        if (n > 0)
                 return -EFAULT;
 
         return n;
diff --git a/arch/um/sys-x86_64/ptrace_user.c b/arch/um/sys-x86_64/ptrace_user.c
index b5f9c33e311e..c57a496d3f5b 100644
--- a/arch/um/sys-x86_64/ptrace_user.c
+++ b/arch/um/sys-x86_64/ptrace_user.c
@@ -4,55 +4,19 @@
  * Licensed under the GPL
  */
 
-#include <stddef.h>
 #include <errno.h>
 #include "ptrace_user.h"
-#include "user.h"
-#include "kern_constants.h"
 
 int ptrace_getregs(long pid, unsigned long *regs_out)
 {
-        if(ptrace(PTRACE_GETREGS, pid, 0, regs_out) < 0)
-                return(-errno);
-        return(0);
-}
-
-int ptrace_setregs(long pid, unsigned long *regs)
-{
-        if(ptrace(PTRACE_SETREGS, pid, 0, regs) < 0)
-                return(-errno);
+        if (ptrace(PTRACE_GETREGS, pid, 0, regs_out) < 0)
+                return -errno;
         return(0);
 }
 
-int ptrace_setfpregs(long pid, unsigned long *regs)
+int ptrace_setregs(long pid, unsigned long *regs_out)
 {
-        if (ptrace(PTRACE_SETFPREGS, pid, 0, regs) < 0)
+        if (ptrace(PTRACE_SETREGS, pid, 0, regs_out) < 0)
                 return -errno;
-        return 0;
-}
-
-void ptrace_pokeuser(unsigned long addr, unsigned long data)
-{
-        panic("ptrace_pokeuser");
-}
-
-#define DS 184
-#define ES 192
-#define __USER_DS     0x2b
-
-void arch_enter_kernel(void *task, int pid)
-{
-}
-
-void arch_leave_kernel(void *task, int pid)
-{
-#ifdef UM_USER_CS
-        if(ptrace(PTRACE_POKEUSR, pid, CS, UM_USER_CS) < 0)
-                printk("POKEUSR CS failed");
-#endif
-
-        if(ptrace(PTRACE_POKEUSR, pid, DS, __USER_DS) < 0)
-                printk("POKEUSR DS failed");
-        if(ptrace(PTRACE_POKEUSR, pid, ES, __USER_DS) < 0)
-                printk("POKEUSR ES failed");
+        return(0);
 }
diff --git a/arch/um/sys-x86_64/signal.c b/arch/um/sys-x86_64/signal.c
index 7457436b433a..1a899a7ed7a6 100644
--- a/arch/um/sys-x86_64/signal.c
+++ b/arch/um/sys-x86_64/signal.c
@@ -81,7 +81,7 @@ static int copy_sc_from_user(struct pt_regs *regs,
         if (err)
                 return 1;
 
-        err = restore_fp_registers(userspace_pid[current_thread->cpu],
+        err = restore_fp_registers(userspace_pid[current_thread_info()->cpu],
                                    (unsigned long *) &fp);
         if (err < 0) {
                 printk(KERN_ERR "copy_sc_from_user - "
@@ -112,7 +112,7 @@ static int copy_sc_to_user(struct sigcontext __user *to,
         err |= PUTREG(regs, RSI, to, si);
         err |= PUTREG(regs, RBP, to, bp);
         /*
-         * Must use orignal RSP, which is passed in, rather than what's in
+         * Must use original RSP, which is passed in, rather than what's in
          * the pt_regs, because that's already been updated to point at the
          * signal frame.
          */
@@ -143,7 +143,7 @@ static int copy_sc_to_user(struct sigcontext __user *to,
         if (err)
                 return 1;
 
-        err = save_fp_registers(userspace_pid[current_thread->cpu],
+        err = save_fp_registers(userspace_pid[current_thread_info()->cpu],
                                 (unsigned long *) &fp);
         if (err < 0) {
                 printk(KERN_ERR "copy_sc_from_user - restore_fp_registers "
diff --git a/arch/um/sys-x86_64/stub.S b/arch/um/sys-x86_64/stub.S
index 4afe204a6af7..568768763155 100644
--- a/arch/um/sys-x86_64/stub.S
+++ b/arch/um/sys-x86_64/stub.S
@@ -8,18 +8,18 @@ syscall_stub:
         /* We don't have 64-bit constants, so this constructs the address
          * we need.
          */
-        movq    $(ASM_STUB_DATA >> 32), %rbx
+        movq    $(STUB_DATA >> 32), %rbx
         salq    $32, %rbx
-        movq    $(ASM_STUB_DATA & 0xffffffff), %rcx
+        movq    $(STUB_DATA & 0xffffffff), %rcx
         or      %rcx, %rbx
         movq    %rax, (%rbx)
         int3
 
         .globl batch_syscall_stub
 batch_syscall_stub:
-        mov     $(ASM_STUB_DATA >> 32), %rbx
+        mov     $(STUB_DATA >> 32), %rbx
         sal     $32, %rbx
-        mov     $(ASM_STUB_DATA & 0xffffffff), %rax
+        mov     $(STUB_DATA & 0xffffffff), %rax
         or      %rax, %rbx
         /* load pointer to first operation */
         mov     %rbx, %rsp
diff --git a/arch/um/sys-x86_64/stub_segv.c b/arch/um/sys-x86_64/stub_segv.c
index 3afb590f0072..ced051afc705 100644
--- a/arch/um/sys-x86_64/stub_segv.c
+++ b/arch/um/sys-x86_64/stub_segv.c
@@ -1,51 +1,22 @@
 /*
- * Copyright (C) 2004 Jeff Dike (jdike@addtoit.com)
+ * Copyright (C) 2004 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Licensed under the GPL
  */
 
-#include <stddef.h>
 #include <signal.h>
-#include <asm/unistd.h>
 #include "as-layout.h"
-#include "uml-config.h"
-#include "sysdep/sigcontext.h"
-#include "sysdep/faultinfo.h"
 #include "sysdep/stub.h"
-
-/* Copied from sys-x86_64/signal.c - Can't find an equivalent definition
- * in the libc headers anywhere.
- */
-struct rt_sigframe
-{
-        char *pretcode;
-        struct ucontext uc;
-        struct siginfo info;
-};
-
-/* Copied here from <linux/kernel.h> - we're userspace. */
-#define container_of(ptr, type, member) ({                   \
-        const typeof( ((type *)0)->member ) *__mptr = (ptr); \
-        (type *)( (char *)__mptr - offsetof(type,member) );})
+#include "sysdep/faultinfo.h"
+#include "sysdep/sigcontext.h"
 
 void __attribute__ ((__section__ (".__syscall_stub")))
 stub_segv_handler(int sig)
 {
         struct ucontext *uc;
-        int pid;
 
         __asm__ __volatile__("movq %%rdx, %0" : "=g" (uc) :);
         GET_FAULTINFO_FROM_SC(*((struct faultinfo *) STUB_DATA),
                               &uc->uc_mcontext);
-
-        pid = stub_syscall0(__NR_getpid);
-        stub_syscall2(__NR_kill, pid, SIGUSR1);
-
-        /* sys_sigreturn expects that the stack pointer will be 8 bytes into
-         * the signal frame.  So, we use the ucontext pointer, which we know
-         * already, to get the signal frame pointer, and add 8 to that.
-         */
-        __asm__ __volatile__("movq %0, %%rsp; movq %1, %%rax ; syscall": :
-                             "g" ((unsigned long)
-                                  container_of(uc, struct rt_sigframe, uc) + 8),
-                             "g" (__NR_rt_sigreturn));
+        trap_myself();
 }
+
diff --git a/arch/um/sys-x86_64/syscall_table.c b/arch/um/sys-x86_64/syscall_table.c
index 71b2ae4ad5de..c128eb897008 100644
--- a/arch/um/sys-x86_64/syscall_table.c
+++ b/arch/um/sys-x86_64/syscall_table.c
@@ -1,5 +1,7 @@
-/* System call table for UML/x86-64, copied from arch/x86_64/kernel/syscall.c
- * with some changes for UML. */
+/*
+ * System call table for UML/x86-64, copied from arch/x86_64/kernel/syscall.c
+ * with some changes for UML.
+ */
 
 #include <linux/linkage.h>
 #include <linux/sys.h>
@@ -8,22 +10,26 @@
 
 #define __NO_STUBS
 
-/* Below you can see, in terms of #define's, the differences between the x86-64
- * and the UML syscall table. */
+/*
+ * Below you can see, in terms of #define's, the differences between the x86-64
+ * and the UML syscall table.
+ */
 
 /* Not going to be implemented by UML, since we have no hardware. */
 #define stub_iopl sys_ni_syscall
 #define sys_ioperm sys_ni_syscall
 
-/* The UML TLS problem. Note that x86_64 does not implement this, so the below
- * is needed only for the ia32 compatibility. */
-/*#define sys_set_thread_area sys_ni_syscall
-#define sys_get_thread_area sys_ni_syscall*/
+/*
+ * The UML TLS problem. Note that x86_64 does not implement this, so the below
+ * is needed only for the ia32 compatibility.
+ */
 
 /* On UML we call it this way ("old" means it's not mmap2) */
 #define sys_mmap old_mmap
-/* On x86-64 sys_uname is actually sys_newuname plus a compatibility trick.
- * See arch/x86_64/kernel/sys_x86_64.c */
+/*
+ * On x86-64 sys_uname is actually sys_newuname plus a compatibility trick.
+ * See arch/x86_64/kernel/sys_x86_64.c
+ */
 #define sys_uname sys_uname64
 
 #define stub_clone sys_clone
@@ -46,8 +52,19 @@ typedef void (*sys_call_ptr_t)(void);
 
 extern void sys_ni_syscall(void);
 
-sys_call_ptr_t sys_call_table[UM_NR_syscall_max+1] __cacheline_aligned = {
-        /* Smells like a like a compiler bug -- it doesn't work when the & below is removed. */
-        [0 ... UM_NR_syscall_max] = &sys_ni_syscall,
+/*
+ * We used to have a trick here which made sure that holes in the
+ * x86_64 table were filled in with sys_ni_syscall, but a comment in
+ * unistd_64.h says that holes aren't allowed, so the trick was
+ * removed.
+ * The trick looked like this
+ *      [0 ... UM_NR_syscall_max] = &sys_ni_syscall
+ * before including unistd_64.h - the later initializations overwrote
+ * the sys_ni_syscall filler.
+ */
+
+sys_call_ptr_t sys_call_table[] __cacheline_aligned = {
 #include <asm-x86/unistd_64.h>
 };
+
+int syscall_table_size = sizeof(sys_call_table);
diff --git a/arch/um/sys-x86_64/syscalls.c b/arch/um/sys-x86_64/syscalls.c
index 86f6b18410ee..f1199fd34d38 100644
--- a/arch/um/sys-x86_64/syscalls.c
+++ b/arch/um/sys-x86_64/syscalls.c
@@ -48,7 +48,9 @@ long arch_prctl(struct task_struct *task, int code, unsigned long __user *addr)
         switch (code) {
         case ARCH_SET_FS:
         case ARCH_SET_GS:
-                restore_registers(pid, &current->thread.regs.regs);
+                ret = restore_registers(pid, &current->thread.regs.regs);
+                if (ret)
+                        return ret;
                 break;
         case ARCH_GET_FS:
         case ARCH_GET_GS:
@@ -70,10 +72,10 @@ long arch_prctl(struct task_struct *task, int code, unsigned long __user *addr)
         switch (code) {
         case ARCH_SET_FS:
                 current->thread.arch.fs = (unsigned long) ptr;
-                save_registers(pid, &current->thread.regs.regs);
+                ret = save_registers(pid, &current->thread.regs.regs);
                 break;
         case ARCH_SET_GS:
-                save_registers(pid, &current->thread.regs.regs);
+                ret = save_registers(pid, &current->thread.regs.regs);
                 break;
         case ARCH_GET_FS:
                 ret = put_user(tmp, addr);
@@ -105,7 +107,7 @@ long sys_clone(unsigned long clone_flags, unsigned long newsp,
         return ret;
 }
 
-void arch_switch_to(struct task_struct *from, struct task_struct *to)
+void arch_switch_to(struct task_struct *to)
 {
         if ((to->thread.arch.fs == 0) || (to->mm == NULL))
                 return;
diff --git a/arch/um/sys-x86_64/sysrq.c b/arch/um/sys-x86_64/sysrq.c
index 765444031819..f4f82beb3508 100644
--- a/arch/um/sys-x86_64/sysrq.c
+++ b/arch/um/sys-x86_64/sysrq.c
@@ -4,32 +4,33 @@
  * Licensed under the GPL
  */
 
-#include "linux/kernel.h"
-#include "linux/utsname.h"
-#include "linux/module.h"
-#include "asm/current.h"
-#include "asm/ptrace.h"
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/utsname.h>
+#include <asm/current.h>
+#include <asm/ptrace.h>
 #include "sysrq.h"
 
-void __show_regs(struct pt_regs * regs)
+void __show_regs(struct pt_regs *regs)
 {
         printk("\n");
         print_modules();
-        printk("Pid: %d, comm: %.20s %s %s\n", task_pid_nr(current),
+        printk(KERN_INFO "Pid: %d, comm: %.20s %s %s\n", task_pid_nr(current),
                 current->comm, print_tainted(), init_utsname()->release);
-        printk("RIP: %04lx:[<%016lx>] ", PT_REGS_CS(regs) & 0xffff,
+        printk(KERN_INFO "RIP: %04lx:[<%016lx>]\n", PT_REGS_CS(regs) & 0xffff,
                PT_REGS_RIP(regs));
-        printk("\nRSP: %016lx  EFLAGS: %08lx\n", PT_REGS_RSP(regs),
+        printk(KERN_INFO "RSP: %016lx  EFLAGS: %08lx\n", PT_REGS_RSP(regs),
                PT_REGS_EFLAGS(regs));
-        printk("RAX: %016lx RBX: %016lx RCX: %016lx\n",
+        printk(KERN_INFO "RAX: %016lx RBX: %016lx RCX: %016lx\n",
                PT_REGS_RAX(regs), PT_REGS_RBX(regs), PT_REGS_RCX(regs));
-        printk("RDX: %016lx RSI: %016lx RDI: %016lx\n",
+        printk(KERN_INFO "RDX: %016lx RSI: %016lx RDI: %016lx\n",
                PT_REGS_RDX(regs), PT_REGS_RSI(regs), PT_REGS_RDI(regs));
-        printk("RBP: %016lx R08: %016lx R09: %016lx\n",
+        printk(KERN_INFO "RBP: %016lx R08: %016lx R09: %016lx\n",
                PT_REGS_RBP(regs), PT_REGS_R8(regs), PT_REGS_R9(regs));
-        printk("R10: %016lx R11: %016lx R12: %016lx\n",
+        printk(KERN_INFO "R10: %016lx R11: %016lx R12: %016lx\n",
                PT_REGS_R10(regs), PT_REGS_R11(regs), PT_REGS_R12(regs));
-        printk("R13: %016lx R14: %016lx R15: %016lx\n",
+        printk(KERN_INFO "R13: %016lx R14: %016lx R15: %016lx\n",
                PT_REGS_R13(regs), PT_REGS_R14(regs), PT_REGS_R15(regs));
 }
 
diff --git a/arch/um/sys-x86_64/um_module.c b/arch/um/sys-x86_64/um_module.c
index 8b8eff1bd977..3dead392a415 100644
--- a/arch/um/sys-x86_64/um_module.c
+++ b/arch/um/sys-x86_64/um_module.c
@@ -1,7 +1,7 @@
 #include <linux/vmalloc.h>
 #include <linux/moduleloader.h>
 
-/*Copied from i386 arch/i386/kernel/module.c */
+/* Copied from i386 arch/i386/kernel/module.c */
 void *module_alloc(unsigned long size)
 {
         if (size == 0)
@@ -13,7 +13,9 @@ void *module_alloc(unsigned long size)
 void module_free(struct module *mod, void *module_region)
 {
         vfree(module_region);
-        /* FIXME: If module_region == mod->init_region, trim exception
-           table entries. */
+        /*
+         * FIXME: If module_region == mod->init_region, trim exception
+         * table entries.
+         */
 }
 
diff --git a/arch/v850/Kconfig b/arch/v850/Kconfig
index b6a50b8b38de..ace479ab273f 100644
--- a/arch/v850/Kconfig
+++ b/arch/v850/Kconfig
@@ -331,8 +331,6 @@ source "sound/Kconfig"
 
 source "drivers/usb/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/v850/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index 65b449134cf7..434821187cfc 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -18,6 +18,8 @@ config X86_64
 ### Arch settings
 config X86
         def_bool y
+        select HAVE_OPROFILE
+        select HAVE_KPROBES
 
 config GENERIC_LOCKBREAK
         def_bool n
@@ -44,6 +46,9 @@ config LOCKDEP_SUPPORT
 config STACKTRACE_SUPPORT
         def_bool y
 
+config HAVE_LATENCYTOP_SUPPORT
+        def_bool y
+
 config SEMAPHORE_SLEEPERS
         def_bool y
 
@@ -103,12 +108,16 @@ config GENERIC_TIME_VSYSCALL
 config HAVE_SETUP_PER_CPU_AREA
         def_bool X86_64
 
-config ARCH_SUPPORTS_OPROFILE
-        bool
-        default y
-
 select HAVE_KVM
 
+config ARCH_HIBERNATION_POSSIBLE
+        def_bool y
+        depends on !SMP || !X86_VOYAGER
+
+config ARCH_SUSPEND_POSSIBLE
+        def_bool y
+        depends on !X86_VOYAGER
+
 config ZONE_DMA32
         bool
         default X86_64
@@ -193,8 +202,7 @@ config SMP
           Y to "Enhanced Real Time Clock Support", below. The "Advanced Power
           Management" code will be disabled if you say Y here.
 
-          See also the <file:Documentation/smp.txt>,
-          <file:Documentation/i386/IO-APIC.txt>,
+          See also <file:Documentation/i386/IO-APIC.txt>,
           <file:Documentation/nmi_watchdog.txt> and the SMP-HOWTO available at
           <http://www.tldp.org/docs.html#howto>.
 
@@ -298,6 +306,7 @@ config X86_RDC321X
         select M486
         select X86_REBOOTFIXUPS
         select GENERIC_GPIO
+        select LEDS_CLASS
         select LEDS_GPIO
         help
           This option is needed for RDC R-321x system-on-chip, also known
@@ -456,6 +465,9 @@ config CALGARY_IOMMU_ENABLED_BY_DEFAULT
           Calgary anyway, pass 'iommu=calgary' on the kernel command line.
           If unsure, say Y.
 
+config IOMMU_HELPER
+        def_bool (CALGARY_IOMMU || GART_IOMMU)
+
 # need this always selected by IOMMU for the VIA workaround
 config SWIOTLB
         bool
@@ -1366,11 +1378,6 @@ config PCI
           your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
           VESA. If you have PCI, say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.tldp.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't.
-
 choice
         prompt "PCI access mode"
         depends on X86_32 && PCI && !X86_VISWS
@@ -1591,8 +1598,6 @@ source "drivers/firmware/Kconfig"
 
 source "fs/Kconfig"
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/x86/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/x86/Makefile b/arch/x86/Makefile
index da8f4129780b..364865b1b08d 100644
--- a/arch/x86/Makefile
+++ b/arch/x86/Makefile
@@ -92,7 +92,6 @@ KBUILD_AFLAGS += $(cfi) $(cfi-sigframe)
 KBUILD_CFLAGS += $(cfi) $(cfi-sigframe)
 
 LDFLAGS := -m elf_$(UTS_MACHINE)
-OBJCOPYFLAGS := -O binary -R .note -R .comment -S
 
 # Speed up the build
 KBUILD_CFLAGS += -pipe
@@ -143,7 +142,7 @@ mcore-$(CONFIG_X86_ES7000)	:= arch/x86/mach-default/
 
 # RDC R-321x subarch support
 mflags-$(CONFIG_X86_RDC321X)    := -Iinclude/asm-x86/mach-rdc321x
-mcore-$(CONFIG_X86_RDC321X)     := arch/x86/mach-default
+mcore-$(CONFIG_X86_RDC321X)     := arch/x86/mach-default/
 core-$(CONFIG_X86_RDC321X)      += arch/x86/mach-rdc321x/
 
 # default subarch .h files
diff --git a/arch/x86/boot/Makefile b/arch/x86/boot/Makefile
index 349b81a39c40..f88458e83ef0 100644
--- a/arch/x86/boot/Makefile
+++ b/arch/x86/boot/Makefile
@@ -26,7 +26,7 @@ SVGA_MODE := -DSVGA_MODE=NORMAL_VGA
 #RAMDISK := -DRAMDISK=512
 
 targets         := vmlinux.bin setup.bin setup.elf zImage bzImage
-subdir-         := compressed
+subdir-         := compressed
 
 setup-y         += a20.o cmdline.o copy.o cpu.o cpucheck.o edd.o
 setup-y         += header.o main.o mca.o memory.o pm.o pmjump.o
@@ -43,9 +43,17 @@ setup-y		+= video-vesa.o
 setup-y         += video-bios.o
 
 targets         += $(setup-y)
-hostprogs-y     := tools/build
+hostprogs-y     := mkcpustr tools/build
 
-HOSTCFLAGS_build.o := $(LINUXINCLUDE)
+HOST_EXTRACFLAGS += $(LINUXINCLUDE)
+
+$(obj)/cpu.o: $(obj)/cpustr.h
+
+quiet_cmd_cpustr = CPUSTR  $@
+      cmd_cpustr = $(obj)/mkcpustr > $@
+targets         += cpustr.h
+$(obj)/cpustr.h: $(obj)/mkcpustr FORCE
+        $(call if_changed,cpustr)
 
 # ---------------------------------------------------------------------------
 
@@ -80,6 +88,7 @@ $(obj)/zImage $(obj)/bzImage: $(obj)/setup.bin \
         $(call if_changed,image)
         @echo 'Kernel: $@ is ready' ' (#'`cat .version`')'
 
+OBJCOPYFLAGS_vmlinux.bin := -O binary -R .note -R .comment -S
 $(obj)/vmlinux.bin: $(obj)/compressed/vmlinux FORCE
         $(call if_changed,objcopy)
 
@@ -90,7 +99,6 @@ $(obj)/setup.elf: $(src)/setup.ld $(SETUP_OBJS) FORCE
         $(call if_changed,ld)
 
 OBJCOPYFLAGS_setup.bin  := -O binary
-
 $(obj)/setup.bin: $(obj)/setup.elf FORCE
         $(call if_changed,objcopy)
 
@@ -98,7 +106,7 @@ $(obj)/compressed/vmlinux: FORCE
         $(Q)$(MAKE) $(build)=$(obj)/compressed IMAGE_OFFSET=$(IMAGE_OFFSET) $@
 
 # Set this if you want to pass append arguments to the zdisk/fdimage/isoimage kernel
-FDARGS = 
+FDARGS =
 # Set this if you want an initrd included with the zdisk/fdimage/isoimage kernel
 FDINITRD =
 
diff --git a/arch/x86/boot/compressed/Makefile b/arch/x86/boot/compressed/Makefile
index fe24ceabd909..d2b9f3bb87c0 100644
--- a/arch/x86/boot/compressed/Makefile
+++ b/arch/x86/boot/compressed/Makefile
@@ -22,6 +22,7 @@ $(obj)/vmlinux: $(src)/vmlinux_$(BITS).lds $(obj)/head_$(BITS).o $(obj)/misc.o $
         $(call if_changed,ld)
         @:
 
+OBJCOPYFLAGS_vmlinux.bin := -O binary -R .note -R .comment -S
 $(obj)/vmlinux.bin: vmlinux FORCE
         $(call if_changed,objcopy)
 
diff --git a/arch/x86/boot/compressed/head_64.S b/arch/x86/boot/compressed/head_64.S
index 1ccb38a7f0d2..e8657b98c902 100644
--- a/arch/x86/boot/compressed/head_64.S
+++ b/arch/x86/boot/compressed/head_64.S
@@ -80,8 +80,8 @@ startup_32:
 
 #ifdef CONFIG_RELOCATABLE
         movl    %ebp, %ebx
-        addl    $(LARGE_PAGE_SIZE -1), %ebx
-        andl    $LARGE_PAGE_MASK, %ebx
+        addl    $(PMD_PAGE_SIZE -1), %ebx
+        andl    $PMD_PAGE_MASK, %ebx
 #else
         movl    $CONFIG_PHYSICAL_START, %ebx
 #endif
@@ -220,8 +220,8 @@ ENTRY(startup_64)
         /* Start with the delta to where the kernel will run at. */
 #ifdef CONFIG_RELOCATABLE
         leaq    startup_32(%rip) /* - $startup_32 */, %rbp
-        addq    $(LARGE_PAGE_SIZE - 1), %rbp
-        andq    $LARGE_PAGE_MASK, %rbp
+        addq    $(PMD_PAGE_SIZE - 1), %rbp
+        andq    $PMD_PAGE_MASK, %rbp
         movq    %rbp, %rbx
 #else
         movq    $CONFIG_PHYSICAL_START, %rbp
diff --git a/arch/x86/boot/compressed/vmlinux_64.lds b/arch/x86/boot/compressed/vmlinux_64.lds
index f6e5b445f457..7e5c7209f6cc 100644
--- a/arch/x86/boot/compressed/vmlinux_64.lds
+++ b/arch/x86/boot/compressed/vmlinux_64.lds
@@ -3,7 +3,7 @@ OUTPUT_ARCH(i386:x86-64)
 ENTRY(startup_64)
 SECTIONS
 {
-        /* Be careful parts of head_64.S assume startup_64 is at
+        /* Be careful parts of head_64.S assume startup_32 is at
          * address 0.
          */
         . = 0;
diff --git a/arch/x86/boot/cpu.c b/arch/x86/boot/cpu.c
index 2a5c32da5852..00e19edd852c 100644
--- a/arch/x86/boot/cpu.c
+++ b/arch/x86/boot/cpu.c
@@ -1,7 +1,7 @@
 /* -*- linux-c -*- ------------------------------------------------------- *
  *
  *   Copyright (C) 1991, 1992 Linus Torvalds
- *   Copyright 2007 rPath, Inc. - All Rights Reserved
+ *   Copyright 2007-2008 rPath, Inc. - All Rights Reserved
  *
  *   This file is part of the Linux kernel, and is made available under
  *   the terms of the GNU General Public License version 2.
@@ -9,7 +9,7 @@
  * ----------------------------------------------------------------------- */
 
 /*
- * arch/i386/boot/cpu.c
+ * arch/x86/boot/cpu.c
  *
  * Check for obligatory CPU features and abort if the features are not
  * present.
@@ -19,6 +19,8 @@
 #include "bitops.h"
 #include <asm/cpufeature.h>
 
+#include "cpustr.h"
+
 static char *cpu_name(int level)
 {
         static char buf[6];
@@ -35,6 +37,7 @@ int validate_cpu(void)
 {
         u32 *err_flags;
         int cpu_level, req_level;
+        const unsigned char *msg_strs;
 
         check_cpu(&cpu_level, &req_level, &err_flags);
 
@@ -51,13 +54,26 @@ int validate_cpu(void)
                 puts("This kernel requires the following features "
                      "not present on the CPU:\n");
 
+                msg_strs = (const unsigned char *)x86_cap_strs;
+
                 for (i = 0; i < NCAPINTS; i++) {
                         u32 e = err_flags[i];
 
                         for (j = 0; j < 32; j++) {
-                                if (e & 1)
-                                        printf("%d:%d ", i, j);
-
+                                int n = (i << 5)+j;
+                                if (*msg_strs < n) {
+                                        /* Skip to the next string */
+                                        do {
+                                                msg_strs++;
+                                        } while (*msg_strs);
+                                        msg_strs++;
+                                }
+                                if (e & 1) {
+                                        if (*msg_strs == n && msg_strs[1])
+                                                printf("%s ", msg_strs+1);
+                                        else
+                                                printf("%d:%d ", i, j);
+                                }
                                 e >>= 1;
                         }
                 }
diff --git a/arch/x86/boot/mkcpustr.c b/arch/x86/boot/mkcpustr.c
new file mode 100644
index 000000000000..bbe76953bae9
--- /dev/null
+++ b/arch/x86/boot/mkcpustr.c
@@ -0,0 +1,49 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2008 rPath, Inc. - All Rights Reserved
+ *
+ *   This file is part of the Linux kernel, and is made available under
+ *   the terms of the GNU General Public License version 2 or (at your
+ *   option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * This is a host program to preprocess the CPU strings into a
+ * compact format suitable for the setup code.
+ */
+
+#include <stdio.h>
+
+#include "../kernel/cpu/feature_names.c"
+
+#if NCAPFLAGS > 8
+# error "Need to adjust the boot code handling of CPUID strings"
+#endif
+
+int main(void)
+{
+        int i;
+        const char *str;
+
+        printf("static const char x86_cap_strs[] = \n");
+
+        for (i = 0; i < NCAPINTS*32; i++) {
+                str = x86_cap_flags[i];
+
+                if (i == NCAPINTS*32-1) {
+                        /* The last entry must be unconditional; this
+                           also consumes the compiler-added null character */
+                        if (!str)
+                                str = "";
+                        printf("\t\"\\x%02x\"\"%s\"\n", i, str);
+                } else if (str) {
+                        printf("#if REQUIRED_MASK%d & (1 << %d)\n"
+                               "\t\"\\x%02x\"\"%s\\0\"\n"
+                               "#endif\n",
+                               i >> 5, i & 31, i, str);
+                }
+        }
+        printf("\t;\n");
+        return 0;
+}
diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S
index 0db0a6291bbd..8022d3c695c0 100644
--- a/arch/x86/ia32/ia32entry.S
+++ b/arch/x86/ia32/ia32entry.S
@@ -722,7 +722,9 @@ ia32_sys_call_table:
         .quad sys_epoll_pwait
         .quad compat_sys_utimensat      /* 320 */
         .quad compat_sys_signalfd
-        .quad compat_sys_timerfd
+        .quad sys_timerfd_create
         .quad sys_eventfd
         .quad sys32_fallocate
+        .quad compat_sys_timerfd_settime        /* 325 */
+        .quad compat_sys_timerfd_gettime
 ia32_syscall_end:
diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile
index 6f813009d44b..21dc1a061bf1 100644
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@@ -37,7 +37,8 @@ obj-$(CONFIG_X86_MSR)		+= msr.o
 obj-$(CONFIG_X86_CPUID)         += cpuid.o
 obj-$(CONFIG_MICROCODE)         += microcode.o
 obj-$(CONFIG_PCI)               += early-quirks.o
-obj-$(CONFIG_APM)               += apm_32.o
+apm-y                           := apm_32.o
+obj-$(CONFIG_APM)               += apm.o
 obj-$(CONFIG_X86_SMP)           += smp_$(BITS).o smpboot_$(BITS).o tsc_sync.o
 obj-$(CONFIG_X86_32_SMP)        += smpcommon_32.o
 obj-$(CONFIG_X86_64_SMP)        += smp_64.o smpboot_64.o tsc_sync.o
@@ -74,7 +75,8 @@ ifdef CONFIG_INPUT_PCSPKR
 obj-y                           += pcspeaker.o
 endif
 
-obj-$(CONFIG_SCx200)            += scx200_32.o
+obj-$(CONFIG_SCx200)            += scx200.o
+scx200-y                        += scx200_32.o
 
 ###
 # 64 bit specific files
diff --git a/arch/x86/kernel/acpi/boot.c b/arch/x86/kernel/acpi/boot.c
index 0ca27c7b0e8d..d2a58431a074 100644
--- a/arch/x86/kernel/acpi/boot.c
+++ b/arch/x86/kernel/acpi/boot.c
@@ -496,7 +496,8 @@ EXPORT_SYMBOL(acpi_register_gsi);
  *  ACPI based hotplug support for CPU
  */
 #ifdef CONFIG_ACPI_HOTPLUG_CPU
-int acpi_map_lsapic(acpi_handle handle, int *pcpu)
+
+static int __cpuinit _acpi_map_lsapic(acpi_handle handle, int *pcpu)
 {
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *obj;
@@ -551,6 +552,11 @@ int acpi_map_lsapic(acpi_handle handle, int *pcpu)
         return 0;
 }
 
+/* wrapper to silence section mismatch warning */
+int __ref acpi_map_lsapic(acpi_handle handle, int *pcpu)
+{
+        return _acpi_map_lsapic(handle, pcpu);
+}
 EXPORT_SYMBOL(acpi_map_lsapic);
 
 int acpi_unmap_lsapic(int cpu)
diff --git a/arch/x86/kernel/cpu/Makefile b/arch/x86/kernel/cpu/Makefile
index cfdb2f3bd763..a0c4d7c5dbd7 100644
--- a/arch/x86/kernel/cpu/Makefile
+++ b/arch/x86/kernel/cpu/Makefile
@@ -3,6 +3,7 @@
 #
 
 obj-y                   := intel_cacheinfo.o addon_cpuid_features.o
+obj-y                   += feature_names.o
 
 obj-$(CONFIG_X86_32)    += common.o proc.o bugs.o
 obj-$(CONFIG_X86_32)    += amd.o
diff --git a/arch/x86/kernel/cpu/amd.c b/arch/x86/kernel/cpu/amd.c
index 06fa159232fd..693e353999cd 100644
--- a/arch/x86/kernel/cpu/amd.c
+++ b/arch/x86/kernel/cpu/amd.c
@@ -304,7 +304,7 @@ static void __cpuinit init_amd(struct cpuinfo_x86 *c)
         if (c->x86 < 6)
                 clear_bit(X86_FEATURE_MCE, c->x86_capability);
 
-        if (cpu_has_xmm)
+        if (cpu_has_xmm2)
                 set_bit(X86_FEATURE_MFENCE_RDTSC, c->x86_capability);
 }
 
diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
index db28aa9e2f69..d9313d9adced 100644
--- a/arch/x86/kernel/cpu/common.c
+++ b/arch/x86/kernel/cpu/common.c
@@ -258,10 +258,10 @@ static int __cpuinit have_cpuid_p(void)
 void __init cpu_detect(struct cpuinfo_x86 *c)
 {
         /* Get vendor name */
-        cpuid(0x00000000, &c->cpuid_level,
-              (int *)&c->x86_vendor_id[0],
-              (int *)&c->x86_vendor_id[8],
-              (int *)&c->x86_vendor_id[4]);
+        cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
+              (unsigned int *)&c->x86_vendor_id[0],
+              (unsigned int *)&c->x86_vendor_id[8],
+              (unsigned int *)&c->x86_vendor_id[4]);
 
         c->x86 = 4;
         if (c->cpuid_level >= 0x00000001) {
@@ -274,14 +274,16 @@ void __init cpu_detect(struct cpuinfo_x86 *c)
                 if (c->x86 >= 0x6)
                         c->x86_model += ((tfms >> 16) & 0xF) << 4;
                 c->x86_mask = tfms & 15;
-                if (cap0 & (1<<19))
+                if (cap0 & (1<<19)) {
                         c->x86_cache_alignment = ((misc >> 8) & 0xff) * 8;
+                        c->x86_clflush_size = ((misc >> 8) & 0xff) * 8;
+                }
         }
 }
 static void __cpuinit early_get_cap(struct cpuinfo_x86 *c)
 {
         u32 tfms, xlvl;
-        int ebx;
+        unsigned int ebx;
 
         memset(&c->x86_capability, 0, sizeof c->x86_capability);
         if (have_cpuid_p()) {
@@ -317,6 +319,7 @@ static void __init early_cpu_detect(void)
         struct cpuinfo_x86 *c = &boot_cpu_data;
 
         c->x86_cache_alignment = 32;
+        c->x86_clflush_size = 32;
 
         if (!have_cpuid_p())
                 return;
@@ -340,14 +343,14 @@ static void __init early_cpu_detect(void)
 static void __cpuinit generic_identify(struct cpuinfo_x86 * c)
 {
         u32 tfms, xlvl;
-        int ebx;
+        unsigned int ebx;
 
         if (have_cpuid_p()) {
                 /* Get vendor name */
-                cpuid(0x00000000, &c->cpuid_level,
-                      (int *)&c->x86_vendor_id[0],
-                      (int *)&c->x86_vendor_id[8],
-                      (int *)&c->x86_vendor_id[4]);
+                cpuid(0x00000000, (unsigned int *)&c->cpuid_level,
+                      (unsigned int *)&c->x86_vendor_id[0],
+                      (unsigned int *)&c->x86_vendor_id[8],
+                      (unsigned int *)&c->x86_vendor_id[4]);
                 
                 get_cpu_vendor(c, 0);
                 /* Initialize the standard set of capabilities */
@@ -620,16 +623,6 @@ cpumask_t cpu_initialized __cpuinitdata = CPU_MASK_NONE;
  * They will insert themselves into the cpu_devs structure.
  * Then, when cpu_init() is called, we can just iterate over that array.
  */
-
-extern int intel_cpu_init(void);
-extern int cyrix_init_cpu(void);
-extern int nsc_init_cpu(void);
-extern int amd_init_cpu(void);
-extern int centaur_init_cpu(void);
-extern int transmeta_init_cpu(void);
-extern int nexgen_init_cpu(void);
-extern int umc_init_cpu(void);
-
 void __init early_cpu_init(void)
 {
         intel_cpu_init();
diff --git a/arch/x86/kernel/cpu/cpu.h b/arch/x86/kernel/cpu/cpu.h
index ad6527a5beb1..e0b38c33d842 100644
--- a/arch/x86/kernel/cpu/cpu.h
+++ b/arch/x86/kernel/cpu/cpu.h
@@ -27,3 +27,12 @@ extern void display_cacheinfo(struct cpuinfo_x86 *c);
 extern void early_init_intel(struct cpuinfo_x86 *c);
 extern void early_init_amd(struct cpuinfo_x86 *c);
 
+/* Specific CPU type init functions */
+int intel_cpu_init(void);
+int amd_init_cpu(void);
+int cyrix_init_cpu(void);
+int nsc_init_cpu(void);
+int centaur_init_cpu(void);
+int transmeta_init_cpu(void);
+int nexgen_init_cpu(void);
+int umc_init_cpu(void);
diff --git a/arch/x86/kernel/cpu/feature_names.c b/arch/x86/kernel/cpu/feature_names.c
new file mode 100644
index 000000000000..ee975ac6bbcb
--- /dev/null
+++ b/arch/x86/kernel/cpu/feature_names.c
@@ -0,0 +1,83 @@
+/*
+ * Strings for the various x86 capability flags.
+ *
+ * This file must not contain any executable code.
+ */
+
+#include "asm/cpufeature.h"
+
+/*
+ * These flag bits must match the definitions in <asm/cpufeature.h>.
+ * NULL means this bit is undefined or reserved; either way it doesn't
+ * have meaning as far as Linux is concerned.  Note that it's important
+ * to realize there is a difference between this table and CPUID -- if
+ * applications want to get the raw CPUID data, they should access
+ * /dev/cpu/<cpu_nr>/cpuid instead.
+ */
+const char * const x86_cap_flags[NCAPINTS*32] = {
+        /* Intel-defined */
+        "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
+        "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
+        "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
+        "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", "pbe",
+
+        /* AMD-defined */
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, "mp", "nx", NULL, "mmxext", NULL,
+        NULL, "fxsr_opt", "pdpe1gb", "rdtscp", NULL, "lm",
+        "3dnowext", "3dnow",
+
+        /* Transmeta-defined */
+        "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+
+        /* Other (Linux-defined) */
+        "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr",
+        NULL, NULL, NULL, NULL,
+        "constant_tsc", "up", NULL, "arch_perfmon",
+        "pebs", "bts", NULL, NULL,
+        "rep_good", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+
+        /* Intel-defined (#2) */
+        "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
+        "tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL,
+        NULL, NULL, "dca", "sse4_1", "sse4_2", NULL, NULL, "popcnt",
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+
+        /* VIA/Cyrix/Centaur-defined */
+        NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
+        "ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+
+        /* AMD-defined (#2) */
+        "lahf_lm", "cmp_legacy", "svm", "extapic",
+        "cr8_legacy", "abm", "sse4a", "misalignsse",
+        "3dnowprefetch", "osvw", "ibs", "sse5",
+        "skinit", "wdt", NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+
+        /* Auxiliary (Linux-defined) */
+        "ida", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+};
+
+const char *const x86_power_flags[32] = {
+        "ts",   /* temperature sensor */
+        "fid",  /* frequency id control */
+        "vid",  /* voltage id control */
+        "ttp",  /* thermal trip */
+        "tm",
+        "stc",
+        "100mhzsteps",
+        "hwpstate",
+        "",     /* tsc invariant mapped to constant_tsc */
+                /* nothing */
+};
diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c
index d1c372b018db..fae31ce747bd 100644
--- a/arch/x86/kernel/cpu/intel.c
+++ b/arch/x86/kernel/cpu/intel.c
@@ -13,6 +13,7 @@
 #include <asm/uaccess.h>
 #include <asm/ptrace.h>
 #include <asm/ds.h>
+#include <asm/bugs.h>
 
 #include "cpu.h"
 
diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c
index 8b4507b8469b..1b889860eb73 100644
--- a/arch/x86/kernel/cpu/intel_cacheinfo.c
+++ b/arch/x86/kernel/cpu/intel_cacheinfo.c
@@ -352,8 +352,8 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
          */
         if ((num_cache_leaves == 0 || c->x86 == 15) && c->cpuid_level > 1) {
                 /* supports eax=2  call */
-                int i, j, n;
-                int regs[4];
+                int j, n;
+                unsigned int regs[4];
                 unsigned char *dp = (unsigned char *)regs;
                 int only_trace = 0;
 
@@ -368,7 +368,7 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
 
                         /* If bit 31 is set, this is an unknown format */
                         for ( j = 0 ; j < 3 ; j++ ) {
-                                if ( regs[j] < 0 ) regs[j] = 0;
+                                if (regs[j] & (1 << 31)) regs[j] = 0;
                         }
 
                         /* Byte 0 is level count, not a descriptor */
diff --git a/arch/x86/kernel/cpu/mtrr/cyrix.c b/arch/x86/kernel/cpu/mtrr/cyrix.c
index 8e139c70f888..ff14c320040c 100644
--- a/arch/x86/kernel/cpu/mtrr/cyrix.c
+++ b/arch/x86/kernel/cpu/mtrr/cyrix.c
@@ -7,8 +7,6 @@
 #include <asm/processor-flags.h>
 #include "mtrr.h"
 
-int arr3_protected;
-
 static void
 cyrix_get_arr(unsigned int reg, unsigned long *base,
               unsigned long *size, mtrr_type * type)
@@ -99,8 +97,6 @@ cyrix_get_free_region(unsigned long base, unsigned long size, int replace_reg)
         case 4:
                 return replace_reg;
         case 3:
-                if (arr3_protected)
-                        break;
         case 2:
         case 1:
         case 0:
@@ -115,8 +111,6 @@ cyrix_get_free_region(unsigned long base, unsigned long size, int replace_reg)
         } else {
                 for (i = 0; i < 7; i++) {
                         cyrix_get_arr(i, &lbase, &lsize, &ltype);
-                        if ((i == 3) && arr3_protected)
-                                continue;
                         if (lsize == 0)
                                 return i;
                 }
@@ -260,107 +254,6 @@ static void cyrix_set_all(void)
         post_set();
 }
 
-#if 0
-/*
- * On Cyrix 6x86(MX) and M II the ARR3 is special: it has connection
- * with the SMM (System Management Mode) mode. So we need the following:
- * Check whether SMI_LOCK (CCR3 bit 0) is set
- *   if it is set, write a warning message: ARR3 cannot be changed!
- *     (it cannot be changed until the next processor reset)
- *   if it is reset, then we can change it, set all the needed bits:
- *   - disable access to SMM memory through ARR3 range (CCR1 bit 7 reset)
- *   - disable access to SMM memory (CCR1 bit 2 reset)
- *   - disable SMM mode (CCR1 bit 1 reset)
- *   - disable write protection of ARR3 (CCR6 bit 1 reset)
- *   - (maybe) disable ARR3
- * Just to be sure, we enable ARR usage by the processor (CCR5 bit 5 set)
- */
-static void __init
-cyrix_arr_init(void)
-{
-        struct set_mtrr_context ctxt;
-        unsigned char ccr[7];
-        int ccrc[7] = { 0, 0, 0, 0, 0, 0, 0 };
-#ifdef CONFIG_SMP
-        int i;
-#endif
-
-        /* flush cache and enable MAPEN */
-        set_mtrr_prepare_save(&ctxt);
-        set_mtrr_cache_disable(&ctxt);
-
-        /* Save all CCRs locally */
-        ccr[0] = getCx86(CX86_CCR0);
-        ccr[1] = getCx86(CX86_CCR1);
-        ccr[2] = getCx86(CX86_CCR2);
-        ccr[3] = ctxt.ccr3;
-        ccr[4] = getCx86(CX86_CCR4);
-        ccr[5] = getCx86(CX86_CCR5);
-        ccr[6] = getCx86(CX86_CCR6);
-
-        if (ccr[3] & 1) {
-                ccrc[3] = 1;
-                arr3_protected = 1;
-        } else {
-                /* Disable SMM mode (bit 1), access to SMM memory (bit 2) and
-                 * access to SMM memory through ARR3 (bit 7).
-                 */
-                if (ccr[1] & 0x80) {
-                        ccr[1] &= 0x7f;
-                        ccrc[1] |= 0x80;
-                }
-                if (ccr[1] & 0x04) {
-                        ccr[1] &= 0xfb;
-                        ccrc[1] |= 0x04;
-                }
-                if (ccr[1] & 0x02) {
-                        ccr[1] &= 0xfd;
-                        ccrc[1] |= 0x02;
-                }
-                arr3_protected = 0;
-                if (ccr[6] & 0x02) {
-                        ccr[6] &= 0xfd;
-                        ccrc[6] = 1;    /* Disable write protection of ARR3 */
-                        setCx86(CX86_CCR6, ccr[6]);
-                }
-                /* Disable ARR3. This is safe now that we disabled SMM. */
-                /* cyrix_set_arr_up (3, 0, 0, 0, FALSE); */
-        }
-        /* If we changed CCR1 in memory, change it in the processor, too. */
-        if (ccrc[1])
-                setCx86(CX86_CCR1, ccr[1]);
-
-        /* Enable ARR usage by the processor */
-        if (!(ccr[5] & 0x20)) {
-                ccr[5] |= 0x20;
-                ccrc[5] = 1;
-                setCx86(CX86_CCR5, ccr[5]);
-        }
-#ifdef CONFIG_SMP
-        for (i = 0; i < 7; i++)
-                ccr_state[i] = ccr[i];
-        for (i = 0; i < 8; i++)
-                cyrix_get_arr(i,
-                              &arr_state[i].base, &arr_state[i].size,
-                              &arr_state[i].type);
-#endif
-
-        set_mtrr_done(&ctxt);   /* flush cache and disable MAPEN */
-
-        if (ccrc[5])
-                printk(KERN_INFO "mtrr: ARR usage was not enabled, enabled manually\n");
-        if (ccrc[3])
-                printk(KERN_INFO "mtrr: ARR3 cannot be changed\n");
-/*
-    if ( ccrc[1] & 0x80) printk ("mtrr: SMM memory access through ARR3 disabled\n");
-    if ( ccrc[1] & 0x04) printk ("mtrr: SMM memory access disabled\n");
-    if ( ccrc[1] & 0x02) printk ("mtrr: SMM mode disabled\n");
-*/
-        if (ccrc[6])
-                printk(KERN_INFO "mtrr: ARR3 was write protected, unprotected\n");
-}
-#endif
-
 static struct mtrr_ops cyrix_mtrr_ops = {
         .vendor            = X86_VENDOR_CYRIX,
 //      .init              = cyrix_arr_init,
diff --git a/arch/x86/kernel/cpu/mtrr/main.c b/arch/x86/kernel/cpu/mtrr/main.c
index 715919582657..1e27b69a7a0e 100644
--- a/arch/x86/kernel/cpu/mtrr/main.c
+++ b/arch/x86/kernel/cpu/mtrr/main.c
@@ -59,12 +59,6 @@ struct mtrr_ops * mtrr_if = NULL;
 static void set_mtrr(unsigned int reg, unsigned long base,
                      unsigned long size, mtrr_type type);
 
-#ifndef CONFIG_X86_64
-extern int arr3_protected;
-#else
-#define arr3_protected 0
-#endif
-
 void set_mtrr_ops(struct mtrr_ops * ops)
 {
         if (ops->vendor && ops->vendor < X86_VENDOR_NUM)
@@ -513,12 +507,6 @@ int mtrr_del_page(int reg, unsigned long base, unsigned long size)
                 printk(KERN_WARNING "mtrr: register: %d too big\n", reg);
                 goto out;
         }
-        if (is_cpu(CYRIX) && !use_intel()) {
-                if ((reg == 3) && arr3_protected) {
-                        printk(KERN_WARNING "mtrr: ARR3 cannot be changed\n");
-                        goto out;
-                }
-        }
         mtrr_if->get(reg, &lbase, &lsize, &ltype);
         if (lsize < 1) {
                 printk(KERN_WARNING "mtrr: MTRR %d not used\n", reg);
@@ -566,10 +554,6 @@ EXPORT_SYMBOL(mtrr_del);
  * These should be called implicitly, but we can't yet until all the initcall
  * stuff is done...
  */
-extern void amd_init_mtrr(void);
-extern void cyrix_init_mtrr(void);
-extern void centaur_init_mtrr(void);
-
 static void __init init_ifs(void)
 {
 #ifndef CONFIG_X86_64
diff --git a/arch/x86/kernel/cpu/mtrr/mtrr.h b/arch/x86/kernel/cpu/mtrr/mtrr.h
index fb74a2c20814..2cc77eb6fea3 100644
--- a/arch/x86/kernel/cpu/mtrr/mtrr.h
+++ b/arch/x86/kernel/cpu/mtrr/mtrr.h
@@ -97,3 +97,7 @@ void mtrr_state_warn(void);
 const char *mtrr_attrib_to_str(int x);
 void mtrr_wrmsr(unsigned, unsigned, unsigned);
 
+/* CPU specific mtrr init functions */
+int amd_init_mtrr(void);
+int cyrix_init_mtrr(void);
+int centaur_init_mtrr(void);
diff --git a/arch/x86/kernel/cpu/proc.c b/arch/x86/kernel/cpu/proc.c
index 028213260148..af11d31dce0a 100644
--- a/arch/x86/kernel/cpu/proc.c
+++ b/arch/x86/kernel/cpu/proc.c
@@ -10,80 +10,6 @@
  */
 static int show_cpuinfo(struct seq_file *m, void *v)
 {
-        /* 
-         * These flag bits must match the definitions in <asm/cpufeature.h>.
-         * NULL means this bit is undefined or reserved; either way it doesn't
-         * have meaning as far as Linux is concerned.  Note that it's important
-         * to realize there is a difference between this table and CPUID -- if
-         * applications want to get the raw CPUID data, they should access
-         * /dev/cpu/<cpu_nr>/cpuid instead.
-         */
-        static const char * const x86_cap_flags[] = {
-                /* Intel-defined */
-                "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
-                "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
-                "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
-                "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", "pbe",
-
-                /* AMD-defined */
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, "mp", "nx", NULL, "mmxext", NULL,
-                NULL, "fxsr_opt", "pdpe1gb", "rdtscp", NULL, "lm",
-                "3dnowext", "3dnow",
-
-                /* Transmeta-defined */
-                "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* Other (Linux-defined) */
-                "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr",
-                NULL, NULL, NULL, NULL,
-                "constant_tsc", "up", NULL, "arch_perfmon",
-                "pebs", "bts", NULL, "sync_rdtsc",
-                "rep_good", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* Intel-defined (#2) */
-                "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
-                "tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL,
-                NULL, NULL, "dca", "sse4_1", "sse4_2", NULL, NULL, "popcnt",
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* VIA/Cyrix/Centaur-defined */
-                NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
-                "ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* AMD-defined (#2) */
-                "lahf_lm", "cmp_legacy", "svm", "extapic",
-                "cr8_legacy", "abm", "sse4a", "misalignsse",
-                "3dnowprefetch", "osvw", "ibs", "sse5",
-                "skinit", "wdt", NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* Auxiliary (Linux-defined) */
-                "ida", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-        };
-        static const char * const x86_power_flags[] = {
-                "ts",   /* temperature sensor */
-                "fid",  /* frequency id control */
-                "vid",  /* voltage id control */
-                "ttp",  /* thermal trip */
-                "tm",
-                "stc",
-                "100mhzsteps",
-                "hwpstate",
-                "",     /* constant_tsc - moved to flags */
-                /* nothing */
-        };
         struct cpuinfo_x86 *c = v;
         int i, n = 0;
         int fpu_exception;
diff --git a/arch/x86/kernel/cpuid.c b/arch/x86/kernel/cpuid.c
index dec66e452810..288e7a6598ac 100644
--- a/arch/x86/kernel/cpuid.c
+++ b/arch/x86/kernel/cpuid.c
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------- *
- *   
- *   Copyright 2000 H. Peter Anvin - All Rights Reserved
+ *
+ *   Copyright 2000-2008 H. Peter Anvin - All Rights Reserved
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -17,6 +17,10 @@
  * and then read in chunks of 16 bytes.  A larger size means multiple
  * reads of consecutive levels.
  *
+ * The lower 32 bits of the file position is used as the incoming %eax,
+ * and the upper 32 bits of the file position as the incoming %ecx,
+ * the latter intended for "counting" eax levels like eax=4.
+ *
  * This driver uses /dev/cpu/%d/cpuid where %d is the minor number, and on
  * an SMP box will direct the access to CPU %d.
  */
@@ -43,35 +47,24 @@
 
 static struct class *cpuid_class;
 
-struct cpuid_command {
-        u32 reg;
-        u32 *data;
+struct cpuid_regs {
+        u32 eax, ebx, ecx, edx;
 };
 
 static void cpuid_smp_cpuid(void *cmd_block)
 {
-        struct cpuid_command *cmd = cmd_block;
-
-        cpuid(cmd->reg, &cmd->data[0], &cmd->data[1], &cmd->data[2],
-                      &cmd->data[3]);
-}
-
-static inline void do_cpuid(int cpu, u32 reg, u32 * data)
-{
-        struct cpuid_command cmd;
-
-        cmd.reg = reg;
-        cmd.data = data;
+        struct cpuid_regs *cmd = (struct cpuid_regs *)cmd_block;
 
-        smp_call_function_single(cpu, cpuid_smp_cpuid, &cmd, 1, 1);
+        cpuid_count(cmd->eax, cmd->ecx,
+                    &cmd->eax, &cmd->ebx, &cmd->ecx, &cmd->edx);
 }
 
 static loff_t cpuid_seek(struct file *file, loff_t offset, int orig)
 {
         loff_t ret;
+        struct inode *inode = file->f_mapping->host;
 
-        lock_kernel();
-
+        mutex_lock(&inode->i_mutex);
         switch (orig) {
         case 0:
                 file->f_pos = offset;
@@ -84,8 +77,7 @@ static loff_t cpuid_seek(struct file *file, loff_t offset, int orig)
         default:
                 ret = -EINVAL;
         }
-
-        unlock_kernel();
+        mutex_unlock(&inode->i_mutex);
         return ret;
 }
 
@@ -93,19 +85,21 @@ static ssize_t cpuid_read(struct file *file, char __user *buf,
                           size_t count, loff_t * ppos)
 {
         char __user *tmp = buf;
-        u32 data[4];
-        u32 reg = *ppos;
+        struct cpuid_regs cmd;
         int cpu = iminor(file->f_path.dentry->d_inode);
+        u64 pos = *ppos;
 
         if (count % 16)
                 return -EINVAL; /* Invalid chunk size */
 
         for (; count; count -= 16) {
-                do_cpuid(cpu, reg, data);
-                if (copy_to_user(tmp, &data, 16))
+                cmd.eax = pos;
+                cmd.ecx = pos >> 32;
+                smp_call_function_single(cpu, cpuid_smp_cpuid, &cmd, 1, 1);
+                if (copy_to_user(tmp, &cmd, 16))
                         return -EFAULT;
                 tmp += 16;
-                *ppos = reg++;
+                *ppos = ++pos;
         }
 
         return tmp - buf;
@@ -170,7 +164,7 @@ static int __cpuinit cpuid_class_cpu_callback(struct notifier_block *nfb,
         return err ? NOTIFY_BAD : NOTIFY_OK;
 }
 
-static struct notifier_block __cpuinitdata cpuid_class_cpu_notifier =
+static struct notifier_block __refdata cpuid_class_cpu_notifier =
 {
         .notifier_call = cpuid_class_cpu_callback,
 };
@@ -193,7 +187,7 @@ static int __init cpuid_init(void)
         }
         for_each_online_cpu(i) {
                 err = cpuid_device_create(i);
-                if (err != 0) 
+                if (err != 0)
                         goto out_class;
         }
         register_hotcpu_notifier(&cpuid_class_cpu_notifier);
@@ -208,7 +202,7 @@ out_class:
         }
         class_destroy(cpuid_class);
 out_chrdev:
-        unregister_chrdev(CPUID_MAJOR, "cpu/cpuid");    
+        unregister_chrdev(CPUID_MAJOR, "cpu/cpuid");
 out:
         return err;
 }
diff --git a/arch/x86/kernel/ds.c b/arch/x86/kernel/ds.c
index 1c5ca4d18787..dcd918c1580d 100644
--- a/arch/x86/kernel/ds.c
+++ b/arch/x86/kernel/ds.c
@@ -223,7 +223,7 @@ int ds_free(void **dsp)
         if (*dsp)
                 kfree((void *)get_bts_buffer_base(*dsp));
         kfree(*dsp);
-        *dsp = 0;
+        *dsp = NULL;
 
         return 0;
 }
diff --git a/arch/x86/kernel/e820_64.c b/arch/x86/kernel/e820_64.c
index c617174e8963..9f65b4cc323c 100644
--- a/arch/x86/kernel/e820_64.c
+++ b/arch/x86/kernel/e820_64.c
@@ -54,30 +54,33 @@ static unsigned long __initdata end_user_pfn = MAXMEM>>PAGE_SHIFT;
 
 struct early_res {
         unsigned long start, end;
+        char name[16];
 };
 static struct early_res early_res[MAX_EARLY_RES] __initdata = {
-        { 0, PAGE_SIZE },                       /* BIOS data page */
+        { 0, PAGE_SIZE, "BIOS data page" },                     /* BIOS data page */
 #ifdef CONFIG_SMP
-        { SMP_TRAMPOLINE_BASE, SMP_TRAMPOLINE_BASE + 2*PAGE_SIZE },
+        { SMP_TRAMPOLINE_BASE, SMP_TRAMPOLINE_BASE + 2*PAGE_SIZE, "SMP_TRAMPOLINE" },
 #endif
         {}
 };
 
-void __init reserve_early(unsigned long start, unsigned long end)
+void __init reserve_early(unsigned long start, unsigned long end, char *name)
 {
         int i;
         struct early_res *r;
         for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++) {
                 r = &early_res[i];
                 if (end > r->start && start < r->end)
-                        panic("Overlapping early reservations %lx-%lx to %lx-%lx\n",
-                              start, end, r->start, r->end);
+                        panic("Overlapping early reservations %lx-%lx %s to %lx-%lx %s\n",
+                              start, end - 1, name?name:"", r->start, r->end - 1, r->name);
         }
         if (i >= MAX_EARLY_RES)
                 panic("Too many early reservations");
         r = &early_res[i];
         r->start = start;
         r->end = end;
+        if (name)
+                strncpy(r->name, name, sizeof(r->name) - 1);
 }
 
 void __init early_res_to_bootmem(void)
@@ -85,6 +88,8 @@ void __init early_res_to_bootmem(void)
         int i;
         for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++) {
                 struct early_res *r = &early_res[i];
+                printk(KERN_INFO "early res: %d [%lx-%lx] %s\n", i,
+                        r->start, r->end - 1, r->name);
                 reserve_bootmem_generic(r->start, r->end - r->start);
         }
 }
@@ -166,12 +171,13 @@ int __init e820_all_mapped(unsigned long start, unsigned long end,
 }
 
 /*
- * Find a free area in a specific range.
+ * Find a free area with specified alignment in a specific range.
  */
 unsigned long __init find_e820_area(unsigned long start, unsigned long end,
-                                    unsigned size)
+                                    unsigned size, unsigned long align)
 {
         int i;
+        unsigned long mask = ~(align - 1);
 
         for (i = 0; i < e820.nr_map; i++) {
                 struct e820entry *ei = &e820.map[i];
@@ -185,7 +191,8 @@ unsigned long __init find_e820_area(unsigned long start, unsigned long end,
                         continue;
                 while (bad_addr(&addr, size) && addr+size <= ei->addr+ei->size)
                         ;
-                last = PAGE_ALIGN(addr) + size;
+                addr = (addr + align - 1) & mask;
+                last = addr + size;
                 if (last > ei->addr + ei->size)
                         continue;
                 if (last > end)
diff --git a/arch/x86/kernel/early_printk.c b/arch/x86/kernel/early_printk.c
index b7d6c23f2871..cff84cd9987f 100644
--- a/arch/x86/kernel/early_printk.c
+++ b/arch/x86/kernel/early_printk.c
@@ -193,7 +193,7 @@ static struct console simnow_console = {
 };
 
 /* Direct interface for emergencies */
-struct console *early_console = &early_vga_console;
+static struct console *early_console = &early_vga_console;
 static int early_console_initialized = 0;
 
 void early_printk(const char *fmt, ...)
diff --git a/arch/x86/kernel/efi.c b/arch/x86/kernel/efi.c
index 1411324a625c..32dd62b36ff7 100644
--- a/arch/x86/kernel/efi.c
+++ b/arch/x86/kernel/efi.c
@@ -379,11 +379,9 @@ void __init efi_init(void)
 #endif
 }
 
-#if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
 static void __init runtime_code_page_mkexec(void)
 {
         efi_memory_desc_t *md;
-        unsigned long end;
         void *p;
 
         if (!(__supported_pte_mask & _PAGE_NX))
@@ -392,18 +390,13 @@ static void __init runtime_code_page_mkexec(void)
         /* Make EFI runtime service code area executable */
         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
                 md = p;
-                end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);
-                if (md->type == EFI_RUNTIME_SERVICES_CODE &&
-                    (end >> PAGE_SHIFT) <= max_pfn_mapped) {
-                        set_memory_x(md->virt_addr, md->num_pages);
-                        set_memory_uc(md->virt_addr, md->num_pages);
-                }
+
+                if (md->type != EFI_RUNTIME_SERVICES_CODE)
+                        continue;
+
+                set_memory_x(md->virt_addr, md->num_pages << EFI_PAGE_SHIFT);
         }
-        __flush_tlb_all();
 }
-#else
-static inline void __init runtime_code_page_mkexec(void) { }
-#endif
 
 /*
  * This function will switch the EFI runtime services to virtual mode.
@@ -417,30 +410,40 @@ void __init efi_enter_virtual_mode(void)
 {
         efi_memory_desc_t *md;
         efi_status_t status;
-        unsigned long end;
-        void *p;
+        unsigned long size;
+        u64 end, systab;
+        void *p, *va;
 
         efi.systab = NULL;
         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
                 md = p;
                 if (!(md->attribute & EFI_MEMORY_RUNTIME))
                         continue;
-                end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);
-                if ((md->attribute & EFI_MEMORY_WB) &&
-                    ((end >> PAGE_SHIFT) <= max_pfn_mapped))
-                        md->virt_addr = (unsigned long)__va(md->phys_addr);
+
+                size = md->num_pages << EFI_PAGE_SHIFT;
+                end = md->phys_addr + size;
+
+                if ((end >> PAGE_SHIFT) <= max_pfn_mapped)
+                        va = __va(md->phys_addr);
                 else
-                        md->virt_addr = (unsigned long)
-                                efi_ioremap(md->phys_addr,
-                                            md->num_pages << EFI_PAGE_SHIFT);
-                if (!md->virt_addr)
+                        va = efi_ioremap(md->phys_addr, size);
+
+                if (md->attribute & EFI_MEMORY_WB)
+                        set_memory_uc(md->virt_addr, size);
+
+                md->virt_addr = (u64) (unsigned long) va;
+
+                if (!va) {
                         printk(KERN_ERR PFX "ioremap of 0x%llX failed!\n",
                                (unsigned long long)md->phys_addr);
-                if ((md->phys_addr <= (unsigned long)efi_phys.systab) &&
-                    ((unsigned long)efi_phys.systab < end))
-                        efi.systab = (efi_system_table_t *)(unsigned long)
-                                (md->virt_addr - md->phys_addr +
-                                 (unsigned long)efi_phys.systab);
+                        continue;
+                }
+
+                systab = (u64) (unsigned long) efi_phys.systab;
+                if (md->phys_addr <= systab && systab < end) {
+                        systab += md->virt_addr - md->phys_addr;
+                        efi.systab = (efi_system_table_t *) (unsigned long) systab;
+                }
         }
 
         BUG_ON(!efi.systab);
diff --git a/arch/x86/kernel/efi_64.c b/arch/x86/kernel/efi_64.c
index 4b73992c1e11..09d5c2330934 100644
--- a/arch/x86/kernel/efi_64.c
+++ b/arch/x86/kernel/efi_64.c
@@ -44,7 +44,7 @@ static void __init early_mapping_set_exec(unsigned long start,
                                           int executable)
 {
         pte_t *kpte;
-        int level;
+        unsigned int level;
 
         while (start < end) {
                 kpte = lookup_address((unsigned long)__va(start), &level);
@@ -54,10 +54,10 @@ static void __init early_mapping_set_exec(unsigned long start,
                 else
                         set_pte(kpte, __pte((pte_val(*kpte) | _PAGE_NX) & \
                                             __supported_pte_mask));
-                if (level == 4)
-                        start = (start + PMD_SIZE) & PMD_MASK;
-                else
+                if (level == PG_LEVEL_4K)
                         start = (start + PAGE_SIZE) & PAGE_MASK;
+                else
+                        start = (start + PMD_SIZE) & PMD_MASK;
         }
 }
 
@@ -109,23 +109,23 @@ void __init efi_reserve_bootmem(void)
                                 memmap.nr_map * memmap.desc_size);
 }
 
-void __iomem * __init efi_ioremap(unsigned long offset,
-                                  unsigned long size)
+void __iomem * __init efi_ioremap(unsigned long phys_addr, unsigned long size)
 {
         static unsigned pages_mapped;
-        unsigned long last_addr;
         unsigned i, pages;
 
-        last_addr = offset + size - 1;
-        offset &= PAGE_MASK;
-        pages = (PAGE_ALIGN(last_addr) - offset) >> PAGE_SHIFT;
+        /* phys_addr and size must be page aligned */
+        if ((phys_addr & ~PAGE_MASK) || (size & ~PAGE_MASK))
+                return NULL;
+
+        pages = size >> PAGE_SHIFT;
         if (pages_mapped + pages > MAX_EFI_IO_PAGES)
                 return NULL;
 
         for (i = 0; i < pages; i++) {
                 __set_fixmap(FIX_EFI_IO_MAP_FIRST_PAGE - pages_mapped,
-                             offset, PAGE_KERNEL_EXEC_NOCACHE);
-                offset += PAGE_SIZE;
+                             phys_addr, PAGE_KERNEL);
+                phys_addr += PAGE_SIZE;
                 pages_mapped++;
         }
 
diff --git a/arch/x86/kernel/head64.c b/arch/x86/kernel/head64.c
index a317336cdeaa..24dbf56928d7 100644
--- a/arch/x86/kernel/head64.c
+++ b/arch/x86/kernel/head64.c
@@ -75,7 +75,7 @@ static __init void reserve_ebda(void)
         if (ebda_size > 64*1024)
                 ebda_size = 64*1024;
 
-        reserve_early(ebda_addr, ebda_addr + ebda_size);
+        reserve_early(ebda_addr, ebda_addr + ebda_size, "EBDA");
 }
 
 void __init x86_64_start_kernel(char * real_mode_data)
@@ -105,14 +105,14 @@ void __init x86_64_start_kernel(char * real_mode_data)
         pda_init(0);
         copy_bootdata(__va(real_mode_data));
 
-        reserve_early(__pa_symbol(&_text), __pa_symbol(&_end));
+        reserve_early(__pa_symbol(&_text), __pa_symbol(&_end), "TEXT DATA BSS");
 
         /* Reserve INITRD */
         if (boot_params.hdr.type_of_loader && boot_params.hdr.ramdisk_image) {
                 unsigned long ramdisk_image = boot_params.hdr.ramdisk_image;
                 unsigned long ramdisk_size  = boot_params.hdr.ramdisk_size;
                 unsigned long ramdisk_end   = ramdisk_image + ramdisk_size;
-                reserve_early(ramdisk_image, ramdisk_end);
+                reserve_early(ramdisk_image, ramdisk_end, "RAMDISK");
         }
 
         reserve_ebda();
diff --git a/arch/x86/kernel/head_64.S b/arch/x86/kernel/head_64.S
index 1d5a7a361200..4f283ad215ec 100644
--- a/arch/x86/kernel/head_64.S
+++ b/arch/x86/kernel/head_64.S
@@ -63,7 +63,7 @@ startup_64:
 
         /* Is the address not 2M aligned? */
         movq    %rbp, %rax
-        andl    $~LARGE_PAGE_MASK, %eax
+        andl    $~PMD_PAGE_MASK, %eax
         testl   %eax, %eax
         jnz     bad_address
 
@@ -88,7 +88,7 @@ startup_64:
 
         /* Add an Identity mapping if I am above 1G */
         leaq    _text(%rip), %rdi
-        andq    $LARGE_PAGE_MASK, %rdi
+        andq    $PMD_PAGE_MASK, %rdi
 
         movq    %rdi, %rax
         shrq    $PUD_SHIFT, %rax
diff --git a/arch/x86/kernel/ldt.c b/arch/x86/kernel/ldt.c
index 8a7660c8394a..0224c3637c73 100644
--- a/arch/x86/kernel/ldt.c
+++ b/arch/x86/kernel/ldt.c
@@ -35,7 +35,8 @@ static int alloc_ldt(mm_context_t *pc, int mincount, int reload)
         if (mincount <= pc->size)
                 return 0;
         oldsize = pc->size;
-        mincount = (mincount + 511) & (~511);
+        mincount = (mincount + (PAGE_SIZE / LDT_ENTRY_SIZE - 1)) &
+                        (~(PAGE_SIZE / LDT_ENTRY_SIZE - 1));
         if (mincount * LDT_ENTRY_SIZE > PAGE_SIZE)
                 newldt = vmalloc(mincount * LDT_ENTRY_SIZE);
         else
diff --git a/arch/x86/kernel/microcode.c b/arch/x86/kernel/microcode.c
index 6ff447f9fda7..f2702d01b8a8 100644
--- a/arch/x86/kernel/microcode.c
+++ b/arch/x86/kernel/microcode.c
@@ -797,7 +797,7 @@ mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
         return NOTIFY_OK;
 }
 
-static struct notifier_block __cpuinitdata mc_cpu_notifier = {
+static struct notifier_block __refdata mc_cpu_notifier = {
         .notifier_call = mc_cpu_callback,
 };
 
diff --git a/arch/x86/kernel/msr.c b/arch/x86/kernel/msr.c
index 21f6e3c0be18..af51ea8400b2 100644
--- a/arch/x86/kernel/msr.c
+++ b/arch/x86/kernel/msr.c
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------- *
- *   
- *   Copyright 2000 H. Peter Anvin - All Rights Reserved
+ *
+ *   Copyright 2000-2008 H. Peter Anvin - All Rights Reserved
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -45,9 +45,10 @@ static struct class *msr_class;
 
 static loff_t msr_seek(struct file *file, loff_t offset, int orig)
 {
-        loff_t ret = -EINVAL;
+        loff_t ret;
+        struct inode *inode = file->f_mapping->host;
 
-        lock_kernel();
+        mutex_lock(&inode->i_mutex);
         switch (orig) {
         case 0:
                 file->f_pos = offset;
@@ -56,8 +57,11 @@ static loff_t msr_seek(struct file *file, loff_t offset, int orig)
         case 1:
                 file->f_pos += offset;
                 ret = file->f_pos;
+                break;
+        default:
+                ret = -EINVAL;
         }
-        unlock_kernel();
+        mutex_unlock(&inode->i_mutex);
         return ret;
 }
 
@@ -168,7 +172,7 @@ static int __cpuinit msr_class_cpu_callback(struct notifier_block *nfb,
         return err ? NOTIFY_BAD : NOTIFY_OK;
 }
 
-static struct notifier_block __cpuinitdata msr_class_cpu_notifier = {
+static struct notifier_block __refdata msr_class_cpu_notifier = {
         .notifier_call = msr_class_cpu_callback,
 };
 
diff --git a/arch/x86/kernel/pci-calgary_64.c b/arch/x86/kernel/pci-calgary_64.c
index 21f34db2c03c..1b5464c2434f 100644
--- a/arch/x86/kernel/pci-calgary_64.c
+++ b/arch/x86/kernel/pci-calgary_64.c
@@ -35,6 +35,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/scatterlist.h>
+#include <linux/iommu-helper.h>
 #include <asm/gart.h>
 #include <asm/calgary.h>
 #include <asm/tce.h>
@@ -260,22 +261,28 @@ static void iommu_range_reserve(struct iommu_table *tbl,
         spin_unlock_irqrestore(&tbl->it_lock, flags);
 }
 
-static unsigned long iommu_range_alloc(struct iommu_table *tbl,
-        unsigned int npages)
+static unsigned long iommu_range_alloc(struct device *dev,
+                                       struct iommu_table *tbl,
+                                       unsigned int npages)
 {
         unsigned long flags;
         unsigned long offset;
+        unsigned long boundary_size;
+
+        boundary_size = ALIGN(dma_get_seg_boundary(dev) + 1,
+                              PAGE_SIZE) >> PAGE_SHIFT;
 
         BUG_ON(npages == 0);
 
         spin_lock_irqsave(&tbl->it_lock, flags);
 
-        offset = find_next_zero_string(tbl->it_map, tbl->it_hint,
-                                       tbl->it_size, npages);
+        offset = iommu_area_alloc(tbl->it_map, tbl->it_size, tbl->it_hint,
+                                  npages, 0, boundary_size, 0);
         if (offset == ~0UL) {
                 tbl->chip_ops->tce_cache_blast(tbl);
-                offset = find_next_zero_string(tbl->it_map, 0,
-                                               tbl->it_size, npages);
+
+                offset = iommu_area_alloc(tbl->it_map, tbl->it_size, 0,
+                                          npages, 0, boundary_size, 0);
                 if (offset == ~0UL) {
                         printk(KERN_WARNING "Calgary: IOMMU full.\n");
                         spin_unlock_irqrestore(&tbl->it_lock, flags);
@@ -286,7 +293,6 @@ static unsigned long iommu_range_alloc(struct iommu_table *tbl,
                 }
         }
 
-        set_bit_string(tbl->it_map, offset, npages);
         tbl->it_hint = offset + npages;
         BUG_ON(tbl->it_hint > tbl->it_size);
 
@@ -295,13 +301,13 @@ static unsigned long iommu_range_alloc(struct iommu_table *tbl,
         return offset;
 }
 
-static dma_addr_t iommu_alloc(struct iommu_table *tbl, void *vaddr,
-        unsigned int npages, int direction)
+static dma_addr_t iommu_alloc(struct device *dev, struct iommu_table *tbl,
+                              void *vaddr, unsigned int npages, int direction)
 {
         unsigned long entry;
         dma_addr_t ret = bad_dma_address;
 
-        entry = iommu_range_alloc(tbl, npages);
+        entry = iommu_range_alloc(dev, tbl, npages);
 
         if (unlikely(entry == bad_dma_address))
                 goto error;
@@ -354,7 +360,7 @@ static void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
                                badbit, tbl, dma_addr, entry, npages);
         }
 
-        __clear_bit_string(tbl->it_map, entry, npages);
+        iommu_area_free(tbl->it_map, entry, npages);
 
         spin_unlock_irqrestore(&tbl->it_lock, flags);
 }
@@ -438,7 +444,7 @@ static int calgary_map_sg(struct device *dev, struct scatterlist *sg,
                 vaddr = (unsigned long) sg_virt(s);
                 npages = num_dma_pages(vaddr, s->length);
 
-                entry = iommu_range_alloc(tbl, npages);
+                entry = iommu_range_alloc(dev, tbl, npages);
                 if (entry == bad_dma_address) {
                         /* makes sure unmap knows to stop */
                         s->dma_length = 0;
@@ -476,7 +482,7 @@ static dma_addr_t calgary_map_single(struct device *dev, void *vaddr,
         npages = num_dma_pages(uaddr, size);
 
         if (translation_enabled(tbl))
-                dma_handle = iommu_alloc(tbl, vaddr, npages, direction);
+                dma_handle = iommu_alloc(dev, tbl, vaddr, npages, direction);
         else
                 dma_handle = virt_to_bus(vaddr);
 
@@ -516,7 +522,7 @@ static void* calgary_alloc_coherent(struct device *dev, size_t size,
 
         if (translation_enabled(tbl)) {
                 /* set up tces to cover the allocated range */
-                mapping = iommu_alloc(tbl, ret, npages, DMA_BIDIRECTIONAL);
+                mapping = iommu_alloc(dev, tbl, ret, npages, DMA_BIDIRECTIONAL);
                 if (mapping == bad_dma_address)
                         goto free;
 
@@ -1006,7 +1012,7 @@ static void __init calgary_set_split_completion_timeout(void __iomem *bbar,
         readq(target); /* flush */
 }
 
-static void calioc2_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev)
+static void __init calioc2_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev)
 {
         unsigned char busnum = dev->bus->number;
         void __iomem *bbar = tbl->bbar;
@@ -1022,7 +1028,7 @@ static void calioc2_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev)
         writel(cpu_to_be32(val), target);
 }
 
-static void calgary_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev)
+static void __init calgary_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev)
 {
         unsigned char busnum = dev->bus->number;
 
diff --git a/arch/x86/kernel/pci-gart_64.c b/arch/x86/kernel/pci-gart_64.c
index 4d5cc7181982..65f6acb025c8 100644
--- a/arch/x86/kernel/pci-gart_64.c
+++ b/arch/x86/kernel/pci-gart_64.c
@@ -25,6 +25,7 @@
 #include <linux/bitops.h>
 #include <linux/kdebug.h>
 #include <linux/scatterlist.h>
+#include <linux/iommu-helper.h>
 #include <asm/atomic.h>
 #include <asm/io.h>
 #include <asm/mtrr.h>
@@ -82,17 +83,24 @@ AGPEXTERN __u32 *agp_gatt_table;
 static unsigned long next_bit;  /* protected by iommu_bitmap_lock */
 static int need_flush;          /* global flush state. set for each gart wrap */
 
-static unsigned long alloc_iommu(int size)
+static unsigned long alloc_iommu(struct device *dev, int size)
 {
         unsigned long offset, flags;
+        unsigned long boundary_size;
+        unsigned long base_index;
+
+        base_index = ALIGN(iommu_bus_base & dma_get_seg_boundary(dev),
+                           PAGE_SIZE) >> PAGE_SHIFT;
+        boundary_size = ALIGN(dma_get_seg_boundary(dev) + 1,
+                              PAGE_SIZE) >> PAGE_SHIFT;
 
         spin_lock_irqsave(&iommu_bitmap_lock, flags);
-        offset = find_next_zero_string(iommu_gart_bitmap, next_bit,
-                                        iommu_pages, size);
+        offset = iommu_area_alloc(iommu_gart_bitmap, iommu_pages, next_bit,
+                                  size, base_index, boundary_size, 0);
         if (offset == -1) {
                 need_flush = 1;
-                offset = find_next_zero_string(iommu_gart_bitmap, 0,
-                                                iommu_pages, size);
+                offset = iommu_area_alloc(iommu_gart_bitmap, iommu_pages, 0,
+                                          size, base_index, boundary_size, 0);
         }
         if (offset != -1) {
                 set_bit_string(iommu_gart_bitmap, offset, size);
@@ -114,7 +122,7 @@ static void free_iommu(unsigned long offset, int size)
         unsigned long flags;
 
         spin_lock_irqsave(&iommu_bitmap_lock, flags);
-        __clear_bit_string(iommu_gart_bitmap, offset, size);
+        iommu_area_free(iommu_gart_bitmap, offset, size);
         spin_unlock_irqrestore(&iommu_bitmap_lock, flags);
 }
 
@@ -235,7 +243,7 @@ static dma_addr_t dma_map_area(struct device *dev, dma_addr_t phys_mem,
                                 size_t size, int dir)
 {
         unsigned long npages = to_pages(phys_mem, size);
-        unsigned long iommu_page = alloc_iommu(npages);
+        unsigned long iommu_page = alloc_iommu(dev, npages);
         int i;
 
         if (iommu_page == -1) {
@@ -355,10 +363,11 @@ static int dma_map_sg_nonforce(struct device *dev, struct scatterlist *sg,
 }
 
 /* Map multiple scatterlist entries continuous into the first. */
-static int __dma_map_cont(struct scatterlist *start, int nelems,
-                          struct scatterlist *sout, unsigned long pages)
+static int __dma_map_cont(struct device *dev, struct scatterlist *start,
+                          int nelems, struct scatterlist *sout,
+                          unsigned long pages)
 {
-        unsigned long iommu_start = alloc_iommu(pages);
+        unsigned long iommu_start = alloc_iommu(dev, pages);
         unsigned long iommu_page = iommu_start;
         struct scatterlist *s;
         int i;
@@ -394,8 +403,8 @@ static int __dma_map_cont(struct scatterlist *start, int nelems,
 }
 
 static inline int
-dma_map_cont(struct scatterlist *start, int nelems, struct scatterlist *sout,
-             unsigned long pages, int need)
+dma_map_cont(struct device *dev, struct scatterlist *start, int nelems,
+             struct scatterlist *sout, unsigned long pages, int need)
 {
         if (!need) {
                 BUG_ON(nelems != 1);
@@ -403,7 +412,7 @@ dma_map_cont(struct scatterlist *start, int nelems, struct scatterlist *sout,
                 sout->dma_length = start->length;
                 return 0;
         }
-        return __dma_map_cont(start, nelems, sout, pages);
+        return __dma_map_cont(dev, start, nelems, sout, pages);
 }
 
 /*
@@ -416,6 +425,8 @@ gart_map_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
         struct scatterlist *s, *ps, *start_sg, *sgmap;
         int need = 0, nextneed, i, out, start;
         unsigned long pages = 0;
+        unsigned int seg_size;
+        unsigned int max_seg_size;
 
         if (nents == 0)
                 return 0;
@@ -426,6 +437,8 @@ gart_map_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
         out = 0;
         start = 0;
         start_sg = sgmap = sg;
+        seg_size = 0;
+        max_seg_size = dma_get_max_seg_size(dev);
         ps = NULL; /* shut up gcc */
         for_each_sg(sg, s, nents, i) {
                 dma_addr_t addr = sg_phys(s);
@@ -443,11 +456,13 @@ gart_map_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
                          * offset.
                          */
                         if (!iommu_merge || !nextneed || !need || s->offset ||
+                            (s->length + seg_size > max_seg_size) ||
                             (ps->offset + ps->length) % PAGE_SIZE) {
-                                if (dma_map_cont(start_sg, i - start, sgmap,
-                                                  pages, need) < 0)
+                                if (dma_map_cont(dev, start_sg, i - start,
+                                                 sgmap, pages, need) < 0)
                                         goto error;
                                 out++;
+                                seg_size = 0;
                                 sgmap = sg_next(sgmap);
                                 pages = 0;
                                 start = i;
@@ -455,11 +470,12 @@ gart_map_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
                         }
                 }
 
+                seg_size += s->length;
                 need = nextneed;
                 pages += to_pages(s->offset, s->length);
                 ps = s;
         }
-        if (dma_map_cont(start_sg, i - start, sgmap, pages, need) < 0)
+        if (dma_map_cont(dev, start_sg, i - start, sgmap, pages, need) < 0)
                 goto error;
         out++;
         flush_gart();
@@ -501,7 +517,7 @@ static __init unsigned long check_iommu_size(unsigned long aper, u64 aper_size)
         }
 
         a = aper + iommu_size;
-        iommu_size -= round_up(a, LARGE_PAGE_SIZE) - a;
+        iommu_size -= round_up(a, PMD_PAGE_SIZE) - a;
 
         if (iommu_size < 64*1024*1024) {
                 printk(KERN_WARNING
@@ -731,7 +747,8 @@ void __init gart_iommu_init(void)
          * the backing memory. The GART address is only used by PCI
          * devices.
          */
-        clear_kernel_mapping((unsigned long)__va(iommu_bus_base), iommu_size);
+        set_memory_np((unsigned long)__va(iommu_bus_base),
+                                iommu_size >> PAGE_SHIFT);
 
         /*
          * Try to workaround a bug (thanks to BenH)
diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
index 968371ab223a..dabdbeff1f77 100644
--- a/arch/x86/kernel/process_32.c
+++ b/arch/x86/kernel/process_32.c
@@ -251,7 +251,7 @@ void cpu_idle_wait(void)
                  * because it has nothing to do.
                  * Give all the remaining CPUS a kick.
                  */
-                smp_call_function_mask(map, do_nothing, 0, 0);
+                smp_call_function_mask(map, do_nothing, NULL, 0);
         } while (!cpus_empty(map));
 
         set_cpus_allowed(current, tmp);
diff --git a/arch/x86/kernel/quirks.c b/arch/x86/kernel/quirks.c
index 150ba29a0d33..3cd7a2dcd4fe 100644
--- a/arch/x86/kernel/quirks.c
+++ b/arch/x86/kernel/quirks.c
@@ -30,8 +30,8 @@ static void __devinit quirk_intel_irqbalance(struct pci_dev *dev)
         raw_pci_ops->read(0, 0, 0x40, 0x4c, 2, &word);
 
         if (!(word & (1 << 13))) {
-                printk(KERN_INFO "Intel E7520/7320/7525 detected. "
-                        "Disabling irq balancing and affinity\n");
+                dev_info(&dev->dev, "Intel E7520/7320/7525 detected; "
+                        "disabling irq balancing and affinity\n");
 #ifdef CONFIG_IRQBALANCE
                 irqbalance_disable("");
 #endif
@@ -104,14 +104,16 @@ static void ich_force_enable_hpet(struct pci_dev *dev)
         pci_read_config_dword(dev, 0xF0, &rcba);
         rcba &= 0xFFFFC000;
         if (rcba == 0) {
-                printk(KERN_DEBUG "RCBA disabled. Cannot force enable HPET\n");
+                dev_printk(KERN_DEBUG, &dev->dev, "RCBA disabled; "
+                        "cannot force enable HPET\n");
                 return;
         }
 
         /* use bits 31:14, 16 kB aligned */
         rcba_base = ioremap_nocache(rcba, 0x4000);
         if (rcba_base == NULL) {
-                printk(KERN_DEBUG "ioremap failed. Cannot force enable HPET\n");
+                dev_printk(KERN_DEBUG, &dev->dev, "ioremap failed; "
+                        "cannot force enable HPET\n");
                 return;
         }
 
@@ -122,8 +124,8 @@ static void ich_force_enable_hpet(struct pci_dev *dev)
                 /* HPET is enabled in HPTC. Just not reported by BIOS */
                 val = val & 0x3;
                 force_hpet_address = 0xFED00000 | (val << 12);
-                printk(KERN_DEBUG "Force enabled HPET at base address 0x%lx\n",
-                               force_hpet_address);
+                dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
+                        "0x%lx\n", force_hpet_address);
                 iounmap(rcba_base);
                 return;
         }
@@ -142,11 +144,12 @@ static void ich_force_enable_hpet(struct pci_dev *dev)
         if (err) {
                 force_hpet_address = 0;
                 iounmap(rcba_base);
-                printk(KERN_DEBUG "Failed to force enable HPET\n");
+                dev_printk(KERN_DEBUG, &dev->dev,
+                        "Failed to force enable HPET\n");
         } else {
                 force_hpet_resume_type = ICH_FORCE_HPET_RESUME;
-                printk(KERN_DEBUG "Force enabled HPET at base address 0x%lx\n",
-                               force_hpet_address);
+                dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
+                        "0x%lx\n", force_hpet_address);
         }
 }
 
@@ -208,8 +211,8 @@ static void old_ich_force_enable_hpet(struct pci_dev *dev)
         if (val & 0x4) {
                 val &= 0x3;
                 force_hpet_address = 0xFED00000 | (val << 12);
-                printk(KERN_DEBUG "HPET at base address 0x%lx\n",
-                               force_hpet_address);
+                dev_printk(KERN_DEBUG, &dev->dev, "HPET at 0x%lx\n",
+                        force_hpet_address);
                 return;
         }
 
@@ -229,14 +232,14 @@ static void old_ich_force_enable_hpet(struct pci_dev *dev)
                 /* HPET is enabled in HPTC. Just not reported by BIOS */
                 val &= 0x3;
                 force_hpet_address = 0xFED00000 | (val << 12);
-                printk(KERN_DEBUG "Force enabled HPET at base address 0x%lx\n",
-                               force_hpet_address);
+                dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
+                        "0x%lx\n", force_hpet_address);
                 cached_dev = dev;
                 force_hpet_resume_type = OLD_ICH_FORCE_HPET_RESUME;
                 return;
         }
 
-        printk(KERN_DEBUG "Failed to force enable HPET\n");
+        dev_printk(KERN_DEBUG, &dev->dev, "Failed to force enable HPET\n");
 }
 
 /*
@@ -294,8 +297,8 @@ static void vt8237_force_enable_hpet(struct pci_dev *dev)
          */
         if (val & 0x80) {
                 force_hpet_address = (val & ~0x3ff);
-                printk(KERN_DEBUG "HPET at base address 0x%lx\n",
-                               force_hpet_address);
+                dev_printk(KERN_DEBUG, &dev->dev, "HPET at 0x%lx\n",
+                        force_hpet_address);
                 return;
         }
 
@@ -309,14 +312,14 @@ static void vt8237_force_enable_hpet(struct pci_dev *dev)
         pci_read_config_dword(dev, 0x68, &val);
         if (val & 0x80) {
                 force_hpet_address = (val & ~0x3ff);
-                printk(KERN_DEBUG "Force enabled HPET at base address 0x%lx\n",
-                               force_hpet_address);
+                dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at "
+                        "0x%lx\n", force_hpet_address);
                 cached_dev = dev;
                 force_hpet_resume_type = VT8237_FORCE_HPET_RESUME;
                 return;
         }
 
-        printk(KERN_DEBUG "Failed to force enable HPET\n");
+        dev_printk(KERN_DEBUG, &dev->dev, "Failed to force enable HPET\n");
 }
 
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235,
@@ -344,7 +347,7 @@ static void nvidia_force_enable_hpet(struct pci_dev *dev)
         pci_read_config_dword(dev, 0x44, &val);
         force_hpet_address = val & 0xfffffffe;
         force_hpet_resume_type = NVIDIA_FORCE_HPET_RESUME;
-        printk(KERN_DEBUG "Force enabled HPET at base address 0x%lx\n",
+        dev_printk(KERN_DEBUG, &dev->dev, "Force enabled HPET at 0x%lx\n",
                 force_hpet_address);
         cached_dev = dev;
         return;
diff --git a/arch/x86/kernel/scx200_32.c b/arch/x86/kernel/scx200_32.c
index 87bc159d29df..7e004acbe526 100644
--- a/arch/x86/kernel/scx200_32.c
+++ b/arch/x86/kernel/scx200_32.c
@@ -65,7 +65,7 @@ static int __devinit scx200_probe(struct pci_dev *pdev, const struct pci_device_
                 base = pci_resource_start(pdev, 0);
                 printk(KERN_INFO NAME ": GPIO base 0x%x\n", base);
 
-                if (request_region(base, SCx200_GPIO_SIZE, "NatSemi SCx200 GPIO") == 0) {
+                if (!request_region(base, SCx200_GPIO_SIZE, "NatSemi SCx200 GPIO")) {
                         printk(KERN_ERR NAME ": can't allocate I/O for GPIOs\n");
                         return -EBUSY;
                 }
diff --git a/arch/x86/kernel/setup_64.c b/arch/x86/kernel/setup_64.c
index 77fb87bf6e5a..c8939dfddfba 100644
--- a/arch/x86/kernel/setup_64.c
+++ b/arch/x86/kernel/setup_64.c
@@ -182,7 +182,8 @@ contig_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
         unsigned long bootmap_size, bootmap;
 
         bootmap_size = bootmem_bootmap_pages(end_pfn)<<PAGE_SHIFT;
-        bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size);
+        bootmap = find_e820_area(0, end_pfn<<PAGE_SHIFT, bootmap_size,
+                                 PAGE_SIZE);
         if (bootmap == -1L)
                 panic("Cannot find bootmem map of size %ld\n", bootmap_size);
         bootmap_size = init_bootmem(bootmap >> PAGE_SHIFT, end_pfn);
@@ -1067,82 +1068,6 @@ static int show_cpuinfo(struct seq_file *m, void *v)
         struct cpuinfo_x86 *c = v;
         int cpu = 0, i;
 
-        /*
-         * These flag bits must match the definitions in <asm/cpufeature.h>.
-         * NULL means this bit is undefined or reserved; either way it doesn't
-         * have meaning as far as Linux is concerned.  Note that it's important
-         * to realize there is a difference between this table and CPUID -- if
-         * applications want to get the raw CPUID data, they should access
-         * /dev/cpu/<cpu_nr>/cpuid instead.
-         */
-        static const char *const x86_cap_flags[] = {
-                /* Intel-defined */
-                "fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce",
-                "cx8", "apic", NULL, "sep", "mtrr", "pge", "mca", "cmov",
-                "pat", "pse36", "pn", "clflush", NULL, "dts", "acpi", "mmx",
-                "fxsr", "sse", "sse2", "ss", "ht", "tm", "ia64", "pbe",
-
-                /* AMD-defined */
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, "syscall", NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, "nx", NULL, "mmxext", NULL,
-                NULL, "fxsr_opt", "pdpe1gb", "rdtscp", NULL, "lm",
-                "3dnowext", "3dnow",
-
-                /* Transmeta-defined */
-                "recovery", "longrun", NULL, "lrti", NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* Other (Linux-defined) */
-                "cxmmx", "k6_mtrr", "cyrix_arr", "centaur_mcr",
-                NULL, NULL, NULL, NULL,
-                "constant_tsc", "up", NULL, "arch_perfmon",
-                "pebs", "bts", NULL, "sync_rdtsc",
-                "rep_good", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* Intel-defined (#2) */
-                "pni", NULL, NULL, "monitor", "ds_cpl", "vmx", "smx", "est",
-                "tm2", "ssse3", "cid", NULL, NULL, "cx16", "xtpr", NULL,
-                NULL, NULL, "dca", "sse4_1", "sse4_2", NULL, NULL, "popcnt",
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* VIA/Cyrix/Centaur-defined */
-                NULL, NULL, "rng", "rng_en", NULL, NULL, "ace", "ace_en",
-                "ace2", "ace2_en", "phe", "phe_en", "pmm", "pmm_en", NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* AMD-defined (#2) */
-                "lahf_lm", "cmp_legacy", "svm", "extapic",
-                "cr8_legacy", "abm", "sse4a", "misalignsse",
-                "3dnowprefetch", "osvw", "ibs", "sse5",
-                "skinit", "wdt", NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-
-                /* Auxiliary (Linux-defined) */
-                "ida", NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-        };
-        static const char *const x86_power_flags[] = {
-                "ts",   /* temperature sensor */
-                "fid",  /* frequency id control */
-                "vid",  /* voltage id control */
-                "ttp",  /* thermal trip */
-                "tm",
-                "stc",
-                "100mhzsteps",
-                "hwpstate",
-                "",     /* tsc invariant mapped to constant_tsc */
-                /* nothing */
-        };
-
-
 #ifdef CONFIG_SMP
         cpu = c->cpu_index;
 #endif
diff --git a/arch/x86/kernel/smpboot_64.c b/arch/x86/kernel/smpboot_64.c
index cc64b8085c2a..d53bd6fcb428 100644
--- a/arch/x86/kernel/smpboot_64.c
+++ b/arch/x86/kernel/smpboot_64.c
@@ -1019,7 +1019,7 @@ static void remove_siblinginfo(int cpu)
         cpu_clear(cpu, cpu_sibling_setup_map);
 }
 
-void remove_cpu_from_maps(void)
+static void __ref remove_cpu_from_maps(void)
 {
         int cpu = smp_processor_id();
 
diff --git a/arch/x86/kernel/suspend_64.c b/arch/x86/kernel/suspend_64.c
index 09199511c256..7ac7130022f1 100644
--- a/arch/x86/kernel/suspend_64.c
+++ b/arch/x86/kernel/suspend_64.c
@@ -140,7 +140,12 @@ static void fix_processor_context(void)
         int cpu = smp_processor_id();
         struct tss_struct *t = &per_cpu(init_tss, cpu);
 
-        set_tss_desc(cpu,t);    /* This just modifies memory; should not be necessary. But... This is necessary, because 386 hardware has concept of busy TSS or some similar stupidity. */
+        /*
+         * This just modifies memory; should not be necessary. But... This
+         * is necessary, because 386 hardware has concept of busy TSS or some
+         * similar stupidity.
+         */
+        set_tss_desc(cpu, t);
 
         get_cpu_gdt_table(cpu)[GDT_ENTRY_TSS].type = 9;
 
@@ -160,7 +165,6 @@ static void fix_processor_context(void)
                 loaddebug(&current->thread, 6);
                 loaddebug(&current->thread, 7);
         }
-
 }
 
 #ifdef CONFIG_HIBERNATION
diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S
index 8344c70adf61..adff5562f5fd 100644
--- a/arch/x86/kernel/syscall_table_32.S
+++ b/arch/x86/kernel/syscall_table_32.S
@@ -321,6 +321,8 @@ ENTRY(sys_call_table)
         .long sys_epoll_pwait
         .long sys_utimensat             /* 320 */
         .long sys_signalfd
-        .long sys_timerfd
+        .long sys_timerfd_create
         .long sys_eventfd
         .long sys_fallocate
+        .long sys_timerfd_settime       /* 325 */
+        .long sys_timerfd_gettime
diff --git a/arch/x86/kernel/test_nx.c b/arch/x86/kernel/test_nx.c
index 6d7ef11e7975..36c100c323aa 100644
--- a/arch/x86/kernel/test_nx.c
+++ b/arch/x86/kernel/test_nx.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/sort.h>
 #include <asm/uaccess.h>
+#include <asm/asm.h>
 
 extern int rodata_test_data;
 
@@ -89,11 +90,7 @@ static noinline int test_address(void *address)
                 "2:     mov %[zero], %[rslt]\n"
                 "       ret\n"
                 ".previous\n"
-                ".section __ex_table,\"a\"\n"
-                "       .align 8\n"
-                "       .quad 0b\n"
-                "       .quad 2b\n"
-                ".previous\n"
+                _ASM_EXTABLE(0b,2b)
                 : [rslt] "=r" (result)
                 : [fake_code] "r" (address), [zero] "r" (0UL), "0" (result)
         );
diff --git a/arch/x86/kernel/topology.c b/arch/x86/kernel/topology.c
index 78cbb655aa79..e6757aaa202b 100644
--- a/arch/x86/kernel/topology.c
+++ b/arch/x86/kernel/topology.c
@@ -57,11 +57,10 @@ void arch_unregister_cpu(int num)
 }
 EXPORT_SYMBOL(arch_unregister_cpu);
 #else
-int arch_register_cpu(int num)
+static int __init arch_register_cpu(int num)
 {
         return register_cpu(&per_cpu(cpu_devices, num).cpu, num);
 }
-EXPORT_SYMBOL(arch_register_cpu);
 #endif /*CONFIG_HOTPLUG_CPU*/
 
 static int __init topology_init(void)
diff --git a/arch/x86/kernel/trampoline_32.S b/arch/x86/kernel/trampoline_32.S
index 9bcc1c6aca3d..64580679861e 100644
--- a/arch/x86/kernel/trampoline_32.S
+++ b/arch/x86/kernel/trampoline_32.S
@@ -11,12 +11,7 @@
  *      trampoline page to make our stack and everything else
  *      is a mystery.
  *
- *      In fact we don't actually need a stack so we don't
- *      set one up.
- *
- *      We jump into the boot/compressed/head.S code. So you'd
- *      better be running a compressed kernel image or you
- *      won't get very far.
+ *      We jump into arch/x86/kernel/head_32.S.
  *
  *      On entry to trampoline_data, the processor is in real mode
  *      with 16-bit addressing and 16-bit data.  CS has some value
diff --git a/arch/x86/kernel/trampoline_64.S b/arch/x86/kernel/trampoline_64.S
index e30b67c6a9f5..4aedd0bcee4c 100644
--- a/arch/x86/kernel/trampoline_64.S
+++ b/arch/x86/kernel/trampoline_64.S
@@ -10,9 +10,6 @@
  *      trampoline page to make our stack and everything else
  *      is a mystery.
  *
- *      In fact we don't actually need a stack so we don't
- *      set one up.
- *
  *      On entry to trampoline_data, the processor is in real mode
  *      with 16-bit addressing and 16-bit data.  CS has some value
  *      and IP is zero.  Thus, data addresses need to be absolute
diff --git a/arch/x86/kernel/vmi_32.c b/arch/x86/kernel/vmi_32.c
index 4525bc2c2e19..12affe1f9bce 100644
--- a/arch/x86/kernel/vmi_32.c
+++ b/arch/x86/kernel/vmi_32.c
@@ -220,21 +220,21 @@ static void vmi_set_tr(void)
 static void vmi_write_idt_entry(gate_desc *dt, int entry, const gate_desc *g)
 {
         u32 *idt_entry = (u32 *)g;
-        vmi_ops.write_idt_entry(dt, entry, idt_entry[0], idt_entry[2]);
+        vmi_ops.write_idt_entry(dt, entry, idt_entry[0], idt_entry[1]);
 }
 
 static void vmi_write_gdt_entry(struct desc_struct *dt, int entry,
                                 const void *desc, int type)
 {
         u32 *gdt_entry = (u32 *)desc;
-        vmi_ops.write_gdt_entry(dt, entry, gdt_entry[0], gdt_entry[2]);
+        vmi_ops.write_gdt_entry(dt, entry, gdt_entry[0], gdt_entry[1]);
 }
 
 static void vmi_write_ldt_entry(struct desc_struct *dt, int entry,
                                 const void *desc)
 {
         u32 *ldt_entry = (u32 *)desc;
-        vmi_ops.write_idt_entry(dt, entry, ldt_entry[0], ldt_entry[2]);
+        vmi_ops.write_idt_entry(dt, entry, ldt_entry[0], ldt_entry[1]);
 }
 
 static void vmi_load_sp0(struct tss_struct *tss,
diff --git a/arch/x86/kvm/Kconfig b/arch/x86/kvm/Kconfig
index c83e1c9b5129..41962e793c0f 100644
--- a/arch/x86/kvm/Kconfig
+++ b/arch/x86/kvm/Kconfig
@@ -53,5 +53,6 @@ config KVM_AMD
 # OK, it's a little counter-intuitive to do this, but it puts it neatly under
 # the virtualization menu.
 source drivers/lguest/Kconfig
+source drivers/virtio/Kconfig
 
 endif # VIRTUALIZATION
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 8f94a0b89dff..cf5308148689 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -1739,7 +1739,7 @@ static int emulator_cmpxchg_emulated(unsigned long addr,
         if (bytes == 8) {
                 gpa_t gpa;
                 struct page *page;
-                char *addr;
+                char *kaddr;
                 u64 val;
 
                 down_read(&current->mm->mmap_sem);
@@ -1754,9 +1754,9 @@ static int emulator_cmpxchg_emulated(unsigned long addr,
 
                 val = *(u64 *)new;
                 page = gfn_to_page(vcpu->kvm, gpa >> PAGE_SHIFT);
-                addr = kmap_atomic(page, KM_USER0);
-                set_64bit((u64 *)(addr + offset_in_page(gpa)), val);
-                kunmap_atomic(addr, KM_USER0);
+                kaddr = kmap_atomic(page, KM_USER0);
+                set_64bit((u64 *)(kaddr + offset_in_page(gpa)), val);
+                kunmap_atomic(kaddr, KM_USER0);
                 kvm_release_page_dirty(page);
         emul_write:
                 up_read(&current->mm->mmap_sem);
diff --git a/arch/x86/lib/Makefile b/arch/x86/lib/Makefile
index 4876182daf8a..25df1c1989fe 100644
--- a/arch/x86/lib/Makefile
+++ b/arch/x86/lib/Makefile
@@ -21,7 +21,7 @@ else
 
         lib-y += csum-partial_64.o csum-copy_64.o csum-wrappers_64.o
         lib-y += thunk_64.o clear_page_64.o copy_page_64.o
-        lib-y += bitstr_64.o bitops_64.o
+        lib-y += bitops_64.o
         lib-y += memmove_64.o memset_64.o
         lib-y += copy_user_64.o rwlock_64.o copy_user_nocache_64.o
 endif
diff --git a/arch/x86/lib/bitops_32.c b/arch/x86/lib/bitops_32.c
index afd0045595d4..b65440459859 100644
--- a/arch/x86/lib/bitops_32.c
+++ b/arch/x86/lib/bitops_32.c
@@ -2,7 +2,7 @@
 #include <linux/module.h>
 
 /**
- * find_next_bit - find the first set bit in a memory region
+ * find_next_bit - find the next set bit in a memory region
  * @addr: The address to base the search on
  * @offset: The bitnumber to start searching at
  * @size: The maximum size to search
diff --git a/arch/x86/lib/bitops_64.c b/arch/x86/lib/bitops_64.c
index 95b6d9639fba..0e8f491e6ccc 100644
--- a/arch/x86/lib/bitops_64.c
+++ b/arch/x86/lib/bitops_64.c
@@ -58,7 +58,7 @@ long find_first_zero_bit(const unsigned long * addr, unsigned long size)
 }
 
 /**
- * find_next_zero_bit - find the first zero bit in a memory region
+ * find_next_zero_bit - find the next zero bit in a memory region
  * @addr: The address to base the search on
  * @offset: The bitnumber to start searching at
  * @size: The maximum size to search
diff --git a/arch/x86/lib/bitstr_64.c b/arch/x86/lib/bitstr_64.c
deleted file mode 100644
index 7445caf1b5de..000000000000
--- a/arch/x86/lib/bitstr_64.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <linux/module.h>
-#include <linux/bitops.h>
-
-/* Find string of zero bits in a bitmap */ 
-unsigned long 
-find_next_zero_string(unsigned long *bitmap, long start, long nbits, int len)
-{ 
-        unsigned long n, end, i;        
-
- again:
-        n = find_next_zero_bit(bitmap, nbits, start);
-        if (n == -1) 
-                return -1;
-        
-        /* could test bitsliced, but it's hardly worth it */
-        end = n+len;
-        if (end > nbits)
-                return -1; 
-        for (i = n+1; i < end; i++) { 
-                if (test_bit(i, bitmap)) {  
-                        start = i+1; 
-                        goto again; 
-                } 
-        }
-        return n;
-}
-
-EXPORT_SYMBOL(find_next_zero_string);
diff --git a/arch/x86/lib/mmx_32.c b/arch/x86/lib/mmx_32.c
index 28084d2e8dd4..cc9b4a4450f3 100644
--- a/arch/x86/lib/mmx_32.c
+++ b/arch/x86/lib/mmx_32.c
@@ -4,6 +4,7 @@
 #include <linux/hardirq.h>
 #include <linux/module.h>
 
+#include <asm/asm.h>
 #include <asm/i387.h>
 
 
@@ -50,10 +51,7 @@ void *_mmx_memcpy(void *to, const void *from, size_t len)
                 "3: movw $0x1AEB, 1b\n" /* jmp on 26 bytes */
                 "   jmp 2b\n"
                 ".previous\n"
-                ".section __ex_table,\"a\"\n"
-                "       .align 4\n"
-                "       .long 1b, 3b\n"
-                ".previous"
+                _ASM_EXTABLE(1b,3b)
                 : : "r" (from) );
                 
         
@@ -81,10 +79,7 @@ void *_mmx_memcpy(void *to, const void *from, size_t len)
                 "3: movw $0x05EB, 1b\n" /* jmp on 5 bytes */
                 "   jmp 2b\n"
                 ".previous\n"
-                ".section __ex_table,\"a\"\n"
-                "       .align 4\n"
-                "       .long 1b, 3b\n"
-                ".previous"
+                _ASM_EXTABLE(1b,3b)
                 : : "r" (from), "r" (to) : "memory");
                 from+=64;
                 to+=64;
@@ -181,10 +176,7 @@ static void fast_copy_page(void *to, void *from)
                 "3: movw $0x1AEB, 1b\n" /* jmp on 26 bytes */
                 "   jmp 2b\n"
                 ".previous\n"
-                ".section __ex_table,\"a\"\n"
-                "       .align 4\n"
-                "       .long 1b, 3b\n"
-                ".previous"
+                _ASM_EXTABLE(1b,3b)
                 : : "r" (from) );
 
         for(i=0; i<(4096-320)/64; i++)
@@ -211,10 +203,7 @@ static void fast_copy_page(void *to, void *from)
                 "3: movw $0x05EB, 1b\n" /* jmp on 5 bytes */
                 "   jmp 2b\n"
                 ".previous\n"
-                ".section __ex_table,\"a\"\n"
-                "       .align 4\n"
-                "       .long 1b, 3b\n"
-                ".previous"
+                _ASM_EXTABLE(1b,3b)
                 : : "r" (from), "r" (to) : "memory");
                 from+=64;
                 to+=64;
@@ -311,10 +300,7 @@ static void fast_copy_page(void *to, void *from)
                 "3: movw $0x1AEB, 1b\n" /* jmp on 26 bytes */
                 "   jmp 2b\n"
                 ".previous\n"
-                ".section __ex_table,\"a\"\n"
-                "       .align 4\n"
-                "       .long 1b, 3b\n"
-                ".previous"
+                _ASM_EXTABLE(1b,3b)
                 : : "r" (from) );
 
         for(i=0; i<4096/64; i++)
@@ -341,10 +327,7 @@ static void fast_copy_page(void *to, void *from)
                 "3: movw $0x05EB, 1b\n" /* jmp on 5 bytes */
                 "   jmp 2b\n"
                 ".previous\n"
-                ".section __ex_table,\"a\"\n"
-                "       .align 4\n"
-                "       .long 1b, 3b\n"
-                ".previous"
+                _ASM_EXTABLE(1b,3b)
                 : : "r" (from), "r" (to) : "memory");
                 from+=64;
                 to+=64;
diff --git a/arch/x86/lib/usercopy_32.c b/arch/x86/lib/usercopy_32.c
index 8bab2b2efaff..e849b9998b0e 100644
--- a/arch/x86/lib/usercopy_32.c
+++ b/arch/x86/lib/usercopy_32.c
@@ -48,10 +48,7 @@ do {									   \
                 "3:     movl %5,%0\n"                                      \
                 "       jmp 2b\n"                                          \
                 ".previous\n"                                              \
-                ".section __ex_table,\"a\"\n"                              \
-                "       .align 4\n"                                        \
-                "       .long 0b,3b\n"                                     \
-                ".previous"                                                \
+                _ASM_EXTABLE(0b,3b)                                        \
                 : "=d"(res), "=c"(count), "=&a" (__d0), "=&S" (__d1),      \
                   "=&D" (__d2)                                             \
                 : "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \
@@ -132,11 +129,8 @@ do {									\
                 "3:     lea 0(%2,%0,4),%0\n"                            \
                 "       jmp 2b\n"                                       \
                 ".previous\n"                                           \
-                ".section __ex_table,\"a\"\n"                           \
-                "       .align 4\n"                                     \
-                "       .long 0b,3b\n"                                  \
-                "       .long 1b,2b\n"                                  \
-                ".previous"                                             \
+                _ASM_EXTABLE(0b,3b)                                     \
+                _ASM_EXTABLE(1b,2b)                                     \
                 : "=&c"(size), "=&D" (__d0)                             \
                 : "r"(size & 3), "0"(size / 4), "1"(addr), "a"(0));     \
 } while (0)
@@ -817,6 +811,7 @@ unsigned long __copy_from_user_ll_nocache(void *to, const void __user *from,
 #endif
         return n;
 }
+EXPORT_SYMBOL(__copy_from_user_ll_nocache);
 
 unsigned long __copy_from_user_ll_nocache_nozero(void *to, const void __user *from,
                                         unsigned long n)
@@ -831,6 +826,7 @@ unsigned long __copy_from_user_ll_nocache_nozero(void *to, const void __user *fr
 #endif
         return n;
 }
+EXPORT_SYMBOL(__copy_from_user_ll_nocache_nozero);
 
 /**
  * copy_to_user: - Copy a block of data into user space.
diff --git a/arch/x86/lib/usercopy_64.c b/arch/x86/lib/usercopy_64.c
index 893d43f838cc..0c89d1bb0287 100644
--- a/arch/x86/lib/usercopy_64.c
+++ b/arch/x86/lib/usercopy_64.c
@@ -31,10 +31,7 @@ do {									   \
                 "3:     movq %5,%0\n"                                      \
                 "       jmp 2b\n"                                          \
                 ".previous\n"                                              \
-                ".section __ex_table,\"a\"\n"                              \
-                "       .align 8\n"                                        \
-                "       .quad 0b,3b\n"                                     \
-                ".previous"                                                \
+                _ASM_EXTABLE(0b,3b)                                        \
                 : "=r"(res), "=c"(count), "=&a" (__d0), "=&S" (__d1),      \
                   "=&D" (__d2)                                             \
                 : "i"(-EFAULT), "0"(count), "1"(count), "3"(src), "4"(dst) \
@@ -87,11 +84,8 @@ unsigned long __clear_user(void __user *addr, unsigned long size)
                 "3:     lea 0(%[size1],%[size8],8),%[size8]\n"
                 "       jmp 2b\n"
                 ".previous\n"
-                ".section __ex_table,\"a\"\n"
-                "       .align 8\n"
-                "       .quad 0b,3b\n"
-                "       .quad 1b,2b\n"
-                ".previous"
+                _ASM_EXTABLE(0b,3b)
+                _ASM_EXTABLE(1b,2b)
                 : [size8] "=c"(size), [dst] "=&D" (__d0)
                 : [size1] "r"(size & 7), "[size8]" (size / 8), "[dst]"(addr),
                   [zero] "r" (0UL), [eight] "r" (8UL));
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index e28cc5277b16..ad8b9733d6b3 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -240,7 +240,8 @@ void dump_pagetable(unsigned long address)
         pud = pud_offset(pgd, address);
         if (bad_address(pud)) goto bad;
         printk("PUD %lx ", pud_val(*pud));
-        if (!pud_present(*pud)) goto ret;
+        if (!pud_present(*pud) || pud_large(*pud))
+                goto ret;
 
         pmd = pmd_offset(pud, address);
         if (bad_address(pmd)) goto bad;
@@ -382,7 +383,7 @@ static void show_fault_oops(struct pt_regs *regs, unsigned long error_code,
 
 #ifdef CONFIG_X86_PAE
         if (error_code & PF_INSTR) {
-                int level;
+                unsigned int level;
                 pte_t *pte = lookup_address(address, &level);
 
                 if (pte && pte_present(*pte) && !pte_exec(*pte))
@@ -508,6 +509,10 @@ static int vmalloc_fault(unsigned long address)
         pmd_t *pmd, *pmd_ref;
         pte_t *pte, *pte_ref;
 
+        /* Make sure we are in vmalloc area */
+        if (!(address >= VMALLOC_START && address < VMALLOC_END))
+                return -1;
+
         /* Copy kernel mappings over when needed. This can also
            happen within a race in page table update. In the later
            case just flush. */
@@ -603,6 +608,9 @@ void __kprobes do_page_fault(struct pt_regs *regs, unsigned long error_code)
          */
 #ifdef CONFIG_X86_32
         if (unlikely(address >= TASK_SIZE)) {
+#else
+        if (unlikely(address >= TASK_SIZE64)) {
+#endif
                 if (!(error_code & (PF_RSVD|PF_USER|PF_PROT)) &&
                     vmalloc_fault(address) >= 0)
                         return;
@@ -618,6 +626,8 @@ void __kprobes do_page_fault(struct pt_regs *regs, unsigned long error_code)
                 goto bad_area_nosemaphore;
         }
 
+
+#ifdef CONFIG_X86_32
         /* It's safe to allow irq's after cr2 has been saved and the vmalloc
            fault has been handled. */
         if (regs->flags & (X86_EFLAGS_IF|VM_MASK))
@@ -630,28 +640,6 @@ void __kprobes do_page_fault(struct pt_regs *regs, unsigned long error_code)
         if (in_atomic() || !mm)
                 goto bad_area_nosemaphore;
 #else /* CONFIG_X86_64 */
-        if (unlikely(address >= TASK_SIZE64)) {
-                /*
-                 * Don't check for the module range here: its PML4
-                 * is always initialized because it's shared with the main
-                 * kernel text. Only vmalloc may need PML4 syncups.
-                 */
-                if (!(error_code & (PF_RSVD|PF_USER|PF_PROT)) &&
-                      ((address >= VMALLOC_START && address < VMALLOC_END))) {
-                        if (vmalloc_fault(address) >= 0)
-                                return;
-                }
-
-                /* Can handle a stale RO->RW TLB */
-                if (spurious_fault(address, error_code))
-                        return;
-
-                /*
-                 * Don't take the mm semaphore here. If we fixup a prefetch
-                 * fault we could otherwise deadlock.
-                 */
-                goto bad_area_nosemaphore;
-        }
         if (likely(regs->flags & X86_EFLAGS_IF))
                 local_irq_enable();
 
diff --git a/arch/x86/mm/init_32.c b/arch/x86/mm/init_32.c
index da524fb22422..d1bc04006d16 100644
--- a/arch/x86/mm/init_32.c
+++ b/arch/x86/mm/init_32.c
@@ -31,6 +31,7 @@
 #include <linux/initrd.h>
 #include <linux/cpumask.h>
 
+#include <asm/asm.h>
 #include <asm/processor.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
@@ -423,23 +424,23 @@ static void __init pagetable_init(void)
         paravirt_pagetable_setup_done(pgd_base);
 }
 
-#if defined(CONFIG_HIBERNATION) || defined(CONFIG_ACPI)
+#ifdef CONFIG_ACPI_SLEEP
 /*
- * Swap suspend & friends need this for resume because things like the intel-agp
+ * ACPI suspend needs this for resume, because things like the intel-agp
  * driver might have split up a kernel 4MB mapping.
  */
-char __nosavedata swsusp_pg_dir[PAGE_SIZE]
+char swsusp_pg_dir[PAGE_SIZE]
         __attribute__ ((aligned(PAGE_SIZE)));
 
 static inline void save_pg_dir(void)
 {
         memcpy(swsusp_pg_dir, swapper_pg_dir, PAGE_SIZE);
 }
-#else
+#else /* !CONFIG_ACPI_SLEEP */
 static inline void save_pg_dir(void)
 {
 }
-#endif
+#endif /* !CONFIG_ACPI_SLEEP */
 
 void zap_low_mappings(void)
 {
@@ -718,10 +719,7 @@ static noinline int do_test_wp_bit(void)
                 "1:     movb %1, %0     \n"
                 "       xorl %2, %2     \n"
                 "2:                     \n"
-                ".section __ex_table, \"a\"\n"
-                "       .align 4        \n"
-                "       .long 1b, 2b    \n"
-                ".previous              \n"
+                _ASM_EXTABLE(1b,2b)
                 :"=m" (*(char *)fix_to_virt(FIX_WP_TEST)),
                  "=q" (tmp_reg),
                  "=r" (flag)
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index cc50a13ce8d9..3a98d6f724ab 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -273,7 +273,6 @@ phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end)
         int i = pmd_index(address);
 
         for (; i < PTRS_PER_PMD; i++, address += PMD_SIZE) {
-                unsigned long entry;
                 pmd_t *pmd = pmd_page + pmd_index(address);
 
                 if (address >= end) {
@@ -287,9 +286,8 @@ phys_pmd_init(pmd_t *pmd_page, unsigned long address, unsigned long end)
                 if (pmd_val(*pmd))
                         continue;
 
-                entry = __PAGE_KERNEL_LARGE|_PAGE_GLOBAL|address;
-                entry &= __supported_pte_mask;
-                set_pmd(pmd, __pmd(entry));
+                set_pte((pte_t *)pmd,
+                        pfn_pte(address >> PAGE_SHIFT, PAGE_KERNEL_LARGE));
         }
 }
 
@@ -354,17 +352,10 @@ static void __init find_early_table_space(unsigned long end)
          * need roughly 0.5KB per GB.
          */
         start = 0x8000;
-        table_start = find_e820_area(start, end, tables);
+        table_start = find_e820_area(start, end, tables, PAGE_SIZE);
         if (table_start == -1UL)
                 panic("Cannot find space for the kernel page tables");
 
-        /*
-         * When you have a lot of RAM like 256GB, early_table will not fit
-         * into 0x8000 range, find_e820_area() will find area after kernel
-         * bss but the table_start is not page aligned, so need to round it
-         * up to avoid overlap with bss:
-         */
-        table_start = round_up(table_start, PAGE_SIZE);
         table_start >>= PAGE_SHIFT;
         table_end = table_start;
 
@@ -420,7 +411,9 @@ void __init_refok init_memory_mapping(unsigned long start, unsigned long end)
                 mmu_cr4_features = read_cr4();
         __flush_tlb_all();
 
-        reserve_early(table_start << PAGE_SHIFT, table_end << PAGE_SHIFT);
+        if (!after_bootmem)
+                reserve_early(table_start << PAGE_SHIFT,
+                                 table_end << PAGE_SHIFT, "PGTABLE");
 }
 
 #ifndef CONFIG_NUMA
@@ -440,49 +433,6 @@ void __init paging_init(void)
 #endif
 
 /*
- * Unmap a kernel mapping if it exists. This is useful to avoid
- * prefetches from the CPU leading to inconsistent cache lines.
- * address and size must be aligned to 2MB boundaries.
- * Does nothing when the mapping doesn't exist.
- */
-void __init clear_kernel_mapping(unsigned long address, unsigned long size)
-{
-        unsigned long end = address + size;
-
-        BUG_ON(address & ~LARGE_PAGE_MASK);
-        BUG_ON(size & ~LARGE_PAGE_MASK);
-
-        for (; address < end; address += LARGE_PAGE_SIZE) {
-                pgd_t *pgd = pgd_offset_k(address);
-                pud_t *pud;
-                pmd_t *pmd;
-
-                if (pgd_none(*pgd))
-                        continue;
-
-                pud = pud_offset(pgd, address);
-                if (pud_none(*pud))
-                        continue;
-
-                pmd = pmd_offset(pud, address);
-                if (!pmd || pmd_none(*pmd))
-                        continue;
-
-                if (!(pmd_val(*pmd) & _PAGE_PSE)) {
-                        /*
-                         * Could handle this, but it should not happen
-                         * currently:
-                         */
-                        printk(KERN_ERR "clear_kernel_mapping: "
-                                "mapping has been split. will leak memory\n");
-                        pmd_ERROR(*pmd);
-                }
-                set_pmd(pmd, __pmd(0));
-        }
-        __flush_tlb_all();
-}
-
-/*
  * Memory hotplug specific functions
  */
 void online_page(struct page *page)
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index ed795721ca8e..ee6648fe6b15 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -70,23 +70,11 @@ int page_is_ram(unsigned long pagenr)
  * Fix up the linear direct mapping of the kernel to avoid cache attribute
  * conflicts.
  */
-static int ioremap_change_attr(unsigned long paddr, unsigned long size,
+static int ioremap_change_attr(unsigned long vaddr, unsigned long size,
                                enum ioremap_mode mode)
 {
-        unsigned long vaddr = (unsigned long)__va(paddr);
         unsigned long nrpages = size >> PAGE_SHIFT;
-        int err, level;
-
-        /* No change for pages after the last mapping */
-        if ((paddr + size - 1) >= (max_pfn_mapped << PAGE_SHIFT))
-                return 0;
-
-        /*
-         * If there is no identity map for this address,
-         * change_page_attr_addr is unnecessary
-         */
-        if (!lookup_address(vaddr, &level))
-                return 0;
+        int err;
 
         switch (mode) {
         case IOR_MODE_UNCACHED:
@@ -113,9 +101,8 @@ static int ioremap_change_attr(unsigned long paddr, unsigned long size,
 static void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
                                enum ioremap_mode mode)
 {
-        void __iomem *addr;
+        unsigned long pfn, offset, last_addr, vaddr;
         struct vm_struct *area;
-        unsigned long offset, last_addr;
         pgprot_t prot;
 
         /* Don't allow wraparound or zero size */
@@ -132,9 +119,10 @@ static void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
         /*
          * Don't allow anybody to remap normal RAM that we're using..
          */
-        for (offset = phys_addr >> PAGE_SHIFT; offset < max_pfn_mapped &&
-             (offset << PAGE_SHIFT) < last_addr; offset++) {
-                if (page_is_ram(offset))
+        for (pfn = phys_addr >> PAGE_SHIFT; pfn < max_pfn_mapped &&
+             (pfn << PAGE_SHIFT) < last_addr; pfn++) {
+                if (page_is_ram(pfn) && pfn_valid(pfn) &&
+                    !PageReserved(pfn_to_page(pfn)))
                         return NULL;
         }
 
@@ -162,19 +150,18 @@ static void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
         if (!area)
                 return NULL;
         area->phys_addr = phys_addr;
-        addr = (void __iomem *) area->addr;
-        if (ioremap_page_range((unsigned long)addr, (unsigned long)addr + size,
-                               phys_addr, prot)) {
-                remove_vm_area((void *)(PAGE_MASK & (unsigned long) addr));
+        vaddr = (unsigned long) area->addr;
+        if (ioremap_page_range(vaddr, vaddr + size, phys_addr, prot)) {
+                remove_vm_area((void *)(vaddr & PAGE_MASK));
                 return NULL;
         }
 
-        if (ioremap_change_attr(phys_addr, size, mode) < 0) {
-                vunmap(addr);
+        if (ioremap_change_attr(vaddr, size, mode) < 0) {
+                vunmap(area->addr);
                 return NULL;
         }
 
-        return (void __iomem *) (offset + (char __iomem *)addr);
+        return (void __iomem *) (vaddr + offset);
 }
 
 /**
@@ -253,9 +240,6 @@ void iounmap(volatile void __iomem *addr)
                 return;
         }
 
-        /* Reset the direct mapping. Can block */
-        ioremap_change_attr(p->phys_addr, p->size, IOR_MODE_CACHED);
-
         /* Finally remove it */
         o = remove_vm_area((void *)addr);
         BUG_ON(p != o || o == NULL);
@@ -340,7 +324,7 @@ void __init early_ioremap_reset(void)
         for (idx = FIX_BTMAP_BEGIN; idx >= FIX_BTMAP_END; idx--) {
                 addr = fix_to_virt(idx);
                 pte = early_ioremap_pte(addr);
-                if (!*pte & _PAGE_PRESENT) {
+                if (*pte & _PAGE_PRESENT) {
                         phys = *pte & PAGE_MASK;
                         set_fixmap(idx, phys);
                 }
diff --git a/arch/x86/mm/numa_64.c b/arch/x86/mm/numa_64.c
index dc3b1f7e1451..5a02bf4c91ec 100644
--- a/arch/x86/mm/numa_64.c
+++ b/arch/x86/mm/numa_64.c
@@ -84,26 +84,24 @@ static int __init populate_memnodemap(const struct bootnode *nodes,
 
 static int __init allocate_cachealigned_memnodemap(void)
 {
-        unsigned long pad, pad_addr;
+        unsigned long addr;
 
         memnodemap = memnode.embedded_map;
         if (memnodemapsize <= ARRAY_SIZE(memnode.embedded_map))
                 return 0;
 
-        pad = L1_CACHE_BYTES - 1;
-        pad_addr = 0x8000;
-        nodemap_size = pad + sizeof(s16) * memnodemapsize;
-        nodemap_addr = find_e820_area(pad_addr, end_pfn<<PAGE_SHIFT,
-                                      nodemap_size);
+        addr = 0x8000;
+        nodemap_size = round_up(sizeof(s16) * memnodemapsize, L1_CACHE_BYTES);
+        nodemap_addr = find_e820_area(addr, end_pfn<<PAGE_SHIFT,
+                                      nodemap_size, L1_CACHE_BYTES);
         if (nodemap_addr == -1UL) {
                 printk(KERN_ERR
                        "NUMA: Unable to allocate Memory to Node hash map\n");
                 nodemap_addr = nodemap_size = 0;
                 return -1;
         }
-        pad_addr = (nodemap_addr + pad) & ~pad;
-        memnodemap = phys_to_virt(pad_addr);
-        reserve_early(nodemap_addr, nodemap_addr + nodemap_size);
+        memnodemap = phys_to_virt(nodemap_addr);
+        reserve_early(nodemap_addr, nodemap_addr + nodemap_size, "MEMNODEMAP");
 
         printk(KERN_DEBUG "NUMA: Allocated memnodemap from %lx - %lx\n",
                nodemap_addr, nodemap_addr + nodemap_size);
@@ -164,15 +162,16 @@ int early_pfn_to_nid(unsigned long pfn)
 }
 
 static void * __init early_node_mem(int nodeid, unsigned long start,
-                                    unsigned long end, unsigned long size)
+                                    unsigned long end, unsigned long size,
+                                    unsigned long align)
 {
-        unsigned long mem = find_e820_area(start, end, size);
+        unsigned long mem = find_e820_area(start, end, size, align);
         void *ptr;
 
         if (mem != -1L)
                 return __va(mem);
-        ptr = __alloc_bootmem_nopanic(size,
-                                SMP_CACHE_BYTES, __pa(MAX_DMA_ADDRESS));
+
+        ptr = __alloc_bootmem_nopanic(size, align, __pa(MAX_DMA_ADDRESS));
         if (ptr == NULL) {
                 printk(KERN_ERR "Cannot find %lu bytes in node %d\n",
                        size, nodeid);
@@ -198,10 +197,13 @@ void __init setup_node_bootmem(int nodeid, unsigned long start,
         start_pfn = start >> PAGE_SHIFT;
         end_pfn = end >> PAGE_SHIFT;
 
-        node_data[nodeid] = early_node_mem(nodeid, start, end, pgdat_size);
+        node_data[nodeid] = early_node_mem(nodeid, start, end, pgdat_size,
+                                           SMP_CACHE_BYTES);
         if (node_data[nodeid] == NULL)
                 return;
         nodedata_phys = __pa(node_data[nodeid]);
+        printk(KERN_INFO "  NODE_DATA [%016lx - %016lx]\n", nodedata_phys,
+                nodedata_phys + pgdat_size - 1);
 
         memset(NODE_DATA(nodeid), 0, sizeof(pg_data_t));
         NODE_DATA(nodeid)->bdata = &plat_node_bdata[nodeid];
@@ -211,8 +213,12 @@ void __init setup_node_bootmem(int nodeid, unsigned long start,
         /* Find a place for the bootmem map */
         bootmap_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
         bootmap_start = round_up(nodedata_phys + pgdat_size, PAGE_SIZE);
+        /*
+         * SMP_CAHCE_BYTES could be enough, but init_bootmem_node like
+         * to use that to align to PAGE_SIZE
+         */
         bootmap = early_node_mem(nodeid, bootmap_start, end,
-                                        bootmap_pages<<PAGE_SHIFT);
+                                 bootmap_pages<<PAGE_SHIFT, PAGE_SIZE);
         if (bootmap == NULL)  {
                 if (nodedata_phys < start || nodedata_phys >= end)
                         free_bootmem((unsigned long)node_data[nodeid],
@@ -221,12 +227,15 @@ void __init setup_node_bootmem(int nodeid, unsigned long start,
                 return;
         }
         bootmap_start = __pa(bootmap);
-        Dprintk("bootmap start %lu pages %lu\n", bootmap_start, bootmap_pages);
 
         bootmap_size = init_bootmem_node(NODE_DATA(nodeid),
                                          bootmap_start >> PAGE_SHIFT,
                                          start_pfn, end_pfn);
 
+        printk(KERN_INFO "  bootmap [%016lx -  %016lx] pages %lx\n",
+                 bootmap_start, bootmap_start + bootmap_size - 1,
+                 bootmap_pages);
+
         free_bootmem_with_active_regions(nodeid, end);
 
         reserve_bootmem_node(NODE_DATA(nodeid), nodedata_phys, pgdat_size);
diff --git a/arch/x86/mm/pageattr-test.c b/arch/x86/mm/pageattr-test.c
index 06353d43f72e..398f3a578dde 100644
--- a/arch/x86/mm/pageattr-test.c
+++ b/arch/x86/mm/pageattr-test.c
@@ -42,7 +42,7 @@ static __init int print_split(struct split_state *s)
         s->max_exec = 0;
         for (i = 0; i < max_pfn_mapped; ) {
                 unsigned long addr = (unsigned long)__va(i << PAGE_SHIFT);
-                int level;
+                unsigned int level;
                 pte_t *pte;
 
                 pte = lookup_address(addr, &level);
@@ -106,7 +106,7 @@ static __init int exercise_pageattr(void)
         unsigned long *bm;
         pte_t *pte, pte0;
         int failed = 0;
-        int level;
+        unsigned int level;
         int i, k;
         int err;
 
@@ -137,7 +137,8 @@ static __init int exercise_pageattr(void)
 
                 for (k = 0; k < len[i]; k++) {
                         pte = lookup_address(addr[i] + k*PAGE_SIZE, &level);
-                        if (!pte || pgprot_val(pte_pgprot(*pte)) == 0) {
+                        if (!pte || pgprot_val(pte_pgprot(*pte)) == 0 ||
+                            !(pte_val(*pte) & _PAGE_PRESENT)) {
                                 addr[i] = 0;
                                 break;
                         }
diff --git a/arch/x86/mm/pageattr.c b/arch/x86/mm/pageattr.c
index 1cc6607eacb0..16ce841f08d6 100644
--- a/arch/x86/mm/pageattr.c
+++ b/arch/x86/mm/pageattr.c
@@ -16,6 +16,17 @@
 #include <asm/uaccess.h>
 #include <asm/pgalloc.h>
 
+/*
+ * The current flushing context - we pass it instead of 5 arguments:
+ */
+struct cpa_data {
+        unsigned long   vaddr;
+        pgprot_t        mask_set;
+        pgprot_t        mask_clr;
+        int             numpages;
+        int             flushtlb;
+};
+
 static inline int
 within(unsigned long addr, unsigned long start, unsigned long end)
 {
@@ -52,21 +63,23 @@ void clflush_cache_range(void *vaddr, unsigned int size)
 
 static void __cpa_flush_all(void *arg)
 {
+        unsigned long cache = (unsigned long)arg;
+
         /*
          * Flush all to work around Errata in early athlons regarding
          * large page flushing.
          */
         __flush_tlb_all();
 
-        if (boot_cpu_data.x86_model >= 4)
+        if (cache && boot_cpu_data.x86_model >= 4)
                 wbinvd();
 }
 
-static void cpa_flush_all(void)
+static void cpa_flush_all(unsigned long cache)
 {
         BUG_ON(irqs_disabled());
 
-        on_each_cpu(__cpa_flush_all, NULL, 1, 1);
+        on_each_cpu(__cpa_flush_all, (void *) cache, 1, 1);
 }
 
 static void __cpa_flush_range(void *arg)
@@ -79,7 +92,7 @@ static void __cpa_flush_range(void *arg)
         __flush_tlb_all();
 }
 
-static void cpa_flush_range(unsigned long start, int numpages)
+static void cpa_flush_range(unsigned long start, int numpages, int cache)
 {
         unsigned int i, level;
         unsigned long addr;
@@ -89,6 +102,9 @@ static void cpa_flush_range(unsigned long start, int numpages)
 
         on_each_cpu(__cpa_flush_range, NULL, 1, 1);
 
+        if (!cache)
+                return;
+
         /*
          * We only need to flush on one CPU,
          * clflush is a MESI-coherent instruction that
@@ -101,11 +117,27 @@ static void cpa_flush_range(unsigned long start, int numpages)
                 /*
                  * Only flush present addresses:
                  */
-                if (pte && pte_present(*pte))
+                if (pte && (pte_val(*pte) & _PAGE_PRESENT))
                         clflush_cache_range((void *) addr, PAGE_SIZE);
         }
 }
 
+#define HIGH_MAP_START  __START_KERNEL_map
+#define HIGH_MAP_END    (__START_KERNEL_map + KERNEL_TEXT_SIZE)
+
+
+/*
+ * Converts a virtual address to a X86-64 highmap address
+ */
+static unsigned long virt_to_highmap(void *address)
+{
+#ifdef CONFIG_X86_64
+        return __pa((unsigned long)address) + HIGH_MAP_START - phys_base;
+#else
+        return (unsigned long)address;
+#endif
+}
+
 /*
  * Certain areas of memory on x86 require very specific protection flags,
  * for example the BIOS area or kernel text. Callers don't always get this
@@ -129,12 +161,24 @@ static inline pgprot_t static_protections(pgprot_t prot, unsigned long address)
          */
         if (within(address, (unsigned long)_text, (unsigned long)_etext))
                 pgprot_val(forbidden) |= _PAGE_NX;
+        /*
+         * Do the same for the x86-64 high kernel mapping
+         */
+        if (within(address, virt_to_highmap(_text), virt_to_highmap(_etext)))
+                pgprot_val(forbidden) |= _PAGE_NX;
+
 
 #ifdef CONFIG_DEBUG_RODATA
         /* The .rodata section needs to be read-only */
         if (within(address, (unsigned long)__start_rodata,
                                 (unsigned long)__end_rodata))
                 pgprot_val(forbidden) |= _PAGE_RW;
+        /*
+         * Do the same for the x86-64 high kernel mapping
+         */
+        if (within(address, virt_to_highmap(__start_rodata),
+                                virt_to_highmap(__end_rodata)))
+                pgprot_val(forbidden) |= _PAGE_RW;
 #endif
 
         prot = __pgprot(pgprot_val(prot) & ~pgprot_val(forbidden));
@@ -142,6 +186,14 @@ static inline pgprot_t static_protections(pgprot_t prot, unsigned long address)
         return prot;
 }
 
+/*
+ * Lookup the page table entry for a virtual address. Return a pointer
+ * to the entry and the level of the mapping.
+ *
+ * Note: We return pud and pmd either when the entry is marked large
+ * or when the present bit is not set. Otherwise we would return a
+ * pointer to a nonexisting mapping.
+ */
 pte_t *lookup_address(unsigned long address, int *level)
 {
         pgd_t *pgd = pgd_offset_k(address);
@@ -152,21 +204,31 @@ pte_t *lookup_address(unsigned long address, int *level)
 
         if (pgd_none(*pgd))
                 return NULL;
+
         pud = pud_offset(pgd, address);
         if (pud_none(*pud))
                 return NULL;
+
+        *level = PG_LEVEL_1G;
+        if (pud_large(*pud) || !pud_present(*pud))
+                return (pte_t *)pud;
+
         pmd = pmd_offset(pud, address);
         if (pmd_none(*pmd))
                 return NULL;
 
         *level = PG_LEVEL_2M;
-        if (pmd_large(*pmd))
+        if (pmd_large(*pmd) || !pmd_present(*pmd))
                 return (pte_t *)pmd;
 
         *level = PG_LEVEL_4K;
+
         return pte_offset_kernel(pmd, address);
 }
 
+/*
+ * Set the new pmd in all the pgds we know about:
+ */
 static void __set_pmd_pte(pte_t *kpte, unsigned long address, pte_t pte)
 {
         /* change init_mm */
@@ -189,18 +251,114 @@ static void __set_pmd_pte(pte_t *kpte, unsigned long address, pte_t pte)
 #endif
 }
 
+static int
+try_preserve_large_page(pte_t *kpte, unsigned long address,
+                        struct cpa_data *cpa)
+{
+        unsigned long nextpage_addr, numpages, pmask, psize, flags;
+        pte_t new_pte, old_pte, *tmp;
+        pgprot_t old_prot, new_prot;
+        int level, do_split = 1;
+
+        /*
+         * An Athlon 64 X2 showed hard hangs if we tried to preserve
+         * largepages and changed the PSE entry from RW to RO.
+         *
+         * As AMD CPUs have a long series of erratas in this area,
+         * (and none of the known ones seem to explain this hang),
+         * disable this code until the hang can be debugged:
+         */
+        if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
+                return 1;
+
+        spin_lock_irqsave(&pgd_lock, flags);
+        /*
+         * Check for races, another CPU might have split this page
+         * up already:
+         */
+        tmp = lookup_address(address, &level);
+        if (tmp != kpte)
+                goto out_unlock;
+
+        switch (level) {
+        case PG_LEVEL_2M:
+                psize = PMD_PAGE_SIZE;
+                pmask = PMD_PAGE_MASK;
+                break;
+#ifdef CONFIG_X86_64
+        case PG_LEVEL_1G:
+                psize = PMD_PAGE_SIZE;
+                pmask = PMD_PAGE_MASK;
+                break;
+#endif
+        default:
+                do_split = -EINVAL;
+                goto out_unlock;
+        }
+
+        /*
+         * Calculate the number of pages, which fit into this large
+         * page starting at address:
+         */
+        nextpage_addr = (address + psize) & pmask;
+        numpages = (nextpage_addr - address) >> PAGE_SHIFT;
+        if (numpages < cpa->numpages)
+                cpa->numpages = numpages;
+
+        /*
+         * We are safe now. Check whether the new pgprot is the same:
+         */
+        old_pte = *kpte;
+        old_prot = new_prot = pte_pgprot(old_pte);
+
+        pgprot_val(new_prot) &= ~pgprot_val(cpa->mask_clr);
+        pgprot_val(new_prot) |= pgprot_val(cpa->mask_set);
+        new_prot = static_protections(new_prot, address);
+
+        /*
+         * If there are no changes, return. maxpages has been updated
+         * above:
+         */
+        if (pgprot_val(new_prot) == pgprot_val(old_prot)) {
+                do_split = 0;
+                goto out_unlock;
+        }
+
+        /*
+         * We need to change the attributes. Check, whether we can
+         * change the large page in one go. We request a split, when
+         * the address is not aligned and the number of pages is
+         * smaller than the number of pages in the large page. Note
+         * that we limited the number of possible pages already to
+         * the number of pages in the large page.
+         */
+        if (address == (nextpage_addr - psize) && cpa->numpages == numpages) {
+                /*
+                 * The address is aligned and the number of pages
+                 * covers the full page.
+                 */
+                new_pte = pfn_pte(pte_pfn(old_pte), canon_pgprot(new_prot));
+                __set_pmd_pte(kpte, address, new_pte);
+                cpa->flushtlb = 1;
+                do_split = 0;
+        }
+
+out_unlock:
+        spin_unlock_irqrestore(&pgd_lock, flags);
+
+        return do_split;
+}
+
 static int split_large_page(pte_t *kpte, unsigned long address)
 {
-        pgprot_t ref_prot = pte_pgprot(pte_clrhuge(*kpte));
+        unsigned long flags, pfn, pfninc = 1;
         gfp_t gfp_flags = GFP_KERNEL;
-        unsigned long flags;
-        unsigned long addr;
+        unsigned int i, level;
         pte_t *pbase, *tmp;
+        pgprot_t ref_prot;
         struct page *base;
-        unsigned int i, level;
 
 #ifdef CONFIG_DEBUG_PAGEALLOC
-        gfp_flags = __GFP_HIGH | __GFP_NOFAIL | __GFP_NOWARN;
         gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
 #endif
         base = alloc_pages(gfp_flags, 0);
@@ -213,30 +371,41 @@ static int split_large_page(pte_t *kpte, unsigned long address)
          * up for us already:
          */
         tmp = lookup_address(address, &level);
-        if (tmp != kpte) {
-                WARN_ON_ONCE(1);
+        if (tmp != kpte)
                 goto out_unlock;
-        }
 
-        address = __pa(address);
-        addr = address & LARGE_PAGE_MASK;
         pbase = (pte_t *)page_address(base);
 #ifdef CONFIG_X86_32
         paravirt_alloc_pt(&init_mm, page_to_pfn(base));
 #endif
+        ref_prot = pte_pgprot(pte_clrhuge(*kpte));
 
-        pgprot_val(ref_prot) &= ~_PAGE_NX;
-        for (i = 0; i < PTRS_PER_PTE; i++, addr += PAGE_SIZE)
-                set_pte(&pbase[i], pfn_pte(addr >> PAGE_SHIFT, ref_prot));
+#ifdef CONFIG_X86_64
+        if (level == PG_LEVEL_1G) {
+                pfninc = PMD_PAGE_SIZE >> PAGE_SHIFT;
+                pgprot_val(ref_prot) |= _PAGE_PSE;
+        }
+#endif
 
         /*
-         * Install the new, split up pagetable. Important detail here:
+         * Get the target pfn from the original entry:
+         */
+        pfn = pte_pfn(*kpte);
+        for (i = 0; i < PTRS_PER_PTE; i++, pfn += pfninc)
+                set_pte(&pbase[i], pfn_pte(pfn, ref_prot));
+
+        /*
+         * Install the new, split up pagetable. Important details here:
          *
          * On Intel the NX bit of all levels must be cleared to make a
          * page executable. See section 4.13.2 of Intel 64 and IA-32
          * Architectures Software Developer's Manual).
+         *
+         * Mark the entry present. The current mapping might be
+         * set to not present, which we preserved above.
          */
         ref_prot = pte_pgprot(pte_mkexec(pte_clrhuge(*kpte)));
+        pgprot_val(ref_prot) |= _PAGE_PRESENT;
         __set_pmd_pte(kpte, address, mk_pte(base, ref_prot));
         base = NULL;
 
@@ -249,18 +418,12 @@ out_unlock:
         return 0;
 }
 
-static int
-__change_page_attr(unsigned long address, unsigned long pfn,
-                   pgprot_t mask_set, pgprot_t mask_clr)
+static int __change_page_attr(unsigned long address, struct cpa_data *cpa)
 {
+        int level, do_split, err;
         struct page *kpte_page;
-        int level, err = 0;
         pte_t *kpte;
 
-#ifdef CONFIG_X86_32
-        BUG_ON(pfn > max_low_pfn);
-#endif
-
 repeat:
         kpte = lookup_address(address, &level);
         if (!kpte)
@@ -271,23 +434,62 @@ repeat:
         BUG_ON(PageCompound(kpte_page));
 
         if (level == PG_LEVEL_4K) {
-                pgprot_t new_prot = pte_pgprot(*kpte);
                 pte_t new_pte, old_pte = *kpte;
+                pgprot_t new_prot = pte_pgprot(old_pte);
+
+                if(!pte_val(old_pte)) {
+                        printk(KERN_WARNING "CPA: called for zero pte. "
+                               "vaddr = %lx cpa->vaddr = %lx\n", address,
+                                cpa->vaddr);
+                        WARN_ON(1);
+                        return -EINVAL;
+                }
 
-                pgprot_val(new_prot) &= ~pgprot_val(mask_clr);
-                pgprot_val(new_prot) |= pgprot_val(mask_set);
+                pgprot_val(new_prot) &= ~pgprot_val(cpa->mask_clr);
+                pgprot_val(new_prot) |= pgprot_val(cpa->mask_set);
 
                 new_prot = static_protections(new_prot, address);
 
-                new_pte = pfn_pte(pfn, canon_pgprot(new_prot));
-                BUG_ON(pte_pfn(new_pte) != pte_pfn(old_pte));
+                /*
+                 * We need to keep the pfn from the existing PTE,
+                 * after all we're only going to change it's attributes
+                 * not the memory it points to
+                 */
+                new_pte = pfn_pte(pte_pfn(old_pte), canon_pgprot(new_prot));
+
+                /*
+                 * Do we really change anything ?
+                 */
+                if (pte_val(old_pte) != pte_val(new_pte)) {
+                        set_pte_atomic(kpte, new_pte);
+                        cpa->flushtlb = 1;
+                }
+                cpa->numpages = 1;
+                return 0;
+        }
+
+        /*
+         * Check, whether we can keep the large page intact
+         * and just change the pte:
+         */
+        do_split = try_preserve_large_page(kpte, address, cpa);
+        /*
+         * When the range fits into the existing large page,
+         * return. cp->numpages and cpa->tlbflush have been updated in
+         * try_large_page:
+         */
+        if (do_split <= 0)
+                return do_split;
 
-                set_pte_atomic(kpte, new_pte);
-        } else {
-                err = split_large_page(kpte, address);
-                if (!err)
-                        goto repeat;
+        /*
+         * We have to split the large page:
+         */
+        err = split_large_page(kpte, address);
+        if (!err) {
+                cpa->flushtlb = 1;
+                goto repeat;
         }
+
         return err;
 }
 
@@ -304,19 +506,14 @@ repeat:
  *
  * Modules and drivers should use the set_memory_* APIs instead.
  */
-
-#define HIGH_MAP_START  __START_KERNEL_map
-#define HIGH_MAP_END    (__START_KERNEL_map + KERNEL_TEXT_SIZE)
-
-static int
-change_page_attr_addr(unsigned long address, pgprot_t mask_set,
-                      pgprot_t mask_clr)
+static int change_page_attr_addr(struct cpa_data *cpa)
 {
-        unsigned long phys_addr = __pa(address);
-        unsigned long pfn = phys_addr >> PAGE_SHIFT;
         int err;
+        unsigned long address = cpa->vaddr;
 
 #ifdef CONFIG_X86_64
+        unsigned long phys_addr = __pa(address);
+
         /*
          * If we are inside the high mapped kernel range, then we
          * fixup the low mapping first. __va() returns the virtual
@@ -326,7 +523,7 @@ change_page_attr_addr(unsigned long address, pgprot_t mask_set,
                 address = (unsigned long) __va(phys_addr);
 #endif
 
-        err = __change_page_attr(address, pfn, mask_set, mask_clr);
+        err = __change_page_attr(address, cpa);
         if (err)
                 return err;
 
@@ -339,42 +536,89 @@ change_page_attr_addr(unsigned long address, pgprot_t mask_set,
                 /*
                  * Calc the high mapping address. See __phys_addr()
                  * for the non obvious details.
+                 *
+                 * Note that NX and other required permissions are
+                 * checked in static_protections().
                  */
                 address = phys_addr + HIGH_MAP_START - phys_base;
-                /* Make sure the kernel mappings stay executable */
-                pgprot_val(mask_clr) |= _PAGE_NX;
 
                 /*
                  * Our high aliases are imprecise, because we check
                  * everything between 0 and KERNEL_TEXT_SIZE, so do
                  * not propagate lookup failures back to users:
                  */
-                __change_page_attr(address, pfn, mask_set, mask_clr);
+                __change_page_attr(address, cpa);
         }
 #endif
         return err;
 }
 
-static int __change_page_attr_set_clr(unsigned long addr, int numpages,
-                                      pgprot_t mask_set, pgprot_t mask_clr)
+static int __change_page_attr_set_clr(struct cpa_data *cpa)
 {
-        unsigned int i;
-        int ret;
+        int ret, numpages = cpa->numpages;
 
-        for (i = 0; i < numpages ; i++, addr += PAGE_SIZE) {
-                ret = change_page_attr_addr(addr, mask_set, mask_clr);
+        while (numpages) {
+                /*
+                 * Store the remaining nr of pages for the large page
+                 * preservation check.
+                 */
+                cpa->numpages = numpages;
+                ret = change_page_attr_addr(cpa);
                 if (ret)
                         return ret;
-        }
 
+                /*
+                 * Adjust the number of pages with the result of the
+                 * CPA operation. Either a large page has been
+                 * preserved or a single page update happened.
+                 */
+                BUG_ON(cpa->numpages > numpages);
+                numpages -= cpa->numpages;
+                cpa->vaddr += cpa->numpages * PAGE_SIZE;
+        }
         return 0;
 }
 
+static inline int cache_attr(pgprot_t attr)
+{
+        return pgprot_val(attr) &
+                (_PAGE_PAT | _PAGE_PAT_LARGE | _PAGE_PWT | _PAGE_PCD);
+}
+
 static int change_page_attr_set_clr(unsigned long addr, int numpages,
                                     pgprot_t mask_set, pgprot_t mask_clr)
 {
-        int ret = __change_page_attr_set_clr(addr, numpages, mask_set,
-                                             mask_clr);
+        struct cpa_data cpa;
+        int ret, cache;
+
+        /*
+         * Check, if we are requested to change a not supported
+         * feature:
+         */
+        mask_set = canon_pgprot(mask_set);
+        mask_clr = canon_pgprot(mask_clr);
+        if (!pgprot_val(mask_set) && !pgprot_val(mask_clr))
+                return 0;
+
+        cpa.vaddr = addr;
+        cpa.numpages = numpages;
+        cpa.mask_set = mask_set;
+        cpa.mask_clr = mask_clr;
+        cpa.flushtlb = 0;
+
+        ret = __change_page_attr_set_clr(&cpa);
+
+        /*
+         * Check whether we really changed something:
+         */
+        if (!cpa.flushtlb)
+                return ret;
+
+        /*
+         * No need to flush, when we did not set any of the caching
+         * attributes:
+         */
+        cache = cache_attr(mask_set);
 
         /*
          * On success we use clflush, when the CPU supports it to
@@ -383,9 +627,9 @@ static int change_page_attr_set_clr(unsigned long addr, int numpages,
          * wbindv):
          */
         if (!ret && cpu_has_clflush)
-                cpa_flush_range(addr, numpages);
+                cpa_flush_range(addr, numpages, cache);
         else
-                cpa_flush_all();
+                cpa_flush_all(cache);
 
         return ret;
 }
@@ -399,8 +643,7 @@ static inline int change_page_attr_set(unsigned long addr, int numpages,
 static inline int change_page_attr_clear(unsigned long addr, int numpages,
                                          pgprot_t mask)
 {
-        return __change_page_attr_set_clr(addr, numpages, __pgprot(0), mask);
-
+        return change_page_attr_set_clr(addr, numpages, __pgprot(0), mask);
 }
 
 int set_memory_uc(unsigned long addr, int numpages)
@@ -490,37 +733,26 @@ int set_pages_rw(struct page *page, int numpages)
         return set_memory_rw(addr, numpages);
 }
 
-
-#if defined(CONFIG_DEBUG_PAGEALLOC) || defined(CONFIG_CPA_DEBUG)
-static inline int __change_page_attr_set(unsigned long addr, int numpages,
-                                         pgprot_t mask)
-{
-        return __change_page_attr_set_clr(addr, numpages, mask, __pgprot(0));
-}
-
-static inline int __change_page_attr_clear(unsigned long addr, int numpages,
-                                           pgprot_t mask)
-{
-        return __change_page_attr_set_clr(addr, numpages, __pgprot(0), mask);
-}
-#endif
-
 #ifdef CONFIG_DEBUG_PAGEALLOC
 
 static int __set_pages_p(struct page *page, int numpages)
 {
-        unsigned long addr = (unsigned long)page_address(page);
+        struct cpa_data cpa = { .vaddr = (unsigned long) page_address(page),
+                                .numpages = numpages,
+                                .mask_set = __pgprot(_PAGE_PRESENT | _PAGE_RW),
+                                .mask_clr = __pgprot(0)};
 
-        return __change_page_attr_set(addr, numpages,
-                                      __pgprot(_PAGE_PRESENT | _PAGE_RW));
+        return __change_page_attr_set_clr(&cpa);
 }
 
 static int __set_pages_np(struct page *page, int numpages)
 {
-        unsigned long addr = (unsigned long)page_address(page);
+        struct cpa_data cpa = { .vaddr = (unsigned long) page_address(page),
+                                .numpages = numpages,
+                                .mask_set = __pgprot(0),
+                                .mask_clr = __pgprot(_PAGE_PRESENT | _PAGE_RW)};
 
-        return __change_page_attr_clear(addr, numpages,
-                                        __pgprot(_PAGE_PRESENT));
+        return __change_page_attr_set_clr(&cpa);
 }
 
 void kernel_map_pages(struct page *page, int numpages, int enable)
diff --git a/arch/x86/mm/pgtable_32.c b/arch/x86/mm/pgtable_32.c
index 2ae5999a795a..6c1914622a88 100644
--- a/arch/x86/mm/pgtable_32.c
+++ b/arch/x86/mm/pgtable_32.c
@@ -219,50 +219,39 @@ static inline void pgd_list_del(pgd_t *pgd)
         list_del(&page->lru);
 }
 
+#define UNSHARED_PTRS_PER_PGD                           \
+        (SHARED_KERNEL_PMD ? USER_PTRS_PER_PGD : PTRS_PER_PGD)
 
-
-#if (PTRS_PER_PMD == 1)
-/* Non-PAE pgd constructor */
-static void pgd_ctor(void *pgd)
+static void pgd_ctor(void *p)
 {
+        pgd_t *pgd = p;
         unsigned long flags;
 
-        /* !PAE, no pagetable sharing */
+        /* Clear usermode parts of PGD */
         memset(pgd, 0, USER_PTRS_PER_PGD*sizeof(pgd_t));
 
         spin_lock_irqsave(&pgd_lock, flags);
 
-        /* must happen under lock */
-        clone_pgd_range((pgd_t *)pgd + USER_PTRS_PER_PGD,
-                        swapper_pg_dir + USER_PTRS_PER_PGD,
-                        KERNEL_PGD_PTRS);
-        paravirt_alloc_pd_clone(__pa(pgd) >> PAGE_SHIFT,
-                                __pa(swapper_pg_dir) >> PAGE_SHIFT,
-                                USER_PTRS_PER_PGD,
-                                KERNEL_PGD_PTRS);
-        pgd_list_add(pgd);
-        spin_unlock_irqrestore(&pgd_lock, flags);
-}
-#else  /* PTRS_PER_PMD > 1 */
-/* PAE pgd constructor */
-static void pgd_ctor(void *pgd)
-{
-        /* PAE, kernel PMD may be shared */
-
-        if (SHARED_KERNEL_PMD) {
-                clone_pgd_range((pgd_t *)pgd + USER_PTRS_PER_PGD,
+        /* If the pgd points to a shared pagetable level (either the
+           ptes in non-PAE, or shared PMD in PAE), then just copy the
+           references from swapper_pg_dir. */
+        if (PAGETABLE_LEVELS == 2 ||
+            (PAGETABLE_LEVELS == 3 && SHARED_KERNEL_PMD)) {
+                clone_pgd_range(pgd + USER_PTRS_PER_PGD,
                                 swapper_pg_dir + USER_PTRS_PER_PGD,
                                 KERNEL_PGD_PTRS);
-        } else {
-                unsigned long flags;
+                paravirt_alloc_pd_clone(__pa(pgd) >> PAGE_SHIFT,
+                                        __pa(swapper_pg_dir) >> PAGE_SHIFT,
+                                        USER_PTRS_PER_PGD,
+                                        KERNEL_PGD_PTRS);
+        }
 
-                memset(pgd, 0, USER_PTRS_PER_PGD*sizeof(pgd_t));
-                spin_lock_irqsave(&pgd_lock, flags);
+        /* list required to sync kernel mapping updates */
+        if (!SHARED_KERNEL_PMD)
                 pgd_list_add(pgd);
-                spin_unlock_irqrestore(&pgd_lock, flags);
-        }
+
+        spin_unlock_irqrestore(&pgd_lock, flags);
 }
-#endif  /* PTRS_PER_PMD */
 
 static void pgd_dtor(void *pgd)
 {
@@ -276,9 +265,6 @@ static void pgd_dtor(void *pgd)
         spin_unlock_irqrestore(&pgd_lock, flags);
 }
 
-#define UNSHARED_PTRS_PER_PGD                           \
-        (SHARED_KERNEL_PMD ? USER_PTRS_PER_PGD : PTRS_PER_PGD)
-
 #ifdef CONFIG_X86_PAE
 /*
  * Mop up any pmd pages which may still be attached to the pgd.
@@ -286,7 +272,7 @@ static void pgd_dtor(void *pgd)
  * preallocate which never got a corresponding vma will need to be
  * freed manually.
  */
-static void pgd_mop_up_pmds(pgd_t *pgdp)
+static void pgd_mop_up_pmds(struct mm_struct *mm, pgd_t *pgdp)
 {
         int i;
 
@@ -299,7 +285,7 @@ static void pgd_mop_up_pmds(pgd_t *pgdp)
                         pgdp[i] = native_make_pgd(0);
 
                         paravirt_release_pd(pgd_val(pgd) >> PAGE_SHIFT);
-                        pmd_free(pmd);
+                        pmd_free(mm, pmd);
                 }
         }
 }
@@ -327,7 +313,7 @@ static int pgd_prepopulate_pmd(struct mm_struct *mm, pgd_t *pgd)
                 pmd_t *pmd = pmd_alloc_one(mm, addr);
 
                 if (!pmd) {
-                        pgd_mop_up_pmds(pgd);
+                        pgd_mop_up_pmds(mm, pgd);
                         return 0;
                 }
 
@@ -347,7 +333,7 @@ static int pgd_prepopulate_pmd(struct mm_struct *mm, pgd_t *pgd)
         return 1;
 }
 
-static void pgd_mop_up_pmds(pgd_t *pgd)
+static void pgd_mop_up_pmds(struct mm_struct *mm, pgd_t *pgdp)
 {
 }
 #endif  /* CONFIG_X86_PAE */
@@ -366,9 +352,9 @@ pgd_t *pgd_alloc(struct mm_struct *mm)
         return pgd;
 }
 
-void pgd_free(pgd_t *pgd)
+void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 {
-        pgd_mop_up_pmds(pgd);
+        pgd_mop_up_pmds(mm, pgd);
         quicklist_free(0, pgd_dtor, pgd);
 }
 
@@ -376,3 +362,19 @@ void check_pgt_cache(void)
 {
         quicklist_trim(0, pgd_dtor, 25, 16);
 }
+
+void __pte_free_tlb(struct mmu_gather *tlb, struct page *pte)
+{
+        paravirt_release_pt(page_to_pfn(pte));
+        tlb_remove_page(tlb, pte);
+}
+
+#ifdef CONFIG_X86_PAE
+
+void __pmd_free_tlb(struct mmu_gather *tlb, pmd_t *pmd)
+{
+        paravirt_release_pd(__pa(pmd) >> PAGE_SHIFT);
+        tlb_remove_page(tlb, virt_to_page(pmd));
+}
+
+#endif
diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c
index cb63007e20b2..74d30ff33c49 100644
--- a/arch/x86/pci/fixup.c
+++ b/arch/x86/pci/fixup.c
@@ -17,7 +17,7 @@ static void __devinit pci_fixup_i450nx(struct pci_dev *d)
         int pxb, reg;
         u8 busno, suba, subb;
 
-        printk(KERN_WARNING "PCI: Searching for i450NX host bridges on %s\n", pci_name(d));
+        dev_warn(&d->dev, "Searching for i450NX host bridges\n");
         reg = 0xd0;
         for(pxb = 0; pxb < 2; pxb++) {
                 pci_read_config_byte(d, reg++, &busno);
@@ -41,7 +41,7 @@ static void __devinit pci_fixup_i450gx(struct pci_dev *d)
          */
         u8 busno;
         pci_read_config_byte(d, 0x4a, &busno);
-        printk(KERN_INFO "PCI: i440KX/GX host bridge %s: secondary bus %02x\n", pci_name(d), busno);
+        dev_info(&d->dev, "i440KX/GX host bridge; secondary bus %02x\n", busno);
         pci_scan_bus_with_sysdata(busno);
         pcibios_last_bus = -1;
 }
@@ -55,7 +55,7 @@ static void __devinit  pci_fixup_umc_ide(struct pci_dev *d)
          */
         int i;
 
-        printk(KERN_WARNING "PCI: Fixing base address flags for device %s\n", pci_name(d));
+        dev_warn(&d->dev, "Fixing base address flags\n");
         for(i = 0; i < 4; i++)
                 d->resource[i].flags |= PCI_BASE_ADDRESS_SPACE_IO;
 }
@@ -68,7 +68,7 @@ static void __devinit  pci_fixup_ncr53c810(struct pci_dev *d)
          * Fix class to be PCI_CLASS_STORAGE_SCSI
          */
         if (!d->class) {
-                printk(KERN_WARNING "PCI: fixing NCR 53C810 class code for %s\n", pci_name(d));
+                dev_warn(&d->dev, "Fixing NCR 53C810 class code\n");
                 d->class = PCI_CLASS_STORAGE_SCSI << 8;
         }
 }
@@ -80,7 +80,7 @@ static void __devinit  pci_fixup_latency(struct pci_dev *d)
          *  SiS 5597 and 5598 chipsets require latency timer set to
          *  at most 32 to avoid lockups.
          */
-        DBG("PCI: Setting max latency to 32\n");
+        dev_dbg(&d->dev, "Setting max latency to 32\n");
         pcibios_max_latency = 32;
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_5597, pci_fixup_latency);
@@ -138,7 +138,7 @@ static void pci_fixup_via_northbridge_bug(struct pci_dev *d)
 
         pci_read_config_byte(d, where, &v);
         if (v & ~mask) {
-                printk(KERN_WARNING "Disabling VIA memory write queue (PCI ID %04x, rev %02x): [%02x] %02x & %02x -> %02x\n", \
+                dev_warn(&d->dev, "Disabling VIA memory write queue (PCI ID %04x, rev %02x): [%02x] %02x & %02x -> %02x\n", \
                         d->device, d->revision, where, v, mask, v & mask);
                 v &= mask;
                 pci_write_config_byte(d, where, v);
@@ -200,7 +200,7 @@ static void pci_fixup_nforce2(struct pci_dev *dev)
          * Apply fixup if needed, but don't touch disconnect state
          */
         if ((val & 0x00FF0000) != 0x00010000) {
-                printk(KERN_WARNING "PCI: nForce2 C1 Halt Disconnect fixup\n");
+                dev_warn(&dev->dev, "nForce2 C1 Halt Disconnect fixup\n");
                 pci_write_config_dword(dev, 0x6c, (val & 0xFF00FFFF) | 0x00010000);
         }
 }
@@ -348,7 +348,7 @@ static void __devinit pci_fixup_video(struct pci_dev *pdev)
         pci_read_config_word(pdev, PCI_COMMAND, &config);
         if (config & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
                 pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW;
-                printk(KERN_DEBUG "Boot video device is %s\n", pci_name(pdev));
+                dev_printk(KERN_DEBUG, &pdev->dev, "Boot video device\n");
         }
 }
 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_video);
@@ -388,11 +388,11 @@ static void __devinit pci_fixup_msi_k8t_onboard_sound(struct pci_dev *dev)
                 /* verify the change for status output */
                 pci_read_config_byte(dev, 0x50, &val);
                 if (val & 0x40)
-                        printk(KERN_INFO "PCI: Detected MSI K8T Neo2-FIR, "
+                        dev_info(&dev->dev, "Detected MSI K8T Neo2-FIR; "
                                         "can't enable onboard soundcard!\n");
                 else
-                        printk(KERN_INFO "PCI: Detected MSI K8T Neo2-FIR, "
-                                        "enabled onboard soundcard.\n");
+                        dev_info(&dev->dev, "Detected MSI K8T Neo2-FIR; "
+                                        "enabled onboard soundcard\n");
         }
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237,
diff --git a/arch/x86/pci/i386.c b/arch/x86/pci/i386.c
index 42ba0e2da1a0..103b9dff1213 100644
--- a/arch/x86/pci/i386.c
+++ b/arch/x86/pci/i386.c
@@ -72,7 +72,7 @@ pcibios_align_resource(void *data, struct resource *res,
                 }
         }
 }
-
+EXPORT_SYMBOL(pcibios_align_resource);
 
 /*
  *  Handle resources of PCI devices.  If the world were perfect, we could
diff --git a/arch/x86/pci/numa.c b/arch/x86/pci/numa.c
index f5f165f69e0c..55270c26237c 100644
--- a/arch/x86/pci/numa.c
+++ b/arch/x86/pci/numa.c
@@ -5,36 +5,62 @@
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/nodemask.h>
+#include <mach_apic.h>
 #include "pci.h"
 
+#define XQUAD_PORTIO_BASE 0xfe400000
+#define XQUAD_PORTIO_QUAD 0x40000  /* 256k per quad. */
+
 #define BUS2QUAD(global) (mp_bus_id_to_node[global])
 #define BUS2LOCAL(global) (mp_bus_id_to_local[global])
 #define QUADLOCAL2BUS(quad,local) (quad_local_to_mp_bus_id[quad][local])
 
+extern void *xquad_portio;    /* Where the IO area was mapped */
+#define XQUAD_PORT_ADDR(port, quad) (xquad_portio + (XQUAD_PORTIO_QUAD*quad) + port)
+
 #define PCI_CONF1_MQ_ADDRESS(bus, devfn, reg) \
         (0x80000000 | (BUS2LOCAL(bus) << 16) | (devfn << 8) | (reg & ~3))
 
+static void write_cf8(unsigned bus, unsigned devfn, unsigned reg)
+{
+        unsigned val = PCI_CONF1_MQ_ADDRESS(bus, devfn, reg);
+        if (xquad_portio)
+                writel(val, XQUAD_PORT_ADDR(0xcf8, BUS2QUAD(bus)));
+        else
+                outl(val, 0xCF8);
+}
+
 static int pci_conf1_mq_read(unsigned int seg, unsigned int bus,
                              unsigned int devfn, int reg, int len, u32 *value)
 {
         unsigned long flags;
+        void *adr __iomem = XQUAD_PORT_ADDR(0xcfc, BUS2QUAD(bus));
 
         if (!value || (bus >= MAX_MP_BUSSES) || (devfn > 255) || (reg > 255))
                 return -EINVAL;
 
         spin_lock_irqsave(&pci_config_lock, flags);
 
-        outl_quad(PCI_CONF1_MQ_ADDRESS(bus, devfn, reg), 0xCF8, BUS2QUAD(bus));
+        write_cf8(bus, devfn, reg);
 
         switch (len) {
         case 1:
-                *value = inb_quad(0xCFC + (reg & 3), BUS2QUAD(bus));
+                if (xquad_portio)
+                        *value = readb(adr + (reg & 3));
+                else
+                        *value = inb(0xCFC + (reg & 3));
                 break;
         case 2:
-                *value = inw_quad(0xCFC + (reg & 2), BUS2QUAD(bus));
+                if (xquad_portio)
+                        *value = readw(adr + (reg & 2));
+                else
+                        *value = inw(0xCFC + (reg & 2));
                 break;
         case 4:
-                *value = inl_quad(0xCFC, BUS2QUAD(bus));
+                if (xquad_portio)
+                        *value = readl(adr);
+                else
+                        *value = inl(0xCFC);
                 break;
         }
 
@@ -47,23 +73,33 @@ static int pci_conf1_mq_write(unsigned int seg, unsigned int bus,
                               unsigned int devfn, int reg, int len, u32 value)
 {
         unsigned long flags;
+        void *adr __iomem = XQUAD_PORT_ADDR(0xcfc, BUS2QUAD(bus));
 
         if ((bus >= MAX_MP_BUSSES) || (devfn > 255) || (reg > 255)) 
                 return -EINVAL;
 
         spin_lock_irqsave(&pci_config_lock, flags);
 
-        outl_quad(PCI_CONF1_MQ_ADDRESS(bus, devfn, reg), 0xCF8, BUS2QUAD(bus));
+        write_cf8(bus, devfn, reg);
 
         switch (len) {
         case 1:
-                outb_quad((u8)value, 0xCFC + (reg & 3), BUS2QUAD(bus));
+                if (xquad_portio)
+                        writeb(value, adr + (reg & 3));
+                else
+                        outb((u8)value, 0xCFC + (reg & 3));
                 break;
         case 2:
-                outw_quad((u16)value, 0xCFC + (reg & 2), BUS2QUAD(bus));
+                if (xquad_portio)
+                        writew(value, adr + (reg & 2));
+                else
+                        outw((u16)value, 0xCFC + (reg & 2));
                 break;
         case 4:
-                outl_quad((u32)value, 0xCFC, BUS2QUAD(bus));
+                if (xquad_portio)
+                        writel(value, adr + reg);
+                else
+                        outl((u32)value, 0xCFC);
                 break;
         }
 
diff --git a/arch/xtensa/Kconfig b/arch/xtensa/Kconfig
index d3cb3d6af4c8..5d5546ce88fe 100644
--- a/arch/xtensa/Kconfig
+++ b/arch/xtensa/Kconfig
@@ -174,11 +174,6 @@ config PCI
           your box. Other bus systems are ISA, EISA, MicroChannel (MCA) or
           VESA. If you have PCI, say Y, otherwise N.
 
-          The PCI-HOWTO, available from
-          <http://www.linuxdoc.org/docs.html#howto>, contains valuable
-          information about which PCI hardware does work under Linux and which
-          doesn't
-
 source "drivers/pci/Kconfig"
 
 config HOTPLUG
@@ -251,8 +246,6 @@ config EMBEDDED_RAMDISK_IMAGE
           provide one yourself.
 endmenu
 
-source "kernel/Kconfig.instrumentation"
-
 source "arch/xtensa/Kconfig.debug"
 
 source "security/Kconfig"