qemu/roms/openbios/include/arch/ppc/io.h

   1 #ifndef _ASM_IO_H
   2 #define _ASM_IO_H
   3
   4 #include "asm/types.h"
   5
   6 #define NO_QEMU_PROTOS
   7 #include "arch/common/fw_cfg.h"
   8
   9 extern char _start, _end;
  10 extern unsigned long virt_offset;
  11
  12 #define phys_to_virt(phys) ((void *) ((unsigned long) (phys) - virt_offset))
  13 #define virt_to_phys(virt) ((unsigned long) (virt) + virt_offset)
  14
  15 #ifndef BOOTSTRAP
  16
  17 extern unsigned long isa_io_base;
  18
  19 /*
  20  * 8, 16 and 32 bit, big and little endian I/O operations, with barrier.
  21  */
  22 static inline uint8_t in_8(volatile uint8_t *addr)
  23 {
  24         uint8_t ret;
  25
  26         __asm__ __volatile__("lbz%U1%X1 %0,%1; eieio":"=r"(ret):"m"(*addr));
  27         return ret;
  28 }
  29
  30 static inline void out_8(volatile uint8_t *addr, uint8_t val)
  31 {
  32         __asm__ __volatile__("stb%U0%X0 %1,%0; eieio":"=m"(*addr):"r"(val));
  33 }
  34
  35 static inline uint16_t in_le16(volatile uint16_t *addr)
  36 {
  37         uint16_t ret;
  38
  39         __asm__ __volatile__("lhbrx %0,0,%1; eieio":"=r"(ret):
  40                              "r"(addr), "m"(*addr));
  41         return ret;
  42 }
  43
  44 static inline uint16_t in_be16(volatile uint16_t *addr)
  45 {
  46         uint16_t ret;
  47
  48         __asm__ __volatile__("lhz%U1%X1 %0,%1; eieio":"=r"(ret):"m"(*addr));
  49         return ret;
  50 }
  51
  52 static inline void out_le16(volatile uint16_t *addr, uint16_t val)
  53 {
  54         __asm__ __volatile__("sthbrx %1,0,%2; eieio":"=m"(*addr):"r"(val),
  55                              "r"(addr));
  56 }
  57
  58 static inline void out_be16(volatile uint16_t *addr, uint16_t val)
  59 {
  60         __asm__ __volatile__("sth%U0%X0 %1,%0; eieio":"=m"(*addr):"r"(val));
  61 }
  62
  63 static inline uint32_t in_le32(volatile uint32_t *addr)
  64 {
  65         uint32_t ret;
  66
  67         __asm__ __volatile__("lwbrx %0,0,%1; eieio":"=r"(ret):
  68                              "r"(addr), "m"(*addr));
  69         return ret;
  70 }
  71
  72 static inline uint32_t in_be32(volatile uint32_t *addr)
  73 {
  74         uint32_t ret;
  75
  76         __asm__ __volatile__("lwz%U1%X1 %0,%1; eieio":"=r"(ret):"m"(*addr));
  77         return ret;
  78 }
  79
  80 static inline void out_le32(volatile uint32_t *addr, uint32_t val)
  81 {
  82         __asm__ __volatile__("stwbrx %1,0,%2; eieio":"=m"(*addr):"r"(val),
  83                              "r"(addr));
  84 }
  85
  86 static inline void out_be32(volatile unsigned *addr, uint32_t val)
  87 {
  88         __asm__ __volatile__("stw%U0%X0 %1,%0; eieio":"=m"(*addr):"r"(val));
  89 }
  90
  91 static inline void _insw_ns(volatile uint16_t * port, void *buf, int ns)
  92 {
  93         uint16_t *b = (uint16_t *) buf;
  94
  95         while (ns > 0) {
  96                 *b++ = in_le16(port);
  97                 ns--;
  98         }
  99 }
 100
 101 static inline void _outsw_ns(volatile uint16_t * port, const void *buf,
 102                              int ns)
 103 {
 104         uint16_t *b = (uint16_t *) buf;
 105
 106         while (ns > 0) {
 107                 out_le16(port, *b++);
 108                 ns--;
 109         }
 110 }
 111
 112 static inline void _insw(volatile uint16_t * port, void *buf, int ns)
 113 {
 114         uint16_t *b = (uint16_t *) buf;
 115
 116         while (ns > 0) {
 117                 *b++ = in_be16(port);
 118                 ns--;
 119         }
 120 }
 121
 122 static inline void _outsw(volatile uint16_t * port, const void *buf,
 123                           int ns)
 124 {
 125         uint16_t *b = (uint16_t *) buf;
 126
 127         while (ns > 0) {
 128                 out_be16(port, *b++);
 129                 ns--;
 130         }
 131 }
 132
 133
 134 /*
 135  * The insw/outsw/insl/outsl functions don't do byte-swapping.
 136  * They are only used in practice for transferring buffers which
 137  * are arrays of bytes, and byte-swapping is not appropriate in
 138  * that case.  - paulus
 139  */
 140
 141 static inline void insw(uint16_t port, void *buf, int ns)
 142 {
 143         _insw((uint16_t *)(port + isa_io_base), buf, ns);
 144 }
 145
 146 static inline void outsw(uint16_t port, void *buf, int ns)
 147 {
 148         _outsw((uint16_t *)(port + isa_io_base), buf, ns);
 149 }
 150
 151
 152 static inline uint8_t inb(uint16_t port)
 153 {
 154         return in_8((uint8_t *)(port + isa_io_base));
 155 }
 156
 157 static inline void outb(uint8_t val, uint16_t port)
 158 {
 159         out_8((uint8_t *)(port + isa_io_base), val);
 160 }
 161
 162 static inline uint16_t inw(uint16_t port)
 163 {
 164         return in_le16((uint16_t *)(port + isa_io_base));
 165 }
 166
 167 static inline void outw(uint16_t val, uint16_t port)
 168 {
 169         out_le16((uint16_t *)(port + isa_io_base), val);
 170 }
 171
 172 static inline uint32_t inl(uint16_t port)
 173 {
 174         return in_le32((uint32_t *)(port + isa_io_base));
 175 }
 176
 177 static inline void outl(uint32_t val, uint16_t port)
 178 {
 179         out_le32((uint32_t *)(port + isa_io_base), val);
 180 }
 181
 182 #else /* BOOTSTRAP */
 183 #ifdef FCOMPILER
 184 #define inb(reg) ((u8)0xff)
 185 #define inw(reg) ((u16)0xffff)
 186 #define inl(reg) ((u32)0xffffffff)
 187 #define outb(reg, val) do{} while(0)
 188 #define outw(reg, val) do{} while(0)
 189 #define outl(reg, val) do{} while(0)
 190 #else
 191 extern u8 inb(u32 reg);
 192 extern u16 inw(u32 reg);
 193 extern u32 inl(u32 reg);
 194 extern void insw(u32 reg, void *addr, unsigned long count);
 195 extern void outb(u32 reg, u8 val);
 196 extern void outw(u32 reg, u16 val);
 197 extern void outl(u32 reg, u32 val);
 198 extern void outsw(u32 reg, const void *addr, unsigned long count);
 199 #endif
 200 #endif
 201
 202 #if defined(CONFIG_QEMU)
 203 #define FW_CFG_ARCH_WIDTH        (FW_CFG_ARCH_LOCAL + 0x00)
 204 #define FW_CFG_ARCH_HEIGHT       (FW_CFG_ARCH_LOCAL + 0x01)
 205 #define FW_CFG_ARCH_DEPTH        (FW_CFG_ARCH_LOCAL + 0x02)
 206 #endif
 207
 208 #endif /* _ASM_IO_H */