Merge branch 'for-linus' of git://git.linaro.org/people/rmk/linux-arm

Pull ARM updates from Russell King:
 "This is the first chunk of ARM updates for this merge window.
  Conflicts are expected in two files - asm/timex.h and
  mach-integrator/integrator_cp.c.  Nothing particularly stands out more
  than anything else.

  Most of the growth is down to the opcodes stuff from Dave Martin,
  which is countered by Rob's patches to use more of the asm-generic
  headers on ARM."

(A few more conflicts grew since then, but it all looked fairly trivial)

* 'for-linus' of git://git.linaro.org/people/rmk/linux-arm: (44 commits)
  ARM: 7548/1: include linux/sched.h in syscall.h
  ARM: 7541/1: Add ARM ERRATA 775420 workaround
  ARM: ensure vm_struct has its phys_addr member filled in
  ARM: 7540/1: kexec: Check segment memory addresses
  ARM: 7539/1: kexec: scan for dtb magic in segments
  ARM: 7538/1: delay: add registration mechanism for delay timer sources
  ARM: 7536/1: smp: Formalize an IPI for wakeup
  ARM: 7525/1: ptrace: use updated syscall number for syscall auditing
  ARM: 7524/1: support syscall tracing
  ARM: 7519/1: integrator: convert platform devices to Device Tree
  ARM: 7518/1: integrator: convert AMBA devices to device tree
  ARM: 7517/1: integrator: initial device tree support
  ARM: 7516/1: plat-versatile: add DT support to FPGA IRQ
  ARM: 7515/1: integrator: check PL010 base address from resource
  ARM: 7514/1: integrator: call common init function from machine
  ARM: 7522/1: arch_timers: register a time/cycle counter
  ARM: 7523/1: arch_timers: enable the use of the virtual timer
  ARM: 7531/1: mark kernelmode mem{cpy,set} non-experimental
  ARM: 7520/1: Build dtb files in all target
  ARM: Fix build warning in arch/arm/mm/alignment.c
  ...

14 files changed, 600 insertions, 371 deletions

diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile
index d81f3a6d9ad8..5dfef9d97ed9 100644
--- a/arch/arm/kernel/Makefile
+++ b/arch/arm/kernel/Makefile
@@ -19,7 +19,9 @@ obj-y		:= elf.o entry-armv.o entry-common.o irq.o opcodes.o \
                    process.o ptrace.o return_address.o sched_clock.o \
                    setup.o signal.o stacktrace.o sys_arm.o time.o traps.o
 
-obj-$(CONFIG_DEPRECATED_PARAM_STRUCT) += compat.o
+obj-$(CONFIG_ATAGS)             += atags_parse.o
+obj-$(CONFIG_ATAGS_PROC)        += atags_proc.o
+obj-$(CONFIG_DEPRECATED_PARAM_STRUCT) += atags_compat.o
 
 obj-$(CONFIG_OC_ETM)            += etm.o
 obj-$(CONFIG_CPU_IDLE)          += cpuidle.o
@@ -51,7 +53,6 @@ test-kprobes-objs		+= kprobes-test-thumb.o
 else
 test-kprobes-objs               += kprobes-test-arm.o
 endif
-obj-$(CONFIG_ATAGS_PROC)        += atags.o
 obj-$(CONFIG_OABI_COMPAT)       += sys_oabi-compat.o
 obj-$(CONFIG_ARM_THUMBEE)       += thumbee.o
 obj-$(CONFIG_KGDB)              += kgdb.o
diff --git a/arch/arm/kernel/arch_timer.c b/arch/arm/kernel/arch_timer.c
index cf258807160d..c8ef20747ee7 100644
--- a/arch/arm/kernel/arch_timer.c
+++ b/arch/arm/kernel/arch_timer.c
@@ -21,18 +21,28 @@
 #include <linux/io.h>
 
 #include <asm/cputype.h>
+#include <asm/delay.h>
 #include <asm/localtimer.h>
 #include <asm/arch_timer.h>
 #include <asm/system_info.h>
 #include <asm/sched_clock.h>
 
 static unsigned long arch_timer_rate;
-static int arch_timer_ppi;
-static int arch_timer_ppi2;
+
+enum ppi_nr {
+        PHYS_SECURE_PPI,
+        PHYS_NONSECURE_PPI,
+        VIRT_PPI,
+        HYP_PPI,
+        MAX_TIMER_PPI
+};
+
+static int arch_timer_ppi[MAX_TIMER_PPI];
 
 static struct clock_event_device __percpu **arch_timer_evt;
+static struct delay_timer arch_delay_timer;
 
