iwlwifi: extend notification wait

Sometimes, for example when we ask the uCode
for calibration, we wait for the "complete"
response while we also need the results that
are sent in other, interim, notifications.

Currently we handle this by installing an RX
handler globally, but that isn't needed as
this is the only time we want to use these
notifications.

So in order to be able to simplify at least
future code that does the same, extend the
notification wait framework to allow you to
wait for multiple commands and decide based
on the command whether the wait finished.

While at it, also fix a race that can then
become relevant -- if the wait function has
returned true once it shouldn't be called
again, today this can happen due to races
between the triggering and the wakeup.

Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 36 insertions, 8 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl-notif-wait.c b/drivers/net/wireless/iwlwifi/iwl-notif-wait.c
index 88dc4a0f96b4..0066b899fe5c 100644
--- a/drivers/net/wireless/iwlwifi/iwl-notif-wait.c
+++ b/drivers/net/wireless/iwlwifi/iwl-notif-wait.c
@@ -75,21 +75,45 @@ void iwl_notification_wait_init(struct iwl_notif_wait_data *notif_wait)
 void iwl_notification_wait_notify(struct iwl_notif_wait_data *notif_wait,
                                   struct iwl_rx_packet *pkt)
 {
+        bool triggered = false;
+
         if (!list_empty(&notif_wait->notif_waits)) {
                 struct iwl_notification_wait *w;
 
                 spin_lock(&notif_wait->notif_wait_lock);
                 list_for_each_entry(w, &notif_wait->notif_waits, list) {
-                        if (w->cmd != pkt->hdr.cmd)
+                        int i;
+                        bool found = false;
+
+                        /*
+                         * If it already finished (triggered) or has been
+                         * aborted then don't evaluate it again to avoid races,
+                         * Otherwise the function could be called again even
+                         * though it returned true before
+                         */
+                        if (w->triggered || w->aborted)
+                                continue;
+
+                        for (i = 0; i < w->n_cmds; i++) {
+                                if (w->cmds[i] == pkt->hdr.cmd) {
+                                        found = true;
+                                        break;
+                                }
+                        }
+                        if (!found)
                                 continue;
-                        w->triggered = true;
-                        if (w->fn)
-                                w->fn(notif_wait, pkt, w->fn_data);
+
+                        if (!w->fn || w->fn(notif_wait, pkt, w->fn_data)) {
+                                w->triggered = true;
+                                triggered = true;
+                        }
                 }
                 spin_unlock(&notif_wait->notif_wait_lock);
 
-                wake_up_all(&notif_wait->notif_waitq);
         }
+
+        if (triggered)
+                wake_up_all(&notif_wait->notif_waitq);
 }
 
 void iwl_abort_notification_waits(struct iwl_notif_wait_data *notif_wait)
@@ -109,14 +133,18 @@ void iwl_abort_notification_waits(struct iwl_notif_wait_data *notif_wait)
 void
 iwl_init_notification_wait(struct iwl_notif_wait_data *notif_wait,
                            struct iwl_notification_wait *wait_entry,
-                           u8 cmd,
-                           void (*fn)(struct iwl_notif_wait_data *notif_wait,
+                           const u8 *cmds, int n_cmds,
+                           bool (*fn)(struct iwl_notif_wait_data *notif_wait,
                                       struct iwl_rx_packet *pkt, void *data),
                            void *fn_data)
 {
+        if (WARN_ON(n_cmds > MAX_NOTIF_CMDS))
+                n_cmds = MAX_NOTIF_CMDS;
+
         wait_entry->fn = fn;
         wait_entry->fn_data = fn_data;
-        wait_entry->cmd = cmd;
+        wait_entry->n_cmds = n_cmds;
+        memcpy(wait_entry->cmds, cmds, n_cmds);
         wait_entry->triggered = false;
         wait_entry->aborted = false;