rt2860v2源码分析三

rt2860_probe

RtmpPhyNetDevInit

PNET_DEV RtmpPhyNetDevInit(
IN VOID                     *pAd,
IN RTMP_OS_NETDEV_OP_HOOK   *pNetDevHook)
{
struct net_device   *net_dev = NULL;
/*  NDIS_STATUS     Status; */
ULONG InfId, OpMode;

RTMP_DRIVER_MAIN_INF_GET(pAd, &InfId);

/*  net_dev = RtmpOSNetDevCreate(pAd, INT_MAIN, 0, sizeof(PRTMP_ADAPTER), INF_MAIN_DEV_NAME); */
RTMP_DRIVER_MAIN_INF_CREATE(pAd, &net_dev);
if (net_dev == NULL)
{
printk("RtmpPhyNetDevInit(): creation failed for main physical net device!\n");
return NULL;
}

NdisZeroMemory((unsigned char *)pNetDevHook, sizeof(RTMP_OS_NETDEV_OP_HOOK));
pNetDevHook->open = MainVirtualIF_open;
pNetDevHook->stop = MainVirtualIF_close;
pNetDevHook->xmit = rt28xx_send_packets;
#ifdef IKANOS_VX_1X0
pNetDevHook->xmit = IKANOS_DataFramesTx;
#endif /* IKANOS_VX_1X0 */
pNetDevHook->ioctl = rt28xx_ioctl;
pNetDevHook->priv_flags = InfId; /*INT_MAIN; */
pNetDevHook->get_stats = RT28xx_get_ether_stats;

pNetDevHook->needProtcted = FALSE;

#if (WIRELESS_EXT < 21) && (WIRELESS_EXT >= 12)
pNetDevHook->get_wstats = rt28xx_get_wireless_stats;
#endif

RTMP_DRIVER_OP_MODE_GET(pAd, &OpMode);

#ifdef CONFIG_STA_SUPPORT
#if WIRELESS_EXT >= 12
if (OpMode == OPMODE_STA)
{
pNetDevHook->iw_handler = (void *)&rt28xx_iw_handler_def;
}
#endif /*WIRELESS_EXT >= 12 */
#endif /* CONFIG_STA_SUPPORT */

#ifdef CONFIG_APSTA_MIXED_SUPPORT
#if WIRELESS_EXT >= 12
if (OpMode == OPMODE_AP)
{
pNetDevHook->iw_handler = &rt28xx_ap_iw_handler_def;
}
#endif /*WIRELESS_EXT >= 12 */
#endif /* CONFIG_APSTA_MIXED_SUPPORT */

/* put private data structure */
RTMP_OS_NETDEV_SET_PRIV(net_dev, pAd);

/* double-check if pAd is associated with the net_dev */
if (RTMP_OS_NETDEV_GET_PRIV(net_dev) == NULL)
{
RtmpOSNetDevFree(net_dev);
return NULL;
}
/*  pAd->net_dev = net_dev; */

RTMP_DRIVER_NET_DEV_SET(pAd, net_dev);

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
SET_MODULE_OWNER(net_dev);
#endif

return net_dev;

}

pNetDevHook

RTMP_OS_NETDEV_OP_HOOK

RtmpOSNetDevAttach

net_device

MainVirtualIF_open

MainVirtualIF_open

/*
========================================================================
Routine Description:
Open raxx interface.

Arguments:
*net_dev            the raxx interface pointer

========================================================================
*/
int MainVirtualIF_open(IN struct net_device *net_dev)
{
VOID *pAd = NULL;

GET_PAD_FROM_NET_DEV(pAd, net_dev);

/* Sanity check for pAd */
if (pAd == NULL)
return 0; /* close ok */

#ifdef CONFIG_AP_SUPPORT
/*  pAd->ApCfg.MBSSID[MAIN_MBSSID].bBcnSntReq = TRUE; */
RTMP_DRIVER_AP_MAIN_OPEN(pAd);
#endif /* CONFIG_AP_SUPPORT */

#ifdef IFUP_IN_PROBE
while (RTMP_DRIVER_IOCTL_SANITY_CHECK(pAd, NULL) != NDIS_STATUS_SUCCESS)
{
OS_WAIT(10);
DBGPRINT(RT_DEBUG_TRACE, ("Card not ready, NDIS_STATUS_SUCCESS!\n"));
}
#else
if (VIRTUAL_IF_UP(pAd) != 0)
return -1;
#endif /* IFUP_IN_PROBE */

/* increase MODULE use count */
RT_MOD_INC_USE_COUNT();

netif_start_queue(net_dev);
netif_carrier_on(net_dev);
netif_wake_queue(net_dev);

return 0;
}

