qcacld-3.0: Refactor vdev create code

Refactor vdev create code to target_if common code. Remove legacy
code for vdev create.

Change-Id: I57caf0c5fa2da7b6ba640a9d2edb72363959c585
CRs-Fixed: 2460786

components/target_if/p2p/src/target_if_p2p.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -361,7 +361,7 @@ QDF_STATUS target_if_p2p_set_noa(struct wlan_objmgr_psoc *psoc,
 
 	target_if_debug("psoc:%pK, vdev_id:%d disable_noa:%d",
 				psoc, vdev_id, disable_noa);
-	param.if_id = vdev_id;
+	param.vdev_id = vdev_id;
 	param.param_id = WMI_VDEV_PARAM_DISABLE_NOA_P2P_GO;
 	param.param_value = (uint32_t)disable_noa;
 

components/target_if/pmo/src/target_if_pmo_suspend_resume.c

@@ -74,7 +74,7 @@ QDF_STATUS target_if_pmo_send_vdev_update_param_req(
 		return QDF_STATUS_E_INVAL;
 	}
 
-	param.if_id = vdev_id;
+	param.vdev_id = vdev_id;
 	param.param_id = param_id;
 	param.param_value = param_value;
 	target_if_debug("set vdev param vdev_id: %d value: %d for param_id: %d",
@@ -127,7 +127,7 @@ QDF_STATUS target_if_pmo_send_vdev_ps_param_req(
 	}
 
 	sta_ps_param.vdev_id = vdev_id;
-	sta_ps_param.param = param_id;
+	sta_ps_param.param_id = param_id;
 	sta_ps_param.value = param_value;
 	target_if_debug("set vdev param vdev_id: %d value: %d for param_id: %d",
 			vdev_id, param_value, param_id);

core/cds/inc/cds_api.h

@@ -329,8 +329,26 @@ QDF_STATUS cds_free_context(QDF_MODULE_ID module_id, void *module_context);
 
 QDF_STATUS cds_set_context(QDF_MODULE_ID module_id, void *context);
 
-QDF_STATUS cds_get_vdev_types(enum QDF_OPMODE mode, uint32_t *type,
+/**
-			      uint32_t *subType);
+ * cds_get_vdev_types() - get vdev type and subtype from it's operation mode
+ * @mode: operation mode of vdev
+ * @type: type of vdev
+ * @sub_type: sub_type of vdev
+ *
+ * This API is called to get vdev type and subtype from it's operation mode.
+ * Vdev operation modes are defined in enum QDF_OPMODE.
+ *
+ * Type of vdev are WLAN_VDEV_MLME_TYPE_AP, WLAN_VDEV_MLME_TYPE_STA,
+ * WLAN_VDEV_MLME_TYPE_IBSS, ,WLAN_VDEV_MLME_TYPE_MONITOR,
+ * WLAN_VDEV_MLME_TYPE_NAN, WLAN_VDEV_MLME_TYPE_OCB, WLAN_VDEV_MLME_TYPE_NDI
+ *
+ * Sub_types of vdev are WLAN_VDEV_MLME_SUBTYPE_P2P_DEVICE,
+ * WLAN_VDEV_MLME_SUBTYPE_P2P_CLIENT, WLAN_VDEV_MLME_SUBTYPE_P2P_GO,
+ * WLAN_VDEV_MLME_SUBTYPE_PROXY_STA, WLAN_VDEV_MLME_SUBTYPE_MESH
+ * Return: QDF_STATUS
+ */
+QDF_STATUS cds_get_vdev_types(enum QDF_OPMODE mode, uint8_t *type,
+			      uint8_t *sub_type);
 
 void cds_flush_work(void *work);
 void cds_flush_delayed_work(void *dwork);

core/cds/src/cds_api.c

@@ -1607,16 +1607,8 @@ QDF_STATUS cds_free_context(QDF_MODULE_ID module_id, void *module_context)
 	return QDF_STATUS_SUCCESS;
 } /* cds_free_context() */
 
-/**
+QDF_STATUS cds_get_vdev_types(enum QDF_OPMODE mode, uint8_t *type,
- * cds_get_vdev_types() - get vdev type
+			      uint8_t *sub_type)
- * @mode: mode
- * @type: type
- * @sub_type: sub_type
- *
- * Return: WMI vdev type
- */
-QDF_STATUS cds_get_vdev_types(enum QDF_OPMODE mode, uint32_t *type,
-			      uint32_t *sub_type)
 {
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	*type = 0;
@@ -1624,34 +1616,34 @@ QDF_STATUS cds_get_vdev_types(enum QDF_OPMODE mode, uint32_t *type,
 
 	switch (mode) {
 	case QDF_STA_MODE:
-		*type = WMI_VDEV_TYPE_STA;
+		*type = WLAN_VDEV_MLME_TYPE_STA;
 		break;
 	case QDF_SAP_MODE:
-		*type = WMI_VDEV_TYPE_AP;
+		*type = WLAN_VDEV_MLME_TYPE_AP;
 		break;
 	case QDF_P2P_DEVICE_MODE:
-		*type = WMI_VDEV_TYPE_AP;
+		*type = WLAN_VDEV_MLME_TYPE_AP;
-		*sub_type = WMI_UNIFIED_VDEV_SUBTYPE_P2P_DEVICE;
+		*sub_type = WLAN_VDEV_MLME_SUBTYPE_P2P_DEVICE;
 		break;
 	case QDF_P2P_CLIENT_MODE:
-		*type = WMI_VDEV_TYPE_STA;
+		*type = WLAN_VDEV_MLME_TYPE_STA;
-		*sub_type = WMI_UNIFIED_VDEV_SUBTYPE_P2P_CLIENT;
+		*sub_type = WLAN_VDEV_MLME_SUBTYPE_P2P_CLIENT;
 		break;
 	case QDF_P2P_GO_MODE:
-		*type = WMI_VDEV_TYPE_AP;
+		*type = WLAN_VDEV_MLME_TYPE_AP;
-		*sub_type = WMI_UNIFIED_VDEV_SUBTYPE_P2P_GO;
+		*sub_type = WLAN_VDEV_MLME_SUBTYPE_P2P_GO;
 		break;
 	case QDF_OCB_MODE:
-		*type = WMI_VDEV_TYPE_OCB;
+		*type = WLAN_VDEV_MLME_TYPE_OCB;
 		break;
 	case QDF_IBSS_MODE:
-		*type = WMI_VDEV_TYPE_IBSS;
+		*type = WLAN_VDEV_MLME_TYPE_IBSS;
 		break;
 	case QDF_MONITOR_MODE:
-		*type = WMI_VDEV_TYPE_MONITOR;
+		*type = WMI_HOST_VDEV_TYPE_MONITOR;
 		break;
 	case QDF_NDI_MODE:
-		*type = WMI_VDEV_TYPE_NDI;
+		*type = WLAN_VDEV_MLME_TYPE_NDI;
 		break;
 	default:
 		cds_err("Invalid device mode %d", mode);

core/hdd/src/wlan_hdd_cfg80211.c

@@ -5885,7 +5885,6 @@ static int hdd_config_mpdu_aggregation(struct hdd_adapter *adapter,
 	struct nlattr *rx_attr =
 		tb[QCA_WLAN_VENDOR_ATTR_CONFIG_RX_MPDU_AGGREGATION];
 	uint8_t tx_size, rx_size;
-	struct sir_set_tx_rx_aggregation_size request;
 	QDF_STATUS status;
 
 	/* nothing to do if neither attribute is present */
@@ -5909,15 +5908,10 @@ static int hdd_config_mpdu_aggregation(struct hdd_adapter *adapter,
 		return -EINVAL;
 	}
 
-	qdf_mem_zero(&request, sizeof(request));
+	status = wma_set_tx_rx_aggr_size(adapter->vdev_id,
-	request.tx_aggregation_size = tx_size;
+					 tx_size,
-	request.rx_aggregation_size = rx_size;
+					 rx_size,
-	request.vdev_id = adapter->vdev_id;
+					 WMI_VDEV_CUSTOM_AGGR_TYPE_AMPDU);
-	request.aggr_type = WMI_VDEV_CUSTOM_AGGR_TYPE_AMPDU;
-
-	status = wma_set_tx_rx_aggregation_size(&request);
-	if (QDF_IS_STATUS_ERROR(status))
-		hdd_err("failed to set aggr sizes err %d", status);
 
 	return qdf_status_to_os_return(status);
 }

core/hdd/src/wlan_hdd_main.c

@@ -4381,24 +4381,13 @@ static int hdd_set_sme_session_param(struct hdd_adapter *adapter,
 			csr_roam_complete_cb callback,
 			void *callback_ctx)
 {
-	uint32_t type;
+	session_param->vdev_id = adapter->vdev_id;
-	uint32_t sub_type;
-	QDF_STATUS status;
-
-	/* determine vdev (sub)type */
-	status = cds_get_vdev_types(adapter->device_mode, &type, &sub_type);
-	if (QDF_STATUS_SUCCESS != status) {
-		hdd_err("failed to get vdev type: %d", status);
-		return qdf_status_to_os_return(status);
-	}
-	session_param->sme_session_id = adapter->vdev_id;
 	session_param->self_mac_addr = (uint8_t *)&adapter->mac_addr;
-	session_param->type_of_persona = type;
-	session_param->subtype_of_persona = sub_type;
 	session_param->session_open_cb = hdd_sme_open_session_callback;
 	session_param->session_close_cb = hdd_sme_close_session_callback;
 	session_param->callback = callback;
 	session_param->callback_ctx = callback_ctx;
+	session_param->vdev = adapter->vdev;
 
 	return 0;
 }
@@ -4470,14 +4459,15 @@ int hdd_vdev_create(struct hdd_adapter *adapter,
 		hdd_err("failed to populating SME params");
 		goto objmgr_vdev_destroy_procedure;
 	}
-	status = sme_open_session(hdd_ctx->mac_handle, &sme_session_params);
+	status = sme_create_vdev(hdd_ctx->mac_handle,
+				 &sme_session_params);
 	if (QDF_IS_STATUS_ERROR(status)) {
-		hdd_err("failed to open sme session: %d", status);
+		hdd_err("failed to create vdev: %d", status);
 		errno = qdf_status_to_os_return(status);
 		goto objmgr_vdev_destroy_procedure;
 	}
 
-	/* block on a completion variable until sme session is opened */
+	/* block on a completion variable until vdev is created in firmware */
 	status = qdf_wait_for_event_completion(&adapter->qdf_session_open_event,
 			SME_CMD_VDEV_CREATE_DELETE_TIMEOUT);
 	if (QDF_STATUS_SUCCESS != status) {

core/hdd/src/wlan_hdd_object_manager.h

@@ -120,7 +120,7 @@ int hdd_objmgr_release_and_destroy_pdev(struct hdd_context *hdd_ctx);
  * Return: 0 for success, negative error code for failure
  */
 int hdd_objmgr_create_and_store_vdev(struct wlan_objmgr_pdev *pdev,
-			      struct hdd_adapter *adapter);
+				     struct hdd_adapter *adapter);
 
 /**
  * hdd_objmgr_release_and_destroy_vdev() - Delete vdev and remove from adapter

core/mac/inc/sir_api.h

@@ -5041,56 +5041,6 @@ struct sme_ndp_peer_ind {
 };
 #endif /* WLAN_FEATURE_NAN */
 
-/**
- * struct sir_set_tx_rx_aggregation_size - sets tx rx aggregation size
- * @vdev_id: vdev id of the session
- * @aggr_type: TX Aggregation Type (0=A-MPDU, 1=A-MSDU)
- * @tx_aggregation_size: Tx aggregation size
- * @tx_aggregation_size_be: Tx aggregation size for be queue
- * @tx_aggregation_size_bk: Tx aggregation size for bk queue
- * @tx_aggregation_size_vi: Tx aggregation size for vi queue
- * @tx_aggregation_size_vo: Tx aggregation size for vo queue
- * @rx_aggregation_size: Rx aggregation size
- */
-struct sir_set_tx_rx_aggregation_size {
-	uint8_t vdev_id;
-	wmi_vdev_custom_aggr_type_t aggr_type;
-	uint32_t tx_aggregation_size;
-	uint32_t tx_aggregation_size_be;
-	uint32_t tx_aggregation_size_bk;
-	uint32_t tx_aggregation_size_vi;
-	uint32_t tx_aggregation_size_vo;
-	uint32_t rx_aggregation_size;
-};
-
-/**
- * struct sir_set_tx_sw_retry_threshold - set sw retry threshold
- * @vdev_id: vdev id of the session
- * @tx_aggr_sw_retry_threshold_be: aggr sw retry threshold for BE
- * @tx_aggr_sw_retry_threshold_bk: aggr sw retry threshold for BK
- * @tx_aggr_sw_retry_threshold_vi: aggr sw retry threshold for VI
- * @tx_aggr_sw_retry_threshold_vo: aggr sw retry threshold for VO
- * @tx_aggr_sw_retry_threshold: aggr sw retry threshold
- * @tx_non_aggr_sw_retry_threshold_be: non aggr sw retry threshold for BE
- * @tx_non_aggr_sw_retry_threshold_bk: non aggr sw retry threshold for BK
- * @tx_non_aggr_sw_retry_threshold_vi: non aggr sw retry threshold for VI
- * @tx_non_aggr_sw_retry_threshold_vo: non aggr sw retry threshold for VO
- * @tx_non_aggr_sw_retry_threshold: non aggr sw retry threshold
- */
-struct sir_set_tx_sw_retry_threshold {
-	uint8_t vdev_id;
-	uint32_t tx_aggr_sw_retry_threshold_be;
-	uint32_t tx_aggr_sw_retry_threshold_bk;
-	uint32_t tx_aggr_sw_retry_threshold_vi;
-	uint32_t tx_aggr_sw_retry_threshold_vo;
-	uint32_t tx_aggr_sw_retry_threshold;
-	uint32_t tx_non_aggr_sw_retry_threshold_be;
-	uint32_t tx_non_aggr_sw_retry_threshold_bk;
-	uint32_t tx_non_aggr_sw_retry_threshold_vi;
-	uint32_t tx_non_aggr_sw_retry_threshold_vo;
-	uint32_t tx_non_aggr_sw_retry_threshold;
-};
-
 /**
  * struct sir_p2p_lo_start - p2p listen offload start
  * @vdev_id: vdev identifier

core/mac/inc/wni_api.h

@@ -87,7 +87,7 @@ enum eWniMsgTypes {
 	eWNI_SME_BEACON_REPORT_REQ_IND = SIR_SME_MSG_TYPES_BEGIN + 45,
 	eWNI_SME_BEACON_REPORT_RESP_XMIT_IND = SIR_SME_MSG_TYPES_BEGIN + 46,
 
-	eWNI_SME_ADD_STA_SELF_RSP = SIR_SME_MSG_TYPES_BEGIN + 47,
+	/* unused SIR_SME_MSG_TYPES_BEGIN + 47, */
 	eWNI_SME_DEL_STA_SELF_RSP = SIR_SME_MSG_TYPES_BEGIN + 48,
 
 	eWNI_SME_FT_PRE_AUTH_REQ = SIR_SME_MSG_TYPES_BEGIN + 49,
@@ -240,7 +240,9 @@ enum eWniMsgTypes {
 	WNI_SME_REGISTER_BCN_REPORT_SEND_CB = SIR_SME_MSG_TYPES_BEGIN + 154,
 	eWNI_SME_ANTENNA_ISOLATION_RSP = SIR_SME_MSG_TYPES_BEGIN + 155,
 	eWNI_SME_MON_DEINIT_SESSION = SIR_SME_MSG_TYPES_BEGIN + 156,
-	eWNI_SME_MSG_TYPES_END = SIR_SME_MSG_TYPES_BEGIN + 157
+	eWNI_SME_VDEV_CREATE_REQ = SIR_SME_MSG_TYPES_BEGIN + 157,
+	eWNI_SME_VDEV_CREATE_RSP = SIR_SME_MSG_TYPES_BEGIN + 158,
+	eWNI_SME_MSG_TYPES_END = SIR_SME_MSG_TYPES_BEGIN + 159
 };
 
 typedef struct sAniCfgTxRateCtrs {

core/mac/src/include/sir_params.h

@@ -298,8 +298,8 @@ struct sir_cfg_action_frm_tb_ppdu {
 /* / PE <-> HAL Host Offload message */
 #define SIR_HAL_SET_HOST_OFFLOAD           (SIR_HAL_ITC_MSG_TYPES_BEGIN + 100)
 
-#define SIR_HAL_ADD_STA_SELF_REQ           (SIR_HAL_ITC_MSG_TYPES_BEGIN + 101)
+/* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 101) is unused */
-#define SIR_HAL_ADD_STA_SELF_RSP           (SIR_HAL_ITC_MSG_TYPES_BEGIN + 102)
+/* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 102) is unused */
 #define SIR_HAL_DEL_STA_SELF_REQ           (SIR_HAL_ITC_MSG_TYPES_BEGIN + 103)
 /*
  * (SIR_HAL_ITC_MSG_TYPES_BEGIN + 104) thru

core/mac/src/pe/lim/lim_process_message_queue.c

@@ -59,6 +59,7 @@
 #include "cds_ieee80211_common.h"
 #include <wlan_scan_ucfg_api.h>
 #include "wlan_mlme_public_struct.h"
+#include "../../core/src/vdev_mgr_ops.h"
 
 void lim_log_session_states(struct mac_context *mac);
 static void lim_process_normal_hdd_msg(struct mac_context *mac_ctx,
@@ -1541,6 +1542,60 @@ static void lim_process_sme_obss_scan_ind(struct mac_context *mac_ctx,
 	return;
 }
 
+static void
+lim_process_vdev_create(struct mac_context *mac_ctx,
+			struct vdev_create_req_param *vdev_create_param)
+{
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_mlme_obj *vdev_mlme = NULL;
+	struct scheduler_msg message = {0};
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(mac_ctx->psoc,
+						    vdev_create_param->vdev_id,
+						    WLAN_LEGACY_MAC_ID);
+	if (!vdev) {
+		pe_err("Failed to get vdev obj for vdev id %d",
+		       vdev_create_param->vdev_id);
+		status = QDF_STATUS_E_INVAL;
+		goto end;
+	}
+
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
+	if (!vdev_mlme) {
+		pe_err("Failed to get vdev mlme obj for vdev id %d",
+		       vdev_create_param->vdev_id);
+		status = QDF_STATUS_E_INVAL;
+		goto end;
+	}
+
+	status = vdev_mgr_create_send(vdev_mlme);
+	if (QDF_IS_STATUS_ERROR(vdev_create_param->status)) {
+		pe_err("Failed to create vdev for vdev id %d",
+		       vdev_create_param->vdev_id);
+		goto end;
+	}
+
+	status = wma_post_vdev_create_setup(vdev);
+
+	if (QDF_IS_STATUS_ERROR(status))
+		vdev_mgr_delete_send(vdev_mlme);
+
+end:
+	if (vdev)
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID);
+
+	vdev_create_param->status = status;
+	message.type = eWNI_SME_VDEV_CREATE_RSP;
+	message.bodyptr = vdev_create_param;
+	status = scheduler_post_message(QDF_MODULE_ID_PE, QDF_MODULE_ID_SME,
+					QDF_MODULE_ID_SME, &message);
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
+		qdf_mem_free(vdev_create_param);
+		pe_err("scheduler_post_msg failed!(err=%d)", status);
+	}
+}
+
 /**
  * lim_process_messages() - Process messages from upper layers.
  *
@@ -2097,6 +2152,11 @@ static void lim_process_messages(struct mac_context *mac_ctx,
 		qdf_mem_free((void *)msg->bodyptr);
 		msg->bodyptr = NULL;
 		break;
+	case eWNI_SME_VDEV_CREATE_REQ:
+		lim_process_vdev_create(mac_ctx, msg->bodyptr);
+		/* Do not free msg->bodyptr, same memory used to send resp */
+		msg->bodyptr = NULL;
+		break;
 	default:
 		qdf_mem_free((void *)msg->bodyptr);
 		msg->bodyptr = NULL;

core/mac/src/sys/legacy/src/utils/src/mac_trace.c

@@ -256,7 +256,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
 		CASE_RETURN_STRING(eWNI_SME_NEIGHBOR_REPORT_IND);
 		CASE_RETURN_STRING(eWNI_SME_BEACON_REPORT_REQ_IND);
 		CASE_RETURN_STRING(eWNI_SME_BEACON_REPORT_RESP_XMIT_IND);
-		CASE_RETURN_STRING(eWNI_SME_ADD_STA_SELF_RSP);
 		CASE_RETURN_STRING(eWNI_SME_DEL_STA_SELF_RSP);
 		CASE_RETURN_STRING(eWNI_SME_FT_PRE_AUTH_REQ);
 		CASE_RETURN_STRING(eWNI_SME_FT_PRE_AUTH_RSP);
@@ -388,7 +387,6 @@ uint8_t *mac_trace_get_wma_msg_string(uint16_t wma_msg)
 	switch (wma_msg) {
 		CASE_RETURN_STRING(WMA_ADD_STA_REQ);
 		CASE_RETURN_STRING(WMA_ADD_STA_RSP);
-		CASE_RETURN_STRING(WMA_ADD_STA_SELF_RSP);
 		CASE_RETURN_STRING(WMA_DELETE_STA_REQ);
 		CASE_RETURN_STRING(WMA_DELETE_STA_RSP);
 		CASE_RETURN_STRING(WMA_ADD_BSS_REQ);
@@ -453,7 +451,6 @@ uint8_t *mac_trace_get_wma_msg_string(uint16_t wma_msg)
 #ifdef WLAN_NS_OFFLOAD
 		CASE_RETURN_STRING(WMA_SET_NS_OFFLOAD);
 #endif /* WLAN_NS_OFFLOAD */
-		CASE_RETURN_STRING(WMA_ADD_STA_SELF_REQ);
 		CASE_RETURN_STRING(WMA_DEL_STA_SELF_REQ);
 		CASE_RETURN_STRING(WMA_WLAN_SUSPEND_IND);
 		CASE_RETURN_STRING(WMA_WLAN_RESUME_REQ);

core/sme/inc/sme_api.h

@@ -212,21 +212,19 @@ struct sme_5g_band_pref_params {
  * @session_open_cb: callback to be registered with SME for opening the session
  * @session_close_cb: callback to be registered with SME for closing the session
  * @callback: callback to be invoked for roaming events
+ * @vdev: pointer to vdev object
  * @callback_ctx: user-supplied context to be passed back on roaming events
  * @self_mac_addr: Self mac address
- * @sme_session_id: SME session id
+ * @vdev_id: vdev id
- * @type_of_persona: person type
- * @subtype_of_persona: sub type of persona
  */
 struct sme_session_params {
 	csr_session_open_cb  session_open_cb;
 	csr_session_close_cb session_close_cb;
 	csr_roam_complete_cb callback;
+	struct wlan_objmgr_vdev *vdev;
 	void *callback_ctx;
 	uint8_t *self_mac_addr;
-	uint8_t sme_session_id;
+	uint8_t vdev_id;
-	uint32_t type_of_persona;
-	uint32_t subtype_of_persona;
 };
 
 #define MAX_CANDIDATE_INFO 10
@@ -370,21 +368,19 @@ sme_nss_chains_update(mac_handle_t mac_handle,
 		      uint8_t vdev_id);
 
 /**
- * sme_open_session() - Open a session for given persona
+ * sme_create_vdev() - Create vdev for given persona
+ * @mac_handle: The handle returned by mac_open
+ * @params: to initialize the session open params
  *
  * This is a synchronous API. For any protocol stack related activity
- * requires session to be opened. This API needs to be called to open
+ * requires vdev to be created. This API needs to be called to create
- * the session in SME module.
+ * vdev in SME module.
  *
- * mac_handle: The handle returned by mac_open.
+ * Return: QDF_STATUS_SUCCESS - vdev is created
- * params: to initialize the session open params
+ * Other status means SME is failed to create vdev
- *
- * Return:
- * QDF_STATUS_SUCCESS - session is opened.
- * Other status means SME is failed to open the session.
  */
-QDF_STATUS sme_open_session(mac_handle_t mac_handle,
+QDF_STATUS sme_create_vdev(mac_handle_t mac_handle,
-			    struct sme_session_params *params);
+			   struct sme_session_params *params);
 
 /**
  * sme_close_session() - Close a session for given persona

core/sme/inc/sme_inside.h

@@ -163,7 +163,6 @@ QDF_STATUS csr_is_valid_channel(struct mac_context *mac, uint8_t chnNum);
 QDF_STATUS sme_acquire_global_lock(struct sme_context *sme);
 QDF_STATUS sme_release_global_lock(struct sme_context *sme);
 
-QDF_STATUS csr_process_add_sta_session_rsp(struct mac_context *mac, uint8_t *pMsg);
 QDF_STATUS csr_process_del_sta_session_rsp(struct mac_context *mac, uint8_t *pMsg);
 
 QDF_STATUS csr_flush_cfg_bg_scan_roam_channel_list(struct mac_context *mac,

core/sme/src/common/sme_api.c

@@ -1997,10 +1997,9 @@ QDF_STATUS sme_process_msg(struct mac_context *mac, struct scheduler_msg *pMsg)
 			sme_err("Empty message for: %d", pMsg->type);
 		}
 		break;
-	case eWNI_SME_ADD_STA_SELF_RSP:
+	case eWNI_SME_VDEV_CREATE_RSP:
 		if (pMsg->bodyptr) {
-			status = csr_process_add_sta_session_rsp(mac,
+			status = csr_vdev_create_resp(mac, pMsg->bodyptr);
-								pMsg->bodyptr);
 			qdf_mem_free(pMsg->bodyptr);
 		} else {
 			sme_err("Empty message for: %d", pMsg->type);
@@ -4486,8 +4485,8 @@ release_ref:
 	return status;
 }
 
-QDF_STATUS sme_open_session(mac_handle_t mac_handle,
+QDF_STATUS sme_create_vdev(mac_handle_t mac_handle,
-			    struct sme_session_params *params)
+			   struct sme_session_params *params)
 {
 	QDF_STATUS status = QDF_STATUS_E_INVAL;
 	struct mac_context *mac_ctx = MAC_CONTEXT(mac_handle);
@@ -4496,17 +4495,13 @@ QDF_STATUS sme_open_session(mac_handle_t mac_handle,
 	uint8_t peer_id;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 
-	QDF_TRACE(QDF_MODULE_ID_SAP, QDF_TRACE_LEVEL_DEBUG,
+	sme_debug("vdev_id %d addr:%pM", params->vdev_id,
-		  "%s: type=%d, session_id %d subType=%d addr:%pM",
-		  __func__, params->type_of_persona,
-		  params->sme_session_id, params->subtype_of_persona,
 		  params->self_mac_addr);
 
 	pdev = cds_get_context(QDF_MODULE_ID_TXRX);
 
 	if (!pdev) {
-		QDF_TRACE(QDF_MODULE_ID_SAP, QDF_TRACE_LEVEL_ERROR,
+		sme_err("Failed to get pdev handler");
-			  "%s: Failed to get pdev handler", __func__);
 		return status;
 	}
 
@@ -4517,17 +4512,15 @@ QDF_STATUS sme_open_session(mac_handle_t mac_handle,
 	peer = cdp_peer_find_by_addr(soc, pdev, params->self_mac_addr,
 				     &peer_id);
 	if (peer) {
-		QDF_TRACE(QDF_MODULE_ID_SAP, QDF_TRACE_LEVEL_ERROR,
+		sme_err("Peer=%d exist with same MAC", peer_id);
-			  "%s: Peer=%d exist with same MAC",
-			  __func__, peer_id);
 		status = QDF_STATUS_E_INVAL;
 	} else {
-		status = csr_roam_open_session(mac_ctx, params);
+		status = csr_create_vdev(mac_ctx, params->vdev, params);
 	}
 	sme_release_global_lock(&mac_ctx->sme);
 
 	MTRACE(qdf_trace(QDF_MODULE_ID_SME, TRACE_CODE_SME_RX_HDD_OPEN_SESSION,
-			 params->sme_session_id, 0));
+			 params->vdev_id, 0));
 
 	return status;
 }

core/sme/src/csr/csr_api_roam.c

@@ -16785,47 +16785,86 @@ static void csr_store_oce_cfg_flags_in_vdev(struct mac_context *mac,
 	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID);
 }
 
-QDF_STATUS csr_process_add_sta_session_rsp(struct mac_context *mac, uint8_t *pMsg)
+static void csr_send_set_ie(uint8_t type, uint8_t sub_type,
+			    uint8_t vdev_id)
 {
-	struct add_sta_self_params *rsp;
 	struct send_extcap_ie *msg;
 	QDF_STATUS status;
 
-	if (!pMsg) {
+	sme_debug("send SET IE msg to PE");
-		sme_err("in %s msg ptr is NULL", __func__);
+
+	if (!(type == WLAN_VDEV_MLME_TYPE_STA ||
+	      (type == WLAN_VDEV_MLME_TYPE_AP &&
+	      sub_type == WLAN_VDEV_MLME_SUBTYPE_P2P_DEVICE))) {
+		sme_err("Failed to send set IE req for vdev_%d", vdev_id);
+		return;
+	}
+
+	msg = qdf_mem_malloc(sizeof(*msg));
+	if (!msg)
+		return;
+
+	msg->msg_type = eWNI_SME_SET_IE_REQ;
+	msg->session_id = vdev_id;
+	msg->length = sizeof(*msg);
+	status = umac_send_mb_message_to_mac(msg);
+	if (!QDF_IS_STATUS_SUCCESS(status))
+		sme_err("Failed to send set IE req for vdev_%d", vdev_id);
+}
+
+QDF_STATUS csr_vdev_create_resp(struct mac_context *mac, uint8_t *pmsg)
+{
+	struct vdev_create_req_param *rsp;
+	struct vdev_mlme_obj *vdev_mlme;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!pmsg) {
+		sme_err("msg ptr is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+	rsp = (struct vdev_create_req_param *)pmsg;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(mac->psoc,
+						    rsp->vdev_id,
+						    WLAN_LEGACY_MAC_ID);
+	if (!vdev) {
+		sme_err("Failed to get vdev obj for vdev id %d",
+			rsp->vdev_id);
+		csr_cleanup_session(mac, rsp->vdev_id);
+		csr_roam_session_opened(mac, QDF_STATUS_E_FAILURE,
+					rsp->vdev_id);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	sme_debug("create vdev status = %d", rsp->status);
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
+	if (!vdev_mlme) {
+		sme_err("Fail to get vdev priv object");
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID);
+		csr_cleanup_session(mac, rsp->vdev_id);
+		csr_roam_session_opened(mac, QDF_STATUS_E_FAILURE,
+					rsp->vdev_id);
 		return QDF_STATUS_E_FAILURE;
 	}
-	rsp = (struct add_sta_self_params *) pMsg;
-	sme_debug("Add Sta self rsp status = %d", rsp->status);
 
 	if (QDF_IS_STATUS_SUCCESS(rsp->status)) {
-		if ((WMI_VDEV_TYPE_STA == rsp->type ||
+		csr_send_set_ie(vdev_mlme->mgmt.generic.type,
-		    (WMI_VDEV_TYPE_AP == rsp->type &&
+				vdev_mlme->mgmt.generic.subtype,
-		     WMI_UNIFIED_VDEV_SUBTYPE_P2P_DEVICE == rsp->sub_type))) {
+				rsp->vdev_id);
-			sme_debug("send SET IE msg to PE");
-			msg = qdf_mem_malloc(sizeof(*msg));
-			if (!msg)
-				return QDF_STATUS_E_NOMEM;
 
-			msg->msg_type = eWNI_SME_SET_IE_REQ;
+		if (vdev_mlme->mgmt.generic.type == WLAN_VDEV_MLME_TYPE_STA) {
-			msg->session_id = rsp->session_id;
+			csr_store_oce_cfg_flags_in_vdev(mac, mac->pdev,
-			msg->length = sizeof(*msg);
+							rsp->vdev_id);
-			status = umac_send_mb_message_to_mac(msg);
+			wlan_mlme_update_oce_flags(mac->pdev);
-			if (!QDF_IS_STATUS_SUCCESS(status))
-				sme_err("Failed to send down the set IE req ");
 		}
 	}
 
-	csr_roam_session_opened(mac, rsp->status, rsp->session_id);
+	csr_roam_session_opened(mac, rsp->status, rsp->vdev_id);
 
-	if (QDF_IS_STATUS_SUCCESS(rsp->status) &&
-	    rsp->type == WMI_VDEV_TYPE_STA) {
-		csr_store_oce_cfg_flags_in_vdev(mac, mac->pdev,
-						rsp->session_id);
-		wlan_mlme_update_oce_flags(mac->pdev);
-	}
 	if (QDF_IS_STATUS_ERROR(rsp->status))
-		csr_cleanup_session(mac, rsp->session_id);
+		csr_cleanup_session(mac, rsp->vdev_id);
+
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_MAC_ID);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -16889,118 +16928,73 @@ void csr_get_vdev_type_nss(struct mac_context *mac_ctx,
 		break;
 	}
 	sme_debug("mode - %d: nss_2g - %d, 5g - %d",
-			dev_mode, *nss_2g, *nss_5g);
+		  dev_mode, *nss_2g, *nss_5g);
 }
 
 static
-QDF_STATUS csr_issue_add_sta_for_session_req(struct mac_context *mac,
+QDF_STATUS csr_issue_vdev_create_req(struct mac_context *mac,
-					     uint32_t sessionId,
+				     uint32_t vdev_id)
-					     tSirMacAddr sessionMacAddr,
-					     uint32_t type, uint32_t subType)
 {
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
-	struct add_sta_self_params *add_sta_self_req;
+	struct vdev_create_req_param *vdev_create_req;
-	struct wlan_mlme_qos *qos_aggr = &mac->mlme_cfg->qos_mlme_params;
+	struct scheduler_msg message = {0};
-	uint8_t nss_2g;
-	uint8_t nss_5g;
-	struct scheduler_msg msg = {0};
 
-	add_sta_self_req = qdf_mem_malloc(sizeof(struct add_sta_self_params));
+	vdev_create_req = qdf_mem_malloc(sizeof(*vdev_create_req));
-	if (!add_sta_self_req)
+	if (!vdev_create_req)
 		return QDF_STATUS_E_NOMEM;
 
-	if (!(mac->mlme_cfg)) {
+	vdev_create_req->vdev_id = vdev_id;
-		pe_err("Mlme cfg NULL");
+	/* Serialize the req through MC thread */
-		return QDF_STATUS_E_FAILURE;
+	message.type    = eWNI_SME_VDEV_CREATE_REQ;
+	message.bodyptr = vdev_create_req;
+	status = scheduler_post_message(QDF_MODULE_ID_SME, QDF_MODULE_ID_PE,
+					QDF_MODULE_ID_PE, &message);
+	if (!QDF_IS_STATUS_SUCCESS(status)) {
+		sme_err("scheduler_post_msg failed!(err=%d)", status);
+		qdf_mem_free(vdev_create_req);
+		status = QDF_STATUS_E_FAILURE;
 	}
 
-	csr_get_vdev_type_nss(mac, mac->sme.curr_device_mode,
-			      &nss_2g, &nss_5g);
-	qdf_mem_copy(add_sta_self_req->self_mac_addr, sessionMacAddr,
-		     sizeof(tSirMacAddr));
-	add_sta_self_req->curr_device_mode = mac->sme.curr_device_mode;
-	add_sta_self_req->session_id = sessionId;
-	add_sta_self_req->type = type;
-	add_sta_self_req->sub_type = subType;
-	add_sta_self_req->nss_2g = nss_2g;
-	add_sta_self_req->nss_5g = nss_5g;
-
-	add_sta_self_req->tx_aggregation_size = qos_aggr->tx_aggregation_size;
-	add_sta_self_req->tx_aggregation_size_be =
-			qos_aggr->tx_aggregation_size_be;
-	add_sta_self_req->tx_aggregation_size_bk =
-			qos_aggr->tx_aggregation_size_bk;
-	add_sta_self_req->tx_aggregation_size_vi =
-			qos_aggr->tx_aggregation_size_vi;
-	add_sta_self_req->tx_aggregation_size_vo =
-			qos_aggr->tx_aggregation_size_vo;
-
-	add_sta_self_req->rx_aggregation_size = qos_aggr->rx_aggregation_size;
-	add_sta_self_req->tx_aggr_sw_retry_threshold_be =
-			qos_aggr->tx_aggr_sw_retry_threshold_be;
-	add_sta_self_req->tx_aggr_sw_retry_threshold_bk =
-			qos_aggr->tx_aggr_sw_retry_threshold_bk;
-	add_sta_self_req->tx_aggr_sw_retry_threshold_vi =
-			qos_aggr->tx_aggr_sw_retry_threshold_vi;
-	add_sta_self_req->tx_aggr_sw_retry_threshold_vo =
-			qos_aggr->tx_aggr_sw_retry_threshold_vo;
-	add_sta_self_req->tx_aggr_sw_retry_threshold =
-			qos_aggr->tx_aggr_sw_retry_threshold;
-	add_sta_self_req->tx_non_aggr_sw_retry_threshold_be =
-			qos_aggr->tx_non_aggr_sw_retry_threshold_be;
-	add_sta_self_req->tx_non_aggr_sw_retry_threshold_bk =
-			qos_aggr->tx_non_aggr_sw_retry_threshold_bk;
-	add_sta_self_req->tx_non_aggr_sw_retry_threshold_vi =
-			qos_aggr->tx_non_aggr_sw_retry_threshold_vi;
-	add_sta_self_req->tx_non_aggr_sw_retry_threshold_vo =
-			qos_aggr->tx_non_aggr_sw_retry_threshold_vo;
-	add_sta_self_req->tx_non_aggr_sw_retry_threshold =
-			qos_aggr->tx_non_aggr_sw_retry_threshold;
-
-	add_sta_self_req->enable_bcast_probe_rsp =
-			mac->mlme_cfg->oce.enable_bcast_probe_rsp;
-	add_sta_self_req->fils_max_chan_guard_time =
-			mac->mlme_cfg->sta.fils_max_chan_guard_time;
-	add_sta_self_req->pkt_err_disconn_th =
-			mac->mlme_cfg->gen.dropped_pkt_disconnect_thresh;
-	add_sta_self_req->oce_feature_bitmap =
-			mac->mlme_cfg->oce.feature_bitmap;
-
-	msg.type = WMA_ADD_STA_SELF_REQ;
-	msg.reserved = 0;
-	msg.bodyptr = add_sta_self_req;
-	msg.bodyval = 0;
-
-	sme_debug(
-		"Send WMA_ADD_STA_SELF_REQ for selfMac=" QDF_MAC_ADDR_STR,
-		 QDF_MAC_ADDR_ARRAY(add_sta_self_req->self_mac_addr));
-	status = scheduler_post_message(QDF_MODULE_ID_SME,
-					QDF_MODULE_ID_WMA,
-					QDF_MODULE_ID_WMA, &msg);
-
-	if (status != QDF_STATUS_SUCCESS) {
-		sme_err("wma_post_ctrl_msg failed");
-		qdf_mem_free(add_sta_self_req);
-		add_sta_self_req = NULL;
-	}
 	return status;
 }
 
-QDF_STATUS csr_roam_open_session(struct mac_context *mac_ctx,
+QDF_STATUS csr_create_vdev(struct mac_context *mac_ctx,
-				 struct sme_session_params *session_param)
+			   struct wlan_objmgr_vdev *vdev,
+			   struct sme_session_params *session_param)
 {
 	QDF_STATUS status;
 	uint32_t existing_session_id;
 	struct mlme_ht_capabilities_info *ht_cap_info;
 	struct csr_roam_session *session;
 	struct mlme_vht_capabilities_info *vht_cap_info;
+	struct vdev_mlme_obj *vdev_mlme;
+	enum QDF_OPMODE op_mode;
 
 	if (!(mac_ctx->mlme_cfg)) {
-		pe_err("invalid mlme cfg");
+		sme_err("invalid mlme cfg");
 		return QDF_STATUS_E_FAILURE;
 	}
 	vht_cap_info = &mac_ctx->mlme_cfg->vht_caps.vht_cap_info;
 
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
+	if (!vdev_mlme) {
+		sme_err("Failed to get cmpt obj");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	op_mode = wlan_vdev_mlme_get_opmode(vdev);
+	csr_get_vdev_type_nss(mac_ctx, op_mode,
+			      &vdev_mlme->proto.generic.nss_2g,
+			      &vdev_mlme->proto.generic.nss_5g);
+
+	status = cds_get_vdev_types(op_mode,
+				    &vdev_mlme->mgmt.generic.type,
+				    &vdev_mlme->mgmt.generic.subtype);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		sme_err("Get vdev type failed; status:%d", status);
+		return status;
+	}
+
 	/* check to see if the mac address already belongs to a session */
 	status = csr_roam_get_session_id_from_bssid(mac_ctx,
 			(struct qdf_mac_addr *)session_param->self_mac_addr,
@@ -17013,22 +17007,22 @@ QDF_STATUS csr_roam_open_session(struct mac_context *mac_ctx,
 	}
 
 	/* attempt to retrieve session for Id */
-	session = CSR_GET_SESSION(mac_ctx, session_param->sme_session_id);
+	session = CSR_GET_SESSION(mac_ctx, session_param->vdev_id);
 	if (!session) {
 		sme_err("Session does not exist for interface %d",
-			session_param->sme_session_id);
+			session_param->vdev_id);
 		return QDF_STATUS_E_FAILURE;
 	}
 
 	/* check to see if the session is already active */
 	if (session->sessionActive) {
 		sme_err("Cannot re-open active session with Id %d",
-			session_param->sme_session_id);
+			session_param->vdev_id);
 		return QDF_STATUS_E_FAILURE;
 	}
 
 	session->sessionActive = true;
-	session->sessionId = session_param->sme_session_id;
+	session->sessionId = session_param->vdev_id;
 
 	/* Initialize FT related data structures only in STA mode */
 	sme_ft_open(MAC_HANDLE(mac_ctx), session->sessionId);
@@ -17095,13 +17089,9 @@ QDF_STATUS csr_roam_open_session(struct mac_context *mac_ctx,
 	 * Do not advertise requester role for SAP & responder role
 	 * for STA
 	 */
-	csr_init_session_twt_cap(session, session_param->type_of_persona);
+	csr_init_session_twt_cap(session, vdev_mlme->mgmt.generic.type);
 
-	return csr_issue_add_sta_for_session_req(mac_ctx,
+	return csr_issue_vdev_create_req(mac_ctx, session->sessionId);
-				session_param->sme_session_id,
-				session_param->self_mac_addr,
-				session_param->type_of_persona,
-				session_param->subtype_of_persona);
 }
 
 QDF_STATUS csr_process_del_sta_session_rsp(struct mac_context *mac_ctx,

core/sme/src/csr/csr_inside_api.h

@@ -248,6 +248,17 @@ csr_roam_save_connected_information(struct mac_context *mac,
 void csr_roam_check_for_link_status_change(struct mac_context *mac,
 					tSirSmeRsp *pSirMsg);
 
+/**
+ * csr_vdev_create_resp() - Vdev create response handler
+ * @mac_ctx: global mac context
+ * @pMsg: pointer to response data
+ *
+ * This API handles vdev create response.
+ *
+ * Return: QDF_STATUS_SUCCESS or QDF_STATUS_E_FAILURE
+ */
+QDF_STATUS csr_vdev_create_resp(struct mac_context *mac, uint8_t *pmsg);
+
 QDF_STATUS csr_roam_issue_start_bss(struct mac_context *mac, uint32_t sessionId,
 				    struct csr_roamstart_bssparams *pParam,
 				    struct csr_roam_profile *pProfile,
@@ -355,8 +366,6 @@ QDF_STATUS csr_save_to_channel_power2_g_5_g(struct mac_context *mac,
 					*channelTable);
 QDF_STATUS csr_roam_set_key(struct mac_context *mac, uint32_t sessionId,
 			    tCsrRoamSetKey *pSetKey, uint32_t roamId);
-QDF_STATUS csr_roam_open_session(struct mac_context *mac,
-				 struct sme_session_params *session_param);
 QDF_STATUS csr_roam_close_session(struct mac_context *mac_ctx,
 				  uint32_t session_id, bool sync);
 void csr_cleanup_session(struct mac_context *mac, uint32_t sessionId);
@@ -1017,6 +1026,17 @@ uint8_t
 csr_scan_get_channel_for_hw_mode_change(
 	struct mac_context *mac_ctx, uint32_t session_id,
 	struct csr_roam_profile *profile);
+/**
+ * csr_create_vdev() - API to create vdev
+ * @mac_ctx: pointer to mac context
+ * @vdev: vdev object
+ * @session_param: Session params
+ *
+ * Returns: QDF_STATUS
+ */
+QDF_STATUS csr_create_vdev(struct mac_context *mac,
+			   struct wlan_objmgr_vdev *vdev,
+			   struct sme_session_params *session_param);
 
 #ifdef FEATURE_WLAN_DIAG_SUPPORT_CSR
 /**

core/wma/inc/wma_api.h

@@ -266,23 +266,44 @@ void wma_process_pdev_hw_mode_trans_ind(void *wma,
  */
 QDF_STATUS wma_set_cts2self_for_p2p_go(void *wma_handle,
 		uint32_t cts2self_for_p2p_go);
-QDF_STATUS wma_set_tx_rx_aggregation_size
-	(struct sir_set_tx_rx_aggregation_size *tx_rx_aggregation_size);
 
 /**
- * wma_set_tx_rx_aggregation_size_per_ac() - set aggregation size per ac
+ * wma_set_tx_rx_aggr_size() - set tx rx aggregation size
- * @tx_rx_aggregation_size: the parameter for aggregation size
+ * @vdev_id: vdev id
+ * @tx_size: tx aggr size
+ * @rx_size: rx aggr size
+ * @aggr_type: aggregation type
  *
- *  This function try to set the aggregation size per AC.
+ *  This function try to set the aggregation size.
  *
  *  Return: QDF_STATUS enumeration
  */
-QDF_STATUS wma_set_tx_rx_aggregation_size_per_ac
+QDF_STATUS wma_set_tx_rx_aggr_size(uint8_t vdev_id,
-	(struct sir_set_tx_rx_aggregation_size *tx_rx_aggregation_size);
+				   uint32_t tx_size,
+				   uint32_t rx_size,
+				   wmi_vdev_custom_aggr_type_t aggr_type);
+/**
+ * wma_set_tx_rx_aggr_size_per_ac() - set aggregation size per ac
+ * @wma_handle: pointer to wma handle.
+ * @vdev_id: vdev_id
+ * @qos_aggr: QoS data
+ * @aggr_type: aggregation type
+ *
+ * This function try to set the aggregation size per AC.
+ *
+ * Return: QDF_STATUS enumeration
+ */
+QDF_STATUS
+wma_set_tx_rx_aggr_size_per_ac(WMA_HANDLE wma_handle,
+			       uint8_t vdev_id,
+			       struct wlan_mlme_qos *qos_aggr,
+			       wmi_vdev_custom_aggr_type_t aggr_type);
+
 /**
  * wma_set_sw_retry_threshold_per_ac() - set sw retry threshold per AC for tx
  * @handle: wma handle
- * @tx_sw_retry_threshold: value needs to set to firmware
+ * @vdev_id: vdev id
+ * @qos_aggr: pointer to QOS TX/RX aggregation values
  *
  * This function sends WMI command to set the sw retry threshold per AC
  * for Tx.
@@ -291,19 +312,20 @@ QDF_STATUS wma_set_tx_rx_aggregation_size_per_ac
  */
 QDF_STATUS wma_set_sw_retry_threshold_per_ac
 	(WMA_HANDLE handle,
-	 struct sir_set_tx_sw_retry_threshold *tx_sw_retry_threshold);
+	 uint8_t vdev_id, struct wlan_mlme_qos *qos_aggr);
 /**
  * wma_set_sw_retry_threshold() - set sw retry threshold for tx
  * @vdev_id: vdev
  * @retry: retry number
- * @param: for aggregation or non-aggregation
+ * @param_id: aggregrate sw retry threshold param id
  *
  * This function sends WMI command to set the sw retry threshold for Tx.
  *
  * Return: QDF_STATUS.
  */
 QDF_STATUS wma_set_sw_retry_threshold(uint8_t vdev_id, uint32_t retry,
-				      uint32_t param);
+				      uint32_t param_id);
+
 /**
  * wma_get_sar_limit() - get SAR limits from the target
  * @handle: wma handle
@@ -576,6 +598,17 @@ QDF_STATUS wma_ap_mlme_vdev_stop_start_send(struct vdev_mlme_obj *vdev_mlme,
  */
 QDF_STATUS wma_sta_mlme_vdev_down_send(struct vdev_mlme_obj *vdev_mlme,
 				       uint16_t data_len, void *data);
+/**
+ * wma_post_vdev_create_setup() - Post vdev create setup
+ * @vdev: vdev obj
+ *
+ * This API is invoked after vded is created to perform post
+ * vdev create operations i.e. creating peer and setting vdev params.
+ *
+ * Return: SUCCESS on successful post vdev operations, FAILURE, if it
+ *         fails due to any
+ */
+QDF_STATUS wma_post_vdev_create_setup(struct wlan_objmgr_vdev *vdev);
 
 /**
  * wma_mon_mlme_vdev_start_continue() - VDEV start response handling

core/wma/inc/wma_if.h

@@ -875,60 +875,13 @@ typedef struct sMaxTxPowerPerBandParams {
 } tMaxTxPowerPerBandParams, *tpMaxTxPowerPerBandParams;
 
 /**
- * struct add_sta_self_params - Add Sta Self params
+ * struct vdev_create_req_param - vdev create request params
- * @self_mac_addr: self MAC Address
+ * @vdev_id: vdev_id
- * @curr_device_mode: operating device mode
- * @type: Vdev Type
- * @sub_type: Vdev Sub Type
- * @session_id: SME Session ID
- * @nss_2g: vdev nss in 2.4G
- * @nss_5g: vdev nss in 5G
  * @status: response status code
- * @tx_aggregation_size: Tx aggregation size
- * @rx_aggregation_size: Rx aggregation size
- * @enable_bcast_probe_rsp: enable broadcast probe response
- * @fils_max_chan_guard_time: FILS max channel guard time
- * @pkt_err_disconn_th: packet drop threshold
- * @tx_aggr_sw_retry_threshold_be: aggr sw retry threshold for be
- * @tx_aggr_sw_retry_threshold_bk: aggr sw retry threshold for bk
- * @tx_aggr_sw_retry_threshold_vi: aggr sw retry threshold for vi
- * @tx_aggr_sw_retry_threshold_vo: aggr sw retry threshold for vo
- * @tx_aggr_sw_retry_threshold: aggr sw retry threshold
- * @tx_non_aggr_sw_retry_threshold_be: non aggr sw retry threshold for be
- * @tx_non_aggr_sw_retry_threshold_bk: non aggr sw retry threshold for bk
- * @tx_non_aggr_sw_retry_threshold_vi: non aggr sw retry threshold for vi
- * @tx_non_aggr_sw_retry_threshold_vo: non aggr sw retry threshold for vo
- * @tx_non_aggr_sw_retry_threshold: non aggr sw retry threshold
  */
-struct add_sta_self_params {
+struct vdev_create_req_param {
-	tSirMacAddr self_mac_addr;
+	uint32_t vdev_id;
-	enum QDF_OPMODE curr_device_mode;
+	QDF_STATUS status;
-	uint32_t type;
-	uint32_t sub_type;
-	uint8_t session_id;
-	uint8_t nss_2g;
-	uint8_t nss_5g;
-	uint32_t status;
-	uint32_t tx_aggregation_size;
-	uint32_t tx_aggregation_size_be;
-	uint32_t tx_aggregation_size_bk;
-	uint32_t tx_aggregation_size_vi;
-	uint32_t tx_aggregation_size_vo;
-	uint32_t rx_aggregation_size;
-	bool enable_bcast_probe_rsp;
-	uint8_t fils_max_chan_guard_time;
-	uint16_t pkt_err_disconn_th;
-	uint8_t oce_feature_bitmap;
-	uint32_t tx_aggr_sw_retry_threshold_be;
-	uint32_t tx_aggr_sw_retry_threshold_bk;
-	uint32_t tx_aggr_sw_retry_threshold_vi;
-	uint32_t tx_aggr_sw_retry_threshold_vo;
-	uint32_t tx_aggr_sw_retry_threshold;
-	uint32_t tx_non_aggr_sw_retry_threshold_be;
-	uint32_t tx_non_aggr_sw_retry_threshold_bk;
-	uint32_t tx_non_aggr_sw_retry_threshold_vi;
-	uint32_t tx_non_aggr_sw_retry_threshold_vo;
-	uint32_t tx_non_aggr_sw_retry_threshold;
 };
 
 /**

core/wma/inc/wma_internal.h

@@ -641,10 +641,6 @@ __wma_handle_vdev_stop_rsp(wmi_vdev_stopped_event_fixed_param *resp_event);
 int wma_vdev_stop_resp_handler(void *handle, uint8_t *cmd_param_info,
 				      uint32_t len);
 
-struct cdp_vdev *wma_vdev_attach(tp_wma_handle wma_handle,
-				struct add_sta_self_params *self_sta_req,
-				uint8_t generateRsp);
-
 QDF_STATUS wma_vdev_start(tp_wma_handle wma, struct wma_vdev_start_req *req,
 			  bool isRestart);
 

core/wma/inc/wma_types.h

@@ -116,7 +116,6 @@
 
 #define WMA_ADD_STA_REQ                SIR_HAL_ADD_STA_REQ
 #define WMA_ADD_STA_RSP                SIR_HAL_ADD_STA_RSP
-#define WMA_ADD_STA_SELF_RSP           SIR_HAL_ADD_STA_SELF_RSP
 #define WMA_DELETE_STA_REQ             SIR_HAL_DELETE_STA_REQ
 #define WMA_DELETE_STA_RSP             SIR_HAL_DELETE_STA_RSP
 #define WMA_ADD_BSS_REQ                SIR_HAL_ADD_BSS_REQ
@@ -208,7 +207,6 @@
 #ifdef WLAN_NS_OFFLOAD
 #define WMA_SET_NS_OFFLOAD             SIR_HAL_SET_NS_OFFLOAD
 #endif /* WLAN_NS_OFFLOAD */
-#define WMA_ADD_STA_SELF_REQ           SIR_HAL_ADD_STA_SELF_REQ
 #define WMA_DEL_STA_SELF_REQ           SIR_HAL_DEL_STA_SELF_REQ
 
 #ifdef FEATURE_WLAN_TDLS

core/wma/src/wma_dev_if.c

@@ -188,45 +188,6 @@ struct cdp_vdev *wma_find_vdev_by_bssid(tp_wma_handle wma, uint8_t *bssid,
 	return NULL;
 }
 
-/**
- * wma_get_txrx_vdev_type() - return operating mode of vdev
- * @type: vdev_type
- *
- * Return: return operating mode as enum wlan_op_mode type
- */
-static enum wlan_op_mode wma_get_txrx_vdev_type(uint32_t type)
-{
-	enum wlan_op_mode vdev_type = wlan_op_mode_unknown;
-
-	switch (type) {
-	case WMI_VDEV_TYPE_AP:
-		vdev_type = wlan_op_mode_ap;
-		break;
-	case WMI_VDEV_TYPE_STA:
-		vdev_type = wlan_op_mode_sta;
-		break;
-#ifdef QCA_IBSS_SUPPORT
-	case WMI_VDEV_TYPE_IBSS:
-		vdev_type = wlan_op_mode_ibss;
-		break;
-#endif /* QCA_IBSS_SUPPORT */
-	case WMI_VDEV_TYPE_OCB:
-		vdev_type = wlan_op_mode_ocb;
-		break;
-	case WMI_VDEV_TYPE_MONITOR:
-		vdev_type = wlan_op_mode_monitor;
-		break;
-	case WMI_VDEV_TYPE_NDI:
-		vdev_type = wlan_op_mode_ndi;
-		break;
-	default:
-		WMA_LOGE("Invalid vdev type %u", type);
-		vdev_type = wlan_op_mode_unknown;
-	}
-
-	return vdev_type;
-}
-
 /**
  * wma_find_req_on_timer_expiry() - find request by address
  * @wma: wma handle
@@ -692,13 +653,12 @@ error:
 
 static void
 wma_cdp_vdev_detach(ol_txrx_soc_handle soc,
-			tp_wma_handle wma_handle,
+		    tp_wma_handle wma_handle,
-			uint8_t vdev_id)
+		    uint8_t vdev_id)
 {
 	struct wma_txrx_node *iface = &wma_handle->interfaces[vdev_id];
 
-	cdp_vdev_detach(soc,
+	cdp_vdev_detach(soc, iface->handle, NULL, NULL);
-		iface->handle, NULL, NULL);
 	iface->handle = NULL;
 }
 
@@ -769,7 +729,7 @@ static QDF_STATUS wma_handle_vdev_detach(tp_wma_handle wma_handle,
 		goto out;
 	}
 
-	WMA_LOGD("vdev_id:%hu vdev_hdl:%pK", vdev_id, iface->handle);
+	WMA_LOGD("vdev_id:%hu", vdev_id);
 	if (!generate_rsp) {
 		WMA_LOGE("Call txrx detach w/o callback for vdev %d", vdev_id);
 		goto out;
@@ -793,6 +753,7 @@ static QDF_STATUS wma_handle_vdev_detach(tp_wma_handle wma_handle,
 				     WMA_FW_RSP_EVENT_WAKE_LOCK_DURATION);
 	}
 	WMA_LOGD("Call txrx detach with callback for vdev %d", vdev_id);
+	wlan_vdev_set_dp_handle(iface->vdev, NULL);
 	wma_release_vdev_ref(iface);
 	wma_cdp_vdev_detach(soc, wma_handle, vdev_id);
 
@@ -807,6 +768,7 @@ static QDF_STATUS wma_handle_vdev_detach(tp_wma_handle wma_handle,
 out:
 	WMA_LOGE("Call txrx detach callback for vdev %d, generate_rsp %u",
 		vdev_id, generate_rsp);
+	wlan_vdev_set_dp_handle(iface->vdev, NULL);
 	wma_release_vdev_ref(iface);
 	wma_cdp_vdev_detach(soc, wma_handle, vdev_id);
 
@@ -981,6 +943,7 @@ QDF_STATUS wma_vdev_detach(tp_wma_handle wma_handle,
 	 * CDP Vdev.
 	 */
 	if (!cds_is_target_ready()) {
+		wlan_vdev_set_dp_handle(iface->vdev, NULL);
 		wma_release_vdev_and_peer_ref(wma_handle, iface);
 		wma_cdp_vdev_detach(soc, wma_handle, vdev_id);
 		goto send_rsp;
@@ -1527,7 +1490,7 @@ wma_vdev_set_param(wmi_unified_t wmi_handle, uint32_t if_id,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	param.if_id = if_id;
+	param.vdev_id = if_id;
 	param.param_id = param_id;
 	param.param_value = param_value;
 
@@ -1564,16 +1527,19 @@ QDF_STATUS wma_set_peer_param(void *wma_ctx, uint8_t *peer_addr,
 {
 	tp_wma_handle wma_handle = (tp_wma_handle) wma_ctx;
 	struct peer_set_params param = {0};
-	int err;
+	QDF_STATUS status;
 
 	param.vdev_id = vdev_id;
 	param.param_value = param_value;
 	param.param_id = param_id;
 
-	err = wmi_set_peer_param_send(wma_handle->wmi_handle, peer_addr,
+	status = wmi_set_peer_param_send(wma_handle->wmi_handle,
-					   &param);
+					 peer_addr,
-
+					 &param);
-	return err;
+	if (QDF_IS_STATUS_ERROR(status))
+		WMA_LOGE("vdev_id: %d peer set failed, id %d, val %d",
+			 vdev_id, param_id, param_value);
+	return status;
 }
 
 /**
@@ -2675,280 +2641,174 @@ int wma_vdev_stop_resp_handler(void *handle, uint8_t *cmd_param_info,
 	return 0;
 }
 
-/**
+QDF_STATUS wma_post_vdev_create_setup(struct wlan_objmgr_vdev *vdev)
- * wma_vdev_attach() - create vdev in fw
- * @wma_handle: wma handle
- * @self_sta_req: self sta request
- * @generateRsp: generate response
- *
- * This function creates vdev in target and
- * attach this vdev to txrx module. It also set
- * vdev related params to fw.
- *
- * Return: txrx vdev handle
- */
-struct cdp_vdev *wma_vdev_attach(tp_wma_handle wma_handle,
-				struct add_sta_self_params *self_sta_req,
-				uint8_t generateRsp)
 {
 	struct cdp_vdev *txrx_vdev_handle = NULL;
 	struct cdp_pdev *txrx_pdev = cds_get_context(QDF_MODULE_ID_TXRX);
-	enum wlan_op_mode txrx_vdev_type;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
 	uint32_t cfg_val;
 	uint8_t mcc_adapt_sch;
 	QDF_STATUS ret;
 	struct mlme_ht_capabilities_info *ht_cap_info;
-	struct scheduler_msg sme_msg = { 0 };
-	struct vdev_create_params params = { 0 };
 	u_int8_t vdev_id;
-	struct sir_set_tx_rx_aggregation_size tx_rx_aggregation_size;
-	struct sir_set_tx_sw_retry_threshold tx_sw_retry_threshold;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	struct wlan_objmgr_peer *obj_peer;
-	struct wlan_objmgr_vdev *vdev;
+	struct wlan_mlme_qos *qos_aggr;
-	uint32_t retry;
+	struct vdev_mlme_obj *vdev_mlme;
+	tp_wma_handle wma_handle;
 
-	qdf_mem_zero(&tx_rx_aggregation_size, sizeof(tx_rx_aggregation_size));
-	WMA_LOGD("mac %pM, vdev_id %hu, type %d, sub_type %d, nss 2g %d, 5g %d",
-		self_sta_req->self_mac_addr, self_sta_req->session_id,
-		self_sta_req->type, self_sta_req->sub_type,
-		self_sta_req->nss_2g, self_sta_req->nss_5g);
 	if (!mac) {
 		WMA_LOGE("%s: Failed to get mac", __func__);
-		status = QDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
-		goto end;
 	}
 
-	vdev_id = self_sta_req->session_id;
+	wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
-	if (wma_is_vdev_valid(vdev_id)) {
+	if (!wma_handle) {
-		WMA_LOGE("%s: vdev %d already active", __func__, vdev_id);
+		WMA_LOGE("%s: WMA context is invalid", __func__);
-		status = QDF_STATUS_E_FAILURE;
+		return QDF_STATUS_E_FAILURE;
-		goto end;
 	}
 
-	params.if_id = self_sta_req->session_id;
+	if (!soc) {
-	params.type = self_sta_req->type;
+		WMA_LOGE("%s: SOC context is invalid", __func__);
-	params.subtype = self_sta_req->sub_type;
+		return QDF_STATUS_E_FAILURE;
-	params.nss_2g = self_sta_req->nss_2g;
-	params.nss_5g = self_sta_req->nss_5g;
-
-	/* Create a vdev in target */
-	ret = wmi_unified_vdev_create_send(wma_handle->wmi_handle,
-					   self_sta_req->self_mac_addr,
-					   &params);
-	if (QDF_IS_STATUS_ERROR(ret)) {
-		WMA_LOGE("%s: Unable to add an interface for ath_dev",
-			 __func__);
-		status = QDF_STATUS_E_FAILURE;
-		goto end;
 	}
 
-	txrx_vdev_type = wma_get_txrx_vdev_type(self_sta_req->type);
+	if (wlan_objmgr_vdev_try_get_ref(vdev, WLAN_LEGACY_WMA_ID) !=
+		QDF_STATUS_SUCCESS)
+		return QDF_STATUS_E_FAILURE;
 
-	if (wlan_op_mode_unknown == txrx_vdev_type) {
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
-		WMA_LOGE("Failed to get txrx vdev type");
+	if (!vdev_mlme) {
-		wmi_unified_vdev_delete_send(wma_handle->wmi_handle,
+		WMA_LOGE("%s: Failed to get vdev mlme obj!", __func__);
-					     self_sta_req->session_id);
+		return QDF_STATUS_E_FAILURE;
-		status = QDF_STATUS_E_FAILURE;
-		goto end;
 	}
 
-	txrx_vdev_handle = cdp_vdev_attach(soc, txrx_pdev,
+	vdev_id = wlan_vdev_get_id(vdev);
-					   self_sta_req->self_mac_addr,
+	txrx_vdev_handle = wlan_vdev_get_dp_handle(vdev);
-					   vdev_id, txrx_vdev_type);
-
-	WMA_LOGD("vdev_id %hu, txrx_vdev_handle = %pK", vdev_id,
-		 txrx_vdev_handle);
-
-	if (!txrx_vdev_handle) {
-		WMA_LOGE("%s: cdp_vdev_attach failed", __func__);
-		status = QDF_STATUS_E_FAILURE;
-		wmi_unified_vdev_delete_send(wma_handle->wmi_handle,
-					     self_sta_req->session_id);
-		goto end;
-	}
 
 	wma_handle->interfaces[vdev_id].vdev_active = true;
 	wma_handle->interfaces[vdev_id].handle = txrx_vdev_handle;
 	wma_vdev_update_pause_bitmap(vdev_id, 0);
 
-	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(wma_handle->psoc, vdev_id,
-						    WLAN_LEGACY_WMA_ID);
-	if (!vdev) {
-		WMA_LOGE(FL("vdev obj is NULL for vdev_id: %u"), vdev_id);
-		status = QDF_STATUS_E_FAILURE;
-		wma_handle->interfaces[vdev_id].vdev_active = false;
-		wmi_unified_vdev_delete_send(wma_handle->wmi_handle, vdev_id);
-		goto end;
-	}
-
 	wma_handle->interfaces[vdev_id].vdev = vdev;
+	wma_handle->interfaces[vdev_id].type =
+		vdev_mlme->mgmt.generic.type;
+	wma_handle->interfaces[vdev_id].sub_type =
+		vdev_mlme->mgmt.generic.subtype;
 
 	qdf_mem_copy(wma_handle->interfaces[vdev_id].addr,
-		     self_sta_req->self_mac_addr,
+		     vdev->vdev_mlme.macaddr,
 		     sizeof(wma_handle->interfaces[vdev_id].addr));
 
-	tx_rx_aggregation_size.tx_aggregation_size =
+	qos_aggr = &mac->mlme_cfg->qos_mlme_params;
-				self_sta_req->tx_aggregation_size;
+	status = wma_set_tx_rx_aggr_size(vdev_id, qos_aggr->tx_aggregation_size,
-	tx_rx_aggregation_size.rx_aggregation_size =
+					 qos_aggr->rx_aggregation_size,
-				self_sta_req->rx_aggregation_size;
+					 WMI_VDEV_CUSTOM_AGGR_TYPE_AMPDU);
-	tx_rx_aggregation_size.vdev_id = self_sta_req->session_id;
+	if (QDF_IS_STATUS_ERROR(status))
-	tx_rx_aggregation_size.aggr_type = WMI_VDEV_CUSTOM_AGGR_TYPE_AMPDU;
+		WMA_LOGE("failed to set aggregation sizes(status = %d)",
+			 status);
 
-	ret = wma_set_tx_rx_aggregation_size(&tx_rx_aggregation_size);
+	if (wma_vdev_uses_self_peer(vdev_mlme->mgmt.generic.type,
-	if (QDF_IS_STATUS_ERROR(ret))
+				    vdev_mlme->mgmt.generic.subtype)) {
-		WMA_LOGE("failed to set aggregation sizes(err=%d)", ret);
+		ret = wma_create_peer(wma_handle, txrx_pdev, txrx_vdev_handle,
+				      vdev->vdev_mlme.macaddr,
+				      WMI_PEER_TYPE_DEFAULT,
+				      vdev_id, false);
+		if (QDF_IS_STATUS_ERROR(ret)) {
+			WMA_LOGE("%s: Failed to create peer", __func__);
+			goto end;
+		}
+	} else if (vdev_mlme->mgmt.generic.type == WMI_VDEV_TYPE_STA) {
+		status = wma_set_tx_rx_aggr_size_per_ac(
+					wma_handle, vdev_id,
+					qos_aggr,
+					WMI_VDEV_CUSTOM_AGGR_TYPE_AMPDU);
 
-	tx_rx_aggregation_size.tx_aggregation_size_be =
+		if (QDF_IS_STATUS_ERROR(status))
-				self_sta_req->tx_aggregation_size_be;
+			WMA_LOGE("failed to set aggr size per ac(status = %d)",
-	tx_rx_aggregation_size.tx_aggregation_size_bk =
+				 status);
-				self_sta_req->tx_aggregation_size_bk;
-	tx_rx_aggregation_size.tx_aggregation_size_vi =
-				self_sta_req->tx_aggregation_size_vi;
-	tx_rx_aggregation_size.tx_aggregation_size_vo =
-				self_sta_req->tx_aggregation_size_vo;
 
-	tx_sw_retry_threshold.tx_aggr_sw_retry_threshold_be =
+		wma_set_sta_keep_alive(
-				self_sta_req->tx_aggr_sw_retry_threshold_be;
+				wma_handle, vdev_id,
-	tx_sw_retry_threshold.tx_aggr_sw_retry_threshold_bk =
+				SIR_KEEP_ALIVE_NULL_PKT,
-				self_sta_req->tx_aggr_sw_retry_threshold_bk;
+				mac->mlme_cfg->sta.sta_keep_alive_period,
-	tx_sw_retry_threshold.tx_aggr_sw_retry_threshold_vi =
+				NULL, NULL, NULL);
-				self_sta_req->tx_aggr_sw_retry_threshold_vi;
-	tx_sw_retry_threshold.tx_aggr_sw_retry_threshold_vo =
-				self_sta_req->tx_aggr_sw_retry_threshold_vo;
-	tx_sw_retry_threshold.tx_aggr_sw_retry_threshold =
-				self_sta_req->tx_aggr_sw_retry_threshold;
-
-	tx_sw_retry_threshold.tx_non_aggr_sw_retry_threshold_be =
-				self_sta_req->tx_non_aggr_sw_retry_threshold_be;
-	tx_sw_retry_threshold.tx_non_aggr_sw_retry_threshold_bk =
-				self_sta_req->tx_non_aggr_sw_retry_threshold_bk;
-	tx_sw_retry_threshold.tx_non_aggr_sw_retry_threshold_vi =
-				self_sta_req->tx_non_aggr_sw_retry_threshold_vi;
-	tx_sw_retry_threshold.tx_non_aggr_sw_retry_threshold_vo =
-				self_sta_req->tx_non_aggr_sw_retry_threshold_vo;
-	tx_sw_retry_threshold.tx_non_aggr_sw_retry_threshold =
-				self_sta_req->tx_non_aggr_sw_retry_threshold;
-
-	tx_sw_retry_threshold.vdev_id = self_sta_req->session_id;
-
-
-	switch (self_sta_req->type) {
-	case WMI_VDEV_TYPE_STA:
-		ret = wma_set_tx_rx_aggregation_size_per_ac(
-						&tx_rx_aggregation_size);
-		if (QDF_IS_STATUS_ERROR(ret))
-			WMA_LOGE("set aggr sizes per ac(err=%d) failed", ret);
-
-		cfg_val = mac->mlme_cfg->sta.sta_keep_alive_period;
-		wma_set_sta_keep_alive(wma_handle,
-				       self_sta_req->session_id,
-				       SIR_KEEP_ALIVE_NULL_PKT,
-				       cfg_val, NULL, NULL, NULL);
 
 		/* offload STA SA query related params to fwr */
 		if (wmi_service_enabled(wma_handle->wmi_handle,
-			wmi_service_sta_pmf_offload)) {
+					wmi_service_sta_pmf_offload)) {
 			wma_set_sta_sa_query_param(wma_handle, vdev_id);
 		}
 
-		vdev_id = tx_sw_retry_threshold.vdev_id;
+		status = wma_set_sw_retry_threshold(
-		retry = tx_sw_retry_threshold.tx_aggr_sw_retry_threshold;
+					vdev_id,
-		if (retry) {
+					qos_aggr->tx_aggr_sw_retry_threshold,
-			ret = wma_set_sw_retry_threshold(vdev_id, retry,
 					WMI_PDEV_PARAM_AGG_SW_RETRY_TH);
-			if (QDF_IS_STATUS_ERROR(ret))
+		if (QDF_IS_STATUS_ERROR(status))
-				WMA_LOGE("failed set agg retry threshold");
+			WMA_LOGE("failed to set sw retry threshold (status = %d)",
-		}
+				 status);
 
-		retry = tx_sw_retry_threshold.tx_non_aggr_sw_retry_threshold;
+		status = wma_set_sw_retry_threshold(
-		if (retry) {
+				vdev_id,
-			ret = wma_set_sw_retry_threshold(vdev_id, retry,
+				qos_aggr->tx_non_aggr_sw_retry_threshold,
-					WMI_PDEV_PARAM_NON_AGG_SW_RETRY_TH);
+				WMI_PDEV_PARAM_AGG_SW_RETRY_TH);
-			if (QDF_IS_STATUS_ERROR(ret))
+		if (QDF_IS_STATUS_ERROR(status))
-				WMA_LOGE("failed set non-agg retry threshold");
+			WMA_LOGE("failed to set sw retry threshold tx non aggr(status = %d)",
-		}
+				 status);
 
-		ret = wma_set_sw_retry_threshold_per_ac(wma_handle,
+		status = wma_set_sw_retry_threshold_per_ac(wma_handle, vdev_id,
-						&tx_sw_retry_threshold);
+							   qos_aggr);
-		if (QDF_IS_STATUS_ERROR(ret))
+		if (QDF_IS_STATUS_ERROR(status))
-			WMA_LOGE("failed to set retry threshold(err=%d)", ret);
+			WMA_LOGE("failed to set sw retry threshold per ac(status = %d)",
-		break;
+				 status);
-	}
 
-	wma_handle->interfaces[vdev_id].type = self_sta_req->type;
-	wma_handle->interfaces[vdev_id].sub_type = self_sta_req->sub_type;
-	qdf_atomic_init(&wma_handle->interfaces[vdev_id].bss_status);
-
-	if (wma_vdev_uses_self_peer(self_sta_req->type,
-				    self_sta_req->sub_type)) {
-		ret = wma_create_peer(wma_handle, txrx_pdev, txrx_vdev_handle,
-				      self_sta_req->self_mac_addr,
-				      WMI_PEER_TYPE_DEFAULT,
-				      self_sta_req->session_id, false);
-		if (QDF_IS_STATUS_ERROR(ret)) {
-			WMA_LOGE("%s: Failed to create peer", __func__);
-			status = QDF_STATUS_E_FAILURE;
-			wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_WMA_ID);
-			wmi_unified_vdev_delete_send(wma_handle->wmi_handle,
-						     self_sta_req->session_id);
-			wma_handle->interfaces[vdev_id].vdev_active = false;
-			wma_cdp_vdev_detach(soc, wma_handle, vdev_id);
-			wma_handle->interfaces[vdev_id].vdev = NULL;
-			txrx_vdev_handle = NULL;
-			goto end;
-		}
-	} else if (self_sta_req->type == WMI_VDEV_TYPE_STA) {
 		obj_peer = wma_create_objmgr_peer(wma_handle, vdev_id,
-						  self_sta_req->self_mac_addr,
+						  vdev->vdev_mlme.macaddr,
 						  WMI_PEER_TYPE_DEFAULT);
 		if (!obj_peer) {
 			WMA_LOGE("%s: Failed to create obj mgr peer for self sta",
 				 __func__);
-			status = QDF_STATUS_E_FAILURE;
-			wmi_unified_vdev_delete_send(wma_handle->wmi_handle,
-						     self_sta_req->session_id);
-			wma_handle->interfaces[vdev_id].vdev_active = false;
-			wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_WMA_ID);
-			wma_handle->interfaces[vdev_id].vdev = NULL;
-			wma_cdp_vdev_detach(soc, wma_handle, vdev_id);
-			txrx_vdev_handle = NULL;
 			goto end;
 		}
 	}
 
 	WMA_LOGD("Setting WMI_VDEV_PARAM_DISCONNECT_TH: %d",
-		 self_sta_req->pkt_err_disconn_th);
+		 mac->mlme_cfg->gen.dropped_pkt_disconnect_thresh);
-	ret = wma_vdev_set_param(wma_handle->wmi_handle, vdev_id,
+	status  = wma_vdev_set_param(
-				 WMI_VDEV_PARAM_DISCONNECT_TH,
+			wma_handle->wmi_handle, vdev_id,
-				 self_sta_req->pkt_err_disconn_th);
+			WMI_VDEV_PARAM_DISCONNECT_TH,
-	if (ret)
+			mac->mlme_cfg->gen.dropped_pkt_disconnect_thresh);
-		WMA_LOGE("Failed to set WMI_VDEV_PARAM_DISCONNECT_TH");
+	if (QDF_IS_STATUS_ERROR(status))
+		WMA_LOGE("failed to set DISCONNECT_TH(status = %d)", status);
 
-	ret = wma_vdev_set_param(wma_handle->wmi_handle,
+	status = wma_vdev_set_param(
-				self_sta_req->session_id,
+			wma_handle->wmi_handle,
-				WMI_VDEV_PARAM_MCC_RTSCTS_PROTECTION_ENABLE,
+			vdev_id,
-				mac->roam.configParam.mcc_rts_cts_prot_enable);
+			WMI_VDEV_PARAM_MCC_RTSCTS_PROTECTION_ENABLE,
-	if (QDF_IS_STATUS_ERROR(ret))
+			mac->roam.configParam.mcc_rts_cts_prot_enable);
-		WMA_LOGE("Failed to set WMI VDEV MCC_RTSCTS_PROTECTION_ENABLE");
+	if (QDF_IS_STATUS_ERROR(status))
+		WMA_LOGE("failed to set MCC_RTSCTS_PROTECTION_ENABLE(status = %d)",
+			 status);
 
-	ret = wma_vdev_set_param(wma_handle->wmi_handle, vdev_id,
+	status = wma_vdev_set_param(
+			wma_handle->wmi_handle, vdev_id,
 			WMI_VDEV_PARAM_MCC_BROADCAST_PROBE_ENABLE,
 			mac->roam.configParam.mcc_bcast_prob_resp_enable);
-	if (QDF_IS_STATUS_ERROR(ret))
+	if (QDF_IS_STATUS_ERROR(status))
-		WMA_LOGE("Failed to set WMI VDEV MCC_BROADCAST_PROBE_ENABLE");
+		WMA_LOGE("failed to set MCC_BROADCAST_PROBE_ENABLE(status = %d)",
+			 status);
 
 	if (wlan_mlme_get_rts_threshold(mac->psoc,
 					&cfg_val) ==
 					QDF_STATUS_SUCCESS) {
-		ret = wma_vdev_set_param(wma_handle->wmi_handle,
+		status = wma_vdev_set_param(wma_handle->wmi_handle,
-					self_sta_req->session_id,
+					    vdev_id,
-					WMI_VDEV_PARAM_RTS_THRESHOLD,
+					    WMI_VDEV_PARAM_RTS_THRESHOLD,
-					cfg_val);
+					    cfg_val);
-		if (QDF_IS_STATUS_ERROR(ret))
+		if (QDF_IS_STATUS_ERROR(status))
-			WMA_LOGE("Failed to set WMI_VDEV_PARAM_RTS_THRESHOLD");
+			WMA_LOGE("failed to set RTS_THRESHOLD(status = %d)",
+				 status);
 	} else {
 		WMA_LOGE("Fail to get val for rts threshold, leave unchanged");
 	}
@@ -2956,27 +2816,23 @@ struct cdp_vdev *wma_vdev_attach(tp_wma_handle wma_handle,
 	if (wlan_mlme_get_frag_threshold(mac->psoc,
 					 &cfg_val) ==
 					 QDF_STATUS_SUCCESS) {
-		ret = wma_vdev_set_param(wma_handle->wmi_handle,
+		wma_vdev_set_param(wma_handle->wmi_handle,
-					self_sta_req->session_id,
+				   vdev_id,
-					WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
+				   WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
-					cfg_val);
+				   cfg_val);
-		if (QDF_IS_STATUS_ERROR(ret))
-			WMA_LOGE("Failed to set WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD");
 	} else {
 		WMA_LOGE("Fail to get val for frag threshold, leave unchanged");
 	}
 
 	ht_cap_info = &mac->mlme_cfg->ht_caps.ht_cap_info;
+	status = wma_vdev_set_param(wma_handle->wmi_handle,
+				    vdev_id,
+				    WMI_VDEV_PARAM_TX_STBC,
+				    ht_cap_info->tx_stbc);
+	if (QDF_IS_STATUS_ERROR(status))
+		WMA_LOGE("failed to set TX_STBC(status = %d)", status);
 
-	ret = wma_vdev_set_param(wma_handle->wmi_handle,
+	wma_set_vdev_mgmt_rate(wma_handle, vdev_id);
-				 self_sta_req->session_id,
-				 WMI_VDEV_PARAM_TX_STBC,
-				 ht_cap_info->tx_stbc);
-	if (QDF_IS_STATUS_ERROR(ret))
-		WMA_LOGE("Failed to set WMI_VDEV_PARAM_TX_STBC");
-
-	wma_set_vdev_mgmt_rate(wma_handle, self_sta_req->session_id);
-
 	if (IS_FEATURE_SUPPORTED_BY_FW(DOT11AX)) {
 		/*
 		 * Enable / disable trigger access for a AP vdev's peers.
@@ -2994,39 +2850,40 @@ struct cdp_vdev *wma_vdev_attach(tp_wma_handle wma_handle,
 		 *                 Rx OFDMA trigger receive & UL response
 		 *  6  | UL MUMIMO
 		 */
-		ret = wma_vdev_set_param(wma_handle->wmi_handle,
+		status = wma_vdev_set_param(wma_handle->wmi_handle,
-					 self_sta_req->session_id,
+					    vdev_id,
-					 WMI_VDEV_PARAM_SET_HEMU_MODE,
+					    WMI_VDEV_PARAM_SET_HEMU_MODE,
-					 0x37);
+					    0x37);
-		if (QDF_IS_STATUS_ERROR(ret))
+		if (QDF_IS_STATUS_ERROR(status))
-			WMA_LOGE("Failed to set WMI_VDEV_PARAM_SET_HEMU_MODE");
+			WMA_LOGE("failed to set HEMU_MODE(status = %d)",
+				 status);
 	}
 
 	/* Initialize roaming offload state */
-	if ((self_sta_req->type == WMI_VDEV_TYPE_STA) &&
+	if (vdev_mlme->mgmt.generic.type == WMI_VDEV_TYPE_STA &&
-	    (self_sta_req->sub_type == 0)) {
+	    vdev_mlme->mgmt.generic.subtype == 0) {
 		/* Pass down enable/disable bcast probe rsp to FW */
 		ret = wma_vdev_set_param(
 				wma_handle->wmi_handle,
-				self_sta_req->session_id,
+				vdev_id,
 				WMI_VDEV_PARAM_ENABLE_BCAST_PROBE_RESPONSE,
-				self_sta_req->enable_bcast_probe_rsp);
+				mac->mlme_cfg->oce.enable_bcast_probe_rsp);
 		if (QDF_IS_STATUS_ERROR(ret))
 			WMA_LOGE("Failed to set WMI_VDEV_PARAM_ENABLE_BCAST_PROBE_RESPONSE");
 
 		/* Pass down the FILS max channel guard time to FW */
 		ret = wma_vdev_set_param(
 				wma_handle->wmi_handle,
-				self_sta_req->session_id,
+				vdev_id,
 				WMI_VDEV_PARAM_FILS_MAX_CHANNEL_GUARD_TIME,
-				self_sta_req->fils_max_chan_guard_time);
+				mac->mlme_cfg->sta.fils_max_chan_guard_time);
 		if (QDF_IS_STATUS_ERROR(ret))
 			WMA_LOGE("Failed to set WMI_VDEV_PARAM_FILS_MAX_CHANNEL_GUARD_TIME");
 
 		/* Pass down the Probe Request tx delay(in ms) to FW */
 		ret = wma_vdev_set_param(
 				wma_handle->wmi_handle,
-				self_sta_req->session_id,
+				vdev_id,
 				WMI_VDEV_PARAM_PROBE_DELAY,
 				PROBE_REQ_TX_DELAY);
 		if (QDF_IS_STATUS_ERROR(ret))
@@ -3035,37 +2892,35 @@ struct cdp_vdev *wma_vdev_attach(tp_wma_handle wma_handle,
 		/* Pass down the probe request tx time gap(in ms) to FW */
 		ret = wma_vdev_set_param(
 				wma_handle->wmi_handle,
-				self_sta_req->session_id,
+				vdev_id,
 				WMI_VDEV_PARAM_REPEAT_PROBE_TIME,
 				PROBE_REQ_TX_TIME_GAP);
 		if (QDF_IS_STATUS_ERROR(ret))
 			WMA_LOGE("Failed to set WMI_VDEV_PARAM_REPEAT_PROBE_TIME");
 	}
 
-	if ((self_sta_req->type == WMI_VDEV_TYPE_STA ||
+	if ((vdev_mlme->mgmt.generic.type == WMI_VDEV_TYPE_STA ||
-	     self_sta_req->type == WMI_VDEV_TYPE_AP) &&
+	     vdev_mlme->mgmt.generic.type == WMI_VDEV_TYPE_AP) &&
-	    self_sta_req->sub_type == 0) {
+	     vdev_mlme->mgmt.generic.subtype == 0) {
-		ret = wma_vdev_set_param(wma_handle->wmi_handle,
+		wma_vdev_set_param(wma_handle->wmi_handle,
-				     self_sta_req->session_id,
+				   vdev_id,
-				     WMI_VDEV_PARAM_ENABLE_DISABLE_OCE_FEATURES,
+				   WMI_VDEV_PARAM_ENABLE_DISABLE_OCE_FEATURES,
-				     self_sta_req->oce_feature_bitmap);
+				   mac->mlme_cfg->oce.feature_bitmap);
-		if (QDF_IS_STATUS_ERROR(ret))
-			WMA_LOGE("Failed to set WMI_VDEV_PARAM_ENABLE_DISABLE_OCE_FEATURES");
 	}
 
 	/* Initialize BMISS parameters */
-	if ((self_sta_req->type == WMI_VDEV_TYPE_STA) &&
+	if (vdev_mlme->mgmt.generic.type == WMI_VDEV_TYPE_STA &&
-	    (self_sta_req->sub_type == 0))
+	    vdev_mlme->mgmt.generic.subtype == 0)
 		wma_roam_scan_bmiss_cnt(wma_handle,
 		mac->mlme_cfg->lfr.roam_bmiss_first_bcnt,
 		mac->mlme_cfg->lfr.roam_bmiss_final_bcnt,
-		self_sta_req->session_id);
+		vdev_id);
 
 	if (policy_mgr_get_mcc_adaptive_sch(mac->psoc,
 					    &mcc_adapt_sch) ==
 	    QDF_STATUS_SUCCESS) {
 		WMA_LOGD("%s: setting ini value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED: %d",
-			__func__, mcc_adapt_sch);
+			 __func__, mcc_adapt_sch);
 		ret =
 		wma_set_enable_disable_mcc_adaptive_scheduler(mcc_adapt_sch);
 		if (QDF_IS_STATUS_ERROR(ret)) {
@@ -3075,66 +2930,59 @@ struct cdp_vdev *wma_vdev_attach(tp_wma_handle wma_handle,
 		WMA_LOGE("Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, leaving unchanged");
 	}
 
-	if ((self_sta_req->type == WMI_VDEV_TYPE_STA) &&
+	if (vdev_mlme->mgmt.generic.type == WMI_VDEV_TYPE_STA &&
-	    (ucfg_pmo_is_apf_enabled(wma_handle->psoc))) {
+	    ucfg_pmo_is_apf_enabled(wma_handle->psoc)) {
 		ret = wma_config_active_apf_mode(wma_handle,
-						 self_sta_req->session_id);
+						 vdev_id);
 		if (QDF_IS_STATUS_ERROR(ret))
 			WMA_LOGE("Failed to configure active APF mode");
 	}
 
+	cdp_data_tx_cb_set(soc, txrx_vdev_handle,
+			   wma_data_tx_ack_comp_hdlr,
+			   wma_handle);
+
+	return QDF_STATUS_SUCCESS;
+
 end:
-	self_sta_req->status = status;
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_WMA_ID);
+	wma_cdp_vdev_detach(soc, wma_handle, vdev_id);
+	wma_handle->interfaces[vdev_id].vdev_active = false;
+	txrx_vdev_handle = NULL;
 
-#ifdef QCA_IBSS_SUPPORT
+	return QDF_STATUS_E_FAILURE;
-	if (generateRsp)
-#endif
-	{
-		sme_msg.type = eWNI_SME_ADD_STA_SELF_RSP;
-		sme_msg.bodyptr = self_sta_req;
-		sme_msg.bodyval = 0;
-
-		status = scheduler_post_message(QDF_MODULE_ID_WMA,
-						QDF_MODULE_ID_SME,
-						QDF_MODULE_ID_SME, &sme_msg);
-		if (!QDF_IS_STATUS_SUCCESS(status)) {
-			WMA_LOGE("Failed to post eWNI_SME_ADD_STA_SELF_RSP");
-			qdf_mem_free(self_sta_req);
-		}
-	}
-	return txrx_vdev_handle;
 }
 
-uint32_t wma_get_bcn_rate_code(uint16_t rate)
+enum mlme_bcn_tx_rate_code wma_get_bcn_rate_code(uint16_t rate)
 {
 	/* rate in multiples of 100 Kbps */
 	switch (rate) {
 	case WMA_BEACON_TX_RATE_1_M:
-		return WMI_BCN_TX_RATE_CODE_1_M;
+		return MLME_BCN_TX_RATE_CODE_1_M;
 	case WMA_BEACON_TX_RATE_2_M:
-		return WMI_BCN_TX_RATE_CODE_2_M;
+		return MLME_BCN_TX_RATE_CODE_2_M;
 	case WMA_BEACON_TX_RATE_5_5_M:
-		return WMI_BCN_TX_RATE_CODE_5_5_M;
+		return MLME_BCN_TX_RATE_CODE_5_5_M;
 	case WMA_BEACON_TX_RATE_11_M:
-		return WMI_BCN_TX_RATE_CODE_11M;
+		return MLME_BCN_TX_RATE_CODE_11M;
 	case WMA_BEACON_TX_RATE_6_M:
-		return WMI_BCN_TX_RATE_CODE_6_M;
+		return MLME_BCN_TX_RATE_CODE_6_M;
 	case WMA_BEACON_TX_RATE_9_M:
-		return WMI_BCN_TX_RATE_CODE_9_M;
+		return MLME_BCN_TX_RATE_CODE_9_M;
 	case WMA_BEACON_TX_RATE_12_M:
-		return WMI_BCN_TX_RATE_CODE_12_M;
+		return MLME_BCN_TX_RATE_CODE_12_M;
 	case WMA_BEACON_TX_RATE_18_M:
-		return WMI_BCN_TX_RATE_CODE_18_M;
+		return MLME_BCN_TX_RATE_CODE_18_M;
 	case WMA_BEACON_TX_RATE_24_M:
-		return WMI_BCN_TX_RATE_CODE_24_M;
+		return MLME_BCN_TX_RATE_CODE_24_M;
 	case WMA_BEACON_TX_RATE_36_M:
-		return WMI_BCN_TX_RATE_CODE_36_M;
+		return MLME_BCN_TX_RATE_CODE_36_M;
 	case WMA_BEACON_TX_RATE_48_M:
-		return WMI_BCN_TX_RATE_CODE_48_M;
+		return MLME_BCN_TX_RATE_CODE_48_M;
 	case WMA_BEACON_TX_RATE_54_M:
-		return WMI_BCN_TX_RATE_CODE_54_M;
+		return MLME_BCN_TX_RATE_CODE_54_M;
 	default:
-		return WMI_BCN_TX_RATE_CODE_1_M;
+		return MLME_BCN_TX_RATE_CODE_1_M;
 	}
 }
 
@@ -3252,7 +3100,7 @@ QDF_STATUS wma_vdev_start(tp_wma_handle wma,
 		 req->vdev_id);
 	params.vdev_id = req->vdev_id;
 
-	intr[params.vdev_id].chanmode = params.channel.phy_mode;
+	intr[params.vdev_id].chanmode = chan_mode;
 	intr[params.vdev_id].ht_capable = req->ht_capable;
 	intr[params.vdev_id].vht_capable = req->vht_capable;
 	intr[params.vdev_id].config.gtx_info.gtxRTMask[0] =
@@ -3314,7 +3162,7 @@ QDF_STATUS wma_vdev_start(tp_wma_handle wma,
 			params.channel.dfs_set = true;
 	}
 
-	params.beacon_intval = req->beacon_intval;
+	params.beacon_interval = req->beacon_intval;
 	params.dtim_period = req->dtim_period;
 
 	if (req->beacon_tx_rate) {
@@ -3339,7 +3187,7 @@ QDF_STATUS wma_vdev_start(tp_wma_handle wma,
 
 	/* TODO: Handle regulatory class, max antenna */
 	if (!isRestart) {
-		params.beacon_intval = req->beacon_intval;
+		params.beacon_interval = req->beacon_intval;
 		params.dtim_period = req->dtim_period;
 
 		/* Copy the SSID */

core/wma/src/wma_features.c

@@ -4247,16 +4247,10 @@ QDF_STATUS wma_send_apf_read_work_memory_cmd(WMA_HANDLE handle,
 }
 #endif /* FEATURE_WLAN_APF */
 
-/**
+QDF_STATUS wma_set_tx_rx_aggr_size(uint8_t vdev_id,
- * wma_set_tx_rx_aggregation_size() - sets tx rx aggregation sizes
+				   uint32_t tx_size,
- * @tx_rx_aggregation_size: aggregation size parameters
+				   uint32_t rx_size,
- *
+				   wmi_vdev_custom_aggr_type_t aggr_type)
- * This function sets tx rx aggregation sizes
- *
- * Return: QDF_STATUS
- */
-QDF_STATUS wma_set_tx_rx_aggregation_size(
-	struct sir_set_tx_rx_aggregation_size *tx_rx_aggregation_size)
 {
 	tp_wma_handle wma_handle;
 	wmi_vdev_set_custom_aggr_size_cmd_fixed_param *cmd;
@@ -4267,10 +4261,6 @@ QDF_STATUS wma_set_tx_rx_aggregation_size(
 
 	wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
 
-	if (!tx_rx_aggregation_size) {
-		WMA_LOGE("%s: invalid pointer", __func__);
-		return QDF_STATUS_E_INVAL;
-	}
 
 	if (!wma_handle) {
 		WMA_LOGE("%s: WMA context is invald!", __func__);
@@ -4291,12 +4281,11 @@ QDF_STATUS wma_set_tx_rx_aggregation_size(
 		WMITLV_GET_STRUCT_TLVLEN(
 			wmi_vdev_set_custom_aggr_size_cmd_fixed_param));
 
-	cmd->vdev_id = tx_rx_aggregation_size->vdev_id;
+	cmd->vdev_id = vdev_id;
-	cmd->tx_aggr_size = tx_rx_aggregation_size->tx_aggregation_size;
+	cmd->tx_aggr_size = tx_size;
-	cmd->rx_aggr_size = tx_rx_aggregation_size->rx_aggregation_size;
+	cmd->rx_aggr_size = rx_size;
 	/* bit 2 (aggr_type): TX Aggregation Type (0=A-MPDU, 1=A-MSDU) */
-	if (tx_rx_aggregation_size->aggr_type ==
+	if (aggr_type == WMI_VDEV_CUSTOM_AGGR_TYPE_AMSDU)
-	    WMI_VDEV_CUSTOM_AGGR_TYPE_AMSDU)
 		cmd->enable_bitmap |= 0x04;
 
 	WMA_LOGD("tx aggr: %d rx aggr: %d vdev: %d enable_bitmap %d",
@@ -4313,10 +4302,11 @@ QDF_STATUS wma_set_tx_rx_aggregation_size(
 	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS wma_set_tx_rx_aggregation_size_per_ac(
+QDF_STATUS wma_set_tx_rx_aggr_size_per_ac(WMA_HANDLE handle,
-	struct sir_set_tx_rx_aggregation_size *tx_rx_aggregation_size)
+					  uint8_t vdev_id,
+					  struct wlan_mlme_qos *qos_aggr,
+					  wmi_vdev_custom_aggr_type_t aggr_type)
 {
-	tp_wma_handle wma_handle;
 	wmi_vdev_set_custom_aggr_size_cmd_fixed_param *cmd;
 	int32_t len;
 	wmi_buf_t buf;
@@ -4324,23 +4314,17 @@ QDF_STATUS wma_set_tx_rx_aggregation_size_per_ac(
 	int ret;
 	int queue_num;
 	uint32_t tx_aggr_size[4];
-
+	tp_wma_handle wma_handle = (tp_wma_handle)handle;
-	wma_handle = cds_get_context(QDF_MODULE_ID_WMA);
-
-	if (!tx_rx_aggregation_size) {
-		WMA_LOGE("%s: invalid pointer", __func__);
-		return QDF_STATUS_E_INVAL;
-	}
 
 	if (!wma_handle) {
 		WMA_LOGE("%s: WMA context is invald!", __func__);
 		return QDF_STATUS_E_INVAL;
 	}
 
-	tx_aggr_size[0] = tx_rx_aggregation_size->tx_aggregation_size_be;
+	tx_aggr_size[0] = qos_aggr->tx_aggregation_size_be;
-	tx_aggr_size[1] = tx_rx_aggregation_size->tx_aggregation_size_bk;
+	tx_aggr_size[1] = qos_aggr->tx_aggregation_size_bk;
-	tx_aggr_size[2] = tx_rx_aggregation_size->tx_aggregation_size_vi;
+	tx_aggr_size[2] = qos_aggr->tx_aggregation_size_vi;
-	tx_aggr_size[3] = tx_rx_aggregation_size->tx_aggregation_size_vo;
+	tx_aggr_size[3] = qos_aggr->tx_aggregation_size_vo;
 
 	for (queue_num = 0; queue_num < 4; queue_num++) {
 		if (tx_aggr_size[queue_num] == 0)
@@ -4360,16 +4344,13 @@ QDF_STATUS wma_set_tx_rx_aggregation_size_per_ac(
 			       WMITLV_GET_STRUCT_TLVLEN(
 					wmi_vdev_set_custom_aggr_size_cmd_fixed_param));
 
-		cmd->vdev_id = tx_rx_aggregation_size->vdev_id;
+		cmd->vdev_id = vdev_id;
-		cmd->rx_aggr_size =
+		cmd->rx_aggr_size = qos_aggr->rx_aggregation_size;
-				  tx_rx_aggregation_size->rx_aggregation_size;
-
 		cmd->tx_aggr_size = tx_aggr_size[queue_num];
 		/* bit 5: tx_ac_enable, if set, ac bitmap is valid. */
 		cmd->enable_bitmap = 0x20 | queue_num;
 		/* bit 2 (aggr_type): TX Aggregation Type (0=A-MPDU, 1=A-MSDU) */
-		if (tx_rx_aggregation_size->aggr_type ==
+		if (aggr_type == WMI_VDEV_CUSTOM_AGGR_TYPE_AMSDU)
-		    WMI_VDEV_CUSTOM_AGGR_TYPE_AMSDU)
 			cmd->enable_bitmap |= 0x04;
 
 		WMA_LOGD("queue_num: %d, tx aggr: %d rx aggr: %d vdev: %d, bitmap: %d",
@@ -4435,23 +4416,15 @@ static QDF_STATUS wma_set_sw_retry_by_qos(
 	return QDF_STATUS_SUCCESS;
 }
 
-QDF_STATUS wma_set_sw_retry_threshold_per_ac(
+QDF_STATUS wma_set_sw_retry_threshold_per_ac(WMA_HANDLE handle,
-	WMA_HANDLE handle,
+					     uint8_t vdev_id,
-	struct sir_set_tx_sw_retry_threshold *tx_sw_retry_threshold)
+					     struct wlan_mlme_qos *qos_aggr)
 {
 	QDF_STATUS ret;
-	tp_wma_handle wma_handle;
-	uint8_t vdev_id;
 	int retry_type, queue_num;
 	uint32_t tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_MAX][WMI_AC_MAX];
 	uint32_t sw_retry;
-
+	tp_wma_handle wma_handle = (tp_wma_handle)handle;
-	wma_handle = (tp_wma_handle)handle;
-
-	if (!tx_sw_retry_threshold) {
-		wma_err("%s: invalid pointer", __func__);
-		return QDF_STATUS_E_INVAL;
-	}
 
 	if (!wma_handle) {
 		wma_err("%s: WMA context is invalid!", __func__);
@@ -4459,22 +4432,22 @@ QDF_STATUS wma_set_sw_retry_threshold_per_ac(
 	}
 
 	tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_AGGR][WMI_AC_BE] =
-		tx_sw_retry_threshold->tx_aggr_sw_retry_threshold_be;
+		qos_aggr->tx_aggr_sw_retry_threshold_be;
 	tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_AGGR][WMI_AC_BK] =
-		tx_sw_retry_threshold->tx_aggr_sw_retry_threshold_bk;
+		qos_aggr->tx_aggr_sw_retry_threshold_bk;
 	tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_AGGR][WMI_AC_VI] =
-		tx_sw_retry_threshold->tx_aggr_sw_retry_threshold_vi;
+		qos_aggr->tx_aggr_sw_retry_threshold_vi;
 	tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_AGGR][WMI_AC_VO] =
-		tx_sw_retry_threshold->tx_aggr_sw_retry_threshold_vo;
+		qos_aggr->tx_aggr_sw_retry_threshold_vo;
 
 	tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_NONAGGR][WMI_AC_BE] =
-		tx_sw_retry_threshold->tx_non_aggr_sw_retry_threshold_be;
+		qos_aggr->tx_non_aggr_sw_retry_threshold_be;
 	tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_NONAGGR][WMI_AC_BK] =
-		tx_sw_retry_threshold->tx_non_aggr_sw_retry_threshold_bk;
+		qos_aggr->tx_non_aggr_sw_retry_threshold_bk;
 	tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_NONAGGR][WMI_AC_VI] =
-		tx_sw_retry_threshold->tx_non_aggr_sw_retry_threshold_vi;
+		qos_aggr->tx_non_aggr_sw_retry_threshold_vi;
 	tx_sw_retry[WMI_VDEV_CUSTOM_SW_RETRY_TYPE_NONAGGR][WMI_AC_VO] =
-		tx_sw_retry_threshold->tx_non_aggr_sw_retry_threshold_vo;
+		qos_aggr->tx_non_aggr_sw_retry_threshold_vo;
 
 	retry_type = WMI_VDEV_CUSTOM_SW_RETRY_TYPE_NONAGGR;
 	while (retry_type < WMI_VDEV_CUSTOM_SW_RETRY_TYPE_MAX) {
@@ -4482,7 +4455,6 @@ QDF_STATUS wma_set_sw_retry_threshold_per_ac(
 			if (tx_sw_retry[retry_type][queue_num] == 0)
 				continue;
 
-			vdev_id = tx_sw_retry_threshold->vdev_id;
 			sw_retry = tx_sw_retry[retry_type][queue_num];
 			ret = wma_set_sw_retry_by_qos(wma_handle,
 						      vdev_id,
@@ -4522,6 +4494,7 @@ QDF_STATUS wma_set_sw_retry_threshold(uint8_t vdev_id, uint32_t retry,
 
 	return QDF_STATUS_SUCCESS;
 }
+
 /**
  * wma_process_fw_test_cmd() - send unit test command to fw.
  * @handle: wma handle
@@ -4972,6 +4945,8 @@ int wma_chan_info_event_handler(void *handle, uint8_t *event_buf,
 	struct mac_context *mac = NULL;
 	struct lim_channel_status *channel_status;
 	bool snr_monitor_enabled;
+	struct wlan_objmgr_vdev *vdev;
+	enum QDF_OPMODE mode;
 
 	WMA_LOGD("%s: Enter", __func__);
 
@@ -4983,21 +4958,20 @@ int wma_chan_info_event_handler(void *handle, uint8_t *event_buf,
 		return -EINVAL;
 	}
 
+	param_buf = (WMI_CHAN_INFO_EVENTID_param_tlvs *)event_buf;
+	if (!param_buf)  {
+		WMA_LOGE("Invalid chan info event buffer");
+		return -EINVAL;
+	}
+	event = param_buf->fixed_param;
+	if (!event) {
+		WMA_LOGA("%s: Invalid fixed param", __func__);
+		return -EINVAL;
+	}
+
 	snr_monitor_enabled = wlan_scan_is_snr_monitor_enabled(mac->psoc);
 	WMA_LOGD("%s: monitor:%d", __func__, snr_monitor_enabled);
 	if (snr_monitor_enabled && mac->chan_info_cb) {
-		param_buf =
-			(WMI_CHAN_INFO_EVENTID_param_tlvs *)event_buf;
-		if (!param_buf) {
-			WMA_LOGA("%s: Invalid chan info event", __func__);
-			return -EINVAL;
-		}
-
-		event = param_buf->fixed_param;
-		if (!event) {
-			WMA_LOGA("%s: Invalid fixed param", __func__);
-			return -EINVAL;
-		}
 		buf.tx_frame_count = event->tx_frame_cnt;
 		buf.clock_freq = event->mac_clk_mhz;
 		buf.cmd_flag = event->cmd_flags;
@@ -5008,14 +4982,19 @@ int wma_chan_info_event_handler(void *handle, uint8_t *event_buf,
 		mac->chan_info_cb(&buf);
 	}
 
-	if (mac->sap.acs_with_more_param &&
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(wma->psoc, event->vdev_id,
-	    mac->sme.curr_device_mode == QDF_SAP_MODE) {
+						    WLAN_LEGACY_WMA_ID);
-		param_buf = (WMI_CHAN_INFO_EVENTID_param_tlvs *) event_buf;
+
-		if (!param_buf)  {
+	if (!vdev) {
-			WMA_LOGE("Invalid chan info event buffer");
+		WMA_LOGE("%s: vdev is NULL for vdev %d",
-			return -EINVAL;
+			 __func__, event->vdev_id);
-		}
+		return -EINVAL;
-		event = param_buf->fixed_param;
+	}
+	mode = wlan_vdev_mlme_get_opmode(vdev);
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_LEGACY_WMA_ID);
+	WMA_LOGD("Vdevid %d mode %d", event->vdev_id, mode);
+
+	if (mac->sap.acs_with_more_param && mode == QDF_SAP_MODE) {
 		channel_status = qdf_mem_malloc(sizeof(*channel_status));
 		if (!channel_status)
 			return -ENOMEM;

core/wma/src/wma_main.c

@@ -954,10 +954,8 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
 	struct pdev_params pdev_param;
 	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 	struct target_psoc_info *tgt_hdl;
-	struct sir_set_tx_rx_aggregation_size aggr;
 
 	WMA_LOGD("wmihandle %pK", wma->wmi_handle);
-	qdf_mem_zero(&aggr, sizeof(aggr));
 
 	if (!mac) {
 		WMA_LOGE("%s: Failed to get mac", __func__);
@@ -1027,6 +1025,8 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
 	{
 		struct cdp_vdev *vdev = NULL;
 		struct wma_txrx_node *intr = wma->interfaces;
+		wmi_vdev_custom_aggr_type_t aggr_type =
+			WMI_VDEV_CUSTOM_AGGR_TYPE_AMSDU;
 
 		vdev = wma_find_vdev_by_id(wma, privcmd->param_vdev_id);
 		if (!vdev) {
@@ -1055,18 +1055,14 @@ static void wma_process_cli_set_cmd(tp_wma_handle wma,
 					intr[privcmd->param_vdev_id].config.
 						ampdu = privcmd->param_value;
 
-				aggr.aggr_type =
+				aggr_type =
 					WMI_VDEV_CUSTOM_AGGR_TYPE_AMPDU;
-			} else {
-				aggr.aggr_type =
-					WMI_VDEV_CUSTOM_AGGR_TYPE_AMSDU;
 			}
 
-			aggr.vdev_id = vid;
+			ret = wma_set_tx_rx_aggr_size(vid,
-			aggr.tx_aggregation_size = privcmd->param_value;
+						      privcmd->param_value,
-			aggr.rx_aggregation_size = privcmd->param_value;
+						      privcmd->param_value,
-
+						      aggr_type);
-			ret = wma_set_tx_rx_aggregation_size(&aggr);
 			if (QDF_IS_STATUS_ERROR(ret)) {
 				WMA_LOGE("set_aggr_size failed ret %d", ret);
 				return;
@@ -8413,9 +8409,6 @@ static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg)
 {
 	QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
 	tp_wma_handle wma_handle;
-	struct cdp_vdev *txrx_vdev_handle = NULL;
-
-	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
 
 	if (!msg) {
 		WMA_LOGE("msg is NULL");
@@ -8454,26 +8447,6 @@ static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg)
 		wma_process_tsm_stats_req(wma_handle, (void *)msg->bodyptr);
 		break;
 #endif /* FEATURE_WLAN_ESE */
-	case WMA_ADD_STA_SELF_REQ:
-		txrx_vdev_handle =
-			wma_vdev_attach(wma_handle,
-				(struct add_sta_self_params *) msg->
-				bodyptr, 1);
-		if (!txrx_vdev_handle) {
-			WMA_LOGE("Failed to attach vdev");
-		} else {
-			/* Register with TxRx Module for Data Ack Complete Cb */
-			if (soc) {
-				cdp_data_tx_cb_set(soc, txrx_vdev_handle,
-						wma_data_tx_ack_comp_hdlr,
-						wma_handle);
-			} else {
-				WMA_LOGE("%s: SOC context is NULL", __func__);
-				qdf_status = QDF_STATUS_E_FAILURE;
-				goto end;
-			}
-		}
-		break;
 	case WMA_DEL_STA_SELF_REQ:
 		wma_vdev_detach(wma_handle,
 				(struct del_sta_self_params *) msg->bodyptr, 1);

core/wma/src/wma_power.c

@@ -116,7 +116,7 @@ QDF_STATUS wma_unified_set_sta_ps_param(wmi_unified_t wmi_handle,
 	iface = &wma->interfaces[vdev_id];
 
 	sta_ps_param.vdev_id = vdev_id;
-	sta_ps_param.param = param;
+	sta_ps_param.param_id = param;
 	sta_ps_param.value = value;
 	status = wmi_unified_sta_ps_cmd_send(wmi_handle, &sta_ps_param);
 	if (QDF_IS_STATUS_ERROR(status))