kernel/arch/arm/mm/highmem.c

   1 /*
   2  * arch/arm/mm/highmem.c -- ARM highmem support
   3  *
   4  * Author:      Nicolas Pitre
   5  * Created:     september 8, 2008
   6  * Copyright:   Marvell Semiconductors Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/highmem.h>
  15 #include <linux/interrupt.h>
  16 #include <asm/fixmap.h>
  17 #include <asm/cacheflush.h>
  18 #include <asm/tlbflush.h>
  19 #include "mm.h"
  20
  21 static inline void set_fixmap_pte(int idx, pte_t pte)
  22 {
  23         unsigned long vaddr = __fix_to_virt(idx);
  24         pte_t *ptep = pte_offset_kernel(pmd_off_k(vaddr), vaddr);
  25
  26         set_pte_ext(ptep, pte, 0);
  27         local_flush_tlb_kernel_page(vaddr);
  28 }
  29
  30 static inline pte_t get_fixmap_pte(unsigned long vaddr)
  31 {
  32         pte_t *ptep = pte_offset_kernel(pmd_off_k(vaddr), vaddr);
  33
  34         return *ptep;
  35 }
  36
  37 void *kmap(struct page *page)
  38 {
  39         might_sleep();
  40         if (!PageHighMem(page))
  41                 return page_address(page);
  42         return kmap_high(page);
  43 }
  44 EXPORT_SYMBOL(kmap);
  45
  46 void kunmap(struct page *page)
  47 {
  48         BUG_ON(in_interrupt());
  49         if (!PageHighMem(page))
  50                 return;
  51         kunmap_high(page);
  52 }
  53 EXPORT_SYMBOL(kunmap);
  54
  55 void *kmap_atomic(struct page *page)
  56 {
  57         pte_t pte = mk_pte(page, kmap_prot);
  58         unsigned int idx;
  59         unsigned long vaddr;
  60         void *kmap;
  61         int type;
  62
  63         preempt_disable_nort();
  64         pagefault_disable();
  65         if (!PageHighMem(page))
  66                 return page_address(page);
  67
  68 #ifdef CONFIG_DEBUG_HIGHMEM
  69         /*
  70          * There is no cache coherency issue when non VIVT, so force the
  71          * dedicated kmap usage for better debugging purposes in that case.
  72          */
  73         if (!cache_is_vivt())
  74                 kmap = NULL;
  75         else
  76 #endif
  77                 kmap = kmap_high_get(page);
  78         if (kmap)
  79                 return kmap;
  80
  81         type = kmap_atomic_idx_push();
  82
  83         idx = type + KM_TYPE_NR * smp_processor_id();
  84         vaddr = __fix_to_virt(idx);
  85 #ifdef CONFIG_DEBUG_HIGHMEM
  86         /*
  87          * With debugging enabled, kunmap_atomic forces that entry to 0.
  88          * Make sure it was indeed properly unmapped.
  89          */
  90         BUG_ON(!pte_none(get_fixmap_pte(vaddr)));
  91 #endif
  92         /*
  93          * When debugging is off, kunmap_atomic leaves the previous mapping
  94          * in place, so the contained TLB flush ensures the TLB is updated
  95          * with the new mapping.
  96          */
  97 #ifdef CONFIG_PREEMPT_RT_FULL
  98         current->kmap_pte[type] = pte;
  99 #endif
 100         set_fixmap_pte(idx, pte);
 101
 102         return (void *)vaddr;
 103 }
 104 EXPORT_SYMBOL(kmap_atomic);
 105
 106 void __kunmap_atomic(void *kvaddr)
 107 {
 108         unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
 109         int idx, type;
 110
 111         if (kvaddr >= (void *)FIXADDR_START) {
 112                 type = kmap_atomic_idx();
 113                 idx = type + KM_TYPE_NR * smp_processor_id();
 114
 115                 if (cache_is_vivt())
 116                         __cpuc_flush_dcache_area((void *)vaddr, PAGE_SIZE);
 117 #ifdef CONFIG_PREEMPT_RT_FULL
 118                 current->kmap_pte[type] = __pte(0);
 119 #endif
 120 #ifdef CONFIG_DEBUG_HIGHMEM
 121                 BUG_ON(vaddr != __fix_to_virt(idx));
 122 #else
 123                 (void) idx;  /* to kill a warning */
 124 #endif
 125                 set_fixmap_pte(idx, __pte(0));
 126                 kmap_atomic_idx_pop();
 127         } else if (vaddr >= PKMAP_ADDR(0) && vaddr < PKMAP_ADDR(LAST_PKMAP)) {
 128                 /* this address was obtained through kmap_high_get() */
 129                 kunmap_high(pte_page(pkmap_page_table[PKMAP_NR(vaddr)]));
 130         }
 131         pagefault_enable();
 132         preempt_enable_nort();
 133 }
 134 EXPORT_SYMBOL(__kunmap_atomic);
 135
 136 void *kmap_atomic_pfn(unsigned long pfn)
 137 {
 138         pte_t pte = pfn_pte(pfn, kmap_prot);
 139         unsigned long vaddr;
 140         int idx, type;
 141         struct page *page = pfn_to_page(pfn);
 142
 143         preempt_disable_nort();
 144         pagefault_disable();
 145         if (!PageHighMem(page))
 146                 return page_address(page);
 147
 148         type = kmap_atomic_idx_push();
 149         idx = type + KM_TYPE_NR * smp_processor_id();
 150         vaddr = __fix_to_virt(idx);
 151 #ifdef CONFIG_DEBUG_HIGHMEM
 152         BUG_ON(!pte_none(get_fixmap_pte(vaddr)));
 153 #endif
 154 #ifdef CONFIG_PREEMPT_RT_FULL
 155         current->kmap_pte[type] = pte;
 156 #endif
 157         set_fixmap_pte(idx, pte);
 158
 159         return (void *)vaddr;
 160 }
 161
 162 struct page *kmap_atomic_to_page(const void *ptr)
 163 {
 164         unsigned long vaddr = (unsigned long)ptr;
 165
 166         if (vaddr < FIXADDR_START)
 167                 return virt_to_page(ptr);
 168
 169         return pte_page(get_fixmap_pte(vaddr));
 170 }
 171
 172 #if defined CONFIG_PREEMPT_RT_FULL
 173 void switch_kmaps(struct task_struct *prev_p, struct task_struct *next_p)
 174 {
 175         int i;
 176
 177         /*
 178          * Clear @prev's kmap_atomic mappings
 179          */
 180         for (i = 0; i < prev_p->kmap_idx; i++) {
 181                 int idx = i + KM_TYPE_NR * smp_processor_id();
 182
 183                 set_fixmap_pte(idx, __pte(0));
 184         }
 185         /*
 186          * Restore @next_p's kmap_atomic mappings
 187          */
 188         for (i = 0; i < next_p->kmap_idx; i++) {
 189                 int idx = i + KM_TYPE_NR * smp_processor_id();
 190
 191                 if (!pte_none(next_p->kmap_pte[i]))
 192                         set_fixmap_pte(idx, next_p->kmap_pte[i]);
 193         }
 194 }
 195 #endif