/*
==========================================================================
Description:
function to be executed at timer thread when auth timer expires
==========================================================================
*/
static VOID ApCliAuthTimeout(
IN PVOID SystemSpecific1,
IN PVOID FunctionContext,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3)
{
RTMP_ADAPTER *pAd = (RTMP_ADAPTER *)FunctionContext;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s():AuthTimeout\n", __FUNCTION__));
MlmeEnqueue(pAd, APCLI_AUTH_STATE_MACHINE, APCLI_MT2_AUTH_TIMEOUT, 0, NULL, 0);
RTMP_MLME_HANDLER(pAd);
return;
}
static VOID RxSensitivityTuning(RTMP_ADAPTER *pAd)
{
UCHAR R66 = 0x26 + pAd->hw_cfg.lan_gain;
#ifdef CONFIG_ATE
if (ATE_ON(pAd))
{
ATE_BBP_IO_WRITE8_BY_REG_ID(pAd, BBP_R66, R66);
}
else
#endif /* CONFIG_ATE */
{
bbp_set_agc(pAd, R66, RX_CHAIN_ALL);
}
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE,("turn off R17 tuning, restore to 0x%02x\n", R66));
}
VOID PMF_PeerAction(
IN PRTMP_ADAPTER pAd,
IN MLME_QUEUE_ELEM *Elem)
{
UCHAR Action = Elem->Msg[LENGTH_802_11+1];
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_WARN, ("[PMF]%s : PMF_PeerAction Action=%d\n", __FUNCTION__, Action));
switch (Action) {
case ACTION_SAQ_REQUEST:
PMF_PeerSAQueryReqAction(pAd, Elem);
break;
case ACTION_SAQ_RESPONSE:
PMF_PeerSAQueryRspAction(pAd, Elem);
break;
}
}
INT bbp_set_bw(struct _RTMP_ADAPTER *pAd, UINT8 bw)
{
INT result = FALSE;
if (pAd->phy_op && pAd->phy_op->bbp_set_bw)
result = pAd->phy_op->bbp_set_bw(pAd, bw);
if (result == TRUE)
{
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s(): Set PhyBW as %sHz.l\n",
__FUNCTION__, get_bw_str(bw)));
}
#ifdef MT7615
if (IS_MT7615(pAd))
{
DBGPRINT(RT_DEBUG_OFF, ("%s():NotSupportYet!\n", __FUNCTION__));
return FALSE;
}
#endif /* MT7615 */
// TODO: shiang-7603, revise following code
#ifdef MT_MAC
if (pAd->chipCap.hif_type == HIF_MT) {
UINT32 val;
RTMP_IO_READ32(pAd, AGG_BWCR, &val);
val &= (~0x0c);
switch (bw)
{
case BW_20:
val |= (0);
break;
case BW_40:
val |= (0x1 << 2);
break;
case BW_80:
val |= (0x2 << 2);
break;
}
RTMP_IO_WRITE32(pAd, AGG_BWCR, val);
}
#endif /* MT_MAC */
return result;
}
INT WdsVirtualIF_open(PNET_DEV dev)
{
VOID *pAd;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s: ===> VirtualIF_open\n", RTMP_OS_NETDEV_GET_DEVNAME(dev)));
pAd = RTMP_OS_NETDEV_GET_PRIV(dev);
if (VIRTUAL_IF_UP(pAd) != 0)
return -1;
/* increase MODULE use count */
RT_MOD_INC_USE_COUNT();
RTMP_OS_NETDEV_START_QUEUE(dev);
return 0;
}
/*
Driver module load/unload function
*/
int __init rt_pci_init_module(void)
{
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("register %s\n", RTMP_DRV_NAME));
/*
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("DriverVersion: 2.7.0.2-Beta-121007\n"
"\tBBP:120824\n"
"\tRF :120813\n"));
*/
/*add for initial hook callback function linking list*/
RTMP_OS_TXRXHOOK_INIT();
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
return pci_register_driver(&rt_pci_driver);
#else
return pci_module_init(&rt_pci_driver);
#endif
}
VOID AndesIncErrorCount(struct MCU_CTRL *ctl, enum cmd_msg_error_type type)
{
if (OS_TEST_BIT(MCU_INIT, &ctl->flags)) {
switch (type) {
case error_tx_kickout_fail:
ctl->tx_kickout_fail_count++;
break;
case error_tx_timeout_fail:
ctl->tx_timeout_fail_count++;
break;
case error_rx_receive_fail:
ctl->rx_receive_fail_count++;
break;
default:
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s:unknown cmd_msg_error_type(%d)\n", __FUNCTION__, type));
}
}
}
INT WdsVirtualIF_close(PNET_DEV dev)
{
VOID *pAd;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s: ===> VirtualIF_close\n", RTMP_OS_NETDEV_GET_DEVNAME(dev)));
pAd = RTMP_OS_NETDEV_GET_PRIV(dev);
//RTMP_OS_NETDEV_CARRIER_OFF(dev);
RTMP_OS_NETDEV_STOP_QUEUE(dev);
VIRTUAL_IF_DOWN(pAd);
RT_MOD_DEC_USE_COUNT();
return 0;
}
void rtmp_read_igmp_snoop_from_file(
IN PRTMP_ADAPTER pAd,
RTMP_STRING *tmpbuf,
RTMP_STRING *buffer)
{
/*IgmpSnEnable */
if(RTMPGetKeyParameter("IgmpSnEnable", tmpbuf, 128, buffer, TRUE))
{
if ((strncmp(tmpbuf, "0", 1) == 0))
pAd->ApCfg.IgmpSnoopEnable = FALSE;
else if ((strncmp(tmpbuf, "1", 1) == 0))
pAd->ApCfg.IgmpSnoopEnable = TRUE;
else
pAd->ApCfg.IgmpSnoopEnable = FALSE;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, (" IGMP Snooping Enable=%d\n", pAd->ApCfg.IgmpSnoopEnable));
}
}
BOOLEAN blockNetIf(BLOCK_QUEUE_ENTRY *pBlockQueueEntry, PNET_DEV pNetDev)
{
NETIF_ENTRY *pNetIfEntry = NULL;
if ((pNetIfEntry = (NETIF_ENTRY *)removeHeadList(&freeNetIfEntryList)) != NULL)
{
RTMP_OS_NETDEV_STOP_QUEUE(pNetDev);
pNetIfEntry->pNetDev = pNetDev;
insertTailList(&pBlockQueueEntry->NetIfList, (RT_LIST_ENTRY *)pNetIfEntry);
pBlockQueueEntry->SwTxQueueBlockFlag = TRUE;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("RTMP_OS_NETDEV_STOP_QUEUE(%s)\n", RTMP_OS_NETDEV_GET_DEVNAME(pNetDev)));
}
else
return FALSE;
return TRUE;
}
VOID RTMP_CFG80211_RemoveVifEntry(VOID *pAdSrc, PNET_DEV pNewNetDev)
{
PRTMP_ADAPTER pAd = (PRTMP_ADAPTER)pAdSrc;
RT_LIST_ENTRY *pListEntry = NULL;
pListEntry = (RT_LIST_ENTRY *)RTMP_CFG80211_FindVifEntry_ByMac(pAd, pNewNetDev);
if (pListEntry)
{
delEntryList(&pAd->cfg80211_ctrl.Cfg80211VifDevSet.vifDevList, pListEntry);
os_free_mem(NULL, pListEntry);
pListEntry = NULL;
}
else
{
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("Error in RTMP_CFG80211_RemoveVifEntry.\n"));
}
}
static INT CFG80211_DummyP2pIf_Ioctl(
IN PNET_DEV dev_p,
IN OUT VOID *rq_p,
IN INT cmd)
{
RTMP_ADAPTER *pAd;
pAd = RTMP_OS_NETDEV_GET_PRIV(dev_p);
ASSERT(pAd);
if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_INTERRUPT_IN_USE))
return -ENETDOWN;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s --->\n", __FUNCTION__));
return rt28xx_ioctl(dev_p, rq_p, cmd);
}
/*
========================================================================
Routine Description:
Channel switching count down process upon radar detection
Arguments:
pAd Pointer to our adapter
========================================================================
*/
VOID ChannelSwitchingCountDownProc(
IN PRTMP_ADAPTER pAd)
{
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s():Channel Switching...(%d/%d)\n",
__FUNCTION__, pAd->Dot11_H.CSCount, pAd->Dot11_H.CSPeriod));
pAd->Dot11_H.CSCount++;
if (pAd->Dot11_H.CSCount >= pAd->Dot11_H.CSPeriod)
{
#ifdef DFS_SUPPORT
pAd->CommonCfg.RadarDetect.DFSAPRestart = 1;
schedule_dfs_task(pAd);
#else
APStop(pAd);
APStartUp(pAd);
#endif /* !DFS_SUPPORT */
}
}
/*
========================================================================
Routine Description:
Close a virtual network interface.
Arguments:
dev_p which WLAN network interface
Return Value:
0: close successfully
otherwise: close fail
Note:
========================================================================
*/
INT ApCli_VirtualIF_Close(PNET_DEV dev_p)
{
VOID *pAd;
pAd = RTMP_OS_NETDEV_GET_PRIV(dev_p);
ASSERT(pAd);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s: ===> %s\n", __FUNCTION__, RTMP_OS_NETDEV_GET_DEVNAME(dev_p)));
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_APC_CLOSE, 0, dev_p, 0);
VIRTUAL_IF_DOWN(pAd);
RT_MOD_DEC_USE_COUNT();
return 0;
}
/* Register WDS interface */
VOID RT28xx_WDS_Init(VOID *pAd, PNET_DEV net_dev)
{
RTMP_OS_NETDEV_OP_HOOK netDevOpHook;
NdisZeroMemory((PUCHAR)&netDevOpHook, sizeof(RTMP_OS_NETDEV_OP_HOOK));
netDevOpHook.open = WdsVirtualIF_open;
netDevOpHook.stop = WdsVirtualIF_close;
netDevOpHook.xmit = rt28xx_send_packets;
netDevOpHook.ioctl = rt28xx_ioctl;
netDevOpHook.get_stats = RT28xx_get_wds_ether_stats;
NdisMoveMemory(&netDevOpHook.devAddr[0], RTMP_OS_NETDEV_GET_PHYADDR(net_dev), MAC_ADDR_LEN);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("The new WDS interface MAC = %02X:%02X:%02X:%02X:%02X:%02X\n",
PRINT_MAC(netDevOpHook.devAddr)));
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_WDS_INIT,
0, &netDevOpHook, 0);
}
static VOID DEVEXIT rt_pci_remove(struct pci_dev *pci_dev)
{
PNET_DEV net_dev = pci_get_drvdata(pci_dev);
VOID *pAd = NULL;
ULONG csr_addr = net_dev->base_addr;
GET_PAD_FROM_NET_DEV(pAd, net_dev);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("===> %s()\n", __FUNCTION__));
if (pAd != NULL)
{
/* Unregister/Free all allocated net_device. */
RtmpPhyNetDevExit(pAd, net_dev);
#ifdef RT_CFG80211_SUPPORT
RTMP_DRIVER_80211_UNREGISTER(pAd, net_dev);
#endif /* RT_CFG80211_SUPPORT */
/* Free RTMP_ADAPTER related structures. */
RtmpRaDevCtrlExit(pAd);
/* Unmap CSR base address */
iounmap((char *)(csr_addr));
/* release memory region */
release_mem_region(pci_resource_start(pci_dev, 0), pci_resource_len(pci_dev, 0));
}
else
{
/* Unregister network device */
RtmpOSNetDevDetach(net_dev);
/* Unmap CSR base address */
iounmap((char *)(net_dev->base_addr));
/* release memory region */
release_mem_region(pci_resource_start(pci_dev, 0), pci_resource_len(pci_dev, 0));
}
/* Free the root net_device */
RtmpOSNetDevFree(net_dev);
}
VOID CFG80211_SendMgmtFrameDone(RTMP_ADAPTER *pAd, USHORT Sequence)
{
//RTMP_USB_SUPPORT/RTMP_PCI_SUPPORT
PCFG80211_CTRL pCfg80211_ctrl = &pAd->cfg80211_ctrl;
if (pCfg80211_ctrl->TxStatusInUsed && pCfg80211_ctrl->pTxStatusBuf
/*&& (pAd->TxStatusSeq == pHeader->Sequence)*/)
{
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_INFO, ("CFG_TX_STATUS: REAL send %d\n", Sequence));
CFG80211OS_TxStatus(CFG80211_GetEventDevice(pAd), 5678,
pCfg80211_ctrl->pTxStatusBuf, pCfg80211_ctrl->TxStatusBufLen,
TRUE);
pCfg80211_ctrl->TxStatusSeq = 0;
pCfg80211_ctrl->TxStatusInUsed = FALSE;
}
}
INT Set_NfcRegenPK_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
POS_COOKIE pObj = (POS_COOKIE) pAd->OS_Cookie;
UCHAR apidx = pObj->ioctl_if, mac_addr[MAC_ADDR_LEN];
BOOLEAN bFromApCli = FALSE;
PWSC_CTRL pWscCtrl;
UINT32 val = 0;
pWscCtrl = &pAd->ApCfg.MBSSID[apidx].WscControl;
val = simple_strtol(arg, 0, 10);
if (val == 1)
pWscCtrl->bRegenPublicKey = 1;
else
pWscCtrl->bRegenPublicKey = 0;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s : bRegenPublicKey=%d, \n",
__FUNCTION__, pWscCtrl->bRegenPublicKey));
}
INT AsicSetDevMac(RTMP_ADAPTER *pAd, UCHAR *addr, UCHAR omac_idx)
{
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s(): Set OwnMac=%02x:%02x:%02x:%02x:%02x:%02x\n",
__FUNCTION__, PRINT_MAC(addr)));
#if defined(RTMP_MAC) || defined(RLT_MAC)
if (pAd->chipCap.hif_type == HIF_RTMP ||pAd->chipCap.hif_type == HIF_RLT)
return RtAsicSetDevMac(pAd, addr, omac_idx);
#endif
#ifdef MT_MAC
if (pAd->chipCap.hif_type == HIF_MT)
return MtAsicSetDevMac(pAd, addr, omac_idx);
#endif
AsicNotSupportFunc(pAd, __FUNCTION__);
return FALSE;
}
INT Set_NfcStatus_Proc(RTMP_ADAPTER *pAd, RTMP_STRING *arg)
{
UCHAR data = 0;
/*
Action: b¡¦<7:6>: 0x00 ¡V Request, 0x01 ¡V Notify
b¡¦<5:0>: 0x00 ¡V Get, 0x01 - Set
*/
UCHAR action = 1, type = TYPE_NFC_STATUS; /* 5 - NFC Status */
if (simple_strtol(arg, 0, 10) != 0)
data = 1;
data = (UCHAR)simple_strtol(arg, 0, 10);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s: Set NFC Status(=%d)\n", __FUNCTION__, data));
NfcCommand(pAd, action, type, 1, &data);
return TRUE;
}
/*
==========================================================================
Description:
==========================================================================
*/
static VOID ApCliInvalidStateWhenAuth(RTMP_ADAPTER *pAd, MLME_QUEUE_ELEM *Elem)
{
APCLI_CTRL_MSG_STRUCT ApCliCtrlMsg;
USHORT ifIndex = (USHORT)(Elem->Priv);
PULONG pCurrState = NULL;
#ifdef MAC_REPEATER_SUPPORT
UCHAR CliIdx = 0xFF;
#endif /* MAC_REPEATER_SUPPORT */
if ((ifIndex >= MAX_APCLI_NUM)
#ifdef MAC_REPEATER_SUPPORT
&& (ifIndex < 64)
#endif /* MAC_REPEATER_SUPPORT */
)
return;
#ifdef MAC_REPEATER_SUPPORT
if (ifIndex >= 64)
{
CliIdx = ((ifIndex - 64) % MAX_EXT_MAC_ADDR_SIZE);
ifIndex = ((ifIndex - 64) / MAX_EXT_MAC_ADDR_SIZE);
pCurrState = &pAd->ApCfg.ApCliTab[ifIndex].RepeaterCli[CliIdx].AuthCurrState;
}
else
#endif /* MAC_REPEATER_SUPPORT */
pCurrState = &pAd->ApCfg.ApCliTab[ifIndex].AuthCurrState;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("APCLI AUTH - InvalidStateWhenAuth (state=%ld), reset AUTH state machine\n", *pCurrState));
*pCurrState= APCLI_AUTH_REQ_IDLE;
#ifdef MAC_REPEATER_SUPPORT
ApCliCtrlMsg.BssIdx = ifIndex;
ApCliCtrlMsg.CliIdx = CliIdx;
ifIndex = (USHORT)(Elem->Priv);
#endif /* MAC_REPEATER_SUPPORT */
ApCliCtrlMsg.Status = MLME_STATE_MACHINE_REJECT;
MlmeEnqueue(pAd, APCLI_CTRL_STATE_MACHINE, APCLI_CTRL_AUTH_RSP,
sizeof(APCLI_CTRL_MSG_STRUCT), &ApCliCtrlMsg, ifIndex);
return;
}
VOID PciKickOutCmdMsgComplete(PNDIS_PACKET net_pkt)
{
struct cmd_msg *msg =CMD_MSG_CB(net_pkt)->msg;
RTMP_ADAPTER *ad = (RTMP_ADAPTER *)msg->priv;
struct MCU_CTRL *ctl = &ad->MCUCtrl;
if (!OS_TEST_BIT(MCU_INIT, &ctl->flags))
return;
if (!msg->need_wait) {
AndesUnlinkCmdMsg(msg, &ctl->kickq);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_INFO, ("%s: msg state = %d\n", __FUNCTION__, msg->state));
AndesQueueTailCmdMsg(&ctl->tx_doneq, msg, tx_done);
} else {
if (msg->state != tx_done)
msg->state = wait_ack;
}
AndesBhSchedule(ad);
}
VOID releaseNetIf(BLOCK_QUEUE_ENTRY *pBlockQueueEntry)
{
NETIF_ENTRY *pNetIfEntry = NULL;
LIST_HEADER *pNetIfList = &pBlockQueueEntry->NetIfList;
while((pNetIfEntry = (NETIF_ENTRY *)removeHeadList(pNetIfList)) != NULL)
{
PNET_DEV pNetDev = pNetIfEntry->pNetDev;
if (pNetDev) {
RTMP_OS_NETDEV_WAKE_QUEUE(pNetDev);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("RTMP_OS_NETDEV_WAKE_QUEUE(%s)\n",
RTMP_OS_NETDEV_GET_DEVNAME(pNetDev)));
}
insertTailList(&freeNetIfEntryList, (RT_LIST_ENTRY *)pNetIfEntry);
}
pBlockQueueEntry->SwTxQueueBlockFlag = FALSE;
return;
}
/*
========================================================================
Routine Description:
Open a virtual network interface.
Arguments:
dev_p which WLAN network interface
Return Value:
0: open successfully
otherwise: open fail
Note:
========================================================================
*/
INT ApCli_VirtualIF_Open(PNET_DEV dev_p)
{
VOID *pAd;
pAd = RTMP_OS_NETDEV_GET_PRIV(dev_p);
ASSERT(pAd);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s: ===> %s\n", __FUNCTION__, RTMP_OS_NETDEV_GET_DEVNAME(dev_p)));
if (VIRTUAL_IF_UP(pAd) != 0)
return -1;
/* increase MODULE use count */
RT_MOD_INC_USE_COUNT();
RTMP_AP_IoctlHandle(pAd, NULL, CMD_RTPRIV_IOCTL_APC_OPEN, 0, dev_p, 0);
return 0;
}
VOID mt_bcn_buf_init(RTMP_ADAPTER *pAd)
{
RTMP_CHIP_CAP *pChipCap = &pAd->chipCap;
pChipCap->FlgIsSupSpecBcnBuf = FALSE;
pChipCap->BcnMaxHwNum = 16;
pChipCap->BcnMaxNum = 16;
#if defined(MT7603_FPGA) || defined(MT7628_FPGA) || defined(MT7636_FPGA)
pChipCap->WcidHwRsvNum = 20;
#else
pChipCap->WcidHwRsvNum = 127;
#endif /* MT7603_FPGA */
pChipCap->BcnMaxHwSize = 0x2000; // useless!!
pChipCap->BcnBase[0] = 0;
pChipCap->BcnBase[1] = 0;
pChipCap->BcnBase[2] = 0;
pChipCap->BcnBase[3] = 0;
pChipCap->BcnBase[4] = 0;
pChipCap->BcnBase[5] = 0;
pChipCap->BcnBase[6] = 0;
pChipCap->BcnBase[7] = 0;
pChipCap->BcnBase[8] = 0;
pChipCap->BcnBase[9] = 0;
pChipCap->BcnBase[10] = 0;
pChipCap->BcnBase[11] = 0;
pChipCap->BcnBase[12] = 0;
pChipCap->BcnBase[13] = 0;
pChipCap->BcnBase[14] = 0;
pChipCap->BcnBase[15] = 0;
pAd->chipOps.BeaconUpdate = NULL;
// TODO: shiang-7603
if (pAd->chipCap.hif_type == HIF_MT) {
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s(%d): Not support for HIF_MT yet!\n",
__FUNCTION__, __LINE__));
}
}
/*
==========================================================================
Description:
This routine init the entire IGMP table.
==========================================================================
*/
VOID MulticastFilterTableInit(
IN PRTMP_ADAPTER pAd,
IN PMULTICAST_FILTER_TABLE *ppMulticastFilterTable)
{
/* Initialize MAC table and allocate spin lock */
os_alloc_mem(NULL, (UCHAR **)ppMulticastFilterTable, sizeof(MULTICAST_FILTER_TABLE));
if (*ppMulticastFilterTable == NULL)
{
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s unable to alloc memory for Multicase filter table, size=%d\n",
__FUNCTION__, sizeof(MULTICAST_FILTER_TABLE)));
return;
}
NdisZeroMemory(*ppMulticastFilterTable, sizeof(MULTICAST_FILTER_TABLE));
NdisAllocateSpinLock(pAd, &((*ppMulticastFilterTable)->MulticastFilterTabLock));
NdisAllocateSpinLock(pAd, &((*ppMulticastFilterTable)->FreeMemberPoolTabLock));
initList(&((*ppMulticastFilterTable)->freeEntryList));
initFreeEntryList(*ppMulticastFilterTable, &((*ppMulticastFilterTable)->freeEntryList));
return;
}
static NDIS_SPIN_LOCK *AndesGetSpinLock(struct MCU_CTRL *ctl, MT_DL_LIST *list)
{
NDIS_SPIN_LOCK *lock = NULL;
if (list == &ctl->txq)
lock = &ctl->txq_lock;
else if (list == &ctl->rxq)
lock = &ctl->rxq_lock;
else if (list == &ctl->ackq)
lock = &ctl->ackq_lock;
else if (list == &ctl->kickq)
lock = &ctl->kickq_lock;
else if (list == &ctl->tx_doneq)
lock = &ctl->tx_doneq_lock;
else if (list == &ctl->rx_doneq)
lock = &ctl->rx_doneq_lock;
else
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_ERROR, ("%s:illegal list\n", __FUNCTION__));
return lock;
}
INT wdev_tim_buf_init(RTMP_ADAPTER *pAd, TIM_BUF_STRUC *tim_info)
{
//bcn_info->bBcnSntReq = FALSE;
tim_info->TimBufIdx = HW_BEACON_MAX_NUM;
if (!tim_info->TimPkt) {
RTMPAllocateNdisPacket(pAd, &tim_info->TimPkt, NULL, 0, NULL, MAX_TIM_SIZE);
//NdisAllocateSpinLock(pAd, &bcn_info->bcn_lock);
} else {
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s():TimPkt is allocated!\n", __func__));
}
// if (!tim_info->TimPkt2) {
// RTMPAllocateNdisPacket(pAd, &tim_info->TimPkt2, NULL, NULL, NULL, MAX_TIM_SIZE);
//NdisAllocateSpinLock(pAd, &bcn_info->bcn_lock);
// } else {
// MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_OFF, ("%s():TimPkt2 is allocated!\n", __func__));
//}
tim_info->bTimSntReq = TRUE;
return TRUE;
}
/*
LED indication for normal connection start.
*/
VOID LEDConnectionStart(RTMP_ADAPTER *pAd)
{
/* LED indication. */
/*if (pAd->StaCfg.WscControl.bWPSSession == FALSE) */
/*if (pAd->StaCfg.WscControl.WscConfMode != WSC_DISABLE && pAd->StaCfg.WscControl.bWscTrigger) */
if (pAd->StaCfg.WscControl.WscConfMode == WSC_DISABLE)
{
if (LED_MODE(pAd) == WPS_LED_MODE_9) /* LED mode 9. */
{
UCHAR WPSLEDStatus = 0;
/* The AP uses OPEN-NONE. */
if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeOpen)
&& (pAd->StaCfg.WepStatus == Ndis802_11WEPDisabled))
WPSLEDStatus = LED_WPS_TURN_LED_OFF;
else /* The AP uses an encryption algorithm. */
WPSLEDStatus = LED_WPS_IN_PROCESS;
RTMPSetLED(pAd, WPSLEDStatus);
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE, ("%s: %d\n", __FUNCTION__, WPSLEDStatus));
}
}
}
/*
==========================================================================
Description:
function to be executed at timer thread when auth timer expires
IRQL = DISPATCH_LEVEL
==========================================================================
*/
VOID FT_OTA_AuthTimeout(
IN PVOID SystemSpecific1,
IN PVOID FunctionContext,
IN PVOID SystemSpecific2,
IN PVOID SystemSpecific3)
{
RTMP_ADAPTER *pAd = (RTMP_ADAPTER *)FunctionContext;
USHORT Status;
MTWF_LOG(DBG_CAT_ALL, DBG_SUBCAT_ALL, DBG_LVL_TRACE,("FT_OTA_AUTH - FT_OTA_AuthTimeout\n"));
/* Do nothing if the driver is starting halt state. */
/* This might happen when timer already been fired before cancel timer with mlmehalt */
if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS | fRTMP_ADAPTER_NIC_NOT_EXIST))
return;
pAd->StaCfg.Dot11RCommInfo.FtRspSuccess = FT_OTA_RESPONSE;
pAd->Mlme.FtOtaAuthMachine.CurrState = FT_OTA_AUTH_REQ_IDLE;
Status = MLME_REJ_TIMEOUT;
MlmeEnqueue(pAd, MLME_CNTL_STATE_MACHINE, MT2_AUTH_CONF, 2, &Status, 0);
RTMP_MLME_HANDLER(pAd);
}
