![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to x86io.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / usr / include.78 / sys|
Return to x86io.h CVS log | Up to [MW Coherent from dump] / coherent / f / usr / include.78 / sys |
1.1 root 1: #ifndef __SYS_X86IO_H__
2: #define __SYS_X86IO_H__
3:
4: /*
5: * The system V DDI/DKI for Intel processors defines a C-language interface to
6: * the machine I/O instructions available through <sys/types.h>.
7: *
8: * For simplicity, this has been factored out into a separate file for this
9: * implementation, and <sys/types.h> pulls this file in.
10: */
11: /*
12: *-IMPORTS:
13: * <sys/ccompat.h>
14: * __EXTERN_C_BEGIN__
15: * __EXTERN_C_END__
16: * __PROTO ()
17: * __NON_ISO ()
18: * __INLINE__
19: * <sys/xdebug.h>
20: * __LOCAL__
21: * <sys/types.h>
22: * uchar_t
23: * ushort_t
24: * ulong_t
25: */
26:
27: #include <sys/ccompat.h>
28: #include <sys/xdebug.h>
29: #include <sys/v_types.h>
30:
31:
32: /*
33: * Get these into a useful form in a similar manner to the way the spl... ()
34: * functions are defined in <sys/inline.h>
35: */
36:
37: #if defined (__GNUC__) && defined (i386) /* 80386 with GNU CC */
38:
39:
40: /*
41: * Note that the definitions for the string-input instructions assume that
42: * ES: is equivalent to DS:.
43: */
44:
45: __LOCAL__ __INLINE__ uchar_t __inb (int _port) {
46: uchar_t _result;
47: __NON_ISO (asm) volatile ("in %1,%0" :
48: "=a" (_result) : "d" ((ushort_t) _port));
49: return _result;
50: }
51:
52: __LOCAL__ __INLINE__ ulong_t __inl (int _port) {
53: ulong_t _result;
54: __NON_ISO (asm) volatile ("in %1,%0" :
55: "=a" (_result) : "d" ((ushort_t) _port));
56: return _result;
57: }
58:
59: __LOCAL__ __INLINE__ ushort_t __inw (int _port) {
60: ushort_t _result;
61: __NON_ISO (asm) volatile ("in %1,%0" :
62: "=a" (_result) : "d" ((ushort_t) _port));
63: return _result;
64: }
65:
66: __LOCAL__ __INLINE__ void __outb (int _port, uchar_t value) {
67: __NON_ISO (asm) volatile ("out %1,%0" : :
68: "d" ((ushort_t) _port), "a" (value));
69: }
70:
71: __LOCAL__ __INLINE__ void __outl (int _port, ulong_t value) {
72: __NON_ISO (asm) volatile ("out %1,%0" : :
73: "d" ((ushort_t) _port), "a" (value));
74: }
75:
76: __LOCAL__ __INLINE__ void __outw (int _port, ushort_t value) {
77: __NON_ISO (asm) volatile ("out %1,%0" : :
78: "d" ((ushort_t) _port), "a" (value));
79: }
80:
81: __LOCAL__ __INLINE__ void __repinsb (int _port, uchar_t * _addr, int _cnt) {
82: __NON_ISO (asm) volatile ("mov %1,%%edi;rep;insb" : :
83: "d" ((ushort_t) _port), "g" (_addr),
84: "c" (_cnt) : "di");
85: }
86:
87: __LOCAL__ __INLINE__ void __repinsd (int _port, ulong_t * _addr, int _cnt) {
88: __NON_ISO (asm) volatile ("mov %1,%%edi;rep;insl" : :
89: "d" ((ushort_t) _port), "g" (_addr),
90: "c" (_cnt) : "di");
91: }
92:
93: __LOCAL__ __INLINE__ void __repinsw (int _port, ushort_t * _addr, int _cnt) {
94: __NON_ISO (asm) volatile ("mov %1,%%edi;rep;insw" : :
95: "d" ((ushort_t) _port), "g" (_addr),
96: "c" (_cnt) : "di");
97: }
98:
99: __LOCAL__ __INLINE__ void __repoutsb (int _port, uchar_t * _addr, int _cnt) {
100: __NON_ISO (asm) volatile ("mov %1,%%esi;rep;outsb" : :
101: "d" ((ushort_t) _port), "g" (_addr),
102: "c" (_cnt) : "si");
103: }
104:
105: __LOCAL__ __INLINE__ void __repoutsd (int _port, ulong_t * _addr, int _cnt) {
106: __NON_ISO (asm) volatile ("movl %1,%%esi;rep;outsl" : :
107: "d" ((ushort_t) _port), "g" (_addr),
108: "c" (_cnt) : "si");
109: }
110:
111: __LOCAL__ __INLINE__ void __repoutsw (int _port, ushort_t * _addr, int _cnt) {
112: __NON_ISO (asm) volatile ("movl %1,%%esi;rep;outsw" : :
113: "d" ((ushort_t) _port), "g" (_addr),
114: "c" (_cnt) : "si");
115: }
116:
117: #define __FORWARD_inb__
118: #define __FORWARD_inl__
119: #define __FORWARD_inw__
120: #define __FORWARD_outb__
121: #define __FORWARD_outl__
122: #define __FORWARD_outw__
123: #define __FORWARD_repinsb__
124: #define __FORWARD_repinsd__
125: #define __FORWARD_repinsw__
126: #define __FORWARD_repoutsb__
127: #define __FORWARD_repoutsd__
128: #define __FORWARD_repoutsw__
129:
130: #elif defined (__BORLANDC__)
131:
132: /*lint +fva *//* __emit__ () is truly varadic */
133: void __emit__ (__ANY_ARGS__);
134: /*lint -fva */
135:
136: /*
137: * Note the use of the 0x66 operand-size override prefix below, which is built
138: * on the assumption that Borland generates 16-bit code segments.
139: */
140:
141: #define __REP__ 0xF3 /* repeat-prefix */
142:
143: #define __INB__ 0xEC
144: #define __INW__ 0xED
145: #define __INL__ 0x66, __INW__ /* size-override for 32-bit form */
146:
147: #define __OUTB__ 0xEE
148: #define __OUTW__ 0xEF
149: #define __OUTL__ 0x66, __OUTW__ /* size-override for 32-bit form */
150:
151: #define __INSB__ 0x6C
152: #define __INSW__ 0x6D
153: #define __INSL__ 0x65, __INSW__
154:
155: #define __OUTSB__ 0x6E
156: #define __OUTSW__ 0x6F /* word/long depending on CS: */
157: #define __OUTSL__ 0x66, __OUTSW__
158:
159:
160: /*
161: * If we are willing to restrict ourselves to i386's, Borland C++ 3.1 allows
162: * support for 32-bit register-pseudovariables if 386 code generation has
163: * been enabled.
164: *
165: * As it turns out, there are all kinds of bugs in the 386 support in BC++ 3.1
166: * but enough works that we can even get a far pointer into ES:whatever via
167: * a 32-bit register, as long as the intermediate register isn't _ESI or _EDI
168: * since _EAX = _ESI or _EAX = _EDI only moves the low 16 bits. Being able to
169: * load ES:whatever via a 32-bit register allows us to write macros that only
170: * reference each argument exactly once.
171: *
172: * While the 32-bit-pointer version still works in the near models, it's not
173: * exactly optimal, so we use a more straightforward version there.
174: */
175:
176: #define __inb(port) (_DX = (port), __emit__ (__INB__), (uchar_t) _AL)
177: #define __inl(port) (_DX = (port), __emit__ (__INL__), _EAX)
178: #define __inw(port) (_DX = (port), __emit__ (__INW__), (ushort_t) _AX)
179:
180: #define __outb(port,value) (_DX = (port), _AL = (value), __emit__ (__OUTB__))
181: #define __outl(port,value) (_DX = (port), _EAX = (value), __emit__ (__OUTL__))
182: #define __outw(port,value) (_DX = (port), _AX = (value), __emit__ (__OUTW__))
183:
184: #if defined (__LARGE__) || defined (__HUGE__) || defined (__COMPACT__)
185:
186: #define __repins(p,a,c) (_EDX = (long) (void __far *) (a), _EAX = _EDX,\
187: _ES = (unsigned) (_EAX >> 16),\
188: _DI = _DX, _CX = (c), _DX = (p))
189: #define __repouts(p,a,c) (_EDX = (long) (void _far *) (a), _EAX = _EDX,\
190: _ES = (unsigned) (_EAX >> 16),\
191: _SI = _DX, _CX = (c), _DX = (p))
192:
193: #else /* use simpler small-data versions */
194:
195: #define __repins(p,a,c) (_ES = _DS, _DI = (unsigned) (a), _CX = (c), _DX = (p))
196: #define __repouts(p,a,c) (_ES = _DS, _SI = (unsigned) (a), _CX = (c), _DX = (p))
197:
198: #endif
199:
200: #define __repinsb(p,a,c) (__repins (p, a, c),\
201: __emit__ (__REP__, __INSB__))
202: #define __repinsd(p,a,c) (__repins (p, a, c),\
203: __emit__ (__REP__, __INSL__))
204: #define __repinsw(p,a,c) (__repins (p, a, c),\
205: __emit__ (__REP__, __INSW__))
206:
207: #define __repoutsb(p,a,c) (__repouts (p, a, c),\
208: __emit__ (__REP__, __OUTSB__))
209: #define __repoutsd(p,a,c) (__repouts (p, a, c),\
210: __emit__ (__REP__, __OUTSL__))
211: #define __repoutsw(p,a,c) (__repouts (p, a, c),\
212: __emit__ (__REP__, __OUTSW__))
213:
214:
215: #define __FORWARD_inb__
216: #define __FORWARD_inl__
217: #define __FORWARD_inw__
218: #define __FORWARD_outb__
219: #define __FORWARD_outl__
220: #define __FORWARD_outw__
221: #define __FORWARD_repinsb__
222: #define __FORWARD_repinsd__
223: #define __FORWARD_repinsw__
224: #define __FORWARD_repoutsb__
225: #define __FORWARD_repoutsd__
226: #define __FORWARD_repoutsw__
227:
228: #elif defined (COHERENT)
229:
230: /*
231: * Under Coherent, the inb ()/inw ()/inl () and outb ()/outw ()/outl ()
232: * operations are already available under those names in the standard system.
233: *
234: * The rep... () operations are provided in a supplemental file that should be
235: * linked in if you are building a DDI/DKI kernel.
236: */
237:
238: #endif
239:
240:
241: __EXTERN_C_BEGIN__
242:
243: uchar_t inb __PROTO ((int _port));
244: ulong_t inl __PROTO ((int _port));
245: ushort_t inw __PROTO ((int _port));
246: void outb __PROTO ((int _port, uchar_t _value));
247: void outl __PROTO ((int _port, ulong_t _value));
248: void outw __PROTO ((int _port, ushort_t _value));
249: void repinsb __PROTO ((int _port, uchar_t * _addr,
250: int _cnt));
251: void repinsd __PROTO ((int _port, ulong_t * _addr,
252: int _cnt));
253: void repinsw __PROTO ((int _port, ushort_t * _addr,
254: int _cnt));
255: void repoutsb __PROTO ((int _port, uchar_t * _addr,
256: int _cnt));
257: void repoutsd __PROTO ((int _port, ulong_t * _addr,
258: int _cnt));
259: void repoutsw __PROTO ((int _port, ushort_t * _addr,
260: int _cnt));
261:
262: __EXTERN_C_END__
263:
264:
265: #ifdef __FORWARD_inb__
266: # define inb(port) __inb (port)
267: #endif
268:
269: #ifdef __FORWARD_inl__
270: # define inl(port) __inl (port)
271: #endif
272:
273: #ifdef __FORWARD_inw__
274: # define inw(port) __inw (port)
275: #endif
276:
277: #ifdef __FORWARD_outb__
278: # define outb(port,val) __outb (port, val)
279: #endif
280:
281: #ifdef __FORWARD_outl__
282: # define outl(port,val) __outl (port, val)
283: #endif
284:
285: #ifdef __FORWARD_outw__
286: # define outw(port,val) __outw (port, val)
287: #endif
288:
289: #ifdef __FORWARD_repinsb__
290: # define repinsb(p,a,c) __repinsb (p, a, c)
291: #endif
292:
293: #ifdef __FORWARD_repinsd__
294: # define repinsd(p,a,c) __repinsd (p, a, c)
295: #endif
296:
297: #ifdef __FORWARD_repinsw__
298: # define repinsw(p,a,c) __repinsw (p, a, c)
299: #endif
300:
301: #ifdef __FORWARD_repoutsb__
302: # define repoutsb(p,a,c) __repoutsb (p, a, c)
303: #endif
304:
305: #ifdef __FORWARD_repoutsd__
306: # define repoutsd(p,a,c) __repoutsd (p, a, c)
307: #endif
308:
309: #ifdef __FORWARD_repoutsw__
310: # define repoutsw(p,a,c) __repoutsw (p, a, c)
311: #endif
312:
313:
314: #undef __FORWARD_inb__
315: #undef __FORWARD_inl__
316: #undef __FORWARD_inw__
317: #undef __FORWARD_outb__
318: #undef __FORWARD_outl__
319: #undef __FORWARD_outw__
320: #undef __FORWARD_repinsb__
321: #undef __FORWARD_repinsd__
322: #undef __FORWARD_repinsw__
323: #undef __FORWARD_repoutsb__
324: #undef __FORWARD_repoutsd__
325: #undef __FORWARD_repoutsw__
326:
327: #endif /* ! defined (__SYS_X86IO_H__) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.