Merge branch 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jdelv...

[deliverable/linux.git] / drivers / net / wireless / p54 / p54common.c

diff --git a/drivers/net/wireless/p54/p54common.c b/drivers/net/wireless/p54/p54common.c
index b857852918035776db96b197274e13fa6f7a63eb..b618bd14583f9489143de1e1654dad3a290c2598 100644 (file)
--- a/drivers/net/wireless/p54/p54common.c
+++ b/drivers/net/wireless/p54/p54common.c
@@ -822,44 +822,37 @@ void p54_free_skb(struct ieee80211_hw *dev, struct sk_buff *skb)
        struct ieee80211_tx_info *info;
        struct p54_tx_info *range;
        unsigned long flags;
-       u32 freed = 0, last_addr = priv->rx_start;
 
-       if (unlikely(!skb || !dev || !skb_queue_len(&priv->tx_queue)))
+       if (unlikely(!skb || !dev || skb_queue_empty(&priv->tx_queue)))
                return;
 
-       /*
-        * don't try to free an already unlinked skb
+       /* There used to be a check here to see if the SKB was on the
+        * TX queue or not.  This can never happen because all SKBs we
+        * see here successfully went through p54_assign_address()
+        * which means the SKB is on the ->tx_queue.
         */
-       if (unlikely((!skb->next) || (!skb->prev)))
-               return;
 
        spin_lock_irqsave(&priv->tx_queue.lock, flags);
        info = IEEE80211_SKB_CB(skb);
        range = (void *)info->rate_driver_data;
-       if (skb->prev != (struct sk_buff *)&priv->tx_queue) {
+       if (!skb_queue_is_first(&priv->tx_queue, skb)) {
                struct ieee80211_tx_info *ni;
                struct p54_tx_info *mr;
 
-               ni = IEEE80211_SKB_CB(skb->prev);
+               ni = IEEE80211_SKB_CB(skb_queue_prev(&priv->tx_queue, skb));
                mr = (struct p54_tx_info *)ni->rate_driver_data;
-               last_addr = mr->end_addr;
        }
-       if (skb->next != (struct sk_buff *)&priv->tx_queue) {
+       if (!skb_queue_is_last(&priv->tx_queue, skb)) {
                struct ieee80211_tx_info *ni;
                struct p54_tx_info *mr;
 
-               ni = IEEE80211_SKB_CB(skb->next);
+               ni = IEEE80211_SKB_CB(skb_queue_next(&priv->tx_queue, skb));
                mr = (struct p54_tx_info *)ni->rate_driver_data;
-               freed = mr->start_addr - last_addr;
-       } else
-               freed = priv->rx_end - last_addr;
+       }
        __skb_unlink(skb, &priv->tx_queue);
        spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
        dev_kfree_skb_any(skb);
-
-       if (freed >= priv->headroom + sizeof(struct p54_hdr) + 48 +
-                    IEEE80211_MAX_RTS_THRESHOLD + priv->tailroom)
-               p54_wake_free_queues(dev);
+       p54_wake_free_queues(dev);
 }
 EXPORT_SYMBOL_GPL(p54_free_skb);
 
