Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 600f5d90 authored by Amitkumar Karwar's avatar Amitkumar Karwar Committed by John W. Linville
Browse files

mwifiex: cleanup ioctl wait queue and abstraction layer 



1) remove mwifiex_alloc_fill_wait_queue() and
mwifiex_request_ioctl()
2) avoid dynamic allocation of wait queue
3) remove unnecessary mwifiex_error_code macros that
were used mainly by the wait queue status code
4) remove some abstraction functions
5) split mwifiex_prepare_cmd() to mwifiex_send_cmd_async()
and mwifiex_send_sync() to handle asynchronous and
synchronous commands respectively

Signed-off-by: default avatarAmitkumar Karwar <akarwar@marvell.com>
Signed-off-by: default avatarBing Zhao <bzhao@marvell.com>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent 3a9dddea

drivers/net/wireless/mwifiex/11n.c

+6 −7
Original line number Diff line number Diff line
@@ -541,9 +541,8 @@ mwifiex_cfg_tx_buf(struct mwifiex_private *priv, 
	else if (priv->adapter->curr_tx_buf_size <= MWIFIEX_TX_DATA_BUF_SIZE_8K)

		curr_tx_buf_size = MWIFIEX_TX_DATA_BUF_SIZE_8K;

	if (curr_tx_buf_size != tx_buf)

		mwifiex_prepare_cmd(priv, HostCmd_CMD_RECONFIGURE_TX_BUFF,

			HostCmd_ACT_GEN_SET, 0,

			NULL, &tx_buf);

		mwifiex_send_cmd_async(priv, HostCmd_CMD_RECONFIGURE_TX_BUFF,

				       HostCmd_ACT_GEN_SET, 0, &tx_buf);



	return;

}
@@ -694,8 +693,8 @@ int mwifiex_send_addba(struct mwifiex_private *priv, int tid, u8 *peer_mac) 
	memcpy(&add_ba_req.peer_mac_addr, peer_mac, ETH_ALEN);



	/* We don't wait for the response of this command */

	ret = mwifiex_prepare_cmd(priv, HostCmd_CMD_11N_ADDBA_REQ,

				  0, 0, NULL, &add_ba_req);

	ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_11N_ADDBA_REQ,

				     0, 0, &add_ba_req);



	return ret;

}
@@ -722,8 +721,8 @@ int mwifiex_send_delba(struct mwifiex_private *priv, int tid, u8 *peer_mac, 
	memcpy(&delba.peer_mac_addr, peer_mac, ETH_ALEN);



	/* We don't wait for the response of this command */

	ret = mwifiex_prepare_cmd(priv, HostCmd_CMD_11N_DELBA,

				  HostCmd_ACT_GEN_SET, 0, NULL, &delba);

	ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_11N_DELBA,

				     HostCmd_ACT_GEN_SET, 0, &delba);



	return ret;

}

drivers/net/wireless/mwifiex/11n_rxreorder.c

+1 −1
Original line number Diff line number Diff line
@@ -609,7 +609,7 @@ void mwifiex_11n_ba_stream_timeout(struct mwifiex_private *priv, 
	delba.del_ba_param_set |= cpu_to_le16(

		(u16) event->origninator << DELBA_INITIATOR_POS);

	delba.reason_code = cpu_to_le16(WLAN_REASON_QSTA_TIMEOUT);

	mwifiex_prepare_cmd(priv, HostCmd_CMD_11N_DELBA, 0, 0, NULL, &delba);

	mwifiex_send_cmd_async(priv, HostCmd_CMD_11N_DELBA, 0, 0, &delba);



	return;

}

drivers/net/wireless/mwifiex/README

+1 −1
Original line number Diff line number Diff line
@@ -157,7 +157,7 @@ info 
	mp_wr_bitmap = <SDIO multi-port write bitmap>

	cmd_resp_received = <0/1, no cmd response to process/response received and yet to process>

	event_received = <0/1, no event to process/event received and yet to process>

	ioctl_pending = <number of ioctl pending>

	cmd_pending = <number of cmd pending>

	tx_pending = <number of Tx packet pending>

	rx_pending = <number of Rx packet pending>

