Merge branch 'linus'

1 files changed, 244 insertions, 0 deletions

diff --git a/net/ieee80211/softmac/ieee80211softmac_scan.c b/net/ieee80211/softmac/ieee80211softmac_scan.c
new file mode 100644
index 000000000000..bb9ab8b45d09
--- /dev/null
+++ b/net/ieee80211/softmac/ieee80211softmac_scan.c
@@ -0,0 +1,244 @@
+/*
+ * Scanning routines.
+ *
+ * These are not exported because they're assigned to the function pointers.
+ *
+ * Copyright (c) 2005, 2006 Johannes Berg <johannes@sipsolutions.net>
+ *                          Joseph Jezak <josejx@gentoo.org>
+ *                          Larry Finger <Larry.Finger@lwfinger.net>
+ *                          Danny van Dyk <kugelfang@gentoo.org>
+ *                          Michael Buesch <mbuesch@freenet.de>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ *
+ * The full GNU General Public License is included in this distribution in the
+ * file called COPYING.
+ */
+
+#include <linux/completion.h>
+#include "ieee80211softmac_priv.h"
+
+/* internal, use to trigger scanning if needed.
+ * Returns -EBUSY if already scanning,
+ * result of start_scan otherwise */
+int
+ieee80211softmac_start_scan(struct ieee80211softmac_device *sm)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&sm->lock, flags);
+        if (sm->scanning)
+        {
+                spin_unlock_irqrestore(&sm->lock, flags);
+                return -EINPROGRESS;
+        }
+        sm->scanning = 1;
+        spin_unlock_irqrestore(&sm->lock, flags);
+
+        ret = sm->start_scan(sm->dev);
+        if (ret) {
+                spin_lock_irqsave(&sm->lock, flags);
+                sm->scanning = 0;
+                spin_unlock_irqrestore(&sm->lock, flags);
+        }
+        return ret;
+}
+
+void
+ieee80211softmac_stop_scan(struct ieee80211softmac_device *sm)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&sm->lock, flags);
+        
+        if (!sm->scanning) {
+                spin_unlock_irqrestore(&sm->lock, flags);
+                return;
+        }
+        
+        spin_unlock_irqrestore(&sm->lock, flags);
+        sm->stop_scan(sm->dev);
+}
+
+void
+ieee80211softmac_wait_for_scan(struct ieee80211softmac_device *sm)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&sm->lock, flags);
+        
+        if (!sm->scanning) {
+                spin_unlock_irqrestore(&sm->lock, flags);
+                return;
+        }
+        
+        spin_unlock_irqrestore(&sm->lock, flags);
+        sm->wait_for_scan(sm->dev);
+}
+
+
+/* internal scanning implementation follows */
+void ieee80211softmac_scan(void *d)
+{
+        int invalid_channel;
+        u8 current_channel_idx;
+        struct ieee80211softmac_device *sm = (struct ieee80211softmac_device *)d;
+        struct ieee80211softmac_scaninfo *si = sm->scaninfo;
+        unsigned long flags;
+
+        while (!(si->stop) && (si->current_channel_idx < si->number_channels)) {
+                current_channel_idx = si->current_channel_idx;
+                si->current_channel_idx++; /* go to the next channel */
+
+                invalid_channel = (si->skip_flags & si->channels[current_channel_idx].flags);
+
+                if (!invalid_channel) {
+                        sm->set_channel(sm->dev, si->channels[current_channel_idx].channel);
+                        // FIXME make this user configurable (active/passive)
+                        if(ieee80211softmac_send_mgt_frame(sm, NULL, IEEE80211_STYPE_PROBE_REQ, 0))
+                                printkl(KERN_DEBUG PFX "Sending Probe Request Failed\n");
+
+                        /* also send directed management frame for the network we're looking for */
+                        // TODO: is this if correct, or should we do this only if scanning from assoc request?
+                        if (sm->associnfo.req_essid.len)
+                                ieee80211softmac_send_mgt_frame(sm, &sm->associnfo.req_essid, IEEE80211_STYPE_PROBE_REQ, 0);
+                        schedule_delayed_work(&si->softmac_scan, IEEE80211SOFTMAC_PROBE_DELAY);
+                        return;
+                } else {
+                        dprintk(PFX "Not probing Channel %d (not allowed here)\n", si->channels[current_channel_idx].channel);
+                }
+        }
+
+        spin_lock_irqsave(&sm->lock, flags);
+        cancel_delayed_work(&si->softmac_scan);
+        si->started = 0;
+        spin_unlock_irqrestore(&sm->lock, flags);
+
+        dprintk(PFX "Scanning finished\n");
+        ieee80211softmac_scan_finished(sm);
+        complete_all(&sm->scaninfo->finished);
+}
+
+static inline struct ieee80211softmac_scaninfo *allocate_scaninfo(struct ieee80211softmac_device *mac)
+{
+        /* ugh. can we call this without having the spinlock held? */
+        struct ieee80211softmac_scaninfo *info = kmalloc(sizeof(struct ieee80211softmac_scaninfo), GFP_ATOMIC);
+        if (unlikely(!info))
+                return NULL;
+        INIT_WORK(&info->softmac_scan, ieee80211softmac_scan, mac);
+        init_completion(&info->finished);
+        return info;
+}
+
+int ieee80211softmac_start_scan_implementation(struct net_device *dev)
+{
+        struct ieee80211softmac_device *sm = ieee80211_priv(dev);
+        unsigned long flags;
+        
+        if (!(dev->flags & IFF_UP))
+                return -ENODEV;
+
+        assert(ieee80211softmac_scan_handlers_check_self(sm));
+        if (!ieee80211softmac_scan_handlers_check_self(sm))
+                return -EINVAL;
+                
+        spin_lock_irqsave(&sm->lock, flags);
+        /* it looks like we need to hold the lock here
+         * to make sure we don't allocate two of these... */
+        if (unlikely(!sm->scaninfo))
+                sm->scaninfo = allocate_scaninfo(sm);
+        if (unlikely(!sm->scaninfo)) {
+                spin_unlock_irqrestore(&sm->lock, flags);
+                return -ENOMEM;
+        }
+
+        sm->scaninfo->skip_flags = IEEE80211_CH_INVALID;
+        if (0 /* not scanning in IEEE802.11b */)//TODO
+                sm->scaninfo->skip_flags |= IEEE80211_CH_B_ONLY;
+        if (0 /* IEEE802.11a */) {//TODO
+                sm->scaninfo->channels = sm->ieee->geo.a;
+                sm->scaninfo->number_channels = sm->ieee->geo.a_channels;
+        } else {
+                sm->scaninfo->channels = sm->ieee->geo.bg;
+                sm->scaninfo->number_channels = sm->ieee->geo.bg_channels;
+        }
+        dprintk(PFX "Start scanning with channel: %d\n", sm->scaninfo->channels[0].channel);
+        dprintk(PFX "Scanning %d channels\n", sm->scaninfo->number_channels);
+        sm->scaninfo->current_channel_idx = 0;
+        sm->scaninfo->started = 1;
+        sm->scaninfo->stop = 0;
+        INIT_COMPLETION(sm->scaninfo->finished);
+        schedule_work(&sm->scaninfo->softmac_scan);
+        spin_unlock_irqrestore(&sm->lock, flags);
+        return 0;
+}
+
+void ieee80211softmac_stop_scan_implementation(struct net_device *dev)
+{
+        struct ieee80211softmac_device *sm = ieee80211_priv(dev);
+        unsigned long flags;
+
+        assert(ieee80211softmac_scan_handlers_check_self(sm));
+        if (!ieee80211softmac_scan_handlers_check_self(sm))
+                return;
+
+        spin_lock_irqsave(&sm->lock, flags);
+        assert(sm->scaninfo != NULL);
+        if (sm->scaninfo) {
+                if (sm->scaninfo->started)
+                        sm->scaninfo->stop = 1;
+                else
+                        complete_all(&sm->scaninfo->finished);
+        }
+        spin_unlock_irqrestore(&sm->lock, flags);
+}
+
+void ieee80211softmac_wait_for_scan_implementation(struct net_device *dev)
+{
+        struct ieee80211softmac_device *sm = ieee80211_priv(dev);
+        unsigned long flags;
+
+        assert(ieee80211softmac_scan_handlers_check_self(sm));
+        if (!ieee80211softmac_scan_handlers_check_self(sm))
+                return;
+
+        spin_lock_irqsave(&sm->lock, flags);
+        if (!sm->scaninfo->started) {
+                spin_unlock_irqrestore(&sm->lock, flags);
+                return;
+        }
+        spin_unlock_irqrestore(&sm->lock, flags);
+        wait_for_completion(&sm->scaninfo->finished);
+}
+
+/* this is what drivers (that do scanning) call when they're done */
+void ieee80211softmac_scan_finished(struct ieee80211softmac_device *sm)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&sm->lock, flags);
+        sm->scanning = 0;
+        spin_unlock_irqrestore(&sm->lock, flags);
+        
+        if (sm->associnfo.bssvalid) {
+                struct ieee80211softmac_network *net;
+
+                net = ieee80211softmac_get_network_by_bssid(sm, sm->associnfo.bssid);
+                if (net)
+                        sm->set_channel(sm->dev, net->channel);
+        }
+        ieee80211softmac_call_events(sm, IEEE80211SOFTMAC_EVENT_SCAN_FINISHED, NULL);
+}
+EXPORT_SYMBOL_GPL(ieee80211softmac_scan_finished);