scan.c 17.2 KB
Newer Older
1
/*
2 3
 * Scanning implementation
 *
4 5 6 7 8 9 10 11 12 13 14
 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
 * Copyright 2004, Instant802 Networks, Inc.
 * Copyright 2005, Devicescape Software, Inc.
 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
 * Copyright 2007, Michael Wu <flamingice@sourmilk.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.
 */

15
/* TODO: figure out how to avoid that the "current BSS" expires */
16

17 18
#include <linux/wireless.h>
#include <linux/if_arp.h>
19
#include <linux/rtnetlink.h>
20 21 22 23
#include <net/mac80211.h>
#include <net/iw_handler.h>

#include "ieee80211_i.h"
24
#include "driver-ops.h"
25
#include "mesh.h"
26 27 28

#define IEEE80211_PROBE_DELAY (HZ / 33)
#define IEEE80211_CHANNEL_TIME (HZ / 33)
29
#define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 8)
30

31
struct ieee80211_bss *
32 33 34
ieee80211_rx_bss_get(struct ieee80211_local *local, u8 *bssid, int freq,
		     u8 *ssid, u8 ssid_len)
{
35 36 37 38 39
	return (void *)cfg80211_get_bss(local->hw.wiphy,
					ieee80211_get_channel(local->hw.wiphy,
							      freq),
					bssid, ssid, ssid_len,
					0, 0);
40 41
}

42
static void ieee80211_rx_bss_free(struct cfg80211_bss *cbss)
43
{
44
	struct ieee80211_bss *bss = (void *)cbss;
45 46 47 48 49 50

	kfree(bss_mesh_id(bss));
	kfree(bss_mesh_cfg(bss));
}

void ieee80211_rx_bss_put(struct ieee80211_local *local,
51
			  struct ieee80211_bss *bss)
52
{
53
	cfg80211_put_bss((struct cfg80211_bss *)bss);
54 55
}

56
struct ieee80211_bss *
57 58 59 60 61
ieee80211_bss_info_update(struct ieee80211_local *local,
			  struct ieee80211_rx_status *rx_status,
			  struct ieee80211_mgmt *mgmt,
			  size_t len,
			  struct ieee802_11_elems *elems,
62 63
			  struct ieee80211_channel *channel,
			  bool beacon)
64
{
65
	struct ieee80211_bss *bss;
66
	int clen;
67 68
	s32 signal = 0;

Johannes Berg's avatar
Johannes Berg committed
69
	if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
70
		signal = rx_status->signal * 100;
Johannes Berg's avatar
Johannes Berg committed
71
	else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
72 73
		signal = (rx_status->signal * 100) / local->hw.max_signal;

74
	bss = (void *)cfg80211_inform_bss_frame(local->hw.wiphy, channel,
Johannes Berg's avatar
Johannes Berg committed
75
						mgmt, len, signal, GFP_ATOMIC);
76

77 78 79 80
	if (!bss)
		return NULL;

	bss->cbss.free_priv = ieee80211_rx_bss_free;
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

	/* save the ERP value so that it is available at association time */
	if (elems->erp_info && elems->erp_info_len >= 1) {
		bss->erp_value = elems->erp_info[0];
		bss->has_erp_value = 1;
	}

	if (elems->tim) {
		struct ieee80211_tim_ie *tim_ie =
			(struct ieee80211_tim_ie *)elems->tim;
		bss->dtim_period = tim_ie->dtim_period;
	}

	/* set default value for buggy APs */
	if (!elems->tim || bss->dtim_period == 0)
		bss->dtim_period = 1;

	bss->supp_rates_len = 0;
	if (elems->supp_rates) {
		clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len;
		if (clen > elems->supp_rates_len)
			clen = elems->supp_rates_len;
		memcpy(&bss->supp_rates[bss->supp_rates_len], elems->supp_rates,
		       clen);
		bss->supp_rates_len += clen;
	}
	if (elems->ext_supp_rates) {
		clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len;
		if (clen > elems->ext_supp_rates_len)
			clen = elems->ext_supp_rates_len;
		memcpy(&bss->supp_rates[bss->supp_rates_len],
		       elems->ext_supp_rates, clen);
		bss->supp_rates_len += clen;
	}

	bss->wmm_used = elems->wmm_param || elems->wmm_info;

	if (!beacon)
		bss->last_probe_resp = jiffies;

	return bss;
}
123

