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