← Back to branch summary

~ubuntu-branches/ubuntu/maverick/linux-backports-modules-2.6.32/maverick

« back to all changes in this revision

Viewing changes to updates/compat-wireless-2.6/net/mac80211/scan.c

  • Committer: Bazaar Package Importer
  • Author(s): Andy Whitcroft, Andy Whitcroft
  • Date: 2010-02-04 23:15:51 UTC
  • Revision ID: james.westby@ubuntu.com-20100204231551-vjz5pkvxclukjxm1
Tags: 2.6.32-12.1
[ Andy Whitcroft ]

* initial LBM for lucid
* drop generated files
* printchanges -- rebase tree does not have stable tags use changelog
* printenv -- add revisions to printenv output
* formally rename compat-wireless to linux-backports-modules-wireless
* Update to compat-wireless-2.6.33-rc5
* update nouveau to mainline 2.6.33-rc4
* add new LBM package for nouveau
* nouveau -- fix major numbers and proc entry names
* fix up firmware installs for -wireless
* clean up UPDATE-NOVEAU
* update Nouveau to v2.6.33-rc6

Show diffs side-by-side

added added

removed removed

Lines of Context:
updates/compat-wireless-2.6/net/mac80211/scan.c
 
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
 
 
15
#include <linux/wireless.h>
 
16
#include <linux/if_arp.h>
 
17
#include <linux/rtnetlink.h>
 
18
#include <net/mac80211.h>
 
19
 
 
20
#include "ieee80211_i.h"
 
21
#include "driver-ops.h"
 
22
#include "mesh.h"
 
23
 
 
24
#define IEEE80211_PROBE_DELAY (HZ / 33)
 
25
#define IEEE80211_CHANNEL_TIME (HZ / 33)
 
26
#define IEEE80211_PASSIVE_CHANNEL_TIME (HZ / 8)
 
27
 
 
28
struct ieee80211_bss *
 
29
ieee80211_rx_bss_get(struct ieee80211_local *local, u8 *bssid, int freq,
 
30
                     u8 *ssid, u8 ssid_len)
 
31
{
 
32
        return (void *)cfg80211_get_bss(local->hw.wiphy,
 
33
                                        ieee80211_get_channel(local->hw.wiphy,
 
34
                                                              freq),
 
35
                                        bssid, ssid, ssid_len,
 
36
                                        0, 0);
 
37
}
 
38
 
 
39
static void ieee80211_rx_bss_free(struct cfg80211_bss *cbss)
 
40
{
 
41
        struct ieee80211_bss *bss = (void *)cbss;
 
42
 
 
43
        kfree(bss_mesh_id(bss));
 
44
        kfree(bss_mesh_cfg(bss));
 
45
}
 
46
 
 
47
void ieee80211_rx_bss_put(struct ieee80211_local *local,
 
48
                          struct ieee80211_bss *bss)
 
49
{
 
50
        cfg80211_put_bss((struct cfg80211_bss *)bss);
 
51
}
 
52
 
 
53
struct ieee80211_bss *
 
54
ieee80211_bss_info_update(struct ieee80211_local *local,
 
55
                          struct ieee80211_rx_status *rx_status,
 
56
                          struct ieee80211_mgmt *mgmt,
 
57
                          size_t len,
 
58
                          struct ieee802_11_elems *elems,
 
59
                          struct ieee80211_channel *channel,
 
60
                          bool beacon)
 