124 125 126 127 128 129 130 131
void ieee80211_rx_bss_remove(struct ieee80211_sub_if_data *sdata, u8 *bssid,
			     int freq, u8 *ssid, u8 ssid_len)
{
	struct ieee80211_bss *bss;
	struct ieee80211_local *local = sdata->local;

	bss = ieee80211_rx_bss_get(local, bssid, freq, ssid, ssid_len);
	if (bss) {
132
		cfg80211_unlink_bss(local->hw.wiphy, (void *)bss);
133 134 135 136
		ieee80211_rx_bss_put(local, bss);
	}
}

137
ieee80211_rx_result
138
ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
139
{
140
	struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
141
	struct ieee80211_mgmt *mgmt;
142
	struct ieee80211_bss *bss;
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
	u8 *elements;
	struct ieee80211_channel *channel;
	size_t baselen;
	int freq;
	__le16 fc;
	bool presp, beacon = false;
	struct ieee802_11_elems elems;

	if (skb->len < 2)
		return RX_DROP_UNUSABLE;

	mgmt = (struct ieee80211_mgmt *) skb->data;
	fc = mgmt->frame_control;

	if (ieee80211_is_ctl(fc))
		return RX_CONTINUE;

	if (skb->len < 24)
		return RX_DROP_MONITOR;

	presp = ieee80211_is_probe_resp(fc);
	if (presp) {
		/* ignore ProbeResp to foreign address */
		if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
			return RX_DROP_MONITOR;

		presp = true;
		elements = mgmt->u.probe_resp.variable;
		baselen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
	} else {
		beacon = ieee80211_is_beacon(fc);
		baselen = offsetof(struct ieee80211_mgmt, u.beacon.variable);
		elements = mgmt->u.beacon.variable;
	}

	if (!presp && !beacon)
		return RX_CONTINUE;

	if (baselen > skb->len)
		return RX_DROP_MONITOR;

	ieee802_11_parse_elems(elements, skb->len - baselen, &elems);

	if (elems.ds_params && elems.ds_params_len == 1)
		freq = ieee80211_channel_to_frequency(elems.ds_params[0]);
	else
		freq = rx_status->freq;

	channel = ieee80211_get_channel(sdata->local->hw.wiphy, freq);

	if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
		return RX_DROP_MONITOR;

	bss = ieee80211_bss_info_update(sdata->local, rx_status,
					mgmt, skb->len, &elems,
198
					channel, beacon);
199 200
	if (bss)
		ieee80211_rx_bss_put(sdata->local, bss);
201 202 203 204 205

	dev_kfree_skb(skb);
	return RX_QUEUED;
}

206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
/*
 * inform AP that we will go to sleep so that it will buffer the frames
 * while we scan
 */
static void ieee80211_scan_ps_enable(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;
	bool ps = false;

	/* FIXME: what to do when local->pspolling is true? */

	del_timer_sync(&local->dynamic_ps_timer);
	cancel_work_sync(&local->dynamic_ps_enable_work);

	if (local->hw.conf.flags & IEEE80211_CONF_PS) {
		ps = true;
		local->hw.conf.flags &= ~IEEE80211_CONF_PS;
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
	}

	if (!ps || !(local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK))
		/*
		 * If power save was enabled, no need to send a nullfunc
		 * frame because AP knows that we are sleeping. But if the
		 * hardware is creating the nullfunc frame for power save
		 * status (ie. IEEE80211_HW_PS_NULLFUNC_STACK is not
		 * enabled) and power save was enabled, the firmware just
		 * sent a null frame with power save disabled. So we need
		 * to send a new nullfunc frame to inform the AP that we
		 * are again sleeping.
		 */
		ieee80211_send_nullfunc(local, sdata, 1);
}

/* inform AP that we are awake again, unless power save is enabled */
static void ieee80211_scan_ps_disable(struct ieee80211_sub_if_data *sdata)
{
	struct ieee80211_local *local = sdata->local;

245
	if (!local->ps_sdata)
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
		ieee80211_send_nullfunc(local, sdata, 0);
	else {
		/*
		 * In !IEEE80211_HW_PS_NULLFUNC_STACK case the hardware
		 * will send a nullfunc frame with the powersave bit set
		 * even though the AP already knows that we are sleeping.
		 * This could be avoided by sending a null frame with power
		 * save bit disabled before enabling the power save, but
		 * this doesn't gain anything.
		 *
		 * When IEEE80211_HW_PS_NULLFUNC_STACK is enabled, no need
		 * to send a nullfunc frame because AP already knows that
		 * we are sleeping, let's just enable power save mode in
		 * hardware.
		 */
		local->hw.conf.flags |= IEEE80211_CONF_PS;
		ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
	}
}

