qcacld-3.0: Register/unregister ML link wdev

Register/unregister the ml link wdev to cfg80211 layer.

Change-Id: I04312e59fbbb68bae01a18fe320175da63bdab35
CRs-Fixed: 2993466

core/hdd/inc/wlan_hdd_main.h

@@ -246,6 +246,7 @@ static inline bool in_compat_syscall(void) { return is_compat_task(); }
  * @DEVICE_IFACE_OPENED: Adapter has been "opened" via the kernel
  * @SOFTAP_INIT_DONE: Software Access Point (SAP) is initialized
  * @VENDOR_ACS_RESPONSE_PENDING: Waiting for event for vendor acs
+ * @WDEV_ONLY_REGISTERED: Only WDEV is registered
  */
 enum hdd_adapter_flags {
 	NET_DEVICE_REGISTERED,
@@ -256,6 +257,7 @@ enum hdd_adapter_flags {
 	DEVICE_IFACE_OPENED,
 	SOFTAP_INIT_DONE,
 	VENDOR_ACS_RESPONSE_PENDING,
+	WDEV_ONLY_REGISTERED,
 };
 
 /**
@@ -1259,6 +1261,8 @@ struct hdd_adapter {
 
 	/** Current MAC Address for the adapter  */
 	struct qdf_mac_addr mac_addr;
+	/* MLD address for adapter */
+	struct qdf_mac_addr mld_addr;
 
 #ifdef WLAN_NUD_TRACKING
 	struct hdd_nud_tracking_info nud_tracking;
@@ -1534,6 +1538,9 @@ struct hdd_adapter {
 #ifdef WLAN_FEATURE_PKT_CAPTURE
 	struct hdd_adapter *mon_adapter;
 #endif
+#ifdef WLAN_FEATURE_11BE_MLO
+	struct hdd_mlo_adapter_info mlo_adapter_info;
+#endif
 };
 
 #define WLAN_HDD_GET_STATION_CTX_PTR(adapter) (&(adapter)->session.station)
@@ -2623,8 +2630,14 @@ struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx,
 				     uint8_t session_type,
 				     const char *name, tSirMacAddr mac_addr,
 				     unsigned char name_assign_type,
-				     bool rtnl_held);
+				     bool rtnl_held,
+				     struct hdd_adapter_create_param *params);
 
+QDF_STATUS hdd_open_adapter_no_trans(struct hdd_context *hdd_ctx,
+				     enum QDF_OPMODE op_mode,
+				     const char *iface_name,
+				     uint8_t *mac_addr_bytes,
+				     struct hdd_adapter_create_param *params);
 /**
  * hdd_close_adapter() - remove and free @adapter from the adapter list
  * @hdd_ctx: The Hdd context containing the adapter list
@@ -4987,4 +5000,23 @@ uint8_t *hdd_ch_width_str(enum phy_ch_width ch_width);
  */
 int hdd_we_set_ch_width(struct hdd_adapter *adapter, int ch_width);
 
+/**
+ * hdd_stop_adapter_ext: close/delete the vdev session in host/fw.
+ * @hdd_context: HDD context
+ * @adapter: Pointer to hdd_adapter
+ *
+ * Close/delete the vdev session in host/firmware.
+ */
+QDF_STATUS hdd_stop_adapter_ext(struct hdd_context *hdd_ctx,
+				struct hdd_adapter *adapter);
+
+/**
+ * hdd_check_for_net_dev_ref_leak: check for vdev reference leak in driver
+ * @adapter: Pointer to hdd_adapter
+ *
+ * various function take netdev reference to get protected against netdev
+ * getting deleted in parallel, check if all those references are cleanly
+ * released.
+ */
+void hdd_check_for_net_dev_ref_leak(struct hdd_adapter *adapter);
 #endif /* end #if !defined(WLAN_HDD_MAIN_H) */

core/hdd/inc/wlan_hdd_mlo.h

@@ -21,10 +21,30 @@
  * support.
  *
  */
-
 #if !defined(WLAN_HDD_MLO_H)
 #define WLAN_HDD_MLO_H
-#include "wlan_hdd_main.h"
+#include <wlan_hdd_main.h>
+
+/**
+ * struct hdd_adapter_create_param - adapter create parameters
+ * @only_wdev_register:  Register only the wdev not the netdev
+ * @associate_with_ml_adapter: Vdev points to the same netdev adapter
+ * @is_ml_adapter: is a ml adapter with associated netdev
+ */
+struct hdd_adapter_create_param {
+	uint32_t only_wdev_register:1,
+		 associate_with_ml_adapter:1,
+		 is_ml_adapter:1,
+		 unused:29;
+};
+
+#ifdef WLAN_FEATURE_11BE_MLO
+#define hdd_adapter_is_link_adapter(x) ((x)->mlo_adapter_info.is_link_adapter)
+#define hdd_adapter_is_ml_adapter(x)   ((x)->mlo_adapter_info.is_ml_adapter)
+#else
+#define hdd_adapter_is_link_adapter(x) (0)
+#define hdd_adapter_is_ml_adapter(x)   (0)
+#endif
 
 #ifdef WLAN_FEATURE_11BE_MLO
 /**
@@ -49,6 +69,26 @@ struct hdd_mld_mac_info {
 	struct hdd_mld_mac mld_mac_list[WLAN_MAX_MLD];
 };
 
+/**
+ * struct hdd_mlo_adapter_info - Mlo specific adapter information
+ * @is_ml_adapter: Whether this is the main ml adaper attached to netdev
+ * @is_link_adapter: Whether this a link adapter without netdev
+ * @associate_with_ml_adapter: adapter which shares the vdev object with the ml
+ * adapter
+ * num_of_vdev_links: Num of vdevs/links part of the association
+ * @ml_adapter: ML adapter backpointer
+ * @link_adapter: backpointers to link adapters part of association
+ */
+struct hdd_mlo_adapter_info {
+	uint32_t is_ml_adapter:1,
+		 is_link_adapter:1,
+		 associate_with_ml_adapter:1,
+		 num_of_vdev_links:2,
+		 unsed:27;
+	struct hdd_adapter *ml_adapter;
+	struct hdd_adapter *link_adapter[WLAN_MAX_MLD];
+};
+
 /**
  * hdd_update_mld_mac_addr() - Derive mld mac address
  * @hdd_context: Global hdd context
@@ -60,11 +100,148 @@ struct hdd_mld_mac_info {
  */
 void hdd_update_mld_mac_addr(struct hdd_context *hdd_ctx,
 			     struct qdf_mac_addr hw_macaddr);
