![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to inline.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 / sys|
Return to inline.h CVS log | Up to [MW Coherent from dump] / coherent / f / usr / include / sys |
1.1 root 1: #ifndef __SYS_INLINE_H__
2: #define __SYS_INLINE_H__
3:
4: /*
5: * This header file exists for compatibility with the System V DDI/DKI.
6: * This header defines some routines which are commonly kept inlined for
7: * efficiency reasons (although under the full DDI/DKI regime they are not
8: * in fact inlined).
9: */
10:
11: /*
12: *-IMPORTS:
13: * <common/ccompat.h>
14: * __PROTO ()
15: * __EXTERN_C_BEGIN__
16: * __EXTERN_C_END__
17: * __NON_ISO ()
18: * <common/xdebug.h>
19: * __LOCAL__
20: * <kernel/__pl.h>
21: * __pl_t
22: * <kernel/ddi_cpu.h>
23: * intmask_t
24: */
25:
26: #include <common/ccompat.h>
27: #include <common/xdebug.h>
28: #include <kernel/__pl.h>
29: #include <kernel/ddi_cpu.h>
30: #include <kernel/x86io.h>
31:
32:
33: /*
34: * This header is made a little more complex by the fact that we want to
35: * be able to support inlining for those compilers that can do it, yet we
36: * also need to be able to use the #include <sys/ddi.h> mechanism to force
37: * all of these to be bound to regular C functions.
38: *
39: * In order to support this, the initial compiler-dependent part of the
40: * file performs feature tests and sets a __FORWARD_x__ macro for those
41: * definitions that are to be "forwarded" via macro to a version whose name
42: * has some additional leading underscores prepended.
43: *
44: * In this way, for systems that have inlining the #include <sys/ddi.h> will
45: * suppress the forwarding.
46: */
47:
48: /*
49: * Perform feature tests to try and work out how the processor priority
50: * level can be manipulated under this machine/compiler.
51: */
52:
53: /*
54: * The 80x86 processor and the IBM PC have numerous design misfeatures when
55: * it comes to the way interrupt priority works. Some are the result of using
56: * external hardware to deal with interrupt priority level (not in itself a
57: * big deal, but the 8259A on the PC ISA-bus is a problem). Others are a
58: * result of the modality of the various processors in the 80x86 family and
59: * the fact that none of them can emulate the others very well, by design.
60: *
61: * The key features are that the sti/cli instructions used in the CPU to mask
62: * all interrupts are simply too coarse for regular use, plus the fact that
63: * certain instructions which manipulate the processor priority at some
64: * privelege levels may trap (or worse, simply do nothing) at others, meaning
65: * branches and tests are required for reliable operation.
66: *
67: * Programming the 8259A interrupt controller directly gives the necessary
68: * granularity (but may cause problems due to bus issues) and allows the
69: * hard-wired priority levels to be redefined by software.
70: */
71:
72:
73: #if defined (__GNUC__) && defined (i386) /* 80386 running GCC */
74:
75: #define __IBM_PC__
76: #define __PICC__ 0x20
77: #define __PICM__ 0x21
78: #define __SPICC__ 0xA0
79: #define __SPICM__ 0xA1
80:
81: #define __EOI_CMD__ 0x20
82:
83: extern intmask_t _masktab [];
84:
85: __LOCAL__ __INLINE__ void __CHEAP_DISABLE_INTS (void) {
86: __NON_ISO (asm) ("cli");
87: }
88:
89: __LOCAL__ __INLINE__ void __CHEAP_ENABLE_INTS (void) {
90: __NON_ISO (asm) ("sti");
91: }
92:
93: __LOCAL__ __INLINE__ void __OUT_IPL_MASK (intmask_t _mask) {
94: outb (__PICM__, _mask);
95: outb (__SPICM__, _mask >> 8);
96: }
97:
98: __LOCAL__ __INLINE__ intmask_t __GET_BASE_MASK (void) {
99: return ddi_cpu_data ()->dc_base_mask;
100: }
101:
102: __LOCAL__ __INLINE__ void __SET_BASE_MASK (intmask_t _mask) {
103: __OUT_IPL_MASK (ddi_cpu_data ()->dc_base_mask = _mask);
104: }
105:
106: __LOCAL__ __INLINE__ void __SEND_EOI (int _vector) {
107: outb (__PICC__, __EOI_CMD__);
108:
109: if (_vector >= 8)
110: outb (__SPICC__, __EOI_CMD__);
111: }
112:
113: #define __FORWARD_splx__
114: #define __FORWARD_splraise__
115:
116:
117: #elif __BORLANDC__
118:
119:
120: #define __IBM_PC__
121: #define __PICC__ 0x20
122: #define __PICM__ 0x21
123: #define __SPICC__ 0xA0
124: #define __SPICM__ 0xA1
125:
126: #define __EOI_CMD__ 0x20
127:
128: void __emit__ (unsigned char _byte, ...);
129:
130: #define __CLI__ 0xFB
131: #define __STI__ 0xFA
132:
133: extern intmask_t _masktab [];
134:
135: #define __CHEAP_DISABLE_INTS() __emit__ (__CLI__)
136: #define __CHEAP_ENABLE_INTS() __emit__ (__STI__)
137:
138: #define __OUT_IPL_MASK(mask) \
139: (void) (outb (__PICM__, mask), \
140: outb (__SPICM__, mask >> 8))
141:
142: #define __GET_BASE_MASK()\
143: (const intmask_t) (ddi_cpu_data ()->dc_base_mask)
144: #define __SET_BASE_MASK(mask)\
145: (void) (ddi_cpu_data ()->dc_base_mask = (mask), \
146: __OUT_IPL_MASK (ddi_cpu_data ()->dc_base_mask))
147:
148: #define __SEND_EOI(vector) \
149: (outb (__PICC__, __EOI_CMD__), (vector < 8 ? (void) 0 : \
150: outb (__SPICC__, __EOI_CMD__)))
151:
152: /*
153: * Since BC++ 3.1 has outlawed inline functions in C code, to the point of
154: * not even providing an __inline__ keyword, we can only provide in-line
155: * definitions for splx () and splraise () under C++
156: */
157:
158: #ifdef __cplusplus
159:
160: #define __FORWARD_splx__
161: #define __FORWARD_splraise__
162:
163: #endif
164:
165:
166: #elif __COHERENT__
167:
168:
169: /*
170: * Coherent's C compiler has no extensions.
171: */
172:
173: #define __IBM_PC__
174: #define __PICC__ 0x20
175: #define __PICM__ 0x21
176: #define __SPICC__ 0xA0
177: #define __SPICM__ 0xA1
178:
179: #define __EOI_CMD__ 0x20
180:
181:
182: extern intmask_t _masktab [];
183:
184:
185: #define __GET_BASE_MASK()\
186: (const intmask_t) (ddi_cpu_data ()->dc_base_mask)
187:
188: __EXTERN_C_BEGIN__
189:
190: void __CHEAP_DISABLE_INTS __PROTO ((void));
191: void __CHEAP_ENABLE_INTS __PROTO ((void));
192: void __SET_BASE_MASK __PROTO ((intmask_t _newmask));
193:
194: __EXTERN_C_END__
195:
196: #endif /* ! __COHERENT__ */
197:
198:
199: /*
200: * Generic stuff for the 80x86 IBM PC interrupt architecture.
201: */
202:
203: #ifdef __IBM_PC__
204:
205: #ifdef __FORWARD_splx__
206:
207: __LOCAL__ __INLINE__ __pl_t __splx (__pl_t _newpl) {
208: __pl_t _prev_pl;
209: intmask_t _mask = __GET_BASE_MASK () | _masktab [_newpl];
210:
211: __OUT_IPL_MASK (mask);
212:
213: _prev_pl = (__pl_t) ddi_cpu_data ()->dc_ipl;
214: ddi_cpu_data ()->dc_ipl = _newpl;
215:
216: return _prev_pl;
217: }
218:
219: #endif
220:
221: #ifdef __FORWARD_splraise__
222:
223: __LOCAL__ __INLINE__ __pl_t __splraise (__pl_t _newpl) {
224: __pl_t _prev_pl;
225:
226: if (_newpl > (_prev_pl = (__pl_t) ddi_cpu_data ()->dc_ipl)) {
227: intmask_t _mask = __GET_BASE_MASK () |
228: _masktab [_newpl];
229:
230: __OUT_IPL_MASK (mask);
231: ddi_cpu_data ()->dc_ipl = _newpl;
232: }
233:
234: return _prev_pl;
235: }
236:
237: #endif
238:
239:
240: #define __splbase() splx (plbase)
241: #define __spltimeout() splx (pltimeout)
242: #define __spldisk() splx (pldisk)
243: #define __splstr() splx (plbase)
244: #define __splhi() splx (plhi)
245:
246: #define __FORWARD_splbase__
247: #define __FORWARD_spltimeout__
248: #define __FORWARD_spldisk__
249: #define __FORWARD_splstr__
250: #define __FORWARD_splhi__
251:
252: #endif
253:
254:
255: /*
256: * Function versions of these are available by including <sys/ddi.h> or by
257: * using a compiler setup that does not permit inlining. The actual function
258: * prototypes always live here, <sys/ddi.h> merely knows how to #undef some
259: * names.
260: */
261:
262: __EXTERN_C_BEGIN__
263:
264: __pl_t splbase __PROTO ((void)); /* enabled */
265: __pl_t spltimeout __PROTO ((void)); /* timeouts */
266: __pl_t spldisk __PROTO ((void)); /* disk I/O */
267: __pl_t splstr __PROTO ((void)); /* STREAMS */
268: __pl_t splhi __PROTO ((void)); /* disabled */
269: __pl_t splx __PROTO ((__pl_t _pl)); /* restore */
270:
271: /* Internal functions - not part of DDI/DKI interface */
272:
273: int splcmp __PROTO ((__pl_t _l, __pl_t _r));
274: /* compare */
275: __pl_t splraise __PROTO ((__pl_t _pl)); /* raise priority */
276:
277: __EXTERN_C_END__
278:
279:
280: /*
281: * Define forwarding macros for those functions that need them.
282: *
283: * Note that the form of these definitions is such that they can be
284: * suppressed by enclosing the name in parentheses. Simply defining a
285: * token mapping is not a good idea for functions.
286: */
287:
288: #ifdef __FORWARD_splbase__
289: # define splbase() __splbase ()
290: #endif
291:
292: #ifdef __FORWARD_spltimeout__
293: # define spltimeout() __spltimeout ()
294: #endif
295:
296: #ifdef __FORWARD_spldisk__
297: # define spldisk() __spldisk ()
298: #endif
299:
300: #ifdef __FORWARD_splstr__
301: # define splstr() __splstr ()
302: #endif
303:
304: #ifdef __FORWARD_splhi__
305: # define splhi() __splhi ()
306: #endif
307:
308: #ifdef __FORWARD_splx__
309: # define splx(x) __splx (x)
310: #endif
311:
312: #ifdef __FORWARD_splcmp__
313: # define splcmp(l,r) __splcmp (l,r)
314: #endif
315:
316: #ifdef __FORWARD_splraise__
317: # define splraise(x) __splraise(x)
318: #endif
319:
320:
321: /*
322: * Clean up the macros we #define
323: */
324:
325: #undef __IBM_PC__
326: #undef __FORWARD_splbase__
327: #undef __FORWARD_spltimeout__
328: #undef __FORWARD_spldisk__
329: #undef __FORWARD_splstr__
330: #undef __FORWARD_splhi__
331: #undef __FORWARD_splx__
332: #undef __FORWARD_splcmp__
333: #undef __FORWARD_splraise__
334:
335:
336: #endif /* ! defined (__SYS_INLINE_H__) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.