1 /* Copyright (C) 2006, Red Hat, Inc. */
3 #include <linux/etherdevice.h>
12 static const u8 bssid_any
[ETH_ALEN
] __attribute__ ((aligned (2))) =
13 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
14 static const u8 bssid_off
[ETH_ALEN
] __attribute__ ((aligned (2))) =
15 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
17 /* The firmware needs certain bits masked out of the beacon-derviced capability
18 * field when associating/joining to BSSs.
20 #define CAPINFO_MASK (~(0xda00))
25 * @brief Associate to a specific BSS discovered in a scan
27 * @param priv A pointer to struct lbs_private structure
28 * @param pbssdesc Pointer to the BSS descriptor to associate with.
30 * @return 0-success, otherwise fail
32 static int lbs_associate(struct lbs_private
*priv
,
33 struct assoc_request
*assoc_req
)
37 lbs_deb_enter(LBS_DEB_ASSOC
);
39 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_AUTHENTICATE
,
40 0, CMD_OPTION_WAITFORRSP
,
41 0, assoc_req
->bss
.bssid
);
46 /* set preamble to firmware */
47 if ((priv
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
) &&
48 (assoc_req
->bss
.capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
))
49 priv
->preamble
= CMD_TYPE_SHORT_PREAMBLE
;
51 priv
->preamble
= CMD_TYPE_LONG_PREAMBLE
;
53 lbs_set_radio_control(priv
);
55 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_ASSOCIATE
,
56 0, CMD_OPTION_WAITFORRSP
, 0, assoc_req
);
59 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
64 * @brief Join an adhoc network found in a previous scan
66 * @param priv A pointer to struct lbs_private structure
67 * @param pbssdesc Pointer to a BSS descriptor found in a previous scan
70 * @return 0--success, -1--fail
72 static int lbs_join_adhoc_network(struct lbs_private
*priv
,
73 struct assoc_request
*assoc_req
)
75 struct bss_descriptor
*bss
= &assoc_req
->bss
;
78 lbs_deb_join("current SSID '%s', ssid length %u\n",
79 escape_essid(priv
->curbssparams
.ssid
,
80 priv
->curbssparams
.ssid_len
),
81 priv
->curbssparams
.ssid_len
);
82 lbs_deb_join("requested ssid '%s', ssid length %u\n",
83 escape_essid(bss
->ssid
, bss
->ssid_len
),
86 /* check if the requested SSID is already joined */
87 if (priv
->curbssparams
.ssid_len
&&
88 !lbs_ssid_cmp(priv
->curbssparams
.ssid
,
89 priv
->curbssparams
.ssid_len
,
90 bss
->ssid
, bss
->ssid_len
) &&
91 (priv
->mode
== IW_MODE_ADHOC
) &&
92 (priv
->connect_status
== LBS_CONNECTED
)) {
93 union iwreq_data wrqu
;
95 lbs_deb_join("ADHOC_J_CMD: New ad-hoc SSID is the same as "
96 "current, not attempting to re-join");
98 /* Send the re-association event though, because the association
99 * request really was successful, even if just a null-op.
101 memset(&wrqu
, 0, sizeof(wrqu
));
102 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
,
104 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
105 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
109 /* Use shortpreamble only when both creator and card supports
111 if (!(bss
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
) ||
112 !(priv
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
)) {
113 lbs_deb_join("AdhocJoin: Long preamble\n");
114 priv
->preamble
= CMD_TYPE_LONG_PREAMBLE
;
116 lbs_deb_join("AdhocJoin: Short preamble\n");
117 priv
->preamble
= CMD_TYPE_SHORT_PREAMBLE
;
120 lbs_set_radio_control(priv
);
122 lbs_deb_join("AdhocJoin: channel = %d\n", assoc_req
->channel
);
123 lbs_deb_join("AdhocJoin: band = %c\n", assoc_req
->band
);
125 priv
->adhoccreate
= 0;
127 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_AD_HOC_JOIN
,
128 0, CMD_OPTION_WAITFORRSP
,
129 OID_802_11_SSID
, assoc_req
);
136 * @brief Start an Adhoc Network
138 * @param priv A pointer to struct lbs_private structure
139 * @param adhocssid The ssid of the Adhoc Network
140 * @return 0--success, -1--fail
142 static int lbs_start_adhoc_network(struct lbs_private
*priv
,
143 struct assoc_request
*assoc_req
)
147 priv
->adhoccreate
= 1;
149 if (priv
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
) {
150 lbs_deb_join("AdhocStart: Short preamble\n");
151 priv
->preamble
= CMD_TYPE_SHORT_PREAMBLE
;
153 lbs_deb_join("AdhocStart: Long preamble\n");
154 priv
->preamble
= CMD_TYPE_LONG_PREAMBLE
;
157 lbs_set_radio_control(priv
);
159 lbs_deb_join("AdhocStart: channel = %d\n", assoc_req
->channel
);
160 lbs_deb_join("AdhocStart: band = %d\n", assoc_req
->band
);
162 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_AD_HOC_START
,
163 0, CMD_OPTION_WAITFORRSP
, 0, assoc_req
);
168 int lbs_stop_adhoc_network(struct lbs_private
*priv
)
170 return lbs_prepare_and_send_command(priv
, CMD_802_11_AD_HOC_STOP
,
171 0, CMD_OPTION_WAITFORRSP
, 0, NULL
);
174 static inline int match_bss_no_security(struct lbs_802_11_security
*secinfo
,
175 struct bss_descriptor
*match_bss
)
177 if (!secinfo
->wep_enabled
&& !secinfo
->WPAenabled
178 && !secinfo
->WPA2enabled
179 && match_bss
->wpa_ie
[0] != MFIE_TYPE_GENERIC
180 && match_bss
->rsn_ie
[0] != MFIE_TYPE_RSN
181 && !(match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
187 static inline int match_bss_static_wep(struct lbs_802_11_security
*secinfo
,
188 struct bss_descriptor
*match_bss
)
190 if (secinfo
->wep_enabled
&& !secinfo
->WPAenabled
191 && !secinfo
->WPA2enabled
192 && (match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
198 static inline int match_bss_wpa(struct lbs_802_11_security
*secinfo
,
199 struct bss_descriptor
*match_bss
)
201 if (!secinfo
->wep_enabled
&& secinfo
->WPAenabled
202 && (match_bss
->wpa_ie
[0] == MFIE_TYPE_GENERIC
)
203 /* privacy bit may NOT be set in some APs like LinkSys WRT54G
204 && (match_bss->capability & WLAN_CAPABILITY_PRIVACY) */
211 static inline int match_bss_wpa2(struct lbs_802_11_security
*secinfo
,
212 struct bss_descriptor
*match_bss
)
214 if (!secinfo
->wep_enabled
&& secinfo
->WPA2enabled
&&
215 (match_bss
->rsn_ie
[0] == MFIE_TYPE_RSN
)
216 /* privacy bit may NOT be set in some APs like LinkSys WRT54G
217 (match_bss->capability & WLAN_CAPABILITY_PRIVACY) */
224 static inline int match_bss_dynamic_wep(struct lbs_802_11_security
*secinfo
,
225 struct bss_descriptor
*match_bss
)
227 if (!secinfo
->wep_enabled
&& !secinfo
->WPAenabled
228 && !secinfo
->WPA2enabled
229 && (match_bss
->wpa_ie
[0] != MFIE_TYPE_GENERIC
)
230 && (match_bss
->rsn_ie
[0] != MFIE_TYPE_RSN
)
231 && (match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
238 * @brief Check if a scanned network compatible with the driver settings
240 * WEP WPA WPA2 ad-hoc encrypt Network
241 * enabled enabled enabled AES mode privacy WPA WPA2 Compatible
242 * 0 0 0 0 NONE 0 0 0 yes No security
243 * 1 0 0 0 NONE 1 0 0 yes Static WEP
244 * 0 1 0 0 x 1x 1 x yes WPA
245 * 0 0 1 0 x 1x x 1 yes WPA2
246 * 0 0 0 1 NONE 1 0 0 yes Ad-hoc AES
247 * 0 0 0 0 !=NONE 1 0 0 yes Dynamic WEP
250 * @param priv A pointer to struct lbs_private
251 * @param index Index in scantable to check against current driver settings
252 * @param mode Network mode: Infrastructure or IBSS
254 * @return Index in scantable, or error code if negative
256 static int is_network_compatible(struct lbs_private
*priv
,
257 struct bss_descriptor
*bss
, uint8_t mode
)
261 lbs_deb_enter(LBS_DEB_SCAN
);
263 if (bss
->mode
!= mode
)
266 matched
= match_bss_no_security(&priv
->secinfo
, bss
);
269 matched
= match_bss_static_wep(&priv
->secinfo
, bss
);
272 matched
= match_bss_wpa(&priv
->secinfo
, bss
);
274 lbs_deb_scan("is_network_compatible() WPA: wpa_ie 0x%x "
275 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
276 "privacy 0x%x\n", bss
->wpa_ie
[0], bss
->rsn_ie
[0],
277 priv
->secinfo
.wep_enabled
? "e" : "d",
278 priv
->secinfo
.WPAenabled
? "e" : "d",
279 priv
->secinfo
.WPA2enabled
? "e" : "d",
280 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
283 matched
= match_bss_wpa2(&priv
->secinfo
, bss
);
285 lbs_deb_scan("is_network_compatible() WPA2: wpa_ie 0x%x "
286 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
287 "privacy 0x%x\n", bss
->wpa_ie
[0], bss
->rsn_ie
[0],
288 priv
->secinfo
.wep_enabled
? "e" : "d",
289 priv
->secinfo
.WPAenabled
? "e" : "d",
290 priv
->secinfo
.WPA2enabled
? "e" : "d",
291 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
294 matched
= match_bss_dynamic_wep(&priv
->secinfo
, bss
);
296 lbs_deb_scan("is_network_compatible() dynamic WEP: "
297 "wpa_ie 0x%x wpa2_ie 0x%x privacy 0x%x\n",
298 bss
->wpa_ie
[0], bss
->rsn_ie
[0],
299 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
303 /* bss security settings don't match those configured on card */
304 lbs_deb_scan("is_network_compatible() FAILED: wpa_ie 0x%x "
305 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s privacy 0x%x\n",
306 bss
->wpa_ie
[0], bss
->rsn_ie
[0],
307 priv
->secinfo
.wep_enabled
? "e" : "d",
308 priv
->secinfo
.WPAenabled
? "e" : "d",
309 priv
->secinfo
.WPA2enabled
? "e" : "d",
310 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
313 lbs_deb_leave_args(LBS_DEB_SCAN
, "matched: %d", matched
);
318 * @brief This function finds a specific compatible BSSID in the scan list
320 * Used in association code
322 * @param priv A pointer to struct lbs_private
323 * @param bssid BSSID to find in the scan list
324 * @param mode Network mode: Infrastructure or IBSS
326 * @return index in BSSID list, or error return code (< 0)
328 static struct bss_descriptor
*lbs_find_bssid_in_list(struct lbs_private
*priv
,
329 uint8_t *bssid
, uint8_t mode
)
331 struct bss_descriptor
*iter_bss
;
332 struct bss_descriptor
*found_bss
= NULL
;
334 lbs_deb_enter(LBS_DEB_SCAN
);
339 lbs_deb_hex(LBS_DEB_SCAN
, "looking for", bssid
, ETH_ALEN
);
341 /* Look through the scan table for a compatible match. The loop will
342 * continue past a matched bssid that is not compatible in case there
343 * is an AP with multiple SSIDs assigned to the same BSSID
345 mutex_lock(&priv
->lock
);
346 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
347 if (compare_ether_addr(iter_bss
->bssid
, bssid
))
348 continue; /* bssid doesn't match */
352 if (!is_network_compatible(priv
, iter_bss
, mode
))
354 found_bss
= iter_bss
;
357 found_bss
= iter_bss
;
361 mutex_unlock(&priv
->lock
);
364 lbs_deb_leave_args(LBS_DEB_SCAN
, "found_bss %p", found_bss
);
369 * @brief This function finds ssid in ssid list.
371 * Used in association code
373 * @param priv A pointer to struct lbs_private
374 * @param ssid SSID to find in the list
375 * @param bssid BSSID to qualify the SSID selection (if provided)
376 * @param mode Network mode: Infrastructure or IBSS
378 * @return index in BSSID list
380 static struct bss_descriptor
*lbs_find_ssid_in_list(struct lbs_private
*priv
,
381 uint8_t *ssid
, uint8_t ssid_len
,
382 uint8_t *bssid
, uint8_t mode
,
386 struct bss_descriptor
*iter_bss
= NULL
;
387 struct bss_descriptor
*found_bss
= NULL
;
388 struct bss_descriptor
*tmp_oldest
= NULL
;
390 lbs_deb_enter(LBS_DEB_SCAN
);
392 mutex_lock(&priv
->lock
);
394 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
396 (iter_bss
->last_scanned
< tmp_oldest
->last_scanned
))
397 tmp_oldest
= iter_bss
;
399 if (lbs_ssid_cmp(iter_bss
->ssid
, iter_bss
->ssid_len
,
400 ssid
, ssid_len
) != 0)
401 continue; /* ssid doesn't match */
402 if (bssid
&& compare_ether_addr(iter_bss
->bssid
, bssid
) != 0)
403 continue; /* bssid doesn't match */
404 if ((channel
> 0) && (iter_bss
->channel
!= channel
))
405 continue; /* channel doesn't match */
410 if (!is_network_compatible(priv
, iter_bss
, mode
))
414 /* Found requested BSSID */
415 found_bss
= iter_bss
;
419 if (SCAN_RSSI(iter_bss
->rssi
) > bestrssi
) {
420 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
421 found_bss
= iter_bss
;
426 if (SCAN_RSSI(iter_bss
->rssi
) > bestrssi
) {
427 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
428 found_bss
= iter_bss
;
435 mutex_unlock(&priv
->lock
);
436 lbs_deb_leave_args(LBS_DEB_SCAN
, "found_bss %p", found_bss
);
440 static int assoc_helper_essid(struct lbs_private
*priv
,
441 struct assoc_request
* assoc_req
)
444 struct bss_descriptor
* bss
;
447 lbs_deb_enter(LBS_DEB_ASSOC
);
449 /* FIXME: take channel into account when picking SSIDs if a channel
453 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
))
454 channel
= assoc_req
->channel
;
456 lbs_deb_assoc("SSID '%s' requested\n",
457 escape_essid(assoc_req
->ssid
, assoc_req
->ssid_len
));
458 if (assoc_req
->mode
== IW_MODE_INFRA
) {
459 lbs_send_specific_ssid_scan(priv
, assoc_req
->ssid
,
460 assoc_req
->ssid_len
);
462 bss
= lbs_find_ssid_in_list(priv
, assoc_req
->ssid
,
463 assoc_req
->ssid_len
, NULL
, IW_MODE_INFRA
, channel
);
465 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
466 ret
= lbs_associate(priv
, assoc_req
);
468 lbs_deb_assoc("SSID not found; cannot associate\n");
470 } else if (assoc_req
->mode
== IW_MODE_ADHOC
) {
471 /* Scan for the network, do not save previous results. Stale
472 * scan data will cause us to join a non-existant adhoc network
474 lbs_send_specific_ssid_scan(priv
, assoc_req
->ssid
,
475 assoc_req
->ssid_len
);
477 /* Search for the requested SSID in the scan table */
478 bss
= lbs_find_ssid_in_list(priv
, assoc_req
->ssid
,
479 assoc_req
->ssid_len
, NULL
, IW_MODE_ADHOC
, channel
);
481 lbs_deb_assoc("SSID found, will join\n");
482 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
483 lbs_join_adhoc_network(priv
, assoc_req
);
485 /* else send START command */
486 lbs_deb_assoc("SSID not found, creating adhoc network\n");
487 memcpy(&assoc_req
->bss
.ssid
, &assoc_req
->ssid
,
489 assoc_req
->bss
.ssid_len
= assoc_req
->ssid_len
;
490 lbs_start_adhoc_network(priv
, assoc_req
);
494 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
499 static int assoc_helper_bssid(struct lbs_private
*priv
,
500 struct assoc_request
* assoc_req
)
503 struct bss_descriptor
* bss
;
504 DECLARE_MAC_BUF(mac
);
506 lbs_deb_enter_args(LBS_DEB_ASSOC
, "BSSID %s",
507 print_mac(mac
, assoc_req
->bssid
));
509 /* Search for index position in list for requested MAC */
510 bss
= lbs_find_bssid_in_list(priv
, assoc_req
->bssid
,
513 lbs_deb_assoc("ASSOC: WAP: BSSID %s not found, "
514 "cannot associate.\n", print_mac(mac
, assoc_req
->bssid
));
518 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
519 if (assoc_req
->mode
== IW_MODE_INFRA
) {
520 ret
= lbs_associate(priv
, assoc_req
);
521 lbs_deb_assoc("ASSOC: lbs_associate(bssid) returned %d\n", ret
);
522 } else if (assoc_req
->mode
== IW_MODE_ADHOC
) {
523 lbs_join_adhoc_network(priv
, assoc_req
);
527 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
532 static int assoc_helper_associate(struct lbs_private
*priv
,
533 struct assoc_request
* assoc_req
)
535 int ret
= 0, done
= 0;
537 lbs_deb_enter(LBS_DEB_ASSOC
);
539 /* If we're given and 'any' BSSID, try associating based on SSID */
541 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
542 if (compare_ether_addr(bssid_any
, assoc_req
->bssid
)
543 && compare_ether_addr(bssid_off
, assoc_req
->bssid
)) {
544 ret
= assoc_helper_bssid(priv
, assoc_req
);
549 if (!done
&& test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
550 ret
= assoc_helper_essid(priv
, assoc_req
);
553 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
558 static int assoc_helper_mode(struct lbs_private
*priv
,
559 struct assoc_request
* assoc_req
)
563 lbs_deb_enter(LBS_DEB_ASSOC
);
565 if (assoc_req
->mode
== priv
->mode
)
568 if (assoc_req
->mode
== IW_MODE_INFRA
) {
569 if (priv
->psstate
!= PS_STATE_FULL_POWER
)
570 lbs_ps_wakeup(priv
, CMD_OPTION_WAITFORRSP
);
571 priv
->psmode
= LBS802_11POWERMODECAM
;
574 priv
->mode
= assoc_req
->mode
;
575 ret
= lbs_prepare_and_send_command(priv
,
577 0, CMD_OPTION_WAITFORRSP
,
578 OID_802_11_INFRASTRUCTURE_MODE
,
579 /* Shoot me now */ (void *) (size_t) assoc_req
->mode
);
582 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
586 static int assoc_helper_channel(struct lbs_private
*priv
,
587 struct assoc_request
* assoc_req
)
591 lbs_deb_enter(LBS_DEB_ASSOC
);
593 ret
= lbs_update_channel(priv
);
595 lbs_deb_assoc("ASSOC: channel: error getting channel.\n");
599 if (assoc_req
->channel
== priv
->curbssparams
.channel
)
602 if (priv
->mesh_dev
) {
603 /* Change mesh channel first; 21.p21 firmware won't let
604 you change channel otherwise (even though it'll return
606 lbs_mesh_config(priv
, CMD_ACT_MESH_CONFIG_STOP
,
610 lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
611 priv
->curbssparams
.channel
, assoc_req
->channel
);
613 ret
= lbs_set_channel(priv
, assoc_req
->channel
);
615 lbs_deb_assoc("ASSOC: channel: error setting channel.\n");
617 /* FIXME: shouldn't need to grab the channel _again_ after setting
618 * it since the firmware is supposed to return the new channel, but
620 ret
= lbs_update_channel(priv
);
622 lbs_deb_assoc("ASSOC: channel: error getting channel.\n");
626 if (assoc_req
->channel
!= priv
->curbssparams
.channel
) {
627 lbs_deb_assoc("ASSOC: channel: failed to update channel to %d\n",
632 if ( assoc_req
->secinfo
.wep_enabled
633 && (assoc_req
->wep_keys
[0].len
634 || assoc_req
->wep_keys
[1].len
635 || assoc_req
->wep_keys
[2].len
636 || assoc_req
->wep_keys
[3].len
)) {
637 /* Make sure WEP keys are re-sent to firmware */
638 set_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
);
641 /* Must restart/rejoin adhoc networks after channel change */
642 set_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
);
646 lbs_mesh_config(priv
, CMD_ACT_MESH_CONFIG_START
,
647 priv
->curbssparams
.channel
);
650 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
655 static int assoc_helper_wep_keys(struct lbs_private
*priv
,
656 struct assoc_request
*assoc_req
)
661 lbs_deb_enter(LBS_DEB_ASSOC
);
663 /* Set or remove WEP keys */
664 if (assoc_req
->wep_keys
[0].len
|| assoc_req
->wep_keys
[1].len
||
665 assoc_req
->wep_keys
[2].len
|| assoc_req
->wep_keys
[3].len
)
666 ret
= lbs_cmd_802_11_set_wep(priv
, CMD_ACT_ADD
, assoc_req
);
668 ret
= lbs_cmd_802_11_set_wep(priv
, CMD_ACT_REMOVE
, assoc_req
);
673 /* enable/disable the MAC's WEP packet filter */
674 if (assoc_req
->secinfo
.wep_enabled
)
675 priv
->mac_control
|= CMD_ACT_MAC_WEP_ENABLE
;
677 priv
->mac_control
&= ~CMD_ACT_MAC_WEP_ENABLE
;
679 lbs_set_mac_control(priv
);
681 mutex_lock(&priv
->lock
);
683 /* Copy WEP keys into priv wep key fields */
684 for (i
= 0; i
< 4; i
++) {
685 memcpy(&priv
->wep_keys
[i
], &assoc_req
->wep_keys
[i
],
686 sizeof(struct enc_key
));
688 priv
->wep_tx_keyidx
= assoc_req
->wep_tx_keyidx
;
690 mutex_unlock(&priv
->lock
);
693 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
697 static int assoc_helper_secinfo(struct lbs_private
*priv
,
698 struct assoc_request
* assoc_req
)
704 lbs_deb_enter(LBS_DEB_ASSOC
);
706 memcpy(&priv
->secinfo
, &assoc_req
->secinfo
,
707 sizeof(struct lbs_802_11_security
));
709 lbs_set_mac_control(priv
);
711 /* If RSN is already enabled, don't try to enable it again, since
712 * ENABLE_RSN resets internal state machines and will clobber the
713 * 4-way WPA handshake.
716 /* Get RSN enabled/disabled */
717 ret
= lbs_cmd_802_11_enable_rsn(priv
, CMD_ACT_GET
, &rsn
);
719 lbs_deb_assoc("Failed to get RSN status: %d\n", ret
);
723 /* Don't re-enable RSN if it's already enabled */
724 do_wpa
= assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
;
728 /* Set RSN enabled/disabled */
729 ret
= lbs_cmd_802_11_enable_rsn(priv
, CMD_ACT_SET
, &do_wpa
);
732 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
737 static int assoc_helper_wpa_keys(struct lbs_private
*priv
,
738 struct assoc_request
* assoc_req
)
741 unsigned int flags
= assoc_req
->flags
;
743 lbs_deb_enter(LBS_DEB_ASSOC
);
745 /* Work around older firmware bug where WPA unicast and multicast
746 * keys must be set independently. Seen in SDIO parts with firmware
750 if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
751 clear_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
);
752 ret
= lbs_cmd_802_11_key_material(priv
, CMD_ACT_SET
, assoc_req
);
753 assoc_req
->flags
= flags
;
759 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)) {
760 clear_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
);
762 ret
= lbs_cmd_802_11_key_material(priv
, CMD_ACT_SET
, assoc_req
);
763 assoc_req
->flags
= flags
;
767 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
772 static int assoc_helper_wpa_ie(struct lbs_private
*priv
,
773 struct assoc_request
* assoc_req
)
777 lbs_deb_enter(LBS_DEB_ASSOC
);
779 if (assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
) {
780 memcpy(&priv
->wpa_ie
, &assoc_req
->wpa_ie
, assoc_req
->wpa_ie_len
);
781 priv
->wpa_ie_len
= assoc_req
->wpa_ie_len
;
783 memset(&priv
->wpa_ie
, 0, MAX_WPA_IE_LEN
);
784 priv
->wpa_ie_len
= 0;
787 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
792 static int should_deauth_infrastructure(struct lbs_private
*priv
,
793 struct assoc_request
* assoc_req
)
797 if (priv
->connect_status
!= LBS_CONNECTED
)
800 lbs_deb_enter(LBS_DEB_ASSOC
);
801 if (test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
802 lbs_deb_assoc("Deauthenticating due to new SSID\n");
807 if (test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
808 if (priv
->secinfo
.auth_mode
!= assoc_req
->secinfo
.auth_mode
) {
809 lbs_deb_assoc("Deauthenticating due to new security\n");
815 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
816 lbs_deb_assoc("Deauthenticating due to new BSSID\n");
821 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
822 lbs_deb_assoc("Deauthenticating due to channel switch\n");
827 /* FIXME: deal with 'auto' mode somehow */
828 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
829 if (assoc_req
->mode
!= IW_MODE_INFRA
) {
830 lbs_deb_assoc("Deauthenticating due to leaving "
838 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
843 static int should_stop_adhoc(struct lbs_private
*priv
,
844 struct assoc_request
* assoc_req
)
846 lbs_deb_enter(LBS_DEB_ASSOC
);
848 if (priv
->connect_status
!= LBS_CONNECTED
)
851 if (lbs_ssid_cmp(priv
->curbssparams
.ssid
,
852 priv
->curbssparams
.ssid_len
,
853 assoc_req
->ssid
, assoc_req
->ssid_len
) != 0)
856 /* FIXME: deal with 'auto' mode somehow */
857 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
858 if (assoc_req
->mode
!= IW_MODE_ADHOC
)
862 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
863 if (assoc_req
->channel
!= priv
->curbssparams
.channel
)
867 lbs_deb_leave(LBS_DEB_ASSOC
);
873 * @brief This function finds the best SSID in the Scan List
875 * Search the scan table for the best SSID that also matches the current
876 * adapter network preference (infrastructure or adhoc)
878 * @param priv A pointer to struct lbs_private
880 * @return index in BSSID list
882 static struct bss_descriptor
*lbs_find_best_ssid_in_list(
883 struct lbs_private
*priv
, uint8_t mode
)
885 uint8_t bestrssi
= 0;
886 struct bss_descriptor
*iter_bss
;
887 struct bss_descriptor
*best_bss
= NULL
;
889 lbs_deb_enter(LBS_DEB_SCAN
);
891 mutex_lock(&priv
->lock
);
893 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
897 if (!is_network_compatible(priv
, iter_bss
, mode
))
899 if (SCAN_RSSI(iter_bss
->rssi
) <= bestrssi
)
901 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
906 if (SCAN_RSSI(iter_bss
->rssi
) <= bestrssi
)
908 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
914 mutex_unlock(&priv
->lock
);
915 lbs_deb_leave_args(LBS_DEB_SCAN
, "best_bss %p", best_bss
);
920 * @brief Find the best AP
922 * Used from association worker.
924 * @param priv A pointer to struct lbs_private structure
925 * @param pSSID A pointer to AP's ssid
927 * @return 0--success, otherwise--fail
929 static int lbs_find_best_network_ssid(struct lbs_private
*priv
,
930 uint8_t *out_ssid
, uint8_t *out_ssid_len
, uint8_t preferred_mode
,
934 struct bss_descriptor
*found
;
936 lbs_deb_enter(LBS_DEB_SCAN
);
938 priv
->scan_ssid_len
= 0;
939 lbs_scan_networks(priv
, 1);
940 if (priv
->surpriseremoved
)
943 found
= lbs_find_best_ssid_in_list(priv
, preferred_mode
);
944 if (found
&& (found
->ssid_len
> 0)) {
945 memcpy(out_ssid
, &found
->ssid
, IW_ESSID_MAX_SIZE
);
946 *out_ssid_len
= found
->ssid_len
;
947 *out_mode
= found
->mode
;
952 lbs_deb_leave_args(LBS_DEB_SCAN
, "ret %d", ret
);
957 void lbs_association_worker(struct work_struct
*work
)
959 struct lbs_private
*priv
= container_of(work
, struct lbs_private
,
961 struct assoc_request
* assoc_req
= NULL
;
963 int find_any_ssid
= 0;
964 DECLARE_MAC_BUF(mac
);
966 lbs_deb_enter(LBS_DEB_ASSOC
);
968 mutex_lock(&priv
->lock
);
969 assoc_req
= priv
->pending_assoc_req
;
970 priv
->pending_assoc_req
= NULL
;
971 priv
->in_progress_assoc_req
= assoc_req
;
972 mutex_unlock(&priv
->lock
);
978 "Association Request:\n"
988 escape_essid(assoc_req
->ssid
, assoc_req
->ssid_len
),
989 assoc_req
->channel
, assoc_req
->band
, assoc_req
->mode
,
990 print_mac(mac
, assoc_req
->bssid
),
991 assoc_req
->secinfo
.WPAenabled
? " WPA" : "",
992 assoc_req
->secinfo
.WPA2enabled
? " WPA2" : "",
993 assoc_req
->secinfo
.wep_enabled
? " WEP" : "",
994 assoc_req
->secinfo
.auth_mode
);
996 /* If 'any' SSID was specified, find an SSID to associate with */
997 if (test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)
998 && !assoc_req
->ssid_len
)
1001 /* But don't use 'any' SSID if there's a valid locked BSSID to use */
1002 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
1003 if (compare_ether_addr(assoc_req
->bssid
, bssid_any
)
1004 && compare_ether_addr(assoc_req
->bssid
, bssid_off
))
1008 if (find_any_ssid
) {
1009 u8 new_mode
= assoc_req
->mode
;
1011 ret
= lbs_find_best_network_ssid(priv
, assoc_req
->ssid
,
1012 &assoc_req
->ssid_len
, assoc_req
->mode
, &new_mode
);
1014 lbs_deb_assoc("Could not find best network\n");
1019 /* Ensure we switch to the mode of the AP */
1020 if (assoc_req
->mode
== IW_MODE_AUTO
) {
1021 set_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
);
1022 assoc_req
->mode
= new_mode
;
1027 * Check if the attributes being changing require deauthentication
1028 * from the currently associated infrastructure access point.
1030 if (priv
->mode
== IW_MODE_INFRA
) {
1031 if (should_deauth_infrastructure(priv
, assoc_req
)) {
1032 ret
= lbs_send_deauthentication(priv
);
1034 lbs_deb_assoc("Deauthentication due to new "
1035 "configuration request failed: %d\n",
1039 } else if (priv
->mode
== IW_MODE_ADHOC
) {
1040 if (should_stop_adhoc(priv
, assoc_req
)) {
1041 ret
= lbs_stop_adhoc_network(priv
);
1043 lbs_deb_assoc("Teardown of AdHoc network due to "
1044 "new configuration request failed: %d\n",
1051 /* Send the various configuration bits to the firmware */
1052 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
1053 ret
= assoc_helper_mode(priv
, assoc_req
);
1058 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
1059 ret
= assoc_helper_channel(priv
, assoc_req
);
1064 if ( test_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
)
1065 || test_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
)) {
1066 ret
= assoc_helper_wep_keys(priv
, assoc_req
);
1071 if (test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
1072 ret
= assoc_helper_secinfo(priv
, assoc_req
);
1077 if (test_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
)) {
1078 ret
= assoc_helper_wpa_ie(priv
, assoc_req
);
1083 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)
1084 || test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
1085 ret
= assoc_helper_wpa_keys(priv
, assoc_req
);
1090 /* SSID/BSSID should be the _last_ config option set, because they
1091 * trigger the association attempt.
1093 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)
1094 || test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
1097 ret
= assoc_helper_associate(priv
, assoc_req
);
1099 lbs_deb_assoc("ASSOC: association unsuccessful: %d\n",
1104 if (priv
->connect_status
!= LBS_CONNECTED
) {
1105 lbs_deb_assoc("ASSOC: association unsuccessful, "
1111 lbs_deb_assoc("associated to %s\n",
1112 print_mac(mac
, priv
->curbssparams
.bssid
));
1113 lbs_prepare_and_send_command(priv
,
1115 0, CMD_OPTION_WAITFORRSP
, 0, NULL
);
1123 lbs_deb_assoc("ASSOC: reconfiguration attempt unsuccessful: %d\n",
1127 mutex_lock(&priv
->lock
);
1128 priv
->in_progress_assoc_req
= NULL
;
1129 mutex_unlock(&priv
->lock
);
1133 lbs_deb_leave(LBS_DEB_ASSOC
);
1138 * Caller MUST hold any necessary locks
1140 struct assoc_request
*lbs_get_association_request(struct lbs_private
*priv
)
1142 struct assoc_request
* assoc_req
;
1144 lbs_deb_enter(LBS_DEB_ASSOC
);
1145 if (!priv
->pending_assoc_req
) {
1146 priv
->pending_assoc_req
= kzalloc(sizeof(struct assoc_request
),
1148 if (!priv
->pending_assoc_req
) {
1149 lbs_pr_info("Not enough memory to allocate association"
1155 /* Copy current configuration attributes to the association request,
1156 * but don't overwrite any that are already set.
1158 assoc_req
= priv
->pending_assoc_req
;
1159 if (!test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
1160 memcpy(&assoc_req
->ssid
, &priv
->curbssparams
.ssid
,
1162 assoc_req
->ssid_len
= priv
->curbssparams
.ssid_len
;
1165 if (!test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
))
1166 assoc_req
->channel
= priv
->curbssparams
.channel
;
1168 if (!test_bit(ASSOC_FLAG_BAND
, &assoc_req
->flags
))
1169 assoc_req
->band
= priv
->curbssparams
.band
;
1171 if (!test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
))
1172 assoc_req
->mode
= priv
->mode
;
1174 if (!test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
1175 memcpy(&assoc_req
->bssid
, priv
->curbssparams
.bssid
,
1179 if (!test_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
)) {
1181 for (i
= 0; i
< 4; i
++) {
1182 memcpy(&assoc_req
->wep_keys
[i
], &priv
->wep_keys
[i
],
1183 sizeof(struct enc_key
));
1187 if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
))
1188 assoc_req
->wep_tx_keyidx
= priv
->wep_tx_keyidx
;
1190 if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)) {
1191 memcpy(&assoc_req
->wpa_mcast_key
, &priv
->wpa_mcast_key
,
1192 sizeof(struct enc_key
));
1195 if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
1196 memcpy(&assoc_req
->wpa_unicast_key
, &priv
->wpa_unicast_key
,
1197 sizeof(struct enc_key
));
1200 if (!test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
1201 memcpy(&assoc_req
->secinfo
, &priv
->secinfo
,
1202 sizeof(struct lbs_802_11_security
));
1205 if (!test_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
)) {
1206 memcpy(&assoc_req
->wpa_ie
, &priv
->wpa_ie
,
1208 assoc_req
->wpa_ie_len
= priv
->wpa_ie_len
;
1211 lbs_deb_leave(LBS_DEB_ASSOC
);
1217 * @brief This function finds common rates between rate1 and card rates.
1219 * It will fill common rates in rate1 as output if found.
1221 * NOTE: Setting the MSB of the basic rates need to be taken
1222 * care, either before or after calling this function
1224 * @param priv A pointer to struct lbs_private structure
1225 * @param rate1 the buffer which keeps input and output
1226 * @param rate1_size the size of rate1 buffer; new size of buffer on return
1230 static int get_common_rates(struct lbs_private
*priv
,
1234 u8
*card_rates
= lbs_bg_rates
;
1235 size_t num_card_rates
= sizeof(lbs_bg_rates
);
1238 size_t tmp_size
= 0;
1240 /* For each rate in card_rates that exists in rate1, copy to tmp */
1241 for (i
= 0; card_rates
[i
] && (i
< num_card_rates
); i
++) {
1242 for (j
= 0; rates
[j
] && (j
< *rates_size
); j
++) {
1243 if (rates
[j
] == card_rates
[i
])
1244 tmp
[tmp_size
++] = card_rates
[i
];
1248 lbs_deb_hex(LBS_DEB_JOIN
, "AP rates ", rates
, *rates_size
);
1249 lbs_deb_hex(LBS_DEB_JOIN
, "card rates ", card_rates
, num_card_rates
);
1250 lbs_deb_hex(LBS_DEB_JOIN
, "common rates", tmp
, tmp_size
);
1251 lbs_deb_join("TX data rate 0x%02x\n", priv
->cur_rate
);
1253 if (!priv
->auto_rate
) {
1254 for (i
= 0; i
< tmp_size
; i
++) {
1255 if (tmp
[i
] == priv
->cur_rate
)
1258 lbs_pr_alert("Previously set fixed data rate %#x isn't "
1259 "compatible with the network.\n", priv
->cur_rate
);
1266 memset(rates
, 0, *rates_size
);
1267 *rates_size
= min_t(int, tmp_size
, *rates_size
);
1268 memcpy(rates
, tmp
, *rates_size
);
1274 * @brief Sets the MSB on basic rates as the firmware requires
1276 * Scan through an array and set the MSB for basic data rates.
1278 * @param rates buffer of data rates
1279 * @param len size of buffer
1281 static void lbs_set_basic_rate_flags(u8
*rates
, size_t len
)
1285 for (i
= 0; i
< len
; i
++) {
1286 if (rates
[i
] == 0x02 || rates
[i
] == 0x04 ||
1287 rates
[i
] == 0x0b || rates
[i
] == 0x16)
1293 * @brief Send Deauthentication Request
1295 * @param priv A pointer to struct lbs_private structure
1296 * @return 0--success, -1--fail
1298 int lbs_send_deauthentication(struct lbs_private
*priv
)
1300 return lbs_prepare_and_send_command(priv
, CMD_802_11_DEAUTHENTICATE
,
1301 0, CMD_OPTION_WAITFORRSP
, 0, NULL
);
1305 * @brief This function prepares command of authenticate.
1307 * @param priv A pointer to struct lbs_private structure
1308 * @param cmd A pointer to cmd_ds_command structure
1309 * @param pdata_buf Void cast of pointer to a BSSID to authenticate with
1313 int lbs_cmd_80211_authenticate(struct lbs_private
*priv
,
1314 struct cmd_ds_command
*cmd
,
1317 struct cmd_ds_802_11_authenticate
*pauthenticate
= &cmd
->params
.auth
;
1319 u8
*bssid
= pdata_buf
;
1320 DECLARE_MAC_BUF(mac
);
1322 lbs_deb_enter(LBS_DEB_JOIN
);
1324 cmd
->command
= cpu_to_le16(CMD_802_11_AUTHENTICATE
);
1325 cmd
->size
= cpu_to_le16(sizeof(struct cmd_ds_802_11_authenticate
)
1328 /* translate auth mode to 802.11 defined wire value */
1329 switch (priv
->secinfo
.auth_mode
) {
1330 case IW_AUTH_ALG_OPEN_SYSTEM
:
1331 pauthenticate
->authtype
= 0x00;
1333 case IW_AUTH_ALG_SHARED_KEY
:
1334 pauthenticate
->authtype
= 0x01;
1336 case IW_AUTH_ALG_LEAP
:
1337 pauthenticate
->authtype
= 0x80;
1340 lbs_deb_join("AUTH_CMD: invalid auth alg 0x%X\n",
1341 priv
->secinfo
.auth_mode
);
1345 memcpy(pauthenticate
->macaddr
, bssid
, ETH_ALEN
);
1347 lbs_deb_join("AUTH_CMD: BSSID %s, auth 0x%x\n",
1348 print_mac(mac
, bssid
), pauthenticate
->authtype
);
1352 lbs_deb_leave_args(LBS_DEB_JOIN
, "ret %d", ret
);
1356 int lbs_cmd_80211_deauthenticate(struct lbs_private
*priv
,
1357 struct cmd_ds_command
*cmd
)
1359 struct cmd_ds_802_11_deauthenticate
*dauth
= &cmd
->params
.deauth
;
1361 lbs_deb_enter(LBS_DEB_JOIN
);
1363 cmd
->command
= cpu_to_le16(CMD_802_11_DEAUTHENTICATE
);
1364 cmd
->size
= cpu_to_le16(sizeof(struct cmd_ds_802_11_deauthenticate
) +
1367 /* set AP MAC address */
1368 memmove(dauth
->macaddr
, priv
->curbssparams
.bssid
, ETH_ALEN
);
1370 /* Reason code 3 = Station is leaving */
1371 #define REASON_CODE_STA_LEAVING 3
1372 dauth
->reasoncode
= cpu_to_le16(REASON_CODE_STA_LEAVING
);
1374 lbs_deb_leave(LBS_DEB_JOIN
);
1378 int lbs_cmd_80211_associate(struct lbs_private
*priv
,
1379 struct cmd_ds_command
*cmd
, void *pdata_buf
)
1381 struct cmd_ds_802_11_associate
*passo
= &cmd
->params
.associate
;
1383 struct assoc_request
*assoc_req
= pdata_buf
;
1384 struct bss_descriptor
*bss
= &assoc_req
->bss
;
1387 struct mrvlietypes_ssidparamset
*ssid
;
1388 struct mrvlietypes_phyparamset
*phy
;
1389 struct mrvlietypes_ssparamset
*ss
;
1390 struct mrvlietypes_ratesparamset
*rates
;
1391 struct mrvlietypes_rsnparamset
*rsn
;
1393 lbs_deb_enter(LBS_DEB_ASSOC
);
1402 cmd
->command
= cpu_to_le16(CMD_802_11_ASSOCIATE
);
1404 memcpy(passo
->peerstaaddr
, bss
->bssid
, sizeof(passo
->peerstaaddr
));
1405 pos
+= sizeof(passo
->peerstaaddr
);
1407 /* set the listen interval */
1408 passo
->listeninterval
= cpu_to_le16(MRVDRV_DEFAULT_LISTEN_INTERVAL
);
1410 pos
+= sizeof(passo
->capability
);
1411 pos
+= sizeof(passo
->listeninterval
);
1412 pos
+= sizeof(passo
->bcnperiod
);
1413 pos
+= sizeof(passo
->dtimperiod
);
1415 ssid
= (struct mrvlietypes_ssidparamset
*) pos
;
1416 ssid
->header
.type
= cpu_to_le16(TLV_TYPE_SSID
);
1417 tmplen
= bss
->ssid_len
;
1418 ssid
->header
.len
= cpu_to_le16(tmplen
);
1419 memcpy(ssid
->ssid
, bss
->ssid
, tmplen
);
1420 pos
+= sizeof(ssid
->header
) + tmplen
;
1422 phy
= (struct mrvlietypes_phyparamset
*) pos
;
1423 phy
->header
.type
= cpu_to_le16(TLV_TYPE_PHY_DS
);
1424 tmplen
= sizeof(phy
->fh_ds
.dsparamset
);
1425 phy
->header
.len
= cpu_to_le16(tmplen
);
1426 memcpy(&phy
->fh_ds
.dsparamset
,
1427 &bss
->phyparamset
.dsparamset
.currentchan
,
1429 pos
+= sizeof(phy
->header
) + tmplen
;
1431 ss
= (struct mrvlietypes_ssparamset
*) pos
;
1432 ss
->header
.type
= cpu_to_le16(TLV_TYPE_CF
);
1433 tmplen
= sizeof(ss
->cf_ibss
.cfparamset
);
1434 ss
->header
.len
= cpu_to_le16(tmplen
);
1435 pos
+= sizeof(ss
->header
) + tmplen
;
1437 rates
= (struct mrvlietypes_ratesparamset
*) pos
;
1438 rates
->header
.type
= cpu_to_le16(TLV_TYPE_RATES
);
1439 memcpy(&rates
->rates
, &bss
->rates
, MAX_RATES
);
1441 if (get_common_rates(priv
, rates
->rates
, &tmplen
)) {
1445 pos
+= sizeof(rates
->header
) + tmplen
;
1446 rates
->header
.len
= cpu_to_le16(tmplen
);
1447 lbs_deb_assoc("ASSOC_CMD: num rates %u\n", tmplen
);
1449 /* Copy the infra. association rates into Current BSS state structure */
1450 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
1451 memcpy(&priv
->curbssparams
.rates
, &rates
->rates
, tmplen
);
1453 /* Set MSB on basic rates as the firmware requires, but _after_
1454 * copying to current bss rates.
1456 lbs_set_basic_rate_flags(rates
->rates
, tmplen
);
1458 if (assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
) {
1459 rsn
= (struct mrvlietypes_rsnparamset
*) pos
;
1460 /* WPA_IE or WPA2_IE */
1461 rsn
->header
.type
= cpu_to_le16((u16
) assoc_req
->wpa_ie
[0]);
1462 tmplen
= (u16
) assoc_req
->wpa_ie
[1];
1463 rsn
->header
.len
= cpu_to_le16(tmplen
);
1464 memcpy(rsn
->rsnie
, &assoc_req
->wpa_ie
[2], tmplen
);
1465 lbs_deb_hex(LBS_DEB_JOIN
, "ASSOC_CMD: RSN IE", (u8
*) rsn
,
1466 sizeof(rsn
->header
) + tmplen
);
1467 pos
+= sizeof(rsn
->header
) + tmplen
;
1470 /* update curbssparams */
1471 priv
->curbssparams
.channel
= bss
->phyparamset
.dsparamset
.currentchan
;
1473 if (lbs_parse_dnld_countryinfo_11d(priv
, bss
)) {
1478 cmd
->size
= cpu_to_le16((u16
) (pos
- (u8
*) passo
) + S_DS_GEN
);
1480 /* set the capability info */
1481 tmpcap
= (bss
->capability
& CAPINFO_MASK
);
1482 if (bss
->mode
== IW_MODE_INFRA
)
1483 tmpcap
|= WLAN_CAPABILITY_ESS
;
1484 passo
->capability
= cpu_to_le16(tmpcap
);
1485 lbs_deb_assoc("ASSOC_CMD: capability 0x%04x\n", tmpcap
);
1488 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1492 int lbs_cmd_80211_ad_hoc_start(struct lbs_private
*priv
,
1493 struct cmd_ds_command
*cmd
, void *pdata_buf
)
1495 struct cmd_ds_802_11_ad_hoc_start
*adhs
= &cmd
->params
.ads
;
1497 int cmdappendsize
= 0;
1498 struct assoc_request
*assoc_req
= pdata_buf
;
1500 size_t ratesize
= 0;
1502 lbs_deb_enter(LBS_DEB_JOIN
);
1509 cmd
->command
= cpu_to_le16(CMD_802_11_AD_HOC_START
);
1512 * Fill in the parameters for 2 data structures:
1513 * 1. cmd_ds_802_11_ad_hoc_start command
1514 * 2. priv->scantable[i]
1516 * Driver will fill up SSID, bsstype,IBSS param, Physical Param,
1517 * probe delay, and cap info.
1519 * Firmware will fill up beacon period, DTIM, Basic rates
1520 * and operational rates.
1523 memset(adhs
->ssid
, 0, IW_ESSID_MAX_SIZE
);
1524 memcpy(adhs
->ssid
, assoc_req
->ssid
, assoc_req
->ssid_len
);
1526 lbs_deb_join("ADHOC_S_CMD: SSID '%s', ssid length %u\n",
1527 escape_essid(assoc_req
->ssid
, assoc_req
->ssid_len
),
1528 assoc_req
->ssid_len
);
1530 /* set the BSS type */
1531 adhs
->bsstype
= CMD_BSS_TYPE_IBSS
;
1532 priv
->mode
= IW_MODE_ADHOC
;
1533 if (priv
->beacon_period
== 0)
1534 priv
->beacon_period
= MRVDRV_BEACON_INTERVAL
;
1535 adhs
->beaconperiod
= cpu_to_le16(priv
->beacon_period
);
1537 /* set Physical param set */
1538 #define DS_PARA_IE_ID 3
1539 #define DS_PARA_IE_LEN 1
1541 adhs
->phyparamset
.dsparamset
.elementid
= DS_PARA_IE_ID
;
1542 adhs
->phyparamset
.dsparamset
.len
= DS_PARA_IE_LEN
;
1544 WARN_ON(!assoc_req
->channel
);
1546 lbs_deb_join("ADHOC_S_CMD: Creating ADHOC on channel %d\n",
1547 assoc_req
->channel
);
1549 adhs
->phyparamset
.dsparamset
.currentchan
= assoc_req
->channel
;
1551 /* set IBSS param set */
1552 #define IBSS_PARA_IE_ID 6
1553 #define IBSS_PARA_IE_LEN 2
1555 adhs
->ssparamset
.ibssparamset
.elementid
= IBSS_PARA_IE_ID
;
1556 adhs
->ssparamset
.ibssparamset
.len
= IBSS_PARA_IE_LEN
;
1557 adhs
->ssparamset
.ibssparamset
.atimwindow
= 0;
1559 /* set capability info */
1560 tmpcap
= WLAN_CAPABILITY_IBSS
;
1561 if (assoc_req
->secinfo
.wep_enabled
) {
1562 lbs_deb_join("ADHOC_S_CMD: WEP enabled, "
1563 "setting privacy on\n");
1564 tmpcap
|= WLAN_CAPABILITY_PRIVACY
;
1566 lbs_deb_join("ADHOC_S_CMD: WEP disabled, "
1567 "setting privacy off\n");
1569 adhs
->capability
= cpu_to_le16(tmpcap
);
1572 adhs
->probedelay
= cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME
);
1574 memset(adhs
->rates
, 0, sizeof(adhs
->rates
));
1575 ratesize
= min(sizeof(adhs
->rates
), sizeof(lbs_bg_rates
));
1576 memcpy(adhs
->rates
, lbs_bg_rates
, ratesize
);
1578 /* Copy the ad-hoc creating rates into Current BSS state structure */
1579 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
1580 memcpy(&priv
->curbssparams
.rates
, &adhs
->rates
, ratesize
);
1582 /* Set MSB on basic rates as the firmware requires, but _after_
1583 * copying to current bss rates.
1585 lbs_set_basic_rate_flags(adhs
->rates
, ratesize
);
1587 lbs_deb_join("ADHOC_S_CMD: rates=%02x %02x %02x %02x \n",
1588 adhs
->rates
[0], adhs
->rates
[1], adhs
->rates
[2], adhs
->rates
[3]);
1590 lbs_deb_join("ADHOC_S_CMD: AD HOC Start command is ready\n");
1592 if (lbs_create_dnld_countryinfo_11d(priv
)) {
1593 lbs_deb_join("ADHOC_S_CMD: dnld_countryinfo_11d failed\n");
1598 cmd
->size
= cpu_to_le16(sizeof(struct cmd_ds_802_11_ad_hoc_start
) +
1599 S_DS_GEN
+ cmdappendsize
);
1603 lbs_deb_leave_args(LBS_DEB_JOIN
, "ret %d", ret
);
1607 int lbs_cmd_80211_ad_hoc_stop(struct cmd_ds_command
*cmd
)
1609 cmd
->command
= cpu_to_le16(CMD_802_11_AD_HOC_STOP
);
1610 cmd
->size
= cpu_to_le16(S_DS_GEN
);
1615 int lbs_cmd_80211_ad_hoc_join(struct lbs_private
*priv
,
1616 struct cmd_ds_command
*cmd
, void *pdata_buf
)
1618 struct cmd_ds_802_11_ad_hoc_join
*join_cmd
= &cmd
->params
.adj
;
1619 struct assoc_request
*assoc_req
= pdata_buf
;
1620 struct bss_descriptor
*bss
= &assoc_req
->bss
;
1621 int cmdappendsize
= 0;
1624 DECLARE_MAC_BUF(mac
);
1626 lbs_deb_enter(LBS_DEB_JOIN
);
1628 cmd
->command
= cpu_to_le16(CMD_802_11_AD_HOC_JOIN
);
1630 join_cmd
->bss
.type
= CMD_BSS_TYPE_IBSS
;
1631 join_cmd
->bss
.beaconperiod
= cpu_to_le16(bss
->beaconperiod
);
1633 memcpy(&join_cmd
->bss
.bssid
, &bss
->bssid
, ETH_ALEN
);
1634 memcpy(&join_cmd
->bss
.ssid
, &bss
->ssid
, bss
->ssid_len
);
1636 memcpy(&join_cmd
->bss
.phyparamset
, &bss
->phyparamset
,
1637 sizeof(union ieeetypes_phyparamset
));
1639 memcpy(&join_cmd
->bss
.ssparamset
, &bss
->ssparamset
,
1640 sizeof(union IEEEtypes_ssparamset
));
1642 join_cmd
->bss
.capability
= cpu_to_le16(bss
->capability
& CAPINFO_MASK
);
1643 lbs_deb_join("ADHOC_J_CMD: tmpcap=%4X CAPINFO_MASK=%4X\n",
1644 bss
->capability
, CAPINFO_MASK
);
1646 /* information on BSSID descriptor passed to FW */
1648 "ADHOC_J_CMD: BSSID = %s, SSID = '%s'\n",
1649 print_mac(mac
, join_cmd
->bss
.bssid
),
1650 join_cmd
->bss
.ssid
);
1653 join_cmd
->failtimeout
= cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT
);
1656 join_cmd
->probedelay
= cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME
);
1658 priv
->curbssparams
.channel
= bss
->channel
;
1660 /* Copy Data rates from the rates recorded in scan response */
1661 memset(join_cmd
->bss
.rates
, 0, sizeof(join_cmd
->bss
.rates
));
1662 ratesize
= min_t(u16
, sizeof(join_cmd
->bss
.rates
), MAX_RATES
);
1663 memcpy(join_cmd
->bss
.rates
, bss
->rates
, ratesize
);
1664 if (get_common_rates(priv
, join_cmd
->bss
.rates
, &ratesize
)) {
1665 lbs_deb_join("ADHOC_J_CMD: get_common_rates returns error.\n");
1670 /* Copy the ad-hoc creating rates into Current BSS state structure */
1671 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
1672 memcpy(&priv
->curbssparams
.rates
, join_cmd
->bss
.rates
, ratesize
);
1674 /* Set MSB on basic rates as the firmware requires, but _after_
1675 * copying to current bss rates.
1677 lbs_set_basic_rate_flags(join_cmd
->bss
.rates
, ratesize
);
1679 join_cmd
->bss
.ssparamset
.ibssparamset
.atimwindow
=
1680 cpu_to_le16(bss
->atimwindow
);
1682 if (assoc_req
->secinfo
.wep_enabled
) {
1683 u16 tmp
= le16_to_cpu(join_cmd
->bss
.capability
);
1684 tmp
|= WLAN_CAPABILITY_PRIVACY
;
1685 join_cmd
->bss
.capability
= cpu_to_le16(tmp
);
1688 if (priv
->psmode
== LBS802_11POWERMODEMAX_PSP
) {
1692 Localpsmode
= cpu_to_le32(LBS802_11POWERMODECAM
);
1693 ret
= lbs_prepare_and_send_command(priv
,
1696 0, 0, &Localpsmode
);
1704 if (lbs_parse_dnld_countryinfo_11d(priv
, bss
)) {
1709 cmd
->size
= cpu_to_le16(sizeof(struct cmd_ds_802_11_ad_hoc_join
) +
1710 S_DS_GEN
+ cmdappendsize
);
1713 lbs_deb_leave_args(LBS_DEB_JOIN
, "ret %d", ret
);
1717 int lbs_ret_80211_associate(struct lbs_private
*priv
,
1718 struct cmd_ds_command
*resp
)
1721 union iwreq_data wrqu
;
1722 struct ieeetypes_assocrsp
*passocrsp
;
1723 struct bss_descriptor
*bss
;
1726 lbs_deb_enter(LBS_DEB_ASSOC
);
1728 if (!priv
->in_progress_assoc_req
) {
1729 lbs_deb_assoc("ASSOC_RESP: no in-progress assoc request\n");
1733 bss
= &priv
->in_progress_assoc_req
->bss
;
1735 passocrsp
= (struct ieeetypes_assocrsp
*) &resp
->params
;
1738 * Older FW versions map the IEEE 802.11 Status Code in the association
1739 * response to the following values returned in passocrsp->statuscode:
1741 * IEEE Status Code Marvell Status Code
1742 * 0 -> 0x0000 ASSOC_RESULT_SUCCESS
1743 * 13 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
1744 * 14 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
1745 * 15 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
1746 * 16 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
1747 * others -> 0x0003 ASSOC_RESULT_REFUSED
1749 * Other response codes:
1750 * 0x0001 -> ASSOC_RESULT_INVALID_PARAMETERS (unused)
1751 * 0x0002 -> ASSOC_RESULT_TIMEOUT (internal timer expired waiting for
1752 * association response from the AP)
1755 status_code
= le16_to_cpu(passocrsp
->statuscode
);
1756 switch (status_code
) {
1760 lbs_deb_assoc("ASSOC_RESP: invalid parameters\n");
1763 lbs_deb_assoc("ASSOC_RESP: internal timer "
1764 "expired while waiting for the AP\n");
1767 lbs_deb_assoc("ASSOC_RESP: association "
1771 lbs_deb_assoc("ASSOC_RESP: authentication "
1775 lbs_deb_assoc("ASSOC_RESP: failure reason 0x%02x "
1776 " unknown\n", status_code
);
1781 lbs_mac_event_disconnected(priv
);
1786 lbs_deb_hex(LBS_DEB_ASSOC
, "ASSOC_RESP", (void *)&resp
->params
,
1787 le16_to_cpu(resp
->size
) - S_DS_GEN
);
1789 /* Send a Media Connected event, according to the Spec */
1790 priv
->connect_status
= LBS_CONNECTED
;
1792 /* Update current SSID and BSSID */
1793 memcpy(&priv
->curbssparams
.ssid
, &bss
->ssid
, IW_ESSID_MAX_SIZE
);
1794 priv
->curbssparams
.ssid_len
= bss
->ssid_len
;
1795 memcpy(priv
->curbssparams
.bssid
, bss
->bssid
, ETH_ALEN
);
1797 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] = 0;
1798 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] = 0;
1800 memset(priv
->rawSNR
, 0x00, sizeof(priv
->rawSNR
));
1801 memset(priv
->rawNF
, 0x00, sizeof(priv
->rawNF
));
1802 priv
->nextSNRNF
= 0;
1805 netif_carrier_on(priv
->dev
);
1806 if (!priv
->tx_pending_len
)
1807 netif_wake_queue(priv
->dev
);
1809 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
, ETH_ALEN
);
1810 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1811 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
1814 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1818 int lbs_ret_80211_disassociate(struct lbs_private
*priv
)
1820 lbs_deb_enter(LBS_DEB_JOIN
);
1822 lbs_mac_event_disconnected(priv
);
1824 lbs_deb_leave(LBS_DEB_JOIN
);
1828 int lbs_ret_80211_ad_hoc_start(struct lbs_private
*priv
,
1829 struct cmd_ds_command
*resp
)
1832 u16 command
= le16_to_cpu(resp
->command
);
1833 u16 result
= le16_to_cpu(resp
->result
);
1834 struct cmd_ds_802_11_ad_hoc_result
*padhocresult
;
1835 union iwreq_data wrqu
;
1836 struct bss_descriptor
*bss
;
1837 DECLARE_MAC_BUF(mac
);
1839 lbs_deb_enter(LBS_DEB_JOIN
);
1841 padhocresult
= &resp
->params
.result
;
1843 lbs_deb_join("ADHOC_RESP: size = %d\n", le16_to_cpu(resp
->size
));
1844 lbs_deb_join("ADHOC_RESP: command = %x\n", command
);
1845 lbs_deb_join("ADHOC_RESP: result = %x\n", result
);
1847 if (!priv
->in_progress_assoc_req
) {
1848 lbs_deb_join("ADHOC_RESP: no in-progress association "
1853 bss
= &priv
->in_progress_assoc_req
->bss
;
1856 * Join result code 0 --> SUCCESS
1859 lbs_deb_join("ADHOC_RESP: failed\n");
1860 if (priv
->connect_status
== LBS_CONNECTED
)
1861 lbs_mac_event_disconnected(priv
);
1867 * Now the join cmd should be successful
1868 * If BSSID has changed use SSID to compare instead of BSSID
1870 lbs_deb_join("ADHOC_RESP: associated to '%s'\n",
1871 escape_essid(bss
->ssid
, bss
->ssid_len
));
1873 /* Send a Media Connected event, according to the Spec */
1874 priv
->connect_status
= LBS_CONNECTED
;
1876 if (command
== CMD_RET(CMD_802_11_AD_HOC_START
)) {
1877 /* Update the created network descriptor with the new BSSID */
1878 memcpy(bss
->bssid
, padhocresult
->bssid
, ETH_ALEN
);
1881 /* Set the BSSID from the joined/started descriptor */
1882 memcpy(&priv
->curbssparams
.bssid
, bss
->bssid
, ETH_ALEN
);
1884 /* Set the new SSID to current SSID */
1885 memcpy(&priv
->curbssparams
.ssid
, &bss
->ssid
, IW_ESSID_MAX_SIZE
);
1886 priv
->curbssparams
.ssid_len
= bss
->ssid_len
;
1888 netif_carrier_on(priv
->dev
);
1889 if (!priv
->tx_pending_len
)
1890 netif_wake_queue(priv
->dev
);
1892 memset(&wrqu
, 0, sizeof(wrqu
));
1893 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
, ETH_ALEN
);
1894 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
1895 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
1897 lbs_deb_join("ADHOC_RESP: - Joined/Started Ad Hoc\n");
1898 lbs_deb_join("ADHOC_RESP: channel = %d\n", priv
->curbssparams
.channel
);
1899 lbs_deb_join("ADHOC_RESP: BSSID = %s\n",
1900 print_mac(mac
, padhocresult
->bssid
));
1903 lbs_deb_leave_args(LBS_DEB_JOIN
, "ret %d", ret
);
1907 int lbs_ret_80211_ad_hoc_stop(struct lbs_private
*priv
)
1909 lbs_deb_enter(LBS_DEB_JOIN
);
1911 lbs_mac_event_disconnected(priv
);
1913 lbs_deb_leave(LBS_DEB_JOIN
);