Attachment 598924 Details for Bug 797709 – Patch 6 of 6 to update driver to 12/30/2011 vendor version

[patch] Patch 6 of 6 to update driver to 12/30/2011 vendor version

0006-rtlwifi-rtl8192de-Update-for-new-vendor-driver.patch (text/plain), 72.66 KB, created by Larry Finger on 2012-07-18 15:30:26 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Larry Finger

Created: 2012-07-18 15:30:26 UTC

Size: 72.66 KB

patch

obsolete

>From 50a6695a44b41d0133c8a1d4be641dde23e35b16 Mon Sep 17 00:00:00 2001
>From: Larry Finger <Larry.Finger@lwfinger.net>
>Date: Tue, 17 Jul 2012 21:44:03 -0500
>Subject: [PATCH 6/6] rtlwifi: rtl8192de: Update for new vendor driver
>
>Realtek driver rtl_92ce_92se_92de_linux_mac80211_0005.1230.2011
>includes m number of changes for the RTL8192DE chips. The main ones
>create a mechanism for the separate instances in a dual-MAC chip to
>share their private variable space.
>
>Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
>---
> drivers/net/wireless/rtlwifi/rtl8192de/dm.c  |  745 +++++++++++++++++++++++++-
> drivers/net/wireless/rtlwifi/rtl8192de/dm.h  |    3 +
> drivers/net/wireless/rtlwifi/rtl8192de/fw.c  |    6 +
> drivers/net/wireless/rtlwifi/rtl8192de/hw.c  |  244 ++++++---
> drivers/net/wireless/rtlwifi/rtl8192de/phy.c |  546 ++++++++++++++++++-
> drivers/net/wireless/rtlwifi/rtl8192de/phy.h |    2 +
> drivers/net/wireless/rtlwifi/rtl8192de/reg.h |    3 +-
> drivers/net/wireless/rtlwifi/rtl8192de/sw.c  |    6 +-
> 8 files changed, 1440 insertions(+), 115 deletions(-)
>
>diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/dm.c b/drivers/net/wireless/rtlwifi/rtl8192de/dm.c
>index f528b66..ff57982 100644
>--- a/drivers/net/wireless/rtlwifi/rtl8192de/dm.c
>+++ b/drivers/net/wireless/rtlwifi/rtl8192de/dm.c
>@@ -183,6 +183,27 @@ static void rtl92d_dm_diginit(struct ieee80211_hw *hw)
> 	de_digtable->forbidden_igi = DM_DIG_FA_LOWER;
> }
> 
>+bool _rtl92d_dualmac_getparameter_from_buddy(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+
>+	if (rtlpriv->rtlhal.macphymode != DUALMAC_SINGLEPHY)
>+		return false;
>+
>+	if (buddy_priv == NULL)
>+		return false;
>+
>+	if (rtlpriv->rtlhal.slave_of_dmsp)
>+		return false;
>+
>+	if ((buddy_priv->mac80211.link_state == MAC80211_LINKED) &&
>+	    (rtlpriv->mac80211.link_state != MAC80211_LINKED))
>+		return true;
>+	else
>+		return false;
>+}
>+
> static void rtl92d_dm_false_alarm_counter_statistics(struct ieee80211_hw *hw)
> {
> 	u32 ret_value;
>@@ -264,11 +285,70 @@ static void rtl92d_dm_false_alarm_counter_statistics(struct ieee80211_hw *hw)
> 		 falsealm_cnt->cnt_all);
> }
> 
>+void rtl92d_dm_false_alarm_counter_statistics_for_slaveofdmsp(
>+					struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	struct false_alarm_statistics *falsealm_cnt = &(rtlpriv->falsealm_cnt);
>+	struct false_alarm_statistics *buddy_flasealm_cnt;
>+
>+	if (buddy_priv == NULL)
>+		return;
>+
>+	buddy_flasealm_cnt = &(buddy_priv->falsealm_cnt);
>+
>+	falsealm_cnt->cnt_fast_fsync_fail = buddy_flasealm_cnt->cnt_fast_fsync_fail;
>+	falsealm_cnt->cnt_sb_search_fail = buddy_flasealm_cnt->cnt_sb_search_fail;
>+	falsealm_cnt->cnt_parity_fail = buddy_flasealm_cnt->cnt_parity_fail;
>+	falsealm_cnt->cnt_rate_illegal = buddy_flasealm_cnt->cnt_rate_illegal;
>+	falsealm_cnt->cnt_crc8_fail = buddy_flasealm_cnt->cnt_crc8_fail;
>+	falsealm_cnt->cnt_mcs_fail = buddy_flasealm_cnt->cnt_mcs_fail;
>+
>+	falsealm_cnt->cnt_ofdm_fail =
>+		falsealm_cnt->cnt_parity_fail +
>+		falsealm_cnt->cnt_rate_illegal +
>+		falsealm_cnt->cnt_crc8_fail +
>+		falsealm_cnt->cnt_mcs_fail +
>+		falsealm_cnt->cnt_fast_fsync_fail +
>+		falsealm_cnt->cnt_sb_search_fail;
>+
>+
>+	/* hold cck counter */
>+	falsealm_cnt->cnt_cck_fail = buddy_flasealm_cnt->cnt_cck_fail;
>+
>+	falsealm_cnt->cnt_all = (falsealm_cnt->cnt_fast_fsync_fail +
>+				 falsealm_cnt->cnt_sb_search_fail +
>+				 falsealm_cnt->cnt_parity_fail +
>+				 falsealm_cnt->cnt_rate_illegal +
>+				 falsealm_cnt->cnt_crc8_fail +
>+				 falsealm_cnt->cnt_mcs_fail +
>+				 falsealm_cnt->cnt_cck_fail);
>+
>+
>+	RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD,
>+		 "cnt_fast_fsync_fail = %x, cnt_sb_search_fail = %x\n",
>+		 falsealm_cnt->cnt_fast_fsync_fail, falsealm_cnt->cnt_sb_search_fail);
>+	RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD,
>+		 "cnt_parity_fail = %x, cnt_rate_illegal = %x,"
>+		 "cnt_crc8_fail = %x, Cnt_Mcs_fail = %x\n",
>+		 falsealm_cnt->cnt_parity_fail, falsealm_cnt->cnt_rate_illegal,
>+		 falsealm_cnt->cnt_crc8_fail, falsealm_cnt->cnt_mcs_fail);
>+	RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD,
>+		 "cnt_ofdm_fail = %x, cnt_cck_fail = %x, cnt_all = %x\n",
>+		 falsealm_cnt->cnt_ofdm_fail, falsealm_cnt->cnt_cck_fail,
>+		 falsealm_cnt->cnt_all);
>+}
>+
> static void rtl92d_dm_find_minimum_rssi(struct ieee80211_hw *hw)
> {
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
> 	struct dig_t *de_digtable = &rtlpriv->dm_digtable;
> 	struct rtl_mac *mac = rtl_mac(rtlpriv);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	long rssi_val_min_back_for_mac0 = 0;
>+	bool getvalue_from_buddy = _rtl92d_dualmac_getparameter_from_buddy(hw);
>+	bool restore_rssi = false;
> 
> 	/* Determine the minimum RSSI  */
> 	if ((mac->link_state < MAC80211_LINKED) &&
>@@ -300,16 +380,178 @@ static void rtl92d_dm_find_minimum_rssi(struct ieee80211_hw *hw)
> 			 de_digtable->min_undecorated_pwdb_for_dm);
> 	}
> 
>+	if (rtlpriv->dm.supp_phymode_switch) {
>+		if (rtlpriv->rtlhal.macphymode == DUALMAC_SINGLEPHY) {
>+			if (buddy_priv) {
>+				if (rtlpriv->rtlhal.slave_of_dmsp) {
>+					RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT,
>+						 DBG_LOUD,
>+						 "Slave case of dmsp\n");
>+					buddy_priv->dmsp_ctl.rssivalmin_for_anothermacofdmsp =
>+						de_digtable->last_min_undecorated_pwdb_for_dm;
>+				} else {
>+					if (getvalue_from_buddy) {
>+						RT_TRACE(rtlpriv,
>+							 COMP_EASY_CONCURRENT,
>+							 DBG_LOUD,
>+							 "get new RSSI\n");
>+						restore_rssi = true;
>+						rssi_val_min_back_for_mac0 =
>+							de_digtable->last_min_undecorated_pwdb_for_dm;
>+						de_digtable->last_min_undecorated_pwdb_for_dm =
>+							rtlpriv->dmsp_ctl.rssivalmin_for_anothermacofdmsp;
>+					}
>+					/*dm_1P_CCA()*/
>+					if (restore_rssi) {
>+						restore_rssi = false;
>+						de_digtable->last_min_undecorated_pwdb_for_dm =
>+							rssi_val_min_back_for_mac0;
>+					}
>+				}
>+			}
>+
>+		}
>+	}
>+
> 	RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, "MinUndecoratedPWDBForDM =%d\n",
> 		 de_digtable->min_undecorated_pwdb_for_dm);
> }
> 
>+u8 _rtl92d_dm_initial_gain_minpwdb(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	long rssi_val_min = 0;
>+	struct dig_t *digtable = &(rtlpriv->dm_digtable);
>+
>+	digtable->curmultista_connectstate = MULTISTA_CONNECT(rtlpriv);
>+	if ((digtable->curmultista_connectstate == DIG_MULTISTA_CONNECT) &&
>+	    (digtable->cursta_connectstate == DIG_STA_CONNECT)) {
>+		if (rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb != 0) {
>+			rssi_val_min = (rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb >
>+				rtlpriv->dm.undecorated_smoothed_pwdb) ?
>+				rtlpriv->dm.undecorated_smoothed_pwdb :
>+				rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb;
>+		} else {
>+			rssi_val_min = rtlpriv->dm.undecorated_smoothed_pwdb;
>+		}
>+	} else if (digtable->cursta_connectstate == DIG_STA_CONNECT ||
>+		   digtable->cursta_connectstate == DIG_STA_BEFORE_CONNECT) {
>+		rssi_val_min = rtlpriv->dm.undecorated_smoothed_pwdb;
>+	} else if (digtable->curmultista_connectstate == DIG_MULTISTA_CONNECT) {
>+		rssi_val_min = rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb;
>+	}
>+
>+	return (u8)rssi_val_min;
>+}
>+
>+void rtl92d_dm_cck_packet_detection_thresh_dmsp(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct dig_t *rtl_dm_dig = &(rtlpriv->dm_digtable);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	bool bgetvalue_from_buddy = _rtl92d_dualmac_getparameter_from_buddy(hw);
>+	unsigned long flag = 0;
>+
>+	if (rtl_dm_dig->cursta_connectstate == DIG_STA_CONNECT) {
>+		rtl_dm_dig->rssi_val_min =
>+			_rtl92d_dm_initial_gain_minpwdb(hw);
>+		if (rtl_dm_dig->pre_cck_pd_state == CCK_PD_STAGE_LOWRSSI) {
>+			if (rtl_dm_dig->rssi_val_min <= 25)
>+				rtl_dm_dig->cur_cck_pd_state = CCK_PD_STAGE_LOWRSSI;
>+			else
>+				rtl_dm_dig->cur_cck_pd_state = CCK_PD_STAGE_HIGHRSSI;
>+		} else {
>+			if (rtl_dm_dig->rssi_val_min <= 20)
>+				rtl_dm_dig->cur_cck_pd_state = CCK_PD_STAGE_LOWRSSI;
>+			else
>+				rtl_dm_dig->cur_cck_pd_state = CCK_PD_STAGE_HIGHRSSI;
>+		}
>+	} else {
>+		rtl_dm_dig->cur_cck_pd_state = CCK_PD_STAGE_MAX;
>+	}
>+
>+	if (bgetvalue_from_buddy) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			"mac 1 connect,mac 0 disconnect case\n");
>+		if (rtlpriv->dmsp_ctl.changecckpdstate_for_anothermacofdmsp) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				"mac 0 set for mac1\n");
>+			if (rtlpriv->dmsp_ctl.curcckpdstate_for_anothermacofdmsp ==
>+			    CCK_PD_STAGE_LOWRSSI) {
>+				rtl92d_acquire_cckandrw_pagea_ctl(hw, &flag);
>+				rtl_set_bbreg(hw, RCCK0_CCA, BMASKBYTE2, 0x83);
>+				rtl92d_release_cckandrw_pagea_ctl(hw, &flag);
>+			} else {
>+				rtl92d_acquire_cckandrw_pagea_ctl(hw, &flag);
>+				rtl_set_bbreg(hw, RCCK0_CCA, BMASKBYTE2, 0xcd);
>+				rtl92d_release_cckandrw_pagea_ctl(hw, &flag);
>+			}
>+			rtlpriv->dmsp_ctl.changecckpdstate_for_anothermacofdmsp = false;
>+		}
>+	}
>+
>+	if (rtl_dm_dig->pre_cck_pd_state != rtl_dm_dig->cur_cck_pd_state) {
>+
>+		if (NULL == buddy_priv) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "buddy == NULL case\n");
>+			if (rtlpriv->rtlhal.slave_of_dmsp) {
>+				rtl_dm_dig->pre_cck_pd_state = rtl_dm_dig->cur_cck_pd_state;
>+			} else {
>+				if (rtl_dm_dig->cur_cck_pd_state == CCK_PD_STAGE_LOWRSSI) {
>+					rtl92d_acquire_cckandrw_pagea_ctl(hw, &flag);
>+					rtl_set_bbreg(hw, RCCK0_CCA, BMASKBYTE2, 0x83);
>+					rtl92d_release_cckandrw_pagea_ctl(hw, &flag);
>+				} else {
>+					rtl92d_acquire_cckandrw_pagea_ctl(hw, &flag);
>+					rtl_set_bbreg(hw, RCCK0_CCA, BMASKBYTE2, 0xcd);
>+					rtl92d_release_cckandrw_pagea_ctl(hw, &flag);
>+				}
>+				rtl_dm_dig->pre_cck_pd_state = rtl_dm_dig->cur_cck_pd_state;
>+			}
>+			return;
>+		}
>+
>+		if (rtlpriv->rtlhal.slave_of_dmsp) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "bslave case\n");
>+			buddy_priv->dmsp_ctl.changecckpdstate_for_anothermacofdmsp = true;
>+			buddy_priv->dmsp_ctl.curcckpdstate_for_anothermacofdmsp =
>+				rtl_dm_dig->cur_cck_pd_state;
>+		} else {
>+			if (!bgetvalue_from_buddy) {
>+				RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+					 "mac 0 set for mac0\n");
>+				if (rtl_dm_dig->cur_cck_pd_state == CCK_PD_STAGE_LOWRSSI) {
>+					rtl92d_acquire_cckandrw_pagea_ctl(hw, &flag);
>+					rtl_set_bbreg(hw, RCCK0_CCA, BMASKBYTE2, 0x83);
>+					rtl92d_release_cckandrw_pagea_ctl(hw, &flag);
>+				} else {
>+					rtl92d_acquire_cckandrw_pagea_ctl(hw, &flag);
>+					rtl_set_bbreg(hw, RCCK0_CCA, BMASKBYTE2, 0xcd);
>+					rtl92d_release_cckandrw_pagea_ctl(hw, &flag);
>+				}
>+			}
>+		}
>+		rtl_dm_dig->pre_cck_pd_state = rtl_dm_dig->cur_cck_pd_state;
>+	}
>+	RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD,
>+		 "CCKPDStage=%x\n", rtl_dm_dig->cur_cck_pd_state);
>+}
>+
> static void rtl92d_dm_cck_packet_detection_thresh(struct ieee80211_hw *hw)
> {
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
> 	struct dig_t *de_digtable = &rtlpriv->dm_digtable;
> 	unsigned long flag = 0;
> 
>+	if (rtlpriv->dm.supp_phymode_switch) {
>+		if (rtlpriv->rtlhal.macphymode == DUALMAC_SINGLEPHY) {
>+			rtl92d_dm_cck_packet_detection_thresh_dmsp(hw);
>+			return;
>+		}
>+	}
>+
> 	if (de_digtable->cursta_connectstate == DIG_STA_CONNECT) {
> 		if (de_digtable->pre_cck_pd_state == CCK_PD_STAGE_LOWRSSI) {
> 			if (de_digtable->min_undecorated_pwdb_for_dm <= 25)
>@@ -352,11 +594,85 @@ static void rtl92d_dm_cck_packet_detection_thresh(struct ieee80211_hw *hw)
> 
> }
> 
>+void rtl92d_dm_write_dig_dmsp(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct dig_t *rtl_dm_dig = &(rtlpriv->dm_digtable);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	bool getvalue_from_othermac = _rtl92d_dualmac_getparameter_from_buddy(hw);
>+
>+	if (buddy_priv == NULL) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			 "not find buddy\n");
>+		if (rtlpriv->rtlhal.master_of_dmsp) {
>+			rtl_set_bbreg(hw, ROFDM0_XAAGCCORE1, 0x7f,
>+				rtl_dm_dig->cur_igvalue);
>+			rtl_set_bbreg(hw, ROFDM0_XBAGCCORE1, 0x7f,
>+				rtl_dm_dig->cur_igvalue);
>+			rtl_dm_dig->pre_igvalue = rtl_dm_dig->cur_igvalue;
>+		} else {
>+			rtl_dm_dig->pre_igvalue = rtl_dm_dig->cur_igvalue;
>+		}
>+		return;
>+	}
>+
>+	RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+		 "bgetvalue_from_othermac %d\n", getvalue_from_othermac);
>+
>+	if (getvalue_from_othermac) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			 "mac 0 set mac 1 value\n");
>+		if (rtlpriv->dmsp_ctl.writedig_for_anothermacofdmsp) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				 "mac 0 set mac 1 value change value\n");
>+			rtlpriv->dmsp_ctl.writedig_for_anothermacofdmsp = false;
>+			rtl_set_bbreg(hw, ROFDM0_XAAGCCORE1, 0x7f,
>+				rtlpriv->dmsp_ctl.curdigvalue_for_anothermacofdmsp);
>+			rtl_set_bbreg(hw, ROFDM0_XBAGCCORE1, 0x7f,
>+				rtlpriv->dmsp_ctl.curdigvalue_for_anothermacofdmsp);
>+		}
>+	}
>+
>+	if (rtl_dm_dig->pre_igvalue != rtl_dm_dig->cur_igvalue) {
>+		/* Set initial gain.
>+		Set only BIT0~BIT6 for DIG. BIT7 is for Antenna diversity.
>+		Just not to modified it for SD3 testing.
>+		*/
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			 "need to change initial gain\n");
>+		 if (rtlpriv->rtlhal.slave_of_dmsp) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "slave case\n");
>+			buddy_priv->dmsp_ctl.writedig_for_anothermacofdmsp = true;
>+			buddy_priv->dmsp_ctl.curdigvalue_for_anothermacofdmsp =
>+				rtl_dm_dig->cur_igvalue;
>+		} else {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "master case\n");
>+			if (!getvalue_from_othermac) {
>+				RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+					 "mac 0 set mac 0 value\n");
>+				rtl_set_bbreg(hw, ROFDM0_XAAGCCORE1, 0x7f,
>+					rtl_dm_dig->cur_igvalue);
>+				rtl_set_bbreg(hw, ROFDM0_XBAGCCORE1, 0x7f,
>+					rtl_dm_dig->cur_igvalue);
>+			}
>+		}
>+		rtl_dm_dig->pre_igvalue = rtl_dm_dig->cur_igvalue;
>+	}
>+}
>+
> void rtl92d_dm_write_dig(struct ieee80211_hw *hw)
> {
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
> 	struct dig_t *de_digtable = &rtlpriv->dm_digtable;
> 
>+	if (rtlpriv->dm.supp_phymode_switch) {
>+		if (rtlpriv->rtlhal.macphymode == DUALMAC_SINGLEPHY) {
>+			rtl92d_dm_write_dig_dmsp(hw);
>+			return;
>+		}
>+	}
> 	RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD,
> 		 "cur_igvalue = 0x%x, pre_igvalue = 0x%x, backoff_val = %d\n",
> 		 de_digtable->cur_igvalue, de_digtable->pre_igvalue,
>@@ -422,9 +738,6 @@ static void rtl92d_dm_dig(struct ieee80211_hw *hw)
> 	/* if (rtlpriv->mac80211.act_scanning)
> 	 *      return; */
> 
>-	/* Not STA mode return tmp */
>-	if (rtlpriv->mac80211.opmode != NL80211_IFTYPE_STATION)
>-		return;
> 	RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD, "progress\n");
> 	/* Decide the current status and if modify initial gain or not */
> 	if (rtlpriv->mac80211.link_state >= MAC80211_LINKED)
>@@ -432,6 +745,10 @@ static void rtl92d_dm_dig(struct ieee80211_hw *hw)
> 	else
> 		de_digtable->cursta_connectstate = DIG_STA_DISCONNECT;
> 
>+	if (rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP ||
>+	    rtlpriv->mac80211.opmode == NL80211_IFTYPE_ADHOC)
>+		de_digtable->cursta_connectstate = DIG_STA_DISCONNECT;
>+
> 	/* adjust initial gain according to false alarm counter */
> 	if (falsealm_cnt->cnt_all < DM_DIG_FA_TH0)
> 		value_igi--;
>@@ -522,6 +839,9 @@ static void rtl92d_dm_dynamic_txpower(struct ieee80211_hw *hw)
> 	struct rtl_phy *rtlphy = &(rtlpriv->phy);
> 	struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
> 	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	bool getvalue_from_buddy = _rtl92d_dualmac_getparameter_from_buddy(hw);
>+	u8 highpowerlvl_backformac0 = TXHIGHPWRLEVEL_LEVEL1;
> 	long undecorated_smoothed_pwdb;
> 
> 	if ((!rtlpriv->dm.dynamic_txpower_enable)
>@@ -529,10 +849,11 @@ static void rtl92d_dm_dynamic_txpower(struct ieee80211_hw *hw)
> 		rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_NORMAL;
> 		return;
> 	}
>-	if ((mac->link_state < MAC80211_LINKED) &&
>+	if (!rtlpriv->dm.supp_phymode_switch &&
>+	    (mac->link_state < MAC80211_LINKED) &&
> 	    (rtlpriv->dm.UNDEC_SM_PWDB == 0)) {
> 		RT_TRACE(rtlpriv, COMP_POWER, DBG_TRACE,
>-			 "Not connected to any\n");
>+			 "Not connected to any AP\n");
> 		rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_NORMAL;
> 		rtlpriv->dm.last_dtp_lvl = TXHIGHPWRLEVEL_NORMAL;
> 		return;
>@@ -602,11 +923,61 @@ static void rtl92d_dm_dynamic_txpower(struct ieee80211_hw *hw)
> 				 "TXHIGHPWRLEVEL_NORMAL\n");
> 		}
> 	}
>+
>+	if (rtlpriv->dm.supp_phymode_switch && getvalue_from_buddy) {
>+		RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
>+			 "mac 0 for mac 1\n");
>+		if (rtlpriv->dmsp_ctl.changetxhighpowerlvl_for_anothermacofdmsp) {
>+			RT_TRACE(rtlpriv, COMP_POWER, DBG_EMERG,
>+				 "change value\n");
>+			highpowerlvl_backformac0 = rtlpriv->dm.dynamic_txhighpower_lvl;
>+			rtlpriv->dm.dynamic_txhighpower_lvl =
>+				rtlpriv->dmsp_ctl.curtxhighlvl_for_anothermacofdmsp;
>+			rtl92d_phy_set_txpower_level(hw, buddy_priv->phy.current_channel);
>+			rtlpriv->dm.dynamic_txhighpower_lvl = highpowerlvl_backformac0;
>+			rtlpriv->dmsp_ctl.changetxhighpowerlvl_for_anothermacofdmsp =
>+					false;
>+		}
>+	}
> 	if ((rtlpriv->dm.dynamic_txhighpower_lvl != rtlpriv->dm.last_dtp_lvl)) {
> 		RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
> 			 "PHY_SetTxPowerLevel8192S() Channel = %d\n",
> 			 rtlphy->current_channel);
>-		rtl92d_phy_set_txpower_level(hw, rtlphy->current_channel);
>+		if (rtlpriv->dm.supp_phymode_switch) {
>+			if (!buddy_priv) {
>+				RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
>+					 "Buddy == NULL case\n");
>+				if (!rtlpriv->rtlhal.slave_of_dmsp)
>+					rtl92d_phy_set_txpower_level(hw, rtlphy->current_channel);
>+			} else {
>+				if (rtlpriv->rtlhal.macphymode == DUALMAC_SINGLEPHY) {
>+					RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
>+						 "Buddy != NULL DMSP\n");
>+					if (rtlpriv->rtlhal.slave_of_dmsp) {
>+						RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
>+							 "bslave case\n");
>+						buddy_priv->dmsp_ctl.
>+							changetxhighpowerlvl_for_anothermacofdmsp = true;
>+						buddy_priv->dmsp_ctl.curtxhighlvl_for_anothermacofdmsp
>+							= rtlpriv->dm.dynamic_txhighpower_lvl;
>+					} else {
>+						RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
>+							 "master case\n");
>+						if (!getvalue_from_buddy) {
>+							RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
>+								 "mac 0 for mac 0\n");
>+							rtl92d_phy_set_txpower_level(hw, rtlphy->current_channel);
>+						}
>+					}
>+				} else {
>+					RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
>+						 "Buddy != NULL DMDP\n");
>+					rtl92d_phy_set_txpower_level(hw, rtlphy->current_channel);
>+				}
>+			}
>+		} else {
>+			rtl92d_phy_set_txpower_level(hw, rtlphy->current_channel);
>+		}
> 	}
> 	rtlpriv->dm.last_dtp_lvl = rtlpriv->dm.dynamic_txhighpower_lvl;
> }
>@@ -614,22 +985,48 @@ static void rtl92d_dm_dynamic_txpower(struct ieee80211_hw *hw)
> static void rtl92d_dm_pwdb_monitor(struct ieee80211_hw *hw)
> {
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_sta_info *drv_priv;
>+	long tmp_entry_max_pwdb = 0, tmp_entry_min_pwdb = 0xff;
>+
>+	/* AP & ADHOC & MESH */
>+	spin_lock_bh(&rtlpriv->locks.entry_list_lock);
>+	list_for_each_entry(drv_priv, &rtlpriv->entry_list, list) {
>+		if (drv_priv->rssi_stat.undecorated_smoothed_pwdb < tmp_entry_min_pwdb)
>+			tmp_entry_min_pwdb = drv_priv->rssi_stat.undecorated_smoothed_pwdb;
>+		if (drv_priv->rssi_stat.undecorated_smoothed_pwdb > tmp_entry_max_pwdb)
>+			tmp_entry_max_pwdb = drv_priv->rssi_stat.undecorated_smoothed_pwdb;
>+	}
>+	spin_unlock_bh(&rtlpriv->locks.entry_list_lock);
>+
>+	/* If associated entry is found */
>+	if (tmp_entry_max_pwdb != 0)	{
>+		rtlpriv->dm.entry_max_undecoratedsmoothed_pwdb = tmp_entry_max_pwdb;
>+		RTPRINT(rtlpriv, FDM, DM_PWDB, "EntryMaxPWDB = 0x%lx(%ld)\n",
>+			tmp_entry_max_pwdb, tmp_entry_max_pwdb);
>+	} else {
>+		rtlpriv->dm.entry_max_undecoratedsmoothed_pwdb = 0;
>+	}
>+	/* If associated entry is found */
>+	if (tmp_entry_min_pwdb != 0xff) {
>+		rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb = tmp_entry_min_pwdb;
>+		RTPRINT(rtlpriv, FDM, DM_PWDB, "EntryMinPWDB = 0x%lx(%ld)\n",
>+					tmp_entry_min_pwdb, tmp_entry_min_pwdb);
>+	} else {
>+		rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb = 0;
>+	}
> 
>-	/* AP & ADHOC & MESH will return tmp */
>-	if (rtlpriv->mac80211.opmode != NL80211_IFTYPE_STATION)
>-		return;
> 	/* Indicate Rx signal strength to FW. */
> 	if (rtlpriv->dm.useramask) {
>-		u32 temp = rtlpriv->dm.undecorated_smoothed_pwdb;
>-
>-		temp <<= 16;
>-		temp |= 0x100;
>+		u32 temp = 0;
>+		temp = rtlpriv->dm.undecorated_smoothed_pwdb;
>+		temp = temp << 16;
>+		temp = temp | 0x100;
> 		/* fw v12 cmdid 5:use max macid ,for nic ,
> 		 * default macid is 0 ,max macid is 1 */
> 		rtl92d_fill_h2c_cmd(hw, H2C_RSSI_REPORT, 3, (u8 *) (&temp));
> 	} else {
> 		rtl_write_byte(rtlpriv, 0x4fe,
>-			       (u8) rtlpriv->dm.undecorated_smoothed_pwdb);
>+				(u8) rtlpriv->dm.undecorated_smoothed_pwdb);
> 	}
> }
> 
>@@ -642,6 +1039,41 @@ void rtl92d_dm_init_edca_turbo(struct ieee80211_hw *hw)
> 	rtlpriv->dm.is_cur_rdlstate = false;
> }
> 
>+void rtl92d_dm_interrupt_migration(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_mac *mac = rtl_mac(rtlpriv);
>+	bool current_int_mt, current_ac_int_disable;
>+	bool int_mt_to_set = false;
>+	bool ac_int_to_set = false;
>+
>+	/* Retrieve current interrupt migration
>+	 * and Tx four ACs IMR settings first. */
>+	rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_INT_MIGRATION,
>+				      (u8 *) (&current_int_mt));
>+	rtlpriv->cfg->ops->get_hw_reg(hw, HW_VAR_INT_AC,
>+				      (u8 *) (&current_ac_int_disable));
>+
>+	/* Currently we use busy traffic for reference
>+	 * instead of RxIntOK counts to prevent non-linear
>+	 * Rx statistics when interrupt migration is set before.*/
>+	if (mac->link_state >= MAC80211_LINKED &&
>+	    rtlpriv->link_info.higher_busytraffic) {
>+		int_mt_to_set = true;
>+
>+		/* To check whether we should disable Tx interrupt or not. */
>+		if (rtlpriv->link_info.higher_busyrxtraffic)
>+			ac_int_to_set = true;
>+	}
>+	/* Update current settings. */
>+	if (current_int_mt != int_mt_to_set)
>+		rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_INT_MIGRATION,
>+				(u8 *)&int_mt_to_set);
>+	if (current_ac_int_disable != ac_int_to_set)
>+		rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_INT_AC,
>+				(u8 *)&ac_int_to_set);
>+}
>+
> static void rtl92d_dm_check_edca_turbo(struct ieee80211_hw *hw)
> {
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
>@@ -1284,6 +1716,14 @@ void rtl92d_dm_check_txpower_tracking_thermal_meter(struct ieee80211_hw *hw)
> 	}
> }
> 
>+void rtl92c_dm_report_signalstrength(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+
>+	rtl_write_byte(rtlpriv, REG_DUMMY,
>+		       (u8) rtlpriv->dm.undecorated_smoothed_pwdb);
>+}
>+
> void rtl92d_dm_init_rate_adaptive_mask(struct ieee80211_hw *hw)
> {
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
>@@ -1297,6 +1737,262 @@ void rtl92d_dm_init_rate_adaptive_mask(struct ieee80211_hw *hw)
> 		rtlpriv->dm.useramask = false;
> }
> 
>+void rtl92d_dm_refresh_rate_adaptive_mask(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
>+	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
>+	struct rate_adaptive *p_ra = &(rtlpriv->ra);
>+	struct ieee80211_sta *sta = NULL;
>+	u32 low_rssithresh_for_ra, high_rssithresh_for_ra;
>+
>+	if (is_hal_stop(rtlhal)) {
>+		RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD,
>+			 "<---- driver is going to unload\n");
>+		return;
>+	}
>+	if (!rtlpriv->dm.useramask) {
>+		RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD,
>+			 "<---- driver does not control rate adaptive mask\n");
>+		return;
>+	}
>+	if (mac->opmode != NL80211_IFTYPE_STATION)
>+		return;
>+
>+	if (mac->link_state == MAC80211_LINKED) {
>+		switch (p_ra->pre_ratr_state) {
>+		case DM_RATR_STA_HIGH:
>+			high_rssithresh_for_ra = 50;
>+			low_rssithresh_for_ra = 20;
>+			break;
>+		case DM_RATR_STA_MIDDLE:
>+			high_rssithresh_for_ra = 55;
>+			low_rssithresh_for_ra = 20;
>+			break;
>+		case DM_RATR_STA_LOW:
>+			high_rssithresh_for_ra = 50;
>+			low_rssithresh_for_ra = 25;
>+			break;
>+		default:
>+			high_rssithresh_for_ra = 50;
>+			low_rssithresh_for_ra = 20;
>+			break;
>+		}
>+		if (rtlpriv->dm.undecorated_smoothed_pwdb >
>+		    (long)high_rssithresh_for_ra)
>+			p_ra->ratr_state = DM_RATR_STA_HIGH;
>+		else if (rtlpriv->dm.undecorated_smoothed_pwdb >
>+			 (long)low_rssithresh_for_ra)
>+			p_ra->ratr_state = DM_RATR_STA_MIDDLE;
>+		else
>+			p_ra->ratr_state = DM_RATR_STA_LOW;
>+
>+		if (p_ra->pre_ratr_state != p_ra->ratr_state) {
>+			RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, "RSSI = %ld\n",
>+					rtlpriv->dm.undecorated_smoothed_pwdb);
>+			RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD, "RSSI_LEVEL = %d\n",
>+					p_ra->ratr_state);
>+			RT_TRACE(rtlpriv, COMP_RATE, DBG_LOUD,
>+					"PreState = %d, CurState = %d\n",
>+					p_ra->pre_ratr_state, p_ra->ratr_state);
>+
>+			rcu_read_lock();
>+			sta = rtl_find_sta(hw, mac->bssid);
>+			rtlpriv->cfg->ops->update_rate_tbl(hw, sta, p_ra->ratr_state);
>+			rcu_read_unlock();
>+
>+			p_ra->pre_ratr_state = p_ra->ratr_state;
>+		}
>+	}
>+}
>+
>+bool _rtl92d_dm_dual_mac_check_switch_to_dmsp(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	struct ieee80211_hw *buddy_hw = NULL;
>+	bool need_to_change = true;
>+
>+	if (buddy_priv == NULL) {
>+		/* SMSP */
>+		need_to_change = false;
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				"buddy is NULL\n");
>+		return need_to_change;
>+	} else {
>+		buddy_hw = buddy_priv->mac80211.hw;
>+		if (rtlhal->macphymode == DUALMAC_SINGLEPHY) {
>+			/* DMSP */
>+			need_to_change = false;
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				"DMSP\n");
>+			return need_to_change;
>+		}
>+
>+		if (rtlpriv->rtlhal.interfaceindex == 1) {
>+			/* MAC 1 */
>+			need_to_change = false;
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "MAC 1\n");
>+			return need_to_change;
>+		}
>+
>+		if ((rtlpriv->rtlhal.being_init_adapter) ||
>+		    (buddy_priv->rtlhal.being_init_adapter)) {
>+			/* hw is not ready */
>+			need_to_change = false;
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "Initialization is on going\n");
>+			return need_to_change;
>+		}
>+
>+		if ((!rtlpriv->rtlhal.bbrf_ready) ||
>+			(!buddy_priv->rtlhal.bbrf_ready)) {
>+			/* hw is not ready */
>+			need_to_change = false;
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "bb rf not ready\n");
>+			return need_to_change;
>+		}
>+
>+		if ((rtlpriv->mac80211.link_state == MAC80211_LINKING) ||
>+		   (buddy_priv->mac80211.link_state == MAC80211_LINKING)) {
>+			/* Link In process */
>+			need_to_change = false;
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "Link has been in Progress\n");
>+			return need_to_change;
>+		}
>+
>+		if ((rtlpriv->mac80211.act_scanning) ||
>+		    (buddy_priv->mac80211.act_scanning)) {
>+			/* Scan In process */
>+			need_to_change = false;
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "Scan In Progress\n");
>+			return need_to_change;
>+		}
>+	}
>+
>+	return need_to_change;
>+}
>+
>+void rtl92d_dm_easy_concurrent_switch_to_dmsp(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	struct ieee80211_hw *buddy_hw = NULL;
>+	struct ieee80211_sta *sta = NULL;
>+	struct rtl_sta_info *sta_entry = NULL;
>+	bool schedule_workitem = false;
>+	bool buddy_linked = false;
>+	bool change_to_dmsp = false;
>+	static int switch_count;
>+
>+	if (!rtlpriv->dm.supp_phymode_switch)
>+		return;
>+	if (rtlpriv->mac80211.opmode == NL80211_IFTYPE_ADHOC)
>+		return;
>+	change_to_dmsp = _rtl92d_dm_dual_mac_check_switch_to_dmsp(hw);
>+	RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+		 "rtlhal->macphymode %x\n", rtlhal->macphymode);
>+	if (buddy_priv)
>+		buddy_hw = buddy_priv->mac80211.hw;
>+	if (!change_to_dmsp) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			 "Skip change To DMSP return\n");
>+
>+		if (buddy_priv != NULL) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "buddy mode is %d\n", buddy_priv->mac80211.opmode);
>+		}
>+		return;
>+	} else {
>+		if ((buddy_priv->mac80211.opmode != NL80211_IFTYPE_AP) &&
>+		    (rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP)) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "STA + STA Case\n");
>+
>+			if (((rtlpriv->mac80211.link_state == MAC80211_LINKED) &&
>+			   (buddy_priv->mac80211.link_state != MAC80211_LINKED)) ||
>+			   ((rtlpriv->mac80211.link_state != MAC80211_LINKED) &&
>+			   (buddy_priv->mac80211.link_state == MAC80211_LINKED))) {
>+				schedule_workitem = true;
>+				switch_count++;
>+			} else {
>+				schedule_workitem = false;
>+				switch_count = 0;
>+			}
>+			if (schedule_workitem && (switch_count == 3)) {
>+				RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+					 "Change to DMSP mode\n");
>+				switch_count = 0;
>+				rcu_read_lock();
>+				if ((rtlpriv->mac80211.link_state == MAC80211_LINKED) &&
>+				    (buddy_priv->mac80211.link_state != MAC80211_LINKED)) {
>+					sta = rtl_find_sta(hw, rtlpriv->mac80211.bssid);
>+				} else {
>+					sta = rtl_find_sta(buddy_priv->mac80211.hw,
>+						buddy_priv->mac80211.bssid);
>+					buddy_linked = true;
>+				}
>+				if (sta) {
>+					sta_entry = (struct rtl_sta_info *) sta->drv_priv;
>+					sta_entry->mimo_ps = IEEE80211_SMPS_OFF;
>+				}
>+				rtlpriv->easy_concurrent_ctl.change_to_dmsp = true;
>+				rtl_dualmac_easyconcurrent(hw);
>+				if (buddy_linked) {
>+					if (sta->ht_cap.ht_supported)
>+						rtl_send_smps_action(buddy_hw, sta, IEEE80211_SMPS_OFF);
>+				} else {
>+					if (sta->ht_cap.ht_supported)
>+						rtl_send_smps_action(hw, sta, IEEE80211_SMPS_OFF);
>+				}
>+				rcu_read_unlock();
>+			}
>+		} else if ((buddy_priv->mac80211.opmode == NL80211_IFTYPE_AP) &&
>+			   (rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP)) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "MAC 0 STA and MAC 1 AP\n");
>+		}
>+
>+	}
>+}
>+
>+void rtl92d_dm_easy_concurrent_switch_to_dmdp(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+
>+	if (!rtlpriv->dm.supp_phymode_switch)
>+		return;
>+	if (!buddy_priv)
>+		return;
>+	if ((buddy_priv->mac80211.opmode != NL80211_IFTYPE_AP) &&
>+	    (rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP)) {
>+		if ((rtlpriv->mac80211.link_state == MAC80211_NOLINK) &&
>+		    (buddy_priv->mac80211.link_state == MAC80211_NOLINK)) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				 "STA + STA no link Case\n");
>+			rtlpriv->easy_concurrent_ctl.change_to_dmdp = true;
>+			buddy_priv->easy_concurrent_ctl.change_to_dmdp = true;
>+
>+			if (rtlpriv->rtlhal.interfaceindex == 0)
>+				rtlpriv->easy_concurrent_ctl.close_bbandrf_for_dmsp
>+					= true;
>+			else
>+				buddy_priv->easy_concurrent_ctl.close_bbandrf_for_dmsp
>+					= true;
>+
>+			rtl_dualmac_easyconcurrent(hw);
>+			rtl_dualmac_easyconcurrent(buddy_priv->mac80211.hw);
>+		}
>+	}
>+}
>+
> void rtl92d_dm_init(struct ieee80211_hw *hw)
> {
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
>@@ -1311,9 +2007,12 @@ void rtl92d_dm_init(struct ieee80211_hw *hw)
> 
> void rtl92d_dm_watchdog(struct ieee80211_hw *hw)
> {
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
> 	struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
> 	bool fw_current_inpsmode = false;
> 	bool fwps_awake = true;
>+	unsigned long flags = 0;
> 
> 	/* 1. RF is OFF. (No need to do DM.)
> 	 * 2. Fw is under power saving mode for FwLPS.
>@@ -1323,14 +2022,30 @@ void rtl92d_dm_watchdog(struct ieee80211_hw *hw)
> 	 * 4. RFChangeInProgress is TRUE.
> 	 *    (Prevent from broken by IPS/HW/SW Rf off.) */
> 
>+	if (rtlpriv->dm.supp_phymode_switch && !buddy_priv) {
>+		if (rtlpriv->intf_ops->check_buddy_priv(hw, &buddy_priv))
>+			rtlpriv->buddy_priv = buddy_priv;
>+	}
>+
> 	if ((ppsc->rfpwr_state == ERFON) && ((!fw_current_inpsmode) &&
> 	    fwps_awake) && (!ppsc->rfchange_inprogress)) {
> 		rtl92d_dm_pwdb_monitor(hw);
>-		rtl92d_dm_false_alarm_counter_statistics(hw);
>+		if (rtlpriv->dm.supp_phymode_switch) {
>+			spin_lock_irqsave(&rtlpriv->glb_var->glb_list_lock, flags);
>+			if (rtlpriv->rtlhal.slave_of_dmsp)
>+				rtl92d_dm_false_alarm_counter_statistics_for_slaveofdmsp(hw);
>+			else
>+				rtl92d_dm_false_alarm_counter_statistics(hw);
>+			spin_unlock_irqrestore(&rtlpriv->glb_var->glb_list_lock, flags);
>+		} else {
>+			rtl92d_dm_false_alarm_counter_statistics(hw);
>+		}
> 		rtl92d_dm_find_minimum_rssi(hw);
> 		rtl92d_dm_dig(hw);
> 		/* rtl92d_dm_dynamic_bb_powersaving(hw); */
> 		rtl92d_dm_dynamic_txpower(hw);
>+		rtl92d_dm_easy_concurrent_switch_to_dmsp(hw);
>+		rtl92d_dm_easy_concurrent_switch_to_dmdp(hw);
> 		/* rtl92d_dm_check_txpower_tracking_thermal_meter(hw); */
> 		/* rtl92d_dm_refresh_rate_adaptive_mask(hw); */
> 		/* rtl92d_dm_interrupt_migration(hw); */
>diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/dm.h b/drivers/net/wireless/rtlwifi/rtl8192de/dm.h
>index 3fea0c1..7e49323 100644
>--- a/drivers/net/wireless/rtlwifi/rtl8192de/dm.h
>+++ b/drivers/net/wireless/rtlwifi/rtl8192de/dm.h
>@@ -151,6 +151,9 @@ enum dm_dig_connect {
> 	DIG_CONNECT_MAX
> };
> 
>+#define MULTISTA_CONNECT(rtlpriv) (list_empty(&rtlpriv->entry_list) ? \
>+		DIG_MULTISTA_DISCONNECT : DIG_MULTISTA_CONNECT);
>+
> void rtl92d_dm_init(struct ieee80211_hw *hw);
> void rtl92d_dm_watchdog(struct ieee80211_hw *hw);
> void rtl92d_dm_init_edca_turbo(struct ieee80211_hw *hw);
>diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/fw.c b/drivers/net/wireless/rtlwifi/rtl8192de/fw.c
>index f548a8d..79b57d2 100644
>--- a/drivers/net/wireless/rtlwifi/rtl8192de/fw.c
>+++ b/drivers/net/wireless/rtlwifi/rtl8192de/fw.c
>@@ -532,8 +532,14 @@ static void _rtl92d_fill_h2c_command(struct ieee80211_hw *hw,
> void rtl92d_fill_h2c_cmd(struct ieee80211_hw *hw,
> 			 u8 element_id, u32 cmd_len, u8 *cmdbuffer)
> {
>+	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
> 	u32 tmp_cmdbuf[2];
> 
>+	if (rtlhal->fw_ready == false) {
>+		RT_ASSERT(false,
>+			  "return H2C cmd because of Fw download fail!!!\n");
>+		return;
>+	}
> 	memset(tmp_cmdbuf, 0, 8);
> 	memcpy(tmp_cmdbuf, cmdbuffer, cmd_len);
> 	_rtl92d_fill_h2c_command(hw, element_id, cmd_len, (u8 *)&tmp_cmdbuf);
>diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/hw.c b/drivers/net/wireless/rtlwifi/rtl8192de/hw.c
>index b338d52..ef944eb 100644
>--- a/drivers/net/wireless/rtlwifi/rtl8192de/hw.c
>+++ b/drivers/net/wireless/rtlwifi/rtl8192de/hw.c
>@@ -203,9 +203,8 @@ void rtl92de_set_hw_reg(struct ieee80211_hw *hw, u8 variable, u8 *val)
> 			rate_cfg = (rate_cfg >> 1);
> 			rate_index++;
> 		}
>-		if (rtlhal->fw_version > 0xe)
>-			rtl_write_byte(rtlpriv, REG_INIRTS_RATE_SEL,
>-				       rate_index);
>+		rtl_write_byte(rtlpriv, REG_INIRTS_RATE_SEL,
>+			       rate_index);
> 		break;
> 	}
> 	case HW_VAR_BSSID:
>@@ -673,12 +672,12 @@ static bool _rtl92de_init_mac(struct ieee80211_hw *hw)
> 
> 	/* 5.   Wait while 0x04[8] == 0 goto 2, otherwise goto 1 */
> 	bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO + 1);
>-	udelay(50);
>+	udelay(2);
> 	retry = 0;
> 	while ((bytetmp & BIT(0)) && retry < 1000) {
> 		retry++;
>-		bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO + 1);
> 		udelay(50);
>+		bytetmp = rtl_read_byte(rtlpriv, REG_APS_FSMCO + 1);
> 	}
> 
> 	/* Enable Radio off, GPIO, and LED function */
>@@ -907,6 +906,7 @@ int rtl92de_hw_init(struct ieee80211_hw *hw)
> 	struct rtl_phy *rtlphy = &(rtlpriv->phy);
> 	struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
> 	struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
> 	bool rtstatus = true;
> 	u8 tmp_u1b;
> 	int i;
>@@ -914,7 +914,6 @@ int rtl92de_hw_init(struct ieee80211_hw *hw)
> 	unsigned long flags;
> 
> 	rtlpci->being_init_adapter = true;
>-	rtlpci->init_ready = false;
> 	spin_lock_irqsave(&globalmutex_for_power_and_efuse, flags);
> 	/* we should do iqk after disable/enable */
> 	rtl92d_phy_reset_iqk_result(hw);
>@@ -931,7 +930,10 @@ int rtl92de_hw_init(struct ieee80211_hw *hw)
> 	if (err) {
> 		RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
> 			 "Failed to download FW. Init HW without FW..\n");
>-		return 1;
>+		err = 1;
>+		rtlhal->fw_ready = false;
>+	} else {
>+		rtlhal->fw_ready = true;
> 	}
> 	rtlhal->last_hmeboxnum = 0;
> 	rtlpriv->psc.fw_current_inpsmode = false;
>@@ -969,39 +971,60 @@ int rtl92de_hw_init(struct ieee80211_hw *hw)
> 	rtlpci->receive_config = rtl_read_dword(rtlpriv, REG_RCR);
> 	rtlpci->receive_config &= ~(RCR_ACRC32 | RCR_AICV);
> 
>-	rtl92d_phy_bb_config(hw);
>-
>-	rtlphy->rf_mode = RF_OP_BY_SW_3WIRE;
>-	/* set before initialize RF */
>-	rtl_set_bbreg(hw, RFPGA0_ANALOGPARAMETER4, 0x00f00000, 0xf);
>-
>-	/* config RF */
>-	rtl92d_phy_rf_config(hw);
>-
> 	/* After read predefined TXT, we must set BB/MAC/RF
>-	 * register as our requirement */
>-	/* After load BB,RF params,we need do more for 92D. */
>-	rtl92d_update_bbrf_configuration(hw);
>+	 * register as our requirement
>+	 * After load BB,RF params,we need do more for 92D. */
>+	if (rtlpriv->dm.supp_phymode_switch) {
>+		if (!rtlhal->slave_of_dmsp)
>+			rtl92d_update_bbrf_configuration(hw);
>+	} else {
>+		rtl92d_update_bbrf_configuration(hw);
>+	}
> 	/* set default value after initialize RF,  */
> 	rtl_set_bbreg(hw, RFPGA0_ANALOGPARAMETER4, 0x00f00000, 0);
>-	rtlphy->rfreg_chnlval[0] = rtl_get_rfreg(hw, (enum radio_path)0,
>+	if (rtlpriv->dm.supp_phymode_switch) {
>+		if (buddy_priv != NULL) {
>+			if (rtlhal->slave_of_dmsp) {
>+				rtlphy->rfreg_chnlval[0]  = buddy_priv->phy.rfreg_chnlval[0] ;
>+				rtlphy->rfreg_chnlval[1]  = buddy_priv->phy.rfreg_chnlval[1] ;
>+			} else {
>+				rtlphy->rfreg_chnlval[0] = rtl_get_rfreg(hw, (enum radio_path)0,
>+					RF_CHNLBW, BRFREGOFFSETMASK);
>+				rtlphy->rfreg_chnlval[1] = rtl_get_rfreg(hw, (enum radio_path)1,
>+					RF_CHNLBW, BRFREGOFFSETMASK);
>+			}
>+		} else {
>+			rtlphy->rfreg_chnlval[0] = rtl_get_rfreg(hw, (enum radio_path)0,
>+				RF_CHNLBW, BRFREGOFFSETMASK);
>+			rtlphy->rfreg_chnlval[1] = rtl_get_rfreg(hw, (enum radio_path)1,
>+				RF_CHNLBW, BRFREGOFFSETMASK);
>+		}
>+	} else {
>+		rtlphy->rfreg_chnlval[0] = rtl_get_rfreg(hw, (enum radio_path)0,
> 			RF_CHNLBW, BRFREGOFFSETMASK);
>-	rtlphy->rfreg_chnlval[1] = rtl_get_rfreg(hw, (enum radio_path)1,
>+		rtlphy->rfreg_chnlval[1] = rtl_get_rfreg(hw, (enum radio_path)1,
> 			RF_CHNLBW, BRFREGOFFSETMASK);
>-
>+	}
> 	/*---- Set CCK and OFDM Block "ON"----*/
> 	if (rtlhal->current_bandtype == BAND_ON_2_4G)
> 		rtl_set_bbreg(hw, RFPGA0_RFMOD, BCCKEN, 0x1);
> 	rtl_set_bbreg(hw, RFPGA0_RFMOD, BOFDMEN, 0x1);
>+	if (!rtlpriv->dm.supp_phymode_switch ||
>+	    (rtlpriv->dm.supp_phymode_switch && (!rtlhal->slave_of_dmsp))) {
>+		if (rtlhal->current_bandtype == BAND_ON_2_4G)
>+			rtl_set_bbreg(hw, RFPGA0_RFMOD, BCCKEN, 0x1);
>+		rtl_set_bbreg(hw, RFPGA0_RFMOD, BOFDMEN, 0x1);
>+	}
> 	if (rtlhal->interfaceindex == 0) {
>-		/* RFPGA0_ANALOGPARAMETER2: cck clock select,
>-		 *  set to 20MHz by default */
>-		rtl_set_bbreg(hw, RFPGA0_ANALOGPARAMETER2, BIT(10) |
>-			      BIT(11), 3);
>+		/*RFPGA0_ANALOGPARAMETER2: cck clock select,  set to 20MHz by default */
>+		if (!rtlpriv->dm.supp_phymode_switch ||
>+			(rtlpriv->dm.supp_phymode_switch && (!rtlhal->slave_of_dmsp)))
>+			rtl_set_bbreg(hw, RFPGA0_ANALOGPARAMETER2, BIT(10) | BIT(11), 3);
> 	} else {
> 		/* Mac1 */
>-		rtl_set_bbreg(hw, RFPGA0_ANALOGPARAMETER2, BIT(11) |
>-			      BIT(10), 3);
>+		if (!rtlpriv->dm.supp_phymode_switch ||
>+		    (rtlpriv->dm.supp_phymode_switch && (!rtlhal->slave_of_dmsp)))
>+			rtl_set_bbreg(hw, RFPGA0_ANALOGPARAMETER2, BIT(11) | BIT(10), 3);
> 	}
> 
> 	_rtl92de_hw_configure(hw);
>@@ -1012,9 +1035,11 @@ int rtl92de_hw_init(struct ieee80211_hw *hw)
> 
> 	/* Read EEPROM TX power index and PHY_REG_PG.txt to capture correct */
> 	/* TX power index for different rate set. */
>-	rtl92d_phy_get_hw_reg_originalvalue(hw);
>-	rtl92d_phy_set_txpower_level(hw, rtlphy->current_channel);
>-
>+	if (!rtlpriv->dm.supp_phymode_switch ||
>+	    (rtlpriv->dm.supp_phymode_switch && (!rtlhal->slave_of_dmsp))) {
>+		rtl92d_phy_get_hw_reg_originalvalue(hw);
>+		rtl92d_phy_set_txpower_level(hw, rtlphy->current_channel);
>+	}
> 	ppsc->rfpwr_state = ERFON;
> 
> 	rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_ETHER_ADDR, mac->mac_addr);
>@@ -1023,6 +1048,26 @@ int rtl92de_hw_init(struct ieee80211_hw *hw)
> 	/* rtlpriv->intf_ops->enable_aspm(hw); */
> 
> 	rtl92d_dm_init(hw);
>+
>+	if (!rtlpriv->dm.supp_phymode_switch ||
>+	    (rtlpriv->dm.supp_phymode_switch && (!rtlhal->slave_of_dmsp))) {
>+		if (ppsc->rfpwr_state == ERFON) {
>+			rtl92d_phy_lc_calibrate(hw);
>+			/* 5G and 2.4G must wait sometime to let RF LO ready */
>+			if (rtlhal->macphymode == DUALMAC_DUALPHY) {
>+				u32 tmp_rega;
>+				for (i = 0; i < 10000; i++) {
>+					udelay(MAX_STALL_TIME);
>+
>+					tmp_rega = rtl_get_rfreg(hw, (enum radio_path)RF90_PATH_A,
>+							0x2a, BMASKDWORD);
>+
>+					if (((tmp_rega & BIT(11)) == BIT(11)))
>+						break;
>+				}
>+			}
>+		}
>+	}
> 	rtlpci->being_init_adapter = false;
> 
> 	if (ppsc->rfpwr_state == ERFON) {
>@@ -1047,7 +1092,10 @@ int rtl92de_hw_init(struct ieee80211_hw *hw)
> 			}
> 		}
> 	}
>+	rtlpriv->rtlhal.being_init_adapter = false;
>+	rtlpriv->rtlhal.bbrf_ready = true;
> 	rtlpci->init_ready = true;
>+
> 	return err;
> }
> 
>@@ -1058,11 +1106,13 @@ static enum version_8192d _rtl92de_read_chip_version(struct ieee80211_hw *hw)
> 	u32 value32;
> 
> 	value32 = rtl_read_dword(rtlpriv, REG_SYS_CFG);
>+	version |= CHIP_92D;
> 	if (!(value32 & 0x000f0000)) {
> 		version = VERSION_TEST_CHIP_92D_SINGLEPHY;
> 		RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "TEST CHIP!!!\n");
> 	} else {
>-		version = VERSION_NORMAL_CHIP_92D_SINGLEPHY;
>+		/*version = VERSION_NORMAL_CHIP_92D_SINGLEPHY;*/
>+		version |= NORMAL_CHIP;
> 		RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD, "Normal CHIP!!!\n");
> 	}
> 	return version;
>@@ -1714,11 +1764,58 @@ static void _rtl92de_read_macphymode_from_prom(struct ieee80211_hw *hw,
> 	}
> }
> 
>+void _rtl92de_read_macphymode(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
>+	u8 macphy_crvalue = 0;
>+
>+	macphy_crvalue = rtl_read_byte(rtlpriv, REG_MAC_PHY_CTRL_NORMAL);
>+
>+	RT_TRACE(rtlpriv, COMP_INIT, DBG_EMERG,
>+		 "MAC_PHY_CTRL Value %x\n", macphy_crvalue);
>+
>+	if ((macphy_crvalue & 0x03) == 0x03) {
>+		rtlhal->macphymode = DUALMAC_DUALPHY;
>+		RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
>+			 "MacPhyMode DUALMAC_DUALPHY\n");
>+	} else if ((macphy_crvalue & 0x03) == 0x01) {
>+		rtlhal->macphymode = DUALMAC_SINGLEPHY;
>+		RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
>+			 "MacPhyMode DUALMAC_SINGLEPHY\n");
>+	} else {
>+		rtlhal->macphymode = SINGLEMAC_SINGLEPHY;
>+		RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
>+			 "MacPhyMode SINGLEMAC_SINGLEPHY\n");
>+	}
>+}
>+
> static void _rtl92de_read_macphymode_and_bandtype(struct ieee80211_hw *hw,
> 						  u8 *content)
> {
>-	_rtl92de_read_macphymode_from_prom(hw, content);
>-	rtl92d_phy_config_macphymode(hw);
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	unsigned long flags = 0;
>+	/* must be true here, used for two macs */
>+	static bool glb_firstconfig = true;
>+
>+	if (rtlpriv->dm.supp_phymode_switch) {
>+		spin_lock_irqsave(&rtlpriv->glb_var->glb_list_lock, flags);
>+		if (glb_firstconfig) {
>+			spin_unlock_irqrestore(&rtlpriv->glb_var->glb_list_lock, flags);
>+			_rtl92de_read_macphymode_from_prom(hw, content);
>+			rtl92d_phy_config_macphymode(hw);
>+
>+			spin_lock_irqsave(&rtlpriv->glb_var->glb_list_lock, flags);
>+			glb_firstconfig = false;
>+			spin_unlock_irqrestore(&rtlpriv->glb_var->glb_list_lock, flags);
>+		} else {
>+			spin_unlock_irqrestore(&rtlpriv->glb_var->glb_list_lock, flags);
>+			_rtl92de_read_macphymode(hw);
>+		}
>+	} else {
>+		_rtl92de_read_macphymode_from_prom(hw, content);
>+		rtl92d_phy_config_macphymode(hw);
>+	}
> 	rtl92d_phy_config_macphymode_info(hw);
> }
> 
>@@ -1902,6 +1999,8 @@ static void rtl92de_update_hal_rate_table(struct ieee80211_hw *hw,
> 		ratr_value = sta->supp_rates[1] << 4;
> 	else
> 		ratr_value = sta->supp_rates[0];
>+	if (mac->opmode == NL80211_IFTYPE_ADHOC)
>+		ratr_value = 0xfff;
> 	ratr_value |= (sta->ht_cap.mcs.rx_mask[1] << 20 |
> 		       sta->ht_cap.mcs.rx_mask[0] << 12);
> 	switch (wirelessmode) {
>@@ -1995,6 +2094,8 @@ static void rtl92de_update_hal_rate_mask(struct ieee80211_hw *hw,
> 		ratr_bitmap = sta->supp_rates[1] << 4;
> 	else
> 		ratr_bitmap = sta->supp_rates[0];
>+	if (mac->opmode == NL80211_IFTYPE_ADHOC)
>+		ratr_bitmap = 0xfff;
> 	ratr_bitmap |= (sta->ht_cap.mcs.rx_mask[1] << 20 |
> 			sta->ht_cap.mcs.rx_mask[0] << 12);
> 	switch (wirelessmode) {
>@@ -2025,47 +2126,39 @@ static void rtl92de_update_hal_rate_mask(struct ieee80211_hw *hw,
> 			ratr_index = RATR_INX_WIRELESS_NGB;
> 		else
> 			ratr_index = RATR_INX_WIRELESS_NG;
>-		if (mimo_ps == IEEE80211_SMPS_STATIC) {
>-			if (rssi_level == 1)
>-				ratr_bitmap &= 0x00070000;
>-			else if (rssi_level == 2)
>-				ratr_bitmap &= 0x0007f000;
>-			else
>-				ratr_bitmap &= 0x0007f005;
>+		if (rtlphy->rf_type == RF_1T2R ||
>+		    rtlphy->rf_type == RF_1T1R ||
>+		    (mimo_ps == IEEE80211_SMPS_STATIC)) {
>+			if (curtxbw_40mhz) {
>+				if (rssi_level == 1)
>+					ratr_bitmap &= 0x000f0000;
>+				else if (rssi_level == 2)
>+					ratr_bitmap &= 0x000ff000;
>+				else
>+					ratr_bitmap &= 0x000ff015;
>+			} else {
>+				if (rssi_level == 1)
>+					ratr_bitmap &= 0x000f0000;
>+				else if (rssi_level == 2)
>+					ratr_bitmap &= 0x000ff000;
>+				else
>+					ratr_bitmap &= 0x000ff005;
>+			}
> 		} else {
>-			if (rtlphy->rf_type == RF_1T2R ||
>-			    rtlphy->rf_type == RF_1T1R) {
>-				if (curtxbw_40mhz) {
>-					if (rssi_level == 1)
>-						ratr_bitmap &= 0x000f0000;
>-					else if (rssi_level == 2)
>-						ratr_bitmap &= 0x000ff000;
>-					else
>-						ratr_bitmap &= 0x000ff015;
>-				} else {
>-					if (rssi_level == 1)
>-						ratr_bitmap &= 0x000f0000;
>-					else if (rssi_level == 2)
>-						ratr_bitmap &= 0x000ff000;
>-					else
>-						ratr_bitmap &= 0x000ff005;
>-				}
>+			if (curtxbw_40mhz) {
>+				if (rssi_level == 1)
>+					ratr_bitmap &= 0x0f0f0000;
>+				else if (rssi_level == 2)
>+					ratr_bitmap &= 0x0f0ff000;
>+				else
>+					ratr_bitmap &= 0x0f0ff015;
> 			} else {
>-				if (curtxbw_40mhz) {
>-					if (rssi_level == 1)
>-						ratr_bitmap &= 0x0f0f0000;
>-					else if (rssi_level == 2)
>-						ratr_bitmap &= 0x0f0ff000;
>-					else
>-						ratr_bitmap &= 0x0f0ff015;
>-				} else {
>-					if (rssi_level == 1)
>-						ratr_bitmap &= 0x0f0f0000;
>-					else if (rssi_level == 2)
>-						ratr_bitmap &= 0x0f0ff000;
>-					else
>-						ratr_bitmap &= 0x0f0ff005;
>-				}
>+				if (rssi_level == 1)
>+					ratr_bitmap &= 0x0f0f0000;
>+				else if (rssi_level == 2)
>+					ratr_bitmap &= 0x0f0ff000;
>+				else
>+					ratr_bitmap &= 0x0f0ff005;
> 			}
> 		}
> 		if ((curtxbw_40mhz && curshortgi_40mhz) ||
>@@ -2086,15 +2179,14 @@ static void rtl92de_update_hal_rate_mask(struct ieee80211_hw *hw,
> 			ratr_bitmap &= 0x0f0ff0ff;
> 		break;
> 	}
>+	sta_entry->ratr_index = ratr_index;
> 
> 	value[0] = (ratr_bitmap & 0x0fffffff) | (ratr_index << 28);
> 	value[1] = macid | (shortgi ? 0x20 : 0x00) | 0x80;
> 	RT_TRACE(rtlpriv, COMP_RATR, DBG_DMESG,
> 		 "ratr_bitmap :%x value0:%x value1:%x\n",
>-		 ratr_bitmap, value[0], value[1]);
>+		  ratr_bitmap, value[0], value[1]);
> 	rtl92d_fill_h2c_cmd(hw, H2C_RA_MASK, 5, (u8 *) value);
>-	if (macid != 0)
>-		sta_entry->ratr_index = ratr_index;
> }
> 
> void rtl92de_update_hal_rate_tbl(struct ieee80211_hw *hw,
>diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/phy.c b/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
>index c913572..e859d6a 100644
>--- a/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
>+++ b/drivers/net/wireless/rtlwifi/rtl8192de/phy.c
>@@ -30,6 +30,7 @@
> #include "../wifi.h"
> #include "../pci.h"
> #include "../ps.h"
>+#include "../base.h"
> #include "reg.h"
> #include "def.h"
> #include "phy.h"
>@@ -2387,7 +2388,7 @@ void rtl92d_phy_iq_calibrate(struct ieee80211_hw *hw)
> 	struct rtl_phy *rtlphy = &(rtlpriv->phy);
> 	struct rtl_hal *rtlhal = &(rtlpriv->rtlhal);
> 	long result[4][8];
>-	u8 i, final_candidate, indexforchannel;
>+	u8 i, final_candidate, index;
> 	bool patha_ok, pathb_ok;
> 	long rege94, rege9c, regea4, regeac, regeb4;
> 	long regebc, regec4, regecc, regtmp = 0;
>@@ -2494,17 +2495,17 @@ void rtl92d_phy_iq_calibrate(struct ieee80211_hw *hw)
> 						final_candidate, (regec4 == 0));
> 	}
> 	if (final_candidate != 0xFF) {
>-		indexforchannel = rtl92d_get_rightchnlplace_for_iqk(
>+		index = rtl92d_get_rightchnlplace_for_iqk(
> 				  rtlphy->current_channel);
> 
> 		for (i = 0; i < IQK_MATRIX_REG_NUM; i++)
>-			rtlphy->iqk_matrix_regsetting[indexforchannel].
>+			rtlphy->iqk_matrix_regsetting[index].
> 				value[0][i] = result[final_candidate][i];
>-		rtlphy->iqk_matrix_regsetting[indexforchannel].iqk_done =
>+		rtlphy->iqk_matrix_regsetting[index].iqk_done =
> 			true;
> 
> 		RT_TRACE(rtlpriv, COMP_SCAN | COMP_MLME, DBG_LOUD,
>-			 "IQK OK indexforchannel %d\n", indexforchannel);
>+			 "IQK OK index %d\n", index);
> 	}
> }
> 
>@@ -2513,46 +2514,46 @@ void rtl92d_phy_reload_iqk_setting(struct ieee80211_hw *hw, u8 channel)
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
> 	struct rtl_phy *rtlphy = &(rtlpriv->phy);
> 	struct rtl_hal *rtlhal = &(rtlpriv->rtlhal);
>-	u8 indexforchannel;
>+	u8 index;
> 
> 	RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD, "channel %d\n", channel);
> 	/*------Do IQK for normal chip and test chip 5G band------- */
>-	indexforchannel = rtl92d_get_rightchnlplace_for_iqk(channel);
>-	RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD, "indexforchannel %d done %d\n",
>-		 indexforchannel,
>-		 rtlphy->iqk_matrix_regsetting[indexforchannel].iqk_done);
>-	if (0 && !rtlphy->iqk_matrix_regsetting[indexforchannel].iqk_done &&
>+	index = rtl92d_get_rightchnlplace_for_iqk(channel);
>+	RT_TRACE(rtlpriv, COMP_CMD, DBG_LOUD, "index %d done %d\n",
>+		 index,
>+		 rtlphy->iqk_matrix_regsetting[index].iqk_done);
>+	if (0 && !rtlphy->iqk_matrix_regsetting[index].iqk_done &&
> 		rtlphy->need_iqk) {
> 		/* Re Do IQK. */
> 		RT_TRACE(rtlpriv, COMP_SCAN | COMP_INIT, DBG_LOUD,
> 			 "Do IQK Matrix reg for channel:%d....\n", channel);
> 		rtl92d_phy_iq_calibrate(hw);
>-	} else {
>+	} else if (!rtlphy->need_iqk) {
> 		/* Just load the value. */
> 		/* 2G band just load once. */
> 		if (((!rtlhal->load_imrandiqk_setting_for2g) &&
>-		    indexforchannel == 0) || indexforchannel > 0) {
>+		    index == 0) || index > 0) {
> 			RT_TRACE(rtlpriv, COMP_SCAN, DBG_LOUD,
> 				 "Just Read IQK Matrix reg for channel:%d....\n",
> 				 channel);
>-			if ((rtlphy->iqk_matrix_regsetting[indexforchannel].
>+			if ((rtlphy->iqk_matrix_regsetting[index].
> 			     value[0] != NULL)
> 				/*&&(regea4 != 0) */)
> 				_rtl92d_phy_patha_fill_iqk_matrix(hw, true,
> 					rtlphy->iqk_matrix_regsetting[
>-					indexforchannel].value,	0,
>+					index].value,	0,
> 					(rtlphy->iqk_matrix_regsetting[
>-					indexforchannel].value[0][2] == 0));
>+					index].value[0][2] == 0));
> 			if (IS_92D_SINGLEPHY(rtlhal->version)) {
> 				if ((rtlphy->iqk_matrix_regsetting[
>-					indexforchannel].value[0][4] != 0)
>+					index].value[0][4] != 0)
> 					/*&&(regec4 != 0) */)
> 					_rtl92d_phy_pathb_fill_iqk_matrix(hw,
> 						true,
> 						rtlphy->iqk_matrix_regsetting[
>-						indexforchannel].value, 0,
>+						index].value, 0,
> 						(rtlphy->iqk_matrix_regsetting[
>-						indexforchannel].value[0][6]
>+						index].value[0][6]
> 						== 0));
> 			}
> 		}
>@@ -2681,7 +2682,6 @@ static void _rtl92d_phy_lc_calibrate_sw(struct ieee80211_hw *hw, bool is2t)
> {
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
> 	struct rtl_hal *rtlhal = &(rtlpriv->rtlhal);
>-	struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
> 	u8 tmpreg, index, rf_mode[2];
> 	u8 path = is2t ? 2 : 1;
> 	u8 i;
>@@ -2705,7 +2705,7 @@ static void _rtl92d_phy_lc_calibrate_sw(struct ieee80211_hw *hw, bool is2t)
> 		/* 2. Set RF mode = standby mode */
> 		rtl_set_rfreg(hw, (enum radio_path)index, RF_AC,
> 			      BRFREGOFFSETMASK, 0x010000);
>-		if (rtlpci->init_ready) {
>+		if (!rtlpriv->rtlhal.being_init_adapter) {
> 			/* switch CV-curve control by LC-calibration */
> 			rtl_set_rfreg(hw, (enum radio_path)index, RF_SYN_G7,
> 				      BIT(17), 0x0);
>@@ -3341,6 +3341,8 @@ void rtl92d_phy_config_macphymode_info(struct ieee80211_hw *hw)
> 	struct rtl_priv *rtlpriv = rtl_priv(hw);
> 	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
> 	struct rtl_phy *rtlphy = &(rtlpriv->phy);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	unsigned long flags = 0;
> 
> 	switch (rtlhal->macphymode) {
> 	case DUALMAC_SINGLEPHY:
>@@ -3348,6 +3350,23 @@ void rtl92d_phy_config_macphymode_info(struct ieee80211_hw *hw)
> 		rtlhal->version |= RF_TYPE_2T2R;
> 		rtlhal->bandset = BAND_ON_BOTH;
> 		rtlhal->current_bandtype = BAND_ON_2_4G;
>+		if (rtlpriv->dm.supp_phymode_switch) {
>+			spin_lock_irqsave(&rtlpriv->glb_var->glb_list_lock, flags);
>+			if (buddy_priv != NULL) {
>+				rtlhal->master_of_dmsp = !buddy_priv->rtlhal.master_of_dmsp;
>+				rtlhal->slave_of_dmsp = !buddy_priv->rtlhal.slave_of_dmsp;
>+				rtlhal->current_bandtype = buddy_priv->rtlhal.current_bandtype;
>+			} else {
>+				if (rtlhal->interfaceindex == 0) {
>+					rtlhal->master_of_dmsp = true;
>+					rtlhal->slave_of_dmsp = false;
>+				} else if (rtlhal->interfaceindex == 1) {
>+					rtlhal->master_of_dmsp = false;
>+					rtlhal->slave_of_dmsp = true;
>+				}
>+			}
>+			spin_unlock_irqrestore(&rtlpriv->glb_var->glb_list_lock, flags);
>+		}
> 		break;
> 
> 	case SINGLEMAC_SINGLEPHY:
>@@ -3355,6 +3374,10 @@ void rtl92d_phy_config_macphymode_info(struct ieee80211_hw *hw)
> 		rtlhal->version |= RF_TYPE_2T2R;
> 		rtlhal->bandset = BAND_ON_BOTH;
> 		rtlhal->current_bandtype = BAND_ON_2_4G;
>+		if (rtlpriv->dm.supp_phymode_switch) {
>+			rtlhal->master_of_dmsp = false;
>+			rtlhal->slave_of_dmsp = false;
>+		}
> 		break;
> 
> 	case DUALMAC_DUALPHY:
>@@ -3368,10 +3391,16 @@ void rtl92d_phy_config_macphymode_info(struct ieee80211_hw *hw)
> 			rtlhal->bandset = BAND_ON_2_4G;
> 			rtlhal->current_bandtype = BAND_ON_2_4G;
> 		}
>+		if (rtlpriv->dm.supp_phymode_switch) {
>+			rtlhal->master_of_dmsp = false;
>+			rtlhal->slave_of_dmsp = false;
>+		}
> 		break;
> 	default:
> 		break;
> 	}
>+	rtlpriv->easy_concurrent_ctl.currentbandtype_backfordmdp =
>+				 rtlhal->current_bandtype;
> }
> 
> u8 rtl92d_get_chnlgroup_fromarray(u8 chnl)
>@@ -3712,3 +3741,478 @@ bool rtl92d_phy_check_poweroff(struct ieee80211_hw *hw)
> 	spin_unlock_irqrestore(&globalmutex_power, flags);
> 	return true;
> }
>+
>+void _rtl92d_phy_update_bbrf_for_easyconcurrent(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
>+	u32 bbregvalue = 0;
>+	u32 bitmask = 0;
>+	u16 reg_value;
>+
>+	if (rtlhal->interfaceindex == 1) {
>+		if (rtlpriv->rtlhal.current_bandtype == BAND_ON_2_4G) {
>+			bitmask |= BIT(24) | BIT(25);
>+			bbregvalue = 0x00;
>+			/* clear 0x800 BIT24 and BIT 25 */
>+			rtl_set_bbreg(hw, RFPGA0_RFMOD, bitmask, bbregvalue);
>+			_rtl92d_phy_config_bb_with_headerfile(hw, BASEBAND_CONFIG_AGC_TAB);
>+			bitmask |= BIT(24) | BIT(25);
>+			bbregvalue = 0x3;
>+			/* clear 0x800 BIT24 and BIT 25 */
>+			rtl_set_bbreg(hw, RFPGA0_RFMOD, bitmask, bbregvalue);
>+		} else if (rtlpriv->rtlhal.current_bandtype == BAND_ON_5G) {
>+			bitmask |= BIT(24) | BIT(25);
>+			bbregvalue = 0x00;
>+			rtl_set_bbreg(hw, RFPGA0_RFMOD, bitmask, bbregvalue);
>+			_rtl92d_phy_config_bb_with_headerfile(hw, BASEBAND_CONFIG_AGC_TAB);
>+
>+			bitmask |= BIT(24) | BIT(25);
>+			bbregvalue = 0x3;
>+			/* clear 0x800 BIT24 and BIT 25 */
>+			rtl_set_bbreg(hw, RFPGA0_RFMOD, bitmask, bbregvalue);
>+		} else {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				"UnKnown BandType\n");
>+		}
>+	}
>+
>+	rtl92d_update_bbrf_configuration(hw);
>+
>+	if (!rtlpriv->rtlhal.slave_of_dmsp) {
>+		reg_value = rtl_read_word(rtlpriv, REG_SYS_FUNC_EN);
>+		reg_value &= 0xFFFE;
>+		rtl_write_word(rtlpriv, REG_SYS_FUNC_EN, reg_value);
>+		reg_value |= 0x0001;
>+		rtl_write_word(rtlpriv, REG_SYS_FUNC_EN, reg_value);
>+	}
>+}
>+
>+void rtl92d_dualmac_easyconcurrent_bbrfreconfig(struct ieee80211_hw *hw,
>+						bool bchange_to_dmsp,
>+						bool bchange_to_dmdp)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+
>+	if (bchange_to_dmdp) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"change to DMDP\n");
>+		rtlhal->macphymode = DUALMAC_DUALPHY;
>+		if ((rtlhal->interfaceindex == 0) &&
>+			(rtlpriv->easy_concurrent_ctl.close_bbandrf_for_dmsp)) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				"close BB/RF  MAC 0\n");
>+			_rtl92d_phy_stop_trx_before_changeband(hw);
>+			rtlpriv->easy_concurrent_ctl.close_bbandrf_for_dmsp = false;
>+		} else if ((rtlhal->interfaceindex == 1) &&
>+			(buddy_priv->easy_concurrent_ctl.close_bbandrf_for_dmsp)) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				"close BB/RF MAC 1\n");
>+			_rtl92d_phy_stop_trx_before_changeband(buddy_priv->mac80211.hw);
>+			buddy_priv->easy_concurrent_ctl.close_bbandrf_for_dmsp = false;
>+		}
>+
>+		rtl_write_byte(rtlpriv, REG_MAC_PHY_CTRL_NORMAL, 0xF3);
>+		rtl_write_byte(rtlpriv, REG_DMC, 0x00);
>+
>+		rtlpriv->phy.num_total_rfpath = 1;
>+		rtlpriv->rtlhal.current_bandtype = rtlpriv->easy_concurrent_ctl.currentbandtype_backfordmdp;
>+		rtlpriv->rtlhal.bandset = rtlpriv->rtlhal.current_bandtype;
>+		rtlpriv->phy.rf_type = RF_1T1R;
>+		rtlpriv->rtlhal.version &= RF_TYPE_1T1R;
>+		rtlpriv->rtlhal.master_of_dmsp = false;
>+		rtlpriv->rtlhal.slave_of_dmsp  = false;
>+
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			"interface index  %d\n", rtlhal->interfaceindex);
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			"rtlpriv->rtlhal.current_bandtype  %d\n",
>+			rtlpriv->rtlhal.current_bandtype);
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			"rtlpriv->rtlhal.bandset %d\n", rtlpriv->rtlhal.bandset);
>+
>+		_rtl92d_phy_update_bbrf_for_easyconcurrent(hw);
>+
>+		if (rtlpriv->rtlhal.current_bandtype == BAND_ON_2_4G)
>+			rtl_set_bbreg(hw, RFPGA0_RFMOD, BCCKEN, 0x1);
>+		rtl_set_bbreg(hw, RFPGA0_RFMOD, BOFDMEN, 0x1);
>+		/* STA and STA */
>+		if (rtlpriv->mac80211.link_state != MAC80211_LINKED) {
>+			if (rtlpriv->rtlhal.current_bandtype == BAND_ON_2_4G) {
>+				rtlpriv->mac80211.mode = WIRELESS_MODE_N_24G;
>+				rtlpriv->phy.current_channel = 1;
>+				rtlpriv->phy.current_chan_bw = 0;
>+			} else {
>+				rtlpriv->mac80211.mode = WIRELESS_MODE_N_5G;
>+				rtlpriv->phy.current_channel = 36;
>+				rtlpriv->phy.current_chan_bw = 0;
>+			}
>+		}
>+	} else if (bchange_to_dmsp) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"change to DMSP\n");
>+		if (rtlhal->interfaceindex == 0) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				"MAC 0 Master\n");
>+			_rtl92d_phy_stop_trx_before_changeband(rtlpriv->mac80211.hw);
>+			_rtl92d_phy_stop_trx_before_changeband(buddy_priv->mac80211.hw);
>+			rtlpriv->rtlhal.macphymode = DUALMAC_SINGLEPHY;
>+
>+			rtl_write_byte(rtlpriv, REG_MAC_PHY_CTRL_NORMAL, 0xF1);
>+
>+			rtl_write_byte(rtlpriv, REG_DMC, 0xf8);
>+			rtl_write_byte(buddy_priv, REG_DMC, 0xf8);
>+			rtlpriv->phy.num_total_rfpath = 2;
>+			if ((buddy_priv->mac80211.opmode != NL80211_IFTYPE_AP) &&
>+				(rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP)) {
>+				if (rtlpriv->mac80211.link_state >= MAC80211_LINKED) {
>+					rtlpriv->rtlhal.current_bandtype =
>+						rtlpriv->easy_concurrent_ctl.
>+							currentbandtype_backfordmdp;
>+				} else if (buddy_priv->mac80211.link_state >= MAC80211_LINKED) {
>+					rtlpriv->rtlhal.current_bandtype =
>+						buddy_priv->easy_concurrent_ctl.
>+							currentbandtype_backfordmdp;
>+				} else {
>+					rtlpriv->rtlhal.current_bandtype =
>+						rtlpriv->easy_concurrent_ctl.
>+							currentbandtype_backfordmdp;
>+				}
>+			} else if ((buddy_priv->mac80211.opmode == NL80211_IFTYPE_AP) &&
>+				(rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP)) {
>+				if (rtlpriv->mac80211.link_state != MAC80211_LINKED)
>+					rtlpriv->rtlhal.current_bandtype =
>+						buddy_priv->easy_concurrent_ctl.
>+							currentbandtype_backfordmdp;
>+			} else if ((buddy_priv->mac80211.opmode != NL80211_IFTYPE_AP) &&
>+				(rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP)) {
>+				if (buddy_priv->mac80211.link_state != MAC80211_LINKED)
>+					rtlpriv->rtlhal.current_bandtype =
>+						rtlpriv->easy_concurrent_ctl.
>+							currentbandtype_backfordmdp;
>+			} else {
>+				rtlpriv->rtlhal.current_bandtype =
>+						rtlpriv->easy_concurrent_ctl.
>+							currentbandtype_backfordmdp;
>+			}
>+			rtlpriv->rtlhal.bandset = BAND_ON_BOTH;
>+			rtlpriv->phy.rf_type  = RF_2T2R;
>+			rtlpriv->rtlhal.version |= RF_TYPE_2T2R;
>+			rtlpriv->rtlhal.master_of_dmsp = true;
>+			rtlpriv->rtlhal.slave_of_dmsp  = false;
>+
>+			buddy_priv->rtlhal.macphymode = DUALMAC_SINGLEPHY;
>+			buddy_priv->phy.num_total_rfpath = 2;
>+			buddy_priv->rtlhal.current_bandtype = rtlpriv->rtlhal.current_bandtype;
>+			buddy_priv->rtlhal.bandset = BAND_ON_BOTH;
>+			buddy_priv->rtlhal.version |= RF_TYPE_2T2R;
>+			buddy_priv->phy.rf_type = RF_2T2R;
>+			buddy_priv->rtlhal.master_of_dmsp = false;
>+			buddy_priv->rtlhal.slave_of_dmsp  = true;
>+
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				"rtlpriv->rtlhal.current_bandtype  %d\n",
>+				rtlpriv->rtlhal.current_bandtype);
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				"rtlpriv->rtlhal.bandset %d\n", rtlpriv->rtlhal.bandset);
>+
>+			_rtl92d_phy_update_bbrf_for_easyconcurrent(hw);
>+
>+			if (rtlpriv->rtlhal.current_bandtype == BAND_ON_2_4G)
>+				rtl_set_bbreg(hw, RFPGA0_RFMOD, BCCKEN, 0x1);
>+			rtl_set_bbreg(hw, RFPGA0_RFMOD, BOFDMEN, 0x1);
>+		}
>+	} else {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			"Do Nothing\n");
>+	}
>+}
>+
>+void _rtl92d_dualmac_reconfig_mgntinfo_forselfmac(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_phy *rtlphy = &(rtlpriv->phy);
>+	struct rtl_mac *mac = &(rtlpriv->mac80211);
>+	struct ieee80211_sta *sta = NULL;
>+	u8 index;
>+
>+	for (index = 0; index < 46; index++)
>+			rtlphy->iqk_matrix_regsetting[index].iqk_done = false;
>+
>+	if (rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP) {
>+		if (rtlpriv->mac80211.link_state >= MAC80211_LINKED) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				"STA  Connect Case\n");
>+			/* set BandWidth */
>+			rtl92d_phy_reset_iqk_result(hw);
>+			rtlphy->need_iqk = true;
>+			rtlpriv->cfg->ops->switch_channel(hw);
>+			rtl92d_linked_set_reg(hw);
>+			rtlpriv->cfg->ops->set_channel_access(hw);
>+			rtlpriv->cfg->ops->set_bw_mode(hw, hw->conf.channel_type);
>+			rcu_read_lock();
>+			sta = rtl_find_sta(hw, mac->bssid);
>+			rtlpriv->cfg->ops->update_rate_tbl(hw, sta, 0);
>+			rcu_read_unlock();
>+			rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SHORTGI_DENSITY,
>+					(u8 *) (&rtlpriv->mac80211.max_mss_density));
>+			rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_AMPDU_FACTOR,
>+					&rtlpriv->mac80211.current_ampdu_factor);
>+			rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_AMPDU_MIN_SPACE,
>+					&rtlpriv->mac80211.current_ampdu_density);
>+			rtlpriv->cfg->ops->set_network_type(hw, rtlpriv->mac80211.vif->type);
>+			rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_SLOT_TIME,
>+					      (u8 *) (&rtlpriv->mac80211.slot_time));
>+		} else {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				"STA change to DMDP DisConnect Case\n");
>+			rtlphy->need_iqk = true;
>+			rtlpriv->cfg->ops->switch_channel(hw);
>+			rtlpriv->cfg->ops->set_channel_access(hw);
>+			rtlpriv->cfg->ops->set_bw_mode(hw,
>+				hw->conf.channel_type);
>+		}
>+	} else {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			"AP Case\n");
>+	}
>+
>+}
>+
>+void _rtl92d_dualmac_reconfig_mgntinfo_foranothermac(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_phy *rtlphy = &(rtlpriv->phy);
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	struct ieee80211_hw *buddy_hw = buddy_priv->mac80211.hw;
>+	struct rtl_mac *buddy_mac = &(buddy_priv->mac80211);
>+	struct ieee80211_sta *sta = NULL;
>+	u8 index;
>+
>+	for (index = 0; index < 46; index++)
>+		rtlphy->iqk_matrix_regsetting[index].iqk_done = false;
>+
>+	if (buddy_priv->mac80211.opmode != NL80211_IFTYPE_AP) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"buddy adapter sta case\n");
>+		rtl92d_phy_reset_iqk_result(hw);
>+		rtlphy->need_iqk = true;
>+		rtlpriv->rtlhal.load_imrandiqk_setting_for2g = false;
>+		rtlphy->current_channel = buddy_priv->phy.current_channel;
>+		rtlphy->current_chan_bw = buddy_priv->phy.current_chan_bw;
>+		rtlpriv->mac80211.cur_40_prime_sc =
>+			 buddy_priv->mac80211.cur_40_prime_sc;
>+		rtlpriv->cfg->ops->switch_channel(hw);
>+		rtl92d_linked_set_reg(hw);
>+		rtlpriv->cfg->ops->set_channel_access(hw);
>+		rtlpriv->cfg->ops->set_bw_mode(hw,
>+				buddy_hw->conf.channel_type);
>+		rcu_read_lock();
>+		sta = rtl_find_sta(buddy_mac->hw, buddy_mac->bssid);
>+		buddy_priv->cfg->ops->update_rate_tbl(buddy_hw, sta, 0);
>+		rcu_read_unlock();
>+		buddy_priv->cfg->ops->set_hw_reg(buddy_hw, HW_VAR_SHORTGI_DENSITY,
>+				(u8 *) (&buddy_priv->mac80211.max_mss_density));
>+		buddy_priv->cfg->ops->set_hw_reg(buddy_hw, HW_VAR_AMPDU_FACTOR,
>+				&buddy_priv->mac80211.current_ampdu_factor);
>+		buddy_priv->cfg->ops->set_hw_reg(buddy_hw, HW_VAR_AMPDU_MIN_SPACE,
>+				&buddy_priv->mac80211.current_ampdu_density);
>+		buddy_priv->cfg->ops->set_network_type(buddy_hw,
>+				buddy_priv->mac80211.vif->type);
>+		pr_info("***** %s():slot_time is %d\n", __func__,
>+			buddy_priv->mac80211.slot_time);
>+		buddy_priv->cfg->ops->set_hw_reg(buddy_hw, HW_VAR_SLOT_TIME,
>+				(u8 *) (&buddy_priv->mac80211.slot_time));
>+	} else {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+			"buddy adapter AP case\n");
>+	}
>+}
>+
>+void rtl_dualmac_easyconcurrent(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+
>+	if (!rtlpriv->dm.supp_phymode_switch)
>+		return;
>+
>+	if (buddy_priv == NULL)
>+		return;
>+
>+	if (rtlpriv->rtlhal.interfaceindex == 0) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"MAC 0\n");
>+	} else {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"MAC 1\n");
>+	}
>+
>+	if (rtlpriv->easy_concurrent_ctl.switch_in_process) {
>+		mod_timer(&rtlpriv->works.dualmac_easyconcurrent_retrytimer,
>+			jiffies + MSECS(100));
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"Another Workitem has been done\n");
>+		return;
>+	}
>+
>+	if (rtlpriv->easy_concurrent_ctl.change_to_dmsp &&
>+		(rtlpriv->mac80211.act_scanning ||
>+		buddy_priv->mac80211.act_scanning)) {
>+		mod_timer(&rtlpriv->works.dualmac_easyconcurrent_retrytimer,
>+			jiffies + MSECS(100));
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"Scan in progress, do it later\n");
>+		return;
>+	}
>+
>+	RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+		"STA change MacPhyMode\n");
>+	if (rtlpriv->easy_concurrent_ctl.change_to_dmdp) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"STA change to DMDP\n");
>+		rtlpriv->easy_concurrent_ctl.switch_in_process = true;
>+		rtl92d_dualmac_easyconcurrent_bbrfreconfig(hw, false, true);
>+		rtlpriv->easy_concurrent_ctl.change_to_dmdp = false;
>+		_rtl92d_dualmac_reconfig_mgntinfo_forselfmac(hw);
>+		rtlpriv->easy_concurrent_ctl.switch_in_process = false;
>+	} else if (rtlpriv->easy_concurrent_ctl.change_to_dmsp) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"STA change to DMSP\n");
>+		rtlpriv->easy_concurrent_ctl.switch_in_process = true;
>+		rtl92d_dualmac_easyconcurrent_bbrfreconfig(hw, true, false);
>+		rtlpriv->easy_concurrent_ctl.change_to_dmsp = false;
>+
>+		if (rtlhal->master_of_dmsp) {
>+			if ((rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP) &&
>+			    (buddy_priv->mac80211.opmode != NL80211_IFTYPE_AP)) {
>+				/* MAC0 and MAC1 all STA */
>+				if ((rtlpriv->mac80211.link_state >= MAC80211_LINKED) &&
>+				   (buddy_priv->mac80211.link_state != MAC80211_LINKED)) {
>+					_rtl92d_dualmac_reconfig_mgntinfo_forselfmac(hw);
>+				} else if ((rtlpriv->mac80211.link_state != MAC80211_LINKED) &&
>+					  (buddy_priv->mac80211.link_state >= MAC80211_LINKED)) {
>+					_rtl92d_dualmac_reconfig_mgntinfo_foranothermac(hw);
>+				} else {
>+					RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+						"dmsp MAC 0 and MAC 1 disconnect or connect\n");
>+				}
>+			} else if ((rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP) &&
>+				   (buddy_priv->mac80211.opmode == NL80211_IFTYPE_AP)) {
>+				/* MAC0  STA and MAC1 AP */
>+				_rtl92d_dualmac_reconfig_mgntinfo_foranothermac(hw);
>+			} else if ((rtlpriv->mac80211.opmode == NL80211_IFTYPE_AP) &&
>+				   (buddy_priv->mac80211.opmode != NL80211_IFTYPE_AP)) {
>+				/* MAC0  AP and MAC1 STA */
>+				if (buddy_priv->mac80211.link_state != MAC80211_LINKED)
>+					_rtl92d_dualmac_reconfig_mgntinfo_foranothermac(hw);
>+			}
>+		}
>+		rtlpriv->easy_concurrent_ctl.switch_in_process = false;
>+	} else {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"STA No Change MacPhyMode\n");
>+		if (rtlhal->macphymode == DUALMAC_DUALPHY) {
>+			_rtl92d_dualmac_reconfig_mgntinfo_forselfmac(hw);
>+		} else if (rtlhal->macphymode == DUALMAC_SINGLEPHY) {
>+			if (rtlhal->master_of_dmsp) {
>+				if ((rtlpriv->mac80211.link_state >= MAC80211_LINKED) &&
>+				   (buddy_priv->mac80211.link_state != MAC80211_LINKED)) {
>+					_rtl92d_dualmac_reconfig_mgntinfo_forselfmac(hw);
>+				} else if ((rtlpriv->mac80211.link_state != MAC80211_LINKED) &&
>+					  (buddy_priv->mac80211.link_state >= MAC80211_LINKED)) {
>+					_rtl92d_dualmac_reconfig_mgntinfo_foranothermac(hw);
>+				} else {
>+					RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+					"dmsp MAC 0 and MAC 1 disconnect or connect\n");
>+				}
>+			}
>+		}
>+	}
>+}
>+
>+void rtl92d_easy_concurrent_switch_to_dmdp(struct ieee80211_hw *hw)
>+{
>+	struct rtl_priv *rtlpriv = rtl_priv(hw);
>+	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
>+	struct ieee80211_sta *sta = NULL;
>+	struct rtl_sta_info *sta_entry = NULL;
>+	struct rtl_priv *buddy_priv = rtlpriv->buddy_priv;
>+	struct ieee80211_hw *buddy_hw = NULL;
>+	u8 new_mimops_mode = IEEE80211_SMPS_STATIC;
>+	unsigned long flags = 0;
>+
>+	if (!rtlpriv->dm.supp_phymode_switch)
>+		return;
>+
>+	if (buddy_priv == NULL) {
>+		RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+			"Buddy is Null Error Case\n");
>+	} else {
>+		spin_lock_irqsave(&rtlpriv->locks.check_sendpkt_lock, flags);
>+		buddy_hw = buddy_priv->mac80211.hw;
>+		if ((buddy_priv->mac80211.opmode != NL80211_IFTYPE_AP &&
>+			buddy_priv->mac80211.link_state >= MAC80211_LINKED) ||
>+			(rtlpriv->mac80211.opmode != NL80211_IFTYPE_AP &&
>+			rtlpriv->mac80211.link_state >= MAC80211_LINKED)) {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+				"one iface is connected, rtlhal->macphymode is %d\n",
>+				rtlhal->macphymode);
>+			if (rtlhal->macphymode == DUALMAC_SINGLEPHY) {
>+				rcu_read_lock();
>+				if (buddy_priv->mac80211.link_state >= MAC80211_LINKED)
>+					sta = rtl_find_sta(buddy_hw, buddy_priv->mac80211.bssid);
>+				else if (rtlpriv->mac80211.link_state >= MAC80211_LINKED)
>+					sta = rtl_find_sta(hw, rtlpriv->mac80211.bssid);
>+				if (sta) {
>+					sta_entry = (struct rtl_sta_info *) sta->drv_priv;
>+					sta_entry->mimo_ps = IEEE80211_SMPS_STATIC;
>+				}
>+				new_mimops_mode = IEEE80211_SMPS_STATIC;
>+				if (sta->ht_cap.ht_supported) {
>+					if (buddy_priv->mac80211.link_state >= MAC80211_LINKED) {
>+						RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+							 "send SMPS_STATIC pkt\n");
>+						rtl_send_smps_action(buddy_hw,
>+								sta, new_mimops_mode);
>+					} else if (rtlpriv->mac80211.link_state >= MAC80211_LINKED) {
>+						RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_EMERG,
>+							 "send SMPS_STATIC pkt\n");
>+						rtl_send_smps_action(hw,
>+								sta, new_mimops_mode);
>+					}
>+				}
>+				rcu_read_unlock();
>+
>+				rtlpriv->easy_concurrent_ctl.change_to_dmdp = true;
>+				buddy_priv->easy_concurrent_ctl.change_to_dmdp = true;
>+
>+				if (rtlpriv->rtlhal.interfaceindex == 0)
>+					rtlpriv->easy_concurrent_ctl.close_bbandrf_for_dmsp
>+						= true;
>+				else
>+					buddy_priv->easy_concurrent_ctl.close_bbandrf_for_dmsp
>+						= true;
>+
>+				if (buddy_priv->mac80211.link_state >=
>+				    MAC80211_LINKED) {
>+					rtl_dualmac_easyconcurrent(buddy_priv->mac80211.hw);
>+					rtl_dualmac_easyconcurrent(hw);
>+				} else if (rtlpriv->mac80211.link_state >=
>+					   MAC80211_LINKED) {
>+					rtl_dualmac_easyconcurrent(hw);
>+					rtl_dualmac_easyconcurrent(buddy_priv->mac80211.hw);
>+				}
>+			}
>+		} else {
>+			RT_TRACE(rtlpriv, COMP_EASY_CONCURRENT, DBG_LOUD,
>+				 "Buddy is AP case or buddy is not linked\n");
>+		}
>+		spin_unlock_irqrestore(&rtlpriv->locks.check_sendpkt_lock,
>+				       flags);
>+	}
>+}
>+
>diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/phy.h b/drivers/net/wireless/rtlwifi/rtl8192de/phy.h
>index 6c1deba..579f2b9 100644
>--- a/drivers/net/wireless/rtlwifi/rtl8192de/phy.h
>+++ b/drivers/net/wireless/rtlwifi/rtl8192de/phy.h
>@@ -173,5 +173,7 @@ void rtl92d_acquire_cckandrw_pagea_ctl(struct ieee80211_hw *hw,
> u8 rtl92d_get_rightchnlplace_for_iqk(u8 chnl);
> void rtl92d_phy_reload_iqk_setting(struct ieee80211_hw *hw, u8 channel);
> void rtl92d_phy_iq_calibrate(struct ieee80211_hw *hw);
>+void rtl92d_easy_concurrent_switch_to_dmdp(struct ieee80211_hw *hw);
>+void rtl_dualmac_easyconcurrent(struct ieee80211_hw *hw);
> 
> #endif
>diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/reg.h b/drivers/net/wireless/rtlwifi/rtl8192de/reg.h
>index ebb1d5f..ca3fb60 100644
>--- a/drivers/net/wireless/rtlwifi/rtl8192de/reg.h
>+++ b/drivers/net/wireless/rtlwifi/rtl8192de/reg.h
>@@ -570,7 +570,8 @@
> /* ----------------------------------------------------- */
> #define	HWSET_MAX_SIZE			256
> #define EFUSE_MAX_SECTION		32
>-#define EFUSE_REAL_CONTENT_LEN		512
>+#define EFUSE_REAL_CONTENT_LEN		1024
>+#define EFUSE_OOB_PROTECT_BYTES		18
> 
> /* ----------------------------------------------------- */
> /*     8192C EEPROM/EFUSE share register definition. */
>diff --git a/drivers/net/wireless/rtlwifi/rtl8192de/sw.c b/drivers/net/wireless/rtlwifi/rtl8192de/sw.c
>index 480862c..744239f 100644
>--- a/drivers/net/wireless/rtlwifi/rtl8192de/sw.c
>+++ b/drivers/net/wireless/rtlwifi/rtl8192de/sw.c
>@@ -106,8 +106,7 @@ static int rtl92d_init_sw_vars(struct ieee80211_hw *hw)
> 
> 	if (rtlpriv->rtlhal.macphymode != SINGLEMAC_SINGLEPHY) {
> 		rtlpriv->rtlhal.disable_amsdu_8k = true;
>-		/* No long RX - reduce fragmentation */
>-		rtlpci->rxbuffersize = 4096;
>+		rtlpriv->dm.supp_phymode_switch = false;
> 	}
> 
> 	rtlpci->transmit_config = CFENDFORM | BIT(12) | BIT(13);
>@@ -250,6 +249,8 @@ static struct rtl_hal_ops rtl8192de_hal_ops = {
> 	.get_rfreg = rtl92d_phy_query_rf_reg,
> 	.set_rfreg = rtl92d_phy_set_rf_reg,
> 	.linked_set_reg = rtl92d_linked_set_reg,
>+	.check_switch_to_dmdp = rtl92d_easy_concurrent_switch_to_dmdp,
>+	.dualmac_easy_concurrent = rtl_dualmac_easyconcurrent,
> };
> 
> static struct rtl_mod_params rtl92de_mod_params = {
>@@ -288,6 +289,7 @@ static struct rtl_hal_cfg rtl92de_hal_cfg = {
> 	.maps[EFUSE_HWSET_MAX_SIZE] = HWSET_MAX_SIZE,
> 	.maps[EFUSE_MAX_SECTION_MAP] = EFUSE_MAX_SECTION,
> 	.maps[EFUSE_REAL_CONTENT_SIZE] = EFUSE_REAL_CONTENT_LEN,
>+	.maps[EFUSE_OOB_PROTECT_BYTES_LEN] = EFUSE_OOB_PROTECT_BYTES,
> 
> 	.maps[RWCAM] = REG_CAMCMD,
> 	.maps[WCAMI] = REG_CAMWRITE,
>-- 
>1.7.10.4
>

Actions: View | Diff

Attachments on bug 797709: 565954 | 592503 | 593847 | 593848 | 597390 | 597641 | 598918 | 598919 | 598920 | 598921 | 598922 | 598924