portstate.c File Reference

#include "atapi.h"

Include dependency graph for portstate.c:

Go to the source code of this file.

Functions
static VOID	AtaPortQueueEvent (_In_ PATAPORT_PORT_DATA PortData, _In_opt_ PATAPORT_DEVICE_EXTENSION DevExt, _In_opt_ PATA_DEVICE_REQUEST FailedRequest, _In_ ATA_PORT_ACTION Action)
static ATA_PORT_ACTION	AtaPortClearPortAction (_In_ PATA_WORKER_CONTEXT Context, _In_ ATA_PORT_ACTION Action)
static BOOLEAN	AtaPortClearDeviceAction (_In_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ ATA_PORT_ACTION Action)
static PATAPORT_DEVICE_EXTENSION	AtaPortFindDeviceForAction (_In_ PATAPORT_PORT_DATA PortData, _In_ ATA_PORT_ACTION Action)
static VOID	AtaPortOnAsyncNotification (_In_ PATAPORT_PORT_DATA PortData, _In_ ULONG DeviceBitmap)
static VOID	AtaPortOnResetNotification (_In_ PATAPORT_PORT_DATA PortData, _In_ ULONG DeviceBitmap)
static VOID	AtaPortOnRequestComplete (_In_ PATAPORT_PORT_DATA PortData, _In_ ULONG CommandsCompleted)
static VOID	AtaPortMarkDeviceFailed (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt)
static NTSTATUS	AtaPortEnumeratePort (_In_ PATAPORT_PORT_DATA PortData)
static NTSTATUS	AtaPortResetPort (_In_ PATAPORT_PORT_DATA PortData)
static NTSTATUS	AtaPortEnumerateDevice (_In_ PATAPORT_PORT_DATA PortData, _In_ ATA_PORT_ACTION Action)
static NTSTATUS	AtaPortRecoveryFromError (_In_ PATAPORT_PORT_DATA PortData)
static NTSTATUS	AtaPortConfigureDevice (_In_ PATAPORT_PORT_DATA PortData)
static NTSTATUS	AtaPortDeviceChangePower (_In_ PATAPORT_PORT_DATA PortData)
static NTSTATUS	AtaPortSetTransferMode (_In_ PATAPORT_PORT_DATA PortData)
static BOOLEAN	AtaPortGetNextEvent (_In_ PATAPORT_PORT_DATA PortData, _Out_ ATA_PORT_ACTION *Action)
static VOID	AtaPortRunStateMachine (_In_ PATAPORT_PORT_DATA PortData)
static VOID	AtaPortWaitForIdle (_In_ PATAPORT_PORT_DATA PortData)
static VOID	AtaPortEnterStateMachine (_In_ PATAPORT_PORT_DATA PortData)
static VOID	AtaPortExitStateMachine (_In_ PATAPORT_PORT_DATA PortData)
static VOID	AtaPortWorkerClearSignal (_In_ PATAPORT_PORT_DATA PortData)
VOID NTAPI	AtaPortWorkerThread (_In_ PVOID StartContext)
VOID __cdecl	AtaPortNotification (_In_ PORT_NOTIFICATION_TYPE NotificationType, _In_ PVOID PortContext,...)
ATA_COMPLETION_ACTION	AtaPortCompleteInternalRequest (_In_ PATA_DEVICE_REQUEST Request)
NTSTATUS	AtaPortSendRequest (_In_ PATAPORT_PORT_DATA PortData, _In_ PATAPORT_DEVICE_EXTENSION DevExt)
VOID	AtaPortTimeout (_In_ PATAPORT_PORT_DATA PortData, _In_ ULONG Slot)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaPortSignalWorkerThread (_In_ PATAPORT_PORT_DATA PortData)
VOID NTAPI	AtaPortWorkerSignalDpc (_In_ PKDPC Dpc, _In_opt_ PVOID DeferredContext, _In_opt_ PVOID SystemArgument1, _In_opt_ PVOID SystemArgument2)
DECLSPEC_NOINLINE_FROM_PAGED VOID	AtaDeviceQueueEvent (_In_ PATAPORT_PORT_DATA PortData, _In_opt_ PATAPORT_DEVICE_EXTENSION DevExt, _In_ ATA_PORT_ACTION Action)

Function Documentation

AtaDeviceQueueEvent()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaDeviceQueueEvent	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_opt_ PATAPORT_DEVICE_EXTENSION	DevExt,
		_In_ ATA_PORT_ACTION	Action
	)

Definition at line 992 of file portstate.c.

{
    KIRQL OldIrql;
 
    TRACE("New action %lu\n", Action);
 
    OldIrql = KeAcquireInterruptSpinLock(PortData->InterruptObject);
    AtaPortQueueEvent(PortData, DevExt, NULL, Action);
    KeReleaseInterruptSpinLock(PortData->InterruptObject, OldIrql);
}

Referenced by AtaFdoEnumeratePort(), AtaFdoQueryDeviceCount(), AtaFdoQueryDeviceStatus(), AtaPdoQueuePowerIrp(), and AtaPdoStartDevice().

AtaPortClearDeviceAction()

static BOOLEAN AtaPortClearDeviceAction ( _In_ PATAPORT_DEVICE_EXTENSION  DevExt, _In_ ATA_PORT_ACTION  Action  )

static

Definition at line 98 of file portstate.c.

{
    TRACE("Clear dev action %lx, total %lx\n", Action, DevExt->Worker.EventsPending & ~Action);
 
    return !!(_InterlockedAnd(&DevExt->Worker.EventsPending, ~(ULONG)Action) & Action);
}