-extern void init_current_timer_delay(unsigned long freq);
+static bool arch_timer_use_virtual = true;
 
 /*
  * Architected system timer support.
@@ -46,50 +56,104 @@ extern void init_current_timer_delay(unsigned long freq);
 #define ARCH_TIMER_REG_FREQ             1
 #define ARCH_TIMER_REG_TVAL             2
 
-static void arch_timer_reg_write(int reg, u32 val)
+#define ARCH_TIMER_PHYS_ACCESS          0
+#define ARCH_TIMER_VIRT_ACCESS          1
+
+/*
+ * These register accessors are marked inline so the compiler can
+ * nicely work out which register we want, and chuck away the rest of
+ * the code. At least it does so with a recent GCC (4.6.3).
+ */
+static inline void arch_timer_reg_write(const int access, const int reg, u32 val)
 {
-        switch (reg) {
-        case ARCH_TIMER_REG_CTRL:
-                asm volatile("mcr p15, 0, %0, c14, c2, 1" : : "r" (val));
-                break;
-        case ARCH_TIMER_REG_TVAL:
-                asm volatile("mcr p15, 0, %0, c14, c2, 0" : : "r" (val));
-                break;
+        if (access == ARCH_TIMER_PHYS_ACCESS) {
+                switch (reg) {
+                case ARCH_TIMER_REG_CTRL:
+                        asm volatile("mcr p15, 0, %0, c14, c2, 1" : : "r" (val));
+                        break;
+                case ARCH_TIMER_REG_TVAL:
+                        asm volatile("mcr p15, 0, %0, c14, c2, 0" : : "r" (val));
+                        break;
+                }
+        }
+
+        if (access == ARCH_TIMER_VIRT_ACCESS) {
+                switch (reg) {
+                case ARCH_TIMER_REG_CTRL:
+                        asm volatile("mcr p15, 0, %0, c14, c3, 1" : : "r" (val));
+                        break;
+                case ARCH_TIMER_REG_TVAL:
+                        asm volatile("mcr p15, 0, %0, c14, c3, 0" : : "r" (val));
+                        break;
+                }
         }
 
         isb();
 }
 
-static u32 arch_timer_reg_read(int reg)
+static inline u32 arch_timer_reg_read(const int access, const int reg)
 {
-        u32 val;
+        u32 val = 0;
+
+        if (access == ARCH_TIMER_PHYS_ACCESS) {
+                switch (reg) {
+                case ARCH_TIMER_REG_CTRL:
+                        asm volatile("mrc p15, 0, %0, c14, c2, 1" : "=r" (val));
+                        break;
+                case ARCH_TIMER_REG_TVAL:
+                        asm volatile("mrc p15, 0, %0, c14, c2, 0" : "=r" (val));
+                        break;
+                case ARCH_TIMER_REG_FREQ:
+                        asm volatile("mrc p15, 0, %0, c14, c0, 0" : "=r" (val));
+                        break;
+                }
+        }
 
-        switch (reg) {
-        case ARCH_TIMER_REG_CTRL:
-                asm volatile("mrc p15, 0, %0, c14, c2, 1" : "=r" (val));
-                break;
-        case ARCH_TIMER_REG_FREQ:
-                asm volatile("mrc p15, 0, %0, c14, c0, 0" : "=r" (val));
-                break;
-        case ARCH_TIMER_REG_TVAL:
-                asm volatile("mrc p15, 0, %0, c14, c2, 0" : "=r" (val));
-                break;
-        default:
-                BUG();
+        if (access == ARCH_TIMER_VIRT_ACCESS) {
+                switch (reg) {
+                case ARCH_TIMER_REG_CTRL:
+                        asm volatile("mrc p15, 0, %0, c14, c3, 1" : "=r" (val));
+                        break;
+                case ARCH_TIMER_REG_TVAL:
+                        asm volatile("mrc p15, 0, %0, c14, c3, 0" : "=r" (val));
+                        break;
+                }
         }
 
         return val;
 }
 
-static irqreturn_t arch_timer_handler(int irq, void *dev_id)
+static inline cycle_t arch_timer_counter_read(const int access)
 {
-        struct clock_event_device *evt = *(struct clock_event_device **)dev_id;
-        unsigned long ctrl;
+        cycle_t cval = 0;
+
+        if (access == ARCH_TIMER_PHYS_ACCESS)
+                asm volatile("mrrc p15, 0, %Q0, %R0, c14" : "=r" (cval));
+
+        if (access == ARCH_TIMER_VIRT_ACCESS)
+                asm volatile("mrrc p15, 1, %Q0, %R0, c14" : "=r" (cval));
+
+        return cval;
+}
+
+static inline cycle_t arch_counter_get_cntpct(void)
+{
+        return arch_timer_counter_read(ARCH_TIMER_PHYS_ACCESS);
+}
 
-        ctrl = arch_timer_reg_read(ARCH_TIMER_REG_CTRL);
+static inline cycle_t arch_counter_get_cntvct(void)
+{
+        return arch_timer_counter_read(ARCH_TIMER_VIRT_ACCESS);
+}
+
+static irqreturn_t inline timer_handler(const int access,
+                                        struct clock_event_device *evt)
+{
+        unsigned long ctrl;
+        ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL);
         if (ctrl & ARCH_TIMER_CTRL_IT_STAT) {
                 ctrl |= ARCH_TIMER_CTRL_IT_MASK;
-                arch_timer_reg_write(ARCH_TIMER_REG_CTRL, ctrl);
+                arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl);
                 evt->event_handler(evt);
                 return IRQ_HANDLED;
         }
@@ -97,63 +161,100 @@ static irqreturn_t arch_timer_handler(int irq, void *dev_id)
         return IRQ_NONE;
 }
 
-static void arch_timer_disable(void)
+static irqreturn_t arch_timer_handler_virt(int irq, void *dev_id)
 {
-        unsigned long ctrl;
+        struct clock_event_device *evt = *(struct clock_event_device **)dev_id;
 
-        ctrl = arch_timer_reg_read(ARCH_TIMER_REG_CTRL);
-        ctrl &= ~ARCH_TIMER_CTRL_ENABLE;
-        arch_timer_reg_write(ARCH_TIMER_REG_CTRL, ctrl);
+        return timer_handler(ARCH_TIMER_VIRT_ACCESS, evt);
 }
 
-static void arch_timer_set_mode(enum clock_event_mode mode,
-                                struct clock_event_device *clk)
+static irqreturn_t arch_timer_handler_phys(int irq, void *dev_id)
 {
+        struct clock_event_device *evt = *(struct clock_event_device **)dev_id;
+
+        return timer_handler(ARCH_TIMER_PHYS_ACCESS, evt);
+}
+
+static inline void timer_set_mode(const int access, int mode)
+{
+        unsigned long ctrl;
         switch (mode) {
         case CLOCK_EVT_MODE_UNUSED:
         case CLOCK_EVT_MODE_SHUTDOWN:
-                arch_timer_disable();
+                ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL);
+                ctrl &= ~ARCH_TIMER_CTRL_ENABLE;
+                arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl);
                 break;
         default:
                 break;
         }
 }
 
-static int arch_timer_set_next_event(unsigned long evt,
-                                     struct clock_event_device *unused)
+static void arch_timer_set_mode_virt(enum clock_event_mode mode,
+                                     struct clock_event_device *clk)
 {
-        unsigned long ctrl;
+        timer_set_mode(ARCH_TIMER_VIRT_ACCESS, mode);
+}
 
-        ctrl = arch_timer_reg_read(ARCH_TIMER_REG_CTRL);
+static void arch_timer_set_mode_phys(enum clock_event_mode mode,
+                                     struct clock_event_device *clk)
+{
+        timer_set_mode(ARCH_TIMER_PHYS_ACCESS, mode);
+}
+
+static inline void set_next_event(const int access, unsigned long evt)
+{
+        unsigned long ctrl;
+        ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL);
         ctrl |= ARCH_TIMER_CTRL_ENABLE;
         ctrl &= ~ARCH_TIMER_CTRL_IT_MASK;
+        arch_timer_reg_write(access, ARCH_TIMER_REG_TVAL, evt);
+        arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl);
+}
 
-        arch_timer_reg_write(ARCH_TIMER_REG_TVAL, evt);
-        arch_timer_reg_write(ARCH_TIMER_REG_CTRL, ctrl);
+static int arch_timer_set_next_event_virt(unsigned long evt,
+                                          struct clock_event_device *unused)
+{
+        set_next_event(ARCH_TIMER_VIRT_ACCESS, evt);
+        return 0;
+}
 
