static void SchCfgInit(const XPfw_Module_t *ModPtr, const u32 *CfgData, u32 Len)
{
/* Task every 5 seconds - For our convenience in manual testing */
fw_printf("Adding Task1 - Status: %d\n", XPfw_CoreScheduleTask(ModPtr, 5000U, PrintMsg1));
/* Every 10 seconds */
fw_printf("Adding Task2 - Status:%d\n", XPfw_CoreScheduleTask(ModPtr, 10000U, PrintMsg2));
}
static void RtcEventHandler(const XPfw_Module_t *ModPtr, u32 EventId)
{
fw_printf("MOD%d:EVENTID: %d\r\n", ModPtr->ModId, EventId);
//XPfw_CorePrintStats();
if (XPFW_EV_RTC_SECONDS == EventId) {
/* Ack the Int in RTC Module */
Xil_Out32(RTC_RTC_INT_STATUS, 1U);
fw_printf("RTC: %d \r\n", Xil_In32(RTC_CURRENT_TIME));
}
}
static void PmIpiHandler(const XPfw_Module_t *ModPtr, u32 IpiNum, u32 SrcMask)
{
u32 isrVal, isrClr, apiId;
XPfw_PmIpiStatus ipiStatus;
XStatus status;
switch (IpiNum) {
case 0:
isrVal = XPfw_Read32(IPI_PMU_0_ISR);
fw_printf("Received IPI Mask:0x%08x\r\n", isrVal);
ipiStatus = XPfw_PmCheckIpiRequest(isrVal, &apiId);
if (XPFW_PM_IPI_IS_PM_CALL == ipiStatus) {
/* Power management API processing */
status = XPfw_PmIpiHandler(isrVal, apiId, &isrClr);
if (XST_SUCCESS == status) {
/* Clear only irq for handled PM request */
XPfw_Write32(IPI_PMU_0_ISR, isrClr);
}
} else {
status = XST_NO_FEATURE;
fw_printf("MOD-%d: Non-PM IPI-%d call received\r\n", ModPtr->ModId, IpiNum);
}
if (XST_SUCCESS != status) {
/*
* Clear all irqs if something went wrong, to avoid
* system looping in interrupt handler because of error
*/
XPfw_Write32(IPI_PMU_0_ISR, isrVal);
fw_printf("ERROR #%d : IPI-%d\r\n", status, IpiNum);
}
break;
case 1:
isrVal = XPfw_Read32(IPI_PMU_1_ISR);
XPfw_Write32(IPI_PMU_1_ISR, isrVal);
break;
case 2:
isrVal = XPfw_Read32(IPI_PMU_2_ISR);
XPfw_Write32(IPI_PMU_2_ISR, isrVal);
break;
case 3:
isrVal = XPfw_Read32(IPI_PMU_3_ISR);
XPfw_Write32(IPI_PMU_3_ISR, isrVal);
break;
default:
fw_printf("ERROR: Invalid IPI Number: %d\r\n", IpiNum);
}
}
void mlme_dump_data(UINT8 *data, UINT32 data_len)
{
int i;
for (i=0; i<data_len; i++)
{
fw_printf(MLME_DBG_LEVEL1,"%02x", data[i]);
fw_printf(MLME_DBG_LEVEL1," ");
if ((i>0) && ((i+1)%16 == 0))
fw_printf(MLME_DBG_LEVEL1,"\n");
}
fw_printf(MLME_DBG_LEVEL1,"\n");
}
static void mlme_aging_table(mlme_data_t *mlme_p)
{
UINT32 i;
UINT32 now=mlme_get_time(mlme_p);
BSS_entry_t *tmp;
BSS_table_t *table=&mlme_p->mTable;
for(i=0;i<BSS_TABLE_SIZE;i++)
{
tmp=&(table->entry[i]);
if(!(tmp->exist))
continue;
if(now > tmp->timestamp)
{
if(now-tmp->timestamp >BEACON_WAIT_TIME) //wait for BEACON_WAIT_TIME ms.
{
tmp->exist=0;
if(mlme_dbg_level&MLME_DEBUG_MLME_BASIC_MSG)
fw_printf(MLME_DBG_LEVEL1,"\n******* BSSID:%x %x %x %x %x %x aged...\n",tmp->mBssid[0],
tmp->mBssid[1],tmp->mBssid[2],tmp->mBssid[3],tmp->mBssid[4],tmp->mBssid[5]);
}
}
else
tmp->timestamp=now;
}
}
static void RtcCfgInit(const XPfw_Module_t *ModPtr, const u32 *CfgData, u32 Len)
{
XPfw_CoreRegisterEvent(ModPtr, XPFW_EV_RTC_SECONDS);
/* Enable Seconds Alarm */
Xil_Out32(RTC_RTC_INT_EN, 1U);
Xil_Out32(RTC_RTC_INT_STATUS, 1U);
fw_printf("RTC (MOD-%d): Initialized.\r\n", ModPtr->ModId);
}
XStatus XPfw_Main(void)
{
XStatus Status;
/* Start the Init Routine */
XPfw_PlatformInit();
fw_printf("PMU Firmware %s\t%s %s\n",
ZYNQMP_XPFW_VERSION, __DATE__, __TIME__);
/* TODO: Print ROM version */
/* Initialize the FW Core Object */
Status = XPfw_CoreInit(0U);
if (Status != XST_SUCCESS) {
fw_printf("%s: Error! Core Init failed\r\n", __func__);
goto Done;
}
/* Call the User Start Up Code to add Mods, Handlers and Tasks */
XPfw_UserStartUp();
/* Configure the Modules. Calls CfgInit Handlers of all modules */
Status = XPfw_CoreConfigure();
if (Status != XST_SUCCESS) {
fw_printf("%s: Error! Core Cfg failed\r\n", __func__);
goto Done;
}
/* Wait to Service the Requests */
Status = XPfw_CoreLoop();
if (Status != XST_SUCCESS) {
fw_printf("%s: Error! Unexpected exit from CoreLoop\r\n", __func__);
goto Done;
}
Done:
/* Control never comes here */
return Status;
}
/* return assoc body length */
UINT32 mlme_make_assoc(mlme_data_t *mlme_p,UINT8 *pkt)
{
I802_11_pkt_t *mlme_pkt=(I802_11_pkt_t *)pkt;
UINT32 len,len2;
UINT16 BcnInterval=mlme_p->mInterval_config;
UINT16 cap=MLME_CAP_NULL;
mlme_make_header(pkt,SUBTYPE_ASSOC_REQ,0,0,mlme_p->bss.mBssid,mlme_p->mMAC,mlme_p->bss.mBssid);
/* capability info */
mlme_pkt->fb[0]=cap&0xff;
mlme_pkt->fb[1]=(cap&0xff00)>>8;
/* beacon interval */
mlme_pkt->fb[2]=BcnInterval&0xff;
mlme_pkt->fb[3]=(BcnInterval&0xff00)>>8;
/* essid */
mlme_pkt->fb[4]=MLME_ELEMENT_SSID;
mlme_pkt->fb[5]=len2=(unsigned char)strlen(mlme_p->bss.mEssid);
fw_memcpy(&mlme_pkt->fb[6],mlme_p->bss.mEssid,len2);
len=6+len2;
/* support rate */
mlme_pkt->fb[len]=MLME_ELEMENT_RATE;
mlme_pkt->fb[len+1]=len2=(unsigned char)strlen(mlme_p->mRate_info);
fw_memcpy(&mlme_pkt->fb[len+2],mlme_p->mRate_info,len2);
len=len+2+len2;
/* SSN support ?*/
if(mlme_p->bss.wpa_ie[0]!=0)
{
fw_memcpy(&mlme_pkt->fb[len],mlme_p->bss.wpa_ie,mlme_p->bss.wpa_ie[1]+2);
len=len+mlme_p->bss.wpa_ie[1]+2;
}
if(len>MLME_ASSOC_BODY_LEN)
{
fw_printf(MLME_DBG_LEVEL1,"\nerror assoc packet length-------------------\n");
mlme_dump_data(pkt,len);
while(1)
;
}
return len;
}
static void PmEventHandler(const XPfw_Module_t *ModPtr, u32 EventId)
{
u32 EvType, RegValue;
EvType = XPfw_EventGetType(EventId);
switch (EvType) {
case XPFW_EV_TYPE_GPI1:
RegValue = XPfw_EventGetRegMask(EventId);
XPfw_PmWakeHandler(RegValue);
break;
case XPFW_EV_TYPE_GPI2:
RegValue = XPfw_EventGetRegMask(EventId);
XPfw_PmWfiHandler(RegValue);
break;
default:
fw_printf("Unhandled PM Event: %d\r\n", EventId);
break;
}
}
static void PrintMsg2(void)
{
fw_printf("Task#2\r\n");
}
static void PrintMsg1(void)
{
fw_printf("Task#1\r\n");
}
void mlme_infra_routine(mlme_data_t *mlme_p)
{
BSS_entry_t *bss_entry;
UINT32 reason;
if(mlme_p->mAssoc)
{
UINT32 now=mlme_get_time(mlme_p);
if(now < mlme_p->mLastBeaconTime)
return;
if((now-mlme_p->mLastBeaconTime)>BEACON_WAIT_TIME)
{
fw_printf(MLME_DBG_LEVEL1,"*******Not accept belonged beacon: 0x%x from now 0x%x\n",mlme_p->mLastBeaconTime,now);
mlme_reset(mlme_p);
mlme_p->mLastBeaconTime=now;
/* it will go through to if(!mlme_p->mAssoc) */
}
else
{
mlme_p->mLastBeaconTime=0;
//check romming quality
bss_entry=mlme_search_table_by_essid(&mlme_p->mTable,mlme_p->bss.mEssid,mlme_p->mChannel_config);
if(!bss_entry)
return;
if(!fw_memcmp(bss_entry->mBssid,mlme_p->bss.mBssid,MACADDR_LEN))
return;
printk("<not equal:%d %d diff:%d>",bss_entry->quality,mlme_p->bss.quality,bss_entry->quality-mlme_p->bss.quality);
if((bss_entry->quality) - (mlme_p->bss.quality) > MLME_QUALITY_OFFSET)
{
/* do disassoc */
// fw_showstr(MLME_DBG_LEVEL1,"Send Message:MLME_DISASSOC_REQ to ASSOC state machine...");
reason=MLME_REASON_DISASSOC_STA_LEAVING;
mlme_msg_enqueue(&mlme_p->mQueue,MLME_ASSOC_STATE_MACHINE,MLME_DISASSOC_REQ,&reason,2,0,0);
// printk("MLMA_main() from mlme_infra_routine\n");
MLME_main(mlme_p);
//join better AP
fw_memcpy(&mlme_p->bss,bss_entry,sizeof(BSS_entry_t));
// fw_showstr(MLME_DBG_LEVEL1,"(mlme_routine)Send Message:MLME_JOIN_REQ to SYNC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_SYNC_STATE_MACHINE,MLME_JOIN_REQ,0,0,0,0);
}
}
}
if(!mlme_p->mAssoc) //not mAssoc
{
// printk("\n<mlme_routine_scan>\n");
mlme_reset(mlme_p);
if(mlme_p->mChannel_config==MLME_CHANNEL_NOCHECK)
{
/* do scan */
// fw_showstr(MLME_DBG_LEVEL1,"(mlme_routine)Send Message:MLME_SCAN_REQ to SYNC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_SYNC_STATE_MACHINE,MLME_SCAN_REQ,0,0,0,0);
// printk("MLMA_main() from mlme_infra_routine\n");
MLME_main(mlme_p);
}
else
{
//search table for specified ssid/ssid
bss_entry=mlme_search_table_by_essid(&mlme_p->mTable,mlme_p->bss.mEssid,mlme_p->mChannel_config);
if(bss_entry)
{
/* do join */
fw_memcpy(&mlme_p->bss,bss_entry,sizeof(BSS_entry_t));
// fw_showstr(MLME_DBG_LEVEL1,"(mlme_routine)Send Message:MLME_JOIN_REQ to SYNC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_SYNC_STATE_MACHINE,MLME_JOIN_REQ,0,0,0,0);
}
else
{
/* do scan */
// fw_showstr(MLME_DBG_LEVEL1,"(mlme_routine)Send Message:MLME_SCAN_REQ to SYNC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_SYNC_STATE_MACHINE,MLME_SCAN_REQ,0,0,0,0);
}
}
}
}
UINT32 MLME_ioctl(mlme_data_t *mlme_p,UINT32 cmd,void *data)
{
switch(cmd)
{
case MLME_IOCTL_QUERY_JOB: //query if queued mlme jobs
if(mlme_query_job(&mlme_p->mQueue))
*(UINT32 *)data=1;
else
*(UINT32 *)data=0;
break;
case MLME_IOCTL_SET_SSID: //use string with 0x0 end
if(fw_strcmp(mlme_p->bss.mEssid,(UINT8 *)data)!=0) //not equal
fw_strcpy(mlme_p->bss.mEssid,(UINT8 *)data);
mlme_reset(mlme_p); //should do mlme_reset because re-typing iwconfig ...
mlme_set_ssid_action(mlme_p);
break;
case MLME_IOCTL_GET_SSID:
fw_strcpy(data,mlme_p->bss.mEssid);
break;
case MLME_IOCTL_SET_BSSID: //use string with 0x0 end
mlme_reset(mlme_p); //should do mlme_reset because re-typing iwconfig ...
mlme_set_bssid_action(mlme_p,data);
break;
case MLME_IOCTL_GET_BSSID:
fw_memcpy(data,mlme_p->bss.mBssid,MACADDR_LEN);
break;
case MLME_IOCTL_SET_MAC:
fw_memcpy((UINT8 *)mlme_p->mMAC,(UINT8 *)data,MACADDR_LEN);
break;
case MLME_IOCTL_GET_MAC:
fw_memcpy((UINT8 *)data,(UINT8 *)mlme_p->mMAC,MACADDR_LEN);
break;
case MLME_IOCTL_SET_MODE: //UINT32 mode
mlme_clean_table(mlme_p);
mlme_p->mMode=*(UINT32 *)data;
// fw_printf(MLME_DBG_LEVEL1,"MLME_SET_MODE:%d\n",mlme_p->mMode);
mlme_down(mlme_p);
mlme_reset(mlme_p); //should do mlme_reset because re-typing iwconfig ...
mlme_set_ssid_action(mlme_p);
break;
case MLME_IOCTL_GET_MODE: //UINT32 mode
*(UINT32 *)data=mlme_p->mMode;
// fw_printf(MLME_DBG_LEVEL1,"MLME_GET_MODE:%d\n",*(UINT32 *)data);
break;
case MLME_IOCTL_RESTART:
mlme_reset(mlme_p);
break;
case MLME_IOCTL_SET_CHANNEL: //UINT32 channel
mlme_p->mChannel_config=*(UINT32 *)data;
mlme_p->bss.mChannel=mlme_p->mChannel_config;
if(mlme_dbg_level&MLME_DEBUG_MLME_BASIC_MSG)
fw_printf(MLME_DBG_LEVEL1,"MLME_IOCTL_SET_CHANNEL:%d\n",mlme_p->bss.mChannel);
mlme_reset(mlme_p); //should do mlme_reset because re-typing iwconfig ...
mlme_set_ssid_action(mlme_p);
break;
case MLME_IOCTL_GET_CHANNEL: //UINT32 channel
*(UINT32 *)data=mlme_p->bss.mChannel;
//fw_printf(MLME_DBG_LEVEL1,"MLME_GET_CHANNEL:%d\n",*(UINT32 *)data);
break;
case MLME_IOCTL_QUERY_ASSOC: //assoc status
if(mlme_p->mAssoc)
*(UINT32 *)data=1;
else
*(UINT32 *)data=0;
break;
case MLME_IOCTL_DEBUG_PRINT:
sim_printmlme(mlme_p,*(UINT32 *)data);
break;
case MLME_IOCTL_SET_AUTH_ALG:
mlme_p->mAuth_config=*(UINT32 *)data;
// printk("MLME_IOCTL_SET_AUTH_ALG=%d\n",mlme_p->mAuth_config);
break;
case MLME_IOCTL_GET_AUTH_ALG:
*(UINT32 *)data=mlme_p->mAuth_config;
// printk("MLME_IOCTL_GET_AUTH_ALG=%d\n",mlme_p->mAuth_config);
break;
case MLME_IOCTL_GET_SCAN_INFO:
*(UINT32 *)data=(UINT32)&mlme_p->mTable;
break;
case MLME_IOCTL_REQ_DISASSOC:
if(mlme_dbg_level&MLME_DEBUG_MLME_BASIC_MSG)
fw_showstr(MLME_DBG_LEVEL1,"Send Message:MLME_DISASSOC_REQ to ASSOC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_ASSOC_STATE_MACHINE,MLME_DISASSOC_REQ,data,2,0,0);
break;
default:
break;
}
return 1;
}
void MLME_rx(mlme_data_t *mlme_p,UINT8 *pkt,UINT32 pkt_len,UINT8 *parm)
{
I802_11_hdr_t *mlme_hdr=(I802_11_hdr_t *)pkt;
I802_11_pkt_t *mlme_pkt=(I802_11_pkt_t *)pkt;
// fw_printf(MLME_DBG_LEVEL1,"\n-----------------------------------\n");
// mlme_dump_data(pkt,50);
if(mlme_dbg_level&MLME_DEBUG_ATTACKER)
return;
if(!mlme_checkinit(mlme_p))
return;
//check management type
switch(mlme_hdr->subtype)
{
case SUBTYPE_ASSOC_REQ: //AP mode only
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),AP function only...");
break;
case SUBTYPE_ASSOC_RSP:
if(mlme_p->mMode==MLME_ADHOC_MODE)
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Adhoc not support MLME_ASSOC_RSP_RCV...");
}
else
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Send Message:MLME_ASSOC_RSP_RCV to ASSOC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_ASSOC_STATE_MACHINE,MLME_ASSOC_RSP_RCV,(UINT8 *)pkt,pkt_len,parm,2);
}
break;
case SUBTYPE_REASSOC_REQ: //AP mode only
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),AP function only...");
break;
case SUBTYPE_REASSOC_RSP:
if(mlme_p->mMode==MLME_ADHOC_MODE)
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Adhoc not support MLME_REASSOC_RSP_RCV...");
}
else
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Send Message:MLME_REASSOC_RSP_RCV to ASSOC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_ASSOC_STATE_MACHINE,MLME_REASSOC_RSP_RCV,(UINT8 *)pkt,pkt_len,parm,2);
}
break;
case SUBTYPE_PROBE_REQ:
if(mlme_p->mMode==MLME_INFRA_MODE)
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),BSS STA not support MLME_PROBE_REQ_RCV...");
}
else if(mlme_p->mMode==MLME_ADHOC_MODE)
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Send Message:MLME_PROBE_REQ_RCV to SYNC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_SYNC_STATE_MACHINE,MLME_PROBE_REQ_RCV,mlme_hdr->addr2,6,0,0);
}
break;
case SUBTYPE_PROBE_RSP:
/* filter if ad-hoc/infrastrucautre packet */
// printk("mlme_pkt->fb[10]=0x%x 0x%x mlme_p->mMode=%d\n",mlme_pkt->fb[10],mlme_pkt->fb[11],mlme_p->mMode);
if(((mlme_pkt->fb[10]&0x2)==0x2) && (mlme_p->mMode==MLME_INFRA_MODE)) //Capability: Ad-hoc bit
return;
if(((mlme_pkt->fb[10]&0x2)!=0x2) && (mlme_p->mMode==MLME_ADHOC_MODE)) //Capability: Ad-hoc bit
return;
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Send Message:MLME_PROBE_RSP_RCV to SYNC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_SYNC_STATE_MACHINE,MLME_PROBE_RSP_RCV,(UINT8 *)pkt,pkt_len,parm,2);
break;
case SUBTYPE_BEACON:
/* filter if ad-hoc/infrastrucautre packet */
//printk("mlme_pkt->fb[10]=0x%x 0x%x mlme_p->mMode=%d\n",mlme_pkt->fb[10],mlme_pkt->fb[11],mlme_p->mMode);
if(((mlme_pkt->fb[10]&0x2)==0x2) && (mlme_p->mMode==MLME_INFRA_MODE)) //Capability: Ad-hoc bit
return;
if(((mlme_pkt->fb[10]&0x2)!=0x2) && (mlme_p->mMode==MLME_ADHOC_MODE)) //Capability: Ad-hoc bit
return;
mlme_msg_enqueue(&mlme_p->mQueue,MLME_SYNC_STATE_MACHINE,MLME_BEACON_RCV,(UINT8 *)pkt,pkt_len,parm,2);
break;
case SUBTYPE_ATIM: // not support yet
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Not Implement!");
break;
case SUBTYPE_DISASSOC:
if(mlme_p->mMode==MLME_ADHOC_MODE)
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Adhoc not support MLME_DISASSOC_RCV...");
}
else
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Send Message:MLME_DISASSOC_RCV to ASSOC state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_ASSOC_STATE_MACHINE,MLME_DISASSOC_RCV,0,0,0,0);
}
break;
case SUBTYPE_AUTH:
if(mlme_p->mMode==MLME_ADHOC_MODE)
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Adhoc not support MLME_AUTH_RCV...");
}
else
{
UINT16 seq_num;
fw_memcpy((UINT32 *)&seq_num,(UINT32 *)&(mlme_pkt->fb[2]),2);
if(seq_num==1||seq_num==3)
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_printf(MLME_DBG_LEVEL1,"NOT support in STA(AUTH seq=%d)\n",seq_num);
}
else
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Send Message:MLME_AUTH_EVEN_RCV to AUTH state machine(pkt_len=%d)...",pkt_len);
mlme_msg_enqueue(&mlme_p->mQueue,MLME_AUTH_STATE_MACHINE,MLME_AUTH_EVEN_RCV,(UINT8 *)pkt,pkt_len,0,0);
}
}
break;
case SUBTYPE_DEAUTH:
if(mlme_p->mMode==MLME_ADHOC_MODE)
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Adhoc not support MLME_DEAUTH_RCV...");
}
else
{
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Send Message:MLME_DEAUTH_RCV to AUTH state machine...");
mlme_msg_enqueue(&mlme_p->mQueue,MLME_AUTH_STATE_MACHINE,MLME_DEAUTH_RCV,0,0,0,0);
}
break;
default:
if(mlme_dbg_level&MLME_DEBUG_MLME_RX_MSG)
fw_showstr(MLME_DBG_LEVEL1,"MLME_rx(),Undefined subtype");
break;
}
}
/* search table by essid/channel */
static void mlme_print_table(BSS_table_t *table)
{
UINT32 i,j=0;
BSS_entry_t *tmp;
for(i=0;i<BSS_TABLE_SIZE;i++)
{
tmp=&(table->entry[i]);
if(!(tmp->exist))
continue;
fw_printf(MLME_DBG_LEVEL1,"[%d]Chl:%x BSSID:%02x %02x %02x %02x %02x %02x Qual:%d WEP:%d SSID:%s\n",i,tmp->mChannel,tmp->mBssid[0],
tmp->mBssid[1],tmp->mBssid[2],tmp->mBssid[3],tmp->mBssid[4],tmp->mBssid[5],tmp->quality,tmp->mPrivacy,tmp->mEssid);
/* mode */
if(tmp->mMode==MLME_ADHOC_MODE)
fw_printf(MLME_DBG_LEVEL1," Mode: Ad-hoc");
else if(tmp->mMode==MLME_INFRA_MODE)
fw_printf(MLME_DBG_LEVEL1," Mode: Infra");
/* support rate */
fw_printf(MLME_DBG_LEVEL1," Support Rate(Mb):");
j=0;
while(1)
{
if(tmp->rate[j]==0)
break;
if(tmp->rate[j]==MLME_SR_1M)
fw_printf(MLME_DBG_LEVEL1,"1 ");
if(tmp->rate[j]==MLME_SR_2M)
fw_printf(MLME_DBG_LEVEL1,"2 ");
if(tmp->rate[j]==MLME_SR_5_5M)
fw_printf(MLME_DBG_LEVEL1,"5.5 ");
if(tmp->rate[j]==MLME_SR_11M)
fw_printf(MLME_DBG_LEVEL1,"11 ");
if(tmp->rate[j]==MLME_SR_16_5M)
fw_printf(MLME_DBG_LEVEL1,"16.5 ");
if(tmp->rate[j]==MLME_SR_22M)
fw_printf(MLME_DBG_LEVEL1,"22 ");
if(tmp->rate[j]==MLME_SR_27_5M)
fw_printf(MLME_DBG_LEVEL1,"27.5 ");
j++;
}
/* basic rate */
fw_printf(MLME_DBG_LEVEL1," Basic Rate value=0x%x",tmp->basic_rate);
fw_printf(MLME_DBG_LEVEL1,"\n");
//fw_printf(MLME_DBG_LEVEL1,"tmp->timestamp=0x%x\n",tmp->timestamp);
//fw_printf(MLME_DBG_LEVEL1," Quality:0x%x Stregth:0x%x timestamp:0x%x\n",tmp->quality,tmp->strength,tmp->timestamp);
#if 0
fw_printf(MLME_DBG_LEVEL1,"wpa_ie=");
for(i=0;i<tmp->wpa_ie[1]+2;i++)
fw_printf(MLME_DBG_LEVEL1,"%02x ",tmp->wpa_ie[i]);
fw_printf(MLME_DBG_LEVEL1,"\n");
#endif
}
fw_printf(MLME_DBG_LEVEL1,"-----------------------------------------------------------------\n");
fw_printf(MLME_DBG_LEVEL1," Debug Level=0x%x\n",mlme_dbg_level);
fw_printf(MLME_DBG_LEVEL1,"MLME_DEBUG_RX_DUMP_PKT=%04x MLME_DEBUG_TX_DUMP_PKT=%04x\n",MLME_DEBUG_RX_DUMP_PKT,MLME_DEBUG_TX_DUMP_PKT);
fw_printf(MLME_DBG_LEVEL1,"MLME_DEBUG_TCB_DUMP_MSG=%04x MLME_DEBUG_WEP_DATA=%04x\n",MLME_DEBUG_TCB_DUMP_MSG,MLME_DEBUG_WEP_DATA);
fw_printf(MLME_DBG_LEVEL1,"MLME_DEBUG_WPA_DATA=%04x MLME_DEBUG_HARDWARE_CTL=%04x\n",MLME_DEBUG_WPA_DATA,MLME_DEBUG_HARDWARE_CTL);
fw_printf(MLME_DBG_LEVEL1,"MLME_DEBUG_MLME_BASIC_MSG=%04x MLME_DEBUG_MLME_ADVANCE_MSG=%04x\n",MLME_DEBUG_MLME_BASIC_MSG,MLME_DEBUG_MLME_ADVANCE_MSG);
fw_printf(MLME_DBG_LEVEL1,"MLME_DEBUG_MLME_BEACON_DUMP=%04x MLME_DEBUG_MLME_RX_MSG=%04x\n",MLME_DEBUG_MLME_BEACON_DUMP,MLME_DEBUG_MLME_RX_MSG);
fw_printf(MLME_DBG_LEVEL1,"MLME_DEBUG_MLME_TX_DUMP=%04x MLME_DEBUG_ATTACKER=%04x\n",MLME_DEBUG_MLME_TX_DUMP,MLME_DEBUG_ATTACKER);
}
void sim_printmlme(mlme_data_t *mlme_p,int value)
{
//mlme_dbg=value;
// fw_printf(MLME_DBG_LEVEL1,"debug level=%d\n",mlme_dbg);
//vt100_clear_line(2);
fw_printf(MLME_DBG_LEVEL1,"\n");
if(mlme_p->mAssoc)
fw_printf(MLME_DBG_LEVEL1,"O");
else
fw_printf(MLME_DBG_LEVEL1,"X");
if(mlme_p->mMode==MLME_INFRA_MODE)
fw_printf(MLME_DBG_LEVEL1,"[BSS]");
else if(mlme_p->mMode==MLME_ADHOC_MODE)
fw_printf(MLME_DBG_LEVEL1,"[Adhoc]");
else
fw_printf(MLME_DBG_LEVEL1,"[NULL]");
fw_printf(MLME_DBG_LEVEL1,"[%d] ",mlme_p->bss.mChannel);
if(!fw_memcmp(mlme_p->mBssid_config,mBroadcast,MACADDR_LEN))
fw_printf(MLME_DBG_LEVEL1,"BSSID(Learning):");
else
fw_printf(MLME_DBG_LEVEL1,"BSSID(Config):");
fw_printf(MLME_DBG_LEVEL1,"%02x %02x %02x %02x %02x %02x",mlme_p->bss.mBssid[0],
mlme_p->bss.mBssid[1],mlme_p->bss.mBssid[2],mlme_p->bss.mBssid[3],
mlme_p->bss.mBssid[4],mlme_p->bss.mBssid[5]);
fw_printf(MLME_DBG_LEVEL1," MAC:%02x %02x %02x %02x %02x %02x\n",mlme_p->mMAC[0],
mlme_p->mMAC[1],mlme_p->mMAC[2],mlme_p->mMAC[3],
mlme_p->mMAC[4],mlme_p->mMAC[5]);
fw_printf(MLME_DBG_LEVEL1," ESSID:\"%s\"",mlme_p->bss.mEssid);
fw_printf(MLME_DBG_LEVEL1," Time(ms):0x%x",mlme_get_time(mlme_p));
fw_printf(MLME_DBG_LEVEL1," Bcn:0x%x\n",mlme_p->mLastBeaconTime);
fw_printf(MLME_DBG_LEVEL1, "System State: CLASS %d ",mlme_get_state(mlme_p,MLME_SYS_STATE_MACHINE));
if(mlme_get_state(mlme_p,MLME_ASSOC_STATE_MACHINE)==ASSOC_IDLE)
fw_printf(MLME_DBG_LEVEL1,"Assoc State: IDLE\n");
else
fw_printf(MLME_DBG_LEVEL1,"Assoc State: WAIT\n");
if(mlme_get_state(mlme_p,MLME_AUTH_STATE_MACHINE)==AUTH_IDLE)
fw_printf(MLME_DBG_LEVEL1,"Auth State: IDLE ");
else if(mlme_get_state(mlme_p,MLME_AUTH_STATE_MACHINE)==WAIT_SEQ_2)
fw_printf(MLME_DBG_LEVEL1,"Auth State: SEQ2 ");
else
fw_printf(MLME_DBG_LEVEL1,"Auth State: SEQ4 ");
if(mlme_get_state(mlme_p,MLME_SYNC_STATE_MACHINE)==SYNC_IDLE)
fw_printf(MLME_DBG_LEVEL1,"Sync State: IDLE \n");
else if(mlme_get_state(mlme_p,MLME_SYNC_STATE_MACHINE)==JOIN_WAIT_BEACON)
fw_printf(MLME_DBG_LEVEL1,"Sync State: WaitBeacon\n");
else
fw_printf(MLME_DBG_LEVEL1,"Sync State: ScanListen\n");
//fw_printf(MLME_DBG_LEVEL1,"q->head=%d q->tail=%d mlme_dbg_level=0x%x\n\n",mlme_p->mQueue.head,mlme_p->mQueue.tail,mlme_dbg_level);
mlme_print_table(&mlme_p->mTable);
#if 0
{
int i;
fw_printf(MLME_DBG_LEVEL1,"wpa_ie=");
for(i=0;i<mlme_p->bss.wpa_ie[1]+2;i++)
fw_printf(MLME_DBG_LEVEL1,"%02x ",mlme_p->bss.wpa_ie[i]);
fw_printf(MLME_DBG_LEVEL1,"\n");
}
#endif
}
