[mirror_ubuntu-jammy-kernel.git] / arch / x86 / mm / ioremap_32.c

/*
 * Re-map IO memory to kernel address space so that we can access it.
 * This is needed for high PCI addresses that aren't mapped in the
 * 640k-1MB IO memory area on PC's
 *
 * (C) Copyright 1995 1996 Linus Torvalds
 */

#include <linux/vmalloc.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/io.h>
#include <asm/fixmap.h>
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
#include <asm/pgtable.h>

#define ISA_START_ADDRESS	0xa0000
#define ISA_END_ADDRESS		0x100000

/*
 * Remap an arbitrary physical address space into the kernel virtual
 * address space. Needed when the kernel wants to access high addresses
 * directly.
 *
 * NOTE! We need to allow non-page-aligned mappings too: we will obviously
 * have to convert them into an offset in a page-aligned mapping, but the
 * caller shouldn't need to know that small detail.
 */
void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
			unsigned long flags)
{
	void __iomem *addr;
	struct vm_struct *area;
	unsigned long offset, last_addr;
	pgprot_t prot;

	/* Don't allow wraparound or zero size */
	last_addr = phys_addr + size - 1;
	if (!size || last_addr < phys_addr)
		return NULL;

	/*
	 * Don't remap the low PCI/ISA area, it's always mapped..
	 */
	if (phys_addr >= ISA_START_ADDRESS && last_addr < ISA_END_ADDRESS)
		return (void __iomem *) phys_to_virt(phys_addr);

	/*
	 * Don't allow anybody to remap normal RAM that we're using..
	 */
	if (phys_addr <= virt_to_phys(high_memory - 1)) {
		char *t_addr, *t_end;
		struct page *page;

		t_addr = __va(phys_addr);
		t_end = t_addr + (size - 1);

		for (page = virt_to_page(t_addr);
		     page <= virt_to_page(t_end); page++)
			if (!PageReserved(page))
				return NULL;
	}

	prot = MAKE_GLOBAL(__PAGE_KERNEL | flags);

	/*
	 * Mappings have to be page-aligned
	 */
	offset = phys_addr & ~PAGE_MASK;
	phys_addr &= PAGE_MASK;
	size = PAGE_ALIGN(last_addr+1) - phys_addr;

	/*
	 * Ok, go for it..
	 */
	area = get_vm_area(size, VM_IOREMAP | (flags << 20));
	if (!area)
		return NULL;
	area->phys_addr = phys_addr;
	addr = (void __iomem *) area->addr;
	if (ioremap_page_range((unsigned long) addr,
			       (unsigned long) addr + size, phys_addr, prot)) {
		vunmap((void __force *) addr);
		return NULL;
	}
	return (void __iomem *) (offset + (char __iomem *)addr);
}
EXPORT_SYMBOL(__ioremap);

/**
 * ioremap_nocache     -   map bus memory into CPU space
 * @offset:    bus address of the memory
 * @size:      size of the resource to map
 *
 * ioremap_nocache performs a platform specific sequence of operations to
 * make bus memory CPU accessible via the readb/readw/readl/writeb/
 * writew/writel functions and the other mmio helpers. The returned
 * address is not guaranteed to be usable directly as a virtual
 * address.
 *
 * This version of ioremap ensures that the memory is marked uncachable
 * on the CPU as well as honouring existing caching rules from things like
 * the PCI bus. Note that there are other caches and buffers on many
 * busses. In particular driver authors should read up on PCI writes
 *
 * It's useful if some control registers are in such an area and
 * write combining or read caching is not desirable:
 *
 * Must be freed with iounmap.
 */
