1 files changed, 236 insertions, 44 deletions

diff --git a/net/mac80211/offchannel.c b/net/mac80211/offchannel.c
index 935aa4b6deee..abb226dc4753 100644
--- a/net/mac80211/offchannel.c
+++ b/net/mac80211/offchannel.c
@@ -16,6 +16,7 @@
 #include <net/mac80211.h>
 #include "ieee80211_i.h"
 #include "driver-trace.h"
+#include "driver-ops.h"
 
 /*
  * Tell our hardware to disable PS.
@@ -181,34 +182,58 @@ void ieee80211_offchannel_return(struct ieee80211_local *local,
         mutex_unlock(&local->iflist_mtx);
 }
 
+void ieee80211_handle_roc_started(struct ieee80211_roc_work *roc)
+{
+        if (roc->notified)
+                return;
+
+        if (roc->mgmt_tx_cookie) {
+                if (!WARN_ON(!roc->frame)) {
+                        ieee80211_tx_skb(roc->sdata, roc->frame);
+                        roc->frame = NULL;
+                }
+        } else {
+                cfg80211_ready_on_channel(roc->sdata->dev, (unsigned long)roc,
+                                          roc->chan, roc->chan_type,
+                                          roc->req_duration, GFP_KERNEL);
+        }
+
+        roc->notified = true;
+}
+
 static void ieee80211_hw_roc_start(struct work_struct *work)
 {
         struct ieee80211_local *local =
                 container_of(work, struct ieee80211_local, hw_roc_start);
-        struct ieee80211_sub_if_data *sdata;
+        struct ieee80211_roc_work *roc, *dep, *tmp;
 
         mutex_lock(&local->mtx);
 
-        if (!local->hw_roc_channel) {
-                mutex_unlock(&local->mtx);
-                return;
-        }
+        if (list_empty(&local->roc_list))
+                goto out_unlock;
 
-        if (local->hw_roc_skb) {
-                sdata = IEEE80211_DEV_TO_SUB_IF(local->hw_roc_dev);
-                ieee80211_tx_skb(sdata, local->hw_roc_skb);
-                local->hw_roc_skb = NULL;
-        } else {
-                cfg80211_ready_on_channel(local->hw_roc_dev,
-                                          local->hw_roc_cookie,
-                                          local->hw_roc_channel,
-                                          local->hw_roc_channel_type,
-                                          local->hw_roc_duration,
-                                          GFP_KERNEL);
-        }
+        roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work,
+                               list);
+
+        if (!roc->started)
+                goto out_unlock;
 
-        ieee80211_recalc_idle(local);
+        roc->hw_begun = true;
+        roc->hw_start_time = local->hw_roc_start_time;
 
+        ieee80211_handle_roc_started(roc);
+        list_for_each_entry_safe(dep, tmp, &roc->dependents, list) {
+                ieee80211_handle_roc_started(dep);
+
+                if (dep->duration > roc->duration) {
+                        u32 dur = dep->duration;
+                        dep->duration = dur - roc->duration;
+                        roc->duration = dur;
+                        list_del(&dep->list);
+                        list_add(&dep->list, &roc->list);
+                }
+        }
+ out_unlock:
         mutex_unlock(&local->mtx);
 }
 
@@ -216,52 +241,179 @@ void ieee80211_ready_on_channel(struct ieee80211_hw *hw)
 {
         struct ieee80211_local *local = hw_to_local(hw);
 
+        local->hw_roc_start_time = jiffies;
+
         trace_api_ready_on_channel(local);
 
         ieee80211_queue_work(hw, &local->hw_roc_start);
 }
 EXPORT_SYMBOL_GPL(ieee80211_ready_on_channel);
 
-static void ieee80211_hw_roc_done(struct work_struct *work)
+void ieee80211_start_next_roc(struct ieee80211_local *local)
 {
-        struct ieee80211_local *local =
-                container_of(work, struct ieee80211_local, hw_roc_done);
+        struct ieee80211_roc_work *roc;
 
-        mutex_lock(&local->mtx);
+        lockdep_assert_held(&local->mtx);
 
-        if (!local->hw_roc_channel) {
-                mutex_unlock(&local->mtx);
+        if (list_empty(&local->roc_list)) {
+                ieee80211_run_deferred_scan(local);
                 return;
         }
 
-        /* was never transmitted */
-        if (local->hw_roc_skb) {
-                u64 cookie;
+        roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work,
+                               list);
 
