![[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] / researchv10dc / lsys / io|
Return to debna.c CVS log | Up to [Research Unix] / researchv10dc / lsys / 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, proto; ! 333: ! 334: if (dp->h.bd_dgsts != NISUC) { ! 335: printf("debna %d dg sts %x\n", bn - bna, dp->h.bd_dgsts); ! 336: return; ! 337: } ! 338: len = (dp->h.bd_len+BVPHSIZE)-sizeof(struct bvpdg)-ETHERCKSUM; ! 339: proto = ((struct etherpup *)dp->d)->type; ! 340: for (n = 0; n < BNACHAN; n++) ! 341: if (bn->chan[n].proto == proto) ! 342: break; ! 343: if (n >= BNACHAN) ! 344: return; /* unexpected proto */ ! 345: q = bn->chan[n].rq; ! 346: if (q == NULL) ! 347: return; /* snh */ ! 348: if (q->next->flag & QFULL) ! 349: return; /* no room */ ! 350: p = dp->d; ! 351: while (len > 0) { ! 352: if ((bp = allocb(len)) == NULL) ! 353: return; /* wrong, but hard */ ! 354: n = bp->lim - bp->wptr; ! 355: if (len < n) ! 356: n = len; ! 357: bcopy(p, bp->wptr, n); ! 358: bp->wptr += n; ! 359: p += n; ! 360: len -= n; ! 361: if (len <= 0) ! 362: bp->class |= S_DELIM; ! 363: (*q->next->qinfo->putp)(q->next, bp); ! 364: } ! 365: } ! 366: ! 367: /* ! 368: * here is a message ! 369: */ ! 370: ! 371: bnarmsg(bn, dp) ! 372: register struct bnactl *bn; ! 373: register struct bvpmsg *dp; ! 374: { ! 375: register struct bnachan *bc; ! 376: register struct mst *sdp; ! 377: ! 378: switch (dp->bm_opc) { ! 379: case NISTPTDB: /* ptdb set, sent ioctl back */ ! 380: sdp = (struct mst *)dp; ! 381: if (sdp->p.pt_id < 0 || sdp->p.pt_id >= BNACHAN) ! 382: panic("bnastptdb"); ! 383: bc = &bn->chan[sdp->p.pt_id]; ! 384: if (bc->rq == NULL || bc->proto != sdp->p.pt_proto) ! 385: return; /* early close? */ ! 386: if (sdp->h.bm_nists != NISUC) ! 387: printf("debna %d %d stptdb sts %x\n", bn - bna, ! 388: sdp->p.pt_id, sdp->h.bm_nists); ! 389: putctl(bc->rq->next, M_IOCACK); ! 390: return; ! 391: ! 392: default: ! 393: printf("debna %d msg opc %x sts %x\n", dp->bm_opc, dp->bm_nists); ! 394: return; ! 395: } ! 396: } ! 397: ! 398: /* ! 399: * find a channel with a packet, ! 400: * find a buffer, ! 401: * and send ! 402: */ ! 403: bnasend(unit) ! 404: int unit; ! 405: { ! 406: register struct bnactl *bn; ! 407: register struct bnachan *bc; ! 408: register struct dgi *dp; ! 409: register char *p; ! 410: register struct block *bp; ! 411: register int n; ! 412: char *ep; ! 413: ! 414: bn = &bna[unit]; ! 415: n = bn->lastx; ! 416: while (bn->chan[n].dcnt == 0) { ! 417: if (++n >= BNACHAN) ! 418: n = 0; ! 419: if (n == bn->lastx) ! 420: return (0); /* nothing to send */ ! 421: } ! 422: bn->lastx = n; ! 423: bc = &bn->chan[n]; ! 424: if ((dp = bn->xfree) == NULL) ! 425: return (0); /* no buffer */ ! 426: bn->xfree = (struct dgi *)dp->h.q.head; ! 427: bzero((caddr_t)&dp->h, sizeof(dp->h)); ! 428: p = dp->d; ! 429: ep = p + sizeof(dp->d); ! 430: while ((bp = getq(WR(bc->rq))) != NULL) { ! 431: n = bp->wptr - bp->rptr; ! 432: if (p + n > ep) ! 433: n = ep - p; /* quietly truncate */ ! 434: if (n) { ! 435: bcopy(bp->rptr, p, n); ! 436: p += n; ! 437: } ! 438: if (bp->class & S_DELIM) { ! 439: bc->dcnt--; ! 440: freeb(bp); ! 441: break; ! 442: } ! 443: freeb(bp); ! 444: } ! 445: if (bp == NULL) { ! 446: printf("debna %d no delim\n", unit); ! 447: bc->dcnt = 0; ! 448: dp->h.q.head = (quadque *)bn->xfree; ! 449: bn->xfree = dp; ! 450: return (1); /* ok to try another channel */ ! 451: } ! 452: if (p - dp->d < ETHERMINTU) ! 453: p = dp->d + ETHERMINTU; /* quietly extend */ ! 454: dp->h.bd_opc = BVPSNDDGI; ! 455: dp->h.bd_flag = BVPRSP; /* so it will appear on rsp queue */ ! 456: dp->h.bd_len = p - &dp->h.bd_dgsts; ! 457: dp->h.bd_ptdb = unit; /* some valid number */ ! 458: /* probably should zero some other fields */ ! 459: if (insqti((caddr_t)dp, &bn->bvp.d->p.p_cmdq[PCMDQ])) ! 460: bvpcomm(bn->bvp.r, PCOWN|PCCMDQ|(PCMDQ<<PCDS)); ! 461: return (1); ! 462: } ! 463: ! 464: /* ! 465: * free a buffer for the port to fill in ! 466: * -- port fusses if buffer bigger than an Ethernet packet + BVP header ! 467: */ ! 468: bnarbuf(bn, dp) ! 469: register struct bnactl *bn; ! 470: register struct dgi *dp; ! 471: { ! 472: ! 473: dp->h.bd_sts = 0; /* just in case */ ! 474: dp->h.bd_opc = BVPRCVDGI; ! 475: dp->h.bd_len = sizeof(struct bvpdg) + NIRCVBUF - BVPHSIZE; ! 476: if (insqti((caddr_t)dp, &bn->bvp.d->f[PFREQ].f_q)) ! 477: bvpcomm(bn->bvp.r, PCOWN|PCFREQ|(PFREQ<<PCDS)); ! 478: } ! 479: ! 480: bnaxbuf(bn, dp) ! 481: register struct bnactl *bn; ! 482: register struct dgi *dp; ! 483: { ! 484: register int i; ! 485: ! 486: dp->h.q.head = (quadque *)bn->xfree; ! 487: bn->xfree = dp; ! 488: if (bn->needst) { ! 489: bn->needst = 0; ! 490: for (i = 0; i < BNACHAN; i++) ! 491: if (bn->chan[i].needst) ! 492: bnastptdb(bn, &bn->chan[i]); ! 493: } ! 494: } ! 495: ! 496: /* ! 497: * (fairly) general BVP routines ! 498: */ ! 499: bvpinit(bv, ap, roff) ! 500: register struct bvp *bv; ! 501: struct biaddr *ap; ! 502: int roff; ! 503: { ! 504: register struct bvpregs *r; ! 505: register struct biic *rb; ! 506: register long ps; /* most recent status */ ! 507: ! 508: if ((rb = bv->rb) == NULL) { ! 509: if ((rb = (struct biic *)biaddr(ap)) == NULL ! 510: || badaddr(rb, sizeof(long))) { ! 511: printf("bvp absent\n"); ! 512: return (0); ! 513: } ! 514: bv->rb = rb; ! 515: } ! 516: if (bv->r == NULL) { ! 517: r = (struct bvpregs *)((char *)rb + roff); ! 518: if (badaddr(r, sizeof(long))) { ! 519: printf("bvp off %x absent\n", roff); ! 520: return (0); ! 521: } ! 522: bv->r = r; ! 523: } ! 524: if (bv->dbuf == NULL) { ! 525: bv->dbuf = geteblk(); ! 526: if (bv->dbuf->b_bcount < sizeof(struct bvpdata)) { ! 527: printf("bcount too small\n"); ! 528: brelse(bv->dbuf); ! 529: return (0); ! 530: } ! 531: clrbuf(bv->dbuf); ! 532: bv->d = (struct bvpdata *)bv->dbuf->b_un.b_addr; ! 533: } ! 534: r = bv->r; ! 535: ps = r->stat; ! 536: if ((ps & PSSTAT) == SUNDEF) { ! 537: biinit(ap, 0); ! 538: bvpdatinit(bv->d); ! 539: bv->d->p.p_nodmsk = rb->biintr; ! 540: bv->d->p.p_vector = (ap->vec<<2) | 5; /* vec, br */ ! 541: bvpcomm(r, physadr(&bv->d->p)|PCOWN|PCINIT); ! 542: ps = bvpstat(r); ! 543: } ! 544: if ((ps & PSSTAT) == SINIT) { ! 545: bvpcomm(r, PCOWN|PCENAB); ! 546: ps = bvpstat(r); ! 547: } ! 548: if ((ps & PSSTAT) != SENAB) { ! 549: printf("ps %x pe %x pd %x\n", r->stat, r->err, r->data); ! 550: return (0); ! 551: } ! 552: return (1); ! 553: } ! 554: ! 555: bvpdatinit(b) ! 556: register struct bvpdata *b; ! 557: { ! 558: bzero((char *)b, sizeof(*b)); ! 559: b->p.p_nfreeq = NFREEQ; ! 560: b->p.p_fqb = b->f; ! 561: b->p.p_bvplvl = 1; ! 562: b->p.p_pqb = &b->p; ! 563: b->p.p_bdt = b->b; ! 564: b->p.p_bdtlen = NBDT; /* -1? */ ! 565: b->p.p_spt = (struct pte *)physadr(Sysmap); ! 566: b->p.p_sptlen = 0x100000; /* huge */ ! 567: b->p.p_gpt = b->p.p_spt; ! 568: b->p.p_gptlen = b->p.p_sptlen; ! 569: } ! 570: ! 571: /* ! 572: * send a port command ! 573: */ ! 574: #define COMMTIME 1000000 ! 575: ! 576: bvpcomm(r, c) ! 577: register struct bvpregs *r; ! 578: long c; ! 579: { ! 580: register int i; ! 581: ! 582: i = COMMTIME; ! 583: while (r->ctrl & PCOWN) ! 584: if (--i <= 0) { ! 585: printf("bvpcomm timeout c %x\n", c); ! 586: return; /* what else to do? */ ! 587: } ! 588: r->stat &=~ PSOWN; ! 589: r->ctrl = c; ! 590: } ! 591: ! 592: /* ! 593: * wait for status in init ! 594: */ ! 595: ! 596: #define STATTIME 1000000 ! 597: ! 598: int ! 599: bvpstat(r) ! 600: register struct bvpregs *r; ! 601: { ! 602: register long ps; ! 603: register int i; ! 604: ! 605: i = STATTIME; ! 606: while (((ps = r->stat) & PSOWN) == 0) ! 607: if (--i <= 0) { ! 608: printf("bvpstat timeout, ps %x\n", ps); ! 609: return (0); ! 610: } ! 611: return (ps); ! 612: } ! 613: ! 614: /* ! 615: * VAX queue primitives ! 616: * ! 617: * -- to set up empty queue, just zero both longwords ! 618: */ ! 619: ! 620: /* ! 621: * remove entry from head; ! 622: * return entry, or 0 if none ! 623: */ ! 624: caddr_t ! 625: remqhi(q) ! 626: quadque *q; ! 627: { ! 628: asm("0: remqhi *4(ap),r0"); ! 629: asm("bcs 0b"); /* couldn't interlock; try again */ ! 630: asm("bvc 1f"); /* br if removed something */ ! 631: asm("clrl r0"); ! 632: asm("1:"); ! 633: } ! 634: ! 635: /* ! 636: * insert entry to tail ! 637: * return 1 if this was the first entry ! 638: */ ! 639: insqti(e, q) ! 640: caddr_t e; ! 641: quadque *q; ! 642: { ! 643: asm("clrl r0"); ! 644: asm("0: insqti *4(ap),*8(ap)"); ! 645: asm("bcs 0b"); ! 646: asm("bneq 1f"); ! 647: asm("incl r0"); ! 648: asm("1:"); ! 649: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.