+static int arch_timer_set_next_event_phys(unsigned long evt,
+                                          struct clock_event_device *unused)
+{
+        set_next_event(ARCH_TIMER_PHYS_ACCESS, evt);
         return 0;
 }
 
 static int __cpuinit arch_timer_setup(struct clock_event_device *clk)
 {
-        /* Be safe... */
-        arch_timer_disable();
-
         clk->features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_C3STOP;
         clk->name = "arch_sys_timer";
         clk->rating = 450;
-        clk->set_mode = arch_timer_set_mode;
-        clk->set_next_event = arch_timer_set_next_event;
-        clk->irq = arch_timer_ppi;
+        if (arch_timer_use_virtual) {
+                clk->irq = arch_timer_ppi[VIRT_PPI];
+                clk->set_mode = arch_timer_set_mode_virt;
+                clk->set_next_event = arch_timer_set_next_event_virt;
+        } else {
+                clk->irq = arch_timer_ppi[PHYS_SECURE_PPI];
+                clk->set_mode = arch_timer_set_mode_phys;
+                clk->set_next_event = arch_timer_set_next_event_phys;
+        }
+
+        clk->set_mode(CLOCK_EVT_MODE_SHUTDOWN, NULL);
 
         clockevents_config_and_register(clk, arch_timer_rate,
                                         0xf, 0x7fffffff);
 
         *__this_cpu_ptr(arch_timer_evt) = clk;
 
-        enable_percpu_irq(clk->irq, 0);
-        if (arch_timer_ppi2)
-                enable_percpu_irq(arch_timer_ppi2, 0);
+        if (arch_timer_use_virtual)
+                enable_percpu_irq(arch_timer_ppi[VIRT_PPI], 0);
+        else {
+                enable_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI], 0);
+                if (arch_timer_ppi[PHYS_NONSECURE_PPI])
+                        enable_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI], 0);
+        }
 
         return 0;
 }
@@ -173,8 +274,8 @@ static int arch_timer_available(void)
                 return -ENXIO;
 
         if (arch_timer_rate == 0) {
-                arch_timer_reg_write(ARCH_TIMER_REG_CTRL, 0);
-                freq = arch_timer_reg_read(ARCH_TIMER_REG_FREQ);
+                freq = arch_timer_reg_read(ARCH_TIMER_PHYS_ACCESS,
+                                           ARCH_TIMER_REG_FREQ);
 
                 /* Check the timer frequency. */
                 if (freq == 0) {
@@ -185,52 +286,57 @@ static int arch_timer_available(void)
                 arch_timer_rate = freq;
         }
 
-        pr_info_once("Architected local timer running at %lu.%02luMHz.\n",
-                     arch_timer_rate / 1000000, (arch_timer_rate / 10000) % 100);
+        pr_info_once("Architected local timer running at %lu.%02luMHz (%s).\n",
+                     arch_timer_rate / 1000000, (arch_timer_rate / 10000) % 100,
+                     arch_timer_use_virtual ? "virt" : "phys");
         return 0;
 }
 
-static inline cycle_t arch_counter_get_cntpct(void)
+static u32 notrace arch_counter_get_cntpct32(void)
 {
-        u32 cvall, cvalh;
-
-        asm volatile("mrrc p15, 0, %0, %1, c14" : "=r" (cvall), "=r" (cvalh));
+        cycle_t cnt = arch_counter_get_cntpct();
 
-        return ((cycle_t) cvalh << 32) | cvall;
-}
-
-static inline cycle_t arch_counter_get_cntvct(void)
-{
-        u32 cvall, cvalh;
-
-        asm volatile("mrrc p15, 1, %0, %1, c14" : "=r" (cvall), "=r" (cvalh));
-
-        return ((cycle_t) cvalh << 32) | cvall;
+        /*
+         * The sched_clock infrastructure only knows about counters
+         * with at most 32bits. Forget about the upper 24 bits for the
+         * time being...
+         */
+        return (u32)cnt;
 }
 
 static u32 notrace arch_counter_get_cntvct32(void)
 {
-        cycle_t cntvct = arch_counter_get_cntvct();
+        cycle_t cnt = arch_counter_get_cntvct();
 
         /*
          * The sched_clock infrastructure only knows about counters
          * with at most 32bits. Forget about the upper 24 bits for the
          * time being...
          */
-        return (u32)(cntvct & (u32)~0);
+        return (u32)cnt;
 }
 
 static cycle_t arch_counter_read(struct clocksource *cs)
 {
+        /*
+         * Always use the physical counter for the clocksource.
+         * CNTHCTL.PL1PCTEN must be set to 1.
+         */
         return arch_counter_get_cntpct();
 }
 
-int read_current_timer(unsigned long *timer_val)
+static unsigned long arch_timer_read_current_timer(void)
 {
-        if (!arch_timer_rate)
-                return -ENXIO;
-        *timer_val = arch_counter_get_cntpct();
-        return 0;
+        return arch_counter_get_cntpct();
+}
+
+static cycle_t arch_counter_read_cc(const struct cyclecounter *cc)
+{
+        /*
+         * Always use the physical counter for the clocksource.
+         * CNTHCTL.PL1PCTEN must be set to 1.
+         */
+        return arch_counter_get_cntpct();
 }
 
 static struct clocksource clocksource_counter = {
@@ -241,14 +347,32 @@ static struct clocksource clocksource_counter = {
         .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
+static struct cyclecounter cyclecounter = {
+        .read   = arch_counter_read_cc,
+        .mask   = CLOCKSOURCE_MASK(56),
+};
+
+static struct timecounter timecounter;
+
+struct timecounter *arch_timer_get_timecounter(void)
+{
+        return &timecounter;
+}
+
 static void __cpuinit arch_timer_stop(struct clock_event_device *clk)
 {
         pr_debug("arch_timer_teardown disable IRQ%d cpu #%d\n",
                  clk->irq, smp_processor_id());
-        disable_percpu_irq(clk->irq);
-        if (arch_timer_ppi2)
-                disable_percpu_irq(arch_timer_ppi2);
-        arch_timer_set_mode(CLOCK_EVT_MODE_UNUSED, clk);
+
+        if (arch_timer_use_virtual)
+                disable_percpu_irq(arch_timer_ppi[VIRT_PPI]);
+        else {
+                disable_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI]);
+                if (arch_timer_ppi[PHYS_NONSECURE_PPI])
+                        disable_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI]);
+        }
+
+        clk->set_mode(CLOCK_EVT_MODE_UNUSED, clk);
 }
 
 static struct local_timer_ops arch_timer_ops __cpuinitdata = {
@@ -261,36 +385,48 @@ static struct clock_event_device arch_timer_global_evt;
 static int __init arch_timer_register(void)
 {
         int err;
+        int ppi;
 
         err = arch_timer_available();
         if (err)
-                return err;
+                goto out;
 
         arch_timer_evt = alloc_percpu(struct clock_event_device *);
-        if (!arch_timer_evt)
-                return -ENOMEM;
+        if (!arch_timer_evt) {
+                err = -ENOMEM;
+                goto out;
+        }
 
         clocksource_register_hz(&clocksource_counter, arch_timer_rate);
+        cyclecounter.mult = clocksource_counter.mult;
+        cyclecounter.shift = clocksource_counter.shift;
+        timecounter_init(&timecounter, &cyclecounter,
+                         arch_counter_get_cntpct());
+
+        if (arch_timer_use_virtual) {
+                ppi = arch_timer_ppi[VIRT_PPI];
+                err = request_percpu_irq(ppi, arch_timer_handler_virt,
+                                         "arch_timer", arch_timer_evt);
+        } else {
+                ppi = arch_timer_ppi[PHYS_SECURE_PPI];
+                err = request_percpu_irq(ppi, arch_timer_handler_phys,
+                                         "arch_timer", arch_timer_evt);
+                if (!err && arch_timer_ppi[PHYS_NONSECURE_PPI]) {
+                        ppi = arch_timer_ppi[PHYS_NONSECURE_PPI];
+                        err = request_percpu_irq(ppi, arch_timer_handler_phys,
+                                                 "arch_timer", arch_timer_evt);
+                        if (err)
+                                free_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI],
+                                                arch_timer_evt);
+                }
+        }
 
