Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/net/mac80211/status.c

 /*
  * Copyright 2002-2005, Instant802 Networks, Inc.
  * Copyright 2005-2006, Devicescape Software, Inc.
  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
  * Copyright 2008-2010  Johannes Berg <johannes@sipsolutions.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
@@ skipping 40 matching lines @@
          * being correct. Clear it so we don't get junk there, and
          * indicate that it needs new processing, but must not be
          * modified/encrypted again.
          */
         memset(&info->control, 0, sizeof(info->control));
 
         info->control.jiffies = jiffies;
         info->control.vif = &sta->sdata->vif;
         info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING |
                        IEEE80211_TX_INTFL_RETRANSMISSION;
+        info->flags &= ~IEEE80211_TX_TEMPORARY_FLAGS;
 
         sta->tx_filtered_count++;
 
         /*
          * Clear the TX filter mask for this STA when sending the next
          * packet. If the STA went to power save mode, this will happen
          * when it wakes up for the next time.
          */
         set_sta_flags(sta, WLAN_STA_CLEAR_PS_FILT);
 
@@ skipping 45 matching lines @@
         if (net_ratelimit())
                 printk(KERN_DEBUG "%s: dropped TX filtered frame, "
                        "queue_len=%d PS=%d @%lu\n",
                        wiphy_name(local->hw.wiphy),
                        skb_queue_len(&sta->tx_filtered),
                        !!test_sta_flags(sta, WLAN_STA_PS_STA), jiffies);
 #endif
         dev_kfree_skb(skb);
 }
 
