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; }