[mirror_ubuntu-focal-kernel.git] / arch / metag / mm / mmu-meta1.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  Copyright (C) 2005,2006,2007,2008,2009 Imagination Technologies
 *
 * Meta 1 MMU handling code.
 *
 */

#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/io.h>

#include <asm/mmu.h>

#define DM3_BASE (LINSYSDIRECT_BASE + (MMCU_DIRECTMAPn_ADDR_SCALE * 3))

/*
 * This contains the physical address of the top level 2k pgd table.
 */
static unsigned long mmu_base_phys;

/*
 * Given a physical address, return a mapped virtual address that can be used
 * to access that location.
 * In practice, we use the DirectMap region to make this happen.
 */
static unsigned long map_addr(unsigned long phys)
{
	static unsigned long dm_base = 0xFFFFFFFF;
	int offset;

	offset = phys - dm_base;

	/* Are we in the current map range ? */
	if ((offset < 0) || (offset >= MMCU_DIRECTMAPn_ADDR_SCALE)) {
		/* Calculate new DM area */
		dm_base = phys & ~(MMCU_DIRECTMAPn_ADDR_SCALE - 1);

		/* Actually map it in! */
		metag_out32(dm_base, MMCU_DIRECTMAP3_ADDR);

		/* And calculate how far into that area our reference is */
		offset = phys - dm_base;
	}

	return DM3_BASE + offset;
}

/*
 * Return the physical address of the base of our pgd table.
 */
static inline unsigned long __get_mmu_base(void)
{
	unsigned long base_phys;
	unsigned int stride;

	if (is_global_space(PAGE_OFFSET))
		stride = 4;
	else
		stride = hard_processor_id();	/* [0..3] */

	base_phys = metag_in32(MMCU_TABLE_PHYS_ADDR);
	base_phys += (0x800 * stride);

	return base_phys;
}

/* Given a virtual address, return the virtual address of the relevant pgd */
static unsigned long pgd_entry_addr(unsigned long virt)
{
	unsigned long pgd_phys;
	unsigned long pgd_virt;

	if (!mmu_base_phys)
		mmu_base_phys = __get_mmu_base();

	/*
	 * Are we trying to map a global address.  If so, then index
	 * the global pgd table instead of our local one.
	 */
	if (is_global_space(virt)) {
		/* Scale into 2gig map */
		virt &= ~0x80000000;
	}

	/* Base of the pgd table plus our 4Meg entry, 4bytes each */
	pgd_phys = mmu_base_phys + ((virt >> PGDIR_SHIFT) * 4);

	pgd_virt = map_addr(pgd_phys);

	return pgd_virt;
}

/* Given a virtual address, return the virtual address of the relevant pte */
static unsigned long pgtable_entry_addr(unsigned long virt)
{
	unsigned long pgtable_phys;
	unsigned long pgtable_virt, pte_virt;

	/* Find the physical address of the 4MB page table*/
	pgtable_phys = metag_in32(pgd_entry_addr(virt)) & MMCU_ENTRY_ADDR_BITS;

	/* Map it to a virtual address */
	pgtable_virt = map_addr(pgtable_phys);

	/* And index into it for our pte */
	pte_virt = pgtable_virt + ((virt >> PAGE_SHIFT) & 0x3FF) * 4;

	return pte_virt;
}

unsigned long mmu_read_first_level_page(unsigned long vaddr)
{
	return metag_in32(pgd_entry_addr(vaddr));
}

unsigned long mmu_read_second_level_page(unsigned long vaddr)
{
	return metag_in32(pgtable_entry_addr(vaddr));
}

unsigned long mmu_get_base(void)
{
	static unsigned long __base;

	/* Find the base of our MMU pgd table */
	if (!__base)
		__base = pgd_entry_addr(0);

	return __base;
}

