Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

author: Andrea Bastoni <bastoni@cs.unc.edu> 2010-05-30 19:16:45 -0400
committer: Andrea Bastoni <bastoni@cs.unc.edu> 2010-05-30 19:16:45 -0400
commit: ada47b5fe13d89735805b566185f4885f5a3f750 (patch)
tree: 644b88f8a71896307d71438e9b3af49126ffb22b /arch/sparc/kernel
parent: 43e98717ad40a4ae64545b5ba047c7b86aa44f4f (diff)
parent: 3280f21d43ee541f97f8cda5792150d2dbec20d5 (diff)
75 files changed, 2464 insertions, 1204 deletions
diff --git a/arch/sparc/kernel/Makefile b/arch/sparc/kernel/Makefile
index 5b47fab9966e..0c2dc1f24a9a 100644
--- a/arch/sparc/kernel/Makefile
+++ b/arch/sparc/kernel/Makefile
@@ -13,6 +13,14 @@ extra-y     += init_task.o
 CPPFLAGS_vmlinux.lds := -Usparc -m$(BITS)
 extra-y              += vmlinux.lds
+ifdef CONFIG_FUNCTION_TRACER
+# Do not profile debug and lowlevel utilities
+CFLAGS_REMOVE_ftrace.o := -pg
+CFLAGS_REMOVE_time_$(BITS).o := -pg
+CFLAGS_REMOVE_perf_event.o := -pg
+CFLAGS_REMOVE_pcr.o := -pg
+endif
 obj-$(CONFIG_SPARC32)   += entry.o wof.o wuf.o
 obj-$(CONFIG_SPARC32)   += etrap_32.o
 obj-$(CONFIG_SPARC32)   += rtrap_32.o
@@ -72,7 +80,7 @@ obj-y                     += dma.o
 obj-$(CONFIG_SPARC32_PCI) += pcic.o
 obj-$(CONFIG_SMP)         += trampoline_$(BITS).o smp_$(BITS).o
-obj-$(CONFIG_SPARC32_SMP) += sun4m_smp.o sun4d_smp.o
+obj-$(CONFIG_SPARC32_SMP) += sun4m_smp.o sun4d_smp.o leon_smp.o
 obj-$(CONFIG_SPARC64_SMP) += hvtramp.o
 obj-y                     += auxio_$(BITS).o
@@ -85,8 +93,9 @@ obj-$(CONFIG_KGDB)        += kgdb_$(BITS).o
 obj-$(CONFIG_DYNAMIC_FTRACE) += ftrace.o
-CFLAGS_REMOVE_ftrace.o := -pg
+obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o
+obj-$(CONFIG_EARLYFB) += btext.o
 obj-$(CONFIG_STACKTRACE)     += stacktrace.o
 # sparc64 PCI
 obj-$(CONFIG_SPARC64_PCI)    += pci.o pci_common.o psycho_common.o
diff --git a/arch/sparc/kernel/apc.c b/arch/sparc/kernel/apc.c
index 9c115823c4b5..71ec90b9e316 100644
--- a/arch/sparc/kernel/apc.c
+++ b/arch/sparc/kernel/apc.c
@@ -10,7 +10,6 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/miscdevice.h>
-#include <linux/smp_lock.h>
 #include <linux/pm.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
@@ -76,7 +75,6 @@ static inline void apc_free(struct of_device *op)
 static int apc_open(struct inode *inode, struct file *f)
 {
-        cycle_kernel_lock();
        return 0;
 }
@@ -87,61 +85,46 @@ static int apc_release(struct inode *inode, struct file *f)
 static long apc_ioctl(struct file *f, unsigned int cmd, unsigned long __arg)
 {
-        __u8 inarg, __user *arg;
+        __u8 inarg, __user *arg = (__u8 __user *) __arg;
-        arg = (__u8 __user *) __arg;
-        lock_kernel();
        switch (cmd) {
        case APCIOCGFANCTL:
-                if (put_user(apc_readb(APC_FANCTL_REG) & APC_REGMASK, arg)) {
+                if (put_user(apc_readb(APC_FANCTL_REG) & APC_REGMASK, arg))
-                        unlock_kernel();
                        return -EFAULT;
-                }
                break;
        case APCIOCGCPWR:
-                if (put_user(apc_readb(APC_CPOWER_REG) & APC_REGMASK, arg)) {
+                if (put_user(apc_readb(APC_CPOWER_REG) & APC_REGMASK, arg))
-                        unlock_kernel();
                        return -EFAULT;
-                }
                break;
        case APCIOCGBPORT:
-                if (put_user(apc_readb(APC_BPORT_REG) & APC_BPMASK, arg)) {
+                if (put_user(apc_readb(APC_BPORT_REG) & APC_BPMASK, arg))
-                        unlock_kernel();
                        return -EFAULT;
-                }
                break;
        case APCIOCSFANCTL:
-                if (get_user(inarg, arg)) {
+                if (get_user(inarg, arg))
-                        unlock_kernel();
                        return -EFAULT;
-                }
                apc_writeb(inarg & APC_REGMASK, APC_FANCTL_REG);
                break;
        case APCIOCSCPWR:
-                if (get_user(inarg, arg)) {
+                if (get_user(inarg, arg))
-                        unlock_kernel();
                        return -EFAULT;
-                }
                apc_writeb(inarg & APC_REGMASK, APC_CPOWER_REG);
                break;
        case APCIOCSBPORT:
-                if (get_user(inarg, arg)) {
+                if (get_user(inarg, arg))
-                        unlock_kernel();
                        return -EFAULT;
-                }
                apc_writeb(inarg & APC_BPMASK, APC_BPORT_REG);
                break;
        default:
-                unlock_kernel();
                return -EINVAL;
        };
-        unlock_kernel();
        return 0;
 }