61
{
 
62
        struct ieee80211_bss *bss;
 
63
        int clen;
 
64
        s32 signal = 0;
 
65
 
 
66
        if (local->hw.flags & IEEE80211_HW_SIGNAL_DBM)
 
67
                signal = rx_status->signal * 100;
 
68
        else if (local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)
 
69
                signal = (rx_status->signal * 100) / local->hw.max_signal;
 
70
 
 
71
        bss = (void *)cfg80211_inform_bss_frame(local->hw.wiphy, channel,
 
72
                                                mgmt, len, signal, GFP_ATOMIC);
 
73
 
 
74
        if (!bss)
 
75
                return NULL;
 
76
 
 
77
        bss->cbss.free_priv = ieee80211_rx_bss_free;
 
78
 
 
79
        /* save the ERP value so that it is available at association time */
 
80
        if (elems->erp_info && elems->erp_info_len >= 1) {
 
81
                bss->erp_value = elems->erp_info[0];
 
82
                bss->has_erp_value = 1;
 
83
        }
 
84
 
 
85
        if (elems->tim) {
 
86
                struct ieee80211_tim_ie *tim_ie =
 
87
                        (struct ieee80211_tim_ie *)elems->tim;
 
88
                bss->dtim_period = tim_ie->dtim_period;
 
89
        }
 
90
 
 
91
        /* set default value for buggy AP/no TIM element */
 
92
        if (bss->dtim_period == 0)
 
93
                bss->dtim_period = 1;
 
94
 
 
95
        bss->supp_rates_len = 0;
 
96
        if (elems->supp_rates) {
 
97
                clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len;
 
98
                if (clen > elems->supp_rates_len)
 
99
                        clen = elems->supp_rates_len;
 
100
                memcpy(&bss->supp_rates[bss->supp_rates_len], elems->supp_rates,
 
101
                       clen);
 
102
                bss->supp_rates_len += clen;
 
103
        }
 
104
        if (elems->ext_supp_rates) {
 
105
                clen = IEEE80211_MAX_SUPP_RATES - bss->supp_rates_len;
 
106
                if (clen > elems->ext_supp_rates_len)
 
107
                        clen = elems->ext_supp_rates_len;
 
108
                memcpy(&bss->supp_rates[bss->supp_rates_len],
 
109
                       elems->ext_supp_rates, clen);
 
110
                bss->supp_rates_len += clen;
 
111
        }
 
112
 
 
113
        bss->wmm_used = elems->wmm_param || elems->wmm_info;
 
114
 
 
115
        if (!beacon)
 
116
                bss->last_probe_resp = jiffies;
 
117
 
 
118
        return bss;
 
119
}
 
120
 
 
121
ieee80211_rx_result
 
