![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xlft.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / io.386|
Return to xlft.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / io.386 |
1.1 ! root 1: #define MWC_FT 1 ! 2: ! 3: /* ! 4: * File: xlft.c ! 5: * ! 6: * Purpose: Floppy tape device control. ! 7: * Inspired by the Archive "xl" driver. ! 8: * Requires 765 controller module fdc.c ! 9: * FDC = floppy disk controller, e.g. NEC upd765 ! 10: * ! 11: * Revised: Tue Jun 1 19:16:37 1993 CDT ! 12: */ ! 13: ! 14: /* ! 15: * Here is the protocol for QIC report commands, I think: ! 16: * ! 17: * Send QIC report command to FDC (this will be an FDC seek command). ! 18: * FDC interrupts when step pulses are sent. ! 19: * Send Sense Interrupt Status to FDC. (Clears interrupt line.) ! 20: * Read interrupt status from FDC. ! 21: * - Get ACK from tape drive. Want Track 0 true. Variable latency. ! 22: * Do ! 23: * Send Sense Drive Status to FDC. ! 24: * Read drive status from FDC, including Track 0 bit. ! 25: * Until Track 0 true. ! 26: * - Get data bits for the report command. ! 27: * For number-of-data-bits-in-report times ! 28: * Send QIC Report Next Bit command to FDC. ! 29: * FDC interrupts when step pulses are sent. ! 30: * Send Sense Interrupt Status to FDC. ! 31: * Read interrupt status from FDC. ! 32: * Send Sense Drive Status to FDC. ! 33: * Read drive status from FDC, including Track 0 bit. ! 34: * Save Track 0 bit value into report data. ! 35: * End for ! 36: * - Get final Track 0 true from tape drive. ! 37: * Send QIC Report Next Bit command to FDC. ! 38: * FDC interrupts when step pulses are sent. ! 39: * Send Sense Interrupt Status to FDC. ! 40: * Read interrupt status from FDC. ! 41: * Send Sense Drive Status to FDC. ! 42: * Read drive status from FDC, including Track 0 bit. ! 43: * Track 0 bit must be true. ! 44: */ ! 45: ! 46: /* ! 47: * ---------------------------------------------------------------------- ! 48: * Includes. ! 49: */ ! 50: #include <sys/coherent.h> ! 51: ! 52: #include <errno.h> ! 53: #include <sys/buf.h> ! 54: #include <sys/con.h> ! 55: #include <sys/devices.h> ! 56: #include <sys/fdc765.h> ! 57: #include <sys/fdioctl.h> ! 58: #include <sys/inode.h> ! 59: #include <sys/sched.h> ! 60: #include <sys/stat.h> ! 61: #include <sys/xl.h> ! 62: #include <sys/xlfdc.h> ! 63: #include <sys/xlft.h> ! 64: #include <sys/xl8237.h> ! 65: ! 66: /* ! 67: * ---------------------------------------------------------------------- ! 68: * Definitions. ! 69: * Constants. ! 70: * Macros with argument lists. ! 71: * Typedefs. ! 72: * Enums. ! 73: */ ! 74: #define HDRSZ 0x4000 /* 16k, size of qic-40 header */ ! 75: #define BFRSZ 0x8000 /* 32k, size of qic-40 buffer */ ! 76: ! 77: #define MAX_PCN 200 ! 78: ! 79: /* compatibility area */ ! 80: ! 81: #define bcopy(src, dest, nbytes) memcpy(dest, src, nbytes) ! 82: #define copyin(userSrc, drvrDest, nbytes) \ ! 83: ukcopy(userSrc, drvrDest, nbytes) ! 84: #define copyout(drvrSrc, userDest, nbytes) \ ! 85: kucopy(drvrSrc, userDest, nbytes) ! 86: #define getfdc(unit) setFtIntr(1) ! 87: #define getfdcn(unit) setFtIntr(1) ! 88: #define kvtophys(vaddr) vtop(vaddr) ! 89: #define relfdc() setFtIntr(0) ! 90: #define sleep(address, priority) \ ! 91: x_sleep(address, pritape, slpriSigLjmp, #address) ! 92: #define spl5() sphi() ! 93: #define splx(lvl) spl(lvl) ! 94: #define tenmicrosec() busyWait2(NULL, 12) ! 95: ! 96: static void cmn_err(); ! 97: ! 98: enum { ! 99: CE_CONT = 0, /* used to continue a previous message */ ! 100: CE_NOTE, /* used to display a NOTICE: message */ ! 101: CE_WARN, /* used to display a WARNING: message */ ! 102: CE_PANIC, /* used to display a PANIC: message */ ! 103: CE_INVALID /* used to warn about invalid severity */ ! 104: }; ! 105: ! 106: /************************************************************************/ ! 107: /* Additional fdc equates */ ! 108: /************************************************************************/ ! 109: ! 110: #define FDTMO 65535 /* xlfdc_in_byte, xlfdc_out_byte timeout*/ ! 111: #define IOTMO (12 * HZ) /* io timeout */ ! 112: #define TMSKP 18 /* # segments missed if IOTMO */ ! 113: ! 114: #define FT_ACK_TRIES 5 /* max # of tries for ACK to QIC rpt cmd*/ ! 115: ! 116: /* ! 117: * ---------------------------------------------------------------------- ! 118: * Functions. ! 119: * Import Functions. ! 120: * Export Functions. ! 121: * Local Functions. ! 122: */ ! 123: extern int nulldev(); ! 124: ! 125: extern int xl_tbi(); /* init ecc tables */ ! 126: extern int xl_enc(); /* encode ecc data */ ! 127: extern int xl_dec(); /* decode ecc data */ ! 128: ! 129: /* CON entry points. */ ! 130: static int ftblock(); ! 131: static int ftclose(); ! 132: static int ftioctl(); ! 133: static int ftload(); ! 134: static int ftopen(); ! 135: static int ftread(); ! 136: static int ftunload(); ! 137: static int ftwrite(); ! 138: ! 139: static int getmem(); ! 140: static int putrb(); ! 141: static struct rb *getrb(); ! 142: static void stdma(); ! 143: static void strbfm(); /* set up rb for format */ ! 144: static void strbsg(); ! 145: static void stseg(); ! 146: static void wvtbl(); ! 147: ! 148: static void xlcal(), xlcal0(), (*pfcal)(); /* calibrate */ ! 149: static void xlcomplete(); ! 150: static void xldelay(), (*pfdly)(); /* "delay" */ ! 151: static void xldma(); ! 152: static unchar xlfdc_in_byte(); ! 153: static unchar xlfdc_out_byte(); ! 154: static unchar xlfdc_out_str(); ! 155: static void xlfdc_reset(); ! 156: static void xlflush(); ! 157: static void xlfmq(), xlfmq0(), xlfmq1(), xlfmq2(); /* format queue */ ! 158: static void xlfms(), xlfm0(), (*pffms)(); /* format segment */ ! 159: static int xlformat(); /* format main routine */ ! 160: static void xlgtdat(); ! 161: static void xlhalt(), (*pfhlt)(); /* halt tape motion */ ! 162: static void xlintr(), (*pfint)(); /* xl2 ptr to intr handler */ ! 163: static void xlnull(); ! 164: static int xlopn(); ! 165: static void xloutput_step(); /* output steps, exit=pfint */ ! 166: static void xlpark(), (*pfprk)(); ! 167: static void xlpark0(), xlpark1(), xlpark2(); ! 168: static void xlpos(), xlpos0(), xlpos1(), xlpos2(), xlpos3(), (*pfpos)(); ! 169: static void xlptdat(); ! 170: static void xlque(), xlqr0(), xlqw0(); ! 171: static void xlrds(), xlrd0(), xlrd1(), (*pfrds)(); /* read segment */ ! 172: static void xlreadid(), xlreadid0(), (*pfrdi)(); /* read id */ ! 173: static void xlready(), xlready0(), (*pfrdy)(); /* "wait" for ready */ ! 174: static void xlrel(); ! 175: static void xlreset(), xlreset0(), (*pfrst)(); /* reset drive */ ! 176: static void xlrn9(), xlrn17(); ! 177: static void xlrnb(), xlrnb0(), (*pfrnb)(); /* report next bits */ ! 178: static void xlrqr(); ! 179: static void xlseek(), (*pfsek)(); /* seek to tptrk */ ! 180: static void xlseek0(), xlseek1(); ! 181: static void xlsel(); ! 182: static void xlskipb(), (*pfskp)(); /* skip n segs back */ ! 183: static void xlskipb0(), xlskipb1(), xlskipb2(); ! 184: static void xlstatus(), (*pfsts)(); /* get status */ ! 185: static void xlstatus0(), xlstatus1(); ! 186: static void xltimout(), xltimfn(); ! 187: static int xlwait(); ! 188: static void xlwds(), (*pfwds)(); /* write del adm segment */ ! 189: static void xlwts(), (*pfwts)(); /* write segment */ ! 190: static void xlwt0(), xlwt1(); ! 191: ! 192: static void xlDbPrintErr(), xlDbPrintCmd(), xlDbPrintStat(); ! 193: ! 194: static void ftDbPrtStat(); ! 195: static int ftCmd(); ! 196: static void ftIrqHandler(); ! 197: static int ftRecal(); ! 198: static void ftResetFDC(); ! 199: static void ftRptBegin(); ! 200: static void ftRptUpdate(); ! 201: static void ftSelect(); ! 202: ! 203: /* ! 204: * ---------------------------------------------------------------------- ! 205: * Global Data. ! 206: * Import Variables. ! 207: * Export Variables. ! 208: * Local Variables. ! 209: */ ! 210: ! 211: /* from assembler module */ ! 212: extern ushort *xltbl; /* ptr to rb.tbl */ ! 213: extern unchar xlbst; /* base sector for segment */ ! 214: extern unchar xlsct; /* sector # for next chunk */ ! 215: extern int xlcnt; /* # bytes to xfer next chunk */ ! 216: extern int xlofs; /* offset for next chunk */ ! 217: ! 218: CON ftxlcon = { ! 219: DFCHR, /* Flags */ ! 220: FL_MAJOR, /* Major index */ ! 221: ftopen, /* Open */ ! 222: ftclose, /* Close */ ! 223: ftblock, /* Block */ ! 224: ftread, /* Read */ ! 225: ftwrite, /* Write */ ! 226: ftioctl, /* Ioctl */ ! 227: nulldev, /* Powerfail */ ! 228: nulldev, /* Timeout */ ! 229: ftload, /* Load */ ! 230: ftunload, /* Unload */ ! 231: nulldev /* Poll */ ! 232: }; ! 233: ! 234: /* ! 235: * Patchable variables. ! 236: */ ! 237: int XL_VERBOSE = 1; ! 238: int XL_NBUFS = 17; /* ~ 3K total 'DATA' for driver */ ! 239: /* 1.25K for ecc, + XL_NBUFS * 94 */ ! 240: ! 241: /* Parameters for FDC Specify Command */ ! 242: int FT_SRT = 0xE; ! 243: int FT_HUT = 0xF; ! 244: int FT_HLT = 0x1; ! 245: ! 246: /************************************************************************/ ! 247: /* UNIX data areas and externals */ ! 248: /************************************************************************/ ! 249: static ulong allocated_add; /* mem allocate addr for kernel buffer */ ! 250: ! 251: /************************************************************************/ ! 252: /* data area */ ! 253: /************************************************************************/ ! 254: static int xldataw; /* data queue wakeup flag */ ! 255: static int xlcompw; /* completion wakeup flag */ ! 256: static int xlfreew; /* free queue wakeup flag */ ! 257: static int xlcompf; /* completion flag */ ! 258: static int xlnactw; /* inactive wakeup flag */ ! 259: static int xlskip_count; /* # segments to skip */ ! 260: ! 261: static fplng ptr_header; /* ptr to header bfr */ ! 262: static fplng ptr_buffer; /* ptr to bfr */ ! 263: ! 264: static struct rb * rbmp; /* request packet pool */ ! 265: ! 266: static struct rbq xlfree_q; /* free queue */ ! 267: static struct rbq req; /* request queue */ ! 268: static struct rbq data_queue; /* read data queue */ ! 269: ! 270: static int xlmem_allocated = 0; /* set if memory allocated */ ! 271: ! 272: static struct { /* flags */ ! 273: unsigned short init :1; ! 274: unsigned short open :1; ! 275: unsigned short writ :1; ! 276: unsigned short cal :1; ! 277: unsigned short actv :1; ! 278: unsigned short tmov :1; ! 279: unsigned short werr :1; ! 280: }f; ! 281: ! 282: static int nseg_p_track; /* # segments/track */ ! 283: static int nseg_p_head; /* # segments/head */ ! 284: static int nseg_p_cyl; /* # segments/cylinder */ ! 285: ! 286: static int fdcmd; /* last fdc cmd */ ! 287: ! 288: static unchar status_buf[10]; /* status buffer */ ! 289: /* bytes 0-6 = 8272 status */ ! 290: /* 7 = nec phase err */ ! 291: /* 8 = 8272 st3 */ ! 292: ! 293: static ushort xlrnbw; /* xl2 report next bit word */ ! 294: static unchar xlster; /* set if last bit not a 1 */ ! 295: static unchar xl6sts; /* xl2 status */ ! 296: static unchar xlests; ! 297: static ushort xl7sts; ! 298: static int xlbcnt; /* xlrnb counter, # of sts bits */ ! 299: ! 300: static unchar fdstb[4] = { 0x1c, 0x2d, 0x4e, 0x8f }; ! 301: static unchar fdsel, unit, fdselr, ftfmt; ! 302: ! 303: static ushort sgwrd; /* strbsg params */ ! 304: static ulong sgmap; ! 305: ! 306: static paddr_t xadr; /* segment io params */ ! 307: static struct rb *xprb; ! 308: static ushort xtbl; ! 309: static int xsct; ! 310: static int xrty; ! 311: static int xstop; /* stop io flag (close) */ ! 312: ! 313: static int tptrk; /* current tape track */ ! 314: static int tpseg; /* next tape segment */ ! 315: static int fmtrk; /* format track */ ! 316: static int vftrk; /* verify track (debug display) */ ! 317: ! 318: static int xltimoutf = 0; /* timeout flag */ ! 319: ! 320: /* fdc commands */ ! 321: static unchar sf2cms[3] = { 0x03, 0xef, 0x02 }; ! 322: ! 323: static unchar sf3cms[3] = { 0x03, 0xdf, 0x02 }; ! 324: static unchar sekcms[3] = { 0x0f, 0x00, 0x00 }; ! 325: static unchar rdicms[2] = { 0x4a, 0x00 }; ! 326: static unchar rwdcms[9] = { 0x46, 0, 0, 0, 0, 3, 226, 1, 0xff }; ! 327: static unchar fmtcms[6] = { 0x4d, 0, 3, 32, 233, 0x6d }; ! 328: /* sekcms[2] = current track, see xlintr() */ ! 329: ! 330: static unchar vtbl[] = "VTBL"; ! 331: static unchar xnxnm[] = "unix"; ! 332: static unchar xnxvs[20] = { ! 333: 0x55, 0xaa, 0x55, 0xaa, 0x02, 0x00, 0x00, 0x00, ! 334: 0x01, 0x00, 0x02, 0x00, 0x4f, 0x05, 0x00, 0x00, ! 335: 0x00, 0x00, 0x00, 0x00 ! 336: }; ! 337: ! 338: static int h0sgn, h1sgn; /* header seg # */ ! 339: static int volume_seg_num; /* volume seg # */ ! 340: static int data_seg_num; /* data seg # */ ! 341: static int curr_seg_num; /* current seg # */ ! 342: static int read_ahead_seg_num; /* read ahead seg # */ ! 343: static struct rb *cprb; /* offset to current rb */ ! 344: static fpchr cptr; /* ptr to current bfr */ ! 345: static int cnbr; /* # bytes remaining */ ! 346: static fpchr wptr; /* copy of cptr for write encod */ ! 347: static int last_seg_num; /* last segment */ ! 348: static int lnbr; /* last seg # bytes */ ! 349: ! 350: static int rnbr; /* # requested bytes remaining */ ! 351: static int rcnt; /* # bytes to copy */ ! 352: ! 353: static struct rb *fprb; /* used to enque requests */ ! 354: ! 355: static TIM xltmo, xldly; ! 356: ! 357: static struct FT { ! 358: unchar ft_pcn; /* present cylinder # */ ! 359: unchar ft_bitsNeeded; /* # of Report Next Bit's to do */ ! 360: unchar ft_bitsRcvd; /* # of report bits received */ ! 361: unchar ft_wakeMeUp; /* 1 = sleeping til next FDC IRQ */ ! 362: unchar ft_dumpIrq; /* 1 = dump IRQ status */ ! 363: unchar ft_ackNeeded; /* 1 = awaiting ACK to rpt cmd */ ! 364: ushort ft_report; /* where reported bits go */ ! 365: TIM ft_tim; ! 366: } ft; ! 367: ! 368: /* ! 369: * ---------------------------------------------------------------------- ! 370: * Code. ! 371: */ ! 372: ! 373: /* ! 374: * CON struct routines. ! 375: */ ! 376: ! 377: /************************************************************************/ ! 378: /* ftblock */ ! 379: /* */ ! 380: /* Tape is not a block device, but we need a block entry point since */ ! 381: /* the same driver controls diskette access. */ ! 382: /************************************************************************/ ! 383: static int ! 384: ftblock(bp) ! 385: BUF *bp; ! 386: { ! 387: u.u_error = EIO; ! 388: bp->b_flag |= BFERR; ! 389: bdone(bp); ! 390: return; ! 391: } ! 392: ! 393: /************************************************************************ ! 394: * ftclose ! 395: * ! 396: ***********************************************************************/ ! 397: static int ! 398: ftclose(dev, mode) ! 399: dev_t dev; ! 400: int mode; ! 401: { ! 402: #if 1 ! 403: printf("ftclose "); ! 404: f.open = 0; ! 405: #else ! 406: if (f.open) { ! 407: /* f.open = 0; reset open flag U001 */ ! 408: xlflush(); /* flush all bfrs */ ! 409: if (f.werr) /* flag error if occurred */ ! 410: u.u_error = EIO; ! 411: ! 412: getfdc(unit); ! 413: xlsel(unit); ! 414: if (minor(dev) & M_REW) { /* rewind if rewind_on_close */ ! 415: pfprk = xlcomplete;/* clear drive status and rewind*/ ! 416: xlpark(); ! 417: xlwait(); ! 418: } else { ! 419: pfsts = xlcomplete; /* clear drive status */ ! 420: xlstatus(); ! 421: xlwait(); ! 422: } ! 423: xlrel(); ! 424: relfdc(); ! 425: f.open = 0; /* reset open flag U001 */ ! 426: cmn_err(CE_CONT, "xlclose: xlster %x f.werr %d\n", xlster, f.werr); ! 427: } ! 428: #endif ! 429: } ! 430: ! 431: /************************************************************************/ ! 432: /* ftioctl */ ! 433: /* Handle tape drive & controller commands like erase, rewind, */ ! 434: /* retension, read filemark, and write filemark */ ! 435: /************************************************************************/ ! 436: ftioctl(dev, cmd, arg) ! 437: register int dev, cmd; ! 438: int arg; ! 439: { ! 440: int xlarg; /* ioctl argument */ ! 441: union xl_status xl; /* status structure */ ! 442: ! 443: cmn_err(CE_CONT, "ftioctl: cmd %x\n", cmd); ! 444: ! 445: if ((cmd & 0xff00) != XLIOC) { ! 446: u.u_error = EINVAL; ! 447: return; ! 448: } ! 449: ! 450: getfdc(unit); /* get control of fdc */ ! 451: xlsel(unit); /* select tape drive */ ! 452: ! 453: switch (cmd) { ! 454: case XL_DEBUG: ! 455: if (copyin(arg, (caddr_t)&XL_VERBOSE, sizeof(int)) == -1) ! 456: u.u_error = EFAULT; ! 457: break; ! 458: case XL_STATUS: /* read status */ ! 459: /* ! 460: * Report current status, then clear ! 461: * any errors by reading the status again. ! 462: */ ! 463: xl.stat[0] = xl6sts; ! 464: xl.stat[1] = xl7sts; ! 465: xl.stat[2] = xl7sts >> 8; ! 466: ! 467: if (copyout(xl.stat, arg, sizeof(xl.stat)) == -1) ! 468: u.u_error = EFAULT; ! 469: else { ! 470: xlster = 0; ! 471: xlests = 0; ! 472: xl7sts = 0; ! 473: pfsts = xlcomplete; ! 474: xlstatus(); ! 475: xlwait(); ! 476: if (f.werr) /* flag error if occurred */ ! 477: u.u_error = EIO; ! 478: break; ! 479: ! 480: case XL_RESET: /* reset drive */ ! 481: pfrst = xlcomplete; ! 482: xlreset(); ! 483: xlwait(); ! 484: if (f.werr) /* flag error if occurred */ ! 485: u.u_error = EIO; ! 486: break; ! 487: ! 488: case XL_RETEN : /* retention tape */ ! 489: pfint = xlready; ! 490: pfrdy = xlcomplete; ! 491: xloutput_step(QIC_CMD_EOT); ! 492: xlwait(); ! 493: ! 494: pfint = xlready; ! 495: pfrdy = xlcomplete; ! 496: xloutput_step(QIC_CMD_BOT); ! 497: xlwait(); ! 498: if (xlster) ! 499: u.u_error = ENXIO; ! 500: ! 501: break; ! 502: ! 503: case XL_REWIND: /* rewind */ ! 504: pfint = xlready; ! 505: pfrdy = xlcomplete; ! 506: xloutput_step(QIC_CMD_BOT); ! 507: xlwait(); ! 508: if (xlster) ! 509: u.u_error = ENXIO; ! 510: break; ! 511: ! 512: case XL_ERASE: /* erase tape */ ! 513: break; ! 514: ! 515: case XL_AMOUNT: /* report amount of data xfered */ ! 516: /*if (copyout(&ct_amount, arg, sizeof(ct_amount)) == -1) ! 517: u.u_error = EFAULT;*/ ! 518: break; ! 519: ! 520: case XL_FORMAT: /* format tape */ ! 521: if (copyin(arg, (caddr_t) &xlarg, sizeof(int)) == -1) ! 522: u.u_error = EFAULT; ! 523: ! 524: else if ((xlarg >= 0 && xlarg <= 14 && ftfmt == 0) || ! 525: (xlarg >= 0 && xlarg <= 28 && ftfmt == 1)) { ! 526: xlformat(xlarg); ! 527: if (f.werr) /* flag err if occurred */ ! 528: u.u_error = EIO; ! 529: } else /* invalid track number */ ! 530: u.u_error = EINVAL; ! 531: } ! 532: break; ! 533: case XL_RFM: /* read file mark */ ! 534: ; /* not implemented */ ! 535: ! 536: default: ! 537: u.u_error = EINVAL; ! 538: break; ! 539: } ! 540: xlrel(); /* release fdc */ ! 541: relfdc(); ! 542: cmn_err(CE_CONT, "xlioctl: returning\n"); ! 543: } ! 544: ! 545: /************************************************************************/ ! 546: /* ftload */ ! 547: /************************************************************************/ ! 548: static int ! 549: ftload() ! 550: { ! 551: register int eflag; ! 552: register int s, t; ! 553: ! 554: #if MWC_FT ! 555: ftIntr = ftIrqHandler; ! 556: #else ! 557: ftIntr = xlintr; ! 558: #endif ! 559: ! 560: f.init = 0; /* reset flags */ ! 561: f.open = 0; ! 562: f.cal = 0; ! 563: f.actv = 0; ! 564: f.tmov = 0; ! 565: xlnactw = 0; ! 566: xlfreew = 0; ! 567: xldataw = 0; ! 568: xlcompw = 0; ! 569: xlcompf = 0; ! 570: xlster = 0; ! 571: status_buf[7] = 0; ! 572: pfint = xlnull; /* reset ptr to fun */ ! 573: xl_tbi(); /* init ecc tables */ ! 574: if(getmem()) ! 575: printf("XL: getmem() failed.\n"); ! 576: else ! 577: printf("Archive xl floppy tape driver v1.0 COH loaded\n"); ! 578: } ! 579: ! 580: /************************************************************************ ! 581: * ftopen ! 582: * ! 583: ***********************************************************************/ ! 584: static int ! 585: ftopen(dev, mode) ! 586: dev_t dev; ! 587: int mode; ! 588: { ! 589: unsigned int drvStat; ! 590: int i; ! 591: int bit; ! 592: int result; ! 593: ! 594: printf("ftopen %x ", dev); ! 595: ! 596: /* Can't append to tape. */ ! 597: if (mode & IPAPPEND) { ! 598: printf("can't append "); ! 599: u.u_error = EINVAL; ! 600: return; ! 601: } ! 602: ! 603: /* Only one open at a time. */ ! 604: if (f.open) { ! 605: printf("only one ftopen at a time "); ! 606: u.u_error = EBUSY; ! 607: return; ! 608: } ! 609: f.open = 1; ! 610: ! 611: unit = FT_UNIT(dev); /* set unit # */ ! 612: ! 613: if (! getfdcn(unit)) { /* get control of fdc */ ! 614: printf("fdc unavailable "); ! 615: u.u_error = EBUSY; /* exit if fdc is being used */ ! 616: f.open = 0; ! 617: return; ! 618: } ! 619: ! 620: #if MWC_FT ! 621: { ! 622: ftIntr = ftIrqHandler; ! 623: ! 624: /* Select tape drive. */ ! 625: /* ftSelect(unit); */ ! 626: fdcRate(FDC_RATE_500K); /* set transfer rate */ ! 627: fdcDrvSelect(unit, FDC_MOTOR_ON); /* 1=motor on */ ! 628: ! 629: /* Reset FDC and Initialize pseudo cylinder number for QIC commands. */ ! 630: ftResetFDC(unit); ! 631: ! 632: fdcSpecify(FT_SRT, FT_HUT, FT_HLT); ! 633: ! 634: /* 80 MB nseg_p_track = 100, nseg_p_head = 600, nseg_p_cyl = 4 */ ! 635: /* 40 MB nseg_p_track = 68, nseg_p_head = 680, nseg_p_cyl = 4 */ ! 636: if (ftfmt) { ! 637: nseg_p_track = 100; /* set for 80 MB drive */ ! 638: nseg_p_head = 600; ! 639: nseg_p_cyl = 4; ! 640: } else { ! 641: nseg_p_track = 68; /* set for 40 MB drive */ ! 642: nseg_p_head = 680; ! 643: nseg_p_cyl = 4; ! 644: } ! 645: ! 646: if (ftCmd(QIC_CMD_RST)) { ! 647: printf("soft reset failed "); ! 648: u.u_error = EIO; ! 649: f.open = 0; ! 650: setFtIntr(0); ! 651: return; ! 652: } ! 653: ! 654: printf("zzz "); ! 655: /* Now wait a second. */ ! 656: timeout(&ft.ft_tim, HZ, wakeup, &ft.ft_wakeMeUp); ! 657: x_sleep(&ft.ft_wakeMeUp, pritape, slpriSigCatch, "ftRstWt"); ! 658: printf("!! "); ! 659: ! 660: if (ftCmd(QIC_CMD_STS)) { ! 661: printf("get drive status failed "); ! 662: u.u_error = EIO; ! 663: f.open = 0; ! 664: setFtIntr(0); ! 665: return; ! 666: } ! 667: xlDbPrintStat(ft.ft_report); ! 668: ! 669: if (ftCmd(QIC_CMD_ECD)) { ! 670: printf("get error code failed "); ! 671: u.u_error = EIO; ! 672: f.open = 0; ! 673: setFtIntr(0); ! 674: return; ! 675: } ! 676: xlDbPrintErr(ft.ft_report); ! 677: ! 678: if (ftCmd(QIC_CMD_STS)) { ! 679: printf("get drive status failed "); ! 680: u.u_error = EIO; ! 681: f.open = 0; ! 682: setFtIntr(0); ! 683: return; ! 684: } ! 685: xlDbPrintStat(ft.ft_report); ! 686: ! 687: } ! 688: xlrel(); ! 689: relfdc(); ! 690: #else ! 691: xlsel(unit); ! 692: ! 693: if (0 == f.init) { /* init drive if 1st time */ ! 694: pfrst = xlcomplete; ! 695: xlreset(); ! 696: if (xlwait()) { ! 697: printf("init interrupted "); ! 698: u.u_error = EINTR; ! 699: f.open = 0; ! 700: relfdc(); ! 701: return; ! 702: } ! 703: f.init = 1; ! 704: } ! 705: ! 706: if (!xlopn(minor(dev))) { /* open drive */ ! 707: /* init current params */ ! 708: read_ahead_seg_num = curr_seg_num = data_seg_num; ! 709: cmn_err(CE_CONT, "xlopen: volume_seg_num %d data_seg_num %d last_seg_num %d lnbr %d\n", ! 710: volume_seg_num, data_seg_num, last_seg_num, lnbr); ! 711: ! 712: cnbr = 0; ! 713: xstop = 0; ! 714: f.writ = 0; ! 715: f.werr = 0; ! 716: } else { ! 717: printf("xlopn failed "); ! 718: u.u_error = ENODEV; /* set no device */ ! 719: f.open = 0; ! 720: } ! 721: xlrel(); /* release fdc */ ! 722: relfdc(); ! 723: cmn_err(CE_CONT, "xlopen: xlster %x, xl6sts %x, xlests %x, xl7sts %x\n", ! 724: xlster, xl6sts, xlests, xl7sts); ! 725: #endif ! 726: } ! 727: ! 728: /************************************************************************ ! 729: * ftread ! 730: * ! 731: ***********************************************************************/ ! 732: static int ! 733: ftread(dev, iop) ! 734: dev_t dev; ! 735: IO * iop; ! 736: { ! 737: if (!f.open) { /* exit if not open */ ! 738: u.u_error = EIO; ! 739: return; ! 740: } ! 741: xlgtdat(iop); ! 742: } ! 743: ! 744: /************************************************************************ ! 745: * ftunload ! 746: * ! 747: ***********************************************************************/ ! 748: static int ! 749: ftunload() ! 750: { ! 751: } ! 752: ! 753: /************************************************************************ ! 754: * ftwrite ! 755: * ! 756: ***********************************************************************/ ! 757: static int ! 758: ftwrite(dev, iop) ! 759: dev_t dev; ! 760: IO * iop; ! 761: { ! 762: if (!f.open) { /* exit if not open */ ! 763: u.u_error = EIO; ! 764: return; ! 765: } ! 766: if (xl6sts & XLSWRP) { /* exit if write protect */ ! 767: u.u_error = EIO; ! 768: return; ! 769: } ! 770: while(fprb = getrb(&data_queue))/* rel any pending read bfrs*/ ! 771: putrb(&xlfree_q, fprb);/* allows swt from read to write*/ ! 772: f.writ = 1; /* set write flag */ ! 773: xlptdat(iop); ! 774: if (f.werr) /* flag error if occurred */ ! 775: u.u_error = EIO; ! 776: } ! 777: ! 778: /* ! 779: * Support routines. ! 780: */ ! 781: ! 782: /************************************************************************/ ! 783: /* cmn_err() - doesn't really belong here */ ! 784: /************************************************************************/ ! 785: static void ! 786: cmn_err(level, format) ! 787: int level; ! 788: char * format; ! 789: { ! 790: if (XL_VERBOSE) ! 791: printf("%r ", &format); ! 792: } ! 793: ! 794: /************************************************************************/ ! 795: /* dsperr display floppy error */ ! 796: /************************************************************************/ ! 797: static int ! 798: dsperr() ! 799: { /* disregard fdc ecc error */ ! 800: if (!(status_buf[0] == 0x41 && ! 801: status_buf[1] == 0x20 && ! 802: status_buf[2] == 0x20)) ! 803: cmn_err(CE_CONT, "fdcerr: ST0=%x ST1=%x ST2=%x\n", ! 804: status_buf[0], status_buf[1], status_buf[2]); ! 805: } ! 806: ! 807: /* ! 808: * For debugging, print command status and interrupt status to console. ! 809: */ ! 810: static void ! 811: ftDbPrtStat() ! 812: { ! 813: int i; ! 814: ! 815: printf("[["); ! 816: if (fdc.fdc_ncmdstat) { ! 817: printf("cmd "); ! 818: for (i = 0; i < fdc.fdc_ncmdstat; i++) ! 819: printf("%x ", fdc.fdc_cmdstat[i]); ! 820: } ! 821: if (fdc.fdc_nintstat) { ! 822: printf("int "); ! 823: for (i = 0; i < fdc.fdc_nintstat; i++) ! 824: printf("%x ", fdc.fdc_intstat[i]); ! 825: } ! 826: printf("]] "); ! 827: } ! 828: ! 829: /* ! 830: * Given a QIC-117 command number, cause that number of step pulses ! 831: * to be sent from the FDC by faking a seek command. ! 832: */ ! 833: static int ! 834: ftCmdSend(cmd) ! 835: int cmd; ! 836: { ! 837: /* Like NEC - pcn=present cylinder #; ncn=new cylinder #. */ ! 838: unsigned char ncn; ! 839: ! 840: xlDbPrintCmd(cmd); ! 841: ! 842: /* ! 843: * Will fake a seek command. ! 844: * Figure out whether to simulate seek to lower or higher ! 845: * cylinder number. ! 846: */ ! 847: if (ft.ft_pcn + cmd <= MAX_PCN) { ! 848: ncn = ft.ft_pcn + cmd; ! 849: } else if (ft.ft_pcn - cmd >= 0) { ! 850: ncn = ft.ft_pcn - cmd; ! 851: } else { ! 852: printf("ftCmd %d invalid, pcn %d ", cmd, ft.ft_pcn); ! 853: return -1; ! 854: } ! 855: ! 856: ft.ft_dumpIrq = 1; ! 857: fdcSeek(unit, 0, ncn); ! 858: } ! 859: ! 860: /* ! 861: * Given a QIC-117 command number, send the command. ! 862: * If report bits are expected in response, initialize the bit counter. ! 863: * Then sleep until the commmand is done and report bits are gathered. ! 864: */ ! 865: static int ! 866: ftCmd(cmd) ! 867: int cmd; ! 868: { ! 869: int bitsNeeded; ! 870: ! 871: /* Will sleep until command done and report bits are in. */ ! 872: ft.ft_wakeMeUp = 1; ! 873: ! 874: /* ! 875: * The following commands expect report bits from the tape drive. ! 876: * After receiving the QIC command (and subsequent delay), ! 877: * the drive sends a leading ACK bit (always 1). This bit is ! 878: * not counted in the numbers below. ! 879: * Subseqeunt bits are sent in response to Report Next Bit, ! 880: * least significant bit first, then a trailing 1. ! 881: * The value of bitsNeeded is either one more than the number of ! 882: * data bits in the report, or zero. ! 883: ! 884: */ ! 885: switch(cmd) { ! 886: case QIC_CMD_STS: ! 887: case QIC_CMD_DRVCN: ! 888: case QIC_CMD_ROMVN: ! 889: case QIC_CMD_TPSTAT: ! 890: bitsNeeded = 9; ! 891: break; ! 892: case QIC_CMD_ECD: ! 893: case QIC_CMD_VNDID: ! 894: bitsNeeded = 17; ! 895: break; ! 896: default: ! 897: bitsNeeded = 0; ! 898: } ! 899: ftRptBegin(bitsNeeded); ! 900: ! 901: ftCmdSend(cmd); ! 902: ! 903: if (x_sleep(&ft.ft_wakeMeUp, pritape, slpriSigCatch, "ftCmd")) ! 904: /* Signal woke us prematurely. */ ! 905: return -1; ! 906: else { ! 907: return 0; ! 908: } ! 909: } ! 910: ! 911: /* ! 912: * Interrupt handler. ! 913: */ ! 914: static void ! 915: ftIrqHandler() ! 916: { ! 917: int i, bit, unit; ! 918: ! 919: /* ! 920: * Need to get FDC status from result phase - fdcCmdStatus - ! 921: * or clear interrupt - fdcIntStatus - that may have been ! 922: * generated by diskette change or seek/recal complete. ! 923: */ ! 924: if (FDC_BUSY()) { ! 925: fdcCmdStatus(); ! 926: } else { ! 927: fdcIntStatus(); ! 928: /* WARNING - should squawk if wrong number of status bytes. */ ! 929: ft.ft_pcn = fdc.fdc_intstat[1]; ! 930: unit = fdc.fdc_intstat[0] & 3; ! 931: } ! 932: ! 933: /* If ACK needed, try several times to get it. */ ! 934: if (ft.ft_ackNeeded) { ! 935: for (i = 0; i < FT_ACK_TRIES; i++) { ! 936: fdcDrvStatus(unit, FDC_HEAD_0); ! 937: fdcCmdStatus(); ! 938: bit = (fdc.fdc_cmdstat[0] & ST3_T0) ? 1 : 0; ! 939: putchar(bit ? '|' : 'o'); ! 940: if (bit) { ! 941: ft.ft_ackNeeded = 0; ! 942: break; ! 943: } ! 944: /* Wait about 20 usec. then try again. */ ! 945: busyWait2(NULL, 20); ! 946: } ! 947: ! 948: if (ft.ft_ackNeeded) { ! 949: /* Need error recovery here! */ ! 950: printf("<= Missing ACK "); ! 951: ft.ft_ackNeeded = 0; ! 952: } ! 953: } else if (ft.ft_bitsNeeded) { ! 954: /* ! 955: * If report bits are needed ! 956: * Get current report bit. ! 957: */ ! 958: ! 959: /* ! 960: * Need unit # for Sense Drive Status command. ! 961: * Get it from preceding Sense Interrupt command. ! 962: */ ! 963: fdcDrvStatus(unit, FDC_HEAD_0); ! 964: fdcCmdStatus(); ! 965: ! 966: /* Get next report bit by checking Track Zero bit in ST3 */ ! 967: if (fdc.fdc_ncmdstat == 1) { ! 968: int bit; ! 969: ! 970: bit = (fdc.fdc_cmdstat[0] & ST3_T0) ? 1 : 0; ! 971: printf("%d", bit); ! 972: ftRptUpdate(bit); ! 973: } else { ! 974: printf("rnb status bad "); ! 975: } ! 976: } ! 977: ! 978: /* ! 979: * If more report bits will be needed ! 980: * Send request for next bit. ! 981: * Else ! 982: * See if original requestor needs wakeup, etc. ! 983: */ ! 984: if (ft.ft_bitsNeeded) { ! 985: ftCmdSend(QIC_CMD_RNB); ! 986: } else { ! 987: if (ft.ft_wakeMeUp) { ! 988: ft.ft_wakeMeUp = 0; ! 989: wakeup(&ft.ft_wakeMeUp); ! 990: } ! 991: ! 992: /* Print debug output if needed. */ ! 993: if (ft.ft_dumpIrq) { ! 994: ft.ft_dumpIrq = 0; ! 995: defer(ftDbPrtStat); ! 996: } ! 997: } ! 998: } ! 999: ! 1000: /* ! 1001: * Send Recalibrate command to FDC and wait for it to finish. ! 1002: * ! 1003: * Return 0 if normal operation, -1 if signaled before recal complete. ! 1004: */ ! 1005: static int ! 1006: ftRecal(unit) ! 1007: int unit; ! 1008: { ! 1009: ft.ft_wakeMeUp = 1; ! 1010: fdcRecal(unit); ! 1011: if (x_sleep(&ft.ft_wakeMeUp, pritape, slpriSigCatch, "ftRecal")) ! 1012: return -1; ! 1013: else ! 1014: return 0; ! 1015: } ! 1016: ! 1017: /************************************************************************ ! 1018: * ftResetFDC ! 1019: * ! 1020: * Reset the FDC and wait for the resulting interrupt. ! 1021: * Reset is done keeping the unit in question selected. ! 1022: ***********************************************************************/ ! 1023: static void ! 1024: ftResetFDC(unit) ! 1025: { ! 1026: /* ! 1027: * Since FDC reset generates an interrupt, we need to tell the ! 1028: * interrupt handler there will be *no* report bits incoming. ! 1029: */ ! 1030: ftRptBegin(0); ! 1031: ! 1032: ft.ft_pcn = 0; ! 1033: ft.ft_wakeMeUp = 1; ! 1034: fdcResetSel(unit, FDC_MOTOR_ON); ! 1035: x_sleep(&ft.ft_wakeMeUp, pritape, slpriSigCatch, "ftRstFDC"); ! 1036: } ! 1037: ! 1038: /************************************************************************ ! 1039: * ftRptBegin ! 1040: * ! 1041: * Initialize ft state information in preparation for QIC report command. ! 1042: * ! 1043: * Argument "bitCount" is the total number of bits expected, including ! 1044: * initial ACK and final TRUE. It is 1 more than the number of ! 1045: * Report Next Bit Commands that will be issued. ! 1046: ***********************************************************************/ ! 1047: static void ! 1048: ftRptBegin(bitCount) ! 1049: int bitCount; ! 1050: { ! 1051: ft.ft_bitsNeeded = bitCount; ! 1052: ft.ft_bitsRcvd = 0; ! 1053: ft.ft_report = 0; ! 1054: ft.ft_ackNeeded = (bitCount) ? 1 : 0; ! 1055: } ! 1056: ! 1057: /************************************************************************ ! 1058: * ftRptUpdate ! 1059: * ! 1060: * Acquire another bit for QIC report command. ! 1061: * Last bit is discarded. Other bits are accumulated, ! 1062: * least significant bit first, into ft_report. ! 1063: ***********************************************************************/ ! 1064: static void ! 1065: ftRptUpdate(bit) ! 1066: int bit; ! 1067: { ! 1068: ft.ft_bitsNeeded--; ! 1069: ft.ft_bitsRcvd++; ! 1070: ! 1071: if (ft.ft_bitsNeeded == 0) { ! 1072: if (bit != 1) ! 1073: printf("Missing final TRUE "); ! 1074: } else { ! 1075: ft.ft_report |= (bit << (ft.ft_bitsRcvd - 1)); ! 1076: } ! 1077: } ! 1078: ! 1079: /* ! 1080: * Select tape unit. ! 1081: */ ! 1082: static void ! 1083: ftSelect(unit) ! 1084: int unit; ! 1085: { ! 1086: fdcRate(FDC_RATE_500K); /* set transfer rate */ ! 1087: fdcDrvSelect(unit, 1); /* 1=motor on */ ! 1088: ! 1089: /* Toggle FDC reset line, then wait for its interrupt. */ ! 1090: ft.ft_wakeMeUp = 1; ! 1091: fdcResetSel(unit, 1); /* Reset, preserving selection */ ! 1092: x_sleep(&ft.ft_wakeMeUp, pritape, slpriSigCatch, "ftSelect"); ! 1093: ! 1094: fdcSpecify(FT_SRT, FT_HUT, FT_HLT); ! 1095: ! 1096: /* 80 MB nseg_p_track = 100, nseg_p_head = 600, nseg_p_cyl = 4 */ ! 1097: /* 40 MB nseg_p_track = 68, nseg_p_head = 680, nseg_p_cyl = 4 */ ! 1098: if (ftfmt) { ! 1099: nseg_p_track = 100; /* set for 80 MB drive */ ! 1100: nseg_p_head = 600; ! 1101: nseg_p_cyl = 4; ! 1102: } else { ! 1103: nseg_p_track = 68; /* set for 40 MB drive */ ! 1104: nseg_p_head = 680; ! 1105: nseg_p_cyl = 4; ! 1106: } ! 1107: } ! 1108: ! 1109: /************************************************************************ ! 1110: * getmem ! 1111: * ! 1112: * Grab XL_NBUFS # of 32k DMA buffers. ! 1113: * Only use 16k of one of these, for QIC headers. ! 1114: * ! 1115: * Return 0 on success, 1 on failure. ! 1116: ***********************************************************************/ ! 1117: static int ! 1118: getmem() ! 1119: { ! 1120: register int i, nb; ! 1121: struct rb *prb; ! 1122: unsigned int tmpad, highAddr; ! 1123: ! 1124: if (xlmem_allocated) ! 1125: return 0; ! 1126: ! 1127: nb = XL_NBUFS; ! 1128: if (nb < 4) ! 1129: nb = 4; ! 1130: ! 1131: rbmp = (struct rb *)kalloc(XL_NBUFS * sizeof(struct rb)); ! 1132: if (rbmp == NULL) { ! 1133: printf("XL: initial kalloc() failed\n"); ! 1134: return 1; ! 1135: } ! 1136: ! 1137: allocated_add = getDmaMem(nb * BFRSZ, BFRSZ); ! 1138: if (allocated_add == NULL) { ! 1139: printf("XL: getDmaMem() failed\n"); ! 1140: return 1; ! 1141: } ! 1142: ! 1143: highAddr = allocated_add + (nb * BFRSZ); ! 1144: ! 1145: cmn_err(CE_CONT, "Allocated %d buffers. Virtual <%x-%x>. " ! 1146: "Physical <%x-%x>.\n", ! 1147: nb, allocated_add, highAddr, vtop(allocated_add), vtop(highAddr)); ! 1148: ! 1149: /* tmpad = 1st 32k bfr adr */ ! 1150: tmpad = (allocated_add + BFRSZ); ! 1151: ! 1152: ptr_header = (fplng)allocated_add; ! 1153: ! 1154: xlfree_q.top = prb = rbmp;/* build free pool */ ! 1155: for (i = 0; i < (nb - 1); ++i) { ! 1156: xlfree_q.bot = prb; ! 1157: ++prb; ! 1158: xlfree_q.bot->nxt = prb; ! 1159: xlfree_q.bot->adr = tmpad; ! 1160: tmpad += BFRSZ; ! 1161: } ! 1162: xlfree_q.bot->nxt = 0; ! 1163: ! 1164: cmn_err(CE_CONT, "getmem: allocated %d buffers\n", nb); ! 1165: ! 1166: xlmem_allocated = 1; ! 1167: data_queue.top = 0; ! 1168: data_queue.bot = 0; ! 1169: return 0; ! 1170: } ! 1171: ! 1172: /************************************************************************/ ! 1173: /* getrb get request buffer from queue */ ! 1174: /************************************************************************/ ! 1175: static struct rb * ! 1176: getrb(prbq) ! 1177: struct rbq *prbq; ! 1178: { ! 1179: struct rb *prb; ! 1180: int ilv; ! 1181: ! 1182: if (0 == (prb = prbq->top)) /* return if empty */ ! 1183: return 0; ! 1184: ilv = spl5(); /* playing with queue */ ! 1185: prbq->top = prb->nxt; /* advance top ptr */ ! 1186: if (0 == prbq->top) ! 1187: prbq->bot = 0; ! 1188: splx(ilv); /* done with queue */ ! 1189: return prb; ! 1190: } ! 1191: ! 1192: /************************************************************************/ ! 1193: /* putrb add req buf to end of queue */ ! 1194: /* return 1 if added to empty queue */ ! 1195: /************************************************************************/ ! 1196: static int ! 1197: putrb(prbq, prb) ! 1198: struct rbq *prbq; ! 1199: struct rb *prb; ! 1200: { ! 1201: int ilv; ! 1202: ! 1203: prb->nxt = 0; /* reset this buf's fwd ptr */ ! 1204: ilv = spl5(); /* playing with queues */ ! 1205: if (0 == prbq->top) { /* if empty queue, */ ! 1206: prbq->top = prb; /* pnt top and bot to new buf */ ! 1207: prbq->bot = prb; ! 1208: splx(ilv); ! 1209: return 1; ! 1210: } else { ! 1211: (prbq->bot)->nxt = prb;/* else pnt old end to new buf */ ! 1212: prbq->bot = prb; /* and bot to new buf */ ! 1213: splx(ilv); ! 1214: return 0; ! 1215: } ! 1216: } ! 1217: ! 1218: /************************************************************************/ ! 1219: /* stdma set dma */ ! 1220: /************************************************************************/ ! 1221: static void ! 1222: stdma(mode, adr, count) ! 1223: int mode; ! 1224: paddr_t adr; ! 1225: int count; ! 1226: { ! 1227: cmn_err(CE_CONT, "dir: %x Vadd: %x, Padd: %x, count: %x\n", ! 1228: mode, adr, kvtophys(adr), count); ! 1229: ! 1230: /* dma_param(DMA_CH2, mode, kvtophys(adr), count - 1); */ ! 1231: /* dma_enable(DMA_CH2); */ ! 1232: xldma((char)(mode + DMA_CH2), (long)kvtophys(adr), count - 1); ! 1233: } ! 1234: ! 1235: /************************************************************************/ ! 1236: /* strbfm set up rb params for format */ ! 1237: /************************************************************************/ ! 1238: static void ! 1239: strbfm(prb) ! 1240: struct rb *prb; ! 1241: { ! 1242: register fpchr p0; ! 1243: register int d0; ! 1244: int d1; ! 1245: ! 1246: d0 = prb->sgn; /* get segment # */ ! 1247: prb->hed = d0/nseg_p_head; /* set up fdc params */ ! 1248: d0 = d0 % nseg_p_head; ! 1249: prb->cyl = d0/nseg_p_cyl; ! 1250: prb->sct = ((d0 % nseg_p_cyl) << 5) + 1; ! 1251: ! 1252: p0 = (fpchr)cprb->adr; ! 1253: ! 1254: /* fill format bfr */ ! 1255: ! 1256: d0 = prb->sct; ! 1257: for (d1 = d0 + 32; d0 != d1; ++d0) { ! 1258: *p0++ = prb->cyl; ! 1259: *p0++ = prb->hed; ! 1260: *p0++ = d0; ! 1261: *p0++ = 3; ! 1262: } ! 1263: } ! 1264: ! 1265: /************************************************************************/ ! 1266: /* strbsg set up rb params for segment */ ! 1267: /* should be called at task time */ ! 1268: /* */ ! 1269: /* rb.tbl is used to skip bad sectors in segments. */ ! 1270: /* segments are split up into "chunks" */ ! 1271: /* index into rb.tbl with relative sector. */ ! 1272: /* each word in rb.tbl: */ ! 1273: /* bits 15-10: sector count for chunk */ ! 1274: /* bits 9- 5: dma offset for chunk */ ! 1275: /* bits 4- 0: sector # for chunk */ ! 1276: /************************************************************************/ ! 1277: static void ! 1278: strbsg(prb) ! 1279: struct rb *prb; ! 1280: { ! 1281: register int d0, d1, d2; ! 1282: ushort *p0; ! 1283: ! 1284: prb->erc = 0; /* reset error count */ ! 1285: d0 = prb->sgn; /* set tape params */ ! 1286: prb->trk = d0 / nseg_p_track; ! 1287: prb->tps = d0 % nseg_p_track; ! 1288: prb->hed = d0 / nseg_p_head; /* set up fdc params */ ! 1289: d0 = d0 % nseg_p_head; ! 1290: prb->cyl = d1 = d0 / nseg_p_cyl; ! 1291: prb->sct = d0 = ((d0 % nseg_p_cyl) << 5) + 1; ! 1292: if (d0 == 1) { /* set up position params */ ! 1293: --d1; ! 1294: d0 = (nseg_p_cyl << 5) - 16; ! 1295: } ! 1296: else ! 1297: d0 -= 16; ! 1298: prb->idc = d1; ! 1299: prb->ids = d0; ! 1300: d2 = 32; /* set up rb.tbl */ ! 1301: sgwrd = 0; ! 1302: sgmap = prb->map; ! 1303: p0 = prb->tbl; ! 1304: prb->nbk = 0; ! 1305: while(d2) { ! 1306: d0 = d2; /* d0 = # scts to skip */ ! 1307: while(sgmap & 1) { ! 1308: --d2; ! 1309: sgmap >>= 1; ! 1310: } ! 1311: d0 -= d2; ! 1312: sgwrd += d0; /* bump sct # in sgwrd */ ! 1313: if (!d2) /* exit if done */ ! 1314: break; ! 1315: d1 = d2; /* d1 = # scts this chunk */ ! 1316: while(d2 && 0 == (sgmap & 1)) { ! 1317: --d2; ! 1318: sgmap >>= 1; ! 1319: } ! 1320: d1 -= d2; ! 1321: prb->nbk += d1; /* adjust # blocks in segment */ ! 1322: sgwrd += d1 << 10; /* set count in sgwrd */ ! 1323: while(d0) { /* fill table for skipped scts */ ! 1324: *p0++ = sgwrd; ! 1325: --d0; ! 1326: } ! 1327: while(d1) { /* for each sct xferred */ ! 1328: *p0++ = sgwrd; /* store table entry */ ! 1329: sgwrd += 0xfc21;/* dec cnt, bump ofset bump sct */ ! 1330: --d1; ! 1331: } ! 1332: } ! 1333: for (++d0; d0; --d0) /* zero out rest of rb.tbl */ ! 1334: *p0++ = 0; ! 1335: } ! 1336: ! 1337: /************************************************************************/ ! 1338: /* stseg set up segment io */ ! 1339: /************************************************************************/ ! 1340: static void ! 1341: stseg(prb) ! 1342: struct rb *prb; ! 1343: { ! 1344: rwdcms[1] = unit; /* set rwdcmd constants */ ! 1345: rwdcms[2] = prb->cyl; ! 1346: rwdcms[3] = prb->hed; ! 1347: xadr = prb->adr; /* set base adr */ ! 1348: xsct = prb->sct; /* set base sct */ ! 1349: xrty = 6; /* set default # retries */ ! 1350: } ! 1351: ! 1352: /************************************************************************/ ! 1353: /* wvtbl create volume table entry */ ! 1354: /************************************************************************/ ! 1355: static void ! 1356: wvtbl() ! 1357: { ! 1358: xlvtbl *p; ! 1359: int ilvl; ! 1360: int i; ! 1361: ! 1362: ilvl = spl5(); /* wait for a new buffer */ ! 1363: while(!(cprb = getrb(&xlfree_q))) { ! 1364: if (!f.actv) ! 1365: xlque(); ! 1366: xlfreew = 1; ! 1367: sleep(&xlfreew, PRIBIO); ! 1368: } ! 1369: splx(ilvl); ! 1370: p = (xlvtbl *)cprb->adr; ! 1371: wptr = (fpchr)p; /* save ptr for encode */ ! 1372: for (i = 0; vtbl[i]; ++i) ! 1373: p->ident[i] = vtbl[i]; ! 1374: p->data_seg_num = (unsigned short)data_seg_num; ! 1375: p->last_seg_num = (unsigned short)curr_seg_num - 1; ! 1376: for (i = 0; p->op_system[i] = xnxnm[i]; ++i); ! 1377: ! 1378: for (ilvl = 0; ilvl < 43; ++ilvl) /* fill zero not implemented */ ! 1379: p->p1[ilvl] = 0; ! 1380: p->c_seq_num = 1; /* cartridge sequence # =1 */ ! 1381: ! 1382: for (ilvl = 0; ilvl < 34; ++ilvl) /* fill zero */ ! 1383: p->p3[ilvl] = 0; ! 1384: ! 1385: p->last_blk_size = (unsigned short)(lnbr - cnbr); ! 1386: cprb->sgn = volume_seg_num; ! 1387: cprb->map = ptr_header[volume_seg_num + 0x200]; ! 1388: cprb->fun = RBFWT; ! 1389: strbsg(cprb); ! 1390: xl_enc(wptr, cprb->nbk); ! 1391: putrb(&req, cprb); ! 1392: ilvl = spl5(); ! 1393: if (!f.actv) ! 1394: xlque(); ! 1395: splx(ilvl); ! 1396: } ! 1397: ! 1398: /************************************************************************/ ! 1399: /* xlcal() calibrate drive */ ! 1400: /* exits via (*xlosb)() */ ! 1401: /************************************************************************/ ! 1402: static void ! 1403: xlcal() ! 1404: { ! 1405: if (xlster) { /* exit if error */ ! 1406: (*pfcal)(); ! 1407: return; ! 1408: } ! 1409: f.cal = 0; /* reset calibrate sent flag */ ! 1410: pfrdy = xlcal0; /* wait for ready */ ! 1411: xlready(); ! 1412: } ! 1413: ! 1414: static void ! 1415: xlcal0() ! 1416: { ! 1417: if (xlster) { /* exit if error */ ! 1418: (*pfcal)(); ! 1419: return; ! 1420: } ! 1421: if ((xl6sts & 0xf7) == 0x65) {/* if ok, seek track 0, exit */ ! 1422: printf("xlcal:Seek tk 0 "); ! 1423: tptrk = 0; ! 1424: pfsek = pfcal; ! 1425: xlseek(); ! 1426: return; ! 1427: } ! 1428: if ((xl6sts & XLSREF) == 0) {/* if not referenced */ ! 1429: printf("xlcal:calibrate "); ! 1430: if (f.cal) { /* and calibrate sent, exit */ ! 1431: (*pfcal)(); ! 1432: return; ! 1433: } ! 1434: f.cal = 1; /* else send calibrate */ ! 1435: pfint = xlready; ! 1436: xloutput_step(QIC_CMD_CAL); ! 1437: return; ! 1438: } ! 1439: pfint = xlready; /* rewind tape */ ! 1440: xloutput_step(QIC_CMD_BOT); ! 1441: } ! 1442: ! 1443: /************************************************************************/ ! 1444: /* xlcomplete interrupt sequence complete */ ! 1445: /************************************************************************/ ! 1446: static void ! 1447: xlcomplete() ! 1448: { ! 1449: pfint = xlnull; /* clean up int handler */ ! 1450: xlcompf = 1; /* indicate completion */ ! 1451: if (xlcompw) { /* wake up if waiting */ ! 1452: xlcompw = 0; ! 1453: wakeup(&xlcompw); ! 1454: } ! 1455: } ! 1456: ! 1457: /************************************************************************/ ! 1458: /* xldelay delay for cnt ticks */ ! 1459: /************************************************************************/ ! 1460: static void ! 1461: xldelay(cnt) ! 1462: int cnt; ! 1463: { ! 1464: if (cnt) ! 1465: timeout(&xldly, cnt, pfdly, 0); ! 1466: else ! 1467: timeout(&xldly, cnt, NULL, 0); ! 1468: } ! 1469: ! 1470: /************************************************************************/ ! 1471: /* xldma */ ! 1472: /************************************************************************/ ! 1473: static void ! 1474: xldma(rw, addr, count) ! 1475: char rw; ! 1476: long addr; ! 1477: int count; ! 1478: { ! 1479: int oldpri; ! 1480: ! 1481: oldpri = sphi(); ! 1482: outb(DMA1CBPFF, 0); ! 1483: outb(DMA1WMR, rw); ! 1484: outb(DMA1BCA2, addr & 0xff); ! 1485: outb(DMA1BCA2, (addr >> 8) & 0xff); ! 1486: outb(DMACH2PG, (addr >> 16) & 0xff); ! 1487: tenmicrosec(); ! 1488: outb(DMA1BCWC2, count & 0xff); ! 1489: outb(DMA1BCWC2, (count >> 8) & 0xff); ! 1490: spl(oldpri); ! 1491: outb(DMA1WSMR, 2); ! 1492: } ! 1493: ! 1494: /************************************************************************/ ! 1495: /* xlfdc_in_byte input byte from fdc */ ! 1496: /************************************************************************/ ! 1497: static unchar ! 1498: xlfdc_in_byte() /* input byte from fdc */ ! 1499: { ! 1500: register int d0; ! 1501: ! 1502: for (d0 = FDTMO; d0; --d0) { /* wait for ready */ ! 1503: ! 1504: /* Wait for Request from Master asserted. */ ! 1505: if (inb(FDSTAT) & 0x80) { ! 1506: /* exit if in output mode */ ! 1507: if ((inb(FDSTAT) & 0x40) == 0) ! 1508: return(status_buf[7] = -1); ! 1509: return(inb(FDDATA)); ! 1510: } ! 1511: } ! 1512: return(status_buf[7] = -1); /* exit if timeout */ ! 1513: } ! 1514: ! 1515: /************************************************************************/ ! 1516: /* xlfdc_out_byte output byte to fdc */ ! 1517: /************************************************************************/ ! 1518: static unchar ! 1519: xlfdc_out_byte(chr) /* output byte to fdc */ ! 1520: int chr; ! 1521: { ! 1522: register int d0; ! 1523: ! 1524: for (d0 = FDTMO; d0; --d0) { /* wait for ready */ ! 1525: ! 1526: /* Wait for Request from Master asserted. */ ! 1527: if (inb(FDSTAT) & 0x80) { ! 1528: /* exit if in status mode */ ! 1529: if (inb(FDSTAT) & 0x40) ! 1530: return(status_buf[7] = -1); ! 1531: outb(FDDATA, chr); /* output byte, exit ok */ ! 1532: return 0; ! 1533: } ! 1534: } ! 1535: return(status_buf[7] = -1); /* exit if timeout */ ! 1536: } ! 1537: ! 1538: /************************************************************************/ ! 1539: /* xlfdc_out_str output cmd string to fdc */ ! 1540: /************************************************************************/ ! 1541: static unchar ! 1542: xlfdc_out_str(cms, cnt) /* output command string */ ! 1543: unchar *cms; ! 1544: int cnt; ! 1545: { ! 1546: register unchar *p0, *p1; ! 1547: ! 1548: p0 = cms; /* set up for output */ ! 1549: fdcmd = *p0; /* save command type */ ! 1550: for (p1 = p0 + cnt; p0 != p1; ++p0) { ! 1551: if (xlfdc_out_byte((int)(*p0)))/* stop if error */ ! 1552: break; ! 1553: } ! 1554: return(status_buf[7]); /* exit ok */ ! 1555: } ! 1556: ! 1557: /************************************************************************/ ! 1558: /* xlfdc_reset reset fdc */ ! 1559: /************************************************************************/ ! 1560: static void ! 1561: xlfdc_reset() /* fdc reset */ ! 1562: { ! 1563: sekcms[1] = 0xff; ! 1564: status_buf[7] = 0; /* reset error flag */ ! 1565: outb(FDCTRL, fdselr); /* reset fdc */ ! 1566: outb(FDCTRL, fdsel); ! 1567: } ! 1568: ! 1569: /************************************************************************/ ! 1570: /* xlflush flush any pending io's */ ! 1571: /************************************************************************/ ! 1572: static void ! 1573: xlflush(dev) ! 1574: { ! 1575: int ilvl; ! 1576: ! 1577: xstop = 1; /* stop any pending reads */ ! 1578: if (f.writ) { /* flush any pending writes */ ! 1579: if (cnbr && cprb->fun == RBFWT) { ! 1580: xl_enc(wptr, cprb->nbk); ! 1581: putrb(&req, cprb); ! 1582: } ! 1583: ilvl = spl5(); ! 1584: if (!f.actv) ! 1585: xlque(); ! 1586: splx(ilvl); ! 1587: wvtbl(); ! 1588: } ! 1589: ilvl = spl5(); /* wait for idle state */ ! 1590: while(f.actv) { ! 1591: xlnactw = 1; ! 1592: sleep(&xlnactw, PRIBIO); ! 1593: } ! 1594: splx(ilvl); ! 1595: cnbr = 0; ! 1596: xstop = 0; ! 1597: while(cprb = getrb(&data_queue))/* relse pending read bfrs */ ! 1598: putrb(&xlfree_q, cprb); ! 1599: while(cprb = getrb(&req)) /* release any pending que bfrs */ ! 1600: putrb(&xlfree_q, cprb); ! 1601: } ! 1602: ! 1603: /************************************************************************/ ! 1604: /* xlfmq format queue handler */ ! 1605: /************************************************************************/ ! 1606: static void ! 1607: xlfmq() ! 1608: { ! 1609: while(xprb = getrb(&req)) { /* while more to do */ ! 1610: if (!f.actv) { /* if not active, start tape */ ! 1611: f.actv = 1; ! 1612: f.tmov = 1; ! 1613: pfint = xlfmq0; ! 1614: xloutput_step(QIC_CMD_FWD); ! 1615: return; ! 1616: } ! 1617: else{ ! 1618: pffms = xlfmq1; /* else, continue format */ ! 1619: xlfms(); ! 1620: return; ! 1621: } ! 1622: } ! 1623: ! 1624: pfrdy = xlfmq2; /* wait for tape stopped */ ! 1625: xlready(); ! 1626: return; ! 1627: } ! 1628: ! 1629: static void ! 1630: xlfmq0() ! 1631: { ! 1632: pffms = xlfmq1; ! 1633: xlfms(); ! 1634: return; ! 1635: } ! 1636: ! 1637: static void ! 1638: xlfmq1() ! 1639: { ! 1640: if (xprb->sts) /* set f.werr if error */ ! 1641: f.werr = 1; ! 1642: putrb(&xlfree_q, xprb); /* relse bfr back to free pool */ ! 1643: if (xlfreew) { /* wakeup if needed */ ! 1644: xlfreew = 0; ! 1645: wakeup(&xlfreew); ! 1646: } ! 1647: xlfmq(); /* start next i/o */ ! 1648: } ! 1649: ! 1650: static void ! 1651: xlfmq2() ! 1652: { ! 1653: if (xlnactw) { /* if sleepg on xlnactw, wakeup */ ! 1654: xlnactw = 0; ! 1655: wakeup(&xlnactw); ! 1656: } ! 1657: f.actv = 0; /* rset actv, moving flgs, exit */ ! 1658: f.tmov = 0; ! 1659: return; ! 1660: } ! 1661: ! 1662: /************************************************************************/ ! 1663: /* xlfms format a segment */ ! 1664: /************************************************************************/ ! 1665: static void ! 1666: xlfms() ! 1667: { ! 1668: pfint = xlfm0; /* set up for format */ ! 1669: xprb->sts = 0; ! 1670: if (f.werr) { /* if error, do idle int */ ! 1671: xloutput_step(0); ! 1672: return; ! 1673: } ! 1674: fmtcms[1] = unit; ! 1675: stdma(DMA_Wrmode, xprb->adr, 128); ! 1676: ! 1677: xltimout(IOTMO); /* do the format */ ! 1678: xlfdc_out_str(fmtcms, 6); ! 1679: if (status_buf[7]) { /* exit if nec error */ ! 1680: xltimout(0); ! 1681: xlster |= XLSNEC; ! 1682: xprb->sts = 1; ! 1683: pfint = xlnull; ! 1684: (*pffms)(); ! 1685: return; ! 1686: } ! 1687: } ! 1688: ! 1689: static void ! 1690: xlfm0() ! 1691: { ! 1692: if (status_buf[0] & 0xc0) ! 1693: xprb->sts = 1; ! 1694: (*pffms)(); ! 1695: } ! 1696: ! 1697: /************************************************************************/ ! 1698: /* xlformat format tape, task time */ ! 1699: /************************************************************************/ ! 1700: static int ! 1701: xlformat(ntrkf) ! 1702: int ntrkf; ! 1703: { ! 1704: int ilvl, i; ! 1705: fplng p0; ! 1706: ! 1707: cmn_err(CE_CONT, "xlformat: formatting %d tracks\n", ntrkf); ! 1708: ! 1709: pfint = xlready; /* rewind tape */ ! 1710: pfrdy = xlcomplete; ! 1711: xloutput_step(QIC_CMD_BOT); ! 1712: xlwait(); ! 1713: if (xlster) ! 1714: return 2; ! 1715: ! 1716: bcopy((fpchr)xnxvs, ptr_header, 20); /* init header */ ! 1717: bcopy(ptr_header + 4, ptr_header + 5, 16 * 1024 - 20); ! 1718: ! 1719: pfint = xlcomplete; /* format mode */ ! 1720: xloutput_step(QIC_CMD_FMD); ! 1721: xlwait(); ! 1722: ! 1723: cmn_err(CE_CONT, "writing reference bursts...\n"); ! 1724: pfint = xlready; ! 1725: pfrdy = xlcomplete; ! 1726: xloutput_step(QIC_CMD_WRF); /* start wrt reference bursts */ ! 1727: xlwait(); ! 1728: ! 1729: cmn_err(CE_CONT, "reference bursts write done, starting format...\n"); ! 1730: ! 1731: f.werr = 0; ! 1732: ! 1733: for (fmtrk = 0; fmtrk < ntrkf; fmtrk += 2) { ! 1734: ! 1735: tptrk = fmtrk; /* set tape track */ ! 1736: curr_seg_num = fmtrk * nseg_p_track; ! 1737: ! 1738: pfint = xlcomplete; /* normal mode */ ! 1739: xloutput_step(QIC_CMD_NMD); ! 1740: xlwait(); ! 1741: ! 1742: pfint = xlcomplete; /* format mode */ ! 1743: xloutput_step(QIC_CMD_FMD); ! 1744: xlwait(); ! 1745: /* format a track pair */ ! 1746: do{ ! 1747: cmn_err(CE_CONT, "\tformatting track %d\n", tptrk); ! 1748: pfsek = xlcomplete; /* seek to track */ ! 1749: xlseek(); ! 1750: xlwait(); ! 1751: for (last_seg_num = curr_seg_num + nseg_p_track; curr_seg_num != last_seg_num; ++curr_seg_num) { ! 1752: /* wait for a new buffer */ ! 1753: ilvl = spl5(); ! 1754: while(!(cprb = getrb(&xlfree_q))) { ! 1755: if (!f.actv) ! 1756: xlfmq(); ! 1757: xlfreew = 1; ! 1758: sleep(&xlfreew, PRIBIO); ! 1759: } ! 1760: splx(ilvl); ! 1761: /* set up buffer */ ! 1762: cprb->sgn = curr_seg_num; ! 1763: strbfm(cprb); ! 1764: putrb(&req, cprb); ! 1765: } /* queue up format request */ ! 1766: ! 1767: ilvl = spl5(); /* track done, wait for idle */ ! 1768: while(f.actv) { ! 1769: xlnactw = 1; ! 1770: sleep(&xlnactw, PRIBIO); ! 1771: } ! 1772: splx(ilvl); ! 1773: ++tptrk; ! 1774: } while(tptrk & 1); ! 1775: if (f.werr) { /* exit if error formatting */ ! 1776: pfprk = xlcomplete; ! 1777: xlpark(); ! 1778: xlwait(); ! 1779: return 1; ! 1780: } ! 1781: ! 1782: /* verify a track pair */ ! 1783: pfint = xlcomplete; /* normal mode */ ! 1784: xloutput_step(QIC_CMD_NMD); ! 1785: xlwait(); ! 1786: ! 1787: pfint = xlcomplete; /* verify mode */ ! 1788: xloutput_step(QIC_CMD_VMD); ! 1789: xlwait(); ! 1790: ! 1791: /* set up for verify */ ! 1792: curr_seg_num = fmtrk * nseg_p_track; ! 1793: xlrel(); ! 1794: relfdc(); ! 1795: vftrk = -1; ! 1796: ! 1797: read_ahead_seg_num = curr_seg_num;/* queue up requests */ ! 1798: while(cprb = getrb(&xlfree_q)) { ! 1799: cprb->sgn = read_ahead_seg_num; ! 1800: cprb->map = 0L; ! 1801: cprb->fun = RBFRD; ! 1802: strbsg(cprb); ! 1803: cprb->erc = 3; /* no errors allowed */ ! 1804: putrb(&req, cprb); ! 1805: ++read_ahead_seg_num; ! 1806: } ! 1807: for (last_seg_num = curr_seg_num + 2 * nseg_p_track; curr_seg_num != last_seg_num; ++curr_seg_num ) { ! 1808: ilvl = spl5(); /* wait for a new buffer */ ! 1809: while(!(cprb = getrb(&data_queue))) { ! 1810: if (!f.actv) ! 1811: xlque(); ! 1812: xldataw = 1; ! 1813: sleep(&xldataw, PRIBIO); ! 1814: } ! 1815: splx(ilvl); ! 1816: if (vftrk != cprb->trk) { ! 1817: vftrk = cprb->trk; ! 1818: cmn_err(CE_CONT, "\tverifying track %d\n", vftrk); ! 1819: } ! 1820: if (cprb->sts) /* mask out segment if error */ ! 1821: *(ptr_header + 0x200 + cprb->sgn) = 0xffffffffL; ! 1822: /* generate another request or */ ! 1823: if (read_ahead_seg_num != last_seg_num) { ! 1824: cprb->sgn = read_ahead_seg_num; ! 1825: cprb->map = 0L; ! 1826: cprb->fun = RBFRD; ! 1827: strbsg(cprb); ! 1828: cprb->erc = 3; ! 1829: putrb(&req, cprb); ! 1830: ++read_ahead_seg_num; ! 1831: } else { ! 1832: putrb(&xlfree_q, cprb); ! 1833: } ! 1834: } /* release buffer */ ! 1835: ! 1836: ilvl = spl5(); /* track pair done, wait for idle */ ! 1837: while(f.actv) { ! 1838: xlnactw = 1; ! 1839: sleep(&xlnactw, PRIBIO); ! 1840: } ! 1841: splx(ilvl); ! 1842: ! 1843: getfdc(unit); /* get fdc again */ ! 1844: xlsel(unit); ! 1845: } ! 1846: ! 1847: if (xlster) { /* if fatal error, exit */ ! 1848: pfprk = xlcomplete; ! 1849: xlpark(); ! 1850: xlwait(); ! 1851: return 1; ! 1852: } ! 1853: ! 1854: pfint = xlcomplete; /* normal mode */ ! 1855: xloutput_step(QIC_CMD_NMD); ! 1856: xlwait(); ! 1857: ! 1858: /* done with format / verify */ ! 1859: /* now find out where headers and volumne table go */ ! 1860: ! 1861: p0 = ptr_header + 0x200; ! 1862: for (i = 0; *p0++; ++i); /* set hdr segment #'s */ ! 1863: ((fpwrd)ptr_header)[3] = h0sgn = i; /* and vol segment */ ! 1864: do { ! 1865: ++i; ! 1866: } while(*p0++); ! 1867: ((fpwrd)ptr_header)[4] = h1sgn = i; ! 1868: do { ! 1869: ++i; ! 1870: } while(*p0++); ! 1871: ((fpwrd)ptr_header)[5] = volume_seg_num = i; ! 1872: /* set last seg number */ ! 1873: ((fpwrd)ptr_header)[6] = last_seg_num = ntrkf * nseg_p_track - 1; ! 1874: ! 1875: cmn_err(CE_CONT, ! 1876: "xlformat: h0sgn %d h1sgn %d volume_seg_num %d last_seg_num %d\n", ! 1877: h0sgn, h1sgn, volume_seg_num, last_seg_num); ! 1878: ! 1879: pfprk = xlcomplete; /* park tape */ ! 1880: xlpark(); ! 1881: xlwait(); ! 1882: ! 1883: if (volume_seg_num > 10) /* if too many bad segment exit */ ! 1884: return 1; ! 1885: ! 1886: xlrel(); /* relse fdc, so xlque can work */ ! 1887: relfdc(); ! 1888: ! 1889: /* start header writes */ ! 1890: for (curr_seg_num = 0; curr_seg_num <= volume_seg_num; ++curr_seg_num) { ! 1891: ilvl = spl5(); /* get a buffer */ ! 1892: while(!(cprb = getrb(&xlfree_q))) { ! 1893: if (!f.actv) ! 1894: xlque(); ! 1895: xlfreew = 1; ! 1896: sleep(&xlfreew, PRIBIO); ! 1897: } ! 1898: splx(ilvl); ! 1899: cprb->sgn = curr_seg_num;/* set up for hdr or del adm write */ ! 1900: cprb->map = 0L; ! 1901: if (ptr_header[curr_seg_num + 0x200]) { ! 1902: cmn_err(CE_CONT, "-"); ! 1903: cprb->fun = RBWFD; ! 1904: } ! 1905: else{ ! 1906: cmn_err(CE_CONT, "*"); ! 1907: cprb->fun = RBFWT; ! 1908: } ! 1909: strbsg(cprb); ! 1910: cptr = (fpchr)cprb->adr; ! 1911: ! 1912: bcopy(ptr_header, cptr, 16 * 1024);/* copy in header */ ! 1913: bcopy(cptr + 16 * 1024 - 4, cptr + 16 * 1024, 13 * 1024 - 4); ! 1914: xl_enc(cptr, cprb->nbk); ! 1915: putrb(&req, cprb); ! 1916: } /* queue up the request */ ! 1917: ! 1918: if (!f.actv) /* activate driver */ ! 1919: xlque(); ! 1920: ! 1921: ilvl = spl5(); /* wait for idle state */ ! 1922: while(f.actv) { ! 1923: xlnactw = 1; ! 1924: sleep(&xlnactw, PRIBIO); ! 1925: } ! 1926: splx(ilvl); ! 1927: ! 1928: getfdc(unit); /* park tape */ ! 1929: xlsel(unit); ! 1930: pfprk = xlcomplete; ! 1931: xlpark(); ! 1932: xlwait(); ! 1933: return 0; ! 1934: } ! 1935: ! 1936: /************************************************************************/ ! 1937: /* xlgtdat get data */ ! 1938: /************************************************************************/ ! 1939: static void ! 1940: xlgtdat(iop) ! 1941: IO * iop; ! 1942: { ! 1943: caddr_t p0; ! 1944: fpchr p1; ! 1945: int ilvl; ! 1946: ! 1947: /* set up requests using all free buffers */ ! 1948: xlrqr(); ! 1949: ! 1950: /* set up to xfer data to user buffer */ ! 1951: ! 1952: rnbr = iop->io_ioc; /* set request params */ ! 1953: p0 = iop->io.vbase; ! 1954: ! 1955: p1 = cptr; /* use local copy of cptr */ ! 1956: ! 1957: while(rnbr) { /* while more to xfer */ ! 1958: if (curr_seg_num > last_seg_num) { ! 1959: break; ! 1960: } ! 1961: if (!cnbr) { /* if a new segment is needed */ ! 1962: ilvl = spl5(); /* wait for data */ ! 1963: while(!(cprb = getrb(&data_queue))) { ! 1964: if (!f.actv) ! 1965: xlque(); ! 1966: xldataw = 1; ! 1967: sleep(&xldataw, PRIBIO); ! 1968: } ! 1969: splx(ilvl); ! 1970: ! 1971: /* just got a new buffer from data queue */ ! 1972: ! 1973: p1 = (fpchr)cprb->adr; ! 1974: if (cprb->sts) {/* check for errors */ ! 1975: u.u_error = EIO; ! 1976: } ! 1977: else{ ! 1978: if (!xl_dec(p1, cprb->nbk, cprb->erc, ! 1979: cprb->ers[0], cprb->ers[1], cprb->ers[2])) { ! 1980: u.u_error = EIO; ! 1981: } ! 1982: } ! 1983: /* cnbr = # data bytes */ ! 1984: cnbr = (cprb->nbk - 3) << 10; ! 1985: if (cprb->sgn != curr_seg_num) ! 1986: curr_seg_num = cprb->sgn; ! 1987: if (cprb->sgn == last_seg_num) { ! 1988: cnbr = lnbr; ! 1989: } ! 1990: } ! 1991: /* copy some data */ ! 1992: rcnt = (cnbr >= rnbr) ? rnbr : cnbr; ! 1993: copyout(p1, p0, rcnt); ! 1994: p0 += rcnt; /* adjust pointers and counts */ ! 1995: p1 += rcnt; ! 1996: rnbr -= rcnt; ! 1997: cnbr -= rcnt; ! 1998: iop->io_ioc -= rcnt; ! 1999: if (!cnbr) { /* release bfr if done */ ! 2000: putrb(&xlfree_q, cprb); ! 2001: ++curr_seg_num; ! 2002: xlrqr(); ! 2003: } ! 2004: } /* set up new read request */ ! 2005: ! 2006: cptr = p1; /* update cptr */ ! 2007: } ! 2008: ! 2009: /************************************************************************/ ! 2010: /* xlhalt halt tape */ ! 2011: /************************************************************************/ ! 2012: static void ! 2013: xlhalt() ! 2014: { ! 2015: /* adjust tpseg for ramp down/up */ ! 2016: if (f.tmov) ! 2017: tpseg += 2; ! 2018: f.tmov = 0; /* reset tape moving flag */ ! 2019: if (xlster) { /* exit if error */ ! 2020: (*pfhlt)(); ! 2021: return; ! 2022: } ! 2023: pfint = xlready; /* after stop cmd wait for rdy */ ! 2024: pfrdy = pfhlt; /* after ready, exit */ ! 2025: xloutput_step(QIC_CMD_STOP); ! 2026: } ! 2027: ! 2028: /************************************************************************/ ! 2029: /* xlintr xl interrupt handler */ ! 2030: /************************************************************************/ ! 2031: static void ! 2032: xlintr() /* fdc interrupt handler */ ! 2033: { ! 2034: register unchar *p0, *p1; ! 2035: ! 2036: xltimout(0); /* reset interrupt timeout */ ! 2037: ! 2038: /* ! 2039: * Wait for Request from Master asserted in Main Status - ! 2040: * indicates data register available for read/write. ! 2041: */ ! 2042: while (inb(FDSTAT) & 0x80 == 0); ! 2043: ! 2044: /* FDC busy indicates read/write command in progress. */ ! 2045: if (inb(FDSTAT) & 0x10) { /* br if non-data int */ ! 2046: p0 = status_buf; /* set up */ ! 2047: for (p1 = p0 + 7; p0 != p1; ++p0) { ! 2048: *p0 = xlfdc_in_byte(); /* store next byte */ ! 2049: if (status_buf[7]) { ! 2050: xlster |= XLSNEC; ! 2051: break; ! 2052: } ! 2053: } ! 2054: } else { ! 2055: /* handle non-I/O int */ ! 2056: for(;;) { ! 2057: if (xlfdc_out_byte(8))/* start sense int */ ! 2058: break; ! 2059: status_buf[0] = xlfdc_in_byte();/* get 1st sts byte*/ ! 2060: if (status_buf[7]) { ! 2061: xlster |= XLSNEC; ! 2062: break; ! 2063: } ! 2064: if (status_buf[0] == 0x80) {/* br if done */ ! 2065: status_buf[0] = unit; ! 2066: if (xltimoutf) { ! 2067: xltimoutf = 0; ! 2068: status_buf[0] = 0xc0; ! 2069: } ! 2070: break; ! 2071: } ! 2072: status_buf[1] = xlfdc_in_byte();/* get 2nd sts byte*/ ! 2073: /* update track if my unit */ ! 2074: if (unit == (3 & status_buf[0])) { ! 2075: sekcms[2] = status_buf[1]; ! 2076: } ! 2077: /* check for more bytes */ ! 2078: } ! 2079: } ! 2080: (*pfint)(); /* exit via caller handler */ ! 2081: return; ! 2082: } ! 2083: ! 2084: /************************************************************************/ ! 2085: /* xlnull null interrupt handler */ ! 2086: /************************************************************************/ ! 2087: static void ! 2088: xlnull() ! 2089: { ! 2090: } ! 2091: ! 2092: /************************************************************************/ ! 2093: /* xlopn open tape (task time call) */ ! 2094: /************************************************************************/ ! 2095: static int ! 2096: xlopn(dev) ! 2097: dev_t dev; ! 2098: { ! 2099: register int i; ! 2100: xlvtbl *pp; ! 2101: ! 2102: printf("xlopn "); ! 2103: ! 2104: /* try 100 times to see drive ready - will fix this later */ ! 2105: for (i = 0; i < 100; i++) { ! 2106: xlster = 0; /* reset error status */ ! 2107: xlests = 0; ! 2108: xl7sts = 0; ! 2109: pfsts = xlcomplete; /* get drive status */ ! 2110: xlstatus(); ! 2111: xlwait(); ! 2112: printf("try:%d ", i+1); ! 2113: if (xl6sts & XLSRDY) ! 2114: break; ! 2115: } ! 2116: ! 2117: xlster &= ~XLSSFT; /* clear soft error bits */ ! 2118: xlests = 0; ! 2119: xl7sts = 0; ! 2120: ! 2121: if (!(xl6sts & XLSCIN)) { /* exit if no cartridge */ ! 2122: printf("no cart "); ! 2123: xlster |= XLSSFT; ! 2124: return 2; ! 2125: } ! 2126: ! 2127: if (xlster) { /* exit if fatal error */ ! 2128: printf("fatal error "); ! 2129: return 2; ! 2130: } ! 2131: ! 2132: if (dev & M_CTL) { /* exit if control open */ ! 2133: volume_seg_num = data_seg_num = 0; ! 2134: return 0; ! 2135: } ! 2136: ! 2137: if (dev & M_RET) { /* retension if retension_on_open */ ! 2138: pfint = xlready; ! 2139: pfrdy = xlcomplete; ! 2140: xloutput_step(QIC_CMD_EOT); ! 2141: xlwait(); ! 2142: if (xlster) { ! 2143: printf("another fatal error "); ! 2144: return 2; ! 2145: } ! 2146: } ! 2147: pfint = xlready; /* rewind tape */ ! 2148: pfrdy = xlcomplete; ! 2149: xloutput_step(QIC_CMD_BOT); ! 2150: xlwait(); ! 2151: printf("should now be at BOT "); ! 2152: if (xlster) { ! 2153: printf("yet another fatal error "); ! 2154: return 2; ! 2155: } ! 2156: ! 2157: pfcal = xlcomplete; /* calibrate drive */ ! 2158: xlcal(); ! 2159: xlwait(); ! 2160: printf("should now be referenced "); ! 2161: if (xlster) { /* exit if fatal error */ ! 2162: printf("still yet another fatal error "); ! 2163: return 2; ! 2164: } ! 2165: i = xl6sts & 0xf7; ! 2166: if (i == 0x45) { /* return if no ref bursts */ ! 2167: printf("no ref bursts "); ! 2168: return 1; ! 2169: } ! 2170: if (i != 0x65) { /* return general error */ ! 2171: printf("general error "); ! 2172: xlster |= XLSSFT; ! 2173: return 2; ! 2174: } ! 2175: xprb = getrb(&xlfree_q); /* get a buffer for open */ ! 2176: xprb->sgn = 0; /* set up buffer */ ! 2177: xlopn0: ! 2178: xprb->map = 0L; ! 2179: strbsg(xprb); ! 2180: ! 2181: ptr_buffer = (fplng)xprb->adr; ! 2182: ! 2183: pfpos = xlrds; /* read a segment */ ! 2184: pfrds = xlcomplete; ! 2185: xlpos(); ! 2186: xlwait(); ! 2187: ! 2188: if (!xprb->sts) { /* ck for errors */ ! 2189: printf("xlopn trying ecc "); ! 2190: if (!xl_dec(ptr_buffer, xprb->nbk, xprb->erc, ! 2191: xprb->ers[0], xprb->ers[1], xprb->ers[2])) { ! 2192: printf("failed "); ! 2193: xprb->sts = 1; ! 2194: } else { ! 2195: printf("succeeded "); ! 2196: } ! 2197: } ! 2198: ! 2199: if (xprb->sts) { /* if error, try next segment */ ! 2200: ++xprb->sgn; ! 2201: if (xprb->sgn < 10 && !xlster) { ! 2202: goto xlopn0; ! 2203: } ! 2204: } ! 2205: if (xprb->sts) { /* if fatal, return bfr & exit */ ! 2206: putrb(&xlfree_q, xprb); ! 2207: pfprk = xlcomplete; ! 2208: xlpark(); ! 2209: xlwait(); ! 2210: printf("fatal "); ! 2211: return 2; ! 2212: } ! 2213: ! 2214: bcopy(ptr_buffer, ptr_header, HDRSZ); /* copy header data */ ! 2215: ! 2216: volume_seg_num = ((fpwrd)ptr_header)[5];/* set seg numbers */ ! 2217: data_seg_num = volume_seg_num + 1; ! 2218: ! 2219: xprb->sgn = volume_seg_num; /* read in volume segment */ ! 2220: xprb->map = ptr_header[volume_seg_num + 0x200]; ! 2221: strbsg(xprb); ! 2222: pfpos = xlrds; ! 2223: pfrds = xlcomplete; ! 2224: xlpos(); ! 2225: xlwait(); ! 2226: ! 2227: if (!xprb->sts) { /* ck for errors */ ! 2228: printf("xlopn trying 2nd ecc "); ! 2229: if (!xl_dec(ptr_buffer, xprb->nbk, xprb->erc, ! 2230: xprb->ers[0], xprb->ers[1], xprb->ers[2])) { ! 2231: printf("failed "); ! 2232: xprb->sts = 1; ! 2233: } else { ! 2234: printf("succeeded "); ! 2235: } ! 2236: } ! 2237: ! 2238: /* set last seg num */ ! 2239: pp = (xlvtbl *)ptr_buffer; ! 2240: last_seg_num = (int)pp->last_seg_num; ! 2241: /* set last # bytes */ ! 2242: lnbr = (int)pp->last_blk_size; ! 2243: putrb(&xlfree_q, xprb); /* return buffer */ ! 2244: pfprk = xlcomplete; /* park tape */ ! 2245: xlpark(); ! 2246: xlwait(); ! 2247: if (xprb->sts) { /* return error if error */ ! 2248: printf("sts err "); ! 2249: return 2; ! 2250: } ! 2251: return 0; ! 2252: } ! 2253: ! 2254: /************************************************************************/ ! 2255: /* xloutput_step output cnt steps */ ! 2256: /************************************************************************/ ! 2257: static void ! 2258: xloutput_step(cnt) /* output cnt steps */ ! 2259: int cnt; ! 2260: { ! 2261: ! 2262: xlDbPrintCmd(cnt); ! 2263: ! 2264: sekcms[1] = unit; ! 2265: if (sekcms[2] > 80) ! 2266: sekcms[2] -= cnt; ! 2267: else ! 2268: sekcms[2] += cnt; ! 2269: xlfdc_out_str(sekcms, 3); /* start seek cmd */ ! 2270: if (status_buf[7]) { /* exit if nec error */ ! 2271: xlster |= XLSNEC; ! 2272: (*pfint)(); ! 2273: } ! 2274: } ! 2275: ! 2276: /************************************************************************/ ! 2277: /* xlpark park tape */ ! 2278: /************************************************************************/ ! 2279: static void ! 2280: xlpark() ! 2281: { ! 2282: if (xlster) { /* exit if error */ ! 2283: (*pfprk)(); ! 2284: return; ! 2285: } ! 2286: pfsts = xlpark0; /* clear any drive status */ ! 2287: xlstatus(); ! 2288: } ! 2289: ! 2290: static void ! 2291: xlpark0() ! 2292: { ! 2293: if (xlster) { /* exit if error */ ! 2294: (*pfprk)(); ! 2295: return; ! 2296: } ! 2297: pfint = xlpark1; /* set normal mode */ ! 2298: xloutput_step(QIC_CMD_NMD); ! 2299: } ! 2300: ! 2301: static void ! 2302: xlpark1() ! 2303: { ! 2304: tpseg = tptrk = 0; /* reset current track, segment */ ! 2305: pfsek = xlpark2; /* seek track 0 */ ! 2306: xlseek(); ! 2307: } ! 2308: ! 2309: static void ! 2310: xlpark2() ! 2311: { ! 2312: if (xlster) { /* exit if error */ ! 2313: (*pfprk)(); ! 2314: return; ! 2315: } ! 2316: pfint = xlready; /* after rewind, wait for rdy */ ! 2317: pfrdy = pfprk; /* after ready, exit */ ! 2318: xloutput_step(QIC_CMD_BOT); /* start rewind */ ! 2319: } ! 2320: ! 2321: /************************************************************************/ ! 2322: /* xlpos position to segment */ ! 2323: /* in: xprb = pointer to r */ ! 2324: /************************************************************************/ ! 2325: static void ! 2326: xlpos() ! 2327: { ! 2328: register int d0; ! 2329: ! 2330: cmn_err(CE_CONT, "xlpos "); ! 2331: ! 2332: if (xlster) { /* exit if error */ ! 2333: pfint = xlpos0; /* use null int to cleanup stak */ ! 2334: xloutput_step(0); ! 2335: return; ! 2336: } ! 2337: d0 = xprb->trk; ! 2338: if (tptrk != d0) { /* if not same track */ ! 2339: if ((tptrk ^ d0) & 1) /* adjust tpseg */ ! 2340: tpseg = nseg_p_track + 5 - tpseg; ! 2341: /* adjust tpseg if 1st seg on trk */ ! 2342: if (!xprb->tps) ! 2343: tpseg = nseg_p_track; ! 2344: printf("seek %d->%d ", tptrk, d0); ! 2345: tptrk = d0; /* seek track */ ! 2346: pfsek = xlpos0; ! 2347: xlseek(); ! 2348: return; ! 2349: } ! 2350: ! 2351: d0 = xprb->tps; /* d0 = new tpseg */ ! 2352: /* adjust tpseg if 1st seg on trk */ ! 2353: if (!d0) ! 2354: tpseg = nseg_p_track; ! 2355: if (d0 == tpseg && f.tmov == 1) { /* exit if on target */ ! 2356: printf("xpos on target "); ! 2357: (*pfpos)(); ! 2358: return; ! 2359: } ! 2360: if (d0 > tpseg) { /* if before target read id */ ! 2361: printf("before: %d < %d ", tpseg, d0); ! 2362: pfrdi = xlpos2; ! 2363: if (f.tmov) { ! 2364: xlreadid(); ! 2365: return; ! 2366: } ! 2367: f.tmov = 1; ! 2368: pfint = xlreadid; ! 2369: xloutput_step(QIC_CMD_FWD); ! 2370: return; ! 2371: } ! 2372: else{ ! 2373: pfskp = xlpos1; /* else skip backwards */ ! 2374: xlskipb(tpseg - d0); ! 2375: return; ! 2376: } ! 2377: } ! 2378: ! 2379: static void ! 2380: xlpos0() /* new track, tape stopped */ ! 2381: { ! 2382: register int d0; ! 2383: ! 2384: if (xlster) { /* exit if error */ ! 2385: (*pfpos)(); ! 2386: return; ! 2387: } ! 2388: d0 = xprb->tps; /* d0 = new tpseg */ ! 2389: /* adjust tpseg if 1st seg on trk */ ! 2390: if (!d0) ! 2391: tpseg = nseg_p_track; ! 2392: if (d0 >= tpseg) { /* if before target */ ! 2393: f.tmov = 1; ! 2394: pfint = xlreadid; /* start tape fwd and read id */ ! 2395: pfrdi = xlpos2; ! 2396: xloutput_step(QIC_CMD_FWD); ! 2397: return; ! 2398: } ! 2399: else{ ! 2400: pfskp = xlpos1; /* else skip backwards */ ! 2401: xlskipb(tpseg - d0); ! 2402: return; ! 2403: } ! 2404: } ! 2405: ! 2406: static void ! 2407: xlpos1() /* skip backwards done */ ! 2408: { ! 2409: cmn_err(CE_CONT, "xlpos1()\n"); ! 2410: ! 2411: if (xlster) { /* exit if error */ ! 2412: (*pfpos)(); ! 2413: return; ! 2414: } ! 2415: f.tmov = 1; ! 2416: if (!xprb->tps) { /* check for 1st seg on trk */ ! 2417: pfint = pfpos; ! 2418: xloutput_step(QIC_CMD_FWD); ! 2419: return; ! 2420: } ! 2421: pfint = xlreadid; /* start tape fwd and read id's */ ! 2422: pfrdi = xlpos2; ! 2423: xloutput_step(QIC_CMD_FWD); ! 2424: } ! 2425: ! 2426: static void ! 2427: xlpos2() /* read id finished */ ! 2428: { ! 2429: cmn_err(CE_CONT, "xlpos2()"); ! 2430: ! 2431: if (xlster) { /* exit if error */ ! 2432: (*pfpos)(); ! 2433: return; ! 2434: } ! 2435: if (status_buf[0] & 0xc0) { /* error handler */ ! 2436: /* if crc error, read id again */ ! 2437: if (status_buf[1] & 0x20) { ! 2438: printf("crc err "); ! 2439: xlreadid(); ! 2440: return; ! 2441: } ! 2442: pfhlt = xlpos3; ! 2443: xlhalt(); ! 2444: return; ! 2445: } ! 2446: if (xprb->idc > status_buf[3] ||/* if bef tgt, read id again */ ! 2447: xprb->ids > status_buf[5]) { ! 2448: printf("before target "); ! 2449: xlreadid(); ! 2450: return; ! 2451: } ! 2452: if (xprb->cyl <= status_buf[3] && /* if past it back up */ ! 2453: xprb->sct <= status_buf[5]) { ! 2454: pfskp = xlpos1; ! 2455: xlskipb(9); ! 2456: return; ! 2457: } ! 2458: /* we are at target spot */ ! 2459: tpseg = xprb->tps; /* set tpseg and exit */ ! 2460: (*pfpos)(); ! 2461: } ! 2462: ! 2463: static void ! 2464: xlpos3() /* status complete tape stopped */ ! 2465: { ! 2466: cmn_err(CE_CONT, "xlpos3()\n"); ! 2467: ! 2468: if (xlster) { /* exit if error */ ! 2469: (*pfpos)(); ! 2470: return; ! 2471: } ! 2472: if (xl6sts & (XLSEOT | XLSBOT)) {/* if end track skip backwd */ ! 2473: pfskp = xlpos1; ! 2474: xlskipb((int)(nseg_p_track + 5 - xprb->tps)); ! 2475: return; ! 2476: } ! 2477: xlster |= XLSNID; /* else can't read id's */ ! 2478: (*pfpos)(); ! 2479: } ! 2480: ! 2481: /************************************************************************/ ! 2482: /* xlptdat put data */ ! 2483: /************************************************************************/ ! 2484: static void ! 2485: xlptdat(iop) ! 2486: IO * iop; ! 2487: { ! 2488: caddr_t p0; ! 2489: fpchr p1; ! 2490: int ilvl; ! 2491: ! 2492: rnbr = iop->io_ioc; /* set request params */ ! 2493: p0 = iop->io.vbase; ! 2494: while(rnbr) { ! 2495: if (!cnbr) { /* if a new buffer is needed */ ! 2496: ilvl = spl5(); /* wait for a new buffer */ ! 2497: while(!(cprb = getrb(&xlfree_q))) { ! 2498: if (!f.actv) ! 2499: xlque(); ! 2500: xlfreew = 1; ! 2501: sleep(&xlfreew, PRIBIO); ! 2502: } ! 2503: splx(ilvl); ! 2504: do{ ! 2505: /* set up segment */ ! 2506: cprb->sgn = curr_seg_num; ! 2507: cprb->map = ptr_header[curr_seg_num + 0x200]; ! 2508: cprb->fun = RBFWT; ! 2509: strbsg(cprb); ! 2510: ++curr_seg_num; ! 2511: }while(cprb->nbk < 4); ! 2512: cnbr = (cprb->nbk - 3) << 10; /* set params */ ! 2513: lnbr = cnbr; ! 2514: cptr = (fpchr)cprb->adr; ! 2515: wptr = cptr; ! 2516: } /* save ptr for later encode */ ! 2517: p1 = cptr; /* copy data */ ! 2518: rcnt = (cnbr >= rnbr) ? rnbr : cnbr; ! 2519: copyin(p0, p1, rcnt); ! 2520: p0 += rcnt; ! 2521: p1 += rcnt; ! 2522: cptr = p1; ! 2523: rnbr -= rcnt; /* adjust count */ ! 2524: cnbr -= rcnt; ! 2525: if (!cnbr) { /* if filled, encode and q bfr */ ! 2526: xl_enc(wptr, cprb->nbk); ! 2527: putrb(&req, cprb); ! 2528: } ! 2529: } ! 2530: iop->io_ioc = 0; ! 2531: } ! 2532: ! 2533: /************************************************************************/ ! 2534: /* xlque process queue request */ ! 2535: /************************************************************************/ ! 2536: static void ! 2537: xlque() ! 2538: { ! 2539: cmn_err(CE_CONT, "xlque()\n"); ! 2540: xlque0: ! 2541: xprb = getrb(&req); /* get next request */ ! 2542: if (!xprb) { /* if end queue and */ ! 2543: if (f.tmov) { /* if tape moving, stop tape */ ! 2544: cmn_err(CE_CONT, "xlque: stopping\n"); ! 2545: pfhlt = xlque; ! 2546: xlhalt(); ! 2547: return; ! 2548: } ! 2549: cmn_err(CE_CONT, "xlque: inactive\n"); ! 2550: ! 2551: if (f.actv) { /* if active, release fdc */ ! 2552: xlrel(); ! 2553: relfdc(); ! 2554: } ! 2555: if (xlnactw) { /* if sleeping on xlnactw, wakeup */ ! 2556: xlnactw = 0; ! 2557: wakeup(&xlnactw); ! 2558: } ! 2559: f.actv = 0; /* reset active flag, exit */ ! 2560: return; ! 2561: } ! 2562: if (!f.actv) { /* if called from task (not active) */ ! 2563: getfdc(unit); /* get fdc */ ! 2564: xlsel(unit); ! 2565: } ! 2566: f.actv = 1; ! 2567: switch(xprb->fun) { ! 2568: case RBFRD: /* read segment */ ! 2569: if (xstop) { /* if stop, ignore request */ ! 2570: putrb(&xlfree_q, xprb); ! 2571: goto xlque0; ! 2572: } ! 2573: pfpos = xlrds; ! 2574: pfrds = xlqr0; ! 2575: xlpos(); ! 2576: return; ! 2577: case RBFWT: /* write segment */ ! 2578: pfpos = xlwts; ! 2579: pfwts = xlqw0; ! 2580: xlpos(); ! 2581: return; ! 2582: case RBWFD: /* write del adr mrk segment */ ! 2583: pfpos = xlwds; ! 2584: pfwds = xlqw0; ! 2585: xlpos(); ! 2586: return; ! 2587: default: ! 2588: ; ! 2589: } ! 2590: } ! 2591: ! 2592: static void ! 2593: xlqr0() ! 2594: { ! 2595: putrb(&data_queue, xprb); /* add to data queue */ ! 2596: if (xldataw) { /* wakeup if needed */ ! 2597: xldataw = 0; ! 2598: wakeup(&xldataw); ! 2599: } ! 2600: xlque(); /* start next i/o */ ! 2601: } ! 2602: ! 2603: static void ! 2604: xlqw0() ! 2605: { ! 2606: if (xprb->sts) /* set f.werr if error */ ! 2607: f.werr = 1; ! 2608: putrb(&xlfree_q, xprb); /* relse bfr back to free pool */ ! 2609: if (xlfreew) { /* wakeup if needed */ ! 2610: xlfreew = 0; ! 2611: wakeup(&xlfreew); ! 2612: } ! 2613: xlque(); /* start next i/o */ ! 2614: } ! 2615: ! 2616: /************************************************************************/ ! 2617: /* xlrds read segment */ ! 2618: /* in: xprb = pointer to rb */ ! 2619: /************************************************************************/ ! 2620: static void ! 2621: xlrds() ! 2622: { ! 2623: if (xlster || xstop) { /* exit if error or stop */ ! 2624: pfint = xlrd0; /* use null int to cleanup stck */ ! 2625: xloutput_step(0); ! 2626: return; ! 2627: } ! 2628: rwdcms[0] = 0x46; /* set for read */ ! 2629: stseg(xprb); ! 2630: xrty = 2; /* 2 tries per sector */ ! 2631: xlrd0(); /* start io */ ! 2632: } ! 2633: ! 2634: static void ! 2635: xlrd0() /* initiate io */ ! 2636: { ! 2637: if (xlster || xstop) { /* exit if error or stop */ ! 2638: printf("xlrd0 - err xlster=%x xstop=%x ", xlster, xstop); ! 2639: pfint = xlnull; ! 2640: xprb->sts = 1; ! 2641: (*pfrds)(); ! 2642: return; ! 2643: } ! 2644: pfint = xlrd1; /* set int handler */ ! 2645: xtbl = (xprb->tbl)[xsct - xprb->sct];/* get rb.tbl entry */ ! 2646: if (xtbl) { /* if more data, start other read */ ! 2647: rwdcms[4] = (xtbl & 0x1f) + xprb->sct; ! 2648: stdma(DMA_Rdmode, xadr | ((xtbl & 0x3e0) << 5), (int)(xtbl & 0xfc00)); ! 2649: xltimout(IOTMO); ! 2650: xlfdc_out_str(rwdcms, 9); ! 2651: if (status_buf[7]) { /* exit if nec error */ ! 2652: xltimout(0); ! 2653: xlster |= XLSNEC; ! 2654: pfint = xlnull; ! 2655: (*pfrds)(); ! 2656: return; ! 2657: } ! 2658: return; ! 2659: } ! 2660: else{ /* else, seg is done */ ! 2661: xprb->sts = 0; ! 2662: tpseg = xprb->tps + 1; ! 2663: if (tpseg == nseg_p_track) { /* if last seg on trk, */ ! 2664: pfrdy = pfrds; /* exit via xlready */ ! 2665: xlready(); ! 2666: return; ! 2667: } ! 2668: pfint = xlnull; /* else just exit */ ! 2669: (*pfrds)(); ! 2670: return; ! 2671: } ! 2672: } ! 2673: ! 2674: static void ! 2675: xlrd1() ! 2676: { ! 2677: if (xlster || xstop) { /* exit if error or stop */ ! 2678: printf("xlrd1 - err xlster=%x xstop=%x ", xlster, xstop); ! 2679: pfint = xlnull; ! 2680: xprb->sts = 1; ! 2681: (*pfrds)(); ! 2682: return; ! 2683: } ! 2684: if (status_buf[0] & 0xc0) { /* if error */ ! 2685: dsperr(); ! 2686: if (status_buf[2] & 0x40) {/* if del adr mark, exit */ ! 2687: ++tpseg; ! 2688: goto xlrd2; ! 2689: } ! 2690: if (status_buf[0] == 0xc0)/* adjust tpseg */ ! 2691: tpseg += TMSKP; ! 2692: else{ ! 2693: tpseg += 2; ! 2694: } ! 2695: if (tpseg > nseg_p_track) ! 2696: tpseg = nseg_p_track; ! 2697: ! 2698: if (status_buf[0] != 0xc0) { /* if not timeout */ ! 2699: /* if no data read */ ! 2700: if (xsct == status_buf[5]) { ! 2701: --xrty; /* skip sct if 2nd time */ ! 2702: if (xrty == 0) { ! 2703: if (xprb->erc < 3) { ! 2704: xprb->ers[xprb->erc] = xsct-xprb->sct; ! 2705: ++xprb->erc; ! 2706: ++xsct; ! 2707: xrty = 2; ! 2708: } ! 2709: else{ /* fail if too many err */ ! 2710: goto xlrd2; ! 2711: } ! 2712: } ! 2713: } ! 2714: else{ /* some data read in */ ! 2715: xrty = 1; /* 1mor try on this sct */ ! 2716: xsct = status_buf[5]; ! 2717: } ! 2718: } /* update xsct */ ! 2719: else{ /* if timeout */ ! 2720: --xrty; /* fail if too many err */ ! 2721: if (!xrty) { ! 2722: xlrd2: ! 2723: printf("xlrd2 - err xlster=%x xstop=%x ", xlster, xstop); ! 2724: xprb->sts = 1; ! 2725: pfint = xlnull; ! 2726: (*pfrds)(); ! 2727: return; ! 2728: } ! 2729: } ! 2730: pfpos = xlrd0; /* restart io after positioning */ ! 2731: xlpos(); ! 2732: return; ! 2733: } ! 2734: ! 2735: /* no errors, start io for next part of segment (if any) */ ! 2736: ! 2737: xsct = status_buf[5]; /* update xsct, start next io */ ! 2738: xlrd0(); ! 2739: } ! 2740: ! 2741: /************************************************************************/ ! 2742: /* xlreadid read id */ ! 2743: /************************************************************************/ ! 2744: static void ! 2745: xlreadid() ! 2746: { ! 2747: cmn_err(CE_CONT, "xlreadid()"); ! 2748: ! 2749: pfint = xlreadid0; /* set pfint */ ! 2750: xltimout(IOTMO); ! 2751: xlfdc_out_str(rdicms, 2); /* start read id cmd */ ! 2752: if (xlster) { /* exit if error */ ! 2753: printf("readid err "); ! 2754: xltimout(0); ! 2755: pfint = xlnull; ! 2756: (*pfrdi)(); ! 2757: return; ! 2758: } ! 2759: } ! 2760: ! 2761: static void ! 2762: xlreadid0() ! 2763: { ! 2764: pfint = xlnull; /* reset pfint */ ! 2765: (*pfrdi)(); /* and exit */ ! 2766: } ! 2767: ! 2768: /************************************************************************/ ! 2769: /* xlready wait for ready */ ! 2770: /************************************************************************/ ! 2771: static void ! 2772: xlready() ! 2773: { ! 2774: if (xlster) { /* exit if error */ ! 2775: (*pfrdy)(); ! 2776: return; ! 2777: } ! 2778: pfsts = xlready0; /* get drive status */ ! 2779: xlstatus(); ! 2780: } ! 2781: ! 2782: static void ! 2783: xlready0() ! 2784: { ! 2785: if (xlster || (xl6sts & XLSRDY)) { /* exit if done */ ! 2786: (*pfrdy)(); ! 2787: return; ! 2788: } ! 2789: xlstatus(); /* else get status again */ ! 2790: } ! 2791: ! 2792: /************************************************************************/ ! 2793: /* xlrel release unit */ ! 2794: /************************************************************************/ ! 2795: static void ! 2796: xlrel() ! 2797: { ! 2798: while(0x80 != (0xc0 & inb(FDSTAT))); /* wait for ready */ ! 2799: outb(FDCTRL, 0x0c); /* deselect all units */ ! 2800: xlfdc_out_str(sf3cms, 3); /* set step rate to 3ms */ ! 2801: } ! 2802: ! 2803: /************************************************************************/ ! 2804: /* xlreset reset drive */ ! 2805: /************************************************************************/ ! 2806: static void ! 2807: xlreset() ! 2808: { ! 2809: pfint = xlreset0; /* output 1 step */ ! 2810: xloutput_step(QIC_CMD_RST); ! 2811: } ! 2812: ! 2813: static void ! 2814: xlreset0() ! 2815: { ! 2816: pfint = xlnull; /* reset pfint */ ! 2817: pfdly = xlready; /* after delay "wait" for ready */ ! 2818: pfrdy = pfrst; /* after ready, exit via pfrst */ ! 2819: xldelay(HZ); /* start delay */ ! 2820: } ! 2821: ! 2822: /************************************************************************/ ! 2823: /* xlrnb report next bit(s) */ ! 2824: /************************************************************************/ ! 2825: static void ! 2826: xlrnb(cnt) ! 2827: int cnt; ! 2828: { ! 2829: xlrnbw = 0; /* reset status int */ ! 2830: pfint = xlrnb0; /* set int handler */ ! 2831: xlbcnt = cnt; /* set up */ ! 2832: xloutput_step(QIC_CMD_RNB); /* start 2 step seek */ ! 2833: } ! 2834: ! 2835: static void ! 2836: xlrn9() /* get 9 bits */ ! 2837: { ! 2838: unchar bit; ! 2839: ! 2840: /* Sense drive status. */ ! 2841: xlfdc_out_byte(4); ! 2842: xlfdc_out_byte((int)unit); ! 2843: ! 2844: /* Read ST3, look at T0 bit. */ ! 2845: bit = (0x10 & xlfdc_in_byte()) ? 1 : 0; ! 2846: printf("%d", bit); ! 2847: ! 2848: xlrnbw = 0; ! 2849: pfint = xlrnb0; ! 2850: xlbcnt = 9; ! 2851: xloutput_step(QIC_CMD_RNB); ! 2852: } ! 2853: ! 2854: static void ! 2855: xlrn17() /* get 17 bits */ ! 2856: { ! 2857: xlrnbw = 0; ! 2858: pfint = xlrnb0; ! 2859: xlbcnt = 17; ! 2860: xloutput_step(QIC_CMD_RNB); ! 2861: } ! 2862: ! 2863: static void ! 2864: xlrnb0() ! 2865: { ! 2866: register int xlrnbb; /* xl2 status bit */ ! 2867: int bit; ! 2868: ! 2869: /* Sense drive status. */ ! 2870: xlfdc_out_byte(4); ! 2871: xlfdc_out_byte((int)unit); ! 2872: ! 2873: /* Read ST3, look at T0 bit. */ ! 2874: bit = (0x10 & xlfdc_in_byte()) ? 1 : 0; ! 2875: printf("%d", bit); ! 2876: ! 2877: xlrnbb = bit ? 0x8000 : 0x0000; ! 2878: if (status_buf[7]) /* exit if nec handshake error */ ! 2879: xlster |= XLSNEC; ! 2880: if (xlster) { ! 2881: pfint = xlnull; ! 2882: (*pfrnb)(); ! 2883: return; ! 2884: } ! 2885: --xlbcnt; ! 2886: if (xlbcnt) { /* if not done, shift in bit */ ! 2887: xlrnbw >>= 1; /* and continue */ ! 2888: xlrnbw |= xlrnbb; ! 2889: xloutput_step(QIC_CMD_RNB); ! 2890: return; ! 2891: } else { ! 2892: if (!xlrnbb) /* last bit must = 1 */ ! 2893: xlster |= XLSLSB; ! 2894: pfint = xlnull; ! 2895: (*pfrnb)(); /* call end step handler */ ! 2896: return; ! 2897: } ! 2898: } ! 2899: ! 2900: /************************************************************************/ ! 2901: /* xlrqr set up read requests */ ! 2902: /************************************************************************/ ! 2903: static void ! 2904: xlrqr() ! 2905: { ! 2906: while(fprb = getrb(&xlfree_q)) {/* enqueue any free bfrs */ ! 2907: xlrqr0: ! 2908: if (read_ahead_seg_num > last_seg_num) { ! 2909: putrb(&xlfree_q, fprb); ! 2910: break; ! 2911: } ! 2912: fprb->sgn = read_ahead_seg_num; ! 2913: fprb->map = ptr_header[read_ahead_seg_num + 0x200]; ! 2914: fprb->fun = RBFRD; ! 2915: strbsg(fprb); ! 2916: if (fprb->nbk < 4) { /* skip if < 4 sectors */ ! 2917: ++read_ahead_seg_num; ! 2918: goto xlrqr0; ! 2919: } ! 2920: putrb(&req, fprb); /* add bfr to req queue */ ! 2921: ++read_ahead_seg_num; ! 2922: } ! 2923: } ! 2924: ! 2925: /************************************************************************/ ! 2926: /* xlseek seek head to tptrk */ ! 2927: /************************************************************************/ ! 2928: static void ! 2929: xlseek() ! 2930: { ! 2931: if (xlster) { /* exit if error */ ! 2932: (*pfsek)(); ! 2933: return; ! 2934: } ! 2935: pfhlt = xlseek0; /* halt tape */ ! 2936: xlhalt(); ! 2937: } ! 2938: ! 2939: static void ! 2940: xlseek0() ! 2941: { ! 2942: if (xlster) { /* exit if error */ ! 2943: (*pfsek)(); ! 2944: return; ! 2945: } ! 2946: pfint = xlseek1; /* do 13 steps */ ! 2947: xloutput_step(QIC_CMD_SEEK); ! 2948: } ! 2949: ! 2950: static void ! 2951: xlseek1() ! 2952: { ! 2953: if (xlster) { /* exit if error */ ! 2954: (*pfsek)(); ! 2955: return; ! 2956: } ! 2957: pfint = xlready; /* after seek "wait" for rdy */ ! 2958: pfrdy = pfsek; /* after ready, exit */ ! 2959: xloutput_step(2 + tptrk); ! 2960: } ! 2961: ! 2962: /************************************************************************ ! 2963: * xlsel select unit, wait for done ! 2964: ***********************************************************************/ ! 2965: static void ! 2966: xlsel() ! 2967: { ! 2968: fdsel = fdstb[unit]; ! 2969: fdselr = 0xfb & fdsel; ! 2970: outb(FDCSR1, 0); /* set 500khz speed */ ! 2971: outb(FDCTRL, fdsel); /* select unit */ ! 2972: pfint = xlcomplete; /* reset fdc */ ! 2973: xlfdc_reset(); ! 2974: xlwait(); ! 2975: xlfdc_out_str(sf2cms, 3); /* set step rate to 2ms */ ! 2976: ! 2977: /* 80 MB nseg_p_track = 100, nseg_p_head = 600, nseg_p_cyl = 4 */ ! 2978: /* 40 MB nseg_p_track = 68, nseg_p_head = 680, nseg_p_cyl = 4 */ ! 2979: if (ftfmt) { ! 2980: nseg_p_track = 100; /* set for 80 MB drive */ ! 2981: nseg_p_head = 600; ! 2982: nseg_p_cyl = 4; ! 2983: } else { ! 2984: nseg_p_track = 68; /* set for 40 MB drive */ ! 2985: nseg_p_head = 680; ! 2986: nseg_p_cyl = 4; ! 2987: } ! 2988: } ! 2989: ! 2990: /************************************************************************/ ! 2991: /* xlskipb skip n segments back */ ! 2992: /************************************************************************/ ! 2993: static void ! 2994: xlskipb(cnt) ! 2995: int cnt; ! 2996: { ! 2997: if (xlster) { /* exit if error */ ! 2998: (*pfskp)(); ! 2999: return; ! 3000: } ! 3001: f.tmov = 0; /* tape will be halted */ ! 3002: xlskip_count = cnt; /* set skip count */ ! 3003: pfint = xlready; /* stop tape first */ ! 3004: pfrdy = xlskipb0; ! 3005: xloutput_step(QIC_CMD_STOP); ! 3006: } ! 3007: ! 3008: static void ! 3009: xlskipb0() ! 3010: { ! 3011: pfint = xlskipb1; /* start skip back cmd */ ! 3012: xloutput_step(QIC_CMD_SKPB); ! 3013: } ! 3014: ! 3015: static void ! 3016: xlskipb1() ! 3017: { ! 3018: if (xlster) { /* exit if error */ ! 3019: (*pfskp)(); ! 3020: return; ! 3021: } ! 3022: pfint = xlskipb2; /* issue 2nd part of cmd */ ! 3023: xloutput_step(2 + (0xf & xlskip_count)); ! 3024: } ! 3025: ! 3026: static void ! 3027: xlskipb2() ! 3028: { ! 3029: if (xlster) { /* exit if error */ ! 3030: (*pfskp)(); ! 3031: return; ! 3032: } ! 3033: /* after 3rd part cmd, wait for ready */ ! 3034: pfint = xlready; ! 3035: pfrdy = pfskp; /* after ready, exit */ ! 3036: /* start 3rd part cmd */ ! 3037: xloutput_step(2 + (0xf & (xlskip_count >> 4))); ! 3038: } ! 3039: ! 3040: /************************************************************************/ ! 3041: /* xlstatus() get drive status */ ! 3042: /************************************************************************/ ! 3043: static void ! 3044: xlstatus() ! 3045: { ! 3046: if (xlster) { /* exit if error */ ! 3047: pfint = xlnull; ! 3048: (*pfsts)(); ! 3049: return; ! 3050: } ! 3051: /* after 6 steps, get 9 report bits */ ! 3052: pfint = xlrn9; ! 3053: pfrnb = xlstatus0; /* after 9 bits, goto xlstatus0 */ ! 3054: xloutput_step(QIC_CMD_STS); /* start steps */ ! 3055: } ! 3056: ! 3057: static void ! 3058: xlstatus0() ! 3059: { ! 3060: if (xlster) { /* exit if error */ ! 3061: pfint = xlnull; ! 3062: (*pfsts)(); ! 3063: return; ! 3064: } ! 3065: ! 3066: xl6sts = xlrnbw >> 8; /* set xl6sts */ ! 3067: ! 3068: if (xl6sts == 0xff) { /* exit if not tape drive */ ! 3069: xlster |= XLSNTD; ! 3070: pfint = xlnull; ! 3071: (*pfsts)(); ! 3072: return; ! 3073: } else { ! 3074: xlDbPrintStat(xl6sts); ! 3075: } ! 3076: ! 3077: if (xl6sts & (XLSEXC | XLSCHG)) {/* if exception condition, */ ! 3078: xlests = xl6sts; /* start type 7 status */ ! 3079: pfint = xlrn17; ! 3080: pfrnb = xlstatus1; ! 3081: xloutput_step(QIC_CMD_ECD); ! 3082: return; ! 3083: } ! 3084: ! 3085: if (xlests || !(xl6sts & XLSCIN)) { /* set soft err if needed */ ! 3086: printf("soft err "); ! 3087: xlster |= XLSSFT; ! 3088: } ! 3089: ! 3090: pfint = xlnull; /* exit */ ! 3091: (*pfsts)(); ! 3092: } ! 3093: ! 3094: static void ! 3095: xlstatus1() ! 3096: { ! 3097: if (xlster) { /* exit if error */ ! 3098: pfint = xlnull; ! 3099: (*pfsts)(); ! 3100: return; ! 3101: } ! 3102: xl7sts = xlrnbw; /* save type 7 status */ ! 3103: xlDbPrintErr(xl7sts); ! 3104: pfint = xlrn9; /* restart normal status sequce */ ! 3105: pfrnb = xlstatus0; ! 3106: xloutput_step(QIC_CMD_STS); ! 3107: } ! 3108: ! 3109: /************************************************************************ ! 3110: * xltimout set timeout for int ! 3111: * ! 3112: * "cnt" is number of ticks. if zero, cancel any pending timeout ! 3113: ***********************************************************************/ ! 3114: static void ! 3115: xltimout(cnt) ! 3116: int cnt; ! 3117: { ! 3118: if (cnt) ! 3119: timeout(&xltmo, cnt, xltimfn, 0); ! 3120: else ! 3121: timeout(&xltmo, cnt, NULL, 0); ! 3122: } ! 3123: ! 3124: static void ! 3125: xltimfn() ! 3126: { ! 3127: cmn_err(CE_CONT, "Timeout!!\n"); ! 3128: xltimoutf = 1; ! 3129: xlfdc_reset(); ! 3130: } ! 3131: ! 3132: /************************************************************************/ ! 3133: /* xlwait wait for xlcomplete (xlcompw wakeup) */ ! 3134: /************************************************************************/ ! 3135: static int ! 3136: xlwait() ! 3137: { ! 3138: register int ilvl; ! 3139: ! 3140: ilvl = spl5(); ! 3141: while(!xlcompf) { /* wait for xlcompf to be set */ ! 3142: xlcompw = 1; ! 3143: if (x_sleep(&xlcompw, pritape, slpriSigCatch, "xlwait")) { ! 3144: printf("xlwait signaled "); ! 3145: return 1; ! 3146: } ! 3147: } ! 3148: xlcompf = 0; /* reset flag */ ! 3149: splx(ilvl); ! 3150: return 0; ! 3151: } ! 3152: ! 3153: /************************************************************************/ ! 3154: /* xlwds write del adm segment */ ! 3155: /* in: xprb = pointer to rb */ ! 3156: /************************************************************************/ ! 3157: static void ! 3158: xlwds() ! 3159: { ! 3160: pfwts = pfwds; /* using xlwts */ ! 3161: if (xlster) { /* exit if error */ ! 3162: pfint = xlwt0; /* use null int to cleanup stck */ ! 3163: xloutput_step(0); ! 3164: return; ! 3165: } ! 3166: rwdcms[0] = 0x49; /* set for write del adm */ ! 3167: stseg(xprb); ! 3168: xrty = 2; ! 3169: pfint = xlwt1; ! 3170: xlwt0(); ! 3171: } ! 3172: ! 3173: /************************************************************************/ ! 3174: /* xlwts write segment */ ! 3175: /* in: xprb = pointer to rb */ ! 3176: /************************************************************************/ ! 3177: static void ! 3178: xlwts() ! 3179: { ! 3180: if (xlster) { /* exit if error */ ! 3181: pfint = xlwt0; /* use null int to cleanup stck */ ! 3182: xloutput_step(0); ! 3183: return; ! 3184: } ! 3185: rwdcms[0] = 0x45; /* set for write */ ! 3186: stseg(xprb); ! 3187: xlwt0(); ! 3188: } ! 3189: ! 3190: static void ! 3191: xlwt0() /* start io */ ! 3192: { ! 3193: if (xlster) { /* exit if error */ ! 3194: xprb->sts = 1; ! 3195: pfint = xlnull; ! 3196: (*pfwts)(); ! 3197: return; ! 3198: } ! 3199: xtbl = (xprb->tbl)[xsct - xprb->sct];/* get rb.tbl entry */ ! 3200: if (xtbl) { /* if more data start other write */ ! 3201: pfint = xlwt1; ! 3202: rwdcms[4] = (xtbl & 0x1f) + xprb->sct; ! 3203: stdma(DMA_Wrmode, xadr | ((xtbl & 0x3e0) << 5), (int)(xtbl & 0xfc00)); ! 3204: xltimout(IOTMO); ! 3205: xlfdc_out_str(rwdcms, 9); ! 3206: if (status_buf[7]) { /* exit if nec error */ ! 3207: xltimout(0); ! 3208: xlster |= XLSNEC; ! 3209: xprb->sts = 1; ! 3210: pfint = xlnull; ! 3211: (*pfwts)(); ! 3212: return; ! 3213: } ! 3214: return; ! 3215: } ! 3216: else{ /* else, seg is ok */ ! 3217: xprb->sts = 0; ! 3218: tpseg = xprb->tps + 1; ! 3219: if (tpseg == nseg_p_track) { /* if last seg on trk, */ ! 3220: pfrdy = pfwts; /* exit via xlready */ ! 3221: xlready(); ! 3222: return; ! 3223: } ! 3224: pfint = xlnull; /* else just exit */ ! 3225: (*pfwts)(); ! 3226: return; ! 3227: } ! 3228: } ! 3229: ! 3230: static void ! 3231: xlwt1() ! 3232: { ! 3233: if (xlster) { /* exit if error */ ! 3234: xprb->sts = 1; ! 3235: pfint = xlnull; ! 3236: (*pfwts)(); ! 3237: return; ! 3238: } ! 3239: if (status_buf[0] & 0xc0) { /* check for io error */ ! 3240: dsperr(); ! 3241: if (status_buf[0] == 0xc0)/* adjust tpseg */ ! 3242: tpseg += TMSKP; ! 3243: else ! 3244: tpseg += 2; ! 3245: if (status_buf[0] != 0xc0)/* update xsct */ ! 3246: xsct = status_buf[5]; ! 3247: --xrty; /* retry if more to try */ ! 3248: if (xrty) { ! 3249: pfpos = xlwt0; ! 3250: xlpos(); ! 3251: return; ! 3252: } ! 3253: else{ ! 3254: /* if del adm write, continue */ ! 3255: if (rwdcms[0] == 0x49) { ! 3256: ++xsct; ! 3257: xrty = 2; ! 3258: pfpos = xlwt0; ! 3259: xlpos(); ! 3260: return; ! 3261: } ! 3262: xprb->sts = 1; /* give up on segment, exit */ ! 3263: pfint = xlnull; ! 3264: (*pfwts)(); ! 3265: return; ! 3266: } ! 3267: } ! 3268: xsct = status_buf[5]; /* if no error, start next io */ ! 3269: xlwt0(); ! 3270: } ! 3271: ! 3272: /******************* DEBUG AREA ******************/ ! 3273: static char *qicErr[] = { ! 3274: "NULL err", ! 3275: "command received while drive not ready", ! 3276: "cartridge not present or removed", ! 3277: "motor speed error (not within 1%)", ! 3278: "motor speed fault (jammed, or gross speed error)", ! 3279: "cartridge write protected", ! 3280: "undefined or reserved command code", ! 3281: "illegal track address specified for seek", ! 3282: "illegal command in report subcontext", ! 3283: "illegal entry into a diagnostic mode", ! 3284: "broken tape detected (based on hole sensor)", ! 3285: "warning - read gain setting error", ! 3286: "command received while error status pending (obsolete)", ! 3287: "command received while new cartridge pending", ! 3288: "command illegal or undefined in primary mode", ! 3289: "command illegal or undefined in format mode", ! 3290: "command illegal or undefined in verify mode", ! 3291: "logical forward not at logical BOT in format mode", ! 3292: "logical EOT before all segments generated", ! 3293: "command illegal when cartridge not referenced", ! 3294: "self-diagnostic failed (cannot be cleared)", ! 3295: "warning EEPROM not initialized, defaults set", ! 3296: "EEPROM corrupt or hardware failure", ! 3297: "motion timeout error", ! 3298: "data segment too long - logical forward or pause", ! 3299: "transmit overrun (obsolete)", ! 3300: "power on reset occurred", ! 3301: "software reset occurred", ! 3302: "diagnostic mode 1 error", ! 3303: "diagnostic mode 2 error", ! 3304: "command received during noninterruptible process", ! 3305: "rate selection error", ! 3306: "illegal command while in high speed mode", ! 3307: "illegal seek segment value" ! 3308: }; ! 3309: ! 3310: static char *qicStat[] = { ! 3311: "drive ready or idle", ! 3312: "error detected", ! 3313: "cartridge present", ! 3314: "cartridge write protected", ! 3315: "new cartridge", ! 3316: "cartridge referenced", ! 3317: "at physical BOT", ! 3318: "at physical EOT" ! 3319: }; ! 3320: ! 3321: static char *qicCmd[] = { ! 3322: "NULL cmd", ! 3323: "soft reset", ! 3324: "report next bit", ! 3325: "pause", ! 3326: "micro step pause", ! 3327: "alternate command timeout", ! 3328: "report drive status", ! 3329: "report error code", ! 3330: "report drive configuration", ! 3331: "report ROM version", ! 3332: "logical forward", ! 3333: "physical reverse", ! 3334: "physical forward", ! 3335: "seek head to track", ! 3336: "seek load point", ! 3337: "enter format mode", ! 3338: "write reference burst", ! 3339: "enter verify mode", ! 3340: "stop tape", ! 3341: "reserved (19)", ! 3342: "reserved (20)", ! 3343: "micro step head up", ! 3344: "micro step head down", ! 3345: "reserved (23)", ! 3346: "reserved (24)", ! 3347: "skip n segments reverse", ! 3348: "skip n segments forward", ! 3349: "select rate", ! 3350: "enter diag mode 1", ! 3351: "enter diag mode 2", ! 3352: "enter primary mode", ! 3353: "reserved (31)", ! 3354: "report vendor ID", ! 3355: "report tape status", ! 3356: "skip n segments extended reverse", ! 3357: "skip n segments extended forward" ! 3358: }; ! 3359: ! 3360: /* print 2-byte error status as <error-code,command> */ ! 3361: static void ! 3362: xlDbPrintErr(errword) ! 3363: unsigned int errword; ! 3364: { ! 3365: unsigned int lo, hi; ! 3366: ! 3367: lo = errword & 0xff; ! 3368: hi = (errword >> 8) & 0xff; ! 3369: ! 3370: if (lo >= 1 && lo < sizeof(qicErr)/sizeof(qicErr[0])) ! 3371: printf("<%s,", qicErr[lo]); ! 3372: else ! 3373: printf("<%x,", lo); ! 3374: ! 3375: if (hi >= 1 && hi < sizeof(qicCmd)/sizeof(qicCmd[0])) ! 3376: printf("%s> ", qicCmd[hi]); ! 3377: else ! 3378: printf("%x> ", hi); ! 3379: } ! 3380: ! 3381: /* print command as [command] */ ! 3382: static void ! 3383: xlDbPrintCmd(cmd) ! 3384: unsigned int cmd; ! 3385: { ! 3386: if (cmd >= 1 && cmd < sizeof(qicCmd)/sizeof(qicCmd[0])) { ! 3387: if (cmd == QIC_CMD_RNB) ! 3388: putchar ('.'); ! 3389: else ! 3390: printf("[%s] ", qicCmd[cmd]); ! 3391: } else ! 3392: printf("[%d] ", cmd); ! 3393: } ! 3394: ! 3395: /* print tape status as { status string,... } */ ! 3396: static void ! 3397: xlDbPrintStat(stat) ! 3398: unsigned int stat; ! 3399: { ! 3400: int i; ! 3401: ! 3402: printf("{ "); ! 3403: for (i = 0; i < 8; i++) { ! 3404: if (stat & (1 << i)) ! 3405: printf("%s, ", qicStat[i]); ! 3406: } ! 3407: putchar('}'); ! 3408: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.