1 /* Copyright (C) 2006, Red Hat, Inc. */
3 #include <linux/bitops.h>
4 #include <net/ieee80211.h>
5 #include <linux/etherdevice.h>
15 static const u8 bssid_any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
16 static const u8 bssid_off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
19 static int assoc_helper_essid(struct lbs_private *priv,
20 struct assoc_request * assoc_req)
23 struct bss_descriptor * bss;
26 lbs_deb_enter(LBS_DEB_ASSOC);
28 /* FIXME: take channel into account when picking SSIDs if a channel
32 if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
33 channel = assoc_req->channel;
35 lbs_deb_assoc("SSID '%s' requested\n",
36 escape_essid(assoc_req->ssid, assoc_req->ssid_len));
37 if (assoc_req->mode == IW_MODE_INFRA) {
38 lbs_send_specific_ssid_scan(priv, assoc_req->ssid,
39 assoc_req->ssid_len, 0);
41 bss = lbs_find_ssid_in_list(priv, assoc_req->ssid,
42 assoc_req->ssid_len, NULL, IW_MODE_INFRA, channel);
44 memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
45 ret = lbs_associate(priv, assoc_req);
47 lbs_deb_assoc("SSID not found; cannot associate\n");
49 } else if (assoc_req->mode == IW_MODE_ADHOC) {
50 /* Scan for the network, do not save previous results. Stale
51 * scan data will cause us to join a non-existant adhoc network
53 lbs_send_specific_ssid_scan(priv, assoc_req->ssid,
54 assoc_req->ssid_len, 1);
56 /* Search for the requested SSID in the scan table */
57 bss = lbs_find_ssid_in_list(priv, assoc_req->ssid,
58 assoc_req->ssid_len, NULL, IW_MODE_ADHOC, channel);
60 lbs_deb_assoc("SSID found, will join\n");
61 memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
62 lbs_join_adhoc_network(priv, assoc_req);
64 /* else send START command */
65 lbs_deb_assoc("SSID not found, creating adhoc network\n");
66 memcpy(&assoc_req->bss.ssid, &assoc_req->ssid,
68 assoc_req->bss.ssid_len = assoc_req->ssid_len;
69 lbs_start_adhoc_network(priv, assoc_req);
73 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
78 static int assoc_helper_bssid(struct lbs_private *priv,
79 struct assoc_request * assoc_req)
82 struct bss_descriptor * bss;
85 lbs_deb_enter_args(LBS_DEB_ASSOC, "BSSID %s",
86 print_mac(mac, assoc_req->bssid));
88 /* Search for index position in list for requested MAC */
89 bss = lbs_find_bssid_in_list(priv, assoc_req->bssid,
92 lbs_deb_assoc("ASSOC: WAP: BSSID %s not found, "
93 "cannot associate.\n", print_mac(mac, assoc_req->bssid));
97 memcpy(&assoc_req->bss, bss, sizeof(struct bss_descriptor));
98 if (assoc_req->mode == IW_MODE_INFRA) {
99 ret = lbs_associate(priv, assoc_req);
100 lbs_deb_assoc("ASSOC: lbs_associate(bssid) returned %d\n", ret);
101 } else if (assoc_req->mode == IW_MODE_ADHOC) {
102 lbs_join_adhoc_network(priv, assoc_req);
106 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
111 static int assoc_helper_associate(struct lbs_private *priv,
112 struct assoc_request * assoc_req)
114 int ret = 0, done = 0;
116 lbs_deb_enter(LBS_DEB_ASSOC);
118 /* If we're given and 'any' BSSID, try associating based on SSID */
120 if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
121 if (compare_ether_addr(bssid_any, assoc_req->bssid)
122 && compare_ether_addr(bssid_off, assoc_req->bssid)) {
123 ret = assoc_helper_bssid(priv, assoc_req);
128 if (!done && test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
129 ret = assoc_helper_essid(priv, assoc_req);
132 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
137 static int assoc_helper_mode(struct lbs_private *priv,
138 struct assoc_request * assoc_req)
142 lbs_deb_enter(LBS_DEB_ASSOC);
144 if (assoc_req->mode == priv->mode)
147 if (assoc_req->mode == IW_MODE_INFRA) {
148 if (priv->psstate != PS_STATE_FULL_POWER)
149 lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
150 priv->psmode = LBS802_11POWERMODECAM;
153 priv->mode = assoc_req->mode;
154 ret = lbs_prepare_and_send_command(priv,
156 0, CMD_OPTION_WAITFORRSP,
157 OID_802_11_INFRASTRUCTURE_MODE,
158 /* Shoot me now */ (void *) (size_t) assoc_req->mode);
161 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
166 int lbs_update_channel(struct lbs_private *priv)
170 /* the channel in f/w could be out of sync; get the current channel */
171 lbs_deb_enter(LBS_DEB_ASSOC);
173 ret = lbs_get_channel(priv);
175 priv->curbssparams.channel = ret;
178 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
182 void lbs_sync_channel(struct work_struct *work)
184 struct lbs_private *priv = container_of(work, struct lbs_private,
187 lbs_deb_enter(LBS_DEB_ASSOC);
188 if (lbs_update_channel(priv))
189 lbs_pr_info("Channel synchronization failed.");
190 lbs_deb_leave(LBS_DEB_ASSOC);
193 static int assoc_helper_channel(struct lbs_private *priv,
194 struct assoc_request * assoc_req)
198 lbs_deb_enter(LBS_DEB_ASSOC);
200 ret = lbs_update_channel(priv);
202 lbs_deb_assoc("ASSOC: channel: error getting channel.\n");
206 if (assoc_req->channel == priv->curbssparams.channel)
209 if (priv->mesh_dev) {
210 /* Change mesh channel first; 21.p21 firmware won't let
211 you change channel otherwise (even though it'll return
213 lbs_mesh_config(priv, 0, assoc_req->channel);
216 lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
217 priv->curbssparams.channel, assoc_req->channel);
219 ret = lbs_set_channel(priv, assoc_req->channel);
221 lbs_deb_assoc("ASSOC: channel: error setting channel.\n");
223 /* FIXME: shouldn't need to grab the channel _again_ after setting
224 * it since the firmware is supposed to return the new channel, but
226 ret = lbs_update_channel(priv);
228 lbs_deb_assoc("ASSOC: channel: error getting channel.\n");
232 if (assoc_req->channel != priv->curbssparams.channel) {
233 lbs_deb_assoc("ASSOC: channel: failed to update channel to %d\n",
238 if ( assoc_req->secinfo.wep_enabled
239 && (assoc_req->wep_keys[0].len
240 || assoc_req->wep_keys[1].len
241 || assoc_req->wep_keys[2].len
242 || assoc_req->wep_keys[3].len)) {
243 /* Make sure WEP keys are re-sent to firmware */
244 set_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags);
247 /* Must restart/rejoin adhoc networks after channel change */
248 set_bit(ASSOC_FLAG_SSID, &assoc_req->flags);
252 lbs_mesh_config(priv, 1, priv->curbssparams.channel);
255 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
260 static int assoc_helper_wep_keys(struct lbs_private *priv,
261 struct assoc_request *assoc_req)
266 lbs_deb_enter(LBS_DEB_ASSOC);
268 /* Set or remove WEP keys */
269 if (assoc_req->wep_keys[0].len || assoc_req->wep_keys[1].len ||
270 assoc_req->wep_keys[2].len || assoc_req->wep_keys[3].len)
271 ret = lbs_cmd_802_11_set_wep(priv, CMD_ACT_ADD, assoc_req);
273 ret = lbs_cmd_802_11_set_wep(priv, CMD_ACT_REMOVE, assoc_req);
278 /* enable/disable the MAC's WEP packet filter */
279 if (assoc_req->secinfo.wep_enabled)
280 priv->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE;
282 priv->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE;
284 ret = lbs_set_mac_packet_filter(priv);
288 mutex_lock(&priv->lock);
290 /* Copy WEP keys into priv wep key fields */
291 for (i = 0; i < 4; i++) {
292 memcpy(&priv->wep_keys[i], &assoc_req->wep_keys[i],
293 sizeof(struct enc_key));
295 priv->wep_tx_keyidx = assoc_req->wep_tx_keyidx;
297 mutex_unlock(&priv->lock);
300 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
304 static int assoc_helper_secinfo(struct lbs_private *priv,
305 struct assoc_request * assoc_req)
311 lbs_deb_enter(LBS_DEB_ASSOC);
313 memcpy(&priv->secinfo, &assoc_req->secinfo,
314 sizeof(struct lbs_802_11_security));
316 ret = lbs_set_mac_packet_filter(priv);
320 /* If RSN is already enabled, don't try to enable it again, since
321 * ENABLE_RSN resets internal state machines and will clobber the
322 * 4-way WPA handshake.
325 /* Get RSN enabled/disabled */
326 ret = lbs_prepare_and_send_command(priv,
327 CMD_802_11_ENABLE_RSN,
329 CMD_OPTION_WAITFORRSP,
332 lbs_deb_assoc("Failed to get RSN status: %d\n", ret);
336 /* Don't re-enable RSN if it's already enabled */
337 do_wpa = (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled);
341 /* Set RSN enabled/disabled */
343 ret = lbs_prepare_and_send_command(priv,
344 CMD_802_11_ENABLE_RSN,
346 CMD_OPTION_WAITFORRSP,
350 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
355 static int assoc_helper_wpa_keys(struct lbs_private *priv,
356 struct assoc_request * assoc_req)
359 unsigned int flags = assoc_req->flags;
361 lbs_deb_enter(LBS_DEB_ASSOC);
363 /* Work around older firmware bug where WPA unicast and multicast
364 * keys must be set independently. Seen in SDIO parts with firmware
368 if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
369 clear_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags);
370 ret = lbs_prepare_and_send_command(priv,
371 CMD_802_11_KEY_MATERIAL,
373 CMD_OPTION_WAITFORRSP,
375 assoc_req->flags = flags;
381 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
382 clear_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags);
384 ret = lbs_prepare_and_send_command(priv,
385 CMD_802_11_KEY_MATERIAL,
387 CMD_OPTION_WAITFORRSP,
389 assoc_req->flags = flags;
393 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
398 static int assoc_helper_wpa_ie(struct lbs_private *priv,
399 struct assoc_request * assoc_req)
403 lbs_deb_enter(LBS_DEB_ASSOC);
405 if (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled) {
406 memcpy(&priv->wpa_ie, &assoc_req->wpa_ie, assoc_req->wpa_ie_len);
407 priv->wpa_ie_len = assoc_req->wpa_ie_len;
409 memset(&priv->wpa_ie, 0, MAX_WPA_IE_LEN);
410 priv->wpa_ie_len = 0;
413 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
418 static int should_deauth_infrastructure(struct lbs_private *priv,
419 struct assoc_request * assoc_req)
423 lbs_deb_enter(LBS_DEB_ASSOC);
425 if (priv->connect_status != LBS_CONNECTED)
428 if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
429 lbs_deb_assoc("Deauthenticating due to new SSID\n");
434 if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
435 if (priv->secinfo.auth_mode != assoc_req->secinfo.auth_mode) {
436 lbs_deb_assoc("Deauthenticating due to new security\n");
442 if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
443 lbs_deb_assoc("Deauthenticating due to new BSSID\n");
448 if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
449 lbs_deb_assoc("Deauthenticating due to channel switch\n");
454 /* FIXME: deal with 'auto' mode somehow */
455 if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
456 if (assoc_req->mode != IW_MODE_INFRA) {
457 lbs_deb_assoc("Deauthenticating due to leaving "
465 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
470 static int should_stop_adhoc(struct lbs_private *priv,
471 struct assoc_request * assoc_req)
473 lbs_deb_enter(LBS_DEB_ASSOC);
475 if (priv->connect_status != LBS_CONNECTED)
478 if (lbs_ssid_cmp(priv->curbssparams.ssid,
479 priv->curbssparams.ssid_len,
480 assoc_req->ssid, assoc_req->ssid_len) != 0)
483 /* FIXME: deal with 'auto' mode somehow */
484 if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
485 if (assoc_req->mode != IW_MODE_ADHOC)
489 if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
490 if (assoc_req->channel != priv->curbssparams.channel)
494 lbs_deb_leave(LBS_DEB_ASSOC);
499 void lbs_association_worker(struct work_struct *work)
501 struct lbs_private *priv = container_of(work, struct lbs_private,
503 struct assoc_request * assoc_req = NULL;
505 int find_any_ssid = 0;
506 DECLARE_MAC_BUF(mac);
508 lbs_deb_enter(LBS_DEB_ASSOC);
510 mutex_lock(&priv->lock);
511 assoc_req = priv->pending_assoc_req;
512 priv->pending_assoc_req = NULL;
513 priv->in_progress_assoc_req = assoc_req;
514 mutex_unlock(&priv->lock);
520 "Association Request:\n"
530 escape_essid(assoc_req->ssid, assoc_req->ssid_len),
531 assoc_req->channel, assoc_req->band, assoc_req->mode,
532 print_mac(mac, assoc_req->bssid),
533 assoc_req->secinfo.WPAenabled ? " WPA" : "",
534 assoc_req->secinfo.WPA2enabled ? " WPA2" : "",
535 assoc_req->secinfo.wep_enabled ? " WEP" : "",
536 assoc_req->secinfo.auth_mode);
538 /* If 'any' SSID was specified, find an SSID to associate with */
539 if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)
540 && !assoc_req->ssid_len)
543 /* But don't use 'any' SSID if there's a valid locked BSSID to use */
544 if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
545 if (compare_ether_addr(assoc_req->bssid, bssid_any)
546 && compare_ether_addr(assoc_req->bssid, bssid_off))
553 ret = lbs_find_best_network_ssid(priv, assoc_req->ssid,
554 &assoc_req->ssid_len, assoc_req->mode, &new_mode);
556 lbs_deb_assoc("Could not find best network\n");
561 /* Ensure we switch to the mode of the AP */
562 if (assoc_req->mode == IW_MODE_AUTO) {
563 set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
564 assoc_req->mode = new_mode;
569 * Check if the attributes being changing require deauthentication
570 * from the currently associated infrastructure access point.
572 if (priv->mode == IW_MODE_INFRA) {
573 if (should_deauth_infrastructure(priv, assoc_req)) {
574 ret = lbs_send_deauthentication(priv);
576 lbs_deb_assoc("Deauthentication due to new "
577 "configuration request failed: %d\n",
581 } else if (priv->mode == IW_MODE_ADHOC) {
582 if (should_stop_adhoc(priv, assoc_req)) {
583 ret = lbs_stop_adhoc_network(priv);
585 lbs_deb_assoc("Teardown of AdHoc network due to "
586 "new configuration request failed: %d\n",
593 /* Send the various configuration bits to the firmware */
594 if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
595 ret = assoc_helper_mode(priv, assoc_req);
600 if (test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags)) {
601 ret = assoc_helper_channel(priv, assoc_req);
606 if ( test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)
607 || test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags)) {
608 ret = assoc_helper_wep_keys(priv, assoc_req);
613 if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
614 ret = assoc_helper_secinfo(priv, assoc_req);
619 if (test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
620 ret = assoc_helper_wpa_ie(priv, assoc_req);
625 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)
626 || test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
627 ret = assoc_helper_wpa_keys(priv, assoc_req);
632 /* SSID/BSSID should be the _last_ config option set, because they
633 * trigger the association attempt.
635 if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)
636 || test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
639 ret = assoc_helper_associate(priv, assoc_req);
641 lbs_deb_assoc("ASSOC: association unsuccessful: %d\n",
646 if (priv->connect_status != LBS_CONNECTED) {
647 lbs_deb_assoc("ASSOC: association unsuccessful, "
653 lbs_deb_assoc("ASSOC: associated to '%s', %s\n",
654 escape_essid(priv->curbssparams.ssid,
655 priv->curbssparams.ssid_len),
656 print_mac(mac, priv->curbssparams.bssid));
657 lbs_prepare_and_send_command(priv,
659 0, CMD_OPTION_WAITFORRSP, 0, NULL);
661 lbs_prepare_and_send_command(priv,
663 0, CMD_OPTION_WAITFORRSP, 0, NULL);
671 lbs_deb_assoc("ASSOC: reconfiguration attempt unsuccessful: %d\n",
675 mutex_lock(&priv->lock);
676 priv->in_progress_assoc_req = NULL;
677 mutex_unlock(&priv->lock);
681 lbs_deb_leave(LBS_DEB_ASSOC);
686 * Caller MUST hold any necessary locks
688 struct assoc_request *lbs_get_association_request(struct lbs_private *priv)
690 struct assoc_request * assoc_req;
692 lbs_deb_enter(LBS_DEB_ASSOC);
693 if (!priv->pending_assoc_req) {
694 priv->pending_assoc_req = kzalloc(sizeof(struct assoc_request),
696 if (!priv->pending_assoc_req) {
697 lbs_pr_info("Not enough memory to allocate association"
703 /* Copy current configuration attributes to the association request,
704 * but don't overwrite any that are already set.
706 assoc_req = priv->pending_assoc_req;
707 if (!test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
708 memcpy(&assoc_req->ssid, &priv->curbssparams.ssid,
710 assoc_req->ssid_len = priv->curbssparams.ssid_len;
713 if (!test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
714 assoc_req->channel = priv->curbssparams.channel;
716 if (!test_bit(ASSOC_FLAG_BAND, &assoc_req->flags))
717 assoc_req->band = priv->curbssparams.band;
719 if (!test_bit(ASSOC_FLAG_MODE, &assoc_req->flags))
720 assoc_req->mode = priv->mode;
722 if (!test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
723 memcpy(&assoc_req->bssid, priv->curbssparams.bssid,
727 if (!test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)) {
729 for (i = 0; i < 4; i++) {
730 memcpy(&assoc_req->wep_keys[i], &priv->wep_keys[i],
731 sizeof(struct enc_key));
735 if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags))
736 assoc_req->wep_tx_keyidx = priv->wep_tx_keyidx;
738 if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
739 memcpy(&assoc_req->wpa_mcast_key, &priv->wpa_mcast_key,
740 sizeof(struct enc_key));
743 if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
744 memcpy(&assoc_req->wpa_unicast_key, &priv->wpa_unicast_key,
745 sizeof(struct enc_key));
748 if (!test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
749 memcpy(&assoc_req->secinfo, &priv->secinfo,
750 sizeof(struct lbs_802_11_security));
753 if (!test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
754 memcpy(&assoc_req->wpa_ie, &priv->wpa_ie,
756 assoc_req->wpa_ie_len = priv->wpa_ie_len;
759 lbs_deb_leave(LBS_DEB_ASSOC);