122
ieee80211_scan_rx(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
 
123
{
 
124
        struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
 
125
        struct ieee80211_mgmt *mgmt;
 
126
        struct ieee80211_bss *bss;
 
127
        u8 *elements;
 
128
        struct ieee80211_channel *channel;
 
129
        size_t baselen;
 
130
        int freq;
 
131
        __le16 fc;
 
132
        bool presp, beacon = false;
 
133
        struct ieee802_11_elems elems;
 
134
 
 
135
        if (skb->len < 2)
 
136
                return RX_DROP_UNUSABLE;
 
137
 
 
138
        mgmt = (struct ieee80211_mgmt *) skb->data;
 
139
        fc = mgmt->frame_control;
 
140
 
 
141
        if (ieee80211_is_ctl(fc))
 
142
                return RX_CONTINUE;
 
143
 
 
144
        if (skb->len < 24)
 
145
                return RX_DROP_MONITOR;
 
146
 
 
147
        presp = ieee80211_is_probe_resp(fc);
 
148
        if (presp) {
 
149
                /* ignore ProbeResp to foreign address */
 
150
                if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
 
151
                        return RX_DROP_MONITOR;
 
152
 
 
153
                presp = true;
 
154
                elements = mgmt->u.probe_resp.variable;
 
155
                baselen = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
 
156
        } else {
 
157
                beacon = ieee80211_is_beacon(fc);
 
158
                baselen = offsetof(struct ieee80211_mgmt, u.beacon.variable);
 
159
                elements = mgmt->u.beacon.variable;
 
160
        }
 
161
 
 
162
        if (!presp && !beacon)
 
163
                return RX_CONTINUE;
 
164
 
 
165
        if (baselen > skb->len)
 
166
                return RX_DROP_MONITOR;
 
167
 
 
168
        ieee802_11_parse_elems(elements, skb->len - baselen, &elems);
 
169
 
 
170
        if (elems.ds_params && elems.ds_params_len == 1)
 
171
                freq = ieee80211_channel_to_frequency(elems.ds_params[0]);
 
172
        else
 
173
                freq = rx_status->freq;
 
174
 
 
175
        channel = ieee80211_get_channel(sdata->local->hw.wiphy, freq);
 
176
 
 
177
        if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
 
178
                return RX_DROP_MONITOR;
 
179
 
 
180
        bss = ieee80211_bss_info_update(sdata->local, rx_status,
 
181
                                        mgmt, skb->len, &elems,
 
182
                                        channel, beacon);
 
183
        if (bss)
 
184
                ieee80211_rx_bss_put(sdata->local, bss);
 
185
 
 
186
        dev_kfree_skb(skb);
 
187
        return RX_QUEUED;
 
188
}
 
189
 
 
190
/* return false if no more work */
 
191
static bool ieee80211_prep_hw_scan(struct ieee80211_local *local)
 
192
{
 
193
        struct cfg80211_scan_request *req = local->scan_req;
 
194
        enum ieee80211_band band;
 
195
        int i, ielen, n_chans;
 
196
 
 
197
        do {
 
198
                if (local->hw_scan_band == IEEE80211_NUM_BANDS)
 
199
                        return false;
 
200
 
 
201
                band = local->hw_scan_band;
 
202
                n_chans = 0;
 
203
                for (i = 0; i < req->n_channels; i++) {
 
204
                        if (req->channels[i]->band == band) {
 
205
                                local->hw_scan_req->channels[n_chans] =
 
206
                                                        req->channels[i];
 
207
                                n_chans++;
 
208
                        }
 
209
                }
 
210
 
 
211
                local->hw_scan_band++;
 
212
        } while (!n_chans);
 
213
 
 
214
        local->hw_scan_req->n_channels = n_chans;
 
215
 
 
216
        ielen = ieee80211_build_preq_ies(local, (u8 *)local->hw_scan_req->ie,
 
217
                                         req->ie, req->ie_len, band);
 
218
        local->hw_scan_req->ie_len = ielen;
 
219
 
 
220
        return true;
 
221
}
 
222
 
 
223
/*
 
224
 * inform AP that we will go to sleep so that it will buffer the frames
 
225
 * while we scan
 
226
 */
 
227
static void ieee80211_scan_ps_enable(struct ieee80211_sub_if_data *sdata)
 
228
{
 
229
        struct ieee80211_local *local = sdata->local;
 
230
 
 
231
        local->scan_ps_enabled = false;
 
232
 
 
233
        /* FIXME: what to do when local->pspolling is true? */
 
234
 
 
235
        del_timer_sync(&local->dynamic_ps_timer);
 
236
        cancel_work_sync(&local->dynamic_ps_enable_work);
 
237
 
 
238
        if (local->hw.conf.flags & IEEE80211_CONF_PS) {
 
239
                local->scan_ps_enabled = true;
 
240
                local->hw.conf.flags &= ~IEEE80211_CONF_PS;
 
241
                ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
 
242
        }
 
243
 
 
244
        if (!(local->scan_ps_enabled) ||
 
245
            !(local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK))
 
246
                /*
 
247
                 * If power save was enabled, no need to send a nullfunc
 
248
                 * frame because AP knows that we are sleeping. But if the
 
249
                 * hardware is creating the nullfunc frame for power save
 
250
                 * status (ie. IEEE80211_HW_PS_NULLFUNC_STACK is not
 
251
                 * enabled) and power save was enabled, the firmware just
 
252
                 * sent a null frame with power save disabled. So we need
 
253
                 * to send a new nullfunc frame to inform the AP that we
 
254
                 * are again sleeping.
 
255
                 */
 
256
                ieee80211_send_nullfunc(local, sdata, 1);
 
257
}
 
258
 
 
259
/* inform AP that we are awake again, unless power save is enabled */
 
260
static void ieee80211_scan_ps_disable(struct ieee80211_sub_if_data *sdata)
 
261
{
 
262
        struct ieee80211_local *local = sdata->local;
 
263
 
 
264
        if (!local->ps_sdata)
 
265
                ieee80211_send_nullfunc(local, sdata, 0);
 
266
        else if (local->scan_ps_enabled) {
 
267
                /*
 
268
                 * In !IEEE80211_HW_PS_NULLFUNC_STACK case the hardware
 
269
                 * will send a nullfunc frame with the powersave bit set
 
270
                 * even though the AP already knows that we are sleeping.
 
271
                 * This could be avoided by sending a null frame with power
 
272
                 * save bit disabled before enabling the power save, but
 
273
                 * this doesn't gain anything.
 
274
                 *
 
275
                 * When IEEE80211_HW_PS_NULLFUNC_STACK is enabled, no need
 
276
                 * to send a nullfunc frame because AP already knows that
 
277
                 * we are sleeping, let's just enable power save mode in
 
278
                 * hardware.
 
279
                 */
 
280
                local->hw.conf.flags |= IEEE80211_CONF_PS;
 
281
                ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
 
282
        } else if (local->hw.conf.dynamic_ps_timeout > 0) {
 
283
                /*
 
284
                 * If IEEE80211_CONF_PS was not set and the dynamic_ps_timer
 
285
                 * had been running before leaving the operating channel,
 
286
                 * restart the timer now and send a nullfunc frame to inform
 
287
                 * the AP that we are awake.
 
288
                 */
 
289
                ieee80211_send_nullfunc(local, sdata, 0);
 
290
                mod_timer(&local->dynamic_ps_timer, jiffies +
 
291
                          msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
 
292
        }
 
293
}
 
294
 
 
295
void ieee80211_scan_completed(struct ieee80211_hw *hw, bool aborted)
 
296
{
 
297
        struct ieee80211_local *local = hw_to_local(hw);
 
298
        struct ieee80211_sub_if_data *sdata;
 
299
        bool was_hw_scan;
 
300
 
 
301
        mutex_lock(&local->scan_mtx);
 
302
 
 
303
        /*
 
304
         * It's ok to abort a not-yet-running scan (that
 
305
         * we have one at all will be verified by checking
 
306
         * local->scan_req next), but not to complete it
 
307
         * successfully.
 
308
         */
 
309
        if (WARN_ON(!local->scanning && !aborted))
 
310
                aborted = true;
 
311
 
 
312
        if (WARN_ON(!local->scan_req)) {
 
313
                mutex_unlock(&local->scan_mtx);
 
314
                return;
 
315
        }
 
316
 
 
317
        was_hw_scan = test_bit(SCAN_HW_SCANNING, &local->scanning);
 
318
        if (was_hw_scan && !aborted && ieee80211_prep_hw_scan(local)) {
 
319
                ieee80211_queue_delayed_work(&local->hw,
 
320
                                             &local->scan_work, 0);
 
321
                mutex_unlock(&local->scan_mtx);
 
322
                return;
 
323
        }
 
324
 
 
325
        kfree(local->hw_scan_req);
 
326
        local->hw_scan_req = NULL;
 
327
 
 
328
        if (local->scan_req != local->int_scan_req)
 
329
                cfg80211_scan_done(local->scan_req, aborted);
 
330
        local->scan_req = NULL;
 
331
        local->scan_sdata = NULL;
 
332
 
 
333
        local->scanning = 0;
 
334
        local->scan_channel = NULL;
 
335
 
 
336
        /* we only have to protect scan_req and hw/sw scan */
 
337
        mutex_unlock(&local->scan_mtx);
 
338
 
 
339
        ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 
340
        if (was_hw_scan)
 
341
                goto done;
 
342
 
 
343
        ieee80211_configure_filter(local);
 
344
 
 
345
        drv_sw_scan_complete(local);
 
346
 
 
347
        mutex_lock(&local->iflist_mtx);
 
348
        list_for_each_entry(sdata, &local->interfaces, list) {
 
349
                if (!netif_running(sdata->dev))
 
350
                        continue;
 
351
 
 
352
                /* Tell AP we're back */
 
353
                if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 
354
                        if (sdata->u.mgd.associated) {
 
355
                                ieee80211_scan_ps_disable(sdata);
 
356
                                netif_tx_wake_all_queues(sdata->dev);
 
357
                        }
 
358
                } else
 
359
                        netif_tx_wake_all_queues(sdata->dev);
 
360
 
 
361
                /* re-enable beaconing */
 
362
                if (sdata->vif.type == NL80211_IFTYPE_AP ||
 
363
                    sdata->vif.type == NL80211_IFTYPE_ADHOC ||
 
364
                    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
 
365
                        ieee80211_bss_info_change_notify(
 
366
                                sdata, BSS_CHANGED_BEACON_ENABLED);
 
367
        }
 
368
        mutex_unlock(&local->iflist_mtx);
 
369
 
 
370
 done:
 
371
        ieee80211_recalc_idle(local);
 
372
        ieee80211_mlme_notify_scan_completed(local);
 
373
        ieee80211_ibss_notify_scan_completed(local);
 
374
        ieee80211_mesh_notify_scan_completed(local);
 
375
}
 
376
EXPORT_SYMBOL(ieee80211_scan_completed);
 
377
 
 
378
static int ieee80211_start_sw_scan(struct ieee80211_local *local)
 
379
{
 
380
        struct ieee80211_sub_if_data *sdata;
 
381
 
 
382
        /*
 
383
         * Hardware/driver doesn't support hw_scan, so use software
 
384
         * scanning instead. First send a nullfunc frame with power save
 
385
         * bit on so that AP will buffer the frames for us while we are not
 
386
         * listening, then send probe requests to each channel and wait for
 
387
         * the responses. After all channels are scanned, tune back to the
 
388
         * original channel and send a nullfunc frame with power save bit
 
389
         * off to trigger the AP to send us all the buffered frames.
 
390
         *
 
391
         * Note that while local->sw_scanning is true everything else but
 
392
         * nullfunc frames and probe requests will be dropped in
 
393
         * ieee80211_tx_h_check_assoc().
 
394
         */
 
395
        drv_sw_scan_start(local);
 
396
 
 
397
        mutex_lock(&local->iflist_mtx);
 
398
        list_for_each_entry(sdata, &local->interfaces, list) {
 
399
                if (!netif_running(sdata->dev))
 
400
                        continue;
 
401
 
 
402
                /* disable beaconing */
 
403
                if (sdata->vif.type == NL80211_IFTYPE_AP ||
 
404
                    sdata->vif.type == NL80211_IFTYPE_ADHOC ||
 
405
                    sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
 
406
                        ieee80211_bss_info_change_notify(
 
407
                                sdata, BSS_CHANGED_BEACON_ENABLED);
 
408
 
 
409
                /*
 
410
                 * only handle non-STA interfaces here, STA interfaces
 
411
                 * are handled in the scan state machine
 
412
                 */
 
413
                if (sdata->vif.type != NL80211_IFTYPE_STATION)
 
414
                        netif_tx_stop_all_queues(sdata->dev);
 
415
        }
 
416
        mutex_unlock(&local->iflist_mtx);
 
417
 
 
418
        local->next_scan_state = SCAN_DECISION;
 
419
        local->scan_channel_idx = 0;
 
420
 
 
421
        ieee80211_configure_filter(local);
 
422
 
 
423
        /* TODO: start scan as soon as all nullfunc frames are ACKed */
 
424
        ieee80211_queue_delayed_work(&local->hw,
 
425
                                     &local->scan_work,
 
426
                                     IEEE80211_CHANNEL_TIME);
 
427
 
 
428
        return 0;
 
429
}
 
430
 
 
431
 
 
432
static int __ieee80211_start_scan(struct ieee80211_sub_if_data *sdata,
 
433
                                  struct cfg80211_scan_request *req)
 
434
{
 
435
        struct ieee80211_local *local = sdata->local;
 
436
        struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
 
437
        int rc;
 
438
 
 
439
        if (local->scan_req)
 
440
                return -EBUSY;
 
441
 
 
442
        if (local->ops->hw_scan) {
 
443
                u8 *ies;
 
444
 
 
445
                local->hw_scan_req = kmalloc(
 
446
                                sizeof(*local->hw_scan_req) +
 
447
                                req->n_channels * sizeof(req->channels[0]) +
 
448
                                2 + IEEE80211_MAX_SSID_LEN + local->scan_ies_len +
 
449
                                req->ie_len, GFP_KERNEL);
 
450
                if (!local->hw_scan_req)
 
451
                        return -ENOMEM;
 
452
 
 
453
                local->hw_scan_req->ssids = req->ssids;
 
454
                local->hw_scan_req->n_ssids = req->n_ssids;
 
455
                ies = (u8 *)local->hw_scan_req +
 
456
                        sizeof(*local->hw_scan_req) +
 
457
                        req->n_channels * sizeof(req->channels[0]);
 
458
                local->hw_scan_req->ie = ies;
 
459
 
 
460
                local->hw_scan_band = 0;
 
461
        }
 
462
 
 
463
        local->scan_req = req;
 
464
        local->scan_sdata = sdata;
 
465
 
 
466
        if (req != local->int_scan_req &&
 
467
            sdata->vif.type == NL80211_IFTYPE_STATION &&
 
468
            !list_empty(&ifmgd->work_list)) {
 
469
                /* actually wait for the work it's doing to finish/time out */
 
470
                set_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request);
 
471
                return 0;
 
472
        }
 
473
 
 
474
        if (local->ops->hw_scan)
 
475
                __set_bit(SCAN_HW_SCANNING, &local->scanning);
 
476
        else
 
477
                __set_bit(SCAN_SW_SCANNING, &local->scanning);
 
478
        /*
 
479
         * Kicking off the scan need not be protected,
 
480
         * only the scan variable stuff, since now
 
481
         * local->scan_req is assigned and other callers
 
482
         * will abort their scan attempts.
 
483
         *
 
484
         * This avoids getting a scan_mtx -> iflist_mtx
 
485
         * dependency, so that the scan completed calls
 
486
         * have more locking freedom.
 
487
         */
 
488
 
 
489
        ieee80211_recalc_idle(local);
 
490
        mutex_unlock(&local->scan_mtx);
 
491
 
 
492
        if (local->ops->hw_scan) {
 
493
                WARN_ON(!ieee80211_prep_hw_scan(local));
 
494
                rc = drv_hw_scan(local, local->hw_scan_req);
 
495
        } else
 
496
                rc = ieee80211_start_sw_scan(local);
 
497
 
 
498
        mutex_lock(&local->scan_mtx);
 
499
 
 
500
        if (rc) {
 
501
                kfree(local->hw_scan_req);
 
502
                local->hw_scan_req = NULL;
 
503
                local->scanning = 0;
 
504
 
 
505
                ieee80211_recalc_idle(local);
 
506
 
 
507
                local->scan_req = NULL;
 
508
                local->scan_sdata = NULL;
 
509
        }
 
510
 
 
511
        return rc;
 
512
}
 
513
 
 
514
static int ieee80211_scan_state_decision(struct ieee80211_local *local,
 
515
                                         unsigned long *next_delay)
 
516
{
 
517
        bool associated = false;
 
518
        struct ieee80211_sub_if_data *sdata;
 
519
 
 
520
        /* if no more bands/channels left, complete scan and advance to the idle state */
 
521
        if (local->scan_channel_idx >= local->scan_req->n_channels) {
 
522
                ieee80211_scan_completed(&local->hw, false);
 
523
                return 1;
 
524
        }
 
525
 
 
526
        /* check if at least one STA interface is associated */
 
527
        mutex_lock(&local->iflist_mtx);
 
528
        list_for_each_entry(sdata, &local->interfaces, list) {
 
529
                if (!netif_running(sdata->dev))
 
530
                        continue;
 
531
 
 
532
                if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 
533
                        if (sdata->u.mgd.associated) {
 
534
                                associated = true;
 
535
                                break;
 
536
                        }
 
537
                }
 
538
        }
 
539
        mutex_unlock(&local->iflist_mtx);
 
540
 
 
541
        if (local->scan_channel) {
 
542
                /*
 
543
                 * we're currently scanning a different channel, let's
 
544
                 * switch back to the operating channel now if at least
 
545
                 * one interface is associated. Otherwise just scan the
 
546
                 * next channel
 
547
                 */
 
548
                if (associated)
 
549
                        local->next_scan_state = SCAN_ENTER_OPER_CHANNEL;
 
550
                else
 
551
                        local->next_scan_state = SCAN_SET_CHANNEL;
 
552
        } else {
 
553
                /*
 
554
                 * we're on the operating channel currently, let's
 
555
                 * leave that channel now to scan another one
 
556
                 */
 
557
                local->next_scan_state = SCAN_LEAVE_OPER_CHANNEL;
 
558
        }
 
559
 
 
560
        *next_delay = 0;
 
561
        return 0;
 
562
}
 
563
 
 
564
static void ieee80211_scan_state_leave_oper_channel(struct ieee80211_local *local,
 
565
                                                    unsigned long *next_delay)
 
566
{
 
567
        struct ieee80211_sub_if_data *sdata;
 
568
 
 
569
        /*
 
570
         * notify the AP about us leaving the channel and stop all STA interfaces
 
571
         */
 
572
        mutex_lock(&local->iflist_mtx);
 
573
        list_for_each_entry(sdata, &local->interfaces, list) {
 
574
                if (!netif_running(sdata->dev))
 
575
                        continue;
 
576
 
 
577
                if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 
578
                        netif_tx_stop_all_queues(sdata->dev);
 
579
                        if (sdata->u.mgd.associated)
 
580
                                ieee80211_scan_ps_enable(sdata);
 
581
                }
 
582
        }
 
583
        mutex_unlock(&local->iflist_mtx);
 
584
 
 
585
        __set_bit(SCAN_OFF_CHANNEL, &local->scanning);
 
586
 
 
587
        /* advance to the next channel to be scanned */
 
588
        *next_delay = HZ / 10;
 
589
        local->next_scan_state = SCAN_SET_CHANNEL;
 
590
}
 
