[mirror_ubuntu-eoan-kernel.git] / arch / sparc / mm / generic_64.c

/*
 * generic.c: Generic Sparc mm routines that are not dependent upon
 *            MMU type but are Sparc specific.
 *
 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
 */

#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/swap.h>
#include <linux/export.h>
#include <linux/pagemap.h>

#include <asm/pgalloc.h>
#include <asm/pgtable.h>
#include <asm/page.h>
#include <asm/tlbflush.h>

/* Remap IO memory, the same way as remap_pfn_range(), but use
 * the obio memory space.
 *
 * They use a pgprot that sets PAGE_IO and does not check the
 * mem_map table as this is independent of normal memory.
 */
static inline void io_remap_pte_range(struct mm_struct *mm, pte_t * pte,
				      unsigned long address,
				      unsigned long size,
				      unsigned long offset, pgprot_t prot,
				      int space)
{
	unsigned long end;

	/* clear hack bit that was used as a write_combine side-effect flag */
	offset &= ~0x1UL;
	address &= ~PMD_MASK;
	end = address + size;
	if (end > PMD_SIZE)
		end = PMD_SIZE;
	do {
		pte_t entry;
		unsigned long curend = address + PAGE_SIZE;
		
		entry = mk_pte_io(offset, prot, space, PAGE_SIZE);
		if (!(address & 0xffff)) {
			if (PAGE_SIZE < (4 * 1024 * 1024) &&
			    !(address & 0x3fffff) &&
			    !(offset & 0x3ffffe) &&
			    end >= address + 0x400000) {
				entry = mk_pte_io(offset, prot, space,
						  4 * 1024 * 1024);
				curend = address + 0x400000;
				offset += 0x400000;
			} else if (PAGE_SIZE < (512 * 1024) &&
				   !(address & 0x7ffff) &&
				   !(offset & 0x7fffe) &&
				   end >= address + 0x80000) {
				entry = mk_pte_io(offset, prot, space,
						  512 * 1024 * 1024);
				curend = address + 0x80000;
				offset += 0x80000;
			} else if (PAGE_SIZE < (64 * 1024) &&
				   !(offset & 0xfffe) &&
				   end >= address + 0x10000) {
				entry = mk_pte_io(offset, prot, space,
						  64 * 1024);
				curend = address + 0x10000;
				offset += 0x10000;
			} else
				offset += PAGE_SIZE;
		} else
			offset += PAGE_SIZE;

		if (pte_write(entry))
			entry = pte_mkdirty(entry);
		do {
			BUG_ON(!pte_none(*pte));
			set_pte_at(mm, address, pte, entry);
			address += PAGE_SIZE;
			pte_val(entry) += PAGE_SIZE;
			pte++;
		} while (address < curend);
	} while (address < end);
}

static inline int io_remap_pmd_range(struct mm_struct *mm, pmd_t * pmd, unsigned long address, unsigned long size,
	unsigned long offset, pgprot_t prot, int space)
{
	unsigned long end;

	address &= ~PGDIR_MASK;
	end = address + size;
	if (end > PGDIR_SIZE)
		end = PGDIR_SIZE;
	offset -= address;
	do {
		pte_t *pte = pte_alloc_map(mm, NULL, pmd, address);
		if (!pte)
			return -ENOMEM;
		io_remap_pte_range(mm, pte, address, end - address, address + offset, prot, space);
		pte_unmap(pte);
		address = (address + PMD_SIZE) & PMD_MASK;
		pmd++;
	} while (address < end);
	return 0;
}

static inline int io_remap_pud_range(struct mm_struct *mm, pud_t * pud, unsigned long address, unsigned long size,
	unsigned long offset, pgprot_t prot, int space)
{
	unsigned long end;

	address &= ~PUD_MASK;
	end = address + size;
	if (end > PUD_SIZE)
		end = PUD_SIZE;
	offset -= address;
	do {
		pmd_t *pmd = pmd_alloc(mm, pud, address);
		if (!pud)
			return -ENOMEM;
		io_remap_pmd_range(mm, pmd, address, end - address, address + offset, prot, space);
		address = (address + PUD_SIZE) & PUD_MASK;
		pud++;
	} while (address < end);
	return 0;
}

