![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cdrom.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / scsi / scsicdrm|
Return to cdrom.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / scsi / scsicdrm |
1.1 root 1: /*++
2:
3: Copyright (c) 1991 Microsoft Corporation
4:
5: Module Name:
6:
7: cdrom.c
8:
9: Abstract:
10:
11: The CDROM class driver tranlates IRPs to SRBs with embedded CDBs
12: and sends them to its devices through the port driver.
13:
14: Author:
15:
16: Mike Glass (mglass)
17:
18: Environment:
19:
20: kernel mode only
21:
22: Notes:
23:
24: SCSI Tape, CDRom and Disk class drivers share common routines
25: that can be found in the CLASS directory (..\ntos\dd\class).
26:
27: Revision History:
28:
29: --*/
30:
31: #include "ntddk.h"
32: #include "scsi.h"
33: #include "class.h"
34: #include "string.h"
35:
36: #define DEVICE_EXTENSION_SIZE sizeof(DEVICE_EXTENSION) + sizeof(BOOLEAN)
37: #define SCSI_CDROM_TIMEOUT 10
38: #define HITACHI_MODE_DATA_SIZE 12
39: #define MODE_DATA_SIZE 64
40:
41: #define PLAY_ACTIVE(DeviceExtension) *((PBOOLEAN) (DeviceExtension+1))
42:
43:
44: NTSTATUS
45: DriverEntry(
46: IN PDRIVER_OBJECT DriverObject,
47: IN PUNICODE_STRING RegistryPath
48: );
49:
50: BOOLEAN
51: FindScsiCdRoms(
52: IN PDRIVER_OBJECT DriveObject,
53: IN PDEVICE_OBJECT PortDeviceObject,
54: IN UCHAR PortNumber
55: );
56:
57: NTSTATUS
58: ScsiCdRomOpenClose(
59: IN PDEVICE_OBJECT DeviceObject,
60: IN PIRP Irp
61: );
62:
63: NTSTATUS
64: ScsiCdRomRead(
65: IN PDEVICE_OBJECT DeviceObject,
66: IN PIRP Irp
67: );
68:
69: NTSTATUS
70: ScsiCdRomDeviceControl(
71: IN PDEVICE_OBJECT DeviceObject,
72: IN PIRP Irp
73: );
74:
75: NTSTATUS
76: CreateCdRomDeviceObject(
77: IN PDRIVER_OBJECT DriverObject,
78: IN PDEVICE_OBJECT PortDeviceObject,
79: IN UCHAR PortNumber,
80: IN PULONG DeviceCount,
81: PIO_SCSI_CAPABILITIES PortCapabilities,
82: IN PSCSI_INQUIRY_DATA LunInfo
83: );
84:
85: NTSTATUS
86: GetTableOfContents(
87: IN PDEVICE_OBJECT DeviceObject
88: );
89:
90: VOID
91: ScanForSpecial(
92: PDEVICE_OBJECT DeviceObject,
93: PINQUIRYDATA InquiryData,
94: PIO_SCSI_CAPABILITIES PortCapabilities
95: );
96:
97: BOOLEAN
98: CdRomIsPlayActive(
99: IN PDEVICE_OBJECT DeviceObject
100: );
101:
102: VOID
103: HitachProcessError(
104: PDEVICE_OBJECT DeviceObject,
105: PSCSI_REQUEST_BLOCK Srb,
106: NTSTATUS *Status,
107: BOOLEAN *Retry
108: );
109:
110: #ifdef ALLOC_PRAGMA
111: #pragma alloc_text(init, DriverEntry)
112: #pragma alloc_text(init, FindScsiCdRoms)
113: #pragma alloc_text(init, CreateCdRomDeviceObject)
114: #pragma alloc_text(init, ScanForSpecial)
115: #endif
116:
117:
118: NTSTATUS
119: DriverEntry(
120: IN PDRIVER_OBJECT DriverObject,
121: IN PUNICODE_STRING RegistryPath
122: )
123:
124: /*++
125:
126: Routine Description:
127:
128: This routine initializes the CD-Rom class driver. The class
129: driver opens the port driver by name and then receives
130: configuration information used to attach to the CDROM devices.
131:
132: Arguments:
133:
134: DriverObject
135:
136: Return Value:
137:
138: NT Status
139:
140: --*/
141:
142: {
143: UCHAR portNumber = 0;
144: NTSTATUS status;
145: PFILE_OBJECT fileObject;
146: PDEVICE_OBJECT portDeviceObject;
147: STRING deviceNameString;
148: CCHAR deviceNameBuffer[256];
149: UNICODE_STRING unicodeDeviceName;
150: BOOLEAN foundOne = FALSE;
151:
152: DebugPrint((1,"\n\nSCSI CdRom Class Driver\n"));
153:
154: //
155: // Set up the device driver entry points.
156: //
157:
158: DriverObject->MajorFunction[IRP_MJ_CREATE] = ScsiCdRomOpenClose;
159: DriverObject->MajorFunction[IRP_MJ_CLOSE] = ScsiCdRomOpenClose;
160: DriverObject->MajorFunction[IRP_MJ_READ] = ScsiCdRomRead;
161: DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ScsiCdRomDeviceControl;
162: DriverObject->MajorFunction[IRP_MJ_SCSI] = ScsiClassInternalIoControl;
163:
164:
165: //
166: // Open port driver device objects by name.
167: //
168:
169: do {
170:
171: //
172: // Create port driver name.
173: //
174:
175: sprintf(deviceNameBuffer,
176: "\\Device\\ScsiPort%d",
177: portNumber);
178:
179: DebugPrint((2,"ScsiCdRomInitialize: Open %s\n",
180: deviceNameBuffer));
181:
182: RtlInitString(&deviceNameString,
183: deviceNameBuffer);
184:
185: status = RtlAnsiStringToUnicodeString(&unicodeDeviceName,
186: &deviceNameString,
187: TRUE);
188:
189: if (!NT_SUCCESS(status)) {
190: break;
191: }
192:
193: status = IoGetDeviceObjectPointer(&unicodeDeviceName,
194: FILE_READ_ATTRIBUTES,
195: &fileObject,
196: &portDeviceObject);
197:
198: RtlFreeUnicodeString(&unicodeDeviceName);
199:
200: if (NT_SUCCESS(status)) {
201:
202: //
203: // SCSI port driver exists.
204: //
205:
206: if (FindScsiCdRoms(DriverObject,
207: portDeviceObject,
208: portNumber++)) {
209:
210: foundOne = TRUE;
211: }
212:
213: //
214: // Dereference the file object since the port device pointer is no
215: // longer needed. The claim device code references the port driver
216: // pointer that is actually being used.
217: //
218:
219: ObDereferenceObject(fileObject);
220: }
221:
222: } while (NT_SUCCESS(status));
223:
224: if (foundOne) {
225: return STATUS_SUCCESS;
226: } else {
227: return STATUS_NO_SUCH_DEVICE;
228: }
229:
230: } // end DriverEntry()
231:
232:
233: BOOLEAN
234: FindScsiCdRoms(
235: IN PDRIVER_OBJECT DriverObject,
236: IN PDEVICE_OBJECT PortDeviceObject,
237: IN UCHAR PortNumber
238: )
239:
240: /*++
241:
242: Routine Description:
243:
244: Connect to SCSI port driver. Get adapter capabilities and
245: SCSI bus configuration information. Search inquiry data
246: for CDROM devices to process.
247:
248: Arguments:
249:
250: DriverObject - CDROM class driver object.
251: PortDeviceObject - SCSI port driver device object.
252: PortNumber - The system ordinal for this scsi adapter.
253:
254: Return Value:
255:
256: TRUE if CDROM device present on this SCSI adapter.
257:
258: --*/
259:
260: {
261: PIO_SCSI_CAPABILITIES portCapabilities;
262: PULONG cdRomCount;
263: PCHAR buffer;
264: PSCSI_INQUIRY_DATA lunInfo;
265: PSCSI_ADAPTER_BUS_INFO adapterInfo;
266: PINQUIRYDATA inquiryData;
267: ULONG scsiBus;
268: NTSTATUS status;
269: BOOLEAN foundDevice = FALSE;
270:
271: //
272: // Call port driver to get adapter capabilities.
273: //
274:
275: status = ScsiClassGetCapabilities(PortDeviceObject, &portCapabilities);
276:
277: if (!NT_SUCCESS(status)) {
278: DebugPrint((1,"FindScsiDevices: ScsiClassGetCapabilities failed\n"));
279: return foundDevice;
280: }
281:
282: //
283: // Call port driver to get inquiry information to find cdroms.
284: //
285:
286: status = ScsiClassGetInquiryData(PortDeviceObject, (PSCSI_ADAPTER_BUS_INFO *) &buffer);
287:
288: if (!NT_SUCCESS(status)) {
289: DebugPrint((1,"FindScsiDevices: ScsiClassGetInquiryData failed\n"));
290: return foundDevice;
291: }
292:
293: //
294: // Get the address of the count of the number of cdroms already initialized.
295: //
296:
297: cdRomCount = &IoGetConfigurationInformation()->CdRomCount;
298: adapterInfo = (PVOID) buffer;
299:
300: //
301: // For each SCSI bus this adapter supports ...
302: //
303:
304: for (scsiBus=0; scsiBus < adapterInfo->NumberOfBuses; scsiBus++) {
305:
306: //
307: // Get the SCSI bus scan data for this bus.
308: //
309:
310: lunInfo = (PVOID) (buffer + adapterInfo->BusData[scsiBus].InquiryDataOffset);
311:
312: //
313: // Search list for unclaimed disk devices.
314: //
315:
316: while (adapterInfo->BusData[scsiBus].InquiryDataOffset) {
317:
318: inquiryData = (PVOID)lunInfo->InquiryData;
319:
320: if ((inquiryData->DeviceType == READ_ONLY_DIRECT_ACCESS_DEVICE) &&
321: (!lunInfo->DeviceClaimed)) {
322:
323: DebugPrint((1,"FindScsiDevices: Vendor string is %.24s\n",
324: inquiryData->VendorId));
325:
326: //
327: // Create device objects for cdrom
328: //
329:
330: status = CreateCdRomDeviceObject(DriverObject,
331: PortDeviceObject,
332: PortNumber,
333: cdRomCount,
334: portCapabilities,
335: lunInfo);
336:
337: if (NT_SUCCESS(status)) {
338:
339: //
340: // Increment system cdrom device count.
341: //
342:
343: (*cdRomCount)++;
344:
345: //
346: // Indicate that a cdrom device was found.
347: //
348:
349: foundDevice = TRUE;
350: }
351: }
352:
353: //
354: // Get next LunInfo.
355: //
356:
357: if (lunInfo->NextInquiryDataOffset == 0) {
358: break;
359: }
360:
361: lunInfo = (PVOID) (buffer + lunInfo->NextInquiryDataOffset);
362: }
363: }
364:
365: ExFreePool(buffer);
366:
367: return foundDevice;
368:
369: } // end FindScsiCdRoms()
370:
371:
372: NTSTATUS
373: CreateCdRomDeviceObject(
374: IN PDRIVER_OBJECT DriverObject,
375: IN PDEVICE_OBJECT PortDeviceObject,
376: IN UCHAR PortNumber,
377: IN PULONG DeviceCount,
378: IN PIO_SCSI_CAPABILITIES PortCapabilities,
379: IN PSCSI_INQUIRY_DATA LunInfo
380: )
381:
382: /*++
383:
384: Routine Description:
385:
386: This routine creates an object for the device and then calls the
387: SCSI port driver for media capacity and sector size.
388:
389: Arguments:
390:
391: DriverObject - Pointer to driver object created by system.
392: PortDeviceObject - to connect to SCSI port driver.
393: DeviceCount - Number of previously installed CDROMs.
394: PortCapabilities - Pointer to structure returned by SCSI port
395: driver describing adapter capabilites (and limitations).
396: LunInfo - Pointer to configuration information for this device.
397:
398: Return Value:
399:
400: NTSTATUS
401:
402: --*/
403: {
404: UCHAR ntNameBuffer[64];
405: UCHAR arcNameBuffer[64];
406: STRING ntNameString;
407: STRING arcNameString;
408: UNICODE_STRING ntUnicodeString;
409: UNICODE_STRING arcUnicodeString;
410: NTSTATUS status;
411: PDEVICE_OBJECT deviceObject = NULL;
412: PDEVICE_EXTENSION deviceExtension;
413: PVOID senseData = NULL;
414:
415: //
416: // Claim the device.
417: //
418:
419: status = ScsiClassClaimDevice(
420: PortDeviceObject,
421: LunInfo,
422: FALSE,
423: &PortDeviceObject
424: );
425:
426: if (!NT_SUCCESS(status)) {
427: return(status);
428: }
429:
430:
431: //
432: // Create device object for this device.
433: //
434:
435: sprintf(ntNameBuffer,
436: "\\Device\\CdRom%d",
437: *DeviceCount);
438:
439: RtlInitString(&ntNameString,
440: ntNameBuffer);
441:
442: DebugPrint((2,"CreateCdRomDeviceObjects: Create device object %s\n",
443: ntNameBuffer));
444:
445: //
446: // Convert ANSI string to Unicode.
447: //
448:
449: status = RtlAnsiStringToUnicodeString(&ntUnicodeString,
450: &ntNameString,
451: TRUE);
452:
453: if (!NT_SUCCESS(status)) {
454:
455: DebugPrint((1,
456: "CreateDiskDeviceObjects: Cannot convert string %s\n",
457: ntNameBuffer));
458:
459: //
460: // Release the device since an error occured.
461: //
462:
463: ScsiClassClaimDevice(
464: PortDeviceObject,
465: LunInfo,
466: TRUE,
467: NULL
468: );
469:
470: return(status);
471: }
472:
473: //
474: // Create device object for this CDROM.
475: //
476:
477: status = IoCreateDevice(DriverObject,
478: DEVICE_EXTENSION_SIZE,
479: &ntUnicodeString,
480: FILE_DEVICE_CD_ROM,
481: FILE_REMOVABLE_MEDIA | FILE_READ_ONLY_DEVICE,
482: FALSE,
483: &deviceObject);
484:
485:
486: if (!NT_SUCCESS(status)) {
487: DebugPrint((1,"CreateCdRomDeviceObjects: Can not create device %s\n",
488: ntNameBuffer));
489:
490: RtlFreeUnicodeString(&ntUnicodeString);
491: deviceObject = NULL;
492: goto CreateCdRomDeviceObjectExit;
493: }
494:
495: //
496: // Indicate that IRPs should include MDLs.
497: //
498:
499: deviceObject->Flags |= DO_DIRECT_IO;
500:
501: //
502: // Set up required stack size in device object.
503: //
504:
505: deviceObject->StackSize = PortDeviceObject->StackSize + 1;
506:
507: deviceExtension = deviceObject->DeviceExtension;
508:
509: //
510: // Allocate spinlock for split request completion.
511: //
512:
513: KeInitializeSpinLock(&deviceExtension->SplitRequestSpinLock);
514:
515: //
516: // This is the physical device.
517: //
518:
519: deviceExtension->PhysicalDevice = deviceObject;
520:
521: //
522: // Copy port device object to device extension.
523: //
524:
525: deviceExtension->PortDeviceObject = PortDeviceObject;
526:
527: //
528: // Set the alignment requirements for the device based on the
529: // host adapter requirements
530: //
531:
532: if (PortDeviceObject->AlignmentRequirement > deviceObject->AlignmentRequirement) {
533: deviceObject->AlignmentRequirement = PortDeviceObject->AlignmentRequirement;
534: }
535:
536: //
537: // Save address of port driver capabilities.
538: //
539:
540: deviceExtension->PortCapabilities = PortCapabilities;
541:
542: //
543: // Disable synchronous transfer for CDROM requests.
544: //
545:
546: deviceExtension->SrbFlags = SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
547:
548: //
549: // Allocate request sense buffer.
550: //
551:
552: senseData = ExAllocatePool(NonPagedPoolCacheAligned, SENSE_BUFFER_SIZE);
553:
554: if (senseData == NULL) {
555:
556: //
557: // The buffer cannot be allocated.
558: //
559:
560: status = STATUS_INSUFFICIENT_RESOURCES;
561: goto CreateCdRomDeviceObjectExit;
562: }
563:
564: //
565: // Set the sense data pointer in the device extension.
566: //
567:
568: deviceExtension->SenseData = senseData;
569:
570: //
571: // CDROMs are not partitionable so starting offset is 0.
572: //
573:
574: deviceExtension->StartingOffset.LowPart = 0;
575: deviceExtension->StartingOffset.HighPart = 0;
576:
577: //
578: // Path/TargetId/LUN describes a device location on the SCSI bus.
579: // This information comes from the LunInfo buffer.
580: //
581:
582: deviceExtension->PortNumber = PortNumber;
583: deviceExtension->PathId = LunInfo->PathId;
584: deviceExtension->TargetId = LunInfo->TargetId;
585: deviceExtension->Lun = LunInfo->Lun;
586:
587: //
588: // Set timeout value in seconds.
589: //
590:
591: deviceExtension->TimeOutValue = SCSI_CDROM_TIMEOUT;
592:
593: //
594: // Back pointer to device object.
595: //
596:
597: deviceExtension->DeviceObject = deviceObject;
598:
599: //
600: // Create a symbolic link from the cdrom name to the corresponding
601: // ARC name, to be used if we're booting off the cdrom. This will
602: // fail if it's not system initialization time; that's fine. The
603: // ARC name looks something like \ArcName\scsi(0)cdrom(0)fdisk(0).
604: //
605:
606: sprintf(arcNameBuffer,
607: "\\ArcName\\scsi(%d)cdrom(%d)fdisk(%d)",
608: PortNumber,
609: LunInfo->TargetId + LunInfo->PathId * SCSI_MAXIMUM_TARGETS_PER_BUS,
610: LunInfo->Lun);
611:
612: RtlInitString(&arcNameString, arcNameBuffer);
613:
614: status = RtlAnsiStringToUnicodeString(&arcUnicodeString,
615: &arcNameString,
616: TRUE);
617:
618: if (!NT_SUCCESS(status)) {
619:
620: DebugPrint((1,
621: "CreateCdRomDeviceObjects: Cannot convert string %s\n",
622: arcNameBuffer));
623:
624: RtlFreeUnicodeString(&ntUnicodeString);
625:
626: goto CreateCdRomDeviceObjectExit;
627: }
628:
629: IoAssignArcName(&arcUnicodeString, &ntUnicodeString);
630:
631: RtlFreeUnicodeString(&ntUnicodeString);
632: RtlFreeUnicodeString(&arcUnicodeString);
633:
634: //
635: // Allocate buffer for drive geometry.
636: //
637:
638: deviceExtension->DiskGeometry =
639: ExAllocatePool(NonPagedPool, sizeof(DISK_GEOMETRY));
640:
641: if (deviceExtension->DiskGeometry == NULL) {
642:
643: status = STATUS_INSUFFICIENT_RESOURCES;
644: goto CreateCdRomDeviceObjectExit;
645: }
646:
647: //
648: // Scan for Scsi controllers that require special processing.
649: //
650:
651: ScanForSpecial(deviceObject,
652: (PINQUIRYDATA) LunInfo->InquiryData,
653: PortCapabilities);
654:
655: //
656: // Do READ CAPACITY. This SCSI command
657: // returns the last sector address on the device
658: // and the bytes per sector.
659: // These are used to calculate the drive capacity
660: // in bytes.
661: //
662:
663: status = ScsiClassReadDriveCapacity(deviceObject);
664:
665: if ((!NT_SUCCESS(status)) ||
666: (deviceExtension->DiskGeometry->BytesPerSector == 0)) {
667:
668: DebugPrint((1,
669: "CreateCdRomDeviceObjects: Can't read capacity for device %s\n",
670: ntNameBuffer));
671:
672: //
673: // Set disk geometry to default values (per ISO 9660).
674: //
675:
676: deviceExtension->DiskGeometry->BytesPerSector = 2048;
677: deviceExtension->SectorShift = 11;
678:
679: }
680:
681: return(STATUS_SUCCESS);
682:
683: CreateCdRomDeviceObjectExit:
684:
685: //
686: // Release the device since an error occured.
687: //
688:
689: ScsiClassClaimDevice(
690: PortDeviceObject,
691: LunInfo,
692: TRUE,
693: NULL
694: );
695:
696: if (senseData != NULL) {
697: ExFreePool(senseData);
698: }
699:
700: if (deviceExtension->DiskGeometry != NULL) {
701: ExFreePool(deviceExtension->DiskGeometry);
702: }
703:
704: if (deviceObject != NULL) {
705: IoDeleteDevice(deviceObject);
706: }
707:
708:
709: return status;
710:
711: } // end CreateCdromDeviceObject()
712:
713:
714: NTSTATUS
715: ScsiCdRomOpenClose(
716: IN PDEVICE_OBJECT DeviceObject,
717: IN PIRP Irp
718: )
719:
720: /*++
721:
722: Routine Description:
723:
724: This routine is called to establish a connection to the CDROM
725: class driver. It does no more than return STATUS_SUCCESS.
726:
727: Arguments:
728:
729: DeviceObject - Device object for CDROM drive
730: Irp - Open or Close request packet
731:
732: Return Value:
733:
734: NT Status - STATUS_SUCCESS
735:
736: --*/
737:
738: {
739: //
740: // Set status in Irp.
741: //
742:
743: Irp->IoStatus.Status = STATUS_SUCCESS;
744:
745: //
746: // Complete request at raised IRQ.
747: //
748:
749: IoCompleteRequest(Irp, IO_NO_INCREMENT);
750: return STATUS_SUCCESS;
751:
752: } // end ScsiCdRomOpenClose()
753:
754:
755: NTSTATUS
756: ScsiCdRomRead(
757: IN PDEVICE_OBJECT DeviceObject,
758: IN PIRP Irp
759: )
760:
761: /*++
762:
763: Routine Description:
764:
765: This is the entry called by the I/O system for read requests.
766: It builds the SRB and sends it to the port driver.
767:
768: Arguments:
769:
770: DeviceObject - the system object for the device.
771: Irp - IRP involved.
772:
773: Return Value:
774:
775: NT Status
776:
777: --*/
778:
779: {
780: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
781: PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
782: ULONG transferByteCount = currentIrpStack->Parameters.Read.Length;
783: LARGE_INTEGER startingOffset;
784: ULONG maximumTransferLength =
785: deviceExtension->PortCapabilities->MaximumTransferLength;
786: ULONG transferPages;
787:
788: //
789: // If the cd is playing music then reject this request.
790: //
791:
792: if (PLAY_ACTIVE(deviceExtension)) {
793: Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
794: IoCompleteRequest(Irp, IO_NO_INCREMENT);
795: return STATUS_DEVICE_BUSY;
796: }
797:
798: //
799: // Check if volume needs verification.
800: //
801:
802: if ((DeviceObject->Flags & DO_VERIFY_VOLUME) &&
803: !(currentIrpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME)) {
804:
805: //
806: // if DO_VERIFY_VOLUME bit is set
807: // in device object flags, fail request.
808: //
809:
810: DebugPrint((2,"ScsiCdRomRead: Volume verfication needed\n"));
811:
812: IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
813:
814: Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
815: Irp->IoStatus.Information = 0;
816:
817: IoCompleteRequest(Irp, IO_NO_INCREMENT);
818: return STATUS_VERIFY_REQUIRED;
819: }
820:
821: //
822: // Verify parameters of this request.
823: // Check that ending sector is on disc and
824: // that number of bytes to transfer is a multiple of
825: // the sector size.
826: //
827:
828: startingOffset = LiFromUlong(transferByteCount);
829: startingOffset = LiAdd(startingOffset,
830: currentIrpStack->Parameters.Read.ByteOffset);
831:
832: if (LiGtr( startingOffset, deviceExtension->PartitionLength) ||
833: (transferByteCount & deviceExtension->DiskGeometry->BytesPerSector - 1)) {
834:
835: DebugPrint((1,"ScsiCdRomRead: Invalid I/O parameters\n"));
836:
837: //
838: // Fail request with status of invalid parameters.
839: //
840:
841: Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
842:
843: IoCompleteRequest(Irp, IO_NO_INCREMENT);
844: return STATUS_INVALID_PARAMETER;
845: }
846:
847: //
848: // Mark IRP with status pending.
849: //
850:
851: IoMarkIrpPending(Irp);
852:
853: //
854: // Calculate number of pages in this transfer.
855: //
856:
857: transferPages = ADDRESS_AND_SIZE_TO_SPAN_PAGES(
858: MmGetMdlVirtualAddress(Irp->MdlAddress),
859: currentIrpStack->Parameters.Read.Length);
860:
861: //
862: // Check if request length is greater than the maximum number of
863: // bytes that the hardware can transfer.
864: //
865:
866: if (currentIrpStack->Parameters.Read.Length > maximumTransferLength ||
867: transferPages > deviceExtension->PortCapabilities->MaximumPhysicalPages) {
868:
869: DebugPrint((2,"ScsiCdromRead: Request greater than maximum\n"));
870: DebugPrint((2,"ScsiCdromRead: Maximum is %lx\n",
871: maximumTransferLength));
872: DebugPrint((2,"ScsiCdromRead: Byte count is %lx\n",
873: currentIrpStack->Parameters.Read.Length));
874:
875: transferPages =
876: deviceExtension->PortCapabilities->MaximumPhysicalPages - 1;
877:
878: if (maximumTransferLength > transferPages << PAGE_SHIFT ) {
879: maximumTransferLength = transferPages << PAGE_SHIFT;
880: }
881:
882: //
883: // Check that maximum transfer size is not zero.
884: //
885:
886: if (maximumTransferLength == 0) {
887: maximumTransferLength = PAGE_SIZE;
888: }
889:
890: //
891: // Mark IRP with status pending.
892: //
893:
894: IoMarkIrpPending(Irp);
895:
896: //
897: // Request greater than port driver maximum.
898: // Break up into smaller routines.
899: //
900:
901: ScsiClassSplitRequest(DeviceObject, Irp, maximumTransferLength);
902:
903:
904: return STATUS_PENDING;
905: }
906:
907: //
908: // Build SRB and CDB for this IRP.
909: //
910:
911: ScsiClassBuildRequest(DeviceObject, Irp);
912:
913: //
914: // Return the results of the call to the port driver.
915: //
916:
917: return IoCallDriver(deviceExtension->PortDeviceObject, Irp);
918:
919: } // end ScsiCdRomRead()
920:
921:
922: NTSTATUS
923: ScsiCdRomDeviceControl(
924: IN PDEVICE_OBJECT DeviceObject,
925: IN PIRP Irp
926: )
927:
928: /*++
929:
930: Routine Description:
931:
932: This is the NT device control handler for CDROMs.
933:
934: Arguments:
935:
936: DeviceObject - for this CDROM
937:
938: Irp - IO Request packet
939:
940: Return Value:
941:
942: NTSTATUS
943:
944: --*/
945:
946: {
947: PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
948: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
949: SCSI_REQUEST_BLOCK srb;
950: PCDB cdb = (PCDB)srb.Cdb;
951: PVOID outputBuffer;
952: ULONG bytesTransferred = 0;
953: NTSTATUS status;
954: NTSTATUS status2;
955:
956: RetryControl:
957:
958: //
959: // Zero the SRB on stack.
960: //
961:
962: RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
963:
964: Irp->IoStatus.Information = 0;
965:
966: switch (irpStack->Parameters.DeviceIoControl.IoControlCode) {
967:
968: case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
969:
970: DebugPrint((2,"ScsiCdRomDeviceControl: Get drive geometry\n"));
971:
972: if ( irpStack->Parameters.DeviceIoControl.OutputBufferLength <
973: sizeof( DISK_GEOMETRY ) ) {
974:
975: status = STATUS_INFO_LENGTH_MISMATCH;
976: break;
977: }
978:
979: //
980: // Issue ReadCapacity to update device extension
981: // with information for current media.
982: //
983:
984: status = ScsiClassReadDriveCapacity(DeviceObject);
985:
986: if ((!NT_SUCCESS(status)) ||
987: (deviceExtension->DiskGeometry->BytesPerSector == 0)) {
988:
989: //
990: // Set disk geometry to default values (per ISO 9660).
991: //
992:
993: deviceExtension->DiskGeometry->BytesPerSector = 2048;
994: deviceExtension->SectorShift = 11;
995: }
996:
997: //
998: // Copy drive geometry information from device extension.
999: //
1000:
1001: RtlMoveMemory(Irp->AssociatedIrp.SystemBuffer,
1002: deviceExtension->DiskGeometry,
1003: sizeof(DISK_GEOMETRY));
1004:
1005: status = STATUS_SUCCESS;
1006: Irp->IoStatus.Information = sizeof(DISK_GEOMETRY);
1007:
1008: break;
1009:
1010: case IOCTL_CDROM_GET_LAST_SESSION:
1011:
1012: //
1013: // Set format to return first and last session numbers.
1014: //
1015:
1016: cdb->READ_TOC.Format = GET_LAST_SESSION;
1017:
1018: //
1019: // Fall through to READ TOC code.
1020: //
1021:
1022: case IOCTL_CDROM_READ_TOC:
1023:
1024: {
1025: PCDROM_TOC toc = Irp->AssociatedIrp.SystemBuffer;
1026: ULONG transferBytes;
1027:
1028: DebugPrint((2,"CdRomDeviceControl: Read TOC\n"));
1029:
1030: //
1031: // If the cd is playing music then reject this request.
1032: //
1033:
1034: if (CdRomIsPlayActive(DeviceObject)) {
1035: Irp->IoStatus.Status = STATUS_DEVICE_BUSY;
1036: IoCompleteRequest(Irp, IO_NO_INCREMENT);
1037: return STATUS_DEVICE_BUSY;
1038: }
1039:
1040: //
1041: // Read TOC is 10 byte CDB.
1042: //
1043:
1044: srb.CdbLength = 10;
1045:
1046: cdb->READ_TOC.OperationCode = SCSIOP_READ_TOC;
1047:
1048: if (irpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_CDROM_READ_TOC) {
1049:
1050: //
1051: // Use MSF addressing if not request for session information.
1052: //
1053:
1054: cdb->READ_TOC.Msf = CDB_USE_MSF;
1055: }
1056:
1057: //
1058: // Start at beginning of disc.
1059: //
1060:
1061: cdb->READ_TOC.StartingTrack = 0;
1062:
1063: //
1064: // Set size of TOC structure.
1065: //
1066:
1067: transferBytes =
1068: irpStack->Parameters.Read.Length >
1069: sizeof(CDROM_TOC) ? sizeof(CDROM_TOC):
1070: irpStack->Parameters.Read.Length;
1071:
1072: cdb->READ_TOC.AllocationLength[0] = (UCHAR) (transferBytes >> 8);
1073: cdb->READ_TOC.AllocationLength[1] = (UCHAR) (transferBytes & 0xFF);
1074:
1075: cdb->READ_TOC.Control = 0;
1076:
1077: //
1078: // Set timeout value.
1079: //
1080:
1081: srb.TimeOutValue = deviceExtension->TimeOutValue;
1082:
1083: status = ScsiClassSendSrbSynchronous(DeviceObject,
1084: &srb,
1085: toc,
1086: transferBytes,
1087: FALSE);
1088:
1089: //
1090: // Check for data underrun.
1091: //
1092:
1093: if (status==STATUS_DATA_OVERRUN) {
1094: status = STATUS_SUCCESS;
1095: }
1096:
1097: Irp->IoStatus.Information = srb.DataTransferLength;
1098: }
1099:
1100: break;
1101:
1102: case IOCTL_CDROM_PLAY_AUDIO_MSF:
1103:
1104: {
1105: PCDROM_PLAY_AUDIO_MSF inputBuffer = Irp->AssociatedIrp.SystemBuffer;
1106:
1107: //
1108: // Play Audio MSF
1109: //
1110:
1111: DebugPrint((2,"ScsiCdRomDeviceControl: Play audio MSF\n"));
1112:
1113: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1114: sizeof(CDROM_PLAY_AUDIO_MSF)) {
1115:
1116: //
1117: // Indicate unsuccessful status.
1118: //
1119:
1120: status = STATUS_BUFFER_TOO_SMALL;
1121: break;
1122: }
1123:
1124: cdb->PLAY_AUDIO_MSF.OperationCode = SCSIOP_PLAY_AUDIO_MSF;
1125:
1126: cdb->PLAY_AUDIO_MSF.StartingM = inputBuffer->StartingM;
1127: cdb->PLAY_AUDIO_MSF.StartingS = inputBuffer->StartingS;
1128: cdb->PLAY_AUDIO_MSF.StartingF = inputBuffer->StartingF;
1129:
1130: cdb->PLAY_AUDIO_MSF.EndingM = inputBuffer->EndingM;
1131: cdb->PLAY_AUDIO_MSF.EndingS = inputBuffer->EndingS;
1132: cdb->PLAY_AUDIO_MSF.EndingF = inputBuffer->EndingF;
1133:
1134: srb.CdbLength = 10;
1135:
1136: //
1137: // Set timeout value.
1138: //
1139:
1140: srb.TimeOutValue = deviceExtension->TimeOutValue;
1141:
1142: status = ScsiClassSendSrbSynchronous(DeviceObject,
1143: &srb,
1144: NULL,
1145: 0,
1146: FALSE);
1147:
1148: if (NT_SUCCESS(status)) {
1149: PLAY_ACTIVE(deviceExtension) = TRUE;
1150: }
1151: }
1152:
1153: break;
1154:
1155: case IOCTL_CDROM_SEEK_AUDIO_MSF:
1156:
1157: {
1158: PCDROM_SEEK_AUDIO_MSF inputBuffer = Irp->AssociatedIrp.SystemBuffer;
1159:
1160: //
1161: // Seek Audio MSF
1162: //
1163:
1164: DebugPrint((2,"ScsiCdRomDeviceControl: Seek audio MSF\n"));
1165:
1166: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1167: sizeof(CDROM_SEEK_AUDIO_MSF)) {
1168:
1169: //
1170: // Indicate unsuccessful status.
1171: //
1172:
1173: status = STATUS_BUFFER_TOO_SMALL;
1174: break;
1175: }
1176:
1177: cdb->PLAY_AUDIO_MSF.OperationCode = SCSIOP_PLAY_AUDIO_MSF;
1178:
1179: cdb->PLAY_AUDIO_MSF.StartingM = inputBuffer->M;
1180: cdb->PLAY_AUDIO_MSF.StartingS = inputBuffer->S;
1181: cdb->PLAY_AUDIO_MSF.StartingF = inputBuffer->F;
1182:
1183: cdb->PLAY_AUDIO_MSF.EndingM = inputBuffer->M;
1184: cdb->PLAY_AUDIO_MSF.EndingS = inputBuffer->S;
1185: cdb->PLAY_AUDIO_MSF.EndingF = inputBuffer->F;
1186:
1187: srb.CdbLength = 10;
1188:
1189: //
1190: // Set timeout value.
1191: //
1192:
1193: srb.TimeOutValue = deviceExtension->TimeOutValue;
1194:
1195: status = ScsiClassSendSrbSynchronous(DeviceObject,
1196: &srb,
1197: NULL,
1198: 0,
1199: FALSE);
1200:
1201: }
1202:
1203: break;
1204:
1205: case IOCTL_CDROM_PAUSE_AUDIO:
1206:
1207: //
1208: // Pause audio
1209: //
1210:
1211: DebugPrint((2, "ScsiCdRomDeviceControl: Pause audio\n"));
1212:
1213: PLAY_ACTIVE(deviceExtension) = FALSE;
1214:
1215: cdb->PAUSE_RESUME.OperationCode = SCSIOP_PAUSE_RESUME;
1216:
1217: cdb->PAUSE_RESUME.Action = CDB_AUDIO_PAUSE;
1218:
1219: srb.CdbLength = 10;
1220:
1221: //
1222: // Set timeout value.
1223: //
1224:
1225: srb.TimeOutValue = deviceExtension->TimeOutValue;
1226:
1227: status = ScsiClassSendSrbSynchronous(DeviceObject,
1228: &srb,
1229: NULL,
1230: 0,
1231: FALSE);
1232:
1233: break;
1234:
1235: case IOCTL_CDROM_RESUME_AUDIO:
1236:
1237: //
1238: // Resume audio
1239: //
1240:
1241: DebugPrint((2, "ScsiCdRomDeviceControl: Resume audio\n"));
1242:
1243: cdb->PAUSE_RESUME.OperationCode = SCSIOP_PAUSE_RESUME;
1244:
1245: cdb->PAUSE_RESUME.Action = CDB_AUDIO_RESUME;
1246:
1247: srb.CdbLength = 10;
1248:
1249: //
1250: // Set timeout value.
1251: //
1252:
1253: srb.TimeOutValue = deviceExtension->TimeOutValue;
1254:
1255: status = ScsiClassSendSrbSynchronous(DeviceObject,
1256: &srb,
1257: NULL,
1258: 0,
1259: FALSE);
1260:
1261: break;
1262:
1263: case IOCTL_CDROM_READ_Q_CHANNEL:
1264:
1265: {
1266:
1267: PSUB_Q_CHANNEL_DATA userChannelData =
1268: Irp->AssociatedIrp.SystemBuffer;
1269: PCDROM_SUB_Q_DATA_FORMAT inputBuffer =
1270: Irp->AssociatedIrp.SystemBuffer;
1271: PSUB_Q_CHANNEL_DATA subQPtr;
1272:
1273: //
1274: // Allocate buffer for subq channel information.
1275: //
1276:
1277: subQPtr = ExAllocatePool(NonPagedPoolCacheAligned,
1278: sizeof(SUB_Q_CHANNEL_DATA));
1279:
1280: if (!subQPtr) {
1281: status = STATUS_INSUFFICIENT_RESOURCES;
1282: Irp->IoStatus.Information = 0;
1283: break;
1284: }
1285:
1286: //
1287: // Read Subchannel Q
1288: //
1289:
1290: DebugPrint((2,
1291: "ScsiCdRomDeviceControl: Read channel Q Format %u\n", inputBuffer->Format ));
1292:
1293: cdb->SUBCHANNEL.OperationCode = SCSIOP_READ_SUB_CHANNEL;
1294:
1295: //
1296: // Always logical unit 0, but only use MSF addressing
1297: // for IOCTL_CDROM_CURRENT_POSITION
1298: //
1299:
1300: if (inputBuffer->Format==IOCTL_CDROM_CURRENT_POSITION)
1301: cdb->SUBCHANNEL.Msf = CDB_USE_MSF;
1302:
1303: //
1304: // Return subchannel data
1305: //
1306:
1307: cdb->SUBCHANNEL.SubQ = CDB_SUBCHANNEL_BLOCK;
1308:
1309: //
1310: // Specify format of informatin to return
1311: //
1312:
1313: cdb->SUBCHANNEL.Format = inputBuffer->Format;
1314:
1315: //
1316: // Specify which track to access (only used by Track ISRC reads)
1317: //
1318:
1319: if (inputBuffer->Format==IOCTL_CDROM_TRACK_ISRC)
1320: cdb->SUBCHANNEL.TrackNumber = inputBuffer->Track;
1321:
1322: //
1323: // Set size of channel data -- however, this is dependent on
1324: // what information we are requesting (which Format)
1325: //
1326:
1327: switch( inputBuffer->Format ) {
1328:
1329: case IOCTL_CDROM_CURRENT_POSITION:
1330: bytesTransferred = sizeof(SUB_Q_CURRENT_POSITION);
1331: break;
1332:
1333: case IOCTL_CDROM_MEDIA_CATALOG:
1334: bytesTransferred = sizeof(SUB_Q_MEDIA_CATALOG_NUMBER);
1335: break;
1336:
1337: case IOCTL_CDROM_TRACK_ISRC:
1338: bytesTransferred = sizeof(SUB_Q_TRACK_ISRC);
1339: break;
1340: }
1341:
1342: cdb->SUBCHANNEL.AllocationLength[0] = (UCHAR) (bytesTransferred >> 8);
1343: cdb->SUBCHANNEL.AllocationLength[1] = (UCHAR) (bytesTransferred & 0xFF);
1344:
1345: srb.CdbLength = 10;
1346:
1347: //
1348: // Set timeout value.
1349: //
1350:
1351: srb.TimeOutValue = deviceExtension->TimeOutValue;
1352:
1353: status = ScsiClassSendSrbSynchronous(DeviceObject,
1354: &srb,
1355: subQPtr,
1356: bytesTransferred,
1357: FALSE);
1358:
1359: if (NT_SUCCESS(status)) {
1360: #if DBG
1361: switch( inputBuffer->Format ) {
1362:
1363: case IOCTL_CDROM_CURRENT_POSITION:
1364: DebugPrint((3,"ScsiCdromDeviceControl: Audio Status is %u\n", subQPtr->CurrentPosition.Header.AudioStatus ));
1365: DebugPrint((3,"ScsiCdromDeviceControl: ADR = 0x%x\n", subQPtr->CurrentPosition.ADR ));
1366: DebugPrint((3,"ScsiCdromDeviceControl: Control = 0x%x\n", subQPtr->CurrentPosition.Control ));
1367: DebugPrint((3,"ScsiCdromDeviceControl: Track = %u\n", subQPtr->CurrentPosition.TrackNumber ));
1368: DebugPrint((3,"ScsiCdromDeviceControl: Index = %u\n", subQPtr->CurrentPosition.IndexNumber ));
1369: break;
1370:
1371: case IOCTL_CDROM_MEDIA_CATALOG:
1372: DebugPrint((3,"ScsiCdromDeviceControl: Audio Status is %u\n", subQPtr->MediaCatalog.Header.AudioStatus ));
1373: DebugPrint((3,"ScsiCdromDeviceControl: Mcval is %u\n", subQPtr->MediaCatalog.Mcval ));
1374: break;
1375:
1376: case IOCTL_CDROM_TRACK_ISRC:
1377: DebugPrint((3,"ScsiCdromDeviceControl: Audio Status is %u\n", subQPtr->TrackIsrc.Header.AudioStatus ));
1378: DebugPrint((3,"ScsiCdromDeviceControl: Tcval is %u\n", subQPtr->TrackIsrc.Tcval ));
1379: break;
1380:
1381: }
1382: #endif
1383:
1384: //
1385: // Update the play active status.
1386: //
1387:
1388: if (subQPtr->CurrentPosition.Header.AudioStatus == AUDIO_STATUS_IN_PROGRESS) {
1389:
1390: PLAY_ACTIVE(deviceExtension) = TRUE;
1391:
1392: } else {
1393:
1394: PLAY_ACTIVE(deviceExtension) = FALSE;
1395:
1396: }
1397:
1398: //
1399: // Check if output buffer is large enough to contain
1400: // the data.
1401: //
1402:
1403: if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
1404: bytesTransferred) {
1405:
1406: bytesTransferred =
1407: irpStack->Parameters.DeviceIoControl.OutputBufferLength;
1408: }
1409:
1410: RtlMoveMemory(userChannelData,
1411: subQPtr,
1412: bytesTransferred);
1413:
1414: Irp->IoStatus.Information = bytesTransferred;
1415: } else {
1416:
1417: PLAY_ACTIVE(deviceExtension) = FALSE;
1418:
1419: }
1420:
1421: ExFreePool(subQPtr);
1422:
1423: break;
1424:
1425: }
1426:
1427: case IOCTL_CDROM_GET_CONTROL:
1428:
1429: DebugPrint((2, "ScsiCdRomDeviceControl: Get audio control\n"));
1430:
1431: //
1432: // Verify user buffer is large enough for the data.
1433: //
1434:
1435: if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
1436: sizeof(CDROM_AUDIO_CONTROL)) {
1437:
1438: //
1439: // Indicate unsuccessful status and no data transferred.
1440: //
1441:
1442: status = STATUS_BUFFER_TOO_SMALL;
1443: Irp->IoStatus.Information = 0;
1444:
1445: } else {
1446:
1447: PAUDIO_OUTPUT audioOutput;
1448: PCDROM_AUDIO_CONTROL audioControl = Irp->AssociatedIrp.SystemBuffer;
1449:
1450: //
1451: // Allocate buffer for volume control information.
1452: //
1453:
1454: outputBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1455: MODE_DATA_SIZE);
1456:
1457: if (!outputBuffer) {
1458: status = STATUS_INSUFFICIENT_RESOURCES;
1459: Irp->IoStatus.Information = 0;
1460: break;
1461: }
1462:
1463: //
1464: // Get audio control information
1465: //
1466:
1467: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1468: cdb->MODE_SENSE.PageCode = CDROM_AUDIO_CONTROL_PAGE;
1469: cdb->MODE_SENSE.AllocationLength = MODE_DATA_SIZE;
1470:
1471: //
1472: // Disable block descriptors.
1473: //
1474:
1475: cdb->MODE_SENSE.Dbd = TRUE;
1476:
1477: srb.CdbLength = 6;
1478:
1479: //
1480: // Set timeout value.
1481: //
1482:
1483: srb.TimeOutValue = deviceExtension->TimeOutValue;
1484:
1485: status = ScsiClassSendSrbSynchronous(DeviceObject,
1486: &srb,
1487: outputBuffer,
1488: MODE_DATA_SIZE,
1489: FALSE);
1490:
1491: if (SRB_STATUS(srb.SrbStatus) == SRB_STATUS_DATA_OVERRUN) {
1492: status = STATUS_SUCCESS;
1493: }
1494:
1495: if (NT_SUCCESS(status)) {
1496:
1497: audioOutput = ScsiClassFindModePage( outputBuffer,
1498: srb.DataTransferLength,
1499: CDROM_AUDIO_CONTROL_PAGE);
1500: //
1501: // Verify the page is as big as expected.
1502: //
1503:
1504: bytesTransferred = (PCHAR) audioOutput - (PCHAR) outputBuffer +
1505: sizeof(AUDIO_OUTPUT);
1506:
1507: if (audioOutput != NULL &&
1508: srb.DataTransferLength >= bytesTransferred) {
1509:
1510: audioControl->LbaFormat = audioOutput->LbaFormat;
1511:
1512: audioControl->LogicalBlocksPerSecond =
1513: (audioOutput->LogicalBlocksPerSecond[0] << (UCHAR)8) |
1514: audioOutput->LogicalBlocksPerSecond[1];
1515:
1516: Irp->IoStatus.Information = sizeof(CDROM_AUDIO_CONTROL);
1517:
1518: } else {
1519: status = STATUS_INVALID_DEVICE_REQUEST;
1520: }
1521:
1522: }
1523:
1524: ExFreePool(outputBuffer);
1525: }
1526:
1527: break;
1528:
1529: case IOCTL_CDROM_GET_VOLUME:
1530:
1531: DebugPrint((2, "ScsiCdRomDeviceControl: Get volume control\n"));
1532:
1533: //
1534: // Verify user buffer is large enough for data.
1535: //
1536:
1537: if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
1538: sizeof(VOLUME_CONTROL)) {
1539:
1540: //
1541: // Indicate unsuccessful status and no data transferred.
1542: //
1543:
1544: status = STATUS_BUFFER_TOO_SMALL;
1545: Irp->IoStatus.Information = 0;
1546:
1547: } else {
1548:
1549: PAUDIO_OUTPUT audioOutput;
1550: PVOLUME_CONTROL volumeControl = Irp->AssociatedIrp.SystemBuffer;
1551: ULONG i;
1552:
1553: //
1554: // Allocate buffer for volume control information.
1555: //
1556:
1557: outputBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1558: MODE_DATA_SIZE);
1559:
1560: if (!outputBuffer) {
1561: status = STATUS_INSUFFICIENT_RESOURCES;
1562: Irp->IoStatus.Information = 0;
1563: break;
1564: }
1565:
1566: //
1567: // In case not as much as expected is returned zero
1568: // all of this.
1569: //
1570:
1571: RtlZeroMemory(outputBuffer, MODE_DATA_SIZE);
1572:
1573: //
1574: // Get volume control information
1575: //
1576:
1577: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1578: cdb->MODE_SENSE.PageCode = CDROM_AUDIO_CONTROL_PAGE;
1579: cdb->MODE_SENSE.AllocationLength = MODE_DATA_SIZE;
1580:
1581: srb.CdbLength = 6;
1582:
1583: //
1584: // Set timeout value.
1585: //
1586:
1587: srb.TimeOutValue = deviceExtension->TimeOutValue;
1588:
1589: status = ScsiClassSendSrbSynchronous(DeviceObject,
1590: &srb,
1591: outputBuffer,
1592: MODE_DATA_SIZE,
1593: FALSE);
1594:
1595: if (SRB_STATUS(srb.SrbStatus) == SRB_STATUS_DATA_OVERRUN) {
1596: status = STATUS_SUCCESS;
1597: }
1598:
1599: if (NT_SUCCESS(status)) {
1600:
1601: audioOutput = ScsiClassFindModePage( outputBuffer,
1602: srb.DataTransferLength,
1603: CDROM_AUDIO_CONTROL_PAGE);
1604:
1605: //
1606: // Verify the page is as big as expected.
1607: //
1608:
1609: bytesTransferred = (PCHAR) audioOutput - (PCHAR) outputBuffer +
1610: sizeof(AUDIO_OUTPUT);
1611:
1612: if (audioOutput != NULL &&
1613: srb.DataTransferLength >= bytesTransferred) {
1614:
1615: for (i=0; i<4; i++) {
1616: volumeControl->PortVolume[i] =
1617: audioOutput->PortOutput[i].Volume;
1618: }
1619:
1620: //
1621: // Set bytes transferred in IRP.
1622: //
1623:
1624: Irp->IoStatus.Information = sizeof(VOLUME_CONTROL);
1625:
1626: } else {
1627: status = STATUS_INVALID_DEVICE_REQUEST;
1628: }
1629:
1630: }
1631:
1632: //
1633: // Free buffer.
1634: //
1635:
1636: ExFreePool(outputBuffer);
1637: }
1638:
1639: break;
1640:
1641: case IOCTL_CDROM_SET_VOLUME:
1642:
1643: DebugPrint((2, "ScsiCdRomDeviceControl: Set volume control\n"));
1644:
1645: {
1646:
1647: PAUDIO_OUTPUT audioOutput;
1648: PAUDIO_OUTPUT audioInput;
1649: PVOID inputBuffer;
1650: PVOLUME_CONTROL volumeControl = Irp->AssociatedIrp.SystemBuffer;
1651: ULONG i;
1652:
1653: if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
1654: sizeof(VOLUME_CONTROL)) {
1655:
1656: //
1657: // Indicate unsuccessful status.
1658: //
1659:
1660: status = STATUS_BUFFER_TOO_SMALL;
1661: break;
1662: }
1663:
1664: //
1665: // Get the current audio contorl information so that the
1666: // port control information can be filled in.
1667: // Allocate buffer for volume control information.
1668: //
1669:
1670: inputBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1671: MODE_DATA_SIZE);
1672:
1673: if (!inputBuffer) {
1674: status = STATUS_INSUFFICIENT_RESOURCES;
1675: Irp->IoStatus.Information = 0;
1676: break;
1677: }
1678:
1679: //
1680: // In case not as much as expected is returned zero
1681: // all of this.
1682: //
1683:
1684: RtlZeroMemory(inputBuffer, MODE_DATA_SIZE);
1685:
1686: //
1687: // Get volume control information
1688: //
1689:
1690: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
1691: cdb->MODE_SENSE.PageCode = CDROM_AUDIO_CONTROL_PAGE;
1692: cdb->MODE_SENSE.AllocationLength = MODE_DATA_SIZE;
1693:
1694: srb.CdbLength = 6;
1695:
1696: //
1697: // Set timeout value.
1698: //
1699:
1700: srb.TimeOutValue = deviceExtension->TimeOutValue;
1701:
1702: status = ScsiClassSendSrbSynchronous(DeviceObject,
1703: &srb,
1704: inputBuffer,
1705: MODE_DATA_SIZE,
1706: FALSE);
1707:
1708: if (SRB_STATUS(srb.SrbStatus) == SRB_STATUS_DATA_OVERRUN) {
1709: status = STATUS_SUCCESS;
1710: }
1711:
1712: if (NT_SUCCESS(status)) {
1713:
1714: audioInput = ScsiClassFindModePage( inputBuffer,
1715: srb.DataTransferLength,
1716: CDROM_AUDIO_CONTROL_PAGE);
1717:
1718: if (audioInput == NULL) {
1719: status = STATUS_INVALID_DEVICE_REQUEST;
1720: }
1721:
1722: //
1723: // Verify the page is as big as expected.
1724: //
1725:
1726: i = (PCHAR) audioInput - (PCHAR) inputBuffer + sizeof(AUDIO_OUTPUT);
1727:
1728: if (srb.DataTransferLength < i) {
1729: status = STATUS_INVALID_DEVICE_REQUEST;
1730: }
1731:
1732: }
1733:
1734: if (!NT_SUCCESS(status)) {
1735:
1736: //
1737: // Free buffer.
1738: //
1739:
1740: ExFreePool(inputBuffer);
1741:
1742: break;
1743: }
1744:
1745: //
1746: // Mode select buffer is the size of the audio page plus a
1747: // mode parameter header.
1748: //
1749:
1750: bytesTransferred = sizeof(AUDIO_OUTPUT) + sizeof(MODE_PARAMETER_HEADER);
1751:
1752: //
1753: // Allocate buffer for volume control information.
1754: //
1755:
1756: outputBuffer = ExAllocatePool(NonPagedPoolCacheAligned,
1757: bytesTransferred);
1758:
1759: if (!outputBuffer) {
1760: status = STATUS_INSUFFICIENT_RESOURCES;
1761: Irp->IoStatus.Information = 0;
1762: break;
1763: }
1764:
1765: //
1766: // Zero the buffer. The mode parameter header will be left as zeros.
1767: // Also clear the srb again.
1768: //
1769:
1770: RtlZeroMemory(outputBuffer, bytesTransferred);
1771: RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
1772:
1773: //
1774: // Set volume control information
1775: //
1776:
1777: cdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
1778: cdb->MODE_SELECT.ParameterListLength = (UCHAR) bytesTransferred;
1779: cdb->MODE_SELECT.PFBit = 1;
1780:
1781: srb.CdbLength = 6;
1782:
1783: audioOutput = (PAUDIO_OUTPUT) ((PCHAR) outputBuffer
1784: + sizeof(MODE_PARAMETER_HEADER));
1785:
1786: //
1787: // Fill in the volume setting and the port control.
1788: //
1789:
1790: for (i=0; i<4; i++) {
1791: audioOutput->PortOutput[i].Volume =
1792: volumeControl->PortVolume[i];
1793: audioOutput->PortOutput[i].ChannelSelection =
1794: audioInput->PortOutput[i].ChannelSelection;
1795: }
1796:
1797: audioOutput->CodePage = CDROM_AUDIO_CONTROL_PAGE;
1798: audioOutput->ParameterLength = sizeof(AUDIO_OUTPUT) - 2;
1799: audioOutput->Immediate = MODE_SELECT_IMMEDIATE;
1800:
1801: //
1802: // Set timeout value.
1803: //
1804:
1805: srb.TimeOutValue = deviceExtension->TimeOutValue;
1806:
1807: status = ScsiClassSendSrbSynchronous(DeviceObject,
1808: &srb,
1809: outputBuffer,
1810: bytesTransferred,
1811: TRUE);
1812:
1813: //
1814: // Set bytes transferred in IRP.
1815: //
1816:
1817: Irp->IoStatus.Information = sizeof(VOLUME_CONTROL);
1818:
1819: //
1820: // Free buffers.
1821: //
1822:
1823: ExFreePool(inputBuffer);
1824: ExFreePool(outputBuffer);
1825:
1826: break;
1827: }
1828:
1829: case IOCTL_CDROM_STOP_AUDIO:
1830:
1831: //
1832: // Stop play.
1833: //
1834:
1835: DebugPrint((2, "ScsiCdRomDeviceControl: Stop audio\n"));
1836:
1837: PLAY_ACTIVE(deviceExtension) = FALSE;
1838:
1839: cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
1840:
1841: cdb->START_STOP.Immediate = 1;
1842: cdb->START_STOP.Start = 0;
1843: cdb->START_STOP.LoadEject = 0;
1844:
1845: srb.CdbLength = 6;
1846:
1847: //
1848: // Set timeout value.
1849: //
1850:
1851: srb.TimeOutValue = deviceExtension->TimeOutValue;
1852:
1853: status = ScsiClassSendSrbSynchronous(DeviceObject,
1854: &srb,
1855: NULL,
1856: 0,
1857: FALSE);
1858: break;
1859:
1860: case IOCTL_CDROM_CHECK_VERIFY:
1861:
1862: srb.CdbLength = 6;
1863:
1864: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
1865:
1866: //
1867: // Set timeout value.
1868: //
1869:
1870: srb.TimeOutValue = deviceExtension->TimeOutValue * 2;
1871:
1872: status = ScsiClassSendSrbSynchronous(DeviceObject,
1873: &srb,
1874: NULL,
1875: 0,
1876: FALSE);
1877:
1878: //
1879: // If the status is verify required, redo the test unit ready to
1880: // verify that the cd-rom is done spinning up.
1881: // ScsiClassSendSrbSynchronous will wait for a while for the device to
1882: // spin up.
1883: //
1884:
1885: if (status == STATUS_VERIFY_REQUIRED) {
1886:
1887: srb.CdbLength = 6;
1888:
1889: cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
1890:
1891: //
1892: // Set timeout value.
1893: //
1894:
1895: srb.TimeOutValue = deviceExtension->TimeOutValue * 2;
1896:
1897: status2 = ScsiClassSendSrbSynchronous(DeviceObject,
1898: &srb,
1899: NULL,
1900: 0,
1901: FALSE);
1902:
1903: DebugPrint((1, "ScsiCdromDeviceControl: Status from second test unit ready is: %lx\n", status2));
1904: }
1905:
1906: //
1907: // Update the play active flag.
1908: //
1909:
1910: if (!CdRomIsPlayActive(DeviceObject) &&
1911: LiEqlZero(deviceExtension->PartitionLength)) {
1912:
1913: //
1914: // If play is not active and the volume needs verification then
1915: // get read capicity again.
1916: //
1917:
1918: status2 = ScsiClassReadDriveCapacity(DeviceObject);
1919:
1920: if ((!NT_SUCCESS(status2)) ||
1921: (deviceExtension->DiskGeometry->BytesPerSector == 0)) {
1922:
1923: //
1924: // Set disk geometry to default values (per ISO 9660).
1925: //
1926:
1927: deviceExtension->DiskGeometry->BytesPerSector = 2048;
1928: deviceExtension->SectorShift = 11;
1929: }
1930: }
1931:
1932: break;
1933:
1934: default:
1935:
1936: //
1937: // Pass the request to the common device control routine.
1938: //
1939:
1940: return(ScsiClassDeviceControl(DeviceObject, Irp));
1941:
1942: break;
1943:
1944: } // end switch()
1945:
1946: if (status == STATUS_VERIFY_REQUIRED) {
1947:
1948: //
1949: // If the status is verified required and the this request
1950: // should bypass verify required then retry the request.
1951: //
1952:
1953: if (irpStack->Flags & SL_OVERRIDE_VERIFY_VOLUME) {
1954:
1955: status = STATUS_IO_DEVICE_ERROR;
1956: goto RetryControl;
1957:
1958: }
1959:
1960: }
1961:
1962: if (IoIsErrorUserInduced(status)) {
1963:
1964: IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
1965:
1966: }
1967:
1968: //
1969: // Update IRP with completion status.
1970: //
1971:
1972: Irp->IoStatus.Status = status;
1973:
1974: //
1975: // Complete the request.
1976: //
1977:
1978: IoCompleteRequest(Irp, IO_DISK_INCREMENT);
1979: DebugPrint((2, "ScsiCdromDeviceControl: Status is %lx\n", status));
1980: return status;
1981:
1982: } // end ScsiCdromDeviceControl()
1983:
1984:
1985: VOID
1986: ScanForSpecial(
1987: PDEVICE_OBJECT DeviceObject,
1988: PINQUIRYDATA InquiryData,
1989: PIO_SCSI_CAPABILITIES PortCapabilities
1990: )
1991:
1992: /*++
1993:
1994: Routine Description:
1995:
1996: This function checks to see if an SCSI logical unit requires an special
1997: initialization or error processing.
1998:
1999: Arguments:
2000:
2001: DeviceObject - Supplies the device object to be tested.
2002:
2003: InquiryData - Supplies the inquiry data returned by the device of interest.
2004:
2005: PortCapabilities - Supplies the capabilities of the device object.
2006:
2007: Return Value:
2008:
2009: None.
2010:
2011: --*/
2012:
2013: {
2014: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
2015:
2016: //
2017: // Look for a Hitachi CDR-1750. Read-ahead must be disabled in order
2018: // to get this cdrom drive to work on scsi adapters that use PIO.
2019: //
2020:
2021: if ((strncmp(InquiryData->VendorId, "HITACHI CDR-1750S", strlen("HITACHI CDR-1750S")) == 0 ||
2022: strncmp(InquiryData->VendorId, "HITACHI CDR-3650/1650S", strlen("HITACHI CDR-3650/1650S")) == 0)
2023: && PortCapabilities->AdapterUsesPio) {
2024:
2025: DebugPrint((1, "ScsiCdrom ScanForSpecial: Found Hitachi CDR-1750S.\n"));
2026:
2027: //
2028: // Setup an error handler to reinitialize the cd rom after it is reset.
2029: //
2030:
2031: deviceExtension->ClassError = HitachProcessError;
2032: }
2033:
2034: return;
2035: }
2036:
2037: VOID
2038: HitachProcessError(
2039: PDEVICE_OBJECT DeviceObject,
2040: PSCSI_REQUEST_BLOCK Srb,
2041: NTSTATUS *Status,
2042: BOOLEAN *Retry
2043: )
2044: /*++
2045:
2046: Routine Description:
2047:
2048: This routine checks the type of error. If the error indicates CD-ROM the
2049: CD-ROM needs to be reinitialized then a Mode sense command is sent to the
2050: device. This command disables read-ahead for the device.
2051:
2052: Arguments:
2053:
2054: DeviceObject - Supplies a pointer to the device object.
2055:
2056: Srb - Supplies a pointer to the failing Srb.
2057:
2058: Status - Not used.
2059:
2060: Retry - Not used.
2061:
2062: Return Value:
2063:
2064: None.
2065:
2066: --*/
2067:
2068: {
2069: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
2070: PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
2071: LARGE_INTEGER largeInt = LiFromUlong(1);
2072: PUCHAR modePage;
2073: PIO_STACK_LOCATION irpStack;
2074: PIRP irp;
2075: PSCSI_REQUEST_BLOCK srb;
2076: PCOMPLETION_CONTEXT context;
2077: PCDB cdb;
2078: ULONG alignment;
2079:
2080: UNREFERENCED_PARAMETER(Status);
2081: UNREFERENCED_PARAMETER(Retry);
2082:
2083: //
2084: // Check the status. The initialization command only needs to be sent
2085: // if UNIT ATTENTION is returned.
2086: //
2087:
2088: if (!(Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID)) {
2089:
2090: //
2091: // The drive does not require reinitialization.
2092: //
2093:
2094: return;
2095: }
2096:
2097: //
2098: // Found a bad HITACHI cd-rom. These devices do not work with PIO
2099: // adapters when read-ahead is enabled. Read-ahead is disabled by
2100: // a mode select command. The mode select page code is zero and the
2101: // length is 6 bytes. All of the other bytes should be zero.
2102: //
2103:
2104:
2105: if ((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_UNIT_ATTENTION) {
2106:
2107: DebugPrint((1, "HitachiProcessError: Reinitializing the CD-ROM.\n"));
2108:
2109: //
2110: // Send the special mode select command to disable read-ahead
2111: // on the CD-ROM reader.
2112: //
2113:
2114: alignment = DeviceObject->AlignmentRequirement ?
2115: DeviceObject->AlignmentRequirement : 1;
2116:
2117: context = ExAllocatePool(
2118: NonPagedPool,
2119: sizeof(COMPLETION_CONTEXT) + HITACHI_MODE_DATA_SIZE + alignment
2120: );
2121:
2122: if (context == NULL) {
2123:
2124: //
2125: // If there is not enough memory to fulfill this request,
2126: // simply return. A subsequent retry will fail and another
2127: // chance to start the unit.
2128: //
2129:
2130: return;
2131: }
2132:
2133: context->DeviceObject = DeviceObject;
2134: srb = &context->Srb;
2135:
2136: RtlZeroMemory(srb, SCSI_REQUEST_BLOCK_SIZE);
2137:
2138: //
2139: // Write length to SRB.
2140: //
2141:
2142: srb->Length = SCSI_REQUEST_BLOCK_SIZE;
2143:
2144: //
2145: // Set up SCSI bus address.
2146: //
2147:
2148: srb->PathId = deviceExtension->PathId;
2149: srb->TargetId = deviceExtension->TargetId;
2150: srb->Lun = deviceExtension->Lun;
2151:
2152: srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
2153: srb->TimeOutValue = deviceExtension->TimeOutValue;
2154:
2155: //
2156: // Set the transfer length.
2157: //
2158:
2159: srb->DataTransferLength = HITACHI_MODE_DATA_SIZE;
2160: srb->SrbFlags = SRB_FLAGS_DATA_OUT | SRB_FLAGS_DISABLE_AUTOSENSE | SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
2161:
2162: //
2163: // The data buffer must be aligned.
2164: //
2165:
2166: srb->DataBuffer = (PVOID) (((ULONG) (context + 1) + (alignment - 1)) &
2167: ~(alignment - 1));
2168:
2169:
2170: //
2171: // Build the HITACHI read-ahead mode select CDB.
2172: //
2173:
2174: srb->CdbLength = 6;
2175: cdb = (PCDB)srb->Cdb;
2176: cdb->MODE_SENSE.LogicalUnitNumber = srb->Lun;
2177: cdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SELECT;
2178: cdb->MODE_SENSE.AllocationLength = HITACHI_MODE_DATA_SIZE;
2179:
2180: //
2181: // Initialize the mode sense data.
2182: //
2183:
2184: modePage = srb->DataBuffer;
2185:
2186: RtlZeroMemory(modePage, HITACHI_MODE_DATA_SIZE);
2187:
2188: //
2189: // Set the page length field to 6.
2190: //
2191:
2192: modePage[5] = 6;
2193:
2194: //
2195: // Build the asynchronous request to be sent to the port driver.
2196: //
2197:
2198: irp = IoBuildAsynchronousFsdRequest(IRP_MJ_WRITE,
2199: DeviceObject,
2200: srb->DataBuffer,
2201: srb->DataTransferLength,
2202: &largeInt,
2203: NULL);
2204:
2205: IoSetCompletionRoutine(irp,
2206: (PIO_COMPLETION_ROUTINE)ScsiClassAsynchronousCompletion,
2207: context,
2208: TRUE,
2209: TRUE,
2210: TRUE);
2211:
2212: irpStack = IoGetNextIrpStackLocation(irp);
2213:
2214: irpStack->MajorFunction = IRP_MJ_SCSI;
2215:
2216: srb->OriginalRequest = irp;
2217:
2218: //
2219: // Save SRB address in next stack for port driver.
2220: //
2221:
2222: irpStack->Parameters.Scsi.Srb = (PVOID)srb;
2223:
2224: //
2225: // Set up IRP Address.
2226: //
2227:
2228: (VOID)IoCallDriver(deviceExtension->PortDeviceObject, irp);
2229:
2230: }
2231: }
2232:
2233: BOOLEAN
2234: CdRomIsPlayActive(
2235: IN PDEVICE_OBJECT DeviceObject
2236: )
2237:
2238: /*++
2239:
2240: Routine Description:
2241:
2242: This routine determines if the cd is currently playing music.
2243:
2244: Arguments:
2245:
2246: DeviceObject - Device object to test.
2247:
2248: Return Value:
2249:
2250: TRUE if the device is playing music.
2251:
2252: --*/
2253: {
2254: PDEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
2255: PIRP irp;
2256: IO_STATUS_BLOCK ioStatus;
2257: KEVENT event;
2258: NTSTATUS status;
2259: PSUB_Q_CURRENT_POSITION currentBuffer;
2260:
2261: if (!PLAY_ACTIVE(deviceExtension)) {
2262: return(FALSE);
2263: }
2264:
2265: currentBuffer = ExAllocatePool(NonPagedPoolCacheAligned, sizeof(SUB_Q_CURRENT_POSITION));
2266:
2267: if (currentBuffer == NULL) {
2268: return(FALSE);
2269: }
2270:
2271: ((PCDROM_SUB_Q_DATA_FORMAT) currentBuffer)->Format = IOCTL_CDROM_CURRENT_POSITION;
2272: ((PCDROM_SUB_Q_DATA_FORMAT) currentBuffer)->Track = 0;
2273:
2274: //
2275: // Create notification event object to be used to signal the
2276: // request completion.
2277: //
2278:
2279: KeInitializeEvent(&event, NotificationEvent, FALSE);
2280:
2281: //
2282: // Build the synchronous request to be sent to the port driver
2283: // to perform the request.
2284: //
2285:
2286: irp = IoBuildDeviceIoControlRequest(IOCTL_CDROM_READ_Q_CHANNEL,
2287: deviceExtension->DeviceObject,
2288: currentBuffer,
2289: sizeof(CDROM_SUB_Q_DATA_FORMAT),
2290: currentBuffer,
2291: sizeof(SUB_Q_CURRENT_POSITION),
2292: FALSE,
2293: &event,
2294: &ioStatus);
2295:
2296: if (irp == NULL) {
2297: ExFreePool(currentBuffer);
2298: return FALSE;
2299: }
2300:
2301: //
2302: // Pass request to port driver and wait for request to complete.
2303: //
2304:
2305: status = IoCallDriver(deviceExtension->DeviceObject, irp);
2306:
2307: if (status == STATUS_PENDING) {
2308: KeWaitForSingleObject(&event, Suspended, KernelMode, FALSE, NULL);
2309: status = ioStatus.Status;
2310: }
2311:
2312: if (!NT_SUCCESS(status)) {
2313: ExFreePool(currentBuffer);
2314: return FALSE;
2315: }
2316:
2317: ExFreePool(currentBuffer);
2318:
2319: return(PLAY_ACTIVE(deviceExtension));
2320:
2321: }
2322:
2323:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.