1437 lines
44 KiB
C
1437 lines
44 KiB
C
/*--
|
||
|
||
Copyright (C) Microsoft Corporation, 2000
|
||
|
||
Module Name:
|
||
|
||
mmc.c
|
||
|
||
Abstract:
|
||
|
||
This file is used to extend cdrom.sys to detect and use mmc-compatible
|
||
drives' capabilities more wisely.
|
||
|
||
Environment:
|
||
|
||
kernel mode only
|
||
|
||
Notes:
|
||
|
||
SCSI Tape, CDRom and Disk class drivers share common routines
|
||
that can be found in the CLASS directory (..\ntos\dd\class).
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "ntddk.h"
|
||
#include "classpnp.h"
|
||
#include "cdrom.h"
|
||
#include "mmc.tmh"
|
||
|
||
|
||
|
||
NTSTATUS
|
||
CdRomGetConfiguration(
|
||
IN PDEVICE_OBJECT Fdo,
|
||
OUT PGET_CONFIGURATION_HEADER *Buffer,
|
||
OUT PULONG BytesReturned,
|
||
IN FEATURE_NUMBER StartingFeature,
|
||
IN ULONG RequestedType
|
||
);
|
||
VOID
|
||
CdRompPrintAllFeaturePages(
|
||
IN PGET_CONFIGURATION_HEADER Buffer,
|
||
IN ULONG Usable
|
||
);
|
||
NTSTATUS
|
||
CdRomUpdateMmcDriveCapabilitiesCompletion(
|
||
IN PDEVICE_OBJECT Unused,
|
||
IN PIRP Irp,
|
||
IN PDEVICE_OBJECT Fdo
|
||
);
|
||
VOID
|
||
CdRomPrepareUpdateCapabilitiesIrp(
|
||
PDEVICE_OBJECT Fdo
|
||
);
|
||
|
||
/*++
|
||
|
||
NOT DOCUMENTED YET - may be called at up to DISPATCH_LEVEL
|
||
if memory is non-paged
|
||
PRESUMES ALL DATA IS ACCESSIBLE based on FeatureBuffer
|
||
|
||
--*/
|
||
VOID
|
||
CdRomFindProfileInProfiles(
|
||
IN PFEATURE_DATA_PROFILE_LIST ProfileHeader,
|
||
IN FEATURE_PROFILE_TYPE ProfileToFind,
|
||
OUT PBOOLEAN Found
|
||
)
|
||
{
|
||
PFEATURE_DATA_PROFILE_LIST_EX profile;
|
||
ULONG numberOfProfiles;
|
||
ULONG i;
|
||
|
||
ASSERT((ProfileHeader->Header.AdditionalLength % 4) == 0);
|
||
|
||
*Found = FALSE;
|
||
|
||
numberOfProfiles = ProfileHeader->Header.AdditionalLength / 4;
|
||
profile = ProfileHeader->Profiles; // zero-sized array
|
||
|
||
for (i = 0; i < numberOfProfiles; i++) {
|
||
|
||
FEATURE_PROFILE_TYPE currentProfile;
|
||
|
||
currentProfile =
|
||
(profile->ProfileNumber[0] << 8) |
|
||
(profile->ProfileNumber[1] & 0xff);
|
||
|
||
if (currentProfile == ProfileToFind) {
|
||
|
||
*Found = TRUE;
|
||
|
||
}
|
||
|
||
profile++;
|
||
}
|
||
return;
|
||
|
||
}
|
||
|
||
|
||
/*++
|
||
|
||
NOT DOCUMENTED YET - may be called at up to DISPATCH_LEVEL
|
||
if memory is non-paged
|
||
|
||
--*/
|
||
PVOID
|
||
CdRomFindFeaturePage(
|
||
IN PGET_CONFIGURATION_HEADER FeatureBuffer,
|
||
IN ULONG Length,
|
||
IN FEATURE_NUMBER Feature
|
||
)
|
||
{
|
||
PUCHAR buffer;
|
||
PUCHAR limit;
|
||
|
||
if (Length < sizeof(GET_CONFIGURATION_HEADER) + sizeof(FEATURE_HEADER)) {
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// set limit to point to first illegal address
|
||
//
|
||
|
||
limit = (PUCHAR)FeatureBuffer;
|
||
limit += Length;
|
||
|
||
//
|
||
// set buffer to point to first page
|
||
//
|
||
|
||
buffer = FeatureBuffer->Data;
|
||
|
||
//
|
||
// loop through each page until we find the requested one, or
|
||
// until it's not safe to access the entire feature header
|
||
// (if equal, have exactly enough for the feature header)
|
||
//
|
||
while (buffer + sizeof(FEATURE_HEADER) <= limit) {
|
||
|
||
PFEATURE_HEADER header = (PFEATURE_HEADER)buffer;
|
||
FEATURE_NUMBER thisFeature;
|
||
|
||
thisFeature =
|
||
(header->FeatureCode[0] << 8) |
|
||
(header->FeatureCode[1]);
|
||
|
||
if (thisFeature == Feature) {
|
||
|
||
PUCHAR temp;
|
||
|
||
//
|
||
// if don't have enough memory to safely access all the feature
|
||
// information, return NULL
|
||
//
|
||
temp = buffer;
|
||
temp += sizeof(FEATURE_HEADER);
|
||
temp += header->AdditionalLength;
|
||
|
||
if (temp > limit) {
|
||
|
||
//
|
||
// this means the transfer was cut-off, an insufficiently
|
||
// small buffer was given, or other arbitrary error. since
|
||
// it's not safe to view the amount of data (even though
|
||
// the header is safe) in this feature, pretend it wasn't
|
||
// transferred at all...
|
||
//
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"Feature %x exists, but not safe to access all its "
|
||
"data. returning NULL\n", Feature));
|
||
return NULL;
|
||
} else {
|
||
return buffer;
|
||
}
|
||
}
|
||
|
||
if (header->AdditionalLength % 4) {
|
||
ASSERT(!"Feature page AdditionalLength field must be integral multiple of 4!\n");
|
||
return NULL;
|
||
}
|
||
|
||
buffer += sizeof(FEATURE_HEADER);
|
||
buffer += header->AdditionalLength;
|
||
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/*++
|
||
|
||
Private so we can later expose to someone wanting to use a preallocated buffer
|
||
|
||
--*/
|
||
NTSTATUS
|
||
CdRompGetConfiguration(
|
||
IN PDEVICE_OBJECT Fdo,
|
||
IN PGET_CONFIGURATION_HEADER Buffer,
|
||
IN ULONG BufferSize,
|
||
OUT PULONG ValidBytes,
|
||
IN FEATURE_NUMBER StartingFeature,
|
||
IN ULONG RequestedType
|
||
)
|
||
{
|
||
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
|
||
PCDROM_DATA cdData;
|
||
SCSI_REQUEST_BLOCK srb;
|
||
PCDB cdb;
|
||
ULONG_PTR returned;
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
ASSERT(Buffer);
|
||
ASSERT(ValidBytes);
|
||
|
||
*ValidBytes = 0;
|
||
returned = 0;
|
||
|
||
RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
|
||
RtlZeroMemory(Buffer, BufferSize);
|
||
|
||
fdoExtension = Fdo->DeviceExtension;
|
||
cdData = (PCDROM_DATA)(fdoExtension->CommonExtension.DriverData);
|
||
|
||
if (TEST_FLAG(cdData->HackFlags, CDROM_HACK_BAD_GET_CONFIG_SUPPORT)) {
|
||
return STATUS_INVALID_DEVICE_REQUEST;
|
||
}
|
||
|
||
srb.TimeOutValue = CDROM_GET_CONFIGURATION_TIMEOUT;
|
||
srb.CdbLength = 10;
|
||
|
||
cdb = (PCDB)srb.Cdb;
|
||
cdb->GET_CONFIGURATION.OperationCode = SCSIOP_GET_CONFIGURATION;
|
||
cdb->GET_CONFIGURATION.RequestType = (UCHAR)RequestedType;
|
||
cdb->GET_CONFIGURATION.StartingFeature[0] = (UCHAR)(StartingFeature >> 8);
|
||
cdb->GET_CONFIGURATION.StartingFeature[1] = (UCHAR)(StartingFeature & 0xff);
|
||
cdb->GET_CONFIGURATION.AllocationLength[0] = (UCHAR)(BufferSize >> 8);
|
||
cdb->GET_CONFIGURATION.AllocationLength[1] = (UCHAR)(BufferSize & 0xff);
|
||
|
||
status = ClassSendSrbSynchronous(Fdo, &srb, Buffer,
|
||
BufferSize, FALSE);
|
||
returned = srb.DataTransferLength;
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: Status was %x\n", status));
|
||
|
||
if (NT_SUCCESS(status) || status == STATUS_BUFFER_OVERFLOW) {
|
||
|
||
//
|
||
// if returned more than can be stored in a ULONG, return false
|
||
//
|
||
|
||
if (returned > (ULONG)(-1)) {
|
||
return STATUS_UNSUCCESSFUL;
|
||
}
|
||
ASSERT(returned <= BufferSize);
|
||
*ValidBytes = (ULONG)returned;
|
||
return STATUS_SUCCESS;
|
||
|
||
} else {
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: failed %x\n", status));
|
||
return status;
|
||
|
||
}
|
||
ASSERT(FALSE);
|
||
return STATUS_UNSUCCESSFUL;
|
||
}
|
||
|
||
/*++
|
||
|
||
Allocates buffer with configuration info, returns STATUS_SUCCESS
|
||
or an error if one occurred
|
||
|
||
NOTE: does not handle case where more than 65000 bytes are returned,
|
||
which requires multiple calls with different starting feature
|
||
numbers.
|
||
|
||
--*/
|
||
NTSTATUS
|
||
CdRomGetConfiguration(
|
||
IN PDEVICE_OBJECT Fdo,
|
||
OUT PGET_CONFIGURATION_HEADER *Buffer,
|
||
OUT PULONG BytesReturned,
|
||
IN FEATURE_NUMBER StartingFeature,
|
||
IN ULONG RequestedType
|
||
)
|
||
{
|
||
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
|
||
GET_CONFIGURATION_HEADER header; // eight bytes, not a lot
|
||
PGET_CONFIGURATION_HEADER buffer;
|
||
ULONG returned;
|
||
ULONG size;
|
||
ULONG i;
|
||
NTSTATUS status;
|
||
|
||
PAGED_CODE();
|
||
|
||
|
||
fdoExtension = Fdo->DeviceExtension;
|
||
*Buffer = NULL;
|
||
*BytesReturned = 0;
|
||
|
||
buffer = NULL;
|
||
returned = 0;
|
||
|
||
//
|
||
// send the first request down to just get the header
|
||
//
|
||
|
||
status = CdRompGetConfiguration(Fdo, &header, sizeof(header),
|
||
&returned, StartingFeature, RequestedType);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
return status;
|
||
}
|
||
|
||
//
|
||
// now try again, using information returned to allocate
|
||
// just enough memory
|
||
//
|
||
|
||
size = header.DataLength[0] << 24 |
|
||
header.DataLength[1] << 16 |
|
||
header.DataLength[2] << 8 |
|
||
header.DataLength[3] << 0 ;
|
||
|
||
|
||
for (i = 0; i < 4; i++) {
|
||
|
||
//
|
||
// the datalength field is the size *following*
|
||
// itself, so adjust accordingly
|
||
//
|
||
|
||
size += 4*sizeof(UCHAR);
|
||
|
||
//
|
||
// make sure the size is reasonable
|
||
//
|
||
|
||
if (size <= sizeof(FEATURE_HEADER)) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: drive reports only %x bytes?\n",
|
||
size));
|
||
return STATUS_UNSUCCESSFUL;
|
||
}
|
||
|
||
//
|
||
// allocate the memory
|
||
//
|
||
|
||
buffer = (PGET_CONFIGURATION_HEADER)
|
||
ExAllocatePoolWithTag(NonPagedPoolCacheAligned,
|
||
size,
|
||
CDROM_TAG_FEATURE);
|
||
|
||
if (buffer == NULL) {
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
//
|
||
// send the first request down to just get the header
|
||
//
|
||
|
||
status = CdRompGetConfiguration(Fdo, buffer, size, &returned,
|
||
StartingFeature, RequestedType);
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
ExFreePool(buffer);
|
||
return status;
|
||
}
|
||
|
||
if (returned > size) {
|
||
ExFreePool(buffer);
|
||
return STATUS_INTERNAL_ERROR;
|
||
}
|
||
|
||
returned = buffer->DataLength[0] << 24 |
|
||
buffer->DataLength[1] << 16 |
|
||
buffer->DataLength[2] << 8 |
|
||
buffer->DataLength[3] << 0 ;
|
||
returned += 4*sizeof(UCHAR);
|
||
|
||
if (returned <= size) {
|
||
*Buffer = buffer;
|
||
*BytesReturned = size; // amount of 'safe' memory
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
//
|
||
// else retry using the new size....
|
||
//
|
||
|
||
size = returned;
|
||
ExFreePool(buffer);
|
||
buffer = NULL;
|
||
|
||
}
|
||
|
||
//
|
||
// it failed after a number of attempts, so just fail.
|
||
//
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomGetConfiguration: Failed %d attempts to get all feature "
|
||
"information\n", i));
|
||
return STATUS_IO_DEVICE_ERROR;
|
||
}
|
||
|
||
VOID
|
||
CdRomIsDeviceMmcDevice(
|
||
IN PDEVICE_OBJECT Fdo,
|
||
OUT PBOOLEAN IsMmc
|
||
)
|
||
{
|
||
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
|
||
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
|
||
PCDROM_DATA cdData = commonExtension->DriverData;
|
||
GET_CONFIGURATION_HEADER localHeader;
|
||
NTSTATUS status;
|
||
ULONG usable;
|
||
ULONG size;
|
||
ULONG previouslyFailed;
|
||
|
||
PAGED_CODE();
|
||
ASSERT( commonExtension->IsFdo );
|
||
|
||
*IsMmc = FALSE;
|
||
|
||
//
|
||
// read the registry in case the drive failed previously,
|
||
// and a timeout is occurring.
|
||
//
|
||
|
||
previouslyFailed = FALSE;
|
||
ClassGetDeviceParameter(fdoExtension,
|
||
CDROM_SUBKEY_NAME,
|
||
CDROM_NON_MMC_DRIVE_NAME,
|
||
&previouslyFailed
|
||
);
|
||
|
||
if (previouslyFailed) {
|
||
SET_FLAG(cdData->HackFlags, CDROM_HACK_BAD_GET_CONFIG_SUPPORT);
|
||
}
|
||
|
||
//
|
||
// check for the following profiles:
|
||
//
|
||
// ProfileList
|
||
//
|
||
|
||
status = CdRompGetConfiguration(Fdo,
|
||
&localHeader,
|
||
sizeof(localHeader),
|
||
&usable,
|
||
FeatureProfileList,
|
||
SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL);
|
||
|
||
if (status == STATUS_INVALID_DEVICE_REQUEST ||
|
||
status == STATUS_NO_MEDIA_IN_DEVICE ||
|
||
status == STATUS_IO_DEVICE_ERROR ||
|
||
status == STATUS_IO_TIMEOUT) {
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"GetConfiguration Failed (%x), device %p not mmc-compliant\n",
|
||
status, Fdo
|
||
));
|
||
previouslyFailed = TRUE;
|
||
ClassSetDeviceParameter(fdoExtension,
|
||
CDROM_SUBKEY_NAME,
|
||
CDROM_NON_MMC_DRIVE_NAME,
|
||
previouslyFailed
|
||
);
|
||
return;
|
||
|
||
} else if (!NT_SUCCESS(status)) {
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugError,
|
||
"GetConfiguration Failed, status %x -- defaulting to -ROM\n",
|
||
status));
|
||
return;
|
||
|
||
} else if (usable < sizeof(GET_CONFIGURATION_HEADER)) {
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"GetConfiguration Failed, returned only %x bytes!\n", usable));
|
||
previouslyFailed = TRUE;
|
||
ClassSetDeviceParameter(fdoExtension,
|
||
CDROM_SUBKEY_NAME,
|
||
CDROM_NON_MMC_DRIVE_NAME,
|
||
previouslyFailed
|
||
);
|
||
return;
|
||
|
||
}
|
||
|
||
size = (localHeader.DataLength[0] << 24) |
|
||
(localHeader.DataLength[1] << 16) |
|
||
(localHeader.DataLength[2] << 8) |
|
||
(localHeader.DataLength[3] << 0);
|
||
|
||
if(size <= 4) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"GetConfiguration Failed, claims MMC support but doesn't "
|
||
"correctly return config length!\n"));
|
||
return;
|
||
}
|
||
|
||
size += 4; // sizeof the datalength fields
|
||
|
||
#if DBG
|
||
{
|
||
PGET_CONFIGURATION_HEADER dbgBuffer;
|
||
NTSTATUS dbgStatus;
|
||
|
||
dbgBuffer = ExAllocatePoolWithTag(NonPagedPoolCacheAligned,
|
||
(SIZE_T)size,
|
||
CDROM_TAG_FEATURE);
|
||
if (dbgBuffer != NULL) {
|
||
RtlZeroMemory(dbgBuffer, size);
|
||
|
||
dbgStatus = CdRompGetConfiguration(Fdo, dbgBuffer, size,
|
||
&size, FeatureProfileList,
|
||
SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL);
|
||
|
||
if (NT_SUCCESS(dbgStatus)) {
|
||
CdRompPrintAllFeaturePages(dbgBuffer, usable);
|
||
}
|
||
ExFreePool(dbgBuffer);
|
||
}
|
||
}
|
||
#endif // DBG
|
||
|
||
*IsMmc = TRUE;
|
||
return;
|
||
}
|
||
|
||
VOID
|
||
CdRompPrintAllFeaturePages(
|
||
IN PGET_CONFIGURATION_HEADER Buffer,
|
||
IN ULONG Usable
|
||
)
|
||
{
|
||
PFEATURE_HEADER header;
|
||
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
// items expected to ALWAYS be current
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureProfileList);
|
||
if (header != NULL) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: CurrentProfile %x "
|
||
"with %x bytes of data at %p\n",
|
||
Buffer->CurrentProfile[0] << 8 |
|
||
Buffer->CurrentProfile[1],
|
||
Usable, Buffer));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureCore);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"CORE Features"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureMorphing);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Morphing"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureMultiRead);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Multi-Read"
|
||
));
|
||
}
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureRemovableMedium);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Removable Medium"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureTimeout);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Timeouts"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeaturePowerManagement);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Power Management"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureEmbeddedChanger);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Embedded Changer"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureLogicalUnitSerialNumber);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"LUN Serial Number"
|
||
));
|
||
}
|
||
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureMicrocodeUpgrade);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Microcode Update"
|
||
));
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
// items expected not to always be current
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureCDAudioAnalogPlay);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Analogue CD Audio Operations"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureCdRead);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"reading from CD-ROM/R/RW"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureCdMastering);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"CD Recording (Mastering)"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureCdTrackAtOnce);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"CD Recording (Track At Once)"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureDvdCSS);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"DVD CSS"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureDvdRead);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"DVD Structure Reads"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureDvdRecordableWrite);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"DVD Recording (Mastering)"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureDiscControlBlocks);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"DVD Disc Control Blocks"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureFormattable);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Formatting"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureRandomReadable);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Random Reads"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureRandomWritable);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Random Writes"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureRestrictedOverwrite);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Restricted Overwrites."
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureWriteOnce);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Write Once Media"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureSectorErasable);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Sector Erasable Media"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureIncrementalStreamingWritable);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Incremental Streaming Writing"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureRealTimeStreaming);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"Real-time Streaming Reads"
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureSMART);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"S.M.A.R.T."
|
||
));
|
||
}
|
||
|
||
header = CdRomFindFeaturePage(Buffer, Usable, FeatureDefectManagement);
|
||
if (header) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdromGetConfiguration: %s %s\n",
|
||
(header->Current ?
|
||
"Currently supports" : "Is able to support"),
|
||
"defect management"
|
||
));
|
||
}
|
||
return;
|
||
}
|
||
|
||
NTSTATUS
|
||
CdRomUpdateMmcDriveCapabilitiesCompletion(
|
||
IN PDEVICE_OBJECT Unused,
|
||
IN PIRP Irp,
|
||
IN PDEVICE_OBJECT Fdo
|
||
)
|
||
{
|
||
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
|
||
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
|
||
PCDROM_DATA cdData = fdoExtension->CommonExtension.DriverData;
|
||
PCDROM_MMC_EXTENSION mmcData = &(cdData->Mmc);
|
||
PSCSI_REQUEST_BLOCK srb = &(mmcData->CapabilitiesSrb);
|
||
PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
|
||
NTSTATUS status = STATUS_UNSUCCESSFUL;
|
||
PIRP delayedIrp;
|
||
|
||
// completion routine should retry as neccessary.
|
||
// when success, clear the flag to allow startio to proceed.
|
||
// else fail original request when retries are exhausted.
|
||
|
||
ASSERT(mmcData->CapabilitiesIrp == Irp);
|
||
|
||
// for now, if succeeded, just print the new pages.
|
||
|
||
if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) {
|
||
|
||
//
|
||
// ISSUE-2000/4/20-henrygab - should we try to reallocate if size
|
||
// available became larger than what we
|
||
// originally allocated? otherwise, it
|
||
// is possible (not probable) that we
|
||
// would miss the feature. can check
|
||
// that by finding out what the last
|
||
// feature is in the current group.
|
||
//
|
||
|
||
BOOLEAN retry;
|
||
ULONG retryInterval;
|
||
|
||
//
|
||
// Release the queue if it is frozen.
|
||
//
|
||
|
||
if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
|
||
ClassReleaseQueue(Fdo);
|
||
}
|
||
|
||
retry = ClassInterpretSenseInfo(
|
||
Fdo,
|
||
srb,
|
||
irpStack->MajorFunction,
|
||
0,
|
||
MAXIMUM_RETRIES - ((ULONG)(ULONG_PTR)irpStack->Parameters.Others.Argument4),
|
||
&status,
|
||
&retryInterval);
|
||
|
||
//
|
||
// DATA_OVERRUN is not an error in this case....
|
||
//
|
||
|
||
if (status == STATUS_DATA_OVERRUN) {
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
|
||
//
|
||
// override verify_volume based on original irp's settings
|
||
//
|
||
|
||
if (TEST_FLAG(irpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME) &&
|
||
status == STATUS_VERIFY_REQUIRED) {
|
||
status = STATUS_IO_DEVICE_ERROR;
|
||
retry = TRUE;
|
||
}
|
||
|
||
if (retry && ((ULONG)(ULONG_PTR)irpStack->Parameters.Others.Argument4)--) {
|
||
|
||
LARGE_INTEGER delay;
|
||
delay.QuadPart = retryInterval;
|
||
delay.QuadPart *= (LONGLONG)1000 * 1000 * 10;
|
||
|
||
//
|
||
// retry the request
|
||
//
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugError,
|
||
"Not using ClassRetryRequest Yet\n"));
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"Retry update capabilities %p\n", Irp));
|
||
CdRomPrepareUpdateCapabilitiesIrp(Fdo);
|
||
|
||
CdRomRetryRequest(fdoExtension, Irp, retryInterval, TRUE);
|
||
|
||
//
|
||
// ClassRetryRequest(Fdo, Irp, delay);
|
||
//
|
||
|
||
return STATUS_MORE_PROCESSING_REQUIRED;
|
||
|
||
}
|
||
|
||
} else {
|
||
|
||
status = STATUS_SUCCESS;
|
||
|
||
}
|
||
|
||
Irp->IoStatus.Status = status;
|
||
|
||
KeSetEvent(&mmcData->CapabilitiesEvent, IO_CD_ROM_INCREMENT, FALSE);
|
||
|
||
|
||
return STATUS_MORE_PROCESSING_REQUIRED;
|
||
}
|
||
|
||
|
||
VOID
|
||
CdRomPrepareUpdateCapabilitiesIrp(
|
||
PDEVICE_OBJECT Fdo
|
||
)
|
||
{
|
||
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
|
||
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
|
||
PCDROM_DATA cdData = fdoExtension->CommonExtension.DriverData;
|
||
PCDROM_MMC_EXTENSION mmcData = &(cdData->Mmc);
|
||
PIO_STACK_LOCATION nextStack;
|
||
PSCSI_REQUEST_BLOCK srb;
|
||
PCDB cdb;
|
||
ULONG bufferSize;
|
||
PIRP irp;
|
||
|
||
ASSERT(mmcData->UpdateState);
|
||
ASSERT(mmcData->NumDelayedIrps != 0);
|
||
ASSERT(mmcData->CapabilitiesIrp != NULL);
|
||
ASSERT(mmcData->CapabilitiesMdl != NULL);
|
||
ASSERT(mmcData->CapabilitiesBuffer);
|
||
ASSERT(mmcData->CapabilitiesBufferSize != 0);
|
||
ASSERT(fdoExtension->SenseData);
|
||
|
||
//
|
||
// do *NOT* call IoReuseIrp(), since it would zero out our
|
||
// current irp stack location, which we really don't want
|
||
// to happen. it would also set the current irp stack location
|
||
// to one greater than currently exists (to give max irp usage),
|
||
// but we don't want that either, since we use the top irp stack.
|
||
//
|
||
// IoReuseIrp(mmcData->CapabilitiesIrp, STATUS_UNSUCCESSFUL);
|
||
//
|
||
|
||
irp = mmcData->CapabilitiesIrp;
|
||
srb = &(mmcData->CapabilitiesSrb);
|
||
cdb = (PCDB)(srb->Cdb);
|
||
bufferSize = mmcData->CapabilitiesBufferSize;
|
||
|
||
//
|
||
// zero stuff out
|
||
//
|
||
|
||
RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
|
||
RtlZeroMemory(fdoExtension->SenseData, sizeof(SENSE_DATA));
|
||
RtlZeroMemory(mmcData->CapabilitiesBuffer, bufferSize);
|
||
|
||
//
|
||
// setup the srb
|
||
//
|
||
|
||
srb->TimeOutValue = CDROM_GET_CONFIGURATION_TIMEOUT;
|
||
srb->Length = SCSI_REQUEST_BLOCK_SIZE;
|
||
srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
|
||
srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
|
||
srb->SenseInfoBuffer = fdoExtension->SenseData;
|
||
srb->DataBuffer = mmcData->CapabilitiesBuffer;
|
||
srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
|
||
srb->DataTransferLength = mmcData->CapabilitiesBufferSize;
|
||
srb->ScsiStatus = 0;
|
||
srb->SrbStatus = 0;
|
||
srb->NextSrb = NULL;
|
||
srb->OriginalRequest = irp;
|
||
srb->SrbFlags = fdoExtension->SrbFlags;
|
||
srb->CdbLength = 10;
|
||
SET_FLAG(srb->SrbFlags, SRB_FLAGS_DATA_IN);
|
||
SET_FLAG(srb->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
|
||
|
||
//
|
||
// setup the cdb
|
||
//
|
||
|
||
cdb->GET_CONFIGURATION.OperationCode = SCSIOP_GET_CONFIGURATION;
|
||
cdb->GET_CONFIGURATION.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_CURRENT;
|
||
cdb->GET_CONFIGURATION.StartingFeature[0] = 0;
|
||
cdb->GET_CONFIGURATION.StartingFeature[1] = 0;
|
||
cdb->GET_CONFIGURATION.AllocationLength[0] = (UCHAR)(bufferSize >> 8);
|
||
cdb->GET_CONFIGURATION.AllocationLength[1] = (UCHAR)(bufferSize & 0xff);
|
||
|
||
//
|
||
// setup the irp
|
||
//
|
||
|
||
nextStack = IoGetNextIrpStackLocation(irp);
|
||
nextStack->MajorFunction = IRP_MJ_SCSI;
|
||
nextStack->Parameters.Scsi.Srb = srb;
|
||
irp->MdlAddress = mmcData->CapabilitiesMdl;
|
||
irp->AssociatedIrp.SystemBuffer = mmcData->CapabilitiesBuffer;
|
||
IoSetCompletionRoutine(irp, CdRomUpdateMmcDriveCapabilitiesCompletion, Fdo,
|
||
TRUE, TRUE, TRUE);
|
||
|
||
return;
|
||
|
||
}
|
||
|
||
VOID
|
||
CdRomUpdateMmcDriveCapabilities(
|
||
IN PDEVICE_OBJECT Fdo,
|
||
IN PVOID Context
|
||
)
|
||
{
|
||
PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
|
||
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
|
||
PCDROM_DATA cdData = fdoExtension->CommonExtension.DriverData;
|
||
PCDROM_MMC_EXTENSION mmcData = &(cdData->Mmc);
|
||
PIO_STACK_LOCATION thisStack = IoGetCurrentIrpStackLocation(mmcData->CapabilitiesIrp);
|
||
PSCSI_REQUEST_BLOCK srb = &(mmcData->CapabilitiesSrb);
|
||
NTSTATUS status;
|
||
|
||
|
||
ASSERT(Context == NULL);
|
||
|
||
//
|
||
// NOTE: a remove lock is unneccessary, since the delayed irp
|
||
// will have said lock held for itself, preventing a remove.
|
||
//
|
||
CdRomPrepareUpdateCapabilitiesIrp(Fdo);
|
||
|
||
ASSERT(thisStack->Parameters.Others.Argument1 == Fdo);
|
||
ASSERT(thisStack->Parameters.Others.Argument2 == mmcData->CapabilitiesBuffer);
|
||
ASSERT(thisStack->Parameters.Others.Argument3 == &(mmcData->CapabilitiesSrb));
|
||
|
||
mmcData->WriteAllowed = FALSE; // default to read-only
|
||
|
||
//
|
||
// set max retries, and also allow volume verify override based on
|
||
// original (delayed) irp
|
||
//
|
||
|
||
thisStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;
|
||
|
||
//
|
||
// send to self... note that SL_OVERRIDE_VERIFY_VOLUME is not required,
|
||
// as this is IRP_MJ_INTERNAL_DEVICE_CONTROL
|
||
//
|
||
|
||
IoCallDriver(commonExtension->LowerDeviceObject, mmcData->CapabilitiesIrp);
|
||
|
||
KeWaitForSingleObject(&mmcData->CapabilitiesEvent,
|
||
Executive, KernelMode, FALSE, NULL);
|
||
|
||
status = mmcData->CapabilitiesIrp->IoStatus.Status;
|
||
|
||
if (!NT_SUCCESS(status)) {
|
||
|
||
goto FinishDriveUpdate;
|
||
|
||
}
|
||
|
||
//
|
||
// we've updated the feature set, so update whether or not reads and writes
|
||
// are allowed or not.
|
||
//
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomUpdateMmc => Succeeded "
|
||
"--------------------"
|
||
"--------------------\n"));
|
||
|
||
/*++
|
||
|
||
NOTE: It is important to only use srb->DataTransferLength worth
|
||
of data at this point, since the bufferSize is what is
|
||
*available* to use, not what was *actually* used.
|
||
|
||
--*/
|
||
|
||
#if DBG
|
||
CdRompPrintAllFeaturePages(mmcData->CapabilitiesBuffer,
|
||
srb->DataTransferLength);
|
||
#endif // DBG
|
||
|
||
//
|
||
// update whether or not writes are allowed. this is currently defined
|
||
// as requiring TargetDefectManagement and RandomWritable features
|
||
//
|
||
{
|
||
PFEATURE_HEADER defectHeader;
|
||
PFEATURE_HEADER writableHeader;
|
||
|
||
defectHeader = CdRomFindFeaturePage(mmcData->CapabilitiesBuffer,
|
||
srb->DataTransferLength,
|
||
FeatureDefectManagement);
|
||
writableHeader = CdRomFindFeaturePage(mmcData->CapabilitiesBuffer,
|
||
srb->DataTransferLength,
|
||
FeatureRandomWritable);
|
||
|
||
if ((defectHeader != NULL) && (writableHeader != NULL) &&
|
||
(defectHeader->Current) && (writableHeader->Current)) {
|
||
|
||
//
|
||
// this should be the *ONLY* place writes are set to allowed
|
||
//
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomUpdateMmc => Writes *allowed*\n"));
|
||
mmcData->WriteAllowed = TRUE;
|
||
|
||
} else {
|
||
|
||
if (defectHeader == NULL) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomUpdateMmc => No writes - %s = %s\n",
|
||
"defect management", "DNE"));
|
||
} else {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomUpdateMmc => No writes - %s = %s\n",
|
||
"defect management", "Not Current"));
|
||
}
|
||
if (writableHeader == NULL) {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomUpdateMmc => No writes - %s = %s\n",
|
||
"sector writable", "DNE"));
|
||
} else {
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomUpdateMmc => No writes - %s = %s\n",
|
||
"sector writable", "Not Current"));
|
||
}
|
||
} // end of feature checking
|
||
} // end of check for writability
|
||
|
||
//
|
||
// update the cached partition table information
|
||
//
|
||
// NOTE: THIS WILL CURRENTLY CAUSE A DEADLOCK!
|
||
//
|
||
// ISSUE-2000/06/20-henrygab - partition support not implemented
|
||
// IoReadPartitionTable must be done
|
||
// at PASSIVE level, requiring a thread
|
||
// or worker item or other such method.
|
||
//
|
||
#if 0
|
||
status = IoReadPartitionTable(Fdo, 1 << fdoExtension->SectorShift,
|
||
TRUE, &mmcData->PartitionList);
|
||
if (!NT_SUCCESS(status)) {
|
||
|
||
goto FinishDriveUpdate;
|
||
|
||
}
|
||
#endif
|
||
|
||
status = STATUS_SUCCESS;
|
||
|
||
FinishDriveUpdate:
|
||
|
||
CdRompFlushDelayedList(Fdo, mmcData, status, TRUE);
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
VOID
|
||
CdRompFlushDelayedList(
|
||
IN PDEVICE_OBJECT Fdo,
|
||
IN PCDROM_MMC_EXTENSION MmcData,
|
||
IN NTSTATUS Status,
|
||
IN BOOLEAN CalledFromWorkItem
|
||
)
|
||
{
|
||
LIST_ENTRY irpList;
|
||
PLIST_ENTRY listEntry;
|
||
KIRQL oldIrql;
|
||
|
||
// NOTE - REF #0002
|
||
//
|
||
// need to set the new state first to prevent deadlocks.
|
||
// this is only done from the workitem, to prevent any
|
||
// edge cases where we'd "lose" the UpdateRequired
|
||
//
|
||
// then, must ignore the state, since it's not guaranteed to
|
||
// be the same any longer. the only thing left is to handle
|
||
// all the delayed irps by flushing the queue and sending them
|
||
// back onto the StartIo queue for the device.
|
||
//
|
||
|
||
if (CalledFromWorkItem) {
|
||
|
||
LONG oldState;
|
||
LONG newState;
|
||
|
||
if (NT_SUCCESS(Status)) {
|
||
newState = CdromMmcUpdateComplete;
|
||
} else {
|
||
newState = CdromMmcUpdateRequired;
|
||
}
|
||
|
||
oldState = InterlockedCompareExchange(&MmcData->UpdateState,
|
||
newState,
|
||
CdromMmcUpdateStarted);
|
||
ASSERT(oldState == CdromMmcUpdateStarted);
|
||
|
||
} else {
|
||
|
||
//
|
||
// just flushing the queue if not called from the workitem,
|
||
// and we don't want to ever fail the queue in those cases.
|
||
//
|
||
|
||
ASSERT(NT_SUCCESS(Status));
|
||
|
||
}
|
||
|
||
/*
|
||
* Get all the delayed IRPs into a private list first to avoid an infinite loop
|
||
* where irps are added to the DelayedIrpsList while we are siphoning them off.
|
||
*/
|
||
InitializeListHead(&irpList);
|
||
KeAcquireSpinLock(&MmcData->DelayedIrpsLock, &oldIrql);
|
||
while (!IsListEmpty(&MmcData->DelayedIrpsList)){
|
||
listEntry = RemoveHeadList(&MmcData->DelayedIrpsList);
|
||
InsertTailList(&irpList, listEntry);
|
||
ASSERT(MmcData->NumDelayedIrps > 0);
|
||
MmcData->NumDelayedIrps--;
|
||
}
|
||
ASSERT(MmcData->NumDelayedIrps == 0);
|
||
KeReleaseSpinLock(&MmcData->DelayedIrpsLock, oldIrql);
|
||
|
||
// if this assert fires, it means that we have started
|
||
// a workitem when the previous workitem took the delayed
|
||
// irp. if this happens, then the logic in HACKHACK #0002
|
||
// is either flawed or the rules set within are not being
|
||
// followed. this would require investigation.
|
||
ASSERT(!IsListEmpty(&irpList));
|
||
|
||
//
|
||
// now either succeed or fail all the delayed irps, according
|
||
// to the update status.
|
||
//
|
||
|
||
while (!IsListEmpty(&irpList)){
|
||
PIRP irp;
|
||
|
||
listEntry = RemoveHeadList(&irpList);
|
||
irp = CONTAINING_RECORD(listEntry, IRP, Tail.Overlay.ListEntry);
|
||
|
||
irp->Tail.Overlay.DriverContext[0] = 0;
|
||
irp->Tail.Overlay.DriverContext[1] = 0;
|
||
irp->Tail.Overlay.DriverContext[2] = 0;
|
||
irp->Tail.Overlay.DriverContext[3] = 0;
|
||
|
||
if (NT_SUCCESS(Status)) {
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomUpdateMmc => Re-sending delayed irp %p\n",
|
||
irp));
|
||
IoStartPacket(Fdo, irp, NULL, NULL);
|
||
|
||
} else {
|
||
|
||
KdPrintEx((DPFLTR_CDROM_ID, CdromDebugFeatures,
|
||
"CdRomUpdateMmc => Failing delayed irp %p with "
|
||
" status %x\n", irp, Status));
|
||
irp->IoStatus.Information = 0;
|
||
irp->IoStatus.Status = Status;
|
||
ClassReleaseRemoveLock(Fdo, irp);
|
||
IoCompleteRequest(irp, IO_CD_ROM_INCREMENT);
|
||
|
||
}
|
||
|
||
} // while (list)
|
||
|
||
return;
|
||
|
||
}
|
||
|
||
VOID
|
||
CdRomDeAllocateMmcResources(
|
||
IN PDEVICE_OBJECT Fdo
|
||
)
|
||
{
|
||
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
|
||
PCDROM_DATA cddata = commonExtension->DriverData;
|
||
PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc;
|
||
NTSTATUS status;
|
||
|
||
if (mmcData->CapabilitiesWorkItem) {
|
||
IoFreeWorkItem(mmcData->CapabilitiesWorkItem);
|
||
mmcData->CapabilitiesWorkItem = NULL;
|
||
}
|
||
if (mmcData->CapabilitiesIrp) {
|
||
IoFreeIrp(mmcData->CapabilitiesIrp);
|
||
mmcData->CapabilitiesIrp = NULL;
|
||
}
|
||
if (mmcData->CapabilitiesMdl) {
|
||
IoFreeMdl(mmcData->CapabilitiesMdl);
|
||
mmcData->CapabilitiesMdl = NULL;
|
||
}
|
||
if (mmcData->CapabilitiesBuffer) {
|
||
ExFreePool(mmcData->CapabilitiesBuffer);
|
||
mmcData->CapabilitiesBuffer = NULL;
|
||
}
|
||
mmcData->CapabilitiesBuffer = 0;
|
||
mmcData->IsMmc = FALSE;
|
||
mmcData->WriteAllowed = FALSE;
|
||
|
||
return;
|
||
}
|
||
|
||
NTSTATUS
|
||
CdRomAllocateMmcResources(
|
||
IN PDEVICE_OBJECT Fdo
|
||
)
|
||
{
|
||
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
|
||
PCDROM_DATA cddata = commonExtension->DriverData;
|
||
PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc;
|
||
PIO_STACK_LOCATION irpStack;
|
||
NTSTATUS status;
|
||
|
||
ASSERT(mmcData->CapabilitiesWorkItem == NULL);
|
||
ASSERT(mmcData->CapabilitiesIrp == NULL);
|
||
ASSERT(mmcData->CapabilitiesMdl == NULL);
|
||
ASSERT(mmcData->CapabilitiesBuffer == NULL);
|
||
ASSERT(mmcData->CapabilitiesBufferSize == 0);
|
||
|
||
status = CdRomGetConfiguration(Fdo,
|
||
&mmcData->CapabilitiesBuffer,
|
||
&mmcData->CapabilitiesBufferSize,
|
||
FeatureProfileList,
|
||
SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL);
|
||
if (!NT_SUCCESS(status)) {
|
||
ASSERT(mmcData->CapabilitiesBuffer == NULL);
|
||
ASSERT(mmcData->CapabilitiesBufferSize == 0);
|
||
return status;
|
||
}
|
||
ASSERT(mmcData->CapabilitiesBuffer != NULL);
|
||
ASSERT(mmcData->CapabilitiesBufferSize != 0);
|
||
|
||
mmcData->CapabilitiesMdl = IoAllocateMdl(mmcData->CapabilitiesBuffer,
|
||
mmcData->CapabilitiesBufferSize,
|
||
FALSE, FALSE, NULL);
|
||
if (mmcData->CapabilitiesMdl == NULL) {
|
||
ExFreePool(mmcData->CapabilitiesBuffer);
|
||
mmcData->CapabilitiesBufferSize = 0;
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
|
||
mmcData->CapabilitiesIrp = IoAllocateIrp(Fdo->StackSize + 2, FALSE);
|
||
if (mmcData->CapabilitiesIrp == NULL) {
|
||
IoFreeMdl(mmcData->CapabilitiesMdl);
|
||
ExFreePool(mmcData->CapabilitiesBuffer);
|
||
mmcData->CapabilitiesBufferSize = 0;
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
mmcData->CapabilitiesWorkItem = IoAllocateWorkItem(Fdo);
|
||
if (mmcData->CapabilitiesWorkItem == NULL) {
|
||
IoFreeIrp(mmcData->CapabilitiesIrp);
|
||
IoFreeMdl(mmcData->CapabilitiesMdl);
|
||
ExFreePool(mmcData->CapabilitiesBuffer);
|
||
mmcData->CapabilitiesBufferSize = 0;
|
||
return STATUS_INSUFFICIENT_RESOURCES;
|
||
}
|
||
|
||
//
|
||
// everything has been allocated, so now prepare it all....
|
||
//
|
||
|
||
MmBuildMdlForNonPagedPool(mmcData->CapabilitiesMdl);
|
||
InitializeListHead(&mmcData->DelayedIrpsList);
|
||
KeInitializeSpinLock(&mmcData->DelayedIrpsLock);
|
||
mmcData->NumDelayedIrps = 0;
|
||
|
||
//
|
||
// use the extra stack for internal bookkeeping
|
||
//
|
||
IoSetNextIrpStackLocation(mmcData->CapabilitiesIrp);
|
||
irpStack = IoGetCurrentIrpStackLocation(mmcData->CapabilitiesIrp);
|
||
irpStack->Parameters.Others.Argument1 = Fdo;
|
||
irpStack->Parameters.Others.Argument2 = mmcData->CapabilitiesBuffer;
|
||
irpStack->Parameters.Others.Argument3 = &(mmcData->CapabilitiesSrb);
|
||
// arg 4 is the retry count
|
||
|
||
//
|
||
// set the completion event to FALSE for now
|
||
//
|
||
|
||
KeInitializeEvent(&mmcData->CapabilitiesEvent,
|
||
SynchronizationEvent, FALSE);
|
||
return STATUS_SUCCESS;
|
||
|
||
}
|