591
 
 
592
static void ieee80211_scan_state_enter_oper_channel(struct ieee80211_local *local,
 
593
                                                    unsigned long *next_delay)
 
594
{
 
595
        struct ieee80211_sub_if_data *sdata = local->scan_sdata;
 
596
 
 
597
        /* switch back to the operating channel */
 
598
        local->scan_channel = NULL;
 
599
        ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
 
600
 
 
601
        /*
 
602
         * notify the AP about us being back and restart all STA interfaces
 
603
         */
 
604
        mutex_lock(&local->iflist_mtx);
 
605
        list_for_each_entry(sdata, &local->interfaces, list) {
 
606
                if (!netif_running(sdata->dev))
 
607
                        continue;
 
608
 
 
609
                /* Tell AP we're back */
 
610
                if (sdata->vif.type == NL80211_IFTYPE_STATION) {
 
611
                        if (sdata->u.mgd.associated)
 
612
                                ieee80211_scan_ps_disable(sdata);
 
613
                        netif_tx_wake_all_queues(sdata->dev);
 
614
                }
 
615
        }
 
616
        mutex_unlock(&local->iflist_mtx);
 
617
 
 
618
        __clear_bit(SCAN_OFF_CHANNEL, &local->scanning);
 
619
 
 
620
        *next_delay = HZ / 5;
 
621
        local->next_scan_state = SCAN_DECISION;
 
622
}
 
