static int async_task(void *param)
{
HIF_DEVICE *device;
BUS_REQUEST *request;
A_STATUS status;
static int rw_cnt = 0;
device = (HIF_DEVICE *)param;
while(!device->async_shutdown)
{
/* wait for work */
NdisWaitEvent(&device->sem_async, 0);
NdisResetEvent(&device->sem_async);
if (device->async_shutdown) {
NDIS_DEBUG_PRINTF(DBG_TRACE, "AR6000: async task stopping\n");
break;
}
/* pull the request to work on */
while (device->asyncreq != NULL)
{
request = device->asyncreq;
if (request->inusenext != NULL)
device->asyncreq = request->inusenext;
else
device->asyncreq = NULL;
/* call HIFReadWrite in sync mode to do the work */
NDIS_DEBUG_PRINTF(DBG_TRACE, "AR6000: async_task processing req: 0x%X \r\n", (unsigned int)request);
rw_cnt++;
if(rw_cnt > 1)
NDIS_DEBUG_PRINTF(DBG_ERR, "%s() : two time call !!!!! \r\n", __FUNCTION__);
status = __HIFReadWrite(device, request->address, request->buffer,
request->length, request->request & ~HIF_SYNCHRONOUS, NULL);
rw_cnt --;
if (request->request & HIF_ASYNCHRONOUS)
{
NDIS_DEBUG_PRINTF(DBG_TRACE, "AR6000: async_task completion routine req: 0x%X\n", (unsigned int)request);
device->htcCallbacks.rwCompletionHandler(request->context, status);
NDIS_DEBUG_PRINTF(DBG_TRACE, "AR6000: async_task freeing req: 0x%X\n", (unsigned int)request);
hifFreeBusRequest(device, request);
}
else
{
NDIS_DEBUG_PRINTF(DBG_TRACE, "AR6000: async_task upping req: 0x%X\n", (unsigned int)request);
request->status = status;
NdisSetEvent(&request->sem_req);
}
}
}
return 0;
}
void IoDecrement(OPEN_INSTANCE *pOpen)
{
if(InterlockedDecrement((PLONG)&pOpen->nIrpCount) == 0)
NdisSetEvent(&pOpen->CleanupEvent);
}
VOID
tapCompleteIrpAndFreeReceiveNetBufferList(
__in PTAP_ADAPTER_CONTEXT Adapter,
__in PNET_BUFFER_LIST NetBufferList, // Only one NB here...
__in NTSTATUS IoCompletionStatus
)
{
PIRP irp;
ULONG frameType, netBufferCount, byteCount;
LONG nblCount;
// Fetch NB frame type.
frameType = tapGetNetBufferFrameType(NET_BUFFER_LIST_FIRST_NB(NetBufferList));
// Fetch statistics for all NBs linked to the NB.
netBufferCount = tapGetNetBufferCountsFromNetBufferList(
NetBufferList,
&byteCount
);
// Update statistics by frame type
if(IoCompletionStatus == STATUS_SUCCESS)
{
switch(frameType)
{
case NDIS_PACKET_TYPE_DIRECTED:
Adapter->FramesRxDirected += netBufferCount;
Adapter->BytesRxDirected += byteCount;
break;
case NDIS_PACKET_TYPE_BROADCAST:
Adapter->FramesRxBroadcast += netBufferCount;
Adapter->BytesRxBroadcast += byteCount;
break;
case NDIS_PACKET_TYPE_MULTICAST:
Adapter->FramesRxMulticast += netBufferCount;
Adapter->BytesRxMulticast += byteCount;
break;
default:
ASSERT(FALSE);
break;
}
}
//
// Handle P2P Packet
// -----------------
// Free MDL allocated for P2P Ethernet header.
//
if(TAP_RX_NBL_FLAG_TEST(NetBufferList,TAP_RX_NBL_FLAGS_IS_P2P))
{
PNET_BUFFER netBuffer;
PMDL mdl;
netBuffer = NET_BUFFER_LIST_FIRST_NB(NetBufferList);
mdl = NET_BUFFER_FIRST_MDL(netBuffer);
mdl->Next = NULL;
NdisFreeMdl(mdl);
}
//
// Handle Injected Packet
// -----------------------
// Free MDL and data buffer allocated for injected packet.
//
if(TAP_RX_NBL_FLAG_TEST(NetBufferList,TAP_RX_NBL_FLAGS_IS_INJECTED))
{
PNET_BUFFER netBuffer;
PMDL mdl;
PUCHAR injectBuffer;
netBuffer = NET_BUFFER_LIST_FIRST_NB(NetBufferList);
mdl = NET_BUFFER_FIRST_MDL(netBuffer);
injectBuffer = (PUCHAR )MmGetSystemAddressForMdlSafe(mdl,NormalPagePriority);
if(injectBuffer)
{
NdisFreeMemory(injectBuffer,0,0);
}
NdisFreeMdl(mdl);
}
//
// Complete the IRP
//
irp = (PIRP )NetBufferList->MiniportReserved[0];
if(irp)
{
irp->IoStatus.Status = IoCompletionStatus;
IoCompleteRequest(irp, IO_NO_INCREMENT);
}
// Decrement in-flight receive NBL count.
nblCount = NdisInterlockedDecrement(&Adapter->ReceiveNblInFlightCount);
ASSERT(nblCount >= 0 );
if (0 == nblCount)
{
NdisSetEvent(&Adapter->ReceiveNblInFlightCountZeroEvent);
}
// Free the NBL
NdisFreeNetBufferList(NetBufferList);
}
A_STATUS
HIFReadWrite(HIF_DEVICE *device,
A_UINT32 address,
A_UCHAR *buffer,
A_UINT32 length,
A_UINT32 request,
void *context)
{
A_STATUS status = A_OK;
//unsigned long flags;
BUS_REQUEST *busrequest;
BUS_REQUEST *async;
BUS_REQUEST *active;
AR_DEBUG_ASSERT(device != NULL);
do
{
if ((request & HIF_ASYNCHRONOUS) || (request & HIF_SYNCHRONOUS))
{
/* serialize all requests through the async thread */
NDIS_DEBUG_PRINTF(DBG_TRACE, "AR6000: Execution mode: %s\n", (request & HIF_ASYNCHRONOUS) ?"Async":"Synch");
busrequest = hifAllocateBusRequest(device);
if (busrequest == NULL) {
NDIS_DEBUG_PRINTF(DBG_ERR, "AR6000: no async bus requests available\n");
return A_ERROR;
}
Hif_Lock();
busrequest->address = address;
busrequest->buffer = buffer;
busrequest->length = length;
busrequest->request = request;
busrequest->context = context;
//NDIS_DEBUG_PRINTF(1, " add = %x, length = %x, request = %d \r\n", address, length, request);
/* add to async list */
active = device->asyncreq;
if (active == NULL)
{
device->asyncreq = busrequest;
device->asyncreq->inusenext = NULL;
}
else
{
for (async = device->asyncreq; async != NULL; async = async->inusenext) {
active = async;
}
active->inusenext = busrequest;
busrequest->inusenext = NULL;
}
Hif_Unlock();
if (request & HIF_SYNCHRONOUS)
{
NdisSetEvent(&device->sem_async);
/* Wait Read/Write Complete from the async_task */
if( ! NdisWaitEvent(&busrequest->sem_req, HIF_SYNCHRONOUS_WAIT_TIME)) {
NDIS_DEBUG_PRINTF(DBG_ERR, " HIF Synchronous Read/Write Time Out !! \r\n");
NdisResetEvent(&busrequest->sem_req);
return A_ERROR;
}
NdisResetEvent(&busrequest->sem_req);
hifFreeBusRequest(device, busrequest);
if(busrequest->status != A_OK)
NDIS_DEBUG_PRINTF(DBG_ERR, "%s() Read/Write Err \r\n", __FUNCTION__);
return busrequest->status;
}
else
{
NdisSetEvent(&device->sem_async);
return A_PENDING;
}
}
else
{
NDIS_DEBUG_PRINTF(DBG_ERR, "AR6000: Invalid execution mode: 0x%08x\n", (unsigned int)request);
status = A_EINVAL;
break;
}
}while(0);
NDIS_DEBUG_PRINTF(0, "%s() : - Exit \r\n",__FUNCTION__);
return status;
}
/**********************************************************
callback from asynchronous RECEIVE PAUSE on reset
***********************************************************/
static void OnReceivePauseCompleteOnReset(PARANDIS_ADAPTER *pContext)
{
DEBUG_ENTRY(0);
NdisSetEvent(&pContext->ResetEvent);
}
NDIS_STATUS
MiniportInitialize5(
OUT PNDIS_STATUS OpenErrorStatus,
OUT PUINT SelectedMediumIndex,
IN PNDIS_MEDIUM MediumArray,
IN UINT MediumArraySize,
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE WrapperConfigurationContext
)
{
UINT i;
PADAPTER pAdapt;
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
NDIS_MEDIUM Medium;
UNREFERENCED_PARAMETER(WrapperConfigurationContext);
do
{
pAdapt = NdisIMGetDeviceContext(MiniportAdapterHandle);
pAdapt->MiniportHandle = MiniportAdapterHandle;
Medium = pAdapt->Medium;
if (Medium == NdisMediumWan)
{
Medium = NdisMedium802_3;
pAdapt->bWanAdapter = TRUE;
}
for (i = 0; i < MediumArraySize; i++)
{
if (MediumArray[i] == Medium)
{
*SelectedMediumIndex = i;
break;
}
}
if (i == MediumArraySize)
{
Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
break;
}
NdisMSetAttributesEx(MiniportAdapterHandle,
pAdapt,
0, // CheckForHangTimeInSeconds
NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT |
NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT|
NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER |
NDIS_ATTRIBUTE_DESERIALIZE |
NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND,
0);
pAdapt->LastIndicatedStatus = NDIS_STATUS_MEDIA_CONNECT;
pAdapt->MiniportDeviceState = NdisDeviceStateD0;
//
// Create an ioctl interface
//
(VOID)ProtocolRegisterDevice();
Status = NDIS_STATUS_SUCCESS;
}
while (FALSE);
ASSERT(pAdapt->MiniportInitPending == TRUE);
pAdapt->MiniportInitPending = FALSE;
NdisSetEvent(&pAdapt->MiniportInitEvent);
*OpenErrorStatus = Status;
return Status;
}
/*************************************************************
Callback of delayed send pause procedure
*************************************************************/
static VOID OnSendStopped(VOID *p)
{
PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)p;
DEBUG_ENTRY(0);
NdisSetEvent(&pContext->HaltEvent);
}
NDIS_STATUS
MPInitialize(
OUT PNDIS_STATUS OpenErrorStatus,
OUT PUINT SelectedMediumIndex,
IN PNDIS_MEDIUM MediumArray,
IN UINT MediumArraySize,
IN NDIS_HANDLE MiniportAdapterHandle,
IN NDIS_HANDLE WrapperConfigurationContext
)
/*++
Routine Description:
This is the initialize handler which gets called as a result of
the BindAdapter handler calling NdisIMInitializeDeviceInstanceEx.
The context parameter which we pass there is the adapter structure
which we retrieve here.
Arguments:
OpenErrorStatus Not used by us.
SelectedMediumIndex Place-holder for what media we are using
MediumArray Array of ndis media passed down to us to pick from
MediumArraySize Size of the array
MiniportAdapterHandle The handle NDIS uses to refer to us
WrapperConfigurationContext For use by NdisOpenConfiguration
Return Value:
NDIS_STATUS_SUCCESS unless something goes wrong
--*/
{
UINT i;
PADAPT pAdapt;
NDIS_STATUS Status = NDIS_STATUS_FAILURE;
NDIS_MEDIUM Medium;
UNREFERENCED_PARAMETER(WrapperConfigurationContext);
do
{
//
// Start off by retrieving our adapter context and storing
// the Miniport handle in it.
//
pAdapt = NdisIMGetDeviceContext(MiniportAdapterHandle);
pAdapt->MiniportHandle = MiniportAdapterHandle;
DBGPRINT(("==> Miniport Initialize: Adapt %p\n", pAdapt));
//
// Usually we export the medium type of the adapter below as our
// virtual miniport's medium type. However if the adapter below us
// is a WAN device, then we claim to be of medium type 802.3.
//
Medium = pAdapt->Medium;
if (Medium == NdisMediumWan)
{
Medium = NdisMedium802_3;
}
for (i = 0; i < MediumArraySize; i++)
{
if (MediumArray[i] == Medium)
{
*SelectedMediumIndex = i;
break;
}
}
if (i == MediumArraySize)
{
Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
break;
}
//
// Set the attributes now. NDIS_ATTRIBUTE_DESERIALIZE enables us
// to make up-calls to NDIS without having to call NdisIMSwitchToMiniport
// or NdisIMQueueCallBack. This also forces us to protect our data using
// spinlocks where appropriate. Also in this case NDIS does not queue
// packets on our behalf. Since this is a very simple pass-thru
// miniport, we do not have a need to protect anything. However in
// a general case there will be a need to use per-adapter spin-locks
// for the packet queues at the very least.
//
NdisMSetAttributesEx(MiniportAdapterHandle,
pAdapt,
0, // CheckForHangTimeInSeconds
NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT |
NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT|
NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER |
NDIS_ATTRIBUTE_DESERIALIZE |
NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND,
0);
//
// Initialize LastIndicatedStatus to be NDIS_STATUS_MEDIA_CONNECT
//
pAdapt->LastIndicatedStatus = NDIS_STATUS_MEDIA_CONNECT;
//
// Initialize the power states for both the lower binding (PTDeviceState)
// and our miniport edge to Powered On.
//
pAdapt->MPDeviceState = NdisDeviceStateD0;
pAdapt->PTDeviceState = NdisDeviceStateD0;
//
// Add this adapter to the global pAdapt List
//
NdisAcquireSpinLock(&GlobalLock);
pAdapt->Next = pAdaptList;
pAdaptList = pAdapt;
NdisReleaseSpinLock(&GlobalLock);
//
// Create an ioctl interface
//
(VOID)PtRegisterDevice();
Status = NDIS_STATUS_SUCCESS;
}
while (FALSE);
//
// If we had received an UnbindAdapter notification on the underlying
// adapter, we would have blocked that thread waiting for the IM Init
// process to complete. Wake up any such thread.
//
ASSERT(pAdapt->MiniportInitPending == TRUE);
pAdapt->MiniportInitPending = FALSE;
NdisSetEvent(&pAdapt->MiniportInitEvent);
DBGPRINT(("<== Miniport Initialize: Adapt %p, Status %x\n", pAdapt, Status));
*OpenErrorStatus = Status;
return Status;
}
/**********************************************************
callback from asynchronous RECEIVE PAUSE on reset
***********************************************************/
static void OnReceivePauseCompleteOnReset(void *ctx)
{
DEBUG_ENTRY(0);
PPARANDIS_ADAPTER pContext = (PPARANDIS_ADAPTER) ctx;
NdisSetEvent(&pContext->ResetEvent);
}
/*************************************************************
Callback of delayed send pause procedure upon reset request
*************************************************************/
static void OnSendStoppedOnReset(VOID *p)
{
PARANDIS_ADAPTER *pContext = (PARANDIS_ADAPTER *)p;
DEBUG_ENTRY(0);
NdisSetEvent(&pContext->ResetEvent);
}
void
shared_dpc_schedule(shared_info_t *sh)
{
NdisSetEvent(&sh->dpc_event);
}
VOID
SxpNdisCompleteInternalOidRequest(
_In_ PSX_SWITCH_OBJECT Switch,
_In_ PNDIS_OID_REQUEST NdisRequest,
_In_ NDIS_STATUS Status
)
/*++
Routine Description:
NDIS entry point indicating completion of a pended NDIS_OID_REQUEST.
Arguments:
Switch - pointer to switch object.
NdisRequest - pointer to NDIS request
Status - Status of request completion
Return Value:
None
--*/
{
PSX_OID_REQUEST oidRequest;
ULONG bytesNeeded;
UNREFERENCED_PARAMETER(Switch);
bytesNeeded = 0;
oidRequest = NULL;
switch (NdisRequest->RequestType)
{
case NdisRequestSetInformation:
bytesNeeded = NdisRequest->DATA.SET_INFORMATION.BytesNeeded;
break;
case NdisRequestQueryInformation:
bytesNeeded = NdisRequest->DATA.QUERY_INFORMATION.BytesNeeded;
break;
case NdisRequestMethod:
bytesNeeded = NdisRequest->DATA.METHOD_INFORMATION.BytesNeeded;
break;
}
//
// Get at the request context.
//
oidRequest = CONTAINING_RECORD(NdisRequest, SX_OID_REQUEST, NdisOidRequest);
//
// Save away the completion status.
//
oidRequest->Status = Status;
//
// Save bytesNeeded
//
oidRequest->BytesNeeded = bytesNeeded;
//
// Wake up the thread blocked for this request to complete.
//
NdisSetEvent(&oidRequest->ReqEvent);
}
void
CAR6KMini::WMIWowListEvent(
WMI_GET_WOW_LIST_REPLY *wowList)
{
/* Alocate for the global ptr, copy data & post wowListReplyGot event. The function that
* calls wmi_get_wow_list should free this.
*/
/* if there are no filters, allocate for WMI_GET_WOW_LIST_REPLY & copy, set event & return
*/
if(m_networkType == AP_NETWORK)
{
return;
}
if ( wowList->num_filters == 0) {
m_WowListReply = (WMI_GET_WOW_LIST_REPLY *) A_MALLOC(sizeof(WMI_GET_WOW_LIST_REPLY));
if (!m_WowListReply) {
NdisSetEvent(&m_tgtWowListReplyEvent);
return;
}
A_MEMZERO((A_UINT8 *)m_WowListReply, sizeof(WMI_GET_WOW_LIST_REPLY));
A_MEMCPY((A_UINT8 *)m_WowListReply, (A_UINT8 *) wowList, sizeof(WMI_GET_WOW_LIST_REPLY));
NdisSetEvent(&m_tgtWowListReplyEvent);
return;
}
if ( wowList->this_filter_num == 1 ) {
if ( wowList->num_filters > 1) {
m_WowListReply = (WMI_GET_WOW_LIST_REPLY *) A_MALLOC(sizeof(WMI_GET_WOW_LIST_REPLY) + sizeof(WOW_FILTER) * (wowList->num_filters-1));
if (!m_WowListReply) {
NdisSetEvent(&m_tgtWowListReplyEvent);
return;
}
A_MEMZERO((A_UINT8 *)m_WowListReply, sizeof(WMI_GET_WOW_LIST_REPLY) + sizeof(WOW_FILTER) * (wowList->num_filters-1));
} else {
m_WowListReply = (WMI_GET_WOW_LIST_REPLY *) A_MALLOC(sizeof(WMI_GET_WOW_LIST_REPLY));
if (!m_WowListReply) {
NdisSetEvent(&m_tgtWowListReplyEvent);
return;
}
A_MEMZERO((A_UINT8 *)m_WowListReply,sizeof(WMI_GET_WOW_LIST_REPLY));
}
A_MEMCPY((A_UINT8 *)m_WowListReply, (A_UINT8 *) wowList, sizeof(WMI_GET_WOW_LIST_REPLY));
} else { // 2nd filter onwards
A_MEMCPY((A_UINT8 *)m_WowListReply+sizeof(WMI_GET_WOW_LIST_REPLY)+(wowList->this_filter_num-2) *sizeof(WOW_FILTER), (A_UINT8 *) wowList->wow_filters, sizeof(WOW_FILTER));
} //endif
// Set the event only after we get all the filter events.
if ( wowList->this_filter_num == wowList->num_filters ) {
NdisSetEvent(&m_tgtWowListReplyEvent);
}
return;
}
void
CAR6KMini::WMITargetStatsEvent(
WMI_TARGET_STATS *pTargetStats)
{
if(m_networkType == AP_NETWORK)
{
return;
}
int ac = 0;
// Update the RSSI for now.
if (m_Connected) {
bss_t *pWmiNode = NULL;
pWmiNode = wmi_find_node((wmi_t *)m_pWMI,m_PeerBSSID);
if (pWmiNode)
{
pWmiNode->ni_rssi = pTargetStats->cservStats.cs_aveBeacon_rssi;
wmi_node_return((wmi_t *)m_pWMI, pWmiNode);
}
m_RSSI = pTargetStats->cservStats.cs_aveBeacon_rssi;
//
// Check whether the current mode is adhoc mode (in case of single node Target returns
// -95 or -96 RSSI values) since there is no specific event from
// taregt to indicate whenever joiner is available,
// host has to check below condition in order to avoid
// null RSSI
//
if ((Ndis802_11IBSS == m_InfrastructureMode) && (RSSI_TO_ABS(m_RSSI) <= 0))
{
m_RSSI = 0; // Max RSSI value
}
}
// Update other target Stats.
if (pTargetStats->txrxStats.tx_stats.tx_packets > pTargetStats->txrxStats.tx_stats.tx_failed_cnt)
{
m_tgtStats.TransmittedFragmentCount.QuadPart += (pTargetStats->txrxStats.tx_stats.tx_packets -
pTargetStats->txrxStats.tx_stats.tx_failed_cnt);
}
else
{
m_tgtStats.TransmittedFragmentCount.QuadPart += 0;
}
m_tgtStats.MulticastTransmittedFrameCount.QuadPart += (pTargetStats->txrxStats.tx_stats.tx_multicast_pkts + \
pTargetStats->txrxStats.tx_stats.tx_broadcast_pkts);
m_tgtStats.FailedCount.QuadPart += pTargetStats->txrxStats.tx_stats.tx_retry_cnt;
m_tgtStats.RetryCount.QuadPart += pTargetStats->txrxStats.tx_stats.tx_mult_retry_cnt;
m_tgtStats.MultipleRetryCount.QuadPart += pTargetStats->txrxStats.tx_stats.tx_mult_retry_cnt;
m_tgtStats.RTSSuccessCount.QuadPart += pTargetStats->txrxStats.tx_stats.tx_rts_success_cnt;
m_tgtStats.RTSFailureCount.QuadPart += pTargetStats->txrxStats.tx_stats.tx_rts_fail_cnt;
m_tgtStats.FrameDuplicateCount.QuadPart += pTargetStats->txrxStats.rx_stats.rx_duplicate_frames;
m_tgtStats.ReceivedFragmentCount.QuadPart += pTargetStats->txrxStats.rx_stats.rx_packets;
m_tgtStats.MulticastReceivedFrameCount.QuadPart += (pTargetStats->txrxStats.rx_stats.rx_multicast_pkts + \
pTargetStats->txrxStats.rx_stats.rx_broadcast_pkts);
m_tgtStats.FCSErrorCount.QuadPart += pTargetStats->txrxStats.rx_stats.rx_crcerr;
m_txRate = wmi_get_rate (pTargetStats->txrxStats.tx_stats.tx_unicast_rate);
m_rxRate = wmi_get_rate (pTargetStats->txrxStats.rx_stats.rx_unicast_rate);
#ifdef OS_ROAM_MANAGEMENT
m_RateInfo.TxRateFiltered = m_txRate;
m_RateInfo.RxRateFiltered = m_rxRate;
m_RateInfo.TxDataFrames += pTargetStats->txrxStats.tx_stats.tx_unicast_pkts;
m_RateInfo.RxDataFrames += pTargetStats->txrxStats.rx_stats.rx_unicast_pkts;
m_RateInfo.RssiFiltered = RSSI_TO_NDIS(pTargetStats->cservStats.cs_aveBeacon_rssi);
if (m_Connected && (0 == pTargetStats->cservStats.cs_bmiss_cnt))
{
m_RateInfo.LastRssiBeaconTime = A_MS_TICKGET();
}
#endif
/* RX/TX Stats */
m_tgtAllStats.tx_packets += pTargetStats->txrxStats.tx_stats.tx_packets;
m_tgtAllStats.tx_bytes += pTargetStats->txrxStats.tx_stats.tx_bytes;
m_tgtAllStats.tx_unicast_pkts += pTargetStats->txrxStats.tx_stats.tx_unicast_pkts;
m_tgtAllStats.tx_unicast_bytes += pTargetStats->txrxStats.tx_stats.tx_unicast_bytes;
m_tgtAllStats.tx_multicast_pkts += pTargetStats->txrxStats.tx_stats.tx_multicast_pkts;
m_tgtAllStats.tx_multicast_bytes += pTargetStats->txrxStats.tx_stats.tx_multicast_bytes;
m_tgtAllStats.tx_broadcast_pkts += pTargetStats->txrxStats.tx_stats.tx_broadcast_pkts;
m_tgtAllStats.tx_broadcast_bytes += pTargetStats->txrxStats.tx_stats.tx_broadcast_bytes;
m_tgtAllStats.tx_rts_success_cnt += pTargetStats->txrxStats.tx_stats.tx_rts_success_cnt;
for (ac = 0; ac < WMM_NUM_AC; ac++)
m_tgtAllStats.tx_packet_per_ac[ac] += pTargetStats->txrxStats.tx_stats.tx_packet_per_ac[ac];
m_tgtAllStats.tx_errors += pTargetStats->txrxStats.tx_stats.tx_errors;
m_tgtAllStats.tx_failed_cnt += pTargetStats->txrxStats.tx_stats.tx_failed_cnt;
m_tgtAllStats.tx_retry_cnt += pTargetStats->txrxStats.tx_stats.tx_retry_cnt;
m_tgtAllStats.tx_mult_retry_cnt += pTargetStats->txrxStats.tx_stats.tx_mult_retry_cnt;
m_tgtAllStats.tx_rts_fail_cnt += pTargetStats->txrxStats.tx_stats.tx_rts_fail_cnt;
m_tgtAllStats.tx_unicast_rate = wmi_get_rate(pTargetStats->txrxStats.tx_stats.tx_unicast_rate);
m_tgtAllStats.rx_packets += pTargetStats->txrxStats.rx_stats.rx_packets;
m_tgtAllStats.rx_bytes += pTargetStats->txrxStats.rx_stats.rx_bytes;
m_tgtAllStats.rx_unicast_pkts += pTargetStats->txrxStats.rx_stats.rx_unicast_pkts;
m_tgtAllStats.rx_unicast_bytes += pTargetStats->txrxStats.rx_stats.rx_unicast_bytes;
m_tgtAllStats.rx_multicast_pkts += pTargetStats->txrxStats.rx_stats.rx_multicast_pkts;
m_tgtAllStats.rx_multicast_bytes += pTargetStats->txrxStats.rx_stats.rx_multicast_bytes;
m_tgtAllStats.rx_broadcast_pkts += pTargetStats->txrxStats.rx_stats.rx_broadcast_pkts;
m_tgtAllStats.rx_broadcast_bytes += pTargetStats->txrxStats.rx_stats.rx_broadcast_bytes;
m_tgtAllStats.rx_fragment_pkt += pTargetStats->txrxStats.rx_stats.rx_fragment_pkt;
m_tgtAllStats.rx_errors += pTargetStats->txrxStats.rx_stats.rx_errors;
m_tgtAllStats.rx_crcerr += pTargetStats->txrxStats.rx_stats.rx_crcerr;
m_tgtAllStats.rx_key_cache_miss += pTargetStats->txrxStats.rx_stats.rx_key_cache_miss;
m_tgtAllStats.rx_decrypt_err += pTargetStats->txrxStats.rx_stats.rx_decrypt_err;
m_tgtAllStats.rx_duplicate_frames += pTargetStats->txrxStats.rx_stats.rx_duplicate_frames;
m_tgtAllStats.rx_unicast_rate = wmi_get_rate(pTargetStats->txrxStats.rx_stats.rx_unicast_rate);
/* Cserv Stats */
m_tgtAllStats.cs_bmiss_cnt += pTargetStats->cservStats.cs_bmiss_cnt;
m_tgtAllStats.cs_lowRssi_cnt += pTargetStats->cservStats.cs_lowRssi_cnt;
m_tgtAllStats.cs_connect_cnt += pTargetStats->cservStats.cs_connect_cnt;
m_tgtAllStats.cs_disconnect_cnt += pTargetStats->cservStats.cs_disconnect_cnt;
m_tgtAllStats.cs_aveBeacon_snr = pTargetStats->cservStats.cs_aveBeacon_snr;
m_tgtAllStats.cs_aveBeacon_rssi = pTargetStats->cservStats.cs_aveBeacon_rssi;
m_tgtAllStats.cs_lastRoam_msec = pTargetStats->cservStats.cs_lastRoam_msec;
m_tgtAllStats.cs_snr = pTargetStats->cservStats.cs_snr;
m_tgtAllStats.cs_rssi = pTargetStats->cservStats.cs_rssi;
/* WoW Stats */
m_tgtAllStats.wow_num_pkts_dropped += pTargetStats->wowStats.wow_num_pkts_dropped;
m_tgtAllStats.wow_num_host_pkt_wakeups += pTargetStats->wowStats.wow_num_host_pkt_wakeups;
m_tgtAllStats.wow_num_host_event_wakeups += pTargetStats->wowStats.wow_num_host_event_wakeups;
m_tgtAllStats.wow_num_events_discarded += pTargetStats->wowStats.wow_num_events_discarded;
/* TKIP,CCMP Stats */
m_tgtAllStats.tkip_local_mic_failure += pTargetStats->txrxStats.tkipCcmpStats.tkip_local_mic_failure;
m_tgtAllStats.tkip_counter_measures_invoked += pTargetStats->txrxStats.tkipCcmpStats.tkip_counter_measures_invoked;
m_tgtAllStats.tkip_replays += pTargetStats->txrxStats.tkipCcmpStats.tkip_replays;
m_tgtAllStats.tkip_format_errors += pTargetStats->txrxStats.tkipCcmpStats.tkip_format_errors;
m_tgtAllStats.ccmp_format_errors += pTargetStats->txrxStats.tkipCcmpStats.ccmp_format_errors;
m_tgtAllStats.ccmp_replays += pTargetStats->txrxStats.tkipCcmpStats.ccmp_replays;
/* misc stats */
m_tgtAllStats.power_save_failure_cnt += pTargetStats->pmStats.power_save_failure_cnt;
m_tgtAllStats.noise_floor_calibation = pTargetStats->noise_floor_calibation;
m_tgtAllStats.lqVal = pTargetStats->lqVal;
//post targetStats event
NdisSetEvent(&m_tgtStatsEvent);
return;
}
void
CAR6KMini::WMIDisconnectIndication(A_UINT8 reason)
{
#ifdef NO_BCAST_PROBE_IN_CONNECT
wmi_probedSsid_cmd((struct wmi_t *)m_pWMI, 0, ANY_SSID_FLAG, 0,NULL);
#endif
do
{
//
// Ignore pyxis specific reason during IEEE Mode
//
if (m_Connected)
{
if (reason == NO_NETWORK_AVAIL)
{
// remove the current associated bssid node
wmi_free_node ((wmi_t *)m_pWMI, m_PeerBSSID);
//
// In case any other same SSID nodes are present
// remove it, since those nodes also not available now
//
IterateNodeAndRemoveSSID (&m_SSID);
SendWMIDisconnectCommand ();
}
// Flush any pending NDIS packets
FlushNdisPacketTransmitQueue();
#ifdef OS_ROAM_MANAGEMENT
if (FALSE == m_osRoamControl)
{
#endif
m_RSSIlevel = 0;
if (m_Config.hostAssistedRoaming)
{
A_UNTIMEOUT(&m_rssiScanTimer);
}
NdisMIndicateStatus(m_MiniportAdapterHandle, NDIS_STATUS_MEDIA_DISCONNECT, 0, 0);
NdisMIndicateStatusComplete(m_MiniportAdapterHandle);
#ifdef OS_ROAM_MANAGEMENT
}
else
{
A_UNTIMEOUT(&m_disconnectIndicationTimer);
A_TIMEOUT_MS(&m_disconnectIndicationTimer, m_Config.discTimeout*1000, 0);
}
#endif
//
// Reset Chanel and BSSID info
//
m_Connected = FALSE;
m_ChannelHint = 0;
m_ConnectedChannel = 0;
memset (m_PeerBSSID, 0, ETHERNET_MAC_ADDRESS_LENGTH);
}
if (m_bIsSwitchAPtoSTA)
{
m_bIsSwitchAPtoSTA = FALSE;
NdisMIndicateStatus(m_MiniportAdapterHandle, NDIS_STATUS_MEDIA_DISCONNECT, 0, 0);
NdisMIndicateStatusComplete(m_MiniportAdapterHandle);
// configTargetParams();
m_WantToBeConnected = TRUE;
}
{
//
// no need to send WMIConnect when target reply disconnect
// reason other than DISCONNECT_CMD
//
if (DISCONNECT_CMD == reason)
{
m_ConnectInProgress = FALSE;
if (m_WantToBeConnected)
{
SendWMIConnectCommand (&m_SSID);
}
}
}
} while (FALSE);
NdisSetEvent (&m_SuspendEvent);
}