RTMP_DRIVD

RTMP_DRIVER_MAIN_INF_GET

RTMP_DRIVER_MAIN_INF_CREATE

RTMP_COM_IoctlHandle

RTMP_COM_IoctlHandle

INT RTMP_COM_IoctlHandle(
IN  VOID                    *pAdSrc,
IN  RTMP_IOCTL_INPUT_STRUCT *wrq,
IN  INT                     cmd,
IN  USHORT                  subcmd,
IN  VOID                    *pData,
IN  ULONG                   Data)
{
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)pAdSrc;
POS_COOKIE pObj = (POS_COOKIE)pAd->OS_Cookie;
INT Status = NDIS_STATUS_SUCCESS, i;
UCHAR PermanentAddress[MAC_ADDR_LEN];
USHORT Addr01, Addr23, Addr45;

pObj = pObj; /* avoid compile warning */

switch(cmd)
{
case CMD_RTPRIV_IOCTL_NETDEV_GET:
/* get main net_dev */
{
VOID **ppNetDev = (VOID **)pData;
*ppNetDev = (VOID *)(pAd->net_dev);
}
break;

case CMD_RTPRIV_IOCTL_NETDEV_SET:
/* set main net_dev */
pAd->net_dev = pData;

#ifdef CONFIG_AP_SUPPORT
pAd->ApCfg.MBSSID[MAIN_MBSSID].MSSIDDev = pData;
#endif /* CONFIG_AP_SUPPORT */
break;

case CMD_RTPRIV_IOCTL_OPMODE_GET:
/* get Operation Mode */
*(ULONG *)pData = pAd->OpMode;
break;

case CMD_RTPRIV_IOCTL_TASK_LIST_GET:
/* get all Tasks */
{
RT_CMD_WAIT_QUEUE_LIST *pList = (RT_CMD_WAIT_QUEUE_LIST *)pData;

pList->pMlmeTask = &pAd->mlmeTask;
#ifdef RTMP_TIMER_TASK_SUPPORT
pList->pTimerTask = &pAd->timerTask;
#endif /* RTMP_TIMER_TASK_SUPPORT */
pList->pCmdQTask = &pAd->cmdQTask;
#ifdef WSC_INCLUDED
pList->pWscTask = &pAd->wscTask;
#endif /* WSC_INCLUDED */
}
break;

case CMD_RTPRIV_IOCTL_IRQ_INIT:
/* init IRQ */
RTMP_IRQ_INIT(pAd);
break;

case CMD_RTPRIV_IOCTL_IRQ_RELEASE:
/* release IRQ */
RTMP_OS_IRQ_RELEASE(pAd, pAd->net_dev);
break;

#ifdef RTMP_MAC_PCI
case CMD_RTPRIV_IOCTL_MSI_ENABLE:
/* enable MSI */
RTMP_MSI_ENABLE(pAd);
*(ULONG **)pData = (ULONG *)(pObj->pci_dev);
break;
#endif /* RTMP_MAC_PCI */

case CMD_RTPRIV_IOCTL_NIC_NOT_EXIST:
/* set driver state to fRTMP_ADAPTER_NIC_NOT_EXIST */
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST);
break;

#ifdef CONFIG_APSTA_MIXED_SUPPORT
case CMD_RTPRIV_IOCTL_MAX_IN_BIT:
/* set MAX_IN_BIT for WMM */
CW_MAX_IN_BITS = Data;
break;
#endif /* CONFIG_APSTA_MIXED_SUPPORT */
#ifdef CONFIG_STA_SUPPORT
#ifdef CONFIG_PM
#ifdef USB_SUPPORT_SELECTIVE_SUSPEND
case CMD_RTPRIV_IOCTL_USB_DEV_GET:
/* get USB DEV */
{
VOID **ppUsb_Dev = (VOID **)pData;
*ppUsb_Dev = (VOID *)(pObj->pUsb_Dev);
}
break;

case CMD_RTPRIV_IOCTL_USB_INTF_GET:
/* get USB INTF */
{
VOID **ppINTF = (VOID **)pData;
*ppINTF = (VOID *)(pObj->intf);
}
break;