266 267 268 269 270 271 272
static void ieee80211_restore_scan_ies(struct ieee80211_local *local)
{
	kfree(local->scan_req->ie);
	local->scan_req->ie = local->orig_ies;
	local->scan_req->ie_len = local->orig_ies_len;
}

273
void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
274 275 276
{
	struct ieee80211_local *local = hw_to_local(hw);
	struct ieee80211_sub_if_data *sdata;
277
	bool was_hw_scan;
278

279
	mutex_lock(&local->scan_mtx);
280

281 282
	if (WARN_ON(!local->hw_scanning && !local->sw_scanning)) {
		mutex_unlock(&local->scan_mtx);
283
		return;
284
	}
285

286 287 288
	if (WARN_ON(!local->scan_req)) {
		mutex_unlock(&local->scan_mtx);
		return;
289 290
	}

291 292 293
	if (local->hw_scanning)
		ieee80211_restore_scan_ies(local);

294 295 296 297
	if (local->scan_req != &local->int_scan_req)
		cfg80211_scan_done(local->scan_req, aborted);
	local->scan_req = NULL;

298 299 300
	was_hw_scan = local->hw_scanning;
	local->hw_scanning = false;
	local->sw_scanning = false;
301
	local->scan_channel = NULL;
302 303 304 305

	/* we only have to protect scan_req and hw/sw scan */
	mutex_unlock(&local->scan_mtx);

306
	ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
307 308
	if (was_hw_scan)
		goto done;
309 310 311 312

	netif_tx_lock_bh(local->mdev);
	netif_addr_lock(local->mdev);
	local->filter_flags &= ~FIF_BCN_PRBRESP_PROMISC;
313 314 315 316
	drv_configure_filter(local, FIF_BCN_PRBRESP_PROMISC,
			     &local->filter_flags,
			     local->mdev->mc_count,
			     local->mdev->mc_list);
317 318 319 320

	netif_addr_unlock(local->mdev);
	netif_tx_unlock_bh(local->mdev);

321
	drv_sw_scan_complete(local);
322

323 324
	mutex_lock(&local->iflist_mtx);
	list_for_each_entry(sdata, &local->interfaces, list) {
325 326 327
		if (!netif_running(sdata->dev))
			continue;

328
		/* Tell AP we're back */
329
		if (sdata->vif.type == NL80211_IFTYPE_STATION) {
330
			if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED) {
331
				ieee80211_scan_ps_disable(sdata);
332 333 334 335
				netif_tx_wake_all_queues(sdata->dev);
			}
		} else
			netif_tx_wake_all_queues(sdata->dev);
336

337 338 339 340
		/* re-enable beaconing */
		if (sdata->vif.type == NL80211_IFTYPE_AP ||
		    sdata->vif.type == NL80211_IFTYPE_ADHOC ||
		    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
341 342
			ieee80211_bss_info_change_notify(
				sdata, BSS_CHANGED_BEACON_ENABLED);
343
	}
344
	mutex_unlock(&local->iflist_mtx);
345 346

 done:
347
	ieee80211_recalc_idle(local);
348
	ieee80211_mlme_notify_scan_completed(local);
349
	ieee80211_ibss_notify_scan_completed(local);
350
	ieee80211_mesh_notify_scan_completed(local);
351 352 353
}
EXPORT_SYMBOL(ieee80211_scan_completed);

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
static int ieee80211_start_sw_scan(struct ieee80211_local *local)
{
	struct ieee80211_sub_if_data *sdata;

	/*
	 * Hardware/driver doesn't support hw_scan, so use software
	 * scanning instead. First send a nullfunc frame with power save
	 * bit on so that AP will buffer the frames for us while we are not
	 * listening, then send probe requests to each channel and wait for
	 * the responses. After all channels are scanned, tune back to the
	 * original channel and send a nullfunc frame with power save bit
	 * off to trigger the AP to send us all the buffered frames.
	 *
	 * Note that while local->sw_scanning is true everything else but
	 * nullfunc frames and probe requests will be dropped in
	 * ieee80211_tx_h_check_assoc().
	 */
371
	drv_sw_scan_start(local);
372 373 374 375 376 377 378 379 380 381

	mutex_lock(&local->iflist_mtx);
	list_for_each_entry(sdata, &local->interfaces, list) {
		if (!netif_running(sdata->dev))
			continue;

		/* disable beaconing */
		if (sdata->vif.type == NL80211_IFTYPE_AP ||
		    sdata->vif.type == NL80211_IFTYPE_ADHOC ||
		    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
382 383
			ieee80211_bss_info_change_notify(
				sdata, BSS_CHANGED_BEACON_ENABLED);
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399

		if (sdata->vif.type == NL80211_IFTYPE_STATION) {
			if (sdata->u.mgd.flags & IEEE80211_STA_ASSOCIATED) {
				netif_tx_stop_all_queues(sdata->dev);
				ieee80211_scan_ps_enable(sdata);
			}
		} else
			netif_tx_stop_all_queues(sdata->dev);
	}
	mutex_unlock(&local->iflist_mtx);

	local->scan_state = SCAN_SET_CHANNEL;
	local->scan_channel_idx = 0;

	netif_addr_lock_bh(local->mdev);
	local->filter_flags |= FIF_BCN_PRBRESP_PROMISC;
400 401 402 403
	drv_configure_filter(local, FIF_BCN_PRBRESP_PROMISC,
			     &local->filter_flags,
			     local->mdev->mc_count,
			     local->mdev->mc_list);
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
	netif_addr_unlock_bh(local->mdev);

	/* TODO: start scan as soon as all nullfunc frames are ACKed */
	queue_delayed_work(local->hw.workqueue, &local->scan_work,
			   IEEE80211_CHANNEL_TIME);

	return 0;
}


static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
				  struct cfg80211_scan_request *req)
{
	struct ieee80211_local *local = sdata->local;
	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
	int rc;