-        err = request_percpu_irq(arch_timer_ppi, arch_timer_handler,
-                                 "arch_timer", arch_timer_evt);
         if (err) {
                 pr_err("arch_timer: can't register interrupt %d (%d)\n",
-                       arch_timer_ppi, err);
+                       ppi, err);
                 goto out_free;
         }
 
-        if (arch_timer_ppi2) {
-                err = request_percpu_irq(arch_timer_ppi2, arch_timer_handler,
-                                         "arch_timer", arch_timer_evt);
-                if (err) {
-                        pr_err("arch_timer: can't register interrupt %d (%d)\n",
-                               arch_timer_ppi2, err);
-                        arch_timer_ppi2 = 0;
-                        goto out_free_irq;
-                }
-        }
-
         err = local_timer_register(&arch_timer_ops);
         if (err) {
                 /*
@@ -302,21 +438,29 @@ static int __init arch_timer_register(void)
                 arch_timer_global_evt.cpumask = cpumask_of(0);
                 err = arch_timer_setup(&arch_timer_global_evt);
         }
-
         if (err)
                 goto out_free_irq;
 
-        init_current_timer_delay(arch_timer_rate);
+        /* Use the architected timer for the delay loop. */
+        arch_delay_timer.read_current_timer = &arch_timer_read_current_timer;
+        arch_delay_timer.freq = arch_timer_rate;
+        register_current_timer_delay(&arch_delay_timer);
         return 0;
 
 out_free_irq:
-        free_percpu_irq(arch_timer_ppi, arch_timer_evt);
-        if (arch_timer_ppi2)
-                free_percpu_irq(arch_timer_ppi2, arch_timer_evt);
+        if (arch_timer_use_virtual)
+                free_percpu_irq(arch_timer_ppi[VIRT_PPI], arch_timer_evt);
+        else {
+                free_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI],
+                                arch_timer_evt);
+                if (arch_timer_ppi[PHYS_NONSECURE_PPI])
+                        free_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI],
+                                        arch_timer_evt);
+        }
 
 out_free:
         free_percpu(arch_timer_evt);
-
+out:
         return err;
 }
 
