![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_dmv.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_dmv.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxif |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that the above copyright notice and this paragraph are ! 7: * duplicated in all such forms and that any documentation, ! 8: * advertising materials, and other materials related to such ! 9: * distribution and use acknowledge that the software was developed ! 10: * by the University of California, Berkeley. The name of the ! 11: * University may not be used to endorse or promote products derived ! 12: * from this software without specific prior written permission. ! 13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 16: * ! 17: * @(#)if_dmv.c 7.5 (Berkeley) 6/29/88 ! 18: */ ! 19: ! 20: /* ! 21: * DMV-11 Driver ! 22: * ! 23: * Qbus Sync DDCMP interface - DMV operated in full duplex, point to point mode ! 24: * ! 25: * Written by Bob Kridle of Mt Xinu ! 26: * starting from if_dmc.c version 6.12 dated 4/23/86 ! 27: */ ! 28: ! 29: #include "dmv.h" ! 30: #if NDMV > 0 ! 31: ! 32: #include "param.h" ! 33: #include "systm.h" ! 34: #include "mbuf.h" ! 35: #include "buf.h" ! 36: #include "ioctl.h" /* must precede tty.h */ ! 37: #include "tty.h" ! 38: #include "protosw.h" ! 39: #include "socket.h" ! 40: #include "syslog.h" ! 41: #include "vmmac.h" ! 42: #include "errno.h" ! 43: #include "time.h" ! 44: #include "kernel.h" ! 45: ! 46: #include "../net/if.h" ! 47: #include "../net/netisr.h" ! 48: #include "../net/route.h" ! 49: ! 50: #ifdef INET ! 51: #include "../netinet/in.h" ! 52: #include "../netinet/in_systm.h" ! 53: #include "../netinet/in_var.h" ! 54: #include "../netinet/ip.h" ! 55: #endif ! 56: ! 57: #include "../vax/cpu.h" ! 58: #include "../vax/mtpr.h" ! 59: #include "../vax/pte.h" ! 60: #include "../vaxuba/ubareg.h" ! 61: #include "../vaxuba/ubavar.h" ! 62: #include "if_uba.h" ! 63: #include "if_dmv.h" ! 64: ! 65: int dmv_timeout = 8; /* timeout value */ ! 66: ! 67: /* ! 68: * Driver information for auto-configuration stuff. ! 69: */ ! 70: int dmvprobe(), dmvattach(), dmvinit(), dmvioctl(); ! 71: int dmvoutput(), dmvreset(), dmvtimeout(); ! 72: struct uba_device *dmvinfo[NDMV]; ! 73: u_short dmvstd[] = { 0 }; ! 74: struct uba_driver dmvdriver = ! 75: { dmvprobe, 0, dmvattach, 0, dmvstd, "dmv", dmvinfo }; ! 76: ! 77: /* ! 78: * Don't really know how many buffers/commands can be queued to a DMV-11. ! 79: * Manual doesn't say... Perhaps we can look at a DEC driver some day. ! 80: * These numbers ame from DMC/DMR driver. ! 81: */ ! 82: #define NRCV 5 ! 83: #define NXMT 3 ! 84: #define NCMDS (NRCV+NXMT+4) /* size of command queue */ ! 85: ! 86: #ifdef DEBUG ! 87: #define printd(f) if (sc->sc_if.if_flags & IFF_DEBUG) \ ! 88: printf("DMVDEBUG: dmv%d: ", unit), printf(f) ! 89: #else ! 90: #define printd(f) /* nil */ ! 91: #endif ! 92: ! 93: /* error reporting intervals */ ! 94: ! 95: #define DMV_RPRTE 1 ! 96: #define DMV_RPTTE 1 ! 97: #define DMV_RPSTE 1 ! 98: #define DMV_RPNXM 1 ! 99: #define DMV_RPMODD 1 ! 100: #define DMV_RPQOVF 1 ! 101: #define DMV_RPCXRL 1 ! 102: ! 103: /* number of errors to accept before trying a reset */ ! 104: #define DMV_RPUNKNOWN 10 ! 105: ! 106: struct dmv_command { ! 107: u_char qp_mask; /* Which registers to set up */ ! 108: #define QP_TRIB 0x01 ! 109: #define QP_SEL4 0x02 ! 110: #define QP_SEL6 0x04 ! 111: #define QP_SEL10 0x08 ! 112: u_char qp_cmd; ! 113: u_char qp_tributary; ! 114: u_short qp_sel4; ! 115: u_short qp_sel6; ! 116: u_short qp_sel10; ! 117: struct dmv_command *qp_next; /* next command on queue */ ! 118: }; ! 119: ! 120: #define qp_lowbufaddr qp_ ! 121: ! 122: struct dmvbufs { ! 123: int ubinfo; /* from uballoc */ ! 124: short cc; /* buffer size */ ! 125: short flags; /* access control */ ! 126: }; ! 127: ! 128: #define DBUF_OURS 0 /* buffer is available */ ! 129: #define DBUF_DMVS 1 /* buffer claimed by somebody */ ! 130: #define DBUF_XMIT 4 /* transmit buffer */ ! 131: #define DBUF_RCV 8 /* receive buffer */ ! 132: ! 133: ! 134: /* ! 135: * DMV software status per interface. ! 136: * ! 137: * Each interface is referenced by a network interface structure, ! 138: * sc_if, which the routing code uses to locate the interface. ! 139: * This structure contains the output queue for the interface, its address, ... ! 140: * We also have, for each interface, a set of 7 UBA interface structures ! 141: * for each, which ! 142: * contain information about the UNIBUS resources held by the interface: ! 143: * map registers, buffered data paths, etc. Information is cached in this ! 144: * structure for use by the if_uba.c routines in running the interface ! 145: * efficiently. ! 146: */ ! 147: struct dmv_softc { ! 148: struct ifnet sc_if; /* network-visible interface */ ! 149: short sc_oused; /* output buffers currently in use */ ! 150: short sc_iused; /* input buffers given to DMV */ ! 151: short sc_flag; /* flags */ ! 152: int sc_ubinfo; /* UBA mapping info for base table */ ! 153: int sc_errors[8]; /* error counters */ ! 154: #define sc_rte sc_errors[0] /* receive threshhold error */ ! 155: #define sc_xte sc_errors[1] /* xmit threshhold error */ ! 156: #define sc_ste sc_errors[2] /* select threshhold error */ ! 157: #define sc_nxm sc_errors[3] /* non-existant memory */ ! 158: #define sc_modd sc_errors[4] /* modem disconnect */ ! 159: #define sc_qovf sc_errors[5] /* command/response queue overflow */ ! 160: #define sc_cxrl sc_errors[6] /* carrier loss */ ! 161: #define sc_unknown sc_errors[7] /* other errors - look in DMV manual */ ! 162: struct dmvbufs sc_rbufs[NRCV]; /* receive buffer info */ ! 163: struct dmvbufs sc_xbufs[NXMT]; /* transmit buffer info */ ! 164: struct ifubinfo sc_ifuba; /* UNIBUS resources */ ! 165: struct ifrw sc_ifr[NRCV]; /* UNIBUS receive buffer maps */ ! 166: struct ifxmt sc_ifw[NXMT]; /* UNIBUS receive buffer maps */ ! 167: /* command queue stuff */ ! 168: struct dmv_command sc_cmdbuf[NCMDS]; ! 169: struct dmv_command *sc_qhead; /* head of command queue */ ! 170: struct dmv_command *sc_qtail; /* tail of command queue */ ! 171: struct dmv_command *sc_qactive; /* command in progress */ ! 172: struct dmv_command *sc_qfreeh; /* head of list of free cmd buffers */ ! 173: struct dmv_command *sc_qfreet; /* tail of list of free cmd buffers */ ! 174: /* end command queue stuff */ ! 175: } dmv_softc[NDMV]; ! 176: ! 177: /* flags */ ! 178: #define DMV_RESTART 0x01 /* software restart in progress */ ! 179: #define DMV_ONLINE 0x02 /* device managed to transmit */ ! 180: #define DMV_RUNNING 0x04 /* device initialized */ ! 181: ! 182: ! 183: /* queue manipulation macros */ ! 184: #define QUEUE_AT_HEAD(qp, head, tail) \ ! 185: (qp)->qp_next = (head); \ ! 186: (head) = (qp); \ ! 187: if ((tail) == (struct dmv_command *) 0) \ ! 188: (tail) = (head) ! 189: ! 190: #define QUEUE_AT_TAIL(qp, head, tail) \ ! 191: if ((tail)) \ ! 192: (tail)->qp_next = (qp); \ ! 193: else \ ! 194: (head) = (qp); \ ! 195: (qp)->qp_next = (struct dmv_command *) 0; \ ! 196: (tail) = (qp) ! 197: ! 198: #define DEQUEUE(head, tail) \ ! 199: (head) = (head)->qp_next;\ ! 200: if ((head) == (struct dmv_command *) 0)\ ! 201: (tail) = (head) ! 202: ! 203: dmvprobe(reg) ! 204: caddr_t reg; ! 205: { ! 206: register int br, cvec; ! 207: register struct dmvdevice *addr = (struct dmvdevice *)reg; ! 208: register int i; ! 209: ! 210: #ifdef lint ! 211: br = 0; cvec = br; br = cvec; ! 212: dmvrint(0); dmvxint(0); ! 213: #endif ! 214: addr->bsel1 = DMV_MCLR; ! 215: for (i = 100000; i && (addr->bsel1 & DMV_RUN) == 0; i--) ! 216: ; ! 217: if ((addr->bsel1 & DMV_RUN) == 0) { ! 218: printf("dmvprobe: can't start device\n" ); ! 219: return (0); ! 220: } ! 221: if ((addr->bsel4 != 033) || (addr->bsel6 != 0305)) ! 222: { ! 223: printf("dmvprobe: device init failed, bsel4=%o, bsel6=%o\n", ! 224: addr->bsel4, addr->bsel6); ! 225: return (0); ! 226: } ! 227: addr->bsel0 = DMV_RQI|DMV_IEI|DMV_IEO; ! 228: DELAY(1000000); ! 229: addr->bsel1 = DMV_MCLR; ! 230: for (i = 100000; i && (addr->bsel1 & DMV_RUN) == 0; i--) ! 231: ; ! 232: br = 0x15; /* screwy interrupt structure */ ! 233: return (1); ! 234: } ! 235: ! 236: /* ! 237: * Interface exists: make available by filling in network interface ! 238: * record. System will initialize the interface when it is ready ! 239: * to accept packets. ! 240: */ ! 241: dmvattach(ui) ! 242: register struct uba_device *ui; ! 243: { ! 244: register struct dmv_softc *sc = &dmv_softc[ui->ui_unit]; ! 245: ! 246: sc->sc_if.if_unit = ui->ui_unit; ! 247: sc->sc_if.if_name = "dmv"; ! 248: sc->sc_if.if_mtu = DMVMTU; ! 249: sc->sc_if.if_init = dmvinit; ! 250: sc->sc_if.if_output = dmvoutput; ! 251: sc->sc_if.if_ioctl = dmvioctl; ! 252: sc->sc_if.if_reset = dmvreset; ! 253: sc->sc_if.if_watchdog = dmvtimeout; ! 254: sc->sc_if.if_flags = IFF_POINTOPOINT; ! 255: sc->sc_ifuba.iff_flags = UBA_CANTWAIT; ! 256: ! 257: if_attach(&sc->sc_if); ! 258: } ! 259: ! 260: /* ! 261: * Reset of interface after UNIBUS reset. ! 262: * If interface is on specified UBA, reset its state. ! 263: */ ! 264: dmvreset(unit, uban) ! 265: int unit, uban; ! 266: { ! 267: register struct uba_device *ui; ! 268: register struct dmv_softc *sc = &dmv_softc[unit]; ! 269: ! 270: if (unit >= NDMV || (ui = dmvinfo[unit]) == 0 || ui->ui_alive == 0 || ! 271: ui->ui_ubanum != uban) ! 272: return; ! 273: printf(" dmv%d", unit); ! 274: sc->sc_flag = 0; ! 275: sc->sc_if.if_flags &= ~IFF_RUNNING; ! 276: dmvinit(unit); ! 277: } ! 278: ! 279: /* ! 280: * Initialization of interface; reinitialize UNIBUS usage. ! 281: */ ! 282: dmvinit(unit) ! 283: int unit; ! 284: { ! 285: register struct dmv_softc *sc = &dmv_softc[unit]; ! 286: register struct uba_device *ui = dmvinfo[unit]; ! 287: register struct dmvdevice *addr; ! 288: register struct ifnet *ifp = &sc->sc_if; ! 289: register struct ifrw *ifrw; ! 290: register struct ifxmt *ifxp; ! 291: register struct dmvbufs *rp; ! 292: register struct dmv_command *qp; ! 293: struct ifaddr *ifa; ! 294: int base; ! 295: int s; ! 296: ! 297: addr = (struct dmvdevice *)ui->ui_addr; ! 298: ! 299: /* ! 300: * Check to see that an address has been set ! 301: * (both local and destination for an address family). ! 302: */ ! 303: for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next) ! 304: if (ifa->ifa_addr.sa_family && ifa->ifa_dstaddr.sa_family) ! 305: break; ! 306: if (ifa == (struct ifaddr *) 0) ! 307: return; ! 308: ! 309: if ((addr->bsel1&DMV_RUN) == 0) { ! 310: log(LOG_CRIT, "dmvinit: dmv%d not running\n", unit); ! 311: ifp->if_flags &= ~IFF_UP; ! 312: return; ! 313: } ! 314: printd(("dmvinit\n")); ! 315: /* initialize UNIBUS resources */ ! 316: sc->sc_iused = sc->sc_oused = 0; ! 317: if ((ifp->if_flags & IFF_RUNNING) == 0) { ! 318: if (if_ubaminit( ! 319: &sc->sc_ifuba, ! 320: ui->ui_ubanum, ! 321: sizeof(struct dmv_header), ! 322: (int)btoc(DMVMTU), ! 323: sc->sc_ifr, ! 324: NRCV, ! 325: sc->sc_ifw, ! 326: NXMT ! 327: ) == 0) { ! 328: log(LOG_CRIT, "dmvinit: dmv%d can't allocate uba resources\n", unit); ! 329: ifp->if_flags &= ~IFF_UP; ! 330: return; ! 331: } ! 332: ifp->if_flags |= IFF_RUNNING; ! 333: } ! 334: /* ! 335: * Limit packets enqueued until we see if we're on the air. ! 336: */ ! 337: ifp->if_snd.ifq_maxlen = 3; ! 338: ! 339: ! 340: /* initialize buffer pool */ ! 341: /* receives */ ! 342: ifrw = &sc->sc_ifr[0]; ! 343: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) { ! 344: rp->ubinfo = ifrw->ifrw_info & 0x3ffff; ! 345: rp->cc = DMVMTU + sizeof (struct dmv_header); ! 346: rp->flags = DBUF_OURS|DBUF_RCV; ! 347: ifrw++; ! 348: } ! 349: /* transmits */ ! 350: ifxp = &sc->sc_ifw[0]; ! 351: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) { ! 352: rp->ubinfo = ifxp->ifw_info & 0x3ffff; ! 353: rp->cc = 0; ! 354: rp->flags = DBUF_OURS|DBUF_XMIT; ! 355: ifxp++; ! 356: } ! 357: ! 358: /* set up command queues */ ! 359: sc->sc_qfreeh = sc->sc_qfreet ! 360: = sc->sc_qhead = sc->sc_qtail = sc->sc_qactive = ! 361: (struct dmv_command *)0; ! 362: /* set up free command buffer list */ ! 363: for (qp = &sc->sc_cmdbuf[0]; qp < &sc->sc_cmdbuf[NCMDS]; qp++) { ! 364: QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet); ! 365: } ! 366: if(sc->sc_flag & DMV_RUNNING) ! 367: dmvload( sc, DMV_CNTRLI, (QP_TRIB|QP_SEL6), 1, 0, DMV_REQHS,0); ! 368: else ! 369: dmvload( sc, DMV_CNTRLI, (QP_TRIB|QP_SEL6), 1, 0, DMV_ESTTRIB,0); ! 370: dmvload( sc, DMV_CNTRLI, (QP_TRIB|QP_SEL6), 1, 0, DMV_REQSUS,0); ! 371: sc->sc_flag |= (DMV_RESTART|DMV_RUNNING); ! 372: sc->sc_flag &= ~DMV_ONLINE; ! 373: addr->bsel0 |= DMV_IEO; ! 374: } ! 375: ! 376: /* ! 377: * Start output on interface. Get another datagram ! 378: * to send from the interface queue and map it to ! 379: * the interface before starting output. ! 380: * ! 381: * Must be called at spl 5 ! 382: */ ! 383: dmvstart(dev) ! 384: dev_t dev; ! 385: { ! 386: int unit = minor(dev); ! 387: register struct dmv_softc *sc = &dmv_softc[unit]; ! 388: struct mbuf *m; ! 389: register struct dmvbufs *rp; ! 390: register int n; ! 391: ! 392: /* ! 393: * Dequeue up to NXMT requests and map them to the UNIBUS. ! 394: * If no more requests, or no dmv buffers available, just return. ! 395: */ ! 396: printd(("dmvstart\n")); ! 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_DMVS) == 0) { ! 401: IF_DEQUEUE(&sc->sc_if.if_snd, m); ! 402: if (m == 0) ! 403: return; ! 404: /* mark it dmvs */ ! 405: rp->flags |= (DBUF_DMVS); ! 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: if (++sc->sc_oused == 1) ! 412: sc->sc_if.if_timer = dmv_timeout; ! 413: dmvload( ! 414: sc, ! 415: DMV_BACCX, ! 416: QP_TRIB|QP_SEL4|QP_SEL6|QP_SEL10, ! 417: 1, ! 418: rp->ubinfo, ! 419: (rp->ubinfo>>16)&0x3f, ! 420: rp->cc ! 421: ); ! 422: } ! 423: n++; ! 424: } ! 425: } ! 426: ! 427: /* ! 428: * Utility routine to load the DMV device registers. ! 429: */ ! 430: dmvload(sc, cmd, mask, tributary, sel4, sel6, sel10) ! 431: register struct dmv_softc *sc; ! 432: u_char cmd, tributary, mask; ! 433: u_short sel4, sel6, sel10; ! 434: { ! 435: register struct dmvdevice *addr; ! 436: register int unit, sps; ! 437: register struct dmv_command *qp; ! 438: ! 439: unit = sc - dmv_softc; ! 440: printd(("dmvload: cmd=%x mask=%x trib=%x sel4=%x sel6=%x sel10=%x\n", ! 441: (unsigned) cmd, ! 442: (unsigned) mask, ! 443: (unsigned) tributary, ! 444: (unsigned) sel4, ! 445: (unsigned) sel6, ! 446: (unsigned) sel10 ! 447: )); ! 448: addr = (struct dmvdevice *)dmvinfo[unit]->ui_addr; ! 449: sps = spl5(); ! 450: ! 451: /* grab a command buffer from the free list */ ! 452: if ((qp = sc->sc_qfreeh) == (struct dmv_command *)0) ! 453: panic("dmv command queue overflow"); ! 454: DEQUEUE(sc->sc_qfreeh, sc->sc_qfreet); ! 455: ! 456: /* fill in requested info */ ! 457: qp->qp_cmd = cmd; ! 458: qp->qp_mask = mask; ! 459: qp->qp_tributary = tributary; ! 460: qp->qp_sel4 = sel4; ! 461: qp->qp_sel6 = sel6; ! 462: qp->qp_sel10 = sel10; ! 463: ! 464: if (sc->sc_qactive) { /* command in progress */ ! 465: if (cmd == DMV_BACCR) { /* supply read buffers first */ ! 466: QUEUE_AT_HEAD(qp, sc->sc_qhead, sc->sc_qtail); ! 467: } else { ! 468: QUEUE_AT_TAIL(qp, sc->sc_qhead, sc->sc_qtail); ! 469: } ! 470: } else { /* command port free */ ! 471: sc->sc_qactive = qp; ! 472: addr->bsel0 = (DMV_RQI|DMV_IEI|DMV_IEO); ! 473: } ! 474: splx(sps); ! 475: } ! 476: /* ! 477: * DMV interface input interrupt. ! 478: * Ready to accept another command, ! 479: * pull one off the command queue. ! 480: */ ! 481: dmvrint(unit) ! 482: int unit; ! 483: { ! 484: register struct dmv_softc *sc; ! 485: register struct dmvdevice *addr; ! 486: register struct dmv_command *qp; ! 487: register int n; ! 488: ! 489: addr = (struct dmvdevice *)dmvinfo[unit]->ui_addr; ! 490: sc = &dmv_softc[unit]; ! 491: printd(("dmvrint\n")); ! 492: if ((qp = sc->sc_qactive) == (struct dmv_command *) 0) { ! 493: log(LOG_WARNING, "dmvrint: dmv%d no command\n", unit); ! 494: return; ! 495: } ! 496: while (addr->bsel2&DMV_RDI) { ! 497: if(qp->qp_mask&QP_SEL4) ! 498: addr->wsel4 = qp->qp_sel4; ! 499: if(qp->qp_mask&QP_SEL6) ! 500: addr->wsel6 = qp->qp_sel6; ! 501: if(qp->qp_mask&QP_SEL10) { ! 502: addr->wsel10 = qp->qp_sel10; ! 503: qp->qp_cmd |= DMV_22BIT; ! 504: } ! 505: if(qp->qp_mask&QP_TRIB) ! 506: addr->wsel2 = qp->qp_cmd|(qp->qp_tributary << 8); ! 507: else ! 508: addr->bsel2 = qp->qp_cmd; ! 509: QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet); ! 510: if ((sc->sc_qactive = sc->sc_qhead) == (struct dmv_command *)0) ! 511: break; ! 512: qp = sc->sc_qactive; ! 513: DEQUEUE(sc->sc_qhead, sc->sc_qtail); ! 514: if (addr->bsel2&DMV_RDO) ! 515: break; ! 516: } ! 517: if (!sc->sc_qactive) { ! 518: if(addr->bsel2&DMV_RDI) { ! 519: /* clear RQI prior to last command per DMV manual */ ! 520: addr->bsel0 &= ~DMV_RQI; ! 521: addr->wsel6 = DMV_NOP; ! 522: addr->bsel2 = DMV_CNTRLI; ! 523: } ! 524: addr->bsel0 = DMV_IEO; ! 525: } ! 526: else /* RDO set or DMV still holding CSR */ ! 527: addr->bsel0 = (DMV_RQI|DMV_IEI|DMV_IEO); ! 528: ! 529: } ! 530: ! 531: /* ! 532: * DMV interface output interrupt. ! 533: * A transfer may have completed, check for errors. ! 534: * If it was a read, notify appropriate protocol. ! 535: * If it was a write, pull the next one off the queue. ! 536: */ ! 537: dmvxint(unit) ! 538: int unit; ! 539: { ! 540: register struct dmv_softc *sc; ! 541: register struct ifnet *ifp; ! 542: struct uba_device *ui = dmvinfo[unit]; ! 543: struct dmvdevice *addr; ! 544: struct mbuf *m; ! 545: struct ifqueue *inq; ! 546: int sel2, sel3, sel4, sel6, sel10, pkaddr, len, s; ! 547: register struct ifrw *ifrw; ! 548: register struct dmvbufs *rp; ! 549: register struct ifxmt *ifxp; ! 550: struct dmv_header *dh; ! 551: int off, resid; ! 552: ! 553: addr = (struct dmvdevice *)ui->ui_addr; ! 554: sc = &dmv_softc[unit]; ! 555: ifp = &sc->sc_if; ! 556: ! 557: while (addr->bsel2 & DMV_RDO) { ! 558: ! 559: sel2 = addr->bsel2; ! 560: sel3 = addr->bsel3; ! 561: sel4 = addr->wsel4; /* release port */ ! 562: sel6 = addr->wsel6; ! 563: if(sel2 & DMV_22BIT) ! 564: sel10 = addr->wsel10; ! 565: addr->bsel2 &= ~DMV_RDO; ! 566: pkaddr = sel4 | ((sel6 & 0x3f) << 16); ! 567: printd(("dmvxint: sel2=%x sel4=%x sel6=%x sel10=%x pkaddr=%x\n", ! 568: (unsigned) sel2, ! 569: (unsigned) sel4, ! 570: (unsigned) sel6, ! 571: (unsigned) sel10, ! 572: (unsigned) pkaddr ! 573: )); ! 574: if((sc->sc_flag & DMV_RUNNING)==0) { ! 575: log(LOG_WARNING, "dmvxint: dmv%d xint while down\n", unit); ! 576: return; ! 577: } ! 578: switch (sel2 & 07) { ! 579: case DMV_BDRUS: ! 580: /* ! 581: * A read has completed. ! 582: * Pass packet to type specific ! 583: * higher-level input routine. ! 584: */ ! 585: ifp->if_ipackets++; ! 586: /* find location in dmvuba struct */ ! 587: ifrw= &sc->sc_ifr[0]; ! 588: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) { ! 589: if(rp->ubinfo == pkaddr) ! 590: break; ! 591: ifrw++; ! 592: } ! 593: if (rp >= &sc->sc_rbufs[NRCV]) ! 594: panic("dmv rcv"); ! 595: if ((rp->flags & DBUF_DMVS) == 0) ! 596: log(LOG_WARNING, "dmvxint: dmv%d done unalloc rbuf\n", unit); ! 597: ! 598: len = (sel10&0x3fff) - sizeof (struct dmv_header); ! 599: if (len < 0 || len > DMVMTU) { ! 600: ifp->if_ierrors++; ! 601: log(LOG_ERR, "dmvxint: dmv%d bad rcv pkt addr 0x%x len 0x%x\n", ! 602: unit, pkaddr, len); ! 603: goto setup; ! 604: } ! 605: /* ! 606: * Deal with trailer protocol: if type is trailer ! 607: * get true type from first 16-bit word past data. ! 608: * Remember that type was trailer by setting off. ! 609: */ ! 610: dh = (struct dmv_header *)ifrw->ifrw_addr; ! 611: dh->dmv_type = ntohs((u_short)dh->dmv_type); ! 612: #define dmvdataaddr(dh, off, type) ((type)(((caddr_t)((dh)+1)+(off)))) ! 613: if (dh->dmv_type >= DMV_TRAILER && ! 614: dh->dmv_type < DMV_TRAILER+DMV_NTRAILER) { ! 615: off = (dh->dmv_type - DMV_TRAILER) * 512; ! 616: if (off >= DMVMTU) ! 617: goto setup; /* sanity */ ! 618: dh->dmv_type = ntohs(*dmvdataaddr(dh, off, u_short *)); ! 619: resid = ntohs(*(dmvdataaddr(dh, off+2, u_short *))); ! 620: if (off + resid > len) ! 621: goto setup; /* sanity */ ! 622: len = off + resid; ! 623: } else ! 624: off = 0; ! 625: if (len == 0) ! 626: goto setup; ! 627: ! 628: /* ! 629: * Pull packet off interface. Off is nonzero if ! 630: * packet has trailing header; dmv_get will then ! 631: * force this header information to be at the front, ! 632: * but we still have to drop the type and length ! 633: * which are at the front of any trailer data. ! 634: */ ! 635: m = if_ubaget(&sc->sc_ifuba, ifrw, len, off, ifp); ! 636: if (m == 0) ! 637: goto setup; ! 638: if (off) { ! 639: ifp = *(mtod(m, struct ifnet **)); ! 640: m->m_off += 2 * sizeof (u_short); ! 641: m->m_len -= 2 * sizeof (u_short); ! 642: *(mtod(m, struct ifnet **)) = ifp; ! 643: } ! 644: switch (dh->dmv_type) { ! 645: #ifdef INET ! 646: case DMV_IPTYPE: ! 647: schednetisr(NETISR_IP); ! 648: inq = &ipintrq; ! 649: break; ! 650: #endif ! 651: default: ! 652: m_freem(m); ! 653: goto setup; ! 654: } ! 655: ! 656: s = splimp(); ! 657: if (IF_QFULL(inq)) { ! 658: IF_DROP(inq); ! 659: m_freem(m); ! 660: } else ! 661: IF_ENQUEUE(inq, m); ! 662: splx(s); ! 663: setup: ! 664: /* is this needed? */ ! 665: rp->ubinfo = ifrw->ifrw_info & 0x3ffff; ! 666: dmvload( ! 667: sc, ! 668: DMV_BACCR, ! 669: QP_SEL4|QP_SEL6|QP_SEL10, ! 670: 0, ! 671: rp->ubinfo, ! 672: (rp->ubinfo>>16)&0x3f, ! 673: rp->cc ! 674: ); ! 675: break; ! 676: case DMV_BDXSA: ! 677: /* ! 678: * A write has completed, start another ! 679: * transfer if there is more data to send. ! 680: */ ! 681: ifp->if_opackets++; ! 682: /* find associated dmvbuf structure */ ! 683: ifxp = &sc->sc_ifw[0]; ! 684: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) { ! 685: if(rp->ubinfo == pkaddr) ! 686: break; ! 687: ifxp++; ! 688: } ! 689: if (rp >= &sc->sc_xbufs[NXMT]) { ! 690: log(LOG_ERR, "dmv%d: bad packet address 0x%x\n", ! 691: unit, pkaddr); ! 692: break; ! 693: } ! 694: if ((rp->flags & DBUF_DMVS) == 0) ! 695: log(LOG_ERR, "dmvxint: dmv%d unallocated packet 0x%x\n", ! 696: unit, pkaddr); ! 697: /* mark buffer free */ ! 698: if (ifxp->ifw_xtofree) { ! 699: (void)m_freem(ifxp->ifw_xtofree); ! 700: ifxp->ifw_xtofree = 0; ! 701: } ! 702: rp->flags &= ~DBUF_DMVS; ! 703: if (--sc->sc_oused == 0) ! 704: sc->sc_if.if_timer = 0; ! 705: else ! 706: sc->sc_if.if_timer = dmv_timeout; ! 707: if ((sc->sc_flag & DMV_ONLINE) == 0) { ! 708: extern int ifqmaxlen; ! 709: ! 710: /* ! 711: * We're on the air. ! 712: * Open the queue to the usual value. ! 713: */ ! 714: sc->sc_flag |= DMV_ONLINE; ! 715: ifp->if_snd.ifq_maxlen = ifqmaxlen; ! 716: } ! 717: break; ! 718: ! 719: case DMV_CNTRLO: ! 720: /* ACCUMULATE STATISTICS */ ! 721: switch(sel6&DMV_EEC) { ! 722: case DMV_ORUN: ! 723: if(sc->sc_flag & DMV_RESTART) { ! 724: load_rec_bufs(sc); ! 725: sc->sc_flag &= ~DMV_RESTART; ! 726: log(LOG_INFO, ! 727: "dmv%d: far end on-line\n", unit); ! 728: } else { ! 729: log(LOG_WARNING, ! 730: "dmv%d: far end restart\n", unit); ! 731: goto restart; ! 732: } ! 733: break; ! 734: case DMV_RTE: ! 735: ifp->if_ierrors++; ! 736: if ((sc->sc_rte++ % DMV_RPRTE) == 0) ! 737: log(LOG_WARNING, ! 738: "dmv%d: receive threshold error\n", ! 739: unit); ! 740: break; ! 741: case DMV_TTE: ! 742: ifp->if_oerrors++; ! 743: if ((sc->sc_xte++ % DMV_RPTTE) == 0) ! 744: log(LOG_WARNING, ! 745: "dmv%d: transmit threshold error\n", ! 746: unit); ! 747: break; ! 748: case DMV_STE: ! 749: if ((sc->sc_ste++ % DMV_RPSTE) == 0) ! 750: log(LOG_WARNING, ! 751: "dmv%d: select threshold error\n", ! 752: unit); ! 753: break; ! 754: case DMV_NXM: ! 755: if ((sc->sc_nxm++ % DMV_RPNXM) == 0) ! 756: log(LOG_WARNING, ! 757: "dmv%d: nonexistent memory error\n", ! 758: unit); ! 759: break; ! 760: case DMV_MODD: ! 761: if ((sc->sc_modd++ % DMV_RPMODD) == 0) { ! 762: log(LOG_WARNING, ! 763: "dmv%d: modem disconnected error\n", ! 764: unit); ! 765: goto restart; ! 766: } ! 767: break; ! 768: case DMV_CXRL: ! 769: if ((sc->sc_cxrl++ % DMV_RPCXRL) == 0) ! 770: log(LOG_WARNING, ! 771: "dmv%d: carrier loss error\n", ! 772: unit); ! 773: break; ! 774: case DMV_QOVF: ! 775: log(LOG_WARNING, ! 776: "dmv%d: response queue overflow\n", ! 777: unit); ! 778: sc->sc_qovf++; ! 779: goto restart; ! 780: ! 781: default: ! 782: log(LOG_WARNING, ! 783: "dmv%d: unknown error %o\n", ! 784: unit, sel6&DMV_EEC); ! 785: if ((sc->sc_unknown++ % DMV_RPUNKNOWN) == 0) ! 786: goto restart; ! 787: break; ! 788: } ! 789: break; ! 790: ! 791: case DMV_BDRUNUS: ! 792: case DMV_BDXSN: ! 793: case DMV_BDXNS: ! 794: log(LOG_INFO, ! 795: "dmv%d: buffer disp for halted trib %o\n", ! 796: unit, sel2&0x7 ! 797: ); ! 798: break; ! 799: ! 800: case DMV_MDEFO: ! 801: if((sel6&0x1f) == 020) { ! 802: log(LOG_INFO, ! 803: "dmv%d: buffer return complete sel3=%x\n", ! 804: unit, sel3); ! 805: } else { ! 806: log(LOG_INFO, ! 807: "dmv%d: info resp sel3=%x sel4=%x sel6=%x\n", ! 808: unit, sel3, sel4, sel6 ! 809: ); ! 810: } ! 811: break; ! 812: ! 813: default: ! 814: log(LOG_WARNING, "dmv%d: bad control %o\n", ! 815: unit, sel2&0x7 ! 816: ); ! 817: break; ! 818: } ! 819: } ! 820: dmvstart(unit); ! 821: return; ! 822: restart: ! 823: dmvrestart(unit); ! 824: } ! 825: ! 826: load_rec_bufs(sc) ! 827: register struct dmv_softc *sc; ! 828: { ! 829: register struct dmvbufs *rp; ! 830: ! 831: /* queue first NRCV buffers for DMV to fill */ ! 832: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) { ! 833: rp->flags |= DBUF_DMVS; ! 834: dmvload( ! 835: sc, ! 836: DMV_BACCR, ! 837: QP_TRIB|QP_SEL4|QP_SEL6|QP_SEL10, ! 838: 1, ! 839: rp->ubinfo, ! 840: (rp->ubinfo>>16)&0x3f, ! 841: rp->cc ! 842: ); ! 843: sc->sc_iused++; ! 844: } ! 845: } ! 846: ! 847: /* ! 848: * DMV output routine. ! 849: * Encapsulate a packet of type family for the dmv. ! 850: * Use trailer local net encapsulation if enough data in first ! 851: * packet leaves a multiple of 512 bytes of data in remainder. ! 852: */ ! 853: dmvoutput(ifp, m0, dst) ! 854: register struct ifnet *ifp; ! 855: register struct mbuf *m0; ! 856: struct sockaddr *dst; ! 857: { ! 858: int type, error, s; ! 859: register struct mbuf *m = m0; ! 860: register struct dmv_header *dh; ! 861: register int off; ! 862: ! 863: if ((ifp->if_flags & IFF_UP) == 0) { ! 864: error = ENETDOWN; ! 865: goto bad; ! 866: } ! 867: ! 868: switch (dst->sa_family) { ! 869: #ifdef INET ! 870: case AF_INET: ! 871: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; ! 872: if ((ifp->if_flags & IFF_NOTRAILERS) == 0) ! 873: if (off > 0 && (off & 0x1ff) == 0 && ! 874: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { ! 875: type = DMV_TRAILER + (off>>9); ! 876: m->m_off -= 2 * sizeof (u_short); ! 877: m->m_len += 2 * sizeof (u_short); ! 878: *mtod(m, u_short *) = htons((u_short)DMV_IPTYPE); ! 879: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len); ! 880: goto gottrailertype; ! 881: } ! 882: type = DMV_IPTYPE; ! 883: off = 0; ! 884: goto gottype; ! 885: #endif ! 886: ! 887: case AF_UNSPEC: ! 888: dh = (struct dmv_header *)dst->sa_data; ! 889: type = dh->dmv_type; ! 890: goto gottype; ! 891: ! 892: default: ! 893: log(LOG_ERR, "dmvoutput, dmv%d can't handle af%d\n", ! 894: ifp->if_unit, dst->sa_family); ! 895: error = EAFNOSUPPORT; ! 896: goto bad; ! 897: } ! 898: ! 899: gottrailertype: ! 900: /* ! 901: * Packet to be sent as a trailer; move first packet ! 902: * (control information) to end of chain. ! 903: */ ! 904: while (m->m_next) ! 905: m = m->m_next; ! 906: m->m_next = m0; ! 907: m = m0->m_next; ! 908: m0->m_next = 0; ! 909: m0 = m; ! 910: ! 911: gottype: ! 912: /* ! 913: * Add local network header ! 914: * (there is space for a uba on a vax to step on) ! 915: */ ! 916: if (m->m_off > MMAXOFF || ! 917: MMINOFF + sizeof(struct dmv_header) > m->m_off) { ! 918: m = m_get(M_DONTWAIT, MT_HEADER); ! 919: if (m == 0) { ! 920: error = ENOBUFS; ! 921: goto bad; ! 922: } ! 923: m->m_next = m0; ! 924: m->m_off = MMINOFF; ! 925: m->m_len = sizeof (struct dmv_header); ! 926: } else { ! 927: m->m_off -= sizeof (struct dmv_header); ! 928: m->m_len += sizeof (struct dmv_header); ! 929: } ! 930: dh = mtod(m, struct dmv_header *); ! 931: dh->dmv_type = htons((u_short)type); ! 932: ! 933: /* ! 934: * Queue message on interface, and start output if interface ! 935: * not yet active. ! 936: */ ! 937: s = splimp(); ! 938: if (IF_QFULL(&ifp->if_snd)) { ! 939: IF_DROP(&ifp->if_snd); ! 940: m_freem(m); ! 941: splx(s); ! 942: return (ENOBUFS); ! 943: } ! 944: IF_ENQUEUE(&ifp->if_snd, m); ! 945: dmvstart(ifp->if_unit); ! 946: splx(s); ! 947: return (0); ! 948: ! 949: bad: ! 950: m_freem(m0); ! 951: return (error); ! 952: } ! 953: ! 954: ! 955: /* ! 956: * Process an ioctl request. ! 957: */ ! 958: /* ARGSUSED */ ! 959: dmvioctl(ifp, cmd, data) ! 960: register struct ifnet *ifp; ! 961: int cmd; ! 962: caddr_t data; ! 963: { ! 964: int s = splimp(), error = 0; ! 965: struct mbuf *m; ! 966: register struct dmv_softc *sc = &dmv_softc[ifp->if_unit]; ! 967: ! 968: switch (cmd) { ! 969: ! 970: case SIOCSIFADDR: ! 971: ifp->if_flags |= IFF_UP; ! 972: if ((ifp->if_flags & IFF_RUNNING) == 0) ! 973: dmvinit(ifp->if_unit); ! 974: break; ! 975: ! 976: case SIOCSIFDSTADDR: ! 977: if ((ifp->if_flags & IFF_RUNNING) == 0) ! 978: dmvinit(ifp->if_unit); ! 979: break; ! 980: ! 981: case SIOCSIFFLAGS: ! 982: if ((ifp->if_flags & IFF_UP) == 0 && ! 983: sc->sc_flag & DMV_RUNNING) ! 984: dmvdown(ifp->if_unit); ! 985: else if (ifp->if_flags & IFF_UP && ! 986: (sc->sc_flag & DMV_RUNNING) == 0) ! 987: dmvrestart(ifp->if_unit); ! 988: break; ! 989: ! 990: default: ! 991: error = EINVAL; ! 992: } ! 993: splx(s); ! 994: return (error); ! 995: } ! 996: ! 997: /* ! 998: * Restart after a fatal error. ! 999: * Clear device and reinitialize. ! 1000: */ ! 1001: dmvrestart(unit) ! 1002: int unit; ! 1003: { ! 1004: register struct dmvdevice *addr; ! 1005: register int i; ! 1006: ! 1007: dmvdown(unit); ! 1008: ! 1009: addr = (struct dmvdevice *)(dmvinfo[unit]->ui_addr); ! 1010: /* ! 1011: * Let the DMV finish the MCLR. ! 1012: */ ! 1013: for (i = 100000; i && (addr->bsel1 & DMV_RUN) == 0; i--) ! 1014: ; ! 1015: if ((addr->bsel1 & DMV_RUN) == 0) { ! 1016: log(LOG_ERR, "dmvrestart: can't start device\n" ); ! 1017: return (0); ! 1018: } ! 1019: if ((addr->bsel4 != 033) || (addr->bsel6 != 0305)) ! 1020: { ! 1021: log(LOG_ERR, "dmv%d: device init failed, bsel4=%o, bsel6=%o\n", ! 1022: unit, addr->bsel4, addr->bsel6); ! 1023: return (0); ! 1024: } ! 1025: ! 1026: /* restart DMV */ ! 1027: dmvinit(unit); ! 1028: dmv_softc[unit].sc_if.if_collisions++; /* why not? */ ! 1029: } ! 1030: ! 1031: /* ! 1032: * Reset a device and mark down. ! 1033: * Flush output queue and drop queue limit. ! 1034: */ ! 1035: dmvdown(unit) ! 1036: int unit; ! 1037: { ! 1038: struct dmv_softc *sc = &dmv_softc[unit]; ! 1039: register struct ifxmt *ifxp; ! 1040: ! 1041: ((struct dmvdevice *)(dmvinfo[unit]->ui_addr))->bsel1 = DMV_MCLR; ! 1042: sc->sc_flag &= ~(DMV_RUNNING | DMV_ONLINE); ! 1043: ! 1044: for (ifxp = sc->sc_ifw; ifxp < &sc->sc_ifw[NXMT]; ifxp++) { ! 1045: if (ifxp->ifw_xtofree) { ! 1046: (void) m_freem(ifxp->ifw_xtofree); ! 1047: ifxp->ifw_xtofree = 0; ! 1048: } ! 1049: } ! 1050: sc->sc_oused = 0; ! 1051: if_qflush(&sc->sc_if.if_snd); ! 1052: ! 1053: /* ! 1054: * Limit packets enqueued until we're back on the air. ! 1055: */ ! 1056: sc->sc_if.if_snd.ifq_maxlen = 3; ! 1057: } ! 1058: ! 1059: /* ! 1060: * Watchdog timeout to see that transmitted packets don't ! 1061: * lose interrupts. The device has to be online. ! 1062: */ ! 1063: dmvtimeout(unit) ! 1064: int unit; ! 1065: { ! 1066: register struct dmv_softc *sc; ! 1067: struct dmvdevice *addr; ! 1068: ! 1069: sc = &dmv_softc[unit]; ! 1070: if (sc->sc_flag & DMV_ONLINE) { ! 1071: addr = (struct dmvdevice *)(dmvinfo[unit]->ui_addr); ! 1072: log(LOG_ERR, "dmv%d: output timeout, bsel0=%b bsel2=%b\n", ! 1073: unit, addr->bsel0 & 0xff, DMV0BITS, ! 1074: addr->bsel2 & 0xff, DMV2BITS); ! 1075: dmvrestart(unit); ! 1076: } ! 1077: } ! 1078: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.