#ifndef __ASM_SH_PGTABLE_2LEVEL_H
 #define __ASM_SH_PGTABLE_2LEVEL_H
 
-#define __ARCH_USE_5LEVEL_HACK
 #include <asm-generic/pgtable-nopmd.h>
 
 /*
 
 #ifndef __ASM_SH_PGTABLE_3LEVEL_H
 #define __ASM_SH_PGTABLE_3LEVEL_H
 
-#define __ARCH_USE_5LEVEL_HACK
 #include <asm-generic/pgtable-nopud.h>
 
 /*
 
 static struct trapped_io *lookup_tiop(unsigned long address)
 {
        pgd_t *pgd_k;
+       p4d_t *p4d_k;
        pud_t *pud_k;
        pmd_t *pmd_k;
        pte_t *pte_k;
        if (!pgd_present(*pgd_k))
                return NULL;
 
-       pud_k = pud_offset(pgd_k, address);
+       p4d_k = p4d_offset(pgd_k, address);
+       if (!p4d_present(*p4d_k))
+               return NULL;
+
+       pud_k = pud_offset(p4d_k, address);
        if (!pud_present(*pud_k))
                return NULL;
 
 
        unsigned long address, pfn, phys;
        int map_coherent = 0;
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
                return;
 
        pgd = pgd_offset(vma->vm_mm, address);
-       pud = pud_offset(pgd, address);
+       p4d = p4d_offset(pgd, address);
+       pud = pud_offset(p4d, address);
        pmd = pmd_offset(pud, address);
        pte = pte_offset_kernel(pmd, address);
 
 
                                unsigned long addr, unsigned long end)
 {
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
        if (pgd_bad(*pgd))
                return;
 
-       pud = pud_offset(pgd, addr);
+       p4d = p4d_offset(pgd, addr);
+       if (p4d_none(*p4d) || p4d_bad(*p4d))
+               return;
+
+       pud = pud_offset(p4d, addr);
        if (pud_none(*pud) || pud_bad(*pud))
                return;
 
 
                 (u64)pgd_val(*pgd));
 
        do {
+               p4d_t *p4d;
                pud_t *pud;
                pmd_t *pmd;
                pte_t *pte;
                        break;
                }
 
-               pud = pud_offset(pgd, addr);
+               p4d = p4d_offset(pgd, addr);
+               if (PTRS_PER_P4D != 1)
+                       pr_cont(", *p4d=%0*Lx", (u32)(sizeof(*p4d) * 2),
+                               (u64)p4d_val(*p4d));
+
+               if (p4d_none(*p4d))
+                       break;
+
+               if (p4d_bad(*p4d)) {
+                       pr_cont("(bad)");
+                       break;
+               }
+
+               pud = pud_offset(p4d, addr);
                if (PTRS_PER_PUD != 1)
                        pr_cont(", *pud=%0*llx", (u32)(sizeof(*pud) * 2),
                                (u64)pud_val(*pud));
 {
        unsigned index = pgd_index(address);
        pgd_t *pgd_k;
+       p4d_t *p4d, *p4d_k;
        pud_t *pud, *pud_k;
        pmd_t *pmd, *pmd_k;
 
        if (!pgd_present(*pgd_k))
                return NULL;
 
-       pud = pud_offset(pgd, address);
-       pud_k = pud_offset(pgd_k, address);
+       p4d = p4d_offset(pgd, address);
+       p4d_k = p4d_offset(pgd_k, address);
+       if (!p4d_present(*p4d_k))
+               return NULL;
+
+       pud = pud_offset(p4d, address);
+       pud_k = pud_offset(p4d_k, address);
        if (!pud_present(*pud_k))
                return NULL;
 
 
                        unsigned long addr, unsigned long sz)
 {
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte = NULL;
 
        pgd = pgd_offset(mm, addr);
        if (pgd) {
-               pud = pud_alloc(mm, pgd, addr);
-               if (pud) {
-                       pmd = pmd_alloc(mm, pud, addr);
-                       if (pmd)
-                               pte = pte_alloc_map(mm, pmd, addr);
+               p4d = p4d_alloc(mm, pgd, addr);
+               if (p4d) {
+                       pud = pud_alloc(mm, p4d, addr);
+                       if (pud) {
+                               pmd = pmd_alloc(mm, pud, addr);
+                               if (pmd)
+                                       pte = pte_alloc_map(mm, pmd, addr);
+                       }
                }
        }
 
                       unsigned long addr, unsigned long sz)
 {
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte = NULL;
 
        pgd = pgd_offset(mm, addr);
        if (pgd) {
-               pud = pud_offset(pgd, addr);
-               if (pud) {
-                       pmd = pmd_offset(pud, addr);
-                       if (pmd)
-                               pte = pte_offset_map(pmd, addr);
+               p4d = p4d_offset(pgd, addr);
+               if (p4d) {
+                       pud = pud_offset(p4d, addr);
+                       if (pud) {
+                               pmd = pmd_offset(pud, addr);
+                               if (pmd)
+                                       pte = pte_offset_map(pmd, addr);
+                       }
                }
        }
 
 
 static pte_t *__get_pte_phys(unsigned long addr)
 {
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
 
                return NULL;
        }
 
-       pud = pud_alloc(NULL, pgd, addr);
+       p4d = p4d_alloc(NULL, pgd, addr);
+       if (unlikely(!p4d)) {
+               p4d_ERROR(*p4d);
+               return NULL;
+       }
+
+       pud = pud_alloc(NULL, p4d, addr);
        if (unlikely(!pud)) {
                pud_ERROR(*pud);
                return NULL;
 
 #include <asm/cacheflush.h>
 
 #define kmap_get_fixmap_pte(vaddr)                                     \
-       pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr)), (vaddr))
+       pte_offset_kernel(pmd_offset(pud_offset(p4d_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr)), (vaddr)), vaddr)
 
 static pte_t *kmap_coherent_pte;
 
 
               unsigned long address)
 {
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
                pgd = pgd_offset(current->mm, address);
        }
 
-       pud = pud_offset(pgd, address);
+       p4d = p4d_offset(pgd, address);
+       if (p4d_none_or_clear_bad(p4d))
+               return 1;
+       pud = pud_offset(p4d, address);
        if (pud_none_or_clear_bad(pud))
                return 1;
        pmd = pmd_offset(pud, address);
 
                          unsigned long address)
 {
        pgd_t *pgd;
+       p4d_t *p4d;
        pud_t *pud;
        pmd_t *pmd;
        pte_t *pte;
                pgd = pgd_offset(current->mm, address);
        }
 
-       pud = pud_offset(pgd, address);
+       p4d = p4d_offset(pgd, address);
+       if (p4d_none(*p4d) || !p4d_present(*p4d))
+               return 1;
+
+       pud = pud_offset(p4d, address);
        if (pud_none(*pud) || !pud_present(*pud))
                return 1;