@@ -329,6 +473,7 @@ int __init arch_timer_of_register(void)
 {
         struct device_node *np;
         u32 freq;
+        int i;
 
         np = of_find_matching_node(NULL, arch_timer_of_match);
         if (!np) {
@@ -340,22 +485,40 @@ int __init arch_timer_of_register(void)
         if (!of_property_read_u32(np, "clock-frequency", &freq))
                 arch_timer_rate = freq;
 
-        arch_timer_ppi = irq_of_parse_and_map(np, 0);
-        arch_timer_ppi2 = irq_of_parse_and_map(np, 1);
-        pr_info("arch_timer: found %s irqs %d %d\n",
-                np->name, arch_timer_ppi, arch_timer_ppi2);
+        for (i = PHYS_SECURE_PPI; i < MAX_TIMER_PPI; i++)
+                arch_timer_ppi[i] = irq_of_parse_and_map(np, i);
+
+        /*
+         * If no interrupt provided for virtual timer, we'll have to
+         * stick to the physical timer. It'd better be accessible...
+         */
+        if (!arch_timer_ppi[VIRT_PPI]) {
+                arch_timer_use_virtual = false;
+
+                if (!arch_timer_ppi[PHYS_SECURE_PPI] ||
+                    !arch_timer_ppi[PHYS_NONSECURE_PPI]) {
+                        pr_warn("arch_timer: No interrupt available, giving up\n");
+                        return -EINVAL;
+                }
+        }
 
         return arch_timer_register();
 }
 
 int __init arch_timer_sched_clock_init(void)
 {
+        u32 (*cnt32)(void);
         int err;
 
         err = arch_timer_available();
         if (err)
                 return err;
 
-        setup_sched_clock(arch_counter_get_cntvct32, 32, arch_timer_rate);
+        if (arch_timer_use_virtual)
+                cnt32 = arch_counter_get_cntvct32;
+        else
+                cnt32 = arch_counter_get_cntpct32;
+
+        setup_sched_clock(cnt32, 32, arch_timer_rate);
         return 0;
 }
diff --git a/arch/arm/kernel/asm-offsets.c b/arch/arm/kernel/asm-offsets.c
index 1429d8989fb9..c985b481192c 100644
--- a/arch/arm/kernel/asm-offsets.c
+++ b/arch/arm/kernel/asm-offsets.c
@@ -59,10 +59,12 @@ int main(void)
   DEFINE(TI_USED_CP,            offsetof(struct thread_info, used_cp));
   DEFINE(TI_TP_VALUE,           offsetof(struct thread_info, tp_value));
   DEFINE(TI_FPSTATE,            offsetof(struct thread_info, fpstate));
+#ifdef CONFIG_VFP
   DEFINE(TI_VFPSTATE,           offsetof(struct thread_info, vfpstate));
 #ifdef CONFIG_SMP
   DEFINE(VFP_CPU,               offsetof(union vfp_state, hard.cpu));
 #endif
+#endif
 #ifdef CONFIG_ARM_THUMBEE
   DEFINE(TI_THUMBEE_STATE,      offsetof(struct thread_info, thumbee_state));
 #endif
diff --git a/arch/arm/kernel/atags.h b/arch/arm/kernel/atags.h
index e5f028d214a1..9edc9692332d 100644
--- a/arch/arm/kernel/atags.h
+++ b/arch/arm/kernel/atags.h
@@ -3,3 +3,17 @@ extern void save_atags(struct tag *tags);
 #else
 static inline void save_atags(struct tag *tags) { }
 #endif
+
+void convert_to_tag_list(struct tag *tags);
+
+#ifdef CONFIG_ATAGS
+struct machine_desc *setup_machine_tags(phys_addr_t __atags_pointer, unsigned int machine_nr);
+#else
+static inline struct machine_desc *
+setup_machine_tags(phys_addr_t __atags_pointer, unsigned int machine_nr)
+{
+        early_print("no ATAGS support: can't continue\n");
+        while (true);
+        unreachable();
+}
+#endif
diff --git a/arch/arm/kernel/compat.c b/arch/arm/kernel/atags_compat.c
index 925652318b8b..5236ad38f417 100644
--- a/arch/arm/kernel/compat.c
+++ b/arch/arm/kernel/atags_compat.c
@@ -1,5 +1,5 @@
 /*
- *  linux/arch/arm/kernel/compat.c
+ *  linux/arch/arm/kernel/atags_compat.c
  *
  *  Copyright (C) 2001 Russell King
  *
@@ -26,7 +26,7 @@
 
 #include <asm/mach/arch.h>
 
-#include "compat.h"
+#include "atags.h"
 
 /*
  * Usage:
diff --git a/arch/arm/kernel/atags_parse.c b/arch/arm/kernel/atags_parse.c
new file mode 100644
index 000000000000..14512e6931d8
--- /dev/null
+++ b/arch/arm/kernel/atags_parse.c
@@ -0,0 +1,238 @@
+/*
+ * Tag parsing.
+ *
+ * Copyright (C) 1995-2001 Russell King
+ *
+ * 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.
+ */
+
+/*
+ * This is the traditional way of passing data to the kernel at boot time.  Rather
+ * than passing a fixed inflexible structure to the kernel, we pass a list
+ * of variable-sized tags to the kernel.  The first tag must be a ATAG_CORE
+ * tag for the list to be recognised (to distinguish the tagged list from
+ * a param_struct).  The list is terminated with a zero-length tag (this tag
+ * is not parsed in any way).
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/root_dev.h>
+#include <linux/screen_info.h>
+
+#include <asm/setup.h>
+#include <asm/system_info.h>
+#include <asm/page.h>
+#include <asm/mach/arch.h>
+
+#include "atags.h"
+
+static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
+
+#ifndef MEM_SIZE
+#define MEM_SIZE        (16*1024*1024)
+#endif
+
+static struct {
+        struct tag_header hdr1;
+        struct tag_core   core;
+        struct tag_header hdr2;
+        struct tag_mem32  mem;
+        struct tag_header hdr3;
+} default_tags __initdata = {
+        { tag_size(tag_core), ATAG_CORE },
+        { 1, PAGE_SIZE, 0xff },
+        { tag_size(tag_mem32), ATAG_MEM },
+        { MEM_SIZE },
+        { 0, ATAG_NONE }
+};
+
+static int __init parse_tag_core(const struct tag *tag)
+{
+        if (tag->hdr.size > 2) {
+                if ((tag->u.core.flags & 1) == 0)
+                        root_mountflags &= ~MS_RDONLY;
+                ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
+        }
+        return 0;
+}
+
+__tagtable(ATAG_CORE, parse_tag_core);
+
+static int __init parse_tag_mem32(const struct tag *tag)
+{
+        return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
+}
+
+__tagtable(ATAG_MEM, parse_tag_mem32);
+
+#if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
+static int __init parse_tag_videotext(const struct tag *tag)
+{
+        screen_info.orig_x            = tag->u.videotext.x;
+        screen_info.orig_y            = tag->u.videotext.y;
+        screen_info.orig_video_page   = tag->u.videotext.video_page;
+        screen_info.orig_video_mode   = tag->u.videotext.video_mode;
+        screen_info.orig_video_cols   = tag->u.videotext.video_cols;
+        screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
+        screen_info.orig_video_lines  = tag->u.videotext.video_lines;
+        screen_info.orig_video_isVGA  = tag->u.videotext.video_isvga;
+        screen_info.orig_video_points = tag->u.videotext.video_points;
+        return 0;
+}
+
+__tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
+#endif
+
+#ifdef CONFIG_BLK_DEV_RAM
+static int __init parse_tag_ramdisk(const struct tag *tag)
+{
+        extern int rd_size, rd_image_start, rd_prompt, rd_doload;
+
+        rd_image_start = tag->u.ramdisk.start;
+        rd_doload = (tag->u.ramdisk.flags & 1) == 0;
+        rd_prompt = (tag->u.ramdisk.flags & 2) == 0;
+
+        if (tag->u.ramdisk.size)
+                rd_size = tag->u.ramdisk.size;
+
+        return 0;
+}
+
+__tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
+#endif
+
+static int __init parse_tag_serialnr(const struct tag *tag)
+{
+        system_serial_low = tag->u.serialnr.low;
+        system_serial_high = tag->u.serialnr.high;
+        return 0;
+}
+
+__tagtable(ATAG_SERIAL, parse_tag_serialnr);
+
+static int __init parse_tag_revision(const struct tag *tag)
+{
+        system_rev = tag->u.revision.rev;
+        return 0;
+}
+
+__tagtable(ATAG_REVISION, parse_tag_revision);
+
+static int __init parse_tag_cmdline(const struct tag *tag)
+{
+#if defined(CONFIG_CMDLINE_EXTEND)
+        strlcat(default_command_line, " ", COMMAND_LINE_SIZE);
+        strlcat(default_command_line, tag->u.cmdline.cmdline,
+                COMMAND_LINE_SIZE);
+#elif defined(CONFIG_CMDLINE_FORCE)
+        pr_warning("Ignoring tag cmdline (using the default kernel command line)\n");
+#else
+        strlcpy(default_command_line, tag->u.cmdline.cmdline,
+                COMMAND_LINE_SIZE);
+#endif
+        return 0;
+}
+
+__tagtable(ATAG_CMDLINE, parse_tag_cmdline);
+
+/*
+ * Scan the tag table for this tag, and call its parse function.
+ * The tag table is built by the linker from all the __tagtable
+ * declarations.
+ */
+static int __init parse_tag(const struct tag *tag)
+{
+        extern struct tagtable __tagtable_begin, __tagtable_end;
+        struct tagtable *t;
+
+        for (t = &__tagtable_begin; t < &__tagtable_end; t++)
+                if (tag->hdr.tag == t->tag) {
+                        t->parse(tag);
+                        break;
+                }
+
+        return t < &__tagtable_end;
+}
+
+/*
+ * Parse all tags in the list, checking both the global and architecture
+ * specific tag tables.
+ */
+static void __init parse_tags(const struct tag *t)
+{
+        for (; t->hdr.size; t = tag_next(t))
+                if (!parse_tag(t))
+                        printk(KERN_WARNING
+                                "Ignoring unrecognised tag 0x%08x\n",
+                                t->hdr.tag);
+}
+
+static void __init squash_mem_tags(struct tag *tag)
+{
+        for (; tag->hdr.size; tag = tag_next(tag))
+                if (tag->hdr.tag == ATAG_MEM)
+                        tag->hdr.tag = ATAG_NONE;
+}
+
+struct machine_desc * __init setup_machine_tags(phys_addr_t __atags_pointer,
+                                                unsigned int machine_nr)
+{
+        struct tag *tags = (struct tag *)&default_tags;
+        struct machine_desc *mdesc = NULL, *p;
+        char *from = default_command_line;
+
+        default_tags.mem.start = PHYS_OFFSET;
+
+        /*
+         * locate machine in the list of supported machines.
+         */
+        for_each_machine_desc(p)
+                if (machine_nr == p->nr) {
+                        printk("Machine: %s\n", p->name);
+                        mdesc = p;
+                        break;
+                }
+
+        if (!mdesc) {
+                early_print("\nError: unrecognized/unsupported machine ID"
+                            " (r1 = 0x%08x).\n\n", machine_nr);
+                dump_machine_table(); /* does not return */
+        }
+
+        if (__atags_pointer)
+                tags = phys_to_virt(__atags_pointer);
+        else if (mdesc->atag_offset)
+                tags = (void *)(PAGE_OFFSET + mdesc->atag_offset);
+
+#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
+        /*
+         * If we have the old style parameters, convert them to
+         * a tag list.
+         */
+        if (tags->hdr.tag != ATAG_CORE)
+                convert_to_tag_list(tags);
+#endif
+        if (tags->hdr.tag != ATAG_CORE) {
+                early_print("Warning: Neither atags nor dtb found\n");
+                tags = (struct tag *)&default_tags;
+        }
+
+        if (mdesc->fixup)
+                mdesc->fixup(tags, &from, &meminfo);
+
+        if (tags->hdr.tag == ATAG_CORE) {
+                if (meminfo.nr_banks != 0)
+                        squash_mem_tags(tags);
+                save_atags(tags);
+                parse_tags(tags);
+        }
+
+        /* parse_early_param needs a boot_command_line */
+        strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);
+
+        return mdesc;
+}
diff --git a/arch/arm/kernel/atags.c b/arch/arm/kernel/atags_proc.c
index 42a1a1415fa6..42a1a1415fa6 100644
--- a/arch/arm/kernel/atags.c
+++ b/arch/arm/kernel/atags_proc.c
diff --git a/arch/arm/kernel/compat.h b/arch/arm/kernel/compat.h
deleted file mode 100644
index 39264ab1b9c6..000000000000
--- a/arch/arm/kernel/compat.h
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- *  linux/arch/arm/kernel/compat.h
- *
- *  Copyright (C) 2001 Russell King
- *
- * 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.
-*/
-
-extern void convert_to_tag_list(struct tag *tags);
diff --git a/arch/arm/kernel/entry-common.S b/arch/arm/kernel/entry-common.S
index 978eac57e04a..f45987037bf1 100644
--- a/arch/arm/kernel/entry-common.S
+++ b/arch/arm/kernel/entry-common.S
@@ -94,6 +94,15 @@ ENDPROC(ret_from_fork)
         .equ NR_syscalls,0
 #define CALL(x) .equ NR_syscalls,NR_syscalls+1
 #include "calls.S"