623
 
 
624
static void ieee80211_scan_state_set_channel(struct ieee80211_local *local,
 
625
                                             unsigned long *next_delay)
 
626
{
 
627
        int skip;
 
628
        struct ieee80211_channel *chan;
 
629
 
 
630
        skip = 0;
 
631
        chan = local->scan_req->channels[local->scan_channel_idx];
 
632
 
 
633
        local->scan_channel = chan;
 
634
        if (ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL))
 
635
                skip = 1;
 
636
 
 
637
        /* advance state machine to next channel/band */
 
638
        local->scan_channel_idx++;
 
639
 
 
640
        if (skip) {
 
641
                /* if we skip this channel return to the decision state */
 
642
                local->next_scan_state = SCAN_DECISION;
 
643
                return;
 
644
        }
 
645
 
 
646
        /*
 
647
         * Probe delay is used to update the NAV, cf. 11.1.3.2.2
 
648
         * (which unfortunately doesn't say _why_ step a) is done,
 
649
         * but it waits for the probe delay or until a frame is
 
650
         * received - and the received frame would update the NAV).
 
651
         * For now, we do not support waiting until a frame is
 
652
         * received.
 
653
         *
 
654
         * In any case, it is not necessary for a passive scan.
 
655
         */
 
656
        if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN ||
 