void __iomem *ioremap_nocache(unsigned long phys_addr, unsigned long size)
{
	unsigned long last_addr;
	void __iomem *p = __ioremap(phys_addr, size, _PAGE_PCD | _PAGE_PWT);

	if (!p)
		return p;

	/* Guaranteed to be > phys_addr, as per __ioremap() */
	last_addr = phys_addr + size - 1;

	if (last_addr < virt_to_phys(high_memory) - 1) {
		struct page *ppage = virt_to_page(__va(phys_addr));
		unsigned long npages;

		phys_addr &= PAGE_MASK;

		/* This might overflow and become zero.. */
		last_addr = PAGE_ALIGN(last_addr);

		/* .. but that's ok, because modulo-2**n arithmetic will make
		 * the page-aligned "last - first" come out right.
		 */
		npages = (last_addr - phys_addr) >> PAGE_SHIFT;

		if (change_page_attr(ppage, npages, PAGE_KERNEL_NOCACHE) < 0) {
			iounmap(p);
			p = NULL;
		}
		global_flush_tlb();
	}

	return p;
}
EXPORT_SYMBOL(ioremap_nocache);

/**
 * iounmap - Free a IO remapping
 * @addr: virtual address from ioremap_*
 *
 * Caller must ensure there is only one unmapping for the same pointer.
 */
void iounmap(volatile void __iomem *addr)
{
	struct vm_struct *p, *o;

	if ((void __force *)addr <= high_memory)
		return;

	/*
	 * __ioremap special-cases the PCI/ISA range by not instantiating a
	 * vm_area and by simply returning an address into the kernel mapping
	 * of ISA space.   So handle that here.
	 */
	if (addr >= phys_to_virt(ISA_START_ADDRESS) &&
	    addr < phys_to_virt(ISA_END_ADDRESS))
		return;

	addr = (volatile void __iomem *)
		(PAGE_MASK & (unsigned long __force)addr);

	/* Use the vm area unlocked, assuming the caller
	   ensures there isn't another iounmap for the same address
	   in parallel. Reuse of the virtual address is prevented by
	   leaving it in the global lists until we're done with it.
	   cpa takes care of the direct mappings. */
	read_lock(&vmlist_lock);
	for (p = vmlist; p; p = p->next) {
		if (p->addr == addr)
			break;
	}
	read_unlock(&vmlist_lock);

	if (!p) {
		printk(KERN_ERR "iounmap: bad address %p\n", addr);
		dump_stack();
		return;
	}

	/* Reset the direct mapping. Can block */
	if ((p->flags >> 20) && p->phys_addr < virt_to_phys(high_memory) - 1) {
		change_page_attr(virt_to_page(__va(p->phys_addr)),
				 get_vm_area_size(p) >> PAGE_SHIFT,
				 PAGE_KERNEL);
		global_flush_tlb();
	}

	/* Finally remove it */
	o = remove_vm_area((void *)addr);
	BUG_ON(p != o || o == NULL);
	kfree(p);
}
EXPORT_SYMBOL(iounmap);


int __initdata early_ioremap_debug;

static int __init early_ioremap_debug_setup(char *str)
{
	early_ioremap_debug = 1;

	return 0;
}
early_param("early_ioremap_debug", early_ioremap_debug_setup);

static __initdata int after_paging_init;
static __initdata unsigned long bm_pte[1024]
				__attribute__((aligned(PAGE_SIZE)));

static inline unsigned long * __init early_ioremap_pgd(unsigned long addr)
{
	return (unsigned long *)swapper_pg_dir + ((addr >> 22) & 1023);
}

static inline unsigned long * __init early_ioremap_pte(unsigned long addr)
{
	return bm_pte + ((addr >> PAGE_SHIFT) & 1023);
}

void __init early_ioremap_init(void)
{
	unsigned long *pgd;

	if (early_ioremap_debug)
		printk(KERN_DEBUG "early_ioremap_init()\n");

	pgd = early_ioremap_pgd(fix_to_virt(FIX_BTMAP_BEGIN));
	*pgd = __pa(bm_pte) | _PAGE_TABLE;
	memset(bm_pte, 0, sizeof(bm_pte));
	/*
	 * The boot-ioremap range spans multiple pgds, for which
	 * we are not prepared:
	 */
	if (pgd != early_ioremap_pgd(fix_to_virt(FIX_BTMAP_END))) {
		WARN_ON(1);
		printk(KERN_WARNING "pgd %p != %p\n",
		       pgd, early_ioremap_pgd(fix_to_virt(FIX_BTMAP_END)));
		printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
		       fix_to_virt(FIX_BTMAP_BEGIN));
		printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END):   %08lx\n",
		       fix_to_virt(FIX_BTMAP_END));

		printk(KERN_WARNING "FIX_BTMAP_END:       %d\n", FIX_BTMAP_END);
		printk(KERN_WARNING "FIX_BTMAP_BEGIN:     %d\n",
		       FIX_BTMAP_BEGIN);
	}
}

