VOID
Hw11Terminate(
__in PHW Hw
)
{
//
// Deregister the DMA from NDIS
//
if (Hw->MiniportDmaHandle != NULL)
{
NdisMDeregisterScatterGatherDma(Hw->MiniportDmaHandle);
}
//
// Cancel all other timers (these are all stopped already)
//
MPASSERT(NdisCancelTimerObject(Hw->ScanContext.Timer_Scan) == FALSE);
MPASSERT(NdisCancelTimerObject(Hw->PhyState.Timer_Doze) == FALSE);
MPASSERT(NdisCancelTimerObject(Hw->PhyState.Timer_Awake) == FALSE);
}
//------------------------------------------------------------------------------
tOplkError hrestimer_exit(void)
{
tHresTimerInfo* pTimerInfo;
UINT index;
if (!hresTimerInstance_l.fInitialized)
return kErrorOk;
for (index = 0; index < TIMER_COUNT; index++)
{
pTimerInfo = &hresTimerInstance_l.aTimerInfo[index];
NdisCancelTimerObject(pTimerInfo->timerObjHandle);
NdisFreeTimerObject(pTimerInfo->timerObjHandle);
pTimerInfo->dueTime.QuadPart = 0;
pTimerInfo->eventArg.timerHdl.handle = 0;
pTimerInfo->pfnCallback = NULL;
}
hresTimerInstance_l.fInitialized = FALSE;
return kErrorOk;
}
BOOLEAN
HwAwake(
_In_ PHW Hw,
_In_ BOOLEAN DeviceIRQL
)
{
BOOLEAN Canceled;
if (HalGetRFPowerState(Hw->Hal) != RF_ON)
{
MpTrace(COMP_POWER, DBG_LOUD, (" *** RF ON\n"));
if (!DeviceIRQL)
{
//
// Try to cancel timer in case we are not called by timer this time
//
Canceled = NdisCancelTimerObject(Hw->PhyState.Timer_Awake);
if (Canceled)
{
MpTrace(COMP_POWER, DBG_LOUD, ("Power ON timer cancelled\n"));
}
// Enable RF and retry 3 times if something else is using it
return HwSetRFOn(Hw, 3);
}
else
{
return HwSetRFState(Hw, RF_ON);
}
}
return TRUE;
}
//------------------------------------------------------------------------------
void stopHeartbeatTimer(void)
{
NdisCancelTimerObject(heartbeatTimer_l);
}
VOID
NICStopTheDatapath(
_In_ PMP_ADAPTER Adapter)
/*++
Routine Description:
This function prevents future sends and receives on the data path, then
prepares the adapter to reach an idle state.
Although the adapter is entering an idle state, there may still be
outstanding NBLs that haven't been returned by a protocol. Call NICIsBusy
to check if NBLs are still outstanding.
Runs at IRQL == PASSIVE_LEVEL.
Arguments:
Adapter Pointer to our adapter
Return Value:
None.
--*/
{
BOOLEAN fResetCancelled, fSendCancelled;
PLIST_ENTRY ReceiveListEntry;
DEBUGP(MP_TRACE, "[%p] ---> NICStopTheDatapath.\n", Adapter);
PAGED_CODE();
//
// Remove this adapter from consideration for future receives.
//
MPDetachAdapter(Adapter);
//
// Free any queued send operations
//
TXFlushSendQueue(Adapter, NDIS_STATUS_FAILURE);
//
// Prevent new calls to NICAsyncResetOrPauseDpc
//
fResetCancelled = NdisCancelTimerObject(Adapter->AsyncBusyCheckTimer);
//
// Prevent new calls to RXReceiveIndicateDpc.
//
for(ReceiveListEntry = Adapter->RecvDpcList.Flink;
ReceiveListEntry != &Adapter->RecvDpcList;
ReceiveListEntry = ReceiveListEntry->Flink)
{
PMP_ADAPTER_RECEIVE_DPC ReceiveDpc = CONTAINING_RECORD(ReceiveListEntry, MP_ADAPTER_RECEIVE_DPC, Entry);
KeRemoveQueueDpc(&ReceiveDpc->Dpc);
}
//
// Prevent new calls to TXSendCompleteDpc.
//
fSendCancelled = NdisCancelTimerObject(Adapter->SendCompleteTimer);
//
// Wait for any DPCs (like our reset and recv timers) that were in-progress
// to run to completion. This is slightly expensive to call, but we don't
// mind calling it during MiniportHaltEx, since it's not a performance-
// sensitive path.
//
KeFlushQueuedDpcs();
if (fSendCancelled)
{
// Free resources associated with a pending (but cancelled) send
}
if (fResetCancelled)
{
// Free resources associated with a pending (but cancelled) reset
}
//
// Double-check that there are still no queued receive operations
//
for(ReceiveListEntry = Adapter->RecvDpcList.Flink;
ReceiveListEntry != &Adapter->RecvDpcList;
ReceiveListEntry = ReceiveListEntry->Flink)
{
RXFlushReceiveQueue(Adapter, CONTAINING_RECORD(ReceiveListEntry, MP_ADAPTER_RECEIVE_DPC, Entry));
}
//
// Double-check that there are still no queued send operations
//
TXFlushSendQueue(Adapter, NDIS_STATUS_FAILURE);
DEBUGP(MP_TRACE, "[%p] <--- NICStopTheDatapath.\n", Adapter);
}
VOID
HelperPortCancelScan(
_In_ PMP_PORT Port,
_In_ PMP_PORT RequestingPort
)
{
ULONG i;
PMP_HELPER_PORT helperPort = MP_GET_HELPPORT(Port);
PMP_SCAN_PARAMETERS scanParameters = NULL;
MP_SCAN_STATE preCancelState = SCAN_EMPTY_REQUEST;
NDIS_STATUS ndisStatus;
BOOLEAN timerCancelled = FALSE;
// Add this scan request to the list
MP_ACQUIRE_PORT_LOCK(Port, FALSE);
// Search for the scan request in our list
for (i = 0; i < MP_MAX_NUMBER_OF_PORT; i++)
{
if ((helperPort->ScanContext.ScanParameters[i].State != SCAN_EMPTY_REQUEST) &&
(helperPort->ScanContext.ScanParameters[i].State != SCAN_COMPLETED) &&
(helperPort->ScanContext.ScanParameters[i].RequestingPort == RequestingPort))
{
// The scan request from this port is in the queue
scanParameters = &helperPort->ScanContext.ScanParameters[i];
scanParameters->CancelScan = TRUE;
// Add a refcount to ensure that the structure does not get deleted on us
MP_INCREMENT_SCAN_PARAMETER_REF(scanParameters);
preCancelState = scanParameters->State;
// Save the previous state (for tracking)
scanParameters->TrackingPreCancelState = preCancelState;
if (preCancelState == SCAN_QUEUED_FOR_PROCESSING)
{
// This request is not yet activated for processing.
// Remove the request from the pending scan list. This is done right now
// with the lock held so that the request does not get requeued
scanParameters->State = SCAN_REQUEST_IN_USE;
MpTrace(COMP_SCAN, DBG_NORMAL, ("Canceling unprocessed scan request\n"));
}
else if (preCancelState == SCAN_EXCLUSIVE_ACCESS_QUEUED)
{
// We are unsure if the exclusive access request would
// be granted or not. It would be granted if the cancel was part of
// a pause or something. It would not be granted if this was
// a halt
MpTrace(COMP_SCAN, DBG_NORMAL, ("Canceling scan request waiting for exclusive access\n"));
}
break;
}
}
MP_RELEASE_PORT_LOCK(Port, FALSE);
if (scanParameters == NULL)
{
// No scan to cancel.
return;
}
if (preCancelState != SCAN_QUEUED_FOR_PROCESSING)
{
// NOTE: Since we added the ref, we know that the ScanParameters buffer is available
// If we have the timer running, force fire the timer
timerCancelled = NdisCancelTimerObject(helperPort->ScanContext.Timer_Scan);
if (timerCancelled == TRUE)
{
// We cancelled the timer, so we would need to invoke the complete ourselves
MpTrace(COMP_SCAN, DBG_NORMAL, ("Canceling scan request waiting for scan timer\n"));
HelperPortScanTimerCallback(helperPort);
}
else
{
// We could be waiting for exclusive access
if (preCancelState == SCAN_EXCLUSIVE_ACCESS_QUEUED)
{
// We would complete the scan here. Because of the cancel flag, the
// exclusive access routine would not proceed with the scan
// if it got called
ndisStatus = NDIS_STATUS_REQUEST_ABORTED;
MP_ACQUIRE_PORT_LOCK(HELPPORT_GET_MP_PORT(helperPort), FALSE);
// Clear the active pointer
helperPort->ScanContext.ActiveScanParameters = NULL;
scanParameters->State = SCAN_COMPLETED;
MP_RELEASE_PORT_LOCK(HELPPORT_GET_MP_PORT(helperPort), FALSE);
// Now perform the indication
HelperPortIndicateScanCompletion(helperPort, scanParameters, &ndisStatus);
// We dont remove the reference here. We wait for the ex or the scan
// to do it
}
// Ask the HW to cancel the scan (if it has it)
VNic11CancelScan(HELPPORT_GET_VNIC(helperPort));
}
// Now wait for the scan complete to get indicated
while (scanParameters->State != SCAN_COMPLETED)
{
MpTrace(COMP_SCAN, DBG_NORMAL, ("Waiting for scan operation to complete\n"));
NdisMSleep(20 * 1000);
}
// This lock is acquired to ensure that the free here does not conflict with an
// in progress scan completion
MP_ACQUIRE_PORT_LOCK(Port, FALSE);
HelperPortScanParametersReleaseRef(helperPort, scanParameters);
MP_RELEASE_PORT_LOCK(Port, FALSE);
// If there is a different second scan pending, process it
HelperPortProcessPendingScans(helperPort);
}
else
{
// This scan was never started, we need to complete the scan request & we are done
ndisStatus = NDIS_STATUS_REQUEST_ABORTED;
HelperPortIndicateScanCompletion(helperPort, scanParameters, &ndisStatus);
MP_ACQUIRE_PORT_LOCK(Port, FALSE);
scanParameters->State = SCAN_COMPLETED;
HelperPortScanParametersReleaseRef(helperPort, scanParameters);
MP_RELEASE_PORT_LOCK(Port, FALSE);
}
}
