1/* Generic I/O port emulation, based on MN10300 code 2 * 3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public Licence 8 * as published by the Free Software Foundation; either version 9 * 2 of the Licence, or (at your option) any later version. 10 */ 11#ifndef __ASM_GENERIC_IO_H 12#define __ASM_GENERIC_IO_H 13 14#include <asm/page.h> /* I/O is all done through memory accesses */ 15#include <asm/cacheflush.h> 16#include <linux/types.h> 17 18#ifdef CONFIG_GENERIC_IOMAP 19#include <asm-generic/iomap.h> 20#endif 21 22#define mmiowb() do {} while (0) 23 24/*****************************************************************************/ 25/* 26 * readX/writeX() are used to access memory mapped devices. On some 27 * architectures the memory mapped IO stuff needs to be accessed 28 * differently. On the simple architectures, we just read/write the 29 * memory location directly. 30 */ 31static inline u8 __raw_readb(const volatile void __iomem *addr) 32{ 33 return *(const volatile u8 __force *) addr; 34} 35 36static inline u16 __raw_readw(const volatile void __iomem *addr) 37{ 38 return *(const volatile u16 __force *) addr; 39} 40 41static inline u32 __raw_readl(const volatile void __iomem *addr) 42{ 43 return *(const volatile u32 __force *) addr; 44} 45 46#define readb __raw_readb 47#define readw(addr) __le16_to_cpu(__raw_readw(addr)) 48#define readl(addr) __le32_to_cpu(__raw_readl(addr)) 49 50static inline void __raw_writeb(u8 b, volatile void __iomem *addr) 51{ 52 *(volatile u8 __force *) addr = b; 53} 54 55static inline void __raw_writew(u16 b, volatile void __iomem *addr) 56{ 57 *(volatile u16 __force *) addr = b; 58} 59 60static inline void __raw_writel(u32 b, volatile void __iomem *addr) 61{ 62 *(volatile u32 __force *) addr = b; 63} 64 65#define writeb __raw_writeb 66#define writew(b,addr) __raw_writew(__cpu_to_le16(b),addr) 67#define writel(b,addr) __raw_writel(__cpu_to_le32(b),addr) 68 69#ifdef CONFIG_64BIT 70static inline u64 __raw_readq(const volatile void __iomem *addr) 71{ 72 return *(const volatile u64 __force *) addr; 73} 74#define readq(addr) __le64_to_cpu(__raw_readq(addr)) 75 76static inline void __raw_writeq(u64 b, volatile void __iomem *addr) 77{ 78 *(volatile u64 __force *) addr = b; 79} 80#define writeq(b,addr) __raw_writeq(__cpu_to_le64(b),addr) 81#endif 82 83/*****************************************************************************/ 84/* 85 * traditional input/output functions 86 */ 87 88static inline u8 inb(unsigned long addr) 89{ 90 return readb((volatile void __iomem *) addr); 91} 92 93static inline u16 inw(unsigned long addr) 94{ 95 return readw((volatile void __iomem *) addr); 96} 97 98static inline u32 inl(unsigned long addr) 99{ 100 return readl((volatile void __iomem *) addr); 101} 102 103static inline void outb(u8 b, unsigned long addr) 104{ 105 writeb(b, (volatile void __iomem *) addr); 106} 107 108static inline void outw(u16 b, unsigned long addr) 109{ 110 writew(b, (volatile void __iomem *) addr); 111} 112 113static inline void outl(u32 b, unsigned long addr) 114{ 115 writel(b, (volatile void __iomem *) addr); 116} 117 118#define inb_p(addr) inb(addr) 119#define inw_p(addr) inw(addr) 120#define inl_p(addr) inl(addr) 121#define outb_p(x, addr) outb((x), (addr)) 122#define outw_p(x, addr) outw((x), (addr)) 123#define outl_p(x, addr) outl((x), (addr)) 124 125static inline void insb(unsigned long addr, void *buffer, int count) 126{ 127 if (count) { 128 u8 *buf = buffer; 129 do { 130 u8 x = inb(addr); 131 *buf++ = x; 132 } while (--count); 133 } 134} 135 136static inline void insw(unsigned long addr, void *buffer, int count) 137{ 138 if (count) { 139 u16 *buf = buffer; 140 do { 141 u16 x = inw(addr); 142 *buf++ = x; 143 } while (--count); 144 } 145} 146 147static inline void insl(unsigned long addr, void *buffer, int count) 148{ 149 if (count) { 150 u32 *buf = buffer; 151 do { 152 u32 x = inl(addr); 153 *buf++ = x; 154 } while (--count); 155 } 156} 157 158static inline void outsb(unsigned long addr, const void *buffer, int count) 159{ 160 if (count) { 161 const u8 *buf = buffer; 162 do { 163 outb(*buf++, addr); 164 } while (--count); 165 } 166} 167 168static inline void outsw(unsigned long addr, const void *buffer, int count) 169{ 170 if (count) { 171 const u16 *buf = buffer; 172 do { 173 outw(*buf++, addr); 174 } while (--count); 175 } 176} 177 178static inline void outsl(unsigned long addr, const void *buffer, int count) 179{ 180 if (count) { 181 const u32 *buf = buffer; 182 do { 183 outl(*buf++, addr); 184 } while (--count); 185 } 186} 187 188#ifndef CONFIG_GENERIC_IOMAP 189#define ioread8(addr) readb(addr) 190#define ioread16(addr) readw(addr) 191#define ioread16be(addr) be16_to_cpu(ioread16(addr)) 192#define ioread32(addr) readl(addr) 193#define ioread32be(addr) be32_to_cpu(ioread32(addr)) 194 195#define iowrite8(v, addr) writeb((v), (addr)) 196#define iowrite16(v, addr) writew((v), (addr)) 197#define iowrite16be(v, addr) iowrite16(be16_to_cpu(v), (addr)) 198#define iowrite32(v, addr) writel((v), (addr)) 199#define iowrite32be(v, addr) iowrite32(be32_to_cpu(v), (addr)) 200 201#define ioread8_rep(p, dst, count) \ 202 insb((unsigned long) (p), (dst), (count)) 203#define ioread16_rep(p, dst, count) \ 204 insw((unsigned long) (p), (dst), (count)) 205#define ioread32_rep(p, dst, count) \ 206 insl((unsigned long) (p), (dst), (count)) 207 208#define iowrite8_rep(p, src, count) \ 209 outsb((unsigned long) (p), (src), (count)) 210#define iowrite16_rep(p, src, count) \ 211 outsw((unsigned long) (p), (src), (count)) 212#define iowrite32_rep(p, src, count) \ 213 outsl((unsigned long) (p), (src), (count)) 214#endif /* CONFIG_GENERIC_IOMAP */ 215 216 217#define IO_SPACE_LIMIT 0xffffffff 218 219#ifdef __KERNEL__ 220 221#include <linux/vmalloc.h> 222#define __io_virt(x) ((void __force *) (x)) 223 224#ifndef CONFIG_GENERIC_IOMAP 225/* Create a virtual mapping cookie for a PCI BAR (memory or IO) */ 226struct pci_dev; 227extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max); 228static inline void pci_iounmap(struct pci_dev *dev, void __iomem *p) 229{ 230} 231#endif /* CONFIG_GENERIC_IOMAP */ 232 233/* 234 * Change virtual addresses to physical addresses and vv. 235 * These are pretty trivial 236 */ 237static inline unsigned long virt_to_phys(volatile void *address) 238{ 239 return __pa((unsigned long)address); 240} 241 242static inline void *phys_to_virt(unsigned long address) 243{ 244 return __va(address); 245} 246 247/* 248 * Change "struct page" to physical address. 249 */ 250static inline void __iomem *ioremap(phys_addr_t offset, unsigned long size) 251{ 252 return (void __iomem*) (unsigned long)offset; 253} 254 255#define __ioremap(offset, size, flags) ioremap(offset, size) 256 257#ifndef ioremap_nocache 258#define ioremap_nocache ioremap 259#endif 260 261#ifndef ioremap_wc 262#define ioremap_wc ioremap_nocache 263#endif 264 265static inline void iounmap(void *addr) 266{ 267} 268 269#ifndef CONFIG_GENERIC_IOMAP 270static inline void __iomem *ioport_map(unsigned long port, unsigned int nr) 271{ 272 return (void __iomem *) port; 273} 274 275static inline void ioport_unmap(void __iomem *p) 276{ 277} 278#else /* CONFIG_GENERIC_IOMAP */ 279extern void __iomem *ioport_map(unsigned long port, unsigned int nr); 280extern void ioport_unmap(void __iomem *p); 281#endif /* CONFIG_GENERIC_IOMAP */ 282 283#define xlate_dev_kmem_ptr(p) p 284#define xlate_dev_mem_ptr(p) ((void *) (p)) 285 286#ifndef virt_to_bus 287static inline unsigned long virt_to_bus(volatile void *address) 288{ 289 return ((unsigned long) address); 290} 291 292static inline void *bus_to_virt(unsigned long address) 293{ 294 return (void *) address; 295} 296#endif 297 298#define memset_io(a, b, c) memset(__io_virt(a), (b), (c)) 299#define memcpy_fromio(a, b, c) memcpy((a), __io_virt(b), (c)) 300#define memcpy_toio(a, b, c) memcpy(__io_virt(a), (b), (c)) 301 302#endif /* __KERNEL__ */ 303 304#endif /* __ASM_GENERIC_IO_H */ 305