void __init early_ioremap_clear(void)
{
	unsigned long *pgd;

	if (early_ioremap_debug)
		printk(KERN_DEBUG "early_ioremap_clear()\n");

	pgd = early_ioremap_pgd(fix_to_virt(FIX_BTMAP_BEGIN));
	*pgd = 0;
	__flush_tlb_all();
}

void __init early_ioremap_reset(void)
{
	enum fixed_addresses idx;
	unsigned long *pte, phys, addr;

	after_paging_init = 1;
	for (idx = FIX_BTMAP_BEGIN; idx >= FIX_BTMAP_END; idx--) {
		addr = fix_to_virt(idx);
		pte = early_ioremap_pte(addr);
		if (!*pte & _PAGE_PRESENT) {
			phys = *pte & PAGE_MASK;
			set_fixmap(idx, phys);
		}
	}
}

static void __init __early_set_fixmap(enum fixed_addresses idx,
				   unsigned long phys, pgprot_t flags)
{
	unsigned long *pte, addr = __fix_to_virt(idx);

	if (idx >= __end_of_fixed_addresses) {
		BUG();
		return;
	}
	pte = early_ioremap_pte(addr);
	if (pgprot_val(flags))
		*pte = (phys & PAGE_MASK) | pgprot_val(flags);
	else
		*pte = 0;
	__flush_tlb_one(addr);
}

static inline void __init early_set_fixmap(enum fixed_addresses idx,
					unsigned long phys)
{
	if (after_paging_init)
		set_fixmap(idx, phys);
	else
		__early_set_fixmap(idx, phys, PAGE_KERNEL);
}

static inline void __init early_clear_fixmap(enum fixed_addresses idx)
{
	if (after_paging_init)
		clear_fixmap(idx);
	else
		__early_set_fixmap(idx, 0, __pgprot(0));
}


int __initdata early_ioremap_nested;

static int __init check_early_ioremap_leak(void)
{
	if (!early_ioremap_nested)
		return 0;

	printk(KERN_WARNING
	       "Debug warning: early ioremap leak of %d areas detected.\n",
	       early_ioremap_nested);
	printk(KERN_WARNING
	       "please boot with early_ioremap_debug and report the dmesg.\n");
	WARN_ON(1);

	return 1;
}
late_initcall(check_early_ioremap_leak);

void __init *early_ioremap(unsigned long phys_addr, unsigned long size)
{
	unsigned long offset, last_addr;
	unsigned int nrpages, nesting;
	enum fixed_addresses idx0, idx;

	WARN_ON(system_state != SYSTEM_BOOTING);

	nesting = early_ioremap_nested;
	if (early_ioremap_debug) {
		printk(KERN_DEBUG "early_ioremap(%08lx, %08lx) [%d] => ",
		       phys_addr, size, nesting);
		dump_stack();
	}

	/* Don't allow wraparound or zero size */
	last_addr = phys_addr + size - 1;
	if (!size || last_addr < phys_addr) {
		WARN_ON(1);
		return NULL;
	}

	if (nesting >= FIX_BTMAPS_NESTING) {
		WARN_ON(1);
		return NULL;
	}
	early_ioremap_nested++;
	/*
	 * Mappings have to be page-aligned
	 */
	offset = phys_addr & ~PAGE_MASK;
	phys_addr &= PAGE_MASK;
	size = PAGE_ALIGN(last_addr) - phys_addr;

	/*
	 * Mappings have to fit in the FIX_BTMAP area.
	 */
	nrpages = size >> PAGE_SHIFT;
	if (nrpages > NR_FIX_BTMAPS) {
		WARN_ON(1);
		return NULL;
	}

	/*
	 * Ok, go for it..
	 */
	idx0 = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*nesting;
	idx = idx0;
	while (nrpages > 0) {
		early_set_fixmap(idx, phys_addr);
		phys_addr += PAGE_SIZE;
		--idx;
		--nrpages;
	}
	if (early_ioremap_debug)
		printk(KERN_CONT "%08lx + %08lx\n", offset, fix_to_virt(idx0));

	return (void *) (offset + fix_to_virt(idx0));
}

