![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_vv.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_vv.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_vv.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "vv.h"
10: #if NVV > 0
11:
12: /*
13: * Proteon proNET-10 and proNET-80 token ring driver.
14: * The name of this device driver derives from the old MIT
15: * name of V2LNI for the proNET hardware, would would abbreviate
16: * to "v2", but this won't work right. Thus the name is "vv".
17: *
18: * This driver is compatible with the proNET 10 meagbit and
19: * 80 megabit token ring interfaces (models p1000 and p1080).
20: * A unit may be marked as 80 megabit using "flags 1" in the
21: * config file.
22: *
23: * TRAILERS: This driver has a new implementation of trailers that
24: * is at least a tolerable neighbor on the ring. The offset is not
25: * stored in the protocol type, but instead only in the vh_info
26: * field. Also, the vh_info field, and the two shorts before the
27: * trailing header, are in network byte order, not VAX byte order.
28: *
29: * Of course, nothing but BSD UNIX supports trailers on ProNET.
30: * If you need interoperability with anything else, turn off
31: * trailers using the -trailers option to /etc/ifconfig!
32: *
33: * HARDWARE COMPATABILITY: This driver prefers that the HSBU (p1001)
34: * have a serial number >= 040, which is about March, 1982. Older
35: * HSBUs do not carry across 64kbyte boundaries. They can be supported
36: * by adding "| UBA_NEED16" to the vs_ifuba.ifu_flags initialization
37: * in vvattach().
38: *
39: * The old warning about use without Wire Centers applies only to CTL
40: * (p1002) cards with serial <= 057, which have not received ECO 176-743,
41: * which was implemented in March, 1982. Most such CTLs have received
42: * this ECO.
43: */
44: #include "../machine/pte.h"
45:
46: #include "param.h"
47: #include "systm.h"
48: #include "mbuf.h"
49: #include "buf.h"
50: #include "protosw.h"
51: #include "socket.h"
52: #include "vmmac.h"
53: #include "errno.h"
54: #include "ioctl.h"
55:
56: #include "../net/if.h"
57: #include "../net/netisr.h"
58: #include "../net/route.h"
59:
60: #ifdef INET
61: #include "../netinet/in.h"
62: #include "../netinet/in_systm.h"
63: #include "../netinet/in_var.h"
64: #include "../netinet/ip.h"
65: #endif
66:
67: #include "../vax/cpu.h"
68: #include "../vax/mtpr.h"
69: #include "if_vv.h"
70: #include "if_uba.h"
71: #include "../vaxuba/ubareg.h"
72: #include "../vaxuba/ubavar.h"
73:
74: /*
75: * maximum transmission unit definition --
76: * you can set VVMTU at anything from 576 to 2024.
77: * 1536 is a popular "large" value, because it is a multiple
78: * of 512, which the trailer scheme likes.
79: * The absolute maximum size is 2024, which is enforced.
80: */
81:
82: #define VVMTU (1536)
83:
84: #define VVMRU (VVMTU + 16)
85: #define VVBUFSIZE (VVMRU + sizeof(struct vv_header))
86: #if VVMTU>2024
87: #undef VVMTU
88: #undef VVMRU
89: #undef VVBUFSIZE
90: #define VVBUFSIZE (2046)
91: #define VVMRU (VVBUFSIZE - sizeof (struct vv_header))
92: #define VVMTU (VVMRU - 16)
93: #endif
94:
95: /*
96: * debugging and tracing stuff
97: */
98: int vv_tracehdr = 0; /* 1 => trace headers (slowly!!) */
99:
100: #define vvtracehdr if (vv_tracehdr) vvprt_hdr
101: #define vvprintf if (vs->vs_if.if_flags & IFF_DEBUG) printf
102:
103: /*
104: * externals, types, etc.
105: */
106: int vvprobe(), vvattach(), vvreset(), vvinit();
107: int vvidentify(), vvstart(), vvxint(), vvwatchdog();
108: int vvrint(), vvoutput(), vvioctl();
109: struct uba_device *vvinfo[NVV];
110: u_short vvstd[] = { 0 };
111: struct uba_driver vvdriver =
112: { vvprobe, 0, vvattach, 0, vvstd, "vv", vvinfo };
113: #define VVUNIT(x) minor(x)
114:
115: #define LOOPBACK /* use loopback for packets meant for us */
116: #ifdef LOOPBACK
117: extern struct ifnet loif;
118: #endif
119:
120: /*
121: * Software status of each interface.
122: *
123: * Each interface is referenced by a network interface structure,
124: * vs_if, which the routing code uses to locate the interface.
125: * This structure contains the output queue for the interface, its address, ...
126: * We also have, for each interface, a UBA interface structure, which
127: * contains information about the UNIBUS resources held by the interface:
128: * map registers, buffered data paths, etc. Information is cached in this
129: * structure for use by the if_uba.c routines in running the interface
130: * efficiently.
131: */
132: struct vv_softc {
133: struct ifnet vs_if; /* network-visible interface */
134: struct ifuba vs_ifuba; /* UNIBUS resources */
135: u_short vs_host; /* this interface address */
136: short vs_oactive; /* is output active */
137: short vs_is80; /* is 80 megabit version */
138: short vs_olen; /* length of last output */
139: u_short vs_lastx; /* address of last packet sent */
140: u_short vs_lastr; /* address of last packet received */
141: short vs_tries; /* transmit current retry count */
142: short vs_init; /* number of ring inits */
143: short vs_refused; /* number of packets refused */
144: short vs_timeouts; /* number of transmit timeouts */
145: short vs_otimeout; /* number of output timeouts */
146: short vs_ibadf; /* number of input bad formats */
147: short vs_parity; /* number of parity errors on 10 meg, */
148: /* link data errors on 80 meg */
149: } vv_softc[NVV];
150:
151: #define NOHOST 0xffff /* illegal host number */
152:
153: /*
154: * probe the interface to see that the registers exist, and then
155: * cause an interrupt to find its vector
156: */
157: vvprobe(reg)
158: caddr_t reg;
159: {
160: register int br, cvec;
161: register struct vvreg *addr;
162:
163: #ifdef lint
164: br = 0; cvec = br; br = cvec;
165: #endif
166: addr = (struct vvreg *)reg;
167:
168: /* reset interface, enable, and wait till dust settles */
169: addr->vvicsr = VV_RST;
170: addr->vvocsr = VV_RST;
171: DELAY(100000);
172:
173: /* generate interrupt by doing 1 word DMA from 0 in uba space!! */
174: addr->vvoba = 0; /* low 16 bits */
175: addr->vvoea = 0; /* extended bits */
176: addr->vvowc = -1; /* for 1 word */
177: addr->vvocsr = VV_IEN | VV_DEN; /* start the DMA, with interrupt */
178: DELAY(100000);
179: addr->vvocsr = VV_RST; /* clear out the CSR */
180: if (cvec && cvec != 0x200)
181: cvec -= 4; /* backup so vector => receive */
182: return(1);
183: }
184:
185: /*
186: * Interface exists: make available by filling in network interface
187: * record. System will initialize the interface when it is ready
188: * to accept packets.
189: */
190: vvattach(ui)
191: struct uba_device *ui;
192: {
193: register struct vv_softc *vs;
194:
195: vs = &vv_softc[ui->ui_unit];
196: vs->vs_if.if_unit = ui->ui_unit;
197: vs->vs_if.if_name = "vv";
198: vs->vs_if.if_mtu = VVMTU;
199: vs->vs_if.if_flags = IFF_BROADCAST;
200: vs->vs_if.if_init = vvinit;
201: vs->vs_if.if_ioctl = vvioctl;
202: vs->vs_if.if_output = vvoutput;
203: vs->vs_if.if_reset = vvreset;
204: vs->vs_if.if_timer = 0;
205: vs->vs_if.if_watchdog = vvwatchdog;
206: vs->vs_ifuba.ifu_flags = UBA_CANTWAIT | UBA_NEEDBDP;
207:
208: /* use flag to determine if this is proNET-80 */
209: vs->vs_is80 = (short)(ui->ui_flags & 01);
210:
211: #if defined(VAX750)
212: /* don't chew up 750 bdp's */
213: if (cpu == VAX_750 && ui->ui_unit > 0)
214: vs->vs_ifuba.ifu_flags &= ~UBA_NEEDBDP;
215: #endif
216: if_attach(&vs->vs_if);
217: }
218:
219: /*
220: * Reset of interface after UNIBUS reset.
221: * If interface is on specified uba, reset its state.
222: */
223: vvreset(unit, uban)
224: int unit, uban;
225: {
226: register struct uba_device *ui;
227:
228: if (unit >= NVV || (ui = vvinfo[unit]) == 0 || ui->ui_alive == 0 ||
229: ui->ui_ubanum != uban)
230: return;
231: printf(" vv%d", unit);
232: vvinit(unit);
233: }
234:
235: /*
236: * Initialization of interface; clear recorded pending
237: * operations, and reinitialize UNIBUS usage.
238: */
239: vvinit(unit)
240: int unit;
241: {
242: register struct vv_softc *vs;
243: register struct uba_device *ui;
244: register struct vvreg *addr;
245: register int ubainfo, s;
246:
247: vs = &vv_softc[unit];
248: ui = vvinfo[unit];
249:
250: if (vs->vs_if.if_addrlist == (struct ifaddr *)0)
251: return;
252:
253: addr = (struct vvreg *)ui->ui_addr;
254: if (if_ubainit(&vs->vs_ifuba, ui->ui_ubanum,
255: sizeof (struct vv_header), (int)btoc(VVMTU)) == 0) {
256: printf("vv%d: can't initialize, if_ubainit() failed\n", unit);
257: vs->vs_if.if_flags &= ~IFF_UP;
258: return;
259: }
260:
261: /*
262: * Now that the uba is set up, figure out our address and
263: * update complete our host address.
264: */
265: if ((vs->vs_host = vvidentify(unit)) == NOHOST) {
266: vs->vs_if.if_flags &= ~IFF_UP;
267: return;
268: }
269: printf("vv%d: host %u\n", unit, vs->vs_host);
270:
271: /*
272: * Reset the interface, and stay in the ring
273: */
274: addr->vvocsr = VV_RST; /* take over output */
275: addr->vvocsr = VV_CPB; /* clear packet buffer */
276: addr->vvicsr = VV_RST | VV_HEN; /* take over input, */
277: /* keep relay closed */
278: DELAY(500000); /* let contacts settle */
279:
280: vs->vs_init = 0; /* clear counters, etc. */
281: vs->vs_refused = 0;
282: vs->vs_timeouts = 0;
283: vs->vs_otimeout = 0;
284: vs->vs_ibadf = 0;
285: vs->vs_parity = 0;
286: vs->vs_lastx = 256; /* an invalid address */
287: vs->vs_lastr = 256; /* an invalid address */
288:
289: /*
290: * Hang a receive and start any
291: * pending writes by faking a transmit complete.
292: */
293: s = splimp();
294: ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
295: addr->vviba = (u_short)ubainfo;
296: addr->vviea = (u_short)(ubainfo >> 16);
297: addr->vviwc = -(VVBUFSIZE) >> 1;
298: addr->vvicsr = VV_IEN | VV_HEN | VV_DEN | VV_ENB;
299: vs->vs_oactive = 1;
300: vs->vs_if.if_flags |= IFF_RUNNING;
301: vvxint(unit);
302: splx(s);
303: }
304:
305: /*
306: * Do a moderately thorough self-test in all three modes. Mostly
307: * to keeps defective nodes off the ring, rather than to be especially
308: * thorough. The key issue is to detect any cable breaks before joining
309: * the ring. Return our node address on success, return -1 on failure.
310: *
311: */
312:
313: /* the three self-test modes */
314: static u_short vv_modes[] = {
315: VV_STE|VV_LPB, /* digital loopback */
316: VV_STE, /* analog loopback */
317: VV_HEN /* network mode */
318: };
319:
320: vvidentify(unit)
321: int unit;
322: {
323: register struct vv_softc *vs;
324: register struct uba_device *ui;
325: register struct vvreg *addr;
326: register struct mbuf *m;
327: register struct vv_header *v;
328: register int ubainfo;
329: register int i, successes, failures, waitcount;
330: u_short shost = NOHOST;
331:
332: vs = &vv_softc[unit];
333: ui = vvinfo[unit];
334: addr = (struct vvreg *)ui->ui_addr;
335:
336: /*
337: * Build a multicast message to identify our address
338: * We need do this only once, since nobody else is about to use
339: * the intermediate transmit buffer (ifu_w.ifrw_addr) that
340: * if_ubainit() aquired for us.
341: */
342: m = m_get(M_DONTWAIT, MT_HEADER);
343: if (m == NULL) {
344: printf("vv%d: can't initialize, m_get() failed\n", unit);
345: return (0);
346: }
347: m->m_next = 0;
348: m->m_off = MMINOFF;
349: m->m_len = sizeof(struct vv_header);
350: v = mtod(m, struct vv_header *);
351: v->vh_dhost = VV_BROADCAST; /* multicast destination address */
352: v->vh_shost = 0; /* will be overwritten with ours */
353: v->vh_version = RING_VERSION;
354: v->vh_type = RING_DIAGNOSTICS;
355: v->vh_info = 0;
356: /* map xmit message into uba, copying to intermediate buffer */
357: vs->vs_olen = if_wubaput(&vs->vs_ifuba, m);
358:
359: /*
360: * For each of the modes (digital, analog, network), go through
361: * a self-test that requires me to send VVIDENTSUCC good packets
362: * in VVIDENTRETRY attempts. Use broadcast destination to find out
363: * who I am, then use this as my address to check my address match
364: * logic. Only data checked is the vh_type field.
365: */
366:
367: for (i = 0; i < 3; i++) {
368: successes = 0; /* clear successes for this mode */
369: failures = 0; /* and clear failures, too */
370:
371: /* take over device, and leave ring */
372: addr->vvicsr = VV_RST;
373: addr->vvocsr = VV_RST;
374: addr->vvicsr = vv_modes[i]; /* test mode */
375:
376: /*
377: * let the flag and token timers pop so that the init ring bit
378: * will be allowed to work, by waiting about 1 second
379: */
380: DELAY(1000000L);
381:
382: /*
383: * retry loop
384: */
385: while ((successes < VVIDENTSUCC) && (failures < VVIDENTRETRY))
386: {
387: /* start a receive */
388: ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
389: addr->vvicsr = VV_RST | vv_modes[i]; /* abort last */
390: addr->vviba = (u_short) ubainfo;
391: addr->vviea = (u_short) (ubainfo >> 16);
392: addr->vviwc = -(VVBUFSIZE) >> 1;
393: addr->vvicsr = vv_modes[i] | VV_DEN | VV_ENB;
394:
395: /* purge stale data from BDP */
396: if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
397: UBAPURGE(vs->vs_ifuba.ifu_uba,
398: vs->vs_ifuba.ifu_w.ifrw_bdp);
399:
400: /* do a transmit */
401: ubainfo = vs->vs_ifuba.ifu_w.ifrw_info;
402: addr->vvocsr = VV_RST; /* abort last try */
403: addr->vvoba = (u_short) ubainfo;
404: addr->vvoea = (u_short) (ubainfo >> 16);
405: addr->vvowc = -((vs->vs_olen + 1) >> 1);
406: addr->vvocsr = VV_CPB | VV_DEN | VV_INR | VV_ENB;
407:
408: /* poll receive side for completion */
409: DELAY(10000); /* give it a chance */
410: for (waitcount = 0; waitcount < 10; waitcount++) {
411: if (addr->vvicsr & VV_RDY)
412: goto gotit;
413: DELAY(1000);
414: }
415: failures++; /* no luck */
416: continue;
417:
418: gotit: /* we got something--is it any good? */
419: if ((addr->vvicsr & (VVRERR|VV_LDE)) ||
420: (addr->vvocsr & (VVXERR|VV_RFS))) {
421: failures++;
422: continue;
423: }
424:
425: /* Purge BDP before looking at received packet */
426: if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
427: UBAPURGE(vs->vs_ifuba.ifu_uba,
428: vs->vs_ifuba.ifu_r.ifrw_bdp);
429: m = if_rubaget(&vs->vs_ifuba, sizeof(struct vv_header),
430: 0, &vs->vs_if);
431: if (m != NULL)
432: m_freem(m);
433:
434: v = (struct vv_header *)(vs->vs_ifuba.ifu_r.ifrw_addr);
435:
436: /* check message type, catch our node address */
437: if ((v->vh_type & 0xff) == RING_DIAGNOSTICS) {
438: if (shost == NOHOST) {
439: shost = v->vh_shost & 0xff;
440: /* send to ourself now */
441: ((struct vv_header *)
442: (vs->vs_ifuba.ifu_r.ifrw_addr))
443: ->vh_dhost = shost;
444: }
445: successes++;
446: } else {
447: failures++;
448: }
449: v->vh_type = 0; /* clear to check again */
450: }
451:
452: if (failures >= VVIDENTRETRY)
453: {
454: printf("vv%d: failed self-test after %d tries \
455: in %s mode\n",
456: unit, VVIDENTRETRY, i == 0 ? "digital loopback" :
457: (i == 1 ? "analog loopback" : "network"));
458: printf("vv%d: icsr = %b, ocsr = %b\n",
459: unit, 0xffff & addr->vvicsr, VV_IBITS,
460: 0xffff & addr->vvocsr, VV_OBITS);
461: addr->vvicsr = VV_RST; /* kill the sick board */
462: addr->vvocsr = VV_RST;
463: shost = NOHOST;
464: goto done;
465: }
466: }
467:
468: done:
469: /* deallocate mbuf used for send packet (won't be one, anyways) */
470: if (vs->vs_ifuba.ifu_xtofree) {
471: m_freem(vs->vs_ifuba.ifu_xtofree);
472: vs->vs_ifuba.ifu_xtofree = 0;
473: }
474:
475: return(shost);
476: }
477:
478: /*
479: * Start or restart output on interface.
480: * If interface is active, this is a retransmit, so just
481: * restuff registers and go.
482: * If interface is not already active, get another datagram
483: * to send off of the interface queue, and map it to the interface
484: * before starting the output.
485: */
486: vvstart(dev)
487: dev_t dev;
488: {
489: register struct uba_device *ui;
490: register struct vv_softc *vs;
491: register struct vvreg *addr;
492: register struct mbuf *m;
493: register int unit, ubainfo, dest, s;
494:
495: unit = VVUNIT(dev);
496: ui = vvinfo[unit];
497: vs = &vv_softc[unit];
498: if (vs->vs_oactive)
499: goto restart;
500: /*
501: * Not already active: dequeue another request
502: * and map it to the UNIBUS. If no more requests,
503: * just return.
504: */
505: s = splimp();
506: IF_DEQUEUE(&vs->vs_if.if_snd, m);
507: splx(s);
508: if (m == NULL) {
509: vs->vs_oactive = 0;
510: return;
511: }
512: dest = mtod(m, struct vv_header *)->vh_dhost;
513: vs->vs_olen = if_wubaput(&vs->vs_ifuba, m);
514: vs->vs_lastx = dest;
515: restart:
516: /*
517: * Have request mapped to UNIBUS for transmission.
518: * Purge any stale data from this BDP, and start the output.
519: *
520: * Make sure this packet will fit in the interface.
521: */
522: if (vs->vs_olen > VVBUFSIZE) {
523: printf("vv%d vs_olen: %d > VVBUFSIZE\n", unit, vs->vs_olen);
524: panic("vvdriver vs_olen botch");
525: }
526:
527: vs->vs_if.if_timer = VVTIMEOUT;
528: vs->vs_oactive = 1;
529:
530: /* ship it */
531: if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
532: UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_w.ifrw_bdp);
533: addr = (struct vvreg *)ui->ui_addr;
534: ubainfo = vs->vs_ifuba.ifu_w.ifrw_info;
535: addr->vvoba = (u_short) ubainfo;
536: addr->vvoea = (u_short) (ubainfo >> 16);
537: addr->vvowc = -((vs->vs_olen + 1) >> 1);
538: addr->vvowc = -((vs->vs_olen + 1) >> 1); /* extra byte is garbage */
539: if (addr->vvocsr & VV_NOK)
540: vs->vs_init++; /* count ring inits */
541: addr->vvocsr = VV_IEN | VV_CPB | VV_DEN | VV_INR | VV_ENB;
542: }
543:
544: /*
545: * proNET transmit interrupt
546: * Start another output if more data to send.
547: */
548: vvxint(unit)
549: int unit;
550: {
551: register struct uba_device *ui;
552: register struct vv_softc *vs;
553: register struct vvreg *addr;
554: register int oc;
555:
556: ui = vvinfo[unit];
557: vs = &vv_softc[unit];
558: vs->vs_if.if_timer = 0;
559: addr = (struct vvreg *)ui->ui_addr;
560: oc = 0xffff & (addr->vvocsr);
561: if (vs->vs_oactive == 0) {
562: vvprintf("vv%d: stray interrupt vvocsr = %b\n", unit,
563: oc, VV_OBITS);
564: return;
565: }
566:
567: /*
568: * we retransmit on soft error
569: * TODO: sort retransmits to end of queue if possible!
570: */
571: if (oc & (VV_OPT | VV_RFS)) {
572: if (vs->vs_tries++ < VVRETRY) {
573: if (oc & VV_OPT)
574: vs->vs_otimeout++;
575: if (oc & VV_RFS) {
576: vs->vs_if.if_collisions++;
577: vs->vs_refused++;
578: }
579: vvstart(unit); /* restart this message */
580: return;
581: }
582: }
583: vs->vs_if.if_opackets++;
584: vs->vs_oactive = 0;
585: vs->vs_tries = 0;
586:
587: if (oc & VVXERR) {
588: vs->vs_if.if_oerrors++;
589: vvprintf("vv%d: error vvocsr = %b\n", unit, 0xffff & oc,
590: VV_OBITS);
591: }
592: if (vs->vs_ifuba.ifu_xtofree) {
593: m_freem(vs->vs_ifuba.ifu_xtofree);
594: vs->vs_ifuba.ifu_xtofree = 0;
595: }
596: vvstart(unit);
597: }
598:
599: /*
600: * Transmit watchdog timer routine.
601: * This routine gets called when we lose a transmit interrupt.
602: * The best we can do is try to restart output.
603: */
604: vvwatchdog(unit)
605: int unit;
606: {
607: register struct vv_softc *vs;
608: register int s;
609:
610: vs = &vv_softc[unit];
611: vvprintf("vv%d: lost a transmit interrupt.\n", unit);
612: vs->vs_timeouts++;
613: s = splimp();
614: vvstart(unit);
615: splx(s);
616: }
617:
618: /*
619: * proNET interface receiver interrupt.
620: * If input error just drop packet.
621: * Otherwise purge input buffered data path and examine
622: * packet to determine type. If can't determine length
623: * from type, then have to drop packet. Otherwise decapsulate
624: * packet based on type and pass to type specific higher-level
625: * input routine.
626: */
627: vvrint(unit)
628: int unit;
629: {
630: register struct vv_softc *vs;
631: register struct vvreg *addr;
632: register struct vv_header *vv;
633: register struct ifqueue *inq;
634: register struct mbuf *m;
635: int ubainfo, len, off, s;
636: short resid;
637:
638: vs = &vv_softc[unit];
639: vs->vs_if.if_ipackets++;
640: addr = (struct vvreg *)vvinfo[unit]->ui_addr;
641:
642: /*
643: * Purge BDP
644: */
645: if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
646: UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_r.ifrw_bdp);
647:
648: /*
649: * receive errors?
650: */
651: if (addr->vvicsr & VVRERR) {
652: vvprintf("vv%d: receive error, vvicsr = %b\n", unit,
653: 0xffff&(addr->vvicsr), VV_IBITS);
654: if (addr->vvicsr & VV_BDF)
655: vs->vs_ibadf++;
656: goto dropit;
657: }
658:
659: /*
660: * parity errors?
661: */
662: if (addr->vvicsr & VV_LDE) {
663: /* we don't have to clear it because the receive command */
664: /* writes 0 to parity bit */
665: vs->vs_parity++;
666:
667: /*
668: * only on 10 megabit proNET is VV_LDE an end-to-end parity
669: * bit. On 80 megabit, it returns to the intended use of
670: * node-to-node parity. End-to-end parity errors on 80 megabit
671: * give VV_BDF.
672: */
673: if (vs->vs_is80 == 0)
674: goto dropit;
675: }
676:
677: /*
678: * Get packet length from residual word count
679: *
680: * Compute header offset if trailer protocol
681: *
682: * Pull packet off interface. Off is nonzero if packet
683: * has trailing header; if_rubaget will then force this header
684: * information to be at the front. The vh_info field
685: * carries the offset to the trailer data in trailer
686: * format packets.
687: */
688: vv = (struct vv_header *)(vs->vs_ifuba.ifu_r.ifrw_addr);
689: vvtracehdr("vi", vv);
690: resid = addr->vviwc & 01777; /* only low 10 bits valid */
691: if (resid)
692: resid |= 0176000; /* high 6 bits are undefined */
693: len = ((VVBUFSIZE >> 1) + resid) << 1;
694: len -= sizeof(struct vv_header);
695:
696: if ((addr->vvicsr & VV_DPR) || len > VVMRU || len <= 0) {
697: vvprintf("vv%d: len too long or short, \
698: len = %d, vvicsr = %b\n",
699: unit, len, 0xffff&(addr->vvicsr), VV_IBITS);
700: goto dropit;
701: }
702:
703: /* check the protocol header version */
704: if (vv->vh_version != RING_VERSION) {
705: vvprintf("vv%d: bad protocol header version %d\n",
706: unit, vv->vh_version & 0xff);
707: goto dropit;
708: }
709:
710: #define vvdataaddr(vv, off, type) ((type)(((caddr_t)((vv)+1)+(off))))
711: if (vv->vh_type == RING_TRAILER ) {
712: off = ntohs((u_short)vv->vh_info);
713: if (off > VVMTU) {
714: vvprintf("vv%d: off > VVMTU, off = %d, vvicsr = %b\n",
715: unit, off, 0xffff&(addr->vvicsr), VV_IBITS);
716: goto dropit;
717: }
718: vv->vh_type = ntohs(*vvdataaddr(vv, off, u_short *));
719: resid = ntohs(*(vvdataaddr(vv, off+sizeof(u_short), u_short *)));
720: if (off + resid > len) {
721: vvprintf("vv%d: trailer packet too short\n", unit);
722: vvprintf("vv%d: off = %d, resid = %d, vvicsr = %b\n",
723: unit, off, resid,
724: 0xffff&(addr->vvicsr), VV_IBITS);
725: goto dropit;
726: }
727: len = off + resid;
728: } else
729: off = 0;
730:
731: if (len == 0) {
732: vvprintf("vv%d: len is zero, vvicsr = %b\n", unit,
733: 0xffff&(addr->vvicsr), VV_IBITS);
734: goto dropit;
735: }
736:
737: m = if_rubaget(&vs->vs_ifuba, len, off, &vs->vs_if);
738: if (m == NULL) {
739: vvprintf("vv%d: if_rubaget() failed, vvicsr = %b\n", unit,
740: 0xffff&(addr->vvicsr), VV_IBITS);
741: goto dropit;
742: }
743: if (off) {
744: struct ifnet *ifp;
745:
746: ifp = *(mtod(m, struct ifnet **));
747: m->m_off += 2 * sizeof (u_short);
748: m->m_len -= 2 * sizeof (u_short);
749: *(mtod(m, struct ifnet **)) = ifp;
750: }
751:
752: /* Keep track of source address of this packet */
753: vs->vs_lastr = vv->vh_shost;
754:
755: /*
756: * Demultiplex on packet type
757: */
758: switch (vv->vh_type) {
759:
760: #ifdef INET
761: case RING_IP:
762: schednetisr(NETISR_IP);
763: inq = &ipintrq;
764: break;
765: #endif
766: default:
767: vvprintf("vv%d: unknown pkt type 0x%x\n", unit, vv->vh_type);
768: m_freem(m);
769: goto setup;
770: }
771: s = splimp();
772: if (IF_QFULL(inq)) {
773: IF_DROP(inq);
774: m_freem(m);
775: } else
776: IF_ENQUEUE(inq, m);
777:
778: splx(s);
779: /*
780: * Reset for the next packet.
781: */
782: setup:
783: ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
784: addr->vviba = (u_short) ubainfo;
785: addr->vviea = (u_short) (ubainfo >> 16);
786: addr->vviwc = -(VVBUFSIZE) >> 1;
787: addr->vvicsr = VV_HEN | VV_IEN | VV_DEN | VV_ENB;
788: return;
789:
790: /*
791: * Drop packet on floor -- count them!!
792: */
793: dropit:
794: vs->vs_if.if_ierrors++;
795: goto setup;
796: }
797:
798: /*
799: * proNET output routine.
800: * Encapsulate a packet of type family for the local net.
801: * Use trailer local net encapsulation if enough data in first
802: * packet leaves a multiple of 512 bytes of data in remainder.
803: */
804: vvoutput(ifp, m0, dst)
805: struct ifnet *ifp;
806: struct mbuf *m0;
807: struct sockaddr *dst;
808: {
809: register struct mbuf *m;
810: register struct vv_header *vv;
811: register int off;
812: register int unit;
813: register struct vvreg *addr;
814: register struct vv_softc *vs;
815: register int s;
816: int type, dest, error;
817:
818: m = m0;
819: unit = ifp->if_unit;
820: addr = (struct vvreg *)vvinfo[unit]->ui_addr;
821: vs = &vv_softc[unit];
822:
823: /*
824: * Check to see if the input side has wedged due the UBA
825: * vectoring through 0.
826: *
827: * We are lower than device ipl when we enter this routine,
828: * so if the interface is ready with an input packet then
829: * an input interrupt must have slipped through the cracks.
830: *
831: * Avoid the race with an input interrupt by watching to see
832: * if any packets come in.
833: */
834: s = vs->vs_if.if_ipackets;
835: if (addr->vvicsr & VV_RDY && s == vs->vs_if.if_ipackets) {
836: vvprintf("vv%d: lost a receive interrupt, icsr = %b\n",
837: unit, 0xffff&(addr->vvicsr), VV_IBITS);
838: s = splimp();
839: vvrint(unit);
840: splx(s);
841: }
842:
843: switch (dst->sa_family) {
844:
845: #ifdef INET
846: case AF_INET:
847: if (in_broadcast(((struct sockaddr_in *)dst)->sin_addr))
848: dest = VV_BROADCAST;
849: else
850: dest = in_lnaof(((struct sockaddr_in *)dst)->sin_addr);
851: #ifdef LOOPBACK
852: if (dest == vs->vs_host && (loif.if_flags & IFF_UP))
853: return (looutput(&loif, m0, dst));
854: #endif LOOPBACK
855: if (dest >= 0x100) {
856: error = EPERM;
857: goto bad;
858: }
859: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
860: /*
861: * Trailerize, if the configuration allows it.
862: * TODO: Need per host negotiation.
863: */
864: if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
865: if (off > 0 && (off & 0x1ff) == 0 &&
866: m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
867: type = RING_TRAILER;
868: m->m_off -= 2 * sizeof (u_short);
869: m->m_len += 2 * sizeof (u_short);
870: *mtod(m, u_short *) = htons((short)RING_IP);
871: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
872: goto gottrailertype;
873: }
874: type = RING_IP;
875: off = 0;
876: goto gottype;
877: #endif
878: default:
879: printf("vv%d: can't handle af%d\n", unit, dst->sa_family);
880: error = EAFNOSUPPORT;
881: goto bad;
882: }
883:
884: gottrailertype:
885: /*
886: * Packet to be sent as trailer: move first packet
887: * (control information) to end of chain.
888: */
889: while (m->m_next)
890: m = m->m_next;
891: m->m_next = m0;
892: m = m0->m_next;
893: m0->m_next = 0;
894: m0 = m;
895: gottype:
896: /*
897: * Add local net header. If no space in first mbuf,
898: * allocate another.
899: */
900: if (m->m_off > MMAXOFF ||
901: MMINOFF + sizeof (struct vv_header) > m->m_off) {
902: m = m_get(M_DONTWAIT, MT_HEADER);
903: if (m == NULL) {
904: error = ENOBUFS;
905: goto bad;
906: }
907: m->m_next = m0;
908: m->m_off = MMINOFF;
909: m->m_len = sizeof (struct vv_header);
910: } else {
911: m->m_off -= sizeof (struct vv_header);
912: m->m_len += sizeof (struct vv_header);
913: }
914: vv = mtod(m, struct vv_header *);
915: vv->vh_shost = vs->vs_host;
916: vv->vh_dhost = dest;
917: vv->vh_version = RING_VERSION;
918: vv->vh_type = type;
919: vv->vh_info = htons((u_short)off);
920: vvtracehdr("vo", vv);
921:
922: /*
923: * Queue message on interface, and start output if interface
924: * not yet active.
925: */
926: s = splimp();
927: if (IF_QFULL(&ifp->if_snd)) {
928: IF_DROP(&ifp->if_snd);
929: error = ENOBUFS;
930: goto qfull;
931: }
932: IF_ENQUEUE(&ifp->if_snd, m);
933: if (vs->vs_oactive == 0)
934: vvstart(unit);
935: splx(s);
936: return (0);
937: qfull:
938: m0 = m;
939: splx(s);
940: bad:
941: m_freem(m0);
942: return(error);
943: }
944:
945: /*
946: * Process an ioctl request.
947: */
948: vvioctl(ifp, cmd, data)
949: register struct ifnet *ifp;
950: int cmd;
951: caddr_t data;
952: {
953: struct ifaddr *ifa = (struct ifaddr *) data;
954: int s = splimp(), error = 0;
955:
956: switch (cmd) {
957:
958: case SIOCSIFADDR:
959: ifp->if_flags |= IFF_UP;
960: if ((ifp->if_flags & IFF_RUNNING) == 0)
961: vvinit(ifp->if_unit);
962: /*
963: * Did self-test succeed?
964: */
965: if ((ifp->if_flags & IFF_UP) == 0)
966: error = ENETDOWN;
967: /*
968: * Attempt to check agreement of protocol address
969: * and board address.
970: */
971: switch (ifa->ifa_addr.sa_family) {
972: case AF_INET:
973: if (in_lnaof(IA_SIN(ifa)->sin_addr) !=
974: vv_softc[ifp->if_unit].vs_host)
975: error = EADDRNOTAVAIL;
976: break;
977: }
978: break;
979:
980: default:
981: error = EINVAL;
982: }
983: splx(s);
984: return (error);
985: }
986:
987: /*
988: * vvprt_hdr(s, v) print the local net header in "v"
989: * with title is "s"
990: */
991: vvprt_hdr(s, v)
992: char *s;
993: register struct vv_header *v;
994: {
995: printf("%s: dsvti: 0x%x 0x%x 0x%x 0x%x 0x%x\n",
996: s,
997: 0xff & (int)(v->vh_dhost), 0xff & (int)(v->vh_shost),
998: 0xff & (int)(v->vh_version), 0xff & (int)(v->vh_type),
999: 0xffff & (int)(v->vh_info));
1000: }
1001: #endif NVV
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.