void copy_page(void *to, void *from);
 
 typedef unsigned long pte_t;
-typedef unsigned long pmd_t;
 typedef unsigned long pgd_t;
 typedef unsigned long pgprot_t;
 
 #define pte_val(x)      (x)
-#define pmd_val(x)      (x)
 #define pgd_val(x)     (x)
 #define pgprot_val(x)   (x)
 
 #define __pte(x)        (x)
-#define __pmd(x)        (x)
 #define __pgd(x)        (x)
 #define __pgprot(x)     (x)
 
 
 /*
  * Since we have only two-level page tables, these are trivial
  */
-#define pmd_alloc_one(mm, addr)                ({ BUG(); ((pmd_t *)2); })
-#define pmd_free(mm, pmd)                      do { } while (0)
-#define pgd_populate(mm, pmd, pte)     BUG()
 #define pmd_pgtable(pmd) pmd_page(pmd)
 
 extern pgd_t *pgd_alloc(struct mm_struct *mm);
 
 #ifndef _ASMNDS32_PGTABLE_H
 #define _ASMNDS32_PGTABLE_H
 
-#define __PAGETABLE_PMD_FOLDED 1
-#include <asm-generic/4level-fixup.h>
+#include <asm-generic/pgtable-nopmd.h>
 #include <linux/sizes.h>
 
 #include <asm/memory.h>
 #ifdef CONFIG_ANDES_PAGE_SIZE_4KB
 #define PGDIR_SHIFT      22
 #define PTRS_PER_PGD     1024
-#define PMD_SHIFT        22
-#define PTRS_PER_PMD     1
 #define PTRS_PER_PTE     1024
 #endif
 
 #ifdef CONFIG_ANDES_PAGE_SIZE_8KB
 #define PGDIR_SHIFT      24
 #define PTRS_PER_PGD     256
-#define PMD_SHIFT        24
-#define PTRS_PER_PMD     1
 #define PTRS_PER_PTE     2048
 #endif
 
 #ifndef __ASSEMBLY__
 extern void __pte_error(const char *file, int line, unsigned long val);
-extern void __pmd_error(const char *file, int line, unsigned long val);
 extern void __pgd_error(const char *file, int line, unsigned long val);
 
 #define pte_ERROR(pte)         __pte_error(__FILE__, __LINE__, pte_val(pte))
-#define pmd_ERROR(pmd)         __pmd_error(__FILE__, __LINE__, pmd_val(pmd))
 #define pgd_ERROR(pgd)         __pgd_error(__FILE__, __LINE__, pgd_val(pgd))
 #endif /* !__ASSEMBLY__ */
 
 /* to find an entry in a kernel page-table-directory */
 #define pgd_offset_k(addr)      pgd_offset(&init_mm, addr)
 