+
+/**
+ * wlan_hdd_get_mld_addr() - Function to get MLD address
+ * @hdd_ctx: hdd_context pointer
+ * @device_mode: QDF_DEVICE_MODE
+ *
+ * Function returns the mld address for device mode
+ * Return: MLD address for success, NULL failure
+ */
+uint8_t *wlan_hdd_get_mld_addr(struct hdd_context *hdd_ctx,
+			       uint8_t device_mode);
+
+/**
+ * hdd_register_wdev() - Function to register only wdev
+ * @sta_adapter : Station adapter linked with netdevice
+ * @link_adapter: Link adapter
+ * @adapter_params: Adapter params
+ *
+ * Function to register only the wdev not the netdev
+ * Return: none
+ */
+void hdd_register_wdev(struct hdd_adapter *sta_adapter,
+		       struct hdd_adapter *link_adapter,
+		       struct hdd_adapter_create_param *adapter_params);
+/**
+ * hdd_wlan_unregister_mlo_interfaces() - Function to unregister mlo
+ * interfaces
+ * @adapter: Link adapter
+ * @rtnl_held: RTNL held or not
+ *
+ * Function to unregister only the link adapter/wdev.
+ * Return: none
+ */
+QDF_STATUS hdd_wlan_unregister_mlo_interfaces(struct hdd_adapter *adapter,
+					      bool rtnl_held);
+
+/**
+ * hdd_wlan_register_mlo_interfaces() - Function to register mlo wdev interfaces
+ * @hdd_ctx: hdd context
+ *
+ * Function to register mlo wdev interfaces.
+ * Return: none
+ */
+void hdd_wlan_register_mlo_interfaces(struct hdd_context *hdd_ctx);
+
+/**
+ * hdd_update_dynamic_mld_mac_addr() - Updates the dynamic MLD MAC list
+ * @hdd_ctx: Pointer to HDD context
+ * @curr_mac_addr: Current interface mac address
+ * @new_mac_addr: New mac address which needs to be updated
+ *
+ * This function updates newly configured MAC address to the
+ * dynamic MLD MAC address list corresponding to the current
+ * adapter MLD MAC address
+ *
+ * Return: None
+ */
+void hdd_update_dynamic_mld_mac_addr(struct hdd_context *hdd_ctx,
+				     struct qdf_mac_addr *curr_mac_addr,
+				     struct qdf_mac_addr *new_mac_addr,
+				     uint8_t device_mode);
+
+/**
+ * hdd_populate_mld_vdev_params() - populates vdev object mld params
+ * @adapter: HDD adapter
+ * @vdev_params: vdev create parameters
+ *
+ * This function populates the mld params in the vdev create params
+ *
+ * Return: None
+ */
+void
+hdd_populate_mld_vdev_params(struct hdd_adapter *adapter,
+			     struct wlan_vdev_create_params *vdev_params);
+
+/**
+ * hdd_adapter_set_ml_adapter() - set adapter as ml adapter
+ * @adapter: HDD adapter
+ *
+ * This function sets adapter as ml adapter
+ * Return: None
+ */
+void hdd_adapter_set_ml_adapter(struct hdd_adapter *adapter);
+
+/**
+ * hdd_get_ml_adater() - get an ml adapter
+ * @adapter: HDD adapter
+ *
+ * This function returns ml adapter from adapter list
+ * Return: adapter or NULL
+ */
+struct hdd_adapter *hdd_get_ml_adater(struct hdd_context *hdd_ctx);
 #else
 static inline
 void hdd_update_mld_mac_addr(struct hdd_context *hdd_ctx,
 			     struct qdf_mac_addr hw_macaddr)
 {
 }
+
+static inline
+uint8_t *wlan_hdd_get_mld_addr(struct hdd_context *hdd_ctx,
+			       uint8_t device_mode)
+{
+	return NULL;
+}
+
+static inline
+QDF_STATUS hdd_wlan_unregister_mlo_interfaces(struct hdd_adapter *adapter,
+					      bool rtnl_held)
+{
+	return QDF_STATUS_SUCCESS;
+}
+
+static inline
+void hdd_register_wdev(struct hdd_adapter *sta_adapter,
+		       struct hdd_adapter *link_adapter,
+		       struct hdd_adapter_create_param *adapter_params)
+{
+}
+
+static inline
+void hdd_wlan_register_mlo_interfaces(struct hdd_context *hdd_ctx)
+{
+}
+
+static inline
+void hdd_update_dynamic_mld_mac_addr(struct hdd_context *hdd_ctx,
+				     struct qdf_mac_addr *curr_mac_addr,
+				     struct qdf_mac_addr *new_macaddr,
+				     uint8_t device_mode)
+{
+}
+
+static inline void
+hdd_adapter_set_ml_adapter(struct hdd_adapter *adapter)
+{
+}
+
+static inline
+struct hdd_adapter *hdd_get_ml_adater(struct hdd_context *hdd_ctx)
+{
+	return NULL;
+}
 #endif
 #endif

core/hdd/src/wlan_hdd_main.c

@@ -1581,8 +1581,6 @@ static void hdd_runtime_suspend_context_init(struct hdd_context *hdd_ctx) {}
 static void hdd_runtime_suspend_context_deinit(struct hdd_context *hdd_ctx) {}
 #endif /* FEATURE_RUNTIME_PM */
 
-#define INTF_MACADDR_MASK       0x7
-
 void hdd_update_macaddr(struct hdd_context *hdd_ctx,
 			struct qdf_mac_addr hw_macaddr, bool generate_mac_auto)
 {
@@ -3378,6 +3376,80 @@ static bool hdd_max_sta_interface_up_count_reached(struct hdd_adapter *adapter)
 	return false;
 }
 
