![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_dmv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / vax / if|
Return to if_dmv.c CVS log | Up to [Net/2] / Net2 / arch / vax / if |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)if_dmv.c 7.12 (Berkeley) 12/16/90
34: */
35:
36: /*
37: * DMV-11 Driver
38: *
39: * Qbus Sync DDCMP interface - DMV operated in full duplex, point to point mode
40: *
41: * Written by Bob Kridle of Mt Xinu
42: * starting from if_dmc.c version 6.12 dated 4/23/86
43: */
44:
45: #include "dmv.h"
46: #if NDMV > 0
47:
48: #include "sys/param.h"
49: #include "sys/systm.h"
50: #include "sys/mbuf.h"
51: #include "sys/buf.h"
52: #include "sys/ioctl.h" /* must precede tty.h */
53: #include "sys/tty.h"
54: #include "sys/protosw.h"
55: #include "sys/socket.h"
56: #include "sys/syslog.h"
57: #include "sys/vmmac.h"
58: #include "sys/errno.h"
59: #include "sys/time.h"
60: #include "sys/kernel.h"
61:
62: #include "net/if.h"
63: #include "net/netisr.h"
64: #include "net/route.h"
65:
66: #ifdef INET
67: #include "netinet/in.h"
68: #include "netinet/in_systm.h"
69: #include "netinet/in_var.h"
70: #include "netinet/ip.h"
71: #endif
72:
73: #include "../include/cpu.h"
74: #include "../include/mtpr.h"
75: #include "../include/pte.h"
76: #include "../uba/ubareg.h"
77: #include "../uba/ubavar.h"
78: #include "if_uba.h"
79: #include "if_dmv.h"
80:
81: int dmv_timeout = 8; /* timeout value */
82:
83: /*
84: * Driver information for auto-configuration stuff.
85: */
86: int dmvprobe(), dmvattach(), dmvinit(), dmvioctl();
87: int dmvoutput(), dmvreset(), dmvtimeout();
88: struct uba_device *dmvinfo[NDMV];
89: u_short dmvstd[] = { 0 };
90: struct uba_driver dmvdriver =
91: { dmvprobe, 0, dmvattach, 0, dmvstd, "dmv", dmvinfo };
92:
93: /*
94: * Don't really know how many buffers/commands can be queued to a DMV-11.
95: * Manual doesn't say... Perhaps we can look at a DEC driver some day.
96: * These numbers ame from DMC/DMR driver.
97: */
98: #define NRCV 5
99: #define NXMT 3
100: #define NCMDS (NRCV+NXMT+4) /* size of command queue */
101:
102: #ifdef DEBUG
103: #define printd(f) if (sc->sc_if.if_flags & IFF_DEBUG) \
104: printf("DMVDEBUG: dmv%d: ", unit), printf(f)
105: #else
106: #define printd(f) /* nil */
107: #endif
108:
109: /* error reporting intervals */
110:
111: #define DMV_RPRTE 1
112: #define DMV_RPTTE 1
113: #define DMV_RPSTE 1
114: #define DMV_RPNXM 1
115: #define DMV_RPMODD 1
116: #define DMV_RPQOVF 1
117: #define DMV_RPCXRL 1
118:
119: /* number of errors to accept before trying a reset */
120: #define DMV_RPUNKNOWN 10
121:
122: struct dmv_command {
123: u_char qp_mask; /* Which registers to set up */
124: #define QP_TRIB 0x01
125: #define QP_SEL4 0x02
126: #define QP_SEL6 0x04
127: #define QP_SEL10 0x08
128: u_char qp_cmd;
129: u_char qp_tributary;
130: u_short qp_sel4;
131: u_short qp_sel6;
132: u_short qp_sel10;
133: struct dmv_command *qp_next; /* next command on queue */
134: };
135:
136: #define qp_lowbufaddr qp_
137:
138: struct dmvbufs {
139: int ubinfo; /* from uballoc */
140: short cc; /* buffer size */
141: short flags; /* access control */
142: };
143:
144: #define DBUF_OURS 0 /* buffer is available */
145: #define DBUF_DMVS 1 /* buffer claimed by somebody */
146: #define DBUF_XMIT 4 /* transmit buffer */
147: #define DBUF_RCV 8 /* receive buffer */
148:
149:
150: /*
151: * DMV software status per interface.
152: *
153: * Each interface is referenced by a network interface structure,
154: * sc_if, which the routing code uses to locate the interface.
155: * This structure contains the output queue for the interface, its address, ...
156: * We also have, for each interface, a set of 7 UBA interface structures
157: * for each, which
158: * contain information about the UNIBUS resources held by the interface:
159: * map registers, buffered data paths, etc. Information is cached in this
160: * structure for use by the if_uba.c routines in running the interface
161: * efficiently.
162: */
163: struct dmv_softc {
164: struct ifnet sc_if; /* network-visible interface */
165: short sc_oused; /* output buffers currently in use */
166: short sc_iused; /* input buffers given to DMV */
167: short sc_flag; /* flags */
168: short sc_ipl; /* interrupt priority */
169: int sc_ubinfo; /* UBA mapping info for base table */
170: int sc_errors[8]; /* error counters */
171: #define sc_rte sc_errors[0] /* receive threshhold error */
172: #define sc_xte sc_errors[1] /* xmit threshhold error */
173: #define sc_ste sc_errors[2] /* select threshhold error */
174: #define sc_nxm sc_errors[3] /* non-existant memory */
175: #define sc_modd sc_errors[4] /* modem disconnect */
176: #define sc_qovf sc_errors[5] /* command/response queue overflow */
177: #define sc_cxrl sc_errors[6] /* carrier loss */
178: #define sc_unknown sc_errors[7] /* other errors - look in DMV manual */
179: struct dmvbufs sc_rbufs[NRCV]; /* receive buffer info */
180: struct dmvbufs sc_xbufs[NXMT]; /* transmit buffer info */
181: struct ifubinfo sc_ifuba; /* UNIBUS resources */
182: struct ifrw sc_ifr[NRCV]; /* UNIBUS receive buffer maps */
183: struct ifxmt sc_ifw[NXMT]; /* UNIBUS receive buffer maps */
184: /* command queue stuff */
185: struct dmv_command sc_cmdbuf[NCMDS];
186: struct dmv_command *sc_qhead; /* head of command queue */
187: struct dmv_command *sc_qtail; /* tail of command queue */
188: struct dmv_command *sc_qactive; /* command in progress */
189: struct dmv_command *sc_qfreeh; /* head of list of free cmd buffers */
190: struct dmv_command *sc_qfreet; /* tail of list of free cmd buffers */
191: /* end command queue stuff */
192: } dmv_softc[NDMV];
193:
194: /* flags */
195: #define DMV_RESTART 0x01 /* software restart in progress */
196: #define DMV_ONLINE 0x02 /* device managed to transmit */
197: #define DMV_RUNNING 0x04 /* device initialized */
198:
199:
200: /* queue manipulation macros */
201: #define QUEUE_AT_HEAD(qp, head, tail) \
202: (qp)->qp_next = (head); \
203: (head) = (qp); \
204: if ((tail) == (struct dmv_command *) 0) \
205: (tail) = (head)
206:
207: #define QUEUE_AT_TAIL(qp, head, tail) \
208: if ((tail)) \
209: (tail)->qp_next = (qp); \
210: else \
211: (head) = (qp); \
212: (qp)->qp_next = (struct dmv_command *) 0; \
213: (tail) = (qp)
214:
215: #define DEQUEUE(head, tail) \
216: (head) = (head)->qp_next;\
217: if ((head) == (struct dmv_command *) 0)\
218: (tail) = (head)
219:
220: dmvprobe(reg, ui)
221: caddr_t reg;
222: struct uba_device *ui;
223: {
224: register int br, cvec;
225: register struct dmvdevice *addr = (struct dmvdevice *)reg;
226: register int i;
227:
228: #ifdef lint
229: br = 0; cvec = br; br = cvec;
230: dmvrint(0); dmvxint(0);
231: #endif
232: addr->bsel1 = DMV_MCLR;
233: for (i = 100000; i && (addr->bsel1 & DMV_RUN) == 0; i--)
234: ;
235: if ((addr->bsel1 & DMV_RUN) == 0) {
236: printf("dmvprobe: can't start device\n" );
237: return (0);
238: }
239: if ((addr->bsel4 != 033) || (addr->bsel6 != 0305))
240: {
241: printf("dmvprobe: device init failed, bsel4=%o, bsel6=%o\n",
242: addr->bsel4, addr->bsel6);
243: return (0);
244: }
245: (void) spl6();
246: addr->bsel0 = DMV_RQI|DMV_IEI|DMV_IEO;
247: DELAY(1000000);
248: dmv_softc[ui->ui_unit].sc_ipl = br = qbgetpri();
249: addr->bsel1 = DMV_MCLR;
250: for (i = 100000; i && (addr->bsel1 & DMV_RUN) == 0; i--)
251: ;
252: return (sizeof(struct dmvdevice));
253: }
254:
255: /*
256: * Interface exists: make available by filling in network interface
257: * record. System will initialize the interface when it is ready
258: * to accept packets.
259: */
260: dmvattach(ui)
261: register struct uba_device *ui;
262: {
263: register struct dmv_softc *sc = &dmv_softc[ui->ui_unit];
264:
265: sc->sc_if.if_unit = ui->ui_unit;
266: sc->sc_if.if_name = "dmv";
267: sc->sc_if.if_mtu = DMVMTU;
268: sc->sc_if.if_init = dmvinit;
269: sc->sc_if.if_output = dmvoutput;
270: sc->sc_if.if_ioctl = dmvioctl;
271: sc->sc_if.if_reset = dmvreset;
272: sc->sc_if.if_watchdog = dmvtimeout;
273: sc->sc_if.if_flags = IFF_POINTOPOINT;
274: sc->sc_ifuba.iff_flags = UBA_CANTWAIT;
275:
276: if_attach(&sc->sc_if);
277: }
278:
279: /*
280: * Reset of interface after UNIBUS reset.
281: * If interface is on specified UBA, reset its state.
282: */
283: dmvreset(unit, uban)
284: int unit, uban;
285: {
286: register struct uba_device *ui;
287: register struct dmv_softc *sc = &dmv_softc[unit];
288:
289: if (unit >= NDMV || (ui = dmvinfo[unit]) == 0 || ui->ui_alive == 0 ||
290: ui->ui_ubanum != uban)
291: return;
292: printf(" dmv%d", unit);
293: sc->sc_flag = 0;
294: sc->sc_if.if_flags &= ~IFF_RUNNING;
295: dmvinit(unit);
296: }
297:
298: /*
299: * Initialization of interface; reinitialize UNIBUS usage.
300: */
301: dmvinit(unit)
302: int unit;
303: {
304: register struct dmv_softc *sc = &dmv_softc[unit];
305: register struct uba_device *ui = dmvinfo[unit];
306: register struct dmvdevice *addr;
307: register struct ifnet *ifp = &sc->sc_if;
308: register struct ifrw *ifrw;
309: register struct ifxmt *ifxp;
310: register struct dmvbufs *rp;
311: register struct dmv_command *qp;
312: struct ifaddr *ifa;
313: int base;
314: int s;
315:
316: addr = (struct dmvdevice *)ui->ui_addr;
317:
318: /*
319: * Check to see that an address has been set
320: * (both local and destination for an address family).
321: */
322: for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next)
323: if (ifa->ifa_addr->sa_family &&
324: ifa->ifa_addr->sa_family != AF_LINK &&
325: ifa->ifa_dstaddr && ifa->ifa_dstaddr->sa_family)
326: break;
327: if (ifa == (struct ifaddr *) 0)
328: return;
329:
330: if ((addr->bsel1&DMV_RUN) == 0) {
331: log(LOG_CRIT, "dmvinit: dmv%d not running\n", unit);
332: ifp->if_flags &= ~IFF_UP;
333: return;
334: }
335: printd(("dmvinit\n"));
336: /* initialize UNIBUS resources */
337: sc->sc_iused = sc->sc_oused = 0;
338: if ((ifp->if_flags & IFF_RUNNING) == 0) {
339: if (if_ubaminit(
340: &sc->sc_ifuba,
341: ui->ui_ubanum,
342: sizeof(struct dmv_header),
343: (int)btoc(DMVMTU),
344: sc->sc_ifr,
345: NRCV,
346: sc->sc_ifw,
347: NXMT
348: ) == 0) {
349: log(LOG_CRIT, "dmvinit: dmv%d can't allocate uba resources\n", unit);
350: ifp->if_flags &= ~IFF_UP;
351: return;
352: }
353: ifp->if_flags |= IFF_RUNNING;
354: }
355: /*
356: * Limit packets enqueued until we see if we're on the air.
357: */
358: ifp->if_snd.ifq_maxlen = 3;
359:
360:
361: /* initialize buffer pool */
362: /* receives */
363: ifrw = &sc->sc_ifr[0];
364: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
365: rp->ubinfo = UBAI_ADDR(ifrw->ifrw_info);
366: rp->cc = DMVMTU + sizeof (struct dmv_header);
367: rp->flags = DBUF_OURS|DBUF_RCV;
368: ifrw++;
369: }
370: /* transmits */
371: ifxp = &sc->sc_ifw[0];
372: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
373: rp->ubinfo = UBAI_ADDR(ifxp->ifw_info);
374: rp->cc = 0;
375: rp->flags = DBUF_OURS|DBUF_XMIT;
376: ifxp++;
377: }
378:
379: /* set up command queues */
380: sc->sc_qfreeh = sc->sc_qfreet
381: = sc->sc_qhead = sc->sc_qtail = sc->sc_qactive =
382: (struct dmv_command *)0;
383: /* set up free command buffer list */
384: for (qp = &sc->sc_cmdbuf[0]; qp < &sc->sc_cmdbuf[NCMDS]; qp++) {
385: QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
386: }
387: if(sc->sc_flag & DMV_RUNNING)
388: dmvload( sc, DMV_CNTRLI, (QP_TRIB|QP_SEL6), 1, 0, DMV_REQHS,0);
389: else
390: dmvload( sc, DMV_CNTRLI, (QP_TRIB|QP_SEL6), 1, 0, DMV_ESTTRIB,0);
391: dmvload( sc, DMV_CNTRLI, (QP_TRIB|QP_SEL6), 1, 0, DMV_REQSUS,0);
392: sc->sc_flag |= (DMV_RESTART|DMV_RUNNING);
393: sc->sc_flag &= ~DMV_ONLINE;
394: addr->bsel0 |= DMV_IEO;
395: }
396:
397: /*
398: * Start output on interface. Get another datagram
399: * to send from the interface queue and map it to
400: * the interface before starting output.
401: *
402: * Must be called at spl 5
403: */
404: dmvstart(dev)
405: dev_t dev;
406: {
407: int unit = minor(dev);
408: register struct dmv_softc *sc = &dmv_softc[unit];
409: struct mbuf *m;
410: register struct dmvbufs *rp;
411: register int n;
412:
413: /*
414: * Dequeue up to NXMT requests and map them to the UNIBUS.
415: * If no more requests, or no dmv buffers available, just return.
416: */
417: printd(("dmvstart\n"));
418: n = 0;
419: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++ ) {
420: /* find an available buffer */
421: if ((rp->flags & DBUF_DMVS) == 0) {
422: IF_DEQUEUE(&sc->sc_if.if_snd, m);
423: if (m == 0)
424: return;
425: /* mark it dmvs */
426: rp->flags |= (DBUF_DMVS);
427: /*
428: * Have request mapped to UNIBUS for transmission
429: * and start the output.
430: */
431: rp->cc = if_ubaput(&sc->sc_ifuba, &sc->sc_ifw[n], m);
432: if (++sc->sc_oused == 1)
433: sc->sc_if.if_timer = dmv_timeout;
434: dmvload(
435: sc,
436: DMV_BACCX,
437: QP_TRIB|QP_SEL4|QP_SEL6|QP_SEL10,
438: 1,
439: rp->ubinfo,
440: (rp->ubinfo>>16)&0x3f,
441: rp->cc
442: );
443: }
444: n++;
445: }
446: }
447:
448: /*
449: * Utility routine to load the DMV device registers.
450: */
451: dmvload(sc, cmd, mask, tributary, sel4, sel6, sel10)
452: register struct dmv_softc *sc;
453: u_char cmd, tributary, mask;
454: u_short sel4, sel6, sel10;
455: {
456: register struct dmvdevice *addr;
457: register int unit, sps;
458: register struct dmv_command *qp;
459:
460: unit = sc - dmv_softc;
461: printd(("dmvload: cmd=%x mask=%x trib=%x sel4=%x sel6=%x sel10=%x\n",
462: (unsigned) cmd,
463: (unsigned) mask,
464: (unsigned) tributary,
465: (unsigned) sel4,
466: (unsigned) sel6,
467: (unsigned) sel10
468: ));
469: addr = (struct dmvdevice *)dmvinfo[unit]->ui_addr;
470: sps = spl5();
471:
472: /* grab a command buffer from the free list */
473: if ((qp = sc->sc_qfreeh) == (struct dmv_command *)0)
474: panic("dmv command queue overflow");
475: DEQUEUE(sc->sc_qfreeh, sc->sc_qfreet);
476:
477: /* fill in requested info */
478: qp->qp_cmd = cmd;
479: qp->qp_mask = mask;
480: qp->qp_tributary = tributary;
481: qp->qp_sel4 = sel4;
482: qp->qp_sel6 = sel6;
483: qp->qp_sel10 = sel10;
484:
485: if (sc->sc_qactive) { /* command in progress */
486: if (cmd == DMV_BACCR) { /* supply read buffers first */
487: QUEUE_AT_HEAD(qp, sc->sc_qhead, sc->sc_qtail);
488: } else {
489: QUEUE_AT_TAIL(qp, sc->sc_qhead, sc->sc_qtail);
490: }
491: } else { /* command port free */
492: sc->sc_qactive = qp;
493: addr->bsel0 = (DMV_RQI|DMV_IEI|DMV_IEO);
494: }
495: splx(sps);
496: }
497: /*
498: * DMV interface input interrupt.
499: * Ready to accept another command,
500: * pull one off the command queue.
501: */
502: dmvrint(unit)
503: int unit;
504: {
505: register struct dmv_softc *sc;
506: register struct dmvdevice *addr;
507: register struct dmv_command *qp;
508: register int n;
509:
510: addr = (struct dmvdevice *)dmvinfo[unit]->ui_addr;
511: sc = &dmv_softc[unit];
512: splx(sc->sc_ipl);
513: printd(("dmvrint\n"));
514: if ((qp = sc->sc_qactive) == (struct dmv_command *) 0) {
515: log(LOG_WARNING, "dmvrint: dmv%d no command\n", unit);
516: return;
517: }
518: while (addr->bsel2&DMV_RDI) {
519: if(qp->qp_mask&QP_SEL4)
520: addr->wsel4 = qp->qp_sel4;
521: if(qp->qp_mask&QP_SEL6)
522: addr->wsel6 = qp->qp_sel6;
523: if(qp->qp_mask&QP_SEL10) {
524: addr->wsel10 = qp->qp_sel10;
525: qp->qp_cmd |= DMV_22BIT;
526: }
527: if(qp->qp_mask&QP_TRIB)
528: addr->wsel2 = qp->qp_cmd|(qp->qp_tributary << 8);
529: else
530: addr->bsel2 = qp->qp_cmd;
531: QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
532: if ((sc->sc_qactive = sc->sc_qhead) == (struct dmv_command *)0)
533: break;
534: qp = sc->sc_qactive;
535: DEQUEUE(sc->sc_qhead, sc->sc_qtail);
536: if (addr->bsel2&DMV_RDO)
537: break;
538: }
539: if (!sc->sc_qactive) {
540: if(addr->bsel2&DMV_RDI) {
541: /* clear RQI prior to last command per DMV manual */
542: addr->bsel0 &= ~DMV_RQI;
543: addr->wsel6 = DMV_NOP;
544: addr->bsel2 = DMV_CNTRLI;
545: }
546: addr->bsel0 = DMV_IEO;
547: }
548: else /* RDO set or DMV still holding CSR */
549: addr->bsel0 = (DMV_RQI|DMV_IEI|DMV_IEO);
550:
551: }
552:
553: /*
554: * DMV interface output interrupt.
555: * A transfer may have completed, check for errors.
556: * If it was a read, notify appropriate protocol.
557: * If it was a write, pull the next one off the queue.
558: */
559: dmvxint(unit)
560: int unit;
561: {
562: register struct dmv_softc *sc;
563: register struct ifnet *ifp;
564: struct uba_device *ui = dmvinfo[unit];
565: struct dmvdevice *addr;
566: struct mbuf *m;
567: struct ifqueue *inq;
568: int sel2, sel3, sel4, sel6, sel10, pkaddr, len, s;
569: register struct ifrw *ifrw;
570: register struct dmvbufs *rp;
571: register struct ifxmt *ifxp;
572: struct dmv_header *dh;
573: int off, resid;
574:
575: addr = (struct dmvdevice *)ui->ui_addr;
576: sc = &dmv_softc[unit];
577: splx(sc->sc_ipl);
578: ifp = &sc->sc_if;
579:
580: while (addr->bsel2 & DMV_RDO) {
581:
582: sel2 = addr->bsel2;
583: sel3 = addr->bsel3;
584: sel4 = addr->wsel4; /* release port */
585: sel6 = addr->wsel6;
586: if(sel2 & DMV_22BIT)
587: sel10 = addr->wsel10;
588: addr->bsel2 &= ~DMV_RDO;
589: pkaddr = sel4 | ((sel6 & 0x3f) << 16);
590: printd(("dmvxint: sel2=%x sel4=%x sel6=%x sel10=%x pkaddr=%x\n",
591: (unsigned) sel2,
592: (unsigned) sel4,
593: (unsigned) sel6,
594: (unsigned) sel10,
595: (unsigned) pkaddr
596: ));
597: if((sc->sc_flag & DMV_RUNNING)==0) {
598: log(LOG_WARNING, "dmvxint: dmv%d xint while down\n", unit);
599: return;
600: }
601: switch (sel2 & 07) {
602: case DMV_BDRUS:
603: /*
604: * A read has completed.
605: * Pass packet to type specific
606: * higher-level input routine.
607: */
608: ifp->if_ipackets++;
609: /* find location in dmvuba struct */
610: ifrw= &sc->sc_ifr[0];
611: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
612: if(rp->ubinfo == pkaddr)
613: break;
614: ifrw++;
615: }
616: if (rp >= &sc->sc_rbufs[NRCV])
617: panic("dmv rcv");
618: if ((rp->flags & DBUF_DMVS) == 0)
619: log(LOG_WARNING, "dmvxint: dmv%d done unalloc rbuf\n", unit);
620:
621: len = (sel10&0x3fff) - sizeof (struct dmv_header);
622: if (len < 0 || len > DMVMTU) {
623: ifp->if_ierrors++;
624: log(LOG_ERR, "dmvxint: dmv%d bad rcv pkt addr 0x%x len 0x%x\n",
625: unit, pkaddr, len);
626: goto setup;
627: }
628: /*
629: * Deal with trailer protocol: if type is trailer
630: * get true type from first 16-bit word past data.
631: * Remember that type was trailer by setting off.
632: */
633: dh = (struct dmv_header *)ifrw->ifrw_addr;
634: dh->dmv_type = ntohs((u_short)dh->dmv_type);
635: #define dmvdataaddr(dh, off, type) ((type)(((caddr_t)((dh)+1)+(off))))
636: if (dh->dmv_type >= DMV_TRAILER &&
637: dh->dmv_type < DMV_TRAILER+DMV_NTRAILER) {
638: off = (dh->dmv_type - DMV_TRAILER) * 512;
639: if (off >= DMVMTU)
640: goto setup; /* sanity */
641: dh->dmv_type = ntohs(*dmvdataaddr(dh, off, u_short *));
642: resid = ntohs(*(dmvdataaddr(dh, off+2, u_short *)));
643: if (off + resid > len)
644: goto setup; /* sanity */
645: len = off + resid;
646: } else
647: off = 0;
648: if (len == 0)
649: goto setup;
650:
651: /*
652: * Pull packet off interface. Off is nonzero if
653: * packet has trailing header; dmv_get will then
654: * force this header information to be at the front,
655: * but we still have to drop the type and length
656: * which are at the front of any trailer data.
657: */
658: m = if_ubaget(&sc->sc_ifuba, ifrw, len, off, ifp);
659: if (m == 0)
660: goto setup;
661: switch (dh->dmv_type) {
662: #ifdef INET
663: case DMV_IPTYPE:
664: schednetisr(NETISR_IP);
665: inq = &ipintrq;
666: break;
667: #endif
668: default:
669: m_freem(m);
670: goto setup;
671: }
672:
673: s = splimp();
674: if (IF_QFULL(inq)) {
675: IF_DROP(inq);
676: m_freem(m);
677: } else
678: IF_ENQUEUE(inq, m);
679: splx(s);
680: setup:
681: /* is this needed? */
682: rp->ubinfo = UBAI_ADDR(ifrw->ifrw_info);
683: dmvload(
684: sc,
685: DMV_BACCR,
686: QP_SEL4|QP_SEL6|QP_SEL10,
687: 0,
688: (u_short) rp->ubinfo,
689: (rp->ubinfo>>16)&0x3f,
690: rp->cc
691: );
692: break;
693: case DMV_BDXSA:
694: /*
695: * A write has completed, start another
696: * transfer if there is more data to send.
697: */
698: ifp->if_opackets++;
699: /* find associated dmvbuf structure */
700: ifxp = &sc->sc_ifw[0];
701: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
702: if(rp->ubinfo == pkaddr)
703: break;
704: ifxp++;
705: }
706: if (rp >= &sc->sc_xbufs[NXMT]) {
707: log(LOG_ERR, "dmv%d: bad packet address 0x%x\n",
708: unit, pkaddr);
709: break;
710: }
711: if ((rp->flags & DBUF_DMVS) == 0)
712: log(LOG_ERR, "dmvxint: dmv%d unallocated packet 0x%x\n",
713: unit, pkaddr);
714: /* mark buffer free */
715: if (ifxp->ifw_xtofree) {
716: (void)m_freem(ifxp->ifw_xtofree);
717: ifxp->ifw_xtofree = 0;
718: }
719: rp->flags &= ~DBUF_DMVS;
720: if (--sc->sc_oused == 0)
721: sc->sc_if.if_timer = 0;
722: else
723: sc->sc_if.if_timer = dmv_timeout;
724: if ((sc->sc_flag & DMV_ONLINE) == 0) {
725: extern int ifqmaxlen;
726:
727: /*
728: * We're on the air.
729: * Open the queue to the usual value.
730: */
731: sc->sc_flag |= DMV_ONLINE;
732: ifp->if_snd.ifq_maxlen = ifqmaxlen;
733: }
734: break;
735:
736: case DMV_CNTRLO:
737: /* ACCUMULATE STATISTICS */
738: switch(sel6&DMV_EEC) {
739: case DMV_ORUN:
740: if(sc->sc_flag & DMV_RESTART) {
741: load_rec_bufs(sc);
742: sc->sc_flag &= ~DMV_RESTART;
743: log(LOG_INFO,
744: "dmv%d: far end on-line\n", unit);
745: } else {
746: log(LOG_WARNING,
747: "dmv%d: far end restart\n", unit);
748: goto restart;
749: }
750: break;
751: case DMV_RTE:
752: ifp->if_ierrors++;
753: if ((sc->sc_rte++ % DMV_RPRTE) == 0)
754: log(LOG_WARNING,
755: "dmv%d: receive threshold error\n",
756: unit);
757: break;
758: case DMV_TTE:
759: ifp->if_oerrors++;
760: if ((sc->sc_xte++ % DMV_RPTTE) == 0)
761: log(LOG_WARNING,
762: "dmv%d: transmit threshold error\n",
763: unit);
764: break;
765: case DMV_STE:
766: if ((sc->sc_ste++ % DMV_RPSTE) == 0)
767: log(LOG_WARNING,
768: "dmv%d: select threshold error\n",
769: unit);
770: break;
771: case DMV_NXM:
772: if ((sc->sc_nxm++ % DMV_RPNXM) == 0)
773: log(LOG_WARNING,
774: "dmv%d: nonexistent memory error\n",
775: unit);
776: break;
777: case DMV_MODD:
778: if ((sc->sc_modd++ % DMV_RPMODD) == 0) {
779: log(LOG_WARNING,
780: "dmv%d: modem disconnected error\n",
781: unit);
782: goto restart;
783: }
784: break;
785: case DMV_CXRL:
786: if ((sc->sc_cxrl++ % DMV_RPCXRL) == 0)
787: log(LOG_WARNING,
788: "dmv%d: carrier loss error\n",
789: unit);
790: break;
791: case DMV_QOVF:
792: log(LOG_WARNING,
793: "dmv%d: response queue overflow\n",
794: unit);
795: sc->sc_qovf++;
796: goto restart;
797:
798: default:
799: log(LOG_WARNING,
800: "dmv%d: unknown error %o\n",
801: unit, sel6&DMV_EEC);
802: if ((sc->sc_unknown++ % DMV_RPUNKNOWN) == 0)
803: goto restart;
804: break;
805: }
806: break;
807:
808: case DMV_BDRUNUS:
809: case DMV_BDXSN:
810: case DMV_BDXNS:
811: log(LOG_INFO,
812: "dmv%d: buffer disp for halted trib %o\n",
813: unit, sel2&0x7
814: );
815: break;
816:
817: case DMV_MDEFO:
818: if((sel6&0x1f) == 020) {
819: log(LOG_INFO,
820: "dmv%d: buffer return complete sel3=%x\n",
821: unit, sel3);
822: } else {
823: log(LOG_INFO,
824: "dmv%d: info resp sel3=%x sel4=%x sel6=%x\n",
825: unit, sel3, sel4, sel6
826: );
827: }
828: break;
829:
830: default:
831: log(LOG_WARNING, "dmv%d: bad control %o\n",
832: unit, sel2&0x7
833: );
834: break;
835: }
836: }
837: dmvstart(unit);
838: return;
839: restart:
840: dmvrestart(unit);
841: }
842:
843: load_rec_bufs(sc)
844: register struct dmv_softc *sc;
845: {
846: register struct dmvbufs *rp;
847:
848: /* queue first NRCV buffers for DMV to fill */
849: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
850: rp->flags |= DBUF_DMVS;
851: dmvload(
852: sc,
853: DMV_BACCR,
854: QP_TRIB|QP_SEL4|QP_SEL6|QP_SEL10,
855: 1,
856: rp->ubinfo,
857: (rp->ubinfo>>16)&0x3f,
858: rp->cc
859: );
860: sc->sc_iused++;
861: }
862: }
863:
864: /*
865: * DMV output routine.
866: * Encapsulate a packet of type family for the dmv.
867: * Use trailer local net encapsulation if enough data in first
868: * packet leaves a multiple of 512 bytes of data in remainder.
869: */
870: dmvoutput(ifp, m0, dst)
871: register struct ifnet *ifp;
872: register struct mbuf *m0;
873: struct sockaddr *dst;
874: {
875: int type, error, s;
876: register struct mbuf *m = m0;
877: register struct dmv_header *dh;
878: register int off;
879:
880: if ((ifp->if_flags & IFF_UP) == 0) {
881: error = ENETDOWN;
882: goto bad;
883: }
884:
885: switch (dst->sa_family) {
886: #ifdef INET
887: case AF_INET:
888: off = m->m_pkthdr.len - m->m_len;
889: if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
890: if (off > 0 && (off & 0x1ff) == 0 &&
891: (m->m_flags & M_EXT) == 0 &&
892: m->m_data >= m->m_pktdat + 2 * sizeof (u_short)) {
893: type = DMV_TRAILER + (off>>9);
894: m->m_data -= 2 * sizeof (u_short);
895: m->m_len += 2 * sizeof (u_short);
896: *mtod(m, u_short *) = htons((u_short)DMV_IPTYPE);
897: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
898: goto gottrailertype;
899: }
900: type = DMV_IPTYPE;
901: off = 0;
902: goto gottype;
903: #endif
904:
905: case AF_UNSPEC:
906: dh = (struct dmv_header *)dst->sa_data;
907: type = dh->dmv_type;
908: goto gottype;
909:
910: default:
911: log(LOG_ERR, "dmvoutput, dmv%d can't handle af%d\n",
912: ifp->if_unit, dst->sa_family);
913: error = EAFNOSUPPORT;
914: goto bad;
915: }
916:
917: gottrailertype:
918: /*
919: * Packet to be sent as a trailer; move first packet
920: * (control information) to end of chain.
921: */
922: while (m->m_next)
923: m = m->m_next;
924: m->m_next = m0;
925: m = m0->m_next;
926: m0->m_next = 0;
927: m0 = m;
928:
929: gottype:
930: /*
931: * Add local network header
932: * (there is space for a uba on a vax to step on)
933: */
934: M_PREPEND(m, sizeof(struct dmv_header), M_DONTWAIT);
935: if (m == 0) {
936: error = ENOBUFS;
937: goto bad;
938: }
939: dh = mtod(m, struct dmv_header *);
940: dh->dmv_type = htons((u_short)type);
941:
942: /*
943: * Queue message on interface, and start output if interface
944: * not yet active.
945: */
946: s = splimp();
947: if (IF_QFULL(&ifp->if_snd)) {
948: IF_DROP(&ifp->if_snd);
949: m_freem(m);
950: splx(s);
951: return (ENOBUFS);
952: }
953: IF_ENQUEUE(&ifp->if_snd, m);
954: dmvstart(ifp->if_unit);
955: splx(s);
956: return (0);
957:
958: bad:
959: m_freem(m0);
960: return (error);
961: }
962:
963:
964: /*
965: * Process an ioctl request.
966: */
967: /* ARGSUSED */
968: dmvioctl(ifp, cmd, data)
969: register struct ifnet *ifp;
970: int cmd;
971: caddr_t data;
972: {
973: int s = splimp(), error = 0;
974: struct mbuf *m;
975: register struct dmv_softc *sc = &dmv_softc[ifp->if_unit];
976:
977: switch (cmd) {
978:
979: case SIOCSIFADDR:
980: ifp->if_flags |= IFF_UP;
981: if ((ifp->if_flags & IFF_RUNNING) == 0)
982: dmvinit(ifp->if_unit);
983: break;
984:
985: case SIOCSIFDSTADDR:
986: if ((ifp->if_flags & IFF_RUNNING) == 0)
987: dmvinit(ifp->if_unit);
988: break;
989:
990: case SIOCSIFFLAGS:
991: if ((ifp->if_flags & IFF_UP) == 0 &&
992: sc->sc_flag & DMV_RUNNING)
993: dmvdown(ifp->if_unit);
994: else if (ifp->if_flags & IFF_UP &&
995: (sc->sc_flag & DMV_RUNNING) == 0)
996: dmvrestart(ifp->if_unit);
997: break;
998:
999: default:
1000: error = EINVAL;
1001: }
1002: splx(s);
1003: return (error);
1004: }
1005:
1006: /*
1007: * Restart after a fatal error.
1008: * Clear device and reinitialize.
1009: */
1010: dmvrestart(unit)
1011: int unit;
1012: {
1013: register struct dmvdevice *addr;
1014: register int i;
1015:
1016: dmvdown(unit);
1017:
1018: addr = (struct dmvdevice *)(dmvinfo[unit]->ui_addr);
1019: /*
1020: * Let the DMV finish the MCLR.
1021: */
1022: for (i = 100000; i && (addr->bsel1 & DMV_RUN) == 0; i--)
1023: ;
1024: if ((addr->bsel1 & DMV_RUN) == 0) {
1025: log(LOG_ERR, "dmvrestart: can't start device\n" );
1026: return (0);
1027: }
1028: if ((addr->bsel4 != 033) || (addr->bsel6 != 0305))
1029: {
1030: log(LOG_ERR, "dmv%d: device init failed, bsel4=%o, bsel6=%o\n",
1031: unit, addr->bsel4, addr->bsel6);
1032: return (0);
1033: }
1034:
1035: /* restart DMV */
1036: dmvinit(unit);
1037: dmv_softc[unit].sc_if.if_collisions++; /* why not? */
1038: }
1039:
1040: /*
1041: * Reset a device and mark down.
1042: * Flush output queue and drop queue limit.
1043: */
1044: dmvdown(unit)
1045: int unit;
1046: {
1047: struct dmv_softc *sc = &dmv_softc[unit];
1048: register struct ifxmt *ifxp;
1049:
1050: ((struct dmvdevice *)(dmvinfo[unit]->ui_addr))->bsel1 = DMV_MCLR;
1051: sc->sc_flag &= ~(DMV_RUNNING | DMV_ONLINE);
1052:
1053: for (ifxp = sc->sc_ifw; ifxp < &sc->sc_ifw[NXMT]; ifxp++) {
1054: if (ifxp->ifw_xtofree) {
1055: (void) m_freem(ifxp->ifw_xtofree);
1056: ifxp->ifw_xtofree = 0;
1057: }
1058: }
1059: sc->sc_oused = 0;
1060: if_qflush(&sc->sc_if.if_snd);
1061:
1062: /*
1063: * Limit packets enqueued until we're back on the air.
1064: */
1065: sc->sc_if.if_snd.ifq_maxlen = 3;
1066: }
1067:
1068: /*
1069: * Watchdog timeout to see that transmitted packets don't
1070: * lose interrupts. The device has to be online.
1071: */
1072: dmvtimeout(unit)
1073: int unit;
1074: {
1075: register struct dmv_softc *sc;
1076: struct dmvdevice *addr;
1077:
1078: sc = &dmv_softc[unit];
1079: if (sc->sc_flag & DMV_ONLINE) {
1080: addr = (struct dmvdevice *)(dmvinfo[unit]->ui_addr);
1081: log(LOG_ERR, "dmv%d: output timeout, bsel0=%b bsel2=%b\n",
1082: unit, addr->bsel0 & 0xff, DMV0BITS,
1083: addr->bsel2 & 0xff, DMV2BITS);
1084: dmvrestart(unit);
1085: }
1086: }
1087: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.