-static void ieee80211_sta_tx_status(struct sta_info *sta, struct sk_buff *skb)
+static void ieee80211_frame_acked(struct sta_info *sta, struct sk_buff *skb)
 {
         struct ieee80211_mgmt *mgmt = (void *) skb->data;
         struct ieee80211_local *local = sta->local;
         struct ieee80211_sub_if_data *sdata = sta->sdata;
-        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-
-        if (sdata->vif.type != NL80211_IFTYPE_STATION)
-                return;
 
         if (ieee80211_is_action(mgmt->frame_control) &&
-            (info->flags & IEEE80211_TX_STAT_ACK) &&
+            sdata->vif.type == NL80211_IFTYPE_STATION &&
             mgmt->u.action.category == WLAN_CATEGORY_HT &&
             mgmt->u.action.u.ht_smps.action == WLAN_HT_ACTION_SMPS) {
                 /*
                  * This update looks racy, but isn't -- if we come
                  * here we've definitely got a station that we're
                  * talking to, and on a managed interface that can
                  * only be the AP. And the only other place updating
                  * this variable is before we're associated.
                  */
                 switch (mgmt->u.action.u.ht_smps.smps_control) {
                 case WLAN_HT_SMPS_CONTROL_DYNAMIC:
                         sta->sdata->u.mgd.ap_smps = IEEE80211_SMPS_DYNAMIC;
                         break;
                 case WLAN_HT_SMPS_CONTROL_STATIC:
                         sta->sdata->u.mgd.ap_smps = IEEE80211_SMPS_STATIC;
                         break;
                 case WLAN_HT_SMPS_CONTROL_DISABLED:
                 default: /* shouldn't happen since we don't send that */
                         sta->sdata->u.mgd.ap_smps = IEEE80211_SMPS_OFF;
                         break;
                 }
 
                 ieee80211_queue_work(&local->hw, &local->recalc_smps);
-        } else if (ieee80211_is_probe_req(mgmt->frame_control) ||
-                   ieee80211_is_nullfunc(mgmt->frame_control)) {
-                struct ieee80211_if_managed *ifmgd = &sta->sdata->u.mgd;
-
-                ifmgd->probe_acked =
-                    (info->flags & IEEE80211_TX_STAT_ACK) ? true : false;
-
-                ieee80211_queue_work(&local->hw, &ifmgd->probe_status_work);
         } else if (ieee80211_is_data(mgmt->frame_control) &&
-                   sdata->vif.type == NL80211_IFTYPE_STATION &&
-                   (info->flags & IEEE80211_TX_STAT_ACK)) {
-                struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
+                   sdata->vif.type == NL80211_IFTYPE_STATION) {
+                struct ieee80211_if_managed *ifmgd;
+                ifmgd = &sta->sdata->u.mgd;
                 if (ifmgd->cqm_bitrate_thold != 0 &&
                     (ifmgd->last_cqm_tx_rate.idx != sta->last_tx_rate.idx ||
                      (ifmgd->last_cqm_tx_rate.flags &
                       (IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_40_MHZ_WIDTH |
                        IEEE80211_TX_RC_SHORT_GI)) !=
                      (sta->last_tx_rate.flags &
                       (IEEE80211_TX_RC_MCS | IEEE80211_TX_RC_40_MHZ_WIDTH |
                        IEEE80211_TX_RC_SHORT_GI)) ||
                      sdata->u.mgd.last_cqm_bitrate == 0)) {
                         ifmgd->last_cqm_tx_rate = sta->last_tx_rate;
@@ skipping 13 matching lines @@
         u16 frag, type;
         __le16 fc;
         struct ieee80211_supported_band *sband;
         struct ieee80211_tx_status_rtap_hdr *rthdr;
         struct ieee80211_sub_if_data *sdata;
         struct net_device *prev_dev = NULL;
         struct sta_info *sta, *tmp;
         int retry_count = -1, i;
         int rates_idx = -1;
         bool send_to_cooked;
+        bool acked;
 
         for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
                 /* the HW cannot have attempted that rate */
                 if (i >= hw->max_rates) {
                         info->status.rates[i].idx = -1;
                         info->status.rates[i].count = 0;
                 } else if (info->status.rates[i].idx >= 0) {
                         rates_idx = i;
                 }
 
                 retry_count += info->status.rates[i].count;
         }
         if (retry_count < 0)
                 retry_count = 0;
 
         rcu_read_lock();
 
         sband = local->hw.wiphy->bands[info->band];
         fc = hdr->frame_control;
 
         for_each_sta_info(local, hdr->addr1, sta, tmp) {
                 /* skip wrong virtual interface */
                 if (memcmp(hdr->addr2, sta->sdata->vif.addr, ETH_ALEN))
                         continue;
 
-                if (!(info->flags & IEEE80211_TX_STAT_ACK) &&
-                    test_sta_flags(sta, WLAN_STA_PS_STA)) {
+                acked = !!(info->flags & IEEE80211_TX_STAT_ACK);
+                if (!acked && test_sta_flags(sta, WLAN_STA_PS_STA)) {
                         /*
                          * The STA is in power save mode, so assume
                          * that this TX packet failed because of that.
                          */
                         ieee80211_handle_filtered_frame(local, sta, skb);
                         rcu_read_unlock();
                         return;
                 }
 
                 if ((local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) &&
@@ skipping 11 matching lines @@
                                                 & IEEE80211_SCTL_SEQ);
                         ieee80211_send_bar(sta->sdata, hdr->addr1,
                                            tid, ssn);
                 }
 
                 if (info->flags & IEEE80211_TX_STAT_TX_FILTERED) {
                         ieee80211_handle_filtered_frame(local, sta, skb);
                         rcu_read_unlock();
                         return;
                 } else {
-                        if (!(info->flags & IEEE80211_TX_STAT_ACK))
+                        if (!acked)
                                 sta->tx_retry_failed++;
                         sta->tx_retry_count += retry_count;
                 }
 
                 rate_control_tx_status(local, sband, sta, skb);
                 if (ieee80211_vif_is_mesh(&sta->sdata->vif))
                         ieee80211s_update_metric(local, sta, skb);
 
-                if (!(info->flags & IEEE80211_TX_CTL_INJECTED))
-                        ieee80211_sta_tx_status(sta, skb);
+                if (!(info->flags & IEEE80211_TX_CTL_INJECTED) && acked)
+                        ieee80211_frame_acked(sta, skb);
+
+                if ((sta->sdata->vif.type == NL80211_IFTYPE_STATION) &&
+                    (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
+                        ieee80211_sta_tx_notify(sta->sdata, (void *) skb->data, acked);
         }
 
         rcu_read_unlock();
 
         ieee80211_led_tx(local, 0);
 
         /* SNMP counters
          * Fragments are passed to low-level drivers as separate skbs, so these
          * are actually fragments, not frames. Update frame counters only for
          * the first fragment of the frame. */
@@ skipping 114 matching lines @@
                                 continue;
 
                         if ((sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES) &&
                             !send_to_cooked)
                                 continue;
 
                         if (prev_dev) {
                                 skb2 = skb_clone(skb, GFP_ATOMIC);
                                 if (skb2) {
                                         skb2->dev = prev_dev;
-                                        netif_receive_skb(skb2);
+                                        netif_rx(skb2);
                                 }
                         }
 
                         prev_dev = sdata->dev;
                 }
         }
         if (prev_dev) {
                 skb->dev = prev_dev;
-                netif_receive_skb(skb);
+                netif_rx(skb);
                 skb = NULL;
         }
         rcu_read_unlock();
         dev_kfree_skb(skb);
 }
 EXPORT_SYMBOL(ieee80211_tx_status);