void __init early_iounmap(void *addr, unsigned long size)
{
	unsigned long virt_addr;
	unsigned long offset;
	unsigned int nrpages;
	enum fixed_addresses idx;
	unsigned int nesting;

	nesting = --early_ioremap_nested;
	WARN_ON(nesting < 0);

	if (early_ioremap_debug) {
		printk(KERN_DEBUG "early_iounmap(%p, %08lx) [%d]\n", addr,
		       size, nesting);
		dump_stack();
	}

	virt_addr = (unsigned long)addr;
	if (virt_addr < fix_to_virt(FIX_BTMAP_BEGIN)) {
		WARN_ON(1);
		return;
	}
	offset = virt_addr & ~PAGE_MASK;
	nrpages = PAGE_ALIGN(offset + size - 1) >> PAGE_SHIFT;

	idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*nesting;
	while (nrpages > 0) {
		early_clear_fixmap(idx);
		--idx;
		--nrpages;
	}
}

void __this_fixmap_does_not_exist(void)
{
	WARN_ON(1);
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Re-map IO memory to kernel address space so that we can access it.
	3	* This is needed for high PCI addresses that aren't mapped in the
	4	* 640k-1MB IO memory area on PC's
	5	*
	6	* (C) Copyright 1995 1996 Linus Torvalds
	7	*/
	8
	9	#include <linux/vmalloc.h>
	10	#include <linux/init.h>
	11	#include <linux/slab.h>
129f6946	12	#include <linux/module.h>
a148ecfd	13	#include <linux/io.h>
1da177e4 LT	14	#include <asm/fixmap.h>
	15	#include <asm/cacheflush.h>
	16	#include <asm/tlbflush.h>
	17	#include <asm/pgtable.h>
	18
	19	#define ISA_START_ADDRESS 0xa0000
	20	#define ISA_END_ADDRESS 0x100000
	21
1da177e4 LT	22	/*
	23	* Remap an arbitrary physical address space into the kernel virtual
	24	* address space. Needed when the kernel wants to access high addresses
	25	* directly.
	26	*
	27	* NOTE! We need to allow non-page-aligned mappings too: we will obviously
	28	* have to convert them into an offset in a page-aligned mapping, but the
	29	* caller shouldn't need to know that small detail.
	30	*/
91eebf40 TG	31	void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
91eebf40 TG	32	unsigned long flags)
1da177e4	33	{
91eebf40 TG	34	void __iomem *addr;
91eebf40 TG	35	struct vm_struct *area;
1da177e4	36	unsigned long offset, last_addr;
a148ecfd	37	pgprot_t prot;
1da177e4 LT	38
	39	/* Don't allow wraparound or zero size */
	40	last_addr = phys_addr + size - 1;
	41	if (!size \|\| last_addr < phys_addr)
	42	return NULL;
	43
	44	/*
	45	* Don't remap the low PCI/ISA area, it's always mapped..
	46	*/
	47	if (phys_addr >= ISA_START_ADDRESS && last_addr < ISA_END_ADDRESS)
	48	return (void __iomem *) phys_to_virt(phys_addr);
	49
	50	/*
	51	* Don't allow anybody to remap normal RAM that we're using..
	52	*/
	53	if (phys_addr <= virt_to_phys(high_memory - 1)) {
	54	char t_addr, t_end;
	55	struct page *page;
	56
	57	t_addr = __va(phys_addr);
	58	t_end = t_addr + (size - 1);
91eebf40 TG	59
	60	for (page = virt_to_page(t_addr);
	61	page <= virt_to_page(t_end); page++)
	62	if (!PageReserved(page))
1da177e4 LT	63	return NULL;
	64	}
	65
a4034349	66	prot = MAKE_GLOBAL(__PAGE_KERNEL \| flags);
a148ecfd	67
1da177e4 LT	68	/*
	69	* Mappings have to be page-aligned
	70	*/
	71	offset = phys_addr & ~PAGE_MASK;
	72	phys_addr &= PAGE_MASK;
	73	size = PAGE_ALIGN(last_addr+1) - phys_addr;
	74
	75	/*
	76	* Ok, go for it..
	77	*/
	78	area = get_vm_area(size, VM_IOREMAP \| (flags << 20));
	79	if (!area)
	80	return NULL;
	81	area->phys_addr = phys_addr;
	82	addr = (void __iomem *) area->addr;
	83	if (ioremap_page_range((unsigned long) addr,
91eebf40	84	(unsigned long) addr + size, phys_addr, prot)) {
1da177e4 LT	85	vunmap((void __force *) addr);
	86	return NULL;
	87	}
	88	return (void __iomem ) (offset + (char __iomem )addr);
	89	}
