![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bsc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / bsc|
Return to bsc.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / bsc |
1.1 root 1: /* D.L.Buck and Associates, Inc. - 9/4/84
2: *
3: * COPYRIGHT NOTICE:
4: * Copyright c 9/4/84 - An unpublished work by
5: * D.L.Buck and Associates, Inc.
6: *
7: * PROPRIETARY RIGHTS NOTICE:
8: * All rights reserved. This document and program contains
9: * proprietary information of D.L.Buck and Associates,Inc.
10: * of San Jose, California, U.S.A., embodying confidential
11: * information, ideas, and expressions, no part of which
12: * may be reproduced, or transmitted in any form or by any
13: * means, electronic, mechanical, or otherwise, without
14: * the written permission of D.L.Buck and Associates, Inc.
15: *
16: * NAME
17: * bsc - bisync device driver
18: *
19: * DESCRIPTION
20: * This file contains the Unix system interface routines, prepared for
21: * UNIX Version 7, System III, System V, or BSD 4.2.
22: * The entry points are bscopen, bscclose, bscread, bscwrite, and
23: * bscioctl. These routines are meant to be hardware-independent.
24: */
25:
26: #ifndef lint
27: static char bsc_c[] = "@(#)bsc.c 1.15 REL";
28: #endif
29:
30: #include "../bsc/local.h"
31: #include "../bsc/bscio.h"
32: #include "../bsc/bsc.h"
33:
34: #if defined v7 || defined BSD42
35: #define delay(x) sleep((caddr_t)&lbolt, BSCPRI)
36: extern int lbolt;
37: #endif
38:
39: #if defined BSD42
40: #define ERRRET(x) return x
41: #define UCOUNT uio->uio_resid
42: #else
43: #define ERRRET(x) u.u_error = x; return
44: #define UCOUNT u.u_count
45: #endif
46:
47: struct bsc bsc[NVBSC*4]; /* device-specific information */
48: extern struct state states[]; /* state table in bscpsm.c */
49:
50: /*
51: * bscopen -- prepare for BISYNC communications
52: * 0) check and lock device
53: * 1) set up defaults for IOCTL-provided parameters
54: * 2) set up counters and fields returned via IOCTL
55: * 3) set up everything else related to bsc driver
56: * 4) do hardware-specific programming and checking
57: * 5) wait for DSR from modem
58: */
59: /*VARARGS1*/
60: bscopen (dev) /* prepare for BISYNC communication */
61: register dev_t dev;
62: {
63: register struct bsc *bp; /* ptr to dev's bsc entry */
64: int errcode;
65:
66: /* 0. Check and lock device. */
67: dev = minor(dev);
68: /* if (dev >= NBSC) { */
69: if (dev >= MX_NBSC) {
70: ERRRET(ENXIO); /* No such device */
71: }
72: bp = &bsc[dev];
73: if (bp->b_lock) { /* Is port locked? */
74: ERRRET(EBUSY); /* Error - port busy */
75: }
76: bp->b_lock = SSLOCK; /* Special single station lock */
77:
78: /* 1. Set up defaults for ioctl-provided params */
79: bp->b_iocin.b_blks = BSCMBLK; /* Max block size */
80: bp->b_hlflgs = BSCPRIM; /* Flags: we are primary */
81: bp->b_iocin.b_termid[0] = '\0'; /* No terminal id */
82: bp->b_iocin.b_hostid[0] = '\0'; /* No host id */
83: bp->b_iocin.b_nbid = /* Max # bids */
84: bp->b_iocin.b_nnak = /* Max # naks we will give */
85: bp->b_iocin.b_nretry = 15; /* Max # receive t/o's and naks */
86: /* we will accept */
87: bp->b_iocin.b_nttd = /* Max # ttds we will accept */
88: bp->b_iocin.b_nwack = 100; /* Max # wacks we will accept */
89: bp->b_iocin.b_nor = 30; /* Max seconds to wait on initial rd */
90:
91: /* 2. Set up counters and fields returned via ioctl */
92: bp->b_iocout.b_blks = 0; /* # blocks sent/received */
93: bp->b_iocout.b_flags = 0; /* Flags: see definition */
94: bp->b_iocout.b_termid[0] = '\0';/* No terminal id */
95: bp->b_iocout.b_hostid[0] = '\0';/* No host id */
96: bp->b_iocout.b_nbid = 0; /* No bids so far */
97: bp->b_iocout.b_nnak = 0; /* No naks so far */
98: bp->b_iocout.b_nretry = 0; /* No retry so far */
99: bp->b_iocout.b_nttd = 0; /* No ttds so far */
100: bp->b_iocout.b_nwack = 0; /* No wacks so far */
101: bp->b_iocout.b_nor = 0; /* No overruns so far */
102:
103: /* 3. Set up miscellaneous fields for driver */
104: bp->b_state = 0; /* Set initial psm state */
105: bp->b_mode = BSC_INIT; /* Initial mode indicates */
106: /* haven't done any i/o yet */
107: bp->b_rxst0 = 0; /* Reset l/l driver state */
108: bp->b_tmperr = 0; /* No temp. errors yet */
109: bp->b_sema = BSC_DDONE; /* Neither psm nor */
110: /* driver busy - both done */
111:
112: /* 4. Initialize I/O port */
113: if (errcode = bsclopn(dev, bp)) {/* device-specific open */
114: bp->b_lock = 0;
115: ERRRET(errcode);
116: }
117:
118: /* 5. wait till DSR shows */
119: while (bsckdsr(dev,bp), !(bp->b_hlflgs & BSC_DSR) && !u.u_error)
120: delay(PSMTICK);
121: if (bp->b_trace)
122: wakeup(&bp->b_trace);
123: if (u.u_error) {
124: bp->b_lock = 0;
125: bsclcls(dev, bp);
126: }
127: #if defined BSD42
128: return 0;
129: #endif
130: }
131:
132: /*
133: * bscclose -- 1) send disconnect message, if we're up and running
134: * 2) turn off DTR, RTS and disable the channel
135: */
136: bscclose(dev)
137: register dev_t dev;
138: {
139: register struct bsc *bp;
140:
141: dev = minor(dev);
142: bp = &bsc[dev];
143:
144: /*debug*/printf("bscclose");
145: /* 1. Terminate PSM processing, kill receive and tracing */
146: if ( (bp->b_hlflgs & (BSCMPT|BSC_DSR)) != BSC_DSR ||
147: bp->b_mode == BSC_INIT)
148: bp->b_mode = BSC_CLOSED; /* Leave quietly */
149: else { /* Point-to-point ... */
150: bp->b_mode = BSC_CL1; /* Send Disconnect */
151: while (bp->b_mode != BSC_CLOSED &&
152: (bp->b_hlflgs & BSC_DSR)) /* Wait */
153: delay(PSMTICK);
154: }
155: bp->b_rclptr = (char *)0; /* terminate receive */
156: bstclose(dev); /* terminate tracing */
157:
158: /* 2. Unlock the port */
159: /*debug*/printf("close:unlock");
160: bp->b_lock = 0;
161:
162: /* 3. Turn off DTR */
163: bsclcls (dev, bp);
164: #if defined BSD42
165: return 0;
166: #endif
167: }
168:
169: /*
170: * bscread -- read next data block.
171: * 0) If error latch set or no DSR, EIO!
172: * 1) if mode = write, EINVAL!
173: * 2) if mode = init, initialize bsc, mode <- idle
174: * 3) if mode = idle, sync with psm, set b_nor timeout,
175: * mode <- read
176: * 4) while buffer empty and no errs and not eof, sleep
177: * 5) Check termination condition:
178: * a) If err, set mode<-idle, reset hlflgs, set EIO error.
179: * b) If signal caused termination, force rxto & reread.
180: * c) If EOF, set mode<-IDLE, reset hlflgs and sema, return.
181: * d) Otherwise, full buffer.
182: * If size not zero, copy it out and mark it empty.
183: */
184: #if defined BSD42
185: bscread(dev,uio)
186: register dev_t dev;
187: struct uio *uio;
188: #else
189: bscread(dev)
190: register dev_t dev;
191: #endif
192: {
193: register struct bsc *bp; /* ptr to bsc device info. */
194: register int l; /* length info. */
195: int x; /* prty save area */
196: int errcode = 0; /* Error code upon exit */
197:
198: dev = minor(dev);
199: bp = &bsc[dev];
200:
201: /* 0. Check error latch and DSR */
202: if (!(bp->b_hlflgs & BSC_DSR) || /* No DSR! */
203: (bp->b_hlflgs & BSC_ERR)) { /* Error logged */
204: if (!(bp->b_hlflgs & BSC_ERR)) {/* Ensure latched err */
205: bp->b_hlflgs |= BSC_ERR;
206: bp->b_iocout.b_flags = BSCNDSR;
207: }
208: bp->b_mode = BSC_IDLE;
209: ERRRET(EIO);
210: }
211:
212: switch (bp->b_mode) {
213: case BSC_WRITE: /* Error! */
214: ERRRET(EINVAL);
215:
216: case BSC_INIT: /* First read or write action */
217: bscsetup(dev); /* Start by initializing */
218: bp->b_mode = BSC_IDLE;
219:
220: case BSC_IDLE: /* Moving from Idle to Write */
221: while (!(bp->b_sema & BSC_PDONE) &&
222: !(bp->b_hlflgs & BSC_ERR))
223: delay(PSMTICK); /* Synchronize */
224: if (bp->b_hlflgs & BSC_ERR) {
225: bp->b_mode = BSC_IDLE;
226: ERRRET(EIO);
227: }
228: /* Set Read Timeout in Ticks */
229: bp->b_rdflag = bp->b_iocin.b_nor*PSMTPS;
230: bp->b_mode = BSC_READ; /* Now we're in read state */
231: x = spl8(); /* *** protect flags *** */
232: bp->b_sema |= BSC_DBUSY;/* Driver now busy */
233: bp->b_sema &= ~BSC_DDONE;
234: splx(x); /* End protection */
235:
236: case BSC_READ: /* Not first read */
237: forceread:
238: x = spl8();
239: /* Test for no-delay mode and not ready */
240: if (bp->b_sema & BSC_SEENBUF) {
241: bp->b_hlflgs &= ~BSC_FULL;
242: bp->b_sema &= ~BSC_SEENBUF;
243: if (states[bp->b_state].s_type == 'd' &&
244: bp->b_alenb) { /* Decision wait? */
245: bp->b_alenb = 0;/* Disable pto */
246: splx(x);
247: bscpsm(dev); /* Wake up PTO */
248: }
249: }
250: if ((bp->b_sema & BSC_NDLY) &&
251: !(bp->b_hlflgs & (BSC_FULL|BSC_ERR|BSC_XLAST))) {
252: splx(x);
253: ERRRET(EAGAIN); /* NO DELAY */
254: }
255: while (!(bp->b_hlflgs & (BSC_FULL|BSC_ERR|BSC_XLAST)))
256: sleep (bp->b_buffer, BSCPRI); /* Take a nap */
257: splx(x);
258:
259: bp->b_rdflag = 0; /* Cancel read timeout */
260:
261: if (bp->b_hlflgs & BSC_XLAST) {
262: x = spl8(); /* Protect flags */
263: bp->b_mode = BSC_IDLE;
264: bp->b_hlflgs &= ~(BSC_XLAST|BSC_XTRN);
265: bp->b_sema |= BSC_DDONE;
266: bp->b_sema &= ~BSC_DBUSY;
267: splx(x);
268: goto readexit; /* EOF! */
269: }
270:
271: if (bp->b_hlflgs & BSC_ERR) { /* Error way out */
272: bp->b_hlflgs &= ~(BSC_XLAST|BSC_XTRN);
273: bp->b_hlflgs &= ~BSC_FULL;
274: bp->b_sema &= ~BSC_SEENBUF;
275: bp->b_mode = BSC_IDLE;
276: ERRRET(EIO);
277: } else { /* No errors - copy buffer out */
278: l = bp->b_bsize;/* Size of data in buffer */
279: if (l > UCOUNT)
280: l = UCOUNT;
281: if (l) /* transfer data */
282: #if defined BSD42
283: errcode = uiomove(bp->b_buffer,l,UIO_READ,uio);
284: #else
285: if (iomove (bp->b_buffer, l, B_READ))
286: errcode = EFAULT;
287: #endif
288: }
289:
290: /* If FAST-ACKNOWLEDGE mode in effect, ACK on next read */
291: if (bp->b_sema & BSC_FACK) {
292: bp->b_sema |= BSC_SEENBUF;
293: goto readret;
294: } else
295: bp->b_hlflgs &= ~BSC_FULL; /* Mark empty */
296: readexit: x = spl8();
297: if (states[bp->b_state].s_type == 'd' &&
298: bp->b_alenb) { /* Decision wait? */
299: bp->b_alenb = 0; /* Disable PTO */
300: splx(x);
301: bscpsm(dev); /* Awaken PSM */
302: }
303: else splx(x);
304: }
305: readret:
306: #if defined BSD42
307: return errcode;
308: #else
309: if (errcode)
310: u.u_error = errcode;
311: #endif
312: }
313:
314: /*
315: * bscwrite -- 0) if no DSR or error latch set, EIO
316: * 1) if length to write zero or > max, EINVAL
317: * 2) if mode = read, EINVAL!
318: * 3) if mode = init, prime the driver
319: * 4) if mode = idle, init, or write,
320: * a) set mode to write,
321: * b) wait till buffer empty,
322: * c) fill the buffer,
323: * d) set flag to show buffer full.
324: */
325: #if defined BSD42
326: bscwrite(dev,uio)
327: register dev_t dev;
328: struct uio *uio;
329: #else
330: bscwrite(dev)
331: register dev_t dev;
332: #endif
333: {
334: register int l; /* length given us */
335: register struct bsc *bp; /* ptr to bsc dev info */
336: int x; /* priority save area */
337: int errcode = 0; /* Error code to be returned */
338:
339: bp = &bsc[dev = minor(dev)];
340:
341: /* 0. Check error latch and DSR */
342: if (bp->b_hlflgs & BSC_ERR && bp->b_iocout.b_flags == BSCRXTO) {
343: bp->b_hlflgs &= ~BSC_ERR;
344: bp->b_iocout.b_flags = 0;
345: bp->b_mode = BSC_IDLE;
346: }
347: if (!(bp->b_hlflgs & BSC_DSR) || (bp->b_hlflgs & BSC_ERR)) {
348: if (!(bp->b_hlflgs & BSC_ERR)) {/* ensure latched err */
349: bp->b_hlflgs |= BSC_ERR;
350: bp->b_iocout.b_flags = BSCNDSR;
351: }
352: bp->b_mode = BSC_IDLE;
353: ERRRET(EIO);
354: }
355:
356: /* 1. Check length and other errors */
357: if ( (l = UCOUNT) == 0 || l > bp->b_iocin.b_blks) { /* bad length */
358: ERRRET(EINVAL);
359: }
360:
361: /* 2. process according to mode */
362: switch (bp->b_mode)
363: {
364: case BSC_READ:
365: if ((bp->b_sema & BSC_FACK) && (bp->b_sema & BSC_SEENBUF)) {
366: bp->b_hlflgs &= ~BSC_FULL;
367: bp->b_sema &= ~BSC_SEENBUF;
368: bp->b_mode = BSC_WRITE;
369: goto casewrite;
370: }
371: if (bp->b_rdflag == 0) {
372: ERRRET(EINVAL); /* oops - can't read now! */
373: } else {
374: bp->b_rdflag = 1; /* kill read timeout */
375: x = spl8(); /* *** protect flags *** */
376: bp->b_sema &= ~BSC_DBUSY;
377: bp->b_sema |= BSC_DDONE;
378: splx(x); /* end protection */
379: /* wait till timeout */
380: while (bp->b_mode == BSC_READ &&
381: !(bp->b_hlflgs & BSC_ERR))
382: delay(PSMTICK);
383: }
384:
385: case BSC_INIT:
386: bscsetup(dev); /* set up device */
387: bp->b_mode = BSC_IDLE;
388:
389: case BSC_IDLE:
390: if (bp->b_hlflgs & BSC_FULL) {
391: ERRRET(EINVAL); /* caller needs to read */
392: }
393: while (!(bp->b_sema & BSC_PDONE) &&
394: !(bp->b_hlflgs & BSC_ERR))
395: delay(PSMTICK); /* Synchronize */
396: if (bp->b_hlflgs & BSC_ERR) {
397: bp->b_mode = BSC_IDLE;
398: ERRRET(EIO);
399: }
400:
401: bp->b_mode = BSC_WRITE; /* set new mode */
402: x = spl8(); /* *** protect flags *** */
403: bp->b_hlflgs &= ~BSC_ERR; /* reset possible err */
404: bp->b_sema |= BSC_DBUSY;/* driver now busy */
405: bp->b_sema &= ~BSC_DDONE;
406: splx(x); /* *** end protection *** */
407:
408: casewrite:
409: case BSC_WRITE:
410: x = spl8();
411: while ((bp->b_hlflgs & BSC_FULL) && /* wait til empty */
412: !(bp->b_hlflgs & BSC_ERR)) /* and no error */
413: sleep (bp->b_buffer, BSCPRI); /* take a nap */
414: splx(x);
415:
416: if (bp->b_hlflgs & BSC_ERR){ /* if error, EIO */
417: bp->b_hlflgs &= ~(BSC_XLAST|BSC_FULL|BSC_XTRN);
418: bp->b_mode = BSC_IDLE;
419: errcode = EIO;
420: break;
421: }
422: /* copy data to buffer */
423: #if defined BSD42
424: errcode = uiomove(bp->b_buffer, l, UIO_WRITE, uio);
425: #else
426: if (iomove (bp->b_buffer, l, B_WRITE))
427: errcode = EFAULT;
428: #endif
429: bp->b_bsize = l; /* save size */
430: x = spl8();
431: bp->b_hlflgs |= BSC_FULL; /* bufr now full */
432: if (states[bp->b_state].s_type == 'd' &&
433: bp->b_alenb) { /* decision wait? */
434: bp->b_alenb = 0; /* disable pto */
435: splx(x);
436: bscpsm(dev); /* wake 'em up */
437: } else splx(x);
438:
439: if (bp->b_hlflgs & BSC_XLAST) { /* if last block, wait*/
440: x = spl8();
441: while ((bp->b_hlflgs & BSC_FULL) && /* wait til empty */
442: !(bp->b_hlflgs & BSC_ERR)) /* and no error */
443: sleep (bp->b_buffer, BSCPRI);/* take a nap */
444: splx(x);
445: if (bp->b_hlflgs & BSC_ERR) /* if error, EIO */
446: errcode = EIO;
447: else {
448: x = spl8(); /* *** protect flags *** */
449: bp->b_sema |= BSC_DDONE;
450: bp->b_sema &= ~BSC_DBUSY;
451: splx(x); /* *** end protection *** */
452: }
453: bp->b_mode = BSC_IDLE;
454: x = spl8(); /* *** protect flags *** */
455: bp->b_hlflgs &= ~(BSC_XLAST|BSC_FULL|BSC_XTRN);
456: splx(x); /* end protection */
457: }
458: }
459: #if defined BSD42
460: return errcode;
461: #else
462: if (errcode)
463: u.u_error = errcode;
464: #endif
465: }
466:
467: /* bscioctl -- set options or get counter values
468: * Depending on cmd:
469: * BSCGET - copy b_iocout to user's area
470: * BSCSET - copy user's values to b_iocin (set stuff)
471: * BSCTRNSP - set transparent mode flag
472: * BSCNTRNS - reset transparent mode flag
473: * BSCSOH - set send SOH flag
474: * BSCNSOH - turn off SOH flag
475: * BSCLAST - set send last flag
476: * BSCNDLY - set NO DELAY flag
477: */
478: /*VARARGS3*/
479: bscioctl(dev, cmd, arg)
480: register dev_t dev;
481: struct bscio *arg;
482: {
483: register struct bsc *bp; /* ptr to dev info */
484: struct bscio tmp; /* temp struct for chk'g user params*/
485: register int x;
486: int y, errcode = 0;
487:
488: bp = &bsc[dev = minor(dev)];
489: if (cmd != BSCGET && cmd != BSCSET) { /* if write op, wait on buf */
490: x = spl8();
491: while (bp->b_mode == BSC_WRITE && bp->b_hlflgs & BSC_FULL)
492: sleep (bp->b_buffer, BSCPRI);
493: splx(x);
494: }
495: switch (cmd) {
496: case BSCGET:
497: x = spl8();
498: #if defined BSD42
499: bcopy(&bp->b_iocout, arg, sizeof bp->b_iocout);
500: #else
501: if (copyout(&bp->b_iocout, arg, sizeof bp->b_iocout))
502: errcode = EFAULT;
503: #endif
504: bp->b_iocout.b_flags = 0;
505: if (bp->b_hlflgs & BSC_ERR) { /* error latch set? */
506: bp->b_hlflgs &= ~(BSC_ERR|BSC_XLAST|BSC_FULL|BSC_XTRN);
507: bp->b_sema &= ~BSC_DBUSY;
508: bp->b_sema |= BSC_DDONE;
509: }
510: splx(x);
511: break;
512:
513: case BSCSET:
514: if (bp->b_mode == BSC_READ || bp->b_mode == BSC_WRITE) {
515: ERRRET(EINVAL);
516: }
517: #if defined BSD42
518: bcopy(arg, &tmp, sizeof tmp);
519: #else
520: if (copyin (arg, &tmp, sizeof tmp)) {
521: errcode = EFAULT;
522: break;
523: }
524: #endif
525: if (tmp.b_blks > BSCMBLK) { /* block size too big? */
526: ERRRET(EINVAL);
527: }
528: bcopy (/*from*/&tmp, /*to*/&bp->b_iocin, sizeof tmp);
529: x = spl8(); /* *** protect hlflgs */
530: bp->b_hlflgs &= ~BSC_UFLAGS; /* throw out old user flags */
531: bp->b_hlflgs |= (tmp.b_flags & BSC_UFLAGS);
532: splx(x); /* *** end protection */
533: bscparam(dev); /* redo parameters */
534: break;
535:
536: case BSCTRNSP:
537: x = spl8(); /* *** protect hlflgs */
538: bp->b_hlflgs |= BSC_XTRN; /* set transparent mode */
539: splx(x); /* *** end protection */
540: break;
541:
542: case BSCNTRNS:
543: x = spl8(); /* *** protect hlflgs */
544: bp->b_hlflgs &= ~BSC_XTRN; /* reset transp. mode */
545: splx(x); /* *** end protection */
546: break;
547:
548: case BSCSOH:
549: x = spl8(); /* *** protect hlflgs */
550: bp->b_hlflgs |= BSC_XSOH; /* set send SOH flag */
551: splx(x); /* *** end protection */
552: break;
553:
554: case BSCNSOH:
555: x = spl8(); /* *** protect hlflgs */
556: bp->b_hlflgs &= ~BSC_XSOH; /* clear send SOH flag*/
557: splx(x); /* *** end protection */
558: break;
559:
560: case BSCLAST:
561: x = spl8(); /* *** protect hlflgs */
562: bp->b_hlflgs |= BSC_XLAST; /* set send last blk flag */
563: splx(x); /* *** end protection */
564: break;
565:
566: case BSCID:
567: y = (bp->b_iocin.b_flags & BSCASCII)? 0x20 : 0x40;
568: #if defined BSD42
569: bcopy(&y,arg,sizeof y);
570: #else
571: copyout(&y,(int *)arg,sizeof y);
572: #endif
573: break;
574:
575: case BSCNDLY:
576: x = spl8(); /* *** protect flags */
577: bp->b_sema |= BSC_NDLY; /* Set NO DELAY flag */
578: splx(x); /* *** end protection */
579: break;
580:
581: case BSCFACK:
582: x = spl8(); /* *** protect flags */
583: bp->b_sema |= BSC_FACK; /* Set FAST ACKNOWLEDGE */
584: splx(x); /* *** end protection */
585: break;
586:
587: default:
588: ERRRET(EINVAL);
589: }
590: #if defined BSD42
591: return errcode;
592: #else
593: if (errcode)
594: u.u_error = errcode;
595: #endif
596: }
597:
598: /*
599: * bscsetup -- start the psm (protocol state machine)
600: * 1) if state > 0, already started
601: * 2) invoke the psm
602: * 3) set timeout for 1 tick for psm
603: */
604: bscsetup(dev)
605: register dev_t dev;
606: {
607: void bscpto();
608:
609: if (bsc[dev].b_state || bsc[dev].b_mode != BSC_INIT)
610: return;
611: bscpsm(dev);
612: timeout (bscpto, (caddr_t)dev, PSMTICK);
613: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.