	if (local->scan_req)
		return -EBUSY;

	if (local->ops->hw_scan) {
		u8 *ies;
		int ielen;

		ies = kmalloc(2 + IEEE80211_MAX_SSID_LEN +
			      local->scan_ies_len + req->ie_len, GFP_KERNEL);
		if (!ies)
			return -ENOMEM;

		ielen = ieee80211_build_preq_ies(local, ies,
						 req->ie, req->ie_len);
		local->orig_ies = req->ie;
		local->orig_ies_len = req->ie_len;
		req->ie = ies;
		req->ie_len = ielen;
	}

	local->scan_req = req;
	local->scan_sdata = sdata;

	if (req != &local->int_scan_req &&
	    sdata->vif.type == NL80211_IFTYPE_STATION &&
	    (ifmgd->state == IEEE80211_STA_MLME_DIRECT_PROBE ||
	     ifmgd->state == IEEE80211_STA_MLME_AUTHENTICATE ||
	     ifmgd->state == IEEE80211_STA_MLME_ASSOCIATE)) {
		/* actually wait for the assoc to finish/time out */
		set_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request);
		return 0;
	}

	if (local->ops->hw_scan)
		local->hw_scanning = true;
	else
		local->sw_scanning = true;
	/*
	 * Kicking off the scan need not be protected,
	 * only the scan variable stuff, since now
	 * local->scan_req is assigned and other callers
	 * will abort their scan attempts.
	 *
	 * This avoids getting a scan_mtx -> iflist_mtx
	 * dependency, so that the scan completed calls
	 * have more locking freedom.
	 */
468 469

	ieee80211_recalc_idle(local);
470 471 472
	mutex_unlock(&local->scan_mtx);

	if (local->ops->hw_scan)
473
		rc = drv_hw_scan(local, local->scan_req);
474 475 476 477 478 479 480 481 482 483 484 485
	else
		rc = ieee80211_start_sw_scan(local);

	mutex_lock(&local->scan_mtx);

	if (rc) {
		if (local->ops->hw_scan) {
			local->hw_scanning = false;
			ieee80211_restore_scan_ies(local);
		} else
			local->sw_scanning = false;

486 487
		ieee80211_recalc_idle(local);

488 489 490 491 492 493 494
		local->scan_req = NULL;
		local->scan_sdata = NULL;
	}

	return rc;
}

