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