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