kernel/2.6.29.6-aldebaran-rt/arch/sh/mm/pg-sh4.c

   1 /*
   2  * arch/sh/mm/pg-sh4.c
   3  *
   4  * Copyright (C) 1999, 2000, 2002  Niibe Yutaka
   5  * Copyright (C) 2002 - 2007  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 #define CACHE_ALIAS (current_cpu_data.dcache.alias_mask)
  19
  20 #define kmap_get_fixmap_pte(vaddr)                                     \
  21         pte_offset_kernel(pmd_offset(pud_offset(pgd_offset_k(vaddr), (vaddr)), (vaddr)), (vaddr))
  22
  23 static pte_t *kmap_coherent_pte;
  24
  25 void __init kmap_coherent_init(void)
  26 {
  27         unsigned long vaddr;
  28
  29         /* cache the first coherent kmap pte */
  30         vaddr = __fix_to_virt(FIX_CMAP_BEGIN);
  31         kmap_coherent_pte = kmap_get_fixmap_pte(vaddr);
  32 }
  33
  34 static inline void *kmap_coherent(struct page *page, unsigned long addr)
  35 {
  36         enum fixed_addresses idx;
  37         unsigned long vaddr, flags;
  38         pte_t pte;
  39
  40         inc_preempt_count();
  41
  42         idx = (addr & current_cpu_data.dcache.alias_mask) >> PAGE_SHIFT;
  43         vaddr = __fix_to_virt(FIX_CMAP_END - idx);
  44         pte = mk_pte(page, PAGE_KERNEL);
  45
  46         local_irq_save(flags);
  47         flush_tlb_one(get_asid(), vaddr);
  48         local_irq_restore(flags);
  49
  50         update_mmu_cache(NULL, vaddr, pte);
  51
  52         set_pte(kmap_coherent_pte - (FIX_CMAP_END - idx), pte);
  53
  54         return (void *)vaddr;
  55 }
  56
  57 static inline void kunmap_coherent(struct page *page)
  58 {
  59         dec_preempt_count();
  60         preempt_check_resched();
  61 }
  62
  63 /*
  64  * clear_user_page
  65  * @to: P1 address
  66  * @address: U0 address to be mapped
  67  * @page: page (virt_to_page(to))
  68  */
  69 void clear_user_page(void *to, unsigned long address, struct page *page)
  70 {
  71         __set_bit(PG_mapped, &page->flags);
  72
  73         clear_page(to);
  74         if ((((address & PAGE_MASK) ^ (unsigned long)to) & CACHE_ALIAS))
  75                 __flush_wback_region(to, PAGE_SIZE);
  76 }
  77
  78 void copy_to_user_page(struct vm_area_struct *vma, struct page *page,
  79                        unsigned long vaddr, void *dst, const void *src,
  80                        unsigned long len)
  81 {
  82         void *vto;
  83
  84         __set_bit(PG_mapped, &page->flags);
  85
  86         vto = kmap_coherent(page, vaddr) + (vaddr & ~PAGE_MASK);
  87         memcpy(vto, src, len);
  88         kunmap_coherent(vto);
  89
  90         if (vma->vm_flags & VM_EXEC)
  91                 flush_cache_page(vma, vaddr, page_to_pfn(page));
  92 }
  93
  94 void copy_from_user_page(struct vm_area_struct *vma, struct page *page,
  95                          unsigned long vaddr, void *dst, const void *src,
  96                          unsigned long len)
  97 {
  98         void *vfrom;
  99
 100         __set_bit(PG_mapped, &page->flags);
 101
 102         vfrom = kmap_coherent(page, vaddr) + (vaddr & ~PAGE_MASK);
 103         memcpy(dst, vfrom, len);
 104         kunmap_coherent(vfrom);
 105 }
 106
 107 void copy_user_highpage(struct page *to, struct page *from,
 108                         unsigned long vaddr, struct vm_area_struct *vma)
 109 {
 110         void *vfrom, *vto;
 111
 112         __set_bit(PG_mapped, &to->flags);
 113
 114         vto = kmap_atomic(to, KM_USER1);
 115         vfrom = kmap_coherent(from, vaddr);
 116         copy_page(vto, vfrom);
 117         kunmap_coherent(vfrom);
 118
 119         if (((vaddr ^ (unsigned long)vto) & CACHE_ALIAS))
 120                 __flush_wback_region(vto, PAGE_SIZE);
 121
 122         kunmap_atomic(vto, KM_USER1);
 123         /* Make sure this page is cleared on other CPU's too before using it */
 124         smp_wmb();
 125 }
 126 EXPORT_SYMBOL(copy_user_highpage);
 127
 128 /*
 129  * For SH-4, we have our own implementation for ptep_get_and_clear
 130  */
 131 pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 132 {
 133         pte_t pte = *ptep;
 134
 135         pte_clear(mm, addr, ptep);
 136         if (!pte_not_present(pte)) {
 137                 unsigned long pfn = pte_pfn(pte);
 138                 if (pfn_valid(pfn)) {
 139                         struct page *page = pfn_to_page(pfn);
 140                         struct address_space *mapping = page_mapping(page);
 141                         if (!mapping || !mapping_writably_mapped(mapping))
 142                                 __clear_bit(PG_mapped, &page->flags);
 143                 }
 144         }
 145         return pte;
 146 }