![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to readwrt.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 readwrt.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: readwrt.c
9:
10: Abstract:
11:
12: Performs low-level read and write operations (with position logic).
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: Q117iReadWrite(
37: IN PTAPE_EXTENSION TapeExtension,
38: IN OUT PIO_REQUEST IoRequestCurrent,
39: IN OUT PIRP Irp
40: )
41:
42: /*++
43:
44:
45: Routine Description:
46:
47: Process a data read or write.
48:
49: The first Wrong Cylinder error is ignored incase of a bad seek. On the
50: system 50, 60, 80 the first N Over Run errors are ignored due to the VGA
51: 16-bit access bug (see PS/2 compatability manual).
52:
53: Arguments:
54:
55: TapeExtension -
56:
57: IoRequestCurrent -
58:
59: Irp -
60:
61: Return Value:
62:
63:
64:
65: --*/
66: {
67: STATUS retval = NoErr;
68: UCHAR i;
69: BOOLEAN dmaDir;
70: STATUS status = NoErr;
71: STATUS sleep_ret = NoErr;
72: RDV_COMMAND rdWrCmd;
73: PIO_STACK_LOCATION irpSp;
74: struct PerpMode perpMode;
75:
76: perpMode.command = PERP_MODE_COMMAND;
77: perpMode.drive_select = TapeExtension->QControllerData->PerpModeSelect;
78: perpMode.reserved = 0;
79: perpMode.over_write = TRUE;
80:
81: irpSp = IoGetCurrentIrpStackLocation( Irp );
82:
83: Q117iGetRetryCounts(TapeExtension, IoRequestCurrent->Command);
84:
85: IoRequestCurrent->RetryList = 0l;
86: TapeExtension->RdWrOp.BytesTransferredSoFar = 0l;
87: TapeExtension->RdWrOp.TotalBytesOfTransfer = 0l;
88: TapeExtension->RdWrOp.RetryCount = TapeExtension->RdWrOp.RetryTimes;
89: TapeExtension->RdWrOp.RetrySectorId = 0;
90: TapeExtension->RdWrOp.SeekFlag = TRUE;
91:
92: if ((retval = Q117iCalcPosition(
93: TapeExtension,
94: IoRequestCurrent->Block,
95: IoRequestCurrent->Number)) != NoErr) {
96:
97: return(retval);
98:
99: }
100:
101: TapeExtension->RdWrOp.CurLst = IoRequestCurrent->BadList;
102:
103: TapeExtension->RdWrOp.Scount = 0;
104:
105: for (i = 0; i < IoRequestCurrent->Number; i++) {
106:
107: if ((TapeExtension->RdWrOp.CurLst & 1) == 0) {
108:
109: TapeExtension->RdWrOp.Scount++;
110:
111: }
112:
113: TapeExtension->RdWrOp.CurLst = TapeExtension->RdWrOp.CurLst >> 1;
114:
115: }
116:
117: TapeExtension->RdWrOp.CurLst = IoRequestCurrent->BadList;
118: TapeExtension->RdWrOp.DataAmount = 0;
119:
120: while (TapeExtension->RdWrOp.Scount != 0 ||
121: TapeExtension->RdWrOp.DataAmount != 0) {
122:
123: if (TapeExtension->RdWrOp.DataAmount == 0) {
124:
125: Q117iNextGoodSectors(TapeExtension);
126:
127: }
128:
129: if ((TapeExtension->TapePosition.D_Track !=
130: TapeExtension->TapePosition.C_Track) ||
131: (TapeExtension->TapePosition.C_Segment >
132: TapeExtension->TapePosition.D_Segment) ||
133: ((TapeExtension->TapePosition.C_Segment !=
134: TapeExtension->TapePosition.D_Segment) &&
135: ((TapeExtension->TapePosition.LogFwd != TRUE) ||
136: ((TapeExtension->TapePosition.D_Segment - 1) !=
137: TapeExtension->TapePosition.C_Segment))))
138:
139: if ((retval = Q117iSeek(TapeExtension)) != NoErr) {
140:
141: return(retval);
142:
143: }
144:
145: if (IoRequestCurrent->Command == DWrite ||
146: IoRequestCurrent->Command == DWriteBad) {
147:
148: dmaDir = DMA_READ;
149:
150: if ((TapeExtension->DriveParms.DriveType == QIC500_DRIVE) &&
151: !TapeExtension->QControllerData->PerpendicularMode) {
152:
153: // Enable Perpendicular Mode
154: perpMode.wgate = 1;
155: perpMode.gap = 1;
156:
157: if ((retval = Q117iProgramFDC(
158: TapeExtension,
159: (CHAR *)&perpMode,
160: sizeof(perpMode),
161: FALSE)) != NoErr) {
162:
163: Q117iResetFDC(TapeExtension);
164: Q117iPauseTape(TapeExtension);
165: return(retval);
166: }
167:
168: TapeExtension->QControllerData->PerpendicularMode = TRUE;
169: }
170:
171: } else {
172:
173: dmaDir = DMA_WRITE;
174:
175: if (TapeExtension->QControllerData->PerpendicularMode) {
176:
177: // Disable Perpendicular Mode
178: perpMode.wgate = 0;
179: perpMode.gap = 0;
180:
181: if ((retval = Q117iProgramFDC(
182: TapeExtension,
183: (CHAR *)&perpMode,
184: sizeof(perpMode),
185: FALSE)) != NoErr) {
186:
187: Q117iResetFDC(TapeExtension);
188: Q117iPauseTape(TapeExtension);
189: return(retval);
190: }
191:
192: TapeExtension->QControllerData->PerpendicularMode = FALSE;
193: }
194:
195: }
196:
197: TapeExtension->RdWrOp.TotalBytesOfTransfer =
198: (ULONG)(TapeExtension->RdWrOp.DataAmount * PHY_SIZ);
199:
200: hio_ProgramDMA(TapeExtension, Irp, dmaDir);
201:
202: switch (IoRequestCurrent->Command) {
203:
204: case DWrite:
205: rdWrCmd.command = WRITE;
206: break;
207:
208: case DWriteBad:
209: rdWrCmd.command = WRTDEL;
210: break;
211:
212: default:
213: rdWrCmd.command = READ;
214:
215: }
216:
217: rdWrCmd.drive = (UCHAR)TapeExtension->DriveParms.DriveSelect;
218: rdWrCmd.C = TapeExtension->RdWrOp.D_FTK;
219: rdWrCmd.H = TapeExtension->RdWrOp.D_Head;
220: rdWrCmd.R = TapeExtension->RdWrOp.D_Sect;
221: rdWrCmd.N = WRT_BPS;
222: rdWrCmd.EOT = (UCHAR)TapeExtension->TapeParms.FsectFtrack;
223: rdWrCmd.GPL = (UCHAR)TapeExtension->TapeParms.RwGapLength;
224: rdWrCmd.DTL = 0xff;
225:
226: if ((retval = Q117iStartTape(TapeExtension)) != NoErr) {
227:
228: hio_FlushDMA(TapeExtension, Irp, dmaDir);
229: return(retval);
230:
231: }
232:
233: (VOID) Q117iResetInterruptEvent(TapeExtension);
234: if ((retval = Q117iProgramFDC(
235: TapeExtension,
236: (CHAR *)&rdWrCmd,
237: sizeof(RDV_COMMAND),
238: TRUE)) != NoErr) {
239:
240: hio_FlushDMA(TapeExtension, Irp, dmaDir);
241: Q117iResetFDC(TapeExtension);
242: Q117iPauseTape(TapeExtension);
243: return(retval);
244: }
245:
246: sleep_ret = Q117iSleep(TapeExtension, mt_wttrks, TRUE);
247: hio_FlushDMA(TapeExtension, Irp, dmaDir);
248:
249: switch (sleep_ret) {
250:
251: case TimeOut:
252: if ((retval = Q117iRW_Timeout(
253: TapeExtension,
254: IoRequestCurrent,
255: &status)) != NoErr) {
256:
257: return(retval);
258:
259: }
260:
261: if (TapeExtension->RdWrOp.NoDat == 0) {
262:
263: return(status);
264:
265: }
266:
267: break;
268:
269: case NoErr:
270:
271: if ((retval = Q117iRW_Normal(
272: TapeExtension,
273: IoRequestCurrent,
274: &status)) != NoErr) {
275:
276: return(retval);
277:
278: }
279:
280: if (status == BadMark || TapeExtension->RdWrOp.NoDat == 0) {
281:
282: return(status);
283:
284: }
285:
286: break;
287:
288: }
289: } /* end of while loop */
290:
291: if (IoRequestCurrent->Command == DRetry) {
292:
293: if (TapeExtension->TapePosition.LogFwd == TRUE) {
294:
295: retval = Q117iGetDriveError(TapeExtension);
296:
297: if (retval && (retval != NotRdy)) {
298:
299: return(retval);
300:
301: }
302:
303: Q117iPauseTape(TapeExtension);
304: }
305:
306: if ((retval = Q117iSetBack(TapeExtension, IoRequestCurrent->Command)) !=
307: NoErr) {
308:
309: return(retval);
310:
311: }
312: }
313:
314:
315: #if DBG
316: if ((QIC117DebugLevel & QIC117MAKEBAD) && status == NoErr &&
317: IoRequestCurrent->Command == DWrite) {
318:
319: LARGE_INTEGER time;
320:
321:
322: // Use the system time as a "Randomizer" to fake bad sectors
323: KeQuerySystemTime(&time);
324: time.LowPart /= 10;
325: if (time.LowPart & 1) {
326: status = BadBlk;
327:
328: IoRequestCurrent->BadList |= 1 << (time.LowPart & 31);
329: if (time.LowPart & 0x100) {
330: IoRequestCurrent->BadList |= 1 << ((time.LowPart>>6) & 31);
331: }
332: if ((time.LowPart & 0xa00) == 0xa00) {
333: IoRequestCurrent->BadList |= 1 << ((time.LowPart>>10) & 31);
334: }
335: CheckedDump(QIC117MAKEBAD, ("badblk generated\n"));
336: } else {
337: CheckedDump(QIC117MAKEBAD, ("no sim\n"));
338: }
339: }
340: #endif
341:
342: return(status);
343: }
344:
345:
346: STATUS
347: Q117iCalcPosition(
348: IN PTAPE_EXTENSION TapeExtension,
349: IN ULONG Block,
350: IN UCHAR Number
351: )
352:
353: /*++
354:
355: Routine Description:
356:
357: Calculate the desired tape position from the Logical Sector Number
358: in the I/O Request.
359:
360: Arguments:
361:
362: TapeExtension -
363:
364: Block -
365:
366: Number -
367:
368: Return Value:
369:
370:
371:
372: --*/
373:
374: {
375: ULONG logSect;
376:
377: //
378: // First check if the desired sector is a legal one, i.e. is less
379: // than the maximum number of sectors on the tape.
380: //
381:
382: CheckedDump(QIC117STOP,( "q117i: requested block %lx\n", Block ));
383:
384: if (Block >= TapeExtension->TapeParms.LogSectors) {
385:
386: return(BadReq);
387:
388: }
389:
390: //
391: // Now we need to determine the sector ID information so that we
392: // can properly program the FDC. The ID information required is the
393: // head, cylinder, and sector numbers. The head number is calculated
394: // as logSect / (floppy sectors per floppy side). This calculation
395: // is done in the while loop which also determines the logical floppy
396: // sector on the floppy side. The cylinder number (d_FTK) and the
397: // sector number (d_sect) are calculated last as (logical floppy sector)
398: // / (floppy sectors per floppy cylinder).
399: //
400:
401: logSect = Block;
402: TapeExtension->RdWrOp.D_Head = 0;
403:
404: while (logSect >= TapeExtension->TapeParms.FsectFside) {
405:
406: logSect -= TapeExtension->TapeParms.FsectFside;
407: TapeExtension->RdWrOp.D_Head++;
408:
409: }
410:
411: TapeExtension->RdWrOp.D_FTK = (UCHAR)(logSect / FSC_FTK);
412:
413: //
414: // fast logSect % 128
415: //
416:
417: TapeExtension->RdWrOp.D_Sect = (UCHAR)(logSect % FSC_FTK) + 1;
418: TapeExtension->RdWrOp.S_Sect = (UCHAR)TapeExtension->RdWrOp.D_Sect;
419:
420: //
421: // Next, we need the tape positioning data. This is the data that
422: // we need to find out where, physically, on the tape we need to be.
423: // The tape track is determined first as
424: // (logical sector number) / (floppy sectors per tape track). The
425: // remainder from this calculation is the absolute sector number
426: // on the tape track. Lastly, the physical segment is determined by
427: // dividing the physical sector number by the number of sectors per
428: // segment.
429: //
430:
431: logSect = Block;
432: TapeExtension->TapePosition.D_Track = 0;
433:
434: while (logSect >= TapeExtension->TapeParms.FsectTtrack) {
435:
436: logSect -= TapeExtension->TapeParms.FsectTtrack;
437: TapeExtension->TapePosition.D_Track++;
438:
439: }
440:
441: logSect = logSect / FSC_SEG;
442: TapeExtension->TapePosition.D_Segment = (SHORT)logSect;
443:
444: //
445: // Finally, if the IO Request requests a read that will cross a segment
446: // boundary then an error is returned.
447: //
448:
449: if((((TapeExtension->RdWrOp.D_Sect - 1) & 0x1f) + Number) >
450: TapeExtension->TapeParms.FsectSeg) {
451:
452: return(BadReq);
453:
454: }
455:
456: return(NoErr);
457: }
458:
459:
460: VOID
461: Q117iGetRetryCounts(
462: IN PTAPE_EXTENSION TapeExtension,
463: IN DRIVER_COMMAND Command
464: )
465:
466: /*++
467:
468: Routine Description:
469:
470: Determine the retry count information according to the drive command
471: eiher read, write, verify, or retry.
472:
473: Arguments:
474:
475: TapeExtension -
476:
477: Command -
478:
479: Return Value:
480:
481: None
482:
483: --*/
484:
485: {
486: switch (Command) {
487:
488: case DWrite:
489: case DWriteBad:
490: TapeExtension->RdWrOp.RetryTimes = WTIMES;
491: TapeExtension->RdWrOp.NoDat = 3;
492: break;
493:
494: case DRead:
495: case DReadBad:
496: TapeExtension->RdWrOp.RetryTimes = ANTIMES;
497: TapeExtension->RdWrOp.NoDat = 3;
498: break;
499:
500: case DVerify:
501: TapeExtension->RdWrOp.RetryTimes = VTIMES;
502: TapeExtension->RdWrOp.NoDat = 2;
503: break;
504:
505: case DRetry:
506: TapeExtension->RdWrOp.RetryTimes = ARTIMES;
507: TapeExtension->RdWrOp.NoDat = ARTIMES;
508: TapeExtension->RetrySeqNum = 0;
509:
510: }
511: }
512:
513:
514: void
515: Q117iNextGoodSectors(
516: IN PTAPE_EXTENSION TapeExtension
517: )
518:
519: /*++
520:
521: Routine Description:
522:
523: Determine the next block of good sectors to read/write/verify.
524:
525: Arguments:
526:
527: TapeExtension -
528:
529: Return Value:
530:
531: None
532:
533: --*/
534:
535: {
536: TapeExtension->RdWrOp.DataAmount = 0;
537:
538: while (TapeExtension->RdWrOp.CurLst & 1) {
539:
540: TapeExtension->RdWrOp.CurLst = TapeExtension->RdWrOp.CurLst >> 1;
541: TapeExtension->RdWrOp.D_Sect++;
542:
543: }
544:
545: do {
546:
547: TapeExtension->RdWrOp.DataAmount++;
548: TapeExtension->RdWrOp.Scount--;
549: TapeExtension->RdWrOp.CurLst = TapeExtension->RdWrOp.CurLst >> 1;
550:
551: } while (!(TapeExtension->RdWrOp.CurLst & 1) &&
552: TapeExtension->RdWrOp.Scount);
553: }
554:
555:
556: STATUS
557: Q117iRW_Timeout(
558: IN PTAPE_EXTENSION TapeExtension,
559: IN OUT PIO_REQUEST IoRequestCurrent,
560: OUT STATUS *Status
561: )
562:
563: /*++
564:
565: Routine Description:
566:
567: Process a TIMEOUT error while reading/writing/verifying. If the FDC
568: does not report any status within the amount of time that the tape
569: would pass apporximately 4 segments, it must be assumed that there is no
570: data on the tape.
571:
572: Arguments:
573:
574: TapeExtension -
575:
576: IoRequestCurrent -
577:
578: Status -
579:
580: Return Value:
581:
582:
583:
584: --*/
585:
586: {
587: STATUS retval;
588:
589: Q117iResetFDC(TapeExtension);
590:
591: if ((retval = Q117iStopTape(TapeExtension)) != NoErr) {
592:
593: return(retval);
594:
595: }
596:
597: if ((retval = Q117iChangeTrack(
598: TapeExtension,
599: TapeExtension->TapePosition.D_Track)) != NoErr) {
600:
601: return(retval);
602:
603: }
604:
605: if (TapeExtension->DriveParms.Status.BOT ||
606: TapeExtension->DriveParms.Status.EOT) {
607:
608: TapeExtension->TapePosition.C_Segment =
609: TapeExtension->TapeParms.SegTtrack;
610:
611: }
612:
613: if (--TapeExtension->RdWrOp.NoDat == 0) {
614:
615: if ((retval = Q117iSetBack(TapeExtension, IoRequestCurrent->Command))
616: != NoErr) {
617:
618: return(retval);
619:
620: }
621:
622: *Status = BadBlk;
623: IoRequestCurrent->BadList = -
624: 1l << (TapeExtension->RdWrOp.D_Sect -
625: TapeExtension->RdWrOp.S_Sect);
626:
627: }
628: return(retval);
629: }
630:
631:
632: STATUS
633: Q117iRW_Normal(
634: IN PTAPE_EXTENSION TapeExtension,
635: IN OUT PIO_REQUEST IoRequestCurrent,
636: OUT STATUS *Status
637: )
638:
639: /*++
640:
641:
642: Routine Description:
643:
644: Process a read/write/verify operation that has returned normally from
645: the FDC.
646:
647: Arguments:
648:
649: TapeExtension -
650:
651: IoRequestCurrent -
652:
653: Status -
654:
655: Return Value:
656:
657:
658:
659: --*/
660:
661: {
662: STATUS retval;
663: SHORT statLength;
664:
665: if ((retval = Q117iReadFDC(
666: TapeExtension,
667: (CHAR *)&TapeExtension->QControllerData->FdcStat,
668: &statLength)) != NoErr) {
669:
670: Q117iPauseTape(TapeExtension);
671: return(retval);
672:
673: }
674:
675: if (statLength != 7) {
676:
677: Q117iResetFDC(TapeExtension);
678: Q117iGetDriveError(TapeExtension);
679: Q117iPauseTape(TapeExtension);
680:
681: if (TapeExtension->RdWrOp.NoDat == 0) {
682:
683: if ((retval = Q117iSetBack(TapeExtension, IoRequestCurrent->Command))
684: != NoErr) {
685:
686: return(retval);
687:
688: }
689:
690: *Status = BadBlk;
691: IoRequestCurrent->BadList =
692: -1l << (TapeExtension->RdWrOp.D_Sect -
693: TapeExtension->RdWrOp.S_Sect);
694: }
695: return(NoErr);
696: }
697:
698: if (TapeExtension->QControllerData->FdcStat.ST1 == 0 &&
699: TapeExtension->QControllerData->FdcStat.ST2 == 0) {
700:
701: //
702: // no errors
703: //
704:
705: DbgAddEntry(TapeExtension->RdWrOp.D_Sect);
706: DbgAddEntry(TapeExtension->RdWrOp.DataAmount);
707: DbgAddEntry(TapeExtension->RdWrOp.CurLst);
708: DbgAddEntry(TapeExtension->RdWrOp.BytesTransferredSoFar);
709:
710: TapeExtension->RdWrOp.SeekFlag = TRUE;
711: TapeExtension->TapePosition.C_Segment =
712: TapeExtension->TapePosition.D_Segment;
713: TapeExtension->RdWrOp.D_Sect +=
714: (UCHAR)TapeExtension->RdWrOp.DataAmount;
715: TapeExtension->RdWrOp.BytesTransferredSoFar +=
716: (ULONG)(TapeExtension->RdWrOp.DataAmount*PHY_SIZ);
717: TapeExtension->RdWrOp.DataAmount = 0;
718: return(NoErr);
719: }
720:
721: if ((IoRequestCurrent->Command == DReadBad) &&
722: (TapeExtension->QControllerData->FdcStat.ST2 & ST2_CM)) {
723:
724: IoRequestCurrent->BadList = 0xffffffff;
725: *Status = BadMark;
726: return(NoErr);
727:
728: }
729:
730: if ((TapeExtension->QControllerData->FdcStat.ST2 & ST2_WC) ||
731: (TapeExtension->QControllerData->FdcStat.ST1 &
732: (ST1_OR | ST1_ND | ST1_MA))) {
733:
734: if (TapeExtension->RdWrOp.SeekFlag == TRUE) {
735:
736: TapeExtension->TapePosition.C_Segment =
737: TapeExtension->TapePosition.D_Segment + 1;
738: TapeExtension->RdWrOp.SeekFlag = FALSE;
739: return(NoErr);
740:
741: }
742: }
743:
744: if ((IoRequestCurrent->Command == DVerify) &&
745: (TapeExtension->QControllerData->FdcStat.ST1 & ST1_MA)) {
746:
747: if (TapeExtension->RdWrOp.SeekFlag == TRUE) {
748:
749: retval = Q117iGetDriveError(TapeExtension);
750:
751: if (retval && (retval != NotRdy)) {
752:
753: return(retval);
754:
755: }
756:
757: if ((retval = Q117iPauseTape(TapeExtension)) != NoErr) {
758:
759: return(retval);
760:
761: }
762:
763: if ((retval = Q117iReadIDRepeat(TapeExtension)) != NoErr) {
764:
765: return(retval);
766:
767: }
768:
769: TapeExtension->RdWrOp.SeekFlag = FALSE;
770: return(NoErr);
771: }
772: }
773:
774: TapeExtension->TapePosition.C_Segment =
775: TapeExtension->TapePosition.D_Segment;
776:
777: retval = Q117iRetryCode(
778: TapeExtension,
779: IoRequestCurrent,
780: &TapeExtension->QControllerData->FdcStat,
781: Status);
782:
783: return(retval);
784: }
785:
786:
787: STATUS
788: Q117iRetryCode(
789: IN PTAPE_EXTENSION TapeExtension,
790: IN OUT PIO_REQUEST IoRequestCurrent,
791: OUT FDC_STATUS *FdcStatus,
792: OUT STATUS *Status
793: )
794:
795: /*++
796:
797: Routine Description:
798:
799: Orchestrate retries for read/write/verify (and retyr) commands.
800:
801: Arguments:
802:
803: TapeExtension -
804:
805: IoRequestCurrent -
806:
807: FdcStatus -
808:
809: Status -
810:
811: Return Value:
812:
813:
814:
815: --*/
816: {
817: STATUS retval;
818: SHORT sectorsRead;
819:
820: if (TapeExtension->RdWrOp.RetryTimes != 0) {
821:
822: if (IoRequestCurrent->Command != DRetry) {
823:
824: retval = Q117iGetDriveError(TapeExtension);
825:
826: if (retval && (retval != NotRdy)) {
827:
828: return(retval);
829:
830: }
831:
832: if ((retval = Q117iPauseTape(TapeExtension)) != NoErr) {
833:
834: return(retval);
835:
836: }
837:
838: }
839:
840: if ((retval = Q117iReadIDRepeat(TapeExtension)) != NoErr) {
841:
842: return(retval);
843:
844: }
845:
846: } else {
847:
848: TapeExtension->RdWrOp.SeekFlag = TRUE;
849:
850: }
851:
852: if ((TapeExtension->RdWrOp.RetryTimes == 0) ||
853: (FdcStatus->R == TapeExtension->RdWrOp.RetrySectorId)) {
854:
855: if ((TapeExtension->RdWrOp.RetryTimes == 0) ||
856: (--TapeExtension->RdWrOp.RetryCount == 0)) {
857:
858: TapeExtension->RdWrOp.SeekFlag = TRUE;
859: IoRequestCurrent->BadList |=
860: 1l << (FdcStatus->R - TapeExtension->RdWrOp.S_Sect);
861: *Status = BadBlk;
862: sectorsRead = FdcStatus->R + 1 - TapeExtension->RdWrOp.D_Sect;
863: TapeExtension->RdWrOp.D_Sect = FdcStatus->R + 1;
864: TapeExtension->RdWrOp.DataAmount -= sectorsRead;
865: TapeExtension->RdWrOp.BytesTransferredSoFar +=
866: sectorsRead * PHY_SIZ;
867: TapeExtension->RdWrOp.RetryCount =
868: TapeExtension->RdWrOp.RetryTimes;
869: TapeExtension->RdWrOp.RetrySectorId = 0;
870: retval = Q117iSetBack(TapeExtension, IoRequestCurrent->Command);
871:
872: } else {
873:
874: retval = Q117iNextTry(TapeExtension, IoRequestCurrent->Command);
875:
876: }
877:
878: } else {
879:
880: IoRequestCurrent->RetryList |=
881: 1l << (FdcStatus->R - TapeExtension->RdWrOp.S_Sect);
882: TapeExtension->RdWrOp.RetrySectorId = FdcStatus->R;
883: TapeExtension->RdWrOp.RetryCount =
884: TapeExtension->RdWrOp.RetryTimes;
885: sectorsRead = FdcStatus->R - TapeExtension->RdWrOp.D_Sect;
886: TapeExtension->RdWrOp.D_Sect = FdcStatus->R;
887: TapeExtension->RdWrOp.DataAmount -= sectorsRead;
888: TapeExtension->RdWrOp.BytesTransferredSoFar +=
889: sectorsRead * PHY_SIZ;
890:
891: }
892:
893: return(retval);
894: }
895:
896:
897:
898: STATUS
899: Q117iNextTry(
900: IN PTAPE_EXTENSION TapeExtension,
901: IN DRIVER_COMMAND Command
902: )
903:
904: /*++
905:
906: Routine Description:
907:
908: Determines the next tape drive head position during off-track retries.
909:
910: Arguments:
911:
912: TapeExtension -
913:
914: Command -
915:
916: Return Value:
917:
918:
919:
920: --*/
921:
922: {
923: STATUS retval = NoErr;
924:
925: if (Command == DRetry) {
926:
927: retval = Q117iGetDriveError(TapeExtension);
928:
929: if (retval && (retval != NotRdy)) {
930:
931: return(retval);
932:
933: }
934:
935: TapeExtension->RetrySeqNum++;
936:
937: if (TapeExtension->RdWrOp.RetryCount > 3) {
938:
939: retval = Q117iSendByte(TapeExtension, Pause);
940:
941: } else {
942:
943: retval = Q117iSendByte(TapeExtension, Micro_Pause);
944:
945: }
946:
947: if (retval) {
948:
949: return(retval);
950:
951: }
952:
953: retval = Q117iWaitCommandComplete(TapeExtension, mt_wt016s);
954: TapeExtension->TapePosition.LogFwd = FALSE;
955:
956: }
957:
958: return(retval);
959: }
960:
961:
962: STATUS
963: Q117iSetBack(
964: IN PTAPE_EXTENSION TapeExtension,
965: IN DRIVER_COMMAND Command
966: )
967:
968: /*++
969:
970: Routine Description:
971:
972: Reset any tape drive head offset due to off-track retries.
973:
974: Arguments:
975:
976: TapeExtension -
977:
978: Command -
979:
980: Return Value:
981:
982:
983:
984: --*/
985: {
986: STATUS retval = NoErr;
987:
988: if (Command == DRetry) {
989:
990: if (TapeExtension->TapePosition.LogFwd == TRUE) {
991:
992: retval = Q117iGetDriveError(TapeExtension);
993:
994: if (retval && (retval != NotRdy)) {
995:
996: return(retval);
997:
998: }
999:
1000: if ((retval = Q117iPauseTape(TapeExtension)) != NoErr) {
1001:
1002: return(retval);
1003:
1004: }
1005:
1006: }
1007:
1008: if ((retval = Q117iSendByte(TapeExtension, Seek_Track)) != NoErr) {
1009:
1010: return(retval);
1011:
1012: }
1013:
1014: Q117iSleep(TapeExtension, mt_wt2ticks, FALSE);
1015:
1016: if ((retval = Q117iSendByte(
1017: TapeExtension,
1018: (CHAR)(TapeExtension->TapePosition.C_Track + 2))) !=
1019: NoErr) {
1020:
1021: return(retval);
1022:
1023: }
1024:
1025: retval = Q117iWaitCommandComplete(TapeExtension, mt_wt007s);
1026: }
1027:
1028: return(retval);
1029: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.