scan.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799
  1. /*
  2. * Scanning implementation
  3. *
  4. * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi>
  5. * Copyright 2004, Instant802 Networks, Inc.
  6. * Copyright 2005, Devicescape Software, Inc.
  7. * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
  8. * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License version 2 as
  12. * published by the Free Software Foundation.
  13. */
  14. #include <linux/if_arp.h>
  15. #include <linux/rtnetlink.h>
  16. #include <linux/pm_qos_params.h>
  17. #include <net/sch_generic.h>
  18. #include <linux/slab.h>
  19. #include <net/mac80211.h>
  20. #include "ieee80211_i.h"
  21. #include "driver-ops.h"
  22. #include "mesh.h"
  23. #define IEEE80211_PROBE_DELAY (HZ / 33)
  24. #define IEEE80211_CHANNEL_TIME (HZ / 33)
  25. #define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 8)
  26. struct ieee80211_bss *
  27. ieee80211_rx_bss_get(struct ieee80211_local *local, u8 *bssid, int freq,
  28. u8 *ssid, u8 ssid_len)
  29. {
  30. struct cfg80211_bss *cbss;
  31. cbss = cfg80211_get_bss(local->hw.wiphy,
  32. ieee80211_get_channel(local->hw.wiphy, freq),
  33. bssid, ssid, ssid_len, 0, 0);
  34. if (!cbss)
  35. return NULL;
  36. return (void *)cbss->priv;
  37. }
  38. static void ieee80211_rx_bss_free(struct cfg80211_bss *cbss)
  39. {
  40. struct ieee80211_bss *bss = (void *)cbss->priv;
  41. kfree(bss_mesh_id(bss));
  42. kfree(bss_mesh_cfg(bss));
  43. }
  44. void ieee80211_rx_bss_put(struct ieee80211_local *local,
  45. struct ieee80211_bss *bss)
  46. {
  47. if (!bss)
  48. return;
  49. cfg80211_put_bss(container_of((void *)bss, struct cfg80211_bss, priv));
  50. }
  51. static bool is_uapsd_supported(struct ieee802_11_elems *elems)
  52. {
  53. u8 qos_info;
  54. if (elems->wmm_info && elems->wmm_info_len == 7
  55. && elems->wmm_info[5] == 1)
  56. qos_info = elems->wmm_info[6];
  57. else if (elems->wmm_param && elems->wmm_param_len == 24
  58. && elems->wmm_param[5] == 1)
  59. qos_info = elems->wmm_param[6];
  60. else
  61. /* no valid wmm information or parameter element found */
  62. return false;
  63. return qos_info & IEEE80211_WMM_IE_AP_QOSINFO_UAPSD;
  64. }
  65. struct ieee80211_bss *
  66. ieee80211_bss_info_update(struct ieee80211_local *local,
  67. struct ieee80211_rx_status *rx_status,
  68. struct ieee80211_mgmt *mgmt,
  69. size_t len,
  70. struct ieee802_11_elems *elems,
  71. struct ieee80211_channel *channel,
  72. bool beacon)
  73. {
  74. struct cfg80211_bss *cbss;
  75. struct ieee80211_bss *bss;
  76. int clen, srlen;
  77. s32 signal = 0;
  78. if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
  79. signal = rx_status->signal * 100;
  80. else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
  81. signal = (rx_status->signal * 100) / local->hw.max_signal;
  82. cbss = cfg80211_inform_bss_frame(local->hw.wiphy, channel,
  83. mgmt, len, signal, GFP_ATOMIC);
  84. if (!cbss)
  85. return NULL;
  86. cbss->free_priv = ieee80211_rx_bss_free;
  87. bss = (void *)cbss->priv;
  88. /* save the ERP value so that it is available at association time */
  89. if (elems->erp_info && elems->erp_info_len >= 1) {
  90. bss->erp_value = elems->erp_info[0];
  91. bss->has_erp_value = 1;
  92. }
  93. if (elems->tim) {
  94. struct ieee80211_tim_ie *tim_ie =
  95. (struct ieee80211_tim_ie *)elems->tim;
  96. bss->dtim_period = tim_ie->dtim_period;
  97. }
  98. /* If the beacon had no TIM IE, or it was invalid, use 1 */
  99. if (beacon && !bss->dtim_period)
  100. bss->dtim_period = 1;
  101. /* replace old supported rates if we get new values */
  102. srlen = 0;
  103. if (elems->supp_rates) {
  104. clen = IEEE80211_MAX_SUPP_RATES;
  105. if (clen > elems->supp_rates_len)
  106. clen = elems->supp_rates_len;
  107. memcpy(bss->supp_rates, elems->supp_rates, clen);
  108. srlen += clen;
  109. }
  110. if (elems->ext_supp_rates) {
  111. clen = IEEE80211_MAX_SUPP_RATES - srlen;
  112. if (clen > elems->ext_supp_rates_len)
  113. clen = elems->ext_supp_rates_len;
  114. memcpy(bss->supp_rates + srlen, elems->ext_supp_rates, clen);
  115. srlen += clen;
  116. }
  117. if (srlen)
  118. bss->supp_rates_len = srlen;
  119. bss->wmm_used = elems->wmm_param || elems->wmm_info;
  120. bss->uapsd_supported = is_uapsd_supported(elems);
  121. if (!beacon)
  122. bss->last_probe_resp = jiffies;
  123. return bss;
  124. }
  125. ieee80211_rx_result
  126. ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
  127. {
  128. struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
  129. struct ieee80211_mgmt *mgmt;
  130. struct ieee80211_bss *bss;
  131. u8 *elements;
  132. struct ieee80211_channel *channel;
  133. size_t baselen;
  134. int freq;
  135. __le16 fc;
  136. bool presp, beacon = false;
  137. struct ieee802_11_elems elems;
  138. if (skb->len < 2)
  139. return RX_DROP_UNUSABLE;
  140. mgmt = (struct ieee80211_mgmt *) skb->data;
  141. fc = mgmt->frame_control;
  142. if (ieee80211_is_ctl(fc))
  143. return RX_CONTINUE;
  144. if (skb->len < 24)
  145. return RX_DROP_MONITOR;
  146. presp = ieee80211_is_probe_resp(fc);
  147. if (presp) {
  148. /* ignore ProbeResp to foreign address */
  149. if (memcmp(mgmt->da, sdata->vif.addr, ETH_ALEN))
  150. return RX_DROP_MONITOR;
  151. presp = true;
  152. elements = mgmt->u.probe_resp.variable;
  153. baselen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
  154. } else {
  155. beacon = ieee80211_is_beacon(fc);
  156. baselen = offsetof(struct ieee80211_mgmt, u.beacon.variable);
  157. elements = mgmt->u.beacon.variable;
  158. }
  159. if (!presp && !beacon)
  160. return RX_CONTINUE;
  161. if (baselen > skb->len)
  162. return RX_DROP_MONITOR;
  163. ieee802_11_parse_elems(elements, skb->len - baselen, &elems);
  164. if (elems.ds_params && elems.ds_params_len == 1)
  165. freq = ieee80211_channel_to_frequency(elems.ds_params[0]);
  166. else
  167. freq = rx_status->freq;
  168. channel = ieee80211_get_channel(sdata->local->hw.wiphy, freq);
  169. if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
  170. return RX_DROP_MONITOR;
  171. bss = ieee80211_bss_info_update(sdata->local, rx_status,
  172. mgmt, skb->len, &elems,
  173. channel, beacon);
  174. if (bss)
  175. ieee80211_rx_bss_put(sdata->local, bss);
  176. dev_kfree_skb(skb);
  177. return RX_QUEUED;
  178. }
  179. /* return false if no more work */
  180. static bool ieee80211_prep_hw_scan(struct ieee80211_local *local)
  181. {
  182. struct cfg80211_scan_request *req = local->scan_req;
  183. enum ieee80211_band band;
  184. int i, ielen, n_chans;
  185. do {
  186. if (local->hw_scan_band == IEEE80211_NUM_BANDS)
  187. return false;
  188. band = local->hw_scan_band;
  189. n_chans = 0;
  190. for (i = 0; i < req->n_channels; i++) {
  191. if (req->channels[i]->band == band) {
  192. local->hw_scan_req->channels[n_chans] =
  193. req->channels[i];
  194. n_chans++;
  195. }
  196. }
  197. local->hw_scan_band++;
  198. } while (!n_chans);
  199. local->hw_scan_req->n_channels = n_chans;
  200. ielen = ieee80211_build_preq_ies(local, (u8 *)local->hw_scan_req->ie,
  201. req->ie, req->ie_len, band);
  202. local->hw_scan_req->ie_len = ielen;
  203. return true;
  204. }
  205. void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
  206. {
  207. struct ieee80211_local *local = hw_to_local(hw);
  208. bool was_hw_scan;
  209. trace_api_scan_completed(local, aborted);
  210. mutex_lock(&local->scan_mtx);
  211. /*
  212. * It's ok to abort a not-yet-running scan (that
  213. * we have one at all will be verified by checking
  214. * local->scan_req next), but not to complete it
  215. * successfully.
  216. */
  217. if (WARN_ON(!local->scanning && !aborted))
  218. aborted = true;
  219. if (WARN_ON(!local->scan_req)) {
  220. mutex_unlock(&local->scan_mtx);
  221. return;
  222. }
  223. was_hw_scan = test_bit(SCAN_HW_SCANNING, &local->scanning);
  224. if (was_hw_scan && !aborted && ieee80211_prep_hw_scan(local)) {
  225. ieee80211_queue_delayed_work(&local->hw,
  226. &local->scan_work, 0);
  227. mutex_unlock(&local->scan_mtx);
  228. return;
  229. }
  230. kfree(local->hw_scan_req);
  231. local->hw_scan_req = NULL;
  232. if (local->scan_req != local->int_scan_req)
  233. cfg80211_scan_done(local->scan_req, aborted);
  234. local->scan_req = NULL;
  235. local->scan_sdata = NULL;
  236. local->scanning = 0;
  237. local->scan_channel = NULL;
  238. /* we only have to protect scan_req and hw/sw scan */
  239. mutex_unlock(&local->scan_mtx);
  240. ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
  241. if (was_hw_scan)
  242. goto done;
  243. ieee80211_configure_filter(local);
  244. drv_sw_scan_complete(local);
  245. ieee80211_offchannel_return(local, true);
  246. done:
  247. ieee80211_recalc_idle(local);
  248. ieee80211_mlme_notify_scan_completed(local);
  249. ieee80211_ibss_notify_scan_completed(local);
  250. ieee80211_mesh_notify_scan_completed(local);
  251. ieee80211_queue_work(&local->hw, &local->work_work);
  252. }
  253. EXPORT_SYMBOL(ieee80211_scan_completed);
  254. static int ieee80211_start_sw_scan(struct ieee80211_local *local)
  255. {
  256. /*
  257. * Hardware/driver doesn't support hw_scan, so use software
  258. * scanning instead. First send a nullfunc frame with power save
  259. * bit on so that AP will buffer the frames for us while we are not
  260. * listening, then send probe requests to each channel and wait for
  261. * the responses. After all channels are scanned, tune back to the
  262. * original channel and send a nullfunc frame with power save bit
  263. * off to trigger the AP to send us all the buffered frames.
  264. *
  265. * Note that while local->sw_scanning is true everything else but
  266. * nullfunc frames and probe requests will be dropped in
  267. * ieee80211_tx_h_check_assoc().
  268. */
  269. drv_sw_scan_start(local);
  270. ieee80211_offchannel_stop_beaconing(local);
  271. local->leave_oper_channel_time = 0;
  272. local->next_scan_state = SCAN_DECISION;
  273. local->scan_channel_idx = 0;
  274. drv_flush(local, false);
  275. ieee80211_configure_filter(local);
  276. ieee80211_queue_delayed_work(&local->hw,
  277. &local->scan_work,
  278. IEEE80211_CHANNEL_TIME);
  279. return 0;
  280. }
  281. static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
  282. struct cfg80211_scan_request *req)
  283. {
  284. struct ieee80211_local *local = sdata->local;
  285. int rc;
  286. if (local->scan_req)
  287. return -EBUSY;
  288. if (!list_empty(&local->work_list)) {
  289. /* wait for the work to finish/time out */
  290. local->scan_req = req;
  291. local->scan_sdata = sdata;
  292. return 0;
  293. }
  294. if (local->ops->hw_scan) {
  295. u8 *ies;
  296. local->hw_scan_req = kmalloc(
  297. sizeof(*local->hw_scan_req) +
  298. req->n_channels * sizeof(req->channels[0]) +
  299. 2 + IEEE80211_MAX_SSID_LEN + local->scan_ies_len +
  300. req->ie_len, GFP_KERNEL);
  301. if (!local->hw_scan_req)
  302. return -ENOMEM;
  303. local->hw_scan_req->ssids = req->ssids;
  304. local->hw_scan_req->n_ssids = req->n_ssids;
  305. ies = (u8 *)local->hw_scan_req +
  306. sizeof(*local->hw_scan_req) +
  307. req->n_channels * sizeof(req->channels[0]);
  308. local->hw_scan_req->ie = ies;
  309. local->hw_scan_band = 0;
  310. /*
  311. * After allocating local->hw_scan_req, we must
  312. * go through until ieee80211_prep_hw_scan(), so
  313. * anything that might be changed here and leave
  314. * this function early must not go after this
  315. * allocation.
  316. */
  317. }
  318. local->scan_req = req;
  319. local->scan_sdata = sdata;
  320. if (local->ops->hw_scan)
  321. __set_bit(SCAN_HW_SCANNING, &local->scanning);
  322. else
  323. __set_bit(SCAN_SW_SCANNING, &local->scanning);
  324. /*
  325. * Kicking off the scan need not be protected,
  326. * only the scan variable stuff, since now
  327. * local->scan_req is assigned and other callers
  328. * will abort their scan attempts.
  329. *
  330. * This avoids too many locking dependencies
  331. * so that the scan completed calls have more
  332. * locking freedom.
  333. */
  334. ieee80211_recalc_idle(local);
  335. mutex_unlock(&local->scan_mtx);
  336. if (local->ops->hw_scan) {
  337. WARN_ON(!ieee80211_prep_hw_scan(local));
  338. rc = drv_hw_scan(local, sdata, local->hw_scan_req);
  339. } else
  340. rc = ieee80211_start_sw_scan(local);
  341. mutex_lock(&local->scan_mtx);
  342. if (rc) {
  343. kfree(local->hw_scan_req);
  344. local->hw_scan_req = NULL;
  345. local->scanning = 0;
  346. ieee80211_recalc_idle(local);
  347. local->scan_req = NULL;
  348. local->scan_sdata = NULL;
  349. }
  350. return rc;
  351. }
  352. static unsigned long
  353. ieee80211_scan_get_channel_time(struct ieee80211_channel *chan)
  354. {
  355. /*
  356. * TODO: channel switching also consumes quite some time,
  357. * add that delay as well to get a better estimation
  358. */
  359. if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
  360. return IEEE80211_PASSIVE_CHANNEL_TIME;
  361. return IEEE80211_PROBE_DELAY + IEEE80211_CHANNEL_TIME;
  362. }
  363. static int ieee80211_scan_state_decision(struct ieee80211_local *local,
  364. unsigned long *next_delay)
  365. {
  366. bool associated = false;
  367. bool tx_empty = true;
  368. bool bad_latency;
  369. bool listen_int_exceeded;
  370. unsigned long min_beacon_int = 0;
  371. struct ieee80211_sub_if_data *sdata;
  372. struct ieee80211_channel *next_chan;
  373. /* if no more bands/channels left, complete scan and advance to the idle state */
  374. if (local->scan_channel_idx >= local->scan_req->n_channels) {
  375. ieee80211_scan_completed(&local->hw, false);
  376. return 1;
  377. }
  378. /*
  379. * check if at least one STA interface is associated,
  380. * check if at least one STA interface has pending tx frames
  381. * and grab the lowest used beacon interval
  382. */
  383. mutex_lock(&local->iflist_mtx);
  384. list_for_each_entry(sdata, &local->interfaces, list) {
  385. if (!ieee80211_sdata_running(sdata))
  386. continue;
  387. if (sdata->vif.type == NL80211_IFTYPE_STATION) {
  388. if (sdata->u.mgd.associated) {
  389. associated = true;
  390. if (sdata->vif.bss_conf.beacon_int <
  391. min_beacon_int || min_beacon_int == 0)
  392. min_beacon_int =
  393. sdata->vif.bss_conf.beacon_int;
  394. if (!qdisc_all_tx_empty(sdata->dev)) {
  395. tx_empty = false;
  396. break;
  397. }
  398. }
  399. }
  400. }
  401. mutex_unlock(&local->iflist_mtx);
  402. if (local->scan_channel) {
  403. /*
  404. * we're currently scanning a different channel, let's
  405. * see if we can scan another channel without interfering
  406. * with the current traffic situation.
  407. *
  408. * Since we don't know if the AP has pending frames for us
  409. * we can only check for our tx queues and use the current
  410. * pm_qos requirements for rx. Hence, if no tx traffic occurs
  411. * at all we will scan as many channels in a row as the pm_qos
  412. * latency allows us to. Additionally we also check for the
  413. * currently negotiated listen interval to prevent losing
  414. * frames unnecessarily.
  415. *
  416. * Otherwise switch back to the operating channel.
  417. */
  418. next_chan = local->scan_req->channels[local->scan_channel_idx];
  419. bad_latency = time_after(jiffies +
  420. ieee80211_scan_get_channel_time(next_chan),
  421. local->leave_oper_channel_time +
  422. usecs_to_jiffies(pm_qos_request(PM_QOS_NETWORK_LATENCY)));
  423. listen_int_exceeded = time_after(jiffies +
  424. ieee80211_scan_get_channel_time(next_chan),
  425. local->leave_oper_channel_time +
  426. usecs_to_jiffies(min_beacon_int * 1024) *
  427. local->hw.conf.listen_interval);
  428. if (associated && ( !tx_empty || bad_latency ||
  429. listen_int_exceeded))
  430. local->next_scan_state = SCAN_ENTER_OPER_CHANNEL;
  431. else
  432. local->next_scan_state = SCAN_SET_CHANNEL;
  433. } else {
  434. /*
  435. * we're on the operating channel currently, let's
  436. * leave that channel now to scan another one
  437. */
  438. local->next_scan_state = SCAN_LEAVE_OPER_CHANNEL;
  439. }
  440. *next_delay = 0;
  441. return 0;
  442. }
  443. static void ieee80211_scan_state_leave_oper_channel(struct ieee80211_local *local,
  444. unsigned long *next_delay)
  445. {
  446. ieee80211_offchannel_stop_station(local);
  447. __set_bit(SCAN_OFF_CHANNEL, &local->scanning);
  448. /*
  449. * What if the nullfunc frames didn't arrive?
  450. */
  451. drv_flush(local, false);
  452. if (local->ops->flush)
  453. *next_delay = 0;
  454. else
  455. *next_delay = HZ / 10;
  456. /* remember when we left the operating channel */
  457. local->leave_oper_channel_time = jiffies;
  458. /* advance to the next channel to be scanned */
  459. local->next_scan_state = SCAN_SET_CHANNEL;
  460. }
  461. static void ieee80211_scan_state_enter_oper_channel(struct ieee80211_local *local,
  462. unsigned long *next_delay)
  463. {
  464. /* switch back to the operating channel */
  465. local->scan_channel = NULL;
  466. ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
  467. /*
  468. * Only re-enable station mode interface now; beaconing will be
  469. * re-enabled once the full scan has been completed.
  470. */
  471. ieee80211_offchannel_return(local, false);
  472. __clear_bit(SCAN_OFF_CHANNEL, &local->scanning);
  473. *next_delay = HZ / 5;
  474. local->next_scan_state = SCAN_DECISION;
  475. }
  476. static void ieee80211_scan_state_set_channel(struct ieee80211_local *local,
  477. unsigned long *next_delay)
  478. {
  479. int skip;
  480. struct ieee80211_channel *chan;
  481. skip = 0;
  482. chan = local->scan_req->channels[local->scan_channel_idx];
  483. local->scan_channel = chan;
  484. if (ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL))
  485. skip = 1;
  486. /* advance state machine to next channel/band */
  487. local->scan_channel_idx++;
  488. if (skip) {
  489. /* if we skip this channel return to the decision state */
  490. local->next_scan_state = SCAN_DECISION;
  491. return;
  492. }
  493. /*
  494. * Probe delay is used to update the NAV, cf. 11.1.3.2.2
  495. * (which unfortunately doesn't say _why_ step a) is done,
  496. * but it waits for the probe delay or until a frame is
  497. * received - and the received frame would update the NAV).
  498. * For now, we do not support waiting until a frame is
  499. * received.
  500. *
  501. * In any case, it is not necessary for a passive scan.
  502. */
  503. if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
  504. !local->scan_req->n_ssids) {
  505. *next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
  506. local->next_scan_state = SCAN_DECISION;
  507. return;
  508. }
  509. /* active scan, send probes */
  510. *next_delay = IEEE80211_PROBE_DELAY;
  511. local->next_scan_state = SCAN_SEND_PROBE;
  512. }
  513. static void ieee80211_scan_state_send_probe(struct ieee80211_local *local,
  514. unsigned long *next_delay)
  515. {
  516. int i;
  517. struct ieee80211_sub_if_data *sdata = local->scan_sdata;
  518. for (i = 0; i < local->scan_req->n_ssids; i++)
  519. ieee80211_send_probe_req(
  520. sdata, NULL,
  521. local->scan_req->ssids[i].ssid,
  522. local->scan_req->ssids[i].ssid_len,
  523. local->scan_req->ie, local->scan_req->ie_len);
  524. /*
  525. * After sending probe requests, wait for probe responses
  526. * on the channel.
  527. */
  528. *next_delay = IEEE80211_CHANNEL_TIME;
  529. local->next_scan_state = SCAN_DECISION;
  530. }
  531. void ieee80211_scan_work(struct work_struct *work)
  532. {
  533. struct ieee80211_local *local =
  534. container_of(work, struct ieee80211_local, scan_work.work);
  535. struct ieee80211_sub_if_data *sdata = local->scan_sdata;
  536. unsigned long next_delay = 0;
  537. mutex_lock(&local->scan_mtx);
  538. if (!sdata || !local->scan_req) {
  539. mutex_unlock(&local->scan_mtx);
  540. return;
  541. }
  542. if (local->hw_scan_req) {
  543. int rc = drv_hw_scan(local, sdata, local->hw_scan_req);
  544. mutex_unlock(&local->scan_mtx);
  545. if (rc)
  546. ieee80211_scan_completed(&local->hw, true);
  547. return;
  548. }
  549. if (local->scan_req && !local->scanning) {
  550. struct cfg80211_scan_request *req = local->scan_req;
  551. int rc;
  552. local->scan_req = NULL;
  553. local->scan_sdata = NULL;
  554. rc = __ieee80211_start_scan(sdata, req);
  555. mutex_unlock(&local->scan_mtx);
  556. if (rc)
  557. ieee80211_scan_completed(&local->hw, true);
  558. return;
  559. }
  560. mutex_unlock(&local->scan_mtx);
  561. /*
  562. * Avoid re-scheduling when the sdata is going away.
  563. */
  564. if (!ieee80211_sdata_running(sdata)) {
  565. ieee80211_scan_completed(&local->hw, true);
  566. return;
  567. }
  568. /*
  569. * as long as no delay is required advance immediately
  570. * without scheduling a new work
  571. */
  572. do {
  573. switch (local->next_scan_state) {
  574. case SCAN_DECISION:
  575. if (ieee80211_scan_state_decision(local, &next_delay))
  576. return;
  577. break;
  578. case SCAN_SET_CHANNEL:
  579. ieee80211_scan_state_set_channel(local, &next_delay);
  580. break;
  581. case SCAN_SEND_PROBE:
  582. ieee80211_scan_state_send_probe(local, &next_delay);
  583. break;
  584. case SCAN_LEAVE_OPER_CHANNEL:
  585. ieee80211_scan_state_leave_oper_channel(local, &next_delay);
  586. break;
  587. case SCAN_ENTER_OPER_CHANNEL:
  588. ieee80211_scan_state_enter_oper_channel(local, &next_delay);
  589. break;
  590. }
  591. } while (next_delay == 0);
  592. ieee80211_queue_delayed_work(&local->hw, &local->scan_work, next_delay);
  593. }
  594. int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
  595. struct cfg80211_scan_request *req)
  596. {
  597. int res;
  598. mutex_lock(&sdata->local->scan_mtx);
  599. res = __ieee80211_start_scan(sdata, req);
  600. mutex_unlock(&sdata->local->scan_mtx);
  601. return res;
  602. }
  603. int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
  604. const u8 *ssid, u8 ssid_len,
  605. struct ieee80211_channel *chan)
  606. {
  607. struct ieee80211_local *local = sdata->local;
  608. int ret = -EBUSY;
  609. enum ieee80211_band band;
  610. mutex_lock(&local->scan_mtx);
  611. /* busy scanning */
  612. if (local->scan_req)
  613. goto unlock;
  614. /* fill internal scan request */
  615. if (!chan) {
  616. int i, nchan = 0;
  617. for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
  618. if (!local->hw.wiphy->bands[band])
  619. continue;
  620. for (i = 0;
  621. i < local->hw.wiphy->bands[band]->n_channels;
  622. i++) {
  623. local->int_scan_req->channels[nchan] =
  624. &local->hw.wiphy->bands[band]->channels[i];
  625. nchan++;
  626. }
  627. }
  628. local->int_scan_req->n_channels = nchan;
  629. } else {
  630. local->int_scan_req->channels[0] = chan;
  631. local->int_scan_req->n_channels = 1;
  632. }
  633. local->int_scan_req->ssids = &local->scan_ssid;
  634. local->int_scan_req->n_ssids = 1;
  635. memcpy(local->int_scan_req->ssids[0].ssid, ssid, IEEE80211_MAX_SSID_LEN);
  636. local->int_scan_req->ssids[0].ssid_len = ssid_len;
  637. ret = __ieee80211_start_scan(sdata, sdata->local->int_scan_req);
  638. unlock:
  639. mutex_unlock(&local->scan_mtx);
  640. return ret;
  641. }
  642. void ieee80211_scan_cancel(struct ieee80211_local *local)
  643. {
  644. bool abortscan;
  645. cancel_delayed_work_sync(&local->scan_work);
  646. /*
  647. * Only call this function when a scan can't be
  648. * queued -- mostly at suspend under RTNL.
  649. */
  650. mutex_lock(&local->scan_mtx);
  651. abortscan = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
  652. (!local->scanning && local->scan_req);
  653. mutex_unlock(&local->scan_mtx);
  654. if (abortscan)
  655. ieee80211_scan_completed(&local->hw, true);
  656. }