zpodd.c File Reference

#include "ntddk.h"
#include "ntddstor.h"
#include "wdmguid.h"
#include "cdrom.h"
#include "mmc.h"
#include "ioctl.h"
#include "scratch.h"

Include dependency graph for zpodd.c:

Go to the source code of this file.

Functions
	_IRQL_requires_max_ (PASSIVE_LEVEL)
	_IRQL_requires_max_ (APC_LEVEL)
NTSTATUS	DeviceZPODDGetPowerupReason (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _Out_ PSTORAGE_IDLE_POWERUP_REASON PowerupReason)

Function Documentation

_IRQL_requires_max_() [1/2]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 574 of file zpodd.c.

{
    PZERO_POWER_ODD_INFO zpoddInfo = DeviceExtension->ZeroPowerODDInfo;
 
    PAGED_CODE()
 
    if (zpoddInfo != NULL)
    {
        FREE_POOL(zpoddInfo->GetConfigurationBuffer);
        FREE_POOL(zpoddInfo);
    }
 
    return;
}

_IRQL_requires_max_() [2/2]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 36 of file zpodd.c.

                       :4152) // nonstandard extension, function/data pointer conversion in expression
#pragma warning(disable:26000) // read overflow reported because of pointer type conversion
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceInitializeZPODD(
    _In_ PCDROM_DEVICE_EXTENSION  DeviceExtension
    )
/*++
 
Routine Description:
 
    This routine initialize the contents of ZPODD structure.
 
Arguments:
 
    DeviceExtension - the device extension
 
Return Value:
    NTSTATUS
 
--*/
{
    NTSTATUS                            status = STATUS_SUCCESS;
    NTSTATUS                            tempStatus = STATUS_SUCCESS;
    PZERO_POWER_ODD_INFO                zpoddInfo = NULL;
    PFEATURE_DATA_REMOVABLE_MEDIUM      removableMediumHeader = NULL;
    ULONG                               ZPODDEnabledInRegistry = 0;
    PD3COLD_SUPPORT_INTERFACE           d3ColdInterface = NULL;
    DEVICE_WAKE_DEPTH                   deepestWakeableDstate = DeviceWakeDepthNotWakeable;
    BOOLEAN                             inHomePosition = FALSE;
 
    PAGED_CODE();
 
    if (DeviceExtension->ZeroPowerODDInfo != NULL)
    {
        //
        // Already initialized.
        //
 
        goto Cleanup;
    }
 
    ZPODDEnabledInRegistry = DeviceGetZPODDEnabledFromRegistry();
 
    if (ZPODDEnabledInRegistry == 0)
    {
        //
        // User has explicitly disabled Zero Power ODD.
        //
 
        status = STATUS_NOT_SUPPORTED;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                    "DeviceInitializeZPODD: ZPODD not enabled due to registry settings.\n"
                    ));
 
        goto Cleanup;
    }
 
    zpoddInfo = ExAllocatePoolWithTag(NonPagedPoolNx,
                                      sizeof(ZERO_POWER_ODD_INFO),
                                      CDROM_TAG_ZERO_POWER_ODD);
 
    if (zpoddInfo == NULL)
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        goto Cleanup;
    }
 
    RtlZeroMemory(zpoddInfo, sizeof (ZERO_POWER_ODD_INFO));
 
    //
    // Check the system for the following prerequisites:
    //
    // 1. SATA: Device Attention line
    // 2. SATA: Asynchronous Notification
    // 3. ODD:  LoChange / MediaRemoval
    // 4. ACPI: Wake capable
    //
    // Only drawer and slot loading types have well defined behaviors in the spec, so only these two
    // types are supported.
    //
 
    //
    // Check for DA & AN
    //
 
    if ((DeviceExtension->PowerDescriptor == NULL) ||
        (DeviceExtension->PowerDescriptor->DeviceAttentionSupported == FALSE) ||
        (DeviceExtension->PowerDescriptor->AsynchronousNotificationSupported == FALSE))
    {
        status = STATUS_NOT_SUPPORTED;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                    "DeviceInitializeZPODD: ZPODD not enabled due to SATA features not present.\n"
                    ));
 
        goto Cleanup;
    }
 
    //
    // Check for LoChange / MediaRemoval
    //
 
    removableMediumHeader = (PFEATURE_DATA_REMOVABLE_MEDIUM)
                            DeviceFindFeaturePage(DeviceExtension->DeviceAdditionalData.Mmc.CapabilitiesBuffer,
                                                  DeviceExtension->DeviceAdditionalData.Mmc.CapabilitiesBufferSize,
                                                  FeatureRemovableMedium);
 
    if ((removableMediumHeader == NULL) ||
        (!((removableMediumHeader->LoadingMechanism == LOADING_MECHANISM_TRAY) && (removableMediumHeader->Load == 0) &&     // Drawer ...
         (removableMediumHeader->DBML != FALSE)) &&                                                                         // requires LoChange/NotBusy
        !((removableMediumHeader->LoadingMechanism == LOADING_MECHANISM_CADDY) && (removableMediumHeader->Load == 0) &&     // Slot ...
         (DeviceExtension->MediaChangeDetectionInfo->Gesn.Supported != FALSE))))                                            // requires MediaRemoval
    {
        status = STATUS_NOT_SUPPORTED;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                    "DeviceInitializeZPODD: ZPODD not enabled due to ODD features not present.\n"
                    ));
 
        goto Cleanup;
    }
 
    zpoddInfo->LoadingMechanism = removableMediumHeader->LoadingMechanism;
    zpoddInfo->Load = removableMediumHeader->Load;
 
    //
    // Check for ACPI
    //
 
    status = DeviceQueryD3ColdInterface(DeviceExtension, &zpoddInfo->D3ColdInterface);
 
    if (!NT_SUCCESS(status))
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                    "DeviceInitializeZPODD: Query D3Cold support interface failed.\n"
                    ));
 
        goto Cleanup;
    }
 
    //
    // If the platform supports Zero Power ODD, the following conditions must be met:
    //
    // 1. The deepest wakeable D-state for the device is D3Cold;
    // 2. The platform supports D3Cold for the device.
    //
 
    d3ColdInterface = &zpoddInfo->D3ColdInterface;
 
    status = d3ColdInterface->GetIdleWakeInfo(d3ColdInterface->Context,
                                              PowerSystemWorking,
                                              &deepestWakeableDstate);
 
    if (!NT_SUCCESS(status))
    {
        goto Cleanup;
    }
 
    //
    // DeviceExtension->PowerDescriptor->D3ColdSupported is retrieved from lower layer.
    // It has more accurate supportive information than just uses d3ColdInterface->GetD3ColdCapability
    //
    if ((deepestWakeableDstate != DeviceWakeDepthD3cold) ||
        (DeviceExtension->PowerDescriptor->D3ColdSupported == FALSE))
    {
        status = STATUS_NOT_SUPPORTED;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                    "DeviceInitializeZPODD: ZPODD not enabled due to ACPI support not present.\n"
                    ));
 
        goto Cleanup;
    }
 
    //
    // The system meets all requirements. Go ahead and enable ZPODD.
    //
 
    //
    // Register with the runtime power framework.
    // Note that no un-registration is needed during tear-down.
    // D3Cold will be enabled (success case of following call) or disabled by port driver during processing Enable Idle Power IOCTL.
    //
 
    status = DeviceSendEnableIdlePowerIoctl(DeviceExtension, TRUE, TRUE, DELAY_TIME_TO_ENTER_ZERO_POWER_IN_MS);
 
    if (!NT_SUCCESS(status))
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                    "DeviceInitializeZPODD: ZPODD not enabled due to runtime power framework.\n"
                    ));
 
        goto Cleanup;
    }
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                "DeviceInitializeZPODD: ZPODD is enabled.\n"
                ));
 
    DeviceExtension->ZeroPowerODDInfo = zpoddInfo;
 
    //
    // If device is not in home position, then we should take an active reference here
    // to prevent it from being powered off.
    //
 
    inHomePosition = DeviceZPODDIsInHomePosition(DeviceExtension);
 
    if (inHomePosition == FALSE)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                   "DeviceInitializeZPODD: not ready to power off, device marked as active\n"));
 
        DeviceMarkActive(DeviceExtension, TRUE, FALSE);
    }
    else
    {
        //
        // cache get configuration response.
        // failing is not critical, so we don't want to check for status here.
        //
 
        if (zpoddInfo->GetConfigurationBuffer == NULL)
        {
            tempStatus = DeviceGetConfigurationWithAlloc(DeviceExtension->Device,
                                                         &zpoddInfo->GetConfigurationBuffer,
                                                         &zpoddInfo->GetConfigurationBufferSize,
                                                         FeatureProfileList,
                                                         SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL);
 
            UNREFERENCED_PARAMETER(tempStatus); // Avoid PREFAST warning.
        }
    }
 