Referenced by AtaPortConfigureDevice(), AtaPortDeviceChangePower(), AtaPortEnumerateDevice(), and AtaPortRecoveryFromError().

AtaPortClearPortAction()

static ATA_PORT_ACTION AtaPortClearPortAction ( _In_ PATA_WORKER_CONTEXT  Context, _In_ ATA_PORT_ACTION  Action  )

static

Definition at line 87 of file portstate.c.

{
    TRACE("Clear port action %lx, total %lx\n", Action, Context->EventsPending & ~Action);
 
    return _InterlockedAnd(&Context->EventsPending, ~(ULONG)Action);
}

Referenced by AtaPortEnumerateDevice(), AtaPortEnumeratePort(), AtaPortFindDeviceForAction(), AtaPortResetPort(), and AtaPortSetTransferMode().

AtaPortCompleteInternalRequest()

ATA_COMPLETION_ACTION AtaPortCompleteInternalRequest

(

_In_ PATA_DEVICE_REQUEST

Request

)

Definition at line 818 of file portstate.c.

{
    PATAPORT_IO_CONTEXT Device = (PATAPORT_IO_CONTEXT)Request->Device;
    PATAPORT_PORT_DATA PortData = Device->PortData;
 
    ASSERT(Request->Flags & REQUEST_FLAG_INTERNAL);
    KeSetEvent(&PortData->Worker.CompletionEvent, IO_NO_INCREMENT, FALSE);
 
    return COMPLETE_IRP;
}

AtaPortConfigureDevice()

static NTSTATUS AtaPortConfigureDevice ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 399 of file portstate.c.

