NDIS_STATUS
Sta11PausePort(
_In_ PMP_PORT Port
)
{
PMP_EXTSTA_PORT extStaPort = MP_GET_STA_PORT(Port);
//
// Wait for roam/scan operations to finish
//
StaStopScan(extStaPort);
//
// Wait for all asynchronous threads to complete. This waits for connection
// attempt to complete
//
while (extStaPort->ConnectContext.AsyncFuncCount > 0)
{
NdisMSleep(100);
}
while (extStaPort->AdHocStaInfo.AsyncFuncCount > 0)
{
NdisMSleep(100);
}
if (extStaPort->Config.BSSType == dot11_BSS_type_independent && Port->CurrentOpState == OP_STATE)
{
StaStopAdHocBeaconing(extStaPort);
}
return BasePortPausePort(Port);
}
VOID wlan_destroy_thread(HANDLE event)
{
int i;
PTHREAD_PARAM pparam = NULL;
for (i=0 ; i<theadlistsize ; i++) {
if (threadlist[i].hEvent == event) {
pparam = &threadlist[i];
break;
}
}
if (i == MAX_THREADLIST) {
DBGPRINT(DBG_THREAD|DBG_WARNING,(L"->Thread: wlan_destroy_thread: No available thread to destroy\n"));
goto funcFinal;
}
DBGPRINT(DBG_THREAD|DBG_HELP,(L"->Thread: wlan_destroy_thread: destroying (%d)th thread in %d\n", i, theadlistsize));
///Destory the thread
if (pparam->EndOfThread == FALSE) {
///Terminate the thread
pparam->EndOfThread = TRUE;
SetEvent(pparam->hEvent);
//wait until the thread is terminated
DBGPRINT(DBG_THREAD|DBG_HELP,(L"->Thread: Waiting for thread to be terminated\n"));
while (pparam->isThreadEnded == FALSE) {
NdisMSleep(1);
}
NdisMSleep(1);
DBGPRINT(DBG_THREAD|DBG_HELP,(L"->Thread: Thread is ended. Close the handler now\n"));
CloseHandle(pparam->hEvent);
CloseHandle(pparam->hThread);
CloseHandle(pparam->syncthread);
} else {
DBGPRINT(DBG_THREAD|DBG_WARNING,(L"->Thread: <Warning> wlan_destroy_thread: Thread had been ended \n"));
}
///Reorganize the list;
if (theadlistsize > 1) {
NdisMoveMemory(pparam, &threadlist[theadlistsize-1], sizeof(THREAD_PARAM));
NdisZeroMemory(&threadlist[theadlistsize-1], sizeof(THREAD_PARAM));
}
theadlistsize --;
DBGPRINT(DBG_THREAD|DBG_HELP,(L"->Thread: wlan_destroy_thread: Thread is destroyed successfully\n"));
funcFinal:
return;
}
//------------------------------------------------------------------------------
tOplkError eventkcal_exit(void)
{
UINT i = 0;
instance_l.fInitialized = FALSE;
instance_l.fStopThread = TRUE;
NdisSetEvent(&instance_l.kernelWaitEvent);
NdisSetEvent(&instance_l.userWaitEvent);
while (instance_l.fThreadIsRunning)
{
NdisMSleep(10);
if (i++ > 1000)
{
DEBUG_LVL_EVENTK_TRACE("Event thread is not terminating, continue shutdown...!\n");
break;
}
}
ZwClose(instance_l.hThreadHandle);
eventkcal_exitQueueCircbuf(kEventQueueK2U);
eventkcal_exitQueueCircbuf(kEventQueueU2K);
eventkcal_exitQueueCircbuf(kEventQueueUInt);
eventkcal_exitQueueCircbuf(kEventQueueKInt);
return kErrorOk;
}
void rtw_usleep_os(int us)
{
#ifdef PLATFORM_LINUX
// msleep((unsigned int)us);
if ( 1 < (us/1000) )
msleep(1);
else
msleep( (us/1000) + 1);
#endif
#ifdef PLATFORM_FREEBSD
//Delay for delay microseconds
DELAY(us);
return ;
#endif
#ifdef PLATFORM_WINDOWS
NdisMSleep(us); //(us)
#endif
}
// XXX this whole thing is f****d up
static void get_mac(PADAPT adapt)
{
NDIS_STATUS Status;
_req.RequestType = NdisRequestQueryInformation;
_req.DATA.QUERY_INFORMATION.Oid = OID_802_3_CURRENT_ADDRESS;
_req.DATA.QUERY_INFORMATION.InformationBuffer = _mac;
_req.DATA.QUERY_INFORMATION.InformationBufferLength = NPROT_MAC_ADDR_LEN;
NdisRequest(&Status,
adapt->BindingHandle,
&_req);
if (Status == NDIS_STATUS_PENDING) {
DbgPrint("f**K PENDING\n");
while (_req.DATA.QUERY_INFORMATION.Oid != 0)
NdisMSleep(2);
} else {
_req.DATA.QUERY_INFORMATION.Oid = 0;
DbgPrint("MAC %x %x %x %x %x %x\n",
_mac[0], _mac[1], _mac[2], _mac[3], _mac[4], _mac[5]);
}
}
void rtw_sleep_schedulable(int ms)
{
#ifdef PLATFORM_LINUX
u32 delta;
delta = (ms * HZ)/1000;//(ms)
if (delta == 0) {
delta = 1;// 1 ms
}
set_current_state(TASK_INTERRUPTIBLE);
if (schedule_timeout(delta) != 0) {
return ;
}
return;
#endif
#ifdef PLATFORM_WINDOWS
NdisMSleep(ms*1000); //(us)*1000=(ms)
#endif
}
//
// FilterRestart Function
// http://msdn.microsoft.com/en-us/library/ff549962(v=VS.85).aspx
//
_Use_decl_annotations_
NDIS_STATUS
SxNdisPause(
NDIS_HANDLE FilterModuleContext,
PNDIS_FILTER_PAUSE_PARAMETERS PauseParameters
)
{
PSX_SWITCH_OBJECT switchObject = (PSX_SWITCH_OBJECT)(FilterModuleContext);
UNREFERENCED_PARAMETER(PauseParameters);
DEBUGP(DL_TRACE,
("===>NDISLWF SxPause: SxInstance %p\n", FilterModuleContext));
SxExtPauseSwitch(switchObject, switchObject->ExtensionContext);
//
// Set the flag that the filter is going to pause.
//
NT_ASSERT(switchObject->DataFlowState == SxSwitchRunning);
switchObject->DataFlowState = SxSwitchPaused;
KeMemoryBarrier();
while(switchObject->PendingInjectedNblCount > 0)
{
NdisMSleep(1000);
}
DEBUGP(DL_TRACE, ("<===SxPause: status %x\n", NDIS_STATUS_SUCCESS));
return NDIS_STATUS_SUCCESS;
}
VOID
HvlWaitForPendingThreads(
_In_ PHVL pHvl
)
{
ULONG ulNumIter = 0;
BOOLEAN fThreadsFinished = FALSE;
/*
Wait for any pending threads to complete before freeing stuff
*/
while (!fThreadsFinished)
{
if ( ++ulNumIter > 30000)
{
// 30 seconds have passed - something must be wrong
ASSERTMSG("Hvl pending thread count hasn't gone to 0 in last 30 seconds. Check driver state\n", FALSE);
}
HvlLock(pHvl);
if (pHvl->ulNumThreadsPending == 0)
{
fThreadsFinished = TRUE;
}
HvlUnlock(pHvl);
if (!fThreadsFinished)
{
NdisMSleep(1000);
}
}
}
VOID
HvlWaitForCtxSProcessingAndLock(_In_ PHVL pHvl)
{
HvlLock(pHvl);
while (HvlIsCtxSInProgress(pHvl))
{
HvlUnlock(pHvl);
NdisMSleep(10 * 1000); // 10 msec
HvlLock(pHvl);
}
}
static VOID wlan_roam_BGScan_deInit(PBGSCANPARAM pScanParam)
{
if (pScanParam->hEventScanComplete != NULL) {
SetEvent(pScanParam->hEventScanComplete);
///To yield the resource
NdisMSleep(1);
CloseHandle(pScanParam->hEventScanComplete);
pScanParam->hEventScanComplete = NULL;
}
return;
}
BOOLEAN PORT_WAIT_FOR_SEND_TOKEN(PMP_PORT Port, ULONG SleepCount)
{
while (TRUE)
{
if (PORT_ACQUIRE_SEND_TOKEN(Port))
return TRUE; // Got the token
// If we have exhausted waiting, give up
if (SleepCount == 0)
return FALSE;
// Sleep a while & we will try again
NdisMSleep(10000);
--SleepCount;
}
}
void rtw_msleep_os(int ms)
{
#ifdef PLATFORM_LINUX
msleep((unsigned int)ms);
#endif
#ifdef PLATFORM_WINDOWS
NdisMSleep(ms*1000); //(us)*1000=(ms)
#endif
}
void usleep_os(int us)
{
#ifdef PLATFORM_LINUX
msleep((unsigned int)us);
#endif
#ifdef PLATFORM_WINDOWS
NdisMSleep(us); //(us)
#endif
}
/*
* --------------------------------------------------------------------------
* Implements filter driver's FilterPause function
* --------------------------------------------------------------------------
*/
NDIS_STATUS
OvsExtPause(NDIS_HANDLE filterModuleContext,
PNDIS_FILTER_PAUSE_PARAMETERS pauseParameters)
{
POVS_SWITCH_CONTEXT switchContext = (POVS_SWITCH_CONTEXT)filterModuleContext;
UNREFERENCED_PARAMETER(pauseParameters);
OVS_LOG_TRACE("Enter: filterModuleContext %p",
filterModuleContext);
switchContext->dataFlowState = OvsSwitchPaused;
KeMemoryBarrier();
while(switchContext->pendingOidCount > 0) {
NdisMSleep(1000);
}
OVS_LOG_TRACE("Exit: OvsExtPause Successfully");
return NDIS_STATUS_SUCCESS;
}
/*
* --------------------------------------------------------------------------
* Implements filter driver's FilterDetach function.
* --------------------------------------------------------------------------
*/
_Use_decl_annotations_
VOID
OvsExtDetach(NDIS_HANDLE filterModuleContext)
{
POVS_SWITCH_CONTEXT switchContext = (POVS_SWITCH_CONTEXT)filterModuleContext;
OVS_LOG_TRACE("Enter: filterModuleContext %p", filterModuleContext);
ASSERT(switchContext->dataFlowState == OvsSwitchPaused);
switchContext->controlFlowState = OvsSwitchDetached;
KeMemoryBarrier();
while(switchContext->pendingOidCount > 0) {
NdisMSleep(1000);
}
OvsDeleteSwitch(switchContext);
OvsCleanupIpHelper();
/* This completes the cleanup, and a new attach can be handled now. */
OVS_LOG_TRACE("Exit: OvsDetach Successfully");
}
void rtw_msleep_os(int ms)
{
#ifdef PLATFORM_LINUX
msleep((unsigned int)ms);
#endif
#ifdef PLATFORM_FREEBSD
//Delay for delay microseconds
DELAY(ms*1000);
return ;
#endif
#ifdef PLATFORM_WINDOWS
NdisMSleep(ms*1000); //(us)*1000=(ms)
#endif
}
void rtw_usleep_os(int us)
{
#ifdef PLATFORM_LINUX
// msleep((unsigned int)us);
if ( 1 < (us/1000) )
msleep(1);
else
msleep( (us/1000) + 1);
#endif
#ifdef PLATFORM_WINDOWS
NdisMSleep(us); //(us)
#endif
}
NDIS_STATUS NeoNdisPause(NDIS_HANDLE MiniportAdapterContext, PNDIS_MINIPORT_PAUSE_PARAMETERS MiniportPauseParameters)
{
UINT counter_dbg = 0;
ctx->Paused = true;
NeoLockPacketQueue();
NeoUnlockPacketQueue();
// Wait for complete all tasks
while (ctx->NumCurrentDispatch != 0)
{
NdisMSleep(10000);
counter_dbg++;
if (counter_dbg >= 1500)
{
break;
}
}
return NDIS_STATUS_SUCCESS;
}
//
// FilterDetach Function
// http://msdn.microsoft.com/en-us/library/ff549918(v=VS.85).aspx
//
_Use_decl_annotations_
VOID
SxNdisDetach(
NDIS_HANDLE FilterModuleContext
)
{
PSX_SWITCH_OBJECT switchObject = (PSX_SWITCH_OBJECT)FilterModuleContext;
DEBUGP(DL_TRACE, ("===>SxDetach: SxInstance %p\n", FilterModuleContext));
//
// The extension must be in paused state.
//
NT_ASSERT(switchObject->DataFlowState == SxSwitchPaused);
switchObject->ControlFlowState = SxSwitchDetached;
KeMemoryBarrier();
while(switchObject->PendingOidCount > 0)
{
NdisMSleep(1000);
}
SxExtDeleteSwitch(switchObject, switchObject->ExtensionContext);
NdisAcquireSpinLock(&SxExtensionListLock);
RemoveEntryList(&switchObject->Link);
NdisReleaseSpinLock(&SxExtensionListLock);
ExFreePool(switchObject);
//
// Alway return success.
//
DEBUGP(DL_TRACE, ("<===SxDetach Successfully\n"));
return;
}
//------------------------------------------------------------------------------
void target_msleep(UINT32 milliSeconds_p)
{
NdisMSleep(milliSeconds_p * 1000);
}
/************************************************************************
* SteMiniportHalt()
*
* NDIS Miniport エントリポイント
* Halt ハンドラは NDIS が PNP マネージャから IRP_MN_STOP_DEVICE、
* IRP_MN_SUPRISE_REMOVE、IRP_MN_REMOVE_DEVICE 要求を受け取ったと
* きに呼ばれる。SteMiniportInitialize で確保された全てのリソース
* を解放する。（特定のミニポートドライバインスタンスに限定される)
*
* o 全ての I/O リソースを free し、unmap する。
* o NdisMRegisterAdapterShutdownHandler によって登録されたシャッ
* トダウンハンドラを登録解除する。
* o NdisMCancelTimer を呼んでキューイングされているコールバック
* ルーチンをキャンセルする。
* o 全ての未処理の受信パケットが処理され終わるまで待つ。
*
* 引数:
* MiniportAdapterContext アダプタへのポインタ
*
* 返り値:
*
* 無し
********************************************************************/
VOID
SteMiniportHalt(
IN NDIS_HANDLE MiniportAdapterContext
)
{
STE_ADAPTER *Adapter;
BOOLEAN bTimerCancelled;
INT i;
DEBUG_PRINT0(3, "SteMiniportHalt called\n");
Adapter = (STE_ADAPTER *) MiniportAdapterContext;
SteMiniportShutdown(
(PVOID) Adapter //IN PVOID
);
//
// NdisMCancelTimer を呼んでキューイングされているコールバック
// ルーチンをキャンセルする。
//
// ReceiveIndication タイマーをキャンセル
NdisCancelTimer(
&Adapter->RecvTimer, // IN PNDIS_TIMER
&bTimerCancelled // OUT PBOOLEAN
);
// Reset タイマーをキャンセル
NdisCancelTimer(
&Adapter->ResetTimer, // IN PNDIS_TIMER
&bTimerCancelled // OUT PBOOLEAN
);
if (bTimerCancelled == TRUE){
// キャンセルされたコールバックルーチンがあったようだ。
// 受信キューに残っている Packet はこの後の SteDeleteAdapter()
// によって Free されるので、ここでは何もしない。
}
// NdisMRegisterAdapterShutdownHandler によって登録された
// シャットダウンハンドラを登録解除する。
NdisMDeregisterAdapterShutdownHandler(
Adapter->MiniportAdapterHandle // IN NDIS_HANDLE
);
//
// 仮想 NIC デーモンからの IOCT/READ/WRITE 用のデバイスの登録を解除する。
//
SteDeregisterDevice(Adapter);
//
// 処理中の受信通知済みパケットがないかどうかチェックする。
// 1 秒おきに、STE_MAX_WAIT_FOR_RECVINDICATE(=5)回確認し、
// RecvIndicatedPackets が 0 にならないようであれば、
// なにか問題があったと考え無視してリソースの開放に進む。
//
for ( i = 0 ; i < STE_MAX_WAIT_FOR_RECVINDICATE ; i++){
if (Adapter->RecvIndicatedPackets == 0) {
break;
}
NdisMSleep(1000);
}
//
// Adapter を削除する。このなかで、Adapter の為に確保されたリソースの
// 開放も（Packet や、Buffer）行われる。
//
SteDeleteAdapter(Adapter);
return;
}
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);
}
}
NDIS_STATUS
MiniportInitialize (
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE MiniportDriverContext,
IN PNDIS_MINIPORT_INIT_PARAMETERS MiniportInitParameters
)
{
PADAPTER adapter = NULL;
NDIS_STATUS ndisStatus;
PCHAR path;
PDEVICE_OBJECT pdo;
PCHAR xenbusPath = NULL;
int i;
UNREFERENCED_PARAMETER(MiniportDriverContext);
UNREFERENCED_PARAMETER(MiniportInitParameters);
TraceVerbose(("====> '%s'.\n", __FUNCTION__));
//
// Wait for xenbus to come up. SMP guests sometimes try and
// initialise xennet and xenvbd in parallel when they come back
// from hibernation, and that causes problems.
//
if (!xenbus_await_initialisation()) {
ndisStatus = NDIS_STATUS_DEVICE_FAILED;
goto exit;
}
//
// 8021P support is disabled by default.
// It can be turned on by specifying the appropriate PV boot option.
//
if (XenPVFeatureEnabled(DEBUG_NIC_8021_P)) {
XennetMacOptions |= NDIS_MAC_OPTION_8021P_PRIORITY;
}
xenbus_write(XBT_NIL, "drivers/xenwnet", XENNET_VERSION);
NdisMGetDeviceProperty(MiniportAdapterHandle,
&pdo,
NULL,
NULL,
NULL,
NULL);
xenbusPath = xenbus_find_frontend(pdo);
if (!xenbusPath) {
ndisStatus = NDIS_STATUS_ADAPTER_NOT_FOUND;
goto exit;
}
TraceNotice(("Found '%s' frontend.\n", xenbusPath));
adapter = XmAllocateZeroedMemory(sizeof(ADAPTER));
if (adapter == NULL) {
ndisStatus = NDIS_STATUS_RESOURCES;
goto exit;
}
path = xenbusPath;
xenbusPath = NULL;
i = 0;
do {
ndisStatus = AdapterInitialize(adapter, MiniportAdapterHandle, path);
if (ndisStatus != NDIS_STATUS_SUCCESS) {
TraceWarning (("Waiting for backend...\n"));
NdisMSleep (1000000); // 1 sec
}
} while ((ndisStatus != NDIS_STATUS_SUCCESS) && (++i < 30));
if (ndisStatus != NDIS_STATUS_SUCCESS) {
goto exit;
}
exit:
if (ndisStatus != NDIS_STATUS_SUCCESS) {
if (adapter) {
XmFreeMemory(adapter->BackendPath);
adapter->BackendPath = NULL;
AdapterDelete(&adapter);
}
if (xenbusPath) {
XmFreeMemory(xenbusPath);
}
}
TraceVerbose(("<==== '%s'.\n", __FUNCTION__));
return ndisStatus;
}
/******************************************************************************
*
* Name: MrvDrvSend()
*
* Description: NDIS miniport serialized send packet routine
*
* Conditions for Use: Protocol driver will call this routine to pass Tx NDIS_PACKET
*
* Arguments:
* IN NDIS_HANDLE MiniportAdapterContext
* IN PPNDIS_PACKET Packet
* IN UINT Flags
*
* Return Value: NDIS_STATUS_RESOURCES or NDIS_STATUS_PENDING
*
* Notes:
*
*****************************************************************************/
NDIS_STATUS
MrvDrvSend(
IN NDIS_HANDLE MiniportAdapterContext,
IN PNDIS_PACKET Packet,
IN UINT Flags)
{
PMRVDRV_ADAPTER Adapter;
NDIS_STATUS Status;
PNDIS_BUFFER pBuffer;
UINT BufferCount;
UINT Length;
UINT TotalPacketLength = 0;
PVOID pVirtualAddr;
PTxCtrlNode pTxNode;
PUCHAR pHeader = NULL;
Status = NDIS_STATUS_SUCCESS;
Adapter = (PMRVDRV_ADAPTER)MiniportAdapterContext;
DBGPRINT(DBG_TX, (L"+MrvDrvSend()\n"));
// printf ("+MrvDrvSend()\n");
// In Deep Sleep Mode no packet can be sent out
//012207
//if (Adapter->IsDeepSleep)
if( !IsThisDsState(Adapter, DS_STATE_NONE) )
{
//Status = NDIS_STATUS_NO_CABLE;
return NDIS_STATUS_FAILURE;
}
// Check device removal status
if( Adapter->SurpriseRemoved == TRUE )
{
DBGPRINT(DBG_TX|DBG_WARNING,(TEXT("[MrvSend]: NDIS_STATUS_FAILURE by supriseRemoved\r\n")));
return NDIS_STATUS_FAILURE;
}
if( Adapter->bIsPendingReset == TRUE || Adapter->ChipResetting == 1)
{
DBGPRINT(DBG_TX|DBG_CMD|DBG_WARNING,(L"[MrvSend]: NDIS RETURN FAILURE by bIsPendingReset or ChipReset\r\n"));
return NDIS_STATUS_FAILURE;
}
if ( Adapter->MediaConnectStatus == NdisMediaStateDisconnected )
{
DBGPRINT(DBG_TX|DBG_WARNING, (L"***WARNING: OS attempted to send packet while disconnected!\r\n"));
if (IsIndicateDisconnect(Adapter) == TRUE) {
Ndis_MediaStatus_Notify(Adapter,NDIS_STATUS_MEDIA_DISCONNECT);
} else {
NdisMSleep(100000); ///Sleep 100ms temporally
}
//dralee_20060712
ResetAllScanTypeAndPower(Adapter);
CleanUpSingleTxBuffer(Adapter);
ResetRxPDQ(Adapter);
return NDIS_STATUS_FAILURE;
}
if( Adapter->bIsScanInProgress == TRUE ) {
return NDIS_STATUS_SUCCESS;
}
*((ULONG *)(&Packet->MacReserved[0])) = GetTickCount();
// check if in key absent state, if so, block all packet other than
// 802.1x
if ( (Adapter->EncryptionStatus == Ndis802_11Encryption2KeyAbsent )|| (Adapter->EncryptionStatus == Ndis802_11Encryption3KeyAbsent ) )
{
pTxNode = &Adapter->TxNode;
NdisQueryPacket(
Packet,
NULL,
&BufferCount,
&pBuffer,
&TotalPacketLength );
if (!pBuffer || !BufferCount || !TotalPacketLength)
{
return NDIS_STATUS_FAILURE;
}
NdisQueryBuffer(pBuffer, &pVirtualAddr, &Length);
pHeader = (PUCHAR)pVirtualAddr;
if ( TotalPacketLength < 14 )
{
// malformed packet, blocked!
DBGPRINT(DBG_TX|DBG_WARNING,(L"Got packet with size less than 14 bytes, reject!\n"));
return NDIS_STATUS_FAILURE;
}
if ( (pHeader[12] != 0x88) || (pHeader[13] != 0x8E) )
{
DBGPRINT(DBG_TX|DBG_WARNING,(L"Still no key and packet type(0x%x 0x%x)is not 802.1x , drop!\n",
pHeader[12],
pHeader[13]));
return NDIS_STATUS_FAILURE;
}
}// if ( (Adapter->EncryptionStatus == Ndis802_11Encryption2KeyAbsent )|| (Adapter->EncryptionStatus == Ndis802_11Encryption3KeyAbsent ) )
if(Adapter->TCloseWZCFlag==WZC_Ignore_Send_EAPOL_START)
{
if ( (Adapter->EncryptionStatus == Ndis802_11Encryption2Enabled )||(Adapter->EncryptionStatus == Ndis802_11Encryption2KeyAbsent )||(Adapter->EncryptionStatus == Ndis802_11Encryption3Enabled )||(Adapter->EncryptionStatus == Ndis802_11Encryption3KeyAbsent ) )
{
pTxNode = &Adapter->TxNode;
NdisQueryPacket(
Packet,
NULL,
&BufferCount,
&pBuffer,
&TotalPacketLength );
if (!pBuffer || !BufferCount || !TotalPacketLength)
{
return NDIS_STATUS_FAILURE;
}
NdisQueryBuffer(pBuffer, &pVirtualAddr, &Length);
pHeader = (PUCHAR)pVirtualAddr;
if ( (pHeader[12] == 0x88) && (pHeader[13] == 0x8E)&& (pHeader[14] == 0x01) &&(pHeader[15] == 0x01) )
{
DBGPRINT(DBG_TX|DBG_HELP,(L"Temporary don't send EAPOL-start!!EncryptionStatus=0x%x, (0x%x, 0x%x, 0x%x, 0x%x)\n",
Adapter->EncryptionStatus,
pHeader[12],
pHeader[13],
pHeader[14],
pHeader[15]));
return NDIS_STATUS_SUCCESS;
}
}
}
EnterCriticalSection(&Adapter->TxCriticalSection);
if(Adapter->TxPacketCount >= (MAX_TX_PACKETS-1) )
{
UCHAR sts;
//DBGPRINT(DBG_ERROR,(L"Tx queue is still full (count=%d), return FAILURE for this packet\r\n",Adapter->TxPacketCount));
sts = TxPacketEnQueue(Adapter, Packet);
if( sts == TRUE ) //101607
{
Adapter->TxPacketCount++;
LeaveCriticalSection(&Adapter->TxCriticalSection);
return NDIS_STATUS_SUCCESS;
}
else if ( sts == EQ_REPLACE_QUEUE )
{
LeaveCriticalSection(&Adapter->TxCriticalSection);
DBGPRINT(DBG_ERROR,(L"Replace a queued packet:%d\n\r",Adapter->TxPacketCount));
return NDIS_STATUS_SUCCESS;
}
else
{
LeaveCriticalSection(&Adapter->TxCriticalSection);
//NdisMSleep(2000);
DBGPRINT(DBG_ERROR,(L"Throw out current packet:%d\n\r",Adapter->TxPacketCount));
//return success otherwise the endpoint may retransmit this packet that low down the throughput.
return NDIS_STATUS_SUCCESS;
}
}
//record how many tx pkt is sent.
Adapter->TxPacketSend++;
DBGPRINT(DBG_TX|DBG_HELP,(L"[Marvell:MrvDrvSend] Adapter->TxPacketSend=%d\n", Adapter->TxPacketSend));
if ( TxPacketEnQueue(Adapter, Packet) != TRUE)
{
LeaveCriticalSection(&Adapter->TxCriticalSection);
return NDIS_STATUS_SUCCESS;
}
Adapter->TxPacketCount++;
LeaveCriticalSection(&Adapter->TxCriticalSection);
if ( Adapter->SentPacket == NULL && Adapter->TxLock == 0 )
{
// Fire TxThread!
Adapter->SoftIntStatus |= MRVL_SOFT_INT_TxRequest;
SetEvent(Adapter->hControllerInterruptEvent);
}
return NDIS_STATUS_SUCCESS;
return Status;
}
NDIS_STATUS
PtRegisterDevice(
VOID
)
/*++
Routine Description:
Register an ioctl interface - a device object to be used for this
purpose is created by NDIS when we call NdisMRegisterDevice.
This routine is called whenever a new miniport instance is
initialized. However, we only create one global device object,
when the first miniport instance is initialized. This routine
handles potential race conditions with PtDeregisterDevice via
the ControlDeviceState and MiniportCount variables.
NOTE: do not call this from DriverEntry; it will prevent the driver
from being unloaded (e.g. on uninstall).
Arguments:
None
Return Value:
NDIS_STATUS_SUCCESS if we successfully register a device object.
--*/
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
UNICODE_STRING DeviceName;
UNICODE_STRING DeviceLinkUnicodeString;
PDRIVER_DISPATCH DispatchTable[IRP_MJ_MAXIMUM_FUNCTION+1];
DBGPRINT(("==>PtRegisterDevice\n"));
NdisAcquireSpinLock(&GlobalLock);
++MiniportCount;
if (1 == MiniportCount)
{
ASSERT(ControlDeviceState != PS_DEVICE_STATE_CREATING);
//
// Another thread could be running PtDeregisterDevice on
// behalf of another miniport instance. If so, wait for
// it to exit.
//
while (ControlDeviceState != PS_DEVICE_STATE_READY)
{
NdisReleaseSpinLock(&GlobalLock);
NdisMSleep(1);
NdisAcquireSpinLock(&GlobalLock);
}
ControlDeviceState = PS_DEVICE_STATE_CREATING;
NdisReleaseSpinLock(&GlobalLock);
NdisZeroMemory(DispatchTable, (IRP_MJ_MAXIMUM_FUNCTION+1) * sizeof(PDRIVER_DISPATCH));
DispatchTable[IRP_MJ_CREATE] = NdisProtOpen;
DispatchTable[IRP_MJ_CLEANUP] = NdisProtCleanup;
DispatchTable[IRP_MJ_CLOSE] = NdisProtClose;
// DispatchTable[IRP_MJ_READ] = NdisProtRead;
DispatchTable[IRP_MJ_READ] = divert_read;
// DispatchTable[IRP_MJ_WRITE] = PtDispatch;
DispatchTable[IRP_MJ_WRITE] = divert_write;
// DispatchTable[IRP_MJ_DEVICE_CONTROL] = NdisProtIoControl;
DispatchTable[IRP_MJ_DEVICE_CONTROL] = PtDispatch;
NdisInitUnicodeString(&DeviceName, NTDEVICE_STRING);
NdisInitUnicodeString(&DeviceLinkUnicodeString, LINKNAME_STRING);
//
// Create a device object and register our dispatch handlers
//
Status = NdisMRegisterDevice(
NdisWrapperHandle,
&DeviceName,
&DeviceLinkUnicodeString,
&DispatchTable[0],
&ControlDeviceObject,
&NdisDeviceHandle
);
ControlDeviceObject->Flags |= DO_DIRECT_IO;
NdisAcquireSpinLock(&GlobalLock);
ControlDeviceState = PS_DEVICE_STATE_READY;
}
NdisReleaseSpinLock(&GlobalLock);
DBGPRINT(("<==PtRegisterDevice: %x\n", Status));
return (Status);
}
NDIS_STATUS
natpPnPNetEventSetPower(
IN PFILTER_ADAPTER pAdapt,
IN PNET_PNP_EVENT pNetPnPEvent
)
{
PNDIS_DEVICE_POWER_STATE pDeviceState =(PNDIS_DEVICE_POWER_STATE)(pNetPnPEvent->Buffer);
NDIS_DEVICE_POWER_STATE PrevDeviceState = pAdapt->natpDeviceState;
NDIS_STATUS Status;
NDIS_STATUS ReturnStatus;
ReturnStatus = NDIS_STATUS_SUCCESS;
NdisAcquireSpinLock(&pAdapt->Lock);
pAdapt->natpDeviceState = *pDeviceState;
if (pAdapt->natpDeviceState > NdisDeviceStateD0){
if (PrevDeviceState == NdisDeviceStateD0)
pAdapt->StandingBy = TRUE;
NdisReleaseSpinLock(&pAdapt->Lock);
while (pAdapt->SendPending != 0)
NdisMSleep(2);
while (pAdapt->OutstandingRequests == TRUE)
NdisMSleep(2);
while (pAdapt->LocalOutstandingRequests == TRUE)
NdisMSleep(2);
NdisAcquireSpinLock(&pAdapt->Lock);
if (pAdapt->QueuedRequest){
pAdapt->QueuedRequest = FALSE;
NdisReleaseSpinLock(&pAdapt->Lock);
natpRequestComplete(pAdapt, &pAdapt->IntReq.NdisRequest, NDIS_STATUS_FAILURE);
}else{
NdisReleaseSpinLock(&pAdapt->Lock);
}
}else{
if (PrevDeviceState > NdisDeviceStateD0)
pAdapt->StandingBy = FALSE;
if (pAdapt->QueuedRequest == TRUE){
pAdapt->QueuedRequest = FALSE;
pAdapt->OutstandingRequests = TRUE;
NdisReleaseSpinLock(&pAdapt->Lock);
NdisRequest(
&Status,
pAdapt->BindingHandle,
&pAdapt->IntReq.NdisRequest
);
if (Status != NDIS_STATUS_PENDING){
natpRequestComplete(
pAdapt,
&pAdapt->IntReq.NdisRequest,
Status
);
}
}else{
NdisReleaseSpinLock(&pAdapt->Lock);
}
}
return ReturnStatus;
}
NDIS_STATUS
ProtocolRegisterDevice(
VOID
)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
UNICODE_STRING DeviceName;
UNICODE_STRING DeviceLinkUnicodeString;
PDRIVER_DISPATCH DispatchTable[IRP_MJ_MAXIMUM_FUNCTION+1];
NdisAcquireSpinLock(&GlobalLock);
++MiniportCount;
if (1 == MiniportCount)
{
ASSERT(ControlDeviceState != PS_DEVICE_STATE_CREATING);
//
// Another thread could be running PtDeregisterDevice on
// behalf of another miniport instance. If so, wait for
// it to exit.
//
while (ControlDeviceState != PS_DEVICE_STATE_READY)
{
NdisReleaseSpinLock(&GlobalLock);
NdisMSleep(1);
NdisAcquireSpinLock(&GlobalLock);
}
ControlDeviceState = PS_DEVICE_STATE_CREATING;
NdisReleaseSpinLock(&GlobalLock);
NdisZeroMemory(DispatchTable, (IRP_MJ_MAXIMUM_FUNCTION+1) * sizeof(PDRIVER_DISPATCH));
DispatchTable[IRP_MJ_CREATE] = DispatchCreate;
DispatchTable[IRP_MJ_CLOSE] = DispatchClose;
DispatchTable[IRP_MJ_DEVICE_CONTROL] = DispatchIoCtrl;
DispatchTable[IRP_MJ_WRITE] = DispatchWrite;
NdisInitUnicodeString(&DeviceName, NTDEVICE_STRING);
NdisInitUnicodeString(&DeviceLinkUnicodeString, LINKNAME_STRING);
//
// Create a device object and register our dispatch handlers
//
Status = NdisMRegisterDevice(
NdisWrapperHandle,
&DeviceName,
&DeviceLinkUnicodeString,
&DispatchTable[0],
&ControlDeviceObject,
&NdisDeviceHandle
);
NdisAcquireSpinLock(&GlobalLock);
ControlDeviceObject->Flags |= DO_BUFFERED_IO;
ControlDeviceState = PS_DEVICE_STATE_READY;
}
NdisReleaseSpinLock(&GlobalLock);
return (Status);
}
NDIS_STATUS
PtPnPNetEventSetPower(
IN PADAPT pAdapt,
IN PNET_PNP_EVENT pNetPnPEvent
)
/*++
Routine Description:
This is a notification to our protocol edge of the power state
of the lower miniport. If it is going to a low-power state, we must
wait here for all outstanding sends and requests to complete.
NDIS 5.1: Since we use packet stacking, it is not sufficient to
check usage of our local send packet pool to detect whether or not
all outstanding sends have completed. For this, use the new API
NdisQueryPendingIOCount.
NDIS 5.1: Use the 5.1 API NdisIMNotifyPnPEvent to pass on PnP
notifications to upper protocol(s).
Arguments:
pAdapt - Pointer to the adpater structure
pNetPnPEvent - The Net Pnp Event. this contains the new device state
Return Value:
NDIS_STATUS_SUCCESS or the status returned by upper-layer protocols.
--*/
{
PNDIS_DEVICE_POWER_STATE pDeviceState =(PNDIS_DEVICE_POWER_STATE)(pNetPnPEvent->Buffer);
NDIS_DEVICE_POWER_STATE PrevDeviceState = pAdapt->PTDeviceState;
NDIS_STATUS Status;
NDIS_STATUS ReturnStatus;
#ifdef NDIS51
ULONG PendingIoCount = 0;
#endif // NDIS51
ReturnStatus = NDIS_STATUS_SUCCESS;
//
// Set the Internal Device State, this blocks all new sends or receives
//
pAdapt->PTDeviceState = *pDeviceState;
//
// Check if the miniport below is going to a low power state.
//
if (*pDeviceState > NdisDeviceStateD0)
{
#ifdef NDIS51
//
// Notify upper layer protocol(s) first.
//
if (pAdapt->MiniportHandle != NULL)
{
ReturnStatus = NdisIMNotifyPnPEvent(pAdapt->MiniportHandle, pNetPnPEvent);
}
#endif // NDIS51
//
// If the miniport below is going to standby, fail all incoming requests
//
if (PrevDeviceState == NdisDeviceStateD0)
{
pAdapt->StandingBy = TRUE;
}
//
// Wait for outstanding sends and requests to complete.
//
#ifdef NDIS51
do
{
Status = NdisQueryPendingIOCount(pAdapt->BindingHandle, &PendingIoCount);
if ((Status != NDIS_STATUS_SUCCESS) ||
(PendingIoCount == 0))
{
break;
}
NdisMSleep(2);
}
while (TRUE);
#else
while (NdisPacketPoolUsage(pAdapt->SendPacketPoolHandle) != 0)
{
NdisMSleep(2);
}
while (pAdapt->OutstandingRequests == TRUE)
{
//
// sleep till outstanding requests complete
//
NdisMSleep(2);
}
#endif // NDIS51
ASSERT(NdisPacketPoolUsage(pAdapt->SendPacketPoolHandle) == 0);
ASSERT(pAdapt->OutstandingRequests == FALSE);
}
else
{
//
// The device below is being turned on. If we had a request
// pending, send it down now.
//
if (pAdapt->QueuedRequest == TRUE)
{
pAdapt->QueuedRequest = FALSE;
NdisRequest(&Status,
pAdapt->BindingHandle,
&pAdapt->Request);
if (Status != NDIS_STATUS_PENDING)
{
PtRequestComplete(pAdapt,
&pAdapt->Request,
Status);
}
}
//
// If the physical miniport is powering up (from Low power state to D0),
// clear the flag
//
if (PrevDeviceState > NdisDeviceStateD0)
{
pAdapt->StandingBy = FALSE;
}
#ifdef NDIS51
//
// Pass on this notification to protocol(s) above
//
if (pAdapt->MiniportHandle)
{
ReturnStatus = NdisIMNotifyPnPEvent(pAdapt->MiniportHandle, pNetPnPEvent);
}
#endif // NDIS51
}
return ReturnStatus;
}
