1/* 2 * Scanning routines. 3 * 4 * These are not exported because they're assigned to the function pointers. 5 * 6 * Copyright (c) 2005, 2006 Johannes Berg <johannes@sipsolutions.net> 7 * Joseph Jezak <josejx@gentoo.org> 8 * Larry Finger <Larry.Finger@lwfinger.net> 9 * Danny van Dyk <kugelfang@gentoo.org> 10 * Michael Buesch <mbuesch@freenet.de> 11 * 12 * This program is free software; you can redistribute it and/or modify it 13 * under the terms of version 2 of the GNU General Public License as 14 * published by the Free Software Foundation. 15 * 16 * This program is distributed in the hope that it will be useful, but WITHOUT 17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 19 * more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 24 * 25 * The full GNU General Public License is included in this distribution in the 26 * file called COPYING. 27 */ 28 29#include <linux/completion.h> 30#include "ieee80211softmac_priv.h" 31 32/* internal, use to trigger scanning if needed. 33 * Returns -EBUSY if already scanning, 34 * result of start_scan otherwise */ 35int 36ieee80211softmac_start_scan(struct ieee80211softmac_device *sm) 37{ 38 unsigned long flags; 39 int ret; 40 41 spin_lock_irqsave(&sm->lock, flags); 42 if (sm->scanning) 43 { 44 spin_unlock_irqrestore(&sm->lock, flags); 45 return -EINPROGRESS; 46 } 47 sm->scanning = 1; 48 spin_unlock_irqrestore(&sm->lock, flags); 49 50 ret = sm->start_scan(sm->dev); 51 if (ret) { 52 spin_lock_irqsave(&sm->lock, flags); 53 sm->scanning = 0; 54 spin_unlock_irqrestore(&sm->lock, flags); 55 } 56 return ret; 57} 58 59void 60ieee80211softmac_stop_scan(struct ieee80211softmac_device *sm) 61{ 62 unsigned long flags; 63 64 spin_lock_irqsave(&sm->lock, flags); 65 66 if (!sm->scanning) { 67 spin_unlock_irqrestore(&sm->lock, flags); 68 return; 69 } 70 71 spin_unlock_irqrestore(&sm->lock, flags); 72 sm->stop_scan(sm->dev); 73} 74 75void 76ieee80211softmac_wait_for_scan(struct ieee80211softmac_device *sm) 77{ 78 unsigned long flags; 79 80 spin_lock_irqsave(&sm->lock, flags); 81 82 if (!sm->scanning) { 83 spin_unlock_irqrestore(&sm->lock, flags); 84 return; 85 } 86 87 spin_unlock_irqrestore(&sm->lock, flags); 88 sm->wait_for_scan(sm->dev); 89} 90 91 92/* internal scanning implementation follows */ 93void ieee80211softmac_scan(struct work_struct *work) 94{ 95 int invalid_channel; 96 u8 current_channel_idx; 97 struct ieee80211softmac_scaninfo *si = 98 container_of(work, struct ieee80211softmac_scaninfo, 99 softmac_scan.work); 100 struct ieee80211softmac_device *sm = si->mac; 101 unsigned long flags; 102 103 while (!(si->stop) && (si->current_channel_idx < si->number_channels)) { 104 current_channel_idx = si->current_channel_idx; 105 si->current_channel_idx++; /* go to the next channel */ 106 107 invalid_channel = (si->skip_flags & si->channels[current_channel_idx].flags); 108 109 if (!invalid_channel) { 110 sm->set_channel(sm->dev, si->channels[current_channel_idx].channel); 111 if(ieee80211softmac_send_mgt_frame(sm, NULL, IEEE80211_STYPE_PROBE_REQ, 0)) 112 printkl(KERN_DEBUG PFX "Sending Probe Request Failed\n"); 113 114 /* also send directed management frame for the network we're looking for */ 115 // TODO: is this if correct, or should we do this only if scanning from assoc request? 116 if (sm->associnfo.req_essid.len) 117 ieee80211softmac_send_mgt_frame(sm, &sm->associnfo.req_essid, IEEE80211_STYPE_PROBE_REQ, 0); 118 119 spin_lock_irqsave(&sm->lock, flags); 120 if (unlikely(!sm->running)) { 121 /* Prevent reschedule on workqueue flush */ 122 spin_unlock_irqrestore(&sm->lock, flags); 123 break; 124 } 125 schedule_delayed_work(&si->softmac_scan, IEEE80211SOFTMAC_PROBE_DELAY); 126 spin_unlock_irqrestore(&sm->lock, flags); 127 return; 128 } else { 129 dprintk(PFX "Not probing Channel %d (not allowed here)\n", si->channels[current_channel_idx].channel); 130 } 131 } 132 133 spin_lock_irqsave(&sm->lock, flags); 134 cancel_delayed_work(&si->softmac_scan); 135 si->started = 0; 136 spin_unlock_irqrestore(&sm->lock, flags); 137 138 dprintk(PFX "Scanning finished: scanned %d channels starting with channel %d\n", 139 sm->scaninfo->number_channels, sm->scaninfo->channels[0].channel); 140 ieee80211softmac_scan_finished(sm); 141 complete_all(&sm->scaninfo->finished); 142} 143 144static inline struct ieee80211softmac_scaninfo *allocate_scaninfo(struct ieee80211softmac_device *mac) 145{ 146 /* ugh. can we call this without having the spinlock held? */ 147 struct ieee80211softmac_scaninfo *info = kmalloc(sizeof(struct ieee80211softmac_scaninfo), GFP_ATOMIC); 148 if (unlikely(!info)) 149 return NULL; 150 INIT_DELAYED_WORK(&info->softmac_scan, ieee80211softmac_scan); 151 info->mac = mac; 152 init_completion(&info->finished); 153 return info; 154} 155 156int ieee80211softmac_start_scan_implementation(struct net_device *dev) 157{ 158 struct ieee80211softmac_device *sm = ieee80211_priv(dev); 159 unsigned long flags; 160 161 if (!(dev->flags & IFF_UP)) 162 return -ENODEV; 163 164 assert(ieee80211softmac_scan_handlers_check_self(sm)); 165 if (!ieee80211softmac_scan_handlers_check_self(sm)) 166 return -EINVAL; 167 168 spin_lock_irqsave(&sm->lock, flags); 169 /* it looks like we need to hold the lock here 170 * to make sure we don't allocate two of these... */ 171 if (unlikely(!sm->scaninfo)) 172 sm->scaninfo = allocate_scaninfo(sm); 173 if (unlikely(!sm->scaninfo)) { 174 spin_unlock_irqrestore(&sm->lock, flags); 175 return -ENOMEM; 176 } 177 178 sm->scaninfo->skip_flags = IEEE80211_CH_INVALID; 179 if (0 /* not scanning in IEEE802.11b */)//TODO 180 sm->scaninfo->skip_flags |= IEEE80211_CH_B_ONLY; 181 if (0 /* IEEE802.11a */) {//TODO 182 sm->scaninfo->channels = sm->ieee->geo.a; 183 sm->scaninfo->number_channels = sm->ieee->geo.a_channels; 184 } else { 185 sm->scaninfo->channels = sm->ieee->geo.bg; 186 sm->scaninfo->number_channels = sm->ieee->geo.bg_channels; 187 } 188 sm->scaninfo->current_channel_idx = 0; 189 sm->scaninfo->started = 1; 190 sm->scaninfo->stop = 0; 191 INIT_COMPLETION(sm->scaninfo->finished); 192 schedule_delayed_work(&sm->scaninfo->softmac_scan, 0); 193 spin_unlock_irqrestore(&sm->lock, flags); 194 return 0; 195} 196 197void ieee80211softmac_stop_scan_implementation(struct net_device *dev) 198{ 199 struct ieee80211softmac_device *sm = ieee80211_priv(dev); 200 unsigned long flags; 201 202 assert(ieee80211softmac_scan_handlers_check_self(sm)); 203 if (!ieee80211softmac_scan_handlers_check_self(sm)) 204 return; 205 206 spin_lock_irqsave(&sm->lock, flags); 207 assert(sm->scaninfo != NULL); 208 if (sm->scaninfo) { 209 if (sm->scaninfo->started) 210 sm->scaninfo->stop = 1; 211 else 212 complete_all(&sm->scaninfo->finished); 213 } 214 spin_unlock_irqrestore(&sm->lock, flags); 215} 216 217void ieee80211softmac_wait_for_scan_implementation(struct net_device *dev) 218{ 219 struct ieee80211softmac_device *sm = ieee80211_priv(dev); 220 unsigned long flags; 221 222 assert(ieee80211softmac_scan_handlers_check_self(sm)); 223 if (!ieee80211softmac_scan_handlers_check_self(sm)) 224 return; 225 226 spin_lock_irqsave(&sm->lock, flags); 227 if (!sm->scaninfo->started) { 228 spin_unlock_irqrestore(&sm->lock, flags); 229 return; 230 } 231 spin_unlock_irqrestore(&sm->lock, flags); 232 wait_for_completion(&sm->scaninfo->finished); 233} 234 235/* this is what drivers (that do scanning) call when they're done */ 236void ieee80211softmac_scan_finished(struct ieee80211softmac_device *sm) 237{ 238 unsigned long flags; 239 240 spin_lock_irqsave(&sm->lock, flags); 241 sm->scanning = 0; 242 spin_unlock_irqrestore(&sm->lock, flags); 243 244 if (sm->associnfo.bssvalid) { 245 struct ieee80211softmac_network *net; 246 247 net = ieee80211softmac_get_network_by_bssid(sm, sm->associnfo.bssid); 248 if (net) 249 sm->set_channel(sm->dev, net->channel); 250 } 251 ieee80211softmac_call_events(sm, IEEE80211SOFTMAC_EVENT_SCAN_FINISHED, NULL); 252} 253EXPORT_SYMBOL_GPL(ieee80211softmac_scan_finished); 254