drivers/net/wireless/mwifiex/cfg80211.c

+45 −68
Original line number Diff line number Diff line
@@ -139,8 +139,16 @@ mwifiex_cfg80211_set_tx_power(struct wiphy *wiphy, 
{

	int ret = 0;

	struct mwifiex_private *priv = mwifiex_cfg80211_get_priv(wiphy);

	struct mwifiex_power_cfg power_cfg;



	ret = mwifiex_set_tx_power(priv, type, dbm);

	if (type == NL80211_TX_POWER_FIXED) {

		power_cfg.is_power_auto = 0;

		power_cfg.power_level = dbm;

	} else {

		power_cfg.is_power_auto = 1;

	}



	ret = mwifiex_set_tx_power(priv, &power_cfg);



	return ret;

}
@@ -157,13 +165,15 @@ mwifiex_cfg80211_set_power_mgmt(struct wiphy *wiphy, 
{

	int ret = 0;

	struct mwifiex_private *priv = mwifiex_cfg80211_get_priv(wiphy);

	u32 ps_mode;



	if (timeout)

		wiphy_dbg(wiphy,

			"info: ignoring the timeout value"

			" for IEEE power save\n");



	ret = mwifiex_drv_set_power(priv, enabled);

	ps_mode = enabled;

	ret = mwifiex_drv_set_power(priv, &ps_mode);



	return ret;

}
@@ -291,8 +301,8 @@ static int mwifiex_send_domain_info_cmd_fw(struct wiphy *wiphy) 


	domain_info->no_of_triplet = no_of_triplet;

	/* Send cmd to FW to set domain info */

	ret = mwifiex_prepare_cmd(priv, HostCmd_CMD_802_11D_DOMAIN_INFO,

				  HostCmd_ACT_GEN_SET, 0, NULL, NULL);

	ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_802_11D_DOMAIN_INFO,

				     HostCmd_ACT_GEN_SET, 0, NULL);

	if (ret)

		wiphy_err(wiphy, "11D: setting domain info in FW\n");
@@ -347,7 +357,6 @@ mwifiex_set_rf_channel(struct mwifiex_private *priv, 
{

	struct mwifiex_chan_freq_power cfp;

	int ret = 0;

	int status = 0;

	struct mwifiex_ds_band_cfg band_cfg;

	u32 config_bands = 0;

	struct wiphy *wiphy = priv->wdev->wiphy;
@@ -370,10 +379,9 @@ mwifiex_set_rf_channel(struct mwifiex_private *priv, 
		band_cfg.sec_chan_offset =

			mwifiex_cfg80211_channel_type_to_mwifiex_channels

			(channel_type);

		status = mwifiex_radio_ioctl_band_cfg(priv, HostCmd_ACT_GEN_SET,

						      &band_cfg);

		ret = mwifiex_set_radio_band_cfg(priv, &band_cfg);



		if (status)

		if (ret)

			return -EFAULT;

		mwifiex_send_domain_info_cmd_fw(wiphy);

	}
@@ -389,8 +397,8 @@ mwifiex_set_rf_channel(struct mwifiex_private *priv, 
	/* Convert frequency to channel */

	cfp.channel = ieee80211_frequency_to_channel(chan->center_freq);



	status = mwifiex_bss_ioctl_channel(priv, HostCmd_ACT_GEN_SET, &cfp);

	if (status)

	ret = mwifiex_bss_set_channel(priv, &cfp);

	if (ret)

		return -EFAULT;



	ret = mwifiex_drv_change_adhoc_chan(priv, cfp.channel);
@@ -422,66 +430,45 @@ mwifiex_cfg80211_set_channel(struct wiphy *wiphy, struct net_device *dev, 
/*

 * This function sets the fragmentation threshold.

 *

 * This function creates an IOCTL request, populates it accordingly

 * and issues an IOCTL.

 *

 * The fragmentation threshold value must lies between MWIFIEX_FRAG_MIN_VALUE

 * The fragmentation threshold value must lie between MWIFIEX_FRAG_MIN_VALUE

 * and MWIFIEX_FRAG_MAX_VALUE.

 */

static int

mwifiex_set_frag(struct mwifiex_private *priv, u32 frag_thr)

{

	int ret = 0;

	int status = 0;

	struct mwifiex_wait_queue *wait = NULL;

	u8 wait_option = MWIFIEX_IOCTL_WAIT;



	if (frag_thr < MWIFIEX_FRAG_MIN_VALUE

	    || frag_thr > MWIFIEX_FRAG_MAX_VALUE)

		return -EINVAL;



	wait = mwifiex_alloc_fill_wait_queue(priv, wait_option);

	if (!wait)

		return -ENOMEM;



	status = mwifiex_snmp_mib_ioctl(priv, wait, FRAG_THRESH_I,

					HostCmd_ACT_GEN_SET, &frag_thr);



	if (mwifiex_request_ioctl(priv, wait, status, wait_option))

		ret = -EFAULT;

	/* Send request to firmware */

	ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,

				    HostCmd_ACT_GEN_SET, FRAG_THRESH_I,

				    &frag_thr);



	kfree(wait);

	return ret;

}



/*

 * This function sets the RTS threshold.

 *

 * This function creates an IOCTL request, populates it accordingly

 * and issues an IOCTL.



 * The rts value must lie between MWIFIEX_RTS_MIN_VALUE

 * and MWIFIEX_RTS_MAX_VALUE.

 */

static int

mwifiex_set_rts(struct mwifiex_private *priv, u32 rts_thr)

{

	int ret = 0;

	struct mwifiex_wait_queue *wait = NULL;

	int status = 0;

	u8 wait_option = MWIFIEX_IOCTL_WAIT;



	if (rts_thr < MWIFIEX_RTS_MIN_VALUE || rts_thr > MWIFIEX_RTS_MAX_VALUE)

		rts_thr = MWIFIEX_RTS_MAX_VALUE;



	wait = mwifiex_alloc_fill_wait_queue(priv, wait_option);

	if (!wait)

		return -ENOMEM;



	status = mwifiex_snmp_mib_ioctl(priv, wait, RTS_THRESH_I,

					HostCmd_ACT_GEN_SET, &rts_thr);



	if (mwifiex_request_ioctl(priv, wait, status, wait_option))

		ret = -EFAULT;

	/* Send request to firmware */

	ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_SNMP_MIB,

				    HostCmd_ACT_GEN_SET, RTS_THRESH_I,

				    &rts_thr);



	kfree(wait);

	return ret;

}
@@ -518,7 +505,6 @@ mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy, 
{

	int ret = 0;

	struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);

	struct mwifiex_wait_queue *wait = NULL;



	if (priv->bss_mode == type) {

		wiphy_warn(wiphy, "already set to required type\n");
@@ -545,24 +531,13 @@ mwifiex_cfg80211_change_virtual_intf(struct wiphy *wiphy, 
		return -EINVAL;

	}



	wait = mwifiex_alloc_fill_wait_queue(priv, MWIFIEX_IOCTL_WAIT);

	if (!wait)

		return -ENOMEM;



	mwifiex_deauthenticate(priv, wait, NULL);

	mwifiex_deauthenticate(priv, NULL);



	priv->sec_info.authentication_mode = NL80211_AUTHTYPE_OPEN_SYSTEM;



	ret = mwifiex_prepare_cmd(priv, HostCmd_CMD_SET_BSS_MODE,

				  HostCmd_ACT_GEN_SET, 0, wait, NULL);

	if (!ret)

		ret = -EINPROGRESS;

	ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_SET_BSS_MODE,

				    HostCmd_ACT_GEN_SET, 0, NULL);



	ret = mwifiex_request_ioctl(priv, wait, ret, MWIFIEX_IOCTL_WAIT);

	if (ret)

		ret = -EFAULT;



	kfree(wait);

	return ret;

}
@@ -592,7 +567,7 @@ mwifiex_dump_station_info(struct mwifiex_private *priv, 


	/* Get signal information from the firmware */

	memset(&signal, 0, sizeof(struct mwifiex_ds_get_signal));

	if (mwifiex_get_signal_info(priv, MWIFIEX_IOCTL_WAIT, &signal)) {

	if (mwifiex_get_signal_info(priv, &signal)) {

		dev_err(priv->adapter->dev, "getting signal information\n");

		ret = -EFAULT;

	}
@@ -750,7 +725,7 @@ mwifiex_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev, 
		return -EBUSY;



	priv->disconnect = 1;

	if (mwifiex_disconnect(priv, MWIFIEX_IOCTL_WAIT, NULL))

	if (mwifiex_deauthenticate(priv, NULL))

		return -EFAULT;



	wiphy_dbg(wiphy, "info: successfully disconnected from %pM:"
@@ -838,8 +813,8 @@ static int mwifiex_inform_bss_from_scan_result(struct mwifiex_private *priv, 
	u8 element_id, element_len;



	memset(&scan_resp, 0, sizeof(scan_resp));

	if (mwifiex_get_scan_table(priv, MWIFIEX_IOCTL_WAIT, &scan_resp))

		return -EFAULT;

	scan_resp.scan_table = (u8 *) priv->adapter->scan_table;

	scan_resp.num_in_scan_table = priv->adapter->num_in_scan_table;



#define MAX_IE_BUF	2048

	ie_buf = kzalloc(MAX_IE_BUF, GFP_KERNEL);
@@ -986,7 +961,7 @@ mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len, u8 *ssid, 
	}



	/* disconnect before try to associate */

	mwifiex_disconnect(priv, MWIFIEX_IOCTL_WAIT, NULL);

	mwifiex_deauthenticate(priv, NULL);



	if (channel)

		ret = mwifiex_set_rf_channel(priv, channel,
@@ -1046,7 +1021,7 @@ mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len, u8 *ssid, 
	}

done:

	/* Do specific SSID scanning */

	if (mwifiex_request_scan(priv, MWIFIEX_IOCTL_WAIT, &req_ssid)) {

	if (mwifiex_request_scan(priv, &req_ssid)) {

		dev_err(priv->adapter->dev, "scan error\n");

		return -EFAULT;

	}
@@ -1055,8 +1030,7 @@ mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len, u8 *ssid, 
	memcpy(&ssid_bssid.ssid, &req_ssid, sizeof(struct mwifiex_802_11_ssid));



	if (mode != NL80211_IFTYPE_ADHOC) {

		if (mwifiex_find_best_bss(priv, MWIFIEX_IOCTL_WAIT,

					  &ssid_bssid))

		if (mwifiex_find_best_bss(priv, &ssid_bssid))

			return -EFAULT;

		/* Inform the BSS information to kernel, otherwise

		 * kernel will give a panic after successful assoc */
@@ -1072,7 +1046,10 @@ mwifiex_cfg80211_assoc(struct mwifiex_private *priv, size_t ssid_len, u8 *ssid, 
	/* Connect to BSS by ESSID */

	memset(&ssid_bssid.bssid, 0, ETH_ALEN);



	if (mwifiex_bss_start(priv, MWIFIEX_IOCTL_WAIT, &ssid_bssid))

	if (!netif_queue_stopped(priv->netdev))

		netif_stop_queue(priv->netdev);



	if (mwifiex_bss_start(priv, &ssid_bssid))

		return -EFAULT;



	if (mode == NL80211_IFTYPE_ADHOC) {
@@ -1176,7 +1153,7 @@ mwifiex_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev) 


	wiphy_dbg(wiphy, "info: disconnecting from essid %pM\n",

			priv->cfg_bssid);

	if (mwifiex_disconnect(priv, MWIFIEX_IOCTL_WAIT, NULL))

	if (mwifiex_deauthenticate(priv, NULL))

		return -EFAULT;



	queue_work(priv->workqueue, &priv->cfg_workqueue);

drivers/net/wireless/mwifiex/cmdevt.c

+72 −107
Original line number Diff line number Diff line
@@ -36,11 +36,12 @@ 
static void

mwifiex_init_cmd_node(struct mwifiex_private *priv,

		      struct cmd_ctrl_node *cmd_node,

		      u32 cmd_oid, void *wait_queue, void *data_buf)

		      u32 cmd_oid, void *data_buf)

{

	cmd_node->priv = priv;

	cmd_node->cmd_oid = cmd_oid;

	cmd_node->wq_buf = wait_queue;

	cmd_node->wait_q_enabled = priv->adapter->cmd_wait_q_required;

	priv->adapter->cmd_wait_q_required = false;

	cmd_node->data_buf = data_buf;

	cmd_node->cmd_skb = cmd_node->skb;

}
@@ -86,8 +87,8 @@ mwifiex_clean_cmd_node(struct mwifiex_adapter *adapter, 
{

	cmd_node->cmd_oid = 0;

	cmd_node->cmd_flag = 0;

	cmd_node->wq_buf = NULL;

	cmd_node->data_buf = NULL;

	cmd_node->wait_q_enabled = false;



	if (cmd_node->resp_skb) {

		mwifiex_recv_complete(adapter, cmd_node->resp_skb, 0);
@@ -97,30 +98,6 @@ mwifiex_clean_cmd_node(struct mwifiex_adapter *adapter, 
	return;

}



/*

 * This function returns a command node from the pending queue which

 * matches the given IOCTL request.

 */

static struct cmd_ctrl_node *

mwifiex_get_pending_ioctl_cmd(struct mwifiex_adapter *adapter,

			      struct mwifiex_wait_queue *wait_queue)

{

	unsigned long flags;

	struct cmd_ctrl_node *cmd_node;



	spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);

	list_for_each_entry(cmd_node, &adapter->cmd_pending_q, list) {

		if (cmd_node->wq_buf == wait_queue) {

			spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,

					       flags);

			return cmd_node;

		}

	}

	spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);



	return NULL;

}



/*

 * This function sends a host command to the firmware.

 *
@@ -155,7 +132,6 @@ static int mwifiex_dnld_cmd_to_fw(struct mwifiex_private *priv, 
	struct mwifiex_adapter *adapter = priv->adapter;

	int ret = 0;

	struct host_cmd_ds_command *host_cmd;

	struct mwifiex_wait_queue *wait_queue = NULL;

	uint16_t cmd_code;

	uint16_t cmd_size;

	struct timeval tstamp;
@@ -165,15 +141,13 @@ static int mwifiex_dnld_cmd_to_fw(struct mwifiex_private *priv, 
		return -1;



	host_cmd = (struct host_cmd_ds_command *) (cmd_node->cmd_skb->data);

	if (cmd_node->wq_buf)

		wait_queue = (struct mwifiex_wait_queue *) cmd_node->wq_buf;



	/* Sanity test */

	if (host_cmd == NULL || host_cmd->size == 0) {

		dev_err(adapter->dev, "DNLD_CMD: host_cmd is null"

			" or cmd size is 0, not sending\n");

		if (wait_queue)

			wait_queue->status = MWIFIEX_ERROR_CMD_DNLD_FAIL;

		if (cmd_node->wait_q_enabled)

			adapter->cmd_wait_q.status = -1;

		mwifiex_insert_cmd_to_free_q(adapter, cmd_node);

		return -1;

	}
@@ -210,8 +184,8 @@ static int mwifiex_dnld_cmd_to_fw(struct mwifiex_private *priv, 


	if (ret == -1) {

		dev_err(adapter->dev, "DNLD_CMD: host to card failed\n");

		if (wait_queue)

			wait_queue->status = MWIFIEX_ERROR_CMD_DNLD_FAIL;

		if (cmd_node->wait_q_enabled)

			adapter->cmd_wait_q.status = -1;

		mwifiex_insert_cmd_to_free_q(adapter, adapter->curr_cmd);



		spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
@@ -437,7 +411,31 @@ int mwifiex_process_event(struct mwifiex_adapter *adapter) 
}



/*

 * This function prepares a command before sending it to the firmware.

 * This function is used to send synchronous command to the firmware.

 *

 * it allocates a wait queue for the command and wait for the command

 * response.

 */

int mwifiex_send_cmd_sync(struct mwifiex_private *priv, uint16_t cmd_no,

			  u16 cmd_action, u32 cmd_oid, void *data_buf)

{

	int ret = 0;

	struct mwifiex_adapter *adapter = priv->adapter;



	adapter->cmd_wait_q_required = true;

	adapter->cmd_wait_q.condition = false;



	ret = mwifiex_send_cmd_async(priv, cmd_no, cmd_action, cmd_oid,

				     data_buf);

	if (!ret)

		ret = mwifiex_wait_queue_complete(adapter);



	return ret;

}





/*

 * This function prepares a command and asynchronously send it to the firmware.

 *

 * Preparation includes -

 *      - Sanity tests to make sure the card is still present or the FW
@@ -447,9 +445,8 @@ int mwifiex_process_event(struct mwifiex_adapter *adapter) 
 *      - Fill up the non-default parameters and buffer pointers

 *      - Add the command to pending queue

 */

int mwifiex_prepare_cmd(struct mwifiex_private *priv, uint16_t cmd_no,

			u16 cmd_action, u32 cmd_oid,

			void *wait_queue, void *data_buf)

int mwifiex_send_cmd_async(struct mwifiex_private *priv, uint16_t cmd_no,

			   u16 cmd_action, u32 cmd_oid, void *data_buf)

{

	int ret = 0;

	struct mwifiex_adapter *adapter = priv->adapter;
@@ -487,7 +484,7 @@ int mwifiex_prepare_cmd(struct mwifiex_private *priv, uint16_t cmd_no, 
	}



	/* Initialize the command node */

	mwifiex_init_cmd_node(priv, cmd_node, cmd_oid, wait_queue, data_buf);

	mwifiex_init_cmd_node(priv, cmd_node, cmd_oid, data_buf);



	if (!cmd_node->cmd_skb) {

		dev_err(adapter->dev, "PREP_CMD: no free cmd buf\n");
@@ -537,18 +534,13 @@ void 
mwifiex_insert_cmd_to_free_q(struct mwifiex_adapter *adapter,

			     struct cmd_ctrl_node *cmd_node)

{

	struct mwifiex_wait_queue *wait_queue = NULL;

	unsigned long flags;



	if (cmd_node == NULL)

		return;

	if (cmd_node->wq_buf) {

		wait_queue = (struct mwifiex_wait_queue *) cmd_node->wq_buf;

		if (wait_queue->status != MWIFIEX_ERROR_NO_ERROR)

			mwifiex_ioctl_complete(adapter, wait_queue, -1);

		else

			mwifiex_ioctl_complete(adapter, wait_queue, 0);

	}



	if (cmd_node->wait_q_enabled)

		mwifiex_complete_cmd(adapter);

	/* Clean the node */

	mwifiex_clean_cmd_node(adapter, cmd_node);
@@ -694,7 +686,6 @@ int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter) 
	uint16_t orig_cmdresp_no;

	uint16_t cmdresp_no;

	uint16_t cmdresp_result;

	struct mwifiex_wait_queue *wait_queue = NULL;

	struct timeval tstamp;

	unsigned long flags;
@@ -708,10 +699,6 @@ int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter) 
		return -1;

	}



	if (adapter->curr_cmd->wq_buf)

		wait_queue = (struct mwifiex_wait_queue *)

				adapter->curr_cmd->wq_buf;



	adapter->num_cmd_timeout = 0;



	resp = (struct host_cmd_ds_command *) adapter->curr_cmd->resp_skb->data;
@@ -766,8 +753,8 @@ int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter) 


	if (!(orig_cmdresp_no & HostCmd_RET_BIT)) {

		dev_err(adapter->dev, "CMD_RESP: invalid cmd resp\n");

		if (wait_queue)

			wait_queue->status = MWIFIEX_ERROR_FW_CMDRESP;

		if (adapter->curr_cmd->wait_q_enabled)

			adapter->cmd_wait_q.status = -1;



		mwifiex_insert_cmd_to_free_q(adapter, adapter->curr_cmd);

		spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);
@@ -783,8 +770,7 @@ int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter) 
			ret = mwifiex_ret_802_11_hs_cfg(priv, resp);

	} else {

		/* handle response */

		ret = mwifiex_process_sta_cmdresp(priv, cmdresp_no, resp,

						  wait_queue);

		ret = mwifiex_process_sta_cmdresp(priv, cmdresp_no, resp);

	}



	/* Check init command response */
@@ -799,10 +785,10 @@ int mwifiex_process_cmdresp(struct mwifiex_adapter *adapter) 
	}



	if (adapter->curr_cmd) {

		if (wait_queue && (!ret))

			wait_queue->status = MWIFIEX_ERROR_NO_ERROR;

		else if (wait_queue && (ret == -1))

			wait_queue->status = MWIFIEX_ERROR_CMD_RESP_FAIL;

		if (adapter->curr_cmd->wait_q_enabled && (!ret))

			adapter->cmd_wait_q.status = 0;

		else if (adapter->curr_cmd->wait_q_enabled && (ret == -1))

			adapter->cmd_wait_q.status = -1;



		/* Clean up and put current command back to cmd_free_q */

		mwifiex_insert_cmd_to_free_q(adapter, adapter->curr_cmd);
@@ -826,7 +812,6 @@ mwifiex_cmd_timeout_func(unsigned long function_context) 
	struct mwifiex_adapter *adapter =

		(struct mwifiex_adapter *) function_context;

	struct cmd_ctrl_node *cmd_node = NULL;

	struct mwifiex_wait_queue *wait_queue = NULL;

	struct timeval tstamp;



	adapter->num_cmd_timeout++;
@@ -836,10 +821,8 @@ mwifiex_cmd_timeout_func(unsigned long function_context) 
		return;

	}

	cmd_node = adapter->curr_cmd;

	if (cmd_node->wq_buf) {

		wait_queue = (struct mwifiex_wait_queue *) cmd_node->wq_buf;

		wait_queue->status = MWIFIEX_ERROR_CMD_TIMEOUT;

	}

	if (cmd_node->wait_q_enabled)

		adapter->cmd_wait_q.status = -ETIMEDOUT;



	if (cmd_node) {

		adapter->dbg.timeout_cmd_id =
@@ -903,18 +886,15 @@ void 
mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter *adapter)

{

	struct cmd_ctrl_node *cmd_node = NULL, *tmp_node = NULL;

	struct mwifiex_wait_queue *wait_queue = NULL;

	unsigned long flags;



	/* Cancel current cmd */

	if ((adapter->curr_cmd) && (adapter->curr_cmd->wq_buf)) {

		wait_queue =

			(struct mwifiex_wait_queue *) adapter->curr_cmd->wq_buf;

	if ((adapter->curr_cmd) && (adapter->curr_cmd->wait_q_enabled)) {

		spin_lock_irqsave(&adapter->mwifiex_cmd_lock, flags);

		adapter->curr_cmd->wq_buf = NULL;

		adapter->curr_cmd->wait_q_enabled = false;

		spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, flags);

		wait_queue->status = MWIFIEX_ERROR_CMD_CANCEL;

		mwifiex_ioctl_complete(adapter, wait_queue, -1);

		adapter->cmd_wait_q.status = -1;

		mwifiex_complete_cmd(adapter);

	}

	/* Cancel all pending command */

	spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
@@ -923,12 +903,10 @@ mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter *adapter) 
		list_del(&cmd_node->list);

		spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);



		if (cmd_node->wq_buf) {

			wait_queue =

				(struct mwifiex_wait_queue *) cmd_node->wq_buf;

			wait_queue->status = MWIFIEX_ERROR_CMD_CANCEL;

			mwifiex_ioctl_complete(adapter, wait_queue, -1);

			cmd_node->wq_buf = NULL;

		if (cmd_node->wait_q_enabled) {

			adapter->cmd_wait_q.status = -1;

			mwifiex_complete_cmd(adapter);

			cmd_node->wait_q_enabled = false;

		}

		mwifiex_insert_cmd_to_free_q(adapter, cmd_node);

		spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
@@ -942,7 +920,7 @@ mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter *adapter) 
		list_del(&cmd_node->list);

		spin_unlock_irqrestore(&adapter->scan_pending_q_lock, flags);



		cmd_node->wq_buf = NULL;

		cmd_node->wait_q_enabled = false;

		mwifiex_insert_cmd_to_free_q(adapter, cmd_node);

		spin_lock_irqsave(&adapter->scan_pending_q_lock, flags);

	}
@@ -964,8 +942,7 @@ mwifiex_cancel_all_pending_cmd(struct mwifiex_adapter *adapter) 
 * are cancelled.

 */

void

mwifiex_cancel_pending_ioctl(struct mwifiex_adapter *adapter,

			     struct mwifiex_wait_queue *wait_queue)

mwifiex_cancel_pending_ioctl(struct mwifiex_adapter *adapter)

{

	struct cmd_ctrl_node *cmd_node = NULL, *tmp_node = NULL;

	unsigned long cmd_flags;
@@ -974,46 +951,34 @@ mwifiex_cancel_pending_ioctl(struct mwifiex_adapter *adapter, 
	uint16_t cancel_scan_cmd = false;



	if ((adapter->curr_cmd) &&

	    (adapter->curr_cmd->wq_buf == wait_queue)) {

	     (adapter->curr_cmd->wait_q_enabled)) {

		spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);

		cmd_node = adapter->curr_cmd;

		cmd_node->wq_buf = NULL;

		cmd_node->wait_q_enabled = false;

		cmd_node->cmd_flag |= CMD_F_CANCELED;

		spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);

	}



	spin_lock_irqsave(&adapter->mwifiex_cmd_lock, cmd_flags);

	while (1) {

		cmd_node = mwifiex_get_pending_ioctl_cmd(adapter, wait_queue);

		if (!cmd_node)

			break;



		spin_lock_irqsave(&adapter->cmd_pending_q_lock,

				  cmd_pending_q_flags);

		list_del(&cmd_node->list);

		spin_unlock_irqrestore(&adapter->cmd_pending_q_lock,

				       cmd_pending_q_flags);



		cmd_node->wq_buf = NULL;

		mwifiex_insert_cmd_to_free_q(adapter, cmd_node);

	}

		spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);

	}



	/* Cancel all pending scan command */

	spin_lock_irqsave(&adapter->scan_pending_q_lock,

			  scan_pending_q_flags);

	list_for_each_entry_safe(cmd_node, tmp_node,

				 &adapter->scan_pending_q, list) {

		if (cmd_node->wq_buf == wait_queue) {

		list_del(&cmd_node->list);

		spin_unlock_irqrestore(&adapter->scan_pending_q_lock,

				       scan_pending_q_flags);

			cmd_node->wq_buf = NULL;

		cmd_node->wait_q_enabled = false;

		mwifiex_insert_cmd_to_free_q(adapter, cmd_node);

		spin_lock_irqsave(&adapter->scan_pending_q_lock,

				  scan_pending_q_flags);

		cancel_scan_cmd = true;

	}

	}

	spin_unlock_irqrestore(&adapter->scan_pending_q_lock,

			       scan_pending_q_flags);
@@ -1022,8 +987,8 @@ mwifiex_cancel_pending_ioctl(struct mwifiex_adapter *adapter, 
		adapter->scan_processing = false;

		spin_unlock_irqrestore(&adapter->mwifiex_cmd_lock, cmd_flags);

	}

	wait_queue->status = MWIFIEX_ERROR_CMD_CANCEL;

	mwifiex_ioctl_complete(adapter, wait_queue, -1);

	adapter->cmd_wait_q.status = -1;

	mwifiex_complete_cmd(adapter);



	return;

}