1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc. 4 * All rights reserved. 5 * 6 * File: rxtx.c 7 * 8 * Purpose: handle WMAC/802.3/802.11 rx & tx functions 9 * 10 * Author: Lyndon Chen 11 * 12 * Date: May 20, 2003 13 * 14 * Functions: 15 * s_vGenerateTxParameter - Generate tx dma required parameter. 16 * vGenerateMACHeader - Translate 802.3 to 802.11 header 17 * cbGetFragCount - Calculate fragment number count 18 * csBeacon_xmit - beacon tx function 19 * csMgmt_xmit - management tx function 20 * s_cbFillTxBufHead - fulfill tx dma buffer header 21 * s_uGetDataDuration - get tx data required duration 22 * s_uFillDataHead- fulfill tx data duration header 23 * s_uGetRTSCTSDuration- get rtx/cts required duration 24 * s_uGetRTSCTSRsvTime- get rts/cts reserved time 25 * s_uGetTxRsvTime- get frame reserved time 26 * s_vFillCTSHead- fulfill CTS ctl header 27 * s_vFillFragParameter- Set fragment ctl parameter. 28 * s_vFillRTSHead- fulfill RTS ctl header 29 * s_vFillTxKey- fulfill tx encrypt key 30 * s_vSWencryption- Software encrypt header 31 * vDMA0_tx_80211- tx 802.11 frame via dma0 32 * vGenerateFIFOHeader- Generate tx FIFO ctl header 33 * 34 * Revision History: 35 * 36 */ 37 38 #include "device.h" 39 #include "rxtx.h" 40 #include "card.h" 41 #include "mac.h" 42 #include "baseband.h" 43 #include "rf.h" 44 45 /*--------------------- Static Definitions -------------------------*/ 46 47 /*--------------------- Static Classes ----------------------------*/ 48 49 /*--------------------- Static Variables --------------------------*/ 50 51 /*--------------------- Static Functions --------------------------*/ 52 53 /*--------------------- Static Definitions -------------------------*/ 54 /* if packet size < 256 -> in-direct send 55 * vpacket size >= 256 -> direct send 56 */ 57 #define CRITICAL_PACKET_LEN 256 58 59 static const unsigned short wTimeStampOff[2][MAX_RATE] = { 60 {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, /* Long Preamble */ 61 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, /* Short Preamble */ 62 }; 63 64 static const unsigned short wFB_Opt0[2][5] = { 65 {RATE_12M, RATE_18M, RATE_24M, RATE_36M, RATE_48M}, /* fallback_rate0 */ 66 {RATE_12M, RATE_12M, RATE_18M, RATE_24M, RATE_36M}, /* fallback_rate1 */ 67 }; 68 69 static const unsigned short wFB_Opt1[2][5] = { 70 {RATE_12M, RATE_18M, RATE_24M, RATE_24M, RATE_36M}, /* fallback_rate0 */ 71 {RATE_6M, RATE_6M, RATE_12M, RATE_12M, RATE_18M}, /* fallback_rate1 */ 72 }; 73 74 #define RTSDUR_BB 0 75 #define RTSDUR_BA 1 76 #define RTSDUR_AA 2 77 #define CTSDUR_BA 3 78 #define RTSDUR_BA_F0 4 79 #define RTSDUR_AA_F0 5 80 #define RTSDUR_BA_F1 6 81 #define RTSDUR_AA_F1 7 82 #define CTSDUR_BA_F0 8 83 #define CTSDUR_BA_F1 9 84 #define DATADUR_B 10 85 #define DATADUR_A 11 86 #define DATADUR_A_F0 12 87 #define DATADUR_A_F1 13 88 89 /*--------------------- Static Functions --------------------------*/ 90 static 91 void 92 s_vFillRTSHead( 93 struct vnt_private *pDevice, 94 unsigned char byPktType, 95 void *pvRTS, 96 unsigned int cbFrameLength, 97 bool bNeedAck, 98 bool bDisCRC, 99 struct ieee80211_hdr *hdr, 100 unsigned short wCurrentRate, 101 unsigned char byFBOption 102 ); 103 104 static 105 void 106 s_vGenerateTxParameter( 107 struct vnt_private *pDevice, 108 unsigned char byPktType, 109 struct vnt_tx_fifo_head *, 110 void *pvRrvTime, 111 void *pvRTS, 112 void *pvCTS, 113 unsigned int cbFrameSize, 114 bool bNeedACK, 115 unsigned int uDMAIdx, 116 void *psEthHeader, 117 unsigned short wCurrentRate 118 ); 119 120 static unsigned int 121 s_cbFillTxBufHead(struct vnt_private *pDevice, unsigned char byPktType, 122 unsigned char *pbyTxBufferAddr, 123 unsigned int uDMAIdx, struct vnt_tx_desc *pHeadTD, 124 unsigned int uNodeIndex); 125 126 static 127 __le16 128 s_uFillDataHead( 129 struct vnt_private *pDevice, 130 unsigned char byPktType, 131 void *pTxDataHead, 132 unsigned int cbFrameLength, 133 unsigned int uDMAIdx, 134 bool bNeedAck, 135 unsigned int uFragIdx, 136 unsigned int cbLastFragmentSize, 137 unsigned int uMACfragNum, 138 unsigned char byFBOption, 139 unsigned short wCurrentRate, 140 bool is_pspoll 141 ); 142 143 /*--------------------- Export Variables --------------------------*/ 144 145 static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate) 146 { 147 return cpu_to_le16(wTimeStampOff[priv->byPreambleType % 2] 148 [rate % MAX_RATE]); 149 } 150 151 /* byPktType : PK_TYPE_11A 0 152 * PK_TYPE_11B 1 153 * PK_TYPE_11GB 2 154 * PK_TYPE_11GA 3 155 */ 156 static 157 unsigned int 158 s_uGetTxRsvTime( 159 struct vnt_private *pDevice, 160 unsigned char byPktType, 161 unsigned int cbFrameLength, 162 unsigned short wRate, 163 bool bNeedAck 164 ) 165 { 166 unsigned int uDataTime, uAckTime; 167 168 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wRate); 169 if (byPktType == PK_TYPE_11B) /* llb,CCK mode */ 170 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (unsigned short)pDevice->byTopCCKBasicRate); 171 else /* 11g 2.4G OFDM mode & 11a 5G OFDM mode */ 172 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, (unsigned short)pDevice->byTopOFDMBasicRate); 173 174 if (bNeedAck) 175 return uDataTime + pDevice->uSIFS + uAckTime; 176 else 177 return uDataTime; 178 } 179 180 static __le16 vnt_rxtx_rsvtime_le16(struct vnt_private *priv, u8 pkt_type, 181 u32 frame_length, u16 rate, bool need_ack) 182 { 183 return cpu_to_le16((u16)s_uGetTxRsvTime(priv, pkt_type, 184 frame_length, rate, need_ack)); 185 } 186 187 /* byFreqType: 0=>5GHZ 1=>2.4GHZ */ 188 static 189 __le16 190 s_uGetRTSCTSRsvTime( 191 struct vnt_private *pDevice, 192 unsigned char byRTSRsvType, 193 unsigned char byPktType, 194 unsigned int cbFrameLength, 195 unsigned short wCurrentRate 196 ) 197 { 198 unsigned int uRrvTime, uRTSTime, uCTSTime, uAckTime, uDataTime; 199 200 uRrvTime = uRTSTime = uCTSTime = uAckTime = uDataTime = 0; 201 202 uDataTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, cbFrameLength, wCurrentRate); 203 if (byRTSRsvType == 0) { /* RTSTxRrvTime_bb */ 204 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate); 205 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 206 } else if (byRTSRsvType == 1) { /* RTSTxRrvTime_ba, only in 2.4GHZ */ 207 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopCCKBasicRate); 208 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 209 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 210 } else if (byRTSRsvType == 2) { /* RTSTxRrvTime_aa */ 211 uRTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 20, pDevice->byTopOFDMBasicRate); 212 uCTSTime = uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 213 } else if (byRTSRsvType == 3) { /* CTSTxRrvTime_ba, only in 2.4GHZ */ 214 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 215 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 216 uRrvTime = uCTSTime + uAckTime + uDataTime + 2 * pDevice->uSIFS; 217 return cpu_to_le16((u16)uRrvTime); 218 } 219 220 /* RTSRrvTime */ 221 uRrvTime = uRTSTime + uCTSTime + uAckTime + uDataTime + 3 * pDevice->uSIFS; 222 return cpu_to_le16((u16)uRrvTime); 223 } 224 225 /* byFreqType 0: 5GHz, 1:2.4Ghz */ 226 static 227 unsigned int 228 s_uGetDataDuration( 229 struct vnt_private *pDevice, 230 unsigned char byDurType, 231 unsigned int cbFrameLength, 232 unsigned char byPktType, 233 unsigned short wRate, 234 bool bNeedAck, 235 unsigned int uFragIdx, 236 unsigned int cbLastFragmentSize, 237 unsigned int uMACfragNum, 238 unsigned char byFBOption 239 ) 240 { 241 bool bLastFrag = false; 242 unsigned int uAckTime = 0, uNextPktTime = 0; 243 244 if (uFragIdx == (uMACfragNum - 1)) 245 bLastFrag = true; 246 247 switch (byDurType) { 248 case DATADUR_B: /* DATADUR_B */ 249 if (((uMACfragNum == 1)) || bLastFrag) {/* Non Frag or Last Frag */ 250 if (bNeedAck) { 251 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 252 return pDevice->uSIFS + uAckTime; 253 } else { 254 return 0; 255 } 256 } else {/* First Frag or Mid Frag */ 257 if (uFragIdx == (uMACfragNum - 2)) 258 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck); 259 else 260 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck); 261 262 if (bNeedAck) { 263 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 264 return pDevice->uSIFS + uAckTime + uNextPktTime; 265 } else { 266 return pDevice->uSIFS + uNextPktTime; 267 } 268 } 269 break; 270 271 case DATADUR_A: /* DATADUR_A */ 272 if (((uMACfragNum == 1)) || bLastFrag) {/* Non Frag or Last Frag */ 273 if (bNeedAck) { 274 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 275 return pDevice->uSIFS + uAckTime; 276 } else { 277 return 0; 278 } 279 } else {/* First Frag or Mid Frag */ 280 if (uFragIdx == (uMACfragNum - 2)) 281 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wRate, bNeedAck); 282 else 283 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck); 284 285 if (bNeedAck) { 286 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 287 return pDevice->uSIFS + uAckTime + uNextPktTime; 288 } else { 289 return pDevice->uSIFS + uNextPktTime; 290 } 291 } 292 break; 293 294 case DATADUR_A_F0: /* DATADUR_A_F0 */ 295 if (((uMACfragNum == 1)) || bLastFrag) {/* Non Frag or Last Frag */ 296 if (bNeedAck) { 297 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 298 return pDevice->uSIFS + uAckTime; 299 } else { 300 return 0; 301 } 302 } else { /* First Frag or Mid Frag */ 303 if (byFBOption == AUTO_FB_0) { 304 if (wRate < RATE_18M) 305 wRate = RATE_18M; 306 else if (wRate > RATE_54M) 307 wRate = RATE_54M; 308 309 if (uFragIdx == (uMACfragNum - 2)) 310 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck); 311 else 312 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck); 313 314 } else { /* (byFBOption == AUTO_FB_1) */ 315 if (wRate < RATE_18M) 316 wRate = RATE_18M; 317 else if (wRate > RATE_54M) 318 wRate = RATE_54M; 319 320 if (uFragIdx == (uMACfragNum - 2)) 321 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck); 322 else 323 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck); 324 } 325 326 if (bNeedAck) { 327 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 328 return pDevice->uSIFS + uAckTime + uNextPktTime; 329 } else { 330 return pDevice->uSIFS + uNextPktTime; 331 } 332 } 333 break; 334 335 case DATADUR_A_F1: /* DATADUR_A_F1 */ 336 if (((uMACfragNum == 1)) || bLastFrag) { /* Non Frag or Last Frag */ 337 if (bNeedAck) { 338 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 339 return pDevice->uSIFS + uAckTime; 340 } else { 341 return 0; 342 } 343 } else { /* First Frag or Mid Frag */ 344 if (byFBOption == AUTO_FB_0) { 345 if (wRate < RATE_18M) 346 wRate = RATE_18M; 347 else if (wRate > RATE_54M) 348 wRate = RATE_54M; 349 350 if (uFragIdx == (uMACfragNum - 2)) 351 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck); 352 else 353 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck); 354 355 } else { /* (byFBOption == AUTO_FB_1) */ 356 if (wRate < RATE_18M) 357 wRate = RATE_18M; 358 else if (wRate > RATE_54M) 359 wRate = RATE_54M; 360 361 if (uFragIdx == (uMACfragNum - 2)) 362 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbLastFragmentSize, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck); 363 else 364 uNextPktTime = s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck); 365 } 366 if (bNeedAck) { 367 uAckTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 368 return pDevice->uSIFS + uAckTime + uNextPktTime; 369 } else { 370 return pDevice->uSIFS + uNextPktTime; 371 } 372 } 373 break; 374 375 default: 376 break; 377 } 378 379 return 0; 380 } 381 382 /* byFreqType: 0=>5GHZ 1=>2.4GHZ */ 383 static 384 __le16 385 s_uGetRTSCTSDuration( 386 struct vnt_private *pDevice, 387 unsigned char byDurType, 388 unsigned int cbFrameLength, 389 unsigned char byPktType, 390 unsigned short wRate, 391 bool bNeedAck, 392 unsigned char byFBOption 393 ) 394 { 395 unsigned int uCTSTime = 0, uDurTime = 0; 396 397 switch (byDurType) { 398 case RTSDUR_BB: /* RTSDuration_bb */ 399 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 400 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck); 401 break; 402 403 case RTSDUR_BA: /* RTSDuration_ba */ 404 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 405 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck); 406 break; 407 408 case RTSDUR_AA: /* RTSDuration_aa */ 409 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 410 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck); 411 break; 412 413 case CTSDUR_BA: /* CTSDuration_ba */ 414 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wRate, bNeedAck); 415 break; 416 417 case RTSDUR_BA_F0: /* RTSDuration_ba_f0 */ 418 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 419 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 420 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck); 421 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 422 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck); 423 424 break; 425 426 case RTSDUR_AA_F0: /* RTSDuration_aa_f0 */ 427 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 428 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 429 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck); 430 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 431 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck); 432 433 break; 434 435 case RTSDUR_BA_F1: /* RTSDuration_ba_f1 */ 436 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopCCKBasicRate); 437 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 438 uDurTime = uCTSTime + 2*pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck); 439 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 440 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck); 441 442 break; 443 444 case RTSDUR_AA_F1: /* RTSDuration_aa_f1 */ 445 uCTSTime = BBuGetFrameTime(pDevice->byPreambleType, byPktType, 14, pDevice->byTopOFDMBasicRate); 446 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 447 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck); 448 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 449 uDurTime = uCTSTime + 2 * pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck); 450 451 break; 452 453 case CTSDUR_BA_F0: /* CTSDuration_ba_f0 */ 454 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 455 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE0][wRate-RATE_18M], bNeedAck); 456 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 457 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE0][wRate-RATE_18M], bNeedAck); 458 459 break; 460 461 case CTSDUR_BA_F1: /* CTSDuration_ba_f1 */ 462 if ((byFBOption == AUTO_FB_0) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 463 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt0[FB_RATE1][wRate-RATE_18M], bNeedAck); 464 else if ((byFBOption == AUTO_FB_1) && (wRate >= RATE_18M) && (wRate <= RATE_54M)) 465 uDurTime = pDevice->uSIFS + s_uGetTxRsvTime(pDevice, byPktType, cbFrameLength, wFB_Opt1[FB_RATE1][wRate-RATE_18M], bNeedAck); 466 467 break; 468 469 default: 470 break; 471 } 472 473 return cpu_to_le16((u16)uDurTime); 474 } 475 476 static 477 __le16 478 s_uFillDataHead( 479 struct vnt_private *pDevice, 480 unsigned char byPktType, 481 void *pTxDataHead, 482 unsigned int cbFrameLength, 483 unsigned int uDMAIdx, 484 bool bNeedAck, 485 unsigned int uFragIdx, 486 unsigned int cbLastFragmentSize, 487 unsigned int uMACfragNum, 488 unsigned char byFBOption, 489 unsigned short wCurrentRate, 490 bool is_pspoll 491 ) 492 { 493 if (!pTxDataHead) 494 return 0; 495 496 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) { 497 if (byFBOption == AUTO_FB_NONE) { 498 struct vnt_tx_datahead_g *buf = pTxDataHead; 499 /* Get SignalField, ServiceField & Length */ 500 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate, 501 byPktType, &buf->a); 502 503 vnt_get_phy_field(pDevice, cbFrameLength, 504 pDevice->byTopCCKBasicRate, 505 PK_TYPE_11B, &buf->b); 506 507 if (is_pspoll) { 508 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15)); 509 510 buf->duration_a = dur; 511 buf->duration_b = dur; 512 } else { 513 /* Get Duration and TimeStamp */ 514 buf->duration_a = 515 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, 516 byPktType, wCurrentRate, bNeedAck, uFragIdx, 517 cbLastFragmentSize, uMACfragNum, 518 byFBOption)); 519 buf->duration_b = 520 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, 521 PK_TYPE_11B, pDevice->byTopCCKBasicRate, 522 bNeedAck, uFragIdx, cbLastFragmentSize, 523 uMACfragNum, byFBOption)); 524 } 525 526 buf->time_stamp_off_a = vnt_time_stamp_off(pDevice, wCurrentRate); 527 buf->time_stamp_off_b = vnt_time_stamp_off(pDevice, pDevice->byTopCCKBasicRate); 528 529 return buf->duration_a; 530 } else { 531 /* Auto Fallback */ 532 struct vnt_tx_datahead_g_fb *buf = pTxDataHead; 533 /* Get SignalField, ServiceField & Length */ 534 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate, 535 byPktType, &buf->a); 536 537 vnt_get_phy_field(pDevice, cbFrameLength, 538 pDevice->byTopCCKBasicRate, 539 PK_TYPE_11B, &buf->b); 540 /* Get Duration and TimeStamp */ 541 buf->duration_a = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType, 542 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); 543 buf->duration_b = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, PK_TYPE_11B, 544 pDevice->byTopCCKBasicRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); 545 buf->duration_a_f0 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType, 546 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); 547 buf->duration_a_f1 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType, 548 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); 549 550 buf->time_stamp_off_a = vnt_time_stamp_off(pDevice, wCurrentRate); 551 buf->time_stamp_off_b = vnt_time_stamp_off(pDevice, pDevice->byTopCCKBasicRate); 552 553 return buf->duration_a; 554 } /* if (byFBOption == AUTO_FB_NONE) */ 555 } else if (byPktType == PK_TYPE_11A) { 556 if (byFBOption != AUTO_FB_NONE) { 557 /* Auto Fallback */ 558 struct vnt_tx_datahead_a_fb *buf = pTxDataHead; 559 /* Get SignalField, ServiceField & Length */ 560 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate, 561 byPktType, &buf->a); 562 563 /* Get Duration and TimeStampOff */ 564 buf->duration = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType, 565 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); 566 buf->duration_f0 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F0, cbFrameLength, byPktType, 567 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); 568 buf->duration_f1 = cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A_F1, cbFrameLength, byPktType, 569 wCurrentRate, bNeedAck, uFragIdx, cbLastFragmentSize, uMACfragNum, byFBOption)); 570 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate); 571 return buf->duration; 572 } else { 573 struct vnt_tx_datahead_ab *buf = pTxDataHead; 574 /* Get SignalField, ServiceField & Length */ 575 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate, 576 byPktType, &buf->ab); 577 578 if (is_pspoll) { 579 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15)); 580 581 buf->duration = dur; 582 } else { 583 /* Get Duration and TimeStampOff */ 584 buf->duration = 585 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_A, cbFrameLength, byPktType, 586 wCurrentRate, bNeedAck, uFragIdx, 587 cbLastFragmentSize, uMACfragNum, 588 byFBOption)); 589 } 590 591 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate); 592 return buf->duration; 593 } 594 } else { 595 struct vnt_tx_datahead_ab *buf = pTxDataHead; 596 /* Get SignalField, ServiceField & Length */ 597 vnt_get_phy_field(pDevice, cbFrameLength, wCurrentRate, 598 byPktType, &buf->ab); 599 600 if (is_pspoll) { 601 __le16 dur = cpu_to_le16(pDevice->current_aid | BIT(14) | BIT(15)); 602 603 buf->duration = dur; 604 } else { 605 /* Get Duration and TimeStampOff */ 606 buf->duration = 607 cpu_to_le16((u16)s_uGetDataDuration(pDevice, DATADUR_B, cbFrameLength, byPktType, 608 wCurrentRate, bNeedAck, uFragIdx, 609 cbLastFragmentSize, uMACfragNum, 610 byFBOption)); 611 } 612 613 buf->time_stamp_off = vnt_time_stamp_off(pDevice, wCurrentRate); 614 return buf->duration; 615 } 616 return 0; 617 } 618 619 static 620 void 621 s_vFillRTSHead( 622 struct vnt_private *pDevice, 623 unsigned char byPktType, 624 void *pvRTS, 625 unsigned int cbFrameLength, 626 bool bNeedAck, 627 bool bDisCRC, 628 struct ieee80211_hdr *hdr, 629 unsigned short wCurrentRate, 630 unsigned char byFBOption 631 ) 632 { 633 unsigned int uRTSFrameLen = 20; 634 635 if (!pvRTS) 636 return; 637 638 if (bDisCRC) { 639 /* When CRCDIS bit is on, H/W forgot to generate FCS for 640 * RTS frame, in this case we need to decrease its length by 4. 641 */ 642 uRTSFrameLen -= 4; 643 } 644 645 /* Note: So far RTSHead doesn't appear in ATIM & Beacom DMA, 646 * so we don't need to take them into account. 647 * Otherwise, we need to modify codes for them. 648 */ 649 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) { 650 if (byFBOption == AUTO_FB_NONE) { 651 struct vnt_rts_g *buf = pvRTS; 652 /* Get SignalField, ServiceField & Length */ 653 vnt_get_phy_field(pDevice, uRTSFrameLen, 654 pDevice->byTopCCKBasicRate, 655 PK_TYPE_11B, &buf->b); 656 657 vnt_get_phy_field(pDevice, uRTSFrameLen, 658 pDevice->byTopOFDMBasicRate, 659 byPktType, &buf->a); 660 /* Get Duration */ 661 buf->duration_bb = 662 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, 663 cbFrameLength, PK_TYPE_11B, 664 pDevice->byTopCCKBasicRate, 665 bNeedAck, byFBOption); 666 buf->duration_aa = 667 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, 668 cbFrameLength, byPktType, 669 wCurrentRate, bNeedAck, 670 byFBOption); 671 buf->duration_ba = 672 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, 673 cbFrameLength, byPktType, 674 wCurrentRate, bNeedAck, 675 byFBOption); 676 677 buf->data.duration = buf->duration_aa; 678 /* Get RTS Frame body */ 679 buf->data.frame_control = 680 cpu_to_le16(IEEE80211_FTYPE_CTL | 681 IEEE80211_STYPE_RTS); 682 683 ether_addr_copy(buf->data.ra, hdr->addr1); 684 ether_addr_copy(buf->data.ta, hdr->addr2); 685 } else { 686 struct vnt_rts_g_fb *buf = pvRTS; 687 /* Get SignalField, ServiceField & Length */ 688 vnt_get_phy_field(pDevice, uRTSFrameLen, 689 pDevice->byTopCCKBasicRate, 690 PK_TYPE_11B, &buf->b); 691 692 vnt_get_phy_field(pDevice, uRTSFrameLen, 693 pDevice->byTopOFDMBasicRate, 694 byPktType, &buf->a); 695 /* Get Duration */ 696 buf->duration_bb = 697 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, 698 cbFrameLength, PK_TYPE_11B, 699 pDevice->byTopCCKBasicRate, 700 bNeedAck, byFBOption); 701 buf->duration_aa = 702 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, 703 cbFrameLength, byPktType, 704 wCurrentRate, bNeedAck, 705 byFBOption); 706 buf->duration_ba = 707 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA, 708 cbFrameLength, byPktType, 709 wCurrentRate, bNeedAck, 710 byFBOption); 711 buf->rts_duration_ba_f0 = 712 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F0, 713 cbFrameLength, byPktType, 714 wCurrentRate, bNeedAck, 715 byFBOption); 716 buf->rts_duration_aa_f0 = 717 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, 718 cbFrameLength, byPktType, 719 wCurrentRate, bNeedAck, 720 byFBOption); 721 buf->rts_duration_ba_f1 = 722 s_uGetRTSCTSDuration(pDevice, RTSDUR_BA_F1, 723 cbFrameLength, byPktType, 724 wCurrentRate, bNeedAck, 725 byFBOption); 726 buf->rts_duration_aa_f1 = 727 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, 728 cbFrameLength, byPktType, 729 wCurrentRate, bNeedAck, 730 byFBOption); 731 buf->data.duration = buf->duration_aa; 732 /* Get RTS Frame body */ 733 buf->data.frame_control = 734 cpu_to_le16(IEEE80211_FTYPE_CTL | 735 IEEE80211_STYPE_RTS); 736 737 ether_addr_copy(buf->data.ra, hdr->addr1); 738 ether_addr_copy(buf->data.ta, hdr->addr2); 739 } /* if (byFBOption == AUTO_FB_NONE) */ 740 } else if (byPktType == PK_TYPE_11A) { 741 if (byFBOption == AUTO_FB_NONE) { 742 struct vnt_rts_ab *buf = pvRTS; 743 /* Get SignalField, ServiceField & Length */ 744 vnt_get_phy_field(pDevice, uRTSFrameLen, 745 pDevice->byTopOFDMBasicRate, 746 byPktType, &buf->ab); 747 /* Get Duration */ 748 buf->duration = 749 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, 750 cbFrameLength, byPktType, 751 wCurrentRate, bNeedAck, 752 byFBOption); 753 buf->data.duration = buf->duration; 754 /* Get RTS Frame body */ 755 buf->data.frame_control = 756 cpu_to_le16(IEEE80211_FTYPE_CTL | 757 IEEE80211_STYPE_RTS); 758 759 ether_addr_copy(buf->data.ra, hdr->addr1); 760 ether_addr_copy(buf->data.ta, hdr->addr2); 761 } else { 762 struct vnt_rts_a_fb *buf = pvRTS; 763 /* Get SignalField, ServiceField & Length */ 764 vnt_get_phy_field(pDevice, uRTSFrameLen, 765 pDevice->byTopOFDMBasicRate, 766 byPktType, &buf->a); 767 /* Get Duration */ 768 buf->duration = 769 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA, 770 cbFrameLength, byPktType, 771 wCurrentRate, bNeedAck, 772 byFBOption); 773 buf->rts_duration_f0 = 774 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F0, 775 cbFrameLength, byPktType, 776 wCurrentRate, bNeedAck, 777 byFBOption); 778 buf->rts_duration_f1 = 779 s_uGetRTSCTSDuration(pDevice, RTSDUR_AA_F1, 780 cbFrameLength, byPktType, 781 wCurrentRate, bNeedAck, 782 byFBOption); 783 buf->data.duration = buf->duration; 784 /* Get RTS Frame body */ 785 buf->data.frame_control = 786 cpu_to_le16(IEEE80211_FTYPE_CTL | 787 IEEE80211_STYPE_RTS); 788 789 ether_addr_copy(buf->data.ra, hdr->addr1); 790 ether_addr_copy(buf->data.ta, hdr->addr2); 791 } 792 } else if (byPktType == PK_TYPE_11B) { 793 struct vnt_rts_ab *buf = pvRTS; 794 /* Get SignalField, ServiceField & Length */ 795 vnt_get_phy_field(pDevice, uRTSFrameLen, 796 pDevice->byTopCCKBasicRate, 797 PK_TYPE_11B, &buf->ab); 798 /* Get Duration */ 799 buf->duration = 800 s_uGetRTSCTSDuration(pDevice, RTSDUR_BB, cbFrameLength, 801 byPktType, wCurrentRate, bNeedAck, 802 byFBOption); 803 804 buf->data.duration = buf->duration; 805 /* Get RTS Frame body */ 806 buf->data.frame_control = 807 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS); 808 809 ether_addr_copy(buf->data.ra, hdr->addr1); 810 ether_addr_copy(buf->data.ta, hdr->addr2); 811 } 812 } 813 814 static 815 void 816 s_vFillCTSHead( 817 struct vnt_private *pDevice, 818 unsigned int uDMAIdx, 819 unsigned char byPktType, 820 void *pvCTS, 821 unsigned int cbFrameLength, 822 bool bNeedAck, 823 bool bDisCRC, 824 unsigned short wCurrentRate, 825 unsigned char byFBOption 826 ) 827 { 828 unsigned int uCTSFrameLen = 14; 829 830 if (!pvCTS) 831 return; 832 833 if (bDisCRC) { 834 /* When CRCDIS bit is on, H/W forgot to generate FCS for 835 * CTS frame, in this case we need to decrease its length by 4. 836 */ 837 uCTSFrameLen -= 4; 838 } 839 840 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) { 841 if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) { 842 /* Auto Fall back */ 843 struct vnt_cts_fb *buf = pvCTS; 844 /* Get SignalField, ServiceField & Length */ 845 vnt_get_phy_field(pDevice, uCTSFrameLen, 846 pDevice->byTopCCKBasicRate, 847 PK_TYPE_11B, &buf->b); 848 849 buf->duration_ba = 850 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, 851 cbFrameLength, byPktType, 852 wCurrentRate, bNeedAck, 853 byFBOption); 854 855 /* Get CTSDuration_ba_f0 */ 856 buf->cts_duration_ba_f0 = 857 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F0, 858 cbFrameLength, byPktType, 859 wCurrentRate, bNeedAck, 860 byFBOption); 861 862 /* Get CTSDuration_ba_f1 */ 863 buf->cts_duration_ba_f1 = 864 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA_F1, 865 cbFrameLength, byPktType, 866 wCurrentRate, bNeedAck, 867 byFBOption); 868 869 /* Get CTS Frame body */ 870 buf->data.duration = buf->duration_ba; 871 872 buf->data.frame_control = 873 cpu_to_le16(IEEE80211_FTYPE_CTL | 874 IEEE80211_STYPE_CTS); 875 876 buf->reserved2 = 0x0; 877 878 ether_addr_copy(buf->data.ra, 879 pDevice->abyCurrentNetAddr); 880 } else { /* if (byFBOption != AUTO_FB_NONE && uDMAIdx != TYPE_ATIMDMA && uDMAIdx != TYPE_BEACONDMA) */ 881 struct vnt_cts *buf = pvCTS; 882 /* Get SignalField, ServiceField & Length */ 883 vnt_get_phy_field(pDevice, uCTSFrameLen, 884 pDevice->byTopCCKBasicRate, 885 PK_TYPE_11B, &buf->b); 886 887 /* Get CTSDuration_ba */ 888 buf->duration_ba = 889 s_uGetRTSCTSDuration(pDevice, CTSDUR_BA, 890 cbFrameLength, byPktType, 891 wCurrentRate, bNeedAck, 892 byFBOption); 893 894 /* Get CTS Frame body */ 895 buf->data.duration = buf->duration_ba; 896 897 buf->data.frame_control = 898 cpu_to_le16(IEEE80211_FTYPE_CTL | 899 IEEE80211_STYPE_CTS); 900 901 buf->reserved2 = 0x0; 902 ether_addr_copy(buf->data.ra, 903 pDevice->abyCurrentNetAddr); 904 } 905 } 906 } 907 908 /* 909 * 910 * Description: 911 * Generate FIFO control for MAC & Baseband controller 912 * 913 * Parameters: 914 * In: 915 * pDevice - Pointer to adapter 916 * pTxDataHead - Transmit Data Buffer 917 * pTxBufHead - pTxBufHead 918 * pvRrvTime - pvRrvTime 919 * pvRTS - RTS Buffer 920 * pCTS - CTS Buffer 921 * cbFrameSize - Transmit Data Length (Hdr+Payload+FCS) 922 * bNeedACK - If need ACK 923 * uDescIdx - Desc Index 924 * Out: 925 * none 926 * 927 * Return Value: none 928 * 929 - 930 * unsigned int cbFrameSize, Hdr+Payload+FCS 931 */ 932 static 933 void 934 s_vGenerateTxParameter( 935 struct vnt_private *pDevice, 936 unsigned char byPktType, 937 struct vnt_tx_fifo_head *tx_buffer_head, 938 void *pvRrvTime, 939 void *pvRTS, 940 void *pvCTS, 941 unsigned int cbFrameSize, 942 bool bNeedACK, 943 unsigned int uDMAIdx, 944 void *psEthHeader, 945 unsigned short wCurrentRate 946 ) 947 { 948 u16 fifo_ctl = le16_to_cpu(tx_buffer_head->fifo_ctl); 949 bool bDisCRC = false; 950 unsigned char byFBOption = AUTO_FB_NONE; 951 952 tx_buffer_head->current_rate = cpu_to_le16(wCurrentRate); 953 954 if (fifo_ctl & FIFOCTL_CRCDIS) 955 bDisCRC = true; 956 957 if (fifo_ctl & FIFOCTL_AUTO_FB_0) 958 byFBOption = AUTO_FB_0; 959 else if (fifo_ctl & FIFOCTL_AUTO_FB_1) 960 byFBOption = AUTO_FB_1; 961 962 if (!pvRrvTime) 963 return; 964 965 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) { 966 if (pvRTS) { /* RTS_need */ 967 /* Fill RsvTime */ 968 struct vnt_rrv_time_rts *buf = pvRrvTime; 969 970 buf->rts_rrv_time_aa = s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate); 971 buf->rts_rrv_time_ba = s_uGetRTSCTSRsvTime(pDevice, 1, byPktType, cbFrameSize, wCurrentRate); 972 buf->rts_rrv_time_bb = s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate); 973 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK); 974 buf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK); 975 976 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption); 977 } else {/* RTS_needless, PCF mode */ 978 struct vnt_rrv_time_cts *buf = pvRrvTime; 979 980 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK); 981 buf->rrv_time_b = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, pDevice->byTopCCKBasicRate, bNeedACK); 982 buf->cts_rrv_time_ba = s_uGetRTSCTSRsvTime(pDevice, 3, byPktType, cbFrameSize, wCurrentRate); 983 984 /* Fill CTS */ 985 s_vFillCTSHead(pDevice, uDMAIdx, byPktType, pvCTS, cbFrameSize, bNeedACK, bDisCRC, wCurrentRate, byFBOption); 986 } 987 } else if (byPktType == PK_TYPE_11A) { 988 if (pvRTS) {/* RTS_need, non PCF mode */ 989 struct vnt_rrv_time_ab *buf = pvRrvTime; 990 991 buf->rts_rrv_time = s_uGetRTSCTSRsvTime(pDevice, 2, byPktType, cbFrameSize, wCurrentRate); 992 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, byPktType, cbFrameSize, wCurrentRate, bNeedACK); 993 994 /* Fill RTS */ 995 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption); 996 } else if (!pvRTS) {/* RTS_needless, non PCF mode */ 997 struct vnt_rrv_time_ab *buf = pvRrvTime; 998 999 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11A, cbFrameSize, wCurrentRate, bNeedACK); 1000 } 1001 } else if (byPktType == PK_TYPE_11B) { 1002 if (pvRTS) {/* RTS_need, non PCF mode */ 1003 struct vnt_rrv_time_ab *buf = pvRrvTime; 1004 1005 buf->rts_rrv_time = s_uGetRTSCTSRsvTime(pDevice, 0, byPktType, cbFrameSize, wCurrentRate); 1006 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK); 1007 1008 /* Fill RTS */ 1009 s_vFillRTSHead(pDevice, byPktType, pvRTS, cbFrameSize, bNeedACK, bDisCRC, psEthHeader, wCurrentRate, byFBOption); 1010 } else { /* RTS_needless, non PCF mode */ 1011 struct vnt_rrv_time_ab *buf = pvRrvTime; 1012 1013 buf->rrv_time = vnt_rxtx_rsvtime_le16(pDevice, PK_TYPE_11B, cbFrameSize, wCurrentRate, bNeedACK); 1014 } 1015 } 1016 } 1017 1018 static unsigned int 1019 s_cbFillTxBufHead(struct vnt_private *pDevice, unsigned char byPktType, 1020 unsigned char *pbyTxBufferAddr, 1021 unsigned int uDMAIdx, struct vnt_tx_desc *pHeadTD, 1022 unsigned int is_pspoll) 1023 { 1024 struct vnt_td_info *td_info = pHeadTD->td_info; 1025 struct sk_buff *skb = td_info->skb; 1026 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1027 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 1028 struct vnt_tx_fifo_head *tx_buffer_head = 1029 (struct vnt_tx_fifo_head *)td_info->buf; 1030 u16 fifo_ctl = le16_to_cpu(tx_buffer_head->fifo_ctl); 1031 unsigned int cbFrameSize; 1032 __le16 uDuration; 1033 unsigned char *pbyBuffer; 1034 unsigned int uLength = 0; 1035 unsigned int cbMICHDR = 0; 1036 unsigned int uMACfragNum = 1; 1037 unsigned int uPadding = 0; 1038 unsigned int cbReqCount = 0; 1039 bool bNeedACK = (bool)(fifo_ctl & FIFOCTL_NEEDACK); 1040 bool bRTS = (bool)(fifo_ctl & FIFOCTL_RTS); 1041 struct vnt_tx_desc *ptdCurr; 1042 unsigned int cbHeaderLength = 0; 1043 void *pvRrvTime; 1044 struct vnt_mic_hdr *pMICHDR; 1045 void *pvRTS; 1046 void *pvCTS; 1047 void *pvTxDataHd; 1048 unsigned short wTxBufSize; /* FFinfo size */ 1049 unsigned char byFBOption = AUTO_FB_NONE; 1050 1051 pvRrvTime = pMICHDR = pvRTS = pvCTS = pvTxDataHd = NULL; 1052 1053 cbFrameSize = skb->len + 4; 1054 1055 if (info->control.hw_key) { 1056 switch (info->control.hw_key->cipher) { 1057 case WLAN_CIPHER_SUITE_CCMP: 1058 cbMICHDR = sizeof(struct vnt_mic_hdr); 1059 default: 1060 break; 1061 } 1062 1063 cbFrameSize += info->control.hw_key->icv_len; 1064 1065 if (pDevice->byLocalID > REV_ID_VT3253_A1) { 1066 /* MAC Header should be padding 0 to DW alignment. */ 1067 uPadding = 4 - (ieee80211_get_hdrlen_from_skb(skb) % 4); 1068 uPadding %= 4; 1069 } 1070 } 1071 1072 /* 1073 * Use for AUTO FALL BACK 1074 */ 1075 if (fifo_ctl & FIFOCTL_AUTO_FB_0) 1076 byFBOption = AUTO_FB_0; 1077 else if (fifo_ctl & FIFOCTL_AUTO_FB_1) 1078 byFBOption = AUTO_FB_1; 1079 1080 /* Set RrvTime/RTS/CTS Buffer */ 1081 wTxBufSize = sizeof(struct vnt_tx_fifo_head); 1082 if (byPktType == PK_TYPE_11GB || byPktType == PK_TYPE_11GA) {/* 802.11g packet */ 1083 1084 if (byFBOption == AUTO_FB_NONE) { 1085 if (bRTS) {/* RTS_need */ 1086 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize); 1087 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts)); 1088 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + cbMICHDR); 1089 pvCTS = NULL; 1090 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + 1091 cbMICHDR + sizeof(struct vnt_rts_g)); 1092 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) + 1093 cbMICHDR + sizeof(struct vnt_rts_g) + 1094 sizeof(struct vnt_tx_datahead_g); 1095 } else { /* RTS_needless */ 1096 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize); 1097 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts)); 1098 pvRTS = NULL; 1099 pvCTS = (void *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR); 1100 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + 1101 sizeof(struct vnt_rrv_time_cts) + cbMICHDR + sizeof(struct vnt_cts)); 1102 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) + 1103 cbMICHDR + sizeof(struct vnt_cts) + sizeof(struct vnt_tx_datahead_g); 1104 } 1105 } else { 1106 /* Auto Fall Back */ 1107 if (bRTS) {/* RTS_need */ 1108 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize); 1109 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts)); 1110 pvRTS = (void *) (pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + cbMICHDR); 1111 pvCTS = NULL; 1112 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_rts) + 1113 cbMICHDR + sizeof(struct vnt_rts_g_fb)); 1114 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_rts) + 1115 cbMICHDR + sizeof(struct vnt_rts_g_fb) + sizeof(struct vnt_tx_datahead_g_fb); 1116 } else { /* RTS_needless */ 1117 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize); 1118 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts)); 1119 pvRTS = NULL; 1120 pvCTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + cbMICHDR); 1121 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_cts) + 1122 cbMICHDR + sizeof(struct vnt_cts_fb)); 1123 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_cts) + 1124 cbMICHDR + sizeof(struct vnt_cts_fb) + sizeof(struct vnt_tx_datahead_g_fb); 1125 } 1126 } /* Auto Fall Back */ 1127 } else {/* 802.11a/b packet */ 1128 1129 if (byFBOption == AUTO_FB_NONE) { 1130 if (bRTS) { 1131 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize); 1132 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab)); 1133 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR); 1134 pvCTS = NULL; 1135 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + 1136 sizeof(struct vnt_rrv_time_ab) + cbMICHDR + sizeof(struct vnt_rts_ab)); 1137 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) + 1138 cbMICHDR + sizeof(struct vnt_rts_ab) + sizeof(struct vnt_tx_datahead_ab); 1139 } else { /* RTS_needless, need MICHDR */ 1140 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize); 1141 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab)); 1142 pvRTS = NULL; 1143 pvCTS = NULL; 1144 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR); 1145 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) + 1146 cbMICHDR + sizeof(struct vnt_tx_datahead_ab); 1147 } 1148 } else { 1149 /* Auto Fall Back */ 1150 if (bRTS) { /* RTS_need */ 1151 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize); 1152 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab)); 1153 pvRTS = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR); 1154 pvCTS = NULL; 1155 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + 1156 sizeof(struct vnt_rrv_time_ab) + cbMICHDR + sizeof(struct vnt_rts_a_fb)); 1157 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) + 1158 cbMICHDR + sizeof(struct vnt_rts_a_fb) + sizeof(struct vnt_tx_datahead_a_fb); 1159 } else { /* RTS_needless */ 1160 pvRrvTime = (void *)(pbyTxBufferAddr + wTxBufSize); 1161 pMICHDR = (struct vnt_mic_hdr *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab)); 1162 pvRTS = NULL; 1163 pvCTS = NULL; 1164 pvTxDataHd = (void *)(pbyTxBufferAddr + wTxBufSize + sizeof(struct vnt_rrv_time_ab) + cbMICHDR); 1165 cbHeaderLength = wTxBufSize + sizeof(struct vnt_rrv_time_ab) + 1166 cbMICHDR + sizeof(struct vnt_tx_datahead_a_fb); 1167 } 1168 } /* Auto Fall Back */ 1169 } 1170 1171 td_info->mic_hdr = pMICHDR; 1172 1173 memset((void *)(pbyTxBufferAddr + wTxBufSize), 0, (cbHeaderLength - wTxBufSize)); 1174 1175 /* Fill FIFO,RrvTime,RTS,and CTS */ 1176 s_vGenerateTxParameter(pDevice, byPktType, tx_buffer_head, pvRrvTime, pvRTS, pvCTS, 1177 cbFrameSize, bNeedACK, uDMAIdx, hdr, pDevice->wCurrentRate); 1178 /* Fill DataHead */ 1179 uDuration = s_uFillDataHead(pDevice, byPktType, pvTxDataHd, cbFrameSize, uDMAIdx, bNeedACK, 1180 0, 0, uMACfragNum, byFBOption, pDevice->wCurrentRate, is_pspoll); 1181 1182 hdr->duration_id = uDuration; 1183 1184 cbReqCount = cbHeaderLength + uPadding + skb->len; 1185 pbyBuffer = (unsigned char *)pHeadTD->td_info->buf; 1186 uLength = cbHeaderLength + uPadding; 1187 1188 /* Copy the Packet into a tx Buffer */ 1189 memcpy((pbyBuffer + uLength), skb->data, skb->len); 1190 1191 ptdCurr = pHeadTD; 1192 1193 ptdCurr->td_info->req_count = (u16)cbReqCount; 1194 1195 return cbHeaderLength; 1196 } 1197 1198 static void vnt_fill_txkey(struct ieee80211_hdr *hdr, u8 *key_buffer, 1199 struct ieee80211_key_conf *tx_key, 1200 struct sk_buff *skb, u16 payload_len, 1201 struct vnt_mic_hdr *mic_hdr) 1202 { 1203 u64 pn64; 1204 u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb)); 1205 1206 /* strip header and icv len from payload */ 1207 payload_len -= ieee80211_get_hdrlen_from_skb(skb); 1208 payload_len -= tx_key->icv_len; 1209 1210 switch (tx_key->cipher) { 1211 case WLAN_CIPHER_SUITE_WEP40: 1212 case WLAN_CIPHER_SUITE_WEP104: 1213 memcpy(key_buffer, iv, 3); 1214 memcpy(key_buffer + 3, tx_key->key, tx_key->keylen); 1215 1216 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) { 1217 memcpy(key_buffer + 8, iv, 3); 1218 memcpy(key_buffer + 11, 1219 tx_key->key, WLAN_KEY_LEN_WEP40); 1220 } 1221 1222 break; 1223 case WLAN_CIPHER_SUITE_TKIP: 1224 ieee80211_get_tkip_p2k(tx_key, skb, key_buffer); 1225 1226 break; 1227 case WLAN_CIPHER_SUITE_CCMP: 1228 1229 if (!mic_hdr) 1230 return; 1231 1232 mic_hdr->id = 0x59; 1233 mic_hdr->payload_len = cpu_to_be16(payload_len); 1234 ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2); 1235 1236 pn64 = atomic64_read(&tx_key->tx_pn); 1237 mic_hdr->ccmp_pn[5] = pn64; 1238 mic_hdr->ccmp_pn[4] = pn64 >> 8; 1239 mic_hdr->ccmp_pn[3] = pn64 >> 16; 1240 mic_hdr->ccmp_pn[2] = pn64 >> 24; 1241 mic_hdr->ccmp_pn[1] = pn64 >> 32; 1242 mic_hdr->ccmp_pn[0] = pn64 >> 40; 1243 1244 if (ieee80211_has_a4(hdr->frame_control)) 1245 mic_hdr->hlen = cpu_to_be16(28); 1246 else 1247 mic_hdr->hlen = cpu_to_be16(22); 1248 1249 ether_addr_copy(mic_hdr->addr1, hdr->addr1); 1250 ether_addr_copy(mic_hdr->addr2, hdr->addr2); 1251 ether_addr_copy(mic_hdr->addr3, hdr->addr3); 1252 1253 mic_hdr->frame_control = cpu_to_le16( 1254 le16_to_cpu(hdr->frame_control) & 0xc78f); 1255 mic_hdr->seq_ctrl = cpu_to_le16( 1256 le16_to_cpu(hdr->seq_ctrl) & 0xf); 1257 1258 if (ieee80211_has_a4(hdr->frame_control)) 1259 ether_addr_copy(mic_hdr->addr4, hdr->addr4); 1260 1261 memcpy(key_buffer, tx_key->key, WLAN_KEY_LEN_CCMP); 1262 1263 break; 1264 default: 1265 break; 1266 } 1267 } 1268 1269 int vnt_generate_fifo_header(struct vnt_private *priv, u32 dma_idx, 1270 struct vnt_tx_desc *head_td, struct sk_buff *skb) 1271 { 1272 struct vnt_td_info *td_info = head_td->td_info; 1273 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 1274 struct ieee80211_tx_rate *tx_rate = &info->control.rates[0]; 1275 struct ieee80211_rate *rate; 1276 struct ieee80211_key_conf *tx_key; 1277 struct ieee80211_hdr *hdr; 1278 struct vnt_tx_fifo_head *tx_buffer_head = 1279 (struct vnt_tx_fifo_head *)td_info->buf; 1280 u16 tx_body_size = skb->len, current_rate; 1281 u8 pkt_type; 1282 bool is_pspoll = false; 1283 1284 memset(tx_buffer_head, 0, sizeof(*tx_buffer_head)); 1285 1286 hdr = (struct ieee80211_hdr *)(skb->data); 1287 1288 rate = ieee80211_get_tx_rate(priv->hw, info); 1289 1290 current_rate = rate->hw_value; 1291 if (priv->wCurrentRate != current_rate && 1292 !(priv->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) { 1293 priv->wCurrentRate = current_rate; 1294 1295 RFbSetPower(priv, priv->wCurrentRate, 1296 priv->hw->conf.chandef.chan->hw_value); 1297 } 1298 1299 if (current_rate > RATE_11M) { 1300 if (info->band == NL80211_BAND_5GHZ) { 1301 pkt_type = PK_TYPE_11A; 1302 } else { 1303 if (tx_rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT) 1304 pkt_type = PK_TYPE_11GB; 1305 else 1306 pkt_type = PK_TYPE_11GA; 1307 } 1308 } else { 1309 pkt_type = PK_TYPE_11B; 1310 } 1311 1312 /*Set fifo controls */ 1313 if (pkt_type == PK_TYPE_11A) 1314 tx_buffer_head->fifo_ctl = 0; 1315 else if (pkt_type == PK_TYPE_11B) 1316 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B); 1317 else if (pkt_type == PK_TYPE_11GB) 1318 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB); 1319 else if (pkt_type == PK_TYPE_11GA) 1320 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA); 1321 1322 /* generate interrupt */ 1323 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT); 1324 1325 if (!ieee80211_is_data(hdr->frame_control)) { 1326 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN); 1327 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_ISDMA0); 1328 tx_buffer_head->time_stamp = 1329 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us); 1330 } else { 1331 tx_buffer_head->time_stamp = 1332 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us); 1333 } 1334 1335 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) 1336 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK); 1337 1338 if (ieee80211_has_retry(hdr->frame_control)) 1339 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY); 1340 1341 if (tx_rate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE) 1342 priv->byPreambleType = PREAMBLE_SHORT; 1343 else 1344 priv->byPreambleType = PREAMBLE_LONG; 1345 1346 if (tx_rate->flags & IEEE80211_TX_RC_USE_RTS_CTS) 1347 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS); 1348 1349 if (ieee80211_has_a4(hdr->frame_control)) { 1350 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD); 1351 priv->bLongHeader = true; 1352 } 1353 1354 if (info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER) 1355 is_pspoll = true; 1356 1357 tx_buffer_head->frag_ctl = 1358 cpu_to_le16(ieee80211_get_hdrlen_from_skb(skb) << 10); 1359 1360 if (info->control.hw_key) { 1361 tx_key = info->control.hw_key; 1362 1363 switch (info->control.hw_key->cipher) { 1364 case WLAN_CIPHER_SUITE_WEP40: 1365 case WLAN_CIPHER_SUITE_WEP104: 1366 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY); 1367 break; 1368 case WLAN_CIPHER_SUITE_TKIP: 1369 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP); 1370 break; 1371 case WLAN_CIPHER_SUITE_CCMP: 1372 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_AES); 1373 default: 1374 break; 1375 } 1376 } 1377 1378 tx_buffer_head->current_rate = cpu_to_le16(current_rate); 1379 1380 /* legacy rates TODO use ieee80211_tx_rate */ 1381 if (current_rate >= RATE_18M && ieee80211_is_data(hdr->frame_control)) { 1382 if (priv->byAutoFBCtrl == AUTO_FB_0) 1383 tx_buffer_head->fifo_ctl |= 1384 cpu_to_le16(FIFOCTL_AUTO_FB_0); 1385 else if (priv->byAutoFBCtrl == AUTO_FB_1) 1386 tx_buffer_head->fifo_ctl |= 1387 cpu_to_le16(FIFOCTL_AUTO_FB_1); 1388 } 1389 1390 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG); 1391 1392 s_cbFillTxBufHead(priv, pkt_type, (u8 *)tx_buffer_head, 1393 dma_idx, head_td, is_pspoll); 1394 1395 if (info->control.hw_key) { 1396 tx_key = info->control.hw_key; 1397 if (tx_key->keylen > 0) 1398 vnt_fill_txkey(hdr, tx_buffer_head->tx_key, 1399 tx_key, skb, tx_body_size, 1400 td_info->mic_hdr); 1401 } 1402 1403 return 0; 1404 } 1405 1406 static int vnt_beacon_xmit(struct vnt_private *priv, 1407 struct sk_buff *skb) 1408 { 1409 struct vnt_tx_short_buf_head *short_head = 1410 (struct vnt_tx_short_buf_head *)priv->tx_beacon_bufs; 1411 struct ieee80211_mgmt *mgmt_hdr = (struct ieee80211_mgmt *) 1412 (priv->tx_beacon_bufs + sizeof(*short_head)); 1413 struct ieee80211_tx_info *info; 1414 u32 frame_size = skb->len + 4; 1415 u16 current_rate; 1416 1417 memset(priv->tx_beacon_bufs, 0, sizeof(*short_head)); 1418 1419 if (priv->byBBType == BB_TYPE_11A) { 1420 current_rate = RATE_6M; 1421 1422 /* Get SignalField,ServiceField,Length */ 1423 vnt_get_phy_field(priv, frame_size, current_rate, 1424 PK_TYPE_11A, &short_head->ab); 1425 1426 /* Get Duration and TimeStampOff */ 1427 short_head->duration = 1428 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B, 1429 frame_size, PK_TYPE_11A, current_rate, 1430 false, 0, 0, 1, AUTO_FB_NONE)); 1431 1432 short_head->time_stamp_off = 1433 vnt_time_stamp_off(priv, current_rate); 1434 } else { 1435 current_rate = RATE_1M; 1436 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B); 1437 1438 /* Get SignalField,ServiceField,Length */ 1439 vnt_get_phy_field(priv, frame_size, current_rate, 1440 PK_TYPE_11B, &short_head->ab); 1441 1442 /* Get Duration and TimeStampOff */ 1443 short_head->duration = 1444 cpu_to_le16((u16)s_uGetDataDuration(priv, DATADUR_B, 1445 frame_size, PK_TYPE_11B, current_rate, 1446 false, 0, 0, 1, AUTO_FB_NONE)); 1447 1448 short_head->time_stamp_off = 1449 vnt_time_stamp_off(priv, current_rate); 1450 } 1451 1452 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT); 1453 1454 /* Copy Beacon */ 1455 memcpy(mgmt_hdr, skb->data, skb->len); 1456 1457 /* time stamp always 0 */ 1458 mgmt_hdr->u.beacon.timestamp = 0; 1459 1460 info = IEEE80211_SKB_CB(skb); 1461 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) { 1462 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr; 1463 1464 hdr->duration_id = 0; 1465 hdr->seq_ctrl = cpu_to_le16(priv->wSeqCounter << 4); 1466 } 1467 1468 priv->wSeqCounter++; 1469 if (priv->wSeqCounter > 0x0fff) 1470 priv->wSeqCounter = 0; 1471 1472 priv->wBCNBufLen = sizeof(*short_head) + skb->len; 1473 1474 MACvSetCurrBCNTxDescAddr(priv->PortOffset, priv->tx_beacon_dma); 1475 1476 MACvSetCurrBCNLength(priv->PortOffset, priv->wBCNBufLen); 1477 /* Set auto Transmit on */ 1478 MACvRegBitsOn(priv->PortOffset, MAC_REG_TCR, TCR_AUTOBCNTX); 1479 /* Poll Transmit the adapter */ 1480 MACvTransmitBCN(priv->PortOffset); 1481 1482 return 0; 1483 } 1484 1485 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif) 1486 { 1487 struct sk_buff *beacon; 1488 1489 beacon = ieee80211_beacon_get(priv->hw, vif); 1490 if (!beacon) 1491 return -ENOMEM; 1492 1493 if (vnt_beacon_xmit(priv, beacon)) { 1494 ieee80211_free_txskb(priv->hw, beacon); 1495 return -ENODEV; 1496 } 1497 1498 return 0; 1499 } 1500 1501 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif, 1502 struct ieee80211_bss_conf *conf) 1503 { 1504 VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST); 1505 1506 VNSvOutPortB(priv->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN); 1507 1508 CARDvSetFirstNextTBTT(priv, conf->beacon_int); 1509 1510 CARDbSetBeaconPeriod(priv, conf->beacon_int); 1511 1512 return vnt_beacon_make(priv, vif); 1513 } 1514