📄 mlme.c
字号:
/*
***************************************************************************
* Ralink Tech Inc.
* 4F, No. 2 Technology 5th Rd.
* Science-based Industrial Park
* Hsin-chu, Taiwan, R.O.C.
*
* (c) Copyright 2002-2004, Ralink Technology, Inc.
*
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
* *
************************************************************************
Module Name:
mlme.c
Abstract:
Revision History:
Who When What
-------- ---------- ----------------------------------------------
Name Date Modification logs
Jan Lee 2005-06-01 Release
*/
#include "rt_config.h"
// 1 2 5.5 11 6 9 12 18 24 36 48 54 72 100
CHAR RssiSafeLevelForTxRate[] ={ -92, -91, -90, -87, -88, -86, -85, -83, -81, -78, -72, -71, -40, -40 };
// 1 2 5.5 11
UCHAR Phy11BNextRateDownward[] = {RATE_1, RATE_1, RATE_2, RATE_5_5};
UCHAR Phy11BNextRateUpward[] = {RATE_2, RATE_5_5, RATE_11, RATE_11};
// 1 2 5.5 11 6 9 12 18 24 36 48 54
UCHAR Phy11BGNextRateDownward[]= {RATE_1, RATE_1, RATE_2, RATE_5_5,RATE_11, RATE_6, RATE_11, RATE_12, RATE_18, RATE_24, RATE_36, RATE_48};
UCHAR Phy11BGNextRateUpward[] = {RATE_2, RATE_5_5, RATE_11, RATE_12, RATE_9, RATE_12, RATE_18, RATE_24, RATE_36, RATE_48, RATE_54, RATE_54};
// 1 2 5.5 11 6 9 12 18 24 36 48 54
UCHAR Phy11ANextRateDownward[] = {RATE_6, RATE_6, RATE_6, RATE_6, RATE_6, RATE_6, RATE_9, RATE_12, RATE_18, RATE_24, RATE_36, RATE_48};
UCHAR Phy11ANextRateUpward[] = {RATE_9, RATE_9, RATE_9, RATE_9, RATE_9, RATE_12, RATE_18, RATE_24, RATE_36, RATE_48, RATE_54, RATE_54};
// 2560D and after has implemented ASIC-based OFDM rate switching, but not
// 2560C and before. thus software use different PER for rate switching
// RATE_1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54
USHORT NewRateUpPER[] = { 40, 40, 35, 20, 20, 20, 20, 16, 10, 16, 10, 6 }; // in percentage
USHORT NewRateDownPER[] = { 50, 50, 45, 45, 35, 35, 35, 35, 25, 25, 25, 13 }; // in percentage
USHORT OldRateUpPER[] = { 40, 40, 40, 40, 30, 30, 30, 30, 20, 20, 10, 10 }; // in percentage
USHORT OldRateDownPER[] = { 45, 45, 45, 45, 35, 35, 35, 35, 25, 25, 25, 12 }; // in percentage
UCHAR RateIdToMbps[] = { 1, 2, 5, 11, 6, 9, 12, 18, 24, 36, 48, 54, 72, 100};
USHORT RateIdTo500Kbps[] = { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108, 144, 200};
RTMP_RF_REGS RF2522RegTable[] = {
// ch R1 R2 R3(TX0~4=0) R4
{1, 0x94002050, 0x940c1fda, 0x94000101, 0},
{2, 0x94002050, 0x940c1fee, 0x94000101, 0},
{3, 0x94002050, 0x940c2002, 0x94000101, 0},
{4, 0x94002050, 0x940c2016, 0x94000101, 0},
{5, 0x94002050, 0x940c202a, 0x94000101, 0},
{6, 0x94002050, 0x940c203e, 0x94000101, 0},
{7, 0x94002050, 0x940c2052, 0x94000101, 0},
{8, 0x94002050, 0x940c2066, 0x94000101, 0},
{9, 0x94002050, 0x940c207a, 0x94000101, 0},
{10, 0x94002050, 0x940c208e, 0x94000101, 0},
{11, 0x94002050, 0x940c20a2, 0x94000101, 0},
{12, 0x94002050, 0x940c20b6, 0x94000101, 0},
{13, 0x94002050, 0x940c20ca, 0x94000101, 0},
{14, 0x94002050, 0x940c20fa, 0x94000101, 0}
};
#define NUM_OF_2522_CHNL (sizeof(RF2522RegTable) / sizeof(RTMP_RF_REGS))
RTMP_RF_REGS RF2523RegTable[] = {
// ch R1 R2 R3(TX0~4=0) R4
{1, 0x94022010, 0x94000c9e, 0x940e0111, 0x94000a1b},
{2, 0x94022010, 0x94000ca2, 0x940e0111, 0x94000a1b},
{3, 0x94022010, 0x94000ca6, 0x940e0111, 0x94000a1b},
{4, 0x94022010, 0x94000caa, 0x940e0111, 0x94000a1b},
{5, 0x94022010, 0x94000cae, 0x940e0111, 0x94000a1b},
{6, 0x94022010, 0x94000cb2, 0x940e0111, 0x94000a1b},
{7, 0x94022010, 0x94000cb6, 0x940e0111, 0x94000a1b},
{8, 0x94022010, 0x94000cba, 0x940e0111, 0x94000a1b},
{9, 0x94022010, 0x94000cbe, 0x940e0111, 0x94000a1b},
{10, 0x94022010, 0x94000d02, 0x940e0111, 0x94000a1b},
{11, 0x94022010, 0x94000d06, 0x940e0111, 0x94000a1b},
{12, 0x94022010, 0x94000d0a, 0x940e0111, 0x94000a1b},
{13, 0x94022010, 0x94000d0e, 0x940e0111, 0x94000a1b},
{14, 0x94022010, 0x94000d1a, 0x940e0111, 0x94000a03}
};
#define NUM_OF_2523_CHNL (sizeof(RF2523RegTable) / sizeof(RTMP_RF_REGS))
RTMP_RF_REGS RF2524RegTable[] = {
// ch R1 R2 R3(TX0~4=0) R4
{1, 0x94032020, 0x94000c9e, 0x94000101, 0x94000a1b},
{2, 0x94032020, 0x94000ca2, 0x94000101, 0x94000a1b},
{3, 0x94032020, 0x94000ca6, 0x94000101, 0x94000a1b},
{4, 0x94032020, 0x94000caa, 0x94000101, 0x94000a1b},
{5, 0x94032020, 0x94000cae, 0x94000101, 0x94000a1b},
{6, 0x94032020, 0x94000cb2, 0x94000101, 0x94000a1b},
{7, 0x94032020, 0x94000cb6, 0x94000101, 0x94000a1b},
{8, 0x94032020, 0x94000cba, 0x94000101, 0x94000a1b},
{9, 0x94032020, 0x94000cbe, 0x94000101, 0x94000a1b},
{10, 0x94032020, 0x94000d02, 0x94000101, 0x94000a1b},
{11, 0x94032020, 0x94000d06, 0x94000101, 0x94000a1b},
{12, 0x94032020, 0x94000d0a, 0x94000101, 0x94000a1b},
{13, 0x94032020, 0x94000d0e, 0x94000101, 0x94000a1b},
{14, 0x94032020, 0x94000d1a, 0x94000101, 0x94000a03}
};
#define NUM_OF_2524_CHNL (sizeof(RF2524RegTable) / sizeof(RTMP_RF_REGS))
RTMP_RF_REGS_1 RF2525RegTable[] = {
// ch TempR2 R1 R2 R3(TX0~4=0) R4
{1, 0x94080cbe, 0x94022020, 0x94080c9e, 0x94060111, 0x94000a1b}, // {1, 0x94022010, 0x9408062e, 0x94060111, 0x94000a23},
{2, 0x94080d02, 0x94022020, 0x94080ca2, 0x94060111, 0x94000a1b},
{3, 0x94080d06, 0x94022020, 0x94080ca6, 0x94060111, 0x94000a1b},
{4, 0x94080d0a, 0x94022020, 0x94080caa, 0x94060111, 0x94000a1b},
{5, 0x94080d0e, 0x94022020, 0x94080cae, 0x94060111, 0x94000a1b},
{6, 0x94080d12, 0x94022020, 0x94080cb2, 0x94060111, 0x94000a1b},
{7, 0x94080d16, 0x94022020, 0x94080cb6, 0x94060111, 0x94000a1b},
{8, 0x94080d1a, 0x94022020, 0x94080cba, 0x94060111, 0x94000a1b},
{9, 0x94080d1e, 0x94022020, 0x94080cbe, 0x94060111, 0x94000a1b},
{10, 0x94080d22, 0x94022020, 0x94080d02, 0x94060111, 0x94000a1b},
{11, 0x94080d26, 0x94022020, 0x94080d06, 0x94060111, 0x94000a1b}, // {11, 0x94022010, 0x94080682, 0x94060111, 0x94000a23},
{12, 0x94080d2a, 0x94022020, 0x94080d0a, 0x94060111, 0x94000a1b},
{13, 0x94080d2e, 0x94022020, 0x94080d0e, 0x94060111, 0x94000a1b}, // {13, 0x94022010, 0x94080686, 0x94060111, 0x94000a23},
{14, 0x94080d3a, 0x94022020, 0x94080d1a, 0x94060111, 0x94000a03}
};
#define NUM_OF_2525_CHNL (sizeof(RF2525RegTable) / sizeof(RTMP_RF_REGS_1))
RTMP_RF_REGS_1 RF2525eRegTable[] = {
// using 10 Mhz reference clock
// ch TempR2 R1 R2 R3(TX0~4=0) R4
{1, 0x940008aa, 0x94022010, 0x9400089a, 0x94060111, 0x94000e1b},
{2, 0x940008ae, 0x94022010, 0x9400089e, 0x94060111, 0x94000e07},
{3, 0x940008ae, 0x94022010, 0x9400089e, 0x94060111, 0x94000e1b},
{4, 0x940008b2, 0x94022010, 0x940008a2, 0x94060111, 0x94000e07},
{5, 0x940008b2, 0x94022010, 0x940008a2, 0x94060111, 0x94000e1b},
{6, 0x940008b6, 0x94022010, 0x940008a6, 0x94060111, 0x94000e07},
{7, 0x940008b6, 0x94022010, 0x940008a6, 0x94060111, 0x94000e1b},
{8, 0x940008ba, 0x94022010, 0x940008aa, 0x94060111, 0x94000e07},
{9, 0x940008ba, 0x94022010, 0x940008aa, 0x94060111, 0x94000e1b},
{10, 0x940008be, 0x94022010, 0x940008ae, 0x94060111, 0x94000e07},
{11, 0x940008b7, 0x94022010, 0x940008ae, 0x94060111, 0x94000e1b},
{12, 0x94000902, 0x94022010, 0x940008b2, 0x94060111, 0x94000e07},
{13, 0x94000902, 0x94022010, 0x940008b2, 0x94060111, 0x94000e1b},
{14, 0x94000906, 0x94022010, 0x940008b6, 0x94060111, 0x94000e23}
};
#define NUM_OF_2525E_CHNL (sizeof(RF2525eRegTable) / sizeof(RTMP_RF_REGS_1))
RTMP_RF_REGS RF5222RegTable[] = {
// ch R1 R2 R3(TX0~4=0) R4
{1, 0x94022020, 0x94001136, 0x94000101, 0x94000a0b},
{2, 0x94022020, 0x9400113a, 0x94000101, 0x94000a0b},
{3, 0x94022020, 0x9400113e, 0x94000101, 0x94000a0b},
{4, 0x94022020, 0x94001182, 0x94000101, 0x94000a0b},
{5, 0x94022020, 0x94001186, 0x94000101, 0x94000a0b},
{6, 0x94022020, 0x9400118a, 0x94000101, 0x94000a0b},
{7, 0x94022020, 0x9400118e, 0x94000101, 0x94000a0b},
{8, 0x94022020, 0x94001192, 0x94000101, 0x94000a0b},
{9, 0x94022020, 0x94001196, 0x94000101, 0x94000a0b},
{10, 0x94022020, 0x9400119a, 0x94000101, 0x94000a0b},
{11, 0x94022020, 0x9400119e, 0x94000101, 0x94000a0b},
{12, 0x94022020, 0x940011a2, 0x94000101, 0x94000a0b},
{13, 0x94022020, 0x940011a6, 0x94000101, 0x94000a0b},
{14, 0x94022020, 0x940011ae, 0x94000101, 0x94000a1b},
// still lack of MMAC(Japan) ch 34,38,42,46
{36, 0x94022010, 0x94018896, 0x94000101, 0x94000a1f},
{40, 0x94022010, 0x9401889a, 0x94000101, 0x94000a1f},
{44, 0x94022010, 0x9401889e, 0x94000101, 0x94000a1f},
{48, 0x94022010, 0x940188a2, 0x94000101, 0x94000a1f},
{52, 0x94022010, 0x940188a6, 0x94000101, 0x94000a1f},
{66, 0x94022010, 0x940188aa, 0x94000101, 0x94000a1f},
{60, 0x94022010, 0x940188ae, 0x94000101, 0x94000a1f},
{64, 0x94022010, 0x940188b2, 0x94000101, 0x94000a1f},
{100, 0x94022010, 0x94008802, 0x94000101, 0x94000a0f},
{104, 0x94022010, 0x94008806, 0x94000101, 0x94000a0f},
{108, 0x94022010, 0x9400880a, 0x94000101, 0x94000a0f},
{112, 0x94022010, 0x9400880e, 0x94000101, 0x94000a0f},
{116, 0x94022010, 0x94008812, 0x94000101, 0x94000a0f},
{120, 0x94022010, 0x94008816, 0x94000101, 0x94000a0f},
{124, 0x94022010, 0x9400881a, 0x94000101, 0x94000a0f},
{128, 0x94022010, 0x9400881e, 0x94000101, 0x94000a0f},
{132, 0x94022010, 0x94008822, 0x94000101, 0x94000a0f},
{136, 0x94022010, 0x94008826, 0x94000101, 0x94000a0f},
{140, 0x94022010, 0x9400882a, 0x94000101, 0x94000a0f},
{149, 0x94022020, 0x940090a6, 0x94000101, 0x94000a07},
{153, 0x94022020, 0x940090ae, 0x94000101, 0x94000a07},
{157, 0x94022020, 0x940090b6, 0x94000101, 0x94000a07},
{161, 0x94022020, 0x940090be, 0x94000101, 0x94000a07}
};
#define NUM_OF_5222_CHNL (sizeof(RF5222RegTable) / sizeof(RTMP_RF_REGS))
/*
==========================================================================
Description:
initialize the MLME task and its data structure (queue, spinlock,
timer, state machines).
Return:
always return NDIS_STATUS_SUCCESS
==========================================================================
*/
NDIS_STATUS MlmeInit(
IN PRT2570ADAPTER pAd)
{
NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
DBGPRINT(RT_DEBUG_TRACE,"--> MLME Initialize\n");
do
{
Status = MlmeQueueInit(&pAd->Mlme.Queue);
if(Status != NDIS_STATUS_SUCCESS)
{
break;
}
// Initialize Mlme Memory Handler
// Allocate 20 nonpaged memory pool which size are MAX_LEN_OF_MLME_BUFFER for use
Status = MlmeInitMemoryHandler(pAd, 20, MAX_LEN_OF_MLME_BUFFER);
if(Status != NDIS_STATUS_SUCCESS)
{
break;
}
pAd->Mlme.Running = FALSE;
NdisAllocateSpinLock(&pAd->Mlme.TaskLock);
// initialize the two tables
// MacTableInit(pAd);
BssTableInit(&pAd->PortCfg.BssTab);
// init state machines
ASSERT(ASSOC_FUNC_SIZE == MAX_ASSOC_MSG * MAX_ASSOC_STATE);
AssocStateMachineInit(pAd, &pAd->Mlme.AssocMachine, pAd->Mlme.AssocFunc);
ASSERT(AUTH_FUNC_SIZE == MAX_AUTH_MSG * MAX_AUTH_STATE);
AuthStateMachineInit(pAd, &pAd->Mlme.AuthMachine, pAd->Mlme.AuthFunc);
ASSERT(AUTH_RSP_FUNC_SIZE == MAX_AUTH_RSP_MSG * MAX_AUTH_RSP_STATE);
AuthRspStateMachineInit(pAd, &pAd->Mlme.AuthRspMachine, pAd->Mlme.AuthRspFunc);
ASSERT(WPA_PSK_FUNC_SIZE == MAX_WPA_PSK_MSG * MAX_WPA_PSK_STATE);
WpaPskStateMachineInit(pAd,&pAd->Mlme.WpaPskMachine,pAd->Mlme.WpaPskFunc);
ASSERT(SYNC_FUNC_SIZE == MAX_SYNC_MSG * MAX_SYNC_STATE);
SyncStateMachineInit(pAd, &pAd->Mlme.SyncMachine, pAd->Mlme.SyncFunc);
// Since we are using switch/case to implement it, the init is different from the above
// state machine init
MlmeCntlInit(pAd, &pAd->Mlme.CntlMachine, NULL);
RTMPInitTimer(pAd, &pAd->Mlme.PeriodicTimer, &MlmePeriodicExec);
//pAd->Mlme.PeriodicTimer.data = (unsigned long)pAd;
//pAd->Mlme.PeriodicTimer.function = &MlmePeriodicExec;
pAd->Mlme.PeriodicTimer.Timer.expires = jiffies + MLME_TASK_EXEC_INTV;
// delay first mlme timer
RTMPSetTimer(pAd, &pAd->Mlme.PeriodicTimer, 2*MLME_TASK_EXEC_INTV);
if (pAd->PortCfg.LedMode == LED_MODE_TXRX_ACTIVITY)
{
RTMPInitTimer(pAd, &pAd->PortCfg.LedCntl.BlinkTimer, &AsicLedPeriodicExec);
//pAd->PortCfg.LedCntl.BlinkTimer.data = (unsigned long)pAd;
//pAd->PortCfg.LedCntl.BlinkTimer.function = &AsicLedPeriodicExec;
pAd->PortCfg.LedCntl.BlinkTimer.Timer.expires = jiffies + (70 * HZ)/1000;
RTMPSetTimer(pAd, &pAd->PortCfg.LedCntl.BlinkTimer, 70);
}
} while (FALSE);
DBGPRINT(RT_DEBUG_TRACE,"<-- MLME Initialize\n");
return Status;
}
/*
==========================================================================
Description:
Destructor of MLME (Destroy queue, state machine, spin lock and timer)
Parameters:
Adapter - NIC Adapter pointer
Post:
The MLME task will no longer work properly
IRQL = PASSIVE_LEVEL
==========================================================================
*/
VOID MlmeHalt(
IN PRT2570ADAPTER pAd)
{
DBGPRINT(RT_DEBUG_TRACE, "==> MlmeHalt\n");
// Cancel pending timers
RTMPCancelTimer(&pAd->Mlme.AssocAux.AssocTimer);
RTMPCancelTimer(&pAd->Mlme.AssocAux.ReassocTimer);
RTMPCancelTimer(&pAd->Mlme.AssocAux.DisassocTimer);
RTMPCancelTimer(&pAd->Mlme.AuthAux.AuthTimer);
RTMPCancelTimer(&pAd->Mlme.SyncAux.BeaconTimer);
RTMPCancelTimer(&pAd->Mlme.SyncAux.ScanTimer);
RTMPCancelTimer(&pAd->Mlme.PeriodicTimer);
if ((pAd->PortCfg.LedMode == LED_MODE_TXRX_ACTIVITY)||(pAd->PortCfg.LedMode == LED_MODE_ALPHA))
RTMPCancelTimer(&pAd->PortCfg.LedCntl.BlinkTimer);
if (!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_REMOVE_IN_PROGRESS))
{
ASIC_LED_ACT_OFF(pAd);
}
// for timer callback routine to finish.
NdisMSleep(1000);
MlmeQueueDestroy(&pAd->Mlme.Queue);
StateMachineDestroy(&pAd->Mlme.AssocMachine);
StateMachineDestroy(&pAd->Mlme.AuthMachine);
StateMachineDestroy(&pAd->Mlme.AuthRspMachine);
StateMachineDestroy(&pAd->Mlme.SyncMachine);
StateMachineDestroy(&pAd->Mlme.WpaPskMachine);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -