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