1 /* Copyright (C) 2006, Red Hat, Inc. */
3 #include <linux/etherdevice.h>
11 static int lbs_adhoc_post(struct lbs_private
*priv
, struct cmd_header
*resp
);
13 static const u8 bssid_any
[ETH_ALEN
] __attribute__ ((aligned (2))) =
14 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
15 static const u8 bssid_off
[ETH_ALEN
] __attribute__ ((aligned (2))) =
16 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
18 /* The firmware needs certain bits masked out of the beacon-derviced capability
19 * field when associating/joining to BSSs.
21 #define CAPINFO_MASK (~(0xda00))
25 * @brief This function finds common rates between rates and card rates.
27 * It will fill common rates in rates as output if found.
29 * NOTE: Setting the MSB of the basic rates need to be taken
30 * care, either before or after calling this function
32 * @param priv A pointer to struct lbs_private structure
33 * @param rates the buffer which keeps input and output
34 * @param rates_size the size of rate1 buffer; new size of buffer on return
36 * @return 0 on success, or -1 on error
38 static int get_common_rates(struct lbs_private
*priv
,
42 u8
*card_rates
= lbs_bg_rates
;
43 size_t num_card_rates
= sizeof(lbs_bg_rates
);
48 /* For each rate in card_rates that exists in rate1, copy to tmp */
49 for (i
= 0; card_rates
[i
] && (i
< num_card_rates
); i
++) {
50 for (j
= 0; rates
[j
] && (j
< *rates_size
); j
++) {
51 if (rates
[j
] == card_rates
[i
])
52 tmp
[tmp_size
++] = card_rates
[i
];
56 lbs_deb_hex(LBS_DEB_JOIN
, "AP rates ", rates
, *rates_size
);
57 lbs_deb_hex(LBS_DEB_JOIN
, "card rates ", card_rates
, num_card_rates
);
58 lbs_deb_hex(LBS_DEB_JOIN
, "common rates", tmp
, tmp_size
);
59 lbs_deb_join("TX data rate 0x%02x\n", priv
->cur_rate
);
61 if (!priv
->enablehwauto
) {
62 for (i
= 0; i
< tmp_size
; i
++) {
63 if (tmp
[i
] == priv
->cur_rate
)
66 lbs_pr_alert("Previously set fixed data rate %#x isn't "
67 "compatible with the network.\n", priv
->cur_rate
);
74 memset(rates
, 0, *rates_size
);
75 *rates_size
= min_t(int, tmp_size
, *rates_size
);
76 memcpy(rates
, tmp
, *rates_size
);
82 * @brief Sets the MSB on basic rates as the firmware requires
84 * Scan through an array and set the MSB for basic data rates.
86 * @param rates buffer of data rates
87 * @param len size of buffer
89 static void lbs_set_basic_rate_flags(u8
*rates
, size_t len
)
93 for (i
= 0; i
< len
; i
++) {
94 if (rates
[i
] == 0x02 || rates
[i
] == 0x04 ||
95 rates
[i
] == 0x0b || rates
[i
] == 0x16)
102 * @brief Associate to a specific BSS discovered in a scan
104 * @param priv A pointer to struct lbs_private structure
105 * @param assoc_req The association request describing the BSS to associate with
107 * @return 0-success, otherwise fail
109 static int lbs_associate(struct lbs_private
*priv
,
110 struct assoc_request
*assoc_req
)
113 u8 preamble
= RADIO_PREAMBLE_LONG
;
115 lbs_deb_enter(LBS_DEB_ASSOC
);
117 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_AUTHENTICATE
,
118 0, CMD_OPTION_WAITFORRSP
,
119 0, assoc_req
->bss
.bssid
);
123 /* Use short preamble only when both the BSS and firmware support it */
124 if ((priv
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
) &&
125 (assoc_req
->bss
.capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
))
126 preamble
= RADIO_PREAMBLE_SHORT
;
128 ret
= lbs_set_radio(priv
, preamble
, 1);
132 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_ASSOCIATE
,
133 0, CMD_OPTION_WAITFORRSP
, 0, assoc_req
);
136 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
141 * @brief Join an adhoc network found in a previous scan
143 * @param priv A pointer to struct lbs_private structure
144 * @param assoc_req The association request describing the BSS to join
146 * @return 0 on success, error on failure
148 static int lbs_adhoc_join(struct lbs_private
*priv
,
149 struct assoc_request
*assoc_req
)
151 struct cmd_ds_802_11_ad_hoc_join cmd
;
152 struct bss_descriptor
*bss
= &assoc_req
->bss
;
153 u8 preamble
= RADIO_PREAMBLE_LONG
;
154 DECLARE_MAC_BUF(mac
);
158 lbs_deb_enter(LBS_DEB_ASSOC
);
160 lbs_deb_join("current SSID '%s', ssid length %u\n",
161 escape_essid(priv
->curbssparams
.ssid
,
162 priv
->curbssparams
.ssid_len
),
163 priv
->curbssparams
.ssid_len
);
164 lbs_deb_join("requested ssid '%s', ssid length %u\n",
165 escape_essid(bss
->ssid
, bss
->ssid_len
),
168 /* check if the requested SSID is already joined */
169 if (priv
->curbssparams
.ssid_len
&&
170 !lbs_ssid_cmp(priv
->curbssparams
.ssid
,
171 priv
->curbssparams
.ssid_len
,
172 bss
->ssid
, bss
->ssid_len
) &&
173 (priv
->mode
== IW_MODE_ADHOC
) &&
174 (priv
->connect_status
== LBS_CONNECTED
)) {
175 union iwreq_data wrqu
;
177 lbs_deb_join("ADHOC_J_CMD: New ad-hoc SSID is the same as "
178 "current, not attempting to re-join");
180 /* Send the re-association event though, because the association
181 * request really was successful, even if just a null-op.
183 memset(&wrqu
, 0, sizeof(wrqu
));
184 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
,
186 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
187 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
191 /* Use short preamble only when both the BSS and firmware support it */
192 if ((priv
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
) &&
193 (bss
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
)) {
194 lbs_deb_join("AdhocJoin: Short preamble\n");
195 preamble
= RADIO_PREAMBLE_SHORT
;
198 ret
= lbs_set_radio(priv
, preamble
, 1);
202 lbs_deb_join("AdhocJoin: channel = %d\n", assoc_req
->channel
);
203 lbs_deb_join("AdhocJoin: band = %c\n", assoc_req
->band
);
205 priv
->adhoccreate
= 0;
206 priv
->curbssparams
.channel
= bss
->channel
;
208 /* Build the join command */
209 memset(&cmd
, 0, sizeof(cmd
));
210 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
212 cmd
.bss
.type
= CMD_BSS_TYPE_IBSS
;
213 cmd
.bss
.beaconperiod
= cpu_to_le16(bss
->beaconperiod
);
215 memcpy(&cmd
.bss
.bssid
, &bss
->bssid
, ETH_ALEN
);
216 memcpy(&cmd
.bss
.ssid
, &bss
->ssid
, bss
->ssid_len
);
218 memcpy(&cmd
.bss
.phyparamset
, &bss
->phyparamset
,
219 sizeof(union ieeetypes_phyparamset
));
221 memcpy(&cmd
.bss
.ssparamset
, &bss
->ssparamset
,
222 sizeof(union IEEEtypes_ssparamset
));
224 cmd
.bss
.capability
= cpu_to_le16(bss
->capability
& CAPINFO_MASK
);
225 lbs_deb_join("ADHOC_J_CMD: tmpcap=%4X CAPINFO_MASK=%4X\n",
226 bss
->capability
, CAPINFO_MASK
);
228 /* information on BSSID descriptor passed to FW */
229 lbs_deb_join("ADHOC_J_CMD: BSSID = %s, SSID = '%s'\n",
230 print_mac(mac
, cmd
.bss
.bssid
), cmd
.bss
.ssid
);
232 /* Only v8 and below support setting these */
233 if (priv
->fwrelease
< 0x09000000) {
235 cmd
.failtimeout
= cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT
);
237 cmd
.probedelay
= cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME
);
240 /* Copy Data rates from the rates recorded in scan response */
241 memset(cmd
.bss
.rates
, 0, sizeof(cmd
.bss
.rates
));
242 ratesize
= min_t(u16
, sizeof(cmd
.bss
.rates
), MAX_RATES
);
243 memcpy(cmd
.bss
.rates
, bss
->rates
, ratesize
);
244 if (get_common_rates(priv
, cmd
.bss
.rates
, &ratesize
)) {
245 lbs_deb_join("ADHOC_JOIN: get_common_rates returned error.\n");
250 /* Copy the ad-hoc creation rates into Current BSS state structure */
251 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
252 memcpy(&priv
->curbssparams
.rates
, cmd
.bss
.rates
, ratesize
);
254 /* Set MSB on basic rates as the firmware requires, but _after_
255 * copying to current bss rates.
257 lbs_set_basic_rate_flags(cmd
.bss
.rates
, ratesize
);
259 cmd
.bss
.ssparamset
.ibssparamset
.atimwindow
= cpu_to_le16(bss
->atimwindow
);
261 if (assoc_req
->secinfo
.wep_enabled
) {
262 u16 tmp
= le16_to_cpu(cmd
.bss
.capability
);
263 tmp
|= WLAN_CAPABILITY_PRIVACY
;
264 cmd
.bss
.capability
= cpu_to_le16(tmp
);
267 if (priv
->psmode
== LBS802_11POWERMODEMAX_PSP
) {
268 __le32 local_ps_mode
= cpu_to_le32(LBS802_11POWERMODECAM
);
271 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_PS_MODE
,
280 if (lbs_parse_dnld_countryinfo_11d(priv
, bss
)) {
285 ret
= lbs_cmd_with_response(priv
, CMD_802_11_AD_HOC_JOIN
, &cmd
);
287 ret
= lbs_adhoc_post(priv
, (struct cmd_header
*) &cmd
);
290 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
295 * @brief Start an Adhoc Network
297 * @param priv A pointer to struct lbs_private structure
298 * @param assoc_req The association request describing the BSS to start
300 * @return 0 on success, error on failure
302 static int lbs_adhoc_start(struct lbs_private
*priv
,
303 struct assoc_request
*assoc_req
)
305 struct cmd_ds_802_11_ad_hoc_start cmd
;
306 u8 preamble
= RADIO_PREAMBLE_LONG
;
311 lbs_deb_enter(LBS_DEB_ASSOC
);
313 if (priv
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
) {
314 lbs_deb_join("ADHOC_START: Will use short preamble\n");
315 preamble
= RADIO_PREAMBLE_SHORT
;
318 ret
= lbs_set_radio(priv
, preamble
, 1);
322 /* Build the start command */
323 memset(&cmd
, 0, sizeof(cmd
));
324 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
326 memcpy(cmd
.ssid
, assoc_req
->ssid
, assoc_req
->ssid_len
);
328 lbs_deb_join("ADHOC_START: SSID '%s', ssid length %u\n",
329 escape_essid(assoc_req
->ssid
, assoc_req
->ssid_len
),
330 assoc_req
->ssid_len
);
332 cmd
.bsstype
= CMD_BSS_TYPE_IBSS
;
334 if (priv
->beacon_period
== 0)
335 priv
->beacon_period
= MRVDRV_BEACON_INTERVAL
;
336 cmd
.beaconperiod
= cpu_to_le16(priv
->beacon_period
);
338 WARN_ON(!assoc_req
->channel
);
340 /* set Physical parameter set */
341 cmd
.phyparamset
.dsparamset
.elementid
= MFIE_TYPE_DS_SET
;
342 cmd
.phyparamset
.dsparamset
.len
= 1;
343 cmd
.phyparamset
.dsparamset
.currentchan
= assoc_req
->channel
;
345 /* set IBSS parameter set */
346 cmd
.ssparamset
.ibssparamset
.elementid
= MFIE_TYPE_IBSS_SET
;
347 cmd
.ssparamset
.ibssparamset
.len
= 2;
348 cmd
.ssparamset
.ibssparamset
.atimwindow
= 0;
350 /* set capability info */
351 tmpcap
= WLAN_CAPABILITY_IBSS
;
352 if (assoc_req
->secinfo
.wep_enabled
) {
353 lbs_deb_join("ADHOC_START: WEP enabled, setting privacy on\n");
354 tmpcap
|= WLAN_CAPABILITY_PRIVACY
;
356 lbs_deb_join("ADHOC_START: WEP disabled, setting privacy off\n");
358 cmd
.capability
= cpu_to_le16(tmpcap
);
360 /* Only v8 and below support setting probe delay */
361 if (priv
->fwrelease
< 0x09000000)
362 cmd
.probedelay
= cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME
);
364 ratesize
= min(sizeof(cmd
.rates
), sizeof(lbs_bg_rates
));
365 memcpy(cmd
.rates
, lbs_bg_rates
, ratesize
);
367 /* Copy the ad-hoc creating rates into Current BSS state structure */
368 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
369 memcpy(&priv
->curbssparams
.rates
, &cmd
.rates
, ratesize
);
371 /* Set MSB on basic rates as the firmware requires, but _after_
372 * copying to current bss rates.
374 lbs_set_basic_rate_flags(cmd
.rates
, ratesize
);
376 lbs_deb_join("ADHOC_START: rates=%02x %02x %02x %02x\n",
377 cmd
.rates
[0], cmd
.rates
[1], cmd
.rates
[2], cmd
.rates
[3]);
379 if (lbs_create_dnld_countryinfo_11d(priv
)) {
380 lbs_deb_join("ADHOC_START: dnld_countryinfo_11d failed\n");
385 lbs_deb_join("ADHOC_START: Starting Ad-Hoc BSS on channel %d, band %d\n",
386 assoc_req
->channel
, assoc_req
->band
);
388 priv
->adhoccreate
= 1;
389 priv
->mode
= IW_MODE_ADHOC
;
391 ret
= lbs_cmd_with_response(priv
, CMD_802_11_AD_HOC_START
, &cmd
);
393 ret
= lbs_adhoc_post(priv
, (struct cmd_header
*) &cmd
);
396 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
401 * @brief Stop and Ad-Hoc network and exit Ad-Hoc mode
403 * @param priv A pointer to struct lbs_private structure
404 * @return 0 on success, or an error
406 int lbs_adhoc_stop(struct lbs_private
*priv
)
408 struct cmd_ds_802_11_ad_hoc_stop cmd
;
411 lbs_deb_enter(LBS_DEB_JOIN
);
413 memset(&cmd
, 0, sizeof (cmd
));
414 cmd
.hdr
.size
= cpu_to_le16 (sizeof (cmd
));
416 ret
= lbs_cmd_with_response(priv
, CMD_802_11_AD_HOC_STOP
, &cmd
);
418 /* Clean up everything even if there was an error */
419 lbs_mac_event_disconnected(priv
);
421 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
425 static inline int match_bss_no_security(struct lbs_802_11_security
*secinfo
,
426 struct bss_descriptor
*match_bss
)
428 if (!secinfo
->wep_enabled
&& !secinfo
->WPAenabled
429 && !secinfo
->WPA2enabled
430 && match_bss
->wpa_ie
[0] != MFIE_TYPE_GENERIC
431 && match_bss
->rsn_ie
[0] != MFIE_TYPE_RSN
432 && !(match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
438 static inline int match_bss_static_wep(struct lbs_802_11_security
*secinfo
,
439 struct bss_descriptor
*match_bss
)
441 if (secinfo
->wep_enabled
&& !secinfo
->WPAenabled
442 && !secinfo
->WPA2enabled
443 && (match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
449 static inline int match_bss_wpa(struct lbs_802_11_security
*secinfo
,
450 struct bss_descriptor
*match_bss
)
452 if (!secinfo
->wep_enabled
&& secinfo
->WPAenabled
453 && (match_bss
->wpa_ie
[0] == MFIE_TYPE_GENERIC
)
454 /* privacy bit may NOT be set in some APs like LinkSys WRT54G
455 && (match_bss->capability & WLAN_CAPABILITY_PRIVACY) */
462 static inline int match_bss_wpa2(struct lbs_802_11_security
*secinfo
,
463 struct bss_descriptor
*match_bss
)
465 if (!secinfo
->wep_enabled
&& secinfo
->WPA2enabled
&&
466 (match_bss
->rsn_ie
[0] == MFIE_TYPE_RSN
)
467 /* privacy bit may NOT be set in some APs like LinkSys WRT54G
468 (match_bss->capability & WLAN_CAPABILITY_PRIVACY) */
475 static inline int match_bss_dynamic_wep(struct lbs_802_11_security
*secinfo
,
476 struct bss_descriptor
*match_bss
)
478 if (!secinfo
->wep_enabled
&& !secinfo
->WPAenabled
479 && !secinfo
->WPA2enabled
480 && (match_bss
->wpa_ie
[0] != MFIE_TYPE_GENERIC
)
481 && (match_bss
->rsn_ie
[0] != MFIE_TYPE_RSN
)
482 && (match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
489 * @brief Check if a scanned network compatible with the driver settings
491 * WEP WPA WPA2 ad-hoc encrypt Network
492 * enabled enabled enabled AES mode privacy WPA WPA2 Compatible
493 * 0 0 0 0 NONE 0 0 0 yes No security
494 * 1 0 0 0 NONE 1 0 0 yes Static WEP
495 * 0 1 0 0 x 1x 1 x yes WPA
496 * 0 0 1 0 x 1x x 1 yes WPA2
497 * 0 0 0 1 NONE 1 0 0 yes Ad-hoc AES
498 * 0 0 0 0 !=NONE 1 0 0 yes Dynamic WEP
501 * @param priv A pointer to struct lbs_private
502 * @param index Index in scantable to check against current driver settings
503 * @param mode Network mode: Infrastructure or IBSS
505 * @return Index in scantable, or error code if negative
507 static int is_network_compatible(struct lbs_private
*priv
,
508 struct bss_descriptor
*bss
, uint8_t mode
)
512 lbs_deb_enter(LBS_DEB_SCAN
);
514 if (bss
->mode
!= mode
)
517 matched
= match_bss_no_security(&priv
->secinfo
, bss
);
520 matched
= match_bss_static_wep(&priv
->secinfo
, bss
);
523 matched
= match_bss_wpa(&priv
->secinfo
, bss
);
525 lbs_deb_scan("is_network_compatible() WPA: wpa_ie 0x%x "
526 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
527 "privacy 0x%x\n", bss
->wpa_ie
[0], bss
->rsn_ie
[0],
528 priv
->secinfo
.wep_enabled
? "e" : "d",
529 priv
->secinfo
.WPAenabled
? "e" : "d",
530 priv
->secinfo
.WPA2enabled
? "e" : "d",
531 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
534 matched
= match_bss_wpa2(&priv
->secinfo
, bss
);
536 lbs_deb_scan("is_network_compatible() WPA2: wpa_ie 0x%x "
537 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
538 "privacy 0x%x\n", bss
->wpa_ie
[0], bss
->rsn_ie
[0],
539 priv
->secinfo
.wep_enabled
? "e" : "d",
540 priv
->secinfo
.WPAenabled
? "e" : "d",
541 priv
->secinfo
.WPA2enabled
? "e" : "d",
542 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
545 matched
= match_bss_dynamic_wep(&priv
->secinfo
, bss
);
547 lbs_deb_scan("is_network_compatible() dynamic WEP: "
548 "wpa_ie 0x%x wpa2_ie 0x%x privacy 0x%x\n",
549 bss
->wpa_ie
[0], bss
->rsn_ie
[0],
550 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
554 /* bss security settings don't match those configured on card */
555 lbs_deb_scan("is_network_compatible() FAILED: wpa_ie 0x%x "
556 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s privacy 0x%x\n",
557 bss
->wpa_ie
[0], bss
->rsn_ie
[0],
558 priv
->secinfo
.wep_enabled
? "e" : "d",
559 priv
->secinfo
.WPAenabled
? "e" : "d",
560 priv
->secinfo
.WPA2enabled
? "e" : "d",
561 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
564 lbs_deb_leave_args(LBS_DEB_SCAN
, "matched: %d", matched
);
569 * @brief This function finds a specific compatible BSSID in the scan list
571 * Used in association code
573 * @param priv A pointer to struct lbs_private
574 * @param bssid BSSID to find in the scan list
575 * @param mode Network mode: Infrastructure or IBSS
577 * @return index in BSSID list, or error return code (< 0)
579 static struct bss_descriptor
*lbs_find_bssid_in_list(struct lbs_private
*priv
,
580 uint8_t *bssid
, uint8_t mode
)
582 struct bss_descriptor
*iter_bss
;
583 struct bss_descriptor
*found_bss
= NULL
;
585 lbs_deb_enter(LBS_DEB_SCAN
);
590 lbs_deb_hex(LBS_DEB_SCAN
, "looking for", bssid
, ETH_ALEN
);
592 /* Look through the scan table for a compatible match. The loop will
593 * continue past a matched bssid that is not compatible in case there
594 * is an AP with multiple SSIDs assigned to the same BSSID
596 mutex_lock(&priv
->lock
);
597 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
598 if (compare_ether_addr(iter_bss
->bssid
, bssid
))
599 continue; /* bssid doesn't match */
603 if (!is_network_compatible(priv
, iter_bss
, mode
))
605 found_bss
= iter_bss
;
608 found_bss
= iter_bss
;
612 mutex_unlock(&priv
->lock
);
615 lbs_deb_leave_args(LBS_DEB_SCAN
, "found_bss %p", found_bss
);
620 * @brief This function finds ssid in ssid list.
622 * Used in association code
624 * @param priv A pointer to struct lbs_private
625 * @param ssid SSID to find in the list
626 * @param bssid BSSID to qualify the SSID selection (if provided)
627 * @param mode Network mode: Infrastructure or IBSS
629 * @return index in BSSID list
631 static struct bss_descriptor
*lbs_find_ssid_in_list(struct lbs_private
*priv
,
632 uint8_t *ssid
, uint8_t ssid_len
,
633 uint8_t *bssid
, uint8_t mode
,
637 struct bss_descriptor
*iter_bss
= NULL
;
638 struct bss_descriptor
*found_bss
= NULL
;
639 struct bss_descriptor
*tmp_oldest
= NULL
;
641 lbs_deb_enter(LBS_DEB_SCAN
);
643 mutex_lock(&priv
->lock
);
645 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
647 (iter_bss
->last_scanned
< tmp_oldest
->last_scanned
))
648 tmp_oldest
= iter_bss
;
650 if (lbs_ssid_cmp(iter_bss
->ssid
, iter_bss
->ssid_len
,
651 ssid
, ssid_len
) != 0)
652 continue; /* ssid doesn't match */
653 if (bssid
&& compare_ether_addr(iter_bss
->bssid
, bssid
) != 0)
654 continue; /* bssid doesn't match */
655 if ((channel
> 0) && (iter_bss
->channel
!= channel
))
656 continue; /* channel doesn't match */
661 if (!is_network_compatible(priv
, iter_bss
, mode
))
665 /* Found requested BSSID */
666 found_bss
= iter_bss
;
670 if (SCAN_RSSI(iter_bss
->rssi
) > bestrssi
) {
671 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
672 found_bss
= iter_bss
;
677 if (SCAN_RSSI(iter_bss
->rssi
) > bestrssi
) {
678 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
679 found_bss
= iter_bss
;
686 mutex_unlock(&priv
->lock
);
687 lbs_deb_leave_args(LBS_DEB_SCAN
, "found_bss %p", found_bss
);
691 static int assoc_helper_essid(struct lbs_private
*priv
,
692 struct assoc_request
* assoc_req
)
695 struct bss_descriptor
* bss
;
698 lbs_deb_enter(LBS_DEB_ASSOC
);
700 /* FIXME: take channel into account when picking SSIDs if a channel
704 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
))
705 channel
= assoc_req
->channel
;
707 lbs_deb_assoc("SSID '%s' requested\n",
708 escape_essid(assoc_req
->ssid
, assoc_req
->ssid_len
));
709 if (assoc_req
->mode
== IW_MODE_INFRA
) {
710 lbs_send_specific_ssid_scan(priv
, assoc_req
->ssid
,
711 assoc_req
->ssid_len
);
713 bss
= lbs_find_ssid_in_list(priv
, assoc_req
->ssid
,
714 assoc_req
->ssid_len
, NULL
, IW_MODE_INFRA
, channel
);
716 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
717 ret
= lbs_associate(priv
, assoc_req
);
719 lbs_deb_assoc("SSID not found; cannot associate\n");
721 } else if (assoc_req
->mode
== IW_MODE_ADHOC
) {
722 /* Scan for the network, do not save previous results. Stale
723 * scan data will cause us to join a non-existant adhoc network
725 lbs_send_specific_ssid_scan(priv
, assoc_req
->ssid
,
726 assoc_req
->ssid_len
);
728 /* Search for the requested SSID in the scan table */
729 bss
= lbs_find_ssid_in_list(priv
, assoc_req
->ssid
,
730 assoc_req
->ssid_len
, NULL
, IW_MODE_ADHOC
, channel
);
732 lbs_deb_assoc("SSID found, will join\n");
733 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
734 lbs_adhoc_join(priv
, assoc_req
);
736 /* else send START command */
737 lbs_deb_assoc("SSID not found, creating adhoc network\n");
738 memcpy(&assoc_req
->bss
.ssid
, &assoc_req
->ssid
,
740 assoc_req
->bss
.ssid_len
= assoc_req
->ssid_len
;
741 lbs_adhoc_start(priv
, assoc_req
);
745 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
750 static int assoc_helper_bssid(struct lbs_private
*priv
,
751 struct assoc_request
* assoc_req
)
754 struct bss_descriptor
* bss
;
755 DECLARE_MAC_BUF(mac
);
757 lbs_deb_enter_args(LBS_DEB_ASSOC
, "BSSID %s",
758 print_mac(mac
, assoc_req
->bssid
));
760 /* Search for index position in list for requested MAC */
761 bss
= lbs_find_bssid_in_list(priv
, assoc_req
->bssid
,
764 lbs_deb_assoc("ASSOC: WAP: BSSID %s not found, "
765 "cannot associate.\n", print_mac(mac
, assoc_req
->bssid
));
769 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
770 if (assoc_req
->mode
== IW_MODE_INFRA
) {
771 ret
= lbs_associate(priv
, assoc_req
);
772 lbs_deb_assoc("ASSOC: lbs_associate(bssid) returned %d\n", ret
);
773 } else if (assoc_req
->mode
== IW_MODE_ADHOC
) {
774 lbs_adhoc_join(priv
, assoc_req
);
778 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
783 static int assoc_helper_associate(struct lbs_private
*priv
,
784 struct assoc_request
* assoc_req
)
786 int ret
= 0, done
= 0;
788 lbs_deb_enter(LBS_DEB_ASSOC
);
790 /* If we're given and 'any' BSSID, try associating based on SSID */
792 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
793 if (compare_ether_addr(bssid_any
, assoc_req
->bssid
)
794 && compare_ether_addr(bssid_off
, assoc_req
->bssid
)) {
795 ret
= assoc_helper_bssid(priv
, assoc_req
);
800 if (!done
&& test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
801 ret
= assoc_helper_essid(priv
, assoc_req
);
804 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
809 static int assoc_helper_mode(struct lbs_private
*priv
,
810 struct assoc_request
* assoc_req
)
814 lbs_deb_enter(LBS_DEB_ASSOC
);
816 if (assoc_req
->mode
== priv
->mode
)
819 if (assoc_req
->mode
== IW_MODE_INFRA
) {
820 if (priv
->psstate
!= PS_STATE_FULL_POWER
)
821 lbs_ps_wakeup(priv
, CMD_OPTION_WAITFORRSP
);
822 priv
->psmode
= LBS802_11POWERMODECAM
;
825 priv
->mode
= assoc_req
->mode
;
826 ret
= lbs_set_snmp_mib(priv
, SNMP_MIB_OID_BSS_TYPE
, assoc_req
->mode
);
829 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
833 static int assoc_helper_channel(struct lbs_private
*priv
,
834 struct assoc_request
* assoc_req
)
838 lbs_deb_enter(LBS_DEB_ASSOC
);
840 ret
= lbs_update_channel(priv
);
842 lbs_deb_assoc("ASSOC: channel: error getting channel.\n");
846 if (assoc_req
->channel
== priv
->curbssparams
.channel
)
849 if (priv
->mesh_dev
) {
850 /* Change mesh channel first; 21.p21 firmware won't let
851 you change channel otherwise (even though it'll return
853 lbs_mesh_config(priv
, CMD_ACT_MESH_CONFIG_STOP
,
857 lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
858 priv
->curbssparams
.channel
, assoc_req
->channel
);
860 ret
= lbs_set_channel(priv
, assoc_req
->channel
);
862 lbs_deb_assoc("ASSOC: channel: error setting channel.\n");
864 /* FIXME: shouldn't need to grab the channel _again_ after setting
865 * it since the firmware is supposed to return the new channel, but
867 ret
= lbs_update_channel(priv
);
869 lbs_deb_assoc("ASSOC: channel: error getting channel.\n");
873 if (assoc_req
->channel
!= priv
->curbssparams
.channel
) {
874 lbs_deb_assoc("ASSOC: channel: failed to update channel to %d\n",
879 if ( assoc_req
->secinfo
.wep_enabled
880 && (assoc_req
->wep_keys
[0].len
881 || assoc_req
->wep_keys
[1].len
882 || assoc_req
->wep_keys
[2].len
883 || assoc_req
->wep_keys
[3].len
)) {
884 /* Make sure WEP keys are re-sent to firmware */
885 set_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
);
888 /* Must restart/rejoin adhoc networks after channel change */
889 set_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
);
893 lbs_mesh_config(priv
, CMD_ACT_MESH_CONFIG_START
,
894 priv
->curbssparams
.channel
);
897 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
902 static int assoc_helper_wep_keys(struct lbs_private
*priv
,
903 struct assoc_request
*assoc_req
)
908 lbs_deb_enter(LBS_DEB_ASSOC
);
910 /* Set or remove WEP keys */
911 if (assoc_req
->wep_keys
[0].len
|| assoc_req
->wep_keys
[1].len
||
912 assoc_req
->wep_keys
[2].len
|| assoc_req
->wep_keys
[3].len
)
913 ret
= lbs_cmd_802_11_set_wep(priv
, CMD_ACT_ADD
, assoc_req
);
915 ret
= lbs_cmd_802_11_set_wep(priv
, CMD_ACT_REMOVE
, assoc_req
);
920 /* enable/disable the MAC's WEP packet filter */
921 if (assoc_req
->secinfo
.wep_enabled
)
922 priv
->mac_control
|= CMD_ACT_MAC_WEP_ENABLE
;
924 priv
->mac_control
&= ~CMD_ACT_MAC_WEP_ENABLE
;
926 lbs_set_mac_control(priv
);
928 mutex_lock(&priv
->lock
);
930 /* Copy WEP keys into priv wep key fields */
931 for (i
= 0; i
< 4; i
++) {
932 memcpy(&priv
->wep_keys
[i
], &assoc_req
->wep_keys
[i
],
933 sizeof(struct enc_key
));
935 priv
->wep_tx_keyidx
= assoc_req
->wep_tx_keyidx
;
937 mutex_unlock(&priv
->lock
);
940 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
944 static int assoc_helper_secinfo(struct lbs_private
*priv
,
945 struct assoc_request
* assoc_req
)
951 lbs_deb_enter(LBS_DEB_ASSOC
);
953 memcpy(&priv
->secinfo
, &assoc_req
->secinfo
,
954 sizeof(struct lbs_802_11_security
));
956 lbs_set_mac_control(priv
);
958 /* If RSN is already enabled, don't try to enable it again, since
959 * ENABLE_RSN resets internal state machines and will clobber the
960 * 4-way WPA handshake.
963 /* Get RSN enabled/disabled */
964 ret
= lbs_cmd_802_11_enable_rsn(priv
, CMD_ACT_GET
, &rsn
);
966 lbs_deb_assoc("Failed to get RSN status: %d\n", ret
);
970 /* Don't re-enable RSN if it's already enabled */
971 do_wpa
= assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
;
975 /* Set RSN enabled/disabled */
976 ret
= lbs_cmd_802_11_enable_rsn(priv
, CMD_ACT_SET
, &do_wpa
);
979 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
984 static int assoc_helper_wpa_keys(struct lbs_private
*priv
,
985 struct assoc_request
* assoc_req
)
988 unsigned int flags
= assoc_req
->flags
;
990 lbs_deb_enter(LBS_DEB_ASSOC
);
992 /* Work around older firmware bug where WPA unicast and multicast
993 * keys must be set independently. Seen in SDIO parts with firmware
997 if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
998 clear_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
);
999 ret
= lbs_cmd_802_11_key_material(priv
, CMD_ACT_SET
, assoc_req
);
1000 assoc_req
->flags
= flags
;
1006 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)) {
1007 clear_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
);
1009 ret
= lbs_cmd_802_11_key_material(priv
, CMD_ACT_SET
, assoc_req
);
1010 assoc_req
->flags
= flags
;
1014 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1019 static int assoc_helper_wpa_ie(struct lbs_private
*priv
,
1020 struct assoc_request
* assoc_req
)
1024 lbs_deb_enter(LBS_DEB_ASSOC
);
1026 if (assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
) {
1027 memcpy(&priv
->wpa_ie
, &assoc_req
->wpa_ie
, assoc_req
->wpa_ie_len
);
1028 priv
->wpa_ie_len
= assoc_req
->wpa_ie_len
;
1030 memset(&priv
->wpa_ie
, 0, MAX_WPA_IE_LEN
);
1031 priv
->wpa_ie_len
= 0;
1034 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1039 static int should_deauth_infrastructure(struct lbs_private
*priv
,
1040 struct assoc_request
* assoc_req
)
1044 if (priv
->connect_status
!= LBS_CONNECTED
)
1047 lbs_deb_enter(LBS_DEB_ASSOC
);
1048 if (test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
1049 lbs_deb_assoc("Deauthenticating due to new SSID\n");
1054 if (test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
1055 if (priv
->secinfo
.auth_mode
!= assoc_req
->secinfo
.auth_mode
) {
1056 lbs_deb_assoc("Deauthenticating due to new security\n");
1062 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
1063 lbs_deb_assoc("Deauthenticating due to new BSSID\n");
1068 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
1069 lbs_deb_assoc("Deauthenticating due to channel switch\n");
1074 /* FIXME: deal with 'auto' mode somehow */
1075 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
1076 if (assoc_req
->mode
!= IW_MODE_INFRA
) {
1077 lbs_deb_assoc("Deauthenticating due to leaving "
1085 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1090 static int should_stop_adhoc(struct lbs_private
*priv
,
1091 struct assoc_request
* assoc_req
)
1093 lbs_deb_enter(LBS_DEB_ASSOC
);
1095 if (priv
->connect_status
!= LBS_CONNECTED
)
1098 if (lbs_ssid_cmp(priv
->curbssparams
.ssid
,
1099 priv
->curbssparams
.ssid_len
,
1100 assoc_req
->ssid
, assoc_req
->ssid_len
) != 0)
1103 /* FIXME: deal with 'auto' mode somehow */
1104 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
1105 if (assoc_req
->mode
!= IW_MODE_ADHOC
)
1109 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
1110 if (assoc_req
->channel
!= priv
->curbssparams
.channel
)
1114 lbs_deb_leave(LBS_DEB_ASSOC
);
1120 * @brief This function finds the best SSID in the Scan List
1122 * Search the scan table for the best SSID that also matches the current
1123 * adapter network preference (infrastructure or adhoc)
1125 * @param priv A pointer to struct lbs_private
1127 * @return index in BSSID list
1129 static struct bss_descriptor
*lbs_find_best_ssid_in_list(
1130 struct lbs_private
*priv
, uint8_t mode
)
1132 uint8_t bestrssi
= 0;
1133 struct bss_descriptor
*iter_bss
;
1134 struct bss_descriptor
*best_bss
= NULL
;
1136 lbs_deb_enter(LBS_DEB_SCAN
);
1138 mutex_lock(&priv
->lock
);
1140 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
1144 if (!is_network_compatible(priv
, iter_bss
, mode
))
1146 if (SCAN_RSSI(iter_bss
->rssi
) <= bestrssi
)
1148 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
1149 best_bss
= iter_bss
;
1153 if (SCAN_RSSI(iter_bss
->rssi
) <= bestrssi
)
1155 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
1156 best_bss
= iter_bss
;
1161 mutex_unlock(&priv
->lock
);
1162 lbs_deb_leave_args(LBS_DEB_SCAN
, "best_bss %p", best_bss
);
1167 * @brief Find the best AP
1169 * Used from association worker.
1171 * @param priv A pointer to struct lbs_private structure
1172 * @param pSSID A pointer to AP's ssid
1174 * @return 0--success, otherwise--fail
1176 static int lbs_find_best_network_ssid(struct lbs_private
*priv
,
1177 uint8_t *out_ssid
, uint8_t *out_ssid_len
, uint8_t preferred_mode
,
1181 struct bss_descriptor
*found
;
1183 lbs_deb_enter(LBS_DEB_SCAN
);
1185 priv
->scan_ssid_len
= 0;
1186 lbs_scan_networks(priv
, 1);
1187 if (priv
->surpriseremoved
)
1190 found
= lbs_find_best_ssid_in_list(priv
, preferred_mode
);
1191 if (found
&& (found
->ssid_len
> 0)) {
1192 memcpy(out_ssid
, &found
->ssid
, IW_ESSID_MAX_SIZE
);
1193 *out_ssid_len
= found
->ssid_len
;
1194 *out_mode
= found
->mode
;
1199 lbs_deb_leave_args(LBS_DEB_SCAN
, "ret %d", ret
);
1204 void lbs_association_worker(struct work_struct
*work
)
1206 struct lbs_private
*priv
= container_of(work
, struct lbs_private
,
1208 struct assoc_request
* assoc_req
= NULL
;
1210 int find_any_ssid
= 0;
1211 DECLARE_MAC_BUF(mac
);
1213 lbs_deb_enter(LBS_DEB_ASSOC
);
1215 mutex_lock(&priv
->lock
);
1216 assoc_req
= priv
->pending_assoc_req
;
1217 priv
->pending_assoc_req
= NULL
;
1218 priv
->in_progress_assoc_req
= assoc_req
;
1219 mutex_unlock(&priv
->lock
);
1225 "Association Request:\n"
1232 " secinfo: %s%s%s\n"
1235 escape_essid(assoc_req
->ssid
, assoc_req
->ssid_len
),
1236 assoc_req
->channel
, assoc_req
->band
, assoc_req
->mode
,
1237 print_mac(mac
, assoc_req
->bssid
),
1238 assoc_req
->secinfo
.WPAenabled
? " WPA" : "",
1239 assoc_req
->secinfo
.WPA2enabled
? " WPA2" : "",
1240 assoc_req
->secinfo
.wep_enabled
? " WEP" : "",
1241 assoc_req
->secinfo
.auth_mode
);
1243 /* If 'any' SSID was specified, find an SSID to associate with */
1244 if (test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)
1245 && !assoc_req
->ssid_len
)
1248 /* But don't use 'any' SSID if there's a valid locked BSSID to use */
1249 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
1250 if (compare_ether_addr(assoc_req
->bssid
, bssid_any
)
1251 && compare_ether_addr(assoc_req
->bssid
, bssid_off
))
1255 if (find_any_ssid
) {
1256 u8 new_mode
= assoc_req
->mode
;
1258 ret
= lbs_find_best_network_ssid(priv
, assoc_req
->ssid
,
1259 &assoc_req
->ssid_len
, assoc_req
->mode
, &new_mode
);
1261 lbs_deb_assoc("Could not find best network\n");
1266 /* Ensure we switch to the mode of the AP */
1267 if (assoc_req
->mode
== IW_MODE_AUTO
) {
1268 set_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
);
1269 assoc_req
->mode
= new_mode
;
1274 * Check if the attributes being changing require deauthentication
1275 * from the currently associated infrastructure access point.
1277 if (priv
->mode
== IW_MODE_INFRA
) {
1278 if (should_deauth_infrastructure(priv
, assoc_req
)) {
1279 ret
= lbs_cmd_80211_deauthenticate(priv
,
1280 priv
->curbssparams
.bssid
,
1281 WLAN_REASON_DEAUTH_LEAVING
);
1283 lbs_deb_assoc("Deauthentication due to new "
1284 "configuration request failed: %d\n",
1288 } else if (priv
->mode
== IW_MODE_ADHOC
) {
1289 if (should_stop_adhoc(priv
, assoc_req
)) {
1290 ret
= lbs_adhoc_stop(priv
);
1292 lbs_deb_assoc("Teardown of AdHoc network due to "
1293 "new configuration request failed: %d\n",
1300 /* Send the various configuration bits to the firmware */
1301 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
1302 ret
= assoc_helper_mode(priv
, assoc_req
);
1307 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
1308 ret
= assoc_helper_channel(priv
, assoc_req
);
1313 if ( test_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
)
1314 || test_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
)) {
1315 ret
= assoc_helper_wep_keys(priv
, assoc_req
);
1320 if (test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
1321 ret
= assoc_helper_secinfo(priv
, assoc_req
);
1326 if (test_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
)) {
1327 ret
= assoc_helper_wpa_ie(priv
, assoc_req
);
1332 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)
1333 || test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
1334 ret
= assoc_helper_wpa_keys(priv
, assoc_req
);
1339 /* SSID/BSSID should be the _last_ config option set, because they
1340 * trigger the association attempt.
1342 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)
1343 || test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
1346 ret
= assoc_helper_associate(priv
, assoc_req
);
1348 lbs_deb_assoc("ASSOC: association unsuccessful: %d\n",
1353 if (priv
->connect_status
!= LBS_CONNECTED
) {
1354 lbs_deb_assoc("ASSOC: association unsuccessful, "
1360 lbs_deb_assoc("associated to %s\n",
1361 print_mac(mac
, priv
->curbssparams
.bssid
));
1362 lbs_prepare_and_send_command(priv
,
1364 0, CMD_OPTION_WAITFORRSP
, 0, NULL
);
1372 lbs_deb_assoc("ASSOC: reconfiguration attempt unsuccessful: %d\n",
1376 mutex_lock(&priv
->lock
);
1377 priv
->in_progress_assoc_req
= NULL
;
1378 mutex_unlock(&priv
->lock
);
1382 lbs_deb_leave(LBS_DEB_ASSOC
);
1387 * Caller MUST hold any necessary locks
1389 struct assoc_request
*lbs_get_association_request(struct lbs_private
*priv
)
1391 struct assoc_request
* assoc_req
;
1393 lbs_deb_enter(LBS_DEB_ASSOC
);
1394 if (!priv
->pending_assoc_req
) {
1395 priv
->pending_assoc_req
= kzalloc(sizeof(struct assoc_request
),
1397 if (!priv
->pending_assoc_req
) {
1398 lbs_pr_info("Not enough memory to allocate association"
1404 /* Copy current configuration attributes to the association request,
1405 * but don't overwrite any that are already set.
1407 assoc_req
= priv
->pending_assoc_req
;
1408 if (!test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
1409 memcpy(&assoc_req
->ssid
, &priv
->curbssparams
.ssid
,
1411 assoc_req
->ssid_len
= priv
->curbssparams
.ssid_len
;
1414 if (!test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
))
1415 assoc_req
->channel
= priv
->curbssparams
.channel
;
1417 if (!test_bit(ASSOC_FLAG_BAND
, &assoc_req
->flags
))
1418 assoc_req
->band
= priv
->curbssparams
.band
;
1420 if (!test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
))
1421 assoc_req
->mode
= priv
->mode
;
1423 if (!test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
1424 memcpy(&assoc_req
->bssid
, priv
->curbssparams
.bssid
,
1428 if (!test_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
)) {
1430 for (i
= 0; i
< 4; i
++) {
1431 memcpy(&assoc_req
->wep_keys
[i
], &priv
->wep_keys
[i
],
1432 sizeof(struct enc_key
));
1436 if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
))
1437 assoc_req
->wep_tx_keyidx
= priv
->wep_tx_keyidx
;
1439 if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)) {
1440 memcpy(&assoc_req
->wpa_mcast_key
, &priv
->wpa_mcast_key
,
1441 sizeof(struct enc_key
));
1444 if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
1445 memcpy(&assoc_req
->wpa_unicast_key
, &priv
->wpa_unicast_key
,
1446 sizeof(struct enc_key
));
1449 if (!test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
1450 memcpy(&assoc_req
->secinfo
, &priv
->secinfo
,
1451 sizeof(struct lbs_802_11_security
));
1454 if (!test_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
)) {
1455 memcpy(&assoc_req
->wpa_ie
, &priv
->wpa_ie
,
1457 assoc_req
->wpa_ie_len
= priv
->wpa_ie_len
;
1460 lbs_deb_leave(LBS_DEB_ASSOC
);
1466 * @brief This function prepares command of authenticate.
1468 * @param priv A pointer to struct lbs_private structure
1469 * @param cmd A pointer to cmd_ds_command structure
1470 * @param pdata_buf Void cast of pointer to a BSSID to authenticate with
1474 int lbs_cmd_80211_authenticate(struct lbs_private
*priv
,
1475 struct cmd_ds_command
*cmd
,
1478 struct cmd_ds_802_11_authenticate
*pauthenticate
= &cmd
->params
.auth
;
1480 u8
*bssid
= pdata_buf
;
1481 DECLARE_MAC_BUF(mac
);
1483 lbs_deb_enter(LBS_DEB_JOIN
);
1485 cmd
->command
= cpu_to_le16(CMD_802_11_AUTHENTICATE
);
1486 cmd
->size
= cpu_to_le16(sizeof(struct cmd_ds_802_11_authenticate
)
1489 /* translate auth mode to 802.11 defined wire value */
1490 switch (priv
->secinfo
.auth_mode
) {
1491 case IW_AUTH_ALG_OPEN_SYSTEM
:
1492 pauthenticate
->authtype
= 0x00;
1494 case IW_AUTH_ALG_SHARED_KEY
:
1495 pauthenticate
->authtype
= 0x01;
1497 case IW_AUTH_ALG_LEAP
:
1498 pauthenticate
->authtype
= 0x80;
1501 lbs_deb_join("AUTH_CMD: invalid auth alg 0x%X\n",
1502 priv
->secinfo
.auth_mode
);
1506 memcpy(pauthenticate
->macaddr
, bssid
, ETH_ALEN
);
1508 lbs_deb_join("AUTH_CMD: BSSID %s, auth 0x%x\n",
1509 print_mac(mac
, bssid
), pauthenticate
->authtype
);
1513 lbs_deb_leave_args(LBS_DEB_JOIN
, "ret %d", ret
);
1518 * @brief Deauthenticate from a specific BSS
1520 * @param priv A pointer to struct lbs_private structure
1521 * @param bssid The specific BSS to deauthenticate from
1522 * @param reason The 802.11 sec. 7.3.1.7 Reason Code for deauthenticating
1524 * @return 0 on success, error on failure
1526 int lbs_cmd_80211_deauthenticate(struct lbs_private
*priv
, u8 bssid
[ETH_ALEN
],
1529 struct cmd_ds_802_11_deauthenticate cmd
;
1532 lbs_deb_enter(LBS_DEB_JOIN
);
1534 memset(&cmd
, 0, sizeof(cmd
));
1535 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
1536 memcpy(cmd
.macaddr
, &bssid
[0], ETH_ALEN
);
1537 cmd
.reasoncode
= cpu_to_le16(reason
);
1539 ret
= lbs_cmd_with_response(priv
, CMD_802_11_DEAUTHENTICATE
, &cmd
);
1541 /* Clean up everything even if there was an error; can't assume that
1542 * we're still authenticated to the AP after trying to deauth.
1544 lbs_mac_event_disconnected(priv
);
1546 lbs_deb_leave(LBS_DEB_JOIN
);
1550 int lbs_cmd_80211_associate(struct lbs_private
*priv
,
1551 struct cmd_ds_command
*cmd
, void *pdata_buf
)
1553 struct cmd_ds_802_11_associate
*passo
= &cmd
->params
.associate
;
1555 struct assoc_request
*assoc_req
= pdata_buf
;
1556 struct bss_descriptor
*bss
= &assoc_req
->bss
;
1559 struct mrvlietypes_ssidparamset
*ssid
;
1560 struct mrvlietypes_phyparamset
*phy
;
1561 struct mrvlietypes_ssparamset
*ss
;
1562 struct mrvlietypes_ratesparamset
*rates
;
1563 struct mrvlietypes_rsnparamset
*rsn
;
1565 lbs_deb_enter(LBS_DEB_ASSOC
);
1574 cmd
->command
= cpu_to_le16(CMD_802_11_ASSOCIATE
);
1576 memcpy(passo
->peerstaaddr
, bss
->bssid
, sizeof(passo
->peerstaaddr
));
1577 pos
+= sizeof(passo
->peerstaaddr
);
1579 /* set the listen interval */
1580 passo
->listeninterval
= cpu_to_le16(MRVDRV_DEFAULT_LISTEN_INTERVAL
);
1582 pos
+= sizeof(passo
->capability
);
1583 pos
+= sizeof(passo
->listeninterval
);
1584 pos
+= sizeof(passo
->bcnperiod
);
1585 pos
+= sizeof(passo
->dtimperiod
);
1587 ssid
= (struct mrvlietypes_ssidparamset
*) pos
;
1588 ssid
->header
.type
= cpu_to_le16(TLV_TYPE_SSID
);
1589 tmplen
= bss
->ssid_len
;
1590 ssid
->header
.len
= cpu_to_le16(tmplen
);
1591 memcpy(ssid
->ssid
, bss
->ssid
, tmplen
);
1592 pos
+= sizeof(ssid
->header
) + tmplen
;
1594 phy
= (struct mrvlietypes_phyparamset
*) pos
;
1595 phy
->header
.type
= cpu_to_le16(TLV_TYPE_PHY_DS
);
1596 tmplen
= sizeof(phy
->fh_ds
.dsparamset
);
1597 phy
->header
.len
= cpu_to_le16(tmplen
);
1598 memcpy(&phy
->fh_ds
.dsparamset
,
1599 &bss
->phyparamset
.dsparamset
.currentchan
,
1601 pos
+= sizeof(phy
->header
) + tmplen
;
1603 ss
= (struct mrvlietypes_ssparamset
*) pos
;
1604 ss
->header
.type
= cpu_to_le16(TLV_TYPE_CF
);
1605 tmplen
= sizeof(ss
->cf_ibss
.cfparamset
);
1606 ss
->header
.len
= cpu_to_le16(tmplen
);
1607 pos
+= sizeof(ss
->header
) + tmplen
;
1609 rates
= (struct mrvlietypes_ratesparamset
*) pos
;
1610 rates
->header
.type
= cpu_to_le16(TLV_TYPE_RATES
);
1611 memcpy(&rates
->rates
, &bss
->rates
, MAX_RATES
);
1613 if (get_common_rates(priv
, rates
->rates
, &tmplen
)) {
1617 pos
+= sizeof(rates
->header
) + tmplen
;
1618 rates
->header
.len
= cpu_to_le16(tmplen
);
1619 lbs_deb_assoc("ASSOC_CMD: num rates %u\n", tmplen
);
1621 /* Copy the infra. association rates into Current BSS state structure */
1622 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
1623 memcpy(&priv
->curbssparams
.rates
, &rates
->rates
, tmplen
);
1625 /* Set MSB on basic rates as the firmware requires, but _after_
1626 * copying to current bss rates.
1628 lbs_set_basic_rate_flags(rates
->rates
, tmplen
);
1630 if (assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
) {
1631 rsn
= (struct mrvlietypes_rsnparamset
*) pos
;
1632 /* WPA_IE or WPA2_IE */
1633 rsn
->header
.type
= cpu_to_le16((u16
) assoc_req
->wpa_ie
[0]);
1634 tmplen
= (u16
) assoc_req
->wpa_ie
[1];
1635 rsn
->header
.len
= cpu_to_le16(tmplen
);
1636 memcpy(rsn
->rsnie
, &assoc_req
->wpa_ie
[2], tmplen
);
1637 lbs_deb_hex(LBS_DEB_JOIN
, "ASSOC_CMD: RSN IE", (u8
*) rsn
,
1638 sizeof(rsn
->header
) + tmplen
);
1639 pos
+= sizeof(rsn
->header
) + tmplen
;
1642 /* update curbssparams */
1643 priv
->curbssparams
.channel
= bss
->phyparamset
.dsparamset
.currentchan
;
1645 if (lbs_parse_dnld_countryinfo_11d(priv
, bss
)) {
1650 cmd
->size
= cpu_to_le16((u16
) (pos
- (u8
*) passo
) + S_DS_GEN
);
1652 /* set the capability info */
1653 tmpcap
= (bss
->capability
& CAPINFO_MASK
);
1654 if (bss
->mode
== IW_MODE_INFRA
)
1655 tmpcap
|= WLAN_CAPABILITY_ESS
;
1656 passo
->capability
= cpu_to_le16(tmpcap
);
1657 lbs_deb_assoc("ASSOC_CMD: capability 0x%04x\n", tmpcap
);
1660 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1664 int lbs_ret_80211_associate(struct lbs_private
*priv
,
1665 struct cmd_ds_command
*resp
)
1668 union iwreq_data wrqu
;
1669 struct ieeetypes_assocrsp
*passocrsp
;
1670 struct bss_descriptor
*bss
;
1673 lbs_deb_enter(LBS_DEB_ASSOC
);
1675 if (!priv
->in_progress_assoc_req
) {
1676 lbs_deb_assoc("ASSOC_RESP: no in-progress assoc request\n");
1680 bss
= &priv
->in_progress_assoc_req
->bss
;
1682 passocrsp
= (struct ieeetypes_assocrsp
*) &resp
->params
;
1685 * Older FW versions map the IEEE 802.11 Status Code in the association
1686 * response to the following values returned in passocrsp->statuscode:
1688 * IEEE Status Code Marvell Status Code
1689 * 0 -> 0x0000 ASSOC_RESULT_SUCCESS
1690 * 13 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
1691 * 14 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
1692 * 15 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
1693 * 16 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
1694 * others -> 0x0003 ASSOC_RESULT_REFUSED
1696 * Other response codes:
1697 * 0x0001 -> ASSOC_RESULT_INVALID_PARAMETERS (unused)
1698 * 0x0002 -> ASSOC_RESULT_TIMEOUT (internal timer expired waiting for
1699 * association response from the AP)
1702 status_code
= le16_to_cpu(passocrsp
->statuscode
);
1703 switch (status_code
) {
1707 lbs_deb_assoc("ASSOC_RESP: invalid parameters\n");
1710 lbs_deb_assoc("ASSOC_RESP: internal timer "
1711 "expired while waiting for the AP\n");
1714 lbs_deb_assoc("ASSOC_RESP: association "
1718 lbs_deb_assoc("ASSOC_RESP: authentication "
1722 lbs_deb_assoc("ASSOC_RESP: failure reason 0x%02x "
1723 " unknown\n", status_code
);
1728 lbs_mac_event_disconnected(priv
);
1733 lbs_deb_hex(LBS_DEB_ASSOC
, "ASSOC_RESP", (void *)&resp
->params
,
1734 le16_to_cpu(resp
->size
) - S_DS_GEN
);
1736 /* Send a Media Connected event, according to the Spec */
1737 priv
->connect_status
= LBS_CONNECTED
;
1739 /* Update current SSID and BSSID */
1740 memcpy(&priv
->curbssparams
.ssid
, &bss
->ssid
, IW_ESSID_MAX_SIZE
);
1741 priv
->curbssparams
.ssid_len
= bss
->ssid_len
;
1742 memcpy(priv
->curbssparams
.bssid
, bss
->bssid
, ETH_ALEN
);
1744 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] = 0;
1745 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] = 0;
1747 memset(priv
->rawSNR
, 0x00, sizeof(priv
->rawSNR
));
1748 memset(priv
->rawNF
, 0x00, sizeof(priv
->rawNF
));
1749 priv
->nextSNRNF
= 0;
1752 netif_carrier_on(priv
->dev
);
1753 if (!priv
->tx_pending_len
)
1754 netif_wake_queue(priv
->dev
);
1756 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
, ETH_ALEN
);
1757 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1758 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
1761 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1765 static int lbs_adhoc_post(struct lbs_private
*priv
, struct cmd_header
*resp
)
1768 u16 command
= le16_to_cpu(resp
->command
);
1769 u16 result
= le16_to_cpu(resp
->result
);
1770 struct cmd_ds_802_11_ad_hoc_result
*adhoc_resp
;
1771 union iwreq_data wrqu
;
1772 struct bss_descriptor
*bss
;
1773 DECLARE_MAC_BUF(mac
);
1775 lbs_deb_enter(LBS_DEB_JOIN
);
1777 adhoc_resp
= (struct cmd_ds_802_11_ad_hoc_result
*) resp
;
1779 if (!priv
->in_progress_assoc_req
) {
1780 lbs_deb_join("ADHOC_RESP: no in-progress association "
1785 bss
= &priv
->in_progress_assoc_req
->bss
;
1788 * Join result code 0 --> SUCCESS
1791 lbs_deb_join("ADHOC_RESP: failed (result 0x%X)\n", result
);
1792 if (priv
->connect_status
== LBS_CONNECTED
)
1793 lbs_mac_event_disconnected(priv
);
1798 /* Send a Media Connected event, according to the Spec */
1799 priv
->connect_status
= LBS_CONNECTED
;
1801 if (command
== CMD_RET(CMD_802_11_AD_HOC_START
)) {
1802 /* Update the created network descriptor with the new BSSID */
1803 memcpy(bss
->bssid
, adhoc_resp
->bssid
, ETH_ALEN
);
1806 /* Set the BSSID from the joined/started descriptor */
1807 memcpy(&priv
->curbssparams
.bssid
, bss
->bssid
, ETH_ALEN
);
1809 /* Set the new SSID to current SSID */
1810 memcpy(&priv
->curbssparams
.ssid
, &bss
->ssid
, IW_ESSID_MAX_SIZE
);
1811 priv
->curbssparams
.ssid_len
= bss
->ssid_len
;
1813 netif_carrier_on(priv
->dev
);
1814 if (!priv
->tx_pending_len
)
1815 netif_wake_queue(priv
->dev
);
1817 memset(&wrqu
, 0, sizeof(wrqu
));
1818 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
, ETH_ALEN
);
1819 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1820 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
1822 lbs_deb_join("ADHOC_RESP: Joined/started '%s', BSSID %s, channel %d\n",
1823 escape_essid(bss
->ssid
, bss
->ssid_len
),
1824 print_mac(mac
, priv
->curbssparams
.bssid
),
1825 priv
->curbssparams
.channel
);
1828 lbs_deb_leave_args(LBS_DEB_JOIN
, "ret %d", ret
);