xref: /linux/drivers/net/wireless/marvell/mwifiex/sta_cmdresp.c (revision ba2290b1b7505b28912092a0976e071a447ee18c)
1 /*
2  * NXP Wireless LAN device driver: station command response handling
3  *
4  * Copyright 2011-2020 NXP
5  *
6  * This software file (the "File") is distributed by NXP
7  * under the terms of the GNU General Public License Version 2, June 1991
8  * (the "License").  You may use, redistribute and/or modify this File in
9  * accordance with the terms and conditions of the License, a copy of which
10  * is available by writing to the Free Software Foundation, Inc.,
11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
13  *
14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
17  * this warranty disclaimer.
18  */
19 
20 #include "decl.h"
21 #include "ioctl.h"
22 #include "util.h"
23 #include "fw.h"
24 #include "main.h"
25 #include "wmm.h"
26 #include "11n.h"
27 #include "11ac.h"
28 
29 
30 /*
31  * This function handles the command response error case.
32  *
33  * For scan response error, the function cancels all the pending
34  * scan commands and generates an event to inform the applications
35  * of the scan completion.
36  *
37  * For Power Save command failure, we do not retry enter PS
38  * command in case of Ad-hoc mode.
39  *
40  * For all other response errors, the current command buffer is freed
41  * and returned to the free command queue.
42  */
43 static void
44 mwifiex_process_cmdresp_error(struct mwifiex_private *priv,
45 			      struct host_cmd_ds_command *resp)
46 {
47 	struct mwifiex_adapter *adapter = priv->adapter;
48 	struct host_cmd_ds_802_11_ps_mode_enh *pm;
49 
50 	mwifiex_dbg(adapter, ERROR,
51 		    "CMD_RESP: cmd %#x error, result=%#x\n",
52 		    resp->command, resp->result);
53 
54 	if (adapter->curr_cmd->wait_q_enabled)
55 		adapter->cmd_wait_q.status = -1;
56 
57 	switch (le16_to_cpu(resp->command)) {
58 	case HostCmd_CMD_802_11_PS_MODE_ENH:
59 		pm = &resp->params.psmode_enh;
60 		mwifiex_dbg(adapter, ERROR,
61 			    "PS_MODE_ENH cmd failed: result=0x%x action=0x%X\n",
62 			    resp->result, le16_to_cpu(pm->action));
63 		/* We do not re-try enter-ps command in ad-hoc mode. */
64 		if (le16_to_cpu(pm->action) == EN_AUTO_PS &&
65 		    (le16_to_cpu(pm->params.ps_bitmap) & BITMAP_STA_PS) &&
66 		    priv->bss_mode == NL80211_IFTYPE_ADHOC)
67 			adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_CAM;
68 
69 		break;
70 	case HostCmd_CMD_802_11_SCAN:
71 	case HostCmd_CMD_802_11_SCAN_EXT:
72 		mwifiex_cancel_scan(adapter);
73 		break;
74 
75 	case HostCmd_CMD_MAC_CONTROL:
76 		break;
77 
78 	case HostCmd_CMD_SDIO_SP_RX_AGGR_CFG:
79 		mwifiex_dbg(adapter, MSG,
80 			    "SDIO RX single-port aggregation Not support\n");
81 		break;
82 
83 	default:
84 		break;
85 	}
86 	/* Handling errors here */
87 	mwifiex_recycle_cmd_node(adapter, adapter->curr_cmd);
88 
89 	spin_lock_bh(&adapter->mwifiex_cmd_lock);
90 	adapter->curr_cmd = NULL;
91 	spin_unlock_bh(&adapter->mwifiex_cmd_lock);
92 }
93 
94 /*
95  * This function handles the command response of get RSSI info.
96  *
97  * Handling includes changing the header fields into CPU format
98  * and saving the following parameters in driver -
99  *      - Last data and beacon RSSI value
100  *      - Average data and beacon RSSI value
101  *      - Last data and beacon NF value
102  *      - Average data and beacon NF value
103  *
104  * The parameters are send to the application as well, along with
105  * calculated SNR values.
106  */
107 static int mwifiex_ret_802_11_rssi_info(struct mwifiex_private *priv,
108 					struct host_cmd_ds_command *resp)
109 {
110 	struct host_cmd_ds_802_11_rssi_info_rsp *rssi_info_rsp =
111 						&resp->params.rssi_info_rsp;
112 	struct mwifiex_ds_misc_subsc_evt *subsc_evt =
113 						&priv->async_subsc_evt_storage;
114 
115 	priv->data_rssi_last = le16_to_cpu(rssi_info_rsp->data_rssi_last);
116 	priv->data_nf_last = le16_to_cpu(rssi_info_rsp->data_nf_last);
117 
118 	priv->data_rssi_avg = le16_to_cpu(rssi_info_rsp->data_rssi_avg);
119 	priv->data_nf_avg = le16_to_cpu(rssi_info_rsp->data_nf_avg);
120 
121 	priv->bcn_rssi_last = le16_to_cpu(rssi_info_rsp->bcn_rssi_last);
122 	priv->bcn_nf_last = le16_to_cpu(rssi_info_rsp->bcn_nf_last);
123 
124 	priv->bcn_rssi_avg = le16_to_cpu(rssi_info_rsp->bcn_rssi_avg);
125 	priv->bcn_nf_avg = le16_to_cpu(rssi_info_rsp->bcn_nf_avg);
126 
127 	if (priv->subsc_evt_rssi_state == EVENT_HANDLED)
128 		return 0;
129 
130 	memset(subsc_evt, 0x00, sizeof(struct mwifiex_ds_misc_subsc_evt));
131 
132 	/* Resubscribe low and high rssi events with new thresholds */
133 	subsc_evt->events = BITMASK_BCN_RSSI_LOW | BITMASK_BCN_RSSI_HIGH;
134 	subsc_evt->action = HostCmd_ACT_BITWISE_SET;
135 	if (priv->subsc_evt_rssi_state == RSSI_LOW_RECVD) {
136 		subsc_evt->bcn_l_rssi_cfg.abs_value = abs(priv->bcn_rssi_avg -
137 				priv->cqm_rssi_hyst);
138 		subsc_evt->bcn_h_rssi_cfg.abs_value = abs(priv->cqm_rssi_thold);
139 	} else if (priv->subsc_evt_rssi_state == RSSI_HIGH_RECVD) {
140 		subsc_evt->bcn_l_rssi_cfg.abs_value = abs(priv->cqm_rssi_thold);
141 		subsc_evt->bcn_h_rssi_cfg.abs_value = abs(priv->bcn_rssi_avg +
142 				priv->cqm_rssi_hyst);
143 	}
144 	subsc_evt->bcn_l_rssi_cfg.evt_freq = 1;
145 	subsc_evt->bcn_h_rssi_cfg.evt_freq = 1;
146 
147 	priv->subsc_evt_rssi_state = EVENT_HANDLED;
148 
149 	mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SUBSCRIBE_EVENT,
150 			 0, 0, subsc_evt, false);
151 
152 	return 0;
153 }
154 
155 /*
156  * This function handles the command response of set/get SNMP
157  * MIB parameters.
158  *
159  * Handling includes changing the header fields into CPU format
160  * and saving the parameter in driver.
161  *
162  * The following parameters are supported -
163  *      - Fragmentation threshold
164  *      - RTS threshold
165  *      - Short retry limit
166  */
167 static int mwifiex_ret_802_11_snmp_mib(struct mwifiex_private *priv,
168 				       struct host_cmd_ds_command *resp,
169 				       u32 *data_buf)
170 {
171 	struct host_cmd_ds_802_11_snmp_mib *smib = &resp->params.smib;
172 	u16 oid = le16_to_cpu(smib->oid);
173 	u16 query_type = le16_to_cpu(smib->query_type);
174 	u32 ul_temp;
175 
176 	mwifiex_dbg(priv->adapter, INFO,
177 		    "info: SNMP_RESP: oid value = %#x,\t"
178 		    "query_type = %#x, buf size = %#x\n",
179 		    oid, query_type, le16_to_cpu(smib->buf_size));
180 	if (query_type == HostCmd_ACT_GEN_GET) {
181 		ul_temp = get_unaligned_le16(smib->value);
182 		if (data_buf)
183 			*data_buf = ul_temp;
184 		switch (oid) {
185 		case FRAG_THRESH_I:
186 			mwifiex_dbg(priv->adapter, INFO,
187 				    "info: SNMP_RESP: FragThsd =%u\n",
188 				    ul_temp);
189 			break;
190 		case RTS_THRESH_I:
191 			mwifiex_dbg(priv->adapter, INFO,
192 				    "info: SNMP_RESP: RTSThsd =%u\n",
193 				    ul_temp);
194 			break;
195 		case SHORT_RETRY_LIM_I:
196 			mwifiex_dbg(priv->adapter, INFO,
197 				    "info: SNMP_RESP: TxRetryCount=%u\n",
198 				    ul_temp);
199 			break;
200 		case DTIM_PERIOD_I:
201 			mwifiex_dbg(priv->adapter, INFO,
202 				    "info: SNMP_RESP: DTIM period=%u\n",
203 				    ul_temp);
204 		default:
205 			break;
206 		}
207 	}
208 
209 	return 0;
210 }
211 
212 /*
213  * This function handles the command response of get log request
214  *
215  * Handling includes changing the header fields into CPU format
216  * and sending the received parameters to application.
217  */
218 static int mwifiex_ret_get_log(struct mwifiex_private *priv,
219 			       struct host_cmd_ds_command *resp,
220 			       struct mwifiex_ds_get_stats *stats)
221 {
222 	struct host_cmd_ds_802_11_get_log *get_log =
223 		&resp->params.get_log;
224 
225 	if (stats) {
226 		stats->mcast_tx_frame = le32_to_cpu(get_log->mcast_tx_frame);
227 		stats->failed = le32_to_cpu(get_log->failed);
228 		stats->retry = le32_to_cpu(get_log->retry);
229 		stats->multi_retry = le32_to_cpu(get_log->multi_retry);
230 		stats->frame_dup = le32_to_cpu(get_log->frame_dup);
231 		stats->rts_success = le32_to_cpu(get_log->rts_success);
232 		stats->rts_failure = le32_to_cpu(get_log->rts_failure);
233 		stats->ack_failure = le32_to_cpu(get_log->ack_failure);
234 		stats->rx_frag = le32_to_cpu(get_log->rx_frag);
235 		stats->mcast_rx_frame = le32_to_cpu(get_log->mcast_rx_frame);
236 		stats->fcs_error = le32_to_cpu(get_log->fcs_error);
237 		stats->tx_frame = le32_to_cpu(get_log->tx_frame);
238 		stats->wep_icv_error[0] =
239 			le32_to_cpu(get_log->wep_icv_err_cnt[0]);
240 		stats->wep_icv_error[1] =
241 			le32_to_cpu(get_log->wep_icv_err_cnt[1]);
242 		stats->wep_icv_error[2] =
243 			le32_to_cpu(get_log->wep_icv_err_cnt[2]);
244 		stats->wep_icv_error[3] =
245 			le32_to_cpu(get_log->wep_icv_err_cnt[3]);
246 		stats->bcn_rcv_cnt = le32_to_cpu(get_log->bcn_rcv_cnt);
247 		stats->bcn_miss_cnt = le32_to_cpu(get_log->bcn_miss_cnt);
248 	}
249 
250 	return 0;
251 }
252 
253 /*
254  * This function handles the command response of set/get Tx rate
255  * configurations.
256  *
257  * Handling includes changing the header fields into CPU format
258  * and saving the following parameters in driver -
259  *      - DSSS rate bitmap
260  *      - OFDM rate bitmap
261  *      - HT MCS rate bitmaps
262  *
263  * Based on the new rate bitmaps, the function re-evaluates if
264  * auto data rate has been activated. If not, it sends another
265  * query to the firmware to get the current Tx data rate.
266  */
267 static int mwifiex_ret_tx_rate_cfg(struct mwifiex_private *priv,
268 				   struct host_cmd_ds_command *resp)
269 {
270 	struct host_cmd_ds_tx_rate_cfg *rate_cfg = &resp->params.tx_rate_cfg;
271 	struct mwifiex_rate_scope *rate_scope;
272 	struct mwifiex_ie_types_header *head;
273 	u16 tlv, tlv_buf_len, tlv_buf_left;
274 	u8 *tlv_buf;
275 	u32 i;
276 
277 	tlv_buf = ((u8 *)rate_cfg) + sizeof(struct host_cmd_ds_tx_rate_cfg);
278 	tlv_buf_left = le16_to_cpu(resp->size) - S_DS_GEN - sizeof(*rate_cfg);
279 
280 	while (tlv_buf_left >= sizeof(*head)) {
281 		head = (struct mwifiex_ie_types_header *)tlv_buf;
282 		tlv = le16_to_cpu(head->type);
283 		tlv_buf_len = le16_to_cpu(head->len);
284 
285 		if (tlv_buf_left < (sizeof(*head) + tlv_buf_len))
286 			break;
287 
288 		switch (tlv) {
289 		case TLV_TYPE_RATE_SCOPE:
290 			rate_scope = (struct mwifiex_rate_scope *) tlv_buf;
291 			priv->bitmap_rates[0] =
292 				le16_to_cpu(rate_scope->hr_dsss_rate_bitmap);
293 			priv->bitmap_rates[1] =
294 				le16_to_cpu(rate_scope->ofdm_rate_bitmap);
295 			for (i = 0;
296 			     i < ARRAY_SIZE(rate_scope->ht_mcs_rate_bitmap);
297 			     i++)
298 				priv->bitmap_rates[2 + i] =
299 					le16_to_cpu(rate_scope->
300 						    ht_mcs_rate_bitmap[i]);
301 
302 			if (priv->adapter->fw_api_ver == MWIFIEX_FW_V15) {
303 				for (i = 0; i < ARRAY_SIZE(rate_scope->
304 							   vht_mcs_rate_bitmap);
305 				     i++)
306 					priv->bitmap_rates[10 + i] =
307 					    le16_to_cpu(rate_scope->
308 							vht_mcs_rate_bitmap[i]);
309 			}
310 			break;
311 			/* Add RATE_DROP tlv here */
312 		}
313 
314 		tlv_buf += (sizeof(*head) + tlv_buf_len);
315 		tlv_buf_left -= (sizeof(*head) + tlv_buf_len);
316 	}
317 
318 	priv->is_data_rate_auto = mwifiex_is_rate_auto(priv);
319 
320 	if (priv->is_data_rate_auto)
321 		priv->data_rate = 0;
322 	else
323 		return mwifiex_send_cmd(priv, HostCmd_CMD_802_11_TX_RATE_QUERY,
324 					HostCmd_ACT_GEN_GET, 0, NULL, false);
325 
326 	return 0;
327 }
328 
329 /*
330  * This function handles the command response of get Tx power level.
331  *
332  * Handling includes saving the maximum and minimum Tx power levels
333  * in driver, as well as sending the values to user.
334  */
335 static int mwifiex_get_power_level(struct mwifiex_private *priv, void *data_buf)
336 {
337 	int length, max_power = -1, min_power = -1;
338 	struct mwifiex_types_power_group *pg_tlv_hdr;
339 	struct mwifiex_power_group *pg;
340 
341 	if (!data_buf)
342 		return -1;
343 
344 	pg_tlv_hdr = (struct mwifiex_types_power_group *)((u8 *)data_buf);
345 	pg = (struct mwifiex_power_group *)
346 		((u8 *) pg_tlv_hdr + sizeof(struct mwifiex_types_power_group));
347 	length = le16_to_cpu(pg_tlv_hdr->length);
348 
349 	/* At least one structure required to update power */
350 	if (length < sizeof(struct mwifiex_power_group))
351 		return 0;
352 
353 	max_power = pg->power_max;
354 	min_power = pg->power_min;
355 	length -= sizeof(struct mwifiex_power_group);
356 
357 	while (length >= sizeof(struct mwifiex_power_group)) {
358 		pg++;
359 		if (max_power < pg->power_max)
360 			max_power = pg->power_max;
361 
362 		if (min_power > pg->power_min)
363 			min_power = pg->power_min;
364 
365 		length -= sizeof(struct mwifiex_power_group);
366 	}
367 	priv->min_tx_power_level = (u8) min_power;
368 	priv->max_tx_power_level = (u8) max_power;
369 
370 	return 0;
371 }
372 
373 /*
374  * This function handles the command response of set/get Tx power
375  * configurations.
376  *
377  * Handling includes changing the header fields into CPU format
378  * and saving the current Tx power level in driver.
379  */
380 static int mwifiex_ret_tx_power_cfg(struct mwifiex_private *priv,
381 				    struct host_cmd_ds_command *resp)
382 {
383 	struct mwifiex_adapter *adapter = priv->adapter;
384 	struct host_cmd_ds_txpwr_cfg *txp_cfg = &resp->params.txp_cfg;
385 	struct mwifiex_types_power_group *pg_tlv_hdr;
386 	struct mwifiex_power_group *pg;
387 	u16 action = le16_to_cpu(txp_cfg->action);
388 	u16 tlv_buf_left;
389 
390 	pg_tlv_hdr = (struct mwifiex_types_power_group *)
391 		((u8 *)txp_cfg +
392 		 sizeof(struct host_cmd_ds_txpwr_cfg));
393 
394 	pg = (struct mwifiex_power_group *)
395 		((u8 *)pg_tlv_hdr +
396 		 sizeof(struct mwifiex_types_power_group));
397 
398 	tlv_buf_left = le16_to_cpu(resp->size) - S_DS_GEN - sizeof(*txp_cfg);
399 	if (tlv_buf_left <
400 			le16_to_cpu(pg_tlv_hdr->length) + sizeof(*pg_tlv_hdr))
401 		return 0;
402 
403 	switch (action) {
404 	case HostCmd_ACT_GEN_GET:
405 		if (adapter->hw_status == MWIFIEX_HW_STATUS_INITIALIZING)
406 			mwifiex_get_power_level(priv, pg_tlv_hdr);
407 
408 		priv->tx_power_level = (u16) pg->power_min;
409 		break;
410 
411 	case HostCmd_ACT_GEN_SET:
412 		if (!le32_to_cpu(txp_cfg->mode))
413 			break;
414 
415 		if (pg->power_max == pg->power_min)
416 			priv->tx_power_level = (u16) pg->power_min;
417 		break;
418 	default:
419 		mwifiex_dbg(adapter, ERROR,
420 			    "CMD_RESP: unknown cmd action %d\n",
421 			    action);
422 		return 0;
423 	}
424 	mwifiex_dbg(adapter, INFO,
425 		    "info: Current TxPower Level = %d, Max Power=%d, Min Power=%d\n",
426 		    priv->tx_power_level, priv->max_tx_power_level,
427 		    priv->min_tx_power_level);
428 
429 	return 0;
430 }
431 
432 /*
433  * This function handles the command response of get RF Tx power.
434  */
435 static int mwifiex_ret_rf_tx_power(struct mwifiex_private *priv,
436 				   struct host_cmd_ds_command *resp)
437 {
438 	struct host_cmd_ds_rf_tx_pwr *txp = &resp->params.txp;
439 	u16 action = le16_to_cpu(txp->action);
440 
441 	priv->tx_power_level = le16_to_cpu(txp->cur_level);
442 
443 	if (action == HostCmd_ACT_GEN_GET) {
444 		priv->max_tx_power_level = txp->max_power;
445 		priv->min_tx_power_level = txp->min_power;
446 	}
447 
448 	mwifiex_dbg(priv->adapter, INFO,
449 		    "Current TxPower Level=%d, Max Power=%d, Min Power=%d\n",
450 		    priv->tx_power_level, priv->max_tx_power_level,
451 		    priv->min_tx_power_level);
452 
453 	return 0;
454 }
455 
456 /*
457  * This function handles the command response of set rf antenna
458  */
459 static int mwifiex_ret_rf_antenna(struct mwifiex_private *priv,
460 				  struct host_cmd_ds_command *resp)
461 {
462 	struct host_cmd_ds_rf_ant_mimo *ant_mimo = &resp->params.ant_mimo;
463 	struct host_cmd_ds_rf_ant_siso *ant_siso = &resp->params.ant_siso;
464 	struct mwifiex_adapter *adapter = priv->adapter;
465 
466 	if (adapter->hw_dev_mcs_support == HT_STREAM_2X2) {
467 		priv->tx_ant = le16_to_cpu(ant_mimo->tx_ant_mode);
468 		priv->rx_ant = le16_to_cpu(ant_mimo->rx_ant_mode);
469 		mwifiex_dbg(adapter, INFO,
470 			    "RF_ANT_RESP: Tx action = 0x%x, Tx Mode = 0x%04x\t"
471 			    "Rx action = 0x%x, Rx Mode = 0x%04x\n",
472 			    le16_to_cpu(ant_mimo->action_tx),
473 			    le16_to_cpu(ant_mimo->tx_ant_mode),
474 			    le16_to_cpu(ant_mimo->action_rx),
475 			    le16_to_cpu(ant_mimo->rx_ant_mode));
476 	} else {
477 		priv->tx_ant = le16_to_cpu(ant_siso->ant_mode);
478 		priv->rx_ant = le16_to_cpu(ant_siso->ant_mode);
479 		mwifiex_dbg(adapter, INFO,
480 			    "RF_ANT_RESP: action = 0x%x, Mode = 0x%04x\n",
481 			    le16_to_cpu(ant_siso->action),
482 			    le16_to_cpu(ant_siso->ant_mode));
483 	}
484 	return 0;
485 }
486 
487 /*
488  * This function handles the command response of set/get MAC address.
489  *
490  * Handling includes saving the MAC address in driver.
491  */
492 static int mwifiex_ret_802_11_mac_address(struct mwifiex_private *priv,
493 					  struct host_cmd_ds_command *resp)
494 {
495 	struct host_cmd_ds_802_11_mac_address *cmd_mac_addr =
496 							&resp->params.mac_addr;
497 
498 	memcpy(priv->curr_addr, cmd_mac_addr->mac_addr, ETH_ALEN);
499 
500 	mwifiex_dbg(priv->adapter, INFO,
501 		    "info: set mac address: %pM\n", priv->curr_addr);
502 
503 	return 0;
504 }
505 
506 /*
507  * This function handles the command response of set/get MAC multicast
508  * address.
509  */
510 static int mwifiex_ret_mac_multicast_adr(struct mwifiex_private *priv,
511 					 struct host_cmd_ds_command *resp)
512 {
513 	return 0;
514 }
515 
516 /*
517  * This function handles the command response of get Tx rate query.
518  *
519  * Handling includes changing the header fields into CPU format
520  * and saving the Tx rate and HT information parameters in driver.
521  *
522  * Both rate configuration and current data rate can be retrieved
523  * with this request.
524  */
525 static int mwifiex_ret_802_11_tx_rate_query(struct mwifiex_private *priv,
526 					    struct host_cmd_ds_command *resp)
527 {
528 	priv->tx_rate = resp->params.tx_rate.tx_rate;
529 	priv->tx_htinfo = resp->params.tx_rate.ht_info;
530 	if (!priv->is_data_rate_auto)
531 		priv->data_rate =
532 			mwifiex_index_to_data_rate(priv, priv->tx_rate,
533 						   priv->tx_htinfo);
534 
535 	return 0;
536 }
537 
538 /*
539  * This function handles the command response of a deauthenticate
540  * command.
541  *
542  * If the deauthenticated MAC matches the current BSS MAC, the connection
543  * state is reset.
544  */
545 static int mwifiex_ret_802_11_deauthenticate(struct mwifiex_private *priv,
546 					     struct host_cmd_ds_command *resp)
547 {
548 	struct mwifiex_adapter *adapter = priv->adapter;
549 
550 	adapter->dbg.num_cmd_deauth++;
551 	if (!memcmp(resp->params.deauth.mac_addr,
552 		    &priv->curr_bss_params.bss_descriptor.mac_address,
553 		    sizeof(resp->params.deauth.mac_addr)))
554 		mwifiex_reset_connect_state(priv, WLAN_REASON_DEAUTH_LEAVING,
555 					    false);
556 
557 	return 0;
558 }
559 
560 /*
561  * This function handles the command response of ad-hoc stop.
562  *
563  * The function resets the connection state in driver.
564  */
565 static int mwifiex_ret_802_11_ad_hoc_stop(struct mwifiex_private *priv,
566 					  struct host_cmd_ds_command *resp)
567 {
568 	mwifiex_reset_connect_state(priv, WLAN_REASON_DEAUTH_LEAVING, false);
569 	return 0;
570 }
571 
572 /*
573  * This function handles the command response of set/get v1 key material.
574  *
575  * Handling includes updating the driver parameters to reflect the
576  * changes.
577  */
578 static int mwifiex_ret_802_11_key_material_v1(struct mwifiex_private *priv,
579 					      struct host_cmd_ds_command *resp)
580 {
581 	struct host_cmd_ds_802_11_key_material *key =
582 						&resp->params.key_material;
583 	int len;
584 
585 	len = le16_to_cpu(key->key_param_set.key_len);
586 	if (len > sizeof(key->key_param_set.key))
587 		return -EINVAL;
588 
589 	if (le16_to_cpu(key->action) == HostCmd_ACT_GEN_SET) {
590 		if ((le16_to_cpu(key->key_param_set.key_info) & KEY_MCAST)) {
591 			mwifiex_dbg(priv->adapter, INFO,
592 				    "info: key: GTK is set\n");
593 			priv->wpa_is_gtk_set = true;
594 			priv->scan_block = false;
595 			priv->port_open = true;
596 		}
597 	}
598 
599 	memset(priv->aes_key.key_param_set.key, 0,
600 	       sizeof(key->key_param_set.key));
601 	priv->aes_key.key_param_set.key_len = cpu_to_le16(len);
602 	memcpy(priv->aes_key.key_param_set.key, key->key_param_set.key, len);
603 
604 	return 0;
605 }
606 
607 /*
608  * This function handles the command response of set/get v2 key material.
609  *
610  * Handling includes updating the driver parameters to reflect the
611  * changes.
612  */
613 static int mwifiex_ret_802_11_key_material_v2(struct mwifiex_private *priv,
614 					      struct host_cmd_ds_command *resp)
615 {
616 	struct host_cmd_ds_802_11_key_material_v2 *key_v2;
617 	int len;
618 
619 	key_v2 = &resp->params.key_material_v2;
620 
621 	len = le16_to_cpu(key_v2->key_param_set.key_params.aes.key_len);
622 	if (len > sizeof(key_v2->key_param_set.key_params.aes.key))
623 		return -EINVAL;
624 
625 	if (le16_to_cpu(key_v2->action) == HostCmd_ACT_GEN_SET) {
626 		if ((le16_to_cpu(key_v2->key_param_set.key_info) & KEY_MCAST)) {
627 			mwifiex_dbg(priv->adapter, INFO, "info: key: GTK is set\n");
628 			priv->wpa_is_gtk_set = true;
629 			priv->scan_block = false;
630 			priv->port_open = true;
631 		}
632 	}
633 
634 	if (key_v2->key_param_set.key_type != KEY_TYPE_ID_AES)
635 		return 0;
636 
637 	memset(priv->aes_key_v2.key_param_set.key_params.aes.key, 0,
638 	       sizeof(key_v2->key_param_set.key_params.aes.key));
639 	priv->aes_key_v2.key_param_set.key_params.aes.key_len =
640 				cpu_to_le16(len);
641 	memcpy(priv->aes_key_v2.key_param_set.key_params.aes.key,
642 	       key_v2->key_param_set.key_params.aes.key, len);
643 
644 	return 0;
645 }
646 
647 /* Wrapper function for processing response of key material command */
648 static int mwifiex_ret_802_11_key_material(struct mwifiex_private *priv,
649 					   struct host_cmd_ds_command *resp)
650 {
651 	if (priv->adapter->key_api_major_ver == KEY_API_VER_MAJOR_V2)
652 		return mwifiex_ret_802_11_key_material_v2(priv, resp);
653 	else
654 		return mwifiex_ret_802_11_key_material_v1(priv, resp);
655 }
656 
657 /*
658  * This function handles the command response of get 11d domain information.
659  */
660 static int mwifiex_ret_802_11d_domain_info(struct mwifiex_private *priv,
661 					   struct host_cmd_ds_command *resp)
662 {
663 	struct host_cmd_ds_802_11d_domain_info_rsp *domain_info =
664 		&resp->params.domain_info_resp;
665 	struct mwifiex_ietypes_domain_param_set *domain = &domain_info->domain;
666 	u16 action = le16_to_cpu(domain_info->action);
667 	u8 no_of_triplet;
668 
669 	no_of_triplet = (u8) ((le16_to_cpu(domain->header.len)
670 				- IEEE80211_COUNTRY_STRING_LEN)
671 			      / sizeof(struct ieee80211_country_ie_triplet));
672 
673 	mwifiex_dbg(priv->adapter, INFO,
674 		    "info: 11D Domain Info Resp: no_of_triplet=%d\n",
675 		    no_of_triplet);
676 
677 	if (no_of_triplet > MWIFIEX_MAX_TRIPLET_802_11D) {
678 		mwifiex_dbg(priv->adapter, FATAL,
679 			    "11D: invalid number of triplets %d returned\n",
680 			    no_of_triplet);
681 		return -1;
682 	}
683 
684 	switch (action) {
685 	case HostCmd_ACT_GEN_SET:  /* Proc Set Action */
686 		break;
687 	case HostCmd_ACT_GEN_GET:
688 		break;
689 	default:
690 		mwifiex_dbg(priv->adapter, ERROR,
691 			    "11D: invalid action:%d\n", domain_info->action);
692 		return -1;
693 	}
694 
695 	return 0;
696 }
697 
698 /*
699  * This function handles the command response of get extended version.
700  *
701  * Handling includes forming the extended version string and sending it
702  * to application.
703  */
704 static int mwifiex_ret_ver_ext(struct mwifiex_private *priv,
705 			       struct host_cmd_ds_command *resp,
706 			       struct host_cmd_ds_version_ext *version_ext)
707 {
708 	struct host_cmd_ds_version_ext *ver_ext = &resp->params.verext;
709 
710 	if (version_ext) {
711 		version_ext->version_str_sel = ver_ext->version_str_sel;
712 		memcpy(version_ext->version_str, ver_ext->version_str,
713 		       sizeof(char) * 128);
714 		memcpy(priv->version_str, ver_ext->version_str, 128);
715 	}
716 	return 0;
717 }
718 
719 /*
720  * This function handles the command response of remain on channel.
721  */
722 static int
723 mwifiex_ret_remain_on_chan(struct mwifiex_private *priv,
724 			   struct host_cmd_ds_command *resp,
725 			   struct host_cmd_ds_remain_on_chan *roc_cfg)
726 {
727 	struct host_cmd_ds_remain_on_chan *resp_cfg = &resp->params.roc_cfg;
728 
729 	if (roc_cfg)
730 		memcpy(roc_cfg, resp_cfg, sizeof(*roc_cfg));
731 
732 	return 0;
733 }
734 
735 /*
736  * This function handles the command response of P2P mode cfg.
737  */
738 static int
739 mwifiex_ret_p2p_mode_cfg(struct mwifiex_private *priv,
740 			 struct host_cmd_ds_command *resp,
741 			 void *data_buf)
742 {
743 	struct host_cmd_ds_p2p_mode_cfg *mode_cfg = &resp->params.mode_cfg;
744 
745 	if (data_buf)
746 		put_unaligned_le16(le16_to_cpu(mode_cfg->mode), data_buf);
747 
748 	return 0;
749 }
750 
751 /* This function handles the command response of mem_access command
752  */
753 static int
754 mwifiex_ret_mem_access(struct mwifiex_private *priv,
755 		       struct host_cmd_ds_command *resp, void *pioctl_buf)
756 {
757 	struct host_cmd_ds_mem_access *mem = (void *)&resp->params.mem;
758 
759 	priv->mem_rw.addr = le32_to_cpu(mem->addr);
760 	priv->mem_rw.value = le32_to_cpu(mem->value);
761 
762 	return 0;
763 }
764 /*
765  * This function handles the command response of register access.
766  *
767  * The register value and offset are returned to the user. For EEPROM
768  * access, the byte count is also returned.
769  */
770 static int mwifiex_ret_reg_access(u16 type, struct host_cmd_ds_command *resp,
771 				  void *data_buf)
772 {
773 	struct mwifiex_ds_reg_rw *reg_rw;
774 	struct mwifiex_ds_read_eeprom *eeprom;
775 	union reg {
776 		struct host_cmd_ds_mac_reg_access *mac;
777 		struct host_cmd_ds_bbp_reg_access *bbp;
778 		struct host_cmd_ds_rf_reg_access *rf;
779 		struct host_cmd_ds_pmic_reg_access *pmic;
780 		struct host_cmd_ds_802_11_eeprom_access *eeprom;
781 	} r;
782 
783 	if (!data_buf)
784 		return 0;
785 
786 	reg_rw = data_buf;
787 	eeprom = data_buf;
788 	switch (type) {
789 	case HostCmd_CMD_MAC_REG_ACCESS:
790 		r.mac = &resp->params.mac_reg;
791 		reg_rw->offset = (u32) le16_to_cpu(r.mac->offset);
792 		reg_rw->value = le32_to_cpu(r.mac->value);
793 		break;
794 	case HostCmd_CMD_BBP_REG_ACCESS:
795 		r.bbp = &resp->params.bbp_reg;
796 		reg_rw->offset = (u32) le16_to_cpu(r.bbp->offset);
797 		reg_rw->value = (u32) r.bbp->value;
798 		break;
799 
800 	case HostCmd_CMD_RF_REG_ACCESS:
801 		r.rf = &resp->params.rf_reg;
802 		reg_rw->offset = (u32) le16_to_cpu(r.rf->offset);
803 		reg_rw->value = (u32) r.bbp->value;
804 		break;
805 	case HostCmd_CMD_PMIC_REG_ACCESS:
806 		r.pmic = &resp->params.pmic_reg;
807 		reg_rw->offset = (u32) le16_to_cpu(r.pmic->offset);
808 		reg_rw->value = (u32) r.pmic->value;
809 		break;
810 	case HostCmd_CMD_CAU_REG_ACCESS:
811 		r.rf = &resp->params.rf_reg;
812 		reg_rw->offset = (u32) le16_to_cpu(r.rf->offset);
813 		reg_rw->value = (u32) r.rf->value;
814 		break;
815 	case HostCmd_CMD_802_11_EEPROM_ACCESS:
816 		r.eeprom = &resp->params.eeprom;
817 		pr_debug("info: EEPROM read len=%x\n",
818 				le16_to_cpu(r.eeprom->byte_count));
819 		if (eeprom->byte_count < le16_to_cpu(r.eeprom->byte_count)) {
820 			eeprom->byte_count = 0;
821 			pr_debug("info: EEPROM read length is too big\n");
822 			return -1;
823 		}
824 		eeprom->offset = le16_to_cpu(r.eeprom->offset);
825 		eeprom->byte_count = le16_to_cpu(r.eeprom->byte_count);
826 		if (eeprom->byte_count > 0)
827 			memcpy(&eeprom->value, &r.eeprom->value,
828 			       min((u16)MAX_EEPROM_DATA, eeprom->byte_count));
829 		break;
830 	default:
831 		return -1;
832 	}
833 	return 0;
834 }
835 
836 /*
837  * This function handles the command response of get IBSS coalescing status.
838  *
839  * If the received BSSID is different than the current one, the current BSSID,
840  * beacon interval, ATIM window and ERP information are updated, along with
841  * changing the ad-hoc state accordingly.
842  */
843 static int mwifiex_ret_ibss_coalescing_status(struct mwifiex_private *priv,
844 					      struct host_cmd_ds_command *resp)
845 {
846 	struct host_cmd_ds_802_11_ibss_status *ibss_coal_resp =
847 					&(resp->params.ibss_coalescing);
848 
849 	if (le16_to_cpu(ibss_coal_resp->action) == HostCmd_ACT_GEN_SET)
850 		return 0;
851 
852 	mwifiex_dbg(priv->adapter, INFO,
853 		    "info: new BSSID %pM\n", ibss_coal_resp->bssid);
854 
855 	/* If rsp has NULL BSSID, Just return..... No Action */
856 	if (is_zero_ether_addr(ibss_coal_resp->bssid)) {
857 		mwifiex_dbg(priv->adapter, FATAL, "new BSSID is NULL\n");
858 		return 0;
859 	}
860 
861 	/* If BSSID is diff, modify current BSS parameters */
862 	if (!ether_addr_equal(priv->curr_bss_params.bss_descriptor.mac_address, ibss_coal_resp->bssid)) {
863 		/* BSSID */
864 		memcpy(priv->curr_bss_params.bss_descriptor.mac_address,
865 		       ibss_coal_resp->bssid, ETH_ALEN);
866 
867 		/* Beacon Interval */
868 		priv->curr_bss_params.bss_descriptor.beacon_period
869 			= le16_to_cpu(ibss_coal_resp->beacon_interval);
870 
871 		/* ERP Information */
872 		priv->curr_bss_params.bss_descriptor.erp_flags =
873 			(u8) le16_to_cpu(ibss_coal_resp->use_g_rate_protect);
874 
875 		priv->adhoc_state = ADHOC_COALESCED;
876 	}
877 
878 	return 0;
879 }
880 static int mwifiex_ret_tdls_oper(struct mwifiex_private *priv,
881 				 struct host_cmd_ds_command *resp)
882 {
883 	struct host_cmd_ds_tdls_oper *cmd_tdls_oper = &resp->params.tdls_oper;
884 	u16 reason = le16_to_cpu(cmd_tdls_oper->reason);
885 	u16 action = le16_to_cpu(cmd_tdls_oper->tdls_action);
886 	struct mwifiex_sta_node *node =
887 			   mwifiex_get_sta_entry(priv, cmd_tdls_oper->peer_mac);
888 
889 	switch (action) {
890 	case ACT_TDLS_DELETE:
891 		if (reason) {
892 			if (!node || reason == TDLS_ERR_LINK_NONEXISTENT)
893 				mwifiex_dbg(priv->adapter, MSG,
894 					    "TDLS link delete for %pM failed: reason %d\n",
895 					    cmd_tdls_oper->peer_mac, reason);
896 			else
897 				mwifiex_dbg(priv->adapter, ERROR,
898 					    "TDLS link delete for %pM failed: reason %d\n",
899 					    cmd_tdls_oper->peer_mac, reason);
900 		} else {
901 			mwifiex_dbg(priv->adapter, MSG,
902 				    "TDLS link delete for %pM successful\n",
903 				    cmd_tdls_oper->peer_mac);
904 		}
905 		break;
906 	case ACT_TDLS_CREATE:
907 		if (reason) {
908 			mwifiex_dbg(priv->adapter, ERROR,
909 				    "TDLS link creation for %pM failed: reason %d",
910 				    cmd_tdls_oper->peer_mac, reason);
911 			if (node && reason != TDLS_ERR_LINK_EXISTS)
912 				node->tdls_status = TDLS_SETUP_FAILURE;
913 		} else {
914 			mwifiex_dbg(priv->adapter, MSG,
915 				    "TDLS link creation for %pM successful",
916 				    cmd_tdls_oper->peer_mac);
917 		}
918 		break;
919 	case ACT_TDLS_CONFIG:
920 		if (reason) {
921 			mwifiex_dbg(priv->adapter, ERROR,
922 				    "TDLS link config for %pM failed, reason %d\n",
923 				    cmd_tdls_oper->peer_mac, reason);
924 			if (node)
925 				node->tdls_status = TDLS_SETUP_FAILURE;
926 		} else {
927 			mwifiex_dbg(priv->adapter, MSG,
928 				    "TDLS link config for %pM successful\n",
929 				    cmd_tdls_oper->peer_mac);
930 		}
931 		break;
932 	default:
933 		mwifiex_dbg(priv->adapter, ERROR,
934 			    "Unknown TDLS command action response %d", action);
935 		return -1;
936 	}
937 
938 	return 0;
939 }
940 /*
941  * This function handles the command response for subscribe event command.
942  */
943 static int mwifiex_ret_subsc_evt(struct mwifiex_private *priv,
944 				 struct host_cmd_ds_command *resp)
945 {
946 	struct host_cmd_ds_802_11_subsc_evt *cmd_sub_event =
947 		&resp->params.subsc_evt;
948 
949 	/* For every subscribe event command (Get/Set/Clear), FW reports the
950 	 * current set of subscribed events*/
951 	mwifiex_dbg(priv->adapter, EVENT,
952 		    "Bitmap of currently subscribed events: %16x\n",
953 		    le16_to_cpu(cmd_sub_event->events));
954 
955 	return 0;
956 }
957 
958 static int mwifiex_ret_uap_sta_list(struct mwifiex_private *priv,
959 				    struct host_cmd_ds_command *resp)
960 {
961 	struct host_cmd_ds_sta_list *sta_list =
962 		&resp->params.sta_list;
963 	struct mwifiex_ie_types_sta_info *sta_info = (void *)&sta_list->tlv;
964 	int i;
965 	struct mwifiex_sta_node *sta_node;
966 
967 	for (i = 0; i < (le16_to_cpu(sta_list->sta_count)); i++) {
968 		sta_node = mwifiex_get_sta_entry(priv, sta_info->mac);
969 		if (unlikely(!sta_node))
970 			continue;
971 
972 		sta_node->stats.rssi = sta_info->rssi;
973 		sta_info++;
974 	}
975 
976 	return 0;
977 }
978 
979 /* This function handles the command response of set_cfg_data */
980 static int mwifiex_ret_cfg_data(struct mwifiex_private *priv,
981 				struct host_cmd_ds_command *resp)
982 {
983 	if (resp->result != HostCmd_RESULT_OK) {
984 		mwifiex_dbg(priv->adapter, ERROR, "Cal data cmd resp failed\n");
985 		return -1;
986 	}
987 
988 	return 0;
989 }
990 
991 /** This Function handles the command response of sdio rx aggr */
992 static int mwifiex_ret_sdio_rx_aggr_cfg(struct mwifiex_private *priv,
993 					struct host_cmd_ds_command *resp)
994 {
995 	struct mwifiex_adapter *adapter = priv->adapter;
996 	struct host_cmd_sdio_sp_rx_aggr_cfg *cfg =
997 				&resp->params.sdio_rx_aggr_cfg;
998 
999 	adapter->sdio_rx_aggr_enable = cfg->enable;
1000 	adapter->sdio_rx_block_size = le16_to_cpu(cfg->block_size);
1001 
1002 	return 0;
1003 }
1004 
1005 static int mwifiex_ret_robust_coex(struct mwifiex_private *priv,
1006 				   struct host_cmd_ds_command *resp,
1007 				   bool *is_timeshare)
1008 {
1009 	struct host_cmd_ds_robust_coex *coex = &resp->params.coex;
1010 	struct mwifiex_ie_types_robust_coex *coex_tlv;
1011 	u16 action = le16_to_cpu(coex->action);
1012 	u32 mode;
1013 
1014 	coex_tlv = (struct mwifiex_ie_types_robust_coex
1015 		    *)((u8 *)coex + sizeof(struct host_cmd_ds_robust_coex));
1016 	if (action == HostCmd_ACT_GEN_GET) {
1017 		mode = le32_to_cpu(coex_tlv->mode);
1018 		if (mode == MWIFIEX_COEX_MODE_TIMESHARE)
1019 			*is_timeshare = true;
1020 		else
1021 			*is_timeshare = false;
1022 	}
1023 
1024 	return 0;
1025 }
1026 
1027 static struct ieee80211_regdomain *
1028 mwifiex_create_custom_regdomain(struct mwifiex_private *priv,
1029 				u8 *buf, u16 buf_len)
1030 {
1031 	u16 num_chan = buf_len / 2;
1032 	struct ieee80211_regdomain *regd;
1033 	struct ieee80211_reg_rule *rule;
1034 	bool new_rule;
1035 	int idx, freq, prev_freq = 0;
1036 	u32 bw, prev_bw = 0;
1037 	u8 chflags, prev_chflags = 0, valid_rules = 0;
1038 
1039 	if (WARN_ON_ONCE(num_chan > NL80211_MAX_SUPP_REG_RULES))
1040 		return ERR_PTR(-EINVAL);
1041 
1042 	regd = kzalloc(struct_size(regd, reg_rules, num_chan), GFP_KERNEL);
1043 	if (!regd)
1044 		return ERR_PTR(-ENOMEM);
1045 
1046 	for (idx = 0; idx < num_chan; idx++) {
1047 		u8 chan;
1048 		enum nl80211_band band;
1049 
1050 		chan = *buf++;
1051 		if (!chan) {
1052 			kfree(regd);
1053 			return NULL;
1054 		}
1055 		chflags = *buf++;
1056 		band = (chan <= 14) ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
1057 		freq = ieee80211_channel_to_frequency(chan, band);
1058 		new_rule = false;
1059 
1060 		if (chflags & MWIFIEX_CHANNEL_DISABLED)
1061 			continue;
1062 
1063 		if (band == NL80211_BAND_5GHZ) {
1064 			if (!(chflags & MWIFIEX_CHANNEL_NOHT80))
1065 				bw = MHZ_TO_KHZ(80);
1066 			else if (!(chflags & MWIFIEX_CHANNEL_NOHT40))
1067 				bw = MHZ_TO_KHZ(40);
1068 			else
1069 				bw = MHZ_TO_KHZ(20);
1070 		} else {
1071 			if (!(chflags & MWIFIEX_CHANNEL_NOHT40))
1072 				bw = MHZ_TO_KHZ(40);
1073 			else
1074 				bw = MHZ_TO_KHZ(20);
1075 		}
1076 
1077 		if (idx == 0 || prev_chflags != chflags || prev_bw != bw ||
1078 		    freq - prev_freq > 20) {
1079 			valid_rules++;
1080 			new_rule = true;
1081 		}
1082 
1083 		rule = &regd->reg_rules[valid_rules - 1];
1084 
1085 		rule->freq_range.end_freq_khz = MHZ_TO_KHZ(freq + 10);
1086 
1087 		prev_chflags = chflags;
1088 		prev_freq = freq;
1089 		prev_bw = bw;
1090 
1091 		if (!new_rule)
1092 			continue;
1093 
1094 		rule->freq_range.start_freq_khz = MHZ_TO_KHZ(freq - 10);
1095 		rule->power_rule.max_eirp = DBM_TO_MBM(19);
1096 
1097 		if (chflags & MWIFIEX_CHANNEL_PASSIVE)
1098 			rule->flags = NL80211_RRF_NO_IR;
1099 
1100 		if (chflags & MWIFIEX_CHANNEL_DFS)
1101 			rule->flags = NL80211_RRF_DFS;
1102 
1103 		rule->freq_range.max_bandwidth_khz = bw;
1104 	}
1105 
1106 	regd->n_reg_rules = valid_rules;
1107 	regd->alpha2[0] = '9';
1108 	regd->alpha2[1] = '9';
1109 
1110 	return regd;
1111 }
1112 
1113 static int mwifiex_ret_chan_region_cfg(struct mwifiex_private *priv,
1114 				       struct host_cmd_ds_command *resp)
1115 {
1116 	struct host_cmd_ds_chan_region_cfg *reg = &resp->params.reg_cfg;
1117 	u16 action = le16_to_cpu(reg->action);
1118 	u16 tlv, tlv_buf_len, tlv_buf_left;
1119 	struct mwifiex_ie_types_header *head;
1120 	struct ieee80211_regdomain *regd;
1121 	u8 *tlv_buf;
1122 
1123 	if (action != HostCmd_ACT_GEN_GET)
1124 		return 0;
1125 
1126 	tlv_buf = (u8 *)reg + sizeof(*reg);
1127 	tlv_buf_left = le16_to_cpu(resp->size) - S_DS_GEN - sizeof(*reg);
1128 
1129 	while (tlv_buf_left >= sizeof(*head)) {
1130 		head = (struct mwifiex_ie_types_header *)tlv_buf;
1131 		tlv = le16_to_cpu(head->type);
1132 		tlv_buf_len = le16_to_cpu(head->len);
1133 
1134 		if (tlv_buf_left < (sizeof(*head) + tlv_buf_len))
1135 			break;
1136 
1137 		switch (tlv) {
1138 		case TLV_TYPE_CHAN_ATTR_CFG:
1139 			mwifiex_dbg_dump(priv->adapter, CMD_D, "CHAN:",
1140 					 (u8 *)head + sizeof(*head),
1141 					 tlv_buf_len);
1142 			regd = mwifiex_create_custom_regdomain(priv,
1143 				(u8 *)head + sizeof(*head), tlv_buf_len);
1144 			if (!IS_ERR(regd))
1145 				priv->adapter->regd = regd;
1146 			break;
1147 		}
1148 
1149 		tlv_buf += (sizeof(*head) + tlv_buf_len);
1150 		tlv_buf_left -= (sizeof(*head) + tlv_buf_len);
1151 	}
1152 
1153 	return 0;
1154 }
1155 
1156 static int mwifiex_ret_pkt_aggr_ctrl(struct mwifiex_private *priv,
1157 				     struct host_cmd_ds_command *resp)
1158 {
1159 	struct host_cmd_ds_pkt_aggr_ctrl *pkt_aggr_ctrl =
1160 					&resp->params.pkt_aggr_ctrl;
1161 	struct mwifiex_adapter *adapter = priv->adapter;
1162 
1163 	adapter->bus_aggr.enable = le16_to_cpu(pkt_aggr_ctrl->enable);
1164 	if (adapter->bus_aggr.enable)
1165 		adapter->intf_hdr_len = INTF_HEADER_LEN;
1166 	adapter->bus_aggr.mode = MWIFIEX_BUS_AGGR_MODE_LEN_V2;
1167 	adapter->bus_aggr.tx_aggr_max_size =
1168 				le16_to_cpu(pkt_aggr_ctrl->tx_aggr_max_size);
1169 	adapter->bus_aggr.tx_aggr_max_num =
1170 				le16_to_cpu(pkt_aggr_ctrl->tx_aggr_max_num);
1171 	adapter->bus_aggr.tx_aggr_align =
1172 				le16_to_cpu(pkt_aggr_ctrl->tx_aggr_align);
1173 
1174 	return 0;
1175 }
1176 
1177 static int mwifiex_ret_get_chan_info(struct mwifiex_private *priv,
1178 				     struct host_cmd_ds_command *resp,
1179 				     struct mwifiex_channel_band *channel_band)
1180 {
1181 	struct host_cmd_ds_sta_configure *sta_cfg_cmd = &resp->params.sta_cfg;
1182 	struct host_cmd_tlv_channel_band *tlv_band_channel;
1183 
1184 	tlv_band_channel =
1185 	(struct host_cmd_tlv_channel_band *)sta_cfg_cmd->tlv_buffer;
1186 	memcpy(&channel_band->band_config, &tlv_band_channel->band_config,
1187 	       sizeof(struct mwifiex_band_config));
1188 	channel_band->channel = tlv_band_channel->channel;
1189 
1190 	return 0;
1191 }
1192 
1193 /*
1194  * This function handles the command responses.
1195  *
1196  * This is a generic function, which calls command specific
1197  * response handlers based on the command ID.
1198  */
1199 int mwifiex_process_sta_cmdresp(struct mwifiex_private *priv, u16 cmdresp_no,
1200 				struct host_cmd_ds_command *resp)
1201 {
1202 	int ret = 0;
1203 	struct mwifiex_adapter *adapter = priv->adapter;
1204 	void *data_buf = adapter->curr_cmd->data_buf;
1205 
1206 	/* If the command is not successful, cleanup and return failure */
1207 	if (resp->result != HostCmd_RESULT_OK) {
1208 		mwifiex_process_cmdresp_error(priv, resp);
1209 		return -1;
1210 	}
1211 	/* Command successful, handle response */
1212 	switch (cmdresp_no) {
1213 	case HostCmd_CMD_GET_HW_SPEC:
1214 		ret = mwifiex_ret_get_hw_spec(priv, resp);
1215 		break;
1216 	case HostCmd_CMD_CFG_DATA:
1217 		ret = mwifiex_ret_cfg_data(priv, resp);
1218 		break;
1219 	case HostCmd_CMD_MAC_CONTROL:
1220 		break;
1221 	case HostCmd_CMD_802_11_MAC_ADDRESS:
1222 		ret = mwifiex_ret_802_11_mac_address(priv, resp);
1223 		break;
1224 	case HostCmd_CMD_MAC_MULTICAST_ADR:
1225 		ret = mwifiex_ret_mac_multicast_adr(priv, resp);
1226 		break;
1227 	case HostCmd_CMD_TX_RATE_CFG:
1228 		ret = mwifiex_ret_tx_rate_cfg(priv, resp);
1229 		break;
1230 	case HostCmd_CMD_802_11_SCAN:
1231 		ret = mwifiex_ret_802_11_scan(priv, resp);
1232 		adapter->curr_cmd->wait_q_enabled = false;
1233 		break;
1234 	case HostCmd_CMD_802_11_SCAN_EXT:
1235 		ret = mwifiex_ret_802_11_scan_ext(priv, resp);
1236 		adapter->curr_cmd->wait_q_enabled = false;
1237 		break;
1238 	case HostCmd_CMD_802_11_BG_SCAN_QUERY:
1239 		ret = mwifiex_ret_802_11_scan(priv, resp);
1240 		cfg80211_sched_scan_results(priv->wdev.wiphy, 0);
1241 		mwifiex_dbg(adapter, CMD,
1242 			    "info: CMD_RESP: BG_SCAN result is ready!\n");
1243 		break;
1244 	case HostCmd_CMD_802_11_BG_SCAN_CONFIG:
1245 		break;
1246 	case HostCmd_CMD_TXPWR_CFG:
1247 		ret = mwifiex_ret_tx_power_cfg(priv, resp);
1248 		break;
1249 	case HostCmd_CMD_RF_TX_PWR:
1250 		ret = mwifiex_ret_rf_tx_power(priv, resp);
1251 		break;
1252 	case HostCmd_CMD_RF_ANTENNA:
1253 		ret = mwifiex_ret_rf_antenna(priv, resp);
1254 		break;
1255 	case HostCmd_CMD_802_11_PS_MODE_ENH:
1256 		ret = mwifiex_ret_enh_power_mode(priv, resp, data_buf);
1257 		break;
1258 	case HostCmd_CMD_802_11_HS_CFG_ENH:
1259 		ret = mwifiex_ret_802_11_hs_cfg(priv, resp);
1260 		break;
1261 	case HostCmd_CMD_802_11_ASSOCIATE:
1262 		ret = mwifiex_ret_802_11_associate(priv, resp);
1263 		break;
1264 	case HostCmd_CMD_802_11_DEAUTHENTICATE:
1265 		ret = mwifiex_ret_802_11_deauthenticate(priv, resp);
1266 		break;
1267 	case HostCmd_CMD_802_11_AD_HOC_START:
1268 	case HostCmd_CMD_802_11_AD_HOC_JOIN:
1269 		ret = mwifiex_ret_802_11_ad_hoc(priv, resp);
1270 		break;
1271 	case HostCmd_CMD_802_11_AD_HOC_STOP:
1272 		ret = mwifiex_ret_802_11_ad_hoc_stop(priv, resp);
1273 		break;
1274 	case HostCmd_CMD_802_11_GET_LOG:
1275 		ret = mwifiex_ret_get_log(priv, resp, data_buf);
1276 		break;
1277 	case HostCmd_CMD_RSSI_INFO:
1278 		ret = mwifiex_ret_802_11_rssi_info(priv, resp);
1279 		break;
1280 	case HostCmd_CMD_802_11_SNMP_MIB:
1281 		ret = mwifiex_ret_802_11_snmp_mib(priv, resp, data_buf);
1282 		break;
1283 	case HostCmd_CMD_802_11_TX_RATE_QUERY:
1284 		ret = mwifiex_ret_802_11_tx_rate_query(priv, resp);
1285 		break;
1286 	case HostCmd_CMD_VERSION_EXT:
1287 		ret = mwifiex_ret_ver_ext(priv, resp, data_buf);
1288 		break;
1289 	case HostCmd_CMD_REMAIN_ON_CHAN:
1290 		ret = mwifiex_ret_remain_on_chan(priv, resp, data_buf);
1291 		break;
1292 	case HostCmd_CMD_11AC_CFG:
1293 		break;
1294 	case HostCmd_CMD_PACKET_AGGR_CTRL:
1295 		ret = mwifiex_ret_pkt_aggr_ctrl(priv, resp);
1296 		break;
1297 	case HostCmd_CMD_P2P_MODE_CFG:
1298 		ret = mwifiex_ret_p2p_mode_cfg(priv, resp, data_buf);
1299 		break;
1300 	case HostCmd_CMD_MGMT_FRAME_REG:
1301 	case HostCmd_CMD_FUNC_INIT:
1302 	case HostCmd_CMD_FUNC_SHUTDOWN:
1303 		break;
1304 	case HostCmd_CMD_802_11_KEY_MATERIAL:
1305 		ret = mwifiex_ret_802_11_key_material(priv, resp);
1306 		break;
1307 	case HostCmd_CMD_802_11D_DOMAIN_INFO:
1308 		ret = mwifiex_ret_802_11d_domain_info(priv, resp);
1309 		break;
1310 	case HostCmd_CMD_11N_ADDBA_REQ:
1311 		ret = mwifiex_ret_11n_addba_req(priv, resp);
1312 		break;
1313 	case HostCmd_CMD_11N_DELBA:
1314 		ret = mwifiex_ret_11n_delba(priv, resp);
1315 		break;
1316 	case HostCmd_CMD_11N_ADDBA_RSP:
1317 		ret = mwifiex_ret_11n_addba_resp(priv, resp);
1318 		break;
1319 	case HostCmd_CMD_RECONFIGURE_TX_BUFF:
1320 		if (0xffff == (u16)le16_to_cpu(resp->params.tx_buf.buff_size)) {
1321 			if (adapter->iface_type == MWIFIEX_USB &&
1322 			    adapter->usb_mc_setup) {
1323 				if (adapter->if_ops.multi_port_resync)
1324 					adapter->if_ops.
1325 						multi_port_resync(adapter);
1326 				adapter->usb_mc_setup = false;
1327 				adapter->tx_lock_flag = false;
1328 			}
1329 			break;
1330 		}
1331 		adapter->tx_buf_size = (u16) le16_to_cpu(resp->params.
1332 							     tx_buf.buff_size);
1333 		adapter->tx_buf_size = (adapter->tx_buf_size
1334 					/ MWIFIEX_SDIO_BLOCK_SIZE)
1335 				       * MWIFIEX_SDIO_BLOCK_SIZE;
1336 		adapter->curr_tx_buf_size = adapter->tx_buf_size;
1337 		mwifiex_dbg(adapter, CMD, "cmd: curr_tx_buf_size=%d\n",
1338 			    adapter->curr_tx_buf_size);
1339 
1340 		if (adapter->if_ops.update_mp_end_port)
1341 			adapter->if_ops.update_mp_end_port(adapter,
1342 				le16_to_cpu(resp->params.tx_buf.mp_end_port));
1343 		break;
1344 	case HostCmd_CMD_AMSDU_AGGR_CTRL:
1345 		break;
1346 	case HostCmd_CMD_WMM_GET_STATUS:
1347 		ret = mwifiex_ret_wmm_get_status(priv, resp);
1348 		break;
1349 	case HostCmd_CMD_802_11_IBSS_COALESCING_STATUS:
1350 		ret = mwifiex_ret_ibss_coalescing_status(priv, resp);
1351 		break;
1352 	case HostCmd_CMD_MEM_ACCESS:
1353 		ret = mwifiex_ret_mem_access(priv, resp, data_buf);
1354 		break;
1355 	case HostCmd_CMD_MAC_REG_ACCESS:
1356 	case HostCmd_CMD_BBP_REG_ACCESS:
1357 	case HostCmd_CMD_RF_REG_ACCESS:
1358 	case HostCmd_CMD_PMIC_REG_ACCESS:
1359 	case HostCmd_CMD_CAU_REG_ACCESS:
1360 	case HostCmd_CMD_802_11_EEPROM_ACCESS:
1361 		ret = mwifiex_ret_reg_access(cmdresp_no, resp, data_buf);
1362 		break;
1363 	case HostCmd_CMD_SET_BSS_MODE:
1364 		break;
1365 	case HostCmd_CMD_11N_CFG:
1366 		break;
1367 	case HostCmd_CMD_PCIE_DESC_DETAILS:
1368 		break;
1369 	case HostCmd_CMD_802_11_SUBSCRIBE_EVENT:
1370 		ret = mwifiex_ret_subsc_evt(priv, resp);
1371 		break;
1372 	case HostCmd_CMD_UAP_SYS_CONFIG:
1373 		break;
1374 	case HOST_CMD_APCMD_STA_LIST:
1375 		ret = mwifiex_ret_uap_sta_list(priv, resp);
1376 		break;
1377 	case HostCmd_CMD_UAP_BSS_START:
1378 		adapter->tx_lock_flag = false;
1379 		adapter->pps_uapsd_mode = false;
1380 		adapter->delay_null_pkt = false;
1381 		priv->bss_started = 1;
1382 		break;
1383 	case HostCmd_CMD_UAP_BSS_STOP:
1384 		priv->bss_started = 0;
1385 		break;
1386 	case HostCmd_CMD_UAP_STA_DEAUTH:
1387 		break;
1388 	case HOST_CMD_APCMD_SYS_RESET:
1389 		break;
1390 	case HostCmd_CMD_MEF_CFG:
1391 		break;
1392 	case HostCmd_CMD_COALESCE_CFG:
1393 		break;
1394 	case HostCmd_CMD_TDLS_OPER:
1395 		ret = mwifiex_ret_tdls_oper(priv, resp);
1396 	case HostCmd_CMD_MC_POLICY:
1397 		break;
1398 	case HostCmd_CMD_CHAN_REPORT_REQUEST:
1399 		break;
1400 	case HostCmd_CMD_SDIO_SP_RX_AGGR_CFG:
1401 		ret = mwifiex_ret_sdio_rx_aggr_cfg(priv, resp);
1402 		break;
1403 	case HostCmd_CMD_HS_WAKEUP_REASON:
1404 		ret = mwifiex_ret_wakeup_reason(priv, resp, data_buf);
1405 		break;
1406 	case HostCmd_CMD_TDLS_CONFIG:
1407 		break;
1408 	case HostCmd_CMD_ROBUST_COEX:
1409 		ret = mwifiex_ret_robust_coex(priv, resp, data_buf);
1410 		break;
1411 	case HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG:
1412 		break;
1413 	case HostCmd_CMD_CHAN_REGION_CFG:
1414 		ret = mwifiex_ret_chan_region_cfg(priv, resp);
1415 		break;
1416 	case HostCmd_CMD_STA_CONFIGURE:
1417 		ret = mwifiex_ret_get_chan_info(priv, resp, data_buf);
1418 		break;
1419 	default:
1420 		mwifiex_dbg(adapter, ERROR,
1421 			    "CMD_RESP: unknown cmd response %#x\n",
1422 			    resp->command);
1423 		break;
1424 	}
1425 
1426 	return ret;
1427 }
1428