657
            !local->scan_req->n_ssids) {
 
658
                *next_delay = IEEE80211_PASSIVE_CHANNEL_TIME;
 
659
                local->next_scan_state = SCAN_DECISION;
 
660
                return;
 
661
        }
 
662
 
 
663
        /* active scan, send probes */
 
664
        *next_delay = IEEE80211_PROBE_DELAY;
 
665
        local->next_scan_state = SCAN_SEND_PROBE;
 
666
}
 
667
 
 
668
static void ieee80211_scan_state_send_probe(struct ieee80211_local *local,
 
669
                                            unsigned long *next_delay)
 
670
{
 
671
        int i;
 
672
        struct ieee80211_sub_if_data *sdata = local->scan_sdata;
 
673
 
 
674
        for (i = 0; i < local->scan_req->n_ssids; i++)
 
675
                ieee80211_send_probe_req(
 
676
                        sdata, NULL,
 
677
                        local->scan_req->ssids[i].ssid,
 
678
                        local->scan_req->ssids[i].ssid_len,
 
679
                        local->scan_req->ie, local->scan_req->ie_len);
 
680
 
 
681
        /*
 
682
         * After sending probe requests, wait for probe responses
 
683
         * on the channel.
 
684
         */
 
685
        *next_delay = IEEE80211_CHANNEL_TIME;
 
686
        local->next_scan_state = SCAN_DECISION;
 
687
}
 
