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