129f6946	90	EXPORT_SYMBOL(__ioremap);
1da177e4 LT	91
	92	/**
	93	* ioremap_nocache - map bus memory into CPU space
	94	* @offset: bus address of the memory
	95	* @size: size of the resource to map
	96	*
	97	* ioremap_nocache performs a platform specific sequence of operations to
	98	* make bus memory CPU accessible via the readb/readw/readl/writeb/
	99	* writew/writel functions and the other mmio helpers. The returned
	100	* address is not guaranteed to be usable directly as a virtual
91eebf40	101	* address.
1da177e4 LT	102	*
	103	* This version of ioremap ensures that the memory is marked uncachable
	104	* on the CPU as well as honouring existing caching rules from things like
91eebf40	105	* the PCI bus. Note that there are other caches and buffers on many
1da177e4 LT	106	* busses. In particular driver authors should read up on PCI writes
	107	*
	108	* It's useful if some control registers are in such an area and
	109	* write combining or read caching is not desirable:
91eebf40	110	*
1da177e4 LT	111	* Must be freed with iounmap.
1da177e4 LT	112	*/
91eebf40	113	void __iomem *ioremap_nocache(unsigned long phys_addr, unsigned long size)
1da177e4 LT	114	{
1da177e4 LT	115	unsigned long last_addr;
4138cc34	116	void __iomem *p = __ioremap(phys_addr, size, _PAGE_PCD \| _PAGE_PWT);
91eebf40 TG	117
	118	if (!p)
	119	return p;
1da177e4 LT	120
	121	/* Guaranteed to be > phys_addr, as per __ioremap() */
	122	last_addr = phys_addr + size - 1;
	123
	124	if (last_addr < virt_to_phys(high_memory) - 1) {
91eebf40	125	struct page *ppage = virt_to_page(__va(phys_addr));
1da177e4 LT	126	unsigned long npages;
	127
	128	phys_addr &= PAGE_MASK;
	129
	130	/* This might overflow and become zero.. */
	131	last_addr = PAGE_ALIGN(last_addr);
	132
	133	/* .. but that's ok, because modulo-2**n arithmetic will make
91eebf40 TG	134	* the page-aligned "last - first" come out right.
91eebf40 TG	135	*/
1da177e4 LT	136	npages = (last_addr - phys_addr) >> PAGE_SHIFT;
1da177e4 LT	137
91eebf40 TG	138	if (change_page_attr(ppage, npages, PAGE_KERNEL_NOCACHE) < 0) {
91eebf40 TG	139	iounmap(p);
1da177e4 LT	140	p = NULL;
	141	}
	142	global_flush_tlb();
	143	}
	144
91eebf40	145	return p;
1da177e4	146	}
129f6946	147	EXPORT_SYMBOL(ioremap_nocache);
1da177e4	148
bf5421c3 AK	149	/**
	150	* iounmap - Free a IO remapping
	151	* @addr: virtual address from ioremap_*
	152	*
	153	* Caller must ensure there is only one unmapping for the same pointer.
	154	*/
