![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to sn.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 ! root 1: #define BSD41 ! 2: #define VAXONE ! 3: #define TIMEOUT ! 4: ! 5: #ifdef MARVIN ! 6: #define TXDRIVER ! 7: #endif ! 8: #ifdef CANTOR ! 9: #define TXDRIVER ! 10: #endif ! 11: #ifdef HILBERT ! 12: #define TXDRIVER ! 13: #endif ! 14: #ifdef DAISY ! 15: #define TXDRIVER ! 16: #endif ! 17: ! 18: #ifdef USG5 ! 19: #define NSN 1 ! 20: #else ! 21: #include "sn.h" ! 22: #endif ! 23: #if NSN > 0 ! 24: ! 25: #ifdef BSD41 ! 26: #include "../h/param.h" ! 27: #include "../h/systm.h" ! 28: #include "../h/buf.h" ! 29: #include "../h/conf.h" ! 30: #include "../h/dir.h" ! 31: #include "../h/user.h" ! 32: #include "../h/pte.h" ! 33: #include "../h/map.h" ! 34: #include "../h/vm.h" ! 35: #include "../h/dk.h" ! 36: #include "../h/cmap.h" ! 37: #include "../h/ubareg.h" ! 38: #include "../h/ubavar.h" ! 39: #include "../h/cpu.h" ! 40: #include "../h/proc.h" ! 41: #include "../h/snet.h" ! 42: #include "../h/packet.h" ! 43: #include "../h/channel.h" ! 44: #include "../h/status.h" ! 45: #endif ! 46: ! 47: #ifdef SNDEBUG ! 48: int sndebug = 1; ! 49: #else ! 50: int sndebug = 0; ! 51: #endif ! 52: ! 53: /* flags for status */ ! 54: #define INPUT 1 ! 55: #define OUTPUT 2 ! 56: ! 57: #define min(x,y) ((x) < (y) ? (x) : (y)) ! 58: #define swab(x) (unsigned short)((((x)>>8)&0xff) | ((x) << 8)) ! 59: ! 60: #define SNPRI 28 ! 61: ! 62: #define CHKINIT 0xbf37 ! 63: ! 64: struct device { ! 65: short drcs; ! 66: short drout; ! 67: short drin; ! 68: }; ! 69: ! 70: /* Command and Status word */ ! 71: #define CSR0 0x1 ! 72: #define CSR1 0x2 ! 73: #define RIE 0x20 ! 74: #define TIE 0x40 ! 75: #define TEMPTY 0x80 ! 76: #define RFULL 0x8000 ! 77: ! 78: /* ! 79: * CSR1 CSR0 ! 80: * 0 0 Write Data ! 81: * 0 1 Write EOP ! 82: * 1 0 Write Command ! 83: * 1 1 Read Status ! 84: */ ! 85: #define DATA_MODE (RIE) ! 86: #define EOP_MODE (CSR0 | RIE) ! 87: #define CMD_MODE (CSR1 | RIE) ! 88: #define STATUS_MODE (CSR0 | CSR1 | RIE) ! 89: ! 90: /* Command word format ! 91: * ! 92: * +-----------------------------------------------+ ! 93: * | |B |R |A | | | | ! 94: * | |C |S |B | DID | | FCN | ! 95: * | |T |T |T | | | | ! 96: * +-----------------------------------------------+ ! 97: * 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ! 98: */ ! 99: /* Function codes */ ! 100: #define NOP 0x0 ! 101: #define BOARD_RESET 0x5 ! 102: #define MASTER_CLEAR 0x6 ! 103: ! 104: #define ABORT(did) (0x1000 | (did)) ! 105: #define RESET(did) (0x2000 | (did)) ! 106: #define BROAD_CAST(did) (0x4000 | (did)) ! 107: ! 108: ! 109: /* SNET status word bits ! 110: * ! 111: * +-----------------------------------------------+ ! 112: * | |E |S |I |O | | | ! 113: * | |O |N |B |B | | | ! 114: * | |P |K |E |E | | | ! 115: * +-----------------------------------------------+ ! 116: * 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ! 117: */ ! 118: #define OUTBUF_E 0x4 ! 119: #define INBUF_E 0x8 ! 120: #define SNACK 0x10 /* transmitter error */ ! 121: #define EOP 0x20 /* we have read and EOP frame */ ! 122: ! 123: static int sn_multiplex; ! 124: ! 125: struct openwait sn_openwait[NUMDEV]; ! 126: struct openwait *sn_owhead, *sn_owtail; ! 127: ! 128: #define SNFILE(dev) (minor(dev) & 0x3f) ! 129: #define SNUNIT(dev) ((minor(dev) & 0xc0) >> 6) ! 130: ! 131: struct chdat sn_chans[NUMLCH]; ! 132: #define MAXMSGLEN (512+8) ! 133: struct sn_buffers { ! 134: short inbuf[MAXMSGLEN]; ! 135: short outbuf[MAXMSGLEN]; ! 136: } sn_buffers[NUMLCH]; ! 137: ! 138: #define NOPDID -1 ! 139: ! 140: #ifdef TIMEOUT ! 141: #define CKFUZZ 4 /* number of timeouts we wait for a response */ ! 142: #ifdef USG5 ! 143: #define CKTICKS (HZ/4) /* number of ticks per timeout */ ! 144: #else ! 145: #define CKTICKS (hz/4) /* number of ticks per timeout */ ! 146: #endif ! 147: ! 148: int sn_state; ! 149: #define OPEN 1 /* set if at least one sn? is open */ ! 150: #define TIMER 2 /* set if at timer is running */ ! 151: ! 152: int cktimchk(); ! 153: int sn_opncnt; ! 154: #endif TIMEOUT ! 155: ! 156: struct snmach snmach[NUMDEV] = { ! 157: { 1, 255 }, ! 158: { 2, 254 }, ! 159: { 3, 253 }, ! 160: { 4, 252 }, ! 161: { 5, 251 }, ! 162: { 6, 250 }, ! 163: { 7, 249 }, ! 164: { 8, 248 } }; ! 165: ! 166: int sn_once; ! 167: ! 168: #ifdef BSD42 ! 169: #define RETURN(x) {return(x);} ! 170: #define ARGS(x) args->x ! 171: #else ! 172: #define RETURN(x) {u.u_error = x; return;} ! 173: #define ARGS(x) args.x ! 174: #endif ! 175: ! 176: #ifdef USG5 ! 177: extern struct sninfo sn_sninfo[]; ! 178: extern int sn_cnt; ! 179: extern struct device *sn_addr[]; ! 180: #else ! 181: struct sninfo sn_sninfo[NSN]; ! 182: int snprobe(), snattach(); ! 183: struct uba_device *sndinfo[NSN]; ! 184: u_short snstd[] = {0}; ! 185: struct uba_driver sndriver = ! 186: { snprobe, 0, snattach, 0, snstd, "sn", sndinfo}; ! 187: ! 188: snprobe(reg) ! 189: caddr_t reg; ! 190: { ! 191: register int br, cvec; /* value result */ ! 192: register struct device *snaddr = (struct device *)reg; ! 193: ! 194: br = 0x15; ! 195: #ifdef VAXONE ! 196: cvec = 0510; ! 197: #else ! 198: #ifdef CANTOR ! 199: if (((int)snaddr & 017777) == 007770) ! 200: cvec = 0504; ! 201: if (((int)snaddr & 017777) == 007750) ! 202: cvec = 0464; ! 203: #else ! 204: cvec = 0504; ! 205: #endif ! 206: #endif ! 207: #ifdef BSD41 ! 208: return(1); ! 209: #endif ! 210: #ifdef BSD42 ! 211: return(sizeof(struct device)); ! 212: #endif ! 213: } ! 214: ! 215: /*ARGSUSED*/ ! 216: snattach(ui) ! 217: register struct uba_device *ui; ! 218: { ! 219: } ! 220: #endif ! 221: ! 222: snopen(dev, rw) ! 223: dev_t dev; ! 224: int rw; ! 225: { ! 226: register struct device *draddr; ! 227: #ifndef USG5 ! 228: struct uba_device *ui; ! 229: #endif ! 230: register struct sninfo *sninfop; ! 231: int mdev = SNFILE(dev); ! 232: int unit = SNUNIT(dev); ! 233: ! 234: if( sndebug ) ! 235: printf("snopen(%x,%x)\n", dev, rw); ! 236: ! 237: #ifdef USG5 ! 238: if ( mdev > NUMDEV || unit >= sn_cnt) { ! 239: RETURN ( ENXIO ); ! 240: } ! 241: draddr = sn_addr[unit]; ! 242: #else ! 243: if (mdev > NUMDEV || unit >= NSN || ! 244: (ui = sndinfo[unit]) == 0 || ui->ui_alive == 0) { ! 245: RETURN ( ENXIO ); ! 246: } ! 247: draddr = (struct device *)ui->ui_addr; ! 248: #endif ! 249: ! 250: if ( sn_once == 0 ) { ! 251: struct chdat *cp = sn_chans; ! 252: ! 253: sn_once++; ! 254: for( ; cp<&sn_chans[NUMLCH]; cp++) { ! 255: cp->lchnum = -1; ! 256: cp->dlchnum = -1; ! 257: } ! 258: sn_owhead = sn_owtail = sn_openwait; ! 259: } ! 260: ! 261: sninfop = &sn_sninfo[unit]; ! 262: spl6(); ! 263: if (sninfop->sndevlock[mdev]++ != 0) { ! 264: spl0(); ! 265: RETURN ( EBUSY ); ! 266: } ! 267: #ifdef TIMEOUT ! 268: sn_opncnt++; ! 269: sn_state |= OPEN; ! 270: if ((sn_state & TIMER) == 0) { ! 271: sn_state |= TIMER; ! 272: timeout(cktimchk, (caddr_t)0, CKTICKS); ! 273: } ! 274: #endif TIMEOUT ! 275: if( sninfop->snlock++ == 0 ) { ! 276: #ifdef TXDRIVER ! 277: { ! 278: extern struct txinfo tx_sninfo[]; ! 279: ! 280: if (tx_sninfo[unit].snlock != 0) { ! 281: spl0(); ! 282: return; ! 283: } ! 284: } ! 285: #endif ! 286: draddr->drcs = CMD_MODE; ! 287: draddr->drout = 0; ! 288: draddr->drout = BOARD_RESET; ! 289: draddr->drout = 0; ! 290: draddr->drcs = DATA_MODE; ! 291: } ! 292: ! 293: spl0(); ! 294: return(0); ! 295: } ! 296: ! 297: snclose(dev) ! 298: { ! 299: register struct chdat *cp; ! 300: #ifndef USG5 ! 301: struct uba_device *ui; ! 302: #endif ! 303: register struct sninfo *sninfop; ! 304: register struct device *draddr; ! 305: int mdev = SNFILE(dev); ! 306: int unit = SNUNIT(dev); ! 307: int resetmachno; ! 308: struct openwait *curtail; ! 309: ! 310: if( sndebug ) ! 311: printf("snclose(%x)\n", dev); ! 312: #ifdef USG5 ! 313: if ( unit >= sn_cnt) { ! 314: RETURN ( ENXIO ); ! 315: } ! 316: draddr = sn_addr[unit]; ! 317: #else ! 318: if ( unit >= NSN) { ! 319: RETURN ( ENXIO ); ! 320: } ! 321: ui = sndinfo[unit]; ! 322: draddr = (struct device *)ui->ui_addr; ! 323: #endif ! 324: ! 325: sninfop = &sn_sninfo[unit]; ! 326: spl6(); ! 327: if( sninfop->snlock == 0 || mdev > NUMDEV ! 328: || sninfop->sndevlock[mdev] == 0 ) { ! 329: spl0(); ! 330: RETURN ( ENXIO ); ! 331: } ! 332: ! 333: resetmachno = -1; ! 334: for(cp=sninfop->snlink[mdev]; cp; cp=cp->link) { ! 335: if (cp->pdid == NOPDID) ! 336: resetmachno = cp->machno; ! 337: chclose(cp); ! 338: } ! 339: if (resetmachno != -1) { ! 340: for(cp=sn_chans; cp < &sn_chans[NUMLCH]; cp++) { ! 341: if (cp->pdid == NOPDID && cp->machno == resetmachno) ! 342: goto noreset; ! 343: } ! 344: draddr->drcs = CMD_MODE; ! 345: draddr->drout = RESET(resetmachno << 8); ! 346: draddr->drcs = EOP_MODE; ! 347: draddr->drout = 0; ! 348: draddr->drcs = DATA_MODE; ! 349: } ! 350: ! 351: noreset: ! 352: for (curtail = sn_owtail; curtail != sn_owhead; ! 353: curtail = ownext(curtail)) { ! 354: if (curtail->pid == u.u_procp->p_pid) { ! 355: curtail->pid = 0; ! 356: goto nowakeup; ! 357: } ! 358: } ! 359: while (sn_owtail != sn_owhead) { ! 360: curtail = sn_owtail; ! 361: sn_owtail = ownext(sn_owtail); ! 362: if (curtail->pid) { ! 363: wakeup(curtail); ! 364: break; ! 365: } ! 366: } ! 367: ! 368: nowakeup: ! 369: sninfop->snlink[mdev] = 0; ! 370: sninfop->sndevlock[mdev] = 0; ! 371: #ifdef TIMEOUT ! 372: if (--sn_opncnt <= 0) { ! 373: sn_state &= ~OPEN; ! 374: sn_opncnt = 0; ! 375: } ! 376: #endif TIMEOUT ! 377: if (--sninfop->snlock == 0 ) { ! 378: #ifdef TXDRIVER ! 379: { ! 380: if (tx_sninfo[unit].snlock != 0) ! 381: return; ! 382: } ! 383: #endif ! 384: draddr->drcs &= ~RIE; ! 385: } ! 386: spl0(); ! 387: return(0); ! 388: } ! 389: ! 390: static short ratshole[MAXMSGLEN]; ! 391: static struct chdat ratschan; ! 392: ! 393: #ifdef USG5 ! 394: snintr(unit) ! 395: #else ! 396: snrint(unit) ! 397: #endif ! 398: int unit; ! 399: { ! 400: register struct chdat *cp; ! 401: register short *sp, *dp; ! 402: register int i; ! 403: register struct sninfo *sninfop; ! 404: register struct device *draddr; ! 405: unsigned short chksum, xchk; ! 406: short len; ! 407: unsigned short chan; ! 408: short *osp; ! 409: #ifndef USG5 ! 410: struct uba_device *ui; ! 411: #endif ! 412: ! 413: #ifdef USG5 ! 414: draddr = sn_addr[unit]; ! 415: #else ! 416: ui = sndinfo[unit]; ! 417: draddr = (struct device *)ui->ui_addr; ! 418: #endif ! 419: dp = &draddr->drin; ! 420: ! 421: sninfop = &sn_sninfo[unit]; ! 422: sninfop->snrcnt++; ! 423: ! 424: loop: ! 425: chksum = CHKINIT; ! 426: ! 427: chan = *dp; ! 428: #ifdef TXDRIVER ! 429: /* unusual process numbers go to tx driver */ ! 430: if ((chan & 0xff) <= 200 || ((unsigned int)chan) >= 0x2000 ) { ! 431: txintrmt(unit, chan); ! 432: goto getstatus; ! 433: } ! 434: #endif ! 435: chksum ^= chan; ! 436: chan = swab(chan); ! 437: len = *dp; ! 438: chksum ^= len; ! 439: len = swab(len); ! 440: if( len > MAXMSGLEN ) { ! 441: sninfop->snnbadlen++; ! 442: goto getstatus; ! 443: } ! 444: sninfop->sninbytes += len+4; ! 445: ! 446: for(cp=sn_chans; cp < &sn_chans[NUMLCH]; cp++) ! 447: if( cp->xchan == chan && cp->snunit == unit ) { ! 448: if( cp->input.done == 0 && len <= cp->input.len ) ! 449: osp = sp = cp->input.buf; ! 450: else ! 451: osp = sp = ratshole; ! 452: goto found; ! 453: } ! 454: osp = sp = ratshole; ! 455: cp = &ratschan; ! 456: sninfop->snnnolc++; ! 457: found: ! 458: ! 459: for(i=len; i>0; i-=8) { ! 460: switch( i ) { ! 461: default: ! 462: *sp = *dp; ! 463: chksum ^= *sp++; ! 464: case 7: ! 465: *sp = *dp; ! 466: chksum ^= *sp++; ! 467: case 6: ! 468: *sp = *dp; ! 469: chksum ^= *sp++; ! 470: case 5: ! 471: *sp = *dp; ! 472: chksum ^= *sp++; ! 473: case 4: ! 474: *sp = *dp; ! 475: chksum ^= *sp++; ! 476: case 3: ! 477: *sp = *dp; ! 478: chksum ^= *sp++; ! 479: case 2: ! 480: *sp = *dp; ! 481: chksum ^= *sp++; ! 482: case 1: ! 483: *sp = *dp; ! 484: chksum ^= *sp++; ! 485: } ! 486: } ! 487: if( (i = ((len < 0 ? 0 : len) + 3)&0xf) != 0 ) { ! 488: for(i^=0xf; i-->=0; ) ! 489: chksum ^= *dp; ! 490: } ! 491: if( chksum != (xchk = *dp) ) { ! 492: sninfop->snnchksum++; ! 493: if( sndebug ) { ! 494: short *usp = osp; ! 495: int x = len; ! 496: ! 497: printf("snchksum (%x, %x):", chan, len); ! 498: for(; --x>=0; ) ! 499: printf(" %x", *usp++); ! 500: printf(" %x (%x)\n", xchk, chksum); ! 501: } ! 502: } else if( len > 0 ) { ! 503: if( osp == ratshole ) { ! 504: cp->flags |= SENTRNR; ! 505: snxstart(unit, cp, RNR); ! 506: sninfop->snsrnr++; ! 507: } else { ! 508: sninfop->snndata++; ! 509: cp->input.done = 1; ! 510: cp->input.len = len; ! 511: snxstart(unit, cp, ACK); ! 512: sninfop->snsack++; ! 513: wakeup((caddr_t)cp->input.buf); ! 514: if( cp->flags&MULTIPLEX ) ! 515: wakeup((caddr_t)&sn_multiplex); ! 516: } ! 517: } else { ! 518: switch( len ) { ! 519: case ACK: ! 520: sninfop->snnack++; ! 521: cp->flags &= ~SENTDATA; ! 522: cp->output.done = 1; ! 523: wakeup((caddr_t)cp->output.buf); ! 524: break; ! 525: ! 526: case RDY: ! 527: sninfop->snnrdy++; ! 528: snxstart(unit, cp, RACK); ! 529: if( cp->output.done == 0 && cp->output.len > 0 ) { ! 530: snxstart(unit, cp, DATA); ! 531: sninfop->snrout++; ! 532: } ! 533: break; ! 534: ! 535: case RNR: ! 536: sninfop->snnrnr++; ! 537: cp->flags &= ~SENTDATA; ! 538: break; ! 539: ! 540: case RACK: ! 541: sninfop->snnrack++; ! 542: cp->flags &= ~SENTRDY; ! 543: break; ! 544: ! 545: default: ! 546: printf("snrint: unit %d, bad type %d\n", unit, len); ! 547: break; ! 548: } ! 549: } ! 550: ! 551: getstatus: ! 552: draddr->drcs = STATUS_MODE; ! 553: i = *dp; ! 554: draddr->drcs = DATA_MODE; ! 555: if ((i&INBUF_E) == 0) { ! 556: sninfop->sninloop++; ! 557: goto loop; ! 558: } ! 559: } ! 560: ! 561: snxstart(unit, cp, type) ! 562: int unit; ! 563: register struct chdat *cp; ! 564: int type; ! 565: { ! 566: register short *sp, *dp; ! 567: register struct sninfo *sninfop; ! 568: register struct device *draddr; ! 569: register int i; ! 570: unsigned short chksum; ! 571: #ifndef USG5 ! 572: struct uba_device *ui; ! 573: #endif ! 574: int len, numretry; ! 575: ! 576: #ifdef USG5 ! 577: draddr = sn_addr[unit]; ! 578: #else ! 579: ui = sndinfo[unit]; ! 580: draddr = (struct device *)ui->ui_addr; ! 581: #endif ! 582: dp = &draddr->drout; ! 583: ! 584: sninfop = &sn_sninfo[unit]; ! 585: ! 586: if( type == DATA ) { ! 587: len = cp->output.len; ! 588: sninfop->snoutbytes += len+4; ! 589: } else { ! 590: len = type; ! 591: sninfop->snoutbytes += 4; ! 592: } ! 593: draddr->drcs = STATUS_MODE; ! 594: ! 595: i = draddr->drin; ! 596: if ( (i&OUTBUF_E) == 0 ) { ! 597: sninfop->snoutfull++; ! 598: do { ! 599: i = draddr->drin; ! 600: sninfop->sncntoutfull++; ! 601: } while( (i&OUTBUF_E) == 0 ); ! 602: } ! 603: ! 604: numretry = 0; ! 605: sninfop->snxcnt++; ! 606: retry: ! 607: sp = cp->output.buf; ! 608: chksum = CHKINIT; ! 609: if (cp->pdid == NOPDID) { ! 610: draddr->drcs = CMD_MODE; ! 611: *dp = cp->machno<<8; ! 612: draddr->drcs = DATA_MODE; ! 613: *dp = i = swab(cp->dlchnum); ! 614: } else { ! 615: draddr->drcs = CMD_MODE; ! 616: *dp = cp->pdid<<8; ! 617: draddr->drcs = DATA_MODE; ! 618: *dp = i = (cp->dlchnum<<8) | cp->machno; ! 619: } ! 620: chksum ^= (unsigned short)i; ! 621: *dp = i = swab(len); ! 622: chksum ^= (unsigned short)i; ! 623: for( i=len; i>0; i-=8 ) { ! 624: switch( i ) { ! 625: default: ! 626: chksum ^= *sp; ! 627: *dp = *sp++; ! 628: case 7: ! 629: chksum ^= *sp; ! 630: *dp = *sp++; ! 631: case 6: ! 632: chksum ^= *sp; ! 633: *dp = *sp++; ! 634: case 5: ! 635: chksum ^= *sp; ! 636: *dp = *sp++; ! 637: case 4: ! 638: chksum ^= *sp; ! 639: *dp = *sp++; ! 640: case 3: ! 641: chksum ^= *sp; ! 642: *dp = *sp++; ! 643: case 2: ! 644: chksum ^= *sp; ! 645: *dp = *sp++; ! 646: case 1: ! 647: chksum ^= *sp; ! 648: *dp = *sp++; ! 649: } ! 650: } ! 651: if( (i = ((len < 0 ? 0 : len) + 3)&0xf) != 0 ) { ! 652: for(i^=0xf; i-->=0; ) ! 653: *dp = 0; ! 654: } ! 655: draddr->drcs = EOP_MODE; ! 656: *dp = chksum; ! 657: draddr->drcs = STATUS_MODE; ! 658: i = draddr->drin; ! 659: draddr->drcs = DATA_MODE; ! 660: if( i&SNACK ) { ! 661: sninfop->snsnack++; ! 662: if( ++numretry < 100 ) ! 663: goto retry; ! 664: sninfop->snlost++; ! 665: } ! 666: cp->ckticks = CKFUZZ; ! 667: if( type == DATA ) { ! 668: cp->flags |= SENTDATA; ! 669: } ! 670: } ! 671: ! 672: snioctl(dev, cmd, addr, flag) ! 673: caddr_t addr; ! 674: dev_t dev; ! 675: { ! 676: register struct chdat *cp; ! 677: register struct reqinfo *rp; ! 678: register struct sninfo *sninfop; ! 679: register struct bufinfo *bp; ! 680: register struct chdat *dp; ! 681: struct status status; ! 682: int i; ! 683: struct status *ustatus; ! 684: char *usaddr; ! 685: int ulen; ! 686: int error; ! 687: int mdev = SNFILE(dev); ! 688: int unit = SNUNIT(dev); ! 689: ! 690: #ifdef USG5 ! 691: if ( unit >= sn_cnt) { ! 692: RETURN ( ENXIO ); ! 693: } ! 694: #else ! 695: if ( unit >= NSN) { ! 696: RETURN ( ENXIO ); ! 697: } ! 698: #endif ! 699: sninfop = &sn_sninfo[unit]; ! 700: ! 701: switch( cmd ) { ! 702: case NIOOPEN: { ! 703: #ifdef BSD42 ! 704: struct oargs *args = (struct oargs *)addr; ! 705: #else ! 706: struct oargs args; ! 707: ! 708: if (copyin(addr, (caddr_t)&args, sizeof(args))) { ! 709: RETURN ( EFAULT ); ! 710: } ! 711: #endif ! 712: spl6(); ! 713: for(cp=sn_chans; cp<&sn_chans[NUMLCH]; cp++) ! 714: if( cp->lchnum == -1 && cp->dlchnum == -1 ) ! 715: break; ! 716: if( cp >= &sn_chans[NUMLCH] ) { ! 717: spl0(); ! 718: RETURN( ENFILE ); ! 719: } ! 720: for(dp=sn_chans; dp<&sn_chans[NUMLCH]; dp++) ! 721: if( dp->lchnum != -1 && dp->lmachno == ARGS(lmachno) ! 722: && dp->lchnum == ARGS(lchno) ! 723: && dp->snunit == unit ) { ! 724: spl0(); ! 725: RETURN( EEXIST ); ! 726: } ! 727: cp->lchnum = ARGS(lchno); ! 728: cp->dlchnum = ARGS(dlchno); ! 729: spl0(); ! 730: cp->lmachno = ARGS(lmachno); ! 731: cp->machno = ARGS(dmachno); ! 732: cp->xchan = (cp->lmachno<<8)|cp->lchnum; ! 733: cp->snunit = unit; ! 734: cp->pdid = NOPDID; ! 735: bp = &cp->input; ! 736: i = cp-sn_chans; ! 737: bp->buf = sn_buffers[i].inbuf; ! 738: bp->len = MAXMSGLEN; ! 739: bp->done = 0; ! 740: bp = &cp->output; ! 741: bp->buf = sn_buffers[i].outbuf; ! 742: bp->len = bp->done = 0; ! 743: cp->flags = 0; ! 744: cp->link = sninfop->snlink[mdev]; ! 745: sninfop->snlink[mdev] = cp; ! 746: return(0); ! 747: } ! 748: ! 749: case NIOXOPEN: { ! 750: struct snmach *snmachp; ! 751: struct openwait *nexthead, *thishead; ! 752: #ifdef BSD42 ! 753: struct oargs *args = (struct oargs *)addr; ! 754: #else ! 755: struct oargs args; ! 756: ! 757: if (copyin(addr, (caddr_t)&args, sizeof(args))) { ! 758: RETURN ( EFAULT ); ! 759: } ! 760: #endif ! 761: for (;;) { ! 762: for (snmachp = &snmach[0]; ! 763: snmachp < &snmach[NUMDEV] && ! 764: snmachp->machno; ! 765: snmachp++) { ! 766: spl6(); ! 767: for (cp=sn_chans; cp<&sn_chans[NUMLCH]; cp++) ! 768: if( cp->lchnum == -1 && ! 769: cp->dlchnum == -1 ) ! 770: break; ! 771: if( cp >= &sn_chans[NUMLCH] ) { ! 772: goto xopensleep; ! 773: } ! 774: for(dp=sn_chans; dp<&sn_chans[NUMLCH]; dp++) { ! 775: if( dp->lchnum != -1 ! 776: && dp->lmachno == snmachp->lmachno ! 777: && dp->lchnum == ARGS(lchno) ! 778: && dp->snunit == unit ) { ! 779: /* Channel already in use */ ! 780: break; ! 781: } ! 782: } ! 783: if( dp >= &sn_chans[NUMLCH] ) ! 784: goto okmachp; ! 785: spl0(); ! 786: } ! 787: xopensleep: ! 788: nexthead = ownext(sn_owhead); ! 789: if (nexthead == sn_owtail) { ! 790: RETURN ( ENXIO ); ! 791: } ! 792: thishead = sn_owhead; ! 793: thishead->pid = u.u_procp->p_pid; ! 794: sn_owhead = nexthead; ! 795: sleep((caddr_t)thishead, SNPRI); ! 796: } ! 797: okmachp: ! 798: cp->lchnum = ARGS(lchno); ! 799: cp->lmachno = snmachp->lmachno; ! 800: spl0(); ! 801: cp->dlchnum = ARGS(dlchno); ! 802: cp->machno = snmachp->machno; ! 803: cp->xchan = (cp->lmachno<<8)|cp->lchnum; ! 804: cp->snunit = unit; ! 805: cp->pdid = NOPDID; ! 806: bp = &cp->input; ! 807: i = cp-sn_chans; ! 808: bp->buf = sn_buffers[i].inbuf; ! 809: bp->len = MAXMSGLEN; ! 810: bp->done = 0; ! 811: bp = &cp->output; ! 812: bp->buf = sn_buffers[i].outbuf; ! 813: bp->len = bp->done = 0; ! 814: cp->flags = 0; ! 815: cp->link = sninfop->snlink[mdev]; ! 816: sninfop->snlink[mdev] = cp; ! 817: ! 818: ARGS(lmachno) = snmachp->lmachno; ! 819: ARGS(dmachno) = snmachp->machno; ! 820: #ifndef BSD42 ! 821: if (copyout((caddr_t)&args, addr, sizeof(args))) { ! 822: RETURN ( EFAULT ); ! 823: } ! 824: #endif ! 825: return(0); ! 826: } ! 827: ! 828: case NIOPOPEN: { ! 829: #ifdef BSD42 ! 830: struct voargs *args = (struct voargs *)addr; ! 831: #else ! 832: struct voargs args; ! 833: ! 834: if (copyin(addr, (caddr_t)&args, sizeof(args))) { ! 835: RETURN ( EFAULT ); ! 836: } ! 837: #endif ! 838: spl6(); ! 839: for(cp=sn_chans; cp<&sn_chans[NUMLCH]; cp++) ! 840: if( cp->lchnum == -1 && cp->dlchnum == -1 ) ! 841: break; ! 842: if( cp >= &sn_chans[NUMLCH] ) { ! 843: spl0(); ! 844: RETURN( ENFILE ); ! 845: } ! 846: for(dp=sn_chans; dp<&sn_chans[NUMLCH]; dp++) ! 847: if( dp->lchnum != -1 && dp->lmachno == ARGS(lmachno) ! 848: && dp->lchnum == ARGS(lchno) ! 849: && dp->snunit == unit ) { ! 850: spl0(); ! 851: RETURN( EEXIST ); ! 852: } ! 853: cp->lchnum = ARGS(lchno); ! 854: cp->lmachno = ARGS(lmachno); ! 855: spl0(); ! 856: cp->dlchnum = ARGS(dlchno); ! 857: cp->machno = ARGS(dmachno); ! 858: cp->xchan = (cp->lmachno<<8)|cp->lchnum; ! 859: cp->snunit = unit; ! 860: cp->pdid = ARGS(pdid); ! 861: bp = &cp->input; ! 862: i = cp-sn_chans; ! 863: bp->buf = sn_buffers[i].inbuf; ! 864: bp->len = MAXMSGLEN; ! 865: bp->done = 0; ! 866: bp = &cp->output; ! 867: bp->buf = sn_buffers[i].outbuf; ! 868: bp->len = bp->done = 0; ! 869: cp->flags = 0; ! 870: cp->link = sninfop->snlink[mdev]; ! 871: sninfop->snlink[mdev] = cp; ! 872: return(0); ! 873: } ! 874: ! 875: case NIOCLOSE: { ! 876: #ifdef BSD42 ! 877: struct cargs *args = (struct cargs *)addr; ! 878: #else ! 879: struct cargs args; ! 880: ! 881: if (copyin(addr, (caddr_t)&args, sizeof(args))) { ! 882: RETURN ( EFAULT ); ! 883: } ! 884: #endif ! 885: for(cp=sninfop->snlink[mdev], dp=0; cp; dp=cp, cp=cp->link) ! 886: if( cp->lmachno == ARGS(lmachno) ! 887: && cp->lchnum == ARGS(lchno) ) { ! 888: /* TIMING !!! */ ! 889: if( dp ) ! 890: dp->link = cp->link; ! 891: else ! 892: sninfop->snlink[mdev] = cp->link; ! 893: chclose(cp); ! 894: return(0); ! 895: } ! 896: RETURN( EBADF ); ! 897: } ! 898: ! 899: case NIOGET: ! 900: case NIOPUT: ! 901: { ! 902: #ifdef BSD42 ! 903: struct gpargs *args = (struct gpargs *)addr; ! 904: #else ! 905: struct gpargs args; ! 906: ! 907: if (copyin(addr, (caddr_t)&args, sizeof(args))) { ! 908: RETURN ( EFAULT ); ! 909: } ! 910: #endif ! 911: status.lchdir = (cmd == NIOGET ? INPUT : OUTPUT); ! 912: status.lchnum = ARGS(lch); ! 913: ustatus = ARGS(status); ! 914: usaddr = ARGS(addr); ! 915: ulen = ARGS(len); ! 916: for(cp=sninfop->snlink[mdev]; cp; cp=cp->link) { ! 917: if( cp->lchnum == ARGS(lch) ! 918: && cp->lmachno == ARGS(lmachno)) { ! 919: do_getput: ! 920: bp = (cmd == NIOGET ? &cp->input : &cp->output); ! 921: if( cmd == NIOPUT ) { ! 922: copyin(usaddr, bp->buf, ulen); ! 923: spl5(); ! 924: bp->len = (ulen+1)/2; ! 925: snxstart(unit, cp, DATA); ! 926: sninfop->snsdata++; ! 927: } else { ! 928: spl5(); ! 929: /* ! 930: * The following may be ! 931: * unnecessary in light of ! 932: * the later check. ! 933: */ ! 934: if( bp->done == 0 && cp->flags&SENTRNR ) { ! 935: cp->flags &= ~SENTRNR; ! 936: cp->flags |= SENTRDY; ! 937: snxstart(unit, cp, RDY); ! 938: sninfop->sns1rdy++; ! 939: } ! 940: } ! 941: for (;;) { ! 942: spl5(); ! 943: if (bp->done) break; ! 944: sleep((caddr_t)bp->buf, SNPRI); ! 945: #ifdef TIMEOUT ! 946: spl6(); ! 947: if (cp->flags & RETRY) { ! 948: cp->flags &= ~RETRY; ! 949: sninfop->sntimeout++; ! 950: snxstart(unit, cp, (cp->flags&SENTDATA) ? DATA : RDY); ! 951: } ! 952: #endif TIMEOUT ! 953: } ! 954: status.code = ST_OK; ! 955: status.len = 2*bp->len; ! 956: if( cmd == NIOGET ) { ! 957: spl0(); ! 958: copyout(bp->buf, usaddr, 2*bp->len); ! 959: spl5(); ! 960: bp->len = MAXMSGLEN; ! 961: /* ! 962: * Believe it or not, we must check ! 963: * this here. This is because ! 964: * we lowered the ipl to do the ! 965: * copyout(). During that time ! 966: * another message may have tried ! 967: * to sneak in. ! 968: */ ! 969: if( cp->flags&SENTRNR ) { ! 970: cp->flags &= ~SENTRNR; ! 971: snxstart(unit, cp, RDY); ! 972: sninfop->snsrdy++; ! 973: } ! 974: } else ! 975: bp->len = 0; ! 976: bp->done = 0; ! 977: spl0(); ! 978: error = 0; ! 979: goto cpyout; ! 980: } ! 981: } ! 982: status.code = ST_IARGS; ! 983: error = EIO; ! 984: cpyout: ! 985: copyout((caddr_t)&status, (caddr_t)ustatus, sizeof(status)); ! 986: RETURN ( error ); ! 987: } ! 988: ! 989: case NIOGETM: ! 990: { ! 991: struct pair pair; ! 992: struct chdat *lchns[MAXMUX+1]; ! 993: register struct chdat **chp = lchns, **chpe = lchns; ! 994: #ifdef BSD42 ! 995: struct gmargs *args = (struct gmargs *)addr; ! 996: #else ! 997: struct gmargs args; ! 998: ! 999: if (copyin(addr, (caddr_t)&args, sizeof(args))) { ! 1000: RETURN ( EFAULT ); ! 1001: } ! 1002: #endif ! 1003: status.lchdir = INPUT; ! 1004: ustatus = ARGS(status); ! 1005: usaddr = ARGS(addr); ! 1006: ulen = ARGS(len); ! 1007: for(i=0; i<MAXMUX; i++) { ! 1008: if (copyin((caddr_t)ARGS(pairp++), (caddr_t)&pair, ! 1009: sizeof(struct pair))) { ! 1010: RETURN ( EFAULT ); ! 1011: } ! 1012: if( pair.lchno == -1 ) ! 1013: break; ! 1014: if (pair.lchno < 0 || pair.lchno >= 512 ! 1015: || pair.lmachno < 0 || pair.lmachno >= 512) { ! 1016: RETURN ( EBADF ); ! 1017: } ! 1018: for(cp=sninfop->snlink[mdev]; cp; cp=cp->link) { ! 1019: if( cp->lchnum == pair.lchno ! 1020: && cp->lmachno == pair.lmachno ) { ! 1021: *chpe++ = cp; ! 1022: break; ! 1023: } ! 1024: } ! 1025: if( cp >= &sn_chans[NUMLCH] ) { ! 1026: RETURN ( EBADF ); ! 1027: } ! 1028: } ! 1029: spl5(); ! 1030: for(chp=lchns; chp<chpe; chp++) { ! 1031: if( (*chp)->flags&MULTIPLEX ) { ! 1032: spl0(); ! 1033: RETURN ( EBUSY ); ! 1034: } ! 1035: } ! 1036: for(chp=lchns; chp<chpe; chp++) ! 1037: (*chp)->flags |= MULTIPLEX; ! 1038: ! 1039: loop: ! 1040: spl5(); ! 1041: for(chp=lchns; chp<chpe; chp++) { ! 1042: if( (*chp)->input.done ) { ! 1043: goto gotone; ! 1044: } ! 1045: } ! 1046: sleep((caddr_t)&sn_multiplex, SNPRI); ! 1047: goto loop; ! 1048: ! 1049: gotone: ! 1050: cp = *chp; ! 1051: for(chp=lchns; chp<chpe; chp++) ! 1052: (*chp)->flags &= ~MULTIPLEX; ! 1053: spl0(); ! 1054: status.lchnum = cp->lchnum; ! 1055: cmd = NIOGET; ! 1056: goto do_getput; ! 1057: } ! 1058: ! 1059: case NIOABORT: ! 1060: case NIORESET: { ! 1061: struct device *draddr; ! 1062: #ifndef USG5 ! 1063: struct uba_device *ui; ! 1064: #endif ! 1065: #ifdef BSD42 ! 1066: struct raargs *args = (struct raargs *)addr; ! 1067: #else ! 1068: struct raargs args; ! 1069: ! 1070: if (copyin(addr, (caddr_t)&args, sizeof(args))) { ! 1071: RETURN ( EFAULT ); ! 1072: } ! 1073: #endif ! 1074: ! 1075: #ifdef USG5 ! 1076: draddr = sn_addr[unit]; ! 1077: #else ! 1078: ui = sndinfo[unit]; ! 1079: draddr = (struct device *)ui->ui_addr; ! 1080: #endif ! 1081: ! 1082: spl5(); ! 1083: i = ARGS(machno) << 8; ! 1084: draddr->drcs = CMD_MODE; ! 1085: draddr->drout = (cmd == NIOABORT ? ABORT(i) : RESET(i)); ! 1086: draddr->drcs = EOP_MODE; ! 1087: draddr->drout = 0; ! 1088: draddr->drcs = DATA_MODE; ! 1089: spl0(); ! 1090: return(0); ! 1091: } ! 1092: ! 1093: case NIOREADSTATUS: ! 1094: #ifdef BSD42 ! 1095: copyout((caddr_t)sninfop, *(caddr_t *)addr, ! 1096: sizeof sn_sninfo[0]); ! 1097: #else ! 1098: copyout((caddr_t)sninfop, (caddr_t)addr, ! 1099: sizeof sn_sninfo[0]); ! 1100: #endif ! 1101: return(0); ! 1102: ! 1103: case NIOCHSTATUS: { ! 1104: ! 1105: struct chinfo chinfo; ! 1106: ! 1107: chinfo.numlch = NUMLCH; ! 1108: chinfo.chanaddr = &sn_chans[0]; ! 1109: #ifdef BSD42 ! 1110: copyout((caddr_t)&chinfo, *(caddr_t *)addr, ! 1111: sizeof chinfo); ! 1112: copyout((caddr_t)chinfo.chanaddr, ! 1113: (*(caddr_t *)addr)+sizeof chinfo, ! 1114: NUMLCH*sizeof sn_chans[0]); ! 1115: #else ! 1116: copyout((caddr_t)&chinfo, (caddr_t)addr, ! 1117: sizeof chinfo); ! 1118: copyout((caddr_t)chinfo.chanaddr, ! 1119: (caddr_t)(addr+sizeof chinfo), ! 1120: NUMLCH*sizeof sn_chans[0]); ! 1121: #endif ! 1122: return(0); ! 1123: } ! 1124: ! 1125: case NIOSETMACH: ! 1126: #ifdef BSD42 ! 1127: copyin(*(caddr_t *)addr, (caddr_t)snmach, sizeof snmach); ! 1128: #else ! 1129: copyin((caddr_t)addr, (caddr_t)snmach, sizeof snmach); ! 1130: #endif ! 1131: return(0); ! 1132: ! 1133: ! 1134: case NIOGETMACH: ! 1135: #ifdef BSD42 ! 1136: copyout((caddr_t)snmach, *(caddr_t *)addr, sizeof snmach); ! 1137: #else ! 1138: copyout((caddr_t)snmach, (caddr_t)addr, sizeof snmach); ! 1139: #endif ! 1140: return(0); ! 1141: ! 1142: ! 1143: case NIOQSTATUS: { ! 1144: struct openinfo openinfo; ! 1145: ! 1146: openinfo.owaddr = sn_openwait; ! 1147: openinfo.head = sn_owhead; ! 1148: openinfo.tail = sn_owtail; ! 1149: ! 1150: #ifdef BSD42 ! 1151: copyout((caddr_t)&openinfo, *(caddr_t *)addr, sizeof openinfo); ! 1152: copyout((caddr_t)sn_openwait, ! 1153: (*(caddr_t *)addr)+sizeof openinfo, ! 1154: NUMDEV*sizeof sn_openwait[0]); ! 1155: #else ! 1156: copyout((caddr_t)&openinfo, (caddr_t)addr, sizeof openinfo); ! 1157: copyout((caddr_t)sn_openwait, (caddr_t)(addr+sizeof openinfo), ! 1158: NUMDEV*sizeof sn_openwait[0]); ! 1159: #endif ! 1160: return(0); ! 1161: } ! 1162: ! 1163: case NIOZEROSTAT: ! 1164: { ! 1165: ! 1166: register char *p, *low, *high; ! 1167: ! 1168: low = (char *) &sn_sninfo[0]; ! 1169: #ifdef USG5 ! 1170: high = low + sn_cnt*sizeof (struct sninfo); ! 1171: #else ! 1172: high = low + NSN*sizeof (struct sninfo); ! 1173: #endif ! 1174: ! 1175: for (p=low; p<high; p++) ! 1176: *p = '\0'; ! 1177: return(0); ! 1178: } ! 1179: case NIOCHECK: ! 1180: case NIOWAIT: ! 1181: case NIOPURGE: ! 1182: case NIOSETVEC: ! 1183: ; ! 1184: } ! 1185: } ! 1186: ! 1187: static ! 1188: chclose(cp) ! 1189: register struct chdat *cp; ! 1190: { ! 1191: cp->lchnum = cp->dlchnum = cp->machno = -1; ! 1192: cp->flags = cp->xchan = cp->input.len = 0; ! 1193: } ! 1194: ! 1195: #ifdef TIMEOUT ! 1196: cktimchk() ! 1197: { ! 1198: register struct chdat *cp; ! 1199: register struct sninfo *sninfop; ! 1200: int unit; ! 1201: int s; ! 1202: ! 1203: for(cp=sn_chans; cp < &sn_chans[NUMLCH]; cp++) { ! 1204: if( cp->flags&(SENTDATA|SENTRDY) && --cp->ckticks == 0 ) { ! 1205: unit = cp->snunit; ! 1206: sninfop = &sn_sninfo[unit]; ! 1207: sninfop->snsched++; ! 1208: sninfop->snenqlost[cp->machno]++; ! 1209: cp->flags |= RETRY; ! 1210: if (cp->flags & SENTDATA) { ! 1211: wakeup((caddr_t)cp->output.buf); ! 1212: } else { ! 1213: wakeup((caddr_t)cp->input.buf); ! 1214: } ! 1215: } ! 1216: } ! 1217: s = spl6(); ! 1218: if (sn_state & OPEN) { ! 1219: timeout(cktimchk, (caddr_t)0, CKTICKS); ! 1220: } else { ! 1221: sn_state &= ~TIMER; ! 1222: } ! 1223: splx(s); ! 1224: } ! 1225: #endif TIMEOUT ! 1226: ! 1227: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.