+
+/*
+ * Ensure that the system call table is equal to __NR_syscalls,
+ * which is the value the rest of the system sees
+ */
+.ifne NR_syscalls - __NR_syscalls
+.error "__NR_syscalls is not equal to the size of the syscall table"
+.endif
+
 #undef CALL
 #define CALL(x) .long x
 
diff --git a/arch/arm/kernel/machine_kexec.c b/arch/arm/kernel/machine_kexec.c
index dfcdb9f7c126..e29c3337ca81 100644
--- a/arch/arm/kernel/machine_kexec.c
+++ b/arch/arm/kernel/machine_kexec.c
@@ -8,7 +8,9 @@
 #include <linux/reboot.h>
 #include <linux/io.h>
 #include <linux/irq.h>
+#include <linux/memblock.h>
 #include <asm/pgtable.h>
+#include <linux/of_fdt.h>
 #include <asm/pgalloc.h>
 #include <asm/mmu_context.h>
 #include <asm/cacheflush.h>
@@ -32,6 +34,29 @@ static atomic_t waiting_for_crash_ipi;
 
 int machine_kexec_prepare(struct kimage *image)
 {
+        struct kexec_segment *current_segment;
+        __be32 header;
+        int i, err;
+
+        /*
+         * No segment at default ATAGs address. try to locate
+         * a dtb using magic.
+         */
+        for (i = 0; i < image->nr_segments; i++) {
+                current_segment = &image->segment[i];
+
+                err = memblock_is_region_memory(current_segment->mem,
+                                                current_segment->memsz);
+                if (err)
+                        return - EINVAL;
+
+                err = get_user(header, (__be32*)current_segment->buf);
+                if (err)
+                        return err;
+
+                if (be32_to_cpu(header) == OF_DT_HEADER)
+                        kexec_boot_atags = current_segment->mem;
+        }
         return 0;
 }
 
@@ -122,7 +147,9 @@ 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;
+        if (!kexec_boot_atags)
+                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/ptrace.c b/arch/arm/kernel/ptrace.c
index 3e0fc5f7ed4b..739db3a1b2d2 100644
--- a/arch/arm/kernel/ptrace.c
+++ b/arch/arm/kernel/ptrace.c
@@ -30,6 +30,9 @@
 #include <asm/pgtable.h>
 #include <asm/traps.h>
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/syscalls.h>
+
 #define REG_PC  15
 #define REG_PSR 16
 /*
@@ -918,11 +921,11 @@ static int ptrace_syscall_trace(struct pt_regs *regs, int scno,
 {
         unsigned long ip;
 
+        current_thread_info()->syscall = scno;
+
         if (!test_thread_flag(TIF_SYSCALL_TRACE))
                 return scno;
 
-        current_thread_info()->syscall = scno;
-
         /*
          * IP is used to denote syscall entry/exit:
          * IP = 0 -> entry, =1 -> exit
@@ -941,15 +944,19 @@ static int ptrace_syscall_trace(struct pt_regs *regs, int scno,
 
 asmlinkage int syscall_trace_enter(struct pt_regs *regs, int scno)
 {
-        int ret = ptrace_syscall_trace(regs, scno, PTRACE_SYSCALL_ENTER);
+        scno = ptrace_syscall_trace(regs, scno, PTRACE_SYSCALL_ENTER);
+        if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
+                trace_sys_enter(regs, scno);
         audit_syscall_entry(AUDIT_ARCH_ARM, scno, regs->ARM_r0, regs->ARM_r1,
                             regs->ARM_r2, regs->ARM_r3);
-        return ret;
+        return scno;
 }
 
 asmlinkage int syscall_trace_exit(struct pt_regs *regs, int scno)
 {
-        int ret = ptrace_syscall_trace(regs, scno, PTRACE_SYSCALL_EXIT);
+        scno = ptrace_syscall_trace(regs, scno, PTRACE_SYSCALL_EXIT);
+        if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
+                trace_sys_exit(regs, scno);
         audit_syscall_exit(regs);
-        return ret;
+        return scno;
 }
diff --git a/arch/arm/kernel/sched_clock.c b/arch/arm/kernel/sched_clock.c
index f4515393248d..e21bac20d90d 100644
--- a/arch/arm/kernel/sched_clock.c
+++ b/arch/arm/kernel/sched_clock.c
@@ -9,6 +9,7 @@
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/kernel.h>
+#include <linux/moduleparam.h>
 #include <linux/sched.h>
 #include <linux/syscore_ops.h>
 #include <linux/timer.h>
@@ -27,6 +28,9 @@ struct clock_data {
 
 static void sched_clock_poll(unsigned long wrap_ticks);
 static DEFINE_TIMER(sched_clock_timer, sched_clock_poll, 0, 0);
+static int irqtime = -1;
+
+core_param(irqtime, irqtime, int, 0400);
 
 static struct clock_data cd = {
         .mult   = NSEC_PER_SEC / HZ,
@@ -157,6 +161,10 @@ void __init setup_sched_clock(u32 (*read)(void), int bits, unsigned long rate)
          */
         cd.epoch_ns = 0;
 
