![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_dmc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxif|
Return to if_dmc.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxif |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)if_dmc.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "dmc.h"
10: #if NDMC > 0
11:
12: /*
13: * DMC11 device driver, internet version
14: *
15: * Bill Nesheim
16: * Cornell University
17: *
18: * Lou Salkind
19: * New York University
20: */
21:
22: /* #define DEBUG /* for base table dump on fatal error */
23:
24: #include "../machine/pte.h"
25:
26: #include "param.h"
27: #include "systm.h"
28: #include "mbuf.h"
29: #include "buf.h"
30: #include "ioctl.h" /* must precede tty.h */
31: #include "tty.h"
32: #include "protosw.h"
33: #include "socket.h"
34: #include "syslog.h"
35: #include "vmmac.h"
36: #include "errno.h"
37:
38: #include "../net/if.h"
39: #include "../net/netisr.h"
40: #include "../net/route.h"
41:
42: #ifdef INET
43: #include "../netinet/in.h"
44: #include "../netinet/in_systm.h"
45: #include "../netinet/in_var.h"
46: #include "../netinet/ip.h"
47: #endif
48:
49: #include "../vax/cpu.h"
50: #include "../vax/mtpr.h"
51: #include "if_uba.h"
52: #include "if_dmc.h"
53: #include "../vaxuba/ubareg.h"
54: #include "../vaxuba/ubavar.h"
55:
56: #include "../h/time.h"
57: #include "../h/kernel.h"
58:
59: int dmctimer; /* timer started? */
60: int dmc_timeout = 8; /* timeout value */
61: int dmcwatch();
62:
63: /*
64: * Driver information for auto-configuration stuff.
65: */
66: int dmcprobe(), dmcattach(), dmcinit(), dmcioctl();
67: int dmcoutput(), dmcreset();
68: struct uba_device *dmcinfo[NDMC];
69: u_short dmcstd[] = { 0 };
70: struct uba_driver dmcdriver =
71: { dmcprobe, 0, dmcattach, 0, dmcstd, "dmc", dmcinfo };
72:
73: #define NRCV 7
74: #define NXMT 3
75: #define NCMDS (NRCV+NXMT+4) /* size of command queue */
76:
77: #define printd if(dmcdebug)printf
78: int dmcdebug = 0;
79:
80: /* error reporting intervals */
81: #define DMC_RPNBFS 50
82: #define DMC_RPDSC 1
83: #define DMC_RPTMO 10
84: #define DMC_RPDCK 10
85:
86: struct dmc_command {
87: char qp_cmd; /* command */
88: short qp_ubaddr; /* buffer address */
89: short qp_cc; /* character count || XMEM */
90: struct dmc_command *qp_next; /* next command on queue */
91: };
92:
93: struct dmcbufs {
94: int ubinfo; /* from uballoc */
95: short cc; /* buffer size */
96: short flags; /* access control */
97: };
98: #define DBUF_OURS 0 /* buffer is available */
99: #define DBUF_DMCS 1 /* buffer claimed by somebody */
100: #define DBUF_XMIT 4 /* transmit buffer */
101: #define DBUF_RCV 8 /* receive buffer */
102:
103:
104: /*
105: * DMC software status per interface.
106: *
107: * Each interface is referenced by a network interface structure,
108: * sc_if, which the routing code uses to locate the interface.
109: * This structure contains the output queue for the interface, its address, ...
110: * We also have, for each interface, a set of 7 UBA interface structures
111: * for each, which
112: * contain information about the UNIBUS resources held by the interface:
113: * map registers, buffered data paths, etc. Information is cached in this
114: * structure for use by the if_uba.c routines in running the interface
115: * efficiently.
116: */
117: struct dmc_softc {
118: struct ifnet sc_if; /* network-visible interface */
119: struct dmcbufs sc_rbufs[NRCV]; /* receive buffer info */
120: struct dmcbufs sc_xbufs[NXMT]; /* transmit buffer info */
121: struct ifubinfo sc_ifuba; /* UNIBUS resources */
122: struct ifrw sc_ifr[NRCV]; /* UNIBUS receive buffer maps */
123: struct ifxmt sc_ifw[NXMT]; /* UNIBUS receive buffer maps */
124: short sc_oused; /* output buffers currently in use */
125: short sc_iused; /* input buffers given to DMC */
126: short sc_flag; /* flags */
127: int sc_nticks; /* seconds since last interrupt */
128: int sc_ubinfo; /* UBA mapping info for base table */
129: int sc_errors[4]; /* non-fatal error counters */
130: #define sc_datck sc_errors[0]
131: #define sc_timeo sc_errors[1]
132: #define sc_nobuf sc_errors[2]
133: #define sc_disc sc_errors[3]
134: /* command queue stuff */
135: struct dmc_command sc_cmdbuf[NCMDS];
136: struct dmc_command *sc_qhead; /* head of command queue */
137: struct dmc_command *sc_qtail; /* tail of command queue */
138: struct dmc_command *sc_qactive; /* command in progress */
139: struct dmc_command *sc_qfreeh; /* head of list of free cmd buffers */
140: struct dmc_command *sc_qfreet; /* tail of list of free cmd buffers */
141: /* end command queue stuff */
142: } dmc_softc[NDMC];
143:
144: /* flags */
145: #define DMC_ALLOC 0x01 /* unibus resources allocated */
146: #define DMC_BMAPPED 0x02 /* base table mapped */
147: #define DMC_RESTART 0x04 /* software restart in progress */
148: #define DMC_ACTIVE 0x08 /* device active */
149: #define DMC_RUNNING 0x20 /* device initialized */
150:
151: struct dmc_base {
152: short d_base[128]; /* DMC base table */
153: } dmc_base[NDMC];
154:
155: /* queue manipulation macros */
156: #define QUEUE_AT_HEAD(qp, head, tail) \
157: (qp)->qp_next = (head); \
158: (head) = (qp); \
159: if ((tail) == (struct dmc_command *) 0) \
160: (tail) = (head)
161:
162: #define QUEUE_AT_TAIL(qp, head, tail) \
163: if ((tail)) \
164: (tail)->qp_next = (qp); \
165: else \
166: (head) = (qp); \
167: (qp)->qp_next = (struct dmc_command *) 0; \
168: (tail) = (qp)
169:
170: #define DEQUEUE(head, tail) \
171: (head) = (head)->qp_next;\
172: if ((head) == (struct dmc_command *) 0)\
173: (tail) = (head)
174:
175: dmcprobe(reg)
176: caddr_t reg;
177: {
178: register int br, cvec;
179: register struct dmcdevice *addr = (struct dmcdevice *)reg;
180: register int i;
181:
182: #ifdef lint
183: br = 0; cvec = br; br = cvec;
184: dmcrint(0); dmcxint(0);
185: #endif
186: addr->bsel1 = DMC_MCLR;
187: for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
188: ;
189: if ((addr->bsel1 & DMC_RUN) == 0) {
190: printf("dmcprobe: can't start device\n" );
191: return (0);
192: }
193: addr->bsel0 = DMC_RQI|DMC_IEI;
194: /* let's be paranoid */
195: addr->bsel0 |= DMC_RQI|DMC_IEI;
196: DELAY(1000000);
197: addr->bsel1 = DMC_MCLR;
198: for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
199: ;
200: return (1);
201: }
202:
203: /*
204: * Interface exists: make available by filling in network interface
205: * record. System will initialize the interface when it is ready
206: * to accept packets.
207: */
208: dmcattach(ui)
209: register struct uba_device *ui;
210: {
211: register struct dmc_softc *sc = &dmc_softc[ui->ui_unit];
212:
213: sc->sc_if.if_unit = ui->ui_unit;
214: sc->sc_if.if_name = "dmc";
215: sc->sc_if.if_mtu = DMCMTU;
216: sc->sc_if.if_init = dmcinit;
217: sc->sc_if.if_output = dmcoutput;
218: sc->sc_if.if_ioctl = dmcioctl;
219: sc->sc_if.if_reset = dmcreset;
220: sc->sc_if.if_flags = IFF_POINTOPOINT;
221: sc->sc_ifuba.iff_flags = UBA_CANTWAIT;
222:
223: if (dmctimer == 0) {
224: dmctimer = 1;
225: timeout(dmcwatch, (caddr_t) 0, hz);
226: }
227: if_attach(&sc->sc_if);
228: }
229:
230: /*
231: * Reset of interface after UNIBUS reset.
232: * If interface is on specified UBA, reset its state.
233: */
234: dmcreset(unit, uban)
235: int unit, uban;
236: {
237: register struct uba_device *ui;
238: register struct dmc_softc *sc = &dmc_softc[unit];
239:
240: if (unit >= NDMC || (ui = dmcinfo[unit]) == 0 || ui->ui_alive == 0 ||
241: ui->ui_ubanum != uban)
242: return;
243: printf(" dmc%d", unit);
244: sc->sc_flag = 0;
245: sc->sc_if.if_flags &= ~IFF_RUNNING;
246: dmcinit(unit);
247: }
248:
249: /*
250: * Initialization of interface; reinitialize UNIBUS usage.
251: */
252: dmcinit(unit)
253: int unit;
254: {
255: register struct dmc_softc *sc = &dmc_softc[unit];
256: register struct uba_device *ui = dmcinfo[unit];
257: register struct dmcdevice *addr;
258: register struct ifnet *ifp = &sc->sc_if;
259: register struct ifrw *ifrw;
260: register struct ifxmt *ifxp;
261: register struct dmcbufs *rp;
262: register struct dmc_command *qp;
263: struct ifaddr *ifa;
264: int base;
265: int s;
266:
267: addr = (struct dmcdevice *)ui->ui_addr;
268:
269: /*
270: * Check to see that an address has been set
271: * (both local and destination for an address family).
272: */
273: for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next)
274: if (ifa->ifa_addr.sa_family && ifa->ifa_dstaddr.sa_family)
275: break;
276: if (ifa == (struct ifaddr *) 0)
277: return;
278:
279: if ((addr->bsel1&DMC_RUN) == 0) {
280: printf("dmcinit: DMC not running\n");
281: ifp->if_flags &= ~IFF_UP;
282: return;
283: }
284: /* map base table */
285: if ((sc->sc_flag & DMC_BMAPPED) == 0) {
286: sc->sc_ubinfo = uballoc(ui->ui_ubanum,
287: (caddr_t)&dmc_base[unit], sizeof (struct dmc_base), 0);
288: sc->sc_flag |= DMC_BMAPPED;
289: }
290: /* initialize UNIBUS resources */
291: sc->sc_iused = sc->sc_oused = 0;
292: if ((ifp->if_flags & IFF_RUNNING) == 0) {
293: if (if_ubaminit(&sc->sc_ifuba, ui->ui_ubanum,
294: sizeof(struct dmc_header), (int)btoc(DMCMTU),
295: sc->sc_ifr, NRCV, sc->sc_ifw, NXMT) == 0) {
296: printf("dmc%d: can't allocate uba resources\n", unit);
297: ifp->if_flags &= ~IFF_UP;
298: return;
299: }
300: ifp->if_flags |= IFF_RUNNING;
301: }
302: sc->sc_flag |= DMC_RUNNING;
303:
304: /* initialize buffer pool */
305: /* receives */
306: ifrw = &sc->sc_ifr[0];
307: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
308: rp->ubinfo = ifrw->ifrw_info & 0x3ffff;
309: rp->cc = DMCMTU + sizeof (struct dmc_header);
310: rp->flags = DBUF_OURS|DBUF_RCV;
311: ifrw++;
312: }
313: /* transmits */
314: ifxp = &sc->sc_ifw[0];
315: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
316: rp->ubinfo = ifxp->ifw_info & 0x3ffff;
317: rp->cc = 0;
318: rp->flags = DBUF_OURS|DBUF_XMIT;
319: ifxp++;
320: }
321:
322: /* set up command queues */
323: sc->sc_qfreeh = sc->sc_qfreet
324: = sc->sc_qhead = sc->sc_qtail = sc->sc_qactive =
325: (struct dmc_command *)0;
326: /* set up free command buffer list */
327: for (qp = &sc->sc_cmdbuf[0]; qp < &sc->sc_cmdbuf[NCMDS]; qp++) {
328: QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
329: }
330:
331: /* base in */
332: base = sc->sc_ubinfo & 0x3ffff;
333: dmcload(sc, DMC_BASEI, base, (base>>2) & DMC_XMEM);
334: /* specify half duplex operation, flags tell if primary */
335: /* or secondary station */
336: if (ui->ui_flags == 0)
337: /* use DDCMP mode in full duplex */
338: dmcload(sc, DMC_CNTLI, 0, 0);
339: else if (ui->ui_flags == 1)
340: /* use MAINTENENCE mode */
341: dmcload(sc, DMC_CNTLI, 0, DMC_MAINT );
342: else if (ui->ui_flags == 2)
343: /* use DDCMP half duplex as primary station */
344: dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX);
345: else if (ui->ui_flags == 3)
346: /* use DDCMP half duplex as secondary station */
347: dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX | DMC_SEC);
348:
349: /* enable operation done interrupts */
350: sc->sc_flag &= ~DMC_ACTIVE;
351: while ((addr->bsel2 & DMC_IEO) == 0)
352: addr->bsel2 |= DMC_IEO;
353: s = spl5();
354: /* queue first NRCV buffers for DMC to fill */
355: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
356: rp->flags |= DBUF_DMCS;
357: dmcload(sc, DMC_READ, rp->ubinfo,
358: (((rp->ubinfo>>2)&DMC_XMEM) | rp->cc));
359: sc->sc_iused++;
360: }
361: splx(s);
362: }
363:
364: /*
365: * Start output on interface. Get another datagram
366: * to send from the interface queue and map it to
367: * the interface before starting output.
368: *
369: * Must be called at spl 5
370: */
371: dmcstart(dev)
372: dev_t dev;
373: {
374: int unit = minor(dev);
375: register struct dmc_softc *sc = &dmc_softc[unit];
376: struct mbuf *m;
377: register struct dmcbufs *rp;
378: register int n;
379:
380: /*
381: * Dequeue up to NXMT requests and map them to the UNIBUS.
382: * If no more requests, or no dmc buffers available, just return.
383: */
384: n = 0;
385: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++ ) {
386: /* find an available buffer */
387: if ((rp->flags & DBUF_DMCS) == 0) {
388: IF_DEQUEUE(&sc->sc_if.if_snd, m);
389: if (m == 0)
390: return;
391: /* mark it dmcs */
392: rp->flags |= (DBUF_DMCS);
393: /*
394: * Have request mapped to UNIBUS for transmission
395: * and start the output.
396: */
397: rp->cc = if_ubaput(&sc->sc_ifuba, &sc->sc_ifw[n], m);
398: rp->cc &= DMC_CCOUNT;
399: sc->sc_oused++;
400: dmcload(sc, DMC_WRITE, rp->ubinfo,
401: rp->cc | ((rp->ubinfo>>2)&DMC_XMEM));
402: }
403: n++;
404: }
405: }
406:
407: /*
408: * Utility routine to load the DMC device registers.
409: */
410: dmcload(sc, type, w0, w1)
411: register struct dmc_softc *sc;
412: int type, w0, w1;
413: {
414: register struct dmcdevice *addr;
415: register int unit, sps;
416: register struct dmc_command *qp;
417:
418: unit = sc - dmc_softc;
419: addr = (struct dmcdevice *)dmcinfo[unit]->ui_addr;
420: sps = spl5();
421:
422: /* grab a command buffer from the free list */
423: if ((qp = sc->sc_qfreeh) == (struct dmc_command *)0)
424: panic("dmc command queue overflow");
425: DEQUEUE(sc->sc_qfreeh, sc->sc_qfreet);
426:
427: /* fill in requested info */
428: qp->qp_cmd = (type | DMC_RQI);
429: qp->qp_ubaddr = w0;
430: qp->qp_cc = w1;
431:
432: if (sc->sc_qactive) { /* command in progress */
433: if (type == DMC_READ) {
434: QUEUE_AT_HEAD(qp, sc->sc_qhead, sc->sc_qtail);
435: } else {
436: QUEUE_AT_TAIL(qp, sc->sc_qhead, sc->sc_qtail);
437: }
438: } else { /* command port free */
439: sc->sc_qactive = qp;
440: addr->bsel0 = qp->qp_cmd;
441: dmcrint(unit);
442: }
443: splx(sps);
444: }
445:
446: /*
447: * DMC interface receiver interrupt.
448: * Ready to accept another command,
449: * pull one off the command queue.
450: */
451: dmcrint(unit)
452: int unit;
453: {
454: register struct dmc_softc *sc;
455: register struct dmcdevice *addr;
456: register struct dmc_command *qp;
457: register int n;
458:
459: addr = (struct dmcdevice *)dmcinfo[unit]->ui_addr;
460: sc = &dmc_softc[unit];
461: if ((qp = sc->sc_qactive) == (struct dmc_command *) 0) {
462: printf("dmc%d: dmcrint no command\n", unit);
463: return;
464: }
465: while (addr->bsel0&DMC_RDYI) {
466: addr->sel4 = qp->qp_ubaddr;
467: addr->sel6 = qp->qp_cc;
468: addr->bsel0 &= ~(DMC_IEI|DMC_RQI);
469: /* free command buffer */
470: QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
471: while (addr->bsel0 & DMC_RDYI) {
472: /*
473: * Can't check for RDYO here 'cause
474: * this routine isn't reentrant!
475: */
476: DELAY(5);
477: }
478: /* move on to next command */
479: if ((sc->sc_qactive = sc->sc_qhead) == (struct dmc_command *)0)
480: break; /* all done */
481: /* more commands to do, start the next one */
482: qp = sc->sc_qactive;
483: DEQUEUE(sc->sc_qhead, sc->sc_qtail);
484: addr->bsel0 = qp->qp_cmd;
485: n = RDYSCAN;
486: while (n-- > 0)
487: if ((addr->bsel0&DMC_RDYI) || (addr->bsel2&DMC_RDYO))
488: break;
489: }
490: if (sc->sc_qactive) {
491: addr->bsel0 |= DMC_IEI|DMC_RQI;
492: /* VMS does it twice !*$%@# */
493: addr->bsel0 |= DMC_IEI|DMC_RQI;
494: }
495:
496: }
497:
498: /*
499: * DMC interface transmitter interrupt.
500: * A transfer may have completed, check for errors.
501: * If it was a read, notify appropriate protocol.
502: * If it was a write, pull the next one off the queue.
503: */
504: dmcxint(unit)
505: int unit;
506: {
507: register struct dmc_softc *sc;
508: register struct ifnet *ifp;
509: struct uba_device *ui = dmcinfo[unit];
510: struct dmcdevice *addr;
511: struct mbuf *m;
512: struct ifqueue *inq;
513: int arg, pkaddr, cmd, len, s;
514: register struct ifrw *ifrw;
515: register struct dmcbufs *rp;
516: register struct ifxmt *ifxp;
517: struct dmc_header *dh;
518: int off, resid;
519:
520: addr = (struct dmcdevice *)ui->ui_addr;
521: sc = &dmc_softc[unit];
522: ifp = &sc->sc_if;
523:
524: while (addr->bsel2 & DMC_RDYO) {
525:
526: cmd = addr->bsel2 & 0xff;
527: arg = addr->sel6 & 0xffff;
528: /* reconstruct UNIBUS address of buffer returned to us */
529: pkaddr = ((arg&DMC_XMEM)<<2) | (addr->sel4 & 0xffff);
530: /* release port */
531: addr->bsel2 &= ~DMC_RDYO;
532: switch (cmd & 07) {
533:
534: case DMC_OUR:
535: /*
536: * A read has completed.
537: * Pass packet to type specific
538: * higher-level input routine.
539: */
540: ifp->if_ipackets++;
541: /* find location in dmcuba struct */
542: ifrw= &sc->sc_ifr[0];
543: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
544: if(rp->ubinfo == pkaddr)
545: break;
546: ifrw++;
547: }
548: if (rp >= &sc->sc_rbufs[NRCV])
549: panic("dmc rcv");
550: if ((rp->flags & DBUF_DMCS) == 0)
551: printf("dmc%d: done unalloc rbuf\n", unit);
552:
553: len = (arg & DMC_CCOUNT) - sizeof (struct dmc_header);
554: if (len < 0 || len > DMCMTU) {
555: ifp->if_ierrors++;
556: printd("dmc%d: bad rcv pkt addr 0x%x len 0x%x\n",
557: unit, pkaddr, len);
558: goto setup;
559: }
560: /*
561: * Deal with trailer protocol: if type is trailer
562: * get true type from first 16-bit word past data.
563: * Remember that type was trailer by setting off.
564: */
565: dh = (struct dmc_header *)ifrw->ifrw_addr;
566: dh->dmc_type = ntohs((u_short)dh->dmc_type);
567: #define dmcdataaddr(dh, off, type) ((type)(((caddr_t)((dh)+1)+(off))))
568: if (dh->dmc_type >= DMC_TRAILER &&
569: dh->dmc_type < DMC_TRAILER+DMC_NTRAILER) {
570: off = (dh->dmc_type - DMC_TRAILER) * 512;
571: if (off >= DMCMTU)
572: goto setup; /* sanity */
573: dh->dmc_type = ntohs(*dmcdataaddr(dh, off, u_short *));
574: resid = ntohs(*(dmcdataaddr(dh, off+2, u_short *)));
575: if (off + resid > len)
576: goto setup; /* sanity */
577: len = off + resid;
578: } else
579: off = 0;
580: if (len == 0)
581: goto setup;
582:
583: /*
584: * Pull packet off interface. Off is nonzero if
585: * packet has trailing header; dmc_get will then
586: * force this header information to be at the front,
587: * but we still have to drop the type and length
588: * which are at the front of any trailer data.
589: */
590: m = if_ubaget(&sc->sc_ifuba, ifrw, len, off, ifp);
591: if (m == 0)
592: goto setup;
593: if (off) {
594: ifp = *(mtod(m, struct ifnet **));
595: m->m_off += 2 * sizeof (u_short);
596: m->m_len -= 2 * sizeof (u_short);
597: *(mtod(m, struct ifnet **)) = ifp;
598: }
599: switch (dh->dmc_type) {
600:
601: #ifdef INET
602: case DMC_IPTYPE:
603: schednetisr(NETISR_IP);
604: inq = &ipintrq;
605: break;
606: #endif
607: default:
608: m_freem(m);
609: goto setup;
610: }
611:
612: s = splimp();
613: if (IF_QFULL(inq)) {
614: IF_DROP(inq);
615: m_freem(m);
616: } else
617: IF_ENQUEUE(inq, m);
618: splx(s);
619:
620: setup:
621: /* is this needed? */
622: rp->ubinfo = ifrw->ifrw_info & 0x3ffff;
623:
624: dmcload(sc, DMC_READ, rp->ubinfo,
625: ((rp->ubinfo >> 2) & DMC_XMEM) | rp->cc);
626: break;
627:
628: case DMC_OUX:
629: /*
630: * A write has completed, start another
631: * transfer if there is more data to send.
632: */
633: ifp->if_opackets++;
634: /* find associated dmcbuf structure */
635: ifxp = &sc->sc_ifw[0];
636: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
637: if(rp->ubinfo == pkaddr)
638: break;
639: ifxp++;
640: }
641: if (rp >= &sc->sc_xbufs[NXMT]) {
642: printf("dmc%d: bad packet address 0x%x\n",
643: unit, pkaddr);
644: break;
645: }
646: if ((rp->flags & DBUF_DMCS) == 0)
647: printf("dmc%d: unallocated packet 0x%x\n",
648: unit, pkaddr);
649: /* mark buffer free */
650: if (ifxp->ifw_xtofree) {
651: (void)m_freem(ifxp->ifw_xtofree);
652: ifxp->ifw_xtofree = 0;
653: }
654: rp->flags &= ~DBUF_DMCS;
655: sc->sc_oused--;
656: sc->sc_nticks = 0;
657: sc->sc_flag |= DMC_ACTIVE;
658: break;
659:
660: case DMC_CNTLO:
661: arg &= DMC_CNTMASK;
662: if (arg & DMC_FATAL) {
663: log(LOG_ERR, "dmc%d: fatal error, flags=%b\n",
664: unit, arg, CNTLO_BITS);
665: dmcrestart(unit);
666: break;
667: }
668: /* ACCUMULATE STATISTICS */
669: switch(arg) {
670: case DMC_NOBUFS:
671: ifp->if_ierrors++;
672: if ((sc->sc_nobuf++ % DMC_RPNBFS) == 0)
673: goto report;
674: break;
675: case DMC_DISCONN:
676: if ((sc->sc_disc++ % DMC_RPDSC) == 0)
677: goto report;
678: break;
679: case DMC_TIMEOUT:
680: if ((sc->sc_timeo++ % DMC_RPTMO) == 0)
681: goto report;
682: break;
683: case DMC_DATACK:
684: ifp->if_oerrors++;
685: if ((sc->sc_datck++ % DMC_RPDCK) == 0)
686: goto report;
687: break;
688: default:
689: goto report;
690: }
691: break;
692: report:
693: printd("dmc%d: soft error, flags=%b\n", unit,
694: arg, CNTLO_BITS);
695: if ((sc->sc_flag & DMC_RESTART) == 0) {
696: /*
697: * kill off the dmc to get things
698: * going again by generating a
699: * procedure error
700: */
701: sc->sc_flag |= DMC_RESTART;
702: arg = sc->sc_ubinfo & 0x3ffff;
703: dmcload(sc, DMC_BASEI, arg, (arg>>2)&DMC_XMEM);
704: }
705: break;
706:
707: default:
708: printf("dmc%d: bad control %o\n", unit, cmd);
709: break;
710: }
711: }
712: dmcstart(unit);
713: return;
714: }
715:
716: /*
717: * DMC output routine.
718: * Encapsulate a packet of type family for the dmc.
719: * Use trailer local net encapsulation if enough data in first
720: * packet leaves a multiple of 512 bytes of data in remainder.
721: */
722: dmcoutput(ifp, m0, dst)
723: register struct ifnet *ifp;
724: register struct mbuf *m0;
725: struct sockaddr *dst;
726: {
727: int type, error, s;
728: register struct mbuf *m = m0;
729: register struct dmc_header *dh;
730: register int off;
731:
732: switch (dst->sa_family) {
733: #ifdef INET
734: case AF_INET:
735: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
736: if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
737: if (off > 0 && (off & 0x1ff) == 0 &&
738: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
739: type = DMC_TRAILER + (off>>9);
740: m->m_off -= 2 * sizeof (u_short);
741: m->m_len += 2 * sizeof (u_short);
742: *mtod(m, u_short *) = htons((u_short)DMC_IPTYPE);
743: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
744: goto gottrailertype;
745: }
746: type = DMC_IPTYPE;
747: off = 0;
748: goto gottype;
749: #endif
750:
751: case AF_UNSPEC:
752: dh = (struct dmc_header *)dst->sa_data;
753: type = dh->dmc_type;
754: goto gottype;
755:
756: default:
757: printf("dmc%d: can't handle af%d\n", ifp->if_unit,
758: dst->sa_family);
759: error = EAFNOSUPPORT;
760: goto bad;
761: }
762:
763: gottrailertype:
764: /*
765: * Packet to be sent as a trailer; move first packet
766: * (control information) to end of chain.
767: */
768: while (m->m_next)
769: m = m->m_next;
770: m->m_next = m0;
771: m = m0->m_next;
772: m0->m_next = 0;
773: m0 = m;
774:
775: gottype:
776: /*
777: * Add local network header
778: * (there is space for a uba on a vax to step on)
779: */
780: if (m->m_off > MMAXOFF ||
781: MMINOFF + sizeof(struct dmc_header) > m->m_off) {
782: m = m_get(M_DONTWAIT, MT_HEADER);
783: if (m == 0) {
784: error = ENOBUFS;
785: goto bad;
786: }
787: m->m_next = m0;
788: m->m_off = MMINOFF;
789: m->m_len = sizeof (struct dmc_header);
790: } else {
791: m->m_off -= sizeof (struct dmc_header);
792: m->m_len += sizeof (struct dmc_header);
793: }
794: dh = mtod(m, struct dmc_header *);
795: dh->dmc_type = htons((u_short)type);
796:
797: /*
798: * Queue message on interface, and start output if interface
799: * not yet active.
800: */
801: s = splimp();
802: if (IF_QFULL(&ifp->if_snd)) {
803: IF_DROP(&ifp->if_snd);
804: m_freem(m);
805: splx(s);
806: return (ENOBUFS);
807: }
808: IF_ENQUEUE(&ifp->if_snd, m);
809: dmcstart(ifp->if_unit);
810: splx(s);
811: return (0);
812:
813: bad:
814: m_freem(m0);
815: return (error);
816: }
817:
818:
819: /*
820: * Process an ioctl request.
821: */
822: /* ARGSUSED */
823: dmcioctl(ifp, cmd, data)
824: register struct ifnet *ifp;
825: int cmd;
826: caddr_t data;
827: {
828: int s = splimp(), error = 0;
829: register struct dmc_softc *sc = &dmc_softc[ifp->if_unit];
830:
831: switch (cmd) {
832:
833: case SIOCSIFADDR:
834: ifp->if_flags |= IFF_UP;
835: if ((ifp->if_flags & IFF_RUNNING) == 0)
836: dmcinit(ifp->if_unit);
837: break;
838:
839: case SIOCSIFDSTADDR:
840: if ((ifp->if_flags & IFF_RUNNING) == 0)
841: dmcinit(ifp->if_unit);
842: break;
843:
844: case SIOCSIFFLAGS:
845: if ((ifp->if_flags & IFF_UP) == 0 &&
846: sc->sc_flag & DMC_RUNNING) {
847: ((struct dmcdevice *)
848: (dmcinfo[ifp->if_unit]->ui_addr))->bsel1 = DMC_MCLR;
849: sc->sc_flag &= ~DMC_RUNNING;
850: } else if (ifp->if_flags & IFF_UP &&
851: (sc->sc_flag & DMC_RUNNING) == 0)
852: dmcrestart(ifp->if_unit);
853: break;
854:
855: default:
856: error = EINVAL;
857: }
858: splx(s);
859: return (error);
860: }
861:
862: /*
863: * Restart after a fatal error.
864: * Clear device and reinitialize.
865: */
866: dmcrestart(unit)
867: int unit;
868: {
869: register struct dmc_softc *sc = &dmc_softc[unit];
870: register struct uba_device *ui = dmcinfo[unit];
871: register struct dmcdevice *addr;
872: register struct ifxmt *ifxp;
873: register int i;
874:
875: addr = (struct dmcdevice *)ui->ui_addr;
876: #ifdef DEBUG
877: /* dump base table */
878: printf("dmc%d base table:\n", unit);
879: for (i = 0; i < sizeof (struct dmc_base); i++)
880: printf("%o\n" ,dmc_base[unit].d_base[i]);
881: #endif
882: /*
883: * Let the DMR finish the MCLR. At 1 Mbit, it should do so
884: * in about a max of 6.4 milliseconds with diagnostics enabled.
885: */
886: addr->bsel1 = DMC_MCLR;
887: for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
888: ;
889: /* Did the timer expire or did the DMR finish? */
890: if ((addr->bsel1 & DMC_RUN) == 0) {
891: log(LOG_ERR, "dmc%d: M820 Test Failed\n", unit);
892: return;
893: }
894:
895: for (ifxp = sc->sc_ifw; ifxp < &sc->sc_ifw[NXMT]; ifxp++) {
896: if (ifxp->ifw_xtofree) {
897: (void) m_freem(ifxp->ifw_xtofree);
898: ifxp->ifw_xtofree = 0;
899: }
900: }
901:
902: /* restart DMC */
903: dmcinit(unit);
904: sc->sc_flag &= ~DMC_RESTART;
905: sc->sc_if.if_collisions++; /* why not? */
906: }
907:
908: /*
909: * Check to see that transmitted packets don't
910: * lose interrupts. The device has to be active.
911: */
912: dmcwatch()
913: {
914: register struct uba_device *ui;
915: register struct dmc_softc *sc;
916: struct dmcdevice *addr;
917: register int i;
918:
919: for (i = 0; i < NDMC; i++) {
920: sc = &dmc_softc[i];
921: if ((sc->sc_flag & DMC_ACTIVE) == 0)
922: continue;
923: if ((ui = dmcinfo[i]) == 0 || ui->ui_alive == 0)
924: continue;
925: if (sc->sc_oused) {
926: sc->sc_nticks++;
927: if (sc->sc_nticks > dmc_timeout) {
928: sc->sc_nticks = 0;
929: addr = (struct dmcdevice *)ui->ui_addr;
930: log(LOG_ERR, "dmc%d hung: bsel0=%b bsel2=%b\n",
931: i, addr->bsel0 & 0xff, DMC0BITS,
932: addr->bsel2 & 0xff, DMC2BITS);
933: dmcrestart(i);
934: }
935: }
936: }
937: timeout(dmcwatch, (caddr_t) 0, hz);
938: }
939: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.