qcacld-3.0: Move sme_config local variables to dynamic allocations

sme_config is used as local variables with struct tSmeConfigParams
in multiple places causing stack frame size to increase. This is
causing build issues with 32 bit systems where the stack frame
size is limited to 1024 bytes for each frame.

Move multiple sme_config local variables to dynamic allocations to
reduce stack frame size.

Change-Id: I86a93546adf40bbbc19438c3b1e3a7ec0d38f39f
CRs-Fixed: 2074224

core/hdd/src/wlan_hdd_cfg80211.c

@@ -17806,8 +17806,9 @@ __wlan_hdd_cfg80211_set_ap_channel_width(struct wiphy *wiphy,
 	hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev);
 	hdd_context_t *pHddCtx;
 	QDF_STATUS status;
-	tSmeConfigParams sme_config;
+	tSmeConfigParams *sme_config;
 	bool cbModeChange = false;
+	int retval = 0;
 
 	if (QDF_GLOBAL_FTM_MODE == hdd_get_conparam()) {
 		hdd_err("Command not allowed in FTM mode");
@@ -17824,58 +17825,66 @@ __wlan_hdd_cfg80211_set_ap_channel_width(struct wiphy *wiphy,
 	if (status)
 		return status;
 
-	qdf_mem_zero(&sme_config, sizeof(tSmeConfigParams));
-	sme_get_config_param(pHddCtx->hHal, &sme_config);
+	sme_config = qdf_mem_malloc(sizeof(*sme_config));
+	if (!sme_config) {
+		hdd_err("failed to allocate memory for sme_config");
+		return -ENOMEM;
+	}
+	qdf_mem_zero(sme_config, sizeof(*sme_config));
+	sme_get_config_param(pHddCtx->hHal, sme_config);
 	switch (chandef->width) {
 	case NL80211_CHAN_WIDTH_20:
 	case NL80211_CHAN_WIDTH_20_NOHT:
-		if (sme_config.csrConfig.channelBondingMode24GHz !=
+		if (sme_config->csrConfig.channelBondingMode24GHz !=
 		    eCSR_INI_SINGLE_CHANNEL_CENTERED) {
-			sme_config.csrConfig.channelBondingMode24GHz =
+			sme_config->csrConfig.channelBondingMode24GHz =
 				eCSR_INI_SINGLE_CHANNEL_CENTERED;
-			sme_update_config(pHddCtx->hHal, &sme_config);
+			sme_update_config(pHddCtx->hHal, sme_config);
 			cbModeChange = true;
 		}
 		break;
 
 	case NL80211_CHAN_WIDTH_40:
-		if (sme_config.csrConfig.channelBondingMode24GHz ==
+		if (sme_config->csrConfig.channelBondingMode24GHz ==
 		    eCSR_INI_SINGLE_CHANNEL_CENTERED) {
 			if (NL80211_CHAN_HT40MINUS ==
 			    cfg80211_get_chandef_type(chandef))
-				sme_config.csrConfig.channelBondingMode24GHz =
+				sme_config->csrConfig.channelBondingMode24GHz =
 					eCSR_INI_DOUBLE_CHANNEL_HIGH_PRIMARY;
 			else
-				sme_config.csrConfig.channelBondingMode24GHz =
+				sme_config->csrConfig.channelBondingMode24GHz =
 					eCSR_INI_DOUBLE_CHANNEL_LOW_PRIMARY;
-			sme_update_config(pHddCtx->hHal, &sme_config);
+			sme_update_config(pHddCtx->hHal, sme_config);
 			cbModeChange = true;
 		}
 		break;
 
 	default:
 		hdd_err("Error!!! Invalid HT20/40 mode !");
-		return -EINVAL;
+		retval = -EINVAL;
+		goto free;
 	}
 
 	if (!cbModeChange)
-		return 0;
+		goto free;
 
 	if (QDF_SAP_MODE != pAdapter->device_mode)
-		return 0;
+		goto free;
 
 	hdd_debug("Channel bonding changed to %d",
-	       sme_config.csrConfig.channelBondingMode24GHz);
+	       sme_config->csrConfig.channelBondingMode24GHz);
 
 	/* Change SAP ht2040 mode */
 	status = hdd_set_sap_ht2040_mode(pAdapter,
 					 cfg80211_get_chandef_type(chandef));
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("Cannot set SAP HT20/40 mode!");
-		return -EINVAL;
+		retval = -EINVAL;
 	}
 
-	return 0;
+free:
+	qdf_mem_free(sme_config);
+	return retval;
 }
 
 /**

core/hdd/src/wlan_hdd_hostapd.c

@@ -7466,7 +7466,7 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 	int32_t i;
 	struct hdd_config *iniConfig;
 	hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pHostapdAdapter);
-	tSmeConfigParams sme_config;
+	tSmeConfigParams *sme_config;
 	bool MFPCapable = false;
 	bool MFPRequired = false;
 	uint16_t prev_rsn_length = 0;
@@ -7492,6 +7492,12 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 		}
 	}
 
+	sme_config = qdf_mem_malloc(sizeof(*sme_config));
+	if (!sme_config) {
+		hdd_err("failed to allocate memory");
+		return -ENOMEM;
+	}
+
 	iniConfig = pHddCtx->config;
 	pHostapdState = WLAN_HDD_GET_HOSTAP_STATE_PTR(pHostapdAdapter);
 
@@ -7889,21 +7895,21 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 			pConfig->SapHw_mode = eCSR_DOT11_MODE_11n;
 	}
 
-	qdf_mem_zero(&sme_config, sizeof(tSmeConfigParams));
-	sme_get_config_param(pHddCtx->hHal, &sme_config);
+	qdf_mem_zero(sme_config, sizeof(*sme_config));
+	sme_get_config_param(pHddCtx->hHal, sme_config);
 	/* Override hostapd.conf wmm_enabled only for 11n and 11AC configs (IOT)
 	 * As per spec 11N/AC STA are QOS STA and may not connect or throughput
 	 * may not be good with non QOS 11N AP
 	 * Default: enable QOS for SAP unless WMM IE not present for 11bga
 	 */
-	sme_config.csrConfig.WMMSupportMode = eCsrRoamWmmAuto;
+	sme_config->csrConfig.WMMSupportMode = eCsrRoamWmmAuto;
 	pIe = wlan_hdd_get_vendor_oui_ie_ptr(WMM_OUI_TYPE, WMM_OUI_TYPE_SIZE,
 					pBeacon->tail, pBeacon->tail_len);
 	if (!pIe && (pConfig->SapHw_mode == eCSR_DOT11_MODE_11a ||
 		pConfig->SapHw_mode == eCSR_DOT11_MODE_11g ||
 		pConfig->SapHw_mode == eCSR_DOT11_MODE_11b))
-		sme_config.csrConfig.WMMSupportMode = eCsrRoamWmmNoQos;
-	sme_update_config(pHddCtx->hHal, &sme_config);
+		sme_config->csrConfig.WMMSupportMode = eCsrRoamWmmNoQos;
+	sme_update_config(pHddCtx->hHal, sme_config);
 
 	if (!pHddCtx->config->sap_force_11n_for_11ac) {
 		pConfig->ch_width_orig =
@@ -7970,7 +7976,8 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 		/* TODO Probably it should update some beacon params. */
 		hdd_debug("Bss Already started...Ignore the request");
 		EXIT();
-		return 0;
+		ret = 0;
+		goto free;
 	}
 
 	if (check_for_concurrency) {
@@ -8056,7 +8063,8 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 	pHostapdState->bCommit = true;
 	EXIT();
 
-	return 0;
+	ret = 0;
+	goto free;
 
 error:
 	clear_bit(SOFTAP_INIT_DONE, &pHostapdAdapter->event_flags);
@@ -8065,6 +8073,9 @@ error:
 			acs_cfg.ch_list);
 		pHostapdAdapter->sessionCtx.ap.sapConfig.acs_cfg.ch_list = NULL;
 	}