1da177e4 LT	155	void iounmap(volatile void __iomem *addr)
1da177e4 LT	156	{
bf5421c3	157	struct vm_struct p, o;
c23a4e96 AM	158
c23a4e96 AM	159	if ((void __force *)addr <= high_memory)
1da177e4 LT	160	return;
	161
	162	/*
	163	* __ioremap special-cases the PCI/ISA range by not instantiating a
	164	* vm_area and by simply returning an address into the kernel mapping
	165	* of ISA space. So handle that here.
	166	*/
	167	if (addr >= phys_to_virt(ISA_START_ADDRESS) &&
91eebf40	168	addr < phys_to_virt(ISA_END_ADDRESS))
1da177e4 LT	169	return;
1da177e4 LT	170
91eebf40 TG	171	addr = (volatile void __iomem *)
91eebf40 TG	172	(PAGE_MASK & (unsigned long __force)addr);
bf5421c3 AK	173
	174	/* Use the vm area unlocked, assuming the caller
	175	ensures there isn't another iounmap for the same address
	176	in parallel. Reuse of the virtual address is prevented by
	177	leaving it in the global lists until we're done with it.
	178	cpa takes care of the direct mappings. */
	179	read_lock(&vmlist_lock);
	180	for (p = vmlist; p; p = p->next) {
	181	if (p->addr == addr)
	182	break;
	183	}
	184	read_unlock(&vmlist_lock);
	185
	186	if (!p) {
91eebf40	187	printk(KERN_ERR "iounmap: bad address %p\n", addr);
c23a4e96	188	dump_stack();
bf5421c3	189	return;
1da177e4 LT	190	}
1da177e4 LT	191
bf5421c3	192	/* Reset the direct mapping. Can block */
1da177e4	193	if ((p->flags >> 20) && p->phys_addr < virt_to_phys(high_memory) - 1) {
1da177e4	194	change_page_attr(virt_to_page(__va(p->phys_addr)),
9585116b	195	get_vm_area_size(p) >> PAGE_SHIFT,
1da177e4 LT	196	PAGE_KERNEL);
1da177e4 LT	197	global_flush_tlb();
91eebf40	198	}
bf5421c3 AK	199
	200	/* Finally remove it */
	201	o = remove_vm_area((void *)addr);
	202	BUG_ON(p != o \|\| o == NULL);
91eebf40	203	kfree(p);
1da177e4	204	}
129f6946	205	EXPORT_SYMBOL(iounmap);
1da177e4	206
d18d6d65 IM	207
	208	int __initdata early_ioremap_debug;
	209
	210	static int __init early_ioremap_debug_setup(char *str)
	211	{
	212	early_ioremap_debug = 1;
	213
793b24a2	214	return 0;
d18d6d65	215	}
793b24a2	216	early_param("early_ioremap_debug", early_ioremap_debug_setup);
d18d6d65	217
0947b2f3 HY	218	static __initdata int after_paging_init;
	219	static __initdata unsigned long bm_pte[1024]
	220	__attribute__((aligned(PAGE_SIZE)));
	221
beacfaac	222	static inline unsigned long * __init early_ioremap_pgd(unsigned long addr)
0947b2f3 HY	223	{
	224	return (unsigned long *)swapper_pg_dir + ((addr >> 22) & 1023);
	225	}
	226
beacfaac	227	static inline unsigned long * __init early_ioremap_pte(unsigned long addr)
0947b2f3 HY	228	{
	229	return bm_pte + ((addr >> PAGE_SHIFT) & 1023);
	230	}
	231
beacfaac	232	void __init early_ioremap_init(void)
0947b2f3 HY	233	{
	234	unsigned long *pgd;
	235
d18d6d65	236	if (early_ioremap_debug)
91eebf40	237	printk(KERN_DEBUG "early_ioremap_init()\n");
d18d6d65	238
beacfaac	239	pgd = early_ioremap_pgd(fix_to_virt(FIX_BTMAP_BEGIN));
0947b2f3 HY	240	*pgd = __pa(bm_pte) \| _PAGE_TABLE;
0947b2f3 HY	241	memset(bm_pte, 0, sizeof(bm_pte));
0e3a9549 IM	242	/*
	243	* The boot-ioremap range spans multiple pgds, for which
	244	* we are not prepared:
	245	*/
	246	if (pgd != early_ioremap_pgd(fix_to_virt(FIX_BTMAP_END))) {
	247	WARN_ON(1);
91eebf40 TG	248	printk(KERN_WARNING "pgd %p != %p\n",
	249	pgd, early_ioremap_pgd(fix_to_virt(FIX_BTMAP_END)));
	250	printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
	251	fix_to_virt(FIX_BTMAP_BEGIN));
	252	printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END): %08lx\n",
	253	fix_to_virt(FIX_BTMAP_END));
	254
	255	printk(KERN_WARNING "FIX_BTMAP_END: %d\n", FIX_BTMAP_END);
	256	printk(KERN_WARNING "FIX_BTMAP_BEGIN: %d\n",
	257	FIX_BTMAP_BEGIN);