495
void ieee80211_scan_work(struct work_struct *work)
496 497 498 499 500
{
	struct ieee80211_local *local =
		container_of(work, struct ieee80211_local, scan_work.work);
	struct ieee80211_sub_if_data *sdata = local->scan_sdata;
	struct ieee80211_channel *chan;
501
	int skip, i;
502 503
	unsigned long next_delay = 0;

504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
	mutex_lock(&local->scan_mtx);
	if (!sdata || !local->scan_req) {
		mutex_unlock(&local->scan_mtx);
		return;
	}

	if (local->scan_req && !(local->sw_scanning || local->hw_scanning)) {
		struct cfg80211_scan_request *req = local->scan_req;
		int rc;

		local->scan_req = NULL;

		rc = __ieee80211_start_scan(sdata, req);
		mutex_unlock(&local->scan_mtx);

		if (rc)
			ieee80211_scan_completed(&local->hw, true);
		return;
	}

	mutex_unlock(&local->scan_mtx);

526 527 528
	/*
	 * Avoid re-scheduling when the sdata is going away.
	 */
529 530
	if (!netif_running(sdata->dev)) {
		ieee80211_scan_completed(&local->hw, true);
531
		return;
532
	}
533 534 535 536

	switch (local->scan_state) {
	case SCAN_SET_CHANNEL:
		/* if no more bands/channels left, complete scan */
537
		if (local->scan_channel_idx >= local->scan_req->n_channels) {
538
			ieee80211_scan_completed(&local->hw, false);
539 540 541
			return;
		}
		skip = 0;
542
		chan = local->scan_req->channels[local->scan_channel_idx];
543 544

		if (chan->flags & IEEE80211_CHAN_DISABLED ||
545
		    (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
546 547 548 549 550
		     chan->flags & IEEE80211_CHAN_NO_IBSS))
			skip = 1;

		if (!skip) {
			local->scan_channel = chan;
551 552
			if (ieee80211_hw_config(local,
						IEEE80211_CONF_CHANGE_CHANNEL))
553 554 555 556 557 558 559 560 561
				skip = 1;
		}

		/* advance state machine to next channel/band */
		local->scan_channel_idx++;

		if (skip)
			break;

Johannes Berg's avatar
Johannes Berg committed
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
		/*
		 * Probe delay is used to update the NAV, cf. 11.1.3.2.2
		 * (which unfortunately doesn't say _why_ step a) is done,
		 * but it waits for the probe delay or until a frame is
		 * received - and the received frame would update the NAV).
		 * For now, we do not support waiting until a frame is
		 * received.
		 *
		 * In any case, it is not necessary for a passive scan.
		 */
		if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
		    !local->scan_req->n_ssids) {
			next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
			break;
		}

		next_delay = IEEE80211_PROBE_DELAY;
579 580 581
		local->scan_state = SCAN_SEND_PROBE;
		break;
	case SCAN_SEND_PROBE:
582 583 584 585
		for (i = 0; i < local->scan_req->n_ssids; i++)
			ieee80211_send_probe_req(
				sdata, NULL,
				local->scan_req->ssids[i].ssid,
586 587
				local->scan_req->ssids[i].ssid_len,
				local->scan_req->ie, local->scan_req->ie_len);
Johannes Berg's avatar
Johannes Berg committed
588 589 590 591 592

		/*
		 * After sending probe requests, wait for probe responses
		 * on the channel.
		 */
593
		next_delay = IEEE80211_CHANNEL_TIME;
Johannes Berg's avatar
Johannes Berg committed
594
		local->scan_state = SCAN_SET_CHANNEL;
595 596 597
		break;
	}

598 599
	queue_delayed_work(local->hw.workqueue, &local->scan_work,
			   next_delay);
600 601
}

602 603
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
			   struct cfg80211_scan_request *req)
604
{
605
	int res;
606

607 608 609
	mutex_lock(&sdata->local->scan_mtx);
	res = __ieee80211_start_scan(sdata, req);
	mutex_unlock(&sdata->local->scan_mtx);
610

611
	return res;
612 613
}

614 615
int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
				    const u8 *ssid, u8 ssid_len)
616 617
{
	struct ieee80211_local *local = sdata->local;
618
	int ret = -EBUSY;
619

620
	mutex_lock(&local->scan_mtx);
621

622 623 624
	/* busy scanning */
	if (local->scan_req)
		goto unlock;
Johannes Berg's avatar
Johannes Berg committed
625

626 627
	memcpy(local->int_scan_req.ssids[0].ssid, ssid, IEEE80211_MAX_SSID_LEN);
	local->int_scan_req.ssids[0].ssid_len = ssid_len;
Johannes Berg's avatar
Johannes Berg committed
628

629 630 631 632
	ret = __ieee80211_start_scan(sdata, &sdata->local->int_scan_req);
 unlock:
	mutex_unlock(&local->scan_mtx);
	return ret;
633
}
634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651

void ieee80211_scan_cancel(struct ieee80211_local *local)
{
	bool swscan;

	cancel_delayed_work_sync(&local->scan_work);

	/*
	 * Only call this function when a scan can't be
	 * queued -- mostly at suspend under RTNL.
	 */
	mutex_lock(&local->scan_mtx);
	swscan = local->sw_scanning;
	mutex_unlock(&local->scan_mtx);

	if (swscan)
		ieee80211_scan_completed(&local->hw, true);
}