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.1 (Berkeley) 6/5/86 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: int dmctimer; /* timer started? */ 60: int dmc_timeout = 8; /* timeout value */ 61: int dmcwatch(); 62: 63: /* 64: * Driver information for auto-configuration stuff. 65: */ 66: int dmcprobe(), dmcattach(), dmcinit(), dmcioctl(); 67: int dmcoutput(), dmcreset(); 68: struct uba_device *dmcinfo[NDMC]; 69: u_short dmcstd[] = { 0 }; 70: struct uba_driver dmcdriver = 71: { dmcprobe, 0, dmcattach, 0, dmcstd, "dmc", dmcinfo }; 72: 73: #define NRCV 7 74: #define NXMT 3 75: #define NCMDS (NRCV+NXMT+4) /* size of command queue */ 76: 77: #define printd if(dmcdebug)printf 78: int dmcdebug = 0; 79: 80: /* error reporting intervals */ 81: #define DMC_RPNBFS 50 82: #define DMC_RPDSC 1 83: #define DMC_RPTMO 10 84: #define DMC_RPDCK 10 85: 86: struct dmc_command { 87: char qp_cmd; /* command */ 88: short qp_ubaddr; /* buffer address */ 89: short qp_cc; /* character count || XMEM */ 90: struct dmc_command *qp_next; /* next command on queue */ 91: }; 92: 93: struct dmcbufs { 94: int ubinfo; /* from uballoc */ 95: short cc; /* buffer size */ 96: short flags; /* access control */ 97: }; 98: #define DBUF_OURS 0 /* buffer is available */ 99: #define DBUF_DMCS 1 /* buffer claimed by somebody */ 100: #define DBUF_XMIT 4 /* transmit buffer */ 101: #define DBUF_RCV 8 /* receive buffer */ 102: 103: 104: /* 105: * DMC software status per interface. 106: * 107: * Each interface is referenced by a network interface structure, 108: * sc_if, which the routing code uses to locate the interface. 109: * This structure contains the output queue for the interface, its address, ... 110: * We also have, for each interface, a set of 7 UBA interface structures 111: * for each, which 112: * contain information about the UNIBUS resources held by the interface: 113: * map registers, buffered data paths, etc. Information is cached in this 114: * structure for use by the if_uba.c routines in running the interface 115: * efficiently. 116: */ 117: struct dmc_softc { 118: struct ifnet sc_if; /* network-visible interface */ 119: struct dmcbufs sc_rbufs[NRCV]; /* receive buffer info */ 120: struct dmcbufs sc_xbufs[NXMT]; /* transmit buffer info */ 121: struct ifubinfo sc_ifuba; /* UNIBUS resources */ 122: struct ifrw sc_ifr[NRCV]; /* UNIBUS receive buffer maps */ 123: struct ifxmt sc_ifw[NXMT]; /* UNIBUS receive buffer maps */ 124: short sc_oused; /* output buffers currently in use */ 125: short sc_iused; /* input buffers given to DMC */ 126: short sc_flag; /* flags */ 127: int sc_nticks; /* seconds since last interrupt */ 128: int sc_ubinfo; /* UBA mapping info for base table */ 129: int sc_errors[4]; /* non-fatal error counters */ 130: #define sc_datck sc_errors[0] 131: #define sc_timeo sc_errors[1] 132: #define sc_nobuf sc_errors[2] 133: #define sc_disc sc_errors[3] 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_ALLOC 0x01 /* unibus resources allocated */ 146: #define DMC_BMAPPED 0x02 /* base table mapped */ 147: #define DMC_RESTART 0x04 /* software restart in progress */ 148: #define DMC_ACTIVE 0x08 /* device active */ 149: #define DMC_RUNNING 0x20 /* device initialized */ 150: 151: struct dmc_base { 152: short d_base[128]; /* DMC base table */ 153: } dmc_base[NDMC]; 154: 155: /* queue manipulation macros */ 156: #define QUEUE_AT_HEAD(qp, head, tail) \ 157: (qp)->qp_next = (head); \ 158: (head) = (qp); \ 159: if ((tail) == (struct dmc_command *) 0) \ 160: (tail) = (head) 161: 162: #define QUEUE_AT_TAIL(qp, head, tail) \ 163: if ((tail)) \ 164: (tail)->qp_next = (qp); \ 165: else \ 166: (head) = (qp); \ 167: (qp)->qp_next = (struct dmc_command *) 0; \ 168: (tail) = (qp) 169: 170: #define DEQUEUE(head, tail) \ 171: (head) = (head)->qp_next;\ 172: if ((head) == (struct dmc_command *) 0)\ 173: (tail) = (head) 174: 175: dmcprobe(reg) 176: caddr_t reg; 177: { 178: register int br, cvec; 179: register struct dmcdevice *addr = (struct dmcdevice *)reg; 180: register int i; 181: 182: #ifdef lint 183: br = 0; cvec = br; br = cvec; 184: dmcrint(0); dmcxint(0); 185: #endif 186: addr->bsel1 = DMC_MCLR; 187: for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--) 188: ; 189: if ((addr->bsel1 & DMC_RUN) == 0) { 190: printf("dmcprobe: can't start device\n" ); 191: return (0); 192: } 193: addr->bsel0 = DMC_RQI|DMC_IEI; 194: /* let's be paranoid */ 195: addr->bsel0 |= DMC_RQI|DMC_IEI; 196: DELAY(1000000); 197: addr->bsel1 = DMC_MCLR; 198: for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--) 199: ; 200: return (1); 201: } 202: 203: /* 204: * Interface exists: make available by filling in network interface 205: * record. System will initialize the interface when it is ready 206: * to accept packets. 207: */ 208: dmcattach(ui) 209: register struct uba_device *ui; 210: { 211: register struct dmc_softc *sc = &dmc_softc[ui->ui_unit]; 212: 213: sc->sc_if.if_unit = ui->ui_unit; 214: sc->sc_if.if_name = "dmc"; 215: sc->sc_if.if_mtu = DMCMTU; 216: sc->sc_if.if_init = dmcinit; 217: sc->sc_if.if_output = dmcoutput; 218: sc->sc_if.if_ioctl = dmcioctl; 219: sc->sc_if.if_reset = dmcreset; 220: sc->sc_if.if_flags = IFF_POINTOPOINT; 221: sc->sc_ifuba.iff_flags = UBA_CANTWAIT; 222: 223: if (dmctimer == 0) { 224: dmctimer = 1; 225: timeout(dmcwatch, (caddr_t) 0, hz); 226: } 227: if_attach(&sc->sc_if); 228: } 229: 230: /* 231: * Reset of interface after UNIBUS reset. 232: * If interface is on specified UBA, reset its state. 233: */ 234: dmcreset(unit, uban) 235: int unit, uban; 236: { 237: register struct uba_device *ui; 238: register struct dmc_softc *sc = &dmc_softc[unit]; 239: 240: if (unit >= NDMC || (ui = dmcinfo[unit]) == 0 || ui->ui_alive == 0 || 241: ui->ui_ubanum != uban) 242: return; 243: printf(" dmc%d", unit); 244: sc->sc_flag = 0; 245: sc->sc_if.if_flags &= ~IFF_RUNNING; 246: dmcinit(unit); 247: } 248: 249: /* 250: * Initialization of interface; reinitialize UNIBUS usage. 251: */ 252: dmcinit(unit) 253: int unit; 254: { 255: register struct dmc_softc *sc = &dmc_softc[unit]; 256: register struct uba_device *ui = dmcinfo[unit]; 257: register struct dmcdevice *addr; 258: register struct ifnet *ifp = &sc->sc_if; 259: register struct ifrw *ifrw; 260: register struct ifxmt *ifxp; 261: register struct dmcbufs *rp; 262: register struct dmc_command *qp; 263: struct ifaddr *ifa; 264: int base; 265: int s; 266: 267: addr = (struct dmcdevice *)ui->ui_addr; 268: 269: /* 270: * Check to see that an address has been set 271: * (both local and destination for an address family). 272: */ 273: for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next) 274: if (ifa->ifa_addr.sa_family && ifa->ifa_dstaddr.sa_family) 275: break; 276: if (ifa == (struct ifaddr *) 0) 277: return; 278: 279: if ((addr->bsel1&DMC_RUN) == 0) { 280: printf("dmcinit: DMC not running\n"); 281: ifp->if_flags &= ~IFF_UP; 282: return; 283: } 284: /* map base table */ 285: if ((sc->sc_flag & DMC_BMAPPED) == 0) { 286: sc->sc_ubinfo = uballoc(ui->ui_ubanum, 287: (caddr_t)&dmc_base[unit], sizeof (struct dmc_base), 0); 288: sc->sc_flag |= DMC_BMAPPED; 289: } 290: /* initialize UNIBUS resources */ 291: sc->sc_iused = sc->sc_oused = 0; 292: if ((ifp->if_flags & IFF_RUNNING) == 0) { 293: if (if_ubaminit(&sc->sc_ifuba, ui->ui_ubanum, 294: sizeof(struct dmc_header), (int)btoc(DMCMTU), 295: sc->sc_ifr, NRCV, sc->sc_ifw, NXMT) == 0) { 296: printf("dmc%d: can't allocate uba resources\n", unit); 297: ifp->if_flags &= ~IFF_UP; 298: return; 299: } 300: ifp->if_flags |= IFF_RUNNING; 301: } 302: sc->sc_flag |= DMC_RUNNING; 303: 304: /* initialize buffer pool */ 305: /* receives */ 306: ifrw = &sc->sc_ifr[0]; 307: for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) { 308: rp->ubinfo = ifrw->ifrw_info & 0x3ffff; 309: rp->cc = DMCMTU + sizeof (struct dmc_header); 310: rp->flags = DBUF_OURS|DBUF_RCV; 311: ifrw++; 312: } 313: /* transmits */ 314: ifxp = &sc->sc_ifw[0]; 315: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) { 316: rp->ubinfo = ifxp->ifw_info & 0x3ffff; 317: rp->cc = 0; 318: rp->flags = DBUF_OURS|DBUF_XMIT; 319: ifxp++; 320: } 321: 322: /* set up command queues */ 323: sc->sc_qfreeh = sc->sc_qfreet 324: = sc->sc_qhead = sc->sc_qtail = sc->sc_qactive = 325: (struct dmc_command *)0; 326: /* set up free command buffer list */ 327: for (qp = &sc->sc_cmdbuf[0]; qp < &sc->sc_cmdbuf[NCMDS]; qp++) { 328: QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet); 329: } 330: 331: /* base in */ 332: base = sc->sc_ubinfo & 0x3ffff; 333: dmcload(sc, DMC_BASEI, base, (base>>2) & DMC_XMEM); 334: /* specify half duplex operation, flags tell if primary */ 335: /* or secondary station */ 336: if (ui->ui_flags == 0) 337: /* use DDCMP mode in full duplex */ 338: dmcload(sc, DMC_CNTLI, 0, 0); 339: else if (ui->ui_flags == 1) 340: /* use MAINTENENCE mode */ 341: dmcload(sc, DMC_CNTLI, 0, DMC_MAINT ); 342: else if (ui->ui_flags == 2) 343: /* use DDCMP half duplex as primary station */ 344: dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX); 345: else if (ui->ui_flags == 3) 346: /* use DDCMP half duplex as secondary station */ 347: dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX | DMC_SEC); 348: 349: /* enable operation done interrupts */ 350: sc->sc_flag &= ~DMC_ACTIVE; 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(dev) 372: dev_t dev; 373: { 374: int unit = minor(dev); 375: register struct dmc_softc *sc = &dmc_softc[unit]; 376: struct mbuf *m; 377: register struct dmcbufs *rp; 378: register int n; 379: 380: /* 381: * Dequeue up to NXMT requests and map them to the UNIBUS. 382: * If no more requests, or no dmc buffers available, just return. 383: */ 384: n = 0; 385: for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++ ) { 386: /* find an available buffer */ 387: if ((rp->flags & DBUF_DMCS) == 0) { 388: IF_DEQUEUE(&sc->sc_if.if_snd, m); 389: if (m == 0) 390: return; 391: /* mark it dmcs */ 392: rp->flags |= (DBUF_DMCS); 393: /* 394: * Have request mapped to UNIBUS for transmission 395: * and start the output. 396: */ 397: rp->cc = if_ubaput(&sc->sc_ifuba, &sc->sc_ifw[n], m); 398: rp->cc &= DMC_CCOUNT; 399: sc->sc_oused++; 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: sc->sc_oused--; 656: sc->sc_nticks = 0; 657: sc->sc_flag |= DMC_ACTIVE; 658: break; 659: 660: case DMC_CNTLO: 661: arg &= DMC_CNTMASK; 662: if (arg & DMC_FATAL) { 663: log(LOG_ERR, "dmc%d: fatal error, flags=%b\n", 664: unit, arg, CNTLO_BITS); 665: dmcrestart(unit); 666: break; 667: } 668: /* ACCUMULATE STATISTICS */ 669: switch(arg) { 670: case DMC_NOBUFS: 671: ifp->if_ierrors++; 672: if ((sc->sc_nobuf++ % DMC_RPNBFS) == 0) 673: goto report; 674: break; 675: case DMC_DISCONN: 676: if ((sc->sc_disc++ % DMC_RPDSC) == 0) 677: goto report; 678: break; 679: case DMC_TIMEOUT: 680: if ((sc->sc_timeo++ % DMC_RPTMO) == 0) 681: goto report; 682: break; 683: case DMC_DATACK: 684: ifp->if_oerrors++; 685: if ((sc->sc_datck++ % DMC_RPDCK) == 0) 686: goto report; 687: break; 688: default: 689: goto report; 690: } 691: break; 692: report: 693: printd("dmc%d: soft error, flags=%b\n", unit, 694: arg, CNTLO_BITS); 695: if ((sc->sc_flag & DMC_RESTART) == 0) { 696: /* 697: * kill off the dmc to get things 698: * going again by generating a 699: * procedure error 700: */ 701: sc->sc_flag |= DMC_RESTART; 702: arg = sc->sc_ubinfo & 0x3ffff; 703: dmcload(sc, DMC_BASEI, arg, (arg>>2)&DMC_XMEM); 704: } 705: break; 706: 707: default: 708: printf("dmc%d: bad control %o\n", unit, cmd); 709: break; 710: } 711: } 712: dmcstart(unit); 713: return; 714: } 715: 716: /* 717: * DMC output routine. 718: * Encapsulate a packet of type family for the dmc. 719: * Use trailer local net encapsulation if enough data in first 720: * packet leaves a multiple of 512 bytes of data in remainder. 721: */ 722: dmcoutput(ifp, m0, dst) 723: register struct ifnet *ifp; 724: register struct mbuf *m0; 725: struct sockaddr *dst; 726: { 727: int type, error, s; 728: register struct mbuf *m = m0; 729: register struct dmc_header *dh; 730: register int off; 731: 732: switch (dst->sa_family) { 733: #ifdef INET 734: case AF_INET: 735: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; 736: if ((ifp->if_flags & IFF_NOTRAILERS) == 0) 737: if (off > 0 && (off & 0x1ff) == 0 && 738: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { 739: type = DMC_TRAILER + (off>>9); 740: m->m_off -= 2 * sizeof (u_short); 741: m->m_len += 2 * sizeof (u_short); 742: *mtod(m, u_short *) = htons((u_short)DMC_IPTYPE); 743: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len); 744: goto gottrailertype; 745: } 746: type = DMC_IPTYPE; 747: off = 0; 748: goto gottype; 749: #endif 750: 751: case AF_UNSPEC: 752: dh = (struct dmc_header *)dst->sa_data; 753: type = dh->dmc_type; 754: goto gottype; 755: 756: default: 757: printf("dmc%d: can't handle af%d\n", ifp->if_unit, 758: dst->sa_family); 759: error = EAFNOSUPPORT; 760: goto bad; 761: } 762: 763: gottrailertype: 764: /* 765: * Packet to be sent as a trailer; move first packet 766: * (control information) to end of chain. 767: */ 768: while (m->m_next) 769: m = m->m_next; 770: m->m_next = m0; 771: m = m0->m_next; 772: m0->m_next = 0; 773: m0 = m; 774: 775: gottype: 776: /* 777: * Add local network header 778: * (there is space for a uba on a vax to step on) 779: */ 780: if (m->m_off > MMAXOFF || 781: MMINOFF + sizeof(struct dmc_header) > m->m_off) { 782: m = m_get(M_DONTWAIT, MT_HEADER); 783: if (m == 0) { 784: error = ENOBUFS; 785: goto bad; 786: } 787: m->m_next = m0; 788: m->m_off = MMINOFF; 789: m->m_len = sizeof (struct dmc_header); 790: } else { 791: m->m_off -= sizeof (struct dmc_header); 792: m->m_len += sizeof (struct dmc_header); 793: } 794: dh = mtod(m, struct dmc_header *); 795: dh->dmc_type = htons((u_short)type); 796: 797: /* 798: * Queue message on interface, and start output if interface 799: * not yet active. 800: */ 801: s = splimp(); 802: if (IF_QFULL(&ifp->if_snd)) { 803: IF_DROP(&ifp->if_snd); 804: m_freem(m); 805: splx(s); 806: return (ENOBUFS); 807: } 808: IF_ENQUEUE(&ifp->if_snd, m); 809: dmcstart(ifp->if_unit); 810: splx(s); 811: return (0); 812: 813: bad: 814: m_freem(m0); 815: return (error); 816: } 817: 818: 819: /* 820: * Process an ioctl request. 821: */ 822: /* ARGSUSED */ 823: dmcioctl(ifp, cmd, data) 824: register struct ifnet *ifp; 825: int cmd; 826: caddr_t data; 827: { 828: int s = splimp(), error = 0; 829: register struct dmc_softc *sc = &dmc_softc[ifp->if_unit]; 830: 831: switch (cmd) { 832: 833: case SIOCSIFADDR: 834: ifp->if_flags |= IFF_UP; 835: if ((ifp->if_flags & IFF_RUNNING) == 0) 836: dmcinit(ifp->if_unit); 837: break; 838: 839: case SIOCSIFDSTADDR: 840: if ((ifp->if_flags & IFF_RUNNING) == 0) 841: dmcinit(ifp->if_unit); 842: break; 843: 844: case SIOCSIFFLAGS: 845: if ((ifp->if_flags & IFF_UP) == 0 && 846: sc->sc_flag & DMC_RUNNING) { 847: ((struct dmcdevice *) 848: (dmcinfo[ifp->if_unit]->ui_addr))->bsel1 = DMC_MCLR; 849: sc->sc_flag &= ~DMC_RUNNING; 850: } else if (ifp->if_flags & IFF_UP && 851: (sc->sc_flag & DMC_RUNNING) == 0) 852: dmcrestart(ifp->if_unit); 853: break; 854: 855: default: 856: error = EINVAL; 857: } 858: splx(s); 859: return (error); 860: } 861: 862: /* 863: * Restart after a fatal error. 864: * Clear device and reinitialize. 865: */ 866: dmcrestart(unit) 867: int unit; 868: { 869: register struct dmc_softc *sc = &dmc_softc[unit]; 870: register struct uba_device *ui = dmcinfo[unit]; 871: register struct dmcdevice *addr; 872: register struct ifxmt *ifxp; 873: register int i; 874: 875: addr = (struct dmcdevice *)ui->ui_addr; 876: #ifdef DEBUG 877: /* dump base table */ 878: printf("dmc%d base table:\n", unit); 879: for (i = 0; i < sizeof (struct dmc_base); i++) 880: printf("%o\n" ,dmc_base[unit].d_base[i]); 881: #endif 882: /* 883: * Let the DMR finish the MCLR. At 1 Mbit, it should do so 884: * in about a max of 6.4 milliseconds with diagnostics enabled. 885: */ 886: addr->bsel1 = DMC_MCLR; 887: for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--) 888: ; 889: /* Did the timer expire or did the DMR finish? */ 890: if ((addr->bsel1 & DMC_RUN) == 0) { 891: log(LOG_ERR, "dmc%d: M820 Test Failed\n", unit); 892: return; 893: } 894: 895: for (ifxp = sc->sc_ifw; ifxp < &sc->sc_ifw[NXMT]; ifxp++) { 896: if (ifxp->ifw_xtofree) { 897: (void) m_freem(ifxp->ifw_xtofree); 898: ifxp->ifw_xtofree = 0; 899: } 900: } 901: 902: /* restart DMC */ 903: dmcinit(unit); 904: sc->sc_flag &= ~DMC_RESTART; 905: sc->sc_if.if_collisions++; /* why not? */ 906: } 907: 908: /* 909: * Check to see that transmitted packets don't 910: * lose interrupts. The device has to be active. 911: */ 912: dmcwatch() 913: { 914: register struct uba_device *ui; 915: register struct dmc_softc *sc; 916: struct dmcdevice *addr; 917: register int i; 918: 919: for (i = 0; i < NDMC; i++) { 920: sc = &dmc_softc[i]; 921: if ((sc->sc_flag & DMC_ACTIVE) == 0) 922: continue; 923: if ((ui = dmcinfo[i]) == 0 || ui->ui_alive == 0) 924: continue; 925: if (sc->sc_oused) { 926: sc->sc_nticks++; 927: if (sc->sc_nticks > dmc_timeout) { 928: sc->sc_nticks = 0; 929: addr = (struct dmcdevice *)ui->ui_addr; 930: log(LOG_ERR, "dmc%d hung: bsel0=%b bsel2=%b\n", 931: i, addr->bsel0 & 0xff, DMC0BITS, 932: addr->bsel2 & 0xff, DMC2BITS); 933: dmcrestart(i); 934: } 935: } 936: } 937: timeout(dmcwatch, (caddr_t) 0, hz); 938: } 939: #endif
|
Last modified: 1986-06-06
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 2026 |
|