SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/sh/mm/cache.c

   1 /*
   2  * arch/sh/mm/pg-mmu.c
   3  *
   4  * Copyright (C) 1999, 2000, 2002  Niibe Yutaka
   5  * Copyright (C) 2002 - 2009  Paul Mundt
   6  *
   7  * Released under the terms of the GNU GPL v2.0.
   8  */
   9 #include <linux/mm.h>
  10 #include <linux/init.h>
  11 #include <linux/mutex.h>
  12 #include <linux/fs.h>
  13 #include <linux/highmem.h>
  14 #include <linux/module.h>
  15 #include <asm/mmu_context.h>
  16 #include <asm/cacheflush.h>
  17
  18 void copy_to_user_page(struct vm_area_struct *vma, struct page *page,
  19                        unsigned long vaddr, void *dst, const void *src,
  20                        unsigned long len)
  21 {
  22         if (boot_cpu_data.dcache.n_aliases && page_mapped(page) &&
  23             !test_bit(PG_dcache_dirty, &page->flags)) {
  24                 void *vto = kmap_coherent(page, vaddr) + (vaddr & ~PAGE_MASK);
  25                 memcpy(vto, src, len);
  26                 kunmap_coherent();
  27         } else {
  28                 memcpy(dst, src, len);
  29                 if (boot_cpu_data.dcache.n_aliases)
  30                         set_bit(PG_dcache_dirty, &page->flags);
  31         }
  32
  33         if (vma->vm_flags & VM_EXEC)
  34                 flush_cache_page(vma, vaddr, page_to_pfn(page));
  35 }
  36
  37 void copy_from_user_page(struct vm_area_struct *vma, struct page *page,
  38                          unsigned long vaddr, void *dst, const void *src,
  39                          unsigned long len)
  40 {
  41         if (boot_cpu_data.dcache.n_aliases && page_mapped(page) &&
  42             !test_bit(PG_dcache_dirty, &page->flags)) {
  43                 void *vfrom = kmap_coherent(page, vaddr) + (vaddr & ~PAGE_MASK);
  44                 memcpy(dst, vfrom, len);
  45                 kunmap_coherent();
  46         } else {
  47                 memcpy(dst, src, len);
  48                 if (boot_cpu_data.dcache.n_aliases)
  49                         set_bit(PG_dcache_dirty, &page->flags);
  50         }
  51 }
  52
  53 void copy_user_highpage(struct page *to, struct page *from,
  54                         unsigned long vaddr, struct vm_area_struct *vma)
  55 {
  56         void *vfrom, *vto;
  57
  58         vto = kmap_atomic(to, KM_USER1);
  59
  60         if (boot_cpu_data.dcache.n_aliases && page_mapped(from) &&
  61             !test_bit(PG_dcache_dirty, &from->flags)) {
  62                 vfrom = kmap_coherent(from, vaddr);
  63                 copy_page(vto, vfrom);
  64                 kunmap_coherent();
  65         } else {
  66                 vfrom = kmap_atomic(from, KM_USER0);
  67                 copy_page(vto, vfrom);
  68                 kunmap_atomic(vfrom, KM_USER0);
  69         }
  70
  71         if (pages_do_alias((unsigned long)vto, vaddr & PAGE_MASK))
  72                 __flush_wback_region(vto, PAGE_SIZE);
  73
  74         kunmap_atomic(vto, KM_USER1);
  75         /* Make sure this page is cleared on other CPU's too before using it */
  76         smp_wmb();
  77 }
  78 EXPORT_SYMBOL(copy_user_highpage);
  79
  80 void clear_user_highpage(struct page *page, unsigned long vaddr)
  81 {
  82         void *kaddr = kmap_atomic(page, KM_USER0);
  83
  84         clear_page(kaddr);
  85
  86         if (pages_do_alias((unsigned long)kaddr, vaddr & PAGE_MASK))
  87                 __flush_wback_region(kaddr, PAGE_SIZE);
  88
  89         kunmap_atomic(kaddr, KM_USER0);
  90 }
  91 EXPORT_SYMBOL(clear_user_highpage);
  92
  93 void __update_cache(struct vm_area_struct *vma,
  94                     unsigned long address, pte_t pte)
  95 {
  96         struct page *page;
  97         unsigned long pfn = pte_pfn(pte);
  98
  99         if (!boot_cpu_data.dcache.n_aliases)
 100                 return;
 101
 102         page = pfn_to_page(pfn);
 103         if (pfn_valid(pfn) && page_mapping(page)) {
 104                 int dirty = test_and_clear_bit(PG_dcache_dirty, &page->flags);
 105                 if (dirty) {
 106                         unsigned long addr = (unsigned long)page_address(page);
 107
 108                         if (pages_do_alias(addr, address & PAGE_MASK))
 109                                 __flush_wback_region((void *)addr, PAGE_SIZE);
 110                 }
 111         }
 112 }
 113
 114 void __flush_anon_page(struct page *page, unsigned long vmaddr)
 115 {
 116         unsigned long addr = (unsigned long) page_address(page);
 117
 118         if (pages_do_alias(addr, vmaddr)) {
 119                 if (boot_cpu_data.dcache.n_aliases && page_mapped(page) &&
 120                     !test_bit(PG_dcache_dirty, &page->flags)) {
 121                         void *kaddr;
 122
 123                         kaddr = kmap_coherent(page, vmaddr);
 124                         __flush_wback_region((void *)kaddr, PAGE_SIZE);
 125                         kunmap_coherent();
 126                 } else
 127                         __flush_wback_region((void *)addr, PAGE_SIZE);
 128         }
 129 }
 130
 131 static void compute_alias(struct cache_info *c)
 132 {
 133         c->alias_mask = ((c->sets - 1) << c->entry_shift) & ~(PAGE_SIZE - 1);
 134         c->n_aliases = c->alias_mask ? (c->alias_mask >> PAGE_SHIFT) + 1 : 0;
 135 }
 136
 137 static void __init emit_cache_params(void)
 138 {
 139         printk(KERN_NOTICE "I-cache : n_ways=%d n_sets=%d way_incr=%d\n",
 140                 boot_cpu_data.icache.ways,
 141                 boot_cpu_data.icache.sets,
 142                 boot_cpu_data.icache.way_incr);
 143         printk(KERN_NOTICE "I-cache : entry_mask=0x%08x alias_mask=0x%08x n_aliases=%d\n",
 144                 boot_cpu_data.icache.entry_mask,
 145                 boot_cpu_data.icache.alias_mask,
 146                 boot_cpu_data.icache.n_aliases);
 147         printk(KERN_NOTICE "D-cache : n_ways=%d n_sets=%d way_incr=%d\n",
 148                 boot_cpu_data.dcache.ways,
 149                 boot_cpu_data.dcache.sets,
 150                 boot_cpu_data.dcache.way_incr);
 151         printk(KERN_NOTICE "D-cache : entry_mask=0x%08x alias_mask=0x%08x n_aliases=%d\n",
 152                 boot_cpu_data.dcache.entry_mask,
 153                 boot_cpu_data.dcache.alias_mask,
 154                 boot_cpu_data.dcache.n_aliases);
 155
 156         /*
 157          * Emit Secondary Cache parameters if the CPU has a probed L2.
 158          */
 159         if (boot_cpu_data.flags & CPU_HAS_L2_CACHE) {
 160                 printk(KERN_NOTICE "S-cache : n_ways=%d n_sets=%d way_incr=%d\n",
 161                         boot_cpu_data.scache.ways,
 162                         boot_cpu_data.scache.sets,
 163                         boot_cpu_data.scache.way_incr);
 164                 printk(KERN_NOTICE "S-cache : entry_mask=0x%08x alias_mask=0x%08x n_aliases=%d\n",
 165                         boot_cpu_data.scache.entry_mask,
 166                         boot_cpu_data.scache.alias_mask,
 167                         boot_cpu_data.scache.n_aliases);
 168         }
 169 }
 170
 171 void __init cpu_cache_init(void)
 172 {
 173         compute_alias(&boot_cpu_data.icache);
 174         compute_alias(&boot_cpu_data.dcache);
 175         compute_alias(&boot_cpu_data.scache);
 176
 177         if ((boot_cpu_data.family == CPU_FAMILY_SH4) ||
 178             (boot_cpu_data.family == CPU_FAMILY_SH4A) ||
 179             (boot_cpu_data.family == CPU_FAMILY_SH4AL_DSP)) {
 180                 extern void __weak sh4_cache_init(void);
 181
 182                 sh4_cache_init();
 183         }
 184
 185         emit_cache_params();
 186 }