arch/mn10300/include/asm/io.h

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