case CMD_RTPRIV_IOCTL_ADAPTER_SUSPEND_SET:
/* set driver state to fRTMP_ADAPTER_SUSPEND */
RTMP_SET_FLAG(pAd,fRTMP_ADAPTER_SUSPEND);
break;

case CMD_RTPRIV_IOCTL_ADAPTER_SUSPEND_CLEAR:
/* clear driver state to fRTMP_ADAPTER_SUSPEND */
RTMP_CLEAR_FLAG(pAd,fRTMP_ADAPTER_SUSPEND);
break;

case CMD_RTPRIV_IOCTL_ADAPTER_SEND_DISSASSOCIATE:
/* clear driver state to fRTMP_ADAPTER_SUSPEND */
if (INFRA_ON(pAd) &&
(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST)))
{
MLME_DISASSOC_REQ_STRUCT    DisReq;
MLME_QUEUE_ELEM *MsgElem;/* = (MLME_QUEUE_ELEM *) kmalloc(sizeof(MLME_QUEUE_ELEM), MEM_ALLOC_FLAG);*/
os_alloc_mem(NULL, (UCHAR **)&MsgElem, sizeof(MLME_QUEUE_ELEM));
if (MsgElem)
{
COPY_MAC_ADDR(DisReq.Addr, pAd->CommonCfg.Bssid);
DisReq.Reason =  REASON_DEAUTH_STA_LEAVING;
MsgElem->Machine = ASSOC_STATE_MACHINE;
MsgElem->MsgType = MT2_MLME_DISASSOC_REQ;
MsgElem->MsgLen = sizeof(MLME_DISASSOC_REQ_STRUCT);
NdisMoveMemory(MsgElem->Msg, &DisReq, sizeof(MLME_DISASSOC_REQ_STRUCT));
/* Prevent to connect AP again in STAMlmePeriodicExec*/
pAd->MlmeAux.AutoReconnectSsidLen= 32;
NdisZeroMemory(pAd->MlmeAux.AutoReconnectSsid, pAd->MlmeAux.AutoReconnectSsidLen);
pAd->Mlme.CntlMachine.CurrState = CNTL_WAIT_OID_DISASSOC;
MlmeDisassocReqAction(pAd, MsgElem);/*              kfree(MsgElem);*/
os_free_mem(NULL, MsgElem);
}
/*              RTMPusecDelay(1000);*/
RtmpOSWrielessEventSend(pAd->net_dev, RT_WLAN_EVENT_CGIWAP, -1, NULL, NULL, 0);
}
break;

case CMD_RTPRIV_IOCTL_ADAPTER_SUSPEND_TEST:
/* test driver state to fRTMP_ADAPTER_SUSPEND */
*(UCHAR *)pData = RTMP_TEST_FLAG(pAd,fRTMP_ADAPTER_SUSPEND);
break;

case CMD_RTPRIV_IOCTL_ADAPTER_IDLE_RADIO_OFF_TEST:
/* test driver state to fRTMP_ADAPTER_IDLE_RADIO_OFF */
*(UCHAR *)pData = RTMP_TEST_FLAG(pAd,fRTMP_ADAPTER_IDLE_RADIO_OFF);
break;

case CMD_RTPRIV_IOCTL_ADAPTER_RT28XX_USB_ASICRADIO_OFF:
/* RT28xxUsbAsicRadioOff */
RT28xxUsbAsicRadioOff(pAd);
break;

case CMD_RTPRIV_IOCTL_ADAPTER_RT28XX_USB_ASICRADIO_ON:
/* RT28xxUsbAsicRadioOn */
RT28xxUsbAsicRadioOn(pAd);
break;

#ifdef WOW_SUPPORT
#endif /* WOW_SUPPORT */

#endif /* USB_SUPPORT_SELECTIVE_SUSPEND */
#endif /* CONFIG_PM */

case CMD_RTPRIV_IOCTL_AP_BSSID_GET:
if (pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED)
NdisCopyMemory(pData, pAd->MlmeAux.Bssid, 6);
else
return NDIS_STATUS_FAILURE;
break;
#endif /* CONFIG_STA_SUPPORT */

case CMD_RTPRIV_IOCTL_SANITY_CHECK:
/* sanity check before IOCTL */
if ((!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_INTERRUPT_IN_USE))
#ifdef IFUP_IN_PROBE
|| (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS))
|| (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS))
|| (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_NIC_NOT_EXIST))
#endif /* IFUP_IN_PROBE */
)
{
if(pData == NULL || RT_isLegalCmdBeforeInfUp((PSTRING) pData) == FALSE)
return NDIS_STATUS_FAILURE;
}
break;

