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 */
mwifiex_fill_cap_info(struct mwifiex_private * priv,u8 radio_type,struct ieee80211_ht_cap * ht_cap)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 dev_err(priv->adapter->dev, "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 *
mwifiex_get_ba_status(struct mwifiex_private * priv,enum mwifiex_ba_status ba_status)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 */
mwifiex_ret_11n_delba(struct mwifiex_private * priv,struct host_cmd_ds_command * resp)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 */
mwifiex_ret_11n_addba_req(struct mwifiex_private * priv,struct host_cmd_ds_command * resp)156 int mwifiex_ret_11n_addba_req(struct mwifiex_private *priv,
157 struct host_cmd_ds_command *resp)
158 {
159 int tid;
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 u16 block_ack_param_set = le16_to_cpu(add_ba_rsp->block_ack_param_set);
163
164 add_ba_rsp->ssn = cpu_to_le16((le16_to_cpu(add_ba_rsp->ssn))
165 & SSN_MASK);
166
167 tid = (block_ack_param_set & IEEE80211_ADDBA_PARAM_TID_MASK)
168 >> BLOCKACKPARAM_TID_POS;
169 if (le16_to_cpu(add_ba_rsp->status_code) != BA_RESULT_SUCCESS) {
170 mwifiex_del_ba_tbl(priv, tid, add_ba_rsp->peer_mac_addr,
171 TYPE_DELBA_SENT, true);
172 if (add_ba_rsp->add_rsp_result != BA_RESULT_TIMEOUT)
173 priv->aggr_prio_tbl[tid].ampdu_ap =
174 BA_STREAM_NOT_ALLOWED;
175 return 0;
176 }
177
178 tx_ba_tbl = mwifiex_get_ba_tbl(priv, tid, add_ba_rsp->peer_mac_addr);
179 if (tx_ba_tbl) {
180 dev_dbg(priv->adapter->dev, "info: BA stream complete\n");
181 tx_ba_tbl->ba_status = BA_SETUP_COMPLETE;
182 if ((block_ack_param_set & BLOCKACKPARAM_AMSDU_SUPP_MASK) &&
183 priv->add_ba_param.tx_amsdu &&
184 (priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED))
185 tx_ba_tbl->amsdu = true;
186 else
187 tx_ba_tbl->amsdu = false;
188 } else {
189 dev_err(priv->adapter->dev, "BA stream not created\n");
190 }
191
192 return 0;
193 }
194
195 /*
196 * This function prepares command of reconfigure Tx buffer.
197 *
198 * Preparation includes -
199 * - Setting command ID, action and proper size
200 * - Setting Tx buffer size (for SET only)
201 * - Ensuring correct endian-ness
202 */
mwifiex_cmd_recfg_tx_buf(struct mwifiex_private * priv,struct host_cmd_ds_command * cmd,int cmd_action,u16 * buf_size)203 int mwifiex_cmd_recfg_tx_buf(struct mwifiex_private *priv,
204 struct host_cmd_ds_command *cmd, int cmd_action,
205 u16 *buf_size)
206 {
207 struct host_cmd_ds_txbuf_cfg *tx_buf = &cmd->params.tx_buf;
208 u16 action = (u16) cmd_action;
209
210 cmd->command = cpu_to_le16(HostCmd_CMD_RECONFIGURE_TX_BUFF);
211 cmd->size =
212 cpu_to_le16(sizeof(struct host_cmd_ds_txbuf_cfg) + S_DS_GEN);
213 tx_buf->action = cpu_to_le16(action);
214 switch (action) {
215 case HostCmd_ACT_GEN_SET:
216 dev_dbg(priv->adapter->dev, "cmd: set tx_buf=%d\n", *buf_size);
217 tx_buf->buff_size = cpu_to_le16(*buf_size);
218 break;
219 case HostCmd_ACT_GEN_GET:
220 default:
221 tx_buf->buff_size = 0;
222 break;
223 }
224 return 0;
225 }
226
227 /*
228 * This function prepares command of AMSDU aggregation control.
229 *
230 * Preparation includes -
231 * - Setting command ID, action and proper size
232 * - Setting AMSDU control parameters (for SET only)
233 * - Ensuring correct endian-ness
234 */
mwifiex_cmd_amsdu_aggr_ctrl(struct host_cmd_ds_command * cmd,int cmd_action,struct mwifiex_ds_11n_amsdu_aggr_ctrl * aa_ctrl)235 int mwifiex_cmd_amsdu_aggr_ctrl(struct host_cmd_ds_command *cmd,
236 int cmd_action,
237 struct mwifiex_ds_11n_amsdu_aggr_ctrl *aa_ctrl)
238 {
239 struct host_cmd_ds_amsdu_aggr_ctrl *amsdu_ctrl =
240 &cmd->params.amsdu_aggr_ctrl;
241 u16 action = (u16) cmd_action;
242
243 cmd->command = cpu_to_le16(HostCmd_CMD_AMSDU_AGGR_CTRL);
244 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_amsdu_aggr_ctrl)
245 + S_DS_GEN);
246 amsdu_ctrl->action = cpu_to_le16(action);
247 switch (action) {
248 case HostCmd_ACT_GEN_SET:
249 amsdu_ctrl->enable = cpu_to_le16(aa_ctrl->enable);
250 amsdu_ctrl->curr_buf_size = 0;
251 break;
252 case HostCmd_ACT_GEN_GET:
253 default:
254 amsdu_ctrl->curr_buf_size = 0;
255 break;
256 }
257 return 0;
258 }
259
260 /*
261 * This function prepares 11n configuration command.
262 *
263 * Preparation includes -
264 * - Setting command ID, action and proper size
265 * - Setting HT Tx capability and HT Tx information fields
266 * - Ensuring correct endian-ness
267 */
mwifiex_cmd_11n_cfg(struct mwifiex_private * priv,struct host_cmd_ds_command * cmd,u16 cmd_action,struct mwifiex_ds_11n_tx_cfg * txcfg)268 int mwifiex_cmd_11n_cfg(struct mwifiex_private *priv,
269 struct host_cmd_ds_command *cmd, u16 cmd_action,
270 struct mwifiex_ds_11n_tx_cfg *txcfg)
271 {
272 struct host_cmd_ds_11n_cfg *htcfg = &cmd->params.htcfg;
273
274 cmd->command = cpu_to_le16(HostCmd_CMD_11N_CFG);
275 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_11n_cfg) + S_DS_GEN);
276 htcfg->action = cpu_to_le16(cmd_action);
277 htcfg->ht_tx_cap = cpu_to_le16(txcfg->tx_htcap);
278 htcfg->ht_tx_info = cpu_to_le16(txcfg->tx_htinfo);
279
280 if (priv->adapter->is_hw_11ac_capable)
281 htcfg->misc_config = cpu_to_le16(txcfg->misc_config);
282
283 return 0;
284 }
285
286 /*
287 * This function appends an 11n TLV to a buffer.
288 *
289 * Buffer allocation is responsibility of the calling
290 * function. No size validation is made here.
291 *
292 * The function fills up the following sections, if applicable -
293 * - HT capability IE
294 * - HT information IE (with channel list)
295 * - 20/40 BSS Coexistence IE
296 * - HT Extended Capabilities IE
297 */
298 int
mwifiex_cmd_append_11n_tlv(struct mwifiex_private * priv,struct mwifiex_bssdescriptor * bss_desc,u8 ** buffer)299 mwifiex_cmd_append_11n_tlv(struct mwifiex_private *priv,
300 struct mwifiex_bssdescriptor *bss_desc,
301 u8 **buffer)
302 {
303 struct mwifiex_ie_types_htcap *ht_cap;
304 struct mwifiex_ie_types_htinfo *ht_info;
305 struct mwifiex_ie_types_chan_list_param_set *chan_list;
306 struct mwifiex_ie_types_2040bssco *bss_co_2040;
307 struct mwifiex_ie_types_extcap *ext_cap;
308 int ret_len = 0;
309 struct ieee80211_supported_band *sband;
310 struct ieee_types_header *hdr;
311 u8 radio_type;
312
313 if (!buffer || !*buffer)
314 return ret_len;
315
316 radio_type = mwifiex_band_to_radio_type((u8) bss_desc->bss_band);
317 sband = priv->wdev->wiphy->bands[radio_type];
318
319 if (bss_desc->bcn_ht_cap) {
320 ht_cap = (struct mwifiex_ie_types_htcap *) *buffer;
321 memset(ht_cap, 0, sizeof(struct mwifiex_ie_types_htcap));
322 ht_cap->header.type = cpu_to_le16(WLAN_EID_HT_CAPABILITY);
323 ht_cap->header.len =
324 cpu_to_le16(sizeof(struct ieee80211_ht_cap));
325 memcpy((u8 *) ht_cap + sizeof(struct mwifiex_ie_types_header),
326 (u8 *)bss_desc->bcn_ht_cap,
327 le16_to_cpu(ht_cap->header.len));
328
329 mwifiex_fill_cap_info(priv, radio_type, &ht_cap->ht_cap);
330
331 *buffer += sizeof(struct mwifiex_ie_types_htcap);
332 ret_len += sizeof(struct mwifiex_ie_types_htcap);
333 }
334
335 if (bss_desc->bcn_ht_oper) {
336 if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
337 ht_info = (struct mwifiex_ie_types_htinfo *) *buffer;
338 memset(ht_info, 0,
339 sizeof(struct mwifiex_ie_types_htinfo));
340 ht_info->header.type =
341 cpu_to_le16(WLAN_EID_HT_OPERATION);
342 ht_info->header.len =
343 cpu_to_le16(
344 sizeof(struct ieee80211_ht_operation));
345
346 memcpy((u8 *) ht_info +
347 sizeof(struct mwifiex_ie_types_header),
348 (u8 *)bss_desc->bcn_ht_oper,
349 le16_to_cpu(ht_info->header.len));
350
351 if (!(sband->ht_cap.cap &
352 IEEE80211_HT_CAP_SUP_WIDTH_20_40))
353 ht_info->ht_oper.ht_param &=
354 ~(IEEE80211_HT_PARAM_CHAN_WIDTH_ANY |
355 IEEE80211_HT_PARAM_CHA_SEC_OFFSET);
356
357 *buffer += sizeof(struct mwifiex_ie_types_htinfo);
358 ret_len += sizeof(struct mwifiex_ie_types_htinfo);
359 }
360
361 chan_list =
362 (struct mwifiex_ie_types_chan_list_param_set *) *buffer;
363 memset(chan_list, 0,
364 sizeof(struct mwifiex_ie_types_chan_list_param_set));
365 chan_list->header.type = cpu_to_le16(TLV_TYPE_CHANLIST);
366 chan_list->header.len = cpu_to_le16(
367 sizeof(struct mwifiex_ie_types_chan_list_param_set) -
368 sizeof(struct mwifiex_ie_types_header));
369 chan_list->chan_scan_param[0].chan_number =
370 bss_desc->bcn_ht_oper->primary_chan;
371 chan_list->chan_scan_param[0].radio_type =
372 mwifiex_band_to_radio_type((u8) bss_desc->bss_band);
373
374 if (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
375 bss_desc->bcn_ht_oper->ht_param &
376 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)
377 SET_SECONDARYCHAN(chan_list->chan_scan_param[0].
378 radio_type,
379 (bss_desc->bcn_ht_oper->ht_param &
380 IEEE80211_HT_PARAM_CHA_SEC_OFFSET));
381
382 *buffer += sizeof(struct mwifiex_ie_types_chan_list_param_set);
383 ret_len += sizeof(struct mwifiex_ie_types_chan_list_param_set);
384 }
385
386 if (bss_desc->bcn_bss_co_2040) {
387 bss_co_2040 = (struct mwifiex_ie_types_2040bssco *) *buffer;
388 memset(bss_co_2040, 0,
389 sizeof(struct mwifiex_ie_types_2040bssco));
390 bss_co_2040->header.type = cpu_to_le16(WLAN_EID_BSS_COEX_2040);
391 bss_co_2040->header.len =
392 cpu_to_le16(sizeof(bss_co_2040->bss_co_2040));
393
394 memcpy((u8 *) bss_co_2040 +
395 sizeof(struct mwifiex_ie_types_header),
396 bss_desc->bcn_bss_co_2040 +
397 sizeof(struct ieee_types_header),
398 le16_to_cpu(bss_co_2040->header.len));
399
400 *buffer += sizeof(struct mwifiex_ie_types_2040bssco);
401 ret_len += sizeof(struct mwifiex_ie_types_2040bssco);
402 }
403
404 if (bss_desc->bcn_ext_cap) {
405 hdr = (void *)bss_desc->bcn_ext_cap;
406 ext_cap = (struct mwifiex_ie_types_extcap *) *buffer;
407 memset(ext_cap, 0, sizeof(struct mwifiex_ie_types_extcap));
408 ext_cap->header.type = cpu_to_le16(WLAN_EID_EXT_CAPABILITY);
409 ext_cap->header.len = cpu_to_le16(hdr->len);
410
411 memcpy((u8 *)ext_cap->ext_capab,
412 bss_desc->bcn_ext_cap + sizeof(struct ieee_types_header),
413 le16_to_cpu(ext_cap->header.len));
414
415 if (hdr->len > 3 &&
416 ext_cap->ext_capab[3] & WLAN_EXT_CAPA4_INTERWORKING_ENABLED)
417 priv->hs2_enabled = true;
418 else
419 priv->hs2_enabled = false;
420
421 *buffer += sizeof(struct mwifiex_ie_types_extcap) + hdr->len;
422 ret_len += sizeof(struct mwifiex_ie_types_extcap) + hdr->len;
423 }
424
425 return ret_len;
426 }
427
428 /*
429 * This function checks if the given pointer is valid entry of
430 * Tx BA Stream table.
431 */
mwifiex_is_tx_ba_stream_ptr_valid(struct mwifiex_private * priv,struct mwifiex_tx_ba_stream_tbl * tx_tbl_ptr)432 static int mwifiex_is_tx_ba_stream_ptr_valid(struct mwifiex_private *priv,
433 struct mwifiex_tx_ba_stream_tbl *tx_tbl_ptr)
434 {
435 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
436
437 list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
438 if (tx_ba_tsr_tbl == tx_tbl_ptr)
439 return true;
440 }
441
442 return false;
443 }
444
445 /*
446 * This function deletes the given entry in Tx BA Stream table.
447 *
448 * The function also performs a validity check on the supplied
449 * pointer before trying to delete.
450 */
mwifiex_11n_delete_tx_ba_stream_tbl_entry(struct mwifiex_private * priv,struct mwifiex_tx_ba_stream_tbl * tx_ba_tsr_tbl)451 void mwifiex_11n_delete_tx_ba_stream_tbl_entry(struct mwifiex_private *priv,
452 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl)
453 {
454 if (!tx_ba_tsr_tbl &&
455 mwifiex_is_tx_ba_stream_ptr_valid(priv, tx_ba_tsr_tbl))
456 return;
457
458 dev_dbg(priv->adapter->dev, "info: tx_ba_tsr_tbl %p\n", tx_ba_tsr_tbl);
459
460 list_del(&tx_ba_tsr_tbl->list);
461
462 kfree(tx_ba_tsr_tbl);
463 }
464
465 /*
466 * This function deletes all the entries in Tx BA Stream table.
467 */
mwifiex_11n_delete_all_tx_ba_stream_tbl(struct mwifiex_private * priv)468 void mwifiex_11n_delete_all_tx_ba_stream_tbl(struct mwifiex_private *priv)
469 {
470 int i;
471 struct mwifiex_tx_ba_stream_tbl *del_tbl_ptr, *tmp_node;
472 unsigned long flags;
473
474 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
475 list_for_each_entry_safe(del_tbl_ptr, tmp_node,
476 &priv->tx_ba_stream_tbl_ptr, list)
477 mwifiex_11n_delete_tx_ba_stream_tbl_entry(priv, del_tbl_ptr);
478 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
479
480 INIT_LIST_HEAD(&priv->tx_ba_stream_tbl_ptr);
481
482 for (i = 0; i < MAX_NUM_TID; ++i)
483 priv->aggr_prio_tbl[i].ampdu_ap =
484 priv->aggr_prio_tbl[i].ampdu_user;
485 }
486
487 /*
488 * This function returns the pointer to an entry in BA Stream
489 * table which matches the given RA/TID pair.
490 */
491 struct mwifiex_tx_ba_stream_tbl *
mwifiex_get_ba_tbl(struct mwifiex_private * priv,int tid,u8 * ra)492 mwifiex_get_ba_tbl(struct mwifiex_private *priv, int tid, u8 *ra)
493 {
494 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
495 unsigned long flags;
496
497 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
498 list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
499 if (ether_addr_equal_unaligned(tx_ba_tsr_tbl->ra, ra) &&
500 tx_ba_tsr_tbl->tid == tid) {
501 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock,
502 flags);
503 return tx_ba_tsr_tbl;
504 }
505 }
506 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
507 return NULL;
508 }
509
510 /*
511 * This function creates an entry in Tx BA stream table for the
512 * given RA/TID pair.
513 */
mwifiex_create_ba_tbl(struct mwifiex_private * priv,u8 * ra,int tid,enum mwifiex_ba_status ba_status)514 void mwifiex_create_ba_tbl(struct mwifiex_private *priv, u8 *ra, int tid,
515 enum mwifiex_ba_status ba_status)
516 {
517 struct mwifiex_tx_ba_stream_tbl *new_node;
518 unsigned long flags;
519
520 if (!mwifiex_get_ba_tbl(priv, tid, ra)) {
521 new_node = kzalloc(sizeof(struct mwifiex_tx_ba_stream_tbl),
522 GFP_ATOMIC);
523 if (!new_node)
524 return;
525
526 INIT_LIST_HEAD(&new_node->list);
527
528 new_node->tid = tid;
529 new_node->ba_status = ba_status;
530 memcpy(new_node->ra, ra, ETH_ALEN);
531
532 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
533 list_add_tail(&new_node->list, &priv->tx_ba_stream_tbl_ptr);
534 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
535 }
536 }
537
538 /*
539 * This function sends an add BA request to the given TID/RA pair.
540 */
mwifiex_send_addba(struct mwifiex_private * priv,int tid,u8 * peer_mac)541 int mwifiex_send_addba(struct mwifiex_private *priv, int tid, u8 *peer_mac)
542 {
543 struct host_cmd_ds_11n_addba_req add_ba_req;
544 u32 tx_win_size = priv->add_ba_param.tx_win_size;
545 static u8 dialog_tok;
546 int ret;
547 u16 block_ack_param_set;
548
549 dev_dbg(priv->adapter->dev, "cmd: %s: tid %d\n", __func__, tid);
550
551 if ((GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_STA) &&
552 ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
553 priv->adapter->is_hw_11ac_capable &&
554 memcmp(priv->cfg_bssid, peer_mac, ETH_ALEN)) {
555 struct mwifiex_sta_node *sta_ptr;
556
557 sta_ptr = mwifiex_get_sta_entry(priv, peer_mac);
558 if (!sta_ptr) {
559 dev_warn(priv->adapter->dev,
560 "BA setup with unknown TDLS peer %pM!\n",
561 peer_mac);
562 return -1;
563 }
564 if (sta_ptr->is_11ac_enabled)
565 tx_win_size = MWIFIEX_11AC_STA_AMPDU_DEF_TXWINSIZE;
566 }
567
568 block_ack_param_set = (u16)((tid << BLOCKACKPARAM_TID_POS) |
569 tx_win_size << BLOCKACKPARAM_WINSIZE_POS |
570 IMMEDIATE_BLOCK_ACK);
571
572 /* enable AMSDU inside AMPDU */
573 if (priv->add_ba_param.tx_amsdu &&
574 (priv->aggr_prio_tbl[tid].amsdu != BA_STREAM_NOT_ALLOWED))
575 block_ack_param_set |= BLOCKACKPARAM_AMSDU_SUPP_MASK;
576
577 add_ba_req.block_ack_param_set = cpu_to_le16(block_ack_param_set);
578 add_ba_req.block_ack_tmo = cpu_to_le16((u16)priv->add_ba_param.timeout);
579
580 ++dialog_tok;
581
582 if (dialog_tok == 0)
583 dialog_tok = 1;
584
585 add_ba_req.dialog_token = dialog_tok;
586 memcpy(&add_ba_req.peer_mac_addr, peer_mac, ETH_ALEN);
587
588 /* We don't wait for the response of this command */
589 ret = mwifiex_send_cmd(priv, HostCmd_CMD_11N_ADDBA_REQ,
590 0, 0, &add_ba_req, false);
591
592 return ret;
593 }
594
595 /*
596 * This function sends a delete BA request to the given TID/RA pair.
597 */
mwifiex_send_delba(struct mwifiex_private * priv,int tid,u8 * peer_mac,int initiator)598 int mwifiex_send_delba(struct mwifiex_private *priv, int tid, u8 *peer_mac,
599 int initiator)
600 {
601 struct host_cmd_ds_11n_delba delba;
602 int ret;
603 uint16_t del_ba_param_set;
604
605 memset(&delba, 0, sizeof(delba));
606 delba.del_ba_param_set = cpu_to_le16(tid << DELBA_TID_POS);
607
608 del_ba_param_set = le16_to_cpu(delba.del_ba_param_set);
609 if (initiator)
610 del_ba_param_set |= IEEE80211_DELBA_PARAM_INITIATOR_MASK;
611 else
612 del_ba_param_set &= ~IEEE80211_DELBA_PARAM_INITIATOR_MASK;
613
614 memcpy(&delba.peer_mac_addr, peer_mac, ETH_ALEN);
615
616 /* We don't wait for the response of this command */
617 ret = mwifiex_send_cmd(priv, HostCmd_CMD_11N_DELBA,
618 HostCmd_ACT_GEN_SET, 0, &delba, false);
619
620 return ret;
621 }
622
623 /*
624 * This function handles the command response of a delete BA request.
625 */
mwifiex_11n_delete_ba_stream(struct mwifiex_private * priv,u8 * del_ba)626 void mwifiex_11n_delete_ba_stream(struct mwifiex_private *priv, u8 *del_ba)
627 {
628 struct host_cmd_ds_11n_delba *cmd_del_ba =
629 (struct host_cmd_ds_11n_delba *) del_ba;
630 uint16_t del_ba_param_set = le16_to_cpu(cmd_del_ba->del_ba_param_set);
631 int tid;
632
633 tid = del_ba_param_set >> DELBA_TID_POS;
634
635 mwifiex_del_ba_tbl(priv, tid, cmd_del_ba->peer_mac_addr,
636 TYPE_DELBA_RECEIVE, INITIATOR_BIT(del_ba_param_set));
637 }
638
639 /*
640 * This function retrieves the Rx reordering table.
641 */
mwifiex_get_rx_reorder_tbl(struct mwifiex_private * priv,struct mwifiex_ds_rx_reorder_tbl * buf)642 int mwifiex_get_rx_reorder_tbl(struct mwifiex_private *priv,
643 struct mwifiex_ds_rx_reorder_tbl *buf)
644 {
645 int i;
646 struct mwifiex_ds_rx_reorder_tbl *rx_reo_tbl = buf;
647 struct mwifiex_rx_reorder_tbl *rx_reorder_tbl_ptr;
648 int count = 0;
649 unsigned long flags;
650
651 spin_lock_irqsave(&priv->rx_reorder_tbl_lock, flags);
652 list_for_each_entry(rx_reorder_tbl_ptr, &priv->rx_reorder_tbl_ptr,
653 list) {
654 rx_reo_tbl->tid = (u16) rx_reorder_tbl_ptr->tid;
655 memcpy(rx_reo_tbl->ta, rx_reorder_tbl_ptr->ta, ETH_ALEN);
656 rx_reo_tbl->start_win = rx_reorder_tbl_ptr->start_win;
657 rx_reo_tbl->win_size = rx_reorder_tbl_ptr->win_size;
658 for (i = 0; i < rx_reorder_tbl_ptr->win_size; ++i) {
659 if (rx_reorder_tbl_ptr->rx_reorder_ptr[i])
660 rx_reo_tbl->buffer[i] = true;
661 else
662 rx_reo_tbl->buffer[i] = false;
663 }
664 rx_reo_tbl++;
665 count++;
666
667 if (count >= MWIFIEX_MAX_RX_BASTREAM_SUPPORTED)
668 break;
669 }
670 spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
671
672 return count;
673 }
674
675 /*
676 * This function retrieves the Tx BA stream table.
677 */
mwifiex_get_tx_ba_stream_tbl(struct mwifiex_private * priv,struct mwifiex_ds_tx_ba_stream_tbl * buf)678 int mwifiex_get_tx_ba_stream_tbl(struct mwifiex_private *priv,
679 struct mwifiex_ds_tx_ba_stream_tbl *buf)
680 {
681 struct mwifiex_tx_ba_stream_tbl *tx_ba_tsr_tbl;
682 struct mwifiex_ds_tx_ba_stream_tbl *rx_reo_tbl = buf;
683 int count = 0;
684 unsigned long flags;
685
686 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
687 list_for_each_entry(tx_ba_tsr_tbl, &priv->tx_ba_stream_tbl_ptr, list) {
688 rx_reo_tbl->tid = (u16) tx_ba_tsr_tbl->tid;
689 dev_dbg(priv->adapter->dev, "data: %s tid=%d\n",
690 __func__, rx_reo_tbl->tid);
691 memcpy(rx_reo_tbl->ra, tx_ba_tsr_tbl->ra, ETH_ALEN);
692 rx_reo_tbl->amsdu = tx_ba_tsr_tbl->amsdu;
693 rx_reo_tbl++;
694 count++;
695 if (count >= MWIFIEX_MAX_TX_BASTREAM_SUPPORTED)
696 break;
697 }
698 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
699
700 return count;
701 }
702
703 /*
704 * This function retrieves the entry for specific tx BA stream table by RA and
705 * deletes it.
706 */
mwifiex_del_tx_ba_stream_tbl_by_ra(struct mwifiex_private * priv,u8 * ra)707 void mwifiex_del_tx_ba_stream_tbl_by_ra(struct mwifiex_private *priv, u8 *ra)
708 {
709 struct mwifiex_tx_ba_stream_tbl *tbl, *tmp;
710 unsigned long flags;
711
712 if (!ra)
713 return;
714
715 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
716 list_for_each_entry_safe(tbl, tmp, &priv->tx_ba_stream_tbl_ptr, list) {
717 if (!memcmp(tbl->ra, ra, ETH_ALEN)) {
718 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock,
719 flags);
720 mwifiex_11n_delete_tx_ba_stream_tbl_entry(priv, tbl);
721 spin_lock_irqsave(&priv->tx_ba_stream_tbl_lock, flags);
722 }
723 }
724 spin_unlock_irqrestore(&priv->tx_ba_stream_tbl_lock, flags);
725
726 return;
727 }
728
729 /* This function initializes the BlockACK setup information for given
730 * mwifiex_private structure.
731 */
mwifiex_set_ba_params(struct mwifiex_private * priv)732 void mwifiex_set_ba_params(struct mwifiex_private *priv)
733 {
734 priv->add_ba_param.timeout = MWIFIEX_DEFAULT_BLOCK_ACK_TIMEOUT;
735
736 if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
737 priv->add_ba_param.tx_win_size =
738 MWIFIEX_UAP_AMPDU_DEF_TXWINSIZE;
739 priv->add_ba_param.rx_win_size =
740 MWIFIEX_UAP_AMPDU_DEF_RXWINSIZE;
741 } else {
742 priv->add_ba_param.tx_win_size =
743 MWIFIEX_STA_AMPDU_DEF_TXWINSIZE;
744 priv->add_ba_param.rx_win_size =
745 MWIFIEX_STA_AMPDU_DEF_RXWINSIZE;
746 }
747
748 priv->add_ba_param.tx_amsdu = true;
749 priv->add_ba_param.rx_amsdu = true;
750
751 return;
752 }
753
mwifiex_get_sec_chan_offset(int chan)754 u8 mwifiex_get_sec_chan_offset(int chan)
755 {
756 u8 sec_offset;
757
758 switch (chan) {
759 case 36:
760 case 44:
761 case 52:
762 case 60:
763 case 100:
764 case 108:
765 case 116:
766 case 124:
767 case 132:
768 case 140:
769 case 149:
770 case 157:
771 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
772 break;
773 case 40:
774 case 48:
775 case 56:
776 case 64:
777 case 104:
778 case 112:
779 case 120:
780 case 128:
781 case 136:
782 case 144:
783 case 153:
784 case 161:
785 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
786 break;
787 case 165:
788 default:
789 sec_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
790 break;
791 }
792
793 return sec_offset;
794 }
795