![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 4mmdat.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 / 4mmdat|
Return to 4mmdat.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / scsitape / 4mmdat |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: 4mmdat.c
8:
9: Abstract:
10:
11: This module contains the device-specific routines for the Archive
12: Python DDS, DDS-DC, and Turbo-Speed DDS-DC DAT tape drives, the
13: HP 35470A DDS and 35480A DDS-DC DAT tape drives, the WangDAT
14: Model 3200 DDS-DC DAT tape drive, and the Compaq DDS-DC DAT tape
15: drive.
16:
17: Author:
18:
19: Mike Glass
20: Hunter Small (Maynard)
21: Lori Brown (Maynard)
22: Chris Hugh Sam (Maynard)
23:
24: Environment:
25:
26: kernel mode only
27:
28: Revision History:
29:
30: --*/
31:
32: #include "ntddk.h"
33: #include "tape.h"
34: #include "4mmdat.h"
35:
36: static ULONG gb_PartitionCount;
37: static UCHAR gb_VendorId[8];
38: static UCHAR gb_ProductId[16];
39:
40: //
41: // Internal (module wide) defines that symbolize
42: // the 4mm DAT drives supported by this module.
43: //
44: #define ARCHIVE_PYTHON 1 ;
45: #define DEC_TLZ06 2 ;
46: #define EXABYTE_4200 3 ;
47: #define EXABYTE_4200C 4 ;
48: #define HP_35470A 5 ;
49: #define HP_35480A 6 ;
50: #define HP_IBM35480A 7 ;
51: #define WANGDAT_1300 8 ;
52: #define WANGDAT_3100 9 ;
53: #define WANGDAT_3200 10 ;
54:
55: //
56: // Function prototype(s) for internal function(s)
57: //
58: static ULONG WhichIsIt(IN PINQUIRYDATA InquiryData);
59:
60:
61: NTSTATUS
62: TapeCreatePartition(
63: IN PDEVICE_OBJECT DeviceObject,
64: IN PIRP Irp
65: )
66:
67: /*++
68: Routine Description:
69:
70: This routine creates initiator-defined partitions on the tape.
71:
72: Arguments:
73:
74: DeviceObject
75: Irp
76:
77: Return Value:
78:
79: NTSTATUS
80:
81: --*/
82:
83: {
84: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
85: PTAPE_CREATE_PARTITION tapePartition = Irp->AssociatedIrp.SystemBuffer;
86: PMODE_MEDIUM_PART_PAGE buffer;
87: SCSI_REQUEST_BLOCK srb;
88: PCDB cdb = (PCDB)srb.Cdb;
89: NTSTATUS status;
90:
91: //
92: // Zero CDB in SRB on stack.
93: //
94:
95: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
96:
97: srb.CdbLength = CDB6GENERIC_LENGTH;
98:
99: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
100:
101: //
102: // Set timeout value.
103: //
104:
105: srb.TimeOutValue = 8000;
106:
107: cdb->MODE_SELECT.ParameterListLength = sizeof(MODE_MEDIUM_PART_PAGE);
108: cdb->MODE_SELECT.PFBit = 1;
109:
110: buffer = ExAllocatePool(NonPagedPoolCacheAligned,
111: sizeof(MODE_MEDIUM_PART_PAGE));
112:
113: if (!buffer) {
114: return STATUS_INSUFFICIENT_RESOURCES;
115: }
116:
117: RtlZeroMemory(buffer, sizeof(MODE_MEDIUM_PART_PAGE));
118:
119: buffer->ParameterListHeader.DeviceSpecificParameter = 0x10;
120:
121: buffer->MediumPartPage.PageCode = MODE_PAGE_MEDIUM_PARTITION;
122:
123: if (tapePartition->Count != 1 && tapePartition->Count != 2) {
124: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
125: ExFreePool(buffer);
126: return STATUS_INVALID_DEVICE_REQUEST;
127: }
128:
129: buffer->MediumPartPage.AdditionalPartitionDefined = tapePartition->Count - 1;
130:
131: switch (tapePartition->Method) {
132: case TAPE_FIXED_PARTITIONS:
133: if (RtlCompareMemory(gb_VendorId,"WangDAT ",8) == 8) {
134: DebugPrint((3,"TapeIoControl: Create Fixed Tape Partitions\n"));
135: buffer->MediumPartPage.FDPBit = SETBITON;
136: buffer->MediumPartPage.PageLength = 0x0A;
137: } else {
138: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
139: ExFreePool(buffer);
140: return STATUS_INVALID_DEVICE_REQUEST;
141: }
142: break;
143:
144: case TAPE_SELECT_PARTITIONS:
145: if (RtlCompareMemory(gb_VendorId,"WangDAT ",8) == 8) {
146: DebugPrint((3,"TapeIoControl: Create Select Tape Partitions\n"));
147: buffer->MediumPartPage.SDPBit = SETBITON;
148: buffer->MediumPartPage.PageLength = 0x0A;
149: } else {
150: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
151: ExFreePool(buffer);
152: return STATUS_INVALID_DEVICE_REQUEST;
153: }
154: break;
155:
156: case TAPE_INITIATOR_PARTITIONS:
157: DebugPrint((3,"TapeIoControl: Create Initiator Defined Tape Partitions\n"));
158: buffer->MediumPartPage.IDPBit = SETBITON;
159:
160: if (buffer->MediumPartPage.AdditionalPartitionDefined) {
161: if (RtlCompareMemory(gb_VendorId,"WangDAT ",8) == 8) {
162: buffer->MediumPartPage.PageLength = 0x0A;
163:
164: buffer->MediumPartPage.Partition1Size[0] =
165: ((tapePartition->Size >> 8) & 0xFF);
166: buffer->MediumPartPage.Partition1Size[1] =
167: (tapePartition->Size & 0xFF);
168:
169: buffer->MediumPartPage.PSUMBit = 2;
170: } else {
171: buffer->MediumPartPage.PageLength = 0x08;
172: cdb->MODE_SELECT.ParameterListLength -= 2;
173:
174: buffer->MediumPartPage.Partition0Size[0] =
175: ((tapePartition->Size >> 8) & 0xFF);
176: buffer->MediumPartPage.Partition0Size[1] =
177: (tapePartition->Size & 0xFF);
178:
179: buffer->MediumPartPage.PSUMBit = 2;
180: }
181: } else {
182: if (RtlCompareMemory(gb_VendorId,"WangDAT ",8) == 8) {
183: buffer->MediumPartPage.PageLength = 0x0A;
184: } else {
185: buffer->MediumPartPage.PageLength = 0x06;
186: cdb->MODE_SELECT.ParameterListLength -= 4;
187: }
188: }
189:
190: break;
191:
192: default:
193: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
194: ExFreePool(buffer);
195: return STATUS_INVALID_DEVICE_REQUEST;
196: }
197:
198: status = ScsiClassSendSrbSynchronous(DeviceObject,
199: &srb,
200: buffer,
201: cdb->MODE_SELECT.ParameterListLength,
202: TRUE);
203:
204: ExFreePool(buffer);
205:
206: return status;
207:
208: } // end TapeCreatePartition()
209:
210:
211: NTSTATUS
212: TapeErase(
213: IN PDEVICE_OBJECT DeviceObject,
214: IN PIRP Irp
215: )
216:
217: /*++
218: Routine Description:
219:
220: This routine erases the current partition of the device by writing an
221: end-of-recorded data marker beginning at the current position.
222:
223: Arguments:
224:
225: DeviceObject
226: Irp
227:
228: Return Value:
229:
230: NTSTATUS
231:
232: --*/
233:
234: {
235: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
236: PTAPE_ERASE tapeErase = Irp->AssociatedIrp.SystemBuffer;
237: SCSI_REQUEST_BLOCK srb;
238: PCDB cdb = (PCDB)srb.Cdb;
239: NTSTATUS status;
240:
241: //
242: // Zero CDB in SRB on stack.
243: //
244:
245: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
246:
247: srb.CdbLength = CDB6GENERIC_LENGTH;
248:
249: cdb->ERASE.OperationCode = SCSIOP_ERASE;
250:
251: //
252: // Set timeout value.
253: //
254:
255: srb.TimeOutValue = deviceExtension->TimeOutValue;
256:
257: if (tapeErase->Type != TAPE_ERASE_SHORT) {
258: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
259: return STATUS_INVALID_DEVICE_REQUEST;
260: }
261:
262: DebugPrint((3,"TapeIoControl: Short Erase Tape\n"));
263:
264: //
265: // Set immediate bit if indicated.
266: //
267:
268: cdb->ERASE.Immediate = tapeErase->Immediate;
269:
270: status = ScsiClassSendSrbSynchronous(DeviceObject,
271: &srb,
272: NULL,
273: 0,
274: FALSE);
275:
276: return status;
277:
278: } // end TapeErase()
279:
280:
281:
282: VOID
283: TapeError(
284: PDEVICE_OBJECT DeviceObject,
285: PSCSI_REQUEST_BLOCK Srb,
286: NTSTATUS *Status,
287: BOOLEAN *Retry
288: )
289:
290: /*++
291:
292: Routine Description:
293:
294: When a request completes with error, the routine InterpretSenseInfo is
295: called to determine from the sense data whether the request should be
296: retried and what NT status to set in the IRP. Then this routine is called
297: for tape requests to handle tape-specific errors and update the nt status
298: and retry boolean.
299:
300: Arguments:
301:
302: DeviceObject - Supplies a pointer to the device object.
303:
304: Srb - Supplies a pointer to the failing Srb.
305:
306: Status - NT Status used to set the IRP's completion status.
307:
308: Retry - Indicates that this request should be retried.
309:
310: Return Value:
311:
312: None.
313:
314: --*/
315:
316: {
317: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
318: PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
319: NTSTATUS status = *Status;
320: BOOLEAN retry = *Retry;
321: UCHAR adsenseq = senseBuffer->AdditionalSenseCodeQualifier;
322: UCHAR adsense = senseBuffer->AdditionalSenseCode;
323:
324: if (status == STATUS_DEVICE_NOT_READY) {
325: if ((adsense == SCSI_ADSENSE_LUN_NOT_READY) &&
326: (adsenseq == SCSI_SENSEQ_BECOMING_READY) ) {
327:
328: *Status = STATUS_NO_MEDIA;
329: *Retry = FALSE;
330:
331: }
332: }
333: return;
334:
335: } // end TapeError()
336:
337:
338: NTSTATUS
339: TapeGetDriveParameters(
340: IN PDEVICE_OBJECT DeviceObject,
341: IN PIRP Irp
342: )
343:
344: /*++
345: Routine Description:
346:
347: This routine returns an indication if reporting setmarks is disabled or
348: enabled, the default fixed-block size, the maximum block size, the
349: minimum block size, the maximum number of partitions, and the device
350: features flag.
351:
352: Arguments:
353:
354: DeviceObject
355: Irp
356:
357: Return Value:
358:
359: NTSTATUS
360:
361: --*/
362:
363: {
364: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
365: PTAPE_GET_DRIVE_PARAMETERS tapeGetDriveParams = Irp->AssociatedIrp.SystemBuffer;
366: PMODE_DEVICE_CONFIG_PAGE buffer;
367: PREAD_BLOCK_LIMITS_DATA blockLimits;
368: SCSI_REQUEST_BLOCK srb;
369: PCDB cdb = (PCDB)srb.Cdb;
370: NTSTATUS status;
371: PMODE_DATA_COMPRESS_PAGE dcbuff;
372:
373: DebugPrint((3,"TapeIoControl: Get Tape Drive Parameters\n"));
374:
375: //
376: // Zero CDB in SRB on stack.
377: //
378:
379: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
380:
381: srb.CdbLength = CDB6GENERIC_LENGTH;
382:
383: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
384:
385: //
386: // Set timeout value.
387: //
388:
389: srb.TimeOutValue = deviceExtension->TimeOutValue;
390:
391: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_DEVICE_CONFIG_PAGE);
392: cdb->MODE_SENSE.Dbd = SETBITON;
393: cdb->MODE_SENSE.PageCode = MODE_PAGE_DEVICE_CONFIG;
394:
395: buffer = ExAllocatePool(NonPagedPoolCacheAligned,
396: sizeof(MODE_DEVICE_CONFIG_PAGE));
397:
398: if (!buffer) {
399: return STATUS_INSUFFICIENT_RESOURCES;
400: }
401:
402: RtlZeroMemory(buffer, sizeof(MODE_DEVICE_CONFIG_PAGE));
403:
404: status = ScsiClassSendSrbSynchronous(DeviceObject,
405: &srb,
406: buffer,
407: sizeof( MODE_DEVICE_CONFIG_PAGE ),
408: FALSE);
409:
410: if (NT_SUCCESS(status)) {
411: Irp->IoStatus.Information = sizeof(TAPE_GET_DRIVE_PARAMETERS);
412:
413: tapeGetDriveParams->ECC = 0;
414: tapeGetDriveParams->DataPadding = 0;
415: tapeGetDriveParams->Compression = 0;
416: tapeGetDriveParams->ReportSetmarks = (buffer->DeviceConfigPage.RSmk ? 1 : 0 );
417: tapeGetDriveParams->DefaultBlockSize = 0x200;
418: tapeGetDriveParams->MaximumPartitionCount = 2;
419:
420: tapeGetDriveParams->FeaturesLow =
421: TAPE_DRIVE_INITIATOR |
422: TAPE_DRIVE_ERASE_SHORT |
423: TAPE_DRIVE_ERASE_BOP_ONLY |
424: TAPE_DRIVE_ERASE_IMMEDIATE |
425: TAPE_DRIVE_TAPE_CAPACITY |
426: TAPE_DRIVE_FIXED_BLOCK |
427: TAPE_DRIVE_VARIABLE_BLOCK |
428: TAPE_DRIVE_WRITE_PROTECT |
429: TAPE_DRIVE_REPORT_SMKS |
430: TAPE_DRIVE_GET_ABSOLUTE_BLK |
431: TAPE_DRIVE_GET_LOGICAL_BLK;
432:
433: tapeGetDriveParams->FeaturesHigh =
434: TAPE_DRIVE_LOAD_UNLOAD |
435: TAPE_DRIVE_LOCK_UNLOCK |
436: TAPE_DRIVE_REWIND_IMMEDIATE |
437: TAPE_DRIVE_SET_BLOCK_SIZE |
438: TAPE_DRIVE_LOAD_UNLD_IMMED |
439: TAPE_DRIVE_SET_REPORT_SMKS |
440: TAPE_DRIVE_ABSOLUTE_BLK |
441: TAPE_DRIVE_ABS_BLK_IMMED |
442: TAPE_DRIVE_LOGICAL_BLK |
443: TAPE_DRIVE_END_OF_DATA |
444: TAPE_DRIVE_RELATIVE_BLKS |
445: TAPE_DRIVE_FILEMARKS |
446: TAPE_DRIVE_SEQUENTIAL_FMKS |
447: TAPE_DRIVE_SETMARKS |
448: TAPE_DRIVE_REVERSE_POSITION |
449: TAPE_DRIVE_WRITE_SETMARKS |
450: TAPE_DRIVE_WRITE_FILEMARKS |
451: TAPE_DRIVE_WRITE_MARK_IMMED;
452:
453: if (RtlCompareMemory(gb_VendorId,"WangDAT ",8) == 8) {
454: tapeGetDriveParams->FeaturesLow |=
455: TAPE_DRIVE_FIXED |
456: TAPE_DRIVE_SELECT;
457: tapeGetDriveParams->FeaturesHigh |=
458: TAPE_DRIVE_LOG_BLK_IMMED |
459: TAPE_DRIVE_SEQUENTIAL_SMKS;
460: } else if (RtlCompareMemory(gb_VendorId,"HP ",8) == 8) {
461: tapeGetDriveParams->FeaturesHigh |=
462: TAPE_DRIVE_LOG_BLK_IMMED |
463: TAPE_DRIVE_SEQUENTIAL_SMKS;
464: } else {
465: tapeGetDriveParams->FeaturesLow |=
466: TAPE_DRIVE_TAPE_REMAINING;
467: }
468:
469: }
470:
471: ExFreePool(buffer);
472:
473: if (!NT_SUCCESS(status)) {
474: return status;
475: }
476:
477: //
478: // Zero CDB in SRB on stack.
479: //
480:
481: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
482:
483: srb.CdbLength = CDB6GENERIC_LENGTH;
484:
485: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
486:
487: //
488: // Set timeout value.
489: //
490:
491: srb.TimeOutValue = deviceExtension->TimeOutValue;
492:
493: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_DATA_COMPRESS_PAGE);
494: cdb->MODE_SENSE.Dbd = SETBITON;
495: cdb->MODE_SENSE.PageCode = MODE_PAGE_DATA_COMPRESS;
496:
497: dcbuff = ExAllocatePool(NonPagedPoolCacheAligned,
498: sizeof(MODE_DATA_COMPRESS_PAGE));
499:
500: if (!dcbuff) {
501: return STATUS_INSUFFICIENT_RESOURCES;
502: }
503:
504: RtlZeroMemory(dcbuff, sizeof(MODE_DATA_COMPRESS_PAGE));
505:
506: status = ScsiClassSendSrbSynchronous(DeviceObject,
507: &srb,
508: dcbuff,
509: sizeof( MODE_DATA_COMPRESS_PAGE ),
510: FALSE);
511:
512: if (NT_SUCCESS(status)) {
513: if (dcbuff->DataCompressPage.DCC == 1) {
514: tapeGetDriveParams->FeaturesLow |= TAPE_DRIVE_COMPRESSION;
515: tapeGetDriveParams->FeaturesHigh |= TAPE_DRIVE_SET_COMPRESSION;
516: tapeGetDriveParams->Compression = (dcbuff->DataCompressPage.DCE == 1 ? TRUE : FALSE);
517: }
518: }
519:
520: ExFreePool(dcbuff);
521:
522: if (!NT_SUCCESS(status) && (status != STATUS_INVALID_DEVICE_REQUEST)) {
523: return status;
524: }
525:
526: //
527: // Zero CDB in SRB on stack.
528: //
529:
530: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
531:
532: srb.CdbLength = CDB6GENERIC_LENGTH;
533:
534: cdb->CDB6GENERIC.OperationCode = SCSIOP_READ_BLOCK_LIMITS;
535:
536: //
537: // Set timeout value.
538: //
539:
540: srb.TimeOutValue = deviceExtension->TimeOutValue;
541:
542: blockLimits = ExAllocatePool(NonPagedPoolCacheAligned,
543: sizeof(READ_BLOCK_LIMITS_DATA));
544:
545: if (!blockLimits) {
546: return STATUS_INSUFFICIENT_RESOURCES;
547: }
548:
549: RtlZeroMemory(blockLimits, sizeof(READ_BLOCK_LIMITS_DATA));
550:
551: status = ScsiClassSendSrbSynchronous(DeviceObject,
552: &srb,
553: blockLimits,
554: sizeof(READ_BLOCK_LIMITS_DATA),
555: FALSE);
556:
557: if (NT_SUCCESS(status)) {
558: tapeGetDriveParams->MaximumBlockSize = blockLimits->BlockMaximumSize[2];
559: tapeGetDriveParams->MaximumBlockSize += (blockLimits->BlockMaximumSize[1] << 8);
560: tapeGetDriveParams->MaximumBlockSize += (blockLimits->BlockMaximumSize[0] << 16);
561:
562: tapeGetDriveParams->MinimumBlockSize = blockLimits->BlockMinimumSize[1];
563: tapeGetDriveParams->MinimumBlockSize += (blockLimits->BlockMinimumSize[0] << 8);
564: }
565:
566: ExFreePool(blockLimits);
567:
568: tapeGetDriveParams->FeaturesHigh &= ~TAPE_DRIVE_HIGH_FEATURES;
569:
570: return status;
571:
572: } // end TapeGetDriveParameters()
573:
574:
575: NTSTATUS
576: TapeGetMediaParameters(
577: IN PDEVICE_OBJECT DeviceObject,
578: IN PIRP Irp
579: )
580:
581: /*++
582: Routine Description:
583:
584: This routine returns the maximum tape capacity, the remaining tape
585: capacity, the fixed-length logical block size, the number of partitions
586: on the tape, and an indication if the tape is write protected. A block
587: size of 0 indicates variable-length block mode.
588:
589: Arguments:
590:
591: DeviceObject
592: Irp
593:
594: Return Value:
595:
596: NTSTATUS
597:
598: --*/
599:
600: {
601: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
602: PTAPE_GET_MEDIA_PARAMETERS tapeGetMediaParams = Irp->AssociatedIrp.SystemBuffer;
603: PMODE_TAPE_MEDIA_INFORMATION modeBuffer;
604: PLOG_SENSE_PARAMETER_FORMAT logBuffer;
605: SCSI_REQUEST_BLOCK srb;
606: PCDB cdb = (PCDB)srb.Cdb;
607: NTSTATUS status;
608: LARGE_INTEGER capacityBuffer[2];
609: LARGE_INTEGER remainingBuffer[2];
610: ULONG sectorShift;
611:
612: DebugPrint((3,"TapeIoControl: Get Tape Media Parameters\n"));
613:
614: //
615: // Zero CDB in SRB on stack.
616: //
617:
618: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
619:
620: srb.CdbLength = CDB6GENERIC_LENGTH;
621:
622: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
623:
624: //
625: // Set timeout value.
626: //
627:
628: srb.TimeOutValue = deviceExtension->TimeOutValue;
629:
630: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_TAPE_MEDIA_INFORMATION);
631: cdb->MODE_SENSE.PageCode = MODE_PAGE_MEDIUM_PARTITION;
632:
633: modeBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
634: sizeof(MODE_TAPE_MEDIA_INFORMATION));
635:
636: if (!modeBuffer) {
637: return STATUS_INSUFFICIENT_RESOURCES;
638: }
639:
640: RtlZeroMemory(modeBuffer, sizeof(MODE_TAPE_MEDIA_INFORMATION));
641:
642: status = ScsiClassSendSrbSynchronous(DeviceObject,
643: &srb,
644: modeBuffer,
645: sizeof( MODE_TAPE_MEDIA_INFORMATION ),
646: FALSE);
647:
648: if (status == STATUS_DATA_OVERRUN) {
649: status = STATUS_SUCCESS;
650: }
651:
652: if (NT_SUCCESS(status)) {
653: Irp->IoStatus.Information = sizeof(TAPE_GET_MEDIA_PARAMETERS);
654:
655: tapeGetMediaParams->BlockSize = modeBuffer->ParameterListBlock.BlockLength[2];
656: tapeGetMediaParams->BlockSize += (modeBuffer->ParameterListBlock.BlockLength[1] << 8);
657: tapeGetMediaParams->BlockSize += (modeBuffer->ParameterListBlock.BlockLength[0] << 16);
658:
659: tapeGetMediaParams->PartitionCount =
660: modeBuffer->MediumPartPage.AdditionalPartitionDefined + 1;
661:
662: tapeGetMediaParams->WriteProtected =
663: ((modeBuffer->ParameterListHeader.DeviceSpecificParameter >> 7) &
664: 0x01);
665:
666: gb_PartitionCount =
667: modeBuffer->MediumPartPage.AdditionalPartitionDefined + 1;
668:
669: if (RtlCompareMemory(gb_VendorId,"WangDAT ",8) == 8) {
670: capacityBuffer[0].LowPart = modeBuffer->MediumPartPage.Partition0Size[1];
671: capacityBuffer[0].LowPart += (modeBuffer->MediumPartPage.Partition0Size[0] << 8);
672:
673: capacityBuffer[0].HighPart = 0;
674:
675: if (tapeGetMediaParams->PartitionCount == 2) {
676: capacityBuffer[1].LowPart = modeBuffer->MediumPartPage.Partition1Size[1];
677: capacityBuffer[1].LowPart += (modeBuffer->MediumPartPage.Partition1Size[0] << 8);
678:
679: capacityBuffer[1].HighPart = 0;
680: } else {
681: capacityBuffer[1].LowPart = 0;
682: capacityBuffer[1].HighPart = 0;
683: }
684:
685: capacityBuffer[0] =
686: RtlLargeIntegerAdd( capacityBuffer[0], capacityBuffer[1]);
687: capacityBuffer[0] =
688: RtlExtendedIntegerMultiply(capacityBuffer[0], 1024000);
689:
690: tapeGetMediaParams->Capacity = capacityBuffer[0];
691:
692: tapeGetMediaParams->Remaining.LowPart = 0;
693: tapeGetMediaParams->Remaining.HighPart = 0;
694:
695: WHICH_BIT(tapeGetMediaParams->BlockSize, sectorShift);
696: deviceExtension->DiskGeometry->BytesPerSector = tapeGetMediaParams->BlockSize;
697: deviceExtension->SectorShift = sectorShift;
698:
699:
700: }
701: }
702:
703: ExFreePool(modeBuffer);
704:
705: if (!NT_SUCCESS(status)) {
706:
707: return status;
708: }
709:
710: if (!(RtlCompareMemory(gb_VendorId,"WangDAT ",8) == 8)) {
711: //
712: // Zero CDB in SRB on stack.
713: //
714:
715: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
716:
717: srb.CdbLength = CDB10GENERIC_LENGTH;
718:
719: cdb->LOGSENSE.OperationCode = SCSIOP_LOG_SENSE;
720:
721: //
722: // Set timeout value.
723: //
724:
725: srb.TimeOutValue = deviceExtension->TimeOutValue;
726:
727: cdb->LOGSENSE.AllocationLength[0] = 0;
728: cdb->LOGSENSE.AllocationLength[1] = 0x24;
729:
730: cdb->LOGSENSE.PageCode = LOGSENSEPAGE31;
731: cdb->LOGSENSE.PCBit = 0x01;
732:
733: logBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
734: sizeof(LOG_SENSE_PARAMETER_FORMAT));
735:
736: if (!logBuffer) {
737: return STATUS_INSUFFICIENT_RESOURCES;
738: }
739:
740: RtlZeroMemory(logBuffer, sizeof(LOG_SENSE_PARAMETER_FORMAT));
741:
742: status = ScsiClassSendSrbSynchronous(DeviceObject,
743: &srb,
744: logBuffer,
745: 0x24,
746: FALSE);
747:
748: if (status == STATUS_DATA_OVERRUN) {
749: status = STATUS_SUCCESS;
750: }
751:
752: if (NT_SUCCESS(status)) {
753: capacityBuffer[0].LowPart = logBuffer->LogSensePageInfo.LogSensePage.Page31.MaximumCapacityPart0[3];
754: capacityBuffer[0].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.MaximumCapacityPart0[2] << 8);
755: capacityBuffer[0].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.MaximumCapacityPart0[1] << 16);
756: capacityBuffer[0].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.MaximumCapacityPart0[0] << 24);
757:
758: capacityBuffer[0].HighPart = 0;
759:
760: remainingBuffer[0].LowPart = logBuffer->LogSensePageInfo.LogSensePage.Page31.RemainingCapacityPart0[3];
761: remainingBuffer[0].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.RemainingCapacityPart0[2] << 8);
762: remainingBuffer[0].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.RemainingCapacityPart0[1] << 16);
763: remainingBuffer[0].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.RemainingCapacityPart0[0] << 24);
764:
765: remainingBuffer[0].HighPart = 0;
766:
767: if (tapeGetMediaParams->PartitionCount == 2) {
768: capacityBuffer[1].LowPart = logBuffer->LogSensePageInfo.LogSensePage.Page31.MaximumCapacityPart1[3];
769: capacityBuffer[1].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.MaximumCapacityPart1[2] << 8);
770: capacityBuffer[1].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.MaximumCapacityPart1[1] << 16);
771: capacityBuffer[1].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.MaximumCapacityPart1[0] << 24);
772:
773: capacityBuffer[1].HighPart = 0;
774:
775: remainingBuffer[1].LowPart = logBuffer->LogSensePageInfo.LogSensePage.Page31.RemainingCapacityPart1[3];
776: remainingBuffer[1].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.RemainingCapacityPart1[2] << 8);
777: remainingBuffer[1].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.RemainingCapacityPart1[1] << 16);
778: remainingBuffer[1].LowPart += (logBuffer->LogSensePageInfo.LogSensePage.Page31.RemainingCapacityPart1[0] << 24);
779:
780: remainingBuffer[1].HighPart = 0;
781:
782: } else {
783: capacityBuffer[1].LowPart = 0;
784: capacityBuffer[1].HighPart = 0;
785: remainingBuffer[1].LowPart = 0;
786: remainingBuffer[1].HighPart = 0;
787: }
788:
789: capacityBuffer[0] =
790: RtlLargeIntegerAdd( capacityBuffer[0], capacityBuffer[1]);
791: capacityBuffer[0] =
792: RtlExtendedIntegerMultiply(capacityBuffer[0], 1024);
793:
794: tapeGetMediaParams->Capacity = capacityBuffer[0];
795:
796: remainingBuffer[0] =
797: RtlLargeIntegerAdd( remainingBuffer[0], remainingBuffer[1]);
798: remainingBuffer[0] =
799: RtlExtendedIntegerMultiply(remainingBuffer[0], 1024);
800:
801: tapeGetMediaParams->Remaining = remainingBuffer[0];
802: }
803:
804: ExFreePool(logBuffer);
805: }
806:
807: return status;
808:
809: } // end TapeGetMediaParameters()
810:
811:
812: NTSTATUS
813: TapeGetPosition(
814: IN PDEVICE_OBJECT DeviceObject,
815: IN PIRP Irp
816: )
817:
818: /*++
819: Routine Description:
820:
821: This routine returns the current position of the tape.
822:
823: Arguments:
824:
825: DeviceObject
826: Irp
827:
828: Return Value:
829:
830: NTSTATUS
831:
832: --*/
833:
834: {
835: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
836: PTAPE_GET_POSITION tapeGetPosition = Irp->AssociatedIrp.SystemBuffer;
837: PTAPE_POSITION_DATA logicalBuffer;
838: PUCHAR absoluteBuffer;
839: SCSI_REQUEST_BLOCK srb;
840: PCDB cdb = (PCDB)srb.Cdb;
841: NTSTATUS status;
842:
843: //
844: // Zero CDB in SRB on stack.
845: //
846:
847: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
848:
849: //
850: // Set timeout value.
851: //
852:
853: srb.TimeOutValue = deviceExtension->TimeOutValue;
854:
855: switch (tapeGetPosition->Type) {
856: case TAPE_ABSOLUTE_POSITION:
857: DebugPrint((3,"TapeIoControl: Get Absolute Position\n"));
858: srb.CdbLength = CDB6GENERIC_LENGTH;
859: cdb->CDB6GENERIC.OperationCode = SCSIOP_REQUEST_BLOCK_ADDR;
860: absoluteBuffer = ExAllocatePool(NonPagedPoolCacheAligned, 3);
861:
862: if (!absoluteBuffer) {
863: return STATUS_INSUFFICIENT_RESOURCES;
864: }
865:
866: status = ScsiClassSendSrbSynchronous(DeviceObject,
867: &srb,
868: absoluteBuffer,
869: 3,
870: FALSE);
871:
872: if (NT_SUCCESS(status)) {
873: Irp->IoStatus.Information = sizeof(TAPE_GET_POSITION);
874:
875: tapeGetPosition->Partition = 0;
876: tapeGetPosition->Offset.HighPart = 0;
877: tapeGetPosition->Offset.LowPart = absoluteBuffer[2];
878: tapeGetPosition->Offset.LowPart += (absoluteBuffer[1] << 8);
879: tapeGetPosition->Offset.LowPart += (absoluteBuffer[0] << 16);
880: }
881:
882: ExFreePool(absoluteBuffer);
883: break;
884:
885: case TAPE_LOGICAL_POSITION:
886: DebugPrint((3,"TapeIoControl: Get Logical Position\n"));
887: srb.CdbLength = CDB10GENERIC_LENGTH;
888: cdb->READ_POSITION.Operation = SCSIOP_READ_POSITION;
889: logicalBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
890: sizeof(TAPE_POSITION_DATA));
891:
892: if (!logicalBuffer) {
893: return STATUS_INSUFFICIENT_RESOURCES;
894: }
895:
896: status = ScsiClassSendSrbSynchronous(DeviceObject,
897: &srb,
898: logicalBuffer,
899: sizeof( TAPE_POSITION_DATA ),
900: FALSE);
901:
902: if (NT_SUCCESS(status)) {
903: Irp->IoStatus.Information = sizeof(TAPE_GET_POSITION);
904:
905: if (logicalBuffer->BlockPositionUnsupported) {
906: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
907: return STATUS_INVALID_DEVICE_REQUEST;
908: }
909:
910: tapeGetPosition->Partition = logicalBuffer->PartitionNumber + 1;
911: tapeGetPosition->Offset.HighPart = 0;
912: REVERSE_BYTES((PFOUR_BYTE)&tapeGetPosition->Offset.LowPart,
913: (PFOUR_BYTE)logicalBuffer->FirstBlock);
914: }
915:
916: ExFreePool(logicalBuffer);
917: break;
918:
919: default:
920: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
921: return STATUS_INVALID_DEVICE_REQUEST;
922: }
923:
924: return status;
925:
926: } // end TapeGetPosition()
927:
928:
929: NTSTATUS
930: TapeGetStatus(
931: IN PDEVICE_OBJECT DeviceObject,
932: IN PIRP Irp
933: )
934:
935: /*++
936: Routine Description:
937:
938: This routine returns the status of the device.
939:
940: Arguments:
941:
942: DeviceObject
943: Irp
944:
945: Return Value:
946:
947: NTSTATUS
948:
949: --*/
950:
951: {
952: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
953: SCSI_REQUEST_BLOCK srb;
954: PCDB cdb = (PCDB)srb.Cdb;
955: NTSTATUS status;
956:
957: DebugPrint((3,"TapeIoControl: Get Tape Status\n"));
958:
959: //
960: // Zero CDB in SRB on stack.
961: //
962:
963: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
964:
965: srb.CdbLength = CDB6GENERIC_LENGTH;
966:
967: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
968:
969: //
970: // Set timeout value.
971: //
972:
973: srb.TimeOutValue = deviceExtension->TimeOutValue;
974:
975: status = ScsiClassSendSrbSynchronous(DeviceObject,
976: &srb,
977: NULL,
978: 0,
979: FALSE);
980:
981: return status;
982:
983: } // end TapeGetStatus()
984:
985:
986: NTSTATUS
987: TapePrepare(
988: IN PDEVICE_OBJECT DeviceObject,
989: IN PIRP Irp
990: )
991:
992: /*++
993: Routine Description:
994:
995: This routine loads, unloads, locks, or unlocks the tape.
996:
997: Arguments:
998:
999: DeviceObject
1000: Irp
1001:
1002: Return Value:
1003:
1004: NTSTATUS
1005:
1006: --*/
1007:
1008: {
1009: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1010: PTAPE_PREPARE tapePrepare = Irp->AssociatedIrp.SystemBuffer;
1011: SCSI_REQUEST_BLOCK srb;
1012: PCDB cdb = (PCDB)srb.Cdb;
1013: NTSTATUS status;
1014:
1015: //
1016: // Zero CDB in SRB on stack.
1017: //
1018:
1019: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1020:
1021: //
1022: // Set timeout value.
1023: //
1024:
1025: srb.TimeOutValue = deviceExtension->TimeOutValue;
1026:
1027: switch (tapePrepare->Operation) {
1028: case TAPE_LOAD:
1029: DebugPrint((3,"TapeIoControl: Load Tape\n"));
1030: srb.CdbLength = CDB6GENERIC_LENGTH;
1031: cdb->CDB6GENERIC.OperationCode = SCSIOP_LOAD_UNLOAD;
1032: cdb->CDB6GENERIC.CommandUniqueBytes[2] = 0x01;
1033: break;
1034:
1035: case TAPE_UNLOAD:
1036: DebugPrint((3,"TapeIoControl: Unload Tape\n"));
1037: srb.CdbLength = CDB6GENERIC_LENGTH;
1038: cdb->CDB6GENERIC.OperationCode = SCSIOP_LOAD_UNLOAD;
1039: break;
1040:
1041: case TAPE_LOCK:
1042: DebugPrint((3,"TapeIoControl: Prevent Tape Removal\n"));
1043: srb.CdbLength = CDB6GENERIC_LENGTH;
1044: cdb->CDB6GENERIC.OperationCode = SCSIOP_MEDIUM_REMOVAL;
1045: cdb->CDB6GENERIC.CommandUniqueBytes[2] = 0x01;
1046: break;
1047:
1048: case TAPE_UNLOCK:
1049: DebugPrint((3,"TapeIoControl: Allow Tape Removal\n"));
1050: srb.CdbLength = CDB6GENERIC_LENGTH;
1051: cdb->CDB6GENERIC.OperationCode = SCSIOP_MEDIUM_REMOVAL;
1052: break;
1053:
1054: default:
1055: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
1056: return STATUS_INVALID_DEVICE_REQUEST;
1057: }
1058:
1059: //
1060: // Set immediate bit if indicated.
1061: //
1062:
1063: cdb->CDB6GENERIC.Immediate = tapePrepare->Immediate;
1064:
1065: status = ScsiClassSendSrbSynchronous(DeviceObject,
1066: &srb,
1067: NULL,
1068: 0,
1069: FALSE);
1070:
1071: return status;
1072:
1073: } // end TapePrepare()
1074:
1075: NTSTATUS
1076: TapeReadWrite(
1077: IN PDEVICE_OBJECT DeviceObject,
1078: IN PIRP Irp
1079: )
1080:
1081: /*++
1082:
1083: Routine Description:
1084:
1085: This routine builds SRBs and CDBs for read and write requests to 4MM DAT
1086: devices.
1087:
1088: Arguments:
1089:
1090: DeviceObject
1091: Irp
1092:
1093: Return Value:
1094:
1095: Returns STATUS_PENDING.
1096:
1097: --*/
1098:
1099: {
1100: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1101: PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
1102: PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
1103: PSCSI_REQUEST_BLOCK srb;
1104: PCDB cdb;
1105: KIRQL currentIrql;
1106: ULONG transferBlocks;
1107: LARGE_INTEGER startingOffset =
1108: currentIrpStack->Parameters.Read.ByteOffset;
1109:
1110: //
1111: // Allocate an Srb.
1112: //
1113:
1114: if (deviceExtension->SrbZone != NULL &&
1115: (srb = ExInterlockedAllocateFromZone(
1116: deviceExtension->SrbZone,
1117: deviceExtension->SrbZoneSpinLock)) != NULL) {
1118:
1119: srb->SrbFlags = SRB_FLAGS_ALLOCATED_FROM_ZONE;
1120:
1121: } else {
1122:
1123: //
1124: // Allocate Srb from non-paged pool.
1125: // This call must succeed.
1126: //
1127:
1128: srb = ExAllocatePool(NonPagedPoolMustSucceed, SCSI_REQUEST_BLOCK_SIZE);
1129:
1130: srb->SrbFlags = 0;
1131:
1132: }
1133:
1134: //
1135: // Write length to SRB.
1136: //
1137:
1138: srb->Length = SCSI_REQUEST_BLOCK_SIZE;
1139:
1140: //
1141: // Set up IRP Address.
1142: //
1143:
1144: srb->OriginalRequest = Irp;
1145:
1146: //
1147: // Set up target id and logical unit number.
1148: //
1149:
1150: srb->PathId = deviceExtension->PathId;
1151: srb->TargetId = deviceExtension->TargetId;
1152: srb->Lun = deviceExtension->Lun;
1153:
1154:
1155: srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
1156:
1157: srb->DataBuffer = MmGetMdlVirtualAddress(Irp->MdlAddress);
1158:
1159: //
1160: // Save byte count of transfer in SRB Extension.
1161: //
1162:
1163: srb->DataTransferLength = currentIrpStack->Parameters.Read.Length;
1164:
1165: //
1166: // Indicate auto request sense by specifying buffer and size.
1167: //
1168:
1169: srb->SenseInfoBuffer = deviceExtension->SenseData;
1170:
1171: srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
1172:
1173: //
1174: // Initialize the queue actions field.
1175: //
1176:
1177: srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
1178:
1179: //
1180: // Indicate auto request sense by specifying buffer and size.
1181: //
1182:
1183: srb->SenseInfoBuffer = deviceExtension->SenseData;
1184:
1185: srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
1186:
1187: //
1188: // Set timeout value in seconds.
1189: //
1190:
1191: srb->TimeOutValue = deviceExtension->TimeOutValue;
1192:
1193: //
1194: // Zero statuses.
1195: //
1196:
1197: srb->SrbStatus = srb->ScsiStatus = 0;
1198:
1199: srb->NextSrb = 0;
1200:
1201: //
1202: // Indicate that 6-byte CDB's will be used.
1203: //
1204:
1205: srb->CdbLength = CDB6GENERIC_LENGTH;
1206:
1207: //
1208: // Fill in CDB fields.
1209: //
1210:
1211: cdb = (PCDB)srb->Cdb;
1212:
1213: //
1214: // Zero CDB in SRB.
1215: //
1216:
1217: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1218:
1219: //
1220: // Since we are writing fixed block mode, normalize transfer count
1221: // to number of blocks.
1222: //
1223:
1224: transferBlocks =
1225: currentIrpStack->Parameters.Read.Length >> deviceExtension->SectorShift;
1226:
1227: //
1228: // Set up transfer length
1229: //
1230:
1231: cdb->CDB6READWRITETAPE.TransferLenMSB = (UCHAR)((transferBlocks >> 16) & 0xff);
1232: cdb->CDB6READWRITETAPE.TransferLen = (UCHAR)((transferBlocks >> 8) & 0xff);
1233: cdb->CDB6READWRITETAPE.TransferLenLSB = (UCHAR)(transferBlocks & 0xff);
1234:
1235: //
1236: // Tell the python we are in fixed block mode
1237: //
1238:
1239: cdb->CDB6READWRITETAPE.VendorSpecific = 1;
1240:
1241: //
1242: // Set transfer direction flag and Cdb command.
1243: //
1244:
1245: if (currentIrpStack->MajorFunction == IRP_MJ_READ) {
1246:
1247: DebugPrint((3, "TapeRequest: Read Command\n"));
1248:
1249: srb->SrbFlags = SRB_FLAGS_DATA_IN;
1250: cdb->CDB6READWRITETAPE.OperationCode = SCSIOP_READ6;
1251:
1252: } else {
1253:
1254: DebugPrint((3, "TapeRequest: Write Command\n"));
1255:
1256: srb->SrbFlags = SRB_FLAGS_DATA_OUT;
1257: cdb->CDB6READWRITETAPE.OperationCode = SCSIOP_WRITE6;
1258: }
1259:
1260: //
1261: // Or in the default flags from the device object.
1262: //
1263:
1264: srb->SrbFlags |= deviceExtension->SrbFlags;
1265:
1266: //
1267: // Set up major SCSI function.
1268: //
1269:
1270: nextIrpStack->MajorFunction = IRP_MJ_SCSI;
1271:
1272: //
1273: // Save SRB address in next stack for port driver.
1274: //
1275:
1276: nextIrpStack->Parameters.Scsi.Srb = srb;
1277:
1278: //
1279: // Save retry count in current IRP stack.
1280: //
1281:
1282: currentIrpStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;
1283:
1284: //
1285: // Set up IoCompletion routine address.
1286: //
1287:
1288: IoSetCompletionRoutine(Irp,
1289: ScsiClassIoComplete,
1290: srb,
1291: TRUE,
1292: TRUE,
1293: FALSE);
1294:
1295: return STATUS_PENDING;
1296:
1297: } // end TapeReadWrite()
1298:
1299: NTSTATUS
1300: TapeSetDriveParameters(
1301: IN PDEVICE_OBJECT DeviceObject,
1302: IN PIRP Irp
1303: )
1304:
1305: /*++
1306: Routine Description:
1307:
1308: This routine enables/disables reporting of setmarks.
1309:
1310: Arguments:
1311:
1312: DeviceObject
1313: Irp
1314:
1315: Return Value:
1316:
1317: NTSTATUS
1318:
1319: --*/
1320:
1321: {
1322: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1323: PTAPE_SET_DRIVE_PARAMETERS tapeSetDriveParams = Irp->AssociatedIrp.SystemBuffer;
1324: PMODE_DEVICE_CONFIG_PAGE buffer;
1325: SCSI_REQUEST_BLOCK srb;
1326: PCDB cdb = (PCDB)srb.Cdb;
1327: NTSTATUS status;
1328: PMODE_DATA_COMPRESS_PAGE dcbuff;
1329:
1330: DebugPrint((3,"TapeIoControl: Set Tape Drive Parameters\n"));
1331:
1332: //
1333: // Zero CDB in SRB on stack.
1334: //
1335:
1336: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1337:
1338: srb.CdbLength = CDB6GENERIC_LENGTH;
1339:
1340: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1341:
1342: //
1343: // Set timeout value.
1344: //
1345:
1346: srb.TimeOutValue = deviceExtension->TimeOutValue;
1347:
1348: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_DEVICE_CONFIG_PAGE);
1349: cdb->MODE_SENSE.Dbd = SETBITON;
1350: cdb->MODE_SENSE.PageCode = MODE_PAGE_DEVICE_CONFIG;
1351:
1352: buffer = ExAllocatePool(NonPagedPoolCacheAligned,
1353: sizeof(MODE_DEVICE_CONFIG_PAGE));
1354:
1355: if (!buffer) {
1356: return STATUS_INSUFFICIENT_RESOURCES;
1357: }
1358:
1359: RtlZeroMemory(buffer, sizeof(MODE_DEVICE_CONFIG_PAGE));
1360:
1361: status = ScsiClassSendSrbSynchronous(DeviceObject,
1362: &srb,
1363: buffer,
1364: sizeof( MODE_DEVICE_CONFIG_PAGE ),
1365: FALSE);
1366:
1367: if (!NT_SUCCESS(status)) {
1368: ExFreePool(buffer);
1369: return status;
1370: }
1371:
1372: //
1373: // Zero CDB in SRB on stack.
1374: //
1375:
1376: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1377:
1378: srb.CdbLength = CDB6GENERIC_LENGTH;
1379:
1380: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
1381:
1382: //
1383: // Set timeout value.
1384: //
1385:
1386: srb.TimeOutValue = deviceExtension->TimeOutValue;
1387:
1388: cdb->MODE_SELECT.ParameterListLength = sizeof(MODE_DEVICE_CONFIG_PAGE);
1389: cdb->MODE_SELECT.PFBit = 1;
1390:
1391: buffer->ParameterListHeader.ModeDataLength = 0;
1392: buffer->ParameterListHeader.MediumType = 0;
1393: buffer->ParameterListHeader.DeviceSpecificParameter = 0x10;
1394: buffer->ParameterListHeader.BlockDescriptorLength = 0;
1395:
1396: buffer->DeviceConfigPage.PageCode = MODE_PAGE_DEVICE_CONFIG;
1397: buffer->DeviceConfigPage.PageLength = 0x0E;
1398:
1399: if (tapeSetDriveParams->ReportSetmarks) {
1400: buffer->DeviceConfigPage.RSmk = SETBITON;
1401: } else {
1402: buffer->DeviceConfigPage.RSmk = SETBITOFF;
1403: }
1404:
1405: status = ScsiClassSendSrbSynchronous(DeviceObject,
1406: &srb,
1407: buffer,
1408: sizeof( MODE_DEVICE_CONFIG_PAGE ),
1409: TRUE);
1410:
1411: ExFreePool(buffer);
1412:
1413: if (!NT_SUCCESS(status)) {
1414: return status;
1415: }
1416:
1417: //
1418: // Zero CDB in SRB on stack.
1419: //
1420:
1421: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1422:
1423: srb.CdbLength = CDB6GENERIC_LENGTH;
1424:
1425: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1426:
1427: //
1428: // Set timeout value.
1429: //
1430:
1431: srb.TimeOutValue = deviceExtension->TimeOutValue;
1432:
1433: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_DATA_COMPRESS_PAGE);
1434: cdb->MODE_SENSE.Dbd = SETBITON;
1435: cdb->MODE_SENSE.PageCode = MODE_PAGE_DATA_COMPRESS;
1436:
1437: dcbuff = ExAllocatePool(NonPagedPoolCacheAligned,
1438: sizeof(MODE_DATA_COMPRESS_PAGE));
1439:
1440: if (!dcbuff) {
1441: return STATUS_INSUFFICIENT_RESOURCES;
1442: }
1443:
1444: RtlZeroMemory(dcbuff, sizeof(MODE_DATA_COMPRESS_PAGE));
1445:
1446: status = ScsiClassSendSrbSynchronous(DeviceObject,
1447: &srb,
1448: dcbuff,
1449: sizeof( MODE_DATA_COMPRESS_PAGE ),
1450: FALSE);
1451:
1452: if (!NT_SUCCESS(status) && (status != STATUS_INVALID_DEVICE_REQUEST)) {
1453: ExFreePool(dcbuff);
1454: return status;
1455: }
1456:
1457: if (NT_SUCCESS(status) && dcbuff->DataCompressPage.DCC == 1) {
1458: //
1459: // Zero CDB in SRB on stack.
1460: //
1461:
1462: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1463:
1464: srb.CdbLength = CDB6GENERIC_LENGTH;
1465:
1466: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
1467:
1468: //
1469: // Set timeout value.
1470: //
1471:
1472: srb.TimeOutValue = deviceExtension->TimeOutValue;
1473:
1474: cdb->MODE_SELECT.ParameterListLength = sizeof(MODE_DATA_COMPRESS_PAGE);
1475: cdb->MODE_SELECT.PFBit = 1;
1476:
1477: dcbuff->ParameterListHeader.ModeDataLength = 0;
1478: dcbuff->ParameterListHeader.MediumType = 0;
1479: dcbuff->ParameterListHeader.DeviceSpecificParameter = 0x10;
1480: dcbuff->ParameterListHeader.BlockDescriptorLength = 0;
1481:
1482: dcbuff->DataCompressPage.PageCode = MODE_PAGE_DATA_COMPRESS;
1483: dcbuff->DataCompressPage.PageLength = 0x0E;
1484:
1485: if (tapeSetDriveParams->Compression) {
1486: dcbuff->DataCompressPage.DCE = SETBITON;
1487: } else {
1488: dcbuff->DataCompressPage.DCE = SETBITOFF;
1489: }
1490:
1491: status = ScsiClassSendSrbSynchronous(DeviceObject,
1492: &srb,
1493: dcbuff,
1494: sizeof( MODE_DATA_COMPRESS_PAGE ),
1495: TRUE);
1496: } else if (status == STATUS_INVALID_DEVICE_REQUEST) {
1497: status = STATUS_SUCCESS;
1498: }
1499:
1500: ExFreePool(dcbuff);
1501:
1502: return status;
1503:
1504: } // end TapeSetDriveParameters()
1505:
1506:
1507: NTSTATUS
1508: TapeSetMediaParameters(
1509: IN PDEVICE_OBJECT DeviceObject,
1510: IN PIRP Irp
1511: )
1512:
1513: /*++
1514: Routine Description:
1515:
1516: This routine sets the fixed-length logical block size or variable-length
1517: block mode (if the block size is 0).
1518:
1519: Arguments:
1520:
1521: DeviceObject
1522: Irp
1523:
1524: Return Value:
1525:
1526: NTSTATUS
1527:
1528: --*/
1529:
1530: {
1531: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1532: PTAPE_SET_MEDIA_PARAMETERS tapeSetMediaParams = Irp->AssociatedIrp.SystemBuffer;
1533: PMODE_PARM_READ_WRITE_DATA buffer;
1534: SCSI_REQUEST_BLOCK srb;
1535: PCDB cdb = (PCDB)srb.Cdb;
1536: NTSTATUS status;
1537:
1538: DebugPrint((3,"TapeIoControl: Set Tape Media Parameters \n"));
1539:
1540: //
1541: // Zero CDB in SRB on stack.
1542: //
1543:
1544: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1545:
1546: srb.CdbLength = CDB6GENERIC_LENGTH;
1547:
1548: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
1549:
1550: //
1551: // Set timeout value.
1552: //
1553:
1554: srb.TimeOutValue = deviceExtension->TimeOutValue;
1555:
1556: cdb->MODE_SELECT.ParameterListLength = sizeof(MODE_PARM_READ_WRITE_DATA);
1557: cdb->MODE_SELECT.PFBit = 1;
1558:
1559: buffer = ExAllocatePool(NonPagedPoolCacheAligned,
1560: sizeof(MODE_PARM_READ_WRITE_DATA));
1561:
1562: if (!buffer) {
1563: return STATUS_INSUFFICIENT_RESOURCES;
1564: }
1565:
1566: RtlZeroMemory(buffer, sizeof(MODE_PARM_READ_WRITE_DATA));
1567:
1568: buffer->ParameterListHeader.DeviceSpecificParameter = 0x10;
1569: buffer->ParameterListHeader.BlockDescriptorLength = MODE_BLOCK_DESC_LENGTH;
1570:
1571: buffer->ParameterListBlock.BlockLength[0] =
1572: ((tapeSetMediaParams->BlockSize >> 16) & 0xFF);
1573: buffer->ParameterListBlock.BlockLength[1] =
1574: ((tapeSetMediaParams->BlockSize >> 8) & 0xFF);
1575: buffer->ParameterListBlock.BlockLength[2] =
1576: (tapeSetMediaParams->BlockSize & 0xFF);
1577:
1578: status = ScsiClassSendSrbSynchronous(DeviceObject,
1579: &srb,
1580: buffer,
1581: sizeof( MODE_PARM_READ_WRITE_DATA ),
1582: TRUE);
1583:
1584: ExFreePool(buffer);
1585:
1586: return status;
1587:
1588: } // end TapeSetMediaParameters()
1589:
1590:
1591: NTSTATUS
1592: TapeSetPosition(
1593: IN PDEVICE_OBJECT DeviceObject,
1594: IN PIRP Irp
1595: )
1596:
1597: /*++
1598: Routine Description:
1599:
1600: This routine sets the position of the tape.
1601:
1602: Arguments:
1603:
1604: DeviceObject
1605: Irp
1606:
1607: Return Value:
1608:
1609: NTSTATUS
1610:
1611: --*/
1612:
1613: {
1614: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1615: PTAPE_DATA tapeData = (PTAPE_DATA)(deviceExtension + 1);
1616: PTAPE_SET_POSITION tapeSetPosition = Irp->AssociatedIrp.SystemBuffer;
1617: SCSI_REQUEST_BLOCK srb;
1618: PCDB cdb = (PCDB)srb.Cdb;
1619: NTSTATUS status;
1620:
1621: if (tapeSetPosition->Immediate) {
1622: switch (tapeSetPosition->Method) {
1623: case TAPE_REWIND:
1624: case TAPE_ABSOLUTE_BLOCK:
1625: case TAPE_LOGICAL_BLOCK:
1626: break;
1627:
1628: case TAPE_SPACE_END_OF_DATA:
1629: case TAPE_SPACE_RELATIVE_BLOCKS:
1630: case TAPE_SPACE_FILEMARKS:
1631: case TAPE_SPACE_SEQUENTIAL_FMKS:
1632: case TAPE_SPACE_SETMARKS:
1633: case TAPE_SPACE_SEQUENTIAL_SMKS:
1634: default:
1635: return STATUS_NOT_IMPLEMENTED;
1636: }
1637: }
1638:
1639: //
1640: // Zero CDB in SRB on stack.
1641: //
1642:
1643: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1644:
1645: //
1646: // Set timeout value.
1647: //
1648:
1649: srb.TimeOutValue = deviceExtension->TimeOutValue;
1650:
1651: srb.CdbLength = CDB6GENERIC_LENGTH;
1652:
1653: //
1654: // Set immediate bit if indicated.
1655: //
1656:
1657: cdb->CDB6GENERIC.Immediate = tapeSetPosition->Immediate;
1658:
1659: switch (tapeSetPosition->Method) {
1660: case TAPE_REWIND:
1661: DebugPrint((3,"TapeIoControl: Rewind Tape\n"));
1662: cdb->CDB6GENERIC.OperationCode = SCSIOP_REWIND;
1663:
1664: break;
1665:
1666: case TAPE_ABSOLUTE_BLOCK:
1667: DebugPrint((3,"TapeIoControl: Position Tape to an Absolute Block\n"));
1668:
1669: srb.TimeOutValue = 360;
1670:
1671: cdb->CDB6GENERIC.OperationCode = SCSIOP_SEEK_BLOCK;
1672:
1673: cdb->CDB6GENERIC.CommandUniqueBytes[0] =
1674: ((tapeSetPosition->Offset.LowPart >> 16) & 0xFF);
1675: cdb->CDB6GENERIC.CommandUniqueBytes[1] =
1676: ((tapeSetPosition->Offset.LowPart >> 8) & 0xFF);
1677: cdb->CDB6GENERIC.CommandUniqueBytes[2] =
1678: (tapeSetPosition->Offset.LowPart & 0xFF);
1679: break;
1680:
1681: case TAPE_LOGICAL_BLOCK:
1682: DebugPrint((3,"TapeIoControl: Position Tape to a Logical Block\n"));
1683:
1684: srb.TimeOutValue = 360;
1685:
1686: cdb->LOCATE.OperationCode = SCSIOP_LOCATE;
1687:
1688: srb.CdbLength = CDB10GENERIC_LENGTH;
1689:
1690: if ((tapeSetPosition->Partition != (ULONG)0) &&
1691: (tapeSetPosition->Partition != (ULONG)tapeData->CurrentPartition) &&
1692: gb_PartitionCount > 1) {
1693: cdb->LOCATE.CPBit = SETBITON;
1694: cdb->LOCATE.Partition =
1695: tapeSetPosition->Partition - 1;
1696: }
1697: cdb->LOCATE.LogicalBlockAddress[0] =
1698: ((tapeSetPosition->Offset.LowPart >> 24) & 0xFF);
1699: cdb->LOCATE.LogicalBlockAddress[1] =
1700: ((tapeSetPosition->Offset.LowPart >> 16) & 0xFF);
1701: cdb->LOCATE.LogicalBlockAddress[2] =
1702: ((tapeSetPosition->Offset.LowPart >> 8) & 0xFF);
1703: cdb->LOCATE.LogicalBlockAddress[3] =
1704: (tapeSetPosition->Offset.LowPart & 0xFF);
1705:
1706: break;
1707:
1708: case TAPE_SPACE_END_OF_DATA:
1709: DebugPrint((3,"TapeIoControl: Position Tape to End-of-Data\n"));
1710: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
1711: cdb->SPACE_TAPE_MARKS.Code = 3;
1712: break;
1713:
1714: case TAPE_SPACE_RELATIVE_BLOCKS:
1715: DebugPrint((3,"TapeIoControl: Position Tape by Spacing Blocks\n"));
1716: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
1717: cdb->SPACE_TAPE_MARKS.Code = 0;
1718: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
1719: ((tapeSetPosition->Offset.LowPart >> 16) & 0xFF);
1720: cdb->SPACE_TAPE_MARKS.NumMarks =
1721: ((tapeSetPosition->Offset.LowPart >> 8) & 0xFF);
1722: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
1723: (tapeSetPosition->Offset.LowPart & 0xFF);
1724: break;
1725:
1726: case TAPE_SPACE_FILEMARKS:
1727: DebugPrint((3,"TapeIoControl: Position Tape by Spacing Filemarks\n"));
1728: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
1729: cdb->SPACE_TAPE_MARKS.Code = 1;
1730: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
1731: ((tapeSetPosition->Offset.LowPart >> 16) & 0xFF);
1732: cdb->SPACE_TAPE_MARKS.NumMarks =
1733: ((tapeSetPosition->Offset.LowPart >> 8) & 0xFF);
1734: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
1735: (tapeSetPosition->Offset.LowPart & 0xFF);
1736: break;
1737:
1738: case TAPE_SPACE_SEQUENTIAL_FMKS:
1739: DebugPrint((3,"TapeIoControl: Position Tape by Spacing Sequential Filemarks\n"));
1740: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
1741: cdb->SPACE_TAPE_MARKS.Code = 2;
1742: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
1743: ((tapeSetPosition->Offset.LowPart >> 16) & 0xFF);
1744: cdb->SPACE_TAPE_MARKS.NumMarks =
1745: ((tapeSetPosition->Offset.LowPart >> 8) & 0xFF);
1746: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
1747: (tapeSetPosition->Offset.LowPart & 0xFF);
1748: break;
1749:
1750: case TAPE_SPACE_SETMARKS:
1751: DebugPrint((3,"TapeIoControl: Position Tape by Spacing Setmarks\n"));
1752: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
1753: cdb->SPACE_TAPE_MARKS.Code = 4;
1754: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
1755: ((tapeSetPosition->Offset.LowPart >> 16) & 0xFF);
1756: cdb->SPACE_TAPE_MARKS.NumMarks =
1757: ((tapeSetPosition->Offset.LowPart >> 8) & 0xFF);
1758: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
1759: (tapeSetPosition->Offset.LowPart & 0xFF);
1760: break;
1761:
1762: case TAPE_SPACE_SEQUENTIAL_SMKS:
1763: default:
1764: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
1765: return STATUS_INVALID_DEVICE_REQUEST;
1766: }
1767:
1768: status = ScsiClassSendSrbSynchronous(DeviceObject,
1769: &srb,
1770: NULL,
1771: 0,
1772: FALSE);
1773:
1774: if (NT_SUCCESS(status)) {
1775: switch (tapeSetPosition->Method) {
1776: case TAPE_LOGICAL_BLOCK:
1777: tapeData->CurrentPartition = tapeSetPosition->Partition;
1778: break;
1779: }
1780: }
1781:
1782: return status;
1783:
1784: } // end TapeSetPosition()
1785:
1786:
1787: BOOLEAN
1788: TapeVerifyInquiry(
1789: IN PSCSI_INQUIRY_DATA LunInfo
1790: )
1791:
1792: /*++
1793: Routine Description:
1794:
1795: This routine determines if the driver should claim this device.
1796:
1797: Arguments:
1798:
1799: LunInfo
1800:
1801: Return Value:
1802:
1803: TRUE - driver should claim this device.
1804: FALSE - driver should not claim this device.
1805:
1806: --*/
1807:
1808: {
1809: PINQUIRYDATA inquiryData;
1810:
1811: DebugPrint((3,"TapeIoControl: Verify Tape Inquiry Data\n"));
1812:
1813: inquiryData = (PVOID)LunInfo->InquiryData;
1814:
1815: //
1816: // Determine, from the Product ID field in the
1817: // inquiry data, whether or not to "claim" this drive.
1818: //
1819:
1820: if (WhichIsIt(inquiryData)) {
1821:
1822: RtlMoveMemory(gb_VendorId,inquiryData->VendorId,8);
1823: RtlMoveMemory(gb_ProductId,inquiryData->ProductId,16);
1824: return TRUE;
1825:
1826: }
1827: return FALSE;
1828:
1829: } // end TapeVerifyInquiry()
1830:
1831:
1832: NTSTATUS
1833: TapeWriteMarks(
1834: IN PDEVICE_OBJECT DeviceObject,
1835: IN PIRP Irp
1836: )
1837:
1838: /*++
1839: Routine Description:
1840:
1841: This routine writes tapemarks on the tape.
1842:
1843: Arguments:
1844:
1845: DeviceObject
1846: Irp
1847:
1848: Return Value:
1849:
1850: NTSTATUS
1851:
1852: --*/
1853:
1854: {
1855: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1856: PTAPE_WRITE_MARKS tapeWriteMarks = Irp->AssociatedIrp.SystemBuffer;
1857: SCSI_REQUEST_BLOCK srb;
1858: PCDB cdb = (PCDB)srb.Cdb;
1859: NTSTATUS status;
1860:
1861: //
1862: // Zero CDB in SRB on stack.
1863: //
1864:
1865: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1866:
1867: srb.CdbLength = CDB6GENERIC_LENGTH;
1868:
1869: cdb->WRITE_TAPE_MARKS.OperationCode = SCSIOP_WRITE_FILEMARKS;
1870:
1871: cdb->WRITE_TAPE_MARKS.TransferLength[0] =
1872: ((tapeWriteMarks->Count >> 16) & 0xFF);
1873:
1874: cdb->WRITE_TAPE_MARKS.TransferLength[1] =
1875: ((tapeWriteMarks->Count >> 8) & 0xFF);
1876:
1877: cdb->WRITE_TAPE_MARKS.TransferLength[2] =
1878: (tapeWriteMarks->Count & 0xFF);
1879:
1880: //
1881: // Set timeout value.
1882: //
1883:
1884: srb.TimeOutValue = deviceExtension->TimeOutValue;
1885:
1886: switch (tapeWriteMarks->Type) {
1887: case TAPE_SETMARKS:
1888: DebugPrint((3,"TapeIoControl: Write Setmarks to Tape\n"));
1889: cdb->WRITE_TAPE_MARKS.WriteSetMarks = SETBITON;
1890: break;
1891:
1892: case TAPE_FILEMARKS:
1893: DebugPrint((3,"TapeIoControl: Write Filemarks to Tape\n"));
1894: break;
1895:
1896: case TAPE_SHORT_FILEMARKS:
1897: case TAPE_LONG_FILEMARKS:
1898: default:
1899: DebugPrint((3,"TapeIoControl: Tape Operation Not Supported\n"));
1900: return STATUS_INVALID_DEVICE_REQUEST;
1901: }
1902:
1903: //
1904: // Set immediate bit if indicated.
1905: //
1906:
1907: cdb->WRITE_TAPE_MARKS.Immediate = tapeWriteMarks->Immediate;
1908:
1909:
1910: srb.CdbLength = CDB6GENERIC_LENGTH;
1911:
1912: status = ScsiClassSendSrbSynchronous(DeviceObject,
1913: &srb,
1914: NULL,
1915: 0,
1916: FALSE);
1917:
1918: return status;
1919:
1920: } // end TapeWriteMarks()
1921:
1922:
1923: static
1924: ULONG
1925: WhichIsIt(
1926: IN PINQUIRYDATA InquiryData
1927: )
1928:
1929: /*++
1930: Routine Description:
1931:
1932: This routine determines a drive's identity from the Product ID field
1933: in its inquiry data.
1934:
1935: Arguments:
1936:
1937: InquiryData (from an Inquiry command)
1938:
1939: Return Value:
1940:
1941: driveID
1942:
1943: --*/
1944:
1945: {
1946: if (RtlCompareMemory(InquiryData->VendorId,"ARCHIVE ",8) == 8) {
1947:
1948: if (RtlCompareMemory(InquiryData->ProductId,"Python",6) == 6) {
1949: return ARCHIVE_PYTHON;
1950: }
1951:
1952: }
1953:
1954: if (RtlCompareMemory(InquiryData->VendorId,"DEC ",8) == 8) {
1955:
1956: if (RtlCompareMemory(InquiryData->ProductId,"TLZ06",5) == 5) {
1957: return DEC_TLZ06;
1958: }
1959:
1960: }
1961:
1962: if (RtlCompareMemory(InquiryData->VendorId,"EXABYTE ",8) == 8) {
1963:
1964: if (RtlCompareMemory(InquiryData->ProductId,"EXB-4200 ",9) == 9) {
1965: return EXABYTE_4200;
1966: }
1967:
1968: if (RtlCompareMemory(InquiryData->ProductId,"EXB-4200c",9) == 9) {
1969: return EXABYTE_4200C;
1970: }
1971:
1972: }
1973:
1974: if (RtlCompareMemory(InquiryData->VendorId,"HP ",8) == 8) {
1975:
1976: if (RtlCompareMemory(InquiryData->ProductId,"HP35470A",8) == 8) {
1977: return HP_35470A;
1978: }
1979:
1980: if (RtlCompareMemory(InquiryData->ProductId,"HP35480A",8) == 8) {
1981: return HP_35480A;
1982: }
1983:
1984: if (RtlCompareMemory(InquiryData->ProductId,"IBM35480A",9) == 9) {
1985: return HP_IBM35480A;
1986: }
1987:
1988: }
1989:
1990: if (RtlCompareMemory(InquiryData->VendorId,"WangDAT ",8) == 8) {
1991:
1992: if (RtlCompareMemory(InquiryData->ProductId,"Model 1300",10) == 10) {
1993: return WANGDAT_1300;
1994: }
1995:
1996: if (RtlCompareMemory(InquiryData->ProductId,"Model 3100",10) == 10) {
1997: return WANGDAT_3100;
1998: }
1999:
2000: if (RtlCompareMemory(InquiryData->ProductId,"Model 3200",10) == 10) {
2001: return WANGDAT_3200;
2002: }
2003:
2004: }
2005:
2006: return 0;
2007: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.