qcacmn: Add mlme/vdev_mgr support for vdev mgmt ops

Add support in mlme vdev_mgr to update
data structures corresponding to vdev mgmt
ops as expected by WMI and send the same to
target_if/mlme/vdev_mgr for sending to WMI.

Core MLME data structures in wlan_vdev_mlme.h
will be updated through provided ucfg APIs
which are used in updated vdev mgmt ops
data structures.

Change-Id: Ic6fc03bcb817c9f2f2724a9591b76656840903ba
CRs-Fixed: 2383346

umac/mlme/include/wlan_vdev_mlme.h

@@ -20,12 +20,360 @@
 #ifndef _WLAN_VDEV_MLME_H_
 #define _WLAN_VDEV_MLME_H_
 
+#include <wlan_vdev_mgr_tgt_if_rx_defs.h>
+
 struct vdev_mlme_obj;
 
+/* Requestor ID for multiple vdev restart */
+#define MULTIPLE_VDEV_RESTART_REQ_ID 0x1234
+
+/* values for vdev_type */
+#define WLAN_VDEV_MLME_TYPE_AP   0x1
+#define WLAN_VDEV_MLME_TYPE_STA  0x2
+#define WLAN_VDEV_MLME_TYPE_IBSS 0x3
+#define WLAN_VDEV_MLME_TYPE_MONITOR 0x4
+
+/* values for vdev_subtype */
+#define WLAN_VDEV_MLME_SUBTYPE_P2P_DEVICE 0x1
+#define WLAN_VDEV_MLME_SUBTYPE_P2P_CLIENT 0x2
+#define WLAN_VDEV_MLME_SUBTYPE_P2P_GO 0x3
+#define WLAN_VDEV_MLME_SUBTYPE_PROXY_STA 0x4
+#define WLAN_VDEV_MLME_SUBTYPE_MESH 0x5
+
+/* vdev control flags (per bits) */
+#define WLAN_VDEV_MLME_FLAGS_NON_MBSSID_AP      0x00000001
+#define WLAN_VDEV_MLME_FLAGS_TRANSMIT_AP        0x00000002
+#define WLAN_VDEV_MLME_FLAGS_NON_TRANSMIT_AP    0x00000004
+
+/**
+ * struct vdev_mlme_proto_generic - generic mlme proto structure
+ * sent in frames
+ * @dtim_period: frequency of data transmissions per beacon 1-255
+ * @slot_time: slot time
+ * @protection_mode: rts cts protection mode
+ * @beacon_interval: beacon interval
+ * @ldpc: low density parity check value
+ * @nss: number of spatial stream
+ * @tsfadjust: adjusted timer sync value
+ */
+struct vdev_mlme_proto_generic {
+	uint8_t dtim_period;
+	uint32_t slot_time;
+	uint32_t protection_mode;
+	uint16_t beacon_interval;
+	uint8_t ldpc;
+	uint8_t nss;
+	uint64_t tsfadjust;
+};
+
+/**
+ * struct vdev_mlme_proto_ap - ap specific mlme protocol
+ * @.
+ */
+struct vdev_mlme_proto_ap {
+};
+
+/**
+ * struct vdev_mlme_proto_sta - sta specific mlme protocol
+ * @assoc_id: association id of station
+ * @uapsd_cfg: uapsd configuration
+ */
+struct vdev_mlme_proto_sta {
+	uint16_t assoc_id;
+	uint16_t uapsd_cfg;
+};
+
+/**
+ * struct vdev_mlme_proto_bss_color - bss color cfg
+ * @flags: proposed for future use cases, currently not used.
+ * @evt_type: bss color collision event.
+ * @current_bss_color: current bss color.
+ * @detection_period_ms: scan interval for both AP and STA mode.
+ * @scan_period_ms: scan period for passive scan to detect collision.
+ * @free_slot_expiry_time_ms: FW to notify host at timer expiry after
+ *                            which Host will disable the bss color.
+ */
+struct vdev_mlme_proto_bss_color {
+	uint32_t flags;
+	uint8_t  evt_type;
+	uint32_t current_bss_color;
+	uint32_t detection_period_ms;
+	uint32_t scan_period_ms;
+	uint32_t free_slot_expiry_time_ms;
+};
+
 /**
- * struct vdev_mlme_proto - VDEV protocol strucutre
+ * struct vdev_mlme_vht_info - vdev VHT information
+ * @caps: vht capabilities
+ * @subfer: su beam former capability
+ * @subfee: su beam formee capability
+ * @mubfer: mu beam former capability
+ * @mubfee: mu beam formee capability
+ * @implicit_bf: Implicit BF support
+ * @sounding_dimension: Beamformer number of sounding dimension
+ * @en_2gvht: 256 qam status
+ * @allow_vht: vht capability status
+ */
+struct vdev_mlme_vht_info {
+	uint32_t caps;
+	uint8_t  subfer;
+	uint8_t  mubfer;
+	uint8_t  subfee;
+	uint8_t  mubfee;
+	uint8_t  implicit_bf;
+	uint8_t  sounding_dimension;
+	uint8_t  en_2gvht;
+	bool     allow_vht;
+};
+
+/**
+ * struct vdev_mlme_ht_info - vdev HT information
+ * @ht_caps: HT capabilities
+ * @allow_ht: HT capability status
+ */
+struct vdev_mlme_ht_info {
+	uint32_t ht_caps;
+	bool     allow_ht;
+};
+
+/**
+ * struct vdev_mlme_he_ops_info - vdev mlme HEOPS information
+ * @he_ops: he ops
+ */
+struct vdev_mlme_he_ops_info {
+	uint32_t he_ops;
+};
+
+/**
+ * struct vdev_mlme_he_ops_info - vdev protocol structure holding information
+ * that is used in frames
+ * @generic: generic protocol information
+ * @ap: ap specific protocol information
+ * @sta: sta specific protocol information
+ * @vht_info: vht information
+ * @ht_info: ht capabilities information
+ * @he_ops_info: he ops information
+ * @bss_color: 11ax HE BSS Color information
  */
 struct vdev_mlme_proto {
+	struct vdev_mlme_proto_generic generic;
+	struct vdev_mlme_proto_ap ap;
+	struct vdev_mlme_proto_sta sta;
+	struct vdev_mlme_vht_info vht_info;
+	struct vdev_mlme_ht_info ht_info;
+	struct vdev_mlme_he_ops_info he_ops_info;
+	struct vdev_mlme_proto_bss_color bss_color;
+};
+
+/**
+ * struct vdev_mlme_mgmt_generic - generic vdev mlme mgmt cfg
+ * @rts_threshold: RTS threshold
+ * @frag_threshold: Fragmentation threshold
+ * @probe_delay: time in msec for delaying to send first probe request
+ * @repeat_probe_time: probe request transmission time
+ * @drop_unencry: drop unencrypted status
+ * @ tx_pwrlimit: Tx power limit
+ * @tx_power: Tx power
+ * @minpower: Min power
+ * @maxpower: Max power
+ * @maxregpower: max regulatory power
+ * @antennamax: max antenna
+ * @ampdu: ampdu limit
+ * @amsdu: amsdu limit
+ * @ssid: service set identifier
+ * @ssid_len: ssid length
+ * @type: vdev type
+ * @sub_type: vdev subtype
+ * @rx_decap_type: rx decap type
+ * @tx_decap_type: tx decap type
+ * @disable_hw_ack: disable ha ack flag
+ * @chan_flags: channel flags
+ * @chan_flags_ext: extended channel flags
+ * @cfreq0: channel frequency index0
+ * @cfreq1: channel frequency index1
+ * @dfs_set: DFS status flag
+ * @dfs_set_cfreq2: DFS status channel index
+ * @is_chan_passive: channel passive indication flag
+ * @reg_class_id: reg domain class id
+ * @is_11ax_stub_enabled: 11AX stub status indication flag
+ * @nss_2g: 2G spatial streams
+ * @nss_5g: 5G spatial streams
+ */
+struct vdev_mlme_mgmt_generic {
+	uint32_t rts_threshold;
+	uint32_t frag_threshold;
+	uint32_t probe_delay;
+	uint32_t repeat_probe_time;
+	uint32_t drop_unencry;
+	uint32_t tx_pwrlimit;
+	uint8_t tx_power;
+	uint8_t minpower;
+	uint8_t maxpower;
+	uint8_t maxregpower;
+	uint8_t antennamax;
+	uint8_t ampdu;
+	uint8_t amsdu;
+	char ssid[WLAN_SSID_MAX_LEN + 1];
+	uint8_t ssid_len;
+	uint8_t type;
+	uint8_t subtype;
+	uint8_t rx_decap_type;
+	uint8_t tx_decap_type;
+	bool disable_hw_ack;
+	uint64_t chan_flags;
+	uint16_t chan_flags_ext;
+	uint32_t cfreq1;
+	uint32_t cfreq2;
+	bool dfs_set;
+	bool dfs_set_cfreq2;
+	bool is_chan_passive;
+	uint8_t reg_class_id;
+	uint8_t is_11ax_stub_enabled;
+	uint8_t nss_2g;
+	uint8_t nss_5g;
+};
+
+/**
+ * struct vdev_mlme_mgmt_ap - ap specific vdev mlme mgmt cfg
+ * @.
+ */
+struct vdev_mlme_mgmt_ap {
+};
+
+/**
+ * struct vdev_mlme_mgmt_sta - sta specific vdev mlme mgmt cfg
+ * @.
+ */
+struct vdev_mlme_mgmt_sta {
+};
+
+/**
+ * struct vdev_mlme_inactivity_params - vdev mlme inactivity parameters
+ * @bmiss_first_bcnt: bmiss first time
+ * @bmiss_final_bcnt: bmiss final time
+ * @keepalive_min_idle_inactive_time_secs: min time AP consider STA to be
+ * inactive
+ * @keepalive_max_idle_inactive_time_secs: max inactive idle time for AP to send
+ * data-null
+ * @keepalive_max_unresponsive_time_secs: max time to send WMI_STA_KICKOUT
+ */
+struct vdev_mlme_inactivity_params {
+	uint32_t bmiss_first_bcnt;
+	uint32_t bmiss_final_bcnt;
+	uint32_t keepalive_min_idle_inactive_time_secs;
+	uint32_t keepalive_max_idle_inactive_time_secs;
+	uint32_t keepalive_max_unresponsive_time_secs;
+};
+
+/**
+ * struct vdev_mlme_rate_info - vdev mlme rate information
+ * @rate_flags: dynamic bandwidth info
+ * @per_band_tx_mgmt_rate: per band Tx mgmt rate
+ * @max_rate: max bandwidth rate
+ * @tx_mgmt_rate: Tx Mgmt rate
+ * @bcn_tx_rate: beacon Tx rate
+ * @type: Type of ratemask configuration
+ * @lower32: Lower 32 bits in the 1st 64-bit value
+ * @higher32: Higher 32 bits in the 1st 64-bit value
+ * @lower32_2: Lower 32 bits in the 2nd 64-bit value
+ * @half_rate: Half rate
+ * @quarter_rate: quarter rate
+ */
+struct vdev_mlme_rate_info {
+	uint32_t rate_flags;
+	uint32_t per_band_tx_mgmt_rate;
+	uint32_t max_rate;
+	uint32_t tx_mgmt_rate;
+	uint32_t bcn_tx_rate;
+	uint8_t  type;
+	uint32_t lower32;
+	uint32_t higher32;
+	uint32_t lower32_2;
+	bool     half_rate;
+	bool     quarter_rate;
+};
+
+/**
+ * struct vdev_mlme_chainmask_info - vdev mlme chainmask information
+ * @tx_chainmask: Tx chainmask
+ * @rx_chainmask: Rx Chainmask
+ * @num_rx_chain: Num of bits set in Rx chain
+ * @num_tx_chain: Num of bits set in Tx chain
+ */
+struct vdev_mlme_chainmask_info {
+	uint8_t tx_chainmask;
+	uint8_t rx_chainmask;
+	uint8_t num_rx_chain;
+	uint8_t num_tx_chain;
+};
+
+/**
+ * struct vdev_mlme_powersave_info - vdev mlme powersave information
+ * @packet_powersave: packet powersave
+ * @max_li_of_moddtim: max mod dtim
+ * @dyndtim_cnt: dynamic dtim count
+ * @listen_interval: listen interval
+ * @moddtim_cnt: mod dtim count
+ */
+struct vdev_mlme_powersave_info {
+	uint32_t packet_powersave;
+	uint32_t max_li_of_moddtim;
+	uint32_t dyndtim_cnt;
+	uint32_t listen_interval;
+	uint32_t moddtim_cnt;
+};
+
+/**
+ * struct vdev_mlme_beacon_info - vdev mlme beacon information
+ * @beacon_buffer: buffer allocated for beacon frame
+ * @beacon_offsets: beacon IE's offsets
+ */
+struct vdev_mlme_beacon_info {
+	qdf_nbuf_t beacon_buffer;
+	void *beacon_offsets;
+};
+
+/**
+ * struct vdev_mlme_mbss_11ax - mbss 11ax fields required for up cmd
+ * @profile_idx: profile index of the connected non-trans ap (mbssid case).
+ *              0  means invalid.
+ * @profile_num: the total profile numbers of non-trans aps (mbssid
+ * case).
+ *              0 means non-MBSS AP.
+ * @mbssid-flags: MBSS IE flags indicating vdev type
+ * @vdevid_trans: id of transmitting vdev for MBSS IE
+ * @trans_bssid: bssid of transmitted AP (MBSS IE case)
+ */
+struct vdev_mlme_mbss_11ax {
+	uint32_t profile_idx;
+	uint32_t profile_num;
+	uint32_t mbssid_flags;
+	uint8_t vdevid_trans;
+	uint8_t trans_bssid[QDF_MAC_ADDR_SIZE];
+};
+
+/**
+ * struct vdev_mlme_mgmt - vdev mlme mgmt related cfg
+ * @generic: generic mgmt information
+ * @ap: ap specific mgmt information
+ * @sta: sta specific mgmt information
+ * @inactivity_params: inactivity parameters
+ * @rate_info: bandwidth rate information
+ * @chainmask_info: Chainmask information
+ * @powersave_info: Power save parameters
+ * @beacon_info: beacon buffer information
+ * @mbss_11ax: MBSS 11ax information
+ */
+struct vdev_mlme_mgmt {
+	struct vdev_mlme_mgmt_generic generic;
+	struct vdev_mlme_mgmt_ap ap;
+	struct vdev_mlme_mgmt_sta sta;
+	struct vdev_mlme_inactivity_params inactivity_params;
+	struct vdev_mlme_rate_info rate_info;
+	struct vdev_mlme_chainmask_info chainmask_info;
+	struct vdev_mlme_powersave_info powersave_info;
+	struct vdev_mlme_beacon_info beacon_info;
+	struct vdev_mlme_mbss_11ax mbss_11ax;
 };
 
 /**
@@ -48,10 +396,28 @@ enum beacon_update_op {
  * enum vdev_cmd_type - Command type
  * @START_REQ:      Start request
  * @RESTART_REQ:    Restart request
+ * @STOP_REQ: STOP request
+ * @DELETE_REQ: DELETE request
  */
 enum vdev_cmd_type {
 	START_REQ,
 	RESTART_REQ,
+	STOP_REQ,
+	DELETE_REQ,
+};
+
+/**
+ * enum vdev_rsp_type - Response type
+ * @START_RSP:      Start Response
+ * @RESTART_RSP:    Restart Response
+ * @STOP_RSP: STOP Response
+ * @DELETE_RSP: DELETE Response
+ */
+enum vdev_rsp_type {
+	START_RSP,
+	RESTART_RSP,
+	STOP_RSP,
+	DELETE_RSP,
 };
 
 /**
@@ -141,19 +507,41 @@ struct vdev_mlme_ops {
 	QDF_STATUS (*mlme_vdev_notify_down_complete)(
 				struct vdev_mlme_obj *vdev_mlme,
 				uint16_t event_data_len, void *event_data);
+	QDF_STATUS (*mlme_vdev_ext_hdl_create)(
+				struct vdev_mlme_obj *vdev_mlme);
+	QDF_STATUS (*mlme_vdev_ext_hdl_post_create)(
+				struct vdev_mlme_obj *vdev_mlme);
+	QDF_STATUS (*mlme_vdev_ext_hdl_destroy)(
+				struct vdev_mlme_obj *vdev_mlme);
+	QDF_STATUS (*mlme_vdev_enqueue_exp_cmd)(
+				struct vdev_mlme_obj *vdev_mlme,
+				uint8_t cmd_type);
+	QDF_STATUS (*mlme_vdev_ext_delete_rsp)(
+				struct vdev_mlme_obj *vdev_mlme,
+				struct vdev_delete_response *rsp);
+	QDF_STATUS (*mlme_vdev_ext_stop_rsp)(
+				struct vdev_mlme_obj *vdev_mlme,
+				struct vdev_stop_response *rsp);
+	QDF_STATUS (*mlme_vdev_ext_start_rsp)(
+				struct vdev_mlme_obj *vdev_mlme,
+				struct vdev_start_response *rsp);
 };
 
 /**
  * struct vdev_mlme_obj - VDEV MLME component object
- * @vdev_proto:           VDEV MLME proto substructure
+ * @proto: VDEV MLME proto substructure
+ * @mgmt: VDEV MLME mgmt substructure
  * @sm_lock:              VDEV SM lock
  * @vdev_cmd_lock:        VDEV MLME command atomicity
  * @sm_hdl:               VDEV SM handle
+ * @vdev: Pointer to vdev objmgr
  * @ops:                  VDEV MLME callback table
  * @ext_vdev_ptr:         VDEV MLME legacy pointer
+ * @vdev_rt: VDEV response timer
  */
 struct vdev_mlme_obj {
-	struct vdev_mlme_proto vdev_proto;
+	struct vdev_mlme_proto proto;
+	struct vdev_mlme_mgmt  mgmt;
 #ifdef VDEV_SM_LOCK_SUPPORT
 	qdf_spinlock_t sm_lock;
 	qdf_mutex_t vdev_cmd_lock;
@@ -162,6 +550,7 @@ struct vdev_mlme_obj {
 	struct wlan_objmgr_vdev *vdev;
 	struct vdev_mlme_ops *ops;
 	void *ext_vdev_ptr;
+	struct vdev_response_timer vdev_rt;
 };
 
 /**

umac/mlme/vdev_mgr/core/src/vdev_mgr_ops.c

@@ -0,0 +1,505 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: vdev_mgr_ops.c
+ *
+ * This header file provides API definitions for filling data structures
+ * and sending vdev mgmt commands to target_if/mlme
+ */
+#include "vdev_mgr_ops.h"
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_vdev_mlme_api.h>
+#include <wlan_mlme_dbg.h>
+#include <wlan_vdev_mgr_tgt_if_tx_api.h>
+#include <target_if.h>
+#include <init_deinit_lmac.h>
+#include <wlan_lmac_if_api.h>
+#include <wlan_reg_services_api.h>
+#include <wlan_dfs_tgt_api.h>
+#include "core/src/dfs.h"
+#include <wlan_vdev_mgr_ucfg_api.h>
+
+static QDF_STATUS vdev_mgr_create_param_update(
+					struct vdev_mlme_obj *mlme_obj,
+					struct vdev_create_params *param)
+{
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_mlme_mbss_11ax *mbss;
+
+	vdev = mlme_obj->vdev;
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	mbss = &mlme_obj->mgmt.mbss_11ax;
+	param->pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev);
+	param->vdev_id = wlan_vdev_get_id(vdev);
+	param->nss_2g = mlme_obj->mgmt.generic.nss_2g;
+	param->nss_5g = mlme_obj->mgmt.generic.nss_5g;
+	param->type = mlme_obj->mgmt.generic.type;
+	param->subtype = mlme_obj->mgmt.generic.subtype;
+	param->mbssid_flags = mbss->mbssid_flags;
+	param->vdevid_trans = mbss->vdevid_trans;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS vdev_mgr_create_send(struct vdev_mlme_obj *mlme_obj)
+{
+	QDF_STATUS status;
+	struct vdev_create_params param = {0};
+
+	if (!mlme_obj) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = vdev_mgr_create_param_update(mlme_obj, &param);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Param Update Error: %d", status);
+		return status;
+	}
+
+	status = tgt_vdev_mgr_create_send(mlme_obj, &param);
+
+	return status;
+}
+
+static QDF_STATUS vdev_mgr_start_param_update(
+					struct vdev_mlme_obj *mlme_obj,
+					struct vdev_start_params *param)
+{
+	struct wlan_channel *bss_chan;
+	uint32_t dfs_reg;
+	uint64_t chan_flags;
+	uint16_t chan_flags_ext;
+	bool set_agile = false, dfs_set_cfreq2 = false;
+	struct wlan_objmgr_vdev *vdev;
+	struct wlan_objmgr_pdev *pdev;
+
+	vdev = mlme_obj->vdev;
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	if (wlan_objmgr_pdev_try_get_ref(pdev, WLAN_MLME_SB_ID) !=
+							QDF_STATUS_SUCCESS) {
+		mlme_err("Failed to get pdev reference");
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	bss_chan = wlan_vdev_mlme_get_bss_chan(vdev);
+	param->vdev_id = wlan_vdev_get_id(vdev);
+	chan_flags = mlme_obj->mgmt.generic.chan_flags;
+	chan_flags_ext = mlme_obj->mgmt.generic.chan_flags_ext;
+
+	tgt_dfs_set_current_channel(pdev, bss_chan->ch_freq,
+				    chan_flags, chan_flags_ext,
+				    bss_chan->ch_ieee,
+				    bss_chan->ch_freq_seg1,
+				    bss_chan->ch_freq_seg2);
+
+	param->beacon_interval = mlme_obj->proto.generic.beacon_interval;
+	param->dtim_period = mlme_obj->proto.generic.dtim_period;
+	param->disable_hw_ack = mlme_obj->mgmt.generic.disable_hw_ack;
+	param->preferred_rx_streams =
+		mlme_obj->mgmt.chainmask_info.num_rx_chain;
+	param->preferred_tx_streams =
+		mlme_obj->mgmt.chainmask_info.num_tx_chain;
+
+	wlan_reg_get_dfs_region(pdev, &dfs_reg);
+	param->regdomain = dfs_reg;
+	param->he_ops = mlme_obj->proto.he_ops_info.he_ops;
+
+	param->channel.chan_id = bss_chan->ch_ieee;
+	param->channel.pwr = mlme_obj->mgmt.generic.tx_power;
+	param->channel.mhz = bss_chan->ch_freq;
+	param->channel.half_rate = mlme_obj->mgmt.rate_info.half_rate;
+	param->channel.quarter_rate = mlme_obj->mgmt.rate_info.quarter_rate;
+	param->channel.dfs_set = mlme_obj->mgmt.generic.dfs_set;
+	param->channel.dfs_set_cfreq2 = mlme_obj->mgmt.generic.dfs_set_cfreq2;
+	param->channel.is_chan_passive =
+		mlme_obj->mgmt.generic.is_chan_passive;
+	param->channel.allow_ht = mlme_obj->proto.ht_info.allow_ht;
+	param->channel.allow_vht = mlme_obj->proto.vht_info.allow_vht;
+	param->channel.phy_mode = bss_chan->ch_phymode;
+	param->channel.cfreq1 = mlme_obj->mgmt.generic.cfreq1;
+	param->channel.cfreq2 = mlme_obj->mgmt.generic.cfreq2;
+	param->channel.maxpower = mlme_obj->mgmt.generic.maxpower;
+	param->channel.minpower = mlme_obj->mgmt.generic.minpower;
+	param->channel.maxregpower = mlme_obj->mgmt.generic.maxregpower;
+	param->channel.antennamax = mlme_obj->mgmt.generic.antennamax;
+	param->channel.reg_class_id = mlme_obj->mgmt.generic.reg_class_id;
+	param->bcn_tx_rate_code = mlme_obj->mgmt.rate_info.bcn_tx_rate;
+	param->ldpc_rx_enabled = mlme_obj->proto.generic.ldpc;
+	wlan_vdev_mlme_get_ssid(vdev, param->ssid.mac_ssid,
+				&param->ssid.length);
+
+	if (bss_chan->ch_phymode == WLAN_PHYMODE_11AXA_HE80_80) {
+		tgt_dfs_find_vht80_chan_for_precac(pdev,
+						   param->channel.phy_mode,
+						   bss_chan->ch_freq_seg1,
+						   &param->channel.cfreq1,
+						   &param->channel.cfreq2,
+						   &param->channel.phy_mode,
+						   &dfs_set_cfreq2,
+						   &set_agile);
+
+		param->channel.dfs_set_cfreq2 = dfs_set_cfreq2;
+		param->channel.set_agile = set_agile;
+	}
+
+	wlan_objmgr_pdev_release_ref(pdev, WLAN_MLME_SB_ID);
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS vdev_mgr_start_send(
+			struct vdev_mlme_obj *mlme_obj,
+			bool restart)
+{
+	QDF_STATUS status;
+	struct vdev_start_params param = {0};
+
+	if (!mlme_obj) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = vdev_mgr_start_param_update(mlme_obj, &param);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Param Update Error: %d", status);
+		return status;
+	}
+
+	param.is_restart = restart;
+	status = tgt_vdev_mgr_start_send(mlme_obj, &param);
+
+	return status;
+}
+
+static QDF_STATUS vdev_mgr_delete_param_update(
+					struct vdev_mlme_obj *mlme_obj,
+					struct vdev_delete_params *param)
+{
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	param->vdev_id = wlan_vdev_get_id(vdev);
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS vdev_mgr_delete_send(struct vdev_mlme_obj *mlme_obj)
+{
+	QDF_STATUS status;
+	struct vdev_delete_params param;
+
+	if (!mlme_obj) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = vdev_mgr_delete_param_update(mlme_obj, &param);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Param Update Error: %d", status);
+		return status;
+	}
+
+	status = tgt_vdev_mgr_delete_send(mlme_obj, &param);
+
+	return status;
+}
+
+static QDF_STATUS vdev_mgr_stop_param_update(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_stop_params *param)
+{
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	param->vdev_id = wlan_vdev_get_id(vdev);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS vdev_mgr_stop_send(struct vdev_mlme_obj *mlme_obj)
+{
+	QDF_STATUS status;
+	struct vdev_stop_params param = {0};
+
+	if (!mlme_obj) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = vdev_mgr_stop_param_update(mlme_obj, &param);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Param Update Error: %d", status);
+		return status;
+	}
+
+	status = tgt_vdev_mgr_stop_send(mlme_obj, &param);
+
+	return status;
+}
+
+static QDF_STATUS vdev_mgr_config_ratemask_update(
+				struct vdev_mlme_obj *mlme_obj,
+				struct config_ratemask_params *param)
+{
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	param->vdev_id = wlan_vdev_get_id(vdev);
+	param->type = mlme_obj->mgmt.rate_info.type;
+	param->lower32 = mlme_obj->mgmt.rate_info.lower32;
+	param->higher32 = mlme_obj->mgmt.rate_info.higher32;
+	param->lower32_2 = mlme_obj->mgmt.rate_info.lower32_2;
+
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS vdev_mgr_bcn_tmpl_param_update(
+				struct vdev_mlme_obj *mlme_obj,
+				struct beacon_tmpl_params *param)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS vdev_mgr_sta_ps_param_update(
+				struct vdev_mlme_obj *mlme_obj,
+				struct sta_ps_params *param)
+{
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	param->vdev_id = wlan_vdev_get_id(vdev);
+	param->param = WLAN_MLME_CFG_UAPSD;
+	param->value = mlme_obj->proto.sta.uapsd_cfg;
+	return QDF_STATUS_SUCCESS;
+}
+
+static QDF_STATUS vdev_mgr_up_param_update(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_up_params *param)
+{
+	struct vdev_mlme_mbss_11ax *mbss;
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	param->vdev_id = wlan_vdev_get_id(vdev);
+	param->assoc_id = mlme_obj->proto.sta.assoc_id;
+	mbss = &mlme_obj->mgmt.mbss_11ax;
+	if (mbss->profile_idx) {
+		param->profile_idx = mbss->profile_idx;
+		param->profile_num = mbss->profile_num;
+		qdf_mem_copy(param->trans_bssid, mbss->trans_bssid,
+			     QDF_MAC_ADDR_SIZE);
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS vdev_mgr_up_send(struct vdev_mlme_obj *mlme_obj)
+{
+	QDF_STATUS status;
+	struct vdev_up_params param = {0};
+	struct config_ratemask_params rm_param = {0};
+	struct sta_ps_params ps_param = {0};
+	struct beacon_tmpl_params bcn_tmpl_param = {0};
+	enum QDF_OPMODE opmode;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!mlme_obj) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev_mgr_up_param_update(mlme_obj, &param);
+	vdev_mgr_bcn_tmpl_param_update(mlme_obj, &bcn_tmpl_param);
+
+	opmode = wlan_vdev_mlme_get_opmode(vdev);
+	if (opmode == QDF_STA_MODE) {
+		vdev_mgr_sta_ps_param_update(mlme_obj, &ps_param);
+		status = tgt_vdev_mgr_sta_ps_param_send(mlme_obj, &ps_param);
+
+	} else if (opmode == QDF_SAP_MODE) {
+		vdev_mgr_config_ratemask_update(mlme_obj, &rm_param);
+		status = tgt_vdev_mgr_config_ratemask_cmd_send(mlme_obj,
+							       &rm_param);
+	}
+
+	status = tgt_vdev_mgr_beacon_tmpl_send(mlme_obj, &bcn_tmpl_param);
+	if (QDF_IS_STATUS_ERROR(status))
+		return status;
+
+	status = tgt_vdev_mgr_up_send(mlme_obj, &param);
+
+	return status;
+}
+
+static QDF_STATUS vdev_mgr_down_param_update(
+					struct vdev_mlme_obj *mlme_obj,
+					struct vdev_down_params *param)
+{
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	param->vdev_id = wlan_vdev_get_id(vdev);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS vdev_mgr_down_send(struct vdev_mlme_obj *mlme_obj)
+{
+	QDF_STATUS status;
+	struct vdev_down_params param = {0};
+
+	if (!mlme_obj) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = vdev_mgr_down_param_update(mlme_obj, &param);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Param Update Error: %d", status);
+		return status;
+	}
+
+	status = tgt_vdev_mgr_down_send(mlme_obj, &param);
+
+	return status;
+}
+
+static QDF_STATUS vdev_mgr_peer_flush_tids_param_update(
+					struct vdev_mlme_obj *mlme_obj,
+					struct peer_flush_params *param,
+					uint8_t *mac,
+					uint32_t peer_tid_bitmap)
+{
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	param->vdev_id = wlan_vdev_get_id(vdev);
+	param->peer_tid_bitmap = peer_tid_bitmap;
+	qdf_mem_copy(param->peer_mac, mac, sizeof(*mac));
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS vdev_mgr_peer_flush_tids_send(struct vdev_mlme_obj *mlme_obj,
+					 uint8_t *mac,
+					 uint32_t peer_tid_bitmap)
+{
+	QDF_STATUS status;
+	struct peer_flush_params param = {0};
+
+	if (!mlme_obj || !mac) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = vdev_mgr_peer_flush_tids_param_update(mlme_obj, &param,
+						       mac, peer_tid_bitmap);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Param Update Error: %d", status);
+		return status;
+	}
+
+	status = tgt_vdev_mgr_peer_flush_tids_send(mlme_obj, &param);
+
+	return status;
+}
+
+static QDF_STATUS vdev_mgr_multiple_restart_param_update(
+				struct wlan_objmgr_pdev *pdev,
+				struct mlme_channel_param *chan,
+				uint32_t disable_hw_ack,
+				uint32_t *vdev_ids,
+				uint32_t num_vdevs,
+				struct multiple_vdev_restart_params *param)
+{
+	param->pdev_id = wlan_objmgr_pdev_get_pdev_id(pdev);
+	param->requestor_id = MULTIPLE_VDEV_RESTART_REQ_ID;
+	param->disable_hw_ack = disable_hw_ack;
+	param->cac_duration_ms = WLAN_DFS_WAIT_MS;
+	param->num_vdevs = num_vdevs;
+
+	qdf_mem_copy(param->vdev_ids, vdev_ids,
+		     sizeof(uint32_t) * (param->num_vdevs));
+	qdf_mem_copy(&param->ch_param, chan,
+		     sizeof(struct mlme_channel_param));
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS vdev_mgr_multiple_restart_send(struct wlan_objmgr_pdev *pdev,
+					  struct mlme_channel_param *chan,
+					  uint32_t disable_hw_ack,
+					  uint32_t *vdev_ids,
+					  uint32_t num_vdevs)
+{
+	struct multiple_vdev_restart_params param = {0};
+
+	vdev_mgr_multiple_restart_param_update(pdev, chan,
+					       disable_hw_ack,
+					       vdev_ids, num_vdevs,
+					       &param);
+
+	return tgt_vdev_mgr_multiple_vdev_restart_send(pdev, &param);
+}

umac/mlme/vdev_mgr/core/src/vdev_mgr_ops.h

@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: vdev_mgr_ops.h
+ *
+ * This header file provides API declarations for filling data structures
+ * and sending vdev mgmt commands to target_if/mlme/vdev_mgr
+ */
+
+#ifndef __VDEV_MGR_OPS_H__
+#define __VDEV_MGR_OPS_H__
+
+#ifdef CMN_VDEV_MGR_TGT_IF_ENABLE
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_vdev_mgr_tgt_if_tx_defs.h>
+#include <wlan_mlme_dbg.h>
+#include "include/wlan_vdev_mlme.h"
+
+/**
+ * vdev_mgr_create_send() – MLME API to create command to
+ * target_if
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_create_send(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * vdev_mgr_start_send() – MLME API to send start request to
+ * target_if
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @restart: flag to indicate type of request START/RESTART
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_start_send(struct vdev_mlme_obj *mlme_obj, bool restart);
+
+/**
+ * vdev_mgr_delete_send() – MLME API to send delete request to
+ * target_if
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_delete_send(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * vdev_mgr_peer_flush_tids_send () – MLME API to setup peer flush tids
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @mac: pointer to peer mac address
+ * @peer_tid_bitmap: peer tid bitmap
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_peer_flush_tids_send(struct vdev_mlme_obj *mlme_obj,
+					 uint8_t *mac,
+					 uint32_t peer_tid_bitmap);
+/**
+ * vdev_mgr_stop_send () – MLME API to send STOP request
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_stop_send(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * vdev_mgr_up_send () – MLME API to send UP command
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_up_send(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * vdev_mgr_down_send () – MLME API to send down command
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_down_send(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * vdev_mgr_set_param_send() – MLME API to send vdev param
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param_id: parameter id
+ * @param_value: value corresponding to parameter id
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_set_param_send(struct vdev_mlme_obj *mlme_obj,
+				   uint32_t param_id,
+				   uint32_t param_value);
+
+/**
+ * vdev_mgr_set_neighbour_rx_cmd_send() – MLME API to send neighbour Rx
+ * cmd
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to set neighbour rx params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_set_neighbour_rx_cmd_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct set_neighbour_rx_params *param);
+
+/**
+ * vdev_mgr_set_nac_rssi_send() – MLME API to send nac rssi
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_scan_nac_rssi_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_nac_rssi_send(
+			struct vdev_mlme_obj *mlme_obj,
+			struct vdev_scan_nac_rssi_params *param);
+
+/**
+ * vdev_mgr_sifs_trigger_send() – MLME API to send SIFS trigger
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param_value: parameter value
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_sifs_trigger_send(
+			struct vdev_mlme_obj *mlme_obj,
+			uint32_t param_value);
+
+/**
+ * vdev_mgr_set_custom_aggr_size_cmd_send() – MLME API to send custom aggr
+ * size
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @val: aggregate size value
+ * @is_amsdu: boolean to indicate value corresponds to amsdu/ampdu
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_set_custom_aggr_size_send(
+			struct vdev_mlme_obj *mlme_obj,
+			uint32_t val, bool is_amsdu);
+
+/**
+ * vdev_mgr_onfig_ratemask_cmd_send() – MLME API to send ratemask
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @type: type of ratemask configuration
+ * @lower32: Lower 32 bits in the 1st 64-bit value
+ * @higher32: Higher 32 bits in the 1st 64-bit value
+ * @lower32_2: Lower 32 bits in the 2nd 64-bit value
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_config_ratemask_cmd_send(
+				struct vdev_mlme_obj *mlme_obj,
+				uint8_t type,
+				uint32_t lower32,
+				uint32_t higher32,
+				uint32_t lower32_2);
+
+/**
+ * vdev_mgr_beacon_stop() – MLME API to stop beacn
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_beacon_stop(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * vdev_mgr_beacon_free() – MLME API to free beacn
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_beacon_free(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * vdev_mgr_beacon_send() – MLME API to send beacon
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to beacon_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_beacon_send(struct vdev_mlme_obj *mlme_obj,
+				struct beacon_params *param);
+
+/**
+ * vdev_mgr_beacon_tmpl_send() – MLME API to send beacon template
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to beacon_tmpl_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_beacon_tmpl_send(struct vdev_mlme_obj *mlme_obj,
+				     struct beacon_tmpl_params *param);
+
+/**
+ * vdev_mgr_bcn_miss_offload_send() – MLME API to send bcn miss offload
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mgr_bcn_miss_offload_send(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * vdev_mgr_multiple_restart_send() – MLME API to send multiple vdev restart
+ * @pdev: pointer to pdev object
+ * @chan: pointer to channel param structure
+ * @disable_hw_ack: ddisable hw ack value
+ * @vdev_ids: pointer to list of vdev ids which require restart
+ * @num_vdevs: number of vdevs in list
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS vdev_mlme_multiple_restart_send(struct wlan_objmgr_pdev *pdev,
+					   struct mlme_channel_param *chan,
+					   uint32_t disable_hw_ack,
+					   uint32_t *vdev_ids,
+					   uint32_t num_vdevs);
+
+#endif /* CMN_VDEV_MGR_TGT_IF_ENABLE */
+#endif /* __VDEV_MGR_OPS_H__ */

umac/mlme/vdev_mgr/dispatcher/inc/wlan_vdev_mgr_tgt_if_rx_api.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_rx_ops.h
+ *
+ * API declarations to handle WMI response event corresponding to vdev mgmt
+ */
+
+#ifndef __WLAN_VDEV_MGR_RX_OPS_H__
+#define __WLAN_VDEV_MGR_RX_OPS_H__
+
+#ifdef CMN_VDEV_MGR_TGT_IF_ENABLE
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_vdev_mgr_tgt_if_rx_defs.h>
+
+/**
+ * tgt_vdev_mgr_register_rx_ops(): API to register rx ops with lmac
+ * @rx_ops: rx ops struct
+ *
+ * Return: none
+ */
+void tgt_vdev_mgr_register_rx_ops(struct wlan_lmac_if_rx_ops *rx_ops);
+#else
+/**
+ * tgt_vdev_mgr_register_rx_ops(): API to register rx ops with lmac
+ * @rx_ops: rx ops struct
+ *
+ * Return: none
+ */
+static inline void
+tgt_vdev_mgr_register_rx_ops(struct wlan_lmac_if_rx_ops *rx_ops) {}
+#endif /* CMN_VDEV_MGR_TGT_IF_ENABLE */
+
+#endif /* __WLAN_VDEV_MGR_RX_OPS_H__ */

umac/mlme/vdev_mgr/dispatcher/inc/wlan_vdev_mgr_tgt_if_rx_defs.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_tgt_if_rx_defs.h
+ *
+ * This header file provides definitions to data structures for
+ * corresponding vdev mgmt operation
+ */
+
+#ifndef __WLAN_VDEV_MGR_TGT_IF_RX_DEFS_H__
+#define __WLAN_VDEV_MGR_TGT_IF_RX_DEFS_H__
+
+#include <qdf_timer.h>
+
+#define START_RESPONSE_BIT  0x1
+#define STOP_RESPONSE_BIT   0x2
+#define DELETE_RESPONSE_BIT 0x3
+
+#define START_RESPONSE_TIMER 6000 /* 6 seconds */
+#define STOP_RESPONSE_TIMER  2000 /* 2 seconds */
+#define DELETE_RESPONSE_TIMER  2000 /* 2 seconds */
+
+/**
+ * struct vdev_response_timer - vdev mgmt response ops timer
+ * @rsp_timer: VDEV MLME mgmt response timer
+ * @rsp_status: variable to check response status
+ */
+struct vdev_response_timer {
+	qdf_timer_t rsp_timer;
+	unsigned long rsp_status;
+};
+
+/**
+ * struct vdev_start_response - start response structure
+ * @vdev_id: vdev id
+ * @requestor_id: requester id
+ * @status: status of start request
+ * @resp_type: response of event type START/RESTART
+ * @chain_mask: chain mask
+ * @smps_mode: smps mode
+ * @mac_id: mac id
+ * @cfgd_tx_streams: configured tx streams
+ * @cfgd_rx_streams: configured rx streams
+ */
+struct vdev_start_response {
+	uint8_t vdev_id;
+	uint32_t requestor_id;
+	uint32_t status;
+	uint32_t resp_type;
+	uint32_t chain_mask;
+	uint32_t smps_mode;
+	uint32_t mac_id;
+	uint32_t cfgd_tx_streams;
+	uint32_t cfgd_rx_streams;
+};
+
+/**
+ * struct vdev_stop_response - stop response structure
+ * @vdev_id: vdev id
+ */
+struct vdev_stop_response {
+	uint8_t vdev_id;
+};
+
+/**
+ * struct vdev_delete_response - delete response structure
+ * @vdev_id: vdev id
+ */
+struct vdev_delete_response {
+	uint8_t vdev_id;
+};
+
+#endif /* __WLAN_VDEV_MGR_TGT_IF_RX_DEFS_H__ */

umac/mlme/vdev_mgr/dispatcher/inc/wlan_vdev_mgr_tgt_if_tx_api.h

@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: vdev_mgr_iface_api.h
+ *
+ * API declarations required for following
+ * - get/set common mlme data structure fields
+ * - send WMI command using Tx Ops
+ */
+
+#ifndef __WLAN_VDEV_MGR_TX_OPS_API_H__
+#define __WLAN_VDEV_MGR_TX_OPS_API_H__
+
+#ifdef CMN_VDEV_MGR_TGT_IF_ENABLE
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_vdev_mgr_tgt_if_tx_defs.h>
+#include <include/wlan_vdev_mlme.h>
+
+/**
+ * tgt_vdev_mgr_rsp_timer_mgmt() – API to handle response timer, responsible
+ * for initializing and freeing
+ * @vdev: pointer to vdev
+ * @rsp_timer: response timer
+ * @init: flag to indicate whether to init/free
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_rsp_timer_mgmt(
+				struct wlan_objmgr_vdev *vdev,
+				qdf_timer_t *rsp_timer, bool init);
+
+/**
+ * tgt_vdev_mgr_create_send() – API to send create command
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_create_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_create_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_create_params *param);
+
+/**
+ * tgt_vdev_mgr_create_complete() – API to send wmi cfg corresponding
+ * to create command
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_create_complete(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * tgt_vdev_mgr_start_send() – API to send start command
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_start_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_start_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_start_params *param);
+
+/**
+ * tgt_vdev_mgr_delete_send() – API to send delete
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_delete_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_delete_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_delete_params *param);
+
+/**
+ * tgt_vdev_mgr_peer_flush_tids_send() – API to send peer flush tids in FW
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to peer_flush_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_peer_flush_tids_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct peer_flush_params *param);
+
+/**
+ * tgt_vdev_mgr_stop_send() – API to send stop command
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_stop_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_stop_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_stop_params *param);
+
+/**
+ * tgt_vdev_mgr_beacon_stop() – API to handle beacon buffer
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_beacon_stop(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * tgt_vdev_mgr_beacon_free() – API to free beacon buffer
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_beacon_free(struct vdev_mlme_obj *mlme_obj);
+
+/**
+ * tgt_vdev_mgr_up_send() – API to send up
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_up_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_up_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_up_params *param);
+
+/**
+ * tgt_vdev_mgr_down_send() – API to send down
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_down_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_down_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_down_params *param);
+
+/**
+ * tgt_vdev_mgr_set_neighbour_rx_cmd_send() – API to send neighbour rx
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to set_neighbour_rx_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_set_neighbour_rx_cmd_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct set_neighbour_rx_params *param);
+
+/**
+ * tgt_vdev_mgr_nac_rssi_send() – API to send NAC RSSI
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_scan_nac_rssi_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_nac_rssi_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_scan_nac_rssi_params *param);
+
+/**
+ * tgt_vdev_mgr_sifs_trigger_send() – API to send SIFS trigger
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to sifs_trigger_param
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_sifs_trigger_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct sifs_trigger_param *param);
+
+/**
+ * tgt_vdev_mgr_set_custom_aggr_size_send() – API to send custom aggr size
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to set_custom_aggr_size_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_set_custom_aggr_size_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct set_custom_aggr_size_params *param);
+
+/**
+ * tgt_vdev_mgr_config_ratemask_cmd_send() – API to configure ratemask
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to config_ratemask_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_config_ratemask_cmd_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct config_ratemask_params *param);
+
+/**
+ * tgt_vdev_mgr_sta_ps_param_send() – API to send sta power save configuration
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to sta_ps_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_sta_ps_param_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct sta_ps_params *param);
+
+/**
+ * tgt_vdev_mgr_beacon_cmd_send() – API to send beacon
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to beacon_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_beacon_cmd_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct beacon_params *param);
+
+/**
+ * tgt_vdev_mgr_beacon_tmpl_send() – API to send beacon template
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to beacon_tmpl_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_beacon_tmpl_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct beacon_tmpl_params *param);
+
+/**
+ * tgt_vdev_mgr_multiple_vdev_restart_send() – API to send multiple vdev
+ * restart
+ * @pdev: pointer to pdev
+ * @param: pointer to multiple_vdev_restart_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_multiple_vdev_restart_send(
+				struct wlan_objmgr_pdev *pdev,
+				struct multiple_vdev_restart_params *param);
+
+/**
+ * tgt_vdev_mgr_set_param_send() – API to send parameter cfg
+ * @mlme_obj: pointer to vdev_mlme_obj
+ * @param: pointer to vdev_set_params
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_set_param_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_set_params *param);
+
+/**
+ * tgt_vdev_mgr_bcn_miss_offload_send() – API to send beacon miss offload
+ * @mlme_obj: pointer to vdev_mlme_obj
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS tgt_vdev_mgr_bcn_miss_offload_send(struct vdev_mlme_obj *mlme_obj);
+
+#endif /* CMN_VDEV_MGR_TGT_IF_ENABLE */
+#endif /* __WLAN_VDEV_MGR_TX_OPS_API_H__ */

umac/mlme/vdev_mgr/dispatcher/inc/wlan_vdev_mgr_tgt_if_tx_defs.h

@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_tgt_if_tx_defs.h
+ *
+ * This file provides definitions to data structures required for vdev Tx ops
+ */
+
+#ifndef __WLAN_VDEV_MGR_TX_OPS_DEFS_H__
+#define __WLAN_VDEV_MGR_TX_OPS_DEFS_H__
+
+#ifdef CMN_VDEV_MGR_TGT_IF_ENABLE
+#include <qdf_nbuf.h>
+
+/**
+ * struct mac_ssid - mac ssid structure
+ * @length: ssid length
+ * @mac_ssid: ssid
+ */
+struct mlme_mac_ssid {
+	uint8_t length;
+	uint8_t mac_ssid[WLAN_SSID_MAX_LEN];
+} qdf_packed;
+
+/**
+ * enum MLME_bcn_tx_rate_code - beacon tx rate code
+ */
+enum mlme_bcn_tx_rate_code {
+	MLME_BCN_TX_RATE_CODE_1_M = 0x43,
+	MLME_BCN_TX_RATE_CODE_2_M = 0x42,
+	MLME_BCN_TX_RATE_CODE_5_5_M = 0x41,
+	MLME_BCN_TX_RATE_CODE_6_M = 0x03,
+	MLME_BCN_TX_RATE_CODE_9_M = 0x07,
+	MLME_BCN_TX_RATE_CODE_11M = 0x40,
+	MLME_BCN_TX_RATE_CODE_12_M = 0x02,
+	MLME_BCN_TX_RATE_CODE_18_M = 0x06,
+	MLME_BCN_TX_RATE_CODE_24_M = 0x01,
+	MLME_BCN_TX_RATE_CODE_36_M = 0x05,
+	MLME_BCN_TX_RATE_CODE_48_M = 0x00,
+	MLME_BCN_TX_RATE_CODE_54_M = 0x04,
+};
+
+/**
+ * struct sta_ps_params - sta ps cmd parameter
+ * @vdev_id: vdev id
+ * @param: sta ps parameter
+ * @value: sta ps parameter value
+ */
+struct sta_ps_params {
+	uint32_t vdev_id;
+	uint32_t param;
+	uint32_t value;
+};
+
+/**
+ * struct tbttoffset_params - Tbttoffset event params
+ * @vdev_id: Virtual AP device identifier
+ * @tbttoffset : Tbttoffset for the virtual AP device
+ */
+struct tbttoffset_params {
+	uint32_t vdev_id;
+	uint32_t tbttoffset;
+};
+
+/**
+ * struct beacon_tmpl_params - beacon template cmd parameter
+ * @vdev_id: vdev id
+ * @tim_ie_offset: tim ie offset
+ * @mbssid_ie_offset: mbssid ie offset
+ * @tmpl_len: beacon template length
+ * @tmpl_len_aligned: beacon template alignment
+ * @csa_switch_count_offset: CSA swith count offset in beacon frame
+ * @ext_csa_switch_count_offset: ECSA switch count offset in beacon frame
+ * @esp_ie_offset: ESP IE offset in beacon frame
+ * @frm: beacon template parameter
+ */
+struct beacon_tmpl_params {
+	uint8_t vdev_id;
+	uint32_t tim_ie_offset;
+	uint32_t mbssid_ie_offset;
+	uint32_t tmpl_len;
+	uint32_t tmpl_len_aligned;
+	uint32_t csa_switch_count_offset;
+	uint32_t ext_csa_switch_count_offset;
+	uint32_t esp_ie_offset;
+	uint8_t *frm;
+};
+
+/**
+ * struct beacon_params - beacon cmd parameter
+ * @vdev_id: vdev id
+ * @beacon_interval: Beacon interval
+ * @wbuf: beacon buffer
+ * @frame_ctrl: frame control field
+ * @bcn_txant: beacon antenna
+ * @is_dtim_count_zero: is it dtim beacon
+ * @is_bitctl_reqd: is Bit control required
+ * @is_high_latency: Is this high latency target
+ */
+struct beacon_params {
+	uint8_t vdev_id;
+	uint16_t beacon_interval;
+	qdf_nbuf_t wbuf;
+	uint16_t frame_ctrl;
+	uint32_t bcn_txant;
+	bool is_dtim_count_zero;
+	bool is_bitctl_reqd;
+	bool is_high_latency;
+};
+
+/**
+ * struct mlme_channel_param - Channel parameters with all
+ *			info required by target.
+ * @chan_id: channel id
+ * @pwr: channel power
+ * @mhz: channel frequency
+ * @half_rate: is half rate
+ * @quarter_rate: is quarter rate
+ * @dfs_set: is dfs channel
+ * @dfs_set_cfreq2: is secondary freq dfs channel
+ * @is_chan_passive: is this passive channel
+ * @allow_ht: HT allowed in chan
+ * @allow_vht: VHT allowed on chan
+ * @set_agile: is agile mode
+ * @phy_mode: phymode (vht80 or ht40 or ...)
+ * @cfreq1: centre frequency on primary
+ * @cfreq2: centre frequency on secondary
+ * @maxpower: max power for channel
+ * @minpower: min power for channel
+ * @maxreqpower: Max regulatory power
+ * @antennamac: Max antenna
+ * @reg_class_id: Regulatory class id.
+ */
+struct mlme_channel_param {
+	uint8_t chan_id;
+	uint8_t pwr;
+	uint32_t mhz;
+	uint32_t half_rate:1,
+		quarter_rate:1,
+		dfs_set:1,
+		dfs_set_cfreq2:1,
+		is_chan_passive:1,
+		allow_ht:1,
+		allow_vht:1,
+		set_agile:1;
+	enum wlan_phymode phy_mode;
+	uint32_t cfreq1;
+	uint32_t cfreq2;
+	int8_t   maxpower;
+	int8_t   minpower;
+	int8_t   maxregpower;
+	uint8_t  antennamax;
+	uint8_t  reg_class_id;
+};
+
+/**
+ * struct multiple_vdev_restart_params - Multiple vdev restart cmd parameter
+ * @pdev_id: Pdev identifier
+ * @requestor_id: Unique id identifying the module
+ * @disable_hw_ack: Flag to indicate disabling HW ACK during CAC
+ * @cac_duration_ms: CAC duration on the given channel
+ * @num_vdevs: No. of vdevs that need to be restarted
+ * @ch_param: Pointer to channel_param
+ * @vdev_ids: Pointer to array of vdev_ids
+ */
+struct multiple_vdev_restart_params {
+	uint32_t pdev_id;
+	uint32_t requestor_id;
+	uint32_t disable_hw_ack;
+	uint32_t cac_duration_ms;
+	uint32_t num_vdevs;
+	struct mlme_channel_param ch_param;
+	uint32_t vdev_ids[WLAN_UMAC_PDEV_MAX_VDEVS];
+};
+
+/**
+ * struct peer_flush_params - peer flush cmd parameter
+ * @peer_tid_bitmap: peer tid bitmap
+ * @vdev_id: vdev id
+ * @peer_mac: peer mac address
+ */
+struct peer_flush_params {
+	uint32_t peer_tid_bitmap;
+	uint8_t vdev_id;
+	uint8_t peer_mac[QDF_MAC_ADDR_SIZE];
+};
+
+/**
+ * struct config_ratemask_params - ratemask config parameters
+ * @vdev_id: vdev id
+ * @type: Type
+ * @lower32: Lower 32 bits in the 1st 64-bit value
+ * @higher32: Higher 32 bits in the 1st 64-bit value
+ * @lower32_2: Lower 32 bits in the 2nd 64-bit value
+ */
+struct config_ratemask_params {
+	uint8_t vdev_id;
+	uint8_t type;
+	uint32_t lower32;
+	uint32_t higher32;
+	uint32_t lower32_2;
+};
+
+/**
+ * struct set_custom_aggr_size_params - custom aggr size params
+ * @vdev_id : vdev id
+ * @tx_aggr_size : TX aggr size
+ * @rx_aggr_size : RX aggr size
+ * @enable_bitmap: Bitmap for aggr size check
+ */
+struct set_custom_aggr_size_params {
+	uint32_t  vdev_id;
+	uint32_t tx_aggr_size;
+	uint32_t rx_aggr_size;
+	uint32_t ac:2,
+		 aggr_type:1,
+		 tx_aggr_size_disable:1,
+		 rx_aggr_size_disable:1,
+		 tx_ac_enable:1,
+		 reserved:26;
+};
+
+/**
+ * struct sifs_trigger_param - sifs_trigger cmd parameter
+ * @vdev_id: vdev id
+ * @param_value: parameter value
+ */
+struct sifs_trigger_param {
+	uint32_t vdev_id;
+	uint32_t param_value;
+};
+
+/**
+ * struct set_neighbour_rx_params - Neighbour RX params
+ * @vdev_id: vdev id
+ * @idx: index of param
+ * @action: action
+ * @type: Type of param
+ */
+struct set_neighbour_rx_params {
+	uint8_t vdev_id;
+	uint32_t idx;
+	uint32_t action;
+	uint32_t type;
+};
+
+/**
+ * struct vdev_scan_nac_rssi_params - NAC_RSSI cmd parameter
+ * @vdev_id: vdev id
+ * @bssid_addr: BSSID address
+ * @client_addr: client address
+ * @chan_num: channel number
+ * @action:NAC_RSSI action,
+ */
+struct vdev_scan_nac_rssi_params {
+	uint32_t vdev_id;
+	uint8_t bssid_addr[QDF_MAC_ADDR_SIZE];
+	uint8_t client_addr[QDF_MAC_ADDR_SIZE];
+	uint32_t chan_num;
+	uint32_t action; /* WMI_FILTER_NAC_RSSI_ACTION */
+};
+
+/**
+ * struct vdev_start_params - vdev start cmd parameter
+ * @vdev_id: vdev id
+ * @beacon_interval: beacon interval
+ * @dtim_period: dtim period
+ * @is_restart: flag to check if it is vdev
+ * @disable_hw_ack: to update disable hw ack flag
+ * @hidden_ssid: hidden ssid
+ * @pmf_enabled: pmf enabled
+ * @ssid: ssid MAC
+ * @num_noa_descriptors: number of noa descriptors
+ * @preferred_tx_streams: preferred tx streams
+ * @preferred_rx_streams: preferred rx streams
+ * @cac_duration_ms: cac duration in milliseconds
+ * @regdomain: Regulatory domain
+ * @he_ops: HE ops
+ * @channel_param: Channel params required by target.
+ * @bcn_tx_rate_code: Beacon tx rate code.
+ * @ldpc_rx_enabled: Enable/Disable LDPC RX for this vdev
+ */
+struct vdev_start_params {
+	uint8_t vdev_id;
+	uint32_t beacon_interval;
+	uint32_t dtim_period;
+	bool is_restart;
+	uint32_t disable_hw_ack;
+	bool hidden_ssid;
+	bool pmf_enabled;
+	struct mlme_mac_ssid ssid;
+	uint32_t num_noa_descriptors;
+	uint32_t preferred_rx_streams;
+	uint32_t preferred_tx_streams;
+	uint32_t cac_duration_ms;
+	uint32_t regdomain;
+	uint32_t he_ops;
+	struct mlme_channel_param channel;
+	enum mlme_bcn_tx_rate_code bcn_tx_rate_code;
+	bool ldpc_rx_enabled;
+};
+
+/**
+ * struct vdev_set_params - vdev set cmd parameter
+ * @vdev_id: vdev id
+ * @param_id: parameter id
+ * @param_value: parameter value
+ */
+struct vdev_set_params {
+	uint32_t vdev_id;
+	uint32_t param_id;
+	uint32_t param_value;
+};
+
+/**
+ * struct vdev_create_params - vdev create cmd parameter
+ * @vdev_id: interface id
+ * @type: interface type
+ * @subtype: interface subtype
+ * @nss_2g: NSS for 2G
+ * @nss_5g: NSS for 5G
+ * @pdev_id: pdev id on pdev for this vdev
+ * @mbssid_flags: MBSS IE flags indicating vdev type
+ * @vdevid_trans: id of transmitting vdev for MBSS IE
+ */
+struct vdev_create_params {
+	uint8_t vdev_id;
+	uint32_t type;
+	uint32_t subtype;
+	uint8_t nss_2g;
+	uint8_t nss_5g;
+	uint32_t pdev_id;
+	uint32_t mbssid_flags;
+	uint8_t vdevid_trans;
+};
+
+/**
+ * struct vdev_delete_params - vdev delete cmd parameter
+ * @vdev_id: vdev id
+ */
+struct vdev_delete_params {
+	uint8_t vdev_id;
+};
+
+/**
+ * struct vdev_stop_params - vdev stop cmd parameter
+ * @vdev_id: vdev id
+ */
+struct vdev_stop_params {
+	uint8_t vdev_id;
+};
+
+/**
+ * struct vdev_up_params - vdev up cmd parameter
+ * @vdev_id: vdev id
+ * @assoc_id: association id
+ * @profile_idx: profile index of the connected non-trans ap (mbssid case).
+ *		0  means invalid.
+ * @profile_num: the total profile numbers of non-trans aps (mbssid case).
+ *		0 means non-MBSS AP.
+ * @trans_bssid: bssid of transmitted AP (MBSS IE case)
+ */
+struct vdev_up_params {
+	uint8_t vdev_id;
+	uint16_t assoc_id;
+	uint32_t profile_idx;
+	uint32_t profile_num;
+	uint8_t trans_bssid[QDF_MAC_ADDR_SIZE];
+};
+
+/**
+ * struct vdev_down_params - vdev down cmd parameter
+ * @vdev_id: vdev id
+ */
+struct vdev_down_params {
+	uint8_t vdev_id;
+};
+
+#endif
+#endif /* __WLAN_VDEV_MGR_TX_OPS_DEFS_H__ */

umac/mlme/vdev_mgr/dispatcher/inc/wlan_vdev_mgr_ucfg_api.h

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_ucfg_api.h
+ *
+ * This header file provides definitions to data structures required
+ * for mlme ucfg and declarations for ucfg public APIs
+ */
+
+#ifndef __UCFG_WLAN_VDEV_MLME_UCFG_H__
+#define __UCFG_WLAN_VDEV_MLME_UCFG_H__
+
+#include <wlan_objmgr_vdev_obj.h>
+#include <wlan_vdev_mgr_tgt_if_tx_defs.h>
+#include <qdf_nbuf.h>
+#include <include/wlan_vdev_mlme.h>
+
+enum wlan_mlme_cfg_id {
+	WLAN_MLME_CFG_DTIM_PERIOD,
+	WLAN_MLME_CFG_SLOT_TIME,
+	WLAN_MLME_CFG_PROTECTION_MODE,
+	WLAN_MLME_CFG_BEACON_INTERVAL,
+	WLAN_MLME_CFG_LDPC,
+	WLAN_MLME_CFG_NSS,
+	WLAN_MLME_CFG_TSF_ADJUST,
+	WLAN_MLME_CFG_ASSOC_ID,
+	WLAN_MLME_CFG_VHT_CAPS,
+	WLAN_MLME_CFG_SUBFER,
+	WLAN_MLME_CFG_MUBFER,
+	WLAN_MLME_CFG_SUBFEE,
+	WLAN_MLME_CFG_MUBFEE,
+	WLAN_MLME_CFG_IMLICIT_BF,
+	WLAN_MLME_CFG_SOUNDING_DIM,
+	WLAN_MLME_CFG_HT_CAPS,
+	WLAN_MLME_CFG_HE_OPS,
+	WLAN_MLME_CFG_RTS_THRESHOLD,
+	WLAN_MLME_CFG_FRAG_THRESHOLD,
+	WLAN_MLME_CFG_PROBE_DELAY,
+	WLAN_MLME_CFG_REPEAT_PROBE_TIME,
+	WLAN_MLME_CFG_DROP_UNENCRY,
+	WLAN_MLME_CFG_TX_PWR_LIMIT,
+	WLAN_MLME_CFG_TX_POWER,
+	WLAN_MLME_CFG_AMPDU,
+	WLAN_MLME_CFG_AMSDU,
+	WLAN_MLME_CFG_SSID,
+	WLAN_MLME_CFG_SSID_LEN,
+	WLAN_MLME_CFG_OP_MODE,
+	WLAN_MLME_CFG_BMISS_FIRST_BCNT,
+	WLAN_MLME_CFG_BMISS_FINAL_BCNT,
+	WLAN_MLME_CFG_MIN_IDLE_INACTIVE_TIME,
+	WLAN_MLME_CFG_MAX_IDLE_INACTIVE_TIME,
+	WLAN_MLME_CFG_MAX_UNRESPONSIVE_INACTIVE_TIME,
+	WLAN_MLME_CFG_RATE_FLAGS,
+	WLAN_MLME_CFG_PER_BAND_TX_MGMT_RATE,
+	WLAN_MLME_CFG_MAX_RATE,
+	WLAN_MLME_CFG_TX_MGMT_RATE,
+	WLAN_MLME_CFG_TX_CHAINMASK,
+	WLAN_MLME_CFG_RX_CHAINMASK,
+	WLAN_MLME_CFG_PKT_POWERSAVE,
+	WLAN_MLME_CFG_MAX_LI_OF_MODDTIM,
+	WLAN_MLME_CFG_DYNDTIM_CNT,
+	WLAN_MLME_CFG_LISTEN_INTERVAL,
+	WLAN_MLME_CFG_MODDTIM_CNT,
+	WLAN_MLME_CFG_BEACON_BUFFER,
+	WLAN_MLME_CFG_BEACON_OFFSETS,
+	WLAN_MLME_CFG_PROILE_IDX,
+	WLAN_MLME_CFG_PROFILE_NUM,
+	WLAN_MLME_CFG_MBSSID_FLAGS,
+	WLAN_MLME_CFG_VDEVID_TRANS,
+	WLAN_MLME_CFG_TRANS_BSSID,
+	WLAN_MLME_CFG_TYPE,
+	WLAN_MLME_CFG_SUBTYPE,
+	WLAN_MLME_CFG_UAPSD,
+	WLAN_MLME_CFG_TX_DECAP_TYPE,
+	WLAN_MLME_CFG_RX_DECAP_TYPE,
+	WLAN_MLME_CFG_RATEMASK_TYPE,
+	WLAN_MLME_CFG_RATEMASK_LOWER32,
+	WLAN_MLME_CFG_RATEMASK_HIGHER32,
+	WLAN_MLME_CFG_RATEMASK_LOWER32_2,
+	WLAN_MLME_CFG_BCN_TX_RATE,
+	WLAN_MLME_CFG_2G_VHT,
+	WLAN_MLME_CFG_11AX_STUB,
+	WLAN_MLME_CFG_MAX
+};
+
+struct wlan_vdev_mgr_cfg {
+	union {
+		uint32_t value;
+		uint8_t trans_bssid[QDF_MAC_ADDR_SIZE];
+		struct mlme_mac_ssid ssid_cfg;
+	} u;
+};
+
+QDF_STATUS ucfg_wlan_vdev_mgr_set_param(struct wlan_objmgr_vdev *vdev,
+					enum wlan_mlme_cfg_id param_id,
+					struct wlan_vdev_mgr_cfg mlme_cfg);
+
+void ucfg_wlan_vdev_mgr_get_param(struct wlan_objmgr_vdev *vdev,
+				  enum wlan_mlme_cfg_id param_id,
+				  uint32_t *param_value);
+
+void ucfg_wlan_vdev_mgr_get_param_ssid(struct wlan_objmgr_vdev *vdev,
+				       uint8_t *ssid,
+				       uint8_t *ssid_len);
+
+void ucfg_wlan_vdev_mgr_get_beacon_buffer(struct wlan_objmgr_vdev *vdev,
+					  qdf_nbuf_t buf);
+
+void ucfg_wlan_vdev_mgr_get_trans_bssid(struct wlan_objmgr_vdev *vdev,
+					uint8_t *addr);
+
+#endif /* __UCFG_WLAN_VDEV_MLME_UCFG_H__ */

umac/mlme/vdev_mgr/dispatcher/inc/wlan_vdev_mgr_utils_api.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_utils_api.h
+ *
+ * This file provides declaration for APIs used for psoc enable/disable
+ */
+
+#ifndef __WLAN_VDEV_MGR_UTILS_API_H__
+#define __WLAN_VDEV_MGR_UTILS_API_H__
+
+#include <wlan_objmgr_psoc_obj.h>
+#include <include/wlan_vdev_mlme.h>
+#include <wlan_vdev_mgr_ucfg_api.h>
+#include <cdp_txrx_cmn_struct.h>
+
+/**
+ * wlan_util_vdev_get_cdp_txrx_opmode - get cdp txrx opmode from qdf mode
+ * @vdev: pointer to vdev object
+ *
+ * Return: wlan_opmode
+ */
+enum wlan_op_mode
+wlan_util_vdev_get_cdp_txrx_opmode(struct wlan_objmgr_vdev *vdev);
+
+/**
+ * wlan_util_vdev_mlme_set_param() – common MLME API to fill common
+ * parameters of vdev_mlme object
+ * @vdev_mlme: pointer to vdev_mlme object
+ * @param_id: param id for which the value should be set
+ * @param_value: value that should bem set to the parameter
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+QDF_STATUS wlan_util_vdev_mlme_set_param(struct vdev_mlme_obj *vdev_mlme,
+					 enum wlan_mlme_cfg_id param_id,
+					 struct wlan_vdev_mgr_cfg mlme_cfg);
+
+/**
+ * wlan_util_vdev_mlme_get_param() – common MLME API to get common
+ * parameters of vdev_mlme object
+ * @vdev_mlme: pointer to vdev_mlme object
+ * @param_id: param id for which the value should be set
+ * @param_value: value that should bem set to the parameter
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+void wlan_util_vdev_mlme_get_param(struct vdev_mlme_obj *vdev_mlme,
+				   enum wlan_mlme_cfg_id param_id,
+				   uint32_t *param_value);
+
+/**
+ * wlan_util_vdev_get_param() – common MLME API to get common
+ * parameters of vdev_mlme object
+ * @vdev_mlme: pointer to vdev_mlme object
+ * @param_id: param id for which the value should be set
+ * @param_value: value that should bem set to the parameter
+ *
+ * Return: QDF_STATUS - Success or Failure
+ */
+void wlan_util_vdev_get_param(struct wlan_objmgr_vdev *vdev,
+			      enum wlan_mlme_cfg_id param_id,
+			      uint32_t *param_value);
+
+#endif /* __WLAN_VDEV_MGR_UTILS_API_H__ */

umac/mlme/vdev_mgr/dispatcher/inc/wlan_vdev_mlme_api.h

@@ -22,7 +22,9 @@
 #define _WLAN_VDEV_MLME_API_H_
 
 /**
- * wlan_vdev_mlme_get_cmpt_obj - Returns MLME component object
+ * wlan_vdev_mlme_get_cmpt_obj - Retrieves MLME component object
+ * from VDEV object
+ * @vdev: pointer to vdev object
  *
  * Retrieves MLME component object from VDEV object
  *
@@ -31,8 +33,20 @@
  */
 struct vdev_mlme_obj *wlan_vdev_mlme_get_cmpt_obj(
 						struct wlan_objmgr_vdev *vdev);
+/**
+ * wlan_vdev_mlme_set_ext_hdl - Sets legacy handle
+ * @vdev: pointer to vdev object
+ * @ext_hdl: pointer to legacy handle
+ *
+ * Sets Legacy handle to MLME component object
+ *
+ * Return:
+ */
+void wlan_vdev_mlme_set_ext_hdl(struct wlan_objmgr_vdev *vdev, void *ext_hdl);
+
 /**
  * wlan_vdev_mlme_get_ext_hdl - Returns legacy handle
+ * @vdev: pointer to vdev object
  *
  * Retrieves legacy handle from vdev mlme component object
  *

umac/mlme/vdev_mgr/dispatcher/src/wlan_vdev_mgr_tgt_if_rx_api.c

@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_tgt_if_rx_api.c
+ *
+ * This file provide definition for APIs registered for LMAC MLME Rx Ops
+ */
+#include <qdf_types.h>
+#include <wlan_vdev_mgr_tgt_if_rx_defs.h>
+#include <wlan_vdev_mgr_tgt_if_rx_api.h>
+#include <include/wlan_vdev_mlme.h>
+#include <wlan_mlme_dbg.h>
+#include <wlan_vdev_mlme_api.h>
+
+static void tgt_vdev_mgr_response_timeout_handler(
+					struct wlan_objmgr_vdev *vdev)
+{
+}
+
+static struct vdev_response_timer *
+tgt_vdev_mgr_get_response_timer_info(struct wlan_objmgr_vdev *vdev)
+{
+	struct vdev_mlme_obj *vdev_mlme;
+
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return NULL;
+	}
+
+	return &vdev_mlme->vdev_rt;
+}
+
+static QDF_STATUS tgt_vdev_mgr_start_response_handle(
+					struct wlan_objmgr_psoc *psoc,
+					struct vdev_start_response *rsp)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct vdev_mlme_obj *vdev_mlme;
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_response_timer *vdev_rsp;
+
+	if (!rsp || !psoc) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, rsp->vdev_id,
+						    WLAN_MLME_SB_ID);
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		goto tgt_vdev_mgr_start_response_handle_end;
+	}
+
+	vdev_rsp = &vdev_mlme->vdev_rt;
+	if (!vdev_rsp)
+		goto tgt_vdev_mgr_start_response_handle_end;
+
+	if (!qdf_atomic_test_and_clear_bit(START_RESPONSE_BIT,
+					   &vdev_rsp->rsp_status)) {
+		mlme_info("Unexpected response");
+		goto tgt_vdev_mgr_start_response_handle_end;
+	}
+
+	qdf_timer_stop(&vdev_rsp->rsp_timer);
+
+	if ((vdev_mlme->ops) && vdev_mlme->ops->mlme_vdev_ext_start_rsp)
+		status = vdev_mlme->ops->mlme_vdev_ext_start_rsp(
+								vdev_mlme,
+								rsp);
+tgt_vdev_mgr_start_response_handle_end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_SB_ID);
+	return status;
+}
+
+static QDF_STATUS tgt_vdev_mgr_stop_response_handle(
+					struct wlan_objmgr_psoc *psoc,
+					struct vdev_stop_response *rsp)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct vdev_mlme_obj *vdev_mlme;
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_response_timer *vdev_rsp;
+
+	if (!rsp || !psoc) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, rsp->vdev_id,
+						    WLAN_MLME_SB_ID);
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		goto tgt_vdev_mgr_stop_response_handle_end;
+	}
+
+	vdev_rsp = &vdev_mlme->vdev_rt;
+	if (!vdev_rsp)
+		goto tgt_vdev_mgr_stop_response_handle_end;
+
+	if (!qdf_atomic_test_and_clear_bit(STOP_RESPONSE_BIT,
+					   &vdev_rsp->rsp_status)) {
+		mlme_info("Unexpected response");
+		goto tgt_vdev_mgr_stop_response_handle_end;
+	}
+
+	qdf_timer_stop(&vdev_rsp->rsp_timer);
+
+	if ((vdev_mlme->ops) && vdev_mlme->ops->mlme_vdev_ext_stop_rsp)
+		status = vdev_mlme->ops->mlme_vdev_ext_stop_rsp(
+								vdev_mlme,
+								rsp);
+tgt_vdev_mgr_stop_response_handle_end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_SB_ID);
+	return status;
+}
+
+static QDF_STATUS tgt_vdev_mgr_delete_response_handle(
+					struct wlan_objmgr_psoc *psoc,
+					struct vdev_delete_response *rsp)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct vdev_mlme_obj *vdev_mlme;
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_response_timer *vdev_rsp;
+
+	if (!rsp || !psoc) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc, rsp->vdev_id,
+						    WLAN_MLME_SB_ID);
+	if (!vdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		goto tgt_vdev_mgr_delete_response_handle_end;
+	}
+
+	vdev_rsp = &vdev_mlme->vdev_rt;
+	if (!vdev_rsp)
+		goto tgt_vdev_mgr_delete_response_handle_end;
+
+	if (!qdf_atomic_test_and_clear_bit(DELETE_RESPONSE_BIT,
+					   &vdev_rsp->rsp_status)) {
+		mlme_info("Unexpected response");
+		goto tgt_vdev_mgr_delete_response_handle_end;
+	}
+
+	qdf_timer_stop(&vdev_rsp->rsp_timer);
+
+	if ((vdev_mlme->ops) &&
+	    vdev_mlme->ops->mlme_vdev_ext_delete_rsp)
+		status = vdev_mlme->ops->mlme_vdev_ext_delete_rsp(
+								vdev_mlme,
+								rsp);
+
+tgt_vdev_mgr_delete_response_handle_end:
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_SB_ID);
+	return status;
+}
+
+static QDF_STATUS
+tgt_vdev_mgr_offload_bcn_tx_status_event_handle(uint32_t vdev_id,
+						uint32_t tx_status)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	return status;
+}
+
+static QDF_STATUS
+tgt_vdev_mgr_tbttoffset_update_handle(uint32_t num_vdevs, bool is_ext)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	return status;
+}
+
+static QDF_STATUS
+tgt_vdev_mgr_ext_tbttoffset_update_handle(uint32_t num_vdevs, bool is_ext)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+
+	return status;
+}
+
+void tgt_vdev_mgr_register_rx_ops(struct wlan_lmac_if_rx_ops *rx_ops)
+{
+	struct wlan_lmac_if_mlme_rx_ops *mlme_rx_ops = &rx_ops->mops;
+
+	mlme_rx_ops->vdev_mgr_offload_bcn_tx_status_event_handle =
+		tgt_vdev_mgr_offload_bcn_tx_status_event_handle;
+	mlme_rx_ops->vdev_mgr_tbttoffset_update_handle =
+		tgt_vdev_mgr_tbttoffset_update_handle;
+	mlme_rx_ops->vdev_mgr_start_response =
+		tgt_vdev_mgr_start_response_handle;
+	mlme_rx_ops->vdev_mgr_stop_response =
+		tgt_vdev_mgr_stop_response_handle;
+	mlme_rx_ops->vdev_mgr_delete_response =
+		tgt_vdev_mgr_delete_response_handle;
+	mlme_rx_ops->vdev_mgr_get_response_timer_info =
+		tgt_vdev_mgr_get_response_timer_info;
+	mlme_rx_ops->vdev_mgr_response_timeout_cb =
+		tgt_vdev_mgr_response_timeout_handler;
+}

