![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bscm.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 bscm.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: * bsm - multi-station 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 bsmopen, bsmclose, bsmread, bsmwrite, and
23: * bsmioctl. These routines are meant to be hardware-independent.
24: */
25:
26: #ifndef lint
27: static char bsm_c[] = "@(#)bscm.c 1.17 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:
48: /***
49: #define DEV(dev) (minor(dev) >> 5) & 0x7
50: #define SUBDEV(dev) minor(dev) & 0x1f
51: ***/
52:
53: #define DEV(dev) (minor(dev) >> 4) & 0xf
54: #define SUBDEV(dev) minor(dev) & 0xf
55:
56: extern struct state states[]; /* state table in bscpsm.c */
57: #ifdef NBSM
58: extern struct bsc bsc[]; /* device-specific information */
59: struct bscsub bscsubs[NVBSC*NBSM][NBSSUB];
60:
61: /*
62: * DEVICE ADDRESSING TABLES
63: * For device numbers 0 - 31, the tables hold the corresponding
64: * EBCDIC (ebcdev) or ASCII (ascdev) address
65: */
66:
67:
68: char ascdev[] = {0x20,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
69: 0x48,0x49,0x5b,0x2e,0x3c,0x28,0x2b,0x21,
70: 0x26,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,
71: 0x51,0x52,0x5d,0x24,0x2a,0x29,0x3b,0x5e};
72:
73: char ebcdev[] = {0x40,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,
74: 0xc8,0xc9,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,
75: 0x50,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,
76: 0xd8,0xd9,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f};
77: /*
78: * NAME
79: * bsmopen -- Prepare for BISYNC communications, multistation mode
80: * SYNOPSIS
81: * bsmopen (dev, flag)
82: * dev_t dev; minor device number:
83: * bits 7-5: modem port number
84: * bits 4-0: station number, 0-31
85: * int flag; unused
86: * ALGORITHM
87: * 1. Check and lock device.
88: * 2. If first station to open on this line, do line initialization
89: * 2.1 Set up defaults for ioctl-provided params
90: * 2.2 Set up counters and fields returned via ioctl
91: * 2.3 Set up miscellaneous fields for driver
92: * 2.4 Initialize I/O port
93: * 3. Wait till DSR shows
94: * 4. If tracing activated, awaken bstopen
95: */
96:
97: /* VARARGS1 */
98: bsmopen (dev) /* prepare for BISYNC communication */
99: dev_t dev;
100: {
101: register dev_t bscdev; /* modem port number */
102: register struct bsc *bp; /* ptr to port's bsc entry */
103: register int subdev; /* station number */
104: register struct bscsub *bpsub; /* ptr to station's bscsubs entry */
105: int errcode;
106:
107: /* 1. Check and lock device. */
108: bscdev = DEV(dev);
109: subdev = SUBDEV(dev);
110:
111: if (bscdev >= MX_NBSM || subdev >= NBSSUB){
112: ERRRET(ENXIO); /* no such device */
113: }
114: bp = &bsc[bscdev];
115: bpsub = &bscsubs[bscdev][subdev];
116: if ((bp->b_lock == SSLOCK) || /* line opened for point to point */
117: (bpsub->bs_mode != BS_FREE)) { /* subdevice busy */
118: ERRRET(EBUSY);
119: }
120: bpsub->bs_mode = BS_IDLE;
121: bpsub->bs_sema = BSC_DDONE | BSC_PDONE;
122:
123: /* 2. If first station to open on this line, do line initialization */
124: if (++bp->b_lock == 1) { /* First one initializes */
125:
126: /* 2.1 Set up defaults for ioctl-provided params */
127: bp->b_iocin.b_blks = BSCMBLK; /* max block size */
128: bp->b_hlflgs = BSCMPT; /* flags: we are multipoint */
129: bp->b_iocin.b_termid[0] = '\0'; /* no terminal id */
130: bp->b_iocin.b_hostid[0] = '\0'; /* no host id */
131: bp->b_iocin.b_nbid = /* max # bids */
132: bp->b_iocin.b_nnak = /* max # naks we will give */
133: bp->b_iocin.b_nretry = 15; /* max # rcv t/o's and naks */
134: /* we will accept */
135: bp->b_iocin.b_nttd = /* max # ttds we will accept */
136: bp->b_iocin.b_nwack = 100; /* max # wacks we will accept */
137: bp->b_iocin.b_nor = 30; /* max time to wait on */
138: /* initial rd */
139:
140: /* 2.2 Set up counters and fields returned via ioctl */
141: bp->b_iocout.b_blks = 0; /* # blocks sent/received */
142: bp->b_iocout.b_flags = 0; /* flags: see definition */
143: bp->b_iocout.b_termid[0] = '\0';/* no terminal id */
144: bp->b_iocout.b_hostid[0] = '\0';/* no host id */
145: bp->b_iocout.b_nbid = 0; /* no bids so far */
146: bp->b_iocout.b_nnak = 0; /* no naks so far */
147: bp->b_iocout.b_nretry = 0; /* no retry so far */
148: bp->b_iocout.b_nttd = 0; /* no ttds so far */
149: bp->b_iocout.b_nwack = 0; /* no wacks so far */
150: bp->b_iocout.b_nor = 0; /* no overruns so far */
151:
152: /* 2.3 Set up miscellaneous fields for driver */
153: bp->b_state = 0; /* set initial psm state*/
154: bp->b_mode = BSC_INIT; /* initial mode indicates */
155: /* haven't done any i/o yet */
156: bp->b_psmbsy = -1; /* no device selected */
157: bp->b_rxst0 = 0; /* reset l/l driver state */
158: bp->b_tmperr = 0; /* no temp. errors yet */
159: bp->b_sema = BSC_DDONE; /* driver not busy */
160:
161: /* 2.4 Initialize I/O port */
162: errcode = bsclopn(bscdev,bp); /* device-specific init. */
163: if (errcode) {
164: bp->b_lock = 0; /* Unlock device */
165: ERRRET(errcode);
166: }
167: }
168:
169: /* 3. Wait till DSR shows */
170: while (bsckdsr(bscdev,bp), !(bp->b_hlflgs & BSC_DSR) && !u.u_error)
171: delay(PSMTICK);
172:
173: /* 4. If tracing activated, awaken bstopen */
174: if (bp->b_trace)
175: wakeup(&bp->b_trace);
176: if (u.u_error)
177: bsmclose(dev);
178: #if defined BSD42
179: return 0;
180: #endif
181: }
182:
183: /*
184: * NAME
185: * bsmclose -- Terminate station processing
186: * SYNOPSIS
187: * bsmclose(dev)
188: * dev_t dev; minor device number:
189: * bits 7-5: modem port number
190: * bits 4-0: station number, 0-31
191: * ALGORITHM
192: * 1. Mark station done, free; decrement multistation lock
193: * If not last station using line, return.
194: * 2. Terminate PSM processing, kill receive and tracing
195: * 3. Turn off DTR
196: */
197: bsmclose(dev)
198: dev_t dev;
199: {
200: register dev_t bscdev; /* modem port number */
201: register struct bsc *bp; /* ptr to port's bsc entry */
202: register int subdev; /* station number */
203: register struct bscsub *bpsub; /* ptr to station's bscsubs entry */
204: register long s;
205:
206: bscdev = DEV(dev);
207: subdev = SUBDEV(dev);
208: bp = &bsc[bscdev];
209: bpsub = &bscsubs[bscdev][subdev];
210:
211: /* 1. Mark station done, free; decrement multistation lock. */
212: /* If not last station using line, return. */
213: bpsub->bs_sema &= ~BSC_DBUSY;
214: bpsub->bs_sema |= BSC_DDONE;
215: bpsub->bs_mode = BS_FREE;
216: bpsub->bs_flags = 0;
217: if (--bp->b_lock) return; /* others still using the line */
218: s = spl8();
219:
220: /* 2. Terminate PSM processing, kill receive and tracing */
221: bp->b_mode = BSC_CLOSED; /* mode is CLOSED */
222: bp->b_rclptr = (char *)0; /* terminate receive */
223: bstclose(bscdev); /* close trace device, too */
224:
225: /* 3. Turn off DTR */
226: bsclcls (bscdev, bp);
227: splx(s);
228:
229: #if defined BSD42
230: return 0;
231: #endif
232: }
233:
234: /*
235: * NAME
236: * bsmread -- read next data block.
237: * SYNOPSIS
238: * bsmread(dev)
239: * dev_t dev; minor device number:
240: * bits 7-5: modem port number
241: * bits 4-0: station number, 0-31
242: * ALGORITHM
243: * 1. Check for error latch or lack of DSR.
244: * If either set, return EIO error.
245: * 2. If first activity on line, set up psm.
246: * 3. Based on present mode:
247: * 3.1 Write: error (EINVAL)
248: * 3.2 Idle: Synch up with psm, then go to Read mode
249: * 3.3 Read: If delay mode in effect, wait for err, eof, or data
250: * 3.3.1 Check for NO DELAY mode
251: * 3.3.2 Wait for full buffer, eof, or error
252: * 3.3.3 If EOF, chg mode to Idle, return 0 bytes read
253: * 3.3.4 If ERR, leave mode at Read, return -1(EIO)
254: * 3.3.5 Buffer full. Copy data out, set length.
255: * 4. Mark buffer empty, awaken psm if its sleeping
256: */
257: #if defined BSD42
258: bsmread(dev,uio)
259: register dev_t dev;
260: struct uio *uio;
261: #else
262: bsmread(dev)
263: register dev_t dev;
264: #endif
265: {
266: register dev_t bscdev; /* modem port number */
267: register struct bsc *bp; /* ptr to port's bsc entry */
268: register int subdev; /* station number */
269: register struct bscsub *bpsub; /* ptr to station's bscsubs entry */
270: register int l; /* length info. */
271: int x; /* prty save area */
272: int errcode = 0; /* Error code upon return */
273:
274: bscdev = DEV(dev);
275: subdev = SUBDEV(dev);
276: bp = &bsc[bscdev];
277: bpsub = &bscsubs[bscdev][subdev];
278:
279: /* 1. Check for error latch or lack of DSR. */
280: /* If either set, return EIO error. */
281: if (!(bp->b_hlflgs & BSC_DSR) || (bpsub->bs_flags & BS_ERR)) {
282: if (!(bpsub->bs_flags & BS_ERR)) {
283: bpsub->bs_flags |= BS_ERR;
284: bpsub->bs_err = BSCNDSR;
285: }
286: bpsub->bs_mode = BS_IDLE;
287: ERRRET(EIO);
288: }
289:
290: /* 2. If first activity on line, set up psm */
291: if (bp->b_mode == BSC_INIT) {
292: bscsetup(bscdev);
293: bp->b_mode = BSC_IDLE;
294: }
295:
296: /* 3. Based on present mode: */
297: switch (bpsub->bs_mode)
298: {
299: /* 3.1 Write: error (EINVAL) */
300: case BS_WRITE:
301: ERRRET(EINVAL);
302:
303: /* 3.2 Idle: Synch up with psm, then go to Read mode */
304: case BS_IDLE: /* First read call */
305: while (!u.u_error &&
306: !(bpsub->bs_sema & BSC_PDONE) &&
307: (bpsub->bs_mode == BS_IDLE) &&
308: !(bpsub->bs_flags&BS_ERR))
309: delay(PSMTICK); /* Synchronize */
310: /* Set read timeout counter */
311: bpsub->bs_rdflg = bp->b_iocin.b_nor*PSMTPS;
312: bpsub->bs_mode = BS_READ;
313: bpsub->bs_sema |= BSC_DBUSY;
314: bpsub->bs_sema &= ~BSC_DDONE; /* driver now busy */
315:
316: /* 3.3 Read: If delay mode in effect, wait for err, eof, or data */
317: case BS_READ: /* not first read */
318: forceread:
319: x = spl8();
320: /* 3.3.1 Check for NO DELAY mode */
321: if (bpsub->bs_sema & BSC_SEENBUF) {
322: bpsub->bs_flags &= ~BS_FULL;
323: bpsub->bs_sema &= ~BSC_SEENBUF;
324: if (states[bp->b_state].s_type == 'd' &&
325: bp->b_alenb) {
326: bp->b_alenb = 0; /* disable alarm */
327: splx(x);
328: bscpsm(bscdev); /* awaken psm */
329: }
330: }
331: if ((bpsub->bs_sema & BSC_NDLY) &&
332: !(bpsub->bs_flags & (BS_FULL|BS_ERR|BS_LAST))) {
333: splx(x);
334: ERRRET(EAGAIN); /* Call again later */
335: }
336:
337: /* 3.3.2 Wait for full buffer, eof, or error */
338: while (!(bpsub->bs_flags & (BS_FULL|BS_ERR|BS_LAST)))
339: sleep ((caddr_t)&bpsub->bs_flags,BSCPRI);
340: splx(x);
341:
342: bpsub->bs_rdflg = 0; /* cancel read timeout */
343:
344: /* 3.3.3 If EOF, chg mode to Idle, return 0 bytes read */
345: if (bpsub->bs_flags & BS_LAST) {
346: bpsub->bs_mode = BS_IDLE;
347: bp->b_hlflgs &= ~(BSC_XLAST|BSC_XTRN);
348: bpsub->bs_flags &= ~(BS_LAST|BSC_XTRN);
349: bpsub->bs_sema |= BSC_DDONE;
350: bpsub->bs_sema &= ~BSC_DBUSY;
351: goto readexit;
352: }
353:
354: /* 3.3.4 If ERR, leave mode at Read, return -1(EIO) */
355: if (bpsub->bs_flags & BS_ERR) { /* error way out */
356: bp->b_hlflgs &= ~(BSC_XLAST|BSC_FULL|BSC_XTRN);
357: bpsub->bs_flags &= ~BS_FULL;
358: bpsub->bs_sema &= ~BSC_SEENBUF;
359: errcode = EIO;
360: goto readexit;
361: }
362:
363: /* 3.3.5 Buffer full. Copy data out, set length. */
364: l = bp->b_bsize; /* buffer space occupied */
365: if (l > UCOUNT)
366: l = UCOUNT;
367: if (l)
368: #if defined BSD42
369: errcode = uiomove(bp->b_buffer,l,UIO_READ,uio);
370: #else
371: if (iomove (bp->b_buffer, l, B_READ))
372: errcode = EFAULT;
373: #endif
374:
375: if (bpsub->bs_sema & BSC_FACK) {
376: bpsub->bs_sema |= BSC_SEENBUF;
377: goto readret;
378: }
379:
380: /* 4. Mark buffer empty, awaken psm if its sleeping */
381: readexit:
382: bpsub->bs_flags &= ~BS_FULL;
383: bp->b_hlflgs &= ~BSC_FULL; /* mark buffer empty */
384: x = spl8();
385: if (states[bp->b_state].s_type == 'd' &&
386: bp->b_alenb) {
387: bp->b_alenb = 0; /* disable alarm */
388: splx(x);
389: bscpsm(bscdev); /* awaken psm */
390: } else splx(x);
391: }
392: readret:
393: #if defined BSD42
394: return errcode;
395: #else
396: if (errcode)
397: u.u_error = errcode;
398: #endif
399: }
400:
401: /*
402: * bsmwrite -- 1) if user's length = 0 or > max block, error
403: * 2) if mode = read, or if error latch set, error!
404: * 3) if mode = init, prime the driver
405: * 4) if mode = idle, init, or write,
406: * a) set mode to write,
407: * b) wait till buffer empty,
408: * c) fill the buffer,
409: * d) set flag to show buffer full.
410: * ** The psm will reset the mode to idle after sending EOT.
411: */
412: #if defined BSD42
413: bsmwrite(dev,uio)
414: register dev_t dev;
415: struct uio *uio;
416: #else
417: bsmwrite(dev)
418: register dev_t dev;
419: #endif
420: {
421: register int l; /* length given us */
422: register struct bsc *bp; /* ptr to bsc dev info */
423: register struct bscsub *bpsub; /* ptr to bsc prot dev */
424: register int subdev;
425: register dev_t bscdev;
426: int x; /* prty save area */
427: int errcode = 0; /* Error code to be returned */
428:
429: subdev = SUBDEV(dev);
430: bscdev = DEV(dev);
431: bp = &bsc[bscdev];
432: bpsub = &bscsubs[bscdev][subdev];
433:
434: /* 0. Check error latch and DSR */
435: if ((bpsub->bs_flags & BS_ERR) || !(bp->b_hlflgs & BSC_DSR)) {
436: if (!(bpsub->bs_flags & BS_ERR)) {
437: bpsub->bs_flags |= BS_ERR;
438: bpsub->bs_err = BSCNDSR;
439: }
440: ERRRET(EIO);
441: }
442:
443: /* 1. Check length and other errors */
444: if ( (l = UCOUNT) == 0 || l > bp->b_iocin.b_blks) {
445: ERRRET(EINVAL);
446: }
447:
448: if (bp->b_mode == BSC_INIT) {
449: bscsetup(bscdev);
450: bp->b_mode = BSC_IDLE;
451: }
452:
453: /* 2. process according to mode */
454: switch (bpsub->bs_mode)
455: {
456: case BS_READ:
457: if ((bpsub->bs_sema & BSC_FACK) &&
458: (bpsub->bs_sema & BSC_SEENBUF)) {
459: bpsub->bs_flags &= ~BS_FULL;
460: bpsub->bs_sema &= ~BSC_SEENBUF;
461: bpsub->bs_mode = BS_WRITE;
462: goto casewrite;
463: }
464: if (bpsub->bs_rdflg == 0) {
465: ERRRET(EINVAL); /* oops - can't read now! */
466: } else {
467: bpsub->bs_sema &= ~BSC_DBUSY;
468: bpsub->bs_sema |= BSC_DDONE;
469: bpsub->bs_rdflg = 1;
470: while (bpsub->bs_mode == BS_READ &&
471: !(bpsub->bs_flags & BS_ERR))
472: delay(PSMTICK);
473: }
474: bpsub->bs_mode = BS_IDLE;
475:
476: case BS_IDLE:
477: if (bpsub->bs_flags & BS_FULL) {
478: ERRRET(EINVAL); /* Caller needs to read */
479: }
480: while (!(bpsub->bs_sema & BSC_PDONE) &&
481: !(bpsub->bs_flags & BS_ERR))
482: delay(PSMTICK); /* Synchronize */
483: bpsub->bs_mode = BS_WRITE;
484: bpsub->bs_flags &= ~BS_ERR; /* reset possible err */
485: bpsub->bs_sema |= BSC_DBUSY;
486: bpsub->bs_sema &= ~BSC_DDONE; /* driver now busy */
487:
488: casewrite:
489: case BS_WRITE:
490: x = spl8();
491: while ((bpsub->bs_flags & BS_FULL) && /*wait til empty */
492: (!(bpsub->bs_flags & BS_ERR)))
493: sleep ((caddr_t)&bpsub->bs_flags,BSCPRI);
494: splx(x);
495:
496: if (bpsub->bs_flags & BS_ERR){
497: bp->b_hlflgs &= ~(BSC_FULL|BSC_XLAST|BSC_XTRN);
498: bpsub->bs_flags &= ~(BS_FULL|BS_LAST|BSC_XTRN);
499: bpsub->bs_mode = BS_IDLE;
500: ERRRET(EIO);
501: }
502:
503: /* copy data to buffer */
504: #if defined BSD42
505: errcode = uiomove(bpsub->bs_buf,l,UIO_WRITE,uio);
506: #else
507: if (iomove (bpsub->bs_buf, l, B_WRITE))
508: errcode = EFAULT;
509: #endif
510:
511: bpsub->bs_size = l; /*save size */
512:
513: x = spl8();
514: bpsub->bs_flags |= BS_FULL; /* bufr now full */
515: if (states[bp->b_state].s_type == 'd' &&
516: bp->b_alenb) { /* decision wait? */
517: bp->b_alenb = 0; /* disable pto */
518: splx(x);
519: bscpsm(bscdev); /* wake 'em up */
520: } else splx(x);
521:
522: if (bpsub->bs_flags & BS_LAST) { /* if last block, wait */
523: x = spl8();
524: while ((bpsub->bs_flags & BS_FULL) && /*wait til empty*/
525: (!(bpsub->bs_flags & BS_ERR))) /*no error*/
526: sleep ((caddr_t)&bpsub->bs_flags, BSCPRI);
527: splx(x);
528: if (bpsub->bs_flags & BS_ERR){
529: errcode = EIO;
530: } else {
531: bpsub->bs_sema |= BSC_DDONE;
532: bpsub->bs_sema &= ~BSC_DBUSY;
533: bpsub->bs_mode = BS_IDLE;
534: }
535: bp->b_hlflgs &= ~(BSC_XLAST|BSC_FULL|BSC_XTRN);
536: bpsub->bs_flags &= ~(BS_LAST|BS_FULL|BSC_XTRN);
537: }
538: }
539: #if defined BSD42
540: return errcode;
541: #else
542: if (errcode)
543: u.u_error = errcode;
544: #endif
545: }
546:
547: /* bsmioctl -- set options or get counter values
548: * Depending on cmd:
549: * BSCGET - copy b_iocout to user's area
550: * BSCSET - copy user's values to b_iocin (set stuff)
551: * BSCTRNSP - set transparent mode flag
552: * BSCNTRNS - reset transparent mode flag
553: * BSCSOH - set send SOH flag
554: * BSCNSOH - turn off SOH flag
555: * BSCLAST - set send last flag
556: * BSCID - determine port id number
557: */
558:
559: /*VARARGS3*/
560: bsmioctl(dev, cmd, arg)
561: dev_t dev;
562: struct bscio *arg;
563: {
564: register struct bsc *bp; /* ptr to dev info */
565: register struct bscsub *bpsub; /* ptr to port info */
566: struct bscio tmp; /* temp struct for chk'g user params*/
567: register int x;
568: register int subdev;
569: register dev_t bscdev;
570: int y,errcode = 0;
571:
572: dev = minor(dev);
573: subdev = SUBDEV(dev);
574: bscdev = DEV(dev);
575: bp = &bsc[bscdev];
576: bpsub = &bscsubs[bscdev][subdev];
577: if (cmd != BSCGET && cmd != BSCSET) { /* if write op, wait on buf */
578: x = spl8();
579: while (bpsub->bs_mode == BS_WRITE && bpsub->bs_flags & BS_FULL)
580: sleep ((caddr_t)&bpsub->bs_flags, BSCPRI);
581: splx(x);
582: }
583:
584: if ((cmd == BSCSET) && (bp->b_lock != 1)) {/* only 1st can set modes */
585: ERRRET(EINVAL);
586: }
587: switch (cmd) {
588: case BSCGET:
589: x = spl8();
590: bp->b_iocout.b_flags = bpsub->bs_err;
591: #if defined BSD42
592: bcopy((caddr_t)&bp->b_iocout, arg, sizeof bp->b_iocout);
593: #else
594: if (copyout(&bp->b_iocout, arg, sizeof bp->b_iocout))
595: errcode = EFAULT;
596: #endif
597: bpsub->bs_err = 0;
598: bp->b_iocout.b_flags = 0;
599: if (bpsub->bs_flags & BS_ERR) {
600: bpsub->bs_flags &= ~(BS_ERR|BS_LAST|BS_FULL|BSC_XTRN);
601: bpsub->bs_sema &= ~BSC_DBUSY;
602: bpsub->bs_sema |= BSC_DDONE;
603: bpsub->bs_mode = BS_IDLE;
604: }
605: splx(x);
606: break;
607:
608: case BSCSET:
609: if (bpsub->bs_mode == BS_READ || bpsub->bs_mode == BS_WRITE) {
610: errcode = EINVAL; /* can't set if active */
611: break;
612: }
613: #if defined BSD42
614: bcopy(arg, (caddr_t)&tmp, sizeof tmp);
615: #else
616: if (copyin (arg, &tmp, sizeof tmp)) {
617: errcode = EFAULT;
618: break;
619: }
620: #endif
621: if (tmp.b_blks > BSCMBLK || /* block size too big? */
622: tmp.b_blks > sizeof bpsub->bs_buf) {
623: errcode = EINVAL;
624: break;
625: }
626: bcopy (/*from*/&tmp, /*to*/&bp->b_iocin, sizeof tmp);
627: x = spl8(); /* *** protect hlflgs */
628: bp->b_hlflgs &= ~BSC_UFLAGS; /* throw out old user flags */
629: bp->b_hlflgs |= (BSCMPT|(tmp.b_flags & BSC_UFLAGS));
630: splx(x); /* *** end protection */
631: bscparam(bscdev); /* redo parameters */
632: break;
633:
634: case BSCTRNSP:
635: x = spl8(); /* *** protect bsflgs */
636: bpsub->bs_flags |= BSC_XTRN; /* set transparent mode */
637: splx(x); /* *** end protection */
638: break;
639:
640: case BSCNTRNS:
641: x = spl8(); /* *** protect bsflgs */
642: bpsub->bs_flags &= ~BSC_XTRN; /* reset transp. mode */
643: splx(x); /* *** end protection */
644: break;
645:
646: case BSCSOH:
647: x = spl8(); /* *** protect bsflags */
648: bpsub->bs_flags |= BSC_XSOH; /* set send SOH flag */
649: splx(x); /* *** end protection */
650: break;
651:
652: case BSCNSOH:
653: x = spl8(); /* *** protect bsflags */
654: bpsub->bs_flags &= ~BSC_XSOH; /* clear send SOH flag*/
655: splx(x); /* end protection */
656: break;
657:
658: case BSCLAST:
659: x = spl8(); /* *** protect bsflags */
660: bpsub->bs_flags |= BS_LAST; /* set send last blk flag */
661: splx(x); /* end protection */
662: break;
663:
664: case BSCNDLY:
665: x = spl8(); /* protect bs flags */
666: bpsub->bs_sema |= BSC_NDLY;
667: splx(x);
668: break;
669:
670: case BSCID:
671: y = ((bp->b_hlflgs & BSCASCII)?ascdev:ebcdev)[subdev];
672: #if defined BSD42
673: bcopy((caddr_t)&y, (int *)arg, sizeof y);
674: #else
675: copyout(&y,(int *)arg,sizeof y);
676: #endif
677: break;
678:
679: case BSCFACK:
680: x = spl8();
681: bpsub->bs_sema |= BSC_FACK;
682: splx(x);
683: break;
684:
685: default:
686: errcode = EINVAL;
687: break;
688: }
689: #if defined BSD42
690: return errcode;
691: #else
692: if (errcode)
693: u.u_error = errcode;
694: #endif
695: }
696: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.