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