1/* MN10300 I/O port emulation and memory-mapped I/O 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_IO_H 12#define _ASM_IO_H 13 14#include <asm/page.h> /* I/O is all done through memory accesses */ 15#include <asm/cpu-regs.h> 16#include <asm/cacheflush.h> 17 18#define mmiowb() do {} while (0) 19 20/*****************************************************************************/ 21/* 22 * readX/writeX() are used to access memory mapped devices. On some 23 * architectures the memory mapped IO stuff needs to be accessed 24 * differently. On the x86 architecture, we just read/write the 25 * memory location directly. 26 */ 27static inline u8 readb(const volatile void __iomem *addr) 28{ 29 return *(const volatile u8 *) addr; 30} 31 32static inline u16 readw(const volatile void __iomem *addr) 33{ 34 return *(const volatile u16 *) addr; 35} 36 37static inline u32 readl(const volatile void __iomem *addr) 38{ 39 return *(const volatile u32 *) addr; 40} 41 42#define __raw_readb readb 43#define __raw_readw readw 44#define __raw_readl readl 45 46#define readb_relaxed readb 47#define readw_relaxed readw 48#define readl_relaxed readl 49 50static inline void writeb(u8 b, volatile void __iomem *addr) 51{ 52 *(volatile u8 *) addr = b; 53} 54 55static inline void writew(u16 b, volatile void __iomem *addr) 56{ 57 *(volatile u16 *) addr = b; 58} 59 60static inline void writel(u32 b, volatile void __iomem *addr) 61{ 62 *(volatile u32 *) addr = b; 63} 64 65#define __raw_writeb writeb 66#define __raw_writew writew 67#define __raw_writel writel 68 69/*****************************************************************************/ 70/* 71 * traditional input/output functions 72 */ 73static inline u8 inb_local(unsigned long addr) 74{ 75 return readb((volatile void __iomem *) addr); 76} 77 78static inline void outb_local(u8 b, unsigned long addr) 79{ 80 return writeb(b, (volatile void __iomem *) addr); 81} 82 83static inline u8 inb(unsigned long addr) 84{ 85 return readb((volatile void __iomem *) addr); 86} 87 88static inline u16 inw(unsigned long addr) 89{ 90 return readw((volatile void __iomem *) addr); 91} 92 93static inline u32 inl(unsigned long addr) 94{ 95 return readl((volatile void __iomem *) addr); 96} 97 98static inline void outb(u8 b, unsigned long addr) 99{ 100 return writeb(b, (volatile void __iomem *) addr); 101} 102 103static inline void outw(u16 b, unsigned long addr) 104{ 105 return writew(b, (volatile void __iomem *) addr); 106} 107 108static inline void outl(u32 b, unsigned long addr) 109{ 110 return writel(b, (volatile void __iomem *) addr); 111} 112 113#define inb_p(addr) inb(addr) 114#define inw_p(addr) inw(addr) 115#define inl_p(addr) inl(addr) 116#define outb_p(x, addr) outb((x), (addr)) 117#define outw_p(x, addr) outw((x), (addr)) 118#define outl_p(x, addr) outl((x), (addr)) 119 120static inline void insb(unsigned long addr, void *buffer, int count) 121{ 122 if (count) { 123 u8 *buf = buffer; 124 do { 125 u8 x = inb(addr); 126 *buf++ = x; 127 } while (--count); 128 } 129} 130 131static inline void insw(unsigned long addr, void *buffer, int count) 132{ 133 if (count) { 134 u16 *buf = buffer; 135 do { 136 u16 x = inw(addr); 137 *buf++ = x; 138 } while (--count); 139 } 140} 141 142static inline void insl(unsigned long addr, void *buffer, int count) 143{ 144 if (count) { 145 u32 *buf = buffer; 146 do { 147 u32 x = inl(addr); 148 *buf++ = x; 149 } while (--count); 150 } 151} 152 153static inline void outsb(unsigned long addr, const void *buffer, int count) 154{ 155 if (count) { 156 const u8 *buf = buffer; 157 do { 158 outb(*buf++, addr); 159 } while (--count); 160 } 161} 162 163static inline void outsw(unsigned long addr, const void *buffer, int count) 164{ 165 if (count) { 166 const u16 *buf = buffer; 167 do { 168 outw(*buf++, addr); 169 } while (--count); 170 } 171} 172 173extern void __outsl(unsigned long addr, const void *buffer, int count); 174static inline void outsl(unsigned long addr, const void *buffer, int count) 175{ 176 if ((unsigned long) buffer & 0x3) 177 return __outsl(addr, buffer, count); 178 179 if (count) { 180 const u32 *buf = buffer; 181 do { 182 outl(*buf++, addr); 183 } while (--count); 184 } 185} 186 187#define ioread8(addr) readb(addr) 188#define ioread16(addr) readw(addr) 189#define ioread32(addr) readl(addr) 190 191#define iowrite8(v, addr) writeb((v), (addr)) 192#define iowrite16(v, addr) writew((v), (addr)) 193#define iowrite32(v, addr) writel((v), (addr)) 194 195#define ioread8_rep(p, dst, count) \ 196 insb((unsigned long) (p), (dst), (count)) 197#define ioread16_rep(p, dst, count) \ 198 insw((unsigned long) (p), (dst), (count)) 199#define ioread32_rep(p, dst, count) \ 200 insl((unsigned long) (p), (dst), (count)) 201 202#define iowrite8_rep(p, src, count) \ 203 outsb((unsigned long) (p), (src), (count)) 204#define iowrite16_rep(p, src, count) \ 205 outsw((unsigned long) (p), (src), (count)) 206#define iowrite32_rep(p, src, count) \ 207 outsl((unsigned long) (p), (src), (count)) 208 209 210#define IO_SPACE_LIMIT 0xffffffff 211 212#ifdef __KERNEL__ 213 214#include <linux/vmalloc.h> 215#define __io_virt(x) ((void *) (x)) 216 217/* Create a virtual mapping cookie for a PCI BAR (memory or IO) */ 218struct pci_dev; 219extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max); 220static inline void pci_iounmap(struct pci_dev *dev, void __iomem *p) 221{ 222} 223 224/* 225 * Change virtual addresses to physical addresses and vv. 226 * These are pretty trivial 227 */ 228static inline unsigned long virt_to_phys(volatile void *address) 229{ 230 return __pa(address); 231} 232 233static inline void *phys_to_virt(unsigned long address) 234{ 235 return __va(address); 236} 237 238/* 239 * Change "struct page" to physical address. 240 */ 241static inline void *__ioremap(unsigned long offset, unsigned long size, 242 unsigned long flags) 243{ 244 return (void *) offset; 245} 246 247static inline void *ioremap(unsigned long offset, unsigned long size) 248{ 249 return (void *) offset; 250} 251 252/* 253 * This one maps high address device memory and turns off caching for that 254 * area. it's useful if some control registers are in such an area and write 255 * combining or read caching is not desirable: 256 */ 257static inline void *ioremap_nocache(unsigned long offset, unsigned long size) 258{ 259 return (void *) (offset | 0x20000000); 260} 261 262#define ioremap_wc ioremap_nocache 263 264static inline void iounmap(void *addr) 265{ 266} 267 268static inline void __iomem *ioport_map(unsigned long port, unsigned int nr) 269{ 270 return (void __iomem *) port; 271} 272 273static inline void ioport_unmap(void __iomem *p) 274{ 275} 276 277#define xlate_dev_kmem_ptr(p) ((void *) (p)) 278#define xlate_dev_mem_ptr(p) ((void *) (p)) 279 280/* 281 * PCI bus iomem addresses must be in the region 0x80000000-0x9fffffff 282 */ 283static inline unsigned long virt_to_bus(volatile void *address) 284{ 285 return ((unsigned long) address) & ~0x20000000; 286} 287 288static inline void *bus_to_virt(unsigned long address) 289{ 290 return (void *) address; 291} 292 293#define page_to_bus page_to_phys 294 295#define memset_io(a, b, c) memset(__io_virt(a), (b), (c)) 296#define memcpy_fromio(a, b, c) memcpy((a), __io_virt(b), (c)) 297#define memcpy_toio(a, b, c) memcpy(__io_virt(a), (b), (c)) 298 299#endif /* __KERNEL__ */ 300 301#endif /* _ASM_IO_H */ 302