![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / tahoe / vba|
Return to vx.c CVS log | Up to [Net/2] / Net2 / arch / tahoe / vba |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Computer Consoles Inc.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)vx.c 7.13 (Berkeley) 5/16/91
37: */
38:
39: #include "vx.h"
40: #if NVX > 0
41: /*
42: * VIOC-X driver
43: */
44: #ifdef VXPERF
45: #define DOSCOPE
46: #endif
47:
48: #include "sys/param.h"
49: #include "sys/ioctl.h"
50: #include "sys/tty.h"
51: #include "sys/user.h"
52: #include "sys/map.h"
53: #include "sys/buf.h"
54: #include "sys/conf.h"
55: #include "sys/file.h"
56: #include "sys/proc.h"
57: #include "sys/vm.h"
58: #include "sys/kernel.h"
59: #include "sys/syslog.h"
60:
61: #include "../include/pte.h"
62:
63: #include "../vba/vbavar.h"
64: #include "../vba/vbaparam.h"
65: #include "../vba/vxreg.h"
66: #include "../vba/scope.h"
67:
68: #ifdef VX_DEBUG
69: long vxintr4 = 0;
70: #define VXERR4 1
71: #define VXNOBUF 2
72: long vxdebug = 0;
73: #define VXVCM 1
74: #define VXVCC 2
75: #define VXVCX 4
76: #endif
77:
78: /*
79: * Interrupt type bits passed to vinthandl().
80: */
81: #define CMDquals 0 /* command completed interrupt */
82: #define RSPquals 1 /* command response interrupt */
83: #define UNSquals 2 /* unsolicited interrupt */
84:
85: #define VXUNIT(n) ((n) >> 4)
86: #define VXPORT(n) ((n) & 0xf)
87:
88: struct tty vx_tty[NVX*16];
89: #ifndef lint
90: int nvx = NVX*16;
91: #endif
92: int vxstart(), ttrstrt();
93: struct vxcmd *vobtain(), *nextcmd();
94:
95: /*
96: * Driver information for auto-configuration stuff.
97: */
98: int vxprobe(), vxattach(), vxrint();
99: struct vba_device *vxinfo[NVX];
100: long vxstd[] = { 0 };
101: struct vba_driver vxdriver =
102: { vxprobe, 0, vxattach, 0, vxstd, "vx", vxinfo };
103:
104: struct vx_softc {
105: struct vxdevice *vs_addr; /* H/W address */
106: u_char vs_type; /* 0: viox-x/vioc-b, 1: vioc-bop */
107: u_char vs_bop; /* bop board # for vioc-bop's */
108: u_char vs_loport; /* low port nbr */
109: u_char vs_hiport; /* high port nbr */
110: u_short vs_nbr; /* viocx number */
111: u_short vs_maxcmd; /* max number of concurrent cmds */
112: u_short vs_silosiz; /* silo size */
113: short vs_vers; /* vioc/pvioc version */
114: #define VXV_OLD 0 /* PVIOCX | VIOCX */
115: #define VXV_NEW 1 /* NPVIOCX | NVIOCX */
116: short vs_state; /* controller state */
117: #define VXS_READY 0 /* ready for commands */
118: #define VXS_RESET 1 /* in process of reseting */
119: u_short vs_softCAR; /* soft carrier */
120: u_int vs_ivec; /* interrupt vector base */
121: caddr_t vs_mricmd; /* most recent issued cmd */
122: /* The remaining fields are zeroed on reset... */
123: #define vs_zero vs_xmtcnt
124: int vs_xmtcnt; /* xmit commands pending */
125: struct vxcmd *vs_avail;/* next available command buffer */
126: struct vxcmd *vs_build;
127: struct vxcmd vs_lst[NVCXBUFS];
128: struct vcmds vs_cmds;
129: } vx_softc[NVX];
130:
131: struct speedtab vxspeedtab[] = {
132: EXTA, V19200,
133: EXTB, V19200,
134: 19200, V19200,
135: 9600, 13,
136: 4800, 12,
137: 2400, 11,
138: 1800, 10,
139: 1200, 9,
140: 600, 8,
141: 300, 7,
142: 200, 6,
143: 150, 5,
144: 134, 4,
145: 110, 3,
146: 75, 2,
147: 50, 1,
148: 0, 0,
149: -1, -1,
150: };
151:
152: vxprobe(reg, vi)
153: caddr_t reg;
154: struct vba_device *vi;
155: {
156: register int br, cvec; /* must be r12, r11 */
157: register struct vxdevice *vp;
158: register struct vx_softc *vs;
159: struct pte *dummypte;
160:
161: #ifdef lint
162: br = 0; cvec = br; br = cvec;
163: vackint(0); vunsol(0); vcmdrsp(0);
164: #ifdef VX_DEBUG
165: vxfreset(0);
166: #endif
167: #endif /* lint */
168: /*
169: * If on an HCX-9, the device has a 32-bit address,
170: * and we receive that address so we can set up a map.
171: * On VERSAbus devices, the address is 24-bit, and is
172: * already mapped (into vmem[]) by autoconf.
173: */
174: if (!(reg >= vmem && reg < &vmem[ctob(VBIOSIZE)]) && /* XXX */
175: !vbmemalloc(16, reg, &dummypte, ®)) {
176: printf("vx%d: vbmemalloc failed.\n", vi->ui_unit);
177: return(0);
178: }
179: vp = (struct vxdevice *)reg;
180: if (badaddr((caddr_t)vp, 1))
181: return (0);
182: vp->v_fault = 0;
183: vp->v_vioc = V_BSY;
184: vp->v_hdwre = V_RESET; /* reset interrupt */
185: DELAY(4000000);
186: if (vp->v_fault != VXF_READY)
187: return (0);
188: vs = &vx_softc[vi->ui_unit];
189: #ifdef notdef
190: /*
191: * Align vioc interrupt vector base to 4 vector
192: * boundary and fitting in 8 bits (is this necessary,
193: * wish we had documentation).
194: */
195: if ((vi->ui_hd->vh_lastiv -= 3) > 0xff)
196: vi->ui_hd->vh_lastiv = 0xff;
197: vs->vs_ivec = vi->ui_hd->vh_lastiv = vi->ui_hd->vh_lastiv &~ 0x3;
198: #else
199: vs->vs_ivec = 0x40+vi->ui_unit*4;
200: #endif
201: br = 0x18, cvec = vs->vs_ivec; /* XXX */
202: return (sizeof (struct vxdevice));
203: }
204:
205: vxattach(vi)
206: register struct vba_device *vi;
207: {
208: register struct vx_softc *vs = &vx_softc[vi->ui_unit];
209:
210: vs->vs_softCAR = vi->ui_flags;
211: vs->vs_addr = (struct vxdevice *)vi->ui_addr;
212: vxinit(vi->ui_unit, 1);
213: }
214:
215: /*
216: * Open a VX line.
217: */
218: /*ARGSUSED*/
219: vxopen(dev, flag)
220: dev_t dev;
221: int flag;
222: {
223: register struct tty *tp; /* pointer to tty struct for port */
224: register struct vx_softc *vs;
225: register struct vba_device *vi;
226: int unit, vx, s, error = 0;
227: int vxparam();
228:
229: unit = minor(dev);
230: vx = VXUNIT(unit);
231: if (vx >= NVX || (vi = vxinfo[vx])== 0 || vi->ui_alive == 0)
232: return (ENXIO);
233: vs = &vx_softc[vx];
234: tp = &vx_tty[unit];
235: unit = VXPORT(unit);
236: if (tp->t_state&TS_XCLUDE && u.u_uid != 0)
237: return (EBUSY);
238: if (unit < vs->vs_loport || unit > vs->vs_hiport)
239: return (ENXIO);
240: tp->t_addr = (caddr_t)vs;
241: tp->t_oproc = vxstart;
242: tp->t_param = vxparam;
243: tp->t_dev = dev;
244: s = spl8();
245: if ((tp->t_state&TS_ISOPEN) == 0) {
246: tp->t_state |= TS_WOPEN;
247: ttychars(tp);
248: if (tp->t_ispeed == 0) {
249: tp->t_iflag = TTYDEF_IFLAG;
250: tp->t_oflag = TTYDEF_OFLAG;
251: tp->t_lflag = TTYDEF_LFLAG;
252: tp->t_cflag = TTYDEF_CFLAG;
253: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
254: }
255: vxparam(tp, &tp->t_termios);
256: ttsetwater(tp);
257: }
258: vcmodem(dev, VMOD_ON);
259: while (!(flag&O_NONBLOCK) && !(tp->t_cflag&CLOCAL) &&
260: (tp->t_state&TS_CARR_ON) == 0) {
261: tp->t_state |= TS_WOPEN;
262: if (error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
263: ttopen, 0))
264: break;
265: }
266: if (error == 0)
267: error = (*linesw[tp->t_line].l_open)(dev,tp);
268: splx(s);
269: return (error);
270: }
271:
272: /*
273: * Close a VX line.
274: */
275: /*ARGSUSED*/
276: vxclose(dev, flag, mode, p)
277: dev_t dev;
278: int flag, mode;
279: struct proc *p;
280: {
281: register struct tty *tp;
282: int unit, s, error = 0;
283:
284: unit = minor(dev);
285: tp = &vx_tty[unit];
286: s = spl8();
287: (*linesw[tp->t_line].l_close)(tp, flag);
288: if (tp->t_cflag & HUPCL || (tp->t_state & TS_ISOPEN) == 0)
289: vcmodem(dev, VMOD_OFF);
290: /* wait for the last response */
291: while (tp->t_state&TS_FLUSH && error == 0)
292: error = tsleep((caddr_t)&tp->t_state, TTOPRI | PCATCH,
293: ttclos, 0);
294: splx(s);
295: if (error)
296: return (error);
297: return (ttyclose(tp));
298: }
299:
300: /*
301: * Read from a VX line.
302: */
303: vxread(dev, uio, flag)
304: dev_t dev;
305: struct uio *uio;
306: {
307: struct tty *tp = &vx_tty[minor(dev)];
308:
309: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
310: }
311:
312: /*
313: * write on a VX line
314: */
315: vxwrite(dev, uio, flag)
316: dev_t dev;
317: struct uio *uio;
318: {
319: register struct tty *tp = &vx_tty[minor(dev)];
320:
321: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
322: }
323:
324: /*
325: * VIOCX unsolicited interrupt.
326: */
327: vxrint(vx)
328: register vx;
329: {
330: register struct tty *tp, *tp0;
331: register struct vxdevice *addr;
332: register struct vx_softc *vs;
333: struct vba_device *vi;
334: register int nc, c;
335: register struct silo {
336: u_char data, port;
337: } *sp;
338: short *osp;
339: int overrun = 0;
340:
341: vi = vxinfo[vx];
342: if (vi == 0 || vi->ui_alive == 0)
343: return;
344: addr = (struct vxdevice *)vi->ui_addr;
345: switch (addr->v_uqual&037) {
346: case 0:
347: break;
348: case 2:
349: if (addr->v_ustat == VP_SILO_OFLOW)
350: log(LOG_ERR, "vx%d: input silo overflow\n", vx);
351: else {
352: printf("vx%d: vc proc err, ustat %x\n",
353: vx, addr->v_ustat);
354: vxstreset(vx);
355: }
356: return;
357: case 3:
358: vcmintr(vx);
359: return;
360: case 4:
361: return;
362: default:
363: printf("vx%d: vc uqual err, uqual %x\n", vx, addr->v_uqual);
364: vxstreset(vx);
365: return;
366: }
367: vs = &vx_softc[vx];
368: if (vs->vs_vers == VXV_NEW)
369: sp = (struct silo *)((caddr_t)addr + *(short *)addr->v_usdata);
370: else
371: sp = (struct silo *)((caddr_t)addr+VX_SILO+(addr->v_usdata[0]<<6));
372: nc = *(osp = (short *)sp);
373: if (nc == 0)
374: return;
375: if (vs->vs_vers == VXV_NEW && nc > vs->vs_silosiz) {
376: printf("vx%d: %d exceeds silo size\n", nc);
377: nc = vs->vs_silosiz;
378: }
379: tp0 = &vx_tty[vx*16];
380: sp = (struct silo *)(((short *)sp)+1);
381: for (; nc > 0; nc--, sp = (struct silo *)(((short *)sp)+1)) {
382: c = sp->port & 017;
383: if (vs->vs_loport > c || c > vs->vs_hiport)
384: continue;
385: tp = tp0 + c;
386: if( (tp->t_state&TS_ISOPEN) == 0) {
387: wakeup((caddr_t)&tp->t_rawq);
388: continue;
389: }
390: c = sp->data&((tp->t_cflag&CSIZE)==CS8 ? 0xff : 0x7f);
391: if ((sp->port&VX_RO) == VX_RO && !overrun) {
392: log(LOG_ERR, "vx%d: receiver overrun\n", vi->ui_unit);
393: overrun = 1;
394: continue;
395: }
396: if (sp->port&VX_PE)
397: c |= TTY_PE;
398: if (sp->port&VX_FE)
399: c |= TTY_FE;
400: (*linesw[tp->t_line].l_rint)(c, tp);
401: }
402: *osp = 0;
403: }
404:
405: /*
406: * Ioctl for VX.
407: */
408: vxioctl(dev, cmd, data, flag)
409: dev_t dev;
410: caddr_t data;
411: {
412: register struct tty *tp;
413: int error;
414:
415: tp = &vx_tty[minor(dev)];
416: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);
417: if (error >= 0)
418: return (error);
419: error = ttioctl(tp, cmd, data, flag);
420: if (error >= 0)
421: return (error);
422: return (ENOTTY);
423: }
424:
425: vxparam(tp, t)
426: struct tty *tp;
427: struct termios *t;
428: {
429:
430: return (vxcparam(tp, t, 1));
431: }
432:
433: /*
434: * Set parameters from open or stty into the VX hardware
435: * registers.
436: */
437: vxcparam(tp, t, wait)
438: struct tty *tp;
439: struct termios *t;
440: int wait;
441: {
442: register struct vx_softc *vs;
443: register struct vxcmd *cp;
444: int s, error = 0;
445: int speedcode = ttspeedtab(t->c_ospeed, vxspeedtab);
446:
447: if (speedcode < 0 || (t->c_ispeed != t->c_ospeed && t->c_ispeed))
448: return (EINVAL);
449: vs = (struct vx_softc *)tp->t_addr;
450: cp = vobtain(vs);
451: s = spl8();
452: /*
453: * Construct ``load parameters'' command block
454: * to setup baud rates, xon-xoff chars, parity,
455: * and stop bits for the specified port.
456: */
457: cp->cmd = VXC_LPARAX;
458: cp->par[1] = VXPORT(minor(tp->t_dev));
459: /*
460: * note: if the hardware does flow control, ^V doesn't work
461: * to escape ^S
462: */
463: if (t->c_iflag&IXON) {
464: if (t->c_cc[VSTART] == _POSIX_VDISABLE)
465: cp->par[2] = 0;
466: else
467: cp->par[2] = t->c_cc[VSTART];
468: if (t->c_cc[VSTOP] == _POSIX_VDISABLE)
469: cp->par[3] = 0;
470: else
471: cp->par[3] = t->c_cc[VSTOP];
472: } else
473: cp->par[2] = cp->par[3] = 0;
474: #ifdef notnow
475: switch (t->c_cflag & CSIZE) { /* XXX */
476: case CS8:
477: #endif
478: cp->par[4] = BITS8; /* 8 bits of data */
479: #ifdef notnow
480: break;
481: case CS7:
482: cp->par[4] = BITS7; /* 7 bits of data */
483: break;
484: case CS6:
485: cp->par[4] = BITS6; /* 6 bits of data */
486: break;
487: case CS5:
488: cp->par[4] = BITS5; /* 5 bits of data */
489: break;
490: }
491: if ((t->c_cflag & PARENB) == 0) /* XXX */
492: #endif
493: cp->par[7] = VNOPARITY; /* no parity */
494: #ifdef notnow
495: else if (t->c_cflag&PARODD)
496: cp->par[7] = VODDP; /* odd parity */
497: else
498: cp->par[7] = VEVENP; /* even parity */
499: #endif
500: cp->par[5] = (t->c_cflag&CSTOPB) ? VSTOP2 : VSTOP1;
501: cp->par[6] = speedcode;
502: if (vcmd((int)vs->vs_nbr, (caddr_t)&cp->cmd) && wait)
503: error = tsleep((caddr_t)cp, TTIPRI | PCATCH, ttyout, 0);
504: if ((t->c_ospeed)==0) {
505: tp->t_cflag |= HUPCL;
506: vcmodem(tp->t_dev, VMOD_OFF);
507: }
508: splx(s);
509: return (error);
510: }
511:
512: /*
513: * VIOCX command response interrupt.
514: * For transmission, restart output to any active port.
515: * For all other commands, just clean up.
516: */
517: vxxint(vx, cp)
518: register int vx;
519: register struct vxcmd *cp;
520: {
521: register struct vxmit *vp;
522: register struct tty *tp, *tp0;
523: register struct vx_softc *vs;
524:
525: vs = &vx_softc[vx];
526: cp = (struct vxcmd *)((long *)cp-1);
527:
528: switch (cp->cmd&0xff00) {
529:
530: case VXC_LIDENT: /* initialization complete */
531: if (vs->vs_state == VXS_RESET) {
532: vxfnreset(vx, cp);
533: vinthandl(vx, ((V_BSY|RSPquals) << 8)|V_INTR);
534: }
535: cp->cmd++;
536: return;
537:
538: case VXC_XMITDTA:
539: case VXC_XMITIMM:
540: break;
541:
542: case VXC_LPARAX:
543: wakeup((caddr_t)cp);
544: /* fall thru... */
545: default: /* VXC_MDMCTL or VXC_FDTATOX */
546: vrelease(vs, cp);
547: if (vs->vs_state == VXS_RESET)
548: vinthandl(vx, ((V_BSY|RSPquals) << 8)|V_INTR);
549: return;
550: }
551: tp0 = &vx_tty[vx*16];
552: vp = (struct vxmit *)(cp->par + (cp->cmd & 07)*sizeof (struct vxmit));
553: for (; vp >= (struct vxmit *)cp->par; vp--) {
554: tp = tp0 + (vp->line & 017);
555: tp->t_state &= ~TS_BUSY;
556: if (tp->t_state & TS_FLUSH) {
557: tp->t_state &= ~TS_FLUSH;
558: wakeup((caddr_t)&tp->t_state);
559: } else
560: ndflush(&tp->t_outq, vp->bcount+1);
561: }
562: vrelease(vs, cp);
563: if (vs->vs_vers == VXV_NEW)
564: (*linesw[tp->t_line].l_start)(tp);
565: else {
566: tp0 = &vx_tty[vx*16 + vs->vs_hiport];
567: for(tp = &vx_tty[vx*16 + vs->vs_loport]; tp <= tp0; tp++)
568: (*linesw[tp->t_line].l_start)(tp);
569: if ((cp = nextcmd(vs)) != NULL) { /* command to send? */
570: vs->vs_xmtcnt++;
571: (void) vcmd(vx, (caddr_t)&cp->cmd);
572: }
573: }
574: vs->vs_xmtcnt--;
575: }
576:
577: /*
578: * Force out partial XMIT command after timeout
579: */
580: vxforce(vs)
581: register struct vx_softc *vs;
582: {
583: register struct vxcmd *cp;
584: int s;
585:
586: s = spl8();
587: if ((cp = nextcmd(vs)) != NULL) {
588: vs->vs_xmtcnt++;
589: (void) vcmd((int)vs->vs_nbr, (caddr_t)&cp->cmd);
590: }
591: splx(s);
592: }
593:
594: /*
595: * Start (restart) transmission on the given VX line.
596: */
597: vxstart(tp)
598: register struct tty *tp;
599: {
600: register short n;
601: register struct vx_softc *vs;
602: int s, port;
603:
604: s = spl8();
605: port = VXPORT(minor(tp->t_dev));
606: vs = (struct vx_softc *)tp->t_addr;
607: if ((tp->t_state&(TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) == 0) {
608: if (tp->t_outq.c_cc <= tp->t_lowat) {
609: if (tp->t_state&TS_ASLEEP) {
610: tp->t_state &= ~TS_ASLEEP;
611: wakeup((caddr_t)&tp->t_outq);
612: }
613: if (tp->t_wsel) {
614: selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
615: tp->t_wsel = 0;
616: tp->t_state &= ~TS_WCOLL;
617: }
618: }
619: if (tp->t_outq.c_cc == 0) {
620: splx(s);
621: return;
622: }
623: scope_out(3);
624: if (1 || !(tp->t_oflag&OPOST)) /* XXX */
625: n = ndqb(&tp->t_outq, 0);
626: else {
627: n = ndqb(&tp->t_outq, 0200);
628: if (n == 0) {
629: n = getc(&tp->t_outq);
630: timeout(ttrstrt, (caddr_t)tp, (n&0177)+6);
631: tp->t_state |= TS_TIMEOUT;
632: n = 0;
633: }
634: }
635: if (n) {
636: tp->t_state |= TS_BUSY;
637: vsetq(vs, port, (char *)tp->t_outq.c_cf, n);
638: }
639: }
640: splx(s);
641: }
642:
643: /*
644: * Stop output on a line.
645: */
646: vxstop(tp)
647: register struct tty *tp;
648: {
649: int s;
650:
651: s = spl8();
652: if (tp->t_state&TS_BUSY)
653: if ((tp->t_state&TS_TTSTOP) == 0)
654: tp->t_state |= TS_FLUSH;
655: splx(s);
656: }
657:
658: static int vxbbno = -1;
659: /*
660: * VIOCX Initialization. Makes free lists of command buffers.
661: * Resets all viocx's. Issues a LIDENT command to each
662: * viocx to establish interrupt vectors and logical port numbers.
663: */
664: vxinit(vx, wait)
665: register int vx;
666: int wait;
667: {
668: register struct vx_softc *vs;
669: register struct vxdevice *addr;
670: register struct vxcmd *cp;
671: register char *resp;
672: register int j;
673: char type, *typestring;
674:
675: vs = &vx_softc[vx];
676: addr = vs->vs_addr;
677: type = addr->v_ident;
678: vs->vs_vers = (type&VXT_NEW) ? VXV_NEW : VXV_OLD;
679: if (vs->vs_vers == VXV_NEW)
680: vs->vs_silosiz = addr->v_maxsilo;
681: switch (type) {
682:
683: case VXT_VIOCX:
684: case VXT_VIOCX|VXT_NEW:
685: typestring = "VIOC-X";
686: /* set soft carrier for printer ports */
687: for (j = 0; j < 16; j++)
688: if (vs->vs_softCAR & (1 << j) ||
689: addr->v_portyp[j] == VXT_PARALLEL) {
690: vs->vs_softCAR |= 1 << j;
691: addr->v_dcd |= 1 << j;
692: }
693: break;
694:
695: case VXT_PVIOCX:
696: case VXT_PVIOCX|VXT_NEW:
697: typestring = "VIOC-X (old connector panel)";
698: break;
699: case VXT_VIOCBOP: /* VIOC-BOP */
700: vs->vs_type = 1;
701: vs->vs_bop = ++vxbbno;
702: printf("VIOC-BOP no. %d at %x\n", vs->vs_bop, addr);
703: goto unsup;
704: default:
705: printf("vx%d: unknown type %x\n", vx, type);
706: unsup:
707: vxinfo[vx]->ui_alive = 0;
708: return;
709: }
710: vs->vs_nbr = vx; /* assign board number */
711: vs->vs_maxcmd = (vs->vs_vers == VXV_NEW) ? 24 : 4;
712: /*
713: * Initialize all cmd buffers by linking them
714: * into a free list.
715: */
716: for (j = 0; j < NVCXBUFS; j++) {
717: cp = &vs->vs_lst[j];
718: cp->c_fwd = &vs->vs_lst[j+1];
719: }
720: vs->vs_avail = &vs->vs_lst[0]; /* set idx to 1st free buf */
721: cp->c_fwd = (struct vxcmd *)0; /* mark last buf in free list */
722:
723: /*
724: * Establish the interrupt vectors and define the port numbers.
725: */
726: cp = vobtain(vs);
727: cp->cmd = VXC_LIDENT;
728: cp->par[0] = vs->vs_ivec; /* ack vector */
729: cp->par[1] = cp->par[0]+1; /* cmd resp vector */
730: cp->par[3] = cp->par[0]+2; /* unsol intr vector */
731: cp->par[4] = 15; /* max ports, no longer used */
732: cp->par[5] = 0; /* set 1st port number */
733: (void) vcmd(vx, (caddr_t)&cp->cmd);
734: if (!wait)
735: return;
736:
737: for (j = 0; cp->cmd == VXC_LIDENT && j < 4000000; j++)
738: ;
739: if (j >= 4000000)
740: printf("vx%d: didn't respond to LIDENT\n", vx);
741:
742: /* calculate address of response buffer */
743: resp = (char *)addr + (addr->v_rspoff&0x3fff);
744: if (resp[0] != 0 && (resp[0]&0177) != 3) {
745: vrelease(vs, cp); /* init failed */
746: return;
747: }
748: vs->vs_loport = cp->par[5];
749: vs->vs_hiport = cp->par[7];
750: printf("vx%d: %s%s, ports %d-%d\n", vx,
751: (vs->vs_vers == VXV_NEW) ? "" : "old ", typestring,
752: vs->vs_loport, vs->vs_hiport);
753: vrelease(vs, cp);
754: }
755:
756: /*
757: * Obtain a command buffer
758: */
759: struct vxcmd *
760: vobtain(vs)
761: register struct vx_softc *vs;
762: {
763: register struct vxcmd *p;
764: int s;
765:
766: s = spl8();
767: p = vs->vs_avail;
768: if (p == (struct vxcmd *)0) {
769: #ifdef VX_DEBUG
770: if (vxintr4&VXNOBUF)
771: vxintr4 &= ~VXNOBUF;
772: #endif
773: printf("vx%d: no buffers\n", vs->vs_nbr);
774: vxstreset(vs->vs_nbr);
775: splx(s);
776: return (vobtain(vs));
777: }
778: vs->vs_avail = p->c_fwd;
779: splx(s);
780: return ((struct vxcmd *)p);
781: }
782:
783: /*
784: * Release a command buffer
785: */
786: vrelease(vs, cp)
787: register struct vx_softc *vs;
788: register struct vxcmd *cp;
789: {
790: int s;
791:
792: #ifdef VX_DEBUG
793: if (vxintr4&VXNOBUF)
794: return;
795: #endif
796: s = spl8();
797: cp->c_fwd = vs->vs_avail;
798: vs->vs_avail = cp;
799: splx(s);
800: }
801:
802: struct vxcmd *
803: nextcmd(vs)
804: register struct vx_softc *vs;
805: {
806: register struct vxcmd *cp;
807: int s;
808:
809: s = spl8();
810: cp = vs->vs_build;
811: vs->vs_build = (struct vxcmd *)0;
812: splx(s);
813: return (cp);
814: }
815:
816: /*
817: * Assemble transmits into a multiple command;
818: * up to 8 transmits to 8 lines can be assembled together
819: * (on PVIOCX only).
820: */
821: vsetq(vs, line, addr, n)
822: register struct vx_softc *vs;
823: caddr_t addr;
824: {
825: register struct vxcmd *cp;
826: register struct vxmit *mp;
827:
828: /*
829: * Grab a new command buffer or append
830: * to the current one being built.
831: */
832: cp = vs->vs_build;
833: if (cp == (struct vxcmd *)0) {
834: cp = vobtain(vs);
835: vs->vs_build = cp;
836: cp->cmd = VXC_XMITDTA;
837: } else {
838: if ((cp->cmd & 07) == 07 || vs->vs_vers == VXV_NEW) {
839: printf("vx%d: setq overflow\n", vs-vx_softc);
840: vxstreset((int)vs->vs_nbr);
841: return;
842: }
843: cp->cmd++;
844: }
845: /*
846: * Select the next vxmit buffer and copy the
847: * characters into the buffer (if there's room
848: * and the device supports ``immediate mode'',
849: * or store an indirect pointer to the data.
850: */
851: mp = (struct vxmit *)(cp->par + (cp->cmd & 07)*sizeof (struct vxmit));
852: mp->bcount = n-1;
853: mp->line = line;
854: if (vs->vs_vers == VXV_NEW && n <= sizeof (mp->ostream)) {
855: cp->cmd = VXC_XMITIMM;
856: bcopy(addr, mp->ostream, (unsigned)n);
857: } else {
858: /* get system address of clist block */
859: addr = (caddr_t)vtoph((struct proc *)0, (unsigned)addr);
860: bcopy((caddr_t)&addr, mp->ostream, sizeof (addr));
861: }
862: /*
863: * We send the data immediately if a VIOCX,
864: * the command buffer is full, or if we've nothing
865: * currently outstanding. If we don't send it,
866: * set a timeout to force the data to be sent soon.
867: */
868: if (vs->vs_vers == VXV_NEW || (cp->cmd & 07) == 7 ||
869: vs->vs_xmtcnt == 0) {
870: vs->vs_xmtcnt++;
871: (void) vcmd((int)vs->vs_nbr, (char *)&cp->cmd);
872: vs->vs_build = 0;
873: } else
874: timeout(vxforce, (caddr_t)vs, 3);
875: }
876:
877: /*
878: * Write a command out to the VIOC
879: */
880: vcmd(vx, cmdad)
881: register int vx;
882: register caddr_t cmdad;
883: {
884: register struct vcmds *cp;
885: register struct vx_softc *vs = &vx_softc[vx];
886: int s;
887:
888: s = spl8();
889: /*
890: * When the vioc is resetting, don't process
891: * anything other than VXC_LIDENT commands.
892: */
893: if (vs->vs_state == VXS_RESET && cmdad != NULL) {
894: struct vxcmd *vcp = (struct vxcmd *)(cmdad-sizeof (vcp->c_fwd));
895:
896: if (vcp->cmd != VXC_LIDENT) {
897: vrelease(vs, vcp);
898: return (0);
899: }
900: }
901: cp = &vs->vs_cmds;
902: if (cmdad != (caddr_t)0) {
903: cp->cmdbuf[cp->v_fill] = cmdad;
904: if (++cp->v_fill >= VC_CMDBUFL)
905: cp->v_fill = 0;
906: if (cp->v_fill == cp->v_empty) {
907: printf("vx%d: cmd q overflow\n", vx);
908: vxstreset(vx);
909: splx(s);
910: return (0);
911: }
912: cp->v_cmdsem++;
913: }
914: if (cp->v_cmdsem && cp->v_curcnt < vs->vs_maxcmd) {
915: cp->v_cmdsem--;
916: cp->v_curcnt++;
917: vinthandl(vx, ((V_BSY|CMDquals) << 8)|V_INTR);
918: }
919: splx(s);
920: return (1);
921: }
922:
923: /*
924: * VIOC acknowledge interrupt. The VIOC has received the new
925: * command. If no errors, the new command becomes one of 16 (max)
926: * current commands being executed.
927: */
928: vackint(vx)
929: register vx;
930: {
931: register struct vxdevice *vp;
932: register struct vcmds *cp;
933: struct vx_softc *vs;
934: int s;
935:
936: scope_out(5);
937: vs = &vx_softc[vx];
938: if (vs->vs_type) /* Its a BOP */
939: return;
940: s = spl8();
941: vp = vs->vs_addr;
942: cp = &vs->vs_cmds;
943: if (vp->v_vcid&V_ERR) {
944: register char *resp;
945: register i;
946:
947: printf("vx%d: ackint error type %x v_dcd %x\n", vx,
948: vp->v_vcid & 07, vp->v_dcd & 0xff);
949: resp = (char *)vs->vs_mricmd;
950: for (i = 0; i < 16; i++)
951: printf("%x ", resp[i]&0xff);
952: printf("\n");
953: splx(s);
954: vxstreset(vx);
955: return;
956: }
957: if ((vp->v_hdwre&017) == CMDquals) {
958: #ifdef VX_DEBUG
959: if (vxintr4 & VXERR4) { /* causes VIOC INTR ERR 4 */
960: struct vxcmd *cp1, *cp0;
961:
962: cp0 = (struct vxcmd *)
963: ((caddr_t)cp->cmdbuf[cp->v_empty]-sizeof (cp0->c_fwd));
964: if (cp0->cmd == VXC_XMITDTA || cp0->cmd == VXC_XMITIMM) {
965: cp1 = vobtain(vs);
966: *cp1 = *cp0;
967: vxintr4 &= ~VXERR4;
968: (void) vcmd(vx, &cp1->cmd);
969: }
970: }
971: #endif
972: cp->v_curcmd[vp->v_vcid & VCMDLEN-1] = cp->cmdbuf[cp->v_empty];
973: if (++cp->v_empty >= VC_CMDBUFL)
974: cp->v_empty = 0;
975: }
976: if (++cp->v_itrempt >= VC_IQLEN)
977: cp->v_itrempt = 0;
978: vintempt(vx);
979: splx(s);
980: (void) vcmd(vx, (caddr_t)0); /* queue next cmd, if any */
981: }
982:
983: /*
984: * Command Response interrupt. The Vioc has completed
985: * a command. The command may now be returned to
986: * the appropriate device driver.
987: */
988: vcmdrsp(vx)
989: register vx;
990: {
991: register struct vxdevice *vp;
992: register struct vcmds *cp;
993: register caddr_t cmd;
994: register struct vx_softc *vs;
995: register char *resp;
996: register k;
997: register int s;
998:
999: scope_out(6);
1000: vs = &vx_softc[vx];
1001: if (vs->vs_type) { /* Its a BOP */
1002: printf("vx%d: vcmdrsp interrupt\n", vx);
1003: return;
1004: }
1005: s = spl8();
1006: vp = vs->vs_addr;
1007: cp = &vs->vs_cmds;
1008: resp = (char *)vp + (vp->v_rspoff&0x7fff);
1009: if (((k = resp[1])&V_UNBSY) == 0) {
1010: printf("vx%d: cmdresp debug\n", vx);
1011: splx(s);
1012: vxstreset(vx);
1013: return;
1014: }
1015: k &= VCMDLEN-1;
1016: cmd = cp->v_curcmd[k];
1017: cp->v_curcmd[k] = (caddr_t)0;
1018: cp->v_curcnt--;
1019: k = *((short *)&resp[4]); /* cmd operation code */
1020: if ((k&0xff00) == VXC_LIDENT) /* want hiport number */
1021: for (k = 0; k < VRESPLEN; k++)
1022: cmd[k] = resp[k+4];
1023: resp[1] = 0;
1024: vxxint(vx, (struct vxcmd *)cmd);
1025: if (vs->vs_state == VXS_READY)
1026: vinthandl(vx, ((V_BSY|RSPquals) << 8)|V_INTR);
1027: splx(s);
1028: }
1029:
1030: /*
1031: * Unsolicited interrupt.
1032: */
1033: vunsol(vx)
1034: register vx;
1035: {
1036: register struct vxdevice *vp;
1037: struct vx_softc *vs;
1038: int s;
1039:
1040: scope_out(1);
1041: vs = &vx_softc[vx];
1042: if (vs->vs_type) { /* Its a BOP */
1043: printf("vx%d: vunsol from BOP\n", vx);
1044: return;
1045: }
1046: s = spl8();
1047: vp = vs->vs_addr;
1048: if (vp->v_uqual&V_UNBSY) {
1049: vxrint(vx);
1050: vinthandl(vx, ((V_BSY|UNSquals) << 8)|V_INTR);
1051: #ifdef notdef
1052: } else {
1053: printf("vx%d: unsolicited interrupt error\n", vx);
1054: splx(s);
1055: vxstreset(vx);
1056: #endif
1057: }
1058: splx(s);
1059: }
1060:
1061: /*
1062: * Enqueue an interrupt.
1063: */
1064: vinthandl(vx, item)
1065: register int vx;
1066: register item;
1067: {
1068: register struct vcmds *cp;
1069: int empty;
1070:
1071: cp = &vx_softc[vx].vs_cmds;
1072: empty = (cp->v_itrfill == cp->v_itrempt);
1073: cp->v_itrqueu[cp->v_itrfill] = item;
1074: if (++cp->v_itrfill >= VC_IQLEN)
1075: cp->v_itrfill = 0;
1076: if (cp->v_itrfill == cp->v_itrempt) {
1077: printf("vx%d: interrupt q overflow\n", vx);
1078: vxstreset(vx);
1079: } else if (empty)
1080: vintempt(vx);
1081: }
1082:
1083: vintempt(vx)
1084: int vx;
1085: {
1086: register struct vcmds *cp;
1087: register struct vxdevice *vp;
1088: register struct vx_softc *vs;
1089: register short item;
1090: register short *intr;
1091:
1092: vs = &vx_softc[vx];
1093: vp = vs->vs_addr;
1094: if (vp->v_vioc&V_BSY)
1095: return;
1096: cp = &vs->vs_cmds;
1097: if (cp->v_itrempt == cp->v_itrfill)
1098: return;
1099: item = cp->v_itrqueu[cp->v_itrempt];
1100: intr = (short *)&vp->v_vioc;
1101: switch ((item >> 8)&03) {
1102:
1103: case CMDquals: { /* command */
1104: int phys;
1105:
1106: if (cp->v_empty == cp->v_fill || vp->v_vcbsy&V_BSY)
1107: break;
1108: vs->vs_mricmd = (caddr_t)cp->cmdbuf[cp->v_empty];
1109: phys = vtoph((struct proc *)0,
1110: (unsigned)cp->cmdbuf[cp->v_empty]);
1111: vp->v_vcp[0] = ((short *)&phys)[0];
1112: vp->v_vcp[1] = ((short *)&phys)[1];
1113: vp->v_vcbsy = V_BSY;
1114: *intr = item;
1115: scope_out(4);
1116: break;
1117: }
1118:
1119: case RSPquals: /* command response */
1120: *intr = item;
1121: scope_out(7);
1122: break;
1123:
1124: case UNSquals: /* unsolicited interrupt */
1125: vp->v_uqual = 0;
1126: *intr = item;
1127: scope_out(2);
1128: break;
1129: }
1130: }
1131:
1132: /*
1133: * Start a reset on a vioc after error (hopefully)
1134: */
1135: vxstreset(vx)
1136: register int vx;
1137: {
1138: register struct vx_softc *vs;
1139: register struct vxdevice *vp;
1140: register struct vxcmd *cp;
1141: register int j;
1142: extern int vxinreset();
1143: int s;
1144:
1145: vs = &vx_softc[vx];
1146: s = spl8();
1147: if (vs->vs_state == VXS_RESET) { /* avoid recursion */
1148: splx(s);
1149: return;
1150: }
1151: vp = vs->vs_addr;
1152: /*
1153: * Zero out the vioc structures, mark the vioc as being
1154: * reset, reinitialize the free command list, reset the vioc
1155: * and start a timer to check on the progress of the reset.
1156: */
1157: bzero((caddr_t)&vs->vs_zero,
1158: (unsigned)((caddr_t)(vs + 1) - (caddr_t)&vs->vs_zero));
1159:
1160: /*
1161: * Setting VXS_RESET prevents others from issuing
1162: * commands while allowing currently queued commands to
1163: * be passed to the VIOC.
1164: */
1165: vs->vs_state = VXS_RESET;
1166: /* init all cmd buffers */
1167: for (j = 0; j < NVCXBUFS; j++) {
1168: cp = &vs->vs_lst[j];
1169: cp->c_fwd = &vs->vs_lst[j+1];
1170: }
1171: vs->vs_avail = &vs->vs_lst[0];
1172: cp->c_fwd = (struct vxcmd *)0;
1173: printf("vx%d: reset...", vx);
1174: vp->v_fault = 0;
1175: vp->v_vioc = V_BSY;
1176: vp->v_hdwre = V_RESET; /* generate reset interrupt */
1177: timeout(vxinreset, (caddr_t)vx, hz*5);
1178: splx(s);
1179: }
1180:
1181: /* continue processing a reset on a vioc after an error (hopefully) */
1182: vxinreset(vx)
1183: int vx;
1184: {
1185: register struct vxdevice *vp;
1186: int s = spl8();
1187:
1188: vp = vx_softc[vx].vs_addr;
1189: /*
1190: * See if the vioc has reset.
1191: */
1192: if (vp->v_fault != VXF_READY) {
1193: printf(" vxreset failed\n");
1194: splx(s);
1195: return;
1196: }
1197: /*
1198: * Send a LIDENT to the vioc and mess with carrier flags
1199: * on parallel printer ports.
1200: */
1201: vxinit(vx, 0);
1202: splx(s);
1203: }
1204:
1205: /*
1206: * Finish the reset on the vioc after an error (hopefully).
1207: *
1208: * Restore modem control, parameters and restart output.
1209: * Since the vioc can handle no more then 24 commands at a time
1210: * and we could generate as many as 48 commands, we must do this in
1211: * phases, issuing no more then 16 commands at a time.
1212: */
1213: vxfnreset(vx, cp)
1214: register int vx;
1215: register struct vxcmd *cp;
1216: {
1217: register struct vx_softc *vs;
1218: register struct vxdevice *vp;
1219: register struct tty *tp, *tp0;
1220: register int i;
1221: #ifdef notdef
1222: register int on;
1223: #endif
1224: extern int vxrestart();
1225: int s = spl8();
1226:
1227: vs = &vx_softc[vx];
1228: vrelease(vs, cp);
1229: vs->vs_state = VXS_READY;
1230:
1231: vp = vs->vs_addr;
1232: vp->v_vcid = 0;
1233:
1234: /*
1235: * Restore modem information and control.
1236: */
1237: tp0 = &vx_tty[vx*16];
1238: for (i = vs->vs_loport; i <= vs->vs_hiport; i++) {
1239: tp = tp0 + i;
1240: if (tp->t_state&(TS_ISOPEN|TS_WOPEN)) {
1241: tp->t_state &= ~TS_CARR_ON;
1242: vcmodem(tp->t_dev, VMOD_ON);
1243: if (tp->t_state&TS_CARR_ON)
1244: (void)(*linesw[tp->t_line].l_modem)(tp, 1);
1245: else if (tp->t_state & TS_ISOPEN)
1246: (void)(*linesw[tp->t_line].l_modem)(tp, 0);
1247: }
1248: #ifdef notdef
1249: /*
1250: * If carrier has changed while we were resetting,
1251: * take appropriate action.
1252: */
1253: on = vp->v_dcd & 1<<i;
1254: if (on && (tp->t_state&TS_CARR_ON) == 0)
1255: (void)(*linesw[tp->t_line].l_modem)(tp, 1);
1256: else if (!on && tp->t_state&TS_CARR_ON)
1257: (void)(*linesw[tp->t_line].l_modem)(tp, 0);
1258: #endif
1259: }
1260: vs->vs_state = VXS_RESET;
1261: timeout(vxrestart, (caddr_t)vx, hz);
1262: splx(s);
1263: }
1264:
1265: /*
1266: * Restore a particular aspect of the VIOC.
1267: */
1268: vxrestart(vx)
1269: int vx;
1270: {
1271: register struct tty *tp, *tp0;
1272: register struct vx_softc *vs;
1273: register int i, count;
1274: int s = spl8();
1275:
1276: count = vx >> 8;
1277: vx &= 0xff;
1278: vs = &vx_softc[vx];
1279: vs->vs_state = VXS_READY;
1280: tp0 = &vx_tty[vx*16];
1281: for (i = vs->vs_loport; i <= vs->vs_hiport; i++) {
1282: tp = tp0 + i;
1283: if (count != 0) {
1284: tp->t_state &= ~(TS_BUSY|TS_TIMEOUT);
1285: if (tp->t_state&(TS_ISOPEN|TS_WOPEN))
1286: vxstart(tp); /* restart pending output */
1287: } else {
1288: if (tp->t_state&(TS_WOPEN|TS_ISOPEN))
1289: vxcparam(tp, &tp->t_termios, 0);
1290: }
1291: }
1292: if (count == 0) {
1293: vs->vs_state = VXS_RESET;
1294: timeout(vxrestart, (caddr_t)(vx + 1*256), hz);
1295: } else
1296: printf(" vx reset done\n");
1297: splx(s);
1298: }
1299:
1300: vxreset(dev)
1301: dev_t dev;
1302: {
1303:
1304: vxstreset((int)VXUNIT(minor(dev))); /* completes asynchronously */
1305: }
1306:
1307: #ifdef VX_DEBUG
1308: vxfreset(vx)
1309: register int vx;
1310: {
1311: struct vba_device *vi;
1312:
1313: if ((unsigned)vx > NVX || (vi = vxinfo[vx]) == 0 || vi->ui_addr == 0)
1314: return (ENODEV);
1315: vx_softc[vx].vs_state = VXS_READY;
1316: vxstreset(vx);
1317: return (0); /* completes asynchronously */
1318: }
1319: #endif
1320:
1321: vcmodem(dev, flag)
1322: dev_t dev;
1323: {
1324: struct tty *tp;
1325: register struct vxcmd *cp;
1326: register struct vx_softc *vs;
1327: register struct vxdevice *kp;
1328: register port;
1329: int unit;
1330:
1331: unit = minor(dev);
1332: tp = &vx_tty[unit];
1333: vs = (struct vx_softc *)tp->t_addr;
1334: if (vs->vs_state != VXS_READY)
1335: return;
1336: cp = vobtain(vs);
1337: kp = vs->vs_addr;
1338:
1339: port = VXPORT(unit);
1340: /*
1341: * Issue MODEM command
1342: */
1343: cp->cmd = VXC_MDMCTL;
1344: if (flag == VMOD_ON) {
1345: if (vs->vs_softCAR & (1 << port)) {
1346: cp->par[0] = V_MANUAL | V_DTR_ON | V_RTS;
1347: kp->v_dcd |= (1 << port);
1348: } else
1349: cp->par[0] = V_AUTO | V_DTR_ON;
1350: } else
1351: cp->par[0] = V_DTR_OFF;
1352: cp->par[1] = port;
1353: (void) vcmd((int)vs->vs_nbr, (caddr_t)&cp->cmd);
1354: if ((kp->v_dcd | vs->vs_softCAR) & (1 << port) && flag == VMOD_ON)
1355: tp->t_state |= TS_CARR_ON;
1356: }
1357:
1358: /*
1359: * VCMINTR called when an unsolicited interrupt occurs signaling
1360: * some change of modem control state.
1361: */
1362: vcmintr(vx)
1363: register vx;
1364: {
1365: register struct vxdevice *kp;
1366: register struct tty *tp;
1367: register port;
1368: register struct vx_softc *vs;
1369:
1370: vs = &vx_softc[vx];
1371: kp = vs->vs_addr;
1372: port = kp->v_usdata[0] & 017;
1373: tp = &vx_tty[vx*16+port];
1374:
1375: if (kp->v_ustat & DCD_ON)
1376: (void)(*linesw[tp->t_line].l_modem)(tp, 1);
1377: else if ((kp->v_ustat & DCD_OFF) &&
1378: ((vs->vs_softCAR & (1 << port))) == 0 &&
1379: (*linesw[tp->t_line].l_modem)(tp, 0) == 0) {
1380: register struct vcmds *cp;
1381: register struct vxcmd *cmdp;
1382:
1383: /* clear all pending transmits */
1384: if (tp->t_state&(TS_BUSY|TS_FLUSH) &&
1385: vs->vs_vers == VXV_NEW) {
1386: int i, cmdfound = 0;
1387:
1388: cp = &vs->vs_cmds;
1389: for (i = cp->v_empty; i != cp->v_fill; ) {
1390: cmdp = (struct vxcmd *)((long *)cp->cmdbuf[i]-1);
1391: if ((cmdp->cmd == VXC_XMITDTA ||
1392: cmdp->cmd == VXC_XMITIMM) &&
1393: ((struct vxmit *)cmdp->par)->line == port) {
1394: cmdfound++;
1395: cmdp->cmd = VXC_FDTATOX;
1396: cmdp->par[1] = port;
1397: }
1398: if (++i >= VC_CMDBUFL)
1399: i = 0;
1400: }
1401: if (cmdfound)
1402: tp->t_state &= ~(TS_BUSY|TS_FLUSH);
1403: /* cmd is already in vioc, have to flush it */
1404: else {
1405: cmdp = vobtain(vs);
1406: cmdp->cmd = VXC_FDTATOX;
1407: cmdp->par[1] = port;
1408: (void) vcmd(vx, (caddr_t)&cmdp->cmd);
1409: }
1410: }
1411: } else if ((kp->v_ustat&BRK_CHR) && (tp->t_state&TS_ISOPEN)) {
1412: (*linesw[tp->t_line].l_rint)(TTY_FE, tp);
1413: return;
1414: }
1415: }
1416: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.