GNU Linux-libre 4.19.207-gnu1
[releases.git] / drivers / net / wireless / marvell / mwifiex / 11n.c
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                 /* Update HT40 capability from current channel information */
345                 if (bss_desc->bcn_ht_oper) {
346                         u8 ht_param = bss_desc->bcn_ht_oper->ht_param;
347                         u8 radio =
348                         mwifiex_band_to_radio_type(bss_desc->bss_band);
349                         int freq =
350                         ieee80211_channel_to_frequency(bss_desc->channel,
351                                                        radio);
352                         struct ieee80211_channel *chan =
353                         ieee80211_get_channel(priv->adapter->wiphy, freq);
354
355                         switch (ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
356                         case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
357                                 if (chan->flags & IEEE80211_CHAN_NO_HT40PLUS) {
358                                         ht_cap->ht_cap.cap_info &=
359                                         cpu_to_le16
360                                         (~IEEE80211_HT_CAP_SUP_WIDTH_20_40);
361                                         ht_cap->ht_cap.cap_info &=
362                                         cpu_to_le16(~IEEE80211_HT_CAP_SGI_40);
363                                 }
364                                 break;
365                         case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
366                                 if (chan->flags & IEEE80211_CHAN_NO_HT40MINUS) {
367                                         ht_cap->ht_cap.cap_info &=
368                                         cpu_to_le16
369                                         (~IEEE80211_HT_CAP_SUP_WIDTH_20_40);
370                                         ht_cap->ht_cap.cap_info &=
371                                         cpu_to_le16(~IEEE80211_HT_CAP_SGI_40);
372                                 }
373                                 break;
374                         }
375                 }
376
377                 *buffer += sizeof(struct mwifiex_ie_types_htcap);
378                 ret_len += sizeof(struct mwifiex_ie_types_htcap);
379         }
380
381         if (bss_desc->bcn_ht_oper) {
382                 if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
383                         ht_info = (struct mwifiex_ie_types_htinfo *) *buffer;
384                         memset(ht_info, 0,
385                                sizeof(struct mwifiex_ie_types_htinfo));
386                         ht_info->header.type =
387                                         cpu_to_le16(WLAN_EID_HT_OPERATION);
388                         ht_info->header.len =
389                                 cpu_to_le16(
390                                         sizeof(struct ieee80211_ht_operation));
391
392                         memcpy((u8 *) ht_info +
393                                sizeof(struct mwifiex_ie_types_header),
394                                (u8 *)bss_desc->bcn_ht_oper,
395                                le16_to_cpu(ht_info->header.len));
396
397                         if (!(sband->ht_cap.cap &
398                                         IEEE80211_HT_CAP_SUP_WIDTH_20_40))
399                                 ht_info->ht_oper.ht_param &=
400                                         ~(IEEE80211_HT_PARAM_CHAN_WIDTH_ANY |
401                                         IEEE80211_HT_PARAM_CHA_SEC_OFFSET);
402
403                         *buffer += sizeof(struct mwifiex_ie_types_htinfo);
404                         ret_len += sizeof(struct mwifiex_ie_types_htinfo);
405                 }
406
407                 chan_list =
408                         (struct mwifiex_ie_types_chan_list_param_set *) *buffer;
409                 memset(chan_list, 0,
410                        sizeof(struct mwifiex_ie_types_chan_list_param_set));
411                 chan_list->header.type = cpu_to_le16(TLV_TYPE_CHANLIST);
412                 chan_list->header.len = cpu_to_le16(
413                         sizeof(struct mwifiex_ie_types_chan_list_param_set) -
414                         sizeof(struct mwifiex_ie_types_header));
415                 chan_list->chan_scan_param[0].chan_number =
416                         bss_desc->bcn_ht_oper->primary_chan;
417                 chan_list->chan_scan_param[0].radio_type =
418                         mwifiex_band_to_radio_type((u8) bss_desc->bss_band);
419
420                 if (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
421                     bss_desc->bcn_ht_oper->ht_param &
422                     IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)
423                         SET_SECONDARYCHAN(chan_list->chan_scan_param[0].
424                                           radio_type,
425                                           (bss_desc->bcn_ht_oper->ht_param &
426                                           IEEE80211_HT_PARAM_CHA_SEC_OFFSET));
427
428                 *buffer += sizeof(struct mwifiex_ie_types_chan_list_param_set);
429                 ret_len += sizeof(struct mwifiex_ie_types_chan_list_param_set);
430         }
431
432         if (bss_desc->bcn_bss_co_2040) {
433                 bss_co_2040 = (struct mwifiex_ie_types_2040bssco *) *buffer;
434                 memset(bss_co_2040, 0,
435                        sizeof(struct mwifiex_ie_types_2040bssco));
436                 bss_co_2040->header.type = cpu_to_le16(WLAN_EID_BSS_COEX_2040);
437                 bss_co_2040->header.len =
438                        cpu_to_le16(sizeof(bss_co_2040->bss_co_2040));
439
440                 memcpy((u8 *) bss_co_2040 +
441                        sizeof(struct mwifiex_ie_types_header),
442                        bss_desc->bcn_bss_co_2040 +
443                        sizeof(struct ieee_types_header),
444                        le16_to_cpu(bss_co_2040->header.len));
445
446                 *buffer += sizeof(struct mwifiex_ie_types_2040bssco);
447                 ret_len += sizeof(struct mwifiex_ie_types_2040bssco);
448         }
449
450         if (bss_desc->bcn_ext_cap) {
451                 hdr = (void *)bss_desc->bcn_ext_cap;
452                 ext_cap = (struct mwifiex_ie_types_extcap *) *buffer;
453                 memset(ext_cap, 0, sizeof(struct mwifiex_ie_types_extcap));
454                 ext_cap->header.type = cpu_to_le16(WLAN_EID_EXT_CAPABILITY);
455                 ext_cap->header.len = cpu_to_le16(hdr->len);
456
457                 memcpy((u8 *)ext_cap->ext_capab,
458                        bss_desc->bcn_ext_cap + sizeof(struct ieee_types_header),
459                        le16_to_cpu(ext_cap->header.len));
460
461                 if (hdr->len > 3 &&
462                     ext_cap->ext_capab[3] & WLAN_EXT_CAPA4_INTERWORKING_ENABLED)
463                         priv->hs2_enabled = true;
464                 else
465                         priv->hs2_enabled = false;
466
467                 *buffer += sizeof(struct mwifiex_ie_types_extcap) + hdr->len;
468                 ret_len += sizeof(struct mwifiex_ie_types_extcap) + hdr->len;
469         }
470
471         return ret_len;
472 }
473
474 /*
475  * This function checks if the given pointer is valid entry of
476  * Tx BA Stream table.
477  */
478 static int mwifiex_is_tx_ba_stream_ptr_valid(struct mwifiex_private *priv,
479                                 struct mwifiex_tx_ba_stream_tbl *tx_tbl_ptr)
480 {
481         struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
482
483         list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
484                 if (tx_ba_tsr_tbl == tx_tbl_ptr)
485                         return true;
486         }
487
488         return false;
489 }
490
491 /*
492  * This function deletes the given entry in Tx BA Stream table.
493  *
494  * The function also performs a validity check on the supplied
495  * pointer before trying to delete.
496  */
497 void mwifiex_11n_delete_tx_ba_stream_tbl_entry(struct mwifiex_private *priv,
498                                 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl)
499 {
500         if (!tx_ba_tsr_tbl &&
501             mwifiex_is_tx_ba_stream_ptr_valid(priv, tx_ba_tsr_tbl))
502                 return;
503
504         mwifiex_dbg(priv->adapter, INFO,
505                     "info: tx_ba_tsr_tbl %p\n", tx_ba_tsr_tbl);
506
507         list_del(&tx_ba_tsr_tbl->list);
508
509         kfree(tx_ba_tsr_tbl);
510 }
511
512 /*
513  * This function deletes all the entries in Tx BA Stream table.
514  */
515 void mwifiex_11n_delete_all_tx_ba_stream_tbl(struct mwifiex_private *priv)
516 {
517         int i;
518         struct mwifiex_tx_ba_stream_tbl *del_tbl_ptr, *tmp_node;
519         unsigned long flags;
520
521         spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
522         list_for_each_entry_safe(del_tbl_ptr, tmp_node,
523                                  &priv->tx_ba_stream_tbl_ptr, list)
524                 mwifiex_11n_delete_tx_ba_stream_tbl_entry(priv, del_tbl_ptr);
525         spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
526
527         INIT_LIST_HEAD(&priv->tx_ba_stream_tbl_ptr);
528
529         for (i = 0; i < MAX_NUM_TID; ++i)
530                 priv->aggr_prio_tbl[i].ampdu_ap =
531                         priv->aggr_prio_tbl[i].ampdu_user;
532 }
533
534 /*
535  * This function returns the pointer to an entry in BA Stream
536  * table which matches the given RA/TID pair.
537  */
538 struct mwifiex_tx_ba_stream_tbl *
539 mwifiex_get_ba_tbl(struct mwifiex_private *priv, int tid, u8 *ra)
540 {
541         struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
542         unsigned long flags;
543
544         spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
545         list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
546                 if (ether_addr_equal_unaligned(tx_ba_tsr_tbl->ra, ra) &&
547                     tx_ba_tsr_tbl->tid == tid) {
548                         spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock,
549                                                flags);
550                         return tx_ba_tsr_tbl;
551                 }
552         }
553         spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
554         return NULL;
555 }
556
557 /*
558  * This function creates an entry in Tx BA stream table for the
559  * given RA/TID pair.
560  */
561 void mwifiex_create_ba_tbl(struct mwifiex_private *priv, u8 *ra, int tid,
562                            enum mwifiex_ba_status ba_status)
563 {
564         struct mwifiex_tx_ba_stream_tbl *new_node;
565         struct mwifiex_ra_list_tbl *ra_list;
566         unsigned long flags;
567         int tid_down;
568
569         if (!mwifiex_get_ba_tbl(priv, tid, ra)) {
570                 new_node = kzalloc(sizeof(struct mwifiex_tx_ba_stream_tbl),
571                                    GFP_ATOMIC);
572                 if (!new_node)
573                         return;
574
575                 tid_down = mwifiex_wmm_downgrade_tid(priv, tid);
576                 ra_list = mwifiex_wmm_get_ralist_node(priv, tid_down, ra);
577                 if (ra_list) {
578                         ra_list->ba_status = ba_status;
579                         ra_list->amsdu_in_ampdu = false;
580                 }
581                 INIT_LIST_HEAD(&new_node->list);
582
583                 new_node->tid = tid;
584                 new_node->ba_status = ba_status;
585                 memcpy(new_node->ra, ra, ETH_ALEN);
586
587                 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
588                 list_add_tail(&new_node->list, &priv->tx_ba_stream_tbl_ptr);
589                 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
590         }
591 }
592
593 /*
594  * This function sends an add BA request to the given TID/RA pair.
595  */
596 int mwifiex_send_addba(struct mwifiex_private *priv, int tid, u8 *peer_mac)
597 {
598         struct host_cmd_ds_11n_addba_req add_ba_req;
599         u32 tx_win_size = priv->add_ba_param.tx_win_size;
600         static u8 dialog_tok;
601         int ret;
602         unsigned long flags;
603         u16 block_ack_param_set;
604
605         mwifiex_dbg(priv->adapter, CMD, "cmd: %s: tid %d\n", __func__, tid);
606
607         memset(&add_ba_req, 0, sizeof(add_ba_req));
608
609         if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
610             ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
611             priv->adapter->is_hw_11ac_capable &&
612             memcmp(priv->cfg_bssid, peer_mac, ETH_ALEN)) {
613                 struct mwifiex_sta_node *sta_ptr;
614
615                 spin_lock_irqsave(&priv->sta_list_spinlock, flags);
616                 sta_ptr = mwifiex_get_sta_entry(priv, peer_mac);
617                 if (!sta_ptr) {
618                         spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);
619                         mwifiex_dbg(priv->adapter, ERROR,
620                                     "BA setup with unknown TDLS peer %pM!\n",
621                                     peer_mac);
622                         return -1;
623                 }
624                 if (sta_ptr->is_11ac_enabled)
625                         tx_win_size = MWIFIEX_11AC_STA_AMPDU_DEF_TXWINSIZE;
626                 spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);
627         }
628
629         block_ack_param_set = (u16)((tid << BLOCKACKPARAM_TID_POS) |
630                                     tx_win_size << BLOCKACKPARAM_WINSIZE_POS |
631                                     IMMEDIATE_BLOCK_ACK);
632
633         /* enable AMSDU inside AMPDU */
634         if (priv->add_ba_param.tx_amsdu &&
635             (priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED))
636                 block_ack_param_set |= BLOCKACKPARAM_AMSDU_SUPP_MASK;
637
638         add_ba_req.block_ack_param_set = cpu_to_le16(block_ack_param_set);
639         add_ba_req.block_ack_tmo = cpu_to_le16((u16)priv->add_ba_param.timeout);
640
641         ++dialog_tok;
642
643         if (dialog_tok == 0)
644                 dialog_tok = 1;
645
646         add_ba_req.dialog_token = dialog_tok;
647         memcpy(&add_ba_req.peer_mac_addr, peer_mac, ETH_ALEN);
648
649         /* We don't wait for the response of this command */
650         ret = mwifiex_send_cmd(priv, HostCmd_CMD_11N_ADDBA_REQ,
651                                0, 0, &add_ba_req, false);
652
653         return ret;
654 }
655
656 /*
657  * This function sends a delete BA request to the given TID/RA pair.
658  */
659 int mwifiex_send_delba(struct mwifiex_private *priv, int tid, u8 *peer_mac,
660                        int initiator)
661 {
662         struct host_cmd_ds_11n_delba delba;
663         int ret;
664         uint16_t del_ba_param_set;
665
666         memset(&delba, 0, sizeof(delba));
667         delba.del_ba_param_set = cpu_to_le16(tid << DELBA_TID_POS);
668
669         del_ba_param_set = le16_to_cpu(delba.del_ba_param_set);
670         if (initiator)
671                 del_ba_param_set |= IEEE80211_DELBA_PARAM_INITIATOR_MASK;
672         else
673                 del_ba_param_set &= ~IEEE80211_DELBA_PARAM_INITIATOR_MASK;
674
675         memcpy(&delba.peer_mac_addr, peer_mac, ETH_ALEN);
676
677         /* We don't wait for the response of this command */
678         ret = mwifiex_send_cmd(priv, HostCmd_CMD_11N_DELBA,
679                                HostCmd_ACT_GEN_SET, 0, &delba, false);
680
681         return ret;
682 }
683
684 /*
685  * This function sends delba to specific tid
686  */
687 void mwifiex_11n_delba(struct mwifiex_private *priv, int tid)
688 {
689         struct mwifiex_rx_reorder_tbl *rx_reor_tbl_ptr;
690         unsigned long flags;
691
692         spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
693         list_for_each_entry(rx_reor_tbl_ptr, &priv->rx_reorder_tbl_ptr, list) {
694                 if (rx_reor_tbl_ptr->tid == tid) {
695                         dev_dbg(priv->adapter->dev,
696                                 "Send delba to tid=%d, %pM\n",
697                                 tid, rx_reor_tbl_ptr->ta);
698                         mwifiex_send_delba(priv, tid, rx_reor_tbl_ptr->ta, 0);
699                         goto exit;
700                 }
701         }
702 exit:
703         spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
704 }
705
706 /*
707  * This function handles the command response of a delete BA request.
708  */
709 void mwifiex_11n_delete_ba_stream(struct mwifiex_private *priv, u8 *del_ba)
710 {
711         struct host_cmd_ds_11n_delba *cmd_del_ba =
712                 (struct host_cmd_ds_11n_delba *) del_ba;
713         uint16_t del_ba_param_set = le16_to_cpu(cmd_del_ba->del_ba_param_set);
714         int tid;
715
716         tid = del_ba_param_set >> DELBA_TID_POS;
717
718         mwifiex_del_ba_tbl(priv, tid, cmd_del_ba->peer_mac_addr,
719                            TYPE_DELBA_RECEIVE, INITIATOR_BIT(del_ba_param_set));
720 }
721
722 /*
723  * This function retrieves the Rx reordering table.
724  */
725 int mwifiex_get_rx_reorder_tbl(struct mwifiex_private *priv,
726                                struct mwifiex_ds_rx_reorder_tbl *buf)
727 {
728         int i;
729         struct mwifiex_ds_rx_reorder_tbl *rx_reo_tbl = buf;
730         struct mwifiex_rx_reorder_tbl *rx_reorder_tbl_ptr;
731         int count = 0;
732         unsigned long flags;
733
734         spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
735         list_for_each_entry(rx_reorder_tbl_ptr, &priv->rx_reorder_tbl_ptr,
736                             list) {
737                 rx_reo_tbl->tid = (u16) rx_reorder_tbl_ptr->tid;
738                 memcpy(rx_reo_tbl->ta, rx_reorder_tbl_ptr->ta, ETH_ALEN);
739                 rx_reo_tbl->start_win = rx_reorder_tbl_ptr->start_win;
740                 rx_reo_tbl->win_size = rx_reorder_tbl_ptr->win_size;
741                 for (i = 0; i < rx_reorder_tbl_ptr->win_size; ++i) {
742                         if (rx_reorder_tbl_ptr->rx_reorder_ptr[i])
743                                 rx_reo_tbl->buffer[i] = true;
744                         else
745                                 rx_reo_tbl->buffer[i] = false;
746                 }
747                 rx_reo_tbl++;
748                 count++;
749
750                 if (count >= MWIFIEX_MAX_RX_BASTREAM_SUPPORTED)
751                         break;
752         }
753         spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
754
755         return count;
756 }
757
758 /*
759  * This function retrieves the Tx BA stream table.
760  */
761 int mwifiex_get_tx_ba_stream_tbl(struct mwifiex_private *priv,
762                                  struct mwifiex_ds_tx_ba_stream_tbl *buf)
763 {
764         struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
765         struct mwifiex_ds_tx_ba_stream_tbl *rx_reo_tbl = buf;
766         int count = 0;
767         unsigned long flags;
768
769         spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
770         list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
771                 rx_reo_tbl->tid = (u16) tx_ba_tsr_tbl->tid;
772                 mwifiex_dbg(priv->adapter, DATA, "data: %s tid=%d\n",
773                             __func__, rx_reo_tbl->tid);
774                 memcpy(rx_reo_tbl->ra, tx_ba_tsr_tbl->ra, ETH_ALEN);
775                 rx_reo_tbl->amsdu = tx_ba_tsr_tbl->amsdu;
776                 rx_reo_tbl++;
777                 count++;
778                 if (count >= MWIFIEX_MAX_TX_BASTREAM_SUPPORTED)
779                         break;
780         }
781         spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
782
783         return count;
784 }
785
786 /*
787  * This function retrieves the entry for specific tx BA stream table by RA and
788  * deletes it.
789  */
790 void mwifiex_del_tx_ba_stream_tbl_by_ra(struct mwifiex_private *priv, u8 *ra)
791 {
792         struct mwifiex_tx_ba_stream_tbl *tbl, *tmp;
793         unsigned long flags;
794
795         if (!ra)
796                 return;
797
798         spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
799         list_for_each_entry_safe(tbl, tmp, &priv->tx_ba_stream_tbl_ptr, list)
800                 if (!memcmp(tbl->ra, ra, ETH_ALEN))
801                         mwifiex_11n_delete_tx_ba_stream_tbl_entry(priv, tbl);
802         spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
803
804         return;
805 }
806
807 /* This function initializes the BlockACK setup information for given
808  * mwifiex_private structure.
809  */
810 void mwifiex_set_ba_params(struct mwifiex_private *priv)
811 {
812         priv->add_ba_param.timeout = MWIFIEX_DEFAULT_BLOCK_ACK_TIMEOUT;
813
814         if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
815                 priv->add_ba_param.tx_win_size =
816                                                 MWIFIEX_UAP_AMPDU_DEF_TXWINSIZE;
817                 priv->add_ba_param.rx_win_size =
818                                                 MWIFIEX_UAP_AMPDU_DEF_RXWINSIZE;
819         } else {
820                 priv->add_ba_param.tx_win_size =
821                                                 MWIFIEX_STA_AMPDU_DEF_TXWINSIZE;
822                 priv->add_ba_param.rx_win_size =
823                                                 MWIFIEX_STA_AMPDU_DEF_RXWINSIZE;
824         }
825
826         priv->add_ba_param.tx_amsdu = true;
827         priv->add_ba_param.rx_amsdu = true;
828
829         return;
830 }
831
832 u8 mwifiex_get_sec_chan_offset(int chan)
833 {
834         u8 sec_offset;
835
836         switch (chan) {
837         case 36:
838         case 44:
839         case 52:
840         case 60:
841         case 100:
842         case 108:
843         case 116:
844         case 124:
845         case 132:
846         case 140:
847         case 149:
848         case 157:
849                 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
850                 break;
851         case 40:
852         case 48:
853         case 56:
854         case 64:
855         case 104:
856         case 112:
857         case 120:
858         case 128:
859         case 136:
860         case 144:
861         case 153:
862         case 161:
863                 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
864                 break;
865         case 165:
866         default:
867                 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
868                 break;
869         }
870
871         return sec_offset;
872 }
873
874 /* This function will send DELBA to entries in the priv's
875  * Tx BA stream table
876  */
877 static void
878 mwifiex_send_delba_txbastream_tbl(struct mwifiex_private *priv, u8 tid)
879 {
880         struct mwifiex_adapter *adapter = priv->adapter;
881         struct mwifiex_tx_ba_stream_tbl *tx_ba_stream_tbl_ptr;
882
883         list_for_each_entry(tx_ba_stream_tbl_ptr,
884                             &priv->tx_ba_stream_tbl_ptr, list) {
885                 if (tx_ba_stream_tbl_ptr->ba_status == BA_SETUP_COMPLETE) {
886                         if (tid == tx_ba_stream_tbl_ptr->tid) {
887                                 dev_dbg(adapter->dev,
888                                         "Tx:Send delba to tid=%d, %pM\n", tid,
889                                         tx_ba_stream_tbl_ptr->ra);
890                                 mwifiex_send_delba(priv,
891                                                    tx_ba_stream_tbl_ptr->tid,
892                                                    tx_ba_stream_tbl_ptr->ra, 1);
893                                 return;
894                         }
895                 }
896         }
897 }
898
899 /* This function updates all the tx_win_size
900  */
901 void mwifiex_update_ampdu_txwinsize(struct mwifiex_adapter *adapter)
902 {
903         u8 i;
904         u32 tx_win_size;
905         struct mwifiex_private *priv;
906
907         for (i = 0; i < adapter->priv_num; i++) {
908                 if (!adapter->priv[i])
909                         continue;
910                 priv = adapter->priv[i];
911                 tx_win_size = priv->add_ba_param.tx_win_size;
912
913                 if (priv->bss_type == MWIFIEX_BSS_TYPE_STA)
914                         priv->add_ba_param.tx_win_size =
915                                 MWIFIEX_STA_AMPDU_DEF_TXWINSIZE;
916
917                 if (priv->bss_type == MWIFIEX_BSS_TYPE_P2P)
918                         priv->add_ba_param.tx_win_size =
919                                 MWIFIEX_STA_AMPDU_DEF_TXWINSIZE;
920
921                 if (priv->bss_type == MWIFIEX_BSS_TYPE_UAP)
922                         priv->add_ba_param.tx_win_size =
923                                 MWIFIEX_UAP_AMPDU_DEF_TXWINSIZE;
924
925                 if (adapter->coex_win_size) {
926                         if (adapter->coex_tx_win_size)
927                                 priv->add_ba_param.tx_win_size =
928                                         adapter->coex_tx_win_size;
929                 }
930
931                 if (tx_win_size != priv->add_ba_param.tx_win_size) {
932                         if (!priv->media_connected)
933                                 continue;
934                         for (i = 0; i < MAX_NUM_TID; i++)
935                                 mwifiex_send_delba_txbastream_tbl(priv, i);
936                 }
937         }
938 }