drivers/net/wireless/rockchip_wlan/rtl8723cs/hal/hal_mcc.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2015 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  ******************************************************************************/
  19 #ifdef CONFIG_MCC_MODE
  20 #define _HAL_MCC_C_
  21
  22 #include <drv_types.h> /* PADAPTER */
  23 #include <rtw_mcc.h> /* mcc structure */
  24 #include <hal_data.h> /* HAL_DATA */
  25 #include <rtw_pwrctrl.h> /* power control */
  26
  27 #define MCC_DURATION_IDX 0
  28 #define MCC_TSF_SYNC_OFFSET_IDX 1
  29 #define MCC_START_TIME_OFFSET_IDX 2
  30 #define MCC_INTERVAL_IDX 3
  31 #define MCC_GUARD_OFFSET0_IDX 4
  32 #define MCC_GUARD_OFFSET1_IDX 5
  33 #define TU 1024 /* 1 TU equals 1024 microseconds */
  34 /* port 1 druration, TSF sync offset, start time offset, interval (unit:TU (1024 microseconds))*/
  35 u8 mcc_switch_channel_policy_table[][6]={
  36         {35, 50, 30, 100, 0, 0},
  37         {19, 50, 40, 100, 2, 2},
  38         {25, 50, 30, 100, 5, 5},
  39 };
  40
  41 const int mcc_max_policy_num = sizeof(mcc_switch_channel_policy_table) /sizeof(u8) /6;
  42
  43 static void dump_iqk_val_table(PADAPTER padapter)
  44 {
  45         HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
  46         struct hal_iqk_reg_backup *iqk_reg_backup = pHalData->iqk_reg_backup;
  47         u8 total_rf_path = pHalData->NumTotalRFPath;
  48         u8 rf_path_idx = 0;
  49         u8 backup_chan_idx = 0;
  50         u8 backup_reg_idx = 0;
  51
  52         RTW_INFO("=============dump IQK backup table================\n");
  53         for (backup_chan_idx = 0; backup_chan_idx < MAX_IQK_INFO_BACKUP_CHNL_NUM; backup_chan_idx++) {
  54                 for (rf_path_idx = 0; rf_path_idx < total_rf_path; rf_path_idx++) {
  55                         for(backup_reg_idx = 0; backup_reg_idx < MAX_IQK_INFO_BACKUP_REG_NUM; backup_reg_idx++) {
  56                                 RTW_INFO("ch:%d. bw:%d. rf path:%d. reg[%d] = 0x%02x \n"
  57                                                 , iqk_reg_backup[backup_chan_idx].central_chnl
  58                                                 , iqk_reg_backup[backup_chan_idx].bw_mode
  59                                                 , rf_path_idx
  60                                                 , backup_reg_idx
  61                                                 , iqk_reg_backup[backup_chan_idx].reg_backup[rf_path_idx][backup_reg_idx]
  62                                                 );
  63                         }
  64                 }
  65         }
  66         RTW_INFO("=============================================\n");
  67 }
  68
  69 static void rtw_hal_mcc_build_p2p_noa_attr(PADAPTER padapter, u8 *ie, u32 *ie_len)
  70 {
  71         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
  72         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
  73         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
  74         u8 p2p_noa_attr_ie[MAX_P2P_IE_LEN] = {0x00};
  75         u32 p2p_noa_attr_len = 0;
  76         u8 noa_desc_num = 1;
  77         u8 opp_ps = 0; /* Disable OppPS */
  78         u8 noa_count = 255;
  79         u32 noa_duration = 0x20;
  80         u32 noa_interval = 0x64;
  81         u8 noa_index = 0;
  82         u8 mcc_policy_idx = 0;
  83
  84         mcc_policy_idx = pmccobjpriv->policy_index;
  85         noa_duration = mcc_switch_channel_policy_table[mcc_policy_idx][MCC_DURATION_IDX];
  86         noa_interval = mcc_switch_channel_policy_table[mcc_policy_idx][MCC_INTERVAL_IDX];
  87
  88         /* P2P OUI(4 bytes) */
  89         _rtw_memcpy(p2p_noa_attr_ie, P2P_OUI, 4);
  90         p2p_noa_attr_len = p2p_noa_attr_len + 4;
  91
  92         /* attrute ID(1 byte) */
  93         p2p_noa_attr_ie[p2p_noa_attr_len] = P2P_ATTR_NOA;
  94         p2p_noa_attr_len = p2p_noa_attr_len + 1;
  95
  96         /* attrute length(2 bytes) length = noa_desc_num*13 + 2 */
  97         RTW_PUT_LE16(p2p_noa_attr_ie + p2p_noa_attr_len, (noa_desc_num*13 + 2));
  98         p2p_noa_attr_len = p2p_noa_attr_len + 2;
  99
 100         /* Index (1 byte) */
 101         p2p_noa_attr_ie[p2p_noa_attr_len] = noa_index;
 102         p2p_noa_attr_len = p2p_noa_attr_len + 1;
 103
 104         /* CTWindow and OppPS Parameters (1 byte) */
 105         p2p_noa_attr_ie[p2p_noa_attr_len] = opp_ps;
 106         p2p_noa_attr_len = p2p_noa_attr_len+ 1;
 107
 108         /* NoA Count (1 byte) */
 109         p2p_noa_attr_ie[p2p_noa_attr_len] = noa_count;
 110         p2p_noa_attr_len = p2p_noa_attr_len + 1;
 111
 112         /* NoA Duration (4 bytes) unit: microseconds */
 113         RTW_PUT_LE32(p2p_noa_attr_ie + p2p_noa_attr_len, (noa_duration * TU));
 114         p2p_noa_attr_len = p2p_noa_attr_len + 4;
 115
 116         /* NoA Interval (4 bytes) unit: microseconds */
 117         RTW_PUT_LE32(p2p_noa_attr_ie + p2p_noa_attr_len, (noa_interval * TU));
 118         p2p_noa_attr_len = p2p_noa_attr_len + 4;
 119
 120         /* NoA Start Time (4 bytes) unit: microseconds */
 121         RTW_PUT_LE32(p2p_noa_attr_ie + p2p_noa_attr_len, pmccadapriv->noa_start_time);
 122         if (0)
 123                 RTW_INFO("indxe:%d, start_time=0x%02x:0x%02x:0x%02x:0x%02x\n"
 124                 , noa_index
 125                 , p2p_noa_attr_ie[p2p_noa_attr_len]
 126                 , p2p_noa_attr_ie[p2p_noa_attr_len + 1]
 127                 , p2p_noa_attr_ie[p2p_noa_attr_len + 2]
 128                 , p2p_noa_attr_ie[p2p_noa_attr_len + 3]);
 129
 130         p2p_noa_attr_len = p2p_noa_attr_len + 4;
 131         rtw_set_ie(ie, _VENDOR_SPECIFIC_IE_, p2p_noa_attr_len, (u8 *)p2p_noa_attr_ie, ie_len);
 132 }
 133
 134
 135 /**
 136  * rtw_hal_mcc_update_go_p2p_ie - update go p2p ie(add NoA attribute)
 137  * @padapter: the adapter to be update go p2p ie
 138  */
 139 static void rtw_hal_mcc_update_go_p2p_ie(PADAPTER padapter)
 140 {
 141         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
 142         u8 *pos = NULL;
 143
 144
 145         /* no noa attribute, build it */
 146         if (pmccadapriv->p2p_go_noa_ie_len == 0)
 147                 rtw_hal_mcc_build_p2p_noa_attr(padapter, pmccadapriv->p2p_go_noa_ie, &pmccadapriv->p2p_go_noa_ie_len);
 148         else {
 149         /* has noa attribut, modify it */
 150                 /* update index */
 151                 pos = pmccadapriv->p2p_go_noa_ie + pmccadapriv->p2p_go_noa_ie_len - 15;
 152                 /* 0~255 */
 153                 (*pos) = ((*pos) + 1) % 256;
 154                 if (1)
 155                         RTW_INFO("indxe:%d\n", (*pos));
 156
 157                 /* update start time */
 158                 pos = pmccadapriv->p2p_go_noa_ie + pmccadapriv->p2p_go_noa_ie_len - 4;
 159                 RTW_PUT_LE32(pos, pmccadapriv->noa_start_time);
 160                 if (0)
 161                         RTW_INFO("start_time=0x%02x:0x%02x:0x%02x:0x%02x\n"
 162                         , ((u8*)(pos))[0]
 163                         , ((u8*)(pos))[1]
 164                         , ((u8*)(pos))[2]
 165                         , ((u8*)(pos))[3]);
 166
 167         }
 168
 169         if (0) {
 170                 u8 i = 0;
 171                 RTW_INFO("p2p_go_noa_ie_len:%d\n", pmccadapriv->p2p_go_noa_ie_len);
 172
 173                 for (i = 0;i < pmccadapriv->p2p_go_noa_ie_len; i++) {
 174                         if ((i+1)%8 != 0)
 175                                 printk("0x%02x ", pmccadapriv->p2p_go_noa_ie[i]);
 176                         else
 177                                 printk("0x%02x\n", pmccadapriv->p2p_go_noa_ie[i]);
 178                 }
 179                 printk("\n");
 180         }
 181         update_beacon(padapter, _VENDOR_SPECIFIC_IE_, P2P_OUI, _TRUE);
 182 }
 183
 184 /**
 185  * rtw_hal_mcc_remove_go_p2p_ie - remove go p2p ie(add NoA attribute)
 186  * @padapter: the adapter to be update go p2p ie
 187  */
 188 static void rtw_hal_mcc_remove_go_p2p_ie(PADAPTER padapter)
 189 {
 190         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 191         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
 192
 193         /* chech has noa ie or not */
 194         if (pmccadapriv->p2p_go_noa_ie_len == 0)
 195                 return;
 196
 197         pmccadapriv->p2p_go_noa_ie_len = 0;
 198         update_beacon(padapter, _VENDOR_SPECIFIC_IE_, P2P_OUI, _TRUE);
 199 }
 200
 201 /* restore IQK value for all interface */
 202 void rtw_hal_mcc_restore_iqk_val(PADAPTER padapter)
 203 {
 204         u8 take_care_iqk = _FALSE;
 205         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 206         _adapter *iface = NULL;
 207         u8 i = 0;
 208
 209         rtw_hal_get_hwreg(padapter, HW_VAR_CH_SW_NEED_TO_TAKE_CARE_IQK_INFO, &take_care_iqk);
 210         if (take_care_iqk == _TRUE && MCC_EN(padapter)) {
 211                 for (i = 0; i < dvobj->iface_nums; i++) {
 212                         iface = dvobj->padapters[i];
 213                         if (iface == NULL)
 214                                 continue;
 215
 216                         rtw_hal_ch_sw_iqk_info_restore(iface, CH_SW_USE_CASE_MCC);
 217                 }
 218         }
 219
 220         if (0)
 221                 dump_iqk_val_table(padapter);
 222 }
 223
 224 u8 rtw_hal_check_mcc_status(PADAPTER padapter, u8 mcc_status)
 225 {
 226         struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
 227
 228         if (pmccobjpriv->mcc_status & (mcc_status))
 229                 return _TRUE;
 230         else
 231                 return _FALSE;
 232 }
 233
 234 void rtw_hal_set_mcc_status(PADAPTER padapter, u8 mcc_status)
 235 {
 236         struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
 237
 238         pmccobjpriv->mcc_status |= (mcc_status);
 239 }
 240
 241 void rtw_hal_clear_mcc_status(PADAPTER padapter, u8 mcc_status)
 242 {
 243         struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
 244
 245         pmccobjpriv->mcc_status &= (~mcc_status);
 246 }
 247
 248 void rtw_hal_mcc_update_switch_channel_policy_table(PADAPTER padapter)
 249 {
 250         struct registry_priv *registry_par = &padapter->registrypriv;
 251         u8 idx = 0;
 252
 253         if (registry_par->rtw_mcc_policy_table_idx < 0)
 254                 return;
 255
 256         if (registry_par->rtw_mcc_policy_table_idx >= mcc_max_policy_num) {
 257                 RTW_INFO("[MCC] mcc_policy_table_idx error, do not update policy table\n");
 258                 return;
 259         }
 260
 261         idx = registry_par->rtw_mcc_policy_table_idx;
 262
 263         if (registry_par->rtw_mcc_duration > 0)
 264                 mcc_switch_channel_policy_table[idx][MCC_DURATION_IDX] = registry_par->rtw_mcc_duration;
 265
 266         if (registry_par->rtw_mcc_tsf_sync_offset > 0)
 267                 mcc_switch_channel_policy_table[idx][MCC_TSF_SYNC_OFFSET_IDX] = registry_par->rtw_mcc_tsf_sync_offset;
 268
 269         if (registry_par->rtw_mcc_start_time_offset > 0)
 270                 mcc_switch_channel_policy_table[idx][MCC_START_TIME_OFFSET_IDX] = registry_par->rtw_mcc_start_time_offset;
 271
 272         if (registry_par->rtw_mcc_interval > 0)
 273                 mcc_switch_channel_policy_table[idx][MCC_INTERVAL_IDX] = registry_par->rtw_mcc_interval;
 274
 275         if (registry_par->rtw_mcc_guard_offset0 >= 0)
 276                 mcc_switch_channel_policy_table[idx][MCC_GUARD_OFFSET0_IDX] = registry_par->rtw_mcc_guard_offset0;
 277
 278         if (registry_par->rtw_mcc_guard_offset1 >= 0)
 279                 mcc_switch_channel_policy_table[idx][MCC_GUARD_OFFSET1_IDX] = registry_par->rtw_mcc_guard_offset1;
 280
 281 }
 282
 283 static void rtw_hal_config_mcc_switch_channel_setting(PADAPTER padapter)
 284 {
 285         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
 286         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 287         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 288         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
 289         struct registry_priv *registry_par = &padapter->registrypriv;
 290         u8 interval = pmlmepriv->cur_network.network.Configuration.BeaconPeriod;
 291         u8 i = 0;
 292         s8 mcc_policy_idx = 0;
 293
 294         rtw_hal_mcc_update_switch_channel_policy_table(padapter);
 295         mcc_policy_idx = registry_par->rtw_mcc_policy_table_idx;
 296
 297         if (mcc_policy_idx < 0 || mcc_policy_idx >= mcc_max_policy_num) {
 298                 pmccobjpriv->policy_index = 0;
 299                 RTW_INFO("[MCC] can't find table(%d,%d,%d), use default policy(%d)\n"
 300                         , pmccobjpriv->duration, interval, mcc_policy_idx, pmccobjpriv->policy_index);
 301         } else
 302                 pmccobjpriv->policy_index = mcc_policy_idx;
 303
 304         RTW_INFO("[MCC] policy(%d): %d,%d,%d,%d,%d,%d\n"
 305                 , pmccobjpriv->policy_index
 306                 , mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_DURATION_IDX]
 307                 , mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_TSF_SYNC_OFFSET_IDX]
 308                 , mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_START_TIME_OFFSET_IDX]
 309                 , mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_INTERVAL_IDX]
 310                 , mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_GUARD_OFFSET0_IDX]
 311                 , mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_GUARD_OFFSET1_IDX]);
 312
 313 }
 314
 315 static void rtw_hal_config_mcc_role_setting(PADAPTER padapter)
 316 {
 317         struct dvobj_priv       *pdvobjpriv = adapter_to_dvobj(padapter);
 318         struct mcc_obj_priv *pmccobjpriv = &(pdvobjpriv->mcc_objpriv);
 319         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
 320         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 321         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 322         struct wlan_network *cur_network = &(pmlmepriv->cur_network);
 323         struct sta_priv *pstapriv = &padapter->stapriv;
 324         struct sta_info *psta = NULL;
 325         struct registry_priv *preg = &padapter->registrypriv;
 326         u8 policy_index = 0;
 327         u8 mcc_duration = 0;
 328         u8 mcc_interval = 0;
 329
 330         policy_index = pmccobjpriv->policy_index;
 331         mcc_duration = mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_DURATION_IDX]
 332                 - mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_GUARD_OFFSET0_IDX]
 333                         - mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_GUARD_OFFSET1_IDX];
 334         mcc_interval = mcc_switch_channel_policy_table[pmccobjpriv->policy_index][MCC_INTERVAL_IDX];
 335
 336         /* GO/AP is 1nd order  GC/STA is 2nd order */
 337         switch (pmccadapriv->role) {
 338         case MCC_ROLE_STA:
 339         case MCC_ROLE_GC:
 340                 pmccadapriv->order = 1;
 341                 pmccadapriv->mcc_duration = mcc_duration;
 342
 343                 switch (pmlmeext->cur_bwmode) {
 344                 case CHANNEL_WIDTH_20:
 345                         /*
 346                         * target tx byte(bytes) = target tx tp(Mbits/sec) * 1024 * 1024 / 8 * (duration(ms) / 1024)
 347                         *                                       = target tx tp(Mbits/sec) * 128 * duration(ms)
 348                         * note:
 349                         * target tx tp(Mbits/sec) * 1024 * 1024 / 8 ==> Mbits to bytes
 350                         * duration(ms) / 1024 ==> msec to sec
 351                         */
 352                         pmccadapriv->mcc_target_tx_bytes_to_port = preg->rtw_mcc_sta_bw20_target_tx_tp * 128 * pmccadapriv->mcc_duration;
 353                         break;
 354                 case CHANNEL_WIDTH_40:
 355                         pmccadapriv->mcc_target_tx_bytes_to_port = preg->rtw_mcc_sta_bw40_target_tx_tp * 128 * pmccadapriv->mcc_duration;
 356                         break;
 357                 case CHANNEL_WIDTH_80:
 358                         pmccadapriv->mcc_target_tx_bytes_to_port = preg->rtw_mcc_sta_bw80_target_tx_tp * 128 * pmccadapriv->mcc_duration;
 359                         break;
 360                 case CHANNEL_WIDTH_160:
 361                 case CHANNEL_WIDTH_80_80:
 362                         RTW_INFO(FUNC_ADPT_FMT": not support bwmode = %d\n"
 363                                 , FUNC_ADPT_ARG(padapter), pmlmeext->cur_bwmode);
 364                         break;
 365                 }
 366
 367                 /* assign used mac to avoid affecting RA */
 368                 pmccadapriv->mgmt_queue_macid = MCC_ROLE_STA_GC_MGMT_QUEUE_MACID;
 369
 370                 psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
 371                 if (psta) {
 372                         /* combine AP/GO macid and mgmt queue macid to bitmap */
 373                         pmccadapriv->mcc_macid_bitmap = BIT(psta->mac_id) | BIT(pmccadapriv->mgmt_queue_macid);
 374                 } else {
 375                         RTW_INFO(FUNC_ADPT_FMT":AP/GO station info is NULL\n", FUNC_ADPT_ARG(padapter));
 376                         rtw_warn_on(1);
 377                 }
 378                 break;
 379         case MCC_ROLE_AP:
 380         case MCC_ROLE_GO:
 381                 pmccadapriv->order = 0;
 382                 /* total druation value equals interval */
 383                 pmccadapriv->mcc_duration = mcc_interval - mcc_duration;
 384                 pmccadapriv->p2p_go_noa_ie_len = 0; /* not NoA attribute at init time */
 385
 386                 switch (pmlmeext->cur_bwmode) {
 387                 case CHANNEL_WIDTH_20:
 388                         pmccadapriv->mcc_target_tx_bytes_to_port = preg->rtw_mcc_ap_bw20_target_tx_tp * 128 * pmccadapriv->mcc_duration;
 389                         break;
 390                 case CHANNEL_WIDTH_40:
 391                         pmccadapriv->mcc_target_tx_bytes_to_port = preg->rtw_mcc_ap_bw40_target_tx_tp * 128 * pmccadapriv->mcc_duration;
 392                         break;
 393                 case CHANNEL_WIDTH_80:
 394                         pmccadapriv->mcc_target_tx_bytes_to_port = preg->rtw_mcc_ap_bw80_target_tx_tp * 128 * pmccadapriv->mcc_duration;
 395                         break;
 396                 case CHANNEL_WIDTH_160:
 397                 case CHANNEL_WIDTH_80_80:
 398                         RTW_INFO(FUNC_ADPT_FMT": not support bwmode = %d\n"
 399                                 , FUNC_ADPT_ARG(padapter), pmlmeext->cur_bwmode);
 400                         break;
 401                 }
 402
 403
 404                 psta = rtw_get_bcmc_stainfo(padapter);
 405
 406                 if (psta != NULL)
 407                         pmccadapriv->mgmt_queue_macid = psta->mac_id;
 408                 else {
 409                         pmccadapriv->mgmt_queue_macid = MCC_ROLE_SOFTAP_GO_MGMT_QUEUE_MACID;
 410                         RTW_INFO(FUNC_ADPT_FMT":bcmc station is NULL, use macid %d\n"
 411                                 , FUNC_ADPT_ARG(padapter), pmccadapriv->mgmt_queue_macid);
 412                 }
 413
 414                 /* combine client macid and mgmt queue macid to bitmap */
 415                 pmccadapriv->mcc_macid_bitmap = (0xff << 8) | BIT(pmccadapriv->mgmt_queue_macid);
 416                 break;
 417         default:
 418                 RTW_INFO("Unknown role\n");
 419                 rtw_warn_on(1);
 420                 break;
 421         }
 422
 423         pmccobjpriv->iface[pmccadapriv->order] = padapter;
 424         RTW_INFO(FUNC_ADPT_FMT": order:%d, role:%d, mcc duration:%d, target tx bytes:%d, mgmt queue macid:%d, bitmap:0x%02x\n"
 425                 , FUNC_ADPT_ARG(padapter), pmccadapriv->order, pmccadapriv->role, pmccadapriv->mcc_duration
 426                         , pmccadapriv->mcc_target_tx_bytes_to_port, pmccadapriv->mgmt_queue_macid, pmccadapriv->mcc_macid_bitmap);
 427 }
 428
 429 static void rtw_hal_clear_mcc_macid(PADAPTER padapter)
 430 {
 431         u16 media_status_rpt;
 432         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
 433
 434         switch (pmccadapriv->role) {
 435         case MCC_ROLE_STA:
 436         case MCC_ROLE_GC:
 437                 break;
 438         case MCC_ROLE_AP:
 439         case MCC_ROLE_GO:
 440         /* nothing to do */
 441                 break;
 442         default:
 443                 RTW_INFO("Unknown role\n");
 444                 rtw_warn_on(1);
 445                 break;
 446         }
 447 }
 448 static u8 rtw_hal_decide_mcc_role(PADAPTER padapter)
 449 {
 450         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 451         _adapter *iface = NULL;
 452         struct mcc_adapter_priv *pmccadapriv = NULL;
 453         struct wifidirect_info *pwdinfo = NULL;
 454         struct mlme_priv *pmlmepriv = NULL;
 455         u8 ret = _SUCCESS, i = 0;
 456
 457         for (i = 0; i < dvobj->iface_nums; i++) {
 458                 iface = dvobj->padapters[i];
 459                 if (iface == NULL)
 460                         continue;
 461
 462                 pmccadapriv = &iface->mcc_adapterpriv;
 463
 464                 if (MLME_IS_GO(iface))
 465                         pmccadapriv->role = MCC_ROLE_GO;
 466                 else if (MLME_IS_AP(iface))
 467                         pmccadapriv->role = MCC_ROLE_AP;
 468                 else if (MLME_IS_GC(iface))
 469                         pmccadapriv->role = MCC_ROLE_GC;
 470                 else if (MLME_IS_STA(iface))
 471                         pmccadapriv->role = MCC_ROLE_STA;
 472                 else {
 473                         pwdinfo = &iface->wdinfo;
 474                         pmlmepriv = &iface->mlmepriv;
 475
 476                         RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(iface));
 477                         RTW_INFO("Unknown:P2P state:%d, mlme state:0x%2x, mlmext info state:0x%02x\n",
 478                                 pwdinfo->role, pmlmepriv->fw_state, iface->mlmeextpriv.mlmext_info.state);
 479                         rtw_warn_on(1);
 480                         ret =  _FAIL;
 481                         goto exit;
 482                 }
 483
 484                 if (ret == _SUCCESS)
 485                         rtw_hal_config_mcc_role_setting(iface);
 486         }
 487
 488 exit:
 489         return ret;
 490 }
 491
 492 static void rtw_hal_init_mcc_parameter(PADAPTER padapter)
 493 {
 494 }
 495
 496 static void rtw_hal_construct_CTS(PADAPTER padapter, u8 *pframe, u32 *pLength)
 497 {
 498         u8 broadcast_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 499
 500         /* frame type, length = 1*/
 501         set_frame_sub_type(pframe, WIFI_RTS);
 502
 503         /* frame control flag, length = 1 */
 504         *(pframe + 1) = 0;
 505
 506         /* frame duration, length = 2 */
 507         *(pframe + 2) = 0x00;
 508         *(pframe + 3) = 0x78;
 509
 510         /* frame recvaddr, length = 6 */
 511         _rtw_memcpy((pframe + 4), broadcast_addr, ETH_ALEN);
 512         _rtw_memcpy((pframe + 4 + ETH_ALEN), adapter_mac_addr(padapter), ETH_ALEN);
 513         _rtw_memcpy((pframe + 4 + ETH_ALEN*2), adapter_mac_addr(padapter), ETH_ALEN);
 514         *pLength = 22;
 515 }
 516
 517 u8 rtw_hal_dl_mcc_fw_rsvd_page(_adapter *adapter, u8 *pframe, u16 *index,
 518         u8 tx_desc, u32 page_size, u8 *page_num, u32 *total_pkt_len,
 519                 RSVDPAGE_LOC *rsvd_page_loc)
 520 {
 521         u32 len = 0;
 522         _adapter *iface = NULL;
 523         struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
 524         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
 525         struct mlme_ext_info *pmlmeinfo = NULL;
 526         struct mlme_ext_priv *pmlmeext = NULL;
 527         u8 ret = _SUCCESS, i = 0, order = 0, CurtPktPageNum = 0;
 528         u8 bssid[ETH_ALEN] = {0};
 529
 530         /* check proccess mcc start setting */
 531         if (!rtw_hal_check_mcc_status(adapter, MCC_STATUS_PROCESS_MCC_START_SETTING)) {
 532                 ret = _FAIL;
 533                 goto exit;
 534         }
 535
 536         for (i = 0; i < dvobj->iface_nums; i++) {
 537                 iface = dvobj->padapters[i];
 538                 if (iface == NULL)
 539                         continue;
 540
 541                 order = iface->mcc_adapterpriv.order;
 542                 dvobj->mcc_objpriv.mcc_loc_rsvd_paga[order] = *page_num;
 543
 544                 switch (iface->mcc_adapterpriv.role) {
 545                 case MCC_ROLE_STA:
 546                 case MCC_ROLE_GC:
 547                         /* Build NULL DATA */
 548                         RTW_INFO("LocNull(order:%d): %d\n"
 549                                 , order, dvobj->mcc_objpriv.mcc_loc_rsvd_paga[order]);
 550                         len = 0;
 551                         pmlmeext = &iface->mlmeextpriv;
 552                         pmlmeinfo = &pmlmeext->mlmext_info;
 553
 554                         _rtw_memcpy(bssid, get_my_bssid(&pmlmeinfo->network), ETH_ALEN);
 555                         rtw_hal_construct_NullFunctionData(iface
 556                                 , &pframe[*index], &len, bssid, _FALSE, 0, 0, _FALSE);
 557                         rtw_hal_fill_fake_txdesc(iface, &pframe[*index-tx_desc],
 558                                 len, _FALSE, _FALSE, _FALSE);
 559
 560                         CurtPktPageNum = (u8)PageNum(tx_desc + len, page_size);
 561                         *page_num += CurtPktPageNum;
 562                         *index += (CurtPktPageNum * page_size);
 563                         *total_pkt_len = *index + len;
 564                         break;
 565                 case MCC_ROLE_AP:
 566                         /* Bulid CTS */
 567                         RTW_INFO("LocCTS(order:%d): %d\n"
 568                                 , order, dvobj->mcc_objpriv.mcc_loc_rsvd_paga[order]);
 569
 570                         len = 0;
 571                         rtw_hal_construct_CTS(iface, &pframe[*index], &len);
 572                         rtw_hal_fill_fake_txdesc(iface, &pframe[*index-tx_desc],
 573                                 len, _FALSE, _FALSE, _FALSE);
 574
 575                         CurtPktPageNum = (u8)PageNum(tx_desc + len, page_size);
 576                         *page_num += CurtPktPageNum;
 577                         *index += (CurtPktPageNum * page_size);
 578                         *total_pkt_len = *index + len;
 579                         break;
 580                 case MCC_ROLE_GO:
 581                 /* To DO */
 582                         break;
 583                 }
 584         }
 585 exit:
 586         return ret;
 587 }
 588
 589 /*
 590 * 1. Download MCC rsvd page
 591 * 2. Re-Download beacon after download rsvd page
 592 */
 593 static void rtw_hal_set_fw_mcc_rsvd_page(PADAPTER padapter)
 594 {
 595         HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
 596         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
 597         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 598         PADAPTER port0_iface = dvobj_get_port0_adapter(dvobj);
 599         PADAPTER iface = NULL;
 600         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
 601         u8 mstatus = RT_MEDIA_CONNECT, i = 0;
 602
 603         RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
 604
 605         rtw_hal_set_hwreg(port0_iface, HW_VAR_H2C_FW_JOINBSSRPT, (u8 *)(&mstatus));
 606
 607         /* Re-Download beacon */
 608         for (i = 0; i < dvobj->iface_nums; i++) {
 609                 iface = pmccobjpriv->iface[i];
 610                 pmccadapriv = &iface->mcc_adapterpriv;
 611                 if (pmccadapriv->role == MCC_ROLE_AP
 612                         || pmccadapriv->role == MCC_ROLE_GO)
 613                         tx_beacon_hdl(iface, NULL);
 614         }
 615 }
 616
 617 static void rtw_hal_set_mcc_rsvdpage_cmd(_adapter *padapter)
 618 {
 619         u8 cmd[H2C_MCC_LOCATION_LEN] = {0}, i = 0, order = 0;
 620         _adapter *iface = NULL;
 621         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 622         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
 623
 624
 625         for (i = 0; i < dvobj->iface_nums; i++) {
 626                 iface = dvobj->padapters[i];
 627                 if (iface == NULL)
 628                         continue;
 629
 630                 order = iface->mcc_adapterpriv.order;
 631                 if (order >= H2C_MCC_LOCATION_LEN) {
 632                         RTW_INFO(FUNC_ADPT_FMT" only support 3 interface at most(%d)\n"
 633                                 , FUNC_ADPT_ARG(padapter), order);
 634                         continue;
 635                 }
 636
 637                 SET_H2CCMD_MCC_RSVDPAGE_LOC((cmd + order), (pmccobjpriv->mcc_loc_rsvd_paga[order]));
 638         }
 639
 640 #ifdef CONFIG_MCC_MODE_DEBUG
 641         RTW_INFO("=========================\n");
 642         RTW_INFO("MCC RSVD PAGE LOC:\n");
 643         for (i = 0; i < H2C_MCC_LOCATION_LEN; i++)
 644                 pr_dbg("0x%x ", cmd[i]);
 645         pr_dbg("\n");
 646         RTW_INFO("=========================\n");
 647 #endif /* CONFIG_MCC_MODE_DEBUG */
 648
 649         rtw_hal_fill_h2c_cmd(padapter, H2C_MCC_LOCATION, H2C_MCC_LOCATION_LEN, cmd);
 650 }
 651
 652 static void rtw_hal_set_mcc_noa_cmd(PADAPTER padapter)
 653 {
 654         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
 655         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 656         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 657         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
 658         u8 cmd[H2C_MCC_NOA_PARAM_LEN] = {0};
 659         u8 policy_idx = pmccobjpriv->policy_index;
 660         u8 noa_fw_eable = 1;
 661         u8 noa_tsf_sync_offset = mcc_switch_channel_policy_table[policy_idx][MCC_TSF_SYNC_OFFSET_IDX];
 662         u8 noa_start_time_offset = mcc_switch_channel_policy_table[policy_idx][MCC_START_TIME_OFFSET_IDX];
 663         u8 noa_interval = mcc_switch_channel_policy_table[policy_idx][MCC_INTERVAL_IDX];
 664         u8 guard_offset0 = mcc_switch_channel_policy_table[policy_idx][MCC_GUARD_OFFSET0_IDX];
 665         u8 guard_offset1 = mcc_switch_channel_policy_table[policy_idx][MCC_GUARD_OFFSET1_IDX];
 666         u8 swchannel_early_time = MCC_SWCH_FW_EARLY_TIME;
 667         u8 i = 0;
 668
 669         /* FW set NOA enable */
 670         SET_H2CCMD_MCC_NOA_FW_EN(cmd, noa_fw_eable);
 671         /* TSF Sync offset */
 672         SET_H2CCMD_MCC_NOA_TSF_SYNC_OFFSET(cmd, noa_tsf_sync_offset);
 673         /* NoA start time offset */
 674         SET_H2CCMD_MCC_NOA_START_TIME(cmd, (noa_start_time_offset + guard_offset0));
 675         /* NoA interval */
 676         SET_H2CCMD_MCC_NOA_INTERVAL(cmd, noa_interval);
 677         /* Early time to inform driver by C2H before switch channel */
 678         SET_H2CCMD_MCC_EARLY_TIME(cmd, swchannel_early_time);
 679
 680 #ifdef CONFIG_MCC_MODE_DEBUG
 681         RTW_INFO("=========================\n");
 682         RTW_INFO("NoA:\n");
 683         for (i = 0; i < H2C_MCC_NOA_PARAM_LEN; i++)
 684                 pr_dbg("0x%x ", cmd[i]);
 685         pr_dbg("\n");
 686         RTW_INFO("=========================\n");
 687 #endif /* CONFIG_MCC_MODE_DEBUG */
 688
 689         rtw_hal_fill_h2c_cmd(padapter, H2C_MCC_NOA_PARAM, H2C_MCC_NOA_PARAM_LEN, cmd);
 690 }
 691
 692 static void rtw_hal_set_mcc_IQK_offload_cmd(PADAPTER padapter)
 693 {
 694         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 695         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
 696         struct mcc_adapter_priv *pmccadapriv = NULL;
 697         _adapter *iface = NULL;
 698         u8 cmd[H2C_MCC_IQK_PARAM_LEN] = {0}, bready = 0, i = 0, order = 0;
 699         u16 TX_X = 0, TX_Y = 0, RX_X = 0, RX_Y = 0;
 700         u8 total_rf_path = GET_HAL_DATA(padapter)->NumTotalRFPath;
 701         u8 rf_path_idx = 0, last_order = MAX_MCC_NUM - 1, last_rf_path_index = total_rf_path - 1;
 702
 703         /* by order, last order & last_rf_path_index must set ready bit = 1 */
 704         for (i = 0; i < dvobj->iface_nums; i++) {
 705                 iface = pmccobjpriv->iface[i];
 706                 if (iface == NULL)
 707                         continue;
 708
 709                 pmccadapriv = &iface->mcc_adapterpriv;
 710                 order = pmccadapriv->order;
 711
 712                 for (rf_path_idx = 0; rf_path_idx < total_rf_path; rf_path_idx ++) {
 713
 714                         _rtw_memset(cmd, 0, H2C_MCC_IQK_PARAM_LEN);
 715                         TX_X = pmccadapriv->mcc_iqk_arr[rf_path_idx].TX_X & 0x7ff;/* [10:0]  */
 716                         TX_Y = pmccadapriv->mcc_iqk_arr[rf_path_idx].TX_Y & 0x7ff;/* [10:0]  */
 717                         RX_X = pmccadapriv->mcc_iqk_arr[rf_path_idx].RX_X & 0x3ff;/* [9:0]  */
 718                         RX_Y = pmccadapriv->mcc_iqk_arr[rf_path_idx].RX_Y & 0x3ff;/* [9:0]  */
 719
 720                         /* ready or not */
 721                         if (order == last_order && rf_path_idx == last_rf_path_index)
 722                                 bready = 1;
 723                         else
 724                                 bready = 0;
 725
 726                         SET_H2CCMD_MCC_IQK_READY(cmd, bready);
 727                         SET_H2CCMD_MCC_IQK_ORDER(cmd, order);
 728                         SET_H2CCMD_MCC_IQK_PATH(cmd, rf_path_idx);
 729
 730                         /* fill RX_X[7:0] to (cmd+1)[7:0] bitlen=8 */
 731                         SET_H2CCMD_MCC_IQK_RX_L(cmd, (u8)(RX_X & 0xff));
 732                         /* fill RX_X[9:8] to (cmd+2)[1:0] bitlen=2 */
 733                         SET_H2CCMD_MCC_IQK_RX_M1(cmd, (u8)((RX_X >> 8) & 0x03));
 734                         /* fill RX_Y[5:0] to (cmd+2)[7:2] bitlen=6 */
 735                         SET_H2CCMD_MCC_IQK_RX_M2(cmd, (u8)(RX_Y & 0x3f));
 736                         /* fill RX_Y[9:6] to (cmd+3)[3:0] bitlen=4 */
 737                         SET_H2CCMD_MCC_IQK_RX_H(cmd, (u8)((RX_Y >> 6) & 0x0f));
 738
 739
 740                         /* fill TX_X[7:0] to (cmd+4)[7:0] bitlen=8 */
 741                         SET_H2CCMD_MCC_IQK_TX_L(cmd, (u8)(TX_X & 0xff));
 742                         /* fill TX_X[10:8] to (cmd+5)[2:0] bitlen=3 */
 743                         SET_H2CCMD_MCC_IQK_TX_M1(cmd, (u8)((TX_X >> 8) & 0x07));
 744                         /* fill TX_Y[4:0] to (cmd+5)[7:3] bitlen=5 */
 745                         SET_H2CCMD_MCC_IQK_TX_M2(cmd, (u8)(TX_Y & 0x1f));
 746                         /* fill TX_Y[10:5] to (cmd+6)[5:0] bitlen=6 */
 747                         SET_H2CCMD_MCC_IQK_TX_H(cmd, (u8)((TX_Y >> 5) & 0x3f));
 748
 749 #ifdef CONFIG_MCC_MODE_DEBUG
 750                         RTW_INFO("=========================\n");
 751                         RTW_INFO(FUNC_ADPT_FMT" IQK:\n", FUNC_ADPT_ARG(iface));
 752                         RTW_INFO("TX_X: 0x%02x\n", TX_X);
 753                         RTW_INFO("TX_Y: 0x%02x\n", TX_Y);
 754                         RTW_INFO("RX_X: 0x%02x\n", RX_X);
 755                         RTW_INFO("RX_Y: 0x%02x\n", RX_Y);
 756                         RTW_INFO("cmd[0]:0x%02x\n", cmd[0]);
 757                         RTW_INFO("cmd[1]:0x%02x\n", cmd[1]);
 758                         RTW_INFO("cmd[2]:0x%02x\n", cmd[2]);
 759                         RTW_INFO("cmd[3]:0x%02x\n", cmd[3]);
 760                         RTW_INFO("cmd[4]:0x%02x\n", cmd[4]);
 761                         RTW_INFO("cmd[5]:0x%02x\n", cmd[5]);
 762                         RTW_INFO("cmd[6]:0x%02x\n", cmd[6]);
 763                         RTW_INFO("=========================\n");
 764 #endif /* CONFIG_MCC_MODE_DEBUG */
 765
 766                         rtw_hal_fill_h2c_cmd(padapter, H2C_MCC_IQK_PARAM, H2C_MCC_IQK_PARAM_LEN, cmd);
 767                 }
 768         }
 769 }
 770
 771
 772 static void rtw_hal_set_mcc_macid_cmd(PADAPTER padapter)
 773 {
 774         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 775         struct mcc_adapter_priv *pmccadapriv = NULL;
 776         _adapter *iface = NULL;
 777         u8 cmd[H2C_MCC_MACID_BITMAP_LEN] = {0}, i = 0, order = 0;
 778         u16 bitmap = 0;
 779
 780         for (i = 0; i < dvobj->iface_nums; i++) {
 781                 iface = dvobj->padapters[i];
 782                 if (iface == NULL)
 783                         continue;
 784
 785                 pmccadapriv = &iface->mcc_adapterpriv;
 786                 order = pmccadapriv->order;
 787                 bitmap = pmccadapriv->mcc_macid_bitmap;
 788
 789                 if (order >= (H2C_MCC_MACID_BITMAP_LEN/2)) {
 790                         RTW_INFO(FUNC_ADPT_FMT" only support 3 interface at most(%d)\n"
 791                                 , FUNC_ADPT_ARG(padapter), order);
 792                         continue;
 793                 }
 794                 SET_H2CCMD_MCC_MACID_BITMAP_L((cmd + order * 2), (u8)(bitmap & 0xff));
 795                 SET_H2CCMD_MCC_MACID_BITMAP_H((cmd + order * 2), (u8)((bitmap >> 8) & 0xff));
 796         }
 797
 798 #ifdef CONFIG_MCC_MODE_DEBUG
 799         RTW_INFO("=========================\n");
 800         RTW_INFO("MACID BITMAP: ");
 801         for (i = 0; i < H2C_MCC_MACID_BITMAP_LEN; i++)
 802                 pr_dbg("0x%x ", cmd[i]);
 803         pr_dbg("\n");
 804         RTW_INFO("=========================\n");
 805 #endif /* CONFIG_MCC_MODE_DEBUG */
 806         rtw_hal_fill_h2c_cmd(padapter, H2C_MCC_MACID_BITMAP, H2C_MCC_MACID_BITMAP_LEN, cmd);
 807 }
 808
 809 static void rtw_hal_set_mcc_ctrl_cmd(PADAPTER padapter, u8 stop)
 810 {
 811         u8 cmd[H2C_MCC_CTRL_LEN] = {0}, i = 0;
 812         u8 order = 0, totalnum = 0, chidx = 0, bw = 0, bw40sc = 0, bw80sc = 0;
 813         u8 duration = 0, role = 0, incurch = 0, rfetype = 0, distxnull = 0, c2hrpt = 0, chscan = 0;
 814         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 815         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
 816         struct mlme_ext_priv *pmlmeext = NULL;
 817         struct mlme_ext_info *pmlmeinfo = NULL;
 818         HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
 819         _adapter *iface = NULL;
 820
 821         RTW_INFO(FUNC_ADPT_FMT": stop=%d\n", FUNC_ADPT_ARG(padapter), stop);
 822
 823         for (i = 0; i < dvobj->iface_nums; i++) {
 824                 iface = pmccobjpriv->iface[i];
 825                 if (iface == NULL)
 826                         continue;
 827
 828                 if (stop) {
 829                         if (iface != padapter)
 830                                 continue;
 831                 }
 832
 833
 834                 order = iface->mcc_adapterpriv.order;
 835                 if (!stop)
 836                         totalnum = dvobj->iface_nums;
 837                 else
 838                         totalnum = 0xff; /* 0xff means stop */
 839
 840                 pmlmeext = &iface->mlmeextpriv;
 841                 chidx = pmlmeext->cur_channel;
 842                 bw = pmlmeext->cur_bwmode;
 843                 bw40sc = pmlmeext->cur_ch_offset;
 844
 845                 /* decide 80 band width offset */
 846                 if (bw == CHANNEL_WIDTH_80) {
 847                         u8 center_ch = rtw_get_center_ch(chidx, bw, bw40sc);
 848
 849                         if (center_ch > chidx)
 850                                 bw80sc = HAL_PRIME_CHNL_OFFSET_LOWER;
 851                         else if (center_ch < chidx)
 852                                 bw80sc = HAL_PRIME_CHNL_OFFSET_UPPER;
 853                         else
 854                                 bw80sc = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 855                 } else
 856                         bw80sc = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
 857
 858                 duration = iface->mcc_adapterpriv.mcc_duration;
 859                 role = iface->mcc_adapterpriv.role;
 860
 861                 incurch = _FALSE;
 862
 863                 if (IS_HARDWARE_TYPE_8812(padapter))
 864                         rfetype = pHalData->rfe_type; /* RFETYPE (only for 8812)*/
 865                 else
 866                         rfetype = 0;
 867
 868                 /* STA/GC TX NULL data to inform AP/GC for ps mode */
 869                 switch (role) {
 870                 case MCC_ROLE_GO:
 871                 case MCC_ROLE_AP:
 872                         distxnull = MCC_DISABLE_TX_NULL;
 873                         break;
 874                 case MCC_ROLE_GC:
 875                 case MCC_ROLE_STA:
 876                         distxnull = MCC_ENABLE_TX_NULL;
 877                         break;
 878                 }
 879
 880                 c2hrpt = MCC_C2H_REPORT_ALL_STATUS;
 881                 chscan = MCC_CHIDX;
 882
 883                 SET_H2CCMD_MCC_CTRL_ORDER(cmd, order);
 884                 SET_H2CCMD_MCC_CTRL_TOTALNUM(cmd, totalnum);
 885                 SET_H2CCMD_MCC_CTRL_CHIDX(cmd, chidx);
 886                 SET_H2CCMD_MCC_CTRL_BW(cmd, bw);
 887                 SET_H2CCMD_MCC_CTRL_BW40SC(cmd, bw40sc);
 888                 SET_H2CCMD_MCC_CTRL_BW80SC(cmd, bw80sc);
 889                 SET_H2CCMD_MCC_CTRL_DURATION(cmd, duration);
 890                 SET_H2CCMD_MCC_CTRL_ROLE(cmd, role);
 891                 SET_H2CCMD_MCC_CTRL_INCURCH(cmd, incurch);
 892                 SET_H2CCMD_MCC_CTRL_RFETYPE(cmd, rfetype);
 893                 SET_H2CCMD_MCC_CTRL_DISTXNULL(cmd, distxnull);
 894                 SET_H2CCMD_MCC_CTRL_C2HRPT(cmd, c2hrpt);
 895                 SET_H2CCMD_MCC_CTRL_CHSCAN(cmd, chscan);
 896
 897 #ifdef CONFIG_MCC_MODE_DEBUG
 898                 RTW_INFO("=========================\n");
 899                 RTW_INFO(FUNC_ADPT_FMT" MCC INFO:\n", FUNC_ADPT_ARG(iface));
 900                 RTW_INFO("cmd[0]:0x%02x\n", cmd[0]);
 901                 RTW_INFO("cmd[1]:0x%02x\n", cmd[1]);
 902                 RTW_INFO("cmd[2]:0x%02x\n", cmd[2]);
 903                 RTW_INFO("cmd[3]:0x%02x\n", cmd[3]);
 904                 RTW_INFO("cmd[4]:0x%02x\n", cmd[4]);
 905                 RTW_INFO("cmd[5]:0x%02x\n", cmd[5]);
 906                 RTW_INFO("cmd[6]:0x%02x\n", cmd[6]);
 907                 RTW_INFO("=========================\n");
 908 #endif /* CONFIG_MCC_MODE_DEBUG */
 909
 910                 rtw_hal_fill_h2c_cmd(padapter, H2C_MCC_CTRL, H2C_MCC_CTRL_LEN, cmd);
 911         }
 912 }
 913
 914 static u8 rtw_hal_set_mcc_start_setting(PADAPTER padapter, u8 status)
 915 {
 916         u8 ret = _SUCCESS;
 917         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 918         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
 919
 920         if (pwrpriv->pwr_mode != PS_MODE_ACTIVE) {
 921                 rtw_warn_on(1);
 922                 RTW_INFO("PS mode is not active before start mcc, force exit ps mode\n");
 923                 LeaveAllPowerSaveModeDirect(padapter);
 924         }
 925
 926         if (dvobj->iface_nums > MAX_MCC_NUM) {
 927                 RTW_INFO("%s: current iface num(%d) > MAX_MCC_NUM(%d)\n", __func__, dvobj->iface_nums, MAX_MCC_NUM);
 928                 ret = _FAIL;
 929                 goto exit;
 930         }
 931
 932         /* configure mcc switch channel setting */
 933         rtw_hal_config_mcc_switch_channel_setting(padapter);
 934
 935         if (rtw_hal_decide_mcc_role(padapter) == _FAIL) {
 936                 ret = _FAIL;
 937                 goto exit;
 938         }
 939
 940         /* set mcc status to indicate process mcc start setting */
 941         rtw_hal_set_mcc_status(padapter, MCC_STATUS_PROCESS_MCC_START_SETTING);
 942
 943         /* only download rsvd page for connect */
 944         if (status == MCC_SETCMD_STATUS_START_CONNECT) {
 945                 /* download mcc rsvd page */
 946                 rtw_hal_set_fw_mcc_rsvd_page(padapter);
 947                 rtw_hal_set_mcc_rsvdpage_cmd(padapter);
 948         }
 949
 950         /* configure NoA setting */
 951         rtw_hal_set_mcc_noa_cmd(padapter);
 952
 953         /* IQK value offload */
 954         rtw_hal_set_mcc_IQK_offload_cmd(padapter);
 955
 956         /* set mac id to fw */
 957         rtw_hal_set_mcc_macid_cmd(padapter);
 958
 959         /* set mcc parameter  */
 960         rtw_hal_set_mcc_ctrl_cmd(padapter, _FALSE);
 961
 962 exit:
 963         return ret;
 964 }
 965
 966 static void rtw_hal_set_mcc_stop_setting(PADAPTER padapter, u8 status)
 967 {
 968         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 969         _adapter *iface = NULL;
 970         u8 i = 0;
 971         /*
 972          * when adapter disconnect, stop mcc mod
 973          * total=0xf means stop mcc mode
 974          */
 975
 976         switch (status) {
 977         default:
 978                 /* let fw switch to other interface channel */
 979                 for (i = 0; i < dvobj->iface_nums; i++) {
 980                         iface = dvobj->padapters[i];
 981                         if (iface == NULL)
 982                                 continue;
 983                         /* use other interface to set cmd */
 984                         if (iface != padapter) {
 985                                 rtw_hal_set_mcc_ctrl_cmd(iface, _TRUE);
 986                                 break;
 987                         }
 988                 }
 989                 break;
 990         }
 991 }
 992
 993 static void rtw_hal_mcc_status_hdl(PADAPTER padapter, u8 status)
 994 {
 995         switch (status) {
 996         case MCC_SETCMD_STATUS_STOP_DISCONNECT:
 997                 rtw_hal_clear_mcc_status(padapter, MCC_STATUS_NEED_MCC | MCC_STATUS_DOING_MCC);
 998                 break;
 999         case MCC_SETCMD_STATUS_STOP_SCAN_START:
1000                 rtw_hal_set_mcc_status(padapter, MCC_STATUS_NEED_MCC);
1001                 rtw_hal_clear_mcc_status(padapter, MCC_STATUS_DOING_MCC);
1002                 break;
1003
1004         case MCC_SETCMD_STATUS_START_CONNECT:
1005         case MCC_SETCMD_STATUS_START_SCAN_DONE:
1006                 rtw_hal_set_mcc_status(padapter, MCC_STATUS_NEED_MCC | MCC_STATUS_DOING_MCC);
1007                 break;
1008         default:
1009                 RTW_INFO(FUNC_ADPT_FMT" error status(%d)\n", FUNC_ADPT_ARG(padapter), status);
1010                 break;
1011         }
1012 }
1013
1014 static void rtw_hal_mcc_stop_posthdl(PADAPTER padapter)
1015 {
1016         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1017         _adapter *iface = NULL;
1018         u8 i = 0;
1019
1020         for (i = 0; i < dvobj->iface_nums; i++) {
1021                 iface = dvobj->padapters[i];
1022                 if (iface == NULL)
1023                         continue;
1024                 /* release network queue */
1025                 rtw_netif_wake_queue(iface->pnetdev);
1026                 iface->mcc_adapterpriv.mcc_tx_bytes_from_kernel = 0;
1027                 iface->mcc_adapterpriv.mcc_last_tx_bytes_from_kernel = 0;
1028                 iface->mcc_adapterpriv.mcc_tx_bytes_to_port = 0;
1029
1030                 if (iface->mcc_adapterpriv.role == MCC_ROLE_GO)
1031                         rtw_hal_mcc_remove_go_p2p_ie(iface);
1032         }
1033 }
1034
1035 static void rtw_hal_mcc_start_posthdl(PADAPTER padapter)
1036 {
1037         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1038         _adapter *iface = NULL;
1039         u8 i = 0;
1040
1041         for (i = 0; i < dvobj->iface_nums; i++) {
1042                 iface = dvobj->padapters[i];
1043                 if (iface == NULL)
1044                         continue;
1045                 iface->mcc_adapterpriv.mcc_tx_bytes_from_kernel = 0;
1046                 iface->mcc_adapterpriv.mcc_last_tx_bytes_from_kernel = 0;
1047                 iface->mcc_adapterpriv.mcc_tx_bytes_to_port = 0;
1048         }
1049 }
1050
1051 /*
1052  * rtw_hal_set_mcc_setting - set mcc setting
1053  * @padapter: currnet padapter to stop/start MCC
1054  * @stop: stop mcc or not
1055  * @return val: 1 for SUCCESS, 0 for fail
1056  */
1057 static u8 rtw_hal_set_mcc_setting(PADAPTER padapter, u8 status)
1058 {
1059         u8 ret = _FAIL;
1060         struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
1061         u8 stop = (status < MCC_SETCMD_STATUS_START_CONNECT) ? _TRUE : _FALSE;
1062         u32 start_time = rtw_get_current_time();
1063
1064         RTW_INFO("===> "FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
1065
1066         rtw_sctx_init(&pmccobjpriv->mcc_sctx, MCC_EXPIRE_TIME);
1067         pmccobjpriv->mcc_c2h_status = MCC_RPT_MAX;
1068
1069         if (stop == _FALSE) {
1070                 /* handle mcc start */
1071                 if (rtw_hal_set_mcc_start_setting(padapter, status) == _FAIL)
1072                         goto exit;
1073
1074                 /* wait for C2H */
1075                 if (!rtw_sctx_wait(&pmccobjpriv->mcc_sctx, __func__))
1076                         RTW_INFO(FUNC_ADPT_FMT": wait for mcc start C2H time out\n", FUNC_ADPT_ARG(padapter));
1077                 else
1078                         ret = _SUCCESS;
1079
1080                 if (ret == _SUCCESS) {
1081                         RTW_INFO(FUNC_ADPT_FMT": mcc start sucecssfully\n", FUNC_ADPT_ARG(padapter));
1082                         rtw_hal_mcc_start_posthdl(padapter);
1083                 }
1084         } else {
1085
1086                 /* set mcc status to indicate process mcc start setting */
1087                 rtw_hal_set_mcc_status(padapter, MCC_STATUS_PROCESS_MCC_STOP_SETTING);
1088
1089                 /* handle mcc stop */
1090                 rtw_hal_set_mcc_stop_setting(padapter, status);
1091
1092                 /* wait for C2H */
1093                 if (!rtw_sctx_wait(&pmccobjpriv->mcc_sctx, __func__))
1094                         RTW_INFO(FUNC_ADPT_FMT": wait for mcc stop C2H time out\n", FUNC_ADPT_ARG(padapter));
1095                 else {
1096                         ret = _SUCCESS;
1097                         rtw_hal_mcc_stop_posthdl(padapter);
1098                 }
1099         }
1100
1101 exit:
1102
1103         rtw_hal_mcc_status_hdl(padapter, status);
1104         /* clear mcc status */
1105         rtw_hal_clear_mcc_status(padapter
1106                 , MCC_STATUS_PROCESS_MCC_START_SETTING | MCC_STATUS_PROCESS_MCC_STOP_SETTING);
1107
1108         RTW_INFO(FUNC_ADPT_FMT" in %dms <===\n"
1109                 , FUNC_ADPT_ARG(padapter), rtw_get_passing_time_ms(start_time));
1110         return ret;
1111 }
1112
1113 /**
1114  * rtw_hal_mcc_check_case_not_limit_traffic - handler flow ctrl for special case
1115  * @cur_iface: fw stay channel setting of this iface
1116  * @next_iface: fw will swich channel setting of this iface
1117  */
1118 static void rtw_hal_mcc_check_case_not_limit_traffic(PADAPTER cur_iface, PADAPTER next_iface)
1119 {
1120         u8 cur_bw = cur_iface->mlmeextpriv.cur_bwmode;
1121         u8 next_bw = next_iface->mlmeextpriv.cur_bwmode;
1122
1123         /* for both interface are VHT80, doesn't limit_traffic according to iperf results */
1124         if (cur_bw == CHANNEL_WIDTH_80 && next_bw == CHANNEL_WIDTH_80) {
1125                 cur_iface->mcc_adapterpriv.mcc_tp_limit = _FALSE;
1126                 next_iface->mcc_adapterpriv.mcc_tp_limit = _FALSE;
1127         }
1128 }
1129
1130
1131 /**
1132  * rtw_hal_mcc_sw_ch_fw_notify_hdl - handler flow ctrl
1133  */
1134 static void rtw_hal_mcc_sw_ch_fw_notify_hdl(PADAPTER padapter)
1135 {
1136         struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
1137         struct mcc_obj_priv *pmccobjpriv = &(pdvobjpriv->mcc_objpriv);
1138         struct mcc_adapter_priv *cur_mccadapriv = NULL, *next_mccadapriv = NULL;
1139         _adapter *iface = NULL, *cur_iface = NULL, *next_iface = NULL;
1140         struct registry_priv *preg = &padapter->registrypriv;
1141         u8 cur_op_ch = pdvobjpriv->oper_channel;
1142         u8 i = 0, iface_num = pdvobjpriv->iface_nums, cur_order = 0, next_order = 0;
1143         static u8 cnt = 1;
1144         u32 single_tx_cri = preg->rtw_mcc_single_tx_cri;
1145
1146         for (i = 0; i < iface_num; i++) {
1147                 iface = pdvobjpriv->padapters[i];
1148                 if (cur_op_ch == iface->mlmeextpriv.cur_channel) {
1149                         cur_iface = iface;
1150                         cur_mccadapriv = &cur_iface->mcc_adapterpriv;
1151                         cur_order = cur_mccadapriv->order;
1152                         next_order = (cur_order + 1) % iface_num;
1153                         next_iface = pmccobjpriv->iface[next_order];
1154                         next_mccadapriv = &next_iface->mcc_adapterpriv;
1155                         break;
1156                 }
1157         }
1158
1159         /* check other interface tx busy traffic or not under every 2 switch channel notify(Mbits/100ms) */
1160         if (cnt == 2) {
1161                 cur_mccadapriv->mcc_tp = (cur_mccadapriv->mcc_tx_bytes_from_kernel
1162                         - cur_mccadapriv->mcc_last_tx_bytes_from_kernel) * 10 * 8 / 1024 / 1024;
1163                 cur_mccadapriv->mcc_last_tx_bytes_from_kernel = cur_mccadapriv->mcc_tx_bytes_from_kernel;
1164
1165                 next_mccadapriv->mcc_tp = (next_mccadapriv->mcc_tx_bytes_from_kernel
1166                         - next_mccadapriv->mcc_last_tx_bytes_from_kernel) * 10 * 8 / 1024 / 1024;
1167                 next_mccadapriv->mcc_last_tx_bytes_from_kernel = next_mccadapriv->mcc_tx_bytes_from_kernel;
1168
1169                 cnt = 1;
1170         } else
1171                 cnt = 2;
1172
1173         /* check single TX or cuncurrnet TX */
1174         if (next_mccadapriv->mcc_tp < single_tx_cri) {
1175                 /* single TX, does not stop */
1176                 cur_mccadapriv->mcc_tx_stop = _FALSE;
1177                 cur_mccadapriv->mcc_tp_limit = _FALSE;
1178         } else {
1179                 /* concurrent TX, stop */
1180                 cur_mccadapriv->mcc_tx_stop = _TRUE;
1181                 cur_mccadapriv->mcc_tp_limit = _TRUE;
1182         }
1183
1184         if (cur_mccadapriv->mcc_tp < single_tx_cri) {
1185                 next_mccadapriv->mcc_tx_stop  = _FALSE;
1186                 next_mccadapriv->mcc_tp_limit = _FALSE;
1187         } else {
1188                 next_mccadapriv->mcc_tx_stop = _FALSE;
1189                 next_mccadapriv->mcc_tp_limit = _TRUE;
1190                 next_mccadapriv->mcc_tx_bytes_to_port = 0;
1191         }
1192
1193         /* stop current iface kernel queue or not */
1194         if (cur_mccadapriv->mcc_tx_stop)
1195                 rtw_netif_stop_queue(cur_iface->pnetdev);
1196         else
1197                 rtw_netif_wake_queue(cur_iface->pnetdev);
1198
1199         /* stop next iface kernel queue or not */
1200         if (next_mccadapriv->mcc_tx_stop)
1201                 rtw_netif_stop_queue(next_iface->pnetdev);
1202         else
1203                 rtw_netif_wake_queue(next_iface->pnetdev);
1204
1205         /* start xmit tasklet */
1206         rtw_os_xmit_schedule(next_iface);
1207
1208         rtw_hal_mcc_check_case_not_limit_traffic(cur_iface, next_iface);
1209
1210         if (0) {
1211                 RTW_INFO("order:%d, mcc_tx_stop:%d, mcc_tp:%d\n",
1212                         cur_mccadapriv->order, cur_mccadapriv->mcc_tx_stop, cur_mccadapriv->mcc_tp);
1213                 dump_os_queue(0, cur_iface);
1214                 RTW_INFO("order:%d, mcc_tx_stop:%d, mcc_tp:%d\n",
1215                         next_mccadapriv->order, next_mccadapriv->mcc_tx_stop, next_mccadapriv->mcc_tp);
1216                 dump_os_queue(0, next_iface);
1217         }
1218 }
1219
1220 static void rtw_hal_mcc_update_noa_start_time_hdl(PADAPTER padapter, u8 buflen, u8 *tmpBuf)
1221 {
1222         struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
1223         struct mcc_obj_priv *pmccobjpriv = &(pdvobjpriv->mcc_objpriv);
1224         struct mcc_adapter_priv *pmccadapriv = NULL;
1225         PADAPTER iface = NULL;
1226         u8 i = 0;
1227         u8 policy_idx = pmccobjpriv->policy_index;
1228         u8 noa_tsf_sync_offset = mcc_switch_channel_policy_table[policy_idx][MCC_TSF_SYNC_OFFSET_IDX];
1229         u8 noa_start_time_offset = mcc_switch_channel_policy_table[policy_idx][MCC_START_TIME_OFFSET_IDX];
1230
1231         for (i = 0; i < pdvobjpriv->iface_nums; i++) {
1232                 iface = pdvobjpriv->padapters[i];
1233                 if (iface == NULL)
1234                         continue;
1235
1236                 pmccadapriv = &iface->mcc_adapterpriv;
1237                 /* GO & channel match */
1238                 if (pmccadapriv->role == MCC_ROLE_GO) {
1239                         /* convert GO TBTT from FW to noa_start_time(TU convert to mircosecond) */
1240                         pmccadapriv->noa_start_time = RTW_GET_LE32(tmpBuf + 2) + noa_start_time_offset * TU;
1241
1242                         if (0) {
1243                                 RTW_INFO("TBTT:0x%02x\n", RTW_GET_LE32(tmpBuf + 2));
1244                                 RTW_INFO("noa_tsf_sync_offset:%d, noa_start_time_offset:%d\n", noa_tsf_sync_offset, noa_start_time_offset);
1245                                 RTW_INFO(FUNC_ADPT_FMT"buf=0x%02x:0x%02x:0x%02x:0x%02x, noa_start_time=0x%02x\n"
1246                                         , FUNC_ADPT_ARG(iface)
1247                                         , tmpBuf[2]
1248                                         , tmpBuf[3]
1249                                         , tmpBuf[4]
1250                                         , tmpBuf[5]
1251                                         ,pmccadapriv->noa_start_time);
1252                                 }
1253
1254                         rtw_hal_mcc_update_go_p2p_ie(iface);
1255
1256                         break;
1257                 }
1258         }
1259
1260 }
1261
1262 /**
1263  * rtw_hal_mcc_c2h_handler - mcc c2h handler
1264  */
1265 void rtw_hal_mcc_c2h_handler(PADAPTER padapter, u8 buflen, u8 *tmpBuf)
1266 {
1267         struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
1268         struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
1269         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
1270         struct submit_ctx *mcc_sctx = &pmccobjpriv->mcc_sctx;
1271         _irqL irqL;
1272
1273         /* RTW_INFO("[length]=%d, [C2H data]="MAC_FMT"\n", buflen, MAC_ARG(tmpBuf)); */
1274         /* To avoid reg is set, but driver recive c2h to set wrong oper_channel */
1275         if (MCC_RPT_STOPMCC == pmccobjpriv->mcc_c2h_status) {
1276                 RTW_INFO(FUNC_ADPT_FMT" MCC alread stops return\n", FUNC_ADPT_ARG(padapter));
1277                 return;
1278         }
1279
1280         pmccobjpriv->mcc_c2h_status = tmpBuf[0];
1281         switch (pmccobjpriv->mcc_c2h_status) {
1282         case MCC_RPT_SUCCESS:
1283                 pdvobjpriv->oper_channel = tmpBuf[1];
1284                 _enter_critical_bh(&pmccobjpriv->mcc_lock, &irqL);
1285                 pmccobjpriv->cur_mcc_success_cnt++;
1286                 _exit_critical_bh(&pmccobjpriv->mcc_lock, &irqL);
1287                 break;
1288         case MCC_RPT_TXNULL_FAIL:
1289                 RTW_INFO("[MCC] TXNULL FAIL\n");
1290                 break;
1291         case MCC_RPT_STOPMCC:
1292                 RTW_INFO("[MCC] MCC stop (time:%d)\n", rtw_get_current_time());
1293                 pmccobjpriv->mcc_c2h_status = MCC_RPT_STOPMCC;
1294                 rtw_sctx_done(&mcc_sctx);
1295                 break;
1296         case MCC_RPT_READY:
1297                 _enter_critical_bh(&pmccobjpriv->mcc_lock, &irqL);
1298                 /* initialize counter & time */
1299                 pmccobjpriv->mcc_launch_time = rtw_get_current_time();
1300                 pmccobjpriv->mcc_c2h_status = MCC_RPT_READY;
1301                 pmccobjpriv->cur_mcc_success_cnt = 0;
1302                 pmccobjpriv->prev_mcc_success_cnt = 0;
1303                 pmccobjpriv->mcc_tolerance_time = MCC_TOLERANCE_TIME;
1304                 _exit_critical_bh(&pmccobjpriv->mcc_lock, &irqL);
1305
1306                 RTW_INFO("[MCC] MCC ready (time:%d)\n", pmccobjpriv->mcc_launch_time);
1307                 rtw_sctx_done(&mcc_sctx);
1308                 break;
1309         case MCC_RPT_SWICH_CHANNEL_NOTIFY:
1310                 pdvobjpriv->oper_channel = tmpBuf[1];
1311                 rtw_hal_mcc_sw_ch_fw_notify_hdl(padapter);
1312                 break;
1313         case MCC_RPT_UPDATE_NOA_START_TIME:
1314                 rtw_hal_mcc_update_noa_start_time_hdl(padapter, buflen, tmpBuf);
1315                 break;
1316         default:
1317                 /* RTW_INFO("[MCC] Other MCC status(%d)\n", pmccobjpriv->mcc_c2h_status); */
1318                 break;
1319         }
1320 }
1321
1322
1323 /**
1324  * rtw_hal_mcc_sw_status_check - check mcc swich channel status
1325  * @padapter: primary adapter
1326  */
1327 void rtw_hal_mcc_sw_status_check(PADAPTER padapter)
1328 {
1329         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1330         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
1331         struct pwrctrl_priv     *pwrpriv = dvobj_to_pwrctl(dvobj);
1332         u8 cur_cnt = 0, prev_cnt = 0, diff_cnt = 0, check_ret = _FAIL;
1333         _irqL irqL;
1334
1335 /* #define MCC_RESTART 1 */
1336
1337         if (!MCC_EN(padapter))
1338                 return;
1339
1340         _enter_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1341
1342         if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC)) {
1343
1344                 if (pwrpriv->pwr_mode != PS_MODE_ACTIVE) {
1345                         rtw_warn_on(1);
1346                         RTW_INFO("PS mode is not active under mcc, force exit ps mode\n");
1347                         LeaveAllPowerSaveModeDirect(padapter);
1348                 }
1349
1350                 if (rtw_get_passing_time_ms(pmccobjpriv->mcc_launch_time) > 2000) {
1351                         _enter_critical_bh(&pmccobjpriv->mcc_lock, &irqL);
1352
1353                         cur_cnt = pmccobjpriv->cur_mcc_success_cnt;
1354                         prev_cnt = pmccobjpriv->prev_mcc_success_cnt;
1355                         if (cur_cnt < prev_cnt)
1356                                 diff_cnt = (cur_cnt + 255) - prev_cnt;
1357                         else
1358                                 diff_cnt = cur_cnt - prev_cnt;
1359
1360                         if (diff_cnt < 30) {
1361                                 pmccobjpriv->mcc_tolerance_time--;
1362                                 RTW_INFO("%s: diff_cnt:%d, tolerance_time:%d\n",
1363                                         __func__, diff_cnt, pmccobjpriv->mcc_tolerance_time);
1364                         } else
1365                                 pmccobjpriv->mcc_tolerance_time = MCC_TOLERANCE_TIME;
1366
1367                         pmccobjpriv->prev_mcc_success_cnt = pmccobjpriv->cur_mcc_success_cnt;
1368
1369                         if (pmccobjpriv->mcc_tolerance_time != 0)
1370                                 check_ret = _SUCCESS;
1371
1372                         _exit_critical_bh(&pmccobjpriv->mcc_lock, &irqL);
1373
1374                         if (check_ret != _SUCCESS) {
1375                                 RTW_INFO("============ MCC swich channel check fail (%d)=============\n", diff_cnt);
1376                                 /* restart MCC */
1377                                 #ifdef MCC_RESTART
1378                                         rtw_hal_set_mcc_setting(padapter, MCC_SETCMD_STATUS_STOP_DISCONNECT);
1379                                         rtw_hal_set_mcc_setting(padapter, MCC_SETCMD_STATUS_START_CONNECT);
1380                                 #endif /* MCC_RESTART */
1381                         }
1382                 } else {
1383                         _enter_critical_bh(&pmccobjpriv->mcc_lock, &irqL);
1384                         pmccobjpriv->prev_mcc_success_cnt = pmccobjpriv->cur_mcc_success_cnt;
1385                         _exit_critical_bh(&pmccobjpriv->mcc_lock, &irqL);
1386                 }
1387
1388         }
1389         _exit_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1390 }
1391
1392 /**
1393  * rtw_hal_mcc_change_scan_flag - change scan flag under mcc
1394  *
1395  * MCC mode under sitesurvey goto AP channel to tx bcn & data
1396  * MCC mode under sitesurvey doesn't support TX data for station mode (FW not support)
1397  *
1398  * @padapter: the adapter to be change scan flag
1399  * @ch: pointer to rerurn ch
1400  * @bw: pointer to rerurn bw
1401  * @offset: pointer to rerurn offset
1402  */
1403 u8 rtw_hal_mcc_change_scan_flag(PADAPTER padapter, u8 *ch, u8 *bw, u8 *offset)
1404 {
1405         u8 need_ch_setting_union = _TRUE, i = 0, flags = 0, role = 0;
1406         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1407         struct mcc_adapter_priv *pmccadapriv = NULL;
1408         struct mlme_ext_priv *pmlmeext = NULL;
1409
1410         if (!MCC_EN(padapter))
1411                 goto exit;
1412
1413         if (!rtw_hal_check_mcc_status(padapter, MCC_STATUS_NEED_MCC))
1414                 goto exit;
1415
1416         for (i = 0; i < dvobj->iface_nums; i++) {
1417                 if (!dvobj->padapters[i])
1418                                 continue;
1419
1420                 pmlmeext = &dvobj->padapters[i]->mlmeextpriv;
1421                 pmccadapriv = &dvobj->padapters[i]->mcc_adapterpriv;
1422                 role = pmccadapriv->role;
1423
1424                 switch (role) {
1425                 case MCC_ROLE_AP:
1426                 case MCC_ROLE_GO:
1427                         *ch = pmlmeext->cur_channel;
1428                         *bw = pmlmeext->cur_bwmode;
1429                         *offset = pmlmeext->cur_ch_offset;
1430                         need_ch_setting_union = _FALSE;
1431                         break;
1432                 case MCC_ROLE_STA:
1433                 case MCC_ROLE_GC:
1434                         break;
1435                 default:
1436                         RTW_INFO("unknown role\n");
1437                         rtw_warn_on(1);
1438                         break;
1439                 }
1440
1441                 /* check other scan flag */
1442                 flags = mlmeext_scan_backop_flags(pmlmeext);
1443                 if (mlmeext_chk_scan_backop_flags(pmlmeext, SS_BACKOP_PS_ANNC))
1444                         flags &= ~SS_BACKOP_PS_ANNC;
1445
1446                 if (mlmeext_chk_scan_backop_flags(pmlmeext, SS_BACKOP_TX_RESUME))
1447                         flags &= ~SS_BACKOP_TX_RESUME;
1448
1449                 mlmeext_assign_scan_backop_flags(pmlmeext, flags);
1450
1451         }
1452 exit:
1453         return need_ch_setting_union;
1454 }
1455
1456 /**
1457  * rtw_hal_mcc_calc_tx_bytes_from_kernel - calculte tx bytes from kernel to check concurrent tx or not
1458  * @padapter: the adapter to be record tx bytes
1459  * @len: data len
1460  */
1461 inline void rtw_hal_mcc_calc_tx_bytes_from_kernel(PADAPTER padapter, u32 len)
1462 {
1463         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
1464
1465         if (MCC_EN(padapter)) {
1466                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC)) {
1467                         pmccadapriv->mcc_tx_bytes_from_kernel += len;
1468                         if (0)
1469                                 RTW_INFO("%s(order:%d): mcc tx bytes from kernel:%lld\n"
1470                                         , __func__, pmccadapriv->order, pmccadapriv->mcc_tx_bytes_from_kernel);
1471                 }
1472         }
1473 }
1474
1475 /**
1476  * rtw_hal_mcc_calc_tx_bytes_to_port - calculte tx bytes to write port in order to flow crtl
1477  * @padapter: the adapter to be record tx bytes
1478  * @len: data len
1479  */
1480 inline void rtw_hal_mcc_calc_tx_bytes_to_port(PADAPTER padapter, u32 len)
1481 {
1482         if (MCC_EN(padapter)) {
1483                 struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
1484                 struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
1485
1486                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC))
1487                         pmccadapriv->mcc_tx_bytes_to_port += len;
1488                         if (0)
1489                                 RTW_INFO("%s(order:%d): mcc tx bytes to port:%d, mcc target tx bytes to port:%d\n"
1490                                         , __func__, pmccadapriv->order, pmccadapriv->mcc_tx_bytes_to_port
1491                                         , pmccadapriv->mcc_target_tx_bytes_to_port);
1492                 }
1493 }
1494
1495 /**
1496  * rtw_hal_mcc_stop_tx_bytes_to_port - stop write port to hw or not
1497  * @padapter: the adapter to be stopped
1498  */
1499 inline u8 rtw_hal_mcc_stop_tx_bytes_to_port(PADAPTER padapter)
1500 {
1501         if (MCC_EN(padapter)) {
1502                 struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
1503                 struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
1504
1505                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC)) {
1506                         if (pmccadapriv->mcc_tp_limit) {
1507                                 if (pmccadapriv->mcc_tx_bytes_to_port >= pmccadapriv->mcc_target_tx_bytes_to_port) {
1508                                         pmccadapriv->mcc_tx_stop = _TRUE;
1509                                         rtw_netif_stop_queue(padapter->pnetdev);
1510                                         return _TRUE;
1511                                 }
1512                         }
1513                 }
1514         }
1515
1516         return _FALSE;
1517 }
1518
1519 /**
1520  * rtw_hal_set_mcc_setting_scan_start - setting mcc under scan start
1521  * @padapter: the adapter to be setted
1522  * @ch_setting_changed: softap channel setting to be changed or not
1523  */
1524 u8 rtw_hal_set_mcc_setting_scan_start(PADAPTER padapter)
1525 {
1526         u8 ret = _FAIL;
1527
1528         if (MCC_EN(padapter)) {
1529                 struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
1530
1531                 _enter_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1532                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_NEED_MCC)) {
1533                         if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC)) {
1534                                 ret = rtw_hal_set_mcc_setting(padapter,  MCC_SETCMD_STATUS_STOP_SCAN_START);
1535                                 /* issue null data to all station connected to AP before scan */
1536                                 rtw_hal_mcc_issue_null_data(padapter, 0, 1);
1537                         }
1538                 }
1539                 _exit_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1540         }
1541
1542         return ret;
1543 }
1544
1545 /**
1546  * rtw_hal_set_mcc_setting_scan_complete - setting mcc after scan commplete
1547  * @padapter: the adapter to be setted
1548  * @ch_setting_changed: softap channel setting to be changed or not
1549  */
1550 u8 rtw_hal_set_mcc_setting_scan_complete(PADAPTER padapter)
1551 {
1552         u8 ret = _FAIL;
1553
1554         if (MCC_EN(padapter)) {
1555                 struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
1556
1557                 _enter_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1558
1559                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_NEED_MCC))
1560                                 ret = rtw_hal_set_mcc_setting(padapter,  MCC_SETCMD_STATUS_START_SCAN_DONE);
1561
1562                 _exit_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1563         }
1564
1565         return ret;
1566 }
1567
1568
1569 /**
1570  * rtw_hal_set_mcc_setting_start_bss_network - setting mcc under softap start
1571  * @padapter: the adapter to be setted
1572  * @chbw_grouped: channel bw offset can not be allowed or not
1573  */
1574 u8 rtw_hal_set_mcc_setting_start_bss_network(PADAPTER padapter, u8 chbw_allow)
1575 {
1576         u8 ret = _FAIL;
1577
1578         if (MCC_EN(padapter)) {
1579                 /* channel bw offset can not be allowed, start MCC */
1580                 if (chbw_allow == _FALSE) {
1581                                 struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
1582
1583                                 rtw_hal_mcc_restore_iqk_val(padapter);
1584                                 _enter_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1585                                 ret = rtw_hal_set_mcc_setting(padapter, MCC_SETCMD_STATUS_START_CONNECT);
1586                                 _exit_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1587                         }
1588                 }
1589
1590         return ret;
1591 }
1592
1593 /**
1594  * rtw_hal_set_mcc_setting_disconnect - setting mcc under mlme disconnect(stop softap/disconnect from AP)
1595  * @padapter: the adapter to be setted
1596  */
1597 u8 rtw_hal_set_mcc_setting_disconnect(PADAPTER padapter)
1598 {
1599         u8 ret = _FAIL;
1600
1601         if (MCC_EN(padapter)) {
1602                 struct mcc_obj_priv *pmccobjpriv = &(adapter_to_dvobj(padapter)->mcc_objpriv);
1603
1604                 _enter_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1605                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_NEED_MCC)) {
1606                         if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC))
1607                                 ret = rtw_hal_set_mcc_setting(padapter,  MCC_SETCMD_STATUS_STOP_DISCONNECT);
1608                 }
1609                 _exit_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1610         }
1611
1612         return ret;
1613 }
1614
1615 /**
1616  * rtw_hal_set_mcc_setting_join_done_chk_ch - setting mcc under join done
1617  * @padapter: the adapter to be checked
1618  */
1619 u8 rtw_hal_set_mcc_setting_join_done_chk_ch(PADAPTER padapter)
1620 {
1621         u8 ret = _FAIL;
1622
1623         if (MCC_EN(padapter)) {
1624                 struct mi_state mstate;
1625
1626                 rtw_mi_status_no_self(padapter, &mstate);
1627
1628                 if (MSTATE_STA_LD_NUM(&mstate) || MSTATE_STA_LG_NUM(&mstate) || MSTATE_AP_NUM(&mstate)) {
1629                         bool chbw_allow = _TRUE;
1630                         u8 u_ch, u_offset, u_bw;
1631                         struct mlme_ext_priv *cur_mlmeext = &padapter->mlmeextpriv;
1632                         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1633
1634                         if (rtw_mi_get_ch_setting_union_no_self(padapter, &u_ch, &u_bw, &u_offset) <= 0) {
1635                                 dump_adapters_status(RTW_DBGDUMP , dvobj);
1636                                 rtw_warn_on(1);
1637                         }
1638
1639                         RTW_INFO(FUNC_ADPT_FMT" union no self: %u,%u,%u\n"
1640                                 , FUNC_ADPT_ARG(padapter), u_ch, u_bw, u_offset);
1641
1642                         /* chbw_allow? */
1643                         chbw_allow = rtw_is_chbw_grouped(cur_mlmeext->cur_channel
1644                                 , cur_mlmeext->cur_bwmode, cur_mlmeext->cur_ch_offset
1645                                         , u_ch, u_bw, u_offset);
1646
1647                         RTW_INFO(FUNC_ADPT_FMT" chbw_allow:%d\n"
1648                                 , FUNC_ADPT_ARG(padapter), chbw_allow);
1649
1650                         /* if chbw_allow = false, start MCC setting */
1651                         if (chbw_allow == _FALSE) {
1652                                 struct mcc_obj_priv *pmccobjpriv = &dvobj->mcc_objpriv;
1653
1654                                 rtw_hal_mcc_restore_iqk_val(padapter);
1655                                 _enter_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1656                                 ret = rtw_hal_set_mcc_setting(padapter, MCC_SETCMD_STATUS_START_CONNECT);
1657                                 _exit_critical_mutex(&pmccobjpriv->mcc_mutex, NULL);
1658                         }
1659                 }
1660         }
1661
1662         return ret;
1663 }
1664
1665 /**
1666  * rtw_hal_set_mcc_setting_chk_start_clnt_join - check change channel under start clnt join
1667  * @padapter: the adapter to be checked
1668  * @ch: pointer to rerurn ch
1669  * @bw: pointer to rerurn bw
1670  * @offset: pointer to rerurn offset
1671  * @chbw_allow: allow to use adapter's channel setting
1672  */
1673 u8 rtw_hal_set_mcc_setting_chk_start_clnt_join(PADAPTER padapter, u8 *ch, u8 *bw, u8 *offset, u8 chbw_allow)
1674 {
1675         u8 ret = _FAIL;
1676
1677         /* if chbw_allow = false under en_mcc = TRUE, we do not change channel related setting  */
1678         if (MCC_EN(padapter)) {
1679                 /* restore union channel related setting to current channel related setting */
1680                 if (chbw_allow == _FALSE) {
1681                         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1682
1683                         *ch = pmlmeext->cur_channel;
1684                         *bw = pmlmeext->cur_bwmode;
1685                         *offset = pmlmeext->cur_ch_offset;
1686
1687                         RTW_INFO(FUNC_ADPT_FMT" en_mcc:%d(%d,%d,%d,)\n"
1688                                 , FUNC_ADPT_ARG(padapter), padapter->registrypriv.en_mcc
1689                                 , *ch, *bw, *offset);
1690                         ret = _SUCCESS;
1691                 }
1692         }
1693
1694         return ret;
1695 }
1696
1697 static void rtw_hal_mcc_dump_noa_content(void *sel, PADAPTER padapter)
1698 {
1699         struct mcc_adapter_priv *pmccadapriv = NULL;
1700         u8 *pos = NULL;
1701         pmccadapriv = &padapter->mcc_adapterpriv;
1702         /* last position for NoA attribute */
1703         pos = pmccadapriv->p2p_go_noa_ie + pmccadapriv->p2p_go_noa_ie_len;
1704
1705
1706         RTW_PRINT_SEL(sel, "\nStart to dump NoA Content\n");
1707         RTW_PRINT_SEL(sel, "NoA Counts:%d\n", *(pos - 13));
1708         RTW_PRINT_SEL(sel, "NoA Duration(TU):%d\n", (RTW_GET_LE32(pos - 12))/TU);
1709         RTW_PRINT_SEL(sel, "NoA Interval(TU):%d\n", (RTW_GET_LE32(pos - 8))/TU);
1710         RTW_PRINT_SEL(sel, "NoA Start time(microseconds):0x%02x\n", RTW_GET_LE32(pos - 4));
1711         RTW_PRINT_SEL(sel, "End to dump NoA Content\n");
1712 }
1713
1714 void rtw_hal_dump_mcc_info(void *sel, struct dvobj_priv *dvobj)
1715 {
1716         struct mcc_obj_priv *pmccobjpriv = &(dvobj->mcc_objpriv);
1717         struct mcc_adapter_priv *pmccadapriv = NULL;
1718         _adapter *iface = NULL, *adapter = NULL;
1719         struct registry_priv *regpriv = NULL;
1720         u8 i = 0;
1721
1722         /* regpriv is common for all adapter */
1723         adapter = dvobj->padapters[IFACE_ID0];
1724
1725         RTW_PRINT_SEL(sel, "**********************************************\n");
1726         for (i = 0; i < dvobj->iface_nums; i++) {
1727                 iface = dvobj->padapters[i];
1728                 if (!iface)
1729                         continue;
1730
1731                 regpriv = &iface->registrypriv;
1732                 pmccadapriv = &iface->mcc_adapterpriv;
1733                 if (pmccadapriv) {
1734                         RTW_PRINT_SEL(sel, "adapter mcc info:\n");
1735                         RTW_PRINT_SEL(sel, "ifname:%s\n", ADPT_ARG(iface));
1736                         RTW_PRINT_SEL(sel, "order:%d\n", pmccadapriv->order);
1737                         RTW_PRINT_SEL(sel, "duration:%d\n", pmccadapriv->mcc_duration);
1738                         RTW_PRINT_SEL(sel, "target tx bytes:%d\n", pmccadapriv->mcc_target_tx_bytes_to_port);
1739                         RTW_PRINT_SEL(sel, "current TP:%d\n", pmccadapriv->mcc_tp);
1740                         RTW_PRINT_SEL(sel, "mgmt queue macid:%d\n", pmccadapriv->mgmt_queue_macid);
1741                         RTW_PRINT_SEL(sel, "macid bitmap:0x%02x\n\n", pmccadapriv->mcc_macid_bitmap);
1742                         RTW_PRINT_SEL(sel, "registry data:\n");
1743                         RTW_PRINT_SEL(sel, "en_mcc:%d\n", regpriv->en_mcc);
1744                         RTW_PRINT_SEL(sel, "ap target tx TP(BW:20M):%d Mbps\n", regpriv->rtw_mcc_ap_bw20_target_tx_tp);
1745                         RTW_PRINT_SEL(sel, "ap target tx TP(BW:40M):%d Mbps\n", regpriv->rtw_mcc_ap_bw40_target_tx_tp);
1746                         RTW_PRINT_SEL(sel, "ap target tx TP(BW:80M):%d Mbps\n", regpriv->rtw_mcc_ap_bw80_target_tx_tp);
1747                         RTW_PRINT_SEL(sel, "sta target tx TP(BW:20M):%d Mbps\n", regpriv->rtw_mcc_sta_bw20_target_tx_tp);
1748                         RTW_PRINT_SEL(sel, "sta target tx TP(BW:40M ):%d Mbps\n", regpriv->rtw_mcc_sta_bw40_target_tx_tp);
1749                         RTW_PRINT_SEL(sel, "sta target tx TP(BW:80M):%d Mbps\n", regpriv->rtw_mcc_sta_bw80_target_tx_tp);
1750                         RTW_PRINT_SEL(sel, "single tx criteria:%d Mbps\n", regpriv->rtw_mcc_single_tx_cri);
1751                         if (MLME_IS_GO(iface))
1752                                 rtw_hal_mcc_dump_noa_content(sel, iface);
1753                         RTW_PRINT_SEL(sel, "**********************************************\n");
1754                 }
1755         }
1756         RTW_PRINT_SEL(sel, "------------------------------------------\n");
1757         RTW_PRINT_SEL(sel, "policy index:%d\n", pmccobjpriv->policy_index);
1758         RTW_PRINT_SEL(sel, "------------------------------------------\n");
1759         RTW_PRINT_SEL(sel, "define data:\n");
1760         RTW_PRINT_SEL(sel, "ap target tx TP(BW:20M):%d Mbps\n", MCC_AP_BW20_TARGET_TX_TP);
1761         RTW_PRINT_SEL(sel, "ap target tx TP(BW:40M):%d Mbps\n", MCC_AP_BW40_TARGET_TX_TP);
1762         RTW_PRINT_SEL(sel, "ap target tx TP(BW:80M):%d Mbps\n", MCC_AP_BW80_TARGET_TX_TP);
1763         RTW_PRINT_SEL(sel, "sta target tx TP(BW:20M):%d Mbps\n", MCC_STA_BW20_TARGET_TX_TP);
1764         RTW_PRINT_SEL(sel, "sta target tx TP(BW:40M):%d Mbps\n", MCC_STA_BW40_TARGET_TX_TP);
1765         RTW_PRINT_SEL(sel, "sta target tx TP(BW:80M):%d Mbps\n", MCC_STA_BW80_TARGET_TX_TP);
1766         RTW_PRINT_SEL(sel, "single tx criteria:%d Mbps\n", MCC_SINGLE_TX_CRITERIA);
1767         RTW_PRINT_SEL(sel, "------------------------------------------\n");
1768 }
1769
1770 inline void update_mcc_mgntframe_attrib(_adapter *padapter, struct pkt_attrib *pattrib)
1771 {
1772         if (MCC_EN(padapter)) {
1773                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC)) {
1774                         /* use QSLT_MGNT to check mgnt queue or bcn queue */
1775                         if (pattrib->qsel == QSLT_MGNT) {
1776                                 pattrib->mac_id = padapter->mcc_adapterpriv.mgmt_queue_macid;
1777                                 pattrib->qsel = QSLT_VO;
1778                         }
1779                 }
1780         }
1781 }
1782
1783 inline u8 rtw_hal_mcc_link_status_chk(_adapter *padapter, const char *msg)
1784 {
1785         u8 ret = _TRUE, i = 0;
1786         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1787         _adapter *iface;
1788         struct mlme_ext_priv *mlmeext;
1789
1790         if (MCC_EN(padapter)) {
1791                 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_NEED_MCC)) {
1792                         for (i = 0; i < dvobj->iface_nums; i++) {
1793                                 iface = dvobj->padapters[i];
1794                                 mlmeext = &iface->mlmeextpriv;
1795                                 if (mlmeext_scan_state(mlmeext) != SCAN_DISABLE) {
1796                                         #ifdef DBG_EXPIRATION_CHK
1797                                                 RTW_INFO(FUNC_ADPT_FMT" don't enter %s under scan for MCC mode\n", FUNC_ADPT_ARG(padapter), msg);
1798                                         #endif
1799                                         ret = _FALSE;
1800                                         goto exit;
1801                                 }
1802                         }
1803                 }
1804         }
1805
1806 exit:
1807         return ret;
1808 }
1809
1810 void rtw_hal_mcc_issue_null_data(_adapter *padapter, u8 chbw_allow, u8 ps_mode)
1811 {
1812         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1813         _adapter *iface = NULL;
1814         u32 start = rtw_get_current_time();
1815         u8 i = 0;
1816
1817         if (!MCC_EN(padapter))
1818                 return;
1819
1820         if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC))
1821                 return;
1822
1823         if (chbw_allow == _TRUE)
1824                 return;
1825
1826         for (i = 0; i < dvobj->iface_nums; i++) {
1827                 iface = dvobj->padapters[i];
1828                 /* issue null data to inform ap station will leave */
1829                 if (is_client_associated_to_ap(iface)) {
1830                         struct mlme_ext_priv *mlmeext = &iface->mlmeextpriv;
1831                         u8 ch = mlmeext->cur_channel;
1832                         u8 bw = mlmeext->cur_bwmode;
1833                         u8 offset = mlmeext->cur_ch_offset;
1834
1835                         set_channel_bwmode(iface, ch, bw, offset);
1836                         issue_nulldata(iface, NULL, ps_mode, 3, 50);
1837                 }
1838         }
1839         RTW_INFO("%s(%d ms)\n", __func__, rtw_get_passing_time_ms(start));
1840 }
1841
1842 u8 *rtw_hal_mcc_append_go_p2p_ie(PADAPTER padapter, u8 *pframe, u32 *len)
1843 {
1844         struct mcc_adapter_priv *pmccadapriv = &padapter->mcc_adapterpriv;
1845
1846         if (!MCC_EN(padapter))
1847                 return pframe;
1848
1849         if (!rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC))
1850                 return pframe;
1851
1852         if (pmccadapriv->p2p_go_noa_ie_len == 0)
1853                 return pframe;
1854
1855         _rtw_memcpy(pframe, pmccadapriv->p2p_go_noa_ie, pmccadapriv->p2p_go_noa_ie_len);
1856         *len = *len + pmccadapriv->p2p_go_noa_ie_len;
1857
1858         return pframe + pmccadapriv->p2p_go_noa_ie_len;
1859 }
1860
1861 void rtw_hal_dump_mcc_policy_table(void *sel)
1862 {
1863         u8 idx = 0;
1864         RTW_PRINT_SEL(sel, "duration\t,tsf sync offset\t,start time offset\t,interval\t,guard offset0\t,guard offset1\n");
1865
1866         for (idx = 0; idx < mcc_max_policy_num; idx ++) {
1867                 RTW_PRINT_SEL(sel, "%d\t\t,%d\t\t\t,%d\t\t\t,%d\t\t,%d\t\t,%d\n"
1868                         , mcc_switch_channel_policy_table[idx][MCC_DURATION_IDX]
1869                         , mcc_switch_channel_policy_table[idx][MCC_TSF_SYNC_OFFSET_IDX]
1870                         , mcc_switch_channel_policy_table[idx][MCC_START_TIME_OFFSET_IDX]
1871                         , mcc_switch_channel_policy_table[idx][MCC_INTERVAL_IDX]
1872                         , mcc_switch_channel_policy_table[idx][MCC_GUARD_OFFSET0_IDX]
1873                         , mcc_switch_channel_policy_table[idx][MCC_GUARD_OFFSET1_IDX]);
1874         }
1875 }
1876
1877 #endif /* CONFIG_MCC_MODE */