umac/mlme/vdev_mgr/dispatcher/src/wlan_vdev_mgr_tgt_if_tx_api.c

@@ -0,0 +1,574 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_tgt_if_tx_api.c
+ *
+ * This file provides definitions for mlme tgt_if APIs, which will
+ * further call target_if/mlme component using LMAC MLME txops
+ */
+#include <wlan_vdev_mgr_tgt_if_tx_api.h>
+#include <target_if_vdev_mgr_tx_ops.h>
+#include "include/wlan_vdev_mlme.h"
+#include <wlan_mlme_dbg.h>
+#include <cdp_txrx_cmn_struct.h>
+#include <cdp_txrx_cmn.h>
+#include <wlan_lmac_if_api.h>
+#include <wlan_utility.h>
+#include <cdp_txrx_ctrl.h>
+#include <wlan_vdev_mlme_api.h>
+#include <wlan_dfs_utils_api.h>
+#include <wlan_vdev_mgr_utils_api.h>
+
+static inline struct wlan_lmac_if_mlme_tx_ops
+*wlan_vdev_mlme_get_lmac_txops(struct wlan_objmgr_vdev *vdev)
+{
+	struct wlan_objmgr_psoc *psoc;
+
+	psoc = wlan_vdev_get_psoc(vdev);
+
+	return target_if_vdev_mgr_get_tx_ops(psoc);
+}
+
+QDF_STATUS tgt_vdev_mgr_rsp_timer_mgmt(
+				struct wlan_objmgr_vdev *vdev,
+				qdf_timer_t *rsp_timer,
+				bool init)
+{
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_mlme_rsp_timer_mgmt) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	return txops->vdev_mlme_rsp_timer_mgmt(vdev, rsp_timer, init);
+}
+
+QDF_STATUS tgt_vdev_mgr_create_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_create_params *param)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_objmgr_vdev *vdev;
+	ol_txrx_soc_handle soc_txrx_handle;
+	struct cdp_pdev *pdev_txrx_handle;
+	struct cdp_vdev *vdev_txrx_handle;
+	enum wlan_op_mode cdp_txrx_opmode;
+	uint32_t vdev_id;
+	uint8_t *vdev_addr;
+	struct vdev_response_timer *vdev_rsp;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_create_send ||
+	    !txops->vdev_mgr_resp_timer_mgmt) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	cdp_txrx_opmode = wlan_util_vdev_get_cdp_txrx_opmode(vdev);
+	vdev_id = wlan_vdev_get_id(vdev);
+	vdev_addr = wlan_vdev_mlme_get_macaddr(vdev);
+	psoc = wlan_vdev_get_psoc(vdev);
+	pdev = wlan_vdev_get_pdev(vdev);
+	soc_txrx_handle = wlan_psoc_get_dp_handle(psoc);
+	pdev_txrx_handle = wlan_pdev_get_dp_handle(pdev);
+	if (!soc_txrx_handle || !pdev_txrx_handle)
+		goto tgt_vdev_mgr_create_end;
+
+	vdev_txrx_handle = cdp_vdev_attach(soc_txrx_handle,
+					   pdev_txrx_handle,
+					   vdev_addr, vdev_id,
+					   cdp_txrx_opmode);
+	if (!vdev_txrx_handle)
+		goto tgt_vdev_mgr_create_end;
+
+	wlan_vdev_set_dp_handle(vdev, vdev_txrx_handle);
+	status = txops->vdev_create_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Tx Ops Error : %d", status);
+		goto tgt_vdev_mgr_create_send_end;
+	} else {
+		vdev_rsp = &mlme_obj->vdev_rt;
+		txops->vdev_mgr_resp_timer_mgmt(vdev, &vdev_rsp->rsp_timer,
+						true);
+	}
+
+	return status;
+
+tgt_vdev_mgr_create_send_end:
+	wlan_vdev_set_dp_handle(vdev, NULL);
+	cdp_vdev_detach(soc_txrx_handle, vdev_txrx_handle, NULL, NULL);
+tgt_vdev_mgr_create_end:
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_create_complete(struct vdev_mlme_obj *mlme_obj)
+{
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_vdev_mgr_start_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_start_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_start_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = txops->vdev_start_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error : %d", status);
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_delete_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_delete_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+	struct wlan_objmgr_psoc *psoc;
+	ol_txrx_soc_handle soc_txrx_handle;
+	struct cdp_vdev *vdev_txrx_handle;
+	struct vdev_response_timer *vdev_rsp;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	psoc = wlan_vdev_get_psoc(vdev);
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_delete_send ||
+	    !txops->vdev_mgr_resp_timer_mgmt) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev_rsp = &mlme_obj->vdev_rt;
+	if (vdev_rsp)
+		qdf_timer_start(&vdev_rsp->rsp_timer, DELETE_RESPONSE_TIMER);
+
+	status = txops->vdev_delete_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status)) {
+		mlme_err("Tx Ops Error : %d", status);
+		qdf_timer_stop(&vdev_rsp->rsp_timer);
+		soc_txrx_handle = wlan_psoc_get_dp_handle(psoc);
+		vdev_txrx_handle = wlan_vdev_get_dp_handle(vdev);
+		if (soc_txrx_handle && vdev_txrx_handle) {
+			wlan_vdev_set_dp_handle(vdev, NULL);
+			cdp_vdev_detach(soc_txrx_handle, vdev_txrx_handle,
+					NULL, NULL);
+		}
+	} else {
+		if (!qdf_atomic_test_and_set_bit(DELETE_RESPONSE_BIT,
+						 &vdev_rsp->rsp_status))
+			mlme_debug("Cmd Bit already set");
+
+		/* pre lithium chipsets doesn't have delete response */
+		if (!txops->target_is_pre_lithium(psoc)) {
+			qdf_timer_stop(&vdev_rsp->rsp_timer);
+			txops->vdev_mgr_resp_timer_mgmt(vdev,
+							&vdev_rsp->rsp_timer,
+							false);
+			qdf_atomic_clear_bit(DELETE_RESPONSE_BIT,
+					     &vdev_rsp->rsp_status);
+		}
+	}
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_peer_flush_tids_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct peer_flush_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->peer_flush_tids_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = txops->peer_flush_tids_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error: %d", status);
+
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_vdev_mgr_stop_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_stop_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_stop_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = txops->vdev_stop_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error: %d", status);
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_beacon_stop(struct vdev_mlme_obj *mlme_obj)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_vdev_mgr_beacon_free(struct vdev_mlme_obj *mlme_obj)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_vdev_mgr_up_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_up_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	ol_txrx_soc_handle soc_txrx_handle;
+	struct cdp_vdev *vdev_txrx_handle;
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_up_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	/* cdp set rx and tx decap type */
+	psoc = wlan_vdev_get_psoc(vdev);
+	soc_txrx_handle = wlan_psoc_get_dp_handle(psoc);
+	vdev_txrx_handle = wlan_vdev_get_dp_handle(vdev);
+	if (!soc_txrx_handle || !vdev_txrx_handle) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	cdp_set_vdev_rx_decap_type(soc_txrx_handle,
+				   (struct cdp_vdev *)vdev_txrx_handle,
+				   mlme_obj->mgmt.generic.rx_decap_type);
+	cdp_set_tx_encap_type(soc_txrx_handle,
+			      (struct cdp_vdev *)vdev_txrx_handle,
+			      mlme_obj->mgmt.generic.tx_decap_type);
+
+	status = txops->vdev_up_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error: %d", status);
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_down_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_down_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_pdev *pdev;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_down_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	if (wlan_util_is_vdev_active(pdev, WLAN_MLME_SB_ID) ==
+						QDF_STATUS_SUCCESS) {
+		status = wlan_objmgr_pdev_try_get_ref(pdev,
+						      WLAN_MLME_SB_ID);
+		if (QDF_IS_STATUS_ERROR(status)) {
+			mlme_err("PDEV Reference error: %d", status);
+			return status;
+		}
+
+		utils_dfs_start_precac_timer(pdev);
+		wlan_objmgr_pdev_release_ref(pdev, WLAN_MLME_SB_ID);
+	}
+
+	status = txops->vdev_down_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error: %d", status);
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_set_neighbour_rx_cmd_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct set_neighbour_rx_params *param)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_vdev_mgr_nac_rssi_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_scan_nac_rssi_params *param)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_vdev_mgr_sifs_trigger_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct sifs_trigger_param *param)
+{
+	QDF_STATUS status = QDF_STATUS_E_FAILURE;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_sifs_trigger_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = txops->vdev_sifs_trigger_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error: %d", status);
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_set_custom_aggr_size_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct set_custom_aggr_size_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_set_custom_aggr_size_cmd_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = txops->vdev_set_custom_aggr_size_cmd_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error: %d", status);
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_config_ratemask_cmd_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct config_ratemask_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_config_ratemask_cmd_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = txops->vdev_config_ratemask_cmd_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error: %d", status);
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_beacon_cmd_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct beacon_params *param)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_vdev_mgr_beacon_tmpl_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct beacon_tmpl_params *param)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+QDF_STATUS tgt_vdev_mgr_multiple_vdev_restart_send(
+				struct wlan_objmgr_pdev *pdev,
+				struct multiple_vdev_restart_params *param)
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev,
+						    param->vdev_ids[0],
+						    WLAN_MLME_SB_ID);
+	if (!vdev) {
+		txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+		if (!txops || !txops->multiple_vdev_restart_req_cmd) {
+			mlme_err("No Tx Ops");
+			wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_SB_ID);
+			return QDF_STATUS_E_INVAL;
+		}
+
+		status = txops->multiple_vdev_restart_req_cmd(pdev, param);
+		if (QDF_IS_STATUS_ERROR(status))
+			mlme_err("Tx Ops Error: %d", status);
+
+		wlan_objmgr_vdev_release_ref(vdev, WLAN_MLME_SB_ID);
+	}
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_set_param_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct vdev_set_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_set_param_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = txops->vdev_set_param_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error %d for param %d",
+			 status, param->param_id);
+
+	return status;
+}
+
+QDF_STATUS tgt_vdev_mgr_sta_ps_param_send(
+				struct vdev_mlme_obj *mlme_obj,
+				struct sta_ps_params *param)
+{
+	QDF_STATUS status;
+	struct wlan_lmac_if_mlme_tx_ops *txops;
+	struct wlan_objmgr_vdev *vdev;
+
+	if (!param) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_INVAL;
+	}
+
+	vdev = mlme_obj->vdev;
+	txops = wlan_vdev_mlme_get_lmac_txops(vdev);
+	if (!txops || !txops->vdev_sta_ps_param_send) {
+		mlme_err("No Tx Ops");
+		return QDF_STATUS_E_INVAL;
+	}
+
+	status = txops->vdev_sta_ps_param_send(vdev, param);
+	if (QDF_IS_STATUS_ERROR(status))
+		mlme_err("Tx Ops Error: %d", status);
+
+	return status;
+}

