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