+        /* Enable IRQ time accounting if we have a fast enough sched_clock */
+        if (irqtime > 0 || (irqtime == -1 && rate >= 1000000))
+                enable_sched_clock_irqtime();
+
         pr_debug("Registered %pF as sched_clock source\n", read);
 }
 
diff --git a/arch/arm/kernel/setup.c b/arch/arm/kernel/setup.c
index 725f9f2a9541..febafa0f552d 100644
--- a/arch/arm/kernel/setup.c
+++ b/arch/arm/kernel/setup.c
@@ -21,11 +21,9 @@
 #include <linux/init.h>
 #include <linux/kexec.h>
 #include <linux/of_fdt.h>
-#include <linux/root_dev.h>
 #include <linux/cpu.h>
 #include <linux/interrupt.h>
 #include <linux/smp.h>
-#include <linux/fs.h>
 #include <linux/proc_fs.h>
 #include <linux/memblock.h>
 #include <linux/bug.h>
@@ -56,15 +54,9 @@
 #include <asm/unwind.h>
 #include <asm/memblock.h>
 
-#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
-#include "compat.h"
-#endif
 #include "atags.h"
 #include "tcm.h"
 
-#ifndef MEM_SIZE
-#define MEM_SIZE        (16*1024*1024)
-#endif
 
 #if defined(CONFIG_FPE_NWFPE) || defined(CONFIG_FPE_FASTFPE)
 char fpe_type[8];
@@ -145,7 +137,6 @@ static const char *machine_name;
 static char __initdata cmd_line[COMMAND_LINE_SIZE];
 struct machine_desc *machine_desc __initdata;
 
-static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
 static union { char c[4]; unsigned long l; } endian_test __initdata = { { 'l', '?', '?', 'b' } };
 #define ENDIANNESS ((char)endian_test.l)
 
@@ -583,21 +574,6 @@ static int __init early_mem(char *p)
 }
 early_param("mem", early_mem);
 
-static void __init
-setup_ramdisk(int doload, int prompt, int image_start, unsigned int rd_sz)
-{
-#ifdef CONFIG_BLK_DEV_RAM
-        extern int rd_size, rd_image_start, rd_prompt, rd_doload;
-
-        rd_image_start = image_start;
-        rd_prompt = prompt;
-        rd_doload = doload;
-
-        if (rd_sz)
-                rd_size = rd_sz;
-#endif
-}
-
 static void __init request_standard_resources(struct machine_desc *mdesc)
 {
         struct memblock_region *region;
@@ -643,35 +619,6 @@ static void __init request_standard_resources(struct machine_desc *mdesc)
                 request_resource(&ioport_resource, &lp2);
 }
 
