1 files changed, 36 insertions, 28 deletions

diff --git a/arch/arm/mm/mmu.c b/arch/arm/mm/mmu.c
index ea67be0223ac..241c24a1c18f 100644
--- a/arch/arm/mm/mmu.c
+++ b/arch/arm/mm/mmu.c
@@ -100,18 +100,17 @@ static struct cachepolicy cache_policies[] __initdata = {
  * writebuffer to be turned off.  (Note: the write
  * buffer should not be on and the cache off).
  */
-static void __init early_cachepolicy(char **p)
+static int __init early_cachepolicy(char *p)
 {
         int i;
 
         for (i = 0; i < ARRAY_SIZE(cache_policies); i++) {
                 int len = strlen(cache_policies[i].policy);
 
-                if (memcmp(*p, cache_policies[i].policy, len) == 0) {
+                if (memcmp(p, cache_policies[i].policy, len) == 0) {
                         cachepolicy = i;
                         cr_alignment &= ~cache_policies[i].cr_mask;
                         cr_no_alignment &= ~cache_policies[i].cr_mask;
-                        *p += len;
                         break;
                 }
         }
@@ -130,36 +129,37 @@ static void __init early_cachepolicy(char **p)
         }
         flush_cache_all();
         set_cr(cr_alignment);
+        return 0;
 }
-__early_param("cachepolicy=", early_cachepolicy);
+early_param("cachepolicy", early_cachepolicy);
 
-static void __init early_nocache(char **__unused)
+static int __init early_nocache(char *__unused)
 {
         char *p = "buffered";
         printk(KERN_WARNING "nocache is deprecated; use cachepolicy=%s\n", p);
-        early_cachepolicy(&p);
+        early_cachepolicy(p);
+        return 0;
 }
-__early_param("nocache", early_nocache);
+early_param("nocache", early_nocache);
 
-static void __init early_nowrite(char **__unused)
+static int __init early_nowrite(char *__unused)
 {
         char *p = "uncached";
         printk(KERN_WARNING "nowb is deprecated; use cachepolicy=%s\n", p);
-        early_cachepolicy(&p);
+        early_cachepolicy(p);
+        return 0;
 }
-__early_param("nowb", early_nowrite);
+early_param("nowb", early_nowrite);
 
-static void __init early_ecc(char **p)
+static int __init early_ecc(char *p)
 {
-        if (memcmp(*p, "on", 2) == 0) {
+        if (memcmp(p, "on", 2) == 0)
                 ecc_mask = PMD_PROTECTION;
-                *p += 2;
-        } else if (memcmp(*p, "off", 3) == 0) {
+        else if (memcmp(p, "off", 3) == 0)
                 ecc_mask = 0;
-                *p += 3;
-        }
+        return 0;
 }
-__early_param("ecc=", early_ecc);
+early_param("ecc", early_ecc);
 
 static int __init noalign_setup(char *__unused)
 {
@@ -420,6 +420,10 @@ static void __init build_mem_type_table(void)
                 user_pgprot |= L_PTE_SHARED;
                 kern_pgprot |= L_PTE_SHARED;
                 vecs_pgprot |= L_PTE_SHARED;
+                mem_types[MT_DEVICE_WC].prot_sect |= PMD_SECT_S;
+                mem_types[MT_DEVICE_WC].prot_pte |= L_PTE_SHARED;
+                mem_types[MT_DEVICE_CACHED].prot_sect |= PMD_SECT_S;
+                mem_types[MT_DEVICE_CACHED].prot_pte |= L_PTE_SHARED;
                 mem_types[MT_MEMORY].prot_sect |= PMD_SECT_S;
                 mem_types[MT_MEMORY_NONCACHED].prot_sect |= PMD_SECT_S;
 #endif
@@ -453,8 +457,7 @@ static void __init build_mem_type_table(void)
 
         pgprot_user   = __pgprot(L_PTE_PRESENT | L_PTE_YOUNG | user_pgprot);
         pgprot_kernel = __pgprot(L_PTE_PRESENT | L_PTE_YOUNG |
-                                 L_PTE_DIRTY | L_PTE_WRITE |
-                                 L_PTE_EXEC | kern_pgprot);
+                                 L_PTE_DIRTY | L_PTE_WRITE | kern_pgprot);
 
         mem_types[MT_LOW_VECTORS].prot_l1 |= ecc_mask;
         mem_types[MT_HIGH_VECTORS].prot_l1 |= ecc_mask;
@@ -671,9 +674,9 @@ static unsigned long __initdata vmalloc_reserve = SZ_128M;
  * bytes. This can be used to increase (or decrease) the vmalloc
  * area - the default is 128m.
  */
-static void __init early_vmalloc(char **arg)
+static int __init early_vmalloc(char *arg)
 {
-        vmalloc_reserve = memparse(*arg, arg);
+        vmalloc_reserve = memparse(arg, NULL);
 
         if (vmalloc_reserve < SZ_16M) {
                 vmalloc_reserve = SZ_16M;
@@ -688,8 +691,9 @@ static void __init early_vmalloc(char **arg)
                         "vmalloc area is too big, limiting to %luMB\n",
                         vmalloc_reserve >> 20);
         }
+        return 0;
 }
-__early_param("vmalloc=", early_vmalloc);
+early_param("vmalloc", early_vmalloc);
 
 #define VMALLOC_MIN     (void *)(VMALLOC_END - vmalloc_reserve)
 
@@ -881,7 +885,7 @@ void __init reserve_node_zero(pg_data_t *pgdat)
                                 BOOTMEM_EXCLUSIVE);
         }
 
-        if (machine_is_treo680()) {
+        if (machine_is_treo680() || machine_is_centro()) {
                 reserve_bootmem_node(pgdat, 0xa0000000, 0x1000,
                                 BOOTMEM_EXCLUSIVE);
                 reserve_bootmem_node(pgdat, 0xa2000000, 0x1000,
@@ -1036,7 +1040,7 @@ void __init paging_init(struct machine_desc *mdesc)
          */
         zero_page = alloc_bootmem_low_pages(PAGE_SIZE);
         empty_zero_page = virt_to_page(zero_page);
-        flush_dcache_page(empty_zero_page);
+        __flush_dcache_page(NULL, empty_zero_page);
 }
 
 /*
@@ -1050,10 +1054,12 @@ void setup_mm_for_reboot(char mode)
         pgd_t *pgd;
         int i;
 
-        if (current->mm && current->mm->pgd)
-                pgd = current->mm->pgd;
-        else
-                pgd = init_mm.pgd;
+        /*
+         * We need to access to user-mode page tables here. For kernel threads
+         * we don't have any user-mode mappings so we use the context that we
+         * "borrowed".
+         */
+        pgd = current->active_mm->pgd;
 
         base_pmdval = PMD_SECT_AP_WRITE | PMD_SECT_AP_READ | PMD_TYPE_SECT;
         if (cpu_architecture() <= CPU_ARCH_ARMv5TEJ && !cpu_is_xscale())
@@ -1068,4 +1074,6 @@ void setup_mm_for_reboot(char mode)
                 pmd[1] = __pmd(pmdval + (1 << (PGDIR_SHIFT - 1)));
                 flush_pmd_entry(pmd);
         }
+
+        local_flush_tlb_all();
 }