projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
drivers: power: report battery voltage in AOSP compatible format
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / vt6656 / rxtx.c
1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * File: rxtx.c
20 *
21 * Purpose: handle WMAC/802.3/802.11 rx & tx functions
22 *
23 * Author: Lyndon Chen
24 *
25 * Date: May 20, 2003
26 *
27 * Functions:
28 * s_vGenerateTxParameter - Generate tx dma required parameter.
29 * s_vGenerateMACHeader - Translate 802.3 to 802.11 header
30 * csBeacon_xmit - beacon tx function
31 * csMgmt_xmit - management tx function
32 * s_uGetDataDuration - get tx data required duration
33 * s_uFillDataHead- fulfill tx data duration header
34 * s_uGetRTSCTSDuration- get rtx/cts required duration
35 * s_uGetRTSCTSRsvTime- get rts/cts reserved time
36 * s_uGetTxRsvTime- get frame reserved time
37 * s_vFillCTSHead- fulfill CTS ctl header
38 * s_vFillFragParameter- Set fragment ctl parameter.
39 * s_vFillRTSHead- fulfill RTS ctl header
40 * s_vFillTxKey- fulfill tx encrypt key
41 * s_vSWencryption- Software encrypt header
42 * vDMA0_tx_80211- tx 802.11 frame via dma0
43 * vGenerateFIFOHeader- Generate tx FIFO ctl header
44 *
45 * Revision History:
46 *
47 */
48
49 #include "device.h"
50 #include "rxtx.h"
51 #include "tether.h"
52 #include "card.h"
53 #include "bssdb.h"
54 #include "mac.h"
55 #include "baseband.h"
56 #include "michael.h"
57 #include "tkip.h"
58 #include "tcrc.h"
59 #include "wctl.h"
60 #include "hostap.h"
61 #include "rf.h"
62 #include "datarate.h"
63 #include "usbpipe.h"
64 #include "iocmd.h"
65
66 static int msglevel = MSG_LEVEL_INFO;
67
68 const u16 wTimeStampOff[2][MAX_RATE] = {
69 {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, // Long Preamble
70 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, // Short Preamble
71 };
72
73 const u16 wFB_Opt0[2][5] = {
74 {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, // fallback_rate0
75 {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, // fallback_rate1
76 };
77 const u16 wFB_Opt1[2][5] = {
78 {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, // fallback_rate0
79 {RATE_6M , RATE_6M, RATE_12M, RATE_12M, RATE_18M}, // fallback_rate1
80 };
81
82 #define RTSDUR_BB 0
83 #define RTSDUR_BA 1
84 #define RTSDUR_AA 2
85 #define CTSDUR_BA 3
86 #define RTSDUR_BA_F0 4
87 #define RTSDUR_AA_F0 5
88 #define RTSDUR_BA_F1 6
89 #define RTSDUR_AA_F1 7
90 #define CTSDUR_BA_F0 8
91 #define CTSDUR_BA_F1 9
92 #define DATADUR_B 10
93 #define DATADUR_A 11
94 #define DATADUR_A_F0 12
95 #define DATADUR_A_F1 13
96
97 static void s_vSaveTxPktInfo(struct vnt_private *pDevice, u8 byPktNum,
98 u8 *pbyDestAddr, u16 wPktLength, u16 wFIFOCtl);
99
100 static void *s_vGetFreeContext(struct vnt_private *pDevice);
101
102 static void s_vGenerateTxParameter(struct vnt_private *pDevice,
103 u8 byPktType, u16 wCurrentRate, void *pTxBufHead, void *pvRrvTime,
104 void *pvRTS, void *pvCTS, u32 cbFrameSize, int bNeedACK, u32 uDMAIdx,
105 struct ethhdr *psEthHeader);
106
107 static u32 s_uFillDataHead(struct vnt_private *pDevice,
108 u8 byPktType, u16 wCurrentRate, void *pTxDataHead, u32 cbFrameLength,
109 u32 uDMAIdx, int bNeedAck, u32 uFragIdx, u32 cbLastFragmentSize,
110 u32 uMACfragNum, u8 byFBOption);
111
112 static void s_vGenerateMACHeader(struct vnt_private *pDevice,
113 u8 *pbyBufferAddr, u16 wDuration, struct ethhdr *psEthHeader,
114 int bNeedEncrypt, u16 wFragType, u32 uDMAIdx, u32 uFragIdx);
115
116 static void s_vFillTxKey(struct vnt_private *pDevice, u8 *pbyBuf,
117 u8 *pbyIVHead, PSKeyItem pTransmitKey, u8 *pbyHdrBuf, u16 wPayloadLen,
118 u8 *pMICHDR);
119
120 static void s_vSWencryption(struct vnt_private *pDevice,
121 PSKeyItem pTransmitKey, u8 *pbyPayloadHead, u16 wPayloadSize);
122
123 static unsigned int s_uGetTxRsvTime(struct vnt_private *pDevice, u8 byPktType,
124 u32 cbFrameLength, u16 wRate, int bNeedAck);
125
126 static u32 s_uGetRTSCTSRsvTime(struct vnt_private *pDevice, u8 byRTSRsvType,
127 u8 byPktType, u32 cbFrameLength, u16 wCurrentRate);
128
129 static void s_vFillCTSHead(struct vnt_private *pDevice, u32 uDMAIdx,
130 u8 byPktType, void *pvCTS, u32 cbFrameLength, int bNeedAck,
131 int bDisCRC, u16 wCurrentRate, u8 byFBOption);
132
133 static void s_vFillRTSHead(struct vnt_private *pDevice, u8 byPktType,
134 void *pvRTS, u32 cbFrameLength, int bNeedAck, int bDisCRC,
135 struct ethhdr *psEthHeader, u16 wCurrentRate, u8 byFBOption);
136
137 static u32 s_uGetDataDuration(struct vnt_private *pDevice, u8 byDurType,
138 u32 cbFrameLength, u8 byPktType, u16 wRate, int bNeedAck,
139 u32 uFragIdx, u32 cbLastFragmentSize, u32 uMACfragNum,
140 u8 byFBOption);
141
142 static unsigned int s_uGetRTSCTSDuration(struct vnt_private *pDevice,
143 u8 byDurType, u32 cbFrameLength, u8 byPktType, u16 wRate,
144 int bNeedAck, u8 byFBOption);
145
146 static void *s_vGetFreeContext(struct vnt_private *pDevice)
147 {
148 PUSB_SEND_CONTEXT pContext = NULL;
149 PUSB_SEND_CONTEXT pReturnContext = NULL;
150 int ii;
151
152 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"GetFreeContext()\n");
153
154 for (ii = 0; ii < pDevice->cbTD; ii++) {
155 pContext = pDevice->apTD[ii];
156 if (pContext->bBoolInUse == false) {
157 pContext->bBoolInUse = true;
158 pReturnContext = pContext;
159 break;
160 }
161 }
162 if ( ii == pDevice->cbTD ) {
163 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Free Tx Context\n");
164 }
165 return (void *) pReturnContext;
166 }
167
168 static void s_vSaveTxPktInfo(struct vnt_private *pDevice, u8 byPktNum,
169 u8 *pbyDestAddr, u16 wPktLength, u16 wFIFOCtl)
170 {
171 PSStatCounter pStatistic = &pDevice->scStatistic;
172
173 if (is_broadcast_ether_addr(pbyDestAddr))
174 pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_BROAD;
175 else if (is_multicast_ether_addr(pbyDestAddr))
176 pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_MULTI;
177 else
178 pStatistic->abyTxPktInfo[byPktNum].byBroadMultiUni = TX_PKT_UNI;
179
180 pStatistic->abyTxPktInfo[byPktNum].wLength = wPktLength;
181 pStatistic->abyTxPktInfo[byPktNum].wFIFOCtl = wFIFOCtl;
182 memcpy(pStatistic->abyTxPktInfo[byPktNum].abyDestAddr,
183 pbyDestAddr,
184 ETH_ALEN);
185 }
186
187 static void s_vFillTxKey(struct vnt_private *pDevice, u8 *pbyBuf,
188 u8 *pbyIVHead, PSKeyItem pTransmitKey, u8 *pbyHdrBuf,
189 u16 wPayloadLen, u8 *pMICHDR)
190 {
191 u32 *pdwIV = (u32 *)pbyIVHead;
192 u32 *pdwExtIV = (u32 *)((u8 *)pbyIVHead + 4);
193 u16 wValue;
194 struct ieee80211_hdr *pMACHeader = (struct ieee80211_hdr *)pbyHdrBuf;
195 u32 dwRevIVCounter;
196
197 //Fill TXKEY
198 if (pTransmitKey == NULL)
199 return;
200
201 dwRevIVCounter = cpu_to_le32(pDevice->dwIVCounter);
202 *pdwIV = pDevice->dwIVCounter;
203 pDevice->byKeyIndex = pTransmitKey->dwKeyIndex & 0xf;
204
205 if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
206 if (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN ){
207 memcpy(pDevice->abyPRNG, (u8 *)&(dwRevIVCounter), 3);
208 memcpy(pDevice->abyPRNG+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
209 } else {
210 memcpy(pbyBuf, (u8 *)&(dwRevIVCounter), 3);
211 memcpy(pbyBuf+3, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
212 if(pTransmitKey->uKeyLength == WLAN_WEP40_KEYLEN) {
213 memcpy(pbyBuf+8, (u8 *)&(dwRevIVCounter), 3);
214 memcpy(pbyBuf+11, pTransmitKey->abyKey, pTransmitKey->uKeyLength);
215 }
216 memcpy(pDevice->abyPRNG, pbyBuf, 16);
217 }
218 // Append IV after Mac Header
219 *pdwIV &= WEP_IV_MASK;//00000000 11111111 11111111 11111111
220 *pdwIV |= (u32)pDevice->byKeyIndex << 30;
221 *pdwIV = cpu_to_le32(*pdwIV);
222 pDevice->dwIVCounter++;
223 if (pDevice->dwIVCounter > WEP_IV_MASK) {
224 pDevice->dwIVCounter = 0;
225 }
226 } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
227 pTransmitKey->wTSC15_0++;
228 if (pTransmitKey->wTSC15_0 == 0) {
229 pTransmitKey->dwTSC47_16++;
230 }
231 TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
232 pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
233 memcpy(pbyBuf, pDevice->abyPRNG, 16);
234 // Make IV
235 memcpy(pdwIV, pDevice->abyPRNG, 3);
236
237 *(pbyIVHead+3) = (u8)(((pDevice->byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV
238 // Append IV&ExtIV after Mac Header
239 *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
240 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vFillTxKey()---- pdwExtIV: %x\n",
241 *pdwExtIV);
242
243 } else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
244 pTransmitKey->wTSC15_0++;
245 if (pTransmitKey->wTSC15_0 == 0) {
246 pTransmitKey->dwTSC47_16++;
247 }
248 memcpy(pbyBuf, pTransmitKey->abyKey, 16);
249
250 // Make IV
251 *pdwIV = 0;
252 *(pbyIVHead+3) = (u8)(((pDevice->byKeyIndex << 6) & 0xc0) | 0x20); // 0x20 is ExtIV
253 *pdwIV |= cpu_to_le16((u16)(pTransmitKey->wTSC15_0));
254 //Append IV&ExtIV after Mac Header
255 *pdwExtIV = cpu_to_le32(pTransmitKey->dwTSC47_16);
256
257 //Fill MICHDR0
258 *pMICHDR = 0x59;
259 *((u8 *)(pMICHDR+1)) = 0; // TxPriority
260 memcpy(pMICHDR+2, &(pMACHeader->addr2[0]), 6);
261 *((u8 *)(pMICHDR+8)) = HIBYTE(HIWORD(pTransmitKey->dwTSC47_16));
262 *((u8 *)(pMICHDR+9)) = LOBYTE(HIWORD(pTransmitKey->dwTSC47_16));
263 *((u8 *)(pMICHDR+10)) = HIBYTE(LOWORD(pTransmitKey->dwTSC47_16));
264 *((u8 *)(pMICHDR+11)) = LOBYTE(LOWORD(pTransmitKey->dwTSC47_16));
265 *((u8 *)(pMICHDR+12)) = HIBYTE(pTransmitKey->wTSC15_0);
266 *((u8 *)(pMICHDR+13)) = LOBYTE(pTransmitKey->wTSC15_0);
267 *((u8 *)(pMICHDR+14)) = HIBYTE(wPayloadLen);
268 *((u8 *)(pMICHDR+15)) = LOBYTE(wPayloadLen);
269
270 //Fill MICHDR1
271 *((u8 *)(pMICHDR+16)) = 0; // HLEN[15:8]
272 if (pDevice->bLongHeader) {
273 *((u8 *)(pMICHDR+17)) = 28; // HLEN[7:0]
274 } else {
275 *((u8 *)(pMICHDR+17)) = 22; // HLEN[7:0]
276 }
277 wValue = cpu_to_le16(pMACHeader->frame_control & 0xC78F);
278 memcpy(pMICHDR+18, (u8 *)&wValue, 2); // MSKFRACTL
279 memcpy(pMICHDR+20, &(pMACHeader->addr1[0]), 6);
280 memcpy(pMICHDR+26, &(pMACHeader->addr2[0]), 6);
281
282 //Fill MICHDR2
283 memcpy(pMICHDR+32, &(pMACHeader->addr3[0]), 6);
284 wValue = pMACHeader->seq_ctrl;
285 wValue &= 0x000F;
286 wValue = cpu_to_le16(wValue);
287 memcpy(pMICHDR+38, (u8 *)&wValue, 2); // MSKSEQCTL
288 if (pDevice->bLongHeader) {
289 memcpy(pMICHDR+40, &(pMACHeader->addr4[0]), 6);
290 }
291 }
292 }
293
294 static void s_vSWencryption(struct vnt_private *pDevice,
295 PSKeyItem pTransmitKey, u8 *pbyPayloadHead, u16 wPayloadSize)
296 {
297 u32 cbICVlen = 4;
298 u32 dwICV = 0xffffffff;
299 u32 *pdwICV;
300
301 if (pTransmitKey == NULL)
302 return;
303
304 if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
305 //=======================================================================
306 // Append ICV after payload
307 dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
308 pdwICV = (u32 *)(pbyPayloadHead + wPayloadSize);
309 // finally, we must invert dwCRC to get the correct answer
310 *pdwICV = cpu_to_le32(~dwICV);
311 // RC4 encryption
312 rc4_init(&pDevice->SBox, pDevice->abyPRNG, pTransmitKey->uKeyLength + 3);
313 rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
314 //=======================================================================
315 } else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
316 //=======================================================================
317 //Append ICV after payload
318 dwICV = CRCdwGetCrc32Ex(pbyPayloadHead, wPayloadSize, dwICV);//ICV(Payload)
319 pdwICV = (u32 *)(pbyPayloadHead + wPayloadSize);
320 // finally, we must invert dwCRC to get the correct answer
321 *pdwICV = cpu_to_le32(~dwICV);
322 // RC4 encryption
323 rc4_init(&pDevice->SBox, pDevice->abyPRNG, TKIP_KEY_LEN);
324 rc4_encrypt(&pDevice->SBox, pbyPayloadHead, pbyPayloadHead, wPayloadSize+cbICVlen);
325 //=======================================================================
326 }
327 }
328
329 /*byPktType : PK_TYPE_11A 0
330 PK_TYPE_11B 1
331 PK_TYPE_11GB 2
332 PK_TYPE_11GA 3
333 */
334 static u32 s_uGetTxRsvTime(struct vnt_private *pDevice, u8 byPktType,
335 u32 cbFrameLength, u16 wRate, int bNeedAck)
336 {
337 u32 uDataTime, uAckTime;
338
339 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate);
340 if (byPktType == PK_TYPE_11B) {//llb,CCK mode
341 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (u16)pDevice->byTopCCKBasicRate);
342 } else {//11g 2.4G OFDM mode & 11a 5G OFDM mode
343 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (u16)pDevice->byTopOFDMBasicRate);
344 }
345
346 if (bNeedAck) {
347 return (uDataTime + pDevice->uSIFS + uAckTime);
348 }
349 else {
350 return uDataTime;
351 }
352 }
353
354 //byFreqType: 0=>5GHZ 1=>2.4GHZ
355 static u32 s_uGetRTSCTSRsvTime(struct vnt_private *pDevice,
356 u8 byRTSRsvType, u8 byPktType, u32 cbFrameLength, u16 wCurrentRate)
357 {
358 u32 uRrvTime, uRTSTime, uCTSTime, uAckTime, uDataTime;
359
360 uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0;
361
362 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate);
363 if (byRTSRsvType == 0) { //RTSTxRrvTime_bb
364 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
365 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
366 }
367 else if (byRTSRsvType == 1){ //RTSTxRrvTime_ba, only in 2.4GHZ
368 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate);
369 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
370 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
371 }
372 else if (byRTSRsvType == 2) { //RTSTxRrvTime_aa
373 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate);
374 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
375 }
376 else if (byRTSRsvType == 3) { //CTSTxRrvTime_ba, only in 2.4GHZ
377 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
378 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
379 uRrvTime = uCTSTime + uAckTime + uDataTime + 2*pDevice->uSIFS;
380 return uRrvTime;
381 }
382
383 //RTSRrvTime
384 uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3*pDevice->uSIFS;
385 return uRrvTime;
386 }
387
388 //byFreqType 0: 5GHz, 1:2.4Ghz
389 static u32 s_uGetDataDuration(struct vnt_private *pDevice, u8 byDurType,
390 u32 cbFrameLength, u8 byPktType, u16 wRate, int bNeedAck,
391 u32 uFragIdx, u32 cbLastFragmentSize, u32 uMACfragNum,
392 u8 byFBOption)
393 {
394 int bLastFrag = 0;
395 u32 uAckTime = 0, uNextPktTime = 0;
396
397 if (uFragIdx == (uMACfragNum-1)) {
398 bLastFrag = 1;
399 }
400
401 switch (byDurType) {
402
403 case DATADUR_B: //DATADUR_B
404 if (((uMACfragNum == 1)) || (bLastFrag == 1)) {//Non Frag or Last Frag
405 if (bNeedAck) {
406 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
407 return (pDevice->uSIFS + uAckTime);
408 } else {
409 return 0;
410 }
411 }
412 else {//First Frag or Mid Frag
413 if (uFragIdx == (uMACfragNum-2)) {
414 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
415 } else {
416 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
417 }
418 if (bNeedAck) {
419 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
420 return (pDevice->uSIFS + uAckTime + uNextPktTime);
421 } else {
422 return (pDevice->uSIFS + uNextPktTime);
423 }
424 }
425 break;
426
427 case DATADUR_A: //DATADUR_A
428 if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
429 if(bNeedAck){
430 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
431 return (pDevice->uSIFS + uAckTime);
432 } else {
433 return 0;
434 }
435 }
436 else {//First Frag or Mid Frag
437 if(uFragIdx == (uMACfragNum-2)){
438 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck);
439 } else {
440 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
441 }
442 if(bNeedAck){
443 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
444 return (pDevice->uSIFS + uAckTime + uNextPktTime);
445 } else {
446 return (pDevice->uSIFS + uNextPktTime);
447 }
448 }
449 break;
450
451 case DATADUR_A_F0: //DATADUR_A_F0
452 if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
453 if(bNeedAck){
454 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
455 return (pDevice->uSIFS + uAckTime);
456 } else {
457 return 0;
458 }
459 }
460 else { //First Frag or Mid Frag
461 if (byFBOption == AUTO_FB_0) {
462 if (wRate < RATE_18M)
463 wRate = RATE_18M;
464 else if (wRate > RATE_54M)
465 wRate = RATE_54M;
466
467 if(uFragIdx == (uMACfragNum-2)){
468 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
469 } else {
470 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
471 }
472 } else { // (byFBOption == AUTO_FB_1)
473 if (wRate < RATE_18M)
474 wRate = RATE_18M;
475 else if (wRate > RATE_54M)
476 wRate = RATE_54M;
477
478 if(uFragIdx == (uMACfragNum-2)){
479 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
480 } else {
481 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
482 }
483 }
484
485 if(bNeedAck){
486 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
487 return (pDevice->uSIFS + uAckTime + uNextPktTime);
488 } else {
489 return (pDevice->uSIFS + uNextPktTime);
490 }
491 }
492 break;
493
494 case DATADUR_A_F1: //DATADUR_A_F1
495 if (((uMACfragNum==1)) || (bLastFrag==1)) {//Non Frag or Last Frag
496 if(bNeedAck){
497 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
498 return (pDevice->uSIFS + uAckTime);
499 } else {
500 return 0;
501 }
502 }
503 else { //First Frag or Mid Frag
504 if (byFBOption == AUTO_FB_0) {
505 if (wRate < RATE_18M)
506 wRate = RATE_18M;
507 else if (wRate > RATE_54M)
508 wRate = RATE_54M;
509
510 if(uFragIdx == (uMACfragNum-2)){
511 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
512 } else {
513 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
514 }
515
516 } else { // (byFBOption == AUTO_FB_1)
517 if (wRate < RATE_18M)
518 wRate = RATE_18M;
519 else if (wRate > RATE_54M)
520 wRate = RATE_54M;
521
522 if(uFragIdx == (uMACfragNum-2)){
523 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
524 } else {
525 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
526 }
527 }
528 if(bNeedAck){
529 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
530 return (pDevice->uSIFS + uAckTime + uNextPktTime);
531 } else {
532 return (pDevice->uSIFS + uNextPktTime);
533 }
534 }
535 break;
536
537 default:
538 break;
539 }
540
541 ASSERT(false);
542 return 0;
543 }
544
545 //byFreqType: 0=>5GHZ 1=>2.4GHZ
546 static u32 s_uGetRTSCTSDuration(struct vnt_private *pDevice, u8 byDurType,
547 u32 cbFrameLength, u8 byPktType, u16 wRate, int bNeedAck,
548 u8 byFBOption)
549 {
550 u32 uCTSTime = 0, uDurTime = 0;
551
552 switch (byDurType) {
553
554 case RTSDUR_BB: //RTSDuration_bb
555 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
556 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
557 break;
558
559 case RTSDUR_BA: //RTSDuration_ba
560 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
561 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
562 break;
563
564 case RTSDUR_AA: //RTSDuration_aa
565 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
566 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
567 break;
568
569 case CTSDUR_BA: //CTSDuration_ba
570 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck);
571 break;
572
573 case RTSDUR_BA_F0: //RTSDuration_ba_f0
574 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
575 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
576 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
577 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
578 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
579 }
580 break;
581
582 case RTSDUR_AA_F0: //RTSDuration_aa_f0
583 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
584 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
585 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
586 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
587 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
588 }
589 break;
590
591 case RTSDUR_BA_F1: //RTSDuration_ba_f1
592 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate);
593 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
594 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
595 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
596 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
597 }
598 break;
599
600 case RTSDUR_AA_F1: //RTSDuration_aa_f1
601 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate);
602 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
603 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
604 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
605 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
606 }
607 break;
608
609 case CTSDUR_BA_F0: //CTSDuration_ba_f0
610 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
611 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck);
612 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
613 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck);
614 }
615 break;
616
617 case CTSDUR_BA_F1: //CTSDuration_ba_f1
618 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
619 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck);
620 } else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <=RATE_54M)) {
621 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck);
622 }
623 break;
624
625 default:
626 break;
627 }
628
629 return uDurTime;
630
631 }
632
633 static u32 s_uFillDataHead(struct vnt_private *pDevice,
634 u8 byPktType, u16 wCurrentRate, void *pTxDataHead, u32 cbFrameLength,
635 u32 uDMAIdx, int bNeedAck, u32 uFragIdx, u32 cbLastFragmentSize,
636 u32 uMACfragNum, u8 byFBOption)
637 {
638
639 if (pTxDataHead == NULL) {
640 return 0;
641 }
642
643 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
644 if ((uDMAIdx == TYPE_ATIMDMA) || (uDMAIdx == TYPE_BEACONDMA)) {
645 PSTxDataHead_ab pBuf = (PSTxDataHead_ab) pTxDataHead;
646 //Get SignalField,ServiceField,Length
647 BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
648 (u16 *)&(pBuf->wTransmitLength), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
649 );
650 //Get Duration and TimeStampOff
651 pBuf->wDuration = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
652 wCurrentRate, bNeedAck, uFragIdx,
653 cbLastFragmentSize, uMACfragNum,
654 byFBOption); //1: 2.4GHz
655 if(uDMAIdx!=TYPE_ATIMDMA) {
656 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
657 }
658 return (pBuf->wDuration);
659 }
660 else { // DATA & MANAGE Frame
661 if (byFBOption == AUTO_FB_NONE) {
662 PSTxDataHead_g pBuf = (PSTxDataHead_g)pTxDataHead;
663 //Get SignalField,ServiceField,Length
664 BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
665 (u16 *)&(pBuf->wTransmitLength_a), (u8 *)&(pBuf->byServiceField_a), (u8 *)&(pBuf->bySignalField_a)
666 );
667 BBvCalculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
668 (u16 *)&(pBuf->wTransmitLength_b), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
669 );
670 //Get Duration and TimeStamp
671 pBuf->wDuration_a = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength,
672 byPktType, wCurrentRate, bNeedAck, uFragIdx,
673 cbLastFragmentSize, uMACfragNum,
674 byFBOption); //1: 2.4GHz
675 pBuf->wDuration_b = (u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength,
676 PK_TYPE_11B, pDevice->byTopCCKBasicRate,
677 bNeedAck, uFragIdx, cbLastFragmentSize,
678 uMACfragNum, byFBOption); //1: 2.4GHz
679
680 pBuf->wTimeStampOff_a = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
681 pBuf->wTimeStampOff_b = wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE];
682 return (pBuf->wDuration_a);
683 } else {
684 // Auto Fallback
685 PSTxDataHead_g_FB pBuf = (PSTxDataHead_g_FB)pTxDataHead;
686 //Get SignalField,ServiceField,Length
687 BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
688 (u16 *)&(pBuf->wTransmitLength_a), (u8 *)&(pBuf->byServiceField_a), (u8 *)&(pBuf->bySignalField_a)
689 );
690 BBvCalculateParameter(pDevice, cbFrameLength, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
691 (u16 *)&(pBuf->wTransmitLength_b), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
692 );
693 //Get Duration and TimeStamp
694 pBuf->wDuration_a = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
695 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
696 pBuf->wDuration_b = (u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B,
697 pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
698 pBuf->wDuration_a_f0 = (u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
699 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
700 pBuf->wDuration_a_f1 = (u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
701 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //1: 2.4GHz
702 pBuf->wTimeStampOff_a = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
703 pBuf->wTimeStampOff_b = wTimeStampOff[pDevice->byPreambleType%2][pDevice->byTopCCKBasicRate%MAX_RATE];
704 return (pBuf->wDuration_a);
705 } //if (byFBOption == AUTO_FB_NONE)
706 }
707 }
708 else if (byPktType == PK_TYPE_11A) {
709 if ((byFBOption != AUTO_FB_NONE) && (uDMAIdx != TYPE_ATIMDMA) && (uDMAIdx != TYPE_BEACONDMA)) {
710 // Auto Fallback
711 PSTxDataHead_a_FB pBuf = (PSTxDataHead_a_FB)pTxDataHead;
712 //Get SignalField,ServiceField,Length
713 BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
714 (u16 *)&(pBuf->wTransmitLength), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
715 );
716 //Get Duration and TimeStampOff
717 pBuf->wDuration = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
718 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
719 pBuf->wDuration_f0 = (u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType,
720 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
721 pBuf->wDuration_f1 = (u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType,
722 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption); //0: 5GHz
723 if(uDMAIdx!=TYPE_ATIMDMA) {
724 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
725 }
726 return (pBuf->wDuration);
727 } else {
728 PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
729 //Get SignalField,ServiceField,Length
730 BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
731 (u16 *)&(pBuf->wTransmitLength), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
732 );
733 //Get Duration and TimeStampOff
734 pBuf->wDuration = (u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType,
735 wCurrentRate, bNeedAck, uFragIdx,
736 cbLastFragmentSize, uMACfragNum,
737 byFBOption);
738
739 if(uDMAIdx!=TYPE_ATIMDMA) {
740 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
741 }
742 return (pBuf->wDuration);
743 }
744 }
745 else if (byPktType == PK_TYPE_11B) {
746 PSTxDataHead_ab pBuf = (PSTxDataHead_ab)pTxDataHead;
747 //Get SignalField,ServiceField,Length
748 BBvCalculateParameter(pDevice, cbFrameLength, wCurrentRate, byPktType,
749 (u16 *)&(pBuf->wTransmitLength), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
750 );
751 //Get Duration and TimeStampOff
752 pBuf->wDuration = (u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType,
753 wCurrentRate, bNeedAck, uFragIdx,
754 cbLastFragmentSize, uMACfragNum,
755 byFBOption);
756 if (uDMAIdx != TYPE_ATIMDMA) {
757 pBuf->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
758 }
759 return (pBuf->wDuration);
760 }
761 return 0;
762 }
763
764 static void s_vFillRTSHead(struct vnt_private *pDevice, u8 byPktType,
765 void *pvRTS, u32 cbFrameLength, int bNeedAck, int bDisCRC,
766 struct ethhdr *psEthHeader, u16 wCurrentRate, u8 byFBOption)
767 {
768 u32 uRTSFrameLen = 20;
769 u16 wLen = 0;
770
771 if (pvRTS == NULL)
772 return;
773
774 if (bDisCRC) {
775 // When CRCDIS bit is on, H/W forgot to generate FCS for RTS frame,
776 // in this case we need to decrease its length by 4.
777 uRTSFrameLen -= 4;
778 }
779
780 // Note: So far RTSHead doesn't appear in ATIM & Beacom DMA, so we don't need to take them into account.
781 // Otherwise, we need to modified codes for them.
782 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
783 if (byFBOption == AUTO_FB_NONE) {
784 PSRTS_g pBuf = (PSRTS_g)pvRTS;
785 //Get SignalField,ServiceField,Length
786 BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
787 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
788 );
789 pBuf->wTransmitLength_b = cpu_to_le16(wLen);
790 BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
791 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_a), (u8 *)&(pBuf->bySignalField_a)
792 );
793 pBuf->wTransmitLength_a = cpu_to_le16(wLen);
794 //Get Duration
795 pBuf->wDuration_bb = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, PK_TYPE_11B, pDevice->byTopCCKBasicRate, bNeedAck, byFBOption)); //0:RTSDuration_bb, 1:2.4G, 1:CCKData
796 pBuf->wDuration_aa = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //2:RTSDuration_aa, 1:2.4G, 2,3: 2.4G OFDMData
797 pBuf->wDuration_ba = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //1:RTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
798
799 pBuf->Data.wDurationID = pBuf->wDuration_aa;
800 //Get RTS Frame body
801 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
802
803 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
804 (pDevice->eOPMode == OP_MODE_AP)) {
805 memcpy(&(pBuf->Data.abyRA[0]),
806 &(psEthHeader->h_dest[0]),
807 ETH_ALEN);
808 }
809 else {
810 memcpy(&(pBuf->Data.abyRA[0]),
811 &(pDevice->abyBSSID[0]),
812 ETH_ALEN);
813 }
814 if (pDevice->eOPMode == OP_MODE_AP) {
815 memcpy(&(pBuf->Data.abyTA[0]),
816 &(pDevice->abyBSSID[0]),
817 ETH_ALEN);
818 }
819 else {
820 memcpy(&(pBuf->Data.abyTA[0]),
821 &(psEthHeader->h_source[0]),
822 ETH_ALEN);
823 }
824 }
825 else {
826 PSRTS_g_FB pBuf = (PSRTS_g_FB)pvRTS;
827 //Get SignalField,ServiceField,Length
828 BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
829 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
830 );
831 pBuf->wTransmitLength_b = cpu_to_le16(wLen);
832 BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
833 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_a), (u8 *)&(pBuf->bySignalField_a)
834 );
835 pBuf->wTransmitLength_a = cpu_to_le16(wLen);
836 //Get Duration
837 pBuf->wDuration_bb = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, PK_TYPE_11B, pDevice->byTopCCKBasicRate, bNeedAck, byFBOption)); //0:RTSDuration_bb, 1:2.4G, 1:CCKData
838 pBuf->wDuration_aa = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //2:RTSDuration_aa, 1:2.4G, 2,3:2.4G OFDMData
839 pBuf->wDuration_ba = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //1:RTSDuration_ba, 1:2.4G, 2,3:2.4G OFDMData
840 pBuf->wRTSDuration_ba_f0 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //4:wRTSDuration_ba_f0, 1:2.4G, 1:CCKData
841 pBuf->wRTSDuration_aa_f0 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //5:wRTSDuration_aa_f0, 1:2.4G, 1:CCKData
842 pBuf->wRTSDuration_ba_f1 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //6:wRTSDuration_ba_f1, 1:2.4G, 1:CCKData
843 pBuf->wRTSDuration_aa_f1 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //7:wRTSDuration_aa_f1, 1:2.4G, 1:CCKData
844 pBuf->Data.wDurationID = pBuf->wDuration_aa;
845 //Get RTS Frame body
846 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
847
848 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
849 (pDevice->eOPMode == OP_MODE_AP)) {
850 memcpy(&(pBuf->Data.abyRA[0]),
851 &(psEthHeader->h_dest[0]),
852 ETH_ALEN);
853 }
854 else {
855 memcpy(&(pBuf->Data.abyRA[0]),
856 &(pDevice->abyBSSID[0]),
857 ETH_ALEN);
858 }
859
860 if (pDevice->eOPMode == OP_MODE_AP) {
861 memcpy(&(pBuf->Data.abyTA[0]),
862 &(pDevice->abyBSSID[0]),
863 ETH_ALEN);
864 }
865 else {
866 memcpy(&(pBuf->Data.abyTA[0]),
867 &(psEthHeader->h_source[0]),
868 ETH_ALEN);
869 }
870
871 } // if (byFBOption == AUTO_FB_NONE)
872 }
873 else if (byPktType == PK_TYPE_11A) {
874 if (byFBOption == AUTO_FB_NONE) {
875 PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
876 //Get SignalField,ServiceField,Length
877 BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
878 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
879 );
880 pBuf->wTransmitLength = cpu_to_le16(wLen);
881 //Get Duration
882 pBuf->wDuration = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_aa, 0:5G, 0: 5G OFDMData
883 pBuf->Data.wDurationID = pBuf->wDuration;
884 //Get RTS Frame body
885 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
886
887 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
888 (pDevice->eOPMode == OP_MODE_AP)) {
889 memcpy(&(pBuf->Data.abyRA[0]),
890 &(psEthHeader->h_dest[0]),
891 ETH_ALEN);
892 } else {
893 memcpy(&(pBuf->Data.abyRA[0]),
894 &(pDevice->abyBSSID[0]),
895 ETH_ALEN);
896 }
897
898 if (pDevice->eOPMode == OP_MODE_AP) {
899 memcpy(&(pBuf->Data.abyTA[0]),
900 &(pDevice->abyBSSID[0]),
901 ETH_ALEN);
902 } else {
903 memcpy(&(pBuf->Data.abyTA[0]),
904 &(psEthHeader->h_source[0]),
905 ETH_ALEN);
906 }
907
908 }
909 else {
910 PSRTS_a_FB pBuf = (PSRTS_a_FB)pvRTS;
911 //Get SignalField,ServiceField,Length
912 BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopOFDMBasicRate, byPktType,
913 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
914 );
915 pBuf->wTransmitLength = cpu_to_le16(wLen);
916 //Get Duration
917 pBuf->wDuration = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_aa, 0:5G, 0: 5G OFDMData
918 pBuf->wRTSDuration_f0 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //5:RTSDuration_aa_f0, 0:5G, 0: 5G OFDMData
919 pBuf->wRTSDuration_f1 = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //7:RTSDuration_aa_f1, 0:5G, 0:
920 pBuf->Data.wDurationID = pBuf->wDuration;
921 //Get RTS Frame body
922 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
923
924 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
925 (pDevice->eOPMode == OP_MODE_AP)) {
926 memcpy(&(pBuf->Data.abyRA[0]),
927 &(psEthHeader->h_dest[0]),
928 ETH_ALEN);
929 } else {
930 memcpy(&(pBuf->Data.abyRA[0]),
931 &(pDevice->abyBSSID[0]),
932 ETH_ALEN);
933 }
934 if (pDevice->eOPMode == OP_MODE_AP) {
935 memcpy(&(pBuf->Data.abyTA[0]),
936 &(pDevice->abyBSSID[0]),
937 ETH_ALEN);
938 } else {
939 memcpy(&(pBuf->Data.abyTA[0]),
940 &(psEthHeader->h_source[0]),
941 ETH_ALEN);
942 }
943 }
944 }
945 else if (byPktType == PK_TYPE_11B) {
946 PSRTS_ab pBuf = (PSRTS_ab)pvRTS;
947 //Get SignalField,ServiceField,Length
948 BBvCalculateParameter(pDevice, uRTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
949 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField), (u8 *)&(pBuf->bySignalField)
950 );
951 pBuf->wTransmitLength = cpu_to_le16(wLen);
952 //Get Duration
953 pBuf->wDuration = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //0:RTSDuration_bb, 1:2.4G, 1:CCKData
954 pBuf->Data.wDurationID = pBuf->wDuration;
955 //Get RTS Frame body
956 pBuf->Data.wFrameControl = TYPE_CTL_RTS;//0x00B4
957
958 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
959 (pDevice->eOPMode == OP_MODE_AP)) {
960 memcpy(&(pBuf->Data.abyRA[0]),
961 &(psEthHeader->h_dest[0]),
962 ETH_ALEN);
963 }
964 else {
965 memcpy(&(pBuf->Data.abyRA[0]),
966 &(pDevice->abyBSSID[0]),
967 ETH_ALEN);
968 }
969
970 if (pDevice->eOPMode == OP_MODE_AP) {
971 memcpy(&(pBuf->Data.abyTA[0]),
972 &(pDevice->abyBSSID[0]),
973 ETH_ALEN);
974 } else {
975 memcpy(&(pBuf->Data.abyTA[0]),
976 &(psEthHeader->h_source[0]),
977 ETH_ALEN);
978 }
979 }
980 }
981
982 static void s_vFillCTSHead(struct vnt_private *pDevice, u32 uDMAIdx,
983 u8 byPktType, void *pvCTS, u32 cbFrameLength, int bNeedAck,
984 int bDisCRC, u16 wCurrentRate, u8 byFBOption)
985 {
986 u32 uCTSFrameLen = 14;
987 u16 wLen = 0;
988
989 if (pvCTS == NULL) {
990 return;
991 }
992
993 if (bDisCRC) {
994 // When CRCDIS bit is on, H/W forgot to generate FCS for CTS frame,
995 // in this case we need to decrease its length by 4.
996 uCTSFrameLen -= 4;
997 }
998
999 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1000 if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) {
1001 // Auto Fall back
1002 PSCTS_FB pBuf = (PSCTS_FB)pvCTS;
1003 //Get SignalField,ServiceField,Length
1004 BBvCalculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1005 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
1006 );
1007 pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1008 pBuf->wDuration_ba = (u16)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //3:CTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1009 pBuf->wDuration_ba += pDevice->wCTSDuration;
1010 pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1011 //Get CTSDuration_ba_f0
1012 pBuf->wCTSDuration_ba_f0 = (u16)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //8:CTSDuration_ba_f0, 1:2.4G, 2,3:2.4G OFDM Data
1013 pBuf->wCTSDuration_ba_f0 += pDevice->wCTSDuration;
1014 pBuf->wCTSDuration_ba_f0 = cpu_to_le16(pBuf->wCTSDuration_ba_f0);
1015 //Get CTSDuration_ba_f1
1016 pBuf->wCTSDuration_ba_f1 = (u16)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption); //9:CTSDuration_ba_f1, 1:2.4G, 2,3:2.4G OFDM Data
1017 pBuf->wCTSDuration_ba_f1 += pDevice->wCTSDuration;
1018 pBuf->wCTSDuration_ba_f1 = cpu_to_le16(pBuf->wCTSDuration_ba_f1);
1019 //Get CTS Frame body
1020 pBuf->Data.wDurationID = pBuf->wDuration_ba;
1021 pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
1022 pBuf->Data.wReserved = 0x0000;
1023 memcpy(&(pBuf->Data.abyRA[0]),
1024 &(pDevice->abyCurrentNetAddr[0]),
1025 ETH_ALEN);
1026 } else { //if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA)
1027 PSCTS pBuf = (PSCTS)pvCTS;
1028 //Get SignalField,ServiceField,Length
1029 BBvCalculateParameter(pDevice, uCTSFrameLen, pDevice->byTopCCKBasicRate, PK_TYPE_11B,
1030 (u16 *)&(wLen), (u8 *)&(pBuf->byServiceField_b), (u8 *)&(pBuf->bySignalField_b)
1031 );
1032 pBuf->wTransmitLength_b = cpu_to_le16(wLen);
1033 //Get CTSDuration_ba
1034 pBuf->wDuration_ba = cpu_to_le16((u16)s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, cbFrameLength, byPktType, wCurrentRate, bNeedAck, byFBOption)); //3:CTSDuration_ba, 1:2.4G, 2,3:2.4G OFDM Data
1035 pBuf->wDuration_ba += pDevice->wCTSDuration;
1036 pBuf->wDuration_ba = cpu_to_le16(pBuf->wDuration_ba);
1037
1038 //Get CTS Frame body
1039 pBuf->Data.wDurationID = pBuf->wDuration_ba;
1040 pBuf->Data.wFrameControl = TYPE_CTL_CTS;//0x00C4
1041 pBuf->Data.wReserved = 0x0000;
1042 memcpy(&(pBuf->Data.abyRA[0]),
1043 &(pDevice->abyCurrentNetAddr[0]),
1044 ETH_ALEN);
1045 }
1046 }
1047 }
1048
1049 /*+
1050 *
1051 * Description:
1052 * Generate FIFO control for MAC & Baseband controller
1053 *
1054 * Parameters:
1055 * In:
1056 * pDevice - Pointer to adpater
1057 * pTxDataHead - Transmit Data Buffer
1058 * pTxBufHead - pTxBufHead
1059 * pvRrvTime - pvRrvTime
1060 * pvRTS - RTS Buffer
1061 * pCTS - CTS Buffer
1062 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS)
1063 * bNeedACK - If need ACK
1064 * uDMAIdx - DMA Index
1065 * Out:
1066 * none
1067 *
1068 * Return Value: none
1069 *
1070 -*/
1071
1072 static void s_vGenerateTxParameter(struct vnt_private *pDevice,
1073 u8 byPktType, u16 wCurrentRate, void *pTxBufHead, void *pvRrvTime,
1074 void *pvRTS, void *pvCTS, u32 cbFrameSize, int bNeedACK, u32 uDMAIdx,
1075 struct ethhdr *psEthHeader)
1076 {
1077 u32 cbMACHdLen = WLAN_HDR_ADDR3_LEN; /* 24 */
1078 u16 wFifoCtl;
1079 int bDisCRC = false;
1080 u8 byFBOption = AUTO_FB_NONE;
1081
1082 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter...\n");
1083 PSTxBufHead pFifoHead = (PSTxBufHead)pTxBufHead;
1084 pFifoHead->wReserved = wCurrentRate;
1085 wFifoCtl = pFifoHead->wFIFOCtl;
1086
1087 if (wFifoCtl & FIFOCTL_CRCDIS) {
1088 bDisCRC = true;
1089 }
1090
1091 if (wFifoCtl & FIFOCTL_AUTO_FB_0) {
1092 byFBOption = AUTO_FB_0;
1093 }
1094 else if (wFifoCtl & FIFOCTL_AUTO_FB_1) {
1095 byFBOption = AUTO_FB_1;
1096 }
1097
1098 if (pDevice->bLongHeader)
1099 cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
1100
1101 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1102
1103 if (pvRTS != NULL) { //RTS_need
1104 //Fill RsvTime
1105 if (pvRrvTime) {
1106 PSRrvTime_gRTS pBuf = (PSRrvTime_gRTS)pvRrvTime;
1107 pBuf->wRTSTxRrvTime_aa = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 1:2.4GHz
1108 pBuf->wRTSTxRrvTime_ba = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 1, byPktType, cbFrameSize, wCurrentRate));//1:RTSTxRrvTime_ba, 1:2.4GHz
1109 pBuf->wRTSTxRrvTime_bb = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
1110 pBuf->wTxRrvTime_a = cpu_to_le16((u16) s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
1111 pBuf->wTxRrvTime_b = cpu_to_le16((u16) s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1112 }
1113 //Fill RTS
1114 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1115 }
1116 else {//RTS_needless, PCF mode
1117
1118 //Fill RsvTime
1119 if (pvRrvTime) {
1120 PSRrvTime_gCTS pBuf = (PSRrvTime_gCTS)pvRrvTime;
1121 pBuf->wTxRrvTime_a = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//2.4G OFDM
1122 pBuf->wTxRrvTime_b = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK));//1:CCK
1123 pBuf->wCTSTxRrvTime_ba = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate));//3:CTSTxRrvTime_Ba, 1:2.4GHz
1124 }
1125 //Fill CTS
1126 s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption);
1127 }
1128 }
1129 else if (byPktType == PK_TYPE_11A) {
1130
1131 if (pvRTS != NULL) {//RTS_need, non PCF mode
1132 //Fill RsvTime
1133 if (pvRrvTime) {
1134 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1135 pBuf->wRTSTxRrvTime = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate));//2:RTSTxRrvTime_aa, 0:5GHz
1136 pBuf->wTxRrvTime = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK));//0:OFDM
1137 }
1138 //Fill RTS
1139 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1140 }
1141 else if (pvRTS == NULL) {//RTS_needless, non PCF mode
1142 //Fill RsvTime
1143 if (pvRrvTime) {
1144 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1145 pBuf->wTxRrvTime = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK)); //0:OFDM
1146 }
1147 }
1148 }
1149 else if (byPktType == PK_TYPE_11B) {
1150
1151 if ((pvRTS != NULL)) {//RTS_need, non PCF mode
1152 //Fill RsvTime
1153 if (pvRrvTime) {
1154 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1155 pBuf->wRTSTxRrvTime = cpu_to_le16((u16)s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate));//0:RTSTxRrvTime_bb, 1:2.4GHz
1156 pBuf->wTxRrvTime = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK));//1:CCK
1157 }
1158 //Fill RTS
1159 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption);
1160 }
1161 else { //RTS_needless, non PCF mode
1162 //Fill RsvTime
1163 if (pvRrvTime) {
1164 PSRrvTime_ab pBuf = (PSRrvTime_ab)pvRrvTime;
1165 pBuf->wTxRrvTime = cpu_to_le16((u16)s_uGetTxRsvTime(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK)); //1:CCK
1166 }
1167 }
1168 }
1169 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_vGenerateTxParameter END.\n");
1170 }
1171 /*
1172 u8 * pbyBuffer,//point to pTxBufHead
1173 u16 wFragType,//00:Non-Frag, 01:Start, 02:Mid, 03:Last
1174 unsigned int cbFragmentSize,//Hdr+payoad+FCS
1175 */
1176
1177 static int s_bPacketToWirelessUsb(struct vnt_private *pDevice, u8 byPktType,
1178 u8 *usbPacketBuf, int bNeedEncryption, u32 uSkbPacketLen, u32 uDMAIdx,
1179 struct ethhdr *psEthHeader, u8 *pPacket, PSKeyItem pTransmitKey,
1180 u32 uNodeIndex, u16 wCurrentRate, u32 *pcbHeaderLen, u32 *pcbTotalLen)
1181 {
1182 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1183 u32 cbFrameSize, cbFrameBodySize;
1184 PTX_BUFFER pTxBufHead;
1185 u32 cb802_1_H_len;
1186 u32 cbIVlen = 0, cbICVlen = 0, cbMIClen = 0, cbMACHdLen = 0;
1187 u32 cbFCSlen = 4, cbMICHDR = 0;
1188 int bNeedACK, bRTS;
1189 u8 *pbyType, *pbyMacHdr, *pbyIVHead, *pbyPayloadHead, *pbyTxBufferAddr;
1190 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
1191 u8 abySNAP_Bridgetunnel[ETH_ALEN]
1192 = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
1193 u32 uDuration;
1194 u32 cbHeaderLength = 0, uPadding = 0;
1195 void *pvRrvTime;
1196 PSMICHDRHead pMICHDR;
1197 void *pvRTS;
1198 void *pvCTS;
1199 void *pvTxDataHd;
1200 u8 byFBOption = AUTO_FB_NONE, byFragType;
1201 u16 wTxBufSize;
1202 u32 dwMICKey0, dwMICKey1, dwMIC_Priority, dwCRC;
1203 u32 *pdwMIC_L, *pdwMIC_R;
1204 int bSoftWEP = false;
1205
1206 pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
1207
1208 if (bNeedEncryption && pTransmitKey->pvKeyTable) {
1209 if (((PSKeyTable)pTransmitKey->pvKeyTable)->bSoftWEP == true)
1210 bSoftWEP = true; /* WEP 256 */
1211 }
1212
1213 pTxBufHead = (PTX_BUFFER) usbPacketBuf;
1214 memset(pTxBufHead, 0, sizeof(TX_BUFFER));
1215
1216 // Get pkt type
1217 if (ntohs(psEthHeader->h_proto) > ETH_DATA_LEN) {
1218 if (pDevice->dwDiagRefCount == 0) {
1219 cb802_1_H_len = 8;
1220 } else {
1221 cb802_1_H_len = 2;
1222 }
1223 } else {
1224 cb802_1_H_len = 0;
1225 }
1226
1227 cbFrameBodySize = uSkbPacketLen - ETH_HLEN + cb802_1_H_len;
1228
1229 //Set packet type
1230 pTxBufHead->wFIFOCtl |= (u16)(byPktType<<8);
1231
1232 if (pDevice->dwDiagRefCount != 0) {
1233 bNeedACK = false;
1234 pTxBufHead->wFIFOCtl = pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1235 } else { //if (pDevice->dwDiagRefCount != 0) {
1236 if ((pDevice->eOPMode == OP_MODE_ADHOC) ||
1237 (pDevice->eOPMode == OP_MODE_AP)) {
1238 if (is_multicast_ether_addr(psEthHeader->h_dest)) {
1239 bNeedACK = false;
1240 pTxBufHead->wFIFOCtl =
1241 pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1242 } else {
1243 bNeedACK = true;
1244 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1245 }
1246 }
1247 else {
1248 // MSDUs in Infra mode always need ACK
1249 bNeedACK = true;
1250 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1251 }
1252 } //if (pDevice->dwDiagRefCount != 0) {
1253
1254 pTxBufHead->wTimeStamp = DEFAULT_MSDU_LIFETIME_RES_64us;
1255
1256 //Set FIFOCTL_LHEAD
1257 if (pDevice->bLongHeader)
1258 pTxBufHead->wFIFOCtl |= FIFOCTL_LHEAD;
1259
1260 if (pDevice->bSoftwareGenCrcErr) {
1261 pTxBufHead->wFIFOCtl |= FIFOCTL_CRCDIS; // set tx descriptors to NO hardware CRC
1262 }
1263
1264 //Set FRAGCTL_MACHDCNT
1265 if (pDevice->bLongHeader) {
1266 cbMACHdLen = WLAN_HDR_ADDR3_LEN + 6;
1267 } else {
1268 cbMACHdLen = WLAN_HDR_ADDR3_LEN;
1269 }
1270 pTxBufHead->wFragCtl |= (u16)(cbMACHdLen << 10);
1271
1272 //Set FIFOCTL_GrpAckPolicy
1273 if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
1274 pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
1275 }
1276
1277 //Set Auto Fallback Ctl
1278 if (wCurrentRate >= RATE_18M) {
1279 if (pDevice->byAutoFBCtrl == AUTO_FB_0) {
1280 pTxBufHead->wFIFOCtl |= FIFOCTL_AUTO_FB_0;
1281 byFBOption = AUTO_FB_0;
1282 } else if (pDevice->byAutoFBCtrl == AUTO_FB_1) {
1283 pTxBufHead->wFIFOCtl |= FIFOCTL_AUTO_FB_1;
1284 byFBOption = AUTO_FB_1;
1285 }
1286 }
1287
1288 if (bSoftWEP != true) {
1289 if ((bNeedEncryption) && (pTransmitKey != NULL)) { //WEP enabled
1290 if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) { //WEP40 or WEP104
1291 pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
1292 }
1293 if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
1294 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Tx Set wFragCtl == FRAGCTL_TKIP\n");
1295 pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
1296 }
1297 else if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) { //CCMP
1298 pTxBufHead->wFragCtl |= FRAGCTL_AES;
1299 }
1300 }
1301 }
1302
1303 if ((bNeedEncryption) && (pTransmitKey != NULL)) {
1304 if (pTransmitKey->byCipherSuite == KEY_CTL_WEP) {
1305 cbIVlen = 4;
1306 cbICVlen = 4;
1307 }
1308 else if (pTransmitKey->byCipherSuite == KEY_CTL_TKIP) {
1309 cbIVlen = 8;//IV+ExtIV
1310 cbMIClen = 8;
1311 cbICVlen = 4;
1312 }
1313 if (pTransmitKey->byCipherSuite == KEY_CTL_CCMP) {
1314 cbIVlen = 8;//RSN Header
1315 cbICVlen = 8;//MIC
1316 cbMICHDR = sizeof(SMICHDRHead);
1317 }
1318 if (bSoftWEP == false) {
1319 //MAC Header should be padding 0 to DW alignment.
1320 uPadding = 4 - (cbMACHdLen%4);
1321 uPadding %= 4;
1322 }
1323 }
1324
1325 cbFrameSize = cbMACHdLen + cbIVlen + (cbFrameBodySize + cbMIClen) + cbICVlen + cbFCSlen;
1326
1327 if ( (bNeedACK == false) ||(cbFrameSize < pDevice->wRTSThreshold) ) {
1328 bRTS = false;
1329 } else {
1330 bRTS = true;
1331 pTxBufHead->wFIFOCtl |= (FIFOCTL_RTS | FIFOCTL_LRETRY);
1332 }
1333
1334 pbyTxBufferAddr = (u8 *) &(pTxBufHead->adwTxKey[0]);
1335 wTxBufSize = sizeof(STxBufHead);
1336 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1337 if (byFBOption == AUTO_FB_NONE) {
1338 if (bRTS == true) {//RTS_need
1339 pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
1340 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
1341 pvRTS = (PSRTS_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
1342 pvCTS = NULL;
1343 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g));
1344 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g) + sizeof(STxDataHead_g);
1345 }
1346 else { //RTS_needless
1347 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1348 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1349 pvRTS = NULL;
1350 pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
1351 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
1352 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
1353 }
1354 } else {
1355 // Auto Fall Back
1356 if (bRTS == true) {//RTS_need
1357 pvRrvTime = (PSRrvTime_gRTS) (pbyTxBufferAddr + wTxBufSize);
1358 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS));
1359 pvRTS = (PSRTS_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR);
1360 pvCTS = NULL;
1361 pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB));
1362 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gRTS) + cbMICHDR + sizeof(SRTS_g_FB) + sizeof(STxDataHead_g_FB);
1363 }
1364 else if (bRTS == false) { //RTS_needless
1365 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1366 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1367 pvRTS = NULL;
1368 pvCTS = (PSCTS_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
1369 pvTxDataHd = (PSTxDataHead_g_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB));
1370 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS_FB) + sizeof(STxDataHead_g_FB);
1371 }
1372 } // Auto Fall Back
1373 }
1374 else {//802.11a/b packet
1375 if (byFBOption == AUTO_FB_NONE) {
1376 if (bRTS == true) {//RTS_need
1377 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1378 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1379 pvRTS = (PSRTS_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1380 pvCTS = NULL;
1381 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab));
1382 cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_ab) + sizeof(STxDataHead_ab);
1383 }
1384 else if (bRTS == false) { //RTS_needless, no MICHDR
1385 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1386 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1387 pvRTS = NULL;
1388 pvCTS = NULL;
1389 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1390 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
1391 }
1392 } else {
1393 // Auto Fall Back
1394 if (bRTS == true) {//RTS_need
1395 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1396 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1397 pvRTS = (PSRTS_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1398 pvCTS = NULL;
1399 pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB));
1400 cbHeaderLength = wTxBufSize + sizeof(PSRrvTime_ab) + cbMICHDR + sizeof(SRTS_a_FB) + sizeof(STxDataHead_a_FB);
1401 }
1402 else if (bRTS == false) { //RTS_needless
1403 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1404 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1405 pvRTS = NULL;
1406 pvCTS = NULL;
1407 pvTxDataHd = (PSTxDataHead_a_FB) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
1408 cbHeaderLength = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_a_FB);
1409 }
1410 } // Auto Fall Back
1411 }
1412
1413 pbyMacHdr = (u8 *)(pbyTxBufferAddr + cbHeaderLength);
1414 pbyIVHead = (u8 *)(pbyMacHdr + cbMACHdLen + uPadding);
1415 pbyPayloadHead = (u8 *)(pbyMacHdr + cbMACHdLen + uPadding + cbIVlen);
1416
1417 //=========================
1418 // No Fragmentation
1419 //=========================
1420 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"No Fragmentation...\n");
1421 byFragType = FRAGCTL_NONFRAG;
1422 //uDMAIdx = TYPE_AC0DMA;
1423 //pTxBufHead = (PSTxBufHead) &(pTxBufHead->adwTxKey[0]);
1424
1425 //Fill FIFO,RrvTime,RTS,and CTS
1426 s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate,
1427 (void *)pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
1428 cbFrameSize, bNeedACK, uDMAIdx, psEthHeader);
1429 //Fill DataHead
1430 uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK,
1431 0, 0, 1/*uMACfragNum*/, byFBOption);
1432 // Generate TX MAC Header
1433 s_vGenerateMACHeader(pDevice, pbyMacHdr, (u16)uDuration, psEthHeader, bNeedEncryption,
1434 byFragType, uDMAIdx, 0);
1435
1436 if (bNeedEncryption == true) {
1437 //Fill TXKEY
1438 s_vFillTxKey(pDevice, (u8 *)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
1439 pbyMacHdr, (u16)cbFrameBodySize, (u8 *)pMICHDR);
1440
1441 if (pDevice->bEnableHostWEP) {
1442 pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
1443 pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
1444 }
1445 }
1446
1447 // 802.1H
1448 if (ntohs(psEthHeader->h_proto) > ETH_DATA_LEN) {
1449 if (pDevice->dwDiagRefCount == 0) {
1450 if ((psEthHeader->h_proto == cpu_to_be16(ETH_P_IPX)) ||
1451 (psEthHeader->h_proto == cpu_to_le16(0xF380))) {
1452 memcpy((u8 *) (pbyPayloadHead),
1453 abySNAP_Bridgetunnel, 6);
1454 } else {
1455 memcpy((u8 *) (pbyPayloadHead), &abySNAP_RFC1042[0], 6);
1456 }
1457 pbyType = (u8 *) (pbyPayloadHead + 6);
1458 memcpy(pbyType, &(psEthHeader->h_proto), sizeof(u16));
1459 } else {
1460 memcpy((u8 *) (pbyPayloadHead), &(psEthHeader->h_proto), sizeof(u16));
1461
1462 }
1463
1464 }
1465
1466 if (pPacket != NULL) {
1467 // Copy the Packet into a tx Buffer
1468 memcpy((pbyPayloadHead + cb802_1_H_len),
1469 (pPacket + ETH_HLEN),
1470 uSkbPacketLen - ETH_HLEN
1471 );
1472
1473 } else {
1474 // while bRelayPacketSend psEthHeader is point to header+payload
1475 memcpy((pbyPayloadHead + cb802_1_H_len), ((u8 *)psEthHeader) + ETH_HLEN, uSkbPacketLen - ETH_HLEN);
1476 }
1477
1478 ASSERT(uLength == cbNdisBodySize);
1479
1480 if ((bNeedEncryption == true) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
1481
1482 ///////////////////////////////////////////////////////////////////
1483
1484 if (pDevice->vnt_mgmt.eAuthenMode == WMAC_AUTH_WPANONE) {
1485 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
1486 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
1487 }
1488 else if ((pTransmitKey->dwKeyIndex & AUTHENTICATOR_KEY) != 0) {
1489 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
1490 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
1491 }
1492 else {
1493 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[24]);
1494 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[28]);
1495 }
1496 // DO Software Michael
1497 MIC_vInit(dwMICKey0, dwMICKey1);
1498 MIC_vAppend((u8 *)&(psEthHeader->h_dest[0]), 12);
1499 dwMIC_Priority = 0;
1500 MIC_vAppend((u8 *)&dwMIC_Priority, 4);
1501 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC KEY: %X, %X\n",
1502 dwMICKey0, dwMICKey1);
1503
1504 ///////////////////////////////////////////////////////////////////
1505
1506 //DBG_PRN_GRP12(("Length:%d, %d\n", cbFrameBodySize, uFromHDtoPLDLength));
1507 //for (ii = 0; ii < cbFrameBodySize; ii++) {
1508 // DBG_PRN_GRP12(("%02x ", *((u8 *)((pbyPayloadHead + cb802_1_H_len) + ii))));
1509 //}
1510 //DBG_PRN_GRP12(("\n\n\n"));
1511
1512 MIC_vAppend(pbyPayloadHead, cbFrameBodySize);
1513
1514 pdwMIC_L = (u32 *)(pbyPayloadHead + cbFrameBodySize);
1515 pdwMIC_R = (u32 *)(pbyPayloadHead + cbFrameBodySize + 4);
1516
1517 MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
1518 MIC_vUnInit();
1519
1520 if (pDevice->bTxMICFail == true) {
1521 *pdwMIC_L = 0;
1522 *pdwMIC_R = 0;
1523 pDevice->bTxMICFail = false;
1524 }
1525 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
1526 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderLength, uPadding, cbIVlen);
1527 //DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%lX, %lX\n", *pdwMIC_L, *pdwMIC_R);
1528 }
1529
1530 if (bSoftWEP == true) {
1531
1532 s_vSWencryption(pDevice, pTransmitKey, (pbyPayloadHead), (u16)(cbFrameBodySize + cbMIClen));
1533
1534 } else if ( ((pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) && (bNeedEncryption == true)) ||
1535 ((pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) && (bNeedEncryption == true)) ||
1536 ((pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) && (bNeedEncryption == true)) ) {
1537 cbFrameSize -= cbICVlen;
1538 }
1539
1540 if (pDevice->bSoftwareGenCrcErr == true) {
1541 unsigned int cbLen;
1542 u32 * pdwCRC;
1543
1544 dwCRC = 0xFFFFFFFFL;
1545 cbLen = cbFrameSize - cbFCSlen;
1546 // calculate CRC, and wrtie CRC value to end of TD
1547 dwCRC = CRCdwGetCrc32Ex(pbyMacHdr, cbLen, dwCRC);
1548 pdwCRC = (u32 *)(pbyMacHdr + cbLen);
1549 // finally, we must invert dwCRC to get the correct answer
1550 *pdwCRC = ~dwCRC;
1551 // Force Error
1552 *pdwCRC -= 1;
1553 } else {
1554 cbFrameSize -= cbFCSlen;
1555 }
1556
1557 *pcbHeaderLen = cbHeaderLength;
1558 *pcbTotalLen = cbHeaderLength + cbFrameSize ;
1559
1560 //Set FragCtl in TxBufferHead
1561 pTxBufHead->wFragCtl |= (u16)byFragType;
1562
1563 return true;
1564
1565 }
1566
1567 /*+
1568 *
1569 * Description:
1570 * Translate 802.3 to 802.11 header
1571 *
1572 * Parameters:
1573 * In:
1574 * pDevice - Pointer to adapter
1575 * dwTxBufferAddr - Transmit Buffer
1576 * pPacket - Packet from upper layer
1577 * cbPacketSize - Transmit Data Length
1578 * Out:
1579 * pcbHeadSize - Header size of MAC&Baseband control and 802.11 Header
1580 * pcbAppendPayload - size of append payload for 802.1H translation
1581 *
1582 * Return Value: none
1583 *
1584 -*/
1585
1586 static void s_vGenerateMACHeader(struct vnt_private *pDevice,
1587 u8 *pbyBufferAddr, u16 wDuration, struct ethhdr *psEthHeader,
1588 int bNeedEncrypt, u16 wFragType, u32 uDMAIdx, u32 uFragIdx)
1589 {
1590 struct ieee80211_hdr *pMACHeader = (struct ieee80211_hdr *)pbyBufferAddr;
1591
1592 memset(pMACHeader, 0, (sizeof(struct ieee80211_hdr)));
1593
1594 if (uDMAIdx == TYPE_ATIMDMA) {
1595 pMACHeader->frame_control = TYPE_802_11_ATIM;
1596 } else {
1597 pMACHeader->frame_control = TYPE_802_11_DATA;
1598 }
1599
1600 if (pDevice->eOPMode == OP_MODE_AP) {
1601 memcpy(&(pMACHeader->addr1[0]),
1602 &(psEthHeader->h_dest[0]),
1603 ETH_ALEN);
1604 memcpy(&(pMACHeader->addr2[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
1605 memcpy(&(pMACHeader->addr3[0]),
1606 &(psEthHeader->h_source[0]),
1607 ETH_ALEN);
1608 pMACHeader->frame_control |= FC_FROMDS;
1609 } else {
1610 if (pDevice->eOPMode == OP_MODE_ADHOC) {
1611 memcpy(&(pMACHeader->addr1[0]),
1612 &(psEthHeader->h_dest[0]),
1613 ETH_ALEN);
1614 memcpy(&(pMACHeader->addr2[0]),
1615 &(psEthHeader->h_source[0]),
1616 ETH_ALEN);
1617 memcpy(&(pMACHeader->addr3[0]),
1618 &(pDevice->abyBSSID[0]),
1619 ETH_ALEN);
1620 } else {
1621 memcpy(&(pMACHeader->addr3[0]),
1622 &(psEthHeader->h_dest[0]),
1623 ETH_ALEN);
1624 memcpy(&(pMACHeader->addr2[0]),
1625 &(psEthHeader->h_source[0]),
1626 ETH_ALEN);
1627 memcpy(&(pMACHeader->addr1[0]),
1628 &(pDevice->abyBSSID[0]),
1629 ETH_ALEN);
1630 pMACHeader->frame_control |= FC_TODS;
1631 }
1632 }
1633
1634 if (bNeedEncrypt)
1635 pMACHeader->frame_control |= cpu_to_le16((u16)WLAN_SET_FC_ISWEP(1));
1636
1637 pMACHeader->duration_id = cpu_to_le16(wDuration);
1638
1639 if (pDevice->bLongHeader) {
1640 PWLAN_80211HDR_A4 pMACA4Header = (PWLAN_80211HDR_A4) pbyBufferAddr;
1641 pMACHeader->frame_control |= (FC_TODS | FC_FROMDS);
1642 memcpy(pMACA4Header->abyAddr4, pDevice->abyBSSID, WLAN_ADDR_LEN);
1643 }
1644 pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
1645
1646 //Set FragNumber in Sequence Control
1647 pMACHeader->seq_ctrl |= cpu_to_le16((u16)uFragIdx);
1648
1649 if ((wFragType == FRAGCTL_ENDFRAG) || (wFragType == FRAGCTL_NONFRAG)) {
1650 pDevice->wSeqCounter++;
1651 if (pDevice->wSeqCounter > 0x0fff)
1652 pDevice->wSeqCounter = 0;
1653 }
1654
1655 if ((wFragType == FRAGCTL_STAFRAG) || (wFragType == FRAGCTL_MIDFRAG)) { //StartFrag or MidFrag
1656 pMACHeader->frame_control |= FC_MOREFRAG;
1657 }
1658 }
1659
1660 /*+
1661 *
1662 * Description:
1663 * Request instructs a MAC to transmit a 802.11 management packet through
1664 * the adapter onto the medium.
1665 *
1666 * Parameters:
1667 * In:
1668 * hDeviceContext - Pointer to the adapter
1669 * pPacket - A pointer to a descriptor for the packet to transmit
1670 * Out:
1671 * none
1672 *
1673 * Return Value: CMD_STATUS_PENDING if MAC Tx resource available; otherwise false
1674 *
1675 -*/
1676
1677 CMD_STATUS csMgmt_xmit(struct vnt_private *pDevice,
1678 struct vnt_tx_mgmt *pPacket)
1679 {
1680 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1681 PTX_BUFFER pTX_Buffer;
1682 PSTxBufHead pTxBufHead;
1683 PUSB_SEND_CONTEXT pContext;
1684 struct ieee80211_hdr *pMACHeader;
1685 PSCTS pCTS;
1686 struct ethhdr sEthHeader;
1687 u8 byPktType, *pbyTxBufferAddr;
1688 void *pvRTS, *pvTxDataHd, *pvRrvTime, *pMICHDR;
1689 u32 uDuration, cbReqCount, cbHeaderSize, cbFrameBodySize, cbFrameSize;
1690 int bNeedACK, bIsPSPOLL = false;
1691 u32 cbIVlen = 0, cbICVlen = 0, cbMIClen = 0, cbFCSlen = 4;
1692 u32 uPadding = 0;
1693 u16 wTxBufSize;
1694 u32 cbMacHdLen;
1695 u16 wCurrentRate = RATE_1M;
1696
1697 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
1698
1699 if (NULL == pContext) {
1700 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ManagementSend TX...NO CONTEXT!\n");
1701 return CMD_STATUS_RESOURCES;
1702 }
1703
1704 pTX_Buffer = (PTX_BUFFER) (&pContext->Data[0]);
1705 pbyTxBufferAddr = (u8 *)&(pTX_Buffer->adwTxKey[0]);
1706 cbFrameBodySize = pPacket->cbPayloadLen;
1707 pTxBufHead = (PSTxBufHead) pbyTxBufferAddr;
1708 wTxBufSize = sizeof(STxBufHead);
1709 memset(pTxBufHead, 0, wTxBufSize);
1710
1711 if (pDevice->byBBType == BB_TYPE_11A) {
1712 wCurrentRate = RATE_6M;
1713 byPktType = PK_TYPE_11A;
1714 } else {
1715 wCurrentRate = RATE_1M;
1716 byPktType = PK_TYPE_11B;
1717 }
1718
1719 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
1720 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
1721 // And cmd timer will wait data pkt TX finish before scanning so it's OK
1722 // to set power here.
1723 if (pMgmt->eScanState != WMAC_NO_SCANNING) {
1724 RFbSetPower(pDevice, wCurrentRate, pDevice->byCurrentCh);
1725 } else {
1726 RFbSetPower(pDevice, wCurrentRate, pMgmt->uCurrChannel);
1727 }
1728 pDevice->wCurrentRate = wCurrentRate;
1729
1730 //Set packet type
1731 if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
1732 pTxBufHead->wFIFOCtl = 0;
1733 }
1734 else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
1735 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
1736 }
1737 else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
1738 pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
1739 }
1740 else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
1741 pTxBufHead->wFIFOCtl |= FIFOCTL_11GA;
1742 }
1743
1744 pTxBufHead->wFIFOCtl |= FIFOCTL_TMOEN;
1745 pTxBufHead->wTimeStamp = cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
1746
1747 if (is_multicast_ether_addr(pPacket->p80211Header->sA3.abyAddr1)) {
1748 bNeedACK = false;
1749 }
1750 else {
1751 bNeedACK = true;
1752 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1753 };
1754
1755 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
1756 (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ) {
1757
1758 pTxBufHead->wFIFOCtl |= FIFOCTL_LRETRY;
1759 //Set Preamble type always long
1760 //pDevice->byPreambleType = PREAMBLE_LONG;
1761 // probe-response don't retry
1762 //if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
1763 // bNeedACK = false;
1764 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
1765 //}
1766 }
1767
1768 pTxBufHead->wFIFOCtl |= (FIFOCTL_GENINT | FIFOCTL_ISDMA0);
1769
1770 if ((pPacket->p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_CTL_PSPOLL) {
1771 bIsPSPOLL = true;
1772 cbMacHdLen = WLAN_HDR_ADDR2_LEN;
1773 } else {
1774 cbMacHdLen = WLAN_HDR_ADDR3_LEN;
1775 }
1776
1777 //Set FRAGCTL_MACHDCNT
1778 pTxBufHead->wFragCtl |= cpu_to_le16((u16)(cbMacHdLen << 10));
1779
1780 // Notes:
1781 // Although spec says MMPDU can be fragmented; In most case,
1782 // no one will send a MMPDU under fragmentation. With RTS may occur.
1783 pDevice->bAES = false; //Set FRAGCTL_WEPTYP
1784
1785 if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
1786 if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) {
1787 cbIVlen = 4;
1788 cbICVlen = 4;
1789 pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
1790 }
1791 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
1792 cbIVlen = 8;//IV+ExtIV
1793 cbMIClen = 8;
1794 cbICVlen = 4;
1795 pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
1796 //We need to get seed here for filling TxKey entry.
1797 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
1798 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
1799 }
1800 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
1801 cbIVlen = 8;//RSN Header
1802 cbICVlen = 8;//MIC
1803 pTxBufHead->wFragCtl |= FRAGCTL_AES;
1804 pDevice->bAES = true;
1805 }
1806 //MAC Header should be padding 0 to DW alignment.
1807 uPadding = 4 - (cbMacHdLen%4);
1808 uPadding %= 4;
1809 }
1810
1811 cbFrameSize = cbMacHdLen + cbFrameBodySize + cbIVlen + cbMIClen + cbICVlen + cbFCSlen;
1812
1813 //Set FIFOCTL_GrpAckPolicy
1814 if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
1815 pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
1816 }
1817 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
1818
1819 //Set RrvTime/RTS/CTS Buffer
1820 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1821
1822 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
1823 pMICHDR = NULL;
1824 pvRTS = NULL;
1825 pCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
1826 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + sizeof(SCTS));
1827 cbHeaderSize = wTxBufSize + sizeof(SRrvTime_gCTS) + sizeof(SCTS) + sizeof(STxDataHead_g);
1828 }
1829 else { // 802.11a/b packet
1830 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
1831 pMICHDR = NULL;
1832 pvRTS = NULL;
1833 pCTS = NULL;
1834 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
1835 cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + sizeof(STxDataHead_ab);
1836 }
1837
1838 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0,
1839 (cbHeaderSize - wTxBufSize));
1840
1841 memcpy(&(sEthHeader.h_dest[0]),
1842 &(pPacket->p80211Header->sA3.abyAddr1[0]),
1843 ETH_ALEN);
1844 memcpy(&(sEthHeader.h_source[0]),
1845 &(pPacket->p80211Header->sA3.abyAddr2[0]),
1846 ETH_ALEN);
1847 //=========================
1848 // No Fragmentation
1849 //=========================
1850 pTxBufHead->wFragCtl |= (u16)FRAGCTL_NONFRAG;
1851
1852 //Fill FIFO,RrvTime,RTS,and CTS
1853 s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate, pbyTxBufferAddr, pvRrvTime, pvRTS, pCTS,
1854 cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader);
1855
1856 //Fill DataHead
1857 uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
1858 0, 0, 1, AUTO_FB_NONE);
1859
1860 pMACHeader = (struct ieee80211_hdr *) (pbyTxBufferAddr + cbHeaderSize);
1861
1862 cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + cbFrameBodySize;
1863
1864 if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
1865 u8 * pbyIVHead;
1866 u8 * pbyPayloadHead;
1867 u8 * pbyBSSID;
1868 PSKeyItem pTransmitKey = NULL;
1869
1870 pbyIVHead = (u8 *)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding);
1871 pbyPayloadHead = (u8 *)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding + cbIVlen);
1872 do {
1873 if ((pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) &&
1874 (pDevice->bLinkPass == true)) {
1875 pbyBSSID = pDevice->abyBSSID;
1876 // get pairwise key
1877 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
1878 // get group key
1879 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
1880 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
1881 break;
1882 }
1883 } else {
1884 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get PTK.\n");
1885 break;
1886 }
1887 }
1888 // get group key
1889 pbyBSSID = pDevice->abyBroadcastAddr;
1890 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
1891 pTransmitKey = NULL;
1892 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KEY is NULL. OP Mode[%d]\n", pDevice->eOPMode);
1893 } else {
1894 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
1895 }
1896 } while(false);
1897 //Fill TXKEY
1898 s_vFillTxKey(pDevice, (u8 *)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
1899 (u8 *)pMACHeader, (u16)cbFrameBodySize, NULL);
1900
1901 memcpy(pMACHeader, pPacket->p80211Header, cbMacHdLen);
1902 memcpy(pbyPayloadHead, ((u8 *)(pPacket->p80211Header) + cbMacHdLen),
1903 cbFrameBodySize);
1904 }
1905 else {
1906 // Copy the Packet into a tx Buffer
1907 memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
1908 }
1909
1910 pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
1911 pDevice->wSeqCounter++ ;
1912 if (pDevice->wSeqCounter > 0x0fff)
1913 pDevice->wSeqCounter = 0;
1914
1915 if (bIsPSPOLL) {
1916 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
1917 // of FIFO control header.
1918 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
1919 // in the same place of other packet's Duration-field).
1920 // And it will cause Cisco-AP to issue Disassociation-packet
1921 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1922 ((PSTxDataHead_g)pvTxDataHd)->wDuration_a = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1923 ((PSTxDataHead_g)pvTxDataHd)->wDuration_b = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1924 } else {
1925 ((PSTxDataHead_ab)pvTxDataHd)->wDuration = cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1926 }
1927 }
1928
1929 pTX_Buffer->wTxByteCount = cpu_to_le16((u16)(cbReqCount));
1930 pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
1931 pTX_Buffer->byType = 0x00;
1932
1933 pContext->pPacket = NULL;
1934 pContext->Type = CONTEXT_MGMT_PACKET;
1935 pContext->uBufLen = (u16)cbReqCount + 4; //USB header
1936
1937 if (WLAN_GET_FC_TODS(pMACHeader->frame_control) == 0) {
1938 s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->addr1[0]), (u16)cbFrameSize, pTX_Buffer->wFIFOCtl);
1939 }
1940 else {
1941 s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->addr3[0]), (u16)cbFrameSize, pTX_Buffer->wFIFOCtl);
1942 }
1943
1944 PIPEnsSendBulkOut(pDevice,pContext);
1945 return CMD_STATUS_PENDING;
1946 }
1947
1948 CMD_STATUS csBeacon_xmit(struct vnt_private *pDevice,
1949 struct vnt_tx_mgmt *pPacket)
1950 {
1951 u32 cbFrameSize = pPacket->cbMPDULen + WLAN_FCS_LEN;
1952 u32 cbHeaderSize = 0;
1953 u16 wTxBufSize = sizeof(STxShortBufHead);
1954 PSTxShortBufHead pTxBufHead;
1955 struct ieee80211_hdr *pMACHeader;
1956 PSTxDataHead_ab pTxDataHead;
1957 u16 wCurrentRate;
1958 u32 cbFrameBodySize;
1959 u32 cbReqCount;
1960 PBEACON_BUFFER pTX_Buffer;
1961 u8 *pbyTxBufferAddr;
1962 PUSB_SEND_CONTEXT pContext;
1963 CMD_STATUS status;
1964
1965 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
1966 if (NULL == pContext) {
1967 status = CMD_STATUS_RESOURCES;
1968 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ManagementSend TX...NO CONTEXT!\n");
1969 return status ;
1970 }
1971 pTX_Buffer = (PBEACON_BUFFER) (&pContext->Data[0]);
1972 pbyTxBufferAddr = (u8 *)&(pTX_Buffer->wFIFOCtl);
1973
1974 cbFrameBodySize = pPacket->cbPayloadLen;
1975
1976 pTxBufHead = (PSTxShortBufHead) pbyTxBufferAddr;
1977 wTxBufSize = sizeof(STxShortBufHead);
1978 memset(pTxBufHead, 0, wTxBufSize);
1979
1980 if (pDevice->byBBType == BB_TYPE_11A) {
1981 wCurrentRate = RATE_6M;
1982 pTxDataHead = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize);
1983 //Get SignalField,ServiceField,Length
1984 BBvCalculateParameter(pDevice, cbFrameSize, wCurrentRate, PK_TYPE_11A,
1985 (u16 *)&(pTxDataHead->wTransmitLength), (u8 *)&(pTxDataHead->byServiceField), (u8 *)&(pTxDataHead->bySignalField)
1986 );
1987 //Get Duration and TimeStampOff
1988 pTxDataHead->wDuration = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameSize, PK_TYPE_11A,
1989 wCurrentRate, false, 0, 0, 1, AUTO_FB_NONE));
1990 pTxDataHead->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
1991 cbHeaderSize = wTxBufSize + sizeof(STxDataHead_ab);
1992 } else {
1993 wCurrentRate = RATE_1M;
1994 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
1995 pTxDataHead = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize);
1996 //Get SignalField,ServiceField,Length
1997 BBvCalculateParameter(pDevice, cbFrameSize, wCurrentRate, PK_TYPE_11B,
1998 (u16 *)&(pTxDataHead->wTransmitLength), (u8 *)&(pTxDataHead->byServiceField), (u8 *)&(pTxDataHead->bySignalField)
1999 );
2000 //Get Duration and TimeStampOff
2001 pTxDataHead->wDuration = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameSize, PK_TYPE_11B,
2002 wCurrentRate, false, 0, 0, 1, AUTO_FB_NONE));
2003 pTxDataHead->wTimeStampOff = wTimeStampOff[pDevice->byPreambleType%2][wCurrentRate%MAX_RATE];
2004 cbHeaderSize = wTxBufSize + sizeof(STxDataHead_ab);
2005 }
2006
2007 //Generate Beacon Header
2008 pMACHeader = (struct ieee80211_hdr *)(pbyTxBufferAddr + cbHeaderSize);
2009 memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
2010
2011 pMACHeader->duration_id = 0;
2012 pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
2013 pDevice->wSeqCounter++ ;
2014 if (pDevice->wSeqCounter > 0x0fff)
2015 pDevice->wSeqCounter = 0;
2016
2017 cbReqCount = cbHeaderSize + WLAN_HDR_ADDR3_LEN + cbFrameBodySize;
2018
2019 pTX_Buffer->wTxByteCount = (u16)cbReqCount;
2020 pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2021 pTX_Buffer->byType = 0x01;
2022
2023 pContext->pPacket = NULL;
2024 pContext->Type = CONTEXT_MGMT_PACKET;
2025 pContext->uBufLen = (u16)cbReqCount + 4; //USB header
2026
2027 PIPEnsSendBulkOut(pDevice,pContext);
2028 return CMD_STATUS_PENDING;
2029
2030 }
2031
2032 void vDMA0_tx_80211(struct vnt_private *pDevice, struct sk_buff *skb)
2033 {
2034 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
2035 u8 byPktType;
2036 u8 *pbyTxBufferAddr;
2037 void *pvRTS, *pvCTS, *pvTxDataHd;
2038 u32 uDuration, cbReqCount;
2039 struct ieee80211_hdr *pMACHeader;
2040 u32 cbHeaderSize, cbFrameBodySize;
2041 int bNeedACK, bIsPSPOLL = false;
2042 PSTxBufHead pTxBufHead;
2043 u32 cbFrameSize;
2044 u32 cbIVlen = 0, cbICVlen = 0, cbMIClen = 0, cbFCSlen = 4;
2045 u32 uPadding = 0;
2046 u32 cbMICHDR = 0, uLength = 0;
2047 u32 dwMICKey0, dwMICKey1;
2048 u32 dwMIC_Priority;
2049 u32 *pdwMIC_L, *pdwMIC_R;
2050 u16 wTxBufSize;
2051 u32 cbMacHdLen;
2052 struct ethhdr sEthHeader;
2053 void *pvRrvTime, *pMICHDR;
2054 u32 wCurrentRate = RATE_1M;
2055 PUWLAN_80211HDR p80211Header;
2056 u32 uNodeIndex = 0;
2057 int bNodeExist = false;
2058 SKeyItem STempKey;
2059 PSKeyItem pTransmitKey = NULL;
2060 u8 *pbyIVHead, *pbyPayloadHead, *pbyMacHdr;
2061 u32 cbExtSuppRate = 0;
2062 PTX_BUFFER pTX_Buffer;
2063 PUSB_SEND_CONTEXT pContext;
2064
2065 pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL;
2066
2067 if(skb->len <= WLAN_HDR_ADDR3_LEN) {
2068 cbFrameBodySize = 0;
2069 }
2070 else {
2071 cbFrameBodySize = skb->len - WLAN_HDR_ADDR3_LEN;
2072 }
2073 p80211Header = (PUWLAN_80211HDR)skb->data;
2074
2075 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2076
2077 if (NULL == pContext) {
2078 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0 TX...NO CONTEXT!\n");
2079 dev_kfree_skb_irq(skb);
2080 return ;
2081 }
2082
2083 pTX_Buffer = (PTX_BUFFER)(&pContext->Data[0]);
2084 pbyTxBufferAddr = (u8 *)(&pTX_Buffer->adwTxKey[0]);
2085 pTxBufHead = (PSTxBufHead) pbyTxBufferAddr;
2086 wTxBufSize = sizeof(STxBufHead);
2087 memset(pTxBufHead, 0, wTxBufSize);
2088
2089 if (pDevice->byBBType == BB_TYPE_11A) {
2090 wCurrentRate = RATE_6M;
2091 byPktType = PK_TYPE_11A;
2092 } else {
2093 wCurrentRate = RATE_1M;
2094 byPktType = PK_TYPE_11B;
2095 }
2096
2097 // SetPower will cause error power TX state for OFDM Date packet in TX buffer.
2098 // 2004.11.11 Kyle -- Using OFDM power to tx MngPkt will decrease the connection capability.
2099 // And cmd timer will wait data pkt TX finish before scanning so it's OK
2100 // to set power here.
2101 if (pMgmt->eScanState != WMAC_NO_SCANNING) {
2102 RFbSetPower(pDevice, wCurrentRate, pDevice->byCurrentCh);
2103 } else {
2104 RFbSetPower(pDevice, wCurrentRate, pMgmt->uCurrChannel);
2105 }
2106
2107 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"vDMA0_tx_80211: p80211Header->sA3.wFrameCtl = %x \n", p80211Header->sA3.wFrameCtl);
2108
2109 //Set packet type
2110 if (byPktType == PK_TYPE_11A) {//0000 0000 0000 0000
2111 pTxBufHead->wFIFOCtl = 0;
2112 }
2113 else if (byPktType == PK_TYPE_11B) {//0000 0001 0000 0000
2114 pTxBufHead->wFIFOCtl |= FIFOCTL_11B;
2115 }
2116 else if (byPktType == PK_TYPE_11GB) {//0000 0010 0000 0000
2117 pTxBufHead->wFIFOCtl |= FIFOCTL_11GB;
2118 }
2119 else if (byPktType == PK_TYPE_11GA) {//0000 0011 0000 0000
2120 pTxBufHead->wFIFOCtl |= FIFOCTL_11GA;
2121 }
2122
2123 pTxBufHead->wFIFOCtl |= FIFOCTL_TMOEN;
2124 pTxBufHead->wTimeStamp = cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
2125
2126 if (is_multicast_ether_addr(p80211Header->sA3.abyAddr1)) {
2127 bNeedACK = false;
2128 if (pDevice->bEnableHostWEP) {
2129 uNodeIndex = 0;
2130 bNodeExist = true;
2131 }
2132 }
2133 else {
2134 if (pDevice->bEnableHostWEP) {
2135 if (BSSbIsSTAInNodeDB(pDevice, (u8 *)(p80211Header->sA3.abyAddr1), &uNodeIndex))
2136 bNodeExist = true;
2137 }
2138 bNeedACK = true;
2139 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
2140 };
2141
2142 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) ||
2143 (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) ) {
2144
2145 pTxBufHead->wFIFOCtl |= FIFOCTL_LRETRY;
2146 //Set Preamble type always long
2147 //pDevice->byPreambleType = PREAMBLE_LONG;
2148
2149 // probe-response don't retry
2150 //if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_MGMT_PROBE_RSP) {
2151 // bNeedACK = false;
2152 // pTxBufHead->wFIFOCtl &= (~FIFOCTL_NEEDACK);
2153 //}
2154 }
2155
2156 pTxBufHead->wFIFOCtl |= (FIFOCTL_GENINT | FIFOCTL_ISDMA0);
2157
2158 if ((p80211Header->sA4.wFrameCtl & TYPE_SUBTYPE_MASK) == TYPE_CTL_PSPOLL) {
2159 bIsPSPOLL = true;
2160 cbMacHdLen = WLAN_HDR_ADDR2_LEN;
2161 } else {
2162 cbMacHdLen = WLAN_HDR_ADDR3_LEN;
2163 }
2164
2165 // hostapd daemon ext support rate patch
2166 if (WLAN_GET_FC_FSTYPE(p80211Header->sA4.wFrameCtl) == WLAN_FSTYPE_ASSOCRESP) {
2167
2168 if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len != 0) {
2169 cbExtSuppRate += ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN;
2170 }
2171
2172 if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len != 0) {
2173 cbExtSuppRate += ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len + WLAN_IEHDR_LEN;
2174 }
2175
2176 if (cbExtSuppRate >0) {
2177 cbFrameBodySize = WLAN_ASSOCRESP_OFF_SUPP_RATES;
2178 }
2179 }
2180
2181 //Set FRAGCTL_MACHDCNT
2182 pTxBufHead->wFragCtl |= cpu_to_le16((u16)cbMacHdLen << 10);
2183
2184 // Notes:
2185 // Although spec says MMPDU can be fragmented; In most case,
2186 // no one will send a MMPDU under fragmentation. With RTS may occur.
2187 pDevice->bAES = false; //Set FRAGCTL_WEPTYP
2188
2189 if (WLAN_GET_FC_ISWEP(p80211Header->sA4.wFrameCtl) != 0) {
2190 if (pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) {
2191 cbIVlen = 4;
2192 cbICVlen = 4;
2193 pTxBufHead->wFragCtl |= FRAGCTL_LEGACY;
2194 }
2195 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) {
2196 cbIVlen = 8;//IV+ExtIV
2197 cbMIClen = 8;
2198 cbICVlen = 4;
2199 pTxBufHead->wFragCtl |= FRAGCTL_TKIP;
2200 //We need to get seed here for filling TxKey entry.
2201 //TKIPvMixKey(pTransmitKey->abyKey, pDevice->abyCurrentNetAddr,
2202 // pTransmitKey->wTSC15_0, pTransmitKey->dwTSC47_16, pDevice->abyPRNG);
2203 }
2204 else if (pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) {
2205 cbIVlen = 8;//RSN Header
2206 cbICVlen = 8;//MIC
2207 cbMICHDR = sizeof(SMICHDRHead);
2208 pTxBufHead->wFragCtl |= FRAGCTL_AES;
2209 pDevice->bAES = true;
2210 }
2211 //MAC Header should be padding 0 to DW alignment.
2212 uPadding = 4 - (cbMacHdLen%4);
2213 uPadding %= 4;
2214 }
2215
2216 cbFrameSize = cbMacHdLen + cbFrameBodySize + cbIVlen + cbMIClen + cbICVlen + cbFCSlen + cbExtSuppRate;
2217
2218 //Set FIFOCTL_GrpAckPolicy
2219 if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
2220 pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
2221 }
2222 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
2223
2224 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
2225
2226 pvRrvTime = (PSRrvTime_gCTS) (pbyTxBufferAddr + wTxBufSize);
2227 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS));
2228 pvRTS = NULL;
2229 pvCTS = (PSCTS) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR);
2230 pvTxDataHd = (PSTxDataHead_g) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS));
2231 cbHeaderSize = wTxBufSize + sizeof(SRrvTime_gCTS) + cbMICHDR + sizeof(SCTS) + sizeof(STxDataHead_g);
2232
2233 }
2234 else {//802.11a/b packet
2235
2236 pvRrvTime = (PSRrvTime_ab) (pbyTxBufferAddr + wTxBufSize);
2237 pMICHDR = (PSMICHDRHead) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab));
2238 pvRTS = NULL;
2239 pvCTS = NULL;
2240 pvTxDataHd = (PSTxDataHead_ab) (pbyTxBufferAddr + wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR);
2241 cbHeaderSize = wTxBufSize + sizeof(SRrvTime_ab) + cbMICHDR + sizeof(STxDataHead_ab);
2242 }
2243 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0,
2244 (cbHeaderSize - wTxBufSize));
2245 memcpy(&(sEthHeader.h_dest[0]),
2246 &(p80211Header->sA3.abyAddr1[0]),
2247 ETH_ALEN);
2248 memcpy(&(sEthHeader.h_source[0]),
2249 &(p80211Header->sA3.abyAddr2[0]),
2250 ETH_ALEN);
2251 //=========================
2252 // No Fragmentation
2253 //=========================
2254 pTxBufHead->wFragCtl |= (u16)FRAGCTL_NONFRAG;
2255
2256 //Fill FIFO,RrvTime,RTS,and CTS
2257 s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate, pbyTxBufferAddr, pvRrvTime, pvRTS, pvCTS,
2258 cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader);
2259
2260 //Fill DataHead
2261 uDuration = s_uFillDataHead(pDevice, byPktType, wCurrentRate, pvTxDataHd, cbFrameSize, TYPE_TXDMA0, bNeedACK,
2262 0, 0, 1, AUTO_FB_NONE);
2263
2264 pMACHeader = (struct ieee80211_hdr *) (pbyTxBufferAddr + cbHeaderSize);
2265
2266 cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + (cbFrameBodySize + cbMIClen) + cbExtSuppRate;
2267
2268 pbyMacHdr = (u8 *)(pbyTxBufferAddr + cbHeaderSize);
2269 pbyPayloadHead = (u8 *)(pbyMacHdr + cbMacHdLen + uPadding + cbIVlen);
2270 pbyIVHead = (u8 *)(pbyMacHdr + cbMacHdLen + uPadding);
2271
2272 // Copy the Packet into a tx Buffer
2273 memcpy(pbyMacHdr, skb->data, cbMacHdLen);
2274
2275 // version set to 0, patch for hostapd deamon
2276 pMACHeader->frame_control &= cpu_to_le16(0xfffc);
2277 memcpy(pbyPayloadHead, (skb->data + cbMacHdLen), cbFrameBodySize);
2278
2279 // replace support rate, patch for hostapd daemon( only support 11M)
2280 if (WLAN_GET_FC_FSTYPE(p80211Header->sA4.wFrameCtl) == WLAN_FSTYPE_ASSOCRESP) {
2281 if (cbExtSuppRate != 0) {
2282 if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len != 0)
2283 memcpy((pbyPayloadHead + cbFrameBodySize),
2284 pMgmt->abyCurrSuppRates,
2285 ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN
2286 );
2287 if (((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len != 0)
2288 memcpy((pbyPayloadHead + cbFrameBodySize) + ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrSuppRates)->len + WLAN_IEHDR_LEN,
2289 pMgmt->abyCurrExtSuppRates,
2290 ((PWLAN_IE_SUPP_RATES)pMgmt->abyCurrExtSuppRates)->len + WLAN_IEHDR_LEN
2291 );
2292 }
2293 }
2294
2295 // Set wep
2296 if (WLAN_GET_FC_ISWEP(p80211Header->sA4.wFrameCtl) != 0) {
2297
2298 if (pDevice->bEnableHostWEP) {
2299 pTransmitKey = &STempKey;
2300 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2301 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2302 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2303 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2304 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2305 memcpy(pTransmitKey->abyKey,
2306 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2307 pTransmitKey->uKeyLength
2308 );
2309 }
2310
2311 if ((pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
2312
2313 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
2314 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
2315
2316 // DO Software Michael
2317 MIC_vInit(dwMICKey0, dwMICKey1);
2318 MIC_vAppend((u8 *)&(sEthHeader.h_dest[0]), 12);
2319 dwMIC_Priority = 0;
2320 MIC_vAppend((u8 *)&dwMIC_Priority, 4);
2321 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0_tx_8021:MIC KEY:"\
2322 " %X, %X\n", dwMICKey0, dwMICKey1);
2323
2324 uLength = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen;
2325
2326 MIC_vAppend((pbyTxBufferAddr + uLength), cbFrameBodySize);
2327
2328 pdwMIC_L = (u32 *)(pbyTxBufferAddr + uLength + cbFrameBodySize);
2329 pdwMIC_R = (u32 *)(pbyTxBufferAddr + uLength + cbFrameBodySize + 4);
2330
2331 MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
2332 MIC_vUnInit();
2333
2334 if (pDevice->bTxMICFail == true) {
2335 *pdwMIC_L = 0;
2336 *pdwMIC_R = 0;
2337 pDevice->bTxMICFail = false;
2338 }
2339
2340 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"uLength: %d, %d\n", uLength, cbFrameBodySize);
2341 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"cbReqCount:%d, %d, %d, %d\n", cbReqCount, cbHeaderSize, uPadding, cbIVlen);
2342 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%x, %x\n",
2343 *pdwMIC_L, *pdwMIC_R);
2344
2345 }
2346
2347 s_vFillTxKey(pDevice, (u8 *)(pTxBufHead->adwTxKey), pbyIVHead, pTransmitKey,
2348 pbyMacHdr, (u16)cbFrameBodySize, (u8 *)pMICHDR);
2349
2350 if (pDevice->bEnableHostWEP) {
2351 pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16 = pTransmitKey->dwTSC47_16;
2352 pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0 = pTransmitKey->wTSC15_0;
2353 }
2354
2355 if ((pDevice->byLocalID <= REV_ID_VT3253_A1)) {
2356 s_vSWencryption(pDevice, pTransmitKey, pbyPayloadHead, (u16)(cbFrameBodySize + cbMIClen));
2357 }
2358 }
2359
2360 pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
2361 pDevice->wSeqCounter++ ;
2362 if (pDevice->wSeqCounter > 0x0fff)
2363 pDevice->wSeqCounter = 0;
2364
2365 if (bIsPSPOLL) {
2366 // The MAC will automatically replace the Duration-field of MAC header by Duration-field
2367 // of FIFO control header.
2368 // This will cause AID-field of PS-POLL packet be incorrect (Because PS-POLL's AID field is
2369 // in the same place of other packet's Duration-field).
2370 // And it will cause Cisco-AP to issue Disassociation-packet
2371 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
2372 ((PSTxDataHead_g)pvTxDataHd)->wDuration_a = cpu_to_le16(p80211Header->sA2.wDurationID);
2373 ((PSTxDataHead_g)pvTxDataHd)->wDuration_b = cpu_to_le16(p80211Header->sA2.wDurationID);
2374 } else {
2375 ((PSTxDataHead_ab)pvTxDataHd)->wDuration = cpu_to_le16(p80211Header->sA2.wDurationID);
2376 }
2377 }
2378
2379 pTX_Buffer->wTxByteCount = cpu_to_le16((u16)(cbReqCount));
2380 pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2381 pTX_Buffer->byType = 0x00;
2382
2383 pContext->pPacket = skb;
2384 pContext->Type = CONTEXT_MGMT_PACKET;
2385 pContext->uBufLen = (u16)cbReqCount + 4; //USB header
2386
2387 if (WLAN_GET_FC_TODS(pMACHeader->frame_control) == 0) {
2388 s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->addr1[0]), (u16)cbFrameSize, pTX_Buffer->wFIFOCtl);
2389 }
2390 else {
2391 s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pMACHeader->addr3[0]), (u16)cbFrameSize, pTX_Buffer->wFIFOCtl);
2392 }
2393 PIPEnsSendBulkOut(pDevice,pContext);
2394 return ;
2395
2396 }
2397
2398 //TYPE_AC0DMA data tx
2399 /*
2400 * Description:
2401 * Tx packet via AC0DMA(DMA1)
2402 *
2403 * Parameters:
2404 * In:
2405 * pDevice - Pointer to the adapter
2406 * skb - Pointer to tx skb packet
2407 * Out:
2408 * void
2409 *
2410 * Return Value: NULL
2411 */
2412
2413 int nsDMA_tx_packet(struct vnt_private *pDevice,
2414 u32 uDMAIdx, struct sk_buff *skb)
2415 {
2416 struct net_device_stats *pStats = &pDevice->stats;
2417 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
2418 u32 BytesToWrite = 0, uHeaderLen = 0;
2419 u32 uNodeIndex = 0;
2420 u8 byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2421 u16 wAID;
2422 u8 byPktType;
2423 int bNeedEncryption = false;
2424 PSKeyItem pTransmitKey = NULL;
2425 SKeyItem STempKey;
2426 int ii;
2427 int bTKIP_UseGTK = false;
2428 int bNeedDeAuth = false;
2429 u8 *pbyBSSID;
2430 int bNodeExist = false;
2431 PUSB_SEND_CONTEXT pContext;
2432 bool fConvertedPacket;
2433 PTX_BUFFER pTX_Buffer;
2434 u32 status;
2435 u16 wKeepRate = pDevice->wCurrentRate;
2436 int bTxeapol_key = false;
2437
2438 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2439
2440 if (pDevice->uAssocCount == 0) {
2441 dev_kfree_skb_irq(skb);
2442 return 0;
2443 }
2444
2445 if (is_multicast_ether_addr((u8 *)(skb->data))) {
2446 uNodeIndex = 0;
2447 bNodeExist = true;
2448 if (pMgmt->sNodeDBTable[0].bPSEnable) {
2449
2450 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2451 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2452 // set tx map
2453 pMgmt->abyPSTxMap[0] |= byMask[0];
2454 return 0;
2455 }
2456 // multicast/broadcast data rate
2457
2458 if (pDevice->byBBType != BB_TYPE_11A)
2459 pDevice->wCurrentRate = RATE_2M;
2460 else
2461 pDevice->wCurrentRate = RATE_24M;
2462 // long preamble type
2463 pDevice->byPreambleType = PREAMBLE_SHORT;
2464
2465 }else {
2466
2467 if (BSSbIsSTAInNodeDB(pDevice, (u8 *)(skb->data), &uNodeIndex)) {
2468
2469 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2470
2471 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2472
2473 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2474 // set tx map
2475 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2476 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
2477 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2478 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2479
2480 return 0;
2481 }
2482 // AP rate decided from node
2483 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2484 // tx preamble decided from node
2485
2486 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2487 pDevice->byPreambleType = pDevice->byShortPreamble;
2488
2489 }else {
2490 pDevice->byPreambleType = PREAMBLE_LONG;
2491 }
2492 bNodeExist = true;
2493 }
2494 }
2495
2496 if (bNodeExist == false) {
2497 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2498 dev_kfree_skb_irq(skb);
2499 return 0;
2500 }
2501 }
2502
2503 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2504
2505 if (pContext == NULL) {
2506 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG" pContext == NULL\n");
2507 dev_kfree_skb_irq(skb);
2508 return STATUS_RESOURCES;
2509 }
2510
2511 memcpy(pDevice->sTxEthHeader.h_dest, (u8 *)(skb->data), ETH_HLEN);
2512
2513 //mike add:station mode check eapol-key challenge--->
2514 {
2515 u8 Protocol_Version; //802.1x Authentication
2516 u8 Packet_Type; //802.1x Authentication
2517 u8 Descriptor_type;
2518 u16 Key_info;
2519
2520 Protocol_Version = skb->data[ETH_HLEN];
2521 Packet_Type = skb->data[ETH_HLEN+1];
2522 Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2523 Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2524 if (pDevice->sTxEthHeader.h_proto == cpu_to_be16(ETH_P_PAE)) {
2525 /* 802.1x OR eapol-key challenge frame transfer */
2526 if (((Protocol_Version == 1) || (Protocol_Version == 2)) &&
2527 (Packet_Type == 3)) {
2528 bTxeapol_key = true;
2529 if(!(Key_info & BIT3) && //WPA or RSN group-key challenge
2530 (Key_info & BIT8) && (Key_info & BIT9)) { //send 2/2 key
2531 if(Descriptor_type==254) {
2532 pDevice->fWPA_Authened = true;
2533 PRINT_K("WPA ");
2534 }
2535 else {
2536 pDevice->fWPA_Authened = true;
2537 PRINT_K("WPA2(re-keying) ");
2538 }
2539 PRINT_K("Authentication completed!!\n");
2540 }
2541 else if((Key_info & BIT3) && (Descriptor_type==2) && //RSN pairwise-key challenge
2542 (Key_info & BIT8) && (Key_info & BIT9)) {
2543 pDevice->fWPA_Authened = true;
2544 PRINT_K("WPA2 Authentication completed!!\n");
2545 }
2546 }
2547 }
2548 }
2549 //mike add:station mode check eapol-key challenge<---
2550
2551 if (pDevice->bEncryptionEnable == true) {
2552 bNeedEncryption = true;
2553 // get Transmit key
2554 do {
2555 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2556 (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2557 pbyBSSID = pDevice->abyBSSID;
2558 // get pairwise key
2559 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2560 // get group key
2561 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
2562 bTKIP_UseGTK = true;
2563 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2564 break;
2565 }
2566 } else {
2567 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2568 break;
2569 }
2570 }else if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2571 /* TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1 */
2572 pbyBSSID = pDevice->sTxEthHeader.h_dest;
2573 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2574 for (ii = 0; ii< 6; ii++)
2575 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2576 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2577
2578 // get pairwise key
2579 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2580 break;
2581 }
2582 // get group key
2583 pbyBSSID = pDevice->abyBroadcastAddr;
2584 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2585 pTransmitKey = NULL;
2586 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2587 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2588 }
2589 else
2590 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2591 } else {
2592 bTKIP_UseGTK = true;
2593 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2594 }
2595 } while(false);
2596 }
2597
2598 if (pDevice->bEnableHostWEP) {
2599 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2600 if (pDevice->bEncryptionEnable == true) {
2601 pTransmitKey = &STempKey;
2602 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2603 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2604 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2605 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2606 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2607 memcpy(pTransmitKey->abyKey,
2608 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2609 pTransmitKey->uKeyLength
2610 );
2611 }
2612 }
2613
2614 byPktType = (u8)pDevice->byPacketType;
2615
2616 if (pDevice->bFixRate) {
2617 if (pDevice->byBBType == BB_TYPE_11B) {
2618 if (pDevice->uConnectionRate >= RATE_11M) {
2619 pDevice->wCurrentRate = RATE_11M;
2620 } else {
2621 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2622 }
2623 } else {
2624 if ((pDevice->byBBType == BB_TYPE_11A) &&
2625 (pDevice->uConnectionRate <= RATE_6M)) {
2626 pDevice->wCurrentRate = RATE_6M;
2627 } else {
2628 if (pDevice->uConnectionRate >= RATE_54M)
2629 pDevice->wCurrentRate = RATE_54M;
2630 else
2631 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2632 }
2633 }
2634 }
2635 else {
2636 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2637 // Adhoc Tx rate decided from node DB
2638 if (is_multicast_ether_addr(pDevice->sTxEthHeader.h_dest)) {
2639 // Multicast use highest data rate
2640 pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2641 // preamble type
2642 pDevice->byPreambleType = pDevice->byShortPreamble;
2643 }
2644 else {
2645 if (BSSbIsSTAInNodeDB(pDevice, &(pDevice->sTxEthHeader.h_dest[0]), &uNodeIndex)) {
2646 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2647 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2648 pDevice->byPreambleType = pDevice->byShortPreamble;
2649
2650 }
2651 else {
2652 pDevice->byPreambleType = PREAMBLE_LONG;
2653 }
2654 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Found Node Index is [%d] Tx Data Rate:[%d]\n",uNodeIndex, pDevice->wCurrentRate);
2655 }
2656 else {
2657 if (pDevice->byBBType != BB_TYPE_11A)
2658 pDevice->wCurrentRate = RATE_2M;
2659 else
2660 pDevice->wCurrentRate = RATE_24M; // refer to vMgrCreateOwnIBSS()'s
2661 // abyCurrExtSuppRates[]
2662 pDevice->byPreambleType = PREAMBLE_SHORT;
2663 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Not Found Node use highest basic Rate.....\n");
2664 }
2665 }
2666 }
2667 if (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE) {
2668 // Infra STA rate decided from AP Node, index = 0
2669 pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2670 }
2671 }
2672
2673 if (pDevice->sTxEthHeader.h_proto == cpu_to_be16(ETH_P_PAE)) {
2674 if (pDevice->byBBType != BB_TYPE_11A) {
2675 pDevice->wCurrentRate = RATE_1M;
2676 pDevice->byACKRate = RATE_1M;
2677 pDevice->byTopCCKBasicRate = RATE_1M;
2678 pDevice->byTopOFDMBasicRate = RATE_6M;
2679 } else {
2680 pDevice->wCurrentRate = RATE_6M;
2681 pDevice->byACKRate = RATE_6M;
2682 pDevice->byTopCCKBasicRate = RATE_1M;
2683 pDevice->byTopOFDMBasicRate = RATE_6M;
2684 }
2685 }
2686
2687 DBG_PRT(MSG_LEVEL_DEBUG,
2688 KERN_INFO "dma_tx: pDevice->wCurrentRate = %d\n",
2689 pDevice->wCurrentRate);
2690
2691 if (wKeepRate != pDevice->wCurrentRate) {
2692 bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
2693 }
2694
2695 if (pDevice->wCurrentRate <= RATE_11M) {
2696 byPktType = PK_TYPE_11B;
2697 }
2698
2699 if (bNeedEncryption == true) {
2700 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.h_proto));
2701 if ((pDevice->sTxEthHeader.h_proto) == cpu_to_be16(ETH_P_PAE)) {
2702 bNeedEncryption = false;
2703 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.h_proto));
2704 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2705 if (pTransmitKey == NULL) {
2706 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
2707 }
2708 else {
2709 if (bTKIP_UseGTK == true) {
2710 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
2711 }
2712 else {
2713 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%X]\n",
2714 pTransmitKey->dwKeyIndex);
2715 bNeedEncryption = true;
2716 }
2717 }
2718 }
2719
2720 if (pDevice->bEnableHostWEP) {
2721 if ((uNodeIndex != 0) &&
2722 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2723 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%X]\n",
2724 pTransmitKey->dwKeyIndex);
2725 bNeedEncryption = true;
2726 }
2727 }
2728 }
2729 else {
2730
2731 if (pTransmitKey == NULL) {
2732 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
2733 pContext->bBoolInUse = false;
2734 dev_kfree_skb_irq(skb);
2735 pStats->tx_dropped++;
2736 return STATUS_FAILURE;
2737 }
2738 }
2739 }
2740
2741 fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
2742 (u8 *)(&pContext->Data[0]), bNeedEncryption,
2743 skb->len, uDMAIdx, &pDevice->sTxEthHeader,
2744 (u8 *)skb->data, pTransmitKey, uNodeIndex,
2745 pDevice->wCurrentRate,
2746 &uHeaderLen, &BytesToWrite
2747 );
2748
2749 if (fConvertedPacket == false) {
2750 pContext->bBoolInUse = false;
2751 dev_kfree_skb_irq(skb);
2752 return STATUS_FAILURE;
2753 }
2754
2755 if ( pDevice->bEnablePSMode == true ) {
2756 if ( !pDevice->bPSModeTxBurst ) {
2757 bScheduleCommand((void *) pDevice,
2758 WLAN_CMD_MAC_DISPOWERSAVING,
2759 NULL);
2760 pDevice->bPSModeTxBurst = true;
2761 }
2762 }
2763
2764 pTX_Buffer = (PTX_BUFFER)&(pContext->Data[0]);
2765 pTX_Buffer->byPKTNO = (u8) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2766 pTX_Buffer->wTxByteCount = (u16)BytesToWrite;
2767
2768 pContext->pPacket = skb;
2769 pContext->Type = CONTEXT_DATA_PACKET;
2770 pContext->uBufLen = (u16)BytesToWrite + 4 ; //USB header
2771
2772 s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pContext->sEthHeader.h_dest[0]), (u16) (BytesToWrite-uHeaderLen), pTX_Buffer->wFIFOCtl);
2773
2774 status = PIPEnsSendBulkOut(pDevice,pContext);
2775
2776 if (bNeedDeAuth == true) {
2777 u16 wReason = WLAN_MGMT_REASON_MIC_FAILURE;
2778
2779 bScheduleCommand((void *) pDevice, WLAN_CMD_DEAUTH, (u8 *) &wReason);
2780 }
2781
2782 if(status!=STATUS_PENDING) {
2783 pContext->bBoolInUse = false;
2784 dev_kfree_skb_irq(skb);
2785 return STATUS_FAILURE;
2786 }
2787 else
2788 return 0;
2789
2790 }
2791
2792 /*
2793 * Description:
2794 * Relay packet send (AC1DMA) from rx dpc.
2795 *
2796 * Parameters:
2797 * In:
2798 * pDevice - Pointer to the adapter
2799 * pPacket - Pointer to rx packet
2800 * cbPacketSize - rx ethernet frame size
2801 * Out:
2802 * TURE, false
2803 *
2804 * Return Value: Return true if packet is copy to dma1; otherwise false
2805 */
2806
2807 int bRelayPacketSend(struct vnt_private *pDevice, u8 *pbySkbData, u32 uDataLen,
2808 u32 uNodeIndex)
2809 {
2810 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
2811 u32 BytesToWrite = 0, uHeaderLen = 0;
2812 u8 byPktType = PK_TYPE_11B;
2813 int bNeedEncryption = false;
2814 SKeyItem STempKey;
2815 PSKeyItem pTransmitKey = NULL;
2816 u8 *pbyBSSID;
2817 PUSB_SEND_CONTEXT pContext;
2818 u8 byPktTyp;
2819 int fConvertedPacket;
2820 PTX_BUFFER pTX_Buffer;
2821 u32 status;
2822 u16 wKeepRate = pDevice->wCurrentRate;
2823
2824 pContext = (PUSB_SEND_CONTEXT)s_vGetFreeContext(pDevice);
2825
2826 if (NULL == pContext) {
2827 return false;
2828 }
2829
2830 memcpy(pDevice->sTxEthHeader.h_dest, (u8 *)pbySkbData, ETH_HLEN);
2831
2832 if (pDevice->bEncryptionEnable == true) {
2833 bNeedEncryption = true;
2834 // get group key
2835 pbyBSSID = pDevice->abyBroadcastAddr;
2836 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2837 pTransmitKey = NULL;
2838 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"KEY is NULL. [%d]\n", pMgmt->eCurrMode);
2839 } else {
2840 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2841 }
2842 }
2843
2844 if (pDevice->bEnableHostWEP) {
2845 if (uNodeIndex < MAX_NODE_NUM + 1) {
2846 pTransmitKey = &STempKey;
2847 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2848 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2849 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2850 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2851 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2852 memcpy(pTransmitKey->abyKey,
2853 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2854 pTransmitKey->uKeyLength
2855 );
2856 }
2857 }
2858
2859 if ( bNeedEncryption && (pTransmitKey == NULL) ) {
2860 pContext->bBoolInUse = false;
2861 return false;
2862 }
2863
2864 byPktTyp = (u8)pDevice->byPacketType;
2865
2866 if (pDevice->bFixRate) {
2867 if (pDevice->byBBType == BB_TYPE_11B) {
2868 if (pDevice->uConnectionRate >= RATE_11M) {
2869 pDevice->wCurrentRate = RATE_11M;
2870 } else {
2871 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2872 }
2873 } else {
2874 if ((pDevice->byBBType == BB_TYPE_11A) &&
2875 (pDevice->uConnectionRate <= RATE_6M)) {
2876 pDevice->wCurrentRate = RATE_6M;
2877 } else {
2878 if (pDevice->uConnectionRate >= RATE_54M)
2879 pDevice->wCurrentRate = RATE_54M;
2880 else
2881 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2882 }
2883 }
2884 }
2885 else {
2886 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2887 }
2888
2889 if (wKeepRate != pDevice->wCurrentRate) {
2890 bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
2891 }
2892
2893 if (pDevice->wCurrentRate <= RATE_11M)
2894 byPktType = PK_TYPE_11B;
2895
2896 BytesToWrite = uDataLen + ETH_FCS_LEN;
2897
2898 // Convert the packet to an usb frame and copy into our buffer
2899 // and send the irp.
2900
2901 fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
2902 (u8 *)(&pContext->Data[0]), bNeedEncryption,
2903 uDataLen, TYPE_AC0DMA, &pDevice->sTxEthHeader,
2904 pbySkbData, pTransmitKey, uNodeIndex,
2905 pDevice->wCurrentRate,
2906 &uHeaderLen, &BytesToWrite
2907 );
2908
2909 if (fConvertedPacket == false) {
2910 pContext->bBoolInUse = false;
2911 return false;
2912 }
2913
2914 pTX_Buffer = (PTX_BUFFER)&(pContext->Data[0]);
2915 pTX_Buffer->byPKTNO = (u8) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2916 pTX_Buffer->wTxByteCount = (u16)BytesToWrite;
2917
2918 pContext->pPacket = NULL;
2919 pContext->Type = CONTEXT_DATA_PACKET;
2920 pContext->uBufLen = (u16)BytesToWrite + 4 ; //USB header
2921
2922 s_vSaveTxPktInfo(pDevice, (u8) (pTX_Buffer->byPKTNO & 0x0F), &(pContext->sEthHeader.h_dest[0]), (u16) (BytesToWrite-uHeaderLen), pTX_Buffer->wFIFOCtl);
2923
2924 status = PIPEnsSendBulkOut(pDevice,pContext);
2925
2926 return true;
2927 }
2928
kernel source for telekom puls (alcatel/mediatek)