![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to deqna.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / io|
Return to deqna.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 ! root 1: /* ! 2: * DEQNA Ethernet Communications Controller interface, ! 3: * vaguely derived from the driver in Ultrix. ! 4: * Each DEQNA has eight minor devices starting at N*8; ! 5: * the different channels may be caused to receive different ! 6: * Ethernet protocols via ENIOTYPE. ! 7: * Packets read or written have the Ethernet header in front. ! 8: */ ! 9: ! 10: #include "sys/param.h" ! 11: #include "sys/buf.h" ! 12: #include "sys/stream.h" ! 13: #include "sys/ubaddr.h" ! 14: #include "sys/conf.h" ! 15: #include "sys/enio.h" ! 16: #include "sys/deqna.h" ! 17: #include "sys/ethernet.h" ! 18: ! 19: struct qedevice { ! 20: unsigned short qe_sta_addr[2]; /* ethernet addr; 6 shorts, overlaid */ ! 21: unsigned short qe_rcvlist_lo; /* rcv list addr */ ! 22: unsigned short qe_rcvlist_hi; ! 23: unsigned short qe_xmtlist_lo; /* xmt list addr */ ! 24: unsigned short qe_xmtlist_hi; ! 25: unsigned short qe_vector; ! 26: unsigned short qe_csr; ! 27: }; ! 28: ! 29: /* ! 30: * qe_csr ! 31: */ ! 32: #define QE_RCV_ENABLE 0x0001 /* receiver enable */ ! 33: #define QE_RESET 0x0002 /* controller reset */ ! 34: #define QE_NEX_MEM_INT 0x0004 /* non-existent memory */ ! 35: #define QE_XL_INVALID 0x0010 /* nothing left to transmit */ ! 36: #define QE_RL_INVALID 0x0020 /* no buffers left to receive */ ! 37: #define QE_INT_ENABLE 0x0040 /* interrupt enable */ ! 38: #define QE_XMIT_INT 0x0080 /* intr because xmit finished */ ! 39: #define QE_ILOOP 0x0100 /* internal loopback disable */ ! 40: #define QE_ELOOP 0x0200 /* external loopback enable */ ! 41: #define QE_RCV_INT 0x8000 /* intr because rcv finished */ ! 42: ! 43: /* ! 44: * bits to shove into qe_csr for normal operation ! 45: */ ! 46: int qebits = QE_RCV_ENABLE|QE_INT_ENABLE|QE_ILOOP; ! 47: /* ! 48: * interrupt request bits: ! 49: * after an interrupt, write the ones that are set ! 50: * to allow the next interrupt ! 51: */ ! 52: #define INTFLAGS (QE_XMIT_INT|QE_RCV_INT) ! 53: ! 54: /* ! 55: * buffer descriptor ! 56: * flag is who owns it; ! 57: * the rest is where the data is, and how big ! 58: * they may be a list, or a chain. ! 59: * we just use a ring; the DEQNA thinks it's a list, ! 60: * but the chain flag is used to sew the ring together that the end ! 61: */ ! 62: ! 63: struct qe_ring { ! 64: short flag; ! 65: short hiaddr; /* and descriptor type flags */ ! 66: short loaddr; ! 67: short len; /* negative length */ ! 68: unsigned short status1; ! 69: unsigned short status2; ! 70: }; ! 71: ! 72: /* ! 73: * flags: just descriptor ownership ! 74: */ ! 75: ! 76: #define FREADY 0x8000 /* descriptor ready, port not using yet */ ! 77: ! 78: /* ! 79: * descriptor type flags, in hiaddr ! 80: */ ! 81: ! 82: #define DVALID 0x8000 /* valid descriptor */ ! 83: #define DCHAIN 0x4000 /* chain: address is that of next descriptor */ ! 84: #define DEND 0x2000 /* end of message; push output packet */ ! 85: #define DSETUP 0x1000 /* this is a setup packet */ ! 86: #define DENDODD 0x80 /* buffer ends on odd address */ ! 87: #define DBEGODD 0x40 /* buffer begins on odd address */ ! 88: ! 89: /* ! 90: * status1 when we write it ! 91: */ ! 92: #define NOTYET 0x8000 /* descriptor ready, but DEQNA hasn't taken it */ ! 93: /* ! 94: * status1 when DEQNA is through ! 95: */ ! 96: #define NOTLAST 0x8000 /* rcv: not the last descriptor of a packet */ ! 97: #define ERROR 0x4000 /* either: some error happened */ ! 98: #define ESETUP 0x2000 /* rcv: setup packet acknowledgement */ ! 99: #define RHILEN 0x0700 /* rcv: high bits of received packet length */ ! 100: ! 101: /* ! 102: * status2 when we write it ! 103: */ ! 104: #define S2MAGIC 1 /* write this there to make descriptor ready. why? */ ! 105: /* ! 106: * status2 when DEQNA is through ! 107: */ ! 108: #define RLOLEN 0x00ff /* rcv: low bits of received length */ ! 109: ! 110: #define RMINLEN 60 /* add this to get real received packet length */ ! 111: ! 112: /* ! 113: * operating condition set-up bits ! 114: */ ! 115: #define ALLM 0x1 /* match all multicast addresses */ ! 116: #define PROM 0x2 /* match all addresses (promiscuous mode) */ ! 117: ! 118: /* ! 119: * setup packet: ! 120: * lists the addresses we may receive ! 121: * each column (sic) of the array contains an address ! 122: * e.g. setup[1][0..5] ! 123: * setup[0][*] and setup[*][6..7] are junk ! 124: */ ! 125: ! 126: struct setup { ! 127: char d[16][8]; ! 128: }; ! 129: ! 130: /* ! 131: * data accessed directly by the DEQNA: ! 132: * the buffer descriptors and the setup packet ! 133: */ ! 134: ! 135: struct qeio { ! 136: struct qe_ring rring[QENRCV+1]; ! 137: struct qe_ring xring[QENXMT+1]; ! 138: struct setup setup; ! 139: }; ! 140: ! 141: /* ! 142: * This constant should really be 60 because the qna adds 4 bytes of crc. ! 143: * However when set to 60 our packets are ignored by deuna's , 3coms are ! 144: * okay ?????????????????????????????????????????? ! 145: */ ! 146: #define ETHERMINTU 64 ! 147: #define ETHERMAXTU 1564 ! 148: #define MAX_RCV_BYTES (3*ETHERMAXTU) /* maximum bytes in receive ring */ ! 149: int nRCV = QENRCV; ! 150: int nXMT = QENXMT; ! 151: ! 152: struct qechan *qefindchan(); ! 153: ! 154: extern int qecnt; ! 155: extern struct qe qe[]; ! 156: extern struct ubaddr qeaddr[]; ! 157: ! 158: #define NEXTCH(c) (((c)+1)%QENCHAN) /* next channel */ ! 159: ! 160: /* flag settings */ ! 161: #define ATTACHED 0x4 ! 162: #define SETUPQD 0x8 ! 163: ! 164: /* handy macros for ring management */ ! 165: #define NFREE(s) ((s)->xindex>=(s)->oxindex?(QENXMT-((s)->xindex-(s)->oxindex)-1):\ ! 166: ((s)->oxindex-(s)->xindex-1)) ! 167: #define NEXTRCV(c) (((c)+1)%QENRCV) ! 168: #define NEXTXMT(c) (((c)+1)%QENXMT) ! 169: ! 170: long qeopen(); ! 171: int qeclose(), qeput(); ! 172: static struct qinit qerinit = { noput, NULL, qeopen, qeclose, 0, 0 }; ! 173: static struct qinit qewinit = { qeput, NULL, qeopen, qeclose, 4*ETHERMAXTU, 64 }; ! 174: static struct streamtab qesinfo = { &qerinit, &qewinit }; ! 175: struct cdevsw qecdev = cstrinit(&qesinfo); ! 176: ! 177: /* open a channel */ ! 178: long ! 179: qeopen(q, dev) ! 180: register struct queue *q; ! 181: register dev_t dev; ! 182: { ! 183: register struct qechan *cp; ! 184: register struct qe *qp; ! 185: int unit, chan; ! 186: ! 187: dev = minor(dev); ! 188: chan = dev % QENCHAN; ! 189: unit = dev / QENCHAN; ! 190: if(unit >= qecnt) ! 191: return(0); ! 192: if (qeinit(unit) == 0) ! 193: return (0); ! 194: qp = &qe[unit]; ! 195: cp = &qp->chan[chan]; ! 196: if(cp->rq) ! 197: return(0); ! 198: cp->unit = unit; ! 199: cp->type = 0; ! 200: q->ptr = (caddr_t)cp; ! 201: WR(q)->ptr = (caddr_t)cp; ! 202: WR(q)->flag |= QDELIM|QBIGB; ! 203: q->flag |= QDELIM; ! 204: cp->rq = q; ! 205: return(1); ! 206: } ! 207: ! 208: qeclose(q) ! 209: register struct queue *q; ! 210: { ! 211: register struct qechan *cp; ! 212: ! 213: cp = (struct qechan *)q->ptr; ! 214: cp->rq = 0; ! 215: cp->type = 0; ! 216: } ! 217: ! 218: /* ! 219: * init a controller-- ! 220: * grab and map a buffer for qeio ! 221: * reset the device and send it a setup packet ! 222: */ ! 223: qeinit(unit) ! 224: int unit; ! 225: { ! 226: register struct qedevice *addr; ! 227: register struct qe *qp; ! 228: register uaddr_t ua; ! 229: ! 230: qp = &qe[unit]; ! 231: if (qp->addr) ! 232: return (1); ! 233: if ((addr = (struct qedevice *)ubaddr(&qeaddr[unit])) == 0 ! 234: || badaddr(&addr->qe_sta_addr[0], sizeof(short))) { ! 235: printf("deqna %d absent\n", unit); ! 236: return (0); ! 237: } ! 238: qp->intvec = qeaddr[unit].vec; ! 239: qp->ubno = qeaddr[unit].ubno; ! 240: if (qp->iobuf == NULL) { ! 241: qp->iobuf = geteblk(); ! 242: qp->iobm = ubmbuf(qp->ubno, qp->iobuf, 0); ! 243: ua = ubadbuf(qp->ubno, qp->iobuf, qp->iobm); ! 244: qp->rring = ((struct qeio *)(qp->iobuf->b_un.b_addr))->rring; ! 245: qp->xring = ((struct qeio *)(qp->iobuf->b_un.b_addr))->xring; ! 246: qp->setup = &((struct qeio *)(qp->iobuf->b_un.b_addr))->setup; ! 247: qp->raddr = (uaddr_t)((struct qeio *)ua)->rring; ! 248: qp->xaddr = (uaddr_t)((struct qeio *)ua)->xring; ! 249: qp->setupaddr = (uaddr_t)&((struct qeio *)ua)->setup; ! 250: } ! 251: qp->addr = addr; ! 252: addr->qe_csr = QE_RESET; ! 253: addr->qe_csr = 0; /* clear RESET to make reset happen */ ! 254: qemkrings(qp); ! 255: qemksetup(qp); ! 256: qeenable(qp); ! 257: return (1); ! 258: } ! 259: ! 260: /* ! 261: * make the setup packet ! 262: * receive from our address, and from the broadcast address ! 263: */ ! 264: qemksetup(qp) ! 265: register struct qe *qp; ! 266: { ! 267: register struct setup *sp; ! 268: register int i, j; ! 269: ! 270: sp = qp->setup; ! 271: /* ! 272: * fetch our Ethernet address into column 1 ! 273: * toss the broadcast address into column 2 ! 274: * copy our address into the rest of the first half ! 275: * duplicate first half into second ! 276: * columns 0 and 8 are junk ! 277: */ ! 278: for (i = 0; i < ETHERALEN; i++) ! 279: sp->d[i][1] = qp->addr->qe_sta_addr[i]; ! 280: #ifndef NOTDEF ! 281: for (i = 0; i < ETHERALEN; i++) ! 282: sp->d[i][2] = 0xff; /* the broadcast addr */ ! 283: for (i = 0; i < ETHERALEN; i++) ! 284: for (j = 3; j < 8; j++) ! 285: sp->d[i][j] = sp->d[i][1]; ! 286: #else ! 287: for (i = 0; i < ETHERALEN; i++) ! 288: for (j = 2; j < 8; j++) ! 289: sp->d[i][j] = sp->d[i][1]; ! 290: #endif ! 291: bcopy(&sp->d[0][0], &sp->d[8][0], 8*8); ! 292: } ! 293: ! 294: /* ! 295: * output put routine ! 296: * treasure up data till a DELIM comes, ! 297: * then send it all as one packet ! 298: */ ! 299: qeput(q, bp) ! 300: register struct queue *q; ! 301: struct block *bp; ! 302: { ! 303: register struct qechan *cp=(struct qechan *)q->ptr; ! 304: int s; ! 305: ! 306: switch (bp->type) { ! 307: case M_IOCTL: ! 308: qeioctl(q, bp); ! 309: return; ! 310: ! 311: case M_DATA: ! 312: putq(q, bp); ! 313: if (bp->class&S_DELIM) ! 314: break; ! 315: return; ! 316: ! 317: default: ! 318: freeb(bp); ! 319: return; ! 320: } ! 321: s = spl6(); ! 322: qestagepacket(cp); ! 323: while (qexmtpacket(&qe[cp->unit])==0) ! 324: ; ! 325: splx(s); ! 326: } ! 327: ! 328: qeioctl(q, bp) ! 329: register struct queue *q; ! 330: register struct block *bp; ! 331: { ! 332: register struct qechan *cp; ! 333: int i; ! 334: char *ap; ! 335: ! 336: cp = (struct qechan *)q->ptr; ! 337: bp->type = M_IOCACK; ! 338: switch(stiocom(bp)){ ! 339: case ENIOTYPE: ! 340: cp->type = *((int *)stiodata(bp)); ! 341: break; ! 342: ! 343: case ENIOPROM: ! 344: qexmtsetup(&qe[cp->unit], PROM, 1); ! 345: break; ! 346: ! 347: case ENIOADDR: ! 348: for (ap=stiodata(bp), i=0; i<ETHERALEN; i++) ! 349: *ap++ = qe[cp->unit].addr->qe_sta_addr[i]; ! 350: bp->wptr = bp->rptr + ETHERALEN + STIOCHDR; ! 351: break; ! 352: ! 353: default: ! 354: bp->type = M_IOCNAK; ! 355: break; ! 356: } ! 357: qreply(q, bp); ! 358: } ! 359: ! 360: /* ! 361: * primitives for sending/receiving packets ! 362: */ ! 363: ! 364: /* ! 365: * make a descriptor invalid ! 366: */ ! 367: qeinvaldesc(rp) ! 368: register struct qe_ring *rp; ! 369: { ! 370: bzero((caddr_t)rp, sizeof(struct qe_ring)); ! 371: } ! 372: ! 373: /* ! 374: * set up a buffer descriptor ! 375: * tflags are the ones in hiaddr, ! 376: * like `setup packet' ! 377: */ ! 378: qefilldesc(rp, addr, len, tflags) ! 379: register struct qe_ring *rp; ! 380: uaddr_t addr; ! 381: int len; ! 382: int tflags; ! 383: { ! 384: ! 385: rp->hiaddr = tflags; ! 386: if (addr & 1) { ! 387: len++; ! 388: addr--; ! 389: rp->hiaddr |= DBEGODD; ! 390: } ! 391: if (len & 1) { ! 392: len++; ! 393: rp->hiaddr |= DENDODD; ! 394: } ! 395: rp->len = -(len/2); ! 396: rp->loaddr = addr; ! 397: rp->hiaddr |= addr >> 16; ! 398: rp->status2 = S2MAGIC; /* something meaningless */ ! 399: rp->status1 = NOTYET; ! 400: rp->flag = FREADY; ! 401: rp->hiaddr |= DVALID; ! 402: } ! 403: ! 404: /* ! 405: * allocate a receive buffer ! 406: * and give it to the DEQNA ! 407: * if we're out of descriptors or are using too much memory, ! 408: * return quietly ! 409: */ ! 410: qercvblock(qp) ! 411: register struct qe *qp; ! 412: { ! 413: register uaddr_t a; ! 414: register int len; ! 415: register struct block *bp; ! 416: ! 417: if (qp->rbytes>MAX_RCV_BYTES || NEXTRCV(qp->rindex)==qp->orindex) ! 418: return -1; ! 419: if ((bp = allocb(ETHERMAXTU))==NULL) ! 420: panic("qercvblock"); ! 421: qp->rbp[qp->rindex] = bp; ! 422: a = ubadwptr(qp->ubno, bp, ubmblk(qe->ubno, bp, 0)); ! 423: len = bp->lim - bp->wptr; ! 424: qefilldesc(&qp->rring[qp->rindex], a, len, 0); ! 425: qp->rbytes += len; ! 426: if ((qp->addr->qe_csr&QE_RL_INVALID) && ! 427: qp->rring[qp->rindex].status1 == NOTYET) { /* wake up device */ ! 428: a = qp->raddr + qp->rindex*sizeof(struct qe_ring); ! 429: qp->addr->qe_rcvlist_lo = a; ! 430: qp->addr->qe_rcvlist_hi = a >> 16; ! 431: } ! 432: qp->rindex = NEXTRCV(qp->rindex); ! 433: return 0; ! 434: } ! 435: ! 436: /* ! 437: * send a block ! 438: */ ! 439: qexmtblock(qp, bp, tflags) ! 440: register struct qe *qp; ! 441: struct block *bp; ! 442: int tflags; ! 443: { ! 444: register uaddr_t a; ! 445: ! 446: if (qp->xring[qp->xindex].status1 == NOTYET) ! 447: panic("qexmitbp"); ! 448: qp->xbp[qp->xindex] = bp; ! 449: a = ubadrptr(qp->ubno, bp, ubmblk(qe->ubno, bp, 0)); ! 450: qefilldesc(&qp->xring[qp->xindex], a, bp->wptr - bp->rptr, tflags); ! 451: if ((qp->addr->qe_csr&QE_XL_INVALID) && ! 452: qp->xring[qp->xindex].status1==NOTYET) { /* wake up device */ ! 453: a = qp->xaddr + qp->xindex*sizeof(struct qe_ring); ! 454: qp->addr->qe_xmtlist_lo = (short)a; ! 455: qp->addr->qe_xmtlist_hi = (short)(a >> 16); ! 456: } ! 457: qp->xindex = NEXTXMT(qp->xindex); ! 458: } ! 459: ! 460: /* ! 461: * send the setup packet ! 462: * -- knows it's the first packet ever sent ! 463: */ ! 464: qexmtsetup(qp, cmd, docmd) ! 465: register struct qe *qp; ! 466: int cmd; ! 467: int docmd; ! 468: { ! 469: register uaddr_t a; ! 470: ! 471: qefilldesc(&qp->xring[qp->xindex], qp->setupaddr, ! 472: docmd ? (128+cmd) : sizeof(struct setup), DSETUP|DEND); ! 473: if ((qp->addr->qe_csr&QE_XL_INVALID) && ! 474: qp->xring[qp->xindex].status1==NOTYET) { /* presumably always */ ! 475: a = qp->xaddr + qp->xindex*sizeof(struct qe_ring); ! 476: qp->addr->qe_xmtlist_lo = a; ! 477: qp->addr->qe_xmtlist_hi = a >> 16; ! 478: } ! 479: qp->xindex = NEXTXMT(qp->xindex); ! 480: } ! 481: ! 482: /* ! 483: * init the descriptor rings: ! 484: * clear out any stale blocks ! 485: * zap all the descriptors ! 486: * point the last descriptor at the first, ! 487: * forming the ring ! 488: */ ! 489: qemkrings(qp) ! 490: register struct qe *qp; ! 491: { ! 492: register int i, ch; ! 493: ! 494: for (i=0; i<QENRCV; i++) ! 495: if (qp->rbp[i]) { ! 496: freeb(qp->rbp[i]); ! 497: qp->rbp[i] = NULL; ! 498: } ! 499: for (i=0; i<QENXMT; i++) ! 500: if (qp->xbp[i]) { ! 501: freeb(qp->xbp[i]); ! 502: qp->xbp[i] = NULL; ! 503: } ! 504: for (ch=0; ch<QENCHAN; ch++) { ! 505: qp->chan[ch].nxmt = 0; ! 506: for (i=0; i<QENXMT; i++) ! 507: if (qp->chan[ch].xmt[i]) { ! 508: freeb(qp->chan[ch].xmt[i]); ! 509: qp->chan[ch].xmt[i] = NULL; ! 510: } ! 511: } ! 512: for (i = 0 ; i < QENRCV ; i++) ! 513: qeinvaldesc(&qp->rring[i]); ! 514: qefilldesc(&qp->rring[QENRCV], qp->raddr, 0, DCHAIN); ! 515: for (i = 0 ; i < QENXMT ; i++) ! 516: qeinvaldesc(&qp->xring[i]); ! 517: qefilldesc(&qp->xring[QENRCV], qp->xaddr, 0, DCHAIN); ! 518: qp->lastch = qp->orindex = qp->oxindex = qp->xindex = qp->rindex = 0; ! 519: qp->rbytes = 0; ! 520: } ! 521: ! 522: /* ! 523: * turn the receiver on: ! 524: * enable the hardware, set up receive buffers ! 525: * send a setup packet ! 526: */ ! 527: ! 528: qeenable(qp) ! 529: register struct qe *qp; ! 530: { ! 531: ! 532: qp->addr->qe_vector = qp->intvec; ! 533: qp->addr->qe_csr = qebits; ! 534: while (qercvblock(qp)==0) ! 535: ; ! 536: qexmtsetup(qp, 0, 0); ! 537: /*printf("qe csr after enable: %x\n", qp->addr->qe_csr);*/ ! 538: } ! 539: ! 540: /* ! 541: * find a staged packet and send it ! 542: */ ! 543: qexmtpacket(qp) ! 544: register struct qe *qp; ! 545: { ! 546: register int i; ! 547: register struct qechan *cp; ! 548: ! 549: /* Look for a channel that has a packet that will fit */ ! 550: for(i=NEXTCH(qp->lastch); ; i=NEXTCH(i)) { ! 551: cp = &qp->chan[i]; ! 552: if (cp->nxmt && cp->nxmt<=NFREE(qp)) ! 553: break; ! 554: if (i==qp->lastch) ! 555: return -1; ! 556: } ! 557: qp->lastch = i; ! 558: qedebug(cp->xmt[0], 1, cp->nbytes); ! 559: for (i=0; i<cp->nxmt-1; i++) { /* send any partial pieces */ ! 560: qexmtblock(qp, cp->xmt[i], 0); ! 561: cp->xmt[i] = NULL; ! 562: } ! 563: qexmtblock(qp, cp->xmt[i], DEND); /* send the last piece */ ! 564: cp->xmt[i] = NULL; ! 565: cp->nxmt = 0; ! 566: qestagepacket(cp); /* stage the next packet for this channel */ ! 567: return 0; ! 568: ! 569: } ! 570: ! 571: /* ! 572: * Here on any interrupt ! 573: */ ! 574: qe0int(unit) ! 575: int unit; ! 576: { ! 577: register struct qe *qp = &qe[unit]; ! 578: register int csr; ! 579: ! 580: csr = qp->addr->qe_csr; ! 581: qp->addr->qe_csr = qebits|(csr&INTFLAGS); ! 582: if( csr & QE_RCV_INT ) ! 583: qerint(qp); ! 584: if( csr & QE_XMIT_INT ) ! 585: qexint(qp); ! 586: if( csr & QE_NEX_MEM_INT ) ! 587: printf("deqna %d: nxm\n", unit); ! 588: } ! 589: ! 590: /* ! 591: * transmit interrupt: ! 592: * free up descriptors and blocks ! 593: * DEQNA doesn't hear its own broadcasts, ! 594: * so loop them around by hand here ! 595: */ ! 596: qexint(qp) ! 597: register struct qe *qp; ! 598: { ! 599: register int last; /* last block of packet */ ! 600: register int first; /* first block of packet */ ! 601: register struct qechan *cp; ! 602: ! 603: /* loop once per packet */ ! 604: for(;;) { ! 605: /* loop once per block */ ! 606: first = qp->oxindex; ! 607: for (last=first; ; last=NEXTXMT(last)) { ! 608: if (last==qp->xindex || qp->xring[last].status1==NOTYET){ ! 609: /* ! 610: * nothing left ! 611: */ ! 612: while (qexmtpacket(qp)==0) ! 613: ; ! 614: return; ! 615: } ! 616: if (qp->xring[last].hiaddr & DEND) ! 617: break; ! 618: } ! 619: /* ! 620: * first -> first descriptor for some packet ! 621: * last -> last descriptor for the same packet ! 622: */ ! 623: if ((qp->xring[last].status1&ERROR) == 0) ! 624: qp->opackets++; ! 625: else { ! 626: printf("deqna %d: xmt err st1 %x st2 %x\n", ! 627: qp - qe, ! 628: qp->xring[last].status1, ! 629: qp->xring[last].status2); ! 630: qp->oerrors++; ! 631: } ! 632: if (qp->xring[first].hiaddr & DSETUP) { /* skip over setup packet */ ! 633: qeinvaldesc(&qp->xring[first]); /* just one desc */ ! 634: qp->oxindex = NEXTXMT(last); ! 635: continue; ! 636: } ! 637: if (qebits&QE_ELOOP) /* debuggery */ ! 638: cp = NULL; ! 639: else ! 640: cp = qefindchan(qp, qp->xbp[first], 1); ! 641: ! 642: /* loop once per block to free (or loop back) packet */ ! 643: for(last=NEXTXMT(last); first!=last; first=NEXTXMT(first)) { ! 644: /*printf("qexint: removing %d to %x\n", first, cp);*/ ! 645: if (cp) ! 646: (*cp->rq->next->qinfo->putp)(cp->rq->next,qp->xbp[first]); ! 647: else ! 648: freeb(qp->xbp[first]); ! 649: qeinvaldesc(&qp->xring[first]); ! 650: qp->xbp[first] = NULL; ! 651: } ! 652: qp->oxindex = last; ! 653: } ! 654: } ! 655: ! 656: /* ! 657: * receiver interrupt: ! 658: * hand packet to the channel ! 659: * that wants that protocol ! 660: */ ! 661: qerint(qp) ! 662: register struct qe *qp; ! 663: { ! 664: register int last; /* last block of packet */ ! 665: register int first; /* first block of packet */ ! 666: register struct qechan *cp; ! 667: struct qe_ring *rp; ! 668: struct block *bp; ! 669: int len; ! 670: ! 671: /* loop once per packet */ ! 672: for(;;) { ! 673: /* loop once per block */ ! 674: first = qp->orindex; ! 675: for (last=first; ; last=NEXTRCV(last)) { ! 676: if (last==qp->rindex || ! 677: qp->rring[last].status1==NOTYET) { ! 678: /* ! 679: * nothing left ! 680: */ ! 681: while(qercvblock(qp)==0) ! 682: ; ! 683: return; ! 684: } ! 685: if ((qp->rring[last].status1&NOTLAST) == 0) ! 686: break; ! 687: } ! 688: /* ! 689: * first -> first block of received packet ! 690: * last -> last block of that packet ! 691: */ ! 692: if (qp->rring[last].status1&ERROR) { ! 693: #if NOTDEF /* usually boring */ ! 694: printf("deqna %d: rcv err st1 %x st2 %x\n", ! 695: qp - qe, ! 696: qp->rring[last].status1, ! 697: qp->rring[last].status2); ! 698: #endif ! 699: cp = NULL; ! 700: qp->ierrors++; ! 701: } else if (qp->rring[last].status1&ESETUP) { ! 702: /* printf("qerint: setup\n");*/ ! 703: cp = NULL; ! 704: } else { ! 705: cp = qefindchan(qp, qp->rbp[first], 0); ! 706: qp->ipackets++; ! 707: } ! 708: ! 709: /* loop once per block to receive packet */ ! 710: if (cp) { ! 711: rp = &qp->rring[last]; ! 712: len = ((rp->status1&RHILEN)|(rp->status2&RLOLEN))+RMINLEN; ! 713: qedebug(qp->rbp[first], 0, len); ! 714: } ! 715: /* install delimiter */ ! 716: if (qp->rbp[last] == NULL) ! 717: panic("qerint"); ! 718: qp->rbp[last]->class |= S_DELIM; ! 719: for(last=NEXTRCV(last); first!=last; first=NEXTRCV(first)) { ! 720: /*printf("qerint: received %d to %x\n", first, cp);*/ ! 721: bp = qp->rbp[first]; ! 722: qp->rbytes -= bp->lim - bp->wptr; ! 723: if (cp) { ! 724: rp = &qp->rring[first]; ! 725: if (rp->status1&NOTLAST) { ! 726: len -= bp->lim-bp->wptr; ! 727: bp->wptr = bp->lim; ! 728: } else { ! 729: bp->wptr += len; ! 730: if (bp->wptr > bp->lim) ! 731: panic("qerint: length"); ! 732: } ! 733: bp = cramb(bp); ! 734: if(cp->rq->next->flag & QFULL) ! 735: freeb(bp); ! 736: else ! 737: (*cp->rq->next->qinfo->putp)(cp->rq->next, bp); ! 738: } else ! 739: freeb(bp); ! 740: qeinvaldesc(&qp->rring[first]); ! 741: qp->rbp[first] = NULL; ! 742: } ! 743: qp->orindex = last; ! 744: } ! 745: } ! 746: ! 747: /* ! 748: * find the channel for this input packet ! 749: * checklocal means check that the packet was ! 750: * addressed to us; used for loopback ! 751: */ ! 752: struct qechan * ! 753: qefindchan(qp, bp, checklocal) ! 754: register struct qe *qp; ! 755: struct block *bp; ! 756: int checklocal; ! 757: { ! 758: register int i; ! 759: register struct etherpup *ep=(struct etherpup *)bp->rptr; ! 760: register struct qechan *ch; ! 761: ! 762: /*printf("qefindchan: %x,%x,%x,%x,%x,%x:%d\n", ! 763: ep->dhost[0], ep->dhost[1], ep->dhost[2], ! 764: ep->dhost[3], ep->dhost[4], ep->dhost[5], ! 765: ep->type);*/ ! 766: if (checklocal) { ! 767: for (i=0; i<ETHERALEN; i++) { ! 768: if (ep->dhost[i]!=qp->setup->d[i][1] ! 769: && ep->dhost[i]!=0xff) /* broadcast */ ! 770: return NULL; ! 771: } ! 772: } ! 773: for (i=0, ch=qp->chan; i<QENCHAN; i++, ch++) ! 774: if (ch->rq!=NULL && ch->type==ep->type) ! 775: return (ch); ! 776: return NULL; ! 777: } ! 778: ! 779: /* ! 780: * stage the next packet for this channel: ! 781: * gather the blocks, make sure they look sensible ! 782: * printfs are a bit silly ! 783: */ ! 784: qestagepacket(cp) ! 785: register struct qechan *cp; ! 786: { ! 787: register struct block *bp; ! 788: register int blk; ! 789: int nbytes; ! 790: register struct etherpup *ep; ! 791: register struct setup *sp; ! 792: ! 793: if (cp->nxmt) /* already have one staged */ ! 794: return; ! 795: blk = 0; ! 796: nbytes = 0; ! 797: while ((bp = getq(WR(cp->rq))) != NULL) { ! 798: if (bp->type != M_DATA) ! 799: panic("qestagepkt"); ! 800: if (blk >= QENXMT-1) { ! 801: blk = qepullup(cp); ! 802: if (blk >= QENXMT-1) { ! 803: freeb(bp); /* wrong! but too hard for now */ ! 804: continue; ! 805: } ! 806: } ! 807: cp->xmt[blk++] = bp; ! 808: nbytes += bp->wptr-bp->rptr; ! 809: if ((bp->class & S_DELIM) == 0) ! 810: continue; ! 811: /* ! 812: * have a whole packet ! 813: */ ! 814: if (nbytes > ETHERMAXTU) { ! 815: printf("deqna %d: packet too long\n", cp->unit); ! 816: break; ! 817: } ! 818: if (cp->xmt[0]->wptr-cp->xmt[0]->rptr < sizeof(struct etherpup)) { ! 819: printf("deqna %d: too fragmented\n", cp->unit); ! 820: break; ! 821: } ! 822: if (nbytes < ETHERMINTU) /* wrong, but do it anyway */ ! 823: cp->xmt[blk-1]->wptr += ETHERMINTU-nbytes; ! 824: /* ! 825: * force our address into the packet ! 826: * why doesn't the hardware do this? ! 827: */ ! 828: ep = (struct etherpup *)cp->xmt[0]->rptr; ! 829: ep->type = cp->type; ! 830: cp->nxmt = blk; ! 831: sp = qe[cp->unit].setup; ! 832: for(blk=0; blk < ETHERALEN; blk++) ! 833: ep->shost[blk] = sp->d[blk][1]; ! 834: /*printf("qestagepacket: staged %d\n", cp->nxmt);*/ ! 835: cp->nbytes = nbytes; ! 836: return; ! 837: } ! 838: /* ! 839: * if we come here, something went wrong ! 840: * any useful packet has already been removed from the queue ! 841: */ ! 842: if (bp) ! 843: freeb(bp); ! 844: else if (blk!=0) ! 845: printf("deqna %d: stage no delim\n", cp->unit); ! 846: while (--blk >= 0) ! 847: freeb(cp->xmt[blk]); ! 848: cp->nxmt = 0; ! 849: } ! 850: ! 851: /* ! 852: * transmit packet came in too many pieces ! 853: * to fit in staging area ! 854: * allocate a big block, ! 855: * and try to squeeze some pieces into it ! 856: * returns the first slot now available for a block, ! 857: * QENXMT-1 if no space could be made ! 858: * ! 859: * assertion: no block we replace is S_DELIM ! 860: */ ! 861: ! 862: int ! 863: qepullup(cp) ! 864: register struct qechan *cp; ! 865: { ! 866: register struct block *newbp, *bp; ! 867: register int blk, rep, space; ! 868: register int n; ! 869: ! 870: if ((newbp = allocb(ETHERMAXTU/2)) == NULL) ! 871: return (QENXMT-1); ! 872: space = newbp->lim - newbp->wptr; ! 873: for (blk = 0; blk < QENXMT-1; blk++) { ! 874: bp = cp->xmt[blk]; ! 875: if (bp->wptr - bp->rptr < space) ! 876: break; ! 877: } ! 878: if (blk >= QENXMT - 1) { /* no block small enough to fit */ ! 879: freeb(newbp); ! 880: return (blk); ! 881: } ! 882: /* ! 883: * pack as much as possible into newbp ! 884: */ ! 885: rep = blk; ! 886: for (; blk < QENXMT-1; blk++) { ! 887: bp = cp->xmt[blk]; ! 888: n = bp->wptr - bp->rptr; ! 889: if (n > space) ! 890: break; ! 891: bcopy(bp->rptr, newbp->wptr, n); ! 892: freeb(bp); ! 893: newbp->wptr += n; ! 894: space -= n; ! 895: } ! 896: /* ! 897: * slide remaining blocks up ! 898: */ ! 899: cp->xmt[rep++] = newbp; ! 900: for (; blk < QENXMT-1; blk++, rep++) ! 901: cp->xmt[rep] = cp->xmt[blk]; ! 902: return (rep); ! 903: } ! 904: ! 905: /* ! 906: * tracing stuff ! 907: */ ! 908: ! 909: #include "sys/systm.h" /* for time */ ! 910: ! 911: #define QEDEBSIZE 64 ! 912: struct { ! 913: time_t time; ! 914: unsigned short code; ! 915: struct etherpup pup; ! 916: short len; ! 917: } qed[QEDEBSIZE]; ! 918: ! 919: int qei = 0; ! 920: ! 921: qedebug(bp, code, len) ! 922: register struct block *bp; ! 923: { ! 924: qed[qei].time = time; ! 925: qed[qei].code = code; ! 926: qed[qei].len = len; ! 927: bcopy(bp->rptr, &qed[qei].pup, sizeof(qed[qei].pup)); ! 928: qei = (qei + 1) % QEDEBSIZE; ! 929: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.