{
    PATAPORT_DEVICE_EXTENSION DevExt;
    NTSTATUS Status;
 
    DevExt = AtaPortFindDeviceForAction(PortData, ACTION_DEVICE_CONFIG);
    if (!DevExt)
        return STATUS_SUCCESS;
 
    Status = AtaPortDeviceProcessConfig(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
    {
        AtaPortMarkDeviceFailed(PortData, DevExt);
        return Status;
    }
 
    if (AtaPortClearDeviceAction(DevExt, ACTION_DEVICE_CONFIG))
        KeSetEvent(&DevExt->Worker.ConfigureEvent, 0, FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by AtaPortRunStateMachine().

AtaPortDeviceChangePower()

static NTSTATUS AtaPortDeviceChangePower ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 424 of file portstate.c.

{
    PATAPORT_DEVICE_EXTENSION DevExt;
    NTSTATUS Status;
 
    DevExt = AtaPortFindDeviceForAction(PortData, ACTION_DEVICE_POWER);
    if (!DevExt)
        return STATUS_SUCCESS;
 
    Status = AtaPortDeviceProcessPowerChange(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
    {
        AtaPortMarkDeviceFailed(PortData, DevExt);
        return Status;
    }
 
    AtaPortClearDeviceAction(DevExt, ACTION_DEVICE_POWER);
    return STATUS_SUCCESS;
}

Referenced by AtaPortRunStateMachine().

AtaPortEnterStateMachine()

static VOID AtaPortEnterStateMachine ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 591 of file portstate.c.

{
    PATAPORT_CHANNEL_EXTENSION ChanExt;
    ATA_SCSI_ADDRESS AtaScsiAddress;
 
    ChanExt = CONTAINING_RECORD(PortData, ATAPORT_CHANNEL_EXTENSION, PortData);
    ASSERT(IS_FDO(ChanExt));
 
    AtaScsiAddress.AsULONG = 0;
    while (TRUE)
    {
        PATAPORT_DEVICE_EXTENSION DevExt;
        PULONG PowerIdleCounter;
 
        /*
         * Acquire a reference to make sure the device object is valid
         * for the duration of the port event handling.
         */
        DevExt = AtaFdoFindNextDeviceByPath(ChanExt,
                                            &AtaScsiAddress,
                                            FALSE,
                                            AtaPortWorkerThread);
        if (!DevExt)
            break;
 
        DevExt->Worker.Flags = DEV_WORKER_FLAG_HOLD_REFERENCE;
        DevExt->Worker.ResetRetryCount = 0;
 
        if (DevExt->Device.QueueFlags & QUEUE_FLAG_FROZEN_REMOVED)
        {
            DevExt->Worker.Flags |= DEV_WORKER_FLAG_REMOVED;
            continue;
        }
 
        /* Stop the Srb processing */
        AtaReqFreezeQueue(DevExt, QUEUE_FLAG_FROZEN_PORT_BUSY);
 
        /*
         * There is a chance that we can receive a power down request
         * while the state maching is being running, so mark the device as busy
         * to reduce the request probability.
         */
        PowerIdleCounter = DevExt->Device.PowerIdleCounter;
        if (PowerIdleCounter)
            PoSetDeviceBusy(PowerIdleCounter);
    }
 
    /* Wait for the port queue to become empty */
    AtaPortWaitForIdle(PortData);
 
    PortData->Worker.Flags = 0;
    PortData->Worker.BadDeviceBitmap = 0;
    PortData->Worker.ResetRetryCount = 0;
#if DBG
    PortData->Worker.StateLoopCount = 0;
#endif
 
    // FIXME: Handle PORT_FLAG_IS_SIMPLEX
}

Referenced by AtaPortWorkerThread().

AtaPortEnumerateDevice()

static NTSTATUS AtaPortEnumerateDevice ( _In_ PATAPORT_PORT_DATA  PortData, _In_ ATA_PORT_ACTION  Action  )

static

Definition at line 324 of file portstate.c.

{
    PATAPORT_DEVICE_EXTENSION DevExt;
 
    if (Action == ACTION_ENUM_DEVICE_NEW)
    {
        DevExt = PortData->Worker.EnumDevExt;
        ASSERT(DevExt);
        AtaReqFreezeQueue(DevExt, QUEUE_FLAG_FROZEN_PORT_BUSY);
    }
    else
    {
        DevExt = AtaPortFindDeviceForAction(PortData, Action);
        if (!DevExt)
            return STATUS_SUCCESS;
    }
 
    if (PortData->Worker.BadDeviceBitmap & (1 << (ULONG)DevExt->Device.AtaScsiAddress.TargetId))
    {
        DevExt->Worker.EnumStatus = DEV_STATUS_NO_DEVICE;
    }
    else
    {
        DevExt->Worker.EnumStatus = AtaPortIdentifyDevice(PortData, DevExt);
        if (DevExt->Worker.EnumStatus == DEV_STATUS_FAILED)
        {
            AtaPortMarkDeviceFailed(PortData, DevExt);
            return STATUS_ADAPTER_HARDWARE_ERROR;
        }
    }
 
    if ((DevExt->Worker.EnumStatus != DEV_STATUS_SAME_DEVICE) &&
        !(DevExt->Device.DeviceFlags & DEVICE_UNINITIALIZED))
    {
        DevExt->Worker.Flags |= DEV_WORKER_FLAG_REMOVED;
    }
 
    if (AtaPortClearDeviceAction(DevExt, Action))
    {
        if (Action == ACTION_ENUM_DEVICE_NEW)
            AtaPortClearPortAction(&PortData->Worker, Action);
 
        KeSetEvent(&DevExt->Worker.EnumerationEvent, 0, FALSE);
    }
 
    return STATUS_SUCCESS;
}

Referenced by AtaPortRunStateMachine().

AtaPortEnumeratePort()

static NTSTATUS AtaPortEnumeratePort ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 255 of file portstate.c.

{
    PATAPORT_CHANNEL_EXTENSION ChanExt;
    ATA_SCSI_ADDRESS AtaScsiAddress;
 
    _InterlockedOr(&PortData->InterruptFlags, PORT_INT_FLAG_IGNORE_LINK_IRQ);
    PortData->Worker.DeviceCount = PortData->EnumerateChannel(PortData->ChannelContext);
    _InterlockedAnd(&PortData->InterruptFlags, ~PORT_INT_FLAG_IGNORE_LINK_IRQ);
 
    INFO("CH %lu: Detected %lu devices\n", PortData->PortNumber, PortData->Worker.DeviceCount);
 
    if (AtaPortClearPortAction(&PortData->Worker, ACTION_ENUM_PORT))
    {
        /* Defer the completion */
        PortData->Worker.Flags |= WORKER_FLAG_COMPLETE_PORT_ENUM_EVENT;
    }
 
    ChanExt = CONTAINING_RECORD(PortData, ATAPORT_CHANNEL_EXTENSION, PortData);
 
    /* Remove detached devices */
    AtaScsiAddress.AsULONG = 0;
    while (TRUE)
    {
        PATAPORT_DEVICE_EXTENSION DevExt;
 
        DevExt = AtaFdoFindNextDeviceByPath(ChanExt, &AtaScsiAddress, FALSE, NULL);
        if (!DevExt)
            break;
 
        if (AtaScsiAddress.TargetId >= PortData->Worker.DeviceCount)
            DevExt->Worker.Flags |= DEV_WORKER_FLAG_REMOVED;
    }
 
    return STATUS_SUCCESS;
}

Referenced by AtaPortResetPort(), and AtaPortRunStateMachine().

AtaPortExitStateMachine()

static VOID AtaPortExitStateMachine ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 654 of file portstate.c.

{
    PATAPORT_CHANNEL_EXTENSION ChanExt;
    ATA_SCSI_ADDRESS AtaScsiAddress;
 
    ChanExt = CONTAINING_RECORD(PortData, ATAPORT_CHANNEL_EXTENSION, PortData);
 
    AtaScsiAddress.AsULONG = 0;
    while (TRUE)
    {
        PATAPORT_DEVICE_EXTENSION DevExt;
        KIRQL OldIrql;
 
        DevExt = AtaFdoFindNextDeviceByPath(ChanExt, &AtaScsiAddress, TRUE, NULL);
        if (!DevExt)
            break;
 
        if (DevExt->Worker.Flags & DEV_WORKER_FLAG_REMOVED)
        {
            KeAcquireSpinLock(&ChanExt->PdoListLock, &OldIrql);
            if (!DevExt->RemovalPending)
                PortData->Worker.Flags |= WORKER_FLAG_NEED_RESCAN;
            DevExt->RemovalPending = TRUE;
            KeReleaseSpinLock(&ChanExt->PdoListLock, OldIrql);
 
            AtaReqFreezeQueue(DevExt, QUEUE_FLAG_FROZEN_REMOVED);
            AtaReqFlushDeviceQueue(&DevExt->Device);
 
            AtaDeviceFlushPowerIrpQueue(DevExt);
            KeSetEvent(&DevExt->Worker.ConfigureEvent, 0, FALSE);
 
            DevExt->Worker.EnumStatus = DEV_STATUS_NO_DEVICE;
            KeSetEvent(&DevExt->Worker.EnumerationEvent, 0, FALSE);
        }
        else
        {
            /* Resume the Srb processing */
            AtaReqThawQueue(DevExt, QUEUE_FLAG_FROZEN_PORT_BUSY);
        }
 
        /* Release a reference */
        if (DevExt->Worker.Flags & DEV_WORKER_FLAG_HOLD_REFERENCE)
        {
            DevExt->Worker.Flags &= ~DEV_WORKER_FLAG_HOLD_REFERENCE;
            IoReleaseRemoveLock(&DevExt->Common.RemoveLock, AtaPortWorkerThread);
        }
    }
 
    if (PortData->Worker.Flags & WORKER_FLAG_COMPLETE_PORT_ENUM_EVENT)
    {
        /* We defer this event completion to avoid a BusRelations request */
        PortData->Worker.Flags &= ~WORKER_FLAG_NEED_RESCAN;
 
        KeSetEvent(&PortData->Worker.EnumerationEvent, 0, FALSE);
    }
 
    if (PortData->Worker.Flags & WORKER_FLAG_NEED_RESCAN)
        IoInvalidateDeviceRelations(ChanExt->Pdo, BusRelations);
}

Referenced by AtaPortWorkerThread().

AtaPortFindDeviceForAction()

static PATAPORT_DEVICE_EXTENSION AtaPortFindDeviceForAction ( _In_ PATAPORT_PORT_DATA  PortData, _In_ ATA_PORT_ACTION  Action  )

static

Definition at line 109 of file portstate.c.

{
    PATAPORT_DEVICE_EXTENSION DevExt, Result = NULL;
    PATAPORT_CHANNEL_EXTENSION ChanExt;
    PSINGLE_LIST_ENTRY Entry;
    KIRQL OldIrql, OldLevel;
 
    ChanExt = CONTAINING_RECORD(PortData, ATAPORT_CHANNEL_EXTENSION, PortData);
 
    KeAcquireSpinLock(&ChanExt->PdoListLock, &OldLevel);
    OldIrql = KeAcquireInterruptSpinLock(PortData->InterruptObject);
 
    for (Entry = ChanExt->PdoList.Next; Entry != NULL; Entry = Entry->Next)
    {
        DevExt = CONTAINING_RECORD(Entry, ATAPORT_DEVICE_EXTENSION, ListEntry);
 
        if (DevExt->Device.AtaScsiAddress.PathId != PortData->PortNumber)
            continue;
 
        if (DevExt->ReportedMissing)
            continue;
 
        if (DevExt->Worker.Flags & DEV_WORKER_FLAG_REMOVED)
            continue;
 
        if (DevExt->Worker.EventsPending & Action)
        {
            Result = DevExt;
            break;
        }
    }
 
    if (!Result)
        AtaPortClearPortAction(&PortData->Worker, Action);
 
    KeReleaseInterruptSpinLock(PortData->InterruptObject, OldIrql);
    KeReleaseSpinLock(&ChanExt->PdoListLock, OldLevel);
 
    return Result;
}

Referenced by AtaPortConfigureDevice(), AtaPortDeviceChangePower(), AtaPortEnumerateDevice(), and AtaPortRecoveryFromError().

AtaPortGetNextEvent()

static BOOLEAN AtaPortGetNextEvent ( _In_ PATAPORT_PORT_DATA  PortData, _Out_ ATA_PORT_ACTION *  Action  )

static

Definition at line 458 of file portstate.c.

{
    KIRQL OldIrql;
    ULONG i, EventIndex;
    BOOLEAN Success;
 
    OldIrql = KeAcquireInterruptSpinLock(PortData->InterruptObject);
 
    /* Handle events by priority order */
    Success = _BitScanForward(&EventIndex, PortData->Worker.EventsPending);
    if (!Success)
    {
        PATA_DEVICE_REQUEST Request;
 
        /* Resume port I/O */
        ASSERT(!(PortData->InterruptFlags & PORT_INT_FLAG_IS_IO_ACTIVE));
        _InterlockedOr(&PortData->InterruptFlags, PORT_INT_FLAG_IS_IO_ACTIVE);
 
        /* Complete failed request */
        Request = PortData->Worker.FailedRequest;
        if (Request && !(PortData->Worker.PausedSlotsBitmap & (1 << Request->Slot)))
        {
            AtaReqStartCompletionDpc(Request);
        }
        PortData->Worker.FailedRequest = NULL;
 
        /* Requeue saved commands */
        for (i = 0; i < MAX_SLOTS; ++i)
        {
            if (!(PortData->Worker.PausedSlotsBitmap & (1 << i)))
              continue;
 
            Request = PortData->Slots[i];
            ASSERT_REQUEST(Request);
            ASSERT(Request != &PortData->Worker.InternalRequest);
 
            Request->SrbStatus = SRB_STATUS_BUSY;
            Request->InternalState = REQUEST_STATE_REQUEUE;
            AtaReqStartCompletionDpc(Request);
        }
 
        PortData->Worker.PausedSlotsBitmap = 0;
    }
 
    KeReleaseInterruptSpinLock(PortData->InterruptObject, OldIrql);
 
    *Action = 1 << EventIndex;
    return Success;
}

Referenced by AtaPortRunStateMachine().

AtaPortMarkDeviceFailed()

static VOID AtaPortMarkDeviceFailed ( _In_ PATAPORT_PORT_DATA  PortData, _In_ PATAPORT_DEVICE_EXTENSION  DevExt  )

static

Definition at line 236 of file portstate.c.

{
    /* Ignore bad or incompatible devices, so we do not access them at all */
    if (++DevExt->Worker.ResetRetryCount >= 4)
    {
        ERR("CH %lu: Too many reset attempts for the device %u, giving up\n",
            PortData->PortNumber,
            DevExt->Device.AtaScsiAddress.TargetId);
 
        DevExt->Worker.Flags |= DEV_WORKER_FLAG_REMOVED;
 
        PortData->Worker.BadDeviceBitmap |= 1 << (ULONG)DevExt->Device.AtaScsiAddress.TargetId;
    }
}

Referenced by AtaPortConfigureDevice(), AtaPortDeviceChangePower(), AtaPortEnumerateDevice(), and AtaPortRecoveryFromError().

AtaPortNotification()

VOID __cdecl AtaPortNotification	(	_In_ PORT_NOTIFICATION_TYPE	NotificationType,
		_In_ PVOID	PortContext,
			...
	)

Definition at line 755 of file portstate.c.

{
    PATAPORT_PORT_DATA PortData = PortContext;
    va_list ap;
 
    va_start(ap, PortContext);
 
    TRACE("CH %lu: Notification %lu\n", PortData->PortNumber, NotificationType);
 
    switch (NotificationType)
    {
        case AtaRequestComplete:
        {
            AtaPortOnRequestComplete(PortData, (ULONG)va_arg(ap, ULONG));
            break;
        }
 
        case AtaResetDetected:
        {
            ASSERT(PortData->Worker.Thread == KeGetCurrentThread());
            ASSERT(!(PortData->InterruptFlags & PORT_INT_FLAG_IS_IO_ACTIVE));
            AtaPortOnResetNotification(PortData, (ULONG)va_arg(ap, ULONG));
            break;
        }
 
        case AtaBusChangeDetected:
        {
            ASSERT(KeGetCurrentIrql() > DISPATCH_LEVEL);
 
            if (!(PortData->InterruptFlags & PORT_INT_FLAG_IGNORE_LINK_IRQ))
                AtaPortQueueEvent(PortData, NULL, NULL, ACTION_PORT_RESET);
            else
                TRACE("CH %lu: Ignore link IRQ\n", PortData->PortNumber);
            break;
        }
 
        case AtaRequestFailed:
        {
            AtaPortQueueEvent(PortData,
                              NULL,
                              (PATA_DEVICE_REQUEST)va_arg(ap, PATA_DEVICE_REQUEST),
                              ACTION_DEVICE_ERROR);
            break;
        }
 
        case AtaAsyncNotificationDetected:
        {
            AtaPortOnAsyncNotification(PortData, (ULONG)va_arg(ap, ULONG));
            break;
        }
 
        default:
            ERR("CH %lu: Unsupported notification %lu\n", PortData->PortNumber, NotificationType);
            break;
    }
 
    va_end(ap);
}

AtaPortOnAsyncNotification()

static VOID AtaPortOnAsyncNotification ( _In_ PATAPORT_PORT_DATA  PortData, _In_ ULONG  DeviceBitmap  )

static

Definition at line 154 of file portstate.c.

{
    ASSERT(KeGetCurrentIrql() > DISPATCH_LEVEL);
 
    KeInsertQueueDpc(&PortData->Worker.NotificationDpc, UlongToPtr(DeviceBitmap), NULL);
}

Referenced by AtaPortNotification().

AtaPortOnRequestComplete()

static VOID AtaPortOnRequestComplete ( _In_ PATAPORT_PORT_DATA  PortData, _In_ ULONG  CommandsCompleted  )

static

Definition at line 208 of file portstate.c.

{
    ULONG Slot;
 
    ASSERT(KeGetCurrentIrql() > DISPATCH_LEVEL);
 
    PortData->ActiveSlotsBitmap &= ~CommandsCompleted;
 
    while (_BitScanForward(&Slot, CommandsCompleted) != 0)
    {
        PATA_DEVICE_REQUEST Request;
 
        CommandsCompleted &= ~(1 << Slot);
 
        Request = PortData->Slots[Slot];
        ASSERT_REQUEST(Request);
        ASSERT(Request->Slot == Slot);
 
        InterlockedPushEntrySList(&AtapCompletionQueueList, &Request->CompletionEntry);
    }
 
    KeInsertQueueDpc(&AtapCompletionDpc, NULL, NULL);
}

Referenced by AtaPortNotification().

AtaPortOnResetNotification()

static VOID AtaPortOnResetNotification ( _In_ PATAPORT_PORT_DATA  PortData, _In_ ULONG  DeviceBitmap  )

static

Definition at line 165 of file portstate.c.

{
    PATAPORT_CHANNEL_EXTENSION ChanExt;
    ATA_SCSI_ADDRESS AtaScsiAddress;
    PATAPORT_DEVICE_EXTENSION DevExt;
 
    /*
     * We are about to reset the channel which will in turn
     * cause the affected devices to lose their software settings.
     * Enqueue a config event so the state machine can re-initialize all devices later on.
     */
    _InterlockedOr(&PortData->Worker.EventsPending,
                   ACTION_ENUM_DEVICE |
                   ACTION_DEVICE_CONFIG |
                   ACTION_PORT_TIMING);
 
    ChanExt = CONTAINING_RECORD(PortData, ATAPORT_CHANNEL_EXTENSION, PortData);
 
    AtaScsiAddress.AsULONG = 0;
    while (TRUE)
    {
        ATA_PORT_ACTION Event;
 
        DevExt = AtaFdoFindNextDeviceByPath(ChanExt, &AtaScsiAddress, FALSE, NULL);
        if (!DevExt)
            break;
 
        if (!(DeviceBitmap & (1 << (ULONG)AtaScsiAddress.TargetId)))
            continue;
 
        if (DevExt->Device.DeviceFlags & DEVICE_PNP_STARTED)
            Event = ACTION_ENUM_DEVICE | ACTION_DEVICE_CONFIG;
        else
            Event = ACTION_ENUM_DEVICE; // ACPI _GTF is not ready yet
 
        _InterlockedOr(&DevExt->Worker.EventsPending, Event);
    }
}

Referenced by AtaPortNotification(), and AtaPortResetPort().

AtaPortQueueEvent()

static VOID AtaPortQueueEvent ( _In_ PATAPORT_PORT_DATA  PortData, _In_opt_ PATAPORT_DEVICE_EXTENSION  DevExt, _In_opt_ PATA_DEVICE_REQUEST  FailedRequest, _In_ ATA_PORT_ACTION  Action  )

static

Definition at line 16 of file portstate.c.

{
    ASSERT(KeGetCurrentIrql() > DISPATCH_LEVEL);
 
    if (Action & (ACTION_PORT_RESET | ACTION_DEVICE_ERROR))
    {
        if (Action & ACTION_DEVICE_ERROR)
        {
            if (FailedRequest)
            {
                ASSERT_REQUEST(FailedRequest);
 
                DevExt = CONTAINING_RECORD(FailedRequest->Device, ATAPORT_DEVICE_EXTENSION, Device);
 
                if (FailedRequest->Flags & REQUEST_FLAG_INTERNAL)
                {
                    Action &= ~ACTION_DEVICE_ERROR;
                }
                else
                {
                    ASSERT(PortData->Worker.FailedRequest == NULL);
                    PortData->Worker.FailedRequest = FailedRequest;
                }
            }
            else
            {
                Action &= ~ACTION_DEVICE_ERROR;
                Action |= ACTION_PORT_RESET;
            }
        }
 
        /* Special case for the internal request */
        if ((PortData->ActiveSlotsBitmap & 1) &&
            (PortData->Slots[0]->Flags & REQUEST_FLAG_INTERNAL))
        {
            PATA_DEVICE_REQUEST InternalRequest = &PortData->Worker.InternalRequest;
 
            if (Action & ACTION_PORT_RESET)
                InternalRequest->SrbStatus = SRB_STATUS_BUS_RESET;
 
            PortData->ActiveSlotsBitmap &= ~1;
 
            /* Internal request failed, kick off the port thread */
            AtaReqStartCompletionDpc(InternalRequest);
        }
 
        /* Error recovery, save any commands pending on this port */
        PortData->Worker.PausedSlotsBitmap |= PortData->ActiveSlotsBitmap;
        PortData->ActiveSlotsBitmap = 0;
 
        PortData->AbortChannel(PortData->ChannelContext, !!(Action & ACTION_PORT_RESET));
    }
 
    if (DevExt)
        _InterlockedOr(&DevExt->Worker.EventsPending, Action);
    _InterlockedOr(&PortData->Worker.EventsPending, Action);
 
    /* Kick off the port thread */
    if (PortData->InterruptFlags & PORT_INT_FLAG_IS_IO_ACTIVE)
    {
        _InterlockedAnd(&PortData->InterruptFlags, ~PORT_INT_FLAG_IS_IO_ACTIVE);
        KeInsertQueueDpc(&PortData->Worker.Dpc, NULL, NULL);
    }
}

Referenced by AtaDeviceQueueEvent(), AtaPortNotification(), and AtaPortTimeout().

AtaPortRecoveryFromError()

static NTSTATUS AtaPortRecoveryFromError ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 376 of file portstate.c.

{
    PATAPORT_DEVICE_EXTENSION DevExt;
    NTSTATUS Status;
 
    DevExt = AtaPortFindDeviceForAction(PortData, ACTION_DEVICE_ERROR);
    if (!DevExt)
        return STATUS_SUCCESS;
 
    Status = AtaPortDeviceProcessError(PortData, DevExt);
    if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
    {
        AtaPortMarkDeviceFailed(PortData, DevExt);
        return Status;
    }
 
    AtaPortClearDeviceAction(DevExt, ACTION_DEVICE_ERROR);
    return STATUS_SUCCESS;
}

Referenced by AtaPortRunStateMachine().

AtaPortResetPort()

static NTSTATUS AtaPortResetPort ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 294 of file portstate.c.

{
    _InterlockedOr(&PortData->InterruptFlags, PORT_INT_FLAG_IGNORE_LINK_IRQ);
    PortData->ResetChannel(PortData->ChannelContext);
    _InterlockedAnd(&PortData->InterruptFlags, ~PORT_INT_FLAG_IGNORE_LINK_IRQ);
 
    AtaPortEnumeratePort(PortData);
    AtaPortOnResetNotification(PortData, MAXULONG);
 
    AtaPortClearPortAction(&PortData->Worker, ACTION_PORT_RESET);
 
    /*
     * Reset bus timings, as attached devices
     * may reset their current transfer mode to default during the processing of a software reset
     * and the subsequent IDENTIFY DEVICE command would end up using incorrect timings.
     */
    AtaPortSelectTimings(PortData, TRUE);
 
    if (++PortData->Worker.ResetRetryCount >= 10)
    {
        ERR("CH %lu: Too many port reset attempts, giving up\n", PortData->PortNumber);
        PortData->Worker.BadDeviceBitmap = MAXULONG;
    }
 
    return STATUS_SUCCESS;
}

Referenced by AtaPortRunStateMachine().

AtaPortRunStateMachine()

static VOID AtaPortRunStateMachine ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 512 of file portstate.c.

{
    ATA_PORT_ACTION Action;
    NTSTATUS Status;
 
    while (TRUE)
    {
        if (!AtaPortGetNextEvent(PortData, &Action))
            break;
 
#if DBG
        if (PortData->Worker.StateLoopCount++ > 1500)
        {
            ERR("CH %lu: Loop detected %lx\n", PortData->PortNumber,
                PortData->Worker.EventsPending);
            ASSERT(FALSE);
        }
#endif
 
        switch (Action)
        {
            case ACTION_PORT_RESET:
                Status = AtaPortResetPort(PortData);
                break;
            case ACTION_ENUM_PORT:
                Status = AtaPortEnumeratePort(PortData);
                break;
            case ACTION_ENUM_DEVICE:
            case ACTION_ENUM_DEVICE_NEW:
                Status = AtaPortEnumerateDevice(PortData, Action);
                break;
            case ACTION_PORT_TIMING:
                Status = AtaPortSetTransferMode(PortData);
                break;
            case ACTION_DEVICE_CONFIG:
                Status = AtaPortConfigureDevice(PortData);
                break;
            case ACTION_DEVICE_ERROR:
                Status = AtaPortRecoveryFromError(PortData);
                break;
            case ACTION_DEVICE_POWER:
                Status = AtaPortDeviceChangePower(PortData);
                break;
 
            default:
                ASSERT(FALSE);
                UNREACHABLE;
        }
 
        if (Status == STATUS_ADAPTER_HARDWARE_ERROR)
            _InterlockedOr(&PortData->Worker.EventsPending, ACTION_PORT_RESET);
    }
}

Referenced by AtaPortWorkerThread().

AtaPortSendRequest()

NTSTATUS AtaPortSendRequest	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ PATAPORT_DEVICE_EXTENSION	DevExt
	)

Definition at line 831 of file portstate.c.

{
    PATA_DEVICE_REQUEST Request = &PortData->Worker.InternalRequest;
    KIRQL OldIrql;
 
    if (Request->Flags & REQUEST_FLAG_PACKET_COMMAND)
    {
        INFO("CH %lu: Send CDB %u %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
             PortData->PortNumber,
             DevExt->Device.AtaScsiAddress.TargetId,
             Request->Cdb[0],
             Request->Cdb[1],
             Request->Cdb[2],
             Request->Cdb[3],
             Request->Cdb[4],
             Request->Cdb[5],
             Request->Cdb[6]);
    }
    else
    {
        INFO("CH %lu: Send TF %u %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
             PortData->PortNumber,
             DevExt->Device.AtaScsiAddress.TargetId,
             Request->TaskFile.Command,
             Request->TaskFile.Feature,
             Request->TaskFile.SectorCount,
             Request->TaskFile.LowLba,
             Request->TaskFile.MidLba,
             Request->TaskFile.HighLba,
             Request->TaskFile.DriveSelect);
    }
 
    KeClearEvent(&PortData->Worker.CompletionEvent);
 
    Request->Flags |= REQUEST_FLAG_INTERNAL;
    Request->Device = (PATA_IO_CONTEXT_COMMON)&DevExt->Device;
 
    PortData->Worker.OldRequest = PortData->Slots[0];
    PortData->Slots[0] = Request;
 
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 
    KeAcquireSpinLockAtDpcLevel(&PortData->QueueLock);
    PortData->ActiveTimersBitmap |= 1 << 0;
    KeReleaseSpinLockFromDpcLevel(&PortData->QueueLock);
 
    AtaReqSendRequest(Request);
 
    KeLowerIrql(OldIrql);
 
    KeWaitForSingleObject(&PortData->Worker.CompletionEvent, Executive, KernelMode, FALSE, NULL);
 
    /* Stop the timer */
    KeAcquireSpinLock(&PortData->QueueLock, &OldIrql);
    PortData->ActiveTimersBitmap = 0;
    KeReleaseSpinLock(&PortData->QueueLock, OldIrql);
 
    PortData->Slots[0] = PortData->Worker.OldRequest;
 
    if ((Request->SrbStatus == SRB_STATUS_TIMEOUT) ||
        (Request->SrbStatus == SRB_STATUS_BUS_RESET))
    {
        return STATUS_ADAPTER_HARDWARE_ERROR;
    }
 
    if (Request->SrbStatus == SRB_STATUS_SUCCESS)
        return STATUS_SUCCESS;
 
    return STATUS_IO_DEVICE_ERROR;
}

Referenced by AtaDeviceEnableMsnFeature(), AtaDeviceExecuteAcpiTaskFile(), AtaDeviceFlushCache(), AtaDeviceLockDeviceParameters(), AtaDeviceLockSecurityModeFeatureCommands(), AtaDeviceSendIdentify(), AtaDeviceSendInquiry(), AtaDeviceSendReadNcqCommandErrorLog(), AtaDeviceSendRequestSense(), AtaDeviceSendRequestSenseExt(), AtaDeviceSetDmaTransferMode(), AtaDeviceSetGeometry(), AtaDeviceSetIdleMode(), AtaDeviceSetMultipleMode(), AtaDeviceSetPioTransferMode(), AtaDeviceSetStandbyMode(), and AtaDeviceSpinUp().

AtaPortSetTransferMode()

static NTSTATUS AtaPortSetTransferMode ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 447 of file portstate.c.

{
    AtaPortSelectTimings(PortData, FALSE);
    AtaPortClearPortAction(&PortData->Worker, ACTION_PORT_TIMING);
 
    return STATUS_SUCCESS;
}

Referenced by AtaPortRunStateMachine().

AtaPortSignalWorkerThread()

DECLSPEC_NOINLINE_FROM_PAGED VOID AtaPortSignalWorkerThread

(

_In_ PATAPORT_PORT_DATA

PortData

)

Definition at line 963 of file portstate.c.

{
    KIRQL OldIrql;
 
    KeAcquireSpinLock(&PortData->Worker.Lock, &OldIrql);
    KeSetEvent(&PortData->Worker.ThreadEvent, IO_NO_INCREMENT, FALSE);
    KeReleaseSpinLock(&PortData->Worker.Lock, OldIrql);
}

Referenced by AtaFdoDestroyPortThread(), and AtaPortWorkerSignalDpc().

AtaPortTimeout()

VOID AtaPortTimeout	(	_In_ PATAPORT_PORT_DATA	PortData,
		_In_ ULONG	Slot
	)

Definition at line 905 of file portstate.c.

{
    PATA_DEVICE_REQUEST Request;
    PATAPORT_DEVICE_EXTENSION DevExt;
 
    ASSERT(KeGetCurrentIrql() > DISPATCH_LEVEL);
 
    Request = PortData->Slots[Slot];
    ASSERT_REQUEST(Request);
 
    DevExt = CONTAINING_RECORD(Request->Device, ATAPORT_DEVICE_EXTENSION, Device);
 
    ERR("CH %lu: Slot %lu (%08lx) timed out %lx (%lus) %u '%s'\n",
        PortData->PortNumber,
        Slot,
        1 << Slot,
        Request->Flags,
        Request->TimeOut,
        DevExt->Device.AtaScsiAddress.TargetId,
        DevExt->FriendlyName);
    if (Request->Flags & REQUEST_FLAG_PACKET_COMMAND)
    {
        ERR("CH %lu: CDB %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
            PortData->PortNumber,
            Request->Cdb[0],
            Request->Cdb[1],
            Request->Cdb[2],
            Request->Cdb[3],
            Request->Cdb[4],
            Request->Cdb[5],
            Request->Cdb[6]);
    }
    else
    {
        ERR("CH %lu: TF %02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
            PortData->PortNumber,
            Request->TaskFile.Command,
            Request->TaskFile.Feature,
            Request->TaskFile.SectorCount,
            Request->TaskFile.LowLba,
            Request->TaskFile.MidLba,
            Request->TaskFile.HighLba,
            Request->TaskFile.DriveSelect);
    }
 
    Request->SrbStatus = SRB_STATUS_TIMEOUT;
 
    /* The active command has timed out, set the ATA outputs to something meaningful */
    Request->Output.Status = IDE_STATUS_ERROR;
    Request->Output.Error = IDE_ERROR_COMMAND_ABORTED;
 
    AtaPortQueueEvent(PortData, NULL, Request, ACTION_PORT_RESET | ACTION_DEVICE_ERROR);
}

Referenced by AtaPortIoTimer().

AtaPortWaitForIdle()

static VOID AtaPortWaitForIdle ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 569 of file portstate.c.

{
    KIRQL OldIrql;
    BOOLEAN DoWait = FALSE;
 
    KeAcquireSpinLock(&PortData->QueueLock, &OldIrql);
    KeClearEvent(&PortData->QueueStoppedEvent);
    if (!AtaPortQueueEmpty(PortData))
    {
        PortData->QueueFlags |= PORT_QUEUE_FLAG_SIGNAL_STOP;
        DoWait = TRUE;
    }
    KeReleaseSpinLock(&PortData->QueueLock, OldIrql);
    if (DoWait)
    {
        KeWaitForSingleObject(&PortData->QueueStoppedEvent, Executive, KernelMode, FALSE, NULL);
    }
}

Referenced by AtaPortEnterStateMachine().

AtaPortWorkerClearSignal()

static VOID AtaPortWorkerClearSignal ( _In_ PATAPORT_PORT_DATA  PortData )

static

Definition at line 717 of file portstate.c.

{
    KIRQL OldIrql;
 
    KeAcquireSpinLock(&PortData->Worker.Lock, &OldIrql);
    KeClearEvent(&PortData->Worker.ThreadEvent);
    KeReleaseSpinLock(&PortData->Worker.Lock, OldIrql);
}

Referenced by AtaPortWorkerThread().

AtaPortWorkerSignalDpc()

VOID NTAPI AtaPortWorkerSignalDpc	(	_In_ PKDPC	Dpc,
		_In_opt_ PVOID	DeferredContext,
		_In_opt_ PVOID	SystemArgument1,
		_In_opt_ PVOID	SystemArgument2
	)

Definition at line 975 of file portstate.c.

{
    PATAPORT_PORT_DATA PortData = DeferredContext;
 
    UNREFERENCED_PARAMETER(Dpc);
    UNREFERENCED_PARAMETER(SystemArgument1);
    UNREFERENCED_PARAMETER(SystemArgument2);
 
    AtaPortSignalWorkerThread(PortData);
}

AtaPortWorkerThread()

VOID NTAPI AtaPortWorkerThread

(

_In_ PVOID

StartContext

)

Definition at line 729 of file portstate.c.

{
    PATAPORT_PORT_DATA PortData = StartContext;
 
    while (TRUE)
    {
        KeWaitForSingleObject(&PortData->Worker.ThreadEvent,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        if (PortData->PortFlags & PORT_FLAG_EXIT_THREAD)
            break;
 
        AtaPortWorkerClearSignal(PortData);
        AtaPortEnterStateMachine(PortData);
        AtaPortRunStateMachine(PortData);
        AtaPortExitStateMachine(PortData);
    }
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}