-/*
- *  Tag parsing.
- *
- * This is the new way of passing data to the kernel at boot time.  Rather
- * than passing a fixed inflexible structure to the kernel, we pass a list
- * of variable-sized tags to the kernel.  The first tag must be a ATAG_CORE
- * tag for the list to be recognised (to distinguish the tagged list from
- * a param_struct).  The list is terminated with a zero-length tag (this tag
- * is not parsed in any way).
- */
-static int __init parse_tag_core(const struct tag *tag)
-{
-        if (tag->hdr.size > 2) {
-                if ((tag->u.core.flags & 1) == 0)
-                        root_mountflags &= ~MS_RDONLY;
-                ROOT_DEV = old_decode_dev(tag->u.core.rootdev);
-        }
-        return 0;
-}
-
-__tagtable(ATAG_CORE, parse_tag_core);
-
-static int __init parse_tag_mem32(const struct tag *tag)
-{
-        return arm_add_memory(tag->u.mem.start, tag->u.mem.size);
-}
-
-__tagtable(ATAG_MEM, parse_tag_mem32);
-
 #if defined(CONFIG_VGA_CONSOLE) || defined(CONFIG_DUMMY_CONSOLE)
 struct screen_info screen_info = {
  .orig_video_lines      = 30,
@@ -681,117 +628,8 @@ struct screen_info screen_info = {
  .orig_video_isVGA      = 1,
  .orig_video_points     = 8
 };
-
-static int __init parse_tag_videotext(const struct tag *tag)
-{
-        screen_info.orig_x            = tag->u.videotext.x;
-        screen_info.orig_y            = tag->u.videotext.y;
-        screen_info.orig_video_page   = tag->u.videotext.video_page;
-        screen_info.orig_video_mode   = tag->u.videotext.video_mode;
-        screen_info.orig_video_cols   = tag->u.videotext.video_cols;
-        screen_info.orig_video_ega_bx = tag->u.videotext.video_ega_bx;
-        screen_info.orig_video_lines  = tag->u.videotext.video_lines;
-        screen_info.orig_video_isVGA  = tag->u.videotext.video_isvga;
-        screen_info.orig_video_points = tag->u.videotext.video_points;
-        return 0;
-}
-
-__tagtable(ATAG_VIDEOTEXT, parse_tag_videotext);
 #endif
 
-static int __init parse_tag_ramdisk(const struct tag *tag)
-{
-        setup_ramdisk((tag->u.ramdisk.flags & 1) == 0,
-                      (tag->u.ramdisk.flags & 2) == 0,
-                      tag->u.ramdisk.start, tag->u.ramdisk.size);
-        return 0;
-}
-
-__tagtable(ATAG_RAMDISK, parse_tag_ramdisk);
-
-static int __init parse_tag_serialnr(const struct tag *tag)
-{
-        system_serial_low = tag->u.serialnr.low;
-        system_serial_high = tag->u.serialnr.high;
-        return 0;
-}
-
-__tagtable(ATAG_SERIAL, parse_tag_serialnr);
-
-static int __init parse_tag_revision(const struct tag *tag)
-{
-        system_rev = tag->u.revision.rev;
-        return 0;
-}
-
-__tagtable(ATAG_REVISION, parse_tag_revision);
-
-static int __init parse_tag_cmdline(const struct tag *tag)
-{
-#if defined(CONFIG_CMDLINE_EXTEND)
-        strlcat(default_command_line, " ", COMMAND_LINE_SIZE);
-        strlcat(default_command_line, tag->u.cmdline.cmdline,
-                COMMAND_LINE_SIZE);
-#elif defined(CONFIG_CMDLINE_FORCE)
-        pr_warning("Ignoring tag cmdline (using the default kernel command line)\n");
-#else
-        strlcpy(default_command_line, tag->u.cmdline.cmdline,
-                COMMAND_LINE_SIZE);
-#endif
-        return 0;
-}
-
-__tagtable(ATAG_CMDLINE, parse_tag_cmdline);
-
-/*
- * Scan the tag table for this tag, and call its parse function.
- * The tag table is built by the linker from all the __tagtable
- * declarations.
- */
-static int __init parse_tag(const struct tag *tag)
-{
-        extern struct tagtable __tagtable_begin, __tagtable_end;
-        struct tagtable *t;
-
-        for (t = &__tagtable_begin; t < &__tagtable_end; t++)
-                if (tag->hdr.tag == t->tag) {
-                        t->parse(tag);
-                        break;
-                }
-
-        return t < &__tagtable_end;
-}
-
-/*
- * Parse all tags in the list, checking both the global and architecture
- * specific tag tables.
- */
-static void __init parse_tags(const struct tag *t)
-{
-        for (; t->hdr.size; t = tag_next(t))
-                if (!parse_tag(t))
-                        printk(KERN_WARNING
-                                "Ignoring unrecognised tag 0x%08x\n",
-                                t->hdr.tag);
-}
-
-/*
- * This holds our defaults.
- */
-static struct init_tags {
-        struct tag_header hdr1;
-        struct tag_core   core;
-        struct tag_header hdr2;
-        struct tag_mem32  mem;
-        struct tag_header hdr3;
-} init_tags __initdata = {
-        { tag_size(tag_core), ATAG_CORE },
-        { 1, PAGE_SIZE, 0xff },
-        { tag_size(tag_mem32), ATAG_MEM },
-        { MEM_SIZE },
-        { 0, ATAG_NONE }
-};
-
 static int __init customize_machine(void)
 {
         /* customizes platform devices, or adds new ones */
@@ -858,78 +696,6 @@ static void __init reserve_crashkernel(void)
 static inline void reserve_crashkernel(void) {}
 #endif /* CONFIG_KEXEC */
 
-static void __init squash_mem_tags(struct tag *tag)
-{
-        for (; tag->hdr.size; tag = tag_next(tag))
-                if (tag->hdr.tag == ATAG_MEM)
-                        tag->hdr.tag = ATAG_NONE;
-}
-
-static struct machine_desc * __init setup_machine_tags(unsigned int nr)
-{
-        struct tag *tags = (struct tag *)&init_tags;
-        struct machine_desc *mdesc = NULL, *p;
-        char *from = default_command_line;
-
-        init_tags.mem.start = PHYS_OFFSET;
-
-        /*
-         * locate machine in the list of supported machines.
-         */
-        for_each_machine_desc(p)
-                if (nr == p->nr) {
-                        printk("Machine: %s\n", p->name);
-                        mdesc = p;
-                        break;
-                }
-
-        if (!mdesc) {
-                early_print("\nError: unrecognized/unsupported machine ID"
-                        " (r1 = 0x%08x).\n\n", nr);
-                dump_machine_table(); /* does not return */
-        }
-
-        if (__atags_pointer)
-                tags = phys_to_virt(__atags_pointer);
-        else if (mdesc->atag_offset)
-                tags = (void *)(PAGE_OFFSET + mdesc->atag_offset);
-
-#if defined(CONFIG_DEPRECATED_PARAM_STRUCT)
-        /*
-         * If we have the old style parameters, convert them to
-         * a tag list.
-         */
-        if (tags->hdr.tag != ATAG_CORE)
-                convert_to_tag_list(tags);
-#endif
-
-        if (tags->hdr.tag != ATAG_CORE) {
-#if defined(CONFIG_OF)
-                /*
-                 * If CONFIG_OF is set, then assume this is a reasonably
-                 * modern system that should pass boot parameters
-                 */
-                early_print("Warning: Neither atags nor dtb found\n");
-#endif
-                tags = (struct tag *)&init_tags;
-        }
-
-        if (mdesc->fixup)
-                mdesc->fixup(tags, &from, &meminfo);
-
-        if (tags->hdr.tag == ATAG_CORE) {
-                if (meminfo.nr_banks != 0)
-                        squash_mem_tags(tags);
-                save_atags(tags);
-                parse_tags(tags);
-        }
-
-        /* parse_early_param needs a boot_command_line */
-        strlcpy(boot_command_line, from, COMMAND_LINE_SIZE);
-
-        return mdesc;
-}
-
 static int __init meminfo_cmp(const void *_a, const void *_b)
 {
         const struct membank *a = _a, *b = _b;
@@ -944,7 +710,7 @@ void __init setup_arch(char **cmdline_p)
         setup_processor();
         mdesc = setup_machine_fdt(__atags_pointer);
         if (!mdesc)
-                mdesc = setup_machine_tags(machine_arch_type);
+                mdesc = setup_machine_tags(__atags_pointer, machine_arch_type);
         machine_desc = mdesc;
         machine_name = mdesc->name;
 
diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c
index dea7a925c7e2..d100eacdb798 100644
--- a/arch/arm/kernel/smp.c
+++ b/arch/arm/kernel/smp.c
@@ -59,7 +59,8 @@ struct secondary_data secondary_data;
 volatile int __cpuinitdata pen_release = -1;
 
 enum ipi_msg_type {
-        IPI_TIMER = 2,
+        IPI_WAKEUP,
+        IPI_TIMER,
         IPI_RESCHEDULE,
         IPI_CALL_FUNC,
         IPI_CALL_FUNC_SINGLE,
@@ -414,7 +415,8 @@ void arch_send_call_function_single_ipi(int cpu)
 }
 
 static const char *ipi_types[NR_IPI] = {
-#define S(x,s)  [x - IPI_TIMER] = s
+#define S(x,s)  [x] = s
+        S(IPI_WAKEUP, "CPU wakeup interrupts"),
         S(IPI_TIMER, "Timer broadcast interrupts"),
         S(IPI_RESCHEDULE, "Rescheduling interrupts"),
         S(IPI_CALL_FUNC, "Function call interrupts"),
@@ -567,10 +569,13 @@ void handle_IPI(int ipinr, struct pt_regs *regs)
         unsigned int cpu = smp_processor_id();
         struct pt_regs *old_regs = set_irq_regs(regs);
 
-        if (ipinr >= IPI_TIMER && ipinr < IPI_TIMER + NR_IPI)
-                __inc_irq_stat(cpu, ipi_irqs[ipinr - IPI_TIMER]);
+        if (ipinr < NR_IPI)
+                __inc_irq_stat(cpu, ipi_irqs[ipinr]);
 
         switch (ipinr) {
+        case IPI_WAKEUP:
+                break;
+
         case IPI_TIMER:
                 irq_enter();
                 ipi_timer();