+
+free:
+	qdf_mem_free(sme_config);
 	return ret;
 }
 

core/hdd/src/wlan_hdd_ioctl.c

@@ -2181,8 +2181,9 @@ static int hdd_set_dwell_time(hdd_adapter_t *adapter, uint8_t *command)
 	tHalHandle hHal;
 	struct hdd_config *pCfg;
 	uint8_t *value = command;
-	tSmeConfigParams smeConfig;
+	tSmeConfigParams *sme_config;
 	int val = 0, temp = 0;
+	int retval = 0;
 
 	pCfg = (WLAN_HDD_GET_CTX(adapter))->config;
 	hHal = WLAN_HDD_GET_HAL_CTX(adapter);
@@ -2191,8 +2192,13 @@ static int hdd_set_dwell_time(hdd_adapter_t *adapter, uint8_t *command)
 		return -EINVAL;
 	}
 
-	qdf_mem_zero(&smeConfig, sizeof(smeConfig));
-	sme_get_config_param(hHal, &smeConfig);
+	sme_config = qdf_mem_malloc(sizeof(*sme_config));
+	if (!sme_config) {
+		hdd_err("failed to allocate memory for sme_config");
+		return -ENOMEM;
+	}
+	qdf_mem_zero(sme_config, sizeof(*sme_config));
+	sme_get_config_param(hHal, sme_config);
 
 	if (strncmp(command, "SETDWELLTIME ACTIVE MAX", 23) == 0) {
 		value = value + 24;
@@ -2200,60 +2206,68 @@ static int hdd_set_dwell_time(hdd_adapter_t *adapter, uint8_t *command)
 		if (temp != 0 || val < CFG_ACTIVE_MAX_CHANNEL_TIME_MIN ||
 		    val > CFG_ACTIVE_MAX_CHANNEL_TIME_MAX) {
 			hdd_err("argument passed for SETDWELLTIME ACTIVE MAX is incorrect");
-			return -EFAULT;
+			retval = -EFAULT;
+			goto free;
 		}
 		pCfg->nActiveMaxChnTime = val;
-		smeConfig.csrConfig.nActiveMaxChnTime = val;
-		sme_update_config(hHal, &smeConfig);
+		sme_config->csrConfig.nActiveMaxChnTime = val;
+		sme_update_config(hHal, sme_config);
 	} else if (strncmp(command, "SETDWELLTIME ACTIVE MIN", 23) == 0) {
 		value = value + 24;
 		temp = kstrtou32(value, 10, &val);
 		if (temp != 0 || val < CFG_ACTIVE_MIN_CHANNEL_TIME_MIN ||
 		    val > CFG_ACTIVE_MIN_CHANNEL_TIME_MAX) {
 			hdd_err("argument passed for SETDWELLTIME ACTIVE MIN is incorrect");
-			return -EFAULT;
+			retval = -EFAULT;
+			goto free;
 		}
 		pCfg->nActiveMinChnTime = val;
-		smeConfig.csrConfig.nActiveMinChnTime = val;
-		sme_update_config(hHal, &smeConfig);
+		sme_config->csrConfig.nActiveMinChnTime = val;
+		sme_update_config(hHal, sme_config);
 	} else if (strncmp(command, "SETDWELLTIME PASSIVE MAX", 24) == 0) {
 		value = value + 25;
 		temp = kstrtou32(value, 10, &val);
 		if (temp != 0 || val < CFG_PASSIVE_MAX_CHANNEL_TIME_MIN ||
 		    val > CFG_PASSIVE_MAX_CHANNEL_TIME_MAX) {
 			hdd_err("argument passed for SETDWELLTIME PASSIVE MAX is incorrect");
-			return -EFAULT;
+			retval = -EFAULT;
+			goto free;
 		}
 		pCfg->nPassiveMaxChnTime = val;
-		smeConfig.csrConfig.nPassiveMaxChnTime = val;
-		sme_update_config(hHal, &smeConfig);
+		sme_config->csrConfig.nPassiveMaxChnTime = val;
+		sme_update_config(hHal, sme_config);
 	} else if (strncmp(command, "SETDWELLTIME PASSIVE MIN", 24) == 0) {
 		value = value + 25;
 		temp = kstrtou32(value, 10, &val);
 		if (temp != 0 || val < CFG_PASSIVE_MIN_CHANNEL_TIME_MIN ||
 		    val > CFG_PASSIVE_MIN_CHANNEL_TIME_MAX) {
 			hdd_err("argument passed for SETDWELLTIME PASSIVE MIN is incorrect");
-			return -EFAULT;
+			retval = -EFAULT;
+			goto free;
 		}
 		pCfg->nPassiveMinChnTime = val;
-		smeConfig.csrConfig.nPassiveMinChnTime = val;
-		sme_update_config(hHal, &smeConfig);
+		sme_config->csrConfig.nPassiveMinChnTime = val;
+		sme_update_config(hHal, sme_config);
 	} else if (strncmp(command, "SETDWELLTIME", 12) == 0) {
 		value = value + 13;
 		temp = kstrtou32(value, 10, &val);
 		if (temp != 0 || val < CFG_ACTIVE_MAX_CHANNEL_TIME_MIN ||
 		    val > CFG_ACTIVE_MAX_CHANNEL_TIME_MAX) {
 			hdd_err("argument passed for SETDWELLTIME is incorrect");
-			return -EFAULT;
+			retval = -EFAULT;
+			goto free;
 		}
 		pCfg->nActiveMaxChnTime = val;
-		smeConfig.csrConfig.nActiveMaxChnTime = val;
-		sme_update_config(hHal, &smeConfig);
+		sme_config->csrConfig.nActiveMaxChnTime = val;
+		sme_update_config(hHal, sme_config);
 	} else {
-		return -EINVAL;
+		retval = -EINVAL;
+		goto free;
 	}
 
