![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to exabyte2.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 / exabyte2|
Return to exabyte2.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / scsitape / exabyte2 |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: exabyte2.c
8:
9: Abstract:
10:
11: This module contains the device-specific routines for the Exabyte
12: EXB-8500 tape drive.
13:
14: Author:
15:
16: Mike Glass
17: Hunter Small (Maynard)
18: Lori Brown (Maynard)
19: Chris Hugh Sam (Maynard)
20:
21: Environment:
22:
23: kernel mode only
24:
25: Revision History:
26:
27: --*/
28:
29: #include "ntddk.h"
30: #include "tape.h"
31:
32: //
33: // Internal (module wide) defines that symbolize
34: // density codes returned by/from EXB-8500 drives
35: //
36: #define EXB_XX00 0 // undetermined tape recording density
37: #define EXB_8200 20 // 0x14 // EXB-8200 tape recording density
38: #define EXB_8500 133 // 0x85 // EXB-8500 tape recording density
39:
40: //
41: // Internal (module wide) defines that symbolize
42: // the 8mm drives supported by this module.
43: //
44: #define EXABYTE_8500 1 // aka the Maynard 5000
45: #define EXABYTE_8505 2 // An Exabyte 8500 with data compresion
46: #define IBM_8505 3 // OEM Exabyte 8500 with data compresion
47:
48: //
49: // Define EXABYTE vendor unique mode select/sense information.
50: //
51:
52: #define EXABYTE_MODE_LENGTH 0x11
53: #define EXABYTE_CARTRIDGE 0x80
54: #define EXABYTE_NO_DATA_DISCONNECT 0x20
55: #define EXABYTE_NO_BUSY_ENABLE 0x08
56: #define EXABYTE_EVEN_BYTE_DISCONNECT 0x04
57: #define EXABYTE_PARITY_ENABLE 0x02
58: #define EXABYTE_NO_AUTO_LOAD 0X01
59:
60: //
61: // Function prototype(s) for internal function(s)
62: //
63: static ULONG WhichIsIt(IN PINQUIRYDATA InquiryData);
64:
65:
66: NTSTATUS
67: TapeCreatePartition(
68: IN PDEVICE_OBJECT DeviceObject,
69: IN PIRP Irp
70: )
71:
72: /*++
73: Routine Description:
74:
75: This routine would partition the tape if the drive was able to do
76: so: because the drive cannot do so, this routine always returns a
77: STATUS_NOT_IMPLEMENTED status.
78:
79: Arguments:
80:
81: DeviceObject
82: Irp
83:
84: Return Value:
85:
86: NTSTATUS
87:
88: --*/
89:
90: {
91: DebugPrint((3,"TapeCreatePartition: Enter routine\n"));
92: DebugPrint((1,"TapeCreatePartition: operation not supported\n"));
93: return STATUS_NOT_IMPLEMENTED;
94:
95: } // end TapeCreatePartition()
96:
97:
98: NTSTATUS
99: TapeErase(
100: IN PDEVICE_OBJECT DeviceObject,
101: IN PIRP Irp
102: )
103:
104: /*++
105: Routine Description:
106:
107: This routine will erase to EOT from the "current position" on tape;
108: i.e., tape will be erased to EOT from the point on tape at which the
109: tape is positioned at the time of entry herein.
110:
111: Arguments:
112:
113: DeviceObject
114: Irp
115:
116: Return Value:
117:
118: NTSTATUS
119:
120: --*/
121:
122: {
123: PTAPE_ERASE tapeErase = Irp->AssociatedIrp.SystemBuffer;
124: SCSI_REQUEST_BLOCK srb;
125: PCDB cdb = (PCDB)srb.Cdb;
126: NTSTATUS status;
127:
128: DebugPrint((3,"TapeErase: Enter routine\n"));
129:
130: if (tapeErase->Immediate) {
131: switch (tapeErase->Type) {
132: case TAPE_ERASE_LONG:
133: DebugPrint((3,"TapeErase: immediate\n"));
134: break;
135:
136: case TAPE_ERASE_SHORT:
137: default:
138: DebugPrint((1,"TapeErase: EraseType, immediate -- operation not supported\n"));
139: return STATUS_NOT_IMPLEMENTED;
140: }
141: }
142:
143: switch (tapeErase->Type) {
144: case TAPE_ERASE_LONG:
145: DebugPrint((3,"TapeErase: long\n"));
146: break;
147:
148: case TAPE_ERASE_SHORT:
149: default:
150: DebugPrint((1,"TapeErase: EraseType -- operation not supported\n"));
151: return STATUS_NOT_IMPLEMENTED;
152: }
153:
154: //
155: // Zero CDB in SRB on stack.
156: //
157:
158: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
159:
160: //
161: // Prepare SCSI command (CDB)
162: //
163:
164: srb.CdbLength = CDB6GENERIC_LENGTH;
165:
166: cdb->ERASE.OperationCode = SCSIOP_ERASE;
167: cdb->ERASE.Immediate = tapeErase->Immediate;
168: cdb->ERASE.Long = SETBITON;
169:
170: //
171: // Set timeout value.
172: //
173:
174: srb.TimeOutValue = 18000;
175:
176: //
177: // Send SCSI command (CDB) to device
178: //
179:
180: DebugPrint((3,"TapeErase: SendSrb (erase)\n"));
181:
182: status = ScsiClassSendSrbSynchronous(DeviceObject,
183: &srb,
184: NULL,
185: 0,
186: FALSE);
187:
188: if (!NT_SUCCESS(status)) {
189: DebugPrint((1,"TapeErase: erase, SendSrb unsuccessful\n"));
190: }
191:
192: return status;
193:
194: } // end TapeErase()
195:
196:
197: VOID
198: TapeError(
199: PDEVICE_OBJECT DeviceObject,
200: PSCSI_REQUEST_BLOCK Srb,
201: NTSTATUS *Status,
202: BOOLEAN *Retry
203: )
204:
205: /*++
206:
207: Routine Description:
208:
209: When a request completes with error, the routine InterpretSenseInfo is
210: called to determine from the sense data whether the request should be
211: retried and what NT status to set in the IRP. Then this routine is called
212: for tape requests to handle tape-specific errors and update the nt status
213: and retry boolean.
214:
215: Arguments:
216:
217: DeviceObject - Supplies a pointer to the device object.
218:
219: Srb - Supplies a pointer to the failing Srb.
220:
221: Status - NT Status used to set the IRP's completion status.
222:
223: Retry - Indicates that this request should be retried.
224:
225: Return Value:
226:
227: None.
228:
229: --*/
230:
231: {
232: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
233: PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
234: NTSTATUS status = *Status;
235: BOOLEAN retry = *Retry;
236:
237: DebugPrint((3,"TapeError: Enter routine\n"));
238: DebugPrint((1,"TapeError: Status 0x%.8X, Retry %d\n", status, retry));
239: return;
240:
241: } // end TapeError()
242:
243:
244: NTSTATUS
245: TapeGetDriveParameters(
246: IN PDEVICE_OBJECT DeviceObject,
247: IN PIRP Irp
248: )
249:
250: /*++
251: Routine Description:
252:
253: This routine determines and returns the "drive parameters" of the
254: Exabyte 8500 tape drive associated with "DeviceObject". From time to
255: time, the drive paramater set of a given drive is variable. It will
256: change as drive operating characteristics change: e.g., tape media
257: type loaded, recording density of the media type loaded, etc.
258:
259: Arguments:
260:
261: DeviceObject
262: Irp
263:
264: Return Value:
265:
266: NTSTATUS
267:
268: --*/
269:
270: {
271: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
272: PTAPE_GET_DRIVE_PARAMETERS tapeGetDriveParams = Irp->AssociatedIrp.SystemBuffer;
273: PMODE_PARM_READ_WRITE_DATA modeParmBuffer;
274: PREAD_BLOCK_LIMITS_DATA blockLimits;
275: UCHAR densityCode;
276: SCSI_REQUEST_BLOCK srb;
277: PCDB cdb = (PCDB)srb.Cdb;
278: NTSTATUS status;
279:
280: DebugPrint((3,"TapeGetDriveParameters: Enter routine\n"));
281:
282: RtlZeroMemory(tapeGetDriveParams, sizeof(TAPE_GET_DRIVE_PARAMETERS));
283: Irp->IoStatus.Information = sizeof(TAPE_GET_DRIVE_PARAMETERS);
284:
285: modeParmBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
286: sizeof(MODE_PARM_READ_WRITE_DATA));
287:
288: if (!modeParmBuffer) {
289: DebugPrint((1,"TapeGetDriveParameters: insufficient resources (modeParmBuffer)\n"));
290: return STATUS_INSUFFICIENT_RESOURCES;
291: }
292:
293: RtlZeroMemory(modeParmBuffer, sizeof(MODE_PARM_READ_WRITE_DATA));
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->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
308: cdb->MODE_SENSE.AllocationLength = sizeof(MODE_PARM_READ_WRITE_DATA);
309:
310: //
311: // Set timeout value.
312: //
313:
314: srb.TimeOutValue = deviceExtension->TimeOutValue;
315:
316: //
317: // Send SCSI command (CDB) to device
318: //
319:
320: DebugPrint((3,"TapeGetDriveParameters: SendSrb (mode sense)\n"));
321:
322: status = ScsiClassSendSrbSynchronous(DeviceObject,
323: &srb,
324: modeParmBuffer,
325: sizeof(MODE_PARM_READ_WRITE_DATA),
326: FALSE);
327:
328: if (NT_SUCCESS(status)) {
329: densityCode = modeParmBuffer->ParameterListBlock.DensityCode;
330: }
331:
332: ExFreePool(modeParmBuffer);
333:
334: if (!NT_SUCCESS(status)) {
335: DebugPrint((1,"TapeGetDriveParameters: mode sense, SendSrb unsuccessful\n"));
336: return status;
337: }
338:
339: blockLimits = ExAllocatePool(NonPagedPoolCacheAligned,
340: sizeof(READ_BLOCK_LIMITS_DATA));
341:
342: if (!blockLimits) {
343: DebugPrint((1,"TapeGetDriveParameters: insufficient resources (blockLimits)\n"));
344: return STATUS_INSUFFICIENT_RESOURCES;
345: }
346:
347: RtlZeroMemory(blockLimits, sizeof(READ_BLOCK_LIMITS_DATA));
348:
349: //
350: // Zero CDB in SRB on stack.
351: //
352:
353: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
354:
355: //
356: // Prepare SCSI command (CDB)
357: //
358:
359: srb.CdbLength = CDB6GENERIC_LENGTH;
360:
361: cdb->CDB6GENERIC.OperationCode = SCSIOP_READ_BLOCK_LIMITS;
362:
363: //
364: // Set timeout value.
365: //
366:
367: srb.TimeOutValue = deviceExtension->TimeOutValue;
368:
369: //
370: // Send SCSI command (CDB) to device
371: //
372:
373: DebugPrint((3,"TapeGetDriveParameters: SendSrb (read block limits)\n"));
374:
375: status = ScsiClassSendSrbSynchronous(DeviceObject,
376: &srb,
377: blockLimits,
378: sizeof(READ_BLOCK_LIMITS_DATA),
379: FALSE);
380:
381: if (NT_SUCCESS(status)) {
382: tapeGetDriveParams->MaximumBlockSize = blockLimits->BlockMaximumSize[2];
383: tapeGetDriveParams->MaximumBlockSize += (blockLimits->BlockMaximumSize[1] << 8);
384: tapeGetDriveParams->MaximumBlockSize += (blockLimits->BlockMaximumSize[0] << 16);
385:
386: tapeGetDriveParams->MinimumBlockSize = blockLimits->BlockMinimumSize[1];
387: tapeGetDriveParams->MinimumBlockSize += (blockLimits->BlockMinimumSize[0] << 8);
388: }
389:
390: ExFreePool(blockLimits);
391:
392: if (!NT_SUCCESS(status)) {
393: return status;
394: }
395:
396: tapeGetDriveParams->ECC = 0;
397: tapeGetDriveParams->Compression = 0;
398: tapeGetDriveParams->DataPadding = 0;
399: tapeGetDriveParams->ReportSetmarks = 0;
400: tapeGetDriveParams->MaximumPartitionCount = 0;
401: tapeGetDriveParams->DefaultBlockSize = 1024;
402:
403: tapeGetDriveParams->FeaturesLow |=
404: TAPE_DRIVE_ERASE_LONG |
405: TAPE_DRIVE_ERASE_IMMEDIATE |
406: TAPE_DRIVE_FIXED_BLOCK |
407: TAPE_DRIVE_VARIABLE_BLOCK |
408: TAPE_DRIVE_WRITE_PROTECT |
409: TAPE_DRIVE_GET_ABSOLUTE_BLK |
410: TAPE_DRIVE_GET_LOGICAL_BLK;
411:
412: tapeGetDriveParams->FeaturesHigh |=
413: TAPE_DRIVE_LOAD_UNLOAD |
414: TAPE_DRIVE_LOCK_UNLOCK |
415: TAPE_DRIVE_REWIND_IMMEDIATE |
416: TAPE_DRIVE_SET_BLOCK_SIZE |
417: TAPE_DRIVE_LOAD_UNLD_IMMED |
418: TAPE_DRIVE_RELATIVE_BLKS |
419: TAPE_DRIVE_FILEMARKS |
420: TAPE_DRIVE_REVERSE_POSITION |
421: TAPE_DRIVE_WRITE_SHORT_FMKS |
422: TAPE_DRIVE_WRITE_LONG_FMKS |
423: TAPE_DRIVE_WRITE_MARK_IMMED |
424: TAPE_DRIVE_ABSOLUTE_BLK |
425: TAPE_DRIVE_ABS_BLK_IMMED |
426: TAPE_DRIVE_LOGICAL_BLK |
427: TAPE_DRIVE_LOG_BLK_IMMED |
428: TAPE_DRIVE_END_OF_DATA;
429:
430: tapeGetDriveParams->FeaturesHigh &= ~TAPE_DRIVE_HIGH_FEATURES;
431:
432: DebugPrint((3,"TapeGetDriveParameters: FeaturesLow == 0x%.8X\n",
433: tapeGetDriveParams->FeaturesLow));
434: DebugPrint((3,"TapeGetDriveParameters: FeaturesHigh == 0x%.8X\n",
435: tapeGetDriveParams->FeaturesHigh));
436:
437: return status;
438:
439: } // end TapeGetDriveParameters()
440:
441:
442: NTSTATUS
443: TapeGetMediaParameters(
444: IN PDEVICE_OBJECT DeviceObject,
445: IN PIRP Irp
446: )
447:
448: /*++
449: Routine Description:
450:
451: This routine determines and returns the "media parameters" of the
452: Exabyte 8500 tape drive associated with "DeviceObject". Tape media
453: must be present (loaded) in the drive for this function to return
454: "no error".
455:
456: Arguments:
457:
458: DeviceObject
459: Irp
460:
461: Return Value:
462:
463: NTSTATUS
464:
465: --*/
466:
467: {
468: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
469: PTAPE_GET_MEDIA_PARAMETERS tapeGetMediaParams = Irp->AssociatedIrp.SystemBuffer;
470: PMODE_PARM_READ_WRITE_DATA modeBuffer;
471: ULONG sectorShift;
472: SCSI_REQUEST_BLOCK srb;
473: PCDB cdb = (PCDB)srb.Cdb;
474: NTSTATUS status;
475:
476: DebugPrint((3,"TapeGetMediaParameters: Enter routine\n"));
477:
478: RtlZeroMemory(tapeGetMediaParams, sizeof(TAPE_GET_MEDIA_PARAMETERS));
479: Irp->IoStatus.Information = sizeof(TAPE_GET_MEDIA_PARAMETERS);
480:
481: //
482: // Zero CDB in SRB on stack.
483: //
484:
485: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
486:
487: //
488: // Prepare SCSI command (CDB)
489: //
490:
491: srb.CdbLength = CDB6GENERIC_LENGTH;
492:
493: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
494:
495: //
496: // Set timeout value.
497: //
498:
499: srb.TimeOutValue = deviceExtension->TimeOutValue;
500:
501: //
502: // Send SCSI command (CDB) to device
503: //
504:
505: DebugPrint((3,"TapeGetMediaParameters: SendSrb (test unit ready)\n"));
506:
507: status = ScsiClassSendSrbSynchronous(DeviceObject,
508: &srb,
509: NULL,
510: 0,
511: FALSE);
512:
513: if (!NT_SUCCESS(status)) {
514: DebugPrint((1,"TapeGetMediaParameters: test unit ready, SendSrb unsuccessful\n"));
515: return status;
516: }
517:
518: modeBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
519: EXABYTE_MODE_LENGTH);
520:
521: if (!modeBuffer) {
522: DebugPrint((1,"TapeGetMediaParameters: insufficient resources (modeBuffer)\n"));
523: return STATUS_INSUFFICIENT_RESOURCES;
524: }
525:
526: RtlZeroMemory(modeBuffer, EXABYTE_MODE_LENGTH);
527:
528: //
529: // Zero CDB in SRB on stack.
530: //
531:
532: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
533:
534: //
535: // Prepare SCSI command (CDB)
536: //
537:
538: srb.CdbLength = CDB6GENERIC_LENGTH;
539:
540: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
541: cdb->MODE_SENSE.AllocationLength = EXABYTE_MODE_LENGTH;
542:
543: //
544: // Set timeout value.
545: //
546:
547: srb.TimeOutValue = deviceExtension->TimeOutValue;
548:
549: //
550: // Send SCSI command (CDB) to device
551: //
552:
553: DebugPrint((3,"TapeGetMediaParameters: SendSrb (mode sense)\n"));
554:
555: status = ScsiClassSendSrbSynchronous(DeviceObject,
556: &srb,
557: modeBuffer,
558: EXABYTE_MODE_LENGTH,
559: FALSE);
560:
561: if (NT_SUCCESS(status)) {
562:
563: tapeGetMediaParams->BlockSize = modeBuffer->ParameterListBlock.BlockLength[2];
564: tapeGetMediaParams->BlockSize += (modeBuffer->ParameterListBlock.BlockLength[1] << 8);
565: tapeGetMediaParams->BlockSize += (modeBuffer->ParameterListBlock.BlockLength[0] << 16);
566:
567: WHICH_BIT(tapeGetMediaParams->BlockSize, sectorShift);
568: deviceExtension->DiskGeometry->BytesPerSector = tapeGetMediaParams->BlockSize;
569: deviceExtension->SectorShift = sectorShift;
570:
571: tapeGetMediaParams->WriteProtected =
572: ((modeBuffer->ParameterListHeader.DeviceSpecificParameter >> 7) & 0x01);
573:
574: //
575: // Set the even byte disconnect flag in the mode data. This is the
576: // first byte of the vendor unique data.
577: //
578:
579: *((PUCHAR)(modeBuffer+1)) |= EXABYTE_EVEN_BYTE_DISCONNECT;
580:
581: modeBuffer->ParameterListHeader.ModeDataLength = 0;
582: modeBuffer->ParameterListHeader.MediumType = 0;
583: modeBuffer->ParameterListHeader.DeviceSpecificParameter = 0x10;
584: modeBuffer->ParameterListBlock.DensityCode = 0;
585: modeBuffer->ParameterListBlock.NumberOfBlocks[0] = 0;
586: modeBuffer->ParameterListBlock.NumberOfBlocks[1] = 0;
587: modeBuffer->ParameterListBlock.NumberOfBlocks[2] = 0;
588: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
589:
590: ScsiClassSendSrbSynchronous(DeviceObject,
591: &srb,
592: modeBuffer,
593: EXABYTE_MODE_LENGTH,
594: TRUE);
595:
596:
597: } else {
598:
599: DebugPrint((1,"TapeGetMediaParameters: mode sense, SendSrb unsuccessful\n"));
600:
601: }
602:
603: ExFreePool(modeBuffer);
604:
605: return status;
606:
607: } // end TapeGetMediaParameters()
608:
609:
610: NTSTATUS
611: TapeGetPosition(
612: IN PDEVICE_OBJECT DeviceObject,
613: IN PIRP Irp
614: )
615:
616: /*++
617: Routine Description:
618:
619: This routine returns the current position of the tape.
620:
621: Arguments:
622:
623: DeviceObject
624: Irp
625:
626: Return Value:
627:
628: NTSTATUS
629:
630: --*/
631:
632: {
633: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
634: PTAPE_GET_POSITION tapeGetPosition = Irp->AssociatedIrp.SystemBuffer;
635: PTAPE_POSITION_DATA logicalBuffer;
636: ULONG type;
637: SCSI_REQUEST_BLOCK srb;
638: PCDB cdb = (PCDB)srb.Cdb;
639: NTSTATUS status;
640:
641: DebugPrint((3,"TapeGetPosition: Enter routine\n"));
642:
643: type = tapeGetPosition->Type;
644: RtlZeroMemory(tapeGetPosition, sizeof(TAPE_GET_POSITION));
645: Irp->IoStatus.Information = sizeof(TAPE_GET_POSITION);
646: tapeGetPosition->Type = type;
647:
648: switch (type) {
649: case TAPE_ABSOLUTE_POSITION:
650: case TAPE_LOGICAL_POSITION:
651: logicalBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
652: sizeof(TAPE_POSITION_DATA));
653:
654: if (!logicalBuffer) {
655: DebugPrint((1,"TapeGetPosition: insufficient resources (logicalBuffer)\n"));
656: return STATUS_INSUFFICIENT_RESOURCES;
657: }
658:
659: RtlZeroMemory(logicalBuffer, sizeof(TAPE_POSITION_DATA));
660:
661: //
662: // Zero CDB in SRB on stack.
663: //
664:
665: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
666:
667: //
668: // Prepare SCSI command (CDB)
669: //
670:
671: srb.CdbLength = CDB10GENERIC_LENGTH;
672:
673: cdb->READ_POSITION.Operation = SCSIOP_READ_POSITION;
674:
675: //
676: // Set timeout value.
677: //
678:
679: srb.TimeOutValue = deviceExtension->TimeOutValue;
680:
681: //
682: // Send SCSI command (CDB) to device
683: //
684:
685: DebugPrint((3,"TapeGetPosition: SendSrb (read position)\n"));
686:
687: status = ScsiClassSendSrbSynchronous(DeviceObject,
688: &srb,
689: logicalBuffer,
690: sizeof(TAPE_POSITION_DATA),
691: FALSE);
692:
693: if (NT_SUCCESS(status)) {
694:
695: if (logicalBuffer->BlockPositionUnsupported) {
696: DebugPrint((1,"TapeGetPosition: read position -- logical block position unsupported\n"));
697: ExFreePool(logicalBuffer);
698: return STATUS_INVALID_DEVICE_REQUEST;
699: }
700:
701: tapeGetPosition->Partition = 0;
702: tapeGetPosition->Offset.HighPart = 0;
703: REVERSE_BYTES((PFOUR_BYTE)&tapeGetPosition->Offset.LowPart,
704: (PFOUR_BYTE)logicalBuffer->FirstBlock);
705:
706: }
707:
708: ExFreePool(logicalBuffer);
709:
710: if (!NT_SUCCESS(status)) {
711: DebugPrint((1,"TapeGetPosition: read position, SendSrb unsuccessful\n"));
712: return status;
713: }
714:
715: break;
716:
717: default:
718: DebugPrint((1,"TapeGetPosition: PositionType -- operation not supported\n"));
719: return STATUS_NOT_IMPLEMENTED;
720: }
721:
722: return status;
723:
724: } // end TapeGetPosition()
725:
726:
727: NTSTATUS
728: TapeGetStatus(
729: IN PDEVICE_OBJECT DeviceObject,
730: IN PIRP Irp
731: )
732:
733: /*++
734: Routine Description:
735:
736: This routine returns the status of the device.
737:
738: Arguments:
739:
740: DeviceObject
741: Irp
742:
743: Return Value:
744:
745: NTSTATUS
746:
747: --*/
748:
749: {
750: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
751: SCSI_REQUEST_BLOCK srb;
752: PCDB cdb = (PCDB)srb.Cdb;
753: NTSTATUS status;
754:
755: DebugPrint((3,"TapeGetStatus: Enter routine\n"));
756:
757: //
758: // Zero CDB in SRB on stack.
759: //
760:
761: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
762:
763: //
764: // Prepare SCSI command (CDB)
765: //
766:
767: srb.CdbLength = CDB6GENERIC_LENGTH;
768:
769: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
770:
771: //
772: // Set timeout value.
773: //
774:
775: srb.TimeOutValue = deviceExtension->TimeOutValue;
776:
777: //
778: // Send SCSI command (CDB) to device
779: //
780:
781: DebugPrint((3,"TapeGetStatus: SendSrb (test unit ready)\n"));
782:
783: status = ScsiClassSendSrbSynchronous(DeviceObject,
784: &srb,
785: NULL,
786: 0,
787: FALSE);
788:
789: if (!NT_SUCCESS(status)) {
790: DebugPrint((1,"TapeGetStatus: test unit ready, SendSrb unsuccessful\n"));
791: }
792:
793: return status;
794:
795: } // end TapeGetStatus()
796:
797:
798: NTSTATUS
799: TapePrepare(
800: IN PDEVICE_OBJECT DeviceObject,
801: IN PIRP Irp
802: )
803:
804: /*++
805: Routine Description:
806:
807: This routine loads, unloads, locks, or unlocks the tape.
808:
809: Arguments:
810:
811: DeviceObject
812: Irp
813:
814: Return Value:
815:
816: NTSTATUS
817:
818: --*/
819:
820: {
821: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
822: PTAPE_PREPARE tapePrepare = Irp->AssociatedIrp.SystemBuffer;
823: SCSI_REQUEST_BLOCK srb;
824: PCDB cdb = (PCDB)srb.Cdb;
825: NTSTATUS status;
826:
827: DebugPrint((3,"TapePrepare: Enter routine\n"));
828:
829: if (tapePrepare->Immediate) {
830: switch (tapePrepare->Operation) {
831: case TAPE_LOAD:
832: case TAPE_UNLOAD:
833: DebugPrint((3,"TapePrepare: immediate\n"));
834: break;
835:
836: case TAPE_TENSION:
837: case TAPE_LOCK:
838: case TAPE_UNLOCK:
839: default:
840: DebugPrint((1,"TapePrepare: Operation, immediate -- operation not supported\n"));
841: return STATUS_NOT_IMPLEMENTED;
842: }
843: }
844:
845: //
846: // Zero CDB in SRB on stack.
847: //
848:
849: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
850:
851: //
852: // Prepare SCSI command (CDB)
853: //
854:
855: srb.CdbLength = CDB6GENERIC_LENGTH;
856:
857: cdb->CDB6GENERIC.Immediate = tapePrepare->Immediate;
858:
859: switch (tapePrepare->Operation) {
860: case TAPE_LOAD:
861: DebugPrint((3,"TapePrepare: Operation == load\n"));
862: cdb->CDB6GENERIC.OperationCode = SCSIOP_LOAD_UNLOAD;
863: cdb->CDB6GENERIC.CommandUniqueBytes[2] = 0x01;
864: srb.TimeOutValue = 150;
865: break;
866:
867: case TAPE_UNLOAD:
868: DebugPrint((3,"TapePrepare: Operation == unload\n"));
869: cdb->CDB6GENERIC.OperationCode = SCSIOP_LOAD_UNLOAD;
870: srb.TimeOutValue = 150;
871: break;
872:
873: case TAPE_LOCK:
874: DebugPrint((3,"TapePrepare: Operation == lock\n"));
875: cdb->CDB6GENERIC.OperationCode = SCSIOP_MEDIUM_REMOVAL;
876: cdb->CDB6GENERIC.CommandUniqueBytes[2] = 0x01;
877: srb.TimeOutValue = 150;
878: break;
879:
880: case TAPE_UNLOCK:
881: DebugPrint((3,"TapePrepare: Operation == unlock\n"));
882: cdb->CDB6GENERIC.OperationCode = SCSIOP_MEDIUM_REMOVAL;
883: srb.TimeOutValue = 150;
884: break;
885:
886: case TAPE_TENSION:
887: default:
888: DebugPrint((1,"TapePrepare: Operation -- operation not supported\n"));
889: return STATUS_NOT_IMPLEMENTED;
890: }
891:
892: //
893: // Send SCSI command (CDB) to device
894: //
895:
896: DebugPrint((3,"TapePrepare: SendSrb (Operation)\n"));
897:
898: status = ScsiClassSendSrbSynchronous(DeviceObject,
899: &srb,
900: NULL,
901: 0,
902: FALSE);
903:
904: if (!NT_SUCCESS(status)) {
905: DebugPrint((1,"TapePrepare: Operation, SendSrb unsuccessful\n"));
906: }
907:
908: return status;
909:
910: } // end TapePrepare()
911:
912:
913: NTSTATUS
914: TapeReadWrite(
915: IN PDEVICE_OBJECT DeviceObject,
916: IN PIRP Irp
917: )
918:
919: /*++
920:
921: Routine Description:
922:
923: This routine builds SRBs and CDBs for read and write requests to
924: Exabyte 8500 drives.
925:
926: Arguments:
927:
928: DeviceObject
929: Irp
930:
931: Return Value:
932:
933: Returns STATUS_PENDING.
934:
935: --*/
936:
937: {
938: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
939: PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
940: PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
941: PSCSI_REQUEST_BLOCK srb;
942: PCDB cdb;
943: KIRQL currentIrql;
944: ULONG transferBlocks;
945: LARGE_INTEGER startingOffset =
946: currentIrpStack->Parameters.Read.ByteOffset;
947:
948: DebugPrint((3,"TapeReadWrite: Enter routine\n"));
949:
950: //
951: // Allocate an Srb.
952: //
953:
954: if (deviceExtension->SrbZone != NULL &&
955: (srb = ExInterlockedAllocateFromZone(
956: deviceExtension->SrbZone,
957: deviceExtension->SrbZoneSpinLock)) != NULL) {
958:
959: srb->SrbFlags = SRB_FLAGS_ALLOCATED_FROM_ZONE;
960:
961: } else {
962:
963: //
964: // Allocate Srb from non-paged pool.
965: // This call must succeed.
966: //
967:
968: srb = ExAllocatePool(NonPagedPoolMustSucceed, SCSI_REQUEST_BLOCK_SIZE);
969:
970: srb->SrbFlags = 0;
971:
972: }
973:
974: //
975: // Write length to SRB.
976: //
977:
978: srb->Length = SCSI_REQUEST_BLOCK_SIZE;
979:
980: //
981: // Set up IRP Address.
982: //
983:
984: srb->OriginalRequest = Irp;
985:
986: //
987: // Set up target id and logical unit number.
988: //
989:
990: srb->PathId = deviceExtension->PathId;
991: srb->TargetId = deviceExtension->TargetId;
992: srb->Lun = deviceExtension->Lun;
993:
994:
995: srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
996:
997: srb->DataBuffer = MmGetMdlVirtualAddress(Irp->MdlAddress);
998:
999: //
1000: // Save byte count of transfer in SRB Extension.
1001: //
1002:
1003: srb->DataTransferLength = currentIrpStack->Parameters.Read.Length;
1004:
1005: //
1006: // Indicate auto request sense by specifying buffer and size.
1007: //
1008:
1009: srb->SenseInfoBuffer = deviceExtension->SenseData;
1010:
1011: srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
1012:
1013: //
1014: // Initialize the queue actions field.
1015: //
1016:
1017: srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
1018:
1019: //
1020: // Set timeout value in seconds.
1021: //
1022:
1023: srb->TimeOutValue = deviceExtension->TimeOutValue;
1024:
1025: //
1026: // Zero statuses.
1027: //
1028:
1029: srb->SrbStatus = srb->ScsiStatus = 0;
1030:
1031: srb->NextSrb = 0;
1032:
1033: //
1034: // Indicate that 6-byte CDB's will be used.
1035: //
1036:
1037: srb->CdbLength = CDB6GENERIC_LENGTH;
1038:
1039: //
1040: // Fill in CDB fields.
1041: //
1042:
1043: cdb = (PCDB)srb->Cdb;
1044:
1045: //
1046: // Zero CDB in SRB.
1047: //
1048:
1049: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1050:
1051: //
1052: // Since we are writing fixed block mode, normalize transfer count
1053: // to number of blocks.
1054: //
1055:
1056: transferBlocks =
1057: currentIrpStack->Parameters.Read.Length >> deviceExtension->SectorShift;
1058:
1059: //
1060: // Set up transfer length
1061: //
1062:
1063: cdb->CDB6READWRITETAPE.TransferLenMSB = (UCHAR)((transferBlocks >> 16) & 0xff);
1064: cdb->CDB6READWRITETAPE.TransferLen = (UCHAR)((transferBlocks >> 8) & 0xff);
1065: cdb->CDB6READWRITETAPE.TransferLenLSB = (UCHAR)(transferBlocks & 0xff);
1066:
1067: //
1068: // Tell the drive we are in fixed block mode
1069: //
1070:
1071: cdb->CDB6READWRITETAPE.VendorSpecific = 1;
1072:
1073: //
1074: // Set transfer direction flag and Cdb command.
1075: //
1076:
1077: if (currentIrpStack->MajorFunction == IRP_MJ_READ) {
1078:
1079: DebugPrint((3, "TapeRequest: Read Command\n"));
1080:
1081: srb->SrbFlags = SRB_FLAGS_DATA_IN;
1082: cdb->CDB6READWRITETAPE.OperationCode = SCSIOP_READ6;
1083:
1084: } else {
1085:
1086: DebugPrint((3, "TapeRequest: Write Command\n"));
1087:
1088: srb->SrbFlags = SRB_FLAGS_DATA_OUT;
1089: cdb->CDB6READWRITETAPE.OperationCode = SCSIOP_WRITE6;
1090: }
1091:
1092: //
1093: // Or in the default flags from the device object.
1094: //
1095:
1096: srb->SrbFlags |= deviceExtension->SrbFlags;
1097:
1098: //
1099: // Set up major SCSI function.
1100: //
1101:
1102: nextIrpStack->MajorFunction = IRP_MJ_SCSI;
1103:
1104: //
1105: // Save SRB address in next stack for port driver.
1106: //
1107:
1108: nextIrpStack->Parameters.Scsi.Srb = srb;
1109:
1110: //
1111: // Save retry count in current IRP stack.
1112: //
1113:
1114: currentIrpStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;
1115:
1116: //
1117: // Set up IoCompletion routine address.
1118: //
1119:
1120: IoSetCompletionRoutine(Irp,
1121: ScsiClassIoComplete,
1122: srb,
1123: TRUE,
1124: TRUE,
1125: FALSE);
1126:
1127: return STATUS_PENDING;
1128:
1129: } // end TapeReadWrite()
1130:
1131:
1132: NTSTATUS
1133: TapeSetDriveParameters(
1134: IN PDEVICE_OBJECT DeviceObject,
1135: IN PIRP Irp
1136: )
1137:
1138: /*++
1139: Routine Description:
1140:
1141: This routine would "set" the "drive parameters", but this drive does not
1142: support doing so: this routine always returns a STATUS_NOT_IMPLEMENTED
1143: status
1144:
1145: Arguments:
1146:
1147: DeviceObject
1148: Irp
1149:
1150: Return Value:
1151:
1152: NTSTATUS
1153:
1154: --*/
1155:
1156: {
1157: DebugPrint((3,"TapeSetDriveParameters: Enter routine\n"));
1158: DebugPrint((1,"TapeSetDriveParameters: operation not supported\n"));
1159: return STATUS_NOT_IMPLEMENTED;
1160:
1161: } // end TapeSetDriveParameters()
1162:
1163:
1164: NTSTATUS
1165: TapeSetMediaParameters(
1166: IN PDEVICE_OBJECT DeviceObject,
1167: IN PIRP Irp
1168: )
1169:
1170: /*++
1171: Routine Description:
1172:
1173: This routine "sets" the "media parameters" of the Exabyte 8500 tape
1174: drive associated with "DeviceObject". Tape media must be present
1175: (loaded) in the drive for this function to return "no error".
1176:
1177: Arguments:
1178:
1179: DeviceObject
1180: Irp
1181:
1182: Return Value:
1183:
1184: NTSTATUS
1185:
1186: --*/
1187:
1188: {
1189: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1190: PTAPE_SET_MEDIA_PARAMETERS tapeSetMediaParams = Irp->AssociatedIrp.SystemBuffer;
1191: PMODE_PARM_READ_WRITE_DATA modeBuffer;
1192: SCSI_REQUEST_BLOCK srb;
1193: PCDB cdb = (PCDB)srb.Cdb;
1194: NTSTATUS status;
1195:
1196: DebugPrint((3,"TapeSetMediaParameters: Enter routine\n"));
1197:
1198: //
1199: // Zero CDB in SRB on stack.
1200: //
1201:
1202: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1203:
1204: //
1205: // Prepare SCSI command (CDB)
1206: //
1207:
1208: srb.CdbLength = CDB6GENERIC_LENGTH;
1209:
1210: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
1211:
1212: //
1213: // Set timeout value.
1214: //
1215:
1216: srb.TimeOutValue = deviceExtension->TimeOutValue;
1217:
1218: //
1219: // Send SCSI command (CDB) to device
1220: //
1221:
1222: DebugPrint((3,"TapeSetMediaParameters: SendSrb (test unit ready)\n"));
1223:
1224: status = ScsiClassSendSrbSynchronous(DeviceObject,
1225: &srb,
1226: NULL,
1227: 0,
1228: FALSE);
1229:
1230: if (!NT_SUCCESS(status)) {
1231: DebugPrint((1,"TapeSetMediaParameters: test unit ready, SendSrb unsuccessful\n"));
1232: return status;
1233: }
1234:
1235: modeBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1236: sizeof(MODE_PARM_READ_WRITE_DATA));
1237:
1238: if (!modeBuffer) {
1239: DebugPrint((1,"TapeSetMediaParameters: insufficient resources (modeBuffer)\n"));
1240: return STATUS_INSUFFICIENT_RESOURCES;
1241: }
1242:
1243: RtlZeroMemory(modeBuffer, sizeof(MODE_PARM_READ_WRITE_DATA));
1244:
1245: modeBuffer->ParameterListHeader.ModeDataLength = 0;
1246: modeBuffer->ParameterListHeader.MediumType = 0;
1247: modeBuffer->ParameterListHeader.DeviceSpecificParameter = 0x10;
1248: modeBuffer->ParameterListHeader.BlockDescriptorLength =
1249: MODE_BLOCK_DESC_LENGTH;
1250:
1251: modeBuffer->ParameterListBlock.DensityCode = 0x7F;
1252: modeBuffer->ParameterListBlock.BlockLength[0] =
1253: ((tapeSetMediaParams->BlockSize >> 16) & 0xFF);
1254: modeBuffer->ParameterListBlock.BlockLength[1] =
1255: ((tapeSetMediaParams->BlockSize >> 8) & 0xFF);
1256: modeBuffer->ParameterListBlock.BlockLength[2] =
1257: (tapeSetMediaParams->BlockSize & 0xFF);
1258:
1259: //
1260: // Zero CDB in SRB on stack.
1261: //
1262:
1263: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1264:
1265: //
1266: // Prepare SCSI command (CDB)
1267: //
1268:
1269: srb.CdbLength = CDB6GENERIC_LENGTH;
1270:
1271: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
1272: cdb->MODE_SELECT.ParameterListLength = sizeof(MODE_PARM_READ_WRITE_DATA);
1273:
1274: //
1275: // Set timeout value.
1276: //
1277:
1278: srb.TimeOutValue = deviceExtension->TimeOutValue;
1279:
1280: //
1281: // Send SCSI command (CDB) to device
1282: //
1283:
1284: DebugPrint((3,"TapeSetMediaParameters: SendSrb (mode select)\n"));
1285:
1286: status = ScsiClassSendSrbSynchronous(DeviceObject,
1287: &srb,
1288: modeBuffer,
1289: sizeof(MODE_PARM_READ_WRITE_DATA),
1290: TRUE);
1291:
1292: ExFreePool(modeBuffer);
1293:
1294: if (!NT_SUCCESS(status)) {
1295: DebugPrint((1,"TapeSetMediaParameters: mode select, SendSrb unsuccessful\n"));
1296: }
1297:
1298: return status;
1299:
1300: } // end TapeSetMediaParameters()
1301:
1302:
1303: NTSTATUS
1304: TapeSetPosition(
1305: IN PDEVICE_OBJECT DeviceObject,
1306: IN PIRP Irp
1307: )
1308:
1309: /*++
1310: Routine Description:
1311:
1312: This routine sets the position of the tape.
1313:
1314: Arguments:
1315:
1316: DeviceObject
1317: Irp
1318:
1319: Return Value:
1320:
1321: NTSTATUS
1322:
1323: --*/
1324:
1325: {
1326: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1327: PTAPE_SET_POSITION tapeSetPosition = Irp->AssociatedIrp.SystemBuffer;
1328: ULONG tapePositionVector;
1329: ULONG method;
1330: SCSI_REQUEST_BLOCK srb;
1331: PCDB cdb = (PCDB)srb.Cdb;
1332: NTSTATUS status;
1333:
1334:
1335: DebugPrint((3,"TapeSetPosition: Enter routine\n"));
1336:
1337: if (tapeSetPosition->Immediate) {
1338: switch (tapeSetPosition->Method) {
1339: case TAPE_REWIND:
1340: case TAPE_ABSOLUTE_BLOCK:
1341: case TAPE_LOGICAL_BLOCK:
1342: DebugPrint((3,"TapeSetPosition: immediate\n"));
1343: break;
1344:
1345: case TAPE_SPACE_END_OF_DATA:
1346: case TAPE_SPACE_RELATIVE_BLOCKS:
1347: case TAPE_SPACE_FILEMARKS:
1348: case TAPE_SPACE_SEQUENTIAL_FMKS:
1349: case TAPE_SPACE_SETMARKS:
1350: case TAPE_SPACE_SEQUENTIAL_SMKS:
1351: default:
1352: DebugPrint((1,"TapeSetPosition: PositionMethod, immediate -- operation not supported\n"));
1353: return STATUS_NOT_IMPLEMENTED;
1354: }
1355: }
1356:
1357: method = tapeSetPosition->Method;
1358: tapePositionVector = tapeSetPosition->Offset.LowPart;
1359:
1360: //
1361: // Zero CDB in SRB on stack.
1362: //
1363:
1364: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1365:
1366: //
1367: // Prepare SCSI command (CDB)
1368: //
1369:
1370: srb.CdbLength = CDB6GENERIC_LENGTH;
1371:
1372: cdb->CDB6GENERIC.Immediate = tapeSetPosition->Immediate;
1373:
1374: switch (method) {
1375: case TAPE_REWIND:
1376: DebugPrint((3,"TapeSetPosition: method == rewind\n"));
1377: cdb->CDB6GENERIC.OperationCode = SCSIOP_REWIND;
1378: srb.TimeOutValue = 250;
1379: break;
1380:
1381: case TAPE_ABSOLUTE_BLOCK:
1382: case TAPE_LOGICAL_BLOCK:
1383: DebugPrint((3,"TapeSetPosition: method == locate (absolute/logical)\n"));
1384: srb.CdbLength = CDB10GENERIC_LENGTH;
1385: cdb->LOCATE.OperationCode = SCSIOP_LOCATE;
1386: cdb->LOCATE.LogicalBlockAddress[0] =
1387: ((tapePositionVector >> 24) & 0xFF);
1388: cdb->LOCATE.LogicalBlockAddress[1] =
1389: ((tapePositionVector >> 16) & 0xFF);
1390: cdb->LOCATE.LogicalBlockAddress[2] =
1391: ((tapePositionVector >> 8) & 0xFF);
1392: cdb->LOCATE.LogicalBlockAddress[3] =
1393: (tapePositionVector & 0xFF);
1394: srb.TimeOutValue = 300;
1395: break;
1396:
1397: case TAPE_SPACE_END_OF_DATA:
1398: DebugPrint((3,"TapeSetPosition: method == space to end-of-data\n"));
1399: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
1400: cdb->SPACE_TAPE_MARKS.Code = 3;
1401: srb.TimeOutValue = 150;
1402: break;
1403:
1404: case TAPE_SPACE_RELATIVE_BLOCKS:
1405: DebugPrint((3,"TapeSetPosition: method == space blocks\n"));
1406: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
1407: cdb->SPACE_TAPE_MARKS.Code = 0;
1408: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
1409: ((tapePositionVector >> 16) & 0xFF);
1410: cdb->SPACE_TAPE_MARKS.NumMarks =
1411: ((tapePositionVector >> 8) & 0xFF);
1412: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
1413: (tapePositionVector & 0xFF);
1414: srb.TimeOutValue = 4100;
1415: break;
1416:
1417: case TAPE_SPACE_FILEMARKS:
1418: DebugPrint((3,"TapeSetPosition: method == space filemarks\n"));
1419: cdb->SPACE_TAPE_MARKS.OperationCode = SCSIOP_SPACE;
1420: cdb->SPACE_TAPE_MARKS.Code = 1;
1421: cdb->SPACE_TAPE_MARKS.NumMarksMSB =
1422: ((tapePositionVector >> 16) & 0xFF);
1423: cdb->SPACE_TAPE_MARKS.NumMarks =
1424: ((tapePositionVector >> 8) & 0xFF);
1425: cdb->SPACE_TAPE_MARKS.NumMarksLSB =
1426: (tapePositionVector & 0xFF);
1427: srb.TimeOutValue = 4100;
1428: break;
1429:
1430: case TAPE_SPACE_SEQUENTIAL_FMKS:
1431: case TAPE_SPACE_SETMARKS:
1432: case TAPE_SPACE_SEQUENTIAL_SMKS:
1433: default:
1434: DebugPrint((1,"TapeSetPosition: PositionMethod -- operation not supported\n"));
1435: return STATUS_NOT_IMPLEMENTED;
1436: }
1437:
1438: //
1439: // Send SCSI command (CDB) to device
1440: //
1441:
1442: DebugPrint((3,"TapeSetPosition: SendSrb (method)\n"));
1443:
1444: status = ScsiClassSendSrbSynchronous(DeviceObject,
1445: &srb,
1446: NULL,
1447: 0,
1448: FALSE);
1449:
1450: if (!NT_SUCCESS(status)) {
1451: DebugPrint((1,"TapeSetPosition: method, SendSrb unsuccessful\n"));
1452: }
1453:
1454: return status;
1455:
1456: } // end TapeSetPosition()
1457:
1458:
1459: BOOLEAN
1460: TapeVerifyInquiry(
1461: IN PSCSI_INQUIRY_DATA LunInfo
1462: )
1463:
1464: /*++
1465: Routine Description:
1466:
1467: This routine determines if this driver should claim this drive.
1468:
1469: Arguments:
1470:
1471: LunInfo
1472:
1473: Return Value:
1474:
1475: TRUE - driver should claim this drive.
1476: FALSE - driver should not claim this drive.
1477:
1478: --*/
1479:
1480: {
1481: PINQUIRYDATA inquiryData;
1482:
1483: DebugPrint((3,"TapeVerifyInquiry: Enter routine\n"));
1484:
1485: inquiryData = (PVOID)LunInfo->InquiryData;
1486:
1487: //
1488: // Determine, from the Product ID field in the
1489: // inquiry data, whether or not to "claim" this drive.
1490: //
1491:
1492: return WhichIsIt(inquiryData)? TRUE : FALSE;
1493:
1494: } // end TapeVerifyInquiry()
1495:
1496:
1497: NTSTATUS
1498: TapeWriteMarks(
1499: IN PDEVICE_OBJECT DeviceObject,
1500: IN PIRP Irp
1501: )
1502:
1503: /*++
1504: Routine Description:
1505:
1506: This routine writes tapemarks on the tape.
1507:
1508: Arguments:
1509:
1510: DeviceObject
1511: Irp
1512:
1513: Return Value:
1514:
1515: NTSTATUS
1516:
1517: --*/
1518:
1519: {
1520: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
1521: PTAPE_WRITE_MARKS tapeWriteMarks = Irp->AssociatedIrp.SystemBuffer;
1522: SCSI_REQUEST_BLOCK srb;
1523: PCDB cdb = (PCDB)srb.Cdb;
1524: NTSTATUS status;
1525:
1526: DebugPrint((3,"TapeWriteMarks: Enter routine\n"));
1527:
1528: if (tapeWriteMarks->Immediate) {
1529: switch (tapeWriteMarks->Type) {
1530: case TAPE_SHORT_FILEMARKS:
1531: case TAPE_LONG_FILEMARKS:
1532: DebugPrint((3,"TapeWriteMarks: immediate\n"));
1533: break;
1534:
1535: case TAPE_SETMARKS:
1536: case TAPE_FILEMARKS:
1537: default:
1538: DebugPrint((1,"TapeWriteMarks: TapemarkType, immediate -- operation not supported\n"));
1539: return STATUS_NOT_IMPLEMENTED;
1540: }
1541: }
1542:
1543: //
1544: // Zero CDB in SRB on stack.
1545: //
1546:
1547: RtlZeroMemory(cdb, MAXIMUM_CDB_SIZE);
1548:
1549: //
1550: // Prepare SCSI command (CDB)
1551: //
1552:
1553: srb.CdbLength = CDB6GENERIC_LENGTH;
1554:
1555: cdb->WRITE_TAPE_MARKS.OperationCode = SCSIOP_WRITE_FILEMARKS;
1556: cdb->WRITE_TAPE_MARKS.Immediate = tapeWriteMarks->Immediate;
1557:
1558: switch (tapeWriteMarks->Type) {
1559: case TAPE_SHORT_FILEMARKS:
1560: DebugPrint((3,"TapeWriteMarks: TapemarkType == short filemarks\n"));
1561: cdb->WRITE_TAPE_MARKS.Control = 0x80;
1562: break;
1563:
1564: case TAPE_LONG_FILEMARKS:
1565: DebugPrint((3,"TapeWriteMarks: TapemarkType == long filemarks\n"));
1566: break;
1567:
1568: case TAPE_SETMARKS:
1569: case TAPE_FILEMARKS:
1570: default:
1571: DebugPrint((1,"TapeWriteMarks: TapemarkType -- operation not supported\n"));
1572: return STATUS_NOT_IMPLEMENTED;
1573: }
1574:
1575: cdb->WRITE_TAPE_MARKS.TransferLength[0] =
1576: ((tapeWriteMarks->Count >> 16) & 0xFF);
1577: cdb->WRITE_TAPE_MARKS.TransferLength[1] =
1578: ((tapeWriteMarks->Count >> 8) & 0xFF);
1579: cdb->WRITE_TAPE_MARKS.TransferLength[2] =
1580: (tapeWriteMarks->Count & 0xFF);
1581:
1582: //
1583: // Set timeout value.
1584: //
1585:
1586: srb.TimeOutValue = deviceExtension->TimeOutValue;
1587:
1588: //
1589: // Send SCSI command (CDB) to device
1590: //
1591:
1592: DebugPrint((3,"TapeWriteMarks: SendSrb (TapemarkType)\n"));
1593:
1594: status = ScsiClassSendSrbSynchronous(DeviceObject,
1595: &srb,
1596: NULL,
1597: 0,
1598: FALSE);
1599:
1600: if (!NT_SUCCESS(status)) {
1601: DebugPrint((1,"TapeWriteMarks: TapemarkType, SendSrb unsuccessful\n"));
1602: }
1603:
1604: return status;
1605:
1606: } // end TapeWriteMarks()
1607:
1608:
1609: static
1610: ULONG
1611: WhichIsIt(
1612: IN PINQUIRYDATA InquiryData
1613: )
1614:
1615: /*++
1616: Routine Description:
1617:
1618: This routine determines a drive's identity from the Product ID field
1619: in its inquiry data.
1620:
1621: Arguments:
1622:
1623: InquiryData (from an Inquiry command)
1624:
1625: Return Value:
1626:
1627: driveID
1628:
1629: --*/
1630:
1631: {
1632: if (RtlCompareMemory(InquiryData->VendorId,"EXABYTE ",8) == 8) {
1633:
1634: if (RtlCompareMemory(InquiryData->ProductId,"EXB-8500",8) == 8) {
1635: return EXABYTE_8500;
1636: }
1637:
1638: if (RtlCompareMemory(InquiryData->ProductId,"EXB8500C",8) == 8) {
1639: return EXABYTE_8500;
1640: }
1641:
1642: if (RtlCompareMemory(InquiryData->ProductId,"EXB-8505",8) == 8) {
1643: return EXABYTE_8505;
1644: }
1645:
1646: if (RtlCompareMemory(InquiryData->ProductId,"IBM-8505",8) == 8) {
1647: return IBM_8505;
1648: }
1649:
1650: }
1651: return 0;
1652: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.