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!

9 files changed, 3142 insertions, 0 deletions

diff --git a/arch/sh64/mm/Makefile b/arch/sh64/mm/Makefile
new file mode 100644
index 000000000000..ff19378ac90a
--- /dev/null
+++ b/arch/sh64/mm/Makefile
@@ -0,0 +1,44 @@
+#
+# 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) 2000, 2001  Paolo Alberelli
+# Copyright (C) 2003, 2004  Paul Mundt
+#
+# Makefile for the sh64-specific parts of the Linux memory manager.
+#
+# Note! Dependencies are done automagically by 'make dep', which also
+# removes any old dependencies. DON'T put your own dependencies here
+# unless it's something special (ie not a .c file).
+#
+
+obj-y := init.o fault.o ioremap.o extable.o cache.o tlbmiss.o tlb.o
+
+obj-$(CONFIG_HUGETLB_PAGE)      += hugetlbpage.o
+
+# Special flags for tlbmiss.o.  This puts restrictions on the number of
+# caller-save registers that the compiler can target when building this file.
+# This is required because the code is called from a context in entry.S where
+# very few registers have been saved in the exception handler (for speed
+# reasons).
+# The caller save registers that have been saved and which can be used are
+# r2,r3,r4,r5 : argument passing
+# r15, r18 : SP and LINK
+# tr0-4 : allow all caller-save TR's.  The compiler seems to be able to make
+#         use of them, so it's probably beneficial to performance to save them
+#         and have them available for it.
+#
+# The resources not listed below are callee save, i.e. the compiler is free to
+# use any of them and will spill them to the stack itself.
+
+CFLAGS_tlbmiss.o += -ffixed-r7 \
+        -ffixed-r8 -ffixed-r9 -ffixed-r10 -ffixed-r11 -ffixed-r12 \
+        -ffixed-r13 -ffixed-r14 -ffixed-r16 -ffixed-r17 -ffixed-r19 \
+        -ffixed-r20 -ffixed-r21 -ffixed-r22 -ffixed-r23 \
+        -ffixed-r24 -ffixed-r25 -ffixed-r26 -ffixed-r27 \
+        -ffixed-r36 -ffixed-r37 -ffixed-r38 -ffixed-r39 -ffixed-r40 \
+        -ffixed-r41 -ffixed-r42 -ffixed-r43  \
+        -ffixed-r60 -ffixed-r61 -ffixed-r62 \
+        -fomit-frame-pointer
+
diff --git a/arch/sh64/mm/cache.c b/arch/sh64/mm/cache.c
new file mode 100644
index 000000000000..3b87e25ea773
--- /dev/null
+++ b/arch/sh64/mm/cache.c
@@ -0,0 +1,1041 @@
+/*
+ * 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.
+ *
+ * arch/sh64/mm/cache.c
+ *
+ * Original version Copyright (C) 2000, 2001  Paolo Alberelli
+ * Second version Copyright (C) benedict.gaster@superh.com 2002
+ * Third version Copyright Richard.Curnow@superh.com 2003
+ * Hacks to third version Copyright (C) 2003 Paul Mundt
+ */
+
+/****************************************************************************/
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/mman.h>
+#include <linux/mm.h>
+#include <linux/threads.h>
+#include <asm/page.h>
+#include <asm/pgtable.h>
+#include <asm/processor.h>
+#include <asm/cache.h>
+#include <asm/tlb.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/mmu_context.h>
+#include <asm/pgalloc.h> /* for flush_itlb_range */
+
+#include <linux/proc_fs.h>
+
+/* This function is in entry.S */
+extern unsigned long switch_and_save_asid(unsigned long new_asid);
+
+/* Wired TLB entry for the D-cache */
+static unsigned long long dtlb_cache_slot;
+
+/**
+ * sh64_cache_init()
+ *
+ * This is pretty much just a straightforward clone of the SH
+ * detect_cpu_and_cache_system().
+ *
+ * This function is responsible for setting up all of the cache
+ * info dynamically as well as taking care of CPU probing and
+ * setting up the relevant subtype data.
+ *
+ * FIXME: For the time being, we only really support the SH5-101
+ * out of the box, and don't support dynamic probing for things
+ * like the SH5-103 or even cut2 of the SH5-101. Implement this
+ * later!
+ */
+int __init sh64_cache_init(void)
+{
+        /*
+         * First, setup some sane values for the I-cache.
+         */
+        cpu_data->icache.ways           = 4;
+        cpu_data->icache.sets           = 256;
+        cpu_data->icache.linesz         = L1_CACHE_BYTES;
+
+        /*
+         * FIXME: This can probably be cleaned up a bit as well.. for example,
+         * do we really need the way shift _and_ the way_step_shift ?? Judging
+         * by the existing code, I would guess no.. is there any valid reason
+         * why we need to be tracking this around?
+         */
+        cpu_data->icache.way_shift      = 13;
+        cpu_data->icache.entry_shift    = 5;
+        cpu_data->icache.set_shift      = 4;
+        cpu_data->icache.way_step_shift = 16;
+        cpu_data->icache.asid_shift     = 2;
+
+        /*
+         * way offset = cache size / associativity, so just don't factor in
+         * associativity in the first place..
+         */
+        cpu_data->icache.way_ofs        = cpu_data->icache.sets *
+                                          cpu_data->icache.linesz;
+
+        cpu_data->icache.asid_mask      = 0x3fc;
+        cpu_data->icache.idx_mask       = 0x1fe0;
+        cpu_data->icache.epn_mask       = 0xffffe000;
+        cpu_data->icache.flags          = 0;
+
+        /*
+         * Next, setup some sane values for the D-cache.
+         *
+         * On the SH5, these are pretty consistent with the I-cache settings,
+         * so we just copy over the existing definitions.. these can be fixed
+         * up later, especially if we add runtime CPU probing.
+         *
+         * Though in the meantime it saves us from having to duplicate all of
+         * the above definitions..
+         */
+        cpu_data->dcache                = cpu_data->icache;
+
+        /*
+         * Setup any cache-related flags here
+         */
+#if defined(CONFIG_DCACHE_WRITE_THROUGH)
+        set_bit(SH_CACHE_MODE_WT, &(cpu_data->dcache.flags));
+#elif defined(CONFIG_DCACHE_WRITE_BACK)
+        set_bit(SH_CACHE_MODE_WB, &(cpu_data->dcache.flags));
+#endif
+
+        /*
+         * We also need to reserve a slot for the D-cache in the DTLB, so we
+         * do this now ..
+         */
+        dtlb_cache_slot                 = sh64_get_wired_dtlb_entry();
+
+        return 0;
+}
+
+#ifdef CONFIG_DCACHE_DISABLED
+#define sh64_dcache_purge_all()                                 do { } while (0)
+#define sh64_dcache_purge_coloured_phy_page(paddr, eaddr)       do { } while (0)
+#define sh64_dcache_purge_user_range(mm, start, end)            do { } while (0)
+#define sh64_dcache_purge_phy_page(paddr)                       do { } while (0)
+#define sh64_dcache_purge_virt_page(mm, eaddr)                  do { } while (0)
+#define sh64_dcache_purge_kernel_range(start, end)              do { } while (0)
+#define sh64_dcache_wback_current_user_range(start, end)        do { } while (0)
+#endif
+
+/*##########################################################################*/
+
+/* From here onwards, a rewrite of the implementation,
+   by Richard.Curnow@superh.com.
+
+   The major changes in this compared to the old version are;
+   1. use more selective purging through OCBP instead of using ALLOCO to purge
+      by natural replacement.  This avoids purging out unrelated cache lines
+      that happen to be in the same set.
+   2. exploit the APIs copy_user_page and clear_user_page better
+   3. be more selective about I-cache purging, in particular use invalidate_all
+      more sparingly.
+
+   */
+
+/*##########################################################################
+                               SUPPORT FUNCTIONS
+  ##########################################################################*/
+
+/****************************************************************************/
+/* The following group of functions deal with mapping and unmapping a temporary
+   page into the DTLB slot that have been set aside for our exclusive use. */
+/* In order to accomplish this, we use the generic interface for adding and
+   removing a wired slot entry as defined in arch/sh64/mm/tlb.c */
+/****************************************************************************/
+
+static unsigned long slot_own_flags;
+
+static inline void sh64_setup_dtlb_cache_slot(unsigned long eaddr, unsigned long asid, unsigned long paddr)
+{
+        local_irq_save(slot_own_flags);
+        sh64_setup_tlb_slot(dtlb_cache_slot, eaddr, asid, paddr);
+}
+
+static inline void sh64_teardown_dtlb_cache_slot(void)
+{
+        sh64_teardown_tlb_slot(dtlb_cache_slot);
+        local_irq_restore(slot_own_flags);
+}
+
+/****************************************************************************/
+
+#ifndef CONFIG_ICACHE_DISABLED
+
+static void __inline__ sh64_icache_inv_all(void)
+{
+        unsigned long long addr, flag, data;
+        unsigned int flags;
+
+        addr=ICCR0;
+        flag=ICCR0_ICI;
+        data=0;
+
+        /* Make this a critical section for safety (probably not strictly necessary.) */
+        local_irq_save(flags);
+
+        /* Without %1 it gets unexplicably wrong */
+        asm volatile("getcfg    %3, 0, %0\n\t"
+                        "or     %0, %2, %0\n\t"
+                        "putcfg %3, 0, %0\n\t"
+                        "synci"
+                        : "=&r" (data)
+                        : "0" (data), "r" (flag), "r" (addr));
+
+        local_irq_restore(flags);
+}
+
+static void sh64_icache_inv_kernel_range(unsigned long start, unsigned long end)
+{
+        /* Invalidate range of addresses [start,end] from the I-cache, where
+         * the addresses lie in the kernel superpage. */
+
+        unsigned long long ullend, addr, aligned_start;
+#if (NEFF == 32)
+        aligned_start = (unsigned long long)(signed long long)(signed long) start;
+#else
+#error "NEFF != 32"
+#endif
+        aligned_start &= L1_CACHE_ALIGN_MASK;
+        addr = aligned_start;
+#if (NEFF == 32)
+        ullend = (unsigned long long) (signed long long) (signed long) end;
+#else
+#error "NEFF != 32"
+#endif
+        while (addr <= ullend) {
+                asm __volatile__ ("icbi %0, 0" : : "r" (addr));
+                addr += L1_CACHE_BYTES;
+        }
+}
+
+static void sh64_icache_inv_user_page(struct vm_area_struct *vma, unsigned long eaddr)
+{
+        /* If we get called, we know that vma->vm_flags contains VM_EXEC.
+           Also, eaddr is page-aligned. */
+
+        unsigned long long addr, end_addr;
+        unsigned long flags = 0;
+        unsigned long running_asid, vma_asid;
+        addr = eaddr;
+        end_addr = addr + PAGE_SIZE;
+
+        /* Check whether we can use the current ASID for the I-cache
+           invalidation.  For example, if we're called via
+           access_process_vm->flush_cache_page->here, (e.g. when reading from
+           /proc), 'running_asid' will be that of the reader, not of the
+           victim.
+
+           Also, note the risk that we might get pre-empted between the ASID
+           compare and blocking IRQs, and before we regain control, the
+           pid->ASID mapping changes.  However, the whole cache will get
+           invalidated when the mapping is renewed, so the worst that can
+           happen is that the loop below ends up invalidating somebody else's
+           cache entries.
+        */
+
+        running_asid = get_asid();
+        vma_asid = (vma->vm_mm->context & MMU_CONTEXT_ASID_MASK);
+        if (running_asid != vma_asid) {
+                local_irq_save(flags);
+                switch_and_save_asid(vma_asid);
+        }
+        while (addr < end_addr) {
+                /* Worth unrolling a little */
+                asm __volatile__("icbi %0,  0" : : "r" (addr));
+                asm __volatile__("icbi %0, 32" : : "r" (addr));
+                asm __volatile__("icbi %0, 64" : : "r" (addr));
+                asm __volatile__("icbi %0, 96" : : "r" (addr));
+                addr += 128;
+        }
+        if (running_asid != vma_asid) {
+                switch_and_save_asid(running_asid);
+                local_irq_restore(flags);
+        }
+}
+
+/****************************************************************************/
+
+static void sh64_icache_inv_user_page_range(struct mm_struct *mm,
+                          unsigned long start, unsigned long end)
+{
+        /* Used for invalidating big chunks of I-cache, i.e. assume the range
+           is whole pages.  If 'start' or 'end' is not page aligned, the code
+           is conservative and invalidates to the ends of the enclosing pages.
+           This is functionally OK, just a performance loss. */
+
+        /* See the comments below in sh64_dcache_purge_user_range() regarding
+           the choice of algorithm.  However, for the I-cache option (2) isn't
+           available because there are no physical tags so aliases can't be
+           resolved.  The icbi instruction has to be used through the user
+           mapping.   Because icbi is cheaper than ocbp on a cache hit, it
+           would be cheaper to use the selective code for a large range than is
+           possible with the D-cache.  Just assume 64 for now as a working
+           figure.
+           */
+
+        int n_pages;
+
+        if (!mm) return;
+
+        n_pages = ((end - start) >> PAGE_SHIFT);
+        if (n_pages >= 64) {
+                sh64_icache_inv_all();
+        } else {
+                unsigned long aligned_start;
+                unsigned long eaddr;
+                unsigned long after_last_page_start;
+                unsigned long mm_asid, current_asid;
+                unsigned long long flags = 0ULL;
+
+                mm_asid = mm->context & MMU_CONTEXT_ASID_MASK;
+                current_asid = get_asid();
+
+                if (mm_asid != current_asid) {
+                        /* Switch ASID and run the invalidate loop under cli */
+                        local_irq_save(flags);
+                        switch_and_save_asid(mm_asid);
+                }
+
+                aligned_start = start & PAGE_MASK;
+                after_last_page_start = PAGE_SIZE + ((end - 1) & PAGE_MASK);
+
+                while (aligned_start < after_last_page_start) {
+                        struct vm_area_struct *vma;
+                        unsigned long vma_end;
+                        vma = find_vma(mm, aligned_start);
+                        if (!vma || (aligned_start <= vma->vm_end)) {
+                                /* Avoid getting stuck in an error condition */
+                                aligned_start += PAGE_SIZE;
+                                continue;
+                        }
+                        vma_end = vma->vm_end;
+                        if (vma->vm_flags & VM_EXEC) {
+                                /* Executable */
+                                eaddr = aligned_start;
+                                while (eaddr < vma_end) {
+                                        sh64_icache_inv_user_page(vma, eaddr);
+                                        eaddr += PAGE_SIZE;
+                                }
+                        }
+                        aligned_start = vma->vm_end; /* Skip to start of next region */
+                }
+                if (mm_asid != current_asid) {
+                        switch_and_save_asid(current_asid);
+                        local_irq_restore(flags);
+                }
+        }
+}
+
+static void sh64_icache_inv_user_small_range(struct mm_struct *mm,
+                                                unsigned long start, int len)
+{
+
+        /* Invalidate a small range of user context I-cache, not necessarily
+           page (or even cache-line) aligned. */
+
+        unsigned long long eaddr = start;
+        unsigned long long eaddr_end = start + len;
+        unsigned long current_asid, mm_asid;
+        unsigned long long flags;
+        unsigned long long epage_start;
+
+        /* Since this is used inside ptrace, the ASID in the mm context
+           typically won't match current_asid.  We'll have to switch ASID to do
+           this.  For safety, and given that the range will be small, do all
+           this under cli.
+
+           Note, there is a hazard that the ASID in mm->context is no longer
+           actually associated with mm, i.e. if the mm->context has started a
+           new cycle since mm was last active.  However, this is just a
+           performance issue: all that happens is that we invalidate lines
+           belonging to another mm, so the owning process has to refill them
+           when that mm goes live again.  mm itself can't have any cache
+           entries because there will have been a flush_cache_all when the new
+           mm->context cycle started. */
+
+        /* Align to start of cache line.  Otherwise, suppose len==8 and start
+           was at 32N+28 : the last 4 bytes wouldn't get invalidated. */
+        eaddr = start & L1_CACHE_ALIGN_MASK;
+        eaddr_end = start + len;
+
+        local_irq_save(flags);
+        mm_asid = mm->context & MMU_CONTEXT_ASID_MASK;
+        current_asid = switch_and_save_asid(mm_asid);
+
+        epage_start = eaddr & PAGE_MASK;
+
+        while (eaddr < eaddr_end)
+        {
+                asm __volatile__("icbi %0, 0" : : "r" (eaddr));
+                eaddr += L1_CACHE_BYTES;
+        }
+        switch_and_save_asid(current_asid);
+        local_irq_restore(flags);
+}
+
+static void sh64_icache_inv_current_user_range(unsigned long start, unsigned long end)
+{
+        /* The icbi instruction never raises ITLBMISS.  i.e. if there's not a
+           cache hit on the virtual tag the instruction ends there, without a
+           TLB lookup. */
+
+        unsigned long long aligned_start;
+        unsigned long long ull_end;
+        unsigned long long addr;
+
+        ull_end = end;
+
+        /* Just invalidate over the range using the natural addresses.  TLB
+           miss handling will be OK (TBC).  Since it's for the current process,
+           either we're already in the right ASID context, or the ASIDs have
+           been recycled since we were last active in which case we might just
+           invalidate another processes I-cache entries : no worries, just a
+           performance drop for him. */
+        aligned_start = start & L1_CACHE_ALIGN_MASK;
+        addr = aligned_start;
+        while (addr < ull_end) {
+                asm __volatile__ ("icbi %0, 0" : : "r" (addr));
+                asm __volatile__ ("nop");
+                asm __volatile__ ("nop");
+                addr += L1_CACHE_BYTES;
+        }
+}
+
+#endif /* !CONFIG_ICACHE_DISABLED */
+
+/****************************************************************************/
+
+#ifndef CONFIG_DCACHE_DISABLED
+
+/* Buffer used as the target of alloco instructions to purge data from cache
+   sets by natural eviction. -- RPC */
+#define DUMMY_ALLOCO_AREA_SIZE L1_CACHE_SIZE_BYTES + (1024 * 4)
+static unsigned char dummy_alloco_area[DUMMY_ALLOCO_AREA_SIZE] __cacheline_aligned = { 0, };
+
+/****************************************************************************/
+
+static void __inline__ sh64_dcache_purge_sets(int sets_to_purge_base, int n_sets)
+{
+        /* Purge all ways in a particular block of sets, specified by the base
+           set number and number of sets.  Can handle wrap-around, if that's
+           needed.  */
+
+        int dummy_buffer_base_set;
+        unsigned long long eaddr, eaddr0, eaddr1;
+        int j;
+        int set_offset;
+
+        dummy_buffer_base_set = ((int)&dummy_alloco_area & cpu_data->dcache.idx_mask) >> cpu_data->dcache.entry_shift;
+        set_offset = sets_to_purge_base - dummy_buffer_base_set;
+
+        for (j=0; j<n_sets; j++, set_offset++) {
+                set_offset &= (cpu_data->dcache.sets - 1);
+                eaddr0 = (unsigned long long)dummy_alloco_area + (set_offset << cpu_data->dcache.entry_shift);
+
+                /* Do one alloco which hits the required set per cache way.  For
+                   write-back mode, this will purge the #ways resident lines.   There's
+                   little point unrolling this loop because the allocos stall more if
+                   they're too close together. */
+                eaddr1 = eaddr0 + cpu_data->dcache.way_ofs * cpu_data->dcache.ways;
+                for (eaddr=eaddr0; eaddr<eaddr1; eaddr+=cpu_data->dcache.way_ofs) {
+                        asm __volatile__ ("alloco %0, 0" : : "r" (eaddr));
+                        asm __volatile__ ("synco"); /* TAKum03020 */
+                }
+
+                eaddr1 = eaddr0 + cpu_data->dcache.way_ofs * cpu_data->dcache.ways;
+                for (eaddr=eaddr0; eaddr<eaddr1; eaddr+=cpu_data->dcache.way_ofs) {
+                        /* Load from each address.  Required because alloco is a NOP if
+                           the cache is write-through.  Write-through is a config option. */
+                        if (test_bit(SH_CACHE_MODE_WT, &(cpu_data->dcache.flags)))
+                                *(volatile unsigned char *)(int)eaddr;
+                }
+        }
+
+        /* Don't use OCBI to invalidate the lines.  That costs cycles directly.
+           If the dummy block is just left resident, it will naturally get
+           evicted as required.  */
+
+        return;
+}
+
+/****************************************************************************/
+
+static void sh64_dcache_purge_all(void)
+{
+        /* Purge the entire contents of the dcache.  The most efficient way to
+           achieve this is to use alloco instructions on a region of unused
+           memory equal in size to the cache, thereby causing the current
+           contents to be discarded by natural eviction.  The alternative,
+           namely reading every tag, setting up a mapping for the corresponding
+           page and doing an OCBP for the line, would be much more expensive.
+           */
+
+        sh64_dcache_purge_sets(0, cpu_data->dcache.sets);
+
+        return;
+
+}
+
+/****************************************************************************/
+
+static void sh64_dcache_purge_kernel_range(unsigned long start, unsigned long end)
+{
+        /* Purge the range of addresses [start,end] from the D-cache.  The
+           addresses lie in the superpage mapping.  There's no harm if we
+           overpurge at either end - just a small performance loss. */
+        unsigned long long ullend, addr, aligned_start;
+#if (NEFF == 32)
+        aligned_start = (unsigned long long)(signed long long)(signed long) start;
+#else
+#error "NEFF != 32"
+#endif
+        aligned_start &= L1_CACHE_ALIGN_MASK;
+        addr = aligned_start;
+#if (NEFF == 32)
+        ullend = (unsigned long long) (signed long long) (signed long) end;
+#else
+#error "NEFF != 32"
+#endif
+        while (addr <= ullend) {
+                asm __volatile__ ("ocbp %0, 0" : : "r" (addr));
+                addr += L1_CACHE_BYTES;
+        }
+        return;
+}
+
+/* Assumes this address (+ (2**n_synbits) pages up from it) aren't used for
+   anything else in the kernel */
+#define MAGIC_PAGE0_START 0xffffffffec000000ULL
+
+static void sh64_dcache_purge_coloured_phy_page(unsigned long paddr, unsigned long eaddr)
+{
+        /* Purge the physical page 'paddr' from the cache.  It's known that any
+           cache lines requiring attention have the same page colour as the the
+           address 'eaddr'.
+
+           This relies on the fact that the D-cache matches on physical tags
+           when no virtual tag matches.  So we create an alias for the original
+           page and purge through that.  (Alternatively, we could have done
+           this by switching ASID to match the original mapping and purged
+           through that, but that involves ASID switching cost + probably a
+           TLBMISS + refill anyway.)
+           */
+
+        unsigned long long magic_page_start;
+        unsigned long long magic_eaddr, magic_eaddr_end;
+
+        magic_page_start = MAGIC_PAGE0_START + (eaddr & CACHE_OC_SYN_MASK);
+
+        /* As long as the kernel is not pre-emptible, this doesn't need to be
+           under cli/sti. */
+
+        sh64_setup_dtlb_cache_slot(magic_page_start, get_asid(), paddr);
+
+        magic_eaddr = magic_page_start;
+        magic_eaddr_end = magic_eaddr + PAGE_SIZE;
+        while (magic_eaddr < magic_eaddr_end) {
+                /* Little point in unrolling this loop - the OCBPs are blocking
+                   and won't go any quicker (i.e. the loop overhead is parallel
+                   to part of the OCBP execution.) */
+                asm __volatile__ ("ocbp %0, 0" : : "r" (magic_eaddr));
+                magic_eaddr += L1_CACHE_BYTES;
+        }
+
+        sh64_teardown_dtlb_cache_slot();
+}
+
+/****************************************************************************/
+
+static void sh64_dcache_purge_phy_page(unsigned long paddr)
+{
+        /* Pure a page given its physical start address, by creating a
+           temporary 1 page mapping and purging across that.  Even if we know
+           the virtual address (& vma or mm) of the page, the method here is
+           more elegant because it avoids issues of coping with page faults on
+           the purge instructions (i.e. no special-case code required in the
+           critical path in the TLB miss handling). */
+
+        unsigned long long eaddr_start, eaddr, eaddr_end;
+        int i;
+
+        /* As long as the kernel is not pre-emptible, this doesn't need to be
+           under cli/sti. */
+
+        eaddr_start = MAGIC_PAGE0_START;
+        for (i=0; i < (1 << CACHE_OC_N_SYNBITS); i++) {
+                sh64_setup_dtlb_cache_slot(eaddr_start, get_asid(), paddr);
+
+                eaddr = eaddr_start;
+                eaddr_end = eaddr + PAGE_SIZE;
+                while (eaddr < eaddr_end) {
+                        asm __volatile__ ("ocbp %0, 0" : : "r" (eaddr));
+                        eaddr += L1_CACHE_BYTES;
+                }
+
+                sh64_teardown_dtlb_cache_slot();
+                eaddr_start += PAGE_SIZE;
+        }
+}
+
+static void sh64_dcache_purge_user_page(struct mm_struct *mm, unsigned long eaddr)
+{
+        pgd_t *pgd;
+        pmd_t *pmd;
+        pte_t *pte;
+        pte_t entry;
+        unsigned long paddr;
+
+        /* NOTE : all the callers of this have mm->page_table_lock held, so the
+           following page table traversal is safe even on SMP/pre-emptible. */
+
+        if (!mm) return; /* No way to find physical address of page */
+        pgd = pgd_offset(mm, eaddr);
+        if (pgd_bad(*pgd)) return;
+
+        pmd = pmd_offset(pgd, eaddr);
+        if (pmd_none(*pmd) || pmd_bad(*pmd)) return;
+
+        pte = pte_offset_kernel(pmd, eaddr);
+        entry = *pte;
+        if (pte_none(entry) || !pte_present(entry)) return;
+
+        paddr = pte_val(entry) & PAGE_MASK;
+
+        sh64_dcache_purge_coloured_phy_page(paddr, eaddr);
+
+}
+/****************************************************************************/
+
+static void sh64_dcache_purge_user_range(struct mm_struct *mm,
+                          unsigned long start, unsigned long end)
+{
+        /* There are at least 5 choices for the implementation of this, with
+           pros (+), cons(-), comments(*):
+
+           1. ocbp each line in the range through the original user's ASID
+              + no lines spuriously evicted
+              - tlbmiss handling (must either handle faults on demand => extra
+                special-case code in tlbmiss critical path), or map the page in
+                advance (=> flush_tlb_range in advance to avoid multiple hits)
+              - ASID switching
+              - expensive for large ranges
+
+           2. temporarily map each page in the range to a special effective
+              address and ocbp through the temporary mapping; relies on the
+              fact that SH-5 OCB* always do TLB lookup and match on ptags (they
+              never look at the etags)
+              + no spurious evictions
+              - expensive for large ranges
+              * surely cheaper than (1)
+
+           3. walk all the lines in the cache, check the tags, if a match
+              occurs create a page mapping to ocbp the line through
+              + no spurious evictions
+              - tag inspection overhead
+              - (especially for small ranges)
+              - potential cost of setting up/tearing down page mapping for
+                every line that matches the range
+              * cost partly independent of range size
+
+           4. walk all the lines in the cache, check the tags, if a match
+              occurs use 4 * alloco to purge the line (+3 other probably
+              innocent victims) by natural eviction
+              + no tlb mapping overheads
+              - spurious evictions
+              - tag inspection overhead
+
+           5. implement like flush_cache_all
+              + no tag inspection overhead
+              - spurious evictions
+              - bad for small ranges
+
+           (1) can be ruled out as more expensive than (2).  (2) appears best
+           for small ranges.  The choice between (3), (4) and (5) for large
+           ranges and the range size for the large/small boundary need
+           benchmarking to determine.
+
+           For now use approach (2) for small ranges and (5) for large ones.
+
+           */
+
+        int n_pages;
+
+        n_pages = ((end - start) >> PAGE_SHIFT);
+        if (n_pages >= 64) {
+#if 1
+                sh64_dcache_purge_all();
+#else
+                unsigned long long set, way;
+                unsigned long mm_asid = mm->context & MMU_CONTEXT_ASID_MASK;
+                for (set = 0; set < cpu_data->dcache.sets; set++) {
+                        unsigned long long set_base_config_addr = CACHE_OC_ADDRESS_ARRAY + (set << cpu_data->dcache.set_shift);
+                        for (way = 0; way < cpu_data->dcache.ways; way++) {
+                                unsigned long long config_addr = set_base_config_addr + (way << cpu_data->dcache.way_step_shift);
+                                unsigned long long tag0;
+                                unsigned long line_valid;
+
+                                asm __volatile__("getcfg %1, 0, %0" : "=r" (tag0) : "r" (config_addr));
+                                line_valid = tag0 & SH_CACHE_VALID;
+                                if (line_valid) {
+                                        unsigned long cache_asid;
+                                        unsigned long epn;
+
+                                        cache_asid = (tag0 & cpu_data->dcache.asid_mask) >> cpu_data->dcache.asid_shift;
+                                        /* The next line needs some
+                                           explanation.  The virtual tags
+                                           encode bits [31:13] of the virtual
+                                           address, bit [12] of the 'tag' being
+                                           implied by the cache set index. */
+                                        epn = (tag0 & cpu_data->dcache.epn_mask) | ((set & 0x80) << cpu_data->dcache.entry_shift);
+
+                                        if ((cache_asid == mm_asid) && (start <= epn) && (epn < end)) {
+                                                /* TODO : could optimise this
+                                                   call by batching multiple
+                                                   adjacent sets together. */
+                                                sh64_dcache_purge_sets(set, 1);
+                                                break; /* Don't waste time inspecting other ways for this set */
+                                        }
+                                }
+                        }
+                }
+#endif
+        } else {
+                /* 'Small' range */
+                unsigned long aligned_start;
+                unsigned long eaddr;
+                unsigned long last_page_start;
+
+                aligned_start = start & PAGE_MASK;
+                /* 'end' is 1 byte beyond the end of the range */
+                last_page_start = (end - 1) & PAGE_MASK;
+
+                eaddr = aligned_start;
+                while (eaddr <= last_page_start) {
+                        sh64_dcache_purge_user_page(mm, eaddr);
+                        eaddr += PAGE_SIZE;
+                }
+        }
+        return;
+}
+
+static void sh64_dcache_wback_current_user_range(unsigned long start, unsigned long end)
+{
+        unsigned long long aligned_start;
+        unsigned long long ull_end;
+        unsigned long long addr;
+
+        ull_end = end;
+
+        /* Just wback over the range using the natural addresses.  TLB miss
+           handling will be OK (TBC) : the range has just been written to by
+           the signal frame setup code, so the PTEs must exist.
+
+           Note, if we have CONFIG_PREEMPT and get preempted inside this loop,
+           it doesn't matter, even if the pid->ASID mapping changes whilst
+           we're away.  In that case the cache will have been flushed when the
+           mapping was renewed.  So the writebacks below will be nugatory (and
+           we'll doubtless have to fault the TLB entry/ies in again with the
+           new ASID), but it's a rare case.
+           */
+        aligned_start = start & L1_CACHE_ALIGN_MASK;
+        addr = aligned_start;
+        while (addr < ull_end) {
+                asm __volatile__ ("ocbwb %0, 0" : : "r" (addr));
+                addr += L1_CACHE_BYTES;
+        }
+}
+
+/****************************************************************************/
+
+/* These *MUST* lie in an area of virtual address space that's otherwise unused. */
+#define UNIQUE_EADDR_START 0xe0000000UL
+#define UNIQUE_EADDR_END   0xe8000000UL
+
+static unsigned long sh64_make_unique_eaddr(unsigned long user_eaddr, unsigned long paddr)
+{
+        /* Given a physical address paddr, and a user virtual address
+           user_eaddr which will eventually be mapped to it, create a one-off
+           kernel-private eaddr mapped to the same paddr.  This is used for
+           creating special destination pages for copy_user_page and
+           clear_user_page */
+
+        static unsigned long current_pointer = UNIQUE_EADDR_START;
+        unsigned long coloured_pointer;
+
+        if (current_pointer == UNIQUE_EADDR_END) {
+                sh64_dcache_purge_all();
+                current_pointer = UNIQUE_EADDR_START;
+        }
+
+        coloured_pointer = (current_pointer & ~CACHE_OC_SYN_MASK) | (user_eaddr & CACHE_OC_SYN_MASK);
+        sh64_setup_dtlb_cache_slot(coloured_pointer, get_asid(), paddr);
+
+        current_pointer += (PAGE_SIZE << CACHE_OC_N_SYNBITS);
+
+        return coloured_pointer;
+}
+
+/****************************************************************************/
+
+static void sh64_copy_user_page_coloured(void *to, void *from, unsigned long address)
+{
+        void *coloured_to;
+
+        /* Discard any existing cache entries of the wrong colour.  These are
+           present quite often, if the kernel has recently used the page
+           internally, then given it up, then it's been allocated to the user.
+           */
+        sh64_dcache_purge_coloured_phy_page(__pa(to), (unsigned long) to);
+
+        coloured_to = (void *) sh64_make_unique_eaddr(address, __pa(to));
+        sh64_page_copy(from, coloured_to);
+
+        sh64_teardown_dtlb_cache_slot();
+}
+
+static void sh64_clear_user_page_coloured(void *to, unsigned long address)
+{
+        void *coloured_to;
+
+        /* Discard any existing kernel-originated lines of the wrong colour (as
+           above) */
+        sh64_dcache_purge_coloured_phy_page(__pa(to), (unsigned long) to);
+
+        coloured_to = (void *) sh64_make_unique_eaddr(address, __pa(to));
+        sh64_page_clear(coloured_to);
+
+        sh64_teardown_dtlb_cache_slot();
+}
+
+#endif /* !CONFIG_DCACHE_DISABLED */
+
+/****************************************************************************/
+
+/*##########################################################################
+                            EXTERNALLY CALLABLE API.
+  ##########################################################################*/
+
+/* These functions are described in Documentation/cachetlb.txt.
+   Each one of these functions varies in behaviour depending on whether the
+   I-cache and/or D-cache are configured out.
+
+   Note that the Linux term 'flush' corresponds to what is termed 'purge' in
+   the sh/sh64 jargon for the D-cache, i.e. write back dirty data then
+   invalidate the cache lines, and 'invalidate' for the I-cache.
+   */
+
+#undef FLUSH_TRACE
+
+void flush_cache_all(void)
+{
+        /* Invalidate the entire contents of both caches, after writing back to
+           memory any dirty data from the D-cache. */
+        sh64_dcache_purge_all();
+        sh64_icache_inv_all();
+}
+
+/****************************************************************************/
+
+void flush_cache_mm(struct mm_struct *mm)
+{
+        /* Invalidate an entire user-address space from both caches, after
+           writing back dirty data (e.g. for shared mmap etc). */
+
+        /* This could be coded selectively by inspecting all the tags then
+           doing 4*alloco on any set containing a match (as for
+           flush_cache_range), but fork/exit/execve (where this is called from)
+           are expensive anyway. */
+
+        /* Have to do a purge here, despite the comments re I-cache below.
+           There could be odd-coloured dirty data associated with the mm still
+           in the cache - if this gets written out through natural eviction
+           after the kernel has reused the page there will be chaos.
+           */
+
+        sh64_dcache_purge_all();
+
+        /* The mm being torn down won't ever be active again, so any Icache
+           lines tagged with its ASID won't be visible for the rest of the
+           lifetime of this ASID cycle.  Before the ASID gets reused, there
+           will be a flush_cache_all.  Hence we don't need to touch the
+           I-cache.  This is similar to the lack of action needed in
+           flush_tlb_mm - see fault.c. */
+}
+
+/****************************************************************************/
+
+void flush_cache_range(struct vm_area_struct *vma, unsigned long start,
+                       unsigned long end)
+{
+        struct mm_struct *mm = vma->vm_mm;
+
+        /* Invalidate (from both caches) the range [start,end) of virtual
+           addresses from the user address space specified by mm, after writing
+           back any dirty data.
+
+           Note(1), 'end' is 1 byte beyond the end of the range to flush.
+
+           Note(2), this is called with mm->page_table_lock held.*/
+
+        sh64_dcache_purge_user_range(mm, start, end);
+        sh64_icache_inv_user_page_range(mm, start, end);
+}
+
+/****************************************************************************/
+
+void flush_cache_page(struct vm_area_struct *vma, unsigned long eaddr, unsigned long pfn)
+{
+        /* Invalidate any entries in either cache for the vma within the user
+           address space vma->vm_mm for the page starting at virtual address
+           'eaddr'.   This seems to be used primarily in breaking COW.  Note,
+           the I-cache must be searched too in case the page in question is
+           both writable and being executed from (e.g. stack trampolines.)
+
+           Note(1), this is called with mm->page_table_lock held.
+           */
+
+        sh64_dcache_purge_phy_page(pfn << PAGE_SHIFT);
+
+        if (vma->vm_flags & VM_EXEC) {
+                sh64_icache_inv_user_page(vma, eaddr);
+        }
+}
+
+/****************************************************************************/
+
+#ifndef CONFIG_DCACHE_DISABLED
+
+void copy_user_page(void *to, void *from, unsigned long address, struct page *page)
+{
+        /* 'from' and 'to' are kernel virtual addresses (within the superpage
+           mapping of the physical RAM).  'address' is the user virtual address
+           where the copy 'to' will be mapped after.  This allows a custom
+           mapping to be used to ensure that the new copy is placed in the
+           right cache sets for the user to see it without having to bounce it
+           out via memory.  Note however : the call to flush_page_to_ram in
+           (generic)/mm/memory.c:(break_cow) undoes all this good work in that one
+           very important case!
+
+           TBD : can we guarantee that on every call, any cache entries for
+           'from' are in the same colour sets as 'address' also?  i.e. is this
+           always used just to deal with COW?  (I suspect not). */
+
+        /* There are two possibilities here for when the page 'from' was last accessed:
+           * by the kernel : this is OK, no purge required.
+           * by the/a user (e.g. for break_COW) : need to purge.
+
+           If the potential user mapping at 'address' is the same colour as
+           'from' there is no need to purge any cache lines from the 'from'
+           page mapped into cache sets of colour 'address'.  (The copy will be
+           accessing the page through 'from').
+           */
+
+        if (((address ^ (unsigned long) from) & CACHE_OC_SYN_MASK) != 0) {
+                sh64_dcache_purge_coloured_phy_page(__pa(from), address);
+        }
+
+        if (((address ^ (unsigned long) to) & CACHE_OC_SYN_MASK) == 0) {
+                /* No synonym problem on destination */
+                sh64_page_copy(from, to);
+        } else {
+                sh64_copy_user_page_coloured(to, from, address);
+        }
+
+        /* Note, don't need to flush 'from' page from the cache again - it's
+           done anyway by the generic code */
+}
+
+void clear_user_page(void *to, unsigned long address, struct page *page)
+{
+        /* 'to' is a kernel virtual address (within the superpage
+           mapping of the physical RAM).  'address' is the user virtual address
+           where the 'to' page will be mapped after.  This allows a custom
+           mapping to be used to ensure that the new copy is placed in the
+           right cache sets for the user to see it without having to bounce it
+           out via memory.
+        */
+
+        if (((address ^ (unsigned long) to) & CACHE_OC_SYN_MASK) == 0) {
+                /* No synonym problem on destination */
+                sh64_page_clear(to);
+        } else {
+                sh64_clear_user_page_coloured(to, address);
+        }
+}
+
+#endif /* !CONFIG_DCACHE_DISABLED */
+
+/****************************************************************************/
+
+void flush_dcache_page(struct page *page)
+{
+        sh64_dcache_purge_phy_page(page_to_phys(page));
+        wmb();
+}
+
+/****************************************************************************/
+
+void flush_icache_range(unsigned long start, unsigned long end)
+{
+        /* Flush the range [start,end] of kernel virtual adddress space from
+           the I-cache.  The corresponding range must be purged from the
+           D-cache also because the SH-5 doesn't have cache snooping between
+           the caches.  The addresses will be visible through the superpage
+           mapping, therefore it's guaranteed that there no cache entries for
+           the range in cache sets of the wrong colour.
+
+           Primarily used for cohering the I-cache after a module has
+           been loaded.  */
+
+        /* We also make sure to purge the same range from the D-cache since
+           flush_page_to_ram() won't be doing this for us! */
+
+        sh64_dcache_purge_kernel_range(start, end);
+        wmb();
+        sh64_icache_inv_kernel_range(start, end);
+}
+
+/****************************************************************************/
+
+void flush_icache_user_range(struct vm_area_struct *vma,
+                        struct page *page, unsigned long addr, int len)
+{
+        /* Flush the range of user (defined by vma->vm_mm) address space
+           starting at 'addr' for 'len' bytes from the cache.  The range does
+           not straddle a page boundary, the unique physical page containing
+           the range is 'page'.  This seems to be used mainly for invalidating
+           an address range following a poke into the program text through the
+           ptrace() call from another process (e.g. for BRK instruction
+           insertion). */
+
+        sh64_dcache_purge_coloured_phy_page(page_to_phys(page), addr);
+        mb();
+
+        if (vma->vm_flags & VM_EXEC) {
+                sh64_icache_inv_user_small_range(vma->vm_mm, addr, len);
+        }
+}
+
+/*##########################################################################
+                        ARCH/SH64 PRIVATE CALLABLE API.
+  ##########################################################################*/
+
+void flush_cache_sigtramp(unsigned long start, unsigned long end)
+{
+        /* For the address range [start,end), write back the data from the
+           D-cache and invalidate the corresponding region of the I-cache for
+           the current process.  Used to flush signal trampolines on the stack
+           to make them executable. */
+
+        sh64_dcache_wback_current_user_range(start, end);
+        wmb();
+        sh64_icache_inv_current_user_range(start, end);
+}
+
diff --git a/arch/sh64/mm/extable.c b/arch/sh64/mm/extable.c
new file mode 100644
index 000000000000..9da50e28b3fa
--- /dev/null
+++ b/arch/sh64/mm/extable.c
@@ -0,0 +1,81 @@
+/*
+ * 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.
+ *
+ * arch/sh64/mm/extable.c
+ *
+ * Copyright (C) 2003 Richard Curnow
+ * Copyright (C) 2003, 2004  Paul Mundt
+ *
+ * Cloned from the 2.5 SH version..
+ */
+#include <linux/config.h>
+#include <linux/rwsem.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+extern unsigned long copy_user_memcpy, copy_user_memcpy_end;
+extern void __copy_user_fixup(void);
+
+static const struct exception_table_entry __copy_user_fixup_ex = {
+        .fixup = (unsigned long)&__copy_user_fixup,
+};
+
+/* Some functions that may trap due to a bad user-mode address have too many loads
+   and stores in them to make it at all practical to label each one and put them all in
+   the main exception table.
+
+   In particular, the fast memcpy routine is like this.  It's fix-up is just to fall back
+   to a slow byte-at-a-time copy, which is handled the conventional way.  So it's functionally
+   OK to just handle any trap occurring in the fast memcpy with that fixup. */
+static const struct exception_table_entry *check_exception_ranges(unsigned long addr)
+{
+        if ((addr >= (unsigned long)&copy_user_memcpy) &&
+            (addr <= (unsigned long)&copy_user_memcpy_end))
+                return &__copy_user_fixup_ex;
+
+        return NULL;
+}
+
+/* Simple binary search */
+const struct exception_table_entry *
+search_extable(const struct exception_table_entry *first,
+                 const struct exception_table_entry *last,
+                 unsigned long value)
+{
+        const struct exception_table_entry *mid;
+
+        mid = check_exception_ranges(value);
+        if (mid)
+                return mid;
+
+        while (first <= last) {
+                long diff;
+
+                mid = (last - first) / 2 + first;
+                diff = mid->insn - value;
+                if (diff == 0)
+                        return mid;
+                else if (diff < 0)
+                        first = mid+1;
+                else
+                        last = mid-1;
+        }
+
+        return NULL;
+}
+
+int fixup_exception(struct pt_regs *regs)
+{
+        const struct exception_table_entry *fixup;
+
+        fixup = search_exception_tables(regs->pc);
+        if (fixup) {
+                regs->pc = fixup->fixup;
+                return 1;
+        }
+
+        return 0;
+}
+
diff --git a/arch/sh64/mm/fault.c b/arch/sh64/mm/fault.c
new file mode 100644
index 000000000000..a24932881dbb
--- /dev/null
+++ b/arch/sh64/mm/fault.c
@@ -0,0 +1,601 @@
+/*
+ * 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.
+ *
+ * arch/sh64/mm/fault.c
+ *
+ * Copyright (C) 2000, 2001  Paolo Alberelli
+ * Copyright (C) 2003  Richard Curnow (/proc/tlb, bug fixes)
+ * Copyright (C) 2003  Paul Mundt
+ *
+ */
+
+#include <linux/signal.h>
+#include <linux/rwsem.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/ptrace.h>
+#include <linux/mman.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/smp_lock.h>
+#include <linux/interrupt.h>
+
+#include <asm/system.h>
+#include <asm/io.h>
+#include <asm/tlb.h>
+#include <asm/uaccess.h>
+#include <asm/pgalloc.h>
+#include <asm/mmu_context.h>
+#include <asm/registers.h>              /* required by inline asm statements */
+
+#if defined(CONFIG_SH64_PROC_TLB)
+#include <linux/init.h>
+#include <linux/proc_fs.h>
+/* Count numbers of tlb refills in each region */
+static unsigned long long calls_to_update_mmu_cache = 0ULL;
+static unsigned long long calls_to_flush_tlb_page   = 0ULL;
+static unsigned long long calls_to_flush_tlb_range  = 0ULL;
+static unsigned long long calls_to_flush_tlb_mm     = 0ULL;
+static unsigned long long calls_to_flush_tlb_all    = 0ULL;
+unsigned long long calls_to_do_slow_page_fault = 0ULL;
+unsigned long long calls_to_do_fast_page_fault = 0ULL;
+
+/* Count size of ranges for flush_tlb_range */
+static unsigned long long flush_tlb_range_1         = 0ULL;
+static unsigned long long flush_tlb_range_2         = 0ULL;
+static unsigned long long flush_tlb_range_3_4       = 0ULL;
+static unsigned long long flush_tlb_range_5_7       = 0ULL;
+static unsigned long long flush_tlb_range_8_11      = 0ULL;
+static unsigned long long flush_tlb_range_12_15     = 0ULL;
+static unsigned long long flush_tlb_range_16_up     = 0ULL;
+
+static unsigned long long page_not_present          = 0ULL;
+
+#endif
+
+extern void die(const char *,struct pt_regs *,long);
+
+#define PFLAG(val,flag)   (( (val) & (flag) ) ? #flag : "" )
+#define PPROT(flag) PFLAG(pgprot_val(prot),flag)
+
+static inline void print_prots(pgprot_t prot)
+{
+        printk("prot is 0x%08lx\n",pgprot_val(prot));
+
+        printk("%s %s %s %s %s\n",PPROT(_PAGE_SHARED),PPROT(_PAGE_READ),
+               PPROT(_PAGE_EXECUTE),PPROT(_PAGE_WRITE),PPROT(_PAGE_USER));
+}
+
+static inline void print_vma(struct vm_area_struct *vma)
+{
+        printk("vma start 0x%08lx\n", vma->vm_start);
+        printk("vma end   0x%08lx\n", vma->vm_end);
+
+        print_prots(vma->vm_page_prot);
+        printk("vm_flags 0x%08lx\n", vma->vm_flags);
+}
+
+static inline void print_task(struct task_struct *tsk)
+{
+        printk("Task pid %d\n", tsk->pid);
+}
+
+static pte_t *lookup_pte(struct mm_struct *mm, unsigned long address)
+{
+        pgd_t *dir;
+        pmd_t *pmd;
+        pte_t *pte;
+        pte_t entry;
+
+        dir = pgd_offset(mm, address);
+        if (pgd_none(*dir)) {
+                return NULL;
+        }
+
+        pmd = pmd_offset(dir, address);
+        if (pmd_none(*pmd)) {
+                return NULL;
+        }
+
+        pte = pte_offset_kernel(pmd, address);
+        entry = *pte;
+
+        if (pte_none(entry)) {
+                return NULL;
+        }
+        if (!pte_present(entry)) {
+                return NULL;
+        }
+
+        return pte;
+}
+
+/*
+ * This routine handles page faults.  It determines the address,
+ * and the problem, and then passes it off to one of the appropriate
+ * routines.
+ */
+asmlinkage void do_page_fault(struct pt_regs *regs, unsigned long writeaccess,
+                              unsigned long textaccess, unsigned long address)
+{
+        struct task_struct *tsk;
+        struct mm_struct *mm;
+        struct vm_area_struct * vma;
+        const struct exception_table_entry *fixup;
+        pte_t *pte;
+
+#if defined(CONFIG_SH64_PROC_TLB)
+        ++calls_to_do_slow_page_fault;
+#endif
+
+        /* SIM
+         * Note this is now called with interrupts still disabled
+         * This is to cope with being called for a missing IO port
+         * address with interupts disabled. This should be fixed as
+         * soon as we have a better 'fast path' miss handler.
+         *
+         * Plus take care how you try and debug this stuff.
+         * For example, writing debug data to a port which you
+         * have just faulted on is not going to work.
+         */
+
+        tsk = current;
+        mm = tsk->mm;
+
+        /* Not an IO address, so reenable interrupts */
+        local_irq_enable();
+
+        /*
+         * If we're in an interrupt or have no user
+         * context, we must not take the fault..
+         */
+        if (in_interrupt() || !mm)
+                goto no_context;
+
+        /* TLB misses upon some cache flushes get done under cli() */
+        down_read(&mm->mmap_sem);
+
+        vma = find_vma(mm, address);
+
+        if (!vma) {
+#ifdef DEBUG_FAULT
+                print_task(tsk);
+                printk("%s:%d fault, address is 0x%08x PC %016Lx textaccess %d writeaccess %d\n",
+                       __FUNCTION__,__LINE__,
+                       address,regs->pc,textaccess,writeaccess);
+                show_regs(regs);
+#endif
+                goto bad_area;
+        }
+        if (vma->vm_start <= address) {
+                goto good_area;
+        }
+
+        if (!(vma->vm_flags & VM_GROWSDOWN)) {
+#ifdef DEBUG_FAULT
+                print_task(tsk);
+                printk("%s:%d fault, address is 0x%08x PC %016Lx textaccess %d writeaccess %d\n",
+                       __FUNCTION__,__LINE__,
+                       address,regs->pc,textaccess,writeaccess);
+                show_regs(regs);
+
+                print_vma(vma);
+#endif
+                goto bad_area;
+        }
+        if (expand_stack(vma, address)) {
+#ifdef DEBUG_FAULT
+                print_task(tsk);
+                printk("%s:%d fault, address is 0x%08x PC %016Lx textaccess %d writeaccess %d\n",
+                       __FUNCTION__,__LINE__,
+                       address,regs->pc,textaccess,writeaccess);
+                show_regs(regs);
+#endif
+                goto bad_area;
+        }
+/*
+ * Ok, we have a good vm_area for this memory access, so
+ * we can handle it..
+ */
+good_area:
+        if (textaccess) {
+                if (!(vma->vm_flags & VM_EXEC))
+                        goto bad_area;
+        } else {
+                if (writeaccess) {
+                        if (!(vma->vm_flags & VM_WRITE))
+                                goto bad_area;
+                } else {
+                        if (!(vma->vm_flags & VM_READ))
+                                goto bad_area;
+                }
+        }
+
+        /*
+         * If for any reason at all we couldn't handle the fault,
+         * make sure we exit gracefully rather than endlessly redo
+         * the fault.
+         */
+survive:
+        switch (handle_mm_fault(mm, vma, address, writeaccess)) {
+        case 1:
+                tsk->min_flt++;
+                break;
+        case 2:
+                tsk->maj_flt++;
+                break;
+        case 0:
+                goto do_sigbus;
+        default:
+                goto out_of_memory;
+        }
+        /* If we get here, the page fault has been handled.  Do the TLB refill
+           now from the newly-setup PTE, to avoid having to fault again right
+           away on the same instruction. */
+        pte = lookup_pte (mm, address);
+        if (!pte) {
+                /* From empirical evidence, we can get here, due to
+                   !pte_present(pte).  (e.g. if a swap-in occurs, and the page
+                   is swapped back out again before the process that wanted it
+                   gets rescheduled?) */
+                goto no_pte;
+        }
+
+        __do_tlb_refill(address, textaccess, pte);
+
+no_pte:
+
+        up_read(&mm->mmap_sem);
+        return;
+
+/*
+ * Something tried to access memory that isn't in our memory map..
+ * Fix it, but check if it's kernel or user first..
+ */
+bad_area:
+#ifdef DEBUG_FAULT
+        printk("fault:bad area\n");
+#endif
+        up_read(&mm->mmap_sem);
+
+        if (user_mode(regs)) {
+                static int count=0;
+                siginfo_t info;
+                if (count < 4) {
+                        /* This is really to help debug faults when starting
+                         * usermode, so only need a few */
+                        count++;
+                        printk("user mode bad_area address=%08lx pid=%d (%s) pc=%08lx\n",
+                                address, current->pid, current->comm,
+                                (unsigned long) regs->pc);
+#if 0
+                        show_regs(regs);
+#endif
+                }
+                if (tsk->pid == 1) {
+                        panic("INIT had user mode bad_area\n");
+                }
+                tsk->thread.address = address;
+                tsk->thread.error_code = writeaccess;
+                info.si_signo = SIGSEGV;
+                info.si_errno = 0;
+                info.si_addr = (void *) address;
+                force_sig_info(SIGSEGV, &info, tsk);
+                return;
+        }
+
+no_context:
+#ifdef DEBUG_FAULT
+        printk("fault:No context\n");
+#endif
+        /* Are we prepared to handle this kernel fault?  */
+        fixup = search_exception_tables(regs->pc);
+        if (fixup) {
+                regs->pc = fixup->fixup;
+                return;
+        }
+
+/*
+ * Oops. The kernel tried to access some bad page. We'll have to
+ * terminate things with extreme prejudice.
+ *
+ */
+        if (address < PAGE_SIZE)
+                printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference");
+        else
+                printk(KERN_ALERT "Unable to handle kernel paging request");
+        printk(" at virtual address %08lx\n", address);
+        printk(KERN_ALERT "pc = %08Lx%08Lx\n", regs->pc >> 32, regs->pc & 0xffffffff);
+        die("Oops", regs, writeaccess);
+        do_exit(SIGKILL);
+
+/*
+ * We ran out of memory, or some other thing happened to us that made
+ * us unable to handle the page fault gracefully.
+ */
+out_of_memory:
+        if (current->pid == 1) {
+                panic("INIT out of memory\n");
+                yield();
+                goto survive;
+        }
+        printk("fault:Out of memory\n");
+        up_read(&mm->mmap_sem);
+        if (current->pid == 1) {
+                yield();
+                down_read(&mm->mmap_sem);
+                goto survive;
+        }
+        printk("VM: killing process %s\n", tsk->comm);
+        if (user_mode(regs))
+                do_exit(SIGKILL);
+        goto no_context;
+
+do_sigbus:
+        printk("fault:Do sigbus\n");
+        up_read(&mm->mmap_sem);
+
+        /*
+         * Send a sigbus, regardless of whether we were in kernel
+         * or user mode.
+         */
+        tsk->thread.address = address;
+        tsk->thread.error_code = writeaccess;
+        tsk->thread.trap_no = 14;
+        force_sig(SIGBUS, tsk);
+
+        /* Kernel mode? Handle exceptions or die */
+        if (!user_mode(regs))
+                goto no_context;
+}
+
+
+void flush_tlb_all(void);
+
+void update_mmu_cache(struct vm_area_struct * vma,
+                        unsigned long address, pte_t pte)
+{
+#if defined(CONFIG_SH64_PROC_TLB)
+        ++calls_to_update_mmu_cache;
+#endif
+
+        /*
+         * This appears to get called once for every pte entry that gets
+         * established => I don't think it's efficient to try refilling the
+         * TLBs with the pages - some may not get accessed even.  Also, for
+         * executable pages, it is impossible to determine reliably here which
+         * TLB they should be mapped into (or both even).
+         *
+         * So, just do nothing here and handle faults on demand.  In the
+         * TLBMISS handling case, the refill is now done anyway after the pte
+         * has been fixed up, so that deals with most useful cases.
+         */
+}
+
+static void __flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
+{
+        unsigned long long match, pteh=0, lpage;
+        unsigned long tlb;
+        struct mm_struct *mm;
+
+        mm = vma->vm_mm;
+
+        if (mm->context == NO_CONTEXT)
+                return;
+
+        /*
+         * Sign-extend based on neff.
+         */
+        lpage = (page & NEFF_SIGN) ? (page | NEFF_MASK) : page;
+        match = ((mm->context & MMU_CONTEXT_ASID_MASK) << PTEH_ASID_SHIFT) | PTEH_VALID;
+        match |= lpage;
+
+        /* Do ITLB : don't bother for pages in non-exectutable VMAs */
+        if (vma->vm_flags & VM_EXEC) {
+                for_each_itlb_entry(tlb) {
+                        asm volatile ("getcfg   %1, 0, %0"
+                                      : "=r" (pteh)
+                                      : "r" (tlb) );
+
+                        if (pteh == match) {
+                                __flush_tlb_slot(tlb);
+                                break;
+                        }
+
+                }
+        }
+
+        /* Do DTLB : any page could potentially be in here. */
+        for_each_dtlb_entry(tlb) {
+                asm volatile ("getcfg   %1, 0, %0"
+                              : "=r" (pteh)
+                              : "r" (tlb) );
+
+                if (pteh == match) {
+                        __flush_tlb_slot(tlb);
+                        break;
+                }
+
+        }
+}
+
+void flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
+{
+        unsigned long flags;
+
+#if defined(CONFIG_SH64_PROC_TLB)
+        ++calls_to_flush_tlb_page;
+#endif
+
+        if (vma->vm_mm) {
+                page &= PAGE_MASK;
+                local_irq_save(flags);
+                __flush_tlb_page(vma, page);
+                local_irq_restore(flags);
+        }
+}
+
+void flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
+                     unsigned long end)
+{
+        unsigned long flags;
+        unsigned long long match, pteh=0, pteh_epn, pteh_low;
+        unsigned long tlb;
+        struct mm_struct *mm;
+
+        mm = vma->vm_mm;
+
+#if defined(CONFIG_SH64_PROC_TLB)
+        ++calls_to_flush_tlb_range;
+
+        {
+                unsigned long size = (end - 1) - start;
+                size >>= 12; /* divide by PAGE_SIZE */
+                size++; /* end=start+4096 => 1 page */
+                switch (size) {
+                  case  1        : flush_tlb_range_1++;     break;
+                  case  2        : flush_tlb_range_2++;     break;
+                  case  3 ...  4 : flush_tlb_range_3_4++;   break;
+                  case  5 ...  7 : flush_tlb_range_5_7++;   break;
+                  case  8 ... 11 : flush_tlb_range_8_11++;  break;
+                  case 12 ... 15 : flush_tlb_range_12_15++; break;
+                  default        : flush_tlb_range_16_up++; break;
+                }
+        }
+#endif
+
+        if (mm->context == NO_CONTEXT)
+                return;
+
+        local_irq_save(flags);
+
+        start &= PAGE_MASK;
+        end &= PAGE_MASK;
+
+        match = ((mm->context & MMU_CONTEXT_ASID_MASK) << PTEH_ASID_SHIFT) | PTEH_VALID;
+
+        /* Flush ITLB */
+        for_each_itlb_entry(tlb) {
+                asm volatile ("getcfg   %1, 0, %0"
+                              : "=r" (pteh)
+                              : "r" (tlb) );
+
+                pteh_epn = pteh & PAGE_MASK;
+                pteh_low = pteh & ~PAGE_MASK;
+
+                if (pteh_low == match && pteh_epn >= start && pteh_epn <= end)
+                        __flush_tlb_slot(tlb);
+        }
+
+        /* Flush DTLB */
+        for_each_dtlb_entry(tlb) {
+                asm volatile ("getcfg   %1, 0, %0"
+                              : "=r" (pteh)
+                              : "r" (tlb) );
+
+                pteh_epn = pteh & PAGE_MASK;
+                pteh_low = pteh & ~PAGE_MASK;
+
+                if (pteh_low == match && pteh_epn >= start && pteh_epn <= end)
+                        __flush_tlb_slot(tlb);
+        }
+
+        local_irq_restore(flags);
+}
+
+void flush_tlb_mm(struct mm_struct *mm)
+{
+        unsigned long flags;
+
+#if defined(CONFIG_SH64_PROC_TLB)
+        ++calls_to_flush_tlb_mm;
+#endif
+
+        if (mm->context == NO_CONTEXT)
+                return;
+
+        local_irq_save(flags);
+
+        mm->context=NO_CONTEXT;
+        if(mm==current->mm)
+                activate_context(mm);
+
+        local_irq_restore(flags);
+
+}
+
+void flush_tlb_all(void)
+{
+        /* Invalidate all, including shared pages, excluding fixed TLBs */
+
+        unsigned long flags, tlb;
+
+#if defined(CONFIG_SH64_PROC_TLB)
+        ++calls_to_flush_tlb_all;
+#endif
+
+        local_irq_save(flags);
+
+        /* Flush each ITLB entry */
+        for_each_itlb_entry(tlb) {
+                __flush_tlb_slot(tlb);
+        }
+
+        /* Flush each DTLB entry */
+        for_each_dtlb_entry(tlb) {
+                __flush_tlb_slot(tlb);
+        }
+
+        local_irq_restore(flags);
+}
+
+void flush_tlb_kernel_range(unsigned long start, unsigned long end)
+{
+        /* FIXME: Optimize this later.. */
+        flush_tlb_all();
+}
+
+#if defined(CONFIG_SH64_PROC_TLB)
+/* Procfs interface to read the performance information */
+
+static int
+tlb_proc_info(char *buf, char **start, off_t fpos, int length, int *eof, void *data)
+{
+  int len=0;
+  len += sprintf(buf+len, "do_fast_page_fault   called %12lld times\n", calls_to_do_fast_page_fault);
+  len += sprintf(buf+len, "do_slow_page_fault   called %12lld times\n", calls_to_do_slow_page_fault);
+  len += sprintf(buf+len, "update_mmu_cache     called %12lld times\n", calls_to_update_mmu_cache);
+  len += sprintf(buf+len, "flush_tlb_page       called %12lld times\n", calls_to_flush_tlb_page);
+  len += sprintf(buf+len, "flush_tlb_range      called %12lld times\n", calls_to_flush_tlb_range);
+  len += sprintf(buf+len, "flush_tlb_mm         called %12lld times\n", calls_to_flush_tlb_mm);
+  len += sprintf(buf+len, "flush_tlb_all        called %12lld times\n", calls_to_flush_tlb_all);
+  len += sprintf(buf+len, "flush_tlb_range_sizes\n"
+                          " 1      : %12lld\n"
+                          " 2      : %12lld\n"
+                          " 3 -  4 : %12lld\n"
+                          " 5 -  7 : %12lld\n"
+                          " 8 - 11 : %12lld\n"
+                          "12 - 15 : %12lld\n"
+                          "16+     : %12lld\n",
+                          flush_tlb_range_1, flush_tlb_range_2, flush_tlb_range_3_4,
+                          flush_tlb_range_5_7, flush_tlb_range_8_11, flush_tlb_range_12_15,
+                          flush_tlb_range_16_up);
+  len += sprintf(buf+len, "page not present           %12lld times\n", page_not_present);
+  *eof = 1;
+  return len;
+}
+
+static int __init register_proc_tlb(void)
+{
+  create_proc_read_entry("tlb", 0, NULL, tlb_proc_info, NULL);
+  return 0;
+}
+
+__initcall(register_proc_tlb);
+
+#endif
diff --git a/arch/sh64/mm/hugetlbpage.c b/arch/sh64/mm/hugetlbpage.c
new file mode 100644
index 000000000000..bcad2aefa4ee
--- /dev/null
+++ b/arch/sh64/mm/hugetlbpage.c
@@ -0,0 +1,264 @@
+/*
+ * arch/sh64/mm/hugetlbpage.c
+ *
+ * SuperH HugeTLB page support.
+ *
+ * Cloned from sparc64 by Paul Mundt.
+ *
+ * Copyright (C) 2002, 2003 David S. Miller (davem@redhat.com)
+ */
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/hugetlb.h>
+#include <linux/pagemap.h>
+#include <linux/smp_lock.h>
+#include <linux/slab.h>
+#include <linux/sysctl.h>
+
+#include <asm/mman.h>
+#include <asm/pgalloc.h>
+#include <asm/tlb.h>
+#include <asm/tlbflush.h>
+#include <asm/cacheflush.h>
+
+static pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr)
+{
+        pgd_t *pgd;
+        pmd_t *pmd;
+        pte_t *pte = NULL;
+
+        pgd = pgd_offset(mm, addr);
+        if (pgd) {
+                pmd = pmd_alloc(mm, pgd, addr);
+                if (pmd)
+                        pte = pte_alloc_map(mm, pmd, addr);
+        }
+        return pte;
+}
+
+static pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
+{
+        pgd_t *pgd;
+        pmd_t *pmd;
+        pte_t *pte = NULL;
+
+        pgd = pgd_offset(mm, addr);
+        if (pgd) {
+                pmd = pmd_offset(pgd, addr);
+                if (pmd)
+                        pte = pte_offset_map(pmd, addr);
+        }
+        return pte;
+}
+
+#define mk_pte_huge(entry) do { pte_val(entry) |= _PAGE_SZHUGE; } while (0)
+
+static void set_huge_pte(struct mm_struct *mm, struct vm_area_struct *vma,
+                         struct page *page, pte_t * page_table, int write_access)
+{
+        unsigned long i;
+        pte_t entry;
+
+        add_mm_counter(mm, rss, HPAGE_SIZE / PAGE_SIZE);
+
+        if (write_access)
+                entry = pte_mkwrite(pte_mkdirty(mk_pte(page,
+                                                       vma->vm_page_prot)));
+        else
+                entry = pte_wrprotect(mk_pte(page, vma->vm_page_prot));
+        entry = pte_mkyoung(entry);
+        mk_pte_huge(entry);
+
+        for (i = 0; i < (1 << HUGETLB_PAGE_ORDER); i++) {
+                set_pte(page_table, entry);
+                page_table++;
+
+                pte_val(entry) += PAGE_SIZE;
+        }
+}
+
+/*
+ * This function checks for proper alignment of input addr and len parameters.
+ */
+int is_aligned_hugepage_range(unsigned long addr, unsigned long len)
+{
+        if (len & ~HPAGE_MASK)
+                return -EINVAL;
+        if (addr & ~HPAGE_MASK)
+                return -EINVAL;
+        return 0;
+}
+
+int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
+                            struct vm_area_struct *vma)
+{
+        pte_t *src_pte, *dst_pte, entry;
+        struct page *ptepage;
+        unsigned long addr = vma->vm_start;
+        unsigned long end = vma->vm_end;
+        int i;
+
+        while (addr < end) {
+                dst_pte = huge_pte_alloc(dst, addr);
+                if (!dst_pte)
+                        goto nomem;
+                src_pte = huge_pte_offset(src, addr);
+                BUG_ON(!src_pte || pte_none(*src_pte));
+                entry = *src_pte;
+                ptepage = pte_page(entry);
+                get_page(ptepage);
+                for (i = 0; i < (1 << HUGETLB_PAGE_ORDER); i++) {
+                        set_pte(dst_pte, entry);
+                        pte_val(entry) += PAGE_SIZE;
+                        dst_pte++;
+                }
+                add_mm_counter(dst, rss, HPAGE_SIZE / PAGE_SIZE);
+                addr += HPAGE_SIZE;
+        }
+        return 0;
+
+nomem:
+        return -ENOMEM;
+}
+
+int follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
+                        struct page **pages, struct vm_area_struct **vmas,
+                        unsigned long *position, int *length, int i)
+{
+        unsigned long vaddr = *position;
+        int remainder = *length;
+
+        WARN_ON(!is_vm_hugetlb_page(vma));
+
+        while (vaddr < vma->vm_end && remainder) {
+                if (pages) {
+                        pte_t *pte;
+                        struct page *page;
+
+                        pte = huge_pte_offset(mm, vaddr);
+
+                        /* hugetlb should be locked, and hence, prefaulted */
+                        BUG_ON(!pte || pte_none(*pte));
+
+                        page = pte_page(*pte);
+
+                        WARN_ON(!PageCompound(page));
+
+                        get_page(page);
+                        pages[i] = page;
+                }
+
+                if (vmas)
+                        vmas[i] = vma;
+
+                vaddr += PAGE_SIZE;
+                --remainder;
+                ++i;
+        }
+
+        *length = remainder;
+        *position = vaddr;
+
+        return i;
+}
+
+struct page *follow_huge_addr(struct mm_struct *mm,
+                              unsigned long address, int write)
+{
+        return ERR_PTR(-EINVAL);
+}
+
+int pmd_huge(pmd_t pmd)
+{
+        return 0;
+}
+
+struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
+                             pmd_t *pmd, int write)
+{
+        return NULL;
+}
+
+void unmap_hugepage_range(struct vm_area_struct *vma,
+                          unsigned long start, unsigned long end)
+{
+        struct mm_struct *mm = vma->vm_mm;
+        unsigned long address;
+        pte_t *pte;
+        struct page *page;
+        int i;
+
+        BUG_ON(start & (HPAGE_SIZE - 1));
+        BUG_ON(end & (HPAGE_SIZE - 1));
+
+        for (address = start; address < end; address += HPAGE_SIZE) {
+                pte = huge_pte_offset(mm, address);
+                BUG_ON(!pte);
+                if (pte_none(*pte))
+                        continue;
+                page = pte_page(*pte);
+                put_page(page);
+                for (i = 0; i < (1 << HUGETLB_PAGE_ORDER); i++) {
+                        pte_clear(mm, address+(i*PAGE_SIZE), pte);
+                        pte++;
+                }
+        }
+        add_mm_counter(mm, rss, -((end - start) >> PAGE_SHIFT));
+        flush_tlb_range(vma, start, end);
+}
+
+int hugetlb_prefault(struct address_space *mapping, struct vm_area_struct *vma)
+{
+        struct mm_struct *mm = current->mm;
+        unsigned long addr;
+        int ret = 0;
+
+        BUG_ON(vma->vm_start & ~HPAGE_MASK);
+        BUG_ON(vma->vm_end & ~HPAGE_MASK);
+
+        spin_lock(&mm->page_table_lock);
+        for (addr = vma->vm_start; addr < vma->vm_end; addr += HPAGE_SIZE) {
+                unsigned long idx;
+                pte_t *pte = huge_pte_alloc(mm, addr);
+                struct page *page;
+
+                if (!pte) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
+                if (!pte_none(*pte))
+                        continue;
+
+                idx = ((addr - vma->vm_start) >> HPAGE_SHIFT)
+                        + (vma->vm_pgoff >> (HPAGE_SHIFT - PAGE_SHIFT));
+                page = find_get_page(mapping, idx);
+                if (!page) {
+                        /* charge the fs quota first */
+                        if (hugetlb_get_quota(mapping)) {
+                                ret = -ENOMEM;
+                                goto out;
+                        }
+                        page = alloc_huge_page();
+                        if (!page) {
+                                hugetlb_put_quota(mapping);
+                                ret = -ENOMEM;
+                                goto out;
+                        }
+                        ret = add_to_page_cache(page, mapping, idx, GFP_ATOMIC);
+                        if (! ret) {
+                                unlock_page(page);
+                        } else {
+                                hugetlb_put_quota(mapping);
+                                free_huge_page(page);
+                                goto out;
+                        }
+                }
+                set_huge_pte(mm, vma, page, pte, vma->vm_flags & VM_WRITE);
+        }
+out:
+        spin_unlock(&mm->page_table_lock);
+        return ret;
+}
diff --git a/arch/sh64/mm/init.c b/arch/sh64/mm/init.c
new file mode 100644
index 000000000000..a65e8bb2c3cc
--- /dev/null
+++ b/arch/sh64/mm/init.c
@@ -0,0 +1,196 @@
+/*
+ * 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.
+ *
+ * arch/sh64/mm/init.c
+ *
+ * Copyright (C) 2000, 2001  Paolo Alberelli
+ * Copyright (C) 2003, 2004  Paul Mundt
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/rwsem.h>
+#include <linux/mm.h>
+#include <linux/swap.h>
+#include <linux/bootmem.h>
+
+#include <asm/mmu_context.h>
+#include <asm/page.h>
+#include <asm/pgalloc.h>
+#include <asm/pgtable.h>
+#include <asm/tlb.h>
+
+#ifdef CONFIG_BLK_DEV_INITRD
+#include <linux/blk.h>
+#endif
+
+DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
+
+/*
+ * Cache of MMU context last used.
+ */
+unsigned long mmu_context_cache;
+pgd_t * mmu_pdtp_cache;
+int after_bootmem = 0;
+
+/*
+ * BAD_PAGE is the page that is used for page faults when linux
+ * is out-of-memory. Older versions of linux just did a
+ * do_exit(), but using this instead means there is less risk
+ * for a process dying in kernel mode, possibly leaving an inode
+ * unused etc..
+ *
+ * BAD_PAGETABLE is the accompanying page-table: it is initialized
+ * to point to BAD_PAGE entries.
+ *
+ * ZERO_PAGE is a special page that is used for zero-initialized
+ * data and COW.
+ */
+
+extern unsigned char empty_zero_page[PAGE_SIZE];
+extern unsigned char empty_bad_page[PAGE_SIZE];
+extern pte_t empty_bad_pte_table[PTRS_PER_PTE];
+extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
+
+extern char _text, _etext, _edata, __bss_start, _end;
+extern char __init_begin, __init_end;
+
+/* It'd be good if these lines were in the standard header file. */
+#define START_PFN       (NODE_DATA(0)->bdata->node_boot_start >> PAGE_SHIFT)
+#define MAX_LOW_PFN     (NODE_DATA(0)->bdata->node_low_pfn)
+
+
+void show_mem(void)
+{
+        int i, total = 0, reserved = 0;
+        int shared = 0, cached = 0;
+
+        printk("Mem-info:\n");
+        show_free_areas();
+        printk("Free swap:       %6ldkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
+        i = max_mapnr;
+        while (i-- > 0) {
+                total++;
+                if (PageReserved(mem_map+i))
+                        reserved++;
+                else if (PageSwapCache(mem_map+i))
+                        cached++;
+                else if (page_count(mem_map+i))
+                        shared += page_count(mem_map+i) - 1;
+        }
+        printk("%d pages of RAM\n",total);
+        printk("%d reserved pages\n",reserved);
+        printk("%d pages shared\n",shared);
+        printk("%d pages swap cached\n",cached);
+        printk("%ld pages in page table cache\n",pgtable_cache_size);
+}
+
+/*
+ * paging_init() sets up the page tables.
+ *
+ * head.S already did a lot to set up address translation for the kernel.
+ * Here we comes with:
+ * . MMU enabled
+ * . ASID set (SR)
+ * .  some 512MB regions being mapped of which the most relevant here is:
+ *   . CACHED segment (ASID 0 [irrelevant], shared AND NOT user)
+ * . possible variable length regions being mapped as:
+ *   . UNCACHED segment (ASID 0 [irrelevant], shared AND NOT user)
+ * . All of the memory regions are placed, independently from the platform
+ *   on high addresses, above 0x80000000.
+ * . swapper_pg_dir is already cleared out by the .space directive
+ *   in any case swapper does not require a real page directory since
+ *   it's all kernel contained.
+ *
+ * Those pesky NULL-reference errors in the kernel are then
+ * dealt with by not mapping address 0x00000000 at all.
+ *
+ */
+void __init paging_init(void)
+{
+        unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0};
+
+        pgd_init((unsigned long)swapper_pg_dir);
+        pgd_init((unsigned long)swapper_pg_dir +
+                 sizeof(pgd_t) * USER_PTRS_PER_PGD);
+
+        mmu_context_cache = MMU_CONTEXT_FIRST_VERSION;
+
+        /*
+         * All memory is good as ZONE_NORMAL (fall-through) and ZONE_DMA.
+         */
+        zones_size[ZONE_DMA] = MAX_LOW_PFN - START_PFN;
+        NODE_DATA(0)->node_mem_map = NULL;
+        free_area_init_node(0, NODE_DATA(0), zones_size, __MEMORY_START >> PAGE_SHIFT, 0);
+}
+
+void __init mem_init(void)
+{
+        int codesize, reservedpages, datasize, initsize;
+        int tmp;
+
+        max_mapnr = num_physpages = MAX_LOW_PFN - START_PFN;
+        high_memory = (void *)__va(MAX_LOW_PFN * PAGE_SIZE);
+
+        /*
+         * Clear the zero-page.
+         * This is not required but we might want to re-use
+         * this very page to pass boot parameters, one day.
+         */
+        memset(empty_zero_page, 0, PAGE_SIZE);
+
+        /* this will put all low memory onto the freelists */
+        totalram_pages += free_all_bootmem_node(NODE_DATA(0));
+        reservedpages = 0;
+        for (tmp = 0; tmp < num_physpages; tmp++)
+                /*
+                 * Only count reserved RAM pages
+                 */
+                if (PageReserved(mem_map+tmp))
+                        reservedpages++;
+
+        after_bootmem = 1;
+
+        codesize =  (unsigned long) &_etext - (unsigned long) &_text;
+        datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
+        initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
+
+        printk("Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data, %dk init)\n",
+                (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
+                max_mapnr << (PAGE_SHIFT-10),
+                codesize >> 10,
+                reservedpages << (PAGE_SHIFT-10),
+                datasize >> 10,
+                initsize >> 10);
+}
+
+void free_initmem(void)
+{
+        unsigned long addr;
+
+        addr = (unsigned long)(&__init_begin);
+        for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
+                ClearPageReserved(virt_to_page(addr));
+                set_page_count(virt_to_page(addr), 1);
+                free_page(addr);
+                totalram_pages++;
+        }
+        printk ("Freeing unused kernel memory: %ldk freed\n", (&__init_end - &__init_begin) >> 10);
+}
+
+#ifdef CONFIG_BLK_DEV_INITRD
+void free_initrd_mem(unsigned long start, unsigned long end)
+{
+        unsigned long p;
+        for (p = start; p < end; p += PAGE_SIZE) {
+                ClearPageReserved(virt_to_page(p));
+                set_page_count(virt_to_page(p), 1);
+                free_page(p);
+                totalram_pages++;
+        }
+        printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
+}
+#endif
+
diff --git a/arch/sh64/mm/ioremap.c b/arch/sh64/mm/ioremap.c
new file mode 100644
index 000000000000..f4003da556bc
--- /dev/null
+++ b/arch/sh64/mm/ioremap.c
@@ -0,0 +1,469 @@
+/*
+ * 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.
+ *
+ * arch/sh64/mm/ioremap.c
+ *
+ * Copyright (C) 2000, 2001  Paolo Alberelli
+ * Copyright (C) 2003, 2004  Paul Mundt
+ *
+ * Mostly derived from arch/sh/mm/ioremap.c which, in turn is mostly
+ * derived from arch/i386/mm/ioremap.c .
+ *
+ *   (C) Copyright 1995 1996 Linus Torvalds
+ */
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <asm/io.h>
+#include <asm/pgalloc.h>
+#include <asm/tlbflush.h>
+#include <linux/ioport.h>
+#include <linux/bootmem.h>
+#include <linux/proc_fs.h>
+
+static void shmedia_mapioaddr(unsigned long, unsigned long);
+static unsigned long shmedia_ioremap(struct resource *, u32, int);
+
+static inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
+        unsigned long phys_addr, unsigned long flags)
+{
+        unsigned long end;
+        unsigned long pfn;
+        pgprot_t pgprot = __pgprot(_PAGE_PRESENT  | _PAGE_READ   |
+                                   _PAGE_WRITE    | _PAGE_DIRTY  |
+                                   _PAGE_ACCESSED | _PAGE_SHARED | flags);
+
+        address &= ~PMD_MASK;
+        end = address + size;
+        if (end > PMD_SIZE)
+                end = PMD_SIZE;
+        if (address >= end)
+                BUG();
+
+        pfn = phys_addr >> PAGE_SHIFT;
+
+        pr_debug("    %s: pte %p address %lx size %lx phys_addr %lx\n",
+                 __FUNCTION__,pte,address,size,phys_addr);
+
+        do {
+                if (!pte_none(*pte)) {
+                        printk("remap_area_pte: page already exists\n");
+                        BUG();
+                }
+
+                set_pte(pte, pfn_pte(pfn, pgprot));
+                address += PAGE_SIZE;
+                pfn++;
+                pte++;
+        } while (address && (address < end));
+}
+
+static inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
+        unsigned long phys_addr, unsigned long flags)
+{
+        unsigned long end;
+
+        address &= ~PGDIR_MASK;
+        end = address + size;
+
+        if (end > PGDIR_SIZE)
+                end = PGDIR_SIZE;
+
+        phys_addr -= address;
+
+        if (address >= end)
+                BUG();
+
+        do {
+                pte_t * pte = pte_alloc_kernel(&init_mm, pmd, address);
+                if (!pte)
+                        return -ENOMEM;
+                remap_area_pte(pte, address, end - address, address + phys_addr, flags);
+                address = (address + PMD_SIZE) & PMD_MASK;
+                pmd++;
+        } while (address && (address < end));
+        return 0;
+}
+
+static int remap_area_pages(unsigned long address, unsigned long phys_addr,
+                                 unsigned long size, unsigned long flags)
+{
+        int error;
+        pgd_t * dir;
+        unsigned long end = address + size;
+
+        phys_addr -= address;
+        dir = pgd_offset_k(address);
+        flush_cache_all();
+        if (address >= end)
+                BUG();
+        spin_lock(&init_mm.page_table_lock);
+        do {
+                pmd_t *pmd = pmd_alloc(&init_mm, dir, address);
+                error = -ENOMEM;
+                if (!pmd)
+                        break;
+                if (remap_area_pmd(pmd, address, end - address,
+                                   phys_addr + address, flags)) {
+                         break;
+                }
+                error = 0;
+                address = (address + PGDIR_SIZE) & PGDIR_MASK;
+                dir++;
+        } while (address && (address < end));
+        spin_unlock(&init_mm.page_table_lock);
+        flush_tlb_all();
+        return 0;
+}
+
+/*
+ * Generic mapping function (not visible outside):
+ */
+
+/*
+ * Remap an arbitrary physical address space into the kernel virtual
+ * address space. Needed when the kernel wants to access high addresses
+ * directly.
+ *
+ * NOTE! We need to allow non-page-aligned mappings too: we will obviously
+ * have to convert them into an offset in a page-aligned mapping, but the
+ * caller shouldn't need to know that small detail.
+ */
+void * __ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags)
+{
+        void * addr;
+        struct vm_struct * area;
+        unsigned long offset, last_addr;
+
+        /* Don't allow wraparound or zero size */
+        last_addr = phys_addr + size - 1;
+        if (!size || last_addr < phys_addr)
+                return NULL;
+
+        /*
+         * Mappings have to be page-aligned
+         */
+        offset = phys_addr & ~PAGE_MASK;
+        phys_addr &= PAGE_MASK;
+        size = PAGE_ALIGN(last_addr + 1) - phys_addr;
+
+        /*
+         * Ok, go for it..
+         */
+        area = get_vm_area(size, VM_IOREMAP);
+        pr_debug("Get vm_area returns %p addr %p\n",area,area->addr);
+        if (!area)
+                return NULL;
+        area->phys_addr = phys_addr;
+        addr = area->addr;
+        if (remap_area_pages((unsigned long)addr, phys_addr, size, flags)) {
+                vunmap(addr);
+                return NULL;
+        }
+        return (void *) (offset + (char *)addr);
+}
+
+void iounmap(void *addr)
+{
+        struct vm_struct *area;
+
+        vfree((void *) (PAGE_MASK & (unsigned long) addr));
+        area = remove_vm_area((void *) (PAGE_MASK & (unsigned long) addr));
+        if (!area) {
+                printk(KERN_ERR "iounmap: bad address %p\n", addr);
+                return;
+        }
+
+        kfree(area);
+}
+
+static struct resource shmedia_iomap = {
+        .name   = "shmedia_iomap",
+        .start  = IOBASE_VADDR + PAGE_SIZE,
+        .end    = IOBASE_END - 1,
+};
+
+static void shmedia_mapioaddr(unsigned long pa, unsigned long va);
+static void shmedia_unmapioaddr(unsigned long vaddr);
+static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz);
+
+/*
+ * We have the same problem as the SPARC, so lets have the same comment:
+ * Our mini-allocator...
+ * Boy this is gross! We need it because we must map I/O for
+ * timers and interrupt controller before the kmalloc is available.
+ */
+
+#define XNMLN  15
+#define XNRES  10
+
+struct xresource {
+        struct resource xres;   /* Must be first */
+        int xflag;              /* 1 == used */
+        char xname[XNMLN+1];
+};
+
+static struct xresource xresv[XNRES];
+
+static struct xresource *xres_alloc(void)
+{
+        struct xresource *xrp;
+        int n;
+
+        xrp = xresv;
+        for (n = 0; n < XNRES; n++) {
+                if (xrp->xflag == 0) {
+                        xrp->xflag = 1;
+                        return xrp;
+                }
+                xrp++;
+        }
+        return NULL;
+}
+
+static void xres_free(struct xresource *xrp)
+{
+        xrp->xflag = 0;
+}
+
+static struct resource *shmedia_find_resource(struct resource *root,
+                                              unsigned long vaddr)
+{
+        struct resource *res;
+
+        for (res = root->child; res; res = res->sibling)
+                if (res->start <= vaddr && res->end >= vaddr)
+                        return res;
+
+        return NULL;
+}
+
+static unsigned long shmedia_alloc_io(unsigned long phys, unsigned long size,
+                                      const char *name)
+{
+        static int printed_full = 0;
+        struct xresource *xres;
+        struct resource *res;
+        char *tack;
+        int tlen;
+
+        if (name == NULL) name = "???";
+
+        if ((xres = xres_alloc()) != 0) {
+                tack = xres->xname;
+                res = &xres->xres;
+        } else {
+                if (!printed_full) {
+                        printk("%s: done with statics, switching to kmalloc\n",
+                               __FUNCTION__);
+                        printed_full = 1;
+                }
+                tlen = strlen(name);
+                tack = kmalloc(sizeof (struct resource) + tlen + 1, GFP_KERNEL);
+                if (!tack)
+                        return -ENOMEM;
+                memset(tack, 0, sizeof(struct resource));
+                res = (struct resource *) tack;
+                tack += sizeof (struct resource);
+        }
+
+        strncpy(tack, name, XNMLN);
+        tack[XNMLN] = 0;
+        res->name = tack;
+
+        return shmedia_ioremap(res, phys, size);
+}
+
+static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz)
+{
+        unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
+        unsigned long round_sz = (offset + sz + PAGE_SIZE-1) & PAGE_MASK;
+        unsigned long va;
+        unsigned int psz;
+
+        if (allocate_resource(&shmedia_iomap, res, round_sz,
+                              shmedia_iomap.start, shmedia_iomap.end,
+                              PAGE_SIZE, NULL, NULL) != 0) {
+                panic("alloc_io_res(%s): cannot occupy\n",
+                    (res->name != NULL)? res->name: "???");
+        }
+
+        va = res->start;
+        pa &= PAGE_MASK;
+
+        psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
+
+        /* log at boot time ... */
+        printk("mapioaddr: %6s  [%2d page%s]  va 0x%08lx   pa 0x%08x\n",
+               ((res->name != NULL) ? res->name : "???"),
+               psz, psz == 1 ? " " : "s", va, pa);
+
+        for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
+                shmedia_mapioaddr(pa, va);
+                va += PAGE_SIZE;
+                pa += PAGE_SIZE;
+        }
+
+        res->start += offset;
+        res->end = res->start + sz - 1;         /* not strictly necessary.. */
+
+        return res->start;
+}
+
+static void shmedia_free_io(struct resource *res)
+{
+        unsigned long len = res->end - res->start + 1;
+
+        BUG_ON((len & (PAGE_SIZE - 1)) != 0);
+
+        while (len) {
+                len -= PAGE_SIZE;
+                shmedia_unmapioaddr(res->start + len);
+        }
+
+        release_resource(res);
+}
+
+static void *sh64_get_page(void)
+{
+        extern int after_bootmem;
+        void *page;
+
+        if (after_bootmem) {
+                page = (void *)get_zeroed_page(GFP_ATOMIC);
+        } else {
+                page = alloc_bootmem_pages(PAGE_SIZE);
+        }
+
+        if (!page || ((unsigned long)page & ~PAGE_MASK))
+                panic("sh64_get_page: Out of memory already?\n");
+
+        return page;
+}
+
+static void shmedia_mapioaddr(unsigned long pa, unsigned long va)
+{
+        pgd_t *pgdp;
+        pmd_t *pmdp;
+        pte_t *ptep, pte;
+        pgprot_t prot;
+        unsigned long flags = 1; /* 1 = CB0-1 device */
+
+        pr_debug("shmedia_mapiopage pa %08lx va %08lx\n",  pa, va);
+
+        pgdp = pgd_offset_k(va);
+        if (pgd_none(*pgdp) || !pgd_present(*pgdp)) {
+                pmdp = (pmd_t *)sh64_get_page();
+                set_pgd(pgdp, __pgd((unsigned long)pmdp | _KERNPG_TABLE));
+        }
+
+        pmdp = pmd_offset(pgdp, va);
+        if (pmd_none(*pmdp) || !pmd_present(*pmdp) ) {
+                ptep = (pte_t *)sh64_get_page();
+                set_pmd(pmdp, __pmd((unsigned long)ptep + _PAGE_TABLE));
+        }
+
+        prot = __pgprot(_PAGE_PRESENT | _PAGE_READ     | _PAGE_WRITE  |
+                        _PAGE_DIRTY   | _PAGE_ACCESSED | _PAGE_SHARED | flags);
+
+        pte = pfn_pte(pa >> PAGE_SHIFT, prot);
+        ptep = pte_offset_kernel(pmdp, va);
+
+        if (!pte_none(*ptep) &&
+            pte_val(*ptep) != pte_val(pte))
+                pte_ERROR(*ptep);
+
+        set_pte(ptep, pte);
+
+        flush_tlb_kernel_range(va, PAGE_SIZE);
+}
+
+static void shmedia_unmapioaddr(unsigned long vaddr)
+{
+        pgd_t *pgdp;
+        pmd_t *pmdp;
+        pte_t *ptep;
+
+        pgdp = pgd_offset_k(vaddr);
+        pmdp = pmd_offset(pgdp, vaddr);
+
+        if (pmd_none(*pmdp) || pmd_bad(*pmdp))
+                return;
+
+        ptep = pte_offset_kernel(pmdp, vaddr);
+
+        if (pte_none(*ptep) || !pte_present(*ptep))
+                return;
+
+        clear_page((void *)ptep);
+        pte_clear(&init_mm, vaddr, ptep);
+}
+
+unsigned long onchip_remap(unsigned long phys, unsigned long size, const char *name)
+{
+        if (size < PAGE_SIZE)
+                size = PAGE_SIZE;
+
+        return shmedia_alloc_io(phys, size, name);
+}
+
+void onchip_unmap(unsigned long vaddr)
+{
+        struct resource *res;
+        unsigned int psz;
+
+        res = shmedia_find_resource(&shmedia_iomap, vaddr);
+        if (!res) {
+                printk(KERN_ERR "%s: Failed to free 0x%08lx\n",
+                       __FUNCTION__, vaddr);
+                return;
+        }
+
+        psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
+
+        printk(KERN_DEBUG "unmapioaddr: %6s  [%2d page%s] freed\n",
+               res->name, psz, psz == 1 ? " " : "s");
+
+        shmedia_free_io(res);
+
+        if ((char *)res >= (char *)xresv &&
+            (char *)res <  (char *)&xresv[XNRES]) {
+                xres_free((struct xresource *)res);
+        } else {
+                kfree(res);
+        }
+}
+
+#ifdef CONFIG_PROC_FS
+static int
+ioremap_proc_info(char *buf, char **start, off_t fpos, int length, int *eof,
+                  void *data)
+{
+        char *p = buf, *e = buf + length;
+        struct resource *r;
+        const char *nm;
+
+        for (r = ((struct resource *)data)->child; r != NULL; r = r->sibling) {
+                if (p + 32 >= e)        /* Better than nothing */
+                        break;
+                if ((nm = r->name) == 0) nm = "???";
+                p += sprintf(p, "%08lx-%08lx: %s\n", r->start, r->end, nm);
+        }
+
+        return p-buf;
+}
+#endif /* CONFIG_PROC_FS */
+
+static int __init register_proc_onchip(void)
+{
+#ifdef CONFIG_PROC_FS
+        create_proc_read_entry("io_map",0,0, ioremap_proc_info, &shmedia_iomap);
+#endif
+        return 0;
+}
+
+__initcall(register_proc_onchip);
diff --git a/arch/sh64/mm/tlb.c b/arch/sh64/mm/tlb.c
new file mode 100644
index 000000000000..d517e7d70340
--- /dev/null
+++ b/arch/sh64/mm/tlb.c
@@ -0,0 +1,166 @@
+/*
+ * arch/sh64/mm/tlb.c
+ *
+ * Copyright (C) 2003  Paul Mundt <lethal@linux-sh.org>
+ * Copyright (C) 2003  Richard Curnow <richard.curnow@superh.com>
+ *
+ * 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.
+ *
+ */
+#include <linux/mm.h>
+#include <linux/init.h>
+#include <asm/page.h>
+#include <asm/tlb.h>
+#include <asm/mmu_context.h>
+
+/**
+ * sh64_tlb_init
+ *
+ * Perform initial setup for the DTLB and ITLB.
+ */
+int __init sh64_tlb_init(void)
+{
+        /* Assign some sane DTLB defaults */
+        cpu_data->dtlb.entries  = 64;
+        cpu_data->dtlb.step     = 0x10;
+
+        cpu_data->dtlb.first    = DTLB_FIXED | cpu_data->dtlb.step;
+        cpu_data->dtlb.next     = cpu_data->dtlb.first;
+
+        cpu_data->dtlb.last     = DTLB_FIXED |
+                                  ((cpu_data->dtlb.entries - 1) *
+                                   cpu_data->dtlb.step);
+
+        /* And again for the ITLB */
+        cpu_data->itlb.entries  = 64;
+        cpu_data->itlb.step     = 0x10;
+
+        cpu_data->itlb.first    = ITLB_FIXED | cpu_data->itlb.step;
+        cpu_data->itlb.next     = cpu_data->itlb.first;
+        cpu_data->itlb.last     = ITLB_FIXED |
+                                  ((cpu_data->itlb.entries - 1) *
+                                   cpu_data->itlb.step);
+
+        return 0;
+}
+
+/**
+ * sh64_next_free_dtlb_entry
+ *
+ * Find the next available DTLB entry
+ */
+unsigned long long sh64_next_free_dtlb_entry(void)
+{
+        return cpu_data->dtlb.next;
+}
+
+/**
+ * sh64_get_wired_dtlb_entry
+ *
+ * Allocate a wired (locked-in) entry in the DTLB
+ */
+unsigned long long sh64_get_wired_dtlb_entry(void)
+{
+        unsigned long long entry = sh64_next_free_dtlb_entry();
+
+        cpu_data->dtlb.first += cpu_data->dtlb.step;
+        cpu_data->dtlb.next  += cpu_data->dtlb.step;
+
+        return entry;
+}
+
+/**
+ * sh64_put_wired_dtlb_entry
+ *
+ * @entry:      Address of TLB slot.
+ *
+ * Free a wired (locked-in) entry in the DTLB.
+ *
+ * Works like a stack, last one to allocate must be first one to free.
+ */
+int sh64_put_wired_dtlb_entry(unsigned long long entry)
+{
+        __flush_tlb_slot(entry);
+
+        /*
+         * We don't do any particularly useful tracking of wired entries,
+         * so this approach works like a stack .. last one to be allocated
+         * has to be the first one to be freed.
+         *
+         * We could potentially load wired entries into a list and work on
+         * rebalancing the list periodically (which also entails moving the
+         * contents of a TLB entry) .. though I have a feeling that this is
+         * more trouble than it's worth.
+         */
+
+        /*
+         * Entry must be valid .. we don't want any ITLB addresses!
+         */
+        if (entry <= DTLB_FIXED)
+                return -EINVAL;
+
+        /*
+         * Next, check if we're within range to be freed. (ie, must be the
+         * entry beneath the first 'free' entry!
+         */
+        if (entry < (cpu_data->dtlb.first - cpu_data->dtlb.step))
+                return -EINVAL;
+
+        /* If we are, then bring this entry back into the list */
+        cpu_data->dtlb.first    -= cpu_data->dtlb.step;
+        cpu_data->dtlb.next     = entry;
+
+        return 0;
+}
+
+/**
+ * sh64_setup_tlb_slot
+ *
+ * @config_addr:        Address of TLB slot.
+ * @eaddr:              Virtual address.
+ * @asid:               Address Space Identifier.
+ * @paddr:              Physical address.
+ *
+ * Load up a virtual<->physical translation for @eaddr<->@paddr in the
+ * pre-allocated TLB slot @config_addr (see sh64_get_wired_dtlb_entry).
+ */
+inline void sh64_setup_tlb_slot(unsigned long long config_addr,
+                                unsigned long eaddr,
+                                unsigned long asid,
+                                unsigned long paddr)
+{
+        unsigned long long pteh, ptel;
+
+        /* Sign extension */
+#if (NEFF == 32)
+        pteh = (unsigned long long)(signed long long)(signed long) eaddr;
+#else
+#error "Can't sign extend more than 32 bits yet"
+#endif
+        pteh &= PAGE_MASK;
+        pteh |= (asid << PTEH_ASID_SHIFT) | PTEH_VALID;
+#if (NEFF == 32)
+        ptel = (unsigned long long)(signed long long)(signed long) paddr;
+#else
+#error "Can't sign extend more than 32 bits yet"
+#endif
+        ptel &= PAGE_MASK;
+        ptel |= (_PAGE_CACHABLE | _PAGE_READ | _PAGE_WRITE);
+
+        asm volatile("putcfg %0, 1, %1\n\t"
+                        "putcfg %0, 0, %2\n"
+                        : : "r" (config_addr), "r" (ptel), "r" (pteh));
+}
+
+/**
+ * sh64_teardown_tlb_slot
+ *
+ * @config_addr:        Address of TLB slot.
+ *
+ * Teardown any existing mapping in the TLB slot @config_addr.
+ */
+inline void sh64_teardown_tlb_slot(unsigned long long config_addr)
+        __attribute__ ((alias("__flush_tlb_slot")));
+
diff --git a/arch/sh64/mm/tlbmiss.c b/arch/sh64/mm/tlbmiss.c
new file mode 100644
index 000000000000..c8615954aaa9
--- /dev/null
+++ b/arch/sh64/mm/tlbmiss.c
@@ -0,0 +1,280 @@
+/*
+ * 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.
+ *
+ * arch/sh64/mm/tlbmiss.c
+ *
+ * Original code from fault.c
+ * Copyright (C) 2000, 2001  Paolo Alberelli
+ *
+ * Fast PTE->TLB refill path
+ * Copyright (C) 2003 Richard.Curnow@superh.com
+ *
+ * IMPORTANT NOTES :
+ * The do_fast_page_fault function is called from a context in entry.S where very few registers
+ * have been saved.  In particular, the code in this file must be compiled not to use ANY
+ * caller-save regiseters that are not part of the restricted save set.  Also, it means that
+ * code in this file must not make calls to functions elsewhere in the kernel, or else the
+ * excepting context will see corruption in its caller-save registers.  Plus, the entry.S save
+ * area is non-reentrant, so this code has to run with SR.BL==1, i.e. no interrupts taken inside
+ * it and panic on any exception.
+ *
+ */
+
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/ptrace.h>
+#include <linux/mman.h>
+#include <linux/mm.h>
+#include <linux/smp.h>
+#include <linux/smp_lock.h>
+#include <linux/interrupt.h>
+
+#include <asm/system.h>
+#include <asm/tlb.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/pgalloc.h>
+#include <asm/mmu_context.h>
+#include <asm/registers.h>              /* required by inline asm statements */
+
+/* Callable from fault.c, so not static */
+inline void __do_tlb_refill(unsigned long address,
+                            unsigned long long is_text_not_data, pte_t *pte)
+{
+        unsigned long long ptel;
+        unsigned long long pteh=0;
+        struct tlb_info *tlbp;
+        unsigned long long next;
+
+        /* Get PTEL first */
+        ptel = pte_val(*pte);
+
+        /*
+         * Set PTEH register
+         */
+        pteh = address & MMU_VPN_MASK;
+
+        /* Sign extend based on neff. */
+#if (NEFF == 32)
+        /* Faster sign extension */
+        pteh = (unsigned long long)(signed long long)(signed long)pteh;
+#else
+        /* General case */
+        pteh = (pteh & NEFF_SIGN) ? (pteh | NEFF_MASK) : pteh;
+#endif
+
+        /* Set the ASID. */
+        pteh |= get_asid() << PTEH_ASID_SHIFT;
+        pteh |= PTEH_VALID;
+
+        /* Set PTEL register, set_pte has performed the sign extension */
+        ptel &= _PAGE_FLAGS_HARDWARE_MASK; /* drop software flags */
+
+        tlbp = is_text_not_data ? &(cpu_data->itlb) : &(cpu_data->dtlb);
+        next = tlbp->next;
+        __flush_tlb_slot(next);
+        asm volatile ("putcfg %0,1,%2\n\n\t"
+                      "putcfg %0,0,%1\n"
+                      :  : "r" (next), "r" (pteh), "r" (ptel) );
+
+        next += TLB_STEP;
+        if (next > tlbp->last) next = tlbp->first;
+        tlbp->next = next;
+
+}
+
+static int handle_vmalloc_fault(struct mm_struct *mm, unsigned long protection_flags,
+                                unsigned long long textaccess,
+                                unsigned long address)
+{
+        pgd_t *dir;
+        pmd_t *pmd;
+        static pte_t *pte;
+        pte_t entry;
+
+        dir = pgd_offset_k(address);
+        pmd = pmd_offset(dir, address);
+
+        if (pmd_none(*pmd)) {
+                return 0;
+        }
+
+        if (pmd_bad(*pmd)) {
+                pmd_clear(pmd);
+                return 0;
+        }
+
+        pte = pte_offset_kernel(pmd, address);
+        entry = *pte;
+
+        if (pte_none(entry) || !pte_present(entry)) {
+                return 0;
+        }
+
+        if ((pte_val(entry) & protection_flags) != protection_flags) {
+                return 0;
+        }
+
+        __do_tlb_refill(address, textaccess, pte);
+
+        return 1;
+}
+
+static int handle_tlbmiss(struct mm_struct *mm, unsigned long long protection_flags,
+                        unsigned long long textaccess,
+                        unsigned long address)
+{
+        pgd_t *dir;
+        pmd_t *pmd;
+        pte_t *pte;
+        pte_t entry;
+
+        /* NB. The PGD currently only contains a single entry - there is no
+           page table tree stored for the top half of the address space since
+           virtual pages in that region should never be mapped in user mode.
+           (In kernel mode, the only things in that region are the 512Mb super
+           page (locked in), and vmalloc (modules) +  I/O device pages (handled
+           by handle_vmalloc_fault), so no PGD for the upper half is required
+           by kernel mode either).
+
+           See how mm->pgd is allocated and initialised in pgd_alloc to see why
+           the next test is necessary.  - RPC */
+        if (address >= (unsigned long) TASK_SIZE) {
+                /* upper half - never has page table entries. */
+                return 0;
+        }
+        dir = pgd_offset(mm, address);
+        if (pgd_none(*dir)) {
+                return 0;
+        }
+        if (!pgd_present(*dir)) {
+                return 0;
+        }
+
+        pmd = pmd_offset(dir, address);
+        if (pmd_none(*pmd)) {
+                return 0;
+        }
+        if (!pmd_present(*pmd)) {
+                return 0;
+        }
+        pte = pte_offset_kernel(pmd, address);
+        entry = *pte;
+        if (pte_none(entry)) {
+                return 0;
+        }
+        if (!pte_present(entry)) {
+                return 0;
+        }
+
+        /* If the page doesn't have sufficient protection bits set to service the
+           kind of fault being handled, there's not much point doing the TLB refill.
+           Punt the fault to the general handler. */
+        if ((pte_val(entry) & protection_flags) != protection_flags) {
+                return 0;
+        }
+
+        __do_tlb_refill(address, textaccess, pte);
+
+        return 1;
+}
+
+/* Put all this information into one structure so that everything is just arithmetic
+   relative to a single base address.  This reduces the number of movi/shori pairs needed
+   just to load addresses of static data. */
+struct expevt_lookup {
+        unsigned short protection_flags[8];
+        unsigned char  is_text_access[8];
+        unsigned char  is_write_access[8];
+};
+
+#define PRU (1<<9)
+#define PRW (1<<8)
+#define PRX (1<<7)
+#define PRR (1<<6)
+
+#define DIRTY (_PAGE_DIRTY | _PAGE_ACCESSED)
+#define YOUNG (_PAGE_ACCESSED)
+
+/* Sized as 8 rather than 4 to allow checking the PTE's PRU bit against whether
+   the fault happened in user mode or privileged mode. */
+static struct expevt_lookup expevt_lookup_table = {
+        .protection_flags = {PRX, PRX, 0, 0, PRR, PRR, PRW, PRW},
+        .is_text_access   = {1,   1,   0, 0, 0,   0,   0,   0}
+};
+
+/*
+   This routine handles page faults that can be serviced just by refilling a
+   TLB entry from an existing page table entry.  (This case represents a very
+   large majority of page faults.) Return 1 if the fault was successfully
+   handled.  Return 0 if the fault could not be handled.  (This leads into the
+   general fault handling in fault.c which deals with mapping file-backed
+   pages, stack growth, segmentation faults, swapping etc etc)
+ */
+asmlinkage int do_fast_page_fault(unsigned long long ssr_md, unsigned long long expevt,
+                                  unsigned long address)
+{
+        struct task_struct *tsk;
+        struct mm_struct *mm;
+        unsigned long long textaccess;
+        unsigned long long protection_flags;
+        unsigned long long index;
+        unsigned long long expevt4;
+
+        /* The next few lines implement a way of hashing EXPEVT into a small array index
+           which can be used to lookup parameters specific to the type of TLBMISS being
+           handled.  Note:
+           ITLBMISS has EXPEVT==0xa40
+           RTLBMISS has EXPEVT==0x040
+           WTLBMISS has EXPEVT==0x060
+        */
+
+        expevt4 = (expevt >> 4);
+        /* TODO : xor ssr_md into this expression too.  Then we can check that PRU is set
+           when it needs to be. */
+        index = expevt4 ^ (expevt4 >> 5);
+        index &= 7;
+        protection_flags = expevt_lookup_table.protection_flags[index];
+        textaccess       = expevt_lookup_table.is_text_access[index];
+
+#ifdef CONFIG_SH64_PROC_TLB
+        ++calls_to_do_fast_page_fault;
+#endif
+
+        /* SIM
+         * Note this is now called with interrupts still disabled
+         * This is to cope with being called for a missing IO port
+         * address with interupts disabled. This should be fixed as
+         * soon as we have a better 'fast path' miss handler.
+         *
+         * Plus take care how you try and debug this stuff.
+         * For example, writing debug data to a port which you
+         * have just faulted on is not going to work.
+         */
+
+        tsk = current;
+        mm = tsk->mm;
+
+        if ((address >= VMALLOC_START && address < VMALLOC_END) ||
+            (address >= IOBASE_VADDR  && address < IOBASE_END)) {
+                if (ssr_md) {
+                        /* Process-contexts can never have this address range mapped */
+                        if (handle_vmalloc_fault(mm, protection_flags, textaccess, address)) {
+                                return 1;
+                        }
+                }
+        } else if (!in_interrupt() && mm) {
+                if (handle_tlbmiss(mm, protection_flags, textaccess, address)) {
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+