Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

7 files changed, 1259 insertions, 0 deletions

diff --git a/arch/mips/jazz/Makefile b/arch/mips/jazz/Makefile
new file mode 100644
index 0000000000..85749246a6
--- /dev/null
+++ b/arch/mips/jazz/Makefile
@@ -0,0 +1,7 @@
+#
+# Makefile for the Jazz family specific parts of the kernel
+#
+
+obj-y           := int-handler.o irq.o jazzdma.o reset.o setup.o
+
+EXTRA_AFLAGS := $(CFLAGS)
diff --git a/arch/mips/jazz/int-handler.S b/arch/mips/jazz/int-handler.S
new file mode 100644
index 0000000000..4dbcf91db8
--- /dev/null
+++ b/arch/mips/jazz/int-handler.S
@@ -0,0 +1,282 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 1995, 1996, 1997, 1998 by Ralf Baechle and Andreas Busse
+ *
+ * Jazz family specific interrupt stuff
+ *
+ * To do: On Jazz machines we remap some non-ISA interrupts to ISA
+ *        interrupts.  These interrupts should use their own vectors.
+ *        Squeeze the last cycles out of the handlers.  Only a dead
+ *        cycle is a good cycle.
+ */
+#include <asm/asm.h>
+#include <asm/mipsregs.h>
+#include <asm/jazz.h>
+#include <asm/regdef.h>
+#include <asm/stackframe.h>
+
+/*
+ * jazz_handle_int: Interrupt handler for the ACER Pica-61 boards
+ */
+                .set    noreorder
+
+                NESTED(jazz_handle_int, PT_SIZE, ra)
+                .set    noat
+                SAVE_ALL
+                CLI
+                .set    at
+
+                /*
+                 * Get pending interrupts
+                 */
+                mfc0    t0,CP0_CAUSE            # get pending interrupts
+                mfc0    t1,CP0_STATUS           # get enabled interrupts
+                and     t0,t1                   # isolate allowed ones
+                andi    t0,0xff00               # isolate pending bits
+                beqz    t0,3f
+                sll     t0,16                   # delay slot
+
+                /*
+                 * Find irq with highest priority
+                 * FIXME: This is slow - use binary search
+                 */
+                la      t1,ll_vectors
+1:              bltz    t0,2f                   # found pending irq
+                sll     t0,1
+                b       1b
+                subu    t1,PTRSIZE              # delay slot
+
+                /*
+                 * Do the low-level stuff
+                 */
+2:              lw      t0,(t1)
+                jr      t0
+                nop                             # delay slot
+                END(jazz_handle_int)
+
+ll_sw0:         li      s1,~IE_SW0
+                mfc0    t0,CP0_CAUSE
+                and     t0,s1
+                mtc0    t0,CP0_CAUSE
+                PANIC("Unimplemented sw0 handler")
+
+ll_sw1:         li      s1,~IE_SW1
+                mfc0    t0,CP0_CAUSE
+                and     t0,s1
+                mtc0    t0,CP0_CAUSE
+                PANIC("Unimplemented sw1 handler")
+
+ll_local_dma:   li      s1,~IE_IRQ0
+                PANIC("Unimplemented local_dma handler")
+
+ll_local_dev:   lbu     t0,JAZZ_IO_IRQ_SOURCE
+#if PTRSIZE == 8        /* True 64 bit kernel */
+                dsll    t0,1
+#endif
+                .set    reorder
+                LONG_L  t0,local_vector(t0)
+                jr      t0
+                .set    noreorder
+
+/*
+ * The braindead PICA hardware gives us no way to distinguish if we really
+ * received interrupt 7 from the (E)ISA bus or if we just received an
+ * interrupt with no findable cause.  This sometimes happens with braindead
+ * cards.  Oh well - for all the Jazz boxes slots are more or less just
+ * whistles and bells and we're aware of the problem.
+ */
+ll_isa_irq:     lw      a0, JAZZ_EISA_IRQ_ACK
+
+                jal     do_IRQ
+                 move   a1,sp
+
+                j       ret_from_irq
+                nop
+
+/*
+ * Hmm...  This is not just a plain PC clone so the question is
+ * which devices on Jazz machines can generate an (E)ISA NMI?
+ * (Writing to nonexistent memory?)
+ */
+ll_isa_nmi:     li      s1,~IE_IRQ3
+                PANIC("Unimplemented isa_nmi handler")
+
+/*
+ * Timer IRQ - remapped to be more similar to an IBM compatible.
+ *
+ * The timer interrupt is handled specially to ensure that the jiffies
+ * variable is updated at all times.  Specifically, the timer interrupt is
+ * just like the complete handlers except that it is invoked with interrupts
+ * disabled and should never re-enable them.  If other interrupts were
+ * allowed to be processed while the timer interrupt is active, then the
+ * other interrupts would have to avoid using the jiffies variable for delay
+ * and interval timing operations to avoid hanging the system.
+ */
+ll_timer:       lw      zero,JAZZ_TIMER_REGISTER # timer irq cleared on read
+                li      s1,~IE_IRQ4
+
+                li      a0, JAZZ_TIMER_IRQ
+                jal     do_IRQ
+                 move   a1,sp
+
+                mfc0    t0,CP0_STATUS           # disable interrupts again
+                ori     t0,1
+                xori    t0,1
+                mtc0    t0,CP0_STATUS
+
+                j       ret_from_irq
+                 nop
+
+/*
+ * CPU count/compare IRQ (unused)
+ */
+ll_count:       j       ret_from_irq
+                 mtc0   zero,CP0_COMPARE
+
+#if 0
+/*
+ * Call the handler for the interrupt
+ * (Currently unused)
+ */
+call_real:      /*
+                 * temporarily disable interrupt
+                 */
+                mfc0    t2,CP0_STATUS
+                and     t2,s1
+                mtc0    t2,CP0_STATUS
+                nor     s1,zero,s1
+                jal     do_IRQ
+
+                /*
+                 * reenable interrupt
+                 */
+                mfc0    t2,CP0_STATUS
+                or      t2,s1
+                mtc0    t2,CP0_STATUS
+                j       ret_from_irq
+#endif
+
+                .data
+                PTR     ll_sw0                  # SW0
+                PTR     ll_sw1                  # SW1
+                PTR     ll_local_dma            # Local DMA
+                PTR     ll_local_dev            # Local devices
+                PTR     ll_isa_irq              # ISA IRQ
+                PTR     ll_isa_nmi              # ISA NMI
+                PTR     ll_timer                # Timer
+ll_vectors:     PTR     ll_count                # Count/Compare IRQ
+
+                /*
+                 * Interrupt handlers for local devices.
+                 */
+                .text
+                .set    reorder
+loc_no_irq:     PANIC("Unimplemented loc_no_irq handler")
+/*
+ * Parallel port IRQ
+ */
+loc_parallel:   li      s1,~JAZZ_IE_PARALLEL
+                li      a0,JAZZ_PARALLEL_IRQ
+                b       loc_call
+
+/*
+ * Floppy IRQ
+ */
+loc_floppy:     li      s1,~JAZZ_IE_FLOPPY
+                li      a0,JAZZ_FLOPPY_IRQ
+                b       loc_call
+
+/*
+ * Sound IRQ
+ */
+loc_sound:      PANIC("Unimplemented loc_sound handler")
+loc_video:      PANIC("Unimplemented loc_video handler")
+
+/*
+ * Ethernet interrupt handler
+ */
+loc_ethernet:   li      s1,~JAZZ_IE_ETHERNET
+                li      a0,JAZZ_ETHERNET_IRQ
+                b       loc_call
+
+/*
+ * SCSI interrupt handler
+ */
+loc_scsi:       li      s1,~JAZZ_IE_SCSI
+                li      a0,JAZZ_SCSI_IRQ
+                b       loc_call
+
+/*
+ * Keyboard interrupt handler
+ */
+loc_keyboard:   li      s1,~JAZZ_IE_KEYBOARD
+                li      a0,JAZZ_KEYBOARD_IRQ
+                b       loc_call
+
+/*
+ * Mouse interrupt handler
+ */
+loc_mouse:      li      s1,~JAZZ_IE_MOUSE
+                li      a0,JAZZ_MOUSE_IRQ
+                b       loc_call
+
+/*
+ * Serial port 1 IRQ
+ */
+loc_serial1:    li      s1,~JAZZ_IE_SERIAL1
+                li      a0,JAZZ_SERIAL1_IRQ
+                b       loc_call
+
+/*
+ * Serial port 2 IRQ
+ */
+loc_serial2:    li      s1,~JAZZ_IE_SERIAL2
+                li      a0,JAZZ_SERIAL2_IRQ
+                b       loc_call
+
+/*
+ * Call the interrupt handler for an interrupt generated by a
+ * local device.
+ */
+loc_call:       /*
+                 * Temporarily disable interrupt source
+                 */
+                lhu     t2,JAZZ_IO_IRQ_ENABLE
+                and     t2,s1
+                sh      t2,JAZZ_IO_IRQ_ENABLE
+
+                nor     s1,zero,s1
+                jal     do_IRQ
+
+                /*
+                 * Reenable interrupt
+                 */
+                lhu     t2,JAZZ_IO_IRQ_ENABLE
+                or      t2,s1
+                sh      t2,JAZZ_IO_IRQ_ENABLE
+
+                j       ret_from_irq
+
+/*
+ * "Jump extender" to reach spurious_interrupt
+ */
+3:              j       spurious_interrupt
+
+/*
+ * Vectors for interrupts generated by local devices
+ */
+                .data
+local_vector:   PTR     loc_no_irq
+                PTR     loc_parallel
+                PTR     loc_floppy
+                PTR     loc_sound
+                PTR     loc_video
+                PTR     loc_ethernet
+                PTR     loc_scsi
+                PTR     loc_keyboard
+                PTR     loc_mouse
+                PTR     loc_serial1
+                PTR     loc_serial2
diff --git a/arch/mips/jazz/io.c b/arch/mips/jazz/io.c
new file mode 100644
index 0000000000..e86904454c
--- /dev/null
+++ b/arch/mips/jazz/io.c
@@ -0,0 +1,135 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Low level I/O functions for Jazz family machines.
+ *
+ * Copyright (C) 1997 by Ralf Baechle.
+ */
+#include <linux/string.h>
+#include <linux/spinlock.h>
+#include <asm/addrspace.h>
+#include <asm/system.h>
+#include <asm/jazz.h>
+
+/*
+ * Map an 16mb segment of the EISA address space to 0xe3000000;
+ */
+static inline void map_eisa_address(unsigned long address)
+{
+  /* XXX */
+  /* We've got an wired entry in the TLB.  We just need to modify it.
+     fast and clean.  But since we want to get rid of wired entries
+     things are a little bit more complicated ... */
+}
+
+static unsigned char jazz_readb(unsigned long addr)
+{
+        unsigned char res;
+
+        map_eisa_address(addr);
+        addr &= 0xffffff;
+        res = *(volatile unsigned char *) (JAZZ_EISA_BASE + addr);
+
+        return res;
+}
+
+static unsigned short jazz_readw(unsigned long addr)
+{
+        unsigned short res;
+
+        map_eisa_address(addr);
+        addr &= 0xffffff;
+        res = *(volatile unsigned char *) (JAZZ_EISA_BASE + addr);
+
+        return res;
+}
+
+static unsigned int jazz_readl(unsigned long addr)
+{
+        unsigned int res;
+
+        map_eisa_address(addr);
+        addr &= 0xffffff;
+        res = *(volatile unsigned char *) (JAZZ_EISA_BASE + addr);
+
+        return res;
+}
+
+static void jazz_writeb(unsigned char val, unsigned long addr)
+{
+        map_eisa_address(addr);
+        addr &= 0xffffff;
+        *(volatile unsigned char *) (JAZZ_EISA_BASE + addr) = val;
+}
+
+static void jazz_writew(unsigned short val, unsigned long addr)
+{
+        map_eisa_address(addr);
+        addr &= 0xffffff;
+        *(volatile unsigned char *) (JAZZ_EISA_BASE + addr) = val;
+}
+
+static void jazz_writel(unsigned int val, unsigned long addr)
+{
+        map_eisa_address(addr);
+        addr &= 0xffffff;
+        *(volatile unsigned char *) (JAZZ_EISA_BASE + addr) = val;
+}
+
+static void jazz_memset_io(unsigned long addr, int val, unsigned long len)
+{
+        unsigned long waddr;
+
+        waddr = JAZZ_EISA_BASE | (addr & 0xffffff);
+        while(len) {
+                unsigned long fraglen;
+
+                fraglen = (~addr + 1) & 0xffffff;
+                fraglen = (fraglen < len) ? fraglen : len;
+                map_eisa_address(addr);
+                memset((char *)waddr, val, fraglen);
+                addr += fraglen;
+                waddr = waddr + fraglen - 0x1000000;
+                len -= fraglen;
+        }
+}
+
+static void jazz_memcpy_fromio(unsigned long to, unsigned long from, unsigned long len)
+{
+        unsigned long waddr;
+
+        waddr = JAZZ_EISA_BASE | (from & 0xffffff);
+        while(len) {
+                unsigned long fraglen;
+
+                fraglen = (~from + 1) & 0xffffff;
+                fraglen = (fraglen < len) ? fraglen : len;
+                map_eisa_address(from);
+                memcpy((void *)to, (void *)waddr, fraglen);
+                to += fraglen;
+                from += fraglen;
+                waddr = waddr + fraglen - 0x1000000;
+                len -= fraglen;
+        }
+}
+
+static void jazz_memcpy_toio(unsigned long to, unsigned long from, unsigned long len)
+{
+        unsigned long waddr;
+
+        waddr = JAZZ_EISA_BASE | (to & 0xffffff);
+        while(len) {
+                unsigned long fraglen;
+
+                fraglen = (~to + 1) & 0xffffff;
+                fraglen = (fraglen < len) ? fraglen : len;
+                map_eisa_address(to);
+                memcpy((char *)to + JAZZ_EISA_BASE, (void *)from, fraglen);
+                to += fraglen;
+                from += fraglen;
+                waddr = waddr + fraglen - 0x1000000;
+                len -= fraglen;
+        }
+}
diff --git a/arch/mips/jazz/irq.c b/arch/mips/jazz/irq.c
new file mode 100644
index 0000000000..0b608fa98d
--- /dev/null
+++ b/arch/mips/jazz/irq.c
@@ -0,0 +1,100 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 1992 Linus Torvalds
+ * Copyright (C) 1994 - 2001, 2003 Ralf Baechle
+ */
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+
+#include <asm/i8259.h>
+#include <asm/io.h>
+#include <asm/jazz.h>
+
+extern asmlinkage void jazz_handle_int(void);
+
+static DEFINE_SPINLOCK(r4030_lock);
+
+static void enable_r4030_irq(unsigned int irq)
+{
+        unsigned int mask = 1 << (irq - JAZZ_PARALLEL_IRQ);
+        unsigned long flags;
+
+        spin_lock_irqsave(&r4030_lock, flags);
+        mask |= r4030_read_reg16(JAZZ_IO_IRQ_ENABLE);
+        r4030_write_reg16(JAZZ_IO_IRQ_ENABLE, mask);
+        spin_unlock_irqrestore(&r4030_lock, flags);
+}
+
+static unsigned int startup_r4030_irq(unsigned int irq)
+{
+        enable_r4030_irq(irq);
+        return 0; /* never anything pending */
+}
+
+#define shutdown_r4030_irq      disable_r4030_irq
+
+void disable_r4030_irq(unsigned int irq)
+{
+        unsigned int mask = ~(1 << (irq - JAZZ_PARALLEL_IRQ));
+        unsigned long flags;
+
+        spin_lock_irqsave(&r4030_lock, flags);
+        mask &= r4030_read_reg16(JAZZ_IO_IRQ_ENABLE);
+        r4030_write_reg16(JAZZ_IO_IRQ_ENABLE, mask);
+        spin_unlock_irqrestore(&r4030_lock, flags);
+}
+
+#define mask_and_ack_r4030_irq disable_r4030_irq
+
+static void end_r4030_irq(unsigned int irq)
+{
+        if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
+                enable_r4030_irq(irq);
+}
+
+static struct hw_interrupt_type r4030_irq_type = {
+        "R4030",
+        startup_r4030_irq,
+        shutdown_r4030_irq,
+        enable_r4030_irq,
+        disable_r4030_irq,
+        mask_and_ack_r4030_irq,
+        end_r4030_irq,
+        NULL
+};
+
+void __init init_r4030_ints(void)
+{
+        int i;
+
+        for (i = JAZZ_PARALLEL_IRQ; i <= JAZZ_TIMER_IRQ; i++) {
+                irq_desc[i].status     = IRQ_DISABLED;
+                irq_desc[i].action     = 0;
+                irq_desc[i].depth      = 1;
+                irq_desc[i].handler    = &r4030_irq_type;
+        }
+
+        r4030_write_reg16(JAZZ_IO_IRQ_ENABLE, 0);
+        r4030_read_reg16(JAZZ_IO_IRQ_SOURCE);           /* clear pending IRQs */
+        r4030_read_reg32(JAZZ_R4030_INVAL_ADDR);        /* clear error bits */
+}
+
+/*
+ * On systems with i8259-style interrupt controllers we assume for
+ * driver compatibility reasons interrupts 0 - 15 to be the i8259
+ * interrupts even if the hardware uses a different interrupt numbering.
+ */
+void __init arch_init_irq(void)
+{
+        set_except_vector(0, jazz_handle_int);
+
+        init_i8259_irqs();                      /* Integrated i8259  */
+        init_r4030_ints();
+
+        change_c0_status(ST0_IM, IE_IRQ4 | IE_IRQ3 | IE_IRQ2 | IE_IRQ1);
+}
diff --git a/arch/mips/jazz/jazzdma.c b/arch/mips/jazz/jazzdma.c
new file mode 100644
index 0000000000..46e421e143
--- /dev/null
+++ b/arch/mips/jazz/jazzdma.c
@@ -0,0 +1,565 @@
+/*
+ * Mips Jazz DMA controller support
+ * Copyright (C) 1995, 1996 by Andreas Busse
+ *
+ * NOTE: Some of the argument checking could be removed when
+ * things have settled down. Also, instead of returning 0xffffffff
+ * on failure of vdma_alloc() one could leave page #0 unused
+ * and return the more usual NULL pointer as logical address.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/mm.h>
+#include <linux/bootmem.h>
+#include <linux/spinlock.h>
+#include <asm/mipsregs.h>
+#include <asm/jazz.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/dma.h>
+#include <asm/jazzdma.h>
+#include <asm/pgtable.h>
+
+/*
+ * Set this to one to enable additional vdma debug code.
+ */
+#define CONF_DEBUG_VDMA 0
+
+static unsigned long vdma_pagetable_start;
+
+static DEFINE_SPINLOCK(vdma_lock);
+
+/*
+ * Debug stuff
+ */
+#define vdma_debug     ((CONF_DEBUG_VDMA) ? debuglvl : 0)
+
+static int debuglvl = 3;
+
+/*
+ * Initialize the pagetable with a one-to-one mapping of
+ * the first 16 Mbytes of main memory and declare all
+ * entries to be unused. Using this method will at least
+ * allow some early device driver operations to work.
+ */
+static inline void vdma_pgtbl_init(void)
+{
+        VDMA_PGTBL_ENTRY *pgtbl = (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
+        unsigned long paddr = 0;
+        int i;
+
+        for (i = 0; i < VDMA_PGTBL_ENTRIES; i++) {
+                pgtbl[i].frame = paddr;
+                pgtbl[i].owner = VDMA_PAGE_EMPTY;
+                paddr += VDMA_PAGESIZE;
+        }
+}
+
+/*
+ * Initialize the Jazz R4030 dma controller
+ */
+void __init vdma_init(void)
+{
+        /*
+         * Allocate 32k of memory for DMA page tables.  This needs to be page
+         * aligned and should be uncached to avoid cache flushing after every
+         * update.
+         */
+        vdma_pagetable_start = alloc_bootmem_low_pages(VDMA_PGTBL_SIZE);
+        if (!vdma_pagetable_start)
+                BUG();
+        dma_cache_wback_inv(vdma_pagetable_start, VDMA_PGTBL_SIZE);
+        vdma_pagetable_start = KSEG1ADDR(vdma_pagetable_start);
+
+        /*
+         * Clear the R4030 translation table
+         */
+        vdma_pgtbl_init();
+
+        r4030_write_reg32(JAZZ_R4030_TRSTBL_BASE,
+                          CPHYSADDR(vdma_pagetable_start));
+        r4030_write_reg32(JAZZ_R4030_TRSTBL_LIM, VDMA_PGTBL_SIZE);
+        r4030_write_reg32(JAZZ_R4030_TRSTBL_INV, 0);
+
+        printk("VDMA: R4030 DMA pagetables initialized.\n");
+}
+
+/*
+ * Allocate DMA pagetables using a simple first-fit algorithm
+ */
+unsigned long vdma_alloc(unsigned long paddr, unsigned long size)
+{
+        VDMA_PGTBL_ENTRY *entry = (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
+        int first, last, pages, frame, i;
+        unsigned long laddr, flags;
+
+        /* check arguments */
+
+        if (paddr > 0x1fffffff) {
+                if (vdma_debug)
+                        printk("vdma_alloc: Invalid physical address: %08lx\n",
+                               paddr);
+                return VDMA_ERROR;      /* invalid physical address */
+        }
+        if (size > 0x400000 || size == 0) {
+                if (vdma_debug)
+                        printk("vdma_alloc: Invalid size: %08lx\n", size);
+                return VDMA_ERROR;      /* invalid physical address */
+        }
+
+        spin_lock_irqsave(&vdma_lock, flags);
+        /*
+         * Find free chunk
+         */
+        pages = (size + 4095) >> 12;    /* no. of pages to allocate */
+        first = 0;
+        while (1) {
+                while (entry[first].owner != VDMA_PAGE_EMPTY &&
+                       first < VDMA_PGTBL_ENTRIES) first++;
+                if (first + pages > VDMA_PGTBL_ENTRIES) {       /* nothing free */
+                        spin_unlock_irqrestore(&vdma_lock, flags);
+                        return VDMA_ERROR;
+                }
+
+                last = first + 1;
+                while (entry[last].owner == VDMA_PAGE_EMPTY
+                       && last - first < pages)
+                        last++;
+
+                if (last - first == pages)
+                        break;  /* found */
+        }
+
+        /*
+         * Mark pages as allocated
+         */
+        laddr = (first << 12) + (paddr & (VDMA_PAGESIZE - 1));
+        frame = paddr & ~(VDMA_PAGESIZE - 1);
+
+        for (i = first; i < last; i++) {
+                entry[i].frame = frame;
+                entry[i].owner = laddr;
+                frame += VDMA_PAGESIZE;
+        }
+
+        /*
+         * Update translation table and return logical start address
+         */
+        r4030_write_reg32(JAZZ_R4030_TRSTBL_INV, 0);
+
+        if (vdma_debug > 1)
+                printk("vdma_alloc: Allocated %d pages starting from %08lx\n",
+                     pages, laddr);
+
+        if (vdma_debug > 2) {
+                printk("LADDR: ");
+                for (i = first; i < last; i++)
+                        printk("%08x ", i << 12);
+                printk("\nPADDR: ");
+                for (i = first; i < last; i++)
+                        printk("%08x ", entry[i].frame);
+                printk("\nOWNER: ");
+                for (i = first; i < last; i++)
+                        printk("%08x ", entry[i].owner);
+                printk("\n");
+        }
+
+        spin_unlock_irqrestore(&vdma_lock, flags);
+
+        return laddr;
+}
+
+EXPORT_SYMBOL(vdma_alloc);
+
+/*
+ * Free previously allocated dma translation pages
+ * Note that this does NOT change the translation table,
+ * it just marks the free'd pages as unused!
+ */
+int vdma_free(unsigned long laddr)
+{
+        VDMA_PGTBL_ENTRY *pgtbl = (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
+        int i;
+
+        i = laddr >> 12;
+
+        if (pgtbl[i].owner != laddr) {
+                printk
+                    ("vdma_free: trying to free other's dma pages, laddr=%8lx\n",
+                     laddr);
+                return -1;
+        }
+
+        while (pgtbl[i].owner == laddr && i < VDMA_PGTBL_ENTRIES) {
+                pgtbl[i].owner = VDMA_PAGE_EMPTY;
+                i++;
+        }
+
+        if (vdma_debug > 1)
+                printk("vdma_free: freed %ld pages starting from %08lx\n",
+                       i - (laddr >> 12), laddr);
+
+        return 0;
+}
+
+EXPORT_SYMBOL(vdma_free);
+
+/*
+ * Map certain page(s) to another physical address.
+ * Caller must have allocated the page(s) before.
+ */
+int vdma_remap(unsigned long laddr, unsigned long paddr, unsigned long size)
+{
+        VDMA_PGTBL_ENTRY *pgtbl =
+            (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
+        int first, pages, npages;
+
+        if (laddr > 0xffffff) {
+                if (vdma_debug)
+                        printk
+                            ("vdma_map: Invalid logical address: %08lx\n",
+                             laddr);
+                return -EINVAL; /* invalid logical address */
+        }
+        if (paddr > 0x1fffffff) {
+                if (vdma_debug)
+                        printk
+                            ("vdma_map: Invalid physical address: %08lx\n",
+                             paddr);
+                return -EINVAL; /* invalid physical address */
+        }
+
+        npages = pages =
+            (((paddr & (VDMA_PAGESIZE - 1)) + size) >> 12) + 1;
+        first = laddr >> 12;
+        if (vdma_debug)
+                printk("vdma_remap: first=%x, pages=%x\n", first, pages);
+        if (first + pages > VDMA_PGTBL_ENTRIES) {
+                if (vdma_debug)
+                        printk("vdma_alloc: Invalid size: %08lx\n", size);
+                return -EINVAL;
+        }
+
+        paddr &= ~(VDMA_PAGESIZE - 1);
+        while (pages > 0 && first < VDMA_PGTBL_ENTRIES) {
+                if (pgtbl[first].owner != laddr) {
+                        if (vdma_debug)
+                                printk("Trying to remap other's pages.\n");
+                        return -EPERM;  /* not owner */
+                }
+                pgtbl[first].frame = paddr;
+                paddr += VDMA_PAGESIZE;
+                first++;
+                pages--;
+        }
+
+        /*
+         * Update translation table
+         */
+        r4030_write_reg32(JAZZ_R4030_TRSTBL_INV, 0);
+
+        if (vdma_debug > 2) {
+                int i;
+                pages = (((paddr & (VDMA_PAGESIZE - 1)) + size) >> 12) + 1;
+                first = laddr >> 12;
+                printk("LADDR: ");
+                for (i = first; i < first + pages; i++)
+                        printk("%08x ", i << 12);
+                printk("\nPADDR: ");
+                for (i = first; i < first + pages; i++)
+                        printk("%08x ", pgtbl[i].frame);
+                printk("\nOWNER: ");
+                for (i = first; i < first + pages; i++)
+                        printk("%08x ", pgtbl[i].owner);
+                printk("\n");
+        }
+
+        return 0;
+}
+
+/*
+ * Translate a physical address to a logical address.
+ * This will return the logical address of the first
+ * match.
+ */
+unsigned long vdma_phys2log(unsigned long paddr)
+{
+        int i;
+        int frame;
+        VDMA_PGTBL_ENTRY *pgtbl =
+            (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
+
+        frame = paddr & ~(VDMA_PAGESIZE - 1);
+
+        for (i = 0; i < VDMA_PGTBL_ENTRIES; i++) {
+                if (pgtbl[i].frame == frame)
+                        break;
+        }
+
+        if (i == VDMA_PGTBL_ENTRIES)
+                return ~0UL;
+
+        return (i << 12) + (paddr & (VDMA_PAGESIZE - 1));
+}
+
+EXPORT_SYMBOL(vdma_phys2log);
+
+/*
+ * Translate a logical DMA address to a physical address
+ */
+unsigned long vdma_log2phys(unsigned long laddr)
+{
+        VDMA_PGTBL_ENTRY *pgtbl =
+            (VDMA_PGTBL_ENTRY *) vdma_pagetable_start;
+
+        return pgtbl[laddr >> 12].frame + (laddr & (VDMA_PAGESIZE - 1));
+}
+
+EXPORT_SYMBOL(vdma_log2phys);
+
+/*
+ * Print DMA statistics
+ */
+void vdma_stats(void)
+{
+        int i;
+
+        printk("vdma_stats: CONFIG: %08x\n",
+               r4030_read_reg32(JAZZ_R4030_CONFIG));
+        printk("R4030 translation table base: %08x\n",
+               r4030_read_reg32(JAZZ_R4030_TRSTBL_BASE));
+        printk("R4030 translation table limit: %08x\n",
+               r4030_read_reg32(JAZZ_R4030_TRSTBL_LIM));
+        printk("vdma_stats: INV_ADDR: %08x\n",
+               r4030_read_reg32(JAZZ_R4030_INV_ADDR));
+        printk("vdma_stats: R_FAIL_ADDR: %08x\n",
+               r4030_read_reg32(JAZZ_R4030_R_FAIL_ADDR));
+        printk("vdma_stats: M_FAIL_ADDR: %08x\n",
+               r4030_read_reg32(JAZZ_R4030_M_FAIL_ADDR));
+        printk("vdma_stats: IRQ_SOURCE: %08x\n",
+               r4030_read_reg32(JAZZ_R4030_IRQ_SOURCE));
+        printk("vdma_stats: I386_ERROR: %08x\n",
+               r4030_read_reg32(JAZZ_R4030_I386_ERROR));
+        printk("vdma_chnl_modes:   ");
+        for (i = 0; i < 8; i++)
+                printk("%04x ",
+                       (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_MODE +
+                                                   (i << 5)));
+        printk("\n");
+        printk("vdma_chnl_enables: ");
+        for (i = 0; i < 8; i++)
+                printk("%04x ",
+                       (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
+                                                   (i << 5)));
+        printk("\n");
+}
+
+/*
+ * DMA transfer functions
+ */
+
+/*
+ * Enable a DMA channel. Also clear any error conditions.
+ */
+void vdma_enable(int channel)
+{
+        int status;
+
+        if (vdma_debug)
+                printk("vdma_enable: channel %d\n", channel);
+
+        /*
+         * Check error conditions first
+         */
+        status = r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5));
+        if (status & 0x400)
+                printk("VDMA: Channel %d: Address error!\n", channel);
+        if (status & 0x200)
+                printk("VDMA: Channel %d: Memory error!\n", channel);
+
+        /*
+         * Clear all interrupt flags
+         */
+        r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
+                          r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
+                                           (channel << 5)) | R4030_TC_INTR
+                          | R4030_MEM_INTR | R4030_ADDR_INTR);
+
+        /*
+         * Enable the desired channel
+         */
+        r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
+                          r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
+                                           (channel << 5)) |
+                          R4030_CHNL_ENABLE);
+}
+
+EXPORT_SYMBOL(vdma_enable);
+
+/*
+ * Disable a DMA channel
+ */
+void vdma_disable(int channel)
+{
+        if (vdma_debug) {
+                int status =
+                    r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
+                                     (channel << 5));
+
+                printk("vdma_disable: channel %d\n", channel);
+                printk("VDMA: channel %d status: %04x (%s) mode: "
+                       "%02x addr: %06x count: %06x\n",
+                       channel, status,
+                       ((status & 0x600) ? "ERROR" : "OK"),
+                       (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_MODE +
+                                                   (channel << 5)),
+                       (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_ADDR +
+                                                   (channel << 5)),
+                       (unsigned) r4030_read_reg32(JAZZ_R4030_CHNL_COUNT +
+                                                   (channel << 5)));
+        }
+
+        r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
+                          r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
+                                           (channel << 5)) &
+                          ~R4030_CHNL_ENABLE);
+
+        /*
+         * After disabling a DMA channel a remote bus register should be
+         * read to ensure that the current DMA acknowledge cycle is completed.
+         */
+        *((volatile unsigned int *) JAZZ_DUMMY_DEVICE);
+}
+
+EXPORT_SYMBOL(vdma_disable);
+
+/*
+ * Set DMA mode. This function accepts the mode values used
+ * to set a PC-style DMA controller. For the SCSI and FDC
+ * channels, we also set the default modes each time we're
+ * called.
+ * NOTE: The FAST and BURST dma modes are supported by the
+ * R4030 Rev. 2 and PICA chipsets only. I leave them disabled
+ * for now.
+ */
+void vdma_set_mode(int channel, int mode)
+{
+        if (vdma_debug)
+                printk("vdma_set_mode: channel %d, mode 0x%x\n", channel,
+                       mode);
+
+        switch (channel) {
+        case JAZZ_SCSI_DMA:     /* scsi */
+                r4030_write_reg32(JAZZ_R4030_CHNL_MODE + (channel << 5),
+/*                        R4030_MODE_FAST | */
+/*                        R4030_MODE_BURST | */
+                                  R4030_MODE_INTR_EN |
+                                  R4030_MODE_WIDTH_16 |
+                                  R4030_MODE_ATIME_80);
+                break;
+
+        case JAZZ_FLOPPY_DMA:   /* floppy */
+                r4030_write_reg32(JAZZ_R4030_CHNL_MODE + (channel << 5),
+/*                        R4030_MODE_FAST | */
+/*                        R4030_MODE_BURST | */
+                                  R4030_MODE_INTR_EN |
+                                  R4030_MODE_WIDTH_8 |
+                                  R4030_MODE_ATIME_120);
+                break;
+
+        case JAZZ_AUDIOL_DMA:
+        case JAZZ_AUDIOR_DMA:
+                printk("VDMA: Audio DMA not supported yet.\n");
+                break;
+
+        default:
+                printk
+                    ("VDMA: vdma_set_mode() called with unsupported channel %d!\n",
+                     channel);
+        }
+
+        switch (mode) {
+        case DMA_MODE_READ:
+                r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
+                                  r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
+                                                   (channel << 5)) &
+                                  ~R4030_CHNL_WRITE);
+                break;
+
+        case DMA_MODE_WRITE:
+                r4030_write_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5),
+                                  r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE +
+                                                   (channel << 5)) |
+                                  R4030_CHNL_WRITE);
+                break;
+
+        default:
+                printk
+                    ("VDMA: vdma_set_mode() called with unknown dma mode 0x%x\n",
+                     mode);
+        }
+}
+
+EXPORT_SYMBOL(vdma_set_mode);
+
+/*
+ * Set Transfer Address
+ */
+void vdma_set_addr(int channel, long addr)
+{
+        if (vdma_debug)
+                printk("vdma_set_addr: channel %d, addr %lx\n", channel,
+                       addr);
+
+        r4030_write_reg32(JAZZ_R4030_CHNL_ADDR + (channel << 5), addr);
+}
+
+EXPORT_SYMBOL(vdma_set_addr);
+
+/*
+ * Set Transfer Count
+ */
+void vdma_set_count(int channel, int count)
+{
+        if (vdma_debug)
+                printk("vdma_set_count: channel %d, count %08x\n", channel,
+                       (unsigned) count);
+
+        r4030_write_reg32(JAZZ_R4030_CHNL_COUNT + (channel << 5), count);
+}
+
+EXPORT_SYMBOL(vdma_set_count);
+
+/*
+ * Get Residual
+ */
+int vdma_get_residue(int channel)
+{
+        int residual;
+
+        residual = r4030_read_reg32(JAZZ_R4030_CHNL_COUNT + (channel << 5));
+
+        if (vdma_debug)
+                printk("vdma_get_residual: channel %d: residual=%d\n",
+                       channel, residual);
+
+        return residual;
+}
+
+/*
+ * Get DMA channel enable register
+ */
+int vdma_get_enable(int channel)
+{
+        int enable;
+
+        enable = r4030_read_reg32(JAZZ_R4030_CHNL_ENABLE + (channel << 5));
+
+        if (vdma_debug)
+                printk("vdma_get_enable: channel %d: enable=%d\n", channel,
+                       enable);
+
+        return enable;
+}
diff --git a/arch/mips/jazz/reset.c b/arch/mips/jazz/reset.c
new file mode 100644
index 0000000000..2a9754750b
--- /dev/null
+++ b/arch/mips/jazz/reset.c
@@ -0,0 +1,69 @@
+/*
+ * Reset a Jazz machine.
+ *
+ * We don't trust the firmware so we do it the classic way by poking and
+ * stabbing at the keyboard controller ...
+ */
+#include <linux/jiffies.h>
+#include <asm/jazz.h>
+#include <asm/io.h>
+#include <asm/system.h>
+#include <asm/reboot.h>
+#include <asm/delay.h>
+
+#define KBD_STAT_IBF            0x02    /* Keyboard input buffer full */
+
+static void jazz_write_output(unsigned char val)
+{
+        int status;
+
+        do {
+                status = jazz_kh->command;
+        } while (status & KBD_STAT_IBF);
+        jazz_kh->data = val;
+}
+
+static void jazz_write_command(unsigned char val)
+{
+        int status;
+
+        do {
+                status = jazz_kh->command;
+        } while (status & KBD_STAT_IBF);
+        jazz_kh->command = val;
+}
+
+static unsigned char jazz_read_status(void)
+{
+        return jazz_kh->command;
+}
+
+static inline void kb_wait(void)
+{
+        unsigned long start = jiffies;
+        unsigned long timeout = start + HZ/2;
+
+        do {
+                if (! (jazz_read_status() & 0x02))
+                        return;
+        } while (time_before_eq(jiffies, timeout));
+}
+
+void jazz_machine_restart(char *command)
+{
+        while(1) {
+                kb_wait();
+                jazz_write_command (0xd1);
+                kb_wait();
+                jazz_write_output (0x00);
+        }
+}
+
+void jazz_machine_halt(void)
+{
+}
+
+void jazz_machine_power_off(void)
+{
+        /* Jazz machines don't have a software power switch */
+}
diff --git a/arch/mips/jazz/setup.c b/arch/mips/jazz/setup.c
new file mode 100644
index 0000000000..fccb06fe20
--- /dev/null
+++ b/arch/mips/jazz/setup.c
@@ -0,0 +1,101 @@
+/*
+ * Setup pointers to hardware-dependent routines.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 1996, 1997, 1998, 2001 by Ralf Baechle
+ * Copyright (C) 2001 MIPS Technologies, Inc.
+ */
+#include <linux/config.h>
+#include <linux/eisa.h>
+#include <linux/hdreg.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/mm.h>
+#include <linux/console.h>
+#include <linux/fb.h>
+#include <linux/ide.h>
+#include <asm/bootinfo.h>
+#include <asm/irq.h>
+#include <asm/jazz.h>
+#include <asm/jazzdma.h>
+#include <asm/ptrace.h>
+#include <asm/reboot.h>
+#include <asm/io.h>
+#include <asm/pgtable.h>
+#include <asm/time.h>
+#include <asm/traps.h>
+
+extern asmlinkage void jazz_handle_int(void);
+
+extern void jazz_machine_restart(char *command);
+extern void jazz_machine_halt(void);
+extern void jazz_machine_power_off(void);
+
+static void __init jazz_time_init(struct irqaction *irq)
+{
+        /* set the clock to 100 Hz */
+        r4030_write_reg32(JAZZ_TIMER_INTERVAL, 9);
+        setup_irq(JAZZ_TIMER_IRQ, irq);
+}
+
+static struct resource jazz_io_resources[] = {
+        { "dma1", 0x00, 0x1f, IORESOURCE_BUSY },
+        { "timer", 0x40, 0x5f, IORESOURCE_BUSY },
+        { "dma page reg", 0x80, 0x8f, IORESOURCE_BUSY },
+        { "dma2", 0xc0, 0xdf, IORESOURCE_BUSY },
+};
+
+static void __init jazz_setup(void)
+{
+        int i;
+
+        /* Map 0xe0000000 -> 0x0:800005C0, 0xe0010000 -> 0x1:30000580 */
+        add_wired_entry (0x02000017, 0x03c00017, 0xe0000000, PM_64K);
+
+        /* Map 0xe2000000 -> 0x0:900005C0, 0xe3010000 -> 0x0:910005C0 */
+        add_wired_entry (0x02400017, 0x02440017, 0xe2000000, PM_16M);
+
+        /* Map 0xe4000000 -> 0x0:600005C0, 0xe4100000 -> 400005C0 */
+        add_wired_entry (0x01800017, 0x01000017, 0xe4000000, PM_4M);
+
+        set_io_port_base(JAZZ_PORT_BASE);
+#ifdef CONFIG_EISA
+        if (mips_machtype == MACH_MIPS_MAGNUM_4000)
+                EISA_bus = 1;
+#endif
+        isa_slot_offset = 0xe3000000;
+
+        /* request I/O space for devices used on all i[345]86 PCs */
+        for (i = 0; i < ARRAY_SIZE(jazz_io_resources); i++)
+                request_resource(&ioport_resource, jazz_io_resources + i);
+
+        board_timer_setup = jazz_time_init;
+        /* The RTC is outside the port address space */
+
+        _machine_restart = jazz_machine_restart;
+        _machine_halt = jazz_machine_halt;
+        _machine_power_off = jazz_machine_power_off;
+
+#warning "Somebody should check if screen_info is ok for Jazz."
+
+        screen_info = (struct screen_info) {
+                0, 0,           /* orig-x, orig-y */
+                0,              /* unused */
+                0,              /* orig_video_page */
+                0,              /* orig_video_mode */
+                160,            /* orig_video_cols */
+                0, 0, 0,        /* unused, ega_bx, unused */
+                64,             /* orig_video_lines */
+                0,              /* orig_video_isVGA */
+                16              /* orig_video_points */
+        };
+
+        vdma_init();
+}
+
+early_initcall(jazz_setup);