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