Merge branch 'linus' into oprofile

Conflicts:
	arch/x86/kernel/apic_32.c
	include/linux/pci_ids.h

9 files changed, 161 insertions, 383 deletions

diff --git a/arch/sparc/mm/Makefile b/arch/sparc/mm/Makefile
index 109c8b22cb38..ea88955d97ff 100644
--- a/arch/sparc/mm/Makefile
+++ b/arch/sparc/mm/Makefile
@@ -3,13 +3,8 @@
 
 EXTRA_AFLAGS := -ansi
 
-obj-y    := fault.o init.o loadmmu.o generic.o extable.o btfixup.o
-
-ifeq ($(CONFIG_SUN4),y)
-obj-y    += nosrmmu.o
-else
-obj-y    += srmmu.o iommu.o io-unit.o hypersparc.o viking.o tsunami.o swift.o
-endif
+obj-y   := fault.o init.o loadmmu.o generic.o extable.o btfixup.o \
+            srmmu.o iommu.o io-unit.o hypersparc.o viking.o tsunami.o swift.o
 
 ifdef CONFIG_HIGHMEM
 obj-y   += highmem.o
diff --git a/arch/sparc/mm/btfixup.c b/arch/sparc/mm/btfixup.c
index a312d127d47a..5175ac2f4820 100644
--- a/arch/sparc/mm/btfixup.c
+++ b/arch/sparc/mm/btfixup.c
@@ -20,11 +20,7 @@
 
 extern char *srmmu_name;
 static char version[] __initdata = "Boot time fixup v1.6. 4/Mar/98 Jakub Jelinek (jj@ultra.linux.cz). Patching kernel for ";
-#ifdef CONFIG_SUN4
-static char str_sun4c[] __initdata = "sun4\n";
-#else
 static char str_sun4c[] __initdata = "sun4c\n";
-#endif
 static char str_srmmu[] __initdata = "srmmu[%s]/";
 static char str_iommu[] __initdata = "iommu\n";
 static char str_iounit[] __initdata = "io-unit\n";
@@ -86,7 +82,7 @@ void __init btfixup(void)
         if (!visited) {
                 visited++;
                 printk(version);
-                if (ARCH_SUN4C_SUN4)
+                if (ARCH_SUN4C)
                         printk(str_sun4c);
                 else {
                         printk(str_srmmu, srmmu_name);
diff --git a/arch/sparc/mm/fault.c b/arch/sparc/mm/fault.c
index 3604c2e86709..a507e1174662 100644
--- a/arch/sparc/mm/fault.c
+++ b/arch/sparc/mm/fault.c
@@ -191,7 +191,7 @@ 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.
          */
-        if (!ARCH_SUN4C_SUN4 && address >= TASK_SIZE)
+        if (!ARCH_SUN4C && address >= TASK_SIZE)
                 goto vmalloc_fault;
 
         info.si_code = SEGV_MAPERR;
diff --git a/arch/sparc/mm/init.c b/arch/sparc/mm/init.c
index e103f1bb3777..677c1e187a23 100644
--- a/arch/sparc/mm/init.c
+++ b/arch/sparc/mm/init.c
@@ -23,6 +23,7 @@
 #include <linux/highmem.h>
 #include <linux/bootmem.h>
 #include <linux/pagemap.h>
+#include <linux/poison.h>
 
 #include <asm/system.h>
 #include <asm/vac-ops.h>
@@ -480,6 +481,7 @@ void free_initmem (void)
         for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
                 struct page *p;
 
+                memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE);
                 p = virt_to_page(addr);
 
                 ClearPageReserved(p);
@@ -488,20 +490,26 @@ void free_initmem (void)
                 totalram_pages++;
                 num_physpages++;
         }
