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