+#ifdef WLAN_FEATURE_11BE_MLO
+static int hdd_start_link_adapter(struct hdd_adapter *sta_adapter)
+{
+	int i, ret = 0;
+	struct hdd_mlo_adapter_info *mlo_adapter_info;
+	struct hdd_adapter *link_adapter;
+
+	hdd_enter_dev(sta_adapter->dev);
+	mlo_adapter_info = &sta_adapter->mlo_adapter_info;
+
+	for (i = 0; i < WLAN_MAX_MLD; i++) {
+		link_adapter = mlo_adapter_info->link_adapter[i];
+		if (!link_adapter)
+			continue;
+		if (link_adapter->mlo_adapter_info.associate_with_ml_adapter) {
+			/* TODO have proper references here */
+			qdf_spin_lock_bh(&link_adapter->vdev_lock);
+			link_adapter->vdev = sta_adapter->vdev;
+			link_adapter->vdev_id = sta_adapter->vdev_id;
+			qdf_spin_unlock_bh(&link_adapter->vdev_lock);
+			continue;
+		}
+		ret = hdd_start_station_adapter(link_adapter);
+	}
+
+	hdd_exit();
+	return ret;
+}
+
+static int hdd_stop_link_adapter(struct hdd_context *hdd_ctx,
+				 struct hdd_adapter *sta_adapter)
+{
+	int i, ret;
+	struct hdd_mlo_adapter_info *mlo_adapter_info;
+	struct hdd_adapter *link_adapter;
+
+	hdd_enter_dev(sta_adapter->dev);
+	hdd_debug("Stop adapter for link mode : %s(%d)",
+		  qdf_opmode_str(sta_adapter->device_mode),
+		  sta_adapter->vdev_id);
+
+	mlo_adapter_info = &sta_adapter->mlo_adapter_info;
+	for (i = 0; i < WLAN_MAX_MLD; i++) {
+		link_adapter = mlo_adapter_info->link_adapter[i];
+		if (!link_adapter)
+			continue;
+
+		if (link_adapter->mlo_adapter_info.associate_with_ml_adapter) {
+			/* TODO have proper references here */
+			qdf_spin_lock_bh(&link_adapter->vdev_lock);
+			link_adapter->vdev = NULL;
+			link_adapter->vdev_id = 0xff;
+			qdf_spin_unlock_bh(&link_adapter->vdev_lock);
+			continue;
+		}
+		ret = hdd_stop_adapter_ext(hdd_ctx, link_adapter);
+	}
+
+	hdd_exit();
+	return ret;
+}
+#else
+static int hdd_start_link_adapter(struct hdd_adapter *link_adapter)
+{
+	return 0;
+}
+
+static int hdd_stop_link_adapter(struct hdd_context *hdd_ctx,
+				 struct hdd_adapter *link_adapter)
+{
+	return 0;
+}
+#endif
+
 /**
  * hdd_start_adapter() - Wrapper function for device specific adapter
  * @adapter: pointer to HDD adapter
@@ -3394,7 +3466,6 @@ int hdd_start_adapter(struct hdd_adapter *adapter)
 	enum QDF_OPMODE device_mode = adapter->device_mode;
 
 	hdd_enter_dev(adapter->dev);
-	hdd_debug("Start_adapter for mode : %d", adapter->device_mode);
 
 	switch (device_mode) {
 	case QDF_STA_MODE:
@@ -3413,6 +3484,11 @@ int hdd_start_adapter(struct hdd_adapter *adapter)
 
 		hdd_nud_ignore_tracking(adapter, false);
 		hdd_mic_enable_work(adapter);
+		if (device_mode == QDF_STA_MODE) {
+			ret = hdd_start_link_adapter(adapter);
+			if (ret)
+				hdd_err("Failed to start link adapter:%d", ret);
+		}
 		break;
 	case QDF_P2P_GO_MODE:
 	case QDF_SAP_MODE:
@@ -4962,6 +5038,27 @@ void hdd_update_dynamic_mac(struct hdd_context *hdd_ctx,
 	hdd_exit();
 }
 
+#ifdef WLAN_FEATURE_11BE_MLO
+static void
+hdd_set_mld_address(struct hdd_adapter *adapter, struct hdd_context *hdd_ctx,
+		    struct qdf_mac_addr *mac_addr)
+{
+	if (adapter->device_mode == QDF_STA_MODE &&
+	    adapter->mlo_adapter_info.is_ml_adapter) {
+		hdd_update_dynamic_mld_mac_addr(hdd_ctx, &adapter->mld_addr,
+						mac_addr,
+						adapter->device_mode);
+		memcpy(&adapter->mld_addr, mac_addr, ETH_ALEN);
+	}
+}
+#else
+static void
+hdd_set_mld_address(struct hdd_adapter *adapter, struct hdd_context *hdd_ctx,
+		    struct qdf_mac_addr *mac_addr)
+{
+}
+#endif
+
 /**
  * __hdd_set_mac_address() - set the user specified mac address
  * @dev:	Pointer to the net device.
@@ -5013,7 +5110,11 @@ static int __hdd_set_mac_address(struct net_device *dev, void *addr)
 		       QDF_MAC_ADDR_FMT " of the interface %s ",
 		       QDF_MAC_ADDR_REF(mac_addr.bytes), dev->name);
 
-	hdd_update_dynamic_mac(hdd_ctx, &adapter->mac_addr, &mac_addr);
+	if (hdd_adapter_is_ml_adapter(adapter))
+		hdd_set_mld_address(adapter, hdd_ctx, &mac_addr);
+	else
+		hdd_update_dynamic_mac(hdd_ctx, &adapter->mac_addr, &mac_addr);
+
 	memcpy(&adapter->mac_addr, psta_mac_addr->sa_data, ETH_ALEN);
 	memcpy(dev->dev_addr, psta_mac_addr->sa_data, ETH_ALEN);
 
@@ -5642,6 +5743,7 @@ hdd_alloc_station_adapter(struct hdd_context *hdd_ctx, tSirMacAddr mac_addr,
 
 	qdf_mem_copy(dev->dev_addr, mac_addr, sizeof(tSirMacAddr));
 	qdf_mem_copy(adapter->mac_addr.bytes, mac_addr, sizeof(tSirMacAddr));
+	qdf_mem_copy(adapter->mld_addr.bytes, mac_addr, sizeof(tSirMacAddr));
 	dev->watchdog_timeo = HDD_TX_TIMEOUT;
 
 	if (wlan_hdd_is_session_type_monitor(session_type)) {
@@ -5941,6 +6043,56 @@ bool hdd_is_vdev_in_conn_state(struct hdd_adapter *adapter)
 	return 0;
 }
 
+#ifdef WLAN_FEATURE_11BE_MLO
+static void
+hdd_populate_vdev_create_params(struct hdd_adapter *adapter,
+				struct wlan_vdev_create_params *vdev_params)
+{
+	int i;
+	struct hdd_mlo_adapter_info *mlo_adapter_info, *link_mlo_adapter_info;
+	struct hdd_adapter *link_adapter;
+
+	hdd_enter_dev(adapter->dev);
+	mlo_adapter_info = &adapter->mlo_adapter_info;
+
+	if (mlo_adapter_info->is_ml_adapter &&
+	    adapter->device_mode == QDF_STA_MODE) {
+		for (i = 0; i < WLAN_MAX_MLD; i++) {
+			link_adapter = mlo_adapter_info->link_adapter[i];
+			if (!link_adapter)
+				continue;
+			link_mlo_adapter_info = &link_adapter->mlo_adapter_info;
+			if (link_mlo_adapter_info->associate_with_ml_adapter) {
+				qdf_mem_copy(vdev_params->macaddr,
+					     link_adapter->mac_addr.bytes,
+					     QDF_MAC_ADDR_SIZE);
+				break;
+			}
+		}
+	} else {
+		qdf_mem_copy(vdev_params->macaddr, adapter->mac_addr.bytes,
+			     QDF_MAC_ADDR_SIZE);
+	}
+
+	vdev_params->opmode = adapter->device_mode;
+
+	hdd_populate_mld_vdev_params(adapter, vdev_params);
+	vdev_params->size_vdev_priv = sizeof(struct vdev_osif_priv);
+	hdd_exit();
+}
+#else
+static void
+hdd_populate_vdev_create_params(struct hdd_adapter *adapter,
+				struct wlan_vdev_create_params *vdev_params)
+{
+	vdev_params->opmode = adapter->device_mode;
+	qdf_mem_copy(vdev_params->macaddr,
+		     adapter->mac_addr.bytes,
+		     QDF_NET_MAC_ADDR_MAX_LEN);
+	vdev_params->size_vdev_priv = sizeof(struct vdev_osif_priv);
+}
+#endif
+
 int hdd_vdev_create(struct hdd_adapter *adapter)
 {
 	QDF_STATUS status;
@@ -5965,12 +6117,8 @@ int hdd_vdev_create(struct hdd_adapter *adapter)
 		return errno;
 	}
 
-	vdev_params.opmode = adapter->device_mode;
-	qdf_mem_copy(vdev_params.macaddr,
-		     adapter->mac_addr.bytes,
-		     QDF_NET_MAC_ADDR_MAX_LEN);
+	hdd_populate_vdev_create_params(adapter, &vdev_params);
 
-	vdev_params.size_vdev_priv = sizeof(*osif_priv);
 	vdev = sme_vdev_create(hdd_ctx->mac_handle, &vdev_params);
 	if (!vdev) {
 		hdd_err("failed to create vdev");
@@ -6248,7 +6396,7 @@ static char *net_dev_ref_debug_string_from_id(wlan_net_dev_ref_dbgid dbgid)
 	return (char *)strings[dbgid];
 }
 
-static void hdd_check_for_net_dev_ref_leak(struct hdd_adapter *adapter)
+void hdd_check_for_net_dev_ref_leak(struct hdd_adapter *adapter)
 {
 	int i, id;
 
@@ -6891,6 +7039,7 @@ static void wlan_hdd_cfg80211_scan_block_cb(struct work_struct *work)
  * @mac_addr: MAC address to assign to the interface
  * @name_assign_type: the name of assign type of the netdev
  * @rtnl_held: the rtnl lock hold flag
+ * @params: adapter create params
  *
  * This function open and setup the hdd adpater according to the device
  * type request, assign the name, the mac address assigned, and then prepared
@@ -6898,13 +7047,16 @@ static void wlan_hdd_cfg80211_scan_block_cb(struct work_struct *work)
  *
  * Return: the pointer of hdd adapter, otherwise NULL.
  */
-struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx, uint8_t session_type,
-				const char *iface_name, tSirMacAddr mac_addr,
-				unsigned char name_assign_type,
-				bool rtnl_held)
+struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx,
+				     uint8_t session_type,
+				     const char *iface_name,
+				     tSirMacAddr mac_addr,
+				     unsigned char name_assign_type,
+				     bool rtnl_held,
+				     struct hdd_adapter_create_param *params)
 {
 	struct net_device *ndev = NULL;
-	struct hdd_adapter *adapter = NULL;
+	struct hdd_adapter *adapter = NULL, *sta_adapter = NULL;
 	QDF_STATUS status = QDF_STATUS_E_FAILURE;
 	uint32_t i;
 
@@ -6923,6 +7075,14 @@ struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx, uint8_t sessio
 		return NULL;
 	}
 
+	if (params->only_wdev_register) {
+		sta_adapter = hdd_get_ml_adater(hdd_ctx);
+		if (!sta_adapter) {
+			hdd_err("not able to find the sta adapter");
+			return NULL;
+		}
+	}
+
 	switch (session_type) {
 	case QDF_STA_MODE:
 		if (!hdd_ctx->config->mac_provision) {
@@ -6990,6 +7150,11 @@ struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx, uint8_t sessio
 		INIT_WORK(&adapter->ipv6_notifier_work,
 			  hdd_ipv6_notifier_work_queue);
 #endif
+		if (params->only_wdev_register) {
+			hdd_register_wdev(sta_adapter, adapter, params);
+			break;
+		}
+
 		status = hdd_register_interface(adapter, rtnl_held);
 		if (QDF_STATUS_SUCCESS != status)
 			goto err_free_netdev;
@@ -7086,6 +7251,8 @@ struct hdd_adapter *hdd_open_adapter(struct hdd_context *hdd_ctx, uint8_t sessio
 		return NULL;
 	}
 
+	if (params->is_ml_adapter)
+		hdd_adapter_set_ml_adapter(adapter);
 	status = hdd_adapter_feature_update_work_init(adapter);
 	if (QDF_IS_STATUS_ERROR(status))
 		goto err_cleanup_adapter;
@@ -7189,11 +7356,20 @@ void hdd_close_all_adapters(struct hdd_context *hdd_ctx, bool rtnl_held)
 {
 	struct hdd_adapter *adapter;
 	struct osif_vdev_sync *vdev_sync;
+	QDF_STATUS qdf_status;
 
 	hdd_enter();
 
 	while (QDF_IS_STATUS_SUCCESS(hdd_get_front_adapter(
 							hdd_ctx, &adapter))) {
+		/* If MLO is enabled unregister the link wdev's */
+		if (adapter->device_mode == QDF_STA_MODE) {
+			qdf_status = hdd_wlan_unregister_mlo_interfaces(adapter,
+								     rtnl_held);
+			if (QDF_IS_STATUS_ERROR(qdf_status))
+				continue;
+		}
+
 		hdd_check_for_net_dev_ref_leak(adapter);
 		hdd_remove_front_adapter(hdd_ctx, &adapter);
 		vdev_sync = osif_vdev_sync_unregister(adapter->dev);
@@ -7354,8 +7530,8 @@ static void hdd_close_pre_cac_adapter(struct hdd_context *hdd_ctx)
 	osif_vdev_sync_destroy(vdev_sync);
 }
 
-QDF_STATUS hdd_stop_adapter(struct hdd_context *hdd_ctx,
-			    struct hdd_adapter *adapter)
+QDF_STATUS hdd_stop_adapter_ext(struct hdd_context *hdd_ctx,
+				struct hdd_adapter *adapter)
 {
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	struct hdd_station_ctx *sta_ctx;
@@ -7369,7 +7545,6 @@ QDF_STATUS hdd_stop_adapter(struct hdd_context *hdd_ctx,
 	enum wlan_reason_code reason = REASON_IFACE_DOWN;
 
 	hdd_enter();
-
 	hdd_destroy_adapter_sysfs_files(adapter);
 
 	if (adapter->device_mode == QDF_STA_MODE &&
@@ -7389,7 +7564,6 @@ QDF_STATUS hdd_stop_adapter(struct hdd_context *hdd_ctx,
 	hdd_stop_tsf_sync(adapter);
 	cds_flush_work(&adapter->scan_block_work);
 	wlan_hdd_cfg80211_scan_block(adapter);
-
 	hdd_debug("Disabling queues");
 	wlan_hdd_netif_queue_control(adapter,
 				     WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER,
@@ -7712,6 +7886,19 @@ QDF_STATUS hdd_stop_adapter(struct hdd_context *hdd_ctx,
 	return QDF_STATUS_SUCCESS;
 }
 
+QDF_STATUS hdd_stop_adapter(struct hdd_context *hdd_ctx,
+			    struct hdd_adapter *adapter)
+{
+	QDF_STATUS status;
+
+	if (adapter->device_mode == QDF_STA_MODE)
+		status = hdd_stop_link_adapter(hdd_ctx, adapter);
+
+	status = hdd_stop_adapter_ext(hdd_ctx, adapter);
+
+	return status;
+}
+
 /**
  * hdd_deinit_all_adapters - deinit all adapters
  * @hdd_ctx:   HDD context
@@ -11459,7 +11646,7 @@ void hdd_indicate_mgmt_frame(tSirSmeMgmtFrameInd *frame_ind)
 	struct hdd_context *hdd_ctx = NULL;
 	struct hdd_adapter *adapter = NULL, *next_adapter = NULL;
 	int i, num_adapters;
-	uint8_t vdev_id[WLAN_MAX_VDEVS];
+	uint8_t vdev_id[WLAN_MAX_VDEVS + WLAN_MAX_ML_VDEVS];
 	struct ieee80211_mgmt *mgmt =
 		(struct ieee80211_mgmt *)frame_ind->frameBuf;
 	struct wlan_objmgr_vdev *vdev;
@@ -12516,7 +12703,6 @@ int hdd_start_ap_adapter(struct hdd_adapter *adapter)
 	}
 
 	status = hdd_init_ap_mode(adapter, is_ssr);
-
 	if (QDF_STATUS_SUCCESS != status) {
 		hdd_err("Error Initializing the AP mode: %d", status);
 		ret = qdf_status_to_os_return(status);
@@ -14533,10 +14719,11 @@ static QDF_STATUS wlan_hdd_cache_chann_mutex_create(struct hdd_context *hdd_ctx)
 }
 #endif
 
-static QDF_STATUS hdd_open_adapter_no_trans(struct hdd_context *hdd_ctx,
-					    enum QDF_OPMODE op_mode,
-					    const char *iface_name,
-					    uint8_t *mac_addr_bytes)
+QDF_STATUS hdd_open_adapter_no_trans(struct hdd_context *hdd_ctx,
+				     enum QDF_OPMODE op_mode,
+				     const char *iface_name,
+				     uint8_t *mac_addr_bytes,
+				     struct hdd_adapter_create_param *params)
 {
 	struct osif_vdev_sync *vdev_sync;
 	struct hdd_adapter *adapter;
@@ -14550,7 +14737,8 @@ static QDF_STATUS hdd_open_adapter_no_trans(struct hdd_context *hdd_ctx,
 		return qdf_status_from_os_return(errno);
 
 	adapter = hdd_open_adapter(hdd_ctx, op_mode, iface_name,
-				   mac_addr_bytes, NET_NAME_UNKNOWN, true);
+				   mac_addr_bytes, NET_NAME_UNKNOWN, true,
+				   params);
 	if (!adapter) {
 		status = QDF_STATUS_E_INVAL;
 		goto destroy_sync;
@@ -14566,6 +14754,22 @@ destroy_sync:
 	return status;
 }
 
+#ifdef WLAN_FEATURE_11BE_MLO
+static
+uint8_t *wlan_hdd_get_mlo_intf_addr(struct hdd_context *hdd_ctx,
+				    enum QDF_OPMODE interface_type)
+{
+		return wlan_hdd_get_mld_addr(hdd_ctx, QDF_STA_MODE);
+}
+#else
+static inline
+uint8_t *wlan_hdd_get_mlo_intf_addr(struct hdd_context *hdd_ctx,
+				    enum QDF_OPMODE interface_type)
+{
+		return wlan_hdd_get_intf_addr(hdd_ctx, QDF_STA_MODE);
+}
+#endif
+
 #ifdef WLAN_OPEN_P2P_INTERFACE
 /**
  * hdd_open_p2p_interface - Open P2P interface
@@ -14578,6 +14782,7 @@ static QDF_STATUS hdd_open_p2p_interface(struct hdd_context *hdd_ctx)
 	QDF_STATUS status;
 	bool p2p_dev_addr_admin;
 	bool is_p2p_locally_administered = false;
+	struct hdd_adapter_create_param params = {0};
 
 	cfg_p2p_get_device_addr_admin(hdd_ctx->psoc, &p2p_dev_addr_admin);
 
@@ -14623,7 +14828,8 @@ static QDF_STATUS hdd_open_p2p_interface(struct hdd_context *hdd_ctx)
 
 	status = hdd_open_adapter_no_trans(hdd_ctx, QDF_P2P_DEVICE_MODE,
 					   "p2p%d",
-					   hdd_ctx->p2p_device_address.bytes);
+					   hdd_ctx->p2p_device_address.bytes,
+					   &params);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		if (!is_p2p_locally_administered)
 			wlan_hdd_release_intf_addr(hdd_ctx,
@@ -14645,13 +14851,15 @@ static QDF_STATUS hdd_open_ocb_interface(struct hdd_context *hdd_ctx)
 {
 	QDF_STATUS status;
 	uint8_t *mac_addr;
+	struct hdd_adapter_create_param params = {0};
 
 	mac_addr = wlan_hdd_get_intf_addr(hdd_ctx, QDF_OCB_MODE);
 	if (!mac_addr)
 		return QDF_STATUS_E_INVAL;
 
 	status = hdd_open_adapter_no_trans(hdd_ctx, QDF_OCB_MODE,
-					   "wlanocb%d", mac_addr);
+					   "wlanocb%d", mac_addr,
+					   &params);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		wlan_hdd_release_intf_addr(hdd_ctx, mac_addr);
 		hdd_err("Failed to open 802.11p interface");
@@ -14665,6 +14873,7 @@ static QDF_STATUS hdd_open_concurrent_interface(struct hdd_context *hdd_ctx)
 	QDF_STATUS status;
 	const char *iface_name;
 	uint8_t *mac_addr;
+	struct hdd_adapter_create_param params = {0};
 
 	if (qdf_str_eq(hdd_ctx->config->enable_concurrent_sta, ""))
 		return QDF_STATUS_SUCCESS;
@@ -14675,7 +14884,8 @@ static QDF_STATUS hdd_open_concurrent_interface(struct hdd_context *hdd_ctx)
 		return QDF_STATUS_E_INVAL;
 
 	status = hdd_open_adapter_no_trans(hdd_ctx, QDF_STA_MODE,
-					   iface_name, mac_addr);
+					   iface_name, mac_addr,
+					   &params);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		wlan_hdd_release_intf_addr(hdd_ctx, mac_addr);
 		hdd_err("Failed to open concurrent station interface");
@@ -14690,6 +14900,7 @@ hdd_open_adapters_for_mission_mode(struct hdd_context *hdd_ctx)
 	enum dot11p_mode dot11p_mode;
 	QDF_STATUS status;
 	uint8_t *mac_addr;
+	struct hdd_adapter_create_param params = {0};
 
 	ucfg_mlme_get_dot11p_mode(hdd_ctx->psoc, &dot11p_mode);
 
@@ -14697,12 +14908,14 @@ hdd_open_adapters_for_mission_mode(struct hdd_context *hdd_ctx)
 	if (dot11p_mode == CFG_11P_STANDALONE)
 		return hdd_open_ocb_interface(hdd_ctx);
 
-	mac_addr = wlan_hdd_get_intf_addr(hdd_ctx, QDF_STA_MODE);
+	mac_addr = wlan_hdd_get_mlo_intf_addr(hdd_ctx, QDF_STA_MODE);
 	if (!mac_addr)
 		return QDF_STATUS_E_INVAL;
 
+	params.is_ml_adapter = true;
 	status = hdd_open_adapter_no_trans(hdd_ctx, QDF_STA_MODE,
-					   "wlan%d", mac_addr);
+					   "wlan%d", mac_addr,
+					   &params);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		wlan_hdd_release_intf_addr(hdd_ctx, mac_addr);
 		return status;
@@ -14725,7 +14938,8 @@ hdd_open_adapters_for_mission_mode(struct hdd_context *hdd_ctx)
 			goto err_close_adapters;
 
 		status = hdd_open_adapter_no_trans(hdd_ctx, QDF_NAN_DISC_MODE,
-						   "wifi-aware%d", mac_addr);
+						   "wifi-aware%d", mac_addr,
+						   &params);
 		if (status) {
 			wlan_hdd_release_intf_addr(hdd_ctx, mac_addr);
 			goto err_close_adapters;
@@ -14738,6 +14952,7 @@ hdd_open_adapters_for_mission_mode(struct hdd_context *hdd_ctx)
 			goto err_close_adapters;
 	}
 
+	hdd_wlan_register_mlo_interfaces(hdd_ctx);
 	return QDF_STATUS_SUCCESS;
 
 err_close_adapters:
@@ -14750,14 +14965,15 @@ static QDF_STATUS hdd_open_adapters_for_ftm_mode(struct hdd_context *hdd_ctx)
 {
 	QDF_STATUS status;
 	uint8_t *mac_addr;
+	struct hdd_adapter_create_param params = {0};
 
 	mac_addr = wlan_hdd_get_intf_addr(hdd_ctx, QDF_FTM_MODE);
 	if (!mac_addr)
 		return QDF_STATUS_E_INVAL;
 
 	status = hdd_open_adapter_no_trans(hdd_ctx, QDF_FTM_MODE,
-					   "wlan%d", mac_addr);
-
+					   "wlan%d", mac_addr,
+					   &params);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		wlan_hdd_release_intf_addr(hdd_ctx, mac_addr);
 		return status;
@@ -14771,14 +14987,15 @@ hdd_open_adapters_for_monitor_mode(struct hdd_context *hdd_ctx)
 {
 	QDF_STATUS status;
 	uint8_t *mac_addr;
+	struct hdd_adapter_create_param params = {0};
 
 	mac_addr = wlan_hdd_get_intf_addr(hdd_ctx, QDF_MONITOR_MODE);
 	if (!mac_addr)
 		return QDF_STATUS_E_INVAL;
 
 	status = hdd_open_adapter_no_trans(hdd_ctx, QDF_MONITOR_MODE,
-					   "wlan%d", mac_addr);
-
+					   "wlan%d", mac_addr,
+					   &params);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		wlan_hdd_release_intf_addr(hdd_ctx, mac_addr);
 		return status;
@@ -18671,6 +18888,7 @@ wlan_hdd_add_monitor_check(struct hdd_context *hdd_ctx,
 	struct hdd_adapter *mon_adapter;
 	uint8_t num_open_session = 0;
 	QDF_STATUS status;
+	struct hdd_adapter_create_param params = {0};
 
 	/* if no interface is up do not add monitor mode */
 	if (!hdd_is_any_interface_open(hdd_ctx))
@@ -18715,7 +18933,7 @@ wlan_hdd_add_monitor_check(struct hdd_context *hdd_ctx,
 				       wlan_hdd_get_intf_addr(
 				       hdd_ctx,
 				       QDF_MONITOR_MODE),
-				       name_assign_type, rtnl_held);
+				       name_assign_type, rtnl_held, &params);
 	if (!mon_adapter) {
 		hdd_err("hdd_open_adapter failed");
 		if (ucfg_pkt_capture_get_mode(hdd_ctx->psoc) !=

core/hdd/src/wlan_hdd_mlo.c

@@ -21,9 +21,9 @@
  * support.
  *
  */
-
 #include "wlan_hdd_main.h"
 #include "wlan_hdd_mlo.h"
+#include "osif_vdev_sync.h"
 
 void hdd_update_mld_mac_addr(struct hdd_context *hdd_ctx,
 			     struct qdf_mac_addr hw_macaddr)
@@ -60,3 +60,262 @@ void hdd_update_mld_mac_addr(struct hdd_context *hdd_ctx,
 	};
 }
 
+uint8_t *wlan_hdd_get_mld_addr(struct hdd_context *hdd_ctx, uint8_t device_mode)
+{
+	int i;
+	struct hdd_mld_mac_info *mac_info;
+
+	if (device_mode != QDF_STA_MODE && device_mode != QDF_SAP_MODE)
+		return NULL;
+
+	mac_info = &hdd_ctx->mld_mac_info;
+	for (i = 0; i <  mac_info->num_mld_addr; i++) {
+		if (mac_info->mld_mac_list[i].device_mode == device_mode)
+			return mac_info->mld_mac_list[i].mld_addr.bytes;
+	}
+
+	i = qdf_ffz(mac_info->mld_intf_addr_mask);
+	if (i < 0 || i >= mac_info->num_mld_addr)
+		return NULL;
+	qdf_atomic_set_bit(i, &mac_info->mld_intf_addr_mask);
+	hdd_nofl_debug("Assigning MLD MAC from derived list " QDF_MAC_ADDR_FMT,
+		    QDF_MAC_ADDR_REF(mac_info->mld_mac_list[i].mld_addr.bytes));
+
+	mac_info->mld_mac_list[i].device_mode = device_mode;
+	return mac_info->mld_mac_list[i].mld_addr.bytes;
+}
+
+void hdd_register_wdev(struct hdd_adapter *sta_adapter,
+		       struct hdd_adapter *link_adapter,
+		       struct hdd_adapter_create_param *adapter_params)
+{
+	int ret, i;
+
+	hdd_enter_dev(sta_adapter->dev);
+	/* Set the relation between adapters*/
+	link_adapter->wdev.iftype = NL80211_IFTYPE_MLO_LINK;
+
+	ret = cfg80211_register_mlo_link(&sta_adapter->wdev,
+					 &link_adapter->wdev);
+	if (ret) {
+		hdd_err("Failed to register ml link wdev %d", ret);
+		return;
+	}
+
+	sta_adapter->mlo_adapter_info.is_ml_adapter = true;
+	sta_adapter->mlo_adapter_info.is_link_adapter = false;
+	link_adapter->mlo_adapter_info.is_link_adapter = true;
+	link_adapter->mlo_adapter_info.is_ml_adapter = false;
+	link_adapter->mlo_adapter_info.ml_adapter = sta_adapter;
+	link_adapter->mlo_adapter_info.associate_with_ml_adapter =
+				      adapter_params->associate_with_ml_adapter;
+	qdf_set_bit(WDEV_ONLY_REGISTERED, &link_adapter->event_flags);
+
+	for (i = 0; i < WLAN_MAX_MLD; i++) {
+		if (sta_adapter->mlo_adapter_info.link_adapter[i])
+			continue;
+		sta_adapter->mlo_adapter_info.link_adapter[i] = link_adapter;
+		break;
+	}
+
+	qdf_mem_copy(link_adapter->mld_addr.bytes, sta_adapter->mld_addr.bytes,
+		     QDF_MAC_ADDR_SIZE);
+	hdd_exit();
+}
+
+static
+void hdd_mlo_close_adapter(struct hdd_adapter *link_adapter, bool rtnl_held)
+{
+	struct osif_vdev_sync *vdev_sync;
+
+	vdev_sync = osif_vdev_sync_unregister(link_adapter->dev);
+	if (vdev_sync)
+		osif_vdev_sync_wait_for_ops(vdev_sync);
+
+	hdd_check_for_net_dev_ref_leak(link_adapter);
+	wlan_hdd_release_intf_addr(link_adapter->hdd_ctx,
+				   link_adapter->mac_addr.bytes);
+
+	link_adapter->wdev.netdev = NULL;
+
+	if (rtnl_held)
+		rtnl_unlock();
+
+	cfg80211_unregister_wdev(&link_adapter->wdev);
+	link_adapter->dev->reg_state = NETREG_UNREGISTERED;
+	free_netdev(link_adapter->dev);
+
+	if (rtnl_held)
+		rtnl_lock();
+
+	if (vdev_sync)
+		osif_vdev_sync_destroy(vdev_sync);
+}
+
+QDF_STATUS hdd_wlan_unregister_mlo_interfaces(struct hdd_adapter *adapter,
+					      bool rtnl_held)
+{
+	int i;
+	struct hdd_mlo_adapter_info *mlo_adapter_info;
+	struct hdd_adapter *link_adapter;
+
+	mlo_adapter_info = &adapter->mlo_adapter_info;
+
+	if (mlo_adapter_info->is_link_adapter) {
+		hdd_remove_front_adapter(adapter->hdd_ctx, &adapter);
+		return QDF_STATUS_E_AGAIN;
+	}
+
+	for (i = 0; i < WLAN_MAX_MLD; i++) {
+		link_adapter = mlo_adapter_info->link_adapter[i];
+		if (!link_adapter)
+			continue;
+		hdd_mlo_close_adapter(link_adapter, rtnl_held);
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+void hdd_wlan_register_mlo_interfaces(struct hdd_context *hdd_ctx)
+{
+	uint8_t *mac_addr;
+	struct hdd_adapter_create_param params = {0};
+	QDF_STATUS status;
+
+	mac_addr = wlan_hdd_get_intf_addr(hdd_ctx, QDF_STA_MODE);
+	if (mac_addr) {
+		/* if target supports MLO create a new dev */
+		params.only_wdev_register = true;
+		params.associate_with_ml_adapter = false;
+		status = hdd_open_adapter_no_trans(hdd_ctx, QDF_STA_MODE,
+						   "null", mac_addr, &params);
+		if (QDF_IS_STATUS_ERROR(status))
+			hdd_err("Failed to register link adapter:%d", status);
+	}
+
+	qdf_mem_zero(&params, sizeof(struct hdd_adapter_create_param));
+	params.only_wdev_register  = true;
+	params.associate_with_ml_adapter = true;
+	mac_addr = wlan_hdd_get_intf_addr(hdd_ctx, QDF_STA_MODE);
+	if (mac_addr) {
+		/* if target supports MLO create a new dev */
+		status = hdd_open_adapter_no_trans(hdd_ctx, QDF_STA_MODE,
+						   "null", mac_addr, &params);
+		if (QDF_IS_STATUS_ERROR(status))
+			hdd_err("Failed to register link adapter:%d", status);
+	}
+}
+
+void hdd_update_dynamic_mld_mac_addr(struct hdd_context *hdd_ctx,
+				     struct qdf_mac_addr *curr_mac_addr,
+				     struct qdf_mac_addr *new_mac_addr,
+				     uint8_t device_mode)
+{
+	uint8_t i;
+	struct hdd_mld_mac_info *mac_info;
+
+	hdd_enter();
+
+	mac_info = &hdd_ctx->mld_mac_info;
+	for (i = 0; i < WLAN_MAX_MLD; i++) {
+		if (device_mode != QDF_STA_MODE)
+			continue;
+		if (!qdf_mem_cmp(curr_mac_addr->bytes,
+				 mac_info->mld_mac_list[i].mld_addr.bytes,
+				 sizeof(struct qdf_mac_addr)))
+			qdf_mem_copy(mac_info->mld_mac_list[i].mld_addr.bytes,
+				     new_mac_addr->bytes,
+				     sizeof(struct qdf_mac_addr));
+			break;
+		}
+	}
+	hdd_exit();
+}
+
+/**
+ * MLD address can be shared with the same device mode but should be different
+ * across device modes. Return error if the macaddress is currently held by a
+ * different device mode.
+ */
+static
+QDF_STATUS hdd_check_for_existing_mldaddr(struct hdd_context *hdd_ctx,
+					  uint8_t *mac_addr,
+					  uint32_t device_mode)
+{
+	struct hdd_adapter *adapter, *next_adapter = NULL;
+	wlan_net_dev_ref_dbgid dbgid = NET_DEV_HOLD_CHECK_FOR_EXISTING_MACADDR;
+
+	hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter,
+					   dbgid) {
+		if (adapter->device_mode != device_mode &&
+		    !qdf_mem_cmp(adapter->mac_addr.bytes, mac_addr,
+		    sizeof(struct qdf_mac_addr))) {
+			hdd_adapter_dev_put_debug(adapter, dbgid);
+			if (next_adapter)
+				hdd_adapter_dev_put_debug(next_adapter, dbgid);
+			return QDF_STATUS_E_FAILURE;
+		}
+		hdd_adapter_dev_put_debug(adapter, dbgid);
+	}
+
+	return QDF_STATUS_SUCCESS;
+}
+
+void
+hdd_populate_mld_vdev_params(struct hdd_adapter *adapter,
+			     struct wlan_vdev_create_params *vdev_params)
+{
+	uint8_t *mld_addr;
+	QDF_STATUS qdf_status;
+	uint8_t device_mode = adapter->device_mode;
+
+	mld_addr = wlan_hdd_get_mld_addr(adapter->hdd_ctx,
+					 adapter->device_mode);
+	if (mld_addr) {
+		/**
+		 * Check if this mld address is getting used by any other
+		 * device mode netdev
+		 */
+		qdf_status = hdd_check_for_existing_mldaddr(adapter->hdd_ctx,
+							    mld_addr,
+							    device_mode);
+		if (QDF_IS_STATUS_ERROR(qdf_status)) {
+			qdf_mem_copy(vdev_params->mldaddr,
+				     adapter->mac_addr.bytes,
+				     QDF_MAC_ADDR_SIZE);
+			return;
+		}
+		qdf_mem_copy(vdev_params->mldaddr, mld_addr,
+			     QDF_NET_MAC_ADDR_MAX_LEN);
+		qdf_mem_copy(adapter->wdev.mld_address, mld_addr,
+			     QDF_NET_MAC_ADDR_MAX_LEN);
+		qdf_mem_copy(adapter->mld_addr.bytes, mld_addr,
+			     QDF_NET_MAC_ADDR_MAX_LEN);
+	}
+}
+
+void
+hdd_adapter_set_ml_adapter(struct hdd_adapter *adapter)
+{
+	adapter->mlo_adapter_info.is_ml_adapter = true;
+}
+
+struct hdd_adapter *hdd_get_ml_adater(struct hdd_context *hdd_ctx)
+{
+	struct hdd_adapter *adapter, *next_adapter = NULL;
+	wlan_net_dev_ref_dbgid dbgid = NET_DEV_HOLD_GET_ADAPTER_BY_VDEV;
+
+	hdd_for_each_adapter_dev_held_safe(hdd_ctx, adapter, next_adapter,
+					   dbgid) {
+		if (hdd_adapter_is_ml_adapter(adapter)) {
+			hdd_adapter_dev_put_debug(adapter, dbgid);
+			if (next_adapter)
+				hdd_adapter_dev_put_debug(next_adapter,
+							  dbgid);
+			return adapter;
+		}
+		hdd_adapter_dev_put_debug(adapter, dbgid);
+	}
+
+	return NULL;
+}

core/hdd/src/wlan_hdd_nan_datapath.c

@@ -570,6 +570,7 @@ int hdd_ndi_open(char *iface_name)
 	struct hdd_context *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
 	uint8_t ndi_adapter_count = 0;
 	uint8_t *ndi_mac_addr;
+	struct hdd_adapter_create_param params = {0};
 
 	hdd_enter();
 	if (!hdd_ctx)
@@ -602,7 +603,8 @@ int hdd_ndi_open(char *iface_name)
 	}
 
 	adapter = hdd_open_adapter(hdd_ctx, QDF_NDI_MODE, iface_name,
-				   ndi_mac_addr, NET_NAME_UNKNOWN, true);
+				   ndi_mac_addr, NET_NAME_UNKNOWN, true,
+				   &params);
 	if (!adapter) {
 		if (!cfg_nan_get_ndi_mac_randomize(hdd_ctx->psoc))
 			wlan_hdd_release_intf_addr(hdd_ctx, ndi_mac_addr);

core/hdd/src/wlan_hdd_nud_tracking.c

@@ -57,6 +57,9 @@ void hdd_nud_flush_work(struct hdd_adapter *adapter)
 
 	hdd_ctx = WLAN_HDD_GET_CTX(adapter);
 
+	if (hdd_adapter_is_link_adapter(adapter))
+		return;
+
 	if (adapter->device_mode == QDF_STA_MODE &&
 	    hdd_ctx->config->enable_nud_tracking) {
 		hdd_debug("Flush the NUD work");

core/hdd/src/wlan_hdd_p2p.c

@@ -707,6 +707,7 @@ struct wireless_dev *__wlan_hdd_add_virtual_intf(struct wiphy *wiphy,
 	QDF_STATUS status;
 	struct wlan_objmgr_vdev *vdev;
 	int ret;
+	struct hdd_adapter_create_param create_params = {0};
 
 	hdd_enter();
 
@@ -800,7 +801,8 @@ struct wireless_dev *__wlan_hdd_add_virtual_intf(struct wiphy *wiphy,
 		p2p_device_address.bytes[4] ^= 0x80;
 		adapter = hdd_open_adapter(hdd_ctx, mode, name,
 					   p2p_device_address.bytes,
-					   name_assign_type, true);
+					   name_assign_type, true,
+					   &create_params);
 	} else {
 		uint8_t *device_address;
 		if (strnstr(name, "p2p", 3) && mode == QDF_STA_MODE) {
@@ -813,7 +815,8 @@ struct wireless_dev *__wlan_hdd_add_virtual_intf(struct wiphy *wiphy,
 
 		adapter = hdd_open_adapter(hdd_ctx, mode, name,
 					   device_address,
-					   name_assign_type, true);
+					   name_assign_type, true,
+					   &create_params);
 		if (!adapter)
 			wlan_hdd_release_intf_addr(hdd_ctx, device_address);
 	}

core/hdd/src/wlan_hdd_sap_cond_chan_switch.c

@@ -244,6 +244,7 @@ static int __wlan_hdd_request_pre_cac(struct hdd_context *hdd_ctx,
 	mac_handle_t mac_handle;
 	bool val;
 	enum phy_ch_width cac_ch_width;
+	struct hdd_adapter_create_param params = {0};
 
 	if (!policy_mgr_is_hw_dbs_capable(hdd_ctx->psoc)) {
 		hdd_debug("Pre CAC is not supported on non-dbs platforms");
@@ -339,7 +340,8 @@ static int __wlan_hdd_request_pre_cac(struct hdd_context *hdd_ctx,
 		 */
 		pre_cac_adapter = hdd_open_adapter(hdd_ctx, QDF_SAP_MODE,
 						   SAP_PRE_CAC_IFNAME, mac_addr,
-						   NET_NAME_UNKNOWN, true);
+						   NET_NAME_UNKNOWN, true,
+						   &params);
 
 		if (!pre_cac_adapter) {
 			hdd_err("error opening the pre cac adapter");

core/hdd/src/wlan_hdd_sysfs.c

@@ -885,11 +885,16 @@ void hdd_create_adapter_sysfs_files(struct hdd_adapter *adapter)
 {
 	int device_mode = adapter->device_mode;
 
+	if (hdd_adapter_is_link_adapter(adapter)) {
+		hdd_err("link adapter returning!!");
+		return;
+	}
+
 	switch (device_mode){
 	case QDF_STA_MODE:
 	case QDF_P2P_DEVICE_MODE:
 	case QDF_P2P_CLIENT_MODE:
-		hdd_sysfs_create_sta_adapter_root_obj(adapter);
+			hdd_sysfs_create_sta_adapter_root_obj(adapter);
 		break;
 	case QDF_SAP_MODE:
 		hdd_sysfs_create_sap_adapter_root_obj(adapter);
@@ -906,14 +911,18 @@ void hdd_destroy_adapter_sysfs_files(struct hdd_adapter *adapter)
 {
 	int device_mode = adapter->device_mode;
 
+	if (hdd_adapter_is_link_adapter(adapter)) {
+		hdd_err("link adapter returning!!");
+		return;
+	}
 	switch (device_mode){
 	case QDF_STA_MODE:
 	case QDF_P2P_DEVICE_MODE:
 	case QDF_P2P_CLIENT_MODE:
-		hdd_sysfs_destroy_sta_adapter_root_obj(adapter);
+			hdd_sysfs_destroy_sta_adapter_root_obj(adapter);
 		break;
 	case QDF_SAP_MODE:
-		hdd_sysfs_destroy_sap_adapter_root_obj(adapter);
+			hdd_sysfs_destroy_sap_adapter_root_obj(adapter);
 		break;
 	case QDF_MONITOR_MODE:
 		hdd_sysfs_destroy_monitor_adapter_root_obj(adapter);

core/hdd/src/wlan_hdd_tx_rx.c

@@ -72,6 +72,7 @@
 #include "nan_ucfg_api.h"
 #include <wlan_hdd_sar_limits.h>
 #include "wlan_hdd_object_manager.h"
+#include "wlan_hdd_mlo.h"
 
 #if defined(QCA_LL_TX_FLOW_CONTROL_V2) || defined(QCA_LL_PDEV_TX_FLOW_CONTROL)
 /*
@@ -2981,11 +2982,14 @@ void wlan_hdd_netif_queue_control(struct hdd_adapter *adapter,
 	struct hdd_netif_queue_history *txq_hist_ptr;
 
 	if ((!adapter) || (WLAN_HDD_ADAPTER_MAGIC != adapter->magic) ||
-		 (!adapter->dev)) {
+	    (!adapter->dev)) {
 		hdd_err("adapter is invalid");
 		return;
 	}
 
+	if (hdd_adapter_is_link_adapter(adapter))
+		return;
+
 	switch (action) {
 
 	case WLAN_NETIF_CARRIER_ON: