aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/staging/rt2860/sta/rtmp_data.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/staging/rt2860/sta/rtmp_data.c')
-rw-r--r--drivers/staging/rt2860/sta/rtmp_data.c2196
1 files changed, 1097 insertions, 1099 deletions
diff --git a/drivers/staging/rt2860/sta/rtmp_data.c b/drivers/staging/rt2860/sta/rtmp_data.c
index 0ab3dce5d1a..3a93ef699ce 100644
--- a/drivers/staging/rt2860/sta/rtmp_data.c
+++ b/drivers/staging/rt2860/sta/rtmp_data.c
@@ -36,107 +36,164 @@
36*/ 36*/
37#include "../rt_config.h" 37#include "../rt_config.h"
38 38
39 39VOID STARxEAPOLFrameIndicate(IN PRTMP_ADAPTER pAd,
40 40 IN MAC_TABLE_ENTRY * pEntry,
41VOID STARxEAPOLFrameIndicate( 41 IN RX_BLK * pRxBlk, IN UCHAR FromWhichBSSID)
42 IN PRTMP_ADAPTER pAd,
43 IN MAC_TABLE_ENTRY *pEntry,
44 IN RX_BLK *pRxBlk,
45 IN UCHAR FromWhichBSSID)
46{ 42{
47 PRT28XX_RXD_STRUC pRxD = &(pRxBlk->RxD); 43 PRT28XX_RXD_STRUC pRxD = &(pRxBlk->RxD);
48 PRXWI_STRUC pRxWI = pRxBlk->pRxWI; 44 PRXWI_STRUC pRxWI = pRxBlk->pRxWI;
49 UCHAR *pTmpBuf; 45 UCHAR *pTmpBuf;
50 46
51 if (pAd->StaCfg.WpaSupplicantUP) 47 if (pAd->StaCfg.WpaSupplicantUP) {
52 {
53 // All EAPoL frames have to pass to upper layer (ex. WPA_SUPPLICANT daemon) 48 // All EAPoL frames have to pass to upper layer (ex. WPA_SUPPLICANT daemon)
54 // TBD : process fragmented EAPol frames 49 // TBD : process fragmented EAPol frames
55 { 50 {
56 // In 802.1x mode, if the received frame is EAP-SUCCESS packet, turn on the PortSecured variable 51 // In 802.1x mode, if the received frame is EAP-SUCCESS packet, turn on the PortSecured variable
57 if ( pAd->StaCfg.IEEE8021X == TRUE && 52 if (pAd->StaCfg.IEEE8021X == TRUE &&
58 (EAP_CODE_SUCCESS == WpaCheckEapCode(pAd, pRxBlk->pData, pRxBlk->DataSize, LENGTH_802_1_H))) 53 (EAP_CODE_SUCCESS ==
59 { 54 WpaCheckEapCode(pAd, pRxBlk->pData,
60 PUCHAR Key; 55 pRxBlk->DataSize,
61 UCHAR CipherAlg; 56 LENGTH_802_1_H))) {
62 int idx = 0; 57 PUCHAR Key;
63 58 UCHAR CipherAlg;
64 DBGPRINT_RAW(RT_DEBUG_TRACE, ("Receive EAP-SUCCESS Packet\n")); 59 int idx = 0;
60
61 DBGPRINT_RAW(RT_DEBUG_TRACE,
62 ("Receive EAP-SUCCESS Packet\n"));
65 //pAd->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED; 63 //pAd->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
66 STA_PORT_SECURED(pAd); 64 STA_PORT_SECURED(pAd);
67 65
68 if (pAd->StaCfg.IEEE8021x_required_keys == FALSE) 66 if (pAd->StaCfg.IEEE8021x_required_keys ==
69 { 67 FALSE) {
70 idx = pAd->StaCfg.DesireSharedKeyId; 68 idx = pAd->StaCfg.DesireSharedKeyId;
71 CipherAlg = pAd->StaCfg.DesireSharedKey[idx].CipherAlg; 69 CipherAlg =
72 Key = pAd->StaCfg.DesireSharedKey[idx].Key; 70 pAd->StaCfg.DesireSharedKey[idx].
73 71 CipherAlg;
74 if (pAd->StaCfg.DesireSharedKey[idx].KeyLen > 0) 72 Key =
75 { 73 pAd->StaCfg.DesireSharedKey[idx].
74 Key;
75
76 if (pAd->StaCfg.DesireSharedKey[idx].
77 KeyLen > 0) {
76#ifdef RTMP_MAC_PCI 78#ifdef RTMP_MAC_PCI
77 MAC_TABLE_ENTRY *pEntry = &pAd->MacTab.Content[BSSID_WCID]; 79 MAC_TABLE_ENTRY *pEntry =
80 &pAd->MacTab.
81 Content[BSSID_WCID];
78 82
79 // Set key material and cipherAlg to Asic 83 // Set key material and cipherAlg to Asic
80 AsicAddSharedKeyEntry(pAd, BSS0, idx, CipherAlg, Key, NULL, NULL); 84 AsicAddSharedKeyEntry(pAd, BSS0,
85 idx,
86 CipherAlg,
87 Key, NULL,
88 NULL);
81 89
82 // Assign group key info 90 // Assign group key info
83 RTMPAddWcidAttributeEntry(pAd, BSS0, idx, CipherAlg, NULL); 91 RTMPAddWcidAttributeEntry(pAd,
92 BSS0,
93 idx,
94 CipherAlg,
95 NULL);
84 96
85 // Assign pairwise key info 97 // Assign pairwise key info
86 RTMPAddWcidAttributeEntry(pAd, BSS0, idx, CipherAlg, pEntry); 98 RTMPAddWcidAttributeEntry(pAd,
87 99 BSS0,
88 pAd->IndicateMediaState = NdisMediaStateConnected; 100 idx,
89 pAd->ExtraInfo = GENERAL_LINK_UP; 101 CipherAlg,
102 pEntry);
103
104 pAd->IndicateMediaState =
105 NdisMediaStateConnected;
106 pAd->ExtraInfo =
107 GENERAL_LINK_UP;
90#endif // RTMP_MAC_PCI // 108#endif // RTMP_MAC_PCI //
91#ifdef RTMP_MAC_USB 109#ifdef RTMP_MAC_USB
92 union 110 union {
93 { 111 char buf[sizeof
94 char buf[sizeof(NDIS_802_11_WEP)+MAX_LEN_OF_KEY- 1]; 112 (NDIS_802_11_WEP)
113 +
114 MAX_LEN_OF_KEY
115 - 1];
95 NDIS_802_11_WEP keyinfo; 116 NDIS_802_11_WEP keyinfo;
96 } WepKey; 117 }
118 WepKey;
97 int len; 119 int len;
98 120
99 121 NdisZeroMemory(&WepKey,
100 NdisZeroMemory(&WepKey, sizeof(WepKey)); 122 sizeof(WepKey));
101 len =pAd->StaCfg.DesireSharedKey[idx].KeyLen; 123 len =
102 124 pAd->StaCfg.
103 NdisMoveMemory(WepKey.keyinfo.KeyMaterial, 125 DesireSharedKey[idx].KeyLen;
104 pAd->StaCfg.DesireSharedKey[idx].Key, 126
105 pAd->StaCfg.DesireSharedKey[idx].KeyLen); 127 NdisMoveMemory(WepKey.keyinfo.
106 128 KeyMaterial,
107 WepKey.keyinfo.KeyIndex = 0x80000000 + idx; 129 pAd->StaCfg.
130 DesireSharedKey
131 [idx].Key,
132 pAd->StaCfg.
133 DesireSharedKey
134 [idx].KeyLen);
135
136 WepKey.keyinfo.KeyIndex =
137 0x80000000 + idx;
108 WepKey.keyinfo.KeyLength = len; 138 WepKey.keyinfo.KeyLength = len;
109 pAd->SharedKey[BSS0][idx].KeyLen =(UCHAR) (len <= 5 ? 5 : 13); 139 pAd->SharedKey[BSS0][idx].
110 140 KeyLen =
111 pAd->IndicateMediaState = NdisMediaStateConnected; 141 (UCHAR) (len <= 5 ? 5 : 13);
112 pAd->ExtraInfo = GENERAL_LINK_UP; 142
143 pAd->IndicateMediaState =
144 NdisMediaStateConnected;
145 pAd->ExtraInfo =
146 GENERAL_LINK_UP;
113 // need to enqueue cmd to thread 147 // need to enqueue cmd to thread
114 RTUSBEnqueueCmdFromNdis(pAd, OID_802_11_ADD_WEP, TRUE, &WepKey, sizeof(WepKey.keyinfo) + len - 1); 148 RTUSBEnqueueCmdFromNdis(pAd,
149 OID_802_11_ADD_WEP,
150 TRUE,
151 &WepKey,
152 sizeof
153 (WepKey.
154 keyinfo)
155 + len -
156 1);
115#endif // RTMP_MAC_USB // 157#endif // RTMP_MAC_USB //
116 // For Preventing ShardKey Table is cleared by remove key procedure. 158 // For Preventing ShardKey Table is cleared by remove key procedure.
117 pAd->SharedKey[BSS0][idx].CipherAlg = CipherAlg; 159 pAd->SharedKey[BSS0][idx].
118 pAd->SharedKey[BSS0][idx].KeyLen = pAd->StaCfg.DesireSharedKey[idx].KeyLen; 160 CipherAlg = CipherAlg;
119 NdisMoveMemory(pAd->SharedKey[BSS0][idx].Key, 161 pAd->SharedKey[BSS0][idx].
120 pAd->StaCfg.DesireSharedKey[idx].Key, 162 KeyLen =
121 pAd->StaCfg.DesireSharedKey[idx].KeyLen); 163 pAd->StaCfg.
122 } 164 DesireSharedKey[idx].KeyLen;
165 NdisMoveMemory(pAd->
166 SharedKey[BSS0]
167 [idx].Key,
168 pAd->StaCfg.
169 DesireSharedKey
170 [idx].Key,
171 pAd->StaCfg.
172 DesireSharedKey
173 [idx].KeyLen);
174 }
123 } 175 }
124 } 176 }
125 177
126 Indicate_Legacy_Packet(pAd, pRxBlk, FromWhichBSSID); 178 Indicate_Legacy_Packet(pAd, pRxBlk, FromWhichBSSID);
127 return; 179 return;
128 } 180 }
129 } 181 } else {
130 else
131 {
132 // Special DATA frame that has to pass to MLME 182 // Special DATA frame that has to pass to MLME
133 // 1. Cisco Aironet frames for CCX2. We need pass it to MLME for special process 183 // 1. Cisco Aironet frames for CCX2. We need pass it to MLME for special process
134 // 2. EAPOL handshaking frames when driver supplicant enabled, pass to MLME for special process 184 // 2. EAPOL handshaking frames when driver supplicant enabled, pass to MLME for special process
135 { 185 {
136 pTmpBuf = pRxBlk->pData - LENGTH_802_11; 186 pTmpBuf = pRxBlk->pData - LENGTH_802_11;
137 NdisMoveMemory(pTmpBuf, pRxBlk->pHeader, LENGTH_802_11); 187 NdisMoveMemory(pTmpBuf, pRxBlk->pHeader, LENGTH_802_11);
138 REPORT_MGMT_FRAME_TO_MLME(pAd, pRxWI->WirelessCliID, pTmpBuf, pRxBlk->DataSize + LENGTH_802_11, pRxWI->RSSI0, pRxWI->RSSI1, pRxWI->RSSI2, pRxD->PlcpSignal); 188 REPORT_MGMT_FRAME_TO_MLME(pAd, pRxWI->WirelessCliID,
139 DBGPRINT_RAW(RT_DEBUG_TRACE, ("!!! report EAPOL/AIRONET DATA to MLME (len=%d) !!!\n", pRxBlk->DataSize)); 189 pTmpBuf,
190 pRxBlk->DataSize +
191 LENGTH_802_11, pRxWI->RSSI0,
192 pRxWI->RSSI1, pRxWI->RSSI2,
193 pRxD->PlcpSignal);
194 DBGPRINT_RAW(RT_DEBUG_TRACE,
195 ("!!! report EAPOL/AIRONET DATA to MLME (len=%d) !!!\n",
196 pRxBlk->DataSize));
140 } 197 }
141 } 198 }
142 199
@@ -145,126 +202,114 @@ VOID STARxEAPOLFrameIndicate(
145 202
146} 203}
147 204
148VOID STARxDataFrameAnnounce( 205VOID STARxDataFrameAnnounce(IN PRTMP_ADAPTER pAd,
149 IN PRTMP_ADAPTER pAd, 206 IN MAC_TABLE_ENTRY * pEntry,
150 IN MAC_TABLE_ENTRY *pEntry, 207 IN RX_BLK * pRxBlk, IN UCHAR FromWhichBSSID)
151 IN RX_BLK *pRxBlk,
152 IN UCHAR FromWhichBSSID)
153{ 208{
154 209
155 // non-EAP frame 210 // non-EAP frame
156 if (!RTMPCheckWPAframe(pAd, pEntry, pRxBlk->pData, pRxBlk->DataSize, FromWhichBSSID)) 211 if (!RTMPCheckWPAframe
157 { 212 (pAd, pEntry, pRxBlk->pData, pRxBlk->DataSize, FromWhichBSSID)) {
158 213
159 { 214 {
160 // drop all non-EAP DATA frame before 215 // drop all non-EAP DATA frame before
161 // this client's Port-Access-Control is secured 216 // this client's Port-Access-Control is secured
162 if (pRxBlk->pHeader->FC.Wep) 217 if (pRxBlk->pHeader->FC.Wep) {
163 {
164 // unsupported cipher suite 218 // unsupported cipher suite
165 if (pAd->StaCfg.WepStatus == Ndis802_11EncryptionDisabled) 219 if (pAd->StaCfg.WepStatus ==
166 { 220 Ndis802_11EncryptionDisabled) {
167 // release packet 221 // release packet
168 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE); 222 RELEASE_NDIS_PACKET(pAd,
223 pRxBlk->pRxPacket,
224 NDIS_STATUS_FAILURE);
169 return; 225 return;
170 } 226 }
171 } 227 } else {
172 else
173 {
174 // encryption in-use but receive a non-EAPOL clear text frame, drop it 228 // encryption in-use but receive a non-EAPOL clear text frame, drop it
175 if ((pAd->StaCfg.WepStatus != Ndis802_11EncryptionDisabled) && 229 if ((pAd->StaCfg.WepStatus !=
176 (pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED)) 230 Ndis802_11EncryptionDisabled)
177 { 231 && (pAd->StaCfg.PortSecured ==
232 WPA_802_1X_PORT_NOT_SECURED)) {
178 // release packet 233 // release packet
179 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE); 234 RELEASE_NDIS_PACKET(pAd,
235 pRxBlk->pRxPacket,
236 NDIS_STATUS_FAILURE);
180 return; 237 return;
181 } 238 }
182 } 239 }
183 } 240 }
184 RX_BLK_CLEAR_FLAG(pRxBlk, fRX_EAP); 241 RX_BLK_CLEAR_FLAG(pRxBlk, fRX_EAP);
185 if (!RX_BLK_TEST_FLAG(pRxBlk, fRX_ARALINK)) 242 if (!RX_BLK_TEST_FLAG(pRxBlk, fRX_ARALINK)) {
186 {
187 // Normal legacy, AMPDU or AMSDU 243 // Normal legacy, AMPDU or AMSDU
188 CmmRxnonRalinkFrameIndicate(pAd, pRxBlk, FromWhichBSSID); 244 CmmRxnonRalinkFrameIndicate(pAd, pRxBlk,
245 FromWhichBSSID);
189 246
190 } 247 } else {
191 else
192 {
193 // ARALINK 248 // ARALINK
194 CmmRxRalinkFrameIndicate(pAd, pEntry, pRxBlk, FromWhichBSSID); 249 CmmRxRalinkFrameIndicate(pAd, pEntry, pRxBlk,
250 FromWhichBSSID);
195 } 251 }
196 } 252 } else {
197 else
198 {
199 RX_BLK_SET_FLAG(pRxBlk, fRX_EAP); 253 RX_BLK_SET_FLAG(pRxBlk, fRX_EAP);
200 254
201 if (RX_BLK_TEST_FLAG(pRxBlk, fRX_AMPDU) && (pAd->CommonCfg.bDisableReordering == 0)) 255 if (RX_BLK_TEST_FLAG(pRxBlk, fRX_AMPDU)
202 { 256 && (pAd->CommonCfg.bDisableReordering == 0)) {
203 Indicate_AMPDU_Packet(pAd, pRxBlk, FromWhichBSSID); 257 Indicate_AMPDU_Packet(pAd, pRxBlk, FromWhichBSSID);
204 } 258 } else {
205 else
206 {
207 // Determin the destination of the EAP frame 259 // Determin the destination of the EAP frame
208 // to WPA state machine or upper layer 260 // to WPA state machine or upper layer
209 STARxEAPOLFrameIndicate(pAd, pEntry, pRxBlk, FromWhichBSSID); 261 STARxEAPOLFrameIndicate(pAd, pEntry, pRxBlk,
262 FromWhichBSSID);
210 } 263 }
211 } 264 }
212} 265}
213 266
214
215// For TKIP frame, calculate the MIC value 267// For TKIP frame, calculate the MIC value
216BOOLEAN STACheckTkipMICValue( 268BOOLEAN STACheckTkipMICValue(IN PRTMP_ADAPTER pAd,
217 IN PRTMP_ADAPTER pAd, 269 IN MAC_TABLE_ENTRY * pEntry, IN RX_BLK * pRxBlk)
218 IN MAC_TABLE_ENTRY *pEntry,
219 IN RX_BLK *pRxBlk)
220{ 270{
221 PHEADER_802_11 pHeader = pRxBlk->pHeader; 271 PHEADER_802_11 pHeader = pRxBlk->pHeader;
222 UCHAR *pData = pRxBlk->pData; 272 UCHAR *pData = pRxBlk->pData;
223 USHORT DataSize = pRxBlk->DataSize; 273 USHORT DataSize = pRxBlk->DataSize;
224 UCHAR UserPriority = pRxBlk->UserPriority; 274 UCHAR UserPriority = pRxBlk->UserPriority;
225 PCIPHER_KEY pWpaKey; 275 PCIPHER_KEY pWpaKey;
226 UCHAR *pDA, *pSA; 276 UCHAR *pDA, *pSA;
227 277
228 pWpaKey = &pAd->SharedKey[BSS0][pRxBlk->pRxWI->KeyIndex]; 278 pWpaKey = &pAd->SharedKey[BSS0][pRxBlk->pRxWI->KeyIndex];
229 279
230 pDA = pHeader->Addr1; 280 pDA = pHeader->Addr1;
231 if (RX_BLK_TEST_FLAG(pRxBlk, fRX_INFRA)) 281 if (RX_BLK_TEST_FLAG(pRxBlk, fRX_INFRA)) {
232 {
233 pSA = pHeader->Addr3; 282 pSA = pHeader->Addr3;
234 } 283 } else {
235 else
236 {
237 pSA = pHeader->Addr2; 284 pSA = pHeader->Addr2;
238 } 285 }
239 286
240 if (RTMPTkipCompareMICValue(pAd, 287 if (RTMPTkipCompareMICValue(pAd,
241 pData, 288 pData,
242 pDA, 289 pDA,
243 pSA, 290 pSA,
244 pWpaKey->RxMic, 291 pWpaKey->RxMic,
245 UserPriority, 292 UserPriority, DataSize) == FALSE) {
246 DataSize) == FALSE) 293 DBGPRINT_RAW(RT_DEBUG_ERROR, ("Rx MIC Value error 2\n"));
247 { 294
248 DBGPRINT_RAW(RT_DEBUG_ERROR,("Rx MIC Value error 2\n")); 295 if (pAd->StaCfg.WpaSupplicantUP) {
249 296 WpaSendMicFailureToWpaSupplicant(pAd,
250 if (pAd->StaCfg.WpaSupplicantUP) 297 (pWpaKey->Type ==
251 { 298 PAIRWISEKEY) ? TRUE :
252 WpaSendMicFailureToWpaSupplicant(pAd, (pWpaKey->Type == PAIRWISEKEY) ? TRUE : FALSE); 299 FALSE);
253 } 300 } else {
254 else
255 {
256 RTMPReportMicError(pAd, pWpaKey); 301 RTMPReportMicError(pAd, pWpaKey);
257 } 302 }
258 303
259 // release packet 304 // release packet
260 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket, NDIS_STATUS_FAILURE); 305 RELEASE_NDIS_PACKET(pAd, pRxBlk->pRxPacket,
306 NDIS_STATUS_FAILURE);
261 return FALSE; 307 return FALSE;
262 } 308 }
263 309
264 return TRUE; 310 return TRUE;
265} 311}
266 312
267
268// 313//
269// All Rx routines use RX_BLK structure to hande rx events 314// All Rx routines use RX_BLK structure to hande rx events
270// It is very important to build pRxBlk attributes 315// It is very important to build pRxBlk attributes
@@ -273,106 +318,112 @@ BOOLEAN STACheckTkipMICValue(
273// 3. set payload size including LLC to DataSize 318// 3. set payload size including LLC to DataSize
274// 4. set some flags with RX_BLK_SET_FLAG() 319// 4. set some flags with RX_BLK_SET_FLAG()
275// 320//
276VOID STAHandleRxDataFrame( 321VOID STAHandleRxDataFrame(IN PRTMP_ADAPTER pAd, IN RX_BLK * pRxBlk)
277 IN PRTMP_ADAPTER pAd,
278 IN RX_BLK *pRxBlk)
279{ 322{
280 PRT28XX_RXD_STRUC pRxD = &(pRxBlk->RxD); 323 PRT28XX_RXD_STRUC pRxD = &(pRxBlk->RxD);
281 PRXWI_STRUC pRxWI = pRxBlk->pRxWI; 324 PRXWI_STRUC pRxWI = pRxBlk->pRxWI;
282 PHEADER_802_11 pHeader = pRxBlk->pHeader; 325 PHEADER_802_11 pHeader = pRxBlk->pHeader;
283 PNDIS_PACKET pRxPacket = pRxBlk->pRxPacket; 326 PNDIS_PACKET pRxPacket = pRxBlk->pRxPacket;
284 BOOLEAN bFragment = FALSE; 327 BOOLEAN bFragment = FALSE;
285 MAC_TABLE_ENTRY *pEntry = NULL; 328 MAC_TABLE_ENTRY *pEntry = NULL;
286 UCHAR FromWhichBSSID = BSS0; 329 UCHAR FromWhichBSSID = BSS0;
287 UCHAR UserPriority = 0; 330 UCHAR UserPriority = 0;
288 331
289 { 332 {
290 // before LINK UP, all DATA frames are rejected 333 // before LINK UP, all DATA frames are rejected
291 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)) 334 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_MEDIA_STATE_CONNECTED)) {
292 {
293 // release packet 335 // release packet
294 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 336 RELEASE_NDIS_PACKET(pAd, pRxPacket,
337 NDIS_STATUS_FAILURE);
295 return; 338 return;
296 } 339 }
297
298 // Drop not my BSS frames 340 // Drop not my BSS frames
299 if (pRxD->MyBss == 0) 341 if (pRxD->MyBss == 0) {
300 {
301 { 342 {
302 // release packet 343 // release packet
303 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 344 RELEASE_NDIS_PACKET(pAd, pRxPacket,
345 NDIS_STATUS_FAILURE);
304 return; 346 return;
305 } 347 }
306 } 348 }
307 349
308 pAd->RalinkCounters.RxCountSinceLastNULL++; 350 pAd->RalinkCounters.RxCountSinceLastNULL++;
309 if (pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable && (pHeader->FC.SubType & 0x08)) 351 if (pAd->CommonCfg.bAPSDCapable
310 { 352 && pAd->CommonCfg.APEdcaParm.bAPSDCapable
353 && (pHeader->FC.SubType & 0x08)) {
311 UCHAR *pData; 354 UCHAR *pData;
312 DBGPRINT(RT_DEBUG_INFO,("bAPSDCapable\n")); 355 DBGPRINT(RT_DEBUG_INFO, ("bAPSDCapable\n"));
313 356
314 // Qos bit 4 357 // Qos bit 4
315 pData = (PUCHAR)pHeader + LENGTH_802_11; 358 pData = (PUCHAR) pHeader + LENGTH_802_11;
316 if ((*pData >> 4) & 0x01) 359 if ((*pData >> 4) & 0x01) {
317 { 360 DBGPRINT(RT_DEBUG_INFO,
318 DBGPRINT(RT_DEBUG_INFO,("RxDone- Rcv EOSP frame, driver may fall into sleep\n")); 361 ("RxDone- Rcv EOSP frame, driver may fall into sleep\n"));
319 pAd->CommonCfg.bInServicePeriod = FALSE; 362 pAd->CommonCfg.bInServicePeriod = FALSE;
320 363
321 // Force driver to fall into sleep mode when rcv EOSP frame 364 // Force driver to fall into sleep mode when rcv EOSP frame
322 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)) 365 if (!OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)) {
323 { 366 USHORT TbttNumToNextWakeUp;
324 USHORT TbttNumToNextWakeUp; 367 USHORT NextDtim =
325 USHORT NextDtim = pAd->StaCfg.DtimPeriod; 368 pAd->StaCfg.DtimPeriod;
326 ULONG Now; 369 ULONG Now;
327 370
328 NdisGetSystemUpTime(&Now); 371 NdisGetSystemUpTime(&Now);
329 NextDtim -= (USHORT)(Now - pAd->StaCfg.LastBeaconRxTime)/pAd->CommonCfg.BeaconPeriod; 372 NextDtim -=
330 373 (USHORT) (Now -
331 TbttNumToNextWakeUp = pAd->StaCfg.DefaultListenCount; 374 pAd->StaCfg.
332 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_RECEIVE_DTIM) && (TbttNumToNextWakeUp > NextDtim)) 375 LastBeaconRxTime) /
376 pAd->CommonCfg.BeaconPeriod;
377
378 TbttNumToNextWakeUp =
379 pAd->StaCfg.DefaultListenCount;
380 if (OPSTATUS_TEST_FLAG
381 (pAd, fOP_STATUS_RECEIVE_DTIM)
382 && (TbttNumToNextWakeUp > NextDtim))
333 TbttNumToNextWakeUp = NextDtim; 383 TbttNumToNextWakeUp = NextDtim;
334 384
335 RTMP_SET_PSM_BIT(pAd, PWR_SAVE); 385 RTMP_SET_PSM_BIT(pAd, PWR_SAVE);
336 // if WMM-APSD is failed, try to disable following line 386 // if WMM-APSD is failed, try to disable following line
337 AsicSleepThenAutoWakeup(pAd, TbttNumToNextWakeUp); 387 AsicSleepThenAutoWakeup(pAd,
388 TbttNumToNextWakeUp);
338 } 389 }
339 } 390 }
340 391
341 if ((pHeader->FC.MoreData) && (pAd->CommonCfg.bInServicePeriod)) 392 if ((pHeader->FC.MoreData)
342 { 393 && (pAd->CommonCfg.bInServicePeriod)) {
343 DBGPRINT(RT_DEBUG_TRACE,("Sending another trigger frame when More Data bit is set to 1\n")); 394 DBGPRINT(RT_DEBUG_TRACE,
395 ("Sending another trigger frame when More Data bit is set to 1\n"));
344 } 396 }
345 } 397 }
346
347 // Drop NULL, CF-ACK(no data), CF-POLL(no data), and CF-ACK+CF-POLL(no data) data frame 398 // Drop NULL, CF-ACK(no data), CF-POLL(no data), and CF-ACK+CF-POLL(no data) data frame
348 if ((pHeader->FC.SubType & 0x04)) // bit 2 : no DATA 399 if ((pHeader->FC.SubType & 0x04)) // bit 2 : no DATA
349 { 400 {
350 // release packet 401 // release packet
351 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 402 RELEASE_NDIS_PACKET(pAd, pRxPacket,
403 NDIS_STATUS_FAILURE);
352 return; 404 return;
353 } 405 }
406 // Drop not my BSS frame (we can not only check the MyBss bit in RxD)
354 407
355 // Drop not my BSS frame (we can not only check the MyBss bit in RxD) 408 if (INFRA_ON(pAd)) {
356
357 if (INFRA_ON(pAd))
358 {
359 // Infrastructure mode, check address 2 for BSSID 409 // Infrastructure mode, check address 2 for BSSID
360 if (!RTMPEqualMemory(&pHeader->Addr2, &pAd->CommonCfg.Bssid, 6)) 410 if (!RTMPEqualMemory
361 { 411 (&pHeader->Addr2, &pAd->CommonCfg.Bssid, 6)) {
362 // Receive frame not my BSSID 412 // Receive frame not my BSSID
363 // release packet 413 // release packet
364 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 414 RELEASE_NDIS_PACKET(pAd, pRxPacket,
415 NDIS_STATUS_FAILURE);
365 return; 416 return;
366 } 417 }
367 } 418 } else // Ad-Hoc mode or Not associated
368 else // Ad-Hoc mode or Not associated
369 { 419 {
370 // Ad-Hoc mode, check address 3 for BSSID 420 // Ad-Hoc mode, check address 3 for BSSID
371 if (!RTMPEqualMemory(&pHeader->Addr3, &pAd->CommonCfg.Bssid, 6)) 421 if (!RTMPEqualMemory
372 { 422 (&pHeader->Addr3, &pAd->CommonCfg.Bssid, 6)) {
373 // Receive frame not my BSSID 423 // Receive frame not my BSSID
374 // release packet 424 // release packet
375 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 425 RELEASE_NDIS_PACKET(pAd, pRxPacket,
426 NDIS_STATUS_FAILURE);
376 return; 427 return;
377 } 428 }
378 } 429 }
@@ -380,39 +431,35 @@ VOID STAHandleRxDataFrame(
380 // 431 //
381 // find pEntry 432 // find pEntry
382 // 433 //
383 if (pRxWI->WirelessCliID < MAX_LEN_OF_MAC_TABLE) 434 if (pRxWI->WirelessCliID < MAX_LEN_OF_MAC_TABLE) {
384 {
385 pEntry = &pAd->MacTab.Content[pRxWI->WirelessCliID]; 435 pEntry = &pAd->MacTab.Content[pRxWI->WirelessCliID];
386 } 436 } else {
387 else
388 {
389 // 1. release packet if infra mode 437 // 1. release packet if infra mode
390 // 2. new a pEntry if ad-hoc mode 438 // 2. new a pEntry if ad-hoc mode
391 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 439 RELEASE_NDIS_PACKET(pAd, pRxPacket,
440 NDIS_STATUS_FAILURE);
392 return; 441 return;
393 } 442 }
394 443
395 // infra or ad-hoc 444 // infra or ad-hoc
396 if (INFRA_ON(pAd)) 445 if (INFRA_ON(pAd)) {
397 {
398 RX_BLK_SET_FLAG(pRxBlk, fRX_INFRA); 446 RX_BLK_SET_FLAG(pRxBlk, fRX_INFRA);
399 ASSERT(pRxWI->WirelessCliID == BSSID_WCID); 447 ASSERT(pRxWI->WirelessCliID == BSSID_WCID);
400 } 448 }
401
402 // check Atheros Client 449 // check Atheros Client
403 if ((pEntry->bIAmBadAtheros == FALSE) && (pRxD->AMPDU == 1) && (pHeader->FC.Retry )) 450 if ((pEntry->bIAmBadAtheros == FALSE) && (pRxD->AMPDU == 1)
404 { 451 && (pHeader->FC.Retry)) {
405 pEntry->bIAmBadAtheros = TRUE; 452 pEntry->bIAmBadAtheros = TRUE;
406 pAd->CommonCfg.IOTestParm.bCurrentAtheros = TRUE; 453 pAd->CommonCfg.IOTestParm.bCurrentAtheros = TRUE;
407 pAd->CommonCfg.IOTestParm.bLastAtheros = TRUE; 454 pAd->CommonCfg.IOTestParm.bLastAtheros = TRUE;
408 if (!STA_AES_ON(pAd)) 455 if (!STA_AES_ON(pAd)) {
409 { 456 AsicUpdateProtect(pAd, 8, ALLN_SETPROTECT, TRUE,
410 AsicUpdateProtect(pAd, 8, ALLN_SETPROTECT, TRUE, FALSE); 457 FALSE);
411 } 458 }
412 } 459 }
413 } 460 }
414 461
415 pRxBlk->pData = (UCHAR *)pHeader; 462 pRxBlk->pData = (UCHAR *) pHeader;
416 463
417 // 464 //
418 // update RxBlk->pData, DataSize 465 // update RxBlk->pData, DataSize
@@ -426,48 +473,41 @@ VOID STAHandleRxDataFrame(
426 } 473 }
427 474
428 // 2. QOS 475 // 2. QOS
429 if (pHeader->FC.SubType & 0x08) 476 if (pHeader->FC.SubType & 0x08) {
430 {
431 RX_BLK_SET_FLAG(pRxBlk, fRX_QOS); 477 RX_BLK_SET_FLAG(pRxBlk, fRX_QOS);
432 UserPriority = *(pRxBlk->pData) & 0x0f; 478 UserPriority = *(pRxBlk->pData) & 0x0f;
433 // bit 7 in QoS Control field signals the HT A-MSDU format 479 // bit 7 in QoS Control field signals the HT A-MSDU format
434 if ((*pRxBlk->pData) & 0x80) 480 if ((*pRxBlk->pData) & 0x80) {
435 {
436 RX_BLK_SET_FLAG(pRxBlk, fRX_AMSDU); 481 RX_BLK_SET_FLAG(pRxBlk, fRX_AMSDU);
437 } 482 }
438
439 // skip QOS contorl field 483 // skip QOS contorl field
440 pRxBlk->pData += 2; 484 pRxBlk->pData += 2;
441 pRxBlk->DataSize -=2; 485 pRxBlk->DataSize -= 2;
442 } 486 }
443 pRxBlk->UserPriority = UserPriority; 487 pRxBlk->UserPriority = UserPriority;
444 488
445 /* check if need to resend PS Poll when received packet with MoreData = 1 */ 489 /* check if need to resend PS Poll when received packet with MoreData = 1 */
446 if ((pAd->StaCfg.Psm == PWR_SAVE) && (pHeader->FC.MoreData == 1)) 490 if ((pAd->StaCfg.Psm == PWR_SAVE) && (pHeader->FC.MoreData == 1)) {
447 {
448 if ((((UserPriority == 0) || (UserPriority == 3)) && 491 if ((((UserPriority == 0) || (UserPriority == 3)) &&
449 pAd->CommonCfg.bAPSDAC_BE == 0) || 492 pAd->CommonCfg.bAPSDAC_BE == 0) ||
450 (((UserPriority == 1) || (UserPriority == 2)) && 493 (((UserPriority == 1) || (UserPriority == 2)) &&
451 pAd->CommonCfg.bAPSDAC_BK == 0) || 494 pAd->CommonCfg.bAPSDAC_BK == 0) ||
452 (((UserPriority == 4) || (UserPriority == 5)) && 495 (((UserPriority == 4) || (UserPriority == 5)) &&
453 pAd->CommonCfg.bAPSDAC_VI == 0) || 496 pAd->CommonCfg.bAPSDAC_VI == 0) ||
454 (((UserPriority == 6) || (UserPriority == 7)) && 497 (((UserPriority == 6) || (UserPriority == 7)) &&
455 pAd->CommonCfg.bAPSDAC_VO == 0)) 498 pAd->CommonCfg.bAPSDAC_VO == 0)) {
456 {
457 /* non-UAPSD delivery-enabled AC */ 499 /* non-UAPSD delivery-enabled AC */
458 RTMP_PS_POLL_ENQUEUE(pAd); 500 RTMP_PS_POLL_ENQUEUE(pAd);
459 } 501 }
460 } 502 }
461
462 // 3. Order bit: A-Ralink or HTC+ 503 // 3. Order bit: A-Ralink or HTC+
463 if (pHeader->FC.Order) 504 if (pHeader->FC.Order) {
464 {
465#ifdef AGGREGATION_SUPPORT 505#ifdef AGGREGATION_SUPPORT
466 if ((pRxWI->PHYMODE <= MODE_OFDM) && (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_AGGREGATION_INUSED))) 506 if ((pRxWI->PHYMODE <= MODE_OFDM)
507 && (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_AGGREGATION_INUSED)))
467 { 508 {
468 RX_BLK_SET_FLAG(pRxBlk, fRX_ARALINK); 509 RX_BLK_SET_FLAG(pRxBlk, fRX_ARALINK);
469 } 510 } else
470 else
471#endif // AGGREGATION_SUPPORT // 511#endif // AGGREGATION_SUPPORT //
472 { 512 {
473 RX_BLK_SET_FLAG(pRxBlk, fRX_HTC); 513 RX_BLK_SET_FLAG(pRxBlk, fRX_HTC);
@@ -476,102 +516,93 @@ VOID STAHandleRxDataFrame(
476 pRxBlk->DataSize -= 4; 516 pRxBlk->DataSize -= 4;
477 } 517 }
478 } 518 }
479
480 // 4. skip HW padding 519 // 4. skip HW padding
481 if (pRxD->L2PAD) 520 if (pRxD->L2PAD) {
482 {
483 // just move pData pointer 521 // just move pData pointer
484 // because DataSize excluding HW padding 522 // because DataSize excluding HW padding
485 RX_BLK_SET_FLAG(pRxBlk, fRX_PAD); 523 RX_BLK_SET_FLAG(pRxBlk, fRX_PAD);
486 pRxBlk->pData += 2; 524 pRxBlk->pData += 2;
487 } 525 }
488 526
489 if (pRxD->BA) 527 if (pRxD->BA) {
490 {
491 RX_BLK_SET_FLAG(pRxBlk, fRX_AMPDU); 528 RX_BLK_SET_FLAG(pRxBlk, fRX_AMPDU);
492 } 529 }
493
494 // 530 //
495 // Case I Process Broadcast & Multicast data frame 531 // Case I Process Broadcast & Multicast data frame
496 // 532 //
497 if (pRxD->Bcast || pRxD->Mcast) 533 if (pRxD->Bcast || pRxD->Mcast) {
498 {
499 INC_COUNTER64(pAd->WlanCounters.MulticastReceivedFrameCount); 534 INC_COUNTER64(pAd->WlanCounters.MulticastReceivedFrameCount);
500 535
501 // Drop Mcast/Bcast frame with fragment bit on 536 // Drop Mcast/Bcast frame with fragment bit on
502 if (pHeader->FC.MoreFrag) 537 if (pHeader->FC.MoreFrag) {
503 {
504 // release packet 538 // release packet
505 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 539 RELEASE_NDIS_PACKET(pAd, pRxPacket,
540 NDIS_STATUS_FAILURE);
506 return; 541 return;
507 } 542 }
508
509 // Filter out Bcast frame which AP relayed for us 543 // Filter out Bcast frame which AP relayed for us
510 if (pHeader->FC.FrDs && MAC_ADDR_EQUAL(pHeader->Addr3, pAd->CurrentAddress)) 544 if (pHeader->FC.FrDs
511 { 545 && MAC_ADDR_EQUAL(pHeader->Addr3, pAd->CurrentAddress)) {
512 // release packet 546 // release packet
513 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 547 RELEASE_NDIS_PACKET(pAd, pRxPacket,
548 NDIS_STATUS_FAILURE);
514 return; 549 return;
515 } 550 }
516 551
517 Indicate_Legacy_Packet(pAd, pRxBlk, FromWhichBSSID); 552 Indicate_Legacy_Packet(pAd, pRxBlk, FromWhichBSSID);
518 return; 553 return;
519 } 554 } else if (pRxD->U2M) {
520 else if (pRxD->U2M) 555 pAd->LastRxRate =
521 { 556 (USHORT) ((pRxWI->MCS) + (pRxWI->BW << 7) +
522 pAd->LastRxRate = (USHORT)((pRxWI->MCS) + (pRxWI->BW <<7) + (pRxWI->ShortGI <<8)+ (pRxWI->PHYMODE <<14)) ; 557 (pRxWI->ShortGI << 8) + (pRxWI->PHYMODE << 14));
523 558
524 if (ADHOC_ON(pAd)) 559 if (ADHOC_ON(pAd)) {
525 {
526 pEntry = MacTableLookup(pAd, pHeader->Addr2); 560 pEntry = MacTableLookup(pAd, pHeader->Addr2);
527 if (pEntry) 561 if (pEntry)
528 Update_Rssi_Sample(pAd, &pEntry->RssiSample, pRxWI); 562 Update_Rssi_Sample(pAd, &pEntry->RssiSample,
563 pRxWI);
529 } 564 }
530 565
531
532 Update_Rssi_Sample(pAd, &pAd->StaCfg.RssiSample, pRxWI); 566 Update_Rssi_Sample(pAd, &pAd->StaCfg.RssiSample, pRxWI);
533 567
534 pAd->StaCfg.LastSNR0 = (UCHAR)(pRxWI->SNR0); 568 pAd->StaCfg.LastSNR0 = (UCHAR) (pRxWI->SNR0);
535 pAd->StaCfg.LastSNR1 = (UCHAR)(pRxWI->SNR1); 569 pAd->StaCfg.LastSNR1 = (UCHAR) (pRxWI->SNR1);
536 570
537 pAd->RalinkCounters.OneSecRxOkDataCnt++; 571 pAd->RalinkCounters.OneSecRxOkDataCnt++;
538 572
573 if (!((pHeader->Frag == 0) && (pHeader->FC.MoreFrag == 0))) {
574 // re-assemble the fragmented packets
575 // return complete frame (pRxPacket) or NULL
576 bFragment = TRUE;
577 pRxPacket = RTMPDeFragmentDataFrame(pAd, pRxBlk);
578 }
539 579
540 if (!((pHeader->Frag == 0) && (pHeader->FC.MoreFrag == 0))) 580 if (pRxPacket) {
541 {
542 // re-assemble the fragmented packets
543 // return complete frame (pRxPacket) or NULL
544 bFragment = TRUE;
545 pRxPacket = RTMPDeFragmentDataFrame(pAd, pRxBlk);
546 }
547
548 if (pRxPacket)
549 {
550 pEntry = &pAd->MacTab.Content[pRxWI->WirelessCliID]; 581 pEntry = &pAd->MacTab.Content[pRxWI->WirelessCliID];
551 582
552 // process complete frame 583 // process complete frame
553 if (bFragment && (pRxD->Decrypted) && (pEntry->WepStatus == Ndis802_11Encryption2Enabled)) 584 if (bFragment && (pRxD->Decrypted)
554 { 585 && (pEntry->WepStatus ==
586 Ndis802_11Encryption2Enabled)) {
555 // Minus MIC length 587 // Minus MIC length
556 pRxBlk->DataSize -= 8; 588 pRxBlk->DataSize -= 8;
557 589
558 // For TKIP frame, calculate the MIC value 590 // For TKIP frame, calculate the MIC value
559 if (STACheckTkipMICValue(pAd, pEntry, pRxBlk) == FALSE) 591 if (STACheckTkipMICValue(pAd, pEntry, pRxBlk) ==
560 { 592 FALSE) {
561 return; 593 return;
562 } 594 }
563 } 595 }
564 596
565 STARxDataFrameAnnounce(pAd, pEntry, pRxBlk, FromWhichBSSID); 597 STARxDataFrameAnnounce(pAd, pEntry, pRxBlk,
598 FromWhichBSSID);
599 return;
600 } else {
601 // just return
602 // because RTMPDeFragmentDataFrame() will release rx packet,
603 // if packet is fragmented
566 return; 604 return;
567 } 605 }
568 else
569 {
570 // just return
571 // because RTMPDeFragmentDataFrame() will release rx packet,
572 // if packet is fragmented
573 return;
574 }
575 } 606 }
576 607
577 ASSERT(0); 608 ASSERT(0);
@@ -579,25 +610,20 @@ VOID STAHandleRxDataFrame(
579 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 610 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
580} 611}
581 612
582VOID STAHandleRxMgmtFrame( 613VOID STAHandleRxMgmtFrame(IN PRTMP_ADAPTER pAd, IN RX_BLK * pRxBlk)
583 IN PRTMP_ADAPTER pAd,
584 IN RX_BLK *pRxBlk)
585{ 614{
586 PRT28XX_RXD_STRUC pRxD = &(pRxBlk->RxD); 615 PRT28XX_RXD_STRUC pRxD = &(pRxBlk->RxD);
587 PRXWI_STRUC pRxWI = pRxBlk->pRxWI; 616 PRXWI_STRUC pRxWI = pRxBlk->pRxWI;
588 PHEADER_802_11 pHeader = pRxBlk->pHeader; 617 PHEADER_802_11 pHeader = pRxBlk->pHeader;
589 PNDIS_PACKET pRxPacket = pRxBlk->pRxPacket; 618 PNDIS_PACKET pRxPacket = pRxBlk->pRxPacket;
590
591 do
592 {
593 619
620 do {
594 621
595 /* check if need to resend PS Poll when received packet with MoreData = 1 */ 622 /* check if need to resend PS Poll when received packet with MoreData = 1 */
596 if ((pAd->StaCfg.Psm == PWR_SAVE) && (pHeader->FC.MoreData == 1)) 623 if ((pAd->StaCfg.Psm == PWR_SAVE)
597 { 624 && (pHeader->FC.MoreData == 1)) {
598 /* for UAPSD, all management frames will be VO priority */ 625 /* for UAPSD, all management frames will be VO priority */
599 if (pAd->CommonCfg.bAPSDAC_VO == 0) 626 if (pAd->CommonCfg.bAPSDAC_VO == 0) {
600 {
601 /* non-UAPSD delivery-enabled AC */ 627 /* non-UAPSD delivery-enabled AC */
602 RTMP_PS_POLL_ENQUEUE(pAd); 628 RTMP_PS_POLL_ENQUEUE(pAd);
603 } 629 }
@@ -605,57 +631,54 @@ VOID STAHandleRxMgmtFrame(
605 631
606 /* TODO: if MoreData == 0, station can go to sleep */ 632 /* TODO: if MoreData == 0, station can go to sleep */
607 633
608
609 // We should collect RSSI not only U2M data but also my beacon 634 // We should collect RSSI not only U2M data but also my beacon
610 if ((pHeader->FC.SubType == SUBTYPE_BEACON) && (MAC_ADDR_EQUAL(&pAd->CommonCfg.Bssid, &pHeader->Addr2)) 635 if ((pHeader->FC.SubType == SUBTYPE_BEACON)
611 && (pAd->RxAnt.EvaluatePeriod == 0)) 636 && (MAC_ADDR_EQUAL(&pAd->CommonCfg.Bssid, &pHeader->Addr2))
612 { 637 && (pAd->RxAnt.EvaluatePeriod == 0)) {
613 Update_Rssi_Sample(pAd, &pAd->StaCfg.RssiSample, pRxWI); 638 Update_Rssi_Sample(pAd, &pAd->StaCfg.RssiSample, pRxWI);
614 639
615 pAd->StaCfg.LastSNR0 = (UCHAR)(pRxWI->SNR0); 640 pAd->StaCfg.LastSNR0 = (UCHAR) (pRxWI->SNR0);
616 pAd->StaCfg.LastSNR1 = (UCHAR)(pRxWI->SNR1); 641 pAd->StaCfg.LastSNR1 = (UCHAR) (pRxWI->SNR1);
617 } 642 }
618 643
619
620 // First check the size, it MUST not exceed the mlme queue size 644 // First check the size, it MUST not exceed the mlme queue size
621 if (pRxWI->MPDUtotalByteCount > MGMT_DMA_BUFFER_SIZE) 645 if (pRxWI->MPDUtotalByteCount > MGMT_DMA_BUFFER_SIZE) {
622 {
623 DBGPRINT_ERR(("STAHandleRxMgmtFrame: frame too large, size = %d \n", pRxWI->MPDUtotalByteCount)); 646 DBGPRINT_ERR(("STAHandleRxMgmtFrame: frame too large, size = %d \n", pRxWI->MPDUtotalByteCount));
624 break; 647 break;
625 } 648 }
626 649
627 REPORT_MGMT_FRAME_TO_MLME(pAd, pRxWI->WirelessCliID, pHeader, pRxWI->MPDUtotalByteCount, 650 REPORT_MGMT_FRAME_TO_MLME(pAd, pRxWI->WirelessCliID, pHeader,
628 pRxWI->RSSI0, pRxWI->RSSI1, pRxWI->RSSI2, pRxD->PlcpSignal); 651 pRxWI->MPDUtotalByteCount,
652 pRxWI->RSSI0, pRxWI->RSSI1,
653 pRxWI->RSSI2, pRxD->PlcpSignal);
629 } while (FALSE); 654 } while (FALSE);
630 655
631 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_SUCCESS); 656 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_SUCCESS);
632} 657}
633 658
634VOID STAHandleRxControlFrame( 659VOID STAHandleRxControlFrame(IN PRTMP_ADAPTER pAd, IN RX_BLK * pRxBlk)
635 IN PRTMP_ADAPTER pAd,
636 IN RX_BLK *pRxBlk)
637{ 660{
638 PRXWI_STRUC pRxWI = pRxBlk->pRxWI; 661 PRXWI_STRUC pRxWI = pRxBlk->pRxWI;
639 PHEADER_802_11 pHeader = pRxBlk->pHeader; 662 PHEADER_802_11 pHeader = pRxBlk->pHeader;
640 PNDIS_PACKET pRxPacket = pRxBlk->pRxPacket; 663 PNDIS_PACKET pRxPacket = pRxBlk->pRxPacket;
641 664
642 switch (pHeader->FC.SubType) 665 switch (pHeader->FC.SubType) {
643 { 666 case SUBTYPE_BLOCK_ACK_REQ:
644 case SUBTYPE_BLOCK_ACK_REQ: 667 {
645 { 668 CntlEnqueueForRecv(pAd, pRxWI->WirelessCliID,
646 CntlEnqueueForRecv(pAd, pRxWI->WirelessCliID, (pRxWI->MPDUtotalByteCount), (PFRAME_BA_REQ)pHeader); 669 (pRxWI->MPDUtotalByteCount),
647 } 670 (PFRAME_BA_REQ) pHeader);
648 break; 671 }
649 case SUBTYPE_BLOCK_ACK: 672 break;
650 case SUBTYPE_ACK: 673 case SUBTYPE_BLOCK_ACK:
651 default: 674 case SUBTYPE_ACK:
652 break; 675 default:
676 break;
653 } 677 }
654 678
655 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 679 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE);
656} 680}
657 681
658
659/* 682/*
660 ======================================================================== 683 ========================================================================
661 684
@@ -675,45 +698,39 @@ VOID STAHandleRxControlFrame(
675 Need to consider QOS DATA format when converting to 802.3 698 Need to consider QOS DATA format when converting to 802.3
676 ======================================================================== 699 ========================================================================
677*/ 700*/
678BOOLEAN STARxDoneInterruptHandle( 701BOOLEAN STARxDoneInterruptHandle(IN PRTMP_ADAPTER pAd, IN BOOLEAN argc)
679 IN PRTMP_ADAPTER pAd,
680 IN BOOLEAN argc)
681{ 702{
682 NDIS_STATUS Status; 703 NDIS_STATUS Status;
683 UINT32 RxProcessed, RxPending; 704 UINT32 RxProcessed, RxPending;
684 BOOLEAN bReschedule = FALSE; 705 BOOLEAN bReschedule = FALSE;
685 RT28XX_RXD_STRUC *pRxD; 706 RT28XX_RXD_STRUC *pRxD;
686 UCHAR *pData; 707 UCHAR *pData;
687 PRXWI_STRUC pRxWI; 708 PRXWI_STRUC pRxWI;
688 PNDIS_PACKET pRxPacket; 709 PNDIS_PACKET pRxPacket;
689 PHEADER_802_11 pHeader; 710 PHEADER_802_11 pHeader;
690 RX_BLK RxCell; 711 RX_BLK RxCell;
691 712
692 RxProcessed = RxPending = 0; 713 RxProcessed = RxPending = 0;
693 714
694 // process whole rx ring 715 // process whole rx ring
695 while (1) 716 while (1) {
696 {
697 717
698 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF | 718 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF |
699 fRTMP_ADAPTER_RESET_IN_PROGRESS | 719 fRTMP_ADAPTER_RESET_IN_PROGRESS |
700 fRTMP_ADAPTER_HALT_IN_PROGRESS | 720 fRTMP_ADAPTER_HALT_IN_PROGRESS |
701 fRTMP_ADAPTER_NIC_NOT_EXIST) || 721 fRTMP_ADAPTER_NIC_NOT_EXIST) ||
702 !RTMP_TEST_FLAG(pAd,fRTMP_ADAPTER_START_UP)) 722 !RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_START_UP)) {
703 {
704 break; 723 break;
705 } 724 }
706
707#ifdef RTMP_MAC_PCI 725#ifdef RTMP_MAC_PCI
708 if (RxProcessed++ > MAX_RX_PROCESS_CNT) 726 if (RxProcessed++ > MAX_RX_PROCESS_CNT) {
709 {
710 // need to reschedule rx handle 727 // need to reschedule rx handle
711 bReschedule = TRUE; 728 bReschedule = TRUE;
712 break; 729 break;
713 } 730 }
714#endif // RTMP_MAC_PCI // 731#endif // RTMP_MAC_PCI //
715 732
716 RxProcessed ++; // test 733 RxProcessed++; // test
717 734
718 // 1. allocate a new data packet into rx ring to replace received packet 735 // 1. allocate a new data packet into rx ring to replace received packet
719 // then processing the received packet 736 // then processing the received packet
@@ -722,19 +739,19 @@ BOOLEAN STARxDoneInterruptHandle(
722 // the rx packet must 739 // the rx packet must
723 // a. be indicated to upper layer or 740 // a. be indicated to upper layer or
724 // b. be released if it is discarded 741 // b. be released if it is discarded
725 pRxPacket = GetPacketFromRxRing(pAd, &(RxCell.RxD), &bReschedule, &RxPending); 742 pRxPacket =
726 if (pRxPacket == NULL) 743 GetPacketFromRxRing(pAd, &(RxCell.RxD), &bReschedule,
727 { 744 &RxPending);
745 if (pRxPacket == NULL) {
728 // no more packet to process 746 // no more packet to process
729 break; 747 break;
730 } 748 }
731
732 // get rx ring descriptor 749 // get rx ring descriptor
733 pRxD = &(RxCell.RxD); 750 pRxD = &(RxCell.RxD);
734 // get rx data buffer 751 // get rx data buffer
735 pData = GET_OS_PKT_DATAPTR(pRxPacket); 752 pData = GET_OS_PKT_DATAPTR(pRxPacket);
736 pRxWI = (PRXWI_STRUC) pData; 753 pRxWI = (PRXWI_STRUC) pData;
737 pHeader = (PHEADER_802_11) (pData+RXWI_SIZE) ; 754 pHeader = (PHEADER_802_11) (pData + RXWI_SIZE);
738 755
739 // build RxCell 756 // build RxCell
740 RxCell.pRxWI = pRxWI; 757 RxCell.pRxWI = pRxWI;
@@ -745,18 +762,19 @@ BOOLEAN STARxDoneInterruptHandle(
745 RxCell.Flags = 0; 762 RxCell.Flags = 0;
746 763
747 // Increase Total receive byte counter after real data received no mater any error or not 764 // Increase Total receive byte counter after real data received no mater any error or not
748 pAd->RalinkCounters.ReceivedByteCount += pRxWI->MPDUtotalByteCount; 765 pAd->RalinkCounters.ReceivedByteCount +=
749 pAd->RalinkCounters.OneSecReceivedByteCount += pRxWI->MPDUtotalByteCount; 766 pRxWI->MPDUtotalByteCount;
750 pAd->RalinkCounters.RxCount ++; 767 pAd->RalinkCounters.OneSecReceivedByteCount +=
768 pRxWI->MPDUtotalByteCount;
769 pAd->RalinkCounters.RxCount++;
751 770
752 INC_COUNTER64(pAd->WlanCounters.ReceivedFragmentCount); 771 INC_COUNTER64(pAd->WlanCounters.ReceivedFragmentCount);
753 772
754 if (pRxWI->MPDUtotalByteCount < 14) 773 if (pRxWI->MPDUtotalByteCount < 14)
755 Status = NDIS_STATUS_FAILURE; 774 Status = NDIS_STATUS_FAILURE;
756 775
757 if (MONITOR_ON(pAd)) 776 if (MONITOR_ON(pAd)) {
758 { 777 send_monitor_packets(pAd, &RxCell);
759 send_monitor_packets(pAd, &RxCell);
760 break; 778 break;
761 } 779 }
762 780
@@ -766,40 +784,38 @@ BOOLEAN STARxDoneInterruptHandle(
766 Status = RTMPCheckRxError(pAd, pHeader, pRxWI, pRxD); 784 Status = RTMPCheckRxError(pAd, pHeader, pRxWI, pRxD);
767 785
768 // Handle the received frame 786 // Handle the received frame
769 if (Status == NDIS_STATUS_SUCCESS) 787 if (Status == NDIS_STATUS_SUCCESS) {
770 { 788 switch (pHeader->FC.Type) {
771 switch (pHeader->FC.Type)
772 {
773 // CASE I, receive a DATA frame 789 // CASE I, receive a DATA frame
774 case BTYPE_DATA: 790 case BTYPE_DATA:
775 { 791 {
776 // process DATA frame 792 // process DATA frame
777 STAHandleRxDataFrame(pAd, &RxCell); 793 STAHandleRxDataFrame(pAd, &RxCell);
778 } 794 }
779 break; 795 break;
780 // CASE II, receive a MGMT frame 796 // CASE II, receive a MGMT frame
781 case BTYPE_MGMT: 797 case BTYPE_MGMT:
782 { 798 {
783 STAHandleRxMgmtFrame(pAd, &RxCell); 799 STAHandleRxMgmtFrame(pAd, &RxCell);
784 } 800 }
785 break; 801 break;
786 // CASE III. receive a CNTL frame 802 // CASE III. receive a CNTL frame
787 case BTYPE_CNTL: 803 case BTYPE_CNTL:
788 { 804 {
789 STAHandleRxControlFrame(pAd, &RxCell); 805 STAHandleRxControlFrame(pAd, &RxCell);
790 } 806 }
791 break; 807 break;
792 // discard other type 808 // discard other type
793 default: 809 default:
794 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 810 RELEASE_NDIS_PACKET(pAd, pRxPacket,
795 break; 811 NDIS_STATUS_FAILURE);
812 break;
796 } 813 }
797 } 814 } else {
798 else
799 {
800 pAd->Counters8023.RxErrors++; 815 pAd->Counters8023.RxErrors++;
801 // discard this frame 816 // discard this frame
802 RELEASE_NDIS_PACKET(pAd, pRxPacket, NDIS_STATUS_FAILURE); 817 RELEASE_NDIS_PACKET(pAd, pRxPacket,
818 NDIS_STATUS_FAILURE);
803 } 819 }
804 } 820 }
805 821
@@ -817,8 +833,7 @@ BOOLEAN STARxDoneInterruptHandle(
817 833
818 ======================================================================== 834 ========================================================================
819*/ 835*/
820VOID RTMPHandleTwakeupInterrupt( 836VOID RTMPHandleTwakeupInterrupt(IN PRTMP_ADAPTER pAd)
821 IN PRTMP_ADAPTER pAd)
822{ 837{
823 AsicForceWakeup(pAd, FALSE); 838 AsicForceWakeup(pAd, FALSE);
824} 839}
@@ -841,47 +856,39 @@ Note:
841 You only can put OS-depened & STA related code in here. 856 You only can put OS-depened & STA related code in here.
842======================================================================== 857========================================================================
843*/ 858*/
844VOID STASendPackets( 859VOID STASendPackets(IN NDIS_HANDLE MiniportAdapterContext,
845 IN NDIS_HANDLE MiniportAdapterContext, 860 IN PPNDIS_PACKET ppPacketArray, IN UINT NumberOfPackets)
846 IN PPNDIS_PACKET ppPacketArray,
847 IN UINT NumberOfPackets)
848{ 861{
849 UINT Index; 862 UINT Index;
850 PRTMP_ADAPTER pAd = (PRTMP_ADAPTER) MiniportAdapterContext; 863 PRTMP_ADAPTER pAd = (PRTMP_ADAPTER) MiniportAdapterContext;
851 PNDIS_PACKET pPacket; 864 PNDIS_PACKET pPacket;
852 BOOLEAN allowToSend = FALSE; 865 BOOLEAN allowToSend = FALSE;
853
854 866
855 for (Index = 0; Index < NumberOfPackets; Index++) 867 for (Index = 0; Index < NumberOfPackets; Index++) {
856 {
857 pPacket = ppPacketArray[Index]; 868 pPacket = ppPacketArray[Index];
858 869
859 do 870 do {
860 { 871 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS)
861 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RESET_IN_PROGRESS) || 872 || RTMP_TEST_FLAG(pAd,
862 RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_HALT_IN_PROGRESS) || 873 fRTMP_ADAPTER_HALT_IN_PROGRESS)
863 RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)) 874 || RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_RADIO_OFF)) {
864 {
865 // Drop send request since hardware is in reset state 875 // Drop send request since hardware is in reset state
866 break; 876 break;
867 } 877 } else if (!INFRA_ON(pAd) && !ADHOC_ON(pAd)) {
868 else if (!INFRA_ON(pAd) && !ADHOC_ON(pAd))
869 {
870 // Drop send request since there are no physical connection yet 878 // Drop send request since there are no physical connection yet
871 break; 879 break;
872 } 880 } else {
873 else
874 {
875 // Record that orignal packet source is from NDIS layer,so that 881 // Record that orignal packet source is from NDIS layer,so that
876 // later on driver knows how to release this NDIS PACKET 882 // later on driver knows how to release this NDIS PACKET
877 RTMP_SET_PACKET_WCID(pPacket, 0); // this field is useless when in STA mode 883 RTMP_SET_PACKET_WCID(pPacket, 0); // this field is useless when in STA mode
878 RTMP_SET_PACKET_SOURCE(pPacket, PKTSRC_NDIS); 884 RTMP_SET_PACKET_SOURCE(pPacket, PKTSRC_NDIS);
879 NDIS_SET_PACKET_STATUS(pPacket, NDIS_STATUS_PENDING); 885 NDIS_SET_PACKET_STATUS(pPacket,
886 NDIS_STATUS_PENDING);
880 pAd->RalinkCounters.PendingNdisPacketCount++; 887 pAd->RalinkCounters.PendingNdisPacketCount++;
881 888
882 allowToSend = TRUE; 889 allowToSend = TRUE;
883 } 890 }
884 } while(FALSE); 891 } while (FALSE);
885 892
886 if (allowToSend == TRUE) 893 if (allowToSend == TRUE)
887 STASendPacket(pAd, pPacket); 894 STASendPacket(pAd, pPacket);
@@ -894,7 +901,6 @@ VOID STASendPackets(
894 901
895} 902}
896 903
897
898/* 904/*
899======================================================================== 905========================================================================
900Routine Description: 906Routine Description:
@@ -914,72 +920,64 @@ Note:
914 You only can put OS-indepened & STA related code in here. 920 You only can put OS-indepened & STA related code in here.
915======================================================================== 921========================================================================
916*/ 922*/
917NDIS_STATUS STASendPacket( 923NDIS_STATUS STASendPacket(IN PRTMP_ADAPTER pAd, IN PNDIS_PACKET pPacket)
918 IN PRTMP_ADAPTER pAd,
919 IN PNDIS_PACKET pPacket)
920{ 924{
921 PACKET_INFO PacketInfo; 925 PACKET_INFO PacketInfo;
922 PUCHAR pSrcBufVA; 926 PUCHAR pSrcBufVA;
923 UINT SrcBufLen; 927 UINT SrcBufLen;
924 UINT AllowFragSize; 928 UINT AllowFragSize;
925 UCHAR NumberOfFrag; 929 UCHAR NumberOfFrag;
926 UCHAR RTSRequired; 930 UCHAR RTSRequired;
927 UCHAR QueIdx, UserPriority; 931 UCHAR QueIdx, UserPriority;
928 MAC_TABLE_ENTRY *pEntry = NULL; 932 MAC_TABLE_ENTRY *pEntry = NULL;
929 unsigned int IrqFlags; 933 unsigned int IrqFlags;
930 UCHAR FlgIsIP = 0; 934 UCHAR FlgIsIP = 0;
931 UCHAR Rate; 935 UCHAR Rate;
932 936
933 // Prepare packet information structure for buffer descriptor 937 // Prepare packet information structure for buffer descriptor
934 // chained within a single NDIS packet. 938 // chained within a single NDIS packet.
935 RTMP_QueryPacketInfo(pPacket, &PacketInfo, &pSrcBufVA, &SrcBufLen); 939 RTMP_QueryPacketInfo(pPacket, &PacketInfo, &pSrcBufVA, &SrcBufLen);
936 940
937 if (pSrcBufVA == NULL) 941 if (pSrcBufVA == NULL) {
938 { 942 DBGPRINT(RT_DEBUG_ERROR,
939 DBGPRINT(RT_DEBUG_ERROR,("STASendPacket --> pSrcBufVA == NULL !!!SrcBufLen=%x\n",SrcBufLen)); 943 ("STASendPacket --> pSrcBufVA == NULL !!!SrcBufLen=%x\n",
944 SrcBufLen));
940 // Resourece is low, system did not allocate virtual address 945 // Resourece is low, system did not allocate virtual address
941 // return NDIS_STATUS_FAILURE directly to upper layer 946 // return NDIS_STATUS_FAILURE directly to upper layer
942 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE); 947 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
943 return NDIS_STATUS_FAILURE; 948 return NDIS_STATUS_FAILURE;
944 } 949 }
945 950
946 951 if (SrcBufLen < 14) {
947 if (SrcBufLen < 14) 952 DBGPRINT(RT_DEBUG_ERROR,
948 { 953 ("STASendPacket --> Ndis Packet buffer error !!!\n"));
949 DBGPRINT(RT_DEBUG_ERROR,("STASendPacket --> Ndis Packet buffer error !!!\n"));
950 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE); 954 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
951 return (NDIS_STATUS_FAILURE); 955 return (NDIS_STATUS_FAILURE);
952 } 956 }
953
954 // In HT rate adhoc mode, A-MPDU is often used. So need to lookup BA Table and MAC Entry. 957 // In HT rate adhoc mode, A-MPDU is often used. So need to lookup BA Table and MAC Entry.
955 // Note multicast packets in adhoc also use BSSID_WCID index. 958 // Note multicast packets in adhoc also use BSSID_WCID index.
956 { 959 {
957 if(INFRA_ON(pAd)) 960 if (INFRA_ON(pAd)) {
958 {
959 {
960 pEntry = &pAd->MacTab.Content[BSSID_WCID];
961 RTMP_SET_PACKET_WCID(pPacket, BSSID_WCID);
962 Rate = pAd->CommonCfg.TxRate;
963 }
964 }
965 else if (ADHOC_ON(pAd))
966 {
967 if (*pSrcBufVA & 0x01)
968 { 961 {
962 pEntry = &pAd->MacTab.Content[BSSID_WCID];
963 RTMP_SET_PACKET_WCID(pPacket, BSSID_WCID);
964 Rate = pAd->CommonCfg.TxRate;
965 }
966 } else if (ADHOC_ON(pAd)) {
967 if (*pSrcBufVA & 0x01) {
969 RTMP_SET_PACKET_WCID(pPacket, MCAST_WCID); 968 RTMP_SET_PACKET_WCID(pPacket, MCAST_WCID);
970 pEntry = &pAd->MacTab.Content[MCAST_WCID]; 969 pEntry = &pAd->MacTab.Content[MCAST_WCID];
971 } 970 } else {
972 else
973 {
974 pEntry = MacTableLookup(pAd, pSrcBufVA); 971 pEntry = MacTableLookup(pAd, pSrcBufVA);
975 } 972 }
976 Rate = pAd->CommonCfg.TxRate; 973 Rate = pAd->CommonCfg.TxRate;
977 } 974 }
978 } 975 }
979 976
980 if (!pEntry) 977 if (!pEntry) {
981 { 978 DBGPRINT(RT_DEBUG_ERROR,
982 DBGPRINT(RT_DEBUG_ERROR,("STASendPacket->Cannot find pEntry(%2x:%2x:%2x:%2x:%2x:%2x) in MacTab!\n", PRINT_MAC(pSrcBufVA))); 979 ("STASendPacket->Cannot find pEntry(%2x:%2x:%2x:%2x:%2x:%2x) in MacTab!\n",
980 PRINT_MAC(pSrcBufVA)));
983 // Resourece is low, system did not allocate virtual address 981 // Resourece is low, system did not allocate virtual address
984 // return NDIS_STATUS_FAILURE directly to upper layer 982 // return NDIS_STATUS_FAILURE directly to upper layer
985 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE); 983 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
@@ -987,44 +985,39 @@ NDIS_STATUS STASendPacket(
987 } 985 }
988 986
989 if (ADHOC_ON(pAd) 987 if (ADHOC_ON(pAd)
990 ) 988 ) {
991 { 989 RTMP_SET_PACKET_WCID(pPacket, (UCHAR) pEntry->Aid);
992 RTMP_SET_PACKET_WCID(pPacket, (UCHAR)pEntry->Aid);
993 } 990 }
994
995 // 991 //
996 // Check the Ethernet Frame type of this packet, and set the RTMP_SET_PACKET_SPECIFIC flags. 992 // Check the Ethernet Frame type of this packet, and set the RTMP_SET_PACKET_SPECIFIC flags.
997 // Here we set the PACKET_SPECIFIC flags(LLC, VLAN, DHCP/ARP, EAPOL). 993 // Here we set the PACKET_SPECIFIC flags(LLC, VLAN, DHCP/ARP, EAPOL).
998 RTMPCheckEtherType(pAd, pPacket); 994 RTMPCheckEtherType(pAd, pPacket);
999 995
1000
1001
1002 // 996 //
1003 // WPA 802.1x secured port control - drop all non-802.1x frame before port secured 997 // WPA 802.1x secured port control - drop all non-802.1x frame before port secured
1004 // 998 //
1005 if (((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) || 999 if (((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) ||
1006 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) || 1000 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) ||
1007 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) || 1001 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) ||
1008 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK) 1002 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK)
1009 || (pAd->StaCfg.IEEE8021X == TRUE) 1003 || (pAd->StaCfg.IEEE8021X == TRUE)
1010 ) 1004 )
1011 && ((pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED) || (pAd->StaCfg.MicErrCnt >= 2)) 1005 && ((pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED)
1012 && (RTMP_GET_PACKET_EAPOL(pPacket)== FALSE) 1006 || (pAd->StaCfg.MicErrCnt >= 2))
1013 ) 1007 && (RTMP_GET_PACKET_EAPOL(pPacket) == FALSE)
1014 { 1008 ) {
1015 DBGPRINT(RT_DEBUG_TRACE,("STASendPacket --> Drop packet before port secured !!!\n")); 1009 DBGPRINT(RT_DEBUG_TRACE,
1010 ("STASendPacket --> Drop packet before port secured !!!\n"));
1016 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE); 1011 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
1017 1012
1018 return (NDIS_STATUS_FAILURE); 1013 return (NDIS_STATUS_FAILURE);
1019 } 1014 }
1020 1015
1021
1022 // STEP 1. Decide number of fragments required to deliver this MSDU. 1016 // STEP 1. Decide number of fragments required to deliver this MSDU.
1023 // The estimation here is not very accurate because difficult to 1017 // The estimation here is not very accurate because difficult to
1024 // take encryption overhead into consideration here. The result 1018 // take encryption overhead into consideration here. The result
1025 // "NumberOfFrag" is then just used to pre-check if enough free 1019 // "NumberOfFrag" is then just used to pre-check if enough free
1026 // TXD are available to hold this MSDU. 1020 // TXD are available to hold this MSDU.
1027
1028 1021
1029 if (*pSrcBufVA & 0x01) // fragmentation not allowed on multicast & broadcast 1022 if (*pSrcBufVA & 0x01) // fragmentation not allowed on multicast & broadcast
1030 NumberOfFrag = 1; 1023 NumberOfFrag = 1;
@@ -1032,10 +1025,10 @@ NDIS_STATUS STASendPacket(
1032 NumberOfFrag = 1; // Aggregation overwhelms fragmentation 1025 NumberOfFrag = 1; // Aggregation overwhelms fragmentation
1033 else if (CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_AMSDU_INUSED)) 1026 else if (CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_AMSDU_INUSED))
1034 NumberOfFrag = 1; // Aggregation overwhelms fragmentation 1027 NumberOfFrag = 1; // Aggregation overwhelms fragmentation
1035 else if ((pAd->StaCfg.HTPhyMode.field.MODE == MODE_HTMIX) || (pAd->StaCfg.HTPhyMode.field.MODE == MODE_HTGREENFIELD)) 1028 else if ((pAd->StaCfg.HTPhyMode.field.MODE == MODE_HTMIX)
1029 || (pAd->StaCfg.HTPhyMode.field.MODE == MODE_HTGREENFIELD))
1036 NumberOfFrag = 1; // MIMO RATE overwhelms fragmentation 1030 NumberOfFrag = 1; // MIMO RATE overwhelms fragmentation
1037 else 1031 else {
1038 {
1039 // The calculated "NumberOfFrag" is a rough estimation because of various 1032 // The calculated "NumberOfFrag" is a rough estimation because of various
1040 // encryption/encapsulation overhead not taken into consideration. This number is just 1033 // encryption/encapsulation overhead not taken into consideration. This number is just
1041 // used to make sure enough free TXD are available before fragmentation takes place. 1034 // used to make sure enough free TXD are available before fragmentation takes place.
@@ -1045,11 +1038,15 @@ NDIS_STATUS STASendPacket(
1045 // resource, and the NDIS packet will be indicated NDIS_STATUS_FAILURE. This should 1038 // resource, and the NDIS packet will be indicated NDIS_STATUS_FAILURE. This should
1046 // rarely happen and the penalty is just like a TX RETRY fail. Affordable. 1039 // rarely happen and the penalty is just like a TX RETRY fail. Affordable.
1047 1040
1048 AllowFragSize = (pAd->CommonCfg.FragmentThreshold) - LENGTH_802_11 - LENGTH_CRC; 1041 AllowFragSize =
1049 NumberOfFrag = ((PacketInfo.TotalPacketLength - LENGTH_802_3 + LENGTH_802_1_H) / AllowFragSize) + 1; 1042 (pAd->CommonCfg.FragmentThreshold) - LENGTH_802_11 -
1043 LENGTH_CRC;
1044 NumberOfFrag =
1045 ((PacketInfo.TotalPacketLength - LENGTH_802_3 +
1046 LENGTH_802_1_H) / AllowFragSize) + 1;
1050 // To get accurate number of fragmentation, Minus 1 if the size just match to allowable fragment size 1047 // To get accurate number of fragmentation, Minus 1 if the size just match to allowable fragment size
1051 if (((PacketInfo.TotalPacketLength - LENGTH_802_3 + LENGTH_802_1_H) % AllowFragSize) == 0) 1048 if (((PacketInfo.TotalPacketLength - LENGTH_802_3 +
1052 { 1049 LENGTH_802_1_H) % AllowFragSize) == 0) {
1053 NumberOfFrag--; 1050 NumberOfFrag--;
1054 } 1051 }
1055 } 1052 }
@@ -1057,16 +1054,19 @@ NDIS_STATUS STASendPacket(
1057 // Save fragment number to Ndis packet reserved field 1054 // Save fragment number to Ndis packet reserved field
1058 RTMP_SET_PACKET_FRAGMENTS(pPacket, NumberOfFrag); 1055 RTMP_SET_PACKET_FRAGMENTS(pPacket, NumberOfFrag);
1059 1056
1060
1061 // STEP 2. Check the requirement of RTS: 1057 // STEP 2. Check the requirement of RTS:
1062 // If multiple fragment required, RTS is required only for the first fragment 1058 // If multiple fragment required, RTS is required only for the first fragment
1063 // if the fragment size large than RTS threshold 1059 // if the fragment size large than RTS threshold
1064 // For RT28xx, Let ASIC send RTS/CTS 1060 // For RT28xx, Let ASIC send RTS/CTS
1065// RTMP_SET_PACKET_RTS(pPacket, 0); 1061// RTMP_SET_PACKET_RTS(pPacket, 0);
1066 if (NumberOfFrag > 1) 1062 if (NumberOfFrag > 1)
1067 RTSRequired = (pAd->CommonCfg.FragmentThreshold > pAd->CommonCfg.RtsThreshold) ? 1 : 0; 1063 RTSRequired =
1064 (pAd->CommonCfg.FragmentThreshold >
1065 pAd->CommonCfg.RtsThreshold) ? 1 : 0;
1068 else 1066 else
1069 RTSRequired = (PacketInfo.TotalPacketLength > pAd->CommonCfg.RtsThreshold) ? 1 : 0; 1067 RTSRequired =
1068 (PacketInfo.TotalPacketLength >
1069 pAd->CommonCfg.RtsThreshold) ? 1 : 0;
1070 1070
1071 // Save RTS requirement to Ndis packet reserved field 1071 // Save RTS requirement to Ndis packet reserved field
1072 RTMP_SET_PACKET_RTS(pPacket, RTSRequired); 1072 RTMP_SET_PACKET_RTS(pPacket, RTSRequired);
@@ -1076,32 +1076,33 @@ NDIS_STATUS STASendPacket(
1076 // STEP 3. Traffic classification. outcome = <UserPriority, QueIdx> 1076 // STEP 3. Traffic classification. outcome = <UserPriority, QueIdx>
1077 // 1077 //
1078 UserPriority = 0; 1078 UserPriority = 0;
1079 QueIdx = QID_AC_BE; 1079 QueIdx = QID_AC_BE;
1080 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_WMM_INUSED) && 1080 if (OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_WMM_INUSED) &&
1081 CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_WMM_CAPABLE)) 1081 CLIENT_STATUS_TEST_FLAG(pEntry, fCLIENT_STATUS_WMM_CAPABLE)) {
1082 {
1083 USHORT Protocol; 1082 USHORT Protocol;
1084 UCHAR LlcSnapLen = 0, Byte0, Byte1; 1083 UCHAR LlcSnapLen = 0, Byte0, Byte1;
1085 do 1084 do {
1086 {
1087 // get Ethernet protocol field 1085 // get Ethernet protocol field
1088 Protocol = (USHORT)((pSrcBufVA[12] << 8) + pSrcBufVA[13]); 1086 Protocol =
1089 if (Protocol <= 1500) 1087 (USHORT) ((pSrcBufVA[12] << 8) + pSrcBufVA[13]);
1090 { 1088 if (Protocol <= 1500) {
1091 // get Ethernet protocol field from LLC/SNAP 1089 // get Ethernet protocol field from LLC/SNAP
1092 if (Sniff2BytesFromNdisBuffer(PacketInfo.pFirstBuffer, LENGTH_802_3 + 6, &Byte0, &Byte1) != NDIS_STATUS_SUCCESS) 1090 if (Sniff2BytesFromNdisBuffer
1091 (PacketInfo.pFirstBuffer, LENGTH_802_3 + 6,
1092 &Byte0, &Byte1) != NDIS_STATUS_SUCCESS)
1093 break; 1093 break;
1094 1094
1095 Protocol = (USHORT)((Byte0 << 8) + Byte1); 1095 Protocol = (USHORT) ((Byte0 << 8) + Byte1);
1096 LlcSnapLen = 8; 1096 LlcSnapLen = 8;
1097 } 1097 }
1098
1099 // always AC_BE for non-IP packet 1098 // always AC_BE for non-IP packet
1100 if (Protocol != 0x0800) 1099 if (Protocol != 0x0800)
1101 break; 1100 break;
1102 1101
1103 // get IP header 1102 // get IP header
1104 if (Sniff2BytesFromNdisBuffer(PacketInfo.pFirstBuffer, LENGTH_802_3 + LlcSnapLen, &Byte0, &Byte1) != NDIS_STATUS_SUCCESS) 1103 if (Sniff2BytesFromNdisBuffer
1104 (PacketInfo.pFirstBuffer, LENGTH_802_3 + LlcSnapLen,
1105 &Byte0, &Byte1) != NDIS_STATUS_SUCCESS)
1105 break; 1106 break;
1106 1107
1107 // return AC_BE if packet is not IPv4 1108 // return AC_BE if packet is not IPv4
@@ -1115,61 +1116,56 @@ NDIS_STATUS STASendPacket(
1115 // TODO: have to check ACM bit. apply TSPEC if ACM is ON 1116 // TODO: have to check ACM bit. apply TSPEC if ACM is ON
1116 // TODO: downgrade UP & QueIdx before passing ACM 1117 // TODO: downgrade UP & QueIdx before passing ACM
1117 /* 1118 /*
1118 Under WMM ACM control, we dont need to check the bit; 1119 Under WMM ACM control, we dont need to check the bit;
1119 Or when a TSPEC is built for VO but we will change to issue 1120 Or when a TSPEC is built for VO but we will change to issue
1120 BA session for BE here, so we will not use BA to send VO packets. 1121 BA session for BE here, so we will not use BA to send VO packets.
1121 */ 1122 */
1122 if (pAd->CommonCfg.APEdcaParm.bACM[QueIdx]) 1123 if (pAd->CommonCfg.APEdcaParm.bACM[QueIdx]) {
1123 {
1124 UserPriority = 0; 1124 UserPriority = 0;
1125 QueIdx = QID_AC_BE; 1125 QueIdx = QID_AC_BE;
1126 } 1126 }
1127 } while (FALSE); 1127 } while (FALSE);
1128 } 1128 }
1129 1129
1130 RTMP_SET_PACKET_UP(pPacket, UserPriority); 1130 RTMP_SET_PACKET_UP(pPacket, UserPriority);
1131 1131
1132
1133
1134 // Make sure SendTxWait queue resource won't be used by other threads 1132 // Make sure SendTxWait queue resource won't be used by other threads
1135 RTMP_IRQ_LOCK(&pAd->irq_lock, IrqFlags); 1133 RTMP_IRQ_LOCK(&pAd->irq_lock, IrqFlags);
1136 if (pAd->TxSwQueue[QueIdx].Number >= MAX_PACKETS_IN_QUEUE) 1134 if (pAd->TxSwQueue[QueIdx].Number >= MAX_PACKETS_IN_QUEUE) {
1137 {
1138 RTMP_IRQ_UNLOCK(&pAd->irq_lock, IrqFlags); 1135 RTMP_IRQ_UNLOCK(&pAd->irq_lock, IrqFlags);
1139 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE); 1136 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
1140 1137
1141 return NDIS_STATUS_FAILURE; 1138 return NDIS_STATUS_FAILURE;
1142 } 1139 } else {
1143 else 1140 InsertTailQueueAc(pAd, pEntry, &pAd->TxSwQueue[QueIdx],
1144 { 1141 PACKET_TO_QUEUE_ENTRY(pPacket));
1145 InsertTailQueueAc(pAd, pEntry, &pAd->TxSwQueue[QueIdx], PACKET_TO_QUEUE_ENTRY(pPacket));
1146 } 1142 }
1147 RTMP_IRQ_UNLOCK(&pAd->irq_lock, IrqFlags); 1143 RTMP_IRQ_UNLOCK(&pAd->irq_lock, IrqFlags);
1148 1144
1149 if ((pAd->CommonCfg.BACapability.field.AutoBA == TRUE)&& 1145 if ((pAd->CommonCfg.BACapability.field.AutoBA == TRUE) &&
1150 IS_HT_STA(pEntry)) 1146 IS_HT_STA(pEntry)) {
1151 { 1147 //PMAC_TABLE_ENTRY pMacEntry = &pAd->MacTab.Content[BSSID_WCID];
1152 //PMAC_TABLE_ENTRY pMacEntry = &pAd->MacTab.Content[BSSID_WCID]; 1148 if (((pEntry->TXBAbitmap & (1 << UserPriority)) == 0) &&
1153 if (((pEntry->TXBAbitmap & (1<<UserPriority)) == 0) && 1149 ((pEntry->BADeclineBitmap & (1 << UserPriority)) == 0) &&
1154 ((pEntry->BADeclineBitmap & (1<<UserPriority)) == 0) && 1150 (pEntry->PortSecured == WPA_802_1X_PORT_SECURED)
1155 (pEntry->PortSecured == WPA_802_1X_PORT_SECURED) 1151 // For IOT compatibility, if
1156 // For IOT compatibility, if 1152 // 1. It is Ralink chip or
1157 // 1. It is Ralink chip or 1153 // 2. It is OPEN or AES mode,
1158 // 2. It is OPEN or AES mode, 1154 // then BA session can be bulit.
1159 // then BA session can be bulit. 1155 && ((pEntry->ValidAsCLI && pAd->MlmeAux.APRalinkIe != 0x0)
1160 && ((pEntry->ValidAsCLI && pAd->MlmeAux.APRalinkIe != 0x0) || 1156 || (pEntry->WepStatus != Ndis802_11WEPEnabled
1161 (pEntry->WepStatus != Ndis802_11WEPEnabled && pEntry->WepStatus != Ndis802_11Encryption2Enabled)) 1157 && pEntry->WepStatus !=
1162 ) 1158 Ndis802_11Encryption2Enabled))
1163 { 1159 ) {
1164 BAOriSessionSetUp(pAd, pEntry, UserPriority, 0, 10, FALSE); 1160 BAOriSessionSetUp(pAd, pEntry, UserPriority, 0, 10,
1161 FALSE);
1165 } 1162 }
1166 } 1163 }
1167 1164
1168 pAd->RalinkCounters.OneSecOsTxCount[QueIdx]++; // TODO: for debug only. to be removed 1165 pAd->RalinkCounters.OneSecOsTxCount[QueIdx]++; // TODO: for debug only. to be removed
1169 return NDIS_STATUS_SUCCESS; 1166 return NDIS_STATUS_SUCCESS;
1170} 1167}
1171 1168
1172
1173/* 1169/*
1174 ======================================================================== 1170 ========================================================================
1175 1171
@@ -1193,45 +1189,52 @@ NDIS_STATUS STASendPacket(
1193 ======================================================================== 1189 ========================================================================
1194*/ 1190*/
1195#ifdef RTMP_MAC_PCI 1191#ifdef RTMP_MAC_PCI
1196NDIS_STATUS RTMPFreeTXDRequest( 1192NDIS_STATUS RTMPFreeTXDRequest(IN PRTMP_ADAPTER pAd,
1197 IN PRTMP_ADAPTER pAd, 1193 IN UCHAR QueIdx,
1198 IN UCHAR QueIdx, 1194 IN UCHAR NumberRequired, IN PUCHAR FreeNumberIs)
1199 IN UCHAR NumberRequired,
1200 IN PUCHAR FreeNumberIs)
1201{ 1195{
1202 ULONG FreeNumber = 0; 1196 ULONG FreeNumber = 0;
1203 NDIS_STATUS Status = NDIS_STATUS_FAILURE; 1197 NDIS_STATUS Status = NDIS_STATUS_FAILURE;
1204 1198
1205 switch (QueIdx) 1199 switch (QueIdx) {
1206 { 1200 case QID_AC_BK:
1207 case QID_AC_BK: 1201 case QID_AC_BE:
1208 case QID_AC_BE: 1202 case QID_AC_VI:
1209 case QID_AC_VI: 1203 case QID_AC_VO:
1210 case QID_AC_VO: 1204 if (pAd->TxRing[QueIdx].TxSwFreeIdx >
1211 if (pAd->TxRing[QueIdx].TxSwFreeIdx > pAd->TxRing[QueIdx].TxCpuIdx) 1205 pAd->TxRing[QueIdx].TxCpuIdx)
1212 FreeNumber = pAd->TxRing[QueIdx].TxSwFreeIdx - pAd->TxRing[QueIdx].TxCpuIdx - 1; 1206 FreeNumber =
1213 else 1207 pAd->TxRing[QueIdx].TxSwFreeIdx -
1214 FreeNumber = pAd->TxRing[QueIdx].TxSwFreeIdx + TX_RING_SIZE - pAd->TxRing[QueIdx].TxCpuIdx - 1; 1208 pAd->TxRing[QueIdx].TxCpuIdx - 1;
1215 1209 else
1216 if (FreeNumber >= NumberRequired) 1210 FreeNumber =
1217 Status = NDIS_STATUS_SUCCESS; 1211 pAd->TxRing[QueIdx].TxSwFreeIdx + TX_RING_SIZE -
1218 break; 1212 pAd->TxRing[QueIdx].TxCpuIdx - 1;
1219 1213
1220 case QID_MGMT: 1214 if (FreeNumber >= NumberRequired)
1221 if (pAd->MgmtRing.TxSwFreeIdx > pAd->MgmtRing.TxCpuIdx) 1215 Status = NDIS_STATUS_SUCCESS;
1222 FreeNumber = pAd->MgmtRing.TxSwFreeIdx - pAd->MgmtRing.TxCpuIdx - 1; 1216 break;
1223 else 1217
1224 FreeNumber = pAd->MgmtRing.TxSwFreeIdx + MGMT_RING_SIZE - pAd->MgmtRing.TxCpuIdx - 1; 1218 case QID_MGMT:
1225 1219 if (pAd->MgmtRing.TxSwFreeIdx > pAd->MgmtRing.TxCpuIdx)
1226 if (FreeNumber >= NumberRequired) 1220 FreeNumber =
1227 Status = NDIS_STATUS_SUCCESS; 1221 pAd->MgmtRing.TxSwFreeIdx - pAd->MgmtRing.TxCpuIdx -
1228 break; 1222 1;
1229 1223 else
1230 default: 1224 FreeNumber =
1231 DBGPRINT(RT_DEBUG_ERROR,("RTMPFreeTXDRequest::Invalid QueIdx(=%d)\n", QueIdx)); 1225 pAd->MgmtRing.TxSwFreeIdx + MGMT_RING_SIZE -
1232 break; 1226 pAd->MgmtRing.TxCpuIdx - 1;
1227
1228 if (FreeNumber >= NumberRequired)
1229 Status = NDIS_STATUS_SUCCESS;
1230 break;
1231
1232 default:
1233 DBGPRINT(RT_DEBUG_ERROR,
1234 ("RTMPFreeTXDRequest::Invalid QueIdx(=%d)\n", QueIdx));
1235 break;
1233 } 1236 }
1234 *FreeNumberIs = (UCHAR)FreeNumber; 1237 *FreeNumberIs = (UCHAR) FreeNumber;
1235 1238
1236 return (Status); 1239 return (Status);
1237} 1240}
@@ -1241,76 +1244,69 @@ NDIS_STATUS RTMPFreeTXDRequest(
1241 Actually, this function used to check if the TxHardware Queue still has frame need to send. 1244 Actually, this function used to check if the TxHardware Queue still has frame need to send.
1242 If no frame need to send, go to sleep, else, still wake up. 1245 If no frame need to send, go to sleep, else, still wake up.
1243*/ 1246*/
1244NDIS_STATUS RTMPFreeTXDRequest( 1247NDIS_STATUS RTMPFreeTXDRequest(IN PRTMP_ADAPTER pAd,
1245 IN PRTMP_ADAPTER pAd, 1248 IN UCHAR QueIdx,
1246 IN UCHAR QueIdx, 1249 IN UCHAR NumberRequired, IN PUCHAR FreeNumberIs)
1247 IN UCHAR NumberRequired,
1248 IN PUCHAR FreeNumberIs)
1249{ 1250{
1250 //ULONG FreeNumber = 0; 1251 //ULONG FreeNumber = 0;
1251 NDIS_STATUS Status = NDIS_STATUS_FAILURE; 1252 NDIS_STATUS Status = NDIS_STATUS_FAILURE;
1252 unsigned long IrqFlags; 1253 unsigned long IrqFlags;
1253 HT_TX_CONTEXT *pHTTXContext; 1254 HT_TX_CONTEXT *pHTTXContext;
1254 1255
1255 switch (QueIdx) 1256 switch (QueIdx) {
1256 { 1257 case QID_AC_BK:
1257 case QID_AC_BK: 1258 case QID_AC_BE:
1258 case QID_AC_BE: 1259 case QID_AC_VI:
1259 case QID_AC_VI: 1260 case QID_AC_VO:
1260 case QID_AC_VO: 1261 {
1261 { 1262 pHTTXContext = &pAd->TxContext[QueIdx];
1262 pHTTXContext = &pAd->TxContext[QueIdx]; 1263 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx],
1263 RTMP_IRQ_LOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags); 1264 IrqFlags);
1264 if ((pHTTXContext->CurWritePosition != pHTTXContext->ENextBulkOutPosition) || 1265 if ((pHTTXContext->CurWritePosition !=
1265 (pHTTXContext->IRPPending == TRUE)) 1266 pHTTXContext->ENextBulkOutPosition)
1266 { 1267 || (pHTTXContext->IRPPending == TRUE)) {
1267 Status = NDIS_STATUS_FAILURE;
1268 }
1269 else
1270 {
1271 Status = NDIS_STATUS_SUCCESS;
1272 }
1273 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx], IrqFlags);
1274 }
1275 break;
1276 case QID_MGMT:
1277 if (pAd->MgmtRing.TxSwFreeIdx != MGMT_RING_SIZE)
1278 Status = NDIS_STATUS_FAILURE; 1268 Status = NDIS_STATUS_FAILURE;
1279 else 1269 } else {
1280 Status = NDIS_STATUS_SUCCESS; 1270 Status = NDIS_STATUS_SUCCESS;
1281 break; 1271 }
1282 default: 1272 RTMP_IRQ_UNLOCK(&pAd->TxContextQueueLock[QueIdx],
1283 DBGPRINT(RT_DEBUG_ERROR,("RTMPFreeTXDRequest::Invalid QueIdx(=%d)\n", QueIdx)); 1273 IrqFlags);
1284 break; 1274 }
1275 break;
1276 case QID_MGMT:
1277 if (pAd->MgmtRing.TxSwFreeIdx != MGMT_RING_SIZE)
1278 Status = NDIS_STATUS_FAILURE;
1279 else
1280 Status = NDIS_STATUS_SUCCESS;
1281 break;
1282 default:
1283 DBGPRINT(RT_DEBUG_ERROR,
1284 ("RTMPFreeTXDRequest::Invalid QueIdx(=%d)\n", QueIdx));
1285 break;
1285 } 1286 }
1286 1287
1287 return (Status); 1288 return (Status);
1288} 1289}
1289#endif // RTMP_MAC_USB // 1290#endif // RTMP_MAC_USB //
1290 1291
1291VOID RTMPSendDisassociationFrame( 1292VOID RTMPSendDisassociationFrame(IN PRTMP_ADAPTER pAd)
1292 IN PRTMP_ADAPTER pAd)
1293{ 1293{
1294} 1294}
1295 1295
1296VOID RTMPSendNullFrame( 1296VOID RTMPSendNullFrame(IN PRTMP_ADAPTER pAd,
1297 IN PRTMP_ADAPTER pAd, 1297 IN UCHAR TxRate, IN BOOLEAN bQosNull)
1298 IN UCHAR TxRate,
1299 IN BOOLEAN bQosNull)
1300{ 1298{
1301 UCHAR NullFrame[48]; 1299 UCHAR NullFrame[48];
1302 ULONG Length; 1300 ULONG Length;
1303 PHEADER_802_11 pHeader_802_11; 1301 PHEADER_802_11 pHeader_802_11;
1304 1302
1305 // WPA 802.1x secured port control 1303 // WPA 802.1x secured port control
1306 if (((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) || 1304 if (((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA) ||
1307 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) || 1305 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) ||
1308 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) || 1306 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) ||
1309 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK) 1307 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK)
1310 || (pAd->StaCfg.IEEE8021X == TRUE) 1308 || (pAd->StaCfg.IEEE8021X == TRUE)
1311 ) && 1309 ) && (pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED)) {
1312 (pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED))
1313 {
1314 return; 1310 return;
1315 } 1311 }
1316 1312
@@ -1326,28 +1322,26 @@ VOID RTMPSendNullFrame(
1326 COPY_MAC_ADDR(pHeader_802_11->Addr2, pAd->CurrentAddress); 1322 COPY_MAC_ADDR(pHeader_802_11->Addr2, pAd->CurrentAddress);
1327 COPY_MAC_ADDR(pHeader_802_11->Addr3, pAd->CommonCfg.Bssid); 1323 COPY_MAC_ADDR(pHeader_802_11->Addr3, pAd->CommonCfg.Bssid);
1328 1324
1329 if (pAd->CommonCfg.bAPSDForcePowerSave) 1325 if (pAd->CommonCfg.bAPSDForcePowerSave) {
1330 {
1331 pHeader_802_11->FC.PwrMgmt = PWR_SAVE; 1326 pHeader_802_11->FC.PwrMgmt = PWR_SAVE;
1327 } else {
1328 pHeader_802_11->FC.PwrMgmt =
1329 (pAd->StaCfg.Psm == PWR_SAVE) ? 1 : 0;
1332 } 1330 }
1333 else 1331 pHeader_802_11->Duration =
1334 { 1332 pAd->CommonCfg.Dsifs + RTMPCalcDuration(pAd, TxRate, 14);
1335 pHeader_802_11->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE) ? 1: 0;
1336 }
1337 pHeader_802_11->Duration = pAd->CommonCfg.Dsifs + RTMPCalcDuration(pAd, TxRate, 14);
1338 1333
1339 pAd->Sequence++; 1334 pAd->Sequence++;
1340 pHeader_802_11->Sequence = pAd->Sequence; 1335 pHeader_802_11->Sequence = pAd->Sequence;
1341 1336
1342 // Prepare QosNull function frame 1337 // Prepare QosNull function frame
1343 if (bQosNull) 1338 if (bQosNull) {
1344 {
1345 pHeader_802_11->FC.SubType = SUBTYPE_QOS_NULL; 1339 pHeader_802_11->FC.SubType = SUBTYPE_QOS_NULL;
1346 1340
1347 // copy QOS control bytes 1341 // copy QOS control bytes
1348 NullFrame[Length] = 0; 1342 NullFrame[Length] = 0;
1349 NullFrame[Length+1] = 0; 1343 NullFrame[Length + 1] = 0;
1350 Length += 2;// if pad with 2 bytes for alignment, APSD will fail 1344 Length += 2; // if pad with 2 bytes for alignment, APSD will fail
1351 } 1345 }
1352 1346
1353 HAL_KickOutNullFrameTx(pAd, 0, NullFrame, Length); 1347 HAL_KickOutNullFrameTx(pAd, 0, NullFrame, Length);
@@ -1355,68 +1349,57 @@ VOID RTMPSendNullFrame(
1355} 1349}
1356 1350
1357// IRQL = DISPATCH_LEVEL 1351// IRQL = DISPATCH_LEVEL
1358VOID RTMPSendRTSFrame( 1352VOID RTMPSendRTSFrame(IN PRTMP_ADAPTER pAd,
1359 IN PRTMP_ADAPTER pAd, 1353 IN PUCHAR pDA,
1360 IN PUCHAR pDA, 1354 IN unsigned int NextMpduSize,
1361 IN unsigned int NextMpduSize, 1355 IN UCHAR TxRate,
1362 IN UCHAR TxRate, 1356 IN UCHAR RTSRate,
1363 IN UCHAR RTSRate, 1357 IN USHORT AckDuration, IN UCHAR QueIdx, IN UCHAR FrameGap)
1364 IN USHORT AckDuration,
1365 IN UCHAR QueIdx,
1366 IN UCHAR FrameGap)
1367{ 1358{
1368} 1359}
1369 1360
1370
1371
1372// -------------------------------------------------------- 1361// --------------------------------------------------------
1373// FIND ENCRYPT KEY AND DECIDE CIPHER ALGORITHM 1362// FIND ENCRYPT KEY AND DECIDE CIPHER ALGORITHM
1374// Find the WPA key, either Group or Pairwise Key 1363// Find the WPA key, either Group or Pairwise Key
1375// LEAP + TKIP also use WPA key. 1364// LEAP + TKIP also use WPA key.
1376// -------------------------------------------------------- 1365// --------------------------------------------------------
1377// Decide WEP bit and cipher suite to be used. Same cipher suite should be used for whole fragment burst 1366// Decide WEP bit and cipher suite to be used. Same cipher suite should be used for whole fragment burst
1378// In Cisco CCX 2.0 Leap Authentication 1367// In Cisco CCX 2.0 Leap Authentication
1379// WepStatus is Ndis802_11Encryption1Enabled but the key will use PairwiseKey 1368// WepStatus is Ndis802_11Encryption1Enabled but the key will use PairwiseKey
1380// Instead of the SharedKey, SharedKey Length may be Zero. 1369// Instead of the SharedKey, SharedKey Length may be Zero.
1381VOID STAFindCipherAlgorithm( 1370VOID STAFindCipherAlgorithm(IN PRTMP_ADAPTER pAd, IN TX_BLK * pTxBlk)
1382 IN PRTMP_ADAPTER pAd,
1383 IN TX_BLK *pTxBlk)
1384{ 1371{
1385 NDIS_802_11_ENCRYPTION_STATUS Cipher; // To indicate cipher used for this packet 1372 NDIS_802_11_ENCRYPTION_STATUS Cipher; // To indicate cipher used for this packet
1386 UCHAR CipherAlg = CIPHER_NONE; // cipher alogrithm 1373 UCHAR CipherAlg = CIPHER_NONE; // cipher alogrithm
1387 UCHAR KeyIdx = 0xff; 1374 UCHAR KeyIdx = 0xff;
1388 PUCHAR pSrcBufVA; 1375 PUCHAR pSrcBufVA;
1389 PCIPHER_KEY pKey = NULL; 1376 PCIPHER_KEY pKey = NULL;
1390 1377
1391 pSrcBufVA = GET_OS_PKT_DATAPTR(pTxBlk->pPacket); 1378 pSrcBufVA = GET_OS_PKT_DATAPTR(pTxBlk->pPacket);
1392 1379
1393 { 1380 {
1394 // Select Cipher 1381 // Select Cipher
1395 if ((*pSrcBufVA & 0x01) && (ADHOC_ON(pAd))) 1382 if ((*pSrcBufVA & 0x01) && (ADHOC_ON(pAd)))
1396 Cipher = pAd->StaCfg.GroupCipher; // Cipher for Multicast or Broadcast 1383 Cipher = pAd->StaCfg.GroupCipher; // Cipher for Multicast or Broadcast
1397 else 1384 else
1398 Cipher = pAd->StaCfg.PairCipher; // Cipher for Unicast 1385 Cipher = pAd->StaCfg.PairCipher; // Cipher for Unicast
1399 1386
1400 if (RTMP_GET_PACKET_EAPOL(pTxBlk->pPacket)) 1387 if (RTMP_GET_PACKET_EAPOL(pTxBlk->pPacket)) {
1401 { 1388 ASSERT(pAd->SharedKey[BSS0][0].CipherAlg <=
1402 ASSERT(pAd->SharedKey[BSS0][0].CipherAlg <= CIPHER_CKIP128); 1389 CIPHER_CKIP128);
1403 1390
1404 // 4-way handshaking frame must be clear 1391 // 4-way handshaking frame must be clear
1405 if (!(TX_BLK_TEST_FLAG(pTxBlk, fTX_bClearEAPFrame)) && (pAd->SharedKey[BSS0][0].CipherAlg) && 1392 if (!(TX_BLK_TEST_FLAG(pTxBlk, fTX_bClearEAPFrame))
1406 (pAd->SharedKey[BSS0][0].KeyLen)) 1393 && (pAd->SharedKey[BSS0][0].CipherAlg)
1407 { 1394 && (pAd->SharedKey[BSS0][0].KeyLen)) {
1408 CipherAlg = pAd->SharedKey[BSS0][0].CipherAlg; 1395 CipherAlg = pAd->SharedKey[BSS0][0].CipherAlg;
1409 KeyIdx = 0; 1396 KeyIdx = 0;
1410 } 1397 }
1411 } 1398 } else if (Cipher == Ndis802_11Encryption1Enabled) {
1412 else if (Cipher == Ndis802_11Encryption1Enabled) 1399 KeyIdx = pAd->StaCfg.DefaultKeyId;
1413 { 1400 } else if ((Cipher == Ndis802_11Encryption2Enabled) ||
1414 KeyIdx = pAd->StaCfg.DefaultKeyId; 1401 (Cipher == Ndis802_11Encryption3Enabled)) {
1415 } 1402 if ((*pSrcBufVA & 0x01) && (ADHOC_ON(pAd))) // multicast
1416 else if ((Cipher == Ndis802_11Encryption2Enabled) ||
1417 (Cipher == Ndis802_11Encryption3Enabled))
1418 {
1419 if ((*pSrcBufVA & 0x01) && (ADHOC_ON(pAd))) // multicast
1420 KeyIdx = pAd->StaCfg.DefaultKeyId; 1403 KeyIdx = pAd->StaCfg.DefaultKeyId;
1421 else if (pAd->SharedKey[BSS0][0].KeyLen) 1404 else if (pAd->SharedKey[BSS0][0].KeyLen)
1422 KeyIdx = 0; 1405 KeyIdx = 0;
@@ -1426,15 +1409,16 @@ VOID STAFindCipherAlgorithm(
1426 1409
1427 if (KeyIdx == 0xff) 1410 if (KeyIdx == 0xff)
1428 CipherAlg = CIPHER_NONE; 1411 CipherAlg = CIPHER_NONE;
1429 else if ((Cipher == Ndis802_11EncryptionDisabled) || (pAd->SharedKey[BSS0][KeyIdx].KeyLen == 0)) 1412 else if ((Cipher == Ndis802_11EncryptionDisabled)
1413 || (pAd->SharedKey[BSS0][KeyIdx].KeyLen == 0))
1430 CipherAlg = CIPHER_NONE; 1414 CipherAlg = CIPHER_NONE;
1431 else if ( pAd->StaCfg.WpaSupplicantUP && 1415 else if (pAd->StaCfg.WpaSupplicantUP &&
1432 (Cipher == Ndis802_11Encryption1Enabled) && 1416 (Cipher == Ndis802_11Encryption1Enabled) &&
1433 (pAd->StaCfg.IEEE8021X == TRUE) && 1417 (pAd->StaCfg.IEEE8021X == TRUE) &&
1434 (pAd->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED)) 1418 (pAd->StaCfg.PortSecured ==
1435 CipherAlg = CIPHER_NONE; 1419 WPA_802_1X_PORT_NOT_SECURED))
1436 else 1420 CipherAlg = CIPHER_NONE;
1437 { 1421 else {
1438 //Header_802_11.FC.Wep = 1; 1422 //Header_802_11.FC.Wep = 1;
1439 CipherAlg = pAd->SharedKey[BSS0][KeyIdx].CipherAlg; 1423 CipherAlg = pAd->SharedKey[BSS0][KeyIdx].CipherAlg;
1440 pKey = &pAd->SharedKey[BSS0][KeyIdx]; 1424 pKey = &pAd->SharedKey[BSS0][KeyIdx];
@@ -1445,12 +1429,9 @@ VOID STAFindCipherAlgorithm(
1445 pTxBlk->pKey = pKey; 1429 pTxBlk->pKey = pKey;
1446} 1430}
1447 1431
1448 1432VOID STABuildCommon802_11Header(IN PRTMP_ADAPTER pAd, IN TX_BLK * pTxBlk)
1449VOID STABuildCommon802_11Header(
1450 IN PRTMP_ADAPTER pAd,
1451 IN TX_BLK *pTxBlk)
1452{ 1433{
1453 HEADER_802_11 *pHeader_802_11; 1434 HEADER_802_11 *pHeader_802_11;
1454 1435
1455 // 1436 //
1456 // MAKE A COMMON 802.11 HEADER 1437 // MAKE A COMMON 802.11 HEADER
@@ -1459,33 +1440,36 @@ VOID STABuildCommon802_11Header(
1459 // normal wlan header size : 24 octets 1440 // normal wlan header size : 24 octets
1460 pTxBlk->MpduHeaderLen = sizeof(HEADER_802_11); 1441 pTxBlk->MpduHeaderLen = sizeof(HEADER_802_11);
1461 1442
1462 pHeader_802_11 = (HEADER_802_11 *) &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE]; 1443 pHeader_802_11 =
1444 (HEADER_802_11 *) & pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
1463 1445
1464 NdisZeroMemory(pHeader_802_11, sizeof(HEADER_802_11)); 1446 NdisZeroMemory(pHeader_802_11, sizeof(HEADER_802_11));
1465 1447
1466 pHeader_802_11->FC.FrDs = 0; 1448 pHeader_802_11->FC.FrDs = 0;
1467 pHeader_802_11->FC.Type = BTYPE_DATA; 1449 pHeader_802_11->FC.Type = BTYPE_DATA;
1468 pHeader_802_11->FC.SubType = ((TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) ? SUBTYPE_QDATA : SUBTYPE_DATA); 1450 pHeader_802_11->FC.SubType =
1469 1451 ((TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) ? SUBTYPE_QDATA :
1470 if (pTxBlk->pMacEntry) 1452 SUBTYPE_DATA);
1471 { 1453
1472 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bForceNonQoS)) 1454 if (pTxBlk->pMacEntry) {
1473 { 1455 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bForceNonQoS)) {
1474 pHeader_802_11->Sequence = pTxBlk->pMacEntry->NonQosDataSeq; 1456 pHeader_802_11->Sequence =
1475 pTxBlk->pMacEntry->NonQosDataSeq = (pTxBlk->pMacEntry->NonQosDataSeq+1) & MAXSEQ; 1457 pTxBlk->pMacEntry->NonQosDataSeq;
1476 } 1458 pTxBlk->pMacEntry->NonQosDataSeq =
1477 else 1459 (pTxBlk->pMacEntry->NonQosDataSeq + 1) & MAXSEQ;
1478 { 1460 } else {
1479 { 1461 {
1480 pHeader_802_11->Sequence = pTxBlk->pMacEntry->TxSeq[pTxBlk->UserPriority]; 1462 pHeader_802_11->Sequence =
1481 pTxBlk->pMacEntry->TxSeq[pTxBlk->UserPriority] = (pTxBlk->pMacEntry->TxSeq[pTxBlk->UserPriority]+1) & MAXSEQ; 1463 pTxBlk->pMacEntry->TxSeq[pTxBlk->
1482 } 1464 UserPriority];
1483 } 1465 pTxBlk->pMacEntry->TxSeq[pTxBlk->UserPriority] =
1484 } 1466 (pTxBlk->pMacEntry->
1485 else 1467 TxSeq[pTxBlk->UserPriority] + 1) & MAXSEQ;
1486 { 1468 }
1469 }
1470 } else {
1487 pHeader_802_11->Sequence = pAd->Sequence; 1471 pHeader_802_11->Sequence = pAd->Sequence;
1488 pAd->Sequence = (pAd->Sequence+1) & MAXSEQ; // next sequence 1472 pAd->Sequence = (pAd->Sequence + 1) & MAXSEQ; // next sequence
1489 } 1473 }
1490 1474
1491 pHeader_802_11->Frag = 0; 1475 pHeader_802_11->Frag = 0;
@@ -1493,20 +1477,23 @@ VOID STABuildCommon802_11Header(
1493 pHeader_802_11->FC.MoreData = TX_BLK_TEST_FLAG(pTxBlk, fTX_bMoreData); 1477 pHeader_802_11->FC.MoreData = TX_BLK_TEST_FLAG(pTxBlk, fTX_bMoreData);
1494 1478
1495 { 1479 {
1496 if (INFRA_ON(pAd)) 1480 if (INFRA_ON(pAd)) {
1497 {
1498 { 1481 {
1499 COPY_MAC_ADDR(pHeader_802_11->Addr1, pAd->CommonCfg.Bssid); 1482 COPY_MAC_ADDR(pHeader_802_11->Addr1,
1500 COPY_MAC_ADDR(pHeader_802_11->Addr2, pAd->CurrentAddress); 1483 pAd->CommonCfg.Bssid);
1501 COPY_MAC_ADDR(pHeader_802_11->Addr3, pTxBlk->pSrcBufHeader); 1484 COPY_MAC_ADDR(pHeader_802_11->Addr2,
1502 pHeader_802_11->FC.ToDs = 1; 1485 pAd->CurrentAddress);
1503 } 1486 COPY_MAC_ADDR(pHeader_802_11->Addr3,
1504 } 1487 pTxBlk->pSrcBufHeader);
1505 else if (ADHOC_ON(pAd)) 1488 pHeader_802_11->FC.ToDs = 1;
1506 { 1489 }
1507 COPY_MAC_ADDR(pHeader_802_11->Addr1, pTxBlk->pSrcBufHeader); 1490 } else if (ADHOC_ON(pAd)) {
1508 COPY_MAC_ADDR(pHeader_802_11->Addr2, pAd->CurrentAddress); 1491 COPY_MAC_ADDR(pHeader_802_11->Addr1,
1509 COPY_MAC_ADDR(pHeader_802_11->Addr3, pAd->CommonCfg.Bssid); 1492 pTxBlk->pSrcBufHeader);
1493 COPY_MAC_ADDR(pHeader_802_11->Addr2,
1494 pAd->CurrentAddress);
1495 COPY_MAC_ADDR(pHeader_802_11->Addr3,
1496 pAd->CommonCfg.Bssid);
1510 pHeader_802_11->FC.ToDs = 0; 1497 pHeader_802_11->FC.ToDs = 0;
1511 } 1498 }
1512 } 1499 }
@@ -1518,20 +1505,18 @@ VOID STABuildCommon802_11Header(
1518 // STEP 2. MAKE A COMMON 802.11 HEADER SHARED BY ENTIRE FRAGMENT BURST. Fill sequence later. 1505 // STEP 2. MAKE A COMMON 802.11 HEADER SHARED BY ENTIRE FRAGMENT BURST. Fill sequence later.
1519 // ----------------------------------------------------------------- 1506 // -----------------------------------------------------------------
1520 if (pAd->CommonCfg.bAPSDForcePowerSave) 1507 if (pAd->CommonCfg.bAPSDForcePowerSave)
1521 pHeader_802_11->FC.PwrMgmt = PWR_SAVE; 1508 pHeader_802_11->FC.PwrMgmt = PWR_SAVE;
1522 else 1509 else
1523 pHeader_802_11->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE); 1510 pHeader_802_11->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE);
1524} 1511}
1525 1512
1526VOID STABuildCache802_11Header( 1513VOID STABuildCache802_11Header(IN RTMP_ADAPTER * pAd,
1527 IN RTMP_ADAPTER *pAd, 1514 IN TX_BLK * pTxBlk, IN UCHAR * pHeader)
1528 IN TX_BLK *pTxBlk,
1529 IN UCHAR *pHeader)
1530{ 1515{
1531 MAC_TABLE_ENTRY *pMacEntry; 1516 MAC_TABLE_ENTRY *pMacEntry;
1532 PHEADER_802_11 pHeader80211; 1517 PHEADER_802_11 pHeader80211;
1533 1518
1534 pHeader80211 = (PHEADER_802_11)pHeader; 1519 pHeader80211 = (PHEADER_802_11) pHeader;
1535 pMacEntry = pTxBlk->pMacEntry; 1520 pMacEntry = pTxBlk->pMacEntry;
1536 1521
1537 // 1522 //
@@ -1546,7 +1531,8 @@ VOID STABuildCache802_11Header(
1546 1531
1547 // Sequence 1532 // Sequence
1548 pHeader80211->Sequence = pMacEntry->TxSeq[pTxBlk->UserPriority]; 1533 pHeader80211->Sequence = pMacEntry->TxSeq[pTxBlk->UserPriority];
1549 pMacEntry->TxSeq[pTxBlk->UserPriority] = (pMacEntry->TxSeq[pTxBlk->UserPriority]+1) & MAXSEQ; 1534 pMacEntry->TxSeq[pTxBlk->UserPriority] =
1535 (pMacEntry->TxSeq[pTxBlk->UserPriority] + 1) & MAXSEQ;
1550 1536
1551 { 1537 {
1552 // Check if the frame can be sent through DLS direct link interface 1538 // Check if the frame can be sent through DLS direct link interface
@@ -1554,34 +1540,34 @@ VOID STABuildCache802_11Header(
1554 1540
1555 // The addr3 of normal packet send from DS is Dest Mac address. 1541 // The addr3 of normal packet send from DS is Dest Mac address.
1556 if (ADHOC_ON(pAd)) 1542 if (ADHOC_ON(pAd))
1557 COPY_MAC_ADDR(pHeader80211->Addr3, pAd->CommonCfg.Bssid); 1543 COPY_MAC_ADDR(pHeader80211->Addr3,
1544 pAd->CommonCfg.Bssid);
1558 else 1545 else
1559 COPY_MAC_ADDR(pHeader80211->Addr3, pTxBlk->pSrcBufHeader); 1546 COPY_MAC_ADDR(pHeader80211->Addr3,
1547 pTxBlk->pSrcBufHeader);
1560 } 1548 }
1561 1549
1562 // ----------------------------------------------------------------- 1550 // -----------------------------------------------------------------
1563 // STEP 2. MAKE A COMMON 802.11 HEADER SHARED BY ENTIRE FRAGMENT BURST. Fill sequence later. 1551 // STEP 2. MAKE A COMMON 802.11 HEADER SHARED BY ENTIRE FRAGMENT BURST. Fill sequence later.
1564 // ----------------------------------------------------------------- 1552 // -----------------------------------------------------------------
1565 if (pAd->CommonCfg.bAPSDForcePowerSave) 1553 if (pAd->CommonCfg.bAPSDForcePowerSave)
1566 pHeader80211->FC.PwrMgmt = PWR_SAVE; 1554 pHeader80211->FC.PwrMgmt = PWR_SAVE;
1567 else 1555 else
1568 pHeader80211->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE); 1556 pHeader80211->FC.PwrMgmt = (pAd->StaCfg.Psm == PWR_SAVE);
1569} 1557}
1570 1558
1571static inline PUCHAR STA_Build_ARalink_Frame_Header( 1559static inline PUCHAR STA_Build_ARalink_Frame_Header(IN RTMP_ADAPTER * pAd,
1572 IN RTMP_ADAPTER *pAd, 1560 IN TX_BLK * pTxBlk)
1573 IN TX_BLK *pTxBlk)
1574{ 1561{
1575 PUCHAR pHeaderBufPtr; 1562 PUCHAR pHeaderBufPtr;
1576 HEADER_802_11 *pHeader_802_11; 1563 HEADER_802_11 *pHeader_802_11;
1577 PNDIS_PACKET pNextPacket; 1564 PNDIS_PACKET pNextPacket;
1578 UINT32 nextBufLen; 1565 UINT32 nextBufLen;
1579 PQUEUE_ENTRY pQEntry; 1566 PQUEUE_ENTRY pQEntry;
1580 1567
1581 STAFindCipherAlgorithm(pAd, pTxBlk); 1568 STAFindCipherAlgorithm(pAd, pTxBlk);
1582 STABuildCommon802_11Header(pAd, pTxBlk); 1569 STABuildCommon802_11Header(pAd, pTxBlk);
1583 1570
1584
1585 pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE]; 1571 pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
1586 pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr; 1572 pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr;
1587 1573
@@ -1591,22 +1577,20 @@ static inline PUCHAR STA_Build_ARalink_Frame_Header(
1591 // skip common header 1577 // skip common header
1592 pHeaderBufPtr += pTxBlk->MpduHeaderLen; 1578 pHeaderBufPtr += pTxBlk->MpduHeaderLen;
1593 1579
1594 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) 1580 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) {
1595 {
1596 // 1581 //
1597 // build QOS Control bytes 1582 // build QOS Control bytes
1598 // 1583 //
1599 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F); 1584 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F);
1600 1585
1601 *(pHeaderBufPtr+1) = 0; 1586 *(pHeaderBufPtr + 1) = 0;
1602 pHeaderBufPtr +=2; 1587 pHeaderBufPtr += 2;
1603 pTxBlk->MpduHeaderLen += 2; 1588 pTxBlk->MpduHeaderLen += 2;
1604 } 1589 }
1605
1606 // padding at front of LLC header. LLC header should at 4-bytes aligment. 1590 // padding at front of LLC header. LLC header should at 4-bytes aligment.
1607 pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr; 1591 pTxBlk->HdrPadLen = (ULONG) pHeaderBufPtr;
1608 pHeaderBufPtr = (PUCHAR)ROUND_UP(pHeaderBufPtr, 4); 1592 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4);
1609 pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen); 1593 pTxBlk->HdrPadLen = (ULONG) (pHeaderBufPtr - pTxBlk->HdrPadLen);
1610 1594
1611 // For RA Aggregation, 1595 // For RA Aggregation,
1612 // put the 2nd MSDU length(extra 2-byte field) after QOS_CONTROL in little endian format 1596 // put the 2nd MSDU length(extra 2-byte field) after QOS_CONTROL in little endian format
@@ -1616,8 +1600,8 @@ static inline PUCHAR STA_Build_ARalink_Frame_Header(
1616 if (RTMP_GET_PACKET_VLAN(pNextPacket)) 1600 if (RTMP_GET_PACKET_VLAN(pNextPacket))
1617 nextBufLen -= LENGTH_802_1Q; 1601 nextBufLen -= LENGTH_802_1Q;
1618 1602
1619 *pHeaderBufPtr = (UCHAR)nextBufLen & 0xff; 1603 *pHeaderBufPtr = (UCHAR) nextBufLen & 0xff;
1620 *(pHeaderBufPtr+1) = (UCHAR)(nextBufLen >> 8); 1604 *(pHeaderBufPtr + 1) = (UCHAR) (nextBufLen >> 8);
1621 1605
1622 pHeaderBufPtr += 2; 1606 pHeaderBufPtr += 2;
1623 pTxBlk->MpduHeaderLen += 2; 1607 pTxBlk->MpduHeaderLen += 2;
@@ -1626,13 +1610,11 @@ static inline PUCHAR STA_Build_ARalink_Frame_Header(
1626 1610
1627} 1611}
1628 1612
1629static inline PUCHAR STA_Build_AMSDU_Frame_Header( 1613static inline PUCHAR STA_Build_AMSDU_Frame_Header(IN RTMP_ADAPTER * pAd,
1630 IN RTMP_ADAPTER *pAd, 1614 IN TX_BLK * pTxBlk)
1631 IN TX_BLK *pTxBlk)
1632{ 1615{
1633 PUCHAR pHeaderBufPtr;//, pSaveBufPtr; 1616 PUCHAR pHeaderBufPtr; //, pSaveBufPtr;
1634 HEADER_802_11 *pHeader_802_11; 1617 HEADER_802_11 *pHeader_802_11;
1635
1636 1618
1637 STAFindCipherAlgorithm(pAd, pTxBlk); 1619 STAFindCipherAlgorithm(pAd, pTxBlk);
1638 STABuildCommon802_11Header(pAd, pTxBlk); 1620 STABuildCommon802_11Header(pAd, pTxBlk);
@@ -1653,8 +1635,8 @@ static inline PUCHAR STA_Build_AMSDU_Frame_Header(
1653 // 1635 //
1654 *pHeaderBufPtr |= 0x80; 1636 *pHeaderBufPtr |= 0x80;
1655 1637
1656 *(pHeaderBufPtr+1) = 0; 1638 *(pHeaderBufPtr + 1) = 0;
1657 pHeaderBufPtr +=2; 1639 pHeaderBufPtr += 2;
1658 pTxBlk->MpduHeaderLen += 2; 1640 pTxBlk->MpduHeaderLen += 2;
1659 1641
1660 //pSaveBufPtr = pHeaderBufPtr; 1642 //pSaveBufPtr = pHeaderBufPtr;
@@ -1665,57 +1647,56 @@ static inline PUCHAR STA_Build_AMSDU_Frame_Header(
1665 // 1647 //
1666 // @@@ MpduHeaderLen excluding padding @@@ 1648 // @@@ MpduHeaderLen excluding padding @@@
1667 // 1649 //
1668 pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr; 1650 pTxBlk->HdrPadLen = (ULONG) pHeaderBufPtr;
1669 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4); 1651 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4);
1670 pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen); 1652 pTxBlk->HdrPadLen = (ULONG) (pHeaderBufPtr - pTxBlk->HdrPadLen);
1671 1653
1672 return pHeaderBufPtr; 1654 return pHeaderBufPtr;
1673 1655
1674} 1656}
1675 1657
1676 1658VOID STA_AMPDU_Frame_Tx(IN PRTMP_ADAPTER pAd, IN TX_BLK * pTxBlk)
1677VOID STA_AMPDU_Frame_Tx(
1678 IN PRTMP_ADAPTER pAd,
1679 IN TX_BLK *pTxBlk)
1680{ 1659{
1681 HEADER_802_11 *pHeader_802_11; 1660 HEADER_802_11 *pHeader_802_11;
1682 PUCHAR pHeaderBufPtr; 1661 PUCHAR pHeaderBufPtr;
1683 USHORT FreeNumber; 1662 USHORT FreeNumber;
1684 MAC_TABLE_ENTRY *pMacEntry; 1663 MAC_TABLE_ENTRY *pMacEntry;
1685 BOOLEAN bVLANPkt; 1664 BOOLEAN bVLANPkt;
1686 PQUEUE_ENTRY pQEntry; 1665 PQUEUE_ENTRY pQEntry;
1687 1666
1688 ASSERT(pTxBlk); 1667 ASSERT(pTxBlk);
1689 1668
1690 while(pTxBlk->TxPacketList.Head) 1669 while (pTxBlk->TxPacketList.Head) {
1691 {
1692 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList); 1670 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
1693 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry); 1671 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
1694 if ( RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) 1672 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) {
1695 { 1673 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket,
1696 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE); 1674 NDIS_STATUS_FAILURE);
1697 continue; 1675 continue;
1698 } 1676 }
1699 1677
1700 bVLANPkt = (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE); 1678 bVLANPkt =
1679 (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE);
1701 1680
1702 pMacEntry = pTxBlk->pMacEntry; 1681 pMacEntry = pTxBlk->pMacEntry;
1703 if (pMacEntry->isCached) 1682 if (pMacEntry->isCached) {
1704 {
1705 // NOTE: Please make sure the size of pMacEntry->CachedBuf[] is smaller than pTxBlk->HeaderBuf[]!!!! 1683 // NOTE: Please make sure the size of pMacEntry->CachedBuf[] is smaller than pTxBlk->HeaderBuf[]!!!!
1706 NdisMoveMemory((PUCHAR)&pTxBlk->HeaderBuf[TXINFO_SIZE], (PUCHAR)&pMacEntry->CachedBuf[0], TXWI_SIZE + sizeof(HEADER_802_11)); 1684 NdisMoveMemory((PUCHAR) & pTxBlk->
1707 pHeaderBufPtr = (PUCHAR)(&pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE]); 1685 HeaderBuf[TXINFO_SIZE],
1686 (PUCHAR) & pMacEntry->CachedBuf[0],
1687 TXWI_SIZE + sizeof(HEADER_802_11));
1688 pHeaderBufPtr =
1689 (PUCHAR) (&pTxBlk->
1690 HeaderBuf[TXINFO_SIZE + TXWI_SIZE]);
1708 STABuildCache802_11Header(pAd, pTxBlk, pHeaderBufPtr); 1691 STABuildCache802_11Header(pAd, pTxBlk, pHeaderBufPtr);
1709 } 1692 } else {
1710 else
1711 {
1712 STAFindCipherAlgorithm(pAd, pTxBlk); 1693 STAFindCipherAlgorithm(pAd, pTxBlk);
1713 STABuildCommon802_11Header(pAd, pTxBlk); 1694 STABuildCommon802_11Header(pAd, pTxBlk);
1714 1695
1715 pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE]; 1696 pHeaderBufPtr =
1697 &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
1716 } 1698 }
1717 1699
1718
1719 pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr; 1700 pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr;
1720 1701
1721 // skip common header 1702 // skip common header
@@ -1725,87 +1706,101 @@ VOID STA_AMPDU_Frame_Tx(
1725 // build QOS Control bytes 1706 // build QOS Control bytes
1726 // 1707 //
1727 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F); 1708 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F);
1728 *(pHeaderBufPtr+1) = 0; 1709 *(pHeaderBufPtr + 1) = 0;
1729 pHeaderBufPtr +=2; 1710 pHeaderBufPtr += 2;
1730 pTxBlk->MpduHeaderLen += 2; 1711 pTxBlk->MpduHeaderLen += 2;
1731 1712
1732 // 1713 //
1733 // build HTC+ 1714 // build HTC+
1734 // HTC control filed following QoS field 1715 // HTC control filed following QoS field
1735 // 1716 //
1736 if ((pAd->CommonCfg.bRdg == TRUE) && CLIENT_STATUS_TEST_FLAG(pTxBlk->pMacEntry, fCLIENT_STATUS_RDG_CAPABLE)) 1717 if ((pAd->CommonCfg.bRdg == TRUE)
1737 { 1718 && CLIENT_STATUS_TEST_FLAG(pTxBlk->pMacEntry,
1738 if (pMacEntry->isCached == FALSE) 1719 fCLIENT_STATUS_RDG_CAPABLE)) {
1739 { 1720 if (pMacEntry->isCached == FALSE) {
1740 // mark HTC bit 1721 // mark HTC bit
1741 pHeader_802_11->FC.Order = 1; 1722 pHeader_802_11->FC.Order = 1;
1742 1723
1743 NdisZeroMemory(pHeaderBufPtr, 4); 1724 NdisZeroMemory(pHeaderBufPtr, 4);
1744 *(pHeaderBufPtr+3) |= 0x80; 1725 *(pHeaderBufPtr + 3) |= 0x80;
1745 } 1726 }
1746 pHeaderBufPtr += 4; 1727 pHeaderBufPtr += 4;
1747 pTxBlk->MpduHeaderLen += 4; 1728 pTxBlk->MpduHeaderLen += 4;
1748 } 1729 }
1749
1750 //pTxBlk->MpduHeaderLen = pHeaderBufPtr - pTxBlk->HeaderBuf - TXWI_SIZE - TXINFO_SIZE; 1730 //pTxBlk->MpduHeaderLen = pHeaderBufPtr - pTxBlk->HeaderBuf - TXWI_SIZE - TXINFO_SIZE;
1751 ASSERT(pTxBlk->MpduHeaderLen >= 24); 1731 ASSERT(pTxBlk->MpduHeaderLen >= 24);
1752 1732
1753 // skip 802.3 header 1733 // skip 802.3 header
1754 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3; 1734 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
1755 pTxBlk->SrcBufLen -= LENGTH_802_3; 1735 pTxBlk->SrcBufLen -= LENGTH_802_3;
1756 1736
1757 // skip vlan tag 1737 // skip vlan tag
1758 if (bVLANPkt) 1738 if (bVLANPkt) {
1759 { 1739 pTxBlk->pSrcBufData += LENGTH_802_1Q;
1760 pTxBlk->pSrcBufData += LENGTH_802_1Q; 1740 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
1761 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
1762 } 1741 }
1763
1764 // 1742 //
1765 // padding at front of LLC header 1743 // padding at front of LLC header
1766 // LLC header should locate at 4-octets aligment 1744 // LLC header should locate at 4-octets aligment
1767 // 1745 //
1768 // @@@ MpduHeaderLen excluding padding @@@ 1746 // @@@ MpduHeaderLen excluding padding @@@
1769 // 1747 //
1770 pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr; 1748 pTxBlk->HdrPadLen = (ULONG) pHeaderBufPtr;
1771 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4); 1749 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4);
1772 pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen); 1750 pTxBlk->HdrPadLen = (ULONG) (pHeaderBufPtr - pTxBlk->HdrPadLen);
1773 1751
1774 { 1752 {
1775 1753
1776 // 1754 //
1777 // Insert LLC-SNAP encapsulation - 8 octets 1755 // Insert LLC-SNAP encapsulation - 8 octets
1778 // 1756 //
1779 EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->pSrcBufData-2, pTxBlk->pExtraLlcSnapEncap); 1757 EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->
1780 if (pTxBlk->pExtraLlcSnapEncap) 1758 pSrcBufData - 2,
1781 { 1759 pTxBlk->
1782 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6); 1760 pExtraLlcSnapEncap);
1761 if (pTxBlk->pExtraLlcSnapEncap) {
1762 NdisMoveMemory(pHeaderBufPtr,
1763 pTxBlk->pExtraLlcSnapEncap, 6);
1783 pHeaderBufPtr += 6; 1764 pHeaderBufPtr += 6;
1784 // get 2 octets (TypeofLen) 1765 // get 2 octets (TypeofLen)
1785 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData-2, 2); 1766 NdisMoveMemory(pHeaderBufPtr,
1767 pTxBlk->pSrcBufData - 2, 2);
1786 pHeaderBufPtr += 2; 1768 pHeaderBufPtr += 2;
1787 pTxBlk->MpduHeaderLen += LENGTH_802_1_H; 1769 pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
1788 } 1770 }
1789 1771
1790 } 1772 }
1791 1773
1792 if (pMacEntry->isCached) 1774 if (pMacEntry->isCached) {
1793 { 1775 RTMPWriteTxWI_Cache(pAd,
1794 RTMPWriteTxWI_Cache(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk); 1776 (PTXWI_STRUC) (&pTxBlk->
1795 } 1777 HeaderBuf
1796 else 1778 [TXINFO_SIZE]),
1797 { 1779 pTxBlk);
1798 RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk); 1780 } else {
1799 1781 RTMPWriteTxWI_Data(pAd,
1800 NdisZeroMemory((PUCHAR)(&pMacEntry->CachedBuf[0]), sizeof(pMacEntry->CachedBuf)); 1782 (PTXWI_STRUC) (&pTxBlk->
1801 NdisMoveMemory((PUCHAR)(&pMacEntry->CachedBuf[0]), (PUCHAR)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), (pHeaderBufPtr - (PUCHAR)(&pTxBlk->HeaderBuf[TXINFO_SIZE]))); 1783 HeaderBuf
1784 [TXINFO_SIZE]),
1785 pTxBlk);
1786
1787 NdisZeroMemory((PUCHAR) (&pMacEntry->CachedBuf[0]),
1788 sizeof(pMacEntry->CachedBuf));
1789 NdisMoveMemory((PUCHAR) (&pMacEntry->CachedBuf[0]),
1790 (PUCHAR) (&pTxBlk->
1791 HeaderBuf[TXINFO_SIZE]),
1792 (pHeaderBufPtr -
1793 (PUCHAR) (&pTxBlk->
1794 HeaderBuf[TXINFO_SIZE])));
1802 pMacEntry->isCached = TRUE; 1795 pMacEntry->isCached = TRUE;
1803 } 1796 }
1804 1797
1805 // calculate Transmitted AMPDU count and ByteCount 1798 // calculate Transmitted AMPDU count and ByteCount
1806 { 1799 {
1807 pAd->RalinkCounters.TransmittedMPDUsInAMPDUCount.u.LowPart ++; 1800 pAd->RalinkCounters.TransmittedMPDUsInAMPDUCount.u.
1808 pAd->RalinkCounters.TransmittedOctetsInAMPDUCount.QuadPart += pTxBlk->SrcBufLen; 1801 LowPart++;
1802 pAd->RalinkCounters.TransmittedOctetsInAMPDUCount.
1803 QuadPart += pTxBlk->SrcBufLen;
1809 } 1804 }
1810 1805
1811 //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx); 1806 //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx);
@@ -1824,62 +1819,64 @@ VOID STA_AMPDU_Frame_Tx(
1824 1819
1825} 1820}
1826 1821
1827 1822VOID STA_AMSDU_Frame_Tx(IN PRTMP_ADAPTER pAd, IN TX_BLK * pTxBlk)
1828VOID STA_AMSDU_Frame_Tx(
1829 IN PRTMP_ADAPTER pAd,
1830 IN TX_BLK *pTxBlk)
1831{ 1823{
1832 PUCHAR pHeaderBufPtr; 1824 PUCHAR pHeaderBufPtr;
1833 USHORT FreeNumber; 1825 USHORT FreeNumber;
1834 USHORT subFramePayloadLen = 0; // AMSDU Subframe length without AMSDU-Header / Padding. 1826 USHORT subFramePayloadLen = 0; // AMSDU Subframe length without AMSDU-Header / Padding.
1835 USHORT totalMPDUSize=0; 1827 USHORT totalMPDUSize = 0;
1836 UCHAR *subFrameHeader; 1828 UCHAR *subFrameHeader;
1837 UCHAR padding = 0; 1829 UCHAR padding = 0;
1838 USHORT FirstTx = 0, LastTxIdx = 0; 1830 USHORT FirstTx = 0, LastTxIdx = 0;
1839 BOOLEAN bVLANPkt; 1831 BOOLEAN bVLANPkt;
1840 int frameNum = 0; 1832 int frameNum = 0;
1841 PQUEUE_ENTRY pQEntry; 1833 PQUEUE_ENTRY pQEntry;
1842
1843 1834
1844 ASSERT(pTxBlk); 1835 ASSERT(pTxBlk);
1845 1836
1846 ASSERT((pTxBlk->TxPacketList.Number > 1)); 1837 ASSERT((pTxBlk->TxPacketList.Number > 1));
1847 1838
1848 while(pTxBlk->TxPacketList.Head) 1839 while (pTxBlk->TxPacketList.Head) {
1849 {
1850 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList); 1840 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
1851 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry); 1841 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
1852 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) 1842 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) {
1853 { 1843 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket,
1854 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE); 1844 NDIS_STATUS_FAILURE);
1855 continue; 1845 continue;
1856 } 1846 }
1857 1847
1858 bVLANPkt = (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE); 1848 bVLANPkt =
1849 (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE);
1859 1850
1860 // skip 802.3 header 1851 // skip 802.3 header
1861 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3; 1852 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
1862 pTxBlk->SrcBufLen -= LENGTH_802_3; 1853 pTxBlk->SrcBufLen -= LENGTH_802_3;
1863 1854
1864 // skip vlan tag 1855 // skip vlan tag
1865 if (bVLANPkt) 1856 if (bVLANPkt) {
1866 { 1857 pTxBlk->pSrcBufData += LENGTH_802_1Q;
1867 pTxBlk->pSrcBufData += LENGTH_802_1Q; 1858 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
1868 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
1869 } 1859 }
1870 1860
1871 if (frameNum == 0) 1861 if (frameNum == 0) {
1872 { 1862 pHeaderBufPtr =
1873 pHeaderBufPtr = STA_Build_AMSDU_Frame_Header(pAd, pTxBlk); 1863 STA_Build_AMSDU_Frame_Header(pAd, pTxBlk);
1874 1864
1875 // NOTE: TxWI->MPDUtotalByteCount will be updated after final frame was handled. 1865 // NOTE: TxWI->MPDUtotalByteCount will be updated after final frame was handled.
1876 RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk); 1866 RTMPWriteTxWI_Data(pAd,
1877 } 1867 (PTXWI_STRUC) (&pTxBlk->
1878 else 1868 HeaderBuf
1879 { 1869 [TXINFO_SIZE]),
1870 pTxBlk);
1871 } else {
1880 pHeaderBufPtr = &pTxBlk->HeaderBuf[0]; 1872 pHeaderBufPtr = &pTxBlk->HeaderBuf[0];
1881 padding = ROUND_UP(LENGTH_AMSDU_SUBFRAMEHEAD + subFramePayloadLen, 4) - (LENGTH_AMSDU_SUBFRAMEHEAD + subFramePayloadLen); 1873 padding =
1882 NdisZeroMemory(pHeaderBufPtr, padding + LENGTH_AMSDU_SUBFRAMEHEAD); 1874 ROUND_UP(LENGTH_AMSDU_SUBFRAMEHEAD +
1875 subFramePayloadLen,
1876 4) - (LENGTH_AMSDU_SUBFRAMEHEAD +
1877 subFramePayloadLen);
1878 NdisZeroMemory(pHeaderBufPtr,
1879 padding + LENGTH_AMSDU_SUBFRAMEHEAD);
1883 pHeaderBufPtr += padding; 1880 pHeaderBufPtr += padding;
1884 pTxBlk->MpduHeaderLen = padding; 1881 pTxBlk->MpduHeaderLen = padding;
1885 } 1882 }
@@ -1893,39 +1890,42 @@ VOID STA_AMSDU_Frame_Tx(
1893 1890
1894 NdisMoveMemory(subFrameHeader, pTxBlk->pSrcBufHeader, 12); 1891 NdisMoveMemory(subFrameHeader, pTxBlk->pSrcBufHeader, 12);
1895 1892
1896
1897 pHeaderBufPtr += LENGTH_AMSDU_SUBFRAMEHEAD; 1893 pHeaderBufPtr += LENGTH_AMSDU_SUBFRAMEHEAD;
1898 pTxBlk->MpduHeaderLen += LENGTH_AMSDU_SUBFRAMEHEAD; 1894 pTxBlk->MpduHeaderLen += LENGTH_AMSDU_SUBFRAMEHEAD;
1899 1895
1900
1901 // 1896 //
1902 // Insert LLC-SNAP encapsulation - 8 octets 1897 // Insert LLC-SNAP encapsulation - 8 octets
1903 // 1898 //
1904 EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->pSrcBufData-2, pTxBlk->pExtraLlcSnapEncap); 1899 EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->pSrcBufData - 2,
1900 pTxBlk->pExtraLlcSnapEncap);
1905 1901
1906 subFramePayloadLen = pTxBlk->SrcBufLen; 1902 subFramePayloadLen = pTxBlk->SrcBufLen;
1907 1903
1908 if (pTxBlk->pExtraLlcSnapEncap) 1904 if (pTxBlk->pExtraLlcSnapEncap) {
1909 { 1905 NdisMoveMemory(pHeaderBufPtr,
1910 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6); 1906 pTxBlk->pExtraLlcSnapEncap, 6);
1911 pHeaderBufPtr += 6; 1907 pHeaderBufPtr += 6;
1912 // get 2 octets (TypeofLen) 1908 // get 2 octets (TypeofLen)
1913 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData-2, 2); 1909 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData - 2,
1910 2);
1914 pHeaderBufPtr += 2; 1911 pHeaderBufPtr += 2;
1915 pTxBlk->MpduHeaderLen += LENGTH_802_1_H; 1912 pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
1916 subFramePayloadLen += LENGTH_802_1_H; 1913 subFramePayloadLen += LENGTH_802_1_H;
1917 } 1914 }
1918
1919 // update subFrame Length field 1915 // update subFrame Length field
1920 subFrameHeader[12] = (subFramePayloadLen & 0xFF00) >> 8; 1916 subFrameHeader[12] = (subFramePayloadLen & 0xFF00) >> 8;
1921 subFrameHeader[13] = subFramePayloadLen & 0xFF; 1917 subFrameHeader[13] = subFramePayloadLen & 0xFF;
1922 1918
1923 totalMPDUSize += pTxBlk->MpduHeaderLen + pTxBlk->SrcBufLen; 1919 totalMPDUSize += pTxBlk->MpduHeaderLen + pTxBlk->SrcBufLen;
1924 1920
1925 if (frameNum ==0) 1921 if (frameNum == 0)
1926 FirstTx = HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum, &FreeNumber); 1922 FirstTx =
1923 HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum,
1924 &FreeNumber);
1927 else 1925 else
1928 LastTxIdx = HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum, &FreeNumber); 1926 LastTxIdx =
1927 HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum,
1928 &FreeNumber);
1929 1929
1930 frameNum++; 1930 frameNum++;
1931 1931
@@ -1934,8 +1934,9 @@ VOID STA_AMSDU_Frame_Tx(
1934 1934
1935 // calculate Transmitted AMSDU Count and ByteCount 1935 // calculate Transmitted AMSDU Count and ByteCount
1936 { 1936 {
1937 pAd->RalinkCounters.TransmittedAMSDUCount.u.LowPart ++; 1937 pAd->RalinkCounters.TransmittedAMSDUCount.u.LowPart++;
1938 pAd->RalinkCounters.TransmittedOctetsInAMSDU.QuadPart += totalMPDUSize; 1938 pAd->RalinkCounters.TransmittedOctetsInAMSDU.QuadPart +=
1939 totalMPDUSize;
1939 } 1940 }
1940 1941
1941 } 1942 }
@@ -1950,29 +1951,24 @@ VOID STA_AMSDU_Frame_Tx(
1950 HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx); 1951 HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx);
1951} 1952}
1952 1953
1953VOID STA_Legacy_Frame_Tx( 1954VOID STA_Legacy_Frame_Tx(IN PRTMP_ADAPTER pAd, IN TX_BLK * pTxBlk)
1954 IN PRTMP_ADAPTER pAd,
1955 IN TX_BLK *pTxBlk)
1956{ 1955{
1957 HEADER_802_11 *pHeader_802_11; 1956 HEADER_802_11 *pHeader_802_11;
1958 PUCHAR pHeaderBufPtr; 1957 PUCHAR pHeaderBufPtr;
1959 USHORT FreeNumber; 1958 USHORT FreeNumber;
1960 BOOLEAN bVLANPkt; 1959 BOOLEAN bVLANPkt;
1961 PQUEUE_ENTRY pQEntry; 1960 PQUEUE_ENTRY pQEntry;
1962 1961
1963 ASSERT(pTxBlk); 1962 ASSERT(pTxBlk);
1964 1963
1965
1966 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList); 1964 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
1967 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry); 1965 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
1968 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) 1966 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) {
1969 {
1970 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE); 1967 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
1971 return; 1968 return;
1972 } 1969 }
1973 1970
1974 if (pTxBlk->TxFrameType == TX_MCAST_FRAME) 1971 if (pTxBlk->TxFrameType == TX_MCAST_FRAME) {
1975 {
1976 INC_COUNTER64(pAd->WlanCounters.MulticastTransmittedFrameCount); 1972 INC_COUNTER64(pAd->WlanCounters.MulticastTransmittedFrameCount);
1977 } 1973 }
1978 1974
@@ -1989,16 +1985,14 @@ VOID STA_Legacy_Frame_Tx(
1989 STAFindCipherAlgorithm(pAd, pTxBlk); 1985 STAFindCipherAlgorithm(pAd, pTxBlk);
1990 STABuildCommon802_11Header(pAd, pTxBlk); 1986 STABuildCommon802_11Header(pAd, pTxBlk);
1991 1987
1992
1993 // skip 802.3 header 1988 // skip 802.3 header
1994 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3; 1989 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
1995 pTxBlk->SrcBufLen -= LENGTH_802_3; 1990 pTxBlk->SrcBufLen -= LENGTH_802_3;
1996 1991
1997 // skip vlan tag 1992 // skip vlan tag
1998 if (bVLANPkt) 1993 if (bVLANPkt) {
1999 { 1994 pTxBlk->pSrcBufData += LENGTH_802_1Q;
2000 pTxBlk->pSrcBufData += LENGTH_802_1Q; 1995 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
2001 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
2002 } 1996 }
2003 1997
2004 pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE]; 1998 pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
@@ -2007,21 +2001,22 @@ VOID STA_Legacy_Frame_Tx(
2007 // skip common header 2001 // skip common header
2008 pHeaderBufPtr += pTxBlk->MpduHeaderLen; 2002 pHeaderBufPtr += pTxBlk->MpduHeaderLen;
2009 2003
2010 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) 2004 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) {
2011 {
2012 // 2005 //
2013 // build QOS Control bytes 2006 // build QOS Control bytes
2014 // 2007 //
2015 *(pHeaderBufPtr) = ((pTxBlk->UserPriority & 0x0F) | (pAd->CommonCfg.AckPolicy[pTxBlk->QueIdx]<<5)); 2008 *(pHeaderBufPtr) =
2016 *(pHeaderBufPtr+1) = 0; 2009 ((pTxBlk->UserPriority & 0x0F) | (pAd->CommonCfg.
2017 pHeaderBufPtr +=2; 2010 AckPolicy[pTxBlk->
2011 QueIdx] << 5));
2012 *(pHeaderBufPtr + 1) = 0;
2013 pHeaderBufPtr += 2;
2018 pTxBlk->MpduHeaderLen += 2; 2014 pTxBlk->MpduHeaderLen += 2;
2019 } 2015 }
2020
2021 // The remaining content of MPDU header should locate at 4-octets aligment 2016 // The remaining content of MPDU header should locate at 4-octets aligment
2022 pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr; 2017 pTxBlk->HdrPadLen = (ULONG) pHeaderBufPtr;
2023 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4); 2018 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4);
2024 pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen); 2019 pTxBlk->HdrPadLen = (ULONG) (pHeaderBufPtr - pTxBlk->HdrPadLen);
2025 2020
2026 { 2021 {
2027 2022
@@ -2029,20 +2024,23 @@ VOID STA_Legacy_Frame_Tx(
2029 // Insert LLC-SNAP encapsulation - 8 octets 2024 // Insert LLC-SNAP encapsulation - 8 octets
2030 // 2025 //
2031 // 2026 //
2032 // if original Ethernet frame contains no LLC/SNAP, 2027 // if original Ethernet frame contains no LLC/SNAP,
2033 // then an extra LLC/SNAP encap is required 2028 // then an extra LLC/SNAP encap is required
2034 // 2029 //
2035 EXTRA_LLCSNAP_ENCAP_FROM_PKT_START(pTxBlk->pSrcBufHeader, pTxBlk->pExtraLlcSnapEncap); 2030 EXTRA_LLCSNAP_ENCAP_FROM_PKT_START(pTxBlk->pSrcBufHeader,
2036 if (pTxBlk->pExtraLlcSnapEncap) 2031 pTxBlk->pExtraLlcSnapEncap);
2037 { 2032 if (pTxBlk->pExtraLlcSnapEncap) {
2038 UCHAR vlan_size; 2033 UCHAR vlan_size;
2039 2034
2040 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6); 2035 NdisMoveMemory(pHeaderBufPtr,
2036 pTxBlk->pExtraLlcSnapEncap, 6);
2041 pHeaderBufPtr += 6; 2037 pHeaderBufPtr += 6;
2042 // skip vlan tag 2038 // skip vlan tag
2043 vlan_size = (bVLANPkt) ? LENGTH_802_1Q : 0; 2039 vlan_size = (bVLANPkt) ? LENGTH_802_1Q : 0;
2044 // get 2 octets (TypeofLen) 2040 // get 2 octets (TypeofLen)
2045 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufHeader+12+vlan_size, 2); 2041 NdisMoveMemory(pHeaderBufPtr,
2042 pTxBlk->pSrcBufHeader + 12 + vlan_size,
2043 2);
2046 pHeaderBufPtr += 2; 2044 pHeaderBufPtr += 2;
2047 pTxBlk->MpduHeaderLen += LENGTH_802_1_H; 2045 pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
2048 } 2046 }
@@ -2054,7 +2052,8 @@ VOID STA_Legacy_Frame_Tx(
2054 // use Wcid as Key Index 2052 // use Wcid as Key Index
2055 // 2053 //
2056 2054
2057 RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk); 2055 RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC) (&pTxBlk->HeaderBuf[TXINFO_SIZE]),
2056 pTxBlk);
2058 2057
2059 //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx); 2058 //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx);
2060 2059
@@ -2070,87 +2069,88 @@ VOID STA_Legacy_Frame_Tx(
2070 HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx); 2069 HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx);
2071} 2070}
2072 2071
2073 2072VOID STA_ARalink_Frame_Tx(IN PRTMP_ADAPTER pAd, IN TX_BLK * pTxBlk)
2074VOID STA_ARalink_Frame_Tx(
2075 IN PRTMP_ADAPTER pAd,
2076 IN TX_BLK *pTxBlk)
2077{ 2073{
2078 PUCHAR pHeaderBufPtr; 2074 PUCHAR pHeaderBufPtr;
2079 USHORT FreeNumber; 2075 USHORT FreeNumber;
2080 USHORT totalMPDUSize=0; 2076 USHORT totalMPDUSize = 0;
2081 USHORT FirstTx, LastTxIdx; 2077 USHORT FirstTx, LastTxIdx;
2082 int frameNum = 0; 2078 int frameNum = 0;
2083 BOOLEAN bVLANPkt; 2079 BOOLEAN bVLANPkt;
2084 PQUEUE_ENTRY pQEntry; 2080 PQUEUE_ENTRY pQEntry;
2085
2086 2081
2087 ASSERT(pTxBlk); 2082 ASSERT(pTxBlk);
2088 2083
2089 ASSERT((pTxBlk->TxPacketList.Number== 2)); 2084 ASSERT((pTxBlk->TxPacketList.Number == 2));
2090 2085
2091 2086 FirstTx = LastTxIdx = 0; // Is it ok init they as 0?
2092 FirstTx = LastTxIdx = 0; // Is it ok init they as 0? 2087 while (pTxBlk->TxPacketList.Head) {
2093 while(pTxBlk->TxPacketList.Head)
2094 {
2095 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList); 2088 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
2096 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry); 2089 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
2097 2090
2098 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) 2091 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) {
2099 { 2092 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket,
2100 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE); 2093 NDIS_STATUS_FAILURE);
2101 continue; 2094 continue;
2102 } 2095 }
2103 2096
2104 bVLANPkt = (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE); 2097 bVLANPkt =
2098 (RTMP_GET_PACKET_VLAN(pTxBlk->pPacket) ? TRUE : FALSE);
2105 2099
2106 // skip 802.3 header 2100 // skip 802.3 header
2107 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3; 2101 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
2108 pTxBlk->SrcBufLen -= LENGTH_802_3; 2102 pTxBlk->SrcBufLen -= LENGTH_802_3;
2109 2103
2110 // skip vlan tag 2104 // skip vlan tag
2111 if (bVLANPkt) 2105 if (bVLANPkt) {
2112 { 2106 pTxBlk->pSrcBufData += LENGTH_802_1Q;
2113 pTxBlk->pSrcBufData += LENGTH_802_1Q; 2107 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
2114 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
2115 } 2108 }
2116 2109
2117 if (frameNum == 0) 2110 if (frameNum == 0) { // For first frame, we need to create the 802.11 header + padding(optional) + RA-AGG-LEN + SNAP Header
2118 { // For first frame, we need to create the 802.11 header + padding(optional) + RA-AGG-LEN + SNAP Header
2119 2111
2120 pHeaderBufPtr = STA_Build_ARalink_Frame_Header(pAd, pTxBlk); 2112 pHeaderBufPtr =
2113 STA_Build_ARalink_Frame_Header(pAd, pTxBlk);
2121 2114
2122 // It's ok write the TxWI here, because the TxWI->MPDUtotalByteCount 2115 // It's ok write the TxWI here, because the TxWI->MPDUtotalByteCount
2123 // will be updated after final frame was handled. 2116 // will be updated after final frame was handled.
2124 RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk); 2117 RTMPWriteTxWI_Data(pAd,
2125 2118 (PTXWI_STRUC) (&pTxBlk->
2119 HeaderBuf
2120 [TXINFO_SIZE]),
2121 pTxBlk);
2126 2122
2127 // 2123 //
2128 // Insert LLC-SNAP encapsulation - 8 octets 2124 // Insert LLC-SNAP encapsulation - 8 octets
2129 // 2125 //
2130 EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->pSrcBufData-2, pTxBlk->pExtraLlcSnapEncap); 2126 EXTRA_LLCSNAP_ENCAP_FROM_PKT_OFFSET(pTxBlk->
2131 2127 pSrcBufData - 2,
2132 if (pTxBlk->pExtraLlcSnapEncap) 2128 pTxBlk->
2133 { 2129 pExtraLlcSnapEncap);
2134 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6); 2130
2131 if (pTxBlk->pExtraLlcSnapEncap) {
2132 NdisMoveMemory(pHeaderBufPtr,
2133 pTxBlk->pExtraLlcSnapEncap, 6);
2135 pHeaderBufPtr += 6; 2134 pHeaderBufPtr += 6;
2136 // get 2 octets (TypeofLen) 2135 // get 2 octets (TypeofLen)
2137 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData-2, 2); 2136 NdisMoveMemory(pHeaderBufPtr,
2137 pTxBlk->pSrcBufData - 2, 2);
2138 pHeaderBufPtr += 2; 2138 pHeaderBufPtr += 2;
2139 pTxBlk->MpduHeaderLen += LENGTH_802_1_H; 2139 pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
2140 } 2140 }
2141 } 2141 } else { // For second aggregated frame, we need create the 802.3 header to headerBuf, because PCI will copy it to SDPtr0.
2142 else
2143 { // For second aggregated frame, we need create the 802.3 header to headerBuf, because PCI will copy it to SDPtr0.
2144 2142
2145 pHeaderBufPtr = &pTxBlk->HeaderBuf[0]; 2143 pHeaderBufPtr = &pTxBlk->HeaderBuf[0];
2146 pTxBlk->MpduHeaderLen = 0; 2144 pTxBlk->MpduHeaderLen = 0;
2147 2145
2148 // A-Ralink sub-sequent frame header is the same as 802.3 header. 2146 // A-Ralink sub-sequent frame header is the same as 802.3 header.
2149 // DA(6)+SA(6)+FrameType(2) 2147 // DA(6)+SA(6)+FrameType(2)
2150 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufHeader, 12); 2148 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufHeader,
2149 12);
2151 pHeaderBufPtr += 12; 2150 pHeaderBufPtr += 12;
2152 // get 2 octets (TypeofLen) 2151 // get 2 octets (TypeofLen)
2153 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData-2, 2); 2152 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufData - 2,
2153 2);
2154 pHeaderBufPtr += 2; 2154 pHeaderBufPtr += 2;
2155 pTxBlk->MpduHeaderLen = LENGTH_ARALINK_SUBFRAMEHEAD; 2155 pTxBlk->MpduHeaderLen = LENGTH_ARALINK_SUBFRAMEHEAD;
2156 } 2156 }
@@ -2158,10 +2158,14 @@ VOID STA_ARalink_Frame_Tx(
2158 totalMPDUSize += pTxBlk->MpduHeaderLen + pTxBlk->SrcBufLen; 2158 totalMPDUSize += pTxBlk->MpduHeaderLen + pTxBlk->SrcBufLen;
2159 2159
2160 //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx); 2160 //FreeNumber = GET_TXRING_FREENO(pAd, QueIdx);
2161 if (frameNum ==0) 2161 if (frameNum == 0)
2162 FirstTx = HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum, &FreeNumber); 2162 FirstTx =
2163 HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum,
2164 &FreeNumber);
2163 else 2165 else
2164 LastTxIdx = HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum, &FreeNumber); 2166 LastTxIdx =
2167 HAL_WriteMultiTxResource(pAd, pTxBlk, frameNum,
2168 &FreeNumber);
2165 2169
2166 frameNum++; 2170 frameNum++;
2167 2171
@@ -2182,31 +2186,26 @@ VOID STA_ARalink_Frame_Tx(
2182 2186
2183} 2187}
2184 2188
2185 2189VOID STA_Fragment_Frame_Tx(IN RTMP_ADAPTER * pAd, IN TX_BLK * pTxBlk)
2186VOID STA_Fragment_Frame_Tx(
2187 IN RTMP_ADAPTER *pAd,
2188 IN TX_BLK *pTxBlk)
2189{ 2190{
2190 HEADER_802_11 *pHeader_802_11; 2191 HEADER_802_11 *pHeader_802_11;
2191 PUCHAR pHeaderBufPtr; 2192 PUCHAR pHeaderBufPtr;
2192 USHORT FreeNumber; 2193 USHORT FreeNumber;
2193 UCHAR fragNum = 0; 2194 UCHAR fragNum = 0;
2194 PACKET_INFO PacketInfo; 2195 PACKET_INFO PacketInfo;
2195 USHORT EncryptionOverhead = 0; 2196 USHORT EncryptionOverhead = 0;
2196 UINT32 FreeMpduSize, SrcRemainingBytes; 2197 UINT32 FreeMpduSize, SrcRemainingBytes;
2197 USHORT AckDuration; 2198 USHORT AckDuration;
2198 UINT NextMpduSize; 2199 UINT NextMpduSize;
2199 BOOLEAN bVLANPkt; 2200 BOOLEAN bVLANPkt;
2200 PQUEUE_ENTRY pQEntry; 2201 PQUEUE_ENTRY pQEntry;
2201 HTTRANSMIT_SETTING *pTransmit; 2202 HTTRANSMIT_SETTING *pTransmit;
2202
2203 2203
2204 ASSERT(pTxBlk); 2204 ASSERT(pTxBlk);
2205 2205
2206 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList); 2206 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList);
2207 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry); 2207 pTxBlk->pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
2208 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) 2208 if (RTMP_FillTxBlkInfo(pAd, pTxBlk) != TRUE) {
2209 {
2210 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE); 2209 RELEASE_NDIS_PACKET(pAd, pTxBlk->pPacket, NDIS_STATUS_FAILURE);
2211 return; 2210 return;
2212 } 2211 }
@@ -2217,104 +2216,100 @@ VOID STA_Fragment_Frame_Tx(
2217 STAFindCipherAlgorithm(pAd, pTxBlk); 2216 STAFindCipherAlgorithm(pAd, pTxBlk);
2218 STABuildCommon802_11Header(pAd, pTxBlk); 2217 STABuildCommon802_11Header(pAd, pTxBlk);
2219 2218
2220 if (pTxBlk->CipherAlg == CIPHER_TKIP) 2219 if (pTxBlk->CipherAlg == CIPHER_TKIP) {
2221 { 2220 pTxBlk->pPacket =
2222 pTxBlk->pPacket = duplicate_pkt_with_TKIP_MIC(pAd, pTxBlk->pPacket); 2221 duplicate_pkt_with_TKIP_MIC(pAd, pTxBlk->pPacket);
2223 if (pTxBlk->pPacket == NULL) 2222 if (pTxBlk->pPacket == NULL)
2224 return; 2223 return;
2225 RTMP_QueryPacketInfo(pTxBlk->pPacket, &PacketInfo, &pTxBlk->pSrcBufHeader, &pTxBlk->SrcBufLen); 2224 RTMP_QueryPacketInfo(pTxBlk->pPacket, &PacketInfo,
2225 &pTxBlk->pSrcBufHeader,
2226 &pTxBlk->SrcBufLen);
2226 } 2227 }
2227
2228 // skip 802.3 header 2228 // skip 802.3 header
2229 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3; 2229 pTxBlk->pSrcBufData = pTxBlk->pSrcBufHeader + LENGTH_802_3;
2230 pTxBlk->SrcBufLen -= LENGTH_802_3; 2230 pTxBlk->SrcBufLen -= LENGTH_802_3;
2231
2232 2231
2233 // skip vlan tag 2232 // skip vlan tag
2234 if (bVLANPkt) 2233 if (bVLANPkt) {
2235 { 2234 pTxBlk->pSrcBufData += LENGTH_802_1Q;
2236 pTxBlk->pSrcBufData += LENGTH_802_1Q; 2235 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
2237 pTxBlk->SrcBufLen -= LENGTH_802_1Q;
2238 } 2236 }
2239 2237
2240 pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE]; 2238 pHeaderBufPtr = &pTxBlk->HeaderBuf[TXINFO_SIZE + TXWI_SIZE];
2241 pHeader_802_11 = (HEADER_802_11 *)pHeaderBufPtr; 2239 pHeader_802_11 = (HEADER_802_11 *) pHeaderBufPtr;
2242
2243 2240
2244 // skip common header 2241 // skip common header
2245 pHeaderBufPtr += pTxBlk->MpduHeaderLen; 2242 pHeaderBufPtr += pTxBlk->MpduHeaderLen;
2246 2243
2247 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) 2244 if (TX_BLK_TEST_FLAG(pTxBlk, fTX_bWMM)) {
2248 {
2249 // 2245 //
2250 // build QOS Control bytes 2246 // build QOS Control bytes
2251 // 2247 //
2252 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F); 2248 *pHeaderBufPtr = (pTxBlk->UserPriority & 0x0F);
2253 2249
2254 *(pHeaderBufPtr+1) = 0; 2250 *(pHeaderBufPtr + 1) = 0;
2255 pHeaderBufPtr +=2; 2251 pHeaderBufPtr += 2;
2256 pTxBlk->MpduHeaderLen += 2; 2252 pTxBlk->MpduHeaderLen += 2;
2257 } 2253 }
2258
2259 // 2254 //
2260 // padding at front of LLC header 2255 // padding at front of LLC header
2261 // LLC header should locate at 4-octets aligment 2256 // LLC header should locate at 4-octets aligment
2262 // 2257 //
2263 pTxBlk->HdrPadLen = (ULONG)pHeaderBufPtr; 2258 pTxBlk->HdrPadLen = (ULONG) pHeaderBufPtr;
2264 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4); 2259 pHeaderBufPtr = (PUCHAR) ROUND_UP(pHeaderBufPtr, 4);
2265 pTxBlk->HdrPadLen = (ULONG)(pHeaderBufPtr - pTxBlk->HdrPadLen); 2260 pTxBlk->HdrPadLen = (ULONG) (pHeaderBufPtr - pTxBlk->HdrPadLen);
2266
2267
2268 2261
2269 // 2262 //
2270 // Insert LLC-SNAP encapsulation - 8 octets 2263 // Insert LLC-SNAP encapsulation - 8 octets
2271 // 2264 //
2272 // 2265 //
2273 // if original Ethernet frame contains no LLC/SNAP, 2266 // if original Ethernet frame contains no LLC/SNAP,
2274 // then an extra LLC/SNAP encap is required 2267 // then an extra LLC/SNAP encap is required
2275 // 2268 //
2276 EXTRA_LLCSNAP_ENCAP_FROM_PKT_START(pTxBlk->pSrcBufHeader, pTxBlk->pExtraLlcSnapEncap); 2269 EXTRA_LLCSNAP_ENCAP_FROM_PKT_START(pTxBlk->pSrcBufHeader,
2277 if (pTxBlk->pExtraLlcSnapEncap) 2270 pTxBlk->pExtraLlcSnapEncap);
2278 { 2271 if (pTxBlk->pExtraLlcSnapEncap) {
2279 UCHAR vlan_size; 2272 UCHAR vlan_size;
2280 2273
2281 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6); 2274 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pExtraLlcSnapEncap, 6);
2282 pHeaderBufPtr += 6; 2275 pHeaderBufPtr += 6;
2283 // skip vlan tag 2276 // skip vlan tag
2284 vlan_size = (bVLANPkt) ? LENGTH_802_1Q : 0; 2277 vlan_size = (bVLANPkt) ? LENGTH_802_1Q : 0;
2285 // get 2 octets (TypeofLen) 2278 // get 2 octets (TypeofLen)
2286 NdisMoveMemory(pHeaderBufPtr, pTxBlk->pSrcBufHeader+12+vlan_size, 2); 2279 NdisMoveMemory(pHeaderBufPtr,
2280 pTxBlk->pSrcBufHeader + 12 + vlan_size, 2);
2287 pHeaderBufPtr += 2; 2281 pHeaderBufPtr += 2;
2288 pTxBlk->MpduHeaderLen += LENGTH_802_1_H; 2282 pTxBlk->MpduHeaderLen += LENGTH_802_1_H;
2289 } 2283 }
2290 2284
2291
2292 // If TKIP is used and fragmentation is required. Driver has to 2285 // If TKIP is used and fragmentation is required. Driver has to
2293 // append TKIP MIC at tail of the scatter buffer 2286 // append TKIP MIC at tail of the scatter buffer
2294 // MAC ASIC will only perform IV/EIV/ICV insertion but no TKIP MIC 2287 // MAC ASIC will only perform IV/EIV/ICV insertion but no TKIP MIC
2295 if (pTxBlk->CipherAlg == CIPHER_TKIP) 2288 if (pTxBlk->CipherAlg == CIPHER_TKIP) {
2296 { 2289 RTMPCalculateMICValue(pAd, pTxBlk->pPacket,
2297 RTMPCalculateMICValue(pAd, pTxBlk->pPacket, pTxBlk->pExtraLlcSnapEncap, pTxBlk->pKey, 0); 2290 pTxBlk->pExtraLlcSnapEncap, pTxBlk->pKey,
2291 0);
2298 2292
2299 // NOTE: DON'T refer the skb->len directly after following copy. Becasue the length is not adjust 2293 // NOTE: DON'T refer the skb->len directly after following copy. Becasue the length is not adjust
2300 // to correct lenght, refer to pTxBlk->SrcBufLen for the packet length in following progress. 2294 // to correct lenght, refer to pTxBlk->SrcBufLen for the packet length in following progress.
2301 NdisMoveMemory(pTxBlk->pSrcBufData + pTxBlk->SrcBufLen, &pAd->PrivateInfo.Tx.MIC[0], 8); 2295 NdisMoveMemory(pTxBlk->pSrcBufData + pTxBlk->SrcBufLen,
2296 &pAd->PrivateInfo.Tx.MIC[0], 8);
2302 //skb_put((RTPKT_TO_OSPKT(pTxBlk->pPacket))->tail, 8); 2297 //skb_put((RTPKT_TO_OSPKT(pTxBlk->pPacket))->tail, 8);
2303 pTxBlk->SrcBufLen += 8; 2298 pTxBlk->SrcBufLen += 8;
2304 pTxBlk->TotalFrameLen += 8; 2299 pTxBlk->TotalFrameLen += 8;
2305 pTxBlk->CipherAlg = CIPHER_TKIP_NO_MIC; 2300 pTxBlk->CipherAlg = CIPHER_TKIP_NO_MIC;
2306 } 2301 }
2307
2308 // 2302 //
2309 // calcuate the overhead bytes that encryption algorithm may add. This 2303 // calcuate the overhead bytes that encryption algorithm may add. This
2310 // affects the calculate of "duration" field 2304 // affects the calculate of "duration" field
2311 // 2305 //
2312 if ((pTxBlk->CipherAlg == CIPHER_WEP64) || (pTxBlk->CipherAlg == CIPHER_WEP128)) 2306 if ((pTxBlk->CipherAlg == CIPHER_WEP64)
2313 EncryptionOverhead = 8; //WEP: IV[4] + ICV[4]; 2307 || (pTxBlk->CipherAlg == CIPHER_WEP128))
2308 EncryptionOverhead = 8; //WEP: IV[4] + ICV[4];
2314 else if (pTxBlk->CipherAlg == CIPHER_TKIP_NO_MIC) 2309 else if (pTxBlk->CipherAlg == CIPHER_TKIP_NO_MIC)
2315 EncryptionOverhead = 12;//TKIP: IV[4] + EIV[4] + ICV[4], MIC will be added to TotalPacketLength 2310 EncryptionOverhead = 12; //TKIP: IV[4] + EIV[4] + ICV[4], MIC will be added to TotalPacketLength
2316 else if (pTxBlk->CipherAlg == CIPHER_TKIP) 2311 else if (pTxBlk->CipherAlg == CIPHER_TKIP)
2317 EncryptionOverhead = 20;//TKIP: IV[4] + EIV[4] + ICV[4] + MIC[8] 2312 EncryptionOverhead = 20; //TKIP: IV[4] + EIV[4] + ICV[4] + MIC[8]
2318 else if (pTxBlk->CipherAlg == CIPHER_AES) 2313 else if (pTxBlk->CipherAlg == CIPHER_AES)
2319 EncryptionOverhead = 16; // AES: IV[4] + EIV[4] + MIC[8] 2314 EncryptionOverhead = 16; // AES: IV[4] + EIV[4] + MIC[8]
2320 else 2315 else
@@ -2331,7 +2326,11 @@ VOID STA_Fragment_Frame_Tx(
2331 2326
2332 // decide how much time an ACK/CTS frame will consume in the air 2327 // decide how much time an ACK/CTS frame will consume in the air
2333 if (pTxBlk->TxRate <= RATE_LAST_OFDM_RATE) 2328 if (pTxBlk->TxRate <= RATE_LAST_OFDM_RATE)
2334 AckDuration = RTMPCalcDuration(pAd, pAd->CommonCfg.ExpectedACKRate[pTxBlk->TxRate], 14); 2329 AckDuration =
2330 RTMPCalcDuration(pAd,
2331 pAd->CommonCfg.ExpectedACKRate[pTxBlk->
2332 TxRate],
2333 14);
2335 else 2334 else
2336 AckDuration = RTMPCalcDuration(pAd, RATE_6_5, 14); 2335 AckDuration = RTMPCalcDuration(pAd, RATE_6_5, 14);
2337 2336
@@ -2346,25 +2345,28 @@ VOID STA_Fragment_Frame_Tx(
2346 2345
2347 FreeMpduSize -= pTxBlk->MpduHeaderLen; 2346 FreeMpduSize -= pTxBlk->MpduHeaderLen;
2348 2347
2349 if (SrcRemainingBytes <= FreeMpduSize) 2348 if (SrcRemainingBytes <= FreeMpduSize) { // this is the last or only fragment
2350 { // this is the last or only fragment
2351 2349
2352 pTxBlk->SrcBufLen = SrcRemainingBytes; 2350 pTxBlk->SrcBufLen = SrcRemainingBytes;
2353 2351
2354 pHeader_802_11->FC.MoreFrag = 0; 2352 pHeader_802_11->FC.MoreFrag = 0;
2355 pHeader_802_11->Duration = pAd->CommonCfg.Dsifs + AckDuration; 2353 pHeader_802_11->Duration =
2354 pAd->CommonCfg.Dsifs + AckDuration;
2356 2355
2357 // Indicate the lower layer that this's the last fragment. 2356 // Indicate the lower layer that this's the last fragment.
2358 pTxBlk->TotalFragNum = fragNum; 2357 pTxBlk->TotalFragNum = fragNum;
2359 } 2358 } else { // more fragment is required
2360 else
2361 { // more fragment is required
2362 2359
2363 pTxBlk->SrcBufLen = FreeMpduSize; 2360 pTxBlk->SrcBufLen = FreeMpduSize;
2364 2361
2365 NextMpduSize = min(((UINT)SrcRemainingBytes - pTxBlk->SrcBufLen), ((UINT)pAd->CommonCfg.FragmentThreshold)); 2362 NextMpduSize =
2363 min(((UINT) SrcRemainingBytes - pTxBlk->SrcBufLen),
2364 ((UINT) pAd->CommonCfg.FragmentThreshold));
2366 pHeader_802_11->FC.MoreFrag = 1; 2365 pHeader_802_11->FC.MoreFrag = 1;
2367 pHeader_802_11->Duration = (3 * pAd->CommonCfg.Dsifs) + (2 * AckDuration) + RTMPCalcDuration(pAd, pTxBlk->TxRate, NextMpduSize + EncryptionOverhead); 2366 pHeader_802_11->Duration =
2367 (3 * pAd->CommonCfg.Dsifs) + (2 * AckDuration) +
2368 RTMPCalcDuration(pAd, pTxBlk->TxRate,
2369 NextMpduSize + EncryptionOverhead);
2368 } 2370 }
2369 2371
2370 if (fragNum == 0) 2372 if (fragNum == 0)
@@ -2372,7 +2374,10 @@ VOID STA_Fragment_Frame_Tx(
2372 else 2374 else
2373 pTxBlk->FrameGap = IFS_SIFS; 2375 pTxBlk->FrameGap = IFS_SIFS;
2374 2376
2375 RTMPWriteTxWI_Data(pAd, (PTXWI_STRUC)(&pTxBlk->HeaderBuf[TXINFO_SIZE]), pTxBlk); 2377 RTMPWriteTxWI_Data(pAd,
2378 (PTXWI_STRUC) (&pTxBlk->
2379 HeaderBuf[TXINFO_SIZE]),
2380 pTxBlk);
2376 2381
2377 HAL_WriteFragTxResource(pAd, pTxBlk, fragNum, &FreeNumber); 2382 HAL_WriteFragTxResource(pAd, pTxBlk, fragNum, &FreeNumber);
2378 2383
@@ -2389,18 +2394,17 @@ VOID STA_Fragment_Frame_Tx(
2389 SrcRemainingBytes -= pTxBlk->SrcBufLen; 2394 SrcRemainingBytes -= pTxBlk->SrcBufLen;
2390 pTxBlk->pSrcBufData += pTxBlk->SrcBufLen; 2395 pTxBlk->pSrcBufData += pTxBlk->SrcBufLen;
2391 2396
2392 pHeader_802_11->Frag++; // increase Frag # 2397 pHeader_802_11->Frag++; // increase Frag #
2393 2398
2394 }while(SrcRemainingBytes > 0); 2399 } while (SrcRemainingBytes > 0);
2395 2400
2396 // 2401 //
2397 // Kick out Tx 2402 // Kick out Tx
2398 // 2403 //
2399 if (!RTMP_TEST_PSFLAG(pAd, fRTMP_PS_DISABLE_TX)) 2404 if (!RTMP_TEST_PSFLAG(pAd, fRTMP_PS_DISABLE_TX))
2400 HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx); 2405 HAL_KickOutTx(pAd, pTxBlk, pTxBlk->QueIdx);
2401} 2406}
2402 2407
2403
2404#define RELEASE_FRAMES_OF_TXBLK(_pAd, _pTxBlk, _pQEntry, _Status) \ 2408#define RELEASE_FRAMES_OF_TXBLK(_pAd, _pTxBlk, _pQEntry, _Status) \
2405 while(_pTxBlk->TxPacketList.Head) \ 2409 while(_pTxBlk->TxPacketList.Head) \
2406 { \ 2410 { \
@@ -2408,7 +2412,6 @@ VOID STA_Fragment_Frame_Tx(
2408 RELEASE_NDIS_PACKET(_pAd, QUEUE_ENTRY_TO_PACKET(_pQEntry), _Status); \ 2412 RELEASE_NDIS_PACKET(_pAd, QUEUE_ENTRY_TO_PACKET(_pQEntry), _Status); \
2409 } 2413 }
2410 2414
2411
2412/* 2415/*
2413 ======================================================================== 2416 ========================================================================
2414 2417
@@ -2431,22 +2434,21 @@ VOID STA_Fragment_Frame_Tx(
2431 2434
2432 ======================================================================== 2435 ========================================================================
2433*/ 2436*/
2434NDIS_STATUS STAHardTransmit( 2437NDIS_STATUS STAHardTransmit(IN PRTMP_ADAPTER pAd,
2435 IN PRTMP_ADAPTER pAd, 2438 IN TX_BLK * pTxBlk, IN UCHAR QueIdx)
2436 IN TX_BLK *pTxBlk,
2437 IN UCHAR QueIdx)
2438{ 2439{
2439 NDIS_PACKET *pPacket; 2440 NDIS_PACKET *pPacket;
2440 PQUEUE_ENTRY pQEntry; 2441 PQUEUE_ENTRY pQEntry;
2441 2442
2442 // --------------------------------------------- 2443 // ---------------------------------------------
2443 // STEP 0. DO SANITY CHECK AND SOME EARLY PREPARATION. 2444 // STEP 0. DO SANITY CHECK AND SOME EARLY PREPARATION.
2444 // --------------------------------------------- 2445 // ---------------------------------------------
2445 // 2446 //
2446 ASSERT(pTxBlk->TxPacketList.Number); 2447 ASSERT(pTxBlk->TxPacketList.Number);
2447 if (pTxBlk->TxPacketList.Head == NULL) 2448 if (pTxBlk->TxPacketList.Head == NULL) {
2448 { 2449 DBGPRINT(RT_DEBUG_ERROR,
2449 DBGPRINT(RT_DEBUG_ERROR, ("pTxBlk->TotalFrameNum == %ld!\n", pTxBlk->TxPacketList.Number)); 2450 ("pTxBlk->TotalFrameNum == %ld!\n",
2451 pTxBlk->TxPacketList.Number));
2450 return NDIS_STATUS_FAILURE; 2452 return NDIS_STATUS_FAILURE;
2451 } 2453 }
2452 2454
@@ -2454,13 +2456,13 @@ NDIS_STATUS STAHardTransmit(
2454 2456
2455 // ------------------------------------------------------------------ 2457 // ------------------------------------------------------------------
2456 // STEP 1. WAKE UP PHY 2458 // STEP 1. WAKE UP PHY
2457 // outgoing frame always wakeup PHY to prevent frame lost and 2459 // outgoing frame always wakeup PHY to prevent frame lost and
2458 // turn off PSM bit to improve performance 2460 // turn off PSM bit to improve performance
2459 // ------------------------------------------------------------------ 2461 // ------------------------------------------------------------------
2460 // not to change PSM bit, just send this frame out? 2462 // not to change PSM bit, just send this frame out?
2461 if ((pAd->StaCfg.Psm == PWR_SAVE) && OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)) 2463 if ((pAd->StaCfg.Psm == PWR_SAVE)
2462 { 2464 && OPSTATUS_TEST_FLAG(pAd, fOP_STATUS_DOZE)) {
2463 DBGPRINT_RAW(RT_DEBUG_INFO, ("AsicForceWakeup At HardTx\n")); 2465 DBGPRINT_RAW(RT_DEBUG_INFO, ("AsicForceWakeup At HardTx\n"));
2464#ifdef RTMP_MAC_PCI 2466#ifdef RTMP_MAC_PCI
2465 AsicForceWakeup(pAd, TRUE); 2467 AsicForceWakeup(pAd, TRUE);
2466#endif // RTMP_MAC_PCI // 2468#endif // RTMP_MAC_PCI //
@@ -2468,85 +2470,81 @@ NDIS_STATUS STAHardTransmit(
2468 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_FORCE_WAKE_UP, NULL, 0); 2470 RTUSBEnqueueInternalCmd(pAd, CMDTHREAD_FORCE_WAKE_UP, NULL, 0);
2469#endif // RTMP_MAC_USB // 2471#endif // RTMP_MAC_USB //
2470 } 2472 }
2471
2472 // It should not change PSM bit, when APSD turn on. 2473 // It should not change PSM bit, when APSD turn on.
2473 if ((!(pAd->CommonCfg.bAPSDCapable && pAd->CommonCfg.APEdcaParm.bAPSDCapable) && (pAd->CommonCfg.bAPSDForcePowerSave == FALSE)) 2474 if ((!
2474 || (RTMP_GET_PACKET_EAPOL(pTxBlk->pPacket)) 2475 (pAd->CommonCfg.bAPSDCapable
2475 || (RTMP_GET_PACKET_WAI(pTxBlk->pPacket))) 2476 && pAd->CommonCfg.APEdcaParm.bAPSDCapable)
2476 { 2477 && (pAd->CommonCfg.bAPSDForcePowerSave == FALSE))
2478 || (RTMP_GET_PACKET_EAPOL(pTxBlk->pPacket))
2479 || (RTMP_GET_PACKET_WAI(pTxBlk->pPacket))) {
2477 if ((pAd->StaCfg.Psm == PWR_SAVE) && 2480 if ((pAd->StaCfg.Psm == PWR_SAVE) &&
2478 (pAd->StaCfg.WindowsPowerMode == Ndis802_11PowerModeFast_PSP)) 2481 (pAd->StaCfg.WindowsPowerMode ==
2482 Ndis802_11PowerModeFast_PSP))
2479 RTMP_SET_PSM_BIT(pAd, PWR_ACTIVE); 2483 RTMP_SET_PSM_BIT(pAd, PWR_ACTIVE);
2480 } 2484 }
2481 2485
2482 switch (pTxBlk->TxFrameType) 2486 switch (pTxBlk->TxFrameType) {
2483 { 2487 case TX_AMPDU_FRAME:
2484 case TX_AMPDU_FRAME: 2488 STA_AMPDU_Frame_Tx(pAd, pTxBlk);
2485 STA_AMPDU_Frame_Tx(pAd, pTxBlk); 2489 break;
2486 break; 2490 case TX_AMSDU_FRAME:
2487 case TX_AMSDU_FRAME: 2491 STA_AMSDU_Frame_Tx(pAd, pTxBlk);
2488 STA_AMSDU_Frame_Tx(pAd, pTxBlk); 2492 break;
2489 break; 2493 case TX_LEGACY_FRAME:
2490 case TX_LEGACY_FRAME: 2494 STA_Legacy_Frame_Tx(pAd, pTxBlk);
2491 STA_Legacy_Frame_Tx(pAd, pTxBlk); 2495 break;
2492 break; 2496 case TX_MCAST_FRAME:
2493 case TX_MCAST_FRAME: 2497 STA_Legacy_Frame_Tx(pAd, pTxBlk);
2494 STA_Legacy_Frame_Tx(pAd, pTxBlk); 2498 break;
2495 break; 2499 case TX_RALINK_FRAME:
2496 case TX_RALINK_FRAME: 2500 STA_ARalink_Frame_Tx(pAd, pTxBlk);
2497 STA_ARalink_Frame_Tx(pAd, pTxBlk); 2501 break;
2498 break; 2502 case TX_FRAG_FRAME:
2499 case TX_FRAG_FRAME: 2503 STA_Fragment_Frame_Tx(pAd, pTxBlk);
2500 STA_Fragment_Frame_Tx(pAd, pTxBlk); 2504 break;
2501 break; 2505 default:
2502 default: 2506 {
2503 { 2507 // It should not happened!
2504 // It should not happened! 2508 DBGPRINT(RT_DEBUG_ERROR,
2505 DBGPRINT(RT_DEBUG_ERROR, ("Send a pacekt was not classified!! It should not happen!\n")); 2509 ("Send a pacekt was not classified!! It should not happen!\n"));
2506 while(pTxBlk->TxPacketList.Number) 2510 while (pTxBlk->TxPacketList.Number) {
2507 { 2511 pQEntry =
2508 pQEntry = RemoveHeadQueue(&pTxBlk->TxPacketList); 2512 RemoveHeadQueue(&pTxBlk->TxPacketList);
2509 pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry); 2513 pPacket = QUEUE_ENTRY_TO_PACKET(pQEntry);
2510 if (pPacket) 2514 if (pPacket)
2511 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE); 2515 RELEASE_NDIS_PACKET(pAd, pPacket,
2512 } 2516 NDIS_STATUS_FAILURE);
2513 } 2517 }
2514 break; 2518 }
2519 break;
2515 } 2520 }
2516 2521
2517 return (NDIS_STATUS_SUCCESS); 2522 return (NDIS_STATUS_SUCCESS);
2518 2523
2519} 2524}
2520 2525
2521ULONG HashBytesPolynomial(UCHAR *value, unsigned int len) 2526ULONG HashBytesPolynomial(UCHAR * value, unsigned int len)
2522{ 2527{
2523 unsigned char *word = value; 2528 unsigned char *word = value;
2524 unsigned int ret = 0; 2529 unsigned int ret = 0;
2525 unsigned int i; 2530 unsigned int i;
2526 2531
2527 for(i=0; i < len; i++) 2532 for (i = 0; i < len; i++) {
2528 { 2533 int mod = i % 32;
2529 int mod = i % 32; 2534 ret ^= (unsigned int)(word[i]) << mod;
2530 ret ^=(unsigned int) (word[i]) << mod; 2535 ret ^= (unsigned int)(word[i]) >> (32 - mod);
2531 ret ^=(unsigned int) (word[i]) >> (32 - mod); 2536 }
2532 } 2537 return ret;
2533 return ret;
2534} 2538}
2535 2539
2536VOID Sta_Announce_or_Forward_802_3_Packet( 2540VOID Sta_Announce_or_Forward_802_3_Packet(IN PRTMP_ADAPTER pAd,
2537 IN PRTMP_ADAPTER pAd, 2541 IN PNDIS_PACKET pPacket,
2538 IN PNDIS_PACKET pPacket, 2542 IN UCHAR FromWhichBSSID)
2539 IN UCHAR FromWhichBSSID)
2540{ 2543{
2541 if (TRUE 2544 if (TRUE) {
2542 )
2543 {
2544 announce_802_3_packet(pAd, pPacket); 2545 announce_802_3_packet(pAd, pPacket);
2545 } 2546 } else {
2546 else
2547 {
2548 // release packet 2547 // release packet
2549 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE); 2548 RELEASE_NDIS_PACKET(pAd, pPacket, NDIS_STATUS_FAILURE);
2550 } 2549 }
2551} 2550}
2552
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-21 06:47:00 -0400