[deliverable/linux.git] / arch / powerpc / kernel / iomap.c

/*
 * ppc64 "iomap" interface implementation.
 *
 * (C) Copyright 2004 Linus Torvalds
 */
#include <linux/pci.h>
#include <linux/mm.h>
#include <linux/export.h>
#include <asm/io.h>
#include <asm/pci-bridge.h>

/*
 * Here comes the ppc64 implementation of the IOMAP 
 * interfaces.
 */
unsigned int ioread8(void __iomem *addr)
{
	return readb(addr);
}
unsigned int ioread16(void __iomem *addr)
{
	return readw(addr);
}
unsigned int ioread16be(void __iomem *addr)
{
	return readw_be(addr);
}
unsigned int ioread32(void __iomem *addr)
{
	return readl(addr);
}
unsigned int ioread32be(void __iomem *addr)
{
	return readl_be(addr);
}
EXPORT_SYMBOL(ioread8);
EXPORT_SYMBOL(ioread16);
EXPORT_SYMBOL(ioread16be);
EXPORT_SYMBOL(ioread32);
EXPORT_SYMBOL(ioread32be);

void iowrite8(u8 val, void __iomem *addr)
{
	writeb(val, addr);
}
void iowrite16(u16 val, void __iomem *addr)
{
	writew(val, addr);
}
void iowrite16be(u16 val, void __iomem *addr)
{
	writew_be(val, addr);
}
void iowrite32(u32 val, void __iomem *addr)
{
	writel(val, addr);
}
void iowrite32be(u32 val, void __iomem *addr)
{
	writel_be(val, addr);
}
EXPORT_SYMBOL(iowrite8);
EXPORT_SYMBOL(iowrite16);
EXPORT_SYMBOL(iowrite16be);
EXPORT_SYMBOL(iowrite32);
EXPORT_SYMBOL(iowrite32be);

/*
 * These are the "repeat read/write" functions. Note the
 * non-CPU byte order. We do things in "IO byteorder"
 * here.
 *
 * FIXME! We could make these do EEH handling if we really
 * wanted. Not clear if we do.
 */
void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
{
	readsb(addr, dst, count);
}
void ioread16_rep(void __iomem *addr, void *dst, unsigned long count)
{
	readsw(addr, dst, count);
}
void ioread32_rep(void __iomem *addr, void *dst, unsigned long count)
{
	readsl(addr, dst, count);
}
EXPORT_SYMBOL(ioread8_rep);
EXPORT_SYMBOL(ioread16_rep);
EXPORT_SYMBOL(ioread32_rep);

void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
{
	writesb(addr, src, count);
}
void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
{
	writesw(addr, src, count);
}
void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
{
	writesl(addr, src, count);
}
EXPORT_SYMBOL(iowrite8_rep);
EXPORT_SYMBOL(iowrite16_rep);
EXPORT_SYMBOL(iowrite32_rep);

void __iomem *ioport_map(unsigned long port, unsigned int len)
{
	return (void __iomem *) (port + _IO_BASE);
}

void ioport_unmap(void __iomem *addr)
{
	/* Nothing to do */
}
EXPORT_SYMBOL(ioport_map);
EXPORT_SYMBOL(ioport_unmap);

#ifdef CONFIG_PCI
void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
{
	if (isa_vaddr_is_ioport(addr))
		return;
	if (pcibios_vaddr_is_ioport(addr))
		return;
	iounmap(addr);
}

EXPORT_SYMBOL(pci_iounmap);
#endif /* CONFIG_PCI */
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* ppc64 "iomap" interface implementation.
	3	*
	4	* (C) Copyright 2004 Linus Torvalds
	5	*/
1da177e4 LT	6	#include <linux/pci.h>
1da177e4 LT	7	#include <linux/mm.h>
93087948	8	#include <linux/export.h>
1da177e4	9	#include <asm/io.h>
50747cb8	10	#include <asm/pci-bridge.h>
1da177e4 LT	11
	12	/*
	13	* Here comes the ppc64 implementation of the IOMAP
	14	* interfaces.
	15	*/
8943212c	16	unsigned int ioread8(void __iomem *addr)
1da177e4 LT	17	{
	18	return readb(addr);
	19	}
8943212c	20	unsigned int ioread16(void __iomem *addr)
1da177e4 LT	21	{
	22	return readw(addr);
	23	}
8943212c	24	unsigned int ioread16be(void __iomem *addr)
76637536	25	{
0eb57368	26	return readw_be(addr);
76637536	27	}
8943212c	28	unsigned int ioread32(void __iomem *addr)
1da177e4 LT	29	{
	30	return readl(addr);
	31	}
8943212c	32	unsigned int ioread32be(void __iomem *addr)
76637536	33	{
0eb57368	34	return readl_be(addr);
76637536	35	}
1da177e4 LT	36	EXPORT_SYMBOL(ioread8);
1da177e4 LT	37	EXPORT_SYMBOL(ioread16);
76637536	38	EXPORT_SYMBOL(ioread16be);
1da177e4	39	EXPORT_SYMBOL(ioread32);
76637536	40	EXPORT_SYMBOL(ioread32be);
1da177e4	41
8943212c	42	void iowrite8(u8 val, void __iomem *addr)
1da177e4 LT	43	{
	44	writeb(val, addr);
	45	}
8943212c	46	void iowrite16(u16 val, void __iomem *addr)
1da177e4 LT	47	{
	48	writew(val, addr);
	49	}
8943212c	50	void iowrite16be(u16 val, void __iomem *addr)
76637536	51	{
0eb57368	52	writew_be(val, addr);
76637536	53	}
8943212c	54	void iowrite32(u32 val, void __iomem *addr)
1da177e4 LT	55	{
	56	writel(val, addr);
	57	}
8943212c	58	void iowrite32be(u32 val, void __iomem *addr)
76637536	59	{
0eb57368	60	writel_be(val, addr);
76637536	61	}
1da177e4 LT	62	EXPORT_SYMBOL(iowrite8);
1da177e4 LT	63	EXPORT_SYMBOL(iowrite16);
76637536	64	EXPORT_SYMBOL(iowrite16be);
1da177e4	65	EXPORT_SYMBOL(iowrite32);
76637536	66	EXPORT_SYMBOL(iowrite32be);
1da177e4 LT	67
	68	/*
	69	* These are the "repeat read/write" functions. Note the
	70	* non-CPU byte order. We do things in "IO byteorder"
	71	* here.
	72	*
	73	* FIXME! We could make these do EEH handling if we really
	74	* wanted. Not clear if we do.
	75	*/
	76	void ioread8_rep(void __iomem addr, void dst, unsigned long count)
	77	{
0eb57368	78	readsb(addr, dst, count);
1da177e4 LT	79	}
	80	void ioread16_rep(void __iomem addr, void dst, unsigned long count)
	81	{
0eb57368	82	readsw(addr, dst, count);
1da177e4 LT	83	}
	84	void ioread32_rep(void __iomem addr, void dst, unsigned long count)
	85	{
0eb57368	86	readsl(addr, dst, count);
1da177e4 LT	87	}
	88	EXPORT_SYMBOL(ioread8_rep);
	89	EXPORT_SYMBOL(ioread16_rep);
	90	EXPORT_SYMBOL(ioread32_rep);
	91
	92	void iowrite8_rep(void __iomem addr, const void src, unsigned long count)
	93	{
0eb57368	94	writesb(addr, src, count);
1da177e4 LT	95	}
	96	void iowrite16_rep(void __iomem addr, const void src, unsigned long count)
	97	{
0eb57368	98	writesw(addr, src, count);
1da177e4 LT	99	}
	100	void iowrite32_rep(void __iomem addr, const void src, unsigned long count)
	101	{
0eb57368	102	writesl(addr, src, count);
1da177e4 LT	103	}
	104	EXPORT_SYMBOL(iowrite8_rep);
	105	EXPORT_SYMBOL(iowrite16_rep);
	106	EXPORT_SYMBOL(iowrite32_rep);
	107
	108	void __iomem *ioport_map(unsigned long port, unsigned int len)
	109	{
68a64357	110	return (void __iomem *) (port + _IO_BASE);
1da177e4 LT	111	}
	112
	113	void ioport_unmap(void __iomem *addr)
	114	{
	115	/* Nothing to do */
	116	}
	117	EXPORT_SYMBOL(ioport_map);
	118	EXPORT_SYMBOL(ioport_unmap);
	119
81210c20	120	#ifdef CONFIG_PCI
1da177e4 LT	121	void pci_iounmap(struct pci_dev dev, void __iomem addr)
1da177e4 LT	122	{
50747cb8 BH	123	if (isa_vaddr_is_ioport(addr))
	124	return;
	125	if (pcibios_vaddr_is_ioport(addr))
	126	return;
	127	iounmap(addr);
1da177e4	128	}
50747cb8	129
1da177e4	130	EXPORT_SYMBOL(pci_iounmap);
a85fe3fc	131	#endif /* CONFIG_PCI */