case CMD_RTPRIV_IOCTL_SIOCGIWFREQ:
/* get channel number */
*(ULONG *)pData = pAd->CommonCfg.Channel;
break;

#ifdef MESH_SUPPORT
case CMD_RTPRIV_IOCTL_MESH_INIT:
MeshInit(pAd, pData);
break;

case CMD_RTPRIV_IOCTL_MESH_REMOVE:
MESH_Remove(pAd);
break;

case CMD_RTPRIV_IOCTL_MESH_OPEN_PRE:
if (MESH_OpenPre(pData) != 0)
return NDIS_STATUS_FAILURE;
break;

case CMD_RTPRIV_IOCTL_MESH_OPEN_POST:
if (MESH_OpenPost(pData) != 0)
return NDIS_STATUS_FAILURE;
break;

case CMD_RTPRIV_IOCTL_MESH_IS_VALID:
*(BOOLEAN *)pData = MeshValid(&pAd->MeshTab);
break;

case CMD_RTPRIV_IOCTL_MESH_CLOSE:
MESH_Close(pData);
break;
#endif /* MESH_SUPPORT */

#ifdef P2P_SUPPORT
case CMD_RTPRIV_IOCTL_P2P_INIT:
P2pInit(pAd, pData);
break;

case CMD_RTPRIV_IOCTL_P2P_REMOVE:
P2P_Remove(pAd);
break;

case CMD_RTPRIV_IOCTL_P2P_OPEN_PRE:
if (P2P_OpenPre(pData) != 0)
return NDIS_STATUS_FAILURE;
break;

case CMD_RTPRIV_IOCTL_P2P_OPEN_POST:
if (P2P_OpenPost(pData) != 0)
return NDIS_STATUS_FAILURE;
break;

case CMD_RTPRIV_IOCTL_P2P_CLOSE:
P2P_Close(pData);
break;
#endif /* P2P_SUPPORT */

case CMD_RTPRIV_IOCTL_BEACON_UPDATE:
/* update all beacon contents */
#ifdef CONFIG_AP_SUPPORT
APMakeAllBssBeacon(pAd);
APUpdateAllBeaconFrame(pAd);
#endif /* CONFIG_AP_SUPPORT */
#ifdef MESH_SUPPORT
MeshMakeBeacon(pAd, pAd->MeshTab.BcnBufIdx);
MeshUpdateBeaconFrame(pAd, pAd->MeshTab.BcnBufIdx);
#endif /* MESH_SUPPORT */
break;

case CMD_RTPRIV_IOCTL_RXPATH_GET:
/* get the number of rx path */
*(ULONG *)pData = pAd->Antenna.field.RxPath;
break;

case CMD_RTPRIV_IOCTL_CHAN_LIST_NUM_GET:
*(ULONG *)pData = pAd->ChannelListNum;
break;

case CMD_RTPRIV_IOCTL_CHAN_LIST_GET:
{
UINT32 i;
UCHAR *pChannel = (UCHAR *)pData;

for (i = 1; i <= pAd->ChannelListNum; i++)
{
*pChannel = pAd->ChannelList[i-1].Channel;
pChannel ++;
}
}
break;

case CMD_RTPRIV_IOCTL_FREQ_LIST_GET:
{
UINT32 i;
UINT32 *pFreq = (UINT32 *)pData;
UINT32 m;

for (i = 1; i <= pAd->ChannelListNum; i++)
{
m = 2412000;
MAP_CHANNEL_ID_TO_KHZ(pAd->ChannelList[i-1].Channel, m);
(*pFreq) = m;
pFreq ++;
}
}
break;

#ifdef EXT_BUILD_CHANNEL_LIST
case CMD_RTPRIV_SET_PRECONFIG_VALUE:
/* Set some preconfigured value before interface up*/
pAd->CommonCfg.DfsType = MAX_RD_REGION;
break;
#endif /* EXT_BUILD_CHANNEL_LIST */

#ifdef RTMP_PCI_SUPPORT
case CMD_RTPRIV_IOCTL_PCI_SUSPEND:
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);
RTMP_SET_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF);
break;

case CMD_RTPRIV_IOCTL_PCI_RESUME:
RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS);
RTMP_CLEAR_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF);
break;