-	return 0;
+free:
+	qdf_mem_free(sme_config);
+	return retval;
 }
 
 struct link_status_priv {

core/hdd/src/wlan_hdd_wext.c

@@ -7338,12 +7338,13 @@ int wlan_hdd_update_phymode(struct net_device *net, tHalHandle hal,
 #endif
 	bool band_24 = false, band_5g = false;
 	bool ch_bond24 = false, ch_bond5g = false;
-	tSmeConfigParams smeconfig;
+	tSmeConfigParams *sme_config;
 	uint32_t chwidth = WNI_CFG_CHANNEL_BONDING_MODE_DISABLE;
 	uint32_t vhtchanwidth;
 	eCsrPhyMode phymode = -EIO, old_phymode;
 	enum hdd_dot11_mode hdd_dot11mode = phddctx->config->dot11Mode;
 	eCsrBand curr_band = eCSR_BAND_ALL;
+	int retval = 0;
 
 	old_phymode = sme_get_phy_mode(hal);
 
@@ -7542,59 +7543,68 @@ int wlan_hdd_update_phymode(struct net_device *net, tHalHandle hal,
 	}
 
 	if (phymode != -EIO) {
-		sme_get_config_param(hal, &smeconfig);
-		smeconfig.csrConfig.phyMode = phymode;
+		sme_config = qdf_mem_malloc(sizeof(*sme_config));
+		if (!sme_config) {
+			hdd_err("Failed to allocate memory for sme_config");
+			return -ENOMEM;
+		}
+		qdf_mem_zero(sme_config, sizeof(*sme_config));
+		sme_get_config_param(hal, sme_config);
+		sme_config->csrConfig.phyMode = phymode;
 #ifdef QCA_HT_2040_COEX
 		if (phymode == eCSR_DOT11_MODE_11n &&
 		    chwidth == WNI_CFG_CHANNEL_BONDING_MODE_DISABLE) {
-			smeconfig.csrConfig.obssEnabled = false;
+			sme_config->csrConfig.obssEnabled = false;
 			halStatus = sme_set_ht2040_mode(hal,
 							pAdapter->sessionId,
 							eHT_CHAN_HT20, false);
 			if (halStatus == QDF_STATUS_E_FAILURE) {
 				hdd_err("Failed to disable OBSS");
-				return -EIO;
+				retval = -EIO;
+				goto free;
 			}
 		} else if (phymode == eCSR_DOT11_MODE_11n &&
 			   chwidth == WNI_CFG_CHANNEL_BONDING_MODE_ENABLE) {
-			smeconfig.csrConfig.obssEnabled = true;
+			sme_config->csrConfig.obssEnabled = true;
 			halStatus = sme_set_ht2040_mode(hal,
 							pAdapter->sessionId,
 							eHT_CHAN_HT20, true);
 			if (halStatus == QDF_STATUS_E_FAILURE) {
 				hdd_err("Failed to enable OBSS");
-				return -EIO;
+				retval = -EIO;
+				goto free;
 			}
 		}
 #endif
-		smeconfig.csrConfig.eBand = curr_band;
-		smeconfig.csrConfig.bandCapability = curr_band;
+		sme_config->csrConfig.eBand = curr_band;
+		sme_config->csrConfig.bandCapability = curr_band;
 		if (curr_band == eCSR_BAND_24)
-			smeconfig.csrConfig.Is11hSupportEnabled = 0;
+			sme_config->csrConfig.Is11hSupportEnabled = 0;
 		else
-			smeconfig.csrConfig.Is11hSupportEnabled =
+			sme_config->csrConfig.Is11hSupportEnabled =
 				phddctx->config->Is11hSupportEnabled;
 		if (curr_band == eCSR_BAND_24)
-			smeconfig.csrConfig.channelBondingMode24GHz = chwidth;
+			sme_config->csrConfig.channelBondingMode24GHz = chwidth;
 		else if (curr_band == eCSR_BAND_24)
-			smeconfig.csrConfig.channelBondingMode5GHz = chwidth;
+			sme_config->csrConfig.channelBondingMode5GHz = chwidth;
 		else {
-			smeconfig.csrConfig.channelBondingMode24GHz = chwidth;
-			smeconfig.csrConfig.channelBondingMode5GHz = chwidth;
+			sme_config->csrConfig.channelBondingMode24GHz = chwidth;
+			sme_config->csrConfig.channelBondingMode5GHz = chwidth;
 		}
-		smeconfig.csrConfig.nVhtChannelWidth = vhtchanwidth;
-		sme_update_config(hal, &smeconfig);
+		sme_config->csrConfig.nVhtChannelWidth = vhtchanwidth;
+		sme_update_config(hal, sme_config);
 
 		phddctx->config->dot11Mode = hdd_dot11mode;
 		phddctx->config->nBandCapability = curr_band;
 		phddctx->config->nChannelBondingMode24GHz =
-			smeconfig.csrConfig.channelBondingMode24GHz;
+			sme_config->csrConfig.channelBondingMode24GHz;
 		phddctx->config->nChannelBondingMode5GHz =
-			smeconfig.csrConfig.channelBondingMode5GHz;
+			sme_config->csrConfig.channelBondingMode5GHz;
 		phddctx->config->vhtChannelWidth = vhtchanwidth;
 		if (hdd_update_config_cfg(phddctx) == false) {
 			hdd_err("could not update config_dat");
-			return -EIO;
+			retval = -EIO;
+			goto free;
 		}
 		if (phddctx->config->nChannelBondingMode5GHz)
 			phddctx->wiphy->bands[HDD_NL80211_BAND_5GHZ]->ht_cap.cap
@@ -7607,7 +7617,10 @@ int wlan_hdd_update_phymode(struct net_device *net, tHalHandle hal,
 			phymode, chwidth, curr_band, vhtchanwidth);
 	}
 
-	return 0;
+free:
+	if (sme_config)
+		qdf_mem_free(sme_config);
+	return retval;
 }
 
 struct temperature_priv {
@@ -7723,7 +7736,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 	hdd_station_ctx_t *pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
 	hdd_context_t *hdd_ctx;
-	tSmeConfigParams smeConfig;
+	tSmeConfigParams *sme_config;
 	int *value = (int *)extra;
 	int sub_cmd = value[0];
 	int set_value = value[1];
@@ -7745,7 +7758,12 @@ static int __iw_setint_getnone(struct net_device *dev,
 	if (0 != ret)
 		return ret;
 
-	memset(&smeConfig, 0x00, sizeof(smeConfig));
+	sme_config = qdf_mem_malloc(sizeof(*sme_config));
+	if (!sme_config) {
+		hdd_err("failed to allocate memory for sme_config");
+		return -ENOMEM;
+	}
+	qdf_mem_zero(sme_config, sizeof(*sme_config));
 
 	switch (sub_cmd) {
 	case WE_SET_11D_STATE:
@@ -7753,17 +7771,18 @@ static int __iw_setint_getnone(struct net_device *dev,
 		if ((ENABLE_11D == set_value)
 		    || (DISABLE_11D == set_value)) {
 
-			sme_get_config_param(hHal, &smeConfig);
-			smeConfig.csrConfig.Is11dSupportEnabled =
+			sme_get_config_param(hHal, sme_config);
+			sme_config->csrConfig.Is11dSupportEnabled =
 				(bool) set_value;
 
 			hdd_debug("11D state=%d!!",
-				  smeConfig.csrConfig.
+				  sme_config->csrConfig.
 				  Is11dSupportEnabled);
 
-			sme_update_config(hHal, &smeConfig);
+			sme_update_config(hHal, sme_config);
 		} else {
-			return -EINVAL;
+			ret = -EINVAL;
+			goto free;
 		}
 		break;
 	}
@@ -7854,8 +7873,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 		}
 		break;
 	case WE_SET_WOW_DATA_INACTIVITY_TO:
-		if (!hHal)
-			return -EINVAL;
+		if (!hHal) {
+			ret = -EINVAL;
+			goto free;
+		}
 
 		if ((set_value < CFG_WOW_DATA_INACTIVITY_TIMEOUT_MIN) ||
 		    (set_value > CFG_WOW_DATA_INACTIVITY_TIMEOUT_MAX) ||
@@ -7881,7 +7902,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 			    pAdapter->device_mode,
 			    set_value) != QDF_STATUS_SUCCESS) {
 			hdd_err("Setting tx power failed");
-			return -EIO;
+			ret = -EIO;
+			goto free;
 		}
 		break;
 	}
@@ -7899,7 +7921,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 		if (sme_set_max_tx_power(hHal, bssid, selfMac, set_value)
 		    != QDF_STATUS_SUCCESS) {
 			hdd_err("Setting maximum tx power failed");
-			return -EIO;
+			ret = -EIO;
+			goto free;
 		}
 
 		break;
@@ -7911,7 +7934,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 		if (sme_set_max_tx_power_per_band(eCSR_BAND_24, set_value) !=
 		    QDF_STATUS_SUCCESS) {
 			hdd_err("Setting max tx power failed for 2.4 GHz band");
-			return -EIO;
+			ret = -EIO;
+			goto free;
 		}
 
 		break;
@@ -7923,7 +7947,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 		if (sme_set_max_tx_power_per_band(eCSR_BAND_5G, set_value) !=
 		    QDF_STATUS_SUCCESS) {
 			hdd_err("Setting max tx power failed for 5.0 GHz band");
-			return -EIO;
+			ret = -EIO;
+			goto free;
 		}
 
 		break;
@@ -8100,10 +8125,12 @@ static int __iw_setint_getnone(struct net_device *dev,
 				RTSThreshold;
 		else if (((set_value & HDD_RTSCTS_EN_MASK) == 0)
 			 || ((set_value & HDD_RTSCTS_EN_MASK) ==
-			     HDD_CTS_ENABLE))
+			     HDD_CTS_ENABLE)) {
 			value = WNI_CFG_RTS_THRESHOLD_STAMAX;
-		else
-			return -EIO;
+		} else {
+			ret = -EIO;
+			goto free;
+		}
 
 		ret = wma_cli_set_command(pAdapter->sessionId,
 					  WMI_VDEV_PARAM_ENABLE_RTSCTS,
@@ -8113,7 +8140,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 				    (hHal, WNI_CFG_RTS_THRESHOLD, value) !=
 				    QDF_STATUS_SUCCESS) {
 				hdd_err("FAILED TO SET RTSCTS");
-				return -EIO;
+				ret = -EIO;
+				goto free;
 			}
 		}
 
