mwifiex: rework round robin scheduling of bss nodes.

Rotate bss prio list, so the bss next to the one served, will come first
in the list of bss' with equal priority. This way we pick bss nodes in a
round robin fashion. Using list rotation instead of a cur ptr simplifies
iteration to calling list_for_each_entry. List rotation is done via
list_move, where the head itself is temporarily removed and then
re-inserted after the bss just served.

Signed-off-by: Andreas Fenkart <andreas.fenkart@streamunlimited.com>
Acked-by: Bing Zhao <bzhao@marvell.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 6 insertions, 15 deletions

diff --git a/drivers/net/wireless/mwifiex/init.c b/drivers/net/wireless/mwifiex/init.c
index 42d7f0adf9bd..9f44fda19db9 100644
--- a/drivers/net/wireless/mwifiex/init.c
+++ b/drivers/net/wireless/mwifiex/init.c
@@ -44,8 +44,6 @@ static int mwifiex_add_bss_prio_tbl(struct mwifiex_private *priv)
 
         bss_prio->priv = priv;
         INIT_LIST_HEAD(&bss_prio->list);
-        if (!tbl[priv->bss_priority].bss_prio_cur)
-                tbl[priv->bss_priority].bss_prio_cur = bss_prio;
 
         spin_lock_irqsave(&tbl[priv->bss_priority].bss_prio_lock, flags);
         list_add_tail(&bss_prio->list, &tbl[priv->bss_priority].bss_prio_head);
@@ -525,7 +523,6 @@ int mwifiex_init_lock_list(struct mwifiex_adapter *adapter)
 
         for (i = 0; i < adapter->priv_num; ++i) {
                 INIT_LIST_HEAD(&adapter->bss_prio_tbl[i].bss_prio_head);
-                adapter->bss_prio_tbl[i].bss_prio_cur = NULL;
                 spin_lock_init(&adapter->bss_prio_tbl[i].bss_prio_lock);
         }
 
@@ -625,42 +622,36 @@ static void mwifiex_delete_bss_prio_tbl(struct mwifiex_private *priv)
 {
         int i;
         struct mwifiex_adapter *adapter = priv->adapter;
-        struct mwifiex_bss_prio_node *bssprio_node, *tmp_node, **cur;
+        struct mwifiex_bss_prio_node *bssprio_node, *tmp_node;
         struct list_head *head;
         spinlock_t *lock; /* bss priority lock */
         unsigned long flags;
 
         for (i = 0; i < adapter->priv_num; ++i) {
                 head = &adapter->bss_prio_tbl[i].bss_prio_head;
-                cur = &adapter->bss_prio_tbl[i].bss_prio_cur;
                 lock = &adapter->bss_prio_tbl[i].bss_prio_lock;
                 dev_dbg(adapter->dev, "info: delete BSS priority table,"
                                 " bss_type = %d, bss_num = %d, i = %d,"
-                                " head = %p, cur = %p\n",
-                              priv->bss_type, priv->bss_num, i, head, *cur);
-                if (*cur) {
+                                " head = %p\n",
+                              priv->bss_type, priv->bss_num, i, head);
+
+                {
                         spin_lock_irqsave(lock, flags);
                         if (list_empty(head)) {
                                 spin_unlock_irqrestore(lock, flags);
                                 continue;
                         }
-                        bssprio_node = list_first_entry(head,
-                                        struct mwifiex_bss_prio_node, list);
-                        spin_unlock_irqrestore(lock, flags);
-
                         list_for_each_entry_safe(bssprio_node, tmp_node, head,
                                                  list) {
                                 if (bssprio_node->priv == priv) {
                                         dev_dbg(adapter->dev, "info: Delete "
                                                 "node %p, next = %p\n",
                                                 bssprio_node, tmp_node);
-                                        spin_lock_irqsave(lock, flags);
                                         list_del(&bssprio_node->list);
-                                        spin_unlock_irqrestore(lock, flags);
                                         kfree(bssprio_node);
                                 }
                         }
-                        *cur = (struct mwifiex_bss_prio_node *)head;
+                        spin_unlock_irqrestore(lock, flags);
                 }
         }
 }