drivers/net/wireless/libertas/assoc.c - maze/linux - Git at Google

 /* Copyright (C) 2006, Red Hat, Inc. */

 #include <linux/bitops.h>
 #include <net/ieee80211.h>

 #include "assoc.h"
 #include "join.h"
 #include "decl.h"
 #include "hostcmd.h"
 #include "host.h"


 static const u8 bssid_any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
 static const u8 bssid_off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

 static int assoc_helper_essid(wlan_private *priv,
                               struct assoc_request * assoc_req)
 {
 	wlan_adapter *adapter = priv->adapter;
 	int ret = 0;
 	int i;

 	ENTER();

 	lbs_pr_debug(1, "New SSID requested: %s\n", assoc_req->ssid.ssid);
 	if (assoc_req->mode == IW_MODE_INFRA) {
 		if (adapter->prescan) {
 			libertas_send_specific_SSID_scan(priv, &assoc_req->ssid, 1);
 		}

 		i = libertas_find_SSID_in_list(adapter, &assoc_req->ssid,
 				NULL, IW_MODE_INFRA);
 		if (i >= 0) {
 			lbs_pr_debug(1,
 			       "SSID found in scan list ... associating...\n");

 			ret = wlan_associate(priv, &adapter->scantable[i]);
 			if (ret == 0) {
 				memcpy(&assoc_req->bssid,
 				       &adapter->scantable[i].macaddress,
 				       ETH_ALEN);
 			}
 		} else {
 			lbs_pr_debug(1, "SSID '%s' not found; cannot associate\n",
 				assoc_req->ssid.ssid);
 		}
 	} else if (assoc_req->mode == IW_MODE_ADHOC) {
 		/* Scan for the network, do not save previous results.  Stale
 		 *   scan data will cause us to join a non-existant adhoc network
 		 */
 		libertas_send_specific_SSID_scan(priv, &assoc_req->ssid, 0);

 		/* Search for the requested SSID in the scan table */
 		i = libertas_find_SSID_in_list(adapter, &assoc_req->ssid, NULL,
 				IW_MODE_ADHOC);
 		if (i >= 0) {
 			lbs_pr_debug(1, "SSID found at %d in List, so join\n", ret);
 			libertas_join_adhoc_network(priv, &adapter->scantable[i]);
 		} else {
 			/* else send START command */
 			lbs_pr_debug(1, "SSID not found in list, so creating adhoc"
 				" with SSID '%s'\n", assoc_req->ssid.ssid);
 			libertas_start_adhoc_network(priv, &assoc_req->ssid);
 		}
 		memcpy(&assoc_req->bssid, &adapter->current_addr, ETH_ALEN);
 	}

 	LEAVE();
 	return ret;
 }


 static int assoc_helper_bssid(wlan_private *priv,
                               struct assoc_request * assoc_req)
 {
 	wlan_adapter *adapter = priv->adapter;
 	int i, ret = 0;

 	ENTER();

 	lbs_pr_debug(1, "ASSOC: WAP: BSSID = " MAC_FMT "\n",
 		MAC_ARG(assoc_req->bssid));

 	/* Search for index position in list for requested MAC */
 	i = libertas_find_BSSID_in_list(adapter, assoc_req->bssid,
 			    assoc_req->mode);
 	if (i < 0) {
 		lbs_pr_debug(1, "ASSOC: WAP: BSSID " MAC_FMT " not found, "
 			"cannot associate.\n", MAC_ARG(assoc_req->bssid));
 		goto out;
 	}

 	if (assoc_req->mode == IW_MODE_INFRA) {
 		ret = wlan_associate(priv, &adapter->scantable[i]);
 		lbs_pr_debug(1, "ASSOC: return from wlan_associate(bssd) was %d\n", ret);
 	} else if (assoc_req->mode == IW_MODE_ADHOC) {
 		libertas_join_adhoc_network(priv, &adapter->scantable[i]);
 	}
 	memcpy(&assoc_req->ssid, &adapter->scantable[i].ssid,
 		sizeof(struct WLAN_802_11_SSID));

 out:
 	LEAVE();
 	return ret;
 }


 static int assoc_helper_associate(wlan_private *priv,
                                   struct assoc_request * assoc_req)
 {
 	int ret = 0, done = 0;

 	/* If we're given and 'any' BSSID, try associating based on SSID */

 	if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 		if (memcmp(bssid_any, assoc_req->bssid, ETH_ALEN)
 		    && memcmp(bssid_off, assoc_req->bssid, ETH_ALEN)) {
 			ret = assoc_helper_bssid(priv, assoc_req);
 			done = 1;
 			if (ret) {
 				lbs_pr_debug(1, "ASSOC: bssid: ret = %d\n", ret);
 			}
 		}
 	}

 	if (!done && test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 		ret = assoc_helper_essid(priv, assoc_req);
 		if (ret) {
 			lbs_pr_debug(1, "ASSOC: bssid: ret = %d\n", ret);
 		}
 	}

 	return ret;
 }


 static int assoc_helper_mode(wlan_private *priv,
                              struct assoc_request * assoc_req)
 {
 	wlan_adapter *adapter = priv->adapter;
 	int ret = 0;

 	ENTER();

 	if (assoc_req->mode == adapter->mode) {
 		LEAVE();
 		return 0;
 	}

 	if (assoc_req->mode == IW_MODE_INFRA) {
 		if (adapter->psstate != PS_STATE_FULL_POWER)
 			libertas_ps_wakeup(priv, cmd_option_waitforrsp);
 		adapter->psmode = wlan802_11powermodecam;
 	}

 	adapter->mode = assoc_req->mode;
 	ret = libertas_prepare_and_send_command(priv,
 				    cmd_802_11_snmp_mib,
 				    0, cmd_option_waitforrsp,
 				    OID_802_11_INFRASTRUCTURE_MODE,
 				    (void *) (size_t) assoc_req->mode);

 	LEAVE();
 	return ret;
 }


 static int assoc_helper_wep_keys(wlan_private *priv,
                                  struct assoc_request * assoc_req)
 {
 	wlan_adapter *adapter = priv->adapter;
 	int i;
 	int ret = 0;

 	ENTER();

 	/* Set or remove WEP keys */
 	if (   assoc_req->wep_keys[0].len
 	    || assoc_req->wep_keys[1].len
 	    || assoc_req->wep_keys[2].len
 	    || assoc_req->wep_keys[3].len) {
 		ret = libertas_prepare_and_send_command(priv,
 					    cmd_802_11_set_wep,
 					    cmd_act_add,
 					    cmd_option_waitforrsp,
 					    0, assoc_req);
 	} else {
 		ret = libertas_prepare_and_send_command(priv,
 					    cmd_802_11_set_wep,
 					    cmd_act_remove,
 					    cmd_option_waitforrsp,
 					    0, NULL);
 	}

 	if (ret)
 		goto out;

 	/* enable/disable the MAC's WEP packet filter */
 	if (assoc_req->secinfo.wep_enabled)
 		adapter->currentpacketfilter |= cmd_act_mac_wep_enable;
 	else
 		adapter->currentpacketfilter &= ~cmd_act_mac_wep_enable;
 	ret = libertas_set_mac_packet_filter(priv);
 	if (ret)
 		goto out;

 	mutex_lock(&adapter->lock);

 	/* Copy WEP keys into adapter wep key fields */
 	for (i = 0; i < 4; i++) {
 		memcpy(&adapter->wep_keys[i], &assoc_req->wep_keys[i],
 			sizeof(struct WLAN_802_11_KEY));
 	}
 	adapter->wep_tx_keyidx = assoc_req->wep_tx_keyidx;

 	mutex_unlock(&adapter->lock);

 out:
 	LEAVE();
 	return ret;
 }

 static int assoc_helper_secinfo(wlan_private *priv,
                                 struct assoc_request * assoc_req)
 {
 	wlan_adapter *adapter = priv->adapter;
 	int ret = 0;

 	ENTER();

 	memcpy(&adapter->secinfo, &assoc_req->secinfo,
 		sizeof(struct wlan_802_11_security));

 	ret = libertas_set_mac_packet_filter(priv);

 	LEAVE();
 	return ret;
 }


 static int assoc_helper_wpa_keys(wlan_private *priv,
                                  struct assoc_request * assoc_req)
 {
 	int ret = 0;

 	ENTER();

 	/* enable/Disable RSN */
 	ret = libertas_prepare_and_send_command(priv,
 				    cmd_802_11_enable_rsn,
 				    cmd_act_set,
 				    cmd_option_waitforrsp,
 				    0, assoc_req);
 	if (ret)
 		goto out;

 	ret = libertas_prepare_and_send_command(priv,
 				    cmd_802_11_key_material,
 				    cmd_act_set,
 				    cmd_option_waitforrsp,
 				    0, assoc_req);

 out:
 	LEAVE();
 	return ret;
 }


 static int assoc_helper_wpa_ie(wlan_private *priv,
                                struct assoc_request * assoc_req)
 {
 	wlan_adapter *adapter = priv->adapter;
 	int ret = 0;

 	ENTER();

 	if (assoc_req->secinfo.WPAenabled || assoc_req->secinfo.WPA2enabled) {
 		memcpy(&adapter->wpa_ie, &assoc_req->wpa_ie, assoc_req->wpa_ie_len);
 		adapter->wpa_ie_len = assoc_req->wpa_ie_len;
 	} else {
 		memset(&adapter->wpa_ie, 0, MAX_WPA_IE_LEN);
 		adapter->wpa_ie_len = 0;
 	}

 	LEAVE();
 	return ret;
 }


 static int should_deauth_infrastructure(wlan_adapter *adapter,
                                         struct assoc_request * assoc_req)
 {
 	if (adapter->connect_status != libertas_connected)
 		return 0;

 	if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 		lbs_pr_debug(1, "Deauthenticating due to new SSID in "
 			" configuration request.\n");
 		return 1;
 	}

 	if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 		if (adapter->secinfo.auth_mode != assoc_req->secinfo.auth_mode) {
 			lbs_pr_debug(1, "Deauthenticating due to updated security "
 				"info in configuration request.\n");
 			return 1;
 		}
 	}

 	if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 		lbs_pr_debug(1, "Deauthenticating due to new BSSID in "
 			" configuration request.\n");
 		return 1;
 	}

 	/* FIXME: deal with 'auto' mode somehow */
 	if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 		if (assoc_req->mode != IW_MODE_INFRA)
 			return 1;
 	}

 	return 0;
 }


 static int should_stop_adhoc(wlan_adapter *adapter,
                              struct assoc_request * assoc_req)
 {
 	if (adapter->connect_status != libertas_connected)
 		return 0;

 	if (adapter->curbssparams.ssid.ssidlength != assoc_req->ssid.ssidlength)
 		return 1;
 	if (memcmp(adapter->curbssparams.ssid.ssid, assoc_req->ssid.ssid,
 			adapter->curbssparams.ssid.ssidlength))
 		return 1;

 	/* FIXME: deal with 'auto' mode somehow */
 	if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 		if (assoc_req->mode != IW_MODE_ADHOC)
 			return 1;
 	}

 	return 0;
 }


 void wlan_association_worker(struct work_struct *work)
 {
 	wlan_private *priv = container_of(work, wlan_private, assoc_work.work);
 	wlan_adapter *adapter = priv->adapter;
 	struct assoc_request * assoc_req = NULL;
 	int ret = 0;
 	int find_any_ssid = 0;

 	ENTER();

 	mutex_lock(&adapter->lock);
 	assoc_req = adapter->assoc_req;
 	adapter->assoc_req = NULL;
 	mutex_unlock(&adapter->lock);

 	if (!assoc_req) {
 		LEAVE();
 		return;
 	}

 	lbs_pr_debug(1, "ASSOC: starting new association request: flags = 0x%lX\n",
 		assoc_req->flags);

 	/* If 'any' SSID was specified, find an SSID to associate with */
 	if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)
 	    && !assoc_req->ssid.ssidlength)
 		find_any_ssid = 1;

 	/* But don't use 'any' SSID if there's a valid locked BSSID to use */
 	if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 		if (memcmp(&assoc_req->bssid, bssid_any, ETH_ALEN)
 		    && memcmp(&assoc_req->bssid, bssid_off, ETH_ALEN))
 			find_any_ssid = 0;
 	}

 	if (find_any_ssid) {
 		u8 new_mode;

 		ret = libertas_find_best_network_SSID(priv, &assoc_req->ssid,
 				assoc_req->mode, &new_mode);
 		if (ret) {
 			lbs_pr_debug(1, "Could not find best network\n");
 			ret = -ENETUNREACH;
 			goto out;
 		}

 		/* Ensure we switch to the mode of the AP */
 		if (assoc_req->mode == IW_MODE_AUTO) {
 			set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
 			assoc_req->mode = new_mode;
 		}
 	}

 	/*
 	 * Check if the attributes being changing require deauthentication
 	 * from the currently associated infrastructure access point.
 	 */
 	if (adapter->mode == IW_MODE_INFRA) {
 		if (should_deauth_infrastructure(adapter, assoc_req)) {
 			ret = libertas_send_deauthentication(priv);
 			if (ret) {
 				lbs_pr_debug(1, "Deauthentication due to new "
 					"configuration request failed: %d\n",
 					ret);
 			}
 		}
 	} else if (adapter->mode == IW_MODE_ADHOC) {
 		if (should_stop_adhoc(adapter, assoc_req)) {
 			ret = libertas_stop_adhoc_network(priv);
 			if (ret) {
 				lbs_pr_debug(1, "Teardown of AdHoc network due to "
 					"new configuration request failed: %d\n",
 					ret);
 			}

 		}
 	}

 	/* Send the various configuration bits to the firmware */
 	if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
 		ret = assoc_helper_mode(priv, assoc_req);
 		if (ret) {
 lbs_pr_debug(1, "ASSOC(:%d) mode: ret = %d\n", __LINE__, ret);
 			goto out;
 		}
 	}

 	if (   test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)
 	    || test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags)) {
 		ret = assoc_helper_wep_keys(priv, assoc_req);
 		if (ret) {
 lbs_pr_debug(1, "ASSOC(:%d) wep_keys: ret = %d\n", __LINE__, ret);
 			goto out;
 		}
 	}

 	if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 		ret = assoc_helper_secinfo(priv, assoc_req);
 		if (ret) {
 lbs_pr_debug(1, "ASSOC(:%d) secinfo: ret = %d\n", __LINE__, ret);
 			goto out;
 		}
 	}

 	if (test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
 		ret = assoc_helper_wpa_ie(priv, assoc_req);
 		if (ret) {
 lbs_pr_debug(1, "ASSOC(:%d) wpa_ie: ret = %d\n", __LINE__, ret);
 			goto out;
 		}
 	}

 	if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)
 	    || test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 		ret = assoc_helper_wpa_keys(priv, assoc_req);
 		if (ret) {
 lbs_pr_debug(1, "ASSOC(:%d) wpa_keys: ret = %d\n", __LINE__, ret);
 			goto out;
 		}
 	}

 	/* SSID/BSSID should be the _last_ config option set, because they
 	 * trigger the association attempt.
 	 */
 	if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)
 	    || test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 		int success = 1;

 		ret = assoc_helper_associate(priv, assoc_req);
 		if (ret) {
 			lbs_pr_debug(1, "ASSOC: association attempt unsuccessful: %d\n",
 				ret);
 			success = 0;
 		}

 		if (adapter->connect_status != libertas_connected) {
 			lbs_pr_debug(1, "ASSOC: assoication attempt unsuccessful, "
 				"not connected.\n");
 			success = 0;
 		}

 		if (success) {
 			lbs_pr_debug(1, "ASSOC: association attempt successful. "
 				"Associated to '%s' (" MAC_FMT ")\n",
 				assoc_req->ssid.ssid, MAC_ARG(assoc_req->bssid));
 			libertas_prepare_and_send_command(priv,
 				cmd_802_11_rssi,
 				0, cmd_option_waitforrsp, 0, NULL);

 			libertas_prepare_and_send_command(priv,
 				cmd_802_11_get_log,
 				0, cmd_option_waitforrsp, 0, NULL);
 		} else {

 			ret = -1;
 		}
 	}

 out:
 	if (ret) {
 		lbs_pr_debug(1, "ASSOC: reconfiguration attempt unsuccessful: %d\n",
 			ret);
 	}
 	kfree(assoc_req);
 	LEAVE();
 }


 /*
  * Caller MUST hold any necessary locks
  */
 struct assoc_request * wlan_get_association_request(wlan_adapter *adapter)
 {
 	struct assoc_request * assoc_req;

 	if (!adapter->assoc_req) {
 		adapter->assoc_req = kzalloc(sizeof(struct assoc_request), GFP_KERNEL);
 		if (!adapter->assoc_req) {
 			lbs_pr_info("Not enough memory to allocate association"
 				" request!\n");
 			return NULL;
 		}
 	}

 	/* Copy current configuration attributes to the association request,
 	 * but don't overwrite any that are already set.
 	 */
 	assoc_req = adapter->assoc_req;
 	if (!test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
 		memcpy(&assoc_req->ssid, adapter->curbssparams.ssid.ssid,
 			adapter->curbssparams.ssid.ssidlength);
 	}

 	if (!test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
 		assoc_req->channel = adapter->curbssparams.channel;

 	if (!test_bit(ASSOC_FLAG_MODE, &assoc_req->flags))
 		assoc_req->mode = adapter->mode;

 	if (!test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
 		memcpy(&assoc_req->bssid, adapter->curbssparams.bssid,
 			ETH_ALEN);
 	}

 	if (!test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)) {
 		int i;
 		for (i = 0; i < 4; i++) {
 			memcpy(&assoc_req->wep_keys[i], &adapter->wep_keys[i],
 				sizeof(struct WLAN_802_11_KEY));
 		}
 	}

 	if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags))
 		assoc_req->wep_tx_keyidx = adapter->wep_tx_keyidx;

 	if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
 		memcpy(&assoc_req->wpa_mcast_key, &adapter->wpa_mcast_key,
 			sizeof(struct WLAN_802_11_KEY));
 	}

 	if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
 		memcpy(&assoc_req->wpa_unicast_key, &adapter->wpa_unicast_key,
 			sizeof(struct WLAN_802_11_KEY));
 	}

 	if (!test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
 		memcpy(&assoc_req->secinfo, &adapter->secinfo,
 			sizeof(struct wlan_802_11_security));
 	}

 	if (!test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
 		memcpy(&assoc_req->wpa_ie, &adapter->wpa_ie,
 			MAX_WPA_IE_LEN);
 		assoc_req->wpa_ie_len = adapter->wpa_ie_len;
 	}

 	return assoc_req;
 }
	/* Copyright (C) 2006, Red Hat, Inc. */

	#include <linux/bitops.h>
	#include <net/ieee80211.h>

	#include "assoc.h"
	#include "join.h"
	#include "decl.h"
	#include "hostcmd.h"
	#include "host.h"


	static const u8 bssid_any[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
	static const u8 bssid_off[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

	static int assoc_helper_essid(wlan_private *priv,
	struct assoc_request * assoc_req)
	{
	wlan_adapter *adapter = priv->adapter;
	int ret = 0;
	int i;

	ENTER();

	lbs_pr_debug(1, "New SSID requested: %s\n", assoc_req->ssid.ssid);
	if (assoc_req->mode == IW_MODE_INFRA) {
	if (adapter->prescan) {
	libertas_send_specific_SSID_scan(priv, &assoc_req->ssid, 1);
	}

	i = libertas_find_SSID_in_list(adapter, &assoc_req->ssid,
	NULL, IW_MODE_INFRA);
	if (i >= 0) {
	lbs_pr_debug(1,
	"SSID found in scan list ... associating...\n");

	ret = wlan_associate(priv, &adapter->scantable[i]);
	if (ret == 0) {
	memcpy(&assoc_req->bssid,
	&adapter->scantable[i].macaddress,
	ETH_ALEN);
	}
	} else {
	lbs_pr_debug(1, "SSID '%s' not found; cannot associate\n",
	assoc_req->ssid.ssid);
	}
	} else if (assoc_req->mode == IW_MODE_ADHOC) {
	/* Scan for the network, do not save previous results. Stale
	* scan data will cause us to join a non-existant adhoc network
	*/
	libertas_send_specific_SSID_scan(priv, &assoc_req->ssid, 0);

	/* Search for the requested SSID in the scan table */
	i = libertas_find_SSID_in_list(adapter, &assoc_req->ssid, NULL,
	IW_MODE_ADHOC);
	if (i >= 0) {
	lbs_pr_debug(1, "SSID found at %d in List, so join\n", ret);
	libertas_join_adhoc_network(priv, &adapter->scantable[i]);
	} else {
	/* else send START command */
	lbs_pr_debug(1, "SSID not found in list, so creating adhoc"
	" with SSID '%s'\n", assoc_req->ssid.ssid);
	libertas_start_adhoc_network(priv, &assoc_req->ssid);
	}
	memcpy(&assoc_req->bssid, &adapter->current_addr, ETH_ALEN);
	}

	LEAVE();
	return ret;
	}


	static int assoc_helper_bssid(wlan_private *priv,
	struct assoc_request * assoc_req)
	{
	wlan_adapter *adapter = priv->adapter;
	int i, ret = 0;

	ENTER();

	lbs_pr_debug(1, "ASSOC: WAP: BSSID = " MAC_FMT "\n",
	MAC_ARG(assoc_req->bssid));

	/* Search for index position in list for requested MAC */
	i = libertas_find_BSSID_in_list(adapter, assoc_req->bssid,
	assoc_req->mode);
	if (i < 0) {
	lbs_pr_debug(1, "ASSOC: WAP: BSSID " MAC_FMT " not found, "
	"cannot associate.\n", MAC_ARG(assoc_req->bssid));
	goto out;
	}

	if (assoc_req->mode == IW_MODE_INFRA) {
	ret = wlan_associate(priv, &adapter->scantable[i]);
	lbs_pr_debug(1, "ASSOC: return from wlan_associate(bssd) was %d\n", ret);
	} else if (assoc_req->mode == IW_MODE_ADHOC) {
	libertas_join_adhoc_network(priv, &adapter->scantable[i]);
	}
	memcpy(&assoc_req->ssid, &adapter->scantable[i].ssid,
	sizeof(struct WLAN_802_11_SSID));

	out:
	LEAVE();
	return ret;
	}


	static int assoc_helper_associate(wlan_private *priv,
	struct assoc_request * assoc_req)
	{
	int ret = 0, done = 0;

	/* If we're given and 'any' BSSID, try associating based on SSID */

	if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
	if (memcmp(bssid_any, assoc_req->bssid, ETH_ALEN)
	&& memcmp(bssid_off, assoc_req->bssid, ETH_ALEN)) {
	ret = assoc_helper_bssid(priv, assoc_req);
	done = 1;
	if (ret) {
	lbs_pr_debug(1, "ASSOC: bssid: ret = %d\n", ret);
	}
	}
	}

	if (!done && test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
	ret = assoc_helper_essid(priv, assoc_req);
	if (ret) {
	lbs_pr_debug(1, "ASSOC: bssid: ret = %d\n", ret);
	}
	}

	return ret;
	}


	static int assoc_helper_mode(wlan_private *priv,
	struct assoc_request * assoc_req)
	{
	wlan_adapter *adapter = priv->adapter;
	int ret = 0;

	ENTER();

	if (assoc_req->mode == adapter->mode) {
	LEAVE();
	return 0;
	}

	if (assoc_req->mode == IW_MODE_INFRA) {
	if (adapter->psstate != PS_STATE_FULL_POWER)
	libertas_ps_wakeup(priv, cmd_option_waitforrsp);
	adapter->psmode = wlan802_11powermodecam;
	}

	adapter->mode = assoc_req->mode;
	ret = libertas_prepare_and_send_command(priv,
	cmd_802_11_snmp_mib,
	0, cmd_option_waitforrsp,
	OID_802_11_INFRASTRUCTURE_MODE,
	(void *) (size_t) assoc_req->mode);

	LEAVE();
	return ret;
	}


	static int assoc_helper_wep_keys(wlan_private *priv,
	struct assoc_request * assoc_req)
	{
	wlan_adapter *adapter = priv->adapter;
	int i;
	int ret = 0;

	ENTER();

	/* Set or remove WEP keys */
	if ( assoc_req->wep_keys[0].len
	\|\| assoc_req->wep_keys[1].len
	\|\| assoc_req->wep_keys[2].len
	\|\| assoc_req->wep_keys[3].len) {
	ret = libertas_prepare_and_send_command(priv,
	cmd_802_11_set_wep,
	cmd_act_add,
	cmd_option_waitforrsp,
	0, assoc_req);
	} else {
	ret = libertas_prepare_and_send_command(priv,
	cmd_802_11_set_wep,
	cmd_act_remove,
	cmd_option_waitforrsp,
	0, NULL);
	}

	if (ret)
	goto out;

	/* enable/disable the MAC's WEP packet filter */
	if (assoc_req->secinfo.wep_enabled)
	adapter->currentpacketfilter \|= cmd_act_mac_wep_enable;
	else
	adapter->currentpacketfilter &= ~cmd_act_mac_wep_enable;
	ret = libertas_set_mac_packet_filter(priv);
	if (ret)
	goto out;

	mutex_lock(&adapter->lock);

	/* Copy WEP keys into adapter wep key fields */
	for (i = 0; i < 4; i++) {
	memcpy(&adapter->wep_keys[i], &assoc_req->wep_keys[i],
	sizeof(struct WLAN_802_11_KEY));
	}
	adapter->wep_tx_keyidx = assoc_req->wep_tx_keyidx;

	mutex_unlock(&adapter->lock);

	out:
	LEAVE();
	return ret;
	}

	static int assoc_helper_secinfo(wlan_private *priv,
	struct assoc_request * assoc_req)
	{
	wlan_adapter *adapter = priv->adapter;
	int ret = 0;

	ENTER();

	memcpy(&adapter->secinfo, &assoc_req->secinfo,
	sizeof(struct wlan_802_11_security));

	ret = libertas_set_mac_packet_filter(priv);

	LEAVE();
	return ret;
	}


	static int assoc_helper_wpa_keys(wlan_private *priv,
	struct assoc_request * assoc_req)
	{
	int ret = 0;

	ENTER();

	/* enable/Disable RSN */
	ret = libertas_prepare_and_send_command(priv,
	cmd_802_11_enable_rsn,
	cmd_act_set,
	cmd_option_waitforrsp,
	0, assoc_req);
	if (ret)
	goto out;

	ret = libertas_prepare_and_send_command(priv,
	cmd_802_11_key_material,
	cmd_act_set,
	cmd_option_waitforrsp,
	0, assoc_req);

	out:
	LEAVE();
	return ret;
	}


	static int assoc_helper_wpa_ie(wlan_private *priv,
	struct assoc_request * assoc_req)
	{
	wlan_adapter *adapter = priv->adapter;
	int ret = 0;

	ENTER();

	if (assoc_req->secinfo.WPAenabled \|\| assoc_req->secinfo.WPA2enabled) {
	memcpy(&adapter->wpa_ie, &assoc_req->wpa_ie, assoc_req->wpa_ie_len);
	adapter->wpa_ie_len = assoc_req->wpa_ie_len;
	} else {
	memset(&adapter->wpa_ie, 0, MAX_WPA_IE_LEN);
	adapter->wpa_ie_len = 0;
	}

	LEAVE();
	return ret;
	}


	static int should_deauth_infrastructure(wlan_adapter *adapter,
	struct assoc_request * assoc_req)
	{
	if (adapter->connect_status != libertas_connected)
	return 0;

	if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
	lbs_pr_debug(1, "Deauthenticating due to new SSID in "
	" configuration request.\n");
	return 1;
	}

	if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
	if (adapter->secinfo.auth_mode != assoc_req->secinfo.auth_mode) {
	lbs_pr_debug(1, "Deauthenticating due to updated security "
	"info in configuration request.\n");
	return 1;
	}
	}

	if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
	lbs_pr_debug(1, "Deauthenticating due to new BSSID in "
	" configuration request.\n");
	return 1;
	}

	/* FIXME: deal with 'auto' mode somehow */
	if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
	if (assoc_req->mode != IW_MODE_INFRA)
	return 1;
	}

	return 0;
	}


	static int should_stop_adhoc(wlan_adapter *adapter,
	struct assoc_request * assoc_req)
	{
	if (adapter->connect_status != libertas_connected)
	return 0;

	if (adapter->curbssparams.ssid.ssidlength != assoc_req->ssid.ssidlength)
	return 1;
	if (memcmp(adapter->curbssparams.ssid.ssid, assoc_req->ssid.ssid,
	adapter->curbssparams.ssid.ssidlength))
	return 1;

	/* FIXME: deal with 'auto' mode somehow */
	if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
	if (assoc_req->mode != IW_MODE_ADHOC)
	return 1;
	}

	return 0;
	}


	void wlan_association_worker(struct work_struct *work)
	{
	wlan_private *priv = container_of(work, wlan_private, assoc_work.work);
	wlan_adapter *adapter = priv->adapter;
	struct assoc_request * assoc_req = NULL;
	int ret = 0;
	int find_any_ssid = 0;

	ENTER();

	mutex_lock(&adapter->lock);
	assoc_req = adapter->assoc_req;
	adapter->assoc_req = NULL;
	mutex_unlock(&adapter->lock);

	if (!assoc_req) {
	LEAVE();
	return;
	}

	lbs_pr_debug(1, "ASSOC: starting new association request: flags = 0x%lX\n",
	assoc_req->flags);

	/* If 'any' SSID was specified, find an SSID to associate with */
	if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)
	&& !assoc_req->ssid.ssidlength)
	find_any_ssid = 1;

	/* But don't use 'any' SSID if there's a valid locked BSSID to use */
	if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
	if (memcmp(&assoc_req->bssid, bssid_any, ETH_ALEN)
	&& memcmp(&assoc_req->bssid, bssid_off, ETH_ALEN))
	find_any_ssid = 0;
	}

	if (find_any_ssid) {
	u8 new_mode;

	ret = libertas_find_best_network_SSID(priv, &assoc_req->ssid,
	assoc_req->mode, &new_mode);
	if (ret) {
	lbs_pr_debug(1, "Could not find best network\n");
	ret = -ENETUNREACH;
	goto out;
	}

	/* Ensure we switch to the mode of the AP */
	if (assoc_req->mode == IW_MODE_AUTO) {
	set_bit(ASSOC_FLAG_MODE, &assoc_req->flags);
	assoc_req->mode = new_mode;
	}
	}

	/*
	* Check if the attributes being changing require deauthentication
	* from the currently associated infrastructure access point.
	*/
	if (adapter->mode == IW_MODE_INFRA) {
	if (should_deauth_infrastructure(adapter, assoc_req)) {
	ret = libertas_send_deauthentication(priv);
	if (ret) {
	lbs_pr_debug(1, "Deauthentication due to new "
	"configuration request failed: %d\n",
	ret);
	}
	}
	} else if (adapter->mode == IW_MODE_ADHOC) {
	if (should_stop_adhoc(adapter, assoc_req)) {
	ret = libertas_stop_adhoc_network(priv);
	if (ret) {
	lbs_pr_debug(1, "Teardown of AdHoc network due to "
	"new configuration request failed: %d\n",
	ret);
	}

	}
	}

	/* Send the various configuration bits to the firmware */
	if (test_bit(ASSOC_FLAG_MODE, &assoc_req->flags)) {
	ret = assoc_helper_mode(priv, assoc_req);
	if (ret) {
	lbs_pr_debug(1, "ASSOC(:%d) mode: ret = %d\n", __LINE__, ret);
	goto out;
	}
	}

	if ( test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)
	\|\| test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags)) {
	ret = assoc_helper_wep_keys(priv, assoc_req);
	if (ret) {
	lbs_pr_debug(1, "ASSOC(:%d) wep_keys: ret = %d\n", __LINE__, ret);
	goto out;
	}
	}

	if (test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
	ret = assoc_helper_secinfo(priv, assoc_req);
	if (ret) {
	lbs_pr_debug(1, "ASSOC(:%d) secinfo: ret = %d\n", __LINE__, ret);
	goto out;
	}
	}

	if (test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
	ret = assoc_helper_wpa_ie(priv, assoc_req);
	if (ret) {
	lbs_pr_debug(1, "ASSOC(:%d) wpa_ie: ret = %d\n", __LINE__, ret);
	goto out;
	}
	}

	if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)
	\|\| test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
	ret = assoc_helper_wpa_keys(priv, assoc_req);
	if (ret) {
	lbs_pr_debug(1, "ASSOC(:%d) wpa_keys: ret = %d\n", __LINE__, ret);
	goto out;
	}
	}

	/* SSID/BSSID should be the _last_ config option set, because they
	* trigger the association attempt.
	*/
	if (test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)
	\|\| test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
	int success = 1;

	ret = assoc_helper_associate(priv, assoc_req);
	if (ret) {
	lbs_pr_debug(1, "ASSOC: association attempt unsuccessful: %d\n",
	ret);
	success = 0;
	}

	if (adapter->connect_status != libertas_connected) {
	lbs_pr_debug(1, "ASSOC: assoication attempt unsuccessful, "
	"not connected.\n");
	success = 0;
	}

	if (success) {
	lbs_pr_debug(1, "ASSOC: association attempt successful. "
	"Associated to '%s' (" MAC_FMT ")\n",
	assoc_req->ssid.ssid, MAC_ARG(assoc_req->bssid));
	libertas_prepare_and_send_command(priv,
	cmd_802_11_rssi,
	0, cmd_option_waitforrsp, 0, NULL);

	libertas_prepare_and_send_command(priv,
	cmd_802_11_get_log,
	0, cmd_option_waitforrsp, 0, NULL);
	} else {

	ret = -1;
	}
	}

	out:
	if (ret) {
	lbs_pr_debug(1, "ASSOC: reconfiguration attempt unsuccessful: %d\n",
	ret);
	}
	kfree(assoc_req);
	LEAVE();
	}


	/*
	* Caller MUST hold any necessary locks
	*/
	struct assoc_request * wlan_get_association_request(wlan_adapter *adapter)
	{
	struct assoc_request * assoc_req;

	if (!adapter->assoc_req) {
	adapter->assoc_req = kzalloc(sizeof(struct assoc_request), GFP_KERNEL);
	if (!adapter->assoc_req) {
	lbs_pr_info("Not enough memory to allocate association"
	" request!\n");
	return NULL;
	}
	}

	/* Copy current configuration attributes to the association request,
	* but don't overwrite any that are already set.
	*/
	assoc_req = adapter->assoc_req;
	if (!test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
	memcpy(&assoc_req->ssid, adapter->curbssparams.ssid.ssid,
	adapter->curbssparams.ssid.ssidlength);
	}

	if (!test_bit(ASSOC_FLAG_CHANNEL, &assoc_req->flags))
	assoc_req->channel = adapter->curbssparams.channel;

	if (!test_bit(ASSOC_FLAG_MODE, &assoc_req->flags))
	assoc_req->mode = adapter->mode;

	if (!test_bit(ASSOC_FLAG_BSSID, &assoc_req->flags)) {
	memcpy(&assoc_req->bssid, adapter->curbssparams.bssid,
	ETH_ALEN);
	}

	if (!test_bit(ASSOC_FLAG_WEP_KEYS, &assoc_req->flags)) {
	int i;
	for (i = 0; i < 4; i++) {
	memcpy(&assoc_req->wep_keys[i], &adapter->wep_keys[i],
	sizeof(struct WLAN_802_11_KEY));
	}
	}

	if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX, &assoc_req->flags))
	assoc_req->wep_tx_keyidx = adapter->wep_tx_keyidx;

	if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
	memcpy(&assoc_req->wpa_mcast_key, &adapter->wpa_mcast_key,
	sizeof(struct WLAN_802_11_KEY));
	}

	if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
	memcpy(&assoc_req->wpa_unicast_key, &adapter->wpa_unicast_key,
	sizeof(struct WLAN_802_11_KEY));
	}

	if (!test_bit(ASSOC_FLAG_SECINFO, &assoc_req->flags)) {
	memcpy(&assoc_req->secinfo, &adapter->secinfo,
	sizeof(struct wlan_802_11_security));
	}

	if (!test_bit(ASSOC_FLAG_WPA_IE, &assoc_req->flags)) {
	memcpy(&assoc_req->wpa_ie, &adapter->wpa_ie,
	MAX_WPA_IE_LEN);
	assoc_req->wpa_ie_len = adapter->wpa_ie_len;
	}

	return assoc_req;
	}