?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ext4: reduce contention on s_orphan_lock
[linux/fpc-iii.git] / drivers / staging / vt6656 / rxtx.c
blob3840323858fcc13ffe57901f9272d0d15096ac7a
1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * File: rxtx.c
20 *
21 * Purpose: handle WMAC/802.3/802.11 rx & tx functions
22 *
23 * Author: Lyndon Chen
24 *
25 * Date: May 20, 2003
26 *
27 * Functions:
28 * s_vGenerateTxParameter - Generate tx dma required parameter.
29 * s_vGenerateMACHeader - Translate 802.3 to 802.11 header
30 * csBeacon_xmit - beacon tx function
31 * csMgmt_xmit - management tx function
32 * s_uGetDataDuration - get tx data required duration
33 * s_uFillDataHead- fulfill tx data duration header
34 * s_uGetRTSCTSDuration- get rtx/cts required duration
35 * s_uGetRTSCTSRsvTime- get rts/cts reserved time
36 * s_uGetTxRsvTime- get frame reserved time
37 * s_vFillCTSHead- fulfill CTS ctl header
38 * s_vFillFragParameter- Set fragment ctl parameter.
39 * s_vFillRTSHead- fulfill RTS ctl header
40 * s_vFillTxKey- fulfill tx encrypt key
41 * s_vSWencryption- Software encrypt header
42 * vDMA0_tx_80211- tx 802.11 frame via dma0
43 * vGenerateFIFOHeader- Generate tx FIFO ctl header
44 *
45 * Revision History:
46 *
47 */
48
49 #include "device.h"
50 #include "rxtx.h"
51 #include "tether.h"
52 #include "card.h"
53 #include "bssdb.h"
54 #include "mac.h"
55 #include "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
65 static int msglevel = MSG_LEVEL_INFO;
66
67 static const u16 wTimeStampOff[2][MAX_RATE] = {
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
72 static const u16 wFB_Opt0[2][5] = {
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 };
76 static const u16 wFB_Opt1[2][5] = {
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
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
96 static void s_vSaveTxPktInfo(struct vnt_private *pDevice, u8 byPktNum,
97 u8 *pbyDestAddr, u16 wPktLength, u16 wFIFOCtl);
98
99 static struct vnt_usb_send_context *s_vGetFreeContext(struct vnt_private *);
100
101 static 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
106 static 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
110 static 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
115 static void s_vSWencryption(struct vnt_private *pDevice,
116 PSKeyItem pTransmitKey, u8 *pbyPayloadHead, u16 wPayloadSize);
117
118 static unsigned int s_uGetTxRsvTime(struct vnt_private *pDevice, u8 byPktType,
119 u32 cbFrameLength, u16 wRate, int bNeedAck);
120
121 static __le16 s_uGetRTSCTSRsvTime(struct vnt_private *priv,
122 u8 rsv_type, u8 pkt_type, u32 frame_lenght, u16 current_rate);
123
124 static 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
128 static 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
132 static __le16 s_uGetDataDuration(struct vnt_private *pDevice,
133 u8 byPktType, int bNeedAck);
134
135 static __le16 s_uGetRTSCTSDuration(struct vnt_private *pDevice,
136 u8 byDurType, u32 cbFrameLength, u8 byPktType, u16 wRate,
137 int bNeedAck, u8 byFBOption);
138
139 static struct vnt_usb_send_context
140 *s_vGetFreeContext(struct vnt_private *priv)
141 {
142 struct vnt_usb_send_context *context = NULL;
143 int ii;
144
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");
162
163 return NULL;
164 }
165
166 static void s_vSaveTxPktInfo(struct vnt_private *pDevice, u8 byPktNum,
167 u8 *pbyDestAddr, u16 wPktLength, u16 wFIFOCtl)
168 {
169 struct net_device_stats *stats = &pDevice->stats;
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);
174
175 stats->tx_bytes += wPktLength;
176 }
177
178 static 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)
182 {
183 u8 *pbyBuf = (u8 *)&fifo_head->adwTxKey[0];
184 u32 *pdwIV = (u32 *)pbyIVHead;
185 u32 *pdwExtIV = (u32 *)((u8 *)pbyIVHead + 4);
186 struct ieee80211_hdr *pMACHeader = (struct ieee80211_hdr *)pbyHdrBuf;
187 u32 dwRevIVCounter;
188
189 /* Fill TXKEY */
190 if (pTransmitKey == NULL)
191 return;
192
193 dwRevIVCounter = cpu_to_le32(pDevice->dwIVCounter);
194 *pdwIV = pDevice->dwIVCounter;
195 pDevice->byKeyIndex = pTransmitKey->dwKeyIndex & 0xf;
196
197 switch (pTransmitKey->byCipherSuite) {
198 case KEY_CTL_WEP:
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;
223
224 break;
225 case KEY_CTL_TKIP:
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
246 break;
247 case KEY_CTL_CCMP:
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 */
276 if (ieee80211_has_a4(pMACHeader->frame_control))
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
287 & 0xc78f);
288 mic_hdr->seq_ctrl = cpu_to_le16(pMACHeader->seq_ctrl & 0xf);
289
290 if (ieee80211_has_a4(pMACHeader->frame_control))
291 memcpy(mic_hdr->addr4, pMACHeader->addr4, ETH_ALEN);
292 }
293 }
294
295 static void s_vSWencryption(struct vnt_private *pDevice,
296 PSKeyItem pTransmitKey, u8 *pbyPayloadHead, u16 wPayloadSize)
297 {
298 u32 cbICVlen = 4;
299 u32 dwICV = 0xffffffff;
300 u32 *pdwICV;
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)
309 pdwICV = (u32 *)(pbyPayloadHead + wPayloadSize);
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)
320 pdwICV = (u32 *)(pbyPayloadHead + wPayloadSize);
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
330 static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate)
331 {
332 return cpu_to_le16(wTimeStampOff[priv->byPreambleType % 2]
333 [rate % MAX_RATE]);
334 }
335
336 /*byPktType : PK_TYPE_11A 0
337 PK_TYPE_11B 1
338 PK_TYPE_11GB 2
339 PK_TYPE_11GA 3
340 */
341 static u32 s_uGetTxRsvTime(struct vnt_private *priv, u8 pkt_type,
342 u32 frame_length, u16 rate, int need_ack)
343 {
344 u32 data_time, ack_time;
345
346 data_time = BBuGetFrameTime(priv->byPreambleType, pkt_type,
347 frame_length, rate);
348
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;
360 }
361
362 static __le16 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
369 //byFreqType: 0=>5GHZ 1=>2.4GHZ
370 static __le16 s_uGetRTSCTSRsvTime(struct vnt_private *priv,
371 u8 rsv_type, u8 pkt_type, u32 frame_lenght, u16 current_rate)
372 {
373 u32 rrv_time, rts_time, cts_time, ack_time, data_time;
374
375 rrv_time = rts_time = cts_time = ack_time = data_time = 0;
376
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 cpu_to_le16((u16)rrv_time);
406 }
407
408 rrv_time = rts_time + cts_time + ack_time + data_time + 3 * priv->uSIFS;
409
410 return cpu_to_le16((u16)rrv_time);
411 }
412
413 //byFreqType 0: 5GHz, 1:2.4Ghz
414 static __le16 s_uGetDataDuration(struct vnt_private *pDevice,
415 u8 byPktType, int bNeedAck)
416 {
417 u32 uAckTime = 0;
418
419 if (bNeedAck) {
420 if (byPktType == PK_TYPE_11B)
421 uAckTime = BBuGetFrameTime(pDevice->byPreambleType,
422 byPktType, 14, pDevice->byTopCCKBasicRate);
423 else
424 uAckTime = BBuGetFrameTime(pDevice->byPreambleType,
425 byPktType, 14, pDevice->byTopOFDMBasicRate);
426 return cpu_to_le16((u16)(pDevice->uSIFS + uAckTime));
427 }
428
429 return 0;
430 }
431
432 //byFreqType: 0=>5GHZ 1=>2.4GHZ
433 static __le16 s_uGetRTSCTSDuration(struct vnt_private *pDevice, u8 byDurType,
434 u32 cbFrameLength, u8 byPktType, u16 wRate, int bNeedAck,
435 u8 byFBOption)
436 {
437 u32 uCTSTime = 0, uDurTime = 0;
438
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;
450
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;
460
461 case CTSDUR_BA:
462 case CTSDUR_BA_F0:
463 case CTSDUR_BA_F1:
464 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice,
465 byPktType, cbFrameLength, wRate, bNeedAck);
466 break;
467
468 default:
469 break;
470 }
471
472 return cpu_to_le16((u16)uDurTime);
473 }
474
475 static 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 */
484 buf->duration_a = s_uGetDataDuration(priv, pkt_type, need_ack);
485 buf->duration_b = s_uGetDataDuration(priv, PK_TYPE_11B, need_ack);
486
487 buf->time_stamp_off_a = vnt_time_stamp_off(priv, rate);
488 buf->time_stamp_off_b = vnt_time_stamp_off(priv,
489 priv->byTopCCKBasicRate);
490
491 return le16_to_cpu(buf->duration_a);
492 }
493
494 static 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 */
505 buf->duration_a = s_uGetDataDuration(priv, pkt_type, need_ack);
506 buf->duration_b = s_uGetDataDuration(priv, PK_TYPE_11B, need_ack);
507
508 buf->duration_a_f0 = s_uGetDataDuration(priv, pkt_type, need_ack);
509 buf->duration_a_f1 = s_uGetDataDuration(priv, pkt_type, need_ack);
510
511 buf->time_stamp_off_a = vnt_time_stamp_off(priv, rate);
512 buf->time_stamp_off_b = vnt_time_stamp_off(priv,
513 priv->byTopCCKBasicRate);
514
515 return le16_to_cpu(buf->duration_a);
516 }
517
518 static 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 */
525 buf->duration = s_uGetDataDuration(priv, pkt_type, need_ack);
526
527 buf->duration_f0 = s_uGetDataDuration(priv, pkt_type, need_ack);
528 buf->duration_f1 = s_uGetDataDuration(priv, pkt_type, need_ack);
529
530 buf->time_stamp_off = vnt_time_stamp_off(priv, rate);
531
532 return le16_to_cpu(buf->duration);
533 }
534
535 static 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 */
542 buf->duration = s_uGetDataDuration(priv, pkt_type, need_ack);
543
544 buf->time_stamp_off = vnt_time_stamp_off(priv, rate);
545
546 return le16_to_cpu(buf->duration);
547 }
548
549 static int vnt_fill_ieee80211_rts(struct vnt_private *priv,
550 struct ieee80211_rts *rts, struct ethhdr *eth_hdr,
551 __le16 duration)
552 {
553 rts->duration = duration;
554 rts->frame_control = TYPE_CTL_RTS;
555
556 if (priv->op_mode == NL80211_IFTYPE_ADHOC ||
557 priv->op_mode == NL80211_IFTYPE_AP)
558 memcpy(rts->ra, eth_hdr->h_dest, ETH_ALEN);
559 else
560 memcpy(rts->ra, priv->abyBSSID, ETH_ALEN);
561
562 if (priv->op_mode == NL80211_IFTYPE_AP)
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
570 static u16 vnt_rxtx_rts_g_head(struct vnt_private *priv,
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
582 buf->duration_bb = s_uGetRTSCTSDuration(priv, RTSDUR_BB, frame_len,
583 PK_TYPE_11B, priv->byTopCCKBasicRate, need_ack, fb_option);
584 buf->duration_aa = s_uGetRTSCTSDuration(priv, RTSDUR_AA, frame_len,
585 pkt_type, current_rate, need_ack, fb_option);
586 buf->duration_ba = s_uGetRTSCTSDuration(priv, RTSDUR_BA, frame_len,
587 pkt_type, current_rate, need_ack, fb_option);
588
589 vnt_fill_ieee80211_rts(priv, &buf->data, eth_hdr, buf->duration_aa);
590
591 return vnt_rxtx_datahead_g(priv, pkt_type, current_rate,
592 &buf->data_head, frame_len, need_ack);
593 }
594
595 static u16 vnt_rxtx_rts_g_fb_head(struct vnt_private *priv,
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
608 buf->duration_bb = s_uGetRTSCTSDuration(priv, RTSDUR_BB, frame_len,
609 PK_TYPE_11B, priv->byTopCCKBasicRate, need_ack, fb_option);
610 buf->duration_aa = s_uGetRTSCTSDuration(priv, RTSDUR_AA, frame_len,
611 pkt_type, current_rate, need_ack, fb_option);
612 buf->duration_ba = s_uGetRTSCTSDuration(priv, RTSDUR_BA, frame_len,
613 pkt_type, current_rate, need_ack, fb_option);
614
615
616 buf->rts_duration_ba_f0 = s_uGetRTSCTSDuration(priv, RTSDUR_BA_F0,
617 frame_len, pkt_type, priv->tx_rate_fb0, need_ack, fb_option);
618 buf->rts_duration_aa_f0 = s_uGetRTSCTSDuration(priv, RTSDUR_AA_F0,
619 frame_len, pkt_type, priv->tx_rate_fb0, need_ack, fb_option);
620 buf->rts_duration_ba_f1 = s_uGetRTSCTSDuration(priv, RTSDUR_BA_F1,
621 frame_len, pkt_type, priv->tx_rate_fb1, need_ack, fb_option);
622 buf->rts_duration_aa_f1 = s_uGetRTSCTSDuration(priv, RTSDUR_AA_F1,
623 frame_len, pkt_type, priv->tx_rate_fb1, need_ack, fb_option);
624
625 vnt_fill_ieee80211_rts(priv, &buf->data, eth_hdr, buf->duration_aa);
626
627 return vnt_rxtx_datahead_g_fb(priv, pkt_type, current_rate,
628 &buf->data_head, frame_len, need_ack);
629 }
630
631 static u16 vnt_rxtx_rts_ab_head(struct vnt_private *priv,
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
641 buf->duration = s_uGetRTSCTSDuration(priv, RTSDUR_AA, frame_len,
642 pkt_type, current_rate, need_ack, fb_option);
643
644 vnt_fill_ieee80211_rts(priv, &buf->data, eth_hdr, buf->duration);
645
646 return vnt_rxtx_datahead_ab(priv, pkt_type, current_rate,
647 &buf->data_head, frame_len, need_ack);
648 }
649
650 static u16 vnt_rxtx_rts_a_fb_head(struct vnt_private *priv,
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
660 buf->duration = s_uGetRTSCTSDuration(priv, RTSDUR_AA, frame_len,
661 pkt_type, current_rate, need_ack, fb_option);
662
663 buf->rts_duration_f0 = s_uGetRTSCTSDuration(priv, RTSDUR_AA_F0,
664 frame_len, pkt_type, priv->tx_rate_fb0, need_ack, fb_option);
665
666 buf->rts_duration_f1 = s_uGetRTSCTSDuration(priv, RTSDUR_AA_F1,
667 frame_len, pkt_type, priv->tx_rate_fb1, need_ack, fb_option);
668
669 vnt_fill_ieee80211_rts(priv, &buf->data, eth_hdr, buf->duration);
670
671 return vnt_rxtx_datahead_a_fb(priv, pkt_type, current_rate,
672 &buf->data_head, frame_len, need_ack);
673 }
674
675 static u16 s_vFillRTSHead(struct vnt_private *pDevice, u8 byPktType,
676 union vnt_tx_data_head *head, u32 cbFrameLength, int bNeedAck,
677 struct ethhdr *psEthHeader, u16 wCurrentRate, u8 byFBOption)
678 {
679
680 if (!head)
681 return 0;
682
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 */
688 switch (byPktType) {
689 case PK_TYPE_11GB:
690 case PK_TYPE_11GA:
691 if (byFBOption == AUTO_FB_NONE)
692 return vnt_rxtx_rts_g_head(pDevice, &head->rts_g,
693 psEthHeader, byPktType, cbFrameLength,
694 bNeedAck, wCurrentRate, byFBOption);
695 else
696 return vnt_rxtx_rts_g_fb_head(pDevice, &head->rts_g_fb,
697 psEthHeader, byPktType, cbFrameLength,
698 bNeedAck, wCurrentRate, byFBOption);
699 break;
700 case PK_TYPE_11A:
701 if (byFBOption) {
702 return vnt_rxtx_rts_a_fb_head(pDevice, &head->rts_a_fb,
703 psEthHeader, byPktType, cbFrameLength,
704 bNeedAck, wCurrentRate, byFBOption);
705 break;
706 }
707 case PK_TYPE_11B:
708 return vnt_rxtx_rts_ab_head(pDevice, &head->rts_ab,
709 psEthHeader, byPktType, cbFrameLength,
710 bNeedAck, wCurrentRate, byFBOption);
711 }
712
713 return 0;
714 }
715
716 static u16 s_vFillCTSHead(struct vnt_private *pDevice, u32 uDMAIdx,
717 u8 byPktType, union vnt_tx_data_head *head, u32 cbFrameLength,
718 int bNeedAck, u16 wCurrentRate, u8 byFBOption)
719 {
720 u32 uCTSFrameLen = 14;
721
722 if (!head)
723 return 0;
724
725 if (byFBOption != AUTO_FB_NONE) {
726 /* Auto Fall back */
727 struct vnt_cts_fb *pBuf = &head->cts_g_fb;
728 /* Get SignalField,ServiceField,Length */
729 BBvCalculateParameter(pDevice, uCTSFrameLen,
730 pDevice->byTopCCKBasicRate, PK_TYPE_11B, &pBuf->b);
731 pBuf->duration_ba = s_uGetRTSCTSDuration(pDevice, CTSDUR_BA,
732 cbFrameLength, byPktType,
733 wCurrentRate, bNeedAck, byFBOption);
734 /* Get CTSDuration_ba_f0 */
735 pBuf->cts_duration_ba_f0 = s_uGetRTSCTSDuration(pDevice,
736 CTSDUR_BA_F0, cbFrameLength, byPktType,
737 pDevice->tx_rate_fb0, bNeedAck, byFBOption);
738 /* Get CTSDuration_ba_f1 */
739 pBuf->cts_duration_ba_f1 = s_uGetRTSCTSDuration(pDevice,
740 CTSDUR_BA_F1, cbFrameLength, byPktType,
741 pDevice->tx_rate_fb1, bNeedAck, byFBOption);
742 /* Get CTS Frame body */
743 pBuf->data.duration = pBuf->duration_ba;
744 pBuf->data.frame_control = TYPE_CTL_CTS;
745 memcpy(pBuf->data.ra, pDevice->abyCurrentNetAddr, ETH_ALEN);
746
747 return vnt_rxtx_datahead_g_fb(pDevice, byPktType, wCurrentRate,
748 &pBuf->data_head, cbFrameLength, bNeedAck);
749 } else {
750 struct vnt_cts *pBuf = &head->cts_g;
751 /* Get SignalField,ServiceField,Length */
752 BBvCalculateParameter(pDevice, uCTSFrameLen,
753 pDevice->byTopCCKBasicRate, PK_TYPE_11B, &pBuf->b);
754 /* Get CTSDuration_ba */
755 pBuf->duration_ba = s_uGetRTSCTSDuration(pDevice,
756 CTSDUR_BA, cbFrameLength, byPktType,
757 wCurrentRate, bNeedAck, byFBOption);
758 /*Get CTS Frame body*/
759 pBuf->data.duration = pBuf->duration_ba;
760 pBuf->data.frame_control = TYPE_CTL_CTS;
761 memcpy(pBuf->data.ra, pDevice->abyCurrentNetAddr, ETH_ALEN);
762
763 return vnt_rxtx_datahead_g(pDevice, byPktType, wCurrentRate,
764 &pBuf->data_head, cbFrameLength, bNeedAck);
765 }
766
767 return 0;
768 }
769
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 -*/
792
793 static u16 s_vGenerateTxParameter(struct vnt_private *pDevice,
794 u8 byPktType, u16 wCurrentRate, struct vnt_tx_buffer *tx_buffer,
795 struct vnt_mic_hdr **mic_hdr, u32 need_mic, u32 cbFrameSize,
796 int bNeedACK, u32 uDMAIdx, struct ethhdr *psEthHeader, bool need_rts)
797 {
798 struct vnt_tx_fifo_head *pFifoHead = &tx_buffer->fifo_head;
799 union vnt_tx_data_head *head = NULL;
800 u16 wFifoCtl;
801 u8 byFBOption = AUTO_FB_NONE;
802
803 pFifoHead->wReserved = wCurrentRate;
804 wFifoCtl = pFifoHead->wFIFOCtl;
805
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;
810
811 if (!pFifoHead)
812 return 0;
813
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;
818
819 pBuf->rts_rrv_time_aa = s_uGetRTSCTSRsvTime(pDevice, 2,
820 byPktType, cbFrameSize, wCurrentRate);
821 pBuf->rts_rrv_time_ba = s_uGetRTSCTSRsvTime(pDevice, 1,
822 byPktType, cbFrameSize, wCurrentRate);
823 pBuf->rts_rrv_time_bb = s_uGetRTSCTSRsvTime(pDevice, 0,
824 byPktType, cbFrameSize, wCurrentRate);
825
826 pBuf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice,
827 byPktType, cbFrameSize, wCurrentRate, bNeedACK);
828 pBuf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice,
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 }
839
840 /* Fill RTS */
841 return s_vFillRTSHead(pDevice, byPktType, head,
842 cbFrameSize, bNeedACK, psEthHeader,
843 wCurrentRate, byFBOption);
844
845 } else {
846 struct vnt_rrv_time_cts *pBuf = &tx_buffer->
847 tx_head.tx_cts.cts;
848
849 pBuf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice,
850 byPktType, cbFrameSize, wCurrentRate, bNeedACK);
851 pBuf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice,
852 PK_TYPE_11B, cbFrameSize,
853 pDevice->byTopCCKBasicRate, bNeedACK);
854
855 pBuf->cts_rrv_time_ba = s_uGetRTSCTSRsvTime(pDevice, 3,
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) {
872 if (need_mic) {
873 *mic_hdr = &tx_buffer->tx_head.tx_ab.tx.mic.hdr;
874 head = &tx_buffer->tx_head.tx_ab.tx.mic.head;
875 } else {
876 head = &tx_buffer->tx_head.tx_ab.tx.head;
877 }
878
879 if (need_rts) {
880 struct vnt_rrv_time_ab *pBuf = &tx_buffer->
881 tx_head.tx_ab.ab;
882
883 pBuf->rts_rrv_time = s_uGetRTSCTSRsvTime(pDevice, 2,
884 byPktType, cbFrameSize, wCurrentRate);
885
886 pBuf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice,
887 byPktType, cbFrameSize, wCurrentRate, bNeedACK);
888
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;
896
897 pBuf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice,
898 PK_TYPE_11A, cbFrameSize,
899 wCurrentRate, bNeedACK);
900
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;
916
917 pBuf->rts_rrv_time = s_uGetRTSCTSRsvTime(pDevice, 0,
918 byPktType, cbFrameSize, wCurrentRate);
919
920 pBuf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice,
921 PK_TYPE_11B, cbFrameSize, wCurrentRate,
922 bNeedACK);
923
924 /* Fill RTS */
925 return s_vFillRTSHead(pDevice, byPktType, head,
926 cbFrameSize,
927 bNeedACK, psEthHeader, wCurrentRate, byFBOption);
928 } else {
929 struct vnt_rrv_time_ab *pBuf = &tx_buffer->
930 tx_head.tx_ab.ab;
931
932 pBuf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice,
933 PK_TYPE_11B, cbFrameSize,
934 wCurrentRate, bNeedACK);
935
936 return vnt_rxtx_datahead_ab(pDevice, byPktType,
937 wCurrentRate, &head->data_head_ab,
938 cbFrameSize, bNeedACK);
939 }
940 }
941
942 return 0;
943 }
944 /*
945 u8 * pbyBuffer,//point to pTxBufHead
946 u16 wFragType,//00:Non-Frag, 01:Start, 02:Mid, 03:Last
947 unsigned int cbFragmentSize,//Hdr+payoad+FCS
948 */
949
950 static int s_bPacketToWirelessUsb(struct vnt_private *pDevice, u8 byPktType,
951 struct vnt_tx_buffer *tx_buffer, int bNeedEncryption,
952 u32 uSkbPacketLen, u32 uDMAIdx, struct ethhdr *psEthHeader,
953 u8 *pPacket, PSKeyItem pTransmitKey, u32 uNodeIndex, u16 wCurrentRate,
954 u32 *pcbHeaderLen, u32 *pcbTotalLen)
955 {
956 struct vnt_tx_fifo_head *pTxBufHead = &tx_buffer->fifo_head;
957 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
958 u32 cbFrameSize, cbFrameBodySize;
959 u32 cb802_1_H_len;
960 u32 cbIVlen = 0, cbICVlen = 0, cbMIClen = 0, cbMACHdLen = 0;
961 u32 cbFCSlen = 4, cbMICHDR = 0;
962 int bNeedACK;
963 bool bRTS = false;
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;
970 struct vnt_mic_hdr *pMICHDR;
971 u8 byFBOption = AUTO_FB_NONE, byFragType;
972 u16 wTxBufSize;
973 u32 dwMICKey0, dwMICKey1, dwMIC_Priority;
974 u32 *pdwMIC_L, *pdwMIC_R;
975 int bSoftWEP = false;
976
977 pMICHDR = NULL;
978
979 if (bNeedEncryption && pTransmitKey->pvKeyTable) {
980 if (((PSKeyTable)pTransmitKey->pvKeyTable)->bSoftWEP == true)
981 bSoftWEP = true; /* WEP 256 */
982 }
983
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;
989
990 cbFrameBodySize = uSkbPacketLen - ETH_HLEN + cb802_1_H_len;
991
992 //Set packet type
993 pTxBufHead->wFIFOCtl |= (u16)(byPktType<<8);
994
995 if (pDevice->op_mode == NL80211_IFTYPE_ADHOC ||
996 pDevice->op_mode == NL80211_IFTYPE_AP) {
997 if (is_multicast_ether_addr(psEthHeader->h_dest)) {
998 bNeedACK = false;
999 pTxBufHead->wFIFOCtl =
1000 pTxBufHead->wFIFOCtl & (~FIFOCTL_NEEDACK);
1001 } else {
1002 bNeedACK = true;
1003 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1004 }
1005 } else {
1006 /* MSDUs in Infra mode always need ACK */
1007 bNeedACK = true;
1008 pTxBufHead->wFIFOCtl |= FIFOCTL_NEEDACK;
1009 }
1010
1011 pTxBufHead->wTimeStamp = DEFAULT_MSDU_LIFETIME_RES_64us;
1012
1013 //Set FRAGCTL_MACHDCNT
1014 cbMACHdLen = WLAN_HDR_ADDR3_LEN;
1015
1016 pTxBufHead->wFragCtl |= (u16)(cbMACHdLen << 10);
1017
1018 //Set FIFOCTL_GrpAckPolicy
1019 if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
1020 pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
1021 }
1022
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 }
1044
1045 if (bSoftWEP != true) {
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
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
1073 cbMICHDR = sizeof(struct vnt_mic_hdr);
1074 }
1075 if (bSoftWEP == false) {
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
1084 if ( (bNeedACK == false) ||(cbFrameSize < pDevice->wRTSThreshold) ) {
1085 bRTS = false;
1086 } else {
1087 bRTS = true;
1088 pTxBufHead->wFIFOCtl |= (FIFOCTL_RTS | FIFOCTL_LRETRY);
1089 }
1090
1091 pbyTxBufferAddr = (u8 *) &(pTxBufHead->adwTxKey[0]);
1092 wTxBufSize = sizeof(struct vnt_tx_fifo_head);
1093
1094 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1095 if (byFBOption == AUTO_FB_NONE) {
1096 if (bRTS == true) {//RTS_need
1097 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1098 cbMICHDR + sizeof(struct vnt_rts_g);
1099 }
1100 else { //RTS_needless
1101 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1102 cbMICHDR + sizeof(struct vnt_cts);
1103 }
1104 } else {
1105 // Auto Fall Back
1106 if (bRTS == true) {//RTS_need
1107 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) +
1108 cbMICHDR + sizeof(struct vnt_rts_g_fb);
1109 }
1110 else if (bRTS == false) { //RTS_needless
1111 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1112 cbMICHDR + sizeof(struct vnt_cts_fb);
1113 }
1114 } // Auto Fall Back
1115 }
1116 else {//802.11a/b packet
1117 if (byFBOption == AUTO_FB_NONE) {
1118 if (bRTS == true) {//RTS_need
1119 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1120 cbMICHDR + sizeof(struct vnt_rts_ab);
1121 }
1122 else if (bRTS == false) { //RTS_needless, no MICHDR
1123 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1124 cbMICHDR + sizeof(struct vnt_tx_datahead_ab);
1125 }
1126 } else {
1127 // Auto Fall Back
1128 if (bRTS == true) {//RTS_need
1129 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1130 cbMICHDR + sizeof(struct vnt_rts_a_fb);
1131 }
1132 else if (bRTS == false) { //RTS_needless
1133 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1134 cbMICHDR + sizeof(struct vnt_tx_datahead_a_fb);
1135 }
1136 } // Auto Fall Back
1137 }
1138
1139 pbyMacHdr = (u8 *)(pbyTxBufferAddr + cbHeaderLength);
1140 pbyIVHead = (u8 *)(pbyMacHdr + cbMACHdLen + uPadding);
1141 pbyPayloadHead = (u8 *)(pbyMacHdr + cbMACHdLen + uPadding + cbIVlen);
1142
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
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);
1155
1156 // Generate TX MAC Header
1157 s_vGenerateMACHeader(pDevice, pbyMacHdr, (u16)uDuration, psEthHeader, bNeedEncryption,
1158 byFragType, uDMAIdx, 0);
1159
1160 if (bNeedEncryption == true) {
1161 //Fill TXKEY
1162 s_vFillTxKey(pDevice, pTxBufHead, pbyIVHead, pTransmitKey,
1163 pbyMacHdr, (u16)cbFrameBodySize, pMICHDR);
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
1171 /* 802.1H */
1172 if (ntohs(psEthHeader->h_proto) > ETH_DATA_LEN) {
1173 if ((psEthHeader->h_proto == cpu_to_be16(ETH_P_IPX)) ||
1174 (psEthHeader->h_proto == cpu_to_le16(0xF380)))
1175 memcpy((u8 *) (pbyPayloadHead),
1176 abySNAP_Bridgetunnel, 6);
1177 else
1178 memcpy((u8 *) (pbyPayloadHead), &abySNAP_RFC1042[0], 6);
1179
1180 pbyType = (u8 *) (pbyPayloadHead + 6);
1181
1182 memcpy(pbyType, &(psEthHeader->h_proto), sizeof(u16));
1183 }
1184
1185 if (pPacket != NULL) {
1186 // Copy the Packet into a tx Buffer
1187 memcpy((pbyPayloadHead + cb802_1_H_len),
1188 (pPacket + ETH_HLEN),
1189 uSkbPacketLen - ETH_HLEN
1190 );
1191
1192 } else {
1193 // while bRelayPacketSend psEthHeader is point to header+payload
1194 memcpy((pbyPayloadHead + cb802_1_H_len), ((u8 *)psEthHeader) + ETH_HLEN, uSkbPacketLen - ETH_HLEN);
1195 }
1196
1197 if ((bNeedEncryption == true) && (pTransmitKey != NULL) && (pTransmitKey->byCipherSuite == KEY_CTL_TKIP)) {
1198
1199 ///////////////////////////////////////////////////////////////////
1200
1201 if (pDevice->vnt_mgmt.eAuthenMode == WMAC_AUTH_WPANONE) {
1202 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
1203 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
1204 }
1205 else if ((pTransmitKey->dwKeyIndex & AUTHENTICATOR_KEY) != 0) {
1206 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
1207 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
1208 }
1209 else {
1210 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[24]);
1211 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[28]);
1212 }
1213 // DO Software Michael
1214 MIC_vInit(dwMICKey0, dwMICKey1);
1215 MIC_vAppend((u8 *)&(psEthHeader->h_dest[0]), 12);
1216 dwMIC_Priority = 0;
1217 MIC_vAppend((u8 *)&dwMIC_Priority, 4);
1218 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC KEY: %X, %X\n",
1219 dwMICKey0, dwMICKey1);
1220
1221 ///////////////////////////////////////////////////////////////////
1222
1223 //DBG_PRN_GRP12(("Length:%d, %d\n", cbFrameBodySize, uFromHDtoPLDLength));
1224 //for (ii = 0; ii < cbFrameBodySize; ii++) {
1225 // DBG_PRN_GRP12(("%02x ", *((u8 *)((pbyPayloadHead + cb802_1_H_len) + ii))));
1226 //}
1227 //DBG_PRN_GRP12(("\n\n\n"));
1228
1229 MIC_vAppend(pbyPayloadHead, cbFrameBodySize);
1230
1231 pdwMIC_L = (u32 *)(pbyPayloadHead + cbFrameBodySize);
1232 pdwMIC_R = (u32 *)(pbyPayloadHead + cbFrameBodySize + 4);
1233
1234 MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
1235 MIC_vUnInit();
1236
1237 if (pDevice->bTxMICFail == true) {
1238 *pdwMIC_L = 0;
1239 *pdwMIC_R = 0;
1240 pDevice->bTxMICFail = false;
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
1247 if (bSoftWEP == true) {
1248
1249 s_vSWencryption(pDevice, pTransmitKey, (pbyPayloadHead), (u16)(cbFrameBodySize + cbMIClen));
1250
1251 } else if ( ((pDevice->eEncryptionStatus == Ndis802_11Encryption1Enabled) && (bNeedEncryption == true)) ||
1252 ((pDevice->eEncryptionStatus == Ndis802_11Encryption2Enabled) && (bNeedEncryption == true)) ||
1253 ((pDevice->eEncryptionStatus == Ndis802_11Encryption3Enabled) && (bNeedEncryption == true)) ) {
1254 cbFrameSize -= cbICVlen;
1255 }
1256
1257 cbFrameSize -= cbFCSlen;
1258
1259 *pcbHeaderLen = cbHeaderLength;
1260 *pcbTotalLen = cbHeaderLength + cbFrameSize ;
1261
1262 //Set FragCtl in TxBufferHead
1263 pTxBufHead->wFragCtl |= (u16)byFragType;
1264
1265 return true;
1266
1267 }
1268
1269 /*+
1270 *
1271 * Description:
1272 * Translate 802.3 to 802.11 header
1273 *
1274 * Parameters:
1275 * In:
1276 * pDevice - Pointer to adapter
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
1288 static void s_vGenerateMACHeader(struct vnt_private *pDevice,
1289 u8 *pbyBufferAddr, u16 wDuration, struct ethhdr *psEthHeader,
1290 int bNeedEncrypt, u16 wFragType, u32 uDMAIdx, u32 uFragIdx)
1291 {
1292 struct ieee80211_hdr *pMACHeader = (struct ieee80211_hdr *)pbyBufferAddr;
1293
1294 pMACHeader->frame_control = TYPE_802_11_DATA;
1295
1296 if (pDevice->op_mode == NL80211_IFTYPE_AP) {
1297 memcpy(&(pMACHeader->addr1[0]),
1298 &(psEthHeader->h_dest[0]),
1299 ETH_ALEN);
1300 memcpy(&(pMACHeader->addr2[0]), &(pDevice->abyBSSID[0]), ETH_ALEN);
1301 memcpy(&(pMACHeader->addr3[0]),
1302 &(psEthHeader->h_source[0]),
1303 ETH_ALEN);
1304 pMACHeader->frame_control |= FC_FROMDS;
1305 } else {
1306 if (pDevice->op_mode == NL80211_IFTYPE_ADHOC) {
1307 memcpy(&(pMACHeader->addr1[0]),
1308 &(psEthHeader->h_dest[0]),
1309 ETH_ALEN);
1310 memcpy(&(pMACHeader->addr2[0]),
1311 &(psEthHeader->h_source[0]),
1312 ETH_ALEN);
1313 memcpy(&(pMACHeader->addr3[0]),
1314 &(pDevice->abyBSSID[0]),
1315 ETH_ALEN);
1316 } else {
1317 memcpy(&(pMACHeader->addr3[0]),
1318 &(psEthHeader->h_dest[0]),
1319 ETH_ALEN);
1320 memcpy(&(pMACHeader->addr2[0]),
1321 &(psEthHeader->h_source[0]),
1322 ETH_ALEN);
1323 memcpy(&(pMACHeader->addr1[0]),
1324 &(pDevice->abyBSSID[0]),
1325 ETH_ALEN);
1326 pMACHeader->frame_control |= FC_TODS;
1327 }
1328 }
1329
1330 if (bNeedEncrypt)
1331 pMACHeader->frame_control |= cpu_to_le16((u16)WLAN_SET_FC_ISWEP(1));
1332
1333 pMACHeader->duration_id = cpu_to_le16(wDuration);
1334
1335 pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
1336
1337 //Set FragNumber in Sequence Control
1338 pMACHeader->seq_ctrl |= cpu_to_le16((u16)uFragIdx);
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
1347 pMACHeader->frame_control |= FC_MOREFRAG;
1348 }
1349 }
1350
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 *
1364 * Return Value: CMD_STATUS_PENDING if MAC Tx resource available; otherwise false
1365 *
1366 -*/
1367
1368 CMD_STATUS csMgmt_xmit(struct vnt_private *pDevice,
1369 struct vnt_tx_mgmt *pPacket)
1370 {
1371 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1372 struct vnt_tx_buffer *pTX_Buffer;
1373 struct vnt_usb_send_context *pContext;
1374 struct vnt_tx_fifo_head *pTxBufHead;
1375 struct ieee80211_hdr *pMACHeader;
1376 struct ethhdr sEthHeader;
1377 u8 byPktType, *pbyTxBufferAddr;
1378 struct vnt_mic_hdr *pMICHDR = NULL;
1379 u32 uDuration, cbReqCount, cbHeaderSize, cbFrameBodySize, cbFrameSize;
1380 int bNeedACK, bIsPSPOLL = false;
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;
1386
1387 pContext = s_vGetFreeContext(pDevice);
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
1394 pTX_Buffer = (struct vnt_tx_buffer *)&pContext->Data[0];
1395 cbFrameBodySize = pPacket->cbPayloadLen;
1396 pTxBufHead = &pTX_Buffer->fifo_head;
1397 pbyTxBufferAddr = (u8 *)&pTxBufHead->adwTxKey[0];
1398 wTxBufSize = sizeof(struct vnt_tx_fifo_head);
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
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
1436 if (is_multicast_ether_addr(pPacket->p80211Header->sA3.abyAddr1)) {
1437 bNeedACK = false;
1438 }
1439 else {
1440 bNeedACK = true;
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) {
1452 // bNeedACK = false;
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) {
1460 bIsPSPOLL = true;
1461 cbMacHdLen = WLAN_HDR_ADDR2_LEN;
1462 } else {
1463 cbMacHdLen = WLAN_HDR_ADDR3_LEN;
1464 }
1465
1466 //Set FRAGCTL_MACHDCNT
1467 pTxBufHead->wFragCtl |= cpu_to_le16((u16)(cbMacHdLen << 10));
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.
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;
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
1501 if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
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
1508 cbHeaderSize = wTxBufSize + sizeof(struct vnt_rrv_time_cts) +
1509 sizeof(struct vnt_cts);
1510 }
1511 else { // 802.11a/b packet
1512 cbHeaderSize = wTxBufSize + sizeof(struct vnt_rrv_time_ab) +
1513 sizeof(struct vnt_tx_datahead_ab);
1514 }
1515
1516 memcpy(&(sEthHeader.h_dest[0]),
1517 &(pPacket->p80211Header->sA3.abyAddr1[0]),
1518 ETH_ALEN);
1519 memcpy(&(sEthHeader.h_source[0]),
1520 &(pPacket->p80211Header->sA3.abyAddr2[0]),
1521 ETH_ALEN);
1522 //=========================
1523 // No Fragmentation
1524 //=========================
1525 pTxBufHead->wFragCtl |= (u16)FRAGCTL_NONFRAG;
1526
1527 /* Fill FIFO,RrvTime,RTS,and CTS */
1528 uDuration = s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate,
1529 pTX_Buffer, &pMICHDR, 0,
1530 cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader, false);
1531
1532 pMACHeader = (struct ieee80211_hdr *) (pbyTxBufferAddr + cbHeaderSize);
1533
1534 cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + cbFrameBodySize;
1535
1536 if (WLAN_GET_FC_ISWEP(pPacket->p80211Header->sA4.wFrameCtl) != 0) {
1537 u8 * pbyIVHead;
1538 u8 * pbyPayloadHead;
1539 u8 * pbyBSSID;
1540 PSKeyItem pTransmitKey = NULL;
1541
1542 pbyIVHead = (u8 *)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding);
1543 pbyPayloadHead = (u8 *)(pbyTxBufferAddr + cbHeaderSize + cbMacHdLen + uPadding + cbIVlen);
1544 do {
1545 if (pDevice->op_mode == NL80211_IFTYPE_STATION &&
1546 pDevice->bLinkPass == true) {
1547 pbyBSSID = pDevice->abyBSSID;
1548 // get pairwise key
1549 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
1550 // get group key
1551 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
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;
1562 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
1563 pTransmitKey = NULL;
1564 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"KEY is NULL. OP Mode[%d]\n", pDevice->op_mode);
1565 } else {
1566 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Get GTK.\n");
1567 }
1568 } while(false);
1569 //Fill TXKEY
1570 s_vFillTxKey(pDevice, pTxBufHead, pbyIVHead, pTransmitKey,
1571 (u8 *)pMACHeader, (u16)cbFrameBodySize, NULL);
1572
1573 memcpy(pMACHeader, pPacket->p80211Header, cbMacHdLen);
1574 memcpy(pbyPayloadHead, ((u8 *)(pPacket->p80211Header) + cbMacHdLen),
1575 cbFrameBodySize);
1576 }
1577 else {
1578 // Copy the Packet into a tx Buffer
1579 memcpy(pMACHeader, pPacket->p80211Header, pPacket->cbMPDULen);
1580 }
1581
1582 pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
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
1589 // of FIFO control header.
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
1593 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
1594 struct vnt_tx_datahead_g *data_head = &pTX_Buffer->tx_head.
1595 tx_cts.tx.head.cts_g.data_head;
1596 data_head->duration_a =
1597 cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1598 data_head->duration_b =
1599 cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1600 } else {
1601 struct vnt_tx_datahead_ab *data_head = &pTX_Buffer->tx_head.
1602 tx_ab.tx.head.data_head_ab;
1603 data_head->duration =
1604 cpu_to_le16(pPacket->p80211Header->sA2.wDurationID);
1605 }
1606 }
1607
1608 pTX_Buffer->wTxByteCount = cpu_to_le16((u16)(cbReqCount));
1609 pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
1610 pTX_Buffer->byType = 0x00;
1611
1612 pContext->pPacket = NULL;
1613 pContext->type = CONTEXT_MGMT_PACKET;
1614 pContext->uBufLen = (u16)cbReqCount + 4; //USB header
1615
1616 if (WLAN_GET_FC_TODS(pMACHeader->frame_control) == 0) {
1617 s_vSaveTxPktInfo(pDevice, (u8)(pTX_Buffer->byPKTNO & 0x0F),
1618 &pMACHeader->addr1[0], (u16)cbFrameSize,
1619 pTxBufHead->wFIFOCtl);
1620 }
1621 else {
1622 s_vSaveTxPktInfo(pDevice, (u8)(pTX_Buffer->byPKTNO & 0x0F),
1623 &pMACHeader->addr3[0], (u16)cbFrameSize,
1624 pTxBufHead->wFIFOCtl);
1625 }
1626
1627 PIPEnsSendBulkOut(pDevice,pContext);
1628 return CMD_STATUS_PENDING;
1629 }
1630
1631 CMD_STATUS csBeacon_xmit(struct vnt_private *pDevice,
1632 struct vnt_tx_mgmt *pPacket)
1633 {
1634 struct vnt_beacon_buffer *pTX_Buffer;
1635 struct vnt_tx_short_buf_head *short_head;
1636 u32 cbFrameSize = pPacket->cbMPDULen + WLAN_FCS_LEN;
1637 u32 cbHeaderSize = 0;
1638 struct ieee80211_hdr *pMACHeader;
1639 u16 wCurrentRate;
1640 u32 cbFrameBodySize;
1641 u32 cbReqCount;
1642 struct vnt_usb_send_context *pContext;
1643 CMD_STATUS status;
1644
1645 pContext = s_vGetFreeContext(pDevice);
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 }
1651
1652 pTX_Buffer = (struct vnt_beacon_buffer *)&pContext->Data[0];
1653 short_head = &pTX_Buffer->short_head;
1654
1655 cbFrameBodySize = pPacket->cbPayloadLen;
1656
1657 cbHeaderSize = sizeof(struct vnt_tx_short_buf_head);
1658
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,
1681 PK_TYPE_11B, false);
1682 short_head->time_stamp_off =
1683 vnt_time_stamp_off(pDevice, wCurrentRate);
1684 }
1685
1686
1687 /* Generate Beacon Header */
1688 pMACHeader = &pTX_Buffer->hdr;
1689
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;
1697
1698 cbReqCount = cbHeaderSize + WLAN_HDR_ADDR3_LEN + cbFrameBodySize;
1699
1700 pTX_Buffer->wTxByteCount = (u16)cbReqCount;
1701 pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
1702 pTX_Buffer->byType = 0x01;
1703
1704 pContext->pPacket = NULL;
1705 pContext->type = CONTEXT_MGMT_PACKET;
1706 pContext->uBufLen = (u16)cbReqCount + 4; //USB header
1707
1708 PIPEnsSendBulkOut(pDevice,pContext);
1709 return CMD_STATUS_PENDING;
1710
1711 }
1712
1713 void vDMA0_tx_80211(struct vnt_private *pDevice, struct sk_buff *skb)
1714 {
1715 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1716 struct vnt_tx_buffer *pTX_Buffer;
1717 struct vnt_tx_fifo_head *pTxBufHead;
1718 u8 byPktType;
1719 u8 *pbyTxBufferAddr;
1720 u32 uDuration, cbReqCount;
1721 struct ieee80211_hdr *pMACHeader;
1722 u32 cbHeaderSize, cbFrameBodySize;
1723 int bNeedACK, bIsPSPOLL = false;
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;
1733 struct ethhdr sEthHeader;
1734 struct vnt_mic_hdr *pMICHDR;
1735 u32 wCurrentRate = RATE_1M;
1736 PUWLAN_80211HDR p80211Header;
1737 u32 uNodeIndex = 0;
1738 int bNodeExist = false;
1739 SKeyItem STempKey;
1740 PSKeyItem pTransmitKey = NULL;
1741 u8 *pbyIVHead, *pbyPayloadHead, *pbyMacHdr;
1742 u32 cbExtSuppRate = 0;
1743 struct vnt_usb_send_context *pContext;
1744
1745 pMICHDR = NULL;
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
1755 pContext = s_vGetFreeContext(pDevice);
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
1763 pTX_Buffer = (struct vnt_tx_buffer *)&pContext->Data[0];
1764 pTxBufHead = &pTX_Buffer->fifo_head;
1765 pbyTxBufferAddr = (u8 *)&pTxBufHead->adwTxKey[0];
1766 wTxBufSize = sizeof(struct vnt_tx_fifo_head);
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
1805 if (is_multicast_ether_addr(p80211Header->sA3.abyAddr1)) {
1806 bNeedACK = false;
1807 if (pDevice->bEnableHostWEP) {
1808 uNodeIndex = 0;
1809 bNodeExist = true;
1810 }
1811 }
1812 else {
1813 if (pDevice->bEnableHostWEP) {
1814 if (BSSbIsSTAInNodeDB(pDevice, (u8 *)(p80211Header->sA3.abyAddr1), &uNodeIndex))
1815 bNodeExist = true;
1816 }
1817 bNeedACK = true;
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) {
1830 // bNeedACK = false;
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) {
1838 bIsPSPOLL = true;
1839 cbMacHdLen = WLAN_HDR_ADDR2_LEN;
1840 } else {
1841 cbMacHdLen = WLAN_HDR_ADDR3_LEN;
1842 }
1843
1844 // hostapd daemon ext support rate patch
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
1860 //Set FRAGCTL_MACHDCNT
1861 pTxBufHead->wFragCtl |= cpu_to_le16((u16)cbMacHdLen << 10);
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.
1866
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
1885 cbMICHDR = sizeof(struct vnt_mic_hdr);
1886 pTxBufHead->wFragCtl |= FRAGCTL_AES;
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
1896 if (pDevice->bGrpAckPolicy == true) {//0000 0100 0000 0000
1897 pTxBufHead->wFIFOCtl |= FIFOCTL_GRPACK;
1898 }
1899 //the rest of pTxBufHead->wFragCtl:FragTyp will be set later in s_vFillFragParameter()
1900
1901 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {//802.11g packet
1902 cbHeaderSize = wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR +
1903 sizeof(struct vnt_cts);
1904
1905 }
1906 else {//802.11a/b packet
1907 cbHeaderSize = wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR +
1908 sizeof(struct vnt_tx_datahead_ab);
1909 }
1910 memcpy(&(sEthHeader.h_dest[0]),
1911 &(p80211Header->sA3.abyAddr1[0]),
1912 ETH_ALEN);
1913 memcpy(&(sEthHeader.h_source[0]),
1914 &(p80211Header->sA3.abyAddr2[0]),
1915 ETH_ALEN);
1916 //=========================
1917 // No Fragmentation
1918 //=========================
1919 pTxBufHead->wFragCtl |= (u16)FRAGCTL_NONFRAG;
1920
1921 /* Fill FIFO,RrvTime,RTS,and CTS */
1922 uDuration = s_vGenerateTxParameter(pDevice, byPktType, wCurrentRate,
1923 pTX_Buffer, &pMICHDR, cbMICHDR,
1924 cbFrameSize, bNeedACK, TYPE_TXDMA0, &sEthHeader, false);
1925
1926 pMACHeader = (struct ieee80211_hdr *) (pbyTxBufferAddr + cbHeaderSize);
1927
1928 cbReqCount = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen + (cbFrameBodySize + cbMIClen) + cbExtSuppRate;
1929
1930 pbyMacHdr = (u8 *)(pbyTxBufferAddr + cbHeaderSize);
1931 pbyPayloadHead = (u8 *)(pbyMacHdr + cbMacHdLen + uPadding + cbIVlen);
1932 pbyIVHead = (u8 *)(pbyMacHdr + cbMacHdLen + uPadding);
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
1938 pMACHeader->frame_control &= cpu_to_le16(0xfffc);
1939 memcpy(pbyPayloadHead, (skb->data + cbMacHdLen), cbFrameBodySize);
1940
1941 // replace support rate, patch for hostapd daemon( only support 11M)
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
1975 dwMICKey0 = *(u32 *)(&pTransmitKey->abyKey[16]);
1976 dwMICKey1 = *(u32 *)(&pTransmitKey->abyKey[20]);
1977
1978 // DO Software Michael
1979 MIC_vInit(dwMICKey0, dwMICKey1);
1980 MIC_vAppend((u8 *)&(sEthHeader.h_dest[0]), 12);
1981 dwMIC_Priority = 0;
1982 MIC_vAppend((u8 *)&dwMIC_Priority, 4);
1983 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"DMA0_tx_8021:MIC KEY:"\
1984 " %X, %X\n", dwMICKey0, dwMICKey1);
1985
1986 uLength = cbHeaderSize + cbMacHdLen + uPadding + cbIVlen;
1987
1988 MIC_vAppend((pbyTxBufferAddr + uLength), cbFrameBodySize);
1989
1990 pdwMIC_L = (u32 *)(pbyTxBufferAddr + uLength + cbFrameBodySize);
1991 pdwMIC_R = (u32 *)(pbyTxBufferAddr + uLength + cbFrameBodySize + 4);
1992
1993 MIC_vGetMIC(pdwMIC_L, pdwMIC_R);
1994 MIC_vUnInit();
1995
1996 if (pDevice->bTxMICFail == true) {
1997 *pdwMIC_L = 0;
1998 *pdwMIC_R = 0;
1999 pDevice->bTxMICFail = false;
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);
2004 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"MIC:%x, %x\n",
2005 *pdwMIC_L, *pdwMIC_R);
2006
2007 }
2008
2009 s_vFillTxKey(pDevice, pTxBufHead, pbyIVHead, pTransmitKey,
2010 pbyMacHdr, (u16)cbFrameBodySize, pMICHDR);
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)) {
2018 s_vSWencryption(pDevice, pTransmitKey, pbyPayloadHead, (u16)(cbFrameBodySize + cbMIClen));
2019 }
2020 }
2021
2022 pMACHeader->seq_ctrl = cpu_to_le16(pDevice->wSeqCounter << 4);
2023 pDevice->wSeqCounter++ ;
2024 if (pDevice->wSeqCounter > 0x0fff)
2025 pDevice->wSeqCounter = 0;
2026
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
2033 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {
2034 struct vnt_tx_datahead_g *data_head = &pTX_Buffer->tx_head.
2035 tx_cts.tx.head.cts_g.data_head;
2036 data_head->duration_a =
2037 cpu_to_le16(p80211Header->sA2.wDurationID);
2038 data_head->duration_b =
2039 cpu_to_le16(p80211Header->sA2.wDurationID);
2040 } else {
2041 struct vnt_tx_datahead_ab *data_head = &pTX_Buffer->tx_head.
2042 tx_ab.tx.head.data_head_ab;
2043 data_head->duration =
2044 cpu_to_le16(p80211Header->sA2.wDurationID);
2045 }
2046 }
2047
2048 pTX_Buffer->wTxByteCount = cpu_to_le16((u16)(cbReqCount));
2049 pTX_Buffer->byPKTNO = (u8) (((wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2050 pTX_Buffer->byType = 0x00;
2051
2052 pContext->pPacket = skb;
2053 pContext->type = CONTEXT_MGMT_PACKET;
2054 pContext->uBufLen = (u16)cbReqCount + 4; //USB header
2055
2056 if (WLAN_GET_FC_TODS(pMACHeader->frame_control) == 0) {
2057 s_vSaveTxPktInfo(pDevice, (u8)(pTX_Buffer->byPKTNO & 0x0F),
2058 &pMACHeader->addr1[0], (u16)cbFrameSize,
2059 pTxBufHead->wFIFOCtl);
2060 }
2061 else {
2062 s_vSaveTxPktInfo(pDevice, (u8)(pTX_Buffer->byPKTNO & 0x0F),
2063 &pMACHeader->addr3[0], (u16)cbFrameSize,
2064 pTxBufHead->wFIFOCtl);
2065 }
2066 PIPEnsSendBulkOut(pDevice,pContext);
2067 return ;
2068
2069 }
2070
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
2086 int nsDMA_tx_packet(struct vnt_private *pDevice,
2087 u32 uDMAIdx, struct sk_buff *skb)
2088 {
2089 struct net_device_stats *pStats = &pDevice->stats;
2090 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
2091 struct vnt_tx_buffer *pTX_Buffer;
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;
2097 int bNeedEncryption = false;
2098 PSKeyItem pTransmitKey = NULL;
2099 SKeyItem STempKey;
2100 int ii;
2101 int bTKIP_UseGTK = false;
2102 int bNeedDeAuth = false;
2103 u8 *pbyBSSID;
2104 int bNodeExist = false;
2105 struct vnt_usb_send_context *pContext;
2106 bool fConvertedPacket;
2107 u32 status;
2108 u16 wKeepRate = pDevice->wCurrentRate;
2109 int bTxeapol_key = false;
2110
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
2118 if (is_multicast_ether_addr((u8 *)(skb->data))) {
2119 uNodeIndex = 0;
2120 bNodeExist = true;
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 }
2129 // multicast/broadcast data rate
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
2140 if (BSSbIsSTAInNodeDB(pDevice, (u8 *)(skb->data), &uNodeIndex)) {
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 }
2165 bNodeExist = true;
2166 }
2167 }
2168
2169 if (bNodeExist == false) {
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
2176 pContext = s_vGetFreeContext(pDevice);
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
2184 memcpy(pDevice->sTxEthHeader.h_dest, (u8 *)(skb->data), ETH_HLEN);
2185
2186 //mike add:station mode check eapol-key challenge--->
2187 {
2188 u8 Protocol_Version; //802.1x Authentication
2189 u8 Packet_Type; //802.1x Authentication
2190 u8 Descriptor_type;
2191 u16 Key_info;
2192
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]);
2197 if (pDevice->sTxEthHeader.h_proto == cpu_to_be16(ETH_P_PAE)) {
2198 /* 802.1x OR eapol-key challenge frame transfer */
2199 if (((Protocol_Version == 1) || (Protocol_Version == 2)) &&
2200 (Packet_Type == 3)) {
2201 bTxeapol_key = true;
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) {
2205 pDevice->fWPA_Authened = true;
2206 PRINT_K("WPA ");
2207 }
2208 else {
2209 pDevice->fWPA_Authened = true;
2210 PRINT_K("WPA2(re-keying) ");
2211 }
2212 PRINT_K("Authentication completed!!\n");
2213 }
2214 else if((Key_info & BIT3) && (Descriptor_type==2) && //RSN pairwise-key challenge
2215 (Key_info & BIT8) && (Key_info & BIT9)) {
2216 pDevice->fWPA_Authened = true;
2217 PRINT_K("WPA2 Authentication completed!!\n");
2218 }
2219 }
2220 }
2221 }
2222 //mike add:station mode check eapol-key challenge<---
2223
2224 if (pDevice->bEncryptionEnable == true) {
2225 bNeedEncryption = true;
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
2232 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2233 // get group key
2234 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
2235 bTKIP_UseGTK = true;
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) {
2244 /* TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1 */
2245 pbyBSSID = pDevice->sTxEthHeader.h_dest;
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
2252 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2253 break;
2254 }
2255 // get group key
2256 pbyBSSID = pDevice->abyBroadcastAddr;
2257 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
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 {
2265 bTKIP_UseGTK = true;
2266 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2267 }
2268 } while(false);
2269 }
2270
2271 if (pDevice->bEnableHostWEP) {
2272 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2273 if (pDevice->bEncryptionEnable == true) {
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
2287 byPktType = (u8)pDevice->byPacketType;
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 {
2294 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
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
2304 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2305 }
2306 }
2307 }
2308 else {
2309 if (pDevice->op_mode == NL80211_IFTYPE_ADHOC) {
2310 // Adhoc Tx rate decided from node DB
2311 if (is_multicast_ether_addr(pDevice->sTxEthHeader.h_dest)) {
2312 // Multicast use highest data rate
2313 pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2314 // preamble type
2315 pDevice->byPreambleType = pDevice->byShortPreamble;
2316 }
2317 else {
2318 if (BSSbIsSTAInNodeDB(pDevice, &(pDevice->sTxEthHeader.h_dest[0]), &uNodeIndex)) {
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 }
2340 if (pDevice->op_mode == NL80211_IFTYPE_STATION) {
2341 // Infra STA rate decided from AP Node, index = 0
2342 pDevice->wCurrentRate = pMgmt->sNodeDBTable[0].wTxDataRate;
2343 }
2344 }
2345
2346 if (pDevice->sTxEthHeader.h_proto == cpu_to_be16(ETH_P_PAE)) {
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 }
2359
2360 DBG_PRT(MSG_LEVEL_DEBUG,
2361 KERN_INFO "dma_tx: pDevice->wCurrentRate = %d\n",
2362 pDevice->wCurrentRate);
2363
2364 if (wKeepRate != pDevice->wCurrentRate) {
2365 bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
2366 }
2367
2368 if (pDevice->wCurrentRate <= RATE_11M) {
2369 byPktType = PK_TYPE_11B;
2370 }
2371
2372 if (bNeedEncryption == true) {
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)) {
2375 bNeedEncryption = false;
2376 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.h_proto));
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 {
2382 if (bTKIP_UseGTK == true) {
2383 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
2384 }
2385 else {
2386 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%X]\n",
2387 pTransmitKey->dwKeyIndex);
2388 bNeedEncryption = true;
2389 }
2390 }
2391 }
2392
2393 if (pDevice->bEnableHostWEP) {
2394 if ((uNodeIndex != 0) &&
2395 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2396 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%X]\n",
2397 pTransmitKey->dwKeyIndex);
2398 bNeedEncryption = true;
2399 }
2400 }
2401 }
2402 else {
2403
2404 if (pTransmitKey == NULL) {
2405 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
2406 pContext->bBoolInUse = false;
2407 dev_kfree_skb_irq(skb);
2408 pStats->tx_dropped++;
2409 return STATUS_FAILURE;
2410 }
2411 }
2412 }
2413
2414 pTX_Buffer = (struct vnt_tx_buffer *)&pContext->Data[0];
2415
2416 fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
2417 pTX_Buffer, bNeedEncryption,
2418 skb->len, uDMAIdx, &pDevice->sTxEthHeader,
2419 (u8 *)skb->data, pTransmitKey, uNodeIndex,
2420 pDevice->wCurrentRate,
2421 &uHeaderLen, &BytesToWrite
2422 );
2423
2424 if (fConvertedPacket == false) {
2425 pContext->bBoolInUse = false;
2426 dev_kfree_skb_irq(skb);
2427 return STATUS_FAILURE;
2428 }
2429
2430 if ( pDevice->bEnablePSMode == true ) {
2431 if ( !pDevice->bPSModeTxBurst ) {
2432 bScheduleCommand((void *) pDevice,
2433 WLAN_CMD_MAC_DISPOWERSAVING,
2434 NULL);
2435 pDevice->bPSModeTxBurst = true;
2436 }
2437 }
2438
2439 pTX_Buffer->byPKTNO = (u8) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2440 pTX_Buffer->wTxByteCount = (u16)BytesToWrite;
2441
2442 pContext->pPacket = skb;
2443 pContext->type = CONTEXT_DATA_PACKET;
2444 pContext->uBufLen = (u16)BytesToWrite + 4 ; //USB header
2445
2446 s_vSaveTxPktInfo(pDevice, (u8)(pTX_Buffer->byPKTNO & 0x0F),
2447 &pDevice->sTxEthHeader.h_dest[0],
2448 (u16)(BytesToWrite-uHeaderLen),
2449 pTX_Buffer->fifo_head.wFIFOCtl);
2450
2451 status = PIPEnsSendBulkOut(pDevice,pContext);
2452
2453 if (bNeedDeAuth == true) {
2454 u16 wReason = WLAN_MGMT_REASON_MIC_FAILURE;
2455
2456 bScheduleCommand((void *) pDevice, WLAN_CMD_DEAUTH, (u8 *) &wReason);
2457 }
2458
2459 if(status!=STATUS_PENDING) {
2460 pContext->bBoolInUse = false;
2461 dev_kfree_skb_irq(skb);
2462 return STATUS_FAILURE;
2463 }
2464 else
2465 return 0;
2466
2467 }
2468
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:
2479 * TURE, false
2480 *
2481 * Return Value: Return true if packet is copy to dma1; otherwise false
2482 */
2483
2484 int bRelayPacketSend(struct vnt_private *pDevice, u8 *pbySkbData, u32 uDataLen,
2485 u32 uNodeIndex)
2486 {
2487 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
2488 struct vnt_tx_buffer *pTX_Buffer;
2489 u32 BytesToWrite = 0, uHeaderLen = 0;
2490 u8 byPktType = PK_TYPE_11B;
2491 int bNeedEncryption = false;
2492 SKeyItem STempKey;
2493 PSKeyItem pTransmitKey = NULL;
2494 u8 *pbyBSSID;
2495 struct vnt_usb_send_context *pContext;
2496 u8 byPktTyp;
2497 int fConvertedPacket;
2498 u32 status;
2499 u16 wKeepRate = pDevice->wCurrentRate;
2500
2501 pContext = s_vGetFreeContext(pDevice);
2502
2503 if (NULL == pContext) {
2504 return false;
2505 }
2506
2507 memcpy(pDevice->sTxEthHeader.h_dest, (u8 *)pbySkbData, ETH_HLEN);
2508
2509 if (pDevice->bEncryptionEnable == true) {
2510 bNeedEncryption = true;
2511 // get group key
2512 pbyBSSID = pDevice->abyBroadcastAddr;
2513 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
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) {
2522 if (uNodeIndex < MAX_NODE_NUM + 1) {
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) ) {
2537 pContext->bBoolInUse = false;
2538 return false;
2539 }
2540
2541 byPktTyp = (u8)pDevice->byPacketType;
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 {
2548 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
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
2558 pDevice->wCurrentRate = (u16)pDevice->uConnectionRate;
2559 }
2560 }
2561 }
2562 else {
2563 pDevice->wCurrentRate = pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2564 }
2565
2566 if (wKeepRate != pDevice->wCurrentRate) {
2567 bScheduleCommand((void *) pDevice, WLAN_CMD_SETPOWER, NULL);
2568 }
2569
2570 if (pDevice->wCurrentRate <= RATE_11M)
2571 byPktType = PK_TYPE_11B;
2572
2573 BytesToWrite = uDataLen + ETH_FCS_LEN;
2574
2575 // Convert the packet to an usb frame and copy into our buffer
2576 // and send the irp.
2577
2578 pTX_Buffer = (struct vnt_tx_buffer *)&pContext->Data[0];
2579
2580 fConvertedPacket = s_bPacketToWirelessUsb(pDevice, byPktType,
2581 pTX_Buffer, bNeedEncryption,
2582 uDataLen, TYPE_AC0DMA, &pDevice->sTxEthHeader,
2583 pbySkbData, pTransmitKey, uNodeIndex,
2584 pDevice->wCurrentRate,
2585 &uHeaderLen, &BytesToWrite
2586 );
2587
2588 if (fConvertedPacket == false) {
2589 pContext->bBoolInUse = false;
2590 return false;
2591 }
2592
2593 pTX_Buffer->byPKTNO = (u8) (((pDevice->wCurrentRate<<4) &0x00F0) | ((pDevice->wSeqCounter - 1) & 0x000F));
2594 pTX_Buffer->wTxByteCount = (u16)BytesToWrite;
2595
2596 pContext->pPacket = NULL;
2597 pContext->type = CONTEXT_DATA_PACKET;
2598 pContext->uBufLen = (u16)BytesToWrite + 4 ; //USB header
2599
2600 s_vSaveTxPktInfo(pDevice, (u8)(pTX_Buffer->byPKTNO & 0x0F),
2601 &pDevice->sTxEthHeader.h_dest[0],
2602 (u16)(BytesToWrite - uHeaderLen),
2603 pTX_Buffer->fifo_head.wFIFOCtl);
2604
2605 status = PIPEnsSendBulkOut(pDevice,pContext);
2606
2607 return true;
2608 }
2609
Linux with added FPC-III support