tx80211_MgmtMsg_t *mlmeApiPrepMgtMsg(UINT32 Subtype, IEEEtypes_MacAddr_t *DestAddr, IEEEtypes_MacAddr_t *SrcAddr)
#endif
{
macmgmtQ_MgmtMsg2_t * MgmtMsg_p;
//tx80211_MgmtMsg_t * TxMsg_p;
//UINT32 size;
#ifdef AP_MAC_LINUX
struct sk_buff *skb;
UINT8 *frm;
if ((skb = ieee80211_getmgtframe(&frm, sizeof(struct ieee80211_frame)+2)) != NULL)
{
//skb->len = 34;
//skb->tail+= 34;
WLDBG_INFO(DBG_LEVEL_8, "mlmeApiPrepMgtMsg length = %d \n", skb->len);
MgmtMsg_p = (macmgmtQ_MgmtMsg2_t *) skb->data;
MgmtMsg_p->Hdr.FrmCtl.Type = IEEE_TYPE_MANAGEMENT;
MgmtMsg_p->Hdr.FrmCtl.Subtype = Subtype;
MgmtMsg_p->Hdr.FrmCtl.Retry=0;
MgmtMsg_p->Hdr.Duration = 300;
memcpy(&MgmtMsg_p->Hdr.DestAddr, DestAddr, sizeof(IEEEtypes_MacAddr_t));
memcpy(&MgmtMsg_p->Hdr.SrcAddr, SrcAddr, sizeof(IEEEtypes_MacAddr_t));
memcpy(&MgmtMsg_p->Hdr.BssId, SrcAddr, sizeof(IEEEtypes_MacAddr_t));
}
return skb;
#else
#ifdef AP_BUFFER
if ((TxMsg_p = (tx80211_MgmtMsg_t *)pool_GetBuf(txMgmtPoolId)) != NULL)
{
MgmtMsg_p = &TxMsg_p->MgmtFrame;
MgmtMsg_p->Hdr.FrmCtl.Type = IEEE_TYPE_MANAGEMENT;
MgmtMsg_p->Hdr.FrmCtl.Subtype = Subtype;
MgmtMsg_p->Hdr.FrmCtl.Retry=0;
MgmtMsg_p->Hdr.Duration = 300;
memcpy(&MgmtMsg_p->Hdr.DestAddr, DestAddr, sizeof(IEEEtypes_MacAddr_t));
memcpy(&MgmtMsg_p->Hdr.SrcAddr, SrcAddr, sizeof(IEEEtypes_MacAddr_t));
memcpy(&MgmtMsg_p->Hdr.BssId, SrcAddr, sizeof(IEEEtypes_MacAddr_t));
}
return TxMsg_p;
#else
return NULL;
#endif
#endif
}
int wlTxRingInit(struct net_device *netdev)
{
struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, netdev);
int currDescr;
int num;
WLDBG_ENTER_INFO(DBG_LEVEL_12, "initializing %i descriptors", MAX_NUM_TX_DESC);
for(num =0; num < NUM_OF_DESCRIPTOR_DATA; num++)
{
QUEUE_INIT(&((struct wlprivate_data *)(wlpptr->wlpd_p))->txQ[num]);
((struct wlprivate_data *)(wlpptr->wlpd_p))->fwDescCnt[num] =0;
if (((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[num].pTxRing != NULL)
{
for (currDescr = 0; currDescr < MAX_NUM_TX_DESC; currDescr++)
{
CURR_TXD(num).Status = ENDIAN_SWAP32(EAGLE_TXD_STATUS_IDLE);
CURR_TXD(num).pNext = &NEXT_TXD(num);
CURR_TXD(num).pPhysNext =
ENDIAN_SWAP32((u_int32_t) ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[num].pPhysTxRing +
((currDescr+1)*sizeof(wltxdesc_t)));
WLDBG_INFO(DBG_LEVEL_12,
"txdesc: %i status: 0x%x (%i) vnext: 0x%p pnext: 0x%x",
currDescr, EAGLE_TXD_STATUS_IDLE, EAGLE_TXD_STATUS_IDLE,
CURR_TXD(num).pNext, ENDIAN_SWAP32(CURR_TXD(num).pPhysNext));
}
LAST_TXD(num).pNext = &FIRST_TXD(num);
LAST_TXD(num).pPhysNext =
ENDIAN_SWAP32((u_int32_t) ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[num].pPhysTxRing);
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[num].pStaleTxDesc = &FIRST_TXD(num);
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[num].pNextTxDesc = &FIRST_TXD(num);
WLDBG_EXIT_INFO(DBG_LEVEL_12,
"last txdesc vnext: 0x%p pnext: 0x%x pstale 0x%x vfirst 0x%x",
LAST_TXD(num).pNext, ENDIAN_SWAP32(LAST_TXD(num).pPhysNext),
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[num].pStaleTxDesc, ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[num].pNextTxDesc);
}
else
{
WLDBG_ERROR(DBG_LEVEL_12, "no valid TX mem");
return FAIL;
}
}
return SUCCESS;
}
void wlTxRingCleanup(struct net_device *netdev)
{
struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, netdev);
int cleanedTxDescr = 0;
int currDescr;
int num;
WLDBG_ENTER(DBG_LEVEL_12);
for(num =0; num < NUM_OF_DESCRIPTOR_DATA; num++)
{
QUEUE_PURGE(&((struct wlprivate_data *)(wlpptr->wlpd_p))->txQ[num]);
((struct wlprivate_data *)(wlpptr->wlpd_p))->fwDescCnt[num] =0;
if (((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[num].pTxRing != NULL)
{
for (currDescr = 0; currDescr < MAX_NUM_TX_DESC; currDescr++)
{
if (CURR_TXD(num).pSkBuff != NULL)
{
WLDBG_INFO(DBG_LEVEL_12,
"unmapped and free'd txdesc %i vaddr: 0x%p paddr: 0x%x",
currDescr, CURR_TXD(num).pSkBuff->data,
ENDIAN_SWAP32(CURR_TXD(num).PktPtr));
pci_unmap_single(wlpptr->pPciDev,
ENDIAN_SWAP32(CURR_TXD(num).PktPtr),
CURR_TXD(num).pSkBuff->len,
PCI_DMA_TODEVICE);
{
WL_SKB_FREE(CURR_TXD(num).pSkBuff);
}
CURR_TXD(num).Status = ENDIAN_SWAP32(EAGLE_TXD_STATUS_IDLE);
CURR_TXD(num).pSkBuff = NULL;
CURR_TXD(num).PktPtr = 0;
CURR_TXD(num).PktLen = 0;
cleanedTxDescr++;
}
}
}
}
WLDBG_EXIT_INFO(DBG_LEVEL_12, "cleaned %i TX descr", cleanedTxDescr);
}
void wlRxRingCleanup(struct net_device *netdev)
{
struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, netdev);
int currDescr;
WLDBG_ENTER(DBG_LEVEL_12);
if (((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pRxRing != NULL)
{
for (currDescr = 0; currDescr < MAX_NUM_RX_DESC; currDescr++)
{
if (CURR_RXD.pSkBuff != NULL)
{
if (skb_shinfo(CURR_RXD.pSkBuff)->nr_frags)
{
skb_shinfo(CURR_RXD.pSkBuff)->nr_frags = 0;
}
if (skb_shinfo(CURR_RXD.pSkBuff)->frag_list)
{
skb_shinfo(CURR_RXD.pSkBuff)->frag_list = NULL;
}
pci_unmap_single(wlpptr->pPciDev,
ENDIAN_SWAP32(CURR_RXD.pPhysBuffData),
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize,
PCI_DMA_FROMDEVICE);
WL_SKB_FREE(CURR_RXD.pSkBuff);
WLDBG_INFO(DBG_LEVEL_12,
"unmapped+free'd rxdesc %i vaddr: 0x%p paddr: 0x%x len: %i",
currDescr, CURR_RXD.pBuffData,
ENDIAN_SWAP32(CURR_RXD.pPhysBuffData),
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize);
CURR_RXD.pBuffData = NULL;
CURR_RXD.pSkBuff = NULL;
}
}
}
WLDBG_EXIT(DBG_LEVEL_12);
}
static void mwl_rx_ring_cleanup(struct mwl_priv *priv)
{
int curr_desc;
WLDBG_ENTER(DBG_LEVEL_4);
BUG_ON(!priv);
if (priv->desc_data[0].prx_ring != NULL) {
for (curr_desc = 0; curr_desc < SYSADPT_MAX_NUM_RX_DESC; curr_desc++) {
if (CURR_RXD.psk_buff != NULL) {
if (skb_shinfo(CURR_RXD.psk_buff)->nr_frags)
skb_shinfo(CURR_RXD.psk_buff)->nr_frags = 0;
if (skb_shinfo(CURR_RXD.psk_buff)->frag_list)
skb_shinfo(CURR_RXD.psk_buff)->frag_list = NULL;
pci_unmap_single(priv->pdev,
ENDIAN_SWAP32(CURR_RXD.pphys_buff_data),
priv->desc_data[0].rx_buf_size,
PCI_DMA_FROMDEVICE);
dev_kfree_skb_any(CURR_RXD.psk_buff);
WLDBG_INFO(DBG_LEVEL_4,
"unmapped+free'd rxdesc %i vaddr: 0x%p paddr: 0x%x len: %i",
curr_desc, CURR_RXD.pbuff_data,
ENDIAN_SWAP32(CURR_RXD.pphys_buff_data),
priv->desc_data[0].rx_buf_size);
CURR_RXD.pbuff_data = NULL;
CURR_RXD.psk_buff = NULL;
}
}
}
WLDBG_EXIT(DBG_LEVEL_4);
}
BOOLEAN UpdateCurrentChannelInMIB(vmacApInfo_t *vmacSta_p, UINT32 channel)
{
MIB_802DOT11 *mib = vmacSta_p->ShadowMib802dot11;
MIB_PHY_DSSS_TABLE *PhyDSSSTable=mib->PhyDSSSTable;
UINT8 *mib_extSubCh_p = mib->mib_extSubCh;
if(domainChannelValid(channel, channel <= 14?FREQ_BAND_2DOT4GHZ:FREQ_BAND_5GHZ))
{
PhyDSSSTable->CurrChan = channel;
/* Currentlly, 40M is not supported for channel 14 */
if (PhyDSSSTable->CurrChan == 14)
{
if ((PhyDSSSTable->Chanflag.ChnlWidth == CH_AUTO_WIDTH) ||
(PhyDSSSTable->Chanflag.ChnlWidth == CH_40_MHz_WIDTH))
PhyDSSSTable->Chanflag.ChnlWidth = CH_20_MHz_WIDTH;
}
//PhyDSSSTable->Chanflag.ChnlWidth=CH_40_MHz_WIDTH;
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
if(((PhyDSSSTable->Chanflag.ChnlWidth==CH_40_MHz_WIDTH) ||
(PhyDSSSTable->Chanflag.ChnlWidth==CH_AUTO_WIDTH)))
{
switch(PhyDSSSTable->CurrChan)
{
case 1:
case 2:
case 3:
case 4:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 5:
if(*mib_extSubCh_p==0)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
else if(*mib_extSubCh_p==1)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
else if(*mib_extSubCh_p==2)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 6:
case 7:
case 8:
case 9:
case 10:
if(*mib_extSubCh_p==0)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
else if(*mib_extSubCh_p==1)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
else if(*mib_extSubCh_p==2)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 11:
case 12:
case 13:
case 14:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
/* for 5G */
case 36:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 40:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 44:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 48:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 52:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 56:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 60:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 64:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 100:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 104:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 108:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 112:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 116:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 120:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 124:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 128:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 132:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 136:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 140:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 149:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 153:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 157:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 161:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
default:
break;
}
}
if(PhyDSSSTable->CurrChan<=14)
PhyDSSSTable->Chanflag.FreqBand=FREQ_BAND_2DOT4GHZ;
else
PhyDSSSTable->Chanflag.FreqBand=FREQ_BAND_5GHZ;
}else
{
WLDBG_INFO(DBG_LEVEL_15, "invalid channel %d\n", channel);
return FALSE;
}
wlFwApplyChannelSettings(vmacSta_p->dev);
return TRUE;
}
/*************************************************************************
* Function:
*
* Description:
*
* Input:
*
* Output:
*
**************************************************************************/
extern SINT8 evtSmeCmdMsg(vmacApInfo_t *vmacSta_p,UINT8 *message)
{
MhsmEvent_t smMsg;
macmgmtQ_SmeCmd_t * smeCmd_p;
extStaDb_StaInfo_t *StaInfo_p;
WLDBG_ENTER(DBG_CLASS_INFO);
if (message == NULL)
{
return 1;
}
#ifdef AP_MAC_LINUX
smMsg.devinfo = (void *) vmacSta_p;
#endif
smeCmd_p = (macmgmtQ_SmeCmd_t *)message;
switch (smeCmd_p->CmdType)
{
case SME_CMD_DISASSOCIATE:
{
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SME_CMD_DISASSOCIATE message received. \n");
if ((StaInfo_p = extStaDb_GetStaInfo(vmacSta_p,&smeCmd_p->Body.AssocCmd.PeerStaAddr, 1)) == NULL)
{
return 1;
}
smMsg.event = MlmeDisAssoc_Req;
smMsg.pBody = (UINT8 *)&(smeCmd_p->Body.AssocCmd);
mhsm_send_event((Mhsm_t *)&StaInfo_p->mgtAssoc.super, &smMsg);
}
break;
case SME_CMD_START:
{
SyncSrvApMsg syncMsg;
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SME_CMD_START message received. \n");
syncMsg.opMode = infrastructure;
syncMsg.mgtMsg = (UINT8 *)&(smeCmd_p->Body.StartCmd);
smMsg.event = MlmeStart_Req;
smMsg.pBody = (unsigned char *)&syncMsg;
mhsm_send_event((Mhsm_t *)&vmacSta_p->mgtSync.super, &smMsg);
}
break;
case SME_CMD_RESET:
{
SyncSrvApMsg syncMsg;
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SME_CMD_RESET message received. \n");
syncMsg.mgtMsg = (UINT8 *)&(smeCmd_p->Body.ResetCmd);
smMsg.event = ResetMAC;
smMsg.pBody = (unsigned char *)&syncMsg;
mhsm_send_event((Mhsm_t *)&vmacSta_p->mgtSync.super, &smMsg);
}
break;
#if defined(AP_SITE_SURVEY) || defined(AUTOCHANNEL)
case SME_CMD_SCAN:
{
SyncSrvApMsg syncMsg;
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SME_CMD_SCAN message received. \n");
syncMsg.mgtMsg = (UINT8 *)&(smeCmd_p->Body.ScanCmd);
smMsg.event = MlmeScan_Req;
smMsg.pBody = (unsigned char *)&syncMsg;
mhsm_send_event((Mhsm_t *)&vmacSta_p->mgtSync.super, &smMsg);
}
break;
#endif /* AP_SITE_SURVEY */
#ifdef IEEE80211H
case SME_CMD_MREQUEST:
{
SyncSrvApMsg syncMsg;
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SME_CMD_MREQUEST message received. \n");
if (!IS_BROADCAST(&smeCmd_p->Body.MrequestCmd.PeerStaAddr))
{
if ((StaInfo_p = extStaDb_GetStaInfo(vmacSta_p,&smeCmd_p->Body.MrequestCmd.PeerStaAddr, 1)) == NULL)
{
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SME_CMD_MREQUEST - no station found %x:%x:%x:%x:%x:%x] \n",
smeCmd_p->Body.MrequestCmd.PeerStaAddr[0],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[1],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[2],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[3],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[4],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[5]);
return 1;
}
}
syncMsg.mgtMsg = (UINT8 *)&(smeCmd_p->Body.MrequestCmd);
smMsg.event = MlmeMrequest_Req;
smMsg.pBody = (unsigned char *)&syncMsg;
mhsm_send_event((Mhsm_t *)&vmacSta_p->mgtSync.super, &smMsg);
}
break;
case SME_CMD_MREPORT:
{
SyncSrvApMsg syncMsg;
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SME_CMD_MREPORT message received. \n");
if ((StaInfo_p = extStaDb_GetStaInfo(vmacSta_p,&smeCmd_p->Body.MrequestCmd.PeerStaAddr, 1)) == NULL)
{
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SME_CMD_MREPORT - no station found %x:%x:%x:%x:%x:%x] \n",
smeCmd_p->Body.MrequestCmd.PeerStaAddr[0],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[1],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[2],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[3],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[4],
smeCmd_p->Body.MrequestCmd.PeerStaAddr[5]);
return 1;
}
syncMsg.mgtMsg = (UINT8 *)&(smeCmd_p->Body.MreportCmd);
smMsg.event = MlmeMreport_Req;
smMsg.pBody = (unsigned char *)&syncMsg;
mhsm_send_event((Mhsm_t *)&vmacSta_p->mgtSync.super, &smMsg);
}
break;
case SMC_CMD_CHANNELSWITCH_REQ:
{
SyncSrvApMsg syncMsg;
WLDBG_INFO(DBG_LEVEL_11, "evtSmeCmdMsg: SMC_CMD_CHANNELSWITCH_REQ message received. \n");
syncMsg.mgtMsg = (UINT8 *)&(smeCmd_p->Body.ChannelSwitchCmd);
smMsg.event = MlmeChannelSwitch_Req;
smMsg.pBody = (unsigned char *)&syncMsg;
mhsm_send_event((Mhsm_t *)&vmacSta_p->mgtSync.super, &smMsg);
}
break;
#endif /* IEEE80211H */
default:
break;
}
WLDBG_EXIT(DBG_CLASS_INFO);
return 0;
}
extern SINT8 evtDot11MgtMsg(vmacApInfo_t *vmacSta_p,UINT8 *message, struct sk_buff *skb)
#endif
{
MIB_AUTH_ALG *mib_AuthAlg_p=vmacSta_p->Mib802dot11->AuthAlg;
MhsmEvent_t smMsg;
macmgmtQ_MgmtMsg3_t *MgmtMsg_p;
extStaDb_StaInfo_t *StaInfo_p;
if (message == NULL)
{
return 1;
}
WLDBG_ENTER(DBG_LEVEL_11);
MgmtMsg_p = (macmgmtQ_MgmtMsg3_t *)message;
#ifdef FILTER_BSSID
if ( ( memcmp(MgmtMsg_p->Hdr.DestAddr, vmacSta_p->macStaAddr,sizeof(IEEEtypes_MacAddr_t)) ||
memcmp(MgmtMsg_p->Hdr.BssId, vmacSta_p->macBssId,sizeof(IEEEtypes_MacAddr_t)) )
&& ( MgmtMsg_p->Hdr.FrmCtl.Subtype != IEEE_MSG_PROBE_RQST ) )
#else
if (memcmp(MgmtMsg_p->Hdr.DestAddr, vmacSta_p->macStaAddr,sizeof(IEEEtypes_MacAddr_t)) &&
memcmp(MgmtMsg_p->Hdr.DestAddr, vmacSta_p->macStaAddr2,sizeof(IEEEtypes_MacAddr_t)) &&
(MgmtMsg_p->Hdr.FrmCtl.Subtype != IEEE_MSG_PROBE_RQST) )
#endif
{
WLDBG_ENTER_INFO(DBG_LEVEL_11,"mgt frame %d rxved %2x-%2x-%2x-%2x-%2x-%2x\n",MgmtMsg_p->Hdr.FrmCtl.Subtype,
MgmtMsg_p->Hdr.DestAddr[0],
MgmtMsg_p->Hdr.DestAddr[1],
MgmtMsg_p->Hdr.DestAddr[2],
MgmtMsg_p->Hdr.DestAddr[3],
MgmtMsg_p->Hdr.DestAddr[4],
MgmtMsg_p->Hdr.DestAddr[5]);
return 1;
}
if (isMacAccessList(vmacSta_p, &(MgmtMsg_p->Hdr.SrcAddr)) != SUCCESS)
{
return 1;
}
if ((StaInfo_p = extStaDb_GetStaInfo(vmacSta_p,&MgmtMsg_p->Hdr.SrcAddr, 0)) == NULL)
{
if(MgmtMsg_p->Hdr.FrmCtl.Subtype == IEEE_MSG_AUTHENTICATE)
{
//added call to check other VAP's StaInfo_p
if ((StaInfo_p = extStaDb_GetStaInfo(vmacSta_p,&MgmtMsg_p->Hdr.SrcAddr, 2)))
{
macMgmtRemoveSta(vmacSta_p, StaInfo_p);
}
if ((StaInfo_p = macMgtStaDbInit(vmacSta_p,&MgmtMsg_p->Hdr.SrcAddr,&MgmtMsg_p->Hdr.DestAddr)) == NULL)
{
WLDBG_ENTER_INFO(DBG_LEVEL_11,"init data base fail\n");
return 1;
}
}
else if ((MgmtMsg_p->Hdr.FrmCtl.Subtype != IEEE_MSG_PROBE_RQST))
{
if ((MgmtMsg_p->Hdr.FrmCtl.Subtype != IEEE_MSG_DEAUTHENTICATE) &&
(MgmtMsg_p->Hdr.FrmCtl.Subtype != IEEE_MSG_PROBE_RSP) )
{
macMgmtMlme_SendDeauthenticateMsg(vmacSta_p,&MgmtMsg_p->Hdr.SrcAddr,
0,
IEEEtypes_REASON_CLASS2_NONAUTH);
}
return 1;
}
}
#ifdef AP_MAC_LINUX
smMsg.devinfo = (void *) vmacSta_p;
#endif
switch (MgmtMsg_p->Hdr.FrmCtl.Subtype)
{
case IEEE_MSG_AUTHENTICATE:
{
AuthRspSrvApMsg authRspMsg;
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_AUTHENTICATE message received. \n");
memcpy(authRspMsg.rspMac, MgmtMsg_p->Hdr.SrcAddr, 6);
authRspMsg.arAlg_in = MgmtMsg_p->Body.Auth.AuthAlg;
{
if (mib_AuthAlg_p->Type == AUTH_OPEN_OR_SHARED_KEY)
{
authRspMsg.arAlg = authRspMsg.arAlg_in;
}
else
{
authRspMsg.arAlg = mib_AuthAlg_p->Type;
}
}
authRspMsg.mgtMsg = (UINT8 *)MgmtMsg_p;
smMsg.event = AuthOdd;
smMsg.pBody = (unsigned char *)&authRspMsg;
#ifdef AP_MAC_LINUX
smMsg.info = (void *) skb;
#endif
mhsm_send_event((Mhsm_t *)&StaInfo_p->mgtAuthRsp.super, &smMsg);
}
break;
case IEEE_MSG_ASSOCIATE_RQST:
{
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_ASSOCIATE_RQST message received. \n");
smMsg.event = AssocReq;
smMsg.pBody = (unsigned char *)MgmtMsg_p;
#ifdef AP_MAC_LINUX
smMsg.info = (void *) skb;
#endif
mhsm_send_event((Mhsm_t *)&StaInfo_p->mgtAssoc.super,&smMsg);
}
break;
case IEEE_MSG_REASSOCIATE_RQST:
{
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_REASSOCIATE_RQST message received. \n");
smMsg.event = ReAssocReq;
smMsg.pBody = (unsigned char *)MgmtMsg_p;
#ifdef AP_MAC_LINUX
smMsg.info = (void *) skb;
#endif
mhsm_send_event((Mhsm_t *)&StaInfo_p->mgtAssoc.super, &smMsg);
}
break;
case IEEE_MSG_DISASSOCIATE:
{
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_DISASSOCIATE message received. \n");
smMsg.event = DisAssoc;
smMsg.pBody = (unsigned char *)MgmtMsg_p;
#ifdef AP_MAC_LINUX
smMsg.info = (void *) skb;
#endif
mhsm_send_event((Mhsm_t *)&StaInfo_p->mgtAssoc.super, &smMsg);
}
break;
case IEEE_MSG_DEAUTHENTICATE:
{
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_DEAUTHENTICATE message received. \n");
smMsg.event = DeAuth;
smMsg.pBody = (unsigned char *)MgmtMsg_p;
#ifdef AP_MAC_LINUX
smMsg.info = (void *) skb;
#endif
mhsm_send_event((Mhsm_t *)&StaInfo_p->mgtAuthRsp.super, &smMsg);
}
break;
/* Could be handled by HW */
case IEEE_MSG_PROBE_RQST:
{
SyncSrvApMsg syncMsg;
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_PROBE_RQST message received. \n");
syncMsg.opMode = infrastructure;
syncMsg.mgtMsg = (UINT8 *)MgmtMsg_p;
smMsg.event = ProbeReq;
smMsg.pBody = (unsigned char *)&syncMsg;
#ifdef AP_MAC_LINUX
smMsg.info = (void *) skb;
#endif
mhsm_send_event((Mhsm_t *)&vmacSta_p->mgtSync.super, &smMsg);
}
break;
#if defined(QOS_FEATURE)||defined(IEEE80211H)
case IEEE_MSG_QOS_ACTION:
{
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_QOS_ACTION message received. \n");
if(MgmtMsg_p->Body.Action.Category == HT_CATEGORY)
{
switch (MgmtMsg_p->Body.Action.Action)
{
case ACTION_SMPS:
{
extern int wlFwSetMimoPsHt(struct net_device *netdev, UINT8 *addr, UINT8 enable, UINT8 mode);
IEEEtypes_SM_PwrCtl_t *p = (IEEEtypes_SM_PwrCtl_t *)&MgmtMsg_p->Body.Act.Field.SmPwrCtl;
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_QOS_ACTION MIMO PS HT message received. \n");
wlFwSetMimoPsHt(vmacSta_p->dev, (UINT8 *)MgmtMsg_p->Hdr.SrcAddr, p->Enable, p->Mode);
break;
}
#ifdef INTOLERANT40
case ACTION_INFOEXCH:
{
extern void RecHTIntolerant(vmacApInfo_t *vmacSta_p,UINT8 enable);
IEEEtypes_InfoExch_t *p = (IEEEtypes_InfoExch_t *)&MgmtMsg_p->Body.Act.Field.InfoExch;
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_QOS_ACTION Info Exch HT message received. \n");
RecHTIntolerant(vmacSta_p,p->FortyMIntolerant);
break;
}
#endif //#ifdef INTOLERANT40
default:
break;
}
break;
}
#ifdef IEEE80211H
if(TRUE == macMgmtMlme_80211hAct(vmacSta_p,(macmgmtQ_MgmtMsg3_t *) MgmtMsg_p)) /* if it's mine frame, then return true */
break;
#endif /* IEEE80211H */
#ifdef COEXIST_20_40_SUPPORT
if(TRUE == macMgmtMlme_80211PublicAction(vmacSta_p,(macmgmtQ_MgmtMsg3_t *) MgmtMsg_p)) /* if it's mine frame, then return true */
break;
#endif
#ifdef QOS_FEATURE
/*smMsg.event = QoSAction;
smMsg.pBody = MgmtMsg_p;
mhsm_send_event((Mhsm_t *)&wlpptr->vmacSta_p->mgtSync.super, &smMsg);*/
macMgmtMlme_QoSAct(vmacSta_p,(macmgmtQ_MgmtMsg3_t *) MgmtMsg_p);
break;
#endif /* QOS_FEATURE */
}
#endif
default:
break;
}
WLDBG_EXIT(DBG_LEVEL_11);
return 0;
}
void receiveWlanMsg(struct net_device *dev, struct sk_buff *skb, UINT32 rssi, BOOLEAN stationpacket)
{
struct wlprivate *priv = NETDEV_PRIV_P(struct wlprivate, dev);
vmacApInfo_t *vmacSta_p = priv->vmacSta_p;
// MIB_802DOT11 *mib=vmacSta_p->Mib802dot11;
// macmgmtQ_SmeCmd_t *SmeCmd_p;
// struct sk_buff *mgmtBuff_p;
IEEEtypes_Frame_t *wlanMsg_p;
wlanMsg_p = (IEEEtypes_Frame_t *) ((UINT8 *)skb->data -2);
wlanMsg_p->Hdr.FrmBodyLen = skb->len;
#ifdef SOC_W8764
dispTxBf((macmgmtQ_MgmtMsg3_t *)wlanMsg_p);
#endif
switch (wlanMsg_p->Hdr.FrmCtl.Type)
{
case IEEE_TYPE_DATA:
break;
case IEEE_TYPE_MANAGEMENT:
{
WLDBG_INFO(DBG_LEVEL_11, "IEEE_TYPE_MANAGEMENT message received. \n");
switch (wlanMsg_p->Hdr.FrmCtl.Subtype)
{
case 0xf: //fw debug type
printk("FW: %s\n", (UINT8 *)((UINT32)wlanMsg_p+6));
/*WLDBG_INFO(DBG_LEVEL_11,"%s\n", (UINT8 *)((UINT32)wlanMsg_p+2+sizeof(IEEEtypes_MgmtHdr2_t)));*/
break;
#ifndef INTEROP
case IEEE_MSG_QOS_ACTION:
WLDBG_INFO(DBG_LEVEL_11, "IEEE_MSG_QOS_ACTION message received. \n");
break;
#endif
case IEEE_MSG_PROBE_RQST:
macMgmtMlme_ProbeRqst(vmacSta_p,(macmgmtQ_MgmtMsg3_t *)wlanMsg_p);
break;
#ifdef CLIENT_SUPPORT
/* Intercept beacon here for AP.
* Client beacon will be handled later.
*/
case IEEE_MSG_BEACON:
RxBeacon(vmacSta_p,wlanMsg_p, skb->len);
#endif //CLIENT_SUPPORT
default:
/* 802.11 Management frame::feed MLME State Machines */
#ifdef CLIENT_SUPPORT
{
#define SK_BUF_RESERVED_PAD 6
if(stationpacket)
{
vmacEntry_t *targetVMacEntry_p = NULL;
IEEEtypes_MgmtHdr_t *Hdr_p;
if( (wlanMsg_p->Hdr.FrmCtl.Subtype == IEEE_MSG_BEACON )
|| (wlanMsg_p->Hdr.FrmCtl.Subtype == IEEE_MSG_QOS_ACTION ))
{
targetVMacEntry_p = sme_GetParentVMacEntry(vmacSta_p->VMacEntry.phyHwMacIndx) ;
}
else
{
targetVMacEntry_p = vmacGetVMacEntryByAddr((UINT8 *)&wlanMsg_p->Hdr.Addr1) ;
}
if( targetVMacEntry_p )
{
curRxInfo_g.RSSI = (UINT8)rssi;
//printk("****** client process dot11 rssi=%d\n",curRxInfo_g.RSSI);
//skb_push(skb, SK_BUF_RESERVED_PAD);
skb_push(skb, 2); /* For UINT16 FrmBodyLen */
Hdr_p = (IEEEtypes_MgmtHdr_t *)(skb->data);
Hdr_p->FrmBodyLen = skb->len;
skb_push(skb, 4); /* For UINT32 priv_p pointer */
targetVMacEntry_p->dot11MsgEvt(skb->data, (UINT8 *)&curRxInfo_g, targetVMacEntry_p->info_p);
skb_pull(skb, SK_BUF_RESERVED_PAD);
}
}
else
{
evtDot11MgtMsg(vmacSta_p,(UINT8 *)wlanMsg_p, skb);
}
}
#else /* CLIENT_SUPPORT */
evtDot11MgtMsg(vmacSta_p,(UINT8 *)wlanMsg_p, skb);
#endif /* CLIENT_SUPPORT */
break;
}
break;
}
case IEEE_TYPE_CONTROL:
{
WLDBG_INFO(DBG_LEVEL_11, "IEEE_TYPE_CONTROL message received. \n");
{
switch (wlanMsg_p->Hdr.FrmCtl.Subtype)
{
case PS_POLL:
case RTS:
case CTS:
case ACK:
case CF_END:
case CF_END_CF_ACK:
break;
default:
break;
}
} /* end if */
break;
}
default:
/* Uknown Type */
break;
}
dev_kfree_skb_any(skb);
}
int wlRxRingInit(struct net_device *netdev)
{
struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, netdev);
int currDescr;
WLDBG_ENTER_INFO(DBG_LEVEL_12, "initializing %i descriptors", MAX_NUM_RX_DESC);
if (((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pRxRing != NULL)
{
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize = MAX_AGGR_SIZE;
for (currDescr = 0; currDescr < MAX_NUM_RX_DESC; currDescr++)
{
CURR_RXD.pSkBuff = dev_alloc_skb(((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize);
if(skb_linearize(CURR_RXD.pSkBuff))
{
WL_SKB_FREE(CURR_RXD.pSkBuff);
printk(KERN_ERR "%s: Need linearize memory\n", netdev->name);
return FAIL;
}
skb_reserve(CURR_RXD.pSkBuff , MIN_BYTES_HEADROOM);
CURR_RXD.RxControl = EAGLE_RXD_CTRL_DRIVER_OWN;
CURR_RXD.Status = EAGLE_RXD_STATUS_OK;
CURR_RXD.QosCtrl = 0x0000;
CURR_RXD.Channel = 0x00;
CURR_RXD.RSSI = 0x00;
CURR_RXD.SQ2 = 0x00;
if (CURR_RXD.pSkBuff != NULL)
{
CURR_RXD.PktLen = 6*netdev->mtu + NUM_EXTRA_RX_BYTES;
CURR_RXD.pBuffData = CURR_RXD.pSkBuff->data;
CURR_RXD.pPhysBuffData =
ENDIAN_SWAP32(pci_map_single(wlpptr->pPciDev,
CURR_RXD.pSkBuff->data,
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize,
PCI_DMA_FROMDEVICE));
CURR_RXD.pNext = &NEXT_RXD;
CURR_RXD.pPhysNext =
ENDIAN_SWAP32((u_int32_t) ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pPhysRxRing +
((currDescr+1)*sizeof(wlrxdesc_t)));
WLDBG_INFO(DBG_LEVEL_12,
"rxdesc: %i status: 0x%x (%i) len: 0x%x (%i)",
currDescr, EAGLE_TXD_STATUS_IDLE, EAGLE_TXD_STATUS_IDLE,
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize, ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize);
WLDBG_INFO(DBG_LEVEL_12,
"rxdesc: %i vnext: 0x%p pnext: 0x%x", currDescr,
CURR_RXD.pNext, ENDIAN_SWAP32(CURR_RXD.pPhysNext));
} else
{
WLDBG_ERROR(DBG_LEVEL_12,
"rxdesc %i: no skbuff available", currDescr);
return FAIL;
}
}
LAST_RXD.pPhysNext =
ENDIAN_SWAP32((u_int32_t) ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pPhysRxRing);
LAST_RXD.pNext = &FIRST_RXD;
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pNextRxDesc = &FIRST_RXD;
WLDBG_EXIT_INFO(DBG_LEVEL_12,
"last rxdesc vnext: 0x%p pnext: 0x%x vfirst 0x%x",
LAST_RXD.pNext, ENDIAN_SWAP32(LAST_RXD.pPhysNext),
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pNextRxDesc);
return SUCCESS;
}
WLDBG_ERROR(DBG_LEVEL_12, "no valid RX mem");
return FAIL;
}
void wlRecv(struct net_device *netdev)
{
struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, netdev);
int work_done = 0;
wlrxdesc_t *pCurrent = ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pNextRxDesc;
static Bool_e isFunctionBusy = WL_FALSE;
int receivedHandled = 0;
u_int32_t rxRdPtr;
u_int32_t rxWrPtr;
struct sk_buff *pRxSkBuff=NULL;
WL_BUFF *wlb = NULL;
void *pCurrentData;
u_int8_t rxRate;
int rxCount;
int rssi;
vmacApInfo_t *vmacSta_p = wlpptr->vmacSta_p;
u_int32_t status;
u_int32_t rssi_paths;
WLDBG_ENTER(DBG_LEVEL_14);
/* In a corner case the descriptors may be uninitialized and not usable, accessing these may cause a crash */
if (isFunctionBusy || (pCurrent == NULL))
{
return;
}
isFunctionBusy = WL_TRUE;
rxRdPtr = readl(wlpptr->ioBase0 + ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxDescRead);
rxWrPtr = readl(wlpptr->ioBase0 + ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxDescWrite);
while ((pCurrent->RxControl ==EAGLE_RXD_CTRL_DMA_OWN)
&& (work_done < vmacSta_p->work_to_do)
)
{
/* AUTOCHANNEL */
{
if(vmacSta_p->StopTraffic)
goto out;
} /* AUTOCHANNEL */
rxCount = ENDIAN_SWAP16(pCurrent->PktLen);
pRxSkBuff = pCurrent->pSkBuff;
if (pRxSkBuff == NULL)
{
goto out;
}
pci_unmap_single(wlpptr->pPciDev,
ENDIAN_SWAP32(pCurrent->pPhysBuffData),
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize,
PCI_DMA_FROMDEVICE);
pCurrentData = pCurrent->pBuffData;
rxRate = pCurrent->Rate;
status = (u_int32_t)pCurrent->Status;
pRxSkBuff->protocol = 0;
if(pCurrent->QosCtrl & IEEE_QOS_CTL_AMSDU)
{
pRxSkBuff->protocol |= WL_WLAN_TYPE_AMSDU;
}
rssi = (int)pCurrent->RSSI + W836X_RSSI_OFFSET;
rssi_paths = *((u_int32_t *)&pCurrent->HwRssiInfo);
if (skb_tailroom(pRxSkBuff) >= rxCount)
{
skb_put(pRxSkBuff, rxCount );
skb_pull(pRxSkBuff, 2);
}
else
{
WLDBG_INFO(DBG_LEVEL_14,"Not enough tail room =%x recvlen=%x, pCurrent=%x, pCurrentData=%x", WL_BUFF_TAILROOM(pRxSkBuff), rxCount,pCurrent, pCurrentData);
WL_SKB_FREE(pRxSkBuff);
goto out;
}
wlpptr->netDevStats->rx_packets++;
wlb = WL_BUFF_PTR(pRxSkBuff);
WL_PREPARE_BUF_INFO(pRxSkBuff);
if(pCurrent->HtSig2 & 0x8 )
{
u_int8_t ampdu_qos;
/** use bit 3 for ampdu flag, and 0,1,2,3 for qos so as to save a register **/
ampdu_qos = 8|(pCurrent->QosCtrl&0x7);
work_done+=ieee80211_input(wlpptr, wlb,rssi,rssi_paths,ampdu_qos,status);
}
else
{
u_int8_t ampdu_qos;
/** use bit 3 for ampdu flag, and 0,1,2,3 for qos so as to save a register **/
ampdu_qos = 0|(pCurrent->QosCtrl&0x7);
work_done+=ieee80211_input(wlpptr, wlb,rssi,rssi_paths,ampdu_qos,status);
}
wlpptr->netDevStats->rx_bytes += pRxSkBuff->len;
{
pCurrent->pSkBuff = dev_alloc_skb(((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize);
if (pCurrent->pSkBuff != NULL)
{
if(skb_linearize(pCurrent->pSkBuff))
{
WL_SKB_FREE(pCurrent->pSkBuff);
printk(KERN_ERR "%s: Need linearize memory\n", netdev->name);
goto out;
}
skb_reserve(pCurrent->pSkBuff , MIN_BYTES_HEADROOM);
pCurrent->Status = EAGLE_RXD_STATUS_OK;
pCurrent->QosCtrl = 0x0000;
pCurrent->Channel = 0x00;
pCurrent->RSSI = 0x00;
pCurrent->SQ2 = 0x00;
pCurrent->PktLen = 6*netdev->mtu + NUM_EXTRA_RX_BYTES;
pCurrent->pBuffData = pCurrent->pSkBuff->data;
pCurrent->pPhysBuffData =
ENDIAN_SWAP32(pci_map_single(wlpptr->pPciDev,
pCurrent->pSkBuff->data,
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxBufSize/*+sizeof(struct skb_shared_info)*/,
PCI_DMA_BIDIRECTIONAL));
}
}
out:
receivedHandled++;
pCurrent->RxControl = EAGLE_RXD_CTRL_DRIVER_OWN;
pCurrent->QosCtrl =0;
rxRdPtr = ENDIAN_SWAP32(pCurrent->pPhysNext);
pCurrent = pCurrent->pNext;
}
writel(rxRdPtr, wlpptr->ioBase0 + ((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].rxDescRead);
((struct wlprivate_data *)(wlpptr->wlpd_p))->descData[0].pNextRxDesc = pCurrent;
isFunctionBusy = WL_FALSE;
WLDBG_EXIT(DBG_LEVEL_14);
}
static int mwl_rx_ring_init(struct mwl_priv *priv)
{
int curr_desc;
WLDBG_ENTER_INFO(DBG_LEVEL_4, "initializing %i descriptors", SYSADPT_MAX_NUM_RX_DESC);
if (priv->desc_data[0].prx_ring != NULL) {
priv->desc_data[0].rx_buf_size = SYSADPT_MAX_AGGR_SIZE;
for (curr_desc = 0; curr_desc < SYSADPT_MAX_NUM_RX_DESC; curr_desc++) {
CURR_RXD.psk_buff = dev_alloc_skb(priv->desc_data[0].rx_buf_size);
if (skb_linearize(CURR_RXD.psk_buff)) {
dev_kfree_skb_any(CURR_RXD.psk_buff);
WLDBG_ERROR(DBG_LEVEL_4, "need linearize memory");
WLDBG_EXIT_INFO(DBG_LEVEL_4, "no suitable memory");
return -ENOMEM;
}
skb_reserve(CURR_RXD.psk_buff, SYSADPT_MIN_BYTES_HEADROOM);
CURR_RXD.rx_control = EAGLE_RXD_CTRL_DRIVER_OWN;
CURR_RXD.status = EAGLE_RXD_STATUS_OK;
CURR_RXD.qos_ctrl = 0x0000;
CURR_RXD.channel = 0x00;
CURR_RXD.rssi = 0x00;
if (CURR_RXD.psk_buff != NULL) {
CURR_RXD.pkt_len = SYSADPT_MAX_AGGR_SIZE;
CURR_RXD.pbuff_data = CURR_RXD.psk_buff->data;
CURR_RXD.pphys_buff_data =
ENDIAN_SWAP32(pci_map_single(priv->pdev,
CURR_RXD.psk_buff->data,
priv->desc_data[0].rx_buf_size,
PCI_DMA_FROMDEVICE));
CURR_RXD.pnext = &NEXT_RXD;
CURR_RXD.pphys_next =
ENDIAN_SWAP32((u32)priv->desc_data[0].pphys_rx_ring +
((curr_desc + 1) * sizeof(struct mwl_rx_desc)));
WLDBG_INFO(DBG_LEVEL_4,
"rxdesc: %i status: 0x%x (%i) len: 0x%x (%i)",
curr_desc, EAGLE_TXD_STATUS_IDLE, EAGLE_TXD_STATUS_IDLE,
priv->desc_data[0].rx_buf_size, priv->desc_data[0].rx_buf_size);
WLDBG_INFO(DBG_LEVEL_4,
"rxdesc: %i vnext: 0x%p pnext: 0x%x", curr_desc,
CURR_RXD.pnext, ENDIAN_SWAP32(CURR_RXD.pphys_next));
} else {
WLDBG_ERROR(DBG_LEVEL_4,
"rxdesc %i: no skbuff available", curr_desc);
WLDBG_EXIT_INFO(DBG_LEVEL_4, "no socket buffer");
return -ENOMEM;
}
}
LAST_RXD.pphys_next =
ENDIAN_SWAP32((u32)priv->desc_data[0].pphys_rx_ring);
LAST_RXD.pnext = &FIRST_RXD;
priv->desc_data[0].pnext_rx_desc = &FIRST_RXD;
WLDBG_EXIT_INFO(DBG_LEVEL_4,
"last rxdesc vnext: 0x%p pnext: 0x%x vfirst 0x%x",
LAST_RXD.pnext, ENDIAN_SWAP32(LAST_RXD.pphys_next),
priv->desc_data[0].pnext_rx_desc);
return 0;
}
WLDBG_ERROR(DBG_LEVEL_4, "no valid RX mem");
WLDBG_EXIT_INFO(DBG_LEVEL_4, "no valid RX mem");
return -ENOMEM;
}
int wlset_mibChannel(vmacEntry_t *clientVMacEntry_p, UINT8 mib_STAMode)
{
int rc = 0;
//not sure the purpose of changing wdev0's mib, TODO
#ifndef MBSS
mibMaster = vmacSta_p->master->ShadowMib802dot11;
if ((mib_STAMode == CLIENT_MODE_N_5) || (mib_STAMode == CLIENT_MODE_A) ||(mib_STAMode == CLIENT_MODE_AUTO))
{
channel = 64;
*mibMaster->mib_ApMode = AP_MODE_AandN;
}
else
{
channel = 6;
*mibMaster->mib_ApMode = AP_MODE_BandGandN;
}
//#ifdef BRS_SUPPORT
ieee80211_reset_rate_mask(mibMaster);
#if 0
switch (*(mibMaster->mib_ApMode))
{
case AP_MODE_B_ONLY:
*(mibMaster->BssBasicRateMask) = MRVL_BSSBASICRATEMASK_B;
*(mibMaster->NotBssBasicRateMask) = MRVL_NOTBSSBASICRATEMASK_B;
break;
case AP_MODE_G_ONLY:
*(mibMaster->BssBasicRateMask) = MRVL_BSSBASICRATEMASK_G;
*(mibMaster->NotBssBasicRateMask) = MRVL_NOTBSSBASICRATEMASK_G;
break;
case AP_MODE_A_ONLY:
case AP_MODE_AandN:
case AP_MODE_5GHZ_N_ONLY:
*(mibMaster->BssBasicRateMask) = MRVL_BSSBASICRATEMASK_A;
*(mibMaster->NotBssBasicRateMask) = MRVL_NOTBSSBASICRATEMASK_A;
break;
case AP_MODE_N_ONLY:
case AP_MODE_MIXED:
default:
*(mibMaster->BssBasicRateMask) = MRVL_BSSBASICRATEMASK_BGN;
*(mibMaster->NotBssBasicRateMask) = MRVL_NOTBSSBASICRATEMASK_BGN;
break;
}
#endif
//#endif
if(domainChannelValid(channel, channel <= 14?FREQ_BAND_2DOT4GHZ:FREQ_BAND_5GHZ))
{
PhyDSSSTable->CurrChan = channel;
/* Currentlly, 40M is not supported for channel 14 */
if (PhyDSSSTable->CurrChan == 14)
{
if ((PhyDSSSTable->Chanflag.ChnlWidth == CH_AUTO_WIDTH) ||
(PhyDSSSTable->Chanflag.ChnlWidth == CH_40_MHz_WIDTH))
PhyDSSSTable->Chanflag.ChnlWidth = CH_20_MHz_WIDTH;
}
//PhyDSSSTable->Chanflag.ChnlWidth=CH_40_MHz_WIDTH;
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
if(((PhyDSSSTable->Chanflag.ChnlWidth==CH_40_MHz_WIDTH) || (PhyDSSSTable->Chanflag.ChnlWidth==CH_AUTO_WIDTH)))
{
switch(PhyDSSSTable->CurrChan)
{
case 1:
case 2:
case 3:
case 4:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 5:
/* Now AutoBW use 5-1 instead of 5-9 for wifi cert convenience*/
/*if(*mib_extSubCh_p==0)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
else if(*mib_extSubCh_p==1)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
else if(*mib_extSubCh_p==2)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;*/
case 6:
case 7:
case 8:
case 9:
case 10:
if(*mib_extSubCh_p==0)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
else if(*mib_extSubCh_p==1)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
else if(*mib_extSubCh_p==2)
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 11:
case 12:
case 13:
case 14:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
/* for 5G */
case 36:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 40:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 44:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 48:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 52:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 56:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 60:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 64:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 100:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 104:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 108:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 112:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 116:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 120:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 124:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 128:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 132:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 136:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 140:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 149:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 153:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
case 157:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_ABOVE_CTRL_CH;
break;
case 161:
PhyDSSSTable->Chanflag.ExtChnlOffset=EXT_CH_BELOW_CTRL_CH;
break;
}
}
if(PhyDSSSTable->CurrChan<=14)
PhyDSSSTable->Chanflag.FreqBand=FREQ_BAND_2DOT4GHZ;
else
PhyDSSSTable->Chanflag.FreqBand=FREQ_BAND_5GHZ;
}else
WLDBG_INFO(DBG_LEVEL_1, "invalid channel %d\n", channel);
#endif
return rc;
}
