![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to wt.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1991 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)wt.c 7.1 (Berkeley) 5/9/91 ! 34: */ ! 35: ! 36: /* ! 37: * ! 38: * Copyright (c) 1989 Carnegie-Mellon University. ! 39: * All rights reserved. ! 40: * ! 41: * Authors: Robert Baron ! 42: * ! 43: * Permission to use, copy, modify and distribute this software and ! 44: * its documentation is hereby granted, provided that both the copyright ! 45: * notice and this permission notice appear in all copies of the ! 46: * software, derivative works or modified versions, and any portions ! 47: * thereof, and that both notices appear in supporting documentation. ! 48: * ! 49: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 50: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND ! 51: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 52: * ! 53: * Carnegie Mellon requests users of this software to return to ! 54: * ! 55: * Software Distribution Coordinator or [email protected] ! 56: * School of Computer Science ! 57: * Carnegie Mellon University ! 58: * Pittsburgh PA 15213-3890 ! 59: * ! 60: * any improvements or extensions that they make and grant Carnegie the ! 61: * rights to redistribute these changes. ! 62: */ ! 63: ! 64: #include "wt.h" ! 65: #if NWT > 0 ! 66: /* ! 67: * HISTORY ! 68: * $Log: wt.c,v $ ! 69: * Revision 2.2.1.3 90/01/08 13:29:38 rvb ! 70: * Add Intel copyright. ! 71: * [90/01/08 rvb] ! 72: * ! 73: * Revision 2.2.1.2 89/12/21 18:00:09 rvb ! 74: * Change WTPRI to make the streamer tape read/write ! 75: * interruptible. [lin] ! 76: * ! 77: * Revision 2.2.1.1 89/11/10 09:49:49 rvb ! 78: * ORC likes their streamer port at 0x288. ! 79: * [89/11/08 rvb] ! 80: * ! 81: * Revision 2.2 89/09/25 12:33:02 rvb ! 82: * Driver was provided by Intel 9/18/89. ! 83: * [89/09/23 rvb] ! 84: * ! 85: */ ! 86: ! 87: /* ! 88: * ! 89: * Copyright 1988, 1989 by Intel Corporation ! 90: * ! 91: * Support Bell Tech QIC-02 and WANGTEK QIC-36 or QIC-02 ! 92: */ ! 93: ! 94: /*#include <sys/errno.h> ! 95: #include <sys/signal.h> ! 96: #include <sys/types.h>*/ ! 97: #include "sys/param.h" ! 98: #include "sys/buf.h" ! 99: #include "sys/file.h" ! 100: #include "sys/proc.h" ! 101: #include "sys/user.h" ! 102: #include "i386/isa/wtreg.h" ! 103: ! 104: #ifdef ORC ! 105: unsigned wtport = 0x288; /* base I/O port of controller */ ! 106: #else ORC ! 107: unsigned wtport = 0x300; /* base I/O port of controller */ ! 108: #endif ORC ! 109: /* standard = 0x300 */ ! 110: /* alternate = 0x338 */ ! 111: ! 112: unsigned wtchan = 1; /* DMA channel number */ ! 113: /* stardard = 1 */ ! 114: /* hardware permits 1, 2 or 3. */ ! 115: /* (Avoid DMA 2: used by disks) */ ! 116: ! 117: int first_wtopen_ever = 1; ! 118: ! 119: ! 120: #define ERROR 1 /* return from tape routines */ ! 121: #define SUCCESS 0 /* return from tape routines */ ! 122: ! 123: int wci = 0; ! 124: int exflag = 0; ! 125: int bytes = 0; ! 126: ! 127: static unsigned char eqdma = 0x8; ! 128: static unsigned char pagereg = 0x83; ! 129: static unsigned char dmareg = 2; ! 130: static unsigned char dma_write = 0x49; ! 131: static unsigned char dma_read = 0x45; ! 132: static unsigned char dma_done = 2; ! 133: static unsigned char mode = 0; ! 134: static unsigned char mbits; /* map bits into each other */ ! 135: static long bufptr; ! 136: static unsigned numbytes; ! 137: /* ! 138: _wci dw 0 ; interrupt chain finished normally ! 139: _exflag dw 0 ; exception variable ! 140: _bytes dw 0 ; current bytes ! 141: ! 142: eqdma db 8h ; enable dma command: ch1,ch2=8h, ch3=10h ! 143: pagereg db 83h ; ch1=83h, ch2=81h, ch3=82h ! 144: dmareg db 2 ; ch1=2, ch2=4, ch3=6 ! 145: dma_write db 49h ; write dma command: 48h+_wtchan ! 146: dma_read db 45h ; read dma command: 44h+_wtchan ! 147: dma_done db 2 ; dma done flag: 1<<_wtchan ! 148: mode db 0 ; dma operation mode ! 149: lbufptr dw 0 ; buffer pointer to data buffers, low word ! 150: hbufptr dw 0 ; buffer pointer to data buffers, high word ! 151: numbytes dw 0 ; number of bytes to read or write (new) ! 152: */ ! 153: ! 154: #define PAGESIZ 4096 ! 155: #define HZ 60 ! 156: ! 157: /* tape controller ports */ ! 158: #define STATPORT wtport ! 159: #define CTLPORT STATPORT ! 160: #define CMDPORT (wtport+1) ! 161: #define DATAPORT CMDPORT ! 162: ! 163: /* defines for reading out status from wangtek tape controller */ ! 164: #define READY 0x01 /* ready bit define */ ! 165: #define EXCEP 0x02 /* exception bit define */ ! 166: #define STAT (READY|EXCEP) ! 167: #define RESETMASK 0x7 ! 168: #define RESETVAL (RESETMASK & ~EXCEP) ! 169: ! 170: /* tape controller control bits (CTLPORT) */ ! 171: #define ONLINE 0x01 ! 172: #define RESET 0x02 ! 173: #define REQUEST 0x04 /* request command */ ! 174: #define CMDOFF 0xC0 ! 175: ! 176: /* QIC-02 commands (CMDPORT) */ ! 177: #define RDDATA 0x80 /* read data */ ! 178: #define READFM 0xA0 /* read file mark */ ! 179: #define WRTDATA 0x40 /* write data */ ! 180: #define WRITEFM 0x60 /* write file mark */ ! 181: #define RDSTAT 0xC0 /* read status command */ ! 182: #define REWIND 0x21 /* rewind command (position+bot) */ ! 183: ! 184: /* 8237 DMA controller regs */ ! 185: #define STATUSREG 0x8 ! 186: #define MASKREG 0xA ! 187: #define MODEREG 0xB ! 188: #define CLEARFF 0xC ! 189: ! 190: /* streamer tape block size */ ! 191: #define BLKSIZE 512 ! 192: ! 193: /* Tape characteristics */ ! 194: #define NBPS 512 /* 512-byte blocks */ ! 195: #define ERROR 1 /* return from tape routines */ ! 196: #define SUCCESS 0 /* return from tape routines */ ! 197: ! 198: /* Minor devs */ ! 199: #define TP_REWCLOSE(d) ((minor(d)&04) == 0) /* Rewind tape on close if read/write */ ! 200: #define TP_DENS(dev) ((minor(dev) >> 3) & 03) /* set density */ ! 201: #define TPHOG(d) 0 /* use Hogproc during tape I/O */ ! 202: ! 203: /* defines for wtflags */ ! 204: #define TPINUSE 0x0001 /* tape is already open */ ! 205: #define TPREAD 0x0002 /* tape is only open for reading */ ! 206: #define TPWRITE 0x0004 /* tape is only open for writing */ ! 207: #define TPSTART 0x0008 /* tape must be rewound and reset */ ! 208: #define TPDEAD 0x0010 /* tape drive does not work or driver error */ ! 209: #define TPSESS 0x0020 /* no more reads or writes allowed in session */ ! 210: /* for example, when tape has to be changed */ ! 211: #define TPSTOP 0x0040 /* Stop command outstanding */ ! 212: #define TPREW 0x0080 /* Rewind command outstanding, see wtdsl2() */ ! 213: #define TPVOL 0x0100 /* Read file mark, or hit end of tape */ ! 214: #define TPWO 0x0200 /* write command outstanding */ ! 215: #define TPRO 0x0400 /* read command outstanding */ ! 216: #define TPWANY 0x0800 /* write command requested */ ! 217: #define TPRANY 0x1000 /* read command requested */ ! 218: #define TPWP 0x2000 /* write protect error seen */ ! 219: ! 220: unsigned int wtflags = TPSTART; /* state of tape drive */ ! 221: ! 222: struct buf rwtbuf; /* header for raw i/o */ ! 223: struct proc *myproc; /* process which opened tape driver */ ! 224: ! 225: char wtimeron; /* wtimer() active flag */ ! 226: char wtio; /* dma (i/o) active flag */ ! 227: char isrlock; /* isr() flag */ ! 228: ! 229: struct proc * Hogproc; /* no Hogproc on Microport */ ! 230: #define ftoseg(x) ((unsigned) (x >> 16)) ! 231: ! 232: struct wtstatus { ! 233: ushort wt_err; /* code for error encountered */ ! 234: ushort wt_ercnt; /* number of error blocks */ ! 235: ushort wt_urcnt; /* number of underruns */ ! 236: } wterror; ! 237: ! 238: /* defines for wtstatus.wt_err */ ! 239: #define TP_POR 0x100 /* Power on/reset occurred */ ! 240: #define TP_RES1 0x200 /* Reserved for end of media */ ! 241: #define TP_RES2 0x400 /* Reserved for bus parity */ ! 242: #define TP_BOM 0x800 /* Beginning of media */ ! 243: #define TP_MBD 0x1000 /* Marginal block detected */ ! 244: #define TP_NDT 0x2000 /* No data detected */ ! 245: #define TP_ILL 0x4000 /* Illegal command */ ! 246: #define TP_ST1 0x8000 /* Status byte 1 bits */ ! 247: #define TP_FIL 0x01 /* File mark detected */ ! 248: #define TP_BNL 0x02 /* Bad block not located */ ! 249: #define TP_UDA 0x04 /* Unrecoverable data error */ ! 250: #define TP_EOM 0x08 /* End of media */ ! 251: #define TP_WRP 0x10 /* Write protected cartridge */ ! 252: #define TP_USL 0x20 /* Unselected drive */ ! 253: #define TP_CNI 0x40 /* Cartridge not in place */ ! 254: #define TP_ST0 0x80 /* Status byte 0 bits */ ! 255: ! 256: /* Grounds for reporting I/O error to user */ ! 257: #define TP_ERR0 (TP_BNL|TP_UDA|TP_WRP|TP_CNI|TP_FIL|TP_EOM|TP_USL) ! 258: #define TP_ERR1 (TP_MBD|TP_NDT|TP_ILL) ! 259: /* TP_ILL should never happen! */ ! 260: /* ! 261: #define TP_ERR0 0x7f ! 262: #define TP_ERR1 0x7700 ! 263: */ ! 264: ! 265: /* defines for reading out status from wangtek tape controller */ ! 266: #define READY 0x01 /* ready bit define */ ! 267: #define EXCEP 0x02 /* exception bit define */ ! 268: ! 269: /* sleep priority */ ! 270: #define WTPRI (PZERO+10) ! 271: ! 272: char pagebuf[NBPS]; /* buffer of size NBPS */ ! 273: unsigned long pageaddr; /* physical addr of pagebuf */ ! 274: /* pageaddr is used with DMA controller */ ! 275: time_t Hogtime; /* lbolt when Hog timer started */ ! 276: extern time_t lbolt; ! 277: ! 278: #define debug printf ! 279: ! 280: /* ! 281: * Strategy routine. ! 282: * ! 283: * Arguments: ! 284: * Pointer to buffer structure ! 285: * Function: ! 286: * Start transfer. ! 287: * ! 288: * It would be nice to have this multiple-threaded. ! 289: * There is a version of dump from Berkeley that works with multiple processes ! 290: * trading off with disk & tape I/O. ! 291: */ ! 292: ! 293: int ! 294: wtstrategy(bp) ! 295: register struct buf *bp; ! 296: { ! 297: unsigned ucnt1, ucnt2, finished; ! 298: unsigned long adr1, adr2; ! 299: int bad; ! 300: ! 301: adr1 = kvtop(bp->b_un.b_addr); ! 302: #ifdef DEBUG ! 303: debug("bpaddr %x\n", adr1); ! 304: #endif ! 305: ucnt1 = bp->b_bcount; ! 306: ucnt2 = 0; ! 307: adr2 = 0; ! 308: #ifdef DEBUG ! 309: debug("WTstart: adr1 %lx cnt %x\n", adr1, ucnt1); ! 310: #endif ! 311: if (ftoseg(adr1) != ftoseg(adr1 + (unsigned) ucnt1 - 1)) ! 312: { ! 313: adr2 = (adr1 & 0xffff0000L) + 0x10000L; ! 314: ucnt2 = (adr1 + ucnt1) - adr2; ! 315: ucnt1 -= ucnt2; ! 316: } ! 317: /* at file marks and end of tape, we just return '0 bytes available' */ ! 318: if (wtflags & TPVOL) { ! 319: bp->b_resid = bp->b_bcount; ! 320: goto xit; ! 321: } ! 322: if ((Hogproc == (struct proc *) 0) && TPHOG(bp->b_dev)) ! 323: { ! 324: #ifdef DEBUG ! 325: printf("setting Hogproc\n"); ! 326: #endif ! 327: Hogtime = 0; ! 328: Hogproc = myproc; ! 329: } ! 330: if (bp->b_flags & B_READ) { ! 331: bad = 0; ! 332: ! 333: /* For now, we assume that all data will be copied out */ ! 334: /* If read command outstanding, just skip down */ ! 335: if (!(wtflags & TPRO)) { ! 336: if (ERROR == wtsense(TP_WRP)) /* clear status */ ! 337: goto errxit; ! 338: #ifdef DEBUG ! 339: debug("WTread: Start read\n"); ! 340: #endif ! 341: if (!(wtflags & TPREAD) || (wtflags & TPWANY) || ! 342: (rstart() == ERROR)) { ! 343: #ifdef DEBUG ! 344: debug("Tpstart: read init error\n"); /* */ ! 345: #endif ! 346: goto errxit; ! 347: } ! 348: wtflags |= TPRO|TPRANY; ! 349: } ! 350: ! 351: finished = 0; ! 352: /* Take a deep breath */ ! 353: if (ucnt1) { ! 354: if ((rtape(adr1, ucnt1) == ERROR) && ! 355: (wtsense(TP_WRP) == ERROR)) ! 356: goto endio; ! 357: /* wait for it */ ! 358: bad = pollrdy(); ! 359: finished = bytes; ! 360: if (bad) ! 361: goto endio; ! 362: } ! 363: /* if a second I/O region, start it */ ! 364: if (ucnt2) { ! 365: if ((rtape(adr2, ucnt2) == ERROR) && ! 366: (wtsense(TP_WRP) == ERROR)) ! 367: ucnt2 = 0; /* don't poll for me */ ! 368: } ! 369: ! 370: /* if second i/o pending wait for it */ ! 371: if (ucnt2) { ! 372: pollrdy(); ! 373: /* whether pollrdy is ok or not */ ! 374: finished += bytes; ! 375: } ! 376: } else { ! 377: if (wtflags & TPWP) /* write protected */ ! 378: goto errxit; ! 379: ! 380: /* If write command outstanding, just skip down */ ! 381: if (!(wtflags & TPWO)) { ! 382: if (ERROR == wtsense(0)) /* clear status */ ! 383: { ! 384: #ifdef DEBUG ! 385: debug("TPstart: sense 0\n"); ! 386: #endif ! 387: goto errxit; ! 388: } ! 389: if (!(wtflags & TPWRITE) || (wtflags & TPRANY) || ! 390: (wstart() == ERROR)) { ! 391: #ifdef DEBUG ! 392: debug("Tpstart: write init error\n"); /* */ ! 393: #endif ! 394: wtsense(0); ! 395: ! 396: errxit: bp->b_flags |= B_ERROR; ! 397: bp->b_resid = bp->b_bcount; ! 398: goto xit; ! 399: } ! 400: wtflags |= TPWO|TPWANY; ! 401: } ! 402: ! 403: /* and hold your nose */ ! 404: if (ucnt1 && ((wtape(adr1, ucnt1) == ERROR) ! 405: && (wtsense(0) == ERROR))) ! 406: finished = bytes; ! 407: ! 408: else if (ucnt2 && ! 409: (((ucnt1 && pollrdy()) || ! 410: (wtape(adr2, ucnt2) == ERROR)) && ! 411: (wtsense(0) == ERROR))) ! 412: finished = ucnt1 + NBPS + bytes; ! 413: /* All writes and/or copyins were fine! */ ! 414: else ! 415: finished = bp->b_bcount; ! 416: bad = pollrdy(); ! 417: } ! 418: ! 419: endio: ! 420: if(bad == EIO) bad = 0; ! 421: wterror.wt_err = 0; ! 422: if (exflag && wtsense((bp->b_flags & B_READ) ? TP_WRP : 0)) { ! 423: if ((wterror.wt_err & TP_ST0) ! 424: && (wterror.wt_err & (TP_FIL|TP_EOM))) { ! 425: #ifdef DEBUG ! 426: debug("WTsta: Hit end of tape\n"); /* */ ! 427: #endif ! 428: wtflags |= TPVOL; ! 429: if (wterror.wt_err & TP_FIL) { ! 430: if (wtflags & TPRO) ! 431: /* interrupter is bogus */ ! 432: rstart(); /* restart read command */ ! 433: else ! 434: wtflags &= ~TPWO; ! 435: finished += NBPS; ! 436: } ! 437: /* Reading file marks or writing end of tape return 0 bytes */ ! 438: } else { ! 439: bp->b_flags |= B_ERROR; ! 440: wtflags &= ~(TPWO|TPRO); ! 441: } ! 442: } ! 443: ! 444: if(bad) { ! 445: bp->b_flags |= B_ERROR; ! 446: bp->b_error = bad; ! 447: } ! 448: bp->b_resid = bp->b_bcount - finished; ! 449: xit: ! 450: biodone(bp); ! 451: if (wtimeron) ! 452: Hogtime = lbolt; ! 453: else if (Hogproc == myproc) ! 454: Hogproc = (struct proc *) 0; ! 455: } ! 456: ! 457: /* ! 458: * simulate an interrupt periodically while I/O is going ! 459: * this is necessary in case interrupts get eaten due to ! 460: * multiple devices on a single IRQ line ! 461: */ ! 462: wtimer() ! 463: { ! 464: /* If I/O going and not in isr(), simulate interrupt ! 465: * If no I/O for at least 1 second, stop being a Hog ! 466: * If I/O done and not a Hog, turn off wtimer() ! 467: */ ! 468: if (wtio && !isrlock) ! 469: isr(); ! 470: ! 471: if ((Hogproc == myproc) && Hogtime && (lbolt-Hogtime > HZ)) ! 472: Hogproc = (struct proc *) 0; ! 473: ! 474: if (wtio || (Hogproc == myproc)) ! 475: timeout(wtimer, (caddr_t) 0, HZ); ! 476: else ! 477: wtimeron = 0; ! 478: } ! 479: ! 480: ! 481: wtrawio(bp) ! 482: struct buf *bp; ! 483: { ! 484: wtstrategy(bp); ! 485: biowait(bp); ! 486: return(0); ! 487: } ! 488: ! 489: wt_minphys(bp) ! 490: struct buf *bp; ! 491: { ! 492: if (bp->b_bcount > PAGESIZ) ! 493: bp->b_bcount = PAGESIZ; ! 494: } ! 495: ! 496: /* ! 497: * raw read routine ! 498: */ ! 499: wtread(dev, uio) ! 500: struct uio *uio; ! 501: { ! 502: if (wtflags & TPSESS) { ! 503: return(EIO); ! 504: } ! 505: physio(wtrawio, &rwtbuf, dev, B_READ, wt_minphys, uio); ! 506: return(0); ! 507: } ! 508: ! 509: /* ! 510: * raw write routine ! 511: */ ! 512: wtwrite(dev, uio) ! 513: struct uio *uio; ! 514: { ! 515: if (wtflags & TPSESS) { ! 516: return(EIO); ! 517: } ! 518: physio(wtrawio, &rwtbuf, dev, B_WRITE, wt_minphys, uio); ! 519: return(0); ! 520: } ! 521: ! 522: ! 523: ! 524: /* ! 525: * ioctl routine ! 526: * for user level QIC commands only ! 527: */ ! 528: wtioctl(dev, cmd, arg, mode) ! 529: int dev, cmd; ! 530: unsigned long arg; ! 531: int mode; ! 532: { ! 533: if (cmd == WTQICMD) ! 534: { ! 535: if ((qicmd((int)arg) == ERROR) || (rdyexc(HZ) == ERROR)) ! 536: { ! 537: wtsense(0); ! 538: return(EIO); ! 539: } ! 540: return(0); ! 541: } ! 542: return(EINVAL); ! 543: } ! 544: ! 545: /* ! 546: * open routine ! 547: * called on every device open ! 548: */ ! 549: wtopen(dev, flag) ! 550: int dev, flag; ! 551: { ! 552: if (first_wtopen_ever) { ! 553: wtinit(); ! 554: first_wtopen_ever = 0; ! 555: } ! 556: #ifdef DEBUG ! 557: printf("wtopen ...\n"); ! 558: #endif ! 559: if (!pageaddr) { ! 560: return(ENXIO); ! 561: } ! 562: if (wtflags & (TPINUSE)) { ! 563: return(ENXIO); ! 564: } ! 565: if (wtflags & (TPDEAD)) { ! 566: return(EIO); ! 567: } ! 568: /* If a rewind from the last session is going on, wait */ ! 569: while(wtflags & TPREW) { ! 570: #ifdef DEBUG ! 571: debug("Waiting for rew to finish\n"); ! 572: #endif ! 573: delay(1000000); /* delay one second */ ! 574: } ! 575: /* Only do reset and select when tape light is off, and tape is rewound. ! 576: * This allows multiple volumes. */ ! 577: if (wtflags & TPSTART) { ! 578: if (t_reset() != SUCCESS) { ! 579: return(ENXIO); ! 580: } ! 581: #ifdef DEBUG ! 582: debug("reset done. calling wtsense\n"); ! 583: #endif ! 584: if (wtsense(TP_WRP) == ERROR) { ! 585: return (EIO); ! 586: } ! 587: #ifdef DEBUG ! 588: debug("wtsense done\n"); ! 589: #endif ! 590: wtflags &= ~TPSTART; ! 591: } ! 592: ! 593: wtflags = TPINUSE; ! 594: if (flag & FREAD) ! 595: wtflags |= TPREAD; ! 596: if (flag & FWRITE) ! 597: wtflags |= TPWRITE; ! 598: rwtbuf.b_flags = 0; ! 599: myproc = curproc; /* for comparison */ ! 600: switch(TP_DENS(dev)) { ! 601: case 0: ! 602: cmds(0x28); ! 603: break; ! 604: case 1: ! 605: cmds(0x29); ! 606: break; ! 607: case 2: ! 608: cmds(0x27); ! 609: break; ! 610: case 3: ! 611: cmds(0x24); ! 612: } ! 613: return(0); ! 614: } ! 615: ! 616: /* ! 617: * close routine ! 618: * called on last device close ! 619: * If not rewind-on-close, leave read or write command intact. ! 620: */ ! 621: wtclose(dev) ! 622: { ! 623: int wtdsl2(); ! 624: ! 625: #ifdef DEBUG ! 626: debug("WTclose:\n"); ! 627: #endif ! 628: if (Hogproc == myproc) ! 629: Hogproc = (struct proc *) 0; ! 630: if (!exflag && (wtflags & TPWANY) && !(wtflags & (TPSESS|TPDEAD))) { ! 631: if (!(wtflags & TPWO)) ! 632: wstart(); ! 633: #ifdef DEBUG ! 634: debug("WT: Writing file mark\n"); ! 635: #endif ! 636: wmark(); /* write file mark */ ! 637: #ifdef DEBUG ! 638: debug("WT: Wrote file mark, going to wait\n"); ! 639: #endif ! 640: if (rdyexc(HZ/10) == ERROR) { ! 641: wtsense(0); ! 642: } ! 643: } ! 644: if (TP_REWCLOSE(dev) || (wtflags & (TPSESS|TPDEAD))) { ! 645: /* rewind tape to beginning of tape, deselect tape, and make a note */ ! 646: /* don't wait until rewind, though */ ! 647: /* Ending read or write causes rewind to happen, if no error, ! 648: * and READY and EXCEPTION stay up until it finishes */ ! 649: if (wtflags & (TPRO|TPWO)) ! 650: { ! 651: #ifdef DEBUG ! 652: debug("End read or write\n"); ! 653: #endif ! 654: rdyexc(HZ/10); ! 655: ioend(); ! 656: wtflags &= ~(TPRO|TPWO); ! 657: } ! 658: else wtwind(); ! 659: wtflags |= TPSTART | TPREW; ! 660: timeout(wtdsl2, 0, HZ); ! 661: } ! 662: else if (!(wtflags & (TPVOL|TPWANY))) ! 663: { ! 664: /* space forward to after next file mark no writing done */ ! 665: /* This allows skipping data without reading it.*/ ! 666: #ifdef DEBUG ! 667: debug("Reading past file mark\n"); ! 668: #endif ! 669: if (!(wtflags & TPRO)) ! 670: rstart(); ! 671: rmark(); ! 672: if (rdyexc(HZ/10)) ! 673: { ! 674: wtsense(TP_WRP); ! 675: } ! 676: } ! 677: wtflags &= TPREW|TPDEAD|TPSTART|TPRO|TPWO; ! 678: return(0); ! 679: } ! 680: ! 681: /* return ERROR if user I/O request should receive an I/O error code */ ! 682: ! 683: wtsense(ignor) ! 684: { ! 685: wtflags &= ~(TPRO|TPWO); ! 686: #ifdef DEBUGx ! 687: debug("WTsense: start "); ! 688: #endif ! 689: if (rdstatus(&wterror) == ERROR) ! 690: { ! 691: #ifdef DEBUG ! 692: debug("WTsense: Can't read status\n"); ! 693: #endif ! 694: return(ERROR); ! 695: } ! 696: #ifdef DEBUG ! 697: if (wterror.wt_err & (TP_ST0|TP_ST1)) ! 698: { ! 699: debug("Tperror: status %x error %d underruns %d\n", ! 700: wterror.wt_err, wterror.wt_ercnt, wterror.wt_urcnt); ! 701: } ! 702: else ! 703: debug("done. no error\n"); ! 704: #endif ! 705: wterror.wt_err &= ~ignor; /* ignore certain errors */ ! 706: reperr(wterror.wt_err); ! 707: if (((wterror.wt_err & TP_ST0) && (wterror.wt_err & TP_ERR0)) || ! 708: ((wterror.wt_err & TP_ST1) && (wterror.wt_err & TP_ERR1))) ! 709: return ERROR; ! 710: ! 711: return SUCCESS; ! 712: } ! 713: ! 714: /* lifted from tdriver.c from Wangtek */ ! 715: reperr(srb0) ! 716: int srb0; ! 717: { ! 718: int s0 = srb0 & (TP_ERR0|TP_ERR1); /* find out which exception to report */ ! 719: ! 720: if (s0) { ! 721: if (s0 & TP_USL) ! 722: sterr("Drive not online"); ! 723: else if (s0 & TP_CNI) ! 724: sterr("No cartridge"); ! 725: else if ((s0 & TP_WRP) && !(wtflags & TPWP)) ! 726: { ! 727: sterr("Tape is write protected"); ! 728: wtflags |= TPWP; ! 729: } ! 730: /* ! 731: if (s0 & TP_FIL) ! 732: sterr("Filemark detected"); ! 733: */ ! 734: else if (s0 & TP_BNL) ! 735: sterr("Block in error not located"); ! 736: else if (s0 & TP_UDA) ! 737: sterr("Unrecoverable data error"); ! 738: /* ! 739: else if (s0 & TP_EOM) ! 740: sterr("End of tape"); ! 741: */ ! 742: else if (s0 & TP_NDT) ! 743: sterr("No data detected"); ! 744: /* ! 745: if (s0 & TP_POR) ! 746: sterr("Reset occured"); ! 747: */ ! 748: else if (s0 & TP_BOM) ! 749: sterr("Beginning of tape"); ! 750: else if (s0 & TP_ILL) ! 751: sterr("Illegal command"); ! 752: } ! 753: } ! 754: ! 755: sterr(errstr) ! 756: char *errstr; ! 757: { ! 758: printf("Streamer: %s\n", errstr); ! 759: } ! 760: ! 761: /* Wait until rewind finishes, and deselect drive */ ! 762: wtdsl2() { ! 763: int stat; ! 764: ! 765: stat = inb(wtport) & (READY|EXCEP); ! 766: #ifdef DEBUG ! 767: debug("Timeout: Waiting for rewind to finish: stat %x\n", stat); ! 768: #endif ! 769: switch (stat) { ! 770: /* They're active low, ya'know */ ! 771: case READY|EXCEP: ! 772: timeout(wtdsl2, (caddr_t) 0, HZ); ! 773: return; ! 774: case EXCEP: ! 775: wtflags &= ~TPREW; ! 776: return; ! 777: case READY: ! 778: case 0: ! 779: wtflags &= ~TPREW; ! 780: sterr("Rewind failed"); ! 781: wtsense(TP_WRP); ! 782: return; ! 783: } ! 784: } ! 785: ! 786: wtwind() { ! 787: #ifdef DEBUG ! 788: debug("WT: About to rewind\n"); ! 789: #endif ! 790: rwind(); /* actually start rewind */ ! 791: } ! 792: ! 793: wtintr(unit) { ! 794: if (wtflags & (TPWO|TPRO)) ! 795: { ! 796: isrlock = 1; ! 797: if (wtio) isr(); ! 798: isrlock = 0; ! 799: } ! 800: } ! 801: ! 802: wtinit() { ! 803: if (wtchan < 1 || wtchan > 3) ! 804: { ! 805: sterr("Bad DMA channel, cannot init driver"); ! 806: return; ! 807: } ! 808: wtlinit(); /* init assembly language variables */ ! 809: pageset(); ! 810: } ! 811: ! 812: rdyexc(ticks) ! 813: { ! 814: int s; ! 815: #ifdef DEBUG ! 816: int os = 0xffff; /* force printout first time */ ! 817: #endif ! 818: for (;;) { /* loop until ready or exception */ ! 819: s=(inb(wtport) & 0xff); /* read the status register */ ! 820: #ifdef DEBUG ! 821: if (os != s) { ! 822: debug("Status reg = %x\n", s); /* */ ! 823: os = s; ! 824: } ! 825: #endif ! 826: if (!(s & EXCEP)) /* check if exception have occured */ ! 827: break; ! 828: if (!(s & READY)) /* check if controller is ready */ ! 829: break; ! 830: s = splbio(); ! 831: delay((ticks/HZ)*1000000); /* */ ! 832: splx(s); ! 833: } ! 834: #ifdef DEBUG ! 835: debug("Status reg = %x on return\n", s); /* */ ! 836: #endif ! 837: return((s & EXCEP)?SUCCESS:ERROR); /* return exception if it occured */ ! 838: } ! 839: ! 840: pollrdy() ! 841: { ! 842: int sps; ! 843: #ifdef DEBUG ! 844: debug("Pollrdy\n"); ! 845: #endif ! 846: sps = splbio(); ! 847: while (wtio) { ! 848: int error; ! 849: ! 850: if (error = tsleep((caddr_t)&wci, WTPRI | PCATCH, ! 851: "wtpoll", 0)) { ! 852: splx(sps); ! 853: return(error); ! 854: } ! 855: } ! 856: splx(sps); ! 857: #ifdef DEBUG ! 858: debug("Finish poll, wci %d exflag %d\n", wci, exflag); ! 859: #endif ! 860: return (EIO); ! 861: } ! 862: ! 863: wtdma() /* start up i/o operation, called from dma() in wtlib1.s */ ! 864: { ! 865: wtio = 1; ! 866: if (!wtimeron) ! 867: { ! 868: wtimeron = 1; ! 869: timeout(wtimer, (caddr_t) 0, HZ/2); ! 870: } ! 871: } ! 872: ! 873: wtwake() /* end i/o operation, called from isr() in wtlib1.s */ ! 874: { ! 875: wtio = 0; ! 876: wakeup(&wci); ! 877: } ! 878: ! 879: pageset() ! 880: { ! 881: unsigned long pp; ! 882: ! 883: pp = (unsigned long) pagebuf; ! 884: pageaddr = kvtop(pp); ! 885: #ifdef DEBUG ! 886: debug("pageset: addr %lx\n", pageaddr); ! 887: #endif ! 888: } ! 889: ! 890: ! 891: ! 892: #define near ! 893: ! 894: static near ! 895: sendcmd() ! 896: { ! 897: /* desired command in global mbits */ ! 898: ! 899: outb(CTLPORT, mbits | REQUEST); /* set request */ ! 900: while (inb(STATPORT) & READY); /* wait for ready */ ! 901: outb(CTLPORT, mbits & ~REQUEST); /* reset request */ ! 902: while ((inb(STATPORT) & READY) == 0); /* wait for not ready */ ! 903: } ! 904: ! 905: static near /* execute command */ ! 906: cmds(cmd) ! 907: { ! 908: register s; ! 909: ! 910: do s = inb(STATPORT); ! 911: while ((s & STAT) == STAT); /* wait for ready */ ! 912: ! 913: if ((s & EXCEP) == 0) /* if exception */ ! 914: return ERROR; /* error */ ! 915: ! 916: outb(CMDPORT, cmd); /* output the command */ ! 917: ! 918: outb(CTLPORT, mbits=ONLINE); /* set & send ONLINE */ ! 919: sendcmd(); ! 920: ! 921: return SUCCESS; ! 922: } ! 923: ! 924: qicmd(cmd) ! 925: { ! 926: return cmds(cmd); ! 927: } ! 928: ! 929: rstart() ! 930: { ! 931: return cmds(RDDATA); ! 932: } ! 933: ! 934: rmark() ! 935: { ! 936: return cmds(READFM); ! 937: } ! 938: ! 939: wstart() ! 940: { ! 941: return cmds(WRTDATA); ! 942: } ! 943: ! 944: ioend() ! 945: { ! 946: register s; ! 947: register rval = SUCCESS; ! 948: ! 949: do s = inb(STATPORT); ! 950: while ((s & STAT) == STAT); /* wait for ready */ ! 951: ! 952: if ((s & EXCEP) == 0) /* if exception */ ! 953: rval = ERROR; /* error */ ! 954: ! 955: mbits &= ~ONLINE; ! 956: outb(CTLPORT, mbits); /* reset ONLINE */ ! 957: outb(MASKREG, wtchan+4); /* turn off dma */ ! 958: outb(CLEARFF, 0); /* reset direction flag */ ! 959: ! 960: return rval; ! 961: } ! 962: ! 963: wmark() ! 964: { ! 965: register s; ! 966: ! 967: if (cmds(WRITEFM) == ERROR) ! 968: return ERROR; ! 969: ! 970: do s = inb(STATPORT); ! 971: while ((s & STAT) == STAT); /* wait for ready */ ! 972: ! 973: if ((s & EXCEP) == 0) /* if exception */ ! 974: return ERROR; /* error */ ! 975: ! 976: return SUCCESS; ! 977: } ! 978: ! 979: rwind() ! 980: { ! 981: register s; ! 982: ! 983: mbits = CMDOFF; ! 984: ! 985: do s = inb(STATPORT); ! 986: while ((s & STAT) == STAT); /* wait for ready */ ! 987: ! 988: outb(CMDPORT, REWIND); ! 989: sendcmd(); ! 990: ! 991: return SUCCESS; ! 992: } ! 993: ! 994: rdstatus(stp) ! 995: char *stp; /* pointer to 6 byte buffer */ ! 996: { ! 997: register s; ! 998: int n; ! 999: ! 1000: do s = inb(STATPORT); ! 1001: while ((s & STAT) == STAT); /* wait for ready or exception */ ! 1002: ! 1003: outb(CMDPORT, RDSTAT); ! 1004: sendcmd(); /* send read status command */ ! 1005: ! 1006: for (n=0; n<6; n++) ! 1007: { ! 1008: #ifdef DEBUGx ! 1009: debug("rdstatus: waiting, byte %d\n", n); ! 1010: #endif ! 1011: do s = inb(STATPORT); ! 1012: while ((s & STAT) == STAT); /* wait for ready */ ! 1013: #ifdef DEBUGx ! 1014: debug("rdstatus: done\n"); ! 1015: #endif ! 1016: if ((s & EXCEP) == 0) /* if exception */ ! 1017: return ERROR; /* error */ ! 1018: ! 1019: *stp++ = inb(DATAPORT); /* read status byte */ ! 1020: ! 1021: outb(CTLPORT, mbits | REQUEST); /* set request */ ! 1022: #ifdef DEBUGx ! 1023: debug("rdstatus: waiting after request, byte %d\n", n); ! 1024: #endif ! 1025: while ((inb(STATPORT)&READY) == 0); /* wait for not ready */ ! 1026: for (s=100; s>0; s--); /* wait an additional time */ ! 1027: ! 1028: outb(CTLPORT, mbits & ~REQUEST);/* unset request */ ! 1029: #ifdef DEBUGx ! 1030: debug("rdstatus: done\n"); ! 1031: #endif ! 1032: } ! 1033: return SUCCESS; ! 1034: } ! 1035: ! 1036: t_reset() ! 1037: { ! 1038: register i; ! 1039: mbits |= RESET; ! 1040: outb(CTLPORT, mbits); /* send reset */ ! 1041: delay(20); ! 1042: mbits &= ~RESET; ! 1043: outb(CTLPORT, mbits); /* turn off reset */ ! 1044: if ((inb(STATPORT) & RESETMASK) == RESETVAL) ! 1045: return SUCCESS; ! 1046: return ERROR; ! 1047: } ! 1048: ! 1049: static ! 1050: dma() ! 1051: { ! 1052: int x=splbio(); ! 1053: wtdma(); ! 1054: outb(CLEARFF, 0); ! 1055: outb(MODEREG, mode); /* set dma mode */ ! 1056: outb(dmareg, bufptr & 0xFF); ! 1057: outb(dmareg, (bufptr>>8) & 0xFF); ! 1058: outb(pagereg, (bufptr>>16) & 0xFF); ! 1059: outb(dmareg+1, (BLKSIZE-1) & 0xFF); ! 1060: outb(dmareg+1, (BLKSIZE-1) >> 8); ! 1061: outb(wtport, eqdma+ONLINE); ! 1062: outb(MASKREG, wtchan); /* enable command to 8237, start dma */ ! 1063: splx(x); ! 1064: } ! 1065: ! 1066: static near ! 1067: wtstart(buf, cnt) ! 1068: long buf; ! 1069: int cnt; ! 1070: { ! 1071: register s; ! 1072: ! 1073: bufptr = buf; /* init statics */ ! 1074: numbytes = cnt; ! 1075: wci = 0; /* init flags */ ! 1076: exflag = 0; ! 1077: bytes = 0; /* init counter */ ! 1078: ! 1079: do s = inb(STATPORT) & STAT; ! 1080: while (s == STAT); /* wait for ready or error */ ! 1081: ! 1082: if (s & EXCEP) /* no error */ ! 1083: { ! 1084: dma(); ! 1085: return SUCCESS; ! 1086: } ! 1087: return ERROR; /* error */ ! 1088: } ! 1089: ! 1090: rtape(buf, cnt) ! 1091: long buf; /* physical address */ ! 1092: int cnt; /* number of bytes */ ! 1093: { ! 1094: mode = dma_read; ! 1095: return wtstart(buf,cnt); ! 1096: } ! 1097: ! 1098: wtape(buf, cnt) ! 1099: long buf; /* physical address */ ! 1100: int cnt; /* number of bytes */ ! 1101: { ! 1102: mode = dma_write; ! 1103: return wtstart(buf,cnt); ! 1104: } ! 1105: ! 1106: isr() ! 1107: { ! 1108: int stat = inb(wtport); ! 1109: if (!(stat & EXCEP)) /* exception during I/O */ ! 1110: { ! 1111: if (bytes + BLKSIZE >= numbytes) wci = 1; ! 1112: exflag = 1; ! 1113: goto isrwake; ! 1114: } ! 1115: if ((stat & READY) || !(inb(STATUSREG) & dma_done)) ! 1116: return; ! 1117: exflag = 0; ! 1118: outb(wtport, ONLINE); ! 1119: bytes += BLKSIZE; ! 1120: if (bytes >= numbytes) /* normal completion of I/O */ ! 1121: { ! 1122: wci = 1; ! 1123: isrwake: ! 1124: outb(MASKREG, 4+wtchan); /* turn off dma */ ! 1125: wtwake(); /* wake up user level */ ! 1126: } ! 1127: else ! 1128: { /* continue I/O */ ! 1129: bufptr += BLKSIZE; ! 1130: dma(); ! 1131: } ! 1132: } ! 1133: ! 1134: wtlinit() ! 1135: { ! 1136: switch (wtchan) { ! 1137: case 1: ! 1138: return; ! 1139: case 2: ! 1140: pagereg = 0x81; ! 1141: dma_done = 4; ! 1142: break; ! 1143: case 3: ! 1144: eqdma = 0x10; ! 1145: pagereg = 0x82; ! 1146: dma_done = 8; ! 1147: break; ! 1148: } ! 1149: dma_write = wtchan+0x48; ! 1150: dma_read = wtchan+0x44; ! 1151: dmareg = wtchan+wtchan; ! 1152: } ! 1153: ! 1154: /* ! 1155: * delay i microseconds ! 1156: */ ! 1157: delay(i) ! 1158: register int i; ! 1159: { ! 1160: while (i-- > 0) ! 1161: DELAY(1000); ! 1162: } ! 1163: ! 1164: wtsize() ! 1165: { ! 1166: } ! 1167: ! 1168: wtdump() ! 1169: { ! 1170: } ! 1171: ! 1172: #include "i386/isa/isa_device.h" ! 1173: #include "i386/isa/icu.h" ! 1174: ! 1175: int wtprobe(), wtattach(); ! 1176: struct isa_driver wtdriver = { ! 1177: wtprobe, wtattach, "wt", ! 1178: }; ! 1179: ! 1180: wtprobe(dvp) ! 1181: struct isa_device *dvp; ! 1182: { ! 1183: int val,i,s; ! 1184: ! 1185: #ifdef lint ! 1186: wtintr(0); ! 1187: #endif ! 1188: ! 1189: wtport = dvp->id_iobase; ! 1190: if(t_reset() != SUCCESS) return(0); ! 1191: return(1); ! 1192: } ! 1193: ! 1194: wtattach() { } ! 1195: ! 1196: #endif NWT
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.