688
 
 
689
void ieee80211_scan_work(struct work_struct *work)
 
690
{
 
691
        struct ieee80211_local *local =
 
692
                container_of(work, struct ieee80211_local, scan_work.work);
 
693
        struct ieee80211_sub_if_data *sdata = local->scan_sdata;
 
694
        unsigned long next_delay = 0;
 
695
 
 
696
        mutex_lock(&local->scan_mtx);
 
697
        if (!sdata || !local->scan_req) {
 
698
                mutex_unlock(&local->scan_mtx);
 
699
                return;
 
700
        }
 
701
 
 
702
        if (local->hw_scan_req) {
 
703
                int rc = drv_hw_scan(local, local->hw_scan_req);
 
704
                mutex_unlock(&local->scan_mtx);
 
705
                if (rc)
 
706
                        ieee80211_scan_completed(&local->hw, true);
 
707
                return;
 
708
        }
 
709
 
 
710
        if (local->scan_req && !local->scanning) {
 
711
                struct cfg80211_scan_request *req = local->scan_req;
 
712
                int rc;
 
713
 
 
714
                local->scan_req = NULL;
 
715
                local->scan_sdata = NULL;
 
716
 
 
717
                rc = __ieee80211_start_scan(sdata, req);
 
718
                mutex_unlock(&local->scan_mtx);
 
719
 
 
720
                if (rc)
 
721
                        ieee80211_scan_completed(&local->hw, true);
 
722
                return;
 
723
        }
 
724
 
 
725
        mutex_unlock(&local->scan_mtx);
 
726
 
 
727
        /*
 
728
         * Avoid re-scheduling when the sdata is going away.
 
729
         */
 
730
        if (!netif_running(sdata->dev)) {
 
731
                ieee80211_scan_completed(&local->hw, true);
 
732
                return;
 
733
        }
 
734
 
 
735
        /*
 
736
         * as long as no delay is required advance immediately
 
737
         * without scheduling a new work
 
738
         */
 
739
        do {
 
740
                switch (local->next_scan_state) {
 
741
                case SCAN_DECISION:
 
742
                        if (ieee80211_scan_state_decision(local, &next_delay))
 
743
                                return;
 
744
                        break;
 
745
                case SCAN_SET_CHANNEL:
 
746
                        ieee80211_scan_state_set_channel(local, &next_delay);
 
747
                        break;
 
748
                case SCAN_SEND_PROBE:
 
749
                        ieee80211_scan_state_send_probe(local, &next_delay);
 
750
                        break;
 
751
                case SCAN_LEAVE_OPER_CHANNEL:
 
752
                        ieee80211_scan_state_leave_oper_channel(local, &next_delay);
 
753
                        break;
 
754
                case SCAN_ENTER_OPER_CHANNEL:
 
755
                        ieee80211_scan_state_enter_oper_channel(local, &next_delay);
 
756
                        break;
 
757
                }
 
758
        } while (next_delay == 0);
 
759
 
 
760
        ieee80211_queue_delayed_work(&local->hw, &local->scan_work, next_delay);
 
761
}
 