case CMD_RTPRIV_IOCTL_PCI_CSR_SET:
pAd->CSRBaseAddress = (PUCHAR)Data;
DBGPRINT(RT_DEBUG_ERROR, ("pAd->CSRBaseAddress =0x%lx, csr_addr=0x%lx!\n", (ULONG)pAd->CSRBaseAddress, (ULONG)Data));
break;

case CMD_RTPRIV_IOCTL_PCIE_INIT:
RTMPInitPCIeDevice(pData, pAd);
break;
#endif /* RTMP_PCI_SUPPORT */

#ifdef RT_CFG80211_SUPPORT
case CMD_RTPRIV_IOCTL_CFG80211_CFG_START:
RT_CFG80211_REINIT(pAd);
RT_CFG80211_CRDA_REG_RULE_APPLY(pAd);
break;
#endif /* RT_CFG80211_SUPPORT */

#ifdef INF_PPA_SUPPORT
case CMD_RTPRIV_IOCTL_INF_PPA_INIT:
os_alloc_mem(NULL, (UCHAR **)&(pAd->pDirectpathCb), sizeof(PPA_DIRECTPATH_CB));
break;

case CMD_RTPRIV_IOCTL_INF_PPA_EXIT:
if (ppa_hook_directpath_register_dev_fn && pAd->PPAEnable==TRUE)
{
UINT status;
status=ppa_hook_directpath_register_dev_fn(&pAd->g_if_id, pAd->net_dev, NULL, 0);
DBGPRINT(RT_DEBUG_TRACE, ("unregister PPA:g_if_id=%d status=%d\n",pAd->g_if_id,status));
}
os_free_mem(NULL, pAd->pDirectpathCb);
break;
#endif /* INF_PPA_SUPPORT*/

case CMD_RTPRIV_IOCTL_VIRTUAL_INF_UP:
/* interface up */
{
RT_CMD_INF_UP_DOWN *pInfConf = (RT_CMD_INF_UP_DOWN *)pData;

if (VIRTUAL_IF_NUM(pAd) == 0)
{
if (pInfConf->rt28xx_open(pAd->net_dev) != 0)
{
DBGPRINT(RT_DEBUG_TRACE, ("rt28xx_open return fail!\n"));
return NDIS_STATUS_FAILURE;
}
}
else
{
#ifdef CONFIG_AP_SUPPORT
extern VOID APMakeAllBssBeacon(IN PRTMP_ADAPTER pAd);
extern VOID  APUpdateAllBeaconFrame(IN PRTMP_ADAPTER pAd);
APMakeAllBssBeacon(pAd);
APUpdateAllBeaconFrame(pAd);
#endif /* CONFIG_AP_SUPPORT */
#ifdef MESH_SUPPORT
{
extern VOID MeshMakeBeacon(IN PRTMP_ADAPTER pAd, IN UCHAR idx);
extern VOID MeshUpdateBeaconFrame(IN PRTMP_ADAPTER pAd, IN UCHAR idx);
MeshMakeBeacon(pAd, pAd->MeshTab.BcnBufIdx);
MeshUpdateBeaconFrame(pAd, pAd->MeshTab.BcnBufIdx);
}
#endif /* MESH_SUPPORT */
}
VIRTUAL_IF_INC(pAd);
}
break;

case CMD_RTPRIV_IOCTL_VIRTUAL_INF_DOWN:
/* interface down */
{
RT_CMD_INF_UP_DOWN *pInfConf = (RT_CMD_INF_UP_DOWN *)pData;

VIRTUAL_IF_DEC(pAd);
if (VIRTUAL_IF_NUM(pAd) == 0)
pInfConf->rt28xx_close(pAd->net_dev);
}
break;

case CMD_RTPRIV_IOCTL_VIRTUAL_INF_GET:
/* get virtual interface number */
*(ULONG *)pData = VIRTUAL_IF_NUM(pAd);
break;

case CMD_RTPRIV_IOCTL_INF_TYPE_GET:
/* get current interface type */
*(ULONG *)pData = pAd->infType;
break;

