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