void __init mmu_init(unsigned long mem_end)
{
	unsigned long entry, addr;
	pgd_t *p_swapper_pg_dir;

	/*
	 * Now copy over any MMU pgd entries already in the mmu page tables
	 * over to our root init process (swapper_pg_dir) map.  This map is
	 * then inherited by all other processes, which means all processes
	 * inherit a map of the kernel space.
	 */
	addr = PAGE_OFFSET;
	entry = pgd_index(PAGE_OFFSET);
	p_swapper_pg_dir = pgd_offset_k(0) + entry;

	while (addr <= META_MEMORY_LIMIT) {
		unsigned long pgd_entry;
		/* copy over the current MMU value */
		pgd_entry = mmu_read_first_level_page(addr);
		pgd_val(*p_swapper_pg_dir) = pgd_entry;

		p_swapper_pg_dir++;
		addr += PGDIR_SIZE;
	}
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
f5df8e26 JH	2	/*
	3	* Copyright (C) 2005,2006,2007,2008,2009 Imagination Technologies
	4	*
	5	* Meta 1 MMU handling code.
	6	*
	7	*/
	8
	9	#include <linux/sched.h>
	10	#include <linux/mm.h>
	11	#include <linux/io.h>
	12
	13	#include <asm/mmu.h>
	14
	15	#define DM3_BASE (LINSYSDIRECT_BASE + (MMCU_DIRECTMAPn_ADDR_SCALE * 3))
	16
	17	/*
	18	* This contains the physical address of the top level 2k pgd table.
	19	*/
	20	static unsigned long mmu_base_phys;
	21
	22	/*
	23	* Given a physical address, return a mapped virtual address that can be used
	24	* to access that location.
	25	* In practice, we use the DirectMap region to make this happen.
	26	*/
	27	static unsigned long map_addr(unsigned long phys)
	28	{
	29	static unsigned long dm_base = 0xFFFFFFFF;
	30	int offset;
	31
	32	offset = phys - dm_base;
	33
	34	/* Are we in the current map range ? */
	35	if ((offset < 0) \|\| (offset >= MMCU_DIRECTMAPn_ADDR_SCALE)) {
	36	/* Calculate new DM area */
	37	dm_base = phys & ~(MMCU_DIRECTMAPn_ADDR_SCALE - 1);
	38
	39	/* Actually map it in! */
	40	metag_out32(dm_base, MMCU_DIRECTMAP3_ADDR);
	41
	42	/* And calculate how far into that area our reference is */
	43	offset = phys - dm_base;
	44	}
	45
	46	return DM3_BASE + offset;
	47	}
	48
	49	/*
	50	* Return the physical address of the base of our pgd table.
	51	*/
	52	static inline unsigned long __get_mmu_base(void)
	53	{
	54	unsigned long base_phys;
	55	unsigned int stride;
	56
	57	if (is_global_space(PAGE_OFFSET))
	58	stride = 4;
	59	else
	60	stride = hard_processor_id(); /* [0..3] */
	61
	62	base_phys = metag_in32(MMCU_TABLE_PHYS_ADDR);
	63	base_phys += (0x800 * stride);
	64
	65	return base_phys;
66	}
67
68	/* Given a virtual address, return the virtual address of the relevant pgd */
69	static unsigned long pgd_entry_addr(unsigned long virt)
70	{
71	unsigned long pgd_phys;
72	unsigned long pgd_virt;
73
74	if (!mmu_base_phys)
75	mmu_base_phys = __get_mmu_base();
76
77	/*
78	* Are we trying to map a global address. If so, then index
79	* the global pgd table instead of our local one.
80	*/
81	if (is_global_space(virt)) {
82	/* Scale into 2gig map */
83	virt &= ~0x80000000;
84	}
85
86	/* Base of the pgd table plus our 4Meg entry, 4bytes each */
87	pgd_phys = mmu_base_phys + ((virt >> PGDIR_SHIFT) * 4);
88
89	pgd_virt = map_addr(pgd_phys);
90
91	return pgd_virt;
92	}
93
94	/* Given a virtual address, return the virtual address of the relevant pte */
95	static unsigned long pgtable_entry_addr(unsigned long virt)
96	{
97	unsigned long pgtable_phys;
98	unsigned long pgtable_virt, pte_virt;
99
100	/* Find the physical address of the 4MB page table*/
101	pgtable_phys = metag_in32(pgd_entry_addr(virt)) & MMCU_ENTRY_ADDR_BITS;
102
103	/* Map it to a virtual address */
104	pgtable_virt = map_addr(pgtable_phys);
105
106	/* And index into it for our pte */
107	pte_virt = pgtable_virt + ((virt >> PAGE_SHIFT) & 0x3FF) * 4;
108
109	return pte_virt;
110	}
111
112	unsigned long mmu_read_first_level_page(unsigned long vaddr)
113	{
114	return metag_in32(pgd_entry_addr(vaddr));
115	}
116
117	unsigned long mmu_read_second_level_page(unsigned long vaddr)
118	{
119	return metag_in32(pgtable_entry_addr(vaddr));
120	}
121
122	unsigned long mmu_get_base(void)
123	{
124	static unsigned long __base;
125
126	/* Find the base of our MMU pgd table */
127	if (!__base)
128	__base = pgd_entry_addr(0);
129
130	return __base;
131	}
132
133	void __init mmu_init(unsigned long mem_end)
134	{
135	unsigned long entry, addr;
136	pgd_t *p_swapper_pg_dir;
137
138	/*
139	* Now copy over any MMU pgd entries already in the mmu page tables
140	* over to our root init process (swapper_pg_dir) map. This map is
141	* then inherited by all other processes, which means all processes
142	* inherit a map of the kernel space.
143	*/
144	addr = PAGE_OFFSET;
145	entry = pgd_index(PAGE_OFFSET);
146	p_swapper_pg_dir = pgd_offset_k(0) + entry;
147
148	while (addr <= META_MEMORY_LIMIT) {
149	unsigned long pgd_entry;
150	/* copy over the current MMU value */
151	pgd_entry = mmu_read_first_level_page(addr);
152	pgd_val(*p_swapper_pg_dir) = pgd_entry;
153
154	p_swapper_pg_dir++;
155	addr += PGDIR_SIZE;
f5df8e26 JH	156	}
f5df8e26 JH	157	}