1 /* 2 * Marvell Wireless LAN device driver: 802.11n 3 * 4 * Copyright (C) 2011-2014, Marvell International Ltd. 5 * 6 * This software file (the "File") is distributed by Marvell International 7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991 8 * (the "License"). You may use, redistribute and/or modify this File in 9 * accordance with the terms and conditions of the License, a copy of which 10 * is available by writing to the Free Software Foundation, Inc., 11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the 12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. 13 * 14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE 16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about 17 * this warranty disclaimer. 18 */ 19 20 #include "decl.h" 21 #include "ioctl.h" 22 #include "util.h" 23 #include "fw.h" 24 #include "main.h" 25 #include "wmm.h" 26 #include "11n.h" 27 28 /* 29 * Fills HT capability information field, AMPDU Parameters field, HT extended 30 * capability field, and supported MCS set fields. 31 * 32 * HT capability information field, AMPDU Parameters field, supported MCS set 33 * fields are retrieved from cfg80211 stack 34 * 35 * RD responder bit to set to clear in the extended capability header. 36 */ 37 int mwifiex_fill_cap_info(struct mwifiex_private *priv, u8 radio_type, 38 struct ieee80211_ht_cap *ht_cap) 39 { 40 uint16_t ht_ext_cap = le16_to_cpu(ht_cap->extended_ht_cap_info); 41 struct ieee80211_supported_band *sband = 42 priv->wdev.wiphy->bands[radio_type]; 43 44 if (WARN_ON_ONCE(!sband)) { 45 mwifiex_dbg(priv->adapter, ERROR, "Invalid radio type!\n"); 46 return -EINVAL; 47 } 48 49 ht_cap->ampdu_params_info = 50 (sband->ht_cap.ampdu_factor & 51 IEEE80211_HT_AMPDU_PARM_FACTOR) | 52 ((sband->ht_cap.ampdu_density << 53 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT) & 54 IEEE80211_HT_AMPDU_PARM_DENSITY); 55 56 memcpy((u8 *)&ht_cap->mcs, &sband->ht_cap.mcs, 57 sizeof(sband->ht_cap.mcs)); 58 59 if (priv->bss_mode == NL80211_IFTYPE_STATION || 60 (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 && 61 (priv->adapter->sec_chan_offset != 62 IEEE80211_HT_PARAM_CHA_SEC_NONE))) 63 /* Set MCS32 for infra mode or ad-hoc mode with 40MHz support */ 64 SETHT_MCS32(ht_cap->mcs.rx_mask); 65 66 /* Clear RD responder bit */ 67 ht_ext_cap &= ~IEEE80211_HT_EXT_CAP_RD_RESPONDER; 68 69 ht_cap->cap_info = cpu_to_le16(sband->ht_cap.cap); 70 ht_cap->extended_ht_cap_info = cpu_to_le16(ht_ext_cap); 71 72 if (ISSUPP_BEAMFORMING(priv->adapter->hw_dot_11n_dev_cap)) 73 ht_cap->tx_BF_cap_info = cpu_to_le32(MWIFIEX_DEF_11N_TX_BF_CAP); 74 75 return 0; 76 } 77 78 /* 79 * This function returns the pointer to an entry in BA Stream 80 * table which matches the requested BA status. 81 */ 82 static struct mwifiex_tx_ba_stream_tbl * 83 mwifiex_get_ba_status(struct mwifiex_private *priv, 84 enum mwifiex_ba_status ba_status) 85 { 86 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl; 87 unsigned long flags; 88 89 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags); 90 list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) { 91 if (tx_ba_tsr_tbl->ba_status == ba_status) { 92 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, 93 flags); 94 return tx_ba_tsr_tbl; 95 } 96 } 97 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags); 98 return NULL; 99 } 100 101 /* 102 * This function handles the command response of delete a block 103 * ack request. 104 * 105 * The function checks the response success status and takes action 106 * accordingly (send an add BA request in case of success, or recreate 107 * the deleted stream in case of failure, if the add BA was also 108 * initiated by us). 109 */ 110 int mwifiex_ret_11n_delba(struct mwifiex_private *priv, 111 struct host_cmd_ds_command *resp) 112 { 113 int tid; 114 struct mwifiex_tx_ba_stream_tbl *tx_ba_tbl; 115 struct host_cmd_ds_11n_delba *del_ba = &resp->params.del_ba; 116 uint16_t del_ba_param_set = le16_to_cpu(del_ba->del_ba_param_set); 117 118 tid = del_ba_param_set >> DELBA_TID_POS; 119 if (del_ba->del_result == BA_RESULT_SUCCESS) { 120 mwifiex_del_ba_tbl(priv, tid, del_ba->peer_mac_addr, 121 TYPE_DELBA_SENT, 122 INITIATOR_BIT(del_ba_param_set)); 123 124 tx_ba_tbl = mwifiex_get_ba_status(priv, BA_SETUP_INPROGRESS); 125 if (tx_ba_tbl) 126 mwifiex_send_addba(priv, tx_ba_tbl->tid, 127 tx_ba_tbl->ra); 128 } else { /* 129 * In case of failure, recreate the deleted stream in case 130 * we initiated the ADDBA 131 */ 132 if (!INITIATOR_BIT(del_ba_param_set)) 133 return 0; 134 135 mwifiex_create_ba_tbl(priv, del_ba->peer_mac_addr, tid, 136 BA_SETUP_INPROGRESS); 137 138 tx_ba_tbl = mwifiex_get_ba_status(priv, BA_SETUP_INPROGRESS); 139 140 if (tx_ba_tbl) 141 mwifiex_del_ba_tbl(priv, tx_ba_tbl->tid, tx_ba_tbl->ra, 142 TYPE_DELBA_SENT, true); 143 } 144 145 return 0; 146 } 147 148 /* 149 * This function handles the command response of add a block 150 * ack request. 151 * 152 * Handling includes changing the header fields to CPU formats, checking 153 * the response success status and taking actions accordingly (delete the 154 * BA stream table in case of failure). 155 */ 156 int mwifiex_ret_11n_addba_req(struct mwifiex_private *priv, 157 struct host_cmd_ds_command *resp) 158 { 159 int tid, tid_down; 160 struct host_cmd_ds_11n_addba_rsp *add_ba_rsp = &resp->params.add_ba_rsp; 161 struct mwifiex_tx_ba_stream_tbl *tx_ba_tbl; 162 struct mwifiex_ra_list_tbl *ra_list; 163 u16 block_ack_param_set = le16_to_cpu(add_ba_rsp->block_ack_param_set); 164 165 add_ba_rsp->ssn = cpu_to_le16((le16_to_cpu(add_ba_rsp->ssn)) 166 & SSN_MASK); 167 168 tid = (block_ack_param_set & IEEE80211_ADDBA_PARAM_TID_MASK) 169 >> BLOCKACKPARAM_TID_POS; 170 171 tid_down = mwifiex_wmm_downgrade_tid(priv, tid); 172 ra_list = mwifiex_wmm_get_ralist_node(priv, tid_down, add_ba_rsp-> 173 peer_mac_addr); 174 if (le16_to_cpu(add_ba_rsp->status_code) != BA_RESULT_SUCCESS) { 175 if (ra_list) { 176 ra_list->ba_status = BA_SETUP_NONE; 177 ra_list->amsdu_in_ampdu = false; 178 } 179 mwifiex_del_ba_tbl(priv, tid, add_ba_rsp->peer_mac_addr, 180 TYPE_DELBA_SENT, true); 181 if (add_ba_rsp->add_rsp_result != BA_RESULT_TIMEOUT) 182 priv->aggr_prio_tbl[tid].ampdu_ap = 183 BA_STREAM_NOT_ALLOWED; 184 return 0; 185 } 186 187 tx_ba_tbl = mwifiex_get_ba_tbl(priv, tid, add_ba_rsp->peer_mac_addr); 188 if (tx_ba_tbl) { 189 mwifiex_dbg(priv->adapter, EVENT, "info: BA stream complete\n"); 190 tx_ba_tbl->ba_status = BA_SETUP_COMPLETE; 191 if ((block_ack_param_set & BLOCKACKPARAM_AMSDU_SUPP_MASK) && 192 priv->add_ba_param.tx_amsdu && 193 (priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED)) 194 tx_ba_tbl->amsdu = true; 195 else 196 tx_ba_tbl->amsdu = false; 197 if (ra_list) { 198 ra_list->amsdu_in_ampdu = tx_ba_tbl->amsdu; 199 ra_list->ba_status = BA_SETUP_COMPLETE; 200 } 201 } else { 202 mwifiex_dbg(priv->adapter, ERROR, "BA stream not created\n"); 203 } 204 205 return 0; 206 } 207 208 /* 209 * This function prepares command of reconfigure Tx buffer. 210 * 211 * Preparation includes - 212 * - Setting command ID, action and proper size 213 * - Setting Tx buffer size (for SET only) 214 * - Ensuring correct endian-ness 215 */ 216 int mwifiex_cmd_recfg_tx_buf(struct mwifiex_private *priv, 217 struct host_cmd_ds_command *cmd, int cmd_action, 218 u16 *buf_size) 219 { 220 struct host_cmd_ds_txbuf_cfg *tx_buf = &cmd->params.tx_buf; 221 u16 action = (u16) cmd_action; 222 223 cmd->command = cpu_to_le16(HostCmd_CMD_RECONFIGURE_TX_BUFF); 224 cmd->size = 225 cpu_to_le16(sizeof(struct host_cmd_ds_txbuf_cfg) + S_DS_GEN); 226 tx_buf->action = cpu_to_le16(action); 227 switch (action) { 228 case HostCmd_ACT_GEN_SET: 229 mwifiex_dbg(priv->adapter, CMD, 230 "cmd: set tx_buf=%d\n", *buf_size); 231 tx_buf->buff_size = cpu_to_le16(*buf_size); 232 break; 233 case HostCmd_ACT_GEN_GET: 234 default: 235 tx_buf->buff_size = 0; 236 break; 237 } 238 return 0; 239 } 240 241 /* 242 * This function prepares command of AMSDU aggregation control. 243 * 244 * Preparation includes - 245 * - Setting command ID, action and proper size 246 * - Setting AMSDU control parameters (for SET only) 247 * - Ensuring correct endian-ness 248 */ 249 int mwifiex_cmd_amsdu_aggr_ctrl(struct host_cmd_ds_command *cmd, 250 int cmd_action, 251 struct mwifiex_ds_11n_amsdu_aggr_ctrl *aa_ctrl) 252 { 253 struct host_cmd_ds_amsdu_aggr_ctrl *amsdu_ctrl = 254 &cmd->params.amsdu_aggr_ctrl; 255 u16 action = (u16) cmd_action; 256 257 cmd->command = cpu_to_le16(HostCmd_CMD_AMSDU_AGGR_CTRL); 258 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_amsdu_aggr_ctrl) 259 + S_DS_GEN); 260 amsdu_ctrl->action = cpu_to_le16(action); 261 switch (action) { 262 case HostCmd_ACT_GEN_SET: 263 amsdu_ctrl->enable = cpu_to_le16(aa_ctrl->enable); 264 amsdu_ctrl->curr_buf_size = 0; 265 break; 266 case HostCmd_ACT_GEN_GET: 267 default: 268 amsdu_ctrl->curr_buf_size = 0; 269 break; 270 } 271 return 0; 272 } 273 274 /* 275 * This function prepares 11n configuration command. 276 * 277 * Preparation includes - 278 * - Setting command ID, action and proper size 279 * - Setting HT Tx capability and HT Tx information fields 280 * - Ensuring correct endian-ness 281 */ 282 int mwifiex_cmd_11n_cfg(struct mwifiex_private *priv, 283 struct host_cmd_ds_command *cmd, u16 cmd_action, 284 struct mwifiex_ds_11n_tx_cfg *txcfg) 285 { 286 struct host_cmd_ds_11n_cfg *htcfg = &cmd->params.htcfg; 287 288 cmd->command = cpu_to_le16(HostCmd_CMD_11N_CFG); 289 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_11n_cfg) + S_DS_GEN); 290 htcfg->action = cpu_to_le16(cmd_action); 291 htcfg->ht_tx_cap = cpu_to_le16(txcfg->tx_htcap); 292 htcfg->ht_tx_info = cpu_to_le16(txcfg->tx_htinfo); 293 294 if (priv->adapter->is_hw_11ac_capable) 295 htcfg->misc_config = cpu_to_le16(txcfg->misc_config); 296 297 return 0; 298 } 299 300 /* 301 * This function appends an 11n TLV to a buffer. 302 * 303 * Buffer allocation is responsibility of the calling 304 * function. No size validation is made here. 305 * 306 * The function fills up the following sections, if applicable - 307 * - HT capability IE 308 * - HT information IE (with channel list) 309 * - 20/40 BSS Coexistence IE 310 * - HT Extended Capabilities IE 311 */ 312 int 313 mwifiex_cmd_append_11n_tlv(struct mwifiex_private *priv, 314 struct mwifiex_bssdescriptor *bss_desc, 315 u8 **buffer) 316 { 317 struct mwifiex_ie_types_htcap *ht_cap; 318 struct mwifiex_ie_types_htinfo *ht_info; 319 struct mwifiex_ie_types_chan_list_param_set *chan_list; 320 struct mwifiex_ie_types_2040bssco *bss_co_2040; 321 struct mwifiex_ie_types_extcap *ext_cap; 322 int ret_len = 0; 323 struct ieee80211_supported_band *sband; 324 struct ieee_types_header *hdr; 325 u8 radio_type; 326 327 if (!buffer || !*buffer) 328 return ret_len; 329 330 radio_type = mwifiex_band_to_radio_type((u8) bss_desc->bss_band); 331 sband = priv->wdev.wiphy->bands[radio_type]; 332 333 if (bss_desc->bcn_ht_cap) { 334 ht_cap = (struct mwifiex_ie_types_htcap *) *buffer; 335 memset(ht_cap, 0, sizeof(struct mwifiex_ie_types_htcap)); 336 ht_cap->header.type = cpu_to_le16(WLAN_EID_HT_CAPABILITY); 337 ht_cap->header.len = 338 cpu_to_le16(sizeof(struct ieee80211_ht_cap)); 339 memcpy((u8 *) ht_cap + sizeof(struct mwifiex_ie_types_header), 340 (u8 *)bss_desc->bcn_ht_cap, 341 le16_to_cpu(ht_cap->header.len)); 342 343 mwifiex_fill_cap_info(priv, radio_type, &ht_cap->ht_cap); 344 345 *buffer += sizeof(struct mwifiex_ie_types_htcap); 346 ret_len += sizeof(struct mwifiex_ie_types_htcap); 347 } 348 349 if (bss_desc->bcn_ht_oper) { 350 if (priv->bss_mode == NL80211_IFTYPE_ADHOC) { 351 ht_info = (struct mwifiex_ie_types_htinfo *) *buffer; 352 memset(ht_info, 0, 353 sizeof(struct mwifiex_ie_types_htinfo)); 354 ht_info->header.type = 355 cpu_to_le16(WLAN_EID_HT_OPERATION); 356 ht_info->header.len = 357 cpu_to_le16( 358 sizeof(struct ieee80211_ht_operation)); 359 360 memcpy((u8 *) ht_info + 361 sizeof(struct mwifiex_ie_types_header), 362 (u8 *)bss_desc->bcn_ht_oper, 363 le16_to_cpu(ht_info->header.len)); 364 365 if (!(sband->ht_cap.cap & 366 IEEE80211_HT_CAP_SUP_WIDTH_20_40)) 367 ht_info->ht_oper.ht_param &= 368 ~(IEEE80211_HT_PARAM_CHAN_WIDTH_ANY | 369 IEEE80211_HT_PARAM_CHA_SEC_OFFSET); 370 371 *buffer += sizeof(struct mwifiex_ie_types_htinfo); 372 ret_len += sizeof(struct mwifiex_ie_types_htinfo); 373 } 374 375 chan_list = 376 (struct mwifiex_ie_types_chan_list_param_set *) *buffer; 377 memset(chan_list, 0, 378 sizeof(struct mwifiex_ie_types_chan_list_param_set)); 379 chan_list->header.type = cpu_to_le16(TLV_TYPE_CHANLIST); 380 chan_list->header.len = cpu_to_le16( 381 sizeof(struct mwifiex_ie_types_chan_list_param_set) - 382 sizeof(struct mwifiex_ie_types_header)); 383 chan_list->chan_scan_param[0].chan_number = 384 bss_desc->bcn_ht_oper->primary_chan; 385 chan_list->chan_scan_param[0].radio_type = 386 mwifiex_band_to_radio_type((u8) bss_desc->bss_band); 387 388 if (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 && 389 bss_desc->bcn_ht_oper->ht_param & 390 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY) 391 SET_SECONDARYCHAN(chan_list->chan_scan_param[0]. 392 radio_type, 393 (bss_desc->bcn_ht_oper->ht_param & 394 IEEE80211_HT_PARAM_CHA_SEC_OFFSET)); 395 396 *buffer += sizeof(struct mwifiex_ie_types_chan_list_param_set); 397 ret_len += sizeof(struct mwifiex_ie_types_chan_list_param_set); 398 } 399 400 if (bss_desc->bcn_bss_co_2040) { 401 bss_co_2040 = (struct mwifiex_ie_types_2040bssco *) *buffer; 402 memset(bss_co_2040, 0, 403 sizeof(struct mwifiex_ie_types_2040bssco)); 404 bss_co_2040->header.type = cpu_to_le16(WLAN_EID_BSS_COEX_2040); 405 bss_co_2040->header.len = 406 cpu_to_le16(sizeof(bss_co_2040->bss_co_2040)); 407 408 memcpy((u8 *) bss_co_2040 + 409 sizeof(struct mwifiex_ie_types_header), 410 bss_desc->bcn_bss_co_2040 + 411 sizeof(struct ieee_types_header), 412 le16_to_cpu(bss_co_2040->header.len)); 413 414 *buffer += sizeof(struct mwifiex_ie_types_2040bssco); 415 ret_len += sizeof(struct mwifiex_ie_types_2040bssco); 416 } 417 418 if (bss_desc->bcn_ext_cap) { 419 hdr = (void *)bss_desc->bcn_ext_cap; 420 ext_cap = (struct mwifiex_ie_types_extcap *) *buffer; 421 memset(ext_cap, 0, sizeof(struct mwifiex_ie_types_extcap)); 422 ext_cap->header.type = cpu_to_le16(WLAN_EID_EXT_CAPABILITY); 423 ext_cap->header.len = cpu_to_le16(hdr->len); 424 425 memcpy((u8 *)ext_cap->ext_capab, 426 bss_desc->bcn_ext_cap + sizeof(struct ieee_types_header), 427 le16_to_cpu(ext_cap->header.len)); 428 429 if (hdr->len > 3 && 430 ext_cap->ext_capab[3] & WLAN_EXT_CAPA4_INTERWORKING_ENABLED) 431 priv->hs2_enabled = true; 432 else 433 priv->hs2_enabled = false; 434 435 *buffer += sizeof(struct mwifiex_ie_types_extcap) + hdr->len; 436 ret_len += sizeof(struct mwifiex_ie_types_extcap) + hdr->len; 437 } 438 439 return ret_len; 440 } 441 442 /* 443 * This function checks if the given pointer is valid entry of 444 * Tx BA Stream table. 445 */ 446 static int mwifiex_is_tx_ba_stream_ptr_valid(struct mwifiex_private *priv, 447 struct mwifiex_tx_ba_stream_tbl *tx_tbl_ptr) 448 { 449 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl; 450 451 list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) { 452 if (tx_ba_tsr_tbl == tx_tbl_ptr) 453 return true; 454 } 455 456 return false; 457 } 458 459 /* 460 * This function deletes the given entry in Tx BA Stream table. 461 * 462 * The function also performs a validity check on the supplied 463 * pointer before trying to delete. 464 */ 465 void mwifiex_11n_delete_tx_ba_stream_tbl_entry(struct mwifiex_private *priv, 466 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl) 467 { 468 if (!tx_ba_tsr_tbl && 469 mwifiex_is_tx_ba_stream_ptr_valid(priv, tx_ba_tsr_tbl)) 470 return; 471 472 mwifiex_dbg(priv->adapter, INFO, 473 "info: tx_ba_tsr_tbl %p\n", tx_ba_tsr_tbl); 474 475 list_del(&tx_ba_tsr_tbl->list); 476 477 kfree(tx_ba_tsr_tbl); 478 } 479 480 /* 481 * This function deletes all the entries in Tx BA Stream table. 482 */ 483 void mwifiex_11n_delete_all_tx_ba_stream_tbl(struct mwifiex_private *priv) 484 { 485 int i; 486 struct mwifiex_tx_ba_stream_tbl *del_tbl_ptr, *tmp_node; 487 unsigned long flags; 488 489 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags); 490 list_for_each_entry_safe(del_tbl_ptr, tmp_node, 491 &priv->tx_ba_stream_tbl_ptr, list) 492 mwifiex_11n_delete_tx_ba_stream_tbl_entry(priv, del_tbl_ptr); 493 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags); 494 495 INIT_LIST_HEAD(&priv->tx_ba_stream_tbl_ptr); 496 497 for (i = 0; i < MAX_NUM_TID; ++i) 498 priv->aggr_prio_tbl[i].ampdu_ap = 499 priv->aggr_prio_tbl[i].ampdu_user; 500 } 501 502 /* 503 * This function returns the pointer to an entry in BA Stream 504 * table which matches the given RA/TID pair. 505 */ 506 struct mwifiex_tx_ba_stream_tbl * 507 mwifiex_get_ba_tbl(struct mwifiex_private *priv, int tid, u8 *ra) 508 { 509 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl; 510 unsigned long flags; 511 512 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags); 513 list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) { 514 if (ether_addr_equal_unaligned(tx_ba_tsr_tbl->ra, ra) && 515 tx_ba_tsr_tbl->tid == tid) { 516 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, 517 flags); 518 return tx_ba_tsr_tbl; 519 } 520 } 521 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags); 522 return NULL; 523 } 524 525 /* 526 * This function creates an entry in Tx BA stream table for the 527 * given RA/TID pair. 528 */ 529 void mwifiex_create_ba_tbl(struct mwifiex_private *priv, u8 *ra, int tid, 530 enum mwifiex_ba_status ba_status) 531 { 532 struct mwifiex_tx_ba_stream_tbl *new_node; 533 struct mwifiex_ra_list_tbl *ra_list; 534 unsigned long flags; 535 int tid_down; 536 537 if (!mwifiex_get_ba_tbl(priv, tid, ra)) { 538 new_node = kzalloc(sizeof(struct mwifiex_tx_ba_stream_tbl), 539 GFP_ATOMIC); 540 if (!new_node) 541 return; 542 543 tid_down = mwifiex_wmm_downgrade_tid(priv, tid); 544 ra_list = mwifiex_wmm_get_ralist_node(priv, tid_down, ra); 545 if (ra_list) { 546 ra_list->ba_status = ba_status; 547 ra_list->amsdu_in_ampdu = false; 548 } 549 INIT_LIST_HEAD(&new_node->list); 550 551 new_node->tid = tid; 552 new_node->ba_status = ba_status; 553 memcpy(new_node->ra, ra, ETH_ALEN); 554 555 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags); 556 list_add_tail(&new_node->list, &priv->tx_ba_stream_tbl_ptr); 557 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags); 558 } 559 } 560 561 /* 562 * This function sends an add BA request to the given TID/RA pair. 563 */ 564 int mwifiex_send_addba(struct mwifiex_private *priv, int tid, u8 *peer_mac) 565 { 566 struct host_cmd_ds_11n_addba_req add_ba_req; 567 u32 tx_win_size = priv->add_ba_param.tx_win_size; 568 static u8 dialog_tok; 569 int ret; 570 unsigned long flags; 571 u16 block_ack_param_set; 572 573 mwifiex_dbg(priv->adapter, CMD, "cmd: %s: tid %d\n", __func__, tid); 574 575 if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) && 576 ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) && 577 priv->adapter->is_hw_11ac_capable && 578 memcmp(priv->cfg_bssid, peer_mac, ETH_ALEN)) { 579 struct mwifiex_sta_node *sta_ptr; 580 581 spin_lock_irqsave(&priv->sta_list_spinlock, flags); 582 sta_ptr = mwifiex_get_sta_entry(priv, peer_mac); 583 if (!sta_ptr) { 584 spin_unlock_irqrestore(&priv->sta_list_spinlock, flags); 585 mwifiex_dbg(priv->adapter, ERROR, 586 "BA setup with unknown TDLS peer %pM!\n", 587 peer_mac); 588 return -1; 589 } 590 if (sta_ptr->is_11ac_enabled) 591 tx_win_size = MWIFIEX_11AC_STA_AMPDU_DEF_TXWINSIZE; 592 spin_unlock_irqrestore(&priv->sta_list_spinlock, flags); 593 } 594 595 block_ack_param_set = (u16)((tid << BLOCKACKPARAM_TID_POS) | 596 tx_win_size << BLOCKACKPARAM_WINSIZE_POS | 597 IMMEDIATE_BLOCK_ACK); 598 599 /* enable AMSDU inside AMPDU */ 600 if (priv->add_ba_param.tx_amsdu && 601 (priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED)) 602 block_ack_param_set |= BLOCKACKPARAM_AMSDU_SUPP_MASK; 603 604 add_ba_req.block_ack_param_set = cpu_to_le16(block_ack_param_set); 605 add_ba_req.block_ack_tmo = cpu_to_le16((u16)priv->add_ba_param.timeout); 606 607 ++dialog_tok; 608 609 if (dialog_tok == 0) 610 dialog_tok = 1; 611 612 add_ba_req.dialog_token = dialog_tok; 613 memcpy(&add_ba_req.peer_mac_addr, peer_mac, ETH_ALEN); 614 615 /* We don't wait for the response of this command */ 616 ret = mwifiex_send_cmd(priv, HostCmd_CMD_11N_ADDBA_REQ, 617 0, 0, &add_ba_req, false); 618 619 return ret; 620 } 621 622 /* 623 * This function sends a delete BA request to the given TID/RA pair. 624 */ 625 int mwifiex_send_delba(struct mwifiex_private *priv, int tid, u8 *peer_mac, 626 int initiator) 627 { 628 struct host_cmd_ds_11n_delba delba; 629 int ret; 630 uint16_t del_ba_param_set; 631 632 memset(&delba, 0, sizeof(delba)); 633 delba.del_ba_param_set = cpu_to_le16(tid << DELBA_TID_POS); 634 635 del_ba_param_set = le16_to_cpu(delba.del_ba_param_set); 636 if (initiator) 637 del_ba_param_set |= IEEE80211_DELBA_PARAM_INITIATOR_MASK; 638 else 639 del_ba_param_set &= ~IEEE80211_DELBA_PARAM_INITIATOR_MASK; 640 641 memcpy(&delba.peer_mac_addr, peer_mac, ETH_ALEN); 642 643 /* We don't wait for the response of this command */ 644 ret = mwifiex_send_cmd(priv, HostCmd_CMD_11N_DELBA, 645 HostCmd_ACT_GEN_SET, 0, &delba, false); 646 647 return ret; 648 } 649 650 /* 651 * This function sends delba to specific tid 652 */ 653 void mwifiex_11n_delba(struct mwifiex_private *priv, int tid) 654 { 655 struct mwifiex_rx_reorder_tbl *rx_reor_tbl_ptr; 656 657 if (list_empty(&priv->rx_reorder_tbl_ptr)) { 658 dev_dbg(priv->adapter->dev, 659 "mwifiex_11n_delba: rx_reorder_tbl_ptr empty\n"); 660 return; 661 } 662 663 list_for_each_entry(rx_reor_tbl_ptr, &priv->rx_reorder_tbl_ptr, list) { 664 if (rx_reor_tbl_ptr->tid == tid) { 665 dev_dbg(priv->adapter->dev, 666 "Send delba to tid=%d, %pM\n", 667 tid, rx_reor_tbl_ptr->ta); 668 mwifiex_send_delba(priv, tid, rx_reor_tbl_ptr->ta, 0); 669 return; 670 } 671 } 672 } 673 674 /* 675 * This function handles the command response of a delete BA request. 676 */ 677 void mwifiex_11n_delete_ba_stream(struct mwifiex_private *priv, u8 *del_ba) 678 { 679 struct host_cmd_ds_11n_delba *cmd_del_ba = 680 (struct host_cmd_ds_11n_delba *) del_ba; 681 uint16_t del_ba_param_set = le16_to_cpu(cmd_del_ba->del_ba_param_set); 682 int tid; 683 684 tid = del_ba_param_set >> DELBA_TID_POS; 685 686 mwifiex_del_ba_tbl(priv, tid, cmd_del_ba->peer_mac_addr, 687 TYPE_DELBA_RECEIVE, INITIATOR_BIT(del_ba_param_set)); 688 } 689 690 /* 691 * This function retrieves the Rx reordering table. 692 */ 693 int mwifiex_get_rx_reorder_tbl(struct mwifiex_private *priv, 694 struct mwifiex_ds_rx_reorder_tbl *buf) 695 { 696 int i; 697 struct mwifiex_ds_rx_reorder_tbl *rx_reo_tbl = buf; 698 struct mwifiex_rx_reorder_tbl *rx_reorder_tbl_ptr; 699 int count = 0; 700 unsigned long flags; 701 702 spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags); 703 list_for_each_entry(rx_reorder_tbl_ptr, &priv->rx_reorder_tbl_ptr, 704 list) { 705 rx_reo_tbl->tid = (u16) rx_reorder_tbl_ptr->tid; 706 memcpy(rx_reo_tbl->ta, rx_reorder_tbl_ptr->ta, ETH_ALEN); 707 rx_reo_tbl->start_win = rx_reorder_tbl_ptr->start_win; 708 rx_reo_tbl->win_size = rx_reorder_tbl_ptr->win_size; 709 for (i = 0; i < rx_reorder_tbl_ptr->win_size; ++i) { 710 if (rx_reorder_tbl_ptr->rx_reorder_ptr[i]) 711 rx_reo_tbl->buffer[i] = true; 712 else 713 rx_reo_tbl->buffer[i] = false; 714 } 715 rx_reo_tbl++; 716 count++; 717 718 if (count >= MWIFIEX_MAX_RX_BASTREAM_SUPPORTED) 719 break; 720 } 721 spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags); 722 723 return count; 724 } 725 726 /* 727 * This function retrieves the Tx BA stream table. 728 */ 729 int mwifiex_get_tx_ba_stream_tbl(struct mwifiex_private *priv, 730 struct mwifiex_ds_tx_ba_stream_tbl *buf) 731 { 732 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl; 733 struct mwifiex_ds_tx_ba_stream_tbl *rx_reo_tbl = buf; 734 int count = 0; 735 unsigned long flags; 736 737 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags); 738 list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) { 739 rx_reo_tbl->tid = (u16) tx_ba_tsr_tbl->tid; 740 mwifiex_dbg(priv->adapter, DATA, "data: %s tid=%d\n", 741 __func__, rx_reo_tbl->tid); 742 memcpy(rx_reo_tbl->ra, tx_ba_tsr_tbl->ra, ETH_ALEN); 743 rx_reo_tbl->amsdu = tx_ba_tsr_tbl->amsdu; 744 rx_reo_tbl++; 745 count++; 746 if (count >= MWIFIEX_MAX_TX_BASTREAM_SUPPORTED) 747 break; 748 } 749 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags); 750 751 return count; 752 } 753 754 /* 755 * This function retrieves the entry for specific tx BA stream table by RA and 756 * deletes it. 757 */ 758 void mwifiex_del_tx_ba_stream_tbl_by_ra(struct mwifiex_private *priv, u8 *ra) 759 { 760 struct mwifiex_tx_ba_stream_tbl *tbl, *tmp; 761 unsigned long flags; 762 763 if (!ra) 764 return; 765 766 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags); 767 list_for_each_entry_safe(tbl, tmp, &priv->tx_ba_stream_tbl_ptr, list) { 768 if (!memcmp(tbl->ra, ra, ETH_ALEN)) { 769 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, 770 flags); 771 mwifiex_11n_delete_tx_ba_stream_tbl_entry(priv, tbl); 772 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags); 773 } 774 } 775 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags); 776 777 return; 778 } 779 780 /* This function initializes the BlockACK setup information for given 781 * mwifiex_private structure. 782 */ 783 void mwifiex_set_ba_params(struct mwifiex_private *priv) 784 { 785 priv->add_ba_param.timeout = MWIFIEX_DEFAULT_BLOCK_ACK_TIMEOUT; 786 787 if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) { 788 priv->add_ba_param.tx_win_size = 789 MWIFIEX_UAP_AMPDU_DEF_TXWINSIZE; 790 priv->add_ba_param.rx_win_size = 791 MWIFIEX_UAP_AMPDU_DEF_RXWINSIZE; 792 } else { 793 priv->add_ba_param.tx_win_size = 794 MWIFIEX_STA_AMPDU_DEF_TXWINSIZE; 795 priv->add_ba_param.rx_win_size = 796 MWIFIEX_STA_AMPDU_DEF_RXWINSIZE; 797 } 798 799 priv->add_ba_param.tx_amsdu = true; 800 priv->add_ba_param.rx_amsdu = true; 801 802 return; 803 } 804 805 u8 mwifiex_get_sec_chan_offset(int chan) 806 { 807 u8 sec_offset; 808 809 switch (chan) { 810 case 36: 811 case 44: 812 case 52: 813 case 60: 814 case 100: 815 case 108: 816 case 116: 817 case 124: 818 case 132: 819 case 140: 820 case 149: 821 case 157: 822 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 823 break; 824 case 40: 825 case 48: 826 case 56: 827 case 64: 828 case 104: 829 case 112: 830 case 120: 831 case 128: 832 case 136: 833 case 144: 834 case 153: 835 case 161: 836 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW; 837 break; 838 case 165: 839 default: 840 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE; 841 break; 842 } 843 844 return sec_offset; 845 } 846 847 /* This function will send DELBA to entries in the priv's 848 * Tx BA stream table 849 */ 850 static void 851 mwifiex_send_delba_txbastream_tbl(struct mwifiex_private *priv, u8 tid) 852 { 853 struct mwifiex_adapter *adapter = priv->adapter; 854 struct mwifiex_tx_ba_stream_tbl *tx_ba_stream_tbl_ptr; 855 856 if (list_empty(&priv->tx_ba_stream_tbl_ptr)) 857 return; 858 859 list_for_each_entry(tx_ba_stream_tbl_ptr, 860 &priv->tx_ba_stream_tbl_ptr, list) { 861 if (tx_ba_stream_tbl_ptr->ba_status == BA_SETUP_COMPLETE) { 862 if (tid == tx_ba_stream_tbl_ptr->tid) { 863 dev_dbg(adapter->dev, 864 "Tx:Send delba to tid=%d, %pM\n", tid, 865 tx_ba_stream_tbl_ptr->ra); 866 mwifiex_send_delba(priv, 867 tx_ba_stream_tbl_ptr->tid, 868 tx_ba_stream_tbl_ptr->ra, 1); 869 return; 870 } 871 } 872 } 873 } 874 875 /* This function updates all the tx_win_size 876 */ 877 void mwifiex_update_ampdu_txwinsize(struct mwifiex_adapter *adapter) 878 { 879 u8 i; 880 u32 tx_win_size; 881 struct mwifiex_private *priv; 882 883 for (i = 0; i < adapter->priv_num; i++) { 884 if (!adapter->priv[i]) 885 continue; 886 priv = adapter->priv[i]; 887 tx_win_size = priv->add_ba_param.tx_win_size; 888 889 if (priv->bss_type == MWIFIEX_BSS_TYPE_STA) 890 priv->add_ba_param.tx_win_size = 891 MWIFIEX_STA_AMPDU_DEF_TXWINSIZE; 892 893 if (priv->bss_type == MWIFIEX_BSS_TYPE_P2P) 894 priv->add_ba_param.tx_win_size = 895 MWIFIEX_STA_AMPDU_DEF_TXWINSIZE; 896 897 if (priv->bss_type == MWIFIEX_BSS_TYPE_UAP) 898 priv->add_ba_param.tx_win_size = 899 MWIFIEX_UAP_AMPDU_DEF_TXWINSIZE; 900 901 if (adapter->coex_win_size) { 902 if (adapter->coex_tx_win_size) 903 priv->add_ba_param.tx_win_size = 904 adapter->coex_tx_win_size; 905 } 906 907 if (tx_win_size != priv->add_ba_param.tx_win_size) { 908 if (!priv->media_connected) 909 continue; 910 for (i = 0; i < MAX_NUM_TID; i++) 911 mwifiex_send_delba_txbastream_tbl(priv, i); 912 } 913 } 914 } 915