![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uda.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 uda.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 ! root 1: /* ! 2: * DSA port driver for uda50 ! 3: * ! 4: * this just passes packets around; ! 5: * it makes calls to the routines in ra.c ! 6: * to get the packets filled in ! 7: */ ! 8: ! 9: #include "sys/param.h" ! 10: #include "sys/buf.h" ! 11: #include "sys/ubaddr.h" ! 12: #include "sys/map.h" ! 13: #include "sys/uba.h" ! 14: #include "sys/uda.h" ! 15: #include "sys/mscp.h" ! 16: ! 17: /* ! 18: * ONEPATH tries to use only one data path per controller; ! 19: * a nice idea, but a disaster on the DW780 -- ! 20: * the UDA50 will cheerfully run transfers in parallel from ! 21: * two drives on the same data path, which confuses the ! 22: * DW780 and mixes up the data ! 23: */ ! 24: /* #define ONEPATH 1 /* don't */ ! 25: ! 26: #define hiword(x) (((long)(x)>>16)&0177777) ! 27: #define loword(x) ((long)(x)&0177777) ! 28: ! 29: extern struct uba uba[]; ! 30: extern struct ubaddr udaddr[]; ! 31: extern struct ud ud[]; ! 32: extern int udcnt; ! 33: ! 34: struct ctab { ! 35: int (*c_seql)(); ! 36: int (*c_dg)(); ! 37: int c_ctype; ! 38: } udctab[MSMAXID]; ! 39: ! 40: struct device { ! 41: short udip; ! 42: short udsa; ! 43: }; ! 44: ! 45: /* ! 46: * bits in udsa ! 47: */ ! 48: ! 49: #define ERR 0100000 ! 50: #define STEP4 040000 ! 51: #define STEP3 020000 ! 52: #define STEP2 010000 ! 53: #define STEP1 04000 ! 54: #define STEPS (STEP1|STEP2|STEP3|STEP4) ! 55: ! 56: #define IE 0200 /* step1 interrupt enable */ ! 57: #define PI 01 /* step2 purge intr enab */ ! 58: #define GO 01 /* step4 ok */ ! 59: ! 60: /* ! 61: * uda communication area ! 62: * ring sizes are chosen so that, ! 63: * with 4K byte buffers, ! 64: * one udcomm + CSIZE-sized command packets will ! 65: * fit in one buffer; ! 66: * RSIZE-sized response packets ! 67: * will fit in another ! 68: * ! 69: * ring sizes must be powers of 2 ! 70: * (they are passed as such to the port) ! 71: * ! 72: * a delicacy: ! 73: * command packets should not cross 64Kb boundaries. ! 74: * it is believed that the KDB50 gets it wrong if they do. ! 75: * hence, make CSIZE+4 evenly divide a page, ! 76: * and get it aligned sensibly in bdreset ! 77: */ ! 78: ! 79: #define NCP2 5 ! 80: #define NRP2 5 ! 81: #define NCMD (1<<NCP2) ! 82: #define NRSP (1<<NRP2) ! 83: ! 84: struct udcomm { ! 85: short ud__r0; /* reserved (ugh) */ ! 86: char ud__r1; ! 87: char ud_bdp; /* path to purge */ ! 88: short ud_cmdint; /* flag for command interrupt */ ! 89: short ud_rspint; /* flag for response interrupt */ ! 90: long ud_rsp[NRSP]; /* response pointer ring */ ! 91: long ud_cmd[NCMD]; /* command pointer ring */ ! 92: }; ! 93: ! 94: /* ! 95: * bits in ring pointers ! 96: */ ! 97: ! 98: #define DPOWN 0x80000000 /* port owns descriptor */ ! 99: #define DIE 0x40000000 /* ring transition intr enab */ ! 100: ! 101: #define CSIZE 60 /* max size of command packet */ ! 102: #define RSIZE 60 /* max size of response packet */ ! 103: #define HDRSIZE 4 /* size of the header */ ! 104: ! 105: struct udcmd { ! 106: short uc_len; /* length of message */ ! 107: char uc_tc; /* type, credits */ ! 108: char uc_cid; /* connection id */ ! 109: char uc_data[CSIZE]; ! 110: }; ! 111: ! 112: struct udrsp { ! 113: short ur_len; /* length of message */ ! 114: char ur_tc; /* type, credits */ ! 115: char ur_cid; /* connection id */ ! 116: char ur_data[RSIZE]; ! 117: }; ! 118: ! 119: /* ! 120: * message types ! 121: */ ! 122: ! 123: #define MTYPE 0xf0 /* where type lives */ ! 124: #define MTSEQL 0x00 /* sequential message */ ! 125: #define MTDG 0x10 /* datagram */ ! 126: #define MTCR 0x20 /* credit notification */ ! 127: ! 128: #define MTNC 0xf /* credits in tc */ ! 129: ! 130: /* ! 131: * etc ! 132: */ ! 133: ! 134: #define PRIINI (PZERO-3) ! 135: #define PRIPKT (PZERO-2) ! 136: #define PRICRED (PZERO-1) ! 137: ! 138: /* ! 139: * command packet to index ! 140: */ ! 141: #define udmptoi(up, mp) ((struct udcmd *)((char *)(mp) - HDRSIZE) - (up)->ud_cpkt) ! 142: ! 143: #define TIMEOUT 15 /* time between checks */ ! 144: ! 145: int udinit(), udsend(), udmap(), udunmap(); ! 146: struct mscmd *udgpkt(); ! 147: struct msportsw udport = { ! 148: udinit, udgpkt, udmap, udsend, udunmap ! 149: }; ! 150: ! 151: /* ! 152: * init the port ! 153: * returns nonzero if probably ok ! 154: * allowed to sleep ! 155: */ ! 156: ! 157: #define UDCOFF (((sizeof(struct udcomm)/sizeof(struct udcmd))+1)*sizeof(struct udcmd)) ! 158: ! 159: udinit(dev, type, force, cid, seql, dg) ! 160: unsigned int dev; ! 161: unsigned int cid; ! 162: int force; ! 163: int (*seql)(), (*dg)(); ! 164: { ! 165: register struct ud *up; ! 166: register int ubno; ! 167: struct buf *geteblk(); ! 168: extern udtimer(); ! 169: ! 170: if (dev >= udcnt) ! 171: return (0); ! 172: if (cid >= MSMAXID) ! 173: return (0); ! 174: udctab[cid].c_seql = seql; ! 175: udctab[cid].c_dg = dg; ! 176: udctab[cid].c_ctype = type; ! 177: up = &ud[dev]; ! 178: ubno = udaddr[dev].ubno; ! 179: if (up->ud_flags & UISTART && force == 0) ! 180: return (1); ! 181: if ((up->ud_addr = (struct device *)ubaddr(&udaddr[dev])) == 0) ! 182: return (0); ! 183: if (ubbadaddr(ubno, &up->ud_addr->udsa, sizeof(short))) { ! 184: printf("ud%d not present\n", dev); ! 185: return (0); ! 186: } ! 187: udrundown(dev); ! 188: if ((up->ud_flags & UINIT) == 0) { ! 189: up->ud_cbuf = geteblk(); ! 190: clrbuf(up->ud_cbuf); ! 191: up->ud_rbuf = geteblk(); ! 192: clrbuf(up->ud_rbuf); ! 193: up->ud_cbm = ubmbuf(ubno, up->ud_cbuf, 0); ! 194: up->ud_rbm = ubmbuf(ubno, up->ud_cbuf, 0); ! 195: #if ONEPATH ! 196: up->ud_bdpno = ubmapath(ubno); ! 197: #endif ! 198: up->ud_comm = (struct udcomm *)up->ud_cbuf->b_un.b_addr; ! 199: up->ud_cpkt = (struct udcmd *)(up->ud_cbuf->b_un.b_addr + UDCOFF); ! 200: up->ud_rpkt = (struct udrsp *)up->ud_rbuf->b_un.b_addr; ! 201: up->ud_flags |= UINIT; ! 202: timeout(udtimer, (caddr_t)dev, TIMEOUT * HZ); ! 203: } ! 204: return (udreset(dev)); ! 205: } ! 206: ! 207: /* ! 208: * reset device ! 209: * initially or after error or power fail ! 210: * -- empirically, INITSTALL must be 200000 or so ! 211: * to work with TD Systems SCSI adapter on 8550 ! 212: */ ! 213: ! 214: #define INITSTALL 200000 /* >>1200us */ ! 215: ! 216: udreset(dev) ! 217: int dev; ! 218: { ! 219: register struct ud *up; ! 220: register struct device *rp; ! 221: register uaddr_t pa; ! 222: register int i; ! 223: ! 224: up = &ud[dev]; ! 225: rp = up->ud_addr; ! 226: up->ud_flags &=~ UIDONE; ! 227: up->ud_flags |= UISTART; ! 228: rp->udip = 0; /* hard reset */ ! 229: pa = ubadbuf(udaddr[dev].ubno, up->ud_cbuf, up->ud_cbm); ! 230: up->ud_pcomm = pa + (4 * sizeof(short)); /* -> ud_rsp */ ! 231: up->ud_pcpkt = pa + UDCOFF; ! 232: up->ud_cnext = 0; ! 233: up->ud_rnext = 0; ! 234: up->ud_credits = 0; ! 235: for (i = 0; (rp->udsa & STEP1) == 0 && i < INITSTALL; i++) ! 236: ; ! 237: if ((rp->udsa & STEP1) == 0) { ! 238: up->ud_flags &=~ UISTART; ! 239: printf("ud%d won't init\n", dev); ! 240: return (0); ! 241: } ! 242: rp->udsa = ERR | IE | (NCP2<<11) | (NRP2<<8) | (udaddr[dev].vec>>2); ! 243: return (1); ! 244: } ! 245: ! 246: /* ! 247: * finish up init, step by step ! 248: * called from interrupt code ! 249: */ ! 250: ! 251: udinintr(dev) ! 252: int dev; ! 253: { ! 254: register struct ud *up; ! 255: register struct device *rp; ! 256: register int i; ! 257: register uaddr_t pa; ! 258: ! 259: up = &ud[dev]; ! 260: rp = up->ud_addr; ! 261: if (up->ud_flags & UIDONE) { ! 262: printf("ud%d: unexpected init: sa %o\n", dev, rp->udsa); ! 263: return; ! 264: } ! 265: switch (rp->udsa & STEPS) { ! 266: case STEP1: ! 267: udreset(dev); ! 268: return; ! 269: ! 270: case STEP2: ! 271: /* need to set PI for 780 type unibus. */ ! 272: rp->udsa = loword(up->ud_pcomm)|((uba[udaddr[dev].ubno].flags&UBQBUS)?0:PI); ! 273: return; ! 274: ! 275: case STEP3: ! 276: rp->udsa = hiword(up->ud_pcomm); ! 277: return; ! 278: ! 279: case STEP4: ! 280: rp->udsa = GO; ! 281: for (i = 0; i < NCMD; i++) { ! 282: up->ud_comm->ud_cmd[i] = 0; /* unnecessary */ ! 283: up->ud_cpkt[i].uc_len = CSIZE; ! 284: up->ud_cbusy[i] = FREE; ! 285: up->ud_back[i] = NOBACK; ! 286: } ! 287: pa = ubadbuf(udaddr[dev].ubno, up->ud_rbuf, up->ud_rbm); ! 288: pa += 2 * sizeof(short); ! 289: for (i = 0; i < NRSP; i++, pa += sizeof(struct udrsp)) { ! 290: up->ud_comm->ud_rsp[i] = pa | DIE | DPOWN; ! 291: up->ud_rpkt[i].ur_len = RSIZE; ! 292: } ! 293: up->ud_flags |= UIDONE | UFIRST; ! 294: wakeup((caddr_t)up); ! 295: return; ! 296: ! 297: default: ! 298: printf("ud%d init bad: sa %o\n", dev, rp->udsa); ! 299: return; ! 300: } ! 301: } ! 302: ! 303: /* ! 304: * tell the class drivers that the controller was reset ! 305: * so they can clean up ! 306: * called after controller is stopped (so it's safe to unmap things) ! 307: */ ! 308: udrundown(dev) ! 309: int dev; ! 310: { ! 311: static struct msend me; ! 312: register int i; ! 313: ! 314: me.m_sts = STRST; /* magic */ ! 315: for (i = 0; i < MSMAXID; i++) ! 316: if (udctab[i].c_seql) ! 317: (*udctab[i].c_seql)(dev, udctab[i].c_ctype, &me); ! 318: } ! 319: ! 320: /* ! 321: * allocate a packet ! 322: * and sufficient resources to send it ! 323: * eg credits ! 324: * may sleep ! 325: * ! 326: * somewhat silly assumption: ! 327: * class driver will allocate a packet, and send it right away or nearly so ! 328: */ ! 329: ! 330: struct mscmd * ! 331: udgpkt(dev) ! 332: int dev; ! 333: { ! 334: register struct ud *up; ! 335: register int i; ! 336: int s; ! 337: ! 338: up = &ud[dev]; ! 339: if (up->ud_addr->udsa & STEP1) /* was reset somehow */ ! 340: udreset(dev); ! 341: s = spl6(); ! 342: while ((up->ud_flags & UIDONE) == 0) ! 343: sleep((caddr_t)up, PRIINI); ! 344: while (up->ud_credits < 2 && (up->ud_flags & UFIRST) == 0) { ! 345: if (udpkscan(dev, 1)) ! 346: continue; ! 347: up->ud_flags |= UCWAIT; ! 348: sleep((caddr_t)&up->ud_credits, PRICRED); ! 349: } ! 350: if ((up->ud_flags & UFIRST) == 0) ! 351: up->ud_credits--; ! 352: for (;;) { ! 353: for (i = 0; i < NCMD; i++) ! 354: if (up->ud_cbusy[i] == FREE) ! 355: break; ! 356: if (i < NCMD) ! 357: break; ! 358: if (udpkscan(dev, 1) == 0 && udcmdscan(dev) == 0) { /* kludge for hung controller */ ! 359: up->ud_flags |= UPWAIT; ! 360: sleep((caddr_t)up->ud_cbusy, PRIPKT); ! 361: } ! 362: } ! 363: up->ud_cbusy[i] = NABBED; ! 364: splx(s); ! 365: return ((struct mscmd *)up->ud_cpkt[i].uc_data); ! 366: } ! 367: ! 368: /* ! 369: * map a transfer into unibus space ! 370: * and record in the buffer descriptor of a packet ! 371: * may sleep ! 372: */ ! 373: ! 374: udmap(dev, mp, bp) ! 375: int dev; ! 376: struct mscmd *mp; ! 377: register struct buf *bp; ! 378: { ! 379: register struct ud *up; ! 380: register int i; ! 381: ! 382: up = &ud[dev]; ! 383: i = udmptoi(up, mp); ! 384: #if ONEPATH ! 385: if (up->ud_cmap[i] == 0) ! 386: up->ud_cmap[i] = ubmbuf(udaddr[dev].ubno, bp, USLP); ! 387: up->ud_cmap[i] = ubinspath(up->ud_bdpno, up->ud_cmap[i]); ! 388: #else ! 389: if (up->ud_cmap[i] == 0) ! 390: up->ud_cmap[i] = ubmbuf(udaddr[dev].ubno, bp, UBDP|USLP); ! 391: #endif ! 392: up->ud_cbusy[i] |= MAPPED; ! 393: *(long *)&mp->m_buff = ubadbuf(udaddr[dev].ubno, bp, up->ud_cmap[i]); ! 394: #if ONEPATH ! 395: *(long *)&mp->m_buff |= up->ud_bdpno << 24; ! 396: #else ! 397: *(long *)&mp->m_buff |= ubmpath(up->ud_cmap[i]) << 24; ! 398: #endif ! 399: } ! 400: ! 401: /* ! 402: * free a mapped packet ! 403: * flush the bdp; ! 404: * change the path in the map to the DDP before freeing (ugh) ! 405: * so we won't free our reserved BDP too ! 406: * it is OK to free an already freed packet, mostly to help reset code ! 407: */ ! 408: ! 409: udunmap(dev, mp) ! 410: int dev; ! 411: struct mscmd *mp; ! 412: { ! 413: register struct ud *up; ! 414: register int i; ! 415: ! 416: up = &ud[dev]; ! 417: i = udmptoi(up, mp); ! 418: if (up->ud_cmap[i]) { ! 419: #if ONEPATH ! 420: ubmflush(udaddr[dev].ubno, ubmpath(up->ud_cmap[i])); ! 421: ubmfree(udaddr[dev].ubno, ubinspath(0, up->ud_cmap[i])); ! 422: #else ! 423: ubmfree(udaddr[dev].ubno, up->ud_cmap[i]); ! 424: #endif ! 425: up->ud_cmap[i] = 0; ! 426: } ! 427: up->ud_cbusy[i] = FREE; ! 428: if (up->ud_flags & UPWAIT) { ! 429: up->ud_flags &=~ UPWAIT; ! 430: wakeup((caddr_t)up->ud_cbusy); ! 431: } ! 432: } ! 433: ! 434: ! 435: /* ! 436: * send a packet ! 437: * may not sleep ! 438: * call at spl5 ! 439: */ ! 440: udsend(dev, cid, mp) ! 441: int dev; ! 442: int cid; ! 443: struct mscmd *mp; ! 444: { ! 445: register struct ud *up; ! 446: register int i; ! 447: register int j; ! 448: register struct device *rp; ! 449: ! 450: up = &ud[dev]; ! 451: up->ud_flags &=~ UFIRST; ! 452: i = udmptoi(up, mp); ! 453: up->ud_cpkt[i].uc_cid = cid; ! 454: j = up->ud_cnext++; ! 455: if (up->ud_cnext >= NCMD) ! 456: up->ud_cnext = 0; ! 457: if (up->ud_comm->ud_cmd[j] & DPOWN) ! 458: panic("udsend"); ! 459: if (up->ud_back[j] >= 0) { /* ran for a while with no free */ ! 460: udcmdscan(dev); ! 461: if (up->ud_back[j] >= 0) ! 462: panic("udsend"); ! 463: } ! 464: rp = up->ud_addr; ! 465: if (rp->udsa & ERR) { /* and now we lose a packet */ ! 466: printf("ud%d: hard error %o\n", dev, rp->udsa & 0177777); ! 467: udreset(dev); ! 468: return; ! 469: } ! 470: up->ud_back[j] = i; ! 471: up->ud_comm->ud_cmd[j] = DPOWN | DIE | ! 472: up->ud_pcpkt + (i * sizeof(struct udcmd)) + (2 * sizeof(short)); ! 473: up->ud_cbusy[i] |= SENT; ! 474: up->ud_cbusy[i] &=~ NABBED; ! 475: i = rp->udip; /* initiate polling */ ! 476: } ! 477: ! 478: /* ! 479: * interrupt routine ! 480: */ ! 481: ! 482: long ud_spur; ! 483: long ud_npr; ! 484: #define INIRETRY 5 /* TQK50 botch -- needs time to settle */ ! 485: ! 486: ud0int(dev) ! 487: int dev; ! 488: { ! 489: register struct ud *up; ! 490: register struct device *rp; ! 491: register int i; ! 492: ! 493: up = &ud[dev]; ! 494: if (dev >= udcnt || (up->ud_flags & UINIT) == 0) { ! 495: printf("ud%d: stray intr\n", dev); ! 496: return; ! 497: } ! 498: rp = up->ud_addr; ! 499: if ((up->ud_flags & UIDONE) == 0) { ! 500: for (i = 0; i < INIRETRY; i++) ! 501: if (rp->udsa & (STEPS|ERR)) ! 502: break; ! 503: if ((rp->udsa & (STEPS|ERR)) == 0) { ! 504: printf("ud%d: init lost; sa 0%o\n", dev, rp->udsa); ! 505: return; ! 506: } ! 507: } ! 508: if (rp->udsa & ERR) { ! 509: printf("ud%d: hard error %o\n", dev, rp->udsa & 0177777); ! 510: udreset(dev); ! 511: return; ! 512: } ! 513: if (rp->udsa & STEPS) { ! 514: udinintr(dev); ! 515: return; ! 516: } ! 517: if (up->ud_comm->ud_bdp == 0 ! 518: && up->ud_comm->ud_cmdint == 0 ! 519: && up->ud_comm->ud_rspint == 0) ! 520: ud_spur++; ! 521: if (up->ud_comm->ud_bdp) { ! 522: ubmflush(udaddr[dev].ubno, up->ud_comm->ud_bdp); ! 523: up->ud_comm->ud_bdp = 0; ! 524: rp->udsa = 0; /* ack purge */ ! 525: ud_npr++; ! 526: } ! 527: while (up->ud_comm->ud_cmdint) { ! 528: up->ud_comm->ud_cmdint = 0; ! 529: udcmdscan(dev); ! 530: } ! 531: while (up->ud_comm->ud_rspint) { ! 532: up->ud_comm->ud_rspint = 0; ! 533: if (udpkscan(dev, 0)) ! 534: up->ud_flags &=~ UTIMER; ! 535: } ! 536: } ! 537: ! 538: /* ! 539: * free packets which are completely sent ! 540: * (and which don't have associated map) ! 541: */ ! 542: ! 543: udcmdscan(dev) ! 544: int dev; ! 545: { ! 546: register struct ud *up; ! 547: register int i, j; ! 548: register int freed; ! 549: register struct udcomm *udc; ! 550: ! 551: up = &ud[dev]; ! 552: udc = up->ud_comm; ! 553: freed = 0; ! 554: for (j = 0; j < NCMD; j++) ! 555: if (up->ud_back[j] >= 0 ! 556: && (udc->ud_cmd[j] & DPOWN) == 0) { ! 557: i = up->ud_back[j]; ! 558: if ((up->ud_cbusy[i] & (SENT|MAPPED)) == SENT) { ! 559: up->ud_cbusy[i] = FREE; ! 560: freed++; ! 561: } ! 562: up->ud_back[j] = NOBACK; ! 563: } ! 564: if (freed && up->ud_flags & UPWAIT) ! 565: wakeup((caddr_t)up->ud_cbusy); ! 566: return (freed); ! 567: } ! 568: ! 569: /* ! 570: * check for responses from the controller ! 571: * and deal with them ! 572: * return a count for debugging purposes ! 573: * called at spl6 (because of udtimer) ! 574: */ ! 575: ! 576: int ! 577: udpkscan(dev, doall) ! 578: int dev; ! 579: int doall; ! 580: { ! 581: register struct ud *up; ! 582: register int i; ! 583: int nf; ! 584: register struct udrsp *pk; ! 585: register struct ctab *cp; ! 586: register struct udcomm *udc; /* speed */ ! 587: ! 588: up = &ud[dev]; ! 589: udc = up->ud_comm; ! 590: nf = 0; ! 591: for (i = up->ud_rnext; ; i < NRSP-1 ? i++ : (i=0)) { ! 592: if (udc->ud_rsp[i] & DPOWN) { ! 593: up->ud_rnext = i; ! 594: /* don't stop if doall? */ ! 595: break; ! 596: } ! 597: nf++; ! 598: pk = &up->ud_rpkt[i]; ! 599: up->ud_credits += pk->ur_tc & MTNC; ! 600: if (up->ud_flags & UCWAIT) { ! 601: wakeup((caddr_t)&up->ud_credits); ! 602: up->ud_flags &=~ UCWAIT; ! 603: } ! 604: if (pk->ur_cid > MSMAXID) ! 605: printf("ud%d msg id %d\n", dev, pk->ur_cid); ! 606: else { ! 607: cp = &udctab[pk->ur_cid]; ! 608: switch (pk->ur_tc & MTYPE) { ! 609: case MTSEQL: ! 610: if (cp->c_seql) ! 611: (*cp->c_seql)(dev, cp->c_ctype, (struct msend *)pk->ur_data); ! 612: break; ! 613: ! 614: case MTDG: ! 615: if (cp->c_dg) ! 616: (*cp->c_dg)(dev, cp->c_ctype, pk->ur_data); ! 617: break; ! 618: ! 619: /* default: ignore */ ! 620: } ! 621: } ! 622: pk->ur_len = RSIZE; ! 623: udc->ud_rsp[i] |= DPOWN | DIE; ! 624: } ! 625: return (nf); ! 626: } ! 627: ! 628: /* ! 629: * timeout routine ! 630: * return any waiting packets ! 631: * -- callout routines don't necessarily run at high priority. ! 632: * hence the spl6, so udpkscan won't be reentered ! 633: */ ! 634: ! 635: int ud_kicked; ! 636: ! 637: udtimer(i) ! 638: int i; ! 639: { ! 640: register struct ud *up; ! 641: register int s; ! 642: ! 643: up = &ud[i]; ! 644: if ((up->ud_flags & UINIT) == 0) ! 645: return; ! 646: if (up->ud_flags & UIDONE) { ! 647: if ((up->ud_flags & UTIMER) == 0) ! 648: up->ud_flags |= UTIMER; ! 649: else { ! 650: s = spl6(); ! 651: if (udpkscan(i, 1) && up->ud_flags & UPWAIT) { ! 652: wakeup((caddr_t)up->ud_cbusy); ! 653: ud_kicked++; ! 654: } ! 655: splx(s); ! 656: up->ud_flags &=~ UTIMER; ! 657: } ! 658: } ! 659: timeout(udtimer, (caddr_t)i, TIMEOUT * HZ); ! 660: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.