![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to debna.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 debna.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 ! root 1: /* ! 2: * first cut at NI port in DEBNA ! 3: * slower than it need be, because of all the copying; ! 4: * disallows use of the storage port ! 5: */ ! 6: #include "sys/param.h" ! 7: #include "sys/biaddr.h" ! 8: #include "sys/conf.h" ! 9: #include "sys/user.h" ! 10: #include "sys/buf.h" ! 11: #include "sys/stream.h" ! 12: #include "sys/biic.h" ! 13: #include "sys/ethernet.h" ! 14: #include "sys/enio.h" ! 15: #include "sys/pte.h" ! 16: #include "sys/bvp.h" ! 17: #include "sys/debna.h" ! 18: ! 19: caddr_t remqhi(); ! 20: ! 21: ! 22: #define PCMDQ 0 /* just one command queue */ ! 23: #define PFREQ 0 /* just one free queue for now */ ! 24: ! 25: /* ! 26: * internal ideas about packets ! 27: */ ! 28: ! 29: /* ! 30: * bounds of an Ethernet packet ! 31: * min is probably uninteresting ! 32: * max is constrained by the port, which will fuss and shut down ! 33: * if handed a buffer bigger than ETHERMAXTU+ETHERCKSUM ! 34: */ ! 35: #define ETHERMINTU 60 ! 36: #define ETHERMAXTU 1514 ! 37: #define ETHERCKSUM 4 ! 38: ! 39: #define NIRCVBUF (ETHERMAXTU+ETHERCKSUM) ! 40: ! 41: struct dgi { ! 42: struct bvpdg h; /* header */ ! 43: char d[NIRCVBUF]; ! 44: }; ! 45: ! 46: struct mst { ! 47: struct bvpmsg h; ! 48: struct stptdb p; ! 49: }; ! 50: ! 51: /* ! 52: * config stuff ! 53: */ ! 54: extern struct bnactl bna[]; ! 55: extern struct bnabuf bnabuf[]; ! 56: extern struct biaddr bnaaddr[]; ! 57: extern int bnacnt; ! 58: ! 59: long bnaopen(); ! 60: int bnaclose(), bnaput(); ! 61: ! 62: static struct qinit bnarinit = { noput, NULL, bnaopen, bnaclose, 0, 0 }; ! 63: static struct qinit bnawinit = { bnaput, NULL, bnaopen, bnaclose, 4*ETHERMAXTU, 64 }; ! 64: static struct streamtab bnasinfo = { &bnarinit, &bnawinit }; ! 65: struct cdevsw bnacdev = cstrinit(&bnasinfo); ! 66: ! 67: long ! 68: bnaopen(q, dev) ! 69: register struct queue *q; ! 70: dev_t dev; ! 71: { ! 72: register int unit, chan; ! 73: register struct bnachan *bc; ! 74: ! 75: unit = minor(dev); ! 76: chan = unit % BNACHAN; ! 77: unit /= BNACHAN; ! 78: if (unit >= bnacnt) ! 79: return (0); ! 80: if (bnainit(unit) == 0) ! 81: return (0); ! 82: bc = &bna[unit].chan[chan]; ! 83: if (bc->rq) ! 84: return (0); ! 85: bc->unit = unit; ! 86: bc->proto = 0; ! 87: q->ptr = (caddr_t)bc; ! 88: q->flag |= QDELIM; ! 89: WR(q)->ptr = (caddr_t)bc; ! 90: WR(q)->flag |= QDELIM|QBIGB; ! 91: bc->rq = q; ! 92: return (1); ! 93: } ! 94: ! 95: /* ! 96: * init the bvp port registers and pqb ! 97: * set up our list of free transmit buffers, ! 98: * and the free queue for the port ! 99: * -- only one free queue for now ! 100: */ ! 101: bnainit(unit) ! 102: register int unit; ! 103: { ! 104: register char *cp; ! 105: register struct bnactl *bn; ! 106: register int i; ! 107: ! 108: bn = &bna[unit]; ! 109: if (bvpinit(&bn->bvp, &bnaaddr[unit], NIREGS) == 0) { ! 110: printf("debna %d: can't init\n", unit); ! 111: return (0); ! 112: } ! 113: if (bn->bvp.d->f[PFREQ].f_size == 0) { /* somewhat sleazy init flag */ ! 114: bn->bvp.d->f[PFREQ].f_size = BNABSIZE-BVPHSIZE; ! 115: cp = bnabuf[unit].rbuf; ! 116: cp = (char *)(((int)cp + 7) & ~07); /* quad-align */ ! 117: for (i = 0; i < BNARBUF; i++, cp += BNABSIZE) { ! 118: if (((int)cp&PGOFSET) > (((int)cp+sizeof(struct bvpdg))&PGOFSET)) ! 119: cp = (char *)(((int)cp+PGOFSET)&~PGOFSET); ! 120: bnarbuf(bn, (struct dgi *)cp); ! 121: } ! 122: cp = bnabuf[unit].xbuf; ! 123: cp = (char *)(((int)cp + 7) & ~07); /* quad-align */ ! 124: for (i = 0; i < BNAXBUF; i++, cp += BNABSIZE) { ! 125: if (((int)cp&PGOFSET) > (((int)cp+sizeof(struct bvpdg))&PGOFSET)) ! 126: cp = (char *)(((int)cp+PGOFSET)&~PGOFSET); ! 127: bnaxbuf(bn, (struct dgi *)cp); ! 128: } ! 129: } ! 130: bcopy(bn->bvp.r->addr, bn->myaddr, sizeof(bn->myaddr)); ! 131: return (1); ! 132: } ! 133: ! 134: bnaclose(q) ! 135: register struct queue *q; ! 136: { ! 137: register struct bnachan *bc; ! 138: ! 139: bc = (struct bnachan *)q->ptr; ! 140: /* turn off PTDB? */ ! 141: bc->rq = NULL; ! 142: bc->proto = 0; ! 143: } ! 144: ! 145: /* ! 146: * output put ! 147: */ ! 148: bnaput(q, bp) ! 149: register struct queue *q; ! 150: register struct block *bp; ! 151: { ! 152: register struct bnachan *bc; ! 153: register int s; ! 154: ! 155: bc = (struct bnachan *)q->ptr; ! 156: switch (bp->type) { ! 157: case M_IOCTL: ! 158: bnaioctl(q, bp); ! 159: return; ! 160: ! 161: case M_DATA: ! 162: putq(q, bp); ! 163: if (bp->class & S_DELIM) ! 164: break; ! 165: return; ! 166: ! 167: default: ! 168: freeb(bp); ! 169: return; ! 170: } ! 171: /* ! 172: * at least a whole packet on the queue ! 173: */ ! 174: bc->dcnt++; ! 175: s = spl6(); ! 176: while (bnasend(bc->unit)) ! 177: ; ! 178: splx(s); ! 179: } ! 180: ! 181: bnaioctl(q, bp) ! 182: register struct queue *q; ! 183: register struct block *bp; ! 184: { ! 185: register struct bnachan *bc; ! 186: register struct bnactl *bn; ! 187: ! 188: bc = (struct bnachan *)q->ptr; ! 189: bn = &bna[bc->unit]; ! 190: bp->type = M_IOCACK; ! 191: switch (stiocom(bp)) { ! 192: case ENIOTYPE: /* set proto */ ! 193: bc->proto = *((int *)stiodata(bp)); ! 194: bnastptdb(bn, bc); ! 195: freeb(bp); /* IOCACK when the port finishes */ ! 196: return; ! 197: ! 198: case ENIOADDR: ! 199: bcopy(bn->myaddr, stiodata(bp), sizeof(bn->myaddr)); ! 200: bp->wptr = bp->rptr + sizeof(bn->myaddr) + STIOCHDR; ! 201: break; ! 202: ! 203: default: ! 204: bp->type = M_IOCNAK; ! 205: break; ! 206: } ! 207: qreply(q, bp); ! 208: } ! 209: ! 210: bnastptdb(bn, bc) ! 211: register struct bnactl *bn; ! 212: register struct bnachan *bc; ! 213: { ! 214: register struct mst *dp; ! 215: register int s; ! 216: ! 217: s = spl6(); ! 218: if ((dp = (struct mst *)bn->xfree) == NULL) { ! 219: bc->needst = 1; ! 220: bn->needst = 1; ! 221: splx(s); ! 222: return; ! 223: } ! 224: bn->xfree = (struct dgi *)(dp->h.q.head); ! 225: bc->needst = 0; ! 226: splx(s); ! 227: bzero((caddr_t)dp, sizeof(*dp)); ! 228: dp->h.bd_opc = BVPSNDMSG; ! 229: dp->h.bd_flag = BVPRSP; ! 230: dp->h.bm_len = sizeof(*dp) - ((char *)&dp->h.bm_opc - (char *)dp); ! 231: dp->h.bm_opc = NISTPTDB; ! 232: dp->p.pt_proto = bc->proto; ! 233: dp->p.pt_fqi = PFREQ; ! 234: dp->p.pt_flag = PTABM|PTAAM; ! 235: dp->p.pt_id = bc - bn->chan; ! 236: if (insqti((caddr_t)dp, &bn->bvp.d->p.p_cmdq[PCMDQ])) ! 237: bvpcomm(bn->bvp.r, PCOWN|PCCMDQ|(PCMDQ<<PCDS)); ! 238: } ! 239: ! 240: /* ! 241: * here on an interrupt ! 242: */ ! 243: bna0int(unit) ! 244: int unit; ! 245: { ! 246: register struct bvpdata *b; ! 247: register struct bnactl *bn; ! 248: register struct dgi *dp; ! 249: register struct bnabuf *bf; /* just for safety check */ ! 250: register int i; ! 251: ! 252: if ((unsigned)unit >= bnacnt) ! 253: panic("bna0int"); ! 254: bn = &bna[unit]; ! 255: if (bn->bvp.r == NULL) { ! 256: printf("debna %d stray intr\n", unit); ! 257: return; ! 258: } ! 259: bn->bvp.rsave = *bn->bvp.r; /* copy all, for debugging */ ! 260: if (bn->bvp.rsave.stat & PSOWN) ! 261: bn->bvp.r->stat &=~ PSOWN; /* allow fresh status */ ! 262: if ((bn->bvp.rsave.stat & PSSTAT) != SENAB) { ! 263: printf("debna %d: ps %x pe %x pd %x\n", unit, ! 264: bn->bvp.rsave.stat, bn->bvp.rsave.err, bn->bvp.rsave.data); ! 265: return; ! 266: } ! 267: b = bn->bvp.d; ! 268: bf = &bnabuf[unit]; ! 269: while ((dp = (struct dgi *)remqhi(&b->p.p_rspq)) != NULL) { ! 270: if (dp->h.bd_sts != BVPSUC) ! 271: printf("debna %d opc %x sts %x\n", unit, dp->h.bd_opc, dp->h.bd_sts); ! 272: switch (dp->h.bd_opc) { ! 273: case BVPSNDDGI: /* datagram sent */ ! 274: for (i = ETHERALEN-1; i >= 0; --i) ! 275: if (((struct etherpup *)dp->d)->dhost[i] != 0xff ! 276: && ((struct etherpup *)dp->d)->dhost[i] != bn->myaddr[i]) ! 277: goto notecho; ! 278: /* ! 279: * packet sent to ourselves; ! 280: * port won't echo it back ! 281: */ ! 282: dp->h.bd_len += ETHERCKSUM; /* banrdg will trim */ ! 283: bcopy(bn->myaddr, ((struct etherpup *)dp->d)->shost, sizeof(bn->myaddr)); ! 284: bnardg(bn, dp); ! 285: notecho: ! 286: /* fall through */ ! 287: case BVPSNDMSG: /* message sent */ ! 288: if ((char *)dp < bf->xbuf ! 289: || (char *)dp >= &bf->xbuf[sizeof(bf->xbuf)]) ! 290: panic("bna0int sent"); ! 291: bnaxbuf(bn, dp); ! 292: continue; ! 293: ! 294: case BVPRCVDGI: /* datagram received */ ! 295: if ((char *)dp < bf->rbuf ! 296: || (char *)dp >= &bf->rbuf[sizeof(bf->rbuf)]) ! 297: panic("bna0int rcv dg"); ! 298: bnardg(bn, dp); ! 299: bnarbuf(bn, dp); ! 300: continue; ! 301: ! 302: case BVPRCVMSG: /* message received */ ! 303: if ((char *)dp < bf->rbuf ! 304: || (char *)dp >= &bf->rbuf[sizeof(bf->rbuf)]) ! 305: panic("bna0int rcv msg"); ! 306: bnarmsg(bn, (struct bvpmsg *)dp); ! 307: bnarbuf(bn, dp); ! 308: continue; ! 309: ! 310: default: ! 311: printf("debna %d: %x: opc %x\n", unit, dp, dp->h.bd_opc); ! 312: continue; /* leaving buffer tied up */ ! 313: } ! 314: } ! 315: while (bnasend(unit)) ! 316: ; ! 317: } ! 318: ! 319: /* ! 320: * here is a received datagram; ! 321: * find the right channel, ! 322: * and send it up the queue ! 323: */ ! 324: bnardg(bn, dp) ! 325: register struct bnactl *bn; ! 326: register struct dgi *dp; ! 327: { ! 328: register int n; ! 329: register struct block *bp; ! 330: register char *p; ! 331: register struct queue *q; ! 332: int len; ! 333: short proto; ! 334: ! 335: if (dp->h.bd_dgsts != NISUC) { ! 336: printf("debna %d dg sts %x\n", bn - bna, dp->h.bd_dgsts); ! 337: return; ! 338: } ! 339: len = (dp->h.bd_len+BVPHSIZE)-sizeof(struct bvpdg)-ETHERCKSUM; ! 340: proto = (short)((struct etherpup *)dp->d)->type; ! 341: for (n = 0; n < BNACHAN; n++) ! 342: if (bn->chan[n].proto == proto) ! 343: break; ! 344: if (n >= BNACHAN) ! 345: return; /* unexpected proto */ ! 346: q = bn->chan[n].rq; ! 347: if (q == NULL) ! 348: return; /* snh */ ! 349: if (q->next->flag & QFULL) ! 350: return; /* no room */ ! 351: p = dp->d; ! 352: while (len > 0) { ! 353: if ((bp = allocb(len)) == NULL) ! 354: return; /* wrong, but hard */ ! 355: n = bp->lim - bp->wptr; ! 356: if (len < n) ! 357: n = len; ! 358: bcopy(p, bp->wptr, n); ! 359: bp->wptr += n; ! 360: p += n; ! 361: len -= n; ! 362: if (len <= 0) ! 363: bp->class |= S_DELIM; ! 364: (*q->next->qinfo->putp)(q->next, bp); ! 365: } ! 366: } ! 367: ! 368: /* ! 369: * here is a message ! 370: */ ! 371: ! 372: bnarmsg(bn, dp) ! 373: register struct bnactl *bn; ! 374: register struct bvpmsg *dp; ! 375: { ! 376: register struct bnachan *bc; ! 377: register struct mst *sdp; ! 378: ! 379: switch (dp->bm_opc) { ! 380: case NISTPTDB: /* ptdb set, sent ioctl back */ ! 381: sdp = (struct mst *)dp; ! 382: if (sdp->p.pt_id < 0 || sdp->p.pt_id >= BNACHAN) ! 383: panic("bnastptdb"); ! 384: bc = &bn->chan[sdp->p.pt_id]; ! 385: if (bc->rq == NULL || bc->proto != sdp->p.pt_proto) ! 386: return; /* early close? */ ! 387: if (sdp->h.bm_nists != NISUC) ! 388: printf("debna %d %d stptdb sts %x\n", bn - bna, ! 389: sdp->p.pt_id, sdp->h.bm_nists); ! 390: putctl(bc->rq->next, M_IOCACK); ! 391: return; ! 392: ! 393: default: ! 394: printf("debna %d msg opc %x sts %x\n", dp->bm_opc, dp->bm_nists); ! 395: return; ! 396: } ! 397: } ! 398: ! 399: /* ! 400: * find a channel with a packet, ! 401: * find a buffer, ! 402: * and send ! 403: */ ! 404: bnasend(unit) ! 405: int unit; ! 406: { ! 407: register struct bnactl *bn; ! 408: register struct bnachan *bc; ! 409: register struct dgi *dp; ! 410: register char *p; ! 411: register struct block *bp; ! 412: register int n; ! 413: char *ep; ! 414: ! 415: bn = &bna[unit]; ! 416: n = bn->lastx; ! 417: while (bn->chan[n].dcnt == 0) { ! 418: if (++n >= BNACHAN) ! 419: n = 0; ! 420: if (n == bn->lastx) ! 421: return (0); /* nothing to send */ ! 422: } ! 423: bn->lastx = n; ! 424: bc = &bn->chan[n]; ! 425: if ((dp = bn->xfree) == NULL) ! 426: return (0); /* no buffer */ ! 427: bn->xfree = (struct dgi *)dp->h.q.head; ! 428: bzero((caddr_t)&dp->h, sizeof(dp->h)); ! 429: p = dp->d; ! 430: ep = p + sizeof(dp->d); ! 431: while ((bp = getq(WR(bc->rq))) != NULL) { ! 432: n = bp->wptr - bp->rptr; ! 433: if (p + n > ep) ! 434: n = ep - p; /* quietly truncate */ ! 435: if (n) { ! 436: bcopy(bp->rptr, p, n); ! 437: p += n; ! 438: } ! 439: if (bp->class & S_DELIM) { ! 440: bc->dcnt--; ! 441: freeb(bp); ! 442: break; ! 443: } ! 444: freeb(bp); ! 445: } ! 446: if (bp == NULL) { ! 447: printf("debna %d no delim\n", unit); ! 448: bc->dcnt = 0; ! 449: dp->h.q.head = (quadque *)bn->xfree; ! 450: bn->xfree = dp; ! 451: return (1); /* ok to try another channel */ ! 452: } ! 453: if (p - dp->d < ETHERMINTU) ! 454: p = dp->d + ETHERMINTU; /* quietly extend */ ! 455: dp->h.bd_opc = BVPSNDDGI; ! 456: dp->h.bd_flag = BVPRSP; /* so it will appear on rsp queue */ ! 457: dp->h.bd_len = p - &dp->h.bd_dgsts; ! 458: dp->h.bd_ptdb = unit; /* some valid number */ ! 459: /* probably should zero some other fields */ ! 460: if (insqti((caddr_t)dp, &bn->bvp.d->p.p_cmdq[PCMDQ])) ! 461: bvpcomm(bn->bvp.r, PCOWN|PCCMDQ|(PCMDQ<<PCDS)); ! 462: return (1); ! 463: } ! 464: ! 465: /* ! 466: * free a buffer for the port to fill in ! 467: * -- port fusses if buffer bigger than an Ethernet packet + BVP header ! 468: */ ! 469: bnarbuf(bn, dp) ! 470: register struct bnactl *bn; ! 471: register struct dgi *dp; ! 472: { ! 473: ! 474: dp->h.bd_sts = 0; /* just in case */ ! 475: dp->h.bd_opc = BVPRCVDGI; ! 476: dp->h.bd_len = sizeof(struct bvpdg) + NIRCVBUF - BVPHSIZE; ! 477: if (insqti((caddr_t)dp, &bn->bvp.d->f[PFREQ].f_q)) ! 478: bvpcomm(bn->bvp.r, PCOWN|PCFREQ|(PFREQ<<PCDS)); ! 479: } ! 480: ! 481: bnaxbuf(bn, dp) ! 482: register struct bnactl *bn; ! 483: register struct dgi *dp; ! 484: { ! 485: register int i; ! 486: ! 487: dp->h.q.head = (quadque *)bn->xfree; ! 488: bn->xfree = dp; ! 489: if (bn->needst) { ! 490: bn->needst = 0; ! 491: for (i = 0; i < BNACHAN; i++) ! 492: if (bn->chan[i].needst) ! 493: bnastptdb(bn, &bn->chan[i]); ! 494: } ! 495: } ! 496: ! 497: /* ! 498: * (fairly) general BVP routines ! 499: */ ! 500: bvpinit(bv, ap, roff) ! 501: register struct bvp *bv; ! 502: struct biaddr *ap; ! 503: int roff; ! 504: { ! 505: register struct bvpregs *r; ! 506: register struct biic *rb; ! 507: register long ps; /* most recent status */ ! 508: ! 509: if ((rb = bv->rb) == NULL) { ! 510: if ((rb = (struct biic *)biaddr(ap)) == NULL ! 511: || badaddr(rb, sizeof(long))) { ! 512: printf("bvp absent\n"); ! 513: return (0); ! 514: } ! 515: bv->rb = rb; ! 516: } ! 517: if (bv->r == NULL) { ! 518: r = (struct bvpregs *)((char *)rb + roff); ! 519: if (badaddr(r, sizeof(long))) { ! 520: printf("bvp off %x absent\n", roff); ! 521: return (0); ! 522: } ! 523: bv->r = r; ! 524: } ! 525: if (bv->dbuf == NULL) { ! 526: bv->dbuf = geteblk(); ! 527: if (bv->dbuf->b_bcount < sizeof(struct bvpdata)) { ! 528: printf("bcount too small\n"); ! 529: brelse(bv->dbuf); ! 530: return (0); ! 531: } ! 532: clrbuf(bv->dbuf); ! 533: bv->d = (struct bvpdata *)bv->dbuf->b_un.b_addr; ! 534: } ! 535: r = bv->r; ! 536: ps = r->stat; ! 537: if ((ps & PSSTAT) == SUNDEF) { ! 538: biinit(ap, 0); ! 539: bvpdatinit(bv->d); ! 540: bv->d->p.p_nodmsk = rb->biintr; ! 541: bv->d->p.p_vector = (ap->vec<<2) | 5; /* vec, br */ ! 542: bvpcomm(r, physadr(&bv->d->p)|PCOWN|PCINIT); ! 543: ps = bvpstat(r); ! 544: } ! 545: if ((ps & PSSTAT) == SINIT) { ! 546: bvpcomm(r, PCOWN|PCENAB); ! 547: ps = bvpstat(r); ! 548: } ! 549: if ((ps & PSSTAT) != SENAB) { ! 550: printf("ps %x pe %x pd %x\n", r->stat, r->err, r->data); ! 551: return (0); ! 552: } ! 553: return (1); ! 554: } ! 555: ! 556: bvpdatinit(b) ! 557: register struct bvpdata *b; ! 558: { ! 559: bzero((char *)b, sizeof(*b)); ! 560: b->p.p_nfreeq = NFREEQ; ! 561: b->p.p_fqb = b->f; ! 562: b->p.p_bvplvl = 1; ! 563: b->p.p_pqb = &b->p; ! 564: b->p.p_bdt = b->b; ! 565: b->p.p_bdtlen = NBDT; /* -1? */ ! 566: b->p.p_spt = (struct pte *)physadr(Sysmap); ! 567: b->p.p_sptlen = 0x100000; /* huge */ ! 568: b->p.p_gpt = b->p.p_spt; ! 569: b->p.p_gptlen = b->p.p_sptlen; ! 570: } ! 571: ! 572: /* ! 573: * send a port command ! 574: */ ! 575: #define COMMTIME 1000000 ! 576: ! 577: bvpcomm(r, c) ! 578: register struct bvpregs *r; ! 579: long c; ! 580: { ! 581: register int i; ! 582: ! 583: i = COMMTIME; ! 584: while (r->ctrl & PCOWN) ! 585: if (--i <= 0) { ! 586: printf("bvpcomm timeout c %x\n", c); ! 587: return; /* what else to do? */ ! 588: } ! 589: r->stat &=~ PSOWN; ! 590: r->ctrl = c; ! 591: } ! 592: ! 593: /* ! 594: * wait for status in init ! 595: */ ! 596: ! 597: #define STATTIME 1000000 ! 598: ! 599: int ! 600: bvpstat(r) ! 601: register struct bvpregs *r; ! 602: { ! 603: register long ps; ! 604: register int i; ! 605: ! 606: i = STATTIME; ! 607: while (((ps = r->stat) & PSOWN) == 0) ! 608: if (--i <= 0) { ! 609: printf("bvpstat timeout, ps %x\n", ps); ! 610: return (0); ! 611: } ! 612: return (ps); ! 613: } ! 614: ! 615: /* ! 616: * VAX queue primitives ! 617: * ! 618: * -- to set up empty queue, just zero both longwords ! 619: */ ! 620: ! 621: /* ! 622: * remove entry from head; ! 623: * return entry, or 0 if none ! 624: */ ! 625: caddr_t ! 626: remqhi(q) ! 627: quadque *q; ! 628: { ! 629: asm("0: remqhi *4(ap),r0"); ! 630: asm("bcs 0b"); /* couldn't interlock; try again */ ! 631: asm("bvc 1f"); /* br if removed something */ ! 632: asm("clrl r0"); ! 633: asm("1:"); ! 634: } ! 635: ! 636: /* ! 637: * insert entry to tail ! 638: * return 1 if this was the first entry ! 639: */ ! 640: insqti(e, q) ! 641: caddr_t e; ! 642: quadque *q; ! 643: { ! 644: asm("clrl r0"); ! 645: asm("0: insqti *4(ap),*8(ap)"); ! 646: asm("bcs 0b"); ! 647: asm("bneq 1f"); ! 648: asm("incl r0"); ! 649: asm("1:"); ! 650: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.