-                cookie = local->hw_roc_cookie ^ 2;
+        if (local->ops->remain_on_channel) {
+                int ret, duration = roc->duration;
 
-                cfg80211_mgmt_tx_status(local->hw_roc_dev, cookie,
-                                        local->hw_roc_skb->data,
-                                        local->hw_roc_skb->len, false,
-                                        GFP_KERNEL);
+                /* XXX: duplicated, see ieee80211_start_roc_work() */
+                if (!duration)
+                        duration = 10;
 
-                kfree_skb(local->hw_roc_skb);
-                local->hw_roc_skb = NULL;
-                local->hw_roc_skb_for_status = NULL;
+                ret = drv_remain_on_channel(local, roc->chan,
+                                            roc->chan_type,
+                                            duration);
+
+                roc->started = true;
+
+                if (ret) {
+                        wiphy_warn(local->hw.wiphy,
+                                   "failed to start next HW ROC (%d)\n", ret);
+                        /*
+                         * queue the work struct again to avoid recursion
+                         * when multiple failures occur
+                         */
+                        ieee80211_remain_on_channel_expired(&local->hw);
+                }
+        } else {
+                /* delay it a bit */
+                ieee80211_queue_delayed_work(&local->hw, &roc->work,
+                                             round_jiffies_relative(HZ/2));
+        }
+}
+
+void ieee80211_roc_notify_destroy(struct ieee80211_roc_work *roc)
+{
+        struct ieee80211_roc_work *dep, *tmp;
+
+        /* was never transmitted */
+        if (roc->frame) {
+                cfg80211_mgmt_tx_status(roc->sdata->dev,
+                                        (unsigned long)roc->frame,
+                                        roc->frame->data, roc->frame->len,
+                                        false, GFP_KERNEL);
+                kfree_skb(roc->frame);
         }
 
-        if (!local->hw_roc_for_tx)
-                cfg80211_remain_on_channel_expired(local->hw_roc_dev,
-                                                   local->hw_roc_cookie,
-                                                   local->hw_roc_channel,
-                                                   local->hw_roc_channel_type,
+        if (!roc->mgmt_tx_cookie)
+                cfg80211_remain_on_channel_expired(roc->sdata->dev,
+                                                   (unsigned long)roc,
+                                                   roc->chan, roc->chan_type,
                                                    GFP_KERNEL);
 
-        local->hw_roc_channel = NULL;
-        local->hw_roc_cookie = 0;
+        list_for_each_entry_safe(dep, tmp, &roc->dependents, list)
+                ieee80211_roc_notify_destroy(dep);
+
+        kfree(roc);
+}
+
+void ieee80211_sw_roc_work(struct work_struct *work)
+{
+        struct ieee80211_roc_work *roc =
+                container_of(work, struct ieee80211_roc_work, work.work);
+        struct ieee80211_sub_if_data *sdata = roc->sdata;
+        struct ieee80211_local *local = sdata->local;
+
+        mutex_lock(&local->mtx);
+
+        if (roc->abort)
+                goto finish;
+
+        if (WARN_ON(list_empty(&local->roc_list)))
+                goto out_unlock;
+
+        if (WARN_ON(roc != list_first_entry(&local->roc_list,
+                                            struct ieee80211_roc_work,
+                                            list)))
+                goto out_unlock;
+
+        if (!roc->started) {
+                struct ieee80211_roc_work *dep;
+
+                /* start this ROC */
 
-        ieee80211_recalc_idle(local);
+                /* switch channel etc */
+                ieee80211_recalc_idle(local);
 
+                local->tmp_channel = roc->chan;
+                local->tmp_channel_type = roc->chan_type;
+                ieee80211_hw_config(local, 0);
+
+                /* tell userspace or send frame */
+                ieee80211_handle_roc_started(roc);
+                list_for_each_entry(dep, &roc->dependents, list)
+                        ieee80211_handle_roc_started(dep);
+
+                /* if it was pure TX, just finish right away */
+                if (!roc->duration)
+                        goto finish;
+
+                roc->started = true;
+                ieee80211_queue_delayed_work(&local->hw, &roc->work,
+                                             msecs_to_jiffies(roc->duration));
+        } else {
+                /* finish this ROC */
+ finish:
+                list_del(&roc->list);
+                ieee80211_roc_notify_destroy(roc);
+
+                if (roc->started) {
+                        drv_flush(local, false);
+
+                        local->tmp_channel = NULL;
+                        ieee80211_hw_config(local, 0);
+
+                        ieee80211_offchannel_return(local, true);
+                }
+
+                ieee80211_recalc_idle(local);
+
+                ieee80211_start_next_roc(local);
+                ieee80211_run_deferred_scan(local);
+        }
+
+ out_unlock:
+        mutex_unlock(&local->mtx);
+}
+
+static void ieee80211_hw_roc_done(struct work_struct *work)
+{
+        struct ieee80211_local *local =
+                container_of(work, struct ieee80211_local, hw_roc_done);
+        struct ieee80211_roc_work *roc;
+
+        mutex_lock(&local->mtx);
+
+        if (list_empty(&local->roc_list))
+                goto out_unlock;
+
+        roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work,
+                               list);
+
+        if (!roc->started)
+                goto out_unlock;
+
+        list_del(&roc->list);
+
+        ieee80211_roc_notify_destroy(roc);
+
+        /* if there's another roc, start it now */
+        ieee80211_start_next_roc(local);
+
+        /* or scan maybe */
+        ieee80211_run_deferred_scan(local);
+
+ out_unlock:
         mutex_unlock(&local->mtx);
 }
 