Cleanup:
 
    if (!NT_SUCCESS(status))
    {
        //
        // We register always even in non-ZPODD case, per request from storport.
        //
 
        tempStatus = DeviceSendEnableIdlePowerIoctl(DeviceExtension, FALSE, FALSE, DELAY_TIME_TO_ENTER_ZERO_POWER_IN_MS);
 
        if (NT_SUCCESS(tempStatus))
        {
            //
            // Mark the device active; this reference will never be released unless the system enters a
            // low power state.
            //
 
            DeviceMarkActive(DeviceExtension, TRUE, FALSE);
        }
 
        FREE_POOL(zpoddInfo);
    }
 
    //
    // If Zero Power ODD is not supported, we should not block the device init sequence.
    //
 
    return STATUS_SUCCESS;
}

DeviceZPODDGetPowerupReason()

NTSTATUS DeviceZPODDGetPowerupReason	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_Out_ PSTORAGE_IDLE_POWERUP_REASON	PowerupReason
	)

Definition at line 608 of file zpodd.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PIRP                    irp = NULL;
    IO_STATUS_BLOCK         ioStatus = {0};
    KEVENT                  event;
 
    RtlZeroMemory(PowerupReason, sizeof (STORAGE_IDLE_POWERUP_REASON));
 
    PowerupReason->Size = sizeof (STORAGE_IDLE_POWERUP_REASON);
    PowerupReason->Version = STORAGE_IDLE_POWERUP_REASON_VERSION_V1;
 
    //
    // Setup a synchronous irp.
    //
 
    KeInitializeEvent(&event, NotificationEvent, FALSE);
 
    irp = IoBuildDeviceIoControlRequest(IOCTL_STORAGE_GET_IDLE_POWERUP_REASON,
                                        DeviceExtension->LowerPdo,
                                        PowerupReason,
                                        sizeof (STORAGE_IDLE_POWERUP_REASON),
                                        PowerupReason,
                                        sizeof (STORAGE_IDLE_POWERUP_REASON),
                                        FALSE,
                                        &event,
                                        &ioStatus);
 
    if (irp == NULL)
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        //
        // Send the synchronous request to port driver.
        //
 
        status = IoCallDriver(DeviceExtension->LowerPdo, irp);
 
        if (status == STATUS_PENDING)
        {
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
 
            status = ioStatus.Status;
        }
    }
 
    return status;
}

Referenced by DeviceEvtD0Entry().