projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
fix some madwifi-testing bugs
[openwrt.git] / package / libertas / src / scan.c
1 /**
2 * Functions implementing wlan scan IOCTL and firmware command APIs
3 *
4 * IOCTL handlers as well as command preperation and response routines
5 * for sending scan commands to the firmware.
6 */
7 #include <linux/ctype.h>
8 #include <linux/if.h>
9 #include <linux/netdevice.h>
10 #include <linux/wireless.h>
11 #include <linux/etherdevice.h>
12
13 #include <net/ieee80211.h>
14 #include <net/iw_handler.h>
15
16 #include <asm/unaligned.h>
17
18 #include "host.h"
19 #include "decl.h"
20 #include "dev.h"
21 #include "scan.h"
22 #include "join.h"
23
24 //! Approximate amount of data needed to pass a scan result back to iwlist
25 #define MAX_SCAN_CELL_SIZE (IW_EV_ADDR_LEN \
26 + IW_ESSID_MAX_SIZE \
27 + IW_EV_UINT_LEN \
28 + IW_EV_FREQ_LEN \
29 + IW_EV_QUAL_LEN \
30 + IW_ESSID_MAX_SIZE \
31 + IW_EV_PARAM_LEN \
32 + 40) /* 40 for WPAIE */
33
34 //! Memory needed to store a max sized channel List TLV for a firmware scan
35 #define CHAN_TLV_MAX_SIZE (sizeof(struct mrvlietypesheader) \
36 + (MRVDRV_MAX_CHANNELS_PER_SCAN \
37 * sizeof(struct chanscanparamset)))
38
39 //! Memory needed to store a max number/size SSID TLV for a firmware scan
40 #define SSID_TLV_MAX_SIZE (1 * sizeof(struct mrvlietypes_ssidparamset))
41
42 //! Maximum memory needed for a lbs_scan_cmd_config with all TLVs at max
43 #define MAX_SCAN_CFG_ALLOC (sizeof(struct lbs_scan_cmd_config) \
44 + CHAN_TLV_MAX_SIZE \
45 + SSID_TLV_MAX_SIZE)
46
47 //! The maximum number of channels the firmware can scan per command
48 #define MRVDRV_MAX_CHANNELS_PER_SCAN 14
49
50 /**
51 * @brief Number of channels to scan per firmware scan command issuance.
52 *
53 * Number restricted to prevent hitting the limit on the amount of scan data
54 * returned in a single firmware scan command.
55 */
56 #define MRVDRV_CHANNELS_PER_SCAN_CMD 4
57
58 //! Scan time specified in the channel TLV for each channel for passive scans
59 #define MRVDRV_PASSIVE_SCAN_CHAN_TIME 100
60
61 //! Scan time specified in the channel TLV for each channel for active scans
62 #define MRVDRV_ACTIVE_SCAN_CHAN_TIME 100
63
64 static const u8 zeromac[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
65 static const u8 bcastmac[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
66
67
68
69
70 /*********************************************************************/
71 /* */
72 /* Misc helper functions */
73 /* */
74 /*********************************************************************/
75
76 static inline void clear_bss_descriptor (struct bss_descriptor * bss)
77 {
78 /* Don't blow away ->list, just BSS data */
79 memset(bss, 0, offsetof(struct bss_descriptor, list));
80 }
81
82 /**
83 * @brief Compare two SSIDs
84 *
85 * @param ssid1 A pointer to ssid to compare
86 * @param ssid2 A pointer to ssid to compare
87 *
88 * @return 0: ssid is same, otherwise is different
89 */
90 int lbs_ssid_cmp(u8 *ssid1, u8 ssid1_len, u8 *ssid2, u8 ssid2_len)
91 {
92 if (ssid1_len != ssid2_len)
93 return -1;
94
95 return memcmp(ssid1, ssid2, ssid1_len);
96 }
97
98 static inline int match_bss_no_security(struct lbs_802_11_security *secinfo,
99 struct bss_descriptor * match_bss)
100 {
101 if ( !secinfo->wep_enabled
102 && !secinfo->WPAenabled
103 && !secinfo->WPA2enabled
104 && match_bss->wpa_ie[0] != MFIE_TYPE_GENERIC
105 && match_bss->rsn_ie[0] != MFIE_TYPE_RSN
106 && !(match_bss->capability & WLAN_CAPABILITY_PRIVACY)) {
107 return 1;
108 }
109 return 0;
110 }
111
112 static inline int match_bss_static_wep(struct lbs_802_11_security *secinfo,
113 struct bss_descriptor * match_bss)
114 {
115 if ( secinfo->wep_enabled
116 && !secinfo->WPAenabled
117 && !secinfo->WPA2enabled
118 && (match_bss->capability & WLAN_CAPABILITY_PRIVACY)) {
119 return 1;
120 }
121 return 0;
122 }
123
124 static inline int match_bss_wpa(struct lbs_802_11_security *secinfo,
125 struct bss_descriptor * match_bss)
126 {
127 if ( !secinfo->wep_enabled
128 && secinfo->WPAenabled
129 && (match_bss->wpa_ie[0] == MFIE_TYPE_GENERIC)
130 /* privacy bit may NOT be set in some APs like LinkSys WRT54G
131 && (match_bss->capability & WLAN_CAPABILITY_PRIVACY)) {
132 */
133 ) {
134 return 1;
135 }
136 return 0;
137 }
138
139 static inline int match_bss_wpa2(struct lbs_802_11_security *secinfo,
140 struct bss_descriptor * match_bss)
141 {
142 if ( !secinfo->wep_enabled
143 && secinfo->WPA2enabled
144 && (match_bss->rsn_ie[0] == MFIE_TYPE_RSN)
145 /* privacy bit may NOT be set in some APs like LinkSys WRT54G
146 && (match_bss->capability & WLAN_CAPABILITY_PRIVACY)) {
147 */
148 ) {
149 return 1;
150 }
151 return 0;
152 }
153
154 static inline int match_bss_dynamic_wep(struct lbs_802_11_security *secinfo,
155 struct bss_descriptor * match_bss)
156 {
157 if ( !secinfo->wep_enabled
158 && !secinfo->WPAenabled
159 && !secinfo->WPA2enabled
160 && (match_bss->wpa_ie[0] != MFIE_TYPE_GENERIC)
161 && (match_bss->rsn_ie[0] != MFIE_TYPE_RSN)
162 && (match_bss->capability & WLAN_CAPABILITY_PRIVACY)) {
163 return 1;
164 }
165 return 0;
166 }
167
168 static inline int is_same_network(struct bss_descriptor *src,
169 struct bss_descriptor *dst)
170 {
171 /* A network is only a duplicate if the channel, BSSID, and ESSID
172 * all match. We treat all <hidden> with the same BSSID and channel
173 * as one network */
174 return ((src->ssid_len == dst->ssid_len) &&
175 (src->channel == dst->channel) &&
176 !compare_ether_addr(src->bssid, dst->bssid) &&
177 !memcmp(src->ssid, dst->ssid, src->ssid_len));
178 }
179
180 /**
181 * @brief Check if a scanned network compatible with the driver settings
182 *
183 * WEP WPA WPA2 ad-hoc encrypt Network
184 * enabled enabled enabled AES mode privacy WPA WPA2 Compatible
185 * 0 0 0 0 NONE 0 0 0 yes No security
186 * 1 0 0 0 NONE 1 0 0 yes Static WEP
187 * 0 1 0 0 x 1x 1 x yes WPA
188 * 0 0 1 0 x 1x x 1 yes WPA2
189 * 0 0 0 1 NONE 1 0 0 yes Ad-hoc AES
190 * 0 0 0 0 !=NONE 1 0 0 yes Dynamic WEP
191 *
192 *
193 * @param priv A pointer to struct lbs_private
194 * @param index Index in scantable to check against current driver settings
195 * @param mode Network mode: Infrastructure or IBSS
196 *
197 * @return Index in scantable, or error code if negative
198 */
199 static int is_network_compatible(struct lbs_private *priv,
200 struct bss_descriptor * bss, u8 mode)
201 {
202 int matched = 0;
203
204 lbs_deb_enter(LBS_DEB_SCAN);
205
206 if (bss->mode != mode)
207 goto done;
208
209 if ((matched = match_bss_no_security(&priv->secinfo, bss))) {
210 goto done;
211 } else if ((matched = match_bss_static_wep(&priv->secinfo, bss))) {
212 goto done;
213 } else if ((matched = match_bss_wpa(&priv->secinfo, bss))) {
214 lbs_deb_scan(
215 "is_network_compatible() WPA: wpa_ie 0x%x "
216 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
217 "privacy 0x%x\n", bss->wpa_ie[0], bss->rsn_ie[0],
218 priv->secinfo.wep_enabled ? "e" : "d",
219 priv->secinfo.WPAenabled ? "e" : "d",
220 priv->secinfo.WPA2enabled ? "e" : "d",
221 (bss->capability & WLAN_CAPABILITY_PRIVACY));
222 goto done;
223 } else if ((matched = match_bss_wpa2(&priv->secinfo, bss))) {
224 lbs_deb_scan(
225 "is_network_compatible() WPA2: wpa_ie 0x%x "
226 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
227 "privacy 0x%x\n", bss->wpa_ie[0], bss->rsn_ie[0],
228 priv->secinfo.wep_enabled ? "e" : "d",
229 priv->secinfo.WPAenabled ? "e" : "d",
230 priv->secinfo.WPA2enabled ? "e" : "d",
231 (bss->capability & WLAN_CAPABILITY_PRIVACY));
232 goto done;
233 } else if ((matched = match_bss_dynamic_wep(&priv->secinfo, bss))) {
234 lbs_deb_scan(
235 "is_network_compatible() dynamic WEP: "
236 "wpa_ie 0x%x wpa2_ie 0x%x privacy 0x%x\n",
237 bss->wpa_ie[0], bss->rsn_ie[0],
238 (bss->capability & WLAN_CAPABILITY_PRIVACY));
239 goto done;
240 }
241
242 /* bss security settings don't match those configured on card */
243 lbs_deb_scan(
244 "is_network_compatible() FAILED: wpa_ie 0x%x "
245 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s privacy 0x%x\n",
246 bss->wpa_ie[0], bss->rsn_ie[0],
247 priv->secinfo.wep_enabled ? "e" : "d",
248 priv->secinfo.WPAenabled ? "e" : "d",
249 priv->secinfo.WPA2enabled ? "e" : "d",
250 (bss->capability & WLAN_CAPABILITY_PRIVACY));
251
252 done:
253 lbs_deb_leave_args(LBS_DEB_SCAN, "matched: %d", matched);
254 return matched;
255 }
256
257
258
259
260 /*********************************************************************/
261 /* */
262 /* Main scanning support */
263 /* */
264 /*********************************************************************/
265
266 void lbs_scan_worker(struct work_struct *work)
267 {
268 struct lbs_private *priv =
269 container_of(work, struct lbs_private, scan_work.work);
270
271 lbs_deb_enter(LBS_DEB_SCAN);
272 lbs_scan_networks(priv, NULL, 0);
273 lbs_deb_leave(LBS_DEB_SCAN);
274 }
275
276
277 /**
278 * @brief Create a channel list for the driver to scan based on region info
279 *
280 * Only used from lbs_scan_setup_scan_config()
281 *
282 * Use the driver region/band information to construct a comprehensive list
283 * of channels to scan. This routine is used for any scan that is not
284 * provided a specific channel list to scan.
285 *
286 * @param priv A pointer to struct lbs_private structure
287 * @param scanchanlist Output parameter: resulting channel list to scan
288 * @param filteredscan Flag indicating whether or not a BSSID or SSID filter
289 * is being sent in the command to firmware. Used to
290 * increase the number of channels sent in a scan
291 * command and to disable the firmware channel scan
292 * filter.
293 *
294 * @return void
295 */
296 static int lbs_scan_create_channel_list(struct lbs_private *priv,
297 struct chanscanparamset * scanchanlist,
298 u8 filteredscan)
299 {
300
301 struct region_channel *scanregion;
302 struct chan_freq_power *cfp;
303 int rgnidx;
304 int chanidx;
305 int nextchan;
306 u8 scantype;
307
308 chanidx = 0;
309
310 /* Set the default scan type to the user specified type, will later
311 * be changed to passive on a per channel basis if restricted by
312 * regulatory requirements (11d or 11h)
313 */
314 scantype = CMD_SCAN_TYPE_ACTIVE;
315
316 for (rgnidx = 0; rgnidx < ARRAY_SIZE(priv->region_channel); rgnidx++) {
317 if (priv->enable11d &&
318 (priv->connect_status != LBS_CONNECTED) &&
319 (priv->mesh_connect_status != LBS_CONNECTED)) {
320 /* Scan all the supported chan for the first scan */
321 if (!priv->universal_channel[rgnidx].valid)
322 continue;
323 scanregion = &priv->universal_channel[rgnidx];
324
325 /* clear the parsed_region_chan for the first scan */
326 memset(&priv->parsed_region_chan, 0x00,
327 sizeof(priv->parsed_region_chan));
328 } else {
329 if (!priv->region_channel[rgnidx].valid)
330 continue;
331 scanregion = &priv->region_channel[rgnidx];
332 }
333
334 for (nextchan = 0;
335 nextchan < scanregion->nrcfp; nextchan++, chanidx++) {
336
337 cfp = scanregion->CFP + nextchan;
338
339 if (priv->enable11d) {
340 scantype =
341 lbs_get_scan_type_11d(cfp->channel,
342 &priv->
343 parsed_region_chan);
344 }
345
346 switch (scanregion->band) {
347 case BAND_B:
348 case BAND_G:
349 default:
350 scanchanlist[chanidx].radiotype =
351 CMD_SCAN_RADIO_TYPE_BG;
352 break;
353 }
354
355 if (scantype == CMD_SCAN_TYPE_PASSIVE) {
356 scanchanlist[chanidx].maxscantime =
357 cpu_to_le16(MRVDRV_PASSIVE_SCAN_CHAN_TIME);
358 scanchanlist[chanidx].chanscanmode.passivescan =
359 1;
360 } else {
361 scanchanlist[chanidx].maxscantime =
362 cpu_to_le16(MRVDRV_ACTIVE_SCAN_CHAN_TIME);
363 scanchanlist[chanidx].chanscanmode.passivescan =
364 0;
365 }
366
367 scanchanlist[chanidx].channumber = cfp->channel;
368
369 if (filteredscan) {
370 scanchanlist[chanidx].chanscanmode.
371 disablechanfilt = 1;
372 }
373 }
374 }
375 return chanidx;
376 }
377
378
379 /*
380 * Add SSID TLV of the form:
381 *
382 * TLV-ID SSID 00 00
383 * length 06 00
384 * ssid 4d 4e 54 45 53 54
385 */
386 static int lbs_scan_add_ssid_tlv(u8 *tlv,
387 const struct lbs_ioctl_user_scan_cfg *user_cfg)
388 {
389 struct mrvlietypes_ssidparamset *ssid_tlv =
390 (struct mrvlietypes_ssidparamset *)tlv;
391 ssid_tlv->header.type = cpu_to_le16(TLV_TYPE_SSID);
392 ssid_tlv->header.len = cpu_to_le16(user_cfg->ssid_len);
393 memcpy(ssid_tlv->ssid, user_cfg->ssid, user_cfg->ssid_len);
394 return sizeof(ssid_tlv->header) + user_cfg->ssid_len;
395 }
396
397
398 /*
399 * Add CHANLIST TLV of the form
400 *
401 * TLV-ID CHANLIST 01 01
402 * length 5b 00
403 * channel 1 00 01 00 00 00 64 00
404 * radio type 00
405 * channel 01
406 * scan type 00
407 * min scan time 00 00
408 * max scan time 64 00
409 * channel 2 00 02 00 00 00 64 00
410 * channel 3 00 03 00 00 00 64 00
411 * channel 4 00 04 00 00 00 64 00
412 * channel 5 00 05 00 00 00 64 00
413 * channel 6 00 06 00 00 00 64 00
414 * channel 7 00 07 00 00 00 64 00
415 * channel 8 00 08 00 00 00 64 00
416 * channel 9 00 09 00 00 00 64 00
417 * channel 10 00 0a 00 00 00 64 00
418 * channel 11 00 0b 00 00 00 64 00
419 * channel 12 00 0c 00 00 00 64 00
420 * channel 13 00 0d 00 00 00 64 00
421 *
422 */
423 static int lbs_scan_add_chanlist_tlv(u8 *tlv,
424 struct chanscanparamset *chan_list,
425 int chan_count)
426 {
427 size_t size = sizeof(struct chanscanparamset) * chan_count;
428 struct mrvlietypes_chanlistparamset *chan_tlv =
429 (struct mrvlietypes_chanlistparamset *) tlv;
430
431 chan_tlv->header.type = cpu_to_le16(TLV_TYPE_CHANLIST);
432 memcpy(chan_tlv->chanscanparam, chan_list, size);
433 chan_tlv->header.len = cpu_to_le16(size);
434 return sizeof(chan_tlv->header) + size;
435 }
436
437
438 /*
439 * Add RATES TLV of the form
440 *
441 * TLV-ID RATES 01 00
442 * length 0e 00
443 * rates 82 84 8b 96 0c 12 18 24 30 48 60 6c
444 *
445 * The rates are in lbs_bg_rates[], but for the 802.11b
446 * rates the high bit isn't set.
447 */
448 static int lbs_scan_add_rates_tlv(u8 *tlv)
449 {
450 int i;
451 struct mrvlietypes_ratesparamset *rate_tlv =
452 (struct mrvlietypes_ratesparamset *) tlv;
453
454 rate_tlv->header.type = cpu_to_le16(TLV_TYPE_RATES);
455 tlv += sizeof(rate_tlv->header);
456 for (i = 0; i < MAX_RATES; i++) {
457 *tlv = lbs_bg_rates[i];
458 if (*tlv == 0)
459 break;
460 /* This code makes sure that the 802.11b rates (1 MBit/s, 2
461 MBit/s, 5.5 MBit/s and 11 MBit/s get's the high bit set.
462 Note that the values are MBit/s * 2, to mark them as
463 basic rates so that the firmware likes it better */
464 if (*tlv == 0x02 || *tlv == 0x04 ||
465 *tlv == 0x0b || *tlv == 0x16)
466 *tlv |= 0x80;
467 tlv++;
468 }
469 rate_tlv->header.len = cpu_to_le16(i);
470 return sizeof(rate_tlv->header) + i;
471 }
472
473
474 /*
475 * Generate the CMD_802_11_SCAN command with the proper tlv
476 * for a bunch of channels.
477 */
478 static int lbs_do_scan(struct lbs_private *priv,
479 u8 bsstype,
480 struct chanscanparamset *chan_list,
481 int chan_count,
482 const struct lbs_ioctl_user_scan_cfg *user_cfg)
483 {
484 int ret = -ENOMEM;
485 struct lbs_scan_cmd_config *scan_cmd;
486 u8 *tlv; /* pointer into our current, growing TLV storage area */
487
488 lbs_deb_enter_args(LBS_DEB_SCAN, "bsstype %d, chanlist[].chan %d, "
489 "chan_count %d",
490 bsstype, chan_list[0].channumber, chan_count);
491
492 /* create the fixed part for scan command */
493 scan_cmd = kzalloc(MAX_SCAN_CFG_ALLOC, GFP_KERNEL);
494 if (scan_cmd == NULL)
495 goto out;
496 tlv = scan_cmd->tlvbuffer;
497 if (user_cfg)
498 memcpy(scan_cmd->bssid, user_cfg->bssid, ETH_ALEN);
499 scan_cmd->bsstype = bsstype;
500
501 /* add TLVs */
502 if (user_cfg && user_cfg->ssid_len)
503 tlv += lbs_scan_add_ssid_tlv(tlv, user_cfg);
504 if (chan_list && chan_count)
505 tlv += lbs_scan_add_chanlist_tlv(tlv, chan_list, chan_count);
506 tlv += lbs_scan_add_rates_tlv(tlv);
507
508 /* This is the final data we are about to send */
509 scan_cmd->tlvbufferlen = tlv - scan_cmd->tlvbuffer;
510 lbs_deb_hex(LBS_DEB_SCAN, "SCAN_CMD", (void *)scan_cmd, 1+6);
511 lbs_deb_hex(LBS_DEB_SCAN, "SCAN_TLV", scan_cmd->tlvbuffer,
512 scan_cmd->tlvbufferlen);
513
514 ret = lbs_prepare_and_send_command(priv, CMD_802_11_SCAN, 0,
515 CMD_OPTION_WAITFORRSP, 0, scan_cmd);
516 out:
517 kfree(scan_cmd);
518 lbs_deb_leave_args(LBS_DEB_SCAN, "ret %d", ret);
519 return ret;
520 }
521
522
523 /**
524 * @brief Internal function used to start a scan based on an input config
525 *
526 * Also used from debugfs
527 *
528 * Use the input user scan configuration information when provided in
529 * order to send the appropriate scan commands to firmware to populate or
530 * update the internal driver scan table
531 *
532 * @param priv A pointer to struct lbs_private structure
533 * @param puserscanin Pointer to the input configuration for the requested
534 * scan.
535 *
536 * @return 0 or < 0 if error
537 */
538 int lbs_scan_networks(struct lbs_private *priv,
539 const struct lbs_ioctl_user_scan_cfg *user_cfg,
540 int full_scan)
541 {
542 int ret = -ENOMEM;
543 struct chanscanparamset *chan_list;
544 struct chanscanparamset *curr_chans;
545 int chan_count;
546 u8 bsstype = CMD_BSS_TYPE_ANY;
547 int numchannels = MRVDRV_CHANNELS_PER_SCAN_CMD;
548 int filteredscan = 0;
549 union iwreq_data wrqu;
550 #ifdef CONFIG_LIBERTAS_DEBUG
551 struct bss_descriptor *iter;
552 int i = 0;
553 DECLARE_MAC_BUF(mac);
554 #endif
555
556 lbs_deb_enter_args(LBS_DEB_SCAN, "full_scan %d",
557 full_scan);
558
559 /* Cancel any partial outstanding partial scans if this scan
560 * is a full scan.
561 */
562 if (full_scan && delayed_work_pending(&priv->scan_work))
563 cancel_delayed_work(&priv->scan_work);
564
565 /* Determine same scan parameters */
566 if (user_cfg) {
567 if (user_cfg->bsstype)
568 bsstype = user_cfg->bsstype;
569 if (compare_ether_addr(user_cfg->bssid, &zeromac[0]) != 0) {
570 numchannels = MRVDRV_MAX_CHANNELS_PER_SCAN;
571 filteredscan = 1;
572 }
573 }
574 lbs_deb_scan("numchannels %d, bsstype %d, "
575 "filteredscan %d\n",
576 numchannels, bsstype, filteredscan);
577
578 /* Create list of channels to scan */
579 chan_list = kzalloc(sizeof(struct chanscanparamset) *
580 LBS_IOCTL_USER_SCAN_CHAN_MAX, GFP_KERNEL);
581 if (!chan_list) {
582 lbs_pr_alert("SCAN: chan_list empty\n");
583 goto out;
584 }
585
586 /* We want to scan all channels */
587 chan_count = lbs_scan_create_channel_list(priv, chan_list,
588 filteredscan);
589
590 netif_stop_queue(priv->dev);
591 netif_carrier_off(priv->dev);
592 if (priv->mesh_dev) {
593 netif_stop_queue(priv->mesh_dev);
594 netif_carrier_off(priv->mesh_dev);
595 }
596
597 /* Prepare to continue an interrupted scan */
598 lbs_deb_scan("chan_count %d, last_scanned_channel %d\n",
599 chan_count, priv->last_scanned_channel);
600 curr_chans = chan_list;
601 /* advance channel list by already-scanned-channels */
602 if (priv->last_scanned_channel > 0) {
603 curr_chans += priv->last_scanned_channel;
604 chan_count -= priv->last_scanned_channel;
605 }
606
607 /* Send scan command(s)
608 * numchannels contains the number of channels we should maximally scan
609 * chan_count is the total number of channels to scan
610 */
611
612 while (chan_count) {
613 int to_scan = min(numchannels, chan_count);
614 lbs_deb_scan("scanning %d of %d channels\n",
615 to_scan, chan_count);
616 ret = lbs_do_scan(priv, bsstype, curr_chans,
617 to_scan, user_cfg);
618 if (ret) {
619 lbs_pr_err("SCAN_CMD failed\n");
620 goto out2;
621 }
622 curr_chans += to_scan;
623 chan_count -= to_scan;
624
625 /* somehow schedule the next part of the scan */
626 if (chan_count &&
627 !full_scan &&
628 !priv->surpriseremoved) {
629 /* -1 marks just that we're currently scanning */
630 if (priv->last_scanned_channel < 0)
631 priv->last_scanned_channel = to_scan;
632 else
633 priv->last_scanned_channel += to_scan;
634 cancel_delayed_work(&priv->scan_work);
635 queue_delayed_work(priv->work_thread, &priv->scan_work,
636 msecs_to_jiffies(300));
637 /* skip over GIWSCAN event */
638 goto out;
639 }
640
641 }
642 memset(&wrqu, 0, sizeof(union iwreq_data));
643 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
644
645 #ifdef CONFIG_LIBERTAS_DEBUG
646 /* Dump the scan table */
647 mutex_lock(&priv->lock);
648 lbs_deb_scan("scan table:\n");
649 list_for_each_entry(iter, &priv->network_list, list)
650 lbs_deb_scan("%02d: BSSID %s, RSSI %d, SSID '%s'\n",
651 i++, print_mac(mac, iter->bssid), (s32) iter->rssi,
652 escape_essid(iter->ssid, iter->ssid_len));
653 mutex_unlock(&priv->lock);
654 #endif
655
656 out2:
657 priv->last_scanned_channel = 0;
658
659 out:
660 if (priv->connect_status == LBS_CONNECTED) {
661 netif_carrier_on(priv->dev);
662 if (!priv->tx_pending_len)
663 netif_wake_queue(priv->dev);
664 }
665 if (priv->mesh_dev && (priv->mesh_connect_status == LBS_CONNECTED)) {
666 netif_carrier_on(priv->mesh_dev);
667 if (!priv->tx_pending_len)
668 netif_wake_queue(priv->mesh_dev);
669 }
670 kfree(chan_list);
671
672 lbs_deb_leave_args(LBS_DEB_SCAN, "ret %d", ret);
673 return ret;
674 }
675
676
677
678
679 /*********************************************************************/
680 /* */
681 /* Result interpretation */
682 /* */
683 /*********************************************************************/
684
685 /**
686 * @brief Interpret a BSS scan response returned from the firmware
687 *
688 * Parse the various fixed fields and IEs passed back for a a BSS probe
689 * response or beacon from the scan command. Record information as needed
690 * in the scan table struct bss_descriptor for that entry.
691 *
692 * @param bss Output parameter: Pointer to the BSS Entry
693 *
694 * @return 0 or -1
695 */
696 static int lbs_process_bss(struct bss_descriptor *bss,
697 u8 ** pbeaconinfo, int *bytesleft)
698 {
699 struct ieeetypes_fhparamset *pFH;
700 struct ieeetypes_dsparamset *pDS;
701 struct ieeetypes_cfparamset *pCF;
702 struct ieeetypes_ibssparamset *pibss;
703 DECLARE_MAC_BUF(mac);
704 struct ieeetypes_countryinfoset *pcountryinfo;
705 u8 *pos, *end, *p;
706 u8 n_ex_rates = 0, got_basic_rates = 0, n_basic_rates = 0;
707 u16 beaconsize = 0;
708 int ret;
709
710 lbs_deb_enter(LBS_DEB_SCAN);
711
712 if (*bytesleft >= sizeof(beaconsize)) {
713 /* Extract & convert beacon size from the command buffer */
714 beaconsize = le16_to_cpu(get_unaligned((__le16 *)*pbeaconinfo));
715 *bytesleft -= sizeof(beaconsize);
716 *pbeaconinfo += sizeof(beaconsize);
717 }
718
719 if (beaconsize == 0 || beaconsize > *bytesleft) {
720 *pbeaconinfo += *bytesleft;
721 *bytesleft = 0;
722 ret = -1;
723 goto done;
724 }
725
726 /* Initialize the current working beacon pointer for this BSS iteration */
727 pos = *pbeaconinfo;
728 end = pos + beaconsize;
729
730 /* Advance the return beacon pointer past the current beacon */
731 *pbeaconinfo += beaconsize;
732 *bytesleft -= beaconsize;
733
734 memcpy(bss->bssid, pos, ETH_ALEN);
735 lbs_deb_scan("process_bss: BSSID %s\n", print_mac(mac, bss->bssid));
736 pos += ETH_ALEN;
737
738 if ((end - pos) < 12) {
739 lbs_deb_scan("process_bss: Not enough bytes left\n");
740 ret = -1;
741 goto done;
742 }
743
744 /*
745 * next 4 fields are RSSI, time stamp, beacon interval,
746 * and capability information
747 */
748
749 /* RSSI is 1 byte long */
750 bss->rssi = *pos;
751 lbs_deb_scan("process_bss: RSSI %d\n", *pos);
752 pos++;
753
754 /* time stamp is 8 bytes long */
755 pos += 8;
756
757 /* beacon interval is 2 bytes long */
758 bss->beaconperiod = le16_to_cpup((void *) pos);
759 pos += 2;
760
761 /* capability information is 2 bytes long */
762 bss->capability = le16_to_cpup((void *) pos);
763 lbs_deb_scan("process_bss: capabilities 0x%04x\n", bss->capability);
764 pos += 2;
765
766 if (bss->capability & WLAN_CAPABILITY_PRIVACY)
767 lbs_deb_scan("process_bss: WEP enabled\n");
768 if (bss->capability & WLAN_CAPABILITY_IBSS)
769 bss->mode = IW_MODE_ADHOC;
770 else
771 bss->mode = IW_MODE_INFRA;
772
773 /* rest of the current buffer are IE's */
774 lbs_deb_scan("process_bss: IE len %zd\n", end - pos);
775 lbs_deb_hex(LBS_DEB_SCAN, "process_bss: IE info", pos, end - pos);
776
777 /* process variable IE */
778 while (pos <= end - 2) {
779 struct ieee80211_info_element * elem =
780 (struct ieee80211_info_element *) pos;
781
782 if (pos + elem->len > end) {
783 lbs_deb_scan("process_bss: error in processing IE, "
784 "bytes left < IE length\n");
785 break;
786 }
787
788 switch (elem->id) {
789 case MFIE_TYPE_SSID:
790 bss->ssid_len = elem->len;
791 memcpy(bss->ssid, elem->data, elem->len);
792 lbs_deb_scan("got SSID IE: '%s', len %u\n",
793 escape_essid(bss->ssid, bss->ssid_len),
794 bss->ssid_len);
795 break;
796
797 case MFIE_TYPE_RATES:
798 n_basic_rates = min_t(u8, MAX_RATES, elem->len);
799 memcpy(bss->rates, elem->data, n_basic_rates);
800 got_basic_rates = 1;
801 lbs_deb_scan("got RATES IE\n");
802 break;
803
804 case MFIE_TYPE_FH_SET:
805 pFH = (struct ieeetypes_fhparamset *) pos;
806 memmove(&bss->phyparamset.fhparamset, pFH,
807 sizeof(struct ieeetypes_fhparamset));
808 lbs_deb_scan("got FH IE\n");
809 break;
810
811 case MFIE_TYPE_DS_SET:
812 pDS = (struct ieeetypes_dsparamset *) pos;
813 bss->channel = pDS->currentchan;
814 memcpy(&bss->phyparamset.dsparamset, pDS,
815 sizeof(struct ieeetypes_dsparamset));
816 lbs_deb_scan("got DS IE, channel %d\n", bss->channel);
817 break;
818
819 case MFIE_TYPE_CF_SET:
820 pCF = (struct ieeetypes_cfparamset *) pos;
821 memcpy(&bss->ssparamset.cfparamset, pCF,
822 sizeof(struct ieeetypes_cfparamset));
823 lbs_deb_scan("got CF IE\n");
824 break;
825
826 case MFIE_TYPE_IBSS_SET:
827 pibss = (struct ieeetypes_ibssparamset *) pos;
828 bss->atimwindow = le16_to_cpu(pibss->atimwindow);
829 memmove(&bss->ssparamset.ibssparamset, pibss,
830 sizeof(struct ieeetypes_ibssparamset));
831 lbs_deb_scan("got IBSS IE\n");
832 break;
833
834 case MFIE_TYPE_COUNTRY:
835 pcountryinfo = (struct ieeetypes_countryinfoset *) pos;
836 lbs_deb_scan("got COUNTRY IE\n");
837 if (pcountryinfo->len < sizeof(pcountryinfo->countrycode)
838 || pcountryinfo->len > 254) {
839 lbs_deb_scan("process_bss: 11D- Err "
840 "CountryInfo len %d, min %zd, max 254\n",
841 pcountryinfo->len,
842 sizeof(pcountryinfo->countrycode));
843 ret = -1;
844 goto done;
845 }
846
847 memcpy(&bss->countryinfo,
848 pcountryinfo, pcountryinfo->len + 2);
849 lbs_deb_hex(LBS_DEB_SCAN, "process_bss: 11d countryinfo",
850 (u8 *) pcountryinfo,
851 (u32) (pcountryinfo->len + 2));
852 break;
853
854 case MFIE_TYPE_RATES_EX:
855 /* only process extended supported rate if data rate is
856 * already found. Data rate IE should come before
857 * extended supported rate IE
858 */
859 lbs_deb_scan("got RATESEX IE\n");
860 if (!got_basic_rates) {
861 lbs_deb_scan("... but ignoring it\n");
862 break;
863 }
864
865 n_ex_rates = elem->len;
866 if (n_basic_rates + n_ex_rates > MAX_RATES)
867 n_ex_rates = MAX_RATES - n_basic_rates;
868
869 p = bss->rates + n_basic_rates;
870 memcpy(p, elem->data, n_ex_rates);
871 break;
872
873 case MFIE_TYPE_GENERIC:
874 if (elem->len >= 4 &&
875 elem->data[0] == 0x00 &&
876 elem->data[1] == 0x50 &&
877 elem->data[2] == 0xf2 &&
878 elem->data[3] == 0x01) {
879 bss->wpa_ie_len = min(elem->len + 2,
880 MAX_WPA_IE_LEN);
881 memcpy(bss->wpa_ie, elem, bss->wpa_ie_len);
882 lbs_deb_scan("got WPA IE\n");
883 lbs_deb_hex(LBS_DEB_SCAN, "WPA IE", bss->wpa_ie,
884 elem->len);
885 } else if (elem->len >= MARVELL_MESH_IE_LENGTH &&
886 elem->data[0] == 0x00 &&
887 elem->data[1] == 0x50 &&
888 elem->data[2] == 0x43 &&
889 elem->data[3] == 0x04) {
890 lbs_deb_scan("got mesh IE\n");
891 bss->mesh = 1;
892 } else {
893 lbs_deb_scan("got generiec IE: "
894 "%02x:%02x:%02x:%02x, len %d\n",
895 elem->data[0], elem->data[1],
896 elem->data[2], elem->data[3],
897 elem->len);
898 }
899 break;
900
901 case MFIE_TYPE_RSN:
902 lbs_deb_scan("got RSN IE\n");
903 bss->rsn_ie_len = min(elem->len + 2, MAX_WPA_IE_LEN);
904 memcpy(bss->rsn_ie, elem, bss->rsn_ie_len);
905 lbs_deb_hex(LBS_DEB_SCAN, "process_bss: RSN_IE",
906 bss->rsn_ie, elem->len);
907 break;
908
909 default:
910 lbs_deb_scan("got IE 0x%04x, len %d\n",
911 elem->id, elem->len);
912 break;
913 }
914
915 pos += elem->len + 2;
916 }
917
918 /* Timestamp */
919 bss->last_scanned = jiffies;
920 lbs_unset_basic_rate_flags(bss->rates, sizeof(bss->rates));
921
922 ret = 0;
923
924 done:
925 lbs_deb_leave_args(LBS_DEB_SCAN, "ret %d", ret);
926 return ret;
927 }
928
929 /**
930 * @brief This function finds a specific compatible BSSID in the scan list
931 *
932 * Used in association code
933 *
934 * @param priv A pointer to struct lbs_private
935 * @param bssid BSSID to find in the scan list
936 * @param mode Network mode: Infrastructure or IBSS
937 *
938 * @return index in BSSID list, or error return code (< 0)
939 */
940 struct bss_descriptor *lbs_find_bssid_in_list(struct lbs_private *priv,
941 u8 * bssid, u8 mode)
942 {
943 struct bss_descriptor * iter_bss;
944 struct bss_descriptor * found_bss = NULL;
945
946 lbs_deb_enter(LBS_DEB_SCAN);
947
948 if (!bssid)
949 goto out;
950
951 lbs_deb_hex(LBS_DEB_SCAN, "looking for",
952 bssid, ETH_ALEN);
953
954 /* Look through the scan table for a compatible match. The loop will
955 * continue past a matched bssid that is not compatible in case there
956 * is an AP with multiple SSIDs assigned to the same BSSID
957 */
958 mutex_lock(&priv->lock);
959 list_for_each_entry (iter_bss, &priv->network_list, list) {
960 if (compare_ether_addr(iter_bss->bssid, bssid))
961 continue; /* bssid doesn't match */
962 switch (mode) {
963 case IW_MODE_INFRA:
964 case IW_MODE_ADHOC:
965 if (!is_network_compatible(priv, iter_bss, mode))
966 break;
967 found_bss = iter_bss;
968 break;
969 default:
970 found_bss = iter_bss;
971 break;
972 }
973 }
974 mutex_unlock(&priv->lock);
975
976 out:
977 lbs_deb_leave_args(LBS_DEB_SCAN, "found_bss %p", found_bss);
978 return found_bss;
979 }
980
981 /**
982 * @brief This function finds ssid in ssid list.
983 *
984 * Used in association code
985 *
986 * @param priv A pointer to struct lbs_private
987 * @param ssid SSID to find in the list
988 * @param bssid BSSID to qualify the SSID selection (if provided)
989 * @param mode Network mode: Infrastructure or IBSS
990 *
991 * @return index in BSSID list
992 */
993 struct bss_descriptor *lbs_find_ssid_in_list(struct lbs_private *priv,
994 u8 *ssid, u8 ssid_len, u8 * bssid, u8 mode,
995 int channel)
996 {
997 u8 bestrssi = 0;
998 struct bss_descriptor * iter_bss = NULL;
999 struct bss_descriptor * found_bss = NULL;
1000 struct bss_descriptor * tmp_oldest = NULL;
1001
1002 lbs_deb_enter(LBS_DEB_SCAN);
1003
1004 mutex_lock(&priv->lock);
1005
1006 list_for_each_entry (iter_bss, &priv->network_list, list) {
1007 if ( !tmp_oldest
1008 || (iter_bss->last_scanned < tmp_oldest->last_scanned))
1009 tmp_oldest = iter_bss;
1010
1011 if (lbs_ssid_cmp(iter_bss->ssid, iter_bss->ssid_len,
1012 ssid, ssid_len) != 0)
1013 continue; /* ssid doesn't match */
1014 if (bssid && compare_ether_addr(iter_bss->bssid, bssid) != 0)
1015 continue; /* bssid doesn't match */
1016 if ((channel > 0) && (iter_bss->channel != channel))
1017 continue; /* channel doesn't match */
1018
1019 switch (mode) {
1020 case IW_MODE_INFRA:
1021 case IW_MODE_ADHOC:
1022 if (!is_network_compatible(priv, iter_bss, mode))
1023 break;
1024
1025 if (bssid) {
1026 /* Found requested BSSID */
1027 found_bss = iter_bss;
1028 goto out;
1029 }
1030
1031 if (SCAN_RSSI(iter_bss->rssi) > bestrssi) {
1032 bestrssi = SCAN_RSSI(iter_bss->rssi);
1033 found_bss = iter_bss;
1034 }
1035 break;
1036 case IW_MODE_AUTO:
1037 default:
1038 if (SCAN_RSSI(iter_bss->rssi) > bestrssi) {
1039 bestrssi = SCAN_RSSI(iter_bss->rssi);
1040 found_bss = iter_bss;
1041 }
1042 break;
1043 }
1044 }
1045
1046 out:
1047 mutex_unlock(&priv->lock);
1048 lbs_deb_leave_args(LBS_DEB_SCAN, "found_bss %p", found_bss);
1049 return found_bss;
1050 }
1051
1052 /**
1053 * @brief This function finds the best SSID in the Scan List
1054 *
1055 * Search the scan table for the best SSID that also matches the current
1056 * adapter network preference (infrastructure or adhoc)
1057 *
1058 * @param priv A pointer to struct lbs_private
1059 *
1060 * @return index in BSSID list
1061 */
1062 static struct bss_descriptor *lbs_find_best_ssid_in_list(
1063 struct lbs_private *priv,
1064 u8 mode)
1065 {
1066 u8 bestrssi = 0;
1067 struct bss_descriptor * iter_bss;
1068 struct bss_descriptor * best_bss = NULL;
1069
1070 lbs_deb_enter(LBS_DEB_SCAN);
1071
1072 mutex_lock(&priv->lock);
1073
1074 list_for_each_entry (iter_bss, &priv->network_list, list) {
1075 switch (mode) {
1076 case IW_MODE_INFRA:
1077 case IW_MODE_ADHOC:
1078 if (!is_network_compatible(priv, iter_bss, mode))
1079 break;
1080 if (SCAN_RSSI(iter_bss->rssi) <= bestrssi)
1081 break;
1082 bestrssi = SCAN_RSSI(iter_bss->rssi);
1083 best_bss = iter_bss;
1084 break;
1085 case IW_MODE_AUTO:
1086 default:
1087 if (SCAN_RSSI(iter_bss->rssi) <= bestrssi)
1088 break;
1089 bestrssi = SCAN_RSSI(iter_bss->rssi);
1090 best_bss = iter_bss;
1091 break;
1092 }
1093 }
1094
1095 mutex_unlock(&priv->lock);
1096 lbs_deb_leave_args(LBS_DEB_SCAN, "best_bss %p", best_bss);
1097 return best_bss;
1098 }
1099
1100 /**
1101 * @brief Find the AP with specific ssid in the scan list
1102 *
1103 * Used from association worker.
1104 *
1105 * @param priv A pointer to struct lbs_private structure
1106 * @param pSSID A pointer to AP's ssid
1107 *
1108 * @return 0--success, otherwise--fail
1109 */
1110 int lbs_find_best_network_ssid(struct lbs_private *priv,
1111 u8 *out_ssid, u8 *out_ssid_len, u8 preferred_mode, u8 *out_mode)
1112 {
1113 int ret = -1;
1114 struct bss_descriptor * found;
1115
1116 lbs_deb_enter(LBS_DEB_SCAN);
1117
1118 lbs_scan_networks(priv, NULL, 1);
1119 if (priv->surpriseremoved)
1120 goto out;
1121
1122 found = lbs_find_best_ssid_in_list(priv, preferred_mode);
1123 if (found && (found->ssid_len > 0)) {
1124 memcpy(out_ssid, &found->ssid, IW_ESSID_MAX_SIZE);
1125 *out_ssid_len = found->ssid_len;
1126 *out_mode = found->mode;
1127 ret = 0;
1128 }
1129
1130 out:
1131 lbs_deb_leave_args(LBS_DEB_SCAN, "ret %d", ret);
1132 return ret;
1133 }
1134
1135
1136 /**
1137 * @brief Send a scan command for all available channels filtered on a spec
1138 *
1139 * Used in association code and from debugfs
1140 *
1141 * @param priv A pointer to struct lbs_private structure
1142 * @param ssid A pointer to the SSID to scan for
1143 * @param ssid_len Length of the SSID
1144 * @param clear_ssid Should existing scan results with this SSID
1145 * be cleared?
1146 *
1147 * @return 0-success, otherwise fail
1148 */
1149 int lbs_send_specific_ssid_scan(struct lbs_private *priv,
1150 u8 *ssid, u8 ssid_len, u8 clear_ssid)
1151 {
1152 struct lbs_ioctl_user_scan_cfg scancfg;
1153 int ret = 0;
1154
1155 lbs_deb_enter_args(LBS_DEB_SCAN, "SSID '%s', clear %d",
1156 escape_essid(ssid, ssid_len), clear_ssid);
1157
1158 if (!ssid_len)
1159 goto out;
1160
1161 memset(&scancfg, 0x00, sizeof(scancfg));
1162 memcpy(scancfg.ssid, ssid, ssid_len);
1163 scancfg.ssid_len = ssid_len;
1164 scancfg.clear_ssid = clear_ssid;
1165
1166 lbs_scan_networks(priv, &scancfg, 1);
1167 if (priv->surpriseremoved) {
1168 ret = -1;
1169 goto out;
1170 }
1171
1172 out:
1173 lbs_deb_leave_args(LBS_DEB_SCAN, "ret %d", ret);
1174 return ret;
1175 }
1176
1177
1178
1179
1180 /*********************************************************************/
1181 /* */
1182 /* Support for Wireless Extensions */
1183 /* */
1184 /*********************************************************************/
1185
1186
1187 #define MAX_CUSTOM_LEN 64
1188
1189 static inline char *lbs_translate_scan(struct lbs_private *priv,
1190 char *start, char *stop,
1191 struct bss_descriptor *bss)
1192 {
1193 struct chan_freq_power *cfp;
1194 char *current_val; /* For rates */
1195 struct iw_event iwe; /* Temporary buffer */
1196 int j;
1197 #define PERFECT_RSSI ((u8)50)
1198 #define WORST_RSSI ((u8)0)
1199 #define RSSI_DIFF ((u8)(PERFECT_RSSI - WORST_RSSI))
1200 u8 rssi;
1201
1202 lbs_deb_enter(LBS_DEB_SCAN);
1203
1204 cfp = lbs_find_cfp_by_band_and_channel(priv, 0, bss->channel);
1205 if (!cfp) {
1206 lbs_deb_scan("Invalid channel number %d\n", bss->channel);
1207 start = NULL;
1208 goto out;
1209 }
1210
1211 /* First entry *MUST* be the BSSID */
1212 iwe.cmd = SIOCGIWAP;
1213 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1214 memcpy(iwe.u.ap_addr.sa_data, &bss->bssid, ETH_ALEN);
1215 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_ADDR_LEN);
1216
1217 /* SSID */
1218 iwe.cmd = SIOCGIWESSID;
1219 iwe.u.data.flags = 1;
1220 iwe.u.data.length = min((u32) bss->ssid_len, (u32) IW_ESSID_MAX_SIZE);
1221 start = iwe_stream_add_point(start, stop, &iwe, bss->ssid);
1222
1223 /* Mode */
1224 iwe.cmd = SIOCGIWMODE;
1225 iwe.u.mode = bss->mode;
1226 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_UINT_LEN);
1227
1228 /* Frequency */
1229 iwe.cmd = SIOCGIWFREQ;
1230 iwe.u.freq.m = (long)cfp->freq * 100000;
1231 iwe.u.freq.e = 1;
1232 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_FREQ_LEN);
1233
1234 /* Add quality statistics */
1235 iwe.cmd = IWEVQUAL;
1236 iwe.u.qual.updated = IW_QUAL_ALL_UPDATED;
1237 iwe.u.qual.level = SCAN_RSSI(bss->rssi);
1238
1239 rssi = iwe.u.qual.level - MRVDRV_NF_DEFAULT_SCAN_VALUE;
1240 iwe.u.qual.qual =
1241 (100 * RSSI_DIFF * RSSI_DIFF - (PERFECT_RSSI - rssi) *
1242 (15 * (RSSI_DIFF) + 62 * (PERFECT_RSSI - rssi))) /
1243 (RSSI_DIFF * RSSI_DIFF);
1244 if (iwe.u.qual.qual > 100)
1245 iwe.u.qual.qual = 100;
1246
1247 if (priv->NF[TYPE_BEACON][TYPE_NOAVG] == 0) {
1248 iwe.u.qual.noise = MRVDRV_NF_DEFAULT_SCAN_VALUE;
1249 } else {
1250 iwe.u.qual.noise =
1251 CAL_NF(priv->NF[TYPE_BEACON][TYPE_NOAVG]);
1252 }
1253
1254 /* Locally created ad-hoc BSSs won't have beacons if this is the
1255 * only station in the adhoc network; so get signal strength
1256 * from receive statistics.
1257 */
1258 if ((priv->mode == IW_MODE_ADHOC)
1259 && priv->adhoccreate
1260 && !lbs_ssid_cmp(priv->curbssparams.ssid,
1261 priv->curbssparams.ssid_len,
1262 bss->ssid, bss->ssid_len)) {
1263 int snr, nf;
1264 snr = priv->SNR[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
1265 nf = priv->NF[TYPE_RXPD][TYPE_AVG] / AVG_SCALE;
1266 iwe.u.qual.level = CAL_RSSI(snr, nf);
1267 }
1268 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_QUAL_LEN);
1269
1270 /* Add encryption capability */
1271 iwe.cmd = SIOCGIWENCODE;
1272 if (bss->capability & WLAN_CAPABILITY_PRIVACY) {
1273 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1274 } else {
1275 iwe.u.data.flags = IW_ENCODE_DISABLED;
1276 }
1277 iwe.u.data.length = 0;
1278 start = iwe_stream_add_point(start, stop, &iwe, bss->ssid);
1279
1280 current_val = start + IW_EV_LCP_LEN;
1281
1282 iwe.cmd = SIOCGIWRATE;
1283 iwe.u.bitrate.fixed = 0;
1284 iwe.u.bitrate.disabled = 0;
1285 iwe.u.bitrate.value = 0;
1286
1287 for (j = 0; bss->rates[j] && (j < sizeof(bss->rates)); j++) {
1288 /* Bit rate given in 500 kb/s units */
1289 iwe.u.bitrate.value = bss->rates[j] * 500000;
1290 current_val = iwe_stream_add_value(start, current_val,
1291 stop, &iwe, IW_EV_PARAM_LEN);
1292 }
1293 if ((bss->mode == IW_MODE_ADHOC)
1294 && !lbs_ssid_cmp(priv->curbssparams.ssid,
1295 priv->curbssparams.ssid_len,
1296 bss->ssid, bss->ssid_len)
1297 && priv->adhoccreate) {
1298 iwe.u.bitrate.value = 22 * 500000;
1299 current_val = iwe_stream_add_value(start, current_val,
1300 stop, &iwe, IW_EV_PARAM_LEN);
1301 }
1302 /* Check if we added any event */
1303 if((current_val - start) > IW_EV_LCP_LEN)
1304 start = current_val;
1305
1306 memset(&iwe, 0, sizeof(iwe));
1307 if (bss->wpa_ie_len) {
1308 char buf[MAX_WPA_IE_LEN];
1309 memcpy(buf, bss->wpa_ie, bss->wpa_ie_len);
1310 iwe.cmd = IWEVGENIE;
1311 iwe.u.data.length = bss->wpa_ie_len;
1312 start = iwe_stream_add_point(start, stop, &iwe, buf);
1313 }
1314
1315 memset(&iwe, 0, sizeof(iwe));
1316 if (bss->rsn_ie_len) {
1317 char buf[MAX_WPA_IE_LEN];
1318 memcpy(buf, bss->rsn_ie, bss->rsn_ie_len);
1319 iwe.cmd = IWEVGENIE;
1320 iwe.u.data.length = bss->rsn_ie_len;
1321 start = iwe_stream_add_point(start, stop, &iwe, buf);
1322 }
1323
1324 if (bss->mesh) {
1325 char custom[MAX_CUSTOM_LEN];
1326 char *p = custom;
1327
1328 iwe.cmd = IWEVCUSTOM;
1329 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
1330 "mesh-type: olpc");
1331 iwe.u.data.length = p - custom;
1332 if (iwe.u.data.length)
1333 start = iwe_stream_add_point(start, stop, &iwe, custom);
1334 }
1335
1336 out:
1337 lbs_deb_leave_args(LBS_DEB_SCAN, "start %p", start);
1338 return start;
1339 }
1340
1341
1342 /**
1343 * @brief Handle Scan Network ioctl
1344 *
1345 * @param dev A pointer to net_device structure
1346 * @param info A pointer to iw_request_info structure
1347 * @param vwrq A pointer to iw_param structure
1348 * @param extra A pointer to extra data buf
1349 *
1350 * @return 0 --success, otherwise fail
1351 */
1352 int lbs_set_scan(struct net_device *dev, struct iw_request_info *info,
1353 struct iw_param *wrqu, char *extra)
1354 {
1355 struct lbs_private *priv = dev->priv;
1356
1357 lbs_deb_enter(LBS_DEB_SCAN);
1358
1359 if (!netif_running(dev))
1360 return -ENETDOWN;
1361
1362 /* mac80211 does this:
1363 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1364 if (sdata->type != IEEE80211_IF_TYPE_xxx)
1365 return -EOPNOTSUPP;
1366
1367 if (wrqu->data.length == sizeof(struct iw_scan_req) &&
1368 wrqu->data.flags & IW_SCAN_THIS_ESSID) {
1369 req = (struct iw_scan_req *)extra;
1370 ssid = req->essid;
1371 ssid_len = req->essid_len;
1372 }
1373 */
1374
1375 if (!delayed_work_pending(&priv->scan_work))
1376 queue_delayed_work(priv->work_thread, &priv->scan_work,
1377 msecs_to_jiffies(50));
1378 /* set marker that currently a scan is taking place */
1379 priv->last_scanned_channel = -1;
1380
1381 if (priv->surpriseremoved)
1382 return -EIO;
1383
1384 lbs_deb_leave(LBS_DEB_SCAN);
1385 return 0;
1386 }
1387
1388
1389 /**
1390 * @brief Handle Retrieve scan table ioctl
1391 *
1392 * @param dev A pointer to net_device structure
1393 * @param info A pointer to iw_request_info structure
1394 * @param dwrq A pointer to iw_point structure
1395 * @param extra A pointer to extra data buf
1396 *
1397 * @return 0 --success, otherwise fail
1398 */
1399 int lbs_get_scan(struct net_device *dev, struct iw_request_info *info,
1400 struct iw_point *dwrq, char *extra)
1401 {
1402 #define SCAN_ITEM_SIZE 128
1403 struct lbs_private *priv = dev->priv;
1404 int err = 0;
1405 char *ev = extra;
1406 char *stop = ev + dwrq->length;
1407 struct bss_descriptor * iter_bss;
1408 struct bss_descriptor * safe;
1409
1410 lbs_deb_enter(LBS_DEB_SCAN);
1411
1412 /* iwlist should wait until the current scan is finished */
1413 if (priv->last_scanned_channel)
1414 return -EAGAIN;
1415
1416 /* Update RSSI if current BSS is a locally created ad-hoc BSS */
1417 if ((priv->mode == IW_MODE_ADHOC) && priv->adhoccreate) {
1418 lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
1419 CMD_OPTION_WAITFORRSP, 0, NULL);
1420 }
1421
1422 mutex_lock(&priv->lock);
1423 list_for_each_entry_safe (iter_bss, safe, &priv->network_list, list) {
1424 char * next_ev;
1425 unsigned long stale_time;
1426
1427 if (stop - ev < SCAN_ITEM_SIZE) {
1428 err = -E2BIG;
1429 break;
1430 }
1431
1432 /* For mesh device, list only mesh networks */
1433 if (dev == priv->mesh_dev && !iter_bss->mesh)
1434 continue;
1435
1436 /* Prune old an old scan result */
1437 stale_time = iter_bss->last_scanned + DEFAULT_MAX_SCAN_AGE;
1438 if (time_after(jiffies, stale_time)) {
1439 list_move_tail (&iter_bss->list,
1440 &priv->network_free_list);
1441 clear_bss_descriptor(iter_bss);
1442 continue;
1443 }
1444
1445 /* Translate to WE format this entry */
1446 next_ev = lbs_translate_scan(priv, ev, stop, iter_bss);
1447 if (next_ev == NULL)
1448 continue;
1449 ev = next_ev;
1450 }
1451 mutex_unlock(&priv->lock);
1452
1453 dwrq->length = (ev - extra);
1454 dwrq->flags = 0;
1455
1456 lbs_deb_leave_args(LBS_DEB_SCAN, "ret %d", err);
1457 return err;
1458 }
1459
1460
1461
1462
1463 /*********************************************************************/
1464 /* */
1465 /* Command execution */
1466 /* */
1467 /*********************************************************************/
1468
1469
1470 /**
1471 * @brief Prepare a scan command to be sent to the firmware
1472 *
1473 * Called via lbs_prepare_and_send_command(priv, CMD_802_11_SCAN, ...)
1474 * from cmd.c
1475 *
1476 * Sends a fixed lenght data part (specifying the BSS type and BSSID filters)
1477 * as well as a variable number/length of TLVs to the firmware.
1478 *
1479 * @param priv A pointer to struct lbs_private structure
1480 * @param cmd A pointer to cmd_ds_command structure to be sent to
1481 * firmware with the cmd_DS_801_11_SCAN structure
1482 * @param pdata_buf Void pointer cast of a lbs_scan_cmd_config struct used
1483 * to set the fields/TLVs for the command sent to firmware
1484 *
1485 * @return 0 or -1
1486 */
1487 int lbs_cmd_80211_scan(struct lbs_private *priv,
1488 struct cmd_ds_command *cmd, void *pdata_buf)
1489 {
1490 struct cmd_ds_802_11_scan *pscan = &cmd->params.scan;
1491 struct lbs_scan_cmd_config *pscancfg = pdata_buf;
1492
1493 lbs_deb_enter(LBS_DEB_SCAN);
1494
1495 /* Set fixed field variables in scan command */
1496 pscan->bsstype = pscancfg->bsstype;
1497 memcpy(pscan->bssid, pscancfg->bssid, ETH_ALEN);
1498 memcpy(pscan->tlvbuffer, pscancfg->tlvbuffer, pscancfg->tlvbufferlen);
1499
1500 /* size is equal to the sizeof(fixed portions) + the TLV len + header */
1501 cmd->size = cpu_to_le16(sizeof(pscan->bsstype) + ETH_ALEN
1502 + pscancfg->tlvbufferlen + S_DS_GEN);
1503
1504 lbs_deb_leave(LBS_DEB_SCAN);
1505 return 0;
1506 }
1507
1508 /**
1509 * @brief This function handles the command response of scan
1510 *
1511 * Called from handle_cmd_response() in cmdrespc.
1512 *
1513 * The response buffer for the scan command has the following
1514 * memory layout:
1515 *
1516 * .-----------------------------------------------------------.
1517 * | header (4 * sizeof(u16)): Standard command response hdr |
1518 * .-----------------------------------------------------------.
1519 * | bufsize (u16) : sizeof the BSS Description data |
1520 * .-----------------------------------------------------------.
1521 * | NumOfSet (u8) : Number of BSS Descs returned |
1522 * .-----------------------------------------------------------.
1523 * | BSSDescription data (variable, size given in bufsize) |
1524 * .-----------------------------------------------------------.
1525 * | TLV data (variable, size calculated using header->size, |
1526 * | bufsize and sizeof the fixed fields above) |
1527 * .-----------------------------------------------------------.
1528 *
1529 * @param priv A pointer to struct lbs_private structure
1530 * @param resp A pointer to cmd_ds_command
1531 *
1532 * @return 0 or -1
1533 */
1534 int lbs_ret_80211_scan(struct lbs_private *priv, struct cmd_ds_command *resp)
1535 {
1536 struct cmd_ds_802_11_scan_rsp *pscan;
1537 struct bss_descriptor * iter_bss;
1538 struct bss_descriptor * safe;
1539 u8 *pbssinfo;
1540 u16 scanrespsize;
1541 int bytesleft;
1542 int idx;
1543 int tlvbufsize;
1544 int ret;
1545
1546 lbs_deb_enter(LBS_DEB_SCAN);
1547
1548 /* Prune old entries from scan table */
1549 list_for_each_entry_safe (iter_bss, safe, &priv->network_list, list) {
1550 unsigned long stale_time = iter_bss->last_scanned + DEFAULT_MAX_SCAN_AGE;
1551 if (time_before(jiffies, stale_time))
1552 continue;
1553 list_move_tail (&iter_bss->list, &priv->network_free_list);
1554 clear_bss_descriptor(iter_bss);
1555 }
1556
1557 pscan = &resp->params.scanresp;
1558
1559 if (pscan->nr_sets > MAX_NETWORK_COUNT) {
1560 lbs_deb_scan(
1561 "SCAN_RESP: too many scan results (%d, max %d)!!\n",
1562 pscan->nr_sets, MAX_NETWORK_COUNT);
1563 ret = -1;
1564 goto done;
1565 }
1566
1567 bytesleft = le16_to_cpu(pscan->bssdescriptsize);
1568 lbs_deb_scan("SCAN_RESP: bssdescriptsize %d\n", bytesleft);
1569
1570 scanrespsize = le16_to_cpu(resp->size);
1571 lbs_deb_scan("SCAN_RESP: scan results %d\n", pscan->nr_sets);
1572
1573 pbssinfo = pscan->bssdesc_and_tlvbuffer;
1574
1575 /* The size of the TLV buffer is equal to the entire command response
1576 * size (scanrespsize) minus the fixed fields (sizeof()'s), the
1577 * BSS Descriptions (bssdescriptsize as bytesLef) and the command
1578 * response header (S_DS_GEN)
1579 */
1580 tlvbufsize = scanrespsize - (bytesleft + sizeof(pscan->bssdescriptsize)
1581 + sizeof(pscan->nr_sets)
1582 + S_DS_GEN);
1583
1584 /*
1585 * Process each scan response returned (pscan->nr_sets). Save
1586 * the information in the newbssentry and then insert into the
1587 * driver scan table either as an update to an existing entry
1588 * or as an addition at the end of the table
1589 */
1590 for (idx = 0; idx < pscan->nr_sets && bytesleft; idx++) {
1591 struct bss_descriptor new;
1592 struct bss_descriptor * found = NULL;
1593 struct bss_descriptor * oldest = NULL;
1594 DECLARE_MAC_BUF(mac);
1595
1596 /* Process the data fields and IEs returned for this BSS */
1597 memset(&new, 0, sizeof (struct bss_descriptor));
1598 if (lbs_process_bss(&new, &pbssinfo, &bytesleft) != 0) {
1599 /* error parsing the scan response, skipped */
1600 lbs_deb_scan("SCAN_RESP: process_bss returned ERROR\n");
1601 continue;
1602 }
1603
1604 /* Try to find this bss in the scan table */
1605 list_for_each_entry (iter_bss, &priv->network_list, list) {
1606 if (is_same_network(iter_bss, &new)) {
1607 found = iter_bss;
1608 break;
1609 }
1610
1611 if ((oldest == NULL) ||
1612 (iter_bss->last_scanned < oldest->last_scanned))
1613 oldest = iter_bss;
1614 }
1615
1616 if (found) {
1617 /* found, clear it */
1618 clear_bss_descriptor(found);
1619 } else if (!list_empty(&priv->network_free_list)) {
1620 /* Pull one from the free list */
1621 found = list_entry(priv->network_free_list.next,
1622 struct bss_descriptor, list);
1623 list_move_tail(&found->list, &priv->network_list);
1624 } else if (oldest) {
1625 /* If there are no more slots, expire the oldest */
1626 found = oldest;
1627 clear_bss_descriptor(found);
1628 list_move_tail(&found->list, &priv->network_list);
1629 } else {
1630 continue;
1631 }
1632
1633 lbs_deb_scan("SCAN_RESP: BSSID %s\n",
1634 print_mac(mac, new.bssid));
1635
1636 /* Copy the locally created newbssentry to the scan table */
1637 memcpy(found, &new, offsetof(struct bss_descriptor, list));
1638 }
1639
1640 ret = 0;
1641
1642 done:
1643 lbs_deb_leave_args(LBS_DEB_SCAN, "ret %d", ret);
1644 return ret;
1645 }
Personal OpenWRT clone
This page took 0.11574 seconds and 5 git commands to generate.