@@ -8130,7 +8158,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 		       set_value);
 		if (set_value > eHT_CHANNEL_WIDTH_80MHZ) {
 			hdd_err("Invalid channel width 0->20 1->40 2->80");
-			return -EINVAL;
+			ret = -EINVAL;
+			goto free;
 		}
 
 		if ((WNI_CFG_CHANNEL_BONDING_MODE_DISABLE !=
@@ -8138,42 +8167,47 @@ static int __iw_setint_getnone(struct net_device *dev,
 							      nChannelBondingMode5GHz)))
 			chwidth = true;
 
-		sme_get_config_param(hHal, &smeConfig);
+		sme_get_config_param(hHal, sme_config);
 		switch (set_value) {
 		case eHT_CHANNEL_WIDTH_20MHZ:
-			smeConfig.csrConfig.channelBondingMode5GHz =
+			sme_config->csrConfig.channelBondingMode5GHz =
 				WNI_CFG_CHANNEL_BONDING_MODE_DISABLE;
 			break;
 		case eHT_CHANNEL_WIDTH_40MHZ:
-			if (chwidth)
-				smeConfig.csrConfig.
+			if (chwidth) {
+				sme_config->csrConfig.
 				channelBondingMode5GHz =
 					phddctx->config->
 					nChannelBondingMode5GHz;
-			else
-				return -EINVAL;
+			} else {
+				ret = -EINVAL;
+				goto free;
+			}
 
 			break;
 		case eHT_CHANNEL_WIDTH_80MHZ:
-			if (chwidth)
-				smeConfig.csrConfig.
+			if (chwidth) {
+				sme_config->csrConfig.
 				channelBondingMode5GHz =
 					phddctx->config->
 					nChannelBondingMode5GHz;
-			else
-				return -EINVAL;
+			} else {
+				ret = -EINVAL;
+				goto free;
+			}
 
 			break;
 
 		default:
-			return -EINVAL;
+			ret = -EINVAL;
+			goto free;
 		}
 
 		ret = wma_cli_set_command(pAdapter->sessionId,
 					  WMI_VDEV_PARAM_CHWIDTH,
 					  set_value, VDEV_CMD);
 		if (!ret)