-        printk (KERN_INFO "Freeing unused kernel memory: %dk freed\n", (&__init_end - &__init_begin) >> 10);
+        printk(KERN_INFO "Freeing unused kernel memory: %dk freed\n",
+                (&__init_end - &__init_begin) >> 10);
 }
 
 #ifdef CONFIG_BLK_DEV_INITRD
 void free_initrd_mem(unsigned long start, unsigned long end)
 {
         if (start < end)
-                printk (KERN_INFO "Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
+                printk(KERN_INFO "Freeing initrd memory: %ldk freed\n",
+                        (end - start) >> 10);
         for (; start < end; start += PAGE_SIZE) {
-                struct page *p = virt_to_page(start);
+                struct page *p;
+
+                memset((void *)start, POISON_FREE_INITMEM, PAGE_SIZE);
+                p = virt_to_page(start);
 
                 ClearPageReserved(p);
                 init_page_count(p);
                 __free_page(p);
+                totalram_pages++;
                 num_physpages++;
         }
 }
diff --git a/arch/sparc/mm/io-unit.c b/arch/sparc/mm/io-unit.c
index f167835db3df..daadf5f88050 100644
--- a/arch/sparc/mm/io-unit.c
+++ b/arch/sparc/mm/io-unit.c
@@ -12,10 +12,11 @@
 #include <linux/highmem.h>      /* pte_offset_map => kmap_atomic */
 #include <linux/bitops.h>
 #include <linux/scatterlist.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
-#include <asm/sbus.h>
 #include <asm/io.h>
 #include <asm/io-unit.h>
 #include <asm/mxcc.h>
@@ -34,13 +35,10 @@
 #define IOPERM        (IOUPTE_CACHE | IOUPTE_WRITE | IOUPTE_VALID)
 #define MKIOPTE(phys) __iopte((((phys)>>4) & IOUPTE_PAGE) | IOPERM)
 
-void __init
-iounit_init(int sbi_node, int io_node, struct sbus_bus *sbus)
+static void __init iounit_iommu_init(struct of_device *op)
 {
-        iopte_t *xpt, *xptend;
         struct iounit_struct *iounit;
-        struct linux_prom_registers iommu_promregs[PROMREG_MAX];
-        struct resource r;
+        iopte_t *xpt, *xptend;
 
         iounit = kzalloc(sizeof(struct iounit_struct), GFP_ATOMIC);
         if (!iounit) {
@@ -55,18 +53,13 @@ iounit_init(int sbi_node, int io_node, struct sbus_bus *sbus)
         iounit->rotor[1] = IOUNIT_BMAP2_START;
         iounit->rotor[2] = IOUNIT_BMAPM_START;
 
-        xpt = NULL;
-        if(prom_getproperty(sbi_node, "reg", (void *) iommu_promregs,
-                            sizeof(iommu_promregs)) != -1) {
-                prom_apply_generic_ranges(io_node, 0, iommu_promregs, 3);
-                memset(&r, 0, sizeof(r));
-                r.flags = iommu_promregs[2].which_io;
-                r.start = iommu_promregs[2].phys_addr;
-                xpt = (iopte_t *) sbus_ioremap(&r, 0, PAGE_SIZE * 16, "XPT");
+        xpt = of_ioremap(&op->resource[2], 0, PAGE_SIZE * 16, "XPT");
+        if (!xpt) {
+                prom_printf("SUN4D: Cannot map External Page Table.");
+                prom_halt();
         }
-        if(!xpt) panic("Cannot map External Page Table.");
         
-        sbus->ofdev.dev.archdata.iommu = iounit;
+        op->dev.archdata.iommu = iounit;
         iounit->page_table = xpt;
         spin_lock_init(&iounit->lock);
         
@@ -75,6 +68,25 @@ iounit_init(int sbi_node, int io_node, struct sbus_bus *sbus)
                 iopte_val(*xpt++) = 0;
 }
 
+static int __init iounit_init(void)
+{
+        extern void sun4d_init_sbi_irq(void);
+        struct device_node *dp;
+
+        for_each_node_by_name(dp, "sbi") {
+                struct of_device *op = of_find_device_by_node(dp);
+
+                iounit_iommu_init(op);
+                of_propagate_archdata(op);
+        }
+
+        sun4d_init_sbi_irq();
+
+        return 0;
+}
+
+subsys_initcall(iounit_init);
+
 /* One has to hold iounit->lock to call this */
 static unsigned long iounit_get_area(struct iounit_struct *iounit, unsigned long vaddr, int size)
 {
@@ -124,10 +136,10 @@ nexti:	scan = find_next_zero_bit(iounit->bmap, limit, scan);
         return vaddr;
 }
 
-static __u32 iounit_get_scsi_one(char *vaddr, unsigned long len, struct sbus_bus *sbus)
+static __u32 iounit_get_scsi_one(struct device *dev, char *vaddr, unsigned long len)
 {
+        struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long ret, flags;
-        struct iounit_struct *iounit = sbus->ofdev.dev.archdata.iommu;
         
         spin_lock_irqsave(&iounit->lock, flags);
         ret = iounit_get_area(iounit, (unsigned long)vaddr, len);
@@ -135,10 +147,10 @@ static __u32 iounit_get_scsi_one(char *vaddr, unsigned long len, struct sbus_bus
         return ret;
 }
 
-static void iounit_get_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
+static void iounit_get_scsi_sgl(struct device *dev, struct scatterlist *sg, int sz)
 {
+        struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long flags;
-        struct iounit_struct *iounit = sbus->ofdev.dev.archdata.iommu;
 
         /* FIXME: Cache some resolved pages - often several sg entries are to the same page */
         spin_lock_irqsave(&iounit->lock, flags);
@@ -151,10 +163,10 @@ static void iounit_get_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus
         spin_unlock_irqrestore(&iounit->lock, flags);
 }
 
-static void iounit_release_scsi_one(__u32 vaddr, unsigned long len, struct sbus_bus *sbus)
+static void iounit_release_scsi_one(struct device *dev, __u32 vaddr, unsigned long len)
 {
+        struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long flags;
-        struct iounit_struct *iounit = sbus->ofdev.dev.archdata.iommu;
         
         spin_lock_irqsave(&iounit->lock, flags);
         len = ((vaddr & ~PAGE_MASK) + len + (PAGE_SIZE-1)) >> PAGE_SHIFT;
@@ -165,11 +177,11 @@ static void iounit_release_scsi_one(__u32 vaddr, unsigned long len, struct sbus_
         spin_unlock_irqrestore(&iounit->lock, flags);
 }
 
-static void iounit_release_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
+static void iounit_release_scsi_sgl(struct device *dev, struct scatterlist *sg, int sz)
 {
+        struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long flags;
         unsigned long vaddr, len;
-        struct iounit_struct *iounit = sbus->ofdev.dev.archdata.iommu;
 
         spin_lock_irqsave(&iounit->lock, flags);
         while (sz != 0) {
@@ -185,12 +197,12 @@ static void iounit_release_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_
 }
 
 #ifdef CONFIG_SBUS
-static int iounit_map_dma_area(dma_addr_t *pba, unsigned long va, __u32 addr, int len)
+static int iounit_map_dma_area(struct device *dev, dma_addr_t *pba, unsigned long va, __u32 addr, int len)
 {
+        struct iounit_struct *iounit = dev->archdata.iommu;
         unsigned long page, end;
         pgprot_t dvma_prot;
         iopte_t *iopte;
-        struct sbus_bus *sbus;
 
         *pba = addr;
 
@@ -212,12 +224,8 @@ static int iounit_map_dma_area(dma_addr_t *pba, unsigned long va, __u32 addr, in
                         
                         i = ((addr - IOUNIT_DMA_BASE) >> PAGE_SHIFT);
 
-                        for_each_sbus(sbus) {
-                                struct iounit_struct *iounit = sbus->ofdev.dev.archdata.iommu;
-
-                                iopte = (iopte_t *)(iounit->page_table + i);
-                                *iopte = MKIOPTE(__pa(page));
-                        }
+                        iopte = (iopte_t *)(iounit->page_table + i);
+                        *iopte = MKIOPTE(__pa(page));
                 }
                 addr += PAGE_SIZE;
                 va += PAGE_SIZE;
@@ -228,23 +236,10 @@ static int iounit_map_dma_area(dma_addr_t *pba, unsigned long va, __u32 addr, in
         return 0;
 }
 
-static void iounit_unmap_dma_area(unsigned long addr, int len)
+static void iounit_unmap_dma_area(struct device *dev, unsigned long addr, int len)
 {
         /* XXX Somebody please fill this in */
 }
-
-/* XXX We do not pass sbus device here, bad. */
-static struct page *iounit_translate_dvma(unsigned long addr)
-{
-        struct sbus_bus *sbus = sbus_root;      /* They are all the same */
-        struct iounit_struct *iounit = sbus->ofdev.dev.archdata.iommu;
-        int i;
-        iopte_t *iopte;
-
-        i = ((addr - IOUNIT_DMA_BASE) >> PAGE_SHIFT);
-        iopte = (iopte_t *)(iounit->page_table + i);
-        return pfn_to_page(iopte_val(*iopte) >> (PAGE_SHIFT-4)); /* XXX sun4d guru, help */
-}
 #endif
 
 static char *iounit_lockarea(char *vaddr, unsigned long len)
@@ -271,54 +266,5 @@ void __init ld_mmu_iounit(void)
 #ifdef CONFIG_SBUS
         BTFIXUPSET_CALL(mmu_map_dma_area, iounit_map_dma_area, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(mmu_unmap_dma_area, iounit_unmap_dma_area, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(mmu_translate_dvma, iounit_translate_dvma, BTFIXUPCALL_NORM);
 #endif
 }
-
-__u32 iounit_map_dma_init(struct sbus_bus *sbus, int size)
-{
-        int i, j, k, npages;
-        unsigned long rotor, scan, limit;
-        unsigned long flags;
-        __u32 ret;
-        struct iounit_struct *iounit = sbus->ofdev.dev.archdata.iommu;
-
-        npages = (size + (PAGE_SIZE-1)) >> PAGE_SHIFT;
-        i = 0x0213;
-        spin_lock_irqsave(&iounit->lock, flags);
-next:   j = (i & 15);
-        rotor = iounit->rotor[j - 1];
-        limit = iounit->limit[j];
-        scan = rotor;
-nexti:  scan = find_next_zero_bit(iounit->bmap, limit, scan);
-        if (scan + npages > limit) {
-                if (limit != rotor) {
-                        limit = rotor;
-                        scan = iounit->limit[j - 1];
-                        goto nexti;
-                }
-                i >>= 4;
-                if (!(i & 15))
-                        panic("iounit_map_dma_init: Couldn't find free iopte slots for %d bytes\n", size);
-                goto next;
-        }
-        for (k = 1, scan++; k < npages; k++)
-                if (test_bit(scan++, iounit->bmap))
-                        goto nexti;
-        iounit->rotor[j - 1] = (scan < limit) ? scan : iounit->limit[j - 1];
-        scan -= npages;
-        ret = IOUNIT_DMA_BASE + (scan << PAGE_SHIFT);
-        for (k = 0; k < npages; k++, scan++)
-                set_bit(scan, iounit->bmap);
-        spin_unlock_irqrestore(&iounit->lock, flags);
-        return ret;
-}
-
-__u32 iounit_map_dma_page(__u32 vaddr, void *addr, struct sbus_bus *sbus)
-{
-        int scan = (vaddr - IOUNIT_DMA_BASE) >> PAGE_SHIFT;
-        struct iounit_struct *iounit = sbus->ofdev.dev.archdata.iommu;
-        
-        iounit->page_table[scan] = MKIOPTE(__pa(((unsigned long)addr) & PAGE_MASK));
-        return vaddr + (((unsigned long)addr) & ~PAGE_MASK);
-}
diff --git a/arch/sparc/mm/iommu.c b/arch/sparc/mm/iommu.c
index 4b934270f05e..e7a499e3aa3c 100644
--- a/arch/sparc/mm/iommu.c
+++ b/arch/sparc/mm/iommu.c
@@ -13,10 +13,11 @@
 #include <linux/slab.h>
 #include <linux/highmem.h>      /* pte_offset_map => kmap_atomic */
 #include <linux/scatterlist.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
 
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
-#include <asm/sbus.h>
 #include <asm/io.h>
 #include <asm/mxcc.h>
 #include <asm/mbus.h>
@@ -55,30 +56,21 @@ static pgprot_t dvma_prot;		/* Consistent mapping pte flags */
 #define IOPERM        (IOPTE_CACHE | IOPTE_WRITE | IOPTE_VALID)
 #define MKIOPTE(pfn, perm) (((((pfn)<<8) & IOPTE_PAGE) | (perm)) & ~IOPTE_WAZ)
 
-void __init
-iommu_init(int iommund, struct sbus_bus *sbus)
+static void __init sbus_iommu_init(struct of_device *op)
 {
-        unsigned int impl, vers;
-        unsigned long tmp;
         struct iommu_struct *iommu;
-        struct linux_prom_registers iommu_promregs[PROMREG_MAX];
-        struct resource r;
+        unsigned int impl, vers;
         unsigned long *bitmap;
+        unsigned long tmp;
 
         iommu = kmalloc(sizeof(struct iommu_struct), GFP_ATOMIC);
         if (!iommu) {
                 prom_printf("Unable to allocate iommu structure\n");
                 prom_halt();
         }
-        iommu->regs = NULL;
-        if (prom_getproperty(iommund, "reg", (void *) iommu_promregs,
-                         sizeof(iommu_promregs)) != -1) {
-                memset(&r, 0, sizeof(r));
-                r.flags = iommu_promregs[0].which_io;
-                r.start = iommu_promregs[0].phys_addr;
-                iommu->regs = (struct iommu_regs *)
-                        sbus_ioremap(&r, 0, PAGE_SIZE * 3, "iommu_regs");
-        }
+
+        iommu->regs = of_ioremap(&op->resource[0], 0, PAGE_SIZE * 3,
+                                 "iommu_regs");
         if (!iommu->regs) {
                 prom_printf("Cannot map IOMMU registers\n");
                 prom_halt();
@@ -128,13 +120,29 @@ iommu_init(int iommund, struct sbus_bus *sbus)
         else
                 iommu->usemap.num_colors = 1;
 
-        printk("IOMMU: impl %d vers %d table 0x%p[%d B] map [%d b]\n",
-            impl, vers, iommu->page_table,
-            (int)(IOMMU_NPTES*sizeof(iopte_t)), (int)IOMMU_NPTES);
+        printk(KERN_INFO "IOMMU: impl %d vers %d table 0x%p[%d B] map [%d b]\n",
+               impl, vers, iommu->page_table,
+               (int)(IOMMU_NPTES*sizeof(iopte_t)), (int)IOMMU_NPTES);
+
+        op->dev.archdata.iommu = iommu;
+}
+
+static int __init iommu_init(void)
+{
+        struct device_node *dp;
+
+        for_each_node_by_name(dp, "iommu") {
+                struct of_device *op = of_find_device_by_node(dp);
+
+                sbus_iommu_init(op);
+                of_propagate_archdata(op);
+        }
 
-        sbus->ofdev.dev.archdata.iommu = iommu;
+        return 0;
 }
 
+subsys_initcall(iommu_init);
+
 /* This begs to be btfixup-ed by srmmu. */
 /* Flush the iotlb entries to ram. */
 /* This could be better if we didn't have to flush whole pages. */
@@ -164,9 +172,9 @@ static void iommu_flush_iotlb(iopte_t *iopte, unsigned int niopte)
         }
 }
 
-static u32 iommu_get_one(struct page *page, int npages, struct sbus_bus *sbus)
+static u32 iommu_get_one(struct device *dev, struct page *page, int npages)
 {
-        struct iommu_struct *iommu = sbus->ofdev.dev.archdata.iommu;
+        struct iommu_struct *iommu = dev->archdata.iommu;
         int ioptex;
         iopte_t *iopte, *iopte0;
         unsigned int busa, busa0;
@@ -194,8 +202,7 @@ static u32 iommu_get_one(struct page *page, int npages, struct sbus_bus *sbus)
         return busa0;
 }
 
-static u32 iommu_get_scsi_one(char *vaddr, unsigned int len,
-    struct sbus_bus *sbus)
+static u32 iommu_get_scsi_one(struct device *dev, char *vaddr, unsigned int len)
 {
         unsigned long off;
         int npages;
@@ -205,22 +212,22 @@ static u32 iommu_get_scsi_one(char *vaddr, unsigned int len,
         off = (unsigned long)vaddr & ~PAGE_MASK;
         npages = (off + len + PAGE_SIZE-1) >> PAGE_SHIFT;
         page = virt_to_page((unsigned long)vaddr & PAGE_MASK);
-        busa = iommu_get_one(page, npages, sbus);
+        busa = iommu_get_one(dev, page, npages);
         return busa + off;
 }
 
-static __u32 iommu_get_scsi_one_noflush(char *vaddr, unsigned long len, struct sbus_bus *sbus)
+static __u32 iommu_get_scsi_one_noflush(struct device *dev, char *vaddr, unsigned long len)
 {
-        return iommu_get_scsi_one(vaddr, len, sbus);
+        return iommu_get_scsi_one(dev, vaddr, len);
 }
 
-static __u32 iommu_get_scsi_one_gflush(char *vaddr, unsigned long len, struct sbus_bus *sbus)
+static __u32 iommu_get_scsi_one_gflush(struct device *dev, char *vaddr, unsigned long len)
 {
         flush_page_for_dma(0);
-        return iommu_get_scsi_one(vaddr, len, sbus);
+        return iommu_get_scsi_one(dev, vaddr, len);
 }
 
-static __u32 iommu_get_scsi_one_pflush(char *vaddr, unsigned long len, struct sbus_bus *sbus)
+static __u32 iommu_get_scsi_one_pflush(struct device *dev, char *vaddr, unsigned long len)
 {
         unsigned long page = ((unsigned long) vaddr) & PAGE_MASK;
 
@@ -228,23 +235,23 @@ static __u32 iommu_get_scsi_one_pflush(char *vaddr, unsigned long len, struct sb
                 flush_page_for_dma(page);
                 page += PAGE_SIZE;
         }
-        return iommu_get_scsi_one(vaddr, len, sbus);
+        return iommu_get_scsi_one(dev, vaddr, len);
 }
 
-static void iommu_get_scsi_sgl_noflush(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
+static void iommu_get_scsi_sgl_noflush(struct device *dev, struct scatterlist *sg, int sz)
 {
         int n;
 
         while (sz != 0) {
                 --sz;
                 n = (sg->length + sg->offset + PAGE_SIZE-1) >> PAGE_SHIFT;
-                sg->dvma_address = iommu_get_one(sg_page(sg), n, sbus) + sg->offset;
+                sg->dvma_address = iommu_get_one(dev, sg_page(sg), n) + sg->offset;
                 sg->dvma_length = (__u32) sg->length;
                 sg = sg_next(sg);
         }
 }
 
-static void iommu_get_scsi_sgl_gflush(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
+static void iommu_get_scsi_sgl_gflush(struct device *dev, struct scatterlist *sg, int sz)
 {
         int n;
 
@@ -252,13 +259,13 @@ static void iommu_get_scsi_sgl_gflush(struct scatterlist *sg, int sz, struct sbu
         while (sz != 0) {
                 --sz;
                 n = (sg->length + sg->offset + PAGE_SIZE-1) >> PAGE_SHIFT;
-                sg->dvma_address = iommu_get_one(sg_page(sg), n, sbus) + sg->offset;
+                sg->dvma_address = iommu_get_one(dev, sg_page(sg), n) + sg->offset;
                 sg->dvma_length = (__u32) sg->length;
                 sg = sg_next(sg);
         }
 }
 
-static void iommu_get_scsi_sgl_pflush(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
+static void iommu_get_scsi_sgl_pflush(struct device *dev, struct scatterlist *sg, int sz)
 {
         unsigned long page, oldpage = 0;
         int n, i;
@@ -283,15 +290,15 @@ static void iommu_get_scsi_sgl_pflush(struct scatterlist *sg, int sz, struct sbu
                         }
                 }
 
-                sg->dvma_address = iommu_get_one(sg_page(sg), n, sbus) + sg->offset;
+                sg->dvma_address = iommu_get_one(dev, sg_page(sg), n) + sg->offset;
                 sg->dvma_length = (__u32) sg->length;
                 sg = sg_next(sg);
         }
 }
 
-static void iommu_release_one(u32 busa, int npages, struct sbus_bus *sbus)
+static void iommu_release_one(struct device *dev, u32 busa, int npages)
 {
-        struct iommu_struct *iommu = sbus->ofdev.dev.archdata.iommu;
+        struct iommu_struct *iommu = dev->archdata.iommu;
         int ioptex;
         int i;
 
@@ -305,17 +312,17 @@ static void iommu_release_one(u32 busa, int npages, struct sbus_bus *sbus)
         bit_map_clear(&iommu->usemap, ioptex, npages);
 }
 
-static void iommu_release_scsi_one(__u32 vaddr, unsigned long len, struct sbus_bus *sbus)
+static void iommu_release_scsi_one(struct device *dev, __u32 vaddr, unsigned long len)
 {
         unsigned long off;
         int npages;
 
         off = vaddr & ~PAGE_MASK;
         npages = (off + len + PAGE_SIZE-1) >> PAGE_SHIFT;
-        iommu_release_one(vaddr & PAGE_MASK, npages, sbus);
+        iommu_release_one(dev, vaddr & PAGE_MASK, npages);
 }
 
-static void iommu_release_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
+static void iommu_release_scsi_sgl(struct device *dev, struct scatterlist *sg, int sz)
 {
         int n;
 
@@ -323,18 +330,18 @@ static void iommu_release_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_b
                 --sz;
 
                 n = (sg->length + sg->offset + PAGE_SIZE-1) >> PAGE_SHIFT;
-                iommu_release_one(sg->dvma_address & PAGE_MASK, n, sbus);
+                iommu_release_one(dev, sg->dvma_address & PAGE_MASK, n);
                 sg->dvma_address = 0x21212121;
                 sg = sg_next(sg);
         }
 }
 
 #ifdef CONFIG_SBUS
-static int iommu_map_dma_area(dma_addr_t *pba, unsigned long va,
-    unsigned long addr, int len)
+static int iommu_map_dma_area(struct device *dev, dma_addr_t *pba, unsigned long va,
+                              unsigned long addr, int len)
 {
+        struct iommu_struct *iommu = dev->archdata.iommu;
         unsigned long page, end;
-        struct iommu_struct *iommu = sbus_root->ofdev.dev.archdata.iommu;
         iopte_t *iopte = iommu->page_table;
         iopte_t *first;
         int ioptex;
@@ -397,9 +404,9 @@ static int iommu_map_dma_area(dma_addr_t *pba, unsigned long va,
         return 0;
 }
 
-static void iommu_unmap_dma_area(unsigned long busa, int len)
+static void iommu_unmap_dma_area(struct device *dev, unsigned long busa, int len)
 {
-        struct iommu_struct *iommu = sbus_root->ofdev.dev.archdata.iommu;
+        struct iommu_struct *iommu = dev->archdata.iommu;
         iopte_t *iopte = iommu->page_table;
         unsigned long end;
         int ioptex = (busa - iommu->start) >> PAGE_SHIFT;
@@ -417,15 +424,6 @@ static void iommu_unmap_dma_area(unsigned long busa, int len)
         iommu_invalidate(iommu->regs);
         bit_map_clear(&iommu->usemap, ioptex, len >> PAGE_SHIFT);
 }
-
-static struct page *iommu_translate_dvma(unsigned long busa)
-{
-        struct iommu_struct *iommu = sbus_root->ofdev.dev.archdata.iommu;
-        iopte_t *iopte = iommu->page_table;
-
-        iopte += ((busa - iommu->start) >> PAGE_SHIFT);
-        return pfn_to_page((iopte_val(*iopte) & IOPTE_PAGE) >> (PAGE_SHIFT-4));
-}
 #endif
 
 static char *iommu_lockarea(char *vaddr, unsigned long len)
@@ -461,7 +459,6 @@ void __init ld_mmu_iommu(void)
 #ifdef CONFIG_SBUS
         BTFIXUPSET_CALL(mmu_map_dma_area, iommu_map_dma_area, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(mmu_unmap_dma_area, iommu_unmap_dma_area, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(mmu_translate_dvma, iommu_translate_dvma, BTFIXUPCALL_NORM);
 #endif
 
         if (viking_mxcc_present || srmmu_modtype == HyperSparc) {
diff --git a/arch/sparc/mm/nosrmmu.c b/arch/sparc/mm/nosrmmu.c
deleted file mode 100644
index 3701f70fc30a..000000000000
--- a/arch/sparc/mm/nosrmmu.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * nosrmmu.c: This file is a bunch of dummies for sun4 compiles, 
- *         so that it does not need srmmu and avoid ifdefs.
- *
- * Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
- */
-
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/init.h>
-#include <asm/mbus.h>
-#include <asm/sbus.h>
-
-static char shouldnothappen[] __initdata = "SUN4 kernel can only run on SUN4\n";
-
-enum mbus_module srmmu_modtype;
-void *srmmu_nocache_pool;
-
-int vac_cache_size = 0;
-
-static void __init should_not_happen(void)
-{
-        prom_printf(shouldnothappen);
-        prom_halt();
-}
-
-void __init srmmu_frob_mem_map(unsigned long start_mem)
-{
-        should_not_happen();
-}
-
-unsigned long __init srmmu_paging_init(unsigned long start_mem, unsigned long end_mem)
-{
-        should_not_happen();
-        return 0;
-}
-
-void __init ld_mmu_srmmu(void)
-{
-        should_not_happen();
-}
-
-void srmmu_mapioaddr(unsigned long physaddr, unsigned long virt_addr, int bus_type, int rdonly)
-{
-}
-
-void srmmu_unmapioaddr(unsigned long virt_addr)
-{
-}
-
-__u32 iounit_map_dma_init(struct sbus_bus *sbus, int size)
-{
-        return 0;
-}
-
-__u32 iounit_map_dma_page(__u32 vaddr, void *addr, struct sbus_bus *sbus)
-{
-        return 0;
-}
diff --git a/arch/sparc/mm/srmmu.c b/arch/sparc/mm/srmmu.c
index ee30462598fc..6a5d7cabc044 100644
--- a/arch/sparc/mm/srmmu.c
+++ b/arch/sparc/mm/srmmu.c
@@ -31,7 +31,6 @@
 #include <asm/mbus.h>
 #include <asm/cache.h>
 #include <asm/oplib.h>
-#include <asm/sbus.h>
 #include <asm/asi.h>
 #include <asm/msi.h>
 #include <asm/mmu_context.h>
diff --git a/arch/sparc/mm/sun4c.c b/arch/sparc/mm/sun4c.c
index d1782f6368be..fe65aeeb3947 100644
--- a/arch/sparc/mm/sun4c.c
+++ b/arch/sparc/mm/sun4c.c
@@ -31,7 +31,6 @@
 #include <asm/oplib.h>
 #include <asm/openprom.h>
 #include <asm/mmu_context.h>
-#include <asm/sun4paddr.h>
 #include <asm/highmem.h>
 #include <asm/btfixup.h>
 #include <asm/cacheflush.h>
@@ -52,15 +51,11 @@ extern int num_segmaps, num_contexts;
 
 extern unsigned long page_kernel;
 
-#ifdef CONFIG_SUN4
-#define SUN4C_VAC_SIZE sun4c_vacinfo.num_bytes
-#else
 /* That's it, we prom_halt() on sun4c if the cache size is something other than 65536.
  * So let's save some cycles and just use that everywhere except for that bootup
  * sanity check.
  */
 #define SUN4C_VAC_SIZE 65536
-#endif
 
 #define SUN4C_KERNEL_BUCKETS 32
 
@@ -285,75 +280,32 @@ void __init sun4c_probe_vac(void)
 {
         sun4c_disable_vac();
 
-        if (ARCH_SUN4) {
-                switch (idprom->id_machtype) {
-
-                case (SM_SUN4|SM_4_110):
-                        sun4c_vacinfo.type = VAC_NONE;
-                        sun4c_vacinfo.num_bytes = 0;
-                        sun4c_vacinfo.linesize = 0;
-                        sun4c_vacinfo.do_hwflushes = 0;
-                        prom_printf("No VAC. Get some bucks and buy a real computer.");
-                        prom_halt();
-                        break;
-
-                case (SM_SUN4|SM_4_260):
-                        sun4c_vacinfo.type = VAC_WRITE_BACK;
-                        sun4c_vacinfo.num_bytes = 128 * 1024;
-                        sun4c_vacinfo.linesize = 16;
-                        sun4c_vacinfo.do_hwflushes = 0;
-                        break;
-
-                case (SM_SUN4|SM_4_330):
-                        sun4c_vacinfo.type = VAC_WRITE_THROUGH;
-                        sun4c_vacinfo.num_bytes = 128 * 1024;
-                        sun4c_vacinfo.linesize = 16;
-                        sun4c_vacinfo.do_hwflushes = 0;
-                        break;
-
-                case (SM_SUN4|SM_4_470):
-                        sun4c_vacinfo.type = VAC_WRITE_BACK;
-                        sun4c_vacinfo.num_bytes = 128 * 1024;
-                        sun4c_vacinfo.linesize = 32;
-                        sun4c_vacinfo.do_hwflushes = 0;
-                        break;
-
-                default:
-                        prom_printf("Cannot initialize VAC - weird sun4 model idprom->id_machtype = %d", idprom->id_machtype);
-                        prom_halt();
-                };
+        if ((idprom->id_machtype == (SM_SUN4C | SM_4C_SS1)) ||
+            (idprom->id_machtype == (SM_SUN4C | SM_4C_SS1PLUS))) {
+                /* PROM on SS1 lacks this info, to be super safe we
+                 * hard code it here since this arch is cast in stone.
+                 */
+                sun4c_vacinfo.num_bytes = 65536;
+                sun4c_vacinfo.linesize = 16;
         } else {
-                sun4c_vacinfo.type = VAC_WRITE_THROUGH;
+                sun4c_vacinfo.num_bytes =
+                 prom_getintdefault(prom_root_node, "vac-size", 65536);
+                sun4c_vacinfo.linesize =
+                 prom_getintdefault(prom_root_node, "vac-linesize", 16);
+        }
+        sun4c_vacinfo.do_hwflushes =
+         prom_getintdefault(prom_root_node, "vac-hwflush", 0);
 
-                if ((idprom->id_machtype == (SM_SUN4C | SM_4C_SS1)) ||
-                    (idprom->id_machtype == (SM_SUN4C | SM_4C_SS1PLUS))) {
-                        /* PROM on SS1 lacks this info, to be super safe we
-                         * hard code it here since this arch is cast in stone.
-                         */
-                        sun4c_vacinfo.num_bytes = 65536;
-                        sun4c_vacinfo.linesize = 16;
-                } else {
-                        sun4c_vacinfo.num_bytes =
-                         prom_getintdefault(prom_root_node, "vac-size", 65536);
-                        sun4c_vacinfo.linesize =
-                         prom_getintdefault(prom_root_node, "vac-linesize", 16);
-                }
+        if (sun4c_vacinfo.do_hwflushes == 0)
                 sun4c_vacinfo.do_hwflushes =
-                 prom_getintdefault(prom_root_node, "vac-hwflush", 0);
-
-                if (sun4c_vacinfo.do_hwflushes == 0)
-                        sun4c_vacinfo.do_hwflushes =
-                         prom_getintdefault(prom_root_node, "vac_hwflush", 0);
+                 prom_getintdefault(prom_root_node, "vac_hwflush", 0);
 
-                if (sun4c_vacinfo.num_bytes != 65536) {
-                        prom_printf("WEIRD Sun4C VAC cache size, "
-                                    "tell sparclinux@vger.kernel.org");
-                        prom_halt();
-                }
+        if (sun4c_vacinfo.num_bytes != 65536) {
+                prom_printf("WEIRD Sun4C VAC cache size, "
+                            "tell sparclinux@vger.kernel.org");
+                prom_halt();
         }
 
-        sun4c_vacinfo.num_lines =
-                (sun4c_vacinfo.num_bytes / sun4c_vacinfo.linesize);
         switch (sun4c_vacinfo.linesize) {
         case 16:
                 sun4c_vacinfo.log2lsize = 4;
@@ -447,49 +399,18 @@ static void __init patch_kernel_fault_handler(void)
 
 static void __init sun4c_probe_mmu(void)
 {
-        if (ARCH_SUN4) {
-                switch (idprom->id_machtype) {
-                case (SM_SUN4|SM_4_110):
-                        prom_printf("No support for 4100 yet\n");
-                        prom_halt();
-                        num_segmaps = 256;
-                        num_contexts = 8;
-                        break;
-
-                case (SM_SUN4|SM_4_260):
-                        /* should be 512 segmaps. when it get fixed */
-                        num_segmaps = 256;
-                        num_contexts = 16;
-                        break;
-
-                case (SM_SUN4|SM_4_330):
-                        num_segmaps = 256;
-                        num_contexts = 16;
-                        break;
-
-                case (SM_SUN4|SM_4_470):
-                        /* should be 1024 segmaps. when it get fixed */
-                        num_segmaps = 256;
-                        num_contexts = 64;
-                        break;
-                default:
-                        prom_printf("Invalid SUN4 model\n");
-                        prom_halt();
-                };
+        if ((idprom->id_machtype == (SM_SUN4C | SM_4C_SS1)) ||
+            (idprom->id_machtype == (SM_SUN4C | SM_4C_SS1PLUS))) {
+                /* Hardcode these just to be safe, PROM on SS1 does
+                * not have this info available in the root node.
+                */
+                num_segmaps = 128;
+                num_contexts = 8;
         } else {
-                if ((idprom->id_machtype == (SM_SUN4C | SM_4C_SS1)) ||
-                    (idprom->id_machtype == (SM_SUN4C | SM_4C_SS1PLUS))) {
-                        /* Hardcode these just to be safe, PROM on SS1 does
-                        * not have this info available in the root node.
-                        */
-                        num_segmaps = 128;
-                        num_contexts = 8;
-                } else {
-                        num_segmaps =
-                            prom_getintdefault(prom_root_node, "mmu-npmg", 128);
-                        num_contexts =
-                            prom_getintdefault(prom_root_node, "mmu-nctx", 0x8);
-                }
+                num_segmaps =
+                    prom_getintdefault(prom_root_node, "mmu-npmg", 128);
+                num_contexts =
+                    prom_getintdefault(prom_root_node, "mmu-nctx", 0x8);
         }
         patch_kernel_fault_handler();
 }
@@ -501,18 +422,14 @@ void __init sun4c_probe_memerr_reg(void)
         int node;
         struct linux_prom_registers regs[1];
 
-        if (ARCH_SUN4) {
-                sun4c_memerr_reg = ioremap(sun4_memreg_physaddr, PAGE_SIZE);
-        } else {
-                node = prom_getchild(prom_root_node);
-                node = prom_searchsiblings(prom_root_node, "memory-error");
-                if (!node)
-                        return;
-                if (prom_getproperty(node, "reg", (char *)regs, sizeof(regs)) <= 0)
-                        return;
-                /* hmm I think regs[0].which_io is zero here anyways */
-                sun4c_memerr_reg = ioremap(regs[0].phys_addr, regs[0].reg_size);
-        }
+        node = prom_getchild(prom_root_node);
+        node = prom_searchsiblings(prom_root_node, "memory-error");
+        if (!node)
+                return;
+        if (prom_getproperty(node, "reg", (char *)regs, sizeof(regs)) <= 0)
+                return;
+        /* hmm I think regs[0].which_io is zero here anyways */
+        sun4c_memerr_reg = ioremap(regs[0].phys_addr, regs[0].reg_size);
 }
 
 static inline void sun4c_init_ss2_cache_bug(void)
@@ -521,7 +438,6 @@ static inline void sun4c_init_ss2_cache_bug(void)
 
         if ((idprom->id_machtype == (SM_SUN4C | SM_4C_SS2)) ||
             (idprom->id_machtype == (SM_SUN4C | SM_4C_IPX)) ||
-            (idprom->id_machtype == (SM_SUN4 | SM_4_330)) ||
             (idprom->id_machtype == (SM_SUN4C | SM_4C_ELC))) {
                 /* Whee.. */
                 printk("SS2 cache bug detected, uncaching trap table page\n");
@@ -532,8 +448,8 @@ static inline void sun4c_init_ss2_cache_bug(void)
 }
 
 /* Addr is always aligned on a page boundary for us already. */
-static int sun4c_map_dma_area(dma_addr_t *pba, unsigned long va,
-    unsigned long addr, int len)
+static int sun4c_map_dma_area(struct device *dev, dma_addr_t *pba, unsigned long va,
+                              unsigned long addr, int len)
 {
         unsigned long page, end;
 
@@ -555,14 +471,7 @@ static int sun4c_map_dma_area(dma_addr_t *pba, unsigned long va,
         return 0;
 }
 
-static struct page *sun4c_translate_dvma(unsigned long busa)
-{
-        /* Fortunately for us, bus_addr == uncached_virt in sun4c. */
-        unsigned long pte = sun4c_get_pte(busa);
-        return pfn_to_page(pte & SUN4C_PFN_MASK);
-}
-
-static void sun4c_unmap_dma_area(unsigned long busa, int len)
+static void sun4c_unmap_dma_area(struct device *dev, unsigned long busa, int len)
 {
         /* Fortunately for us, bus_addr == uncached_virt in sun4c. */
         /* XXX Implement this */
@@ -624,11 +533,7 @@ static inline void sun4c_init_map_kernelprom(unsigned long kernel_end)
 {
         unsigned long vaddr;
         unsigned char pseg, ctx;
-#ifdef CONFIG_SUN4
-        /* sun4/110 and 260 have no kadb. */
-        if ((idprom->id_machtype != (SM_SUN4 | SM_4_260)) && 
-            (idprom->id_machtype != (SM_SUN4 | SM_4_110))) {
-#endif
+
         for (vaddr = KADB_DEBUGGER_BEGVM;
              vaddr < LINUX_OPPROM_ENDVM;
              vaddr += SUN4C_REAL_PGDIR_SIZE) {
@@ -640,9 +545,7 @@ static inline void sun4c_init_map_kernelprom(unsigned long kernel_end)
                         fix_permissions(vaddr, _SUN4C_PAGE_PRIV, 0);
                 }
         }
-#ifdef CONFIG_SUN4
-        }
-#endif
+
         for (vaddr = KERNBASE; vaddr < kernel_end; vaddr += SUN4C_REAL_PGDIR_SIZE) {
                 pseg = sun4c_get_segmap(vaddr);
                 mmu_entry_pool[pseg].locked = 1;
@@ -1048,14 +951,10 @@ static struct thread_info *sun4c_alloc_thread_info(void)
          * so we must flush the cache to guarantee consistency.
          */
         sun4c_flush_page(pages);
-#ifndef CONFIG_SUN4     
         sun4c_flush_page(pages + PAGE_SIZE);
-#endif
 
         sun4c_put_pte(addr, BUCKET_PTE(pages));
-#ifndef CONFIG_SUN4     
         sun4c_put_pte(addr + PAGE_SIZE, BUCKET_PTE(pages + PAGE_SIZE));
-#endif
 
 #ifdef CONFIG_DEBUG_STACK_USAGE
         memset((void *)addr, 0, PAGE_SIZE << THREAD_INFO_ORDER);
@@ -1072,13 +971,11 @@ static void sun4c_free_thread_info(struct thread_info *ti)
 
         /* We are deleting a mapping, so the flush here is mandatory. */
         sun4c_flush_page(tiaddr);
-#ifndef CONFIG_SUN4     
         sun4c_flush_page(tiaddr + PAGE_SIZE);
-#endif
+
         sun4c_put_pte(tiaddr, 0);
-#ifndef CONFIG_SUN4     
         sun4c_put_pte(tiaddr + PAGE_SIZE, 0);
-#endif
+
         sun4c_bucket[entry] = BUCKET_EMPTY;
         if (entry < sun4c_lowbucket_avail)
                 sun4c_lowbucket_avail = entry;
@@ -1211,7 +1108,7 @@ static void sun4c_unlockarea(char *vaddr, unsigned long size)
  * by implication and fool the page locking code above
  * if passed to by mistake.
  */
-static __u32 sun4c_get_scsi_one(char *bufptr, unsigned long len, struct sbus_bus *sbus)
+static __u32 sun4c_get_scsi_one(struct device *dev, char *bufptr, unsigned long len)
 {
         unsigned long page;
 
@@ -1223,7 +1120,7 @@ static __u32 sun4c_get_scsi_one(char *bufptr, unsigned long len, struct sbus_bus
         return (__u32)sun4c_lockarea(bufptr, len);
 }
 
-static void sun4c_get_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
+static void sun4c_get_scsi_sgl(struct device *dev, struct scatterlist *sg, int sz)
 {
         while (sz != 0) {
                 --sz;
@@ -1233,14 +1130,14 @@ static void sun4c_get_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus *
         }
 }
 
-static void sun4c_release_scsi_one(__u32 bufptr, unsigned long len, struct sbus_bus *sbus)
+static void sun4c_release_scsi_one(struct device *dev, __u32 bufptr, unsigned long len)
 {
         if (bufptr < sun4c_iobuffer_start)
                 return; /* On kernel stack or similar, see above */
         sun4c_unlockarea((char *)bufptr, len);
 }
 
-static void sun4c_release_scsi_sgl(struct scatterlist *sg, int sz, struct sbus_bus *sbus)
+static void sun4c_release_scsi_sgl(struct device *dev, struct scatterlist *sg, int sz)
 {
         while (sz != 0) {
                 --sz;
@@ -2263,7 +2160,6 @@ void __init ld_mmu_sun4c(void)
 
         BTFIXUPSET_CALL(mmu_map_dma_area, sun4c_map_dma_area, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(mmu_unmap_dma_area, sun4c_unmap_dma_area, BTFIXUPCALL_NORM);
-        BTFIXUPSET_CALL(mmu_translate_dvma, sun4c_translate_dvma, BTFIXUPCALL_NORM);
 
         BTFIXUPSET_CALL(sparc_mapiorange, sun4c_mapiorange, BTFIXUPCALL_NORM);
         BTFIXUPSET_CALL(sparc_unmapiorange, sun4c_unmapiorange, BTFIXUPCALL_NORM);