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