17 files changed, 516 insertions, 122 deletions

diff --git a/arch/sparc/kernel/Makefile b/arch/sparc/kernel/Makefile
index 53adcaa0348b..54742e58831c 100644
--- a/arch/sparc/kernel/Makefile
+++ b/arch/sparc/kernel/Makefile
@@ -52,6 +52,8 @@ obj-$(CONFIG_SPARC64)   += visemul.o
 obj-$(CONFIG_SPARC64)   += hvapi.o
 obj-$(CONFIG_SPARC64)   += sstate.o
 obj-$(CONFIG_SPARC64)   += mdesc.o
+obj-$(CONFIG_SPARC64)   += pcr.o
+obj-$(CONFIG_SPARC64)   += nmi.o
 
 # sparc32 do not use GENERIC_HARDIRQS but uses the generic devres implementation
 obj-$(CONFIG_SPARC32)     += devres.o
diff --git a/arch/sparc/kernel/central.c b/arch/sparc/kernel/central.c
index 05f1c916db06..f3b5466c389c 100644
--- a/arch/sparc/kernel/central.c
+++ b/arch/sparc/kernel/central.c
@@ -103,6 +103,7 @@ static int __devinit clock_board_probe(struct of_device *op,
         p->leds_resource.name = "leds";
 
         p->leds_pdev.name = "sunfire-clockboard-leds";
+        p->leds_pdev.id = -1;
         p->leds_pdev.resource = &p->leds_resource;
         p->leds_pdev.num_resources = 1;
         p->leds_pdev.dev.parent = &op->dev;
@@ -197,6 +198,7 @@ static int __devinit fhc_probe(struct of_device *op,
                 p->leds_resource.name = "leds";
 
                 p->leds_pdev.name = "sunfire-fhc-leds";
+                p->leds_pdev.id = p->board_num;
                 p->leds_pdev.resource = &p->leds_resource;
                 p->leds_pdev.num_resources = 1;
                 p->leds_pdev.dev.parent = &op->dev;
diff --git a/arch/sparc/kernel/cpu.c b/arch/sparc/kernel/cpu.c
index f0b825505da5..d85c3dc4953a 100644
--- a/arch/sparc/kernel/cpu.c
+++ b/arch/sparc/kernel/cpu.c
@@ -26,6 +26,7 @@ EXPORT_PER_CPU_SYMBOL(__cpu_data);
 struct cpu_info {
         int psr_vers;
         const char *name;
+        const char *pmu_name;
 };
 
 struct fpu_info {
@@ -45,6 +46,9 @@ struct manufacturer_info {
 #define CPU(ver, _name) \
 { .psr_vers = ver, .name = _name }
 
+#define CPU_PMU(ver, _name, _pmu_name)  \
+{ .psr_vers = ver, .name = _name, .pmu_name = _pmu_name }
+
 #define FPU(ver, _name) \
 { .fp_vers = ver, .name = _name }
 
@@ -183,10 +187,10 @@ static const struct manufacturer_info __initconst manufacturer_info[] = {
 },{
         0x17,
         .cpu_info = {
-                CPU(0x10, "TI UltraSparc I   (SpitFire)"),
-                CPU(0x11, "TI UltraSparc II  (BlackBird)"),
-                CPU(0x12, "TI UltraSparc IIi (Sabre)"),
-                CPU(0x13, "TI UltraSparc IIe (Hummingbird)"),
+                CPU_PMU(0x10, "TI UltraSparc I   (SpitFire)", "ultra12"),
+                CPU_PMU(0x11, "TI UltraSparc II  (BlackBird)", "ultra12"),
+                CPU_PMU(0x12, "TI UltraSparc IIi (Sabre)", "ultra12"),
+                CPU_PMU(0x13, "TI UltraSparc IIe (Hummingbird)", "ultra12"),
                 CPU(-1, NULL)
         },
         .fpu_info = {
@@ -199,7 +203,7 @@ static const struct manufacturer_info __initconst manufacturer_info[] = {
 },{
         0x22,
         .cpu_info = {
-                CPU(0x10, "TI UltraSparc I   (SpitFire)"),
+                CPU_PMU(0x10, "TI UltraSparc I   (SpitFire)", "ultra12"),
                 CPU(-1, NULL)
         },
         .fpu_info = {
@@ -209,12 +213,12 @@ static const struct manufacturer_info __initconst manufacturer_info[] = {
 },{
         0x3e,
         .cpu_info = {
-                CPU(0x14, "TI UltraSparc III (Cheetah)"),
-                CPU(0x15, "TI UltraSparc III+ (Cheetah+)"),
-                CPU(0x16, "TI UltraSparc IIIi (Jalapeno)"),
-                CPU(0x18, "TI UltraSparc IV (Jaguar)"),
-                CPU(0x19, "TI UltraSparc IV+ (Panther)"),
-                CPU(0x22, "TI UltraSparc IIIi+ (Serrano)"),
+                CPU_PMU(0x14, "TI UltraSparc III (Cheetah)", "ultra3"),
+                CPU_PMU(0x15, "TI UltraSparc III+ (Cheetah+)", "ultra3+"),
+                CPU_PMU(0x16, "TI UltraSparc IIIi (Jalapeno)", "ultra3i"),
+                CPU_PMU(0x18, "TI UltraSparc IV (Jaguar)", "ultra3+"),
+                CPU_PMU(0x19, "TI UltraSparc IV+ (Panther)", "ultra4+"),
+                CPU_PMU(0x22, "TI UltraSparc IIIi+ (Serrano)", "ultra3i"),
                 CPU(-1, NULL)
         },
         .fpu_info = {
@@ -234,29 +238,44 @@ static const struct manufacturer_info __initconst manufacturer_info[] = {
 
 const char *sparc_cpu_type;
 const char *sparc_fpu_type;
+const char *sparc_pmu_type;
 
 unsigned int fsr_storage;
 
 static void set_cpu_and_fpu(int psr_impl, int psr_vers, int fpu_vers)
 {
+        const struct manufacturer_info *manuf;
+        int i;
+
         sparc_cpu_type = NULL;
         sparc_fpu_type = NULL;
-        if (psr_impl < ARRAY_SIZE(manufacturer_info))
+        sparc_pmu_type = NULL;
+        manuf = NULL;
+
+        for (i = 0; i < ARRAY_SIZE(manufacturer_info); i++)
+        {
+                if (psr_impl == manufacturer_info[i].psr_impl) {
+                        manuf = &manufacturer_info[i];
+                        break;
+                }
+        }
+        if (manuf != NULL)
         {
                 const struct cpu_info *cpu;
                 const struct fpu_info *fpu;
 
-                cpu = &manufacturer_info[psr_impl].cpu_info[0];
+                cpu = &manuf->cpu_info[0];
                 while (cpu->psr_vers != -1)
                 {
                         if (cpu->psr_vers == psr_vers) {
                                 sparc_cpu_type = cpu->name;
+                                sparc_pmu_type = cpu->pmu_name;
                                 sparc_fpu_type = "No FPU";
                                 break;
                         }
                         cpu++;
                 }
-                fpu =  &manufacturer_info[psr_impl].fpu_info[0];
+                fpu =  &manuf->fpu_info[0];
                 while (fpu->fp_vers != -1)
                 {
                         if (fpu->fp_vers == fpu_vers) {
@@ -278,6 +297,8 @@ static void set_cpu_and_fpu(int psr_impl, int psr_vers, int fpu_vers)
                        psr_impl, fpu_vers);
                 sparc_fpu_type = "Unknown FPU";
         }
+        if (sparc_pmu_type == NULL)
+                sparc_pmu_type = "Unknown PMU";
 }
 
 #ifdef CONFIG_SPARC32
@@ -303,11 +324,13 @@ static void __init sun4v_cpu_probe(void)
         case SUN4V_CHIP_NIAGARA1:
                 sparc_cpu_type = "UltraSparc T1 (Niagara)";
                 sparc_fpu_type = "UltraSparc T1 integrated FPU";
+                sparc_pmu_type = "niagara";
                 break;
 
         case SUN4V_CHIP_NIAGARA2:
                 sparc_cpu_type = "UltraSparc T2 (Niagara2)";
                 sparc_fpu_type = "UltraSparc T2 integrated FPU";
+                sparc_pmu_type = "niagara2";
                 break;
 
         default:
diff --git a/arch/sparc/kernel/head_64.S b/arch/sparc/kernel/head_64.S
index 8ffee714f932..a46c3a21e26d 100644
--- a/arch/sparc/kernel/head_64.S
+++ b/arch/sparc/kernel/head_64.S
@@ -891,10 +891,35 @@ prom_tba:	.xword	0
 tlb_type:       .word   0       /* Must NOT end up in BSS */
         .section        ".fixup",#alloc,#execinstr
 
-        .globl  __ret_efault, __retl_efault
-__ret_efault:
+        .globl  __ret_efault, __retl_efault, __ret_one, __retl_one
+ENTRY(__ret_efault)
         ret
          restore %g0, -EFAULT, %o0
-__retl_efault:
+ENDPROC(__ret_efault)
+
+ENTRY(__retl_efault)
         retl
          mov    -EFAULT, %o0
+ENDPROC(__retl_efault)
+
+ENTRY(__retl_one)
+        retl
+         mov    1, %o0
+ENDPROC(__retl_one)
+
+ENTRY(__ret_one_asi)
+        wr      %g0, ASI_AIUS, %asi
+        ret
+         restore %g0, 1, %o0
+ENDPROC(__ret_one_asi)
+
+ENTRY(__retl_one_asi)
+        wr      %g0, ASI_AIUS, %asi
+        retl
+         mov    1, %o0
+ENDPROC(__retl_one_asi)
+
+ENTRY(__retl_o1)
+        retl
+         mov    %o1, %o0
+ENDPROC(__retl_o1)
diff --git a/arch/sparc/kernel/irq_64.c b/arch/sparc/kernel/irq_64.c
index cab8e0286871..e53138365490 100644
--- a/arch/sparc/kernel/irq_64.c
+++ b/arch/sparc/kernel/irq_64.c
@@ -185,7 +185,7 @@ int show_interrupts(struct seq_file *p, void *v)
                 seq_printf(p, "%10u ", kstat_irqs(i));
 #else
                 for_each_online_cpu(j)
-                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
+                        seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
 #endif
                 seq_printf(p, " %9s", irq_desc[i].chip->typename);
                 seq_printf(p, "  %s", action->name);
@@ -196,6 +196,11 @@ int show_interrupts(struct seq_file *p, void *v)
                 seq_putc(p, '\n');
 skip:
                 spin_unlock_irqrestore(&irq_desc[i].lock, flags);
+        } else if (i == NR_IRQS) {
+                seq_printf(p, "NMI: ");
+                for_each_online_cpu(j)
+                        seq_printf(p, "%10u ", cpu_data(j).__nmi_count);
+                seq_printf(p, "     Non-maskable interrupts\n");
         }
         return 0;
 }
@@ -778,69 +783,6 @@ void do_softirq(void)
         local_irq_restore(flags);
 }
 
-static void unhandled_perf_irq(struct pt_regs *regs)
-{
-        unsigned long pcr, pic;
-
-        read_pcr(pcr);
-        read_pic(pic);
-
-        write_pcr(0);
-
-        printk(KERN_EMERG "CPU %d: Got unexpected perf counter IRQ.\n",
-               smp_processor_id());
-        printk(KERN_EMERG "CPU %d: PCR[%016lx] PIC[%016lx]\n",
-               smp_processor_id(), pcr, pic);
-}
-
-/* Almost a direct copy of the powerpc PMC code.  */
-static DEFINE_SPINLOCK(perf_irq_lock);
-static void *perf_irq_owner_caller; /* mostly for debugging */
-static void (*perf_irq)(struct pt_regs *regs) = unhandled_perf_irq;
-
-/* Invoked from level 15 PIL handler in trap table.  */
-void perfctr_irq(int irq, struct pt_regs *regs)
-{
-        clear_softint(1 << irq);
-        perf_irq(regs);
-}
-
-int register_perfctr_intr(void (*handler)(struct pt_regs *))
-{
-        int ret;
-
-        if (!handler)
-                return -EINVAL;
-
-        spin_lock(&perf_irq_lock);
-        if (perf_irq != unhandled_perf_irq) {
-                printk(KERN_WARNING "register_perfctr_intr: "
-                       "perf IRQ busy (reserved by caller %p)\n",
-                       perf_irq_owner_caller);
-                ret = -EBUSY;
-                goto out;
-        }
-
-        perf_irq_owner_caller = __builtin_return_address(0);
-        perf_irq = handler;
-
-        ret = 0;
-out:
-        spin_unlock(&perf_irq_lock);
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(register_perfctr_intr);
-
-void release_perfctr_intr(void (*handler)(struct pt_regs *))
-{
-        spin_lock(&perf_irq_lock);
-        perf_irq_owner_caller = NULL;
-        perf_irq = unhandled_perf_irq;
-        spin_unlock(&perf_irq_lock);
-}
-EXPORT_SYMBOL_GPL(release_perfctr_intr);
-
 #ifdef CONFIG_HOTPLUG_CPU
 void fixup_irqs(void)
 {
diff --git a/arch/sparc/kernel/kernel.h b/arch/sparc/kernel/kernel.h
index 81a972e8d8ea..15d8a3f645c9 100644
--- a/arch/sparc/kernel/kernel.h
+++ b/arch/sparc/kernel/kernel.h
@@ -5,6 +5,7 @@
 
 /* cpu.c */
 extern const char *sparc_cpu_type;
+extern const char *sparc_pmu_type;
 extern const char *sparc_fpu_type;
 
 extern unsigned int fsr_storage;
diff --git a/arch/sparc/kernel/nmi.c b/arch/sparc/kernel/nmi.c
new file mode 100644
index 000000000000..f3577223c863
--- /dev/null
+++ b/arch/sparc/kernel/nmi.c
@@ -0,0 +1,225 @@
+/* Pseudo NMI support on sparc64 systems.
+ *
+ * Copyright (C) 2009 David S. Miller <davem@davemloft.net>
+ *
+ * The NMI watchdog support and infrastructure is based almost
+ * entirely upon the x86 NMI support code.
+ */
+#include <linux/kernel.h>
+#include <linux/param.h>
+#include <linux/init.h>
+#include <linux/percpu.h>
+#include <linux/nmi.h>
+#include <linux/module.h>
+#include <linux/kprobes.h>
+#include <linux/kernel_stat.h>
+#include <linux/slab.h>
+#include <linux/kdebug.h>
+#include <linux/delay.h>
+#include <linux/smp.h>
+
+#include <asm/ptrace.h>
+#include <asm/local.h>
+#include <asm/pcr.h>
+
+/* We don't have a real NMI on sparc64, but we can fake one
+ * up using profiling counter overflow interrupts and interrupt
+ * levels.
+ *
+ * The profile overflow interrupts at level 15, so we use
+ * level 14 as our IRQ off level.
+ */
+
+static int nmi_watchdog_active;
+static int panic_on_timeout;
+
+int nmi_usable;
+EXPORT_SYMBOL_GPL(nmi_usable);
+
+static unsigned int nmi_hz = HZ;
+
+static DEFINE_PER_CPU(unsigned int, last_irq_sum);
+static DEFINE_PER_CPU(local_t, alert_counter);
+static DEFINE_PER_CPU(int, nmi_touch);
+
+void touch_nmi_watchdog(void)
+{
+        if (nmi_watchdog_active) {
+                int cpu;
+
+                for_each_present_cpu(cpu) {
+                        if (per_cpu(nmi_touch, cpu) != 1)
+                                per_cpu(nmi_touch, cpu) = 1;
+                }
+        }
+
+        touch_softlockup_watchdog();
+}
+EXPORT_SYMBOL(touch_nmi_watchdog);
+
+static void die_nmi(const char *str, struct pt_regs *regs, int do_panic)
+{
+        if (notify_die(DIE_NMIWATCHDOG, str, regs, 0,
+                       pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP)
+                return;
+
+        console_verbose();
+        bust_spinlocks(1);
+
+        printk(KERN_EMERG "%s", str);
+        printk(" on CPU%d, ip %08lx, registers:\n",
+               smp_processor_id(), regs->tpc);
+        show_regs(regs);
+        dump_stack();
+
+        bust_spinlocks(0);
+
+        if (do_panic || panic_on_oops)
+                panic("Non maskable interrupt");
+
+        local_irq_enable();
+        do_exit(SIGBUS);
+}
+
+notrace __kprobes void perfctr_irq(int irq, struct pt_regs *regs)
+{
+        unsigned int sum, touched = 0;
+        int cpu = smp_processor_id();
+
+        clear_softint(1 << irq);
+        pcr_ops->write(PCR_PIC_PRIV);
+
+        local_cpu_data().__nmi_count++;
+
+        if (notify_die(DIE_NMI, "nmi", regs, 0,
+                       pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP)
+                touched = 1;
+
+        sum = kstat_irqs_cpu(0, cpu);
+        if (__get_cpu_var(nmi_touch)) {
+                __get_cpu_var(nmi_touch) = 0;
+                touched = 1;
+        }
+        if (!touched && __get_cpu_var(last_irq_sum) == sum) {
+                local_inc(&__get_cpu_var(alert_counter));
+                if (local_read(&__get_cpu_var(alert_counter)) == 5 * nmi_hz)
+                        die_nmi("BUG: NMI Watchdog detected LOCKUP",
+                                regs, panic_on_timeout);
+        } else {
+                __get_cpu_var(last_irq_sum) = sum;
+                local_set(&__get_cpu_var(alert_counter), 0);
+        }
+        if (nmi_usable) {
+                write_pic(picl_value(nmi_hz));
+                pcr_ops->write(pcr_enable);
+        }
+}
+
+static inline unsigned int get_nmi_count(int cpu)
+{
+        return cpu_data(cpu).__nmi_count;
+}
+
+static int endflag __initdata;
+
+static __init void nmi_cpu_busy(void *data)
+{
+        local_irq_enable_in_hardirq();
+        while (endflag == 0)
+                mb();
+}
+
+static void report_broken_nmi(int cpu, int *prev_nmi_count)
+{
+        printk(KERN_CONT "\n");
+
+        printk(KERN_WARNING
+                "WARNING: CPU#%d: NMI appears to be stuck (%d->%d)!\n",
+                        cpu, prev_nmi_count[cpu], get_nmi_count(cpu));
+
+        printk(KERN_WARNING
+                "Please report this to bugzilla.kernel.org,\n");
+        printk(KERN_WARNING
+                "and attach the output of the 'dmesg' command.\n");
+
+        nmi_usable = 0;
+}
+
+static void stop_watchdog(void *unused)
+{
+        pcr_ops->write(PCR_PIC_PRIV);
+}
+
+static int __init check_nmi_watchdog(void)
+{
+        unsigned int *prev_nmi_count;
+        int cpu, err;
+
+        prev_nmi_count = kmalloc(nr_cpu_ids * sizeof(unsigned int), GFP_KERNEL);
+        if (!prev_nmi_count) {
+                err = -ENOMEM;
+                goto error;
+        }
+
+        printk(KERN_INFO "Testing NMI watchdog ... ");
+
+        smp_call_function(nmi_cpu_busy, (void *)&endflag, 0);
+
+        for_each_possible_cpu(cpu)
+                prev_nmi_count[cpu] = get_nmi_count(cpu);
+        local_irq_enable();
+        mdelay((20 * 1000) / nmi_hz); /* wait 20 ticks */
+
+        for_each_online_cpu(cpu) {
+                if (get_nmi_count(cpu) - prev_nmi_count[cpu] <= 5)
+                        report_broken_nmi(cpu, prev_nmi_count);
+        }
+        endflag = 1;
+        if (!nmi_usable) {
+                kfree(prev_nmi_count);
+                err = -ENODEV;
+                goto error;
+        }
+        printk("OK.\n");
+
+        nmi_hz = 1;
+
+        kfree(prev_nmi_count);
+        return 0;
+error:
+        on_each_cpu(stop_watchdog, NULL, 1);
+        return err;
+}
+
+static void start_watchdog(void *unused)
+{
+        pcr_ops->write(PCR_PIC_PRIV);
+        write_pic(picl_value(nmi_hz));
+
+        pcr_ops->write(pcr_enable);
+}
+
+void nmi_adjust_hz(unsigned int new_hz)
+{
+        nmi_hz = new_hz;
+        on_each_cpu(start_watchdog, NULL, 1);
+}
+EXPORT_SYMBOL_GPL(nmi_adjust_hz);
+
+int __init nmi_init(void)
+{
+        nmi_usable = 1;
+
+        on_each_cpu(start_watchdog, NULL, 1);
+
+        return check_nmi_watchdog();
+}
+
+static int __init setup_nmi_watchdog(char *str)
+{
+        if (!strncmp(str, "panic", 5))
+                panic_on_timeout = 1;
+
+        return 0;
+}
+__setup("nmi_watchdog=", setup_nmi_watchdog);
diff --git a/arch/sparc/kernel/pcr.c b/arch/sparc/kernel/pcr.c
new file mode 100644
index 000000000000..1ae8cdd7e703
--- /dev/null
+++ b/arch/sparc/kernel/pcr.c
@@ -0,0 +1,158 @@
+/* pcr.c: Generic sparc64 performance counter infrastructure.
+ *
+ * Copyright (C) 2009 David S. Miller (davem@davemloft.net)
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+
+#include <asm/pil.h>
+#include <asm/pcr.h>
+#include <asm/nmi.h>
+
+/* This code is shared between various users of the performance
+ * counters.  Users will be oprofile, pseudo-NMI watchdog, and the
+ * perf_counter support layer.
+ */
+
+#define PCR_SUN4U_ENABLE        (PCR_PIC_PRIV | PCR_STRACE | PCR_UTRACE)
+#define PCR_N2_ENABLE           (PCR_PIC_PRIV | PCR_STRACE | PCR_UTRACE | \
+                                 PCR_N2_TOE_OV1 | \
+                                 (2 << PCR_N2_SL1_SHIFT) | \
+                                 (0xff << PCR_N2_MASK1_SHIFT))
+
+u64 pcr_enable;
+unsigned int picl_shift;
+
+/* Performance counter interrupts run unmasked at PIL level 15.
+ * Therefore we can't do things like wakeups and other work
+ * that expects IRQ disabling to be adhered to in locking etc.
+ *
+ * Therefore in such situations we defer the work by signalling
+ * a lower level cpu IRQ.
+ */
+void deferred_pcr_work_irq(int irq, struct pt_regs *regs)
+{
+        clear_softint(1 << PIL_DEFERRED_PCR_WORK);
+}
+
+void schedule_deferred_pcr_work(void)
+{
+        set_softint(1 << PIL_DEFERRED_PCR_WORK);
+}
+
+const struct pcr_ops *pcr_ops;
+EXPORT_SYMBOL_GPL(pcr_ops);
+
+static u64 direct_pcr_read(void)
+{
+        u64 val;
+
+        read_pcr(val);
+        return val;
+}
+
+static void direct_pcr_write(u64 val)
+{
+        write_pcr(val);
+}
+
+static const struct pcr_ops direct_pcr_ops = {
+        .read   = direct_pcr_read,
+        .write  = direct_pcr_write,
+};
+
+static void n2_pcr_write(u64 val)
+{
+        unsigned long ret;
+
+        ret = sun4v_niagara2_setperf(HV_N2_PERF_SPARC_CTL, val);
+        if (val != HV_EOK)
+                write_pcr(val);
+}
+
+static const struct pcr_ops n2_pcr_ops = {
+        .read   = direct_pcr_read,
+        .write  = n2_pcr_write,
+};
+
+static unsigned long perf_hsvc_group;
+static unsigned long perf_hsvc_major;
+static unsigned long perf_hsvc_minor;
+
+static int __init register_perf_hsvc(void)
+{
+        if (tlb_type == hypervisor) {
+                switch (sun4v_chip_type) {
+                case SUN4V_CHIP_NIAGARA1:
+                        perf_hsvc_group = HV_GRP_NIAG_PERF;
+                        break;
+
+                case SUN4V_CHIP_NIAGARA2:
+                        perf_hsvc_group = HV_GRP_N2_CPU;
+                        break;
+
+                default:
+                        return -ENODEV;
+                }
+
+
+                perf_hsvc_major = 1;
+                perf_hsvc_minor = 0;
+                if (sun4v_hvapi_register(perf_hsvc_group,
+                                         perf_hsvc_major,
+                                         &perf_hsvc_minor)) {
+                        printk("perfmon: Could not register hvapi.\n");
+                        return -ENODEV;
+                }
+        }
+        return 0;
+}
+
+static void __init unregister_perf_hsvc(void)
+{
+        if (tlb_type != hypervisor)
+                return;
+        sun4v_hvapi_unregister(perf_hsvc_group);
+}
+
+int __init pcr_arch_init(void)
+{
+        int err = register_perf_hsvc();
+
+        if (err)
+                return err;
+
+        switch (tlb_type) {
+        case hypervisor:
+                pcr_ops = &n2_pcr_ops;
+                pcr_enable = PCR_N2_ENABLE;
+                picl_shift = 2;
+                break;
+
+        case cheetah:
+        case cheetah_plus:
+                pcr_ops = &direct_pcr_ops;
+                pcr_enable = PCR_SUN4U_ENABLE;
+                break;
+
+        case spitfire:
+                /* UltraSPARC-I/II and derivatives lack a profile
+                 * counter overflow interrupt so we can't make use of
+                 * their hardware currently.
+                 */
+                /* fallthrough */
+        default:
+                err = -ENODEV;
+                goto out_unregister;
+        }
+
+        return nmi_init();
+
+out_unregister:
+        unregister_perf_hsvc();
+        return err;
+}
+
+arch_initcall(pcr_arch_init);
diff --git a/arch/sparc/kernel/process_64.c b/arch/sparc/kernel/process_64.c
index cc8b5604442c..a73954b87f0a 100644
--- a/arch/sparc/kernel/process_64.c
+++ b/arch/sparc/kernel/process_64.c
@@ -29,6 +29,7 @@
 #include <linux/cpu.h>
 #include <linux/elfcore.h>
 #include <linux/sysrq.h>
+#include <linux/nmi.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -52,8 +53,10 @@
 
 static void sparc64_yield(int cpu)
 {
-        if (tlb_type != hypervisor)
+        if (tlb_type != hypervisor) {
+                touch_nmi_watchdog();
                 return;
+        }
 
         clear_thread_flag(TIF_POLLING_NRFLAG);
         smp_mb__after_clear_bit();
diff --git a/arch/sparc/kernel/setup_64.c b/arch/sparc/kernel/setup_64.c
index 49d061f4ae9d..f2bcfd2967d7 100644
--- a/arch/sparc/kernel/setup_64.c
+++ b/arch/sparc/kernel/setup_64.c
@@ -354,6 +354,7 @@ static int show_cpuinfo(struct seq_file *m, void *__unused)
         seq_printf(m, 
                    "cpu\t\t: %s\n"
                    "fpu\t\t: %s\n"
+                   "pmu\t\t: %s\n"
                    "prom\t\t: %s\n"
                    "type\t\t: %s\n"
                    "ncpus probed\t: %d\n"
@@ -366,6 +367,7 @@ static int show_cpuinfo(struct seq_file *m, void *__unused)
                    ,
                    sparc_cpu_type,
                    sparc_fpu_type,
+                   sparc_pmu_type,
                    prom_version,
                    ((tlb_type == hypervisor) ?
                     "sun4v" :
diff --git a/arch/sparc/kernel/sys_sparc_64.c b/arch/sparc/kernel/sys_sparc_64.c
index 09058fc39e73..e2d102447a43 100644
--- a/arch/sparc/kernel/sys_sparc_64.c
+++ b/arch/sparc/kernel/sys_sparc_64.c
@@ -399,7 +399,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm)
         }
 }
 
-asmlinkage unsigned long sparc_brk(unsigned long brk)
+SYSCALL_DEFINE1(sparc_brk, unsigned long, brk)
 {
         /* People could try to be nasty and use ta 0x6d in 32bit programs */
         if (test_thread_flag(TIF_32BIT) && brk >= STACK_TOP32)
@@ -415,7 +415,7 @@ asmlinkage unsigned long sparc_brk(unsigned long brk)
  * sys_pipe() is the normal C calling standard for creating
  * a pipe. It's not the way unix traditionally does this, though.
  */
-asmlinkage long sparc_pipe(struct pt_regs *regs)
+SYSCALL_DEFINE1(sparc_pipe_real, struct pt_regs *, regs)
 {
         int fd[2];
         int error;
@@ -435,8 +435,8 @@ out:
  * This is really horribly ugly.
  */
 
-asmlinkage long sys_ipc(unsigned int call, int first, unsigned long second,
-                        unsigned long third, void __user *ptr, long fifth)
+SYSCALL_DEFINE6(ipc, unsigned int, call, int, first, unsigned long, second,
+                unsigned long, third, void __user *, ptr, long, fifth)
 {
         long err;
 
@@ -519,7 +519,7 @@ out:
         return err;
 }
 
-asmlinkage long sparc64_newuname(struct new_utsname __user *name)
+SYSCALL_DEFINE1(sparc64_newuname, struct new_utsname __user *, name)
 {
         int ret = sys_newuname(name);
         
@@ -530,7 +530,7 @@ asmlinkage long sparc64_newuname(struct new_utsname __user *name)
         return ret;
 }
 
-asmlinkage long sparc64_personality(unsigned long personality)
+SYSCALL_DEFINE1(sparc64_personality, unsigned long, personality)
 {
         int ret;
 
@@ -564,9 +564,9 @@ int sparc_mmap_check(unsigned long addr, unsigned long len)
 }
 
 /* Linux version of mmap */
-asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
-        unsigned long prot, unsigned long flags, unsigned long fd,
-        unsigned long off)
+SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
+                unsigned long, prot, unsigned long, flags, unsigned long, fd,
+                unsigned long, off)
 {
         struct file * file = NULL;
         unsigned long retval = -EBADF;
@@ -589,7 +589,7 @@ out:
         return retval;
 }
 
-asmlinkage long sys64_munmap(unsigned long addr, size_t len)
+SYSCALL_DEFINE2(64_munmap, unsigned long, addr, size_t, len)
 {
         long ret;
 
@@ -606,9 +606,9 @@ extern unsigned long do_mremap(unsigned long addr,
         unsigned long old_len, unsigned long new_len,
         unsigned long flags, unsigned long new_addr);
                 
-asmlinkage unsigned long sys64_mremap(unsigned long addr,
-        unsigned long old_len, unsigned long new_len,
-        unsigned long flags, unsigned long new_addr)
+SYSCALL_DEFINE5(64_mremap, unsigned long, addr, unsigned long, old_len,
+                unsigned long, new_len, unsigned long, flags,
+                unsigned long, new_addr)
 {
         unsigned long ret = -EINVAL;
 
@@ -671,7 +671,7 @@ asmlinkage void sparc_breakpoint(struct pt_regs *regs)
 
 extern void check_pending(int signum);
 
-asmlinkage long sys_getdomainname(char __user *name, int len)
+SYSCALL_DEFINE2(getdomainname, char __user *, name, int, len)
 {
         int nlen, err;
 
@@ -694,11 +694,10 @@ out:
         return err;
 }
 
-asmlinkage long sys_utrap_install(utrap_entry_t type,
-                                  utrap_handler_t new_p,
-                                  utrap_handler_t new_d,
-                                  utrap_handler_t __user *old_p,
-                                  utrap_handler_t __user *old_d)
+SYSCALL_DEFINE5(utrap_install, utrap_entry_t, type,
+                utrap_handler_t, new_p, utrap_handler_t, new_d,
+                utrap_handler_t __user *, old_p,
+                utrap_handler_t __user *, old_d)
 {
         if (type < UT_INSTRUCTION_EXCEPTION || type > UT_TRAP_INSTRUCTION_31)
                 return -EINVAL;
@@ -764,11 +763,9 @@ asmlinkage long sparc_memory_ordering(unsigned long model,
         return 0;
 }
 
-asmlinkage long sys_rt_sigaction(int sig,
-                                 const struct sigaction __user *act,
-                                 struct sigaction __user *oact,
-                                 void __user *restorer,
-                                 size_t sigsetsize)
+SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
+                struct sigaction __user *, oact, void __user *, restorer,
+                size_t, sigsetsize)
 {
         struct k_sigaction new_ka, old_ka;
         int ret;
@@ -808,7 +805,8 @@ asmlinkage void update_perfctrs(void)
         reset_pic();
 }
 
-asmlinkage long sys_perfctr(int opcode, unsigned long arg0, unsigned long arg1, unsigned long arg2)
+SYSCALL_DEFINE4(perfctr, int, opcode, unsigned long, arg0,
+                unsigned long, arg1, unsigned long, arg2)
 {
         int err = 0;
 
diff --git a/arch/sparc/kernel/syscalls.S b/arch/sparc/kernel/syscalls.S
index 87f5a3b8a253..d150c2aa98d2 100644
--- a/arch/sparc/kernel/syscalls.S
+++ b/arch/sparc/kernel/syscalls.S
@@ -21,7 +21,7 @@ execve_merge:
 
         .align  32
 sys_sparc_pipe:
-        ba,pt   %xcc, sparc_pipe
+        ba,pt   %xcc, sys_sparc_pipe_real
          add    %sp, PTREGS_OFF, %o0
 sys_nis_syscall:
         ba,pt   %xcc, c_sys_nis_syscall
diff --git a/arch/sparc/kernel/systbls.h b/arch/sparc/kernel/systbls.h
index bc9f5dac4069..15c2d752b2bc 100644
--- a/arch/sparc/kernel/systbls.h
+++ b/arch/sparc/kernel/systbls.h
@@ -16,9 +16,6 @@ extern asmlinkage long sys_ipc(unsigned int call, int first,
                                void __user *ptr, long fifth);
 extern asmlinkage long sparc64_newuname(struct new_utsname __user *name);
 extern asmlinkage long sparc64_personality(unsigned long personality);
-extern asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
-                                         unsigned long prot, unsigned long flags,
-                                         unsigned long fd, unsigned long off);
 extern asmlinkage long sys64_munmap(unsigned long addr, size_t len);
 extern asmlinkage unsigned long sys64_mremap(unsigned long addr,
                                              unsigned long old_len,
diff --git a/arch/sparc/kernel/systbls_64.S b/arch/sparc/kernel/systbls_64.S
index e6007bb37046..f93c42a2b522 100644
--- a/arch/sparc/kernel/systbls_64.S
+++ b/arch/sparc/kernel/systbls_64.S
@@ -21,7 +21,7 @@ sys_call_table32:
 /*0*/   .word sys_restart_syscall, sys32_exit, sys_fork, sys_read, sys_write
 /*5*/   .word sys32_open, sys_close, sys32_wait4, sys32_creat, sys_link
 /*10*/  .word sys_unlink, sunos_execv, sys_chdir, sys_chown16, sys32_mknod
-/*15*/  .word sys_chmod, sys_lchown16, sparc_brk, sys32_perfctr, sys32_lseek
+/*15*/  .word sys_chmod, sys_lchown16, sys_sparc_brk, sys32_perfctr, sys32_lseek
 /*20*/  .word sys_getpid, sys_capget, sys_capset, sys_setuid16, sys_getuid16
 /*25*/  .word sys32_vmsplice, compat_sys_ptrace, sys_alarm, sys32_sigaltstack, sys_pause
 /*30*/  .word compat_sys_utime, sys_lchown, sys_fchown, sys32_access, sys32_nice
@@ -55,8 +55,8 @@ sys_call_table32:
 /*170*/ .word sys32_lsetxattr, sys32_fsetxattr, sys_getxattr, sys_lgetxattr, compat_sys_getdents
         .word sys_setsid, sys_fchdir, sys32_fgetxattr, sys_listxattr, sys_llistxattr
 /*180*/ .word sys32_flistxattr, sys_removexattr, sys_lremovexattr, compat_sys_sigpending, sys_ni_syscall
-        .word sys32_setpgid, sys32_fremovexattr, sys32_tkill, sys32_exit_group, sparc64_newuname
-/*190*/ .word sys32_init_module, sparc64_personality, sys_remap_file_pages, sys32_epoll_create, sys32_epoll_ctl
+        .word sys32_setpgid, sys32_fremovexattr, sys32_tkill, sys32_exit_group, sys_sparc64_newuname
+/*190*/ .word sys32_init_module, sys_sparc64_personality, sys_remap_file_pages, sys32_epoll_create, sys32_epoll_ctl
         .word sys32_epoll_wait, sys32_ioprio_set, sys_getppid, sys32_sigaction, sys_sgetmask
 /*200*/ .word sys32_ssetmask, sys_sigsuspend, compat_sys_newlstat, sys_uselib, compat_sys_old_readdir
         .word sys32_readahead, sys32_socketcall, sys32_syslog, sys32_lookup_dcookie, sys32_fadvise64
@@ -95,7 +95,7 @@ sys_call_table:
 /*0*/   .word sys_restart_syscall, sparc_exit, sys_fork, sys_read, sys_write
 /*5*/   .word sys_open, sys_close, sys_wait4, sys_creat, sys_link
 /*10*/  .word sys_unlink, sys_nis_syscall, sys_chdir, sys_chown, sys_mknod
-/*15*/  .word sys_chmod, sys_lchown, sparc_brk, sys_perfctr, sys_lseek
+/*15*/  .word sys_chmod, sys_lchown, sys_sparc_brk, sys_perfctr, sys_lseek
 /*20*/  .word sys_getpid, sys_capget, sys_capset, sys_setuid, sys_getuid
 /*25*/  .word sys_vmsplice, sys_ptrace, sys_alarm, sys_sigaltstack, sys_nis_syscall
 /*30*/  .word sys_utime, sys_nis_syscall, sys_nis_syscall, sys_access, sys_nice
@@ -106,7 +106,7 @@ sys_call_table:
         .word sys_reboot, sys_nis_syscall, sys_symlink, sys_readlink, sys_execve
 /*60*/  .word sys_umask, sys_chroot, sys_newfstat, sys_fstat64, sys_getpagesize
         .word sys_msync, sys_vfork, sys_pread64, sys_pwrite64, sys_nis_syscall
-/*70*/  .word sys_nis_syscall, sys_mmap, sys_nis_syscall, sys64_munmap, sys_mprotect
+/*70*/  .word sys_nis_syscall, sys_mmap, sys_nis_syscall, sys_64_munmap, sys_mprotect
         .word sys_madvise, sys_vhangup, sys_nis_syscall, sys_mincore, sys_getgroups
 /*80*/  .word sys_setgroups, sys_getpgrp, sys_nis_syscall, sys_setitimer, sys_nis_syscall
         .word sys_swapon, sys_getitimer, sys_nis_syscall, sys_sethostname, sys_nis_syscall
@@ -129,8 +129,8 @@ sys_call_table:
 /*170*/ .word sys_lsetxattr, sys_fsetxattr, sys_getxattr, sys_lgetxattr, sys_getdents
         .word sys_setsid, sys_fchdir, sys_fgetxattr, sys_listxattr, sys_llistxattr
 /*180*/ .word sys_flistxattr, sys_removexattr, sys_lremovexattr, sys_nis_syscall, sys_ni_syscall
-        .word sys_setpgid, sys_fremovexattr, sys_tkill, sys_exit_group, sparc64_newuname
-/*190*/ .word sys_init_module, sparc64_personality, sys_remap_file_pages, sys_epoll_create, sys_epoll_ctl
+        .word sys_setpgid, sys_fremovexattr, sys_tkill, sys_exit_group, sys_sparc64_newuname
+/*190*/ .word sys_init_module, sys_sparc64_personality, sys_remap_file_pages, sys_epoll_create, sys_epoll_ctl
         .word sys_epoll_wait, sys_ioprio_set, sys_getppid, sys_nis_syscall, sys_sgetmask
 /*200*/ .word sys_ssetmask, sys_nis_syscall, sys_newlstat, sys_uselib, sys_nis_syscall
         .word sys_readahead, sys_socketcall, sys_syslog, sys_lookup_dcookie, sys_fadvise64
@@ -142,7 +142,7 @@ sys_call_table:
         .word sys_fstatfs64, sys_llseek, sys_mlock, sys_munlock, sys_mlockall
 /*240*/ .word sys_munlockall, sys_sched_setparam, sys_sched_getparam, sys_sched_setscheduler, sys_sched_getscheduler
         .word sys_sched_yield, sys_sched_get_priority_max, sys_sched_get_priority_min, sys_sched_rr_get_interval, sys_nanosleep
-/*250*/ .word sys64_mremap, sys_sysctl, sys_getsid, sys_fdatasync, sys_nfsservctl
+/*250*/ .word sys_64_mremap, sys_sysctl, sys_getsid, sys_fdatasync, sys_nfsservctl
         .word sys_sync_file_range, sys_clock_settime, sys_clock_gettime, sys_clock_getres, sys_clock_nanosleep
 /*260*/ .word sys_sched_getaffinity, sys_sched_setaffinity, sys_timer_settime, sys_timer_gettime, sys_timer_getoverrun
         .word sys_timer_delete, sys_timer_create, sys_ni_syscall, sys_io_setup, sys_io_destroy
diff --git a/arch/sparc/kernel/time_64.c b/arch/sparc/kernel/time_64.c
index 2db3c2229b95..642562d83ec4 100644
--- a/arch/sparc/kernel/time_64.c
+++ b/arch/sparc/kernel/time_64.c
@@ -36,10 +36,10 @@
 #include <linux/clocksource.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
+#include <linux/irq.h>
 
 #include <asm/oplib.h>
 #include <asm/timer.h>
-#include <asm/irq.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/starfire.h>
diff --git a/arch/sparc/kernel/traps_64.c b/arch/sparc/kernel/traps_64.c
index c2d153d46586..d809c4ebb48f 100644
--- a/arch/sparc/kernel/traps_64.c
+++ b/arch/sparc/kernel/traps_64.c
@@ -1,6 +1,6 @@
 /* arch/sparc64/kernel/traps.c
  *
- * Copyright (C) 1995,1997,2008 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 1995,1997,2008,2009 David S. Miller (davem@davemloft.net)
  * Copyright (C) 1997,1999,2000 Jakub Jelinek (jakub@redhat.com)
  */
 
@@ -314,6 +314,21 @@ void sun4v_data_access_exception(struct pt_regs *regs, unsigned long addr, unsig
                 return;
 
         if (regs->tstate & TSTATE_PRIV) {
+                /* Test if this comes from uaccess places. */
+                const struct exception_table_entry *entry;
+
+                entry = search_exception_tables(regs->tpc);
+                if (entry) {
+                        /* Ouch, somebody is trying VM hole tricks on us... */
+#ifdef DEBUG_EXCEPTIONS
+                        printk("Exception: PC<%016lx> faddr<UNKNOWN>\n", regs->tpc);
+                        printk("EX_TABLE: insn<%016lx> fixup<%016lx>\n",
+                               regs->tpc, entry->fixup);
+#endif
+                        regs->tpc = entry->fixup;
+                        regs->tnpc = regs->tpc + 4;
+                        return;
+                }
                 printk("sun4v_data_access_exception: ADDR[%016lx] "
                        "CTX[%04x] TYPE[%04x], going.\n",
                        addr, ctx, type);
diff --git a/arch/sparc/kernel/ttable.S b/arch/sparc/kernel/ttable.S
index ea925503b42e..d9bdfb9d5c18 100644
--- a/arch/sparc/kernel/ttable.S
+++ b/arch/sparc/kernel/ttable.S
@@ -63,7 +63,8 @@ tl0_irq6:	TRAP_IRQ(smp_call_function_single_client, 6)
 #else
 tl0_irq6:       BTRAP(0x46)
 #endif
-tl0_irq7:       BTRAP(0x47) BTRAP(0x48) BTRAP(0x49)
+tl0_irq7:       TRAP_IRQ(deferred_pcr_work_irq, 7)
+tl0_irq8:       BTRAP(0x48) BTRAP(0x49)
 tl0_irq10:      BTRAP(0x4a) BTRAP(0x4b) BTRAP(0x4c) BTRAP(0x4d)
 tl0_irq14:      TRAP_IRQ(timer_interrupt, 14)
 tl0_irq15:      TRAP_NMI_IRQ(perfctr_irq, 15)