int io_remap_pfn_range(struct vm_area_struct *vma, unsigned long from,
		unsigned long pfn, unsigned long size, pgprot_t prot)
{
	int error = 0;
	pgd_t * dir;
	unsigned long beg = from;
	unsigned long end = from + size;
	struct mm_struct *mm = vma->vm_mm;
	int space = GET_IOSPACE(pfn);
	unsigned long offset = GET_PFN(pfn) << PAGE_SHIFT;
	unsigned long phys_base;

	phys_base = offset | (((unsigned long) space) << 32UL);

	/* See comment in mm/memory.c remap_pfn_range */
	vma->vm_flags |= VM_IO | VM_RESERVED | VM_PFNMAP;
	vma->vm_pgoff = phys_base >> PAGE_SHIFT;

	offset -= from;
	dir = pgd_offset(mm, from);
	flush_cache_range(vma, beg, end);

	while (from < end) {
		pud_t *pud = pud_alloc(mm, dir, from);
		error = -ENOMEM;
		if (!pud)
			break;
		error = io_remap_pud_range(mm, pud, from, end - from, offset + from, prot, space);
		if (error)
			break;
		from = (from + PGDIR_SIZE) & PGDIR_MASK;
		dir++;
	}

	flush_tlb_range(vma, beg, end);
	return error;
}
EXPORT_SYMBOL(io_remap_pfn_range);
Commit	Line	Data
b00dc837	1	/*
1da177e4 LT	2	* generic.c: Generic Sparc mm routines that are not dependent upon
	3	* MMU type but are Sparc specific.
	4	*
	5	* Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
	6	*/
	7
	8	#include <linux/kernel.h>
	9	#include <linux/mm.h>
	10	#include <linux/swap.h>
7b64db60	11	#include <linux/export.h>
1da177e4 LT	12	#include <linux/pagemap.h>
	13
	14	#include <asm/pgalloc.h>
	15	#include <asm/pgtable.h>
	16	#include <asm/page.h>
	17	#include <asm/tlbflush.h>
	18
	19	/* Remap IO memory, the same way as remap_pfn_range(), but use
	20	* the obio memory space.
	21	*
	22	* They use a pgprot that sets PAGE_IO and does not check the
	23	* mem_map table as this is independent of normal memory.
	24	*/
	25	static inline void io_remap_pte_range(struct mm_struct mm, pte_t pte,
	26	unsigned long address,
	27	unsigned long size,
	28	unsigned long offset, pgprot_t prot,
	29	int space)
	30	{
	31	unsigned long end;
	32
	33	/* clear hack bit that was used as a write_combine side-effect flag */
	34	offset &= ~0x1UL;
	35	address &= ~PMD_MASK;
	36	end = address + size;
	37	if (end > PMD_SIZE)
	38	end = PMD_SIZE;
	39	do {
	40	pte_t entry;
	41	unsigned long curend = address + PAGE_SIZE;
	42
c4bce90e	43	entry = mk_pte_io(offset, prot, space, PAGE_SIZE);
1da177e4	44	if (!(address & 0xffff)) {
c4bce90e DM	45	if (PAGE_SIZE < (4 * 1024 * 1024) &&
	46	!(address & 0x3fffff) &&
	47	!(offset & 0x3ffffe) &&
	48	end >= address + 0x400000) {
	49	entry = mk_pte_io(offset, prot, space,
	50	4 * 1024 * 1024);
1da177e4 LT	51	curend = address + 0x400000;
1da177e4 LT	52	offset += 0x400000;
c4bce90e DM	53	} else if (PAGE_SIZE < (512 * 1024) &&
	54	!(address & 0x7ffff) &&
	55	!(offset & 0x7fffe) &&
	56	end >= address + 0x80000) {
	57	entry = mk_pte_io(offset, prot, space,
	58	512 * 1024 * 1024);
1da177e4 LT	59	curend = address + 0x80000;
1da177e4 LT	60	offset += 0x80000;
c4bce90e DM	61	} else if (PAGE_SIZE < (64 * 1024) &&
	62	!(offset & 0xfffe) &&
	63	end >= address + 0x10000) {
	64	entry = mk_pte_io(offset, prot, space,
	65	64 * 1024);
1da177e4 LT	66	curend = address + 0x10000;
	67	offset += 0x10000;
	68	} else
	69	offset += PAGE_SIZE;
	70	} else
	71	offset += PAGE_SIZE;
	72
47f2c360 DM	73	if (pte_write(entry))
47f2c360 DM	74	entry = pte_mkdirty(entry);
1da177e4 LT	75	do {
	76	BUG_ON(!pte_none(*pte));
	77	set_pte_at(mm, address, pte, entry);
	78	address += PAGE_SIZE;
cab3f16f	79	pte_val(entry) += PAGE_SIZE;
1da177e4 LT	80	pte++;
	81	} while (address < curend);
	82	} while (address < end);
	83	}
	84
	85	static inline int io_remap_pmd_range(struct mm_struct mm, pmd_t pmd, unsigned long address, unsigned long size,
	86	unsigned long offset, pgprot_t prot, int space)
	87	{
	88	unsigned long end;
	89
	90	address &= ~PGDIR_MASK;
	91	end = address + size;
	92	if (end > PGDIR_SIZE)
	93	end = PGDIR_SIZE;
	94	offset -= address;
	95	do {
8ac1f832	96	pte_t *pte = pte_alloc_map(mm, NULL, pmd, address);
1da177e4 LT	97	if (!pte)
	98	return -ENOMEM;
	99	io_remap_pte_range(mm, pte, address, end - address, address + offset, prot, space);
	100	pte_unmap(pte);
	101	address = (address + PMD_SIZE) & PMD_MASK;
	102	pmd++;
	103	} while (address < end);
	104	return 0;
	105	}
	106
	107	static inline int io_remap_pud_range(struct mm_struct mm, pud_t pud, unsigned long address, unsigned long size,
	108	unsigned long offset, pgprot_t prot, int space)
	109	{
	110	unsigned long end;
	111
	112	address &= ~PUD_MASK;
	113	end = address + size;
	114	if (end > PUD_SIZE)
	115	end = PUD_SIZE;
	116	offset -= address;
	117	do {
	118	pmd_t *pmd = pmd_alloc(mm, pud, address);
	119	if (!pud)
	120	return -ENOMEM;
	121	io_remap_pmd_range(mm, pmd, address, end - address, address + offset, prot, space);
	122	address = (address + PUD_SIZE) & PUD_MASK;
	123	pud++;
	124	} while (address < end);
	125	return 0;
	126	}
	127