case CMD_RTPRIV_IOCTL_INF_STATS_GET:
/* get statistics */
{
RT_CMD_STATS *pStats = (RT_CMD_STATS *)pData;
pStats->pStats = pAd->stats;
if(pAd->OpMode == OPMODE_STA)
{
pStats->rx_packets = pAd->WlanCounters.ReceivedFragmentCount.QuadPart;
pStats->tx_packets = pAd->WlanCounters.TransmittedFragmentCount.QuadPart;
pStats->rx_bytes = pAd->RalinkCounters.ReceivedByteCount;
pStats->tx_bytes = pAd->RalinkCounters.TransmittedByteCount;
pStats->rx_errors = pAd->Counters8023.RxErrors;
pStats->tx_errors = pAd->Counters8023.TxErrors;
pStats->multicast = pAd->WlanCounters.MulticastReceivedFrameCount.QuadPart;   /* multicast packets received*/
pStats->collisions = pAd->Counters8023.OneCollision + pAd->Counters8023.MoreCollisions;  /* Collision packets*/
pStats->rx_over_errors = pAd->Counters8023.RxNoBuffer;                   /* receiver ring buff overflow*/
pStats->rx_crc_errors = 0;/*pAd->WlanCounters.FCSErrorCount;      recved pkt with crc error*/
pStats->rx_frame_errors = pAd->Counters8023.RcvAlignmentErrors;          /* recv'd frame alignment error*/
pStats->rx_fifo_errors = pAd->Counters8023.RxNoBuffer;                   /* recv'r fifo overrun*/
}
#ifdef CONFIG_AP_SUPPORT
else if(pAd->OpMode == OPMODE_AP)
{
INT index;
for(index = 0; index < MAX_MBSSID_NUM(pAd); index++)
{
if (pAd->ApCfg.MBSSID[index].MSSIDDev == (PNET_DEV)(pStats->pNetDev))
{
break;
}
}

if(index >= MAX_MBSSID_NUM(pAd))
{
//reset counters
pStats->rx_packets = 0;
pStats->tx_packets = 0;
pStats->rx_bytes = 0;
pStats->tx_bytes = 0;
pStats->rx_errors = 0;
pStats->tx_errors = 0;
pStats->multicast = 0;   /* multicast packets received*/
pStats->collisions = 0;  /* Collision packets*/
pStats->rx_over_errors = 0; /* receiver ring buff overflow*/
pStats->rx_crc_errors = 0; /* recved pkt with crc error*/
pStats->rx_frame_errors = 0; /* recv'd frame alignment error*/
pStats->rx_fifo_errors = 0; /* recv'r fifo overrun*/

DBGPRINT(RT_DEBUG_ERROR, ("CMD_RTPRIV_IOCTL_INF_STATS_GET: can not find mbss I/F\n"));
return NDIS_STATUS_FAILURE;
}

pStats->rx_packets = pAd->ApCfg.MBSSID[index].RxCount;
pStats->tx_packets = pAd->ApCfg.MBSSID[index].TxCount;
pStats->rx_bytes = pAd->ApCfg.MBSSID[index].ReceivedByteCount;
pStats->tx_bytes = pAd->ApCfg.MBSSID[index].TransmittedByteCount;
pStats->rx_errors = pAd->ApCfg.MBSSID[index].RxErrorCount;
pStats->tx_errors = pAd->ApCfg.MBSSID[index].TxErrorCount;
pStats->multicast = pAd->ApCfg.MBSSID[index].mcPktsRx; /* multicast packets received */
pStats->collisions = 0;  /* Collision packets*/
pStats->rx_over_errors = 0;                   /* receiver ring buff overflow*/
pStats->rx_crc_errors = 0;/* recved pkt with crc error*/
pStats->rx_frame_errors = 0;          /* recv'd frame alignment error*/
pStats->rx_fifo_errors = 0;                   /* recv'r fifo overrun*/
}
#endif
}
break;

case CMD_RTPRIV_IOCTL_INF_IW_STATUS_GET:
/* get wireless statistics */
{
UCHAR CurOpMode = OPMODE_AP;
#ifdef CONFIG_AP_SUPPORT
PMAC_TABLE_ENTRY pMacEntry = NULL;
#endif /* CONFIG_AP_SUPPORT */
RT_CMD_IW_STATS *pStats = (RT_CMD_IW_STATS *)pData;

pStats->qual = 0;
pStats->level = 0;
pStats->noise = 0;
pStats->pStats = pAd->iw_stats;

#ifdef CONFIG_STA_SUPPORT
if (pAd->OpMode == OPMODE_STA)
{
CurOpMode = OPMODE_STA;
#ifdef P2P_SUPPORT
if (pStats->priv_flags == INT_P2P)
CurOpMode = OPMODE_AP;
#endif /* P2P_SUPPORT */
}
#endif /* CONFIG_STA_SUPPORT */

/*check if the interface is down*/
if(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_INTERRUPT_IN_USE))
return NDIS_STATUS_FAILURE;

#ifdef CONFIG_AP_SUPPORT
if (CurOpMode == OPMODE_AP)
{
#ifdef APCLI_SUPPORT
if ((pStats->priv_flags == INT_APCLI)
#ifdef P2P_SUPPORT
|| (P2P_CLI_ON(pAd))
#endif /* P2P_SUPPORT */
)
{
INT ApCliIdx = ApCliIfLookUp(pAd, (PUCHAR)pStats->dev_addr);
if ((ApCliIdx >= 0) && VALID_WCID(pAd->ApCfg.ApCliTab[ApCliIdx].MacTabWCID))
pMacEntry = &pAd->MacTab.Content[pAd->ApCfg.ApCliTab[ApCliIdx].MacTabWCID];
}
else
#endif /* APCLI_SUPPORT */
{
/*
only AP client support wireless stats function.
return NULL pointer for all other cases.
*/
pMacEntry = NULL;
}
}
#endif /* CONFIG_AP_SUPPORT */

#ifdef CONFIG_STA_SUPPORT
if (CurOpMode == OPMODE_STA)
pStats->qual = ((pAd->Mlme.ChannelQuality * 12)/10 + 10);
#endif /* CONFIG_STA_SUPPORT */
#ifdef CONFIG_AP_SUPPORT
if (CurOpMode == OPMODE_AP)
{
if (pMacEntry != NULL)
pStats->qual = ((pMacEntry->ChannelQuality * 12)/10 + 10);
else
pStats->qual = ((pAd->Mlme.ChannelQuality * 12)/10 + 10);
}
#endif /* CONFIG_AP_SUPPORT */

if (pStats->qual > 100)
pStats->qual = 100;

#ifdef CONFIG_STA_SUPPORT
if (CurOpMode == OPMODE_STA)
{
pStats->level =
RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.AvgRssi0,
pAd->StaCfg.RssiSample.AvgRssi1,
pAd->StaCfg.RssiSample.AvgRssi2);
}
#endif /* CONFIG_STA_SUPPORT */
#ifdef CONFIG_AP_SUPPORT
if (CurOpMode == OPMODE_AP)
{
if (pMacEntry != NULL)
pStats->level =
RTMPMaxRssi(pAd, pMacEntry->RssiSample.AvgRssi0,
pMacEntry->RssiSample.AvgRssi1,
pMacEntry->RssiSample.AvgRssi2);
#ifdef P2P_APCLI_SUPPORT
else
pStats->level =
RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.AvgRssi0,
pAd->StaCfg.RssiSample.AvgRssi1,
pAd->StaCfg.RssiSample.AvgRssi2);
#endif /* P2P_APCLI_SUPPORT */
}
#endif /* CONFIG_AP_SUPPORT */

#ifdef CONFIG_AP_SUPPORT
pStats->noise = RTMPMaxRssi(pAd, pAd->ApCfg.RssiSample.AvgRssi0,
pAd->ApCfg.RssiSample.AvgRssi1,
pAd->ApCfg.RssiSample.AvgRssi2) -
RTMPMinSnr(pAd, pAd->ApCfg.RssiSample.AvgSnr0,
pAd->ApCfg.RssiSample.AvgSnr1);
#endif /* CONFIG_AP_SUPPORT */
#ifdef CONFIG_STA_SUPPORT
pStats->noise = RTMPMaxRssi(pAd, pAd->StaCfg.RssiSample.AvgRssi0,
pAd->StaCfg.RssiSample.AvgRssi1,
pAd->StaCfg.RssiSample.AvgRssi2) -
RTMPMinSnr(pAd, pAd->StaCfg.RssiSample.AvgSnr0,
pAd->StaCfg.RssiSample.AvgSnr1);
#endif /* CONFIG_STA_SUPPORT */
}
break;

case CMD_RTPRIV_IOCTL_INF_MAIN_CREATE:
*(VOID **)pData = RtmpPhyNetDevMainCreate(pAd);
break;

case CMD_RTPRIV_IOCTL_INF_MAIN_ID_GET:
*(ULONG *)pData = INT_MAIN;
break;

case CMD_RTPRIV_IOCTL_INF_MAIN_CHECK:
if (Data != INT_MAIN)
return NDIS_STATUS_FAILURE;
break;

