![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tandqic.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / scsitape / tandqic|
Return to tandqic.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / scsitape / tandqic |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: tandqic.c
8:
9: Abstract:
10:
11: This module contains device specific routines for Tandberg QIC
12: drives with SCSI-2 interfaces -- TDC 4220, TDC 4120, TDC 3820,
13: and TDC 3660.
14:
15: Author:
16:
17: Mike Colandreo (Maynard)
18:
19: Environment:
20:
21: kernel mode only
22:
23: Revision History:
24:
25: --*/
26:
27: #include "ntddk.h"
28: #include "tape.h"
29: #include "physlogi.h"
30:
31: //
32: // Internal (module wide) defines that symbolize
33: // non-QFA mode and the two QFA mode partitions.
34: //
35: #define NO_PARTITIONS 0 // non-QFA mode
36: #define DIRECTORY_PARTITION 1 // QFA mode, directory partition #
37: #define DATA_PARTITION 2 // QFA mode, data partition #
38:
39: //
40: // Internal (module wide) defines that symbolize
41: // the Tandberg QIC drives supported by this module.
42: //
43: #define TDC_3600 (ULONG)1 // aka the TDC 3660
44: #define TDC_3800 (ULONG)2 // aka the TDC 3820
45: #define TDC_4100 (ULONG)3 // aka the TDC 4120
46: #define TDC_4200 (ULONG)4 // aka the TDC 4220
47:
48: //
49: // Function Prototype(s) for internal function(s)
50: //
51: static
52: NTSTATUS
53: GetInquiryInformationData (
54: IN PDEVICE_OBJECT DeviceObject,
55: IN PIRP Irp,
56: OUT PINQUIRYDATA InquiryBuffer
57: );
58:
59: static
60: NTSTATUS
61: RewindToBOT(
62: IN PDEVICE_OBJECT DeviceObject,
63: IN PIRP Irp
64: );
65:
66: static
67: ULONG
68: WhichIsIt(
69: IN PINQUIRYDATA InquiryData
70: );
71:
72:
73: NTSTATUS
74: TapeCreatePartition(
75: IN PDEVICE_OBJECT DeviceObject,
76: IN PIRP Irp
77: )
78:
79: /*++
80: Routine Description:
81:
82: This routine can either "create" two, fixed, QFA partitions on a QIC
83: tape by selecting/enabling the drive's dual-partition, QFA mode or
84: return the drive to the not partitioned mode (i.e., disable QFA mode).
85: Note that this function "creates" two partitions only in a conceptual
86: sense -- it does not physically affect tape.
87:
88: Arguments:
89:
90: DeviceObject
91: Irp
92:
93: Return Value:
94:
95: NTSTATUS
96:
97: --*/
98:
99: {
100: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
101: PTAPE_CREATE_PARTITION tapePartition = Irp->AssociatedIrp.SystemBuffer;
102: PTAPE_DATA tapeData = (PTAPE_DATA)(deviceExtension + 1);
103: PMODE_MEDIUM_PART_PAGE buffer;
104: SCSI_REQUEST_BLOCK srb;
105: PCDB cdb = (PCDB)srb.Cdb;
106: NTSTATUS status;
107:
108: //
109: // Only support 2 partitions, QFA mode
110: // Partition 1 = Used as directory
111: // Partition 0 = used as data
112: //
113: // Note that 0 & 1 are partition numbers used
114: // by the drive -- they are not tape API partition
115: // numbers.
116: //
117:
118: DebugPrint((3,"TapeCreatePartition: Enter routine\n"));
119:
120: switch (tapePartition->Method) {
121: case TAPE_FIXED_PARTITIONS:
122: DebugPrint((3,"TapeCreatePartition: fixed partitions\n"));
123: break;
124:
125: case TAPE_SELECT_PARTITIONS:
126: case TAPE_INITIATOR_PARTITIONS:
127: default:
128: DebugPrint((1,"TapeCreatePartition: "));
129: DebugPrint((1,"PartitionMethod -- operation not supported\n"));
130: return STATUS_NOT_IMPLEMENTED;
131: }
132:
133: //
134: // Must rewind to BOT before one can enable/disable QFA mode.
135: // Changing the value of the FDP bit is only valid at BOT.
136: // FDP bit is used to enable/disable "additional partitions"
137: // (mode sense command).
138: //
139:
140: DebugPrint((3,"TapeCreatePartition: SendSrb (rewind)\n"));
141:
142: status = RewindToBOT(DeviceObject, Irp);
143:
144: if (!NT_SUCCESS(status)) {
145: DebugPrint((1,"TapeCreatePartition: rewind, SendSrb unsuccessful\n"));
146: return status;
147: }
148:
149: //
150: // Performing mode select command, medium partition parameters page,
151: // to enable/disable QFA mode: set the FDP bit accordingly.
152: //
153:
154: buffer = ExAllocatePool(NonPagedPoolCacheAligned,
155: sizeof(MODE_MEDIUM_PART_PAGE));
156:
157: if (!buffer) {
158: DebugPrint((1,"TapeCreatePartition: insufficient resources (buffer)\n"));
159: return STATUS_INSUFFICIENT_RESOURCES;
160: }
161:
162: RtlZeroMemory(buffer, sizeof(MODE_MEDIUM_PART_PAGE));
163:
164: buffer->ParameterListHeader.DeviceSpecificParameter = 0x10;
165:
166: buffer->MediumPartPage.PageCode = MODE_PAGE_MEDIUM_PARTITION;
167: buffer->MediumPartPage.PageLength = 0x06;
168: buffer->MediumPartPage.MaximumAdditionalPartitions = 1;
169:
170: //
171: // Setup FDP bit to enable/disable "additional partition".
172: //
173:
174: if (tapePartition->Count == 0) {
175: buffer->MediumPartPage.FDPBit = SETBITOFF;
176: } else {
177: buffer->MediumPartPage.FDPBit = SETBITON;
178: }
179:
180: //
181: // Zero CDB in SRB on stack.
182: //
183:
184: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
185:
186: //
187: // Prepare SCSI command (CDB)
188: //
189:
190: srb.CdbLength = CDB6GENERIC_LENGTH;
191:
192: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
193: cdb->MODE_SELECT.PFBit = SETBITON;
194: cdb->MODE_SELECT.ParameterListLength = sizeof(MODE_MEDIUM_PART_PAGE) - 4;
195:
196: //
197: // Set timeout value.
198: //
199:
200: srb.TimeOutValue = deviceExtension->TimeOutValue;
201:
202: //
203: // Send SCSI command (CDB) to device
204: //
205:
206: DebugPrint((3,"TapeCreatePartition: SendSrb (mode select)\n"));
207:
208: status = ScsiClassSendSrbSynchronous(DeviceObject,
209: &srb,
210: buffer,
211: sizeof(MODE_MEDIUM_PART_PAGE) - 4,
212: TRUE);
213:
214: ExFreePool(buffer);
215:
216: if (NT_SUCCESS(status)) {
217:
218: if (tapePartition->Count == 0) {
219: tapeData->CurrentPartition = NO_PARTITIONS;
220: DebugPrint((3,"TapeCreatePartition: QFA disabled\n"));
221: } else {
222: tapeData->CurrentPartition = DATA_PARTITION;
223: DebugPrint((3,"TapeCreatePartition: QFA enabled\n"));
224: }
225:
226: } else {
227:
228: DebugPrint((1,"TapeCreatePartition: mode select, SendSrb unsuccessful\n"));
229:
230: }
231:
232: return status;
233:
234: } // end TapeCreatePartition()
235:
236:
237: NTSTATUS
238: TapeErase(
239: IN PDEVICE_OBJECT DeviceObject,
240: IN PIRP Irp
241: )
242:
243: /*++
244: Routine Description:
245:
246: This routine erases the entire tape. The Tandberg QIC drives cannot
247: partially erase tape. Positioning the tape at BOT is a prerequisite:
248: the drive rejects the command if the tape is not at BOT.
249:
250: Arguments:
251:
252: DeviceObject
253: Irp
254:
255: Return Value:
256:
257: NTSTATUS
258:
259: --*/
260:
261: {
262: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
263: PTAPE_ERASE tapeErase = Irp->AssociatedIrp.SystemBuffer;
264: PTAPE_DATA tapeData = (PTAPE_DATA)(deviceExtension + 1);
265: SCSI_REQUEST_BLOCK srb;
266: PCDB cdb = (PCDB)srb.Cdb;
267: NTSTATUS status;
268:
269: DebugPrint((3,"TapeErase: Enter routine\n"));
270:
271: if (tapeErase->Immediate) {
272: switch (tapeErase->Type) {
273: case TAPE_ERASE_LONG:
274: DebugPrint((3,"TapeErase: immediate\n"));
275: break;
276:
277: case TAPE_ERASE_SHORT:
278: default:
279: DebugPrint((1,"TapeErase: EraseType, immediate -- operation not supported\n"));
280: return STATUS_NOT_IMPLEMENTED;
281: }
282: }
283:
284: switch (tapeErase->Type) {
285: case TAPE_ERASE_LONG:
286: DebugPrint((3,"TapeErase: long\n"));
287: break;
288:
289: case TAPE_ERASE_SHORT:
290: default:
291: DebugPrint((1,"TapeErase: EraseType -- operation not supported\n"));
292: return STATUS_NOT_IMPLEMENTED;
293: }
294:
295: //
296: // Zero CDB in SRB on stack.
297: //
298:
299: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
300:
301: //
302: // Prepare SCSI command (CDB)
303: //
304:
305: srb.CdbLength = CDB6GENERIC_LENGTH;
306:
307: cdb->ERASE.OperationCode = SCSIOP_ERASE;
308: cdb->ERASE.Immediate = tapeErase->Immediate;
309: cdb->ERASE.Long = SETBITON;
310:
311: //
312: // Set timeout value.
313: //
314:
315: srb.TimeOutValue = 360;
316:
317: //
318: // Send SCSI command (CDB) to device
319: //
320:
321: DebugPrint((3,"TapeErase: SendSrb (erase)\n"));
322:
323: status = ScsiClassSendSrbSynchronous(DeviceObject,
324: &srb,
325: NULL,
326: 0,
327: FALSE);
328:
329: if (!NT_SUCCESS(status)) {
330: DebugPrint((1,"TapeErase: erase, SendSrb unsuccessful\n"));
331: return status;
332: }
333:
334: if (tapeData->CurrentPartition) {
335: tapeData->CurrentPartition = DATA_PARTITION;
336: }
337:
338: return status;
339:
340: } // end TapeErase()
341:
342:
343: VOID
344: TapeError(
345: PDEVICE_OBJECT DeviceObject,
346: PSCSI_REQUEST_BLOCK Srb,
347: NTSTATUS *Status,
348: BOOLEAN *Retry
349: )
350:
351: /*++
352:
353: Routine Description:
354:
355: When a request completes with error, the routine InterpretSenseInfo is
356: called to determine from the sense data whether the request should be
357: retried and what NT status to set in the IRP. Then this routine is called
358: for tape requests to handle tape-specific errors and update the nt status
359: and retry boolean.
360:
361: Arguments:
362:
363: DeviceObject - Supplies a pointer to the device object.
364:
365: Srb - Supplies a pointer to the failing Srb.
366:
367: Status - NT Status used to set the IRP's completion status.
368:
369: Retry - Indicates that this request should be retried.
370:
371: Return Value:
372:
373: None.
374:
375: --*/
376:
377: {
378: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
379: PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
380: NTSTATUS status = *Status;
381: BOOLEAN retry = *Retry;
382:
383: DebugPrint((3,"TapeError: Enter routine\n"));
384: DebugPrint((1,"TapeError: Status 0x%.8X, Retry %d\n", status, retry));
385: return;
386:
387: } // end TapeError()
388:
389:
390: NTSTATUS
391: TapeGetDriveParameters(
392: IN PDEVICE_OBJECT DeviceObject,
393: IN PIRP Irp
394: )
395:
396: /*++
397: Routine Description:
398:
399: This routine determines and returns the "drive parameters" of the
400: Tandberg QIC tape drive associated with "DeviceObject". From time
401: to time, the drive paramater set of a given drive will vary. It will
402: change as drive operating characteristics change: e.g., tape media
403: type loaded, recording density of the media type loaded, etc.
404:
405: Arguments:
406:
407: DeviceObject
408: Irp
409:
410: Return Value:
411:
412: NTSTATUS
413:
414: --*/
415:
416: {
417: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
418: PTAPE_GET_DRIVE_PARAMETERS tapeGetDriveParams = Irp->AssociatedIrp.SystemBuffer;
419: PMODE_PARM_READ_WRITE_DATA modeParmBuffer;
420: PREAD_BLOCK_LIMITS_DATA blockLimits;
421: PINQUIRYDATA inquiryBuffer;
422: UCHAR densityCode;
423: UCHAR mediumType;
424: ULONG tapeBlockLength;
425: ULONG whichdrive;
426: SCSI_REQUEST_BLOCK srb;
427: PCDB cdb = (PCDB)srb.Cdb;
428: NTSTATUS status;
429:
430: DebugPrint((3,"TapeGetDriveParameters: Enter routine\n"));
431:
432: RtlZeroMemory(tapeGetDriveParams, sizeof(TAPE_GET_DRIVE_PARAMETERS));
433: Irp->IoStatus.Information = sizeof(TAPE_GET_DRIVE_PARAMETERS);
434:
435: modeParmBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
436: sizeof(MODE_PARM_READ_WRITE_DATA));
437:
438: if (!modeParmBuffer) {
439: DebugPrint((1,"TapeGetDriveParameters: insufficient resources (modeParmBuffer)\n"));
440: return STATUS_INSUFFICIENT_RESOURCES;
441: }
442:
443: RtlZeroMemory(modeParmBuffer, sizeof(MODE_PARM_READ_WRITE_DATA));
444:
445: //
446: // Zero CDB in SRB on stack.
447: //
448:
449: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
450:
451: //
452: // Prepare SCSI command (CDB)
453: //
454:
455: srb.CdbLength = CDB6GENERIC_LENGTH;
456:
457: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
458: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_PARM_READ_WRITE_DATA);
459:
460: //
461: // Set timeout value.
462: //
463:
464: srb.TimeOutValue = deviceExtension->TimeOutValue;
465:
466: //
467: // Send SCSI command (CDB) to device
468: //
469:
470: DebugPrint((3,"TapeGetDriveParameters: SendSrb (mode sense)\n"));
471:
472: status = ScsiClassSendSrbSynchronous(DeviceObject,
473: &srb,
474: modeParmBuffer,
475: sizeof(MODE_PARM_READ_WRITE_DATA),
476: FALSE);
477:
478: if (NT_SUCCESS(status)) {
479:
480: mediumType = modeParmBuffer->ParameterListHeader.MediumType;
481: densityCode = modeParmBuffer->ParameterListBlock.DensityCode;
482: tapeBlockLength = modeParmBuffer->ParameterListBlock.BlockLength[2];
483: tapeBlockLength += (modeParmBuffer->ParameterListBlock.BlockLength[1] << 8);
484: tapeBlockLength += (modeParmBuffer->ParameterListBlock.BlockLength[0] << 16);
485:
486: switch (mediumType) {
487: case 1:
488: mediumType = DC600;
489: break;
490:
491: case 2:
492: mediumType = DC6150;
493: break;
494:
495: case 3:
496: mediumType = DC6320;
497: break;
498:
499: }
500:
501: }
502:
503: ExFreePool(modeParmBuffer);
504:
505: if (!NT_SUCCESS(status)) {
506: DebugPrint((1,"TapeGetDriveParameters: mode sense, SendSrb unsuccessful\n"));
507: return status;
508: }
509:
510: blockLimits = ExAllocatePool(NonPagedPoolCacheAligned,
511: sizeof(READ_BLOCK_LIMITS_DATA));
512:
513: if (!blockLimits) {
514: DebugPrint((1,"TapeGetDriveParameters: insufficient resources (blockLimits)\n"));
515: return STATUS_INSUFFICIENT_RESOURCES;
516: }
517:
518: RtlZeroMemory(blockLimits, sizeof(READ_BLOCK_LIMITS_DATA));
519:
520: //
521: // Zero CDB in SRB on stack.
522: //
523:
524: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
525:
526: //
527: // Prepare SCSI command (CDB)
528: //
529:
530: srb.CdbLength = CDB6GENERIC_LENGTH;
531:
532: cdb->CDB6GENERIC.OperationCode = SCSIOP_READ_BLOCK_LIMITS;
533:
534: //
535: // Set timeout value.
536: //
537:
538: srb.TimeOutValue = deviceExtension->TimeOutValue;
539:
540: //
541: // Send SCSI command (CDB) to device
542: //
543:
544: DebugPrint((3,"TapeGetDriveParameters: SendSrb (read block limits)\n"));
545:
546: status = ScsiClassSendSrbSynchronous(DeviceObject,
547: &srb,
548: blockLimits,
549: sizeof(READ_BLOCK_LIMITS_DATA),
550: FALSE);
551:
552: if (NT_SUCCESS(status)) {
553: tapeGetDriveParams->MaximumBlockSize = blockLimits->BlockMaximumSize[2];
554: tapeGetDriveParams->MaximumBlockSize += (blockLimits->BlockMaximumSize[1] << 8);
555: tapeGetDriveParams->MaximumBlockSize += (blockLimits->BlockMaximumSize[0] << 16);
556:
557: tapeGetDriveParams->MinimumBlockSize = blockLimits->BlockMinimumSize[1];
558: tapeGetDriveParams->MinimumBlockSize += (blockLimits->BlockMinimumSize[0] << 8);
559: }
560:
561: ExFreePool(blockLimits);
562:
563: if (!NT_SUCCESS(status)) {
564: DebugPrint((1,"TapeGetDriveParameters: read block limits, SendSrb unsuccessful\n"));
565: return status;
566: }
567:
568: inquiryBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
569: sizeof(INQUIRYDATA));
570:
571: if (!inquiryBuffer) {
572: DebugPrint((1,"TapeGetDriveParameters: insufficient resources (inquiryBuffer)\n"));
573: return STATUS_INSUFFICIENT_RESOURCES;
574: }
575:
576: RtlZeroMemory(inquiryBuffer, sizeof(INQUIRYDATA));
577:
578: //
579: // Send SCSI command (CDB) to device
580: //
581:
582: DebugPrint((3,"TapeGetDriveParameters: SendSrb (inquiry)\n"));
583:
584: status = GetInquiryInformationData(DeviceObject, Irp, inquiryBuffer);
585:
586: if (NT_SUCCESS(status)) {
587:
588: //
589: // Which drive do we have, TDC 3660, 3820, 4120 or 4220?
590: //
591:
592: whichdrive = WhichIsIt(inquiryBuffer);
593: }
594:
595: ExFreePool(inquiryBuffer);
596:
597: if (!NT_SUCCESS(status)) {
598: DebugPrint((1,"TapeGetDriveParameters: inquiry, SendSrb unsuccessful\n"));
599: return status;
600: }
601:
602: tapeGetDriveParams->ECC = 0;
603: tapeGetDriveParams->Compression = 0;
604: tapeGetDriveParams->DataPadding = 0;
605: tapeGetDriveParams->MaximumPartitionCount = 2;
606:
607: if ((whichdrive == TDC_4100) || (whichdrive == TDC_4200)) {
608:
609: tapeGetDriveParams->ReportSetmarks = TRUE;
610:
611: tapeGetDriveParams->FeaturesLow |=
612: TAPE_DRIVE_REPORT_SMKS;
613:
614: tapeGetDriveParams->FeaturesHigh |=
615: TAPE_DRIVE_SETMARKS |
616: TAPE_DRIVE_WRITE_SETMARKS;
617:
618: }
619:
620: if (whichdrive != TDC_3600) {
621:
622: tapeGetDriveParams->FeaturesLow |=
623: TAPE_DRIVE_VARIABLE_BLOCK;
624:
625: tapeGetDriveParams->FeaturesHigh |=
626: TAPE_DRIVE_SET_BLOCK_SIZE;
627:
628: }
629:
630: switch (densityCode) {
631: case QIC_XX:
632: switch (mediumType) {
633: case DC6320:
634: case DC6525:
635: case DC9100:
636: case DC9100XL:
637: tapeGetDriveParams->DefaultBlockSize = 1024;
638: break;
639:
640: default:
641: tapeGetDriveParams->DefaultBlockSize = 512;
642: break;
643: }
644: break;
645:
646: case QIC_525:
647: case QIC_1000:
648: case QIC_2GB:
649: tapeGetDriveParams->DefaultBlockSize = 1024;
650: break;
651:
652: default:
653: tapeGetDriveParams->DefaultBlockSize = 512;
654: break;
655: }
656:
657: tapeGetDriveParams->FeaturesLow |=
658: TAPE_DRIVE_FIXED |
659: TAPE_DRIVE_ERASE_LONG |
660: TAPE_DRIVE_ERASE_BOP_ONLY |
661: TAPE_DRIVE_ERASE_IMMEDIATE |
662: TAPE_DRIVE_FIXED_BLOCK |
663: TAPE_DRIVE_WRITE_PROTECT |
664: TAPE_DRIVE_GET_ABSOLUTE_BLK |
665: TAPE_DRIVE_GET_LOGICAL_BLK;
666:
667: tapeGetDriveParams->FeaturesHigh |=
668: TAPE_DRIVE_LOAD_UNLOAD |
669: TAPE_DRIVE_TENSION |
670: TAPE_DRIVE_LOCK_UNLOCK |
671: TAPE_DRIVE_REWIND_IMMEDIATE |
672: TAPE_DRIVE_LOAD_UNLD_IMMED |
673: TAPE_DRIVE_TENSION_IMMED |
674: TAPE_DRIVE_ABSOLUTE_BLK |
675: TAPE_DRIVE_LOGICAL_BLK |
676: TAPE_DRIVE_END_OF_DATA |
677: TAPE_DRIVE_RELATIVE_BLKS |
678: TAPE_DRIVE_FILEMARKS |
679: TAPE_DRIVE_SEQUENTIAL_FMKS |
680: TAPE_DRIVE_REVERSE_POSITION |
681: TAPE_DRIVE_WRITE_FILEMARKS |
682: TAPE_DRIVE_WRITE_MARK_IMMED;
683:
684: tapeGetDriveParams->FeaturesHigh &= ~TAPE_DRIVE_HIGH_FEATURES;
685:
686: DebugPrint((3,"TapeGetDriveParameters: FeaturesLow == 0x%.8X\n",
687: tapeGetDriveParams->FeaturesLow));
688: DebugPrint((3,"TapeGetDriveParameters: FeaturesHigh == 0x%.8X\n",
689: tapeGetDriveParams->FeaturesHigh));
690:
691: return status;
692:
693: } // end TapeGetDriveParameters()
694:
695:
696: NTSTATUS
697: TapeGetMediaParameters(
698: IN PDEVICE_OBJECT DeviceObject,
699: IN PIRP Irp
700: )
701:
702: /*++
703: Routine Description:
704:
705: This routine determines and returns the "media parameters" of the
706: Tandberg QIC tape drive associated with "DeviceObject". Tape media
707: must be present (loaded) in the drive for this function to return
708: "no error".
709:
710: Arguments:
711:
712: DeviceObject
713: Irp
714:
715: Return Value:
716:
717: NTSTATUS
718:
719: --*/
720:
721: {
722: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
723: PTAPE_DATA tapeData = (PTAPE_DATA)(deviceExtension + 1);
724: PTAPE_GET_MEDIA_PARAMETERS tapeGetMediaParams = Irp->AssociatedIrp.SystemBuffer;
725: PMODE_TAPE_MEDIA_INFORMATION mediaInfoBuffer;
726: PMODE_DEVICE_CONFIG_PAGE deviceConfigBuffer;
727: ULONG sectorShift;
728: SCSI_REQUEST_BLOCK srb;
729: PCDB cdb = (PCDB)srb.Cdb;
730: NTSTATUS status;
731:
732: DebugPrint((3,"TapeGetMediaParameters: Enter routine\n"));
733:
734: RtlZeroMemory(tapeGetMediaParams, sizeof(TAPE_GET_MEDIA_PARAMETERS));
735: Irp->IoStatus.Information = sizeof(TAPE_GET_MEDIA_PARAMETERS);
736:
737: //
738: // Zero CDB in SRB on stack.
739: //
740:
741: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
742:
743: //
744: // Prepare SCSI command (CDB)
745: //
746:
747: srb.CdbLength = CDB6GENERIC_LENGTH;
748:
749: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
750:
751: //
752: // Set timeout value.
753: //
754:
755: srb.TimeOutValue = deviceExtension->TimeOutValue;
756:
757: //
758: // Send SCSI command (CDB) to device
759: //
760:
761: DebugPrint((3,"TapeGetMediaParameters: SendSrb (test unit ready)\n"));
762:
763: status = ScsiClassSendSrbSynchronous(DeviceObject,
764: &srb,
765: NULL,
766: 0,
767: FALSE);
768:
769: if (!NT_SUCCESS(status)) {
770: DebugPrint((1,"TapeGetMediaParameters: test unit ready, SendSrb unsuccessful\n"));
771: return status;
772: }
773:
774: mediaInfoBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
775: sizeof(MODE_TAPE_MEDIA_INFORMATION));
776:
777: if (!mediaInfoBuffer) {
778: DebugPrint((1,"TapeGetMediaParameters: insufficient resources (mediaInfoBuffer)\n"));
779: return STATUS_INSUFFICIENT_RESOURCES;
780: }
781:
782: RtlZeroMemory(mediaInfoBuffer, sizeof(MODE_TAPE_MEDIA_INFORMATION));
783:
784: //
785: // Zero CDB in SRB on stack.
786: //
787:
788: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
789:
790: //
791: // Prepare SCSI command (CDB)
792: //
793:
794: srb.CdbLength = CDB6GENERIC_LENGTH;
795:
796: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
797: cdb->MODE_SENSE.PageCode = MODE_PAGE_MEDIUM_PARTITION;
798: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_TAPE_MEDIA_INFORMATION) - 4;
799:
800: //
801: // Set timeout value.
802: //
803:
804: srb.TimeOutValue = deviceExtension->TimeOutValue;
805:
806: //
807: // Send SCSI command (CDB) to device
808: //
809:
810: DebugPrint((3,"TapeGetMediaParameters: SendSrb (mode sense #1)\n"));
811:
812: status = ScsiClassSendSrbSynchronous(DeviceObject,
813: &srb,
814: mediaInfoBuffer,
815: sizeof(MODE_TAPE_MEDIA_INFORMATION) - 4,
816: FALSE);
817:
818: if (!NT_SUCCESS(status)) {
819: DebugPrint((1,"TapeGetMediaParameters: mode sense #1, SendSrb unsuccessful\n"));
820: ExFreePool(mediaInfoBuffer);
821: return status;
822: }
823:
824: if (mediaInfoBuffer->MediumPartPage.FDPBit) {
825:
826: deviceConfigBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
827: sizeof(MODE_DEVICE_CONFIG_PAGE));
828:
829: if (!deviceConfigBuffer) {
830: DebugPrint((1,"TapeGetMediaParameters: insufficient resources (deviceConfigBuffer)\n"));
831: ExFreePool(mediaInfoBuffer);
832: return STATUS_INSUFFICIENT_RESOURCES;
833: }
834:
835: RtlZeroMemory(deviceConfigBuffer, sizeof(MODE_DEVICE_CONFIG_PAGE));
836:
837: //
838: // Zero CDB in SRB on stack.
839: //
840:
841: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
842:
843: //
844: // Prepare SCSI command (CDB)
845: //
846:
847: srb.CdbLength = CDB6GENERIC_LENGTH;
848:
849: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
850: cdb->MODE_SENSE.Dbd = SETBITON;
851: cdb->MODE_SENSE.PageCode = MODE_PAGE_DEVICE_CONFIG;
852: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_DEVICE_CONFIG_PAGE);
853:
854: //
855: // Set timeout value.
856: //
857:
858: srb.TimeOutValue = deviceExtension->TimeOutValue;
859:
860: //
861: // Send SCSI command (CDB) to device
862: //
863:
864: DebugPrint((3,"TapeGetMediaParameters: SendSrb (mode sense #2)\n"));
865:
866: status = ScsiClassSendSrbSynchronous(DeviceObject,
867: &srb,
868: deviceConfigBuffer,
869: sizeof(MODE_DEVICE_CONFIG_PAGE),
870: FALSE);
871:
872: if (!NT_SUCCESS(status)) {
873: DebugPrint((1,"TapeGetMediaParameters: mode sense #2, SendSrb unsuccessful\n"));
874: ExFreePool(deviceConfigBuffer);
875: ExFreePool(mediaInfoBuffer);
876: return status;
877: }
878:
879: tapeData->CurrentPartition =
880: deviceConfigBuffer->DeviceConfigPage.ActivePartition?
881: DIRECTORY_PARTITION : DATA_PARTITION;
882:
883: tapeGetMediaParams->PartitionCount = 2;
884:
885: ExFreePool(deviceConfigBuffer);
886:
887: } else {
888:
889: tapeGetMediaParams->PartitionCount = 1 ;
890:
891: tapeData->CurrentPartition = NO_PARTITIONS;
892:
893: }
894:
895: tapeGetMediaParams->BlockSize = mediaInfoBuffer->ParameterListBlock.BlockLength[2];
896: tapeGetMediaParams->BlockSize += (mediaInfoBuffer->ParameterListBlock.BlockLength[1] << 8);
897: tapeGetMediaParams->BlockSize += (mediaInfoBuffer->ParameterListBlock.BlockLength[0] << 16);
898:
899: WHICH_BIT(tapeGetMediaParams->BlockSize, sectorShift);
900: deviceExtension->DiskGeometry->BytesPerSector = tapeGetMediaParams->BlockSize;
901: deviceExtension->SectorShift = sectorShift;
902:
903: tapeGetMediaParams->WriteProtected =
904: ((mediaInfoBuffer->ParameterListHeader.DeviceSpecificParameter >> 7) & 0x01);
905:
906: ExFreePool(mediaInfoBuffer);
907:
908: return status;
909:
910: } // end TapeGetMediaParameters()
911:
912:
913: NTSTATUS
914: TapeGetPosition(
915: IN PDEVICE_OBJECT DeviceObject,
916: IN PIRP Irp
917: )
918:
919: /*++
920: Routine Description:
921:
922: This routine returns the current position of the tape.
923:
924: Arguments:
925:
926: DeviceObject
927: Irp
928:
929: Return Value:
930:
931: NTSTATUS
932:
933: --*/
934:
935: {
936: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
937: PTAPE_GET_POSITION tapeGetPosition = Irp->AssociatedIrp.SystemBuffer;
938: PTAPE_DATA tapeData = (PTAPE_DATA)(deviceExtension + 1);
939: PMODE_TAPE_MEDIA_INFORMATION mediaInfoBuffer;
940: PMODE_DEVICE_CONFIG_PAGE deviceConfigBuffer;
941: PTAPE_POSITION_DATA absoluteBuffer;
942: UCHAR densityCode;
943: ULONG tapeBlockLength;
944: ULONG tapeBlockAddress;
945: ULONG type;
946: SCSI_REQUEST_BLOCK srb;
947: PCDB cdb = (PCDB)srb.Cdb;
948: NTSTATUS status;
949:
950: DebugPrint((3,"TapeGetPosition: Enter routine\n"));
951:
952: type = tapeGetPosition->Type;
953: RtlZeroMemory(tapeGetPosition, sizeof(TAPE_GET_POSITION));
954: Irp->IoStatus.Information = sizeof(TAPE_GET_POSITION);
955: tapeGetPosition->Type = type;
956:
957: //
958: // Zero CDB in SRB on stack.
959: //
960:
961: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
962:
963: //
964: // Prepare SCSI command (CDB)
965: //
966:
967: srb.CdbLength = CDB6GENERIC_LENGTH;
968:
969: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
970:
971: //
972: // Set timeout value.
973: //
974:
975: srb.TimeOutValue = deviceExtension->TimeOutValue;
976:
977: //
978: // Send SCSI command (CDB) to device
979: //
980:
981: DebugPrint((3,"TapeGetPosition: SendSrb (test unit ready)\n"));
982:
983: status = ScsiClassSendSrbSynchronous(DeviceObject,
984: &srb,
985: NULL,
986: 0,
987: FALSE);
988:
989: if (!NT_SUCCESS(status)) {
990: DebugPrint((1,"TapeGetPosition: test unit ready, SendSrb unsuccessful\n"));
991: return status;
992: }
993:
994: if (type == TAPE_LOGICAL_POSITION) {
995:
996: DebugPrint((3,"TapeGetPosition: pseudo logical\n"));
997:
998: type = TAPE_PSEUDO_LOGICAL_POSITION;
999:
1000: mediaInfoBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1001: sizeof(MODE_TAPE_MEDIA_INFORMATION));
1002:
1003: if (!mediaInfoBuffer) {
1004: DebugPrint((1,"TapeGetPosition: insufficient resources (mediaInfoBuffer)\n"));
1005: return STATUS_INSUFFICIENT_RESOURCES;
1006: }
1007:
1008: RtlZeroMemory(mediaInfoBuffer, sizeof(MODE_TAPE_MEDIA_INFORMATION));
1009:
1010: //
1011: // Zero CDB in SRB on stack.
1012: //
1013:
1014: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1015:
1016: //
1017: // Prepare SCSI command (CDB)
1018: //
1019:
1020: srb.CdbLength = CDB6GENERIC_LENGTH;
1021:
1022: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1023: cdb->MODE_SENSE.PageCode = MODE_PAGE_MEDIUM_PARTITION;
1024: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_TAPE_MEDIA_INFORMATION) - 4;
1025:
1026: //
1027: // Set timeout value.
1028: //
1029:
1030: srb.TimeOutValue = deviceExtension->TimeOutValue;
1031:
1032: //
1033: // Send SCSI command (CDB) to device
1034: //
1035:
1036: DebugPrint((3,"TapeGetPosition: SendSrb (mode sense #1)\n"));
1037:
1038: status = ScsiClassSendSrbSynchronous(DeviceObject,
1039: &srb,
1040: mediaInfoBuffer,
1041: sizeof(MODE_TAPE_MEDIA_INFORMATION) - 4,
1042: FALSE);
1043:
1044: if (!NT_SUCCESS(status)) {
1045: DebugPrint((1,"TapeGetPosition: mode sense #1, SendSrb unsuccessful\n"));
1046: ExFreePool(mediaInfoBuffer);
1047: return status;
1048: }
1049:
1050: if (mediaInfoBuffer->MediumPartPage.FDPBit) {
1051:
1052: deviceConfigBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1053: sizeof(MODE_DEVICE_CONFIG_PAGE));
1054:
1055: if (!deviceConfigBuffer) {
1056: DebugPrint((1,"TapeGetPosition: insufficient resources (deviceConfigBuffer)\n"));
1057: ExFreePool(mediaInfoBuffer);
1058: return STATUS_INSUFFICIENT_RESOURCES;
1059: }
1060:
1061: RtlZeroMemory(deviceConfigBuffer, sizeof(MODE_DEVICE_CONFIG_PAGE));
1062:
1063: //
1064: // Zero CDB in SRB on stack.
1065: //
1066:
1067: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1068:
1069: //
1070: // Prepare SCSI command (CDB)
1071: //
1072:
1073: srb.CdbLength = CDB6GENERIC_LENGTH;
1074:
1075: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1076: cdb->MODE_SENSE.Dbd = SETBITON;
1077: cdb->MODE_SENSE.PageCode = MODE_PAGE_DEVICE_CONFIG;
1078: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_DEVICE_CONFIG_PAGE);
1079:
1080: //
1081: // Set timeout value.
1082: //
1083:
1084: srb.TimeOutValue = deviceExtension->TimeOutValue;
1085:
1086: //
1087: // Send SCSI command (CDB) to device
1088: //
1089:
1090: DebugPrint((3,"TapeGetPosition: SendSrb (mode sense #2)\n"));
1091:
1092: status = ScsiClassSendSrbSynchronous(DeviceObject,
1093: &srb,
1094: deviceConfigBuffer,
1095: sizeof(MODE_DEVICE_CONFIG_PAGE),
1096: FALSE);
1097:
1098: if (!NT_SUCCESS(status)) {
1099: DebugPrint((1,"TapeGetPosition: mode sense #2, SendSrb unsuccessful\n"));
1100: ExFreePool(deviceConfigBuffer);
1101: ExFreePool(mediaInfoBuffer);
1102: return status;
1103: }
1104:
1105: tapeData->CurrentPartition =
1106: deviceConfigBuffer->DeviceConfigPage.ActivePartition?
1107: DIRECTORY_PARTITION : DATA_PARTITION;
1108:
1109: ExFreePool(deviceConfigBuffer);
1110:
1111: } else {
1112:
1113: tapeData->CurrentPartition = NO_PARTITIONS;
1114:
1115: }
1116:
1117: densityCode = mediaInfoBuffer->ParameterListBlock.DensityCode;
1118: tapeBlockLength = mediaInfoBuffer->ParameterListBlock.BlockLength[2];
1119: tapeBlockLength += (mediaInfoBuffer->ParameterListBlock.BlockLength[1] << 8);
1120: tapeBlockLength += (mediaInfoBuffer->ParameterListBlock.BlockLength[0] << 16);
1121:
1122: ExFreePool(mediaInfoBuffer);
1123:
1124: }
1125:
1126: switch (type) {
1127: case TAPE_PSEUDO_LOGICAL_POSITION:
1128: case TAPE_ABSOLUTE_POSITION:
1129: absoluteBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1130: sizeof(TAPE_POSITION_DATA));
1131:
1132: if (!absoluteBuffer) {
1133: DebugPrint((1,"TapeGetPosition: insufficient resources (absoluteBuffer)\n"));
1134: return STATUS_INSUFFICIENT_RESOURCES;
1135: }
1136:
1137: RtlZeroMemory(absoluteBuffer, sizeof(TAPE_POSITION_DATA));
1138:
1139: //
1140: // Zero CDB in SRB on stack.
1141: //
1142:
1143: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1144:
1145: //
1146: // Prepare SCSI command (CDB)
1147: //
1148:
1149: srb.CdbLength = CDB10GENERIC_LENGTH;
1150:
1151: cdb->READ_POSITION.Operation = SCSIOP_READ_POSITION;
1152: cdb->READ_POSITION.BlockType = SETBITON;
1153:
1154: //
1155: // Set timeout value.
1156: //
1157:
1158: srb.TimeOutValue = deviceExtension->TimeOutValue;
1159:
1160: //
1161: // Send SCSI command (CDB) to device
1162: //
1163:
1164: DebugPrint((3,"TapeGetPosition: SendSrb (read position)\n"));
1165:
1166: status = ScsiClassSendSrbSynchronous(DeviceObject,
1167: &srb,
1168: absoluteBuffer,
1169: sizeof(TAPE_POSITION_DATA),
1170: FALSE);
1171:
1172: if (NT_SUCCESS(status)) {
1173:
1174: REVERSE_BYTES((PFOUR_BYTE)&tapeBlockAddress,
1175: (PFOUR_BYTE)absoluteBuffer->FirstBlock);
1176: }
1177:
1178: ExFreePool(absoluteBuffer);
1179:
1180: if (!NT_SUCCESS(status)) {
1181: DebugPrint((1,"TapeGetPosition: read position, SendSrb unsuccessful\n"));
1182: return status;
1183: }
1184:
1185: if (type == TAPE_ABSOLUTE_POSITION) {
1186: tapeGetPosition->Partition = 0;
1187: tapeGetPosition->Offset.HighPart = 0;
1188: tapeGetPosition->Offset.LowPart = tapeBlockAddress;
1189: break;
1190: }
1191:
1192: tapeBlockAddress =
1193: TapePhysicalBlockToLogicalBlock(
1194: densityCode,
1195: tapeBlockAddress,
1196: tapeBlockLength,
1197: (BOOLEAN)(
1198: (tapeData->CurrentPartition
1199: == DIRECTORY_PARTITION)?
1200: NOT_FROM_BOT : FROM_BOT
1201: )
1202: );
1203:
1204: tapeGetPosition->Offset.HighPart = 0;
1205: tapeGetPosition->Offset.LowPart = tapeBlockAddress;
1206: tapeGetPosition->Partition = tapeData->CurrentPartition;
1207: break;
1208:
1209: default:
1210: DebugPrint((1,"TapeGetPosition: PositionType -- operation not supported\n"));
1211: return STATUS_NOT_IMPLEMENTED;
1212: }
1213:
1214: return status;
1215:
1216: } // end TapeGetPosition()
1217:
1218:
1219: NTSTATUS
1220: TapeGetStatus(
1221: IN PDEVICE_OBJECT DeviceObject,
1222: IN PIRP Irp
1223: )
1224:
1225: /*++
1226: Routine Description:
1227:
1228: This routine returns the status of the device.
1229:
1230: Arguments:
1231:
1232: DeviceObject
1233: Irp
1234:
1235: Return Value:
1236:
1237: NTSTATUS
1238:
1239: --*/
1240:
1241: {
1242: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1243: SCSI_REQUEST_BLOCK srb;
1244: PCDB cdb = (PCDB)srb.Cdb;
1245: NTSTATUS status;
1246:
1247: DebugPrint((3,"TapeGetStatus: Enter routine\n"));
1248:
1249: //
1250: // Zero CDB in SRB on stack.
1251: //
1252:
1253: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1254:
1255: //
1256: // Prepare SCSI command (CDB)
1257: //
1258:
1259: srb.CdbLength = CDB6GENERIC_LENGTH;
1260:
1261: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
1262:
1263: //
1264: // Set timeout value.
1265: //
1266:
1267: srb.TimeOutValue = deviceExtension->TimeOutValue;
1268:
1269: //
1270: // Send SCSI command (CDB) to device
1271: //
1272:
1273: DebugPrint((3,"TapeGetStatus: SendSrb (test unit ready)\n"));
1274:
1275: status = ScsiClassSendSrbSynchronous(DeviceObject,
1276: &srb,
1277: NULL,
1278: 0,
1279: FALSE);
1280:
1281: if (!NT_SUCCESS(status)) {
1282: DebugPrint((1,"TapeGetStatus: test unit ready, SendSrb unsuccessful\n"));
1283: }
1284:
1285: return status;
1286:
1287: } // end TapeGetStatus()
1288:
1289:
1290: NTSTATUS
1291: TapePrepare(
1292: IN PDEVICE_OBJECT DeviceObject,
1293: IN PIRP Irp
1294: )
1295:
1296: /*++
1297: Routine Description:
1298:
1299: This routine loads, unloads, tensions, locks, or unlocks the tape.
1300:
1301: Arguments:
1302:
1303: DeviceObject
1304: Irp
1305:
1306: Return Value:
1307:
1308: NTSTATUS
1309:
1310: --*/
1311:
1312: {
1313: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1314: PTAPE_PREPARE tapePrepare = Irp->AssociatedIrp.SystemBuffer;
1315: SCSI_REQUEST_BLOCK srb;
1316: PCDB cdb = (PCDB)srb.Cdb;
1317: NTSTATUS status;
1318:
1319: DebugPrint((3,"TapePrepare: Enter routine\n"));
1320:
1321: if (tapePrepare->Immediate) {
1322: switch (tapePrepare->Operation) {
1323: case TAPE_LOAD:
1324: case TAPE_UNLOAD:
1325: case TAPE_TENSION:
1326: DebugPrint((3,"TapePrepare: immediate\n"));
1327: break;
1328:
1329: case TAPE_LOCK:
1330: case TAPE_UNLOCK:
1331: default:
1332: DebugPrint((1,"TapePrepare: Operation, immediate -- operation not supported\n"));
1333: return STATUS_NOT_IMPLEMENTED;
1334: }
1335: }
1336:
1337: //
1338: // Zero CDB in SRB on stack.
1339: //
1340:
1341: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1342:
1343: //
1344: // Prepare SCSI command (CDB)
1345: //
1346:
1347: srb.CdbLength = CDB6GENERIC_LENGTH;
1348:
1349: cdb->CDB6GENERIC.Immediate = tapePrepare->Immediate;
1350:
1351: switch (tapePrepare->Operation) {
1352: case TAPE_LOAD:
1353: DebugPrint((3,"TapePrepare: Operation == load\n"));
1354: cdb->CDB6GENERIC.OperationCode = SCSIOP_LOAD_UNLOAD;
1355: cdb->CDB6GENERIC.CommandUniqueBytes[2] = 0x01;
1356: srb.TimeOutValue = 180;
1357: break;
1358:
1359: case TAPE_UNLOAD:
1360: DebugPrint((3,"TapePrepare: Operation == unload\n"));
1361: cdb->CDB6GENERIC.OperationCode = SCSIOP_LOAD_UNLOAD;
1362: srb.TimeOutValue = 180;
1363: break;
1364:
1365: case TAPE_TENSION:
1366: DebugPrint((3,"TapePrepare: Operation == tension\n"));
1367: cdb->CDB6GENERIC.OperationCode = SCSIOP_LOAD_UNLOAD;
1368: cdb->CDB6GENERIC.CommandUniqueBytes[2] = 0x03;
1369: srb.TimeOutValue = 360;
1370: break;
1371:
1372: case TAPE_LOCK:
1373: DebugPrint((3,"TapePrepare: Operation == lock\n"));
1374: cdb->CDB6GENERIC.OperationCode = SCSIOP_MEDIUM_REMOVAL;
1375: cdb->CDB6GENERIC.CommandUniqueBytes[2] = 0x01;
1376: srb.TimeOutValue = 180;
1377: break;
1378:
1379: case TAPE_UNLOCK:
1380: DebugPrint((3,"TapePrepare: Operation == unlock\n"));
1381: cdb->CDB6GENERIC.OperationCode = SCSIOP_MEDIUM_REMOVAL;
1382: srb.TimeOutValue = 180;
1383: break;
1384:
1385: default:
1386: DebugPrint((1,"TapePrepare: Operation -- operation not supported\n"));
1387: return STATUS_NOT_IMPLEMENTED;
1388: }
1389:
1390: //
1391: // Send SCSI command (CDB) to device
1392: //
1393:
1394: DebugPrint((3,"TapePrepare: SendSrb (Operation)\n"));
1395:
1396: status = ScsiClassSendSrbSynchronous(DeviceObject,
1397: &srb,
1398: NULL,
1399: 0,
1400: FALSE);
1401:
1402: if (!NT_SUCCESS(status)) {
1403: DebugPrint((1,"TapePrepare: Operation, SendSrb unsuccessful\n"));
1404: }
1405:
1406: return status;
1407:
1408: } // end TapePrepare()
1409:
1410:
1411: NTSTATUS
1412: TapeReadWrite(
1413: IN PDEVICE_OBJECT DeviceObject,
1414: IN PIRP Irp
1415: )
1416:
1417: /*++
1418:
1419: Routine Description:
1420:
1421: This routine builds SRBs and CDBs for read and write requests to
1422: Tandberg QIC drives.
1423:
1424: Arguments:
1425:
1426: DeviceObject
1427: Irp
1428:
1429: Return Value:
1430:
1431: Returns STATUS_PENDING.
1432:
1433: --*/
1434:
1435: {
1436: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1437: PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
1438: PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
1439: PSCSI_REQUEST_BLOCK srb;
1440: PCDB cdb;
1441: KIRQL currentIrql;
1442: ULONG transferBlocks;
1443: LARGE_INTEGER startingOffset =
1444: currentIrpStack->Parameters.Read.ByteOffset;
1445:
1446: DebugPrint((3,"TapeReadWrite: Enter routine\n"));
1447:
1448: //
1449: // Allocate an Srb.
1450: //
1451:
1452: if (deviceExtension->SrbZone != NULL &&
1453: (srb = ExInterlockedAllocateFromZone(
1454: deviceExtension->SrbZone,
1455: deviceExtension->SrbZoneSpinLock)) != NULL) {
1456:
1457: srb->SrbFlags = SRB_FLAGS_ALLOCATED_FROM_ZONE;
1458:
1459: } else {
1460:
1461: //
1462: // Allocate Srb from non-paged pool.
1463: // This call must succeed.
1464: //
1465:
1466: srb = ExAllocatePool(NonPagedPoolMustSucceed, SCSI_REQUEST_BLOCK_SIZE);
1467:
1468: srb->SrbFlags = 0;
1469:
1470: }
1471:
1472: //
1473: // Write length to SRB.
1474: //
1475:
1476: srb->Length = SCSI_REQUEST_BLOCK_SIZE;
1477:
1478: //
1479: // Set up IRP Address.
1480: //
1481:
1482: srb->OriginalRequest = Irp;
1483:
1484: //
1485: // Set up target id and logical unit number.
1486: //
1487:
1488: srb->PathId = deviceExtension->PathId;
1489: srb->TargetId = deviceExtension->TargetId;
1490: srb->Lun = deviceExtension->Lun;
1491:
1492:
1493: srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
1494:
1495: srb->DataBuffer = MmGetMdlVirtualAddress(Irp->MdlAddress);
1496:
1497: //
1498: // Save byte count of transfer in SRB Extension.
1499: //
1500:
1501: srb->DataTransferLength = currentIrpStack->Parameters.Read.Length;
1502:
1503: //
1504: // Indicate auto request sense by specifying buffer and size.
1505: //
1506:
1507: srb->SenseInfoBuffer = deviceExtension->SenseData;
1508:
1509: srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
1510:
1511: //
1512: // Initialize the queue actions field.
1513: //
1514:
1515: srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
1516:
1517: //
1518: // Indicate auto request sense by specifying buffer and size.
1519: //
1520:
1521: srb->SenseInfoBuffer = deviceExtension->SenseData;
1522:
1523: srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
1524:
1525: //
1526: // Set timeout value in seconds.
1527: //
1528:
1529: srb->TimeOutValue = deviceExtension->TimeOutValue;
1530:
1531: //
1532: // Zero statuses.
1533: //
1534:
1535: srb->SrbStatus = srb->ScsiStatus = 0;
1536:
1537: srb->NextSrb = 0;
1538:
1539: //
1540: // Indicate that 6-byte CDB's will be used.
1541: //
1542:
1543: srb->CdbLength = CDB6GENERIC_LENGTH;
1544:
1545: //
1546: // Fill in CDB fields.
1547: //
1548:
1549: cdb = (PCDB)srb->Cdb;
1550:
1551: //
1552: // Zero CDB in SRB.
1553: //
1554:
1555: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1556:
1557: //
1558: // Since we are writing fixed block mode, normalize transfer count
1559: // to number of blocks.
1560: //
1561:
1562: transferBlocks =
1563: currentIrpStack->Parameters.Read.Length >> deviceExtension->SectorShift;
1564:
1565: //
1566: // Set up transfer length
1567: //
1568:
1569: cdb->CDB6READWRITETAPE.TransferLenMSB = (UCHAR)((transferBlocks >> 16) & 0xff);
1570: cdb->CDB6READWRITETAPE.TransferLen = (UCHAR)((transferBlocks >> 8) & 0xff);
1571: cdb->CDB6READWRITETAPE.TransferLenLSB = (UCHAR)(transferBlocks & 0xff);
1572:
1573: //
1574: // Tell the python we are in fixed block mode
1575: //
1576:
1577: cdb->CDB6READWRITETAPE.VendorSpecific = 1;
1578:
1579: //
1580: // Set transfer direction flag and Cdb command.
1581: //
1582:
1583: if (currentIrpStack->MajorFunction == IRP_MJ_READ) {
1584:
1585: DebugPrint((3, "TapeRequest: Read Command\n"));
1586:
1587: srb->SrbFlags = SRB_FLAGS_DATA_IN;
1588: cdb->CDB6READWRITETAPE.OperationCode = SCSIOP_READ6;
1589:
1590: } else {
1591:
1592: DebugPrint((3, "TapeRequest: Write Command\n"));
1593:
1594: srb->SrbFlags = SRB_FLAGS_DATA_OUT;
1595: cdb->CDB6READWRITETAPE.OperationCode = SCSIOP_WRITE6;
1596: }
1597:
1598: //
1599: // Or in the default flags from the device object.
1600: //
1601:
1602: srb->SrbFlags |= deviceExtension->SrbFlags;
1603:
1604: //
1605: // Set up major SCSI function.
1606: //
1607:
1608: nextIrpStack->MajorFunction = IRP_MJ_SCSI;
1609:
1610: //
1611: // Save SRB address in next stack for port driver.
1612: //
1613:
1614: nextIrpStack->Parameters.Scsi.Srb = srb;
1615:
1616: //
1617: // Save retry count in current IRP stack.
1618: //
1619:
1620: currentIrpStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;
1621:
1622: //
1623: // Set up IoCompletion routine address.
1624: //
1625:
1626: IoSetCompletionRoutine(Irp,
1627: ScsiClassIoComplete,
1628: srb,
1629: TRUE,
1630: TRUE,
1631: FALSE);
1632:
1633: return STATUS_PENDING;
1634:
1635: } // end TapeReadWrite()
1636:
1637:
1638: NTSTATUS
1639: TapeSetDriveParameters(
1640: IN PDEVICE_OBJECT DeviceObject,
1641: IN PIRP Irp
1642: )
1643:
1644: /*++
1645: Routine Description:
1646:
1647: This routine would "set" the "drive parameters" of the Tandberg QIC
1648: tape drive associated with "DeviceObject" if any could be set, but
1649: none can! Hence, this routine always returns a STATUS_NOT_IMPLEMENTED
1650: status.
1651:
1652: Arguments:
1653:
1654: DeviceObject
1655: Irp
1656:
1657: Return Value:
1658:
1659: NTSTATUS
1660:
1661: --*/
1662:
1663: {
1664: DebugPrint((3,"TapeSetDriveParameters: Enter routine\n"));
1665:
1666: DebugPrint((1,"TapeSetDriveParameters: Operation -- operation not supported\n"));
1667:
1668: return STATUS_NOT_IMPLEMENTED;
1669:
1670: } // end TapeSetDriveParameters()
1671:
1672:
1673:
1674: NTSTATUS
1675: TapeSetMediaParameters(
1676: IN PDEVICE_OBJECT DeviceObject,
1677: IN PIRP Irp
1678: )
1679:
1680: /*++
1681: Routine Description:
1682:
1683: This routine "sets" the "media parameters" of the Tandberg QIC tape
1684: drive associated with "DeviceObject". Tape media must be present
1685: (loaded) in the drive for this function to return "no error".
1686:
1687: Arguments:
1688:
1689: DeviceObject
1690: Irp
1691:
1692: Return Value:
1693:
1694: NTSTATUS
1695:
1696: --*/
1697:
1698: {
1699: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1700: PTAPE_SET_MEDIA_PARAMETERS tapeSetMediaParams = Irp->AssociatedIrp.SystemBuffer;
1701: PMODE_PARM_READ_WRITE_DATA modeBuffer;
1702: PINQUIRYDATA inquiryBuffer;
1703: ULONG whichdrive;
1704: SCSI_REQUEST_BLOCK srb;
1705: PCDB cdb = (PCDB)srb.Cdb;
1706: NTSTATUS status;
1707:
1708: DebugPrint((3,"TapeSetMediaParameters: Enter routine\n"));
1709:
1710: inquiryBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1711: sizeof(INQUIRYDATA));
1712:
1713: if (!inquiryBuffer) {
1714: DebugPrint((1,"TapeSetMediaParameters: insufficient resources (inquiryBuffer)\n"));
1715: return STATUS_INSUFFICIENT_RESOURCES;
1716: }
1717:
1718: RtlZeroMemory(inquiryBuffer, sizeof(INQUIRYDATA));
1719:
1720: //
1721: // Send SCSI command (CDB) to device
1722: //
1723:
1724: DebugPrint((3,"TapeSetMediaParameters: SendSrb (inquiry)\n"));
1725:
1726: status = GetInquiryInformationData(DeviceObject, Irp, inquiryBuffer);
1727:
1728: if (NT_SUCCESS(status)) {
1729:
1730: //
1731: // Which drive do we have, TDC 3660, 3820, 4120 or 4220?
1732: //
1733:
1734: whichdrive = WhichIsIt(inquiryBuffer);
1735: }
1736:
1737: ExFreePool(inquiryBuffer);
1738:
1739: if (!NT_SUCCESS(status)) {
1740: DebugPrint((1,"TapeSetMediaParameters: inquiry, SendSrb unsuccessful\n"));
1741: return status;
1742: }
1743:
1744: if (whichdrive == TDC_3600) {
1745: DebugPrint((1,"TapeSetMediaParameters: whichdrive -- operation not supported\n"));
1746: return STATUS_NOT_IMPLEMENTED;
1747: }
1748:
1749: //
1750: // Zero CDB in SRB on stack.
1751: //
1752:
1753: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1754:
1755: //
1756: // Prepare SCSI command (CDB)
1757: //
1758:
1759: srb.CdbLength = CDB6GENERIC_LENGTH;
1760:
1761: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
1762:
1763: //
1764: // Set timeout value.
1765: //
1766:
1767: srb.TimeOutValue = deviceExtension->TimeOutValue;
1768:
1769: //
1770: // Send SCSI command (CDB) to device
1771: //
1772:
1773: DebugPrint((3,"TapeSetMediaParameters: SendSrb (test unit ready)\n"));
1774:
1775: status = ScsiClassSendSrbSynchronous(DeviceObject,
1776: &srb,
1777: NULL,
1778: 0,
1779: FALSE);
1780:
1781: if (!NT_SUCCESS(status)) {
1782: DebugPrint((1,"TapeSetMediaParameters: test unit ready, SendSrb unsuccessful\n"));
1783: return status;
1784: }
1785:
1786: modeBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1787: sizeof(MODE_PARM_READ_WRITE_DATA));
1788:
1789: if (!modeBuffer) {
1790: DebugPrint((1,"TapeSetMediaParameters: insufficient resources (modeBuffer)\n"));
1791: return STATUS_INSUFFICIENT_RESOURCES;
1792: }
1793:
1794: RtlZeroMemory(modeBuffer, sizeof(MODE_PARM_READ_WRITE_DATA));
1795:
1796: modeBuffer->ParameterListHeader.DeviceSpecificParameter = 0x10;
1797: modeBuffer->ParameterListHeader.BlockDescriptorLength = MODE_BLOCK_DESC_LENGTH;
1798:
1799: modeBuffer->ParameterListBlock.DensityCode = 0x7F;
1800: modeBuffer->ParameterListBlock.BlockLength[0] =
1801: ((tapeSetMediaParams->BlockSize >> 16) & 0xFF);
1802: modeBuffer->ParameterListBlock.BlockLength[1] =
1803: ((tapeSetMediaParams->BlockSize >> 8) & 0xFF);
1804: modeBuffer->ParameterListBlock.BlockLength[2] =
1805: (tapeSetMediaParams->BlockSize & 0xFF);
1806:
1807: //
1808: // Zero CDB in SRB on stack.
1809: //
1810:
1811: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1812:
1813: //
1814: // Prepare SCSI command (CDB)
1815: //
1816:
1817: srb.CdbLength = CDB6GENERIC_LENGTH;
1818:
1819: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
1820: cdb->MODE_SELECT.ParameterListLength = sizeof(MODE_PARM_READ_WRITE_DATA);
1821:
1822: //
1823: // Set timeout value.
1824: //
1825:
1826: srb.TimeOutValue = deviceExtension->TimeOutValue;
1827:
1828: //
1829: // Send SCSI command (CDB) to device
1830: //
1831:
1832: DebugPrint((3,"TapeSetMediaParameters: SendSrb (mode select)\n"));
1833:
1834: status = ScsiClassSendSrbSynchronous(DeviceObject,
1835: &srb,
1836: modeBuffer,
1837: sizeof(MODE_PARM_READ_WRITE_DATA),
1838: TRUE);
1839:
1840: ExFreePool(modeBuffer);
1841:
1842: if (!NT_SUCCESS(status)) {
1843: DebugPrint((1,"TapeSetMediaParameters: mode select, SendSrb unsuccessful\n"));
1844: }
1845:
1846: return status;
1847:
1848: } // end TapeSetMediaParameters()
1849:
1850:
1851: NTSTATUS
1852: TapeSetPosition(
1853: IN PDEVICE_OBJECT DeviceObject,
1854: IN PIRP Irp
1855: )
1856:
1857: /*++
1858: Routine Description:
1859:
1860: This routine sets the position of the tape.
1861:
1862: Arguments:
1863:
1864: DeviceObject
1865: Irp
1866:
1867: Return Value:
1868:
1869: NTSTATUS
1870:
1871: --*/
1872:
1873: {
1874: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1875: PTAPE_SET_POSITION tapeSetPosition = Irp->AssociatedIrp.SystemBuffer;
1876: PTAPE_DATA tapeData = (PTAPE_DATA)(deviceExtension + 1);
1877: BOOLEAN changePartition = FALSE;
1878: PMODE_TAPE_MEDIA_INFORMATION mediaInfoBuffer;
1879: PMODE_DEVICE_CONFIG_PAGE deviceConfigBuffer;
1880: TAPE_PHYS_POSITION physPosition;
1881: UCHAR densityCode;
1882: ULONG tapePositionVector;
1883: ULONG tapeBlockLength;
1884: ULONG method;
1885: SCSI_REQUEST_BLOCK srb;
1886: PCDB cdb = (PCDB)srb.Cdb;
1887: NTSTATUS status;
1888:
1889: DebugPrint((3,"TapeSetPosition: Enter routine\n"));
1890:
1891: if (tapeSetPosition->Immediate) {
1892: switch (tapeSetPosition->Method) {
1893: case TAPE_REWIND:
1894: DebugPrint((3,"TapeSetPosition: immediate\n"));
1895: break;
1896:
1897: case TAPE_LOGICAL_BLOCK:
1898: case TAPE_ABSOLUTE_BLOCK:
1899: case TAPE_SPACE_END_OF_DATA:
1900: case TAPE_SPACE_RELATIVE_BLOCKS:
1901: case TAPE_SPACE_FILEMARKS:
1902: case TAPE_SPACE_SEQUENTIAL_FMKS:
1903: case TAPE_SPACE_SETMARKS:
1904: case TAPE_SPACE_SEQUENTIAL_SMKS:
1905: default:
1906: DebugPrint((1,"TapeSetPosition: PositionMethod, immediate -- operation not supported\n"));
1907: return STATUS_NOT_IMPLEMENTED;
1908: }
1909: }
1910:
1911: method = tapeSetPosition->Method;
1912: tapePositionVector = tapeSetPosition->Offset.LowPart;
1913:
1914: if (method == TAPE_LOGICAL_BLOCK) {
1915:
1916: DebugPrint((3,"TapeSetPosition: pseudo logical\n"));
1917:
1918: method = TAPE_PSEUDO_LOGICAL_BLOCK;
1919:
1920: mediaInfoBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1921: sizeof(MODE_TAPE_MEDIA_INFORMATION));
1922:
1923: if (!mediaInfoBuffer) {
1924: DebugPrint((1,"TapeSetPosition: insufficient resources (mediaInfoBuffer)\n"));
1925: return STATUS_INSUFFICIENT_RESOURCES;
1926: }
1927:
1928: RtlZeroMemory(mediaInfoBuffer, sizeof(MODE_TAPE_MEDIA_INFORMATION));
1929:
1930: //
1931: // Zero CDB in SRB on stack.
1932: //
1933:
1934: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1935:
1936: //
1937: // Prepare SCSI command (CDB)
1938: //
1939:
1940: srb.CdbLength = CDB6GENERIC_LENGTH;
1941:
1942: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1943: cdb->MODE_SENSE.PageCode = MODE_PAGE_MEDIUM_PARTITION;
1944: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_TAPE_MEDIA_INFORMATION) - 4;
1945:
1946: //
1947: // Set timeout value.
1948: //
1949:
1950: srb.TimeOutValue = deviceExtension->TimeOutValue;
1951:
1952: //
1953: // Send SCSI command (CDB) to device
1954: //
1955:
1956: DebugPrint((3,"TapeSetPosition: SendSrb (mode sense #1)\n"));
1957:
1958: status = ScsiClassSendSrbSynchronous(DeviceObject,
1959: &srb,
1960: mediaInfoBuffer,
1961: sizeof(MODE_TAPE_MEDIA_INFORMATION) - 4,
1962: FALSE);
1963:
1964: if (!NT_SUCCESS(status)) {
1965: DebugPrint((1,"TapeSetPosition: mode sense #1, SendSrb unsuccessful\n"));
1966: ExFreePool(mediaInfoBuffer);
1967: return status;
1968: }
1969:
1970: if (mediaInfoBuffer->MediumPartPage.FDPBit) {
1971:
1972: deviceConfigBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1973: sizeof(MODE_DEVICE_CONFIG_PAGE));
1974:
1975: if (!deviceConfigBuffer) {
1976: DebugPrint((1,"TapeSetPosition: insufficient resources (deviceConfigBuffer)\n"));
1977: ExFreePool(mediaInfoBuffer);
1978: return STATUS_INSUFFICIENT_RESOURCES;
1979: }
1980:
1981: RtlZeroMemory(deviceConfigBuffer, sizeof(MODE_DEVICE_CONFIG_PAGE));
1982:
1983: //
1984: // Zero CDB in SRB on stack.
1985: //
1986:
1987: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1988:
1989: //
1990: // Prepare SCSI command (CDB)
1991: //
1992:
1993: srb.CdbLength = CDB6GENERIC_LENGTH;
1994:
1995: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1996: cdb->MODE_SENSE.Dbd = SETBITON;
1997: cdb->MODE_SENSE.PageCode = MODE_PAGE_DEVICE_CONFIG;
1998: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_DEVICE_CONFIG_PAGE);
1999:
2000: //
2001: // Set timeout value.
2002: //
2003:
2004: srb.TimeOutValue = deviceExtension->TimeOutValue;
2005:
2006: //
2007: // Send SCSI command (CDB) to device
2008: //
2009:
2010: DebugPrint((3,"TapeSetPosition: SendSrb (mode sense #2)\n"));
2011:
2012: status = ScsiClassSendSrbSynchronous(DeviceObject,
2013: &srb,
2014: deviceConfigBuffer,
2015: sizeof(MODE_DEVICE_CONFIG_PAGE),
2016: FALSE);
2017:
2018: if (!NT_SUCCESS(status)) {
2019: DebugPrint((1,"TapeSetPosition: mode sense #2, SendSrb unsuccessful\n"));
2020: ExFreePool(deviceConfigBuffer);
2021: ExFreePool(mediaInfoBuffer);
2022: return status;
2023: }
2024:
2025: tapeData->CurrentPartition =
2026: deviceConfigBuffer->DeviceConfigPage.ActivePartition?
2027: DIRECTORY_PARTITION : DATA_PARTITION;
2028:
2029: ExFreePool(deviceConfigBuffer);
2030:
2031: } else {
2032:
2033: tapeData->CurrentPartition = NO_PARTITIONS;
2034:
2035: }
2036:
2037: densityCode = mediaInfoBuffer->ParameterListBlock.DensityCode;
2038: tapeBlockLength = mediaInfoBuffer->ParameterListBlock.BlockLength[2];
2039: tapeBlockLength += (mediaInfoBuffer->ParameterListBlock.BlockLength[1] << 8);
2040: tapeBlockLength += (mediaInfoBuffer->ParameterListBlock.BlockLength[0] << 16);
2041:
2042: ExFreePool(mediaInfoBuffer);
2043:
2044: switch (tapeSetPosition->Partition) {
2045: case 0:
2046: break;
2047:
2048: case DIRECTORY_PARTITION:
2049: case DATA_PARTITION:
2050: if (tapeData->CurrentPartition != NO_PARTITIONS) {
2051: if (tapeSetPosition->Partition
2052: != tapeData->CurrentPartition) {
2053: changePartition = TRUE;
2054: }
2055: break;
2056: }
2057: // else: fall through to next case
2058:
2059: default:
2060: DebugPrint((1,"TapeSetPosition: Partition -- invalid parameter\n"));
2061: return STATUS_INVALID_PARAMETER;
2062: }
2063:
2064: physPosition =
2065: TapeLogicalBlockToPhysicalBlock(
2066: densityCode,
2067: tapePositionVector,
2068: tapeBlockLength,
2069: (BOOLEAN)(
2070: (tapeData->CurrentPartition
2071: == DIRECTORY_PARTITION)?
2072: NOT_FROM_BOT : FROM_BOT
2073: )
2074: );
2075:
2076: tapePositionVector = physPosition.SeekBlockAddress;
2077:
2078: }
2079:
2080: //
2081: // Zero CDB in SRB on stack.
2082: //
2083:
2084: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
2085:
2086: //
2087: // Prepare SCSI command (CDB)
2088: //
2089:
2090: srb.CdbLength = CDB6GENERIC_LENGTH;
2091:
2092: cdb->CDB6GENERIC.Immediate = tapeSetPosition->Immediate;
2093:
2094: switch (method) {
2095: case TAPE_REWIND:
2096: DebugPrint((3,"TapeSetPosition: method == rewind\n"));
2097: cdb->CDB6GENERIC.OperationCode = SCSIOP_REWIND;
2098: srb.TimeOutValue = 180;
2099: break;
2100:
2101: case TAPE_PSEUDO_LOGICAL_BLOCK:
2102: case TAPE_ABSOLUTE_BLOCK:
2103: DebugPrint((3,"TapeSetPosition: method == locate (absolute)\n"));
2104: srb.CdbLength = CDB10GENERIC_LENGTH;
2105: cdb->LOCATE.OperationCode = SCSIOP_LOCATE;
2106: cdb->LOCATE.CPBit = changePartition? SETBITON : SETBITOFF;
2107: cdb->LOCATE.BTBit = SETBITON;
2108: cdb->LOCATE.LogicalBlockAddress[1] =
2109: ((tapePositionVector >> 16) & 0xFF);
2110: cdb->LOCATE.LogicalBlockAddress[2] =
2111: ((tapePositionVector >> 8) & 0xFF);
2112: cdb->LOCATE.LogicalBlockAddress[3] =
2113: (tapePositionVector & 0xFF);
2114: if (changePartition &&
2115: (tapeSetPosition->Partition == DIRECTORY_PARTITION)) {
2116: cdb->LOCATE.Partition = 1;
2117: }
2118: srb.TimeOutValue = 480;
2119: if ((physPosition.SpaceBlockCount != 0) &&
2120: (method == TAPE_PSEUDO_LOGICAL_BLOCK)) {
2121:
2122: //
2123: // Send SCSI command (CDB) to device
2124: //
2125:
2126: DebugPrint((3,"TapeSetPosition: SendSrb (locate)\n"));
2127:
2128: status = ScsiClassSendSrbSynchronous(DeviceObject,
2129: &srb,
2130: NULL,
2131: 0,
2132: FALSE);
2133:
2134: if (!NT_SUCCESS(status)) {
2135: DebugPrint((1,"TapeSetPosition: locate, SendSrb unsuccessful\n"));
2136: return status;
2137: }
2138:
2139: //
2140: // Zero CDB in SRB on stack.
2141: //
2142:
2143: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
2144:
2145: //
2146: // Prepare SCSI command (CDB)
2147: //
2148:
2149: srb.CdbLength = CDB6GENERIC_LENGTH;
2150:
2151: DebugPrint((3,"TapeSetPosition: method == space block(s)\n"));
2152: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
2153: cdb->SPACE_TAPE_MARKS.Code = 0;
2154: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
2155: ((physPosition.SpaceBlockCount >> 16) & 0xFF);
2156: cdb->SPACE_TAPE_MARKS.NumMarks =
2157: ((physPosition.SpaceBlockCount >> 8) & 0xFF);
2158: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
2159: (physPosition.SpaceBlockCount & 0xFF);
2160: srb.TimeOutValue = deviceExtension->TimeOutValue;
2161:
2162: }
2163: break;
2164:
2165: case TAPE_SPACE_END_OF_DATA:
2166: DebugPrint((3,"TapeSetPosition: method == space to end-of-data\n"));
2167: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
2168: cdb->SPACE_TAPE_MARKS.Code = 3;
2169: srb.TimeOutValue = 480;
2170: break;
2171:
2172: case TAPE_SPACE_RELATIVE_BLOCKS:
2173: DebugPrint((3,"TapeSetPosition: method == space blocks\n"));
2174: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
2175: cdb->SPACE_TAPE_MARKS.Code = 0;
2176: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
2177: ((tapePositionVector >> 16) & 0xFF);
2178: cdb->SPACE_TAPE_MARKS.NumMarks =
2179: ((tapePositionVector >> 8) & 0xFF);
2180: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
2181: (tapePositionVector & 0xFF);
2182: srb.TimeOutValue = 4100;
2183: break;
2184:
2185: case TAPE_SPACE_FILEMARKS:
2186: DebugPrint((3,"TapeSetPosition: method == space filemarks\n"));
2187: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
2188: cdb->SPACE_TAPE_MARKS.Code = 1;
2189: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
2190: ((tapePositionVector >> 16) & 0xFF);
2191: cdb->SPACE_TAPE_MARKS.NumMarks =
2192: ((tapePositionVector >> 8) & 0xFF);
2193: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
2194: (tapePositionVector & 0xFF);
2195: srb.TimeOutValue = 4100;
2196: break;
2197:
2198: case TAPE_SPACE_SEQUENTIAL_FMKS:
2199: DebugPrint((3,"TapeSetPosition: method == space sequential filemarks\n"));
2200: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
2201: cdb->SPACE_TAPE_MARKS.Code = 2;
2202: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
2203: ((tapePositionVector >> 16) & 0xFF);
2204: cdb->SPACE_TAPE_MARKS.NumMarks =
2205: ((tapePositionVector >> 8) & 0xFF);
2206: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
2207: (tapePositionVector & 0xFF);
2208: srb.TimeOutValue = 4100;
2209: break;
2210:
2211: case TAPE_SPACE_SETMARKS:
2212: DebugPrint((3,"TapeSetPosition: method == space setmarks\n"));
2213: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
2214: cdb->SPACE_TAPE_MARKS.Code = 4;
2215: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
2216: ((tapePositionVector >> 16) & 0xFF);
2217: cdb->SPACE_TAPE_MARKS.NumMarks =
2218: ((tapePositionVector >> 8) & 0xFF);
2219: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
2220: (tapePositionVector & 0xFF);
2221: srb.TimeOutValue = 4100;
2222: break;
2223:
2224: default:
2225: DebugPrint((1,"TapeSetPosition: PositionMethod -- operation not supported\n"));
2226: return STATUS_NOT_IMPLEMENTED;
2227: }
2228:
2229: //
2230: // Send SCSI command (CDB) to device
2231: //
2232:
2233: DebugPrint((3,"TapeSetPosition: SendSrb (method)\n"));
2234:
2235: status = ScsiClassSendSrbSynchronous(DeviceObject,
2236: &srb,
2237: NULL,
2238: 0,
2239: FALSE);
2240:
2241: if (NT_SUCCESS(status)) {
2242: if (changePartition) {
2243: tapeData->CurrentPartition = tapeSetPosition->Partition;
2244: }
2245: } else {
2246: DebugPrint((1,"TapeSetPosition: method, SendSrb unsuccessful\n"));
2247: }
2248:
2249: return status;
2250:
2251: } // end TapeSetPosition()
2252:
2253:
2254: BOOLEAN
2255: TapeVerifyInquiry(
2256: IN PSCSI_INQUIRY_DATA LunInfo
2257: )
2258:
2259: /*++
2260: Routine Description:
2261:
2262: This routine determines if this driver should claim this device.
2263:
2264: Arguments:
2265:
2266: LunInfo
2267:
2268: Return Value:
2269:
2270: TRUE - driver should claim this device.
2271: FALSE - driver should not claim this device.
2272:
2273: --*/
2274:
2275: {
2276: PINQUIRYDATA inquiryData;
2277:
2278: DebugPrint((3,"TapeVerifyInquiry: Enter routine\n"));
2279:
2280: inquiryData = (PVOID)LunInfo->InquiryData;
2281:
2282: //
2283: // Determine, from the Product ID field in the
2284: // inquiry data, whether or not to "claim" this drive.
2285: //
2286:
2287: return WhichIsIt(inquiryData)? TRUE : FALSE;
2288:
2289: } // end TapeVerifyInquiry()
2290:
2291:
2292: NTSTATUS
2293: TapeWriteMarks(
2294: IN PDEVICE_OBJECT DeviceObject,
2295: IN PIRP Irp
2296: )
2297:
2298: /*++
2299: Routine Description:
2300:
2301: This routine writes tapemarks on the tape.
2302:
2303: Arguments:
2304:
2305: DeviceObject
2306: Irp
2307:
2308: Return Value:
2309:
2310: NTSTATUS
2311:
2312: --*/
2313:
2314: {
2315: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
2316: PTAPE_WRITE_MARKS tapeWriteMarks = Irp->AssociatedIrp.SystemBuffer;
2317: SCSI_REQUEST_BLOCK srb;
2318: PCDB cdb = (PCDB)srb.Cdb;
2319: NTSTATUS status;
2320:
2321: DebugPrint((3,"TapeWriteMarks: Enter routine\n"));
2322:
2323: if (tapeWriteMarks->Immediate) {
2324: switch (tapeWriteMarks->Type) {
2325: case TAPE_SETMARKS:
2326: case TAPE_FILEMARKS:
2327: DebugPrint((3,"TapeWriteMarks: immediate\n"));
2328: break;
2329:
2330: case TAPE_SHORT_FILEMARKS:
2331: case TAPE_LONG_FILEMARKS:
2332: default:
2333: DebugPrint((1,"TapeWriteMarks: TapemarkType, immediate -- operation not supported\n"));
2334: return STATUS_NOT_IMPLEMENTED;
2335: }
2336: }
2337:
2338: //
2339: // Zero CDB in SRB on stack.
2340: //
2341:
2342: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
2343:
2344: //
2345: // Prepare SCSI command (CDB)
2346: //
2347:
2348: srb.CdbLength = CDB6GENERIC_LENGTH;
2349:
2350: cdb->WRITE_TAPE_MARKS.OperationCode = SCSIOP_WRITE_FILEMARKS;
2351: cdb->WRITE_TAPE_MARKS.Immediate = tapeWriteMarks->Immediate;
2352:
2353: switch (tapeWriteMarks->Type) {
2354: case TAPE_SETMARKS:
2355: DebugPrint((3,"TapeWriteMarks: TapemarkType == setmarks\n"));
2356: cdb->WRITE_TAPE_MARKS.WriteSetMarks = SETBITON;
2357: break;
2358:
2359: case TAPE_FILEMARKS:
2360: DebugPrint((3,"TapeWriteMarks: TapemarkType == filemarks\n"));
2361: break;
2362:
2363: case TAPE_SHORT_FILEMARKS:
2364: case TAPE_LONG_FILEMARKS:
2365: default:
2366: DebugPrint((1,"TapeWriteMarks: TapemarkType -- operation not supported\n"));
2367: return STATUS_NOT_IMPLEMENTED;
2368: }
2369:
2370: cdb->WRITE_TAPE_MARKS.TransferLength[0] =
2371: ((tapeWriteMarks->Count >> 16) & 0xFF);
2372: cdb->WRITE_TAPE_MARKS.TransferLength[1] =
2373: ((tapeWriteMarks->Count >> 8) & 0xFF);
2374: cdb->WRITE_TAPE_MARKS.TransferLength[2] =
2375: (tapeWriteMarks->Count & 0xFF);
2376:
2377: //
2378: // Set timeout value.
2379: //
2380:
2381: srb.TimeOutValue = deviceExtension->TimeOutValue;
2382:
2383: //
2384: // Send SCSI command (CDB) to device
2385: //
2386:
2387: DebugPrint((3,"TapeWriteMarks: SendSrb (TapemarkType)\n"));
2388:
2389: status = ScsiClassSendSrbSynchronous(DeviceObject,
2390: &srb,
2391: NULL,
2392: 0,
2393: FALSE);
2394:
2395: if (!NT_SUCCESS(status)) {
2396: DebugPrint((1,"TapeWriteMarks: TapemarkType, SendSrb unsuccessful\n"));
2397: }
2398:
2399: return status;
2400:
2401: } // end TapeWriteMarks()
2402:
2403:
2404: static
2405: NTSTATUS
2406: GetInquiryInformationData (
2407: IN PDEVICE_OBJECT DeviceObject,
2408: IN PIRP Irp,
2409: OUT PINQUIRYDATA InquiryBuffer
2410: )
2411:
2412: /*++
2413: Routine Description:
2414:
2415: Get the inquiry parameter list buffer
2416:
2417: Arguments:
2418:
2419: DeviceObject
2420: Irp
2421: InquiryBuffer
2422:
2423: Return Value:
2424:
2425: NTSTATUS
2426:
2427: --*/
2428:
2429: {
2430: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
2431: SCSI_REQUEST_BLOCK srb;
2432: PCDB cdb = (PCDB)srb.Cdb;
2433: NTSTATUS status;
2434:
2435: RtlZeroMemory(InquiryBuffer, sizeof(INQUIRYDATA));
2436:
2437: //
2438: // Zero CDB in SRB on stack.
2439: //
2440:
2441: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
2442:
2443: //
2444: // Prepare SCSI command (CDB)
2445: //
2446:
2447: srb.CdbLength = CDB6GENERIC_LENGTH;
2448:
2449: cdb->CDB6INQUIRY.OperationCode = SCSIOP_INQUIRY;
2450: cdb->CDB6INQUIRY.AllocationLength = INQUIRYDATABUFFERSIZE;
2451:
2452: //
2453: // Set timeout value.
2454: //
2455:
2456: srb.TimeOutValue = deviceExtension->TimeOutValue;
2457:
2458: //
2459: // Send SCSI command (CDB) to device
2460: //
2461:
2462: status = ScsiClassSendSrbSynchronous(DeviceObject,
2463: &srb,
2464: InquiryBuffer,
2465: INQUIRYDATABUFFERSIZE,
2466: FALSE);
2467:
2468: return status;
2469: }
2470:
2471:
2472: static
2473: NTSTATUS
2474: RewindToBOT(
2475: IN PDEVICE_OBJECT DeviceObject,
2476: IN PIRP Irp
2477: )
2478:
2479: /*++
2480: Routine Description:
2481:
2482: This routine will rewind to BOT. Note: BOP is BOT for both the
2483: data partition and the directory partition; thus, if QFA is enabled,
2484: a rewind to BOT is a rewind to BOP of the active partition.
2485:
2486: Arguments:
2487:
2488: DeviceObject
2489: Irp
2490:
2491: Return Value:
2492:
2493: NTSTATUS
2494:
2495: --*/
2496:
2497: {
2498: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
2499: SCSI_REQUEST_BLOCK srb;
2500: PCDB cdb = (PCDB)srb.Cdb;
2501: NTSTATUS status;
2502:
2503: //
2504: // Zero CDB in SRB on stack.
2505: //
2506:
2507: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
2508:
2509: //
2510: // Prepare SCSI command (CDB)
2511: //
2512:
2513: srb.CdbLength = CDB6GENERIC_LENGTH;
2514:
2515: cdb->CDB6INQUIRY.OperationCode = SCSIOP_REWIND;
2516:
2517: //
2518: // Set timeout value.
2519: //
2520:
2521: srb.TimeOutValue = 180;
2522:
2523: //
2524: // Send SCSI command (CDB) to device
2525: //
2526:
2527: status = ScsiClassSendSrbSynchronous(DeviceObject,
2528: &srb,
2529: NULL,
2530: 0,
2531: FALSE);
2532: return status;
2533: }
2534:
2535:
2536: static
2537: ULONG
2538: WhichIsIt(
2539: IN PINQUIRYDATA InquiryData
2540: )
2541:
2542: /*++
2543: Routine Description:
2544:
2545: This routine determines a drive's identity from the Product ID field
2546: in its inquiry data.
2547:
2548: Arguments:
2549:
2550: InquiryData (from an Inquiry command)
2551:
2552: Return Value:
2553:
2554: driveID
2555:
2556: --*/
2557:
2558: {
2559: if (RtlCompareMemory(InquiryData->VendorId,"TANDBERG",8) == 8) {
2560:
2561: if (RtlCompareMemory(InquiryData->ProductId," TDC 3600",9) == 9) {
2562: return TDC_3600;
2563: }
2564:
2565: if (RtlCompareMemory(InquiryData->ProductId," TDC 3800",9) == 9) {
2566: return TDC_3800;
2567: }
2568:
2569: if (RtlCompareMemory(InquiryData->ProductId," TDC 4100",9) == 9) {
2570: return TDC_4100;
2571: }
2572:
2573: if (RtlCompareMemory(InquiryData->ProductId," IBM 4100",9) == 9) {
2574: return TDC_4100;
2575: }
2576:
2577: if (RtlCompareMemory(InquiryData->ProductId," TDC 4200",9) == 9) {
2578: return TDC_4200;
2579: }
2580:
2581: }
2582:
2583: if (RtlCompareMemory(InquiryData->VendorId,"DEC ",8) == 8) {
2584:
2585: if (RtlCompareMemory(InquiryData->ProductId,"TZK10",5) == 5) {
2586: return TDC_3800;
2587: }
2588:
2589: }
2590:
2591: return (ULONG)0;
2592: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.