![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ta.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 ta.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 ! root 1: /* ! 2: * DSA tape class driver ! 3: * drives TMSCP tapes ! 4: */ ! 5: ! 6: #include "sys/param.h" ! 7: #include "sys/buf.h" ! 8: #include "sys/ta.h" ! 9: #include "sys/mscp.h" ! 10: #include "sys/user.h" ! 11: #include "sys/file.h" ! 12: #include "sys/conf.h" ! 13: #include "sys/mtio.h" ! 14: ! 15: extern struct msaddr taaddr[]; ! 16: extern struct tatape tatape[]; ! 17: extern int tacnt; ! 18: static long tarefno; /* ref seq num */ ! 19: extern struct buf tabuf[]; ! 20: ! 21: static tacmd(), taonline(), tasonl(), tacinit(); ! 22: ! 23: int taopen(), taread(), tawrite(), taioctl(), tastrategy(), taclose(); ! 24: struct bdevsw tabdev = bdinit(taopen, taclose, tastrategy, B_TAPE); ! 25: struct cdevsw tacdev = cdinit(taopen, taclose, taread, tawrite, taioctl); ! 26: ! 27: /* ! 28: * minor device number split ! 29: * ! 30: * NOCACHE disables write-behind caching; probably useless ! 31: * DENS selects one of the eight TMSCP density values; ! 32: * the drive is instructed to use 1<<DENS(dev) in whatever ! 33: * density language it believes ! 34: * here are some languages: ! 35: * for 9-track tapes, (0) 800 bpi (1) PE (2) GCR ! 36: * for old cartridge tapes (TK50), (3) block tape ! 37: * for new cartridge tapes (TK70), (0) low density (1) high density ! 38: * for other TMSCP devices, (0) is usually the right number ! 39: */ ! 40: #define UNIT(d) ((d)&07) ! 41: #define DENS(d) (((d)&070)>>3) ! 42: #define NOCACHE(d) ((d)&0100) ! 43: #define NOREW(d) ((d)&0200) ! 44: ! 45: /* ! 46: * reused bits of buf/iobuf struct ! 47: */ ! 48: ! 49: #define b_next av_forw /* next buffer in queue */ ! 50: #define b_pkt av_back /* pointer to mscp command */ ! 51: #define b_crf b_resid /* saved refno for pending command */ ! 52: ! 53: /* ! 54: * flags in tatape.flags ! 55: */ ! 56: ! 57: #define ONLINE 01 /* drive is online */ ! 58: #define WONLINE 02 /* waiting for online */ ! 59: #define OPEN 04 /* someone has drive open */ ! 60: #define WRITTEN 010 /* some data was written */ ! 61: #define WPROT 020 /* drive is write protected */ ! 62: #define NEEDCMD 040 /* waiting for some command to start */ ! 63: #define CMDDONE 0100 /* command is finished */ ! 64: #define CMDERR 0200 /* command finished, and error */ ! 65: #define UNHAPPY 0400 /* needs `cache data loss' clear */ ! 66: #define WONLY 01000 /* tape was opened only for writing */ ! 67: ! 68: /* ! 69: * random numbers ! 70: */ ! 71: ! 72: #define PRIONL (PZERO-1) ! 73: #define IDTA 1 /* connection ID for MSCP */ ! 74: ! 75: /* ! 76: * open a drive ! 77: */ ! 78: ! 79: int taseql(), tadg(); ! 80: ! 81: taopen(dev, flag) ! 82: dev_t dev; ! 83: { ! 84: register int unit; ! 85: register struct tatape *ta; ! 86: register struct msaddr *rp; ! 87: int wasoff; ! 88: ! 89: unit = UNIT(dev); ! 90: if (unit > tacnt) { ! 91: u.u_error = ENXIO; ! 92: return; ! 93: } ! 94: ta = &tatape[unit]; ! 95: rp = &taaddr[unit]; ! 96: if (ta->flags & OPEN) { ! 97: u.u_error = EBUSY; ! 98: return; ! 99: } ! 100: if (rp->ctype < 0 || rp->ctype >= nmsport ! 101: || (ta->port = msportsw[rp->ctype]) == NULL) { ! 102: u.u_error = ENXIO; ! 103: return; ! 104: } ! 105: ta->flags |= OPEN; ! 106: ta->flags &=~ (WRITTEN|WPROT|WONLY); ! 107: if ((*ta->port->mp_init)(rp->ctl, rp->ctype, 0, IDTA, taseql, tadg) == 0) { ! 108: u.u_error = ENXIO; ! 109: ta->flags &=~ OPEN; ! 110: return; ! 111: } ! 112: tacinit(ta, rp); ! 113: spl6(); ! 114: wasoff = (ta->flags & ONLINE) == 0; ! 115: if ((ta->flags & ONLINE) == 0) ! 116: taonline(ta, rp); ! 117: spl0(); ! 118: if ((ta->flags & ONLINE) == 0) { ! 119: u.u_error = ENXIO; ! 120: ta->flags &=~ OPEN; ! 121: return; ! 122: } ! 123: if ((ta->flags & WPROT) && (flag & FWRITE)) { ! 124: u.u_error = ENODEV; ! 125: if (!NOREW(dev)) ! 126: tacmd(unit, 1, OPAVL, 0, 0); ! 127: ta->flags &=~ (OPEN|ONLINE); ! 128: return; ! 129: } ! 130: ta->dens = (1<<DENS(dev)); ! 131: if (tacmd(unit, 0, OPGUS, 0, 0) /* fill in language in dens */ ! 132: || tacmd(unit, 0, OPSUC, NOCACHE(dev)?0:UFWBK, wasoff?ta->dens:0)) { ! 133: u.u_error = ENXIO; ! 134: if (!NOREW(dev)) ! 135: tacmd(unit, 1, OPAVL, 0, 0); ! 136: ta->flags &=~ (OPEN|ONLINE); ! 137: return; ! 138: } ! 139: if ((flag & (FREAD|FWRITE)) == FWRITE) ! 140: ta->flags |= WONLY; ! 141: } ! 142: ! 143: taclose(dev) ! 144: { ! 145: register struct tatape *ta; ! 146: int unit; ! 147: ! 148: unit = UNIT(dev); ! 149: ta = &tatape[unit]; ! 150: if (ta->flags & ONLINE) { ! 151: if (ta->flags & (WONLY|WRITTEN)) { ! 152: tacmd(unit, 0, OPWRM, 0, 0); ! 153: tacmd(unit, 0, OPWRM, 0, 0); ! 154: tacmd(unit, 0, OPPOS, 0, -1); ! 155: } ! 156: /* annoyance: OPAVL always rewinds. */ ! 157: if (!NOREW(dev)) ! 158: tacmd(unit, 1, OPAVL, 0, 0); ! 159: } ! 160: ta->flags &=~ OPEN; ! 161: } ! 162: ! 163: /* ! 164: * send some non-io command to a tape drive ! 165: * op is the MSCP opcode; ! 166: * p0 and p1 are some parameters ! 167: * if async == 0, don't return until command does ! 168: */ ! 169: ! 170: #define TWPRI PZERO ! 171: #define TCPRI (PZERO+1) ! 172: ! 173: static ! 174: tacmd(dev, async, op, p0, p1) ! 175: { ! 176: register struct mscmd *mp; ! 177: register struct tatape *ta; ! 178: register struct msaddr *rp; ! 179: register s; ! 180: register err; ! 181: ! 182: ta = &tatape[dev]; ! 183: rp = &taaddr[dev]; ! 184: if ((ta->flags & ONLINE) == 0) ! 185: return (1); ! 186: mp = (*ta->port->mp_get)(rp->ctl); ! 187: bzero((caddr_t)mp, sizeof(struct mscmd)); /* clear reserved fields */ ! 188: mp->m_crf = ++tarefno; ! 189: mp->m_unit = rp->unit; ! 190: mp->m_opcd = op; ! 191: mp->m_mod = MDCSX; ! 192: switch (op) { ! 193: case OPPOS: /* position: type, nobjs */ ! 194: if (p1 < 0) { ! 195: p1 = -p1; ! 196: mp->m_mod |= MDREV; ! 197: } ! 198: if (p0 == -1) { /* -1 == rewind */ ! 199: mp->m_mod |= MDREW; ! 200: mp->m_mod |= p1; /* hack */ ! 201: } ! 202: else if (p0 == 0) /* 0 == skip files */ ! 203: mp->m_fcnt = p1; ! 204: else { /* 1 == skip records */ ! 205: mp->m_mod |= MDOBJ; ! 206: mp->m_rcnt = p1; ! 207: } ! 208: break; ! 209: ! 210: case OPSUC: /* set unit char: unit flags, density */ ! 211: mp->m_unfl |= p0; ! 212: mp->m_fmt = p1; ! 213: break; ! 214: ! 215: case OPGUS: /* get unit status */ ! 216: mp->m_mod = p0; /* wretched TK50 */ ! 217: break; ! 218: ! 219: default: /* anything else: modifiers, 0 */ ! 220: mp->m_mod |= p0; ! 221: break; ! 222: } ! 223: s = spl6(); ! 224: while (ta->cmdp) { ! 225: ta->flags |= NEEDCMD; ! 226: sleep((caddr_t)ta, TWPRI); ! 227: } ! 228: ta->cmdp = mp; ! 229: ta->flags &=~ (CMDERR|CMDDONE); ! 230: if (ta->flags & UNHAPPY) { ! 231: ta->flags &=~ UNHAPPY; ! 232: mp->m_mod |= MDCDL; ! 233: } ! 234: (*ta->port->mp_send)(rp->ctl, IDTA, mp); ! 235: if (async == 0) { ! 236: while ((ta->flags & CMDDONE) == 0) ! 237: if (tsleep((caddr_t)ta, TCPRI, 0) == TS_SIG) ! 238: break; ! 239: } ! 240: err = ((ta->flags & CMDERR) != 0); ! 241: ta->cmdp = NULL; ! 242: if (ta->flags & NEEDCMD) { ! 243: ta->flags &=~ NEEDCMD; ! 244: wakeup((caddr_t)ta); ! 245: } ! 246: splx(s); ! 247: return (err); ! 248: } ! 249: ! 250: int tastrategy(); ! 251: ! 252: taread(dev) ! 253: { ! 254: physio(tastrategy, &tabuf[UNIT(dev)], dev, B_READ, minphys); ! 255: } ! 256: ! 257: tawrite(dev) ! 258: { ! 259: physio(tastrategy, &tabuf[UNIT(dev)], dev, B_WRITE, minphys); ! 260: } ! 261: ! 262: /* ! 263: * strategy routine; ! 264: * send the packet right away ! 265: */ ! 266: ! 267: tastrategy(bp) ! 268: register struct buf *bp; ! 269: { ! 270: register struct tatape *ta; ! 271: register struct mscmd *mp; ! 272: register int unit; ! 273: register struct msaddr *rp; ! 274: int count; ! 275: ! 276: unit = UNIT(minor(bp->b_dev)); ! 277: ta = &tatape[unit]; ! 278: rp = &taaddr[unit]; ! 279: count = bp->b_bcount; ! 280: spl6(); ! 281: if ((ta->flags & ONLINE) == 0 && taonline(ta, rp) == 0) { ! 282: bp->b_flags |= B_ERROR; ! 283: iodone(bp); ! 284: spl0(); ! 285: return; ! 286: } ! 287: mp = (*ta->port->mp_get)(rp->ctl); ! 288: mp->m_crf = ++tarefno; ! 289: mp->m_unit = rp->unit; ! 290: mp->m_opcd = (bp->b_flags & B_READ) ? OPRD : OPWR; ! 291: mp->m_mod = MDCSX; ! 292: if (ta->flags & UNHAPPY && (bp->b_flags & B_READ) == 0) { ! 293: ta->flags &=~ UNHAPPY; ! 294: mp->m_mod |= MDCDL; ! 295: } ! 296: mp->m_unfl = 0; ! 297: mp->m_bcnt = count; ! 298: /* seek on block device? later */ ! 299: (*ta->port->mp_map)(rp->ctl, mp, bp); ! 300: bp->b_pkt = (struct buf *)mp; ! 301: bp->b_crf = mp->m_crf; ! 302: bp->b_next = NULL; ! 303: if (ta->actf) ! 304: ta->actl->b_next = bp; ! 305: else ! 306: ta->actf = bp; ! 307: ta->actl = bp; ! 308: if ((bp->b_flags & B_READ) == 0) ! 309: ta->flags |= WRITTEN; ! 310: (*ta->port->mp_send)(rp->ctl, IDTA, mp); ! 311: spl0(); ! 312: } ! 313: ! 314: /* ! 315: * ioctl ! 316: * a subset of the berkeley ones ! 317: */ ! 318: ! 319: taioctl(dev, cmd, addr, flag) ! 320: dev_t dev; ! 321: caddr_t addr; ! 322: { ! 323: struct mtop mt; ! 324: int func, p0, p1; ! 325: ! 326: switch (cmd) { ! 327: default: ! 328: u.u_error = ENOTTY; ! 329: break; ! 330: /* does anything use the other ones? */ ! 331: ! 332: case MTIOCTOP: ! 333: if (copyin(addr, (caddr_t)&mt, sizeof(struct mtop)) < 0) { ! 334: u.u_error = EFAULT; ! 335: return; ! 336: } ! 337: if (mt.mt_op == MTWEOF) { /* oddball */ ! 338: if ((flag & FWRITE) == 0) { ! 339: u.u_error = EBADF; ! 340: return; ! 341: } ! 342: while (mt.mt_count-- > 0) ! 343: if (tacmd(UNIT(dev), 0, OPWRM, 0, 0)) { ! 344: u.u_error = EIO; ! 345: return; ! 346: } ! 347: return; ! 348: } ! 349: if (mt.mt_op == MTRST) { /* another oddball */ ! 350: (*tatape[UNIT(dev)].port->mp_init)(taaddr[UNIT(dev)].ctl, taaddr[UNIT(dev)].ctype, 1, IDTA, taseql, tadg); ! 351: return; ! 352: } ! 353: p1 = mt.mt_count; ! 354: func = OPPOS; ! 355: switch (mt.mt_op) { /* arcane arguments to tapos */ ! 356: case MTBSF: ! 357: p1 = -p1; ! 358: case MTFSF: ! 359: p0 = 0; ! 360: break; ! 361: ! 362: case MTBSR: ! 363: p1 = -p1; ! 364: case MTFSR: ! 365: p0 = 1; ! 366: break; ! 367: ! 368: case MTREW: ! 369: p1 = 0; ! 370: p0 = -1; ! 371: break; ! 372: ! 373: case MTOFFL: ! 374: func = OPAVL; ! 375: p1 = 0; ! 376: p0 = MDUNL; ! 377: break; ! 378: ! 379: case MTNOP: ! 380: return; /* silly */ ! 381: } ! 382: if (tacmd(UNIT(dev), 0, func, p0, p1)) ! 383: u.u_error = EIO; ! 384: break; ! 385: } ! 386: } ! 387: ! 388: /* ! 389: * here when the port gets a sequential message ! 390: */ ! 391: taseql(ctl, type, ep) ! 392: int ctl, type; ! 393: register struct msend *ep; ! 394: { ! 395: register struct buf *bp; ! 396: register struct tatape *ta; ! 397: register int unit; ! 398: register struct buf *obp; ! 399: int sts; ! 400: ! 401: if (ep->m_opcd == 0 && ep->m_sts == STRST) { ! 402: tareset(ctl, type); ! 403: return; ! 404: } ! 405: /* get rid of this wretched loop somehow */ ! 406: for (unit = 0; unit < tacnt; unit++) ! 407: if (taaddr[unit].ctl == ctl ! 408: && taaddr[unit].ctype == type ! 409: && taaddr[unit].unit == ep->m_unit) ! 410: break; ! 411: if (unit >= tacnt) { ! 412: printf("tmscp stray unit: ctl%d typ%d ta%d sts %o opcode %o\n", ! 413: ctl, type, ep->m_unit, ep->m_sts, ep->m_opcd); ! 414: return; ! 415: } ! 416: ta = &tatape[unit]; ! 417: if (ep->m_flgs & EFCDL) ! 418: ta->flags |= UNHAPPY; ! 419: switch (ep->m_opcd & 0377) { ! 420: case OPEND: /* eg invalid command */ ! 421: printf("tmscp ctl%d ta%d ill cmd crf %d off %d\n", ctl, ! 422: ep->m_unit, ep->m_crf, ep->m_sts>>8); ! 423: if (ta->cmdp && ta->cmdp->m_crf == ep->m_crf) ! 424: goto fincmd; ! 425: /* else maybe it's a transfer; fall in */ ! 426: case OPRD|OPEND: ! 427: case OPWR|OPEND: ! 428: for (bp = ta->actf, obp = NULL; bp; obp = bp, bp = bp->b_next) ! 429: if (ep->m_crf == bp->b_crf) ! 430: break; ! 431: if (bp == NULL) { ! 432: printf("ta%d stray end: crf %d sts x%x opcode 0%o\n", ! 433: unit, ep->m_crf, ep->m_sts, ep->m_opcd & 0377); ! 434: return; ! 435: } ! 436: if (obp) ! 437: obp->b_next = bp->b_next; ! 438: else ! 439: ta->actf = bp->b_next; ! 440: if (bp == ta->actl) ! 441: ta->actl = obp; ! 442: sts = ep->m_sts & STMSK; ! 443: if (sts == STAVL || sts == STOFL) ! 444: ta->flags &=~ ONLINE; /* help! */ ! 445: bp->b_resid = bp->b_bcount - ep->m_bcnt; ! 446: if (sts == STTPM) ! 447: sts = STSUC; /* tape mark -> empty read */ ! 448: if (sts != STSUC) { ! 449: bp->b_flags |= B_ERROR; ! 450: switch (sts) { ! 451: case STRDT: ! 452: case STOFL: ! 453: case STAVL: ! 454: case STWPR: /* well ... */ ! 455: break; ! 456: default: ! 457: printf("err on ta%d block %D: sts 0%o flgs 0%o\n", unit, bp->b_blkno, ep->m_sts, ep->m_flgs); ! 458: } ! 459: } ! 460: if (ep->m_flgs & EFEOT && (bp->b_flags & B_READ) == 0) { ! 461: bp->b_error = ENOSPC; ! 462: bp->b_flags |= B_ERROR; ! 463: } ! 464: (*ta->port->mp_unmap)(ctl, (struct mscmd *)bp->b_pkt); ! 465: iodone(bp); ! 466: return; ! 467: ! 468: case OPGUS|OPEND: ! 469: ta->dens &= TFMASK; ! 470: ta->dens |= ep->m_menu & ~TFMASK; ! 471: goto fincmd; ! 472: ! 473: case OPAVL|OPEND: ! 474: if (ep->m_sts == STSUC) /* sic */ ! 475: ta->flags &=~ ONLINE; ! 476: case OPWRM|OPEND: ! 477: case OPPOS|OPEND: ! 478: case OPFLS|OPEND: ! 479: case OPSUC|OPEND: ! 480: fincmd: ! 481: if ((ep->m_sts & STMSK) == STAVL || (ep->m_sts & STMSK) == STOFL) ! 482: ta->flags &=~ ONLINE; ! 483: if (ta->cmdp) { ! 484: ta->flags |= CMDDONE; ! 485: if ((ep->m_sts & STMSK) != STSUC) { ! 486: printf("ta%d: cmd 0%o sts 0%o flgs 0%o\n", unit, ep->m_opcd&0377, ep->m_sts, ep->m_flgs); ! 487: ta->flags |= CMDERR; ! 488: } ! 489: wakeup((caddr_t)ta); ! 490: } ! 491: return; ! 492: ! 493: case OPONL|OPEND: ! 494: tasonl(ta, ep); ! 495: return; ! 496: ! 497: case OPSCC|OPEND: ! 498: if ((ep->m_sts & STMSK) != STSUC) ! 499: printf("tmscp ctl%d typ%d: bad init\n", ctl, type); ! 500: return; ! 501: ! 502: default: ! 503: printf("stray tmscp msg ta%d opcd 0%o sts x%x\n", ! 504: unit, ep->m_opcd&0377, ep->m_sts&0177777); ! 505: return; ! 506: } ! 507: } ! 508: ! 509: /* ! 510: * controller was reset ! 511: * discard all pending io, ! 512: * awake all sleepers, ! 513: * mark everything offline ! 514: */ ! 515: ! 516: tareset(ctl, type) ! 517: int ctl, type; ! 518: { ! 519: register int unit; ! 520: register struct tatape *ta; ! 521: register struct buf *bp, *nbp; ! 522: ! 523: for (unit = 0; unit < tacnt; unit++) { ! 524: if (taaddr[unit].ctl != ctl || taaddr[unit].ctype != type) ! 525: continue; ! 526: ta = &tatape[unit]; ! 527: for (bp = ta->actf; bp; bp = nbp) { ! 528: nbp = bp->b_next; ! 529: (*ta->port->mp_unmap)(ctl, (struct mscmd *)bp->b_pkt); ! 530: bp->b_flags |= B_ERROR; ! 531: iodone(bp); ! 532: } ! 533: ta->actf = ta->actl = NULL; ! 534: ta->flags &=~ (ONLINE|WONLINE); ! 535: if (ta->cmdp) ! 536: ta->flags |= CMDDONE|CMDERR; ! 537: wakeup((caddr_t)ta); ! 538: } ! 539: } ! 540: ! 541: /* ! 542: * here with a datagram message ! 543: * explanations really shouldn't be in the driver ! 544: */ ! 545: ! 546: static char *taevents[] = { ! 547: "ok", ! 548: "inv cmd", ! 549: "op aborted", ! 550: "offline", ! 551: "available", ! 552: "med fmt", ! 553: "write prot", ! 554: "comp err", ! 555: "data err", ! 556: "host buf access err", ! 557: "cntl err", ! 558: "drive err", ! 559: }; ! 560: #define MAXEVT 0xb ! 561: ! 562: tadg(ctl, type, ep) ! 563: int ctl, type; ! 564: register struct mserl *ep; ! 565: { ! 566: ! 567: if (ep->l_evnt == STSEX) /* boring, at least for now */ ! 568: return; ! 569: printf("ta%d ctl%d typ%d seq %d: %s err; fmt x%x ev x%x fl x%x\n", ! 570: ep->l_unit, ctl, type, ep->l_seq, /* phys unit, not log */ ! 571: ep->l_flgs&(LFSUC|LFCON) ? "soft" : "hard", ! 572: ep->l_fmt, ep->l_evnt, ep->l_flgs&0377); ! 573: if ((ep->l_evnt & STMSK) <= MAXEVT) ! 574: printf("%s; ", taevents[ep->l_evnt & STMSK]); ! 575: switch (ep->l_fmt) { ! 576: case FMCNT: ! 577: /* now the thing should be marked disastrously bad */ ! 578: printf("oops\n"); ! 579: break; ! 580: ! 581: case FMBAD: ! 582: printf("host mem access; addr x%x\n", ep->l_badr); ! 583: break; ! 584: ! 585: case FMTAPE: ! 586: printf("lvl x%x retry x%x\n", ep->l_lvl, ep->l_rtry); ! 587: break; ! 588: ! 589: default: ! 590: printf("\n"); ! 591: break; ! 592: } ! 593: } ! 594: ! 595: /* ! 596: * unit is believed offline ! 597: * try to bring it on ! 598: */ ! 599: ! 600: static ! 601: taonline(ta, rp) ! 602: register struct tatape *ta; ! 603: register struct msaddr *rp; ! 604: { ! 605: register struct mscmd *mp; ! 606: int s; ! 607: ! 608: s = spl6(); ! 609: if ((ta->flags & WONLINE) == 0) { ! 610: mp = (*ta->port->mp_get)(rp->ctl); ! 611: bzero((caddr_t)mp, sizeof(struct mscmd)); /* clear reserved fields */ ! 612: mp->m_crf = ++tarefno; ! 613: mp->m_unit = rp->unit; ! 614: mp->m_opcd = OPONL; ! 615: mp->m_mod = MDCSX|MDXCL; ! 616: if (ta->flags & UNHAPPY) { ! 617: ta->flags &=~ UNHAPPY; ! 618: mp->m_mod |= MDCDL; ! 619: } ! 620: mp->m_unfl = 0; ! 621: mp->m_fmt = 0; /* ta->dens? */ ! 622: (*ta->port->mp_send)(rp->ctl, IDTA, mp); ! 623: ta->flags |= WONLINE; ! 624: } ! 625: while (ta->flags & WONLINE) ! 626: tsleep((caddr_t)ta, PRIONL, 60); ! 627: splx(s); ! 628: if ((ta->flags & ONLINE) == 0) ! 629: return (0); ! 630: return (1); ! 631: } ! 632: ! 633: static ! 634: tasonl(ta, ep) ! 635: register struct tatape *ta; ! 636: register struct msend *ep; ! 637: { ! 638: ! 639: if (ta->flags & WONLINE) { ! 640: ta->flags &=~ WONLINE; ! 641: wakeup((caddr_t)ta); ! 642: } ! 643: if ((ep->m_sts & STMSK) != STSUC) ! 644: return; ! 645: ta->flags |= ONLINE; ! 646: if (ep->m_unfl & UFWPH) ! 647: ta->flags |= WPROT; ! 648: } ! 649: ! 650: /* ! 651: * controller init ! 652: * set characteristics to turn off host timeouts ! 653: */ ! 654: ! 655: static ! 656: tacinit(ta, rp) ! 657: struct tatape *ta; ! 658: struct msaddr *rp; ! 659: { ! 660: register struct mscmd *mp; ! 661: register int s; ! 662: ! 663: mp = (*ta->port->mp_get)(rp->ctl); ! 664: bzero((caddr_t)mp, sizeof(struct mscmd)); /* clear reserved fields */ ! 665: mp->m_crf = ++tarefno; ! 666: mp->m_opcd = OPSCC; ! 667: mp->m_mod = MDCSX; ! 668: mp->m_cntf = CFMSC | CFTHS; ! 669: mp->m_vrsn = MSCPVER; ! 670: s = spl6(); ! 671: (*ta->port->mp_send)(rp->ctl, IDTA, mp); ! 672: splx(s); ! 673: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.