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 */ 31 static inline u8 __raw_readb(const volatile void __iomem *addr) 32 { 33 return *(const volatile u8 __force *) addr; 34 } 35 36 static inline u16 __raw_readw(const volatile void __iomem *addr) 37 { 38 return *(const volatile u16 __force *) addr; 39 } 40 41 static 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 50 static inline void __raw_writeb(u8 b, volatile void __iomem *addr) 51 { 52 *(volatile u8 __force *) addr = b; 53 } 54 55 static inline void __raw_writew(u16 b, volatile void __iomem *addr) 56 { 57 *(volatile u16 __force *) addr = b; 58 } 59 60 static 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 70 static 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 76 static 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 88 static inline u8 inb(unsigned long addr) 89 { 90 return readb((volatile void __iomem *) addr); 91 } 92 93 static inline u16 inw(unsigned long addr) 94 { 95 return readw((volatile void __iomem *) addr); 96 } 97 98 static inline u32 inl(unsigned long addr) 99 { 100 return readl((volatile void __iomem *) addr); 101 } 102 103 static inline void outb(u8 b, unsigned long addr) 104 { 105 writeb(b, (volatile void __iomem *) addr); 106 } 107 108 static inline void outw(u16 b, unsigned long addr) 109 { 110 writew(b, (volatile void __iomem *) addr); 111 } 112 113 static 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 125 static 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 136 static 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 147 static 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 158 static 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 168 static 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 178 static 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) */ 226 struct pci_dev; 227 extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max); 228 static 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 */ 237 static inline unsigned long virt_to_phys(volatile void *address) 238 { 239 return __pa((unsigned long)address); 240 } 241 242 static inline void *phys_to_virt(unsigned long address) 243 { 244 return __va(address); 245 } 246 247 /* 248 * Change "struct page" to physical address. 249 */ 250 static 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 265 static inline void iounmap(void *addr) 266 { 267 } 268 269 #ifndef CONFIG_GENERIC_IOMAP 270 static inline void __iomem *ioport_map(unsigned long port, unsigned int nr) 271 { 272 return (void __iomem *) port; 273 } 274 275 static inline void ioport_unmap(void __iomem *p) 276 { 277 } 278 #else /* CONFIG_GENERIC_IOMAP */ 279 extern void __iomem *ioport_map(unsigned long port, unsigned int nr); 280 extern 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 287 static inline unsigned long virt_to_bus(volatile void *address) 288 { 289 return ((unsigned long) address); 290 } 291 292 static 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