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