M7350/kernel/arch/arm/mm/highmem.c

213 lines
4.7 KiB
C
Raw Permalink Normal View History

2024-09-09 08:52:07 +00:00
/*
* arch/arm/mm/highmem.c -- ARM highmem support
*
* Author: Nicolas Pitre
* Created: september 8, 2008
* Copyright: Marvell Semiconductors Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/cpu.h>
#include <linux/module.h>
#include <linux/highmem.h>
#include <linux/interrupt.h>
#include <asm/fixmap.h>
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
#include "mm.h"
2024-09-09 08:57:42 +00:00
static inline void set_fixmap_pte(int idx, pte_t pte)
{
unsigned long vaddr = __fix_to_virt(idx);
pte_t *ptep = pte_offset_kernel(pmd_off_k(vaddr), vaddr);
set_pte_ext(ptep, pte, 0);
local_flush_tlb_kernel_page(vaddr);
}
static inline pte_t get_fixmap_pte(unsigned long vaddr)
{
pte_t *ptep = pte_offset_kernel(pmd_off_k(vaddr), vaddr);
return *ptep;
}
2024-09-09 08:52:07 +00:00
void *kmap(struct page *page)
{
might_sleep();
if (!PageHighMem(page))
return page_address(page);
return kmap_high(page);
}
EXPORT_SYMBOL(kmap);
void kunmap(struct page *page)
{
BUG_ON(in_interrupt());
if (!PageHighMem(page))
return;
kunmap_high(page);
}
EXPORT_SYMBOL(kunmap);
void *kmap_atomic(struct page *page)
{
unsigned int idx;
unsigned long vaddr;
void *kmap;
int type;
pagefault_disable();
if (!PageHighMem(page))
return page_address(page);
#ifdef CONFIG_DEBUG_HIGHMEM
/*
* There is no cache coherency issue when non VIVT, so force the
* dedicated kmap usage for better debugging purposes in that case.
*/
if (!cache_is_vivt())
kmap = NULL;
else
#endif
kmap = kmap_high_get(page);
if (kmap)
return kmap;
type = kmap_atomic_idx_push();
2024-09-09 08:57:42 +00:00
idx = FIX_KMAP_BEGIN + type + KM_TYPE_NR * smp_processor_id();
vaddr = __fix_to_virt(idx);
2024-09-09 08:52:07 +00:00
#ifdef CONFIG_DEBUG_HIGHMEM
/*
* With debugging enabled, kunmap_atomic forces that entry to 0.
* Make sure it was indeed properly unmapped.
*/
2024-09-09 08:57:42 +00:00
BUG_ON(!pte_none(*get_fixmap_pte(vaddr)));
2024-09-09 08:52:07 +00:00
#endif
/*
* When debugging is off, kunmap_atomic leaves the previous mapping
* in place, so the contained TLB flush ensures the TLB is updated
* with the new mapping.
*/
2024-09-09 08:57:42 +00:00
set_fixmap_pte(idx, mk_pte(page, kmap_prot));
2024-09-09 08:52:07 +00:00
return (void *)vaddr;
}
EXPORT_SYMBOL(kmap_atomic);
void __kunmap_atomic(void *kvaddr)
{
unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
int idx, type;
if (kvaddr >= (void *)FIXADDR_START) {
type = kmap_atomic_idx();
2024-09-09 08:57:42 +00:00
idx = FIX_KMAP_BEGIN + type + KM_TYPE_NR * smp_processor_id();
2024-09-09 08:52:07 +00:00
if (cache_is_vivt())
__cpuc_flush_dcache_area((void *)vaddr, PAGE_SIZE);
#ifdef CONFIG_DEBUG_HIGHMEM
2024-09-09 08:57:42 +00:00
BUG_ON(vaddr != __fix_to_virt(idx));
set_fixmap_pte(idx, __pte(0));
2024-09-09 08:52:07 +00:00
#else
(void) idx; /* to kill a warning */
#endif
kmap_atomic_idx_pop();
} else if (vaddr >= PKMAP_ADDR(0) && vaddr < PKMAP_ADDR(LAST_PKMAP)) {
/* this address was obtained through kmap_high_get() */
kunmap_high(pte_page(pkmap_page_table[PKMAP_NR(vaddr)]));
}
pagefault_enable();
}
EXPORT_SYMBOL(__kunmap_atomic);
void *kmap_atomic_pfn(unsigned long pfn)
{
unsigned long vaddr;
int idx, type;
2024-09-09 08:57:42 +00:00
struct page *page = pfn_to_page(pfn);
2024-09-09 08:52:07 +00:00
pagefault_disable();
2024-09-09 08:57:42 +00:00
if (!PageHighMem(page))
return page_address(page);
2024-09-09 08:52:07 +00:00
type = kmap_atomic_idx_push();
2024-09-09 08:57:42 +00:00
idx = FIX_KMAP_BEGIN + type + KM_TYPE_NR * smp_processor_id();
vaddr = __fix_to_virt(idx);
2024-09-09 08:52:07 +00:00
#ifdef CONFIG_DEBUG_HIGHMEM
2024-09-09 08:57:42 +00:00
BUG_ON(!pte_none(*get_fixmap_pte(vaddr)));
2024-09-09 08:52:07 +00:00
#endif
2024-09-09 08:57:42 +00:00
set_fixmap_pte(idx, pfn_pte(pfn, kmap_prot));
2024-09-09 08:52:07 +00:00
return (void *)vaddr;
}
struct page *kmap_atomic_to_page(const void *ptr)
{
unsigned long vaddr = (unsigned long)ptr;
if (vaddr < FIXADDR_START)
return virt_to_page(ptr);
2024-09-09 08:57:42 +00:00
return pte_page(get_fixmap_pte(vaddr));
2024-09-09 08:52:07 +00:00
}
#ifdef CONFIG_ARCH_WANT_KMAP_ATOMIC_FLUSH
static void kmap_remove_unused_cpu(int cpu)
{
int start_idx, idx, type;
pagefault_disable();
type = kmap_atomic_idx();
2024-09-09 08:57:42 +00:00
start_idx = FIX_KMAP_BEGIN + type + 1 + KM_TYPE_NR * cpu;
2024-09-09 08:52:07 +00:00
for (idx = start_idx; idx < KM_TYPE_NR + KM_TYPE_NR * cpu; idx++) {
unsigned long vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
pte_t ptep;
ptep = get_top_pte(vaddr);
if (ptep)
set_top_pte(vaddr, __pte(0));
}
pagefault_enable();
}
static void kmap_remove_unused(void *unused)
{
kmap_remove_unused_cpu(smp_processor_id());
}
void kmap_atomic_flush_unused(void)
{
on_each_cpu(kmap_remove_unused, NULL, 1);
}
static int hotplug_kmap_atomic_callback(struct notifier_block *nfb,
unsigned long action, void *hcpu)
{
switch (action & (~CPU_TASKS_FROZEN)) {
case CPU_DYING:
kmap_remove_unused_cpu((int)hcpu);
break;
default:
break;
}
return NOTIFY_OK;
}
static struct notifier_block hotplug_kmap_atomic_notifier = {
.notifier_call = hotplug_kmap_atomic_callback,
};
static int __init init_kmap_atomic(void)
{
return register_hotcpu_notifier(&hotplug_kmap_atomic_notifier);
}
early_initcall(init_kmap_atomic);
#endif