arch/metag/mm/highmem.c

   1 #include <linux/export.h>
   2 #include <linux/highmem.h>
   3 #include <linux/sched.h>
   4 #include <linux/smp.h>
   5 #include <linux/interrupt.h>
   6 #include <asm/fixmap.h>
   7 #include <asm/tlbflush.h>
   8
   9 static pte_t *kmap_pte;
  10
  11 unsigned long highstart_pfn, highend_pfn;
  12
  13 void *kmap(struct page *page)
  14 {
  15         might_sleep();
  16         if (!PageHighMem(page))
  17                 return page_address(page);
  18         return kmap_high(page);
  19 }
  20 EXPORT_SYMBOL(kmap);
  21
  22 void kunmap(struct page *page)
  23 {
  24         BUG_ON(in_interrupt());
  25         if (!PageHighMem(page))
  26                 return;
  27         kunmap_high(page);
  28 }
  29 EXPORT_SYMBOL(kunmap);
  30
  31 /*
  32  * kmap_atomic/kunmap_atomic is significantly faster than kmap/kunmap because
  33  * no global lock is needed and because the kmap code must perform a global TLB
  34  * invalidation when the kmap pool wraps.
  35  *
  36  * However when holding an atomic kmap is is not legal to sleep, so atomic
  37  * kmaps are appropriate for short, tight code paths only.
  38  */
  39
  40 void *kmap_atomic(struct page *page)
  41 {
  42         enum fixed_addresses idx;
  43         unsigned long vaddr;
  44         int type;
  45
  46         preempt_disable();
  47         pagefault_disable();
  48         if (!PageHighMem(page))
  49                 return page_address(page);
  50
  51         type = kmap_atomic_idx_push();
  52         idx = type + KM_TYPE_NR * smp_processor_id();
  53         vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
  54 #ifdef CONFIG_DEBUG_HIGHMEM
  55         BUG_ON(!pte_none(*(kmap_pte - idx)));
  56 #endif
  57         set_pte(kmap_pte - idx, mk_pte(page, PAGE_KERNEL));
  58
  59         return (void *)vaddr;
  60 }
  61 EXPORT_SYMBOL(kmap_atomic);
  62
  63 void __kunmap_atomic(void *kvaddr)
  64 {
  65         unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
  66         int idx, type;
  67
  68         if (kvaddr >= (void *)FIXADDR_START) {
  69                 type = kmap_atomic_idx();
  70                 idx = type + KM_TYPE_NR * smp_processor_id();
  71
  72                 /*
  73                  * Force other mappings to Oops if they'll try to access this
  74                  * pte without first remap it.  Keeping stale mappings around
  75                  * is a bad idea also, in case the page changes cacheability
  76                  * attributes or becomes a protected page in a hypervisor.
  77                  */
  78                 pte_clear(&init_mm, vaddr, kmap_pte-idx);
  79                 flush_tlb_kernel_range(vaddr, vaddr + PAGE_SIZE);
  80
  81                 kmap_atomic_idx_pop();
  82         }
  83
  84         pagefault_enable();
  85         preempt_enable();
  86 }
  87 EXPORT_SYMBOL(__kunmap_atomic);
  88
  89 /*
  90  * This is the same as kmap_atomic() but can map memory that doesn't
  91  * have a struct page associated with it.
  92  */
  93 void *kmap_atomic_pfn(unsigned long pfn)
  94 {
  95         enum fixed_addresses idx;
  96         unsigned long vaddr;
  97         int type;
  98
  99         preempt_disable();
 100         pagefault_disable();
 101
 102         type = kmap_atomic_idx_push();
 103         idx = type + KM_TYPE_NR * smp_processor_id();
 104         vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
 105 #ifdef CONFIG_DEBUG_HIGHMEM
 106         BUG_ON(!pte_none(*(kmap_pte - idx)));
 107 #endif
 108         set_pte(kmap_pte - idx, pfn_pte(pfn, PAGE_KERNEL));
 109         flush_tlb_kernel_range(vaddr, vaddr + PAGE_SIZE);
 110
 111         return (void *)vaddr;
 112 }
 113
 114 void __init kmap_init(void)
 115 {
 116         unsigned long kmap_vstart;
 117
 118         /* cache the first kmap pte */
 119         kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
 120         kmap_pte = kmap_get_fixmap_pte(kmap_vstart);
 121 }