Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
wmm.c
Go to the documentation of this file.
1 /*
2  * Marvell Wireless LAN device driver: WMM
3  *
4  * Copyright (C) 2011, 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 /* Maximum value FW can accept for driver delay in packet transmission */
30 #define DRV_PKT_DELAY_TO_FW_MAX 512
31 
32 
33 #define WMM_QUEUED_PACKET_LOWER_LIMIT 180
34 
35 #define WMM_QUEUED_PACKET_UPPER_LIMIT 200
36 
37 /* Offset for TOS field in the IP header */
38 #define IPTOS_OFFSET 5
39 
40 /* WMM information IE */
41 static const u8 wmm_info_ie[] = { WLAN_EID_VENDOR_SPECIFIC, 0x07,
42  0x00, 0x50, 0xf2, 0x02,
43  0x00, 0x01, 0x00
44 };
45 
46 static const u8 wmm_aci_to_qidx_map[] = { WMM_AC_BE,
47  WMM_AC_BK,
48  WMM_AC_VI,
49  WMM_AC_VO
50 };
51 
52 static u8 tos_to_tid[] = {
53  /* TID DSCP_P2 DSCP_P1 DSCP_P0 WMM_AC */
54  0x01, /* 0 1 0 AC_BK */
55  0x02, /* 0 0 0 AC_BK */
56  0x00, /* 0 0 1 AC_BE */
57  0x03, /* 0 1 1 AC_BE */
58  0x04, /* 1 0 0 AC_VI */
59  0x05, /* 1 0 1 AC_VI */
60  0x06, /* 1 1 0 AC_VO */
61  0x07 /* 1 1 1 AC_VO */
62 };
63 
64 /*
65  * This table inverses the tos_to_tid operation to get a priority
66  * which is in sequential order, and can be compared.
67  * Use this to compare the priority of two different TIDs.
68  */
69 static u8 tos_to_tid_inv[] = {
70  0x02, /* from tos_to_tid[2] = 0 */
71  0x00, /* from tos_to_tid[0] = 1 */
72  0x01, /* from tos_to_tid[1] = 2 */
73  0x03,
74  0x04,
75  0x05,
76  0x06,
77  0x07};
78 
79 static u8 ac_to_tid[4][2] = { {1, 2}, {0, 3}, {4, 5}, {6, 7} };
80 
81 /*
82  * This function debug prints the priority parameters for a WMM AC.
83  */
84 static void
85 mwifiex_wmm_ac_debug_print(const struct ieee_types_wmm_ac_parameters *ac_param)
86 {
87  const char *ac_str[] = { "BK", "BE", "VI", "VO" };
88 
89  pr_debug("info: WMM AC_%s: ACI=%d, ACM=%d, Aifsn=%d, "
90  "EcwMin=%d, EcwMax=%d, TxopLimit=%d\n",
91  ac_str[wmm_aci_to_qidx_map[(ac_param->aci_aifsn_bitmap
92  & MWIFIEX_ACI) >> 5]],
93  (ac_param->aci_aifsn_bitmap & MWIFIEX_ACI) >> 5,
94  (ac_param->aci_aifsn_bitmap & MWIFIEX_ACM) >> 4,
95  ac_param->aci_aifsn_bitmap & MWIFIEX_AIFSN,
96  ac_param->ecw_bitmap & MWIFIEX_ECW_MIN,
97  (ac_param->ecw_bitmap & MWIFIEX_ECW_MAX) >> 4,
98  le16_to_cpu(ac_param->tx_op_limit));
99 }
100 
101 /*
102  * This function allocates a route address list.
103  *
104  * The function also initializes the list with the provided RA.
105  */
106 static struct mwifiex_ra_list_tbl *
107 mwifiex_wmm_allocate_ralist_node(struct mwifiex_adapter *adapter, u8 *ra)
108 {
109  struct mwifiex_ra_list_tbl *ra_list;
110 
111  ra_list = kzalloc(sizeof(struct mwifiex_ra_list_tbl), GFP_ATOMIC);
112 
113  if (!ra_list) {
114  dev_err(adapter->dev, "%s: failed to alloc ra_list\n",
115  __func__);
116  return NULL;
117  }
118  INIT_LIST_HEAD(&ra_list->list);
119  skb_queue_head_init(&ra_list->skb_head);
120 
121  memcpy(ra_list->ra, ra, ETH_ALEN);
122 
123  ra_list->total_pkts_size = 0;
124 
125  dev_dbg(adapter->dev, "info: allocated ra_list %p\n", ra_list);
126 
127  return ra_list;
128 }
129 
130 /* This function returns random no between 16 and 32 to be used as threshold
131  * for no of packets after which BA setup is initiated.
132  */
133 static u8 mwifiex_get_random_ba_threshold(void)
134 {
135  u32 sec, usec;
136  struct timeval ba_tstamp;
137  u8 ba_threshold;
138 
139  /* setup ba_packet_threshold here random number between
140  * [BA_SETUP_PACKET_OFFSET,
141  * BA_SETUP_PACKET_OFFSET+BA_SETUP_MAX_PACKET_THRESHOLD-1]
142  */
143 
144  do_gettimeofday(&ba_tstamp);
145  sec = (ba_tstamp.tv_sec & 0xFFFF) + (ba_tstamp.tv_sec >> 16);
146  usec = (ba_tstamp.tv_usec & 0xFFFF) + (ba_tstamp.tv_usec >> 16);
147  ba_threshold = (((sec << 16) + usec) % BA_SETUP_MAX_PACKET_THRESHOLD)
149 
150  return ba_threshold;
151 }
152 
153 /*
154  * This function allocates and adds a RA list for all TIDs
155  * with the given RA.
156  */
157 void
159 {
160  int i;
161  struct mwifiex_ra_list_tbl *ra_list;
162  struct mwifiex_adapter *adapter = priv->adapter;
163  struct mwifiex_sta_node *node;
164  unsigned long flags;
165 
166  spin_lock_irqsave(&priv->sta_list_spinlock, flags);
167  node = mwifiex_get_sta_entry(priv, ra);
168  spin_unlock_irqrestore(&priv->sta_list_spinlock, flags);
169 
170  for (i = 0; i < MAX_NUM_TID; ++i) {
171  ra_list = mwifiex_wmm_allocate_ralist_node(adapter, ra);
172  dev_dbg(adapter->dev, "info: created ra_list %p\n", ra_list);
173 
174  if (!ra_list)
175  break;
176 
177  ra_list->is_11n_enabled = 0;
178  if (!mwifiex_queuing_ra_based(priv)) {
179  ra_list->is_11n_enabled = IS_11N_ENABLED(priv);
180  } else {
181  ra_list->is_11n_enabled =
182  mwifiex_is_sta_11n_enabled(priv, node);
183  if (ra_list->is_11n_enabled)
184  ra_list->max_amsdu = node->max_amsdu;
185  }
186 
187  dev_dbg(adapter->dev, "data: ralist %p: is_11n_enabled=%d\n",
188  ra_list, ra_list->is_11n_enabled);
189 
190  if (ra_list->is_11n_enabled) {
191  ra_list->pkt_count = 0;
192  ra_list->ba_packet_thr =
193  mwifiex_get_random_ba_threshold();
194  }
195  list_add_tail(&ra_list->list,
196  &priv->wmm.tid_tbl_ptr[i].ra_list);
197 
198  if (!priv->wmm.tid_tbl_ptr[i].ra_list_curr)
199  priv->wmm.tid_tbl_ptr[i].ra_list_curr = ra_list;
200  }
201 }
202 
203 /*
204  * This function sets the WMM queue priorities to their default values.
205  */
206 static void mwifiex_wmm_default_queue_priorities(struct mwifiex_private *priv)
207 {
208  /* Default queue priorities: VO->VI->BE->BK */
209  priv->wmm.queue_priority[0] = WMM_AC_VO;
210  priv->wmm.queue_priority[1] = WMM_AC_VI;
211  priv->wmm.queue_priority[2] = WMM_AC_BE;
212  priv->wmm.queue_priority[3] = WMM_AC_BK;
213 }
214 
215 /*
216  * This function map ACs to TIDs.
217  */
218 static void
219 mwifiex_wmm_queue_priorities_tid(struct mwifiex_wmm_desc *wmm)
220 {
221  u8 *queue_priority = wmm->queue_priority;
222  int i;
223 
224  for (i = 0; i < 4; ++i) {
225  tos_to_tid[7 - (i * 2)] = ac_to_tid[queue_priority[i]][1];
226  tos_to_tid[6 - (i * 2)] = ac_to_tid[queue_priority[i]][0];
227  }
228 
229  for (i = 0; i < MAX_NUM_TID; ++i)
230  tos_to_tid_inv[tos_to_tid[i]] = (u8)i;
231 
233 }
234 
235 /*
236  * This function initializes WMM priority queues.
237  */
238 void
240  struct ieee_types_wmm_parameter *wmm_ie)
241 {
242  u16 cw_min, avg_back_off, tmp[4];
243  u32 i, j, num_ac;
244  u8 ac_idx;
245 
246  if (!wmm_ie || !priv->wmm_enabled) {
247  /* WMM is not enabled, just set the defaults and return */
248  mwifiex_wmm_default_queue_priorities(priv);
249  return;
250  }
251 
252  dev_dbg(priv->adapter->dev, "info: WMM Parameter IE: version=%d, "
253  "qos_info Parameter Set Count=%d, Reserved=%#x\n",
254  wmm_ie->vend_hdr.version, wmm_ie->qos_info_bitmap &
256  wmm_ie->reserved);
257 
258  for (num_ac = 0; num_ac < ARRAY_SIZE(wmm_ie->ac_params); num_ac++) {
259  u8 ecw = wmm_ie->ac_params[num_ac].ecw_bitmap;
260  u8 aci_aifsn = wmm_ie->ac_params[num_ac].aci_aifsn_bitmap;
261  cw_min = (1 << (ecw & MWIFIEX_ECW_MIN)) - 1;
262  avg_back_off = (cw_min >> 1) + (aci_aifsn & MWIFIEX_AIFSN);
263 
264  ac_idx = wmm_aci_to_qidx_map[(aci_aifsn & MWIFIEX_ACI) >> 5];
265  priv->wmm.queue_priority[ac_idx] = ac_idx;
266  tmp[ac_idx] = avg_back_off;
267 
268  dev_dbg(priv->adapter->dev,
269  "info: WMM: CWmax=%d CWmin=%d Avg Back-off=%d\n",
270  (1 << ((ecw & MWIFIEX_ECW_MAX) >> 4)) - 1,
271  cw_min, avg_back_off);
272  mwifiex_wmm_ac_debug_print(&wmm_ie->ac_params[num_ac]);
273  }
274 
275  /* Bubble sort */
276  for (i = 0; i < num_ac; i++) {
277  for (j = 1; j < num_ac - i; j++) {
278  if (tmp[j - 1] > tmp[j]) {
279  swap(tmp[j - 1], tmp[j]);
280  swap(priv->wmm.queue_priority[j - 1],
281  priv->wmm.queue_priority[j]);
282  } else if (tmp[j - 1] == tmp[j]) {
283  if (priv->wmm.queue_priority[j - 1]
284  < priv->wmm.queue_priority[j])
285  swap(priv->wmm.queue_priority[j - 1],
286  priv->wmm.queue_priority[j]);
287  }
288  }
289  }
290 
291  mwifiex_wmm_queue_priorities_tid(&priv->wmm);
292 }
293 
294 /*
295  * This function evaluates whether or not an AC is to be downgraded.
296  *
297  * In case the AC is not enabled, the highest AC is returned that is
298  * enabled and does not require admission control.
299  */
300 static enum mwifiex_wmm_ac_e
301 mwifiex_wmm_eval_downgrade_ac(struct mwifiex_private *priv,
302  enum mwifiex_wmm_ac_e eval_ac)
303 {
304  int down_ac;
305  enum mwifiex_wmm_ac_e ret_ac;
306  struct mwifiex_wmm_ac_status *ac_status;
307 
308  ac_status = &priv->wmm.ac_status[eval_ac];
309 
310  if (!ac_status->disabled)
311  /* Okay to use this AC, its enabled */
312  return eval_ac;
313 
314  /* Setup a default return value of the lowest priority */
315  ret_ac = WMM_AC_BK;
316 
317  /*
318  * Find the highest AC that is enabled and does not require
319  * admission control. The spec disallows downgrading to an AC,
320  * which is enabled due to a completed admission control.
321  * Unadmitted traffic is not to be sent on an AC with admitted
322  * traffic.
323  */
324  for (down_ac = WMM_AC_BK; down_ac < eval_ac; down_ac++) {
325  ac_status = &priv->wmm.ac_status[down_ac];
326 
327  if (!ac_status->disabled && !ac_status->flow_required)
328  /* AC is enabled and does not require admission
329  control */
330  ret_ac = (enum mwifiex_wmm_ac_e) down_ac;
331  }
332 
333  return ret_ac;
334 }
335 
336 /*
337  * This function downgrades WMM priority queue.
338  */
339 void
341 {
342  int ac_val;
343 
344  dev_dbg(priv->adapter->dev, "info: WMM: AC Priorities:"
345  "BK(0), BE(1), VI(2), VO(3)\n");
346 
347  if (!priv->wmm_enabled) {
348  /* WMM is not enabled, default priorities */
349  for (ac_val = WMM_AC_BK; ac_val <= WMM_AC_VO; ac_val++)
350  priv->wmm.ac_down_graded_vals[ac_val] =
351  (enum mwifiex_wmm_ac_e) ac_val;
352  } else {
353  for (ac_val = WMM_AC_BK; ac_val <= WMM_AC_VO; ac_val++) {
354  priv->wmm.ac_down_graded_vals[ac_val]
355  = mwifiex_wmm_eval_downgrade_ac(priv,
356  (enum mwifiex_wmm_ac_e) ac_val);
357  dev_dbg(priv->adapter->dev,
358  "info: WMM: AC PRIO %d maps to %d\n",
359  ac_val, priv->wmm.ac_down_graded_vals[ac_val]);
360  }
361  }
362 }
363 
364 /*
365  * This function converts the IP TOS field to an WMM AC
366  * Queue assignment.
367  */
368 static enum mwifiex_wmm_ac_e
369 mwifiex_wmm_convert_tos_to_ac(struct mwifiex_adapter *adapter, u32 tos)
370 {
371  /* Map of TOS UP values to WMM AC */
372  const enum mwifiex_wmm_ac_e tos_to_ac[] = { WMM_AC_BE,
373  WMM_AC_BK,
374  WMM_AC_BK,
375  WMM_AC_BE,
376  WMM_AC_VI,
377  WMM_AC_VI,
378  WMM_AC_VO,
379  WMM_AC_VO
380  };
381 
382  if (tos >= ARRAY_SIZE(tos_to_ac))
383  return WMM_AC_BE;
384 
385  return tos_to_ac[tos];
386 }
387 
388 /*
389  * This function evaluates a given TID and downgrades it to a lower
390  * TID if the WMM Parameter IE received from the AP indicates that the
391  * AP is disabled (due to call admission control (ACM bit). Mapping
392  * of TID to AC is taken care of internally.
393  */
394 static u8
395 mwifiex_wmm_downgrade_tid(struct mwifiex_private *priv, u32 tid)
396 {
397  enum mwifiex_wmm_ac_e ac, ac_down;
398  u8 new_tid;
399 
400  ac = mwifiex_wmm_convert_tos_to_ac(priv->adapter, tid);
401  ac_down = priv->wmm.ac_down_graded_vals[ac];
402 
403  /* Send the index to tid array, picking from the array will be
404  * taken care by dequeuing function
405  */
406  new_tid = ac_to_tid[ac_down][tid % 2];
407 
408  return new_tid;
409 }
410 
411 /*
412  * This function initializes the WMM state information and the
413  * WMM data path queues.
414  */
415 void
417 {
418  int i, j;
419  struct mwifiex_private *priv;
420 
421  for (j = 0; j < adapter->priv_num; ++j) {
422  priv = adapter->priv[j];
423  if (!priv)
424  continue;
425 
426  for (i = 0; i < MAX_NUM_TID; ++i) {
427  priv->aggr_prio_tbl[i].amsdu = tos_to_tid_inv[i];
428  priv->aggr_prio_tbl[i].ampdu_ap = tos_to_tid_inv[i];
429  priv->aggr_prio_tbl[i].ampdu_user = tos_to_tid_inv[i];
430  priv->wmm.tid_tbl_ptr[i].ra_list_curr = NULL;
431  }
432 
433  priv->aggr_prio_tbl[6].amsdu
434  = priv->aggr_prio_tbl[6].ampdu_ap
435  = priv->aggr_prio_tbl[6].ampdu_user
437 
438  priv->aggr_prio_tbl[7].amsdu = priv->aggr_prio_tbl[7].ampdu_ap
439  = priv->aggr_prio_tbl[7].ampdu_user
441 
443  priv->add_ba_param.tx_win_size = MWIFIEX_AMPDU_DEF_TXWINSIZE;
444  priv->add_ba_param.rx_win_size = MWIFIEX_AMPDU_DEF_RXWINSIZE;
445 
446  mwifiex_reset_11n_rx_seq_num(priv);
447 
448  atomic_set(&priv->wmm.tx_pkts_queued, 0);
449  atomic_set(&priv->wmm.highest_queued_prio, HIGH_PRIO_TID);
450  }
451 }
452 
453 /*
454  * This function checks if WMM Tx queue is empty.
455  */
456 int
458 {
459  int i;
460  struct mwifiex_private *priv;
461 
462  for (i = 0; i < adapter->priv_num; ++i) {
463  priv = adapter->priv[i];
464  if (priv && atomic_read(&priv->wmm.tx_pkts_queued))
465  return false;
466  }
467 
468  return true;
469 }
470 
471 /*
472  * This function deletes all packets in an RA list node.
473  *
474  * The packet sent completion callback handler are called with
475  * status failure, after they are dequeued to ensure proper
476  * cleanup. The RA list node itself is freed at the end.
477  */
478 static void
479 mwifiex_wmm_del_pkts_in_ralist_node(struct mwifiex_private *priv,
480  struct mwifiex_ra_list_tbl *ra_list)
481 {
482  struct mwifiex_adapter *adapter = priv->adapter;
483  struct sk_buff *skb, *tmp;
484 
485  skb_queue_walk_safe(&ra_list->skb_head, skb, tmp)
486  mwifiex_write_data_complete(adapter, skb, -1);
487 }
488 
489 /*
490  * This function deletes all packets in an RA list.
491  *
492  * Each nodes in the RA list are freed individually first, and then
493  * the RA list itself is freed.
494  */
495 static void
496 mwifiex_wmm_del_pkts_in_ralist(struct mwifiex_private *priv,
497  struct list_head *ra_list_head)
498 {
499  struct mwifiex_ra_list_tbl *ra_list;
500 
501  list_for_each_entry(ra_list, ra_list_head, list)
502  mwifiex_wmm_del_pkts_in_ralist_node(priv, ra_list);
503 }
504 
505 /*
506  * This function deletes all packets in all RA lists.
507  */
508 static void mwifiex_wmm_cleanup_queues(struct mwifiex_private *priv)
509 {
510  int i;
511 
512  for (i = 0; i < MAX_NUM_TID; i++)
513  mwifiex_wmm_del_pkts_in_ralist(priv, &priv->wmm.tid_tbl_ptr[i].
514  ra_list);
515 
516  atomic_set(&priv->wmm.tx_pkts_queued, 0);
517  atomic_set(&priv->wmm.highest_queued_prio, HIGH_PRIO_TID);
518 }
519 
520 /*
521  * This function deletes all route addresses from all RA lists.
522  */
523 static void mwifiex_wmm_delete_all_ralist(struct mwifiex_private *priv)
524 {
525  struct mwifiex_ra_list_tbl *ra_list, *tmp_node;
526  int i;
527 
528  for (i = 0; i < MAX_NUM_TID; ++i) {
529  dev_dbg(priv->adapter->dev,
530  "info: ra_list: freeing buf for tid %d\n", i);
531  list_for_each_entry_safe(ra_list, tmp_node,
532  &priv->wmm.tid_tbl_ptr[i].ra_list,
533  list) {
534  list_del(&ra_list->list);
535  kfree(ra_list);
536  }
537 
538  INIT_LIST_HEAD(&priv->wmm.tid_tbl_ptr[i].ra_list);
539 
540  priv->wmm.tid_tbl_ptr[i].ra_list_curr = NULL;
541  }
542 }
543 
544 /*
545  * This function cleans up the Tx and Rx queues.
546  *
547  * Cleanup includes -
548  * - All packets in RA lists
549  * - All entries in Rx reorder table
550  * - All entries in Tx BA stream table
551  * - MPA buffer (if required)
552  * - All RA lists
553  */
554 void
556 {
557  unsigned long flags;
558 
560  spin_lock_irqsave(&priv->wmm.ra_list_spinlock, flags);
561 
562  mwifiex_wmm_cleanup_queues(priv);
564 
565  if (priv->adapter->if_ops.cleanup_mpa_buf)
566  priv->adapter->if_ops.cleanup_mpa_buf(priv->adapter);
567 
568  mwifiex_wmm_delete_all_ralist(priv);
569  memcpy(tos_to_tid, ac_to_tid, sizeof(tos_to_tid));
570 
571  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock, flags);
572 }
573 
574 /*
575  * This function retrieves a particular RA list node, matching with the
576  * given TID and RA address.
577  */
578 static struct mwifiex_ra_list_tbl *
579 mwifiex_wmm_get_ralist_node(struct mwifiex_private *priv, u8 tid,
580  u8 *ra_addr)
581 {
582  struct mwifiex_ra_list_tbl *ra_list;
583 
584  list_for_each_entry(ra_list, &priv->wmm.tid_tbl_ptr[tid].ra_list,
585  list) {
586  if (!memcmp(ra_list->ra, ra_addr, ETH_ALEN))
587  return ra_list;
588  }
589 
590  return NULL;
591 }
592 
593 /*
594  * This function retrieves an RA list node for a given TID and
595  * RA address pair.
596  *
597  * If no such node is found, a new node is added first and then
598  * retrieved.
599  */
600 static struct mwifiex_ra_list_tbl *
601 mwifiex_wmm_get_queue_raptr(struct mwifiex_private *priv, u8 tid, u8 *ra_addr)
602 {
603  struct mwifiex_ra_list_tbl *ra_list;
604 
605  ra_list = mwifiex_wmm_get_ralist_node(priv, tid, ra_addr);
606  if (ra_list)
607  return ra_list;
608  mwifiex_ralist_add(priv, ra_addr);
609 
610  return mwifiex_wmm_get_ralist_node(priv, tid, ra_addr);
611 }
612 
613 /*
614  * This function checks if a particular RA list node exists in a given TID
615  * table index.
616  */
617 int
619  struct mwifiex_ra_list_tbl *ra_list, int ptr_index)
620 {
621  struct mwifiex_ra_list_tbl *rlist;
622 
623  list_for_each_entry(rlist, &priv->wmm.tid_tbl_ptr[ptr_index].ra_list,
624  list) {
625  if (rlist == ra_list)
626  return true;
627  }
628 
629  return false;
630 }
631 
632 /*
633  * This function adds a packet to WMM queue.
634  *
635  * In disconnected state the packet is immediately dropped and the
636  * packet send completion callback is called with status failure.
637  *
638  * Otherwise, the correct RA list node is located and the packet
639  * is queued at the list tail.
640  */
641 void
643  struct sk_buff *skb)
644 {
645  struct mwifiex_adapter *adapter = priv->adapter;
646  u32 tid;
647  struct mwifiex_ra_list_tbl *ra_list;
648  u8 ra[ETH_ALEN], tid_down;
649  unsigned long flags;
650 
651  if (!priv->media_connected && !mwifiex_is_skb_mgmt_frame(skb)) {
652  dev_dbg(adapter->dev, "data: drop packet in disconnect\n");
653  mwifiex_write_data_complete(adapter, skb, -1);
654  return;
655  }
656 
657  tid = skb->priority;
658 
659  spin_lock_irqsave(&priv->wmm.ra_list_spinlock, flags);
660 
661  tid_down = mwifiex_wmm_downgrade_tid(priv, tid);
662 
663  /* In case of infra as we have already created the list during
664  association we just don't have to call get_queue_raptr, we will
665  have only 1 raptr for a tid in case of infra */
666  if (!mwifiex_queuing_ra_based(priv) &&
667  !mwifiex_is_skb_mgmt_frame(skb)) {
668  if (!list_empty(&priv->wmm.tid_tbl_ptr[tid_down].ra_list))
669  ra_list = list_first_entry(
670  &priv->wmm.tid_tbl_ptr[tid_down].ra_list,
671  struct mwifiex_ra_list_tbl, list);
672  else
673  ra_list = NULL;
674  } else {
675  memcpy(ra, skb->data, ETH_ALEN);
676  if (ra[0] & 0x01 || mwifiex_is_skb_mgmt_frame(skb))
677  memset(ra, 0xff, ETH_ALEN);
678  ra_list = mwifiex_wmm_get_queue_raptr(priv, tid_down, ra);
679  }
680 
681  if (!ra_list) {
682  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock, flags);
683  mwifiex_write_data_complete(adapter, skb, -1);
684  return;
685  }
686 
687  skb_queue_tail(&ra_list->skb_head, skb);
688 
689  ra_list->total_pkts_size += skb->len;
690  ra_list->pkt_count++;
691 
692  atomic_inc(&priv->wmm.tx_pkts_queued);
693 
694  if (atomic_read(&priv->wmm.highest_queued_prio) <
695  tos_to_tid_inv[tid_down])
696  atomic_set(&priv->wmm.highest_queued_prio,
697  tos_to_tid_inv[tid_down]);
698 
699  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock, flags);
700 }
701 
702 /*
703  * This function processes the get WMM status command response from firmware.
704  *
705  * The response may contain multiple TLVs -
706  * - AC Queue status TLVs
707  * - Current WMM Parameter IE TLV
708  * - Admission Control action frame TLVs
709  *
710  * This function parses the TLVs and then calls further specific functions
711  * to process any changes in the queue prioritize or state.
712  */
714  const struct host_cmd_ds_command *resp)
715 {
716  u8 *curr = (u8 *) &resp->params.get_wmm_status;
718  int valid = true;
719 
720  struct mwifiex_ie_types_data *tlv_hdr;
721  struct mwifiex_ie_types_wmm_queue_status *tlv_wmm_qstatus;
722  struct ieee_types_wmm_parameter *wmm_param_ie = NULL;
723  struct mwifiex_wmm_ac_status *ac_status;
724 
725  dev_dbg(priv->adapter->dev, "info: WMM: WMM_GET_STATUS cmdresp received: %d\n",
726  resp_len);
727 
728  while ((resp_len >= sizeof(tlv_hdr->header)) && valid) {
729  tlv_hdr = (struct mwifiex_ie_types_data *) curr;
730  tlv_len = le16_to_cpu(tlv_hdr->header.len);
731 
732  switch (le16_to_cpu(tlv_hdr->header.type)) {
733  case TLV_TYPE_WMMQSTATUS:
734  tlv_wmm_qstatus =
736  tlv_hdr;
737  dev_dbg(priv->adapter->dev,
738  "info: CMD_RESP: WMM_GET_STATUS:"
739  " QSTATUS TLV: %d, %d, %d\n",
740  tlv_wmm_qstatus->queue_index,
741  tlv_wmm_qstatus->flow_required,
742  tlv_wmm_qstatus->disabled);
743 
744  ac_status = &priv->wmm.ac_status[tlv_wmm_qstatus->
745  queue_index];
746  ac_status->disabled = tlv_wmm_qstatus->disabled;
747  ac_status->flow_required =
748  tlv_wmm_qstatus->flow_required;
749  ac_status->flow_created = tlv_wmm_qstatus->flow_created;
750  break;
751 
753  /*
754  * Point the regular IEEE IE 2 bytes into the Marvell IE
755  * and setup the IEEE IE type and length byte fields
756  */
757 
758  wmm_param_ie =
759  (struct ieee_types_wmm_parameter *) (curr +
760  2);
761  wmm_param_ie->vend_hdr.len = (u8) tlv_len;
762  wmm_param_ie->vend_hdr.element_id =
764 
765  dev_dbg(priv->adapter->dev,
766  "info: CMD_RESP: WMM_GET_STATUS:"
767  " WMM Parameter Set Count: %d\n",
768  wmm_param_ie->qos_info_bitmap &
770 
771  memcpy((u8 *) &priv->curr_bss_params.bss_descriptor.
772  wmm_ie, wmm_param_ie,
773  wmm_param_ie->vend_hdr.len + 2);
774 
775  break;
776 
777  default:
778  valid = false;
779  break;
780  }
781 
782  curr += (tlv_len + sizeof(tlv_hdr->header));
783  resp_len -= (tlv_len + sizeof(tlv_hdr->header));
784  }
785 
786  mwifiex_wmm_setup_queue_priorities(priv, wmm_param_ie);
788 
789  return 0;
790 }
791 
792 /*
793  * Callback handler from the command module to allow insertion of a WMM TLV.
794  *
795  * If the BSS we are associating to supports WMM, this function adds the
796  * required WMM Information IE to the association request command buffer in
797  * the form of a Marvell extended IEEE IE.
798  */
799 u32
801  u8 **assoc_buf,
802  struct ieee_types_wmm_parameter *wmm_ie,
803  struct ieee80211_ht_cap *ht_cap)
804 {
805  struct mwifiex_ie_types_wmm_param_set *wmm_tlv;
806  u32 ret_len = 0;
807 
808  /* Null checks */
809  if (!assoc_buf)
810  return 0;
811  if (!(*assoc_buf))
812  return 0;
813 
814  if (!wmm_ie)
815  return 0;
816 
817  dev_dbg(priv->adapter->dev,
818  "info: WMM: process assoc req: bss->wmm_ie=%#x\n",
819  wmm_ie->vend_hdr.element_id);
820 
821  if ((priv->wmm_required ||
822  (ht_cap && (priv->adapter->config_bands & BAND_GN ||
823  priv->adapter->config_bands & BAND_AN))) &&
824  wmm_ie->vend_hdr.element_id == WLAN_EID_VENDOR_SPECIFIC) {
825  wmm_tlv = (struct mwifiex_ie_types_wmm_param_set *) *assoc_buf;
826  wmm_tlv->header.type = cpu_to_le16((u16) wmm_info_ie[0]);
827  wmm_tlv->header.len = cpu_to_le16((u16) wmm_info_ie[1]);
828  memcpy(wmm_tlv->wmm_ie, &wmm_info_ie[2],
829  le16_to_cpu(wmm_tlv->header.len));
831  memcpy((u8 *) (wmm_tlv->wmm_ie
832  + le16_to_cpu(wmm_tlv->header.len)
833  - sizeof(priv->wmm_qosinfo)),
834  &priv->wmm_qosinfo, sizeof(priv->wmm_qosinfo));
835 
836  ret_len = sizeof(wmm_tlv->header)
837  + le16_to_cpu(wmm_tlv->header.len);
838 
839  *assoc_buf += ret_len;
840  }
841 
842  return ret_len;
843 }
844 
845 /*
846  * This function computes the time delay in the driver queues for a
847  * given packet.
848  *
849  * When the packet is received at the OS/Driver interface, the current
850  * time is set in the packet structure. The difference between the present
851  * time and that received time is computed in this function and limited
852  * based on pre-compiled limits in the driver.
853  */
854 u8
856  const struct sk_buff *skb)
857 {
858  u8 ret_val;
859  struct timeval out_tstamp, in_tstamp;
860  u32 queue_delay;
861 
862  do_gettimeofday(&out_tstamp);
863  in_tstamp = ktime_to_timeval(skb->tstamp);
864 
865  queue_delay = (out_tstamp.tv_sec - in_tstamp.tv_sec) * 1000;
866  queue_delay += (out_tstamp.tv_usec - in_tstamp.tv_usec) / 1000;
867 
868  /*
869  * Queue delay is passed as a uint8 in units of 2ms (ms shifted
870  * by 1). Min value (other than 0) is therefore 2ms, max is 510ms.
871  *
872  * Pass max value if queue_delay is beyond the uint8 range
873  */
874  ret_val = (u8) (min(queue_delay, priv->wmm.drv_pkt_delay_max) >> 1);
875 
876  dev_dbg(priv->adapter->dev, "data: WMM: Pkt Delay: %d ms,"
877  " %d ms sent to FW\n", queue_delay, ret_val);
878 
879  return ret_val;
880 }
881 
882 /*
883  * This function retrieves the highest priority RA list table pointer.
884  */
885 static struct mwifiex_ra_list_tbl *
886 mwifiex_wmm_get_highest_priolist_ptr(struct mwifiex_adapter *adapter,
887  struct mwifiex_private **priv, int *tid)
888 {
889  struct mwifiex_private *priv_tmp;
890  struct mwifiex_ra_list_tbl *ptr, *head;
891  struct mwifiex_bss_prio_node *bssprio_node, *bssprio_head;
892  struct mwifiex_tid_tbl *tid_ptr;
893  atomic_t *hqp;
894  int is_list_empty;
895  unsigned long flags;
896  int i, j;
897 
898  for (j = adapter->priv_num - 1; j >= 0; --j) {
899  spin_lock_irqsave(&adapter->bss_prio_tbl[j].bss_prio_lock,
900  flags);
901  is_list_empty = list_empty(&adapter->bss_prio_tbl[j]
902  .bss_prio_head);
903  spin_unlock_irqrestore(&adapter->bss_prio_tbl[j].bss_prio_lock,
904  flags);
905  if (is_list_empty)
906  continue;
907 
908  if (adapter->bss_prio_tbl[j].bss_prio_cur ==
909  (struct mwifiex_bss_prio_node *)
910  &adapter->bss_prio_tbl[j].bss_prio_head) {
911  adapter->bss_prio_tbl[j].bss_prio_cur =
912  list_first_entry(&adapter->bss_prio_tbl[j]
913  .bss_prio_head,
914  struct mwifiex_bss_prio_node,
915  list);
916  }
917 
918  bssprio_node = adapter->bss_prio_tbl[j].bss_prio_cur;
919  bssprio_head = bssprio_node;
920 
921  do {
922  priv_tmp = bssprio_node->priv;
923  hqp = &priv_tmp->wmm.highest_queued_prio;
924 
925  for (i = atomic_read(hqp); i >= LOW_PRIO_TID; --i) {
926 
927  tid_ptr = &(priv_tmp)->wmm.
928  tid_tbl_ptr[tos_to_tid[i]];
929 
930  /* For non-STA ra_list_curr may be NULL */
931  if (!tid_ptr->ra_list_curr)
932  continue;
933 
935  flags);
936  is_list_empty =
937  list_empty(&adapter->bss_prio_tbl[j]
938  .bss_prio_head);
939  spin_unlock_irqrestore(&tid_ptr->tid_tbl_lock,
940  flags);
941  if (is_list_empty)
942  continue;
943 
944  /*
945  * Always choose the next ra we transmitted
946  * last time, this way we pick the ra's in
947  * round robin fashion.
948  */
949  ptr = list_first_entry(
950  &tid_ptr->ra_list_curr->list,
951  struct mwifiex_ra_list_tbl,
952  list);
953 
954  head = ptr;
955  if (ptr == (struct mwifiex_ra_list_tbl *)
956  &tid_ptr->ra_list) {
957  /* Get next ra */
958  ptr = list_first_entry(&ptr->list,
959  struct mwifiex_ra_list_tbl, list);
960  head = ptr;
961  }
962 
963  do {
964  is_list_empty =
965  skb_queue_empty(&ptr->skb_head);
966 
967  if (!is_list_empty)
968  goto found;
969 
970  /* Get next ra */
971  ptr = list_first_entry(&ptr->list,
972  struct mwifiex_ra_list_tbl,
973  list);
974  if (ptr ==
975  (struct mwifiex_ra_list_tbl *)
976  &tid_ptr->ra_list)
977  ptr = list_first_entry(
978  &ptr->list,
979  struct mwifiex_ra_list_tbl,
980  list);
981  } while (ptr != head);
982  }
983 
984  /* No packet at any TID for this priv. Mark as such
985  * to skip checking TIDs for this priv (until pkt is
986  * added).
987  */
989 
990  /* Get next bss priority node */
991  bssprio_node = list_first_entry(&bssprio_node->list,
992  struct mwifiex_bss_prio_node,
993  list);
994 
995  if (bssprio_node ==
996  (struct mwifiex_bss_prio_node *)
997  &adapter->bss_prio_tbl[j].bss_prio_head)
998  /* Get next bss priority node */
999  bssprio_node = list_first_entry(
1000  &bssprio_node->list,
1001  struct mwifiex_bss_prio_node,
1002  list);
1003  } while (bssprio_node != bssprio_head);
1004  }
1005  return NULL;
1006 
1007 found:
1008  spin_lock_irqsave(&priv_tmp->wmm.ra_list_spinlock, flags);
1009  if (atomic_read(hqp) > i)
1010  atomic_set(hqp, i);
1011  spin_unlock_irqrestore(&priv_tmp->wmm.ra_list_spinlock, flags);
1012 
1013  *priv = priv_tmp;
1014  *tid = tos_to_tid[i];
1015 
1016  return ptr;
1017 }
1018 
1019 /*
1020  * This function checks if 11n aggregation is possible.
1021  */
1022 static int
1023 mwifiex_is_11n_aggragation_possible(struct mwifiex_private *priv,
1024  struct mwifiex_ra_list_tbl *ptr,
1025  int max_buf_size)
1026 {
1027  int count = 0, total_size = 0;
1028  struct sk_buff *skb, *tmp;
1029  int max_amsdu_size;
1030 
1031  if (priv->bss_role == MWIFIEX_BSS_ROLE_UAP && priv->ap_11n_enabled &&
1032  ptr->is_11n_enabled)
1033  max_amsdu_size = min_t(int, ptr->max_amsdu, max_buf_size);
1034  else
1035  max_amsdu_size = max_buf_size;
1036 
1037  skb_queue_walk_safe(&ptr->skb_head, skb, tmp) {
1038  total_size += skb->len;
1039  if (total_size >= max_amsdu_size)
1040  break;
1041  if (++count >= MIN_NUM_AMSDU)
1042  return true;
1043  }
1044 
1045  return false;
1046 }
1047 
1048 /*
1049  * This function sends a single packet to firmware for transmission.
1050  */
1051 static void
1052 mwifiex_send_single_packet(struct mwifiex_private *priv,
1053  struct mwifiex_ra_list_tbl *ptr, int ptr_index,
1054  unsigned long ra_list_flags)
1055  __releases(&priv->wmm.ra_list_spinlock)
1056 {
1057  struct sk_buff *skb, *skb_next;
1058  struct mwifiex_tx_param tx_param;
1059  struct mwifiex_adapter *adapter = priv->adapter;
1060  struct mwifiex_txinfo *tx_info;
1061 
1062  if (skb_queue_empty(&ptr->skb_head)) {
1063  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock,
1064  ra_list_flags);
1065  dev_dbg(adapter->dev, "data: nothing to send\n");
1066  return;
1067  }
1068 
1069  skb = skb_dequeue(&ptr->skb_head);
1070 
1071  tx_info = MWIFIEX_SKB_TXCB(skb);
1072  dev_dbg(adapter->dev, "data: dequeuing the packet %p %p\n", ptr, skb);
1073 
1074  ptr->total_pkts_size -= skb->len;
1075 
1076  if (!skb_queue_empty(&ptr->skb_head))
1077  skb_next = skb_peek(&ptr->skb_head);
1078  else
1079  skb_next = NULL;
1080 
1081  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock, ra_list_flags);
1082 
1083  tx_param.next_pkt_len = ((skb_next) ? skb_next->len +
1084  sizeof(struct txpd) : 0);
1085 
1086  if (mwifiex_process_tx(priv, skb, &tx_param) == -EBUSY) {
1087  /* Queue the packet back at the head */
1088  spin_lock_irqsave(&priv->wmm.ra_list_spinlock, ra_list_flags);
1089 
1090  if (!mwifiex_is_ralist_valid(priv, ptr, ptr_index)) {
1091  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock,
1092  ra_list_flags);
1093  mwifiex_write_data_complete(adapter, skb, -1);
1094  return;
1095  }
1096 
1097  skb_queue_tail(&ptr->skb_head, skb);
1098 
1099  ptr->total_pkts_size += skb->len;
1100  ptr->pkt_count++;
1102  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock,
1103  ra_list_flags);
1104  } else {
1105  spin_lock_irqsave(&priv->wmm.ra_list_spinlock, ra_list_flags);
1106  if (mwifiex_is_ralist_valid(priv, ptr, ptr_index)) {
1107  priv->wmm.packets_out[ptr_index]++;
1108  priv->wmm.tid_tbl_ptr[ptr_index].ra_list_curr = ptr;
1109  }
1110  adapter->bss_prio_tbl[priv->bss_priority].bss_prio_cur =
1112  &adapter->bss_prio_tbl[priv->bss_priority]
1113  .bss_prio_cur->list,
1114  struct mwifiex_bss_prio_node,
1115  list);
1116  atomic_dec(&priv->wmm.tx_pkts_queued);
1117  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock,
1118  ra_list_flags);
1119  }
1120 }
1121 
1122 /*
1123  * This function checks if the first packet in the given RA list
1124  * is already processed or not.
1125  */
1126 static int
1127 mwifiex_is_ptr_processed(struct mwifiex_private *priv,
1128  struct mwifiex_ra_list_tbl *ptr)
1129 {
1130  struct sk_buff *skb;
1131  struct mwifiex_txinfo *tx_info;
1132 
1133  if (skb_queue_empty(&ptr->skb_head))
1134  return false;
1135 
1136  skb = skb_peek(&ptr->skb_head);
1137 
1138  tx_info = MWIFIEX_SKB_TXCB(skb);
1139  if (tx_info->flags & MWIFIEX_BUF_FLAG_REQUEUED_PKT)
1140  return true;
1141 
1142  return false;
1143 }
1144 
1145 /*
1146  * This function sends a single processed packet to firmware for
1147  * transmission.
1148  */
1149 static void
1150 mwifiex_send_processed_packet(struct mwifiex_private *priv,
1151  struct mwifiex_ra_list_tbl *ptr, int ptr_index,
1152  unsigned long ra_list_flags)
1153  __releases(&priv->wmm.ra_list_spinlock)
1154 {
1155  struct mwifiex_tx_param tx_param;
1156  struct mwifiex_adapter *adapter = priv->adapter;
1157  int ret = -1;
1158  struct sk_buff *skb, *skb_next;
1159  struct mwifiex_txinfo *tx_info;
1160 
1161  if (skb_queue_empty(&ptr->skb_head)) {
1162  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock,
1163  ra_list_flags);
1164  return;
1165  }
1166 
1167  skb = skb_dequeue(&ptr->skb_head);
1168 
1169  if (!skb_queue_empty(&ptr->skb_head))
1170  skb_next = skb_peek(&ptr->skb_head);
1171  else
1172  skb_next = NULL;
1173 
1174  tx_info = MWIFIEX_SKB_TXCB(skb);
1175 
1176  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock, ra_list_flags);
1177 
1178  if (adapter->iface_type == MWIFIEX_USB) {
1179  adapter->data_sent = true;
1180  ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_USB_EP_DATA,
1181  skb, NULL);
1182  } else {
1183  tx_param.next_pkt_len =
1184  ((skb_next) ? skb_next->len +
1185  sizeof(struct txpd) : 0);
1186  ret = adapter->if_ops.host_to_card(adapter, MWIFIEX_TYPE_DATA,
1187  skb, &tx_param);
1188  }
1189 
1190  switch (ret) {
1191  case -EBUSY:
1192  dev_dbg(adapter->dev, "data: -EBUSY is returned\n");
1193  spin_lock_irqsave(&priv->wmm.ra_list_spinlock, ra_list_flags);
1194 
1195  if (!mwifiex_is_ralist_valid(priv, ptr, ptr_index)) {
1196  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock,
1197  ra_list_flags);
1198  mwifiex_write_data_complete(adapter, skb, -1);
1199  return;
1200  }
1201 
1202  skb_queue_tail(&ptr->skb_head, skb);
1203 
1205  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock,
1206  ra_list_flags);
1207  break;
1208  case -1:
1209  adapter->data_sent = false;
1210  dev_err(adapter->dev, "host_to_card failed: %#x\n", ret);
1211  adapter->dbg.num_tx_host_to_card_failure++;
1212  mwifiex_write_data_complete(adapter, skb, ret);
1213  break;
1214  case -EINPROGRESS:
1215  adapter->data_sent = false;
1216  default:
1217  break;
1218  }
1219  if (ret != -EBUSY) {
1220  spin_lock_irqsave(&priv->wmm.ra_list_spinlock, ra_list_flags);
1221  if (mwifiex_is_ralist_valid(priv, ptr, ptr_index)) {
1222  priv->wmm.packets_out[ptr_index]++;
1223  priv->wmm.tid_tbl_ptr[ptr_index].ra_list_curr = ptr;
1224  }
1225  adapter->bss_prio_tbl[priv->bss_priority].bss_prio_cur =
1227  &adapter->bss_prio_tbl[priv->bss_priority]
1228  .bss_prio_cur->list,
1229  struct mwifiex_bss_prio_node,
1230  list);
1231  atomic_dec(&priv->wmm.tx_pkts_queued);
1232  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock,
1233  ra_list_flags);
1234  }
1235 }
1236 
1237 /*
1238  * This function dequeues a packet from the highest priority list
1239  * and transmits it.
1240  */
1241 static int
1242 mwifiex_dequeue_tx_packet(struct mwifiex_adapter *adapter)
1243 {
1244  struct mwifiex_ra_list_tbl *ptr;
1245  struct mwifiex_private *priv = NULL;
1246  int ptr_index = 0;
1247  u8 ra[ETH_ALEN];
1248  int tid_del = 0, tid = 0;
1249  unsigned long flags;
1250 
1251  ptr = mwifiex_wmm_get_highest_priolist_ptr(adapter, &priv, &ptr_index);
1252  if (!ptr)
1253  return -1;
1254 
1255  tid = mwifiex_get_tid(ptr);
1256 
1257  dev_dbg(adapter->dev, "data: tid=%d\n", tid);
1258 
1259  spin_lock_irqsave(&priv->wmm.ra_list_spinlock, flags);
1260  if (!mwifiex_is_ralist_valid(priv, ptr, ptr_index)) {
1261  spin_unlock_irqrestore(&priv->wmm.ra_list_spinlock, flags);
1262  return -1;
1263  }
1264 
1265  if (mwifiex_is_ptr_processed(priv, ptr)) {
1266  mwifiex_send_processed_packet(priv, ptr, ptr_index, flags);
1267  /* ra_list_spinlock has been freed in
1268  mwifiex_send_processed_packet() */
1269  return 0;
1270  }
1271 
1272  if (!ptr->is_11n_enabled ||
1273  mwifiex_is_ba_stream_setup(priv, ptr, tid) ||
1274  priv->wps.session_enable ||
1275  ((priv->sec_info.wpa_enabled ||
1276  priv->sec_info.wpa2_enabled) &&
1277  !priv->wpa_is_gtk_set)) {
1278  mwifiex_send_single_packet(priv, ptr, ptr_index, flags);
1279  /* ra_list_spinlock has been freed in
1280  mwifiex_send_single_packet() */
1281  } else {
1282  if (mwifiex_is_ampdu_allowed(priv, tid) &&
1283  ptr->pkt_count > ptr->ba_packet_thr) {
1284  if (mwifiex_space_avail_for_new_ba_stream(adapter)) {
1285  mwifiex_create_ba_tbl(priv, ptr->ra, tid,
1287  mwifiex_send_addba(priv, tid, ptr->ra);
1288  } else if (mwifiex_find_stream_to_delete
1289  (priv, tid, &tid_del, ra)) {
1290  mwifiex_create_ba_tbl(priv, ptr->ra, tid,
1292  mwifiex_send_delba(priv, tid_del, ra, 1);
1293  }
1294  }
1295  if (mwifiex_is_amsdu_allowed(priv, tid) &&
1296  mwifiex_is_11n_aggragation_possible(priv, ptr,
1297  adapter->tx_buf_size))
1299  ptr_index, flags);
1300  /* ra_list_spinlock has been freed in
1301  mwifiex_11n_aggregate_pkt() */
1302  else
1303  mwifiex_send_single_packet(priv, ptr, ptr_index, flags);
1304  /* ra_list_spinlock has been freed in
1305  mwifiex_send_single_packet() */
1306  }
1307  return 0;
1308 }
1309 
1310 /*
1311  * This function transmits the highest priority packet awaiting in the
1312  * WMM Queues.
1313  */
1314 void
1316 {
1317  do {
1318  /* Check if busy */
1319  if (adapter->data_sent || adapter->tx_lock_flag)
1320  break;
1321 
1322  if (mwifiex_dequeue_tx_packet(adapter))
1323  break;
1324  } while (!mwifiex_wmm_lists_empty(adapter));
1325 }