![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to seek.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 seek.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: seek.c
9:
10: Abstract:
11:
12: positions tape to correct location to be before the desired track and block
13:
14: Revision History:
15:
16:
17:
18:
19: --*/
20:
21: //
22: // include files
23: //
24:
25: #include <ntddk.h> // various NT definitions
26: #include <ntdddisk.h> // disk device driver I/O control codes
27: #include <ntiologc.h>
28: #include "common.h"
29: #include "drvtask.h" // this driver's data declarations
30: #include "mt1defs.h" // this driver's data declarations
31: #include "mt1strc.h" // this driver's data declarations
32: #include "q117data.h" // this driver's data declarations
33:
34:
35: STATUS
36: Q117iSeek(
37: IN PTAPE_EXTENSION TapeExtension
38: )
39:
40: /*++
41:
42: Routine Description:
43:
44: Reposition tape for desired track and block.
45:
46: Change track first if necessary.
47:
48: Seek at high speed to approximately get to the specified area on
49: the tape.
50:
51: Read ID marks from the tape until the tape is positioned 1 block in
52: front of (logically) the desired block.
53:
54: Arguments:
55:
56: TapeExtension -
57:
58: Return Value:
59:
60:
61:
62: --*/
63:
64: {
65: STATUS retval = NoErr;
66: BOOLEAN newTrack;
67: SHORT seekCount;
68: BOOLEAN retensionFlag = FALSE;
69:
70: newTrack = FALSE;
71: seekCount = MAX_SEEK_COUNT;
72:
73: do {
74:
75: if (TapeExtension->TapePosition.D_Segment == 0)
76:
77: if ((retval = Q117iLogicalBOT(TapeExtension)) != NoErr) {
78:
79: return(retval);
80:
81: }
82:
83: if (TapeExtension->TapePosition.D_Track !=
84: TapeExtension->TapePosition.C_Track) {
85:
86: if ((retval = Q117iChangeTrack(
87: TapeExtension,
88: TapeExtension->TapePosition.D_Track)) != NoErr) {
89:
90: return(retval);
91:
92: }
93:
94: if (!TapeExtension->DriveParms.Status.BOT &&
95: !TapeExtension->DriveParms.Status.EOT) {
96:
97: newTrack = TRUE;
98:
99: }
100:
101: }
102:
103: if (TapeExtension->TapePosition.D_Segment == 0)
104: return(NoErr);
105:
106: if (newTrack == TRUE) {
107:
108: retval = Q117iReadIDRepeat(TapeExtension);
109:
110: }
111:
112: if (retval == NoErr) {
113:
114: retval = Q117iHighSpeedSeek(TapeExtension);
115:
116: }
117:
118: if (retval == NoErr) {
119:
120: retval = Q117iReadIDRepeat(TapeExtension);
121:
122: }
123:
124: --seekCount;
125:
126: if ((retval == SeekErr || seekCount == 0) && retensionFlag == FALSE) {
127:
128: if ((retval = Q117iStopTape(TapeExtension)) != NoErr) {
129:
130: return(retval);
131:
132: }
133:
134: if ((retval = Q117iDReten(TapeExtension)) != NoErr) {
135:
136: return(retval);
137:
138: }
139:
140: seekCount = MAX_SEEK_COUNT;
141: retensionFlag = TRUE;
142: retval = NoErr;
143:
144: }
145:
146: if (retval != NoErr) {
147:
148: return(retval);
149:
150: }
151:
152: } while (!((0 <= ((TapeExtension->TapePosition.D_Segment - 1) -
153: TapeExtension->TapePosition.C_Segment)) &&
154: (((TapeExtension->TapePosition.D_Segment - 1) -
155: TapeExtension->TapePosition.C_Segment) <= 10)) &&
156: (seekCount > 0));
157:
158: if (seekCount == 0) {
159:
160: CheckedDump(QIC117WARN,( "SeekErr - seekCount = 0\n" ));
161: return(SeekErr);
162:
163: }
164:
165: do {
166:
167: if ((retval = Q117iReadIDRepeat(TapeExtension)) != NoErr) {
168:
169: return(retval);
170:
171: }
172:
173:
174: } while ((TapeExtension->TapePosition.D_Segment - 1) >
175: TapeExtension->TapePosition.C_Segment);
176:
177: return(retval);
178: }
179:
180:
181: STATUS
182: Q117iChangeTrack(
183: IN PTAPE_EXTENSION TapeExtension,
184: IN SHORT DestinationTrack
185: )
186:
187: /*++
188:
189: Routine Description:
190:
191: Position the tape drive head to a new track.
192:
193: Arguments:
194:
195: TapeExtension -
196:
197: DestinationTrack -
198:
199: Return Value:
200:
201:
202:
203: --*/
204:
205: {
206: STATUS retval;
207:
208: if ((retval = Q117iStopTape(TapeExtension)) != NoErr) {
209:
210: return(retval);
211:
212: }
213:
214: if ((retval = Q117iSendByte(TapeExtension, Seek_Track)) != NoErr) {
215:
216: return(retval);
217:
218: }
219:
220: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
221:
222: if ((retval = Q117iSendByte(TapeExtension, (CHAR)(DestinationTrack + 2)))
223: != NoErr) {
224:
225: return(retval);
226:
227: }
228:
229: if ((retval = Q117iWaitCommandComplete(TapeExtension, mt_wt007s)) !=
230: NoErr) {
231:
232: return(retval);
233:
234: }
235:
236: TapeExtension->TapePosition.C_Track =
237: TapeExtension->TapePosition.D_Track;
238:
239: if (TapeExtension->DriveParms.Status.BOT ||
240: TapeExtension->DriveParms.Status.EOT) {
241:
242: if (((TapeExtension->TapePosition.C_Track / 2 * 2 ==
243: TapeExtension->TapePosition.C_Track) &&
244: (TapeExtension->DriveParms.Status.BOT)) ||
245: ((TapeExtension->TapePosition.C_Track / 2 * 2 !=
246: TapeExtension->TapePosition.C_Track) &&
247: (TapeExtension->DriveParms.Status.EOT))) {
248:
249: TapeExtension->TapePosition.C_Segment = 0;
250:
251: } else {
252:
253: TapeExtension->TapePosition.C_Segment =
254: TapeExtension->TapeParms.SegTtrack;
255:
256: }
257:
258: }
259: return(retval);
260: }
261:
262:
263: STATUS
264: Q117iReadIDRepeat(
265: IN PTAPE_EXTENSION TapeExtension
266: )
267:
268: /*++
269:
270: Routine Description:
271:
272: Read an ID field off of the tape with the FDC. Read_id_repeat will
273: attempt 10 times to read a legal ID field before a failure is returned.
274:
275: Arguments:
276:
277: TapeExtension -
278:
279: Return Value:
280:
281:
282:
283: --*/
284:
285: {
286: STATUS retval;
287: SHORT readIdCnt;
288: FDC_STATUS status;
289:
290: readIdCnt = NumBad;
291:
292: while (readIdCnt > 0) {
293:
294: --readIdCnt;
295:
296: if ((retval = Q117iStartTape(TapeExtension)) != NoErr) {
297:
298: return(retval);
299:
300: }
301:
302: retval = Q117iDoReadID(TapeExtension, mt_wttrks, &status);
303:
304: if (retval && retval != TimeOut) {
305:
306: return(retval);
307:
308: }
309:
310: if (!retval && !(status.ST0 & ST0_IC) &&
311: (TapeExtension->QControllerData->InterfaceType != MicroChannel ||
312: !(status.ST1 & ST1_MA))) {
313:
314: break;
315:
316: } else {
317:
318: if ((retval = Q117iChangeTrack(
319: TapeExtension,
320: TapeExtension->TapePosition.D_Track)) != NoErr) {
321:
322: return(retval);
323:
324: }
325:
326: if (TapeExtension->DriveParms.Status.BOT ||
327: TapeExtension->DriveParms.Status.EOT) {
328:
329: if (((TapeExtension->TapePosition.C_Track / 2 * 2 ==
330: TapeExtension->TapePosition.C_Track) &&
331: (TapeExtension->DriveParms.Status.BOT)) ||
332: ((TapeExtension->TapePosition.C_Track / 2 * 2 !=
333: TapeExtension->TapePosition.C_Track) &&
334: (TapeExtension->DriveParms.Status.EOT))) {
335:
336: TapeExtension->TapePosition.C_Segment = 0;
337: return(NoErr);
338:
339: } else {
340:
341: TapeExtension->TapePosition.C_Segment =
342: TapeExtension->TapeParms.SegTtrack;
343: return(NoErr);
344:
345: }
346: }
347: }
348: }
349:
350: if (readIdCnt == 0) {
351: CheckedDump(QIC117WARN,( "SeekErr - readIdCnt = 0\n" ));
352: return(SeekErr);
353: }
354:
355: TapeExtension->TapePosition.C_Segment =
356: (status.H * TapeExtension->TapeParms.FtrackFside +
357: status.C) * SEG_FTK + (status.R - 1) / FSC_SEG;
358: TapeExtension->TapePosition.C_Track =
359: TapeExtension->TapePosition.C_Segment /
360: TapeExtension->TapeParms.SegTtrack;
361: TapeExtension->TapePosition.C_Segment =
362: TapeExtension->TapePosition.C_Segment %
363: TapeExtension->TapeParms.SegTtrack;
364:
365: return(retval);
366: }
367:
368:
369: STATUS
370: Q117iDoReadID(
371: IN PTAPE_EXTENSION TapeExtension,
372: IN QIC_TIME ReadIdDelay,
373: IN FDC_STATUS *ReadIdStatus
374: )
375:
376: /*++
377:
378: Routine Description:
379:
380: Try to read an ID fiedl off of the tape via the FDC.
381:
382: Arguments:
383:
384: TapeExtension -
385:
386: ReadIdDelay -
387:
388: ReadIdStatus -
389:
390: Return Value:
391:
392:
393:
394: --*/
395:
396: {
397: STATUS retval;
398: SHORT statLength;
399: struct read_id_cmd readId;
400:
401: readId.command = 0x4a;
402: readId.drive = (UCHAR)TapeExtension->DriveParms.DriveSelect;
403:
404: (VOID) Q117iResetInterruptEvent(TapeExtension);
405: if ((retval = Q117iProgramFDC(
406: TapeExtension,
407: (CHAR *)&readId,
408: sizeof(readId),
409: TRUE)) != NoErr) {
410:
411: Q117iResetFDC(TapeExtension);
412: return(retval);
413:
414: }
415:
416: if ((retval = Q117iSleep(
417: TapeExtension,
418: ReadIdDelay,
419: TRUE)) == TimeOut) {
420:
421: Q117iResetFDC(TapeExtension);
422: return(retval);
423:
424: }
425:
426: if ((retval = Q117iReadFDC(
427: TapeExtension,
428: (CHAR *)ReadIdStatus,
429: &statLength)) != NoErr) {
430:
431: return(retval);
432:
433: }
434:
435: return(retval);
436: }
437:
438:
439: VOID
440: Q117iGetComFirmStr(
441: IN PTAPE_EXTENSION TapeExtension,
442: IN OUT CHAR **Ptr,
443: IN SHORT Index
444: )
445:
446: /*++
447:
448: Routine Description:
449:
450: Takes a string and fills it with a requested DComFirm string.
451:
452: Arguments:
453:
454: TapeExtension -
455:
456: Ptr - a byte pointer that points to memory into which the requested
457: DComFirm string is to be placed.
458:
459: Index - a number that indicates which DcomFirm string to place in the
460: memory pointed to by the Ptr parameter.
461:
462: Return Value:
463:
464: None
465:
466: --*/
467:
468: {
469: SHORT numChars; // number of chars in requested DComfirm str
470:
471:
472: switch(Index) {
473:
474: case DCOMFIRM_READ_RAM_REQ:
475: *Ptr = DCOMFIRM_READ_RAM_STRING;
476: numChars = DCOMFIRM_NUM_READ_RAM_CHARS;
477: break;
478:
479: case DCOMFIRM_SET_RAM_REQ:
480: *Ptr = DCOMFIRM_SET_RAM_STRING;
481: numChars = DCOMFIRM_NUM_SET_RAM_CHARS;
482: break;
483:
484: case DCOMFIRM_WRITE_RAM_REQ:
485: *Ptr = DCOMFIRM_WRITE_RAM_STRING;
486: numChars = DCOMFIRM_NUM_WRITE_RAM_CHARS;
487: break;
488:
489: }
490:
491: }
492:
493:
494: STATUS
495: Q117iLogicalBOT(
496: IN PTAPE_EXTENSION TapeExtension
497: )
498:
499: /*++
500:
501: Routine Description:
502:
503: Go at high speed to logical BOT. Logical BOT is physical BOT for even
504: numbered tracks and physical EOT for odd numbered tracks.
505:
506: Arguments:
507:
508: TapeExtension -
509:
510: Return Value:
511:
512:
513:
514: --*/
515:
516: {
517: STATUS retval;
518: CHAR *string; // holds DComFirm string
519: SHORT direction; // tells physical direction of tape movement
520:
521:
522: if ((retval = Q117iStopTape(TapeExtension)) != NoErr) {
523:
524: return(retval);
525:
526: }
527:
528: if ((TapeExtension->TapePosition.D_Track / 2 * 2) ==
529: TapeExtension->TapePosition.D_Track) {
530:
531: retval = Q117iSendByte(TapeExtension, Physical_Rev);
532: direction = REVERSE;
533:
534: } else {
535:
536: retval = Q117iSendByte(TapeExtension, Physical_Fwd);
537: direction = FORWARD;
538:
539: }
540:
541: if (retval) {
542:
543: return(retval);
544:
545: }
546:
547: //
548: // This is part of the Sankyo motor "hack." While the motor is moving
549: // at high speed to the end of the tape, the driver sets the RAM pointer
550: // on the 8051 to point to the byte in memory that contains the bit that
551: // tells whether or not the EOT/BOT sensor is over a hole. This
552: // concurrent operation is purely for performance enhancement (saves
553: // ~220 msec).
554: //
555:
556: if ((TapeExtension->DriveParms.Version == FIRM_VERSION_64) &&
557: (TapeExtension->DriveParms.Flavor == CMS)) {
558:
559: Q117iSleep(TapeExtension, mt_wt200ms, FALSE);
560:
561: //
562: // Set the ram ptr to the byte with the hole_flag bit.
563: //
564:
565: Q117iGetComFirmStr(TapeExtension, &string, DCOMFIRM_SET_RAM_REQ);
566: string[DCOMFIRM_SETRAM_HI_NIB_INDEX] =
567: HOLE_FLAG_BYTE_ADD_UPPER_NIBBLE;
568: string[DCOMFIRM_SETRAM_LOW_NIB_INDEX] =
569: HOLE_FLAG_BYTE_ADD_LOWER_NIBBLE;
570:
571: if ((retval = Q117iDComFirm(TapeExtension, (CHAR *)string)) !=
572: NoErr) {
573:
574: return(retval);
575:
576: }
577: }
578:
579: if ((retval = Q117iWaitCommandComplete(
580: TapeExtension,
581: TapeExtension->TapeParms.TimeOut[PHYSICAL])) !=
582: NoErr) {
583:
584: return(retval);
585:
586: }
587:
588: if (TapeExtension->DriveParms.Version == FIRM_VERSION_64) {
589:
590: //
591: // Prepare the communication string to read the byte with the
592: // hole_flag bit in it.
593: //
594:
595: //
596: // Wait for the motor to stop.
597: //
598:
599: Q117iSleep(TapeExtension, mt_wt260ms, FALSE);
600:
601:
602: //
603: // Read the byte with the hole flag bit in it. If the bit is 0,
604: // that means the drive has stopped over a hole. In that case,
605: // the tape zone counter must be adjusted and written to the drive,
606: // and the driver saves the day.
607: //
608:
609: Q117iGetComFirmStr(TapeExtension, &string,DCOMFIRM_READ_RAM_REQ);
610:
611: if ((retval = Q117iDComFirm(TapeExtension, (CHAR *)string)) !=
612: NoErr) {
613:
614: return(retval);
615:
616: }
617:
618: if (!(string[DCOMFIRM_READ_RTRN_BYTE_INDEX] & HOLE_INDICATOR_MASK)) {
619:
620: if (direction == REVERSE) {
621:
622: //
623: // If at BOT, the only cause for concern is when the EOT/BOT
624: // sensor is over the rightmost hole of the BOT pair. To
625: // differentiate this from the case where the sensor is
626: // sitting over the leftmost hole, read the double hole
627: // distance counter. If it is non-zero, do nothing.
628: //
629:
630: //
631: // Set the ram ptr to 0x3B, the double hole counter,
632: //
633:
634: Q117iGetComFirmStr(
635: TapeExtension, &string, DCOMFIRM_SET_RAM_REQ);
636: string[DCOMFIRM_SETRAM_HI_NIB_INDEX] =
637: DBL_HOLE_CNTER_ADD_UPPER_NIBBLE;
638: string[DCOMFIRM_SETRAM_LOW_NIB_INDEX] =
639: DBL_HOLE_CNTER_ADD_LOWER_NIBBLE;
640: if ( (retval = Q117iDComFirm(
641: TapeExtension,
642: (CHAR *)string)) != NoErr) {
643:
644: return(retval);
645:
646: }
647:
648: //
649: // Read the double hole counter.
650: //
651:
652: Q117iGetComFirmStr(
653: TapeExtension, &string,DCOMFIRM_READ_RAM_REQ);
654:
655: if ((retval = Q117iDComFirm(
656: TapeExtension,
657: (CHAR *)string)) != NoErr) {
658:
659: return(retval);
660:
661: }
662:
663: if (!(string[DCOMFIRM_READ_RTRN_BYTE_INDEX])) {
664:
665: if ((retval = Q117iAdjustTapeZone(TapeExtension, (SHORT) AT_BOT))
666: != NoErr) {
667:
668: return(retval);
669:
670: }
671: }
672:
673: } else {
674:
675: if ((retval = Q117iAdjustTapeZone(TapeExtension, (SHORT) AT_EOT)) !=
676: NoErr) {
677:
678: return(retval);
679:
680: }
681: }
682: }
683: }
684: if ((TapeExtension->TapePosition.D_Track / 2 * 2) ==
685: TapeExtension->TapePosition.D_Track) {
686:
687: if (!TapeExtension->DriveParms.Status.BOT) {
688:
689: CheckedDump(QIC117WARN,( "SeekErr - not at BOT\n" ));
690: return(SeekErr);
691:
692: }
693:
694: } else {
695:
696: if (!TapeExtension->DriveParms.Status.EOT) {
697:
698: CheckedDump(QIC117WARN,( "SeekErr - not at EOT\n" ));
699: return(SeekErr);
700:
701: }
702: }
703:
704: TapeExtension->TapePosition.C_Segment = 0;
705: return(NoErr);
706: }
707:
708:
709: STATUS
710: Q117iAdjustTapeZone(
711: IN PTAPE_EXTENSION TapeExtension,
712: IN SHORT TapePosition
713: )
714:
715: /*++
716:
717: Routine Description:
718:
719: Adjust the tape zone counter to compensate for stopping with the EOT/BOT
720: sensor over a hole.
721:
722: Arguments:
723:
724: TapeExtension -
725:
726: TapePosition - tells wheather EOT or BOT
727:
728: Return Value:
729:
730:
731:
732: --*/
733:
734: {
735:
736: CHAR highNibble;
737: CHAR lowNibble;
738: CHAR *string;
739: STATUS retval = NoErr;
740:
741: //
742: // Set the pointer in the 8051 RAM to the tape zone counter.
743: //
744:
745: Q117iGetComFirmStr(TapeExtension, &string, DCOMFIRM_SET_RAM_REQ);
746: string[DCOMFIRM_SETRAM_HI_NIB_INDEX] = TAPE_ZONE_BYTE_ADD_UPPER_NIBBLE;
747: string[DCOMFIRM_SETRAM_LOW_NIB_INDEX] = TAPE_ZONE_BTYE_ADD_LOWER_NIBBLE;
748:
749: retval = Q117iDComFirm(TapeExtension, (CHAR *)string);
750:
751: if (retval == NoErr) {
752:
753: if (TapePosition == AT_EOT) {
754:
755: highNibble = EOT_ZONE_COUNTER_UPPER_NIBBLE;
756: lowNibble = EOT_ZONE_COUNTER_LOWER_NIBBLE;
757:
758: } else {
759:
760: highNibble = BOT_ZONE_COUNTER_UPPER_NIBBLE;
761: lowNibble = BOT_ZONE_COUNTER_LOWER_NIBBLE;
762:
763: }
764:
765: //
766: // Write the upper and lower nybbles of the tape zone counter.
767: //
768:
769: Q117iGetComFirmStr(TapeExtension, &string, DCOMFIRM_WRITE_RAM_REQ);
770: string[DCOMFIRM_WRTRAM_HI_NIB_INDEX] = highNibble;
771: string[DCOMFIRM_WRTRAM_LOW_NIB_INDEX] = lowNibble;
772: retval = Q117iDComFirm(TapeExtension, (CHAR *)string);
773: }
774:
775: return(retval);
776: }
777:
778:
779: STATUS
780: Q117iHighSpeedSeek(
781: IN PTAPE_EXTENSION TapeExtension
782: )
783:
784: /*++
785:
786: Routine Description:
787:
788: Execute a High Speed Seek. There are two methods of doing this now.
789: First, if the Skip commands are not implemented, the high speed seek
790: is accomplished by calculating the approximate amount of time needed
791: at high speed to reach the target position and allowing the tape drive
792: to go at 90 ips for that amount of time. If the Skip commands are
793: implemented, the high speed seek is merely the proper command with
794: a calculated offset.
795:
796: The Seeking is done by using either the Skip_N_Segments command or by using
797: the time seeking algorithm provided by Q117iWaitSeek. The Skip_N_Segments commands
798: are not reliable in all versions of the firmware. Only in versions for JUMBO_B
799: and greater are the commands available at all and only in versions of 65 and
800: greater are the Skip_N_Segment commands reliable for skipping past the
801: DC erased gap.
802:
803: Arguments:
804:
805: TapeExtension -
806:
807: Return Value:
808:
809:
810:
811: --*/
812:
813: {
814: STATUS retval = NoErr;
815: SHORT seekOffset;
816: SHORT i;
817: CHAR seekDir;
818: CHAR skipNSegs;
819: USHORT skip;
820:
821: //
822: // Determine the logical direction that the tape needs to be moved
823: //
824:
825: if ((seekOffset = (TapeExtension->TapePosition.D_Segment - 1) -
826: TapeExtension->TapePosition.C_Segment) >= 0) {
827:
828: seekDir = FWD;
829:
830: } else {
831:
832: seekDir = REV;
833: seekOffset = 0 - seekOffset;
834:
835: }
836:
837: if (seekDir == REV || seekOffset > STOP_LEN) {
838:
839: if((retval = Q117iStopTape(TapeExtension)) != NoErr) {
840:
841: return(retval);
842:
843: }
844:
845: if (seekDir == FWD) {
846:
847: if (TapeExtension->DriveParms.SeekMode == SEEK_TIMED) {
848:
849: seekOffset -= SEEK_SLOP;
850:
851: } else {
852:
853: seekOffset -= 1;
854:
855: }
856:
857: } else {
858:
859: //
860: // seek direction is reverse
861: //
862:
863: if (TapeExtension->DriveParms.Status.BOT ||
864: TapeExtension->DriveParms.Status.EOT) {
865:
866: switch (TapeExtension->TapeParms.TapeType) {
867:
868: case QIC40_SHORT:
869: case QIC80_SHORT:
870: seekOffset += QIC_REV_OFFSET;
871: break;
872:
873: case QIC40_LONG:
874: case QIC80_LONG:
875: case QIC500_SHORT:
876: seekOffset += QIC_REV_OFFSET_L;
877: break;
878:
879: case QICEST_40:
880: case QICEST_80:
881: case QICEST_500:
882: seekOffset += QICEST_REV_OFFSET;
883: break;
884:
885: }
886:
887: } else {
888:
889: if (TapeExtension->DriveParms.SeekMode == SEEK_TIMED) {
890:
891: seekOffset += SEEK_SLOP;
892:
893: } else {
894:
895: seekOffset += 1;
896:
897: }
898:
899: }
900: }
901:
902: switch (TapeExtension->DriveParms.SeekMode) {
903:
904: case SEEK_SKIP:
905: //
906: // Determine the offset to be used for the Skip_N_Segment commands
907: //
908:
909: CheckedDump(QIC117SHOWQD,( "Q117i: Skip_N_Segments Seek\n"));
910:
911: if (seekDir == FWD) {
912:
913: skipNSegs = Skip_N_Fwd;
914:
915: } else {
916:
917: skipNSegs = Skip_N_Rev;
918:
919: }
920:
921: // Skip the first bytes worth of segments
922:
923: if ((retval = Q117iSendByte(
924: TapeExtension,
925: skipNSegs)) != NoErr) {
926:
927: return(retval);
928:
929: }
930:
931: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
932:
933: if ((retval = Q117iSendByte(
934: TapeExtension,
935: ((seekOffset & 0xf) + 2))) != NoErr) {
936:
937: return(retval);
938:
939: }
940:
941: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
942:
943: seekOffset >>= 4;
944:
945: if ((retval = Q117iSendByte(
946: TapeExtension,
947: ((seekOffset & 0x0f)+2))) != NoErr) {
948:
949: return(retval);
950:
951: }
952:
953: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
954:
955: if ((retval = Q117iWaitCommandComplete(
956: TapeExtension,
957: TapeExtension->TapeParms.TimeOut[PHYSICAL])) != NoErr) {
958:
959: return(retval);
960:
961: }
962:
963: seekOffset >>= 4;
964:
965: for (;seekOffset != 0; --seekOffset) {
966:
967: // Skip the second bytes worth of segments
968:
969: for (i=0; i<2; ++i) {
970: if (i) {
971:
972: skip = 1;
973:
974: } else {
975:
976: skip = MAX_SKIP;
977:
978: }
979:
980: if ((retval = Q117iSendByte(
981: TapeExtension,
982: skipNSegs)) != NoErr) {
983:
984: return(retval);
985:
986: }
987:
988: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
989:
990: if ((retval = Q117iSendByte(
991: TapeExtension,
992: ((skip & 0xf) + 2))) != NoErr) {
993:
994: return(retval);
995:
996: }
997:
998: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
999:
1000: if ((retval = Q117iSendByte(
1001: TapeExtension,
1002: ((skip >> 4) + 2))) != NoErr) {
1003:
1004: return(retval);
1005:
1006: }
1007:
1008: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
1009:
1010: if ((retval = Q117iWaitCommandComplete(
1011: TapeExtension,
1012: TapeExtension->TapeParms.TimeOut[PHYSICAL])) != NoErr) {
1013:
1014: return(retval);
1015:
1016: }
1017: }
1018: }
1019:
1020: break;
1021:
1022: case SEEK_SKIP_EXTENDED:
1023:
1024: if (seekDir == FWD) {
1025:
1026: skipNSegs = Skip_N_Fwd_Ext;
1027:
1028: } else {
1029:
1030: skipNSegs = Skip_N_Rev_Ext;
1031:
1032: }
1033:
1034:
1035: if ((retval = Q117iSendByte(
1036: TapeExtension,
1037: skipNSegs)) != NoErr) {
1038:
1039: return(retval);
1040:
1041: }
1042:
1043: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
1044:
1045: for (i = 0; i < MAX_SEEK_NIBBLES; i++) {
1046:
1047: if ((retval = Q117iSendByte(
1048: TapeExtension,
1049: ((seekOffset & 0xf) + 2))) != NoErr) {
1050:
1051: return(retval);
1052:
1053: }
1054:
1055: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
1056:
1057: seekOffset >>= 4;
1058:
1059: }
1060:
1061: if ((retval = Q117iWaitCommandComplete(
1062: TapeExtension,
1063: TapeExtension->TapeParms.TimeOut[PHYSICAL])) != NoErr) {
1064:
1065: return(retval);
1066:
1067: }
1068:
1069: break;
1070:
1071: default: // SEEK_TIMED
1072:
1073: //
1074: // Skip segments commands are not available
1075: //
1076:
1077: CheckedDump(QIC117SHOWQD,( "Q117i: Timed Seek\n"));
1078:
1079:
1080: if (((seekDir == FWD) &&
1081: (TapeExtension->TapePosition.C_Track / 2 * 2 ==
1082: TapeExtension->TapePosition.C_Track)) ||
1083: ((seekDir == REV) &&
1084: (TapeExtension->TapePosition.C_Track / 2 * 2 !=
1085: TapeExtension->TapePosition.C_Track))) {
1086:
1087: if ((retval = Q117iSendByte(TapeExtension, Physical_Fwd)) !=
1088: NoErr) {
1089:
1090: return(retval);
1091:
1092: }
1093:
1094: } else {
1095:
1096: if ((retval = Q117iSendByte(TapeExtension, Physical_Rev)) !=
1097: NoErr) {
1098:
1099: return(retval);
1100:
1101: }
1102: }
1103:
1104: if ((retval = Q117iWaitSeek(TapeExtension, seekOffset)) != NoErr) {
1105:
1106: return(retval);
1107:
1108: }
1109:
1110: if ((retval = Q117iStopTape(TapeExtension)) != NoErr) {
1111:
1112: return(retval);
1113:
1114: }
1115: }
1116: }
1117: return(retval);
1118: }
1119:
1120:
1121: STATUS
1122: Q117iWaitSeek(
1123: IN PTAPE_EXTENSION TapeExtension,
1124: SHORT SeekDelay
1125: )
1126:
1127: /*++
1128:
1129: Routine Description:
1130:
1131: Execute a timed high speed seek. This routine is used for CMS drives
1132: that have not implemented the Skip commands (all those before firmware
1133: version 34) and all non-CMS drives.
1134:
1135: Arguments:
1136:
1137: TapeExtension -
1138:
1139: SeekDelay -
1140:
1141: Return Value:
1142:
1143:
1144:
1145: --*/
1146:
1147: {
1148: STATUS retval;
1149:
1150: do {
1151:
1152: Q117iSleep(TapeExtension, mt_wt200ms, FALSE);
1153: retval = Q117iGetDriveError(TapeExtension);
1154:
1155: if (retval && retval != NotRdy) {
1156:
1157: return(retval);
1158:
1159: }
1160:
1161: if (retval == NoErr) {
1162:
1163: if (TapeExtension->DriveParms.Status.BOT ||
1164: TapeExtension->DriveParms.Status.EOT) {
1165:
1166: break;
1167:
1168: }
1169:
1170: return(DriveFlt);
1171: }
1172:
1173: --SeekDelay;
1174:
1175: } while (SeekDelay > 0);
1176:
1177: return(NoErr);
1178: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.