![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / boot / stand|
Return to ar.c CVS log | Up to [Research Unix] / researchv9 / sys / boot / stand |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)ar.c 1.1 86/02/03 Copyr 1983 Sun Micro"; ! 3: #endif ! 4: ! 5: /* ! 6: * Copyright (c) 1983 by Sun Microsystems, Inc. ! 7: */ ! 8: ! 9: /* ! 10: * Standalone Driver for Archive Intelligent Streaming Tape ! 11: */ ! 12: #include "saio.h" ! 13: #include "param.h" ! 14: #include "../sundev/arreg.h" ! 15: #include "ardef.h" ! 16: ! 17: #define min(a,b) ((a) < (b) ? (a) : (b)) ! 18: ! 19: int ardebug = 0; ! 20: #define Dprintf if (ardebug) printf ! 21: ! 22: /* Trace all writes to control reg */ ! 23: #define DebugTrace Dprintf(ar_ctrl_hdr, *(long*)(2+(char*)araddr), ar_bits) ! 24: ! 25: /* Define assorted debugging strings to save repeating them N times */ ! 26: #ifdef DEBUG ! 27: char ar_bits[] = ARCH_LONG_CTRL_BITS; ! 28: char ar_ctrl_hdr[] = "ar* Bits: %b\n"; ! 29: char ar_set_hdr[] = "ar* CMD: %x\n"; ! 30: #endif DEBUG ! 31: char ar_stat_bits[] = ARCH_BITS; ! 32: ! 33: /* ! 34: * Standard I/O addresses. ! 35: */ ! 36: #define NARADDR 2 ! 37: u_long araddrs[] = { 0x200, 0x208}; ! 38: ! 39: /* ! 40: * What resources we need to run ! 41: */ ! 42: struct devinfo arinfo = { ! 43: sizeof (struct ardevice), /* I/O regs */ ! 44: 0, /* no DMA */ ! 45: sizeof (struct ar_softc), /* work area */ ! 46: NARADDR, ! 47: araddrs, ! 48: MAP_MBIO, ! 49: DEV_BSIZE, /* transfer size */ ! 50: }; ! 51: ! 52: /* ! 53: * What facilities we export to the world ! 54: */ ! 55: int aropen(), arclose(), arstrategy(); ! 56: extern int xxboot(), xxprobe(); ! 57: ! 58: struct boottab ardriver = { ! 59: "ar", xxprobe, xxboot, aropen, arclose, arstrategy, ! 60: "ar: Multibus Archive tape controller", &arinfo, ! 61: }; ! 62: ! 63: /* ! 64: * Translation between generic tape commands and initial states of ! 65: * the Archive state machine. ! 66: */ ! 67: enum ARstates ar_cmds[] = { ! 68: /* CLOSE */ CLOSEinit, ! 69: /* REWIND */ REWinit, ! 70: /* STATUS */ RDSTinit, ! 71: /* READ */ READinit, ! 72: /* WRITE */ WRinit, ! 73: /* WEOF */ WFMinit, ! 74: /* ERASE */ ERASEinit, ! 75: /* SELECT */ SELinit, ! 76: /* DELSELECT */ DESELinit, ! 77: /* TENSE */ TENSEinit, ! 78: /* SKIPFILE */ RFMinit, ! 79: /* CMD OK? */ CMDOKinit, ! 80: }; ! 81: ! 82: ! 83: #define SPININIT 1000000 ! 84: /* ! 85: * Initialize a controller ! 86: */ ! 87: aropen(sip) ! 88: register struct saioreq *sip; ! 89: { ! 90: register struct ar_softc *sc; ! 91: register int count; ! 92: register struct ardevice *araddr; ! 93: int skip; ! 94: ! 95: sc = (struct ar_softc *)sip->si_devdata; ! 96: araddr = sc->sc_addr = (struct ardevice *)sip->si_devaddr; ! 97: ! 98: sc->sc_lastiow = 0; ! 99: sc->sc_state = IDLEstate; ! 100: /* sc->sc_status = 0; Doesn't work, so leave it alone. */ ! 101: sc->sc_size = 0; ! 102: sc->sc_bufptr = (char *) 0x1ff001; /* very funny buf addr */ ! 103: /* sc->sc_attached had better already be 1. */ ! 104: sc->sc_initted = 0; /* until later */ ! 105: sc->sc_opened = 0; /* until later */ ! 106: sc->sc_drive = 0; ! 107: sc->sc_histate = 0; ! 108: /* sc->sc_addr had better already be initialized. */ ! 109: sc->sc_qidle = 1; ! 110: sc->sc_eoflag = 0; ! 111: sc->sc_cmdok = 0; ! 112: sc->sc_selecteddev = -1; ! 113: /* When adding new fields to softc, be sure to initialize them here. */ ! 114: /* FIXME, should initialize buffer headers here too */ ! 115: ! 116: araddr->arunwedge = 1; /* Take it out of burst mode wedge */ ! 117: araddr->arburst = 0; ! 118: araddr->arreq = 0; ! 119: araddr->arxfer = 0; ! 120: araddr->arcatch = 0; ! 121: araddr->arexcie = 0; ! 122: araddr->arrdyie = 0; ! 123: ! 124: /* ! 125: * If tape is up from previous system operation, ! 126: * take it down gently. ! 127: */ ! 128: if (araddr->aronline) { ! 129: Dprintf("ar*init tape online\n"); ! 130: araddr->aronline = 0; /* Writes TM (if writing) & rewinds */ ! 131: } ! 132: ! 133: count = SPININIT; ! 134: while (!araddr->arrdy && !araddr->arexc && count) ! 135: count--; ! 136: if (count == 0) Dprintf("ar: Timeout waiting for Ready at %x\n", araddr); ! 137: ! 138: if (araddr->arrdy) Dprintf("ar*init arrdy on before reset\n"); ! 139: if (araddr->arexc) Dprintf("ar*init arexc on before reset\n"); ! 140: ! 141: /* Tape is ready or exceptional. Reset it for good measure. */ ! 142: #ifdef PRF ! 143: Dprintf("ar*init about to arreset\n"); ! 144: #endif PRF ! 145: araddr->arreset = 1; ! 146: #ifdef PRF ! 147: Dprintf("ar*init asserted arreset\n"); ! 148: #endif PRF ! 149: DELAY(25); /* at least 13 usec */ ! 150: araddr->arreset = 0; ! 151: #ifdef PRF ! 152: Dprintf("ar*init Reset complete\n"); ! 153: #endif PRF ! 154: ! 155: count = SPININIT; ! 156: while (!araddr->arexc && count) ! 157: count--; ! 158: if (count == 0) { ! 159: Dprintf("ar: Timeout waiting for Exception after reset\n"); ! 160: return (-1); ! 161: } ! 162: ! 163: /* Now read back status from the reset. */ ! 164: sc->sc_initted = 1; /* Must do first so interrupt OK */ ! 165: sc->sc_opened = 1; /* Must do first so interrupt OK */ ! 166: araddr->aronline = 1; /* Must do first so RDST microcode doesn't ! 167: play games with arrdy line. See comments ! 168: in open(). */ ! 169: if (arcmd(sc, AR_STATUS)) { ! 170: Dprintf("ar*init Error from command STATUS\n"); ! 171: araddr->aronline = 0; ! 172: sc->sc_initted = 0; /* Try again on next open */ ! 173: sc->sc_opened = 0; /* Try again on next open */ ! 174: return (-1); ! 175: } ! 176: ! 177: /* ! 178: * FIXME, this is a kludge. open() won't select the drive unless ! 179: * the in-core status claims we are at BOT, since the tape drive ! 180: * will reject the command if indeed a tape was in use and is not ! 181: * at BOT. However, tapes at BOT after a Reset do not necessarily ! 182: * indicate BOT in their status. We should probably do a rewind ! 183: * here instead, if the tape exists. ! 184: */ ! 185: sc->sc_status.BOT = 1; /* Pretend we're at BOT for open() */ ! 186: ! 187: /* ! 188: * There is a problem in the Archive in that after each command, ! 189: * it goes thru a cleanup routine. If aronline is not asserted, ! 190: * this cleanup routine drops arrdy while it rewinds the tape ! 191: * to BOT. It deasserts arrdy for 90 us even if the tape is ! 192: * already at BOT. This causes us problems because we get a arrdy ! 193: * interrupt and then discover that arrdy is gone. ! 194: * ! 195: * The problem has been circumvented at the low level by checking ! 196: * for arrdy in the interrupt routine, and looping until it (or ! 197: * arexc) comes on. We attempt to fix the problem here, to avoid ! 198: * looping at SPL(), by having aronline always on when we are doing ! 199: * anything. ! 200: * ! 201: * The problem seems especially a problem for us on Select and Read ! 202: * Status commands. (That's because those are the only commands we ! 203: * do with aronline deasserted.) ! 204: * ! 205: * This info was obtained from Lou Domshy, Mgr. of Product Mgmt and ! 206: * Applications Engineering(?) at the Archive factory, 714-641-0279, ! 207: * on 1 December 1982, by John Gilmore of Sun Microsystems. ! 208: */ ! 209: araddr->aronline = 1; /* Let ctrlr know we are doing a series */ ! 210: ! 211: /* ! 212: * First select the drive we're interested in. ! 213: * ! 214: * Since the select command doesn't work when we aren't at BOT, ! 215: * we just have to hope the same drive is still selected as last ! 216: * time. FIXME. We should record this info in softc and keep it ! 217: * up to date. FIXME: also, I'm not happy about using status.BOT ! 218: * here, even tho it should always be up to date. -- JCGnu 22Nov82 ! 219: */ ! 220: sc->sc_cmdok = 0; ! 221: (void) arcmd(sc, AR_CMDOK); /* See if OK to issue cmds */ ! 222: /* ! 223: * Now get its status and check on a few things. ! 224: */ ! 225: if (sc->sc_cmdok) { ! 226: if (arcmd(sc, AR_STATUS)) { /* interrupted */ ! 227: Dprintf("ar*open command STATUS error\n"); ! 228: goto err; ! 229: } ! 230: if (sc->sc_status.NoDrive) { ! 231: printf("ar: no drive\n"); ! 232: goto err; ! 233: } ! 234: if (sc->sc_status.NoCart) { ! 235: printf("ar: no cartridge in drive\n"); ! 236: goto err; ! 237: } ! 238: } ! 239: ! 240: if ((sip->si_flgs&F_WRITE) && sc->sc_status.WriteProt) { ! 241: printf("ar: cartridge is write protected\n"); ! 242: goto err; ! 243: } ! 244: sc->sc_lastiow = 0; ! 245: ! 246: skip = sip->si_boff; ! 247: while (skip--) { ! 248: arcmd(sc, AR_SKIPFILE); ! 249: arcmd(sc, AR_STATUS); ! 250: } ! 251: sc->sc_eoflag = 0; ! 252: Dprintf("ar*open exiting\n"); ! 253: return (0); ! 254: ! 255: err: ! 256: arcmd(sc, AR_DESELECT); ! 257: araddr->aronline = 0; ! 258: sc->sc_opened = 0; ! 259: return (-1); ! 260: } ! 261: ! 262: /* ! 263: * Close tape device. ! 264: * ! 265: * If tape was open for writing or last operation was ! 266: * a write, then write two EOF's and backspace over the last one. ! 267: * Unless this is a non-rewinding special file, rewind the tape. ! 268: * Make the tape available to others. ! 269: */ ! 270: arclose(sip) ! 271: struct saioreq *sip; ! 272: { ! 273: register struct ar_softc *sc = (struct ar_softc *)sip->si_devdata; ! 274: register struct ardevice *araddr = sc->sc_addr; ! 275: ! 276: /* ! 277: * Write file mark and rewind, by dropping aronline. ! 278: * FIXME. These 3 commands should be moved into AR_CLOSE ! 279: * in order that the user program can continue while the ! 280: * tape is rewinding. ! 281: */ ! 282: arcmd(sc, AR_CLOSE); /* Shut down things */ ! 283: araddr->aronline = 1; /* After rewind, set aronline */ ! 284: /* See comments in open() about aronline and read status cmds */ ! 285: /* FIXME, this might screw low level code if it affects arrdy */ ! 286: arcmd(sc, AR_STATUS); /* Read block counts */ ! 287: arcmd(sc, AR_DESELECT); /* Turn LED off */ ! 288: sc->sc_selecteddev = -1; ! 289: sc->sc_eoflag = 0; /* Not at eof after rewind */ ! 290: sc->sc_opened = 0; /* Available to be opened again */ ! 291: Dprintf("ar*close exiting\n"); ! 292: } ! 293: ! 294: arstrategy(sip, rw) ! 295: register struct saioreq *sip; ! 296: int rw; ! 297: { ! 298: register struct ar_softc *sc = (struct ar_softc *)sip->si_devdata; ! 299: int func = (rw == WRITE) ? AR_WRITE : AR_READ; ! 300: ! 301: if (sc->sc_eoflag) { ! 302: sc->sc_eoflag = 0; ! 303: return (0); ! 304: } ! 305: sc->sc_size = sip->si_cc; ! 306: sc->sc_bufptr = sip->si_ma; ! 307: if (arcmd(sc, func)) ! 308: return (-1); ! 309: return (sip->si_cc); ! 310: } ! 311: ! 312: /* ! 313: * Begin execution of a device command for the device pointed to by ! 314: * sc. The command begins execution in state newstate. ! 315: * ! 316: * This is HARDWARE oriented software. It doesn't know or care of ! 317: * state of buffers, etc. Its result reflects what the hardware is ! 318: * doing, not what the software is doing. ! 319: * ! 320: * The device is assumed to be in one of the FIN or IDLE states: ! 321: * IDLEstate, FINstate, READfin, READidle, WRfin, or WRidle. ! 322: * This is a requirement, since various fields in sc have already ! 323: * been set up for us, and the use of those fields would conflict ! 324: * with their use by the interrupt routine if we weren't idle or fin. ! 325: * ! 326: * Our result is: ! 327: * 0 if the operation completed normally ! 328: * 1 if the operation completed abnormally ! 329: * ! 330: */ ! 331: arcmd(sc, cmd) ! 332: register struct ar_softc *sc; ! 333: { ! 334: struct ardevice *araddr = sc->sc_addr; ! 335: ! 336: if (!sc->sc_opened) ! 337: return (-1); ! 338: ! 339: sc->sc_state = ar_cmds[cmd]; ! 340: ! 341: for (;;) { ! 342: if (araddr->arexc) { ! 343: /* ! 344: * This interrupt is from the true level of arexc. ! 345: * ! 346: * An error has occurred. Deal with it somehow. ! 347: * If we are reading status, just do it; else do our own ! 348: * RDST to find out the problem, and cancel the current ! 349: * operation. ! 350: */ ! 351: if (sc->sc_state == RDSTinit) ! 352: goto doit; ! 353: Dprintf("ar*intr arexc set, old state %x\n", sc->sc_state); ! 354: sc->sc_oldstate = sc->sc_state; ! 355: sc->sc_state = RDSTinit; ! 356: /* ! 357: * Clear EdgeReady and enable it so the next arrdy ! 358: * edge will be caught (possibly inside armachine()). ! 359: */ ! 360: araddr->arcatch = 0; ! 361: araddr->arcatch = 1; ! 362: while (!armachine(sc)) { ! 363: /* Shouldn't happen! */ ! 364: printf("ar*intr RDST did not return 1\n"); ! 365: } ! 366: if (!sc->sc_status.FileMark) { ! 367: printf("ar: error %x\n", ! 368: *(u_short *)&sc->sc_status); ! 369: return (1); ! 370: } ! 371: /* Eof signaled now means that NEXT block is an EOF. */ ! 372: sc->sc_eoflag = 1; ! 373: return (0); ! 374: } ! 375: if (araddr->arrdy) { ! 376: ! 377: doit: ! 378: araddr->arcatch = 0; ! 379: araddr->arcatch = 1; ! 380: if (armachine(sc)) ! 381: return (0); ! 382: } ! 383: } ! 384: } ! 385: ! 386: /* ! 387: * State machine for archive tape drive controller. ! 388: * This actually accomplishes things w.r.t. the tape drive. ! 389: * Returns 0 if operation still in progress, 1 if finished. ! 390: * Note that we may take further interrupts after claiming that an ! 391: * operation is "finished". For example, we say a write is done when ! 392: * we have transferred the last byte of the block; but there will be ! 393: * an interrupt 5.5ms later to tell us it's ok to send the next block. ! 394: * Eventually, we will rewind the tape asynchronously after the file is ! 395: * closed, letting the user go free while it spins. FIXME: THIS CANNOT ! 396: * BE DONE until we clean up the high level code so it doesn't clobber ! 397: * our variables as it is setting up to call arstart_cmd(). ! 398: */ ! 399: armachine(sc) ! 400: register struct ar_softc *sc; ! 401: { ! 402: register struct ardevice *araddr = sc->sc_addr; ! 403: register int count, i, x; ! 404: register char *byteptr; ! 405: ! 406: Dprintf("ar*machine(%x, %x) state %x\n", sc, araddr, sc->sc_state); ! 407: ! 408: switch (sc->sc_state) { ! 409: ! 410: case CMDOKinit: ! 411: /* ! 412: * If we got here the command state is ok, ! 413: * i.e., not in the middle of a read or write. ! 414: */ ! 415: sc->sc_state = IDLEstate; ! 416: sc->sc_cmdok = 1; ! 417: return (1); ! 418: ! 419: case CLOSEinit: ! 420: /* FIXME, this is time dependent and not documented in ! 421: the Archive manual */ ! 422: araddr->aronline = 0; /* Drop online; we're done. */ ! 423: if (araddr->arrdy) ! 424: goto IdleState; /* No interrupt will occur. */ ! 425: else ! 426: goto FinState; /* Rewinding; wait for interrupt. */ ! 427: ! 428: #ifdef FIXME ! 429: case CLOSEend: ! 430: /* This is entered from READidle or WRidle. */ ! 431: araddr->aronline = 0; /* Drop it, causing rewind. */ ! 432: goto FinState; /* Interrupt will signal end of rew. */ ! 433: #endif ! 434: ! 435: case WFMinit: ! 436: sc->sc_status.BOT = 0; ! 437: araddr->ardata = ARCMD_WREOF; ! 438: araddr->arreq = 1; ! 439: goto CmdState; ! 440: ! 441: case RFMinit: ! 442: araddr->ardata = ARCMD_RDEOF; ! 443: araddr->arreq = 1; ! 444: goto CmdState; ! 445: ! 446: case REWinit: ! 447: araddr->ardata = ARCMD_REWIND; ! 448: araddr->arreq = 1; ! 449: goto CmdState; ! 450: ! 451: case TENSEinit: ! 452: araddr->ardata = ARCMD_TENSION; ! 453: araddr->arreq = 1; ! 454: goto CmdState; ! 455: ! 456: case ERASEinit: ! 457: araddr->ardata = ARCMD_ERASE; ! 458: araddr->arreq = 1; ! 459: goto CmdState; ! 460: ! 461: case SELinit: ! 462: araddr->ardata = ARCMD_LED | (1 << sc->sc_drive); ! 463: araddr->arreq = 1; ! 464: goto CmdState; ! 465: ! 466: case DESELinit: ! 467: araddr->ardata = 1 << sc->sc_drive; ! 468: araddr->arreq = 1; ! 469: goto CmdState; ! 470: ! 471: RDSTagain: ! 472: printf("ar: RDST gave Exception, retrying\n"); ! 473: /* Fall thru... */ ! 474: ! 475: case RDSTinit: ! 476: byteptr = (char *) &sc->sc_status; ! 477: ! 478: /* We could have either arrdy or arexc; remember which */ ! 479: count = 0; ! 480: if (araddr->arrdy) ! 481: count = 1; ! 482: araddr->ardata = ARCMD_RDSTAT; ! 483: araddr->arreq = 1; ! 484: ! 485: /* ! 486: * Now wait for arrdy indicating command accepted. ! 487: * Check for Exception, if we started with arrdy. ! 488: * (It's not legal to do RDST all the time(!).) ! 489: */ ! 490: while (!araddr->arrdy) ! 491: if (count && araddr->arexc) ! 492: goto RDSTagain; ! 493: ! 494: /* Negate arreq, wait for arrdy to drop. */ ! 495: araddr->arcatch = 0; /* Clear arrdyedge */ ! 496: araddr->arcatch = 1; /* Catch edge */ ! 497: araddr->arreq = 0; ! 498: ! 499: /* Now xfer a byte or six. */ ! 500: do { ! 501: /* Wait for edge of arrdy */ ! 502: while (!araddr->arrdyedge) ! 503: if (araddr->arexc) ! 504: goto RDSTagain; ! 505: *byteptr++ = araddr->ardata; ! 506: araddr->arcatch = 0; /* Clear edge indicator */ ! 507: araddr->arcatch = 1; /* Catch next one */ ! 508: araddr->arreq = 1; /* Tell controller we have it */ ! 509: /* Ready will fall within 250ns of our arreq, but ! 510: we're supposed to keep it high for 20us */ ! 511: DELAY(30); /* at least 20 usec */ ! 512: araddr->arreq = 0; ! 513: } while (byteptr < ! 514: (char *)(&sc->sc_status) + sizeof (sc->sc_status)); ! 515: /* ! 516: * On exit from this loop, arcatch has been negated and ! 517: * asserted, so it will correctly reflect the leading edge ! 518: * of arrdy for the next command. ! 519: */ ! 520: sc->sc_oldstate = sc->sc_state; ! 521: sc->sc_state = FINstate; /* Awaiting final interrupt */ ! 522: ! 523: /* Dump status bytes after a command AR_STATUS */ ! 524: ! 525: Dprintf("ar*RDST %b %d %d\n", *(unsigned short*)&sc->sc_status, ! 526: ar_stat_bits, sc->sc_status.SoftErrs, sc->sc_status.TapeStops); ! 527: ! 528: /* This code is obsolete since sc_qidle, and should be replaceable ! 529: by a simple branch to RdWrFin. However, that doesn't work, so ! 530: try this. JCGnu, 23Nov82 */ ! 531: while (!araddr->arrdy) ! 532: if (araddr->arexc) ! 533: goto RDSTagain; ! 534: /* We leave the edge of Ready caught in EdgeReady, but IdleState will ! 535: disable interrupts on it. */ ! 536: goto IdleState; ! 537: ! 538: case READcmd: ! 539: case WRcmd: ! 540: araddr->arreq = 0; ! 541: goto next; ! 542: ! 543: case READinit: ! 544: araddr->ardata = ARCMD_RDDATA; ! 545: araddr->arreq = 1; ! 546: goto next; ! 547: ! 548: case READburst: ! 549: /* Read a block of data from the tape drive. */ ! 550: Dprintf("ar*READ addr %x count %x\n", sc->sc_bufptr, sc->sc_size); ! 551: sc->sc_status.BOT = 0; ! 552: while (!araddr->arrdy) { ! 553: if (araddr->arexc) ! 554: return (0); /* Not yet done */ ! 555: Dprintf("ar*Read no READY\n"); ! 556: } ! 557: araddr->arburst = 1; /* Begin block xfer */ ! 558: count = min(sc->sc_size, AR_BSIZE); ! 559: byteptr = sc->sc_bufptr; ! 560: for (i=0; i<count; i++) ! 561: *byteptr++ = araddr->ardata; /* read data */ ! 562: for (; i<AR_BSIZE; i++) ! 563: x = araddr->ardata; /* read junk */ ! 564: araddr->arburst = 0; ! 565: sc->sc_oldstate = sc->sc_state; ! 566: sc->sc_state = READfin; /* Like FINstate sorta */ ! 567: break; ! 568: ! 569: case WRinit: ! 570: araddr->ardata = ARCMD_WRDATA; ! 571: araddr->arreq = 1; ! 572: goto next; ! 573: ! 574: case WRburst: ! 575: /* Write a block of data to the tape drive. */ ! 576: Dprintf("ar*WRITE addr %x count %x\n", sc->sc_bufptr, sc->sc_size); ! 577: while (!araddr->arrdy) { ! 578: if (araddr->arexc) ! 579: return (0); /* Not done yet */ ! 580: Dprintf("ar*Write no READY\n"); ! 581: } ! 582: araddr->arburst = 1; /* Begin block xfer */ ! 583: count = AR_BSIZE; ! 584: byteptr = sc->sc_bufptr; ! 585: while (count--) ! 586: araddr->ardata = *byteptr++; ! 587: araddr->arburst = 0; ! 588: sc->sc_oldstate = sc->sc_state; ! 589: sc->sc_state = WRfin; /* Like FINstate sorta */ ! 590: Dprintf("ar*machine exiting done in state %x\n", sc->sc_state); ! 591: /* ! 592: * This code is a copy of the code at the end of this ! 593: * switch statement, except that it returns 1 (operation ! 594: * completed) instead of 0 (more needs doing) ! 595: */ ! 596: araddr->arrdyie = 1; ! 597: araddr->arexcie = 1; ! 598: return (1); ! 599: ! 600: case CMDstate: ! 601: /* All commands that stop interacting once you say "do it" */ ! 602: araddr->arreq = 0; /* Done with command */ ! 603: goto FinState; /* Final interaction for this cmd */ ! 604: ! 605: IdleState: /* Drive is idle; set IDLEstate and disable */ ! 606: sc->sc_oldstate = sc->sc_state; ! 607: sc->sc_state = IDLEstate; ! 608: goto DisAble; ! 609: ! 610: case WRfin: /* Entry after writing a block */ ! 611: case READfin: /* Entry after reading a block */ ! 612: case FINstate: /* Entry after any other command */ ! 613: /* ! 614: * Go to next sequential state - WRidle, READidle, IDLEstate. ! 615: * Disable interrupts, and return. arstart_cmd() will later ! 616: * put us into READ/WRburst or some commandinit state. ! 617: */ ! 618: sc->sc_oldstate = sc->sc_state; ! 619: sc->sc_state = (enum ARstates)(1 +(int)sc->sc_state); ! 620: DisAble: ! 621: Dprintf("ar*machine idling\n"); ! 622: araddr->arrdyie = 0; /* Negate arrdy interrupt */ ! 623: return (1); /* Tell caller op is done */ ! 624: ! 625: case WRidle: /* Writing blocks, but none to write now */ ! 626: case READidle: /* Reading blocks, but don't need one now */ ! 627: case IDLEstate: /* Issuing commands, but don't have one now */ ! 628: /* This can only happen if software triggers us. */ ! 629: printf("ar: triggerred at idle %x\n", sc->sc_state); ! 630: goto DisAble; /* Turn off interrupt enable again */ ! 631: ! 632: default: ! 633: printf("ar: invalid state %d\n", sc->sc_state); ! 634: goto FinState; /* Is this reasonable? */ ! 635: ! 636: next: ! 637: /* Go to next sequential state */ ! 638: sc->sc_oldstate = sc->sc_state; ! 639: sc->sc_state = (enum ARstates)(1 +(int)sc->sc_state); ! 640: break; ! 641: ! 642: FinState: ! 643: sc->sc_oldstate = sc->sc_state; ! 644: sc->sc_state = FINstate; ! 645: break; ! 646: ! 647: CmdState: ! 648: sc->sc_oldstate = sc->sc_state; ! 649: sc->sc_state = CMDstate; ! 650: break; ! 651: ! 652: } ! 653: ! 654: Dprintf("ar*machine exiting in state %x\n", sc->sc_state); ! 655: ! 656: /* Go to next state on the next leading edge of arrdy. */ ! 657: araddr->arrdyie = 1; /* Interrupt on arrdy leading edge */ ! 658: araddr->arexcie = 1; /* Interrupt on arexc too */ ! 659: /* FIXME. Figure out where to set and unset, leave alone otherwise. */ ! 660: ! 661: return (0); ! 662: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.