@@ -871,15 +864,13 @@ static struct sk_buff *p54_find_tx_entry(struct ieee80211_hw *dev,
        unsigned long flags;
 
        spin_lock_irqsave(&priv->tx_queue.lock, flags);
-       entry = priv->tx_queue.next;
-       while (entry != (struct sk_buff *)&priv->tx_queue) {
+       skb_queue_walk(&priv->tx_queue, entry) {
                struct p54_hdr *hdr = (struct p54_hdr *) entry->data;
 
                if (hdr->req_id == req_id) {
                        spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
                        return entry;
                }
-               entry = entry->next;
        }
        spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
        return NULL;
@@ -893,37 +884,29 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
        struct sk_buff *entry;
        u32 addr = le32_to_cpu(hdr->req_id) - priv->headroom;
        struct p54_tx_info *range = NULL;
-       u32 freed = 0;
-       u32 last_addr = priv->rx_start;
        unsigned long flags;
        int count, idx;
 
        spin_lock_irqsave(&priv->tx_queue.lock, flags);
-       entry = (struct sk_buff *) priv->tx_queue.next;
-       while (entry != (struct sk_buff *)&priv->tx_queue) {
+       skb_queue_walk(&priv->tx_queue, entry) {
                struct ieee80211_tx_info *info = IEEE80211_SKB_CB(entry);
                struct p54_hdr *entry_hdr;
                struct p54_tx_data *entry_data;
                unsigned int pad = 0, frame_len;
 
                range = (void *)info->rate_driver_data;
-               if (range->start_addr != addr) {
-                       last_addr = range->end_addr;
-                       entry = entry->next;
+               if (range->start_addr != addr)
                        continue;
-               }
 
-               if (entry->next != (struct sk_buff *)&priv->tx_queue) {
+               if (!skb_queue_is_last(&priv->tx_queue, entry)) {
                        struct ieee80211_tx_info *ni;
                        struct p54_tx_info *mr;
 
-                       ni = IEEE80211_SKB_CB(entry->next);
+                       ni = IEEE80211_SKB_CB(skb_queue_next(&priv->tx_queue,
+                                                            entry));
                        mr = (struct p54_tx_info *)ni->rate_driver_data;
-                       freed = mr->start_addr - last_addr;
-               } else
-                       freed = priv->rx_end - last_addr;
+               }
 
-               last_addr = range->end_addr;
                __skb_unlink(entry, &priv->tx_queue);
                spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
 
@@ -1010,9 +993,7 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
        spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
 
 out:
-       if (freed >= priv->headroom + sizeof(struct p54_hdr) + 48 +
-                    IEEE80211_MAX_RTS_THRESHOLD + priv->tailroom)
-               p54_wake_free_queues(dev);
+       p54_wake_free_queues(dev);
 }
 
 static void p54_rx_eeprom_readback(struct ieee80211_hw *dev,
@@ -1183,23 +1164,21 @@ static int p54_assign_address(struct ieee80211_hw *dev, struct sk_buff *skb,
                }
        }
 
-       entry = priv->tx_queue.next;
-       while (left--) {
+       skb_queue_walk(&priv->tx_queue, entry) {
                u32 hole_size;
                info = IEEE80211_SKB_CB(entry);
                range = (void *)info->rate_driver_data;
                hole_size = range->start_addr - last_addr;
                if (!target_skb && hole_size >= len) {
-                       target_skb = entry->prev;
+                       target_skb = skb_queue_prev(&priv->tx_queue, entry);
                        hole_size -= len;
                        target_addr = last_addr;
                }
                largest_hole = max(largest_hole, hole_size);
                last_addr = range->end_addr;
-               entry = entry->next;
        }
        if (!target_skb && priv->rx_end - last_addr >= len) {
-               target_skb = priv->tx_queue.prev;
+               target_skb = skb_peek_tail(&priv->tx_queue);
                largest_hole = max(largest_hole, priv->rx_end - last_addr - len);
                if (!skb_queue_empty(&priv->tx_queue)) {
                        info = IEEE80211_SKB_CB(target_skb);
@@ -2105,7 +2084,6 @@ out:
 static void p54_stop(struct ieee80211_hw *dev)
 {
        struct p54_common *priv = dev->priv;
-       struct sk_buff *skb;
 
        mutex_lock(&priv->conf_mutex);
        priv->mode = NL80211_IFTYPE_UNSPECIFIED;
@@ -2120,8 +2098,7 @@ static void p54_stop(struct ieee80211_hw *dev)
                p54_tx_cancel(dev, priv->cached_beacon);
 
        priv->stop(dev);
-       while ((skb = skb_dequeue(&priv->tx_queue)))
-               kfree_skb(skb);
+       skb_queue_purge(&priv->tx_queue);
        priv->cached_beacon = NULL;
        priv->tsf_high32 = priv->tsf_low32 = 0;
        mutex_unlock(&priv->conf_mutex);