![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to conf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc|
Return to conf.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1997 by Apple Computer, Inc., all rights reserved
27: * Copyright (c) 1993 NeXT Computer, Inc.
28: *
29: * UNIX Device switch tables.
30: *
31: */
32:
33: #import <sys/param.h>
34: #import <sys/systm.h>
35: #import <sys/buf.h>
36: #import <sys/ioctl.h>
37: #import <sys/tty.h>
38: #import <sys/conf.h>
39:
40:
41: extern int nulldev();
42:
43: __private_extern__ int sdopen(), sdclose(), sdread();
44: __private_extern__ int sdwrite(), sdioctl(), sdsize();
45: __private_extern__ void sdstrategy();
46:
47:
48: struct bdevsw bdevsw[] =
49: {
50: /*
51: * For block devices, every other block of 8 slots is
52: * reserved to NeXT. The other slots are available for
53: * the user. This way we can both add new entries without
54: * running into each other. Be sure to fill in NeXT's
55: * 8 reserved slots when you jump over us -- we'll do the
56: * same for you.
57: */
58:
59: /* 0 - 7 are reserved to NeXT */
60:
61: NO_BDEVICE, /* 0*/
62: NO_BDEVICE, /* 1*/
63: NO_BDEVICE, /* 2*/
64: NO_BDEVICE, /* 3*/
65: NO_BDEVICE, /* 4*/
66: NO_BDEVICE, /* 5*/
67: { sdopen, sdclose, sdstrategy, sdioctl, /* 6*/
68: enodev, sdsize, D_DISK },
69: NO_BDEVICE, /* 7*/
70:
71: /* 8 - 15 are reserved to the user */
72: NO_BDEVICE, /* 8*/
73: NO_BDEVICE, /* 9*/
74: NO_BDEVICE, /*10*/
75: NO_BDEVICE, /*11*/
76: NO_BDEVICE, /*12*/
77: NO_BDEVICE, /*13*/
78: NO_BDEVICE, /*14*/
79: NO_BDEVICE, /*15*/
80:
81: /* 16 - 23 are reserved to NeXT */
82: NO_BDEVICE, /*16*/
83: NO_BDEVICE, /*17*/
84: NO_BDEVICE, /*18*/
85: NO_BDEVICE, /*18*/
86: NO_BDEVICE, /*20*/
87: NO_BDEVICE, /*21*/
88: NO_BDEVICE, /*22*/
89: NO_BDEVICE, /*23*/
90: };
91:
92: int nblkdev = sizeof (bdevsw) / sizeof (bdevsw[0]);
93:
94: extern struct tty *km_tty[];
95: extern int cnopen(),cnclose(),cnread(),cnwrite(),cnioctl(),
96: cnselect(),cngetc(), cnputc(dev_t dev, char c);
97: extern int kmopen(),kmclose(),kmread(),kmwrite(),kmioctl(),
98: kmgetc(), kmputc(dev_t dev, char c);
99: extern int sgopen(),sgclose(), sgioctl();
100:
101: #define TEMPDISPLAY 1
102:
103: #if TEMPDISPLAY
104: extern int tdis_open(),tdis_close(),tdis_ioctl();
105: #endif
106:
107:
108: #import <vol.h>
109: #if NVOL > 0
110: extern int volopen(),volclose(),volioctl();
111: #else
112: #define volopen eno_opcl
113: #define volclose eno_opcl
114: #define volioctl eno_ioctl
115: #endif
116:
117: extern int cttyopen(), cttyread(), cttywrite(), cttyioctl(), cttyselect();
118:
119: extern int mmread(),mmwrite();
120: #define mmselect seltrue
121: #define mmmmap eno_mmap
122:
123: #import <pty.h>
124: #if NPTY > 0
125: extern struct tty *pt_tty[];
126: extern int ptsopen(),ptsclose(),ptsread(),ptswrite(),ptsstop(),ptsputc();
127: extern int ptcopen(),ptcclose(),ptcread(),ptcwrite(),ptcselect(),
128: ptyioctl();
129: #else
130: #define ptsopen eno_opcl
131: #define ptsclose eno_opcl
132: #define ptsread eno_rdwrt
133: #define ptswrite eno_rdwrt
134: #define ptsstop nulldev
135: #define ptsputc nulldev
136:
137: #define ptcopen eno_opcl
138: #define ptcclose eno_opcl
139: #define ptcread eno_rdwrt
140: #define ptcwrite eno_rdwrt
141: #define ptcselect eno_select
142: #define ptyioctl eno_ioctl
143: #endif
144:
145: extern int logopen(),logclose(),logread(),logioctl(),logselect();
146: extern int nvopen(), nvclose(), nvread(), nvwrite();
147: extern int fdesc_open(), fdesc_read(), fdesc_write(),
148: fdesc_ioctl(), fdesc_select();
149:
150: extern int seltrue();
151:
152: struct cdevsw cdevsw[] =
153: {
154: /*
155: * For character devices, every other block of 16 slots is
156: * reserved to NeXT. The other slots are available for
157: * the user. This way we can both add new entries without
158: * running into each other. Be sure to fill in NeXT's
159: * 16 reserved slots when you jump over us -- we'll do the
160: * same for you.
161: */
162:
163: /* 0 - 15 are reserved to NeXT */
164:
165: {
166: cnopen, cnclose, cnread, cnwrite, /* 0*/
167: cnioctl, nulldev, nulldev, 0, cnselect,
168: eno_mmap, eno_strat, cngetc, cnputc, D_TTY
169: },
170: NO_CDEVICE, /* 1*/
171: {
172: cttyopen, nulldev, cttyread, cttywrite, /* 2*/
173: cttyioctl, nulldev, nulldev, 0, cttyselect,
174: eno_mmap, eno_strat, eno_getc, eno_putc, D_TTY
175: },
176: {
177: nulldev, nulldev, mmread, mmwrite, /* 3*/
178: eno_ioctl, nulldev, nulldev, 0, mmselect,
179: mmmmap, eno_strat, eno_getc, eno_putc, 0
180: },
181: {
182: ptsopen, ptsclose, ptsread, ptswrite, /* 4*/
183: ptyioctl, ptsstop, nulldev, pt_tty, ttselect,
184: eno_mmap, eno_strat, eno_getc, eno_putc, D_TTY
185: },
186: {
187: ptcopen, ptcclose, ptcread, ptcwrite, /* 5*/
188: ptyioctl, nulldev, nulldev, 0, ptcselect,
189: eno_mmap, eno_strat, eno_getc, eno_putc, D_TTY
190: },
191: {
192: logopen, logclose, logread, eno_rdwrt, /* 6*/
193: logioctl, eno_stop, nulldev, 0, logselect,
194: eno_mmap, eno_strat, eno_getc, eno_putc, 0
195: },
196: NO_CDEVICE, /* 7*/
197: NO_CDEVICE, /* 8*/
198: NO_CDEVICE, /* 9*/
199: NO_CDEVICE, /*10*/
200: NO_CDEVICE, /*11*/
201: {
202: kmopen, kmclose, kmread, kmwrite, /*12*/
203: kmioctl, nulldev, nulldev, km_tty, ttselect,
204: eno_mmap, eno_strat, kmgetc, kmputc, 0
205: },
206: NO_CDEVICE, /*13*/
207: {
208: sdopen, sdclose, sdread, sdwrite, /*14*/
209: sdioctl, eno_stop, nulldev, 0, eno_select,
210: eno_mmap, eno_strat, eno_getc, eno_putc, D_TAPE
211: },
212: NO_CDEVICE, /*15*/
213:
214: /* 16 - 31 are reserved to the user */
215: NO_CDEVICE, /*16*/
216: NO_CDEVICE, /*17*/
217: NO_CDEVICE, /*18*/
218: NO_CDEVICE, /*19*/
219: NO_CDEVICE, /*20*/
220: NO_CDEVICE, /*21*/
221: NO_CDEVICE, /*22*/
222: NO_CDEVICE, /*23*/
223: NO_CDEVICE, /*24*/
224: NO_CDEVICE, /*25*/
225: NO_CDEVICE, /*26*/
226: NO_CDEVICE, /*27*/
227: NO_CDEVICE, /*28*/
228: NO_CDEVICE, /*29*/
229: NO_CDEVICE, /*30*/
230: NO_CDEVICE, /*31*/
231:
232: /* 32 - 47 are reserved to NeXT */
233: {
234: fdesc_open, eno_opcl, fdesc_read, fdesc_write, /*32*/
235: fdesc_ioctl, eno_stop, eno_reset, 0, fdesc_select,
236: eno_mmap, eno_strat, eno_getc, eno_putc, 0
237: },
238: {
239: sgopen, sgclose, eno_rdwrt, eno_rdwrt, /*33*/
240: sgioctl, eno_stop, eno_reset, 0, eno_select,
241: eno_mmap, eno_strat, eno_getc, eno_putc, D_TAPE
242: },
243: NO_CDEVICE, /*34*/
244: NO_CDEVICE, /*35*/
245: NO_CDEVICE, /*36*/
246: {
247: nvopen, nvclose, nvread, nvwrite, /*37*/
248: eno_ioctl, nulldev, nulldev, 0, seltrue,
249: eno_mmap, eno_strat, eno_getc, eno_putc, 0
250: },
251: NO_CDEVICE, /*38*/
252: NO_CDEVICE, /*39*/
253: NO_CDEVICE, /*40*/
254: /* 41 used to be for fd */
255: NO_CDEVICE, /*41*/
256: {
257: volopen, volclose, eno_rdwrt, eno_rdwrt, /*42*/
258: volioctl, eno_stop, eno_reset, 0, seltrue,
259: eno_mmap, eno_strat, eno_getc, eno_putc, 0
260: },
261: };
262: int nchrdev = sizeof (cdevsw) / sizeof (cdevsw[0]);
263:
264:
265: #import <sys/vnode.h> /* for VCHR and VBLK */
266: /*
267: * return true if a disk
268: */
269: int
270: isdisk(dev, type)
271: dev_t dev;
272: int type;
273: {
274: switch (major(dev)) {
275: case 1: /* fd: floppy */
276: case 6: /* sd: scsi disk */
277: case 3: /* ide: */
278: if (type == VBLK)
279: return(1);
280: break;
281: case 14: /* sd: scsi disk */
282: case 41: /* fd: floppy */
283: if (type == VCHR)
284: return(1);
285: break;
286: }
287: return(0);
288: }
289:
290: static int chrtoblktab[] = {
291: /* CHR*/ /* BLK*/ /* CHR*/ /* BLK*/
292: /* 0 */ NODEV, /* 1 */ NODEV,
293: /* 2 */ NODEV, /* 3 */ NODEV,
294: /* 4 */ NODEV, /* 5 */ NODEV,
295: /* 6 */ NODEV, /* 7 */ NODEV,
296: /* 8 */ NODEV, /* 9 */ NODEV,
297: /* 10 */ NODEV, /* 11 */ NODEV,
298: /* 12 */ NODEV, /* 13 */ NODEV,
299: /* 14 */ 6, /* 15 */ NODEV,
300: /* 16 */ NODEV, /* 17 */ NODEV,
301: /* 18 */ NODEV, /* 19 */ NODEV,
302: /* 20 */ NODEV, /* 21 */ NODEV,
303: /* 22 */ NODEV, /* 23 */ NODEV,
304: /* 24 */ NODEV, /* 25 */ NODEV,
305: /* 26 */ NODEV, /* 27 */ NODEV,
306: /* 28 */ NODEV, /* 29 */ NODEV,
307: /* 30 */ NODEV, /* 31 */ NODEV,
308: /* 32 */ NODEV, /* 33 */ NODEV,
309: /* 34 */ NODEV, /* 35 */ NODEV,
310: /* 36 */ NODEV, /* 37 */ NODEV,
311: /* 38 */ NODEV, /* 39 */ NODEV,
312: /* 40 */ NODEV, /* 41 */ 1,
313: /* 42 */ NODEV, /* 43 */ NODEV,
314: /* 44 */ NODEV,
315: };
316:
317: /*
318: * convert chr dev to blk dev
319: */
320: dev_t
321: chrtoblk(dev)
322: dev_t dev;
323: {
324: int blkmaj;
325:
326: if (major(dev) >= nchrdev)
327: return(NODEV);
328: blkmaj = chrtoblktab[major(dev)];
329: if (blkmaj == NODEV)
330: return(NODEV);
331: return(makedev(blkmaj, minor(dev)));
332: }
333:
334: /*
335: * Returns true if dev is /dev/mem or /dev/kmem.
336: */
337: int iskmemdev(dev)
338: dev_t dev;
339: {
340:
341: return (major(dev) == 3 && minor(dev) < 2);
342: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.