0e3a9549	258	}
0947b2f3 HY	259	}
0947b2f3 HY	260
beacfaac	261	void __init early_ioremap_clear(void)
0947b2f3 HY	262	{
	263	unsigned long *pgd;
	264
d18d6d65	265	if (early_ioremap_debug)
91eebf40	266	printk(KERN_DEBUG "early_ioremap_clear()\n");
d18d6d65	267
beacfaac	268	pgd = early_ioremap_pgd(fix_to_virt(FIX_BTMAP_BEGIN));
0947b2f3 HY	269	*pgd = 0;
	270	__flush_tlb_all();
	271	}
	272
beacfaac	273	void __init early_ioremap_reset(void)
0947b2f3 HY	274	{
	275	enum fixed_addresses idx;
	276	unsigned long *pte, phys, addr;
	277
	278	after_paging_init = 1;
64a8f852	279	for (idx = FIX_BTMAP_BEGIN; idx >= FIX_BTMAP_END; idx--) {
0947b2f3	280	addr = fix_to_virt(idx);
beacfaac	281	pte = early_ioremap_pte(addr);
0947b2f3 HY	282	if (!*pte & _PAGE_PRESENT) {
	283	phys = *pte & PAGE_MASK;
	284	set_fixmap(idx, phys);
	285	}
	286	}
	287	}
	288
beacfaac	289	static void __init __early_set_fixmap(enum fixed_addresses idx,
0947b2f3 HY	290	unsigned long phys, pgprot_t flags)
	291	{
	292	unsigned long *pte, addr = __fix_to_virt(idx);
	293
	294	if (idx >= __end_of_fixed_addresses) {
	295	BUG();
	296	return;
	297	}
beacfaac	298	pte = early_ioremap_pte(addr);
0947b2f3 HY	299	if (pgprot_val(flags))
	300	*pte = (phys & PAGE_MASK) \| pgprot_val(flags);
	301	else
	302	*pte = 0;
	303	__flush_tlb_one(addr);
	304	}
	305
beacfaac	306	static inline void __init early_set_fixmap(enum fixed_addresses idx,
0947b2f3 HY	307	unsigned long phys)
	308	{
	309	if (after_paging_init)
	310	set_fixmap(idx, phys);
	311	else
beacfaac	312	__early_set_fixmap(idx, phys, PAGE_KERNEL);
0947b2f3 HY	313	}
0947b2f3 HY	314
beacfaac	315	static inline void __init early_clear_fixmap(enum fixed_addresses idx)
0947b2f3 HY	316	{
	317	if (after_paging_init)
	318	clear_fixmap(idx);
	319	else
beacfaac	320	__early_set_fixmap(idx, 0, __pgprot(0));
0947b2f3 HY	321	}
0947b2f3 HY	322
1b42f516 IM	323
	324	int __initdata early_ioremap_nested;
	325
d690b2af IM	326	static int __init check_early_ioremap_leak(void)
	327	{
	328	if (!early_ioremap_nested)
	329	return 0;
	330
	331	printk(KERN_WARNING
91eebf40 TG	332	"Debug warning: early ioremap leak of %d areas detected.\n",
91eebf40 TG	333	early_ioremap_nested);
d690b2af	334	printk(KERN_WARNING
91eebf40	335	"please boot with early_ioremap_debug and report the dmesg.\n");
d690b2af IM	336	WARN_ON(1);
	337
	338	return 1;
	339	}
	340	late_initcall(check_early_ioremap_leak);
	341