1da177e4 LT	128	int io_remap_pfn_range(struct vm_area_struct *vma, unsigned long from,
	129	unsigned long pfn, unsigned long size, pgprot_t prot)
	130	{
	131	int error = 0;
	132	pgd_t * dir;
	133	unsigned long beg = from;
	134	unsigned long end = from + size;
	135	struct mm_struct *mm = vma->vm_mm;
	136	int space = GET_IOSPACE(pfn);
	137	unsigned long offset = GET_PFN(pfn) << PAGE_SHIFT;
5cd9194a DM	138	unsigned long phys_base;
	139
	140	phys_base = offset \| (((unsigned long) space) << 32UL);
1da177e4	141
b5810039	142	/* See comment in mm/memory.c remap_pfn_range */
5cd9194a DM	143	vma->vm_flags \|= VM_IO \| VM_RESERVED \| VM_PFNMAP;
5cd9194a DM	144	vma->vm_pgoff = phys_base >> PAGE_SHIFT;
b5810039	145
1da177e4 LT	146	offset -= from;
	147	dir = pgd_offset(mm, from);
	148	flush_cache_range(vma, beg, end);
	149
1da177e4	150	while (from < end) {
b462705a	151	pud_t *pud = pud_alloc(mm, dir, from);
1da177e4 LT	152	error = -ENOMEM;
	153	if (!pud)
	154	break;
	155	error = io_remap_pud_range(mm, pud, from, end - from, offset + from, prot, space);
	156	if (error)
	157	break;
	158	from = (from + PGDIR_SIZE) & PGDIR_MASK;
	159	dir++;
	160	}
1da177e4	161
b462705a	162	flush_tlb_range(vma, beg, end);
1da177e4 LT	163	return error;
1da177e4 LT	164	}
917c3660	165	EXPORT_SYMBOL(io_remap_pfn_range);