-/* Find an entry in the second-level page table.. */
-#define pmd_offset(dir, addr)  ((pmd_t *)(dir))
-
 static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
 {
        const unsigned long mask = 0xfff;
 
 #include <asm-generic/tlb.h>
 
 #define __pte_free_tlb(tlb, pte, addr) pte_free((tlb)->mm, pte)
-#define __pmd_free_tlb(tlb, pmd, addr) pmd_free((tln)->mm, pmd)
 
 #endif
 
 static void nds32_suspend2ram(void)
 {
        pgd_t *pgdv;
+       p4d_t *p4dv;
        pud_t *pudv;
        pmd_t *pmdv;
        pte_t *ptev;
        pgdv = (pgd_t *)__va((__nds32__mfsr(NDS32_SR_L1_PPTB) &
                L1_PPTB_mskBASE)) + pgd_index((unsigned int)cpu_resume);
 
-       pudv = pud_offset(pgdv, (unsigned int)cpu_resume);
+       p4dv = p4d_offset(pgdv, (unsigned int)cpu_resume);
+       pudv = pud_offset(p4dv, (unsigned int)cpu_resume);
        pmdv = pmd_offset(pudv, (unsigned int)cpu_resume);
        ptev = pte_offset_map(pmdv, (unsigned int)cpu_resume);
 
 
        pr_alert("[%08lx] *pgd=%08lx", addr, pgd_val(*pgd));
 
        do {
+               p4d_t *p4d;
+               pud_t *pud;
                pmd_t *pmd;
 
                if (pgd_none(*pgd))
                        break;
                }
 
-               pmd = pmd_offset(pgd, addr);
+               p4d = p4d_offset(pgd, addr);
+               pud = pud_offset(p4d, addr);
+               pmd = pmd_offset(pud, addr);
 #if PTRS_PER_PMD != 1
                pr_alert(", *pmd=%08lx", pmd_val(*pmd));
 #endif
 
                unsigned int index = pgd_index(addr);
                pgd_t *pgd, *pgd_k;
+               p4d_t *p4d, *p4d_k;
                pud_t *pud, *pud_k;
                pmd_t *pmd, *pmd_k;
                pte_t *pte_k;
                if (!pgd_present(*pgd_k))
                        goto no_context;
 
-               pud = pud_offset(pgd, addr);
-               pud_k = pud_offset(pgd_k, addr);
+               p4d = p4d_offset(pgd, addr);
+               p4d_k = p4d_offset(pgd_k, addr);
+               if (!p4d_present(*p4d_k))
+                       goto no_context;
+
+               pud = pud_offset(p4d, addr);
+               pud_k = pud_offset(p4d_k, addr);
                if (!pud_present(*pud_k))
                        goto no_context;
 
 
 {
        unsigned long v, p, e;
        pgd_t *pge;
+       p4d_t *p4e;
        pud_t *pue;
        pmd_t *pme;
        pte_t *pte;
 
        while (p < e) {
                int j;
-               pue = pud_offset(pge, v);
+               p4e = p4d_offset(pge, v);
+               pue = pud_offset(p4e, v);
                pme = pmd_offset(pue, v);
 
                if ((u32) pue != (u32) pge || (u32) pme != (u32) pge) {
 {
        unsigned long vaddr;
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
 #ifdef CONFIG_HIGHMEM
         */
        vaddr = __fix_to_virt(__end_of_fixed_addresses - 1);
        pgd = swapper_pg_dir + pgd_index(vaddr);
-       pud = pud_offset(pgd, vaddr);
+       p4d = p4d_offset(pgd, vaddr);
+       pud = pud_offset(p4d, vaddr);
        pmd = pmd_offset(pud, vaddr);
        fixmap_pmd_p = memblock_alloc(PAGE_SIZE, PAGE_SIZE);
        if (!fixmap_pmd_p)
        vaddr = PKMAP_BASE;
 
        pgd = swapper_pg_dir + pgd_index(vaddr);
-       pud = pud_offset(pgd, vaddr);
+       p4d = p4d_offset(pgd, vaddr);
+       pud = pud_offset(p4d, vaddr);
        pmd = pmd_offset(pud, vaddr);
        pte = memblock_alloc(PAGE_SIZE, PAGE_SIZE);
        if (!pte)
 
 {
        unsigned long pmdval;
        pgd_t *pgd;
+       p4d_t *p4d;
+       pud_t *pud;
        pmd_t *pmd;
        int i;
 
 
        for (i = 0; i < USER_PTRS_PER_PGD; i++) {
                pmdval = (i << PGDIR_SHIFT);
-               pmd = pmd_offset(pgd + i, i << PGDIR_SHIFT);
+               p4d = p4d_offset(pgd, i << PGDIR_SHIFT);
+               pud = pud_offset(p4d, i << PGDIR_SHIFT);
+               pmd = pmd_offset(pud + i, i << PGDIR_SHIFT);
                set_pmd(pmd, __pmd(pmdval));
        }
 }
 
 
 int va_kernel_present(unsigned long addr)
 {
+       p4d_t *p4d;
+       pud_t *pud;
        pmd_t *pmd;
        pte_t *ptep, pte;
 
-       pmd = pmd_offset(pgd_offset_k(addr), addr);
+       p4d = p4d_offset(pgd_offset_k(addr), addr);
+       pud = pud_offset(p4d, addr);
+       pmd = pmd_offset(pud, addr);
        if (!pmd_none(*pmd)) {
                ptep = pte_offset_map(pmd, addr);
                pte = *ptep;
 pte_t va_present(struct mm_struct * mm, unsigned long addr)
 {
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *ptep, pte;
 
        pgd = pgd_offset(mm, addr);
        if (!pgd_none(*pgd)) {
-               pud = pud_offset(pgd, addr);
-               if (!pud_none(*pud)) {
-                       pmd = pmd_offset(pud, addr);
-                       if (!pmd_none(*pmd)) {
-                               ptep = pte_offset_map(pmd, addr);
-                               pte = *ptep;
-                               if (pte_present(pte))
-                                       return pte;
+               p4d = p4d_offset(pgd, addr);
+               if (!p4d_none(*p4d)) {
+                       pud = pud_offset(p4d, addr);
+                       if (!pud_none(*pud)) {
+                               pmd = pmd_offset(pud, addr);
+                               if (!pmd_none(*pmd)) {
+                                       ptep = pte_offset_map(pmd, addr);
+                                       pte = *ptep;
+                                       if (pte_present(pte))
+                                               return pte;
+                               }
                        }
                }
        }