@@ -275,8 +427,48 @@ void ieee80211_remain_on_channel_expired(struct ieee80211_hw *hw)
 }
 EXPORT_SYMBOL_GPL(ieee80211_remain_on_channel_expired);
 
-void ieee80211_hw_roc_setup(struct ieee80211_local *local)
+void ieee80211_roc_setup(struct ieee80211_local *local)
 {
         INIT_WORK(&local->hw_roc_start, ieee80211_hw_roc_start);
         INIT_WORK(&local->hw_roc_done, ieee80211_hw_roc_done);
+        INIT_LIST_HEAD(&local->roc_list);
+}
+
+void ieee80211_roc_purge(struct ieee80211_sub_if_data *sdata)
+{
+        struct ieee80211_local *local = sdata->local;
+        struct ieee80211_roc_work *roc, *tmp;
+        LIST_HEAD(tmp_list);
+
+        mutex_lock(&local->mtx);
+        list_for_each_entry_safe(roc, tmp, &local->roc_list, list) {
+                if (roc->sdata != sdata)
+                        continue;
+
+                if (roc->started && local->ops->remain_on_channel) {
+                        /* can race, so ignore return value */
+                        drv_cancel_remain_on_channel(local);
+                }
+
+                list_move_tail(&roc->list, &tmp_list);
+                roc->abort = true;
+        }
+
+        ieee80211_start_next_roc(local);
+        ieee80211_run_deferred_scan(local);
+        mutex_unlock(&local->mtx);
+
+        list_for_each_entry_safe(roc, tmp, &tmp_list, list) {
+                if (local->ops->remain_on_channel) {
+                        list_del(&roc->list);
+                        ieee80211_roc_notify_destroy(roc);
+                } else {
+                        ieee80211_queue_delayed_work(&local->hw, &roc->work, 0);
+
+                        /* work will clean up etc */
+                        flush_delayed_work(&roc->work);
+                }
+        }
+
+        WARN_ON_ONCE(!list_empty(&tmp_list));
 }