![[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] / 42BSD / sys / vaxif|
Return to if_dmc.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vaxif |
1.1 root 1: /* if_dmc.c 6.1 83/07/29 */
2:
3: #include "dmc.h"
4: #if NDMC > 0
5: #define printd if(dmcdebug)printf
6: int dmcdebug = 0;
7: /*
8: * DMC11 device driver, internet version
9: *
10: * TODO
11: * allow more than one outstanding read or write.
12: *
13: * UNTESTED WITH 4.2
14: */
15: #include "../machine/pte.h"
16:
17: #include "../h/param.h"
18: #include "../h/systm.h"
19: #include "../h/mbuf.h"
20: #include "../h/buf.h"
21: #include "../h/ioctl.h" /* must precede tty.h */
22: #include "../h/tty.h"
23: #include "../h/protosw.h"
24: #include "../h/socket.h"
25: #include "../h/vmmac.h"
26: #include "../h/errno.h"
27:
28: #include "../net/if.h"
29: #include "../net/netisr.h"
30: #include "../net/route.h"
31: #include "../netinet/in.h"
32: #include "../netinet/in_systm.h"
33:
34: #include "../vax/cpu.h"
35: #include "../vax/mtpr.h"
36: #include "../vaxif/if_uba.h"
37: #include "../vaxif/if_dmc.h"
38: #include "../vaxuba/ubareg.h"
39: #include "../vaxuba/ubavar.h"
40:
41: #ifndef DMC_USEMAINT
42: #define DMC_USEMAINT 1 /* use maintenance mode */
43: #endif
44:
45: /*
46: * Driver information for auto-configuration stuff.
47: */
48: int dmcprobe(), dmcattach(), dmcinit(), dmcioctl();
49: int dmcoutput(), dmcreset();
50: struct uba_device *dmcinfo[NDMC];
51: u_short dmcstd[] = { 0 };
52: struct uba_driver dmcdriver =
53: { dmcprobe, 0, dmcattach, 0, dmcstd, "dmc", dmcinfo };
54:
55: /*
56: * DMC software status per interface.
57: *
58: * Each interface is referenced by a network interface structure,
59: * sc_if, which the routing code uses to locate the interface.
60: * This structure contains the output queue for the interface, its address, ...
61: * We also have, for each interface, a UBA interface structure, which
62: * contains information about the UNIBUS resources held by the interface:
63: * map registers, buffered data paths, etc. Information is cached in this
64: * structure for use by the if_uba.c routines in running the interface
65: * efficiently.
66: */
67: struct dmc_softc {
68: struct ifnet sc_if; /* network-visible interface */
69: struct ifuba sc_ifuba; /* UNIBUS resources */
70: short sc_flag; /* flags */
71: short sc_oactive; /* output active */
72: int sc_ubinfo; /* UBA mapping info for base table */
73: struct clist sc_que; /* command queue */
74: } dmc_softc[NDMC];
75:
76: /* flags */
77: #define DMCRUN 01
78: #define DMCBMAPPED 02 /* base table mapped */
79:
80: struct dmc_base {
81: short d_base[128]; /* DMC base table */
82: } dmc_base[NDMC];
83:
84: #define loword(x) ((short *)&x)[0]
85: #define hiword(x) ((short *)&x)[1]
86:
87: dmcprobe(reg)
88: caddr_t reg;
89: {
90: register int br, cvec;
91: register struct dmcdevice *addr = (struct dmcdevice *)reg;
92: register int i;
93:
94: #ifdef lint
95: br = 0; cvec = br; br = cvec;
96: dmcrint(0); dmcxint(0);
97: #endif
98: addr->bsel1 = DMC_MCLR;
99: for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
100: ;
101: if ((addr->bsel1 & DMC_RUN) == 0)
102: return (0);
103: addr->bsel1 &= ~DMC_MCLR;
104: addr->bsel0 = DMC_RQI|DMC_IEI;
105: DELAY(100000);
106: addr->bsel1 = DMC_MCLR;
107: for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
108: ;
109: return (1);
110: }
111:
112: /*
113: * Interface exists: make available by filling in network interface
114: * record. System will initialize the interface when it is ready
115: * to accept packets.
116: */
117: dmcattach(ui)
118: register struct uba_device *ui;
119: {
120: register struct dmc_softc *sc = &dmc_softc[ui->ui_unit];
121:
122: sc->sc_if.if_unit = ui->ui_unit;
123: sc->sc_if.if_name = "dmc";
124: sc->sc_if.if_mtu = DMCMTU;
125: sc->sc_if.if_init = dmcinit;
126: sc->sc_if.if_output = dmcoutput;
127: sc->sc_if.if_ioctl = dmcioctl;
128: sc->sc_if.if_reset = dmcreset;
129: /* DON'T KNOW IF THIS WILL WORK WITH A BDP AT HIGH SPEEDS */
130: sc->sc_ifuba.ifu_flags = UBA_NEEDBDP | UBA_CANTWAIT;
131: if_attach(&sc->sc_if);
132: }
133:
134: /*
135: * Reset of interface after UNIBUS reset.
136: * If interface is on specified UBA, reset it's state.
137: */
138: dmcreset(unit, uban)
139: int unit, uban;
140: {
141: register struct uba_device *ui;
142:
143: if (unit >= NDMC || (ui = dmcinfo[unit]) == 0 || ui->ui_alive == 0 ||
144: ui->ui_ubanum != uban)
145: return;
146: printf(" dmc%d", unit);
147: dmcinit(unit);
148: }
149:
150: /*
151: * Initialization of interface; reinitialize UNIBUS usage.
152: */
153: dmcinit(unit)
154: int unit;
155: {
156: register struct dmc_softc *sc = &dmc_softc[unit];
157: register struct uba_device *ui = dmcinfo[unit];
158: register struct dmcdevice *addr;
159: register struct ifnet *ifp = &sc->sc_if;
160: struct sockaddr_in *sin;
161: int base;
162:
163: printd("dmcinit\n");
164: sin = (struct sockaddr_in *)&ifp->if_addr;
165: if (sin->sin_addr.s_addr == 0)
166: return;
167: if ((ifp->if_flags & IFF_RUNNING) == 0) {
168: if ((sc->sc_flag&DMCBMAPPED) == 0) {
169: sc->sc_ubinfo = uballoc(ui->ui_ubanum,
170: (caddr_t)&dmc_base[unit],
171: sizeof (struct dmc_base), 0);
172: sc->sc_flag |= DMCBMAPPED;
173: }
174: if (if_ubainit(&sc->sc_ifuba, ui->ui_ubanum, 0,
175: (int)btoc(DMCMTU)) == 0) {
176: printf("dmc%d: can't initialize\n", unit);
177: ifp->if_flags &= ~IFF_UP;
178: return;
179: }
180: addr = (struct dmcdevice *)ui->ui_addr;
181: addr->bsel2 |= DMC_IEO;
182: base = sc->sc_ubinfo & 0x3ffff;
183: printd(" base 0x%x\n", base);
184: dmcload(sc, DMC_BASEI, base, (base>>2)&DMC_XMEM);
185: dmcload(sc, DMC_CNTLI, 0, DMC_USEMAINT ? DMC_MAINT : 0);
186: base = sc->sc_ifuba.ifu_r.ifrw_info & 0x3ffff;
187: dmcload(sc, DMC_READ, base, ((base>>2)&DMC_XMEM)|DMCMTU);
188: printd(" first read queued, addr 0x%x\n", base);
189: ifp->if_flags |= IFF_UP|IFF_RUNNING;
190: }
191: /* set up routing table entry */
192: if ((ifp->if_flags & IFF_ROUTE) == 0) {
193: rtinit((struct sockaddr *)sin, (struct sockaddr *)sin,
194: RTF_HOST|RTF_UP);
195: ifp->if_flags |= IFF_ROUTE;
196: }
197: }
198:
199: /*
200: * Start output on interface. Get another datagram
201: * to send from the interface queue and map it to
202: * the interface before starting output.
203: */
204: dmcstart(dev)
205: dev_t dev;
206: {
207: int unit = minor(dev);
208: register struct dmc_softc *sc = &dmc_softc[unit];
209: int addr, len;
210: struct mbuf *m;
211:
212: printd("dmcstart\n");
213: /*
214: * Dequeue a request and map it to the UNIBUS.
215: * If no more requests, just return.
216: */
217: IF_DEQUEUE(&sc->sc_if.if_snd, m);
218: if (m == 0)
219: return;
220: len = if_wubaput(&sc->sc_ifuba, m);
221:
222: /*
223: * Have request mapped to UNIBUS for transmission.
224: * Purge any stale data from this BDP and start the output.
225: */
226: if (sc->sc_ifuba.ifu_flags & UBA_NEEDBDP)
227: UBAPURGE(sc->sc_ifuba.ifu_uba, sc->sc_ifuba.ifu_w.ifrw_bdp);
228: addr = sc->sc_ifuba.ifu_w.ifrw_info & 0x3ffff;
229: printd(" len %d, addr 0x%x, ", len, addr);
230: printd("mr 0x%x\n", sc->sc_ifuba.ifu_w.ifrw_mr[0]);
231: dmcload(sc, DMC_WRITE, addr, (len&DMC_CCOUNT)|((addr>>2)&DMC_XMEM));
232: sc->sc_oactive = 1;
233: }
234:
235: /*
236: * Utility routine to load the DMC device registers.
237: */
238: dmcload(sc, type, w0, w1)
239: register struct dmc_softc *sc;
240: int type, w0, w1;
241: {
242: register struct dmcdevice *addr;
243: register int unit, sps, n;
244:
245: printd("dmcload: 0x%x 0x%x 0x%x\n", type, w0, w1);
246: unit = sc - dmc_softc;
247: addr = (struct dmcdevice *)dmcinfo[unit]->ui_addr;
248: sps = spl5();
249: if ((n = sc->sc_que.c_cc) == 0)
250: addr->bsel0 = type | DMC_RQI;
251: else
252: (void) putc(type | DMC_RQI, &sc->sc_que);
253: (void) putw(w0, &sc->sc_que);
254: (void) putw(w1, &sc->sc_que);
255: if (n == 0)
256: dmcrint(unit);
257: splx(sps);
258: }
259:
260: /*
261: * DMC interface receiver interrupt.
262: * Ready to accept another command,
263: * pull one off the command queue.
264: */
265: dmcrint(unit)
266: int unit;
267: {
268: register struct dmc_softc *sc;
269: register struct dmcdevice *addr;
270: register int n;
271:
272: addr = (struct dmcdevice *)dmcinfo[unit]->ui_addr;
273: sc = &dmc_softc[unit];
274: while (addr->bsel0&DMC_RDYI) {
275: addr->sel4 = getw(&sc->sc_que);
276: addr->sel6 = getw(&sc->sc_que);
277: addr->bsel0 &= ~(DMC_IEI|DMC_RQI);
278: while (addr->bsel0&DMC_RDYI)
279: ;
280: if (sc->sc_que.c_cc == 0)
281: goto out;
282: addr->bsel0 = getc(&sc->sc_que);
283: n = RDYSCAN;
284: while (n-- && (addr->bsel0&DMC_RDYI) == 0)
285: ;
286: }
287: if (sc->sc_que.c_cc)
288: addr->bsel0 |= DMC_IEI;
289: out:
290: dmcxint(unit);
291: }
292:
293: /*
294: * DMC interface transmitter interrupt.
295: * A transfer has completed, check for errors.
296: * If it was a read, notify appropriate protocol.
297: * If it was a write, pull the next one off the queue.
298: */
299: dmcxint(unit)
300: int unit;
301: {
302: register struct dmc_softc *sc;
303: register struct ifnet *ifp;
304: struct uba_device *ui = dmcinfo[unit];
305: struct dmcdevice *addr;
306: struct mbuf *m;
307: register struct ifqueue *inq;
308: int arg, cmd, len;
309:
310: addr = (struct dmcdevice *)ui->ui_addr;
311: cmd = addr->bsel2 & 0xff;
312: if ((cmd & DMC_RDYO) == 0)
313: return;
314: #ifdef notdef
315: arg2 = addr->sel4;
316: #endif
317: arg = addr->sel6;
318: addr->bsel2 &= ~DMC_RDYO;
319: sc = &dmc_softc[unit];
320: ifp = &sc->sc_if;
321: printd("dmcxint\n");
322: switch (cmd & 07) {
323:
324: case DMC_OUR:
325: /*
326: * A read has completed. Purge input buffered
327: * data path. Pass packet to type specific
328: * higher-level input routine.
329: */
330: ifp->if_ipackets++;
331: if (sc->sc_ifuba.ifu_flags & UBA_NEEDBDP)
332: UBAPURGE(sc->sc_ifuba.ifu_uba,
333: sc->sc_ifuba.ifu_r.ifrw_bdp);
334: len = arg & DMC_CCOUNT;
335: printd(" read done, len %d\n", len);
336: switch (ifp->if_addr.sa_family) {
337: #ifdef INET
338: case AF_INET:
339: schednetisr(NETISR_IP);
340: inq = &ipintrq;
341: break;
342: #endif
343:
344: default:
345: printf("dmc%d: unknown address type %d\n", unit,
346: ifp->if_addr.sa_family);
347: goto setup;
348: }
349: m = if_rubaget(&sc->sc_ifuba, len, 0);
350: if (m == 0)
351: goto setup;
352: if (IF_QFULL(inq)) {
353: IF_DROP(inq);
354: m_freem(m);
355: } else
356: IF_ENQUEUE(inq, m);
357:
358: setup:
359: arg = sc->sc_ifuba.ifu_r.ifrw_info & 0x3ffff;
360: dmcload(sc, DMC_READ, arg, ((arg >> 2) & DMC_XMEM) | DMCMTU);
361: return;
362:
363: case DMC_OUX:
364: /*
365: * A write has completed, start another
366: * transfer if there is more data to send.
367: */
368: if (sc->sc_oactive == 0)
369: return; /* SHOULD IT BE A FATAL ERROR? */
370: printd(" write done\n");
371: ifp->if_opackets++;
372: sc->sc_oactive = 0;
373: if (sc->sc_ifuba.ifu_xtofree) {
374: m_freem(sc->sc_ifuba.ifu_xtofree);
375: sc->sc_ifuba.ifu_xtofree = 0;
376: }
377: if (ifp->if_snd.ifq_head == 0)
378: return;
379: dmcstart(unit);
380: return;
381:
382: case DMC_CNTLO:
383: arg &= DMC_CNTMASK;
384: if (arg&DMC_FATAL) {
385: addr->bsel1 = DMC_MCLR;
386: sc->sc_flag &= ~DMCRUN;
387: /*** DO SOMETHING TO RESTART DEVICE ***/
388: printf("DMC FATAL ERROR 0%o\n", arg);
389: } else {
390: /* ACCUMULATE STATISTICS */
391: printf("DMC SOFT ERROR 0%o\n", arg);
392: }
393: return;
394:
395: default:
396: printf("dmc%d: bad control %o\n", unit, cmd);
397: }
398: }
399:
400: /*
401: * DMC output routine.
402: * Just send the data, header was supplied by
403: * upper level protocol routines.
404: */
405: dmcoutput(ifp, m, dst)
406: register struct ifnet *ifp;
407: register struct mbuf *m;
408: struct sockaddr *dst;
409: {
410: int s;
411:
412: printd("dmcoutput\n");
413: if (dst->sa_family != ifp->if_addr.sa_family) {
414: printf("dmc%d: af%d not supported\n", ifp->if_unit,
415: dst->sa_family);
416: m_freem(m);
417: return (EAFNOSUPPORT);
418: }
419: s = splimp();
420: if (IF_QFULL(&ifp->if_snd)) {
421: IF_DROP(&ifp->if_snd);
422: m_freem(m);
423: splx(s);
424: return (ENOBUFS);
425: }
426: IF_ENQUEUE(&ifp->if_snd, m);
427: if (dmc_softc[ifp->if_unit].sc_oactive == 0)
428: dmcstart(ifp->if_unit);
429: splx(s);
430: return (0);
431: }
432:
433: /*
434: * Process an ioctl request.
435: */
436: dmcioctl(ifp, cmd, data)
437: register struct ifnet *ifp;
438: int cmd;
439: caddr_t data;
440: {
441: struct ifreq *ifr = (struct ifreq *)data;
442: struct sockaddr_in *sin;
443: int s = splimp(), error = 0;
444:
445: switch (cmd) {
446:
447: case SIOCSIFADDR:
448: if (ifp->if_flags & IFF_RUNNING)
449: if_rtinit(ifp, -1); /* delete previous route */
450: sin = (struct sockaddr_in *)&ifr->ifr_addr;
451: ifp->if_addr = *(struct sockaddr *)sin;
452: ifp->if_net = in_netof(sin->sin_addr);
453: ifp->if_host[0] = in_lnaof(sin->sin_addr);
454: dmcinit(ifp->if_unit);
455: break;
456:
457: case SIOCSIFDSTADDR:
458: ifp->if_dstaddr = ifr->ifr_dstaddr;
459: break;
460:
461: default:
462: error = EINVAL;
463: }
464: splx(s);
465: return (error);
466: }
467: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.