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