diff --git a/arch/sparc/kernel/auxio_32.c b/arch/sparc/kernel/auxio_32.c
index 45c41232fc4c..ee8d214cae1e 100644
--- a/arch/sparc/kernel/auxio_32.c
+++ b/arch/sparc/kernel/auxio_32.c
@@ -28,6 +28,7 @@ void __init auxio_probe(void)
        struct resource r;
        switch (sparc_cpu_model) {
+        case sparc_leon:
        case sun4d:
        case sun4:
                return;
diff --git a/arch/sparc/kernel/btext.c b/arch/sparc/kernel/btext.c
new file mode 100644
index 000000000000..8cc2d56ffe9a
--- /dev/null
+++ b/arch/sparc/kernel/btext.c
@@ -0,0 +1,673 @@
+/*
+ * Procedures for drawing on the screen early on in the boot process.
+ *
+ * Benjamin Herrenschmidt <benh@kernel.crashing.org>
+ */
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/console.h>
+#include <asm/btext.h>
+#include <asm/oplib.h>
+#include <asm/io.h>
+#define NO_SCROLL
+#ifndef NO_SCROLL
+static void scrollscreen(void);
+#endif
+static void draw_byte(unsigned char c, long locX, long locY);
+static void draw_byte_32(unsigned char *bits, unsigned int *base, int rb);
+static void draw_byte_16(unsigned char *bits, unsigned int *base, int rb);
+static void draw_byte_8(unsigned char *bits, unsigned int *base, int rb);
+#define __force_data __attribute__((__section__(".data")))
+static int g_loc_X __force_data;
+static int g_loc_Y __force_data;
+static int g_max_loc_X __force_data;
+static int g_max_loc_Y __force_data;
+static int dispDeviceRowBytes __force_data;
+static int dispDeviceDepth  __force_data;
+static int dispDeviceRect[4] __force_data;
+static unsigned char *dispDeviceBase __force_data;
+#define cmapsz  (16*256)
+static unsigned char vga_font[cmapsz];
+static int __init btext_initialize(unsigned int node)
+{
+        unsigned int width, height, depth, pitch;
+        unsigned long address = 0;
+        u32 prop;
+        if (prom_getproperty(node, "width", (char *)&width, 4) < 0)
+                return -EINVAL;
+        if (prom_getproperty(node, "height", (char *)&height, 4) < 0)
+                return -EINVAL;
+        if (prom_getproperty(node, "depth", (char *)&depth, 4) < 0)
+                return -EINVAL;
+        pitch = width * ((depth + 7) / 8);
+        if (prom_getproperty(node, "linebytes", (char *)&prop, 4) >= 0 &&
+            prop != 0xffffffffu)
+                pitch = prop;
+        if (pitch == 1)
+                pitch = 0x1000;
+        if (prom_getproperty(node, "address", (char *)&prop, 4) >= 0)
+                address = prop;
+        /* FIXME: Add support for PCI reg properties. Right now, only
+         * reliable on macs
+         */
+        if (address == 0)
+                return -EINVAL;
+        g_loc_X = 0;
+        g_loc_Y = 0;
+        g_max_loc_X = width / 8;
+        g_max_loc_Y = height / 16;
+        dispDeviceBase = (unsigned char *)address;
+        dispDeviceRowBytes = pitch;
+        dispDeviceDepth = depth == 15 ? 16 : depth;
+        dispDeviceRect[0] = dispDeviceRect[1] = 0;
+        dispDeviceRect[2] = width;
+        dispDeviceRect[3] = height;
+        return 0;
+}
+/* Calc the base address of a given point (x,y) */
+static unsigned char * calc_base(int x, int y)
+{
+        unsigned char *base = dispDeviceBase;
+        base += (x + dispDeviceRect[0]) * (dispDeviceDepth >> 3);
+        base += (y + dispDeviceRect[1]) * dispDeviceRowBytes;
+        return base;
+}
+static void btext_clearscreen(void)
+{
+        unsigned int *base      = (unsigned int *)calc_base(0, 0);
+        unsigned long width     = ((dispDeviceRect[2] - dispDeviceRect[0]) *
+                                        (dispDeviceDepth >> 3)) >> 2;
+        int i,j;
+        for (i=0; i<(dispDeviceRect[3] - dispDeviceRect[1]); i++)
+        {
+                unsigned int *ptr = base;
+                for(j=width; j; --j)
+                        *(ptr++) = 0;
+                base += (dispDeviceRowBytes >> 2);
+        }
+}
+#ifndef NO_SCROLL
+static void scrollscreen(void)
+{
+        unsigned int *src       = (unsigned int *)calc_base(0,16);
+        unsigned int *dst       = (unsigned int *)calc_base(0,0);
+        unsigned long width     = ((dispDeviceRect[2] - dispDeviceRect[0]) *
+                                   (dispDeviceDepth >> 3)) >> 2;
+        int i,j;
+        for (i=0; i<(dispDeviceRect[3] - dispDeviceRect[1] - 16); i++)
+        {
+                unsigned int *src_ptr = src;
+                unsigned int *dst_ptr = dst;
+                for(j=width; j; --j)
+                        *(dst_ptr++) = *(src_ptr++);
+                src += (dispDeviceRowBytes >> 2);
+                dst += (dispDeviceRowBytes >> 2);
+        }
+        for (i=0; i<16; i++)
+        {
+                unsigned int *dst_ptr = dst;
+                for(j=width; j; --j)
+                        *(dst_ptr++) = 0;
+                dst += (dispDeviceRowBytes >> 2);
+        }
+}
+#endif /* ndef NO_SCROLL */
+void btext_drawchar(char c)
+{
+        int cline = 0;
+#ifdef NO_SCROLL
+        int x;
+#endif
+        switch (c) {
+        case '\b':
+                if (g_loc_X > 0)
+                        --g_loc_X;
+                break;
+        case '\t':
+                g_loc_X = (g_loc_X & -8) + 8;
+                break;
+        case '\r':
+                g_loc_X = 0;
+                break;
+        case '\n':
+                g_loc_X = 0;
+                g_loc_Y++;
+                cline = 1;
+                break;
+        default:
+                draw_byte(c, g_loc_X++, g_loc_Y);
+        }
+        if (g_loc_X >= g_max_loc_X) {
+                g_loc_X = 0;
+                g_loc_Y++;
+                cline = 1;
+        }
+#ifndef NO_SCROLL
+        while (g_loc_Y >= g_max_loc_Y) {
+                scrollscreen();
+                g_loc_Y--;
+        }
+#else
+        /* wrap around from bottom to top of screen so we don't
+           waste time scrolling each line.  -- paulus. */
+        if (g_loc_Y >= g_max_loc_Y)
+                g_loc_Y = 0;
+        if (cline) {
+                for (x = 0; x < g_max_loc_X; ++x)
+                        draw_byte(' ', x, g_loc_Y);
+        }
+#endif
+}
+static void btext_drawtext(const char *c, unsigned int len)
+{
+        while (len--)
+                btext_drawchar(*c++);
+}
+static void draw_byte(unsigned char c, long locX, long locY)
+{
+        unsigned char *base     = calc_base(locX << 3, locY << 4);
+        unsigned char *font     = &vga_font[((unsigned int)c) * 16];
+        int rb                  = dispDeviceRowBytes;
+        switch(dispDeviceDepth) {
+        case 24:
+        case 32:
+                draw_byte_32(font, (unsigned int *)base, rb);
+                break;
+        case 15:
+        case 16:
+                draw_byte_16(font, (unsigned int *)base, rb);
+                break;
+        case 8:
+                draw_byte_8(font, (unsigned int *)base, rb);
+                break;
+        }
+}
+static unsigned int expand_bits_8[16] = {
+        0x00000000,
+        0x000000ff,
+        0x0000ff00,
+        0x0000ffff,
+        0x00ff0000,
+        0x00ff00ff,
+        0x00ffff00,
+        0x00ffffff,
+        0xff000000,
+        0xff0000ff,
+        0xff00ff00,
+        0xff00ffff,
+        0xffff0000,
+        0xffff00ff,
+        0xffffff00,
+        0xffffffff
+};
+static unsigned int expand_bits_16[4] = {
+        0x00000000,
+        0x0000ffff,
+        0xffff0000,
+        0xffffffff
+};
+static void draw_byte_32(unsigned char *font, unsigned int *base, int rb)
+{
+        int l, bits;
+        int fg = 0xFFFFFFFFUL;
+        int bg = 0x00000000UL;
+        for (l = 0; l < 16; ++l)
+        {
+                bits = *font++;
+                base[0] = (-(bits >> 7) & fg) ^ bg;
+                base[1] = (-((bits >> 6) & 1) & fg) ^ bg;
+                base[2] = (-((bits >> 5) & 1) & fg) ^ bg;
+                base[3] = (-((bits >> 4) & 1) & fg) ^ bg;
+                base[4] = (-((bits >> 3) & 1) & fg) ^ bg;
+                base[5] = (-((bits >> 2) & 1) & fg) ^ bg;
+                base[6] = (-((bits >> 1) & 1) & fg) ^ bg;
+                base[7] = (-(bits & 1) & fg) ^ bg;
+                base = (unsigned int *) ((char *)base + rb);
+        }
+}
+static void draw_byte_16(unsigned char *font, unsigned int *base, int rb)
+{
+        int l, bits;
+        int fg = 0xFFFFFFFFUL;
+        int bg = 0x00000000UL;
+        unsigned int *eb = (int *)expand_bits_16;
+        for (l = 0; l < 16; ++l)
+        {
+                bits = *font++;
+                base[0] = (eb[bits >> 6] & fg) ^ bg;
+                base[1] = (eb[(bits >> 4) & 3] & fg) ^ bg;
+                base[2] = (eb[(bits >> 2) & 3] & fg) ^ bg;
+                base[3] = (eb[bits & 3] & fg) ^ bg;
+                base = (unsigned int *) ((char *)base + rb);
+        }
+}
+static void draw_byte_8(unsigned char *font, unsigned int *base, int rb)
+{
+        int l, bits;
+        int fg = 0x0F0F0F0FUL;
+        int bg = 0x00000000UL;
+        unsigned int *eb = (int *)expand_bits_8;
+        for (l = 0; l < 16; ++l)
+        {
+                bits = *font++;
+                base[0] = (eb[bits >> 4] & fg) ^ bg;
+                base[1] = (eb[bits & 0xf] & fg) ^ bg;
+                base = (unsigned int *) ((char *)base + rb);
+        }
+}
+static void btext_console_write(struct console *con, const char *s,
+                                unsigned int n)
+{
+        btext_drawtext(s, n);
+}
+static struct console btext_console = {
+        .name   = "btext",
+        .write  = btext_console_write,
+        .flags  = CON_PRINTBUFFER | CON_ENABLED | CON_BOOT | CON_ANYTIME,
+        .index  = 0,
+};
+int __init btext_find_display(void)
+{
+        unsigned int node;
+        char type[32];
+        int ret;
+        node = prom_inst2pkg(prom_stdout);
+        if (prom_getproperty(node, "device_type", type, 32) < 0)
+                return -ENODEV;
+        if (strcmp(type, "display"))
+                return -ENODEV;
+        ret = btext_initialize(node);
+        if (!ret) {
+                btext_clearscreen();
+                register_console(&btext_console);
+        }
+        return ret;
+}
+static unsigned char vga_font[cmapsz] = {
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0x81, 0xbd,
+0x99, 0x81, 0x81, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xff,
+0xdb, 0xff, 0xff, 0xc3, 0xe7, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe,
+0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
+0x3c, 0x3c, 0xe7, 0xe7, 0xe7, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x7e, 0x18, 0x18, 0x3c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c,
+0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00,
+0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd,
+0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x1e, 0x0e,
+0x1a, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x33, 0x3f, 0x30, 0x30, 0x30,
+0x30, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x63,
+0x7f, 0x63, 0x63, 0x63, 0x63, 0x67, 0xe7, 0xe6, 0xc0, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfe, 0xf8,
+0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x0e,
+0x1e, 0x3e, 0xfe, 0x3e, 0x1e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
+0x66, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xdb,
+0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c, 0xc6,
+0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c,
+0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,
+0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c,
+0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x24, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c,
+0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00,
+0x18, 0x18, 0x7c, 0xc6, 0xc2, 0xc0, 0x7c, 0x06, 0x06, 0x86, 0xc6, 0x7c,
+0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc2, 0xc6, 0x0c, 0x18,
+0x30, 0x60, 0xc6, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c,
+0x6c, 0x38, 0x76, 0xdc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x30, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30,
+0x30, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x18,
+0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e,
+0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xce, 0xde, 0xf6, 0xe6, 0xc6, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,
+0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, 0x06, 0x06, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc, 0xfe,
+0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0,
+0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x38, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0x06, 0x06, 0x0c, 0x18,
+0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,
+0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x0c, 0x78,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00,
+0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x06,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00,
+0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60,
+0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x0c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xde, 0xde,
+0xde, 0xdc, 0xc0, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38,
+0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x66, 0x66, 0x66, 0x66, 0xfc,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xc0,
+0xc0, 0xc2, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x6c,
+0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6c, 0xf8, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x62, 0x66, 0xfe,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68,
+0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66,
+0xc2, 0xc0, 0xc0, 0xde, 0xc6, 0xc6, 0x66, 0x3a, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x0c,
+0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xe6, 0x66, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0x66, 0xe6,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x60, 0x60, 0x60, 0x60, 0x60,
+0x60, 0x62, 0x66, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xe7,
+0xff, 0xff, 0xdb, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, 0xc6, 0xc6,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,
+0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x66,
+0x66, 0x66, 0x7c, 0x60, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xde, 0x7c,
+0x0c, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x6c,
+0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6,
+0xc6, 0x60, 0x38, 0x0c, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xff, 0xdb, 0x99, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,
+0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3,
+0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xdb, 0xdb, 0xff, 0x66, 0x66,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0x66, 0x3c, 0x18, 0x18,
+0x3c, 0x66, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3,
+0xc3, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xff, 0xc3, 0x86, 0x0c, 0x18, 0x30, 0x60, 0xc1, 0xc3, 0xff,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30,
+0x30, 0x30, 0x30, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
+0xc0, 0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c,
+0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00,
+0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c, 0x7c,
+0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x60,
+0x60, 0x78, 0x6c, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x0c, 0x0c, 0x3c, 0x6c, 0xcc,
+0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, 0x60, 0x60, 0xf0,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc,
+0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xcc, 0x78, 0x00, 0x00, 0x00, 0xe0, 0x60,
+0x60, 0x6c, 0x76, 0x66, 0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x00, 0x0e, 0x06, 0x06,
+0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00, 0xe0, 0x60,
+0x60, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6, 0xff, 0xdb,
+0xdb, 0xdb, 0xdb, 0xdb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66,
+0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x76, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0x0c, 0x1e, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x76, 0x66, 0x60, 0x60, 0x60, 0xf0,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0x60,
+0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x30,
+0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3,
+0xc3, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xc3, 0xc3, 0xc3, 0xdb, 0xdb, 0xff, 0x66, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18, 0x3c, 0x66, 0xc3,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6,
+0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xfe, 0xcc, 0x18, 0x30, 0x60, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x0e, 0x18, 0x18, 0x18, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0e,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x18,
+0x18, 0x18, 0x0e, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6,
+0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66,
+0xc2, 0xc0, 0xc0, 0xc0, 0xc2, 0x66, 0x3c, 0x0c, 0x06, 0x7c, 0x00, 0x00,
+0x00, 0x00, 0xcc, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xfe,
+0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c,
+0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xcc, 0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0x78, 0x0c, 0x7c,
+0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38,
+0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x60, 0x60, 0x66, 0x3c, 0x0c, 0x06,
+0x3c, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xfe,
+0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00,
+0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x38, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x66,
+0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6,
+0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00,
+0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00,
+0x18, 0x30, 0x60, 0x00, 0xfe, 0x66, 0x60, 0x7c, 0x60, 0x60, 0x66, 0xfe,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x3b, 0x1b,
+0x7e, 0xd8, 0xdc, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x6c,
+0xcc, 0xcc, 0xfe, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x00, 0x7c, 0xc6, 0xc6,
+0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18,
+0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x30, 0x78, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0xcc, 0xcc, 0xcc,
+0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00,
+0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0x78, 0x00,
+0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,
+0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e,
+0xc3, 0xc0, 0xc0, 0xc0, 0xc3, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, 0x60, 0x60, 0xe6, 0xfc,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18, 0xff, 0x18,
+0xff, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x66, 0x66,
+0x7c, 0x62, 0x66, 0x6f, 0x66, 0x66, 0x66, 0xf3, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x0e, 0x1b, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18,
+0xd8, 0x70, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x00, 0x78, 0x0c, 0x7c,
+0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30,
+0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x18, 0x30, 0x60, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x00, 0xcc, 0xcc, 0xcc,
+0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc,
+0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00,
+0x76, 0xdc, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, 0xc6,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x6c, 0x6c, 0x3e, 0x00, 0x7e, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x6c,
+0x38, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x60, 0xc0, 0xc6, 0xc6, 0x7c,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0,
+0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0xfe, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, 0x60, 0xce, 0x9b, 0x06,
+0x0c, 0x1f, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30,
+0x66, 0xce, 0x96, 0x3e, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18,
+0x00, 0x18, 0x18, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36,
+0x6c, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x44, 0x11, 0x44,
+0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44,
+0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa,
+0x55, 0xaa, 0x55, 0xaa, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77,
+0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0xf8,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36,
+0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0xf6,
+0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37,
+0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xff,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36,
+0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f,
+0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
+0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0,
+0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
+0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x76, 0xdc, 0xd8, 0xd8, 0xd8, 0xdc, 0x76, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xd8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0,
+0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0xfe, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0xfe, 0xc6, 0x60, 0x30, 0x18, 0x30, 0x60, 0xc6, 0xfe,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xd8, 0xd8,
+0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x66, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xc0, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x18, 0x3c, 0x66, 0x66,
+0x66, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38,
+0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x6c, 0x6c, 0x6c, 0x6c, 0xee,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x30, 0x18, 0x0c, 0x3e, 0x66,
+0x66, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x7e, 0xdb, 0xdb, 0xdb, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x03, 0x06, 0x7e, 0xdb, 0xdb, 0xf3, 0x7e, 0x60, 0xc0,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x30, 0x60, 0x60, 0x7c, 0x60,
+0x60, 0x60, 0x30, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c,
+0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18,
+0x18, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,
+0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x00, 0x7e,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x1b, 0x1b, 0x1b, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
+0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x7e, 0x00, 0x18, 0x18, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00,
+0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x6c,
+0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c,
+0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x6c, 0x3c, 0x1c, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xd8, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xd8, 0x30, 0x60, 0xc8, 0xf8, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00,
+};
diff --git a/arch/sparc/kernel/central.c b/arch/sparc/kernel/central.c
index f3b5466c389c..415c86d5a8da 100644
--- a/arch/sparc/kernel/central.c
+++ b/arch/sparc/kernel/central.c
@@ -5,6 +5,7 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/of_device.h>
@@ -99,7 +100,7 @@ static int __devinit clock_board_probe(struct of_device *op,
        p->leds_resource.start = (unsigned long)
                (p->clock_regs + CLOCK_CTRL);
-        p->leds_resource.end = p->leds_resource.end;
+        p->leds_resource.end = p->leds_resource.start;
        p->leds_resource.name = "leds";
        p->leds_pdev.name = "sunfire-clockboard-leds";
@@ -194,7 +195,7 @@ static int __devinit fhc_probe(struct of_device *op,
        if (!p->central) {
                p->leds_resource.start = (unsigned long)
                        (p->pregs + FHC_PREGS_CTRL);
-                p->leds_resource.end = p->leds_resource.end;
+                p->leds_resource.end = p->leds_resource.start;
                p->leds_resource.name = "leds";
                p->leds_pdev.name = "sunfire-fhc-leds";
diff --git a/arch/sparc/kernel/cpu.c b/arch/sparc/kernel/cpu.c
index 1446df90ef85..e447938d39cf 100644
--- a/arch/sparc/kernel/cpu.c
+++ b/arch/sparc/kernel/cpu.c
@@ -185,6 +185,17 @@ static const struct manufacturer_info __initconst manufacturer_info[] = {
                FPU(-1, NULL)
        }
 },{
+        0xF,            /* Aeroflex Gaisler */
+        .cpu_info = {
+                CPU(3, "LEON"),
+                CPU(-1, NULL)
+        },
+        .fpu_info = {
+                FPU(2, "GRFPU"),
+                FPU(3, "GRFPU-Lite"),
+                FPU(-1, NULL)
+        }
+},{
        0x17,
        .cpu_info = {
                CPU_PMU(0x10, "TI UltraSparc I   (SpitFire)", "ultra12"),
diff --git a/arch/sparc/kernel/cpumap.c b/arch/sparc/kernel/cpumap.c
index 7430ed080b23..8de64c8126bc 100644
--- a/arch/sparc/kernel/cpumap.c
+++ b/arch/sparc/kernel/cpumap.c
@@ -4,6 +4,7 @@
 */
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/cpumask.h>
diff --git a/arch/sparc/kernel/devices.c b/arch/sparc/kernel/devices.c
index b171ae8de90d..62dc7a021413 100644
--- a/arch/sparc/kernel/devices.c
+++ b/arch/sparc/kernel/devices.c
@@ -59,7 +59,7 @@ static int __cpu_find_by(int (*compare)(int, int, void *), void *compare_arg,
        cur_inst = 0;
        for_each_node_by_type(dp, "cpu") {
-                int err = check_cpu_node(dp->node, &cur_inst,
+                int err = check_cpu_node(dp->phandle, &cur_inst,
                                         compare, compare_arg,
                                         prom_node, mid);
                if (!err) {
@@ -143,6 +143,4 @@ void __init device_scan(void)
        if (ARCH_SUN4C)
                sun4c_probe_memerr_reg();
-        return;
 }
diff --git a/arch/sparc/kernel/entry.S b/arch/sparc/kernel/entry.S
index f41ecc5ac0b4..1504df8ddf70 100644
--- a/arch/sparc/kernel/entry.S
+++ b/arch/sparc/kernel/entry.S
@@ -400,6 +400,39 @@ linux_trap_ipi15_sun4d:
        /* FIXME */
 1:      b,a     1b
+#ifdef CONFIG_SPARC_LEON
+        .globl  smpleon_ticker
+        /* SMP per-cpu ticker interrupts are handled specially. */
+smpleon_ticker:
+        SAVE_ALL
+        or      %l0, PSR_PIL, %g2
+        wr      %g2, 0x0, %psr
+        WRITE_PAUSE
+        wr      %g2, PSR_ET, %psr
+        WRITE_PAUSE
+        call    leon_percpu_timer_interrupt
+         add    %sp, STACKFRAME_SZ, %o0
+        wr      %l0, PSR_ET, %psr
+        WRITE_PAUSE
+        RESTORE_ALL
+        .align  4
+        .globl  linux_trap_ipi15_leon
+linux_trap_ipi15_leon:
+        SAVE_ALL
+        or      %l0, PSR_PIL, %l4
+        wr      %l4, 0x0, %psr
+        WRITE_PAUSE
+        wr      %l4, PSR_ET, %psr
+        WRITE_PAUSE
+        call    leon_cross_call_irq
+         nop
+        b       ret_trap_lockless_ipi
+         clr    %l6
+#endif /* CONFIG_SPARC_LEON */
 #endif /* CONFIG_SMP */
        /* This routine handles illegal instructions and privileged
@@ -1261,7 +1294,7 @@ linux_sparc_syscall:
        sethi   %hi(PSR_SYSCALL), %l4
        or      %l0, %l4, %l0
        /* Direct access to user regs, must faster. */
-        cmp     %g1, NR_SYSCALLS
+        cmp     %g1, NR_syscalls
        bgeu    linux_sparc_ni_syscall
         sll    %g1, 2, %l4
        ld      [%l7 + %l4], %l7
diff --git a/arch/sparc/kernel/entry.h b/arch/sparc/kernel/entry.h
index 4f53a2395ac6..c011b932bb17 100644
--- a/arch/sparc/kernel/entry.h
+++ b/arch/sparc/kernel/entry.h
@@ -48,7 +48,6 @@ extern void __init boot_cpu_id_too_large(int cpu);
 extern unsigned int dcache_parity_tl1_occurred;
 extern unsigned int icache_parity_tl1_occurred;
-extern asmlinkage void update_perfctrs(void);
 extern asmlinkage void sparc_breakpoint(struct pt_regs *regs);
 extern void timer_interrupt(int irq, struct pt_regs *regs);
diff --git a/arch/sparc/kernel/ftrace.c b/arch/sparc/kernel/ftrace.c
index d3b1a3076569..03ab022e51c5 100644
--- a/arch/sparc/kernel/ftrace.c
+++ b/arch/sparc/kernel/ftrace.c
@@ -4,6 +4,7 @@
 #include <linux/percpu.h>
 #include <linux/init.h>
 #include <linux/list.h>
+#include <trace/syscall.h>
 #include <asm/ftrace.h>
@@ -12,7 +13,7 @@ static const u32 ftrace_nop = 0x01000000;
 static u32 ftrace_call_replace(unsigned long ip, unsigned long addr)
 {
-        static u32 call;
+        u32 call;
        s32 off;
        off = ((s32)addr - (s32)ip);
@@ -91,3 +92,60 @@ int __init ftrace_dyn_arch_init(void *data)
 }
 #endif
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+#ifdef CONFIG_DYNAMIC_FTRACE
+extern void ftrace_graph_call(void);
+int ftrace_enable_ftrace_graph_caller(void)
+{
+        unsigned long ip = (unsigned long)(&ftrace_graph_call);
+        u32 old, new;
+        old = *(u32 *) &ftrace_graph_call;
+        new = ftrace_call_replace(ip, (unsigned long) &ftrace_graph_caller);
+        return ftrace_modify_code(ip, old, new);
+}
+int ftrace_disable_ftrace_graph_caller(void)
+{
+        unsigned long ip = (unsigned long)(&ftrace_graph_call);
+        u32 old, new;
+        old = *(u32 *) &ftrace_graph_call;
+        new = ftrace_call_replace(ip, (unsigned long) &ftrace_stub);
+        return ftrace_modify_code(ip, old, new);
+}
+#endif /* !CONFIG_DYNAMIC_FTRACE */
+/*
+ * Hook the return address and push it in the stack of return addrs
+ * in current thread info.
+ */
+unsigned long prepare_ftrace_return(unsigned long parent,
+                                    unsigned long self_addr,
+                                    unsigned long frame_pointer)
+{
+        unsigned long return_hooker = (unsigned long) &return_to_handler;
+        struct ftrace_graph_ent trace;
+        if (unlikely(atomic_read(&current->tracing_graph_pause)))
+                return parent + 8UL;
+        if (ftrace_push_return_trace(parent, self_addr, &trace.depth,
+                                     frame_pointer) == -EBUSY)
+                return parent + 8UL;
+        trace.func = self_addr;
+        /* Only trace if the calling function expects to */
+        if (!ftrace_graph_entry(&trace)) {
+                current->curr_ret_stack--;
+                return parent + 8UL;
+        }
+        return return_hooker;
+}
+#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
diff --git a/arch/sparc/kernel/head_32.S b/arch/sparc/kernel/head_32.S
index 439d82a95ac9..21bb2590d4ae 100644
--- a/arch/sparc/kernel/head_32.S
+++ b/arch/sparc/kernel/head_32.S
@@ -811,9 +811,31 @@ found_version:
 got_prop:
 #ifdef CONFIG_SPARC_LEON
                /* no cpu-type check is needed, it is a SPARC-LEON */
+#ifdef CONFIG_SMP
+                ba leon_smp_init
+                 nop
+                .global leon_smp_init
+leon_smp_init:
+                sethi   %hi(boot_cpu_id), %g1    ! master always 0
+                stb     %g0, [%g1 + %lo(boot_cpu_id)]
+                sethi   %hi(boot_cpu_id4), %g1   ! master always 0
+                stb     %g0, [%g1 + %lo(boot_cpu_id4)]
+                rd     %asr17,%g1
+                srl    %g1,28,%g1
+                cmp %g0,%g1
+                 beq sun4c_continue_boot         !continue with master
+                nop
+                ba leon_smp_cpu_startup
+                 nop
+#else
                ba sun4c_continue_boot
                 nop
 #endif
+#endif
                set     cputypval, %o2
                ldub    [%o2 + 0x4], %l1
diff --git a/arch/sparc/kernel/helpers.S b/arch/sparc/kernel/helpers.S
index 314dd0c9fc5b..92090cc9e829 100644
--- a/arch/sparc/kernel/helpers.S
+++ b/arch/sparc/kernel/helpers.S
@@ -46,6 +46,81 @@ stack_trace_flush:
         nop
        .size           stack_trace_flush,.-stack_trace_flush
+#ifdef CONFIG_PERF_EVENTS
+        .globl          perf_arch_fetch_caller_regs
+        .type           perf_arch_fetch_caller_regs,#function
+perf_arch_fetch_caller_regs:
+        /* We always read the %pstate into %o5 since we will use
+         * that to construct a fake %tstate to store into the regs.
+         */
+        rdpr            %pstate, %o5
+        brz,pn          %o2, 50f
+         mov            %o2, %g7
+        /* Turn off interrupts while we walk around the register
+         * window by hand.
+         */
+        wrpr            %o5, PSTATE_IE, %pstate
+        /* The %canrestore tells us how many register windows are
+         * still live in the chip above us, past that we have to
+         * walk the frame as saved on the stack.   We stash away
+         * the %cwp in %g1 so we can return back to the original
+         * register window.
+         */
+        rdpr            %cwp, %g1
+        rdpr            %canrestore, %g2
+        sub             %g1, 1, %g3
+        /* We have the skip count in %g7, if it hits zero then
+         * %fp/%i7 are the registers we need.  Otherwise if our
+         * %canrestore count maintained in %g2 hits zero we have
+         * to start traversing the stack.
+         */
+10:     brz,pn          %g2, 4f
+         sub            %g2, 1, %g2
+        wrpr            %g3, %cwp
+        subcc           %g7, 1, %g7
+        bne,pt          %xcc, 10b
+         sub            %g3, 1, %g3
+        /* We found the values we need in the cpu's register
+         * windows.
+         */
+        mov             %fp, %g3
+        ba,pt           %xcc, 3f
+         mov            %i7, %g2
+50:     mov             %fp, %g3
+        ba,pt           %xcc, 2f
+         mov            %i7, %g2
+        /* We hit the end of the valid register windows in the
+         * cpu, start traversing the stack frame.
+         */
+4:      mov             %fp, %g3
+20:     ldx             [%g3 + STACK_BIAS + RW_V9_I7], %g2
+        subcc           %g7, 1, %g7
+        bne,pn          %xcc, 20b
+         ldx            [%g3 + STACK_BIAS + RW_V9_I6], %g3
+        /* Restore the current register window position and
+         * re-enable interrupts.
+         */
+3:      wrpr            %g1, %cwp
+        wrpr            %o5, %pstate
+2:      stx             %g3, [%o0 + PT_V9_FP]
+        sllx            %o5, 8, %o5
+        stx             %o5, [%o0 + PT_V9_TSTATE]
+        stx             %g2, [%o0 + PT_V9_TPC]
+        add             %g2, 4, %g2
+        retl
+         stx            %g2, [%o0 + PT_V9_TNPC]
+        .size           perf_arch_fetch_caller_regs,.-perf_arch_fetch_caller_regs
+#endif /* CONFIG_PERF_EVENTS */
 #ifdef CONFIG_SMP
        .globl          hard_smp_processor_id
        .type           hard_smp_processor_id,#function
diff --git a/arch/sparc/kernel/hvapi.c b/arch/sparc/kernel/hvapi.c
index 1d272c3b5740..7c60afb835b0 100644
--- a/arch/sparc/kernel/hvapi.c
+++ b/arch/sparc/kernel/hvapi.c
@@ -5,7 +5,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/slab.h>
 #include <asm/hypervisor.h>
 #include <asm/oplib.h>
diff --git a/arch/sparc/kernel/iommu.c b/arch/sparc/kernel/iommu.c
index 7690cc219ecc..47977a77f6c6 100644
--- a/arch/sparc/kernel/iommu.c
+++ b/arch/sparc/kernel/iommu.c
@@ -6,11 +6,13 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/dma-mapping.h>
 #include <linux/errno.h>
 #include <linux/iommu-helper.h>
+#include <linux/bitmap.h>
 #ifdef CONFIG_PCI
 #include <linux/pci.h>
@@ -169,7 +171,7 @@ void iommu_range_free(struct iommu *iommu, dma_addr_t dma_addr, unsigned long np
        entry = (dma_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT;
-        iommu_area_free(arena->map, entry, npages);
+        bitmap_clear(arena->map, entry, npages);
 }
 int iommu_table_init(struct iommu *iommu, int tsbsize,
@@ -861,13 +863,3 @@ int dma_supported(struct device *dev, u64 device_mask)
        return 0;
 }
 EXPORT_SYMBOL(dma_supported);
-int dma_set_mask(struct device *dev, u64 dma_mask)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
-                return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
-#endif
-        return -EINVAL;
-}
-EXPORT_SYMBOL(dma_set_mask);
diff --git a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
index 9f61fd8cbb7b..84e5386714cd 100644
--- a/arch/sparc/kernel/ioport.c
+++ b/arch/sparc/kernel/ioport.c
@@ -48,8 +48,13 @@
 #include <asm/dma.h>
 #include <asm/iommu.h>
 #include <asm/io-unit.h>
+#include <asm/leon.h>
+#ifdef CONFIG_SPARC_LEON
+#define mmu_inval_dma_area(p, l) leon_flush_dcache_all()
+#else
 #define mmu_inval_dma_area(p, l)        /* Anton pulled it out for 2.4.0-xx */
+#endif
 static struct resource *_sparc_find_resource(struct resource *r,
                                             unsigned long);
@@ -671,17 +676,6 @@ int dma_supported(struct device *dev, u64 mask)
 }
 EXPORT_SYMBOL(dma_supported);
-int dma_set_mask(struct device *dev, u64 dma_mask)
-{
-#ifdef CONFIG_PCI
-        if (dev->bus == &pci_bus_type)
-                return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
-#endif
-        return -EOPNOTSUPP;
-}
-EXPORT_SYMBOL(dma_set_mask);
 #ifdef CONFIG_PROC_FS
 static int sparc_io_proc_show(struct seq_file *m, void *v)
diff --git a/arch/sparc/kernel/irq_64.c b/arch/sparc/kernel/irq_64.c
index 8ab1d4728a4b..830d70a3e20b 100644
--- a/arch/sparc/kernel/irq_64.c
+++ b/arch/sparc/kernel/irq_64.c
@@ -20,7 +20,9 @@
 #include <linux/delay.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/ftrace.h>
 #include <linux/irq.h>
+#include <linux/kmemleak.h>
 #include <asm/ptrace.h>
 #include <asm/processor.h>
@@ -45,6 +47,7 @@
 #include "entry.h"
 #include "cpumap.h"
+#include "kstack.h"
 #define NUM_IVECS       (IMAP_INR + 1)
@@ -176,7 +179,7 @@ int show_interrupts(struct seq_file *p, void *v)
        }
        if (i < NR_IRQS) {
-                spin_lock_irqsave(&irq_desc[i].lock, flags);
+                raw_spin_lock_irqsave(&irq_desc[i].lock, flags);
                action = irq_desc[i].action;
                if (!action)
                        goto skip;
@@ -187,7 +190,7 @@ int show_interrupts(struct seq_file *p, void *v)
                for_each_online_cpu(j)
                        seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
 #endif
-                seq_printf(p, " %9s", irq_desc[i].chip->typename);
+                seq_printf(p, " %9s", irq_desc[i].chip->name);
                seq_printf(p, "  %s", action->name);
                for (action=action->next; action; action = action->next)
@@ -195,7 +198,7 @@ int show_interrupts(struct seq_file *p, void *v)
                seq_putc(p, '\n');
 skip:
-                spin_unlock_irqrestore(&irq_desc[i].lock, flags);
+                raw_spin_unlock_irqrestore(&irq_desc[i].lock, flags);
        } else if (i == NR_IRQS) {
                seq_printf(p, "NMI: ");
                for_each_online_cpu(j)
@@ -250,12 +253,12 @@ struct irq_handler_data {
 };
 #ifdef CONFIG_SMP
-static int irq_choose_cpu(unsigned int virt_irq)
+static int irq_choose_cpu(unsigned int virt_irq, const struct cpumask *affinity)
 {
        cpumask_t mask;
        int cpuid;
-        cpumask_copy(&mask, irq_desc[virt_irq].affinity);
+        cpumask_copy(&mask, affinity);
        if (cpus_equal(mask, cpu_online_map)) {
                cpuid = map_to_cpu(virt_irq);
        } else {
@@ -268,10 +271,8 @@ static int irq_choose_cpu(unsigned int virt_irq)
        return cpuid;
 }
 #else
-static int irq_choose_cpu(unsigned int virt_irq)
+#define irq_choose_cpu(virt_irq, affinity)      \
-{
+        real_hard_smp_processor_id()
-        return real_hard_smp_processor_id();
-}
 #endif
 static void sun4u_irq_enable(unsigned int virt_irq)
@@ -282,7 +283,8 @@ static void sun4u_irq_enable(unsigned int virt_irq)
                unsigned long cpuid, imap, val;
                unsigned int tid;
-                cpuid = irq_choose_cpu(virt_irq);
+                cpuid = irq_choose_cpu(virt_irq,
+                                       irq_desc[virt_irq].affinity);
                imap = data->imap;
                tid = sun4u_compute_tid(imap, cpuid);
@@ -299,7 +301,24 @@ static void sun4u_irq_enable(unsigned int virt_irq)
 static int sun4u_set_affinity(unsigned int virt_irq,
                               const struct cpumask *mask)
 {
-        sun4u_irq_enable(virt_irq);
+        struct irq_handler_data *data = get_irq_chip_data(virt_irq);
+        if (likely(data)) {
+                unsigned long cpuid, imap, val;
+                unsigned int tid;
+                cpuid = irq_choose_cpu(virt_irq, mask);
+                imap = data->imap;
+                tid = sun4u_compute_tid(imap, cpuid);
+                val = upa_readq(imap);
+                val &= ~(IMAP_TID_UPA | IMAP_TID_JBUS |
+                         IMAP_AID_SAFARI | IMAP_NID_SAFARI);
+                val |= tid | IMAP_VALID;
+                upa_writeq(val, imap);
+                upa_writeq(ICLR_IDLE, data->iclr);
+        }
        return 0;
 }
@@ -340,7 +359,8 @@ static void sun4u_irq_eoi(unsigned int virt_irq)
 static void sun4v_irq_enable(unsigned int virt_irq)
 {
        unsigned int ino = virt_irq_table[virt_irq].dev_ino;
-        unsigned long cpuid = irq_choose_cpu(virt_irq);
+        unsigned long cpuid = irq_choose_cpu(virt_irq,
+                                             irq_desc[virt_irq].affinity);
        int err;
        err = sun4v_intr_settarget(ino, cpuid);
@@ -361,7 +381,7 @@ static int sun4v_set_affinity(unsigned int virt_irq,
                               const struct cpumask *mask)
 {
        unsigned int ino = virt_irq_table[virt_irq].dev_ino;
-        unsigned long cpuid = irq_choose_cpu(virt_irq);
+        unsigned long cpuid = irq_choose_cpu(virt_irq, mask);
        int err;
        err = sun4v_intr_settarget(ino, cpuid);
@@ -403,7 +423,7 @@ static void sun4v_virq_enable(unsigned int virt_irq)
        unsigned long cpuid, dev_handle, dev_ino;
        int err;
-        cpuid = irq_choose_cpu(virt_irq);
+        cpuid = irq_choose_cpu(virt_irq, irq_desc[virt_irq].affinity);
        dev_handle = virt_irq_table[virt_irq].dev_handle;
        dev_ino = virt_irq_table[virt_irq].dev_ino;
@@ -433,7 +453,7 @@ static int sun4v_virt_set_affinity(unsigned int virt_irq,
        unsigned long cpuid, dev_handle, dev_ino;
        int err;
-        cpuid = irq_choose_cpu(virt_irq);
+        cpuid = irq_choose_cpu(virt_irq, mask);
        dev_handle = virt_irq_table[virt_irq].dev_handle;
        dev_ino = virt_irq_table[virt_irq].dev_ino;
@@ -484,7 +504,7 @@ static void sun4v_virq_eoi(unsigned int virt_irq)
 }
 static struct irq_chip sun4u_irq = {
-        .typename       = "sun4u",
+        .name           = "sun4u",
        .enable         = sun4u_irq_enable,
        .disable        = sun4u_irq_disable,
        .eoi            = sun4u_irq_eoi,
@@ -492,7 +512,7 @@ static struct irq_chip sun4u_irq = {
 };
 static struct irq_chip sun4v_irq = {
-        .typename       = "sun4v",
+        .name           = "sun4v",
        .enable         = sun4v_irq_enable,
        .disable        = sun4v_irq_disable,
        .eoi            = sun4v_irq_eoi,
@@ -500,7 +520,7 @@ static struct irq_chip sun4v_irq = {
 };
 static struct irq_chip sun4v_virq = {
-        .typename       = "vsun4v",
+        .name           = "vsun4v",
        .enable         = sun4v_virq_enable,
        .disable        = sun4v_virq_disable,
        .eoi            = sun4v_virq_eoi,
@@ -630,6 +650,14 @@ unsigned int sun4v_build_virq(u32 devhandle, unsigned int devino)
        bucket = kzalloc(sizeof(struct ino_bucket), GFP_ATOMIC);
        if (unlikely(!bucket))
                return 0;
+        /* The only reference we store to the IRQ bucket is
+         * by physical address which kmemleak can't see, tell
+         * it that this object explicitly is not a leak and
+         * should be scanned.
+         */
+        kmemleak_not_leak(bucket);
        __flush_dcache_range((unsigned long) bucket,
                             ((unsigned long) bucket +
                              sizeof(struct ino_bucket)));
@@ -686,25 +714,7 @@ void ack_bad_irq(unsigned int virt_irq)
 void *hardirq_stack[NR_CPUS];
 void *softirq_stack[NR_CPUS];
-static __attribute__((always_inline)) void *set_hardirq_stack(void)
+void __irq_entry handler_irq(int irq, struct pt_regs *regs)
-{
-        void *orig_sp, *sp = hardirq_stack[smp_processor_id()];
-        __asm__ __volatile__("mov %%sp, %0" : "=r" (orig_sp));
-        if (orig_sp < sp ||
-            orig_sp > (sp + THREAD_SIZE)) {
-                sp += THREAD_SIZE - 192 - STACK_BIAS;
-                __asm__ __volatile__("mov %0, %%sp" : : "r" (sp));
-        }
-        return orig_sp;
-}
-static __attribute__((always_inline)) void restore_hardirq_stack(void *orig_sp)
-{
-        __asm__ __volatile__("mov %0, %%sp" : : "r" (orig_sp));
-}
-void handler_irq(int irq, struct pt_regs *regs)
 {
        unsigned long pstate, bucket_pa;
        struct pt_regs *old_regs;
@@ -785,14 +795,14 @@ void fixup_irqs(void)
        for (irq = 0; irq < NR_IRQS; irq++) {
                unsigned long flags;
-                spin_lock_irqsave(&irq_desc[irq].lock, flags);
+                raw_spin_lock_irqsave(&irq_desc[irq].lock, flags);
                if (irq_desc[irq].action &&
                    !(irq_desc[irq].status & IRQ_PER_CPU)) {
                        if (irq_desc[irq].chip->set_affinity)
                                irq_desc[irq].chip->set_affinity(irq,
                                        irq_desc[irq].affinity);
                }
-                spin_unlock_irqrestore(&irq_desc[irq].lock, flags);
+                raw_spin_unlock_irqrestore(&irq_desc[irq].lock, flags);
        }
        tick_ops->disable_irq();
diff --git a/arch/sparc/kernel/kgdb_64.c b/arch/sparc/kernel/kgdb_64.c
index f5a0fd490b59..0a2bd0f99fc1 100644
--- a/arch/sparc/kernel/kgdb_64.c
+++ b/arch/sparc/kernel/kgdb_64.c
@@ -5,6 +5,7 @@
 #include <linux/kgdb.h>
 #include <linux/kdebug.h>
+#include <linux/ftrace.h>
 #include <asm/kdebug.h>
 #include <asm/ptrace.h>
@@ -108,7 +109,7 @@ void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
 }
 #ifdef CONFIG_SMP
-void smp_kgdb_capture_client(int irq, struct pt_regs *regs)
+void __irq_entry smp_kgdb_capture_client(int irq, struct pt_regs *regs)
 {
        unsigned long flags;
diff --git a/arch/sparc/kernel/kprobes.c b/arch/sparc/kernel/kprobes.c
index 3bc6527c95af..a39d1ba5a119 100644
--- a/arch/sparc/kernel/kprobes.c
+++ b/arch/sparc/kernel/kprobes.c
@@ -7,6 +7,7 @@
 #include <linux/kprobes.h>
 #include <linux/module.h>
 #include <linux/kdebug.h>
+#include <linux/slab.h>
 #include <asm/signal.h>
 #include <asm/cacheflush.h>
 #include <asm/uaccess.h>
@@ -46,6 +47,9 @@ struct kretprobe_blackpoint kretprobe_blacklist[] = {{NULL, NULL}};
 int __kprobes arch_prepare_kprobe(struct kprobe *p)
 {
+        if ((unsigned long) p->addr & 0x3UL)
+                return -EILSEQ;
        p->ainsn.insn[0] = *p->addr;
        flushi(&p->ainsn.insn[0]);
diff --git a/arch/sparc/kernel/kstack.h b/arch/sparc/kernel/kstack.h
index 4248d969272f..53dfb92e09fb 100644
--- a/arch/sparc/kernel/kstack.h
+++ b/arch/sparc/kernel/kstack.h
@@ -11,6 +11,10 @@ static inline bool kstack_valid(struct thread_info *tp, unsigned long sp)
 {
        unsigned long base = (unsigned long) tp;
+        /* Stack pointer must be 16-byte aligned.  */
+        if (sp & (16UL - 1))
+                return false;
        if (sp >= (base + sizeof(struct thread_info)) &&
            sp <= (base + THREAD_SIZE - sizeof(struct sparc_stackf)))
                return true;
@@ -57,4 +61,23 @@ check_magic:
 }
+static inline __attribute__((always_inline)) void *set_hardirq_stack(void)
+{
+        void *orig_sp, *sp = hardirq_stack[smp_processor_id()];
+        __asm__ __volatile__("mov %%sp, %0" : "=r" (orig_sp));
+        if (orig_sp < sp ||
+            orig_sp > (sp + THREAD_SIZE)) {
+                sp += THREAD_SIZE - 192 - STACK_BIAS;
+                __asm__ __volatile__("mov %0, %%sp" : : "r" (sp));
+        }
+        return orig_sp;
+}
+static inline __attribute__((always_inline)) void restore_hardirq_stack(void *orig_sp)
+{
+        __asm__ __volatile__("mov %0, %%sp" : : "r" (orig_sp));
+}
 #endif /* _KSTACK_H */
diff --git a/arch/sparc/kernel/ldc.c b/arch/sparc/kernel/ldc.c
index cb3c72c45aab..df39a0f0d27a 100644
--- a/arch/sparc/kernel/ldc.c
+++ b/arch/sparc/kernel/ldc.c
@@ -14,6 +14,7 @@
 #include <linux/interrupt.h>
 #include <linux/list.h>
 #include <linux/init.h>
+#include <linux/bitmap.h>
 #include <asm/hypervisor.h>
 #include <asm/iommu.h>
@@ -1242,13 +1243,13 @@ int ldc_bind(struct ldc_channel *lp, const char *name)
        snprintf(lp->tx_irq_name, LDC_IRQ_NAME_MAX, "%s TX", name);
        err = request_irq(lp->cfg.rx_irq, ldc_rx,
-                          IRQF_SAMPLE_RANDOM | IRQF_DISABLED | IRQF_SHARED,
+                          IRQF_SAMPLE_RANDOM | IRQF_DISABLED,
                          lp->rx_irq_name, lp);
        if (err)
                return err;
        err = request_irq(lp->cfg.tx_irq, ldc_tx,
-                          IRQF_SAMPLE_RANDOM | IRQF_DISABLED | IRQF_SHARED,
+                          IRQF_SAMPLE_RANDOM | IRQF_DISABLED,
                          lp->tx_irq_name, lp);
        if (err) {
                free_irq(lp->cfg.rx_irq, lp);
@@ -1875,7 +1876,7 @@ EXPORT_SYMBOL(ldc_read);
 static long arena_alloc(struct ldc_iommu *iommu, unsigned long npages)
 {
        struct iommu_arena *arena = &iommu->arena;
-        unsigned long n, i, start, end, limit;
+        unsigned long n, start, end, limit;
        int pass;
        limit = arena->limit;
@@ -1883,7 +1884,7 @@ static long arena_alloc(struct ldc_iommu *iommu, unsigned long npages)
        pass = 0;
 again:
-        n = find_next_zero_bit(arena->map, limit, start);
+        n = bitmap_find_next_zero_area(arena->map, limit, start, npages, 0);
        end = n + npages;
        if (unlikely(end >= limit)) {
                if (likely(pass < 1)) {
@@ -1896,16 +1897,7 @@ again:
                        return -1;
                }
        }
+        bitmap_set(arena->map, n, npages);
-        for (i = n; i < end; i++) {
-                if (test_bit(i, arena->map)) {
-                        start = i + 1;
-                        goto again;
-                }
-        }
-        for (i = n; i < end; i++)
-                __set_bit(i, arena->map);
        arena->hint = end;
diff --git a/arch/sparc/kernel/led.c b/arch/sparc/kernel/led.c
index 00d034ea2164..3ae36f36e758 100644
--- a/arch/sparc/kernel/led.c
+++ b/arch/sparc/kernel/led.c
@@ -3,6 +3,7 @@
 #include <linux/init.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/jiffies.h>
 #include <linux/timer.h>
diff --git a/arch/sparc/kernel/leon_kernel.c b/arch/sparc/kernel/leon_kernel.c
index 54d8a5bd4824..6a7b4dbc8e09 100644
--- a/arch/sparc/kernel/leon_kernel.c
+++ b/arch/sparc/kernel/leon_kernel.c
@@ -7,16 +7,18 @@
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/mutex.h>
-#include <linux/slab.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
 #include <linux/interrupt.h>
 #include <linux/of_device.h>
 #include <asm/oplib.h>
 #include <asm/timer.h>
 #include <asm/prom.h>
 #include <asm/leon.h>
 #include <asm/leon_amba.h>
+#include <asm/traps.h>
+#include <asm/cacheflush.h>
 #include "prom.h"
 #include "irq.h"
@@ -115,6 +117,21 @@ void __init leon_init_timers(irq_handler_t counter_fn)
                                      (((1000000 / 100) - 1)));
                LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[0].ctrl, 0);
+#ifdef CONFIG_SMP
+                leon_percpu_timer_dev[0].start = (int)leon3_gptimer_regs;
+                leon_percpu_timer_dev[0].irq = leon3_gptimer_irq+1;
+                if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->config) &
+                      (1<<LEON3_GPTIMER_SEPIRQ))) {
+                        prom_printf("irq timer not configured with separate irqs\n");
+                        BUG();
+                }
+                LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[1].val, 0);
+                LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[1].rld, (((1000000/100) - 1)));
+                LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[1].ctrl, 0);
+# endif
        } else {
                printk(KERN_ERR "No Timer/irqctrl found\n");
                BUG();
@@ -130,11 +147,41 @@ void __init leon_init_timers(irq_handler_t counter_fn)
                prom_halt();
        }
+# ifdef CONFIG_SMP
+        {
+                unsigned long flags;
+                struct tt_entry *trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (leon_percpu_timer_dev[0].irq - 1)];
+                /* For SMP we use the level 14 ticker, however the bootup code
+                 * has copied the firmwares level 14 vector into boot cpu's
+                 * trap table, we must fix this now or we get squashed.
+                 */
+                local_irq_save(flags);
+                patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */
+                /* Adjust so that we jump directly to smpleon_ticker */
+                trap_table->inst_three += smpleon_ticker - real_irq_entry;
+                local_flush_cache_all();
+                local_irq_restore(flags);
+        }
+# endif
        if (leon3_gptimer_regs) {
                LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[0].ctrl,
                                      LEON3_GPTIMER_EN |
                                      LEON3_GPTIMER_RL |
                                      LEON3_GPTIMER_LD | LEON3_GPTIMER_IRQEN);
+#ifdef CONFIG_SMP
+                LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[1].ctrl,
+                                      LEON3_GPTIMER_EN |
+                                      LEON3_GPTIMER_RL |
+                                      LEON3_GPTIMER_LD |
+                                      LEON3_GPTIMER_IRQEN);
+#endif
        }
 }
@@ -175,6 +222,42 @@ void __init leon_node_init(struct device_node *dp, struct device_node ***nextp)
        }
 }
+#ifdef CONFIG_SMP
+void leon_set_cpu_int(int cpu, int level)
+{
+        unsigned long mask;
+        mask = get_irqmask(level);
+        LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask);
+}
+static void leon_clear_ipi(int cpu, int level)
+{
+        unsigned long mask;
+        mask = get_irqmask(level);
+        LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask<<16);
+}
+static void leon_set_udt(int cpu)
+{
+}
+void leon_clear_profile_irq(int cpu)
+{
+}
+void leon_enable_irq_cpu(unsigned int irq_nr, unsigned int cpu)
+{
+        unsigned long mask, flags, *addr;
+        mask = get_irqmask(irq_nr);
+        local_irq_save(flags);
+        addr = (unsigned long *)&(leon3_irqctrl_regs->mask[cpu]);
+        LEON3_BYPASS_STORE_PA(addr, (LEON3_BYPASS_LOAD_PA(addr) | (mask)));
+        local_irq_restore(flags);
+}
+#endif
 void __init leon_init_IRQ(void)
 {
        sparc_init_timers = leon_init_timers;
diff --git a/arch/sparc/kernel/leon_smp.c b/arch/sparc/kernel/leon_smp.c
new file mode 100644
index 000000000000..e1656fc41ccb
--- /dev/null
+++ b/arch/sparc/kernel/leon_smp.c
@@ -0,0 +1,469 @@
+/* leon_smp.c: Sparc-Leon SMP support.
+ *
+ * based on sun4m_smp.c
+ * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
+ * Copyright (C) 2009 Daniel Hellstrom (daniel@gaisler.com) Aeroflex Gaisler AB
+ * Copyright (C) 2009 Konrad Eisele (konrad@gaisler.com) Aeroflex Gaisler AB
+ */
+#include <asm/head.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/threads.h>
+#include <linux/smp.h>
+#include <linux/smp_lock.h>
+#include <linux/interrupt.h>
+#include <linux/kernel_stat.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/swap.h>
+#include <linux/profile.h>
+#include <linux/pm.h>
+#include <linux/delay.h>
+#include <linux/gfp.h>
+#include <asm/cacheflush.h>
+#include <asm/tlbflush.h>
+#include <asm/ptrace.h>
+#include <asm/atomic.h>
+#include <asm/irq_regs.h>
+#include <asm/delay.h>
+#include <asm/irq.h>
+#include <asm/page.h>
+#include <asm/pgalloc.h>
+#include <asm/pgtable.h>
+#include <asm/oplib.h>
+#include <asm/cpudata.h>
+#include <asm/asi.h>
+#include <asm/leon.h>
+#include <asm/leon_amba.h>
+#ifdef CONFIG_SPARC_LEON
+#include "irq.h"
+extern ctxd_t *srmmu_ctx_table_phys;
+static int smp_processors_ready;
+extern volatile unsigned long cpu_callin_map[NR_CPUS];
+extern unsigned char boot_cpu_id;
+extern cpumask_t smp_commenced_mask;
+void __init leon_configure_cache_smp(void);
+static inline unsigned long do_swap(volatile unsigned long *ptr,
+                                    unsigned long val)
+{
+        __asm__ __volatile__("swapa [%1] %2, %0\n\t" : "=&r"(val)
+                             : "r"(ptr), "i"(ASI_LEON_DCACHE_MISS)
+                             : "memory");
+        return val;
+}
+static void smp_setup_percpu_timer(void);
+void __cpuinit leon_callin(void)
+{
+        int cpuid = hard_smpleon_processor_id();
+        local_flush_cache_all();
+        local_flush_tlb_all();
+        leon_configure_cache_smp();
+        /* Get our local ticker going. */
+        smp_setup_percpu_timer();
+        calibrate_delay();
+        smp_store_cpu_info(cpuid);
+        local_flush_cache_all();
+        local_flush_tlb_all();
+        /*
+         * Unblock the master CPU _only_ when the scheduler state
+         * of all secondary CPUs will be up-to-date, so after
+         * the SMP initialization the master will be just allowed
+         * to call the scheduler code.
+         * Allow master to continue.
+         */
+        do_swap(&cpu_callin_map[cpuid], 1);
+        local_flush_cache_all();
+        local_flush_tlb_all();
+        cpu_probe();
+        /* Fix idle thread fields. */
+        __asm__ __volatile__("ld [%0], %%g6\n\t" : : "r"(&current_set[cpuid])
+                             : "memory" /* paranoid */);
+        /* Attach to the address space of init_task. */
+        atomic_inc(&init_mm.mm_count);
+        current->active_mm = &init_mm;
+        while (!cpu_isset(cpuid, smp_commenced_mask))
+                mb();
+        local_irq_enable();
+        cpu_set(cpuid, cpu_online_map);
+}
+/*
+ *      Cycle through the processors asking the PROM to start each one.
+ */
+extern struct linux_prom_registers smp_penguin_ctable;
+void __init leon_configure_cache_smp(void)
+{
+        unsigned long cfg = sparc_leon3_get_dcachecfg();
+        int me = smp_processor_id();
+        if (ASI_LEON3_SYSCTRL_CFG_SSIZE(cfg) > 4) {
+                printk(KERN_INFO "Note: SMP with snooping only works on 4k cache, found %dk(0x%x) on cpu %d, disabling caches\n",
+                     (unsigned int)ASI_LEON3_SYSCTRL_CFG_SSIZE(cfg),
+                     (unsigned int)cfg, (unsigned int)me);
+                sparc_leon3_disable_cache();
+        } else {
+                if (cfg & ASI_LEON3_SYSCTRL_CFG_SNOOPING) {
+                        sparc_leon3_enable_snooping();
+                } else {
+                        printk(KERN_INFO "Note: You have to enable snooping in the vhdl model cpu %d, disabling caches\n",
+                             me);
+                        sparc_leon3_disable_cache();
+                }
+        }
+        local_flush_cache_all();
+        local_flush_tlb_all();
+}
+void leon_smp_setbroadcast(unsigned int mask)
+{
+        int broadcast =
+            ((LEON3_BYPASS_LOAD_PA(&(leon3_irqctrl_regs->mpstatus)) >>
+              LEON3_IRQMPSTATUS_BROADCAST) & 1);
+        if (!broadcast) {
+                prom_printf("######## !!!! The irqmp-ctrl must have broadcast enabled, smp wont work !!!!! ####### nr cpus: %d\n",
+                     leon_smp_nrcpus());
+                if (leon_smp_nrcpus() > 1) {
+                        BUG();
+                } else {
+                        prom_printf("continue anyway\n");
+                        return;
+                }
+        }
+        LEON_BYPASS_STORE_PA(&(leon3_irqctrl_regs->mpbroadcast), mask);
+}
+unsigned int leon_smp_getbroadcast(void)
+{
+        unsigned int mask;
+        mask = LEON_BYPASS_LOAD_PA(&(leon3_irqctrl_regs->mpbroadcast));
+        return mask;
+}
+int leon_smp_nrcpus(void)
+{
+        int nrcpu =
+            ((LEON3_BYPASS_LOAD_PA(&(leon3_irqctrl_regs->mpstatus)) >>
+              LEON3_IRQMPSTATUS_CPUNR) & 0xf) + 1;
+        return nrcpu;
+}
+void __init leon_boot_cpus(void)
+{
+        int nrcpu = leon_smp_nrcpus();
+        int me = smp_processor_id();
+        printk(KERN_INFO "%d:(%d:%d) cpus mpirq at 0x%x\n", (unsigned int)me,
+               (unsigned int)nrcpu, (unsigned int)NR_CPUS,
+               (unsigned int)&(leon3_irqctrl_regs->mpstatus));
+        leon_enable_irq_cpu(LEON3_IRQ_CROSS_CALL, me);
+        leon_enable_irq_cpu(LEON3_IRQ_TICKER, me);
+        leon_enable_irq_cpu(LEON3_IRQ_RESCHEDULE, me);
+        leon_smp_setbroadcast(1 << LEON3_IRQ_TICKER);
+        leon_configure_cache_smp();
+        smp_setup_percpu_timer();
+        local_flush_cache_all();
+}
+int __cpuinit leon_boot_one_cpu(int i)
+{
+        struct task_struct *p;
+        int timeout;
+        /* Cook up an idler for this guy. */
+        p = fork_idle(i);
+        current_set[i] = task_thread_info(p);
+        /* See trampoline.S:leon_smp_cpu_startup for details...
+         * Initialize the contexts table
+         * Since the call to prom_startcpu() trashes the structure,
+         * we need to re-initialize it for each cpu
+         */
+        smp_penguin_ctable.which_io = 0;
+        smp_penguin_ctable.phys_addr = (unsigned int)srmmu_ctx_table_phys;
+        smp_penguin_ctable.reg_size = 0;
+        /* whirrr, whirrr, whirrrrrrrrr... */
+        printk(KERN_INFO "Starting CPU %d : (irqmp: 0x%x)\n", (unsigned int)i,
+               (unsigned int)&leon3_irqctrl_regs->mpstatus);
+        local_flush_cache_all();
+        LEON_BYPASS_STORE_PA(&(leon3_irqctrl_regs->mpstatus), 1 << i);
+        /* wheee... it's going... */
+        for (timeout = 0; timeout < 10000; timeout++) {
+                if (cpu_callin_map[i])
+                        break;
+                udelay(200);
+        }
+        printk(KERN_INFO "Started CPU %d\n", (unsigned int)i);
+        if (!(cpu_callin_map[i])) {
+                printk(KERN_ERR "Processor %d is stuck.\n", i);
+                return -ENODEV;
+        } else {
+                leon_enable_irq_cpu(LEON3_IRQ_CROSS_CALL, i);
+                leon_enable_irq_cpu(LEON3_IRQ_TICKER, i);
+                leon_enable_irq_cpu(LEON3_IRQ_RESCHEDULE, i);
+        }
+        local_flush_cache_all();
+        return 0;
+}
+void __init leon_smp_done(void)
+{
+        int i, first;
+        int *prev;
+        /* setup cpu list for irq rotation */
+        first = 0;
+        prev = &first;
+        for (i = 0; i < NR_CPUS; i++) {
+                if (cpu_online(i)) {
+                        *prev = i;
+                        prev = &cpu_data(i).next;
+                }
+        }
+        *prev = first;
+        local_flush_cache_all();
+        /* Free unneeded trap tables */
+        if (!cpu_isset(1, cpu_present_map)) {
+                ClearPageReserved(virt_to_page(trapbase_cpu1));
+                init_page_count(virt_to_page(trapbase_cpu1));
+                free_page((unsigned long)trapbase_cpu1);
+                totalram_pages++;
+                num_physpages++;
+        }
+        if (!cpu_isset(2, cpu_present_map)) {
+                ClearPageReserved(virt_to_page(trapbase_cpu2));
+                init_page_count(virt_to_page(trapbase_cpu2));
+                free_page((unsigned long)trapbase_cpu2);
+                totalram_pages++;
+                num_physpages++;
+        }
+        if (!cpu_isset(3, cpu_present_map)) {
+                ClearPageReserved(virt_to_page(trapbase_cpu3));
+                init_page_count(virt_to_page(trapbase_cpu3));
+                free_page((unsigned long)trapbase_cpu3);
+                totalram_pages++;
+                num_physpages++;
+        }
+        /* Ok, they are spinning and ready to go. */
+        smp_processors_ready = 1;
+}
+void leon_irq_rotate(int cpu)
+{
+}
+static struct smp_funcall {
+        smpfunc_t func;
+        unsigned long arg1;
+        unsigned long arg2;
+        unsigned long arg3;
+        unsigned long arg4;
+        unsigned long arg5;
+        unsigned long processors_in[NR_CPUS];   /* Set when ipi entered. */
+        unsigned long processors_out[NR_CPUS];  /* Set when ipi exited. */
+} ccall_info;
+static DEFINE_SPINLOCK(cross_call_lock);
+/* Cross calls must be serialized, at least currently. */
+static void leon_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
+                            unsigned long arg2, unsigned long arg3,
+                            unsigned long arg4)
+{
+        if (smp_processors_ready) {
+                register int high = NR_CPUS - 1;
+                unsigned long flags;
+                spin_lock_irqsave(&cross_call_lock, flags);
+                {
+                        /* If you make changes here, make sure gcc generates proper code... */
+                        register smpfunc_t f asm("i0") = func;
+                        register unsigned long a1 asm("i1") = arg1;
+                        register unsigned long a2 asm("i2") = arg2;
+                        register unsigned long a3 asm("i3") = arg3;
+                        register unsigned long a4 asm("i4") = arg4;
+                        register unsigned long a5 asm("i5") = 0;
+                        __asm__ __volatile__("std %0, [%6]\n\t"
+                                             "std %2, [%6 + 8]\n\t"
+                                             "std %4, [%6 + 16]\n\t" : :
+                                             "r"(f), "r"(a1), "r"(a2), "r"(a3),
+                                             "r"(a4), "r"(a5),
+                                             "r"(&ccall_info.func));
+                }
+                /* Init receive/complete mapping, plus fire the IPI's off. */
+                {
+                        register int i;
+                        cpu_clear(smp_processor_id(), mask);
+                        cpus_and(mask, cpu_online_map, mask);
+                        for (i = 0; i <= high; i++) {
+                                if (cpu_isset(i, mask)) {
+                                        ccall_info.processors_in[i] = 0;
+                                        ccall_info.processors_out[i] = 0;
+                                        set_cpu_int(i, LEON3_IRQ_CROSS_CALL);
+                                }
+                        }
+                }
+                {
+                        register int i;
+                        i = 0;
+                        do {
+                                if (!cpu_isset(i, mask))
+                                        continue;
+                                while (!ccall_info.processors_in[i])
+                                        barrier();
+                        } while (++i <= high);
+                        i = 0;
+                        do {
+                                if (!cpu_isset(i, mask))
+                                        continue;
+                                while (!ccall_info.processors_out[i])
+                                        barrier();
+                        } while (++i <= high);
+                }
+                spin_unlock_irqrestore(&cross_call_lock, flags);
+        }
+}
+/* Running cross calls. */
+void leon_cross_call_irq(void)
+{
+        int i = smp_processor_id();
+        ccall_info.processors_in[i] = 1;
+        ccall_info.func(ccall_info.arg1, ccall_info.arg2, ccall_info.arg3,
+                        ccall_info.arg4, ccall_info.arg5);
+        ccall_info.processors_out[i] = 1;
+}
+void leon_percpu_timer_interrupt(struct pt_regs *regs)
+{
+        struct pt_regs *old_regs;
+        int cpu = smp_processor_id();
+        old_regs = set_irq_regs(regs);
+        leon_clear_profile_irq(cpu);
+        profile_tick(CPU_PROFILING);
+        if (!--prof_counter(cpu)) {
+                int user = user_mode(regs);
+                irq_enter();
+                update_process_times(user);
+                irq_exit();
+                prof_counter(cpu) = prof_multiplier(cpu);
+        }
+        set_irq_regs(old_regs);
+}
+static void __init smp_setup_percpu_timer(void)
+{
+        int cpu = smp_processor_id();
+        prof_counter(cpu) = prof_multiplier(cpu) = 1;
+}
+void __init leon_blackbox_id(unsigned *addr)
+{
+        int rd = *addr & 0x3e000000;
+        int rs1 = rd >> 11;
+        /* patch places where ___b_hard_smp_processor_id appears */
+        addr[0] = 0x81444000 | rd;      /* rd %asr17, reg */
+        addr[1] = 0x8130201c | rd | rs1;        /* srl reg, 0x1c, reg */
+        addr[2] = 0x01000000;   /* nop */
+}
+void __init leon_blackbox_current(unsigned *addr)
+{
+        int rd = *addr & 0x3e000000;
+        int rs1 = rd >> 11;
+        /* patch LOAD_CURRENT macro where ___b_load_current appears */
+        addr[0] = 0x81444000 | rd;      /* rd %asr17, reg */
+        addr[2] = 0x8130201c | rd | rs1;        /* srl reg, 0x1c, reg */
+        addr[4] = 0x81282002 | rd | rs1;        /* sll reg, 0x2, reg */
+}
+/*
+ * CPU idle callback function
+ * See .../arch/sparc/kernel/process.c
+ */
+void pmc_leon_idle(void)
+{
+        __asm__ volatile ("mov %g0, %asr19");
+}
+void __init leon_init_smp(void)
+{
+        /* Patch ipi15 trap table */
+        t_nmi[1] = t_nmi[1] + (linux_trap_ipi15_leon - linux_trap_ipi15_sun4m);
+        BTFIXUPSET_BLACKBOX(hard_smp_processor_id, leon_blackbox_id);
+        BTFIXUPSET_BLACKBOX(load_current, leon_blackbox_current);
+        BTFIXUPSET_CALL(smp_cross_call, leon_cross_call, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(__hard_smp_processor_id, __leon_processor_id,
+                        BTFIXUPCALL_NORM);
+#ifndef PMC_NO_IDLE
+        /* Assign power management IDLE handler */
+        pm_idle = pmc_leon_idle;
+        printk(KERN_INFO "leon: power management initialized\n");
+#endif
+}
+#endif /* CONFIG_SPARC_LEON */
diff --git a/arch/sparc/kernel/mdesc.c b/arch/sparc/kernel/mdesc.c
index 938da19dc065..cdc91d919e93 100644
--- a/arch/sparc/kernel/mdesc.c
+++ b/arch/sparc/kernel/mdesc.c
@@ -10,6 +10,7 @@
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/miscdevice.h>
+#include <linux/bootmem.h>
 #include <asm/cpudata.h>
 #include <asm/hypervisor.h>
@@ -108,25 +109,15 @@ static struct mdesc_handle * __init mdesc_lmb_alloc(unsigned int mdesc_size)
 static void mdesc_lmb_free(struct mdesc_handle *hp)
 {
-        unsigned int alloc_size, handle_size = hp->handle_size;
+        unsigned int alloc_size;
-        unsigned long start, end;
+        unsigned long start;
        BUG_ON(atomic_read(&hp->refcnt) != 0);
        BUG_ON(!list_empty(&hp->list));
-        alloc_size = PAGE_ALIGN(handle_size);
+        alloc_size = PAGE_ALIGN(hp->handle_size);
+        start = __pa(hp);
-        start = (unsigned long) hp;
+        free_bootmem_late(start, alloc_size);
-        end = start + alloc_size;
-        while (start < end) {
-                struct page *p;
-                p = virt_to_page(start);
-                ClearPageReserved(p);
-                __free_page(p);
-                start += PAGE_SIZE;
-        }
 }
 static struct mdesc_mem_ops lmb_mdesc_ops = {
diff --git a/arch/sparc/kernel/module.c b/arch/sparc/kernel/module.c
index 0ee642f63234..f848aadf54dc 100644
--- a/arch/sparc/kernel/module.c
+++ b/arch/sparc/kernel/module.c
@@ -9,9 +9,9 @@
 #include <linux/elf.h>
 #include <linux/vmalloc.h>
 #include <linux/fs.h>
+#include <linux/gfp.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
-#include <linux/slab.h>
 #include <linux/mm.h>
 #include <asm/processor.h>
diff --git a/arch/sparc/kernel/nmi.c b/arch/sparc/kernel/nmi.c
index b129611590a4..a4bd7ba74c89 100644
--- a/arch/sparc/kernel/nmi.c
+++ b/arch/sparc/kernel/nmi.c
@@ -21,9 +21,10 @@
 #include <asm/perf_event.h>
 #include <asm/ptrace.h>
-#include <asm/local.h>
 #include <asm/pcr.h>
+#include "kstack.h"
 /* We don't have a real NMI on sparc64, but we can fake one
 * up using profiling counter overflow interrupts and interrupt
 * levels.
@@ -47,7 +48,7 @@ static DEFINE_PER_CPU(short, wd_enabled);
 static int endflag __initdata;
 static DEFINE_PER_CPU(unsigned int, last_irq_sum);
-static DEFINE_PER_CPU(local_t, alert_counter);
+static DEFINE_PER_CPU(long, alert_counter);
 static DEFINE_PER_CPU(int, nmi_touch);
 void touch_nmi_watchdog(void)
@@ -93,38 +94,43 @@ static void die_nmi(const char *str, struct pt_regs *regs, int do_panic)
 notrace __kprobes void perfctr_irq(int irq, struct pt_regs *regs)
 {
        unsigned int sum, touched = 0;
-        int cpu = smp_processor_id();
+        void *orig_sp;
        clear_softint(1 << irq);
-        pcr_ops->write(PCR_PIC_PRIV);
        local_cpu_data().__nmi_count++;
        nmi_enter();
+        orig_sp = set_hardirq_stack();
        if (notify_die(DIE_NMI, "nmi", regs, 0,
                       pt_regs_trap_type(regs), SIGINT) == NOTIFY_STOP)
                touched = 1;
+        else
+                pcr_ops->write(PCR_PIC_PRIV);
-        sum = kstat_irqs_cpu(0, cpu);
+        sum = local_cpu_data().irq0_irqs;
        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));
+                __this_cpu_inc(alert_counter);
-                if (local_read(&__get_cpu_var(alert_counter)) == 30 * nmi_hz)
+                if (__this_cpu_read(alert_counter) == 30 * 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);
+                __this_cpu_write(alert_counter, 0);
        }
        if (__get_cpu_var(wd_enabled)) {
                write_pic(picl_value(nmi_hz));
                pcr_ops->write(pcr_enable);
        }
+        restore_hardirq_stack(orig_sp);
        nmi_exit();
 }
diff --git a/arch/sparc/kernel/of_device_32.c b/arch/sparc/kernel/of_device_32.c
index 4c26eb59e742..da527b33ebc7 100644
--- a/arch/sparc/kernel/of_device_32.c
+++ b/arch/sparc/kernel/of_device_32.c
@@ -105,7 +105,7 @@ static unsigned long of_bus_sbus_get_flags(const u32 *addr, unsigned long flags)
 static int of_bus_ambapp_match(struct device_node *np)
 {
-        return !strcmp(np->name, "ambapp");
+        return !strcmp(np->type, "ambapp");
 }
 static void of_bus_ambapp_count_cells(struct device_node *child,
@@ -433,7 +433,7 @@ build_resources:
        if (!parent)
                dev_set_name(&op->dev, "root");
        else
-                dev_set_name(&op->dev, "%08x", dp->node);
+                dev_set_name(&op->dev, "%08x", dp->phandle);
        if (of_device_register(op)) {
                printk("%s: Could not register of device.\n",
diff --git a/arch/sparc/kernel/of_device_64.c b/arch/sparc/kernel/of_device_64.c
index 881947e59e95..b3d4cb5d21b3 100644
--- a/arch/sparc/kernel/of_device_64.c
+++ b/arch/sparc/kernel/of_device_64.c
@@ -104,9 +104,19 @@ static int of_bus_pci_map(u32 *addr, const u32 *range,
        int i;
        /* Check address type match */
-        if ((addr[0] ^ range[0]) & 0x03000000)
+        if (!((addr[0] ^ range[0]) & 0x03000000))
-                return -EINVAL;
+                goto type_match;
+        /* Special exception, we can map a 64-bit address into
+         * a 32-bit range.
+         */
+        if ((addr[0] & 0x03000000) == 0x03000000 &&
+            (range[0] & 0x03000000) == 0x02000000)
+                goto type_match;
+        return -EINVAL;
+type_match:
        if (of_out_of_range(addr + 1, range + 1, range + na + pna,
                            na - 1, ns))
                return -EINVAL;
@@ -666,7 +676,7 @@ static struct of_device * __init scan_one_device(struct device_node *dp,
        if (!parent)
                dev_set_name(&op->dev, "root");
        else
-                dev_set_name(&op->dev, "%08x", dp->node);
+                dev_set_name(&op->dev, "%08x", dp->phandle);
        if (of_device_register(op)) {
                printk("%s: Could not register of device.\n",
diff --git a/arch/sparc/kernel/of_device_common.c b/arch/sparc/kernel/of_device_common.c
index cb8eb799bb6c..0247e68210b3 100644
--- a/arch/sparc/kernel/of_device_common.c
+++ b/arch/sparc/kernel/of_device_common.c
@@ -4,7 +4,6 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/mod_devicetable.h>
-#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/irq.h>
 #include <linux/of_device.h>
diff --git a/arch/sparc/kernel/pci.c b/arch/sparc/kernel/pci.c
index c68648662802..5ac539a5930f 100644
--- a/arch/sparc/kernel/pci.c
+++ b/arch/sparc/kernel/pci.c
@@ -247,6 +247,7 @@ static struct pci_dev *of_create_pci_dev(struct pci_pbm_info *pbm,
                                         struct pci_bus *bus, int devfn)
 {
        struct dev_archdata *sd;
+        struct pci_slot *slot;
        struct of_device *op;
        struct pci_dev *dev;
        const char *type;
@@ -286,6 +287,11 @@ static struct pci_dev *of_create_pci_dev(struct pci_pbm_info *pbm,
        dev->dev.bus = &pci_bus_type;
        dev->devfn = devfn;
        dev->multifunction = 0;         /* maybe a lie? */
+        set_pcie_port_type(dev);
+        list_for_each_entry(slot, &dev->bus->slots, list)
+                if (PCI_SLOT(dev->devfn) == slot->number)
+                        dev->slot = slot;
        dev->vendor = of_getintprop_default(node, "vendor-id", 0xffff);
        dev->device = of_getintprop_default(node, "device-id", 0xffff);
@@ -322,6 +328,7 @@ static struct pci_dev *of_create_pci_dev(struct pci_pbm_info *pbm,
        dev->current_state = 4;         /* unknown power state */
        dev->error_state = pci_channel_io_normal;
+        dev->dma_mask = 0xffffffff;
        if (!strcmp(node->name, "pci")) {
                /* a PCI-PCI bridge */
@@ -715,9 +722,10 @@ void pcibios_update_irq(struct pci_dev *pdev, int irq)
 {
 }
-void pcibios_align_resource(void *data, struct resource *res,
+resource_size_t pcibios_align_resource(void *data, const struct resource *res,
-                            resource_size_t size, resource_size_t align)
+                                resource_size_t size, resource_size_t align)
 {
+        return res->start;
 }
 int pcibios_enable_device(struct pci_dev *dev, int mask)
@@ -1064,7 +1072,6 @@ int pci64_dma_supported(struct pci_dev *pdev, u64 device_mask)
        return (device_mask & dma_addr_mask) == dma_addr_mask;
 }
-EXPORT_SYMBOL(pci_dma_supported);
 void pci_resource_to_user(const struct pci_dev *pdev, int bar,
                          const struct resource *rp, resource_size_t *start,
@@ -1081,3 +1088,85 @@ void pci_resource_to_user(const struct pci_dev *pdev, int bar,
        *start = rp->start - offset;
        *end = rp->end - offset;
 }
+static int __init pcibios_init(void)
+{
+        pci_dfl_cache_line_size = 64 >> 2;
+        return 0;
+}
+subsys_initcall(pcibios_init);
+#ifdef CONFIG_SYSFS
+static void __devinit pci_bus_slot_names(struct device_node *node,
+                                         struct pci_bus *bus)
+{
+        const struct pci_slot_names {
+                u32     slot_mask;
+                char    names[0];
+        } *prop;
+        const char *sp;
+        int len, i;
+        u32 mask;
+        prop = of_get_property(node, "slot-names", &len);
+        if (!prop)
+                return;
+        mask = prop->slot_mask;
+        sp = prop->names;
+        if (ofpci_verbose)
+                printk("PCI: Making slots for [%s] mask[0x%02x]\n",
+                       node->full_name, mask);
+        i = 0;
+        while (mask) {
+                struct pci_slot *pci_slot;
+                u32 this_bit = 1 << i;
+                if (!(mask & this_bit)) {
+                        i++;
+                        continue;
+                }
+                if (ofpci_verbose)
+                        printk("PCI: Making slot [%s]\n", sp);
+                pci_slot = pci_create_slot(bus, i, sp, NULL);
+                if (IS_ERR(pci_slot))
+                        printk(KERN_ERR "PCI: pci_create_slot returned %ld\n",
+                               PTR_ERR(pci_slot));
+                sp += strlen(sp) + 1;
+                mask &= ~this_bit;
+                i++;
+        }
+}
+static int __init of_pci_slot_init(void)
+{
+        struct pci_bus *pbus = NULL;
+        while ((pbus = pci_find_next_bus(pbus)) != NULL) {
+                struct device_node *node;
+                if (pbus->self) {
+                        struct dev_archdata *sd = pbus->self->sysdata;
+                        /* PCI->PCI bridge */
+                        node = sd->prom_node;
+                } else {
+                        struct pci_pbm_info *pbm = pbus->sysdata;
+                        /* Host PCI controller */
+                        node = pbm->op->node;
+                }
+                pci_bus_slot_names(node, pbus);
+        }
+        return 0;
+}
+module_init(of_pci_slot_init);
+#endif
diff --git a/arch/sparc/kernel/pci_common.c b/arch/sparc/kernel/pci_common.c
index b775658a927d..8a000583b5cf 100644
--- a/arch/sparc/kernel/pci_common.c
+++ b/arch/sparc/kernel/pci_common.c
@@ -371,14 +371,19 @@ static void pci_register_iommu_region(struct pci_pbm_info *pbm)
                struct resource *rp = kzalloc(sizeof(*rp), GFP_KERNEL);
                if (!rp) {
-                        prom_printf("Cannot allocate IOMMU resource.\n");
+                        pr_info("%s: Cannot allocate IOMMU resource.\n",
-                        prom_halt();
+                                pbm->name);
+                        return;
                }
                rp->name = "IOMMU";
                rp->start = pbm->mem_space.start + (unsigned long) vdma[0];
                rp->end = rp->start + (unsigned long) vdma[1] - 1UL;
                rp->flags = IORESOURCE_BUSY;
-                request_resource(&pbm->mem_space, rp);
+                if (request_resource(&pbm->mem_space, rp)) {
+                        pr_info("%s: Unable to request IOMMU resource.\n",
+                                pbm->name);
+                        kfree(rp);
+                }
        }
 }
diff --git a/arch/sparc/kernel/pci_msi.c b/arch/sparc/kernel/pci_msi.c
index f1be37a7b123..e0ef847219c3 100644
--- a/arch/sparc/kernel/pci_msi.c
+++ b/arch/sparc/kernel/pci_msi.c
@@ -4,6 +4,7 @@
 */
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/irq.h>
 #include "pci_impl.h"
@@ -112,7 +113,7 @@ static void free_msi(struct pci_pbm_info *pbm, int msi_num)
 }
 static struct irq_chip msi_irq = {
-        .typename       = "PCI-MSI",
+        .name           = "PCI-MSI",
        .mask           = mask_msi_irq,
        .unmask         = unmask_msi_irq,
        .enable         = unmask_msi_irq,
diff --git a/arch/sparc/kernel/pcic.c b/arch/sparc/kernel/pcic.c
index 85e7037429b9..d36a8d391ca0 100644
--- a/arch/sparc/kernel/pcic.c
+++ b/arch/sparc/kernel/pcic.c
@@ -30,6 +30,7 @@
 #include <asm/oplib.h>
 #include <asm/prom.h>
 #include <asm/pcic.h>
+#include <asm/timex.h>
 #include <asm/timer.h>
 #include <asm/uaccess.h>
 #include <asm/irq_regs.h>
@@ -163,8 +164,6 @@ void __iomem *pcic_regs;
 volatile int pcic_speculative;
 volatile int pcic_trapped;
-static void pci_do_gettimeofday(struct timeval *tv);
-static int pci_do_settimeofday(struct timespec *tv);
 #define CONFIG_CMD(bus, device_fn, where) (0x80000000 | (((unsigned int)bus) << 16) | (((unsigned int)device_fn) << 8) | (where & ~3))
@@ -586,8 +585,6 @@ pcic_fill_irq(struct linux_pcic *pcic, struct pci_dev *dev, int node)
                        writew(ivec, pcic->pcic_regs+PCI_INT_SELECT_LO);
                }
        }
-        return;
 }
 /*
@@ -716,19 +713,27 @@ static irqreturn_t pcic_timer_handler (int irq, void *h)
 #define USECS_PER_JIFFY  10000  /* We have 100HZ "standard" timer for sparc */
 #define TICK_TIMER_LIMIT ((100*1000000/4)/100)
+u32 pci_gettimeoffset(void)
+{
+        /*
+         * We divide all by 100
+         * to have microsecond resolution and to avoid overflow
+         */
+        unsigned long count =
+            readl(pcic0.pcic_regs+PCI_SYS_COUNTER) & ~PCI_SYS_COUNTER_OVERFLOW;
+        count = ((count/100)*USECS_PER_JIFFY) / (TICK_TIMER_LIMIT/100);
+        return count * 1000;
+}
 void __init pci_time_init(void)
 {
        struct linux_pcic *pcic = &pcic0;
        unsigned long v;
        int timer_irq, irq;
-        /* A hack until do_gettimeofday prototype is moved to arch specific headers
+        do_arch_gettimeoffset = pci_gettimeoffset;
-           and btfixupped. Patch do_gettimeofday with ba pci_do_gettimeofday; nop */
-        ((unsigned int *)do_gettimeofday)[0] = 
-            0x10800000 | ((((unsigned long)pci_do_gettimeofday -
-             (unsigned long)do_gettimeofday) >> 2) & 0x003fffff);
-        ((unsigned int *)do_gettimeofday)[1] = 0x01000000;
-        BTFIXUPSET_CALL(bus_do_settimeofday, pci_do_settimeofday, BTFIXUPCALL_NORM);
        btfixup();
        writel (TICK_TIMER_LIMIT, pcic->pcic_regs+PCI_SYS_LIMIT);
@@ -746,84 +751,6 @@ void __init pci_time_init(void)
        local_irq_enable();
 }
-static inline unsigned long do_gettimeoffset(void)
-{
-        /*
-         * We divide all by 100
-         * to have microsecond resolution and to avoid overflow
-         */
-        unsigned long count =
-            readl(pcic0.pcic_regs+PCI_SYS_COUNTER) & ~PCI_SYS_COUNTER_OVERFLOW;
-        count = ((count/100)*USECS_PER_JIFFY) / (TICK_TIMER_LIMIT/100);
-        return count;
-}
-static void pci_do_gettimeofday(struct timeval *tv)
-{
-        unsigned long flags;
-        unsigned long seq;
-        unsigned long usec, sec;
-        unsigned long max_ntp_tick = tick_usec - tickadj;
-        do {
-                seq = read_seqbegin_irqsave(&xtime_lock, flags);
-                usec = do_gettimeoffset();
-                /*
-                 * If time_adjust is negative then NTP is slowing the clock
-                 * so make sure not to go into next possible interval.
-                 * Better to lose some accuracy than have time go backwards..
-                 */
-                if (unlikely(time_adjust < 0))
-                        usec = min(usec, max_ntp_tick);
-                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;
-}
-static int pci_do_settimeofday(struct timespec *tv)
-{
-        if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
-                return -EINVAL;
-        /*
-         * This is revolting. We need to set "xtime" correctly. However, the
-         * value in this location is the value at the most recent update of
-         * wall time.  Discover what correction gettimeofday() would have
-         * made, and then undo it!
-         */
-        tv->tv_nsec -= 1000 * do_gettimeoffset();
-        while (tv->tv_nsec < 0) {
-                tv->tv_nsec += NSEC_PER_SEC;
-                tv->tv_sec--;
-        }
-        wall_to_monotonic.tv_sec += xtime.tv_sec - tv->tv_sec;
-        wall_to_monotonic.tv_nsec += xtime.tv_nsec - tv->tv_nsec;
-        if (wall_to_monotonic.tv_nsec > NSEC_PER_SEC) {
-                wall_to_monotonic.tv_nsec -= NSEC_PER_SEC;
-                wall_to_monotonic.tv_sec++;
-        }
-        if (wall_to_monotonic.tv_nsec < 0) {
-                wall_to_monotonic.tv_nsec += NSEC_PER_SEC;
-                wall_to_monotonic.tv_sec--;
-        }
-        xtime.tv_sec = tv->tv_sec;
-        xtime.tv_nsec = tv->tv_nsec;
-        ntp_clear();
-        return 0;
-}
 #if 0
 static void watchdog_reset() {
@@ -839,9 +766,10 @@ char * __devinit pcibios_setup(char *str)
        return str;
 }
-void pcibios_align_resource(void *data, struct resource *res,
+resource_size_t pcibios_align_resource(void *data, const struct resource *res,
-                            resource_size_t size, resource_size_t align)
+                                resource_size_t size, resource_size_t align)
 {
+        return res->start;
 }
 int pcibios_enable_device(struct pci_dev *pdev, int mask)
diff --git a/arch/sparc/kernel/pcr.c b/arch/sparc/kernel/pcr.c
index 2d94e7a03af5..c4a6a50b4849 100644
--- a/arch/sparc/kernel/pcr.c
+++ b/arch/sparc/kernel/pcr.c
@@ -8,6 +8,7 @@
 #include <linux/irq.h>
 #include <linux/perf_event.h>
+#include <linux/ftrace.h>
 #include <asm/pil.h>
 #include <asm/pcr.h>
@@ -34,7 +35,7 @@ unsigned int picl_shift;
 * 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)
+void __irq_entry deferred_pcr_work_irq(int irq, struct pt_regs *regs)
 {
        struct pt_regs *old_regs;
diff --git a/arch/sparc/kernel/perf_event.c b/arch/sparc/kernel/perf_event.c
index fa5936e1c3b9..e2771939341d 100644
--- a/arch/sparc/kernel/perf_event.c
+++ b/arch/sparc/kernel/perf_event.c
@@ -1,6 +1,6 @@
 /* Performance event support for sparc64.
 *
- * Copyright (C) 2009 David S. Miller <davem@davemloft.net>
+ * Copyright (C) 2009, 2010 David S. Miller <davem@davemloft.net>
 *
 * This code is based almost entirely upon the x86 perf event
 * code, which is:
@@ -18,11 +18,15 @@
 #include <linux/kdebug.h>
 #include <linux/mutex.h>
+#include <asm/stacktrace.h>
 #include <asm/cpudata.h>
+#include <asm/uaccess.h>
 #include <asm/atomic.h>
 #include <asm/nmi.h>
 #include <asm/pcr.h>
+#include "kstack.h"
 /* Sparc64 chips have two performance counters, 32-bits each, with
 * overflow interrupts generated on transition from 0xffffffff to 0.
 * The counters are accessed in one go using a 64-bit register.
@@ -51,16 +55,49 @@
 #define PIC_UPPER_INDEX                 0
 #define PIC_LOWER_INDEX                 1
+#define PIC_NO_INDEX                    -1
 struct cpu_hw_events {
-        struct perf_event       *events[MAX_HWEVENTS];
+        /* Number of events currently scheduled onto this cpu.
-        unsigned long           used_mask[BITS_TO_LONGS(MAX_HWEVENTS)];
+         * This tells how many entries in the arrays below
-        unsigned long           active_mask[BITS_TO_LONGS(MAX_HWEVENTS)];
+         * are valid.
+         */
+        int                     n_events;
+        /* Number of new events added since the last hw_perf_disable().
+         * This works because the perf event layer always adds new
+         * events inside of a perf_{disable,enable}() sequence.
+         */
+        int                     n_added;
+        /* Array of events current scheduled on this cpu.  */
+        struct perf_event       *event[MAX_HWEVENTS];
+        /* Array of encoded longs, specifying the %pcr register
+         * encoding and the mask of PIC counters this even can
+         * be scheduled on.  See perf_event_encode() et al.
+         */
+        unsigned long           events[MAX_HWEVENTS];
+        /* The current counter index assigned to an event.  When the
+         * event hasn't been programmed into the cpu yet, this will
+         * hold PIC_NO_INDEX.  The event->hw.idx value tells us where
+         * we ought to schedule the event.
+         */
+        int                     current_idx[MAX_HWEVENTS];
+        /* Software copy of %pcr register on this cpu.  */
        u64                     pcr;
+        /* Enabled/disable state.  */
        int                     enabled;
 };
 DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events) = { .enabled = 1, };
+/* An event map describes the characteristics of a performance
+ * counter event.  In particular it gives the encoding as well as
+ * a mask telling which counters the event can be measured on.
+ */
 struct perf_event_map {
        u16     encoding;
        u8      pic_mask;
@@ -69,15 +106,20 @@ struct perf_event_map {
 #define PIC_LOWER       0x02
 };
+/* Encode a perf_event_map entry into a long.  */
 static unsigned long perf_event_encode(const struct perf_event_map *pmap)
 {
        return ((unsigned long) pmap->encoding << 16) | pmap->pic_mask;
 }
-static void perf_event_decode(unsigned long val, u16 *enc, u8 *msk)
+static u8 perf_event_get_msk(unsigned long val)
 {
-        *msk = val & 0xff;
+        return val & 0xff;
-        *enc = val >> 16;
+}
+static u64 perf_event_get_enc(unsigned long val)
+{
+        return val >> 16;
 }
 #define C(x) PERF_COUNT_HW_CACHE_##x
@@ -491,53 +533,6 @@ static inline void sparc_pmu_disable_event(struct cpu_hw_events *cpuc, struct hw
        pcr_ops->write(cpuc->pcr);
 }
-void hw_perf_enable(void)
-{
-        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
-        u64 val;
-        int i;
-        if (cpuc->enabled)
-                return;
-        cpuc->enabled = 1;
-        barrier();
-        val = cpuc->pcr;
-        for (i = 0; i < MAX_HWEVENTS; i++) {
-                struct perf_event *cp = cpuc->events[i];
-                struct hw_perf_event *hwc;
-                if (!cp)
-                        continue;
-                hwc = &cp->hw;
-                val |= hwc->config_base;
-        }
-        cpuc->pcr = val;
-        pcr_ops->write(cpuc->pcr);
-}
-void hw_perf_disable(void)
-{
-        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
-        u64 val;
-        if (!cpuc->enabled)
-                return;
-        cpuc->enabled = 0;
-        val = cpuc->pcr;
-        val &= ~(PCR_UTRACE | PCR_STRACE |
-                 sparc_pmu->hv_bit | sparc_pmu->irq_bit);
-        cpuc->pcr = val;
-        pcr_ops->write(cpuc->pcr);
-}
 static u32 read_pmc(int idx)
 {
        u64 val;
@@ -566,6 +561,30 @@ static void write_pmc(int idx, u64 val)
        write_pic(pic);
 }
+static u64 sparc_perf_event_update(struct perf_event *event,
+                                   struct hw_perf_event *hwc, int idx)
+{
+        int shift = 64 - 32;
+        u64 prev_raw_count, new_raw_count;
+        s64 delta;
+again:
+        prev_raw_count = atomic64_read(&hwc->prev_count);
+        new_raw_count = read_pmc(idx);
+        if (atomic64_cmpxchg(&hwc->prev_count, prev_raw_count,
+                             new_raw_count) != prev_raw_count)
+                goto again;
+        delta = (new_raw_count << shift) - (prev_raw_count << shift);
+        delta >>= shift;
+        atomic64_add(delta, &event->count);
+        atomic64_sub(delta, &hwc->period_left);
+        return new_raw_count;
+}
 static int sparc_perf_event_set_period(struct perf_event *event,
                                       struct hw_perf_event *hwc, int idx)
 {
@@ -598,81 +617,166 @@ static int sparc_perf_event_set_period(struct perf_event *event,
        return ret;
 }
-static int sparc_pmu_enable(struct perf_event *event)
+/* If performance event entries have been added, move existing
+ * events around (if necessary) and then assign new entries to
+ * counters.
+ */
+static u64 maybe_change_configuration(struct cpu_hw_events *cpuc, u64 pcr)
 {
-        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
+        int i;
-        struct hw_perf_event *hwc = &event->hw;
-        int idx = hwc->idx;
-        if (test_and_set_bit(idx, cpuc->used_mask))
+        if (!cpuc->n_added)
-                return -EAGAIN;
+                goto out;
-        sparc_pmu_disable_event(cpuc, hwc, idx);
+        /* Read in the counters which are moving.  */
+        for (i = 0; i < cpuc->n_events; i++) {
+                struct perf_event *cp = cpuc->event[i];
-        cpuc->events[idx] = event;
+                if (cpuc->current_idx[i] != PIC_NO_INDEX &&
-        set_bit(idx, cpuc->active_mask);
+                    cpuc->current_idx[i] != cp->hw.idx) {
+                        sparc_perf_event_update(cp, &cp->hw,
+                                                cpuc->current_idx[i]);
+                        cpuc->current_idx[i] = PIC_NO_INDEX;
+                }
+        }
-        sparc_perf_event_set_period(event, hwc, idx);
+        /* Assign to counters all unassigned events.  */
-        sparc_pmu_enable_event(cpuc, hwc, idx);
+        for (i = 0; i < cpuc->n_events; i++) {
-        perf_event_update_userpage(event);
+                struct perf_event *cp = cpuc->event[i];
-        return 0;
+                struct hw_perf_event *hwc = &cp->hw;
+                int idx = hwc->idx;
+                u64 enc;
+                if (cpuc->current_idx[i] != PIC_NO_INDEX)
+                        continue;
+                sparc_perf_event_set_period(cp, hwc, idx);
+                cpuc->current_idx[i] = idx;
+                enc = perf_event_get_enc(cpuc->events[i]);
+                pcr |= event_encoding(enc, idx);
+        }
+out:
+        return pcr;
 }
-static u64 sparc_perf_event_update(struct perf_event *event,
+void hw_perf_enable(void)
-                                   struct hw_perf_event *hwc, int idx)
 {
-        int shift = 64 - 32;
+        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
-        u64 prev_raw_count, new_raw_count;
+        u64 pcr;
-        s64 delta;
-again:
+        if (cpuc->enabled)
-        prev_raw_count = atomic64_read(&hwc->prev_count);
+                return;
-        new_raw_count = read_pmc(idx);
-        if (atomic64_cmpxchg(&hwc->prev_count, prev_raw_count,
+        cpuc->enabled = 1;
-                             new_raw_count) != prev_raw_count)
+        barrier();
-                goto again;
-        delta = (new_raw_count << shift) - (prev_raw_count << shift);
+        pcr = cpuc->pcr;
-        delta >>= shift;
+        if (!cpuc->n_events) {
+                pcr = 0;
+        } else {
+                pcr = maybe_change_configuration(cpuc, pcr);
-        atomic64_add(delta, &event->count);
+                /* We require that all of the events have the same
-        atomic64_sub(delta, &hwc->period_left);
+                 * configuration, so just fetch the settings from the
+                 * first entry.
+                 */
+                cpuc->pcr = pcr | cpuc->event[0]->hw.config_base;
+        }
-        return new_raw_count;
+        pcr_ops->write(cpuc->pcr);
+}
+void hw_perf_disable(void)
+{
+        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
+        u64 val;
+        if (!cpuc->enabled)
+                return;
+        cpuc->enabled = 0;
+        cpuc->n_added = 0;
+        val = cpuc->pcr;
+        val &= ~(PCR_UTRACE | PCR_STRACE |
+                 sparc_pmu->hv_bit | sparc_pmu->irq_bit);
+        cpuc->pcr = val;
+        pcr_ops->write(cpuc->pcr);
 }
 static void sparc_pmu_disable(struct perf_event *event)
 {
        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
        struct hw_perf_event *hwc = &event->hw;
-        int idx = hwc->idx;
+        unsigned long flags;
+        int i;
-        clear_bit(idx, cpuc->active_mask);
+        local_irq_save(flags);
-        sparc_pmu_disable_event(cpuc, hwc, idx);
+        perf_disable();
+        for (i = 0; i < cpuc->n_events; i++) {
+                if (event == cpuc->event[i]) {
+                        int idx = cpuc->current_idx[i];
+                        /* Shift remaining entries down into
+                         * the existing slot.
+                         */
+                        while (++i < cpuc->n_events) {
+                                cpuc->event[i - 1] = cpuc->event[i];
+                                cpuc->events[i - 1] = cpuc->events[i];
+                                cpuc->current_idx[i - 1] =
+                                        cpuc->current_idx[i];
+                        }
+                        /* Absorb the final count and turn off the
+                         * event.
+                         */
+                        sparc_pmu_disable_event(cpuc, hwc, idx);
+                        barrier();
+                        sparc_perf_event_update(event, hwc, idx);
-        barrier();
+                        perf_event_update_userpage(event);
-        sparc_perf_event_update(event, hwc, idx);
+                        cpuc->n_events--;
-        cpuc->events[idx] = NULL;
+                        break;
-        clear_bit(idx, cpuc->used_mask);
+                }
+        }
-        perf_event_update_userpage(event);
+        perf_enable();
+        local_irq_restore(flags);
+}
+static int active_event_index(struct cpu_hw_events *cpuc,
+                              struct perf_event *event)
+{
+        int i;
+        for (i = 0; i < cpuc->n_events; i++) {
+                if (cpuc->event[i] == event)
+                        break;
+        }
+        BUG_ON(i == cpuc->n_events);
+        return cpuc->current_idx[i];
 }
 static void sparc_pmu_read(struct perf_event *event)
 {
+        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
+        int idx = active_event_index(cpuc, event);
        struct hw_perf_event *hwc = &event->hw;
-        sparc_perf_event_update(event, hwc, hwc->idx);
+        sparc_perf_event_update(event, hwc, idx);
 }
 static void sparc_pmu_unthrottle(struct perf_event *event)
 {
        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
+        int idx = active_event_index(cpuc, event);
        struct hw_perf_event *hwc = &event->hw;
-        sparc_pmu_enable_event(cpuc, hwc, hwc->idx);
+        sparc_pmu_enable_event(cpuc, hwc, idx);
 }
 static atomic_t active_events = ATOMIC_INIT(0);
@@ -750,43 +854,75 @@ static void hw_perf_event_destroy(struct perf_event *event)
 /* Make sure all events can be scheduled into the hardware at
 * the same time.  This is simplified by the fact that we only
 * need to support 2 simultaneous HW events.
+ *
+ * As a side effect, the evts[]->hw.idx values will be assigned
+ * on success.  These are pending indexes.  When the events are
+ * actually programmed into the chip, these values will propagate
+ * to the per-cpu cpuc->current_idx[] slots, see the code in
+ * maybe_change_configuration() for details.
 */
-static int sparc_check_constraints(unsigned long *events, int n_ev)
+static int sparc_check_constraints(struct perf_event **evts,
+                                   unsigned long *events, int n_ev)
 {
-        if (n_ev <= perf_max_events) {
+        u8 msk0 = 0, msk1 = 0;
-                u8 msk1, msk2;
+        int idx0 = 0;
-                u16 dummy;
+        /* This case is possible when we are invoked from
-                if (n_ev == 1)
+         * hw_perf_group_sched_in().
-                        return 0;
+         */
-                BUG_ON(n_ev != 2);
+        if (!n_ev)
-                perf_event_decode(events[0], &dummy, &msk1);
+                return 0;
-                perf_event_decode(events[1], &dummy, &msk2);
+        if (n_ev > perf_max_events)
-                /* If both events can go on any counter, OK.  */
+                return -1;
-                if (msk1 == (PIC_UPPER | PIC_LOWER) &&
-                    msk2 == (PIC_UPPER | PIC_LOWER))
+        msk0 = perf_event_get_msk(events[0]);
-                        return 0;
+        if (n_ev == 1) {
+                if (msk0 & PIC_LOWER)
-                /* If one event is limited to a specific counter,
+                        idx0 = 1;
-                 * and the other can go on both, OK.
+                goto success;
-                 */
+        }
-                if ((msk1 == PIC_UPPER || msk1 == PIC_LOWER) &&
+        BUG_ON(n_ev != 2);
-                    msk2 == (PIC_UPPER | PIC_LOWER))
+        msk1 = perf_event_get_msk(events[1]);
-                        return 0;
-                if ((msk2 == PIC_UPPER || msk2 == PIC_LOWER) &&
+        /* If both events can go on any counter, OK.  */
-                    msk1 == (PIC_UPPER | PIC_LOWER))
+        if (msk0 == (PIC_UPPER | PIC_LOWER) &&
-                        return 0;
+            msk1 == (PIC_UPPER | PIC_LOWER))
+                goto success;
-                /* If the events are fixed to different counters, OK.  */
-                if ((msk1 == PIC_UPPER && msk2 == PIC_LOWER) ||
+        /* If one event is limited to a specific counter,
-                    (msk1 == PIC_LOWER && msk2 == PIC_UPPER))
+         * and the other can go on both, OK.
-                        return 0;
+         */
+        if ((msk0 == PIC_UPPER || msk0 == PIC_LOWER) &&
-                /* Otherwise, there is a conflict.  */
+            msk1 == (PIC_UPPER | PIC_LOWER)) {
+                if (msk0 & PIC_LOWER)
+                        idx0 = 1;
+                goto success;
        }
+        if ((msk1 == PIC_UPPER || msk1 == PIC_LOWER) &&
+            msk0 == (PIC_UPPER | PIC_LOWER)) {
+                if (msk1 & PIC_UPPER)
+                        idx0 = 1;
+                goto success;
+        }
+        /* If the events are fixed to different counters, OK.  */
+        if ((msk0 == PIC_UPPER && msk1 == PIC_LOWER) ||
+            (msk0 == PIC_LOWER && msk1 == PIC_UPPER)) {
+                if (msk0 & PIC_LOWER)
+                        idx0 = 1;
+                goto success;
+        }
+        /* Otherwise, there is a conflict.  */
        return -1;
+success:
+        evts[0]->hw.idx = idx0;
+        if (n_ev == 2)
+                evts[1]->hw.idx = idx0 ^ 1;
+        return 0;
 }
 static int check_excludes(struct perf_event **evts, int n_prev, int n_new)
@@ -818,7 +954,8 @@ static int check_excludes(struct perf_event **evts, int n_prev, int n_new)
 }
 static int collect_events(struct perf_event *group, int max_count,
-                          struct perf_event *evts[], unsigned long *events)
+                          struct perf_event *evts[], unsigned long *events,
+                          int *current_idx)
 {
        struct perf_event *event;
        int n = 0;
@@ -827,7 +964,8 @@ static int collect_events(struct perf_event *group, int max_count,
                if (n >= max_count)
                        return -1;
                evts[n] = group;
-                events[n++] = group->hw.event_base;
+                events[n] = group->hw.event_base;
+                current_idx[n++] = PIC_NO_INDEX;
        }
        list_for_each_entry(event, &group->sibling_list, group_entry) {
                if (!is_software_event(event) &&
@@ -835,20 +973,100 @@ static int collect_events(struct perf_event *group, int max_count,
                        if (n >= max_count)
                                return -1;
                        evts[n] = event;
-                        events[n++] = event->hw.event_base;
+                        events[n] = event->hw.event_base;
+                        current_idx[n++] = PIC_NO_INDEX;
                }
        }
        return n;
 }
+static void event_sched_in(struct perf_event *event)
+{
+        event->state = PERF_EVENT_STATE_ACTIVE;
+        event->oncpu = smp_processor_id();
+        event->tstamp_running += event->ctx->time - event->tstamp_stopped;
+        if (is_software_event(event))
+                event->pmu->enable(event);
+}
+int hw_perf_group_sched_in(struct perf_event *group_leader,
+                           struct perf_cpu_context *cpuctx,
+                           struct perf_event_context *ctx)
+{
+        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
+        struct perf_event *sub;
+        int n0, n;
+        if (!sparc_pmu)
+                return 0;
+        n0 = cpuc->n_events;
+        n = collect_events(group_leader, perf_max_events - n0,
+                           &cpuc->event[n0], &cpuc->events[n0],
+                           &cpuc->current_idx[n0]);
+        if (n < 0)
+                return -EAGAIN;
+        if (check_excludes(cpuc->event, n0, n))
+                return -EINVAL;
+        if (sparc_check_constraints(cpuc->event, cpuc->events, n + n0))
+                return -EAGAIN;
+        cpuc->n_events = n0 + n;
+        cpuc->n_added += n;
+        cpuctx->active_oncpu += n;
+        n = 1;
+        event_sched_in(group_leader);
+        list_for_each_entry(sub, &group_leader->sibling_list, group_entry) {
+                if (sub->state != PERF_EVENT_STATE_OFF) {
+                        event_sched_in(sub);
+                        n++;
+                }
+        }
+        ctx->nr_active += n;
+        return 1;
+}
+static int sparc_pmu_enable(struct perf_event *event)
+{
+        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
+        int n0, ret = -EAGAIN;
+        unsigned long flags;
+        local_irq_save(flags);
+        perf_disable();
+        n0 = cpuc->n_events;
+        if (n0 >= perf_max_events)
+                goto out;
+        cpuc->event[n0] = event;
+        cpuc->events[n0] = event->hw.event_base;
+        cpuc->current_idx[n0] = PIC_NO_INDEX;
+        if (check_excludes(cpuc->event, n0, 1))
+                goto out;
+        if (sparc_check_constraints(cpuc->event, cpuc->events, n0 + 1))
+                goto out;
+        cpuc->n_events++;
+        cpuc->n_added++;
+        ret = 0;
+out:
+        perf_enable();
+        local_irq_restore(flags);
+        return ret;
+}
 static int __hw_perf_event_init(struct perf_event *event)
 {
        struct perf_event_attr *attr = &event->attr;
        struct perf_event *evts[MAX_HWEVENTS];
        struct hw_perf_event *hwc = &event->hw;
        unsigned long events[MAX_HWEVENTS];
+        int current_idx_dmy[MAX_HWEVENTS];
        const struct perf_event_map *pmap;
-        u64 enc;
        int n;
        if (atomic_read(&nmi_active) < 0)
@@ -865,10 +1083,7 @@ static int __hw_perf_event_init(struct perf_event *event)
        } else
                return -EOPNOTSUPP;
-        /* We save the enable bits in the config_base.  So to
+        /* We save the enable bits in the config_base.  */
-         * turn off sampling just write 'config', and to enable
-         * things write 'config | config_base'.
-         */
        hwc->config_base = sparc_pmu->irq_bit;
        if (!attr->exclude_user)
                hwc->config_base |= PCR_UTRACE;
@@ -879,13 +1094,11 @@ static int __hw_perf_event_init(struct perf_event *event)
        hwc->event_base = perf_event_encode(pmap);
-        enc = pmap->encoding;
        n = 0;
        if (event->group_leader != event) {
                n = collect_events(event->group_leader,
                                   perf_max_events - 1,
-                                   evts, events);
+                                   evts, events, current_idx_dmy);
                if (n < 0)
                        return -EINVAL;
        }
@@ -895,9 +1108,11 @@ static int __hw_perf_event_init(struct perf_event *event)
        if (check_excludes(evts, n, 1))
                return -EINVAL;
-        if (sparc_check_constraints(events, n + 1))
+        if (sparc_check_constraints(evts, events, n + 1))
                return -EINVAL;
+        hwc->idx = PIC_NO_INDEX;
        /* Try to do all error checking before this point, as unwinding
         * state after grabbing the PMC is difficult.
         */
@@ -910,15 +1125,6 @@ static int __hw_perf_event_init(struct perf_event *event)
                atomic64_set(&hwc->period_left, hwc->sample_period);
        }
-        if (pmap->pic_mask & PIC_UPPER) {
-                hwc->idx = PIC_UPPER_INDEX;
-                enc <<= sparc_pmu->upper_shift;
-        } else {
-                hwc->idx = PIC_LOWER_INDEX;
-                enc <<= sparc_pmu->lower_shift;
-        }
-        hwc->config |= enc;
        return 0;
 }
@@ -968,7 +1174,7 @@ static int __kprobes perf_event_nmi_handler(struct notifier_block *self,
        struct perf_sample_data data;
        struct cpu_hw_events *cpuc;
        struct pt_regs *regs;
-        int idx;
+        int i;
        if (!atomic_read(&active_events))
                return NOTIFY_DONE;
@@ -983,16 +1189,26 @@ static int __kprobes perf_event_nmi_handler(struct notifier_block *self,
        regs = args->regs;
-        data.addr = 0;
+        perf_sample_data_init(&data, 0);
        cpuc = &__get_cpu_var(cpu_hw_events);
-        for (idx = 0; idx < MAX_HWEVENTS; idx++) {
-                struct perf_event *event = cpuc->events[idx];
+        /* If the PMU has the TOE IRQ enable bits, we need to do a
+         * dummy write to the %pcr to clear the overflow bits and thus
+         * the interrupt.
+         *
+         * Do this before we peek at the counters to determine
+         * overflow so we don't lose any events.
+         */
+        if (sparc_pmu->irq_bit)
+                pcr_ops->write(cpuc->pcr);
+        for (i = 0; i < cpuc->n_events; i++) {
+                struct perf_event *event = cpuc->event[i];
+                int idx = cpuc->current_idx[i];
                struct hw_perf_event *hwc;
                u64 val;
-                if (!test_bit(idx, cpuc->active_mask))
-                        continue;
                hwc = &event->hw;
                val = sparc_perf_event_update(event, hwc, idx);
                if (val & (1ULL << 31))
@@ -1044,10 +1260,122 @@ void __init init_hw_perf_events(void)
        pr_cont("Supported PMU type is '%s'\n", sparc_pmu_type);
-        /* All sparc64 PMUs currently have 2 events.  But this simple
+        /* All sparc64 PMUs currently have 2 events.  */
-         * driver only supports one active event at a time.
+        perf_max_events = 2;
-         */
-        perf_max_events = 1;
        register_die_notifier(&perf_event_nmi_notifier);
 }
+static inline void callchain_store(struct perf_callchain_entry *entry, u64 ip)
+{
+        if (entry->nr < PERF_MAX_STACK_DEPTH)
+                entry->ip[entry->nr++] = ip;
+}
+static void perf_callchain_kernel(struct pt_regs *regs,
+                                  struct perf_callchain_entry *entry)
+{
+        unsigned long ksp, fp;
+        callchain_store(entry, PERF_CONTEXT_KERNEL);
+        callchain_store(entry, regs->tpc);
+        ksp = regs->u_regs[UREG_I6];
+        fp = ksp + STACK_BIAS;
+        do {
+                struct sparc_stackf *sf;
+                struct pt_regs *regs;
+                unsigned long pc;
+                if (!kstack_valid(current_thread_info(), fp))
+                        break;
+                sf = (struct sparc_stackf *) fp;
+                regs = (struct pt_regs *) (sf + 1);
+                if (kstack_is_trap_frame(current_thread_info(), regs)) {
+                        if (user_mode(regs))
+                                break;
+                        pc = regs->tpc;
+                        fp = regs->u_regs[UREG_I6] + STACK_BIAS;
+                } else {
+                        pc = sf->callers_pc;
+                        fp = (unsigned long)sf->fp + STACK_BIAS;
+                }
+                callchain_store(entry, pc);
+        } while (entry->nr < PERF_MAX_STACK_DEPTH);
+}
+static void perf_callchain_user_64(struct pt_regs *regs,
+                                   struct perf_callchain_entry *entry)
+{
+        unsigned long ufp;
+        callchain_store(entry, PERF_CONTEXT_USER);
+        callchain_store(entry, regs->tpc);
+        ufp = regs->u_regs[UREG_I6] + STACK_BIAS;
+        do {
+                struct sparc_stackf *usf, sf;
+                unsigned long pc;
+                usf = (struct sparc_stackf *) ufp;
+                if (__copy_from_user_inatomic(&sf, usf, sizeof(sf)))
+                        break;
+                pc = sf.callers_pc;
+                ufp = (unsigned long)sf.fp + STACK_BIAS;
+                callchain_store(entry, pc);
+        } while (entry->nr < PERF_MAX_STACK_DEPTH);
+}
+static void perf_callchain_user_32(struct pt_regs *regs,
+                                   struct perf_callchain_entry *entry)
+{
+        unsigned long ufp;
+        callchain_store(entry, PERF_CONTEXT_USER);
+        callchain_store(entry, regs->tpc);
+        ufp = regs->u_regs[UREG_I6] & 0xffffffffUL;
+        do {
+                struct sparc_stackf32 *usf, sf;
+                unsigned long pc;
+                usf = (struct sparc_stackf32 *) ufp;
+                if (__copy_from_user_inatomic(&sf, usf, sizeof(sf)))
+                        break;
+                pc = sf.callers_pc;
+                ufp = (unsigned long)sf.fp;
+                callchain_store(entry, pc);
+        } while (entry->nr < PERF_MAX_STACK_DEPTH);
+}
+/* Like powerpc we can't get PMU interrupts within the PMU handler,
+ * so no need for separate NMI and IRQ chains as on x86.
+ */
+static DEFINE_PER_CPU(struct perf_callchain_entry, callchain);
+struct perf_callchain_entry *perf_callchain(struct pt_regs *regs)
+{
+        struct perf_callchain_entry *entry = &__get_cpu_var(callchain);
+        entry->nr = 0;
+        if (!user_mode(regs)) {
+                stack_trace_flush();
+                perf_callchain_kernel(regs, entry);
+                if (current->mm)
+                        regs = task_pt_regs(current);
+                else
+                        regs = NULL;
+        }
+        if (regs) {
+                flushw_user();
+                if (test_thread_flag(TIF_32BIT))
+                        perf_callchain_user_32(regs, entry);
+                else
+                        perf_callchain_user_64(regs, entry);
+        }
+        return entry;
+}
diff --git a/arch/sparc/kernel/process_32.c b/arch/sparc/kernel/process_32.c
index 2830b415e214..40e29fc8a4d6 100644
--- a/arch/sparc/kernel/process_32.c
+++ b/arch/sparc/kernel/process_32.c
@@ -17,13 +17,13 @@
 #include <linux/mm.h>
 #include <linux/stddef.h>
 #include <linux/ptrace.h>
-#include <linux/slab.h>
 #include <linux/user.h>
 #include <linux/smp.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/init.h>
+#include <linux/slab.h>
 #include <asm/auxio.h>
 #include <asm/oplib.h>
@@ -526,7 +526,7 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
                         * Set some valid stack frames to give to the child.
                         */
                        childstack = (struct sparc_stackf __user *)
-                                (sp & ~0x7UL);
+                                (sp & ~0xfUL);
                        parentstack = (struct sparc_stackf __user *)
                                regs->u_regs[UREG_FP];
diff --git a/arch/sparc/kernel/process_64.c b/arch/sparc/kernel/process_64.c
index 18d67854a1b8..a5cf3864b31f 100644
--- a/arch/sparc/kernel/process_64.c
+++ b/arch/sparc/kernel/process_64.c
@@ -352,12 +352,6 @@ void exit_thread(void)
                else
                        t->utraps[0]--;
        }
-        if (test_and_clear_thread_flag(TIF_PERFCTR)) {
-                t->user_cntd0 = t->user_cntd1 = NULL;
-                t->pcr_reg = 0;
-                write_pcr(0);
-        }
 }
 void flush_thread(void)
@@ -365,27 +359,12 @@ void flush_thread(void)
        struct thread_info *t = current_thread_info();
        struct mm_struct *mm;
-        if (test_ti_thread_flag(t, TIF_ABI_PENDING)) {
-                clear_ti_thread_flag(t, TIF_ABI_PENDING);
-                if (test_ti_thread_flag(t, TIF_32BIT))
-                        clear_ti_thread_flag(t, TIF_32BIT);
-                else
-                        set_ti_thread_flag(t, TIF_32BIT);
-        }
        mm = t->task->mm;
        if (mm)
                tsb_context_switch(mm);
        set_thread_wsaved(0);
-        /* Turn off performance counters if on. */
-        if (test_and_clear_thread_flag(TIF_PERFCTR)) {
-                t->user_cntd0 = t->user_cntd1 = NULL;
-                t->pcr_reg = 0;
-                write_pcr(0);
-        }
        /* Clear FPU register state. */
        t->fpsaved[0] = 0;
        
@@ -406,11 +385,11 @@ static unsigned long clone_stackframe(unsigned long csp, unsigned long psp)
        } else
                __get_user(fp, &(((struct reg_window32 __user *)psp)->ins[6]));
-        /* Now 8-byte align the stack as this is mandatory in the
+        /* Now align the stack as this is mandatory in the Sparc ABI
-         * Sparc ABI due to how register windows work.  This hides
+         * due to how register windows work.  This hides the
-         * the restriction from thread libraries etc.  -DaveM
+         * restriction from thread libraries etc.
         */
-        csp &= ~7UL;
+        csp &= ~15UL;
        distance = fp - psp;
        rval = (csp - distance);
@@ -599,16 +578,6 @@ int copy_thread(unsigned long clone_flags, unsigned long sp,
                t->kregs->u_regs[UREG_FP] =
                  ((unsigned long) child_sf) - STACK_BIAS;
-                /* Special case, if we are spawning a kernel thread from
-                 * a userspace task (usermode helper, NFS or similar), we
-                 * must disable performance counters in the child because
-                 * the address space and protection realm are changing.
-                 */
-                if (t->flags & _TIF_PERFCTR) {
-                        t->user_cntd0 = t->user_cntd1 = NULL;
-                        t->pcr_reg = 0;
-                        t->flags &= ~_TIF_PERFCTR;
-                }
                t->flags |= ((long)ASI_P << TI_FLAG_CURRENT_DS_SHIFT);
                t->kregs->u_regs[UREG_G6] = (unsigned long) t;
                t->kregs->u_regs[UREG_G4] = (unsigned long) t->task;
diff --git a/arch/sparc/kernel/prom.h b/arch/sparc/kernel/prom.h
index 453397fe5e14..a8591ef2636d 100644
--- a/arch/sparc/kernel/prom.h
+++ b/arch/sparc/kernel/prom.h
@@ -4,9 +4,6 @@
 #include <linux/spinlock.h>
 #include <asm/prom.h>
-extern struct device_node *allnodes;    /* temporary while merging */
-extern rwlock_t devtree_lock;   /* temporary while merging */
 extern void * prom_early_alloc(unsigned long size);
 extern void irq_trans_init(struct device_node *dp);
diff --git a/arch/sparc/kernel/prom_common.c b/arch/sparc/kernel/prom_common.c
index d80a65d9e893..57ac9e28be0c 100644
--- a/arch/sparc/kernel/prom_common.c
+++ b/arch/sparc/kernel/prom_common.c
@@ -37,18 +37,6 @@ EXPORT_SYMBOL(of_console_path);
 char *of_console_options;
 EXPORT_SYMBOL(of_console_options);
-struct device_node *of_find_node_by_phandle(phandle handle)
-{
-        struct device_node *np;
-        for (np = allnodes; np; np = np->allnext)
-                if (np->node == handle)
-                        break;
-        return np;
-}
-EXPORT_SYMBOL(of_find_node_by_phandle);
 int of_getintprop_default(struct device_node *np, const char *name, int def)
 {
        struct property *prop;
@@ -89,7 +77,7 @@ int of_set_property(struct device_node *dp, const char *name, void *val, int len
                        void *old_val = prop->value;
                        int ret;
-                        ret = prom_setprop(dp->node, name, val, len);
+                        ret = prom_setprop(dp->phandle, name, val, len);
                        err = -EINVAL;
                        if (ret >= 0) {
@@ -236,7 +224,7 @@ static struct device_node * __init prom_create_node(phandle node,
        dp->name = get_one_property(node, "name");
        dp->type = get_one_property(node, "device_type");
-        dp->node = node;
+        dp->phandle = node;
        dp->properties = build_prop_list(node);
@@ -313,7 +301,7 @@ void __init prom_build_devicetree(void)
        nextp = &allnodes->allnext;
        allnodes->child = prom_build_tree(allnodes,
-                                          prom_getchild(allnodes->node),
+                                          prom_getchild(allnodes->phandle),
                                          &nextp);
        of_console_init();
diff --git a/arch/sparc/kernel/ptrace_32.c b/arch/sparc/kernel/ptrace_32.c
index 7e3dfd9bb97e..e608f397e11f 100644
--- a/arch/sparc/kernel/ptrace_32.c
+++ b/arch/sparc/kernel/ptrace_32.c
@@ -65,6 +65,7 @@ static int genregs32_get(struct task_struct *target,
                        *k++ = regs->u_regs[pos++];
                reg_window = (unsigned long __user *) regs->u_regs[UREG_I6];
+                reg_window -= 16;
                for (; count > 0 && pos < 32; count--) {
                        if (get_user(*k++, &reg_window[pos++]))
                                return -EFAULT;
@@ -76,6 +77,7 @@ static int genregs32_get(struct task_struct *target,
                }
                reg_window = (unsigned long __user *) regs->u_regs[UREG_I6];
+                reg_window -= 16;
                for (; count > 0 && pos < 32; count--) {
                        if (get_user(reg, &reg_window[pos++]) ||
                            put_user(reg, u++))
@@ -141,6 +143,7 @@ static int genregs32_set(struct task_struct *target,
                        regs->u_regs[pos++] = *k++;
                reg_window = (unsigned long __user *) regs->u_regs[UREG_I6];
+                reg_window -= 16;
                for (; count > 0 && pos < 32; count--) {
                        if (put_user(*k++, &reg_window[pos++]))
                                return -EFAULT;
@@ -153,6 +156,7 @@ static int genregs32_set(struct task_struct *target,
                }
                reg_window = (unsigned long __user *) regs->u_regs[UREG_I6];
+                reg_window -= 16;
                for (; count > 0 && pos < 32; count--) {
                        if (get_user(reg, u++) ||
                            put_user(reg, &reg_window[pos++]))
diff --git a/arch/sparc/kernel/ptrace_64.c b/arch/sparc/kernel/ptrace_64.c
index 4ae91dc2feb9..aa90da08bf61 100644
--- a/arch/sparc/kernel/ptrace_64.c
+++ b/arch/sparc/kernel/ptrace_64.c
@@ -23,6 +23,7 @@
 #include <linux/signal.h>
 #include <linux/regset.h>
 #include <linux/tracehook.h>
+#include <trace/syscall.h>
 #include <linux/compat.h>
 #include <linux/elf.h>
@@ -37,6 +38,9 @@
 #include <asm/cpudata.h>
 #include <asm/cacheflush.h>
+#define CREATE_TRACE_POINTS
+#include <trace/events/syscalls.h>
 #include "entry.h"
 /* #define ALLOW_INIT_TRACING */
@@ -488,6 +492,7 @@ static int genregs32_get(struct task_struct *target,
                        *k++ = regs->u_regs[pos++];
                reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6];
+                reg_window -= 16;
                if (target == current) {
                        for (; count > 0 && pos < 32; count--) {
                                if (get_user(*k++, &reg_window[pos++]))
@@ -512,6 +517,7 @@ static int genregs32_get(struct task_struct *target,
                }
                reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6];
+                reg_window -= 16;
                if (target == current) {
                        for (; count > 0 && pos < 32; count--) {
                                if (get_user(reg, &reg_window[pos++]) ||
@@ -595,6 +601,7 @@ static int genregs32_set(struct task_struct *target,
                        regs->u_regs[pos++] = *k++;
                reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6];
+                reg_window -= 16;
                if (target == current) {
                        for (; count > 0 && pos < 32; count--) {
                                if (put_user(*k++, &reg_window[pos++]))
@@ -621,6 +628,7 @@ static int genregs32_set(struct task_struct *target,
                }
                reg_window = (compat_ulong_t __user *) regs->u_regs[UREG_I6];
+                reg_window -= 16;
                if (target == current) {
                        for (; count > 0 && pos < 32; count--) {
                                if (get_user(reg, u++) ||
@@ -1059,6 +1067,9 @@ asmlinkage int syscall_trace_enter(struct pt_regs *regs)
        if (test_thread_flag(TIF_SYSCALL_TRACE))
                ret = tracehook_report_syscall_entry(regs);
+        if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
+                trace_sys_enter(regs, regs->u_regs[UREG_G1]);
        if (unlikely(current->audit_context) && !ret)
                audit_syscall_entry((test_thread_flag(TIF_32BIT) ?
                                     AUDIT_ARCH_SPARC :
@@ -1084,6 +1095,9 @@ asmlinkage void syscall_trace_leave(struct pt_regs *regs)
                audit_syscall_exit(result, regs->u_regs[UREG_I0]);
        }
+        if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
+                trace_sys_exit(regs, regs->u_regs[UREG_G1]);
        if (test_thread_flag(TIF_SYSCALL_TRACE))
                tracehook_report_syscall_exit(regs, 0);
 }
diff --git a/arch/sparc/kernel/rtrap_64.S b/arch/sparc/kernel/rtrap_64.S
index fd3cee4d117c..090b9e9ad5e3 100644
--- a/arch/sparc/kernel/rtrap_64.S
+++ b/arch/sparc/kernel/rtrap_64.S
@@ -65,48 +65,6 @@ __handle_user_windows:
                ba,pt                   %xcc, __handle_user_windows_continue
                 andn                   %l1, %l4, %l1
-__handle_perfctrs:
-                call                    update_perfctrs
-                 wrpr                   %g0, RTRAP_PSTATE, %pstate
-                wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
-                ldub                    [%g6 + TI_WSAVED], %o2
-                brz,pt                  %o2, 1f
-                 nop
-                /* Redo userwin+sched+sig checks */
-                call                    fault_in_user_windows
-                 wrpr                   %g0, RTRAP_PSTATE, %pstate
-                wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
-                ldx                     [%g6 + TI_FLAGS], %l0
-                andcc                   %l0, _TIF_NEED_RESCHED, %g0
-                be,pt                   %xcc, 1f
-                 nop
-                call                    schedule
-                 wrpr                   %g0, RTRAP_PSTATE, %pstate
-                wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
-                ldx                     [%g6 + TI_FLAGS], %l0
-1:              andcc                   %l0, _TIF_DO_NOTIFY_RESUME_MASK, %g0
-                be,pt                   %xcc, __handle_perfctrs_continue
-                 sethi                  %hi(TSTATE_PEF), %o0
-                mov                     %l5, %o1
-                add                     %sp, PTREGS_OFF, %o0
-                mov                     %l0, %o2
-                call                    do_notify_resume
-                 wrpr                   %g0, RTRAP_PSTATE, %pstate
-                wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
-                /* Signal delivery can modify pt_regs tstate, so we must
-                 * reload it.
-                 */
-                ldx                     [%sp + PTREGS_OFF + PT_V9_TSTATE], %l1
-                sethi                   %hi(0xf << 20), %l4
-                and                     %l1, %l4, %l4
-                andn                    %l1, %l4, %l1
-                ba,pt                   %xcc, __handle_perfctrs_continue
-                 sethi                  %hi(TSTATE_PEF), %o0
 __handle_userfpu:
                rd                      %fprs, %l5
                andcc                   %l5, FPRS_FEF, %g0
@@ -149,11 +107,11 @@ rtrap_nmi:	ldx			[%sp + PTREGS_OFF + PT_V9_TSTATE], %l1
 rtrap_irq:
 rtrap:
 #ifndef CONFIG_SMP
-                sethi                   %hi(per_cpu____cpu_data), %l0
+                sethi                   %hi(__cpu_data), %l0
-                lduw                    [%l0 + %lo(per_cpu____cpu_data)], %l1
+                lduw                    [%l0 + %lo(__cpu_data)], %l1
 #else
-                sethi                   %hi(per_cpu____cpu_data), %l0
+                sethi                   %hi(__cpu_data), %l0
-                or                      %l0, %lo(per_cpu____cpu_data), %l0
+                or                      %l0, %lo(__cpu_data), %l0
                lduw                    [%l0 + %g5], %l1
 #endif
                cmp                     %l1, 0
@@ -172,7 +130,17 @@ rtrap_xcall:
                 nop
                call                    trace_hardirqs_on
                 nop
-                wrpr                    %l4, %pil
+                /* Do not actually set the %pil here.  We will do that
+                 * below after we clear PSTATE_IE in the %pstate register.
+                 * If we re-enable interrupts here, we can recurse down
+                 * the hardirq stack potentially endlessly, causing a
+                 * stack overflow.
+                 *
+                 * It is tempting to put this test and trace_hardirqs_on
+                 * call at the 'rt_continue' label, but that will not work
+                 * as that path hits unconditionally and we do not want to
+                 * execute this in NMI return paths, for example.
+                 */
 #endif
 rtrap_no_irq_enable:
                andcc                   %l1, TSTATE_PRIV, %l3
@@ -191,9 +159,9 @@ rtrap_no_irq_enable:
                 * take until the next local IRQ before the signal/resched
                 * event would be handled.
                 *
-                 * This also means that if we have to deal with performance
+                 * This also means that if we have to deal with user
-                 * counters or user windows, we have to redo all of these
+                 * windows, we have to redo all of these sched+signal checks
-                 * sched+signal checks with IRQs disabled.
+                 * with IRQs disabled.
                 */
 to_user:        wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
                wrpr                    0, %pil
@@ -214,12 +182,8 @@ __handle_signal_continue:
                brnz,pn                 %o2, __handle_user_windows
                 nop
 __handle_user_windows_continue:
-                ldx                     [%g6 + TI_FLAGS], %l5
-                andcc                   %l5, _TIF_PERFCTR, %g0
                sethi                   %hi(TSTATE_PEF), %o0
-                bne,pn                  %xcc, __handle_perfctrs
+                andcc                   %l1, %o0, %g0
-__handle_perfctrs_continue:
-                 andcc                  %l1, %o0, %g0
                /* This fpdepth clear is necessary for non-syscall rtraps only */
 user_nowork:
diff --git a/arch/sparc/kernel/setup_32.c b/arch/sparc/kernel/setup_32.c
index 9be2af55c5cd..b22ce6100403 100644
--- a/arch/sparc/kernel/setup_32.c
+++ b/arch/sparc/kernel/setup_32.c
@@ -95,8 +95,6 @@ static void prom_sync_me(void)
                             "nop\n\t"
                             "nop\n\t" : : "r" (prom_tbr));
        local_irq_restore(flags);
-        return;
 }
 static unsigned int boot_flags __initdata = 0;
diff --git a/arch/sparc/kernel/setup_64.c b/arch/sparc/kernel/setup_64.c
index 21180339cb09..5f72de67588b 100644
--- a/arch/sparc/kernel/setup_64.c
+++ b/arch/sparc/kernel/setup_64.c
@@ -12,7 +12,6 @@
 #include <linux/stddef.h>
 #include <linux/unistd.h>
 #include <linux/ptrace.h>
-#include <linux/slab.h>
 #include <asm/smp.h>
 #include <linux/user.h>
 #include <linux/screen_info.h>
@@ -46,6 +45,7 @@
 #include <asm/setup.h>
 #include <asm/mmu.h>
 #include <asm/ns87303.h>
+#include <asm/btext.h>
 #ifdef CONFIG_IP_PNP
 #include <net/ipconfig.h>
@@ -286,7 +286,10 @@ void __init setup_arch(char **cmdline_p)
        parse_early_param();
        boot_flags_init(*cmdline_p);
-        register_console(&prom_early_console);
+#ifdef CONFIG_EARLYFB
+        if (btext_find_display())
+#endif
+                register_console(&prom_early_console);
        if (tlb_type == hypervisor)
                printk("ARCH: SUN4V\n");
diff --git a/arch/sparc/kernel/signal32.c b/arch/sparc/kernel/signal32.c
index ba5b09ad6666..ea22cd373c64 100644
--- a/arch/sparc/kernel/signal32.c
+++ b/arch/sparc/kernel/signal32.c
@@ -120,8 +120,8 @@ struct rt_signal_frame32 {
 };
 /* Align macros */
-#define SF_ALIGNEDSZ  (((sizeof(struct signal_frame32) + 7) & (~7)))
+#define SF_ALIGNEDSZ  (((sizeof(struct signal_frame32) + 15) & (~15)))
-#define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
+#define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame32) + 15) & (~15)))
 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
 {
@@ -420,15 +420,17 @@ static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, uns
                        sp = current->sas_ss_sp + current->sas_ss_size;
        }
+        sp -= framesize;
        /* Always align the stack frame.  This handles two cases.  First,
         * sigaltstack need not be mindful of platform specific stack
         * alignment.  Second, if we took this signal because the stack
         * is not aligned properly, we'd like to take the signal cleanly
         * and report that.
         */
-        sp &= ~7UL;
+        sp &= ~15UL;
-        return (void __user *)(sp - framesize);
+        return (void __user *) sp;
 }
 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
diff --git a/arch/sparc/kernel/signal_32.c b/arch/sparc/kernel/signal_32.c
index 7ce1a1005b1d..9882df92ba0a 100644
--- a/arch/sparc/kernel/signal_32.c
+++ b/arch/sparc/kernel/signal_32.c
@@ -267,15 +267,17 @@ static inline void __user *get_sigframe(struct sigaction *sa, struct pt_regs *re
                        sp = current->sas_ss_sp + current->sas_ss_size;
        }
+        sp -= framesize;
        /* Always align the stack frame.  This handles two cases.  First,
         * sigaltstack need not be mindful of platform specific stack
         * alignment.  Second, if we took this signal because the stack
         * is not aligned properly, we'd like to take the signal cleanly
         * and report that.
         */
-        sp &= ~7UL;
+        sp &= ~15UL;
-        return (void __user *)(sp - framesize);
+        return (void __user *) sp;
 }
 static inline int
diff --git a/arch/sparc/kernel/signal_64.c b/arch/sparc/kernel/signal_64.c
index 647afbda7ae1..9fa48c30037e 100644
--- a/arch/sparc/kernel/signal_64.c
+++ b/arch/sparc/kernel/signal_64.c
@@ -353,7 +353,7 @@ segv:
 /* Checks if the fp is valid */
 static int invalid_frame_pointer(void __user *fp, int fplen)
 {
-        if (((unsigned long) fp) & 7)
+        if (((unsigned long) fp) & 15)
                return 1;
        return 0;
 }
@@ -396,15 +396,17 @@ static inline void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *
                        sp = current->sas_ss_sp + current->sas_ss_size;
        }
+        sp -= framesize;
        /* Always align the stack frame.  This handles two cases.  First,
         * sigaltstack need not be mindful of platform specific stack
         * alignment.  Second, if we took this signal because the stack
         * is not aligned properly, we'd like to take the signal cleanly
         * and report that.
         */
-        sp &= ~7UL;
+        sp &= ~15UL;
-        return (void __user *)(sp - framesize);
+        return (void __user *) sp;
 }
 static inline void
diff --git a/arch/sparc/kernel/smp_32.c b/arch/sparc/kernel/smp_32.c
index 132d81fb2616..91c10fb70858 100644
--- a/arch/sparc/kernel/smp_32.c
+++ b/arch/sparc/kernel/smp_32.c
@@ -32,6 +32,7 @@
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 #include <asm/cpudata.h>
+#include <asm/leon.h>
 #include "irq.h"
@@ -96,6 +97,9 @@ void __init smp_cpus_done(unsigned int max_cpus)
        case sun4d:
                smp4d_smp_done();
                break;
+        case sparc_leon:
+                leon_smp_done();
+                break;
        case sun4e:
                printk("SUN4E\n");
                BUG();
@@ -306,6 +310,9 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
        case sun4d:
                smp4d_boot_cpus();
                break;
+        case sparc_leon:
+                leon_boot_cpus();
+                break;
        case sun4e:
                printk("SUN4E\n");
                BUG();
@@ -376,6 +383,9 @@ int __cpuinit __cpu_up(unsigned int cpu)
        case sun4d:
                ret = smp4d_boot_one_cpu(cpu);
                break;
+        case sparc_leon:
+                ret = leon_boot_one_cpu(cpu);
+                break;
        case sun4e:
                printk("SUN4E\n");
                BUG();
diff --git a/arch/sparc/kernel/smp_64.c b/arch/sparc/kernel/smp_64.c
index aa36223497b9..b6a2b8f47040 100644
--- a/arch/sparc/kernel/smp_64.c
+++ b/arch/sparc/kernel/smp_64.c
@@ -22,7 +22,9 @@
 #include <linux/profile.h>
 #include <linux/bootmem.h>
 #include <linux/vmalloc.h>
+#include <linux/ftrace.h>
 #include <linux/cpu.h>
+#include <linux/slab.h>
 #include <asm/head.h>
 #include <asm/ptrace.h>
@@ -370,7 +372,7 @@ static int __cpuinit smp_boot_one_cpu(unsigned int cpu)
        } else {
                struct device_node *dp = of_find_node_by_cpuid(cpu);
-                prom_startcpu(dp->node, entry, cookie);
+                prom_startcpu(dp->phandle, entry, cookie);
        }
        for (timeout = 0; timeout < 50000; timeout++) {
@@ -822,13 +824,13 @@ void arch_send_call_function_single_ipi(int cpu)
                      &cpumask_of_cpu(cpu));
 }
-void smp_call_function_client(int irq, struct pt_regs *regs)
+void __irq_entry smp_call_function_client(int irq, struct pt_regs *regs)
 {
        clear_softint(1 << irq);
        generic_smp_call_function_interrupt();
 }
-void smp_call_function_single_client(int irq, struct pt_regs *regs)
+void __irq_entry smp_call_function_single_client(int irq, struct pt_regs *regs)
 {
        clear_softint(1 << irq);
        generic_smp_call_function_single_interrupt();
@@ -964,7 +966,7 @@ void flush_dcache_page_all(struct mm_struct *mm, struct page *page)
        put_cpu();
 }
-void smp_new_mmu_context_version_client(int irq, struct pt_regs *regs)
+void __irq_entry smp_new_mmu_context_version_client(int irq, struct pt_regs *regs)
 {
        struct mm_struct *mm;
        unsigned long flags;
@@ -1148,7 +1150,7 @@ void smp_release(void)
 */
 extern void prom_world(int);
-void smp_penguin_jailcell(int irq, struct pt_regs *regs)
+void __irq_entry smp_penguin_jailcell(int irq, struct pt_regs *regs)
 {
        clear_softint(1 << irq);
@@ -1364,7 +1366,7 @@ void smp_send_reschedule(int cpu)
                      &cpumask_of_cpu(cpu));
 }
-void smp_receive_signal_client(int irq, struct pt_regs *regs)
+void __irq_entry smp_receive_signal_client(int irq, struct pt_regs *regs)
 {
        clear_softint(1 << irq);
 }
diff --git a/arch/sparc/kernel/sparc_ksyms_64.c b/arch/sparc/kernel/sparc_ksyms_64.c
index 0f26066a08d9..372ad59c4cba 100644
--- a/arch/sparc/kernel/sparc_ksyms_64.c
+++ b/arch/sparc/kernel/sparc_ksyms_64.c
@@ -38,17 +38,5 @@ EXPORT_SYMBOL(sun4v_niagara_setperf);
 EXPORT_SYMBOL(sun4v_niagara2_getperf);
 EXPORT_SYMBOL(sun4v_niagara2_setperf);
-#ifdef CONFIG_PCI
-/* inline functions in asm/pci_64.h */
-EXPORT_SYMBOL(pci_alloc_consistent);
-EXPORT_SYMBOL(pci_free_consistent);
-EXPORT_SYMBOL(pci_map_single);
-EXPORT_SYMBOL(pci_unmap_single);
-EXPORT_SYMBOL(pci_map_sg);
-EXPORT_SYMBOL(pci_unmap_sg);
-EXPORT_SYMBOL(pci_dma_sync_single_for_cpu);
-EXPORT_SYMBOL(pci_dma_sync_sg_for_cpu);
-#endif
 /* Exporting a symbol from /init/main.c */
 EXPORT_SYMBOL(saved_command_line);
diff --git a/arch/sparc/kernel/sun4c_irq.c b/arch/sparc/kernel/sun4c_irq.c
index bc3adbf79c6a..892fb884910a 100644
--- a/arch/sparc/kernel/sun4c_irq.c
+++ b/arch/sparc/kernel/sun4c_irq.c
@@ -16,7 +16,6 @@
 #include <linux/sched.h>
 #include <linux/ptrace.h>
 #include <linux/interrupt.h>
-#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
diff --git a/arch/sparc/kernel/sun4d_smp.c b/arch/sparc/kernel/sun4d_smp.c
index 68791cad7b74..482f2ab92692 100644
--- a/arch/sparc/kernel/sun4d_smp.c
+++ b/arch/sparc/kernel/sun4d_smp.c
@@ -194,7 +194,7 @@ int __cpuinit smp4d_boot_one_cpu(int i)
                        smp_penguin_ctable.reg_size = 0;
                        /* whirrr, whirrr, whirrrrrrrrr... */
-                        SMP_PRINTK(("Starting CPU %d at %p \n", i, entry));
+                        SMP_PRINTK(("Starting CPU %d at %p\n", i, entry));
                        local_flush_cache_all();
                        prom_startcpu(cpu_node,
                                      &smp_penguin_ctable, 0, (char *)entry);
diff --git a/arch/sparc/kernel/sun4m_irq.c b/arch/sparc/kernel/sun4m_irq.c
index 301892e2d718..7f3b97ff62c1 100644
--- a/arch/sparc/kernel/sun4m_irq.c
+++ b/arch/sparc/kernel/sun4m_irq.c
@@ -17,7 +17,6 @@
 #include <linux/ptrace.h>
 #include <linux/smp.h>
 #include <linux/interrupt.h>
-#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/of.h>
diff --git a/arch/sparc/kernel/sys32.S b/arch/sparc/kernel/sys32.S
index e7061138c98a..46a76ba3fb4b 100644
--- a/arch/sparc/kernel/sys32.S
+++ b/arch/sparc/kernel/sys32.S
@@ -51,7 +51,6 @@ SIGN1(sys32_exit_group, sys_exit_group, %o0)
 SIGN1(sys32_wait4, compat_sys_wait4, %o2)
 SIGN1(sys32_creat, sys_creat, %o1)
 SIGN1(sys32_mknod, sys_mknod, %o1)
-SIGN1(sys32_perfctr, sys_perfctr, %o0)
 SIGN1(sys32_umount, sys_umount, %o1)
 SIGN1(sys32_signal, sys_signal, %o0)
 SIGN1(sys32_access, sys_access, %o1)
diff --git a/arch/sparc/kernel/sys_sparc32.c b/arch/sparc/kernel/sys_sparc32.c
index 04e28b2671c8..c0ca87553e1c 100644
--- a/arch/sparc/kernel/sys_sparc32.c
+++ b/arch/sparc/kernel/sys_sparc32.c
@@ -21,16 +21,10 @@
 #include <linux/sem.h>
 #include <linux/msg.h>
 #include <linux/shm.h>
-#include <linux/slab.h>
 #include <linux/uio.h>
 #include <linux/nfs_fs.h>
 #include <linux/quota.h>
 #include <linux/module.h>
-#include <linux/sunrpc/svc.h>
-#include <linux/nfsd/nfsd.h>
-#include <linux/nfsd/cache.h>
-#include <linux/nfsd/xdr.h>
-#include <linux/nfsd/syscall.h>
 #include <linux/poll.h>
 #include <linux/personality.h>
 #include <linux/stat.h>
@@ -48,8 +42,8 @@
 #include <linux/security.h>
 #include <linux/compat.h>
 #include <linux/vfs.h>
-#include <linux/netfilter_ipv4/ip_tables.h>
 #include <linux/ptrace.h>
+#include <linux/slab.h>
 #include <asm/types.h>
 #include <asm/uaccess.h>
@@ -569,85 +563,6 @@ asmlinkage long sparc32_open(const char __user *filename,
        return do_sys_open(AT_FDCWD, filename, flags, mode);
 }
-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 sys32_mremap(unsigned long addr,
-        unsigned long old_len, unsigned long new_len,
-        unsigned long flags, u32 __new_addr)
-{
-        unsigned long ret = -EINVAL;
-        unsigned long new_addr = __new_addr;
-        if (unlikely(sparc_mmap_check(addr, old_len)))
-                goto out;
-        if (unlikely(sparc_mmap_check(new_addr, new_len)))
-                goto out;
-        down_write(&current->mm->mmap_sem);
-        ret = do_mremap(addr, old_len, new_len, flags, new_addr);
-        up_write(&current->mm->mmap_sem);
-out:
-        return ret;       
-}
-struct __sysctl_args32 {
-        u32 name;
-        int nlen;
-        u32 oldval;
-        u32 oldlenp;
-        u32 newval;
-        u32 newlen;
-        u32 __unused[4];
-};
-asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args)
-{
-#ifndef CONFIG_SYSCTL_SYSCALL
-        return -ENOSYS;
-#else
-        struct __sysctl_args32 tmp;
-        int error;
-        size_t oldlen, __user *oldlenp = NULL;
-        unsigned long addr = (((unsigned long)&args->__unused[0]) + 7UL) & ~7UL;
-        if (copy_from_user(&tmp, args, sizeof(tmp)))
-                return -EFAULT;
-        if (tmp.oldval && tmp.oldlenp) {
-                /* Duh, this is ugly and might not work if sysctl_args
-                   is in read-only memory, but do_sysctl does indirectly
-                   a lot of uaccess in both directions and we'd have to
-                   basically copy the whole sysctl.c here, and
-                   glibc's __sysctl uses rw memory for the structure
-                   anyway.  */
-                if (get_user(oldlen, (u32 __user *)(unsigned long)tmp.oldlenp) ||
-                    put_user(oldlen, (size_t __user *)addr))
-                        return -EFAULT;
-                oldlenp = (size_t __user *)addr;
-        }
-        lock_kernel();
-        error = do_sysctl((int __user *)(unsigned long) tmp.name,
-                          tmp.nlen,
-                          (void __user *)(unsigned long) tmp.oldval,
-                          oldlenp,
-                          (void __user *)(unsigned long) tmp.newval,
-                          tmp.newlen);
-        unlock_kernel();
-        if (oldlenp) {
-                if (!error) {
-                        if (get_user(oldlen, (size_t __user *)addr) ||
-                            put_user(oldlen, (u32 __user *)(unsigned long) tmp.oldlenp))
-                                error = -EFAULT;
-                }
-                if (copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused)))
-                        error = -EFAULT;
-        }
-        return error;
-#endif
-}
 long sys32_lookup_dcookie(unsigned long cookie_high,
                          unsigned long cookie_low,
                          char __user *buf, size_t len)
diff --git a/arch/sparc/kernel/sys_sparc_32.c b/arch/sparc/kernel/sys_sparc_32.c
index 03035c852a43..ee995b7dae7e 100644
--- a/arch/sparc/kernel/sys_sparc_32.c
+++ b/arch/sparc/kernel/sys_sparc_32.c
@@ -45,7 +45,8 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsi
                /* We do not accept a shared mapping if it would violate
                 * cache aliasing constraints.
                 */
-                if ((flags & MAP_SHARED) && (addr & (SHMLBA - 1)))
+                if ((flags & MAP_SHARED) &&
+                    ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))
                        return -EINVAL;
                return addr;
        }
@@ -79,15 +80,6 @@ unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsi
        }
 }
-asmlinkage unsigned long sparc_brk(unsigned long brk)
-{
-        if(ARCH_SUN4C) {
-                if ((brk & 0xe0000000) != (current->mm->brk & 0xe0000000))
-                        return current->mm->brk;
-        }
-        return sys_brk(brk);
-}
 /*
 * sys_pipe() is the normal C calling standard for creating
 * a pipe. It's not the way unix traditionally does this, though.
@@ -106,119 +98,6 @@ out:
        return error;
 }
-/*
- * sys_ipc() is the de-multiplexer for the SysV IPC calls..
- *
- * This is really horribly ugly.
- */
-asmlinkage int sys_ipc (uint call, int first, int second, int third, void __user *ptr, long fifth)
-{
-        int version, err;
-        version = call >> 16; /* hack for backward compatibility */
-        call &= 0xffff;
-        if (call <= SEMCTL)
-                switch (call) {
-                case SEMOP:
-                        err = sys_semtimedop (first, (struct sembuf __user *)ptr, second, NULL);
-                        goto out;
-                case SEMTIMEDOP:
-                        err = sys_semtimedop (first, (struct sembuf __user *)ptr, second, (const struct timespec __user *) fifth);
-                        goto out;
-                case SEMGET:
-                        err = sys_semget (first, second, third);
-                        goto out;
-                case SEMCTL: {
-                        union semun fourth;
-                        err = -EINVAL;
-                        if (!ptr)
-                                goto out;
-                        err = -EFAULT;
-                        if (get_user(fourth.__pad,
-                                     (void __user * __user *)ptr))
-                                goto out;
-                        err = sys_semctl (first, second, third, fourth);
-                        goto out;
-                        }
-                default:
-                        err = -ENOSYS;
-                        goto out;
-                }
-        if (call <= MSGCTL) 
-                switch (call) {
-                case MSGSND:
-                        err = sys_msgsnd (first, (struct msgbuf __user *) ptr, 
-                                          second, third);
-                        goto out;
-                case MSGRCV:
-                        switch (version) {
-                        case 0: {
-                                struct ipc_kludge tmp;
-                                err = -EINVAL;
-                                if (!ptr)
-                                        goto out;
-                                err = -EFAULT;
-                                if (copy_from_user(&tmp, (struct ipc_kludge __user *) ptr, sizeof (tmp)))
-                                        goto out;
-                                err = sys_msgrcv (first, tmp.msgp, second, tmp.msgtyp, third);
-                                goto out;
-                                }
-                        case 1: default:
-                                err = sys_msgrcv (first,
-                                                  (struct msgbuf __user *) ptr,
-                                                  second, fifth, third);
-                                goto out;
-                        }
-                case MSGGET:
-                        err = sys_msgget ((key_t) first, second);
-                        goto out;
-                case MSGCTL:
-                        err = sys_msgctl (first, second, (struct msqid_ds __user *) ptr);
-                        goto out;
-                default:
-                        err = -ENOSYS;
-                        goto out;
-                }
-        if (call <= SHMCTL) 
-                switch (call) {
-                case SHMAT:
-                        switch (version) {
-                        case 0: default: {
-                                ulong raddr;
-                                err = do_shmat (first, (char __user *) ptr, second, &raddr);
-                                if (err)
-                                        goto out;
-                                err = -EFAULT;
-                                if (put_user (raddr, (ulong __user *) third))
-                                        goto out;
-                                err = 0;
-                                goto out;
-                                }
-                        case 1: /* iBCS2 emulator entry point */
-                                err = -EINVAL;
-                                goto out;
-                        }
-                case SHMDT: 
-                        err = sys_shmdt ((char __user *)ptr);
-                        goto out;
-                case SHMGET:
-                        err = sys_shmget (first, second, third);
-                        goto out;
-                case SHMCTL:
-                        err = sys_shmctl (first, second, (struct shmid_ds __user *) ptr);
-                        goto out;
-                default:
-                        err = -ENOSYS;
-                        goto out;
-                }
-        else
-                err = -ENOSYS;
-out:
-        return err;
-}
 int sparc_mmap_check(unsigned long addr, unsigned long len)
 {
        if (ARCH_SUN4C &&
@@ -234,31 +113,6 @@ int sparc_mmap_check(unsigned long addr, unsigned long len)
 }
 /* Linux version of mmap */
-static unsigned long do_mmap2(unsigned long addr, unsigned long len,
-        unsigned long prot, unsigned long flags, unsigned long fd,
-        unsigned long pgoff)
-{
-        struct file * file = NULL;
-        unsigned long retval = -EBADF;
-        if (!(flags & MAP_ANONYMOUS)) {
-                file = fget(fd);
-                if (!file)
-                        goto out;
-        }
-        len = PAGE_ALIGN(len);
-        flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
-        down_write(&current->mm->mmap_sem);
-        retval = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
-        up_write(&current->mm->mmap_sem);
-        if (file)
-                fput(file);
-out:
-        return retval;
-}
 asmlinkage unsigned long sys_mmap2(unsigned long addr, unsigned long len,
        unsigned long prot, unsigned long flags, unsigned long fd,
@@ -266,14 +120,16 @@ asmlinkage unsigned long sys_mmap2(unsigned long addr, unsigned long len,
 {
        /* Make sure the shift for mmap2 is constant (12), no matter what PAGE_SIZE
           we have. */
-        return do_mmap2(addr, len, prot, flags, fd, pgoff >> (PAGE_SHIFT - 12));
+        return sys_mmap_pgoff(addr, len, prot, flags, fd,
+                              pgoff >> (PAGE_SHIFT - 12));
 }
 asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
        unsigned long prot, unsigned long flags, unsigned long fd,
        unsigned long off)
 {
-        return do_mmap2(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
+        /* no alignment check? */
+        return sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
 }
 long sparc_remap_file_pages(unsigned long start, unsigned long size,
@@ -287,27 +143,6 @@ long sparc_remap_file_pages(unsigned long start, unsigned long size,
                                    (pgoff >> (PAGE_SHIFT - 12)), flags);
 }
-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 sparc_mremap(unsigned long addr,
-        unsigned long old_len, unsigned long new_len,
-        unsigned long flags, unsigned long new_addr)
-{
-        unsigned long ret = -EINVAL;
-        if (unlikely(sparc_mmap_check(addr, old_len)))
-                goto out;
-        if (unlikely(sparc_mmap_check(new_addr, new_len)))
-                goto out;
-        down_write(&current->mm->mmap_sem);
-        ret = do_mremap(addr, old_len, new_len, flags, new_addr);
-        up_write(&current->mm->mmap_sem);
-out:
-        return ret;       
-}
 /* we come to here via sys_nis_syscall so it can setup the regs argument */
 asmlinkage unsigned long
 c_sys_nis_syscall (struct pt_regs *regs)
diff --git a/arch/sparc/kernel/sys_sparc_64.c b/arch/sparc/kernel/sys_sparc_64.c
index e2d102447a43..3d435c42e6db 100644
--- a/arch/sparc/kernel/sys_sparc_64.c
+++ b/arch/sparc/kernel/sys_sparc_64.c
@@ -27,7 +27,6 @@
 #include <asm/uaccess.h>
 #include <asm/utrap.h>
-#include <asm/perfctr.h>
 #include <asm/unistd.h>
 #include "entry.h"
@@ -317,10 +316,14 @@ bottomup:
 unsigned long get_fb_unmapped_area(struct file *filp, unsigned long orig_addr, unsigned long len, unsigned long pgoff, unsigned long flags)
 {
        unsigned long align_goal, addr = -ENOMEM;
+        unsigned long (*get_area)(struct file *, unsigned long,
+                                  unsigned long, unsigned long, unsigned long);
+        get_area = current->mm->get_unmapped_area;
        if (flags & MAP_FIXED) {
                /* Ok, don't mess with it. */
-                return get_unmapped_area(NULL, orig_addr, len, pgoff, flags);
+                return get_area(NULL, orig_addr, len, pgoff, flags);
        }
        flags &= ~MAP_SHARED;
@@ -333,7 +336,7 @@ unsigned long get_fb_unmapped_area(struct file *filp, unsigned long orig_addr, u
                align_goal = (64UL * 1024);
        do {
-                addr = get_unmapped_area(NULL, orig_addr, len + (align_goal - PAGE_SIZE), pgoff, flags);
+                addr = get_area(NULL, orig_addr, len + (align_goal - PAGE_SIZE), pgoff, flags);
                if (!(addr & ~PAGE_MASK)) {
                        addr = (addr + (align_goal - 1UL)) & ~(align_goal - 1UL);
                        break;
@@ -351,7 +354,7 @@ unsigned long get_fb_unmapped_area(struct file *filp, unsigned long orig_addr, u
         * be obtained.
         */
        if (addr & ~PAGE_MASK)
-                addr = get_unmapped_area(NULL, orig_addr, len, pgoff, flags);
+                addr = get_area(NULL, orig_addr, len, pgoff, flags);
        return addr;
 }
@@ -361,6 +364,7 @@ EXPORT_SYMBOL(get_fb_unmapped_area);
 void arch_pick_mmap_layout(struct mm_struct *mm)
 {
        unsigned long random_factor = 0UL;
+        unsigned long gap;
        if (current->flags & PF_RANDOMIZE) {
                random_factor = get_random_int();
@@ -375,9 +379,10 @@ void arch_pick_mmap_layout(struct mm_struct *mm)
         * Fall back to the standard layout if the personality
         * bit is set, or if the expected stack growth is unlimited:
         */
+        gap = rlimit(RLIMIT_STACK);
        if (!test_thread_flag(TIF_32BIT) ||
            (current->personality & ADDR_COMPAT_LAYOUT) ||
-            current->signal->rlim[RLIMIT_STACK].rlim_cur == RLIM_INFINITY ||
+            gap == RLIM_INFINITY ||
            sysctl_legacy_va_layout) {
                mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
                mm->get_unmapped_area = arch_get_unmapped_area;
@@ -385,9 +390,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm)
        } else {
                /* We know it's 32-bit */
                unsigned long task_size = STACK_TOP32;
-                unsigned long gap;
-                gap = current->signal->rlim[RLIMIT_STACK].rlim_cur;
                if (gap < 128 * 1024 * 1024)
                        gap = 128 * 1024 * 1024;
                if (gap > (task_size / 6 * 5))
@@ -399,18 +402,6 @@ void arch_pick_mmap_layout(struct mm_struct *mm)
        }
 }
-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)
-                return current->mm->brk;
-        if (unlikely(straddles_64bit_va_hole(current->mm->brk, brk)))
-                return current->mm->brk;
-        return sys_brk(brk);
-}
-                                                                
 /*
 * sys_pipe() is the normal C calling standard for creating
 * a pipe. It's not the way unix traditionally does this, though.
@@ -435,7 +426,7 @@ out:
 * This is really horribly ugly.
 */
-SYSCALL_DEFINE6(ipc, unsigned int, call, int, first, unsigned long, second,
+SYSCALL_DEFINE6(sparc_ipc, unsigned int, call, int, first, unsigned long, second,
                unsigned long, third, void __user *, ptr, long, fifth)
 {
        long err;
@@ -519,17 +510,6 @@ out:
        return err;
 }
-SYSCALL_DEFINE1(sparc64_newuname, struct new_utsname __user *, name)
-{
-        int ret = sys_newuname(name);
-        
-        if (current->personality == PER_LINUX32 && !ret) {
-                ret = (copy_to_user(name->machine, "sparc\0\0", 8)
-                       ? -EFAULT : 0);
-        }
-        return ret;
-}
 SYSCALL_DEFINE1(sparc64_personality, unsigned long, personality)
 {
        int ret;
@@ -568,23 +548,13 @@ 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 = -EINVAL;
-        unsigned long retval = -EBADF;
-        if (!(flags & MAP_ANONYMOUS)) {
+        if ((off + PAGE_ALIGN(len)) < off)
-                file = fget(fd);
+                goto out;
-                if (!file)
+        if (off & ~PAGE_MASK)
-                        goto out;
+                goto out;
-        }
+        retval = sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
-        flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
-        len = PAGE_ALIGN(len);
-        down_write(&current->mm->mmap_sem);
-        retval = do_mmap(file, addr, len, prot, flags, off);
-        up_write(&current->mm->mmap_sem);
-        if (file)
-                fput(file);
 out:
        return retval;
 }
@@ -614,12 +584,6 @@ SYSCALL_DEFINE5(64_mremap, unsigned long, addr,	unsigned long, old_len,
        if (test_thread_flag(TIF_32BIT))
                goto out;
-        if (unlikely(new_len >= VA_EXCLUDE_START))
-                goto out;
-        if (unlikely(sparc_mmap_check(addr, old_len)))
-                goto out;
-        if (unlikely(sparc_mmap_check(new_addr, new_len)))
-                goto out;
        down_write(&current->mm->mmap_sem);
        ret = do_mremap(addr, old_len, new_len, flags, new_addr);
@@ -790,109 +754,6 @@ SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
        return ret;
 }
-/* Invoked by rtrap code to update performance counters in
- * user space.
- */
-asmlinkage void update_perfctrs(void)
-{
-        unsigned long pic, tmp;
-        read_pic(pic);
-        tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
-        __put_user(tmp, current_thread_info()->user_cntd0);
-        tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
-        __put_user(tmp, current_thread_info()->user_cntd1);
-        reset_pic();
-}
-SYSCALL_DEFINE4(perfctr, int, opcode, unsigned long, arg0,
-                unsigned long, arg1, unsigned long, arg2)
-{
-        int err = 0;
-        switch(opcode) {
-        case PERFCTR_ON:
-                current_thread_info()->pcr_reg = arg2;
-                current_thread_info()->user_cntd0 = (u64 __user *) arg0;
-                current_thread_info()->user_cntd1 = (u64 __user *) arg1;
-                current_thread_info()->kernel_cntd0 =
-                        current_thread_info()->kernel_cntd1 = 0;
-                write_pcr(arg2);
-                reset_pic();
-                set_thread_flag(TIF_PERFCTR);
-                break;
-        case PERFCTR_OFF:
-                err = -EINVAL;
-                if (test_thread_flag(TIF_PERFCTR)) {
-                        current_thread_info()->user_cntd0 =
-                                current_thread_info()->user_cntd1 = NULL;
-                        current_thread_info()->pcr_reg = 0;
-                        write_pcr(0);
-                        clear_thread_flag(TIF_PERFCTR);
-                        err = 0;
-                }
-                break;
-        case PERFCTR_READ: {
-                unsigned long pic, tmp;
-                if (!test_thread_flag(TIF_PERFCTR)) {
-                        err = -EINVAL;
-                        break;
-                }
-                read_pic(pic);
-                tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
-                err |= __put_user(tmp, current_thread_info()->user_cntd0);
-                tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
-                err |= __put_user(tmp, current_thread_info()->user_cntd1);
-                reset_pic();
-                break;
-        }
-        case PERFCTR_CLRPIC:
-                if (!test_thread_flag(TIF_PERFCTR)) {
-                        err = -EINVAL;
-                        break;
-                }
-                current_thread_info()->kernel_cntd0 =
-                        current_thread_info()->kernel_cntd1 = 0;
-                reset_pic();
-                break;
-        case PERFCTR_SETPCR: {
-                u64 __user *user_pcr = (u64 __user *)arg0;
-                if (!test_thread_flag(TIF_PERFCTR)) {
-                        err = -EINVAL;
-                        break;
-                }
-                err |= __get_user(current_thread_info()->pcr_reg, user_pcr);
-                write_pcr(current_thread_info()->pcr_reg);
-                current_thread_info()->kernel_cntd0 =
-                        current_thread_info()->kernel_cntd1 = 0;
-                reset_pic();
-                break;
-        }
-        case PERFCTR_GETPCR: {
-                u64 __user *user_pcr = (u64 __user *)arg0;
-                if (!test_thread_flag(TIF_PERFCTR)) {
-                        err = -EINVAL;
-                        break;
-                }
-                err |= __put_user(current_thread_info()->pcr_reg, user_pcr);
-                break;
-        }
-        default:
-                err = -EINVAL;
-                break;
-        };
-        return err;
-}
 /*
 * Do a system call from kernel instead of calling sys_execve so we
 * end up with proper pt_regs.
diff --git a/arch/sparc/kernel/syscalls.S b/arch/sparc/kernel/syscalls.S
index d150c2aa98d2..1d7e274f3f2b 100644
--- a/arch/sparc/kernel/syscalls.S
+++ b/arch/sparc/kernel/syscalls.S
@@ -62,7 +62,7 @@ sys32_rt_sigreturn:
 #endif
        .align  32
 1:      ldx     [%g6 + TI_FLAGS], %l5
-        andcc   %l5, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT), %g0
+        andcc   %l5, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT|_TIF_SYSCALL_TRACEPOINT), %g0
        be,pt   %icc, rtrap
         nop
        call    syscall_trace_leave
@@ -110,31 +110,12 @@ sys_clone:
        .globl  ret_from_syscall
 ret_from_syscall:
-        /* Clear current_thread_info()->new_child, and
+        /* Clear current_thread_info()->new_child. */
-         * check performance counter stuff too.
-         */
        stb     %g0, [%g6 + TI_NEW_CHILD]
        ldx     [%g6 + TI_FLAGS], %l0
        call    schedule_tail
         mov    %g7, %o0
-        andcc   %l0, _TIF_PERFCTR, %g0
+        ba,pt   %xcc, ret_sys_call
-        be,pt   %icc, 1f
-         nop
-        ldx     [%g6 + TI_PCR], %o7
-        wr      %g0, %o7, %pcr
-        /* Blackbird errata workaround.  See commentary in
-         * smp.c:smp_percpu_timer_interrupt() for more
-         * information.
-         */
-        ba,pt   %xcc, 99f
-         nop
-        .align  64
-99:     wr      %g0, %g0, %pic
-        rd      %pic, %g0
-1:      ba,pt   %xcc, ret_sys_call
         ldx    [%sp + PTREGS_OFF + PT_V9_I0], %o0
        .globl  sparc_exit
@@ -187,7 +168,7 @@ linux_syscall_trace:
        .globl  linux_sparc_syscall32
 linux_sparc_syscall32:
        /* Direct access to user regs, much faster. */
-        cmp     %g1, NR_SYSCALLS                        ! IEU1  Group
+        cmp     %g1, NR_syscalls                        ! IEU1  Group
        bgeu,pn %xcc, linux_sparc_ni_syscall            ! CTI
         srl    %i0, 0, %o0                             ! IEU0
        sll     %g1, 2, %l4                             ! IEU0  Group
@@ -198,7 +179,7 @@ linux_sparc_syscall32:
        srl     %i5, 0, %o5                             ! IEU1
        srl     %i2, 0, %o2                             ! IEU0  Group
-        andcc   %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT), %g0
+        andcc   %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT|_TIF_SYSCALL_TRACEPOINT), %g0
        bne,pn  %icc, linux_syscall_trace32             ! CTI
         mov    %i0, %l5                                ! IEU1
        call    %l7                                     ! CTI   Group brk forced
@@ -210,7 +191,7 @@ linux_sparc_syscall32:
        .globl  linux_sparc_syscall
 linux_sparc_syscall:
        /* Direct access to user regs, much faster. */
-        cmp     %g1, NR_SYSCALLS                        ! IEU1  Group
+        cmp     %g1, NR_syscalls                        ! IEU1  Group
        bgeu,pn %xcc, linux_sparc_ni_syscall            ! CTI
         mov    %i0, %o0                                ! IEU0
        sll     %g1, 2, %l4                             ! IEU0  Group
@@ -221,7 +202,7 @@ linux_sparc_syscall:
        mov     %i3, %o3                                ! IEU1
        mov     %i4, %o4                                ! IEU0  Group
-        andcc   %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT), %g0
+        andcc   %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT|_TIF_SYSCALL_TRACEPOINT), %g0
        bne,pn  %icc, linux_syscall_trace               ! CTI   Group
         mov    %i0, %l5                                ! IEU0
 2:      call    %l7                                     ! CTI   Group brk forced
@@ -245,7 +226,7 @@ ret_sys_call:
        cmp     %o0, -ERESTART_RESTARTBLOCK
        bgeu,pn %xcc, 1f
-         andcc  %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT), %l6
+         andcc  %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT|_TIF_SYSCALL_TRACEPOINT), %l6
 80:
        /* System call success, clear Carry condition code. */
        andn    %g3, %g2, %g3
@@ -260,7 +241,7 @@ ret_sys_call:
        /* System call failure, set Carry condition code.
         * Also, get abs(errno) to return to the process.
         */
-        andcc   %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT), %l6  
+        andcc   %l0, (_TIF_SYSCALL_TRACE|_TIF_SECCOMP|_TIF_SYSCALL_AUDIT|_TIF_SYSCALL_TRACEPOINT), %l6  
        sub     %g0, %o0, %o0
        or      %g3, %g2, %g3
        stx     %o0, [%sp + PTREGS_OFF + PT_V9_I0]
diff --git a/arch/sparc/kernel/sysfs.c b/arch/sparc/kernel/sysfs.c
index ca39c606fe8e..1eb8b00aed75 100644
--- a/arch/sparc/kernel/sysfs.c
+++ b/arch/sparc/kernel/sysfs.c
@@ -107,12 +107,12 @@ static unsigned long run_on_cpu(unsigned long cpu,
        unsigned long ret;
        /* should return -EINVAL to userspace */
-        if (set_cpus_allowed(current, cpumask_of_cpu(cpu)))
+        if (set_cpus_allowed_ptr(current, cpumask_of(cpu)))
                return 0;
        ret = func(arg);
-        set_cpus_allowed(current, old_affinity);
+        set_cpus_allowed_ptr(current, &old_affinity);
        return ret;
 }
diff --git a/arch/sparc/kernel/systbls.h b/arch/sparc/kernel/systbls.h
index a63c5d2d9849..118759cd7342 100644
--- a/arch/sparc/kernel/systbls.h
+++ b/arch/sparc/kernel/systbls.h
@@ -6,16 +6,12 @@
 #include <asm/utrap.h>
 #include <asm/signal.h>
-struct new_utsname;
 extern asmlinkage unsigned long sys_getpagesize(void);
-extern asmlinkage unsigned long sparc_brk(unsigned long brk);
 extern asmlinkage long sparc_pipe(struct pt_regs *regs);
-extern asmlinkage long sys_ipc(unsigned int call, int first,
+extern asmlinkage long sys_sparc_ipc(unsigned int call, int first,
                               unsigned long second,
                               unsigned long third,
                               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 long sys64_munmap(unsigned long addr, size_t len);
 extern asmlinkage unsigned long sys64_mremap(unsigned long addr,
@@ -37,8 +33,6 @@ extern asmlinkage long sys_rt_sigaction(int sig,
                                        struct sigaction __user *oact,
                                        void __user *restorer,
                                        size_t sigsetsize);
-extern asmlinkage long sys_perfctr(int opcode, unsigned long arg0,
-                                   unsigned long arg1, unsigned long arg2);
 extern asmlinkage void sparc64_set_context(struct pt_regs *regs);
 extern asmlinkage void sparc64_get_context(struct pt_regs *regs);
diff --git a/arch/sparc/kernel/systbls_32.S b/arch/sparc/kernel/systbls_32.S
index 0f1658d37490..801fc8e5a0e8 100644
--- a/arch/sparc/kernel/systbls_32.S
+++ b/arch/sparc/kernel/systbls_32.S
@@ -19,7 +19,7 @@ sys_call_table:
 /*0*/   .long sys_restart_syscall, sys_exit, sys_fork, sys_read, sys_write
 /*5*/   .long sys_open, sys_close, sys_wait4, sys_creat, sys_link
 /*10*/  .long sys_unlink, sunos_execv, sys_chdir, sys_chown16, sys_mknod
-/*15*/  .long sys_chmod, sys_lchown16, sparc_brk, sys_nis_syscall, sys_lseek
+/*15*/  .long sys_chmod, sys_lchown16, sys_brk, sys_nis_syscall, sys_lseek
 /*20*/  .long sys_getpid, sys_capget, sys_capset, sys_setuid16, sys_getuid16
 /*25*/  .long sys_vmsplice, sys_ptrace, sys_alarm, sys_sigaltstack, sys_pause
 /*30*/  .long sys_utime, sys_lchown, sys_fchown, sys_access, sys_nice
@@ -67,7 +67,7 @@ sys_call_table:
 /*235*/ .long sys_fstatfs64, sys_llseek, sys_mlock, sys_munlock, sys_mlockall
 /*240*/ .long sys_munlockall, sys_sched_setparam, sys_sched_getparam, sys_sched_setscheduler, sys_sched_getscheduler
 /*245*/ .long sys_sched_yield, sys_sched_get_priority_max, sys_sched_get_priority_min, sys_sched_rr_get_interval, sys_nanosleep
-/*250*/ .long sparc_mremap, sys_sysctl, sys_getsid, sys_fdatasync, sys_nfsservctl
+/*250*/ .long sys_mremap, sys_sysctl, sys_getsid, sys_fdatasync, sys_nfsservctl
 /*255*/ .long sys_sync_file_range, sys_clock_settime, sys_clock_gettime, sys_clock_getres, sys_clock_nanosleep
 /*260*/ .long sys_sched_getaffinity, sys_sched_setaffinity, sys_timer_settime, sys_timer_gettime, sys_timer_getoverrun
 /*265*/ .long sys_timer_delete, sys_timer_create, sys_nis_syscall, sys_io_setup, sys_io_destroy
@@ -82,5 +82,5 @@ sys_call_table:
 /*310*/ .long sys_utimensat, sys_signalfd, sys_timerfd_create, sys_eventfd, sys_fallocate
 /*315*/ .long sys_timerfd_settime, sys_timerfd_gettime, sys_signalfd4, sys_eventfd2, sys_epoll_create1
 /*320*/ .long sys_dup3, sys_pipe2, sys_inotify_init1, sys_accept4, sys_preadv
-/*325*/ .long sys_pwritev, sys_rt_tgsigqueueinfo, sys_perf_event_open
+/*325*/ .long sys_pwritev, sys_rt_tgsigqueueinfo, sys_perf_event_open, sys_recvmmsg
diff --git a/arch/sparc/kernel/systbls_64.S b/arch/sparc/kernel/systbls_64.S
index 009825f6e73c..9db058dd039e 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, sys_sparc_brk, sys32_perfctr, sys32_lseek
+/*15*/  .word sys_chmod, sys_lchown16, sys_brk, sys_nis_syscall, 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,7 +55,7 @@ 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, sys_sparc64_newuname
+        .word sys32_setpgid, sys32_fremovexattr, sys32_tkill, sys32_exit_group, sys_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
@@ -68,7 +68,7 @@ sys_call_table32:
        .word compat_sys_fstatfs64, sys_llseek, sys_mlock, sys_munlock, sys32_mlockall
 /*240*/ .word sys_munlockall, sys32_sched_setparam, sys32_sched_getparam, sys32_sched_setscheduler, sys32_sched_getscheduler
        .word sys_sched_yield, sys32_sched_get_priority_max, sys32_sched_get_priority_min, sys32_sched_rr_get_interval, compat_sys_nanosleep
-/*250*/ .word sys32_mremap, sys32_sysctl, sys32_getsid, sys_fdatasync, sys32_nfsservctl
+/*250*/ .word sys_mremap, compat_sys_sysctl, sys32_getsid, sys_fdatasync, sys32_nfsservctl
        .word sys32_sync_file_range, compat_sys_clock_settime, compat_sys_clock_gettime, compat_sys_clock_getres, sys32_clock_nanosleep
 /*260*/ .word compat_sys_sched_getaffinity, compat_sys_sched_setaffinity, sys32_timer_settime, compat_sys_timer_gettime, sys_timer_getoverrun
        .word sys_timer_delete, compat_sys_timer_create, sys_ni_syscall, compat_sys_io_setup, sys_io_destroy
@@ -83,7 +83,7 @@ sys_call_table32:
 /*310*/ .word compat_sys_utimensat, compat_sys_signalfd, sys_timerfd_create, sys_eventfd, compat_sys_fallocate
        .word compat_sys_timerfd_settime, compat_sys_timerfd_gettime, compat_sys_signalfd4, sys_eventfd2, sys_epoll_create1
 /*320*/ .word sys_dup3, sys_pipe2, sys_inotify_init1, sys_accept4, compat_sys_preadv
-        .word compat_sys_pwritev, compat_sys_rt_tgsigqueueinfo, sys_perf_event_open
+        .word compat_sys_pwritev, compat_sys_rt_tgsigqueueinfo, sys_perf_event_open, compat_sys_recvmmsg
 #endif /* CONFIG_COMPAT */
@@ -96,7 +96,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, sys_sparc_brk, sys_perfctr, sys_lseek
+/*15*/  .word sys_chmod, sys_lchown, sys_brk, sys_nis_syscall, 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
@@ -130,13 +130,13 @@ 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, sys_sparc64_newuname
+        .word sys_setpgid, sys_fremovexattr, sys_tkill, sys_exit_group, sys_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
 /*210*/ .word sys_fadvise64_64, sys_tgkill, sys_waitpid, sys_swapoff, sys_sysinfo
-        .word sys_ipc, sys_nis_syscall, sys_clone, sys_ioprio_get, sys_adjtimex
+        .word sys_sparc_ipc, sys_nis_syscall, sys_clone, sys_ioprio_get, sys_adjtimex
 /*220*/ .word sys_nis_syscall, sys_ni_syscall, sys_delete_module, sys_ni_syscall, sys_getpgid
        .word sys_bdflush, sys_sysfs, sys_nis_syscall, sys_setfsuid, sys_setfsgid
 /*230*/ .word sys_select, sys_nis_syscall, sys_splice, sys_stime, sys_statfs64
@@ -158,4 +158,4 @@ sys_call_table:
 /*310*/ .word sys_utimensat, sys_signalfd, sys_timerfd_create, sys_eventfd, sys_fallocate
        .word sys_timerfd_settime, sys_timerfd_gettime, sys_signalfd4, sys_eventfd2, sys_epoll_create1
 /*320*/ .word sys_dup3, sys_pipe2, sys_inotify_init1, sys_accept4, sys_preadv
-        .word sys_pwritev, sys_rt_tgsigqueueinfo, sys_perf_event_open
+        .word sys_pwritev, sys_rt_tgsigqueueinfo, sys_perf_event_open, sys_recvmmsg
diff --git a/arch/sparc/kernel/time_32.c b/arch/sparc/kernel/time_32.c
index 614ac7b4a9dd..0d4c09b15efc 100644
--- a/arch/sparc/kernel/time_32.c
+++ b/arch/sparc/kernel/time_32.c
@@ -35,6 +35,7 @@
 #include <linux/platform_device.h>
 #include <asm/oplib.h>
+#include <asm/timex.h>
 #include <asm/timer.h>
 #include <asm/system.h>
 #include <asm/irq.h>
@@ -51,7 +52,6 @@ DEFINE_SPINLOCK(rtc_lock);
 EXPORT_SYMBOL(rtc_lock);
 static int set_rtc_mmss(unsigned long);
-static int sbus_do_settimeofday(struct timespec *tv);
 unsigned long profile_pc(struct pt_regs *regs)
 {
@@ -76,6 +76,8 @@ EXPORT_SYMBOL(profile_pc);
 __volatile__ unsigned int *master_l10_counter;
+u32 (*do_arch_gettimeoffset)(void);
 /*
 * timer_interrupt() needs to keep up the real-time clock,
 * as well as call the "do_timer()" routine every clocktick
@@ -196,38 +198,14 @@ static int __init clock_init(void)
 {
        return of_register_driver(&clock_driver, &of_platform_bus_type);
 }
 /* Must be after subsys_initcall() so that busses are probed.  Must
 * be before device_initcall() because things like the RTC driver
 * need to see the clock registers.
 */
 fs_initcall(clock_init);
-static void __init sbus_time_init(void)
-{
-        BTFIXUPSET_CALL(bus_do_settimeofday, sbus_do_settimeofday, BTFIXUPCALL_NORM);
-        btfixup();
-        sparc_init_timers(timer_interrupt);
-        
-        /* Now that OBP ticker has been silenced, it is safe to enable IRQ. */
-        local_irq_enable();
-}
-void __init time_init(void)
-{
-#ifdef CONFIG_PCI
-        extern void pci_time_init(void);
-        if (pcic_present()) {
-                pci_time_init();
-                return;
-        }
-#endif
-        sbus_time_init();
-}
-static inline unsigned long do_gettimeoffset(void)
+u32 sbus_do_gettimeoffset(void)
 {
        unsigned long val = *master_l10_counter;
        unsigned long usec = (val >> 10) & 0x1fffff;
@@ -236,86 +214,39 @@ static inline unsigned long do_gettimeoffset(void)
        if (val & 0x80000000)
                usec += 1000000 / HZ;
-        return usec;
+        return usec * 1000;
 }
-/* Ok, my cute asm atomicity trick doesn't work anymore.
- * There are just too many variables that need to be protected
- * now (both members of xtime, et al.)
- */
-void do_gettimeofday(struct timeval *tv)
-{
-        unsigned long flags;
-        unsigned long seq;
-        unsigned long usec, sec;
-        unsigned long max_ntp_tick = tick_usec - tickadj;
-        do {
-                seq = read_seqbegin_irqsave(&xtime_lock, flags);
-                usec = do_gettimeoffset();
-                /*
-                 * If time_adjust is negative then NTP is slowing the clock
-                 * so make sure not to go into next possible interval.
-                 * Better to lose some accuracy than have time go backwards..
-                 */
-                if (unlikely(time_adjust < 0))
-                        usec = min(usec, max_ntp_tick);
-                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;
+u32 arch_gettimeoffset(void)
-        tv->tv_usec = usec;
-}
-EXPORT_SYMBOL(do_gettimeofday);
-int do_settimeofday(struct timespec *tv)
 {
-        int ret;
+        if (unlikely(!do_arch_gettimeoffset))
+                return 0;
-        write_seqlock_irq(&xtime_lock);
+        return do_arch_gettimeoffset();
-        ret = bus_do_settimeofday(tv);
-        write_sequnlock_irq(&xtime_lock);
-        clock_was_set();
-        return ret;
 }
-EXPORT_SYMBOL(do_settimeofday);
+static void __init sbus_time_init(void)
-static int sbus_do_settimeofday(struct timespec *tv)
 {
-        time_t wtm_sec, sec = tv->tv_sec;
+        do_arch_gettimeoffset = sbus_do_gettimeoffset;
-        long wtm_nsec, nsec = tv->tv_nsec;
-        if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
+        btfixup();
-                return -EINVAL;
-        /*
-         * This is revolting. We need to set "xtime" correctly. However, the
-         * value in this location is the value at the most recent update of
-         * wall time.  Discover what correction gettimeofday() would have
-         * made, and then undo it!
-         */
-        nsec -= 1000 * do_gettimeoffset();
-        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);
+        sparc_init_timers(timer_interrupt);
-        set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
+}
-        ntp_clear();
+void __init time_init(void)
-        return 0;
+{
+#ifdef CONFIG_PCI
+        extern void pci_time_init(void);
+        if (pcic_present()) {
+                pci_time_init();
+                return;
+        }
+#endif
+        sbus_time_init();
 }
 static int set_rtc_mmss(unsigned long secs)
 {
        struct rtc_device *rtc = rtc_class_open("rtc0");
diff --git a/arch/sparc/kernel/time_64.c b/arch/sparc/kernel/time_64.c
index da1218e8ee87..c7bbe6cf7b85 100644
--- a/arch/sparc/kernel/time_64.c
+++ b/arch/sparc/kernel/time_64.c
@@ -35,6 +35,7 @@
 #include <linux/clocksource.h>
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
+#include <linux/ftrace.h>
 #include <asm/oplib.h>
 #include <asm/timer.h>
@@ -717,7 +718,7 @@ static struct clock_event_device sparc64_clockevent = {
 };
 static DEFINE_PER_CPU(struct clock_event_device, sparc64_events);
-void timer_interrupt(int irq, struct pt_regs *regs)
+void __irq_entry timer_interrupt(int irq, struct pt_regs *regs)
 {
        struct pt_regs *old_regs = set_irq_regs(regs);
        unsigned long tick_mask = tick_ops->softint_mask;
@@ -728,6 +729,7 @@ void timer_interrupt(int irq, struct pt_regs *regs)
        irq_enter();
+        local_cpu_data().irq0_irqs++;
        kstat_incr_irqs_this_cpu(0, irq_to_desc(0));
        if (unlikely(!evt->event_handler)) {
@@ -774,26 +776,9 @@ void __devinit setup_sparc64_timer(void)
 static struct clocksource clocksource_tick = {
        .rating         = 100,
        .mask           = CLOCKSOURCE_MASK(64),
-        .shift          = 16,
        .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 };
-static void __init setup_clockevent_multiplier(unsigned long hz)
-{
-        unsigned long mult, shift = 32;
-        while (1) {
-                mult = div_sc(hz, NSEC_PER_SEC, shift);
-                if (mult && (mult >> 32UL) == 0UL)
-                        break;
-                shift--;
-        }
-        sparc64_clockevent.shift = shift;
-        sparc64_clockevent.mult = mult;
-}
 static unsigned long tb_ticks_per_usec __read_mostly;
 void __delay(unsigned long loops)
@@ -828,9 +813,7 @@ void __init time_init(void)
                clocksource_hz2mult(freq, SPARC64_NSEC_PER_CYC_SHIFT);
        clocksource_tick.name = tick_ops->name;
-        clocksource_tick.mult =
+        clocksource_calc_mult_shift(&clocksource_tick, freq, 4);
-                clocksource_hz2mult(freq,
-                                    clocksource_tick.shift);
        clocksource_tick.read = clocksource_tick_read;
        printk("clocksource: mult[%x] shift[%d]\n",
@@ -839,15 +822,14 @@ void __init time_init(void)
        clocksource_register(&clocksource_tick);
        sparc64_clockevent.name = tick_ops->name;
+        clockevents_calc_mult_shift(&sparc64_clockevent, freq, 4);
-        setup_clockevent_multiplier(freq);
        sparc64_clockevent.max_delta_ns =
                clockevent_delta2ns(0x7fffffffffffffffUL, &sparc64_clockevent);
        sparc64_clockevent.min_delta_ns =
                clockevent_delta2ns(0xF, &sparc64_clockevent);
-        printk("clockevent: mult[%lx] shift[%d]\n",
+        printk("clockevent: mult[%x] shift[%d]\n",
               sparc64_clockevent.mult, sparc64_clockevent.shift);
        setup_sparc64_timer();
diff --git a/arch/sparc/kernel/trampoline_32.S b/arch/sparc/kernel/trampoline_32.S
index 5e235c52d667..691f484e03b3 100644
--- a/arch/sparc/kernel/trampoline_32.S
+++ b/arch/sparc/kernel/trampoline_32.S
@@ -15,7 +15,7 @@
 #include <asm/contregs.h>
 #include <asm/thread_info.h>
-        .globl sun4m_cpu_startup, __smp4m_processor_id
+        .globl sun4m_cpu_startup, __smp4m_processor_id, __leon_processor_id
        .globl sun4d_cpu_startup, __smp4d_processor_id
        __CPUINIT
@@ -106,6 +106,12 @@ __smp4d_processor_id:
        retl
         mov    %g1, %o7
+__leon_processor_id:
+        rd     %asr17,%g2
+        srl    %g2,28,%g2
+        retl
+         mov    %g1, %o7
 /* CPUID in bootbus can be found at PA 0xff0140000 */
 #define SUN4D_BOOTBUS_CPUID     0xf0140000
@@ -160,3 +166,64 @@ sun4d_cpu_startup:
         nop
        b,a     smp_do_cpu_idle
+#ifdef CONFIG_SPARC_LEON
+        __CPUINIT
+        .align  4
+        .global leon_smp_cpu_startup, smp_penguin_ctable
+leon_smp_cpu_startup:
+        set smp_penguin_ctable,%g1
+        ld [%g1+4],%g1
+        srl %g1,4,%g1
+        set 0x00000100,%g5 /* SRMMU_CTXTBL_PTR */
+        sta %g1, [%g5] ASI_M_MMUREGS
+        /* Set up a sane %psr -- PIL<0xf> S<0x1> PS<0x1> CWP<0x0> */
+        set     (PSR_PIL | PSR_S | PSR_PS), %g1
+        wr      %g1, 0x0, %psr          ! traps off though
+        WRITE_PAUSE
+        /* Our %wim is one behind CWP */
+        mov     2, %g1
+        wr      %g1, 0x0, %wim
+        WRITE_PAUSE
+        /* Set tbr - we use just one trap table. */
+        set     trapbase, %g1
+        wr      %g1, 0x0, %tbr
+        WRITE_PAUSE
+        /* Get our CPU id */
+        rd     %asr17,%g3
+        /* Give ourselves a stack and curptr. */
+        set     current_set, %g5
+        srl     %g3, 28, %g4
+        sll     %g4, 2, %g4
+        ld      [%g5 + %g4], %g6
+        sethi   %hi(THREAD_SIZE - STACKFRAME_SZ), %sp
+        or      %sp, %lo(THREAD_SIZE - STACKFRAME_SZ), %sp
+        add     %g6, %sp, %sp
+        /* Turn on traps (PSR_ET). */
+        rd      %psr, %g1
+        wr      %g1, PSR_ET, %psr       ! traps on
+        WRITE_PAUSE
+        /* Init our caches, etc. */
+        set     poke_srmmu, %g5
+        ld      [%g5], %g5
+        call    %g5
+         nop
+        /* Start this processor. */
+        call    leon_callin
+         nop
+        b,a     smp_do_cpu_idle
+#endif
diff --git a/arch/sparc/kernel/traps_64.c b/arch/sparc/kernel/traps_64.c
index 10f7bb9fc140..9da57f032983 100644
--- a/arch/sparc/kernel/traps_64.c
+++ b/arch/sparc/kernel/traps_64.c
@@ -17,6 +17,7 @@
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/kdebug.h>
+#include <linux/gfp.h>
 #include <asm/smp.h>
 #include <asm/delay.h>
@@ -2202,27 +2203,6 @@ void dump_stack(void)
 EXPORT_SYMBOL(dump_stack);
-static inline int is_kernel_stack(struct task_struct *task,
-                                  struct reg_window *rw)
-{
-        unsigned long rw_addr = (unsigned long) rw;
-        unsigned long thread_base, thread_end;
-        if (rw_addr < PAGE_OFFSET) {
-                if (task != &init_task)
-                        return 0;
-        }
-        thread_base = (unsigned long) task_stack_page(task);
-        thread_end = thread_base + sizeof(union thread_union);
-        if (rw_addr >= thread_base &&
-            rw_addr < thread_end &&
-            !(rw_addr & 0x7UL))
-                return 1;
-        return 0;
-}
 static inline struct reg_window *kernel_stack_up(struct reg_window *rw)
 {
        unsigned long fp = rw->ins[6];
@@ -2251,6 +2231,7 @@ void die_if_kernel(char *str, struct pt_regs *regs)
        show_regs(regs);
        add_taint(TAINT_DIE);
        if (regs->tstate & TSTATE_PRIV) {
+                struct thread_info *tp = current_thread_info();
                struct reg_window *rw = (struct reg_window *)
                        (regs->u_regs[UREG_FP] + STACK_BIAS);
@@ -2258,8 +2239,8 @@ void die_if_kernel(char *str, struct pt_regs *regs)
                 * find some badly aligned kernel stack.
                 */
                while (rw &&
-                       count++ < 30&&
+                       count++ < 30 &&
-                       is_kernel_stack(current, rw)) {
+                       kstack_valid(tp, (unsigned long) rw)) {
                        printk("Caller[%016lx]: %pS\n", rw->ins[7],
                               (void *) rw->ins[7]);
@@ -2548,15 +2529,6 @@ void __init trap_init(void)
                                               rwbuf_stkptrs) ||
                     TI_GSR != offsetof(struct thread_info, gsr) ||
                     TI_XFSR != offsetof(struct thread_info, xfsr) ||
-                     TI_USER_CNTD0 != offsetof(struct thread_info,
-                                               user_cntd0) ||
-                     TI_USER_CNTD1 != offsetof(struct thread_info,
-                                               user_cntd1) ||
-                     TI_KERN_CNTD0 != offsetof(struct thread_info,
-                                               kernel_cntd0) ||
-                     TI_KERN_CNTD1 != offsetof(struct thread_info,
-                                               kernel_cntd1) ||
-                     TI_PCR != offsetof(struct thread_info, pcr_reg) ||
                     TI_PRE_COUNT != offsetof(struct thread_info,
                                              preempt_count) ||
                     TI_NEW_CHILD != offsetof(struct thread_info, new_child) ||
diff --git a/arch/sparc/kernel/tsb.S b/arch/sparc/kernel/tsb.S
index 8c91d9b29a2f..db15d123f054 100644
--- a/arch/sparc/kernel/tsb.S
+++ b/arch/sparc/kernel/tsb.S
@@ -191,10 +191,12 @@ tsb_dtlb_load:
 tsb_itlb_load:
        /* Executable bit must be set.  */
-661:    andcc           %g5, _PAGE_EXEC_4U, %g0
+661:    sethi           %hi(_PAGE_EXEC_4U), %g4
-        .section        .sun4v_1insn_patch, "ax"
+        andcc           %g5, %g4, %g0
+        .section        .sun4v_2insn_patch, "ax"
        .word           661b
        andcc           %g5, _PAGE_EXEC_4V, %g0
+        nop
        .previous
        be,pn           %xcc, tsb_do_fault
diff --git a/arch/sparc/kernel/unaligned_32.c b/arch/sparc/kernel/unaligned_32.c
index 6b1e6cde6fff..f8514e291e15 100644
--- a/arch/sparc/kernel/unaligned_32.c
+++ b/arch/sparc/kernel/unaligned_32.c
@@ -17,8 +17,7 @@
 #include <asm/uaccess.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
+#include <linux/perf_event.h>
-/* #define DEBUG_MNA */
 enum direction {
        load,    /* ld, ldd, ldh, ldsh */
@@ -29,12 +28,6 @@ enum direction {
        invalid,
 };
-#ifdef DEBUG_MNA
-static char *dirstrings[] = {
-  "load", "store", "both", "fpload", "fpstore", "invalid"
-};
-#endif
 static inline enum direction decode_direction(unsigned int insn)
 {
        unsigned long tmp = (insn >> 21) & 1;
@@ -255,10 +248,7 @@ asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn)
                unsigned long addr = compute_effective_address(regs, insn);
                int err;
-#ifdef DEBUG_MNA
+                perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, 0, regs, addr);
-                printk("KMNA: pc=%08lx [dir=%s addr=%08lx size=%d] retpc[%08lx]\n",
-                       regs->pc, dirstrings[dir], addr, size, regs->u_regs[UREG_RETPC]);
-#endif
                switch (dir) {
                case load:
                        err = do_int_load(fetch_reg_addr(((insn>>25)&0x1f),
@@ -350,6 +340,7 @@ asmlinkage void user_unaligned_trap(struct pt_regs *regs, unsigned int insn)
                }
                addr = compute_effective_address(regs, insn);
+                perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, 0, regs, addr);
                switch(dir) {
                case load:
                        err = do_int_load(fetch_reg_addr(((insn>>25)&0x1f),
diff --git a/arch/sparc/kernel/unaligned_64.c b/arch/sparc/kernel/unaligned_64.c
index 379209982a07..c752c4c479bd 100644
--- a/arch/sparc/kernel/unaligned_64.c
+++ b/arch/sparc/kernel/unaligned_64.c
@@ -20,10 +20,10 @@
 #include <asm/uaccess.h>
 #include <linux/smp.h>
 #include <linux/bitops.h>
+#include <linux/perf_event.h>
+#include <linux/ratelimit.h>
 #include <asm/fpumacro.h>
-/* #define DEBUG_MNA */
 enum direction {
        load,    /* ld, ldd, ldh, ldsh */
        store,   /* st, std, sth, stsh */
@@ -33,12 +33,6 @@ enum direction {
        invalid,
 };
-#ifdef DEBUG_MNA
-static char *dirstrings[] = {
-  "load", "store", "both", "fpload", "fpstore", "invalid"
-};
-#endif
 static inline enum direction decode_direction(unsigned int insn)
 {
        unsigned long tmp = (insn >> 21) & 1;
@@ -56,7 +50,7 @@ static inline enum direction decode_direction(unsigned int insn)
 }
 /* 16 = double-word, 8 = extra-word, 4 = word, 2 = half-word */
-static inline int decode_access_size(unsigned int insn)
+static inline int decode_access_size(struct pt_regs *regs, unsigned int insn)
 {
        unsigned int tmp;
@@ -72,7 +66,7 @@ static inline int decode_access_size(unsigned int insn)
                return 2;
        else {
                printk("Impossible unaligned trap. insn=%08x\n", insn);
-                die_if_kernel("Byte sized unaligned access?!?!", current_thread_info()->kregs);
+                die_if_kernel("Byte sized unaligned access?!?!", regs);
                /* GCC should never warn that control reaches the end
                 * of this function without returning a value because
@@ -281,13 +275,9 @@ static void kernel_mna_trap_fault(int fixup_tstate_asi)
 static void log_unaligned(struct pt_regs *regs)
 {
-        static unsigned long count, last_time;
+        static DEFINE_RATELIMIT_STATE(ratelimit, 5 * HZ, 5);
-        if (time_after(jiffies, last_time + 5 * HZ))
+        if (__ratelimit(&ratelimit)) {
-                count = 0;
-        if (count < 5) {
-                last_time = jiffies;
-                count++;
                printk("Kernel unaligned access at TPC[%lx] %pS\n",
                       regs->tpc, (void *) regs->tpc);
        }
@@ -296,7 +286,7 @@ static void log_unaligned(struct pt_regs *regs)
 asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn)
 {
        enum direction dir = decode_direction(insn);
-        int size = decode_access_size(insn);
+        int size = decode_access_size(regs, insn);
        int orig_asi, asi;
        current_thread_info()->kern_una_regs = regs;
@@ -327,12 +317,7 @@ asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn)
                addr = compute_effective_address(regs, insn,
                                                 ((insn >> 25) & 0x1f));
-#ifdef DEBUG_MNA
+                perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, 0, regs, addr);
-                printk("KMNA: pc=%016lx [dir=%s addr=%016lx size=%d] "
-                       "retpc[%016lx]\n",
-                       regs->tpc, dirstrings[dir], addr, size,
-                       regs->u_regs[UREG_RETPC]);
-#endif
                switch (asi) {
                case ASI_NL:
                case ASI_AIUPL:
@@ -399,6 +384,7 @@ int handle_popc(u32 insn, struct pt_regs *regs)
        int ret, i, rd = ((insn >> 25) & 0x1f);
        int from_kernel = (regs->tstate & TSTATE_PRIV) != 0;
                                
+        perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS, 1, 0, regs, 0);
        if (insn & 0x2000) {
                maybe_flush_windows(0, 0, rd, from_kernel);
                value = sign_extend_imm13(insn);
@@ -445,6 +431,8 @@ int handle_ldf_stq(u32 insn, struct pt_regs *regs)
        int asi = decode_asi(insn, regs);
        int flag = (freg < 32) ? FPRS_DL : FPRS_DU;
+        perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS, 1, 0, regs, 0);
        save_and_clear_fpu();
        current_thread_info()->xfsr[0] &= ~0x1c000;
        if (freg & 3) {
@@ -566,6 +554,8 @@ void handle_ld_nf(u32 insn, struct pt_regs *regs)
        int from_kernel = (regs->tstate & TSTATE_PRIV) != 0;
        unsigned long *reg;
                                
+        perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS, 1, 0, regs, 0);
        maybe_flush_windows(0, 0, rd, from_kernel);
        reg = fetch_reg_addr(rd, regs);
        if (from_kernel || rd < 16) {
@@ -596,6 +586,7 @@ void handle_lddfmna(struct pt_regs *regs, unsigned long sfar, unsigned long sfsr
        if (tstate & TSTATE_PRIV)
                die_if_kernel("lddfmna from kernel", regs);
+        perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, 0, regs, sfar);
        if (test_thread_flag(TIF_32BIT))
                pc = (u32)pc;
        if (get_user(insn, (u32 __user *) pc) != -EFAULT) {
@@ -642,7 +633,6 @@ daex:
                return;
        }
        advance(regs);
-        return;
 }
 void handle_stdfmna(struct pt_regs *regs, unsigned long sfar, unsigned long sfsr)
@@ -657,6 +647,7 @@ void handle_stdfmna(struct pt_regs *regs, unsigned long sfar, unsigned long sfsr
        if (tstate & TSTATE_PRIV)
                die_if_kernel("stdfmna from kernel", regs);
+        perf_sw_event(PERF_COUNT_SW_ALIGNMENT_FAULTS, 1, 0, regs, sfar);
        if (test_thread_flag(TIF_32BIT))
                pc = (u32)pc;
        if (get_user(insn, (u32 __user *) pc) != -EFAULT) {
@@ -690,5 +681,4 @@ daex:
                return;
        }
        advance(regs);
-        return;
 }
diff --git a/arch/sparc/kernel/us2e_cpufreq.c b/arch/sparc/kernel/us2e_cpufreq.c
index 791c15138f3a..8f982b76c712 100644
--- a/arch/sparc/kernel/us2e_cpufreq.c
+++ b/arch/sparc/kernel/us2e_cpufreq.c
@@ -238,12 +238,12 @@ static unsigned int us2e_freq_get(unsigned int cpu)
                return 0;
        cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, cpumask_of(cpu));
        clock_tick = sparc64_get_clock_tick(cpu) / 1000;
        estar = read_hbreg(HBIRD_ESTAR_MODE_ADDR);
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
        return clock_tick / estar_to_divisor(estar);
 }
@@ -259,7 +259,7 @@ static void us2e_set_cpu_divider_index(unsigned int cpu, unsigned int index)
                return;
        cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, cpumask_of(cpu));
        new_freq = clock_tick = sparc64_get_clock_tick(cpu) / 1000;
        new_bits = index_to_estar_mode(index);
@@ -281,7 +281,7 @@ static void us2e_set_cpu_divider_index(unsigned int cpu, unsigned int index)
        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
 }
 static int us2e_freq_target(struct cpufreq_policy *policy,
diff --git a/arch/sparc/kernel/us3_cpufreq.c b/arch/sparc/kernel/us3_cpufreq.c
index 365b6464e2ce..f35d1e794548 100644
--- a/arch/sparc/kernel/us3_cpufreq.c
+++ b/arch/sparc/kernel/us3_cpufreq.c
@@ -86,12 +86,12 @@ static unsigned int us3_freq_get(unsigned int cpu)
                return 0;
        cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, cpumask_of(cpu));
        reg = read_safari_cfg();
        ret = get_current_freq(cpu, reg);
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
        return ret;
 }
@@ -106,7 +106,7 @@ static void us3_set_cpu_divider_index(unsigned int cpu, unsigned int index)
                return;
        cpus_allowed = current->cpus_allowed;
-        set_cpus_allowed(current, cpumask_of_cpu(cpu));
+        set_cpus_allowed_ptr(current, cpumask_of(cpu));
        new_freq = sparc64_get_clock_tick(cpu) / 1000;
        switch (index) {
@@ -140,7 +140,7 @@ static void us3_set_cpu_divider_index(unsigned int cpu, unsigned int index)
        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
-        set_cpus_allowed(current, cpus_allowed);
+        set_cpus_allowed_ptr(current, &cpus_allowed);
 }
 static int us3_freq_target(struct cpufreq_policy *policy,
diff --git a/arch/sparc/kernel/vio.c b/arch/sparc/kernel/vio.c
index c28c71449a6c..3cb1def9806c 100644
--- a/arch/sparc/kernel/vio.c
+++ b/arch/sparc/kernel/vio.c
@@ -10,6 +10,7 @@
 */
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/irq.h>
 #include <linux/init.h>
diff --git a/arch/sparc/kernel/visemul.c b/arch/sparc/kernel/visemul.c
index d231cbd5c526..9dfd2ebcb157 100644
--- a/arch/sparc/kernel/visemul.c
+++ b/arch/sparc/kernel/visemul.c
@@ -5,6 +5,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/thread_info.h>
+#include <linux/perf_event.h>
 #include <asm/ptrace.h>
 #include <asm/pstate.h>
@@ -801,6 +802,8 @@ int vis_emul(struct pt_regs *regs, unsigned int insn)
        BUG_ON(regs->tstate & TSTATE_PRIV);
+        perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS, 1, 0, regs, 0);
        if (test_thread_flag(TIF_32BIT))
                pc = (u32)pc;
diff --git a/arch/sparc/kernel/vmlinux.lds.S b/arch/sparc/kernel/vmlinux.lds.S
index 4e5992593967..0c1e6783657f 100644
--- a/arch/sparc/kernel/vmlinux.lds.S
+++ b/arch/sparc/kernel/vmlinux.lds.S
@@ -46,11 +46,16 @@ SECTIONS
                SCHED_TEXT
                LOCK_TEXT
                KPROBES_TEXT
+                IRQENTRY_TEXT
                *(.gnu.warning)
        } = 0
        _etext = .;
        RO_DATA(PAGE_SIZE)
+        /* Start of data section */
+        _sdata = .;
        .data1 : {
                *(.data1)
        }
author	Andrea Bastoni <bastoni@cs.unc.edu>	2010-05-30 19:16:45 -0400
committer	Andrea Bastoni <bastoni@cs.unc.edu>	2010-05-30 19:16:45 -0400
commit	ada47b5fe13d89735805b566185f4885f5a3f750 (patch)
tree	644b88f8a71896307d71438e9b3af49126ffb22b /arch/sparc/kernel
parent	43e98717ad40a4ae64545b5ba047c7b86aa44f4f (diff)
parent	3280f21d43ee541f97f8cda5792150d2dbec20d5 (diff)