umac/mlme/vdev_mgr/dispatcher/src/wlan_vdev_mgr_ucfg_api.c

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_ucfg_api.c
+ *
+ * This file provides definitions to APIs to get/set mlme fields in
+ * vdev mlme core data structures
+ */
+#include <wlan_vdev_mgr_tgt_if_tx_api.h>
+#include "wlan_vdev_mgr_ucfg_api.h"
+#include "include/wlan_vdev_mlme.h"
+#include <wlan_mlme_dbg.h>
+#include <wlan_vdev_mgr_utils_api.h>
+
+void ucfg_wlan_vdev_mgr_get_param_ssid(
+				struct wlan_objmgr_vdev *vdev,
+				uint8_t *ssid, uint8_t *ssid_len)
+{
+	struct vdev_mlme_mgmt *mlme_mgmt;
+	struct vdev_mlme_obj *vdev_mlme;
+
+	vdev_mlme = wlan_objmgr_vdev_get_comp_private_obj(
+			vdev, WLAN_UMAC_COMP_MLME);
+
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return;
+	}
+
+	mlme_mgmt = &vdev_mlme->mgmt;
+
+	*ssid_len = mlme_mgmt->generic.ssid_len;
+	qdf_mem_copy(ssid, mlme_mgmt->generic.ssid,
+		     mlme_mgmt->generic.ssid_len);
+}
+
+qdf_export_symbol(ucfg_wlan_vdev_mgr_get_param_ssid);
+
+void ucfg_wlan_vdev_mgr_get_beacon_buffer(
+				struct wlan_objmgr_vdev *vdev,
+				qdf_nbuf_t buf)
+{
+	struct vdev_mlme_obj *vdev_mlme;
+	struct vdev_mlme_mgmt *mlme_mgmt;
+
+	vdev_mlme = wlan_objmgr_vdev_get_comp_private_obj(
+			vdev, WLAN_UMAC_COMP_MLME);
+
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return;
+	}
+
+	mlme_mgmt = &vdev_mlme->mgmt;
+
+	buf = mlme_mgmt->beacon_info.beacon_buffer;
+}
+
+qdf_export_symbol(ucfg_wlan_vdev_mgr_get_beacon_buffer);
+
+void ucfg_wlan_vdev_mgr_get_trans_bssid(
+				struct wlan_objmgr_vdev *vdev,
+				uint8_t *addr)
+{
+	struct vdev_mlme_obj *vdev_mlme;
+	struct vdev_mlme_mgmt *mlme_mgmt;
+
+	vdev_mlme = wlan_objmgr_vdev_get_comp_private_obj(
+			vdev, WLAN_UMAC_COMP_MLME);
+
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return;
+	}
+
+	mlme_mgmt = &vdev_mlme->mgmt;
+
+	qdf_mem_copy(addr, mlme_mgmt->mbss_11ax.trans_bssid, QDF_MAC_ADDR_SIZE);
+}
+
+qdf_export_symbol(ucfg_wlan_vdev_mgr_get_trans_bssid);
+
+QDF_STATUS ucfg_wlan_vdev_mgr_set_param(
+				struct wlan_objmgr_vdev *vdev,
+				enum wlan_mlme_cfg_id param_id,
+				struct wlan_vdev_mgr_cfg mlme_cfg)
+{
+	struct vdev_mlme_obj *vdev_mlme;
+
+	vdev_mlme = wlan_objmgr_vdev_get_comp_private_obj(
+							vdev,
+							WLAN_UMAC_COMP_MLME);
+
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return QDF_STATUS_E_FAILURE;
+	}
+
+	return wlan_util_vdev_mlme_set_param(vdev_mlme, param_id, mlme_cfg);
+}
+
+qdf_export_symbol(ucfg_wlan_vdev_mgr_set_param);
+
+void ucfg_wlan_vdev_mgr_get_param(
+				struct wlan_objmgr_vdev *vdev,
+				enum wlan_mlme_cfg_id param_id,
+				uint32_t *value)
+{
+	struct vdev_mlme_obj *vdev_mlme;
+
+	mlme_info("paramId: %d", param_id);
+	mlme_info("paramId: %d", param_id);
+	vdev_mlme = wlan_objmgr_vdev_get_comp_private_obj(
+							vdev,
+							WLAN_UMAC_COMP_MLME);
+
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return;
+	}
+
+	wlan_util_vdev_mlme_get_param(vdev_mlme, param_id, value);
+}
+
+qdf_export_symbol(ucfg_wlan_vdev_mgr_get_param);

