[mirror_ubuntu-jammy-kernel.git] / arch / sh / mm / pg-sh4.c

/*
 * arch/sh/mm/pg-sh4.c
 *
 * Copyright (C) 1999, 2000, 2002  Niibe Yutaka
 * Copyright (C) 2002  Paul Mundt
 *
 * Released under the terms of the GNU GPL v2.0.
 */
#include <linux/init.h>
#include <linux/mman.h>
#include <linux/mm.h>
#include <linux/threads.h>
#include <asm/addrspace.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/processor.h>
#include <asm/cache.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/pgalloc.h>
#include <asm/mmu_context.h>
#include <asm/cacheflush.h>

extern struct semaphore p3map_sem[];

/*
 * clear_user_page
 * @to: P1 address
 * @address: U0 address to be mapped
 * @page: page (virt_to_page(to))
 */
void clear_user_page(void *to, unsigned long address, struct page *page)
{
	__set_bit(PG_mapped, &page->flags);
	if (((address ^ (unsigned long)to) & CACHE_ALIAS) == 0)
		clear_page(to);
	else {
		pgprot_t pgprot = __pgprot(_PAGE_PRESENT | 
					   _PAGE_RW | _PAGE_CACHABLE |
					   _PAGE_DIRTY | _PAGE_ACCESSED | 
					   _PAGE_HW_SHARED | _PAGE_FLAGS_HARD);
		unsigned long phys_addr = PHYSADDR(to);
		unsigned long p3_addr = P3SEG + (address & CACHE_ALIAS);
		pgd_t *dir = pgd_offset_k(p3_addr);
		pmd_t *pmd = pmd_offset(dir, p3_addr);
		pte_t *pte = pte_offset_kernel(pmd, p3_addr);
		pte_t entry;
		unsigned long flags;

		entry = pfn_pte(phys_addr >> PAGE_SHIFT, pgprot);
		down(&p3map_sem[(address & CACHE_ALIAS)>>12]);
		set_pte(pte, entry);
		local_irq_save(flags);
		__flush_tlb_page(get_asid(), p3_addr);
		local_irq_restore(flags);
		update_mmu_cache(NULL, p3_addr, entry);
		__clear_user_page((void *)p3_addr, to);
		pte_clear(&init_mm, p3_addr, pte);
		up(&p3map_sem[(address & CACHE_ALIAS)>>12]);
	}
}

/*
 * copy_user_page
 * @to: P1 address
 * @from: P1 address
 * @address: U0 address to be mapped
 * @page: page (virt_to_page(to))
 */
void copy_user_page(void *to, void *from, unsigned long address, 
		    struct page *page)
{
	__set_bit(PG_mapped, &page->flags);
	if (((address ^ (unsigned long)to) & CACHE_ALIAS) == 0)
		copy_page(to, from);
	else {
		pgprot_t pgprot = __pgprot(_PAGE_PRESENT | 
					   _PAGE_RW | _PAGE_CACHABLE |
					   _PAGE_DIRTY | _PAGE_ACCESSED | 
					   _PAGE_HW_SHARED | _PAGE_FLAGS_HARD);
		unsigned long phys_addr = PHYSADDR(to);
		unsigned long p3_addr = P3SEG + (address & CACHE_ALIAS);
		pgd_t *dir = pgd_offset_k(p3_addr);
		pmd_t *pmd = pmd_offset(dir, p3_addr);
		pte_t *pte = pte_offset_kernel(pmd, p3_addr);
		pte_t entry;
		unsigned long flags;

		entry = pfn_pte(phys_addr >> PAGE_SHIFT, pgprot);
		down(&p3map_sem[(address & CACHE_ALIAS)>>12]);
		set_pte(pte, entry);
		local_irq_save(flags);
		__flush_tlb_page(get_asid(), p3_addr);
		local_irq_restore(flags);
		update_mmu_cache(NULL, p3_addr, entry);
		__copy_user_page((void *)p3_addr, from, to);
		pte_clear(&init_mm, p3_addr, pte);
		up(&p3map_sem[(address & CACHE_ALIAS)>>12]);
	}
}

/*
 * For SH-4, we have our own implementation for ptep_get_and_clear
 */
inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
{
	pte_t pte = *ptep;

	pte_clear(mm, addr, ptep);
	if (!pte_not_present(pte)) {
		unsigned long pfn = pte_pfn(pte);
		if (pfn_valid(pfn)) {
			struct page *page = pfn_to_page(pfn);
			struct address_space *mapping = page_mapping(page);
			if (!mapping || !mapping_writably_mapped(mapping))
				__clear_bit(PG_mapped, &page->flags);
		}
	}
	return pte;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* arch/sh/mm/pg-sh4.c
	3	*
	4	* Copyright (C) 1999, 2000, 2002 Niibe Yutaka
	5	* Copyright (C) 2002 Paul Mundt
	6	*
	7	* Released under the terms of the GNU GPL v2.0.
	8	*/
1da177e4 LT	9	#include <linux/init.h>
	10	#include <linux/mman.h>
	11	#include <linux/mm.h>
	12	#include <linux/threads.h>
	13	#include <asm/addrspace.h>
	14	#include <asm/page.h>
	15	#include <asm/pgtable.h>
	16	#include <asm/processor.h>
	17	#include <asm/cache.h>
	18	#include <asm/io.h>
	19	#include <asm/uaccess.h>
	20	#include <asm/pgalloc.h>
	21	#include <asm/mmu_context.h>
	22	#include <asm/cacheflush.h>
	23
	24	extern struct semaphore p3map_sem[];
	25
	26	/*
	27	* clear_user_page
	28	* @to: P1 address
	29	* @address: U0 address to be mapped
	30	* @page: page (virt_to_page(to))
	31	*/
	32	void clear_user_page(void to, unsigned long address, struct page page)
	33	{
	34	__set_bit(PG_mapped, &page->flags);
	35	if (((address ^ (unsigned long)to) & CACHE_ALIAS) == 0)
	36	clear_page(to);
	37	else {
	38	pgprot_t pgprot = __pgprot(_PAGE_PRESENT \|
	39	_PAGE_RW \| _PAGE_CACHABLE \|
	40	_PAGE_DIRTY \| _PAGE_ACCESSED \|
	41	_PAGE_HW_SHARED \| _PAGE_FLAGS_HARD);
	42	unsigned long phys_addr = PHYSADDR(to);
	43	unsigned long p3_addr = P3SEG + (address & CACHE_ALIAS);
	44	pgd_t *dir = pgd_offset_k(p3_addr);
	45	pmd_t *pmd = pmd_offset(dir, p3_addr);
	46	pte_t *pte = pte_offset_kernel(pmd, p3_addr);
	47	pte_t entry;
	48	unsigned long flags;
	49
	50	entry = pfn_pte(phys_addr >> PAGE_SHIFT, pgprot);
	51	down(&p3map_sem[(address & CACHE_ALIAS)>>12]);
	52	set_pte(pte, entry);
	53	local_irq_save(flags);
	54	__flush_tlb_page(get_asid(), p3_addr);
	55	local_irq_restore(flags);
	56	update_mmu_cache(NULL, p3_addr, entry);
	57	__clear_user_page((void *)p3_addr, to);
	58	pte_clear(&init_mm, p3_addr, pte);
	59	up(&p3map_sem[(address & CACHE_ALIAS)>>12]);
	60	}
	61	}
	62
	63	/*
	64	* copy_user_page
	65	* @to: P1 address
	66	* @from: P1 address
	67	* @address: U0 address to be mapped
	68	* @page: page (virt_to_page(to))
	69	*/
	70	void copy_user_page(void to, void from, unsigned long address,
	71	struct page *page)
	72	{
73	__set_bit(PG_mapped, &page->flags);
74	if (((address ^ (unsigned long)to) & CACHE_ALIAS) == 0)
75	copy_page(to, from);
76	else {
77	pgprot_t pgprot = __pgprot(_PAGE_PRESENT \|
78	_PAGE_RW \| _PAGE_CACHABLE \|
79	_PAGE_DIRTY \| _PAGE_ACCESSED \|
80	_PAGE_HW_SHARED \| _PAGE_FLAGS_HARD);
81	unsigned long phys_addr = PHYSADDR(to);
82	unsigned long p3_addr = P3SEG + (address & CACHE_ALIAS);
83	pgd_t *dir = pgd_offset_k(p3_addr);
84	pmd_t *pmd = pmd_offset(dir, p3_addr);
85	pte_t *pte = pte_offset_kernel(pmd, p3_addr);
86	pte_t entry;
87	unsigned long flags;
88
89	entry = pfn_pte(phys_addr >> PAGE_SHIFT, pgprot);
90	down(&p3map_sem[(address & CACHE_ALIAS)>>12]);
91	set_pte(pte, entry);
92	local_irq_save(flags);
93	__flush_tlb_page(get_asid(), p3_addr);
94	local_irq_restore(flags);
95	update_mmu_cache(NULL, p3_addr, entry);
96	__copy_user_page((void *)p3_addr, from, to);
97	pte_clear(&init_mm, p3_addr, pte);
98	up(&p3map_sem[(address & CACHE_ALIAS)>>12]);
99	}
100	}
101
102	/*
103	* For SH-4, we have our own implementation for ptep_get_and_clear
104	*/
105	inline pte_t ptep_get_and_clear(struct mm_struct mm, unsigned long addr, pte_t ptep)
106	{
107	pte_t pte = *ptep;
108
109	pte_clear(mm, addr, ptep);
110	if (!pte_not_present(pte)) {
111	unsigned long pfn = pte_pfn(pte);
112	if (pfn_valid(pfn)) {
113	struct page *page = pfn_to_page(pfn);
114	struct address_space *mapping = page_mapping(page);
115	if (!mapping \|\| !mapping_writably_mapped(mapping))
116	__clear_bit(PG_mapped, &page->flags);
117	}
118	}
119	return pte;
120	}
121