case CMD_RTPRIV_IOCTL_INF_P2P_CHECK:
if (Data != INT_P2P)
return NDIS_STATUS_FAILURE;
break;

#ifdef WDS_SUPPORT
case CMD_RTPRIV_IOCTL_WDS_INIT:
WDS_Init(pAd, pData);
break;

case CMD_RTPRIV_IOCTL_WDS_REMOVE:
WDS_Remove(pAd);
break;

case CMD_RTPRIV_IOCTL_WDS_STATS_GET:
if (Data == INT_WDS)
{
if (WDS_StatsGet(pAd, pData) != TRUE)
return NDIS_STATUS_FAILURE;
}
else
return NDIS_STATUS_FAILURE;
break;
#endif /* WDS_SUPPORT */

#ifdef RALINK_ATE
#ifdef RALINK_QA
case CMD_RTPRIV_IOCTL_ATE:
RtmpDoAte(pAd, wrq, pData);
break;
#endif /* RALINK_QA */
#endif /* RALINK_ATE */

case CMD_RTPRIV_IOCTL_MAC_ADDR_GET:

RT28xx_EEPROM_READ16(pAd, 0x04, Addr01);
RT28xx_EEPROM_READ16(pAd, 0x06, Addr23);
RT28xx_EEPROM_READ16(pAd, 0x08, Addr45);

PermanentAddress[0] = (UCHAR)(Addr01 & 0xff);
PermanentAddress[1] = (UCHAR)(Addr01 >> 8);
PermanentAddress[2] = (UCHAR)(Addr23 & 0xff);
PermanentAddress[3] = (UCHAR)(Addr23 >> 8);
PermanentAddress[4] = (UCHAR)(Addr45 & 0xff);
PermanentAddress[5] = (UCHAR)(Addr45 >> 8);

for(i=0; i<6; i++)
*(UCHAR *)(pData+i) = PermanentAddress[i];
break;
#ifdef CONFIG_AP_SUPPORT
case CMD_RTPRIV_IOCTL_AP_SIOCGIWRATEQ:
/* handle for SIOCGIWRATEQ */
{
RT_CMD_IOCTL_RATE *pRate = (RT_CMD_IOCTL_RATE *)pData;
HTTRANSMIT_SETTING HtPhyMode;

#ifdef MESH_SUPPORT
if (pRate->priv_flags == INT_MESH)
HtPhyMode = pAd->MeshTab.HTPhyMode;
else
#endif /* MESH_SUPPORT */
#ifdef APCLI_SUPPORT
if (pRate->priv_flags == INT_APCLI)
HtPhyMode = pAd->ApCfg.ApCliTab[pObj->ioctl_if].HTPhyMode;
else
#endif /* APCLI_SUPPORT */
#ifdef WDS_SUPPORT
if (pRate->priv_flags == INT_WDS)
HtPhyMode = pAd->WdsTab.WdsEntry[pObj->ioctl_if].HTPhyMode;
else
#endif /* WDS_SUPPORT */
{
HtPhyMode = pAd->ApCfg.MBSSID[pObj->ioctl_if].HTPhyMode;
#ifdef MBSS_SUPPORT
/* reset phy mode for MBSS */
MBSS_PHY_MODE_RESET(pObj->ioctl_if, HtPhyMode);
#endif /* MBSS_SUPPORT */
}
RtmpDrvMaxRateGet(pAd, HtPhyMode.field.MODE, HtPhyMode.field.ShortGI,
HtPhyMode.field.BW, HtPhyMode.field.MCS,
(UINT32 *)&pRate->BitRate);
}
break;
#endif /* CONFIG_AP_SUPPORT */

case CMD_RTPRIV_IOCTL_SIOCGIWNAME:
RtmpIoctl_rt_ioctl_giwname(pAd, pData, 0);
break;

}

#ifdef RT_CFG80211_SUPPORT
if ((CMD_RTPRIV_IOCTL_80211_START <= cmd) &&
(cmd <= CMD_RTPRIV_IOCTL_80211_END))
{
CFG80211DRV_IoctlHandle(pAd, wrq, cmd, subcmd, pData, Data);
}
#endif /* RT_CFG80211_SUPPORT */

if (cmd >= CMD_RTPRIV_IOCTL_80211_COM_LATEST_ONE)
return NDIS_STATUS_FAILURE;

return Status;
}