Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

191 files changed, 5206 insertions, 4665 deletions

diff --git a/arch/sparc/Kconfig b/arch/sparc/Kconfig
index 491e9d6de191..253986bd6bb6 100644
--- a/arch/sparc/Kconfig
+++ b/arch/sparc/Kconfig
@@ -1,9 +1,3 @@
-# For a description of the syntax of this configuration file,
-# see Documentation/kbuild/kconfig-language.txt.
-#
-
-mainmenu "Linux/SPARC Kernel Configuration"
-
 config 64BIT
         bool "64-bit kernel" if ARCH = "sparc"
         default ARCH = "sparc64"
@@ -19,6 +13,7 @@ config SPARC
         bool
         default y
         select OF
+        select OF_PROMTREE
         select HAVE_IDE
         select HAVE_OPROFILE
         select HAVE_ARCH_KGDB if !SMP || SPARC64
@@ -26,10 +21,13 @@ config SPARC
         select ARCH_WANT_OPTIONAL_GPIOLIB
         select RTC_CLASS
         select RTC_DRV_M48T59
-        select HAVE_PERF_EVENTS
-        select PERF_USE_VMALLOC
+        select HAVE_IRQ_WORK
         select HAVE_DMA_ATTRS
         select HAVE_DMA_API_DEBUG
+        select HAVE_ARCH_JUMP_LABEL
+        select HAVE_GENERIC_HARDIRQS
+        select GENERIC_IRQ_SHOW
+        select USE_GENERIC_SMP_HELPERS if SMP
 
 config SPARC32
         def_bool !64BIT
@@ -48,13 +46,13 @@ config SPARC64
         select HAVE_DYNAMIC_FTRACE
         select HAVE_FTRACE_MCOUNT_RECORD
         select HAVE_SYSCALL_TRACEPOINTS
-        select USE_GENERIC_SMP_HELPERS if SMP
         select RTC_DRV_CMOS
         select RTC_DRV_BQ4802
         select RTC_DRV_SUN4V
         select RTC_DRV_STARFIRE
         select HAVE_PERF_EVENTS
         select PERF_USE_VMALLOC
+        select IRQ_PREFLOW_FASTEOI
 
 config ARCH_DEFCONFIG
         string
@@ -112,10 +110,6 @@ config NEED_PER_CPU_EMBED_FIRST_CHUNK
 config NEED_PER_CPU_PAGE_FIRST_CHUNK
         def_bool y if SPARC64
 
-config GENERIC_HARDIRQS_NO__DO_IRQ
-        bool
-        def_bool y if SPARC64
-
 config MMU
         bool
         default y
@@ -195,10 +189,6 @@ config RWSEM_XCHGADD_ALGORITHM
         bool
         default y if SPARC64
 
-config GENERIC_FIND_NEXT_BIT
-        bool
-        default y
-
 config GENERIC_HWEIGHT
         bool
         default y if !ULTRA_HAS_POPULATION_COUNT
@@ -281,10 +271,6 @@ config HOTPLUG_CPU
           can be controlled through /sys/devices/system/cpu/cpu#.
           Say N if you want to disable CPU hotplug.
 
-config GENERIC_HARDIRQS
-        bool
-        default y if SPARC64
-
 source "kernel/time/Kconfig"
 
 if SPARC64
@@ -472,6 +458,39 @@ config SPARC_LEON
           from www.gaisler.com. You can download a sparc-linux cross-compilation
           toolchain at www.gaisler.com.
 
+if SPARC_LEON
+menu "U-Boot options"
+
+config UBOOT_LOAD_ADDR
+        hex "uImage Load Address"
+        default 0x40004000
+        ---help---
+         U-Boot kernel load address, the address in physical address space
+         where u-boot will place the Linux kernel before booting it.
+         This address is normally the base address of main memory + 0x4000.
+
+config UBOOT_FLASH_ADDR
+        hex "uImage.o Load Address"
+        default 0x00080000
+        ---help---
+         Optional setting only affecting the uImage.o ELF-image used to
+         download the uImage file to the target using a ELF-loader other than
+         U-Boot. It may for example be used to download an uImage to FLASH with
+         the GRMON utility before even starting u-boot.
+
+config UBOOT_ENTRY_ADDR
+        hex "uImage Entry Address"
+        default 0xf0004000
+        ---help---
+         Do not change this unless you know what you're doing. This is
+         hardcoded by the SPARC32 and LEON port.
+
+         This is the virtual address u-boot jumps to when booting the Linux
+         Kernel.
+
+endmenu
+endif
+
 endmenu
 
 menu "Bus options (PCI etc.)"
@@ -508,6 +527,23 @@ config PCI_DOMAINS
 config PCI_SYSCALL
         def_bool PCI
 
+config PCIC_PCI
+        bool
+        depends on PCI && SPARC32 && !SPARC_LEON
+        default y
+
+config LEON_PCI
+        bool
+        depends on PCI && SPARC_LEON
+        default y
+
+config GRPCI2
+        bool "GRPCI2 Host Bridge Support"
+        depends on LEON_PCI
+        default y
+        help
+          Say Y here to include the GRPCI2 Host Bridge Driver.
+
 source "drivers/pci/Kconfig"
 
 source "drivers/pcmcia/Kconfig"
diff --git a/arch/sparc/Kconfig.debug b/arch/sparc/Kconfig.debug
index d9a795efbc04..6db35fba79fd 100644
--- a/arch/sparc/Kconfig.debug
+++ b/arch/sparc/Kconfig.debug
@@ -6,15 +6,6 @@ config TRACE_IRQFLAGS_SUPPORT
 
 source "lib/Kconfig.debug"
 
-config DEBUG_STACK_USAGE
-        bool "Enable stack utilization instrumentation"
-        depends on DEBUG_KERNEL
-        help
-          Enables the display of the minimum amount of free stack which each
-          task has ever had available in the sysrq-T and sysrq-P debug output.
-
-          This option will slow down process creation somewhat.
-
 config DEBUG_DCFLUSH
         bool "D-cache flush debugging"
         depends on SPARC64 && DEBUG_KERNEL
diff --git a/arch/sparc/Makefile b/arch/sparc/Makefile
index 113225b241e0..ad1fb5d969f3 100644
--- a/arch/sparc/Makefile
+++ b/arch/sparc/Makefile
@@ -88,7 +88,7 @@ boot := arch/sparc/boot
 # Default target
 all: zImage
 
-image zImage tftpboot.img vmlinux.aout: vmlinux
+image zImage uImage tftpboot.img vmlinux.aout: vmlinux
         $(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
 
 archclean:
@@ -102,6 +102,7 @@ ifeq ($(ARCH),sparc)
 define archhelp
   echo  '* image        - kernel image ($(boot)/image)'
   echo  '* zImage       - stripped kernel image ($(boot)/zImage)'
+  echo  '  uImage       - U-Boot SPARC32 Image (only for LEON)'
   echo  '  tftpboot.img - image prepared for tftp'
 endef
 else
diff --git a/arch/sparc/boot/Makefile b/arch/sparc/boot/Makefile
index 97e3feb9ff1b..9205416b1e67 100644
--- a/arch/sparc/boot/Makefile
+++ b/arch/sparc/boot/Makefile
@@ -5,26 +5,26 @@
 
 ROOT_IMG        := /usr/src/root.img
 ELFTOAOUT       := elftoaout
+MKIMAGE         := $(srctree)/scripts/mkuboot.sh
 
-hostprogs-y     := piggyback_32 piggyback_64 btfixupprep
+hostprogs-y     := piggyback btfixupprep
 targets         := tftpboot.img btfix.o btfix.S image zImage vmlinux.aout
 clean-files     := System.map
 
 quiet_cmd_elftoaout     = ELFTOAOUT $@
       cmd_elftoaout     = $(ELFTOAOUT) $(obj)/image -o $@
+quiet_cmd_piggy         = PIGGY   $@
+      cmd_piggy         = $(obj)/piggyback $(BITS) $@ System.map $(ROOT_IMG)
+quiet_cmd_strip         = STRIP   $@
+      cmd_strip         = $(STRIP) -R .comment -R .note -K sun4u_init -K _end -K _start $< -o $@
 
 ifeq ($(CONFIG_SPARC32),y)
-quiet_cmd_piggy         = PIGGY   $@
-      cmd_piggy         = $(obj)/piggyback_32 $@ System.map $(ROOT_IMG)
 quiet_cmd_btfix         = BTFIX   $@
       cmd_btfix         = $(OBJDUMP) -x vmlinux | $(obj)/btfixupprep > $@
 quiet_cmd_sysmap        = SYSMAP  $(obj)/System.map
       cmd_sysmap        = $(CONFIG_SHELL) $(srctree)/scripts/mksysmap
 quiet_cmd_image = LD      $@
       cmd_image = $(LD) $(LDFLAGS) $(EXTRA_LDFLAGS) $(LDFLAGS_$(@F)) -o $@
-quiet_cmd_strip = STRIP   $@
-      cmd_strip = $(STRIP) -R .comment -R .note -K sun4u_init -K _end -K _start $(obj)/image -o $@
-
 
 define rule_image
         $(if $($(quiet)cmd_image),               \
@@ -57,10 +57,7 @@ $(obj)/image: $(obj)/btfix.o FORCE
 
 $(obj)/zImage: $(obj)/image
         $(call if_changed,strip)
-
-$(obj)/tftpboot.img: $(obj)/image $(obj)/piggyback_32 System.map $(ROOT_IMG) FORCE
-        $(call if_changed,elftoaout)
-        $(call if_changed,piggy)
+        @echo '  kernel: $@ is ready'
 
 $(obj)/btfix.S: $(obj)/btfixupprep vmlinux FORCE
         $(call if_changed,btfix)
@@ -68,11 +65,6 @@ $(obj)/btfix.S: $(obj)/btfixupprep vmlinux FORCE
 endif
 
 ifeq ($(CONFIG_SPARC64),y)
-quiet_cmd_piggy     = PIGGY   $@
-      cmd_piggy     = $(obj)/piggyback_64 $@ System.map $(ROOT_IMG)
-quiet_cmd_strip     = STRIP   $@
-      cmd_strip     = $(STRIP) -R .comment -R .note -K sun4u_init -K _end -K _start vmlinux -o $@
-
 
 # Actual linking
 $(obj)/image: vmlinux FORCE
@@ -81,14 +73,43 @@ $(obj)/image: vmlinux FORCE
 
 $(obj)/zImage: $(obj)/image
         $(call if_changed,gzip)
-
-$(obj)/tftpboot.img: $(obj)/image $(obj)/piggyback_64 System.map $(ROOT_IMG) FORCE
-        $(call if_changed,elftoaout)
-        $(call if_changed,piggy)
         @echo '  kernel: $@ is ready'
 
 $(obj)/vmlinux.aout: vmlinux FORCE
         $(call if_changed,elftoaout)
         @echo '  kernel: $@ is ready'
+else
+
+# The following lines make a readable image for U-Boot.
+#  uImage   - Binary file read by U-boot
+#  uImage.o - object file of uImage for loading with a
+#             flash programmer understanding ELF.
+
+OBJCOPYFLAGS_image.bin := -S -O binary -R .note -R .comment
+$(obj)/image.bin: $(obj)/image FORCE
+        $(call if_changed,objcopy)
+
+$(obj)/image.gz: $(obj)/image.bin
+        $(call if_changed,gzip)
+
+quiet_cmd_uimage = UIMAGE  $@
+      cmd_uimage = $(CONFIG_SHELL) $(MKIMAGE) -A sparc -O linux -T kernel \
+               -C gzip -a $(CONFIG_UBOOT_LOAD_ADDR) \
+               -e $(CONFIG_UBOOT_ENTRY_ADDR) -n 'Linux-$(KERNELRELEASE)' \
+               -d $< $@
+
+quiet_cmd_uimage.o = UIMAGE.O $@
+      cmd_uimage.o = $(LD) -Tdata $(CONFIG_UBOOT_FLASH_ADDR) \
+                     -r -b binary $@ -o $@.o
+
+targets += uImage
+$(obj)/uImage: $(obj)/image.gz
+        $(call if_changed,uimage)
+        $(call if_changed,uimage.o)
+        @echo '  Image $@ is ready'
+
 endif
 
+$(obj)/tftpboot.img: $(obj)/image $(obj)/piggyback System.map $(ROOT_IMG) FORCE
+        $(call if_changed,elftoaout)
+        $(call if_changed,piggy)
diff --git a/arch/sparc/boot/piggyback.c b/arch/sparc/boot/piggyback.c
new file mode 100644
index 000000000000..c0a798fcf030
--- /dev/null
+++ b/arch/sparc/boot/piggyback.c
@@ -0,0 +1,272 @@
+/*
+   Simple utility to make a single-image install kernel with initial ramdisk
+   for Sparc tftpbooting without need to set up nfs.
+
+   Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
+   Pete Zaitcev <zaitcev@yahoo.com> endian fixes for cross-compiles, 2000.
+   Copyright (C) 2011 Sam Ravnborg <sam@ravnborg.org>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <dirent.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+/*
+ * Note: run this on an a.out kernel (use elftoaout for it),
+ * as PROM looks for a.out image only.
+ */
+
+#define AOUT_TEXT_OFFSET   32
+
+static int is64bit = 0;
+
+/* align to power-of-two size */
+static int align(int n)
+{
+        if (is64bit)
+                return (n + 0x1fff) & ~0x1fff;
+        else
+                return (n + 0xfff) & ~0xfff;
+}
+
+/* read two bytes as big endian */
+static unsigned short ld2(char *p)
+{
+        return (p[0] << 8) | p[1];
+}
+
+/* save 4 bytes as big endian */
+static void st4(char *p, unsigned int x)
+{
+        p[0] = x >> 24;
+        p[1] = x >> 16;
+        p[2] = x >> 8;
+        p[3] = x;
+}
+
+static void die(const char *str)
+{
+        perror(str);
+        exit(1);
+}
+
+static void usage(void)
+{
+        /* fs_img.gz is an image of initial ramdisk. */
+        fprintf(stderr, "Usage: piggyback bits vmlinux.aout System.map fs_img.gz\n");
+        fprintf(stderr, "\tKernel image will be modified in place.\n");
+        exit(1);
+}
+
+static int start_line(const char *line)
+{
+        if (strcmp(line + 8, " T _start\n") == 0)
+                return 1;
+        else if (strcmp(line + 16, " T _start\n") == 0)
+                return 1;
+        return 0;
+}
+
+static int end_line(const char *line)
+{
+        if (strcmp(line + 8, " A _end\n") == 0)
+                return 1;
+        else if (strcmp (line + 16, " A _end\n") == 0)
+                return 1;
+        return 0;
+}
+
+/*
+ * Find address for start and end in System.map.
+ * The file looks like this:
+ * f0004000 T _start
+ * f0379f79 A _end
+ * 1234567890123456
+ * ^coloumn 1
+ * There is support for 64 bit addresses too.
+ *
+ * Return 0 if either start or end is not found
+ */
+static int get_start_end(const char *filename, unsigned int *start,
+                                               unsigned int *end)
+{
+        FILE *map;
+        char buffer[1024];
+
+        *start = 0;
+        *end = 0;
+        map = fopen(filename, "r");
+        if (!map)
+                die(filename);
+        while (fgets(buffer, 1024, map)) {
+                if (start_line(buffer))
+                        *start = strtoul(buffer, NULL, 16);
+                else if (end_line(buffer))
+                        *end = strtoul(buffer, NULL, 16);
+        }
+        fclose (map);
+
+        if (*start == 0 || *end == 0)
+                return 0;
+
+        return 1;
+}
+
+#define LOOKBACK (128 * 4)
+#define BUFSIZE 1024
+/*
+ * Find the HdrS entry from head_32/head_64.
+ * We check if it is at the beginning of the file (sparc64 case)
+ * and if not we search for it.
+ * When we search do so in steps of 4 as HdrS is on a 4-byte aligned
+ * address (it is on same alignment as sparc instructions)
+ * Return the offset to the HdrS entry (as off_t)
+ */
+static off_t get_hdrs_offset(int kernelfd, const char *filename)
+{
+        char buffer[BUFSIZE];
+        off_t offset;
+        int i;
+
+        if (lseek(kernelfd, 0, SEEK_SET) < 0)
+                die("lseek");
+        if (read(kernelfd, buffer, BUFSIZE) != BUFSIZE)
+                die(filename);
+
+        if (buffer[40] == 'H' && buffer[41] == 'd' &&
+            buffer[42] == 'r' && buffer[43] == 'S') {
+                return 40;
+        } else {
+                /*  Find the gokernel label */
+                /* Decode offset from branch instruction */
+                offset = ld2(buffer + AOUT_TEXT_OFFSET + 2) << 2;
+                /* Go back 512 bytes so we do not miss HdrS */
+                offset -= LOOKBACK;
+                /* skip a.out header */
+                offset += AOUT_TEXT_OFFSET;
+                if (lseek(kernelfd, offset, SEEK_SET) < 0)
+                        die("lseek");
+                if (read(kernelfd, buffer, BUFSIZE) != BUFSIZE)
+                        die(filename);
+
+                for (i = 0; i < LOOKBACK; i += 4) {
+                        if (buffer[i + 0] == 'H' && buffer[i + 1] == 'd' &&
+                            buffer[i + 2] == 'r' && buffer[i + 3] == 'S') {
+                                return offset + i;
+                        }
+                }
+        }
+        fprintf (stderr, "Couldn't find headers signature in %s\n", filename);
+        exit(1);
+}
+
+int main(int argc,char **argv)
+{
+        static char aout_magic[] = { 0x01, 0x03, 0x01, 0x07 };
+        char buffer[1024];
+        unsigned int i, start, end;
+        off_t offset;
+        struct stat s;
+        int image, tail;
+
+        if (argc != 5)
+                usage();
+        if (strcmp(argv[1], "64") == 0)
+                is64bit = 1;
+        if (stat (argv[4], &s) < 0)
+                die(argv[4]);
+
+        if (!get_start_end(argv[3], &start, &end)) {
+                fprintf(stderr, "Could not determine start and end from %s\n",
+                        argv[3]);
+                exit(1);
+        }
+        if ((image = open(argv[2], O_RDWR)) < 0)
+                die(argv[2]);
+        if (read(image, buffer, 512) != 512)
+                die(argv[2]);
+        if (memcmp(buffer, aout_magic, 4) != 0) {
+                fprintf (stderr, "Not a.out. Don't blame me.\n");
+                exit(1);
+        }
+        /*
+         * We need to fill in values for
+         * sparc_ramdisk_image + sparc_ramdisk_size
+         * To locate these symbols search for the "HdrS" text which appear
+         * in the image a little before the gokernel symbol.
+         * See definition of these in init_32.S
+         */
+
+        offset = get_hdrs_offset(image, argv[2]);
+        /* skip HdrS + LINUX_VERSION_CODE + HdrS version */
+        offset += 10;
+
+        if (lseek(image, offset, 0) < 0)
+                die("lseek");
+
+        /*
+         * root_flags = 0
+         * root_dev = 1 (RAMDISK_MAJOR)
+         * ram_flags = 0
+         * sparc_ramdisk_image = "PAGE aligned address after _end")
+         * sparc_ramdisk_size = size of image
+         */
+        st4(buffer, 0);
+        st4(buffer + 4, 0x01000000);
+        st4(buffer + 8, align(end + 32));
+        st4(buffer + 12, s.st_size);
+
+        if (write(image, buffer + 2, 14) != 14)
+                die(argv[2]);
+
+        /* For sparc64 update a_text and clear a_data + a_bss */
+        if (is64bit)
+        {
+                if (lseek(image, 4, 0) < 0)
+                        die("lseek");
+                /* a_text */
+                st4(buffer, align(end + 32 + 8191) - (start & ~0x3fffffUL) +
+                            s.st_size);
+                /* a_data */
+                st4(buffer + 4, 0);
+                /* a_bss */
+                st4(buffer + 8, 0);
+                if (write(image, buffer, 12) != 12)
+                        die(argv[2]);
+        }
+
+        /* seek page aligned boundary in the image file and add boot image */
+        if (lseek(image, AOUT_TEXT_OFFSET - start + align(end + 32), 0) < 0)
+                die("lseek");
+        if ((tail = open(argv[4], O_RDONLY)) < 0)
+                die(argv[4]);
+        while ((i = read(tail, buffer, 1024)) > 0)
+                if (write(image, buffer, i) != i)
+                        die(argv[2]);
+        if (close(image) < 0)
+                die("close");
+        if (close(tail) < 0)
+                die("close");
+        return 0;
+}
diff --git a/arch/sparc/boot/piggyback_32.c b/arch/sparc/boot/piggyback_32.c
deleted file mode 100644
index ac944aec7301..000000000000
--- a/arch/sparc/boot/piggyback_32.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-   Simple utility to make a single-image install kernel with initial ramdisk
-   for Sparc tftpbooting without need to set up nfs.
-
-   Copyright (C) 1996 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
-   Pete Zaitcev <zaitcev@yahoo.com> endian fixes for cross-compiles, 2000.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
-   
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <dirent.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-/*
- * Note: run this on an a.out kernel (use elftoaout for it),
- * as PROM looks for a.out image only.
- */
-
-static unsigned short ld2(char *p)
-{
-        return (p[0] << 8) | p[1];
-}
-
-static unsigned int ld4(char *p)
-{
-        return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
-}
-
-static void st4(char *p, unsigned int x)
-{
-        p[0] = x >> 24;
-        p[1] = x >> 16;
-        p[2] = x >> 8;
-        p[3] = x;
-}
-
-static void usage(void)
-{
-        /* fs_img.gz is an image of initial ramdisk. */
-        fprintf(stderr, "Usage: piggyback vmlinux.aout System.map fs_img.gz\n");
-        fprintf(stderr, "\tKernel image will be modified in place.\n");
-        exit(1);
-}
-
-static void die(char *str)
-{
-        perror (str);
-        exit(1);
-}
-
-int main(int argc,char **argv)
-{
-        static char aout_magic[] = { 0x01, 0x03, 0x01, 0x07 };
-        char buffer[1024], *q, *r;
-        unsigned int i, j, k, start, end, offset;
-        FILE *map;
-        struct stat s;
-        int image, tail;
-
-        if (argc != 4) usage();
-        start = end = 0;
-        if (stat (argv[3], &s) < 0) die (argv[3]);
-        map = fopen (argv[2], "r");
-        if (!map) die(argv[2]);
-        while (fgets (buffer, 1024, map)) {
-                if (!strcmp (buffer + 8, " T start\n") || !strcmp (buffer + 16, " T start\n"))
-                        start = strtoul (buffer, NULL, 16);
-                else if (!strcmp (buffer + 8, " A _end\n") || !strcmp (buffer + 16, " A _end\n"))
-                        end = strtoul (buffer, NULL, 16);
-        }
-        fclose (map);
-        if (!start || !end) {
-                fprintf (stderr, "Could not determine start and end from System.map\n");
-                exit(1);
-        }
-        if ((image = open(argv[1],O_RDWR)) < 0) die(argv[1]);
-        if (read(image,buffer,512) != 512) die(argv[1]);
-        if (memcmp (buffer, "\177ELF", 4) == 0) {
-                q = buffer + ld4(buffer + 28);
-                i = ld4(q + 4) + ld4(buffer + 24) - ld4(q + 8);
-                if (lseek(image,i,0) < 0) die("lseek");
-                if (read(image,buffer,512) != 512) die(argv[1]);
-                j = 0;
-        } else if (memcmp(buffer, aout_magic, 4) == 0) {
-                i = j = 32;
-        } else {
-                fprintf (stderr, "Not ELF nor a.out. Don't blame me.\n");
-                exit(1);
-        }
-        k = i;
-        i += (ld2(buffer + j + 2)<<2) - 512;
-        if (lseek(image,i,0) < 0) die("lseek");
-        if (read(image,buffer,1024) != 1024) die(argv[1]);
-        for (q = buffer, r = q + 512; q < r; q += 4) {
-                if (*q == 'H' && q[1] == 'd' && q[2] == 'r' && q[3] == 'S')
-                        break;
-        }
-        if (q == r) {
-                fprintf (stderr, "Couldn't find headers signature in the kernel.\n");
-                exit(1);
-        }
-        offset = i + (q - buffer) + 10;
-        if (lseek(image, offset, 0) < 0) die ("lseek");
-
-        st4(buffer, 0);
-        st4(buffer + 4, 0x01000000);
-        st4(buffer + 8, (end + 32 + 4095) & ~4095);
-        st4(buffer + 12, s.st_size);
-
-        if (write(image,buffer+2,14) != 14) die (argv[1]);
-        if (lseek(image, k - start + ((end + 32 + 4095) & ~4095), 0) < 0) die ("lseek");
-        if ((tail = open(argv[3],O_RDONLY)) < 0) die(argv[3]);
-        while ((i = read (tail,buffer,1024)) > 0)
-                if (write(image,buffer,i) != i) die (argv[1]);
-        if (close(image) < 0) die("close");
-        if (close(tail) < 0) die("close");
-        return 0;
-}
diff --git a/arch/sparc/boot/piggyback_64.c b/arch/sparc/boot/piggyback_64.c
deleted file mode 100644
index a26a686cb5aa..000000000000
--- a/arch/sparc/boot/piggyback_64.c
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
-   Simple utility to make a single-image install kernel with initial ramdisk
-   for Sparc64 tftpbooting without need to set up nfs.
-   
-   Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
-   
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-   
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
-   
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <dirent.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-/* Note: run this on an a.out kernel (use elftoaout for it), as PROM looks for a.out image onlly
-   usage: piggyback vmlinux System.map tail, where tail is gzipped fs of the initial ramdisk */
-
-static void die(char *str)
-{
-        perror (str);
-        exit(1);
-}
-
-int main(int argc,char **argv)
-{
-        char buffer [1024], *q, *r;
-        unsigned int i, j, k, start, end, offset;
-        FILE *map;
-        struct stat s;
-        int image, tail;
-        
-        start = end = 0;
-        if (stat (argv[3], &s) < 0) die (argv[3]);
-        map = fopen (argv[2], "r");
-        if (!map) die(argv[2]);
-        while (fgets (buffer, 1024, map)) {
-                if (!strcmp (buffer + 19, "_start\n"))
-                start = strtoul (buffer + 8, NULL, 16);
-                else if (!strcmp (buffer + 19, "_end\n"))
-                end = strtoul (buffer + 8, NULL, 16);
-        }
-        fclose (map);
-        if ((image = open(argv[1],O_RDWR)) < 0) die(argv[1]);
-        if (read(image,buffer,512) != 512) die(argv[1]);
-        if (!memcmp (buffer, "\177ELF", 4)) {
-                unsigned int *p = (unsigned int *)(buffer + *(unsigned int *)(buffer + 28));
-                
-                i = p[1] + *(unsigned int *)(buffer + 24) - p[2];
-                if (lseek(image,i,0) < 0) die("lseek");
-                if (read(image,buffer,512) != 512) die(argv[1]);
-                j = 0;
-        } else if (*(unsigned int *)buffer == 0x01030107) {
-                i = j = 32;
-        } else {
-                fprintf (stderr, "Not ELF nor a.out. Don't blame me.\n");
-                exit(1);
-        }
-        k = i;
-        if (j == 32 && buffer[40] == 'H' && buffer[41] == 'd' && buffer[42] == 'r' && buffer[43] == 'S') {
-                offset = 40 + 10;
-        } else {
-                i += ((*(unsigned short *)(buffer + j + 2))<<2) - 512;
-                if (lseek(image,i,0) < 0) die("lseek");
-                if (read(image,buffer,1024) != 1024) die(argv[1]);
-                for (q = buffer, r = q + 512; q < r; q += 4) {
-                        if (*q == 'H' && q[1] == 'd' && q[2] == 'r' && q[3] == 'S')
-                                break;
-                }
-                if (q == r) {
-                        fprintf (stderr, "Couldn't find headers signature in the kernel.\n");
-                        exit(1);
-                }
-                offset = i + (q - buffer) + 10;
-        }
-        if (lseek(image, offset, 0) < 0) die ("lseek");
-        *(unsigned *)buffer = 0;
-        *(unsigned *)(buffer + 4) = 0x01000000;
-        *(unsigned *)(buffer + 8) = ((end + 32 + 8191) & ~8191);
-        *(unsigned *)(buffer + 12) = s.st_size;
-        if (write(image,buffer+2,14) != 14) die (argv[1]);
-        if (lseek(image, 4, 0) < 0) die ("lseek");
-        *(unsigned *)buffer = ((end + 32 + 8191) & ~8191) - (start & ~0x3fffffUL) + s.st_size;
-        *(unsigned *)(buffer + 4) = 0;
-        *(unsigned *)(buffer + 8) = 0;
-        if (write(image,buffer,12) != 12) die (argv[1]);
-        if (lseek(image, k - start + ((end + 32 + 8191) & ~8191), 0) < 0) die ("lseek");
-        if ((tail = open(argv[3],O_RDONLY)) < 0) die(argv[3]);
-        while ((i = read (tail,buffer,1024)) > 0)
-                if (write(image,buffer,i) != i) die (argv[1]);
-        if (close(image) < 0) die("close");
-        if (close(tail) < 0) die("close");
-        return 0;
-}
diff --git a/arch/sparc/include/asm/Kbuild b/arch/sparc/include/asm/Kbuild
index deeb0fba8029..3c93f08ce187 100644
--- a/arch/sparc/include/asm/Kbuild
+++ b/arch/sparc/include/asm/Kbuild
@@ -7,7 +7,6 @@ header-y += display7seg.h
 header-y += envctrl.h
 header-y += fbio.h
 header-y += jsflash.h
-header-y += openprom.h
 header-y += openpromio.h
 header-y += perfctr.h
 header-y += psrcompat.h
diff --git a/arch/sparc/include/asm/bitops_32.h b/arch/sparc/include/asm/bitops_32.h
index 9cf4ae0cd7ba..25a676653d45 100644
--- a/arch/sparc/include/asm/bitops_32.h
+++ b/arch/sparc/include/asm/bitops_32.h
@@ -103,9 +103,8 @@ static inline void change_bit(unsigned long nr, volatile unsigned long *addr)
 #include <asm-generic/bitops/hweight.h>
 #include <asm-generic/bitops/lock.h>
 #include <asm-generic/bitops/find.h>
-#include <asm-generic/bitops/ext2-non-atomic.h>
+#include <asm-generic/bitops/le.h>
 #include <asm-generic/bitops/ext2-atomic.h>
-#include <asm-generic/bitops/minix.h>
 
 #endif /* __KERNEL__ */
 
diff --git a/arch/sparc/include/asm/bitops_64.h b/arch/sparc/include/asm/bitops_64.h
index 766121a67a24..38e9aa1b2cea 100644
--- a/arch/sparc/include/asm/bitops_64.h
+++ b/arch/sparc/include/asm/bitops_64.h
@@ -89,15 +89,13 @@ static inline unsigned int __arch_hweight8(unsigned int w)
 
 #ifdef __KERNEL__
 
-#include <asm-generic/bitops/ext2-non-atomic.h>
+#include <asm-generic/bitops/le.h>
 
 #define ext2_set_bit_atomic(lock,nr,addr) \
         test_and_set_bit((nr) ^ 0x38,(unsigned long *)(addr))
 #define ext2_clear_bit_atomic(lock,nr,addr) \
         test_and_clear_bit((nr) ^ 0x38,(unsigned long *)(addr))
 
-#include <asm-generic/bitops/minix.h>
-
 #endif /* __KERNEL__ */
 
 #endif /* defined(_SPARC64_BITOPS_H) */
diff --git a/arch/sparc/include/asm/cpudata_32.h b/arch/sparc/include/asm/cpudata_32.h
index 31d48a0e32c7..a4c5a938b936 100644
--- a/arch/sparc/include/asm/cpudata_32.h
+++ b/arch/sparc/include/asm/cpudata_32.h
@@ -16,6 +16,10 @@ typedef struct {
         unsigned long clock_tick;
         unsigned int multiplier;
         unsigned int counter;
+#ifdef CONFIG_SMP
+        unsigned int irq_resched_count;
+        unsigned int irq_call_count;
+#endif
         int prom_node;
         int mid;
         int next;
@@ -23,5 +27,6 @@ typedef struct {
 
 DECLARE_PER_CPU(cpuinfo_sparc, __cpu_data);
 #define cpu_data(__cpu) per_cpu(__cpu_data, (__cpu))
+#define local_cpu_data() __get_cpu_var(__cpu_data)
 
 #endif /* _SPARC_CPUDATA_H */
diff --git a/arch/sparc/include/asm/errno.h b/arch/sparc/include/asm/errno.h
index 4e2bc490d714..c351aba997b7 100644
--- a/arch/sparc/include/asm/errno.h
+++ b/arch/sparc/include/asm/errno.h
@@ -112,4 +112,6 @@
 
 #define ERFKILL         134     /* Operation not possible due to RF-kill */
 
+#define EHWPOISON       135     /* Memory page has hardware error */
+
 #endif
diff --git a/arch/sparc/include/asm/fcntl.h b/arch/sparc/include/asm/fcntl.h
index 38f37b333cc7..d0b83f66f356 100644
--- a/arch/sparc/include/asm/fcntl.h
+++ b/arch/sparc/include/asm/fcntl.h
@@ -34,6 +34,8 @@
 #define __O_SYNC        0x800000
 #define O_SYNC          (__O_SYNC|O_DSYNC)
 
+#define O_PATH          0x1000000
+
 #define F_GETOWN        5       /*  for sockets. */
 #define F_SETOWN        6       /*  for sockets. */
 #define F_GETLK         7
diff --git a/arch/sparc/include/asm/floppy_32.h b/arch/sparc/include/asm/floppy_32.h
index c792830636de..7440915e86d8 100644
--- a/arch/sparc/include/asm/floppy_32.h
+++ b/arch/sparc/include/asm/floppy_32.h
@@ -138,7 +138,7 @@ static unsigned char sun_82072_fd_inb(int port)
                 return sun_fdc->data_82072;
         case 7: /* FD_DIR */
                 return sun_read_dir();
-        };
+        }
         panic("sun_82072_fd_inb: How did I get here?");
 }
 
@@ -161,7 +161,7 @@ static void sun_82072_fd_outb(unsigned char value, int port)
         case 4: /* FD_STATUS */
                 sun_fdc->status_82072 = value;
                 break;
-        };
+        }
         return;
 }
 
@@ -186,7 +186,7 @@ static unsigned char sun_82077_fd_inb(int port)
                 return sun_fdc->data_82077;
         case 7: /* FD_DIR */
                 return sun_read_dir();
-        };
+        }
         panic("sun_82077_fd_inb: How did I get here?");
 }
 
@@ -212,7 +212,7 @@ static void sun_82077_fd_outb(unsigned char value, int port)
         case 3: /* FD_TDR */
                 sun_fdc->tapectl_82077 = value;
                 break;
-        };
+        }
         return;
 }
 
@@ -281,35 +281,34 @@ static inline void sun_fd_enable_dma(void)
         pdma_areasize = pdma_size;
 }
 
-/* Our low-level entry point in arch/sparc/kernel/entry.S */
-extern int sparc_floppy_request_irq(int irq, unsigned long flags,
-                                    irq_handler_t irq_handler);
+extern int sparc_floppy_request_irq(unsigned int irq,
+                                    irq_handler_t irq_handler);
 
 static int sun_fd_request_irq(void)
 {
         static int once = 0;
-        int error;
 
-        if(!once) {
+        if (!once) {
                 once = 1;
-                error = sparc_floppy_request_irq(FLOPPY_IRQ,
-                                                 IRQF_DISABLED,
-                                                 floppy_interrupt);
-                return ((error == 0) ? 0 : -1);
-        } else return 0;
+                return sparc_floppy_request_irq(FLOPPY_IRQ, floppy_interrupt);
+        } else {
+                return 0;
+        }
 }
 
 static struct linux_prom_registers fd_regs[2];
 
 static int sun_floppy_init(void)
 {
+        struct platform_device *op;
+        struct device_node *dp;
         char state[128];
-        int tnode, fd_node, num_regs;
+        phandle tnode, fd_node;
+        int num_regs;
         struct resource r;
 
         use_virtual_dma = 1;
 
-        FLOPPY_IRQ = 11;
         /* Forget it if we aren't on a machine that could possibly
          * ever have a floppy drive.
          */
@@ -348,6 +347,26 @@ static int sun_floppy_init(void)
         sun_fdc = (struct sun_flpy_controller *)
             of_ioremap(&r, 0, fd_regs[0].reg_size, "floppy");
 
+        /* Look up irq in platform_device.
+         * We try "SUNW,fdtwo" and "fd"
+         */
+        for_each_node_by_name(dp, "SUNW,fdtwo") {
+                op = of_find_device_by_node(dp);
+                if (op)
+                        break;
+        }
+        if (!op) {
+                for_each_node_by_name(dp, "fd") {
+                        op = of_find_device_by_node(dp);
+                        if (op)
+                                break;
+                }
+        }
+        if (!op)
+                goto no_sun_fdc;
+
+        FLOPPY_IRQ = op->archdata.irqs[0];
+
         /* Last minute sanity check... */
         if(sun_fdc->status_82072 == 0xff) {
                 sun_fdc = NULL;
diff --git a/arch/sparc/include/asm/floppy_64.h b/arch/sparc/include/asm/floppy_64.h
index 6597ce874d78..bcef1f5a2a6d 100644
--- a/arch/sparc/include/asm/floppy_64.h
+++ b/arch/sparc/include/asm/floppy_64.h
@@ -111,7 +111,7 @@ static unsigned char sun_82077_fd_inb(unsigned long port)
         case 7: /* FD_DIR */
                 /* XXX: Is DCL on 0x80 in sun4m? */
                 return sbus_readb(&sun_fdc->dir_82077);
-        };
+        }
         panic("sun_82072_fd_inb: How did I get here?");
 }
 
@@ -135,7 +135,7 @@ static void sun_82077_fd_outb(unsigned char value, unsigned long port)
         case 4: /* FD_STATUS */
                 sbus_writeb(value, &sun_fdc->status_82077);
                 break;
-        };
+        }
         return;
 }
 
diff --git a/arch/sparc/include/asm/futex_64.h b/arch/sparc/include/asm/futex_64.h
index 47f95839dc69..444e7bea23bc 100644
--- a/arch/sparc/include/asm/futex_64.h
+++ b/arch/sparc/include/asm/futex_64.h
@@ -30,7 +30,7 @@
         : "r" (uaddr), "r" (oparg), "i" (-EFAULT)       \
         : "memory")
 
-static inline int futex_atomic_op_inuser(int encoded_op, int __user *uaddr)
+static inline int futex_atomic_op_inuser(int encoded_op, u32 __user *uaddr)
 {
         int op = (encoded_op >> 28) & 7;
         int cmp = (encoded_op >> 24) & 15;
@@ -38,7 +38,7 @@ static inline int futex_atomic_op_inuser(int encoded_op, int __user *uaddr)
         int cmparg = (encoded_op << 20) >> 20;
         int oldval = 0, ret, tem;
 
-        if (unlikely(!access_ok(VERIFY_WRITE, uaddr, sizeof(int))))
+        if (unlikely(!access_ok(VERIFY_WRITE, uaddr, sizeof(u32))))
                 return -EFAULT;
         if (unlikely((((unsigned long) uaddr) & 0x3UL)))
                 return -EINVAL;
@@ -85,26 +85,30 @@ static inline int futex_atomic_op_inuser(int encoded_op, int __user *uaddr)
 }
 
 static inline int
-futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
+futex_atomic_cmpxchg_inatomic(u32 *uval, u32 __user *uaddr,
+                              u32 oldval, u32 newval)
 {
+        int ret = 0;
+
         __asm__ __volatile__(
-        "\n1:   casa    [%3] %%asi, %2, %0\n"
+        "\n1:   casa    [%4] %%asi, %3, %1\n"
         "2:\n"
         "       .section .fixup,#alloc,#execinstr\n"
         "       .align  4\n"
         "3:     sethi   %%hi(2b), %0\n"
         "       jmpl    %0 + %%lo(2b), %%g0\n"
-        "        mov    %4, %0\n"
+        "       mov     %5, %0\n"
         "       .previous\n"
         "       .section __ex_table,\"a\"\n"
         "       .align  4\n"
         "       .word   1b, 3b\n"
         "       .previous\n"
-        : "=r" (newval)
-        : "0" (newval), "r" (oldval), "r" (uaddr), "i" (-EFAULT)
+        : "+r" (ret), "=r" (newval)
+        : "1" (newval), "r" (oldval), "r" (uaddr), "i" (-EFAULT)
         : "memory");
 
-        return newval;
+        *uval = newval;
+        return ret;
 }
 
 #endif /* !(_SPARC64_FUTEX_H) */
diff --git a/arch/sparc/include/asm/highmem.h b/arch/sparc/include/asm/highmem.h
index ec23b0a87b98..3d7afbb7f4bb 100644
--- a/arch/sparc/include/asm/highmem.h
+++ b/arch/sparc/include/asm/highmem.h
@@ -70,8 +70,8 @@ static inline void kunmap(struct page *page)
         kunmap_high(page);
 }
 
-extern void *kmap_atomic(struct page *page, enum km_type type);
-extern void kunmap_atomic_notypecheck(void *kvaddr, enum km_type type);
+extern void *__kmap_atomic(struct page *page);
+extern void __kunmap_atomic(void *kvaddr);
 extern struct page *kmap_atomic_to_page(void *vaddr);
 
 #define flush_cache_kmaps()     flush_cache_all()
diff --git a/arch/sparc/include/asm/hypervisor.h b/arch/sparc/include/asm/hypervisor.h
index bafe5a631b6d..75686409be24 100644
--- a/arch/sparc/include/asm/hypervisor.h
+++ b/arch/sparc/include/asm/hypervisor.h
@@ -654,7 +654,7 @@ extern unsigned long sun4v_mmu_tsb_ctx0(unsigned long num_descriptions,
  * ARG3:        mmu context
  * ARG4:        flags (HV_MMU_{IMMU,DMMU})
  * RET0:        status
- * ERRORS:      EINVAL                  Invalid virutal address, context, or
+ * ERRORS:      EINVAL                  Invalid virtual address, context, or
  *                                      flags value
  *              ENOTSUPPORTED           ARG0 or ARG1 is non-zero
  *
@@ -721,7 +721,7 @@ extern void sun4v_mmu_demap_all(void);
  * ARG2:        TTE
  * ARG3:        flags (HV_MMU_{IMMU,DMMU})
  * RET0:        status
- * ERRORS:      EINVAL                  Invalid virutal address or flags value
+ * ERRORS:      EINVAL                  Invalid virtual address or flags value
  *              EBADPGSZ                Invalid page size value
  *              ENORADDR                Invalid real address in TTE
  *              ETOOMANY                Too many mappings (max of 8 reached)
@@ -800,7 +800,7 @@ extern unsigned long sun4v_mmu_map_perm_addr(unsigned long vaddr,
  * ARG1:        reserved, must be zero
  * ARG2:        flags (HV_MMU_{IMMU,DMMU})
  * RET0:        status
- * ERRORS:      EINVAL                  Invalid virutal address or flags value
+ * ERRORS:      EINVAL                  Invalid virtual address or flags value
  *              ENOMAP                  Specified mapping was not found
  *
  * Demaps any permanent page mapping (established via
@@ -1205,7 +1205,7 @@ struct hv_trap_trace_control {
  * structure contents.  Attempts to do so will result in undefined
  * behavior for the guest.
  *
- * Each trap trace buffer entry is layed out as follows:
+ * Each trap trace buffer entry is laid out as follows:
  */
 #ifndef __ASSEMBLY__
 struct hv_trap_trace_entry {
@@ -1300,7 +1300,7 @@ struct hv_trap_trace_entry {
  * state in RET1.  Future systems may define various flags for the
  * enable argument (ARG0), for the moment a guest should pass
  * "(uint64_t) -1" to enable, and "(uint64_t) 0" to disable all
- * tracing - which will ensure future compatability.
+ * tracing - which will ensure future compatibility.
  */
 #define HV_FAST_TTRACE_ENABLE           0x92
 
@@ -1880,7 +1880,7 @@ extern unsigned long sun4v_vintr_set_target(unsigned long dev_handle,
  * pci_device, at pci_config_offset from the beginning of the device's
  * configuration space.  If there was no error, RET1 is set to zero and
  * RET2 is set to the data read.  Insignificant bits in RET2 are not
- * guarenteed to have any specific value and therefore must be ignored.
+ * guaranteed to have any specific value and therefore must be ignored.
  *
  * The data returned in RET2 is size based byte swapped.
  *
@@ -1941,9 +1941,9 @@ extern unsigned long sun4v_vintr_set_target(unsigned long dev_handle,
  * and return the actual data read in RET2.  The data returned is size based
  * byte swapped.
  *
- * Non-significant bits in RET2 are not guarenteed to have any specific value
+ * Non-significant bits in RET2 are not guaranteed to have any specific value
  * and therefore must be ignored.  If RET1 is returned as non-zero, the data
- * value is not guarenteed to have any specific value and should be ignored.
+ * value is not guaranteed to have any specific value and should be ignored.
  *
  * The caller must have permission to read from the given devhandle, real
  * address, which must be an IO address.  The argument real address must be a
@@ -2456,9 +2456,9 @@ extern unsigned long sun4v_vintr_set_target(unsigned long dev_handle,
  *
  * As receive queue configuration causes a reset of the queue's head and
  * tail pointers there is no way for a gues to determine how many entries
- * have been received between a preceeding ldc_get_rx_state() API call
+ * have been received between a preceding ldc_get_rx_state() API call
  * and the completion of the configuration operation.  It should be noted
- * that datagram delivery is not guarenteed via domain channels anyway,
+ * that datagram delivery is not guaranteed via domain channels anyway,
  * and therefore any higher protocol should be resilient to datagram
  * loss if necessary.  However, to overcome this specific race potential
  * it is recommended, for example, that a higher level protocol be employed
diff --git a/arch/sparc/include/asm/io.h b/arch/sparc/include/asm/io.h
index a34b2994937a..f6902cf3cbe9 100644
--- a/arch/sparc/include/asm/io.h
+++ b/arch/sparc/include/asm/io.h
@@ -5,4 +5,17 @@
 #else
 #include <asm/io_32.h>
 #endif
+
+/*
+ * Defines used for both SPARC32 and SPARC64
+ */
+
+/* Big endian versions of memory read/write routines */
+#define readb_be(__addr)        __raw_readb(__addr)
+#define readw_be(__addr)        __raw_readw(__addr)
+#define readl_be(__addr)        __raw_readl(__addr)
+#define writeb_be(__b, __addr)  __raw_writeb(__b, __addr)
+#define writel_be(__w, __addr)  __raw_writel(__w, __addr)
+#define writew_be(__l, __addr)  __raw_writew(__l, __addr)
+
 #endif
diff --git a/arch/sparc/include/asm/io_32.h b/arch/sparc/include/asm/io_32.h
index 2889574608db..c2ced21c9dc1 100644
--- a/arch/sparc/include/asm/io_32.h
+++ b/arch/sparc/include/asm/io_32.h
@@ -208,6 +208,21 @@ _memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)
 #define memset_io(d,c,sz)       _memset_io(d,c,sz)
 
 static inline void
+_sbus_memcpy_fromio(void *dst, const volatile void __iomem *src,
+                    __kernel_size_t n)
+{
+        char *d = dst;
+
+        while (n--) {
+                char tmp = sbus_readb(src);
+                *d++ = tmp;
+                src++;
+        }
+}
+
+#define sbus_memcpy_fromio(d, s, sz)    _sbus_memcpy_fromio(d, s, sz)
+
+static inline void
 _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
 {
         char *d = dst;
@@ -222,6 +237,22 @@ _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
 #define memcpy_fromio(d,s,sz)   _memcpy_fromio(d,s,sz)
 
 static inline void
+_sbus_memcpy_toio(volatile void __iomem *dst, const void *src,
+                  __kernel_size_t n)
+{
+        const char *s = src;
+        volatile void __iomem *d = dst;
+
+        while (n--) {
+                char tmp = *s++;
+                sbus_writeb(tmp, d);
+                d++;
+        }
+}
+
+#define sbus_memcpy_toio(d, s, sz)      _sbus_memcpy_toio(d, s, sz)
+
+static inline void
 _memcpy_toio(volatile void __iomem *dst, const void *src, __kernel_size_t n)
 {
         const char *s = src;
diff --git a/arch/sparc/include/asm/io_64.h b/arch/sparc/include/asm/io_64.h
index 9517d063c79c..9c8965415f0a 100644
--- a/arch/sparc/include/asm/io_64.h
+++ b/arch/sparc/include/asm/io_64.h
@@ -419,6 +419,21 @@ _memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)
 #define memset_io(d,c,sz)       _memset_io(d,c,sz)
 
 static inline void
+_sbus_memcpy_fromio(void *dst, const volatile void __iomem *src,
+                    __kernel_size_t n)
+{
+        char *d = dst;
+
+        while (n--) {
+                char tmp = sbus_readb(src);
+                *d++ = tmp;
+                src++;
+        }
+}
+
+#define sbus_memcpy_fromio(d, s, sz)    _sbus_memcpy_fromio(d, s, sz)
+
+static inline void
 _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
 {
         char *d = dst;
@@ -433,6 +448,22 @@ _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
 #define memcpy_fromio(d,s,sz)   _memcpy_fromio(d,s,sz)
 
 static inline void
+_sbus_memcpy_toio(volatile void __iomem *dst, const void *src,
+                  __kernel_size_t n)
+{
+        const char *s = src;
+        volatile void __iomem *d = dst;
+
+        while (n--) {
+                char tmp = *s++;
+                sbus_writeb(tmp, d);
+                d++;
+        }
+}
+
+#define sbus_memcpy_toio(d, s, sz)      _sbus_memcpy_toio(d, s, sz)
+
+static inline void
 _memcpy_toio(volatile void __iomem *dst, const void *src, __kernel_size_t n)
 {
         const char *s = src;
diff --git a/arch/sparc/include/asm/ioctls.h b/arch/sparc/include/asm/ioctls.h
index 53f4ee009bdd..28d0c8b02cc3 100644
--- a/arch/sparc/include/asm/ioctls.h
+++ b/arch/sparc/include/asm/ioctls.h
@@ -19,6 +19,8 @@
 #define TCSETS2         _IOW('T', 13, struct termios2)
 #define TCSETSW2        _IOW('T', 14, struct termios2)
 #define TCSETSF2        _IOW('T', 15, struct termios2)
+#define TIOCGDEV        _IOR('T',0x32, unsigned int) /* Get primary device node of /dev/console */
+#define TIOCVHANGUP     _IO('T', 0x37)
 
 /* Note that all the ioctls that are not available in Linux have a 
  * double underscore on the front to: a) avoid some programs to
diff --git a/arch/sparc/include/asm/irq_32.h b/arch/sparc/include/asm/irq_32.h
index cbf4801deaaf..2ae3acaeb1b3 100644
--- a/arch/sparc/include/asm/irq_32.h
+++ b/arch/sparc/include/asm/irq_32.h
@@ -6,11 +6,18 @@
 #ifndef _SPARC_IRQ_H
 #define _SPARC_IRQ_H
 
-#define NR_IRQS    16
+/* Allocated number of logical irq numbers.
+ * sun4d boxes (ss2000e) should be OK with ~32.
+ * Be on the safe side and make room for 64
+ */
+#define NR_IRQS    64
 
 #include <linux/interrupt.h>
 
 #define irq_canonicalize(irq)   (irq)
 
 extern void __init init_IRQ(void);
+
+#define NO_IRQ          0xffffffff
+
 #endif
diff --git a/arch/sparc/include/asm/irq_64.h b/arch/sparc/include/asm/irq_64.h
index a0b443cb3c1f..16dcae6d56e7 100644
--- a/arch/sparc/include/asm/irq_64.h
+++ b/arch/sparc/include/asm/irq_64.h
@@ -33,34 +33,34 @@
 
 /* The largest number of unique interrupt sources we support.
  * If this needs to ever be larger than 255, you need to change
- * the type of ino_bucket->virt_irq as appropriate.
+ * the type of ino_bucket->irq as appropriate.
  *
- * ino_bucket->virt_irq allocation is made during {sun4v_,}build_irq().
+ * ino_bucket->irq allocation is made during {sun4v_,}build_irq().
  */
 #define NR_IRQS    255
 
-extern void irq_install_pre_handler(int virt_irq,
+extern void irq_install_pre_handler(int irq,
                                     void (*func)(unsigned int, void *, void *),
                                     void *arg1, void *arg2);
 #define irq_canonicalize(irq)   (irq)
 extern unsigned int build_irq(int inofixup, unsigned long iclr, unsigned long imap);
 extern unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino);
 extern unsigned int sun4v_build_virq(u32 devhandle, unsigned int devino);
-extern unsigned int sun4v_build_msi(u32 devhandle, unsigned int *virt_irq_p,
+extern unsigned int sun4v_build_msi(u32 devhandle, unsigned int *irq_p,
                                     unsigned int msi_devino_start,
                                     unsigned int msi_devino_end);
-extern void sun4v_destroy_msi(unsigned int virt_irq);
-extern unsigned int sun4u_build_msi(u32 portid, unsigned int *virt_irq_p,
+extern void sun4v_destroy_msi(unsigned int irq);
+extern unsigned int sun4u_build_msi(u32 portid, unsigned int *irq_p,
                                     unsigned int msi_devino_start,
                                     unsigned int msi_devino_end,
                                     unsigned long imap_base,
                                     unsigned long iclr_base);
-extern void sun4u_destroy_msi(unsigned int virt_irq);
+extern void sun4u_destroy_msi(unsigned int irq);
 
-extern unsigned char virt_irq_alloc(unsigned int dev_handle,
+extern unsigned char irq_alloc(unsigned int dev_handle,
                                     unsigned int dev_ino);
 #ifdef CONFIG_PCI_MSI
-extern void virt_irq_free(unsigned int virt_irq);
+extern void irq_free(unsigned int irq);
 #endif
 
 extern void __init init_IRQ(void);
@@ -97,4 +97,6 @@ extern void *softirq_stack[NR_CPUS];
 #define __ARCH_HAS_DO_SOFTIRQ
 #define ARCH_HAS_NMI_WATCHDOG
 
+#define NO_IRQ          0xffffffff
+
 #endif
diff --git a/arch/sparc/include/asm/irqflags_32.h b/arch/sparc/include/asm/irqflags_32.h
index 0fca9d97d44f..14848909e0de 100644
--- a/arch/sparc/include/asm/irqflags_32.h
+++ b/arch/sparc/include/asm/irqflags_32.h
@@ -5,33 +5,40 @@
  *
  * This file gets included from lowlevel asm headers too, to provide
  * wrapped versions of the local_irq_*() APIs, based on the
- * raw_local_irq_*() functions from the lowlevel headers.
+ * arch_local_irq_*() functions from the lowlevel headers.
  */
 #ifndef _ASM_IRQFLAGS_H
 #define _ASM_IRQFLAGS_H
 
 #ifndef __ASSEMBLY__
 
-extern void raw_local_irq_restore(unsigned long);
-extern unsigned long __raw_local_irq_save(void);
-extern void raw_local_irq_enable(void);
+#include <linux/types.h>
 
-static inline unsigned long getipl(void)
+extern void arch_local_irq_restore(unsigned long);
+extern unsigned long arch_local_irq_save(void);
+extern void arch_local_irq_enable(void);
+
+static inline notrace unsigned long arch_local_save_flags(void)
 {
-        unsigned long retval;
+        unsigned long flags;
+
+        asm volatile("rd        %%psr, %0" : "=r" (flags));
+        return flags;
+}
 
-        __asm__ __volatile__("rd        %%psr, %0" : "=r" (retval));
-        return retval;
+static inline notrace void arch_local_irq_disable(void)
+{
+        arch_local_irq_save();
 }
 
-#define raw_local_save_flags(flags) ((flags) = getipl())
-#define raw_local_irq_save(flags)   ((flags) = __raw_local_irq_save())
-#define raw_local_irq_disable()     ((void) __raw_local_irq_save())
-#define raw_irqs_disabled()         ((getipl() & PSR_PIL) != 0)
+static inline notrace bool arch_irqs_disabled_flags(unsigned long flags)
+{
+        return (flags & PSR_PIL) != 0;
+}
 
-static inline int raw_irqs_disabled_flags(unsigned long flags)
+static inline notrace bool arch_irqs_disabled(void)
 {
-        return ((flags & PSR_PIL) != 0);
+        return arch_irqs_disabled_flags(arch_local_save_flags());
 }
 
 #endif /* (__ASSEMBLY__) */
diff --git a/arch/sparc/include/asm/irqflags_64.h b/arch/sparc/include/asm/irqflags_64.h
index bfa1ea45b4cd..23cd27f6beb4 100644
--- a/arch/sparc/include/asm/irqflags_64.h
+++ b/arch/sparc/include/asm/irqflags_64.h
@@ -5,7 +5,7 @@
  *
  * This file gets included from lowlevel asm headers too, to provide
  * wrapped versions of the local_irq_*() APIs, based on the
- * raw_local_irq_*() functions from the lowlevel headers.
+ * arch_local_irq_*() functions from the lowlevel headers.
  */
 #ifndef _ASM_IRQFLAGS_H
 #define _ASM_IRQFLAGS_H
@@ -14,7 +14,7 @@
 
 #ifndef __ASSEMBLY__
 
-static inline unsigned long __raw_local_save_flags(void)
+static inline notrace unsigned long arch_local_save_flags(void)
 {
         unsigned long flags;
 
@@ -26,10 +26,7 @@ static inline unsigned long __raw_local_save_flags(void)
         return flags;
 }
 
-#define raw_local_save_flags(flags) \
-                do { (flags) = __raw_local_save_flags(); } while (0)
-
-static inline void raw_local_irq_restore(unsigned long flags)
+static inline notrace void arch_local_irq_restore(unsigned long flags)
 {
         __asm__ __volatile__(
                 "wrpr   %0, %%pil"
@@ -39,7 +36,7 @@ static inline void raw_local_irq_restore(unsigned long flags)
         );
 }
 
-static inline void raw_local_irq_disable(void)
+static inline notrace void arch_local_irq_disable(void)
 {
         __asm__ __volatile__(
                 "wrpr   %0, %%pil"
@@ -49,7 +46,7 @@ static inline void raw_local_irq_disable(void)
         );
 }
 
-static inline void raw_local_irq_enable(void)
+static inline notrace void arch_local_irq_enable(void)
 {
         __asm__ __volatile__(
                 "wrpr   0, %%pil"
@@ -59,22 +56,17 @@ static inline void raw_local_irq_enable(void)
         );
 }
 
-static inline int raw_irqs_disabled_flags(unsigned long flags)
+static inline notrace int arch_irqs_disabled_flags(unsigned long flags)
 {
         return (flags > 0);
 }
 
-static inline int raw_irqs_disabled(void)
+static inline notrace int arch_irqs_disabled(void)
 {
-        unsigned long flags = __raw_local_save_flags();
-
-        return raw_irqs_disabled_flags(flags);
+        return arch_irqs_disabled_flags(arch_local_save_flags());
 }
 
-/*
- * For spinlocks, etc:
- */
-static inline unsigned long __raw_local_irq_save(void)
+static inline notrace unsigned long arch_local_irq_save(void)
 {
         unsigned long flags, tmp;
 
@@ -100,9 +92,6 @@ static inline unsigned long __raw_local_irq_save(void)
         return flags;
 }
 
-#define raw_local_irq_save(flags) \
-                do { (flags) = __raw_local_irq_save(); } while (0)
-
 #endif /* (__ASSEMBLY__) */
 
 #endif /* !(_ASM_IRQFLAGS_H) */
diff --git a/arch/sparc/include/asm/jump_label.h b/arch/sparc/include/asm/jump_label.h
new file mode 100644
index 000000000000..fc73a82366f8
--- /dev/null
+++ b/arch/sparc/include/asm/jump_label.h
@@ -0,0 +1,35 @@
+#ifndef _ASM_SPARC_JUMP_LABEL_H
+#define _ASM_SPARC_JUMP_LABEL_H
+
+#ifdef __KERNEL__
+
+#include <linux/types.h>
+
+#define JUMP_LABEL_NOP_SIZE 4
+
+static __always_inline bool arch_static_branch(struct jump_label_key *key)
+{
+                asm goto("1:\n\t"
+                         "nop\n\t"
+                         "nop\n\t"
+                         ".pushsection __jump_table,  \"aw\"\n\t"
+                         ".align 4\n\t"
+                         ".word 1b, %l[l_yes], %c0\n\t"
+                         ".popsection \n\t"
+                         : :  "i" (key) : : l_yes);
+        return false;
+l_yes:
+        return true;
+}
+
+#endif /* __KERNEL__ */
+
+typedef u32 jump_label_t;
+
+struct jump_entry {
+        jump_label_t code;
+        jump_label_t target;
+        jump_label_t key;
+};
+
+#endif
diff --git a/arch/sparc/include/asm/leon.h b/arch/sparc/include/asm/leon.h
index 3ea5964c43b4..a4e457f003ed 100644
--- a/arch/sparc/include/asm/leon.h
+++ b/arch/sparc/include/asm/leon.h
@@ -52,29 +52,6 @@
 #define LEON_DIAGF_VALID        0x2000
 #define LEON_DIAGF_VALID_SHIFT  13
 
-/*
- *  Interrupt Sources
- *
- *  The interrupt source numbers directly map to the trap type and to
- *  the bits used in the Interrupt Clear, Interrupt Force, Interrupt Mask,
- *  and the Interrupt Pending Registers.
- */
-#define LEON_INTERRUPT_CORRECTABLE_MEMORY_ERROR 1
-#define LEON_INTERRUPT_UART_1_RX_TX             2
-#define LEON_INTERRUPT_UART_0_RX_TX             3
-#define LEON_INTERRUPT_EXTERNAL_0               4
-#define LEON_INTERRUPT_EXTERNAL_1               5
-#define LEON_INTERRUPT_EXTERNAL_2               6
-#define LEON_INTERRUPT_EXTERNAL_3               7
-#define LEON_INTERRUPT_TIMER1                   8
-#define LEON_INTERRUPT_TIMER2                   9
-#define LEON_INTERRUPT_EMPTY1                   10
-#define LEON_INTERRUPT_EMPTY2                   11
-#define LEON_INTERRUPT_OPEN_ETH                 12
-#define LEON_INTERRUPT_EMPTY4                   13
-#define LEON_INTERRUPT_EMPTY5                   14
-#define LEON_INTERRUPT_EMPTY6                   15
-
 /* irq masks */
 #define LEON_HARD_INT(x)        (1 << (x))      /* irq 0-15 */
 #define LEON_IRQMASK_R          0x0000fffe      /* bit 15- 1 of lregs.irqmask */
@@ -183,7 +160,6 @@ static inline void leon_srmmu_enabletlb(void)
 /* macro access for leon_readnobuffer_reg() */
 #define LEON_BYPASSCACHE_LOAD_VA(x) leon_readnobuffer_reg((unsigned long)(x))
 
-extern void sparc_leon_eirq_register(int eirq);
 extern void leon_init(void);
 extern void leon_switch_mm(void);
 extern void leon_init_IRQ(void);
@@ -224,11 +200,23 @@ static inline void sparc_leon3_disable_cache(void)
                           "sta %%l2, [%%g0] 2\n\t" : : : "l1", "l2");
 };
 
+static inline unsigned long sparc_leon3_asr17(void)
+{
+        u32 asr17;
+        __asm__ __volatile__ ("rd %%asr17, %0\n\t" : "=r"(asr17));
+        return asr17;
+};
+
+static inline int sparc_leon3_cpuid(void)
+{
+        return sparc_leon3_asr17() >> 28;
+}
+
 #endif /*!__ASSEMBLY__*/
 
 #ifdef CONFIG_SMP
-# define LEON3_IRQ_RESCHEDULE           13
-# define LEON3_IRQ_TICKER               (leon_percpu_timer_dev[0].irq)
+# define LEON3_IRQ_IPI_DEFAULT          13
+# define LEON3_IRQ_TICKER               (leon3_ticker_irq)
 # define LEON3_IRQ_CROSS_CALL           15
 #endif
 
@@ -327,9 +315,12 @@ struct leon2_cacheregs {
 #include <linux/interrupt.h>
 
 struct device_node;
-extern int sparc_leon_eirq_get(int eirq, int cpu);
-extern irqreturn_t sparc_leon_eirq_isr(int dummy, void *dev_id);
-extern void sparc_leon_eirq_register(int eirq);
+extern unsigned int leon_build_device_irq(unsigned int real_irq,
+                                           irq_flow_handler_t flow_handler,
+                                           const char *name, int do_ack);
+extern void leon_update_virq_handling(unsigned int virq,
+                              irq_flow_handler_t flow_handler,
+                              const char *name, int do_ack);
 extern void leon_clear_clock_irq(void);
 extern void leon_load_profile_irq(int cpu, unsigned int limit);
 extern void leon_init_timers(irq_handler_t counter_fn);
@@ -346,6 +337,7 @@ extern void leon3_getCacheRegs(struct leon3_cacheregs *regs);
 extern int leon_flush_needed(void);
 extern void leon_switch_mm(void);
 extern int srmmu_swprobe_trace;
+extern int leon3_ticker_irq;
 
 #ifdef CONFIG_SMP
 extern int leon_smp_nrcpus(void);
@@ -354,20 +346,19 @@ extern void leon_smp_done(void);
 extern void leon_boot_cpus(void);
 extern int leon_boot_one_cpu(int i);
 void leon_init_smp(void);
-extern void cpu_probe(void);
 extern void cpu_idle(void);
 extern void init_IRQ(void);
 extern void cpu_panic(void);
 extern int __leon_processor_id(void);
 void leon_enable_irq_cpu(unsigned int irq_nr, unsigned int cpu);
+extern irqreturn_t leon_percpu_timer_interrupt(int irq, void *unused);
 
-extern unsigned int real_irq_entry[], smpleon_ticker[];
+extern unsigned int real_irq_entry[];
+extern unsigned int smpleon_ipi[];
 extern unsigned int patchme_maybe_smp_msg[];
-extern unsigned long trapbase_cpu1[];
-extern unsigned long trapbase_cpu2[];
-extern unsigned long trapbase_cpu3[];
 extern unsigned int t_nmi[], linux_trap_ipi15_leon[];
 extern unsigned int linux_trap_ipi15_sun4m[];
+extern int leon_ipi_irq;
 
 #endif /* CONFIG_SMP */
 
diff --git a/arch/sparc/include/asm/leon_amba.h b/arch/sparc/include/asm/leon_amba.h
index 618e88821795..e50f326e71bd 100644
--- a/arch/sparc/include/asm/leon_amba.h
+++ b/arch/sparc/include/asm/leon_amba.h
@@ -100,9 +100,8 @@ struct leon3_irqctrl_regs_map {
         u32 mpbroadcast;
         u32 notused02;
         u32 notused03;
-        u32 notused10;
-        u32 notused11;
-        u32 notused12;
+        u32 ampctrl;
+        u32 icsel[2];
         u32 notused13;
         u32 notused20;
         u32 notused21;
@@ -112,6 +111,7 @@ struct leon3_irqctrl_regs_map {
         u32 force[16];
         /* Extended IRQ registers */
         u32 intid[16];  /* 0xc0 */
+        u32 unused[(0x1000-0x100)/4];
 };
 
 struct leon3_apbuart_regs_map {
@@ -180,6 +180,7 @@ struct amba_ahb_device {
 struct device_node;
 void _amba_init(struct device_node *dp, struct device_node ***nextp);
 
+extern unsigned long amba_system_id;
 extern struct leon3_irqctrl_regs_map *leon3_irqctrl_regs;
 extern struct leon3_gptimer_regs_map *leon3_gptimer_regs;
 extern struct amba_apb_device leon_percpu_timer_dev[16];
@@ -254,6 +255,11 @@ extern unsigned int sparc_leon_eirq;
 #define GAISLER_L2C      0xffe  /* internal device: leon2compat */
 #define GAISLER_PLUGPLAY 0xfff  /* internal device: plug & play configarea */
 
+/* Chip IDs */
+#define AEROFLEX_UT699    0x0699
+#define LEON4_NEXTREME1   0x0102
+#define GAISLER_GR712RC   0x0712
+
 #define amba_vendor(x) (((x) >> 24) & 0xff)
 
 #define amba_device(x) (((x) >> 12) & 0xfff)
diff --git a/arch/sparc/include/asm/leon_pci.h b/arch/sparc/include/asm/leon_pci.h
new file mode 100644
index 000000000000..42b4b31a82fe
--- /dev/null
+++ b/arch/sparc/include/asm/leon_pci.h
@@ -0,0 +1,21 @@
+/*
+ * asm/leon_pci.h
+ *
+ * Copyright (C) 2011 Aeroflex Gaisler AB, Daniel Hellstrom
+ */
+
+#ifndef _ASM_LEON_PCI_H_
+#define _ASM_LEON_PCI_H_
+
+/* PCI related definitions */
+struct leon_pci_info {
+        struct pci_ops *ops;
+        struct resource io_space;
+        struct resource mem_space;
+        int (*map_irq)(struct pci_dev *dev, u8 slot, u8 pin);
+};
+
+extern void leon_pci_init(struct platform_device *ofdev,
+                                struct leon_pci_info *info);
+
+#endif /* _ASM_LEON_PCI_H_ */
diff --git a/arch/sparc/include/asm/memblock.h b/arch/sparc/include/asm/memblock.h
index f12af880649b..c67b047ef85e 100644
--- a/arch/sparc/include/asm/memblock.h
+++ b/arch/sparc/include/asm/memblock.h
@@ -5,6 +5,4 @@
 
 #define MEMBLOCK_DBG(fmt...) prom_printf(fmt)
 
-#define MEMBLOCK_REAL_LIMIT     0
-
 #endif /* !(_SPARC64_MEMBLOCK_H) */
diff --git a/arch/sparc/include/asm/mmu_32.h b/arch/sparc/include/asm/mmu_32.h
index ccd36d26615a..6f056e535cf8 100644
--- a/arch/sparc/include/asm/mmu_32.h
+++ b/arch/sparc/include/asm/mmu_32.h
@@ -4,4 +4,7 @@
 /* Default "unsigned long" context */
 typedef unsigned long mm_context_t;
 
+/* mm/srmmu.c */
+extern ctxd_t *srmmu_ctx_table_phys;
+
 #endif
diff --git a/arch/sparc/include/asm/mmzone.h b/arch/sparc/include/asm/mmzone.h
index e8c648741ed4..99d9b9f577bf 100644
--- a/arch/sparc/include/asm/mmzone.h
+++ b/arch/sparc/include/asm/mmzone.h
@@ -8,8 +8,6 @@
 extern struct pglist_data *node_data[];
 
 #define NODE_DATA(nid)          (node_data[nid])
-#define node_start_pfn(nid)     (NODE_DATA(nid)->node_start_pfn)
-#define node_end_pfn(nid)       (NODE_DATA(nid)->node_end_pfn)
 
 extern int numa_cpu_lookup_table[];
 extern cpumask_t numa_cpumask_lookup_table[];
diff --git a/arch/sparc/include/asm/ns87303.h b/arch/sparc/include/asm/ns87303.h
index 686defe6aaa0..af755483e17d 100644
--- a/arch/sparc/include/asm/ns87303.h
+++ b/arch/sparc/include/asm/ns87303.h
@@ -37,7 +37,7 @@
 /* Power and Test Register (PTR) bits */
 #define PTR_LPTB_IRQ7   0x08
 #define PTR_LEVEL_IRQ   0x80    /* When not ECP/EPP: Use level IRQ           */
-#define PTR_LPT_REG_DIR 0x80    /* When ECP/EPP: LPT CTR controlls direction */
+#define PTR_LPT_REG_DIR 0x80    /* When ECP/EPP: LPT CTR controls direction */
                                 /*               of the parallel port        */
 
 /* Function Control Register (FCR) bits */
diff --git a/arch/sparc/include/asm/openprom.h b/arch/sparc/include/asm/openprom.h
index 963e1a45c35f..47eaafad15ce 100644
--- a/arch/sparc/include/asm/openprom.h
+++ b/arch/sparc/include/asm/openprom.h
@@ -11,6 +11,8 @@
 #define LINUX_OPPROM_MAGIC      0x10010407
 
 #ifndef __ASSEMBLY__
+#include <linux/of.h>
+
 /* V0 prom device operations. */
 struct linux_dev_v0_funcs {
         int (*v0_devopen)(char *device_str);
@@ -26,7 +28,7 @@ struct linux_dev_v0_funcs {
 
 /* V2 and later prom device operations. */
 struct linux_dev_v2_funcs {
-        int (*v2_inst2pkg)(int d);      /* Convert ihandle to phandle */
+        phandle (*v2_inst2pkg)(int d);  /* Convert ihandle to phandle */
         char * (*v2_dumb_mem_alloc)(char *va, unsigned sz);
         void (*v2_dumb_mem_free)(char *va, unsigned sz);
 
@@ -37,7 +39,7 @@ struct linux_dev_v2_funcs {
         int (*v2_dev_open)(char *devpath);
         void (*v2_dev_close)(int d);
         int (*v2_dev_read)(int d, char *buf, int nbytes);
-        int (*v2_dev_write)(int d, char *buf, int nbytes);
+        int (*v2_dev_write)(int d, const char *buf, int nbytes);
         int (*v2_dev_seek)(int d, int hi, int lo);
 
         /* Never issued (multistage load support) */
@@ -168,12 +170,12 @@ struct linux_romvec {
 
 /* Routines for traversing the prom device tree. */
 struct linux_nodeops {
-        int (*no_nextnode)(int node);
-        int (*no_child)(int node);
-        int (*no_proplen)(int node, const char *name);
-        int (*no_getprop)(int node, const char *name, char *val);
-        int (*no_setprop)(int node, const char *name, char *val, int len);
-        char * (*no_nextprop)(int node, char *name);
+        phandle (*no_nextnode)(phandle node);
+        phandle (*no_child)(phandle node);
+        int (*no_proplen)(phandle node, const char *name);
+        int (*no_getprop)(phandle node, const char *name, char *val);
+        int (*no_setprop)(phandle node, const char *name, char *val, int len);
+        char * (*no_nextprop)(phandle node, char *name);
 };
 
 /* More fun PROM structures for device probing. */
diff --git a/arch/sparc/include/asm/oplib_32.h b/arch/sparc/include/asm/oplib_32.h
index 33e31ce6b31f..71e5e9aeb67e 100644
--- a/arch/sparc/include/asm/oplib_32.h
+++ b/arch/sparc/include/asm/oplib_32.h
@@ -30,7 +30,7 @@ extern unsigned int prom_rev, prom_prev;
 /* Root node of the prom device tree, this stays constant after
  * initialization is complete.
  */
-extern int prom_root_node;
+extern phandle prom_root_node;
 
 /* Pointer to prom structure containing the device tree traversal
  * and usage utility functions.  Only prom-lib should use these,
@@ -48,37 +48,6 @@ extern void prom_init(struct linux_romvec *rom_ptr);
 /* Boot argument acquisition, returns the boot command line string. */
 extern char *prom_getbootargs(void);
 
-/* Device utilities. */
-
-/* Map and unmap devices in IO space at virtual addresses. Note that the
- * virtual address you pass is a request and the prom may put your mappings
- * somewhere else, so check your return value as that is where your new
- * mappings really are!
- *
- * Another note, these are only available on V2 or higher proms!
- */
-extern char *prom_mapio(char *virt_hint, int io_space, unsigned int phys_addr, unsigned int num_bytes);
-extern void prom_unmapio(char *virt_addr, unsigned int num_bytes);
-
-/* Device operations. */
-
-/* Open the device described by the passed string.  Note, that the format
- * of the string is different on V0 vs. V2->higher proms.  The caller must
- * know what he/she is doing!  Returns the device descriptor, an int.
- */
-extern int prom_devopen(char *device_string);
-
-/* Close a previously opened device described by the passed integer
- * descriptor.
- */
-extern int prom_devclose(int device_handle);
-
-/* Do a seek operation on the device described by the passed integer
- * descriptor.
- */
-extern void prom_seek(int device_handle, unsigned int seek_hival,
-                      unsigned int seek_lowval);
-
 /* Miscellaneous routines, don't really fit in any category per se. */
 
 /* Reboot the machine with the command line passed. */
@@ -95,7 +64,7 @@ extern void prom_cmdline(void);
 /* Enter the prom, with no chance of continuation for the stand-alone
  * which calls this.
  */
-extern void prom_halt(void) __attribute__ ((noreturn));
+extern void __noreturn prom_halt(void);
 
 /* Set the PROM 'sync' callback function to the passed function pointer.
  * When the user gives the 'sync' command at the prom prompt while the
@@ -121,19 +90,8 @@ extern int prom_getrev(void);
 /* Get the prom firmware revision. */
 extern int prom_getprev(void);
 
-/* Character operations to/from the console.... */
-
-/* Non-blocking get character from console. */
-extern int prom_nbgetchar(void);
-
-/* Non-blocking put character to console. */
-extern int prom_nbputchar(char character);
-
-/* Blocking get character from console. */
-extern char prom_getchar(void);
-
-/* Blocking put character to console. */
-extern void prom_putchar(char character);
+/* Write a buffer of characters to the console. */
+extern void prom_console_write_buf(const char *buf, int len);
 
 /* Prom's internal routines, don't use in kernel/boot code. */
 extern void prom_printf(const char *fmt, ...);
@@ -147,25 +105,6 @@ extern void prom_write(const char *buf, unsigned int len);
 extern int prom_startcpu(int cpunode, struct linux_prom_registers *context_table,
                          int context, char *program_counter);
 
-/* Stop the CPU with the passed device tree node. */
-extern int prom_stopcpu(int cpunode);
-
-/* Idle the CPU with the passed device tree node. */
-extern int prom_idlecpu(int cpunode);
-
-/* Re-Start the CPU with the passed device tree node. */
-extern int prom_restartcpu(int cpunode);
-
-/* PROM memory allocation facilities... */
-
-/* Allocated at possibly the given virtual address a chunk of the
- * indicated size.
- */
-extern char *prom_alloc(char *virt_hint, unsigned int size);
-
-/* Free a previously allocated chunk. */
-extern void prom_free(char *virt_addr, unsigned int size);
-
 /* Sun4/sun4c specific memory-management startup hook. */
 
 /* Map the passed segment in the given context at the passed
@@ -174,72 +113,62 @@ extern void prom_free(char *virt_addr, unsigned int size);
 extern void prom_putsegment(int context, unsigned long virt_addr,
                             int physical_segment);
 
+/* Initialize the memory lists based upon the prom version. */
+void prom_meminit(void);
 
 /* PROM device tree traversal functions... */
 
 /* Get the child node of the given node, or zero if no child exists. */
-extern int prom_getchild(int parent_node);
+extern phandle prom_getchild(phandle parent_node);
 
 /* Get the next sibling node of the given node, or zero if no further
  * siblings exist.
  */
-extern int prom_getsibling(int node);
+extern phandle prom_getsibling(phandle node);
 
 /* Get the length, at the passed node, of the given property type.
  * Returns -1 on error (ie. no such property at this node).
  */
-extern int prom_getproplen(int thisnode, const char *property);
+extern int prom_getproplen(phandle thisnode, const char *property);
 
 /* Fetch the requested property using the given buffer.  Returns
  * the number of bytes the prom put into your buffer or -1 on error.
  */
-extern int __must_check prom_getproperty(int thisnode, const char *property,
+extern int __must_check prom_getproperty(phandle thisnode, const char *property,
                                          char *prop_buffer, int propbuf_size);
 
 /* Acquire an integer property. */
-extern int prom_getint(int node, char *property);
+extern int prom_getint(phandle node, char *property);
 
 /* Acquire an integer property, with a default value. */
-extern int prom_getintdefault(int node, char *property, int defval);
+extern int prom_getintdefault(phandle node, char *property, int defval);
 
 /* Acquire a boolean property, 0=FALSE 1=TRUE. */
-extern int prom_getbool(int node, char *prop);
+extern int prom_getbool(phandle node, char *prop);
 
 /* Acquire a string property, null string on error. */
-extern void prom_getstring(int node, char *prop, char *buf, int bufsize);
-
-/* Does the passed node have the given "name"? YES=1 NO=0 */
-extern int prom_nodematch(int thisnode, char *name);
+extern void prom_getstring(phandle node, char *prop, char *buf, int bufsize);
 
 /* Search all siblings starting at the passed node for "name" matching
  * the given string.  Returns the node on success, zero on failure.
  */
-extern int prom_searchsiblings(int node_start, char *name);
-
-/* Return the first property type, as a string, for the given node.
- * Returns a null string on error.
- */
-extern char *prom_firstprop(int node, char *buffer);
+extern phandle prom_searchsiblings(phandle node_start, char *name);
 
 /* Returns the next property after the passed property for the given
  * node.  Returns null string on failure.
  */
-extern char *prom_nextprop(int node, char *prev_property, char *buffer);
+extern char *prom_nextprop(phandle node, char *prev_property, char *buffer);
 
 /* Returns phandle of the path specified */
-extern int prom_finddevice(char *name);
-
-/* Returns 1 if the specified node has given property. */
-extern int prom_node_has_property(int node, char *property);
+extern phandle prom_finddevice(char *name);
 
 /* Set the indicated property at the given node with the passed value.
  * Returns the number of bytes of your value that the prom took.
  */
-extern int prom_setprop(int node, const char *prop_name, char *prop_value,
+extern int prom_setprop(phandle node, const char *prop_name, char *prop_value,
                         int value_size);
 
-extern int prom_pathtoinode(char *path);
-extern int prom_inst2pkg(int);
+extern phandle prom_inst2pkg(int);
 
 /* Dorking with Bus ranges... */
 
@@ -247,13 +176,15 @@ extern int prom_inst2pkg(int);
 extern void prom_apply_obio_ranges(struct linux_prom_registers *obioregs, int nregs);
 
 /* Apply ranges of any prom node (and optionally parent node as well) to registers. */
-extern void prom_apply_generic_ranges(int node, int parent,
+extern void prom_apply_generic_ranges(phandle node, phandle parent,
                                       struct linux_prom_registers *sbusregs, int nregs);
 
+void prom_ranges_init(void);
+
 /* CPU probing helpers.  */
-int cpu_find_by_instance(int instance, int *prom_node, int *mid);
-int cpu_find_by_mid(int mid, int *prom_node);
-int cpu_get_hwmid(int prom_node);
+int cpu_find_by_instance(int instance, phandle *prom_node, int *mid);
+int cpu_find_by_mid(int mid, phandle *prom_node);
+int cpu_get_hwmid(phandle prom_node);
 
 extern spinlock_t prom_lock;
 
diff --git a/arch/sparc/include/asm/oplib_64.h b/arch/sparc/include/asm/oplib_64.h
index 3e0b2d62303d..97a90475c314 100644
--- a/arch/sparc/include/asm/oplib_64.h
+++ b/arch/sparc/include/asm/oplib_64.h
@@ -16,15 +16,15 @@ extern char prom_version[];
 /* Root node of the prom device tree, this stays constant after
  * initialization is complete.
  */
-extern int prom_root_node;
+extern phandle prom_root_node;
 
-/* PROM stdin and stdout */
-extern int prom_stdin, prom_stdout;
+/* PROM stdout */
+extern int prom_stdout;
 
 /* /chosen node of the prom device tree, this stays constant after
  * initialization is complete.
  */
-extern int prom_chosen_node;
+extern phandle prom_chosen_node;
 
 /* Helper values and strings in arch/sparc64/kernel/head.S */
 extern const char prom_peer_name[];
@@ -67,27 +67,6 @@ extern void prom_init(void *cif_handler, void *cif_stack);
 /* Boot argument acquisition, returns the boot command line string. */
 extern char *prom_getbootargs(void);
 
-/* Device utilities. */
-
-/* Device operations. */
-
-/* Open the device described by the passed string.  Note, that the format
- * of the string is different on V0 vs. V2->higher proms.  The caller must
- * know what he/she is doing!  Returns the device descriptor, an int.
- */
-extern int prom_devopen(const char *device_string);
-
-/* Close a previously opened device described by the passed integer
- * descriptor.
- */
-extern int prom_devclose(int device_handle);
-
-/* Do a seek operation on the device described by the passed integer
- * descriptor.
- */
-extern void prom_seek(int device_handle, unsigned int seek_hival,
-                      unsigned int seek_lowval);
-
 /* Miscellaneous routines, don't really fit in any category per se. */
 
 /* Reboot the machine with the command line passed. */
@@ -109,33 +88,14 @@ extern void prom_halt(void) __attribute__ ((noreturn));
 /* Halt and power-off the machine. */
 extern void prom_halt_power_off(void) __attribute__ ((noreturn));
 
-/* Set the PROM 'sync' callback function to the passed function pointer.
- * When the user gives the 'sync' command at the prom prompt while the
- * kernel is still active, the prom will call this routine.
- *
- */
-typedef int (*callback_func_t)(long *cmd);
-extern void prom_setcallback(callback_func_t func_ptr);
-
 /* Acquire the IDPROM of the root node in the prom device tree.  This
  * gets passed a buffer where you would like it stuffed.  The return value
  * is the format type of this idprom or 0xff on error.
  */
 extern unsigned char prom_get_idprom(char *idp_buffer, int idpbuf_size);
 
-/* Character operations to/from the console.... */
-
-/* Non-blocking get character from console. */
-extern int prom_nbgetchar(void);
-
-/* Non-blocking put character to console. */
-extern int prom_nbputchar(char character);
-
-/* Blocking get character from console. */
-extern char prom_getchar(void);
-
-/* Blocking put character to console. */
-extern void prom_putchar(char character);
+/* Write a buffer of characters to the console. */
+extern void prom_console_write_buf(const char *buf, int len);
 
 /* Prom's internal routines, don't use in kernel/boot code. */
 extern void prom_printf(const char *fmt, ...);
@@ -218,69 +178,68 @@ extern void prom_unmap(unsigned long size, unsigned long vaddr);
 /* PROM device tree traversal functions... */
 
 /* Get the child node of the given node, or zero if no child exists. */
-extern int prom_getchild(int parent_node);
+extern phandle prom_getchild(phandle parent_node);
 
 /* Get the next sibling node of the given node, or zero if no further
  * siblings exist.
  */
-extern int prom_getsibling(int node);
+extern phandle prom_getsibling(phandle node);
 
 /* Get the length, at the passed node, of the given property type.
  * Returns -1 on error (ie. no such property at this node).
  */
-extern int prom_getproplen(int thisnode, const char *property);
+extern int prom_getproplen(phandle thisnode, const char *property);
 
 /* Fetch the requested property using the given buffer.  Returns
  * the number of bytes the prom put into your buffer or -1 on error.
  */
-extern int prom_getproperty(int thisnode, const char *property,
+extern int prom_getproperty(phandle thisnode, const char *property,
                             char *prop_buffer, int propbuf_size);
 
 /* Acquire an integer property. */
-extern int prom_getint(int node, const char *property);
+extern int prom_getint(phandle node, const char *property);
 
 /* Acquire an integer property, with a default value. */
-extern int prom_getintdefault(int node, const char *property, int defval);
+extern int prom_getintdefault(phandle node, const char *property, int defval);
 
 /* Acquire a boolean property, 0=FALSE 1=TRUE. */
-extern int prom_getbool(int node, const char *prop);
+extern int prom_getbool(phandle node, const char *prop);
 
 /* Acquire a string property, null string on error. */
-extern void prom_getstring(int node, const char *prop, char *buf, int bufsize);
+extern void prom_getstring(phandle node, const char *prop, char *buf,
+                           int bufsize);
 
 /* Does the passed node have the given "name"? YES=1 NO=0 */
-extern int prom_nodematch(int thisnode, const char *name);
+extern int prom_nodematch(phandle thisnode, const char *name);
 
 /* Search all siblings starting at the passed node for "name" matching
  * the given string.  Returns the node on success, zero on failure.
  */
-extern int prom_searchsiblings(int node_start, const char *name);
+extern phandle prom_searchsiblings(phandle node_start, const char *name);
 
 /* Return the first property type, as a string, for the given node.
  * Returns a null string on error. Buffer should be at least 32B long.
  */
-extern char *prom_firstprop(int node, char *buffer);
+extern char *prom_firstprop(phandle node, char *buffer);
 
 /* Returns the next property after the passed property for the given
  * node.  Returns null string on failure. Buffer should be at least 32B long.
  */
-extern char *prom_nextprop(int node, const char *prev_property, char *buffer);
+extern char *prom_nextprop(phandle node, const char *prev_property, char *buf);
 
 /* Returns 1 if the specified node has given property. */
-extern int prom_node_has_property(int node, const char *property);
+extern int prom_node_has_property(phandle node, const char *property);
 
 /* Returns phandle of the path specified */
-extern int prom_finddevice(const char *name);
+extern phandle prom_finddevice(const char *name);
 
 /* Set the indicated property at the given node with the passed value.
  * Returns the number of bytes of your value that the prom took.
  */
-extern int prom_setprop(int node, const char *prop_name, char *prop_value,
+extern int prom_setprop(phandle node, const char *prop_name, char *prop_value,
                         int value_size);
 
-extern int prom_pathtoinode(const char *path);
-extern int prom_inst2pkg(int);
-extern int prom_service_exists(const char *service_name);
+extern phandle prom_inst2pkg(int);
 extern void prom_sun4v_guest_soft_state(void);
 
 extern int prom_ihandle2path(int handle, char *buffer, int bufsize);
diff --git a/arch/sparc/include/asm/parport.h b/arch/sparc/include/asm/parport.h
index aa4c82648d88..cb33608cc68f 100644
--- a/arch/sparc/include/asm/parport.h
+++ b/arch/sparc/include/asm/parport.h
@@ -103,7 +103,7 @@ static inline unsigned int get_dma_residue(unsigned int dmanr)
         return ebus_dma_residue(&sparc_ebus_dmas[dmanr].info);
 }
 
-static int __devinit ecpp_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit ecpp_probe(struct platform_device *op)
 {
         unsigned long base = op->resource[0].start;
         unsigned long config = op->resource[1].start;
@@ -235,7 +235,7 @@ static const struct of_device_id ecpp_match[] = {
         {},
 };
 
-static struct of_platform_driver ecpp_driver = {
+static struct platform_driver ecpp_driver = {
         .driver = {
                 .name = "ecpp",
                 .owner = THIS_MODULE,
@@ -247,7 +247,7 @@ static struct of_platform_driver ecpp_driver = {
 
 static int parport_pc_find_nonpci_ports(int autoirq, int autodma)
 {
-        return of_register_platform_driver(&ecpp_driver);
+        return platform_driver_register(&ecpp_driver);
 }
 
 #endif /* !(_ASM_SPARC64_PARPORT_H */
diff --git a/arch/sparc/include/asm/pci_32.h b/arch/sparc/include/asm/pci_32.h
index 332ac9ab36bc..862e3ce92b15 100644
--- a/arch/sparc/include/asm/pci_32.h
+++ b/arch/sparc/include/asm/pci_32.h
@@ -47,7 +47,31 @@ extern struct device_node *pci_device_to_OF_node(struct pci_dev *pdev);
 
 #endif /* __KERNEL__ */
 
+#ifndef CONFIG_LEON_PCI
 /* generic pci stuff */
 #include <asm-generic/pci.h>
+#else
+/*
+ * On LEON PCI Memory space is mapped 1:1 with physical address space.
+ *
+ * I/O space is located at low 64Kbytes in PCI I/O space. The I/O addresses
+ * are converted into CPU addresses to virtual addresses that are mapped with
+ * MMU to the PCI Host PCI I/O space window which are translated to the low
+ * 64Kbytes by the Host controller.
+ */
+
+extern void
+pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
+                        struct resource *res);
+
+extern void
+pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
+                        struct pci_bus_region *region);
+
+static inline int pci_get_legacy_ide_irq(struct pci_dev *dev, int channel)
+{
+        return PCI_IRQ_NONE;
+}
+#endif
 
 #endif /* __SPARC_PCI_H */
diff --git a/arch/sparc/include/asm/pci_64.h b/arch/sparc/include/asm/pci_64.h
index 5312782f0b5e..948b686ec089 100644
--- a/arch/sparc/include/asm/pci_64.h
+++ b/arch/sparc/include/asm/pci_64.h
@@ -38,7 +38,7 @@ static inline void pcibios_penalize_isa_irq(int irq, int active)
  * types on sparc64.  However, it requires that the device
  * can drive enough of the 64 bits.
  */
-#define PCI64_REQUIRED_MASK     (~(dma64_addr_t)0)
+#define PCI64_REQUIRED_MASK     (~(u64)0)
 #define PCI64_ADDR_BASE         0xfffc000000000000UL
 
 #ifdef CONFIG_PCI
diff --git a/arch/sparc/include/asm/pcic.h b/arch/sparc/include/asm/pcic.h
index f20ef562b265..6676cbcc8b6a 100644
--- a/arch/sparc/include/asm/pcic.h
+++ b/arch/sparc/include/asm/pcic.h
@@ -29,11 +29,17 @@ struct linux_pcic {
         int                     pcic_imdim;
 };
 
-extern int pcic_probe(void);
-/* Erm... MJ redefined pcibios_present() so that it does not work early. */
+#ifdef CONFIG_PCIC_PCI
 extern int pcic_present(void);
+extern int pcic_probe(void);
+extern void pci_time_init(void);
 extern void sun4m_pci_init_IRQ(void);
-
+#else
+static inline int pcic_present(void) { return 0; }
+static inline int pcic_probe(void) { return 0; }
+static inline void pci_time_init(void) {}
+static inline void sun4m_pci_init_IRQ(void) {}
+#endif
 #endif
 
 /* Size of PCI I/O space which we relocate. */
diff --git a/arch/sparc/include/asm/pcr.h b/arch/sparc/include/asm/pcr.h
index a2f5c61f924e..288d7beba051 100644
--- a/arch/sparc/include/asm/pcr.h
+++ b/arch/sparc/include/asm/pcr.h
@@ -31,7 +31,7 @@ extern unsigned int picl_shift;
 
 /* In order to commonize as much of the implementation as
  * possible, we use PICH as our counter.  Mostly this is
- * to accomodate Niagara-1 which can only count insn cycles
+ * to accommodate Niagara-1 which can only count insn cycles
  * in PICH.
  */
 static inline u64 picl_value(unsigned int nmi_hz)
@@ -43,4 +43,6 @@ static inline u64 picl_value(unsigned int nmi_hz)
 
 extern u64 pcr_enable;
 
+extern int pcr_arch_init(void);
+
 #endif /* __PCR_H */
diff --git a/arch/sparc/include/asm/perf_event.h b/arch/sparc/include/asm/perf_event.h
index 727af70646cb..4d3dbe3703e9 100644
--- a/arch/sparc/include/asm/perf_event.h
+++ b/arch/sparc/include/asm/perf_event.h
@@ -1,15 +1,9 @@
 #ifndef __ASM_SPARC_PERF_EVENT_H
 #define __ASM_SPARC_PERF_EVENT_H
 
-extern void set_perf_event_pending(void);
-
-#define PERF_EVENT_INDEX_OFFSET 0
-
 #ifdef CONFIG_PERF_EVENTS
 #include <asm/ptrace.h>
 
-extern void init_hw_perf_events(void);
-
 #define perf_arch_fetch_caller_regs(regs, ip)           \
 do {                                                    \
         unsigned long _pstate, _asi, _pil, _i7, _fp;    \
@@ -30,8 +24,6 @@ do {							\
         (regs)->u_regs[UREG_I6] = _fp;                  \
         (regs)->u_regs[UREG_I7] = _i7;                  \
 } while (0)
-#else
-static inline void init_hw_perf_events(void)    { }
 #endif
 
 #endif
diff --git a/arch/sparc/include/asm/pgalloc_64.h b/arch/sparc/include/asm/pgalloc_64.h
index 5bdfa2c6e400..4e5e0878144f 100644
--- a/arch/sparc/include/asm/pgalloc_64.h
+++ b/arch/sparc/include/asm/pgalloc_64.h
@@ -78,4 +78,7 @@ static inline void check_pgt_cache(void)
         quicklist_trim(0, NULL, 25, 16);
 }
 
+#define __pte_free_tlb(tlb, pte, addr)  pte_free((tlb)->mm, pte)
+#define __pmd_free_tlb(tlb, pmd, addr)  pmd_free((tlb)->mm, pmd)
+
 #endif /* _SPARC64_PGALLOC_H */
diff --git a/arch/sparc/include/asm/pgtable_32.h b/arch/sparc/include/asm/pgtable_32.h
index 0ece77f47753..5b31a8e89823 100644
--- a/arch/sparc/include/asm/pgtable_32.h
+++ b/arch/sparc/include/asm/pgtable_32.h
@@ -8,6 +8,8 @@
  *  Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  */
 
+#include <linux/const.h>
+
 #ifndef __ASSEMBLY__
 #include <asm-generic/4level-fixup.h>
 
@@ -304,10 +306,7 @@ BTFIXUPDEF_CALL(pte_t *, pte_offset_kernel, pmd_t *, unsigned long)
  * and sun4c is guaranteed to have no highmem anyway.
  */
 #define pte_offset_map(d, a)            pte_offset_kernel(d,a)
-#define pte_offset_map_nested(d, a)     pte_offset_kernel(d,a)
-
 #define pte_unmap(pte)          do{}while(0)
-#define pte_unmap_nested(pte)   do{}while(0)
 
 /* Certain architectures need to do special things when pte's
  * within a page table are directly modified.  Thus, the following
@@ -459,9 +458,9 @@ extern int io_remap_pfn_range(struct vm_area_struct *vma,
 
 #endif /* !(__ASSEMBLY__) */
 
-#define VMALLOC_START           0xfe600000
+#define VMALLOC_START           _AC(0xfe600000,UL)
 /* XXX Alter this when I get around to fixing sun4c - Anton */
-#define VMALLOC_END             0xffc00000
+#define VMALLOC_END             _AC(0xffc00000,UL)
 
 
 /* We provide our own get_unmapped_area to cope with VA holes for userland */
diff --git a/arch/sparc/include/asm/pgtable_64.h b/arch/sparc/include/asm/pgtable_64.h
index f5b5fa76c02d..1e03c5a6b4f7 100644
--- a/arch/sparc/include/asm/pgtable_64.h
+++ b/arch/sparc/include/asm/pgtable_64.h
@@ -652,14 +652,14 @@ static inline int pte_special(pte_t pte)
          ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1)))
 #define pte_offset_kernel               pte_index
 #define pte_offset_map                  pte_index
-#define pte_offset_map_nested           pte_index
 #define pte_unmap(pte)                  do { } while (0)
-#define pte_unmap_nested(pte)           do { } while (0)
 
 /* Actual page table PTE updates.  */
-extern void tlb_batch_add(struct mm_struct *mm, unsigned long vaddr, pte_t *ptep, pte_t orig);
+extern void tlb_batch_add(struct mm_struct *mm, unsigned long vaddr,
+                          pte_t *ptep, pte_t orig, int fullmm);
 
-static inline void set_pte_at(struct mm_struct *mm, unsigned long addr, pte_t *ptep, pte_t pte)
+static inline void __set_pte_at(struct mm_struct *mm, unsigned long addr,
+                             pte_t *ptep, pte_t pte, int fullmm)
 {
         pte_t orig = *ptep;
 
@@ -672,12 +672,19 @@ static inline void set_pte_at(struct mm_struct *mm, unsigned long addr, pte_t *p
          *             and SUN4V pte layout, so this inline test is fine.
          */
         if (likely(mm != &init_mm) && (pte_val(orig) & _PAGE_VALID))
-                tlb_batch_add(mm, addr, ptep, orig);
+                tlb_batch_add(mm, addr, ptep, orig, fullmm);
 }
 
+#define set_pte_at(mm,addr,ptep,pte)    \
+        __set_pte_at((mm), (addr), (ptep), (pte), 0)
+
 #define pte_clear(mm,addr,ptep)         \
         set_pte_at((mm), (addr), (ptep), __pte(0UL))
 
+#define __HAVE_ARCH_PTE_CLEAR_NOT_PRESENT_FULL
+#define pte_clear_not_present_full(mm,addr,ptep,fullmm) \
+        __set_pte_at((mm), (addr), (ptep), __pte(0UL), (fullmm))
+
 #ifdef DCACHE_ALIASING_POSSIBLE
 #define __HAVE_ARCH_MOVE_PTE
 #define move_pte(pte, prot, old_addr, new_addr)                         \
@@ -701,6 +708,9 @@ extern pmd_t swapper_low_pmd_dir[2048];
 extern void paging_init(void);
 extern unsigned long find_ecache_flush_span(unsigned long size);
 
+struct seq_file;
+extern void mmu_info(struct seq_file *);
+
 /* These do nothing with the way I have things setup. */
 #define mmu_lockarea(vaddr, len)                (vaddr)
 #define mmu_unlockarea(vaddr, len)              do { } while(0)
diff --git a/arch/sparc/include/asm/prom.h b/arch/sparc/include/asm/prom.h
index 291f12575edd..56bbaadef646 100644
--- a/arch/sparc/include/asm/prom.h
+++ b/arch/sparc/include/asm/prom.h
@@ -18,6 +18,7 @@
  * 2 of the License, or (at your option) any later version.
  */
 #include <linux/types.h>
+#include <linux/of_pdt.h>
 #include <linux/proc_fs.h>
 #include <linux/mutex.h>
 #include <asm/atomic.h>
@@ -67,8 +68,8 @@ extern struct device_node *of_console_device;
 extern char *of_console_path;
 extern char *of_console_options;
 
-extern void (*prom_build_more)(struct device_node *dp, struct device_node ***nextp);
-extern char *build_full_name(struct device_node *dp);
+extern void irq_trans_init(struct device_node *dp);
+extern char *build_path_component(struct device_node *dp);
 
 #endif /* __KERNEL__ */
 #endif /* _SPARC_PROM_H */
diff --git a/arch/sparc/include/asm/ptrace.h b/arch/sparc/include/asm/ptrace.h
index 30b0b797dc0c..b928b31424b1 100644
--- a/arch/sparc/include/asm/ptrace.h
+++ b/arch/sparc/include/asm/ptrace.h
@@ -33,7 +33,7 @@ struct pt_regs {
          * things like "in a system call" etc. for an arbitray
          * process.
          *
-         * The PT_REGS_MAGIC is choosen such that it can be
+         * The PT_REGS_MAGIC is chosen such that it can be
          * loaded completely using just a sethi instruction.
          */
         unsigned int magic;
@@ -205,6 +205,7 @@ do {	current_thread_info()->syscall_noerror = 1; \
 } while (0)
 #define user_mode(regs) (!((regs)->tstate & TSTATE_PRIV))
 #define instruction_pointer(regs) ((regs)->tpc)
+#define instruction_pointer_set(regs, val) ((regs)->tpc = (val))
 #define user_stack_pointer(regs) ((regs)->u_regs[UREG_FP])
 #define regs_return_value(regs) ((regs)->u_regs[UREG_I0])
 #ifdef CONFIG_SMP
diff --git a/arch/sparc/include/asm/rwsem.h b/arch/sparc/include/asm/rwsem.h
index a2b4302869bc..069bf4d663a1 100644
--- a/arch/sparc/include/asm/rwsem.h
+++ b/arch/sparc/include/asm/rwsem.h
@@ -13,53 +13,12 @@
 
 #ifdef __KERNEL__
 
-#include <linux/list.h>
-#include <linux/spinlock.h>
-
-struct rwsem_waiter;
-
-struct rw_semaphore {
-        signed long                     count;
 #define RWSEM_UNLOCKED_VALUE            0x00000000L
 #define RWSEM_ACTIVE_BIAS               0x00000001L
 #define RWSEM_ACTIVE_MASK               0xffffffffL
 #define RWSEM_WAITING_BIAS              (-RWSEM_ACTIVE_MASK-1)
 #define RWSEM_ACTIVE_READ_BIAS          RWSEM_ACTIVE_BIAS
 #define RWSEM_ACTIVE_WRITE_BIAS         (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
-        spinlock_t                      wait_lock;
-        struct list_head                wait_list;
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-        struct lockdep_map              dep_map;
-#endif
-};
-
-#ifdef CONFIG_DEBUG_LOCK_ALLOC
-# define __RWSEM_DEP_MAP_INIT(lockname) , .dep_map = { .name = #lockname }
-#else
-# define __RWSEM_DEP_MAP_INIT(lockname)
-#endif
-
-#define __RWSEM_INITIALIZER(name) \
-{ RWSEM_UNLOCKED_VALUE, __SPIN_LOCK_UNLOCKED((name).wait_lock), \
-  LIST_HEAD_INIT((name).wait_list) __RWSEM_DEP_MAP_INIT(name) }
-
-#define DECLARE_RWSEM(name) \
-        struct rw_semaphore name = __RWSEM_INITIALIZER(name)
-
-extern struct rw_semaphore *rwsem_down_read_failed(struct rw_semaphore *sem);
-extern struct rw_semaphore *rwsem_down_write_failed(struct rw_semaphore *sem);
-extern struct rw_semaphore *rwsem_wake(struct rw_semaphore *sem);
-extern struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *sem);
-
-extern void __init_rwsem(struct rw_semaphore *sem, const char *name,
-                         struct lock_class_key *key);
-
-#define init_rwsem(sem)                                         \
-do {                                                            \
-        static struct lock_class_key __key;                     \
-                                                                \
-        __init_rwsem((sem), #sem, &__key);                      \
-} while (0)
 
 /*
  * lock for reading
@@ -160,11 +119,6 @@ static inline long rwsem_atomic_update(long delta, struct rw_semaphore *sem)
         return atomic64_add_return(delta, (atomic64_t *)(&sem->count));
 }
 
-static inline int rwsem_is_locked(struct rw_semaphore *sem)
-{
-        return (sem->count != 0);
-}
-
 #endif /* __KERNEL__ */
 
 #endif /* _SPARC64_RWSEM_H */
diff --git a/arch/sparc/include/asm/setup.h b/arch/sparc/include/asm/setup.h
index 2643c62f4ac0..64718ba26434 100644
--- a/arch/sparc/include/asm/setup.h
+++ b/arch/sparc/include/asm/setup.h
@@ -11,4 +11,16 @@
 # define COMMAND_LINE_SIZE 256
 #endif
 
+#ifdef __KERNEL__
+
+#ifdef CONFIG_SPARC32
+/* The CPU that was used for booting
+ * Only sun4d + leon may have boot_cpu_id != 0
+ */
+extern unsigned char boot_cpu_id;
+extern unsigned char boot_cpu_id4;
+#endif
+
+#endif /* __KERNEL__ */
+
 #endif /* _SPARC_SETUP_H */
diff --git a/arch/sparc/include/asm/smp_32.h b/arch/sparc/include/asm/smp_32.h
index 841905c10215..093f10843ff2 100644
--- a/arch/sparc/include/asm/smp_32.h
+++ b/arch/sparc/include/asm/smp_32.h
@@ -29,10 +29,16 @@
  */
 
 extern unsigned char boot_cpu_id;
+extern volatile unsigned long cpu_callin_map[NR_CPUS];
+extern cpumask_t smp_commenced_mask;
+extern struct linux_prom_registers smp_penguin_ctable;
 
 typedef void (*smpfunc_t)(unsigned long, unsigned long, unsigned long,
                        unsigned long, unsigned long);
 
+void cpu_panic(void);
+extern void smp4m_irq_rotate(int cpu);
+
 /*
  *      General functions that each host system must provide.
  */
@@ -44,42 +50,38 @@ void smp_callin(void);
 void smp_boot_cpus(void);
 void smp_store_cpu_info(int);
 
+void smp_resched_interrupt(void);
+void smp_call_function_single_interrupt(void);
+void smp_call_function_interrupt(void);
+
 struct seq_file;
 void smp_bogo(struct seq_file *);
 void smp_info(struct seq_file *);
 
 BTFIXUPDEF_CALL(void, smp_cross_call, smpfunc_t, cpumask_t, unsigned long, unsigned long, unsigned long, unsigned long)
 BTFIXUPDEF_CALL(int, __hard_smp_processor_id, void)
+BTFIXUPDEF_CALL(void, smp_ipi_resched, int);
+BTFIXUPDEF_CALL(void, smp_ipi_single, int);
+BTFIXUPDEF_CALL(void, smp_ipi_mask_one, int);
 BTFIXUPDEF_BLACKBOX(hard_smp_processor_id)
 BTFIXUPDEF_BLACKBOX(load_current)
 
 #define smp_cross_call(func,mask,arg1,arg2,arg3,arg4) BTFIXUP_CALL(smp_cross_call)(func,mask,arg1,arg2,arg3,arg4)
 
-static inline void xc0(smpfunc_t func) { smp_cross_call(func, cpu_online_map, 0, 0, 0, 0); }
+static inline void xc0(smpfunc_t func) { smp_cross_call(func, *cpu_online_mask, 0, 0, 0, 0); }
 static inline void xc1(smpfunc_t func, unsigned long arg1)
-{ smp_cross_call(func, cpu_online_map, arg1, 0, 0, 0); }
+{ smp_cross_call(func, *cpu_online_mask, arg1, 0, 0, 0); }
 static inline void xc2(smpfunc_t func, unsigned long arg1, unsigned long arg2)
-{ smp_cross_call(func, cpu_online_map, arg1, arg2, 0, 0); }
+{ smp_cross_call(func, *cpu_online_mask, arg1, arg2, 0, 0); }
 static inline void xc3(smpfunc_t func, unsigned long arg1, unsigned long arg2,
                            unsigned long arg3)
-{ smp_cross_call(func, cpu_online_map, arg1, arg2, arg3, 0); }
+{ smp_cross_call(func, *cpu_online_mask, arg1, arg2, arg3, 0); }
 static inline void xc4(smpfunc_t func, unsigned long arg1, unsigned long arg2,
                            unsigned long arg3, unsigned long arg4)
-{ smp_cross_call(func, cpu_online_map, arg1, arg2, arg3, arg4); }
+{ smp_cross_call(func, *cpu_online_mask, arg1, arg2, arg3, arg4); }
 
-static inline int smp_call_function(void (*func)(void *info), void *info, int wait)
-{
-        xc1((smpfunc_t)func, (unsigned long)info);
-        return 0;
-}
-
-static inline int smp_call_function_single(int cpuid, void (*func) (void *info),
-                                           void *info, int wait)
-{
-        smp_cross_call((smpfunc_t)func, cpumask_of_cpu(cpuid),
-                       (unsigned long) info, 0, 0, 0);
-        return 0;
-}
+extern void arch_send_call_function_single_ipi(int cpu);
+extern void arch_send_call_function_ipi_mask(const struct cpumask *mask);
 
 static inline int cpu_logical_map(int cpu)
 {
@@ -129,6 +131,11 @@ static inline int hard_smp_processor_id(void)
                 __asm__ __volatile__("lda [%g0] ASI_M_VIKING_TMP1, %0\n\t"
                                      "nop; nop" :
                                      "=&r" (cpuid));
+                     - leon
+                __asm__ __volatile__(   "rd %asr17, %0\n\t"
+                                        "srl %0, 0x1c, %0\n\t"
+                                        "nop\n\t" :
+                                        "=&r" (cpuid));
            See btfixup.h and btfixupprep.c to understand how a blackbox works.
          */
         __asm__ __volatile__("sethi %%hi(___b_hard_smp_processor_id), %0\n\t"
diff --git a/arch/sparc/include/asm/smp_64.h b/arch/sparc/include/asm/smp_64.h
index f49e11cd4ded..20bca8950710 100644
--- a/arch/sparc/include/asm/smp_64.h
+++ b/arch/sparc/include/asm/smp_64.h
@@ -49,6 +49,10 @@ extern void cpu_play_dead(void);
 
 extern void smp_fetch_global_regs(void);
 
+struct seq_file;
+void smp_bogo(struct seq_file *);
+void smp_info(struct seq_file *);
+
 #ifdef CONFIG_HOTPLUG_CPU
 extern int __cpu_disable(void);
 extern void __cpu_die(unsigned int cpu);
diff --git a/arch/sparc/include/asm/spinlock_32.h b/arch/sparc/include/asm/spinlock_32.h
index 7f9b9dba38a6..5f5b8bf3f50d 100644
--- a/arch/sparc/include/asm/spinlock_32.h
+++ b/arch/sparc/include/asm/spinlock_32.h
@@ -9,6 +9,7 @@
 #ifndef __ASSEMBLY__
 
 #include <asm/psr.h>
+#include <asm/processor.h> /* for cpu_relax */
 
 #define arch_spin_is_locked(lock) (*((volatile unsigned char *)(lock)) != 0)
 
diff --git a/arch/sparc/include/asm/system_32.h b/arch/sparc/include/asm/system_32.h
index 890036b3689a..aba16092a81b 100644
--- a/arch/sparc/include/asm/system_32.h
+++ b/arch/sparc/include/asm/system_32.h
@@ -15,11 +15,6 @@
 
 #include <linux/irqflags.h>
 
-static inline unsigned int probe_irq_mask(unsigned long val)
-{
-        return 0;
-}
-
 /*
  * Sparc (general) CPU types
  */
@@ -225,7 +220,7 @@ static inline unsigned long __xchg(unsigned long x, __volatile__ void * ptr, int
         switch (size) {
         case 4:
                 return xchg_u32(ptr, x);
-        };
+        }
         __xchg_called_with_bad_pointer();
         return x;
 }
diff --git a/arch/sparc/include/asm/system_64.h b/arch/sparc/include/asm/system_64.h
index e3b65d8cf41b..10bcabce97b2 100644
--- a/arch/sparc/include/asm/system_64.h
+++ b/arch/sparc/include/asm/system_64.h
@@ -29,10 +29,6 @@ enum sparc_cpu {
 /* This cannot ever be a sun4c :) That's just history. */
 #define ARCH_SUN4C 0
 
-extern const char *sparc_cpu_type;
-extern const char *sparc_fpu_type;
-extern const char *sparc_pmu_type;
-
 extern char reboot_command[];
 
 /* These are here in an effort to more fully work around Spitfire Errata
@@ -238,7 +234,7 @@ static inline unsigned long __xchg(unsigned long x, __volatile__ void * ptr,
                 return xchg32(ptr, x);
         case 8:
                 return xchg64(ptr, x);
-        };
+        }
         __xchg_called_with_bad_pointer();
         return x;
 }
diff --git a/arch/sparc/include/asm/thread_info_32.h b/arch/sparc/include/asm/thread_info_32.h
index 9dd0318d3ddf..fa5753233410 100644
--- a/arch/sparc/include/asm/thread_info_32.h
+++ b/arch/sparc/include/asm/thread_info_32.h
@@ -82,8 +82,8 @@ register struct thread_info *current_thread_info_reg asm("g6");
 
 #define __HAVE_ARCH_THREAD_INFO_ALLOCATOR
 
-BTFIXUPDEF_CALL(struct thread_info *, alloc_thread_info, void)
-#define alloc_thread_info(tsk) BTFIXUP_CALL(alloc_thread_info)()
+BTFIXUPDEF_CALL(struct thread_info *, alloc_thread_info_node, int)
+#define alloc_thread_info_node(tsk, node) BTFIXUP_CALL(alloc_thread_info_node)(node)
 
 BTFIXUPDEF_CALL(void, free_thread_info, struct thread_info *)
 #define free_thread_info(ti) BTFIXUP_CALL(free_thread_info)(ti)
@@ -92,7 +92,7 @@ BTFIXUPDEF_CALL(void, free_thread_info, struct thread_info *)
 
 /*
  * Size of kernel stack for each process.
- * Observe the order of get_free_pages() in alloc_thread_info().
+ * Observe the order of get_free_pages() in alloc_thread_info_node().
  * The sun4 has 8K stack too, because it's short on memory, and 16K is a waste.
  */
 #define THREAD_SIZE             8192
diff --git a/arch/sparc/include/asm/thread_info_64.h b/arch/sparc/include/asm/thread_info_64.h
index fb2ea7705a46..60d86be1a533 100644
--- a/arch/sparc/include/asm/thread_info_64.h
+++ b/arch/sparc/include/asm/thread_info_64.h
@@ -146,21 +146,21 @@ register struct thread_info *current_thread_info_reg asm("g6");
 #define __HAVE_ARCH_THREAD_INFO_ALLOCATOR
 
 #ifdef CONFIG_DEBUG_STACK_USAGE
-#define alloc_thread_info(tsk)                                  \
-({                                                              \
-        struct thread_info *ret;                                \
-                                                                \
-        ret = (struct thread_info *)                            \
-          __get_free_pages(GFP_KERNEL, __THREAD_INFO_ORDER);    \
-        if (ret)                                                \
-                memset(ret, 0, PAGE_SIZE<<__THREAD_INFO_ORDER); \
-        ret;                                                    \
-})
+#define THREAD_FLAGS (GFP_KERNEL | __GFP_ZERO)
 #else
-#define alloc_thread_info(tsk) \
-        ((struct thread_info *)__get_free_pages(GFP_KERNEL, __THREAD_INFO_ORDER))
+#define THREAD_FLAGS (GFP_KERNEL)
 #endif
 
+#define alloc_thread_info_node(tsk, node)                               \
+({                                                                      \
+        struct page *page = alloc_pages_node(node, THREAD_FLAGS,        \
+                                             __THREAD_INFO_ORDER);      \
+        struct thread_info *ret;                                        \
+                                                                        \
+        ret = page ? page_address(page) : NULL;                         \
+        ret;                                                            \
+})
+
 #define free_thread_info(ti) \
         free_pages((unsigned long)(ti),__THREAD_INFO_ORDER)
 
diff --git a/arch/sparc/include/asm/tlb_64.h b/arch/sparc/include/asm/tlb_64.h
index dca406b9b6fc..190e18913cc6 100644
--- a/arch/sparc/include/asm/tlb_64.h
+++ b/arch/sparc/include/asm/tlb_64.h
@@ -7,66 +7,11 @@
 #include <asm/tlbflush.h>
 #include <asm/mmu_context.h>
 
-#define TLB_BATCH_NR    192
-
-/*
- * For UP we don't need to worry about TLB flush
- * and page free order so much..
- */
-#ifdef CONFIG_SMP
-  #define FREE_PTE_NR   506
-  #define tlb_fast_mode(bp) ((bp)->pages_nr == ~0U)
-#else
-  #define FREE_PTE_NR   1
-  #define tlb_fast_mode(bp) 1
-#endif
-
-struct mmu_gather {
-        struct mm_struct *mm;
-        unsigned int pages_nr;
-        unsigned int need_flush;
-        unsigned int fullmm;
-        unsigned int tlb_nr;
-        unsigned long vaddrs[TLB_BATCH_NR];
-        struct page *pages[FREE_PTE_NR];
-};
-
-DECLARE_PER_CPU(struct mmu_gather, mmu_gathers);
-
 #ifdef CONFIG_SMP
 extern void smp_flush_tlb_pending(struct mm_struct *,
                                   unsigned long, unsigned long *);
 #endif
 
-extern void __flush_tlb_pending(unsigned long, unsigned long, unsigned long *);
-extern void flush_tlb_pending(void);
-
-static inline struct mmu_gather *tlb_gather_mmu(struct mm_struct *mm, unsigned int full_mm_flush)
-{
-        struct mmu_gather *mp = &get_cpu_var(mmu_gathers);
-
-        BUG_ON(mp->tlb_nr);
-
-        mp->mm = mm;
-        mp->pages_nr = num_online_cpus() > 1 ? 0U : ~0U;
-        mp->fullmm = full_mm_flush;
-
-        return mp;
-}
-
-
-static inline void tlb_flush_mmu(struct mmu_gather *mp)
-{
-        if (!mp->fullmm)
-                flush_tlb_pending();
-        if (mp->need_flush) {
-                free_pages_and_swap_cache(mp->pages, mp->pages_nr);
-                mp->pages_nr = 0;
-                mp->need_flush = 0;
-        }
-
-}
-
 #ifdef CONFIG_SMP
 extern void smp_flush_tlb_mm(struct mm_struct *mm);
 #define do_flush_tlb_mm(mm) smp_flush_tlb_mm(mm)
@@ -74,38 +19,14 @@ extern void smp_flush_tlb_mm(struct mm_struct *mm);
 #define do_flush_tlb_mm(mm) __flush_tlb_mm(CTX_HWBITS(mm->context), SECONDARY_CONTEXT)
 #endif
 
-static inline void tlb_finish_mmu(struct mmu_gather *mp, unsigned long start, unsigned long end)
-{
-        tlb_flush_mmu(mp);
-
-        if (mp->fullmm)
-                mp->fullmm = 0;
-
-        /* keep the page table cache within bounds */
-        check_pgt_cache();
-
-        put_cpu_var(mmu_gathers);
-}
-
-static inline void tlb_remove_page(struct mmu_gather *mp, struct page *page)
-{
-        if (tlb_fast_mode(mp)) {
-                free_page_and_swap_cache(page);
-                return;
-        }
-        mp->need_flush = 1;
-        mp->pages[mp->pages_nr++] = page;
-        if (mp->pages_nr >= FREE_PTE_NR)
-                tlb_flush_mmu(mp);
-}
-
-#define tlb_remove_tlb_entry(mp,ptep,addr) do { } while (0)
-#define pte_free_tlb(mp, ptepage, addr) pte_free((mp)->mm, ptepage)
-#define pmd_free_tlb(mp, pmdp, addr) pmd_free((mp)->mm, pmdp)
-#define pud_free_tlb(tlb,pudp, addr) __pud_free_tlb(tlb,pudp,addr)
+extern void __flush_tlb_pending(unsigned long, unsigned long, unsigned long *);
+extern void flush_tlb_pending(void);
 
-#define tlb_migrate_finish(mm)  do { } while (0)
 #define tlb_start_vma(tlb, vma) do { } while (0)
 #define tlb_end_vma(tlb, vma)   do { } while (0)
+#define __tlb_remove_tlb_entry(tlb, ptep, address) do { } while (0)
+#define tlb_flush(tlb)  flush_tlb_pending()
+
+#include <asm-generic/tlb.h>
 
 #endif /* _SPARC64_TLB_H */
diff --git a/arch/sparc/include/asm/tlbflush_64.h b/arch/sparc/include/asm/tlbflush_64.h
index fbb675dbe0c9..2ef463494153 100644
--- a/arch/sparc/include/asm/tlbflush_64.h
+++ b/arch/sparc/include/asm/tlbflush_64.h
@@ -5,9 +5,17 @@
 #include <asm/mmu_context.h>
 
 /* TSB flush operations. */
-struct mmu_gather;
+
+#define TLB_BATCH_NR    192
+
+struct tlb_batch {
+        struct mm_struct *mm;
+        unsigned long tlb_nr;
+        unsigned long vaddrs[TLB_BATCH_NR];
+};
+
 extern void flush_tsb_kernel_range(unsigned long start, unsigned long end);
-extern void flush_tsb_user(struct mmu_gather *mp);
+extern void flush_tsb_user(struct tlb_batch *tb);
 
 /* TLB flush operations. */
 
diff --git a/arch/sparc/include/asm/topology_64.h b/arch/sparc/include/asm/topology_64.h
index 1c79f32734a0..8b9c556d630b 100644
--- a/arch/sparc/include/asm/topology_64.h
+++ b/arch/sparc/include/asm/topology_64.h
@@ -65,6 +65,10 @@ static inline int pcibus_to_node(struct pci_bus *pbus)
 #define smt_capable()                           (sparc64_multi_core)
 #endif /* CONFIG_SMP */
 
-#define cpu_coregroup_mask(cpu)                 (&cpu_core_map[cpu])
+extern cpumask_t cpu_core_map[NR_CPUS];
+static inline const struct cpumask *cpu_coregroup_mask(int cpu)
+{
+        return &cpu_core_map[cpu];
+}
 
 #endif /* _ASM_SPARC64_TOPOLOGY_H */
diff --git a/arch/sparc/include/asm/types.h b/arch/sparc/include/asm/types.h
index 09c79a9c8516..91e5a034f987 100644
--- a/arch/sparc/include/asm/types.h
+++ b/arch/sparc/include/asm/types.h
@@ -18,28 +18,6 @@ typedef unsigned short umode_t;
 
 #endif /* __ASSEMBLY__ */
 
-#ifdef __KERNEL__
-
-#ifndef __ASSEMBLY__
-
-/* Dma addresses come in generic and 64-bit flavours.  */
-
-typedef u32 dma_addr_t;
-
-#if defined(__arch64__)
-
-/*** SPARC 64 bit ***/
-typedef u64 dma64_addr_t;
-#else
-/*** SPARC 32 bit ***/
-typedef u32 dma64_addr_t;
-
-#endif /* defined(__arch64__) */
-
-#endif /* __ASSEMBLY__ */
-
-#endif /* __KERNEL__ */
-
 #endif /* defined(__sparc__) */
 
 #endif /* defined(_SPARC_TYPES_H) */
diff --git a/arch/sparc/include/asm/unistd.h b/arch/sparc/include/asm/unistd.h
index 03eb5a8f6f93..6260d5deeabc 100644
--- a/arch/sparc/include/asm/unistd.h
+++ b/arch/sparc/include/asm/unistd.h
@@ -400,8 +400,14 @@
 #define __NR_fanotify_init      329
 #define __NR_fanotify_mark      330
 #define __NR_prlimit64          331
+#define __NR_name_to_handle_at  332
+#define __NR_open_by_handle_at  333
+#define __NR_clock_adjtime      334
+#define __NR_syncfs             335
+#define __NR_sendmmsg           336
+#define __NR_setns              337
 
-#define NR_syscalls             332
+#define NR_syscalls             338
 
 #ifdef __32bit_syscall_numbers__
 /* Sparc 32-bit only has the "setresuid32", "getresuid32" variants,
diff --git a/arch/sparc/include/asm/winmacro.h b/arch/sparc/include/asm/winmacro.h
index 5b0a06dc3bcb..a9be04b0d049 100644
--- a/arch/sparc/include/asm/winmacro.h
+++ b/arch/sparc/include/asm/winmacro.h
@@ -103,6 +103,7 @@
         st       %scratch, [%cur_reg + TI_W_SAVED];
 
 #ifdef CONFIG_SMP
+/* Results of LOAD_CURRENT() after BTFIXUP for SUN4M, SUN4D & LEON (comments) */
 #define LOAD_CURRENT4M(dest_reg, idreg) \
         rd       %tbr, %idreg; \
         sethi    %hi(current_set), %dest_reg; \
@@ -118,6 +119,14 @@
         or      %dest_reg, %lo(C_LABEL(current_set)), %dest_reg; \
         ld      [%idreg + %dest_reg], %dest_reg;
 
+#define LOAD_CURRENT_LEON(dest_reg, idreg)                      \
+        rd      %asr17, %idreg;                                 \
+        sethi   %hi(current_set), %dest_reg;                    \
+        srl     %idreg, 0x1c, %idreg;                           \
+        or      %dest_reg, %lo(current_set), %dest_reg;         \
+        sll     %idreg, 0x2, %idreg;                            \
+        ld      [%idreg + %dest_reg], %dest_reg;
+
 /* Blackbox - take care with this... - check smp4m and smp4d before changing this. */
 #define LOAD_CURRENT(dest_reg, idreg)                                   \
         sethi    %hi(___b_load_current), %idreg;                        \
diff --git a/arch/sparc/kernel/Makefile b/arch/sparc/kernel/Makefile
index 0c2dc1f24a9a..b90b4a1d070a 100644
--- a/arch/sparc/kernel/Makefile
+++ b/arch/sparc/kernel/Makefile
@@ -42,7 +42,6 @@ obj-$(CONFIG_SPARC32)   += windows.o
 obj-y                   += cpu.o
 obj-$(CONFIG_SPARC32)   += devices.o
 obj-$(CONFIG_SPARC32)   += tadpole.o
-obj-$(CONFIG_SPARC32)   += tick14.o
 obj-y                   += ptrace_$(BITS).o
 obj-y                   += unaligned_$(BITS).o
 obj-y                   += una_asm_$(BITS).o
@@ -54,6 +53,7 @@ obj-y                   += of_device_$(BITS).o
 obj-$(CONFIG_SPARC64)   += prom_irqtrans.o
 
 obj-$(CONFIG_SPARC_LEON)+= leon_kernel.o
+obj-$(CONFIG_SPARC_LEON)+= leon_pmc.o
 
 obj-$(CONFIG_SPARC64)   += reboot.o
 obj-$(CONFIG_SPARC64)   += sysfs.o
@@ -71,13 +71,11 @@ obj-$(CONFIG_SPARC64)	+= pcr.o
 obj-$(CONFIG_SPARC64)   += nmi.o
 obj-$(CONFIG_SPARC64_SMP) += cpumap.o
 
-# sparc32 do not use GENERIC_HARDIRQS but uses the generic devres implementation
-obj-$(CONFIG_SPARC32)     += devres.o
-devres-y                  := ../../../kernel/irq/devres.o
-
 obj-y                     += dma.o
 
-obj-$(CONFIG_SPARC32_PCI) += pcic.o
+obj-$(CONFIG_PCIC_PCI)    += pcic.o
+obj-$(CONFIG_LEON_PCI)    += leon_pci.o
+obj-$(CONFIG_GRPCI2)      += leon_pci_grpci2.o
 
 obj-$(CONFIG_SMP)         += trampoline_$(BITS).o smp_$(BITS).o
 obj-$(CONFIG_SPARC32_SMP) += sun4m_smp.o sun4d_smp.o leon_smp.o
@@ -119,3 +117,5 @@ obj-$(CONFIG_COMPAT)    += $(audit--y)
 
 pc--$(CONFIG_PERF_EVENTS) := perf_event.o
 obj-$(CONFIG_SPARC64)   += $(pc--y)
+
+obj-$(CONFIG_SPARC64)   += jump_label.o
diff --git a/arch/sparc/kernel/apc.c b/arch/sparc/kernel/apc.c
index 2c0046ecc715..caef9deb5866 100644
--- a/arch/sparc/kernel/apc.c
+++ b/arch/sparc/kernel/apc.c
@@ -123,7 +123,7 @@ static long apc_ioctl(struct file *f, unsigned int cmd, unsigned long __arg)
 
         default:
                 return -EINVAL;
-        };
+        }
 
         return 0;
 }
@@ -132,12 +132,12 @@ static const struct file_operations apc_fops = {
         .unlocked_ioctl =       apc_ioctl,
         .open =                 apc_open,
         .release =              apc_release,
+        .llseek =               noop_llseek,
 };
 
 static struct miscdevice apc_miscdev = { APC_MINOR, APC_DEVNAME, &apc_fops };
 
-static int __devinit apc_probe(struct platform_device *op,
-                               const struct of_device_id *match)
+static int __devinit apc_probe(struct platform_device *op)
 {
         int err;
 
@@ -165,7 +165,7 @@ static int __devinit apc_probe(struct platform_device *op,
         return 0;
 }
 
-static struct of_device_id __initdata apc_match[] = {
+static struct of_device_id apc_match[] = {
         {
                 .name = APC_OBPNAME,
         },
@@ -173,7 +173,7 @@ static struct of_device_id __initdata apc_match[] = {
 };
 MODULE_DEVICE_TABLE(of, apc_match);
 
-static struct of_platform_driver apc_driver = {
+static struct platform_driver apc_driver = {
         .driver = {
                 .name = "apc",
                 .owner = THIS_MODULE,
@@ -184,7 +184,7 @@ static struct of_platform_driver apc_driver = {
 
 static int __init apc_init(void)
 {
-        return of_register_platform_driver(&apc_driver);
+        return platform_driver_register(&apc_driver);
 }
 
 /* This driver is not critical to the boot process
diff --git a/arch/sparc/kernel/auxio_32.c b/arch/sparc/kernel/auxio_32.c
index ee8d214cae1e..acf5151f3c1d 100644
--- a/arch/sparc/kernel/auxio_32.c
+++ b/arch/sparc/kernel/auxio_32.c
@@ -23,7 +23,7 @@ static DEFINE_SPINLOCK(auxio_lock);
 
 void __init auxio_probe(void)
 {
-        int node, auxio_nd;
+        phandle node, auxio_nd;
         struct linux_prom_registers auxregs[1];
         struct resource r;
 
@@ -101,7 +101,7 @@ void set_auxio(unsigned char bits_on, unsigned char bits_off)
                 break;
         default:
                 panic("Can't set AUXIO register on this machine.");
-        };
+        }
         spin_unlock_irqrestore(&auxio_lock, flags);
 }
 EXPORT_SYMBOL(set_auxio);
@@ -113,7 +113,7 @@ volatile unsigned char * auxio_power_register = NULL;
 void __init auxio_power_probe(void)
 {
         struct linux_prom_registers regs;
-        int node;
+        phandle node;
         struct resource r;
 
         /* Attempt to find the sun4m power control node. */
@@ -121,7 +121,7 @@ void __init auxio_power_probe(void)
         node = prom_searchsiblings(node, "obio");
         node = prom_getchild(node);
         node = prom_searchsiblings(node, "power");
-        if (node == 0 || node == -1)
+        if (node == 0 || (s32)node == -1)
                 return;
 
         /* Map the power control register. */
diff --git a/arch/sparc/kernel/auxio_64.c b/arch/sparc/kernel/auxio_64.c
index 3efd3c5af6a9..773091ac71a3 100644
--- a/arch/sparc/kernel/auxio_64.c
+++ b/arch/sparc/kernel/auxio_64.c
@@ -93,7 +93,7 @@ void auxio_set_lte(int on)
 }
 EXPORT_SYMBOL(auxio_set_lte);
 
-static struct of_device_id __initdata auxio_match[] = {
+static const struct of_device_id auxio_match[] = {
         {
                 .name = "auxio",
         },
@@ -102,8 +102,7 @@ static struct of_device_id __initdata auxio_match[] = {
 
 MODULE_DEVICE_TABLE(of, auxio_match);
 
-static int __devinit auxio_probe(struct platform_device *dev,
-                                 const struct of_device_id *match)
+static int __devinit auxio_probe(struct platform_device *dev)
 {
         struct device_node *dp = dev->dev.of_node;
         unsigned long size;
@@ -132,7 +131,7 @@ static int __devinit auxio_probe(struct platform_device *dev,
         return 0;
 }
 
-static struct of_platform_driver auxio_driver = {
+static struct platform_driver auxio_driver = {
         .probe          = auxio_probe,
         .driver = {
                 .name = "auxio",
@@ -143,7 +142,7 @@ static struct of_platform_driver auxio_driver = {
 
 static int __init auxio_init(void)
 {
-        return of_register_platform_driver(&auxio_driver);
+        return platform_driver_register(&auxio_driver);
 }
 
 /* Must be after subsys_initcall() so that busses are probed.  Must
diff --git a/arch/sparc/kernel/btext.c b/arch/sparc/kernel/btext.c
index 8cc2d56ffe9a..89aa4eb20cf5 100644
--- a/arch/sparc/kernel/btext.c
+++ b/arch/sparc/kernel/btext.c
@@ -40,7 +40,7 @@ static unsigned char *dispDeviceBase __force_data;
 
 static unsigned char vga_font[cmapsz];
 
-static int __init btext_initialize(unsigned int node)
+static int __init btext_initialize(phandle node)
 {
         unsigned int width, height, depth, pitch;
         unsigned long address = 0;
@@ -309,7 +309,7 @@ static struct console btext_console = {
 
 int __init btext_find_display(void)
 {
-        unsigned int node;
+        phandle node;
         char type[32];
         int ret;
 
diff --git a/arch/sparc/kernel/central.c b/arch/sparc/kernel/central.c
index cfa2624c5332..7eef3f741963 100644
--- a/arch/sparc/kernel/central.c
+++ b/arch/sparc/kernel/central.c
@@ -59,8 +59,7 @@ static int __devinit clock_board_calc_nslots(struct clock_board *p)
         }
 }
 
-static int __devinit clock_board_probe(struct platform_device *op,
-                                       const struct of_device_id *match)
+static int __devinit clock_board_probe(struct platform_device *op)
 {
         struct clock_board *p = kzalloc(sizeof(*p), GFP_KERNEL);
         int err = -ENOMEM;
@@ -141,14 +140,14 @@ out_free:
         goto out;
 }
 
-static struct of_device_id __initdata clock_board_match[] = {
+static const struct of_device_id clock_board_match[] = {
         {
                 .name = "clock-board",
         },
         {},
 };
 
-static struct of_platform_driver clock_board_driver = {
+static struct platform_driver clock_board_driver = {
         .probe          = clock_board_probe,
         .driver = {
                 .name = "clock_board",
@@ -157,8 +156,7 @@ static struct of_platform_driver clock_board_driver = {
         },
 };
 
-static int __devinit fhc_probe(struct platform_device *op,
-                               const struct of_device_id *match)
+static int __devinit fhc_probe(struct platform_device *op)
 {
         struct fhc *p = kzalloc(sizeof(*p), GFP_KERNEL);
         int err = -ENOMEM;
@@ -247,14 +245,14 @@ out_free:
         goto out;
 }
 
-static struct of_device_id __initdata fhc_match[] = {
+static const struct of_device_id fhc_match[] = {
         {
                 .name = "fhc",
         },
         {},
 };
 
-static struct of_platform_driver fhc_driver = {
+static struct platform_driver fhc_driver = {
         .probe          = fhc_probe,
         .driver = {
                 .name = "fhc",
@@ -265,8 +263,8 @@ static struct of_platform_driver fhc_driver = {
 
 static int __init sunfire_init(void)
 {
-        (void) of_register_platform_driver(&fhc_driver);
-        (void) of_register_platform_driver(&clock_board_driver);
+        (void) platform_driver_register(&fhc_driver);
+        (void) platform_driver_register(&clock_board_driver);
         return 0;
 }
 
diff --git a/arch/sparc/kernel/chmc.c b/arch/sparc/kernel/chmc.c
index 08c466ebb32b..5f450260981d 100644
--- a/arch/sparc/kernel/chmc.c
+++ b/arch/sparc/kernel/chmc.c
@@ -392,8 +392,7 @@ static void __devinit jbusmc_construct_dimm_groups(struct jbusmc *p,
         }
 }
 
-static int __devinit jbusmc_probe(struct platform_device *op,
-                                  const struct of_device_id *match)
+static int __devinit jbusmc_probe(struct platform_device *op)
 {
         const struct linux_prom64_registers *mem_regs;
         struct device_node *mem_node;
@@ -665,7 +664,7 @@ static void chmc_interpret_one_decode_reg(struct chmc *p, int which_bank, u64 va
         case 0x0:
                 bp->interleave = 16;
                 break;
-        };
+        }
 
         /* UK[10] is reserved, and UK[11] is not set for the SDRAM
          * bank size definition.
@@ -690,8 +689,7 @@ static void chmc_fetch_decode_regs(struct chmc *p)
                                       chmc_read_mcreg(p, CHMCTRL_DECODE4));
 }
 
-static int __devinit chmc_probe(struct platform_device *op,
-                                const struct of_device_id *match)
+static int __devinit chmc_probe(struct platform_device *op)
 {
         struct device_node *dp = op->dev.of_node;
         unsigned long ver;
@@ -765,13 +763,12 @@ out_free:
         goto out;
 }
 
-static int __devinit us3mc_probe(struct platform_device *op,
-                                const struct of_device_id *match)
+static int __devinit us3mc_probe(struct platform_device *op)
 {
         if (mc_type == MC_TYPE_SAFARI)
-                return chmc_probe(op, match);
+                return chmc_probe(op);
         else if (mc_type == MC_TYPE_JBUS)
-                return jbusmc_probe(op, match);
+                return jbusmc_probe(op);
         return -ENODEV;
 }
 
@@ -810,7 +807,7 @@ static const struct of_device_id us3mc_match[] = {
 };
 MODULE_DEVICE_TABLE(of, us3mc_match);
 
-static struct of_platform_driver us3mc_driver = {
+static struct platform_driver us3mc_driver = {
         .driver = {
                 .name = "us3mc",
                 .owner = THIS_MODULE,
@@ -848,7 +845,7 @@ static int __init us3mc_init(void)
         ret = register_dimm_printer(us3mc_dimm_printer);
 
         if (!ret) {
-                ret = of_register_platform_driver(&us3mc_driver);
+                ret = platform_driver_register(&us3mc_driver);
                 if (ret)
                         unregister_dimm_printer(us3mc_dimm_printer);
         }
@@ -859,7 +856,7 @@ static void __exit us3mc_cleanup(void)
 {
         if (us3mc_platform()) {
                 unregister_dimm_printer(us3mc_dimm_printer);
-                of_unregister_platform_driver(&us3mc_driver);
+                platform_driver_unregister(&us3mc_driver);
         }
 }
 
diff --git a/arch/sparc/kernel/cpu.c b/arch/sparc/kernel/cpu.c
index e447938d39cf..138dbbc8dc84 100644
--- a/arch/sparc/kernel/cpu.c
+++ b/arch/sparc/kernel/cpu.c
@@ -4,6 +4,7 @@
  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
  */
 
+#include <linux/seq_file.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -11,7 +12,9 @@
 #include <linux/threads.h>
 
 #include <asm/spitfire.h>
+#include <asm/pgtable.h>
 #include <asm/oplib.h>
+#include <asm/setup.h>
 #include <asm/page.h>
 #include <asm/head.h>
 #include <asm/psr.h>
@@ -23,6 +26,9 @@
 DEFINE_PER_CPU(cpuinfo_sparc, __cpu_data) = { 0 };
 EXPORT_PER_CPU_SYMBOL(__cpu_data);
 
+int ncpus_probed;
+unsigned int fsr_storage;
+
 struct cpu_info {
         int psr_vers;
         const char *name;
@@ -247,13 +253,12 @@ static const struct manufacturer_info __initconst manufacturer_info[] = {
  * machine type value into consideration too.  I will fix this.
  */
 
-const char *sparc_cpu_type;
-const char *sparc_fpu_type;
+static const char *sparc_cpu_type;
+static const char *sparc_fpu_type;
 const char *sparc_pmu_type;
 
-unsigned int fsr_storage;
 
-static void set_cpu_and_fpu(int psr_impl, int psr_vers, int fpu_vers)
+static void __init set_cpu_and_fpu(int psr_impl, int psr_vers, int fpu_vers)
 {
         const struct manufacturer_info *manuf;
         int i;
@@ -313,7 +318,123 @@ static void set_cpu_and_fpu(int psr_impl, int psr_vers, int fpu_vers)
 }
 
 #ifdef CONFIG_SPARC32
-void __cpuinit cpu_probe(void)
+static int show_cpuinfo(struct seq_file *m, void *__unused)
+{
+        seq_printf(m,
+                   "cpu\t\t: %s\n"
+                   "fpu\t\t: %s\n"
+                   "promlib\t\t: Version %d Revision %d\n"
+                   "prom\t\t: %d.%d\n"
+                   "type\t\t: %s\n"
+                   "ncpus probed\t: %d\n"
+                   "ncpus active\t: %d\n"
+#ifndef CONFIG_SMP
+                   "CPU0Bogo\t: %lu.%02lu\n"
+                   "CPU0ClkTck\t: %ld\n"
+#endif
+                   ,
+                   sparc_cpu_type,
+                   sparc_fpu_type ,
+                   romvec->pv_romvers,
+                   prom_rev,
+                   romvec->pv_printrev >> 16,
+                   romvec->pv_printrev & 0xffff,
+                   &cputypval[0],
+                   ncpus_probed,
+                   num_online_cpus()
+#ifndef CONFIG_SMP
+                   , cpu_data(0).udelay_val/(500000/HZ),
+                   (cpu_data(0).udelay_val/(5000/HZ)) % 100,
+                   cpu_data(0).clock_tick
+#endif
+                );
+
+#ifdef CONFIG_SMP
+        smp_bogo(m);
+#endif
+        mmu_info(m);
+#ifdef CONFIG_SMP
+        smp_info(m);
+#endif
+        return 0;
+}
+#endif /* CONFIG_SPARC32 */
+
+#ifdef CONFIG_SPARC64
+unsigned int dcache_parity_tl1_occurred;
+unsigned int icache_parity_tl1_occurred;
+
+
+static int show_cpuinfo(struct seq_file *m, void *__unused)
+{
+        seq_printf(m,
+                   "cpu\t\t: %s\n"
+                   "fpu\t\t: %s\n"
+                   "pmu\t\t: %s\n"
+                   "prom\t\t: %s\n"
+                   "type\t\t: %s\n"
+                   "ncpus probed\t: %d\n"
+                   "ncpus active\t: %d\n"
+                   "D$ parity tl1\t: %u\n"
+                   "I$ parity tl1\t: %u\n"
+#ifndef CONFIG_SMP
+                   "Cpu0ClkTck\t: %016lx\n"
+#endif
+                   ,
+                   sparc_cpu_type,
+                   sparc_fpu_type,
+                   sparc_pmu_type,
+                   prom_version,
+                   ((tlb_type == hypervisor) ?
+                    "sun4v" :
+                    "sun4u"),
+                   ncpus_probed,
+                   num_online_cpus(),
+                   dcache_parity_tl1_occurred,
+                   icache_parity_tl1_occurred
+#ifndef CONFIG_SMP
+                   , cpu_data(0).clock_tick
+#endif
+                );
+#ifdef CONFIG_SMP
+        smp_bogo(m);
+#endif
+        mmu_info(m);
+#ifdef CONFIG_SMP
+        smp_info(m);
+#endif
+        return 0;
+}
+#endif /* CONFIG_SPARC64 */
+
+static void *c_start(struct seq_file *m, loff_t *pos)
+{
+        /* The pointer we are returning is arbitrary,
+         * it just has to be non-NULL and not IS_ERR
+         * in the success case.
+         */
+        return *pos == 0 ? &c_start : NULL;
+}
+
+static void *c_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        ++*pos;
+        return c_start(m, pos);
+}
+
+static void c_stop(struct seq_file *m, void *v)
+{
+}
+
+const struct seq_operations cpuinfo_op = {
+        .start =c_start,
+        .next = c_next,
+        .stop = c_stop,
+        .show = show_cpuinfo,
+};
+
+#ifdef CONFIG_SPARC32
+static int __init cpu_type_probe(void)
 {
         int psr_impl, psr_vers, fpu_vers;
         int psr;
@@ -324,7 +445,7 @@ void __cpuinit cpu_probe(void)
         psr = get_psr();
         put_psr(psr | PSR_EF);
 #ifdef CONFIG_SPARC_LEON
-        fpu_vers = 7;
+        fpu_vers = get_psr() & PSR_EF ? ((get_fsr() >> 17) & 0x7) : 7;
 #else
         fpu_vers = ((get_fsr() >> 17) & 0x7);
 #endif
@@ -332,8 +453,12 @@ void __cpuinit cpu_probe(void)
         put_psr(psr);
 
         set_cpu_and_fpu(psr_impl, psr_vers, fpu_vers);
+
+        return 0;
 }
-#else
+#endif /* CONFIG_SPARC32 */
+
+#ifdef CONFIG_SPARC64
 static void __init sun4v_cpu_probe(void)
 {
         switch (sun4v_chip_type) {
@@ -374,6 +499,6 @@ static int __init cpu_type_probe(void)
         }
         return 0;
 }
+#endif /* CONFIG_SPARC64 */
 
-arch_initcall(cpu_type_probe);
-#endif
+early_initcall(cpu_type_probe);
diff --git a/arch/sparc/kernel/cpumap.c b/arch/sparc/kernel/cpumap.c
index 8de64c8126bc..d91fd782743a 100644
--- a/arch/sparc/kernel/cpumap.c
+++ b/arch/sparc/kernel/cpumap.c
@@ -202,7 +202,7 @@ static struct cpuinfo_tree *build_cpuinfo_tree(void)
         new_tree->total_nodes = n;
         memcpy(&new_tree->level, tmp_level, sizeof(tmp_level));
 
-        prev_cpu = cpu = first_cpu(cpu_online_map);
+        prev_cpu = cpu = cpumask_first(cpu_online_mask);
 
         /* Initialize all levels in the tree with the first CPU */
         for (level = CPUINFO_LVL_PROC; level >= CPUINFO_LVL_ROOT; level--) {
@@ -381,7 +381,7 @@ static int simple_map_to_cpu(unsigned int index)
         }
 
         /* Impossible, since num_online_cpus() <= num_possible_cpus() */
-        return first_cpu(cpu_online_map);
+        return cpumask_first(cpu_online_mask);
 }
 
 static int _map_to_cpu(unsigned int index)
diff --git a/arch/sparc/kernel/devices.c b/arch/sparc/kernel/devices.c
index 62dc7a021413..113c052c3043 100644
--- a/arch/sparc/kernel/devices.c
+++ b/arch/sparc/kernel/devices.c
@@ -20,7 +20,6 @@
 #include <asm/system.h>
 #include <asm/cpudata.h>
 
-extern void cpu_probe(void);
 extern void clock_stop_probe(void); /* tadpole.c */
 extern void sun4c_probe_memerr_reg(void);
 
@@ -31,9 +30,9 @@ static char *cpu_mid_prop(void)
         return "mid";
 }
 
-static int check_cpu_node(int nd, int *cur_inst,
-                          int (*compare)(int, int, void *), void *compare_arg,
-                          int *prom_node, int *mid)
+static int check_cpu_node(phandle nd, int *cur_inst,
+                int (*compare)(phandle, int, void *), void *compare_arg,
+                phandle *prom_node, int *mid)
 {
         if (!compare(nd, *cur_inst, compare_arg)) {
                 if (prom_node)
@@ -51,8 +50,8 @@ static int check_cpu_node(int nd, int *cur_inst,
         return -ENODEV;
 }
 
-static int __cpu_find_by(int (*compare)(int, int, void *), void *compare_arg,
-                         int *prom_node, int *mid)
+static int __cpu_find_by(int (*compare)(phandle, int, void *),
+                void *compare_arg, phandle *prom_node, int *mid)
 {
         struct device_node *dp;
         int cur_inst;
@@ -71,7 +70,7 @@ static int __cpu_find_by(int (*compare)(int, int, void *), void *compare_arg,
         return -ENODEV;
 }
 
-static int cpu_instance_compare(int nd, int instance, void *_arg)
+static int cpu_instance_compare(phandle nd, int instance, void *_arg)
 {
         int desired_instance = (int) _arg;
 
@@ -80,13 +79,13 @@ static int cpu_instance_compare(int nd, int instance, void *_arg)
         return -ENODEV;
 }
 
-int cpu_find_by_instance(int instance, int *prom_node, int *mid)
+int cpu_find_by_instance(int instance, phandle *prom_node, int *mid)
 {
         return __cpu_find_by(cpu_instance_compare, (void *)instance,
                              prom_node, mid);
 }
 
-static int cpu_mid_compare(int nd, int instance, void *_arg)
+static int cpu_mid_compare(phandle nd, int instance, void *_arg)
 {
         int desired_mid = (int) _arg;
         int this_mid;
@@ -98,7 +97,7 @@ static int cpu_mid_compare(int nd, int instance, void *_arg)
         return -ENODEV;
 }
 
-int cpu_find_by_mid(int mid, int *prom_node)
+int cpu_find_by_mid(int mid, phandle *prom_node)
 {
         return __cpu_find_by(cpu_mid_compare, (void *)mid,
                              prom_node, NULL);
@@ -108,18 +107,19 @@ int cpu_find_by_mid(int mid, int *prom_node)
  * address (0-3).  This gives us the true hardware mid, which might have
  * some other bits set.  On 4d hardware and software mids are the same.
  */
-int cpu_get_hwmid(int prom_node)
+int cpu_get_hwmid(phandle prom_node)
 {
         return prom_getintdefault(prom_node, cpu_mid_prop(), -ENODEV);
 }
 
 void __init device_scan(void)
 {
-        prom_printf("Booting Linux...\n");
+        printk(KERN_NOTICE "Booting Linux...\n");
 
 #ifndef CONFIG_SMP
         {
-                int err, cpu_node;
+                phandle cpu_node;
+                int err;
                 err = cpu_find_by_instance(0, &cpu_node, NULL);
                 if (err) {
                         /* Probably a sun4e, Sun is trying to trick us ;-) */
@@ -132,7 +132,6 @@ void __init device_scan(void)
         }
 #endif /* !CONFIG_SMP */
 
-        cpu_probe();
         {
                 extern void auxio_probe(void);
                 extern void auxio_power_probe(void);
diff --git a/arch/sparc/kernel/ds.c b/arch/sparc/kernel/ds.c
index 4a700f4b79ce..dd1342c0a3be 100644
--- a/arch/sparc/kernel/ds.c
+++ b/arch/sparc/kernel/ds.c
@@ -497,7 +497,7 @@ static void dr_cpu_init_response(struct ds_data *resp, u64 req_num,
         tag->num_records = ncpus;
 
         i = 0;
-        for_each_cpu_mask(cpu, *mask) {
+        for_each_cpu(cpu, mask) {
                 ent[i].cpu = cpu;
                 ent[i].result = DR_CPU_RES_OK;
                 ent[i].stat = default_stat;
@@ -534,7 +534,7 @@ static int __cpuinit dr_cpu_configure(struct ds_info *dp,
         int resp_len, ncpus, cpu;
         unsigned long flags;
 
-        ncpus = cpus_weight(*mask);
+        ncpus = cpumask_weight(mask);
         resp_len = dr_cpu_size_response(ncpus);
         resp = kzalloc(resp_len, GFP_KERNEL);
         if (!resp)
@@ -547,7 +547,7 @@ static int __cpuinit dr_cpu_configure(struct ds_info *dp,
         mdesc_populate_present_mask(mask);
         mdesc_fill_in_cpu_data(mask);
 
-        for_each_cpu_mask(cpu, *mask) {
+        for_each_cpu(cpu, mask) {
                 int err;
 
                 printk(KERN_INFO "ds-%llu: Starting cpu %d...\n",
@@ -593,7 +593,7 @@ static int dr_cpu_unconfigure(struct ds_info *dp,
         int resp_len, ncpus, cpu;
         unsigned long flags;
 
-        ncpus = cpus_weight(*mask);
+        ncpus = cpumask_weight(mask);
         resp_len = dr_cpu_size_response(ncpus);
         resp = kzalloc(resp_len, GFP_KERNEL);
         if (!resp)
@@ -603,7 +603,7 @@ static int dr_cpu_unconfigure(struct ds_info *dp,
                              resp_len, ncpus, mask,
                              DR_CPU_STAT_UNCONFIGURED);
 
-        for_each_cpu_mask(cpu, *mask) {
+        for_each_cpu(cpu, mask) {
                 int err;
 
                 printk(KERN_INFO "ds-%llu: Shutting down cpu %d...\n",
@@ -649,13 +649,13 @@ static void __cpuinit dr_cpu_data(struct ds_info *dp,
 
         purge_dups(cpu_list, tag->num_records);
 
-        cpus_clear(mask);
+        cpumask_clear(&mask);
         for (i = 0; i < tag->num_records; i++) {
                 if (cpu_list[i] == CPU_SENTINEL)
                         continue;
 
                 if (cpu_list[i] < nr_cpu_ids)
-                        cpu_set(cpu_list[i], mask);
+                        cpumask_set_cpu(cpu_list[i], &mask);
         }
 
         if (tag->type == DR_CPU_CONFIGURE)
@@ -1218,7 +1218,7 @@ static int ds_remove(struct vio_dev *vdev)
         return 0;
 }
 
-static struct vio_device_id __initdata ds_match[] = {
+static const struct vio_device_id ds_match[] = {
         {
                 .type = "domain-services-port",
         },
diff --git a/arch/sparc/kernel/entry.S b/arch/sparc/kernel/entry.S
index 1504df8ddf70..f445e98463e6 100644
--- a/arch/sparc/kernel/entry.S
+++ b/arch/sparc/kernel/entry.S
@@ -229,7 +229,7 @@ real_irq_entry:
 #ifdef CONFIG_SMP
         .globl  patchme_maybe_smp_msg
 
-        cmp     %l7, 12
+        cmp     %l7, 11
 patchme_maybe_smp_msg:
         bgu     maybe_smp4m_msg
          nop
@@ -269,19 +269,22 @@ smp4m_ticker:
         /* Here is where we check for possible SMP IPI passed to us
          * on some level other than 15 which is the NMI and only used
          * for cross calls.  That has a separate entry point below.
+         *
+         * IPIs are sent on Level 12, 13 and 14. See IRQ_IPI_*.
          */
 maybe_smp4m_msg:
         GET_PROCESSOR4M_ID(o3)
         sethi   %hi(sun4m_irq_percpu), %l5
         sll     %o3, 2, %o3
         or      %l5, %lo(sun4m_irq_percpu), %o5
-        sethi   %hi(0x40000000), %o2
+        sethi   %hi(0x70000000), %o2    ! Check all soft-IRQs
         ld      [%o5 + %o3], %o1
         ld      [%o1 + 0x00], %o3       ! sun4m_irq_percpu[cpu]->pending
         andcc   %o3, %o2, %g0
         be,a    smp4m_ticker
          cmp    %l7, 14
-        st      %o2, [%o1 + 0x04]       ! sun4m_irq_percpu[cpu]->clear=0x40000000
+        /* Soft-IRQ IPI */
+        st      %o2, [%o1 + 0x04]       ! sun4m_irq_percpu[cpu]->clear=0x70000000
         WRITE_PAUSE
         ld      [%o1 + 0x00], %g0       ! sun4m_irq_percpu[cpu]->pending
         WRITE_PAUSE
@@ -290,9 +293,27 @@ maybe_smp4m_msg:
         WRITE_PAUSE
         wr      %l4, PSR_ET, %psr
         WRITE_PAUSE
-        call    smp_reschedule_irq
+        srl     %o3, 28, %o2            ! shift for simpler checks below
+maybe_smp4m_msg_check_single:
+        andcc   %o2, 0x1, %g0
+        beq,a   maybe_smp4m_msg_check_mask
+         andcc  %o2, 0x2, %g0
+        call    smp_call_function_single_interrupt
          nop
-
+        andcc   %o2, 0x2, %g0
+maybe_smp4m_msg_check_mask:
+        beq,a   maybe_smp4m_msg_check_resched
+         andcc  %o2, 0x4, %g0
+        call    smp_call_function_interrupt
+         nop
+        andcc   %o2, 0x4, %g0
+maybe_smp4m_msg_check_resched:
+        /* rescheduling is done in RESTORE_ALL regardless, but incr stats */
+        beq,a   maybe_smp4m_msg_out
+         nop
+        call    smp_resched_interrupt
+         nop
+maybe_smp4m_msg_out:
         RESTORE_ALL
 
         .align  4
@@ -401,18 +422,18 @@ linux_trap_ipi15_sun4d:
 1:      b,a     1b
 
 #ifdef CONFIG_SPARC_LEON
-
-        .globl  smpleon_ticker
-        /* SMP per-cpu ticker interrupts are handled specially. */
-smpleon_ticker:
+        .globl  smpleon_ipi
+        .extern leon_ipi_interrupt
+        /* SMP per-cpu IPI interrupts are handled specially. */
+smpleon_ipi:
         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
+        call    leonsmp_ipi_interrupt
+         add    %sp, STACKFRAME_SZ, %o1 ! pt_regs
         wr      %l0, PSR_ET, %psr
         WRITE_PAUSE
         RESTORE_ALL
@@ -801,7 +822,7 @@ vac_linesize_patch_32:		subcc	%l7, 32, %l7
         .globl  vac_hwflush_patch1_on, vac_hwflush_patch2_on
 
 /*
- * Ugly, but we cant use hardware flushing on the sun4 and we'd require
+ * Ugly, but we can't use hardware flushing on the sun4 and we'd require
  * two instructions (Anton)
  */
 vac_hwflush_patch1_on:          addcc   %l7, -PAGE_SIZE, %l7
@@ -851,7 +872,7 @@ sun4c_fault:
          sethi  %hi(~((1 << SUN4C_REAL_PGDIR_SHIFT) - 1)), %l4
 
         /* If the kernel references a bum kernel pointer, or a pte which
-         * points to a non existant page in ram, we will run this code
+         * points to a non existent page in ram, we will run this code
          * _forever_ and lock up the machine!!!!! So we must check for
          * this condition, the AC_SYNC_ERR bits are what we must examine.
          * Also a parity error would make this happen as well.  So we just
@@ -1283,7 +1304,7 @@ linux_syscall_trace:
         .globl  ret_from_fork
 ret_from_fork:
         call    schedule_tail
-         mov    %g3, %o0
+         ld     [%g3 + TI_TASK], %o0
         b       ret_sys_call
          ld     [%sp + STACKFRAME_SZ + PT_I0], %o0
 
@@ -1583,7 +1604,7 @@ restore_current:
         retl
          nop
 
-#ifdef CONFIG_PCI
+#ifdef CONFIG_PCIC_PCI
 #include <asm/pcic.h>
 
         .align  4
@@ -1629,7 +1650,7 @@ pcic_nmi_trap_patch:
          rd     %psr, %l0
         .word   0
 
-#endif /* CONFIG_PCI */
+#endif /* CONFIG_PCIC_PCI */
 
         .globl  flushw_all
 flushw_all:
diff --git a/arch/sparc/kernel/entry.h b/arch/sparc/kernel/entry.h
index c011b932bb17..d1f1361c4167 100644
--- a/arch/sparc/kernel/entry.h
+++ b/arch/sparc/kernel/entry.h
@@ -213,8 +213,8 @@ extern struct cheetah_err_info *cheetah_error_log;
 struct ino_bucket {
 /*0x00*/unsigned long __irq_chain_pa;
 
-        /* Virtual interrupt number assigned to this INO.  */
-/*0x08*/unsigned int __virt_irq;
+        /* Interrupt number assigned to this INO.  */
+/*0x08*/unsigned int __irq;
 /*0x0c*/unsigned int __pad;
 };
 
diff --git a/arch/sparc/kernel/head_32.S b/arch/sparc/kernel/head_32.S
index 21bb2590d4ae..587785759838 100644
--- a/arch/sparc/kernel/head_32.S
+++ b/arch/sparc/kernel/head_32.S
@@ -73,12 +73,11 @@ sun4e_notsup:
 
         /* The Sparc trap table, bootloader gives us control at _start. */
         __HEAD
-        .globl  start, _stext, _start, __stext
+        .globl  _stext, _start, __stext
         .globl  trapbase
 _start:   /* danger danger */
 __stext:
 _stext:
-start:
 trapbase:
 #ifdef CONFIG_SMP
 trapbase_cpu0:
@@ -811,31 +810,25 @@ 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)]
+                sethi   %hi(boot_cpu_id), %g2   ! boot-cpu index
 
-                rd     %asr17,%g1
-                srl    %g1,28,%g1
+#ifdef CONFIG_SMP
+                ldub    [%g2 + %lo(boot_cpu_id)], %g1
+                cmp     %g1, 0xff               ! unset means first CPU
+                bne     leon_smp_cpu_startup    ! continue only with master
+                 nop
+#endif
+                /* Get CPU-ID from most significant 4-bit of ASR17 */
+                rd     %asr17, %g1
+                srl    %g1, 28, %g1
 
-                cmp %g0,%g1
-                 beq sun4c_continue_boot         !continue with master
-                nop
+                /* Update boot_cpu_id only on boot cpu */
+                stub    %g1, [%g2 + %lo(boot_cpu_id)]
 
-                ba leon_smp_cpu_startup
-                 nop
-#else
                 ba sun4c_continue_boot
                  nop
 #endif
-#endif
                 set     cputypval, %o2
                 ldub    [%o2 + 0x4], %l1
 
@@ -894,9 +887,6 @@ sun4d_init:
         sta     %g4, [%g0] ASI_M_VIKING_TMP1
         sethi   %hi(boot_cpu_id), %g5
         stb     %g4, [%g5 + %lo(boot_cpu_id)]
-        sll     %g4, 2, %g4
-        sethi   %hi(boot_cpu_id4), %g5
-        stb     %g4, [%g5 + %lo(boot_cpu_id4)]
 #endif
 
         /* Fall through to sun4m_init */
@@ -1025,14 +1015,28 @@ sun4c_continue_boot:
                 bl      1b
                  add    %o0, 0x1, %o0
 
+                /* If boot_cpu_id has not been setup by machine specific
+                 * init-code above we default it to zero.
+                 */
+                sethi   %hi(boot_cpu_id), %g2
+                ldub    [%g2 + %lo(boot_cpu_id)], %g3
+                cmp     %g3, 0xff
+                bne     1f
+                 nop
+                mov     %g0, %g3
+                stub    %g3, [%g2 + %lo(boot_cpu_id)]
+
+1:              /* boot_cpu_id set. calculate boot_cpu_id4 = boot_cpu_id*4 */
+                sll     %g3, 2, %g3
+                sethi   %hi(boot_cpu_id4), %g2
+                stub    %g3, [%g2 + %lo(boot_cpu_id4)]
+
                 /* Initialize the uwinmask value for init task just in case.
                  * But first make current_set[boot_cpu_id] point to something useful.
                  */
                 set     init_thread_union, %g6
                 set     current_set, %g2
 #ifdef CONFIG_SMP
-                sethi   %hi(boot_cpu_id4), %g3
-                ldub    [%g3 + %lo(boot_cpu_id4)], %g3
                 st      %g6, [%g2]
                 add     %g2, %g3, %g2
 #endif
diff --git a/arch/sparc/kernel/head_64.S b/arch/sparc/kernel/head_64.S
index f8f21050448b..aa594c792d19 100644
--- a/arch/sparc/kernel/head_64.S
+++ b/arch/sparc/kernel/head_64.S
@@ -85,7 +85,7 @@ sparc_ramdisk_image64:
 sparc64_boot:
         mov     %o4, %l7
 
-        /* We need to remap the kernel.  Use position independant
+        /* We need to remap the kernel.  Use position independent
          * code to remap us to KERNBASE.
          *
          * SILO can invoke us with 32-bit address masking enabled,
diff --git a/arch/sparc/kernel/init_task.c b/arch/sparc/kernel/init_task.c
index 5fe3d65581f7..35f141a9f506 100644
--- a/arch/sparc/kernel/init_task.c
+++ b/arch/sparc/kernel/init_task.c
@@ -15,7 +15,7 @@ EXPORT_SYMBOL(init_task);
 
 /* .text section in head.S is aligned at 8k boundary and this gets linked
  * right after that so that the init_thread_union is aligned properly as well.
- * If this is not aligned on a 8k boundry, then you should change code
+ * If this is not aligned on a 8k boundary, then you should change code
  * in etrap.S which assumes it.
  */
 union thread_union init_thread_union __init_task_data =
diff --git a/arch/sparc/kernel/iommu.c b/arch/sparc/kernel/iommu.c
index 47977a77f6c6..6f01e8c83197 100644
--- a/arch/sparc/kernel/iommu.c
+++ b/arch/sparc/kernel/iommu.c
@@ -255,10 +255,9 @@ static inline iopte_t *alloc_npages(struct device *dev, struct iommu *iommu,
 static int iommu_alloc_ctx(struct iommu *iommu)
 {
         int lowest = iommu->ctx_lowest_free;
-        int sz = IOMMU_NUM_CTXS - lowest;
-        int n = find_next_zero_bit(iommu->ctx_bitmap, sz, lowest);
+        int n = find_next_zero_bit(iommu->ctx_bitmap, IOMMU_NUM_CTXS, lowest);
 
-        if (unlikely(n == sz)) {
+        if (unlikely(n == IOMMU_NUM_CTXS)) {
                 n = find_next_zero_bit(iommu->ctx_bitmap, lowest, 1);
                 if (unlikely(n == lowest)) {
                         printk(KERN_WARNING "IOMMU: Ran out of contexts.\n");
@@ -334,13 +333,10 @@ static void dma_4u_free_coherent(struct device *dev, size_t size,
                                  void *cpu, dma_addr_t dvma)
 {
         struct iommu *iommu;
-        iopte_t *iopte;
         unsigned long flags, order, npages;
 
         npages = IO_PAGE_ALIGN(size) >> IO_PAGE_SHIFT;
         iommu = dev->archdata.iommu;
-        iopte = iommu->page_table +
-                ((dvma - iommu->page_table_map_base) >> IO_PAGE_SHIFT);
 
         spin_lock_irqsave(&iommu->lock, flags);
 
diff --git a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c
index 41f7e4e0f72a..1c9c80a1a86a 100644
--- a/arch/sparc/kernel/ioport.c
+++ b/arch/sparc/kernel/ioport.c
@@ -50,10 +50,19 @@
 #include <asm/io-unit.h>
 #include <asm/leon.h>
 
-#ifdef CONFIG_SPARC_LEON
-#define mmu_inval_dma_area(p, l) leon_flush_dcache_all()
+/* This function must make sure that caches and memory are coherent after DMA
+ * On LEON systems without cache snooping it flushes the entire D-CACHE.
+ */
+#ifndef CONFIG_SPARC_LEON
+static inline void dma_make_coherent(unsigned long pa, unsigned long len)
+{
+}
 #else
-#define mmu_inval_dma_area(p, l)        /* Anton pulled it out for 2.4.0-xx */
+static inline void dma_make_coherent(unsigned long pa, unsigned long len)
+{
+        if (!sparc_leon3_snooping_enabled())
+                leon_flush_dcache_all();
+}
 #endif
 
 static struct resource *_sparc_find_resource(struct resource *r,
@@ -254,7 +263,7 @@ static void *sbus_alloc_coherent(struct device *dev, size_t len,
                                  dma_addr_t *dma_addrp, gfp_t gfp)
 {
         struct platform_device *op = to_platform_device(dev);
-        unsigned long len_total = (len + PAGE_SIZE-1) & PAGE_MASK;
+        unsigned long len_total = PAGE_ALIGN(len);
         unsigned long va;
         struct resource *res;
         int order;
@@ -280,7 +289,7 @@ static void *sbus_alloc_coherent(struct device *dev, size_t len,
                 printk("sbus_alloc_consistent: cannot occupy 0x%lx", len_total);
                 goto err_nova;
         }
-        mmu_inval_dma_area(va, len_total);
+
         // XXX The mmu_map_dma_area does this for us below, see comments.
         // sparc_mapiorange(0, virt_to_phys(va), res->start, len_total);
         /*
@@ -297,9 +306,9 @@ static void *sbus_alloc_coherent(struct device *dev, size_t len,
 err_noiommu:
         release_resource(res);
 err_nova:
-        free_pages(va, order);
-err_nomem:
         kfree(res);
+err_nomem:
+        free_pages(va, order);
 err_nopages:
         return NULL;
 }
@@ -321,7 +330,7 @@ static void sbus_free_coherent(struct device *dev, size_t n, void *p,
                 return;
         }
 
-        n = (n + PAGE_SIZE-1) & PAGE_MASK;
+        n = PAGE_ALIGN(n);
         if ((res->end-res->start)+1 != n) {
                 printk("sbus_free_consistent: region 0x%lx asked 0x%zx\n",
                     (long)((res->end-res->start)+1), n);
@@ -331,7 +340,6 @@ static void sbus_free_coherent(struct device *dev, size_t n, void *p,
         release_resource(res);
         kfree(res);
 
-        /* mmu_inval_dma_area(va, n); */ /* it's consistent, isn't it */
         pgv = virt_to_page(p);
         mmu_unmap_dma_area(dev, ba, n);
 
@@ -408,9 +416,6 @@ struct dma_map_ops sbus_dma_ops = {
         .sync_sg_for_device     = sbus_sync_sg_for_device,
 };
 
-struct dma_map_ops *dma_ops = &sbus_dma_ops;
-EXPORT_SYMBOL(dma_ops);
-
 static int __init sparc_register_ioport(void)
 {
         register_proc_sparc_ioport();
@@ -422,7 +427,9 @@ arch_initcall(sparc_register_ioport);
 
 #endif /* CONFIG_SBUS */
 
-#ifdef CONFIG_PCI
+
+/* LEON reuses PCI DMA ops */
+#if defined(CONFIG_PCI) || defined(CONFIG_SPARC_LEON)
 
 /* Allocate and map kernel buffer using consistent mode DMA for a device.
  * hwdev should be valid struct pci_dev pointer for PCI devices.
@@ -430,8 +437,8 @@ arch_initcall(sparc_register_ioport);
 static void *pci32_alloc_coherent(struct device *dev, size_t len,
                                   dma_addr_t *pba, gfp_t gfp)
 {
-        unsigned long len_total = (len + PAGE_SIZE-1) & PAGE_MASK;
-        unsigned long va;
+        unsigned long len_total = PAGE_ALIGN(len);
+        void *va;
         struct resource *res;
         int order;
 
@@ -443,34 +450,33 @@ static void *pci32_alloc_coherent(struct device *dev, size_t len,
         }
 
         order = get_order(len_total);
-        va = __get_free_pages(GFP_KERNEL, order);
-        if (va == 0) {
+        va = (void *) __get_free_pages(GFP_KERNEL, order);
+        if (va == NULL) {
                 printk("pci_alloc_consistent: no %ld pages\n", len_total>>PAGE_SHIFT);
-                return NULL;
+                goto err_nopages;
         }
 
         if ((res = kzalloc(sizeof(struct resource), GFP_KERNEL)) == NULL) {
-                free_pages(va, order);
                 printk("pci_alloc_consistent: no core\n");
-                return NULL;
+                goto err_nomem;
         }
 
         if (allocate_resource(&_sparc_dvma, res, len_total,
             _sparc_dvma.start, _sparc_dvma.end, PAGE_SIZE, NULL, NULL) != 0) {
                 printk("pci_alloc_consistent: cannot occupy 0x%lx", len_total);
-                free_pages(va, order);
-                kfree(res);
-                return NULL;
+                goto err_nova;
         }
-        mmu_inval_dma_area(va, len_total);
-#if 0
-/* P3 */ printk("pci_alloc_consistent: kva %lx uncva %lx phys %lx size %lx\n",
-  (long)va, (long)res->start, (long)virt_to_phys(va), len_total);
-#endif
         sparc_mapiorange(0, virt_to_phys(va), res->start, len_total);
 
         *pba = virt_to_phys(va); /* equals virt_to_bus (R.I.P.) for us. */
         return (void *) res->start;
+
+err_nova:
+        kfree(res);
+err_nomem:
+        free_pages((unsigned long)va, order);
+err_nopages:
+        return NULL;
 }
 
 /* Free and unmap a consistent DMA buffer.
@@ -485,7 +491,6 @@ static void pci32_free_coherent(struct device *dev, size_t n, void *p,
                                 dma_addr_t ba)
 {
         struct resource *res;
-        unsigned long pgp;
 
         if ((res = _sparc_find_resource(&_sparc_dvma,
             (unsigned long)p)) == NULL) {
@@ -498,21 +503,19 @@ static void pci32_free_coherent(struct device *dev, size_t n, void *p,
                 return;
         }
 
-        n = (n + PAGE_SIZE-1) & PAGE_MASK;
+        n = PAGE_ALIGN(n);
         if ((res->end-res->start)+1 != n) {
                 printk("pci_free_consistent: region 0x%lx asked 0x%lx\n",
                     (long)((res->end-res->start)+1), (long)n);
                 return;
         }
 
-        pgp = (unsigned long) phys_to_virt(ba); /* bus_to_virt actually */
-        mmu_inval_dma_area(pgp, n);
+        dma_make_coherent(ba, n);
         sparc_unmapiorange((unsigned long)p, n);
 
         release_resource(res);
         kfree(res);
-
-        free_pages(pgp, get_order(n));
+        free_pages((unsigned long)phys_to_virt(ba), get_order(n));
 }
 
 /*
@@ -527,6 +530,13 @@ static dma_addr_t pci32_map_page(struct device *dev, struct page *page,
         return page_to_phys(page) + offset;
 }
 
+static void pci32_unmap_page(struct device *dev, dma_addr_t ba, size_t size,
+                             enum dma_data_direction dir, struct dma_attrs *attrs)
+{
+        if (dir != PCI_DMA_TODEVICE)
+                dma_make_coherent(ba, PAGE_ALIGN(size));
+}
+
 /* Map a set of buffers described by scatterlist in streaming
  * mode for DMA.  This is the scather-gather version of the
  * above pci_map_single interface.  Here the scatter gather list
@@ -551,8 +561,7 @@ static int pci32_map_sg(struct device *device, struct scatterlist *sgl,
 
         /* IIep is write-through, not flushing. */
         for_each_sg(sgl, sg, nents, n) {
-                BUG_ON(page_address(sg_page(sg)) == NULL);
-                sg->dma_address = virt_to_phys(sg_virt(sg));
+                sg->dma_address = sg_phys(sg);
                 sg->dma_length = sg->length;
         }
         return nents;
@@ -571,10 +580,7 @@ static void pci32_unmap_sg(struct device *dev, struct scatterlist *sgl,
 
         if (dir != PCI_DMA_TODEVICE) {
                 for_each_sg(sgl, sg, nents, n) {
-                        BUG_ON(page_address(sg_page(sg)) == NULL);
-                        mmu_inval_dma_area(
-                            (unsigned long) page_address(sg_page(sg)),
-                            (sg->length + PAGE_SIZE-1) & PAGE_MASK);
+                        dma_make_coherent(sg_phys(sg), PAGE_ALIGN(sg->length));
                 }
         }
 }
@@ -593,8 +599,7 @@ static void pci32_sync_single_for_cpu(struct device *dev, dma_addr_t ba,
                                       size_t size, enum dma_data_direction dir)
 {
         if (dir != PCI_DMA_TODEVICE) {
-                mmu_inval_dma_area((unsigned long)phys_to_virt(ba),
-                    (size + PAGE_SIZE-1) & PAGE_MASK);
+                dma_make_coherent(ba, PAGE_ALIGN(size));
         }
 }
 
@@ -602,8 +607,7 @@ static void pci32_sync_single_for_device(struct device *dev, dma_addr_t ba,
                                          size_t size, enum dma_data_direction dir)
 {
         if (dir != PCI_DMA_TODEVICE) {
-                mmu_inval_dma_area((unsigned long)phys_to_virt(ba),
-                    (size + PAGE_SIZE-1) & PAGE_MASK);
+                dma_make_coherent(ba, PAGE_ALIGN(size));
         }
 }
 
@@ -621,10 +625,7 @@ static void pci32_sync_sg_for_cpu(struct device *dev, struct scatterlist *sgl,
 
         if (dir != PCI_DMA_TODEVICE) {
                 for_each_sg(sgl, sg, nents, n) {
-                        BUG_ON(page_address(sg_page(sg)) == NULL);
-                        mmu_inval_dma_area(
-                            (unsigned long) page_address(sg_page(sg)),
-                            (sg->length + PAGE_SIZE-1) & PAGE_MASK);
+                        dma_make_coherent(sg_phys(sg), PAGE_ALIGN(sg->length));
                 }
         }
 }
@@ -637,10 +638,7 @@ static void pci32_sync_sg_for_device(struct device *device, struct scatterlist *
 
         if (dir != PCI_DMA_TODEVICE) {
                 for_each_sg(sgl, sg, nents, n) {
-                        BUG_ON(page_address(sg_page(sg)) == NULL);
-                        mmu_inval_dma_area(
-                            (unsigned long) page_address(sg_page(sg)),
-                            (sg->length + PAGE_SIZE-1) & PAGE_MASK);
+                        dma_make_coherent(sg_phys(sg), PAGE_ALIGN(sg->length));
                 }
         }
 }
@@ -649,6 +647,7 @@ struct dma_map_ops pci32_dma_ops = {
         .alloc_coherent         = pci32_alloc_coherent,
         .free_coherent          = pci32_free_coherent,
         .map_page               = pci32_map_page,
+        .unmap_page             = pci32_unmap_page,
         .map_sg                 = pci32_map_sg,
         .unmap_sg               = pci32_unmap_sg,
         .sync_single_for_cpu    = pci32_sync_single_for_cpu,
@@ -658,7 +657,16 @@ struct dma_map_ops pci32_dma_ops = {
 };
 EXPORT_SYMBOL(pci32_dma_ops);
 
-#endif /* CONFIG_PCI */
+#endif /* CONFIG_PCI || CONFIG_SPARC_LEON */
+
+#ifdef CONFIG_SPARC_LEON
+struct dma_map_ops *dma_ops = &pci32_dma_ops;
+#elif defined(CONFIG_SBUS)
+struct dma_map_ops *dma_ops = &sbus_dma_ops;
+#endif
+
+EXPORT_SYMBOL(dma_ops);
+
 
 /*
  * Return whether the given PCI device DMA address mask can be
@@ -717,7 +725,7 @@ static const struct file_operations sparc_io_proc_fops = {
 static struct resource *_sparc_find_resource(struct resource *root,
                                              unsigned long hit)
 {
-        struct resource *tmp;
+        struct resource *tmp;
 
         for (tmp = root->child; tmp != 0; tmp = tmp->sibling) {
                 if (tmp->start <= hit && tmp->end >= hit)
diff --git a/arch/sparc/kernel/irq.h b/arch/sparc/kernel/irq.h
index db7513881530..100b9c204e78 100644
--- a/arch/sparc/kernel/irq.h
+++ b/arch/sparc/kernel/irq.h
@@ -1,5 +1,62 @@
+#include <linux/platform_device.h>
+
 #include <asm/btfixup.h>
 
+struct irq_bucket {
+        struct irq_bucket *next;
+        unsigned int real_irq;
+        unsigned int irq;
+        unsigned int pil;
+};
+
+#define SUN4D_MAX_BOARD 10
+#define SUN4D_MAX_IRQ ((SUN4D_MAX_BOARD + 2) << 5)
+
+/* Map between the irq identifier used in hw to the
+ * irq_bucket. The map is sufficient large to hold
+ * the sun4d hw identifiers.
+ */
+extern struct irq_bucket *irq_map[SUN4D_MAX_IRQ];
+
+
+/* sun4m specific type definitions */
+
+/* This maps direct to CPU specific interrupt registers */
+struct sun4m_irq_percpu {
+        u32     pending;
+        u32     clear;
+        u32     set;
+};
+
+/* This maps direct to global interrupt registers */
+struct sun4m_irq_global {
+        u32     pending;
+        u32     mask;
+        u32     mask_clear;
+        u32     mask_set;
+        u32     interrupt_target;
+};
+
+extern struct sun4m_irq_percpu __iomem *sun4m_irq_percpu[SUN4M_NCPUS];
+extern struct sun4m_irq_global __iomem *sun4m_irq_global;
+
+/*
+ * Platform specific irq configuration
+ * The individual platforms assign their platform
+ * specifics in their init functions.
+ */
+struct sparc_irq_config {
+        void (*init_timers)(irq_handler_t);
+        unsigned int (*build_device_irq)(struct platform_device *op,
+                                         unsigned int real_irq);
+};
+extern struct sparc_irq_config sparc_irq_config;
+
+unsigned int irq_alloc(unsigned int real_irq, unsigned int pil);
+void irq_link(unsigned int irq);
+void irq_unlink(unsigned int irq);
+void handler_irq(unsigned int pil, struct pt_regs *regs);
+
 /* Dave Redman (djhr@tadpole.co.uk)
  * changed these to function pointers.. it saves cycles and will allow
  * the irq dependencies to be split into different files at a later date
@@ -8,33 +65,9 @@
  * Changed these to btfixup entities... It saves cycles :)
  */
 
-BTFIXUPDEF_CALL(void, disable_irq, unsigned int)
-BTFIXUPDEF_CALL(void, enable_irq, unsigned int)
-BTFIXUPDEF_CALL(void, disable_pil_irq, unsigned int)
-BTFIXUPDEF_CALL(void, enable_pil_irq, unsigned int)
 BTFIXUPDEF_CALL(void, clear_clock_irq, void)
 BTFIXUPDEF_CALL(void, load_profile_irq, int, unsigned int)
 
-static inline void __disable_irq(unsigned int irq)
-{
-        BTFIXUP_CALL(disable_irq)(irq);
-}
-
-static inline void __enable_irq(unsigned int irq)
-{
-        BTFIXUP_CALL(enable_irq)(irq);
-}
-
-static inline void disable_pil_irq(unsigned int irq)
-{
-        BTFIXUP_CALL(disable_pil_irq)(irq);
-}
-
-static inline void enable_pil_irq(unsigned int irq)
-{
-        BTFIXUP_CALL(enable_pil_irq)(irq);
-}
-
 static inline void clear_clock_irq(void)
 {
         BTFIXUP_CALL(clear_clock_irq)();
@@ -45,12 +78,6 @@ static inline void load_profile_irq(int cpu, int limit)
         BTFIXUP_CALL(load_profile_irq)(cpu, limit);
 }
 
-extern void (*sparc_init_timers)(irq_handler_t lvl10_irq);
-
-extern void claim_ticker14(irq_handler_t irq_handler,
-                           int irq,
-                           unsigned int timeout);
-
 #ifdef CONFIG_SMP
 BTFIXUPDEF_CALL(void, set_cpu_int, int, int)
 BTFIXUPDEF_CALL(void, clear_cpu_int, int, int)
@@ -59,4 +86,10 @@ BTFIXUPDEF_CALL(void, set_irq_udt, int)
 #define set_cpu_int(cpu,level) BTFIXUP_CALL(set_cpu_int)(cpu,level)
 #define clear_cpu_int(cpu,level) BTFIXUP_CALL(clear_cpu_int)(cpu,level)
 #define set_irq_udt(cpu) BTFIXUP_CALL(set_irq_udt)(cpu)
+
+/* All SUN4D IPIs are sent on this IRQ, may be shared with hard IRQs */
+#define SUN4D_IPI_IRQ 14
+
+extern void sun4d_ipi_interrupt(void);
+
 #endif
diff --git a/arch/sparc/kernel/irq_32.c b/arch/sparc/kernel/irq_32.c
index e1af43728329..9b89d842913c 100644
--- a/arch/sparc/kernel/irq_32.c
+++ b/arch/sparc/kernel/irq_32.c
@@ -1,8 +1,8 @@
 /*
- *  arch/sparc/kernel/irq.c:  Interrupt request handling routines. On the
- *                            Sparc the IRQs are basically 'cast in stone'
- *                            and you are supposed to probe the prom's device
- *                            node trees to find out who's got which IRQ.
+ * Interrupt request handling routines. On the
+ * Sparc the IRQs are basically 'cast in stone'
+ * and you are supposed to probe the prom's device
+ * node trees to find out who's got which IRQ.
  *
  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  *  Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
@@ -11,40 +11,12 @@
  *  Copyright (C) 1998-2000 Anton Blanchard (anton@samba.org)
  */
 
-#include <linux/module.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/errno.h>
-#include <linux/linkage.h>
 #include <linux/kernel_stat.h>
-#include <linux/signal.h>
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-#include <linux/random.h>
-#include <linux/init.h>
-#include <linux/smp.h>
-#include <linux/delay.h>
-#include <linux/threads.h>
-#include <linux/spinlock.h>
 #include <linux/seq_file.h>
 
-#include <asm/ptrace.h>
-#include <asm/processor.h>
-#include <asm/system.h>
-#include <asm/psr.h>
-#include <asm/smp.h>
-#include <asm/vaddrs.h>
-#include <asm/timer.h>
-#include <asm/openprom.h>
-#include <asm/oplib.h>
-#include <asm/traps.h>
-#include <asm/irq.h>
-#include <asm/io.h>
-#include <asm/pgalloc.h>
-#include <asm/pgtable.h>
-#include <asm/pcic.h>
 #include <asm/cacheflush.h>
-#include <asm/irq_regs.h>
+#include <asm/cpudata.h>
+#include <asm/pcic.h>
 #include <asm/leon.h>
 
 #include "kernel.h"
@@ -57,7 +29,11 @@
 #define SMP_NOP2
 #define SMP_NOP3
 #endif /* SMP */
-unsigned long __raw_local_irq_save(void)
+
+/* platform specific irq setup */
+struct sparc_irq_config sparc_irq_config;
+
+unsigned long arch_local_irq_save(void)
 {
         unsigned long retval;
         unsigned long tmp;
@@ -74,8 +50,9 @@ unsigned long __raw_local_irq_save(void)
 
         return retval;
 }
+EXPORT_SYMBOL(arch_local_irq_save);
 
-void raw_local_irq_enable(void)
+void arch_local_irq_enable(void)
 {
         unsigned long tmp;
 
@@ -89,8 +66,9 @@ void raw_local_irq_enable(void)
                 : "i" (PSR_PIL)
                 : "memory");
 }
+EXPORT_SYMBOL(arch_local_irq_enable);
 
-void raw_local_irq_restore(unsigned long old_psr)
+void arch_local_irq_restore(unsigned long old_psr)
 {
         unsigned long tmp;
 
@@ -105,10 +83,7 @@ void raw_local_irq_restore(unsigned long old_psr)
                 : "i" (PSR_PIL), "r" (old_psr)
                 : "memory");
 }
-
-EXPORT_SYMBOL(__raw_local_irq_save);
-EXPORT_SYMBOL(raw_local_irq_enable);
-EXPORT_SYMBOL(raw_local_irq_restore);
+EXPORT_SYMBOL(arch_local_irq_restore);
 
 /*
  * Dave Redman (djhr@tadpole.co.uk)
@@ -127,309 +102,185 @@ EXPORT_SYMBOL(raw_local_irq_restore);
  * directed CPU interrupts using the existing enable/disable irq code
  * with tweaks.
  *
+ * Sun4d complicates things even further.  IRQ numbers are arbitrary
+ * 32-bit values in that case.  Since this is similar to sparc64,
+ * we adopt a virtual IRQ numbering scheme as is done there.
+ * Virutal interrupt numbers are allocated by build_irq().  So NR_IRQS
+ * just becomes a limit of how many interrupt sources we can handle in
+ * a single system.  Even fully loaded SS2000 machines top off at
+ * about 32 interrupt sources or so, therefore a NR_IRQS value of 64
+ * is more than enough.
+  *
+ * We keep a map of per-PIL enable interrupts.  These get wired
+ * up via the irq_chip->startup() method which gets invoked by
+ * the generic IRQ layer during request_irq().
  */
 
-static void irq_panic(void)
-{
-    extern char *cputypval;
-    prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval);
-    prom_halt();
-}
 
-void (*sparc_init_timers)(irq_handler_t ) =
-    (void (*)(irq_handler_t )) irq_panic;
+/* Table of allocated irqs. Unused entries has irq == 0 */
+static struct irq_bucket irq_table[NR_IRQS];
+/* Protect access to irq_table */
+static DEFINE_SPINLOCK(irq_table_lock);
 
-/*
- * Dave Redman (djhr@tadpole.co.uk)
- *
- * There used to be extern calls and hard coded values here.. very sucky!
- * instead, because some of the devices attach very early, I do something
- * equally sucky but at least we'll never try to free statically allocated
- * space or call kmalloc before kmalloc_init :(.
- * 
- * In fact it's the timer10 that attaches first.. then timer14
- * then kmalloc_init is called.. then the tty interrupts attach.
- * hmmm....
- *
- */
-#define MAX_STATIC_ALLOC        4
-struct irqaction static_irqaction[MAX_STATIC_ALLOC];
-int static_irq_count;
-
-static struct {
-        struct irqaction *action;
-        int flags;
-} sparc_irq[NR_IRQS];
-#define SPARC_IRQ_INPROGRESS 1
+/* Map between the irq identifier used in hw to the irq_bucket. */
+struct irq_bucket *irq_map[SUN4D_MAX_IRQ];
+/* Protect access to irq_map */
+static DEFINE_SPINLOCK(irq_map_lock);
 
-/* Used to protect the IRQ action lists */
-DEFINE_SPINLOCK(irq_action_lock);
-
-int show_interrupts(struct seq_file *p, void *v)
+/* Allocate a new irq from the irq_table */
+unsigned int irq_alloc(unsigned int real_irq, unsigned int pil)
 {
-        int i = *(loff_t *) v;
-        struct irqaction * action;
         unsigned long flags;
-#ifdef CONFIG_SMP
-        int j;
-#endif
+        unsigned int i;
 
-        if (sparc_cpu_model == sun4d) {
-                extern int show_sun4d_interrupts(struct seq_file *, void *);
-                
-                return show_sun4d_interrupts(p, v);
+        spin_lock_irqsave(&irq_table_lock, flags);
+        for (i = 1; i < NR_IRQS; i++) {
+                if (irq_table[i].real_irq == real_irq && irq_table[i].pil == pil)
+                        goto found;
         }
-        spin_lock_irqsave(&irq_action_lock, flags);
+
+        for (i = 1; i < NR_IRQS; i++) {
+                if (!irq_table[i].irq)
+                        break;
+        }
+
         if (i < NR_IRQS) {
-                action = sparc_irq[i].action;
-                if (!action) 
-                        goto out_unlock;
-                seq_printf(p, "%3d: ", i);
-#ifndef CONFIG_SMP
-                seq_printf(p, "%10u ", kstat_irqs(i));
-#else
-                for_each_online_cpu(j) {
-                        seq_printf(p, "%10u ",
-                                    kstat_cpu(j).irqs[i]);
-                }
-#endif
-                seq_printf(p, " %c %s",
-                        (action->flags & IRQF_DISABLED) ? '+' : ' ',
-                        action->name);
-                for (action=action->next; action; action = action->next) {
-                        seq_printf(p, ",%s %s",
-                                (action->flags & IRQF_DISABLED) ? " +" : "",
-                                action->name);
-                }
-                seq_putc(p, '\n');
+                irq_table[i].real_irq = real_irq;
+                irq_table[i].irq = i;
+                irq_table[i].pil = pil;
+        } else {
+                printk(KERN_ERR "IRQ: Out of virtual IRQs.\n");
+                i = 0;
         }
-out_unlock:
-        spin_unlock_irqrestore(&irq_action_lock, flags);
-        return 0;
+found:
+        spin_unlock_irqrestore(&irq_table_lock, flags);
+
+        return i;
 }
 
-void free_irq(unsigned int irq, void *dev_id)
+/* Based on a single pil handler_irq may need to call several
+ * interrupt handlers. Use irq_map as entry to irq_table,
+ * and let each entry in irq_table point to the next entry.
+ */
+void irq_link(unsigned int irq)
 {
-        struct irqaction * action;
-        struct irqaction **actionp;
-        unsigned long flags;
-        unsigned int cpu_irq;
-        
-        if (sparc_cpu_model == sun4d) {
-                extern void sun4d_free_irq(unsigned int, void *);
-                
-                sun4d_free_irq(irq, dev_id);
-                return;
-        }
-        cpu_irq = irq & (NR_IRQS - 1);
-        if (cpu_irq > 14) {  /* 14 irq levels on the sparc */
-                printk("Trying to free bogus IRQ %d\n", irq);
-                return;
-        }
-
-        spin_lock_irqsave(&irq_action_lock, flags);
+        struct irq_bucket *p;
+        unsigned long flags;
+        unsigned int pil;
 
-        actionp = &sparc_irq[cpu_irq].action;
-        action = *actionp;
+        BUG_ON(irq >= NR_IRQS);
 
-        if (!action->handler) {
-                printk("Trying to free free IRQ%d\n",irq);
-                goto out_unlock;
-        }
-        if (dev_id) {
-                for (; action; action = action->next) {
-                        if (action->dev_id == dev_id)
-                                break;
-                        actionp = &action->next;
-                }
-                if (!action) {
-                        printk("Trying to free free shared IRQ%d\n",irq);
-                        goto out_unlock;
-                }
-        } else if (action->flags & IRQF_SHARED) {
-                printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
-                goto out_unlock;
-        }
-        if (action->flags & SA_STATIC_ALLOC)
-        {
-                /* This interrupt is marked as specially allocated
-                 * so it is a bad idea to free it.
-                 */
-                printk("Attempt to free statically allocated IRQ%d (%s)\n",
-                       irq, action->name);
-                goto out_unlock;
-        }
+        spin_lock_irqsave(&irq_map_lock, flags);
 
-        *actionp = action->next;
+        p = &irq_table[irq];
+        pil = p->pil;
+        BUG_ON(pil > SUN4D_MAX_IRQ);
+        p->next = irq_map[pil];
+        irq_map[pil] = p;
 
-        spin_unlock_irqrestore(&irq_action_lock, flags);
+        spin_unlock_irqrestore(&irq_map_lock, flags);
+}
 
-        synchronize_irq(irq);
+void irq_unlink(unsigned int irq)
+{
+        struct irq_bucket *p, **pnext;
+        unsigned long flags;
 
-        spin_lock_irqsave(&irq_action_lock, flags);
+        BUG_ON(irq >= NR_IRQS);
 
-        kfree(action);
+        spin_lock_irqsave(&irq_map_lock, flags);
 
-        if (!sparc_irq[cpu_irq].action)
-                __disable_irq(irq);
+        p = &irq_table[irq];
+        BUG_ON(p->pil > SUN4D_MAX_IRQ);
+        pnext = &irq_map[p->pil];
+        while (*pnext != p)
+                pnext = &(*pnext)->next;
+        *pnext = p->next;
 
-out_unlock:
-        spin_unlock_irqrestore(&irq_action_lock, flags);
+        spin_unlock_irqrestore(&irq_map_lock, flags);
 }
 
-EXPORT_SYMBOL(free_irq);
 
-/*
- * This is called when we want to synchronize with
- * interrupts. We may for example tell a device to
- * stop sending interrupts: but to make sure there
- * are no interrupts that are executing on another
- * CPU we need to call this function.
- */
-#ifdef CONFIG_SMP
-void synchronize_irq(unsigned int irq)
+/* /proc/interrupts printing */
+int arch_show_interrupts(struct seq_file *p, int prec)
 {
-        unsigned int cpu_irq;
-
-        cpu_irq = irq & (NR_IRQS - 1);
-        while (sparc_irq[cpu_irq].flags & SPARC_IRQ_INPROGRESS)
-                cpu_relax();
-}
-EXPORT_SYMBOL(synchronize_irq);
-#endif /* SMP */
+        int j;
 
-void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
-{
-        int i;
-        struct irqaction * action;
-        unsigned int cpu_irq;
-        
-        cpu_irq = irq & (NR_IRQS - 1);
-        action = sparc_irq[cpu_irq].action;
-
-        printk("IO device interrupt, irq = %d\n", irq);
-        printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc, 
-                    regs->npc, regs->u_regs[14]);
-        if (action) {
-                printk("Expecting: ");
-                for (i = 0; i < 16; i++)
-                        if (action->handler)
-                                printk("[%s:%d:0x%x] ", action->name,
-                                       (int) i, (unsigned int) action->handler);
-        }
-        printk("AIEEE\n");
-        panic("bogus interrupt received");
+#ifdef CONFIG_SMP
+        seq_printf(p, "RES: ");
+        for_each_online_cpu(j)
+                seq_printf(p, "%10u ", cpu_data(j).irq_resched_count);
+        seq_printf(p, "     IPI rescheduling interrupts\n");
+        seq_printf(p, "CAL: ");
+        for_each_online_cpu(j)
+                seq_printf(p, "%10u ", cpu_data(j).irq_call_count);
+        seq_printf(p, "     IPI function call interrupts\n");
+#endif
+        seq_printf(p, "NMI: ");
+        for_each_online_cpu(j)
+                seq_printf(p, "%10u ", cpu_data(j).counter);
+        seq_printf(p, "     Non-maskable interrupts\n");
+        return 0;
 }
 
-void handler_irq(int irq, struct pt_regs * regs)
+void handler_irq(unsigned int pil, struct pt_regs *regs)
 {
         struct pt_regs *old_regs;
-        struct irqaction * action;
-        int cpu = smp_processor_id();
-#ifdef CONFIG_SMP
-        extern void smp4m_irq_rotate(int cpu);
-#endif
+        struct irq_bucket *p;
 
+        BUG_ON(pil > 15);
         old_regs = set_irq_regs(regs);
         irq_enter();
-        disable_pil_irq(irq);
-#ifdef CONFIG_SMP
-        /* Only rotate on lower priority IRQs (scsi, ethernet, etc.). */
-        if((sparc_cpu_model==sun4m) && (irq < 10))
-                smp4m_irq_rotate(cpu);
-#endif
-        action = sparc_irq[irq].action;
-        sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS;
-        kstat_cpu(cpu).irqs[irq]++;
-        do {
-                if (!action || !action->handler)
-                        unexpected_irq(irq, NULL, regs);
-                action->handler(irq, action->dev_id);
-                action = action->next;
-        } while (action);
-        sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
-        enable_pil_irq(irq);
+
+        p = irq_map[pil];
+        while (p) {
+                struct irq_bucket *next = p->next;
+
+                generic_handle_irq(p->irq);
+                p = next;
+        }
         irq_exit();
         set_irq_regs(old_regs);
 }
 
 #if defined(CONFIG_BLK_DEV_FD) || defined(CONFIG_BLK_DEV_FD_MODULE)
+static unsigned int floppy_irq;
 
-/* Fast IRQs on the Sparc can only have one routine attached to them,
- * thus no sharing possible.
- */
-static int request_fast_irq(unsigned int irq,
-                            void (*handler)(void),
-                            unsigned long irqflags, const char *devname)
+int sparc_floppy_request_irq(unsigned int irq, irq_handler_t irq_handler)
 {
-        struct irqaction *action;
-        unsigned long flags;
         unsigned int cpu_irq;
-        int ret;
-#ifdef CONFIG_SMP
+        int err;
+
+#if defined CONFIG_SMP && !defined CONFIG_SPARC_LEON
         struct tt_entry *trap_table;
-        extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
 #endif
-        
-        cpu_irq = irq & (NR_IRQS - 1);
-        if(cpu_irq > 14) {
-                ret = -EINVAL;
-                goto out;
-        }
-        if(!handler) {
-                ret = -EINVAL;
-                goto out;
-        }
 
-        spin_lock_irqsave(&irq_action_lock, flags);
+        err = request_irq(irq, irq_handler, 0, "floppy", NULL);
+        if (err)
+                return -1;
 
-        action = sparc_irq[cpu_irq].action;
-        if(action) {
-                if(action->flags & IRQF_SHARED)
-                        panic("Trying to register fast irq when already shared.\n");
-                if(irqflags & IRQF_SHARED)
-                        panic("Trying to register fast irq as shared.\n");
+        /* Save for later use in floppy interrupt handler */
+        floppy_irq = irq;
 
-                /* Anyway, someone already owns it so cannot be made fast. */
-                printk("request_fast_irq: Trying to register yet already owned.\n");
-                ret = -EBUSY;
-                goto out_unlock;
-        }
-
-        /* If this is flagged as statically allocated then we use our
-         * private struct which is never freed.
-         */
-        if (irqflags & SA_STATIC_ALLOC) {
-            if (static_irq_count < MAX_STATIC_ALLOC)
-                action = &static_irqaction[static_irq_count++];
-            else
-                printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
-                       irq, devname);
-        }
-        
-        if (action == NULL)
-            action = kmalloc(sizeof(struct irqaction),
-                                                 GFP_ATOMIC);
-        
-        if (!action) { 
-                ret = -ENOMEM;
-                goto out_unlock;
-        }
+        cpu_irq = (irq & (NR_IRQS - 1));
 
         /* Dork with trap table if we get this far. */
 #define INSTANTIATE(table) \
         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
-                SPARC_BRANCH((unsigned long) handler, \
+                SPARC_BRANCH((unsigned long) floppy_hardint, \
                              (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;
 
         INSTANTIATE(sparc_ttable)
-#ifdef CONFIG_SMP
-        trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
-        trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
-        trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
+#if defined CONFIG_SMP && !defined CONFIG_SPARC_LEON
+        trap_table = &trapbase_cpu1;
+        INSTANTIATE(trap_table)
+        trap_table = &trapbase_cpu2;
+        INSTANTIATE(trap_table)
+        trap_table = &trapbase_cpu3;
+        INSTANTIATE(trap_table)
 #endif
 #undef INSTANTIATE
         /*
@@ -438,24 +289,12 @@ static int request_fast_irq(unsigned int irq,
          * writing we have no CPU-neutral interface to fine-grained flushes.
          */
         flush_cache_all();
-
-        action->flags = irqflags;
-        action->name = devname;
-        action->dev_id = NULL;
-        action->next = NULL;
-
-        sparc_irq[cpu_irq].action = action;
-
-        __enable_irq(irq);
-
-        ret = 0;
-out_unlock:
-        spin_unlock_irqrestore(&irq_action_lock, flags);
-out:
-        return ret;
+        return 0;
 }
+EXPORT_SYMBOL(sparc_floppy_request_irq);
 
-/* These variables are used to access state from the assembler
+/*
+ * These variables are used to access state from the assembler
  * interrupt handler, floppy_hardint, so we cannot put these in
  * the floppy driver image because that would not work in the
  * modular case.
@@ -478,155 +317,23 @@ EXPORT_SYMBOL(pdma_base);
 unsigned long pdma_areasize;
 EXPORT_SYMBOL(pdma_areasize);
 
-extern void floppy_hardint(void);
-
-static irq_handler_t floppy_irq_handler;
-
+/* Use the generic irq support to call floppy_interrupt
+ * which was setup using request_irq() in sparc_floppy_request_irq().
+ * We only have one floppy interrupt so we do not need to check
+ * for additional handlers being wired up by irq_link()
+ */
 void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
 {
         struct pt_regs *old_regs;
-        int cpu = smp_processor_id();
 
         old_regs = set_irq_regs(regs);
-        disable_pil_irq(irq);
         irq_enter();
-        kstat_cpu(cpu).irqs[irq]++;
-        floppy_irq_handler(irq, dev_id);
+        generic_handle_irq(floppy_irq);
         irq_exit();
-        enable_pil_irq(irq);
         set_irq_regs(old_regs);
-        // XXX Eek, it's totally changed with preempt_count() and such
-        // if (softirq_pending(cpu))
-        //      do_softirq();
 }
-
-int sparc_floppy_request_irq(int irq, unsigned long flags,
-                             irq_handler_t irq_handler)
-{
-        floppy_irq_handler = irq_handler;
-        return request_fast_irq(irq, floppy_hardint, flags, "floppy");
-}
-EXPORT_SYMBOL(sparc_floppy_request_irq);
-
 #endif
 
-int request_irq(unsigned int irq,
-                irq_handler_t handler,
-                unsigned long irqflags, const char * devname, void *dev_id)
-{
-        struct irqaction * action, **actionp;
-        unsigned long flags;
-        unsigned int cpu_irq;
-        int ret;
-        
-        if (sparc_cpu_model == sun4d) {
-                extern int sun4d_request_irq(unsigned int, 
-                                             irq_handler_t ,
-                                             unsigned long, const char *, void *);
-                return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
-        }
-        cpu_irq = irq & (NR_IRQS - 1);
-        if(cpu_irq > 14) {
-                ret = -EINVAL;
-                goto out;
-        }
-        if (!handler) {
-                ret = -EINVAL;
-                goto out;
-        }
-            
-        spin_lock_irqsave(&irq_action_lock, flags);
-
-        actionp = &sparc_irq[cpu_irq].action;
-        action = *actionp;
-        if (action) {
-                if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) {
-                        ret = -EBUSY;
-                        goto out_unlock;
-                }
-                if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) {
-                        printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
-                        ret = -EBUSY;
-                        goto out_unlock;
-                }
-                for ( ; action; action = *actionp)
-                        actionp = &action->next;
-        }
-
-        /* If this is flagged as statically allocated then we use our
-         * private struct which is never freed.
-         */
-        if (irqflags & SA_STATIC_ALLOC) {
-                if (static_irq_count < MAX_STATIC_ALLOC)
-                        action = &static_irqaction[static_irq_count++];
-                else
-                        printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
-        }
-        
-        if (action == NULL)
-                action = kmalloc(sizeof(struct irqaction),
-                                                     GFP_ATOMIC);
-        
-        if (!action) { 
-                ret = -ENOMEM;
-                goto out_unlock;
-        }
-
-        action->handler = handler;
-        action->flags = irqflags;
-        action->name = devname;
-        action->next = NULL;
-        action->dev_id = dev_id;
-
-        *actionp = action;
-
-        __enable_irq(irq);
-
-        ret = 0;
-out_unlock:
-        spin_unlock_irqrestore(&irq_action_lock, flags);
-out:
-        return ret;
-}
-
-EXPORT_SYMBOL(request_irq);
-
-void disable_irq_nosync(unsigned int irq)
-{
-        __disable_irq(irq);
-}
-EXPORT_SYMBOL(disable_irq_nosync);
-
-void disable_irq(unsigned int irq)
-{
-        __disable_irq(irq);
-}
-EXPORT_SYMBOL(disable_irq);
-
-void enable_irq(unsigned int irq)
-{
-        __enable_irq(irq);
-}
-
-EXPORT_SYMBOL(enable_irq);
-
-/* We really don't need these at all on the Sparc.  We only have
- * stubs here because they are exported to modules.
- */
-unsigned long probe_irq_on(void)
-{
-        return 0;
-}
-
-EXPORT_SYMBOL(probe_irq_on);
-
-int probe_irq_off(unsigned long mask)
-{
-        return 0;
-}
-
-EXPORT_SYMBOL(probe_irq_off);
-
 /* djhr
  * This could probably be made indirect too and assigned in the CPU
  * bits of the code. That would be much nicer I think and would also
@@ -637,27 +344,20 @@ EXPORT_SYMBOL(probe_irq_off);
 
 void __init init_IRQ(void)
 {
-        extern void sun4c_init_IRQ( void );
-        extern void sun4m_init_IRQ( void );
-        extern void sun4d_init_IRQ( void );
-
-        switch(sparc_cpu_model) {
+        switch (sparc_cpu_model) {
         case sun4c:
         case sun4:
                 sun4c_init_IRQ();
                 break;
 
         case sun4m:
-#ifdef CONFIG_PCI
                 pcic_probe();
-                if (pcic_present()) {
+                if (pcic_present())
                         sun4m_pci_init_IRQ();
-                        break;
-                }
-#endif
-                sun4m_init_IRQ();
+                else
+                        sun4m_init_IRQ();
                 break;
-                
+
         case sun4d:
                 sun4d_init_IRQ();
                 break;
@@ -673,9 +373,3 @@ void __init init_IRQ(void)
         btfixup();
 }
 
-#ifdef CONFIG_PROC_FS
-void init_irq_proc(void)
-{
-        /* For now, nothing... */
-}
-#endif /* CONFIG_PROC_FS */
diff --git a/arch/sparc/kernel/irq_64.c b/arch/sparc/kernel/irq_64.c
index 830d70a3e20b..4e78862d12fd 100644
--- a/arch/sparc/kernel/irq_64.c
+++ b/arch/sparc/kernel/irq_64.c
@@ -82,7 +82,7 @@ static void bucket_clear_chain_pa(unsigned long bucket_pa)
                                "i" (ASI_PHYS_USE_EC));
 }
 
-static unsigned int bucket_get_virt_irq(unsigned long bucket_pa)
+static unsigned int bucket_get_irq(unsigned long bucket_pa)
 {
         unsigned int ret;
 
@@ -90,21 +90,20 @@ static unsigned int bucket_get_virt_irq(unsigned long bucket_pa)
                              : "=&r" (ret)
                              : "r" (bucket_pa +
                                     offsetof(struct ino_bucket,
-                                             __virt_irq)),
+                                             __irq)),
                                "i" (ASI_PHYS_USE_EC));
 
         return ret;
 }
 
-static void bucket_set_virt_irq(unsigned long bucket_pa,
-                                unsigned int virt_irq)
+static void bucket_set_irq(unsigned long bucket_pa, unsigned int irq)
 {
         __asm__ __volatile__("stwa      %0, [%1] %2"
                              : /* no outputs */
-                             : "r" (virt_irq),
+                             : "r" (irq),
                                "r" (bucket_pa +
                                     offsetof(struct ino_bucket,
-                                             __virt_irq)),
+                                             __irq)),
                                "i" (ASI_PHYS_USE_EC));
 }
 
@@ -114,97 +113,63 @@ static struct {
         unsigned int dev_handle;
         unsigned int dev_ino;
         unsigned int in_use;
-} virt_irq_table[NR_IRQS];
-static DEFINE_SPINLOCK(virt_irq_alloc_lock);
+} irq_table[NR_IRQS];
+static DEFINE_SPINLOCK(irq_alloc_lock);
 
-unsigned char virt_irq_alloc(unsigned int dev_handle,
-                             unsigned int dev_ino)
+unsigned char irq_alloc(unsigned int dev_handle, unsigned int dev_ino)
 {
         unsigned long flags;
         unsigned char ent;
 
         BUILD_BUG_ON(NR_IRQS >= 256);
 
-        spin_lock_irqsave(&virt_irq_alloc_lock, flags);
+        spin_lock_irqsave(&irq_alloc_lock, flags);
 
         for (ent = 1; ent < NR_IRQS; ent++) {
-                if (!virt_irq_table[ent].in_use)
+                if (!irq_table[ent].in_use)
                         break;
         }
         if (ent >= NR_IRQS) {
                 printk(KERN_ERR "IRQ: Out of virtual IRQs.\n");
                 ent = 0;
         } else {
-                virt_irq_table[ent].dev_handle = dev_handle;
-                virt_irq_table[ent].dev_ino = dev_ino;
-                virt_irq_table[ent].in_use = 1;
+                irq_table[ent].dev_handle = dev_handle;
+                irq_table[ent].dev_ino = dev_ino;
+                irq_table[ent].in_use = 1;
         }
 
-        spin_unlock_irqrestore(&virt_irq_alloc_lock, flags);
+        spin_unlock_irqrestore(&irq_alloc_lock, flags);
 
         return ent;
 }
 
 #ifdef CONFIG_PCI_MSI
-void virt_irq_free(unsigned int virt_irq)
+void irq_free(unsigned int irq)
 {
         unsigned long flags;
 
-        if (virt_irq >= NR_IRQS)
+        if (irq >= NR_IRQS)
                 return;
 
-        spin_lock_irqsave(&virt_irq_alloc_lock, flags);
+        spin_lock_irqsave(&irq_alloc_lock, flags);
 
-        virt_irq_table[virt_irq].in_use = 0;
+        irq_table[irq].in_use = 0;
 
-        spin_unlock_irqrestore(&virt_irq_alloc_lock, flags);
+        spin_unlock_irqrestore(&irq_alloc_lock, flags);
 }
 #endif
 
 /*
  * /proc/interrupts printing:
  */
-
-int show_interrupts(struct seq_file *p, void *v)
+int arch_show_interrupts(struct seq_file *p, int prec)
 {
-        int i = *(loff_t *) v, j;
-        struct irqaction * action;
-        unsigned long flags;
+        int j;
 
-        if (i == 0) {
-                seq_printf(p, "           ");
-                for_each_online_cpu(j)
-                        seq_printf(p, "CPU%d       ",j);
-                seq_putc(p, '\n');
-        }
-
-        if (i < NR_IRQS) {
-                raw_spin_lock_irqsave(&irq_desc[i].lock, flags);
-                action = irq_desc[i].action;
-                if (!action)
-                        goto skip;
-                seq_printf(p, "%3d: ",i);
-#ifndef CONFIG_SMP
-                seq_printf(p, "%10u ", kstat_irqs(i));
-#else
-                for_each_online_cpu(j)
-                        seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
-#endif
-                seq_printf(p, " %9s", irq_desc[i].chip->name);
-                seq_printf(p, "  %s", action->name);
-
-                for (action=action->next; action; action = action->next)
-                        seq_printf(p, ", %s", action->name);
-
-                seq_putc(p, '\n');
-skip:
-                raw_spin_unlock_irqrestore(&irq_desc[i].lock, flags);
-        } else if (i == NR_IRQS) {
-                seq_printf(p, "NMI: ");
-                for_each_online_cpu(j)
-                        seq_printf(p, "%10u ", cpu_data(j).__nmi_count);
-                seq_printf(p, "     Non-maskable interrupts\n");
-        }
+        seq_printf(p, "NMI: ");
+        for_each_online_cpu(j)
+                seq_printf(p, "%10u ", cpu_data(j).__nmi_count);
+        seq_printf(p, "     Non-maskable interrupts\n");
         return 0;
 }
 
@@ -253,39 +218,38 @@ struct irq_handler_data {
 };
 
 #ifdef CONFIG_SMP
-static int irq_choose_cpu(unsigned int virt_irq, const struct cpumask *affinity)
+static int irq_choose_cpu(unsigned int irq, const struct cpumask *affinity)
 {
         cpumask_t mask;
         int cpuid;
 
         cpumask_copy(&mask, affinity);
-        if (cpus_equal(mask, cpu_online_map)) {
-                cpuid = map_to_cpu(virt_irq);
+        if (cpumask_equal(&mask, cpu_online_mask)) {
+                cpuid = map_to_cpu(irq);
         } else {
                 cpumask_t tmp;
 
-                cpus_and(tmp, cpu_online_map, mask);
-                cpuid = cpus_empty(tmp) ? map_to_cpu(virt_irq) : first_cpu(tmp);
+                cpumask_and(&tmp, cpu_online_mask, &mask);
+                cpuid = cpumask_empty(&tmp) ? map_to_cpu(irq) : cpumask_first(&tmp);
         }
 
         return cpuid;
 }
 #else
-#define irq_choose_cpu(virt_irq, affinity)      \
+#define irq_choose_cpu(irq, affinity)   \
         real_hard_smp_processor_id()
 #endif
 
-static void sun4u_irq_enable(unsigned int virt_irq)
+static void sun4u_irq_enable(struct irq_data *data)
 {
-        struct irq_handler_data *data = get_irq_chip_data(virt_irq);
+        struct irq_handler_data *handler_data = data->handler_data;
 
-        if (likely(data)) {
+        if (likely(handler_data)) {
                 unsigned long cpuid, imap, val;
                 unsigned int tid;
 
-                cpuid = irq_choose_cpu(virt_irq,
-                                       irq_desc[virt_irq].affinity);
-                imap = data->imap;
+                cpuid = irq_choose_cpu(data->irq, data->affinity);
+                imap = handler_data->imap;
 
                 tid = sun4u_compute_tid(imap, cpuid);
 
@@ -294,21 +258,21 @@ static void sun4u_irq_enable(unsigned int virt_irq)
                          IMAP_AID_SAFARI | IMAP_NID_SAFARI);
                 val |= tid | IMAP_VALID;
                 upa_writeq(val, imap);
-                upa_writeq(ICLR_IDLE, data->iclr);
+                upa_writeq(ICLR_IDLE, handler_data->iclr);
         }
 }
 
-static int sun4u_set_affinity(unsigned int virt_irq,
-                               const struct cpumask *mask)
+static int sun4u_set_affinity(struct irq_data *data,
+                               const struct cpumask *mask, bool force)
 {
-        struct irq_handler_data *data = get_irq_chip_data(virt_irq);
+        struct irq_handler_data *handler_data = data->handler_data;
 
-        if (likely(data)) {
+        if (likely(handler_data)) {
                 unsigned long cpuid, imap, val;
                 unsigned int tid;
 
-                cpuid = irq_choose_cpu(virt_irq, mask);
-                imap = data->imap;
+                cpuid = irq_choose_cpu(data->irq, mask);
+                imap = handler_data->imap;
 
                 tid = sun4u_compute_tid(imap, cpuid);
 
@@ -317,7 +281,7 @@ static int sun4u_set_affinity(unsigned int virt_irq,
                          IMAP_AID_SAFARI | IMAP_NID_SAFARI);
                 val |= tid | IMAP_VALID;
                 upa_writeq(val, imap);
-                upa_writeq(ICLR_IDLE, data->iclr);
+                upa_writeq(ICLR_IDLE, handler_data->iclr);
         }
 
         return 0;
@@ -340,27 +304,22 @@ static int sun4u_set_affinity(unsigned int virt_irq,
  * sees that, it also hooks up a default ->shutdown method which
  * invokes ->mask() which we do not want.  See irq_chip_set_defaults().
  */
-static void sun4u_irq_disable(unsigned int virt_irq)
+static void sun4u_irq_disable(struct irq_data *data)
 {
 }
 
-static void sun4u_irq_eoi(unsigned int virt_irq)
+static void sun4u_irq_eoi(struct irq_data *data)
 {
-        struct irq_handler_data *data = get_irq_chip_data(virt_irq);
-        struct irq_desc *desc = irq_desc + virt_irq;
+        struct irq_handler_data *handler_data = data->handler_data;
 
-        if (unlikely(desc->status & (IRQ_DISABLED|IRQ_INPROGRESS)))
-                return;
-
-        if (likely(data))
-                upa_writeq(ICLR_IDLE, data->iclr);
+        if (likely(handler_data))
+                upa_writeq(ICLR_IDLE, handler_data->iclr);
 }
 
-static void sun4v_irq_enable(unsigned int virt_irq)
+static void sun4v_irq_enable(struct irq_data *data)
 {
-        unsigned int ino = virt_irq_table[virt_irq].dev_ino;
-        unsigned long cpuid = irq_choose_cpu(virt_irq,
-                                             irq_desc[virt_irq].affinity);
+        unsigned int ino = irq_table[data->irq].dev_ino;
+        unsigned long cpuid = irq_choose_cpu(data->irq, data->affinity);
         int err;
 
         err = sun4v_intr_settarget(ino, cpuid);
@@ -377,11 +336,11 @@ static void sun4v_irq_enable(unsigned int virt_irq)
                        ino, err);
 }
 
-static int sun4v_set_affinity(unsigned int virt_irq,
-                               const struct cpumask *mask)
+static int sun4v_set_affinity(struct irq_data *data,
+                               const struct cpumask *mask, bool force)
 {
-        unsigned int ino = virt_irq_table[virt_irq].dev_ino;
-        unsigned long cpuid = irq_choose_cpu(virt_irq, mask);
+        unsigned int ino = irq_table[data->irq].dev_ino;
+        unsigned long cpuid = irq_choose_cpu(data->irq, mask);
         int err;
 
         err = sun4v_intr_settarget(ino, cpuid);
@@ -392,9 +351,9 @@ static int sun4v_set_affinity(unsigned int virt_irq,
         return 0;
 }
 
-static void sun4v_irq_disable(unsigned int virt_irq)
+static void sun4v_irq_disable(struct irq_data *data)
 {
-        unsigned int ino = virt_irq_table[virt_irq].dev_ino;
+        unsigned int ino = irq_table[data->irq].dev_ino;
         int err;
 
         err = sun4v_intr_setenabled(ino, HV_INTR_DISABLED);
@@ -403,30 +362,26 @@ static void sun4v_irq_disable(unsigned int virt_irq)
                        "err(%d)\n", ino, err);
 }
 
-static void sun4v_irq_eoi(unsigned int virt_irq)
+static void sun4v_irq_eoi(struct irq_data *data)
 {
-        unsigned int ino = virt_irq_table[virt_irq].dev_ino;
-        struct irq_desc *desc = irq_desc + virt_irq;
+        unsigned int ino = irq_table[data->irq].dev_ino;
         int err;
 
-        if (unlikely(desc->status & (IRQ_DISABLED|IRQ_INPROGRESS)))
-                return;
-
         err = sun4v_intr_setstate(ino, HV_INTR_STATE_IDLE);
         if (err != HV_EOK)
                 printk(KERN_ERR "sun4v_intr_setstate(%x): "
                        "err(%d)\n", ino, err);
 }
 
-static void sun4v_virq_enable(unsigned int virt_irq)
+static void sun4v_virq_enable(struct irq_data *data)
 {
         unsigned long cpuid, dev_handle, dev_ino;
         int err;
 
-        cpuid = irq_choose_cpu(virt_irq, irq_desc[virt_irq].affinity);
+        cpuid = irq_choose_cpu(data->irq, data->affinity);
 
-        dev_handle = virt_irq_table[virt_irq].dev_handle;
-        dev_ino = virt_irq_table[virt_irq].dev_ino;
+        dev_handle = irq_table[data->irq].dev_handle;
+        dev_ino = irq_table[data->irq].dev_ino;
 
         err = sun4v_vintr_set_target(dev_handle, dev_ino, cpuid);
         if (err != HV_EOK)
@@ -447,16 +402,16 @@ static void sun4v_virq_enable(unsigned int virt_irq)
                        dev_handle, dev_ino, err);
 }
 
-static int sun4v_virt_set_affinity(unsigned int virt_irq,
-                                    const struct cpumask *mask)
+static int sun4v_virt_set_affinity(struct irq_data *data,
+                                    const struct cpumask *mask, bool force)
 {
         unsigned long cpuid, dev_handle, dev_ino;
         int err;
 
-        cpuid = irq_choose_cpu(virt_irq, mask);
+        cpuid = irq_choose_cpu(data->irq, mask);
 
-        dev_handle = virt_irq_table[virt_irq].dev_handle;
-        dev_ino = virt_irq_table[virt_irq].dev_ino;
+        dev_handle = irq_table[data->irq].dev_handle;
+        dev_ino = irq_table[data->irq].dev_ino;
 
         err = sun4v_vintr_set_target(dev_handle, dev_ino, cpuid);
         if (err != HV_EOK)
@@ -467,13 +422,13 @@ static int sun4v_virt_set_affinity(unsigned int virt_irq,
         return 0;
 }
 
-static void sun4v_virq_disable(unsigned int virt_irq)
+static void sun4v_virq_disable(struct irq_data *data)
 {
         unsigned long dev_handle, dev_ino;
         int err;
 
-        dev_handle = virt_irq_table[virt_irq].dev_handle;
-        dev_ino = virt_irq_table[virt_irq].dev_ino;
+        dev_handle = irq_table[data->irq].dev_handle;
+        dev_ino = irq_table[data->irq].dev_ino;
 
         err = sun4v_vintr_set_valid(dev_handle, dev_ino,
                                     HV_INTR_DISABLED);
@@ -483,17 +438,13 @@ static void sun4v_virq_disable(unsigned int virt_irq)
                        dev_handle, dev_ino, err);
 }
 
-static void sun4v_virq_eoi(unsigned int virt_irq)
+static void sun4v_virq_eoi(struct irq_data *data)
 {
-        struct irq_desc *desc = irq_desc + virt_irq;
         unsigned long dev_handle, dev_ino;
         int err;
 
-        if (unlikely(desc->status & (IRQ_DISABLED|IRQ_INPROGRESS)))
-                return;
-
-        dev_handle = virt_irq_table[virt_irq].dev_handle;
-        dev_ino = virt_irq_table[virt_irq].dev_ino;
+        dev_handle = irq_table[data->irq].dev_handle;
+        dev_ino = irq_table[data->irq].dev_ino;
 
         err = sun4v_vintr_set_state(dev_handle, dev_ino,
                                     HV_INTR_STATE_IDLE);
@@ -504,132 +455,128 @@ static void sun4v_virq_eoi(unsigned int virt_irq)
 }
 
 static struct irq_chip sun4u_irq = {
-        .name           = "sun4u",
-        .enable         = sun4u_irq_enable,
-        .disable        = sun4u_irq_disable,
-        .eoi            = sun4u_irq_eoi,
-        .set_affinity   = sun4u_set_affinity,
+        .name                   = "sun4u",
+        .irq_enable             = sun4u_irq_enable,
+        .irq_disable            = sun4u_irq_disable,
+        .irq_eoi                = sun4u_irq_eoi,
+        .irq_set_affinity       = sun4u_set_affinity,
+        .flags                  = IRQCHIP_EOI_IF_HANDLED,
 };
 
 static struct irq_chip sun4v_irq = {
-        .name           = "sun4v",
-        .enable         = sun4v_irq_enable,
-        .disable        = sun4v_irq_disable,
-        .eoi            = sun4v_irq_eoi,
-        .set_affinity   = sun4v_set_affinity,
+        .name                   = "sun4v",
+        .irq_enable             = sun4v_irq_enable,
+        .irq_disable            = sun4v_irq_disable,
+        .irq_eoi                = sun4v_irq_eoi,
+        .irq_set_affinity       = sun4v_set_affinity,
+        .flags                  = IRQCHIP_EOI_IF_HANDLED,
 };
 
 static struct irq_chip sun4v_virq = {
-        .name           = "vsun4v",
-        .enable         = sun4v_virq_enable,
-        .disable        = sun4v_virq_disable,
-        .eoi            = sun4v_virq_eoi,
-        .set_affinity   = sun4v_virt_set_affinity,
+        .name                   = "vsun4v",
+        .irq_enable             = sun4v_virq_enable,
+        .irq_disable            = sun4v_virq_disable,
+        .irq_eoi                = sun4v_virq_eoi,
+        .irq_set_affinity       = sun4v_virt_set_affinity,
+        .flags                  = IRQCHIP_EOI_IF_HANDLED,
 };
 
-static void pre_flow_handler(unsigned int virt_irq,
-                                      struct irq_desc *desc)
+static void pre_flow_handler(struct irq_data *d)
 {
-        struct irq_handler_data *data = get_irq_chip_data(virt_irq);
-        unsigned int ino = virt_irq_table[virt_irq].dev_ino;
+        struct irq_handler_data *handler_data = irq_data_get_irq_handler_data(d);
+        unsigned int ino = irq_table[d->irq].dev_ino;
 
-        data->pre_handler(ino, data->arg1, data->arg2);
-
-        handle_fasteoi_irq(virt_irq, desc);
+        handler_data->pre_handler(ino, handler_data->arg1, handler_data->arg2);
 }
 
-void irq_install_pre_handler(int virt_irq,
+void irq_install_pre_handler(int irq,
                              void (*func)(unsigned int, void *, void *),
                              void *arg1, void *arg2)
 {
-        struct irq_handler_data *data = get_irq_chip_data(virt_irq);
-        struct irq_desc *desc = irq_desc + virt_irq;
+        struct irq_handler_data *handler_data = irq_get_handler_data(irq);
 
-        data->pre_handler = func;
-        data->arg1 = arg1;
-        data->arg2 = arg2;
+        handler_data->pre_handler = func;
+        handler_data->arg1 = arg1;
+        handler_data->arg2 = arg2;
 
-        desc->handle_irq = pre_flow_handler;
+        __irq_set_preflow_handler(irq, pre_flow_handler);
 }
 
 unsigned int build_irq(int inofixup, unsigned long iclr, unsigned long imap)
 {
         struct ino_bucket *bucket;
-        struct irq_handler_data *data;
-        unsigned int virt_irq;
+        struct irq_handler_data *handler_data;
+        unsigned int irq;
         int ino;
 
         BUG_ON(tlb_type == hypervisor);
 
         ino = (upa_readq(imap) & (IMAP_IGN | IMAP_INO)) + inofixup;
         bucket = &ivector_table[ino];
-        virt_irq = bucket_get_virt_irq(__pa(bucket));
-        if (!virt_irq) {
-                virt_irq = virt_irq_alloc(0, ino);
-                bucket_set_virt_irq(__pa(bucket), virt_irq);
-                set_irq_chip_and_handler_name(virt_irq,
-                                              &sun4u_irq,
-                                              handle_fasteoi_irq,
-                                              "IVEC");
+        irq = bucket_get_irq(__pa(bucket));
+        if (!irq) {
+                irq = irq_alloc(0, ino);
+                bucket_set_irq(__pa(bucket), irq);
+                irq_set_chip_and_handler_name(irq, &sun4u_irq,
+                                              handle_fasteoi_irq, "IVEC");
         }
 
-        data = get_irq_chip_data(virt_irq);
-        if (unlikely(data))
+        handler_data = irq_get_handler_data(irq);
+        if (unlikely(handler_data))
                 goto out;
 
-        data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
-        if (unlikely(!data)) {
+        handler_data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
+        if (unlikely(!handler_data)) {
                 prom_printf("IRQ: kzalloc(irq_handler_data) failed.\n");
                 prom_halt();
         }
-        set_irq_chip_data(virt_irq, data);
+        irq_set_handler_data(irq, handler_data);
 
-        data->imap  = imap;
-        data->iclr  = iclr;
+        handler_data->imap  = imap;
+        handler_data->iclr  = iclr;
 
 out:
-        return virt_irq;
+        return irq;
 }
 
 static unsigned int sun4v_build_common(unsigned long sysino,
                                        struct irq_chip *chip)
 {
         struct ino_bucket *bucket;
-        struct irq_handler_data *data;
-        unsigned int virt_irq;
+        struct irq_handler_data *handler_data;
+        unsigned int irq;
 
         BUG_ON(tlb_type != hypervisor);
 
         bucket = &ivector_table[sysino];
-        virt_irq = bucket_get_virt_irq(__pa(bucket));
-        if (!virt_irq) {
-                virt_irq = virt_irq_alloc(0, sysino);
-                bucket_set_virt_irq(__pa(bucket), virt_irq);
-                set_irq_chip_and_handler_name(virt_irq, chip,
-                                              handle_fasteoi_irq,
+        irq = bucket_get_irq(__pa(bucket));
+        if (!irq) {
+                irq = irq_alloc(0, sysino);
+                bucket_set_irq(__pa(bucket), irq);
+                irq_set_chip_and_handler_name(irq, chip, handle_fasteoi_irq,
                                               "IVEC");
         }
 
-        data = get_irq_chip_data(virt_irq);
-        if (unlikely(data))
+        handler_data = irq_get_handler_data(irq);
+        if (unlikely(handler_data))
                 goto out;
 
-        data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
-        if (unlikely(!data)) {
+        handler_data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
+        if (unlikely(!handler_data)) {
                 prom_printf("IRQ: kzalloc(irq_handler_data) failed.\n");
                 prom_halt();
         }
-        set_irq_chip_data(virt_irq, data);
+        irq_set_handler_data(irq, handler_data);
 
         /* Catch accidental accesses to these things.  IMAP/ICLR handling
          * is done by hypervisor calls on sun4v platforms, not by direct
          * register accesses.
          */
-        data->imap = ~0UL;
-        data->iclr = ~0UL;
+        handler_data->imap = ~0UL;
+        handler_data->iclr = ~0UL;
 
 out:
-        return virt_irq;
+        return irq;
 }
 
 unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino)
@@ -641,11 +588,10 @@ unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino)
 
 unsigned int sun4v_build_virq(u32 devhandle, unsigned int devino)
 {
-        struct irq_handler_data *data;
+        struct irq_handler_data *handler_data;
         unsigned long hv_err, cookie;
         struct ino_bucket *bucket;
-        struct irq_desc *desc;
-        unsigned int virt_irq;
+        unsigned int irq;
 
         bucket = kzalloc(sizeof(struct ino_bucket), GFP_ATOMIC);
         if (unlikely(!bucket))
@@ -662,32 +608,29 @@ unsigned int sun4v_build_virq(u32 devhandle, unsigned int devino)
                              ((unsigned long) bucket +
                               sizeof(struct ino_bucket)));
 
-        virt_irq = virt_irq_alloc(devhandle, devino);
-        bucket_set_virt_irq(__pa(bucket), virt_irq);
+        irq = irq_alloc(devhandle, devino);
+        bucket_set_irq(__pa(bucket), irq);
 
-        set_irq_chip_and_handler_name(virt_irq, &sun4v_virq,
-                                      handle_fasteoi_irq,
+        irq_set_chip_and_handler_name(irq, &sun4v_virq, handle_fasteoi_irq,
                                       "IVEC");
 
-        data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
-        if (unlikely(!data))
+        handler_data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
+        if (unlikely(!handler_data))
                 return 0;
 
         /* In order to make the LDC channel startup sequence easier,
          * especially wrt. locking, we do not let request_irq() enable
          * the interrupt.
          */
-        desc = irq_desc + virt_irq;
-        desc->status |= IRQ_NOAUTOEN;
-
-        set_irq_chip_data(virt_irq, data);
+        irq_set_status_flags(irq, IRQ_NOAUTOEN);
+        irq_set_handler_data(irq, handler_data);
 
         /* Catch accidental accesses to these things.  IMAP/ICLR handling
          * is done by hypervisor calls on sun4v platforms, not by direct
          * register accesses.
          */
-        data->imap = ~0UL;
-        data->iclr = ~0UL;
+        handler_data->imap = ~0UL;
+        handler_data->iclr = ~0UL;
 
         cookie = ~__pa(bucket);
         hv_err = sun4v_vintr_set_cookie(devhandle, devino, cookie);
@@ -697,30 +640,30 @@ unsigned int sun4v_build_virq(u32 devhandle, unsigned int devino)
                 prom_halt();
         }
 
-        return virt_irq;
+        return irq;
 }
 
-void ack_bad_irq(unsigned int virt_irq)
+void ack_bad_irq(unsigned int irq)
 {
-        unsigned int ino = virt_irq_table[virt_irq].dev_ino;
+        unsigned int ino = irq_table[irq].dev_ino;
 
         if (!ino)
                 ino = 0xdeadbeef;
 
-        printk(KERN_CRIT "Unexpected IRQ from ino[%x] virt_irq[%u]\n",
-               ino, virt_irq);
+        printk(KERN_CRIT "Unexpected IRQ from ino[%x] irq[%u]\n",
+               ino, irq);
 }
 
 void *hardirq_stack[NR_CPUS];
 void *softirq_stack[NR_CPUS];
 
-void __irq_entry handler_irq(int irq, struct pt_regs *regs)
+void __irq_entry handler_irq(int pil, struct pt_regs *regs)
 {
         unsigned long pstate, bucket_pa;
         struct pt_regs *old_regs;
         void *orig_sp;
 
-        clear_softint(1 << irq);
+        clear_softint(1 << pil);
 
         old_regs = set_irq_regs(regs);
         irq_enter();
@@ -739,18 +682,14 @@ void __irq_entry handler_irq(int irq, struct pt_regs *regs)
         orig_sp = set_hardirq_stack();
 
         while (bucket_pa) {
-                struct irq_desc *desc;
                 unsigned long next_pa;
-                unsigned int virt_irq;
+                unsigned int irq;
 
                 next_pa = bucket_get_chain_pa(bucket_pa);
-                virt_irq = bucket_get_virt_irq(bucket_pa);
+                irq = bucket_get_irq(bucket_pa);
                 bucket_clear_chain_pa(bucket_pa);
 
-                desc = irq_desc + virt_irq;
-
-                if (!(desc->status & IRQ_DISABLED))
-                        desc->handle_irq(virt_irq, desc);
+                generic_handle_irq(irq);
 
                 bucket_pa = next_pa;
         }
@@ -793,16 +732,18 @@ void fixup_irqs(void)
         unsigned int irq;
 
         for (irq = 0; irq < NR_IRQS; irq++) {
+                struct irq_desc *desc = irq_to_desc(irq);
+                struct irq_data *data = irq_desc_get_irq_data(desc);
                 unsigned long 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);
+                raw_spin_lock_irqsave(&desc->lock, flags);
+                if (desc->action && !irqd_is_per_cpu(data)) {
+                        if (data->chip->irq_set_affinity)
+                                data->chip->irq_set_affinity(data,
+                                                             data->affinity,
+                                                             false);
                 }
-                raw_spin_unlock_irqrestore(&irq_desc[irq].lock, flags);
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
         }
 
         tick_ops->disable_irq();
@@ -1040,5 +981,5 @@ void __init init_IRQ(void)
                              : "i" (PSTATE_IE)
                              : "g1");
 
-        irq_desc[0].action = &timer_irq_action;
+        irq_to_desc(0)->action = &timer_irq_action;
 }
diff --git a/arch/sparc/kernel/jump_label.c b/arch/sparc/kernel/jump_label.c
new file mode 100644
index 000000000000..ea2dafc93d78
--- /dev/null
+++ b/arch/sparc/kernel/jump_label.c
@@ -0,0 +1,47 @@
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/mutex.h>
+#include <linux/cpu.h>
+
+#include <linux/jump_label.h>
+#include <linux/memory.h>
+
+#ifdef HAVE_JUMP_LABEL
+
+void arch_jump_label_transform(struct jump_entry *entry,
+                               enum jump_label_type type)
+{
+        u32 val;
+        u32 *insn = (u32 *) (unsigned long) entry->code;
+
+        if (type == JUMP_LABEL_ENABLE) {
+                s32 off = (s32)entry->target - (s32)entry->code;
+
+#ifdef CONFIG_SPARC64
+                /* ba,pt %xcc, . + (off << 2) */
+                val = 0x10680000 | ((u32) off >> 2);
+#else
+                /* ba . + (off << 2) */
+                val = 0x10800000 | ((u32) off >> 2);
+#endif
+        } else {
+                val = 0x01000000;
+        }
+
+        get_online_cpus();
+        mutex_lock(&text_mutex);
+        *insn = val;
+        flushi(insn);
+        mutex_unlock(&text_mutex);
+        put_online_cpus();
+}
+
+void arch_jump_label_text_poke_early(jump_label_t addr)
+{
+        u32 *insn_p = (u32 *) (unsigned long) addr;
+
+        *insn_p = 0x01000000;
+        flushi(insn_p);
+}
+
+#endif
diff --git a/arch/sparc/kernel/kernel.h b/arch/sparc/kernel/kernel.h
index 15d8a3f645c9..6f6544cfa0ef 100644
--- a/arch/sparc/kernel/kernel.h
+++ b/arch/sparc/kernel/kernel.h
@@ -3,12 +3,12 @@
 
 #include <linux/interrupt.h>
 
+#include <asm/traps.h>
+
 /* cpu.c */
-extern const char *sparc_cpu_type;
 extern const char *sparc_pmu_type;
-extern const char *sparc_fpu_type;
-
 extern unsigned int fsr_storage;
+extern int ncpus_probed;
 
 #ifdef CONFIG_SPARC32
 /* cpu.c */
@@ -26,6 +26,54 @@ extern int static_irq_count;
 extern spinlock_t irq_action_lock;
 
 extern void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs);
+extern void init_IRQ(void);
+
+/* sun4c_irq.c */
+extern void sun4c_init_IRQ(void);
+
+/* sun4m_irq.c */
+extern unsigned int lvl14_resolution;
+
+extern void sun4m_init_IRQ(void);
+extern void sun4m_unmask_profile_irq(void);
+extern void sun4m_clear_profile_irq(int cpu);
+
+/* sun4d_irq.c */
+extern spinlock_t sun4d_imsk_lock;
+
+extern void sun4d_init_IRQ(void);
+extern int sun4d_request_irq(unsigned int irq,
+                             irq_handler_t handler,
+                             unsigned long irqflags,
+                             const char *devname, void *dev_id);
+extern int show_sun4d_interrupts(struct seq_file *, void *);
+extern void sun4d_distribute_irqs(void);
+extern void sun4d_free_irq(unsigned int irq, void *dev_id);
+
+/* head_32.S */
+extern unsigned int t_nmi[];
+extern unsigned int linux_trap_ipi15_sun4d[];
+extern unsigned int linux_trap_ipi15_sun4m[];
+
+extern struct tt_entry trapbase_cpu1;
+extern struct tt_entry trapbase_cpu2;
+extern struct tt_entry trapbase_cpu3;
+
+extern char cputypval[];
+
+/* entry.S */
+extern unsigned long lvl14_save[4];
+extern unsigned int real_irq_entry[];
+extern unsigned int smp4d_ticker[];
+extern unsigned int patchme_maybe_smp_msg[];
+
+extern void floppy_hardint(void);
+
+/* trampoline_32.S */
+extern int __smp4m_processor_id(void);
+extern int __smp4d_processor_id(void);
+extern unsigned long sun4m_cpu_startup;
+extern unsigned long sun4d_cpu_startup;
 
 #else /* CONFIG_SPARC32 */
 #endif /* CONFIG_SPARC32 */
diff --git a/arch/sparc/kernel/ldc.c b/arch/sparc/kernel/ldc.c
index df39a0f0d27a..732b0bce6001 100644
--- a/arch/sparc/kernel/ldc.c
+++ b/arch/sparc/kernel/ldc.c
@@ -790,16 +790,20 @@ static void send_events(struct ldc_channel *lp, unsigned int event_mask)
 static irqreturn_t ldc_rx(int irq, void *dev_id)
 {
         struct ldc_channel *lp = dev_id;
-        unsigned long orig_state, hv_err, flags;
+        unsigned long orig_state, flags;
         unsigned int event_mask;
 
         spin_lock_irqsave(&lp->lock, flags);
 
         orig_state = lp->chan_state;
-        hv_err = sun4v_ldc_rx_get_state(lp->id,
-                                        &lp->rx_head,
-                                        &lp->rx_tail,
-                                        &lp->chan_state);
+
+        /* We should probably check for hypervisor errors here and
+         * reset the LDC channel if we get one.
+         */
+        sun4v_ldc_rx_get_state(lp->id,
+                               &lp->rx_head,
+                               &lp->rx_tail,
+                               &lp->chan_state);
 
         ldcdbg(RX, "RX state[0x%02lx:0x%02lx] head[0x%04lx] tail[0x%04lx]\n",
                orig_state, lp->chan_state, lp->rx_head, lp->rx_tail);
@@ -904,16 +908,20 @@ out:
 static irqreturn_t ldc_tx(int irq, void *dev_id)
 {
         struct ldc_channel *lp = dev_id;
-        unsigned long flags, hv_err, orig_state;
+        unsigned long flags, orig_state;
         unsigned int event_mask = 0;
 
         spin_lock_irqsave(&lp->lock, flags);
 
         orig_state = lp->chan_state;
-        hv_err = sun4v_ldc_tx_get_state(lp->id,
-                                        &lp->tx_head,
-                                        &lp->tx_tail,
-                                        &lp->chan_state);
+
+        /* We should probably check for hypervisor errors here and
+         * reset the LDC channel if we get one.
+         */
+        sun4v_ldc_tx_get_state(lp->id,
+                               &lp->tx_head,
+                               &lp->tx_tail,
+                               &lp->chan_state);
 
         ldcdbg(TX, " TX state[0x%02lx:0x%02lx] head[0x%04lx] tail[0x%04lx]\n",
                orig_state, lp->chan_state, lp->tx_head, lp->tx_tail);
diff --git a/arch/sparc/kernel/leon_kernel.c b/arch/sparc/kernel/leon_kernel.c
index 6a7b4dbc8e09..d17255a2bbac 100644
--- a/arch/sparc/kernel/leon_kernel.c
+++ b/arch/sparc/kernel/leon_kernel.c
@@ -19,51 +19,70 @@
 #include <asm/leon_amba.h>
 #include <asm/traps.h>
 #include <asm/cacheflush.h>
+#include <asm/smp.h>
+#include <asm/setup.h>
 
 #include "prom.h"
 #include "irq.h"
 
-struct leon3_irqctrl_regs_map *leon3_irqctrl_regs; /* interrupt controller base address, initialized by amba_init() */
-struct leon3_gptimer_regs_map *leon3_gptimer_regs; /* timer controller base address, initialized by amba_init() */
-struct amba_apb_device leon_percpu_timer_dev[16];
+struct leon3_irqctrl_regs_map *leon3_irqctrl_regs; /* interrupt controller base address */
+struct leon3_gptimer_regs_map *leon3_gptimer_regs; /* timer controller base address */
 
 int leondebug_irq_disable;
 int leon_debug_irqout;
 static int dummy_master_l10_counter;
+unsigned long amba_system_id;
+static DEFINE_SPINLOCK(leon_irq_lock);
 
-unsigned long leon3_gptimer_irq; /* interrupt controller irq number, initialized by amba_init() */
+unsigned long leon3_gptimer_irq; /* interrupt controller irq number */
+unsigned long leon3_gptimer_idx; /* Timer Index (0..6) within Timer Core */
+int leon3_ticker_irq; /* Timer ticker IRQ */
 unsigned int sparc_leon_eirq;
-#define LEON_IMASK ((&leon3_irqctrl_regs->mask[0]))
+#define LEON_IMASK(cpu) (&leon3_irqctrl_regs->mask[cpu])
+#define LEON_IACK (&leon3_irqctrl_regs->iclear)
+#define LEON_DO_ACK_HW 1
 
-/* Return the IRQ of the pending IRQ on the extended IRQ controller */
-int sparc_leon_eirq_get(int eirq, int cpu)
+/* Return the last ACKed IRQ by the Extended IRQ controller. It has already
+ * been (automatically) ACKed when the CPU takes the trap.
+ */
+static inline unsigned int leon_eirq_get(int cpu)
 {
         return LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->intid[cpu]) & 0x1f;
 }
 
-irqreturn_t sparc_leon_eirq_isr(int dummy, void *dev_id)
+/* Handle one or multiple IRQs from the extended interrupt controller */
+static void leon_handle_ext_irq(unsigned int irq, struct irq_desc *desc)
 {
-        printk(KERN_ERR "sparc_leon_eirq_isr: ERROR EXTENDED IRQ\n");
-        return IRQ_HANDLED;
+        unsigned int eirq;
+        int cpu = sparc_leon3_cpuid();
+
+        eirq = leon_eirq_get(cpu);
+        if ((eirq & 0x10) && irq_map[eirq]->irq) /* bit4 tells if IRQ happened */
+                generic_handle_irq(irq_map[eirq]->irq);
 }
 
 /* The extended IRQ controller has been found, this function registers it */
-void sparc_leon_eirq_register(int eirq)
+void leon_eirq_setup(unsigned int eirq)
 {
-        int irq;
-
-        /* Register a "BAD" handler for this interrupt, it should never happen */
-        irq = request_irq(eirq, sparc_leon_eirq_isr,
-                          (IRQF_DISABLED | SA_STATIC_ALLOC), "extirq", NULL);
+        unsigned long mask, oldmask;
+        unsigned int veirq;
 
-        if (irq) {
-                printk(KERN_ERR
-                       "sparc_leon_eirq_register: unable to attach IRQ%d\n",
-                       eirq);
-        } else {
-                sparc_leon_eirq = eirq;
+        if (eirq < 1 || eirq > 0xf) {
+                printk(KERN_ERR "LEON EXT IRQ NUMBER BAD: %d\n", eirq);
+                return;
         }
 
+        veirq = leon_build_device_irq(eirq, leon_handle_ext_irq, "extirq", 0);
+
+        /*
+         * Unmask the Extended IRQ, the IRQs routed through the Ext-IRQ
+         * controller have a mask-bit of their own, so this is safe.
+         */
+        irq_link(veirq);
+        mask = 1 << eirq;
+        oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(boot_cpu_id));
+        LEON3_BYPASS_STORE_PA(LEON_IMASK(boot_cpu_id), (oldmask | mask));
+        sparc_leon_eirq = eirq;
 }
 
 static inline unsigned long get_irqmask(unsigned int irq)
@@ -81,108 +100,327 @@ static inline unsigned long get_irqmask(unsigned int irq)
         return mask;
 }
 
-static void leon_enable_irq(unsigned int irq_nr)
+#ifdef CONFIG_SMP
+static int irq_choose_cpu(const struct cpumask *affinity)
 {
-        unsigned long mask, flags;
-        mask = get_irqmask(irq_nr);
-        local_irq_save(flags);
-        LEON3_BYPASS_STORE_PA(LEON_IMASK,
-                              (LEON3_BYPASS_LOAD_PA(LEON_IMASK) | (mask)));
-        local_irq_restore(flags);
+        cpumask_t mask;
+
+        cpus_and(mask, cpu_online_map, *affinity);
+        if (cpus_equal(mask, cpu_online_map) || cpus_empty(mask))
+                return boot_cpu_id;
+        else
+                return first_cpu(mask);
+}
+#else
+#define irq_choose_cpu(affinity) boot_cpu_id
+#endif
+
+static int leon_set_affinity(struct irq_data *data, const struct cpumask *dest,
+                             bool force)
+{
+        unsigned long mask, oldmask, flags;
+        int oldcpu, newcpu;
+
+        mask = (unsigned long)data->chip_data;
+        oldcpu = irq_choose_cpu(data->affinity);
+        newcpu = irq_choose_cpu(dest);
+
+        if (oldcpu == newcpu)
+                goto out;
+
+        /* unmask on old CPU first before enabling on the selected CPU */
+        spin_lock_irqsave(&leon_irq_lock, flags);
+        oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(oldcpu));
+        LEON3_BYPASS_STORE_PA(LEON_IMASK(oldcpu), (oldmask & ~mask));
+        oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(newcpu));
+        LEON3_BYPASS_STORE_PA(LEON_IMASK(newcpu), (oldmask | mask));
+        spin_unlock_irqrestore(&leon_irq_lock, flags);
+out:
+        return IRQ_SET_MASK_OK;
 }
 
-static void leon_disable_irq(unsigned int irq_nr)
+static void leon_unmask_irq(struct irq_data *data)
 {
-        unsigned long mask, flags;
-        mask = get_irqmask(irq_nr);
-        local_irq_save(flags);
-        LEON3_BYPASS_STORE_PA(LEON_IMASK,
-                              (LEON3_BYPASS_LOAD_PA(LEON_IMASK) & ~(mask)));
-        local_irq_restore(flags);
+        unsigned long mask, oldmask, flags;
+        int cpu;
+
+        mask = (unsigned long)data->chip_data;
+        cpu = irq_choose_cpu(data->affinity);
+        spin_lock_irqsave(&leon_irq_lock, flags);
+        oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu));
+        LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu), (oldmask | mask));
+        spin_unlock_irqrestore(&leon_irq_lock, flags);
+}
+
+static void leon_mask_irq(struct irq_data *data)
+{
+        unsigned long mask, oldmask, flags;
+        int cpu;
+
+        mask = (unsigned long)data->chip_data;
+        cpu = irq_choose_cpu(data->affinity);
+        spin_lock_irqsave(&leon_irq_lock, flags);
+        oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu));
+        LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu), (oldmask & ~mask));
+        spin_unlock_irqrestore(&leon_irq_lock, flags);
+}
+
+static unsigned int leon_startup_irq(struct irq_data *data)
+{
+        irq_link(data->irq);
+        leon_unmask_irq(data);
+        return 0;
+}
 
+static void leon_shutdown_irq(struct irq_data *data)
+{
+        leon_mask_irq(data);
+        irq_unlink(data->irq);
+}
+
+/* Used by external level sensitive IRQ handlers on the LEON: ACK IRQ ctrl */
+static void leon_eoi_irq(struct irq_data *data)
+{
+        unsigned long mask = (unsigned long)data->chip_data;
+
+        if (mask & LEON_DO_ACK_HW)
+                LEON3_BYPASS_STORE_PA(LEON_IACK, mask & ~LEON_DO_ACK_HW);
+}
+
+static struct irq_chip leon_irq = {
+        .name                   = "leon",
+        .irq_startup            = leon_startup_irq,
+        .irq_shutdown           = leon_shutdown_irq,
+        .irq_mask               = leon_mask_irq,
+        .irq_unmask             = leon_unmask_irq,
+        .irq_eoi                = leon_eoi_irq,
+        .irq_set_affinity       = leon_set_affinity,
+};
+
+/*
+ * Build a LEON IRQ for the edge triggered LEON IRQ controller:
+ *  Edge (normal) IRQ           - handle_simple_irq, ack=DONT-CARE, never ack
+ *  Level IRQ (PCI|Level-GPIO)  - handle_fasteoi_irq, ack=1, ack after ISR
+ *  Per-CPU Edge                - handle_percpu_irq, ack=0
+ */
+unsigned int leon_build_device_irq(unsigned int real_irq,
+                                    irq_flow_handler_t flow_handler,
+                                    const char *name, int do_ack)
+{
+        unsigned int irq;
+        unsigned long mask;
+
+        irq = 0;
+        mask = get_irqmask(real_irq);
+        if (mask == 0)
+                goto out;
+
+        irq = irq_alloc(real_irq, real_irq);
+        if (irq == 0)
+                goto out;
+
+        if (do_ack)
+                mask |= LEON_DO_ACK_HW;
+
+        irq_set_chip_and_handler_name(irq, &leon_irq,
+                                      flow_handler, name);
+        irq_set_chip_data(irq, (void *)mask);
+
+out:
+        return irq;
+}
+
+static unsigned int _leon_build_device_irq(struct platform_device *op,
+                                           unsigned int real_irq)
+{
+        return leon_build_device_irq(real_irq, handle_simple_irq, "edge", 0);
+}
+
+void leon_update_virq_handling(unsigned int virq,
+                              irq_flow_handler_t flow_handler,
+                              const char *name, int do_ack)
+{
+        unsigned long mask = (unsigned long)irq_get_chip_data(virq);
+
+        mask &= ~LEON_DO_ACK_HW;
+        if (do_ack)
+                mask |= LEON_DO_ACK_HW;
+
+        irq_set_chip_and_handler_name(virq, &leon_irq,
+                                      flow_handler, name);
+        irq_set_chip_data(virq, (void *)mask);
 }
 
 void __init leon_init_timers(irq_handler_t counter_fn)
 {
-        int irq;
+        int irq, eirq;
+        struct device_node *rootnp, *np, *nnp;
+        struct property *pp;
+        int len;
+        int icsel;
+        int ampopts;
+        int err;
 
         leondebug_irq_disable = 0;
         leon_debug_irqout = 0;
         master_l10_counter = (unsigned int *)&dummy_master_l10_counter;
         dummy_master_l10_counter = 0;
 
-        if (leon3_gptimer_regs && leon3_irqctrl_regs) {
-                LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[0].val, 0);
-                LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[0].rld,
-                                      (((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;
+        rootnp = of_find_node_by_path("/ambapp0");
+        if (!rootnp)
+                goto bad;
+
+        /* Find System ID: GRLIB build ID and optional CHIP ID */
+        pp = of_find_property(rootnp, "systemid", &len);
+        if (pp)
+                amba_system_id = *(unsigned long *)pp->value;
+
+        /* Find IRQMP IRQ Controller Registers base adr otherwise bail out */
+        np = of_find_node_by_name(rootnp, "GAISLER_IRQMP");
+        if (!np) {
+                np = of_find_node_by_name(rootnp, "01_00d");
+                if (!np)
+                        goto bad;
+        }
+        pp = of_find_property(np, "reg", &len);
+        if (!pp)
+                goto bad;
+        leon3_irqctrl_regs = *(struct leon3_irqctrl_regs_map **)pp->value;
+
+        /* Find GPTIMER Timer Registers base address otherwise bail out. */
+        nnp = rootnp;
+        do {
+                np = of_find_node_by_name(nnp, "GAISLER_GPTIMER");
+                if (!np) {
+                        np = of_find_node_by_name(nnp, "01_011");
+                        if (!np)
+                                goto bad;
+                }
 
-                if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->config) &
-                      (1<<LEON3_GPTIMER_SEPIRQ))) {
-                        prom_printf("irq timer not configured with separate irqs\n");
-                        BUG();
+                ampopts = 0;
+                pp = of_find_property(np, "ampopts", &len);
+                if (pp) {
+                        ampopts = *(int *)pp->value;
+                        if (ampopts == 0) {
+                                /* Skip this instance, resource already
+                                 * allocated by other OS */
+                                nnp = np;
+                                continue;
+                        }
                 }
 
-                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
+                /* Select Timer-Instance on Timer Core. Default is zero */
+                leon3_gptimer_idx = ampopts & 0x7;
 
-        } else {
-                printk(KERN_ERR "No Timer/irqctrl found\n");
+                pp = of_find_property(np, "reg", &len);
+                if (pp)
+                        leon3_gptimer_regs = *(struct leon3_gptimer_regs_map **)
+                                                pp->value;
+                pp = of_find_property(np, "interrupts", &len);
+                if (pp)
+                        leon3_gptimer_irq = *(unsigned int *)pp->value;
+        } while (0);
+
+        if (!(leon3_gptimer_regs && leon3_irqctrl_regs && leon3_gptimer_irq))
+                goto bad;
+
+        LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].val, 0);
+        LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].rld,
+                                (((1000000 / HZ) - 1)));
+        LEON3_BYPASS_STORE_PA(
+                        &leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl, 0);
+
+#ifdef CONFIG_SMP
+        leon3_ticker_irq = leon3_gptimer_irq + 1 + leon3_gptimer_idx;
+
+        if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->config) &
+              (1<<LEON3_GPTIMER_SEPIRQ))) {
+                printk(KERN_ERR "timer not configured with separate irqs\n");
                 BUG();
         }
 
-        irq = request_irq(leon3_gptimer_irq,
-                          counter_fn,
-                          (IRQF_DISABLED | SA_STATIC_ALLOC), "timer", NULL);
+        LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].val,
+                                0);
+        LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].rld,
+                                (((1000000/HZ) - 1)));
+        LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl,
+                                0);
+#endif
 
-        if (irq) {
-                printk(KERN_ERR "leon_time_init: unable to attach IRQ%d\n",
-                       LEON_INTERRUPT_TIMER1);
+        /*
+         * The IRQ controller may (if implemented) consist of multiple
+         * IRQ controllers, each mapped on a 4Kb boundary.
+         * Each CPU may be routed to different IRQCTRLs, however
+         * we assume that all CPUs (in SMP system) is routed to the
+         * same IRQ Controller, and for non-SMP only one IRQCTRL is
+         * accessed anyway.
+         * In AMP systems, Linux must run on CPU0 for the time being.
+         */
+        icsel = LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->icsel[boot_cpu_id/8]);
+        icsel = (icsel >> ((7 - (boot_cpu_id&0x7)) * 4)) & 0xf;
+        leon3_irqctrl_regs += icsel;
+
+        /* Mask all IRQs on boot-cpu IRQ controller */
+        LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->mask[boot_cpu_id], 0);
+
+        /* Probe extended IRQ controller */
+        eirq = (LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->mpstatus)
+                >> 16) & 0xf;
+        if (eirq != 0)
+                leon_eirq_setup(eirq);
+
+        irq = _leon_build_device_irq(NULL, leon3_gptimer_irq+leon3_gptimer_idx);
+        err = request_irq(irq, counter_fn, IRQF_TIMER, "timer", NULL);
+        if (err) {
+                printk(KERN_ERR "unable to attach timer IRQ%d\n", irq);
                 prom_halt();
         }
 
-# ifdef CONFIG_SMP
+#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.
+                /*
+                 * In SMP, sun4m adds a IPI handler to IRQ trap handler that
+                 * LEON never must take, sun4d and LEON overwrites the branch
+                 * with a NOP.
                  */
                 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
+#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);
+        LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].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
-
+        /* Install per-cpu IRQ handler for broadcasted ticker */
+        irq = leon_build_device_irq(leon3_ticker_irq, handle_percpu_irq,
+                                    "per-cpu", 0);
+        err = request_irq(irq, leon_percpu_timer_interrupt,
+                          IRQF_PERCPU | IRQF_TIMER, "ticker",
+                          NULL);
+        if (err) {
+                printk(KERN_ERR "unable to attach ticker IRQ%d\n", irq);
+                prom_halt();
         }
+
+        LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl,
+                              LEON3_GPTIMER_EN |
+                              LEON3_GPTIMER_RL |
+                              LEON3_GPTIMER_LD |
+                              LEON3_GPTIMER_IRQEN);
+#endif
+        return;
+bad:
+        printk(KERN_ERR "No Timer/irqctrl found\n");
+        BUG();
+        return;
 }
 
 void leon_clear_clock_irq(void)
@@ -194,9 +432,6 @@ void leon_load_profile_irq(int cpu, unsigned int limit)
         BUG();
 }
 
-
-
-
 void __init leon_trans_init(struct device_node *dp)
 {
         if (strcmp(dp->type, "cpu") == 0 && strcmp(dp->name, "<NULL>") == 0) {
@@ -250,22 +485,18 @@ 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);
+        spin_lock_irqsave(&leon_irq_lock, flags);
+        addr = (unsigned long *)LEON_IMASK(cpu);
+        LEON3_BYPASS_STORE_PA(addr, (LEON3_BYPASS_LOAD_PA(addr) | mask));
+        spin_unlock_irqrestore(&leon_irq_lock, flags);
 }
 
 #endif
 
 void __init leon_init_IRQ(void)
 {
-        sparc_init_timers = leon_init_timers;
-
-        BTFIXUPSET_CALL(enable_irq, leon_enable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_irq, leon_disable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(enable_pil_irq, leon_enable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_pil_irq, leon_disable_irq, BTFIXUPCALL_NORM);
+        sparc_irq_config.init_timers      = leon_init_timers;
+        sparc_irq_config.build_device_irq = _leon_build_device_irq;
 
         BTFIXUPSET_CALL(clear_clock_irq, leon_clear_clock_irq,
                         BTFIXUPCALL_NORM);
@@ -282,5 +513,5 @@ void __init leon_init_IRQ(void)
 
 void __init leon_init(void)
 {
-        prom_build_more = &leon_node_init;
+        of_pdt_build_more = &leon_node_init;
 }
diff --git a/arch/sparc/kernel/leon_pci.c b/arch/sparc/kernel/leon_pci.c
new file mode 100644
index 000000000000..a8a9a275037d
--- /dev/null
+++ b/arch/sparc/kernel/leon_pci.c
@@ -0,0 +1,253 @@
+/*
+ * leon_pci.c: LEON Host PCI support
+ *
+ * Copyright (C) 2011 Aeroflex Gaisler AB, Daniel Hellstrom
+ *
+ * Code is partially derived from pcic.c
+ */
+
+#include <linux/of_device.h>
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <asm/leon.h>
+#include <asm/leon_pci.h>
+
+/* The LEON architecture does not rely on a BIOS or bootloader to setup
+ * PCI for us. The Linux generic routines are used to setup resources,
+ * reset values of confuration-space registers settings ae preseved.
+ */
+void leon_pci_init(struct platform_device *ofdev, struct leon_pci_info *info)
+{
+        struct pci_bus *root_bus;
+
+        root_bus = pci_scan_bus_parented(&ofdev->dev, 0, info->ops, info);
+        if (root_bus) {
+                root_bus->resource[0] = &info->io_space;
+                root_bus->resource[1] = &info->mem_space;
+                root_bus->resource[2] = NULL;
+
+                /* Init all PCI devices into PCI tree */
+                pci_bus_add_devices(root_bus);
+
+                /* Setup IRQs of all devices using custom routines */
+                pci_fixup_irqs(pci_common_swizzle, info->map_irq);
+
+                /* Assign devices with resources */
+                pci_assign_unassigned_resources();
+        }
+}
+
+/* PCI Memory and Prefetchable Memory is direct-mapped. However I/O Space is
+ * accessed through a Window which is translated to low 64KB in PCI space, the
+ * first 4KB is not used so 60KB is available.
+ *
+ * This function is used by generic code to translate resource addresses into
+ * PCI addresses.
+ */
+void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
+                             struct resource *res)
+{
+        struct leon_pci_info *info = dev->bus->sysdata;
+
+        region->start = res->start;
+        region->end = res->end;
+
+        if (res->flags & IORESOURCE_IO) {
+                region->start -= (info->io_space.start - 0x1000);
+                region->end -= (info->io_space.start - 0x1000);
+        }
+}
+EXPORT_SYMBOL(pcibios_resource_to_bus);
+
+/* see pcibios_resource_to_bus() comment */
+void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
+                             struct pci_bus_region *region)
+{
+        struct leon_pci_info *info = dev->bus->sysdata;
+
+        res->start = region->start;
+        res->end = region->end;
+
+        if (res->flags & IORESOURCE_IO) {
+                res->start += (info->io_space.start - 0x1000);
+                res->end += (info->io_space.start - 0x1000);
+        }
+}
+EXPORT_SYMBOL(pcibios_bus_to_resource);
+
+void __devinit pcibios_fixup_bus(struct pci_bus *pbus)
+{
+        struct leon_pci_info *info = pbus->sysdata;
+        struct pci_dev *dev;
+        int i, has_io, has_mem;
+        u16 cmd;
+
+        /* Generic PCI bus probing sets these to point at
+         * &io{port,mem}_resouce which is wrong for us.
+         */
+        if (pbus->self == NULL) {
+                pbus->resource[0] = &info->io_space;
+                pbus->resource[1] = &info->mem_space;
+                pbus->resource[2] = NULL;
+        }
+
+        list_for_each_entry(dev, &pbus->devices, bus_list) {
+                /*
+                 * We can not rely on that the bootloader has enabled I/O
+                 * or memory access to PCI devices. Instead we enable it here
+                 * if the device has BARs of respective type.
+                 */
+                has_io = has_mem = 0;
+                for (i = 0; i < PCI_ROM_RESOURCE; i++) {
+                        unsigned long f = dev->resource[i].flags;
+                        if (f & IORESOURCE_IO)
+                                has_io = 1;
+                        else if (f & IORESOURCE_MEM)
+                                has_mem = 1;
+                }
+                /* ROM BARs are mapped into 32-bit memory space */
+                if (dev->resource[PCI_ROM_RESOURCE].end != 0) {
+                        dev->resource[PCI_ROM_RESOURCE].flags |=
+                                                        IORESOURCE_ROM_ENABLE;
+                        has_mem = 1;
+                }
+                pci_bus_read_config_word(pbus, dev->devfn, PCI_COMMAND, &cmd);
+                if (has_io && !(cmd & PCI_COMMAND_IO)) {
+#ifdef CONFIG_PCI_DEBUG
+                        printk(KERN_INFO "LEONPCI: Enabling I/O for dev %s\n",
+                                         pci_name(dev));
+#endif
+                        cmd |= PCI_COMMAND_IO;
+                        pci_bus_write_config_word(pbus, dev->devfn, PCI_COMMAND,
+                                                                        cmd);
+                }
+                if (has_mem && !(cmd & PCI_COMMAND_MEMORY)) {
+#ifdef CONFIG_PCI_DEBUG
+                        printk(KERN_INFO "LEONPCI: Enabling MEMORY for dev"
+                                         "%s\n", pci_name(dev));
+#endif
+                        cmd |= PCI_COMMAND_MEMORY;
+                        pci_bus_write_config_word(pbus, dev->devfn, PCI_COMMAND,
+                                                                        cmd);
+                }
+        }
+}
+
+/*
+ * Other archs parse arguments here.
+ */
+char * __devinit pcibios_setup(char *str)
+{
+        return str;
+}
+
+resource_size_t pcibios_align_resource(void *data, const struct resource *res,
+                                resource_size_t size, resource_size_t align)
+{
+        return res->start;
+}
+
+int pcibios_enable_device(struct pci_dev *dev, int mask)
+{
+        return pci_enable_resources(dev, mask);
+}
+
+struct device_node *pci_device_to_OF_node(struct pci_dev *pdev)
+{
+        /*
+         * Currently the OpenBoot nodes are not connected with the PCI device,
+         * this is because the LEON PROM does not create PCI nodes. Eventually
+         * this will change and the same approach as pcic.c can be used to
+         * match PROM nodes with pci devices.
+         */
+        return NULL;
+}
+EXPORT_SYMBOL(pci_device_to_OF_node);
+
+void __devinit pcibios_update_irq(struct pci_dev *dev, int irq)
+{
+#ifdef CONFIG_PCI_DEBUG
+        printk(KERN_DEBUG "LEONPCI: Assigning IRQ %02d to %s\n", irq,
+                pci_name(dev));
+#endif
+        pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
+}
+
+/* in/out routines taken from pcic.c
+ *
+ * This probably belongs here rather than ioport.c because
+ * we do not want this crud linked into SBus kernels.
+ * Also, think for a moment about likes of floppy.c that
+ * include architecture specific parts. They may want to redefine ins/outs.
+ *
+ * We do not use horrible macros here because we want to
+ * advance pointer by sizeof(size).
+ */
+void outsb(unsigned long addr, const void *src, unsigned long count)
+{
+        while (count) {
+                count -= 1;
+                outb(*(const char *)src, addr);
+                src += 1;
+                /* addr += 1; */
+        }
+}
+EXPORT_SYMBOL(outsb);
+
+void outsw(unsigned long addr, const void *src, unsigned long count)
+{
+        while (count) {
+                count -= 2;
+                outw(*(const short *)src, addr);
+                src += 2;
+                /* addr += 2; */
+        }
+}
+EXPORT_SYMBOL(outsw);
+
+void outsl(unsigned long addr, const void *src, unsigned long count)
+{
+        while (count) {
+                count -= 4;
+                outl(*(const long *)src, addr);
+                src += 4;
+                /* addr += 4; */
+        }
+}
+EXPORT_SYMBOL(outsl);
+
+void insb(unsigned long addr, void *dst, unsigned long count)
+{
+        while (count) {
+                count -= 1;
+                *(unsigned char *)dst = inb(addr);
+                dst += 1;
+                /* addr += 1; */
+        }
+}
+EXPORT_SYMBOL(insb);
+
+void insw(unsigned long addr, void *dst, unsigned long count)
+{
+        while (count) {
+                count -= 2;
+                *(unsigned short *)dst = inw(addr);
+                dst += 2;
+                /* addr += 2; */
+        }
+}
+EXPORT_SYMBOL(insw);
+
+void insl(unsigned long addr, void *dst, unsigned long count)
+{
+        while (count) {
+                count -= 4;
+                /*
+                 * XXX I am sure we are in for an unaligned trap here.
+                 */
+                *(unsigned long *)dst = inl(addr);
+                dst += 4;
+                /* addr += 4; */
+        }
+}
+EXPORT_SYMBOL(insl);
diff --git a/arch/sparc/kernel/leon_pci_grpci2.c b/arch/sparc/kernel/leon_pci_grpci2.c
new file mode 100644
index 000000000000..44dc093ee33a
--- /dev/null
+++ b/arch/sparc/kernel/leon_pci_grpci2.c
@@ -0,0 +1,897 @@
+/*
+ * leon_pci_grpci2.c: GRPCI2 Host PCI driver
+ *
+ * Copyright (C) 2011 Aeroflex Gaisler AB, Daniel Hellstrom
+ *
+ */
+
+#include <linux/of_device.h>
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <asm/io.h>
+#include <asm/leon.h>
+#include <asm/vaddrs.h>
+#include <asm/sections.h>
+#include <asm/leon_pci.h>
+
+#include "irq.h"
+
+struct grpci2_barcfg {
+        unsigned long pciadr;   /* PCI Space Address */
+        unsigned long ahbadr;   /* PCI Base address mapped to this AHB addr */
+};
+
+/* Device Node Configuration options:
+ *  - barcfgs    : Custom Configuration of Host's 6 target BARs
+ *  - irq_mask   : Limit which PCI interrupts are enabled
+ *  - do_reset   : Force PCI Reset on startup
+ *
+ * barcfgs
+ * =======
+ *
+ * Optional custom Target BAR configuration (see struct grpci2_barcfg). All
+ * addresses are physical. Array always contains 6 elements (len=2*4*6 bytes)
+ *
+ * -1 means not configured (let host driver do default setup).
+ *
+ * [i*2+0] = PCI Address of BAR[i] on target interface
+ * [i*2+1] = Accessing PCI address of BAR[i] result in this AMBA address
+ *
+ *
+ * irq_mask
+ * ========
+ *
+ * Limit which PCI interrupts are enabled. 0=Disable, 1=Enable. By default
+ * all are enabled. Use this when PCI interrupt pins are floating on PCB.
+ * int, len=4.
+ *  bit0 = PCI INTA#
+ *  bit1 = PCI INTB#
+ *  bit2 = PCI INTC#
+ *  bit3 = PCI INTD#
+ *
+ *
+ * reset
+ * =====
+ *
+ * Force PCI reset on startup. int, len=4
+ */
+
+/* Enable Debugging Configuration Space Access */
+#undef GRPCI2_DEBUG_CFGACCESS
+
+/*
+ * GRPCI2 APB Register MAP
+ */
+struct grpci2_regs {
+        unsigned int ctrl;              /* 0x00 Control */
+        unsigned int sts_cap;           /* 0x04 Status / Capabilities */
+        int res1;                       /* 0x08 */
+        unsigned int io_map;            /* 0x0C I/O Map address */
+        unsigned int dma_ctrl;          /* 0x10 DMA */
+        unsigned int dma_bdbase;        /* 0x14 DMA */
+        int res2[2];                    /* 0x18 */
+        unsigned int bars[6];           /* 0x20 read-only PCI BARs */
+        int res3[2];                    /* 0x38 */
+        unsigned int ahbmst_map[16];    /* 0x40 AHB->PCI Map per AHB Master */
+
+        /* PCI Trace Buffer Registers (OPTIONAL) */
+        unsigned int t_ctrl;            /* 0x80 */
+        unsigned int t_cnt;             /* 0x84 */
+        unsigned int t_adpat;           /* 0x88 */
+        unsigned int t_admask;          /* 0x8C */
+        unsigned int t_sigpat;          /* 0x90 */
+        unsigned int t_sigmask;         /* 0x94 */
+        unsigned int t_adstate;         /* 0x98 */
+        unsigned int t_sigstate;        /* 0x9C */
+};
+
+#define REGLOAD(a)      (be32_to_cpu(__raw_readl(&(a))))
+#define REGSTORE(a, v)  (__raw_writel(cpu_to_be32(v), &(a)))
+
+#define CTRL_BUS_BIT 16
+
+#define CTRL_RESET (1<<31)
+#define CTRL_SI (1<<27)
+#define CTRL_PE (1<<26)
+#define CTRL_EI (1<<25)
+#define CTRL_ER (1<<24)
+#define CTRL_BUS (0xff<<CTRL_BUS_BIT)
+#define CTRL_HOSTINT 0xf
+
+#define STS_HOST_BIT    31
+#define STS_MST_BIT     30
+#define STS_TAR_BIT     29
+#define STS_DMA_BIT     28
+#define STS_DI_BIT      27
+#define STS_HI_BIT      26
+#define STS_IRQMODE_BIT 24
+#define STS_TRACE_BIT   23
+#define STS_CFGERRVALID_BIT 20
+#define STS_CFGERR_BIT  19
+#define STS_INTTYPE_BIT 12
+#define STS_INTSTS_BIT  8
+#define STS_FDEPTH_BIT  2
+#define STS_FNUM_BIT    0
+
+#define STS_HOST        (1<<STS_HOST_BIT)
+#define STS_MST         (1<<STS_MST_BIT)
+#define STS_TAR         (1<<STS_TAR_BIT)
+#define STS_DMA         (1<<STS_DMA_BIT)
+#define STS_DI          (1<<STS_DI_BIT)
+#define STS_HI          (1<<STS_HI_BIT)
+#define STS_IRQMODE     (0x3<<STS_IRQMODE_BIT)
+#define STS_TRACE       (1<<STS_TRACE_BIT)
+#define STS_CFGERRVALID (1<<STS_CFGERRVALID_BIT)
+#define STS_CFGERR      (1<<STS_CFGERR_BIT)
+#define STS_INTTYPE     (0x3f<<STS_INTTYPE_BIT)
+#define STS_INTSTS      (0xf<<STS_INTSTS_BIT)
+#define STS_FDEPTH      (0x7<<STS_FDEPTH_BIT)
+#define STS_FNUM        (0x3<<STS_FNUM_BIT)
+
+#define STS_ISYSERR     (1<<17)
+#define STS_IDMA        (1<<16)
+#define STS_IDMAERR     (1<<15)
+#define STS_IMSTABRT    (1<<14)
+#define STS_ITGTABRT    (1<<13)
+#define STS_IPARERR     (1<<12)
+
+#define STS_ERR_IRQ (STS_ISYSERR | STS_IMSTABRT | STS_ITGTABRT | STS_IPARERR)
+
+struct grpci2_bd_chan {
+        unsigned int ctrl;      /* 0x00 DMA Control */
+        unsigned int nchan;     /* 0x04 Next DMA Channel Address */
+        unsigned int nbd;       /* 0x08 Next Data Descriptor in chan */
+        unsigned int res;       /* 0x0C Reserved */
+};
+
+#define BD_CHAN_EN              0x80000000
+#define BD_CHAN_TYPE            0x00300000
+#define BD_CHAN_BDCNT           0x0000ffff
+#define BD_CHAN_EN_BIT          31
+#define BD_CHAN_TYPE_BIT        20
+#define BD_CHAN_BDCNT_BIT       0
+
+struct grpci2_bd_data {
+        unsigned int ctrl;      /* 0x00 DMA Data Control */
+        unsigned int pci_adr;   /* 0x04 PCI Start Address */
+        unsigned int ahb_adr;   /* 0x08 AHB Start address */
+        unsigned int next;      /* 0x0C Next Data Descriptor in chan */
+};
+
+#define BD_DATA_EN              0x80000000
+#define BD_DATA_IE              0x40000000
+#define BD_DATA_DR              0x20000000
+#define BD_DATA_TYPE            0x00300000
+#define BD_DATA_ER              0x00080000
+#define BD_DATA_LEN             0x0000ffff
+#define BD_DATA_EN_BIT          31
+#define BD_DATA_IE_BIT          30
+#define BD_DATA_DR_BIT          29
+#define BD_DATA_TYPE_BIT        20
+#define BD_DATA_ER_BIT          19
+#define BD_DATA_LEN_BIT         0
+
+/* GRPCI2 Capability */
+struct grpci2_cap_first {
+        unsigned int ctrl;
+        unsigned int pci2ahb_map[6];
+        unsigned int ext2ahb_map;
+        unsigned int io_map;
+        unsigned int pcibar_size[6];
+};
+#define CAP9_CTRL_OFS 0
+#define CAP9_BAR_OFS 0x4
+#define CAP9_IOMAP_OFS 0x20
+#define CAP9_BARSIZE_OFS 0x24
+
+struct grpci2_priv {
+        struct leon_pci_info    info; /* must be on top of this structure */
+        struct grpci2_regs      *regs;
+        char                    irq;
+        char                    irq_mode; /* IRQ Mode from CAPSTS REG */
+        char                    bt_enabled;
+        char                    do_reset;
+        char                    irq_mask;
+        u32                     pciid; /* PCI ID of Host */
+        unsigned char           irq_map[4];
+
+        /* Virtual IRQ numbers */
+        unsigned int            virq_err;
+        unsigned int            virq_dma;
+
+        /* AHB PCI Windows */
+        unsigned long           pci_area;       /* MEMORY */
+        unsigned long           pci_area_end;
+        unsigned long           pci_io;         /* I/O */
+        unsigned long           pci_conf;       /* CONFIGURATION */
+        unsigned long           pci_conf_end;
+        unsigned long           pci_io_va;
+
+        struct grpci2_barcfg    tgtbars[6];
+};
+
+DEFINE_SPINLOCK(grpci2_dev_lock);
+struct grpci2_priv *grpci2priv;
+
+int grpci2_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
+{
+        struct grpci2_priv *priv = dev->bus->sysdata;
+        int irq_group;
+
+        /* Use default IRQ decoding on PCI BUS0 according slot numbering */
+        irq_group = slot & 0x3;
+        pin = ((pin - 1) + irq_group) & 0x3;
+
+        return priv->irq_map[pin];
+}
+
+static int grpci2_cfg_r32(struct grpci2_priv *priv, unsigned int bus,
+                                unsigned int devfn, int where, u32 *val)
+{
+        unsigned int *pci_conf;
+        unsigned long flags;
+        u32 tmp;
+
+        if (where & 0x3)
+                return -EINVAL;
+
+        if (bus == 0 && PCI_SLOT(devfn) != 0)
+                devfn += (0x8 * 6);
+
+        /* Select bus */
+        spin_lock_irqsave(&grpci2_dev_lock, flags);
+        REGSTORE(priv->regs->ctrl, (REGLOAD(priv->regs->ctrl) & ~(0xff << 16)) |
+                                   (bus << 16));
+        spin_unlock_irqrestore(&grpci2_dev_lock, flags);
+
+        /* clear old status */
+        REGSTORE(priv->regs->sts_cap, (STS_CFGERR | STS_CFGERRVALID));
+
+        pci_conf = (unsigned int *) (priv->pci_conf |
+                                                (devfn << 8) | (where & 0xfc));
+        tmp = LEON3_BYPASS_LOAD_PA(pci_conf);
+
+        /* Wait until GRPCI2 signals that CFG access is done, it should be
+         * done instantaneously unless a DMA operation is ongoing...
+         */
+        while ((REGLOAD(priv->regs->sts_cap) & STS_CFGERRVALID) == 0)
+                ;
+
+        if (REGLOAD(priv->regs->sts_cap) & STS_CFGERR) {
+                *val = 0xffffffff;
+        } else {
+                /* Bus always little endian (unaffected by byte-swapping) */
+                *val = flip_dword(tmp);
+        }
+
+        return 0;
+}
+
+static int grpci2_cfg_r16(struct grpci2_priv *priv, unsigned int bus,
+                                unsigned int devfn, int where, u32 *val)
+{
+        u32 v;
+        int ret;
+
+        if (where & 0x1)
+                return -EINVAL;
+        ret = grpci2_cfg_r32(priv, bus, devfn, where & ~0x3, &v);
+        *val = 0xffff & (v >> (8 * (where & 0x3)));
+        return ret;
+}
+
+static int grpci2_cfg_r8(struct grpci2_priv *priv, unsigned int bus,
+                                unsigned int devfn, int where, u32 *val)
+{
+        u32 v;
+        int ret;
+
+        ret = grpci2_cfg_r32(priv, bus, devfn, where & ~0x3, &v);
+        *val = 0xff & (v >> (8 * (where & 3)));
+
+        return ret;
+}
+
+static int grpci2_cfg_w32(struct grpci2_priv *priv, unsigned int bus,
+                                unsigned int devfn, int where, u32 val)
+{
+        unsigned int *pci_conf;
+        unsigned long flags;
+
+        if (where & 0x3)
+                return -EINVAL;
+
+        if (bus == 0 && PCI_SLOT(devfn) != 0)
+                devfn += (0x8 * 6);
+
+        /* Select bus */
+        spin_lock_irqsave(&grpci2_dev_lock, flags);
+        REGSTORE(priv->regs->ctrl, (REGLOAD(priv->regs->ctrl) & ~(0xff << 16)) |
+                                   (bus << 16));
+        spin_unlock_irqrestore(&grpci2_dev_lock, flags);
+
+        /* clear old status */
+        REGSTORE(priv->regs->sts_cap, (STS_CFGERR | STS_CFGERRVALID));
+
+        pci_conf = (unsigned int *) (priv->pci_conf |
+                                                (devfn << 8) | (where & 0xfc));
+        LEON3_BYPASS_STORE_PA(pci_conf, flip_dword(val));
+
+        /* Wait until GRPCI2 signals that CFG access is done, it should be
+         * done instantaneously unless a DMA operation is ongoing...
+         */
+        while ((REGLOAD(priv->regs->sts_cap) & STS_CFGERRVALID) == 0)
+                ;
+
+        return 0;
+}
+
+static int grpci2_cfg_w16(struct grpci2_priv *priv, unsigned int bus,
+                                unsigned int devfn, int where, u32 val)
+{
+        int ret;
+        u32 v;
+
+        if (where & 0x1)
+                return -EINVAL;
+        ret = grpci2_cfg_r32(priv, bus, devfn, where&~3, &v);
+        if (ret)
+                return ret;
+        v = (v & ~(0xffff << (8 * (where & 0x3)))) |
+            ((0xffff & val) << (8 * (where & 0x3)));
+        return grpci2_cfg_w32(priv, bus, devfn, where & ~0x3, v);
+}
+
+static int grpci2_cfg_w8(struct grpci2_priv *priv, unsigned int bus,
+                                unsigned int devfn, int where, u32 val)
+{
+        int ret;
+        u32 v;
+
+        ret = grpci2_cfg_r32(priv, bus, devfn, where & ~0x3, &v);
+        if (ret != 0)
+                return ret;
+        v = (v & ~(0xff << (8 * (where & 0x3)))) |
+            ((0xff & val) << (8 * (where & 0x3)));
+        return grpci2_cfg_w32(priv, bus, devfn, where & ~0x3, v);
+}
+
+/* Read from Configuration Space. When entering here the PCI layer has taken
+ * the pci_lock spinlock and IRQ is off.
+ */
+static int grpci2_read_config(struct pci_bus *bus, unsigned int devfn,
+                              int where, int size, u32 *val)
+{
+        struct grpci2_priv *priv = grpci2priv;
+        unsigned int busno = bus->number;
+        int ret;
+
+        if (PCI_SLOT(devfn) > 15 || (PCI_SLOT(devfn) == 0 && busno == 0)) {
+                *val = ~0;
+                return 0;
+        }
+
+        switch (size) {
+        case 1:
+                ret = grpci2_cfg_r8(priv, busno, devfn, where, val);
+                break;
+        case 2:
+                ret = grpci2_cfg_r16(priv, busno, devfn, where, val);
+                break;
+        case 4:
+                ret = grpci2_cfg_r32(priv, busno, devfn, where, val);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+#ifdef GRPCI2_DEBUG_CFGACCESS
+        printk(KERN_INFO "grpci2_read_config: [%02x:%02x:%x] ofs=%d val=%x "
+                "size=%d\n", busno, PCI_SLOT(devfn), PCI_FUNC(devfn), where,
+                *val, size);
+#endif
+
+        return ret;
+}
+
+/* Write to Configuration Space. When entering here the PCI layer has taken
+ * the pci_lock spinlock and IRQ is off.
+ */
+static int grpci2_write_config(struct pci_bus *bus, unsigned int devfn,
+                               int where, int size, u32 val)
+{
+        struct grpci2_priv *priv = grpci2priv;
+        unsigned int busno = bus->number;
+
+        if (PCI_SLOT(devfn) > 15 || (PCI_SLOT(devfn) == 0 && busno == 0))
+                return 0;
+
+#ifdef GRPCI2_DEBUG_CFGACCESS
+        printk(KERN_INFO "grpci2_write_config: [%02x:%02x:%x] ofs=%d size=%d "
+                "val=%x\n", busno, PCI_SLOT(devfn), PCI_FUNC(devfn),
+                where, size, val);
+#endif
+
+        switch (size) {
+        default:
+                return -EINVAL;
+        case 1:
+                return grpci2_cfg_w8(priv, busno, devfn, where, val);
+        case 2:
+                return grpci2_cfg_w16(priv, busno, devfn, where, val);
+        case 4:
+                return grpci2_cfg_w32(priv, busno, devfn, where, val);
+        }
+}
+
+static struct pci_ops grpci2_ops = {
+        .read =         grpci2_read_config,
+        .write =        grpci2_write_config,
+};
+
+/* GENIRQ IRQ chip implementation for GRPCI2 irqmode=0..2. In configuration
+ * 3 where all PCI Interrupts has a separate IRQ on the system IRQ controller
+ * this is not needed and the standard IRQ controller can be used.
+ */
+
+static void grpci2_mask_irq(struct irq_data *data)
+{
+        unsigned long flags;
+        unsigned int irqidx;
+        struct grpci2_priv *priv = grpci2priv;
+
+        irqidx = (unsigned int)data->chip_data - 1;
+        if (irqidx > 3) /* only mask PCI interrupts here */
+                return;
+
+        spin_lock_irqsave(&grpci2_dev_lock, flags);
+        REGSTORE(priv->regs->ctrl, REGLOAD(priv->regs->ctrl) & ~(1 << irqidx));
+        spin_unlock_irqrestore(&grpci2_dev_lock, flags);
+}
+
+static void grpci2_unmask_irq(struct irq_data *data)
+{
+        unsigned long flags;
+        unsigned int irqidx;
+        struct grpci2_priv *priv = grpci2priv;
+
+        irqidx = (unsigned int)data->chip_data - 1;
+        if (irqidx > 3) /* only unmask PCI interrupts here */
+                return;
+
+        spin_lock_irqsave(&grpci2_dev_lock, flags);
+        REGSTORE(priv->regs->ctrl, REGLOAD(priv->regs->ctrl) | (1 << irqidx));
+        spin_unlock_irqrestore(&grpci2_dev_lock, flags);
+}
+
+static unsigned int grpci2_startup_irq(struct irq_data *data)
+{
+        grpci2_unmask_irq(data);
+        return 0;
+}
+
+static void grpci2_shutdown_irq(struct irq_data *data)
+{
+        grpci2_mask_irq(data);
+}
+
+static struct irq_chip grpci2_irq = {
+        .name           = "grpci2",
+        .irq_startup    = grpci2_startup_irq,
+        .irq_shutdown   = grpci2_shutdown_irq,
+        .irq_mask       = grpci2_mask_irq,
+        .irq_unmask     = grpci2_unmask_irq,
+};
+
+/* Handle one or multiple IRQs from the PCI core */
+static void grpci2_pci_flow_irq(unsigned int irq, struct irq_desc *desc)
+{
+        struct grpci2_priv *priv = grpci2priv;
+        int i, ack = 0;
+        unsigned int ctrl, sts_cap, pci_ints;
+
+        ctrl = REGLOAD(priv->regs->ctrl);
+        sts_cap = REGLOAD(priv->regs->sts_cap);
+
+        /* Error Interrupt? */
+        if (sts_cap & STS_ERR_IRQ) {
+                generic_handle_irq(priv->virq_err);
+                ack = 1;
+        }
+
+        /* PCI Interrupt? */
+        pci_ints = ((~sts_cap) >> STS_INTSTS_BIT) & ctrl & CTRL_HOSTINT;
+        if (pci_ints) {
+                /* Call respective PCI Interrupt handler */
+                for (i = 0; i < 4; i++) {
+                        if (pci_ints & (1 << i))
+                                generic_handle_irq(priv->irq_map[i]);
+                }
+                ack = 1;
+        }
+
+        /*
+         * Decode DMA Interrupt only when shared with Err and PCI INTX#, when
+         * the DMA is a unique IRQ the DMA interrupts doesn't end up here, they
+         * goes directly to DMA ISR.
+         */
+        if ((priv->irq_mode == 0) && (sts_cap & (STS_IDMA | STS_IDMAERR))) {
+                generic_handle_irq(priv->virq_dma);
+                ack = 1;
+        }
+
+        /*
+         * Call "first level" IRQ chip end-of-irq handler. It will ACK LEON IRQ
+         * Controller, this must be done after IRQ sources have been handled to
+         * avoid double IRQ generation
+         */
+        if (ack)
+                desc->irq_data.chip->irq_eoi(&desc->irq_data);
+}
+
+/* Create a virtual IRQ */
+static unsigned int grpci2_build_device_irq(unsigned int irq)
+{
+        unsigned int virq = 0, pil;
+
+        pil = 1 << 8;
+        virq = irq_alloc(irq, pil);
+        if (virq == 0)
+                goto out;
+
+        irq_set_chip_and_handler_name(virq, &grpci2_irq, handle_simple_irq,
+                                      "pcilvl");
+        irq_set_chip_data(virq, (void *)irq);
+
+out:
+        return virq;
+}
+
+void grpci2_hw_init(struct grpci2_priv *priv)
+{
+        u32 ahbadr, pciadr, bar_sz, capptr, io_map, data;
+        struct grpci2_regs *regs = priv->regs;
+        int i;
+        struct grpci2_barcfg *barcfg = priv->tgtbars;
+
+        /* Reset any earlier setup */
+        if (priv->do_reset) {
+                printk(KERN_INFO "GRPCI2: Resetting PCI bus\n");
+                REGSTORE(regs->ctrl, CTRL_RESET);
+                ssleep(1); /* Wait for boards to settle */
+        }
+        REGSTORE(regs->ctrl, 0);
+        REGSTORE(regs->sts_cap, ~0); /* Clear Status */
+        REGSTORE(regs->dma_ctrl, 0);
+        REGSTORE(regs->dma_bdbase, 0);
+
+        /* Translate I/O accesses to 0, I/O Space always @ PCI low 64Kbytes */
+        REGSTORE(regs->io_map, REGLOAD(regs->io_map) & 0x0000ffff);
+
+        /* set 1:1 mapping between AHB -> PCI memory space, for all Masters
+         * Each AHB master has it's own mapping registers. Max 16 AHB masters.
+         */
+        for (i = 0; i < 16; i++)
+                REGSTORE(regs->ahbmst_map[i], priv->pci_area);
+
+        /* Get the GRPCI2 Host PCI ID */
+        grpci2_cfg_r32(priv, 0, 0, PCI_VENDOR_ID, &priv->pciid);
+
+        /* Get address to first (always defined) capability structure */
+        grpci2_cfg_r8(priv, 0, 0, PCI_CAPABILITY_LIST, &capptr);
+
+        /* Enable/Disable Byte twisting */
+        grpci2_cfg_r32(priv, 0, 0, capptr+CAP9_IOMAP_OFS, &io_map);
+        io_map = (io_map & ~0x1) | (priv->bt_enabled ? 1 : 0);
+        grpci2_cfg_w32(priv, 0, 0, capptr+CAP9_IOMAP_OFS, io_map);
+
+        /* Setup the Host's PCI Target BARs for other peripherals to access,
+         * and do DMA to the host's memory. The target BARs can be sized and
+         * enabled individually.
+         *
+         * User may set custom target BARs, but default is:
+         * The first BARs is used to map kernel low (DMA is part of normal
+         * region on sparc which is SRMMU_MAXMEM big) main memory 1:1 to the
+         * PCI bus, the other BARs are disabled. We assume that the first BAR
+         * is always available.
+         */
+        for (i = 0; i < 6; i++) {
+                if (barcfg[i].pciadr != ~0 && barcfg[i].ahbadr != ~0) {
+                        /* Target BARs must have the proper alignment */
+                        ahbadr = barcfg[i].ahbadr;
+                        pciadr = barcfg[i].pciadr;
+                        bar_sz = ((pciadr - 1) & ~pciadr) + 1;
+                } else {
+                        if (i == 0) {
+                                /* Map main memory */
+                                bar_sz = 0xf0000008; /* 256MB prefetchable */
+                                ahbadr = 0xf0000000 & (u32)__pa(PAGE_ALIGN(
+                                        (unsigned long) &_end));
+                                pciadr = ahbadr;
+                        } else {
+                                bar_sz = 0;
+                                ahbadr = 0;
+                                pciadr = 0;
+                        }
+                }
+                grpci2_cfg_w32(priv, 0, 0, capptr+CAP9_BARSIZE_OFS+i*4, bar_sz);
+                grpci2_cfg_w32(priv, 0, 0, PCI_BASE_ADDRESS_0+i*4, pciadr);
+                grpci2_cfg_w32(priv, 0, 0, capptr+CAP9_BAR_OFS+i*4, ahbadr);
+                printk(KERN_INFO "        TGT BAR[%d]: 0x%08x (PCI)-> 0x%08x\n",
+                        i, pciadr, ahbadr);
+        }
+
+        /* set as bus master and enable pci memory responses */
+        grpci2_cfg_r32(priv, 0, 0, PCI_COMMAND, &data);
+        data |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
+        grpci2_cfg_w32(priv, 0, 0, PCI_COMMAND, data);
+
+        /* Enable Error respone (CPU-TRAP) on illegal memory access. */
+        REGSTORE(regs->ctrl, CTRL_ER | CTRL_PE);
+}
+
+static irqreturn_t grpci2_jump_interrupt(int irq, void *arg)
+{
+        printk(KERN_ERR "GRPCI2: Jump IRQ happened\n");
+        return IRQ_NONE;
+}
+
+/* Handle GRPCI2 Error Interrupt */
+static irqreturn_t grpci2_err_interrupt(int irq, void *arg)
+{
+        struct grpci2_priv *priv = arg;
+        struct grpci2_regs *regs = priv->regs;
+        unsigned int status;
+
+        status = REGLOAD(regs->sts_cap);
+        if ((status & STS_ERR_IRQ) == 0)
+                return IRQ_NONE;
+
+        if (status & STS_IPARERR)
+                printk(KERN_ERR "GRPCI2: Parity Error\n");
+
+        if (status & STS_ITGTABRT)
+                printk(KERN_ERR "GRPCI2: Target Abort\n");
+
+        if (status & STS_IMSTABRT)
+                printk(KERN_ERR "GRPCI2: Master Abort\n");
+
+        if (status & STS_ISYSERR)
+                printk(KERN_ERR "GRPCI2: System Error\n");
+
+        /* Clear handled INT TYPE IRQs */
+        REGSTORE(regs->sts_cap, status & STS_ERR_IRQ);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit grpci2_of_probe(struct platform_device *ofdev)
+{
+        struct grpci2_regs *regs;
+        struct grpci2_priv *priv;
+        int err, i, len;
+        const int *tmp;
+        unsigned int capability;
+
+        if (grpci2priv) {
+                printk(KERN_ERR "GRPCI2: only one GRPCI2 core supported\n");
+                return -ENODEV;
+        }
+
+        if (ofdev->num_resources < 3) {
+                printk(KERN_ERR "GRPCI2: not enough APB/AHB resources\n");
+                return -EIO;
+        }
+
+        /* Find Device Address */
+        regs = of_ioremap(&ofdev->resource[0], 0,
+                          resource_size(&ofdev->resource[0]),
+                          "grlib-grpci2 regs");
+        if (regs == NULL) {
+                printk(KERN_ERR "GRPCI2: ioremap failed\n");
+                return -EIO;
+        }
+
+        /*
+         * Check that we're in Host Slot and that we can act as a Host Bridge
+         * and not only as target.
+         */
+        capability = REGLOAD(regs->sts_cap);
+        if ((capability & STS_HOST) || !(capability & STS_MST)) {
+                printk(KERN_INFO "GRPCI2: not in host system slot\n");
+                err = -EIO;
+                goto err1;
+        }
+
+        priv = grpci2priv = kzalloc(sizeof(struct grpci2_priv), GFP_KERNEL);
+        if (grpci2priv == NULL) {
+                err = -ENOMEM;
+                goto err1;
+        }
+        memset(grpci2priv, 0, sizeof(*grpci2priv));
+        priv->regs = regs;
+        priv->irq = ofdev->archdata.irqs[0]; /* BASE IRQ */
+        priv->irq_mode = (capability & STS_IRQMODE) >> STS_IRQMODE_BIT;
+
+        printk(KERN_INFO "GRPCI2: host found at %p, irq%d\n", regs, priv->irq);
+
+        /* Byte twisting should be made configurable from kernel command line */
+        priv->bt_enabled = 1;
+
+        /* Let user do custom Target BAR assignment */
+        tmp = of_get_property(ofdev->dev.of_node, "barcfg", &len);
+        if (tmp && (len == 2*4*6))
+                memcpy(priv->tgtbars, tmp, 2*4*6);
+        else
+                memset(priv->tgtbars, -1, 2*4*6);
+
+        /* Limit IRQ unmasking in irq_mode 2 and 3 */
+        tmp = of_get_property(ofdev->dev.of_node, "irq_mask", &len);
+        if (tmp && (len == 4))
+                priv->do_reset = *tmp;
+        else
+                priv->irq_mask = 0xf;
+
+        /* Optional PCI reset. Force PCI reset on startup */
+        tmp = of_get_property(ofdev->dev.of_node, "reset", &len);
+        if (tmp && (len == 4))
+                priv->do_reset = *tmp;
+        else
+                priv->do_reset = 0;
+
+        /* Find PCI Memory, I/O and Configuration Space Windows */
+        priv->pci_area = ofdev->resource[1].start;
+        priv->pci_area_end = ofdev->resource[1].end+1;
+        priv->pci_io = ofdev->resource[2].start;
+        priv->pci_conf = ofdev->resource[2].start + 0x10000;
+        priv->pci_conf_end = priv->pci_conf + 0x10000;
+        priv->pci_io_va = (unsigned long)ioremap(priv->pci_io, 0x10000);
+        if (!priv->pci_io_va) {
+                err = -EIO;
+                goto err2;
+        }
+
+        printk(KERN_INFO
+                "GRPCI2: MEMORY SPACE [0x%08lx - 0x%08lx]\n"
+                "        I/O    SPACE [0x%08lx - 0x%08lx]\n"
+                "        CONFIG SPACE [0x%08lx - 0x%08lx]\n",
+                priv->pci_area, priv->pci_area_end-1,
+                priv->pci_io, priv->pci_conf-1,
+                priv->pci_conf, priv->pci_conf_end-1);
+
+        /*
+         * I/O Space resources in I/O Window mapped into Virtual Adr Space
+         * We never use low 4KB because some devices seem have problems using
+         * address 0.
+         */
+        memset(&priv->info.io_space, 0, sizeof(struct resource));
+        priv->info.io_space.name = "GRPCI2 PCI I/O Space";
+        priv->info.io_space.start = priv->pci_io_va + 0x1000;
+        priv->info.io_space.end = priv->pci_io_va + 0x10000 - 1;
+        priv->info.io_space.flags = IORESOURCE_IO;
+
+        /*
+         * GRPCI2 has no prefetchable memory, map everything as
+         * non-prefetchable memory
+         */
+        memset(&priv->info.mem_space, 0, sizeof(struct resource));
+        priv->info.mem_space.name = "GRPCI2 PCI MEM Space";
+        priv->info.mem_space.start = priv->pci_area;
+        priv->info.mem_space.end = priv->pci_area_end - 1;
+        priv->info.mem_space.flags = IORESOURCE_MEM;
+
+        if (request_resource(&iomem_resource, &priv->info.mem_space) < 0)
+                goto err3;
+        if (request_resource(&ioport_resource, &priv->info.io_space) < 0)
+                goto err4;
+
+        grpci2_hw_init(priv);
+
+        /*
+         * Get PCI Interrupt to System IRQ mapping and setup IRQ handling
+         * Error IRQ always on PCI INTA.
+         */
+        if (priv->irq_mode < 2) {
+                /* All PCI interrupts are shared using the same system IRQ */
+                leon_update_virq_handling(priv->irq, grpci2_pci_flow_irq,
+                                         "pcilvl", 0);
+
+                priv->irq_map[0] = grpci2_build_device_irq(1);
+                priv->irq_map[1] = grpci2_build_device_irq(2);
+                priv->irq_map[2] = grpci2_build_device_irq(3);
+                priv->irq_map[3] = grpci2_build_device_irq(4);
+
+                priv->virq_err = grpci2_build_device_irq(5);
+                if (priv->irq_mode & 1)
+                        priv->virq_dma = ofdev->archdata.irqs[1];
+                else
+                        priv->virq_dma = grpci2_build_device_irq(6);
+
+                /* Enable IRQs on LEON IRQ controller */
+                err = request_irq(priv->irq, grpci2_jump_interrupt, 0,
+                                        "GRPCI2_JUMP", priv);
+                if (err)
+                        printk(KERN_ERR "GRPCI2: ERR IRQ request failed\n");
+        } else {
+                /* All PCI interrupts have an unique IRQ interrupt */
+                for (i = 0; i < 4; i++) {
+                        /* Make LEON IRQ layer handle level IRQ by acking */
+                        leon_update_virq_handling(ofdev->archdata.irqs[i],
+                                                 handle_fasteoi_irq, "pcilvl",
+                                                 1);
+                        priv->irq_map[i] = ofdev->archdata.irqs[i];
+                }
+                priv->virq_err = priv->irq_map[0];
+                if (priv->irq_mode & 1)
+                        priv->virq_dma = ofdev->archdata.irqs[4];
+                else
+                        priv->virq_dma = priv->irq_map[0];
+
+                /* Unmask all PCI interrupts, request_irq will not do that */
+                REGSTORE(regs->ctrl, REGLOAD(regs->ctrl)|(priv->irq_mask&0xf));
+        }
+
+        /* Setup IRQ handler for non-configuration space access errors */
+        err = request_irq(priv->virq_err, grpci2_err_interrupt, IRQF_SHARED,
+                                "GRPCI2_ERR", priv);
+        if (err) {
+                printk(KERN_DEBUG "GRPCI2: ERR VIRQ request failed: %d\n", err);
+                goto err5;
+        }
+
+        /*
+         * Enable Error Interrupts. PCI interrupts are unmasked once request_irq
+         * is called by the PCI Device drivers
+         */
+        REGSTORE(regs->ctrl, REGLOAD(regs->ctrl) | CTRL_EI | CTRL_SI);
+
+        /* Init common layer and scan buses */
+        priv->info.ops = &grpci2_ops;
+        priv->info.map_irq = grpci2_map_irq;
+        leon_pci_init(ofdev, &priv->info);
+
+        return 0;
+
+err5:
+        release_resource(&priv->info.io_space);
+err4:
+        release_resource(&priv->info.mem_space);
+err3:
+        err = -ENOMEM;
+        iounmap((void *)priv->pci_io_va);
+err2:
+        kfree(priv);
+err1:
+        of_iounmap(&ofdev->resource[0], regs,
+                resource_size(&ofdev->resource[0]));
+        return err;
+}
+
+static struct of_device_id grpci2_of_match[] = {
+        {
+         .name = "GAISLER_GRPCI2",
+         },
+        {
+         .name = "01_07c",
+         },
+        {},
+};
+
+static struct platform_driver grpci2_of_driver = {
+        .driver = {
+                .name = "grpci2",
+                .owner = THIS_MODULE,
+                .of_match_table = grpci2_of_match,
+        },
+        .probe = grpci2_of_probe,
+};
+
+static int __init grpci2_init(void)
+{
+        return platform_driver_register(&grpci2_of_driver);
+}
+
+subsys_initcall(grpci2_init);
diff --git a/arch/sparc/kernel/leon_pmc.c b/arch/sparc/kernel/leon_pmc.c
new file mode 100644
index 000000000000..519ca923f59f
--- /dev/null
+++ b/arch/sparc/kernel/leon_pmc.c
@@ -0,0 +1,82 @@
+/* leon_pmc.c: LEON Power-down cpu_idle() handler
+ *
+ * Copyright (C) 2011 Daniel Hellstrom (daniel@gaisler.com) Aeroflex Gaisler AB
+ */
+
+#include <linux/init.h>
+#include <linux/pm.h>
+
+#include <asm/leon_amba.h>
+#include <asm/leon.h>
+
+/* List of Systems that need fixup instructions around power-down instruction */
+unsigned int pmc_leon_fixup_ids[] = {
+        AEROFLEX_UT699,
+        GAISLER_GR712RC,
+        LEON4_NEXTREME1,
+        0
+};
+
+int pmc_leon_need_fixup(void)
+{
+        unsigned int systemid = amba_system_id >> 16;
+        unsigned int *id;
+
+        id = &pmc_leon_fixup_ids[0];
+        while (*id != 0) {
+                if (*id == systemid)
+                        return 1;
+                id++;
+        }
+
+        return 0;
+}
+
+/*
+ * CPU idle callback function for systems that need some extra handling
+ * See .../arch/sparc/kernel/process.c
+ */
+void pmc_leon_idle_fixup(void)
+{
+        /* Prepare an address to a non-cachable region. APB is always
+         * none-cachable. One instruction is executed after the Sleep
+         * instruction, we make sure to read the bus and throw away the
+         * value by accessing a non-cachable area, also we make sure the
+         * MMU does not get a TLB miss here by using the MMU BYPASS ASI.
+         */
+        register unsigned int address = (unsigned int)leon3_irqctrl_regs;
+        __asm__ __volatile__ (
+                "mov    %%g0, %%asr19\n"
+                "lda    [%0] %1, %%g0\n"
+                :
+                : "r"(address), "i"(ASI_LEON_BYPASS));
+}
+
+/*
+ * CPU idle callback function
+ * See .../arch/sparc/kernel/process.c
+ */
+void pmc_leon_idle(void)
+{
+        /* For systems without power-down, this will be no-op */
+        __asm__ __volatile__ ("mov      %g0, %asr19\n\t");
+}
+
+/* Install LEON Power Down function */
+static int __init leon_pmc_install(void)
+{
+        /* Assign power management IDLE handler */
+        if (pmc_leon_need_fixup())
+                pm_idle = pmc_leon_idle_fixup;
+        else
+                pm_idle = pmc_leon_idle;
+
+        printk(KERN_INFO "leon: power management initialized\n");
+
+        return 0;
+}
+
+/* This driver is not critical to the boot process, don't care
+ * if initialized late.
+ */
+late_initcall(leon_pmc_install);
diff --git a/arch/sparc/kernel/leon_smp.c b/arch/sparc/kernel/leon_smp.c
index e1656fc41ccb..fe8fb44c609c 100644
--- a/arch/sparc/kernel/leon_smp.c
+++ b/arch/sparc/kernel/leon_smp.c
@@ -12,9 +12,9 @@
 #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/of.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/mm.h>
@@ -30,6 +30,7 @@
 #include <asm/ptrace.h>
 #include <asm/atomic.h>
 #include <asm/irq_regs.h>
+#include <asm/traps.h>
 
 #include <asm/delay.h>
 #include <asm/irq.h>
@@ -42,6 +43,8 @@
 #include <asm/leon.h>
 #include <asm/leon_amba.h>
 
+#include "kernel.h"
+
 #ifdef CONFIG_SPARC_LEON
 
 #include "irq.h"
@@ -49,15 +52,18 @@
 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 void leon_ipi_init(void);
+
+/* IRQ number of LEON IPIs */
+int leon_ipi_irq = LEON3_IRQ_IPI_DEFAULT;
 
 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)
+        __asm__ __volatile__("swapa [%2] %3, %0\n\t" : "=&r"(val)
+                             : "0"(val), "r"(ptr), "i"(ASI_LEON_DCACHE_MISS)
                              : "memory");
         return val;
 }
@@ -93,8 +99,6 @@ void __cpuinit leon_callin(void)
         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 */);
@@ -103,11 +107,11 @@ void __cpuinit leon_callin(void)
         atomic_inc(&init_mm.mm_count);
         current->active_mm = &init_mm;
 
-        while (!cpu_isset(cpuid, smp_commenced_mask))
+        while (!cpumask_test_cpu(cpuid, &smp_commenced_mask))
                 mb();
 
         local_irq_enable();
-        cpu_set(cpuid, cpu_online_map);
+        set_cpu_online(cpuid, true);
 }
 
 /*
@@ -178,13 +182,16 @@ void __init leon_boot_cpus(void)
         int nrcpu = leon_smp_nrcpus();
         int me = smp_processor_id();
 
+        /* Setup IPI */
+        leon_ipi_init();
+
         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_enable_irq_cpu(leon_ipi_irq, me);
 
         leon_smp_setbroadcast(1 << LEON3_IRQ_TICKER);
 
@@ -219,6 +226,10 @@ int __cpuinit leon_boot_one_cpu(int i)
                (unsigned int)&leon3_irqctrl_regs->mpstatus);
         local_flush_cache_all();
 
+        /* Make sure all IRQs are of from the start for this new CPU */
+        LEON_BYPASS_STORE_PA(&leon3_irqctrl_regs->mask[i], 0);
+
+        /* Wake one CPU */
         LEON_BYPASS_STORE_PA(&(leon3_irqctrl_regs->mpstatus), 1 << i);
 
         /* wheee... it's going... */
@@ -235,7 +246,7 @@ int __cpuinit leon_boot_one_cpu(int i)
         } 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);
+                leon_enable_irq_cpu(leon_ipi_irq, i);
         }
 
         local_flush_cache_all();
@@ -261,24 +272,24 @@ void __init leon_smp_done(void)
         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);
+        if (!cpu_present(1)) {
+                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);
+        if (!cpu_present(2)) {
+                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);
+        if (!cpu_present(3)) {
+                ClearPageReserved(virt_to_page(&trapbase_cpu3));
+                init_page_count(virt_to_page(&trapbase_cpu3));
+                free_page((unsigned long)&trapbase_cpu3);
                 totalram_pages++;
                 num_physpages++;
         }
@@ -291,6 +302,99 @@ void leon_irq_rotate(int cpu)
 {
 }
 
+struct leon_ipi_work {
+        int single;
+        int msk;
+        int resched;
+};
+
+static DEFINE_PER_CPU_SHARED_ALIGNED(struct leon_ipi_work, leon_ipi_work);
+
+/* Initialize IPIs on the LEON, in order to save IRQ resources only one IRQ
+ * is used for all three types of IPIs.
+ */
+static void __init leon_ipi_init(void)
+{
+        int cpu, len;
+        struct leon_ipi_work *work;
+        struct property *pp;
+        struct device_node *rootnp;
+        struct tt_entry *trap_table;
+        unsigned long flags;
+
+        /* Find IPI IRQ or stick with default value */
+        rootnp = of_find_node_by_path("/ambapp0");
+        if (rootnp) {
+                pp = of_find_property(rootnp, "ipi_num", &len);
+                if (pp && (*(int *)pp->value))
+                        leon_ipi_irq = *(int *)pp->value;
+        }
+        printk(KERN_INFO "leon: SMP IPIs at IRQ %d\n", leon_ipi_irq);
+
+        /* Adjust so that we jump directly to smpleon_ipi */
+        local_irq_save(flags);
+        trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (leon_ipi_irq - 1)];
+        trap_table->inst_three += smpleon_ipi - real_irq_entry;
+        local_flush_cache_all();
+        local_irq_restore(flags);
+
+        for_each_possible_cpu(cpu) {
+                work = &per_cpu(leon_ipi_work, cpu);
+                work->single = work->msk = work->resched = 0;
+        }
+}
+
+static void leon_ipi_single(int cpu)
+{
+        struct leon_ipi_work *work = &per_cpu(leon_ipi_work, cpu);
+
+        /* Mark work */
+        work->single = 1;
+
+        /* Generate IRQ on the CPU */
+        set_cpu_int(cpu, leon_ipi_irq);
+}
+
+static void leon_ipi_mask_one(int cpu)
+{
+        struct leon_ipi_work *work = &per_cpu(leon_ipi_work, cpu);
+
+        /* Mark work */
+        work->msk = 1;
+
+        /* Generate IRQ on the CPU */
+        set_cpu_int(cpu, leon_ipi_irq);
+}
+
+static void leon_ipi_resched(int cpu)
+{
+        struct leon_ipi_work *work = &per_cpu(leon_ipi_work, cpu);
+
+        /* Mark work */
+        work->resched = 1;
+
+        /* Generate IRQ on the CPU (any IRQ will cause resched) */
+        set_cpu_int(cpu, leon_ipi_irq);
+}
+
+void leonsmp_ipi_interrupt(void)
+{
+        struct leon_ipi_work *work = &__get_cpu_var(leon_ipi_work);
+
+        if (work->single) {
+                work->single = 0;
+                smp_call_function_single_interrupt();
+        }
+        if (work->msk) {
+                work->msk = 0;
+                smp_call_function_interrupt();
+        }
+        if (work->resched) {
+                work->resched = 0;
+                smp_resched_interrupt();
+        }
+}
+
 static struct smp_funcall {
         smpfunc_t func;
         unsigned long arg1;
@@ -336,10 +440,10 @@ static void leon_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
                 {
                         register int i;
 
-                        cpu_clear(smp_processor_id(), mask);
-                        cpus_and(mask, cpu_online_map, mask);
+                        cpumask_clear_cpu(smp_processor_id(), &mask);
+                        cpumask_and(&mask, cpu_online_mask, &mask);
                         for (i = 0; i <= high; i++) {
-                                if (cpu_isset(i, mask)) {
+                                if (cpumask_test_cpu(i, &mask)) {
                                         ccall_info.processors_in[i] = 0;
                                         ccall_info.processors_out[i] = 0;
                                         set_cpu_int(i, LEON3_IRQ_CROSS_CALL);
@@ -353,7 +457,7 @@ static void leon_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
 
                         i = 0;
                         do {
-                                if (!cpu_isset(i, mask))
+                                if (!cpumask_test_cpu(i, &mask))
                                         continue;
 
                                 while (!ccall_info.processors_in[i])
@@ -362,7 +466,7 @@ static void leon_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
 
                         i = 0;
                         do {
-                                if (!cpu_isset(i, mask))
+                                if (!cpumask_test_cpu(i, &mask))
                                         continue;
 
                                 while (!ccall_info.processors_out[i])
@@ -385,27 +489,23 @@ void leon_cross_call_irq(void)
         ccall_info.processors_out[i] = 1;
 }
 
-void leon_percpu_timer_interrupt(struct pt_regs *regs)
+irqreturn_t leon_percpu_timer_interrupt(int irq, void *unused)
 {
-        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);
+                int user = user_mode(get_irq_regs());
 
-                irq_enter();
                 update_process_times(user);
-                irq_exit();
 
                 prof_counter(cpu) = prof_multiplier(cpu);
         }
-        set_irq_regs(old_regs);
+
+        return IRQ_HANDLED;
 }
 
 static void __init smp_setup_percpu_timer(void)
@@ -438,15 +538,6 @@ void __init leon_blackbox_current(unsigned *addr)
 
 }
 
-/*
- * 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 */
@@ -457,13 +548,9 @@ void __init leon_init_smp(void)
         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
-
+        BTFIXUPSET_CALL(smp_ipi_resched, leon_ipi_resched, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(smp_ipi_single, leon_ipi_single, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(smp_ipi_mask_one, leon_ipi_mask_one, BTFIXUPCALL_NORM);
 }
 
 #endif /* CONFIG_SPARC_LEON */
diff --git a/arch/sparc/kernel/mdesc.c b/arch/sparc/kernel/mdesc.c
index 83e85c2e802a..42f28c7420e1 100644
--- a/arch/sparc/kernel/mdesc.c
+++ b/arch/sparc/kernel/mdesc.c
@@ -107,7 +107,7 @@ static struct mdesc_handle * __init mdesc_memblock_alloc(unsigned int mdesc_size
         return hp;
 }
 
-static void mdesc_memblock_free(struct mdesc_handle *hp)
+static void __init mdesc_memblock_free(struct mdesc_handle *hp)
 {
         unsigned int alloc_size;
         unsigned long start;
@@ -768,7 +768,7 @@ static void * __cpuinit mdesc_iterate_over_cpus(void *(*func)(struct mdesc_handl
                                cpuid, NR_CPUS);
                         continue;
                 }
-                if (!cpu_isset(cpuid, *mask))
+                if (!cpumask_test_cpu(cpuid, mask))
                         continue;
 #endif
 
@@ -890,6 +890,7 @@ static ssize_t mdesc_read(struct file *file, char __user *buf,
 static const struct file_operations mdesc_fops = {
         .read   = mdesc_read,
         .owner  = THIS_MODULE,
+        .llseek = noop_llseek,
 };
 
 static struct miscdevice mdesc_misc = {
diff --git a/arch/sparc/kernel/module.c b/arch/sparc/kernel/module.c
index f848aadf54dc..99ba5baa9497 100644
--- a/arch/sparc/kernel/module.c
+++ b/arch/sparc/kernel/module.c
@@ -18,19 +18,16 @@
 #include <asm/spitfire.h>
 
 #ifdef CONFIG_SPARC64
-static void *module_map(unsigned long size)
-{
-        struct vm_struct *area;
 
-        size = PAGE_ALIGN(size);
-        if (!size || size > MODULES_LEN)
-                return NULL;
+#include <linux/jump_label.h>
 
-        area = __get_vm_area(size, VM_ALLOC, MODULES_VADDR, MODULES_END);
-        if (!area)
+static void *module_map(unsigned long size)
+{
+        if (PAGE_ALIGN(size) > MODULES_LEN)
                 return NULL;
-
-        return __vmalloc_area(area, GFP_KERNEL, PAGE_KERNEL);
+        return __vmalloc_node_range(size, 1, MODULES_VADDR, MODULES_END,
+                                GFP_KERNEL, PAGE_KERNEL, -1,
+                                __builtin_return_address(0));
 }
 
 static char *dot2underscore(char *name)
@@ -217,7 +214,7 @@ int apply_relocate_add(Elf_Shdr *sechdrs,
                                me->name,
                                (int) (ELF_R_TYPE(rel[i].r_info) & 0xff));
                         return -ENOEXEC;
-                };
+                }
         }
         return 0;
 }
@@ -227,6 +224,9 @@ int module_finalize(const Elf_Ehdr *hdr,
                     const Elf_Shdr *sechdrs,
                     struct module *me)
 {
+        /* make jump label nops */
+        jump_label_apply_nops(me);
+
         /* Cheetah's I-cache is fully coherent.  */
         if (tlb_type == spitfire) {
                 unsigned long va;
diff --git a/arch/sparc/kernel/nmi.c b/arch/sparc/kernel/nmi.c
index a4bd7ba74c89..300f810142f5 100644
--- a/arch/sparc/kernel/nmi.c
+++ b/arch/sparc/kernel/nmi.c
@@ -270,8 +270,6 @@ int __init nmi_init(void)
                         atomic_set(&nmi_active, -1);
                 }
         }
-        if (!err)
-                init_hw_perf_events();
 
         return err;
 }
diff --git a/arch/sparc/kernel/of_device_32.c b/arch/sparc/kernel/of_device_32.c
index 2d055a1e9cc2..a312af40ea84 100644
--- a/arch/sparc/kernel/of_device_32.c
+++ b/arch/sparc/kernel/of_device_32.c
@@ -13,6 +13,7 @@
 #include <asm/leon_amba.h>
 
 #include "of_device_common.h"
+#include "irq.h"
 
 /*
  * PCI bus specific translator
@@ -355,7 +356,8 @@ static struct platform_device * __init scan_one_device(struct device_node *dp,
         if (intr) {
                 op->archdata.num_irqs = len / sizeof(struct linux_prom_irqs);
                 for (i = 0; i < op->archdata.num_irqs; i++)
-                        op->archdata.irqs[i] = intr[i].pri;
+                        op->archdata.irqs[i] =
+                            sparc_irq_config.build_device_irq(op, intr[i].pri);
         } else {
                 const unsigned int *irq =
                         of_get_property(dp, "interrupts", &len);
@@ -363,64 +365,13 @@ static struct platform_device * __init scan_one_device(struct device_node *dp,
                 if (irq) {
                         op->archdata.num_irqs = len / sizeof(unsigned int);
                         for (i = 0; i < op->archdata.num_irqs; i++)
-                                op->archdata.irqs[i] = irq[i];
+                                op->archdata.irqs[i] =
+                                    sparc_irq_config.build_device_irq(op, irq[i]);
                 } else {
                         op->archdata.num_irqs = 0;
                 }
         }
-        if (sparc_cpu_model == sun4d) {
-                static int pil_to_sbus[] = {
-                        0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0,
-                };
-                struct device_node *io_unit, *sbi = dp->parent;
-                const struct linux_prom_registers *regs;
-                int board, slot;
-
-                while (sbi) {
-                        if (!strcmp(sbi->name, "sbi"))
-                                break;
-
-                        sbi = sbi->parent;
-                }
-                if (!sbi)
-                        goto build_resources;
-
-                regs = of_get_property(dp, "reg", NULL);
-                if (!regs)
-                        goto build_resources;
-
-                slot = regs->which_io;
-
-                /* If SBI's parent is not io-unit or the io-unit lacks
-                 * a "board#" property, something is very wrong.
-                 */
-                if (!sbi->parent || strcmp(sbi->parent->name, "io-unit")) {
-                        printk("%s: Error, parent is not io-unit.\n",
-                               sbi->full_name);
-                        goto build_resources;
-                }
-                io_unit = sbi->parent;
-                board = of_getintprop_default(io_unit, "board#", -1);
-                if (board == -1) {
-                        printk("%s: Error, lacks board# property.\n",
-                               io_unit->full_name);
-                        goto build_resources;
-                }
-
-                for (i = 0; i < op->archdata.num_irqs; i++) {
-                        int this_irq = op->archdata.irqs[i];
-                        int sbusl = pil_to_sbus[this_irq];
-
-                        if (sbusl)
-                                this_irq = (((board + 1) << 5) +
-                                            (sbusl << 2) +
-                                            slot);
-
-                        op->archdata.irqs[i] = this_irq;
-                }
-        }
 
-build_resources:
         build_device_resources(op, parent);
 
         op->dev.parent = parent;
diff --git a/arch/sparc/kernel/of_device_64.c b/arch/sparc/kernel/of_device_64.c
index 63cd4e5d47c2..3bb2eace58cf 100644
--- a/arch/sparc/kernel/of_device_64.c
+++ b/arch/sparc/kernel/of_device_64.c
@@ -459,7 +459,7 @@ apply_interrupt_map(struct device_node *dp, struct device_node *pp,
                  *
                  * Handle this by deciding that, if we didn't get a
                  * match in the parent's 'interrupt-map', and the
-                 * parent is an IRQ translater, then use the parent as
+                 * parent is an IRQ translator, then use the parent as
                  * our IRQ controller.
                  */
                 if (pp->irq_trans)
@@ -622,8 +622,9 @@ static unsigned int __init build_one_device_irq(struct platform_device *op,
 out:
         nid = of_node_to_nid(dp);
         if (nid != -1) {
-                cpumask_t numa_mask = *cpumask_of_node(nid);
+                cpumask_t numa_mask;
 
+                cpumask_copy(&numa_mask, cpumask_of_node(nid));
                 irq_set_affinity(irq, &numa_mask);
         }
 
diff --git a/arch/sparc/kernel/of_device_common.c b/arch/sparc/kernel/of_device_common.c
index 49ddff56cb04..cb15bbf8a201 100644
--- a/arch/sparc/kernel/of_device_common.c
+++ b/arch/sparc/kernel/of_device_common.c
@@ -22,6 +22,33 @@ unsigned int irq_of_parse_and_map(struct device_node *node, int index)
 }
 EXPORT_SYMBOL(irq_of_parse_and_map);
 
+int of_address_to_resource(struct device_node *node, int index,
+                           struct resource *r)
+{
+        struct platform_device *op = of_find_device_by_node(node);
+
+        if (!op || index >= op->num_resources)
+                return -EINVAL;
+
+        memcpy(r, &op->archdata.resource[index], sizeof(*r));
+        return 0;
+}
+EXPORT_SYMBOL_GPL(of_address_to_resource);
+
+void __iomem *of_iomap(struct device_node *node, int index)
+{
+        struct platform_device *op = of_find_device_by_node(node);
+        struct resource *r;
+
+        if (!op || index >= op->num_resources)
+                return NULL;
+
+        r = &op->archdata.resource[index];
+
+        return of_ioremap(r, 0, resource_size(r), (char *) r->name);
+}
+EXPORT_SYMBOL(of_iomap);
+
 /* Take the archdata values for IOMMU, STC, and HOSTDATA found in
  * BUS and propagate to all child platform_device objects.
  */
diff --git a/arch/sparc/kernel/pci.c b/arch/sparc/kernel/pci.c
index 4137579d9adc..713dc91020a6 100644
--- a/arch/sparc/kernel/pci.c
+++ b/arch/sparc/kernel/pci.c
@@ -675,6 +675,7 @@ static void __devinit pci_bus_register_of_sysfs(struct pci_bus *bus)
                  * humanoid.
                  */
                 err = sysfs_create_file(&dev->dev.kobj, &dev_attr_obppath.attr);
+                (void) err;
         }
         list_for_each_entry(child_bus, &bus->children, node)
                 pci_bus_register_of_sysfs(child_bus);
@@ -1001,22 +1002,22 @@ EXPORT_SYMBOL(pci_domain_nr);
 int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
 {
         struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
-        unsigned int virt_irq;
+        unsigned int irq;
 
         if (!pbm->setup_msi_irq)
                 return -EINVAL;
 
-        return pbm->setup_msi_irq(&virt_irq, pdev, desc);
+        return pbm->setup_msi_irq(&irq, pdev, desc);
 }
 
-void arch_teardown_msi_irq(unsigned int virt_irq)
+void arch_teardown_msi_irq(unsigned int irq)
 {
-        struct msi_desc *entry = get_irq_msi(virt_irq);
+        struct msi_desc *entry = irq_get_msi_desc(irq);
         struct pci_dev *pdev = entry->dev;
         struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
 
         if (pbm->teardown_msi_irq)
-                pbm->teardown_msi_irq(virt_irq, pdev);
+                pbm->teardown_msi_irq(irq, pdev);
 }
 #endif /* !(CONFIG_PCI_MSI) */
 
diff --git a/arch/sparc/kernel/pci_common.c b/arch/sparc/kernel/pci_common.c
index 6c7a33af3ba6..a6895987fb70 100644
--- a/arch/sparc/kernel/pci_common.c
+++ b/arch/sparc/kernel/pci_common.c
@@ -281,7 +281,7 @@ static int sun4v_read_pci_cfg(struct pci_bus *bus_dev, unsigned int devfn,
         case 4:
                 *value = ret & 0xffffffff;
                 break;
-        };
+        }
 
 
         return PCIBIOS_SUCCESSFUL;
@@ -295,14 +295,17 @@ static int sun4v_write_pci_cfg(struct pci_bus *bus_dev, unsigned int devfn,
         unsigned int bus = bus_dev->number;
         unsigned int device = PCI_SLOT(devfn);
         unsigned int func = PCI_FUNC(devfn);
-        unsigned long ret;
 
         if (config_out_of_range(pbm, bus, devfn, where)) {
                 /* Do nothing. */
         } else {
-                ret = pci_sun4v_config_put(devhandle,
-                                HV_PCI_DEVICE_BUILD(bus, device, func),
-                                where, size, value);
+                /* We don't check for hypervisor errors here, but perhaps
+                 * we should and influence our return value depending upon
+                 * what kind of error is thrown.
+                 */
+                pci_sun4v_config_put(devhandle,
+                                     HV_PCI_DEVICE_BUILD(bus, device, func),
+                                     where, size, value);
         }
         return PCIBIOS_SUCCESSFUL;
 }
@@ -453,7 +456,7 @@ void pci_determine_mem_io_space(struct pci_pbm_info *pbm)
 
                 default:
                         break;
-                };
+                }
         }
 
         if (!saw_io || !saw_mem) {
diff --git a/arch/sparc/kernel/pci_fire.c b/arch/sparc/kernel/pci_fire.c
index efb896d68754..d29a32fcc5e4 100644
--- a/arch/sparc/kernel/pci_fire.c
+++ b/arch/sparc/kernel/pci_fire.c
@@ -214,11 +214,9 @@ static int pci_fire_msi_setup(struct pci_pbm_info *pbm, unsigned long msiqid,
 
 static int pci_fire_msi_teardown(struct pci_pbm_info *pbm, unsigned long msi)
 {
-        unsigned long msiqid;
         u64 val;
 
         val = upa_readq(pbm->pbm_regs + MSI_MAP(msi));
-        msiqid = (val & MSI_MAP_EQNUM);
 
         val &= ~MSI_MAP_VALID;
 
@@ -277,7 +275,7 @@ static int pci_fire_msiq_build_irq(struct pci_pbm_info *pbm,
 {
         unsigned long cregs = (unsigned long) pbm->pbm_regs;
         unsigned long imap_reg, iclr_reg, int_ctrlr;
-        unsigned int virt_irq;
+        unsigned int irq;
         int fixup;
         u64 val;
 
@@ -293,14 +291,14 @@ static int pci_fire_msiq_build_irq(struct pci_pbm_info *pbm,
 
         fixup = ((pbm->portid << 6) | devino) - int_ctrlr;
 
-        virt_irq = build_irq(fixup, iclr_reg, imap_reg);
-        if (!virt_irq)
+        irq = build_irq(fixup, iclr_reg, imap_reg);
+        if (!irq)
                 return -ENOMEM;
 
         upa_writeq(EVENT_QUEUE_CONTROL_SET_EN,
                    pbm->pbm_regs + EVENT_QUEUE_CONTROL_SET(msiqid));
 
-        return virt_irq;
+        return irq;
 }
 
 static const struct sparc64_msiq_ops pci_fire_msiq_ops = {
@@ -455,8 +453,7 @@ static int __devinit pci_fire_pbm_init(struct pci_pbm_info *pbm,
         return 0;
 }
 
-static int __devinit fire_probe(struct platform_device *op,
-                                const struct of_device_id *match)
+static int __devinit fire_probe(struct platform_device *op)
 {
         struct device_node *dp = op->dev.of_node;
         struct pci_pbm_info *pbm;
@@ -499,7 +496,7 @@ out_err:
         return err;
 }
 
-static struct of_device_id __initdata fire_match[] = {
+static const struct of_device_id fire_match[] = {
         {
                 .name = "pci",
                 .compatible = "pciex108e,80f0",
@@ -507,7 +504,7 @@ static struct of_device_id __initdata fire_match[] = {
         {},
 };
 
-static struct of_platform_driver fire_driver = {
+static struct platform_driver fire_driver = {
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
@@ -518,7 +515,7 @@ static struct of_platform_driver fire_driver = {
 
 static int __init fire_init(void)
 {
-        return of_register_platform_driver(&fire_driver);
+        return platform_driver_register(&fire_driver);
 }
 
 subsys_initcall(fire_init);
diff --git a/arch/sparc/kernel/pci_impl.h b/arch/sparc/kernel/pci_impl.h
index e20ed5f06e9c..6beb60df31d0 100644
--- a/arch/sparc/kernel/pci_impl.h
+++ b/arch/sparc/kernel/pci_impl.h
@@ -131,9 +131,9 @@ struct pci_pbm_info {
         void                            *msi_queues;
         unsigned long                   *msi_bitmap;
         unsigned int                    *msi_irq_table;
-        int (*setup_msi_irq)(unsigned int *virt_irq_p, struct pci_dev *pdev,
+        int (*setup_msi_irq)(unsigned int *irq_p, struct pci_dev *pdev,
                              struct msi_desc *entry);
-        void (*teardown_msi_irq)(unsigned int virt_irq, struct pci_dev *pdev);
+        void (*teardown_msi_irq)(unsigned int irq, struct pci_dev *pdev);
         const struct sparc64_msiq_ops   *msi_ops;
 #endif /* !(CONFIG_PCI_MSI) */
 
diff --git a/arch/sparc/kernel/pci_msi.c b/arch/sparc/kernel/pci_msi.c
index 548b8ca9c210..580651af73f2 100644
--- a/arch/sparc/kernel/pci_msi.c
+++ b/arch/sparc/kernel/pci_msi.c
@@ -30,13 +30,10 @@ static irqreturn_t sparc64_msiq_interrupt(int irq, void *cookie)
 
                 err = ops->dequeue_msi(pbm, msiqid, &head, &msi);
                 if (likely(err > 0)) {
-                        struct irq_desc *desc;
-                        unsigned int virt_irq;
+                        unsigned int irq;
 
-                        virt_irq = pbm->msi_irq_table[msi - pbm->msi_first];
-                        desc = irq_desc + virt_irq;
-
-                        desc->handle_irq(virt_irq, desc);
+                        irq = pbm->msi_irq_table[msi - pbm->msi_first];
+                        generic_handle_irq(irq);
                 }
 
                 if (unlikely(err < 0))
@@ -114,14 +111,14 @@ static void free_msi(struct pci_pbm_info *pbm, int msi_num)
 
 static struct irq_chip msi_irq = {
         .name           = "PCI-MSI",
-        .mask           = mask_msi_irq,
-        .unmask         = unmask_msi_irq,
-        .enable         = unmask_msi_irq,
-        .disable        = mask_msi_irq,
+        .irq_mask       = mask_msi_irq,
+        .irq_unmask     = unmask_msi_irq,
+        .irq_enable     = unmask_msi_irq,
+        .irq_disable    = mask_msi_irq,
         /* XXX affinity XXX */
 };
 
-static int sparc64_setup_msi_irq(unsigned int *virt_irq_p,
+static int sparc64_setup_msi_irq(unsigned int *irq_p,
                                  struct pci_dev *pdev,
                                  struct msi_desc *entry)
 {
@@ -131,17 +128,17 @@ static int sparc64_setup_msi_irq(unsigned int *virt_irq_p,
         int msi, err;
         u32 msiqid;
 
-        *virt_irq_p = virt_irq_alloc(0, 0);
+        *irq_p = irq_alloc(0, 0);
         err = -ENOMEM;
-        if (!*virt_irq_p)
+        if (!*irq_p)
                 goto out_err;
 
-        set_irq_chip_and_handler_name(*virt_irq_p, &msi_irq,
-                                      handle_simple_irq, "MSI");
+        irq_set_chip_and_handler_name(*irq_p, &msi_irq, handle_simple_irq,
+                                      "MSI");
 
         err = alloc_msi(pbm);
         if (unlikely(err < 0))
-                goto out_virt_irq_free;
+                goto out_irq_free;
 
         msi = err;
 
@@ -152,7 +149,7 @@ static int sparc64_setup_msi_irq(unsigned int *virt_irq_p,
         if (err)
                 goto out_msi_free;
 
-        pbm->msi_irq_table[msi - pbm->msi_first] = *virt_irq_p;
+        pbm->msi_irq_table[msi - pbm->msi_first] = *irq_p;
 
         if (entry->msi_attrib.is_64) {
                 msg.address_hi = pbm->msi64_start >> 32;
@@ -163,24 +160,24 @@ static int sparc64_setup_msi_irq(unsigned int *virt_irq_p,
         }
         msg.data = msi;
 
-        set_irq_msi(*virt_irq_p, entry);
-        write_msi_msg(*virt_irq_p, &msg);
+        irq_set_msi_desc(*irq_p, entry);
+        write_msi_msg(*irq_p, &msg);
 
         return 0;
 
 out_msi_free:
         free_msi(pbm, msi);
 
-out_virt_irq_free:
-        set_irq_chip(*virt_irq_p, NULL);
-        virt_irq_free(*virt_irq_p);
-        *virt_irq_p = 0;
+out_irq_free:
+        irq_set_chip(*irq_p, NULL);
+        irq_free(*irq_p);
+        *irq_p = 0;
 
 out_err:
         return err;
 }
 
-static void sparc64_teardown_msi_irq(unsigned int virt_irq,
+static void sparc64_teardown_msi_irq(unsigned int irq,
                                      struct pci_dev *pdev)
 {
         struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
@@ -189,12 +186,12 @@ static void sparc64_teardown_msi_irq(unsigned int virt_irq,
         int i, err;
 
         for (i = 0; i < pbm->msi_num; i++) {
-                if (pbm->msi_irq_table[i] == virt_irq)
+                if (pbm->msi_irq_table[i] == irq)
                         break;
         }
         if (i >= pbm->msi_num) {
                 printk(KERN_ERR "%s: teardown: No MSI for irq %u\n",
-                       pbm->name, virt_irq);
+                       pbm->name, irq);
                 return;
         }
 
@@ -205,14 +202,14 @@ static void sparc64_teardown_msi_irq(unsigned int virt_irq,
         if (err) {
                 printk(KERN_ERR "%s: teardown: ops->teardown() on MSI %u, "
                        "irq %u, gives error %d\n",
-                       pbm->name, msi_num, virt_irq, err);
+                       pbm->name, msi_num, irq, err);
                 return;
         }
 
         free_msi(pbm, msi_num);
 
-        set_irq_chip(virt_irq, NULL);
-        virt_irq_free(virt_irq);
+        irq_set_chip(irq, NULL);
+        irq_free(irq);
 }
 
 static int msi_bitmap_alloc(struct pci_pbm_info *pbm)
@@ -287,8 +284,9 @@ static int bringup_one_msi_queue(struct pci_pbm_info *pbm,
 
         nid = pbm->numa_node;
         if (nid != -1) {
-                cpumask_t numa_mask = *cpumask_of_node(nid);
+                cpumask_t numa_mask;
 
+                cpumask_copy(&numa_mask, cpumask_of_node(nid));
                 irq_set_affinity(irq, &numa_mask);
         }
         err = request_irq(irq, sparc64_msiq_interrupt, 0,
diff --git a/arch/sparc/kernel/pci_psycho.c b/arch/sparc/kernel/pci_psycho.c
index 22eab7cf3b11..86ae08d9b6ee 100644
--- a/arch/sparc/kernel/pci_psycho.c
+++ b/arch/sparc/kernel/pci_psycho.c
@@ -503,8 +503,7 @@ static struct pci_pbm_info * __devinit psycho_find_sibling(u32 upa_portid)
 
 #define PSYCHO_CONFIGSPACE      0x001000000UL
 
-static int __devinit psycho_probe(struct platform_device *op,
-                                  const struct of_device_id *match)
+static int __devinit psycho_probe(struct platform_device *op)
 {
         const struct linux_prom64_registers *pr_regs;
         struct device_node *dp = op->dev.of_node;
@@ -593,7 +592,7 @@ out_err:
         return err;
 }
 
-static struct of_device_id __initdata psycho_match[] = {
+static const struct of_device_id psycho_match[] = {
         {
                 .name = "pci",
                 .compatible = "pci108e,8000",
@@ -601,7 +600,7 @@ static struct of_device_id __initdata psycho_match[] = {
         {},
 };
 
-static struct of_platform_driver psycho_driver = {
+static struct platform_driver psycho_driver = {
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
@@ -612,7 +611,7 @@ static struct of_platform_driver psycho_driver = {
 
 static int __init psycho_init(void)
 {
-        return of_register_platform_driver(&psycho_driver);
+        return platform_driver_register(&psycho_driver);
 }
 
 subsys_initcall(psycho_init);
diff --git a/arch/sparc/kernel/pci_sabre.c b/arch/sparc/kernel/pci_sabre.c
index 5c3f5ec4cabc..d1840dbdaa2f 100644
--- a/arch/sparc/kernel/pci_sabre.c
+++ b/arch/sparc/kernel/pci_sabre.c
@@ -452,9 +452,10 @@ static void __devinit sabre_pbm_init(struct pci_pbm_info *pbm,
         sabre_scan_bus(pbm, &op->dev);
 }
 
-static int __devinit sabre_probe(struct platform_device *op,
-                                 const struct of_device_id *match)
+static const struct of_device_id sabre_match[];
+static int __devinit sabre_probe(struct platform_device *op)
 {
+        const struct of_device_id *match;
         const struct linux_prom64_registers *pr_regs;
         struct device_node *dp = op->dev.of_node;
         struct pci_pbm_info *pbm;
@@ -464,7 +465,8 @@ static int __devinit sabre_probe(struct platform_device *op,
         const u32 *vdma;
         u64 clear_irq;
 
-        hummingbird_p = (match->data != NULL);
+        match = of_match_device(sabre_match, &op->dev);
+        hummingbird_p = match && (match->data != NULL);
         if (!hummingbird_p) {
                 struct device_node *cpu_dp;
 
@@ -582,7 +584,7 @@ out_err:
         return err;
 }
 
-static struct of_device_id __initdata sabre_match[] = {
+static const struct of_device_id sabre_match[] = {
         {
                 .name = "pci",
                 .compatible = "pci108e,a001",
@@ -595,7 +597,7 @@ static struct of_device_id __initdata sabre_match[] = {
         {},
 };
 
-static struct of_platform_driver sabre_driver = {
+static struct platform_driver sabre_driver = {
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
@@ -606,7 +608,7 @@ static struct of_platform_driver sabre_driver = {
 
 static int __init sabre_init(void)
 {
-        return of_register_platform_driver(&sabre_driver);
+        return platform_driver_register(&sabre_driver);
 }
 
 subsys_initcall(sabre_init);
diff --git a/arch/sparc/kernel/pci_schizo.c b/arch/sparc/kernel/pci_schizo.c
index 445a47a2fb3d..f030b02edddd 100644
--- a/arch/sparc/kernel/pci_schizo.c
+++ b/arch/sparc/kernel/pci_schizo.c
@@ -264,7 +264,7 @@ static void schizo_check_iommu_error_pbm(struct pci_pbm_info *pbm,
                 default:
                         type_string = "ECC Error";
                         break;
-                };
+                }
                 printk("%s: IOMMU Error, type[%s]\n",
                        pbm->name, type_string);
 
@@ -319,7 +319,7 @@ static void schizo_check_iommu_error_pbm(struct pci_pbm_info *pbm,
                         default:
                                 type_string = "ECC Error";
                                 break;
-                        };
+                        }
                         printk("%s: IOMMU TAG(%d)[error(%s) ctx(%x) wr(%d) str(%d) "
                                "sz(%dK) vpg(%08lx)]\n",
                                pbm->name, i, type_string,
@@ -1313,7 +1313,7 @@ static int __devinit schizo_pbm_init(struct pci_pbm_info *pbm,
         const struct linux_prom64_registers *regs;
         struct device_node *dp = op->dev.of_node;
         const char *chipset_name;
-        int is_pbm_a, err;
+        int err;
 
         switch (chip_type) {
         case PBM_CHIP_TYPE_TOMATILLO:
@@ -1328,7 +1328,7 @@ static int __devinit schizo_pbm_init(struct pci_pbm_info *pbm,
         default:
                 chipset_name = "SCHIZO";
                 break;
-        };
+        }
 
         /* For SCHIZO, three OBP regs:
          * 1) PBM controller regs
@@ -1343,8 +1343,6 @@ static int __devinit schizo_pbm_init(struct pci_pbm_info *pbm,
          */
         regs = of_get_property(dp, "reg", NULL);
 
-        is_pbm_a = ((regs[0].phys_addr & 0x00700000) == 0x00600000);
-
         pbm->next = pci_pbm_root;
         pci_pbm_root = pbm;
 
@@ -1460,10 +1458,15 @@ out_err:
         return err;
 }
 
-static int __devinit schizo_probe(struct platform_device *op,
-                                  const struct of_device_id *match)
+static const struct of_device_id schizo_match[];
+static int __devinit schizo_probe(struct platform_device *op)
 {
-        return __schizo_init(op, (unsigned long) match->data);
+        const struct of_device_id *match;
+
+        match = of_match_device(schizo_match, &op->dev);
+        if (!match)
+                return -EINVAL;
+        return __schizo_init(op, (unsigned long)match->data);
 }
 
 /* The ordering of this table is very important.  Some Tomatillo
@@ -1471,7 +1474,7 @@ static int __devinit schizo_probe(struct platform_device *op,
  * and pci108e,8001.  So list the chips in reverse chronological
  * order.
  */
-static struct of_device_id __initdata schizo_match[] = {
+static const struct of_device_id schizo_match[] = {
         {
                 .name = "pci",
                 .compatible = "pci108e,a801",
@@ -1490,7 +1493,7 @@ static struct of_device_id __initdata schizo_match[] = {
         {},
 };
 
-static struct of_platform_driver schizo_driver = {
+static struct platform_driver schizo_driver = {
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
@@ -1501,7 +1504,7 @@ static struct of_platform_driver schizo_driver = {
 
 static int __init schizo_init(void)
 {
-        return of_register_platform_driver(&schizo_driver);
+        return platform_driver_register(&schizo_driver);
 }
 
 subsys_initcall(schizo_init);
diff --git a/arch/sparc/kernel/pci_sun4v.c b/arch/sparc/kernel/pci_sun4v.c
index 743344aa6d8a..b01a06e9ae4e 100644
--- a/arch/sparc/kernel/pci_sun4v.c
+++ b/arch/sparc/kernel/pci_sun4v.c
@@ -580,7 +580,7 @@ static int __devinit pci_sun4v_iommu_init(struct pci_pbm_info *pbm)
 {
         static const u32 vdma_default[] = { 0x80000000, 0x80000000 };
         struct iommu *iommu = pbm->iommu;
-        unsigned long num_tsb_entries, sz, tsbsize;
+        unsigned long num_tsb_entries, sz;
         u32 dma_mask, dma_offset;
         const u32 *vdma;
 
@@ -596,7 +596,6 @@ static int __devinit pci_sun4v_iommu_init(struct pci_pbm_info *pbm)
 
         dma_mask = (roundup_pow_of_two(vdma[1]) - 1UL);
         num_tsb_entries = vdma[1] / IO_PAGE_SIZE;
-        tsbsize = num_tsb_entries * sizeof(iopte_t);
 
         dma_offset = vdma[0];
 
@@ -844,9 +843,9 @@ static int pci_sun4v_msiq_build_irq(struct pci_pbm_info *pbm,
                                     unsigned long msiqid,
                                     unsigned long devino)
 {
-        unsigned int virt_irq = sun4v_build_irq(pbm->devhandle, devino);
+        unsigned int irq = sun4v_build_irq(pbm->devhandle, devino);
 
-        if (!virt_irq)
+        if (!irq)
                 return -ENOMEM;
 
         if (pci_sun4v_msiq_setstate(pbm->devhandle, msiqid, HV_MSIQSTATE_IDLE))
@@ -854,7 +853,7 @@ static int pci_sun4v_msiq_build_irq(struct pci_pbm_info *pbm,
         if (pci_sun4v_msiq_setvalid(pbm->devhandle, msiqid, HV_MSIQ_VALID))
                 return -EINVAL;
 
-        return virt_irq;
+        return irq;
 }
 
 static const struct sparc64_msiq_ops pci_sun4v_msiq_ops = {
@@ -918,8 +917,7 @@ static int __devinit pci_sun4v_pbm_init(struct pci_pbm_info *pbm,
         return 0;
 }
 
-static int __devinit pci_sun4v_probe(struct platform_device *op,
-                                     const struct of_device_id *match)
+static int __devinit pci_sun4v_probe(struct platform_device *op)
 {
         const struct linux_prom64_registers *regs;
         static int hvapi_negotiated = 0;
@@ -1000,7 +998,7 @@ out_err:
         return err;
 }
 
-static struct of_device_id __initdata pci_sun4v_match[] = {
+static const struct of_device_id pci_sun4v_match[] = {
         {
                 .name = "pci",
                 .compatible = "SUNW,sun4v-pci",
@@ -1008,7 +1006,7 @@ static struct of_device_id __initdata pci_sun4v_match[] = {
         {},
 };
 
-static struct of_platform_driver pci_sun4v_driver = {
+static struct platform_driver pci_sun4v_driver = {
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
@@ -1019,7 +1017,7 @@ static struct of_platform_driver pci_sun4v_driver = {
 
 static int __init pci_sun4v_init(void)
 {
-        return of_register_platform_driver(&pci_sun4v_driver);
+        return platform_driver_register(&pci_sun4v_driver);
 }
 
 subsys_initcall(pci_sun4v_init);
diff --git a/arch/sparc/kernel/pcic.c b/arch/sparc/kernel/pcic.c
index d36a8d391ca0..948601a066ff 100644
--- a/arch/sparc/kernel/pcic.c
+++ b/arch/sparc/kernel/pcic.c
@@ -164,6 +164,9 @@ void __iomem *pcic_regs;
 volatile int pcic_speculative;
 volatile int pcic_trapped;
 
+/* forward */
+unsigned int pcic_build_device_irq(struct platform_device *op,
+                                   unsigned int real_irq);
 
 #define CONFIG_CMD(bus, device_fn, where) (0x80000000 | (((unsigned int)bus) << 16) | (((unsigned int)device_fn) << 8) | (where & ~3))
 
@@ -284,7 +287,7 @@ int __init pcic_probe(void)
         struct linux_prom_registers regs[PROMREG_MAX];
         struct linux_pbm_info* pbm;
         char namebuf[64];
-        int node;
+        phandle node;
         int err;
 
         if (pcic0_up) {
@@ -440,7 +443,7 @@ static int __devinit pdev_to_pnode(struct linux_pbm_info *pbm,
 {
         struct linux_prom_pci_registers regs[PROMREG_MAX];
         int err;
-        int node = prom_getchild(pbm->prom_node);
+        phandle node = prom_getchild(pbm->prom_node);
 
         while(node) {
                 err = prom_getproperty(node, "reg", 
@@ -523,6 +526,7 @@ static void
 pcic_fill_irq(struct linux_pcic *pcic, struct pci_dev *dev, int node)
 {
         struct pcic_ca2irq *p;
+        unsigned int real_irq;
         int i, ivec;
         char namebuf[64];
 
@@ -551,26 +555,25 @@ pcic_fill_irq(struct linux_pcic *pcic, struct pci_dev *dev, int node)
         i = p->pin;
         if (i >= 0 && i < 4) {
                 ivec = readw(pcic->pcic_regs+PCI_INT_SELECT_LO);
-                dev->irq = ivec >> (i << 2) & 0xF;
+                real_irq = ivec >> (i << 2) & 0xF;
         } else if (i >= 4 && i < 8) {
                 ivec = readw(pcic->pcic_regs+PCI_INT_SELECT_HI);
-                dev->irq = ivec >> ((i-4) << 2) & 0xF;
+                real_irq = ivec >> ((i-4) << 2) & 0xF;
         } else {                                        /* Corrupted map */
                 printk("PCIC: BAD PIN %d\n", i); for (;;) {}
         }
 /* P3 */ /* printk("PCIC: device %s pin %d ivec 0x%x irq %x\n", namebuf, i, ivec, dev->irq); */
 
-        /*
-         * dev->irq=0 means PROM did not bother to program the upper
+        /* real_irq means PROM did not bother to program the upper
          * half of PCIC. This happens on JS-E with PROM 3.11, for instance.
          */
-        if (dev->irq == 0 || p->force) {
+        if (real_irq == 0 || p->force) {
                 if (p->irq == 0 || p->irq >= 15) {      /* Corrupted map */
                         printk("PCIC: BAD IRQ %d\n", p->irq); for (;;) {}
                 }
                 printk("PCIC: setting irq %d at pin %d for device %02x:%02x\n",
                     p->irq, p->pin, dev->bus->number, dev->devfn);
-                dev->irq = p->irq;
+                real_irq = p->irq;
 
                 i = p->pin;
                 if (i >= 4) {
@@ -584,7 +587,8 @@ pcic_fill_irq(struct linux_pcic *pcic, struct pci_dev *dev, int node)
                         ivec |= p->irq << (i << 2);
                         writew(ivec, pcic->pcic_regs+PCI_INT_SELECT_LO);
                 }
-        }
+        }
+        dev->irq = pcic_build_device_irq(NULL, real_irq);
 }
 
 /*
@@ -700,10 +704,8 @@ static void pcic_clear_clock_irq(void)
 
 static irqreturn_t pcic_timer_handler (int irq, void *h)
 {
-        write_seqlock(&xtime_lock);     /* Dummy, to show that we remember */
         pcic_clear_clock_irq();
-        do_timer(1);
-        write_sequnlock(&xtime_lock);
+        xtime_update(1);
 #ifndef CONFIG_SMP
         update_process_times(user_mode(get_irq_regs()));
 #endif
@@ -731,6 +733,7 @@ void __init pci_time_init(void)
         struct linux_pcic *pcic = &pcic0;
         unsigned long v;
         int timer_irq, irq;
+        int err;
 
         do_arch_gettimeoffset = pci_gettimeoffset;
 
@@ -742,9 +745,10 @@ void __init pci_time_init(void)
         timer_irq = PCI_COUNTER_IRQ_SYS(v);
         writel (PCI_COUNTER_IRQ_SET(timer_irq, 0),
                 pcic->pcic_regs+PCI_COUNTER_IRQ);
-        irq = request_irq(timer_irq, pcic_timer_handler,
-                          (IRQF_DISABLED | SA_STATIC_ALLOC), "timer", NULL);
-        if (irq) {
+        irq = pcic_build_device_irq(NULL, timer_irq);
+        err = request_irq(irq, pcic_timer_handler,
+                          IRQF_TIMER, "timer", NULL);
+        if (err) {
                 prom_printf("time_init: unable to attach IRQ%d\n", timer_irq);
                 prom_halt();
         }
@@ -805,50 +809,73 @@ static inline unsigned long get_irqmask(int irq_nr)
         return 1 << irq_nr;
 }
 
-static void pcic_disable_irq(unsigned int irq_nr)
+static void pcic_mask_irq(struct irq_data *data)
 {
         unsigned long mask, flags;
 
-        mask = get_irqmask(irq_nr);
+        mask = (unsigned long)data->chip_data;
         local_irq_save(flags);
         writel(mask, pcic0.pcic_regs+PCI_SYS_INT_TARGET_MASK_SET);
         local_irq_restore(flags);
 }
 
-static void pcic_enable_irq(unsigned int irq_nr)
+static void pcic_unmask_irq(struct irq_data *data)
 {
         unsigned long mask, flags;
 
-        mask = get_irqmask(irq_nr);
+        mask = (unsigned long)data->chip_data;
         local_irq_save(flags);
         writel(mask, pcic0.pcic_regs+PCI_SYS_INT_TARGET_MASK_CLEAR);
         local_irq_restore(flags);
 }
 
-static void pcic_load_profile_irq(int cpu, unsigned int limit)
+static unsigned int pcic_startup_irq(struct irq_data *data)
 {
-        printk("PCIC: unimplemented code: FILE=%s LINE=%d", __FILE__, __LINE__);
+        irq_link(data->irq);
+        pcic_unmask_irq(data);
+        return 0;
 }
 
-/* We assume the caller has disabled local interrupts when these are called,
- * or else very bizarre behavior will result.
- */
-static void pcic_disable_pil_irq(unsigned int pil)
+static struct irq_chip pcic_irq = {
+        .name           = "pcic",
+        .irq_startup    = pcic_startup_irq,
+        .irq_mask       = pcic_mask_irq,
+        .irq_unmask     = pcic_unmask_irq,
+};
+
+unsigned int pcic_build_device_irq(struct platform_device *op,
+                                   unsigned int real_irq)
 {
-        writel(get_irqmask(pil), pcic0.pcic_regs+PCI_SYS_INT_TARGET_MASK_SET);
+        unsigned int irq;
+        unsigned long mask;
+
+        irq = 0;
+        mask = get_irqmask(real_irq);
+        if (mask == 0)
+                goto out;
+
+        irq = irq_alloc(real_irq, real_irq);
+        if (irq == 0)
+                goto out;
+
+        irq_set_chip_and_handler_name(irq, &pcic_irq,
+                                      handle_level_irq, "PCIC");
+        irq_set_chip_data(irq, (void *)mask);
+
+out:
+        return irq;
 }
 
-static void pcic_enable_pil_irq(unsigned int pil)
+
+static void pcic_load_profile_irq(int cpu, unsigned int limit)
 {
-        writel(get_irqmask(pil), pcic0.pcic_regs+PCI_SYS_INT_TARGET_MASK_CLEAR);
+        printk("PCIC: unimplemented code: FILE=%s LINE=%d", __FILE__, __LINE__);
 }
 
 void __init sun4m_pci_init_IRQ(void)
 {
-        BTFIXUPSET_CALL(enable_irq, pcic_enable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_irq, pcic_disable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(enable_pil_irq, pcic_enable_pil_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_pil_irq, pcic_disable_pil_irq, BTFIXUPCALL_NORM);
+        sparc_irq_config.build_device_irq = pcic_build_device_irq;
+
         BTFIXUPSET_CALL(clear_clock_irq, pcic_clear_clock_irq, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(load_profile_irq, pcic_load_profile_irq, BTFIXUPCALL_NORM);
 }
diff --git a/arch/sparc/kernel/pcr.c b/arch/sparc/kernel/pcr.c
index c4a6a50b4849..8ac23e660080 100644
--- a/arch/sparc/kernel/pcr.c
+++ b/arch/sparc/kernel/pcr.c
@@ -7,7 +7,7 @@
 #include <linux/init.h>
 #include <linux/irq.h>
 
-#include <linux/perf_event.h>
+#include <linux/irq_work.h>
 #include <linux/ftrace.h>
 
 #include <asm/pil.h>
@@ -43,14 +43,14 @@ void __irq_entry deferred_pcr_work_irq(int irq, struct pt_regs *regs)
 
         old_regs = set_irq_regs(regs);
         irq_enter();
-#ifdef CONFIG_PERF_EVENTS
-        perf_event_do_pending();
+#ifdef CONFIG_IRQ_WORK
+        irq_work_run();
 #endif
         irq_exit();
         set_irq_regs(old_regs);
 }
 
-void set_perf_event_pending(void)
+void arch_irq_work_raise(void)
 {
         set_softint(1 << PIL_DEFERRED_PCR_WORK);
 }
@@ -81,7 +81,7 @@ static void n2_pcr_write(u64 val)
         unsigned long ret;
 
         ret = sun4v_niagara2_setperf(HV_N2_PERF_SPARC_CTL, val);
-        if (val != HV_EOK)
+        if (ret != HV_EOK)
                 write_pcr(val);
 }
 
@@ -167,5 +167,3 @@ out_unregister:
         unregister_perf_hsvc();
         return err;
 }
-
-arch_initcall(pcr_arch_init);
diff --git a/arch/sparc/kernel/perf_event.c b/arch/sparc/kernel/perf_event.c
index 6318e622cfb0..2cb0e1c001e2 100644
--- a/arch/sparc/kernel/perf_event.c
+++ b/arch/sparc/kernel/perf_event.c
@@ -26,6 +26,7 @@
 #include <asm/nmi.h>
 #include <asm/pcr.h>
 
+#include "kernel.h"
 #include "kstack.h"
 
 /* Sparc64 chips have two performance counters, 32-bits each, with
@@ -658,13 +659,16 @@ static u64 maybe_change_configuration(struct cpu_hw_events *cpuc, u64 pcr)
 
                 enc = perf_event_get_enc(cpuc->events[i]);
                 pcr &= ~mask_for_index(idx);
-                pcr |= event_encoding(enc, idx);
+                if (hwc->state & PERF_HES_STOPPED)
+                        pcr |= nop_for_index(idx);
+                else
+                        pcr |= event_encoding(enc, idx);
         }
 out:
         return pcr;
 }
 
-void hw_perf_enable(void)
+static void sparc_pmu_enable(struct pmu *pmu)
 {
         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
         u64 pcr;
@@ -691,7 +695,7 @@ void hw_perf_enable(void)
         pcr_ops->write(cpuc->pcr);
 }
 
-void hw_perf_disable(void)
+static void sparc_pmu_disable(struct pmu *pmu)
 {
         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
         u64 val;
@@ -710,19 +714,65 @@ void hw_perf_disable(void)
         pcr_ops->write(cpuc->pcr);
 }
 
-static void sparc_pmu_disable(struct perf_event *event)
+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_start(struct perf_event *event, int flags)
+{
+        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
+        int idx = active_event_index(cpuc, event);
+
+        if (flags & PERF_EF_RELOAD) {
+                WARN_ON_ONCE(!(event->hw.state & PERF_HES_UPTODATE));
+                sparc_perf_event_set_period(event, &event->hw, idx);
+        }
+
+        event->hw.state = 0;
+
+        sparc_pmu_enable_event(cpuc, &event->hw, idx);
+}
+
+static void sparc_pmu_stop(struct perf_event *event, int flags)
+{
+        struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
+        int idx = active_event_index(cpuc, event);
+
+        if (!(event->hw.state & PERF_HES_STOPPED)) {
+                sparc_pmu_disable_event(cpuc, &event->hw, idx);
+                event->hw.state |= PERF_HES_STOPPED;
+        }
+
+        if (!(event->hw.state & PERF_HES_UPTODATE) && (flags & PERF_EF_UPDATE)) {
+                sparc_perf_event_update(event, &event->hw, idx);
+                event->hw.state |= PERF_HES_UPTODATE;
+        }
+}
+
+static void sparc_pmu_del(struct perf_event *event, int _flags)
 {
         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
-        struct hw_perf_event *hwc = &event->hw;
         unsigned long flags;
         int i;
 
         local_irq_save(flags);
-        perf_disable();
+        perf_pmu_disable(event->pmu);
 
         for (i = 0; i < cpuc->n_events; i++) {
                 if (event == cpuc->event[i]) {
-                        int idx = cpuc->current_idx[i];
+                        /* Absorb the final count and turn off the
+                         * event.
+                         */
+                        sparc_pmu_stop(event, PERF_EF_UPDATE);
 
                         /* Shift remaining entries down into
                          * the existing slot.
@@ -734,13 +784,6 @@ static void sparc_pmu_disable(struct perf_event *event)
                                         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);
-
                         perf_event_update_userpage(event);
 
                         cpuc->n_events--;
@@ -748,23 +791,10 @@ static void sparc_pmu_disable(struct perf_event *event)
                 }
         }
 
-        perf_enable();
+        perf_pmu_enable(event->pmu);
         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);
@@ -774,15 +804,6 @@ static void sparc_pmu_read(struct perf_event *event)
         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, idx);
-}
-
 static atomic_t active_events = ATOMIC_INIT(0);
 static DEFINE_MUTEX(pmc_grab_mutex);
 
@@ -877,7 +898,7 @@ static int sparc_check_constraints(struct perf_event **evts,
         if (!n_ev)
                 return 0;
 
-        if (n_ev > perf_max_events)
+        if (n_ev > MAX_HWEVENTS)
                 return -1;
 
         msk0 = perf_event_get_msk(events[0]);
@@ -984,26 +1005,30 @@ static int collect_events(struct perf_event *group, int max_count,
         return n;
 }
 
-static int sparc_pmu_enable(struct perf_event *event)
+static int sparc_pmu_add(struct perf_event *event, int ef_flags)
 {
         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
         int n0, ret = -EAGAIN;
         unsigned long flags;
 
         local_irq_save(flags);
-        perf_disable();
+        perf_pmu_disable(event->pmu);
 
         n0 = cpuc->n_events;
-        if (n0 >= perf_max_events)
+        if (n0 >= MAX_HWEVENTS)
                 goto out;
 
         cpuc->event[n0] = event;
         cpuc->events[n0] = event->hw.event_base;
         cpuc->current_idx[n0] = PIC_NO_INDEX;
 
+        event->hw.state = PERF_HES_UPTODATE;
+        if (!(ef_flags & PERF_EF_START))
+                event->hw.state |= PERF_HES_STOPPED;
+
         /*
          * If group events scheduling transaction was started,
-         * skip the schedulability test here, it will be peformed
+         * skip the schedulability test here, it will be performed
          * at commit time(->commit_txn) as a whole
          */
         if (cpuc->group_flag & PERF_EVENT_TXN)
@@ -1020,12 +1045,12 @@ nocheck:
 
         ret = 0;
 out:
-        perf_enable();
+        perf_pmu_enable(event->pmu);
         local_irq_restore(flags);
         return ret;
 }
 
-static int __hw_perf_event_init(struct perf_event *event)
+static int sparc_pmu_event_init(struct perf_event *event)
 {
         struct perf_event_attr *attr = &event->attr;
         struct perf_event *evts[MAX_HWEVENTS];
@@ -1038,22 +1063,33 @@ static int __hw_perf_event_init(struct perf_event *event)
         if (atomic_read(&nmi_active) < 0)
                 return -ENODEV;
 
-        pmap = NULL;
-        if (attr->type == PERF_TYPE_HARDWARE) {
+        switch (attr->type) {
+        case PERF_TYPE_HARDWARE:
                 if (attr->config >= sparc_pmu->max_events)
                         return -EINVAL;
                 pmap = sparc_pmu->event_map(attr->config);
-        } else if (attr->type == PERF_TYPE_HW_CACHE) {
+                break;
+
+        case PERF_TYPE_HW_CACHE:
                 pmap = sparc_map_cache_event(attr->config);
                 if (IS_ERR(pmap))
                         return PTR_ERR(pmap);
-        } else if (attr->type != PERF_TYPE_RAW)
-                return -EOPNOTSUPP;
+                break;
+
+        case PERF_TYPE_RAW:
+                pmap = NULL;
+                break;
+
+        default:
+                return -ENOENT;
+
+        }
 
         if (pmap) {
                 hwc->event_base = perf_event_encode(pmap);
         } else {
-                /* User gives us "(encoding << 16) | pic_mask" for
+                /*
+                 * User gives us "(encoding << 16) | pic_mask" for
                  * PERF_TYPE_RAW events.
                  */
                 hwc->event_base = attr->config;
@@ -1071,7 +1107,7 @@ static int __hw_perf_event_init(struct perf_event *event)
         n = 0;
         if (event->group_leader != event) {
                 n = collect_events(event->group_leader,
-                                   perf_max_events - 1,
+                                   MAX_HWEVENTS - 1,
                                    evts, events, current_idx_dmy);
                 if (n < 0)
                         return -EINVAL;
@@ -1107,10 +1143,11 @@ static int __hw_perf_event_init(struct perf_event *event)
  * Set the flag to make pmu::enable() not perform the
  * schedulability test, it will be performed at commit time
  */
-static void sparc_pmu_start_txn(const struct pmu *pmu)
+static void sparc_pmu_start_txn(struct pmu *pmu)
 {
         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
 
+        perf_pmu_disable(pmu);
         cpuhw->group_flag |= PERF_EVENT_TXN;
 }
 
@@ -1119,11 +1156,12 @@ static void sparc_pmu_start_txn(const struct pmu *pmu)
  * Clear the flag and pmu::enable() will perform the
  * schedulability test.
  */
-static void sparc_pmu_cancel_txn(const struct pmu *pmu)
+static void sparc_pmu_cancel_txn(struct pmu *pmu)
 {
         struct cpu_hw_events *cpuhw = &__get_cpu_var(cpu_hw_events);
 
         cpuhw->group_flag &= ~PERF_EVENT_TXN;
+        perf_pmu_enable(pmu);
 }
 
 /*
@@ -1131,7 +1169,7 @@ static void sparc_pmu_cancel_txn(const struct pmu *pmu)
  * Perform the group schedulability test as a whole
  * Return 0 if success
  */
-static int sparc_pmu_commit_txn(const struct pmu *pmu)
+static int sparc_pmu_commit_txn(struct pmu *pmu)
 {
         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
         int n;
@@ -1147,28 +1185,24 @@ static int sparc_pmu_commit_txn(const struct pmu *pmu)
                 return -EAGAIN;
 
         cpuc->group_flag &= ~PERF_EVENT_TXN;
+        perf_pmu_enable(pmu);
         return 0;
 }
 
-static const struct pmu pmu = {
-        .enable         = sparc_pmu_enable,
-        .disable        = sparc_pmu_disable,
+static struct pmu pmu = {
+        .pmu_enable     = sparc_pmu_enable,
+        .pmu_disable    = sparc_pmu_disable,
+        .event_init     = sparc_pmu_event_init,
+        .add            = sparc_pmu_add,
+        .del            = sparc_pmu_del,
+        .start          = sparc_pmu_start,
+        .stop           = sparc_pmu_stop,
         .read           = sparc_pmu_read,
-        .unthrottle     = sparc_pmu_unthrottle,
         .start_txn      = sparc_pmu_start_txn,
         .cancel_txn     = sparc_pmu_cancel_txn,
         .commit_txn     = sparc_pmu_commit_txn,
 };
 
-const struct pmu *hw_perf_event_init(struct perf_event *event)
-{
-        int err = __hw_perf_event_init(event);
-
-        if (err)
-                return ERR_PTR(err);
-        return &pmu;
-}
-
 void perf_event_print_debug(void)
 {
         unsigned long flags;
@@ -1244,7 +1278,7 @@ static int __kprobes perf_event_nmi_handler(struct notifier_block *self,
                         continue;
 
                 if (perf_event_overflow(event, 1, &data, regs))
-                        sparc_pmu_disable_event(cpuc, hwc, idx);
+                        sparc_pmu_stop(event, 0);
         }
 
         return NOTIFY_STOP;
@@ -1274,39 +1308,35 @@ static bool __init supported_pmu(void)
         return false;
 }
 
-void __init init_hw_perf_events(void)
+int __init init_hw_perf_events(void)
 {
         pr_info("Performance events: ");
 
         if (!supported_pmu()) {
                 pr_cont("No support for PMU type '%s'\n", sparc_pmu_type);
-                return;
+                return 0;
         }
 
         pr_cont("Supported PMU type is '%s'\n", sparc_pmu_type);
 
-        /* All sparc64 PMUs currently have 2 events.  */
-        perf_max_events = 2;
-
+        perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);
         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;
+        return 0;
 }
+early_initcall(init_hw_perf_events);
 
-static void perf_callchain_kernel(struct pt_regs *regs,
-                                  struct perf_callchain_entry *entry)
+void perf_callchain_kernel(struct perf_callchain_entry *entry,
+                           struct pt_regs *regs)
 {
         unsigned long ksp, fp;
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
         int graph = 0;
 #endif
 
-        callchain_store(entry, PERF_CONTEXT_KERNEL);
-        callchain_store(entry, regs->tpc);
+        stack_trace_flush();
+
+        perf_callchain_store(entry, regs->tpc);
 
         ksp = regs->u_regs[UREG_I6];
         fp = ksp + STACK_BIAS;
@@ -1330,13 +1360,13 @@ static void perf_callchain_kernel(struct pt_regs *regs,
                         pc = sf->callers_pc;
                         fp = (unsigned long)sf->fp + STACK_BIAS;
                 }
-                callchain_store(entry, pc);
+                perf_callchain_store(entry, pc);
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
                 if ((pc + 8UL) == (unsigned long) &return_to_handler) {
                         int index = current->curr_ret_stack;
                         if (current->ret_stack && index >= graph) {
                                 pc = current->ret_stack[index - graph].ret;
-                                callchain_store(entry, pc);
+                                perf_callchain_store(entry, pc);
                                 graph++;
                         }
                 }
@@ -1344,13 +1374,12 @@ static void perf_callchain_kernel(struct pt_regs *regs,
         } while (entry->nr < PERF_MAX_STACK_DEPTH);
 }
 
-static void perf_callchain_user_64(struct pt_regs *regs,
-                                   struct perf_callchain_entry *entry)
+static void perf_callchain_user_64(struct perf_callchain_entry *entry,
+                                   struct pt_regs *regs)
 {
         unsigned long ufp;
 
-        callchain_store(entry, PERF_CONTEXT_USER);
-        callchain_store(entry, regs->tpc);
+        perf_callchain_store(entry, regs->tpc);
 
         ufp = regs->u_regs[UREG_I6] + STACK_BIAS;
         do {
@@ -1363,17 +1392,16 @@ static void perf_callchain_user_64(struct pt_regs *regs,
 
                 pc = sf.callers_pc;
                 ufp = (unsigned long)sf.fp + STACK_BIAS;
-                callchain_store(entry, pc);
+                perf_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)
+static void perf_callchain_user_32(struct perf_callchain_entry *entry,
+                                   struct pt_regs *regs)
 {
         unsigned long ufp;
 
-        callchain_store(entry, PERF_CONTEXT_USER);
-        callchain_store(entry, regs->tpc);
+        perf_callchain_store(entry, regs->tpc);
 
         ufp = regs->u_regs[UREG_I6] & 0xffffffffUL;
         do {
@@ -1386,34 +1414,16 @@ static void perf_callchain_user_32(struct pt_regs *regs,
 
                 pc = sf.callers_pc;
                 ufp = (unsigned long)sf.fp;
-                callchain_store(entry, pc);
+                perf_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)
+void
+perf_callchain_user(struct perf_callchain_entry *entry, 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;
+        flushw_user();
+        if (test_thread_flag(TIF_32BIT))
+                perf_callchain_user_32(entry, regs);
+        else
+                perf_callchain_user_64(entry, regs);
 }
diff --git a/arch/sparc/kernel/pmc.c b/arch/sparc/kernel/pmc.c
index 94536a85f161..6a585d393580 100644
--- a/arch/sparc/kernel/pmc.c
+++ b/arch/sparc/kernel/pmc.c
@@ -51,8 +51,7 @@ static void pmc_swift_idle(void)
 #endif
 }
 
-static int __devinit pmc_probe(struct platform_device *op,
-                               const struct of_device_id *match)
+static int __devinit pmc_probe(struct platform_device *op)
 {
         regs = of_ioremap(&op->resource[0], 0,
                           resource_size(&op->resource[0]), PMC_OBPNAME);
@@ -70,7 +69,7 @@ static int __devinit pmc_probe(struct platform_device *op,
         return 0;
 }
 
-static struct of_device_id __initdata pmc_match[] = {
+static struct of_device_id pmc_match[] = {
         {
                 .name = PMC_OBPNAME,
         },
@@ -78,7 +77,7 @@ static struct of_device_id __initdata pmc_match[] = {
 };
 MODULE_DEVICE_TABLE(of, pmc_match);
 
-static struct of_platform_driver pmc_driver = {
+static struct platform_driver pmc_driver = {
         .driver = {
                 .name = "pmc",
                 .owner = THIS_MODULE,
@@ -89,7 +88,7 @@ static struct of_platform_driver pmc_driver = {
 
 static int __init pmc_init(void)
 {
-        return of_register_platform_driver(&pmc_driver);
+        return platform_driver_register(&pmc_driver);
 }
 
 /* This driver is not critical to the boot process
diff --git a/arch/sparc/kernel/power.c b/arch/sparc/kernel/power.c
index 2c59f4d387dd..cb4c0f57c024 100644
--- a/arch/sparc/kernel/power.c
+++ b/arch/sparc/kernel/power.c
@@ -33,7 +33,7 @@ static int __devinit has_button_interrupt(unsigned int irq, struct device_node *
         return 1;
 }
 
-static int __devinit power_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit power_probe(struct platform_device *op)
 {
         struct resource *res = &op->resource[0];
         unsigned int irq = op->archdata.irqs[0];
@@ -52,14 +52,14 @@ static int __devinit power_probe(struct platform_device *op, const struct of_dev
         return 0;
 }
 
-static struct of_device_id __initdata power_match[] = {
+static const struct of_device_id power_match[] = {
         {
                 .name = "power",
         },
         {},
 };
 
-static struct of_platform_driver power_driver = {
+static struct platform_driver power_driver = {
         .probe          = power_probe,
         .driver = {
                 .name = "power",
@@ -70,7 +70,7 @@ static struct of_platform_driver power_driver = {
 
 static int __init power_init(void)
 {
-        return of_register_platform_driver(&power_driver);
+        return platform_driver_register(&power_driver);
 }
 
 device_initcall(power_init);
diff --git a/arch/sparc/kernel/process_32.c b/arch/sparc/kernel/process_32.c
index 17529298c50a..c8cc461ff75f 100644
--- a/arch/sparc/kernel/process_32.c
+++ b/arch/sparc/kernel/process_32.c
@@ -128,8 +128,16 @@ void cpu_idle(void)
         set_thread_flag(TIF_POLLING_NRFLAG);
         /* endless idle loop with no priority at all */
         while(1) {
-                while (!need_resched())
-                        cpu_relax();
+#ifdef CONFIG_SPARC_LEON
+                if (pm_idle) {
+                        while (!need_resched())
+                                (*pm_idle)();
+                } else
+#endif
+                {
+                        while (!need_resched())
+                                cpu_relax();
+                }
                 preempt_enable_no_resched();
                 schedule();
                 preempt_disable();
diff --git a/arch/sparc/kernel/prom.h b/arch/sparc/kernel/prom.h
index eeb04a782ec8..cf5fe1c0b024 100644
--- a/arch/sparc/kernel/prom.h
+++ b/arch/sparc/kernel/prom.h
@@ -4,12 +4,6 @@
 #include <linux/spinlock.h>
 #include <asm/prom.h>
 
-extern void * prom_early_alloc(unsigned long size);
-extern void irq_trans_init(struct device_node *dp);
-
-extern unsigned int prom_unique_id;
-
-extern char *build_path_component(struct device_node *dp);
 extern void of_console_init(void);
 
 extern unsigned int prom_early_allocated;
diff --git a/arch/sparc/kernel/prom_32.c b/arch/sparc/kernel/prom_32.c
index 0a37e8cfd160..5ce3d15a99b0 100644
--- a/arch/sparc/kernel/prom_32.c
+++ b/arch/sparc/kernel/prom_32.c
@@ -136,18 +136,29 @@ static void __init ebus_path_component(struct device_node *dp, char *tmp_buf)
 /* "name:vendor:device@irq,addrlo" */
 static void __init ambapp_path_component(struct device_node *dp, char *tmp_buf)
 {
-        struct amba_prom_registers *regs; unsigned int *intr;
-        unsigned int *device, *vendor;
+        struct amba_prom_registers *regs;
+        unsigned int *intr, *device, *vendor, reg0;
         struct property *prop;
+        int interrupt = 0;
 
+        /* In order to get a unique ID in the device tree (multiple AMBA devices
+         * may have the same name) the node number is printed
+         */
         prop = of_find_property(dp, "reg", NULL);
-        if (!prop)
-                return;
-        regs = prop->value;
+        if (!prop) {
+                reg0 = (unsigned int)dp->phandle;
+        } else {
+                regs = prop->value;
+                reg0 = regs->phys_addr;
+        }
+
+        /* Not all cores have Interrupt */
         prop = of_find_property(dp, "interrupts", NULL);
         if (!prop)
-                return;
-        intr = prop->value;
+                intr = &interrupt; /* IRQ0 does not exist */
+        else
+                intr = prop->value;
+
         prop = of_find_property(dp, "vendor", NULL);
         if (!prop)
                 return;
@@ -159,7 +170,7 @@ static void __init ambapp_path_component(struct device_node *dp, char *tmp_buf)
 
         sprintf(tmp_buf, "%s:%d:%d@%x,%x",
                 dp->name, *vendor, *device,
-                *intr, regs->phys_addr);
+                *intr, reg0);
 }
 
 static void __init __build_path_component(struct device_node *dp, char *tmp_buf)
@@ -315,7 +326,6 @@ void __init of_console_init(void)
                         of_console_options = NULL;
         }
 
-        prom_printf(msg, of_console_path);
         printk(msg, of_console_path);
 }
 
diff --git a/arch/sparc/kernel/prom_common.c b/arch/sparc/kernel/prom_common.c
index 1f830da2ddf2..ed25834328f4 100644
--- a/arch/sparc/kernel/prom_common.c
+++ b/arch/sparc/kernel/prom_common.c
@@ -20,14 +20,13 @@
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/of.h>
+#include <linux/of_pdt.h>
 #include <asm/prom.h>
 #include <asm/oplib.h>
 #include <asm/leon.h>
 
 #include "prom.h"
 
-void (*prom_build_more)(struct device_node *dp, struct device_node ***nextp);
-
 struct device_node *of_console_device;
 EXPORT_SYMBOL(of_console_device);
 
@@ -119,192 +118,47 @@ int of_find_in_proplist(const char *list, const char *match, int len)
 }
 EXPORT_SYMBOL(of_find_in_proplist);
 
-unsigned int prom_unique_id;
-
-static struct property * __init build_one_prop(phandle node, char *prev,
-                                               char *special_name,
-                                               void *special_val,
-                                               int special_len)
+/*
+ * SPARC32 and SPARC64's prom_nextprop() do things differently
+ * here, despite sharing the same interface.  SPARC32 doesn't fill in 'buf',
+ * returning NULL on an error.  SPARC64 fills in 'buf', but sets it to an
+ * empty string upon error.
+ */
+static int __init handle_nextprop_quirks(char *buf, const char *name)
 {
-        static struct property *tmp = NULL;
-        struct property *p;
-        const char *name;
-
-        if (tmp) {
-                p = tmp;
-                memset(p, 0, sizeof(*p) + 32);
-                tmp = NULL;
-        } else {
-                p = prom_early_alloc(sizeof(struct property) + 32);
-                p->unique_id = prom_unique_id++;
-        }
-
-        p->name = (char *) (p + 1);
-        if (special_name) {
-                strcpy(p->name, special_name);
-                p->length = special_len;
-                p->value = prom_early_alloc(special_len);
-                memcpy(p->value, special_val, special_len);
-        } else {
-                if (prev == NULL) {
-                        name = prom_firstprop(node, p->name);
-                } else {
-                        name = prom_nextprop(node, prev, p->name);
-                }
+        if (!name || strlen(name) == 0)
+                return -1;
 
-                if (!name || strlen(name) == 0) {
-                        tmp = p;
-                        return NULL;
-                }
 #ifdef CONFIG_SPARC32
-                strcpy(p->name, name);
+        strcpy(buf, name);
 #endif
-                p->length = prom_getproplen(node, p->name);
-                if (p->length <= 0) {
-                        p->length = 0;
-                } else {
-                        int len;
-
-                        p->value = prom_early_alloc(p->length + 1);
-                        len = prom_getproperty(node, p->name, p->value,
-                                               p->length);
-                        if (len <= 0)
-                                p->length = 0;
-                        ((unsigned char *)p->value)[p->length] = '\0';
-                }
-        }
-        return p;
-}
-
-static struct property * __init build_prop_list(phandle node)
-{
-        struct property *head, *tail;
-
-        head = tail = build_one_prop(node, NULL,
-                                     ".node", &node, sizeof(node));
-
-        tail->next = build_one_prop(node, NULL, NULL, NULL, 0);
-        tail = tail->next;
-        while(tail) {
-                tail->next = build_one_prop(node, tail->name,
-                                            NULL, NULL, 0);
-                tail = tail->next;
-        }
-
-        return head;
-}
-
-static char * __init get_one_property(phandle node, const char *name)
-{
-        char *buf = "<NULL>";
-        int len;
-
-        len = prom_getproplen(node, name);
-        if (len > 0) {
-                buf = prom_early_alloc(len);
-                len = prom_getproperty(node, name, buf, len);
-        }
-
-        return buf;
-}
-
-static struct device_node * __init prom_create_node(phandle node,
-                                                    struct device_node *parent)
-{
-        struct device_node *dp;
-
-        if (!node)
-                return NULL;
-
-        dp = prom_early_alloc(sizeof(*dp));
-        dp->unique_id = prom_unique_id++;
-        dp->parent = parent;
-
-        kref_init(&dp->kref);
-
-        dp->name = get_one_property(node, "name");
-        dp->type = get_one_property(node, "device_type");
-        dp->phandle = node;
-
-        dp->properties = build_prop_list(node);
-
-        irq_trans_init(dp);
-
-        return dp;
-}
-
-char * __init build_full_name(struct device_node *dp)
-{
-        int len, ourlen, plen;
-        char *n;
-
-        plen = strlen(dp->parent->full_name);
-        ourlen = strlen(dp->path_component_name);
-        len = ourlen + plen + 2;
-
-        n = prom_early_alloc(len);
-        strcpy(n, dp->parent->full_name);
-        if (!of_node_is_root(dp->parent)) {
-                strcpy(n + plen, "/");
-                plen++;
-        }
-        strcpy(n + plen, dp->path_component_name);
-
-        return n;
+        return 0;
 }
 
-static struct device_node * __init prom_build_tree(struct device_node *parent,
-                                                   phandle node,
-                                                   struct device_node ***nextp)
+static int __init prom_common_nextprop(phandle node, char *prev, char *buf)
 {
-        struct device_node *ret = NULL, *prev_sibling = NULL;
-        struct device_node *dp;
-
-        while (1) {
-                dp = prom_create_node(node, parent);
-                if (!dp)
-                        break;
-
-                if (prev_sibling)
-                        prev_sibling->sibling = dp;
-
-                if (!ret)
-                        ret = dp;
-                prev_sibling = dp;
-
-                *(*nextp) = dp;
-                *nextp = &dp->allnext;
-
-                dp->path_component_name = build_path_component(dp);
-                dp->full_name = build_full_name(dp);
-
-                dp->child = prom_build_tree(dp, prom_getchild(node), nextp);
-
-                if (prom_build_more)
-                        prom_build_more(dp, nextp);
-
-                node = prom_getsibling(node);
-        }
+        const char *name;
 
-        return ret;
+        buf[0] = '\0';
+        name = prom_nextprop(node, prev, buf);
+        return handle_nextprop_quirks(buf, name);
 }
 
 unsigned int prom_early_allocated __initdata;
 
+static struct of_pdt_ops prom_sparc_ops __initdata = {
+        .nextprop = prom_common_nextprop,
+        .getproplen = prom_getproplen,
+        .getproperty = prom_getproperty,
+        .getchild = prom_getchild,
+        .getsibling = prom_getsibling,
+};
+
 void __init prom_build_devicetree(void)
 {
-        struct device_node **nextp;
-
-        allnodes = prom_create_node(prom_root_node, NULL);
-        allnodes->path_component_name = "";
-        allnodes->full_name = "/";
-
-        nextp = &allnodes->allnext;
-        allnodes->child = prom_build_tree(allnodes,
-                                          prom_getchild(allnodes->phandle),
-                                          &nextp);
+        of_pdt_build_devicetree(prom_root_node, &prom_sparc_ops);
         of_console_init();
 
-        printk("PROM: Built device tree with %u bytes of memory.\n",
-               prom_early_allocated);
+        pr_info("PROM: Built device tree with %u bytes of memory.\n",
+                        prom_early_allocated);
 }
diff --git a/arch/sparc/kernel/prom_irqtrans.c b/arch/sparc/kernel/prom_irqtrans.c
index ce651147fabc..40e4936bd479 100644
--- a/arch/sparc/kernel/prom_irqtrans.c
+++ b/arch/sparc/kernel/prom_irqtrans.c
@@ -227,7 +227,7 @@ static unsigned int sabre_irq_build(struct device_node *dp,
         unsigned long imap, iclr;
         unsigned long imap_off, iclr_off;
         int inofixup = 0;
-        int virt_irq;
+        int irq;
 
         ino &= 0x3f;
         if (ino < SABRE_ONBOARD_IRQ_BASE) {
@@ -247,7 +247,7 @@ static unsigned int sabre_irq_build(struct device_node *dp,
         if ((ino & 0x20) == 0)
                 inofixup = ino & 0x03;
 
-        virt_irq = build_irq(inofixup, iclr, imap);
+        irq = build_irq(inofixup, iclr, imap);
 
         /* If the parent device is a PCI<->PCI bridge other than
          * APB, we have to install a pre-handler to ensure that
@@ -256,13 +256,13 @@ static unsigned int sabre_irq_build(struct device_node *dp,
          */
         regs = of_get_property(dp, "reg", NULL);
         if (regs && sabre_device_needs_wsync(dp)) {
-                irq_install_pre_handler(virt_irq,
+                irq_install_pre_handler(irq,
                                         sabre_wsync_handler,
                                         (void *) (long) regs->phys_hi,
                                         (void *) irq_data);
         }
 
-        return virt_irq;
+        return irq;
 }
 
 static void __init sabre_irq_trans_init(struct device_node *dp)
@@ -382,7 +382,7 @@ static unsigned int schizo_irq_build(struct device_node *dp,
         unsigned long pbm_regs = irq_data->pbm_regs;
         unsigned long imap, iclr;
         int ign_fixup;
-        int virt_irq;
+        int irq;
         int is_tomatillo;
 
         ino &= 0x3f;
@@ -409,17 +409,17 @@ static unsigned int schizo_irq_build(struct device_node *dp,
                         ign_fixup = (1 << 6);
         }
 
-        virt_irq = build_irq(ign_fixup, iclr, imap);
+        irq = build_irq(ign_fixup, iclr, imap);
 
         if (is_tomatillo) {
-                irq_install_pre_handler(virt_irq,
+                irq_install_pre_handler(irq,
                                         tomatillo_wsync_handler,
                                         ((irq_data->chip_version <= 4) ?
                                          (void *) 1 : (void *) 0),
                                         (void *) irq_data->sync_reg);
         }
 
-        return virt_irq;
+        return irq;
 }
 
 static void __init __schizo_irq_trans_init(struct device_node *dp,
@@ -694,7 +694,7 @@ static unsigned int sbus_of_build_irq(struct device_node *dp,
                 case 3:
                         iclr = reg_base + SYSIO_ICLR_SLOT3;
                         break;
-                };
+                }
 
                 iclr += ((unsigned long)sbus_level - 1UL) * 8UL;
         }
diff --git a/arch/sparc/kernel/psycho_common.c b/arch/sparc/kernel/psycho_common.c
index fe2af66bb198..8db48e808ed4 100644
--- a/arch/sparc/kernel/psycho_common.c
+++ b/arch/sparc/kernel/psycho_common.c
@@ -228,7 +228,7 @@ void psycho_check_iommu_error(struct pci_pbm_info *pbm,
                 default:
                         type_str = "ECC Error";
                         break;
-                };
+                }
                 printk(KERN_ERR "%s: IOMMU Error, type[%s]\n",
                        pbm->name, type_str);
 
diff --git a/arch/sparc/kernel/ptrace_32.c b/arch/sparc/kernel/ptrace_32.c
index e608f397e11f..27b9e93d0121 100644
--- a/arch/sparc/kernel/ptrace_32.c
+++ b/arch/sparc/kernel/ptrace_32.c
@@ -323,18 +323,35 @@ const struct user_regset_view *task_user_regset_view(struct task_struct *task)
         return &user_sparc32_view;
 }
 
-long arch_ptrace(struct task_struct *child, long request, long addr, long data)
+struct fps {
+        unsigned long regs[32];
+        unsigned long fsr;
+        unsigned long flags;
+        unsigned long extra;
+        unsigned long fpqd;
+        struct fq {
+                unsigned long *insnaddr;
+                unsigned long insn;
+        } fpq[16];
+};
+
+long arch_ptrace(struct task_struct *child, long request,
+                 unsigned long addr, unsigned long data)
 {
         unsigned long addr2 = current->thread.kregs->u_regs[UREG_I4];
+        void __user *addr2p;
         const struct user_regset_view *view;
+        struct pt_regs __user *pregs;
+        struct fps __user *fps;
         int ret;
 
         view = task_user_regset_view(current);
+        addr2p = (void __user *) addr2;
+        pregs = (struct pt_regs __user *) addr;
+        fps = (struct fps __user *) addr;
 
         switch(request) {
         case PTRACE_GETREGS: {
-                struct pt_regs __user *pregs = (struct pt_regs __user *) addr;
-
                 ret = copy_regset_to_user(child, view, REGSET_GENERAL,
                                           32 * sizeof(u32),
                                           4 * sizeof(u32),
@@ -348,8 +365,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         }
 
         case PTRACE_SETREGS: {
-                struct pt_regs __user *pregs = (struct pt_regs __user *) addr;
-
                 ret = copy_regset_from_user(child, view, REGSET_GENERAL,
                                             32 * sizeof(u32),
                                             4 * sizeof(u32),
@@ -363,19 +378,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         }
 
         case PTRACE_GETFPREGS: {
-                struct fps {
-                        unsigned long regs[32];
-                        unsigned long fsr;
-                        unsigned long flags;
-                        unsigned long extra;
-                        unsigned long fpqd;
-                        struct fq {
-                                unsigned long *insnaddr;
-                                unsigned long insn;
-                        } fpq[16];
-                };
-                struct fps __user *fps = (struct fps __user *) addr;
-
                 ret = copy_regset_to_user(child, view, REGSET_FP,
                                           0 * sizeof(u32),
                                           32 * sizeof(u32),
@@ -397,19 +399,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         }
 
         case PTRACE_SETFPREGS: {
-                struct fps {
-                        unsigned long regs[32];
-                        unsigned long fsr;
-                        unsigned long flags;
-                        unsigned long extra;
-                        unsigned long fpqd;
-                        struct fq {
-                                unsigned long *insnaddr;
-                                unsigned long insn;
-                        } fpq[16];
-                };
-                struct fps __user *fps = (struct fps __user *) addr;
-
                 ret = copy_regset_from_user(child, view, REGSET_FP,
                                             0 * sizeof(u32),
                                             32 * sizeof(u32),
@@ -424,8 +413,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 
         case PTRACE_READTEXT:
         case PTRACE_READDATA:
-                ret = ptrace_readdata(child, addr,
-                                      (void __user *) addr2, data);
+                ret = ptrace_readdata(child, addr, addr2p, data);
 
                 if (ret == data)
                         ret = 0;
@@ -435,8 +423,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 
         case PTRACE_WRITETEXT:
         case PTRACE_WRITEDATA:
-                ret = ptrace_writedata(child, (void __user *) addr2,
-                                       addr, data);
+                ret = ptrace_writedata(child, addr2p, addr, data);
 
                 if (ret == data)
                         ret = 0;
diff --git a/arch/sparc/kernel/ptrace_64.c b/arch/sparc/kernel/ptrace_64.c
index aa90da08bf61..96ee50a80661 100644
--- a/arch/sparc/kernel/ptrace_64.c
+++ b/arch/sparc/kernel/ptrace_64.c
@@ -969,16 +969,19 @@ struct fps {
         unsigned long fsr;
 };
 
-long arch_ptrace(struct task_struct *child, long request, long addr, long data)
+long arch_ptrace(struct task_struct *child, long request,
+                 unsigned long addr, unsigned long data)
 {
         const struct user_regset_view *view = task_user_regset_view(current);
         unsigned long addr2 = task_pt_regs(current)->u_regs[UREG_I4];
         struct pt_regs __user *pregs;
         struct fps __user *fps;
+        void __user *addr2p;
         int ret;
 
-        pregs = (struct pt_regs __user *) (unsigned long) addr;
-        fps = (struct fps __user *) (unsigned long) addr;
+        pregs = (struct pt_regs __user *) addr;
+        fps = (struct fps __user *) addr;
+        addr2p = (void __user *) addr2;
 
         switch (request) {
         case PTRACE_PEEKUSR:
@@ -1029,8 +1032,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 
         case PTRACE_READTEXT:
         case PTRACE_READDATA:
-                ret = ptrace_readdata(child, addr,
-                                      (char __user *)addr2, data);
+                ret = ptrace_readdata(child, addr, addr2p, data);
                 if (ret == data)
                         ret = 0;
                 else if (ret >= 0)
@@ -1039,8 +1041,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 
         case PTRACE_WRITETEXT:
         case PTRACE_WRITEDATA:
-                ret = ptrace_writedata(child, (char __user *) addr2,
-                                       addr, data);
+                ret = ptrace_writedata(child, addr2p, addr, data);
                 if (ret == data)
                         ret = 0;
                 else if (ret >= 0)
@@ -1085,6 +1086,7 @@ asmlinkage int syscall_trace_enter(struct pt_regs *regs)
 
 asmlinkage void syscall_trace_leave(struct pt_regs *regs)
 {
+#ifdef CONFIG_AUDITSYSCALL
         if (unlikely(current->audit_context)) {
                 unsigned long tstate = regs->tstate;
                 int result = AUDITSC_SUCCESS;
@@ -1094,7 +1096,7 @@ asmlinkage void syscall_trace_leave(struct pt_regs *regs)
 
                 audit_syscall_exit(result, regs->u_regs[UREG_I0]);
         }
-
+#endif
         if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
                 trace_sys_exit(regs, regs->u_regs[UREG_G1]);
 
diff --git a/arch/sparc/kernel/rtrap_32.S b/arch/sparc/kernel/rtrap_32.S
index 4da2e1f66290..5f5f74c2c2ca 100644
--- a/arch/sparc/kernel/rtrap_32.S
+++ b/arch/sparc/kernel/rtrap_32.S
@@ -78,9 +78,9 @@ signal_p:
         call    do_notify_resume
          add    %sp, STACKFRAME_SZ, %o0 ! pt_regs ptr
 
-        /* Fall through. */
-        ld      [%sp + STACKFRAME_SZ + PT_PSR], %t_psr
-        clr     %l6
+        b       signal_p
+         ld     [%curptr + TI_FLAGS], %g2
+
 ret_trap_continue:
         sethi   %hi(PSR_SYSCALL), %g1
         andn    %t_psr, %g1, %t_psr
diff --git a/arch/sparc/kernel/rtrap_64.S b/arch/sparc/kernel/rtrap_64.S
index 090b9e9ad5e3..77f1b95e0806 100644
--- a/arch/sparc/kernel/rtrap_64.S
+++ b/arch/sparc/kernel/rtrap_64.S
@@ -34,37 +34,9 @@ __handle_preemption:
 __handle_user_windows:
                 call                    fault_in_user_windows
                  wrpr                   %g0, RTRAP_PSTATE, %pstate
-                wrpr                    %g0, RTRAP_PSTATE_IRQOFF, %pstate
-                /* Redo sched+sig checks */
-                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_user_windows_continue
-                 nop
-                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
-                ba,pt                   %xcc, __handle_user_windows_continue
+                ba,pt                   %xcc, __handle_preemption_continue
+                 wrpr                   %g0, RTRAP_PSTATE_IRQOFF, %pstate
 
-                 andn                   %l1, %l4, %l1
 __handle_userfpu:
                 rd                      %fprs, %l5
                 andcc                   %l5, FPRS_FEF, %g0
@@ -87,7 +59,7 @@ __handle_signal:
                 ldx                     [%sp + PTREGS_OFF + PT_V9_TSTATE], %l1
                 sethi                   %hi(0xf << 20), %l4
                 and                     %l1, %l4, %l4
-                ba,pt                   %xcc, __handle_signal_continue
+                ba,pt                   %xcc, __handle_preemption_continue
                  andn                   %l1, %l4, %l1
 
                 /* When returning from a NMI (%pil==15) interrupt we want to
@@ -177,11 +149,9 @@ __handle_preemption_continue:
                 bne,pn                  %xcc, __handle_preemption
                  andcc                  %l0, _TIF_DO_NOTIFY_RESUME_MASK, %g0
                 bne,pn                  %xcc, __handle_signal
-__handle_signal_continue:
                  ldub                   [%g6 + TI_WSAVED], %o2
                 brnz,pn                 %o2, __handle_user_windows
                  nop
-__handle_user_windows_continue:
                 sethi                   %hi(TSTATE_PEF), %o0
                 andcc                   %l1, %o0, %g0
 
diff --git a/arch/sparc/kernel/sbus.c b/arch/sparc/kernel/sbus.c
index 2ca32d13abcf..a161b9c77f05 100644
--- a/arch/sparc/kernel/sbus.c
+++ b/arch/sparc/kernel/sbus.c
@@ -97,7 +97,7 @@ void sbus_set_sbus64(struct device *dev, int bursts)
 
         default:
                 return;
-        };
+        }
 
         val = upa_readq(cfg_reg);
         if (val & (1UL << 14UL)) {
@@ -244,7 +244,7 @@ static unsigned int sbus_build_irq(struct platform_device *op, unsigned int ino)
                 case 3:
                         iclr = reg_base + SYSIO_ICLR_SLOT3;
                         break;
-                };
+                }
 
                 iclr += ((unsigned long)sbus_level - 1UL) * 8UL;
         }
diff --git a/arch/sparc/kernel/setup_32.c b/arch/sparc/kernel/setup_32.c
index b22ce6100403..d26e1f6c717a 100644
--- a/arch/sparc/kernel/setup_32.c
+++ b/arch/sparc/kernel/setup_32.c
@@ -82,7 +82,7 @@ static void prom_sync_me(void)
                              "nop\n\t" : : "r" (&trapbase));
 
         prom_printf("PROM SYNC COMMAND...\n");
-        show_free_areas();
+        show_free_areas(0);
         if(current->pid != 0) {
                 local_irq_enable();
                 sys_sync();
@@ -103,16 +103,20 @@ static unsigned int boot_flags __initdata = 0;
 /* Exported for mm/init.c:paging_init. */
 unsigned long cmdline_memory_size __initdata = 0;
 
+/* which CPU booted us (0xff = not set) */
+unsigned char boot_cpu_id = 0xff; /* 0xff will make it into DATA section... */
+unsigned char boot_cpu_id4; /* boot_cpu_id << 2 */
+
 static void
 prom_console_write(struct console *con, const char *s, unsigned n)
 {
         prom_write(s, n);
 }
 
-static struct console prom_debug_console = {
-        .name =         "debug",
+static struct console prom_early_console = {
+        .name =         "earlyprom",
         .write =        prom_console_write,
-        .flags =        CON_PRINTBUFFER,
+        .flags =        CON_PRINTBUFFER | CON_BOOT,
         .index =        -1,
 };
 
@@ -133,8 +137,7 @@ static void __init process_switch(char c)
                 prom_halt();
                 break;
         case 'p':
-                /* Use PROM debug console. */
-                register_console(&prom_debug_console);
+                /* Just ignore, this behavior is now the default.  */
                 break;
         default:
                 printk("Unknown boot switch (-%c)\n", c);
@@ -184,8 +187,6 @@ static void __init boot_flags_init(char *commands)
  */
 
 extern void sun4c_probe_vac(void);
-extern char cputypval;
-extern unsigned long start, end;
 
 extern unsigned short root_flags;
 extern unsigned short root_dev;
@@ -210,30 +211,34 @@ void __init setup_arch(char **cmdline_p)
         int i;
         unsigned long highest_paddr;
 
-        sparc_ttable = (struct tt_entry *) &start;
+        sparc_ttable = (struct tt_entry *) &trapbase;
 
         /* Initialize PROM console and command line. */
         *cmdline_p = prom_getbootargs();
         strcpy(boot_command_line, *cmdline_p);
         parse_early_param();
 
+        boot_flags_init(*cmdline_p);
+
+        register_console(&prom_early_console);
+
         /* Set sparc_cpu_model */
         sparc_cpu_model = sun_unknown;
-        if (!strcmp(&cputypval,"sun4 "))
+        if (!strcmp(&cputypval[0], "sun4 "))
                 sparc_cpu_model = sun4;
-        if (!strcmp(&cputypval,"sun4c"))
+        if (!strcmp(&cputypval[0], "sun4c"))
                 sparc_cpu_model = sun4c;
-        if (!strcmp(&cputypval,"sun4m"))
+        if (!strcmp(&cputypval[0], "sun4m"))
                 sparc_cpu_model = sun4m;
-        if (!strcmp(&cputypval,"sun4s"))
+        if (!strcmp(&cputypval[0], "sun4s"))
                 sparc_cpu_model = sun4m; /* CP-1200 with PROM 2.30 -E */
-        if (!strcmp(&cputypval,"sun4d"))
+        if (!strcmp(&cputypval[0], "sun4d"))
                 sparc_cpu_model = sun4d;
-        if (!strcmp(&cputypval,"sun4e"))
+        if (!strcmp(&cputypval[0], "sun4e"))
                 sparc_cpu_model = sun4e;
-        if (!strcmp(&cputypval,"sun4u"))
+        if (!strcmp(&cputypval[0], "sun4u"))
                 sparc_cpu_model = sun4u;
-        if (!strncmp(&cputypval, "leon" , 4))
+        if (!strncmp(&cputypval[0], "leon" , 4))
                 sparc_cpu_model = sparc_leon;
 
         printk("ARCH: ");
@@ -262,12 +267,11 @@ void __init setup_arch(char **cmdline_p)
         default:
                 printk("UNKNOWN!\n");
                 break;
-        };
+        }
 
 #ifdef CONFIG_DUMMY_CONSOLE
         conswitchp = &dummy_con;
 #endif
-        boot_flags_init(*cmdline_p);
 
         idprom_init();
         if (ARCH_SUN4C)
@@ -313,75 +317,6 @@ void __init setup_arch(char **cmdline_p)
         smp_setup_cpu_possible_map();
 }
 
-static int ncpus_probed;
-
-static int show_cpuinfo(struct seq_file *m, void *__unused)
-{
-        seq_printf(m,
-                   "cpu\t\t: %s\n"
-                   "fpu\t\t: %s\n"
-                   "promlib\t\t: Version %d Revision %d\n"
-                   "prom\t\t: %d.%d\n"
-                   "type\t\t: %s\n"
-                   "ncpus probed\t: %d\n"
-                   "ncpus active\t: %d\n"
-#ifndef CONFIG_SMP
-                   "CPU0Bogo\t: %lu.%02lu\n"
-                   "CPU0ClkTck\t: %ld\n"
-#endif
-                   ,
-                   sparc_cpu_type,
-                   sparc_fpu_type ,
-                   romvec->pv_romvers,
-                   prom_rev,
-                   romvec->pv_printrev >> 16,
-                   romvec->pv_printrev & 0xffff,
-                   &cputypval,
-                   ncpus_probed,
-                   num_online_cpus()
-#ifndef CONFIG_SMP
-                   , cpu_data(0).udelay_val/(500000/HZ),
-                   (cpu_data(0).udelay_val/(5000/HZ)) % 100,
-                   cpu_data(0).clock_tick
-#endif
-                );
-
-#ifdef CONFIG_SMP
-        smp_bogo(m);
-#endif
-        mmu_info(m);
-#ifdef CONFIG_SMP
-        smp_info(m);
-#endif
-        return 0;
-}
-
-static void *c_start(struct seq_file *m, loff_t *pos)
-{
-        /* The pointer we are returning is arbitrary,
-         * it just has to be non-NULL and not IS_ERR
-         * in the success case.
-         */
-        return *pos == 0 ? &c_start : NULL;
-}
-
-static void *c_next(struct seq_file *m, void *v, loff_t *pos)
-{
-        ++*pos;
-        return c_start(m, pos);
-}
-
-static void c_stop(struct seq_file *m, void *v)
-{
-}
-
-const struct seq_operations cpuinfo_op = {
-        .start =c_start,
-        .next = c_next,
-        .stop = c_stop,
-        .show = show_cpuinfo,
-};
-
 extern int stop_a_enabled;
 
 void sun_do_break(void)
diff --git a/arch/sparc/kernel/setup_64.c b/arch/sparc/kernel/setup_64.c
index 5f72de67588b..c4dd0999da86 100644
--- a/arch/sparc/kernel/setup_64.c
+++ b/arch/sparc/kernel/setup_64.c
@@ -209,7 +209,7 @@ void __init per_cpu_patch(void)
                 default:
                         prom_printf("Unknown cpu type, halting.\n");
                         prom_halt();
-                };
+                }
 
                 *(unsigned int *) (addr +  0) = insns[0];
                 wmb();
@@ -315,7 +315,7 @@ void __init setup_arch(char **cmdline_p)
 
 #ifdef CONFIG_IP_PNP
         if (!ic_set_manually) {
-                int chosen = prom_finddevice ("/chosen");
+                phandle chosen = prom_finddevice("/chosen");
                 u32 cl, sv, gw;
                 
                 cl = prom_getintdefault (chosen, "client-ip", 0);
@@ -339,84 +339,6 @@ void __init setup_arch(char **cmdline_p)
         paging_init();
 }
 
-/* BUFFER is PAGE_SIZE bytes long. */
-
-extern void smp_info(struct seq_file *);
-extern void smp_bogo(struct seq_file *);
-extern void mmu_info(struct seq_file *);
-
-unsigned int dcache_parity_tl1_occurred;
-unsigned int icache_parity_tl1_occurred;
-
-int ncpus_probed;
-
-static int show_cpuinfo(struct seq_file *m, void *__unused)
-{
-        seq_printf(m, 
-                   "cpu\t\t: %s\n"
-                   "fpu\t\t: %s\n"
-                   "pmu\t\t: %s\n"
-                   "prom\t\t: %s\n"
-                   "type\t\t: %s\n"
-                   "ncpus probed\t: %d\n"
-                   "ncpus active\t: %d\n"
-                   "D$ parity tl1\t: %u\n"
-                   "I$ parity tl1\t: %u\n"
-#ifndef CONFIG_SMP
-                   "Cpu0ClkTck\t: %016lx\n"
-#endif
-                   ,
-                   sparc_cpu_type,
-                   sparc_fpu_type,
-                   sparc_pmu_type,
-                   prom_version,
-                   ((tlb_type == hypervisor) ?
-                    "sun4v" :
-                    "sun4u"),
-                   ncpus_probed,
-                   num_online_cpus(),
-                   dcache_parity_tl1_occurred,
-                   icache_parity_tl1_occurred
-#ifndef CONFIG_SMP
-                   , cpu_data(0).clock_tick
-#endif
-                );
-#ifdef CONFIG_SMP
-        smp_bogo(m);
-#endif
-        mmu_info(m);
-#ifdef CONFIG_SMP
-        smp_info(m);
-#endif
-        return 0;
-}
-
-static void *c_start(struct seq_file *m, loff_t *pos)
-{
-        /* The pointer we are returning is arbitrary,
-         * it just has to be non-NULL and not IS_ERR
-         * in the success case.
-         */
-        return *pos == 0 ? &c_start : NULL;
-}
-
-static void *c_next(struct seq_file *m, void *v, loff_t *pos)
-{
-        ++*pos;
-        return c_start(m, pos);
-}
-
-static void c_stop(struct seq_file *m, void *v)
-{
-}
-
-const struct seq_operations cpuinfo_op = {
-        .start =c_start,
-        .next = c_next,
-        .stop = c_stop,
-        .show = show_cpuinfo,
-};
-
 extern int stop_a_enabled;
 
 void sun_do_break(void)
diff --git a/arch/sparc/kernel/smp_32.c b/arch/sparc/kernel/smp_32.c
index 91c10fb70858..21b125341bf7 100644
--- a/arch/sparc/kernel/smp_32.c
+++ b/arch/sparc/kernel/smp_32.c
@@ -37,8 +37,6 @@
 #include "irq.h"
 
 volatile unsigned long cpu_callin_map[NR_CPUS] __cpuinitdata = {0,};
-unsigned char boot_cpu_id = 0;
-unsigned char boot_cpu_id4 = 0; /* boot_cpu_id << 2 */
 
 cpumask_t smp_commenced_mask = CPU_MASK_NONE;
 
@@ -53,6 +51,7 @@ cpumask_t smp_commenced_mask = CPU_MASK_NONE;
 void __cpuinit smp_store_cpu_info(int id)
 {
         int cpu_node;
+        int mid;
 
         cpu_data(id).udelay_val = loops_per_jiffy;
 
@@ -60,10 +59,13 @@ void __cpuinit smp_store_cpu_info(int id)
         cpu_data(id).clock_tick = prom_getintdefault(cpu_node,
                                                      "clock-frequency", 0);
         cpu_data(id).prom_node = cpu_node;
-        cpu_data(id).mid = cpu_get_hwmid(cpu_node);
+        mid = cpu_get_hwmid(cpu_node);
 
-        if (cpu_data(id).mid < 0)
-                panic("No MID found for CPU%d at node 0x%08d", id, cpu_node);
+        if (mid < 0) {
+                printk(KERN_NOTICE "No MID found for CPU%d at node 0x%08d", id, cpu_node);
+                mid = 0;
+        }
+        cpu_data(id).mid = mid;
 }
 
 void __init smp_cpus_done(unsigned int max_cpus)
@@ -112,7 +114,7 @@ void __init smp_cpus_done(unsigned int max_cpus)
                 printk("UNKNOWN!\n");
                 BUG();
                 break;
-        };
+        }
 }
 
 void cpu_panic(void)
@@ -125,13 +127,58 @@ struct linux_prom_registers smp_penguin_ctable __cpuinitdata = { 0 };
 
 void smp_send_reschedule(int cpu)
 {
-        /* See sparc64 */
+        /*
+         * CPU model dependent way of implementing IPI generation targeting
+         * a single CPU. The trap handler needs only to do trap entry/return
+         * to call schedule.
+         */
+        BTFIXUP_CALL(smp_ipi_resched)(cpu);
 }
 
 void smp_send_stop(void)
 {
 }
 
+void arch_send_call_function_single_ipi(int cpu)
+{
+        /* trigger one IPI single call on one CPU */
+        BTFIXUP_CALL(smp_ipi_single)(cpu);
+}
+
+void arch_send_call_function_ipi_mask(const struct cpumask *mask)
+{
+        int cpu;
+
+        /* trigger IPI mask call on each CPU */
+        for_each_cpu(cpu, mask)
+                BTFIXUP_CALL(smp_ipi_mask_one)(cpu);
+}
+
+void smp_resched_interrupt(void)
+{
+        irq_enter();
+        scheduler_ipi();
+        local_cpu_data().irq_resched_count++;
+        irq_exit();
+        /* re-schedule routine called by interrupt return code. */
+}
+
+void smp_call_function_single_interrupt(void)
+{
+        irq_enter();
+        generic_smp_call_function_single_interrupt();
+        local_cpu_data().irq_call_count++;
+        irq_exit();
+}
+
+void smp_call_function_interrupt(void)
+{
+        irq_enter();
+        generic_smp_call_function_interrupt();
+        local_cpu_data().irq_call_count++;
+        irq_exit();
+}
+
 void smp_flush_cache_all(void)
 {
         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_cache_all));
@@ -147,9 +194,10 @@ void smp_flush_tlb_all(void)
 void smp_flush_cache_mm(struct mm_struct *mm)
 {
         if(mm->context != NO_CONTEXT) {
-                cpumask_t cpu_mask = *mm_cpumask(mm);
-                cpu_clear(smp_processor_id(), cpu_mask);
-                if (!cpus_empty(cpu_mask))
+                cpumask_t cpu_mask;
+                cpumask_copy(&cpu_mask, mm_cpumask(mm));
+                cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
+                if (!cpumask_empty(&cpu_mask))
                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_cache_mm), (unsigned long) mm);
                 local_flush_cache_mm(mm);
         }
@@ -158,9 +206,10 @@ void smp_flush_cache_mm(struct mm_struct *mm)
 void smp_flush_tlb_mm(struct mm_struct *mm)
 {
         if(mm->context != NO_CONTEXT) {
-                cpumask_t cpu_mask = *mm_cpumask(mm);
-                cpu_clear(smp_processor_id(), cpu_mask);
-                if (!cpus_empty(cpu_mask)) {
+                cpumask_t cpu_mask;
+                cpumask_copy(&cpu_mask, mm_cpumask(mm));
+                cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
+                if (!cpumask_empty(&cpu_mask)) {
                         xc1((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_mm), (unsigned long) mm);
                         if(atomic_read(&mm->mm_users) == 1 && current->active_mm == mm)
                                 cpumask_copy(mm_cpumask(mm),
@@ -176,9 +225,10 @@ void smp_flush_cache_range(struct vm_area_struct *vma, unsigned long start,
         struct mm_struct *mm = vma->vm_mm;
 
         if (mm->context != NO_CONTEXT) {
-                cpumask_t cpu_mask = *mm_cpumask(mm);
-                cpu_clear(smp_processor_id(), cpu_mask);
-                if (!cpus_empty(cpu_mask))
+                cpumask_t cpu_mask;
+                cpumask_copy(&cpu_mask, mm_cpumask(mm));
+                cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
+                if (!cpumask_empty(&cpu_mask))
                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_cache_range), (unsigned long) vma, start, end);
                 local_flush_cache_range(vma, start, end);
         }
@@ -190,9 +240,10 @@ void smp_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
         struct mm_struct *mm = vma->vm_mm;
 
         if (mm->context != NO_CONTEXT) {
-                cpumask_t cpu_mask = *mm_cpumask(mm);
-                cpu_clear(smp_processor_id(), cpu_mask);
-                if (!cpus_empty(cpu_mask))
+                cpumask_t cpu_mask;
+                cpumask_copy(&cpu_mask, mm_cpumask(mm));
+                cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
+                if (!cpumask_empty(&cpu_mask))
                         xc3((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_range), (unsigned long) vma, start, end);
                 local_flush_tlb_range(vma, start, end);
         }
@@ -203,9 +254,10 @@ void smp_flush_cache_page(struct vm_area_struct *vma, unsigned long page)
         struct mm_struct *mm = vma->vm_mm;
 
         if(mm->context != NO_CONTEXT) {
-                cpumask_t cpu_mask = *mm_cpumask(mm);
-                cpu_clear(smp_processor_id(), cpu_mask);
-                if (!cpus_empty(cpu_mask))
+                cpumask_t cpu_mask;
+                cpumask_copy(&cpu_mask, mm_cpumask(mm));
+                cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
+                if (!cpumask_empty(&cpu_mask))
                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_cache_page), (unsigned long) vma, page);
                 local_flush_cache_page(vma, page);
         }
@@ -216,19 +268,15 @@ void smp_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
         struct mm_struct *mm = vma->vm_mm;
 
         if(mm->context != NO_CONTEXT) {
-                cpumask_t cpu_mask = *mm_cpumask(mm);
-                cpu_clear(smp_processor_id(), cpu_mask);
-                if (!cpus_empty(cpu_mask))
+                cpumask_t cpu_mask;
+                cpumask_copy(&cpu_mask, mm_cpumask(mm));
+                cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
+                if (!cpumask_empty(&cpu_mask))
                         xc2((smpfunc_t) BTFIXUP_CALL(local_flush_tlb_page), (unsigned long) vma, page);
                 local_flush_tlb_page(vma, page);
         }
 }
 
-void smp_reschedule_irq(void)
-{
-        set_need_resched();
-}
-
 void smp_flush_page_to_ram(unsigned long page)
 {
         /* Current theory is that those who call this are the one's
@@ -245,9 +293,10 @@ void smp_flush_page_to_ram(unsigned long page)
 
 void smp_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
 {
-        cpumask_t cpu_mask = *mm_cpumask(mm);
-        cpu_clear(smp_processor_id(), cpu_mask);
-        if (!cpus_empty(cpu_mask))
+        cpumask_t cpu_mask;
+        cpumask_copy(&cpu_mask, mm_cpumask(mm));
+        cpumask_clear_cpu(smp_processor_id(), &cpu_mask);
+        if (!cpumask_empty(&cpu_mask))
                 xc2((smpfunc_t) BTFIXUP_CALL(local_flush_sig_insns), (unsigned long) mm, insn_addr);
         local_flush_sig_insns(mm, insn_addr);
 }
@@ -325,7 +374,7 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
                 printk("UNKNOWN!\n");
                 BUG();
                 break;
-        };
+        }
 }
 
 /* Set this up early so that things like the scheduler can init
@@ -398,10 +447,10 @@ int __cpuinit __cpu_up(unsigned int cpu)
                 printk("UNKNOWN!\n");
                 BUG();
                 break;
-        };
+        }
 
         if (!ret) {
-                cpu_set(cpu, smp_commenced_mask);
+                cpumask_set_cpu(cpu, &smp_commenced_mask);
                 while (!cpu_online(cpu))
                         mb();
         }
diff --git a/arch/sparc/kernel/smp_64.c b/arch/sparc/kernel/smp_64.c
index b6a2b8f47040..99cb17251bb5 100644
--- a/arch/sparc/kernel/smp_64.c
+++ b/arch/sparc/kernel/smp_64.c
@@ -49,6 +49,7 @@
 #include <asm/mdesc.h>
 #include <asm/ldc.h>
 #include <asm/hypervisor.h>
+#include <asm/pcr.h>
 
 #include "cpumap.h"
 
@@ -120,11 +121,11 @@ void __cpuinit smp_callin(void)
         /* inform the notifiers about the new cpu */
         notify_cpu_starting(cpuid);
 
-        while (!cpu_isset(cpuid, smp_commenced_mask))
+        while (!cpumask_test_cpu(cpuid, &smp_commenced_mask))
                 rmb();
 
         ipi_call_lock_irq();
-        cpu_set(cpuid, cpu_online_map);
+        set_cpu_online(cpuid, true);
         ipi_call_unlock_irq();
 
         /* idle thread is expected to have preempt disabled */
@@ -188,7 +189,7 @@ static inline long get_delta (long *rt, long *master)
 void smp_synchronize_tick_client(void)
 {
         long i, delta, adj, adjust_latency = 0, done = 0;
-        unsigned long flags, rt, master_time_stamp, bound;
+        unsigned long flags, rt, master_time_stamp;
 #if DEBUG_TICK_SYNC
         struct {
                 long rt;        /* roundtrip time */
@@ -207,10 +208,8 @@ void smp_synchronize_tick_client(void)
         {
                 for (i = 0; i < NUM_ROUNDS; i++) {
                         delta = get_delta(&rt, &master_time_stamp);
-                        if (delta == 0) {
+                        if (delta == 0)
                                 done = 1;       /* let's lock on to this... */
-                                bound = rt;
-                        }
 
                         if (!done) {
                                 if (i > 0) {
@@ -786,7 +785,7 @@ static void xcall_deliver(u64 data0, u64 data1, u64 data2, const cpumask_t *mask
 
 /* Send cross call to all processors mentioned in MASK_P
  * except self.  Really, there are only two cases currently,
- * "&cpu_online_map" and "&mm->cpu_vm_mask".
+ * "cpu_online_mask" and "mm_cpumask(mm)".
  */
 static void smp_cross_call_masked(unsigned long *func, u32 ctx, u64 data1, u64 data2, const cpumask_t *mask)
 {
@@ -798,7 +797,7 @@ static void smp_cross_call_masked(unsigned long *func, u32 ctx, u64 data1, u64 d
 /* Send cross call to all processors except self. */
 static void smp_cross_call(unsigned long *func, u32 ctx, u64 data1, u64 data2)
 {
-        smp_cross_call_masked(func, ctx, data1, data2, &cpu_online_map);
+        smp_cross_call_masked(func, ctx, data1, data2, cpu_online_mask);
 }
 
 extern unsigned long xcall_sync_tick;
@@ -806,7 +805,7 @@ extern unsigned long xcall_sync_tick;
 static void smp_start_sync_tick_client(int cpu)
 {
         xcall_deliver((u64) &xcall_sync_tick, 0, 0,
-                      &cpumask_of_cpu(cpu));
+                      cpumask_of(cpu));
 }
 
 extern unsigned long xcall_call_function;
@@ -821,7 +820,7 @@ extern unsigned long xcall_call_function_single;
 void arch_send_call_function_single_ipi(int cpu)
 {
         xcall_deliver((u64) &xcall_call_function_single, 0, 0,
-                      &cpumask_of_cpu(cpu));
+                      cpumask_of(cpu));
 }
 
 void __irq_entry smp_call_function_client(int irq, struct pt_regs *regs)
@@ -919,7 +918,7 @@ void smp_flush_dcache_page_impl(struct page *page, int cpu)
                 }
                 if (data0) {
                         xcall_deliver(data0, __pa(pg_addr),
-                                      (u64) pg_addr, &cpumask_of_cpu(cpu));
+                                      (u64) pg_addr, cpumask_of(cpu));
 #ifdef CONFIG_DEBUG_DCFLUSH
                         atomic_inc(&dcpage_flushes_xcall);
 #endif
@@ -932,13 +931,12 @@ void smp_flush_dcache_page_impl(struct page *page, int cpu)
 void flush_dcache_page_all(struct mm_struct *mm, struct page *page)
 {
         void *pg_addr;
-        int this_cpu;
         u64 data0;
 
         if (tlb_type == hypervisor)
                 return;
 
-        this_cpu = get_cpu();
+        preempt_disable();
 
 #ifdef CONFIG_DEBUG_DCFLUSH
         atomic_inc(&dcpage_flushes);
@@ -956,14 +954,14 @@ void flush_dcache_page_all(struct mm_struct *mm, struct page *page)
         }
         if (data0) {
                 xcall_deliver(data0, __pa(pg_addr),
-                              (u64) pg_addr, &cpu_online_map);
+                              (u64) pg_addr, cpu_online_mask);
 #ifdef CONFIG_DEBUG_DCFLUSH
                 atomic_inc(&dcpage_flushes_xcall);
 #endif
         }
         __local_flush_dcache_page(page);
 
-        put_cpu();
+        preempt_enable();
 }
 
 void __irq_entry smp_new_mmu_context_version_client(int irq, struct pt_regs *regs)
@@ -1199,32 +1197,32 @@ void __devinit smp_fill_in_sib_core_maps(void)
         for_each_present_cpu(i) {
                 unsigned int j;
 
-                cpus_clear(cpu_core_map[i]);
+                cpumask_clear(&cpu_core_map[i]);
                 if (cpu_data(i).core_id == 0) {
-                        cpu_set(i, cpu_core_map[i]);
+                        cpumask_set_cpu(i, &cpu_core_map[i]);
                         continue;
                 }
 
                 for_each_present_cpu(j) {
                         if (cpu_data(i).core_id ==
                             cpu_data(j).core_id)
-                                cpu_set(j, cpu_core_map[i]);
+                                cpumask_set_cpu(j, &cpu_core_map[i]);
                 }
         }
 
         for_each_present_cpu(i) {
                 unsigned int j;
 
-                cpus_clear(per_cpu(cpu_sibling_map, i));
+                cpumask_clear(&per_cpu(cpu_sibling_map, i));
                 if (cpu_data(i).proc_id == -1) {
-                        cpu_set(i, per_cpu(cpu_sibling_map, i));
+                        cpumask_set_cpu(i, &per_cpu(cpu_sibling_map, i));
                         continue;
                 }
 
                 for_each_present_cpu(j) {
                         if (cpu_data(i).proc_id ==
                             cpu_data(j).proc_id)
-                                cpu_set(j, per_cpu(cpu_sibling_map, i));
+                                cpumask_set_cpu(j, &per_cpu(cpu_sibling_map, i));
                 }
         }
 }
@@ -1234,10 +1232,10 @@ int __cpuinit __cpu_up(unsigned int cpu)
         int ret = smp_boot_one_cpu(cpu);
 
         if (!ret) {
-                cpu_set(cpu, smp_commenced_mask);
-                while (!cpu_isset(cpu, cpu_online_map))
+                cpumask_set_cpu(cpu, &smp_commenced_mask);
+                while (!cpu_online(cpu))
                         mb();
-                if (!cpu_isset(cpu, cpu_online_map)) {
+                if (!cpu_online(cpu)) {
                         ret = -ENODEV;
                 } else {
                         /* On SUN4V, writes to %tick and %stick are
@@ -1271,7 +1269,7 @@ void cpu_play_dead(void)
                                 tb->nonresum_mondo_pa, 0);
         }
 
-        cpu_clear(cpu, smp_commenced_mask);
+        cpumask_clear_cpu(cpu, &smp_commenced_mask);
         membar_safe("#Sync");
 
         local_irq_disable();
@@ -1292,13 +1290,13 @@ int __cpu_disable(void)
         cpuinfo_sparc *c;
         int i;
 
-        for_each_cpu_mask(i, cpu_core_map[cpu])
-                cpu_clear(cpu, cpu_core_map[i]);
-        cpus_clear(cpu_core_map[cpu]);
+        for_each_cpu(i, &cpu_core_map[cpu])
+                cpumask_clear_cpu(cpu, &cpu_core_map[i]);
+        cpumask_clear(&cpu_core_map[cpu]);
 
-        for_each_cpu_mask(i, per_cpu(cpu_sibling_map, cpu))
-                cpu_clear(cpu, per_cpu(cpu_sibling_map, i));
-        cpus_clear(per_cpu(cpu_sibling_map, cpu));
+        for_each_cpu(i, &per_cpu(cpu_sibling_map, cpu))
+                cpumask_clear_cpu(cpu, &per_cpu(cpu_sibling_map, i));
+        cpumask_clear(&per_cpu(cpu_sibling_map, cpu));
 
         c = &cpu_data(cpu);
 
@@ -1315,7 +1313,7 @@ int __cpu_disable(void)
         local_irq_disable();
 
         ipi_call_lock();
-        cpu_clear(cpu, cpu_online_map);
+        set_cpu_online(cpu, false);
         ipi_call_unlock();
 
         cpu_map_rebuild();
@@ -1329,11 +1327,11 @@ void __cpu_die(unsigned int cpu)
 
         for (i = 0; i < 100; i++) {
                 smp_rmb();
-                if (!cpu_isset(cpu, smp_commenced_mask))
+                if (!cpumask_test_cpu(cpu, &smp_commenced_mask))
                         break;
                 msleep(100);
         }
-        if (cpu_isset(cpu, smp_commenced_mask)) {
+        if (cpumask_test_cpu(cpu, &smp_commenced_mask)) {
                 printk(KERN_ERR "CPU %u didn't die...\n", cpu);
         } else {
 #if defined(CONFIG_SUN_LDOMS)
@@ -1343,7 +1341,7 @@ void __cpu_die(unsigned int cpu)
                 do {
                         hv_err = sun4v_cpu_stop(cpu);
                         if (hv_err == HV_EOK) {
-                                cpu_clear(cpu, cpu_present_map);
+                                set_cpu_present(cpu, false);
                                 break;
                         }
                 } while (--limit > 0);
@@ -1358,17 +1356,19 @@ void __cpu_die(unsigned int cpu)
 
 void __init smp_cpus_done(unsigned int max_cpus)
 {
+        pcr_arch_init();
 }
 
 void smp_send_reschedule(int cpu)
 {
         xcall_deliver((u64) &xcall_receive_signal, 0, 0,
-                      &cpumask_of_cpu(cpu));
+                      cpumask_of(cpu));
 }
 
 void __irq_entry smp_receive_signal_client(int irq, struct pt_regs *regs)
 {
         clear_softint(1 << irq);
+        scheduler_ipi();
 }
 
 /* This is a nop because we capture all other cpus
diff --git a/arch/sparc/kernel/starfire.c b/arch/sparc/kernel/starfire.c
index 060d0f3a6151..82281a566bb8 100644
--- a/arch/sparc/kernel/starfire.c
+++ b/arch/sparc/kernel/starfire.c
@@ -23,8 +23,8 @@ int this_is_starfire = 0;
 
 void check_if_starfire(void)
 {
-        int ssnode = prom_finddevice("/ssp-serial");
-        if (ssnode != 0 && ssnode != -1)
+        phandle ssnode = prom_finddevice("/ssp-serial");
+        if (ssnode != 0 && (s32)ssnode != -1)
                 this_is_starfire = 1;
 }
 
diff --git a/arch/sparc/kernel/sun4c_irq.c b/arch/sparc/kernel/sun4c_irq.c
index 892fb884910a..f6bf25a2ff80 100644
--- a/arch/sparc/kernel/sun4c_irq.c
+++ b/arch/sparc/kernel/sun4c_irq.c
@@ -1,5 +1,5 @@
-/*  sun4c_irq.c
- *  arch/sparc/kernel/sun4c_irq.c:
+/*
+ * sun4c irq support
  *
  *  djhr: Hacked out of irq.c into a CPU dependent version.
  *
@@ -9,31 +9,41 @@
  *  Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
  */
 
-#include <linux/errno.h>
-#include <linux/linkage.h>
-#include <linux/kernel_stat.h>
-#include <linux/signal.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/interrupt.h>
 #include <linux/init.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-#include "irq.h"
 
-#include <asm/ptrace.h>
-#include <asm/processor.h>
-#include <asm/system.h>
-#include <asm/psr.h>
-#include <asm/vaddrs.h>
-#include <asm/timer.h>
-#include <asm/openprom.h>
 #include <asm/oplib.h>
-#include <asm/traps.h>
+#include <asm/timer.h>
 #include <asm/irq.h>
 #include <asm/io.h>
-#include <asm/idprom.h>
-#include <asm/machines.h>
+
+#include "irq.h"
+
+/* Sun4c interrupts are typically laid out as follows:
+ *
+ *  1 - Software interrupt, SBUS level 1
+ *  2 - SBUS level 2
+ *  3 - ESP SCSI, SBUS level 3
+ *  4 - Software interrupt
+ *  5 - Lance ethernet, SBUS level 4
+ *  6 - Software interrupt
+ *  7 - Graphics card, SBUS level 5
+ *  8 - SBUS level 6
+ *  9 - SBUS level 7
+ * 10 - Counter timer
+ * 11 - Floppy
+ * 12 - Zilog uart
+ * 13 - CS4231 audio
+ * 14 - Profiling timer
+ * 15 - NMI
+ *
+ * The interrupt enable bits in the interrupt mask register are
+ * really only used to enable/disable the timer interrupts, and
+ * for signalling software interrupts.  There is also a master
+ * interrupt enable bit in this register.
+ *
+ * Interrupts are enabled by setting the SUN4C_INT_* bits, they
+ * are disabled by clearing those bits.
+ */
 
 /*
  * Bit field defines for the interrupt registers on various
@@ -49,73 +59,100 @@
 #define SUN4C_INT_E4      0x04     /* Enable level 4 IRQ. */
 #define SUN4C_INT_E1      0x02     /* Enable level 1 IRQ. */
 
-/* Pointer to the interrupt enable byte
- *
- * Dave Redman (djhr@tadpole.co.uk)
- * What you may not be aware of is that entry.S requires this variable.
- *
- *  --- linux_trap_nmi_sun4c --
- *
- * so don't go making it static, like I tried. sigh.
+/*
+ * Pointer to the interrupt enable byte
+ * Used by entry.S
  */
-unsigned char __iomem *interrupt_enable = NULL;
+unsigned char __iomem *interrupt_enable;
 
-static void sun4c_disable_irq(unsigned int irq_nr)
+static void sun4c_mask_irq(struct irq_data *data)
 {
-        unsigned long flags;
-        unsigned char current_mask, new_mask;
-    
-        local_irq_save(flags);
-        irq_nr &= (NR_IRQS - 1);
-        current_mask = sbus_readb(interrupt_enable);
-        switch(irq_nr) {
-        case 1:
-                new_mask = ((current_mask) & (~(SUN4C_INT_E1)));
-                break;
-        case 8:
-                new_mask = ((current_mask) & (~(SUN4C_INT_E8)));
-                break;
-        case 10:
-                new_mask = ((current_mask) & (~(SUN4C_INT_E10)));
-                break;
-        case 14:
-                new_mask = ((current_mask) & (~(SUN4C_INT_E14)));
-                break;
-        default:
+        unsigned long mask = (unsigned long)data->chip_data;
+
+        if (mask) {
+                unsigned long flags;
+
+                local_irq_save(flags);
+                mask = sbus_readb(interrupt_enable) & ~mask;
+                sbus_writeb(mask, interrupt_enable);
                 local_irq_restore(flags);
-                return;
         }
-        sbus_writeb(new_mask, interrupt_enable);
-        local_irq_restore(flags);
 }
 
-static void sun4c_enable_irq(unsigned int irq_nr)
+static void sun4c_unmask_irq(struct irq_data *data)
 {
-        unsigned long flags;
-        unsigned char current_mask, new_mask;
-    
-        local_irq_save(flags);
-        irq_nr &= (NR_IRQS - 1);
-        current_mask = sbus_readb(interrupt_enable);
-        switch(irq_nr) {
-        case 1:
-                new_mask = ((current_mask) | SUN4C_INT_E1);
-                break;
-        case 8:
-                new_mask = ((current_mask) | SUN4C_INT_E8);
-                break;
-        case 10:
-                new_mask = ((current_mask) | SUN4C_INT_E10);
-                break;
-        case 14:
-                new_mask = ((current_mask) | SUN4C_INT_E14);
-                break;
-        default:
+        unsigned long mask = (unsigned long)data->chip_data;
+
+        if (mask) {
+                unsigned long flags;
+
+                local_irq_save(flags);
+                mask = sbus_readb(interrupt_enable) | mask;
+                sbus_writeb(mask, interrupt_enable);
                 local_irq_restore(flags);
-                return;
         }
-        sbus_writeb(new_mask, interrupt_enable);
-        local_irq_restore(flags);
+}
+
+static unsigned int sun4c_startup_irq(struct irq_data *data)
+{
+        irq_link(data->irq);
+        sun4c_unmask_irq(data);
+
+        return 0;
+}
+
+static void sun4c_shutdown_irq(struct irq_data *data)
+{
+        sun4c_mask_irq(data);
+        irq_unlink(data->irq);
+}
+
+static struct irq_chip sun4c_irq = {
+        .name           = "sun4c",
+        .irq_startup    = sun4c_startup_irq,
+        .irq_shutdown   = sun4c_shutdown_irq,
+        .irq_mask       = sun4c_mask_irq,
+        .irq_unmask     = sun4c_unmask_irq,
+};
+
+static unsigned int sun4c_build_device_irq(struct platform_device *op,
+                                           unsigned int real_irq)
+{
+         unsigned int irq;
+
+        if (real_irq >= 16) {
+                prom_printf("Bogus sun4c IRQ %u\n", real_irq);
+                prom_halt();
+        }
+
+        irq = irq_alloc(real_irq, real_irq);
+        if (irq) {
+                unsigned long mask = 0UL;
+
+                switch (real_irq) {
+                case 1:
+                        mask = SUN4C_INT_E1;
+                        break;
+                case 8:
+                        mask = SUN4C_INT_E8;
+                        break;
+                case 10:
+                        mask = SUN4C_INT_E10;
+                        break;
+                case 14:
+                        mask = SUN4C_INT_E14;
+                        break;
+                default:
+                        /* All the rest are either always enabled,
+                         * or are for signalling software interrupts.
+                         */
+                        break;
+                }
+                irq_set_chip_and_handler_name(irq, &sun4c_irq,
+                                              handle_level_irq, "level");
+                irq_set_chip_data(irq, (void *)mask);
+        }
+        return irq;
 }
 
 struct sun4c_timer_info {
@@ -139,8 +176,9 @@ static void sun4c_load_profile_irq(int cpu, unsigned int limit)
 
 static void __init sun4c_init_timers(irq_handler_t counter_fn)
 {
-        const struct linux_prom_irqs *irq;
+        const struct linux_prom_irqs *prom_irqs;
         struct device_node *dp;
+        unsigned int irq;
         const u32 *addr;
         int err;
 
@@ -158,9 +196,9 @@ static void __init sun4c_init_timers(irq_handler_t counter_fn)
 
         sun4c_timers = (void __iomem *) (unsigned long) addr[0];
 
-        irq = of_get_property(dp, "intr", NULL);
+        prom_irqs = of_get_property(dp, "intr", NULL);
         of_node_put(dp);
-        if (!irq) {
+        if (!prom_irqs) {
                 prom_printf("sun4c_init_timers: No intr property\n");
                 prom_halt();
         }
@@ -173,19 +211,21 @@ static void __init sun4c_init_timers(irq_handler_t counter_fn)
 
         master_l10_counter = &sun4c_timers->l10_count;
 
-        err = request_irq(irq[0].pri, counter_fn,
-                          (IRQF_DISABLED | SA_STATIC_ALLOC),
-                          "timer", NULL);
+        irq = sun4c_build_device_irq(NULL, prom_irqs[0].pri);
+        err = request_irq(irq, counter_fn, IRQF_TIMER, "timer", NULL);
         if (err) {
                 prom_printf("sun4c_init_timers: request_irq() fails with %d\n", err);
                 prom_halt();
         }
-    
-        sun4c_disable_irq(irq[1].pri);
+
+        /* disable timer interrupt */
+        sun4c_mask_irq(irq_get_irq_data(irq));
 }
 
 #ifdef CONFIG_SMP
-static void sun4c_nop(void) {}
+static void sun4c_nop(void)
+{
+}
 #endif
 
 void __init sun4c_init_IRQ(void)
@@ -208,13 +248,12 @@ void __init sun4c_init_IRQ(void)
 
         interrupt_enable = (void __iomem *) (unsigned long) addr[0];
 
-        BTFIXUPSET_CALL(enable_irq, sun4c_enable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_irq, sun4c_disable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(enable_pil_irq, sun4c_enable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_pil_irq, sun4c_disable_irq, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(clear_clock_irq, sun4c_clear_clock_irq, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(load_profile_irq, sun4c_load_profile_irq, BTFIXUPCALL_NOP);
-        sparc_init_timers = sun4c_init_timers;
+
+        sparc_irq_config.init_timers      = sun4c_init_timers;
+        sparc_irq_config.build_device_irq = sun4c_build_device_irq;
+
 #ifdef CONFIG_SMP
         BTFIXUPSET_CALL(set_cpu_int, sun4c_nop, BTFIXUPCALL_NOP);
         BTFIXUPSET_CALL(clear_cpu_int, sun4c_nop, BTFIXUPCALL_NOP);
diff --git a/arch/sparc/kernel/sun4d_irq.c b/arch/sparc/kernel/sun4d_irq.c
index e11b4612dabb..1d13c5bda0b1 100644
--- a/arch/sparc/kernel/sun4d_irq.c
+++ b/arch/sparc/kernel/sun4d_irq.c
@@ -1,50 +1,41 @@
 /*
- *  arch/sparc/kernel/sun4d_irq.c:
- *                      SS1000/SC2000 interrupt handling.
+ * SS1000/SC2000 interrupt handling.
  *
  *  Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  *  Heavily based on arch/sparc/kernel/irq.c.
  */
 
-#include <linux/errno.h>
-#include <linux/linkage.h>
 #include <linux/kernel_stat.h>
-#include <linux/signal.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/interrupt.h>
-#include <linux/slab.h>
-#include <linux/random.h>
-#include <linux/init.h>
-#include <linux/smp.h>
-#include <linux/spinlock.h>
 #include <linux/seq_file.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-
-#include <asm/ptrace.h>
-#include <asm/processor.h>
-#include <asm/system.h>
-#include <asm/psr.h>
-#include <asm/smp.h>
-#include <asm/vaddrs.h>
+
 #include <asm/timer.h>
-#include <asm/openprom.h>
-#include <asm/oplib.h>
 #include <asm/traps.h>
 #include <asm/irq.h>
 #include <asm/io.h>
-#include <asm/pgalloc.h>
-#include <asm/pgtable.h>
 #include <asm/sbi.h>
 #include <asm/cacheflush.h>
-#include <asm/irq_regs.h>
+#include <asm/setup.h>
 
 #include "kernel.h"
 #include "irq.h"
 
-/* If you trust current SCSI layer to handle different SCSI IRQs, enable this. I don't trust it... -jj */
-/* #define DISTRIBUTE_IRQS */
+/* Sun4d interrupts fall roughly into two categories.  SBUS and
+ * cpu local.  CPU local interrupts cover the timer interrupts
+ * and whatnot, and we encode those as normal PILs between
+ * 0 and 15.
+ * SBUS interrupts are encodes as a combination of board, level and slot.
+ */
+
+struct sun4d_handler_data {
+        unsigned int cpuid;    /* target cpu */
+        unsigned int real_irq; /* interrupt level */
+};
+
+
+static unsigned int sun4d_encode_irq(int board, int lvl, int slot)
+{
+        return (board + 1) << 5 | (lvl << 2) | slot;
+}
 
 struct sun4d_timer_regs {
         u32     l10_timer_limit;
@@ -56,320 +47,201 @@ struct sun4d_timer_regs {
 
 static struct sun4d_timer_regs __iomem *sun4d_timers;
 
-#define TIMER_IRQ       10
-
-#define MAX_STATIC_ALLOC        4
-extern int static_irq_count;
-static unsigned char sbus_tid[32];
-
-static struct irqaction *irq_action[NR_IRQS];
-extern spinlock_t irq_action_lock;
+#define SUN4D_TIMER_IRQ        10
 
-static struct sbus_action {
-        struct irqaction *action;
-        /* For SMP this needs to be extended */
-} *sbus_actions;
+/* Specify which cpu handle interrupts from which board.
+ * Index is board - value is cpu.
+ */
+static unsigned char board_to_cpu[32];
 
 static int pil_to_sbus[] = {
-        0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0,
-};
-
-static int sbus_to_pil[] = {
-        0, 2, 3, 5, 7, 9, 11, 13,
+        0,
+        0,
+        1,
+        2,
+        0,
+        3,
+        0,
+        4,
+        0,
+        5,
+        0,
+        6,
+        0,
+        7,
+        0,
+        0,
 };
 
-static int nsbi;
-
 /* Exported for sun4d_smp.c */
 DEFINE_SPINLOCK(sun4d_imsk_lock);
 
-int show_sun4d_interrupts(struct seq_file *p, void *v)
-{
-        int i = *(loff_t *) v, j = 0, k = 0, sbusl;
-        struct irqaction * action;
-        unsigned long flags;
-#ifdef CONFIG_SMP
-        int x;
-#endif
-
-        spin_lock_irqsave(&irq_action_lock, flags);
-        if (i < NR_IRQS) {
-                sbusl = pil_to_sbus[i];
-                if (!sbusl) {
-                        action = *(i + irq_action);
-                        if (!action) 
-                                goto out_unlock;
-                } else {
-                        for (j = 0; j < nsbi; j++) {
-                                for (k = 0; k < 4; k++)
-                                        if ((action = sbus_actions [(j << 5) + (sbusl << 2) + k].action))
-                                                goto found_it;
-                        }
-                        goto out_unlock;
-                }
-found_it:       seq_printf(p, "%3d: ", i);
-#ifndef CONFIG_SMP
-                seq_printf(p, "%10u ", kstat_irqs(i));
-#else
-                for_each_online_cpu(x)
-                        seq_printf(p, "%10u ",
-                               kstat_cpu(cpu_logical_map(x)).irqs[i]);
-#endif
-                seq_printf(p, "%c %s",
-                        (action->flags & IRQF_DISABLED) ? '+' : ' ',
-                        action->name);
-                action = action->next;
-                for (;;) {
-                        for (; action; action = action->next) {
-                                seq_printf(p, ",%s %s",
-                                        (action->flags & IRQF_DISABLED) ? " +" : "",
-                                        action->name);
-                        }
-                        if (!sbusl) break;
-                        k++;
-                        if (k < 4)
-                                action = sbus_actions [(j << 5) + (sbusl << 2) + k].action;
-                        else {
-                                j++;
-                                if (j == nsbi) break;
-                                k = 0;
-                                action = sbus_actions [(j << 5) + (sbusl << 2)].action;
-                        }
-                }
-                seq_putc(p, '\n');
-        }
-out_unlock:
-        spin_unlock_irqrestore(&irq_action_lock, flags);
-        return 0;
-}
-
-void sun4d_free_irq(unsigned int irq, void *dev_id)
+/* SBUS interrupts are encoded integers including the board number
+ * (plus one), the SBUS level, and the SBUS slot number.  Sun4D
+ * IRQ dispatch is done by:
+ *
+ * 1) Reading the BW local interrupt table in order to get the bus
+ *    interrupt mask.
+ *
+ *    This table is indexed by SBUS interrupt level which can be
+ *    derived from the PIL we got interrupted on.
+ *
+ * 2) For each bus showing interrupt pending from #1, read the
+ *    SBI interrupt state register.  This will indicate which slots
+ *    have interrupts pending for that SBUS interrupt level.
+ *
+ * 3) Call the genreric IRQ support.
+ */
+static void sun4d_sbus_handler_irq(int sbusl)
 {
-        struct irqaction *action, **actionp;
-        struct irqaction *tmp = NULL;
-        unsigned long flags;
-
-        spin_lock_irqsave(&irq_action_lock, flags);
-        if (irq < 15)
-                actionp = irq + irq_action;
-        else
-                actionp = &(sbus_actions[irq - (1 << 5)].action);
-        action = *actionp;
-        if (!action) {
-                printk("Trying to free free IRQ%d\n",irq);
-                goto out_unlock;
-        }
-        if (dev_id) {
-                for (; action; action = action->next) {
-                        if (action->dev_id == dev_id)
-                                break;
-                        tmp = action;
-                }
-                if (!action) {
-                        printk("Trying to free free shared IRQ%d\n",irq);
-                        goto out_unlock;
-                }
-        } else if (action->flags & IRQF_SHARED) {
-                printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
-                goto out_unlock;
-        }
-        if (action->flags & SA_STATIC_ALLOC)
-        {
-                /* This interrupt is marked as specially allocated
-                 * so it is a bad idea to free it.
+        unsigned int bus_mask;
+        unsigned int sbino, slot;
+        unsigned int sbil;
+
+        bus_mask = bw_get_intr_mask(sbusl) & 0x3ffff;
+        bw_clear_intr_mask(sbusl, bus_mask);
+
+        sbil = (sbusl << 2);
+        /* Loop for each pending SBI */
+        for (sbino = 0; bus_mask; sbino++, bus_mask >>= 1) {
+                unsigned int idx, mask;
+
+                if (!(bus_mask & 1))
+                        continue;
+                /* XXX This seems to ACK the irq twice.  acquire_sbi()
+                 * XXX uses swap, therefore this writes 0xf << sbil,
+                 * XXX then later release_sbi() will write the individual
+                 * XXX bits which were set again.
                  */
-                printk("Attempt to free statically allocated IRQ%d (%s)\n",
-                       irq, action->name);
-                goto out_unlock;
-        }
-        
-        if (tmp)
-                tmp->next = action->next;
-        else
-                *actionp = action->next;
-
-        spin_unlock_irqrestore(&irq_action_lock, flags);
+                mask = acquire_sbi(SBI2DEVID(sbino), 0xf << sbil);
+                mask &= (0xf << sbil);
 
-        synchronize_irq(irq);
+                /* Loop for each pending SBI slot */
+                slot = (1 << sbil);
+                for (idx = 0; mask != 0; idx++, slot <<= 1) {
+                        unsigned int pil;
+                        struct irq_bucket *p;
 
-        spin_lock_irqsave(&irq_action_lock, flags);
+                        if (!(mask & slot))
+                                continue;
 
-        kfree(action);
+                        mask &= ~slot;
+                        pil = sun4d_encode_irq(sbino, sbusl, idx);
 
-        if (!(*actionp))
-                __disable_irq(irq);
+                        p = irq_map[pil];
+                        while (p) {
+                                struct irq_bucket *next;
 
-out_unlock:
-        spin_unlock_irqrestore(&irq_action_lock, flags);
+                                next = p->next;
+                                generic_handle_irq(p->irq);
+                                p = next;
+                        }
+                        release_sbi(SBI2DEVID(sbino), slot);
+                }
+        }
 }
 
-extern void unexpected_irq(int, void *, struct pt_regs *);
-
-void sun4d_handler_irq(int irq, struct pt_regs * regs)
+void sun4d_handler_irq(int pil, struct pt_regs *regs)
 {
         struct pt_regs *old_regs;
-        struct irqaction * action;
-        int cpu = smp_processor_id();
         /* SBUS IRQ level (1 - 7) */
-        int sbusl = pil_to_sbus[irq];
-        
+        int sbusl = pil_to_sbus[pil];
+
         /* FIXME: Is this necessary?? */
         cc_get_ipen();
-        
-        cc_set_iclr(1 << irq);
-        
+
+        cc_set_iclr(1 << pil);
+
+#ifdef CONFIG_SMP
+        /*
+         * Check IPI data structures after IRQ has been cleared. Hard and Soft
+         * IRQ can happen at the same time, so both cases are always handled.
+         */
+        if (pil == SUN4D_IPI_IRQ)
+                sun4d_ipi_interrupt();
+#endif
+
         old_regs = set_irq_regs(regs);
         irq_enter();
-        kstat_cpu(cpu).irqs[irq]++;
-        if (!sbusl) {
-                action = *(irq + irq_action);
-                if (!action)
-                        unexpected_irq(irq, NULL, regs);
-                do {
-                        action->handler(irq, action->dev_id);
-                        action = action->next;
-                } while (action);
+        if (sbusl == 0) {
+                /* cpu interrupt */
+                struct irq_bucket *p;
+
+                p = irq_map[pil];
+                while (p) {
+                        struct irq_bucket *next;
+
+                        next = p->next;
+                        generic_handle_irq(p->irq);
+                        p = next;
+                }
         } else {
-                int bus_mask = bw_get_intr_mask(sbusl) & 0x3ffff;
-                int sbino;
-                struct sbus_action *actionp;
-                unsigned mask, slot;
-                int sbil = (sbusl << 2);
-                
-                bw_clear_intr_mask(sbusl, bus_mask);
-                
-                /* Loop for each pending SBI */
-                for (sbino = 0; bus_mask; sbino++, bus_mask >>= 1)
-                        if (bus_mask & 1) {
-                                mask = acquire_sbi(SBI2DEVID(sbino), 0xf << sbil);
-                                mask &= (0xf << sbil);
-                                actionp = sbus_actions + (sbino << 5) + (sbil);
-                                /* Loop for each pending SBI slot */
-                                for (slot = (1 << sbil); mask; slot <<= 1, actionp++)
-                                        if (mask & slot) {
-                                                mask &= ~slot;
-                                                action = actionp->action;
-                                                
-                                                if (!action)
-                                                        unexpected_irq(irq, NULL, regs);
-                                                do {
-                                                        action->handler(irq, action->dev_id);
-                                                        action = action->next;
-                                                } while (action);
-                                                release_sbi(SBI2DEVID(sbino), slot);
-                                        }
-                        }
+                /* SBUS interrupt */
+                sun4d_sbus_handler_irq(sbusl);
         }
         irq_exit();
         set_irq_regs(old_regs);
 }
 
-int sun4d_request_irq(unsigned int irq,
-                irq_handler_t handler,
-                unsigned long irqflags, const char * devname, void *dev_id)
+
+static void sun4d_mask_irq(struct irq_data *data)
 {
-        struct irqaction *action, *tmp = NULL, **actionp;
+        struct sun4d_handler_data *handler_data = data->handler_data;
+        unsigned int real_irq;
+#ifdef CONFIG_SMP
+        int cpuid = handler_data->cpuid;
         unsigned long flags;
-        int ret;
-        
-        if(irq > 14 && irq < (1 << 5)) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        if (!handler) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        spin_lock_irqsave(&irq_action_lock, flags);
-
-        if (irq >= (1 << 5))
-                actionp = &(sbus_actions[irq - (1 << 5)].action);
-        else
-                actionp = irq + irq_action;
-        action = *actionp;
-        
-        if (action) {
-                if ((action->flags & IRQF_SHARED) && (irqflags & IRQF_SHARED)) {
-                        for (tmp = action; tmp->next; tmp = tmp->next);
-                } else {
-                        ret = -EBUSY;
-                        goto out_unlock;
-                }
-                if ((action->flags & IRQF_DISABLED) ^ (irqflags & IRQF_DISABLED)) {
-                        printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
-                        ret = -EBUSY;
-                        goto out_unlock;
-                }
-                action = NULL;          /* Or else! */
-        }
-
-        /* If this is flagged as statically allocated then we use our
-         * private struct which is never freed.
-         */
-        if (irqflags & SA_STATIC_ALLOC) {
-                if (static_irq_count < MAX_STATIC_ALLOC)
-                        action = &static_irqaction[static_irq_count++];
-                else
-                        printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
-        }
-        
-        if (action == NULL)
-                action = kmalloc(sizeof(struct irqaction),
-                                                     GFP_ATOMIC);
-        
-        if (!action) { 
-                ret = -ENOMEM;
-                goto out_unlock;
-        }
-
-        action->handler = handler;
-        action->flags = irqflags;
-        action->name = devname;
-        action->next = NULL;
-        action->dev_id = dev_id;
-
-        if (tmp)
-                tmp->next = action;
-        else
-                *actionp = action;
-                
-        __enable_irq(irq);
-
-        ret = 0;
-out_unlock:
-        spin_unlock_irqrestore(&irq_action_lock, flags);
-out:
-        return ret;
+#endif
+        real_irq = handler_data->real_irq;
+#ifdef CONFIG_SMP
+        spin_lock_irqsave(&sun4d_imsk_lock, flags);
+        cc_set_imsk_other(cpuid, cc_get_imsk_other(cpuid) | (1 << real_irq));
+        spin_unlock_irqrestore(&sun4d_imsk_lock, flags);
+#else
+        cc_set_imsk(cc_get_imsk() | (1 << real_irq));
+#endif
 }
 
-static void sun4d_disable_irq(unsigned int irq)
+static void sun4d_unmask_irq(struct irq_data *data)
 {
-        int tid = sbus_tid[(irq >> 5) - 1];
+        struct sun4d_handler_data *handler_data = data->handler_data;
+        unsigned int real_irq;
+#ifdef CONFIG_SMP
+        int cpuid = handler_data->cpuid;
         unsigned long flags;
-        
-        if (irq < NR_IRQS)
-                return;
+#endif
+        real_irq = handler_data->real_irq;
 
+#ifdef CONFIG_SMP
         spin_lock_irqsave(&sun4d_imsk_lock, flags);
-        cc_set_imsk_other(tid, cc_get_imsk_other(tid) | (1 << sbus_to_pil[(irq >> 2) & 7]));
+        cc_set_imsk_other(cpuid, cc_get_imsk_other(cpuid) & ~(1 << real_irq));
         spin_unlock_irqrestore(&sun4d_imsk_lock, flags);
+#else
+        cc_set_imsk(cc_get_imsk() & ~(1 << real_irq));
+#endif
 }
 
-static void sun4d_enable_irq(unsigned int irq)
+static unsigned int sun4d_startup_irq(struct irq_data *data)
 {
-        int tid = sbus_tid[(irq >> 5) - 1];
-        unsigned long flags;
-        
-        if (irq < NR_IRQS)
-                return;
+        irq_link(data->irq);
+        sun4d_unmask_irq(data);
+        return 0;
+}
 
-        spin_lock_irqsave(&sun4d_imsk_lock, flags);
-        cc_set_imsk_other(tid, cc_get_imsk_other(tid) & ~(1 << sbus_to_pil[(irq >> 2) & 7]));
-        spin_unlock_irqrestore(&sun4d_imsk_lock, flags);
+static void sun4d_shutdown_irq(struct irq_data *data)
+{
+        sun4d_mask_irq(data);
+        irq_unlink(data->irq);
 }
 
+struct irq_chip sun4d_irq = {
+        .name           = "sun4d",
+        .irq_startup    = sun4d_startup_irq,
+        .irq_shutdown   = sun4d_shutdown_irq,
+        .irq_unmask     = sun4d_unmask_irq,
+        .irq_mask       = sun4d_mask_irq,
+};
+
 #ifdef CONFIG_SMP
 static void sun4d_set_cpu_int(int cpu, int level)
 {
@@ -389,44 +261,6 @@ void __init sun4d_distribute_irqs(void)
 {
         struct device_node *dp;
 
-#ifdef DISTRIBUTE_IRQS
-        cpumask_t sbus_serving_map;
-
-        sbus_serving_map = cpu_present_map;
-        for_each_node_by_name(dp, "sbi") {
-                int board = of_getintprop_default(dp, "board#", 0);
-
-                if ((board * 2) == boot_cpu_id && cpu_isset(board * 2 + 1, cpu_present_map))
-                        sbus_tid[board] = (board * 2 + 1);
-                else if (cpu_isset(board * 2, cpu_present_map))
-                        sbus_tid[board] = (board * 2);
-                else if (cpu_isset(board * 2 + 1, cpu_present_map))
-                        sbus_tid[board] = (board * 2 + 1);
-                else
-                        sbus_tid[board] = 0xff;
-                if (sbus_tid[board] != 0xff)
-                        cpu_clear(sbus_tid[board], sbus_serving_map);
-        }
-        for_each_node_by_name(dp, "sbi") {
-                int board = of_getintprop_default(dp, "board#", 0);
-                if (sbus_tid[board] == 0xff) {
-                        int i = 31;
-                                
-                        if (cpus_empty(sbus_serving_map))
-                                sbus_serving_map = cpu_present_map;
-                        while (cpu_isset(i, sbus_serving_map))
-                                i--;
-                        sbus_tid[board] = i;
-                        cpu_clear(i, sbus_serving_map);
-                }
-        }
-        for_each_node_by_name(dp, "sbi") {
-                int devid = of_getintprop_default(dp, "device-id", 0);
-                int board = of_getintprop_default(dp, "board#", 0);
-                printk("sbus%d IRQs directed to CPU%d\n", board, sbus_tid[board]);
-                set_sbi_tid(devid, sbus_tid[board] << 3);
-        }
-#else
         int cpuid = cpu_logical_map(1);
 
         if (cpuid == -1)
@@ -434,14 +268,13 @@ void __init sun4d_distribute_irqs(void)
         for_each_node_by_name(dp, "sbi") {
                 int devid = of_getintprop_default(dp, "device-id", 0);
                 int board = of_getintprop_default(dp, "board#", 0);
-                sbus_tid[board] = cpuid;
+                board_to_cpu[board] = cpuid;
                 set_sbi_tid(devid, cpuid << 3);
         }
-        printk("All sbus IRQs directed to CPU%d\n", cpuid);
-#endif
+        printk(KERN_ERR "All sbus IRQs directed to CPU%d\n", cpuid);
 }
 #endif
- 
+
 static void sun4d_clear_clock_irq(void)
 {
         sbus_readl(&sun4d_timers->l10_timer_limit);
@@ -462,14 +295,115 @@ static void __init sun4d_load_profile_irqs(void)
         }
 }
 
+unsigned int _sun4d_build_device_irq(unsigned int real_irq,
+                                     unsigned int pil,
+                                     unsigned int board)
+{
+        struct sun4d_handler_data *handler_data;
+        unsigned int irq;
+
+        irq = irq_alloc(real_irq, pil);
+        if (irq == 0) {
+                prom_printf("IRQ: allocate for %d %d %d failed\n",
+                        real_irq, pil, board);
+                goto err_out;
+        }
+
+        handler_data = irq_get_handler_data(irq);
+        if (unlikely(handler_data))
+                goto err_out;
+
+        handler_data = kzalloc(sizeof(struct sun4d_handler_data), GFP_ATOMIC);
+        if (unlikely(!handler_data)) {
+                prom_printf("IRQ: kzalloc(sun4d_handler_data) failed.\n");
+                prom_halt();
+        }
+        handler_data->cpuid    = board_to_cpu[board];
+        handler_data->real_irq = real_irq;
+        irq_set_chip_and_handler_name(irq, &sun4d_irq,
+                                      handle_level_irq, "level");
+        irq_set_handler_data(irq, handler_data);
+
+err_out:
+        return irq;
+}
+
+
+
+unsigned int sun4d_build_device_irq(struct platform_device *op,
+                                    unsigned int real_irq)
+{
+        struct device_node *dp = op->dev.of_node;
+        struct device_node *board_parent, *bus = dp->parent;
+        char *bus_connection;
+        const struct linux_prom_registers *regs;
+        unsigned int pil;
+        unsigned int irq;
+        int board, slot;
+        int sbusl;
+
+        irq = real_irq;
+        while (bus) {
+                if (!strcmp(bus->name, "sbi")) {
+                        bus_connection = "io-unit";
+                        break;
+                }
+
+                if (!strcmp(bus->name, "bootbus")) {
+                        bus_connection = "cpu-unit";
+                        break;
+                }
+
+                bus = bus->parent;
+        }
+        if (!bus)
+                goto err_out;
+
+        regs = of_get_property(dp, "reg", NULL);
+        if (!regs)
+                goto err_out;
+
+        slot = regs->which_io;
+
+        /*
+         * If Bus nodes parent is not io-unit/cpu-unit or the io-unit/cpu-unit
+         * lacks a "board#" property, something is very wrong.
+         */
+        if (!bus->parent || strcmp(bus->parent->name, bus_connection)) {
+                printk(KERN_ERR "%s: Error, parent is not %s.\n",
+                        bus->full_name, bus_connection);
+                goto err_out;
+        }
+        board_parent = bus->parent;
+        board = of_getintprop_default(board_parent, "board#", -1);
+        if (board == -1) {
+                printk(KERN_ERR "%s: Error, lacks board# property.\n",
+                        board_parent->full_name);
+                goto err_out;
+        }
+
+        sbusl = pil_to_sbus[real_irq];
+        if (sbusl)
+                pil = sun4d_encode_irq(board, sbusl, slot);
+        else
+                pil = real_irq;
+
+        irq = _sun4d_build_device_irq(real_irq, pil, board);
+err_out:
+        return irq;
+}
+
+unsigned int sun4d_build_timer_irq(unsigned int board, unsigned int real_irq)
+{
+        return _sun4d_build_device_irq(real_irq, real_irq, board);
+}
+
+
 static void __init sun4d_fixup_trap_table(void)
 {
 #ifdef CONFIG_SMP
         unsigned long flags;
-        extern unsigned long lvl14_save[4];
         struct tt_entry *trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (14 - 1)];
-        extern unsigned int real_irq_entry[], smp4d_ticker[];
-        extern unsigned int patchme_maybe_smp_msg[];
 
         /* Adjust so that we jump directly to smp4d_ticker */
         lvl14_save[2] += smp4d_ticker - real_irq_entry;
@@ -493,8 +427,10 @@ static void __init sun4d_init_timers(irq_handler_t counter_fn)
 {
         struct device_node *dp;
         struct resource res;
+        unsigned int irq;
         const u32 *reg;
         int err;
+        int board;
 
         dp = of_find_node_by_name(NULL, "cpu-unit");
         if (!dp) {
@@ -507,12 +443,19 @@ static void __init sun4d_init_timers(irq_handler_t counter_fn)
          * bootbus.
          */
         reg = of_get_property(dp, "reg", NULL);
-        of_node_put(dp);
         if (!reg) {
                 prom_printf("sun4d_init_timers: No reg property\n");
                 prom_halt();
         }
 
+        board = of_getintprop_default(dp, "board#", -1);
+        if (board == -1) {
+                prom_printf("sun4d_init_timers: No board# property on cpu-unit\n");
+                prom_halt();
+        }
+
+        of_node_put(dp);
+
         res.start = reg[1];
         res.end = reg[2] - 1;
         res.flags = reg[0] & 0xff;
@@ -527,11 +470,11 @@ static void __init sun4d_init_timers(irq_handler_t counter_fn)
 
         master_l10_counter = &sun4d_timers->l10_cur_count;
 
-        err = request_irq(TIMER_IRQ, counter_fn,
-                          (IRQF_DISABLED | SA_STATIC_ALLOC),
-                          "timer", NULL);
+        irq = sun4d_build_timer_irq(board, SUN4D_TIMER_IRQ);
+        err = request_irq(irq, counter_fn, IRQF_TIMER, "timer", NULL);
         if (err) {
-                prom_printf("sun4d_init_timers: request_irq() failed with %d\n", err);
+                prom_printf("sun4d_init_timers: request_irq() failed with %d\n",
+                             err);
                 prom_halt();
         }
         sun4d_load_profile_irqs();
@@ -541,32 +484,22 @@ static void __init sun4d_init_timers(irq_handler_t counter_fn)
 void __init sun4d_init_sbi_irq(void)
 {
         struct device_node *dp;
-        int target_cpu = 0;
+        int target_cpu;
 
-#ifdef CONFIG_SMP
         target_cpu = boot_cpu_id;
-#endif
-
-        nsbi = 0;
-        for_each_node_by_name(dp, "sbi")
-                nsbi++;
-        sbus_actions = kzalloc (nsbi * 8 * 4 * sizeof(struct sbus_action), GFP_ATOMIC);
-        if (!sbus_actions) {
-                prom_printf("SUN4D: Cannot allocate sbus_actions, halting.\n");
-                prom_halt();
-        }
         for_each_node_by_name(dp, "sbi") {
                 int devid = of_getintprop_default(dp, "device-id", 0);
                 int board = of_getintprop_default(dp, "board#", 0);
                 unsigned int mask;
 
                 set_sbi_tid(devid, target_cpu << 3);
-                sbus_tid[board] = target_cpu;
+                board_to_cpu[board] = target_cpu;
 
                 /* Get rid of pending irqs from PROM */
                 mask = acquire_sbi(devid, 0xffffffff);
                 if (mask) {
-                        printk ("Clearing pending IRQs %08x on SBI %d\n", mask, board);
+                        printk(KERN_ERR "Clearing pending IRQs %08x on SBI %d\n",
+                               mask, board);
                         release_sbi(devid, mask);
                 }
         }
@@ -576,11 +509,12 @@ void __init sun4d_init_IRQ(void)
 {
         local_irq_disable();
 
-        BTFIXUPSET_CALL(enable_irq, sun4d_enable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_irq, sun4d_disable_irq, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(clear_clock_irq, sun4d_clear_clock_irq, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(load_profile_irq, sun4d_load_profile_irq, BTFIXUPCALL_NORM);
-        sparc_init_timers = sun4d_init_timers;
+
+        sparc_irq_config.init_timers      = sun4d_init_timers;
+        sparc_irq_config.build_device_irq = sun4d_build_device_irq;
+
 #ifdef CONFIG_SMP
         BTFIXUPSET_CALL(set_cpu_int, sun4d_set_cpu_int, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(clear_cpu_int, sun4d_clear_ipi, BTFIXUPCALL_NOP);
diff --git a/arch/sparc/kernel/sun4d_smp.c b/arch/sparc/kernel/sun4d_smp.c
index 482f2ab92692..133387980b56 100644
--- a/arch/sparc/kernel/sun4d_smp.c
+++ b/arch/sparc/kernel/sun4d_smp.c
@@ -1,4 +1,4 @@
-/* sun4d_smp.c: Sparc SS1000/SC2000 SMP support.
+/* Sparc SS1000/SC2000 SMP support.
  *
  * Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  *
@@ -6,59 +6,23 @@
  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
  */
 
-#include <asm/head.h>
-
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/threads.h>
-#include <linux/smp.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/delay.h>
 #include <linux/cpu.h>
 
-#include <asm/ptrace.h>
-#include <asm/atomic.h>
-#include <asm/irq_regs.h>
-
-#include <asm/irq.h>
-#include <asm/page.h>
-#include <asm/pgalloc.h>
-#include <asm/pgtable.h>
-#include <asm/oplib.h>
 #include <asm/sbi.h>
+#include <asm/mmu.h>
 #include <asm/tlbflush.h>
 #include <asm/cacheflush.h>
-#include <asm/cpudata.h>
 
+#include "kernel.h"
 #include "irq.h"
-#define IRQ_CROSS_CALL          15
 
-extern ctxd_t *srmmu_ctx_table_phys;
+#define IRQ_CROSS_CALL          15
 
-static volatile int smp_processors_ready = 0;
+static volatile int smp_processors_ready;
 static int smp_highest_cpu;
-extern volatile unsigned long cpu_callin_map[NR_CPUS];
-extern cpuinfo_sparc cpu_data[NR_CPUS];
-extern unsigned char boot_cpu_id;
-extern volatile int smp_process_available;
-
-extern cpumask_t smp_commenced_mask;
-
-extern int __smp4d_processor_id(void);
-
-/* #define SMP_DEBUG */
-
-#ifdef SMP_DEBUG
-#define SMP_PRINTK(x)   printk x
-#else
-#define SMP_PRINTK(x)
-#endif
 
 static inline unsigned long sun4d_swap(volatile unsigned long *ptr, unsigned long val)
 {
@@ -68,9 +32,8 @@ static inline unsigned long sun4d_swap(volatile unsigned long *ptr, unsigned lon
         return val;
 }
 
+static void smp4d_ipi_init(void);
 static void smp_setup_percpu_timer(void);
-extern void cpu_probe(void);
-extern void sun4d_distribute_irqs(void);
 
 static unsigned char cpu_leds[32];
 
@@ -86,9 +49,8 @@ static inline void show_leds(int cpuid)
 void __cpuinit smp4d_callin(void)
 {
         int cpuid = hard_smp4d_processor_id();
-        extern spinlock_t sun4d_imsk_lock;
         unsigned long flags;
-        
+
         /* Show we are alive */
         cpu_leds[cpuid] = 0x6;
         show_leds(cpuid);
@@ -118,15 +80,13 @@ void __cpuinit smp4d_callin(void)
         sun4d_swap((unsigned long *)&cpu_callin_map[cpuid], 1);
         local_flush_cache_all();
         local_flush_tlb_all();
-        
-        cpu_probe();
 
-        while((unsigned long)current_set[cpuid] < PAGE_OFFSET)
+        while ((unsigned long)current_set[cpuid] < PAGE_OFFSET)
                 barrier();
-                
-        while(current_set[cpuid]->cpu != cpuid)
+
+        while (current_set[cpuid]->cpu != cpuid)
                 barrier();
-                
+
         /* Fix idle thread fields. */
         __asm__ __volatile__("ld [%0], %%g6\n\t"
                              : : "r" (&current_set[cpuid])
@@ -134,17 +94,17 @@ void __cpuinit smp4d_callin(void)
 
         cpu_leds[cpuid] = 0x9;
         show_leds(cpuid);
-        
+
         /* Attach to the address space of init_task. */
         atomic_inc(&init_mm.mm_count);
         current->active_mm = &init_mm;
 
         local_flush_cache_all();
         local_flush_tlb_all();
-        
+
         local_irq_enable();     /* We don't allow PIL 14 yet */
-        
-        while (!cpu_isset(cpuid, smp_commenced_mask))
+
+        while (!cpumask_test_cpu(cpuid, &smp_commenced_mask))
                 barrier();
 
         spin_lock_irqsave(&sun4d_imsk_lock, flags);
@@ -154,17 +114,12 @@ void __cpuinit smp4d_callin(void)
 
 }
 
-extern void init_IRQ(void);
-extern void cpu_panic(void);
-
 /*
  *      Cycle through the processors asking the PROM to start each one.
  */
- 
-extern struct linux_prom_registers smp_penguin_ctable;
-
 void __init smp4d_boot_cpus(void)
 {
+        smp4d_ipi_init();
         if (boot_cpu_id)
                 current_set[0] = NULL;
         smp_setup_percpu_timer();
@@ -173,43 +128,42 @@ void __init smp4d_boot_cpus(void)
 
 int __cpuinit smp4d_boot_one_cpu(int i)
 {
-                        extern unsigned long sun4d_cpu_startup;
-                        unsigned long *entry = &sun4d_cpu_startup;
-                        struct task_struct *p;
-                        int timeout;
-                        int cpu_node;
+        unsigned long *entry = &sun4d_cpu_startup;
+        struct task_struct *p;
+        int timeout;
+        int cpu_node;
 
-                        cpu_find_by_instance(i, &cpu_node,NULL);
-                        /* Cook up an idler for this guy. */
-                        p = fork_idle(i);
-                        current_set[i] = task_thread_info(p);
+        cpu_find_by_instance(i, &cpu_node, NULL);
+        /* Cook up an idler for this guy. */
+        p = fork_idle(i);
+        current_set[i] = task_thread_info(p);
+
+        /*
+         * 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 at %p\n", i, entry);
+        local_flush_cache_all();
+        prom_startcpu(cpu_node,
+                      &smp_penguin_ctable, 0, (char *)entry);
+
+        printk(KERN_INFO "prom_startcpu returned :)\n");
+
+        /* wheee... it's going... */
+        for (timeout = 0; timeout < 10000; timeout++) {
+                if (cpu_callin_map[i])
+                        break;
+                udelay(200);
+        }
 
-                        /*
-                         * 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... */
-                        SMP_PRINTK(("Starting CPU %d at %p\n", i, entry));
-                        local_flush_cache_all();
-                        prom_startcpu(cpu_node,
-                                      &smp_penguin_ctable, 0, (char *)entry);
-                                      
-                        SMP_PRINTK(("prom_startcpu returned :)\n"));
-
-                        /* wheee... it's going... */
-                        for(timeout = 0; timeout < 10000; timeout++) {
-                                if(cpu_callin_map[i])
-                                        break;
-                                udelay(200);
-                        }
-                        
         if (!(cpu_callin_map[i])) {
-                printk("Processor %d is stuck.\n", i);
+                printk(KERN_ERR "Processor %d is stuck.\n", i);
                 return -ENODEV;
 
         }
@@ -237,6 +191,80 @@ void __init smp4d_smp_done(void)
         sun4d_distribute_irqs();
 }
 
+/* Memory structure giving interrupt handler information about IPI generated */
+struct sun4d_ipi_work {
+        int single;
+        int msk;
+        int resched;
+};
+
+static DEFINE_PER_CPU_SHARED_ALIGNED(struct sun4d_ipi_work, sun4d_ipi_work);
+
+/* Initialize IPIs on the SUN4D SMP machine */
+static void __init smp4d_ipi_init(void)
+{
+        int cpu;
+        struct sun4d_ipi_work *work;
+
+        printk(KERN_INFO "smp4d: setup IPI at IRQ %d\n", SUN4D_IPI_IRQ);
+
+        for_each_possible_cpu(cpu) {
+                work = &per_cpu(sun4d_ipi_work, cpu);
+                work->single = work->msk = work->resched = 0;
+        }
+}
+
+void sun4d_ipi_interrupt(void)
+{
+        struct sun4d_ipi_work *work = &__get_cpu_var(sun4d_ipi_work);
+
+        if (work->single) {
+                work->single = 0;
+                smp_call_function_single_interrupt();
+        }
+        if (work->msk) {
+                work->msk = 0;
+                smp_call_function_interrupt();
+        }
+        if (work->resched) {
+                work->resched = 0;
+                smp_resched_interrupt();
+        }
+}
+
+static void smp4d_ipi_single(int cpu)
+{
+        struct sun4d_ipi_work *work = &per_cpu(sun4d_ipi_work, cpu);
+
+        /* Mark work */
+        work->single = 1;
+
+        /* Generate IRQ on the CPU */
+        sun4d_send_ipi(cpu, SUN4D_IPI_IRQ);
+}
+
+static void smp4d_ipi_mask_one(int cpu)
+{
+        struct sun4d_ipi_work *work = &per_cpu(sun4d_ipi_work, cpu);
+
+        /* Mark work */
+        work->msk = 1;
+
+        /* Generate IRQ on the CPU */
+        sun4d_send_ipi(cpu, SUN4D_IPI_IRQ);
+}
+
+static void smp4d_ipi_resched(int cpu)
+{
+        struct sun4d_ipi_work *work = &per_cpu(sun4d_ipi_work, cpu);
+
+        /* Mark work */
+        work->resched = 1;
+
+        /* Generate IRQ on the CPU (any IRQ will cause resched) */
+        sun4d_send_ipi(cpu, SUN4D_IPI_IRQ);
+}
+
 static struct smp_funcall {
         smpfunc_t func;
         unsigned long arg1;
@@ -255,14 +283,17 @@ static void smp4d_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
                              unsigned long arg2, unsigned long arg3,
                              unsigned long arg4)
 {
-        if(smp_processors_ready) {
+        if (smp_processors_ready) {
                 register int high = smp_highest_cpu;
                 unsigned long flags;
 
                 spin_lock_irqsave(&cross_call_lock, flags);
 
                 {
-                        /* If you make changes here, make sure gcc generates proper code... */
+                        /*
+                         * 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;
@@ -282,10 +313,10 @@ static void smp4d_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
                 {
                         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)) {
+                        cpumask_clear_cpu(smp_processor_id(), &mask);
+                        cpumask_and(&mask, cpu_online_mask, &mask);
+                        for (i = 0; i <= high; i++) {
+                                if (cpumask_test_cpu(i, &mask)) {
                                         ccall_info.processors_in[i] = 0;
                                         ccall_info.processors_out[i] = 0;
                                         sun4d_send_ipi(i, IRQ_CROSS_CALL);
@@ -298,19 +329,19 @@ static void smp4d_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
 
                         i = 0;
                         do {
-                                if (!cpu_isset(i, mask))
+                                if (!cpumask_test_cpu(i, &mask))
                                         continue;
-                                while(!ccall_info.processors_in[i])
+                                while (!ccall_info.processors_in[i])
                                         barrier();
-                        } while(++i <= high);
+                        } while (++i <= high);
 
                         i = 0;
                         do {
-                                if (!cpu_isset(i, mask))
+                                if (!cpumask_test_cpu(i, &mask))
                                         continue;
-                                while(!ccall_info.processors_out[i])
+                                while (!ccall_info.processors_out[i])
                                         barrier();
-                        } while(++i <= high);
+                        } while (++i <= high);
                 }
 
                 spin_unlock_irqrestore(&cross_call_lock, flags);
@@ -336,7 +367,7 @@ void smp4d_percpu_timer_interrupt(struct pt_regs *regs)
         static char led_mask[] = { 0xe, 0xd, 0xb, 0x7, 0xb, 0xd };
 
         old_regs = set_irq_regs(regs);
-        bw_get_prof_limit(cpu); 
+        bw_get_prof_limit(cpu);
         bw_clear_intr_mask(0, 1);       /* INTR_TABLE[0] & 1 is Profile IRQ */
 
         cpu_tick[cpu]++;
@@ -349,7 +380,7 @@ void smp4d_percpu_timer_interrupt(struct pt_regs *regs)
 
         profile_tick(CPU_PROFILING);
 
-        if(!--prof_counter(cpu)) {
+        if (!--prof_counter(cpu)) {
                 int user = user_mode(regs);
 
                 irq_enter();
@@ -361,8 +392,6 @@ void smp4d_percpu_timer_interrupt(struct pt_regs *regs)
         set_irq_regs(old_regs);
 }
 
-extern unsigned int lvl14_resolution;
-
 static void __cpuinit smp_setup_percpu_timer(void)
 {
         int cpu = hard_smp4d_processor_id();
@@ -374,16 +403,16 @@ static void __cpuinit smp_setup_percpu_timer(void)
 void __init smp4d_blackbox_id(unsigned *addr)
 {
         int rd = *addr & 0x3e000000;
-        
+
         addr[0] = 0xc0800800 | rd;              /* lda [%g0] ASI_M_VIKING_TMP1, reg */
-        addr[1] = 0x01000000;                   /* nop */
-        addr[2] = 0x01000000;                   /* nop */
+        addr[1] = 0x01000000;                   /* nop */
+        addr[2] = 0x01000000;                   /* nop */
 }
 
 void __init smp4d_blackbox_current(unsigned *addr)
 {
         int rd = *addr & 0x3e000000;
-        
+
         addr[0] = 0xc0800800 | rd;              /* lda [%g0] ASI_M_VIKING_TMP1, reg */
         addr[2] = 0x81282002 | rd | (rd >> 11); /* sll reg, 2, reg */
         addr[4] = 0x01000000;                   /* nop */
@@ -392,17 +421,19 @@ void __init smp4d_blackbox_current(unsigned *addr)
 void __init sun4d_init_smp(void)
 {
         int i;
-        extern unsigned int t_nmi[], linux_trap_ipi15_sun4d[], linux_trap_ipi15_sun4m[];
 
         /* Patch ipi15 trap table */
         t_nmi[1] = t_nmi[1] + (linux_trap_ipi15_sun4d - linux_trap_ipi15_sun4m);
-        
+
         /* And set btfixup... */
         BTFIXUPSET_BLACKBOX(hard_smp_processor_id, smp4d_blackbox_id);
         BTFIXUPSET_BLACKBOX(load_current, smp4d_blackbox_current);
         BTFIXUPSET_CALL(smp_cross_call, smp4d_cross_call, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(__hard_smp_processor_id, __smp4d_processor_id, BTFIXUPCALL_NORM);
-        
+        BTFIXUPSET_CALL(smp_ipi_resched, smp4d_ipi_resched, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(smp_ipi_single, smp4d_ipi_single, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(smp_ipi_mask_one, smp4d_ipi_mask_one, BTFIXUPCALL_NORM);
+
         for (i = 0; i < NR_CPUS; i++) {
                 ccall_info.processors_in[i] = 1;
                 ccall_info.processors_out[i] = 1;
diff --git a/arch/sparc/kernel/sun4m_irq.c b/arch/sparc/kernel/sun4m_irq.c
index 7f3b97ff62c1..422c16dad1f6 100644
--- a/arch/sparc/kernel/sun4m_irq.c
+++ b/arch/sparc/kernel/sun4m_irq.c
@@ -1,5 +1,5 @@
-/*  sun4m_irq.c
- *  arch/sparc/kernel/sun4m_irq.c:
+/*
+ * sun4m irq support
  *
  *  djhr: Hacked out of irq.c into a CPU dependent version.
  *
@@ -9,101 +9,44 @@
  *  Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
  */
 
-#include <linux/errno.h>
-#include <linux/linkage.h>
-#include <linux/kernel_stat.h>
-#include <linux/signal.h>
-#include <linux/sched.h>
-#include <linux/ptrace.h>
-#include <linux/smp.h>
-#include <linux/interrupt.h>
-#include <linux/init.h>
-#include <linux/ioport.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-
-#include <asm/ptrace.h>
-#include <asm/processor.h>
-#include <asm/system.h>
-#include <asm/psr.h>
-#include <asm/vaddrs.h>
 #include <asm/timer.h>
-#include <asm/openprom.h>
-#include <asm/oplib.h>
 #include <asm/traps.h>
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
-#include <asm/smp.h>
 #include <asm/irq.h>
 #include <asm/io.h>
 #include <asm/cacheflush.h>
 
 #include "irq.h"
+#include "kernel.h"
 
-struct sun4m_irq_percpu {
-        u32             pending;
-        u32             clear;
-        u32             set;
-};
-
-struct sun4m_irq_global {
-        u32             pending;
-        u32             mask;
-        u32             mask_clear;
-        u32             mask_set;
-        u32             interrupt_target;
-};
-
-/* Code in entry.S needs to get at these register mappings.  */
-struct sun4m_irq_percpu __iomem *sun4m_irq_percpu[SUN4M_NCPUS];
-struct sun4m_irq_global __iomem *sun4m_irq_global;
-
-/* Dave Redman (djhr@tadpole.co.uk)
- * The sun4m interrupt registers.
- */
-#define SUN4M_INT_ENABLE        0x80000000
-#define SUN4M_INT_E14           0x00000080
-#define SUN4M_INT_E10           0x00080000
-
-#define SUN4M_HARD_INT(x)       (0x000000001 << (x))
-#define SUN4M_SOFT_INT(x)       (0x000010000 << (x))
-
-#define SUN4M_INT_MASKALL       0x80000000        /* mask all interrupts */
-#define SUN4M_INT_MODULE_ERR    0x40000000        /* module error */
-#define SUN4M_INT_M2S_WRITE_ERR 0x20000000        /* write buffer error */
-#define SUN4M_INT_ECC_ERR       0x10000000        /* ecc memory error */
-#define SUN4M_INT_VME_ERR       0x08000000        /* vme async error */
-#define SUN4M_INT_FLOPPY        0x00400000        /* floppy disk */
-#define SUN4M_INT_MODULE        0x00200000        /* module interrupt */
-#define SUN4M_INT_VIDEO         0x00100000        /* onboard video */
-#define SUN4M_INT_REALTIME      0x00080000        /* system timer */
-#define SUN4M_INT_SCSI          0x00040000        /* onboard scsi */
-#define SUN4M_INT_AUDIO         0x00020000        /* audio/isdn */
-#define SUN4M_INT_ETHERNET      0x00010000        /* onboard ethernet */
-#define SUN4M_INT_SERIAL        0x00008000        /* serial ports */
-#define SUN4M_INT_KBDMS         0x00004000        /* keyboard/mouse */
-#define SUN4M_INT_SBUSBITS      0x00003F80        /* sbus int bits */
-#define SUN4M_INT_VMEBITS       0x0000007F        /* vme int bits */
-
-#define SUN4M_INT_ERROR         (SUN4M_INT_MODULE_ERR |    \
-                                 SUN4M_INT_M2S_WRITE_ERR | \
-                                 SUN4M_INT_ECC_ERR |       \
-                                 SUN4M_INT_VME_ERR)
-
-#define SUN4M_INT_SBUS(x)       (1 << (x+7))
-#define SUN4M_INT_VME(x)        (1 << (x))
-
-/* Interrupt levels used by OBP */
-#define OBP_INT_LEVEL_SOFT      0x10
-#define OBP_INT_LEVEL_ONBOARD   0x20
-#define OBP_INT_LEVEL_SBUS      0x30
-#define OBP_INT_LEVEL_VME       0x40
-
-/* Interrupt level assignment on sun4m:
+/* Sample sun4m IRQ layout:
+ *
+ * 0x22 - Power
+ * 0x24 - ESP SCSI
+ * 0x26 - Lance ethernet
+ * 0x2b - Floppy
+ * 0x2c - Zilog uart
+ * 0x32 - SBUS level 0
+ * 0x33 - Parallel port, SBUS level 1
+ * 0x35 - SBUS level 2
+ * 0x37 - SBUS level 3
+ * 0x39 - Audio, Graphics card, SBUS level 4
+ * 0x3b - SBUS level 5
+ * 0x3d - SBUS level 6
+ *
+ * Each interrupt source has a mask bit in the interrupt registers.
+ * When the mask bit is set, this blocks interrupt deliver.  So you
+ * clear the bit to enable the interrupt.
+ *
+ * Interrupts numbered less than 0x10 are software triggered interrupts
+ * and unused by Linux.
+ *
+ * Interrupt level assignment on sun4m:
  *
  *      level           source
  * ------------------------------------------------------------
- *        1             softint-1
+ *        1             softint-1
  *        2             softint-2, VME/SBUS level 1
  *        3             softint-3, VME/SBUS level 2
  *        4             softint-4, onboard SCSI
@@ -138,10 +81,10 @@ struct sun4m_irq_global __iomem *sun4m_irq_global;
  * 'intr' property IRQ priority values from ss4, ss5, ss10, ss20, and
  * Tadpole S3 GX systems.
  *
- * esp:         0x24    onboard ESP SCSI
- * le:          0x26    onboard Lance ETHERNET
+ * esp:         0x24    onboard ESP SCSI
+ * le:          0x26    onboard Lance ETHERNET
  * p9100:       0x32    SBUS level 1 P9100 video
- * bpp:         0x33    SBUS level 2 BPP parallel port device
+ * bpp:         0x33    SBUS level 2 BPP parallel port device
  * DBRI:        0x39    SBUS level 5 DBRI ISDN audio
  * SUNW,leo:    0x39    SBUS level 5 LEO video
  * pcmcia:      0x3b    SBUS level 6 PCMCIA controller
@@ -152,8 +95,62 @@ struct sun4m_irq_global __iomem *sun4m_irq_global;
  * power:       0x22    onboard power device (XXX unknown mask bit XXX)
  */
 
-static unsigned long irq_mask[0x50] = {
-        /* SMP */
+
+/* Code in entry.S needs to get at these register mappings.  */
+struct sun4m_irq_percpu __iomem *sun4m_irq_percpu[SUN4M_NCPUS];
+struct sun4m_irq_global __iomem *sun4m_irq_global;
+
+struct sun4m_handler_data {
+        bool    percpu;
+        long    mask;
+};
+
+/* Dave Redman (djhr@tadpole.co.uk)
+ * The sun4m interrupt registers.
+ */
+#define SUN4M_INT_ENABLE        0x80000000
+#define SUN4M_INT_E14           0x00000080
+#define SUN4M_INT_E10           0x00080000
+
+#define SUN4M_HARD_INT(x)       (0x000000001 << (x))
+#define SUN4M_SOFT_INT(x)       (0x000010000 << (x))
+
+#define SUN4M_INT_MASKALL       0x80000000        /* mask all interrupts */
+#define SUN4M_INT_MODULE_ERR    0x40000000        /* module error */
+#define SUN4M_INT_M2S_WRITE_ERR 0x20000000        /* write buffer error */
+#define SUN4M_INT_ECC_ERR       0x10000000        /* ecc memory error */
+#define SUN4M_INT_VME_ERR       0x08000000        /* vme async error */
+#define SUN4M_INT_FLOPPY        0x00400000        /* floppy disk */
+#define SUN4M_INT_MODULE        0x00200000        /* module interrupt */
+#define SUN4M_INT_VIDEO         0x00100000        /* onboard video */
+#define SUN4M_INT_REALTIME      0x00080000        /* system timer */
+#define SUN4M_INT_SCSI          0x00040000        /* onboard scsi */
+#define SUN4M_INT_AUDIO         0x00020000        /* audio/isdn */
+#define SUN4M_INT_ETHERNET      0x00010000        /* onboard ethernet */
+#define SUN4M_INT_SERIAL        0x00008000        /* serial ports */
+#define SUN4M_INT_KBDMS         0x00004000        /* keyboard/mouse */
+#define SUN4M_INT_SBUSBITS      0x00003F80        /* sbus int bits */
+#define SUN4M_INT_VMEBITS       0x0000007F        /* vme int bits */
+
+#define SUN4M_INT_ERROR         (SUN4M_INT_MODULE_ERR |    \
+                                 SUN4M_INT_M2S_WRITE_ERR | \
+                                 SUN4M_INT_ECC_ERR |       \
+                                 SUN4M_INT_VME_ERR)
+
+#define SUN4M_INT_SBUS(x)       (1 << (x+7))
+#define SUN4M_INT_VME(x)        (1 << (x))
+
+/* Interrupt levels used by OBP */
+#define OBP_INT_LEVEL_SOFT      0x10
+#define OBP_INT_LEVEL_ONBOARD   0x20
+#define OBP_INT_LEVEL_SBUS      0x30
+#define OBP_INT_LEVEL_VME       0x40
+
+#define SUN4M_TIMER_IRQ         (OBP_INT_LEVEL_ONBOARD | 10)
+#define SUN4M_PROFILE_IRQ       (OBP_INT_LEVEL_ONBOARD | 14)
+
+static unsigned long sun4m_imask[0x50] = {
+        /* 0x00 - SMP */
         0,  SUN4M_SOFT_INT(1),
         SUN4M_SOFT_INT(2),  SUN4M_SOFT_INT(3),
         SUN4M_SOFT_INT(4),  SUN4M_SOFT_INT(5),
@@ -162,7 +159,7 @@ static unsigned long irq_mask[0x50] = {
         SUN4M_SOFT_INT(10), SUN4M_SOFT_INT(11),
         SUN4M_SOFT_INT(12), SUN4M_SOFT_INT(13),
         SUN4M_SOFT_INT(14), SUN4M_SOFT_INT(15),
-        /* soft */
+        /* 0x10 - soft */
         0,  SUN4M_SOFT_INT(1),
         SUN4M_SOFT_INT(2),  SUN4M_SOFT_INT(3),
         SUN4M_SOFT_INT(4),  SUN4M_SOFT_INT(5),
@@ -171,122 +168,129 @@ static unsigned long irq_mask[0x50] = {
         SUN4M_SOFT_INT(10), SUN4M_SOFT_INT(11),
         SUN4M_SOFT_INT(12), SUN4M_SOFT_INT(13),
         SUN4M_SOFT_INT(14), SUN4M_SOFT_INT(15),
-        /* onboard */
+        /* 0x20 - onboard */
         0, 0, 0, 0,
         SUN4M_INT_SCSI,  0, SUN4M_INT_ETHERNET, 0,
         SUN4M_INT_VIDEO, SUN4M_INT_MODULE,
         SUN4M_INT_REALTIME, SUN4M_INT_FLOPPY,
         (SUN4M_INT_SERIAL | SUN4M_INT_KBDMS),
-        SUN4M_INT_AUDIO, 0, SUN4M_INT_MODULE_ERR,
-        /* sbus */
+        SUN4M_INT_AUDIO, SUN4M_INT_E14, SUN4M_INT_MODULE_ERR,
+        /* 0x30 - sbus */
         0, 0, SUN4M_INT_SBUS(0), SUN4M_INT_SBUS(1),
         0, SUN4M_INT_SBUS(2), 0, SUN4M_INT_SBUS(3),
         0, SUN4M_INT_SBUS(4), 0, SUN4M_INT_SBUS(5),
         0, SUN4M_INT_SBUS(6), 0, 0,
-        /* vme */
+        /* 0x40 - vme */
         0, 0, SUN4M_INT_VME(0), SUN4M_INT_VME(1),
         0, SUN4M_INT_VME(2), 0, SUN4M_INT_VME(3),
         0, SUN4M_INT_VME(4), 0, SUN4M_INT_VME(5),
         0, SUN4M_INT_VME(6), 0, 0
 };
 
-static unsigned long sun4m_get_irqmask(unsigned int irq)
-{
-        unsigned long mask;
-    
-        if (irq < 0x50)
-                mask = irq_mask[irq];
-        else
-                mask = 0;
-
-        if (!mask)
-                printk(KERN_ERR "sun4m_get_irqmask: IRQ%d has no valid mask!\n",
-                       irq);
-
-        return mask;
-}
-
-static void sun4m_disable_irq(unsigned int irq_nr)
+static void sun4m_mask_irq(struct irq_data *data)
 {
-        unsigned long mask, flags;
+        struct sun4m_handler_data *handler_data = data->handler_data;
         int cpu = smp_processor_id();
 
-        mask = sun4m_get_irqmask(irq_nr);
-        local_irq_save(flags);
-        if (irq_nr > 15)
-                sbus_writel(mask, &sun4m_irq_global->mask_set);
-        else
-                sbus_writel(mask, &sun4m_irq_percpu[cpu]->set);
-        local_irq_restore(flags);    
+        if (handler_data->mask) {
+                unsigned long flags;
+
+                local_irq_save(flags);
+                if (handler_data->percpu) {
+                        sbus_writel(handler_data->mask, &sun4m_irq_percpu[cpu]->set);
+                } else {
+                        sbus_writel(handler_data->mask, &sun4m_irq_global->mask_set);
+                }
+                local_irq_restore(flags);
+        }
 }
 
-static void sun4m_enable_irq(unsigned int irq_nr)
+static void sun4m_unmask_irq(struct irq_data *data)
 {
-        unsigned long mask, flags;
+        struct sun4m_handler_data *handler_data = data->handler_data;
         int cpu = smp_processor_id();
 
-        /* Dreadful floppy hack. When we use 0x2b instead of
-         * 0x0b the system blows (it starts to whistle!).
-         * So we continue to use 0x0b. Fixme ASAP. --P3
-         */
-        if (irq_nr != 0x0b) {
-                mask = sun4m_get_irqmask(irq_nr);
-                local_irq_save(flags);
-                if (irq_nr > 15)
-                        sbus_writel(mask, &sun4m_irq_global->mask_clear);
-                else
-                        sbus_writel(mask, &sun4m_irq_percpu[cpu]->clear);
-                local_irq_restore(flags);    
-        } else {
+        if (handler_data->mask) {
+                unsigned long flags;
+
                 local_irq_save(flags);
-                sbus_writel(SUN4M_INT_FLOPPY, &sun4m_irq_global->mask_clear);
+                if (handler_data->percpu) {
+                        sbus_writel(handler_data->mask, &sun4m_irq_percpu[cpu]->clear);
+                } else {
+                        sbus_writel(handler_data->mask, &sun4m_irq_global->mask_clear);
+                }
                 local_irq_restore(flags);
         }
 }
 
-static unsigned long cpu_pil_to_imask[16] = {
-/*0*/   0x00000000,
-/*1*/   0x00000000,
-/*2*/   SUN4M_INT_SBUS(0) | SUN4M_INT_VME(0),
-/*3*/   SUN4M_INT_SBUS(1) | SUN4M_INT_VME(1),
-/*4*/   SUN4M_INT_SCSI,
-/*5*/   SUN4M_INT_SBUS(2) | SUN4M_INT_VME(2),
-/*6*/   SUN4M_INT_ETHERNET,
-/*7*/   SUN4M_INT_SBUS(3) | SUN4M_INT_VME(3),
-/*8*/   SUN4M_INT_VIDEO,
-/*9*/   SUN4M_INT_SBUS(4) | SUN4M_INT_VME(4) | SUN4M_INT_MODULE_ERR,
-/*10*/  SUN4M_INT_REALTIME,
-/*11*/  SUN4M_INT_SBUS(5) | SUN4M_INT_VME(5) | SUN4M_INT_FLOPPY,
-/*12*/  SUN4M_INT_SERIAL  | SUN4M_INT_KBDMS,
-/*13*/  SUN4M_INT_SBUS(6) | SUN4M_INT_VME(6) | SUN4M_INT_AUDIO,
-/*14*/  SUN4M_INT_E14,
-/*15*/  SUN4M_INT_ERROR
-};
+static unsigned int sun4m_startup_irq(struct irq_data *data)
+{
+        irq_link(data->irq);
+        sun4m_unmask_irq(data);
+        return 0;
+}
 
-/* We assume the caller has disabled local interrupts when these are called,
- * or else very bizarre behavior will result.
- */
-static void sun4m_disable_pil_irq(unsigned int pil)
+static void sun4m_shutdown_irq(struct irq_data *data)
 {
-        sbus_writel(cpu_pil_to_imask[pil], &sun4m_irq_global->mask_set);
+        sun4m_mask_irq(data);
+        irq_unlink(data->irq);
 }
 
-static void sun4m_enable_pil_irq(unsigned int pil)
+static struct irq_chip sun4m_irq = {
+        .name           = "sun4m",
+        .irq_startup    = sun4m_startup_irq,
+        .irq_shutdown   = sun4m_shutdown_irq,
+        .irq_mask       = sun4m_mask_irq,
+        .irq_unmask     = sun4m_unmask_irq,
+};
+
+
+static unsigned int sun4m_build_device_irq(struct platform_device *op,
+                                           unsigned int real_irq)
 {
-        sbus_writel(cpu_pil_to_imask[pil], &sun4m_irq_global->mask_clear);
+        struct sun4m_handler_data *handler_data;
+        unsigned int irq;
+        unsigned int pil;
+
+        if (real_irq >= OBP_INT_LEVEL_VME) {
+                prom_printf("Bogus sun4m IRQ %u\n", real_irq);
+                prom_halt();
+        }
+        pil = (real_irq & 0xf);
+        irq = irq_alloc(real_irq, pil);
+
+        if (irq == 0)
+                goto out;
+
+        handler_data = irq_get_handler_data(irq);
+        if (unlikely(handler_data))
+                goto out;
+
+        handler_data = kzalloc(sizeof(struct sun4m_handler_data), GFP_ATOMIC);
+        if (unlikely(!handler_data)) {
+                prom_printf("IRQ: kzalloc(sun4m_handler_data) failed.\n");
+                prom_halt();
+        }
+
+        handler_data->mask = sun4m_imask[real_irq];
+        handler_data->percpu = real_irq < OBP_INT_LEVEL_ONBOARD;
+        irq_set_chip_and_handler_name(irq, &sun4m_irq,
+                                      handle_level_irq, "level");
+        irq_set_handler_data(irq, handler_data);
+
+out:
+        return irq;
 }
 
 #ifdef CONFIG_SMP
 static void sun4m_send_ipi(int cpu, int level)
 {
-        unsigned long mask = sun4m_get_irqmask(level);
-        sbus_writel(mask, &sun4m_irq_percpu[cpu]->set);
+        sbus_writel(SUN4M_SOFT_INT(level), &sun4m_irq_percpu[cpu]->set);
 }
 
 static void sun4m_clear_ipi(int cpu, int level)
 {
-        unsigned long mask = sun4m_get_irqmask(level);
-        sbus_writel(mask, &sun4m_irq_percpu[cpu]->clear);
+        sbus_writel(SUN4M_SOFT_INT(level), &sun4m_irq_percpu[cpu]->clear);
 }
 
 static void sun4m_set_udt(int cpu)
@@ -314,7 +318,6 @@ struct sun4m_timer_global {
 
 static struct sun4m_timer_global __iomem *timers_global;
 
-#define TIMER_IRQ       (OBP_INT_LEVEL_ONBOARD | 10)
 
 unsigned int lvl14_resolution = (((1000000/HZ) + 1) << 10);
 
@@ -350,7 +353,15 @@ void sun4m_nmi(struct pt_regs *regs)
         prom_halt();
 }
 
-/* Exported for sun4m_smp.c */
+void sun4m_unmask_profile_irq(void)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        sbus_writel(sun4m_imask[SUN4M_PROFILE_IRQ], &sun4m_irq_global->mask_clear);
+        local_irq_restore(flags);
+}
+
 void sun4m_clear_profile_irq(int cpu)
 {
         sbus_readl(&timers_percpu[cpu]->l14_limit);
@@ -365,6 +376,7 @@ static void __init sun4m_init_timers(irq_handler_t counter_fn)
 {
         struct device_node *dp = of_find_node_by_name(NULL, "counter");
         int i, err, len, num_cpu_timers;
+        unsigned int irq;
         const u32 *addr;
 
         if (!dp) {
@@ -391,8 +403,9 @@ static void __init sun4m_init_timers(irq_handler_t counter_fn)
 
         master_l10_counter = &timers_global->l10_count;
 
-        err = request_irq(TIMER_IRQ, counter_fn,
-                          (IRQF_DISABLED | SA_STATIC_ALLOC), "timer", NULL);
+        irq = sun4m_build_device_irq(NULL, SUN4M_TIMER_IRQ);
+
+        err = request_irq(irq, counter_fn, IRQF_TIMER, "timer", NULL);
         if (err) {
                 printk(KERN_ERR "sun4m_init_timers: Register IRQ error %d.\n",
                         err);
@@ -407,7 +420,6 @@ static void __init sun4m_init_timers(irq_handler_t counter_fn)
 #ifdef CONFIG_SMP
         {
                 unsigned long flags;
-                extern unsigned long lvl14_save[4];
                 struct tt_entry *trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (14 - 1)];
 
                 /* For SMP we use the level 14 ticker, however the bootup code
@@ -460,13 +472,12 @@ void __init sun4m_init_IRQ(void)
         if (num_cpu_iregs == 4)
                 sbus_writel(0, &sun4m_irq_global->interrupt_target);
 
-        BTFIXUPSET_CALL(enable_irq, sun4m_enable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_irq, sun4m_disable_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(enable_pil_irq, sun4m_enable_pil_irq, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(disable_pil_irq, sun4m_disable_pil_irq, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(clear_clock_irq, sun4m_clear_clock_irq, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(load_profile_irq, sun4m_load_profile_irq, BTFIXUPCALL_NORM);
-        sparc_init_timers = sun4m_init_timers;
+
+        sparc_irq_config.init_timers = sun4m_init_timers;
+        sparc_irq_config.build_device_irq = sun4m_build_device_irq;
+
 #ifdef CONFIG_SMP
         BTFIXUPSET_CALL(set_cpu_int, sun4m_send_ipi, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(clear_cpu_int, sun4m_clear_ipi, BTFIXUPCALL_NORM);
diff --git a/arch/sparc/kernel/sun4m_smp.c b/arch/sparc/kernel/sun4m_smp.c
index 762d6eedd944..594768686525 100644
--- a/arch/sparc/kernel/sun4m_smp.c
+++ b/arch/sparc/kernel/sun4m_smp.c
@@ -1,59 +1,25 @@
-/* sun4m_smp.c: Sparc SUN4M SMP support.
+/*
+ *  sun4m SMP support.
  *
  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
  */
 
-#include <asm/head.h>
-
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/threads.h>
-#include <linux/smp.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/delay.h>
 #include <linux/cpu.h>
 
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
-#include <asm/irq_regs.h>
-
-#include <asm/ptrace.h>
-#include <asm/atomic.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 "irq.h"
+#include "kernel.h"
 
+#define IRQ_IPI_SINGLE          12
+#define IRQ_IPI_MASK            13
+#define IRQ_IPI_RESCHED         14
 #define IRQ_CROSS_CALL          15
 
-extern ctxd_t *srmmu_ctx_table_phys;
-
-extern volatile unsigned long cpu_callin_map[NR_CPUS];
-extern unsigned char boot_cpu_id;
-
-extern cpumask_t smp_commenced_mask;
-
-extern int __smp4m_processor_id(void);
-
-/*#define SMP_DEBUG*/
-
-#ifdef SMP_DEBUG
-#define SMP_PRINTK(x)   printk x
-#else
-#define SMP_PRINTK(x)
-#endif
-
 static inline unsigned long
 swap_ulong(volatile unsigned long *ptr, unsigned long val)
 {
@@ -63,8 +29,8 @@ swap_ulong(volatile unsigned long *ptr, unsigned long val)
         return val;
 }
 
+static void smp4m_ipi_init(void);
 static void smp_setup_percpu_timer(void);
-extern void cpu_probe(void);
 
 void __cpuinit smp4m_callin(void)
 {
@@ -96,8 +62,6 @@ void __cpuinit smp4m_callin(void)
         /* XXX: What's up with all the flushes? */
         local_flush_cache_all();
         local_flush_tlb_all();
-        
-        cpu_probe();
 
         /* Fix idle thread fields. */
         __asm__ __volatile__("ld [%0], %%g6\n\t"
@@ -108,7 +72,7 @@ void __cpuinit smp4m_callin(void)
         atomic_inc(&init_mm.mm_count);
         current->active_mm = &init_mm;
 
-        while (!cpu_isset(cpuid, smp_commenced_mask))
+        while (!cpumask_test_cpu(cpuid, &smp_commenced_mask))
                 mb();
 
         local_irq_enable();
@@ -119,18 +83,15 @@ void __cpuinit smp4m_callin(void)
 /*
  *      Cycle through the processors asking the PROM to start each one.
  */
- 
-extern struct linux_prom_registers smp_penguin_ctable;
-
 void __init smp4m_boot_cpus(void)
 {
+        smp4m_ipi_init();
         smp_setup_percpu_timer();
         local_flush_cache_all();
 }
 
 int __cpuinit smp4m_boot_one_cpu(int i)
 {
-        extern unsigned long sun4m_cpu_startup;
         unsigned long *entry = &sun4m_cpu_startup;
         struct task_struct *p;
         int timeout;
@@ -142,7 +103,7 @@ int __cpuinit smp4m_boot_one_cpu(int i)
         p = fork_idle(i);
         current_set[i] = task_thread_info(p);
         /* See trampoline.S for details... */
-        entry += ((i-1) * 3);
+        entry += ((i - 1) * 3);
 
         /*
          * Initialize the contexts table
@@ -154,20 +115,19 @@ int __cpuinit smp4m_boot_one_cpu(int i)
         smp_penguin_ctable.reg_size = 0;
 
         /* whirrr, whirrr, whirrrrrrrrr... */
-        printk("Starting CPU %d at %p\n", i, entry);
+        printk(KERN_INFO "Starting CPU %d at %p\n", i, entry);
         local_flush_cache_all();
-        prom_startcpu(cpu_node,
-                      &smp_penguin_ctable, 0, (char *)entry);
+        prom_startcpu(cpu_node, &smp_penguin_ctable, 0, (char *)entry);
 
         /* wheee... it's going... */
-        for(timeout = 0; timeout < 10000; timeout++) {
-                if(cpu_callin_map[i])
+        for (timeout = 0; timeout < 10000; timeout++) {
+                if (cpu_callin_map[i])
                         break;
                 udelay(200);
         }
 
         if (!(cpu_callin_map[i])) {
-                printk("Processor %d is stuck.\n", i);
+                printk(KERN_ERR "Processor %d is stuck.\n", i);
                 return -ENODEV;
         }
 
@@ -193,17 +153,25 @@ void __init smp4m_smp_done(void)
         /* Ok, they are spinning and ready to go. */
 }
 
-/* At each hardware IRQ, we get this called to forward IRQ reception
- * to the next processor.  The caller must disable the IRQ level being
- * serviced globally so that there are no double interrupts received.
- *
- * XXX See sparc64 irq.c.
- */
-void smp4m_irq_rotate(int cpu)
+
+/* Initialize IPIs on the SUN4M SMP machine */
+static void __init smp4m_ipi_init(void)
 {
-        int next = cpu_data(cpu).next;
-        if (next != cpu)
-                set_irq_udt(next);
+}
+
+static void smp4m_ipi_resched(int cpu)
+{
+        set_cpu_int(cpu, IRQ_IPI_RESCHED);
+}
+
+static void smp4m_ipi_single(int cpu)
+{
+        set_cpu_int(cpu, IRQ_IPI_SINGLE);
+}
+
+static void smp4m_ipi_mask_one(int cpu)
+{
+        set_cpu_int(cpu, IRQ_IPI_MASK);
 }
 
 static struct smp_funcall {
@@ -241,10 +209,10 @@ static void smp4m_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
                 {
                         register int i;
 
-                        cpu_clear(smp_processor_id(), mask);
-                        cpus_and(mask, cpu_online_map, mask);
-                        for(i = 0; i < ncpus; i++) {
-                                if (cpu_isset(i, mask)) {
+                        cpumask_clear_cpu(smp_processor_id(), &mask);
+                        cpumask_and(&mask, cpu_online_mask, &mask);
+                        for (i = 0; i < ncpus; i++) {
+                                if (cpumask_test_cpu(i, &mask)) {
                                         ccall_info.processors_in[i] = 0;
                                         ccall_info.processors_out[i] = 0;
                                         set_cpu_int(i, IRQ_CROSS_CALL);
@@ -260,21 +228,20 @@ static void smp4m_cross_call(smpfunc_t func, cpumask_t mask, unsigned long arg1,
 
                         i = 0;
                         do {
-                                if (!cpu_isset(i, mask))
+                                if (!cpumask_test_cpu(i, &mask))
                                         continue;
-                                while(!ccall_info.processors_in[i])
+                                while (!ccall_info.processors_in[i])
                                         barrier();
-                        } while(++i < ncpus);
+                        } while (++i < ncpus);
 
                         i = 0;
                         do {
-                                if (!cpu_isset(i, mask))
+                                if (!cpumask_test_cpu(i, &mask))
                                         continue;
-                                while(!ccall_info.processors_out[i])
+                                while (!ccall_info.processors_out[i])
                                         barrier();
-                        } while(++i < ncpus);
+                        } while (++i < ncpus);
                 }
-
                 spin_unlock_irqrestore(&cross_call_lock, flags);
 }
 
@@ -289,8 +256,6 @@ void smp4m_cross_call_irq(void)
         ccall_info.processors_out[i] = 1;
 }
 
-extern void sun4m_clear_profile_irq(int cpu);
-
 void smp4m_percpu_timer_interrupt(struct pt_regs *regs)
 {
         struct pt_regs *old_regs;
@@ -302,7 +267,7 @@ void smp4m_percpu_timer_interrupt(struct pt_regs *regs)
 
         profile_tick(CPU_PROFILING);
 
-        if(!--prof_counter(cpu)) {
+        if (!--prof_counter(cpu)) {
                 int user = user_mode(regs);
 
                 irq_enter();
@@ -314,8 +279,6 @@ void smp4m_percpu_timer_interrupt(struct pt_regs *regs)
         set_irq_regs(old_regs);
 }
 
-extern unsigned int lvl14_resolution;
-
 static void __cpuinit smp_setup_percpu_timer(void)
 {
         int cpu = smp_processor_id();
@@ -323,17 +286,17 @@ static void __cpuinit smp_setup_percpu_timer(void)
         prof_counter(cpu) = prof_multiplier(cpu) = 1;
         load_profile_irq(cpu, lvl14_resolution);
 
-        if(cpu == boot_cpu_id)
-                enable_pil_irq(14);
+        if (cpu == boot_cpu_id)
+                sun4m_unmask_profile_irq();
 }
 
 static void __init smp4m_blackbox_id(unsigned *addr)
 {
         int rd = *addr & 0x3e000000;
         int rs1 = rd >> 11;
-        
+
         addr[0] = 0x81580000 | rd;              /* rd %tbr, reg */
-        addr[1] = 0x8130200c | rd | rs1;        /* srl reg, 0xc, reg */
+        addr[1] = 0x8130200c | rd | rs1;        /* srl reg, 0xc, reg */
         addr[2] = 0x80082003 | rd | rs1;        /* and reg, 3, reg */
 }
 
@@ -341,9 +304,9 @@ static void __init smp4m_blackbox_current(unsigned *addr)
 {
         int rd = *addr & 0x3e000000;
         int rs1 = rd >> 11;
-        
+
         addr[0] = 0x81580000 | rd;              /* rd %tbr, reg */
-        addr[2] = 0x8130200a | rd | rs1;        /* srl reg, 0xa, reg */
+        addr[2] = 0x8130200a | rd | rs1;        /* srl reg, 0xa, reg */
         addr[4] = 0x8008200c | rd | rs1;        /* and reg, 0xc, reg */
 }
 
@@ -353,4 +316,7 @@ void __init sun4m_init_smp(void)
         BTFIXUPSET_BLACKBOX(load_current, smp4m_blackbox_current);
         BTFIXUPSET_CALL(smp_cross_call, smp4m_cross_call, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(__hard_smp_processor_id, __smp4m_processor_id, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(smp_ipi_resched, smp4m_ipi_resched, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(smp_ipi_single, smp4m_ipi_single, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(smp_ipi_mask_one, smp4m_ipi_mask_one, BTFIXUPCALL_NORM);
 }
diff --git a/arch/sparc/kernel/sys_sparc32.c b/arch/sparc/kernel/sys_sparc32.c
index e6375a750d9a..170cd8e8eb2a 100644
--- a/arch/sparc/kernel/sys_sparc32.c
+++ b/arch/sparc/kernel/sys_sparc32.c
@@ -17,7 +17,6 @@
 #include <linux/resource.h>
 #include <linux/times.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/sem.h>
 #include <linux/msg.h>
 #include <linux/shm.h>
@@ -110,7 +109,7 @@ asmlinkage long compat_sys_ipc(u32 call, u32 first, u32 second, u32 third, compa
 
         default:
                 return -ENOSYS;
-        };
+        }
 
         return -ENOSYS;
 }
diff --git a/arch/sparc/kernel/sys_sparc_32.c b/arch/sparc/kernel/sys_sparc_32.c
index 675c9e11ada5..42b282fa6112 100644
--- a/arch/sparc/kernel/sys_sparc_32.c
+++ b/arch/sparc/kernel/sys_sparc_32.c
@@ -19,7 +19,6 @@
 #include <linux/mman.h>
 #include <linux/utsname.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/ipc.h>
 
 #include <asm/uaccess.h>
diff --git a/arch/sparc/kernel/sys_sparc_64.c b/arch/sparc/kernel/sys_sparc_64.c
index f836f4e93afe..908b47a5ee24 100644
--- a/arch/sparc/kernel/sys_sparc_64.c
+++ b/arch/sparc/kernel/sys_sparc_64.c
@@ -360,20 +360,25 @@ unsigned long get_fb_unmapped_area(struct file *filp, unsigned long orig_addr, u
 }
 EXPORT_SYMBOL(get_fb_unmapped_area);
 
-/* Essentially the same as PowerPC... */
-void arch_pick_mmap_layout(struct mm_struct *mm)
+/* Essentially the same as PowerPC.  */
+static unsigned long mmap_rnd(void)
 {
-        unsigned long random_factor = 0UL;
-        unsigned long gap;
+        unsigned long rnd = 0UL;
 
         if (current->flags & PF_RANDOMIZE) {
-                random_factor = get_random_int();
+                unsigned long val = get_random_int();
                 if (test_thread_flag(TIF_32BIT))
-                        random_factor &= ((1 * 1024 * 1024) - 1);
+                        rnd = (val % (1UL << (22UL-PAGE_SHIFT)));
                 else
-                        random_factor = ((random_factor << PAGE_SHIFT) &
-                                         0xffffffffUL);
+                        rnd = (val % (1UL << (29UL-PAGE_SHIFT)));
         }
+        return (rnd << PAGE_SHIFT) * 2;
+}
+
+void arch_pick_mmap_layout(struct mm_struct *mm)
+{
+        unsigned long random_factor = mmap_rnd();
+        unsigned long gap;
 
         /*
          * Fall back to the standard layout if the personality
@@ -455,7 +460,7 @@ SYSCALL_DEFINE6(sparc_ipc, unsigned int, call, int, first, unsigned long, second
                 default:
                         err = -ENOSYS;
                         goto out;
-                };
+                }
         }
         if (call <= MSGCTL) {
                 switch (call) {
@@ -476,7 +481,7 @@ SYSCALL_DEFINE6(sparc_ipc, unsigned int, call, int, first, unsigned long, second
                 default:
                         err = -ENOSYS;
                         goto out;
-                };
+                }
         }
         if (call <= SHMCTL) {
                 switch (call) {
@@ -502,7 +507,7 @@ SYSCALL_DEFINE6(sparc_ipc, unsigned int, call, int, first, unsigned long, second
                 default:
                         err = -ENOSYS;
                         goto out;
-                };
+                }
         } else {
                 err = -ENOSYS;
         }
diff --git a/arch/sparc/kernel/sysfs.c b/arch/sparc/kernel/sysfs.c
index 1eb8b00aed75..7408201d7efb 100644
--- a/arch/sparc/kernel/sysfs.c
+++ b/arch/sparc/kernel/sysfs.c
@@ -103,9 +103,10 @@ static unsigned long run_on_cpu(unsigned long cpu,
                                 unsigned long (*func)(unsigned long),
                                 unsigned long arg)
 {
-        cpumask_t old_affinity = current->cpus_allowed;
+        cpumask_t old_affinity;
         unsigned long ret;
 
+        cpumask_copy(&old_affinity, tsk_cpus_allowed(current));
         /* should return -EINVAL to userspace */
         if (set_cpus_allowed_ptr(current, cpumask_of(cpu)))
                 return 0;
diff --git a/arch/sparc/kernel/systbls_32.S b/arch/sparc/kernel/systbls_32.S
index ec396e1916b9..6e492d59f6b1 100644
--- a/arch/sparc/kernel/systbls_32.S
+++ b/arch/sparc/kernel/systbls_32.S
@@ -83,5 +83,5 @@ sys_call_table:
 /*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, sys_recvmmsg, sys_fanotify_init
-/*330*/ .long sys_fanotify_mark, sys_prlimit64
-
+/*330*/ .long sys_fanotify_mark, sys_prlimit64, sys_name_to_handle_at, sys_open_by_handle_at, sys_clock_adjtime
+/*335*/ .long sys_syncfs, sys_sendmmsg, sys_setns
diff --git a/arch/sparc/kernel/systbls_64.S b/arch/sparc/kernel/systbls_64.S
index 8cfcaa549580..f566518483b5 100644
--- a/arch/sparc/kernel/systbls_64.S
+++ b/arch/sparc/kernel/systbls_64.S
@@ -84,7 +84,8 @@ sys_call_table32:
         .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, compat_sys_recvmmsg, sys_fanotify_init
-/*330*/ .word sys32_fanotify_mark, sys_prlimit64
+/*330*/ .word sys32_fanotify_mark, sys_prlimit64, sys_name_to_handle_at, compat_sys_open_by_handle_at, compat_sys_clock_adjtime
+        .word sys_syncfs, compat_sys_sendmmsg, sys_setns
 
 #endif /* CONFIG_COMPAT */
 
@@ -160,4 +161,5 @@ sys_call_table:
         .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, sys_recvmmsg, sys_fanotify_init
-/*330*/ .word sys_fanotify_mark, sys_prlimit64
+/*330*/ .word sys_fanotify_mark, sys_prlimit64, sys_name_to_handle_at, sys_open_by_handle_at, sys_clock_adjtime
+        .word sys_syncfs, sys_sendmmsg, sys_setns
diff --git a/arch/sparc/kernel/tadpole.c b/arch/sparc/kernel/tadpole.c
index f476a5f4af6a..9aba8bd5a78b 100644
--- a/arch/sparc/kernel/tadpole.c
+++ b/arch/sparc/kernel/tadpole.c
@@ -100,7 +100,7 @@ static void swift_clockstop(void)
 
 void __init clock_stop_probe(void)
 {
-        unsigned int node, clk_nd;
+        phandle node, clk_nd;
         char name[20];
     
         prom_getstring(prom_root_node, "name", name, sizeof(name));
diff --git a/arch/sparc/kernel/tick14.c b/arch/sparc/kernel/tick14.c
deleted file mode 100644
index 138bbf5f8724..000000000000
--- a/arch/sparc/kernel/tick14.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/* tick14.c
- *
- * Copyright (C) 1996 David Redman (djhr@tadpole.co.uk)
- *
- * This file handles the Sparc specific level14 ticker
- * This is really useful for profiling OBP uses it for keyboard
- * aborts and other stuff.
- */
-#include <linux/kernel.h>
-
-extern unsigned long lvl14_save[5];
-static unsigned long *linux_lvl14 = NULL;
-static unsigned long obp_lvl14[4];
- 
-/*
- * Call with timer IRQ closed.
- * First time we do it with disable_irq, later prom code uses spin_lock_irq().
- */
-void install_linux_ticker(void)
-{
-
-        if (!linux_lvl14)
-                return;
-        linux_lvl14[0] =  lvl14_save[0];
-        linux_lvl14[1] =  lvl14_save[1];
-        linux_lvl14[2] =  lvl14_save[2];
-        linux_lvl14[3] =  lvl14_save[3];
-}
-
-void install_obp_ticker(void)
-{
-
-        if (!linux_lvl14)
-                return;
-        linux_lvl14[0] =  obp_lvl14[0];
-        linux_lvl14[1] =  obp_lvl14[1];
-        linux_lvl14[2] =  obp_lvl14[2];
-        linux_lvl14[3] =  obp_lvl14[3]; 
-}
diff --git a/arch/sparc/kernel/time_32.c b/arch/sparc/kernel/time_32.c
index 9c743b1886ff..1060e0672a4b 100644
--- a/arch/sparc/kernel/time_32.c
+++ b/arch/sparc/kernel/time_32.c
@@ -85,7 +85,7 @@ int update_persistent_clock(struct timespec now)
 
 /*
  * timer_interrupt() needs to keep up the real-time clock,
- * as well as call the "do_timer()" routine every clocktick
+ * as well as call the "xtime_update()" routine every clocktick
  */
 
 #define TICK_SIZE (tick_nsec / 1000)
@@ -96,14 +96,9 @@ static irqreturn_t timer_interrupt(int dummy, void *dev_id)
         profile_tick(CPU_PROFILING);
 #endif
 
-        /* Protect counter clear so that do_gettimeoffset works */
-        write_seqlock(&xtime_lock);
-
         clear_clock_irq();
 
-        do_timer(1);
-
-        write_sequnlock(&xtime_lock);
+        xtime_update(1);
 
 #ifndef CONFIG_SMP
         update_process_times(user_mode(get_irq_regs()));
@@ -142,7 +137,7 @@ static struct platform_device m48t59_rtc = {
         },
 };
 
-static int __devinit clock_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit clock_probe(struct platform_device *op)
 {
         struct device_node *dp = op->dev.of_node;
         const char *model = of_get_property(dp, "model", NULL);
@@ -150,6 +145,10 @@ static int __devinit clock_probe(struct platform_device *op, const struct of_dev
         if (!model)
                 return -ENODEV;
 
+        /* Only the primary RTC has an address property */
+        if (!of_find_property(dp, "address", NULL))
+                return -ENODEV;
+
         m48t59_rtc.resource = &op->resource[0];
         if (!strcmp(model, "mk48t02")) {
                 /* Map the clock register io area read-only */
@@ -169,14 +168,14 @@ static int __devinit clock_probe(struct platform_device *op, const struct of_dev
         return 0;
 }
 
-static struct of_device_id __initdata clock_match[] = {
+static struct of_device_id clock_match[] = {
         {
                 .name = "eeprom",
         },
         {},
 };
 
-static struct of_platform_driver clock_driver = {
+static struct platform_driver clock_driver = {
         .probe          = clock_probe,
         .driver = {
                 .name = "rtc",
@@ -189,7 +188,7 @@ static struct of_platform_driver clock_driver = {
 /* Probe for the mostek real time clock chip. */
 static int __init clock_init(void)
 {
-        return of_register_platform_driver(&clock_driver);
+        return platform_driver_register(&clock_driver);
 }
 /* Must be after subsys_initcall() so that busses are probed.  Must
  * be before device_initcall() because things like the RTC driver
@@ -224,19 +223,15 @@ static void __init sbus_time_init(void)
 
         btfixup();
 
-        sparc_init_timers(timer_interrupt);
+        sparc_irq_config.init_timers(timer_interrupt);
 }
 
 void __init time_init(void)
 {
-#ifdef CONFIG_PCI
-        extern void pci_time_init(void);
-        if (pcic_present()) {
+        if (pcic_present())
                 pci_time_init();
-                return;
-        }
-#endif
-        sbus_time_init();
+        else
+                sbus_time_init();
 }
 
 
diff --git a/arch/sparc/kernel/time_64.c b/arch/sparc/kernel/time_64.c
index 3bc9c9979b92..1db6b18964d2 100644
--- a/arch/sparc/kernel/time_64.c
+++ b/arch/sparc/kernel/time_64.c
@@ -419,7 +419,7 @@ static struct platform_device rtc_cmos_device = {
         .num_resources  = 1,
 };
 
-static int __devinit rtc_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit rtc_probe(struct platform_device *op)
 {
         struct resource *r;
 
@@ -442,7 +442,7 @@ static int __devinit rtc_probe(struct platform_device *op, const struct of_devic
         return platform_device_register(&rtc_cmos_device);
 }
 
-static struct of_device_id __initdata rtc_match[] = {
+static const struct of_device_id rtc_match[] = {
         {
                 .name = "rtc",
                 .compatible = "m5819",
@@ -462,7 +462,7 @@ static struct of_device_id __initdata rtc_match[] = {
         {},
 };
 
-static struct of_platform_driver rtc_driver = {
+static struct platform_driver rtc_driver = {
         .probe          = rtc_probe,
         .driver = {
                 .name = "rtc",
@@ -477,7 +477,7 @@ static struct platform_device rtc_bq4802_device = {
         .num_resources  = 1,
 };
 
-static int __devinit bq4802_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit bq4802_probe(struct platform_device *op)
 {
 
         printk(KERN_INFO "%s: BQ4802 regs at 0x%llx\n",
@@ -487,7 +487,7 @@ static int __devinit bq4802_probe(struct platform_device *op, const struct of_de
         return platform_device_register(&rtc_bq4802_device);
 }
 
-static struct of_device_id __initdata bq4802_match[] = {
+static const struct of_device_id bq4802_match[] = {
         {
                 .name = "rtc",
                 .compatible = "bq4802",
@@ -495,7 +495,7 @@ static struct of_device_id __initdata bq4802_match[] = {
         {},
 };
 
-static struct of_platform_driver bq4802_driver = {
+static struct platform_driver bq4802_driver = {
         .probe          = bq4802_probe,
         .driver = {
                 .name = "bq4802",
@@ -534,7 +534,7 @@ static struct platform_device m48t59_rtc = {
         },
 };
 
-static int __devinit mostek_probe(struct platform_device *op, const struct of_device_id *match)
+static int __devinit mostek_probe(struct platform_device *op)
 {
         struct device_node *dp = op->dev.of_node;
 
@@ -552,14 +552,14 @@ static int __devinit mostek_probe(struct platform_device *op, const struct of_de
         return platform_device_register(&m48t59_rtc);
 }
 
-static struct of_device_id __initdata mostek_match[] = {
+static const struct of_device_id mostek_match[] = {
         {
                 .name = "eeprom",
         },
         {},
 };
 
-static struct of_platform_driver mostek_driver = {
+static struct platform_driver mostek_driver = {
         .probe          = mostek_probe,
         .driver = {
                 .name = "mostek",
@@ -586,9 +586,9 @@ static int __init clock_init(void)
         if (tlb_type == hypervisor)
                 return platform_device_register(&rtc_sun4v_device);
 
-        (void) of_register_platform_driver(&rtc_driver);
-        (void) of_register_platform_driver(&mostek_driver);
-        (void) of_register_platform_driver(&bq4802_driver);
+        (void) platform_driver_register(&rtc_driver);
+        (void) platform_driver_register(&mostek_driver);
+        (void) platform_driver_register(&bq4802_driver);
 
         return 0;
 }
@@ -708,7 +708,7 @@ static void sparc64_timer_setup(enum clock_event_mode mode,
         case CLOCK_EVT_MODE_UNUSED:
                 WARN_ON(1);
                 break;
-        };
+        }
 }
 
 static struct clock_event_device sparc64_clockevent = {
@@ -816,14 +816,12 @@ void __init time_init(void)
                 clocksource_hz2mult(freq, SPARC64_NSEC_PER_CYC_SHIFT);
 
         clocksource_tick.name = tick_ops->name;
-        clocksource_calc_mult_shift(&clocksource_tick, freq, 4);
         clocksource_tick.read = clocksource_tick_read;
 
+        clocksource_register_hz(&clocksource_tick, freq);
         printk("clocksource: mult[%x] shift[%d]\n",
                clocksource_tick.mult, clocksource_tick.shift);
 
-        clocksource_register(&clocksource_tick);
-
         sparc64_clockevent.name = tick_ops->name;
         clockevents_calc_mult_shift(&sparc64_clockevent, freq, 4);
 
diff --git a/arch/sparc/kernel/traps_64.c b/arch/sparc/kernel/traps_64.c
index 42ad2ba85010..0cbdaa41cd1e 100644
--- a/arch/sparc/kernel/traps_64.c
+++ b/arch/sparc/kernel/traps_64.c
@@ -622,7 +622,7 @@ static const char CHAFSR_PERR_msg[] =
 static const char CHAFSR_IERR_msg[] =
         "Internal processor error";
 static const char CHAFSR_ISAP_msg[] =
-        "System request parity error on incoming addresss";
+        "System request parity error on incoming address";
 static const char CHAFSR_UCU_msg[] =
         "Uncorrectable E-cache ECC error for ifetch/data";
 static const char CHAFSR_UCC_msg[] =
@@ -1804,7 +1804,7 @@ static const char *sun4v_err_type_to_str(u32 type)
                 return "warning resumable";
         default:
                 return "unknown";
-        };
+        }
 }
 
 static void sun4v_log_error(struct pt_regs *regs, struct sun4v_error_entry *ent, int cpu, const char *pfx, atomic_t *ocnt)
@@ -2152,7 +2152,7 @@ static void user_instruction_dump(unsigned int __user *pc)
 
 void show_stack(struct task_struct *tsk, unsigned long *_ksp)
 {
-        unsigned long fp, thread_base, ksp;
+        unsigned long fp, ksp;
         struct thread_info *tp;
         int count = 0;
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
@@ -2173,7 +2173,6 @@ void show_stack(struct task_struct *tsk, unsigned long *_ksp)
                 flushw_all();
 
         fp = ksp + STACK_BIAS;
-        thread_base = (unsigned long) tp;
 
         printk("Call Trace:\n");
         do {
diff --git a/arch/sparc/kernel/una_asm_32.S b/arch/sparc/kernel/una_asm_32.S
index 8cc03458eb7e..8f096e84a937 100644
--- a/arch/sparc/kernel/una_asm_32.S
+++ b/arch/sparc/kernel/una_asm_32.S
@@ -24,9 +24,9 @@ retl_efault:
         .globl  __do_int_store
 __do_int_store:
         ld      [%o2], %g1
-        cmp     %1, 2
+        cmp     %o1, 2
         be      2f
-         cmp    %1, 4
+         cmp    %o1, 4
         be      1f
          srl    %g1, 24, %g2
         srl     %g1, 16, %g7
diff --git a/arch/sparc/kernel/una_asm_64.S b/arch/sparc/kernel/una_asm_64.S
index be183fe41443..1c8d33228b2a 100644
--- a/arch/sparc/kernel/una_asm_64.S
+++ b/arch/sparc/kernel/una_asm_64.S
@@ -127,7 +127,7 @@ do_int_load:
         wr      %o5, 0x0, %asi
         retl
          mov    0, %o0
-        .size   __do_int_load, .-__do_int_load
+        .size   do_int_load, .-do_int_load
 
         .section        __ex_table,"a"
         .word           4b, __retl_efault
diff --git a/arch/sparc/kernel/unaligned_32.c b/arch/sparc/kernel/unaligned_32.c
index 12b9f352595f..4491f4cb2695 100644
--- a/arch/sparc/kernel/unaligned_32.c
+++ b/arch/sparc/kernel/unaligned_32.c
@@ -16,7 +16,6 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/perf_event.h>
 
 enum direction {
diff --git a/arch/sparc/kernel/unaligned_64.c b/arch/sparc/kernel/unaligned_64.c
index c752c4c479bd..b2b019ea8caa 100644
--- a/arch/sparc/kernel/unaligned_64.c
+++ b/arch/sparc/kernel/unaligned_64.c
@@ -211,7 +211,7 @@ static inline int do_int_store(int reg_num, int size, unsigned long *dst_addr,
                 default:
                         BUG();
                         break;
-                };
+                }
         }
         return __do_int_store(dst_addr, size, src_val, asi);
 }
@@ -328,7 +328,7 @@ asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn)
                 case ASI_SNFL:
                         asi &= ~0x08;
                         break;
-                };
+                }
                 switch (dir) {
                 case load:
                         reg_addr = fetch_reg_addr(((insn>>25)&0x1f), regs);
@@ -351,7 +351,7 @@ asmlinkage void kernel_unaligned_trap(struct pt_regs *regs, unsigned int insn)
                                 default:
                                         BUG();
                                         break;
-                                };
+                                }
                                 *reg_addr = val_in;
                         }
                         break;
diff --git a/arch/sparc/kernel/us2e_cpufreq.c b/arch/sparc/kernel/us2e_cpufreq.c
index 8f982b76c712..489fc15f3194 100644
--- a/arch/sparc/kernel/us2e_cpufreq.c
+++ b/arch/sparc/kernel/us2e_cpufreq.c
@@ -176,7 +176,7 @@ static unsigned long index_to_estar_mode(unsigned int index)
 
         default:
                 BUG();
-        };
+        }
 }
 
 static unsigned long index_to_divisor(unsigned int index)
@@ -199,7 +199,7 @@ static unsigned long index_to_divisor(unsigned int index)
 
         default:
                 BUG();
-        };
+        }
 }
 
 static unsigned long estar_to_divisor(unsigned long estar)
@@ -224,7 +224,7 @@ static unsigned long estar_to_divisor(unsigned long estar)
                 break;
         default:
                 BUG();
-        };
+        }
 
         return ret;
 }
@@ -237,7 +237,7 @@ static unsigned int us2e_freq_get(unsigned int cpu)
         if (!cpu_online(cpu))
                 return 0;
 
-        cpus_allowed = current->cpus_allowed;
+        cpumask_copy(&cpus_allowed, tsk_cpus_allowed(current));
         set_cpus_allowed_ptr(current, cpumask_of(cpu));
 
         clock_tick = sparc64_get_clock_tick(cpu) / 1000;
@@ -258,7 +258,7 @@ static void us2e_set_cpu_divider_index(unsigned int cpu, unsigned int index)
         if (!cpu_online(cpu))
                 return;
 
-        cpus_allowed = current->cpus_allowed;
+        cpumask_copy(&cpus_allowed, tsk_cpus_allowed(current));
         set_cpus_allowed_ptr(current, cpumask_of(cpu));
 
         new_freq = clock_tick = sparc64_get_clock_tick(cpu) / 1000;
diff --git a/arch/sparc/kernel/us3_cpufreq.c b/arch/sparc/kernel/us3_cpufreq.c
index f35d1e794548..eb1624b931d9 100644
--- a/arch/sparc/kernel/us3_cpufreq.c
+++ b/arch/sparc/kernel/us3_cpufreq.c
@@ -71,7 +71,7 @@ static unsigned long get_current_freq(unsigned int cpu, unsigned long safari_cfg
                 break;
         default:
                 BUG();
-        };
+        }
 
         return ret;
 }
@@ -85,7 +85,7 @@ static unsigned int us3_freq_get(unsigned int cpu)
         if (!cpu_online(cpu))
                 return 0;
 
-        cpus_allowed = current->cpus_allowed;
+        cpumask_copy(&cpus_allowed, tsk_cpus_allowed(current));
         set_cpus_allowed_ptr(current, cpumask_of(cpu));
 
         reg = read_safari_cfg();
@@ -105,7 +105,7 @@ static void us3_set_cpu_divider_index(unsigned int cpu, unsigned int index)
         if (!cpu_online(cpu))
                 return;
 
-        cpus_allowed = current->cpus_allowed;
+        cpumask_copy(&cpus_allowed, tsk_cpus_allowed(current));
         set_cpus_allowed_ptr(current, cpumask_of(cpu));
 
         new_freq = sparc64_get_clock_tick(cpu) / 1000;
@@ -125,7 +125,7 @@ static void us3_set_cpu_divider_index(unsigned int cpu, unsigned int index)
 
         default:
                 BUG();
-        };
+        }
 
         reg = read_safari_cfg();
 
diff --git a/arch/sparc/kernel/viohs.c b/arch/sparc/kernel/viohs.c
index aa6ac70d4fd5..29348ea139c3 100644
--- a/arch/sparc/kernel/viohs.c
+++ b/arch/sparc/kernel/viohs.c
@@ -363,7 +363,7 @@ static int process_ver(struct vio_driver_state *vio, struct vio_ver_info *pkt)
 
         default:
                 return handshake_failure(vio);
-        };
+        }
 }
 
 static int process_attr(struct vio_driver_state *vio, void *pkt)
diff --git a/arch/sparc/kernel/visemul.c b/arch/sparc/kernel/visemul.c
index 9dfd2ebcb157..36357717d691 100644
--- a/arch/sparc/kernel/visemul.c
+++ b/arch/sparc/kernel/visemul.c
@@ -334,7 +334,7 @@ static void edge(struct pt_regs *regs, unsigned int insn, unsigned int opf)
                 left = edge32_tab_l[(rs1 >> 2) & 0x1].left;
                 right = edge32_tab_l[(rs2 >> 2) & 0x1].right;
                 break;
-        };
+        }
 
         if ((rs1 & ~0x7UL) == (rs2 & ~0x7UL))
                 rd_val = right & left;
@@ -360,7 +360,7 @@ static void edge(struct pt_regs *regs, unsigned int insn, unsigned int opf)
                 tstate = regs->tstate & ~(TSTATE_XCC | TSTATE_ICC);
                 regs->tstate = tstate | (ccr << 32UL);
         }
-        };
+        }
 }
 
 static void array(struct pt_regs *regs, unsigned int insn, unsigned int opf)
@@ -392,7 +392,7 @@ static void array(struct pt_regs *regs, unsigned int insn, unsigned int opf)
 
         case ARRAY32_OPF:
                 rd_val <<= 2;
-        };
+        }
 
         store_reg(regs, rd_val, RD(insn));
 }
@@ -577,7 +577,7 @@ static void pformat(struct pt_regs *regs, unsigned int insn, unsigned int opf)
                 *fpd_regaddr(f, RD(insn)) = rd_val;
                 break;
         }
-        };
+        }
 }
 
 static void pmul(struct pt_regs *regs, unsigned int insn, unsigned int opf)
@@ -693,7 +693,7 @@ static void pmul(struct pt_regs *regs, unsigned int insn, unsigned int opf)
                 *fpd_regaddr(f, RD(insn)) = rd_val;
                 break;
         }
-        };
+        }
 }
 
 static void pcmp(struct pt_regs *regs, unsigned int insn, unsigned int opf)
@@ -786,7 +786,7 @@ static void pcmp(struct pt_regs *regs, unsigned int insn, unsigned int opf)
                                 rd_val |= 1 << i;
                 }
                 break;
-        };
+        }
 
         maybe_flush_windows(0, 0, RD(insn), 0);
         store_reg(regs, rd_val, RD(insn));
@@ -885,7 +885,7 @@ int vis_emul(struct pt_regs *regs, unsigned int insn)
         case BSHUFFLE_OPF:
                 bshuffle(regs, insn);
                 break;
-        };
+        }
 
         regs->tpc = regs->tnpc;
         regs->tnpc += 4;
diff --git a/arch/sparc/kernel/vmlinux.lds.S b/arch/sparc/kernel/vmlinux.lds.S
index 0c1e6783657f..c0220759003e 100644
--- a/arch/sparc/kernel/vmlinux.lds.S
+++ b/arch/sparc/kernel/vmlinux.lds.S
@@ -108,7 +108,7 @@ SECTIONS
                 __sun4v_2insn_patch_end = .;
         }
 
-        PERCPU(PAGE_SIZE)
+        PERCPU_SECTION(SMP_CACHE_BYTES)
 
         . = ALIGN(PAGE_SIZE);
         __init_end = .;
diff --git a/arch/sparc/kernel/windows.c b/arch/sparc/kernel/windows.c
index b351770cbdd6..3107381e576d 100644
--- a/arch/sparc/kernel/windows.c
+++ b/arch/sparc/kernel/windows.c
@@ -9,7 +9,6 @@
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 
 #include <asm/uaccess.h>
 
diff --git a/arch/sparc/lib/Makefile b/arch/sparc/lib/Makefile
index 846d1c4374ea..7f01b8fce8bc 100644
--- a/arch/sparc/lib/Makefile
+++ b/arch/sparc/lib/Makefile
@@ -15,7 +15,6 @@ lib-$(CONFIG_SPARC32) += divdi3.o udivdi3.o
 lib-$(CONFIG_SPARC32) += copy_user.o locks.o
 lib-y                 += atomic_$(BITS).o
 lib-$(CONFIG_SPARC32) += lshrdi3.o ashldi3.o
-lib-$(CONFIG_SPARC32) += rwsem_32.o
 lib-$(CONFIG_SPARC32) += muldi3.o bitext.o cmpdi2.o
 
 lib-$(CONFIG_SPARC64) += copy_page.o clear_page.o bzero.o
diff --git a/arch/sparc/lib/atomic32.c b/arch/sparc/lib/atomic32.c
index cbddeb38ffda..d3c7a12ad879 100644
--- a/arch/sparc/lib/atomic32.c
+++ b/arch/sparc/lib/atomic32.c
@@ -16,7 +16,7 @@
 #define ATOMIC_HASH(a)  (&__atomic_hash[(((unsigned long)a)>>8) & (ATOMIC_HASH_SIZE-1)])
 
 spinlock_t __atomic_hash[ATOMIC_HASH_SIZE] = {
-        [0 ... (ATOMIC_HASH_SIZE-1)] = SPIN_LOCK_UNLOCKED
+        [0 ... (ATOMIC_HASH_SIZE-1)] = __SPIN_LOCK_UNLOCKED(__atomic_hash)
 };
 
 #else /* SMP */
diff --git a/arch/sparc/lib/bitext.c b/arch/sparc/lib/bitext.c
index 764b3eb7b604..48d00e72ce15 100644
--- a/arch/sparc/lib/bitext.c
+++ b/arch/sparc/lib/bitext.c
@@ -10,7 +10,7 @@
  */
 
 #include <linux/string.h>
-#include <linux/bitops.h>
+#include <linux/bitmap.h>
 
 #include <asm/bitext.h>
 
@@ -80,8 +80,7 @@ int bit_map_string_get(struct bit_map *t, int len, int align)
                 while (test_bit(offset + i, t->map) == 0) {
                         i++;
                         if (i == len) {
-                                for (i = 0; i < len; i++)
-                                        __set_bit(offset + i, t->map);
+                                bitmap_set(t->map, offset, len);
                                 if (offset == t->first_free)
                                         t->first_free = find_next_zero_bit
                                                         (t->map, t->size,
diff --git a/arch/sparc/lib/checksum_32.S b/arch/sparc/lib/checksum_32.S
index 3632cb34e914..0084c3361e15 100644
--- a/arch/sparc/lib/checksum_32.S
+++ b/arch/sparc/lib/checksum_32.S
@@ -289,10 +289,16 @@ cc_end_cruft:
 
         /* Also, handle the alignment code out of band. */
 cc_dword_align:
-        cmp     %g1, 6
-        bl,a    ccte
+        cmp     %g1, 16
+        bge     1f
+         srl    %g1, 1, %o3
+2:      cmp     %o3, 0
+        be,a    ccte
          andcc  %g1, 0xf, %o3
-        andcc   %o0, 0x1, %g0
+        andcc   %o3, %o0, %g0   ! Check %o0 only (%o1 has the same last 2 bits)
+        be,a    2b
+         srl    %o3, 1, %o3
+1:      andcc   %o0, 0x1, %g0
         bne     ccslow
          andcc  %o0, 0x2, %g0
         be      1f
diff --git a/arch/sparc/lib/rwsem_32.S b/arch/sparc/lib/rwsem_32.S
deleted file mode 100644
index 9675268e7fde..000000000000
--- a/arch/sparc/lib/rwsem_32.S
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Assembly part of rw semaphores.
- *
- * Copyright (C) 1999 Jakub Jelinek (jakub@redhat.com)
- */
-
-#include <asm/ptrace.h>
-#include <asm/psr.h>
-
-        .section .sched.text, "ax"
-        .align  4
-
-        .globl          ___down_read
-___down_read:
-        rd              %psr, %g3
-        nop
-        nop
-        nop
-        or              %g3, PSR_PIL, %g7
-        wr              %g7, 0, %psr
-        nop
-        nop
-        nop
-#ifdef CONFIG_SMP
-1:      ldstub          [%g1 + 4], %g7
-        tst             %g7
-        bne             1b
-         ld             [%g1], %g7
-        sub             %g7, 1, %g7
-        st              %g7, [%g1]
-        stb             %g0, [%g1 + 4]
-#else
-        ld              [%g1], %g7
-        sub             %g7, 1, %g7
-        st              %g7, [%g1]
-#endif
-        wr              %g3, 0, %psr
-        add             %g7, 1, %g7
-        nop
-        nop
-        subcc           %g7, 1, %g7
-        bneg            3f
-         nop
-2:      jmpl            %o7, %g0
-         mov            %g4, %o7
-3:      save            %sp, -64, %sp
-        mov             %g1, %l1
-        mov             %g4, %l4
-        bcs             4f
-         mov            %g5, %l5
-        call            down_read_failed
-         mov            %l1, %o0
-        mov             %l1, %g1
-        mov             %l4, %g4
-        ba              ___down_read
-         restore        %l5, %g0, %g5
-4:      call            down_read_failed_biased
-         mov            %l1, %o0
-        mov             %l1, %g1
-        mov             %l4, %g4
-        ba              2b
-         restore        %l5, %g0, %g5
-
-        .globl          ___down_write
-___down_write:
-        rd              %psr, %g3
-        nop
-        nop
-        nop
-        or              %g3, PSR_PIL, %g7
-        wr              %g7, 0, %psr
-        sethi           %hi(0x01000000), %g2
-        nop
-        nop
-#ifdef CONFIG_SMP
-1:      ldstub          [%g1 + 4], %g7
-        tst             %g7
-        bne             1b
-         ld             [%g1], %g7
-        sub             %g7, %g2, %g7
-        st              %g7, [%g1]
-        stb             %g0, [%g1 + 4]
-#else
-        ld              [%g1], %g7
-        sub             %g7, %g2, %g7
-        st              %g7, [%g1]
-#endif
-        wr              %g3, 0, %psr
-        add             %g7, %g2, %g7
-        nop
-        nop
-        subcc           %g7, %g2, %g7
-        bne             3f
-         nop
-2:      jmpl            %o7, %g0
-         mov            %g4, %o7
-3:      save            %sp, -64, %sp
-        mov             %g1, %l1
-        mov             %g4, %l4
-        bcs             4f
-         mov            %g5, %l5
-        call            down_write_failed
-         mov            %l1, %o0
-        mov             %l1, %g1
-        mov             %l4, %g4
-        ba              ___down_write
-         restore        %l5, %g0, %g5
-4:      call            down_write_failed_biased
-         mov            %l1, %o0
-        mov             %l1, %g1
-        mov             %l4, %g4
-        ba              2b
-         restore        %l5, %g0, %g5
-
-        .text
-        .globl          ___up_read
-___up_read:
-        rd              %psr, %g3
-        nop
-        nop
-        nop
-        or              %g3, PSR_PIL, %g7
-        wr              %g7, 0, %psr
-        nop
-        nop
-        nop
-#ifdef CONFIG_SMP
-1:      ldstub          [%g1 + 4], %g7
-        tst             %g7
-        bne             1b
-         ld             [%g1], %g7
-        add             %g7, 1, %g7
-        st              %g7, [%g1]
-        stb             %g0, [%g1 + 4]
-#else
-        ld              [%g1], %g7
-        add             %g7, 1, %g7
-        st              %g7, [%g1]
-#endif
-        wr              %g3, 0, %psr
-        nop
-        nop
-        nop
-        cmp             %g7, 0
-        be              3f
-         nop
-2:      jmpl            %o7, %g0
-         mov            %g4, %o7
-3:      save            %sp, -64, %sp
-        mov             %g1, %l1
-        mov             %g4, %l4
-        mov             %g5, %l5
-        clr             %o1
-        call            __rwsem_wake
-         mov            %l1, %o0
-        mov             %l1, %g1
-        mov             %l4, %g4
-        ba              2b
-         restore        %l5, %g0, %g5
-
-        .globl          ___up_write
-___up_write:
-        rd              %psr, %g3
-        nop
-        nop
-        nop
-        or              %g3, PSR_PIL, %g7
-        wr              %g7, 0, %psr
-        sethi           %hi(0x01000000), %g2
-        nop
-        nop
-#ifdef CONFIG_SMP
-1:      ldstub          [%g1 + 4], %g7
-        tst             %g7
-        bne             1b
-         ld             [%g1], %g7
-        add             %g7, %g2, %g7
-        st              %g7, [%g1]
-        stb             %g0, [%g1 + 4]
-#else
-        ld              [%g1], %g7
-        add             %g7, %g2, %g7
-        st              %g7, [%g1]
-#endif
-        wr              %g3, 0, %psr
-        sub             %g7, %g2, %g7
-        nop
-        nop
-        addcc           %g7, %g2, %g7
-        bcs             3f
-         nop
-2:      jmpl            %o7, %g0
-         mov            %g4, %o7
-3:      save            %sp, -64, %sp
-        mov             %g1, %l1
-        mov             %g4, %l4
-        mov             %g5, %l5
-        mov             %g7, %o1
-        call            __rwsem_wake
-         mov            %l1, %o0
-        mov             %l1, %g1
-        mov             %l4, %g4
-        ba              2b
-         restore        %l5, %g0, %g5
diff --git a/arch/sparc/math-emu/Makefile b/arch/sparc/math-emu/Makefile
index b9085ecbb27b..825dbee94d84 100644
--- a/arch/sparc/math-emu/Makefile
+++ b/arch/sparc/math-emu/Makefile
@@ -2,7 +2,7 @@
 # Makefile for the FPU instruction emulation.
 #
 
-# supress all warnings - as math.c produces a lot!
+# suppress all warnings - as math.c produces a lot!
 ccflags-y := -w
 
 obj-y    := math_$(BITS).o
diff --git a/arch/sparc/mm/fault_32.c b/arch/sparc/mm/fault_32.c
index bd8601601afa..7543ddbdadb2 100644
--- a/arch/sparc/mm/fault_32.c
+++ b/arch/sparc/mm/fault_32.c
@@ -135,7 +135,7 @@ asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc,
 
         default:
                 break;
-        };
+        }
 
         memset(&regs, 0, sizeof (regs));
         regs.pc = pc;
@@ -240,11 +240,10 @@ asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
          * only copy the information from the master page table,
          * nothing more.
          */
+        code = SEGV_MAPERR;
         if (!ARCH_SUN4C && address >= TASK_SIZE)
                 goto vmalloc_fault;
 
-        code = SEGV_MAPERR;
-
         /*
          * If we're in an interrupt or have no user
          * context, we must not take the fault..
@@ -539,6 +538,12 @@ do_sigbus:
         __do_fault_siginfo(BUS_ADRERR, SIGBUS, tsk->thread.kregs, address);
 }
 
+static void check_stack_aligned(unsigned long sp)
+{
+        if (sp & 0x7UL)
+                force_sig(SIGILL, current);
+}
+
 void window_overflow_fault(void)
 {
         unsigned long sp;
@@ -547,6 +552,8 @@ void window_overflow_fault(void)
         if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
                 force_user_fault(sp + 0x38, 1);
         force_user_fault(sp, 1);
+
+        check_stack_aligned(sp);
 }
 
 void window_underflow_fault(unsigned long sp)
@@ -554,6 +561,8 @@ void window_underflow_fault(unsigned long sp)
         if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
                 force_user_fault(sp + 0x38, 0);
         force_user_fault(sp, 0);
+
+        check_stack_aligned(sp);
 }
 
 void window_ret_fault(struct pt_regs *regs)
@@ -564,4 +573,6 @@ void window_ret_fault(struct pt_regs *regs)
         if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
                 force_user_fault(sp + 0x38, 0);
         force_user_fault(sp, 0);
+
+        check_stack_aligned(sp);
 }
diff --git a/arch/sparc/mm/generic_32.c b/arch/sparc/mm/generic_32.c
index 5edcac184eaf..e6067b75f11c 100644
--- a/arch/sparc/mm/generic_32.c
+++ b/arch/sparc/mm/generic_32.c
@@ -50,7 +50,7 @@ static inline int io_remap_pmd_range(struct mm_struct *mm, pmd_t * pmd, unsigned
                 end = PGDIR_SIZE;
         offset -= address;
         do {
-                pte_t * pte = pte_alloc_map(mm, pmd, address);
+                pte_t *pte = pte_alloc_map(mm, NULL, pmd, address);
                 if (!pte)
                         return -ENOMEM;
                 io_remap_pte_range(mm, pte, address, end - address, address + offset, prot, space);
diff --git a/arch/sparc/mm/generic_64.c b/arch/sparc/mm/generic_64.c
index 04f2bf4cd571..3cb00dfd4bd6 100644
--- a/arch/sparc/mm/generic_64.c
+++ b/arch/sparc/mm/generic_64.c
@@ -92,7 +92,7 @@ static inline int io_remap_pmd_range(struct mm_struct *mm, pmd_t * pmd, unsigned
                 end = PGDIR_SIZE;
         offset -= address;
         do {
-                pte_t * pte = pte_alloc_map(mm, pmd, address);
+                pte_t *pte = pte_alloc_map(mm, NULL, pmd, address);
                 if (!pte)
                         return -ENOMEM;
                 io_remap_pte_range(mm, pte, address, end - address, address + offset, prot, space);
diff --git a/arch/sparc/mm/highmem.c b/arch/sparc/mm/highmem.c
index e139e9cbf5f7..4730eac0747b 100644
--- a/arch/sparc/mm/highmem.c
+++ b/arch/sparc/mm/highmem.c
@@ -29,17 +29,17 @@
 #include <asm/tlbflush.h>
 #include <asm/fixmap.h>
 
-void *kmap_atomic(struct page *page, enum km_type type)
+void *__kmap_atomic(struct page *page)
 {
-        unsigned long idx;
         unsigned long vaddr;
+        long idx, type;
 
         /* even !CONFIG_PREEMPT needs this, for in_atomic in do_page_fault */
         pagefault_disable();
         if (!PageHighMem(page))
                 return page_address(page);
 
-        debug_kmap_atomic(type);
+        type = kmap_atomic_idx_push();
         idx = type + KM_TYPE_NR*smp_processor_id();
         vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
 
@@ -63,44 +63,52 @@ void *kmap_atomic(struct page *page, enum km_type type)
 
         return (void*) vaddr;
 }
-EXPORT_SYMBOL(kmap_atomic);
+EXPORT_SYMBOL(__kmap_atomic);
 
-void kunmap_atomic_notypecheck(void *kvaddr, enum km_type type)
+void __kunmap_atomic(void *kvaddr)
 {
-#ifdef CONFIG_DEBUG_HIGHMEM
         unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
-        unsigned long idx = type + KM_TYPE_NR*smp_processor_id();
+        int type;
 
         if (vaddr < FIXADDR_START) { // FIXME
                 pagefault_enable();
                 return;
         }
 
-        BUG_ON(vaddr != __fix_to_virt(FIX_KMAP_BEGIN+idx));
+        type = kmap_atomic_idx();
 
-/* XXX Fix - Anton */
+#ifdef CONFIG_DEBUG_HIGHMEM
+        {
+                unsigned long idx;
+
+                idx = type + KM_TYPE_NR * smp_processor_id();
+                BUG_ON(vaddr != __fix_to_virt(FIX_KMAP_BEGIN+idx));
+
+                /* XXX Fix - Anton */
 #if 0
-        __flush_cache_one(vaddr);
+                __flush_cache_one(vaddr);
 #else
-        flush_cache_all();
+                flush_cache_all();
 #endif
 
-        /*
-         * force other mappings to Oops if they'll try to access
-         * this pte without first remap it
-         */
-        pte_clear(&init_mm, vaddr, kmap_pte-idx);
-/* XXX Fix - Anton */
+                /*
+                 * force other mappings to Oops if they'll try to access
+                 * this pte without first remap it
+                 */
+                pte_clear(&init_mm, vaddr, kmap_pte-idx);
+                /* XXX Fix - Anton */
 #if 0
-        __flush_tlb_one(vaddr);
+                __flush_tlb_one(vaddr);
 #else
-        flush_tlb_all();
+                flush_tlb_all();
 #endif
+        }
 #endif
 
+        kmap_atomic_idx_pop();
         pagefault_enable();
 }
-EXPORT_SYMBOL(kunmap_atomic_notypecheck);
+EXPORT_SYMBOL(__kunmap_atomic);
 
 /* We may be fed a pagetable here by ptep_to_xxx and others. */
 struct page *kmap_atomic_to_page(void *ptr)
diff --git a/arch/sparc/mm/hugetlbpage.c b/arch/sparc/mm/hugetlbpage.c
index 5fdddf134caa..f4e97646ce23 100644
--- a/arch/sparc/mm/hugetlbpage.c
+++ b/arch/sparc/mm/hugetlbpage.c
@@ -214,7 +214,7 @@ pte_t *huge_pte_alloc(struct mm_struct *mm,
         if (pud) {
                 pmd = pmd_alloc(mm, pud, addr);
                 if (pmd)
-                        pte = pte_alloc_map(mm, pmd, addr);
+                        pte = pte_alloc_map(mm, NULL, pmd, addr);
         }
         return pte;
 }
diff --git a/arch/sparc/mm/init_32.c b/arch/sparc/mm/init_32.c
index 6d0e02c4fe09..7b00de61c5f1 100644
--- a/arch/sparc/mm/init_32.c
+++ b/arch/sparc/mm/init_32.c
@@ -37,8 +37,6 @@
 #include <asm/prom.h>
 #include <asm/leon.h>
 
-DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
-
 unsigned long *sparc_valid_addr_bitmap;
 EXPORT_SYMBOL(sparc_valid_addr_bitmap);
 
@@ -75,10 +73,10 @@ void __init kmap_init(void)
         kmap_prot = __pgprot(SRMMU_ET_PTE | SRMMU_PRIV | SRMMU_CACHE);
 }
 
-void show_mem(void)
+void show_mem(unsigned int filter)
 {
         printk("Mem-info:\n");
-        show_free_areas();
+        show_free_areas(filter);
         printk("Free swap:       %6ldkB\n",
                nr_swap_pages << (PAGE_SHIFT-10));
         printk("%ld pages of RAM\n", totalram_pages);
@@ -342,7 +340,7 @@ void __init paging_init(void)
                 prom_printf("paging_init: sparc_cpu_model = %d\n", sparc_cpu_model);
                 prom_printf("paging_init: Halting...\n");
                 prom_halt();
-        };
+        }
 
         /* Initialize the protection map with non-constant, MMU dependent values. */
         protection_map[0] = PAGE_NONE;
diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index f0434513df15..3fd8e18bed80 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -88,7 +88,7 @@ static void __init read_obp_memory(const char *property,
                                    struct linux_prom64_registers *regs,
                                    int *num_ents)
 {
-        int node = prom_finddevice("/memory");
+        phandle node = prom_finddevice("/memory");
         int prop_size = prom_getproplen(node, property);
         int ents, ret, i;
 
@@ -785,8 +785,7 @@ static int find_node(unsigned long addr)
         return -1;
 }
 
-static unsigned long long nid_range(unsigned long long start,
-                                    unsigned long long end, int *nid)
+u64 memblock_nid_range(u64 start, u64 end, int *nid)
 {
         *nid = find_node(start);
         start += PAGE_SIZE;
@@ -804,8 +803,7 @@ static unsigned long long nid_range(unsigned long long start,
         return start;
 }
 #else
-static unsigned long long nid_range(unsigned long long start,
-                                    unsigned long long end, int *nid)
+u64 memblock_nid_range(u64 start, u64 end, int *nid)
 {
         *nid = 0;
         return end;
@@ -822,8 +820,7 @@ static void __init allocate_node_data(int nid)
         struct pglist_data *p;
 
 #ifdef CONFIG_NEED_MULTIPLE_NODES
-        paddr = memblock_alloc_nid(sizeof(struct pglist_data),
-                              SMP_CACHE_BYTES, nid, nid_range);
+        paddr = memblock_alloc_try_nid(sizeof(struct pglist_data), SMP_CACHE_BYTES, nid);
         if (!paddr) {
                 prom_printf("Cannot allocate pglist_data for nid[%d]\n", nid);
                 prom_halt();
@@ -843,8 +840,7 @@ static void __init allocate_node_data(int nid)
         if (p->node_spanned_pages) {
                 num_pages = bootmem_bootmap_pages(p->node_spanned_pages);
 
-                paddr = memblock_alloc_nid(num_pages << PAGE_SHIFT, PAGE_SIZE, nid,
-                                      nid_range);
+                paddr = memblock_alloc_try_nid(num_pages << PAGE_SHIFT, PAGE_SIZE, nid);
                 if (!paddr) {
                         prom_printf("Cannot allocate bootmap for nid[%d]\n",
                                   nid);
@@ -866,7 +862,7 @@ static void init_node_masks_nonnuma(void)
         for (i = 0; i < NR_CPUS; i++)
                 numa_cpu_lookup_table[i] = 0;
 
-        numa_cpumask_lookup_table[0] = CPU_MASK_ALL;
+        cpumask_setall(&numa_cpumask_lookup_table[0]);
 }
 
 #ifdef CONFIG_NEED_MULTIPLE_NODES
@@ -972,19 +968,19 @@ int of_node_to_nid(struct device_node *dp)
 
 static void __init add_node_ranges(void)
 {
-        int i;
+        struct memblock_region *reg;
 
-        for (i = 0; i < memblock.memory.cnt; i++) {
-                unsigned long size = memblock_size_bytes(&memblock.memory, i);
+        for_each_memblock(memory, reg) {
+                unsigned long size = reg->size;
                 unsigned long start, end;
 
-                start = memblock.memory.region[i].base;
+                start = reg->base;
                 end = start + size;
                 while (start < end) {
                         unsigned long this_end;
                         int nid;
 
-                        this_end = nid_range(start, end, &nid);
+                        this_end = memblock_nid_range(start, end, &nid);
 
                         numadbg("Adding active range nid[%d] "
                                 "start[%lx] end[%lx]\n",
@@ -1084,7 +1080,7 @@ static void __init numa_parse_mdesc_group_cpus(struct mdesc_handle *md,
 {
         u64 arc;
 
-        cpus_clear(*mask);
+        cpumask_clear(mask);
 
         mdesc_for_each_arc(arc, md, grp, MDESC_ARC_TYPE_BACK) {
                 u64 target = mdesc_arc_target(md, arc);
@@ -1095,7 +1091,7 @@ static void __init numa_parse_mdesc_group_cpus(struct mdesc_handle *md,
                         continue;
                 id = mdesc_get_property(md, target, "id", NULL);
                 if (*id < nr_cpu_ids)
-                        cpu_set(*id, *mask);
+                        cpumask_set_cpu(*id, mask);
         }
 }
 
@@ -1157,13 +1153,13 @@ static int __init numa_parse_mdesc_group(struct mdesc_handle *md, u64 grp,
 
         numa_parse_mdesc_group_cpus(md, grp, &mask);
 
-        for_each_cpu_mask(cpu, mask)
+        for_each_cpu(cpu, &mask)
                 numa_cpu_lookup_table[cpu] = index;
-        numa_cpumask_lookup_table[index] = mask;
+        cpumask_copy(&numa_cpumask_lookup_table[index], &mask);
 
         if (numa_debug) {
                 printk(KERN_INFO "NUMA GROUP[%d]: cpus [ ", index);
-                for_each_cpu_mask(cpu, mask)
+                for_each_cpu(cpu, &mask)
                         printk("%d ", cpu);
                 printk("]\n");
         }
@@ -1222,7 +1218,7 @@ static int __init numa_parse_jbus(void)
         index = 0;
         for_each_present_cpu(cpu) {
                 numa_cpu_lookup_table[cpu] = index;
-                numa_cpumask_lookup_table[index] = cpumask_of_cpu(cpu);
+                cpumask_copy(&numa_cpumask_lookup_table[index], cpumask_of(cpu));
                 node_masks[index].mask = ~((1UL << 36UL) - 1UL);
                 node_masks[index].val = cpu << 36UL;
 
@@ -1281,7 +1277,7 @@ static void __init bootmem_init_nonnuma(void)
 {
         unsigned long top_of_ram = memblock_end_of_DRAM();
         unsigned long total_ram = memblock_phys_mem_size();
-        unsigned int i;
+        struct memblock_region *reg;
 
         numadbg("bootmem_init_nonnuma()\n");
 
@@ -1292,15 +1288,14 @@ static void __init bootmem_init_nonnuma(void)
 
         init_node_masks_nonnuma();
 
-        for (i = 0; i < memblock.memory.cnt; i++) {
-                unsigned long size = memblock_size_bytes(&memblock.memory, i);
+        for_each_memblock(memory, reg) {
                 unsigned long start_pfn, end_pfn;
 
-                if (!size)
+                if (!reg->size)
                         continue;
 
-                start_pfn = memblock.memory.region[i].base >> PAGE_SHIFT;
-                end_pfn = start_pfn + memblock_size_pages(&memblock.memory, i);
+                start_pfn = memblock_region_memory_base_pfn(reg);
+                end_pfn = memblock_region_memory_end_pfn(reg);
                 add_active_range(0, start_pfn, end_pfn);
         }
 
@@ -1318,7 +1313,7 @@ static void __init reserve_range_in_node(int nid, unsigned long start,
                 unsigned long this_end;
                 int n;
 
-                this_end = nid_range(start, end, &n);
+                this_end = memblock_nid_range(start, end, &n);
                 if (n == nid) {
                         numadbg("      MATCH reserving range [%lx:%lx]\n",
                                 start, this_end);
@@ -1334,17 +1329,12 @@ static void __init reserve_range_in_node(int nid, unsigned long start,
 
 static void __init trim_reserved_in_node(int nid)
 {
-        int i;
+        struct memblock_region *reg;
 
         numadbg("  trim_reserved_in_node(%d)\n", nid);
 
-        for (i = 0; i < memblock.reserved.cnt; i++) {
-                unsigned long start = memblock.reserved.region[i].base;
-                unsigned long size = memblock_size_bytes(&memblock.reserved, i);
-                unsigned long end = start + size;
-
-                reserve_range_in_node(nid, start, end);
-        }
+        for_each_memblock(reserved, reg)
+                reserve_range_in_node(nid, reg->base, reg->base + reg->size);
 }
 
 static void __init bootmem_init_one_node(int nid)
@@ -1635,7 +1625,7 @@ static void __init sun4v_ktsb_init(void)
                 ktsb_descr[0].pgsz_idx = HV_PGSZ_IDX_4MB;
                 ktsb_descr[0].pgsz_mask = HV_PGSZ_MASK_4MB;
                 break;
-        };
+        }
 
         ktsb_descr[0].assoc = 1;
         ktsb_descr[0].num_ttes = KERNEL_TSB_NENTRIES;
@@ -2276,7 +2266,7 @@ unsigned long pte_sz_bits(unsigned long sz)
                         return _PAGE_SZ512K_4V;
                 case 4 * 1024 * 1024:
                         return _PAGE_SZ4MB_4V;
-                };
+                }
         } else {
                 switch (sz) {
                 case 8 * 1024:
@@ -2288,7 +2278,7 @@ unsigned long pte_sz_bits(unsigned long sz)
                         return _PAGE_SZ512K_4U;
                 case 4 * 1024 * 1024:
                         return _PAGE_SZ4MB_4U;
-                };
+                }
         }
 }
 
diff --git a/arch/sparc/mm/leon_mm.c b/arch/sparc/mm/leon_mm.c
index c0e01297e64e..e485a6804998 100644
--- a/arch/sparc/mm/leon_mm.c
+++ b/arch/sparc/mm/leon_mm.c
@@ -226,7 +226,7 @@ void leon3_getCacheRegs(struct leon3_cacheregs *regs)
  * Leon2 and Leon3 differ in their way of telling cache information
  *
  */
-int leon_flush_needed(void)
+int __init leon_flush_needed(void)
 {
         int flush_needed = -1;
         unsigned int ssize, sets;
diff --git a/arch/sparc/mm/srmmu.c b/arch/sparc/mm/srmmu.c
index b0b43aa5e45a..cbef74e793b8 100644
--- a/arch/sparc/mm/srmmu.c
+++ b/arch/sparc/mm/srmmu.c
@@ -650,7 +650,7 @@ static void srmmu_unmapiorange(unsigned long virt_addr, unsigned int len)
  * mappings on the kernel stack without any special code as we did
  * need on the sun4c.
  */
-static struct thread_info *srmmu_alloc_thread_info(void)
+static struct thread_info *srmmu_alloc_thread_info_node(int node)
 {
         struct thread_info *ret;
 
@@ -1262,7 +1262,8 @@ extern unsigned long bootmem_init(unsigned long *pages_avail);
 
 void __init srmmu_paging_init(void)
 {
-        int i, cpunode;
+        int i;
+        phandle cpunode;
         char node_str[128];
         pgd_t *pgd;
         pmd_t *pmd;
@@ -1398,7 +1399,8 @@ static void __init srmmu_is_bad(void)
 
 static void __init init_vac_layout(void)
 {
-        int nd, cache_lines;
+        phandle nd;
+        int cache_lines;
         char node_str[128];
 #ifdef CONFIG_SMP
         int cpu = 0;
@@ -1663,7 +1665,7 @@ static void __init init_swift(void)
         default:
                 srmmu_modtype = Swift_ok;
                 break;
-        };
+        }
 
         BTFIXUPSET_CALL(flush_cache_all, swift_flush_cache_all, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(flush_cache_mm, swift_flush_cache_mm, BTFIXUPCALL_NORM);
@@ -2067,7 +2069,7 @@ static void __init get_srmmu_type(void)
                         /* Some other Cypress revision, assume a 605. */
                         init_cypress_605(mod_rev);
                         break;
-                };
+                }
                 return;
         }
         
@@ -2082,7 +2084,7 @@ static void __init get_srmmu_type(void)
 
         /* Next check for Fujitsu Swift. */
         if(psr_typ == 0 && psr_vers == 4) {
-                int cpunode;
+                phandle cpunode;
                 char node_str[128];
 
                 /* Look if it is not a TurboSparc emulating Swift... */
@@ -2269,7 +2271,7 @@ void __init ld_mmu_srmmu(void)
 
         BTFIXUPSET_CALL(mmu_info, srmmu_mmu_info, BTFIXUPCALL_NORM);
 
-        BTFIXUPSET_CALL(alloc_thread_info, srmmu_alloc_thread_info, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(alloc_thread_info_node, srmmu_alloc_thread_info_node, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(free_thread_info, srmmu_free_thread_info, BTFIXUPCALL_NORM);
 
         BTFIXUPSET_CALL(pte_to_pgoff, srmmu_pte_to_pgoff, BTFIXUPCALL_NORM);
diff --git a/arch/sparc/mm/sun4c.c b/arch/sparc/mm/sun4c.c
index 4289f90f8697..1cf4f198709a 100644
--- a/arch/sparc/mm/sun4c.c
+++ b/arch/sparc/mm/sun4c.c
@@ -318,7 +318,7 @@ void __init sun4c_probe_vac(void)
                 prom_printf("probe_vac: Didn't expect vac-linesize of %d, halting\n",
                             sun4c_vacinfo.linesize);
                 prom_halt();
-        };
+        }
 
         sun4c_flush_all();
         sun4c_enable_vac();
@@ -364,7 +364,7 @@ static void __init patch_kernel_fault_handler(void)
                         prom_printf("Unhandled number of segmaps: %d\n",
                                     num_segmaps);
                         prom_halt();
-        };
+        }
         switch (num_contexts) {
                 case 8:
                         /* Default, nothing to do. */
@@ -377,7 +377,7 @@ static void __init patch_kernel_fault_handler(void)
                         prom_printf("Unhandled number of contexts: %d\n",
                                     num_contexts);
                         prom_halt();
-        };
+        }
 
         if (sun4c_vacinfo.do_hwflushes != 0) {
                 PATCH_INSN(vac_hwflush_patch1_on, vac_hwflush_patch1);
@@ -394,7 +394,7 @@ static void __init patch_kernel_fault_handler(void)
                         prom_printf("Impossible VAC linesize %d, halting...\n",
                                     sun4c_vacinfo.linesize);
                         prom_halt();
-                };
+                }
         }
 }
 
@@ -420,7 +420,7 @@ volatile unsigned long __iomem *sun4c_memerr_reg = NULL;
 
 void __init sun4c_probe_memerr_reg(void)
 {
-        int node;
+        phandle node;
         struct linux_prom_registers regs[1];
 
         node = prom_getchild(prom_root_node);
@@ -435,16 +435,14 @@ void __init sun4c_probe_memerr_reg(void)
 
 static inline void sun4c_init_ss2_cache_bug(void)
 {
-        extern unsigned long start;
-
         if ((idprom->id_machtype == (SM_SUN4C | SM_4C_SS2)) ||
             (idprom->id_machtype == (SM_SUN4C | SM_4C_IPX)) ||
             (idprom->id_machtype == (SM_SUN4C | SM_4C_ELC))) {
                 /* Whee.. */
                 printk("SS2 cache bug detected, uncaching trap table page\n");
-                sun4c_flush_page((unsigned int) &start);
-                sun4c_put_pte(((unsigned long) &start),
-                        (sun4c_get_pte((unsigned long) &start) | _SUN4C_PAGE_NOCACHE));
+                sun4c_flush_page((unsigned int) &_start);
+                sun4c_put_pte(((unsigned long) &_start),
+                        (sun4c_get_pte((unsigned long) &_start) | _SUN4C_PAGE_NOCACHE));
         }
 }
 
@@ -924,7 +922,7 @@ static inline void garbage_collect(int entry)
         free_locked_segment(BUCKET_ADDR(entry));
 }
 
-static struct thread_info *sun4c_alloc_thread_info(void)
+static struct thread_info *sun4c_alloc_thread_info_node(int node)
 {
         unsigned long addr, pages;
         int entry;
@@ -2157,7 +2155,7 @@ void __init ld_mmu_sun4c(void)
         BTFIXUPSET_CALL(__swp_offset, sun4c_swp_offset, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(__swp_entry, sun4c_swp_entry, BTFIXUPCALL_NORM);
 
-        BTFIXUPSET_CALL(alloc_thread_info, sun4c_alloc_thread_info, BTFIXUPCALL_NORM);
+        BTFIXUPSET_CALL(alloc_thread_info_node, sun4c_alloc_thread_info_node, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(free_thread_info, sun4c_free_thread_info, BTFIXUPCALL_NORM);
 
         BTFIXUPSET_CALL(mmu_info, sun4c_mmu_info, BTFIXUPCALL_NORM);
diff --git a/arch/sparc/mm/tlb.c b/arch/sparc/mm/tlb.c
index d8f21e24a82f..b1f279cd00bf 100644
--- a/arch/sparc/mm/tlb.c
+++ b/arch/sparc/mm/tlb.c
@@ -19,33 +19,34 @@
 
 /* Heavily inspired by the ppc64 code.  */
 
-DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
+static DEFINE_PER_CPU(struct tlb_batch, tlb_batch);
 
 void flush_tlb_pending(void)
 {
-        struct mmu_gather *mp = &get_cpu_var(mmu_gathers);
+        struct tlb_batch *tb = &get_cpu_var(tlb_batch);
 
-        if (mp->tlb_nr) {
-                flush_tsb_user(mp);
+        if (tb->tlb_nr) {
+                flush_tsb_user(tb);
 
-                if (CTX_VALID(mp->mm->context)) {
+                if (CTX_VALID(tb->mm->context)) {
 #ifdef CONFIG_SMP
-                        smp_flush_tlb_pending(mp->mm, mp->tlb_nr,
-                                              &mp->vaddrs[0]);
+                        smp_flush_tlb_pending(tb->mm, tb->tlb_nr,
+                                              &tb->vaddrs[0]);
 #else
-                        __flush_tlb_pending(CTX_HWBITS(mp->mm->context),
-                                            mp->tlb_nr, &mp->vaddrs[0]);
+                        __flush_tlb_pending(CTX_HWBITS(tb->mm->context),
+                                            tb->tlb_nr, &tb->vaddrs[0]);
 #endif
                 }
-                mp->tlb_nr = 0;
+                tb->tlb_nr = 0;
         }
 
-        put_cpu_var(mmu_gathers);
+        put_cpu_var(tlb_batch);
 }
 
-void tlb_batch_add(struct mm_struct *mm, unsigned long vaddr, pte_t *ptep, pte_t orig)
+void tlb_batch_add(struct mm_struct *mm, unsigned long vaddr,
+                   pte_t *ptep, pte_t orig, int fullmm)
 {
-        struct mmu_gather *mp = &__get_cpu_var(mmu_gathers);
+        struct tlb_batch *tb = &get_cpu_var(tlb_batch);
         unsigned long nr;
 
         vaddr &= PAGE_MASK;
@@ -77,21 +78,25 @@ void tlb_batch_add(struct mm_struct *mm, unsigned long vaddr, pte_t *ptep, pte_t
 
 no_cache_flush:
 
-        if (mp->fullmm)
+        if (fullmm) {
+                put_cpu_var(tlb_batch);
                 return;
+        }
 
-        nr = mp->tlb_nr;
+        nr = tb->tlb_nr;
 
-        if (unlikely(nr != 0 && mm != mp->mm)) {
+        if (unlikely(nr != 0 && mm != tb->mm)) {
                 flush_tlb_pending();
                 nr = 0;
         }
 
         if (nr == 0)
-                mp->mm = mm;
+                tb->mm = mm;
 
-        mp->vaddrs[nr] = vaddr;
-        mp->tlb_nr = ++nr;
+        tb->vaddrs[nr] = vaddr;
+        tb->tlb_nr = ++nr;
         if (nr >= TLB_BATCH_NR)
                 flush_tlb_pending();
+
+        put_cpu_var(tlb_batch);
 }
diff --git a/arch/sparc/mm/tsb.c b/arch/sparc/mm/tsb.c
index 101d7c82870b..a5f51b22fcbe 100644
--- a/arch/sparc/mm/tsb.c
+++ b/arch/sparc/mm/tsb.c
@@ -47,12 +47,13 @@ void flush_tsb_kernel_range(unsigned long start, unsigned long end)
         }
 }
 
-static void __flush_tsb_one(struct mmu_gather *mp, unsigned long hash_shift, unsigned long tsb, unsigned long nentries)
+static void __flush_tsb_one(struct tlb_batch *tb, unsigned long hash_shift,
+                            unsigned long tsb, unsigned long nentries)
 {
         unsigned long i;
 
-        for (i = 0; i < mp->tlb_nr; i++) {
-                unsigned long v = mp->vaddrs[i];
+        for (i = 0; i < tb->tlb_nr; i++) {
+                unsigned long v = tb->vaddrs[i];
                 unsigned long tag, ent, hash;
 
                 v &= ~0x1UL;
@@ -65,9 +66,9 @@ static void __flush_tsb_one(struct mmu_gather *mp, unsigned long hash_shift, uns
         }
 }
 
-void flush_tsb_user(struct mmu_gather *mp)
+void flush_tsb_user(struct tlb_batch *tb)
 {
-        struct mm_struct *mm = mp->mm;
+        struct mm_struct *mm = tb->mm;
         unsigned long nentries, base, flags;
 
         spin_lock_irqsave(&mm->context.lock, flags);
@@ -76,7 +77,7 @@ void flush_tsb_user(struct mmu_gather *mp)
         nentries = mm->context.tsb_block[MM_TSB_BASE].tsb_nentries;
         if (tlb_type == cheetah_plus || tlb_type == hypervisor)
                 base = __pa(base);
-        __flush_tsb_one(mp, PAGE_SHIFT, base, nentries);
+        __flush_tsb_one(tb, PAGE_SHIFT, base, nentries);
 
 #ifdef CONFIG_HUGETLB_PAGE
         if (mm->context.tsb_block[MM_TSB_HUGE].tsb) {
@@ -84,7 +85,7 @@ void flush_tsb_user(struct mmu_gather *mp)
                 nentries = mm->context.tsb_block[MM_TSB_HUGE].tsb_nentries;
                 if (tlb_type == cheetah_plus || tlb_type == hypervisor)
                         base = __pa(base);
-                __flush_tsb_one(mp, HPAGE_SHIFT, base, nentries);
+                __flush_tsb_one(tb, HPAGE_SHIFT, base, nentries);
         }
 #endif
         spin_unlock_irqrestore(&mm->context.lock, flags);
@@ -179,7 +180,7 @@ static void setup_tsb_params(struct mm_struct *mm, unsigned long tsb_idx, unsign
                 printk(KERN_ERR "TSB[%s:%d]: Impossible TSB size %lu, killing process.\n",
                        current->comm, current->pid, tsb_bytes);
                 do_exit(SIGSEGV);
-        };
+        }
         tte |= pte_sz_bits(page_sz);
 
         if (tlb_type == cheetah_plus || tlb_type == hypervisor) {
@@ -214,7 +215,7 @@ static void setup_tsb_params(struct mm_struct *mm, unsigned long tsb_idx, unsign
 #endif
                 default:
                         BUG();
-                };
+                }
                 hp->assoc = 1;
                 hp->num_ttes = tsb_bytes / 16;
                 hp->ctx_idx = 0;
@@ -229,7 +230,7 @@ static void setup_tsb_params(struct mm_struct *mm, unsigned long tsb_idx, unsign
 #endif
                 default:
                         BUG();
-                };
+                }
                 hp->tsb_base = tsb_paddr;
                 hp->resv = 0;
         }
diff --git a/arch/sparc/prom/Makefile b/arch/sparc/prom/Makefile
index 1b8c073adb44..8287bbe88768 100644
--- a/arch/sparc/prom/Makefile
+++ b/arch/sparc/prom/Makefile
@@ -5,13 +5,10 @@ asflags := -ansi
 ccflags := -Werror
 
 lib-y                 := bootstr_$(BITS).o
-lib-$(CONFIG_SPARC32) += devmap.o
-lib-y                 += devops_$(BITS).o
 lib-y                 += init_$(BITS).o
 lib-$(CONFIG_SPARC32) += memory.o
 lib-y                 += misc_$(BITS).o
 lib-$(CONFIG_SPARC32) += mp.o
-lib-$(CONFIG_SPARC32) += palloc.o
 lib-$(CONFIG_SPARC32) += ranges.o
 lib-$(CONFIG_SPARC32) += segment.o
 lib-y                 += console_$(BITS).o
diff --git a/arch/sparc/prom/bootstr_32.c b/arch/sparc/prom/bootstr_32.c
index 916831da7e67..f5ec32e0d419 100644
--- a/arch/sparc/prom/bootstr_32.c
+++ b/arch/sparc/prom/bootstr_32.c
@@ -29,7 +29,8 @@ prom_getbootargs(void)
                 /* Start from 1 and go over fd(0,0,0)kernel */
                 for(iter = 1; iter < 8; iter++) {
                         arg = (*(romvec->pv_v0bootargs))->argv[iter];
-                        if(arg == 0) break;
+                        if (arg == NULL)
+                                break;
                         while(*arg != 0) {
                                 /* Leave place for space and null. */
                                 if(cp >= barg_buf + BARG_LEN-2){
diff --git a/arch/sparc/prom/console_32.c b/arch/sparc/prom/console_32.c
index 5340264b78f5..a00f47b16c10 100644
--- a/arch/sparc/prom/console_32.c
+++ b/arch/sparc/prom/console_32.c
@@ -16,82 +16,42 @@
 
 extern void restore_current(void);
 
-/* Non blocking get character from console input device, returns -1
- * if no input was taken.  This can be used for polling.
- */
-int
-prom_nbgetchar(void)
-{
-        static char inc;
-        int i = -1;
-        unsigned long flags;
-
-        spin_lock_irqsave(&prom_lock, flags);
-        switch(prom_vers) {
-        case PROM_V0:
-                i = (*(romvec->pv_nbgetchar))();
-                break;
-        case PROM_V2:
-        case PROM_V3:
-                if( (*(romvec->pv_v2devops).v2_dev_read)(*romvec->pv_v2bootargs.fd_stdin , &inc, 0x1) == 1) {
-                        i = inc;
-                } else {
-                        i = -1;
-                }
-                break;
-        default:
-                i = -1;
-                break;
-        };
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-        return i; /* Ugh, we could spin forever on unsupported proms ;( */
-}
-
 /* Non blocking put character to console device, returns -1 if
  * unsuccessful.
  */
-int
-prom_nbputchar(char c)
+static int prom_nbputchar(const char *buf)
 {
-        static char outc;
         unsigned long flags;
         int i = -1;
 
         spin_lock_irqsave(&prom_lock, flags);
         switch(prom_vers) {
         case PROM_V0:
-                i = (*(romvec->pv_nbputchar))(c);
+                if ((*(romvec->pv_nbputchar))(*buf))
+                        i = 1;
                 break;
         case PROM_V2:
         case PROM_V3:
-                outc = c;
-                if( (*(romvec->pv_v2devops).v2_dev_write)(*romvec->pv_v2bootargs.fd_stdout, &outc, 0x1) == 1)
-                        i = 0;
-                else
-                        i = -1;
+                if ((*(romvec->pv_v2devops).v2_dev_write)(*romvec->pv_v2bootargs.fd_stdout,
+                                                          buf, 0x1) == 1)
+                        i = 1;
                 break;
         default:
-                i = -1;
                 break;
-        };
+        }
         restore_current();
         spin_unlock_irqrestore(&prom_lock, flags);
         return i; /* Ugh, we could spin forever on unsupported proms ;( */
 }
 
-/* Blocking version of get character routine above. */
-char
-prom_getchar(void)
+void prom_console_write_buf(const char *buf, int len)
 {
-        int character;
-        while((character = prom_nbgetchar()) == -1) ;
-        return (char) character;
+        while (len) {
+                int n = prom_nbputchar(buf);
+                if (n < 0)
+                        continue;
+                len--;
+                buf++;
+        }
 }
 
-/* Blocking version of put character routine above. */
-void
-prom_putchar(char c)
-{
-        while(prom_nbputchar(c) == -1) ;
-}
diff --git a/arch/sparc/prom/console_64.c b/arch/sparc/prom/console_64.c
index 10322dc2f557..9de6c8cfe04a 100644
--- a/arch/sparc/prom/console_64.c
+++ b/arch/sparc/prom/console_64.c
@@ -13,87 +13,34 @@
 #include <asm/system.h>
 #include <linux/string.h>
 
-extern int prom_stdin, prom_stdout;
-
-/* Non blocking get character from console input device, returns -1
- * if no input was taken.  This can be used for polling.
- */
-inline int
-prom_nbgetchar(void)
+static int __prom_console_write_buf(const char *buf, int len)
 {
         unsigned long args[7];
-        char inc;
-
-        args[0] = (unsigned long) "read";
-        args[1] = 3;
-        args[2] = 1;
-        args[3] = (unsigned int) prom_stdin;
-        args[4] = (unsigned long) &inc;
-        args[5] = 1;
-        args[6] = (unsigned long) -1;
-
-        p1275_cmd_direct(args);
-
-        if (args[6] == 1)
-                return inc;
-        return -1;
-}
-
-/* Non blocking put character to console device, returns -1 if
- * unsuccessful.
- */
-inline int
-prom_nbputchar(char c)
-{
-        unsigned long args[7];
-        char outc;
-        
-        outc = c;
+        int ret;
 
         args[0] = (unsigned long) "write";
         args[1] = 3;
         args[2] = 1;
         args[3] = (unsigned int) prom_stdout;
-        args[4] = (unsigned long) &outc;
-        args[5] = 1;
+        args[4] = (unsigned long) buf;
+        args[5] = (unsigned int) len;
         args[6] = (unsigned long) -1;
 
         p1275_cmd_direct(args);
 
-        if (args[6] == 1)
-                return 0;
-        else
+        ret = (int) args[6];
+        if (ret < 0)
                 return -1;
+        return ret;
 }
 
-/* Blocking version of get character routine above. */
-char
-prom_getchar(void)
+void prom_console_write_buf(const char *buf, int len)
 {
-        int character;
-        while((character = prom_nbgetchar()) == -1) ;
-        return (char) character;
-}
-
-/* Blocking version of put character routine above. */
-void
-prom_putchar(char c)
-{
-        prom_nbputchar(c);
-}
-
-void
-prom_puts(const char *s, int len)
-{
-        unsigned long args[7];
-
-        args[0] = (unsigned long) "write";
-        args[1] = 3;
-        args[2] = 1;
-        args[3] = (unsigned int) prom_stdout;
-        args[4] = (unsigned long) s;
-        args[5] = len;
-        args[6] = (unsigned long) -1;
-
-        p1275_cmd_direct(args);
+        while (len) {
+                int n = __prom_console_write_buf(buf, len);
+                if (n < 0)
+                        continue;
+                len -= n;
+                buf += len;
+        }
 }
diff --git a/arch/sparc/prom/devmap.c b/arch/sparc/prom/devmap.c
deleted file mode 100644
index 46157d2aba0d..000000000000
--- a/arch/sparc/prom/devmap.c
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * promdevmap.c:  Map device/IO areas to virtual addresses.
- *
- * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
- */
-
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-
-#include <asm/openprom.h>
-#include <asm/oplib.h>
-
-extern void restore_current(void);
-
-/* Just like the routines in palloc.c, these should not be used
- * by the kernel at all.  Bootloader facility mainly.  And again,
- * this is only available on V2 proms and above.
- */
-
-/* Map physical device address 'paddr' in IO space 'ios' of size
- * 'num_bytes' to a virtual address, with 'vhint' being a hint to
- * the prom as to where you would prefer the mapping.  We return
- * where the prom actually mapped it.
- */
-char *
-prom_mapio(char *vhint, int ios, unsigned int paddr, unsigned int num_bytes)
-{
-        unsigned long flags;
-        char *ret;
-
-        spin_lock_irqsave(&prom_lock, flags);
-        if((num_bytes == 0) || (paddr == 0)) ret = (char *) 0x0;
-        else
-        ret = (*(romvec->pv_v2devops.v2_dumb_mmap))(vhint, ios, paddr,
-                                                    num_bytes);
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-        return ret;
-}
-
-/* Unmap an IO/device area that was mapped using the above routine. */
-void
-prom_unmapio(char *vaddr, unsigned int num_bytes)
-{
-        unsigned long flags;
-
-        if(num_bytes == 0x0) return;
-        spin_lock_irqsave(&prom_lock, flags);
-        (*(romvec->pv_v2devops.v2_dumb_munmap))(vaddr, num_bytes);
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-}
diff --git a/arch/sparc/prom/devops_32.c b/arch/sparc/prom/devops_32.c
deleted file mode 100644
index 9c5d4687242a..000000000000
--- a/arch/sparc/prom/devops_32.c
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * devops.c:  Device operations using the PROM.
- *
- * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
- */
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-
-#include <asm/openprom.h>
-#include <asm/oplib.h>
-
-extern void restore_current(void);
-
-/* Open the device described by the string 'dstr'.  Returns the handle
- * to that device used for subsequent operations on that device.
- * Returns -1 on failure.
- */
-int
-prom_devopen(char *dstr)
-{
-        int handle;
-        unsigned long flags;
-        spin_lock_irqsave(&prom_lock, flags);
-        switch(prom_vers) {
-        case PROM_V0:
-                handle = (*(romvec->pv_v0devops.v0_devopen))(dstr);
-                if(handle == 0) handle = -1;
-                break;
-        case PROM_V2:
-        case PROM_V3:
-                handle = (*(romvec->pv_v2devops.v2_dev_open))(dstr);
-                break;
-        default:
-                handle = -1;
-                break;
-        };
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-
-        return handle;
-}
-
-/* Close the device described by device handle 'dhandle'. */
-int
-prom_devclose(int dhandle)
-{
-        unsigned long flags;
-        spin_lock_irqsave(&prom_lock, flags);
-        switch(prom_vers) {
-        case PROM_V0:
-                (*(romvec->pv_v0devops.v0_devclose))(dhandle);
-                break;
-        case PROM_V2:
-        case PROM_V3:
-                (*(romvec->pv_v2devops.v2_dev_close))(dhandle);
-                break;
-        default:
-                break;
-        };
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-        return 0;
-}
-
-/* Seek to specified location described by 'seekhi' and 'seeklo'
- * for device 'dhandle'.
- */
-void
-prom_seek(int dhandle, unsigned int seekhi, unsigned int seeklo)
-{
-        unsigned long flags;
-        spin_lock_irqsave(&prom_lock, flags);
-        switch(prom_vers) {
-        case PROM_V0:
-                (*(romvec->pv_v0devops.v0_seekdev))(dhandle, seekhi, seeklo);
-                break;
-        case PROM_V2:
-        case PROM_V3:
-                (*(romvec->pv_v2devops.v2_dev_seek))(dhandle, seekhi, seeklo);
-                break;
-        default:
-                break;
-        };
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-}
diff --git a/arch/sparc/prom/devops_64.c b/arch/sparc/prom/devops_64.c
deleted file mode 100644
index a017119e7ef1..000000000000
--- a/arch/sparc/prom/devops_64.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * devops.c:  Device operations using the PROM.
- *
- * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
- * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
- */
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-
-#include <asm/openprom.h>
-#include <asm/oplib.h>
-
-/* Open the device described by the string 'dstr'.  Returns the handle
- * to that device used for subsequent operations on that device.
- * Returns 0 on failure.
- */
-int
-prom_devopen(const char *dstr)
-{
-        unsigned long args[5];
-
-        args[0] = (unsigned long) "open";
-        args[1] = 1;
-        args[2] = 1;
-        args[3] = (unsigned long) dstr;
-        args[4] = (unsigned long) -1;
-
-        p1275_cmd_direct(args);
-
-        return (int) args[4];
-}
-
-/* Close the device described by device handle 'dhandle'. */
-int
-prom_devclose(int dhandle)
-{
-        unsigned long args[4];
-
-        args[0] = (unsigned long) "close";
-        args[1] = 1;
-        args[2] = 0;
-        args[3] = (unsigned int) dhandle;
-
-        p1275_cmd_direct(args);
-
-        return 0;
-}
-
-/* Seek to specified location described by 'seekhi' and 'seeklo'
- * for device 'dhandle'.
- */
-void
-prom_seek(int dhandle, unsigned int seekhi, unsigned int seeklo)
-{
-        unsigned long args[7];
-
-        args[0] = (unsigned long) "seek";
-        args[1] = 3;
-        args[2] = 1;
-        args[3] = (unsigned int) dhandle;
-        args[4] = seekhi;
-        args[5] = seeklo;
-        args[6] = (unsigned long) -1;
-
-        p1275_cmd_direct(args);
-}
diff --git a/arch/sparc/prom/init_32.c b/arch/sparc/prom/init_32.c
index ccb36c7f9b8c..26c64cea3c9c 100644
--- a/arch/sparc/prom/init_32.c
+++ b/arch/sparc/prom/init_32.c
@@ -20,7 +20,7 @@ enum prom_major_version prom_vers;
 unsigned int prom_rev, prom_prev;
 
 /* The root node of the prom device tree. */
-int prom_root_node;
+phandle prom_root_node;
 EXPORT_SYMBOL(prom_root_node);
 
 /* Pointer to the device tree operations structure. */
@@ -53,14 +53,14 @@ void __init prom_init(struct linux_romvec *rp)
                             romvec->pv_romvers);
                 prom_halt();
                 break;
-        };
+        }
 
         prom_rev = romvec->pv_plugin_revision;
         prom_prev = romvec->pv_printrev;
         prom_nodeops = romvec->pv_nodeops;
 
         prom_root_node = prom_getsibling(0);
-        if((prom_root_node == 0) || (prom_root_node == -1))
+        if ((prom_root_node == 0) || ((s32)prom_root_node == -1))
                 prom_halt();
 
         if((((unsigned long) prom_nodeops) == 0) || 
diff --git a/arch/sparc/prom/init_64.c b/arch/sparc/prom/init_64.c
index 7b00f89490a4..5016c5e20575 100644
--- a/arch/sparc/prom/init_64.c
+++ b/arch/sparc/prom/init_64.c
@@ -18,8 +18,8 @@
 char prom_version[80];
 
 /* The root node of the prom device tree. */
-int prom_stdin, prom_stdout;
-int prom_chosen_node;
+int prom_stdout;
+phandle prom_chosen_node;
 
 /* You must call prom_init() before you attempt to use any of the
  * routines in the prom library.  It returns 0 on success, 1 on
@@ -30,19 +30,18 @@ extern void prom_cif_init(void *, void *);
 
 void __init prom_init(void *cif_handler, void *cif_stack)
 {
-        int node;
+        phandle node;
 
         prom_cif_init(cif_handler, cif_stack);
 
         prom_chosen_node = prom_finddevice(prom_chosen_path);
-        if (!prom_chosen_node || prom_chosen_node == -1)
+        if (!prom_chosen_node || (s32)prom_chosen_node == -1)
                 prom_halt();
 
-        prom_stdin = prom_getint(prom_chosen_node, "stdin");
         prom_stdout = prom_getint(prom_chosen_node, "stdout");
 
         node = prom_finddevice("/openprom");
-        if (!node || node == -1)
+        if (!node || (s32)node == -1)
                 prom_halt();
 
         prom_getstring(node, "version", prom_version, sizeof(prom_version));
diff --git a/arch/sparc/prom/memory.c b/arch/sparc/prom/memory.c
index fac7899a29c3..3f263a64857d 100644
--- a/arch/sparc/prom/memory.c
+++ b/arch/sparc/prom/memory.c
@@ -31,7 +31,8 @@ static int __init prom_meminit_v0(void)
 static int __init prom_meminit_v2(void)
 {
         struct linux_prom_registers reg[64];
-        int node, size, num_ents, i;
+        phandle node;
+        int size, num_ents, i;
 
         node = prom_searchsiblings(prom_getchild(prom_root_node), "memory");
         size = prom_getproperty(node, "available", (char *) reg, sizeof(reg));
diff --git a/arch/sparc/prom/misc_32.c b/arch/sparc/prom/misc_32.c
index 4d61c540bb3d..677b6a10fbde 100644
--- a/arch/sparc/prom/misc_32.c
+++ b/arch/sparc/prom/misc_32.c
@@ -54,15 +54,11 @@ EXPORT_SYMBOL(prom_feval);
 void
 prom_cmdline(void)
 {
-        extern void install_obp_ticker(void);
-        extern void install_linux_ticker(void);
         unsigned long flags;
 
         spin_lock_irqsave(&prom_lock, flags);
-        install_obp_ticker();
         (*(romvec->pv_abort))();
         restore_current();
-        install_linux_ticker();
         spin_unlock_irqrestore(&prom_lock, flags);
         set_auxio(AUXIO_LED, 0);
 }
@@ -70,7 +66,7 @@ prom_cmdline(void)
 /* Drop into the prom, but completely terminate the program.
  * No chance of continuing.
  */
-void
+void __noreturn
 prom_halt(void)
 {
         unsigned long flags;
diff --git a/arch/sparc/prom/misc_64.c b/arch/sparc/prom/misc_64.c
index 6cb1581d6aef..e4f31d4d3715 100644
--- a/arch/sparc/prom/misc_64.c
+++ b/arch/sparc/prom/misc_64.c
@@ -18,7 +18,7 @@
 #include <asm/system.h>
 #include <asm/ldc.h>
 
-int prom_service_exists(const char *service_name)
+static int prom_service_exists(const char *service_name)
 {
         unsigned long args[5];
 
@@ -150,20 +150,6 @@ void prom_halt_power_off(void)
         prom_halt();
 }
 
-/* Set prom sync handler to call function 'funcp'. */
-void prom_setcallback(callback_func_t funcp)
-{
-        unsigned long args[5];
-        if (!funcp)
-                return;
-        args[0] = (unsigned long) "set-callback";
-        args[1] = 1;
-        args[2] = 1;
-        args[3] = (unsigned long) funcp;
-        args[4] = (unsigned long) -1;
-        p1275_cmd_direct(args);
-}
-
 /* Get the idprom and stuff it into buffer 'idbuf'.  Returns the
  * format type.  'num_bytes' is the number of bytes that your idbuf
  * has space for.  Returns 0xff on error.
@@ -183,7 +169,8 @@ unsigned char prom_get_idprom(char *idbuf, int num_bytes)
 
 int prom_get_mmu_ihandle(void)
 {
-        int node, ret;
+        phandle node;
+        int ret;
 
         if (prom_mmu_ihandle_cache != 0)
                 return prom_mmu_ihandle_cache;
@@ -201,7 +188,8 @@ int prom_get_mmu_ihandle(void)
 static int prom_get_memory_ihandle(void)
 {
         static int memory_ihandle_cache;
-        int node, ret;
+        phandle node;
+        int ret;
 
         if (memory_ihandle_cache != 0)
                 return memory_ihandle_cache;
diff --git a/arch/sparc/prom/mp.c b/arch/sparc/prom/mp.c
index 4c4dc79f65af..0da8256cf76f 100644
--- a/arch/sparc/prom/mp.c
+++ b/arch/sparc/prom/mp.c
@@ -35,85 +35,7 @@ prom_startcpu(int cpunode, struct linux_prom_registers *ctable_reg, int ctx, cha
         case PROM_V3:
                 ret = (*(romvec->v3_cpustart))(cpunode, (int) ctable_reg, ctx, pc);
                 break;
-        };
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-
-        return ret;
-}
-
-/* Stop CPU with device prom-tree node 'cpunode'.
- * XXX Again, what does the return value really mean? XXX
- */
-int
-prom_stopcpu(int cpunode)
-{
-        int ret;
-        unsigned long flags;
-
-        spin_lock_irqsave(&prom_lock, flags);
-        switch(prom_vers) {
-        case PROM_V0:
-        case PROM_V2:
-        default:
-                ret = -1;
-                break;
-        case PROM_V3:
-                ret = (*(romvec->v3_cpustop))(cpunode);
-                break;
-        };
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-
-        return ret;
-}
-
-/* Make CPU with device prom-tree node 'cpunode' idle.
- * XXX Return value, anyone? XXX
- */
-int
-prom_idlecpu(int cpunode)
-{
-        int ret;
-        unsigned long flags;
-
-        spin_lock_irqsave(&prom_lock, flags);
-        switch(prom_vers) {
-        case PROM_V0:
-        case PROM_V2:
-        default:
-                ret = -1;
-                break;
-        case PROM_V3:
-                ret = (*(romvec->v3_cpuidle))(cpunode);
-                break;
-        };
-        restore_current();
-        spin_unlock_irqrestore(&prom_lock, flags);
-
-        return ret;
-}
-
-/* Resume the execution of CPU with nodeid 'cpunode'.
- * XXX Come on, somebody has to know... XXX
- */
-int
-prom_restartcpu(int cpunode)
-{
-        int ret;
-        unsigned long flags;
-
-        spin_lock_irqsave(&prom_lock, flags);
-        switch(prom_vers) {
-        case PROM_V0:
-        case PROM_V2:
-        default:
-                ret = -1;
-                break;
-        case PROM_V3:
-                ret = (*(romvec->v3_cpuresume))(cpunode);
-                break;
-        };
+        }
         restore_current();
         spin_unlock_irqrestore(&prom_lock, flags);
 
diff --git a/arch/sparc/prom/p1275.c b/arch/sparc/prom/p1275.c
index fa6e4e219b9c..d9850c2b9bf2 100644
--- a/arch/sparc/prom/p1275.c
+++ b/arch/sparc/prom/p1275.c
@@ -39,7 +39,7 @@ void p1275_cmd_direct(unsigned long *args)
         unsigned long flags;
 
         raw_local_save_flags(flags);
-        raw_local_irq_restore(PIL_NMI);
+        raw_local_irq_restore((unsigned long)PIL_NMI);
         raw_spin_lock(&prom_entry_lock);
 
         prom_world(1);
diff --git a/arch/sparc/prom/palloc.c b/arch/sparc/prom/palloc.c
deleted file mode 100644
index 2e2a88b211fb..000000000000
--- a/arch/sparc/prom/palloc.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * palloc.c:  Memory allocation from the Sun PROM.
- *
- * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
- */
-
-#include <asm/openprom.h>
-#include <asm/oplib.h>
-
-/* You should not call these routines after memory management
- * has been initialized in the kernel, if fact you should not
- * use these if at all possible in the kernel.  They are mainly
- * to be used for a bootloader for temporary allocations which
- * it will free before jumping into the kernel it has loaded.
- *
- * Also, these routines don't work on V0 proms, only V2 and later.
- */
-
-/* Allocate a chunk of memory of size 'num_bytes' giving a suggestion
- * of virtual_hint as the preferred virtual base address of this chunk.
- * There are no guarantees that you will get the allocation, or that
- * the prom will abide by your "hint".  So check your return value.
- */
-char *
-prom_alloc(char *virtual_hint, unsigned int num_bytes)
-{
-        if(prom_vers == PROM_V0) return (char *) 0x0;
-        if(num_bytes == 0x0) return (char *) 0x0;
-        return (*(romvec->pv_v2devops.v2_dumb_mem_alloc))(virtual_hint, num_bytes);
-}
-
-/* Free a previously allocated chunk back to the prom at virtual address
- * 'vaddr' of size 'num_bytes'.  NOTE: This vaddr is not the hint you
- * used for the allocation, but the virtual address the prom actually
- * returned to you.  They may be have been the same, they may have not,
- * doesn't matter.
- */
-void
-prom_free(char *vaddr, unsigned int num_bytes)
-{
-        if((prom_vers == PROM_V0) || (num_bytes == 0x0)) return;
-        (*(romvec->pv_v2devops.v2_dumb_mem_free))(vaddr, num_bytes);
-}
diff --git a/arch/sparc/prom/printf.c b/arch/sparc/prom/printf.c
index ca869266b9f3..d9682f06b3b0 100644
--- a/arch/sparc/prom/printf.c
+++ b/arch/sparc/prom/printf.c
@@ -15,22 +15,45 @@
 
 #include <linux/kernel.h>
 #include <linux/compiler.h>
+#include <linux/spinlock.h>
 
 #include <asm/openprom.h>
 #include <asm/oplib.h>
 
+#define CONSOLE_WRITE_BUF_SIZE  1024
+
 static char ppbuf[1024];
+static char console_write_buf[CONSOLE_WRITE_BUF_SIZE];
+static DEFINE_RAW_SPINLOCK(console_write_lock);
 
 void notrace prom_write(const char *buf, unsigned int n)
 {
-        char ch;
+        unsigned int dest_len;
+        unsigned long flags;
+        char *dest;
+
+        dest = console_write_buf;
+        raw_spin_lock_irqsave(&console_write_lock, flags);
 
-        while (n != 0) {
-                --n;
-                if ((ch = *buf++) == '\n')
-                        prom_putchar('\r');
-                prom_putchar(ch);
+        dest_len = 0;
+        while (n-- != 0) {
+                char ch = *buf++;
+                if (ch == '\n') {
+                        *dest++ = '\r';
+                        dest_len++;
+                }
+                *dest++ = ch;
+                dest_len++;
+                if (dest_len >= CONSOLE_WRITE_BUF_SIZE - 1) {
+                        prom_console_write_buf(console_write_buf, dest_len);
+                        dest = console_write_buf;
+                        dest_len = 0;
+                }
         }
+        if (dest_len)
+                prom_console_write_buf(console_write_buf, dest_len);
+
+        raw_spin_unlock_irqrestore(&console_write_lock, flags);
 }
 
 void notrace prom_printf(const char *fmt, ...)
diff --git a/arch/sparc/prom/ranges.c b/arch/sparc/prom/ranges.c
index aeff43e44e45..0857aa9e839d 100644
--- a/arch/sparc/prom/ranges.c
+++ b/arch/sparc/prom/ranges.c
@@ -13,8 +13,8 @@
 #include <asm/types.h>
 #include <asm/system.h>
 
-struct linux_prom_ranges promlib_obio_ranges[PROMREG_MAX];
-int num_obio_ranges;
+static struct linux_prom_ranges promlib_obio_ranges[PROMREG_MAX];
+static int num_obio_ranges;
 
 /* Adjust register values based upon the ranges parameters. */
 static void
@@ -35,7 +35,7 @@ prom_adjust_regs(struct linux_prom_registers *regp, int nregs,
         }
 }
 
-void
+static void
 prom_adjust_ranges(struct linux_prom_ranges *ranges1, int nranges1,
                    struct linux_prom_ranges *ranges2, int nranges2)
 {
@@ -68,7 +68,7 @@ EXPORT_SYMBOL(prom_apply_obio_ranges);
 
 void __init prom_ranges_init(void)
 {
-        int node, obio_node;
+        phandle node, obio_node;
         int success;
 
         num_obio_ranges = 0;
@@ -89,8 +89,8 @@ void __init prom_ranges_init(void)
                 prom_printf("PROMLIB: obio_ranges %d\n", num_obio_ranges);
 }
 
-void
-prom_apply_generic_ranges (int node, int parent, struct linux_prom_registers *regs, int nregs)
+void prom_apply_generic_ranges(phandle node, phandle parent,
+                struct linux_prom_registers *regs, int nregs)
 {
         int success;
         int num_ranges;
diff --git a/arch/sparc/prom/tree_32.c b/arch/sparc/prom/tree_32.c
index b21592f8e3fe..f30e8d038f01 100644
--- a/arch/sparc/prom/tree_32.c
+++ b/arch/sparc/prom/tree_32.c
@@ -20,10 +20,10 @@ extern void restore_current(void);
 static char promlib_buf[128];
 
 /* Internal version of prom_getchild that does not alter return values. */
-int __prom_getchild(int node)
+static phandle __prom_getchild(phandle node)
 {
         unsigned long flags;
-        int cnode;
+        phandle cnode;
 
         spin_lock_irqsave(&prom_lock, flags);
         cnode = prom_nodeops->no_child(node);
@@ -36,15 +36,15 @@ int __prom_getchild(int node)
 /* Return the child of node 'node' or zero if no this node has no
  * direct descendent.
  */
-int prom_getchild(int node)
+phandle prom_getchild(phandle node)
 {
-        int cnode;
+        phandle cnode;
 
-        if (node == -1)
+        if ((s32)node == -1)
                 return 0;
 
         cnode = __prom_getchild(node);
-        if (cnode == 0 || cnode == -1)
+        if (cnode == 0 || (s32)cnode == -1)
                 return 0;
 
         return cnode;
@@ -52,10 +52,10 @@ int prom_getchild(int node)
 EXPORT_SYMBOL(prom_getchild);
 
 /* Internal version of prom_getsibling that does not alter return values. */
-int __prom_getsibling(int node)
+static phandle __prom_getsibling(phandle node)
 {
         unsigned long flags;
-        int cnode;
+        phandle cnode;
 
         spin_lock_irqsave(&prom_lock, flags);
         cnode = prom_nodeops->no_nextnode(node);
@@ -68,15 +68,15 @@ int __prom_getsibling(int node)
 /* Return the next sibling of node 'node' or zero if no more siblings
  * at this level of depth in the tree.
  */
-int prom_getsibling(int node)
+phandle prom_getsibling(phandle node)
 {
-        int sibnode;
+        phandle sibnode;
 
-        if (node == -1)
+        if ((s32)node == -1)
                 return 0;
 
         sibnode = __prom_getsibling(node);
-        if (sibnode == 0 || sibnode == -1)
+        if (sibnode == 0 || (s32)sibnode == -1)
                 return 0;
 
         return sibnode;
@@ -86,7 +86,7 @@ EXPORT_SYMBOL(prom_getsibling);
 /* Return the length in bytes of property 'prop' at node 'node'.
  * Return -1 on error.
  */
-int prom_getproplen(int node, const char *prop)
+int prom_getproplen(phandle node, const char *prop)
 {
         int ret;
         unsigned long flags;
@@ -106,7 +106,7 @@ EXPORT_SYMBOL(prom_getproplen);
  * 'buffer' which has a size of 'bufsize'.  If the acquisition
  * was successful the length will be returned, else -1 is returned.
  */
-int prom_getproperty(int node, const char *prop, char *buffer, int bufsize)
+int prom_getproperty(phandle node, const char *prop, char *buffer, int bufsize)
 {
         int plen, ret;
         unsigned long flags;
@@ -126,7 +126,7 @@ EXPORT_SYMBOL(prom_getproperty);
 /* Acquire an integer property and return its value.  Returns -1
  * on failure.
  */
-int prom_getint(int node, char *prop)
+int prom_getint(phandle node, char *prop)
 {
         static int intprop;
 
@@ -140,7 +140,7 @@ EXPORT_SYMBOL(prom_getint);
 /* Acquire an integer property, upon error return the passed default
  * integer.
  */
-int prom_getintdefault(int node, char *property, int deflt)
+int prom_getintdefault(phandle node, char *property, int deflt)
 {
         int retval;
 
@@ -152,7 +152,7 @@ int prom_getintdefault(int node, char *property, int deflt)
 EXPORT_SYMBOL(prom_getintdefault);
 
 /* Acquire a boolean property, 1=TRUE 0=FALSE. */
-int prom_getbool(int node, char *prop)
+int prom_getbool(phandle node, char *prop)
 {
         int retval;
 
@@ -166,7 +166,7 @@ EXPORT_SYMBOL(prom_getbool);
  * string on error.  The char pointer is the user supplied string
  * buffer.
  */
-void prom_getstring(int node, char *prop, char *user_buf, int ubuf_size)
+void prom_getstring(phandle node, char *prop, char *user_buf, int ubuf_size)
 {
         int len;
 
@@ -177,27 +177,14 @@ void prom_getstring(int node, char *prop, char *user_buf, int ubuf_size)
 EXPORT_SYMBOL(prom_getstring);
 
 
-/* Does the device at node 'node' have name 'name'?
- * YES = 1   NO = 0
- */
-int prom_nodematch(int node, char *name)
-{
-        int error;
-
-        static char namebuf[128];
-        error = prom_getproperty(node, "name", namebuf, sizeof(namebuf));
-        if (error == -1) return 0;
-        if(strcmp(namebuf, name) == 0) return 1;
-        return 0;
-}
-
 /* Search siblings at 'node_start' for a node with name
  * 'nodename'.  Return node if successful, zero if not.
  */
-int prom_searchsiblings(int node_start, char *nodename)
+phandle prom_searchsiblings(phandle node_start, char *nodename)
 {
 
-        int thisnode, error;
+        phandle thisnode;
+        int error;
 
         for(thisnode = node_start; thisnode;
             thisnode=prom_getsibling(thisnode)) {
@@ -213,7 +200,7 @@ int prom_searchsiblings(int node_start, char *nodename)
 EXPORT_SYMBOL(prom_searchsiblings);
 
 /* Interal version of nextprop that does not alter return values. */
-char * __prom_nextprop(int node, char * oprop)
+static char *__prom_nextprop(phandle node, char * oprop)
 {
         unsigned long flags;
         char *prop;
@@ -226,35 +213,24 @@ char * __prom_nextprop(int node, char * oprop)
         return prop;
 }
 
-/* Return the first property name for node 'node'. */
-/* buffer is unused argument, but as v9 uses it, we need to have the same interface */
-char * prom_firstprop(int node, char *bufer)
-{
-        if (node == 0 || node == -1)
-                return "";
-
-        return __prom_nextprop(node, "");
-}
-EXPORT_SYMBOL(prom_firstprop);
-
 /* Return the property type string after property type 'oprop'
  * at node 'node' .  Returns empty string if no more
  * property types for this node.
  */
-char * prom_nextprop(int node, char *oprop, char *buffer)
+char *prom_nextprop(phandle node, char *oprop, char *buffer)
 {
-        if (node == 0 || node == -1)
+        if (node == 0 || (s32)node == -1)
                 return "";
 
         return __prom_nextprop(node, oprop);
 }
 EXPORT_SYMBOL(prom_nextprop);
 
-int prom_finddevice(char *name)
+phandle prom_finddevice(char *name)
 {
         char nbuf[128];
         char *s = name, *d;
-        int node = prom_root_node, node2;
+        phandle node = prom_root_node, node2;
         unsigned int which_io, phys_addr;
         struct linux_prom_registers reg[PROMREG_MAX];
 
@@ -277,7 +253,7 @@ int prom_finddevice(char *name)
                                 if (d != s + 3 && (!*d || *d == '/')
                                     && d <= s + 3 + 8) {
                                         node2 = node;
-                                        while (node2 && node2 != -1) {
+                                        while (node2 && (s32)node2 != -1) {
                                                 if (prom_getproperty (node2, "reg", (char *)reg, sizeof (reg)) > 0) {
                                                         if (which_io == reg[0].which_io && phys_addr == reg[0].phys_addr) {
                                                                 node = node2;
@@ -285,7 +261,7 @@ int prom_finddevice(char *name)
                                                         }
                                                 }
                                                 node2 = prom_getsibling(node2);
-                                                if (!node2 || node2 == -1)
+                                                if (!node2 || (s32)node2 == -1)
                                                         break;
                                                 node2 = prom_searchsiblings(prom_getsibling(node2), nbuf);
                                         }
@@ -298,29 +274,18 @@ int prom_finddevice(char *name)
 }
 EXPORT_SYMBOL(prom_finddevice);
 
-int prom_node_has_property(int node, char *prop)
-{
-        char *current_property = "";
-
-        do {
-                current_property = prom_nextprop(node, current_property, NULL);
-                if(!strcmp(current_property, prop))
-                   return 1;
-        } while (*current_property);
-        return 0;
-}
-EXPORT_SYMBOL(prom_node_has_property);
-
 /* Set property 'pname' at node 'node' to value 'value' which has a length
  * of 'size' bytes.  Return the number of bytes the prom accepted.
  */
-int prom_setprop(int node, const char *pname, char *value, int size)
+int prom_setprop(phandle node, const char *pname, char *value, int size)
 {
         unsigned long flags;
         int ret;
 
-        if(size == 0) return 0;
-        if((pname == 0) || (value == 0)) return 0;
+        if (size == 0)
+                return 0;
+        if ((pname == NULL) || (value == NULL))
+                return 0;
         spin_lock_irqsave(&prom_lock, flags);
         ret = prom_nodeops->no_setprop(node, pname, value, size);
         restore_current();
@@ -329,30 +294,16 @@ int prom_setprop(int node, const char *pname, char *value, int size)
 }
 EXPORT_SYMBOL(prom_setprop);
 
-int prom_inst2pkg(int inst)
+phandle prom_inst2pkg(int inst)
 {
-        int node;
+        phandle node;
         unsigned long flags;
         
         spin_lock_irqsave(&prom_lock, flags);
         node = (*romvec->pv_v2devops.v2_inst2pkg)(inst);
         restore_current();
         spin_unlock_irqrestore(&prom_lock, flags);
-        if (node == -1) return 0;
-        return node;
-}
-
-/* Return 'node' assigned to a particular prom 'path'
- * FIXME: Should work for v0 as well
- */
-int prom_pathtoinode(char *path)
-{
-        int node, inst;
-        
-        inst = prom_devopen (path);
-        if (inst == -1) return 0;
-        node = prom_inst2pkg (inst);
-        prom_devclose (inst);
-        if (node == -1) return 0;
+        if ((s32)node == -1)
+                return 0;
         return node;
 }
diff --git a/arch/sparc/prom/tree_64.c b/arch/sparc/prom/tree_64.c
index 9d3f9137a43a..92204c3800b5 100644
--- a/arch/sparc/prom/tree_64.c
+++ b/arch/sparc/prom/tree_64.c
@@ -16,7 +16,7 @@
 #include <asm/oplib.h>
 #include <asm/ldc.h>
 
-static int prom_node_to_node(const char *type, int node)
+static phandle prom_node_to_node(const char *type, phandle node)
 {
         unsigned long args[5];
 
@@ -28,38 +28,38 @@ static int prom_node_to_node(const char *type, int node)
 
         p1275_cmd_direct(args);
 
-        return (int) args[4];
+        return (phandle) args[4];
 }
 
 /* Return the child of node 'node' or zero if no this node has no
  * direct descendent.
  */
-inline int __prom_getchild(int node)
+inline phandle __prom_getchild(phandle node)
 {
         return prom_node_to_node("child", node);
 }
 
-inline int prom_getchild(int node)
+inline phandle prom_getchild(phandle node)
 {
-        int cnode;
+        phandle cnode;
 
-        if (node == -1)
+        if ((s32)node == -1)
                 return 0;
         cnode = __prom_getchild(node);
-        if (cnode == -1)
+        if ((s32)cnode == -1)
                 return 0;
         return cnode;
 }
 EXPORT_SYMBOL(prom_getchild);
 
-inline int prom_getparent(int node)
+inline phandle prom_getparent(phandle node)
 {
-        int cnode;
+        phandle cnode;
 
-        if (node == -1)
+        if ((s32)node == -1)
                 return 0;
         cnode = prom_node_to_node("parent", node);
-        if (cnode == -1)
+        if ((s32)cnode == -1)
                 return 0;
         return cnode;
 }
@@ -67,19 +67,19 @@ inline int prom_getparent(int node)
 /* Return the next sibling of node 'node' or zero if no more siblings
  * at this level of depth in the tree.
  */
-inline int __prom_getsibling(int node)
+inline phandle __prom_getsibling(phandle node)
 {
         return prom_node_to_node(prom_peer_name, node);
 }
 
-inline int prom_getsibling(int node)
+inline phandle prom_getsibling(phandle node)
 {
-        int sibnode;
+        phandle sibnode;
 
-        if (node == -1)
+        if ((s32)node == -1)
                 return 0;
         sibnode = __prom_getsibling(node);
-        if (sibnode == -1)
+        if ((s32)sibnode == -1)
                 return 0;
 
         return sibnode;
@@ -89,7 +89,7 @@ EXPORT_SYMBOL(prom_getsibling);
 /* Return the length in bytes of property 'prop' at node 'node'.
  * Return -1 on error.
  */
-inline int prom_getproplen(int node, const char *prop)
+inline int prom_getproplen(phandle node, const char *prop)
 {
         unsigned long args[6];
 
@@ -113,7 +113,7 @@ EXPORT_SYMBOL(prom_getproplen);
  * 'buffer' which has a size of 'bufsize'.  If the acquisition
  * was successful the length will be returned, else -1 is returned.
  */
-inline int prom_getproperty(int node, const char *prop,
+inline int prom_getproperty(phandle node, const char *prop,
                             char *buffer, int bufsize)
 {
         unsigned long args[8];
@@ -141,7 +141,7 @@ EXPORT_SYMBOL(prom_getproperty);
 /* Acquire an integer property and return its value.  Returns -1
  * on failure.
  */
-inline int prom_getint(int node, const char *prop)
+inline int prom_getint(phandle node, const char *prop)
 {
         int intprop;
 
@@ -156,7 +156,7 @@ EXPORT_SYMBOL(prom_getint);
  * integer.
  */
 
-int prom_getintdefault(int node, const char *property, int deflt)
+int prom_getintdefault(phandle node, const char *property, int deflt)
 {
         int retval;
 
@@ -169,7 +169,7 @@ int prom_getintdefault(int node, const char *property, int deflt)
 EXPORT_SYMBOL(prom_getintdefault);
 
 /* Acquire a boolean property, 1=TRUE 0=FALSE. */
-int prom_getbool(int node, const char *prop)
+int prom_getbool(phandle node, const char *prop)
 {
         int retval;
 
@@ -184,7 +184,8 @@ EXPORT_SYMBOL(prom_getbool);
  * string on error.  The char pointer is the user supplied string
  * buffer.
  */
-void prom_getstring(int node, const char *prop, char *user_buf, int ubuf_size)
+void prom_getstring(phandle node, const char *prop, char *user_buf,
+                int ubuf_size)
 {
         int len;
 
@@ -198,7 +199,7 @@ EXPORT_SYMBOL(prom_getstring);
 /* Does the device at node 'node' have name 'name'?
  * YES = 1   NO = 0
  */
-int prom_nodematch(int node, const char *name)
+int prom_nodematch(phandle node, const char *name)
 {
         char namebuf[128];
         prom_getproperty(node, "name", namebuf, sizeof(namebuf));
@@ -210,10 +211,10 @@ int prom_nodematch(int node, const char *name)
 /* Search siblings at 'node_start' for a node with name
  * 'nodename'.  Return node if successful, zero if not.
  */
-int prom_searchsiblings(int node_start, const char *nodename)
+phandle prom_searchsiblings(phandle node_start, const char *nodename)
 {
-
-        int thisnode, error;
+        phandle thisnode;
+        int error;
         char promlib_buf[128];
 
         for(thisnode = node_start; thisnode;
@@ -234,12 +235,12 @@ static const char *prom_nextprop_name = "nextprop";
 /* Return the first property type for node 'node'.
  * buffer should be at least 32B in length
  */
-inline char *prom_firstprop(int node, char *buffer)
+inline char *prom_firstprop(phandle node, char *buffer)
 {
         unsigned long args[7];
 
         *buffer = 0;
-        if (node == -1)
+        if ((s32)node == -1)
                 return buffer;
 
         args[0] = (unsigned long) prom_nextprop_name;
@@ -260,12 +261,12 @@ EXPORT_SYMBOL(prom_firstprop);
  * at node 'node' .  Returns NULL string if no more
  * property types for this node.
  */
-inline char *prom_nextprop(int node, const char *oprop, char *buffer)
+inline char *prom_nextprop(phandle node, const char *oprop, char *buffer)
 {
         unsigned long args[7];
         char buf[32];
 
-        if (node == -1) {
+        if ((s32)node == -1) {
                 *buffer = 0;
                 return buffer;
         }
@@ -288,8 +289,7 @@ inline char *prom_nextprop(int node, const char *oprop, char *buffer)
 }
 EXPORT_SYMBOL(prom_nextprop);
 
-int
-prom_finddevice(const char *name)
+phandle prom_finddevice(const char *name)
 {
         unsigned long args[5];
 
@@ -307,7 +307,7 @@ prom_finddevice(const char *name)
 }
 EXPORT_SYMBOL(prom_finddevice);
 
-int prom_node_has_property(int node, const char *prop)
+int prom_node_has_property(phandle node, const char *prop)
 {
         char buf [32];
         
@@ -325,7 +325,7 @@ EXPORT_SYMBOL(prom_node_has_property);
  * of 'size' bytes.  Return the number of bytes the prom accepted.
  */
 int
-prom_setprop(int node, const char *pname, char *value, int size)
+prom_setprop(phandle node, const char *pname, char *value, int size)
 {
         unsigned long args[8];
 
@@ -355,10 +355,10 @@ prom_setprop(int node, const char *pname, char *value, int size)
 }
 EXPORT_SYMBOL(prom_setprop);
 
-inline int prom_inst2pkg(int inst)
+inline phandle prom_inst2pkg(int inst)
 {
         unsigned long args[5];
-        int node;
+        phandle node;
         
         args[0] = (unsigned long) "instance-to-package";
         args[1] = 1;
@@ -369,25 +369,7 @@ inline int prom_inst2pkg(int inst)
         p1275_cmd_direct(args);
 
         node = (int) args[4];
-        if (node == -1)
-                return 0;
-        return node;
-}
-
-/* Return 'node' assigned to a particular prom 'path'
- * FIXME: Should work for v0 as well
- */
-int
-prom_pathtoinode(const char *path)
-{
-        int node, inst;
-
-        inst = prom_devopen (path);
-        if (inst == 0)
-                return 0;
-        node = prom_inst2pkg(inst);
-        prom_devclose(inst);
-        if (node == -1)
+        if ((s32)node == -1)
                 return 0;
         return node;
 }