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