![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / include / arch / ppc|
Return to io.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / include / arch / ppc |
1.1 root 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 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.