![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to confinfo.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 confinfo.h CVS log | Up to [MW Coherent from dump] / coherent / f / usr / include / sys |
1.1 root 1: #ifndef __SYS_CONFINFO_H__
2: #define __SYS_CONFINFO_H__
3:
4: /*
5: * This file contains definitions used by the automatically-generated
6: * configuration file "conf.c". The generated code makes heavy use of macros
7: * to allow the final result to be precisely tailored to the target system
8: * without modification to the code generator.
9: */
10: /*
11: *-IMPORTS:
12: * <common/ccompat.h>
13: * __EXTERN_C_BEGIN__
14: * __EXTERN_C_END__
15: * __USE_PROTO__
16: * __PROTO ()
17: * <common/xdebug.h>
18: * __LOCAL__
19: * <common/_intmask.h>
20: * intmask_t
21: * <common/_cred.h>
22: * cred_t
23: * <common/_uid.h>
24: * n_dev_t
25: * __major_t
26: * __minor_t
27: * <common/_off.h>
28: * off_t
29: * <sys/inline.h>
30: * _masktab []
31: * __GET_BASE_MASK ()
32: * __SET_BASE_MASK ()
33: * <sys/stream.h>
34: * struct streamtab
35: * <sys/uio.h>
36: * uio_t
37: */
38:
39: #include <common/ccompat.h>
40: #include <common/xdebug.h>
41: #include <common/_intmask.h>
42: #include <common/_cred.h>
43: #include <common/_uid.h>
44: #include <common/_off.h>
45: #include <sys/inline.h>
46: #include <sys/stream.h>
47: #include <sys/uio.h>
48:
49:
50: #ifdef __USE_PROTO__
51: #define DEF(ansi,k_r) ansi
52: #else
53: #define DEF(ansi,k_r) k_r
54: #endif
55:
56: /*
57: * Since we don't import the definition of "buf", let's create an incomplete
58: * definition at file scope. Same for "pollhead".
59: */
60:
61: struct buf;
62: struct pollhead;
63:
64: #define __OPEN(name) __CONCAT (name, open)
65: #define __CLOSE(name) __CONCAT (name, close)
66: #define __READ(name) __CONCAT (name, read)
67: #define __WRITE(name) __CONCAT (name, write)
68: #define __IOCTL(name) __CONCAT (name, ioctl)
69: #define __STRATEGY(name) __CONCAT (name, strategy)
70: #define __PRINT(name) __CONCAT (name, print)
71: #define __SIZE(name) __CONCAT (name, size)
72: #define __CHPOLL(name) __CONCAT (name, chpoll)
73: #define __MMAP(name) __CONCAT (name, mmap)
74: #define __INTR(name) __CONCAT (name, intr)
75: #define __INIT(name) __CONCAT (name, init)
76: #define __HALT(name) __CONCAT (name, halt)
77: #define __START(name) __CONCAT (name, start)
78: #define __EXIT(name) __CONCAT (name, exit)
79:
80: #define __INFO(name) __CONCAT (name, info)
81: #define __DEVFLAG(name) __CONCAT (name, devflag)
82:
83:
84: typedef int (* ddi_open_t) __PROTO ((n_dev_t * _devp, int _oflag,
85: int _otyp, cred_t * _credp));
86: #define EXTERN_OPEN(name) __EXTERN_C__ \
87: int __OPEN (name) __PROTO ((n_dev_t * _devp, int _oflag,\
88: int _otyp, cred_t * _credp))
89:
90: typedef int (* ddi_close_t) __PROTO ((n_dev_t _dev, int _oflag, int _otyp,
91: cred_t * _credp));
92: #define EXTERN_CLOSE(name) __EXTERN_C__ \
93: int __CLOSE (name) __PROTO ((n_dev_t _dev, int _oflag, int _otyp,\
94: cred_t * _credp))
95:
96: typedef int (* ddi_read_t) __PROTO ((n_dev_t _dev, uio_t * _uiop,
97: cred_t * _credp));
98: #define EXTERN_READ(name) __EXTERN_C__ \
99: int __READ (name) __PROTO ((n_dev_t _dev, uio_t * _uiop,\
100: cred_t * _credp))
101:
102: typedef int (* ddi_write_t) __PROTO ((n_dev_t _dev, uio_t * _uiop,
103: cred_t * _credp));
104: #define EXTERN_WRITE(name) __EXTERN_C__ \
105: int __WRITE (name) __PROTO ((n_dev_t _dev, uio_t * _uiop,\
106: cred_t * _credp))
107:
108: typedef int (* ddi_ioctl_t) __PROTO ((n_dev_t _dev, int _cmd, _VOID * _arg,
109: int _mode, cred_t * _credp,
110: int * _rvalp));
111: #define EXTERN_IOCTL(name) __EXTERN_C__ \
112: int __IOCTL (name) __PROTO ((n_dev_t _dev, int _cmd, _VOID * _arg,\
113: int _mode, cred_t * _credp,\
114: int * _rvalp))
115:
116: typedef int (* ddi_strategy_t) __PROTO ((struct buf * _bufp));
117: #define EXTERN_STRATEGY(name) __EXTERN_C__ \
118: int __STRATEGY (name) __PROTO ((struct buf * _bufp))
119:
120: typedef int (* ddi_print_t) __PROTO ((n_dev_t _dev, char * _str));
121: #define EXTERN_PRINT(name) __EXTERN_C__ \
122: int __PRINT (name) __PROTO ((n_dev_t _dev, char * _str))
123:
124: typedef int (* ddi_size_t) __PROTO ((n_dev_t _dev));
125: #define EXTERN_SIZE(name) __EXTERN_C__ \
126: int __SIZE (name) __PROTO ((n_dev_t _dev))
127:
128: typedef int (* ddi_chpoll_t) __PROTO ((n_dev_t _dev, short _events,
129: int _anyyet, short * _reventsp,
130: struct pollhead ** _phpp));
131: #define EXTERN_CHPOLL(name) __EXTERN_C__ \
132: int __CHPOLL (name) __PROTO ((n_dev_t _dev, short _events,\
133: int _anyyet, short * _reventsp,\
134: struct pollhead ** _phpp))
135:
136: typedef int (* ddi_mmap_t) __PROTO ((n_dev_t _dev, off_t _off,
137: int _prot));
138: #define EXTERN_MMAP(name) __EXTERN_C__ \
139: int __MMAP (name) __PROTO ((n_dev_t _dev, off_t _off,\
140: int _prot))
141:
142: typedef int (* ddi_intr_t) __PROTO ((int _ivec));
143: #define EXTERN_INTR(name) __EXTERN_C__ \
144: int __INTR (name) __PROTO ((int _ivec))
145:
146: typedef void (* ddi_init_t) __PROTO ((void));
147: #define EXTERN_INIT(name) __EXTERN_C__ \
148: void __INIT (name) __PROTO ((void))
149:
150: typedef void (* ddi_start_t) __PROTO ((void));
151: #define EXTERN_START(name) __EXTERN_C__ \
152: void __START (name) __PROTO ((void))
153:
154: typedef void (* ddi_exit_t) __PROTO ((void));
155: #define EXTERN_EXIT(name) __EXTERN_C__ \
156: void __EXIT (name) __PROTO ((void))
157:
158: typedef void (* ddi_halt_t) __PROTO ((void));
159: #define EXTERN_HALT(name) __EXTERN_C__ \
160: void __HALT (name) __PROTO ((void))
161:
162: #define NULL_OPEN ((ddi_open_t) 0)
163: #define NULL_CLOSE ((ddi_close_t) 0)
164: #define NULL_READ ((ddi_read_t) 0)
165: #define NULL_WRITE ((ddi_write_t) 0)
166: #define NULL_IOCTL ((ddi_ioctl_t) 0)
167: #define NULL_STRATEGY ((ddi_strategy_t) 0)
168: #define NULL_PRINT ((ddi_print_t) 0)
169: #define NULL_SIZE ((ddi_size_t) 0)
170: #define NULL_CHPOLL ((ddi_chpoll_t) 0)
171: #define NULL_MMAP ((ddi_mmap_t) 0)
172: #define NULL_INTR ((ddi_intr_t) 0)
173: #define NULL_INIT ((ddi_init_t) 0)
174: #define NULL_START ((ddi_start_t) 0)
175: #define NULL_EXIT ((ddi_exit_t) 0)
176: #define NULL_HALT ((ddi_halt_t) 0)
177: #define NULL_CON ((CON *) 0)
178:
179: #if __COHERENT__ || defined (__MSDOS__)
180:
181: #define __KERNEL__ 2
182:
183: #if defined (__MSDOS__)
184: #include <sys/_con.h>
185: #else
186: #include <sys/buf.h>
187: #include <sys/con.h>
188: #endif
189:
190: #include <sys/io.h>
191:
192: #undef __KERNEL__
193:
194: __EXTERN_C_BEGIN__
195:
196: int _forward_open __PROTO ((o_dev_t _dev, int _mode, int _flags,
197: ddi_open_t _funcp));
198: int _forward_close __PROTO ((o_dev_t _dev, int _mode, int _flags,
199: ddi_close_t _funcp));
200: int _forward_read __PROTO ((o_dev_t _dev, IO * _iop,
201: ddi_read_t _funcp));
202: int _forward_write __PROTO ((o_dev_t _dev, IO * _iop,
203: ddi_write_t _funcp));
204: int _forward_ioctl __PROTO ((o_dev_t _dev, int _cmd,
205: _VOID * _arg, int mode,
206: ddi_ioctl_t _funcp));
207: #ifndef __MSDOS__
208: int _forward_strategy __PROTO ((BUF * _buf,
209: ddi_strategy_t _funcp));
210: #endif
211: int _forward_chpoll __PROTO ((o_dev_t _dev, int _events,
212: int _msec, ddi_chpoll_t _funcp));
213:
214: int _streams_open __PROTO ((o_dev_t _dev, int _mode, int _flags,
215: struct streamtab * _infop));
216: int _streams_close __PROTO ((o_dev_t _dev, int _mode, int _flags,
217: struct streamtab * _infop));
218: int _streams_read __PROTO ((o_dev_t _dev, IO * _iop,
219: struct streamtab * _infop));
220: int _streams_write __PROTO ((o_dev_t _dev, IO * _iop,
221: struct streamtab * _infop));
222: int _streams_ioctl __PROTO ((o_dev_t _dev, int _cmd,
223: _VOID * _arg, int mode,
224: struct streamtab * _infop));
225: int _streams_chpoll __PROTO ((o_dev_t _dev, int _events,
226: int _msec,
227: struct streamtab * _infop));
228:
229: __EXTERN_C_END__
230:
231: typedef struct {
232: int * cdev_flag;
233: CON cdev_con;
234: } cdevsw_t;
235:
236: /*
237: * Note that we do not have the DFPOL flag set by default. While most compilers
238: * can evaluate a "(ch) == 0 ? :" type of expression which is a constant in an
239: * initializer, the MWC compiler cannot do so reliably. We fix up the flags at
240: * startup time as a result.
241: */
242:
243: #define CDEVSW_ENTRY(fl,op,cl,re,wr,io,ch,mm) \
244: { (fl), { (ch) == 0 ? DFCHR : DFCHR | DFPOL, 0, \
245: (op), (cl), 0, (re), (wr), (io), 0, 0, 0, 0, (ch) } }
246:
247: #define NULL_CDEVSW() \
248: { 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
249:
250: #define STREAMS_ENTRY(name) \
251: { & __DEVFLAG (name), { DFCHR | DFPOL, 0, \
252: __CONCAT (name, openS), __CONCAT (name, closeS), \
253: 0, __CONCAT (name, readS), __CONCAT (name, writeS), \
254: __CONCAT (name, ioctlS), 0, 0, 0, 0, \
255: __CONCAT (name, chpollS) } }
256:
257: #define COH_OPEN(name,s) \
258: __LOCAL__ int __CONCAT3 (name, open, s) \
259: DEF ((o_dev_t dev, int mode, int flag),\
260: (dev, mode, flag) o_dev_t dev; int mode; int flag;)
261:
262: #define COH_CLOSE(name,s) \
263: __LOCAL__ int __CONCAT3 (name, close, s) \
264: DEF ((o_dev_t dev, int mode, int flag), \
265: (dev, mode, flag) o_dev_t dev; int mode; int flag;)
266:
267: #define COH_READ(name,s) \
268: __LOCAL__ int __CONCAT3 (name, read, s) \
269: DEF ((o_dev_t dev, IO * iop), \
270: (dev, iop) o_dev_t dev; IO * iop;)
271:
272: #define COH_WRITE(name,s) \
273: __LOCAL__ int __CONCAT3 (name, write, s) \
274: DEF ((o_dev_t dev, IO * iop), \
275: (dev, iop) o_dev_t dev; IO * iop;)
276:
277: #define COH_IOCTL(name,s) \
278: __LOCAL__ int __CONCAT3 (name, ioctl, s) \
279: DEF ((o_dev_t dev, int cmd, _VOID * arg, int mode), \
280: (dev, cmd, arg, mode) \
281: o_dev_t dev; int cmd; _VOID * arg; int mode;)
282:
283: #define COH_STRATEGY(name,s) \
284: __LOCAL__ int __CONCAT3 (name, strategy, s) \
285: DEF ((BUF * buf), \
286: (buf) BUF * buf;)
287:
288: #define COH_CHPOLL(name,s) \
289: __LOCAL__ int __CONCAT3 (name, chpoll, s) \
290: DEF ((o_dev_t dev, int events, int msec), \
291: (dev, events, msec) o_dev_t dev; int events; int msec;)
292:
293: #define DECLARE_STREAMS(name) \
294: extern struct streamtab __INFO (name); \
295: COH_OPEN (name, S) { \
296: return _streams_open (dev, mode, flag, & __INFO (name)); \
297: } \
298: COH_CLOSE (name, S) { \
299: return _streams_close (dev, mode, flag, & __INFO (name)); \
300: } \
301: COH_READ (name, S) { \
302: return _streams_read (dev, iop, & __INFO (name)); \
303: } \
304: COH_WRITE (name, S) { \
305: return _streams_write (dev, iop, & __INFO (name)); \
306: } \
307: COH_IOCTL (name, S) { \
308: return _streams_ioctl (dev, cmd, arg, mode, & __INFO (name));\
309: } \
310: COH_CHPOLL (name, S) { \
311: return _streams_chpoll (dev, events, msec, & __INFO (name)); \
312: }
313:
314: #define DECLARE_OPEN(name) \
315: COH_OPEN (name,D) { \
316: EXTERN_OPEN (name); \
317: return _forward_open (dev, mode, flag, __OPEN (name)); \
318: }
319:
320: #define DECLARE_CLOSE(name) \
321: COH_CLOSE (name,D) { \
322: EXTERN_CLOSE (name); \
323: return _forward_close (dev, mode, flag, __CLOSE (name)); \
324: }
325:
326: #define DECLARE_READ(name) \
327: COH_READ (name,D) { \
328: EXTERN_READ (name); \
329: return _forward_read (dev, iop, __READ (name)); \
330: }
331:
332: #define DECLARE_WRITE(name) \
333: COH_WRITE (name,D) { \
334: EXTERN_WRITE (name); \
335: return _forward_write (dev, iop, __WRITE (name)); \
336: }
337:
338: #define DECLARE_IOCTL(name) \
339: COH_IOCTL (name,D) { \
340: EXTERN_IOCTL (name); \
341: return _forward_ioctl (dev, cmd, arg, mode, __IOCTL (name)); \
342: }
343:
344: #define DECLARE_STRATEGY(name) \
345: COH_STRATEGY (name,D) { \
346: EXTERN_STRATEGY (name); \
347: return _forward_strategy (buf, __STRATEGY (name)); \
348: }
349:
350: #define DECLARE_CHPOLL(name) \
351: COH_CHPOLL (name,D) { \
352: EXTERN_CHPOLL (name); \
353: return _forward_chpoll (dev, events, msec, __CHPOLL (name)); \
354: }
355:
356: #define OPEN(name) __CONCAT (name, openD)
357: #define CLOSE(name) __CONCAT (name, closeD)
358: #define READ(name) __CONCAT (name, readD)
359: #define WRITE(name) __CONCAT (name, writeD)
360: #define IOCTL(name) __CONCAT (name, ioctlD)
361: #define STRATEGY(name) __CONCAT (name, strategyD)
362: #define CHPOLL(name) __CONCAT (name, chpollD)
363:
364: /*
365: * "drvl" and "drvn" are declared for us in <sys/con.h>. Note that the drvl []
366: * table always has 32 entries to allow the patching hacks (shudder).
367: */
368:
369: #define DECLARE_DRVL(name) extern CON __CONCAT (name, con);
370:
371: #define DRVL_ENTRY(name) { & __CONCAT (name, con) }
372:
373: #define NULL_DRVL() { 0 }
374:
375: #endif /* __COHERENT__ || defined (__MSDOS__) */
376:
377:
378: /*
379: * Now default definitions for those things that are not overridden above.
380: */
381:
382: #if ! defined (DECLARE_STREAMS)
383: # define DECLARE_STREAMS(name) extern struct streamtab __INFO (name);
384: #endif
385:
386: #if ! defined (DECLARE_MODULE)
387: # define DECLARE_MODULE(name) extern struct streamtab __INFO (name);
388: #endif
389:
390: #if ! defined (DECLARE_OPEN) || ! defined (OPEN)
391: # define DECLARE_OPEN(name) EXTERN_OPEN (name);
392: # define OPEN(name) __OPEN (name)
393: #endif
394:
395: #if ! defined (DECLARE_CLOSE) || ! defined (CLOSE)
396: # define DECLARE_CLOSE(name) EXTERN_CLOSE (name);
397: # define CLOSE(name) __CLOSE (name)
398: #endif
399:
400: #if ! defined (DECLARE_READ) || ! defined (READ)
401: # define DECLARE_READ(name) EXTERN_READ (name);
402: # define READ(name) __READ (name)
403: #endif
404:
405: #if ! defined (DECLARE_WRITE) || ! defined (WRITE)
406: # define DECLARE_WRITE(name) EXTERN_WRITE (name);
407: # define WRITE(name) __WRITE (name)
408: #endif
409:
410: #if ! defined (DECLARE_IOCTL) || ! defined (IOCTL)
411: # define DECLARE_IOCTL(name) EXTERN_IOCTL (name);
412: # define IOCTL(name) __IOCTL (name)
413: #endif
414:
415: #if ! defined (DECLARE_CHPOLL) || ! defined (CHPOLL)
416: # define DECLARE_CHPOLL(name) EXTERN_CHPOLL (name);
417: # define CHPOLL(name) __CHPOLL (name)
418: #endif
419:
420: #if ! defined (DECLARE_MMAP) || ! defined (MMAP)
421: # define DECLARE_MMAP(name) EXTERN_MMAP (name);
422: # define MMAP(name) __MMAP (name)
423: #endif
424:
425: #if ! defined (DECLARE_STRATEGY) || ! defined (STRATEGY)
426: # define DECLARE_STRATEGY(name) EXTERN_STRATEGY (name);
427: # define STRATEGY(name) __STRATEGY (name)
428: #endif
429:
430: #if ! defined (DECLARE_PRINT) || ! defined (PRINT)
431: # define DECLARE_PRINT(name) EXTERN_PRINT (name);
432: # define PRINT(name) __PRINT (name)
433: #endif
434:
435: #if ! defined (DECLARE_SIZE) || ! defined (SIZE)
436: # define DECLARE_SIZE(name) EXTERN_SIZE (name);
437: # define SIZE(name) __SIZE (name)
438: #endif
439:
440: #if ! defined (DECLARE_INTR) || ! defined (INTR)
441: # define DECLARE_INTR(name) EXTERN_INTR (name);
442: # define INTR(name) __INTR (name)
443: #endif
444:
445: #if ! defined (DECLARE_INIT) || ! defined (INIT)
446: # define DECLARE_INIT(name) EXTERN_INIT (name);
447: # define INIT(name) __INIT (name)
448: #endif
449:
450: #if ! defined (DECLARE_START) || ! defined (START)
451: # define DECLARE_START(name) EXTERN_START (name);
452: # define START(name) __START (name)
453: #endif
454:
455: #if ! defined (DECLARE_EXIT) || ! defined (EXIT)
456: # define DECLARE_EXIT(name) EXTERN_EXIT (name);
457: # define EXIT(name) __EXIT (name)
458: #endif
459:
460: #if ! defined (DECLARE_HALT) || ! defined (HALT)
461: # define DECLARE_HALT(name) EXTERN_HALT (name);
462: # define HALT(name) __EXIT (halt)
463: #endif
464:
465: #ifndef CDEVSW_ENTRY
466:
467: typedef struct {
468: int * cdev_flag;
469: struct streamtab
470: * cdev_stream;
471: ddi_open_t cdev_open;
472: ddi_close_t cdev_close;
473: ddi_read_t cdev_read;
474: ddi_write_t cdev_write;
475: ddi_ioctl_t cdev_ioctl;
476: ddi_chpoll_t cdev_chpoll;
477: ddi_mmap_t cdev_mmap;
478: } cdevsw_t;
479:
480: #define CDEVSW_ENTRY(fl,op,cl,re,wr,io,ch,mm) \
481: { (fl), 0, (op), (cl), (re), (wr), (io), (ch), (mm) }
482:
483: #define STREAMS_ENTRY(name) \
484: { & __DEVFLAG (name), & __INFO (name), 0, 0, 0, 0, 0, 0 }
485:
486: #define NULL_CDEVSW() \
487: { 0, 0, 0, 0, 0, 0, 0, 0 }
488:
489: #endif /* ! defined (CDEVSW_ENTRY) */
490:
491: #ifndef BDEVSW_ENTRY
492:
493: typedef struct {
494: int * bdev_flag;
495: ddi_open_t bdev_open;
496: ddi_close_t bdev_close;
497: ddi_strategy_t bdev_strategy;
498: ddi_print_t bdev_print;
499: ddi_size_t bdev_size;
500: } bdevsw_t;
501:
502: #define BDEVSW_ENTRY(fl,op,cl,st,pr,si) \
503: { (fl), (op), (cl), (st), (pr), (si) }
504:
505: #define NULL_BDEVSW() \
506: { 0, 0, 0, 0, 0, 0 }
507:
508: #endif /* ! defined (BDEVSW_ENTRY) */
509:
510:
511: #ifndef MODSW_ENTRY
512:
513: typedef struct {
514: int * mod_flag;
515: struct streamtab
516: * mod_stream;
517: } modsw_t;
518:
519: #define MODSW_ENTRY(name) { & __DEVFLAG (name), & __INFO (name) }
520:
521: #define NULL_MODSW() { 0, 0 }
522:
523: #endif /* ! defined (MODSW_ENTRY) */
524:
525:
526: #define __VECTOR(vec) __CONCAT (vector, vec)
527: #define __PREV(vec) __CONCAT3 (vector, vec, _prev)
528:
529:
530: #ifdef __BORLANDC__
531:
532: /*
533: * Under MS-DOS, we have to avoid disrupting the existing software. That means
534: * we have to take care to chain to the appropriate previous handlers; given
535: * that Borland C++ has support for this, interrupts under C++ are supported
536: * using native facilities rather than a generic trap layer. A generic trap
537: * layer should be doing similar things, of course.
538: */
539:
540: typedef interrupt void (* intthunk_t) __PROTO ((__ANY_ARGS__));
541:
542: __EXTERN_C_BEGIN__
543:
544: void _chain_intr (intthunk_t _prev_int); /* Borland C++ library */
545: void CHECK_DEFER (void);
546:
547: __EXTERN_C_END__
548:
549:
550: typedef struct {
551: int int_vector;
552: intthunk_t int_thunk;
553: intthunk_t * int_prev;
554: } intr_t;
555:
556: #define BEGIN_THUNK(vec,mask) \
557: __LOCAL__ intthunk_t __PREV (vec); \
558: __LOCAL__ interrupt void __VECTOR (vec) \
559: DEF ((__ANY_ARGS__), __ARGS (())) { \
560: intmask_t oldmask = __GET_BASE_MASK (); \
561: pl_t prev_pl; \
562: if (__PREV (vec) != 0) \
563: (* __PREV (vec)) (); \
564: __SET_BASE_MASK (oldmask | (mask)); \
565: ddi_cpu_data ()->dc_int_level ++; \
566: prev_pl = spltimeout (); \
567: __SEND_EOI (vec); \
568: __CHEAP_ENABLE_INTS ();
569:
570: #define CALL_INTR(vec,name) (void) __INTR (name) (vec);
571:
572: #define END_THUNK(vec) \
573: __CHEAP_DISABLE_INTS (); \
574: __SET_BASE_MASK (oldmask); \
575: splx (prev_pl); \
576: if (ddi_cpu_data ()->dc_int_level == 1 && \
577: ddi_cpu_data ()->dc_ipl == plbase) \
578: CHECK_DEFER (); \
579: ddi_cpu_data ()->dc_int_level --; \
580: }
581:
582: #define INTR_THUNK(vec) { vec, __VECTOR (vec), & __PREV (vec) }
583:
584: #else
585:
586: typedef void (* intthunk_t) __PROTO ((__ANY_ARGS__));
587:
588: typedef struct {
589: int int_vector;
590: intthunk_t int_thunk;
591: } intr_t;
592:
593: #define BEGIN_THUNK(vec,mask) \
594: __LOCAL__ void __VECTOR (vec) \
595: DEF ((void), __ARGS (())) { \
596: intmask_t oldmask = __GET_BASE_MASK (); \
597: __SET_BASE_MASK (oldmask | (mask)); \
598: ddi_cpu_data ()->dc_int_level ++;
599:
600: #define CALL_INTR(vec,name) (void) __INTR (name) (vec);
601:
602: #define END_THUNK(vec) \
603: ddi_cpu_data ()->dc_int_level --; \
604: __SET_BASE_MASK (oldmask); \
605: }
606:
607: #define INTR_THUNK(vec) { vec, __VECTOR (vec) }
608:
609: #endif
610:
611:
612: typedef ddi_init_t init_t;
613: typedef ddi_start_t start_t;
614: typedef ddi_exit_t exit_t;
615: typedef ddi_halt_t halt_t;
616:
617: extern init_t inittab [];
618: extern unsigned int ninit;
619:
620: extern start_t starttab [];
621: extern unsigned int nstart;
622:
623: extern exit_t exittab [];
624: extern unsigned int nexit;
625:
626: extern halt_t halttab [];
627: extern unsigned int nhalt;
628:
629: extern cdevsw_t cdevsw [];
630: extern unsigned int ncdevsw;
631:
632: extern bdevsw_t bdevsw [];
633: extern unsigned int nbdevsw;
634:
635: extern modsw_t modsw [];
636: extern unsigned int nmodsw;
637:
638: extern __major_t _maxmajor;
639: extern __major_t _major [];
640: extern __minor_t _minor [];
641:
642: extern intr_t inttab [];
643: extern unsigned int nintr;
644:
645: #endif /* ! defined (__SYS_CONFINFO_H__) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.