![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tapcmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / qic117|
Return to tapcmd.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / qic117 |
1.1 ! root 1: /*++ ! 2: ! 3: Copyright (c) 1993 - Colorado Memory Systems, Inc. ! 4: All Rights Reserved ! 5: ! 6: Module Name: ! 7: ! 8: tapecmd.c ! 9: ! 10: Abstract: ! 11: ! 12: ! 13: Revision History: ! 14: ! 15: ! 16: ! 17: ! 18: --*/ ! 19: ! 20: // ! 21: // include files ! 22: // ! 23: ! 24: #include <ntddk.h> // various NT definitions ! 25: #include <ntdddisk.h> // disk device driver I/O control codes ! 26: #include <ntiologc.h> ! 27: #include "common.h" ! 28: #include "drvtask.h" // this driver's data declarations ! 29: #include "mt1defs.h" // this driver's data declarations ! 30: #include "mt1strc.h" // this driver's data declarations ! 31: #include "q117data.h" // this driver's data declarations ! 32: ! 33: ! 34: STATUS ! 35: Q117iTapeCommands( ! 36: IN PTAPE_EXTENSION TapeExtension, ! 37: IN OUT PIO_REQUEST IoRequestCurrent, ! 38: IN OUT PIRP Irp ! 39: ) ! 40: ! 41: /*++ ! 42: ! 43: Routine Description: ! 44: ! 45: Execute an IORequest command. TapeCommands is merely a command controller, ! 46: calling the appropriate routines to execute the IORequiest commands. ! 47: ! 48: Arguments: ! 49: ! 50: TapeExtension - ! 51: ! 52: IoRequestCurrent - ! 53: ! 54: Irp - ! 55: ! 56: Return Value: ! 57: ! 58: ! 59: --*/ ! 60: ! 61: { ! 62: int retval = NoErr; ! 63: ! 64: if (TapeExtension->Found == FALSE && ! 65: IoRequestCurrent->Command != DFndDrv && ! 66: IoRequestCurrent->Command != DGetFDC ! 67: ) { ! 68: ! 69: return(NoDrive); ! 70: ! 71: } ! 72: ! 73: switch (IoRequestCurrent->Command) { ! 74: ! 75: case DFndDrv: ! 76: retval = Q117iDFndDrv(TapeExtension); ! 77: break; ! 78: ! 79: case DRead: ! 80: case DWrite: ! 81: case DVerify: ! 82: case DRetry: ! 83: case DWriteBad: ! 84: case DReadBad: ! 85: retval = Q117iReadWrite(TapeExtension, IoRequestCurrent, Irp); ! 86: break; ! 87: ! 88: case DFmt: ! 89: retval = Q117iDFmt(TapeExtension, Irp, IoRequestCurrent); ! 90: break; ! 91: ! 92: case DEject: ! 93: retval = Q117iDEject(TapeExtension); ! 94: break; ! 95: ! 96: case DFast: ! 97: case DSlow: ! 98: retval = Q117iDFast_DSlow(TapeExtension, IoRequestCurrent->Command); ! 99: break; ! 100: ! 101: case DSndWPro: ! 102: retval = Q117iDSndWPro(TapeExtension); ! 103: break; ! 104: ! 105: case DGetRev: ! 106: retval = Q117iDGetRev(TapeExtension, IoRequestCurrent->Data); ! 107: break; ! 108: ! 109: case DReten: ! 110: retval = Q117iDReten(TapeExtension); ! 111: break; ! 112: ! 113: case DGetCap: ! 114: retval = Q117iDGetCap(TapeExtension, IoRequestCurrent->Data); ! 115: break; ! 116: ! 117: case DChkDrv: ! 118: retval = Q117iDChkDrv(TapeExtension, IoRequestCurrent->Data); ! 119: break; ! 120: ! 121: case DSndReel: ! 122: retval = Q117iDSndReel(TapeExtension); ! 123: break; ! 124: ! 125: case DGetCart: ! 126: retval = Q117iDGetCart(TapeExtension, IoRequestCurrent->Data); ! 127: break; ! 128: ! 129: case DGetSpeed: ! 130: retval = Q117iDGetSpeed(TapeExtension, IoRequestCurrent->Data); ! 131: break; ! 132: ! 133: case DStatus: ! 134: retval = Q117iDStatus(TapeExtension, IoRequestCurrent->Data); ! 135: break; ! 136: ! 137: case DGetFDC: ! 138: retval = Q117iDGetFDC(TapeExtension, IoRequestCurrent->Data); ! 139: break; ! 140: ! 141: case DReportProtoVer: ! 142: retval = Q117iDReportProtoVer(TapeExtension, IoRequestCurrent->Data); ! 143: break; ! 144: ! 145: case DSelPart: ! 146: case DGetPos: ! 147: case DIgnore: ! 148: case DUseLock: ! 149: break; ! 150: ! 151: case DGetDriveInfo: ! 152: retval = Q117iDGetDriveInfo(TapeExtension, IoRequestCurrent->Data); ! 153: break; ! 154: ! 155: case DChkFmt: ! 156: retval = Q117iDChkFmt(TapeExtension); ! 157: break; ! 158: ! 159: case DDeselect: ! 160: retval = Q117iDDeselect(TapeExtension); ! 161: break; ! 162: ! 163: case DClearNewCart: ! 164: CheckedDump(QIC117SHOWTD,("Q117i: DClearNewCart received\n")); ! 165: TapeExtension->PersistentNewCart = FALSE; ! 166: retval = NoErr; ! 167: break; ! 168: ! 169: default: ! 170: retval = InvalCmd; ! 171: break; ! 172: ! 173: } ! 174: ! 175: return(retval); ! 176: } ! 177: ! 178: ! 179: STATUS ! 180: Q117iDEject( ! 181: IN PTAPE_EXTENSION TapeExtension ! 182: ) ! 183: ! 184: /*++ ! 185: ! 186: Routine Description: ! 187: ! 188: Position the tape to the physical BOT and track 0. ! 189: ! 190: Arguments: ! 191: ! 192: TapeExtension - ! 193: ! 194: Return Value: ! 195: ! 196: ! 197: --*/ ! 198: ! 199: { ! 200: STATUS retval; ! 201: ! 202: if ((retval = Q117iStopTape(TapeExtension)) != NoErr) { ! 203: ! 204: return(retval); ! 205: ! 206: } ! 207: ! 208: if((retval = Q117iSendByte(TapeExtension, Physical_Rev)) != NoErr) { ! 209: ! 210: return(retval); ! 211: ! 212: } ! 213: ! 214: if((retval = Q117iWaitCommandComplete( ! 215: TapeExtension, ! 216: TapeExtension->TapeParms.TimeOut[PHYSICAL])) != NoErr) { ! 217: ! 218: return(retval); ! 219: ! 220: } ! 221: ! 222: TapeExtension->TapePosition.C_Segment = 0; ! 223: ! 224: if (TapeExtension->DriveParms.Flavor == ! 225: CMS && !TapeExtension->DriveParms.Status.Referenced) { ! 226: ! 227: // ! 228: // Park the head if the tape is not referenced and the drive is Jumbo ! 229: // A. (Do nothing if tape not referenced and the drive is Jumbo B). ! 230: // ! 231: ! 232: if (TapeExtension->DriveParms.Version < FIRM_VERSION_60) { ! 233: ! 234: if ((retval = Q117iSetDriveMode(TapeExtension, DIAGNOSTIC_1_MODE)) != NoErr) { ! 235: ! 236: return(retval); ! 237: ! 238: } ! 239: ! 240: if ((retval = Q117iSendByte(TapeExtension, Park_Head)) != NoErr) { ! 241: ! 242: return(retval); ! 243: ! 244: } ! 245: ! 246: // ! 247: // Can't use Q117iWaitCommandComplete since the drive ready bit ! 248: // of the status byte is not updated during the Park_Head command. ! 249: // Because of this, you must sleep until the head is parked or ! 250: // the drive will not "see" the set primary mode command. ! 251: // ! 252: ! 253: Q117iSleep(TapeExtension, mt_wt007s, FALSE); ! 254: Q117iSetDriveMode(TapeExtension, PRIMARY_MODE); ! 255: retval = Q117iWaitCommandComplete(TapeExtension, mt_wt007s); ! 256: TapeExtension->TapePosition.C_Track = -1; ! 257: ! 258: } ! 259: ! 260: } else { ! 261: ! 262: if ((retval = Q117iSendByte(TapeExtension, Seek_Track)) != NoErr) { ! 263: ! 264: return(retval); ! 265: ! 266: } ! 267: ! 268: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE); ! 269: ! 270: if ((retval = Q117iSendByte(TapeExtension, 2 /* Track 0 */)) != NoErr) { ! 271: ! 272: return(retval); ! 273: ! 274: } ! 275: ! 276: retval = Q117iWaitCommandComplete(TapeExtension, mt_wt007s); ! 277: TapeExtension->TapePosition.C_Track = 0; ! 278: ! 279: } ! 280: ! 281: return(retval); ! 282: } ! 283: ! 284: ! 285: STATUS ! 286: Q117iDReten( ! 287: IN PTAPE_EXTENSION TapeExtension ! 288: ) ! 289: ! 290: /*++ ! 291: ! 292: Routine Description: ! 293: ! 294: Retension the tape by first going to physical EOT then turning around and ! 295: going to physical BOT ! 296: ! 297: Arguments: ! 298: ! 299: TapeExtension - ! 300: ! 301: Return Value: ! 302: ! 303: ! 304: --*/ ! 305: ! 306: { ! 307: STATUS retval; ! 308: ! 309: if ((retval = Q117iSendByte(TapeExtension, Physical_Fwd)) != NoErr) { ! 310: ! 311: return(retval); ! 312: ! 313: } ! 314: ! 315: if ((retval = Q117iWaitCommandComplete( ! 316: TapeExtension, ! 317: TapeExtension->TapeParms.TimeOut[PHYSICAL])) ! 318: != NoErr) { ! 319: ! 320: return(retval); ! 321: ! 322: } ! 323: ! 324: if ((retval = Q117iSendByte(TapeExtension, Physical_Rev)) != NoErr) { ! 325: ! 326: return(retval); ! 327: ! 328: } ! 329: ! 330: if ((retval = Q117iWaitCommandComplete( ! 331: TapeExtension, ! 332: TapeExtension->TapeParms.TimeOut[PHYSICAL])) ! 333: != NoErr) { ! 334: ! 335: return(retval); ! 336: ! 337: } ! 338: ! 339: TapeExtension->TapePosition.C_Segment = 0; ! 340: return(NoErr); ! 341: ! 342: } ! 343: ! 344: ! 345: STATUS ! 346: Q117iDFast_DSlow( ! 347: IN PTAPE_EXTENSION TapeExtension, ! 348: IN DRIVER_COMMAND Command ! 349: ) ! 350: ! 351: /*++ ! 352: ! 353: Routine Description: ! 354: ! 355: Set the operating speed of the tape drive and the corresponding transfer ! 356: rate of the FDC. Setting the operating speed can currently be done only ! 357: on CMS drives. It is assumed that no ther drive manufacturers have ! 358: multi-speed drive. ! 359: ! 360: Arguments: ! 361: ! 362: TapeExtension - ! 363: ! 364: Command - ! 365: ! 366: Return Value: ! 367: ! 368: ! 369: --*/ ! 370: ! 371: { ! 372: STATUS retval; ! 373: struct DriveConfiguration driveConfig; ! 374: CHAR newSpeed; ! 375: ! 376: if ((retval = Q117iStopTape(TapeExtension)) != NoErr) { ! 377: ! 378: return(retval); ! 379: ! 380: } ! 381: ! 382: if (Command == DFast) { ! 383: ! 384: TapeExtension->XferRate.XferRate = FAST; ! 385: ! 386: } else { ! 387: ! 388: TapeExtension->XferRate.XferRate = SLOW; ! 389: ! 390: } ! 391: ! 392: if ((retval = Q117iSendByte(TapeExtension, Select_Speed)) != NoErr) { ! 393: ! 394: return(retval); ! 395: ! 396: } ! 397: ! 398: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE); ! 399: ! 400: if (Command == DFast) { ! 401: ! 402: newSpeed = TapeExtension->XferRate.TapeFast + 2; ! 403: ! 404: } else { ! 405: ! 406: newSpeed = TapeExtension->XferRate.TapeSlow + 2; ! 407: ! 408: } ! 409: ! 410: if ((retval = Q117iSendByte(TapeExtension, newSpeed)) != NoErr) { ! 411: ! 412: return(retval); ! 413: ! 414: } ! 415: ! 416: Q117iConfigureFDC(TapeExtension); ! 417: ! 418: if ((retval = Q117iWaitCommandComplete(TapeExtension, mt_wt010s)) != NoErr) { ! 419: ! 420: return(retval); ! 421: ! 422: } ! 423: ! 424: if ((retval = Q117iReport(TapeExtension, ! 425: Report_Confg, ! 426: (USHORT *)&driveConfig, ! 427: READ_BYTE, ! 428: NULL)) ! 429: != NoErr) { ! 430: ! 431: return(retval); ! 432: ! 433: } ! 434: ! 435: if (Command == DFast ? ! 436: driveConfig.XferRate != TapeExtension->XferRate.TapeFast : ! 437: driveConfig.XferRate != TapeExtension->XferRate.TapeSlow) { ! 438: ! 439: retval = TapeFlt; ! 440: TapeExtension->FirmwareError = Speed_not_Avail; ! 441: ! 442: } ! 443: ! 444: return(retval); ! 445: } ! 446: ! 447: ! 448: STATUS ! 449: Q117iDGetRev( ! 450: IN PTAPE_EXTENSION TapeExtension, ! 451: OUT PUCHAR Version ! 452: ) ! 453: ! 454: /*++ ! 455: ! 456: Routine Description: ! 457: ! 458: Get the current version of firmware in the tape drive. ! 459: ! 460: Arguments: ! 461: ! 462: TapeExtension - ! 463: ! 464: Version - ! 465: ! 466: Return Value: ! 467: ! 468: ! 469: --*/ ! 470: ! 471: { ! 472: STATUS retval; ! 473: UCHAR ROM_Version; ! 474: ! 475: if ((retval = Q117iReport(TapeExtension, ! 476: Report_ROM, ! 477: (USHORT *)&ROM_Version, ! 478: READ_BYTE, ! 479: NULL)) ! 480: != NoErr) { ! 481: ! 482: return(retval); ! 483: ! 484: } ! 485: ! 486: *Version = ROM_Version; ! 487: return(NoErr); ! 488: } ! 489: ! 490: ! 491: STATUS ! 492: Q117iDGetCap( ! 493: IN PTAPE_EXTENSION TapeExtension, ! 494: struct S_O_DGetCap *Capacity ! 495: ) ! 496: ! 497: /*++ ! 498: ! 499: Routine Description: ! 500: ! 501: Get the current tape type, which includes the tape format (if any) and ! 502: the tape length ( in the case of a QIC-40 format tape). If the tape is ! 503: not referenced then that information must be included. ! 504: ! 505: Arguments: ! 506: ! 507: TapeExtension - ! 508: ! 509: Capacity - ! 510: ! 511: Return Value: ! 512: ! 513: ! 514: --*/ ! 515: ! 516: { ! 517: STATUS retval; ! 518: ! 519: retval = Q117iGetTapeParameters(TapeExtension); ! 520: ! 521: if (!retval) { ! 522: ! 523: // ! 524: // floppy sectors per segment ! 525: // ! 526: Capacity->SectsPerSegment = TapeExtension->TapeParms.FsectSeg; ! 527: ! 528: // ! 529: // segments per tape track ! 530: // ! 531: Capacity->SegmentsPerTrack = TapeExtension->TapeParms.SegTtrack; ! 532: ! 533: // ! 534: // number of tape tracks ! 535: // ! 536: Capacity->TracksPerTape = TapeExtension->TapeParms.NumTtrack; ! 537: ! 538: // ! 539: // segments per floppy track ! 540: // ! 541: Capacity->SegmentsPerFTrack = TapeExtension->TapeParms.SegFtrack; ! 542: ! 543: // ! 544: // floppy tracks per floppy side ! 545: // ! 546: Capacity->FTrackPerFSide = TapeExtension->TapeParms.FtrackFside; ! 547: ! 548: // ! 549: // floppy sectors per floppy track ! 550: // ! 551: Capacity->MaxFSector = TapeExtension->TapeParms.FsectFtrack; ! 552: ! 553: Capacity->drive_type = TapeExtension->DriveParms.DriveType; ! 554: ! 555: if (TapeExtension->DriveParms.Status.Referenced) { ! 556: ! 557: Capacity->referenced = TRUE; ! 558: ! 559: } else { ! 560: ! 561: Capacity->referenced = FALSE; ! 562: ! 563: } ! 564: ! 565: Capacity->TapeFormatCode = TapeExtension->TapeParms.TapeFormatCode; ! 566: ! 567: Capacity->FormattableSegments = ! 568: TapeExtension->TapeParms.FormattableSegs; ! 569: ! 570: } ! 571: ! 572: return(retval); ! 573: } ! 574: ! 575: ! 576: ! 577: STATUS ! 578: Q117iDComFirm( ! 579: IN PTAPE_EXTENSION TapeExtension, ! 580: IN OUT PUCHAR CommandString ! 581: ) ! 582: ! 583: /*++ ! 584: ! 585: Routine Description: ! 586: ! 587: Send and receive non-standard data to/from the tape drive. ! 588: ! 589: Arguments: ! 590: ! 591: TapeExtension - ! 592: ! 593: CommandString - ! 594: ! 595: Return Value: ! 596: ! 597: ! 598: --*/ ! 599: ! 600: { ! 601: STATUS retval = NoErr; ! 602: UCHAR tCount; ! 603: CHAR sendData; ! 604: USHORT receiveData; ! 605: SHORT waitTime; ! 606: SHORT receiveLength; ! 607: ! 608: tCount = *CommandString++; ! 609: ! 610: while (tCount) { ! 611: ! 612: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE); ! 613: ! 614: sendData = *CommandString++; ! 615: ! 616: if ((retval = Q117iSendByte(TapeExtension, sendData)) != NoErr) { ! 617: ! 618: return(retval); ! 619: } ! 620: ! 621: --tCount; ! 622: ! 623: } ! 624: ! 625: tCount = *CommandString++; ! 626: ! 627: switch (tCount) { ! 628: ! 629: case 0xff: ! 630: retval = Q117iWaitCommandComplete(TapeExtension, mt_wt300s); ! 631: break; ! 632: ! 633: case 0xfe: ! 634: waitTime = *(SHORT *)CommandString; ! 635: ! 636: if (waitTime) { ! 637: ! 638: Q117iSleep(TapeExtension, waitTime, FALSE); ! 639: ! 640: } ! 641: ! 642: break; ! 643: ! 644: default: ! 645: if (tCount == 0xfd) { ! 646: ! 647: TapeExtension->NoPause = TRUE; ! 648: tCount = *CommandString++; ! 649: ! 650: } ! 651: ! 652: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE); ! 653: ! 654: if (tCount != 0) { ! 655: ! 656: if (tCount == 1) { ! 657: ! 658: receiveLength = READ_BYTE; ! 659: ! 660: } else { ! 661: ! 662: receiveLength = READ_WORD; ! 663: ! 664: } ! 665: ! 666: if ((retval = Q117iReceiveByte(TapeExtension, ! 667: receiveLength, ! 668: &receiveData)) ! 669: != NoErr) { ! 670: ! 671: return(retval); ! 672: ! 673: } ! 674: ! 675: if (tCount == 1) { ! 676: ! 677: *CommandString = (CHAR)receiveData; ! 678: ! 679: } else { ! 680: ! 681: *(USHORT *)CommandString = receiveData; ! 682: ! 683: } ! 684: ! 685: } ! 686: ! 687: break; ! 688: ! 689: } ! 690: return(retval); ! 691: } ! 692: ! 693: STATUS ! 694: Q117iDSndWPro( ! 695: IN PTAPE_EXTENSION TapeExtension ! 696: ) ! 697: ! 698: /*++ ! 699: ! 700: Routine Description: ! 701: ! 702: Report the write protect status of the tape. ! 703: ! 704: Arguments: ! 705: ! 706: TapeExtension - ! 707: ! 708: Return Value: ! 709: ! 710: ! 711: --*/ ! 712: ! 713: { ! 714: STATUS retval; ! 715: ! 716: if((retval = Q117iGetDriveError(TapeExtension)) == NoErr) { ! 717: ! 718: if (TapeExtension->DriveParms.Status.WriteProtect) { ! 719: ! 720: retval = WProt; ! 721: ! 722: } ! 723: ! 724: } ! 725: ! 726: return(retval); ! 727: } ! 728: ! 729: STATUS ! 730: Q117iDSndReel( ! 731: IN PTAPE_EXTENSION TapeExtension ! 732: ) ! 733: ! 734: /*++ ! 735: ! 736: Routine Description: ! 737: ! 738: Return cartridge in status. ! 739: ! 740: Arguments: ! 741: ! 742: TapeExtension - ! 743: ! 744: Return Value: ! 745: ! 746: ! 747: --*/ ! 748: ! 749: { ! 750: STATUS retval; ! 751: ! 752: retval = Q117iGetDriveError(TapeExtension); ! 753: ! 754: if (retval == NoErr || retval == NewCart) { ! 755: ! 756: if (TapeExtension->NewCart) { ! 757: ! 758: Q117iNewTape(TapeExtension); ! 759: ! 760: } ! 761: ! 762: retval = NoErr; ! 763: ! 764: } else { ! 765: ! 766: if (retval == NotRdy) { ! 767: ! 768: retval = NoTape; ! 769: ! 770: } ! 771: ! 772: } ! 773: ! 774: return(retval); ! 775: } ! 776: ! 777: STATUS ! 778: Q117iDGetCart( ! 779: IN PTAPE_EXTENSION TapeExtension, ! 780: OUT PUCHAR TapeType ! 781: ) ! 782: ! 783: /*++ ! 784: ! 785: Routine Description: ! 786: ! 787: Return new cartidge status as necessary. ! 788: ! 789: Arguments: ! 790: ! 791: TapeExtension - ! 792: ! 793: TapeType - ! 794: ! 795: Return Value: ! 796: ! 797: ! 798: --*/ ! 799: ! 800: { ! 801: STATUS retval; ! 802: ! 803: retval = Q117iWaitCommandComplete(TapeExtension, mt_wt150s); ! 804: ! 805: if (retval == NoErr || retval == NewCart) { ! 806: ! 807: if (TapeExtension->NewCart) { ! 808: ! 809: // ! 810: // If there is an illegitimate write protect status due to the ! 811: // firmware 63 bug, the call to Q117iNewTape will clear the ! 812: // write-protect bit from the status byte. ! 813: // ! 814: ! 815: retval = Q117iNewTape(TapeExtension); ! 816: ! 817: if (retval == NoErr) { ! 818: ! 819: retval = NewCart; ! 820: } ! 821: ! 822: } ! 823: ! 824: } else { ! 825: ! 826: // ! 827: // This is to test to see if the tape drive erroneously thought the ! 828: // tape was invalide media and correct the error if so ! 829: // ! 830: ! 831: if (retval == TapeFlt && TapeExtension->FirmwareError == Inval_Media) { ! 832: ! 833: retval = Q117iNewTape(TapeExtension); ! 834: ! 835: if (retval == NoErr) { ! 836: ! 837: retval = NewCart; ! 838: } ! 839: ! 840: } ! 841: ! 842: } ! 843: ! 844: *TapeType = TapeExtension->TapeParms.TapeType; ! 845: return(retval); ! 846: } ! 847: ! 848: ! 849: STATUS ! 850: Q117iDChkDrv( ! 851: IN PTAPE_EXTENSION TapeExtension, ! 852: OUT PUCHAR DriveType ! 853: ) ! 854: ! 855: /*++ ! 856: ! 857: Routine Description: ! 858: ! 859: Return the drive manufacturer (CMS or ALIEN). ! 860: ! 861: Arguments: ! 862: ! 863: TapeExtension - ! 864: ! 865: DriveType - ! 866: ! 867: Return Value: ! 868: ! 869: ! 870: --*/ ! 871: ! 872: { ! 873: *DriveType = TapeExtension->DriveParms.Flavor; ! 874: return(NoErr); ! 875: } ! 876: ! 877: STATUS ! 878: Q117iDGetSpeed( ! 879: IN PTAPE_EXTENSION TapeExtension, ! 880: OUT struct S_O_DGetSpeed *TransferRate ! 881: ) ! 882: ! 883: /*++ ! 884: ! 885: Routine Description: ! 886: ! 887: Return the current FDC transfer rate. ! 888: ! 889: Arguments: ! 890: ! 891: TapeExtension - ! 892: ! 893: TransferRate- ! 894: ! 895: Return Value: ! 896: ! 897: ! 898: --*/ ! 899: ! 900: { ! 901: switch (TapeExtension->XferRate.XferRate ? ! 902: TapeExtension->XferRate.TapeFast : ! 903: TapeExtension->XferRate.TapeSlow) { ! 904: ! 905: case TAPE_250Kbps: ! 906: TransferRate->CurSpeed = 250/8; ! 907: break; ! 908: ! 909: case TAPE_500Kbps: ! 910: TransferRate->CurSpeed = 500/8; ! 911: break; ! 912: ! 913: case TAPE_1Mbps: ! 914: TransferRate->CurSpeed = 1000/8; ! 915: break; ! 916: ! 917: case TAPE_2Mbps: ! 918: TransferRate->CurSpeed = 2000/8; ! 919: break; ! 920: ! 921: } ! 922: ! 923: switch (TapeExtension->XferRate.MaxRate ? ! 924: TapeExtension->XferRate.FDC_Fast : ! 925: TapeExtension->XferRate.FDC_Slow) { ! 926: ! 927: case FDC_250Kbps: ! 928: TransferRate->FmtSpeed = 250/8; ! 929: break; ! 930: ! 931: case FDC_500Kbps: ! 932: TransferRate->FmtSpeed = 500/8; ! 933: break; ! 934: ! 935: case FDC_1Mbps: ! 936: TransferRate->FmtSpeed = 1000/8; ! 937: break; ! 938: ! 939: case FDC_2Mbps: ! 940: TransferRate->FmtSpeed = 2000/8; ! 941: break; ! 942: ! 943: } ! 944: ! 945: return(NoErr); ! 946: } ! 947: ! 948: STATUS ! 949: Q117iDStatus( ! 950: IN PTAPE_EXTENSION TapeExtension, ! 951: OUT struct S_O_DStatus *DriveStatus ! 952: ) ! 953: ! 954: /*++ ! 955: ! 956: Routine Description: ! 957: ! 958: ! 959: ! 960: Arguments: ! 961: ! 962: TapeExtension - ! 963: ! 964: DriveStatus - ! 965: ! 966: Return Value: ! 967: ! 968: ! 969: --*/ ! 970: ! 971: { ! 972: DriveStatus->underruns = 0; ! 973: // DriveStatus->retries = cmd_SoftErrors; ! 974: ! 975: return(NoErr); ! 976: } ! 977: ! 978: ! 979: ! 980: STATUS ! 981: Q117iDGetFDC( ! 982: IN PTAPE_EXTENSION TapeExtension, ! 983: OUT PUCHAR FdcType ! 984: ) ! 985: ! 986: /*++ ! 987: ! 988: Routine Description: ! 989: ! 990: Determine whether or not the floppy controller is an 82077. ! 991: ! 992: Arguments: ! 993: ! 994: TapeExtension - ! 995: ! 996: FdcType - ! 997: ! 998: Return Value: ! 999: ! 1000: ! 1001: --*/ ! 1002: ! 1003: { ! 1004: STATUS retval = NoErr; ! 1005: SHORT i, test; ! 1006: UCHAR status = 0; ! 1007: SHORT statLength = 0; ! 1008: struct version_cmd verCmd; ! 1009: struct national_cmd nscCmd; ! 1010: struct PerpMode perpMode; ! 1011: struct part_id_cmd partId; ! 1012: ! 1013: // Set up the Perp Mode Command ! 1014: ! 1015: perpMode.command = PERP_MODE_COMMAND; ! 1016: perpMode.drive_select = 0; ! 1017: perpMode.wgate = 0; ! 1018: perpMode.gap = 0; ! 1019: perpMode.reserved = 0; ! 1020: perpMode.over_write = TRUE; ! 1021: ! 1022: verCmd.command = FDC_VERSION; ! 1023: nscCmd.command = NSC_VERSION; ! 1024: partId.command = FDC_PART_ID; ! 1025: *FdcType = FDC_UNKNOWN; ! 1026: ! 1027: ! 1028: // ! 1029: // Check for an enhanced type controller by issuing the version command. ! 1030: // ! 1031: ! 1032: if ((retval = Q117iProgramFDC(TapeExtension, ! 1033: (CHAR *)&verCmd, ! 1034: sizeof(verCmd), ! 1035: FALSE)) ! 1036: == NoErr) { ! 1037: ! 1038: if((retval = Q117iReadFDC(TapeExtension, ! 1039: (CHAR *)&status, ! 1040: (SHORT *)&statLength)) ! 1041: == NoErr) { ! 1042: ! 1043: if (statLength != 1) { ! 1044: ! 1045: retval = NECFlt; ! 1046: ! 1047: } else { ! 1048: ! 1049: if (status == VALID_NEC_FDC) { ! 1050: ! 1051: *FdcType = FDC_ENHANCED; ! 1052: ! 1053: } else { ! 1054: ! 1055: *FdcType = FDC_NORMAL; ! 1056: ! 1057: } ! 1058: } ! 1059: ! 1060: } ! 1061: } ! 1062: ! 1063: // ! 1064: // Determine if the controller is a National 8477 by issuing the NSC ! 1065: // command which is specific to National parts and returns 0x71. The ! 1066: // lower four bits are subject to change by National and will reflect ! 1067: // the version of the part in question. At this point we will only test ! 1068: // the high four bits. ! 1069: // ! 1070: ! 1071: if (*FdcType == FDC_ENHANCED && retval == NoErr) { ! 1072: ! 1073: if ((retval = Q117iProgramFDC(TapeExtension, ! 1074: (CHAR *)&nscCmd, ! 1075: sizeof(nscCmd), ! 1076: FALSE)) ! 1077: == NoErr) { ! 1078: ! 1079: if ((retval = Q117iReadFDC(TapeExtension, ! 1080: (CHAR *)&status, ! 1081: (SHORT *)&statLength)) ! 1082: == NoErr) { ! 1083: ! 1084: if (statLength != 1) { ! 1085: ! 1086: retval = NECFlt; ! 1087: ! 1088: } else { ! 1089: ! 1090: if ((status & NSC_MASK) == NSC_PRIMARY_VERSION) { ! 1091: ! 1092: *FdcType = FDC_NATIONAL; ! 1093: ! 1094: } ! 1095: ! 1096: } ! 1097: ! 1098: } ! 1099: } ! 1100: } ! 1101: ! 1102: // ! 1103: // Determine if the controller is an 82077 by issuing the perpendicular ! 1104: // mode command which at this time is only valid on 82077's. ! 1105: // ! 1106: ! 1107: if (*FdcType == FDC_ENHANCED && retval == NoErr) { ! 1108: ! 1109: if ((retval = Q117iProgramFDC(TapeExtension, ! 1110: (CHAR *)&perpMode, ! 1111: sizeof(perpMode), ! 1112: FALSE)) ! 1113: == NECFlt) { ! 1114: ! 1115: if ((retval = Q117iReadFDC(TapeExtension, ! 1116: (CHAR *)&status, ! 1117: (SHORT *)&statLength)) ! 1118: == NoErr) { ! 1119: ! 1120: if (statLength != 1) { ! 1121: ! 1122: retval = NECFlt; ! 1123: ! 1124: } ! 1125: ! 1126: } ! 1127: ! 1128: } else { ! 1129: ! 1130: *FdcType = FDC_82077; ! 1131: ! 1132: } ! 1133: } ! 1134: ! 1135: // ! 1136: // Determine if the controller is an 82077AA by setting the tdr to several ! 1137: // valid values and reading the results to determine if in fact the tdr ! 1138: // is active. Only the AA parts have an active tdr. ! 1139: // ! 1140: ! 1141: if (*FdcType == FDC_82077 && retval == NoErr) { ! 1142: ! 1143: for (i = 0, test = 0; i < FDC_REPEAT; i++) { ! 1144: ! 1145: WRITE_CONTROLLER(&TapeExtension->QControllerData->FDC_Addr->tdr, i); ! 1146: ! 1147: if (i == (FDC_TDR_MASK & READ_CONTROLLER( ! 1148: &TapeExtension->QControllerData->FDC_Addr->tdr))) { ! 1149: ! 1150: test++; ! 1151: ! 1152: } ! 1153: ! 1154: } ! 1155: ! 1156: if (test == FDC_REPEAT) { ! 1157: ! 1158: *FdcType = FDC_82077AA; ! 1159: CheckedDump(QIC117INFO,( "Q117i: FdcType = FDC_82077AA\n")); ! 1160: ! 1161: } ! 1162: ! 1163: } ! 1164: ! 1165: #if DBG ! 1166: ! 1167: switch (*FdcType) { ! 1168: case FDC_NORMAL: ! 1169: CheckedDump(QIC117INFO,( "Q117i: FdcType = FDC_NORMAL\n")); ! 1170: break; ! 1171: case FDC_ENHANCED: ! 1172: CheckedDump(QIC117INFO,( "Q117i: FdcType = FDC_ENHANCED\n")); ! 1173: break; ! 1174: case FDC_NATIONAL: ! 1175: CheckedDump(QIC117INFO,( "Q117i: FdcType = FDC_NATIONAL\n")); ! 1176: break; ! 1177: case FDC_82077: ! 1178: CheckedDump(QIC117INFO,( "Q117i: FdcType = FDC_82077\n")); ! 1179: break; ! 1180: case FDC_82077AA: ! 1181: CheckedDump(QIC117INFO,( "Q117i: FdcType = FDC_82077AA\n")); ! 1182: break; ! 1183: default: ! 1184: CheckedDump(QIC117INFO,( "Q117i: FdcType = FDC_UNKNOWN\n")); ! 1185: } ! 1186: ! 1187: #endif ! 1188: ! 1189: return(retval); ! 1190: } ! 1191: ! 1192: ! 1193: STATUS ! 1194: Q117iDGetDriveInfo( ! 1195: IN PTAPE_EXTENSION TapeExtension, ! 1196: OUT struct S_O_DMiscInfo *MiscellaneousInformation ! 1197: ) ! 1198: ! 1199: /*++ ! 1200: ! 1201: Routine Description: ! 1202: ! 1203: Gets the followin information: ! 1204: 1) Drive Type/Model ! 1205: 2) Firmware Revision ! 1206: 3) Info Exists Flag ! 1207: 4) OEM Field ! 1208: 5) Serial Number ! 1209: 6) Date of manufacture ! 1210: ! 1211: Arguments: ! 1212: ! 1213: TapeExtension - ! 1214: ! 1215: MiscellaneousInformation - ! 1216: ! 1217: Return Value: ! 1218: ! 1219: ! 1220: ! 1221: --*/ ! 1222: ! 1223: { ! 1224: CHAR i; ! 1225: ! 1226: MiscellaneousInformation->drive_type = ! 1227: TapeExtension->MiscDriveInfo.DriveType; ! 1228: MiscellaneousInformation->ROM_Version = ! 1229: TapeExtension->MiscDriveInfo.ROM_Version; ! 1230: MiscellaneousInformation->info_exists = ! 1231: TapeExtension->MiscDriveInfo.InfoExists; ! 1232: ! 1233: for (i=0; i<SERIAL_NUM_LENGTH; ++i) { ! 1234: ! 1235: MiscellaneousInformation->serial_number[i] = ! 1236: TapeExtension->MiscDriveInfo.SerialNumber[i]; ! 1237: ! 1238: } ! 1239: ! 1240: for (i=0; i<MAN_DATE_LENGTH; ++i) { ! 1241: ! 1242: MiscellaneousInformation->man_date[i] = ! 1243: TapeExtension->MiscDriveInfo.ManDate[i]; ! 1244: ! 1245: } ! 1246: ! 1247: for (i=0; i<OEM_LENGTH; ++i) { ! 1248: ! 1249: MiscellaneousInformation->oem[i] = ! 1250: TapeExtension->MiscDriveInfo.Oem[i]; ! 1251: ! 1252: } ! 1253: ! 1254: return(NoErr); ! 1255: } ! 1256: ! 1257: ! 1258: STATUS ! 1259: Q117iDChkFmt( ! 1260: IN PTAPE_EXTENSION TapeExtension ! 1261: ) ! 1262: ! 1263: /*++ ! 1264: ! 1265: Routine Description: ! 1266: ! 1267: Checks the tape format and compares it to the drive type. ! 1268: ! 1269: If the drive type is CMS and the firmware version is 80 or greater, the ! 1270: following status condition are returned: ! 1271: ! 1272: WrongFmt - Indicates that a QIC-40 tape was detected in a QIC-80 ! 1273: drive. ! 1274: ! 1275: IncompTapeFmt - Indicates that a QIC-80 tape was detected in a QIC-40 ! 1276: drive. ! 1277: ! 1278: If the drive type is not CMS or the firmware version is earlier then the ! 1279: following error condition are returned: ! 1280: ! 1281: WrongFmt - Indicates that a QIC-40 tape was detected in a QIC-80 ! 1282: drive. ! 1283: ! 1284: IncompTapeFmt - Indicates that the drive is not reference and it is ! 1285: suspected that a QIC-80 tape is in a QIC-40 drive. ! 1286: ! 1287: Arguments: ! 1288: ! 1289: TapeExtension - ! 1290: ! 1291: Return Value: ! 1292: ! 1293: ! 1294: --*/ ! 1295: ! 1296: { ! 1297: STATUS retval = NoErr; ! 1298: SHORT fmtStat = NoErr; ! 1299: CHAR currentMode; ! 1300: struct CmsStatus cmsStatus; ! 1301: ! 1302: ! 1303: if (TapeExtension->DriveParms.Flavor == CMS && ! 1304: TapeExtension->DriveParms.Version >= FIRM_VERSION_80) { ! 1305: ! 1306: // ! 1307: // Save current drive mode and put drive into diagnostics mode ! 1308: // ! 1309: ! 1310: currentMode = TapeExtension->DriveParms.Mode; ! 1311: retval = Q117iSetDriveMode(TapeExtension, DIAGNOSTIC_1_MODE); ! 1312: ! 1313: if (retval != NoErr) { ! 1314: ! 1315: return(retval); ! 1316: ! 1317: } ! 1318: ! 1319: // ! 1320: // Get the drive type via the Rpt_cmsStatus command ! 1321: // ! 1322: ! 1323: retval = Q117iReport(TapeExtension, ! 1324: Rpt_CMS_Status, ! 1325: (USHORT *)&cmsStatus, ! 1326: READ_BYTE, ! 1327: NULL); ! 1328: ! 1329: if (retval != NoErr) { ! 1330: ! 1331: return(retval); ! 1332: ! 1333: } ! 1334: ! 1335: if (!cmsStatus.DriveType) { ! 1336: ! 1337: // ! 1338: // If drive type is QIC80, the drive_type bit is set low ! 1339: // and the eagle bit is low. ! 1340: // ! 1341: ! 1342: if (!cmsStatus.Eagle) { ! 1343: ! 1344: if ((TapeExtension->TapeParms.TapeType == QIC40_SHORT) || ! 1345: (TapeExtension->TapeParms.TapeType == QIC40_LONG) || ! 1346: (TapeExtension->TapeParms.TapeType == QICEST_40)) { ! 1347: ! 1348: fmtStat = WrongFmt; ! 1349: ! 1350: } ! 1351: ! 1352: } else { ! 1353: ! 1354: // Drive Type is Eagle ! 1355: ! 1356: if ((TapeExtension->TapeParms.TapeType == QIC40_SHORT) || ! 1357: (TapeExtension->TapeParms.TapeType == QIC40_LONG) || ! 1358: (TapeExtension->TapeParms.TapeType == QICEST_40)) { ! 1359: ! 1360: fmtStat = QIC40InEagle; ! 1361: ! 1362: } ! 1363: if ((TapeExtension->TapeParms.TapeType == QIC80_SHORT) || ! 1364: (TapeExtension->TapeParms.TapeType == QIC80_LONG) || ! 1365: (TapeExtension->TapeParms.TapeType == QICEST_80)) { ! 1366: ! 1367: fmtStat = QIC80InEagle; ! 1368: ! 1369: } ! 1370: } ! 1371: ! 1372: } else { ! 1373: ! 1374: // ! 1375: // It must be a QIC40 Drive ! 1376: // ! 1377: ! 1378: if ((TapeExtension->TapeParms.TapeType == QIC80_SHORT) || ! 1379: (TapeExtension->TapeParms.TapeType == QIC80_LONG) || ! 1380: (TapeExtension->TapeParms.TapeType == QICEST_80)) { ! 1381: ! 1382: fmtStat = IncompTapeFmt; ! 1383: ! 1384: } ! 1385: ! 1386: } ! 1387: ! 1388: // ! 1389: // To exit DIAGNOSTIC_1_MODE, put drive into PRIMARY_MODE ! 1390: // ! 1391: ! 1392: retval = Q117iSetDriveMode(TapeExtension, PRIMARY_MODE); ! 1393: ! 1394: if (retval != NoErr) { ! 1395: ! 1396: return(retval); ! 1397: ! 1398: } ! 1399: ! 1400: // ! 1401: // Restore drive to its original mode ! 1402: // ! 1403: ! 1404: if (currentMode != PRIMARY_MODE) { ! 1405: ! 1406: retval = Q117iSetDriveMode(TapeExtension, currentMode); ! 1407: ! 1408: if (retval != NoErr) { ! 1409: ! 1410: return(retval); ! 1411: ! 1412: } ! 1413: ! 1414: } ! 1415: ! 1416: } else { ! 1417: ! 1418: // ! 1419: // It is not a CMS Drive or it is not firmware version 80 or better ! 1420: // ! 1421: ! 1422: if ((TapeExtension->DriveParms.DriveType == QIC80_DRIVE) && ! 1423: ((TapeExtension->TapeParms.TapeType == QIC40_SHORT) || ! 1424: (TapeExtension->TapeParms.TapeType == QIC40_LONG) || ! 1425: (TapeExtension->TapeParms.TapeType == QICEST_40))) { ! 1426: ! 1427: fmtStat = WrongFmt; ! 1428: ! 1429: } ! 1430: ! 1431: } ! 1432: ! 1433: return(fmtStat); ! 1434: } ! 1435: ! 1436: ! 1437: STATUS ! 1438: Q117iDReportProtoVer( ! 1439: IN PTAPE_EXTENSION TapeExtension, ! 1440: OUT PUCHAR PrototypeVersion ! 1441: ) ! 1442: ! 1443: /*++ ! 1444: ! 1445: Routine Description: ! 1446: ! 1447: Gets the Prototype firmware version from the drive. ! 1448: ! 1449: Arguments: ! 1450: ! 1451: TapeExtension - ! 1452: ! 1453: PrototypeVersion - ! 1454: ! 1455: Return Value: ! 1456: ! 1457: ! 1458: --*/ ! 1459: ! 1460: { ! 1461: UBYTE protoVersion = 0; ! 1462: CHAR currentMode; ! 1463: STATUS retval = NoErr; ! 1464: ! 1465: if (TapeExtension->DriveParms.Flavor == CMS && ! 1466: TapeExtension->DriveParms.Version >= FIRM_VERSION_80) { ! 1467: ! 1468: // ! 1469: // Save current drive mode and put drive into diagnostics mode ! 1470: // ! 1471: ! 1472: currentMode = TapeExtension->DriveParms.Mode; ! 1473: retval = Q117iSetDriveMode(TapeExtension, DIAGNOSTIC_1_MODE); ! 1474: ! 1475: // ! 1476: // Since we are only looking at the firmware, ignore all NoTape ! 1477: // errors. ! 1478: // ! 1479: ! 1480: if (retval != NoErr && retval != NoTape) { ! 1481: ! 1482: return(retval); ! 1483: ! 1484: } ! 1485: ! 1486: // ! 1487: // Get the firmware prototype version number ! 1488: // ! 1489: ! 1490: retval = Q117iReport(TapeExtension, ! 1491: ReportProtoVer, ! 1492: (USHORT *)&protoVersion, ! 1493: READ_BYTE, ! 1494: NULL); ! 1495: ! 1496: // ! 1497: // Since we are only looking at the firmware, ignore all NoTape errors ! 1498: // ! 1499: ! 1500: if (retval != NoErr && retval != NoTape) { ! 1501: ! 1502: return(retval); ! 1503: ! 1504: } ! 1505: ! 1506: // ! 1507: // To exit DIAGNOSTIC_1_MODE, put drive into PRIMARY_MODE ! 1508: // ! 1509: ! 1510: retval = Q117iSetDriveMode(TapeExtension, PRIMARY_MODE); ! 1511: ! 1512: // ! 1513: // Since we are only looking at the firmware, ignore all NoTape errors ! 1514: // ! 1515: ! 1516: if (retval != NoErr && retval != NoTape) { ! 1517: ! 1518: return(retval); ! 1519: ! 1520: } ! 1521: ! 1522: // ! 1523: // Restore drive to its original mode ! 1524: // Since we are only looking at the firmware, ignore all NoTape errors ! 1525: // ! 1526: ! 1527: if (currentMode != PRIMARY_MODE) { ! 1528: ! 1529: retval = Q117iSetDriveMode(TapeExtension, currentMode); ! 1530: ! 1531: if (retval != NoErr && retval != NoTape) { ! 1532: ! 1533: return(retval); ! 1534: ! 1535: } ! 1536: ! 1537: } ! 1538: ! 1539: } ! 1540: ! 1541: *PrototypeVersion = protoVersion; ! 1542: return(NoErr); ! 1543: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.