![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kdi.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 kdi.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 ! root 1: /* ! 2: * stream driver for DK via KMC-11/KDI board ! 3: * delicately intertwined with kmc.c ! 4: */ ! 5: ! 6: #include "sys/param.h" ! 7: #include "sys/stream.h" ! 8: #include "sys/ttyio.h" ! 9: #include "sys/dkio.h" ! 10: #include "sys/conf.h" ! 11: #include "sys/dkstat.h" ! 12: #include "sys/dkmod.h" ! 13: #include "sys/ubaddr.h" ! 14: #include "sys/kmc.h" ! 15: #include "sys/kdi.h" ! 16: #include "sys/buf.h" ! 17: #include "sys/dkwindow.h" ! 18: ! 19: #define KDIPRI 28 ! 20: ! 21: /* ! 22: * flags ! 23: */ ! 24: #define KMBUSY 0x01 ! 25: #define KMSTOP 0x02 ! 26: #define KMINC 0x04 ! 27: #define KMBIG 0x3c /* rcvd lots last time, use big rcv buffer */ ! 28: #define KMXCL 0x40 /* exclusive use */ ! 29: #define KMXBIG 0x80 /* tell KMC to use large messages */ ! 30: #define BIGSET(c) ((((c)<<1)|KMINC)&KMBIG | ((c)&~KMBIG)) ! 31: #define BIGCLR(c) (((c)<<1)&KMBIG | ((c)&~KMBIG)) ! 32: ! 33: /* ! 34: * device structure ! 35: */ ! 36: struct device { ! 37: char sts; ! 38: char x1; ! 39: union { ! 40: struct { ! 41: u_short lo; ! 42: u_char hi; ! 43: } a; ! 44: struct { ! 45: u_char x2; ! 46: u_char x3; ! 47: u_char ch; ! 48: u_char ct; ! 49: u_char sh; ! 50: u_char st; ! 51: } q; ! 52: } u; ! 53: }; ! 54: ! 55: /* ! 56: * KMC commands ! 57: */ ! 58: #define KC_INIT 1 ! 59: #define KC_SEND 2 ! 60: #define KC_RCVB 3 ! 61: #define KC_CLOSE 4 ! 62: #define KC_XINIT 5 ! 63: #define KC_CMD 6 ! 64: #define KC_FLAG 7 ! 65: #define KC_SOI 8 ! 66: ! 67: /* ! 68: * subcommands of KC_CMD or KC_SEND ! 69: */ ! 70: #define OFLUSH 02 /* flush output */ ! 71: #define OSPND 04 /* suspend output */ ! 72: #define ORSME 010 /* resume output */ ! 73: #define OBOTM 0200 /* send BOTM trailer, not BOT */ ! 74: ! 75: /* ! 76: * KMC reports ! 77: */ ! 78: #define KS_SEND 024 ! 79: #define KS_RDB 025 ! 80: #define KS_EOI 026 ! 81: #define KS_CNTL 027 ! 82: #define KS_ERR 030 ! 83: ! 84: /* ! 85: * KC_RCV modes ! 86: */ ! 87: #define CBLOCK 0040 /* return on block boundary */ ! 88: #define CTIME 0100 /* return when time expires */ ! 89: ! 90: /* ! 91: * KS_RDB mode ! 92: */ ! 93: #define SFULL 0001 /* buffer full */ ! 94: #define SCNTL 0002 /* cntl char recv */ ! 95: #define SABORT 0010 /* rcv aborted */ ! 96: #define SBLOCK 0040 /* block boundary */ ! 97: #define STIME 0100 /* time limit expired */ ! 98: ! 99: /* ! 100: * URP control characters ! 101: */ ! 102: #define D_DELAY 0100 ! 103: #define D_BREAK 0110 ! 104: ! 105: /* ! 106: * KMC errors ! 107: */ ! 108: #define E_NOQB 4 /* internal buffer runout */ ! 109: #define E_DUP 5 /* duplicate send (shouldn't but does happen) */ ! 110: #define E_UMETA 7 /* unknown control character */ ! 111: ! 112: /* ! 113: * tracing ! 114: */ ! 115: #define DEBUG ! 116: #ifdef DEBUG ! 117: struct kin ktrbuf[256]; ! 118: struct kin *ktrp = ktrbuf; ! 119: #define TRACE(x) *ktrp++ = x; if (ktrp >= &ktrbuf[256]) ktrp = ktrbuf; ! 120: #else ! 121: #define TRACE(x) ; ! 122: #endif ! 123: ! 124: int kdiclose(), kdiput(), kdiisrv(); ! 125: long kdiopen(); ! 126: struct qinit kdirinit = { noput, kdiisrv, kdiopen, kdiclose, 0, 0 }; ! 127: struct qinit kdiwinit = { kdiput, NULL, kdiopen, kdiclose, 512, 128 }; ! 128: struct streamtab kdiinfo = { &kdirinit, &kdiwinit }; ! 129: struct cdevsw kdicdev = cstrinit(&kdiinfo); ! 130: ! 131: struct kmaddr kmcubaddr(); ! 132: extern struct kdikmc kdikmc[]; ! 133: extern struct kmcdk k[]; ! 134: extern int kdicnt; ! 135: extern struct kmc kmc[]; ! 136: extern struct ubaddr kmcaddr[]; ! 137: extern int kmccnt; ! 138: struct dkstat dkstat; ! 139: ! 140: #define KDICHAN 96 /* channels per kdi (== per kmc) */ ! 141: #define KMC(d) ((d)/KDICHAN) ! 142: #define CHAN(d) ((d)%KDICHAN) ! 143: ! 144: /* ! 145: * open channel ! 146: */ ! 147: long ! 148: kdiopen(q, dev) ! 149: register struct queue *q; ! 150: dev_t dev; ! 151: { ! 152: register struct kdi *kp; ! 153: register struct block *bp; ! 154: register struct kdikmc *xp; ! 155: register int kno, chan; ! 156: ! 157: kno = KMC(minor(dev)); ! 158: chan = CHAN(minor(dev)); ! 159: if (kno >= kdicnt || kno >= kmccnt || chan >= KDICHAN) ! 160: return (0); ! 161: xp = &kdikmc[kno]; ! 162: if (xp->bad) ! 163: return (0); ! 164: if (xp->init == 0) ! 165: if (kdiinit(dev) == 0) ! 166: return (0); ! 167: kp = &xp->kdi[chan]; ! 168: if (xp->state[chan] != DKCLOSED) { ! 169: if (kp->ostate&KMXCL) /* exclusive use until reset */ ! 170: return(0); ! 171: if (xp->state[chan] != DKOPEN) ! 172: return(0); /* closing channels cannot reopen */ ! 173: return(1); ! 174: } ! 175: kp->dkrq = q; ! 176: q->ptr = (caddr_t)kp; ! 177: WR(q)->flag |= QDELIM|QBIGB; ! 178: q->flag |= QDELIM; ! 179: WR(q)->ptr = (caddr_t)kp; ! 180: xp->state[chan] = DKOPEN; ! 181: kp->ostate = KMXCL; ! 182: kcmd(kno, KC_INIT, kp->chan, 0, 0, 0, (uaddr_t)NULL); ! 183: if ((bp = allocb(64)) == NULL) { ! 184: xp->state[chan] = 0; ! 185: return(0); ! 186: } ! 187: kp->lastctl = 0; ! 188: kp->ibp = bp; ! 189: kp->imap = ubmblk(xp->ubno, bp, 0); ! 190: kcmd(kno, KC_RCVB, chan, bp->lim-bp->wptr, 50, ! 191: CBLOCK|CTIME, ubadwptr(xp->ubno, bp, kp->imap)); ! 192: return(1); ! 193: } ! 194: ! 195: kdiclose(q) ! 196: register struct queue *q; ! 197: { ! 198: register struct kdi *kp = (struct kdi *)q->ptr; ! 199: register s, i; ! 200: register struct kdikmc *xp; ! 201: ! 202: xp = &kdikmc[kp->kno]; ! 203: if (xp->modp == NULL || xp->modp->listnrq == NULL ! 204: || xp->state[kp->chan]==DKRCLOSE) ! 205: xp->state[kp->chan] = DKCLOSED; ! 206: else if (xp->state[kp->chan] == DKOPEN) { ! 207: xp->state[kp->chan] = DKLCLOSE; ! 208: for (i=0; i<30 && (WR(q)->count || kp->obp); i++) ! 209: tsleep((caddr_t)kp, KDIPRI, 1); ! 210: } ! 211: kp->dkrq = NULL; ! 212: if (xp->modp && xp->modp->listnrq) ! 213: putctl2(RD(xp->modp->listnrq), M_PRICTL, DKMCLOSE, kp->chan); ! 214: s = spl6(); ! 215: if (kp->obp) { ! 216: freeb(kp->obp); ! 217: kp->obp = NULL; ! 218: } ! 219: splx(s); ! 220: kp->ostate &= ~KMXCL; ! 221: kcmd(kp->kno, KC_CLOSE, kp->chan, 0, 0, 0, (uaddr_t)NULL); ! 222: } ! 223: ! 224: kdiput(q, bp) ! 225: register struct queue *q; ! 226: register struct block *bp; ! 227: { ! 228: register struct kdi *kdp = (struct kdi *)q->ptr; ! 229: register char *sp; ! 230: register s; ! 231: register struct kdikmc *xp; ! 232: struct block *xbp; ! 233: int t; ! 234: ! 235: xp = &kdikmc[kdp->kno]; ! 236: switch(bp->type) { ! 237: ! 238: case M_CTL: ! 239: case M_DATA: ! 240: case M_DELAY: ! 241: case M_BREAK: ! 242: if (xp->state[kdp->chan] < DKLCLOSE) { ! 243: freeb(bp); ! 244: return; ! 245: } ! 246: putq(q, bp); ! 247: if ((kdp->ostate&KMBUSY)==0) ! 248: kmstart(kdp); ! 249: return; ! 250: ! 251: case M_PRICTL: ! 252: switch (*bp->rptr) { ! 253: case DKMCLOSE: ! 254: s = bp->rptr[1]; ! 255: if (s < KDICHAN) { ! 256: flushq(q, 1); ! 257: if (xp->state[s] == DKOPEN) { ! 258: xp->state[s] = DKRCLOSE; ! 259: putctl(xp->kdi[s].dkrq->next, M_HANGUP); ! 260: } else if (xp->state[s] == DKLCLOSE) ! 261: xp->state[s] = DKCLOSED; ! 262: kcmd(kdp->kno, KC_CLOSE, s, 0, 0, 0, (uaddr_t)NULL); ! 263: } ! 264: break; ! 265: ! 266: case DKMXINIT: ! 267: /* retrieve channel number */ ! 268: bp->rptr++; ! 269: s = *bp->rptr++; ! 270: ! 271: /* forget it if this isn't a valid channel */ ! 272: if (s >= KDICHAN || xp->state[s] != DKOPEN) ! 273: break; ! 274: ! 275: /* next two bytes (if there) are the traffic type */ ! 276: if(bp->wptr-bp->rptr>=2){ ! 277: t = (*bp->rptr++<<8) & 0xff00; ! 278: t |= *bp->rptr++ & 0xff; ! 279: ! 280: /* check window sizes */ ! 281: if (W_VALID(t)) { ! 282: ! 283: /* kmc has only two possible window sizes */ ! 284: t = W_VALUE(W_ORIG(t)); ! 285: if(t<1024) ! 286: xp->kdi[s].ostate &= ~KMXBIG; ! 287: else ! 288: xp->kdi[s].ostate |= KMXBIG; ! 289: } ! 290: } ! 291: ! 292: /* restart urp on the channel, with the correct window */ ! 293: kdixinit(&xp->kdi[s]); ! 294: break; ! 295: ! 296: default: ! 297: break; ! 298: } ! 299: break; /* and freeb */ ! 300: ! 301: case M_IOCTL: ! 302: sp = stiodata(bp); ! 303: bp->type = M_IOCACK; ! 304: switch (stiocom(bp)) { ! 305: ! 306: case TIOCSDEV: ! 307: if (((struct ttydevb *)sp)->ispeed == 0) ! 308: putctl2(q, M_PRICTL, DKMCLOSE, kdp->chan); ! 309: case KIOCISURP: ! 310: bp->wptr = bp->rptr; ! 311: break; ! 312: ! 313: case DIOCSCTL: ! 314: bp->wptr = bp->rptr; ! 315: if (*sp == 0) ! 316: break; ! 317: if ((xbp = allocb(1)) == NULL) ! 318: bp->type = M_IOCNAK; ! 319: else { ! 320: xbp->type = M_CTL; ! 321: *xbp->wptr++ = *sp; ! 322: putq(q, xbp); ! 323: if ((kdp->ostate&KMBUSY) == 0) ! 324: kmstart(kdp); ! 325: } ! 326: break; ! 327: ! 328: case DIOCRCTL: ! 329: *sp = kdp->lastctl; ! 330: kdp->lastctl = 0; ! 331: bp->wptr = (unsigned char *)sp + 1; ! 332: break; ! 333: ! 334: case DIOCNXCL: ! 335: kdp->ostate &= ~KMXCL; ! 336: bp->wptr = bp->rptr; ! 337: break; ! 338: ! 339: case TIOCGDEV: ! 340: ((struct ttydevb *)sp)->ispeed = ! 341: ((struct ttydevb *)sp)->ospeed = B9600; ! 342: break; ! 343: ! 344: case KIOCINIT: ! 345: kdixinit(kdp); ! 346: bp->rptr = bp->wptr; ! 347: break; ! 348: ! 349: case KIOCSHUT: ! 350: if (kdp->chan > 2) { /* hackish security attempt */ ! 351: bp->type = M_IOCNAK; ! 352: break; ! 353: } ! 354: kdireset(kdp->kno); ! 355: bp->rptr = bp->wptr; ! 356: break; ! 357: ! 358: case DIOCSTREAM: ! 359: RD(q)->flag &= ~QDELIM; ! 360: bp->rptr = bp->wptr; ! 361: break; ! 362: ! 363: case DIOCRECORD: ! 364: RD(q)->flag |= QDELIM; ! 365: bp->rptr = bp->wptr; ! 366: break; ! 367: ! 368: case DIOCXWIN: { ! 369: unsigned int wins; ! 370: /* KMC does big (756) or small (84) windows currently */ ! 371: wins = (sp[0] + (sp[1]<<8))*sp[4]; ! 372: kdp->ostate &= ~KMXBIG; ! 373: if (wins>=756) ! 374: kdp->ostate |= KMXBIG; ! 375: /* will take effect next XINIT */ ! 376: bp->rptr = bp->wptr; ! 377: break; ! 378: } ! 379: ! 380: default: ! 381: bp->wptr = bp->rptr; ! 382: bp->type = M_IOCNAK; ! 383: break; ! 384: } ! 385: qreply(q, bp); ! 386: return; ! 387: ! 388: case M_STOP: ! 389: s = OSPND; ! 390: kdp->ostate |= KMSTOP; ! 391: goto dontcmd; ! 392: ! 393: case M_FLUSH: ! 394: flushq(q, 0); ! 395: s = spl6(); ! 396: if (kdp->obp) { ! 397: freeb(kdp->obp); /* this cannot be right -- too early */ ! 398: kdp->obp = 0; ! 399: } ! 400: kdp->ostate &= ~(KMSTOP|KMBUSY); ! 401: splx(s); ! 402: s = OFLUSH|ORSME; ! 403: goto docmd; ! 404: ! 405: case M_START: ! 406: case M_HANGUP: ! 407: s = ORSME; ! 408: kdp->ostate &= ~KMSTOP; ! 409: goto dontcmd; ! 410: docmd: ! 411: kcmd(kdp->kno, KC_CMD, kdp->chan, 0, s, 0, (uaddr_t)NULL); ! 412: dontcmd: ! 413: kmstart(kdp); ! 414: break; ! 415: ! 416: default: /* not handled; just toss */ ! 417: break; ! 418: } ! 419: freeb(bp); ! 420: } ! 421: ! 422: /* ! 423: * restart URP on some channel: ! 424: * send XINIT to KMC; ! 425: * discard any pending transmit block ! 426: * ! 427: * should pending block really be discarded, or requeued? ! 428: * former seems to match real cases ! 429: */ ! 430: ! 431: kdixinit(kp) ! 432: register struct kdi *kp; ! 433: { ! 434: register int s; ! 435: ! 436: s = spl6(); ! 437: kcmd(kp->kno, KC_XINIT, kp->chan, 0, 0, (kp->ostate&KMXBIG)!=0, (uaddr_t)NULL); ! 438: if (kp->obp) { ! 439: freeb(kp->obp); ! 440: kp->obp = NULL; ! 441: } ! 442: if (kp->omap) { ! 443: ubmfree(kdikmc[kp->kno].ubno, kp->omap); ! 444: kp->omap = 0; ! 445: } ! 446: kp->ostate &=~ (KMSTOP|KMBUSY); ! 447: splx(s); ! 448: } ! 449: ! 450: kdiisrv(q) ! 451: register struct queue *q; ! 452: { ! 453: register struct kdi *kp = (struct kdi *)q->ptr; ! 454: register int ubno; ! 455: register struct block *bp; ! 456: ! 457: if ((q->next->flag&QFULL)==0 && kp->ibp==NULL) { ! 458: bp = allocb(kp->ostate&KMBIG? 1024:64); ! 459: if (bp == NULL) ! 460: panic("kdi: can't alloc"); ! 461: kp->ibp = bp; ! 462: ubno = kdikmc[kp->kno].ubno; ! 463: kp->imap = ubmblk(ubno, bp, 0); ! 464: kcmd(kp->kno, KC_RCVB, kp->chan, bp->lim - bp->wptr, ! 465: 50, CBLOCK|CTIME, ubadwptr(ubno, bp, kp->imap)); ! 466: } ! 467: } ! 468: ! 469: kmstart(kdp) ! 470: register struct kdi *kdp; ! 471: { ! 472: register s = spl5(); ! 473: register struct block *bp; ! 474: register struct queue *qp; ! 475: register c; ! 476: register struct kdikmc *xp; ! 477: ! 478: if (kdp->ostate&(KMBUSY|KMSTOP)) { ! 479: splx(s); ! 480: return; ! 481: } ! 482: if ((qp = kdp->dkrq)==NULL || (qp = WR(qp))==NULL) { ! 483: splx(s); ! 484: return; ! 485: } ! 486: xp = &kdikmc[kdp->kno]; ! 487: if (bp = getq(qp)) switch (bp->type) { ! 488: ! 489: case M_DATA: ! 490: c = OBOTM; ! 491: if (bp->class&S_DELIM) ! 492: c = 0; ! 493: kdp->omap = ubmblk(xp->ubno, bp, 0); ! 494: kcmd(kdp->kno, KC_SEND, kdp->chan, bp->wptr-bp->rptr, ! 495: 0, c, ubadrptr(xp->ubno, bp, kdp->omap)); ! 496: kdp->ostate |= KMBUSY; ! 497: dkstat.output += bp->wptr - bp->rptr; ! 498: kdp->obp = bp; ! 499: break; ! 500: ! 501: case M_DELAY: ! 502: c = D_DELAY; ! 503: while (*bp->rptr>0) { ! 504: c++; ! 505: *bp->rptr >>= 1; ! 506: } ! 507: kdp->omap = ubmblk(xp->ubno, bp, 0); ! 508: kcmd(kdp->kno, KC_SEND, kdp->chan, 1, c, 0, ubadrptr(xp->ubno, bp, kdp->omap)); ! 509: kdp->ostate |= KMBUSY; ! 510: kdp->obp = bp; ! 511: break; ! 512: ! 513: case M_CTL: ! 514: kdp->omap = ubmblk(xp->ubno, bp, 0); ! 515: kcmd(kdp->kno, KC_SEND, kdp->chan, 0, *bp->rptr, 0, ubadrptr(xp->ubno, bp, kdp->omap)); ! 516: kdp->ostate |= KMBUSY; ! 517: kdp->obp = bp; ! 518: break; ! 519: ! 520: case M_BREAK: ! 521: kdp->omap = ubmblk(xp->ubno, bp, 0); ! 522: kcmd(kdp->kno, KC_SEND, kdp->chan, 0, D_BREAK, 0, ubadrptr(xp->ubno, bp, kdp->omap)); ! 523: kdp->ostate |= KMBUSY; ! 524: kdp->obp = bp; ! 525: break; ! 526: ! 527: default: ! 528: printf("mesg %o in kdi\n", bp->type); ! 529: freeb(bp); ! 530: break; ! 531: } ! 532: splx(s); ! 533: } ! 534: ! 535: int kcmdovern[10]; ! 536: long kcmdovert[10]; ! 537: ! 538: kcmd(kno, type, chan, len, ctl, mode, addr) ! 539: uaddr_t addr; ! 540: { ! 541: register i; ! 542: register struct device *dp = kmc[kno].k_addr; ! 543: register struct kin *kp; ! 544: register s; ! 545: static struct kmaddr nulladr = {0, 0}; ! 546: static serno; ! 547: register long loop; ! 548: ! 549: /* ! 550: * if the kmc is dead, don't ask it to do things ! 551: */ ! 552: if(dp->sts ==3) ! 553: return; ! 554: ! 555: if (dp->u.q.x3) ! 556: dp->u.q.x3 = 0; ! 557: busywait: ! 558: /* ! 559: * wait at low priority till there's a free command. No ! 560: * sense slowing all processes down. ! 561: */ ! 562: if(((dp->u.q.ch+1)%NKMB)==dp->u.q.ct) { ! 563: loop = 0; ! 564: while (((dp->u.q.ch+1)%NKMB)==dp->u.q.ct) { ! 565: if (loop == 1000) ! 566: printf("waiting for kdi%d\n", kno); ! 567: if(loop++>1000000) { ! 568: printf("kmc%d died, restart\n", kno); ! 569: kdireset(kno); ! 570: return; ! 571: } ! 572: } ! 573: kcmdovern[kno]++; ! 574: if(kcmdovert[kno]<loop) ! 575: kcmdovert[kno] = loop; ! 576: } ! 577: s = spl5(); ! 578: /* ! 579: * someone else might have gotten in at low priority. check ! 580: * again. ! 581: */ ! 582: if(((dp->u.q.ch+1)%NKMB)==dp->u.q.ct) { ! 583: splx(s); ! 584: goto busywait; ! 585: } ! 586: i = dp->u.q.ch; ! 587: if (i >= NKMB) ! 588: panic("kcmd"); ! 589: kp = &k[kno].cmd[i]; ! 590: kp->type = type; ! 591: kp->serno = ++serno; ! 592: kp->chan = chan; ! 593: kp->len = len; ! 594: kp->ctl = ctl; ! 595: kp->mode = mode; ! 596: kp->addr.hi = addr>>16; ! 597: kp->addr.lo = addr; ! 598: i++; ! 599: if (i >= NKMB) ! 600: i = 0; ! 601: dp->u.q.ch = i; ! 602: TRACE(*kp); ! 603: splx(s); ! 604: } ! 605: ! 606: u_char kdiseqno[10]; ! 607: ! 608: /* ! 609: * Interrupt routine-- unload status buffer: ! 610: * release write blocks, collect input ! 611: */ ! 612: kdiintr(kno) ! 613: { ! 614: register struct device *dp = kmc[kno].k_addr; ! 615: register struct kin *sp; ! 616: register struct kdi *kp; ! 617: register struct block *bp; ! 618: register c; ! 619: register struct kdikmc *xp; ! 620: ! 621: xp = &kdikmc[kno]; ! 622: if (dp->u.q.x3) ! 623: dp->u.q.x3 = 0; ! 624: for ( ; (c = dp->u.q.st) != dp->u.q.sh; dp->u.q.st = c) { ! 625: if (c >= NKMB) { ! 626: printf("kdi stat buf is %d\n", c); ! 627: panic("kdiintr"); ! 628: } ! 629: sp = &k[kno].stat[c]; ! 630: TRACE(*sp); ! 631: c++; ! 632: if (c >= NKMB) ! 633: c = 0; ! 634: if (sp->chan >= KDICHAN) { ! 635: printf("kdi%d stat chan is 0%o\n", kno, sp->chan); ! 636: printf("type: %o len: 0%o mode: 0%o\n"); ! 637: continue; ! 638: } ! 639: if(sp->serno!=kdiseqno[kno]){ ! 640: printf("kdi%d stat chan is 0%o\n", kno, sp->chan); ! 641: printf("seqno is %d, should be %d\n",sp->serno, ! 642: kdiseqno[kno]); ! 643: } ! 644: kdiseqno[kno]=(sp->serno+1)%256; ! 645: kp = &xp->kdi[sp->chan]; ! 646: switch (sp->type) { ! 647: ! 648: case KS_SEND: ! 649: if (kp->obp) { ! 650: freeb(kp->obp); ! 651: kp->obp = NULL; ! 652: } ! 653: kp->ostate &= ~KMBUSY; ! 654: if (kp->omap) { ! 655: ubmfree(xp->ubno, kp->omap); ! 656: kp->omap = 0; ! 657: } ! 658: if (kp->dkrq && WR(kp->dkrq)->first) ! 659: kmstart(kp); ! 660: break; ! 661: ! 662: case KS_RDB: ! 663: if (kp->imap) { ! 664: ubmfree(xp->ubno, kp->imap); ! 665: kp->imap = 0; ! 666: } ! 667: bp = kp->ibp; ! 668: kp->ibp = NULL; ! 669: if (kp->dkrq==NULL || xp->state[kp->chan]!=DKOPEN) { ! 670: if (bp) ! 671: freeb(bp); ! 672: break; ! 673: } ! 674: if (sp->mode & SABORT) { ! 675: printf("kdi%d rcv abort chan %d mode %o bp %x\n", ! 676: kno, kp->chan, sp->mode, bp); ! 677: if (bp) ! 678: kp->ibp = bp; ! 679: kp->rsize = 0; ! 680: kp->ostate &= ~KMBIG; ! 681: break; ! 682: } ! 683: if (bp == NULL) { ! 684: printf("kdi%d: no ibp\n", kno); ! 685: break; ! 686: } ! 687: /* special hacks */ ! 688: if (sp->mode&020 ! 689: || sp->mode==0100 && bp->wptr+sp->len==bp->lim) { ! 690: /* ! 691: * Something no one understands. Print out ! 692: * some info so that we might figure out ! 693: * why this freeb is in the code. ! 694: */ ! 695: printf("kdi%d rcv chan %d mode %o bp %x len %d\n", ! 696: kno, kp->chan, sp->mode, bp, sp->len); ! 697: freeb(bp); ! 698: } else { ! 699: bp->wptr = bp->lim - sp->len; ! 700: kp->rsize += bp->wptr - bp->rptr; ! 701: dkstat.input += bp->wptr - bp->rptr; ! 702: if(sp->mode&(SBLOCK|STIME)) { ! 703: bp->class |= S_DELIM; ! 704: if (kp->rsize >= 512) ! 705: kp->ostate = BIGSET(kp->ostate); ! 706: else ! 707: kp->ostate = BIGCLR(kp->ostate); ! 708: kp->rsize = 0; ! 709: } ! 710: (*kp->dkrq->next->qinfo->putp) ! 711: (kp->dkrq->next, bp); ! 712: kp->ibp = NULL; ! 713: if (sp->mode&SCNTL) { ! 714: switch (sp->ctl) { ! 715: ! 716: case D_BREAK: ! 717: putctl(kp->dkrq->next, M_BREAK); ! 718: break; ! 719: ! 720: default: ! 721: kp->lastctl = sp->ctl; ! 722: putctl1(kp->dkrq->next, M_CTL, sp->ctl); ! 723: break; ! 724: ! 725: } ! 726: } ! 727: } ! 728: if ((kp->dkrq->next->flag&QFULL) == 0) { ! 729: bp = allocb(kp->ostate&KMBIG? 1024:64); ! 730: if (bp == NULL) ! 731: panic("kdi: can't alloc"); ! 732: kp->ibp = bp; ! 733: kp->imap = ubmblk(xp->ubno, bp, 0); ! 734: kcmd(kno, KC_RCVB, kp->chan, bp->lim - bp->wptr, ! 735: 50, CBLOCK|CTIME, ubadwptr(xp->ubno, bp, kp->imap)); ! 736: } ! 737: break; ! 738: ! 739: case KS_EOI: ! 740: printf("kdi%d chan %d rcv EOI %x\n", kno, sp->chan, sp->len); ! 741: break; ! 742: ! 743: case KS_CNTL: ! 744: /* ! 745: printf("kdi%d chan %d rcv ctl %x\n", kno, sp->chan, sp->len); ! 746: */ ! 747: break; ! 748: ! 749: case KS_ERR: ! 750: printf("kdi%d chan %d error %d\n", kno, sp->chan, sp->len); ! 751: if (sp->len==E_NOQB || sp->len==E_UMETA ! 752: || sp->len==E_DUP) { ! 753: printf("ignored\n"); ! 754: break; ! 755: } ! 756: kdireset(kno); ! 757: break; ! 758: ! 759: } ! 760: } ! 761: } ! 762: ! 763: /* ! 764: * init things, including data structures ! 765: * -- assume KDICHAN struct kdis and KDICHAN chars for state ! 766: * will fit in a buffer. when BSIZE is 4096, it's true. ! 767: */ ! 768: int kdireload(); ! 769: ! 770: kdiinit(dev) ! 771: int dev; ! 772: { ! 773: register struct device *kp; ! 774: register i; ! 775: register struct kdikmc *xp; ! 776: register int kno; ! 777: struct kmaddr ka; ! 778: extern time_t time; ! 779: ! 780: kno = KMC(minor(dev)); ! 781: /* close all open channels? */ ! 782: if ((kp = kmc[kno].k_addr) == NULL) ! 783: return (0); ! 784: xp = &kdikmc[kno]; ! 785: if (xp->badtime+30 > time) /* UGH */ ! 786: return(0); ! 787: kp->sts = 0; /* initialize KMC */ ! 788: if (xp->buf == NULL) { ! 789: if ((xp->buf = geteblk()) == NULL) ! 790: return (0); ! 791: clrbuf(xp->buf); ! 792: xp->kdi = (struct kdi *)xp->buf->b_un.b_addr; ! 793: xp->state = (char *)&xp->kdi[KDICHAN]; ! 794: for (i = 0; i < KDICHAN; i++) { ! 795: xp->kdi[i].chan = i; ! 796: xp->kdi[i].kno = kno; ! 797: } ! 798: } ! 799: if ((xp->modp = dkmodall(dev, kno*KDICHAN, (kno+1)*KDICHAN)) == 0) ! 800: return (0); ! 801: xp->modp->dkstate = xp->state; ! 802: xp->ubno = kmcaddr[kno].ubno; ! 803: if (xp->umap == 0) { ! 804: if ((xp->umap = ubmalloc(xp->ubno, sizeof(struct kmcdk), 0)) == 0) { ! 805: printf("kdi%d: no map\n", kno); ! 806: return (0); ! 807: } ! 808: } ! 809: xp->ubad = ubmaddr(xp->ubno, (caddr_t)&k[kno], sizeof(struct kmcdk), xp->umap); ! 810: k[kno].kinit.cmdaddr = kmcubaddr((caddr_t)k[kno].cmd, (caddr_t)&k[kno], xp->ubad); ! 811: k[kno].kinit.stataddr = kmcubaddr((caddr_t)k[kno].stat, (caddr_t)&k[kno], xp->ubad); ! 812: k[kno].kinit.bufaddr = kmcubaddr((caddr_t)k[kno].kmcbuf, (caddr_t)&k[kno], xp->ubad); ! 813: ka = kmcubaddr((caddr_t)&k[kno].kinit, (caddr_t)&k[kno], xp->ubad); ! 814: kp->u.a.lo = ka.lo; ! 815: kp->u.a.hi = ka.hi; ! 816: xp->badtime = time; ! 817: kp->sts = 1; /* start handshake */ ! 818: for (i = 0; i<100000; i++) { ! 819: if (kp->sts == 2) { ! 820: kmc[kno].k_rint = kdiintr; ! 821: kmc[kno].k_xint = kdiintr; ! 822: kmc[kno].k_reset = kdireload; ! 823: xp->init = 1; ! 824: return(1); /* KMC is running OK */ ! 825: } ! 826: if (kp->sts == 3) { ! 827: printf("kdi%d: entered state 3\n", kno); ! 828: return(0); ! 829: } ! 830: } ! 831: printf("kdi%d: kmc not ready\n", kno); ! 832: return(0); ! 833: } ! 834: ! 835: struct kmaddr ! 836: kmcubaddr(memaddr, membase, ubbase) ! 837: caddr_t memaddr, membase; ! 838: uaddr_t ubbase; ! 839: { ! 840: register struct kmaddr r; ! 841: register long a; ! 842: ! 843: a = (long)memaddr - (long)membase + (long)ubbase; ! 844: r.hi = a >> 16; ! 845: r.lo = (u_short)a; ! 846: return(r); ! 847: } ! 848: ! 849: /* ! 850: * kmc reload ! 851: */ ! 852: kdireload(kno) ! 853: { ! 854: register struct kdikmc *xp; ! 855: ! 856: xp = &kdikmc[kno]; ! 857: xp->init = 0; ! 858: xp->modp = 0; ! 859: xp->bad = 0; ! 860: } ! 861: ! 862: /* ! 863: * zap all open channels ! 864: */ ! 865: kdireset(kno) ! 866: { ! 867: register struct kdi *kp; ! 868: register struct kdikmc *xp; ! 869: register struct device *dp; ! 870: ! 871: xp = &kdikmc[kno]; ! 872: if (xp->modp==0) ! 873: return; ! 874: if ((dp = kmc[kno].k_addr) != NULL) ! 875: dp->sts = 3; /* disable kdi kmc code */ ! 876: for (kp = &xp->kdi[KDICHAN-1]; kp >= xp->kdi; --kp) { ! 877: register state = xp->state[kp->chan]; ! 878: if ((state==DKOPEN || state==DKLCLOSE) && kp->dkrq) { ! 879: flushq(WR(kp->dkrq), 1); ! 880: xp->state[kp->chan] = state==DKOPEN? DKRCLOSE: DKCLOSED; ! 881: putctl(kp->dkrq->next, M_HANGUP); ! 882: } ! 883: if (kp->imap) ! 884: ubmfree(xp->ubno, kp->imap); ! 885: if (kp->omap) ! 886: ubmfree(xp->ubno, kp->omap); ! 887: kp->imap = kp->omap = 0; ! 888: } ! 889: xp->bad = 1; ! 890: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.