1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 #define _RTW_XMIT_C_ 8 9 #include <drv_types.h> 10 #include <rtw_debug.h> 11 12 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 }; 13 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 }; 14 15 static void _init_txservq(struct tx_servq *ptxservq) 16 { 17 INIT_LIST_HEAD(&ptxservq->tx_pending); 18 _rtw_init_queue(&ptxservq->sta_pending); 19 ptxservq->qcnt = 0; 20 } 21 22 void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv) 23 { 24 memset((unsigned char *)psta_xmitpriv, 0, sizeof(struct sta_xmit_priv)); 25 26 spin_lock_init(&psta_xmitpriv->lock); 27 28 _init_txservq(&psta_xmitpriv->be_q); 29 _init_txservq(&psta_xmitpriv->bk_q); 30 _init_txservq(&psta_xmitpriv->vi_q); 31 _init_txservq(&psta_xmitpriv->vo_q); 32 INIT_LIST_HEAD(&psta_xmitpriv->legacy_dz); 33 INIT_LIST_HEAD(&psta_xmitpriv->apsd); 34 } 35 36 s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter) 37 { 38 int i; 39 struct xmit_buf *pxmitbuf; 40 struct xmit_frame *pxframe; 41 sint res = _SUCCESS; 42 43 spin_lock_init(&pxmitpriv->lock); 44 spin_lock_init(&pxmitpriv->lock_sctx); 45 init_completion(&pxmitpriv->xmit_comp); 46 init_completion(&pxmitpriv->terminate_xmitthread_comp); 47 48 /* 49 Please insert all the queue initializaiton using _rtw_init_queue below 50 */ 51 52 pxmitpriv->adapter = padapter; 53 54 _rtw_init_queue(&pxmitpriv->be_pending); 55 _rtw_init_queue(&pxmitpriv->bk_pending); 56 _rtw_init_queue(&pxmitpriv->vi_pending); 57 _rtw_init_queue(&pxmitpriv->vo_pending); 58 _rtw_init_queue(&pxmitpriv->bm_pending); 59 60 _rtw_init_queue(&pxmitpriv->free_xmit_queue); 61 62 /* 63 Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME, 64 and initialize free_xmit_frame below. 65 Please also apply free_txobj to link_up all the xmit_frames... 66 */ 67 68 pxmitpriv->pallocated_frame_buf = vzalloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4); 69 70 if (!pxmitpriv->pallocated_frame_buf) { 71 pxmitpriv->pxmit_frame_buf = NULL; 72 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("alloc xmit_frame fail!\n")); 73 res = _FAIL; 74 goto exit; 75 } 76 pxmitpriv->pxmit_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_frame_buf), 4); 77 78 pxframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf; 79 80 for (i = 0; i < NR_XMITFRAME; i++) { 81 INIT_LIST_HEAD(&pxframe->list); 82 83 pxframe->padapter = padapter; 84 pxframe->frame_tag = NULL_FRAMETAG; 85 86 pxframe->pkt = NULL; 87 88 pxframe->buf_addr = NULL; 89 pxframe->pxmitbuf = NULL; 90 91 list_add_tail(&pxframe->list, 92 &pxmitpriv->free_xmit_queue.queue); 93 94 pxframe++; 95 } 96 97 pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME; 98 99 pxmitpriv->frag_len = MAX_FRAG_THRESHOLD; 100 101 /* init xmit_buf */ 102 _rtw_init_queue(&pxmitpriv->free_xmitbuf_queue); 103 _rtw_init_queue(&pxmitpriv->pending_xmitbuf_queue); 104 105 pxmitpriv->pallocated_xmitbuf = vzalloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4); 106 107 if (!pxmitpriv->pallocated_xmitbuf) { 108 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("alloc xmit_buf fail!\n")); 109 res = _FAIL; 110 goto exit; 111 } 112 113 pxmitpriv->pxmitbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmitbuf), 4); 114 115 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf; 116 117 for (i = 0; i < NR_XMITBUFF; i++) { 118 INIT_LIST_HEAD(&pxmitbuf->list); 119 120 pxmitbuf->priv_data = NULL; 121 pxmitbuf->padapter = padapter; 122 pxmitbuf->buf_tag = XMITBUF_DATA; 123 124 /* Tx buf allocation may fail sometimes, so sleep and retry. */ 125 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true); 126 if (res == _FAIL) { 127 msleep(10); 128 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true); 129 if (res == _FAIL) 130 goto exit; 131 } 132 133 pxmitbuf->phead = pxmitbuf->pbuf; 134 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMITBUF_SZ; 135 pxmitbuf->len = 0; 136 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead; 137 138 pxmitbuf->flags = XMIT_VO_QUEUE; 139 140 list_add_tail(&pxmitbuf->list, 141 &pxmitpriv->free_xmitbuf_queue.queue); 142 #ifdef DBG_XMIT_BUF 143 pxmitbuf->no = i; 144 #endif 145 146 pxmitbuf++; 147 } 148 149 pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF; 150 151 /* init xframe_ext queue, the same count as extbuf */ 152 _rtw_init_queue(&pxmitpriv->free_xframe_ext_queue); 153 154 pxmitpriv->xframe_ext_alloc_addr = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_frame) + 4); 155 156 if (!pxmitpriv->xframe_ext_alloc_addr) { 157 pxmitpriv->xframe_ext = NULL; 158 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("alloc xframe_ext fail!\n")); 159 res = _FAIL; 160 goto exit; 161 } 162 pxmitpriv->xframe_ext = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->xframe_ext_alloc_addr), 4); 163 pxframe = (struct xmit_frame *)pxmitpriv->xframe_ext; 164 165 for (i = 0; i < NR_XMIT_EXTBUFF; i++) { 166 INIT_LIST_HEAD(&pxframe->list); 167 168 pxframe->padapter = padapter; 169 pxframe->frame_tag = NULL_FRAMETAG; 170 171 pxframe->pkt = NULL; 172 173 pxframe->buf_addr = NULL; 174 pxframe->pxmitbuf = NULL; 175 176 pxframe->ext_tag = 1; 177 178 list_add_tail(&pxframe->list, 179 &pxmitpriv->free_xframe_ext_queue.queue); 180 181 pxframe++; 182 } 183 pxmitpriv->free_xframe_ext_cnt = NR_XMIT_EXTBUFF; 184 185 /* Init xmit extension buff */ 186 _rtw_init_queue(&pxmitpriv->free_xmit_extbuf_queue); 187 188 pxmitpriv->pallocated_xmit_extbuf = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_buf) + 4); 189 190 if (!pxmitpriv->pallocated_xmit_extbuf) { 191 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("alloc xmit_extbuf fail!\n")); 192 res = _FAIL; 193 goto exit; 194 } 195 196 pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmit_extbuf), 4); 197 198 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf; 199 200 for (i = 0; i < NR_XMIT_EXTBUFF; i++) { 201 INIT_LIST_HEAD(&pxmitbuf->list); 202 203 pxmitbuf->priv_data = NULL; 204 pxmitbuf->padapter = padapter; 205 pxmitbuf->buf_tag = XMITBUF_MGNT; 206 207 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ, true); 208 if (res == _FAIL) { 209 res = _FAIL; 210 goto exit; 211 } 212 213 pxmitbuf->phead = pxmitbuf->pbuf; 214 pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMIT_EXTBUF_SZ; 215 pxmitbuf->len = 0; 216 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead; 217 218 list_add_tail(&pxmitbuf->list, 219 &pxmitpriv->free_xmit_extbuf_queue.queue); 220 #ifdef DBG_XMIT_BUF_EXT 221 pxmitbuf->no = i; 222 #endif 223 pxmitbuf++; 224 } 225 226 pxmitpriv->free_xmit_extbuf_cnt = NR_XMIT_EXTBUFF; 227 228 for (i = 0; i < CMDBUF_MAX; i++) { 229 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i]; 230 if (pxmitbuf) { 231 INIT_LIST_HEAD(&pxmitbuf->list); 232 233 pxmitbuf->priv_data = NULL; 234 pxmitbuf->padapter = padapter; 235 pxmitbuf->buf_tag = XMITBUF_CMD; 236 237 res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, true); 238 if (res == _FAIL) { 239 res = _FAIL; 240 goto exit; 241 } 242 243 pxmitbuf->phead = pxmitbuf->pbuf; 244 pxmitbuf->pend = pxmitbuf->pbuf + MAX_CMDBUF_SZ; 245 pxmitbuf->len = 0; 246 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead; 247 pxmitbuf->alloc_sz = MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ; 248 } 249 } 250 251 res = rtw_alloc_hwxmits(padapter); 252 if (res == _FAIL) 253 goto exit; 254 rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry); 255 256 for (i = 0; i < 4; i++) 257 pxmitpriv->wmm_para_seq[i] = i; 258 259 pxmitpriv->ack_tx = false; 260 mutex_init(&pxmitpriv->ack_tx_mutex); 261 rtw_sctx_init(&pxmitpriv->ack_tx_ops, 0); 262 263 rtw_hal_init_xmit_priv(padapter); 264 265 exit: 266 return res; 267 } 268 269 void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv) 270 { 271 int i; 272 struct adapter *padapter = pxmitpriv->adapter; 273 struct xmit_frame *pxmitframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf; 274 struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf; 275 276 rtw_hal_free_xmit_priv(padapter); 277 278 if (!pxmitpriv->pxmit_frame_buf) 279 return; 280 281 for (i = 0; i < NR_XMITFRAME; i++) { 282 rtw_os_xmit_complete(padapter, pxmitframe); 283 284 pxmitframe++; 285 } 286 287 for (i = 0; i < NR_XMITBUFF; i++) { 288 rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true); 289 290 pxmitbuf++; 291 } 292 293 if (pxmitpriv->pallocated_frame_buf) 294 vfree(pxmitpriv->pallocated_frame_buf); 295 296 if (pxmitpriv->pallocated_xmitbuf) 297 vfree(pxmitpriv->pallocated_xmitbuf); 298 299 /* free xframe_ext queue, the same count as extbuf */ 300 pxmitframe = (struct xmit_frame *)pxmitpriv->xframe_ext; 301 if (pxmitframe) { 302 for (i = 0; i < NR_XMIT_EXTBUFF; i++) { 303 rtw_os_xmit_complete(padapter, pxmitframe); 304 pxmitframe++; 305 } 306 } 307 if (pxmitpriv->xframe_ext_alloc_addr) 308 vfree(pxmitpriv->xframe_ext_alloc_addr); 309 310 /* free xmit extension buff */ 311 pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf; 312 for (i = 0; i < NR_XMIT_EXTBUFF; i++) { 313 rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ), true); 314 315 pxmitbuf++; 316 } 317 318 if (pxmitpriv->pallocated_xmit_extbuf) 319 vfree(pxmitpriv->pallocated_xmit_extbuf); 320 321 for (i = 0; i < CMDBUF_MAX; i++) { 322 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i]; 323 if (pxmitbuf) 324 rtw_os_xmit_resource_free(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, true); 325 } 326 327 rtw_free_hwxmits(padapter); 328 329 mutex_destroy(&pxmitpriv->ack_tx_mutex); 330 } 331 332 u8 query_ra_short_GI(struct sta_info *psta) 333 { 334 u8 sgi = false, sgi_20m = false, sgi_40m = false, sgi_80m = false; 335 336 sgi_20m = psta->htpriv.sgi_20m; 337 sgi_40m = psta->htpriv.sgi_40m; 338 339 switch (psta->bw_mode) { 340 case CHANNEL_WIDTH_80: 341 sgi = sgi_80m; 342 break; 343 case CHANNEL_WIDTH_40: 344 sgi = sgi_40m; 345 break; 346 case CHANNEL_WIDTH_20: 347 default: 348 sgi = sgi_20m; 349 break; 350 } 351 352 return sgi; 353 } 354 355 static void update_attrib_vcs_info(struct adapter *padapter, struct xmit_frame *pxmitframe) 356 { 357 u32 sz; 358 struct pkt_attrib *pattrib = &pxmitframe->attrib; 359 /* struct sta_info *psta = pattrib->psta; */ 360 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 361 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info; 362 363 if (pattrib->nr_frags != 1) 364 sz = padapter->xmitpriv.frag_len; 365 else /* no frag */ 366 sz = pattrib->last_txcmdsz; 367 368 /* (1) RTS_Threshold is compared to the MPDU, not MSDU. */ 369 /* (2) If there are more than one frag in this MSDU, only the first frag uses protection frame. */ 370 /* Other fragments are protected by previous fragment. */ 371 /* So we only need to check the length of first fragment. */ 372 if (pmlmeext->cur_wireless_mode < WIRELESS_11_24N || padapter->registrypriv.wifi_spec) { 373 if (sz > padapter->registrypriv.rts_thresh) 374 pattrib->vcs_mode = RTS_CTS; 375 else { 376 if (pattrib->rtsen) 377 pattrib->vcs_mode = RTS_CTS; 378 else if (pattrib->cts2self) 379 pattrib->vcs_mode = CTS_TO_SELF; 380 else 381 pattrib->vcs_mode = NONE_VCS; 382 } 383 } else { 384 while (true) { 385 /* IOT action */ 386 if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_ATHEROS) && (pattrib->ampdu_en == true) && 387 (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) { 388 pattrib->vcs_mode = CTS_TO_SELF; 389 break; 390 } 391 392 /* check ERP protection */ 393 if (pattrib->rtsen || pattrib->cts2self) { 394 if (pattrib->rtsen) 395 pattrib->vcs_mode = RTS_CTS; 396 else if (pattrib->cts2self) 397 pattrib->vcs_mode = CTS_TO_SELF; 398 399 break; 400 } 401 402 /* check HT op mode */ 403 if (pattrib->ht_en) { 404 u8 HTOpMode = pmlmeinfo->HT_protection; 405 if ((pmlmeext->cur_bwmode && (HTOpMode == 2 || HTOpMode == 3)) || 406 (!pmlmeext->cur_bwmode && HTOpMode == 3)) { 407 pattrib->vcs_mode = RTS_CTS; 408 break; 409 } 410 } 411 412 /* check rts */ 413 if (sz > padapter->registrypriv.rts_thresh) { 414 pattrib->vcs_mode = RTS_CTS; 415 break; 416 } 417 418 /* to do list: check MIMO power save condition. */ 419 420 /* check AMPDU aggregation for TXOP */ 421 if (pattrib->ampdu_en == true) { 422 pattrib->vcs_mode = RTS_CTS; 423 break; 424 } 425 426 pattrib->vcs_mode = NONE_VCS; 427 break; 428 } 429 } 430 431 /* for debug : force driver control vrtl_carrier_sense. */ 432 if (padapter->driver_vcs_en == 1) 433 pattrib->vcs_mode = padapter->driver_vcs_type; 434 } 435 436 static void update_attrib_phy_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta) 437 { 438 struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv; 439 440 pattrib->rtsen = psta->rtsen; 441 pattrib->cts2self = psta->cts2self; 442 443 pattrib->mdata = 0; 444 pattrib->eosp = 0; 445 pattrib->triggered = 0; 446 pattrib->ampdu_spacing = 0; 447 448 /* qos_en, ht_en, init rate, , bw, ch_offset, sgi */ 449 pattrib->qos_en = psta->qos_option; 450 451 pattrib->raid = psta->raid; 452 453 if (mlmeext->cur_bwmode < psta->bw_mode) 454 pattrib->bwmode = mlmeext->cur_bwmode; 455 else 456 pattrib->bwmode = psta->bw_mode; 457 458 pattrib->sgi = query_ra_short_GI(psta); 459 460 pattrib->ldpc = psta->ldpc; 461 pattrib->stbc = psta->stbc; 462 463 pattrib->ht_en = psta->htpriv.ht_option; 464 pattrib->ch_offset = psta->htpriv.ch_offset; 465 pattrib->ampdu_en = false; 466 467 if (padapter->driver_ampdu_spacing != 0xFF) /* driver control AMPDU Density for peer sta's rx */ 468 pattrib->ampdu_spacing = padapter->driver_ampdu_spacing; 469 else 470 pattrib->ampdu_spacing = psta->htpriv.rx_ampdu_min_spacing; 471 472 pattrib->retry_ctrl = false; 473 474 #ifdef CONFIG_AUTO_AP_MODE 475 if (psta->isrc && psta->pid > 0) 476 pattrib->pctrl = true; 477 #endif 478 } 479 480 static s32 update_attrib_sec_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta) 481 { 482 sint res = _SUCCESS; 483 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 484 struct security_priv *psecuritypriv = &padapter->securitypriv; 485 sint bmcast = IS_MCAST(pattrib->ra); 486 487 memset(pattrib->dot118021x_UncstKey.skey, 0, 16); 488 memset(pattrib->dot11tkiptxmickey.skey, 0, 16); 489 pattrib->mac_id = psta->mac_id; 490 491 if (psta->ieee8021x_blocked == true) { 492 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("\n psta->ieee8021x_blocked == true\n")); 493 494 pattrib->encrypt = 0; 495 496 if ((pattrib->ether_type != 0x888e) && (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false)) { 497 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("\npsta->ieee8021x_blocked == true, pattrib->ether_type(%.4x) != 0x888e\n", pattrib->ether_type)); 498 #ifdef DBG_TX_DROP_FRAME 499 DBG_871X("DBG_TX_DROP_FRAME %s psta->ieee8021x_blocked == true, pattrib->ether_type(%04x) != 0x888e\n", __func__, pattrib->ether_type); 500 #endif 501 res = _FAIL; 502 goto exit; 503 } 504 } else { 505 GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt, bmcast); 506 507 switch (psecuritypriv->dot11AuthAlgrthm) { 508 case dot11AuthAlgrthm_Open: 509 case dot11AuthAlgrthm_Shared: 510 case dot11AuthAlgrthm_Auto: 511 pattrib->key_idx = (u8)psecuritypriv->dot11PrivacyKeyIndex; 512 break; 513 case dot11AuthAlgrthm_8021X: 514 if (bmcast) 515 pattrib->key_idx = (u8)psecuritypriv->dot118021XGrpKeyid; 516 else 517 pattrib->key_idx = 0; 518 break; 519 default: 520 pattrib->key_idx = 0; 521 break; 522 } 523 524 /* For WPS 1.0 WEP, driver should not encrypt EAPOL Packet for WPS handshake. */ 525 if (((pattrib->encrypt == _WEP40_) || (pattrib->encrypt == _WEP104_)) && (pattrib->ether_type == 0x888e)) 526 pattrib->encrypt = _NO_PRIVACY_; 527 } 528 529 switch (pattrib->encrypt) { 530 case _WEP40_: 531 case _WEP104_: 532 pattrib->iv_len = 4; 533 pattrib->icv_len = 4; 534 WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx); 535 break; 536 537 case _TKIP_: 538 pattrib->iv_len = 8; 539 pattrib->icv_len = 4; 540 541 if (psecuritypriv->busetkipkey == _FAIL) { 542 #ifdef DBG_TX_DROP_FRAME 543 DBG_871X("DBG_TX_DROP_FRAME %s psecuritypriv->busetkipkey(%d) == _FAIL drop packet\n", __func__, psecuritypriv->busetkipkey); 544 #endif 545 res = _FAIL; 546 goto exit; 547 } 548 549 if (bmcast) 550 TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx); 551 else 552 TKIP_IV(pattrib->iv, psta->dot11txpn, 0); 553 554 memcpy(pattrib->dot11tkiptxmickey.skey, psta->dot11tkiptxmickey.skey, 16); 555 556 break; 557 558 case _AES_: 559 560 pattrib->iv_len = 8; 561 pattrib->icv_len = 8; 562 563 if (bmcast) 564 AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx); 565 else 566 AES_IV(pattrib->iv, psta->dot11txpn, 0); 567 568 break; 569 570 default: 571 pattrib->iv_len = 0; 572 pattrib->icv_len = 0; 573 break; 574 } 575 576 if (pattrib->encrypt > 0) 577 memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16); 578 579 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, 580 ("update_attrib: encrypt =%d securitypriv.sw_encrypt =%d\n", 581 pattrib->encrypt, padapter->securitypriv.sw_encrypt)); 582 583 if (pattrib->encrypt && 584 ((padapter->securitypriv.sw_encrypt == true) || (psecuritypriv->hw_decrypted == false))) { 585 pattrib->bswenc = true; 586 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, 587 ("update_attrib: encrypt =%d securitypriv.hw_decrypted =%d bswenc =true\n", 588 pattrib->encrypt, padapter->securitypriv.sw_encrypt)); 589 } else { 590 pattrib->bswenc = false; 591 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("update_attrib: bswenc =false\n")); 592 } 593 594 exit: 595 596 return res; 597 } 598 599 u8 qos_acm(u8 acm_mask, u8 priority) 600 { 601 switch (priority) { 602 case 0: 603 case 3: 604 if (acm_mask & BIT(1)) 605 priority = 1; 606 break; 607 case 1: 608 case 2: 609 break; 610 case 4: 611 case 5: 612 if (acm_mask & BIT(2)) 613 priority = 0; 614 break; 615 case 6: 616 case 7: 617 if (acm_mask & BIT(3)) 618 priority = 5; 619 break; 620 default: 621 DBG_871X("qos_acm(): invalid pattrib->priority: %d!!!\n", priority); 622 break; 623 } 624 625 return priority; 626 } 627 628 static void set_qos(struct pkt_file *ppktfile, struct pkt_attrib *pattrib) 629 { 630 struct ethhdr etherhdr; 631 struct iphdr ip_hdr; 632 s32 UserPriority = 0; 633 634 _rtw_open_pktfile(ppktfile->pkt, ppktfile); 635 _rtw_pktfile_read(ppktfile, (unsigned char *)ðerhdr, ETH_HLEN); 636 637 /* get UserPriority from IP hdr */ 638 if (pattrib->ether_type == 0x0800) { 639 _rtw_pktfile_read(ppktfile, (u8 *)&ip_hdr, sizeof(ip_hdr)); 640 UserPriority = ip_hdr.tos >> 5; 641 } 642 pattrib->priority = UserPriority; 643 pattrib->hdrlen = WLAN_HDR_A3_QOS_LEN; 644 pattrib->subtype = WIFI_QOS_DATA_TYPE; 645 } 646 647 static s32 update_attrib(struct adapter *padapter, _pkt *pkt, struct pkt_attrib *pattrib) 648 { 649 struct pkt_file pktfile; 650 struct sta_info *psta = NULL; 651 struct ethhdr etherhdr; 652 653 sint bmcast; 654 struct sta_priv *pstapriv = &padapter->stapriv; 655 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 656 struct qos_priv *pqospriv = &pmlmepriv->qospriv; 657 sint res = _SUCCESS; 658 659 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib); 660 661 _rtw_open_pktfile(pkt, &pktfile); 662 _rtw_pktfile_read(&pktfile, (u8 *)ðerhdr, ETH_HLEN); 663 664 pattrib->ether_type = ntohs(etherhdr.h_proto); 665 666 memcpy(pattrib->dst, ðerhdr.h_dest, ETH_ALEN); 667 memcpy(pattrib->src, ðerhdr.h_source, ETH_ALEN); 668 669 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) || 670 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) { 671 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN); 672 memcpy(pattrib->ta, pattrib->src, ETH_ALEN); 673 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_adhoc); 674 } else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 675 memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN); 676 memcpy(pattrib->ta, pattrib->src, ETH_ALEN); 677 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_sta); 678 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 679 memcpy(pattrib->ra, pattrib->dst, ETH_ALEN); 680 memcpy(pattrib->ta, get_bssid(pmlmepriv), ETH_ALEN); 681 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_ap); 682 } else 683 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_unknown); 684 685 pattrib->pktlen = pktfile.pkt_len; 686 687 if (ETH_P_IP == pattrib->ether_type) { 688 /* The following is for DHCP and ARP packet, we use cck1M to tx these packets and let LPS awake some time */ 689 /* to prevent DHCP protocol fail */ 690 691 u8 tmp[24]; 692 693 _rtw_pktfile_read(&pktfile, &tmp[0], 24); 694 695 pattrib->dhcp_pkt = 0; 696 if (pktfile.pkt_len > 282) {/* MINIMUM_DHCP_PACKET_SIZE) { */ 697 if (ETH_P_IP == pattrib->ether_type) {/* IP header */ 698 if (((tmp[21] == 68) && (tmp[23] == 67)) || 699 ((tmp[21] == 67) && (tmp[23] == 68))) { 700 /* 68 : UDP BOOTP client */ 701 /* 67 : UDP BOOTP server */ 702 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("======================update_attrib: get DHCP Packet\n")); 703 pattrib->dhcp_pkt = 1; 704 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_dhcp); 705 } 706 } 707 } 708 709 /* for parsing ICMP pakcets */ 710 { 711 struct iphdr *piphdr = (struct iphdr *)tmp; 712 713 pattrib->icmp_pkt = 0; 714 if (piphdr->protocol == 0x1) { /* protocol type in ip header 0x1 is ICMP */ 715 pattrib->icmp_pkt = 1; 716 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_icmp); 717 } 718 } 719 } else if (0x888e == pattrib->ether_type) { 720 DBG_871X_LEVEL(_drv_always_, "send eapol packet\n"); 721 } 722 723 if ((pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1)) 724 rtw_set_scan_deny(padapter, 3000); 725 726 /* If EAPOL , ARP , OR DHCP packet, driver must be in active mode. */ 727 if (pattrib->icmp_pkt == 1) 728 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1); 729 else if (pattrib->dhcp_pkt == 1) { 730 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_active); 731 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SPECIAL_PACKET, 1); 732 } 733 734 bmcast = IS_MCAST(pattrib->ra); 735 736 /* get sta_info */ 737 if (bmcast) { 738 psta = rtw_get_bcmc_stainfo(padapter); 739 } else { 740 psta = rtw_get_stainfo(pstapriv, pattrib->ra); 741 if (!psta) { /* if we cannot get psta => drop the pkt */ 742 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_ucast_sta); 743 RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("\nupdate_attrib => get sta_info fail, ra:" MAC_FMT"\n", MAC_ARG(pattrib->ra))); 744 #ifdef DBG_TX_DROP_FRAME 745 DBG_871X("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __func__, MAC_ARG(pattrib->ra)); 746 #endif 747 res = _FAIL; 748 goto exit; 749 } else if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) && (!(psta->state & _FW_LINKED))) { 750 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_ucast_ap_link); 751 res = _FAIL; 752 goto exit; 753 } 754 } 755 756 if (!psta) { 757 /* if we cannot get psta => drop the pkt */ 758 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_sta); 759 RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("\nupdate_attrib => get sta_info fail, ra:" MAC_FMT "\n", MAC_ARG(pattrib->ra))); 760 #ifdef DBG_TX_DROP_FRAME 761 DBG_871X("DBG_TX_DROP_FRAME %s get sta_info fail, ra:" MAC_FMT"\n", __func__, MAC_ARG(pattrib->ra)); 762 #endif 763 res = _FAIL; 764 goto exit; 765 } 766 767 if (!(psta->state & _FW_LINKED)) { 768 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_link); 769 DBG_871X("%s, psta("MAC_FMT")->state(0x%x) != _FW_LINKED\n", __func__, MAC_ARG(psta->hwaddr), psta->state); 770 return _FAIL; 771 } 772 773 /* TODO:_lock */ 774 if (update_attrib_sec_info(padapter, pattrib, psta) == _FAIL) { 775 DBG_COUNTER(padapter->tx_logs.core_tx_upd_attrib_err_sec); 776 res = _FAIL; 777 goto exit; 778 } 779 780 update_attrib_phy_info(padapter, pattrib, psta); 781 782 pattrib->psta = psta; 783 /* TODO:_unlock */ 784 785 pattrib->pctrl = 0; 786 787 pattrib->ack_policy = 0; 788 /* get ether_hdr_len */ 789 pattrib->pkt_hdrlen = ETH_HLEN;/* pattrib->ether_type == 0x8100) ? (14 + 4): 14; vlan tag */ 790 791 pattrib->hdrlen = WLAN_HDR_A3_LEN; 792 pattrib->subtype = WIFI_DATA_TYPE; 793 pattrib->priority = 0; 794 795 if (check_fwstate(pmlmepriv, WIFI_AP_STATE|WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE)) { 796 if (pattrib->qos_en) 797 set_qos(&pktfile, pattrib); 798 } else { 799 if (pqospriv->qos_option) { 800 set_qos(&pktfile, pattrib); 801 802 if (pmlmepriv->acm_mask != 0) 803 pattrib->priority = qos_acm(pmlmepriv->acm_mask, pattrib->priority); 804 } 805 } 806 807 /* pattrib->priority = 5; force to used VI queue, for testing */ 808 809 exit: 810 return res; 811 } 812 813 static s32 xmitframe_addmic(struct adapter *padapter, struct xmit_frame *pxmitframe) 814 { 815 sint curfragnum, length; 816 u8 *pframe, *payload, mic[8]; 817 struct mic_data micdata; 818 struct pkt_attrib *pattrib = &pxmitframe->attrib; 819 struct security_priv *psecuritypriv = &padapter->securitypriv; 820 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 821 u8 priority[4] = {0x0, 0x0, 0x0, 0x0}; 822 u8 hw_hdr_offset = 0; 823 sint bmcst = IS_MCAST(pattrib->ra); 824 825 hw_hdr_offset = TXDESC_OFFSET; 826 827 if (pattrib->encrypt == _TKIP_) { 828 /* encode mic code */ 829 { 830 u8 null_key[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; 831 832 pframe = pxmitframe->buf_addr + hw_hdr_offset; 833 834 if (bmcst) { 835 if (!memcmp(psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey, null_key, 16)) 836 return _FAIL; 837 /* start to calculate the mic code */ 838 rtw_secmicsetkey(&micdata, psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey); 839 } else { 840 if (!memcmp(&pattrib->dot11tkiptxmickey.skey[0], null_key, 16)) 841 return _FAIL; 842 /* start to calculate the mic code */ 843 rtw_secmicsetkey(&micdata, &pattrib->dot11tkiptxmickey.skey[0]); 844 } 845 846 if (pframe[1]&1) { /* ToDS == 1 */ 847 rtw_secmicappend(&micdata, &pframe[16], 6); /* DA */ 848 if (pframe[1]&2) /* From Ds == 1 */ 849 rtw_secmicappend(&micdata, &pframe[24], 6); 850 else 851 rtw_secmicappend(&micdata, &pframe[10], 6); 852 } else { /* ToDS == 0 */ 853 rtw_secmicappend(&micdata, &pframe[4], 6); /* DA */ 854 if (pframe[1]&2) /* From Ds == 1 */ 855 rtw_secmicappend(&micdata, &pframe[16], 6); 856 else 857 rtw_secmicappend(&micdata, &pframe[10], 6); 858 } 859 860 if (pattrib->qos_en) 861 priority[0] = (u8)pxmitframe->attrib.priority; 862 863 rtw_secmicappend(&micdata, &priority[0], 4); 864 865 payload = pframe; 866 867 for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) { 868 payload = (u8 *)RND4((SIZE_PTR)(payload)); 869 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("===curfragnum =%d, pframe = 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x, 0x%.2x,!!!\n", 870 curfragnum, *payload, *(payload+1), *(payload+2), *(payload+3), *(payload+4), *(payload+5), *(payload+6), *(payload+7))); 871 872 payload = payload+pattrib->hdrlen+pattrib->iv_len; 873 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("curfragnum =%d pattrib->hdrlen =%d pattrib->iv_len =%d", curfragnum, pattrib->hdrlen, pattrib->iv_len)); 874 if ((curfragnum+1) == pattrib->nr_frags) { 875 length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-((pattrib->bswenc) ? pattrib->icv_len : 0); 876 rtw_secmicappend(&micdata, payload, length); 877 payload = payload+length; 878 } else { 879 length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-((pattrib->bswenc) ? pattrib->icv_len : 0); 880 rtw_secmicappend(&micdata, payload, length); 881 payload = payload+length+pattrib->icv_len; 882 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("curfragnum =%d length =%d pattrib->icv_len =%d", curfragnum, length, pattrib->icv_len)); 883 } 884 } 885 rtw_secgetmic(&micdata, &mic[0]); 886 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("xmitframe_addmic: before add mic code!!!\n")); 887 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("xmitframe_addmic: pattrib->last_txcmdsz =%d!!!\n", pattrib->last_txcmdsz)); 888 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("xmitframe_addmic: mic[0]= 0x%.2x , mic[1]= 0x%.2x , mic[2]= 0x%.2x , mic[3]= 0x%.2x\n\ 889 mic[4]= 0x%.2x , mic[5]= 0x%.2x , mic[6]= 0x%.2x , mic[7]= 0x%.2x !!!!\n", 890 mic[0], mic[1], mic[2], mic[3], mic[4], mic[5], mic[6], mic[7])); 891 /* add mic code and add the mic code length in last_txcmdsz */ 892 893 memcpy(payload, &mic[0], 8); 894 pattrib->last_txcmdsz += 8; 895 896 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("\n ========last pkt ========\n")); 897 payload = payload-pattrib->last_txcmdsz+8; 898 for (curfragnum = 0; curfragnum < pattrib->last_txcmdsz; curfragnum = curfragnum+8) 899 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, (" %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x, %.2x ", 900 *(payload+curfragnum), *(payload+curfragnum+1), *(payload+curfragnum+2), *(payload+curfragnum+3), 901 *(payload+curfragnum+4), *(payload+curfragnum+5), *(payload+curfragnum+6), *(payload+curfragnum+7))); 902 } 903 /* 904 */ 905 } 906 return _SUCCESS; 907 } 908 909 static s32 xmitframe_swencrypt(struct adapter *padapter, struct xmit_frame *pxmitframe) 910 { 911 struct pkt_attrib *pattrib = &pxmitframe->attrib; 912 913 if (pattrib->bswenc) { 914 RT_TRACE(_module_rtl871x_xmit_c_, _drv_alert_, ("### xmitframe_swencrypt\n")); 915 switch (pattrib->encrypt) { 916 case _WEP40_: 917 case _WEP104_: 918 rtw_wep_encrypt(padapter, (u8 *)pxmitframe); 919 break; 920 case _TKIP_: 921 rtw_tkip_encrypt(padapter, (u8 *)pxmitframe); 922 break; 923 case _AES_: 924 rtw_aes_encrypt(padapter, (u8 *)pxmitframe); 925 break; 926 default: 927 break; 928 } 929 } else 930 RT_TRACE(_module_rtl871x_xmit_c_, _drv_notice_, ("### xmitframe_hwencrypt\n")); 931 932 return _SUCCESS; 933 } 934 935 s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattrib) 936 { 937 u16 *qc; 938 939 struct ieee80211_hdr *pwlanhdr = (struct ieee80211_hdr *)hdr; 940 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 941 struct qos_priv *pqospriv = &pmlmepriv->qospriv; 942 u8 qos_option = false; 943 sint res = _SUCCESS; 944 __le16 *fctrl = &pwlanhdr->frame_control; 945 946 memset(hdr, 0, WLANHDR_OFFSET); 947 948 SetFrameSubType(fctrl, pattrib->subtype); 949 950 if (pattrib->subtype & WIFI_DATA_TYPE) { 951 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 952 /* to_ds = 1, fr_ds = 0; */ 953 954 { 955 /* 1.Data transfer to AP */ 956 /* 2.Arp pkt will relayed by AP */ 957 SetToDs(fctrl); 958 memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN); 959 memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN); 960 memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN); 961 } 962 963 if (pqospriv->qos_option) 964 qos_option = true; 965 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) { 966 /* to_ds = 0, fr_ds = 1; */ 967 SetFrDs(fctrl); 968 memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN); 969 memcpy(pwlanhdr->addr2, get_bssid(pmlmepriv), ETH_ALEN); 970 memcpy(pwlanhdr->addr3, pattrib->src, ETH_ALEN); 971 972 if (pattrib->qos_en) 973 qos_option = true; 974 } else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) || 975 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) { 976 memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN); 977 memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN); 978 memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN); 979 980 if (pattrib->qos_en) 981 qos_option = true; 982 } else { 983 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("fw_state:%x is not allowed to xmit frame\n", get_fwstate(pmlmepriv))); 984 res = _FAIL; 985 goto exit; 986 } 987 988 if (pattrib->mdata) 989 SetMData(fctrl); 990 991 if (pattrib->encrypt) 992 SetPrivacy(fctrl); 993 994 if (qos_option) { 995 qc = (unsigned short *)(hdr + pattrib->hdrlen - 2); 996 997 if (pattrib->priority) 998 SetPriority(qc, pattrib->priority); 999 1000 SetEOSP(qc, pattrib->eosp); 1001 1002 SetAckpolicy(qc, pattrib->ack_policy); 1003 } 1004 1005 /* TODO: fill HT Control Field */ 1006 1007 /* Update Seq Num will be handled by f/w */ 1008 { 1009 struct sta_info *psta; 1010 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra); 1011 if (pattrib->psta != psta) { 1012 DBG_871X("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta); 1013 return _FAIL; 1014 } 1015 1016 if (!psta) { 1017 DBG_871X("%s, psta ==NUL\n", __func__); 1018 return _FAIL; 1019 } 1020 1021 if (!(psta->state & _FW_LINKED)) { 1022 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state); 1023 return _FAIL; 1024 } 1025 1026 if (psta) { 1027 psta->sta_xmitpriv.txseq_tid[pattrib->priority]++; 1028 psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF; 1029 pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority]; 1030 1031 SetSeqNum(hdr, pattrib->seqnum); 1032 1033 /* check if enable ampdu */ 1034 if (pattrib->ht_en && psta->htpriv.ampdu_enable) 1035 if (psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority)) 1036 pattrib->ampdu_en = true; 1037 1038 /* re-check if enable ampdu by BA_starting_seqctrl */ 1039 if (pattrib->ampdu_en == true) { 1040 u16 tx_seq; 1041 1042 tx_seq = psta->BA_starting_seqctrl[pattrib->priority & 0x0f]; 1043 1044 /* check BA_starting_seqctrl */ 1045 if (SN_LESS(pattrib->seqnum, tx_seq)) { 1046 pattrib->ampdu_en = false;/* AGG BK */ 1047 } else if (SN_EQUAL(pattrib->seqnum, tx_seq)) { 1048 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)&0xfff; 1049 1050 pattrib->ampdu_en = true;/* AGG EN */ 1051 } else { 1052 psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)&0xfff; 1053 pattrib->ampdu_en = true;/* AGG EN */ 1054 } 1055 } 1056 } 1057 } 1058 } else { 1059 } 1060 1061 exit: 1062 return res; 1063 } 1064 1065 s32 rtw_txframes_pending(struct adapter *padapter) 1066 { 1067 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 1068 1069 return ((!list_empty(&pxmitpriv->be_pending.queue)) || 1070 (!list_empty(&pxmitpriv->bk_pending.queue)) || 1071 (!list_empty(&pxmitpriv->vi_pending.queue)) || 1072 (!list_empty(&pxmitpriv->vo_pending.queue))); 1073 } 1074 1075 /* 1076 * Calculate wlan 802.11 packet MAX size from pkt_attrib 1077 * This function doesn't consider fragment case 1078 */ 1079 u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib) 1080 { 1081 u32 len = 0; 1082 1083 len = pattrib->hdrlen + pattrib->iv_len; /* WLAN Header and IV */ 1084 len += SNAP_SIZE + sizeof(u16); /* LLC */ 1085 len += pattrib->pktlen; 1086 if (pattrib->encrypt == _TKIP_) 1087 len += 8; /* MIC */ 1088 len += ((pattrib->bswenc) ? pattrib->icv_len : 0); /* ICV */ 1089 1090 return len; 1091 } 1092 1093 /* 1094 1095 This sub-routine will perform all the following: 1096 1097 1. remove 802.3 header. 1098 2. create wlan_header, based on the info in pxmitframe 1099 3. append sta's iv/ext-iv 1100 4. append LLC 1101 5. move frag chunk from pframe to pxmitframe->mem 1102 6. apply sw-encrypt, if necessary. 1103 1104 */ 1105 s32 rtw_xmitframe_coalesce(struct adapter *padapter, _pkt *pkt, struct xmit_frame *pxmitframe) 1106 { 1107 struct pkt_file pktfile; 1108 1109 s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz; 1110 1111 SIZE_PTR addr; 1112 1113 u8 *pframe, *mem_start; 1114 u8 hw_hdr_offset; 1115 1116 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 1117 1118 struct pkt_attrib *pattrib = &pxmitframe->attrib; 1119 1120 u8 *pbuf_start; 1121 1122 s32 bmcst = IS_MCAST(pattrib->ra); 1123 s32 res = _SUCCESS; 1124 1125 if (!pxmitframe->buf_addr) { 1126 DBG_8192C("==> %s buf_addr == NULL\n", __func__); 1127 return _FAIL; 1128 } 1129 1130 pbuf_start = pxmitframe->buf_addr; 1131 1132 hw_hdr_offset = TXDESC_OFFSET; 1133 mem_start = pbuf_start + hw_hdr_offset; 1134 1135 if (rtw_make_wlanhdr(padapter, mem_start, pattrib) == _FAIL) { 1136 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("rtw_xmitframe_coalesce: rtw_make_wlanhdr fail; drop pkt\n")); 1137 DBG_8192C("rtw_xmitframe_coalesce: rtw_make_wlanhdr fail; drop pkt\n"); 1138 res = _FAIL; 1139 goto exit; 1140 } 1141 1142 _rtw_open_pktfile(pkt, &pktfile); 1143 _rtw_pktfile_read(&pktfile, NULL, pattrib->pkt_hdrlen); 1144 1145 frg_inx = 0; 1146 frg_len = pxmitpriv->frag_len - 4;/* 2346-4 = 2342 */ 1147 1148 while (1) { 1149 llc_sz = 0; 1150 1151 mpdu_len = frg_len; 1152 1153 pframe = mem_start; 1154 1155 SetMFrag(mem_start); 1156 1157 pframe += pattrib->hdrlen; 1158 mpdu_len -= pattrib->hdrlen; 1159 1160 /* adding icv, if necessary... */ 1161 if (pattrib->iv_len) { 1162 memcpy(pframe, pattrib->iv, pattrib->iv_len); 1163 1164 RT_TRACE(_module_rtl871x_xmit_c_, _drv_notice_, 1165 ("rtw_xmitframe_coalesce: keyid =%d pattrib->iv[3]=%.2x pframe =%.2x %.2x %.2x %.2x\n", 1166 padapter->securitypriv.dot11PrivacyKeyIndex, pattrib->iv[3], *pframe, *(pframe+1), *(pframe+2), *(pframe+3))); 1167 1168 pframe += pattrib->iv_len; 1169 1170 mpdu_len -= pattrib->iv_len; 1171 } 1172 1173 if (frg_inx == 0) { 1174 llc_sz = rtw_put_snap(pframe, pattrib->ether_type); 1175 pframe += llc_sz; 1176 mpdu_len -= llc_sz; 1177 } 1178 1179 if ((pattrib->icv_len > 0) && (pattrib->bswenc)) 1180 mpdu_len -= pattrib->icv_len; 1181 1182 if (bmcst) { 1183 /* don't do fragment to broadcat/multicast packets */ 1184 mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen); 1185 } else { 1186 mem_sz = _rtw_pktfile_read(&pktfile, pframe, mpdu_len); 1187 } 1188 1189 pframe += mem_sz; 1190 1191 if ((pattrib->icv_len > 0) && (pattrib->bswenc)) { 1192 memcpy(pframe, pattrib->icv, pattrib->icv_len); 1193 pframe += pattrib->icv_len; 1194 } 1195 1196 frg_inx++; 1197 1198 if (bmcst || (rtw_endofpktfile(&pktfile) == true)) { 1199 pattrib->nr_frags = frg_inx; 1200 1201 pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len + ((pattrib->nr_frags == 1) ? llc_sz:0) + 1202 ((pattrib->bswenc) ? pattrib->icv_len : 0) + mem_sz; 1203 1204 ClearMFrag(mem_start); 1205 1206 break; 1207 } else 1208 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("%s: There're still something in packet!\n", __func__)); 1209 1210 addr = (SIZE_PTR)(pframe); 1211 1212 mem_start = (unsigned char *)RND4(addr) + hw_hdr_offset; 1213 memcpy(mem_start, pbuf_start + hw_hdr_offset, pattrib->hdrlen); 1214 } 1215 1216 if (xmitframe_addmic(padapter, pxmitframe) == _FAIL) { 1217 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("xmitframe_addmic(padapter, pxmitframe) == _FAIL\n")); 1218 DBG_8192C("xmitframe_addmic(padapter, pxmitframe) == _FAIL\n"); 1219 res = _FAIL; 1220 goto exit; 1221 } 1222 1223 xmitframe_swencrypt(padapter, pxmitframe); 1224 1225 if (bmcst == false) 1226 update_attrib_vcs_info(padapter, pxmitframe); 1227 else 1228 pattrib->vcs_mode = NONE_VCS; 1229 1230 exit: 1231 return res; 1232 } 1233 1234 /* broadcast or multicast management pkt use BIP, unicast management pkt use CCMP encryption */ 1235 s32 rtw_mgmt_xmitframe_coalesce(struct adapter *padapter, _pkt *pkt, struct xmit_frame *pxmitframe) 1236 { 1237 u8 *pframe, *mem_start = NULL, *tmp_buf = NULL; 1238 u8 subtype; 1239 struct sta_info *psta = NULL; 1240 struct pkt_attrib *pattrib = &pxmitframe->attrib; 1241 s32 bmcst = IS_MCAST(pattrib->ra); 1242 u8 *BIP_AAD = NULL; 1243 u8 *MGMT_body = NULL; 1244 1245 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1246 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1247 struct ieee80211_hdr *pwlanhdr; 1248 u8 MME[_MME_IE_LENGTH_]; 1249 u32 ori_len; 1250 mem_start = pframe = (u8 *)(pxmitframe->buf_addr) + TXDESC_OFFSET; 1251 pwlanhdr = (struct ieee80211_hdr *)pframe; 1252 1253 ori_len = BIP_AAD_SIZE+pattrib->pktlen; 1254 tmp_buf = BIP_AAD = rtw_zmalloc(ori_len); 1255 subtype = GetFrameSubType(pframe); /* bit(7)~bit(2) */ 1256 1257 if (!BIP_AAD) 1258 return _FAIL; 1259 1260 spin_lock_bh(&padapter->security_key_mutex); 1261 1262 /* only support station mode */ 1263 if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE) || !check_fwstate(pmlmepriv, _FW_LINKED)) 1264 goto xmitframe_coalesce_success; 1265 1266 /* IGTK key is not install, it may not support 802.11w */ 1267 if (padapter->securitypriv.binstallBIPkey != true) { 1268 DBG_871X("no instll BIP key\n"); 1269 goto xmitframe_coalesce_success; 1270 } 1271 /* station mode doesn't need TX BIP, just ready the code */ 1272 if (bmcst) { 1273 int frame_body_len; 1274 u8 mic[16]; 1275 1276 memset(MME, 0, 18); 1277 1278 /* other types doesn't need the BIP */ 1279 if (GetFrameSubType(pframe) != WIFI_DEAUTH && GetFrameSubType(pframe) != WIFI_DISASSOC) 1280 goto xmitframe_coalesce_fail; 1281 1282 MGMT_body = pframe + sizeof(struct ieee80211_hdr_3addr); 1283 pframe += pattrib->pktlen; 1284 1285 /* octent 0 and 1 is key index , BIP keyid is 4 or 5, LSB only need octent 0 */ 1286 MME[0] = padapter->securitypriv.dot11wBIPKeyid; 1287 /* copy packet number */ 1288 memcpy(&MME[2], &pmlmeext->mgnt_80211w_IPN, 6); 1289 /* increase the packet number */ 1290 pmlmeext->mgnt_80211w_IPN++; 1291 1292 /* add MME IE with MIC all zero, MME string doesn't include element id and length */ 1293 pframe = rtw_set_ie(pframe, _MME_IE_, 16, 1294 MME, &pattrib->pktlen); 1295 pattrib->last_txcmdsz = pattrib->pktlen; 1296 /* total frame length - header length */ 1297 frame_body_len = pattrib->pktlen - sizeof(struct ieee80211_hdr_3addr); 1298 1299 /* conscruct AAD, copy frame control field */ 1300 memcpy(BIP_AAD, &pwlanhdr->frame_control, 2); 1301 ClearRetry(BIP_AAD); 1302 ClearPwrMgt(BIP_AAD); 1303 ClearMData(BIP_AAD); 1304 /* conscruct AAD, copy address 1 to address 3 */ 1305 memcpy(BIP_AAD+2, pwlanhdr->addr1, 18); 1306 /* copy management fram body */ 1307 memcpy(BIP_AAD+BIP_AAD_SIZE, MGMT_body, frame_body_len); 1308 /* calculate mic */ 1309 if (omac1_aes_128(padapter->securitypriv.dot11wBIPKey[padapter->securitypriv.dot11wBIPKeyid].skey 1310 , BIP_AAD, BIP_AAD_SIZE+frame_body_len, mic)) 1311 goto xmitframe_coalesce_fail; 1312 1313 /* copy right BIP mic value, total is 128bits, we use the 0~63 bits */ 1314 memcpy(pframe-8, mic, 8); 1315 } else { /* unicast mgmt frame TX */ 1316 /* start to encrypt mgmt frame */ 1317 if (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC || 1318 subtype == WIFI_REASSOCREQ || subtype == WIFI_ACTION) { 1319 if (pattrib->psta) 1320 psta = pattrib->psta; 1321 else 1322 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra); 1323 1324 if (!psta) { 1325 DBG_871X("%s, psta ==NUL\n", __func__); 1326 goto xmitframe_coalesce_fail; 1327 } 1328 1329 if (!(psta->state & _FW_LINKED) || !pxmitframe->buf_addr) { 1330 DBG_871X("%s, not _FW_LINKED or addr null\n", __func__); 1331 goto xmitframe_coalesce_fail; 1332 } 1333 1334 /* according 802.11-2012 standard, these five types are not robust types */ 1335 if (subtype == WIFI_ACTION && 1336 (pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_PUBLIC || 1337 pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_HT || 1338 pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_UNPROTECTED_WNM || 1339 pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_SELF_PROTECTED || 1340 pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_P2P)) 1341 goto xmitframe_coalesce_fail; 1342 /* before encrypt dump the management packet content */ 1343 if (pattrib->encrypt > 0) 1344 memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16); 1345 /* bakeup original management packet */ 1346 memcpy(tmp_buf, pframe, pattrib->pktlen); 1347 /* move to data portion */ 1348 pframe += pattrib->hdrlen; 1349 1350 /* 802.11w unicast management packet must be _AES_ */ 1351 pattrib->iv_len = 8; 1352 /* it's MIC of AES */ 1353 pattrib->icv_len = 8; 1354 1355 switch (pattrib->encrypt) { 1356 case _AES_: 1357 /* set AES IV header */ 1358 AES_IV(pattrib->iv, psta->dot11wtxpn, 0); 1359 break; 1360 default: 1361 goto xmitframe_coalesce_fail; 1362 } 1363 /* insert iv header into management frame */ 1364 memcpy(pframe, pattrib->iv, pattrib->iv_len); 1365 pframe += pattrib->iv_len; 1366 /* copy mgmt data portion after CCMP header */ 1367 memcpy(pframe, tmp_buf+pattrib->hdrlen, pattrib->pktlen-pattrib->hdrlen); 1368 /* move pframe to end of mgmt pkt */ 1369 pframe += pattrib->pktlen-pattrib->hdrlen; 1370 /* add 8 bytes CCMP IV header to length */ 1371 pattrib->pktlen += pattrib->iv_len; 1372 if ((pattrib->icv_len > 0) && (pattrib->bswenc)) { 1373 memcpy(pframe, pattrib->icv, pattrib->icv_len); 1374 pframe += pattrib->icv_len; 1375 } 1376 /* add 8 bytes MIC */ 1377 pattrib->pktlen += pattrib->icv_len; 1378 /* set final tx command size */ 1379 pattrib->last_txcmdsz = pattrib->pktlen; 1380 1381 /* set protected bit must be beofre SW encrypt */ 1382 SetPrivacy(mem_start); 1383 /* software encrypt */ 1384 xmitframe_swencrypt(padapter, pxmitframe); 1385 } 1386 } 1387 1388 xmitframe_coalesce_success: 1389 spin_unlock_bh(&padapter->security_key_mutex); 1390 kfree(BIP_AAD); 1391 return _SUCCESS; 1392 1393 xmitframe_coalesce_fail: 1394 spin_unlock_bh(&padapter->security_key_mutex); 1395 kfree(BIP_AAD); 1396 return _FAIL; 1397 } 1398 1399 /* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header 1400 * IEEE LLC/SNAP header contains 8 octets 1401 * First 3 octets comprise the LLC portion 1402 * SNAP portion, 5 octets, is divided into two fields: 1403 *Organizationally Unique Identifier(OUI), 3 octets, 1404 *type, defined by that organization, 2 octets. 1405 */ 1406 s32 rtw_put_snap(u8 *data, u16 h_proto) 1407 { 1408 struct ieee80211_snap_hdr *snap; 1409 u8 *oui; 1410 1411 snap = (struct ieee80211_snap_hdr *)data; 1412 snap->dsap = 0xaa; 1413 snap->ssap = 0xaa; 1414 snap->ctrl = 0x03; 1415 1416 if (h_proto == 0x8137 || h_proto == 0x80f3) 1417 oui = P802_1H_OUI; 1418 else 1419 oui = RFC1042_OUI; 1420 1421 snap->oui[0] = oui[0]; 1422 snap->oui[1] = oui[1]; 1423 snap->oui[2] = oui[2]; 1424 1425 *(__be16 *)(data + SNAP_SIZE) = htons(h_proto); 1426 1427 return SNAP_SIZE + sizeof(u16); 1428 } 1429 1430 void rtw_update_protection(struct adapter *padapter, u8 *ie, uint ie_len) 1431 { 1432 uint protection; 1433 u8 *perp; 1434 sint erp_len; 1435 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 1436 struct registry_priv *pregistrypriv = &padapter->registrypriv; 1437 1438 switch (pxmitpriv->vcs_setting) { 1439 case DISABLE_VCS: 1440 pxmitpriv->vcs = NONE_VCS; 1441 break; 1442 1443 case ENABLE_VCS: 1444 break; 1445 1446 case AUTO_VCS: 1447 default: 1448 perp = rtw_get_ie(ie, _ERPINFO_IE_, &erp_len, ie_len); 1449 if (!perp) 1450 pxmitpriv->vcs = NONE_VCS; 1451 else { 1452 protection = (*(perp + 2)) & BIT(1); 1453 if (protection) { 1454 if (pregistrypriv->vcs_type == RTS_CTS) 1455 pxmitpriv->vcs = RTS_CTS; 1456 else 1457 pxmitpriv->vcs = CTS_TO_SELF; 1458 } else 1459 pxmitpriv->vcs = NONE_VCS; 1460 } 1461 1462 break; 1463 } 1464 } 1465 1466 void rtw_count_tx_stats(struct adapter *padapter, struct xmit_frame *pxmitframe, int sz) 1467 { 1468 struct sta_info *psta = NULL; 1469 struct stainfo_stats *pstats = NULL; 1470 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 1471 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1472 u8 pkt_num = 1; 1473 1474 if ((pxmitframe->frame_tag&0x0f) == DATA_FRAMETAG) { 1475 pkt_num = pxmitframe->agg_num; 1476 1477 pmlmepriv->LinkDetectInfo.NumTxOkInPeriod += pkt_num; 1478 1479 pxmitpriv->tx_pkts += pkt_num; 1480 1481 pxmitpriv->tx_bytes += sz; 1482 1483 psta = pxmitframe->attrib.psta; 1484 if (psta) { 1485 pstats = &psta->sta_stats; 1486 1487 pstats->tx_pkts += pkt_num; 1488 1489 pstats->tx_bytes += sz; 1490 } 1491 } 1492 } 1493 1494 static struct xmit_buf *__rtw_alloc_cmd_xmitbuf(struct xmit_priv *pxmitpriv, 1495 enum cmdbuf_type buf_type) 1496 { 1497 struct xmit_buf *pxmitbuf = NULL; 1498 1499 pxmitbuf = &pxmitpriv->pcmd_xmitbuf[buf_type]; 1500 if (pxmitbuf) { 1501 pxmitbuf->priv_data = NULL; 1502 1503 pxmitbuf->len = 0; 1504 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead; 1505 pxmitbuf->agg_num = 0; 1506 pxmitbuf->pg_num = 0; 1507 1508 if (pxmitbuf->sctx) { 1509 DBG_871X("%s pxmitbuf->sctx is not NULL\n", __func__); 1510 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC); 1511 } 1512 } else 1513 DBG_871X("%s fail, no xmitbuf available !!!\n", __func__); 1514 1515 return pxmitbuf; 1516 } 1517 1518 struct xmit_frame *__rtw_alloc_cmdxmitframe(struct xmit_priv *pxmitpriv, 1519 enum cmdbuf_type buf_type) 1520 { 1521 struct xmit_frame *pcmdframe; 1522 struct xmit_buf *pxmitbuf; 1523 1524 pcmdframe = rtw_alloc_xmitframe(pxmitpriv); 1525 if (!pcmdframe) { 1526 DBG_871X("%s, alloc xmitframe fail\n", __func__); 1527 return NULL; 1528 } 1529 1530 pxmitbuf = __rtw_alloc_cmd_xmitbuf(pxmitpriv, buf_type); 1531 if (!pxmitbuf) { 1532 DBG_871X("%s, alloc xmitbuf fail\n", __func__); 1533 rtw_free_xmitframe(pxmitpriv, pcmdframe); 1534 return NULL; 1535 } 1536 1537 pcmdframe->frame_tag = MGNT_FRAMETAG; 1538 1539 pcmdframe->pxmitbuf = pxmitbuf; 1540 1541 pcmdframe->buf_addr = pxmitbuf->pbuf; 1542 1543 pxmitbuf->priv_data = pcmdframe; 1544 1545 return pcmdframe; 1546 } 1547 1548 struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv) 1549 { 1550 _irqL irqL; 1551 struct xmit_buf *pxmitbuf = NULL; 1552 struct list_head *plist, *phead; 1553 struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue; 1554 1555 spin_lock_irqsave(&pfree_queue->lock, irqL); 1556 1557 if (list_empty(&pfree_queue->queue)) { 1558 pxmitbuf = NULL; 1559 } else { 1560 phead = get_list_head(pfree_queue); 1561 1562 plist = get_next(phead); 1563 1564 pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); 1565 1566 list_del_init(&pxmitbuf->list); 1567 } 1568 1569 if (pxmitbuf) { 1570 pxmitpriv->free_xmit_extbuf_cnt--; 1571 #ifdef DBG_XMIT_BUF_EXT 1572 DBG_871X("DBG_XMIT_BUF_EXT ALLOC no =%d, free_xmit_extbuf_cnt =%d\n", pxmitbuf->no, pxmitpriv->free_xmit_extbuf_cnt); 1573 #endif 1574 1575 pxmitbuf->priv_data = NULL; 1576 1577 pxmitbuf->len = 0; 1578 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead; 1579 pxmitbuf->agg_num = 1; 1580 1581 if (pxmitbuf->sctx) { 1582 DBG_871X("%s pxmitbuf->sctx is not NULL\n", __func__); 1583 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC); 1584 } 1585 } 1586 1587 spin_unlock_irqrestore(&pfree_queue->lock, irqL); 1588 1589 return pxmitbuf; 1590 } 1591 1592 s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf) 1593 { 1594 _irqL irqL; 1595 struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue; 1596 1597 if (!pxmitbuf) 1598 return _FAIL; 1599 1600 spin_lock_irqsave(&pfree_queue->lock, irqL); 1601 1602 list_del_init(&pxmitbuf->list); 1603 1604 list_add_tail(&pxmitbuf->list, get_list_head(pfree_queue)); 1605 pxmitpriv->free_xmit_extbuf_cnt++; 1606 #ifdef DBG_XMIT_BUF_EXT 1607 DBG_871X("DBG_XMIT_BUF_EXT FREE no =%d, free_xmit_extbuf_cnt =%d\n", pxmitbuf->no, pxmitpriv->free_xmit_extbuf_cnt); 1608 #endif 1609 1610 spin_unlock_irqrestore(&pfree_queue->lock, irqL); 1611 1612 return _SUCCESS; 1613 } 1614 1615 struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv) 1616 { 1617 _irqL irqL; 1618 struct xmit_buf *pxmitbuf = NULL; 1619 struct list_head *plist, *phead; 1620 struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue; 1621 1622 spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL); 1623 1624 if (list_empty(&pfree_xmitbuf_queue->queue)) { 1625 pxmitbuf = NULL; 1626 } else { 1627 phead = get_list_head(pfree_xmitbuf_queue); 1628 1629 plist = get_next(phead); 1630 1631 pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); 1632 1633 list_del_init(&pxmitbuf->list); 1634 } 1635 1636 if (pxmitbuf) { 1637 pxmitpriv->free_xmitbuf_cnt--; 1638 #ifdef DBG_XMIT_BUF 1639 DBG_871X("DBG_XMIT_BUF ALLOC no =%d, free_xmitbuf_cnt =%d\n", pxmitbuf->no, pxmitpriv->free_xmitbuf_cnt); 1640 #endif 1641 1642 pxmitbuf->priv_data = NULL; 1643 1644 pxmitbuf->len = 0; 1645 pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead; 1646 pxmitbuf->agg_num = 0; 1647 pxmitbuf->pg_num = 0; 1648 1649 if (pxmitbuf->sctx) { 1650 DBG_871X("%s pxmitbuf->sctx is not NULL\n", __func__); 1651 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC); 1652 } 1653 } 1654 #ifdef DBG_XMIT_BUF 1655 else 1656 DBG_871X("DBG_XMIT_BUF rtw_alloc_xmitbuf return NULL\n"); 1657 #endif 1658 1659 spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL); 1660 1661 return pxmitbuf; 1662 } 1663 1664 s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf) 1665 { 1666 _irqL irqL; 1667 struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue; 1668 1669 if (!pxmitbuf) 1670 return _FAIL; 1671 1672 if (pxmitbuf->sctx) { 1673 DBG_871X("%s pxmitbuf->sctx is not NULL\n", __func__); 1674 rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_FREE); 1675 } 1676 1677 if (pxmitbuf->buf_tag == XMITBUF_CMD) { 1678 } else if (pxmitbuf->buf_tag == XMITBUF_MGNT) { 1679 rtw_free_xmitbuf_ext(pxmitpriv, pxmitbuf); 1680 } else { 1681 spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL); 1682 1683 list_del_init(&pxmitbuf->list); 1684 1685 list_add_tail(&pxmitbuf->list, 1686 get_list_head(pfree_xmitbuf_queue)); 1687 1688 pxmitpriv->free_xmitbuf_cnt++; 1689 #ifdef DBG_XMIT_BUF 1690 DBG_871X("DBG_XMIT_BUF FREE no =%d, free_xmitbuf_cnt =%d\n", pxmitbuf->no, pxmitpriv->free_xmitbuf_cnt); 1691 #endif 1692 spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL); 1693 } 1694 return _SUCCESS; 1695 } 1696 1697 static void rtw_init_xmitframe(struct xmit_frame *pxframe) 1698 { 1699 if (pxframe) { /* default value setting */ 1700 pxframe->buf_addr = NULL; 1701 pxframe->pxmitbuf = NULL; 1702 1703 memset(&pxframe->attrib, 0, sizeof(struct pkt_attrib)); 1704 1705 pxframe->frame_tag = DATA_FRAMETAG; 1706 1707 pxframe->pg_num = 1; 1708 pxframe->agg_num = 1; 1709 pxframe->ack_report = 0; 1710 } 1711 } 1712 1713 /* 1714 Calling context: 1715 1. OS_TXENTRY 1716 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack) 1717 1718 If we turn on USE_RXTHREAD, then, no need for critical section. 1719 Otherwise, we must use _enter/_exit critical to protect free_xmit_queue... 1720 1721 Must be very very cautious... 1722 1723 */ 1724 struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv)/* _queue *pfree_xmit_queue) */ 1725 { 1726 /* 1727 Please remember to use all the osdep_service api, 1728 and lock/unlock or _enter/_exit critical to protect 1729 pfree_xmit_queue 1730 */ 1731 1732 struct xmit_frame *pxframe = NULL; 1733 struct list_head *plist, *phead; 1734 struct __queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue; 1735 1736 spin_lock_bh(&pfree_xmit_queue->lock); 1737 1738 if (list_empty(&pfree_xmit_queue->queue)) { 1739 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_alloc_xmitframe:%d\n", pxmitpriv->free_xmitframe_cnt)); 1740 pxframe = NULL; 1741 } else { 1742 phead = get_list_head(pfree_xmit_queue); 1743 1744 plist = get_next(phead); 1745 1746 pxframe = LIST_CONTAINOR(plist, struct xmit_frame, list); 1747 1748 list_del_init(&pxframe->list); 1749 pxmitpriv->free_xmitframe_cnt--; 1750 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_alloc_xmitframe():free_xmitframe_cnt =%d\n", pxmitpriv->free_xmitframe_cnt)); 1751 } 1752 1753 spin_unlock_bh(&pfree_xmit_queue->lock); 1754 1755 rtw_init_xmitframe(pxframe); 1756 return pxframe; 1757 } 1758 1759 struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv) 1760 { 1761 struct xmit_frame *pxframe = NULL; 1762 struct list_head *plist, *phead; 1763 struct __queue *queue = &pxmitpriv->free_xframe_ext_queue; 1764 1765 spin_lock_bh(&queue->lock); 1766 1767 if (list_empty(&queue->queue)) { 1768 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_alloc_xmitframe_ext:%d\n", pxmitpriv->free_xframe_ext_cnt)); 1769 pxframe = NULL; 1770 } else { 1771 phead = get_list_head(queue); 1772 plist = get_next(phead); 1773 pxframe = LIST_CONTAINOR(plist, struct xmit_frame, list); 1774 1775 list_del_init(&pxframe->list); 1776 pxmitpriv->free_xframe_ext_cnt--; 1777 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_alloc_xmitframe_ext():free_xmitframe_cnt =%d\n", pxmitpriv->free_xframe_ext_cnt)); 1778 } 1779 1780 spin_unlock_bh(&queue->lock); 1781 1782 rtw_init_xmitframe(pxframe); 1783 1784 return pxframe; 1785 } 1786 1787 struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv) 1788 { 1789 struct xmit_frame *pxframe = NULL; 1790 u8 *alloc_addr; 1791 1792 alloc_addr = rtw_zmalloc(sizeof(struct xmit_frame) + 4); 1793 1794 if (!alloc_addr) 1795 goto exit; 1796 1797 pxframe = (struct xmit_frame *)N_BYTE_ALIGMENT((SIZE_PTR)(alloc_addr), 4); 1798 pxframe->alloc_addr = alloc_addr; 1799 1800 pxframe->padapter = pxmitpriv->adapter; 1801 pxframe->frame_tag = NULL_FRAMETAG; 1802 1803 pxframe->pkt = NULL; 1804 1805 pxframe->buf_addr = NULL; 1806 pxframe->pxmitbuf = NULL; 1807 1808 rtw_init_xmitframe(pxframe); 1809 1810 DBG_871X("################## %s ##################\n", __func__); 1811 1812 exit: 1813 return pxframe; 1814 } 1815 1816 s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe) 1817 { 1818 struct __queue *queue = NULL; 1819 struct adapter *padapter = pxmitpriv->adapter; 1820 _pkt *pndis_pkt = NULL; 1821 1822 if (!pxmitframe) { 1823 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("======rtw_free_xmitframe():pxmitframe == NULL!!!!!!!!!!\n")); 1824 goto exit; 1825 } 1826 1827 if (pxmitframe->pkt) { 1828 pndis_pkt = pxmitframe->pkt; 1829 pxmitframe->pkt = NULL; 1830 } 1831 1832 if (pxmitframe->alloc_addr) { 1833 DBG_871X("################## %s with alloc_addr ##################\n", __func__); 1834 kfree(pxmitframe->alloc_addr); 1835 goto check_pkt_complete; 1836 } 1837 1838 if (pxmitframe->ext_tag == 0) 1839 queue = &pxmitpriv->free_xmit_queue; 1840 else if (pxmitframe->ext_tag == 1) 1841 queue = &pxmitpriv->free_xframe_ext_queue; 1842 else { 1843 } 1844 1845 spin_lock_bh(&queue->lock); 1846 1847 list_del_init(&pxmitframe->list); 1848 list_add_tail(&pxmitframe->list, get_list_head(queue)); 1849 if (pxmitframe->ext_tag == 0) { 1850 pxmitpriv->free_xmitframe_cnt++; 1851 RT_TRACE(_module_rtl871x_xmit_c_, _drv_debug_, ("rtw_free_xmitframe():free_xmitframe_cnt =%d\n", pxmitpriv->free_xmitframe_cnt)); 1852 } else if (pxmitframe->ext_tag == 1) { 1853 pxmitpriv->free_xframe_ext_cnt++; 1854 RT_TRACE(_module_rtl871x_xmit_c_, _drv_debug_, ("rtw_free_xmitframe():free_xframe_ext_cnt =%d\n", pxmitpriv->free_xframe_ext_cnt)); 1855 } else { 1856 } 1857 1858 spin_unlock_bh(&queue->lock); 1859 1860 check_pkt_complete: 1861 1862 if (pndis_pkt) 1863 rtw_os_pkt_complete(padapter, pndis_pkt); 1864 1865 exit: 1866 return _SUCCESS; 1867 } 1868 1869 void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, struct __queue *pframequeue) 1870 { 1871 struct list_head *plist, *phead; 1872 struct xmit_frame *pxmitframe; 1873 1874 spin_lock_bh(&pframequeue->lock); 1875 1876 phead = get_list_head(pframequeue); 1877 plist = get_next(phead); 1878 1879 while (phead != plist) { 1880 pxmitframe = LIST_CONTAINOR(plist, struct xmit_frame, list); 1881 1882 plist = get_next(plist); 1883 1884 rtw_free_xmitframe(pxmitpriv, pxmitframe); 1885 } 1886 spin_unlock_bh(&pframequeue->lock); 1887 } 1888 1889 s32 rtw_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe) 1890 { 1891 DBG_COUNTER(padapter->tx_logs.core_tx_enqueue); 1892 if (rtw_xmit_classifier(padapter, pxmitframe) == _FAIL) { 1893 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, 1894 ("rtw_xmitframe_enqueue: drop xmit pkt for classifier fail\n")); 1895 return _FAIL; 1896 } 1897 1898 return _SUCCESS; 1899 } 1900 1901 struct tx_servq *rtw_get_sta_pending(struct adapter *padapter, struct sta_info *psta, sint up, u8 *ac) 1902 { 1903 struct tx_servq *ptxservq = NULL; 1904 1905 switch (up) { 1906 case 1: 1907 case 2: 1908 ptxservq = &psta->sta_xmitpriv.bk_q; 1909 *(ac) = 3; 1910 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_get_sta_pending : BK\n")); 1911 break; 1912 1913 case 4: 1914 case 5: 1915 ptxservq = &psta->sta_xmitpriv.vi_q; 1916 *(ac) = 1; 1917 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_get_sta_pending : VI\n")); 1918 break; 1919 1920 case 6: 1921 case 7: 1922 ptxservq = &psta->sta_xmitpriv.vo_q; 1923 *(ac) = 0; 1924 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_get_sta_pending : VO\n")); 1925 break; 1926 1927 case 0: 1928 case 3: 1929 default: 1930 ptxservq = &psta->sta_xmitpriv.be_q; 1931 *(ac) = 2; 1932 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("rtw_get_sta_pending : BE\n")); 1933 break; 1934 } 1935 1936 return ptxservq; 1937 } 1938 1939 /* 1940 * Will enqueue pxmitframe to the proper queue, 1941 * and indicate it to xx_pending list..... 1942 */ 1943 s32 rtw_xmit_classifier(struct adapter *padapter, struct xmit_frame *pxmitframe) 1944 { 1945 u8 ac_index; 1946 struct sta_info *psta; 1947 struct tx_servq *ptxservq; 1948 struct pkt_attrib *pattrib = &pxmitframe->attrib; 1949 struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits; 1950 sint res = _SUCCESS; 1951 1952 DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class); 1953 1954 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra); 1955 if (pattrib->psta != psta) { 1956 DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class_err_sta); 1957 DBG_871X("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta); 1958 return _FAIL; 1959 } 1960 1961 if (!psta) { 1962 DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class_err_nosta); 1963 res = _FAIL; 1964 DBG_8192C("rtw_xmit_classifier: psta == NULL\n"); 1965 RT_TRACE(_module_rtl871x_xmit_c_, _drv_err_, ("rtw_xmit_classifier: psta == NULL\n")); 1966 goto exit; 1967 } 1968 1969 if (!(psta->state & _FW_LINKED)) { 1970 DBG_COUNTER(padapter->tx_logs.core_tx_enqueue_class_err_fwlink); 1971 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state); 1972 return _FAIL; 1973 } 1974 1975 ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index)); 1976 1977 if (list_empty(&ptxservq->tx_pending)) 1978 list_add_tail(&ptxservq->tx_pending, get_list_head(phwxmits[ac_index].sta_queue)); 1979 1980 list_add_tail(&pxmitframe->list, get_list_head(&ptxservq->sta_pending)); 1981 ptxservq->qcnt++; 1982 phwxmits[ac_index].accnt++; 1983 1984 exit: 1985 1986 return res; 1987 } 1988 1989 s32 rtw_alloc_hwxmits(struct adapter *padapter) 1990 { 1991 struct hw_xmit *hwxmits; 1992 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 1993 1994 pxmitpriv->hwxmit_entry = HWXMIT_ENTRY; 1995 1996 pxmitpriv->hwxmits = NULL; 1997 1998 pxmitpriv->hwxmits = rtw_zmalloc(sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry); 1999 2000 if (!pxmitpriv->hwxmits) 2001 return _FAIL; 2002 2003 hwxmits = pxmitpriv->hwxmits; 2004 2005 if (pxmitpriv->hwxmit_entry == 5) { 2006 hwxmits[0] .sta_queue = &pxmitpriv->bm_pending; 2007 2008 hwxmits[1] .sta_queue = &pxmitpriv->vo_pending; 2009 2010 hwxmits[2] .sta_queue = &pxmitpriv->vi_pending; 2011 2012 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending; 2013 2014 hwxmits[4] .sta_queue = &pxmitpriv->be_pending; 2015 } else if (pxmitpriv->hwxmit_entry == 4) { 2016 hwxmits[0] .sta_queue = &pxmitpriv->vo_pending; 2017 2018 hwxmits[1] .sta_queue = &pxmitpriv->vi_pending; 2019 2020 hwxmits[2] .sta_queue = &pxmitpriv->be_pending; 2021 2022 hwxmits[3] .sta_queue = &pxmitpriv->bk_pending; 2023 } else { 2024 } 2025 2026 return _SUCCESS; 2027 } 2028 2029 void rtw_free_hwxmits(struct adapter *padapter) 2030 { 2031 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 2032 2033 kfree(pxmitpriv->hwxmits); 2034 } 2035 2036 void rtw_init_hwxmits(struct hw_xmit *phwxmit, sint entry) 2037 { 2038 sint i; 2039 2040 for (i = 0; i < entry; i++, phwxmit++) 2041 phwxmit->accnt = 0; 2042 } 2043 2044 u32 rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe) 2045 { 2046 u32 addr; 2047 struct pkt_attrib *pattrib = &pxmitframe->attrib; 2048 2049 switch (pattrib->qsel) { 2050 case 0: 2051 case 3: 2052 addr = BE_QUEUE_INX; 2053 break; 2054 case 1: 2055 case 2: 2056 addr = BK_QUEUE_INX; 2057 break; 2058 case 4: 2059 case 5: 2060 addr = VI_QUEUE_INX; 2061 break; 2062 case 6: 2063 case 7: 2064 addr = VO_QUEUE_INX; 2065 break; 2066 case 0x10: 2067 addr = BCN_QUEUE_INX; 2068 break; 2069 case 0x11:/* BC/MC in PS (HIQ) */ 2070 addr = HIGH_QUEUE_INX; 2071 break; 2072 case 0x12: 2073 default: 2074 addr = MGT_QUEUE_INX; 2075 break; 2076 } 2077 2078 return addr; 2079 } 2080 2081 static void do_queue_select(struct adapter *padapter, struct pkt_attrib *pattrib) 2082 { 2083 u8 qsel; 2084 2085 qsel = pattrib->priority; 2086 RT_TRACE(_module_rtl871x_xmit_c_, _drv_info_, ("### do_queue_select priority =%d , qsel = %d\n", pattrib->priority, qsel)); 2087 2088 pattrib->qsel = qsel; 2089 } 2090 2091 /* 2092 * The main transmit(tx) entry 2093 * 2094 * Return 2095 *1 enqueue 2096 *0 success, hardware will handle this xmit frame(packet) 2097 *<0 fail 2098 */ 2099 s32 rtw_xmit(struct adapter *padapter, _pkt **ppkt) 2100 { 2101 static unsigned long start; 2102 static u32 drop_cnt; 2103 2104 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 2105 struct xmit_frame *pxmitframe = NULL; 2106 2107 s32 res; 2108 2109 DBG_COUNTER(padapter->tx_logs.core_tx); 2110 2111 if (start == 0) 2112 start = jiffies; 2113 2114 pxmitframe = rtw_alloc_xmitframe(pxmitpriv); 2115 2116 if (jiffies_to_msecs(jiffies - start) > 2000) { 2117 if (drop_cnt) 2118 DBG_871X("DBG_TX_DROP_FRAME %s no more pxmitframe, drop_cnt:%u\n", __func__, drop_cnt); 2119 start = jiffies; 2120 drop_cnt = 0; 2121 } 2122 2123 if (!pxmitframe) { 2124 drop_cnt++; 2125 RT_TRACE(_module_xmit_osdep_c_, _drv_err_, ("%s: no more pxmitframe\n", __func__)); 2126 DBG_COUNTER(padapter->tx_logs.core_tx_err_pxmitframe); 2127 return -1; 2128 } 2129 2130 res = update_attrib(padapter, *ppkt, &pxmitframe->attrib); 2131 2132 if (res == _FAIL) { 2133 RT_TRACE(_module_xmit_osdep_c_, _drv_err_, ("%s: update attrib fail\n", __func__)); 2134 #ifdef DBG_TX_DROP_FRAME 2135 DBG_871X("DBG_TX_DROP_FRAME %s update attrib fail\n", __func__); 2136 #endif 2137 rtw_free_xmitframe(pxmitpriv, pxmitframe); 2138 return -1; 2139 } 2140 pxmitframe->pkt = *ppkt; 2141 2142 do_queue_select(padapter, &pxmitframe->attrib); 2143 2144 spin_lock_bh(&pxmitpriv->lock); 2145 if (xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe) == true) { 2146 spin_unlock_bh(&pxmitpriv->lock); 2147 DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue); 2148 return 1; 2149 } 2150 spin_unlock_bh(&pxmitpriv->lock); 2151 2152 /* pre_xmitframe */ 2153 if (rtw_hal_xmit(padapter, pxmitframe) == false) 2154 return 1; 2155 2156 return 0; 2157 } 2158 2159 #define RTW_HIQ_FILTER_ALLOW_ALL 0 2160 #define RTW_HIQ_FILTER_ALLOW_SPECIAL 1 2161 #define RTW_HIQ_FILTER_DENY_ALL 2 2162 2163 inline bool xmitframe_hiq_filter(struct xmit_frame *xmitframe) 2164 { 2165 bool allow = false; 2166 struct adapter *adapter = xmitframe->padapter; 2167 struct registry_priv *registry = &adapter->registrypriv; 2168 2169 if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_SPECIAL) { 2170 struct pkt_attrib *attrib = &xmitframe->attrib; 2171 2172 if (attrib->ether_type == 0x0806 2173 || attrib->ether_type == 0x888e 2174 || attrib->dhcp_pkt 2175 ) { 2176 DBG_871X(FUNC_ADPT_FMT" ether_type:0x%04x%s\n", FUNC_ADPT_ARG(xmitframe->padapter) 2177 , attrib->ether_type, attrib->dhcp_pkt?" DHCP":""); 2178 allow = true; 2179 } 2180 } else if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_ALL) 2181 allow = true; 2182 else if (registry->hiq_filter == RTW_HIQ_FILTER_DENY_ALL) { 2183 } else 2184 rtw_warn_on(1); 2185 2186 return allow; 2187 } 2188 2189 sint xmitframe_enqueue_for_sleeping_sta(struct adapter *padapter, struct xmit_frame *pxmitframe) 2190 { 2191 sint ret = false; 2192 struct sta_info *psta = NULL; 2193 struct sta_priv *pstapriv = &padapter->stapriv; 2194 struct pkt_attrib *pattrib = &pxmitframe->attrib; 2195 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2196 sint bmcst = IS_MCAST(pattrib->ra); 2197 bool update_tim = false; 2198 2199 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == false) { 2200 DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_fwstate); 2201 return ret; 2202 } 2203 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra); 2204 if (pattrib->psta != psta) { 2205 DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_sta); 2206 DBG_871X("%s, pattrib->psta(%p) != psta(%p)\n", __func__, pattrib->psta, psta); 2207 return false; 2208 } 2209 2210 if (!psta) { 2211 DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_nosta); 2212 DBG_871X("%s, psta ==NUL\n", __func__); 2213 return false; 2214 } 2215 2216 if (!(psta->state & _FW_LINKED)) { 2217 DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_link); 2218 DBG_871X("%s, psta->state(0x%x) != _FW_LINKED\n", __func__, psta->state); 2219 return false; 2220 } 2221 2222 if (pattrib->triggered == 1) { 2223 DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_warn_trigger); 2224 2225 if (bmcst && xmitframe_hiq_filter(pxmitframe)) 2226 pattrib->qsel = 0x11;/* HIQ */ 2227 2228 return ret; 2229 } 2230 2231 if (bmcst) { 2232 spin_lock_bh(&psta->sleep_q.lock); 2233 2234 if (pstapriv->sta_dz_bitmap) { /* if anyone sta is in ps mode */ 2235 /* pattrib->qsel = 0x11;HIQ */ 2236 2237 list_del_init(&pxmitframe->list); 2238 2239 list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q)); 2240 2241 psta->sleepq_len++; 2242 2243 if (!(pstapriv->tim_bitmap & BIT(0))) 2244 update_tim = true; 2245 2246 pstapriv->tim_bitmap |= BIT(0); 2247 pstapriv->sta_dz_bitmap |= BIT(0); 2248 2249 if (update_tim) 2250 update_beacon(padapter, _TIM_IE_, NULL, true); 2251 else 2252 chk_bmc_sleepq_cmd(padapter); 2253 2254 ret = true; 2255 2256 DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_mcast); 2257 } 2258 2259 spin_unlock_bh(&psta->sleep_q.lock); 2260 2261 return ret; 2262 } 2263 2264 spin_lock_bh(&psta->sleep_q.lock); 2265 2266 if (psta->state&WIFI_SLEEP_STATE) { 2267 u8 wmmps_ac = 0; 2268 2269 if (pstapriv->sta_dz_bitmap & BIT(psta->aid)) { 2270 list_del_init(&pxmitframe->list); 2271 2272 list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q)); 2273 2274 psta->sleepq_len++; 2275 2276 switch (pattrib->priority) { 2277 case 1: 2278 case 2: 2279 wmmps_ac = psta->uapsd_bk&BIT(0); 2280 break; 2281 case 4: 2282 case 5: 2283 wmmps_ac = psta->uapsd_vi&BIT(0); 2284 break; 2285 case 6: 2286 case 7: 2287 wmmps_ac = psta->uapsd_vo&BIT(0); 2288 break; 2289 case 0: 2290 case 3: 2291 default: 2292 wmmps_ac = psta->uapsd_be&BIT(0); 2293 break; 2294 } 2295 2296 if (wmmps_ac) 2297 psta->sleepq_ac_len++; 2298 2299 if (((psta->has_legacy_ac) && (!wmmps_ac)) || ((!psta->has_legacy_ac) && (wmmps_ac))) { 2300 if (!(pstapriv->tim_bitmap & BIT(psta->aid))) 2301 update_tim = true; 2302 2303 pstapriv->tim_bitmap |= BIT(psta->aid); 2304 2305 if (update_tim) 2306 /* upate BCN for TIM IE */ 2307 update_beacon(padapter, _TIM_IE_, NULL, true); 2308 } 2309 2310 ret = true; 2311 2312 DBG_COUNTER(padapter->tx_logs.core_tx_ap_enqueue_ucast); 2313 } 2314 } 2315 2316 spin_unlock_bh(&psta->sleep_q.lock); 2317 2318 return ret; 2319 } 2320 2321 static void dequeue_xmitframes_to_sleeping_queue(struct adapter *padapter, struct sta_info *psta, struct __queue *pframequeue) 2322 { 2323 sint ret; 2324 struct list_head *plist, *phead; 2325 u8 ac_index; 2326 struct tx_servq *ptxservq; 2327 struct pkt_attrib *pattrib; 2328 struct xmit_frame *pxmitframe; 2329 struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits; 2330 2331 phead = get_list_head(pframequeue); 2332 plist = get_next(phead); 2333 2334 while (phead != plist) { 2335 pxmitframe = LIST_CONTAINOR(plist, struct xmit_frame, list); 2336 2337 plist = get_next(plist); 2338 2339 pattrib = &pxmitframe->attrib; 2340 2341 pattrib->triggered = 0; 2342 2343 ret = xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe); 2344 2345 if (true == ret) { 2346 ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index)); 2347 2348 ptxservq->qcnt--; 2349 phwxmits[ac_index].accnt--; 2350 } else { 2351 } 2352 } 2353 } 2354 2355 void stop_sta_xmit(struct adapter *padapter, struct sta_info *psta) 2356 { 2357 struct sta_info *psta_bmc; 2358 struct sta_xmit_priv *pstaxmitpriv; 2359 struct sta_priv *pstapriv = &padapter->stapriv; 2360 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 2361 2362 pstaxmitpriv = &psta->sta_xmitpriv; 2363 2364 /* for BC/MC Frames */ 2365 psta_bmc = rtw_get_bcmc_stainfo(padapter); 2366 2367 spin_lock_bh(&pxmitpriv->lock); 2368 2369 psta->state |= WIFI_SLEEP_STATE; 2370 2371 pstapriv->sta_dz_bitmap |= BIT(psta->aid); 2372 2373 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending); 2374 list_del_init(&pstaxmitpriv->vo_q.tx_pending); 2375 2376 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending); 2377 list_del_init(&pstaxmitpriv->vi_q.tx_pending); 2378 2379 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending); 2380 list_del_init(&pstaxmitpriv->be_q.tx_pending); 2381 2382 dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending); 2383 list_del_init(&pstaxmitpriv->bk_q.tx_pending); 2384 2385 /* for BC/MC Frames */ 2386 pstaxmitpriv = &psta_bmc->sta_xmitpriv; 2387 dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->be_q.sta_pending); 2388 list_del_init(&pstaxmitpriv->be_q.tx_pending); 2389 2390 spin_unlock_bh(&pxmitpriv->lock); 2391 } 2392 2393 void wakeup_sta_to_xmit(struct adapter *padapter, struct sta_info *psta) 2394 { 2395 u8 update_mask = 0, wmmps_ac = 0; 2396 struct sta_info *psta_bmc; 2397 struct list_head *xmitframe_plist, *xmitframe_phead; 2398 struct xmit_frame *pxmitframe = NULL; 2399 struct sta_priv *pstapriv = &padapter->stapriv; 2400 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 2401 2402 psta_bmc = rtw_get_bcmc_stainfo(padapter); 2403 2404 spin_lock_bh(&pxmitpriv->lock); 2405 2406 xmitframe_phead = get_list_head(&psta->sleep_q); 2407 xmitframe_plist = get_next(xmitframe_phead); 2408 2409 while (xmitframe_phead != xmitframe_plist) { 2410 pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list); 2411 2412 xmitframe_plist = get_next(xmitframe_plist); 2413 2414 list_del_init(&pxmitframe->list); 2415 2416 switch (pxmitframe->attrib.priority) { 2417 case 1: 2418 case 2: 2419 wmmps_ac = psta->uapsd_bk&BIT(1); 2420 break; 2421 case 4: 2422 case 5: 2423 wmmps_ac = psta->uapsd_vi&BIT(1); 2424 break; 2425 case 6: 2426 case 7: 2427 wmmps_ac = psta->uapsd_vo&BIT(1); 2428 break; 2429 case 0: 2430 case 3: 2431 default: 2432 wmmps_ac = psta->uapsd_be&BIT(1); 2433 break; 2434 } 2435 2436 psta->sleepq_len--; 2437 if (psta->sleepq_len > 0) 2438 pxmitframe->attrib.mdata = 1; 2439 else 2440 pxmitframe->attrib.mdata = 0; 2441 2442 if (wmmps_ac) { 2443 psta->sleepq_ac_len--; 2444 if (psta->sleepq_ac_len > 0) { 2445 pxmitframe->attrib.mdata = 1; 2446 pxmitframe->attrib.eosp = 0; 2447 } else { 2448 pxmitframe->attrib.mdata = 0; 2449 pxmitframe->attrib.eosp = 1; 2450 } 2451 } 2452 2453 pxmitframe->attrib.triggered = 1; 2454 2455 rtw_hal_xmitframe_enqueue(padapter, pxmitframe); 2456 } 2457 2458 if (psta->sleepq_len == 0) { 2459 if (pstapriv->tim_bitmap & BIT(psta->aid)) 2460 update_mask = BIT(0); 2461 2462 pstapriv->tim_bitmap &= ~BIT(psta->aid); 2463 2464 if (psta->state&WIFI_SLEEP_STATE) 2465 psta->state ^= WIFI_SLEEP_STATE; 2466 2467 if (psta->state & WIFI_STA_ALIVE_CHK_STATE) { 2468 DBG_871X("%s alive check\n", __func__); 2469 psta->expire_to = pstapriv->expire_to; 2470 psta->state ^= WIFI_STA_ALIVE_CHK_STATE; 2471 } 2472 2473 pstapriv->sta_dz_bitmap &= ~BIT(psta->aid); 2474 } 2475 2476 /* for BC/MC Frames */ 2477 if (!psta_bmc) 2478 goto _exit; 2479 2480 if ((pstapriv->sta_dz_bitmap&0xfffe) == 0x0) { /* no any sta in ps mode */ 2481 xmitframe_phead = get_list_head(&psta_bmc->sleep_q); 2482 xmitframe_plist = get_next(xmitframe_phead); 2483 2484 while (xmitframe_phead != xmitframe_plist) { 2485 pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list); 2486 2487 xmitframe_plist = get_next(xmitframe_plist); 2488 2489 list_del_init(&pxmitframe->list); 2490 2491 psta_bmc->sleepq_len--; 2492 if (psta_bmc->sleepq_len > 0) 2493 pxmitframe->attrib.mdata = 1; 2494 else 2495 pxmitframe->attrib.mdata = 0; 2496 2497 pxmitframe->attrib.triggered = 1; 2498 rtw_hal_xmitframe_enqueue(padapter, pxmitframe); 2499 } 2500 2501 if (psta_bmc->sleepq_len == 0) { 2502 if (pstapriv->tim_bitmap & BIT(0)) 2503 update_mask |= BIT(1); 2504 2505 pstapriv->tim_bitmap &= ~BIT(0); 2506 pstapriv->sta_dz_bitmap &= ~BIT(0); 2507 } 2508 } 2509 2510 _exit: 2511 2512 spin_unlock_bh(&pxmitpriv->lock); 2513 2514 if (update_mask) 2515 update_beacon(padapter, _TIM_IE_, NULL, true); 2516 } 2517 2518 void xmit_delivery_enabled_frames(struct adapter *padapter, struct sta_info *psta) 2519 { 2520 u8 wmmps_ac = 0; 2521 struct list_head *xmitframe_plist, *xmitframe_phead; 2522 struct xmit_frame *pxmitframe = NULL; 2523 struct sta_priv *pstapriv = &padapter->stapriv; 2524 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 2525 2526 spin_lock_bh(&pxmitpriv->lock); 2527 2528 xmitframe_phead = get_list_head(&psta->sleep_q); 2529 xmitframe_plist = get_next(xmitframe_phead); 2530 2531 while (xmitframe_phead != xmitframe_plist) { 2532 pxmitframe = LIST_CONTAINOR(xmitframe_plist, struct xmit_frame, list); 2533 2534 xmitframe_plist = get_next(xmitframe_plist); 2535 2536 switch (pxmitframe->attrib.priority) { 2537 case 1: 2538 case 2: 2539 wmmps_ac = psta->uapsd_bk&BIT(1); 2540 break; 2541 case 4: 2542 case 5: 2543 wmmps_ac = psta->uapsd_vi&BIT(1); 2544 break; 2545 case 6: 2546 case 7: 2547 wmmps_ac = psta->uapsd_vo&BIT(1); 2548 break; 2549 case 0: 2550 case 3: 2551 default: 2552 wmmps_ac = psta->uapsd_be&BIT(1); 2553 break; 2554 } 2555 2556 if (!wmmps_ac) 2557 continue; 2558 2559 list_del_init(&pxmitframe->list); 2560 2561 psta->sleepq_len--; 2562 psta->sleepq_ac_len--; 2563 2564 if (psta->sleepq_ac_len > 0) { 2565 pxmitframe->attrib.mdata = 1; 2566 pxmitframe->attrib.eosp = 0; 2567 } else { 2568 pxmitframe->attrib.mdata = 0; 2569 pxmitframe->attrib.eosp = 1; 2570 } 2571 2572 pxmitframe->attrib.triggered = 1; 2573 rtw_hal_xmitframe_enqueue(padapter, pxmitframe); 2574 2575 if ((psta->sleepq_ac_len == 0) && (!psta->has_legacy_ac) && (wmmps_ac)) { 2576 pstapriv->tim_bitmap &= ~BIT(psta->aid); 2577 2578 update_beacon(padapter, _TIM_IE_, NULL, true); 2579 } 2580 } 2581 2582 spin_unlock_bh(&pxmitpriv->lock); 2583 } 2584 2585 void enqueue_pending_xmitbuf( 2586 struct xmit_priv *pxmitpriv, 2587 struct xmit_buf *pxmitbuf) 2588 { 2589 struct __queue *pqueue; 2590 struct adapter *pri_adapter = pxmitpriv->adapter; 2591 2592 pqueue = &pxmitpriv->pending_xmitbuf_queue; 2593 2594 spin_lock_bh(&pqueue->lock); 2595 list_del_init(&pxmitbuf->list); 2596 list_add_tail(&pxmitbuf->list, get_list_head(pqueue)); 2597 spin_unlock_bh(&pqueue->lock); 2598 2599 complete(&pri_adapter->xmitpriv.xmit_comp); 2600 } 2601 2602 void enqueue_pending_xmitbuf_to_head( 2603 struct xmit_priv *pxmitpriv, 2604 struct xmit_buf *pxmitbuf) 2605 { 2606 struct __queue *pqueue; 2607 2608 pqueue = &pxmitpriv->pending_xmitbuf_queue; 2609 2610 spin_lock_bh(&pqueue->lock); 2611 list_del_init(&pxmitbuf->list); 2612 list_add(&pxmitbuf->list, get_list_head(pqueue)); 2613 spin_unlock_bh(&pqueue->lock); 2614 } 2615 2616 struct xmit_buf *dequeue_pending_xmitbuf( 2617 struct xmit_priv *pxmitpriv) 2618 { 2619 struct xmit_buf *pxmitbuf; 2620 struct __queue *pqueue; 2621 2622 pxmitbuf = NULL; 2623 pqueue = &pxmitpriv->pending_xmitbuf_queue; 2624 2625 spin_lock_bh(&pqueue->lock); 2626 2627 if (!list_empty(&pqueue->queue)) { 2628 struct list_head *plist, *phead; 2629 2630 phead = get_list_head(pqueue); 2631 plist = get_next(phead); 2632 pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); 2633 list_del_init(&pxmitbuf->list); 2634 } 2635 2636 spin_unlock_bh(&pqueue->lock); 2637 2638 return pxmitbuf; 2639 } 2640 2641 struct xmit_buf *dequeue_pending_xmitbuf_under_survey( 2642 struct xmit_priv *pxmitpriv) 2643 { 2644 struct xmit_buf *pxmitbuf; 2645 struct __queue *pqueue; 2646 2647 pxmitbuf = NULL; 2648 pqueue = &pxmitpriv->pending_xmitbuf_queue; 2649 2650 spin_lock_bh(&pqueue->lock); 2651 2652 if (!list_empty(&pqueue->queue)) { 2653 struct list_head *plist, *phead; 2654 u8 type; 2655 2656 phead = get_list_head(pqueue); 2657 plist = phead; 2658 do { 2659 plist = get_next(plist); 2660 if (plist == phead) 2661 break; 2662 2663 pxmitbuf = LIST_CONTAINOR(plist, struct xmit_buf, list); 2664 2665 type = GetFrameSubType(pxmitbuf->pbuf + TXDESC_OFFSET); 2666 2667 if ((type == WIFI_PROBEREQ) || 2668 (type == WIFI_DATA_NULL) || 2669 (type == WIFI_QOS_DATA_NULL)) { 2670 list_del_init(&pxmitbuf->list); 2671 break; 2672 } 2673 pxmitbuf = NULL; 2674 } while (1); 2675 } 2676 2677 spin_unlock_bh(&pqueue->lock); 2678 2679 return pxmitbuf; 2680 } 2681 2682 sint check_pending_xmitbuf( 2683 struct xmit_priv *pxmitpriv) 2684 { 2685 struct __queue *pqueue; 2686 sint ret = false; 2687 2688 pqueue = &pxmitpriv->pending_xmitbuf_queue; 2689 2690 spin_lock_bh(&pqueue->lock); 2691 2692 if (!list_empty(&pqueue->queue)) 2693 ret = true; 2694 2695 spin_unlock_bh(&pqueue->lock); 2696 2697 return ret; 2698 } 2699 2700 int rtw_xmit_thread(void *context) 2701 { 2702 s32 err; 2703 struct adapter *padapter; 2704 2705 err = _SUCCESS; 2706 padapter = context; 2707 2708 thread_enter("RTW_XMIT_THREAD"); 2709 2710 do { 2711 err = rtw_hal_xmit_thread_handler(padapter); 2712 flush_signals_thread(); 2713 } while (err == _SUCCESS); 2714 2715 complete(&padapter->xmitpriv.terminate_xmitthread_comp); 2716 2717 thread_exit(); 2718 } 2719 2720 void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms) 2721 { 2722 sctx->timeout_ms = timeout_ms; 2723 sctx->submit_time = jiffies; 2724 init_completion(&sctx->done); 2725 sctx->status = RTW_SCTX_SUBMITTED; 2726 } 2727 2728 int rtw_sctx_wait(struct submit_ctx *sctx, const char *msg) 2729 { 2730 int ret = _FAIL; 2731 unsigned long expire; 2732 int status = 0; 2733 2734 expire = sctx->timeout_ms ? msecs_to_jiffies(sctx->timeout_ms) : MAX_SCHEDULE_TIMEOUT; 2735 if (!wait_for_completion_timeout(&sctx->done, expire)) { 2736 /* timeout, do something?? */ 2737 status = RTW_SCTX_DONE_TIMEOUT; 2738 DBG_871X("%s timeout: %s\n", __func__, msg); 2739 } else { 2740 status = sctx->status; 2741 } 2742 2743 if (status == RTW_SCTX_DONE_SUCCESS) 2744 ret = _SUCCESS; 2745 2746 return ret; 2747 } 2748 2749 static bool rtw_sctx_chk_warning_status(int status) 2750 { 2751 switch (status) { 2752 case RTW_SCTX_DONE_UNKNOWN: 2753 case RTW_SCTX_DONE_BUF_ALLOC: 2754 case RTW_SCTX_DONE_BUF_FREE: 2755 2756 case RTW_SCTX_DONE_DRV_STOP: 2757 case RTW_SCTX_DONE_DEV_REMOVE: 2758 return true; 2759 default: 2760 return false; 2761 } 2762 } 2763 2764 void rtw_sctx_done_err(struct submit_ctx **sctx, int status) 2765 { 2766 if (*sctx) { 2767 if (rtw_sctx_chk_warning_status(status)) 2768 DBG_871X("%s status:%d\n", __func__, status); 2769 (*sctx)->status = status; 2770 complete(&((*sctx)->done)); 2771 *sctx = NULL; 2772 } 2773 } 2774 2775 void rtw_sctx_done(struct submit_ctx **sctx) 2776 { 2777 rtw_sctx_done_err(sctx, RTW_SCTX_DONE_SUCCESS); 2778 } 2779 2780 int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms) 2781 { 2782 struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops; 2783 2784 pack_tx_ops->submit_time = jiffies; 2785 pack_tx_ops->timeout_ms = timeout_ms; 2786 pack_tx_ops->status = RTW_SCTX_SUBMITTED; 2787 2788 return rtw_sctx_wait(pack_tx_ops, __func__); 2789 } 2790 2791 void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status) 2792 { 2793 struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops; 2794 2795 if (pxmitpriv->ack_tx) 2796 rtw_sctx_done_err(&pack_tx_ops, status); 2797 else 2798 DBG_871X("%s ack_tx not set\n", __func__); 2799 } 2800