-			sme_update_config(hHal, &smeConfig);
+			sme_update_config(hHal, sme_config);
 
 		break;
 	}
@@ -8546,8 +8580,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_PAID_MATCH:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 
 		hdd_debug("WMI_VDEV_PPS_PAID_MATCH val %d ",
 		       set_value);
@@ -8559,8 +8595,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_GID_MATCH:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 		hdd_debug("WMI_VDEV_PPS_GID_MATCH val %d ",
 		       set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8571,8 +8609,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_EARLY_TIM_CLEAR:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 		hdd_debug(" WMI_VDEV_PPS_EARLY_TIM_CLEAR val %d ",
 		       set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8583,8 +8623,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_EARLY_DTIM_CLEAR:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 		hdd_debug("WMI_VDEV_PPS_EARLY_DTIM_CLEAR val %d",
 		       set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8595,8 +8637,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_EOF_PAD_DELIM:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 		hdd_debug("WMI_VDEV_PPS_EOF_PAD_DELIM val %d ",
 		       set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8607,8 +8651,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_MACADDR_MISMATCH:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 		hdd_debug("WMI_VDEV_PPS_MACADDR_MISMATCH val %d ",
 		       set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8619,8 +8665,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_DELIM_CRC_FAIL:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 		hdd_debug("WMI_VDEV_PPS_DELIM_CRC_FAIL val %d ",
 		       set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8631,8 +8679,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_GID_NSTS_ZERO:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 		hdd_debug("WMI_VDEV_PPS_GID_NSTS_ZERO val %d ",
 		       set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8643,8 +8693,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_RSSI_CHECK:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 		hdd_debug("WMI_VDEV_PPS_RSSI_CHECK val %d ",
 		       set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8655,8 +8707,10 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_PPS_5G_EBT:
 	{
-		if (pAdapter->device_mode != QDF_STA_MODE)
-			return -EINVAL;
+		if (pAdapter->device_mode != QDF_STA_MODE) {
+			ret = -EINVAL;
+			goto free;
+		}
 
 		hdd_debug("WMI_VDEV_PPS_5G_EBT val %d", set_value);
 		ret = wma_cli_set_command(pAdapter->sessionId,
@@ -8849,7 +8903,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 		if (!((set_value >= CFG_CONC_SYSTEM_PREF_MIN) &&
 				(set_value <= CFG_CONC_SYSTEM_PREF_MAX))) {
 			hdd_err("Invalid system preference %d", set_value);
-			return -EINVAL;
+			ret = -EINVAL;
+			goto free;
 		}
 
 		/* hdd_ctx, hdd_ctx->config are already checked for null */
@@ -8880,6 +8935,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 	}
 	}
 	EXIT();
+free:
+	qdf_mem_free(sme_config);
 	return ret;
 }
 
@@ -9113,9 +9170,16 @@ static int __iw_setnone_getint(struct net_device *dev,
 	tHalHandle hHal = WLAN_HDD_GET_HAL_CTX(pAdapter);
 	int *value = (int *)extra;
 	int ret;
-	tSmeConfigParams smeConfig;
+	tSmeConfigParams *sme_config;
 	hdd_context_t *hdd_ctx;
 
+	sme_config = qdf_mem_malloc(sizeof(*sme_config));
+	if (!sme_config) {
+		hdd_err("failed to allocate memory for sme_config");
+		return -ENOMEM;
+	}
+	qdf_mem_zero(sme_config, sizeof(*sme_config));
+
 	ENTER_DEV(dev);
 
 	hdd_ctx = WLAN_HDD_GET_CTX(pAdapter);
@@ -9130,9 +9194,9 @@ static int __iw_setnone_getint(struct net_device *dev,
 	switch (value[0]) {
 	case WE_GET_11D_STATE:
 	{
-		sme_get_config_param(hHal, &smeConfig);
+		sme_get_config_param(hHal, sme_config);
 
-		*value = smeConfig.csrConfig.Is11dSupportEnabled;
+		*value = sme_config->csrConfig.Is11dSupportEnabled;
 
 		hdd_debug("11D state=%d!!", *value);
 
@@ -9170,8 +9234,8 @@ static int __iw_setnone_getint(struct net_device *dev,
 
 	case WE_GET_NSS:
 	{
-		sme_get_config_param(hHal, &smeConfig);
-		*value = (smeConfig.csrConfig.enable2x2 == 0) ? 1 : 2;
+		sme_get_config_param(hHal, sme_config);
+		*value = (sme_config->csrConfig.enable2x2 == 0) ? 1 : 2;
 		 if (policy_mgr_is_current_hwmode_dbs(hdd_ctx->hdd_psoc))
 			 *value = *value-1;
 		hdd_debug("GET_NSS: Current NSS:%d", *value);
@@ -9602,6 +9666,7 @@ static int __iw_setnone_getint(struct net_device *dev,
 	}
 	}
 	EXIT();
+	qdf_mem_free(sme_config);
 	return ret;
 }
 

core/sme/src/common/sme_api.c

@@ -15699,24 +15699,31 @@ QDF_STATUS sme_update_sta_roam_policy(tHalHandle hal_handle,
 {
 	tpAniSirGlobal mac_ctx = PMAC_STRUCT(hal_handle);
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	tSmeConfigParams sme_config;
+	tSmeConfigParams *sme_config;
 
 	if (!mac_ctx) {
 		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_FATAL,
 				"%s: mac_ctx is null", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
-	qdf_mem_zero(&sme_config, sizeof(sme_config));
-	sme_get_config_param(hal_handle, &sme_config);
 
-	sme_config.csrConfig.sta_roam_policy_params.dfs_mode =
+	sme_config = qdf_mem_malloc(sizeof(*sme_config));
+	if (!sme_config) {
+		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
+			FL("failed to allocate memory for sme_config"));
+		return QDF_STATUS_E_FAILURE;
+	}
+	qdf_mem_zero(sme_config, sizeof(*sme_config));
+	sme_get_config_param(hal_handle, sme_config);
+
+	sme_config->csrConfig.sta_roam_policy_params.dfs_mode =
 		dfs_mode;
-	sme_config.csrConfig.sta_roam_policy_params.skip_unsafe_channels =
+	sme_config->csrConfig.sta_roam_policy_params.skip_unsafe_channels =
 		skip_unsafe_channels;
-	sme_config.csrConfig.sta_roam_policy_params.sap_operating_band =
+	sme_config->csrConfig.sta_roam_policy_params.sap_operating_band =
 		sap_operating_band;
 
-	sme_update_config(hal_handle, &sme_config);
+	sme_update_config(hal_handle, sme_config);
 
 	status = csr_update_channel_list(mac_ctx);
 	if (QDF_STATUS_SUCCESS != status) {
@@ -15727,6 +15734,8 @@ QDF_STATUS sme_update_sta_roam_policy(tHalHandle hal_handle,
 		csr_roam_offload_scan(mac_ctx, session_id,
 				ROAM_SCAN_OFFLOAD_UPDATE_CFG,
 				REASON_ROAM_SCAN_STA_ROAM_POLICY_CHANGED);
+
+	qdf_mem_free(sme_config);
 	return status;
 }