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