762
 
 
763
int ieee80211_request_scan(struct ieee80211_sub_if_data *sdata,
 
764
                           struct cfg80211_scan_request *req)
 
765
{
 
766
        int res;
 
767
 
 
768
        mutex_lock(&sdata->local->scan_mtx);
 
769
        res = __ieee80211_start_scan(sdata, req);
 
770
        mutex_unlock(&sdata->local->scan_mtx);
 
771
 
 
772
        return res;
 
773
}
 
774
 
 
775
int ieee80211_request_internal_scan(struct ieee80211_sub_if_data *sdata,
 
776
                                    const u8 *ssid, u8 ssid_len)
 
777
{
 
778
        struct ieee80211_local *local = sdata->local;
 
779
        int ret = -EBUSY;
 
780
 
 
781
        mutex_lock(&local->scan_mtx);
 
782
 
 
783
        /* busy scanning */
 
784
        if (local->scan_req)
 
785
                goto unlock;
 
786
 
 
787
        memcpy(local->int_scan_req->ssids[0].ssid, ssid, IEEE80211_MAX_SSID_LEN);
 
788
        local->int_scan_req->ssids[0].ssid_len = ssid_len;
 
789
 
 
790
        ret = __ieee80211_start_scan(sdata, sdata->local->int_scan_req);
 
791
 unlock:
 
792
        mutex_unlock(&local->scan_mtx);
 
793
        return ret;
 
794
}
 
795
 
 
796
void ieee80211_scan_cancel(struct ieee80211_local *local)
 
797
{
 
798
        bool abortscan;
 
799
 
 
800
        cancel_delayed_work_sync(&local->scan_work);
 
801
 
 
802
        /*
 
803
         * Only call this function when a scan can't be
 
804
         * queued -- mostly at suspend under RTNL.
 
805
         */
 
806
        mutex_lock(&local->scan_mtx);
 
807
        abortscan = test_bit(SCAN_SW_SCANNING, &local->scanning) ||
 
808
                    (!local->scanning && local->scan_req);
 
809
        mutex_unlock(&local->scan_mtx);
 
810
 
 
811
        if (abortscan)
 
812
                ieee80211_scan_completed(&local->hw, true);
 
813
}