umac/mlme/vdev_mgr/dispatcher/src/wlan_vdev_mgr_utils_api.c

@@ -0,0 +1,477 @@
+/*
+ * Copyright (c) 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
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/**
+ * DOC: wlan_vdev_mgr_utils_api.c
+ *
+ * This file provide definition for APIs to enable Tx Ops and Rx Ops registered
+ * through LMAC
+ */
+#include <wlan_vdev_mgr_utils_api.h>
+#include <wlan_vdev_mgr_tgt_if_tx_api.h>
+#include <cdp_txrx_cmn_struct.h>
+
+enum wlan_op_mode
+wlan_util_vdev_get_cdp_txrx_opmode(struct wlan_objmgr_vdev *vdev)
+{
+	enum QDF_OPMODE qdf_opmode;
+	enum wlan_op_mode cdp_txrx_opmode;
+
+	qdf_opmode = wlan_vdev_mlme_get_opmode(vdev);
+	switch (qdf_opmode) {
+	case QDF_STA_MODE:
+		cdp_txrx_opmode = wlan_op_mode_sta;
+		break;
+	case QDF_SAP_MODE:
+		cdp_txrx_opmode = wlan_op_mode_ap;
+		break;
+	case QDF_MONITOR_MODE:
+		cdp_txrx_opmode = wlan_op_mode_monitor;
+		break;
+	default:
+		cdp_txrx_opmode = wlan_op_mode_unknown;
+	};
+
+	return cdp_txrx_opmode;
+}
+
+QDF_STATUS
+wlan_util_vdev_mlme_set_param(struct vdev_mlme_obj *vdev_mlme,
+			      enum wlan_mlme_cfg_id param_id,
+			      struct wlan_vdev_mgr_cfg mlme_cfg)
+{
+	struct wlan_objmgr_vdev *vdev;
+	struct vdev_mlme_proto *mlme_proto;
+	struct vdev_mlme_mgmt *mlme_mgmt;
+	struct vdev_mlme_inactivity_params *inactivity_params;
+	int is_wmi_cmd = 0;
+	int ret = QDF_STATUS_SUCCESS;
+	struct vdev_set_params param = {0};
+
+	vdev = vdev_mlme->vdev;
+	mlme_proto = &vdev_mlme->proto;
+	mlme_mgmt = &vdev_mlme->mgmt;
+	inactivity_params = &mlme_mgmt->inactivity_params;
+
+	switch (param_id) {
+	case WLAN_MLME_CFG_DTIM_PERIOD:
+		mlme_proto->generic.dtim_period = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_SLOT_TIME:
+		mlme_proto->generic.slot_time = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_PROTECTION_MODE:
+		mlme_proto->generic.protection_mode = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_BEACON_INTERVAL:
+		mlme_proto->generic.beacon_interval = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_LDPC:
+		mlme_proto->generic.ldpc = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_NSS:
+		mlme_proto->generic.nss = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_TSF_ADJUST:
+		mlme_proto->generic.tsfadjust = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_ASSOC_ID:
+		mlme_proto->sta.assoc_id = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_VHT_CAPS:
+		mlme_proto->vht_info.caps = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_SUBFER:
+		mlme_proto->vht_info.subfer = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_MUBFER:
+		mlme_proto->vht_info.mubfer = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_SUBFEE:
+		mlme_proto->vht_info.subfee = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_MUBFEE:
+		mlme_proto->vht_info.mubfee = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_IMLICIT_BF:
+		mlme_proto->vht_info.implicit_bf = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_SOUNDING_DIM:
+		mlme_proto->vht_info.sounding_dimension = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_HT_CAPS:
+		mlme_proto->ht_info.ht_caps = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_HE_OPS:
+		mlme_proto->he_ops_info.he_ops = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_RTS_THRESHOLD:
+		mlme_mgmt->generic.rts_threshold = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_FRAG_THRESHOLD:
+		mlme_mgmt->generic.frag_threshold = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_PROBE_DELAY:
+		mlme_mgmt->generic.probe_delay = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_REPEAT_PROBE_TIME:
+		mlme_mgmt->generic.repeat_probe_time = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_DROP_UNENCRY:
+		mlme_mgmt->generic.drop_unencry = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_TX_PWR_LIMIT:
+		mlme_mgmt->generic.tx_pwrlimit = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_TX_POWER:
+		mlme_mgmt->generic.tx_power = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_AMPDU:
+		mlme_mgmt->generic.ampdu = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_AMSDU:
+		mlme_mgmt->generic.amsdu = mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_BMISS_FIRST_BCNT:
+		inactivity_params->bmiss_first_bcnt = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_BMISS_FINAL_BCNT:
+		inactivity_params->bmiss_final_bcnt = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_MIN_IDLE_INACTIVE_TIME:
+		inactivity_params->keepalive_min_idle_inactive_time_secs =
+							mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_MAX_IDLE_INACTIVE_TIME:
+		inactivity_params->keepalive_max_idle_inactive_time_secs =
+							mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_MAX_UNRESPONSIVE_INACTIVE_TIME:
+		inactivity_params->keepalive_max_unresponsive_time_secs =
+							mlme_cfg.u.value;
+		is_wmi_cmd = 1;
+		break;
+	case WLAN_MLME_CFG_RATE_FLAGS:
+		mlme_mgmt->rate_info.rate_flags = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_PER_BAND_TX_MGMT_RATE:
+		mlme_mgmt->rate_info.per_band_tx_mgmt_rate = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_MAX_RATE:
+		mlme_mgmt->rate_info.max_rate = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_TX_MGMT_RATE:
+		mlme_mgmt->rate_info.tx_mgmt_rate = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_TX_CHAINMASK:
+		mlme_mgmt->chainmask_info.tx_chainmask = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_RX_CHAINMASK:
+		mlme_mgmt->chainmask_info.rx_chainmask = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_PKT_POWERSAVE:
+		mlme_mgmt->powersave_info.packet_powersave = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_MAX_LI_OF_MODDTIM:
+		mlme_mgmt->powersave_info.max_li_of_moddtim = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_DYNDTIM_CNT:
+		mlme_mgmt->powersave_info.dyndtim_cnt = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_LISTEN_INTERVAL:
+		mlme_mgmt->powersave_info.listen_interval = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_MODDTIM_CNT:
+		mlme_mgmt->powersave_info.moddtim_cnt = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_PROILE_IDX:
+		mlme_mgmt->mbss_11ax.profile_idx = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_PROFILE_NUM:
+		mlme_mgmt->mbss_11ax.profile_num = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_MBSSID_FLAGS:
+		mlme_mgmt->mbss_11ax.mbssid_flags = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_VDEVID_TRANS:
+		mlme_mgmt->mbss_11ax.vdevid_trans = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_SSID:
+		if (mlme_cfg.u.ssid_cfg.length <= WLAN_SSID_MAX_LEN) {
+			qdf_mem_copy(mlme_mgmt->generic.ssid,
+				     mlme_cfg.u.ssid_cfg.mac_ssid,
+				     mlme_cfg.u.ssid_cfg.length);
+			mlme_mgmt->generic.ssid_len =
+						mlme_cfg.u.ssid_cfg.length;
+		} else {
+			mlme_mgmt->generic.ssid_len = 0;
+		}
+
+		break;
+	case WLAN_MLME_CFG_TRANS_BSSID:
+		qdf_mem_copy(mlme_mgmt->mbss_11ax.trans_bssid,
+			     mlme_cfg.u.trans_bssid, QDF_MAC_ADDR_SIZE);
+		break;
+	case WLAN_MLME_CFG_TYPE:
+		mlme_mgmt->generic.type = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_SUBTYPE:
+		mlme_mgmt->generic.subtype = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_UAPSD:
+		mlme_proto->sta.uapsd_cfg = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_TX_DECAP_TYPE:
+		mlme_mgmt->generic.tx_decap_type = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_RX_DECAP_TYPE:
+		mlme_mgmt->generic.rx_decap_type = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_RATEMASK_TYPE:
+		mlme_mgmt->rate_info.type = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_RATEMASK_LOWER32:
+		mlme_mgmt->rate_info.lower32 = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_RATEMASK_HIGHER32:
+		mlme_mgmt->rate_info.higher32 = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_RATEMASK_LOWER32_2:
+		mlme_mgmt->rate_info.lower32_2 = mlme_cfg.u.value;
+		break;
+	case WLAN_MLME_CFG_BCN_TX_RATE:
+		mlme_mgmt->rate_info.bcn_tx_rate = mlme_cfg.u.value;
+		break;
+	default:
+		break;
+	}
+
+	if (is_wmi_cmd) {
+		param.param_id = param_id;
+		param.vdev_id = wlan_vdev_get_id(vdev);
+		param.param_value = mlme_cfg.u.value;
+		ret = tgt_vdev_mgr_set_param_send(vdev_mlme, &param);
+	}
+
+	return ret;
+}
+
+qdf_export_symbol(wlan_util_vdev_mlme_set_param);
+
+void wlan_util_vdev_mlme_get_param(struct vdev_mlme_obj *vdev_mlme,
+				   enum wlan_mlme_cfg_id param_id,
+				   uint32_t *value)
+{
+	struct vdev_mlme_proto *mlme_proto;
+	struct vdev_mlme_mgmt *mlme_mgmt;
+	struct vdev_mlme_inactivity_params *inactivity_params;
+
+	mlme_proto = &vdev_mlme->proto;
+	mlme_mgmt = &vdev_mlme->mgmt;
+	inactivity_params = &mlme_mgmt->inactivity_params;
+
+	switch (param_id) {
+	case WLAN_MLME_CFG_DTIM_PERIOD:
+		*value = mlme_proto->generic.dtim_period;
+		break;
+	case WLAN_MLME_CFG_SLOT_TIME:
+		*value = mlme_proto->generic.slot_time;
+		break;
+	case WLAN_MLME_CFG_PROTECTION_MODE:
+		*value = mlme_proto->generic.protection_mode;
+		break;
+	case WLAN_MLME_CFG_BEACON_INTERVAL:
+		*value = mlme_proto->generic.beacon_interval;
+		break;
+	case WLAN_MLME_CFG_LDPC:
+		*value = mlme_proto->generic.ldpc;
+		break;
+	case WLAN_MLME_CFG_NSS:
+		*value = mlme_proto->generic.nss;
+		break;
+	case WLAN_MLME_CFG_TSF_ADJUST:
+		*value = mlme_proto->generic.tsfadjust;
+		break;
+	case WLAN_MLME_CFG_ASSOC_ID:
+		*value = mlme_proto->sta.assoc_id;
+		break;
+	case WLAN_MLME_CFG_VHT_CAPS:
+		*value = mlme_proto->vht_info.caps;
+		break;
+	case WLAN_MLME_CFG_SUBFER:
+		*value = mlme_proto->vht_info.subfer;
+		break;
+	case WLAN_MLME_CFG_MUBFER:
+		*value = mlme_proto->vht_info.mubfer;
+		break;
+	case WLAN_MLME_CFG_SUBFEE:
+		*value = mlme_proto->vht_info.subfee;
+		break;
+	case WLAN_MLME_CFG_MUBFEE:
+		*value = mlme_proto->vht_info.mubfee;
+		break;
+	case WLAN_MLME_CFG_IMLICIT_BF:
+		*value = mlme_proto->vht_info.implicit_bf;
+		break;
+	case WLAN_MLME_CFG_SOUNDING_DIM:
+		*value = mlme_proto->vht_info.sounding_dimension;
+		break;
+	case WLAN_MLME_CFG_HT_CAPS:
+		*value = mlme_proto->ht_info.ht_caps;
+		break;
+	case WLAN_MLME_CFG_HE_OPS:
+		*value = mlme_proto->he_ops_info.he_ops;
+		break;
+	case WLAN_MLME_CFG_RTS_THRESHOLD:
+		*value = mlme_mgmt->generic.rts_threshold;
+		break;
+	case WLAN_MLME_CFG_FRAG_THRESHOLD:
+		*value = mlme_mgmt->generic.frag_threshold;
+		break;
+	case WLAN_MLME_CFG_PROBE_DELAY:
+		*value = mlme_mgmt->generic.probe_delay;
+		break;
+	case WLAN_MLME_CFG_REPEAT_PROBE_TIME:
+		*value = mlme_mgmt->generic.repeat_probe_time;
+		break;
+	case WLAN_MLME_CFG_DROP_UNENCRY:
+		*value = mlme_mgmt->generic.drop_unencry;
+		break;
+	case WLAN_MLME_CFG_TX_PWR_LIMIT:
+		*value = mlme_mgmt->generic.tx_pwrlimit;
+		break;
+	case WLAN_MLME_CFG_TX_POWER:
+		*value = mlme_mgmt->generic.tx_power;
+		break;
+	case WLAN_MLME_CFG_AMPDU:
+		*value = mlme_mgmt->generic.ampdu;
+		break;
+	case WLAN_MLME_CFG_AMSDU:
+		*value = mlme_mgmt->generic.amsdu;
+		break;
+	case WLAN_MLME_CFG_SSID_LEN:
+		*value = mlme_mgmt->generic.ssid_len;
+		break;
+	case WLAN_MLME_CFG_BMISS_FIRST_BCNT:
+		*value = inactivity_params->bmiss_first_bcnt;
+		break;
+	case WLAN_MLME_CFG_BMISS_FINAL_BCNT:
+		*value = inactivity_params->bmiss_final_bcnt;
+		break;
+	case WLAN_MLME_CFG_MIN_IDLE_INACTIVE_TIME:
+		*value =
+		      inactivity_params->keepalive_min_idle_inactive_time_secs;
+		break;
+	case WLAN_MLME_CFG_MAX_IDLE_INACTIVE_TIME:
+		*value =
+		      inactivity_params->keepalive_max_idle_inactive_time_secs;
+		break;
+	case WLAN_MLME_CFG_MAX_UNRESPONSIVE_INACTIVE_TIME:
+		*value =
+		      inactivity_params->keepalive_max_unresponsive_time_secs;
+		break;
+	case WLAN_MLME_CFG_RATE_FLAGS:
+		*value = mlme_mgmt->rate_info.rate_flags;
+		break;
+	case WLAN_MLME_CFG_PER_BAND_TX_MGMT_RATE:
+		*value = mlme_mgmt->rate_info.per_band_tx_mgmt_rate;
+		break;
+	case WLAN_MLME_CFG_MAX_RATE:
+		*value = mlme_mgmt->rate_info.max_rate;
+		break;
+	case WLAN_MLME_CFG_TX_MGMT_RATE:
+		*value = mlme_mgmt->rate_info.tx_mgmt_rate;
+		break;
+	case WLAN_MLME_CFG_TX_CHAINMASK:
+		*value = mlme_mgmt->chainmask_info.tx_chainmask;
+		break;
+	case WLAN_MLME_CFG_RX_CHAINMASK:
+		*value = mlme_mgmt->chainmask_info.rx_chainmask;
+		break;
+	case WLAN_MLME_CFG_PKT_POWERSAVE:
+		*value = mlme_mgmt->powersave_info.packet_powersave;
+		break;
+	case WLAN_MLME_CFG_MAX_LI_OF_MODDTIM:
+		*value = mlme_mgmt->powersave_info.max_li_of_moddtim;
+		break;
+	case WLAN_MLME_CFG_DYNDTIM_CNT:
+		*value = mlme_mgmt->powersave_info.dyndtim_cnt;
+		break;
+	case WLAN_MLME_CFG_LISTEN_INTERVAL:
+		*value = mlme_mgmt->powersave_info.listen_interval;
+		break;
+	case WLAN_MLME_CFG_MODDTIM_CNT:
+		*value = mlme_mgmt->powersave_info.moddtim_cnt;
+		break;
+	case WLAN_MLME_CFG_PROILE_IDX:
+		*value = mlme_mgmt->mbss_11ax.profile_idx;
+		break;
+	case WLAN_MLME_CFG_PROFILE_NUM:
+		*value = mlme_mgmt->mbss_11ax.profile_num;
+		break;
+	case WLAN_MLME_CFG_MBSSID_FLAGS:
+		*value = mlme_mgmt->mbss_11ax.mbssid_flags;
+		break;
+	case WLAN_MLME_CFG_VDEVID_TRANS:
+		*value = mlme_mgmt->mbss_11ax.vdevid_trans;
+		break;
+	case WLAN_MLME_CFG_BCN_TX_RATE:
+		*value = mlme_mgmt->rate_info.bcn_tx_rate;
+		break;
+	case WLAN_MLME_CFG_2G_VHT:
+		*value = mlme_proto->vht_info.en_2gvht;
+		break;
+	case WLAN_MLME_CFG_11AX_STUB:
+		*value = mlme_mgmt->generic.is_11ax_stub_enabled;
+		break;
+	default:
+		break;
+	}
+}
+
+qdf_export_symbol(wlan_util_vdev_mlme_get_param);
+
+void wlan_util_vdev_get_param(struct wlan_objmgr_vdev *vdev,
+			      enum wlan_mlme_cfg_id param_id,
+			      uint32_t *value)
+{
+	ucfg_wlan_vdev_mgr_get_param(vdev, param_id, value);
+}
+
+qdf_export_symbol(wlan_util_vdev_get_param);

umac/mlme/vdev_mgr/dispatcher/src/wlan_vdev_mlme_api.c

@@ -44,6 +44,22 @@ struct vdev_mlme_obj *wlan_vdev_mlme_get_cmpt_obj(struct wlan_objmgr_vdev *vdev)
 	return vdev_mlme;
 }
 
+void wlan_vdev_mlme_set_ext_hdl(struct wlan_objmgr_vdev *vdev, void *ext_hdl)
+{
+	struct vdev_mlme_obj *vdev_mlme;
+
+	if (!ext_hdl) {
+		mlme_err("Invalid input");
+		return;
+	}
+
+	vdev_mlme = wlan_vdev_mlme_get_cmpt_obj(vdev);
+	if (vdev_mlme)
+		vdev_mlme->ext_vdev_ptr = ext_hdl;
+}
+
+qdf_export_symbol(wlan_vdev_mlme_set_ext_hdl);
+
 void *wlan_vdev_mlme_get_ext_hdl(struct wlan_objmgr_vdev *vdev)
 {
 	struct vdev_mlme_obj *vdev_mlme;