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