beacfaac	342	void __init *early_ioremap(unsigned long phys_addr, unsigned long size)
1da177e4 LT	343	{
1da177e4 LT	344	unsigned long offset, last_addr;
1b42f516 IM	345	unsigned int nrpages, nesting;
	346	enum fixed_addresses idx0, idx;
	347
	348	WARN_ON(system_state != SYSTEM_BOOTING);
	349
	350	nesting = early_ioremap_nested;
d18d6d65	351	if (early_ioremap_debug) {
91eebf40 TG	352	printk(KERN_DEBUG "early_ioremap(%08lx, %08lx) [%d] => ",
91eebf40 TG	353	phys_addr, size, nesting);
d18d6d65 IM	354	dump_stack();
d18d6d65 IM	355	}
1da177e4 LT	356
	357	/* Don't allow wraparound or zero size */
	358	last_addr = phys_addr + size - 1;
bd796ed0 IM	359	if (!size \|\| last_addr < phys_addr) {
bd796ed0 IM	360	WARN_ON(1);
1da177e4	361	return NULL;
bd796ed0	362	}
1da177e4	363
bd796ed0 IM	364	if (nesting >= FIX_BTMAPS_NESTING) {
bd796ed0 IM	365	WARN_ON(1);
1b42f516	366	return NULL;
bd796ed0	367	}
1b42f516	368	early_ioremap_nested++;
1da177e4 LT	369	/*
	370	* Mappings have to be page-aligned
	371	*/
	372	offset = phys_addr & ~PAGE_MASK;
	373	phys_addr &= PAGE_MASK;
	374	size = PAGE_ALIGN(last_addr) - phys_addr;
	375
	376	/*
	377	* Mappings have to fit in the FIX_BTMAP area.
	378	*/
	379	nrpages = size >> PAGE_SHIFT;
bd796ed0 IM	380	if (nrpages > NR_FIX_BTMAPS) {
bd796ed0 IM	381	WARN_ON(1);
1da177e4	382	return NULL;
bd796ed0	383	}
1da177e4 LT	384
	385	/*
	386	* Ok, go for it..
	387	*/
1b42f516 IM	388	idx0 = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*nesting;
1b42f516 IM	389	idx = idx0;
1da177e4	390	while (nrpages > 0) {
beacfaac	391	early_set_fixmap(idx, phys_addr);
1da177e4 LT	392	phys_addr += PAGE_SIZE;
	393	--idx;
	394	--nrpages;
	395	}
d18d6d65 IM	396	if (early_ioremap_debug)
d18d6d65 IM	397	printk(KERN_CONT "%08lx + %08lx\n", offset, fix_to_virt(idx0));
1b42f516	398
91eebf40	399	return (void *) (offset + fix_to_virt(idx0));
1da177e4 LT	400	}
1da177e4 LT	401
beacfaac	402	void __init early_iounmap(void *addr, unsigned long size)
1da177e4 LT	403	{
	404	unsigned long virt_addr;
	405	unsigned long offset;
	406	unsigned int nrpages;
	407	enum fixed_addresses idx;
1b42f516 IM	408	unsigned int nesting;
	409
	410	nesting = --early_ioremap_nested;
bd796ed0	411	WARN_ON(nesting < 0);
1da177e4	412
d18d6d65	413	if (early_ioremap_debug) {
91eebf40 TG	414	printk(KERN_DEBUG "early_iounmap(%p, %08lx) [%d]\n", addr,
91eebf40 TG	415	size, nesting);
d18d6d65 IM	416	dump_stack();
	417	}
	418
1da177e4	419	virt_addr = (unsigned long)addr;
bd796ed0 IM	420	if (virt_addr < fix_to_virt(FIX_BTMAP_BEGIN)) {
bd796ed0 IM	421	WARN_ON(1);
1da177e4	422	return;
bd796ed0	423	}
1da177e4 LT	424	offset = virt_addr & ~PAGE_MASK;
	425	nrpages = PAGE_ALIGN(offset + size - 1) >> PAGE_SHIFT;
	426
1b42f516	427	idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*nesting;
1da177e4	428	while (nrpages > 0) {
beacfaac	429	early_clear_fixmap(idx);
1da177e4 LT	430	--idx;
	431	--nrpages;
	432	}
	433	}
1b42f516 IM	434
	435	void __this_fixmap_does_not_exist(void)
	436	{
	437	WARN_ON(1);
	438	}