rtl8812au/hal/phydm/phydm_debug.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 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  ******************************************************************************/
  20
  21 /* ************************************************************
  22  * include files
  23  * ************************************************************ */
  24
  25 #include "mp_precomp.h"
  26 #include "phydm_precomp.h"
  27
  28 void
  29 phydm_init_debug_setting(
  30         struct PHY_DM_STRUCT            *p_dm_odm
  31 )
  32 {
  33         p_dm_odm->debug_level = ODM_DBG_TRACE;
  34
  35         p_dm_odm->fw_debug_components = 0;
  36         p_dm_odm->debug_components                      =
  37                 \
  38 #if DBG
  39                 /*BB Functions*/
  40                 /*                                                                      ODM_COMP_DIG                                    |*/
  41                 /*                                                                      ODM_COMP_RA_MASK                                |*/
  42                 /*                                                                      ODM_COMP_DYNAMIC_TXPWR                  |*/
  43                 /*                                                                      ODM_COMP_FA_CNT                         |*/
  44                 /*                                                                      ODM_COMP_RSSI_MONITOR                   |*/
  45                 /*                                                                      ODM_COMP_SNIFFER                                |*/
  46                 /*                                                                      ODM_COMP_ANT_DIV                                |*/
  47                 /*                                                                      ODM_COMP_NOISY_DETECT                   |*/
  48                 /*                                                                      ODM_COMP_RATE_ADAPTIVE                  |*/
  49                 /*                                                                      ODM_COMP_PATH_DIV                               |*/
  50                 /*                                                                      ODM_COMP_DYNAMIC_PRICCA         |*/
  51                 /*                                                                      ODM_COMP_MP                                     |*/
  52                 /*                                                                      ODM_COMP_CFO_TRACKING                   |*/
  53                 /*                                                                      ODM_COMP_ACS                                    |*/
  54                 /*                                                                      PHYDM_COMP_ADAPTIVITY                   |*/
  55                 /*                                                                      PHYDM_COMP_RA_DBG                               |*/
  56                 /*                                                                      PHYDM_COMP_TXBF                                 |*/
  57
  58                 /*MAC Functions*/
  59                 /*                                                                      ODM_COMP_EDCA_TURBO                     |*/
  60                 /*                                                                      ODM_COMP_DYNAMIC_RX_PATH                |*/
  61                 /*                                                                      ODM_FW_DEBUG_TRACE                              |*/
  62
  63                 /*RF Functions*/
  64                 /*                                                                      ODM_COMP_TX_PWR_TRACK                   |*/
  65                 /*                                                                      ODM_COMP_CALIBRATION                    |*/
  66
  67                 /*Common*/
  68                 /*                                                                      ODM_PHY_CONFIG                                  |*/
  69                 /*                                                                      ODM_COMP_INIT                                   |*/
  70                 /*                                                                      ODM_COMP_COMMON                         |*/
  71                 /*                                                                      ODM_COMP_API                            |*/
  72
  73
  74 #endif
  75                 0;
  76
  77         p_dm_odm->fw_buff_is_enpty = true;
  78         p_dm_odm->pre_c2h_seq = 0;
  79 }
  80
  81 void
  82 phydm_bb_dbg_port_header_sel(
  83         void                    *p_dm_void,
  84         u32                     header_idx
  85 ) {
  86         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
  87
  88         if (p_dm_odm->support_ic_type & ODM_IC_11AC_SERIES) {
  89
  90                 odm_set_bb_reg(p_dm_odm, 0x8f8, (BIT(25) | BIT(24) | BIT(23) | BIT(22)), header_idx);
  91
  92                 /*
  93                 header_idx:
  94                         (0:) '{ofdm_dbg[31:0]}'
  95                         (1:) '{cca,crc32_fail,dbg_ofdm[29:0]}'
  96                         (2:) '{vbon,crc32_fail,dbg_ofdm[29:0]}'
  97                         (3:) '{cca,crc32_ok,dbg_ofdm[29:0]}'
  98                         (4:) '{vbon,crc32_ok,dbg_ofdm[29:0]}'
  99                         (5:) '{dbg_iqk_anta}'
 100                         (6:) '{cca,ofdm_crc_ok,dbg_dp_anta[29:0]}'
 101                         (7:) '{dbg_iqk_antb}'
 102                         (8:) '{DBGOUT_RFC_b[31:0]}'
 103                         (9:) '{DBGOUT_RFC_a[31:0]}'
 104                         (a:) '{dbg_ofdm}'
 105                         (b:) '{dbg_cck}'
 106                 */
 107         }
 108 }
 109
 110 void
 111 phydm_bb_dbg_port_clock_en(
 112         void                    *p_dm_void,
 113         u8                      enable
 114 ) {
 115         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
 116         u32             reg_value = 0;
 117
 118         if (p_dm_odm->support_ic_type & (ODM_RTL8822B | ODM_RTL8821C | ODM_RTL8814A | ODM_RTL8814B)) {
 119
 120                 reg_value = (enable == true) ? 0x7 : 0;
 121                 odm_set_bb_reg(p_dm_odm, 0x198c, 0x7, reg_value); /*enable/disable debug port clock, for power saving*/
 122         }
 123 }
 124
 125 u8
 126 phydm_set_bb_dbg_port(
 127         void                    *p_dm_void,
 128         u8                      curr_dbg_priority,
 129         u32                     debug_port
 130 )
 131 {
 132         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
 133         u8      dbg_port_result = false;
 134
 135         if (curr_dbg_priority > p_dm_odm->pre_dbg_priority) {
 136
 137                 if (p_dm_odm->support_ic_type & ODM_IC_11AC_SERIES) {
 138
 139                         phydm_bb_dbg_port_clock_en(p_dm_odm, TRUE);
 140
 141                         odm_set_bb_reg(p_dm_odm, 0x8fc, MASKDWORD, debug_port);
 142                         /**/
 143                 } else /*if (p_dm_odm->support_ic_type & ODM_IC_11N_SERIES)*/ {
 144                         odm_set_bb_reg(p_dm_odm, 0x908, MASKDWORD, debug_port);
 145                         /**/
 146                 }
 147                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_API, ODM_DBG_LOUD, ("DbgPort set success, Reg((0x%x)), Cur_priority=((%d)), Pre_priority=((%d))\n", debug_port, curr_dbg_priority, p_dm_odm->pre_dbg_priority));
 148                 p_dm_odm->pre_dbg_priority = curr_dbg_priority;
 149                 dbg_port_result = true;
 150         }
 151
 152         return dbg_port_result;
 153 }
 154
 155 void
 156 phydm_release_bb_dbg_port(
 157         void                    *p_dm_void
 158 )
 159 {
 160         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
 161
 162         phydm_bb_dbg_port_clock_en(p_dm_odm, FALSE);
 163         phydm_bb_dbg_port_header_sel(p_dm_odm, 0);
 164
 165         p_dm_odm->pre_dbg_priority = BB_DBGPORT_RELEASE;
 166         ODM_RT_TRACE(p_dm_odm, ODM_COMP_API, ODM_DBG_LOUD, ("Release BB dbg_port\n"));
 167 }
 168
 169 u32
 170 phydm_get_bb_dbg_port_value(
 171         void                    *p_dm_void
 172 )
 173 {
 174         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
 175         u32     dbg_port_value = 0;
 176
 177         if (p_dm_odm->support_ic_type & ODM_IC_11AC_SERIES) {
 178                 dbg_port_value = odm_get_bb_reg(p_dm_odm, 0xfa0, MASKDWORD);
 179                 /**/
 180         } else /*if (p_dm_odm->support_ic_type & ODM_IC_11N_SERIES)*/ {
 181                 dbg_port_value = odm_get_bb_reg(p_dm_odm, 0xdf4, MASKDWORD);
 182                 /**/
 183         }
 184         ODM_RT_TRACE(p_dm_odm, ODM_COMP_API, ODM_DBG_LOUD, ("dbg_port_value = 0x%x\n", dbg_port_value));
 185         return  dbg_port_value;
 186 }
 187
 188 #if CONFIG_PHYDM_DEBUG_FUNCTION
 189 void
 190 phydm_bb_rx_hang_info(
 191         void                    *p_dm_void,
 192         u32                     *_used,
 193         char                            *output,
 194         u32                     *_out_len
 195 )
 196 {
 197         u32     value32 = 0;
 198         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
 199         u32 used = *_used;
 200         u32 out_len = *_out_len;
 201
 202         if (p_dm_odm->support_ic_type & ODM_IC_11N_SERIES)
 203                 return;
 204
 205         value32 = odm_get_bb_reg(p_dm_odm, 0xF80, MASKDWORD);
 206         PHYDM_SNPRINTF((output + used, out_len - used,  "\r\n %-35s = 0x%x", "rptreg of sc/bw/ht/...", value32));
 207
 208         if (p_dm_odm->support_ic_type & ODM_RTL8822B)
 209                 odm_set_bb_reg(p_dm_odm, 0x198c, BIT(2) | BIT(1) | BIT(0), 7);
 210
 211         /* dbg_port = basic state machine */
 212         {
 213                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0x000);
 214                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 215                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 216
 217                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 218                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "basic state machine", value32));
 219         }
 220
 221         /* dbg_port = state machine */
 222         {
 223                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0x007);
 224                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 225                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 226
 227                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 228                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "state machine", value32));
 229         }
 230
 231         /* dbg_port = CCA-related*/
 232         {
 233                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0x204);
 234                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 235                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 236
 237                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 238                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "CCA-related", value32));
 239         }
 240
 241
 242         /* dbg_port = edcca/rxd*/
 243         {
 244                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0x278);
 245                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 246                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 247
 248                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 249                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "edcca/rxd", value32));
 250         }
 251
 252         /* dbg_port = rx_state/mux_state/ADC_MASK_OFDM*/
 253         {
 254                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0x290);
 255                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 256                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 257
 258                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 259                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "rx_state/mux_state/ADC_MASK_OFDM", value32));
 260         }
 261
 262         /* dbg_port = bf-related*/
 263         {
 264                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0x2B2);
 265                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 266                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 267
 268                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 269                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "bf-related", value32));
 270         }
 271
 272         /* dbg_port = bf-related*/
 273         {
 274                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0x2B8);
 275                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 276                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 277
 278                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 279                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "bf-related", value32));
 280         }
 281
 282         /* dbg_port = txon/rxd*/
 283         {
 284                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xA03);
 285                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 286                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 287
 288                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 289                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "txon/rxd", value32));
 290         }
 291
 292         /* dbg_port = l_rate/l_length*/
 293         {
 294                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xA0B);
 295                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 296                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 297
 298                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 299                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "l_rate/l_length", value32));
 300         }
 301
 302         /* dbg_port = rxd/rxd_hit*/
 303         {
 304                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xA0D);
 305                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 306                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 307
 308                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 309                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "rxd/rxd_hit", value32));
 310         }
 311
 312         /* dbg_port = dis_cca*/
 313         {
 314                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xAA0);
 315                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 316                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 317
 318                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 319                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "dis_cca", value32));
 320         }
 321
 322
 323         /* dbg_port = tx*/
 324         {
 325                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xAB0);
 326                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 327                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 328
 329                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 330                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "tx", value32));
 331         }
 332
 333         /* dbg_port = rx plcp*/
 334         {
 335                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xAD0);
 336                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 337                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 338
 339                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 340                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "rx plcp", value32));
 341
 342                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xAD1);
 343                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 344                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 345
 346                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 347                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "rx plcp", value32));
 348
 349                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xAD2);
 350                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 351                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 352
 353                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 354                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "rx plcp", value32));
 355
 356                 odm_set_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD, 0xAD3);
 357                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_DBG_RPT_11AC, MASKDWORD);
 358                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "0x8fc", value32));
 359
 360                 value32 = odm_get_bb_reg(p_dm_odm, ODM_REG_RPT_11AC, MASKDWORD);
 361                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = 0x%x", "rx plcp", value32));
 362         }
 363
 364 }
 365
 366 void
 367 phydm_bb_debug_info_n_series(
 368         void                    *p_dm_void,
 369         u32                     *_used,
 370         char                            *output,
 371         u32                     *_out_len
 372 )
 373 {
 374         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
 375         u32 used = *_used;
 376         u32 out_len = *_out_len;
 377
 378         u32     value32 = 0, value32_1 = 0, value32_2 = 0, value32_3 = 0;
 379         u8      rf_gain_a = 0, rf_gain_b = 0, rf_gain_c = 0, rf_gain_d = 0;
 380         u8      rx_snr_a = 0, rx_snr_b = 0, rx_snr_c = 0, rx_snr_d = 0;
 381
 382         s8    rxevm_0 = 0, rxevm_1 = 0;
 383         s32     short_cfo_a = 0, short_cfo_b = 0, long_cfo_a = 0, long_cfo_b = 0;
 384         s32     scfo_a = 0, scfo_b = 0, avg_cfo_a = 0, avg_cfo_b = 0;
 385         s32     cfo_end_a = 0, cfo_end_b = 0, acq_cfo_a = 0, acq_cfo_b = 0;
 386
 387         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s\n", "BB Report Info"));
 388
 389         /*AGC result*/
 390         value32 = odm_get_bb_reg(p_dm_odm, 0xdd0, MASKDWORD);
 391         rf_gain_a = (u8)(value32 & 0x3f);
 392         rf_gain_a = rf_gain_a << 1;
 393
 394         rf_gain_b = (u8)((value32 >> 8) & 0x3f);
 395         rf_gain_b = rf_gain_b << 1;
 396
 397         rf_gain_c = (u8)((value32 >> 16) & 0x3f);
 398         rf_gain_c = rf_gain_c << 1;
 399
 400         rf_gain_d = (u8)((value32 >> 24) & 0x3f);
 401         rf_gain_d = rf_gain_d << 1;
 402
 403         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d / %d", "OFDM RX RF Gain(A/B/C/D)", rf_gain_a, rf_gain_b, rf_gain_c, rf_gain_d));
 404
 405         /*SNR report*/
 406         value32 = odm_get_bb_reg(p_dm_odm, 0xdd4, MASKDWORD);
 407         rx_snr_a = (u8)(value32 & 0xff);
 408         rx_snr_a = rx_snr_a >> 1;
 409
 410         rx_snr_b = (u8)((value32 >> 8) & 0xff);
 411         rx_snr_b = rx_snr_b >> 1;
 412
 413         rx_snr_c = (u8)((value32 >> 16) & 0xff);
 414         rx_snr_c = rx_snr_c >> 1;
 415
 416         rx_snr_d = (u8)((value32 >> 24) & 0xff);
 417         rx_snr_d = rx_snr_d >> 1;
 418
 419         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d / %d", "RXSNR(A/B/C/D, dB)", rx_snr_a, rx_snr_b, rx_snr_c, rx_snr_d));
 420
 421         /* PostFFT related info*/
 422         value32 = odm_get_bb_reg(p_dm_odm, 0xdd8, MASKDWORD);
 423
 424         rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16);
 425         rxevm_0 /= 2;
 426         if (rxevm_0 < -63)
 427                 rxevm_0 = 0;
 428
 429         rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24);
 430         rxevm_1 /= 2;
 431         if (rxevm_1 < -63)
 432                 rxevm_1 = 0;
 433
 434         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "RXEVM (1ss/2ss)", rxevm_0, rxevm_1));
 435
 436         /*CFO Report Info*/
 437         odm_set_bb_reg(p_dm_odm, 0xd00, BIT(26), 1);
 438
 439         /*Short CFO*/
 440         value32 = odm_get_bb_reg(p_dm_odm, 0xdac, MASKDWORD);
 441         value32_1 = odm_get_bb_reg(p_dm_odm, 0xdb0, MASKDWORD);
 442
 443         short_cfo_b = (s32)(value32 & 0xfff);                   /*S(12,11)*/
 444         short_cfo_a = (s32)((value32 & 0x0fff0000) >> 16);
 445
 446         long_cfo_b = (s32)(value32_1 & 0x1fff);         /*S(13,12)*/
 447         long_cfo_a = (s32)((value32_1 & 0x1fff0000) >> 16);
 448
 449         /*SFO 2's to dec*/
 450         if (short_cfo_a > 2047)
 451                 short_cfo_a = short_cfo_a - 4096;
 452         if (short_cfo_b > 2047)
 453                 short_cfo_b = short_cfo_b - 4096;
 454
 455         short_cfo_a = (short_cfo_a * 312500) / 2048;
 456         short_cfo_b = (short_cfo_b * 312500) / 2048;
 457
 458         /*LFO 2's to dec*/
 459
 460         if (long_cfo_a > 4095)
 461                 long_cfo_a = long_cfo_a - 8192;
 462
 463         if (long_cfo_b > 4095)
 464                 long_cfo_b = long_cfo_b - 8192;
 465
 466         long_cfo_a = long_cfo_a * 312500 / 4096;
 467         long_cfo_b = long_cfo_b * 312500 / 4096;
 468
 469         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s", "CFO Report Info"));
 470         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "Short CFO(Hz) <A/B>", short_cfo_a, short_cfo_b));
 471         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "Long CFO(Hz) <A/B>", long_cfo_a, long_cfo_b));
 472
 473         /*SCFO*/
 474         value32 = odm_get_bb_reg(p_dm_odm, 0xdb8, MASKDWORD);
 475         value32_1 = odm_get_bb_reg(p_dm_odm, 0xdb4, MASKDWORD);
 476
 477         scfo_b = (s32)(value32 & 0x7ff);                        /*S(11,10)*/
 478         scfo_a = (s32)((value32 & 0x07ff0000) >> 16);
 479
 480         if (scfo_a > 1023)
 481                 scfo_a = scfo_a - 2048;
 482
 483         if (scfo_b > 1023)
 484                 scfo_b = scfo_b - 2048;
 485
 486         scfo_a = scfo_a * 312500 / 1024;
 487         scfo_b = scfo_b * 312500 / 1024;
 488
 489         avg_cfo_b = (s32)(value32_1 & 0x1fff);  /*S(13,12)*/
 490         avg_cfo_a = (s32)((value32_1 & 0x1fff0000) >> 16);
 491
 492         if (avg_cfo_a > 4095)
 493                 avg_cfo_a = avg_cfo_a - 8192;
 494
 495         if (avg_cfo_b > 4095)
 496                 avg_cfo_b = avg_cfo_b - 8192;
 497
 498         avg_cfo_a = avg_cfo_a * 312500 / 4096;
 499         avg_cfo_b = avg_cfo_b * 312500 / 4096;
 500
 501         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "value SCFO(Hz) <A/B>", scfo_a, scfo_b));
 502         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "Avg CFO(Hz) <A/B>", avg_cfo_a, avg_cfo_b));
 503
 504         value32 = odm_get_bb_reg(p_dm_odm, 0xdbc, MASKDWORD);
 505         value32_1 = odm_get_bb_reg(p_dm_odm, 0xde0, MASKDWORD);
 506
 507         cfo_end_b = (s32)(value32 & 0x1fff);            /*S(13,12)*/
 508         cfo_end_a = (s32)((value32 & 0x1fff0000) >> 16);
 509
 510         if (cfo_end_a > 4095)
 511                 cfo_end_a = cfo_end_a - 8192;
 512
 513         if (cfo_end_b > 4095)
 514                 cfo_end_b = cfo_end_b - 8192;
 515
 516         cfo_end_a = cfo_end_a * 312500 / 4096;
 517         cfo_end_b = cfo_end_b * 312500 / 4096;
 518
 519         acq_cfo_b = (s32)(value32_1 & 0x1fff);  /*S(13,12)*/
 520         acq_cfo_a = (s32)((value32_1 & 0x1fff0000) >> 16);
 521
 522         if (acq_cfo_a > 4095)
 523                 acq_cfo_a = acq_cfo_a - 8192;
 524
 525         if (acq_cfo_b > 4095)
 526                 acq_cfo_b = acq_cfo_b - 8192;
 527
 528         acq_cfo_a = acq_cfo_a * 312500 / 4096;
 529         acq_cfo_b = acq_cfo_b * 312500 / 4096;
 530
 531         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "End CFO(Hz) <A/B>", cfo_end_a, cfo_end_b));
 532         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "ACQ CFO(Hz) <A/B>", acq_cfo_a, acq_cfo_b));
 533
 534 }
 535
 536
 537 void
 538 phydm_bb_debug_info(
 539         void                    *p_dm_void,
 540         u32                     *_used,
 541         char                            *output,
 542         u32                     *_out_len
 543 )
 544 {
 545         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
 546         u32 used = *_used;
 547         u32 out_len = *_out_len;
 548
 549         char *tmp_string = NULL;
 550
 551         u8      RX_HT_BW, RX_VHT_BW, RXSC, RX_HT, RX_BW;
 552         static u8 v_rx_bw ;
 553         u32     value32, value32_1, value32_2, value32_3;
 554         s32     SFO_A, SFO_B, SFO_C, SFO_D;
 555         s32     LFO_A, LFO_B, LFO_C, LFO_D;
 556         static u8       MCSS, tail, parity, rsv, vrsv, idx, smooth, htsound, agg, stbc, vstbc, fec, fecext, sgi, sgiext, htltf, vgid, v_nsts, vtxops, vrsv2, vbrsv, bf, vbcrc;
 557         static u16      h_length, htcrc8, length;
 558         static u16 vpaid;
 559         static u16      v_length, vhtcrc8, v_mcss, v_tail, vb_tail;
 560         static u8       HMCSS, HRX_BW;
 561
 562         u8    pwdb;
 563         s8    RXEVM_0, RXEVM_1, RXEVM_2 ;
 564         u8    rf_gain_path_a, rf_gain_path_b, rf_gain_path_c, rf_gain_path_d;
 565         u8    rx_snr_path_a, rx_snr_path_b, rx_snr_path_c, rx_snr_path_d;
 566         s32    sig_power;
 567
 568         const char *L_rate[8] = {"6M", "9M", "12M", "18M", "24M", "36M", "48M", "54M"};
 569
 570         if (p_dm_odm->support_ic_type & ODM_IC_11N_SERIES) {
 571                 phydm_bb_debug_info_n_series(p_dm_odm, &used, output, &out_len);
 572                 return;
 573         }
 574
 575         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s\n", "BB Report Info"));
 576
 577         /*BW & mode Detection*/
 578
 579         value32 = odm_get_bb_reg(p_dm_odm, 0xf80, MASKDWORD);
 580         value32_2 = value32;
 581         RX_HT_BW = (u8)(value32 & 0x1);
 582         RX_VHT_BW = (u8)((value32 >> 1) & 0x3);
 583         RXSC = (u8)(value32 & 0x78);
 584         value32_1 = (value32 & 0x180) >> 7;
 585         RX_HT = (u8)(value32_1);
 586
 587         RX_BW = 0;
 588
 589         if (RX_HT == 2) {
 590                 if (RX_VHT_BW == 0)
 591                         tmp_string = "20M";
 592                 else if (RX_VHT_BW == 1)
 593                         tmp_string = "40M";
 594                 else
 595                         tmp_string = "80M";
 596                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s %s %s", "mode", "VHT", tmp_string));
 597                 RX_BW = RX_VHT_BW;
 598         } else if (RX_HT == 1) {
 599                 if (RX_HT_BW == 0)
 600                         tmp_string = "20M";
 601                 else if (RX_HT_BW == 1)
 602                         tmp_string = "40M";
 603                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s %s %s", "mode", "HT", tmp_string));
 604                 RX_BW = RX_HT_BW;
 605         } else
 606                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s %s", "mode", "Legacy"));
 607
 608         if (RX_HT != 0) {
 609                 if (RXSC == 0)
 610                         tmp_string = "duplicate/full bw";
 611                 else if (RXSC == 1)
 612                         tmp_string = "usc20-1";
 613                 else if (RXSC == 2)
 614                         tmp_string = "lsc20-1";
 615                 else if (RXSC == 3)
 616                         tmp_string = "usc20-2";
 617                 else if (RXSC == 4)
 618                         tmp_string = "lsc20-2";
 619                 else if (RXSC == 9)
 620                         tmp_string = "usc40";
 621                 else if (RXSC == 10)
 622                         tmp_string = "lsc40";
 623                 PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s", tmp_string));
 624         }
 625
 626         /* RX signal power and AGC related info*/
 627
 628         value32 = odm_get_bb_reg(p_dm_odm, 0xF90, MASKDWORD);
 629         pwdb = (u8)((value32 & MASKBYTE1) >> 8);
 630         pwdb = pwdb >> 1;
 631         sig_power = -110 + pwdb;
 632         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d", "OFDM RX Signal Power(dB)", sig_power));
 633
 634         value32 = odm_get_bb_reg(p_dm_odm, 0xd14, MASKDWORD);
 635         rx_snr_path_a = (u8)(value32 & 0xFF) >> 1;
 636         rf_gain_path_a = (s8)((value32 & MASKBYTE1) >> 8);
 637         rf_gain_path_a *= 2;
 638         value32 = odm_get_bb_reg(p_dm_odm, 0xd54, MASKDWORD);
 639         rx_snr_path_b = (u8)(value32 & 0xFF) >> 1;
 640         rf_gain_path_b = (s8)((value32 & MASKBYTE1) >> 8);
 641         rf_gain_path_b *= 2;
 642         value32 = odm_get_bb_reg(p_dm_odm, 0xd94, MASKDWORD);
 643         rx_snr_path_c = (u8)(value32 & 0xFF) >> 1;
 644         rf_gain_path_c = (s8)((value32 & MASKBYTE1) >> 8);
 645         rf_gain_path_c *= 2;
 646         value32 = odm_get_bb_reg(p_dm_odm, 0xdd4, MASKDWORD);
 647         rx_snr_path_d = (u8)(value32 & 0xFF) >> 1;
 648         rf_gain_path_d = (s8)((value32 & MASKBYTE1) >> 8);
 649         rf_gain_path_d *= 2;
 650
 651         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d / %d", "OFDM RX RF Gain(A/B/C/D)", rf_gain_path_a, rf_gain_path_b, rf_gain_path_c, rf_gain_path_d));
 652
 653
 654         /* RX counter related info*/
 655
 656         value32 = odm_get_bb_reg(p_dm_odm, 0xF08, MASKDWORD);
 657         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d", "OFDM CCA counter", ((value32 & 0xFFFF0000) >> 16)));
 658
 659         value32 = odm_get_bb_reg(p_dm_odm, 0xFD0, MASKDWORD);
 660         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d", "OFDM SBD Fail counter", value32 & 0xFFFF));
 661
 662         value32 = odm_get_bb_reg(p_dm_odm, 0xFC4, MASKDWORD);
 663         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "VHT SIGA/SIGB CRC8 Fail counter", value32 & 0xFFFF, ((value32 & 0xFFFF0000) >> 16)));
 664
 665         value32 = odm_get_bb_reg(p_dm_odm, 0xFCC, MASKDWORD);
 666         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d", "CCK CCA counter", value32 & 0xFFFF));
 667
 668         value32 = odm_get_bb_reg(p_dm_odm, 0xFBC, MASKDWORD);
 669         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "LSIG (parity Fail/rate Illegal) counter", value32 & 0xFFFF, ((value32 & 0xFFFF0000) >> 16)));
 670
 671         value32_1 = odm_get_bb_reg(p_dm_odm, 0xFC8, MASKDWORD);
 672         value32_2 = odm_get_bb_reg(p_dm_odm, 0xFC0, MASKDWORD);
 673         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "HT/VHT MCS NOT SUPPORT counter", ((value32_2 & 0xFFFF0000) >> 16), value32_1 & 0xFFFF));
 674
 675         /* PostFFT related info*/
 676         value32 = odm_get_bb_reg(p_dm_odm, 0xF8c, MASKDWORD);
 677         RXEVM_0 = (s8)((value32 & MASKBYTE2) >> 16);
 678         RXEVM_0 /= 2;
 679         if (RXEVM_0 < -63)
 680                 RXEVM_0 = 0;
 681
 682         RXEVM_1 = (s8)((value32 & MASKBYTE3) >> 24);
 683         RXEVM_1 /= 2;
 684         value32 = odm_get_bb_reg(p_dm_odm, 0xF88, MASKDWORD);
 685         RXEVM_2 = (s8)((value32 & MASKBYTE2) >> 16);
 686         RXEVM_2 /= 2;
 687
 688         if (RXEVM_1 < -63)
 689                 RXEVM_1 = 0;
 690         if (RXEVM_2 < -63)
 691                 RXEVM_2 = 0;
 692
 693         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d", "RXEVM (1ss/2ss/3ss)", RXEVM_0, RXEVM_1, RXEVM_2));
 694         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d / %d", "RXSNR(A/B/C/D, dB)", rx_snr_path_a, rx_snr_path_b, rx_snr_path_c, rx_snr_path_d));
 695
 696         value32 = odm_get_bb_reg(p_dm_odm, 0xF8C, MASKDWORD);
 697         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d", "CSI_1st /CSI_2nd", value32 & 0xFFFF, ((value32 & 0xFFFF0000) >> 16)));
 698
 699         /*BW & mode Detection*/
 700
 701         /*Reset Page F counter*/
 702         odm_set_bb_reg(p_dm_odm, 0xB58, BIT(0), 1);
 703         odm_set_bb_reg(p_dm_odm, 0xB58, BIT(0), 0);
 704
 705         /*CFO Report Info*/
 706         /*Short CFO*/
 707         value32 = odm_get_bb_reg(p_dm_odm, 0xd0c, MASKDWORD);
 708         value32_1 = odm_get_bb_reg(p_dm_odm, 0xd4c, MASKDWORD);
 709         value32_2 = odm_get_bb_reg(p_dm_odm, 0xd8c, MASKDWORD);
 710         value32_3 = odm_get_bb_reg(p_dm_odm, 0xdcc, MASKDWORD);
 711
 712         SFO_A = (s32)(value32 & 0xfff);
 713         SFO_B = (s32)(value32_1 & 0xfff);
 714         SFO_C = (s32)(value32_2 & 0xfff);
 715         SFO_D = (s32)(value32_3 & 0xfff);
 716
 717         LFO_A = (s32)(value32 >> 16);
 718         LFO_B = (s32)(value32_1 >> 16);
 719         LFO_C = (s32)(value32_2 >> 16);
 720         LFO_D = (s32)(value32_3 >> 16);
 721
 722         /*SFO 2's to dec*/
 723         if (SFO_A > 2047)
 724                 SFO_A = SFO_A - 4096;
 725         SFO_A = (SFO_A * 312500) / 2048;
 726         if (SFO_B > 2047)
 727                 SFO_B = SFO_B - 4096;
 728         SFO_B = (SFO_B * 312500) / 2048;
 729         if (SFO_C > 2047)
 730                 SFO_C = SFO_C - 4096;
 731         SFO_C = (SFO_C * 312500) / 2048;
 732         if (SFO_D > 2047)
 733                 SFO_D = SFO_D - 4096;
 734         SFO_D = (SFO_D * 312500) / 2048;
 735
 736         /*LFO 2's to dec*/
 737
 738         if (LFO_A > 4095)
 739                 LFO_A = LFO_A - 8192;
 740
 741         if (LFO_B > 4095)
 742                 LFO_B = LFO_B - 8192;
 743
 744         if (LFO_C > 4095)
 745                 LFO_C = LFO_C - 8192;
 746
 747         if (LFO_D > 4095)
 748                 LFO_D = LFO_D - 8192;
 749         LFO_A = LFO_A * 312500 / 4096;
 750         LFO_B = LFO_B * 312500 / 4096;
 751         LFO_C = LFO_C * 312500 / 4096;
 752         LFO_D = LFO_D * 312500 / 4096;
 753         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s", "CFO Report Info"));
 754         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "Short CFO(Hz) <A/B/C/D>", SFO_A, SFO_B, SFO_C, SFO_D));
 755         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "Long CFO(Hz) <A/B/C/D>", LFO_A, LFO_B, LFO_C, LFO_D));
 756
 757         /*SCFO*/
 758         value32 = odm_get_bb_reg(p_dm_odm, 0xd10, MASKDWORD);
 759         value32_1 = odm_get_bb_reg(p_dm_odm, 0xd50, MASKDWORD);
 760         value32_2 = odm_get_bb_reg(p_dm_odm, 0xd90, MASKDWORD);
 761         value32_3 = odm_get_bb_reg(p_dm_odm, 0xdd0, MASKDWORD);
 762
 763         SFO_A = (s32)(value32 & 0x7ff);
 764         SFO_B = (s32)(value32_1 & 0x7ff);
 765         SFO_C = (s32)(value32_2 & 0x7ff);
 766         SFO_D = (s32)(value32_3 & 0x7ff);
 767
 768         if (SFO_A > 1023)
 769                 SFO_A = SFO_A - 2048;
 770
 771         if (SFO_B > 2047)
 772                 SFO_B = SFO_B - 4096;
 773
 774         if (SFO_C > 2047)
 775                 SFO_C = SFO_C - 4096;
 776
 777         if (SFO_D > 2047)
 778                 SFO_D = SFO_D - 4096;
 779
 780         SFO_A = SFO_A * 312500 / 1024;
 781         SFO_B = SFO_B * 312500 / 1024;
 782         SFO_C = SFO_C * 312500 / 1024;
 783         SFO_D = SFO_D * 312500 / 1024;
 784
 785         LFO_A = (s32)(value32 >> 16);
 786         LFO_B = (s32)(value32_1 >> 16);
 787         LFO_C = (s32)(value32_2 >> 16);
 788         LFO_D = (s32)(value32_3 >> 16);
 789
 790         if (LFO_A > 4095)
 791                 LFO_A = LFO_A - 8192;
 792
 793         if (LFO_B > 4095)
 794                 LFO_B = LFO_B - 8192;
 795
 796         if (LFO_C > 4095)
 797                 LFO_C = LFO_C - 8192;
 798
 799         if (LFO_D > 4095)
 800                 LFO_D = LFO_D - 8192;
 801         LFO_A = LFO_A * 312500 / 4096;
 802         LFO_B = LFO_B * 312500 / 4096;
 803         LFO_C = LFO_C * 312500 / 4096;
 804         LFO_D = LFO_D * 312500 / 4096;
 805
 806         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "value SCFO(Hz) <A/B/C/D>", SFO_A, SFO_B, SFO_C, SFO_D));
 807         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "ACQ CFO(Hz) <A/B/C/D>", LFO_A, LFO_B, LFO_C, LFO_D));
 808
 809         value32 = odm_get_bb_reg(p_dm_odm, 0xd14, MASKDWORD);
 810         value32_1 = odm_get_bb_reg(p_dm_odm, 0xd54, MASKDWORD);
 811         value32_2 = odm_get_bb_reg(p_dm_odm, 0xd94, MASKDWORD);
 812         value32_3 = odm_get_bb_reg(p_dm_odm, 0xdd4, MASKDWORD);
 813
 814         LFO_A = (s32)(value32 >> 16);
 815         LFO_B = (s32)(value32_1 >> 16);
 816         LFO_C = (s32)(value32_2 >> 16);
 817         LFO_D = (s32)(value32_3 >> 16);
 818
 819         if (LFO_A > 4095)
 820                 LFO_A = LFO_A - 8192;
 821
 822         if (LFO_B > 4095)
 823                 LFO_B = LFO_B - 8192;
 824
 825         if (LFO_C > 4095)
 826                 LFO_C = LFO_C - 8192;
 827
 828         if (LFO_D > 4095)
 829                 LFO_D = LFO_D - 8192;
 830
 831         LFO_A = LFO_A * 312500 / 4096;
 832         LFO_B = LFO_B * 312500 / 4096;
 833         LFO_C = LFO_C * 312500 / 4096;
 834         LFO_D = LFO_D * 312500 / 4096;
 835
 836         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "End CFO(Hz) <A/B/C/D>", LFO_A, LFO_B, LFO_C, LFO_D));
 837
 838         value32 = odm_get_bb_reg(p_dm_odm, 0xf20, MASKDWORD);  /*L SIG*/
 839
 840         tail = (u8)((value32 & 0xfc0000) >> 16);
 841         parity = (u8)((value32 & 0x20000) >> 16);
 842         length = (u16)((value32 & 0x1ffe00) >> 8);
 843         rsv = (u8)(value32 & 0x10);
 844         MCSS = (u8)(value32 & 0x0f);
 845
 846         switch (MCSS) {
 847         case 0x0b:
 848                 idx = 0;
 849                 break;
 850         case 0x0f:
 851                 idx = 1;
 852                 break;
 853         case 0x0a:
 854                 idx = 2;
 855                 break;
 856         case 0x0e:
 857                 idx = 3;
 858                 break;
 859         case 0x09:
 860                 idx = 4;
 861                 break;
 862         case 0x08:
 863                 idx = 5;
 864                 break;
 865         case 0x0c:
 866                 idx = 6;
 867                 break;
 868         default:
 869                 idx = 6;
 870                 break;
 871
 872         }
 873
 874         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s", "L-SIG"));
 875         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s : %s", "rate", L_rate[idx]));
 876         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %x / %x / %x", "Rsv/length/parity", rsv, RX_BW, length));
 877
 878         value32 = odm_get_bb_reg(p_dm_odm, 0xf2c, MASKDWORD);  /*HT SIG*/
 879         if (RX_HT == 1) {
 880
 881                 HMCSS = (u8)(value32 & 0x7F);
 882                 HRX_BW = (u8)(value32 & 0x80);
 883                 h_length = (u16)((value32 >> 8) & 0xffff);
 884         }
 885         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s", "HT-SIG1"));
 886         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %x / %x / %x", "MCS/BW/length", HMCSS, HRX_BW, h_length));
 887
 888         value32 = odm_get_bb_reg(p_dm_odm, 0xf30, MASKDWORD);  /*HT SIG*/
 889
 890         if (RX_HT == 1) {
 891                 smooth = (u8)(value32 & 0x01);
 892                 htsound = (u8)(value32 & 0x02);
 893                 rsv = (u8)(value32 & 0x04);
 894                 agg = (u8)(value32 & 0x08);
 895                 stbc = (u8)(value32 & 0x30);
 896                 fec = (u8)(value32 & 0x40);
 897                 sgi = (u8)(value32 & 0x80);
 898                 htltf = (u8)((value32 & 0x300) >> 8);
 899                 htcrc8 = (u16)((value32 & 0x3fc00) >> 8);
 900                 tail = (u8)((value32 & 0xfc0000) >> 16);
 901         }
 902         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s", "HT-SIG2"));
 903         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x / %x / %x", "Smooth/NoSound/Rsv/Aggregate/STBC/LDPC", smooth, htsound, rsv, agg, stbc, fec));
 904         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x", "SGI/E-HT-LTFs/CRC/tail", sgi, htltf, htcrc8, tail));
 905
 906         value32 = odm_get_bb_reg(p_dm_odm, 0xf2c, MASKDWORD);  /*VHT SIG A1*/
 907         if (RX_HT == 2) {
 908                 /* value32 = odm_get_bb_reg(p_dm_odm, 0xf2c,MASKDWORD);*/
 909                 v_rx_bw = (u8)(value32 & 0x03);
 910                 vrsv = (u8)(value32 & 0x04);
 911                 vstbc = (u8)(value32 & 0x08);
 912                 vgid = (u8)((value32 & 0x3f0) >> 4);
 913                 v_nsts = (u8)(((value32 & 0x1c00) >> 8) + 1);
 914                 vpaid = (u16)(value32 & 0x3fe);
 915                 vtxops = (u8)((value32 & 0x400000) >> 20);
 916                 vrsv2 = (u8)((value32 & 0x800000) >> 20);
 917         }
 918         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s", "VHT-SIG-A1"));
 919         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x / %x / %x / %x / %x", "BW/Rsv1/STBC/GID/Nsts/PAID/TXOPPS/Rsv2", v_rx_bw, vrsv, vstbc, vgid, v_nsts, vpaid, vtxops, vrsv2));
 920
 921         value32 = odm_get_bb_reg(p_dm_odm, 0xf30, MASKDWORD);  /*VHT SIG*/
 922
 923         if (RX_HT == 2) {
 924                 /*value32 = odm_get_bb_reg(p_dm_odm, 0xf30,MASKDWORD); */  /*VHT SIG*/
 925
 926                 /* sgi=(u8)(value32&0x01); */
 927                 sgiext = (u8)(value32 & 0x03);
 928                 /* fec = (u8)(value32&0x04); */
 929                 fecext = (u8)(value32 & 0x0C);
 930
 931                 v_mcss = (u8)(value32 & 0xf0);
 932                 bf = (u8)((value32 & 0x100) >> 8);
 933                 vrsv = (u8)((value32 & 0x200) >> 8);
 934                 vhtcrc8 = (u16)((value32 & 0x3fc00) >> 8);
 935                 v_tail = (u8)((value32 & 0xfc0000) >> 16);
 936         }
 937         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s", "VHT-SIG-A2"));
 938         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x / %x / %x / %x", "SGI/FEC/MCS/BF/Rsv/CRC/tail", sgiext, fecext, v_mcss, bf, vrsv, vhtcrc8, v_tail));
 939
 940         value32 = odm_get_bb_reg(p_dm_odm, 0xf34, MASKDWORD);  /*VHT SIG*/
 941         {
 942                 v_length = (u16)(value32 & 0x1fffff);
 943                 vbrsv = (u8)((value32 & 0x600000) >> 20);
 944                 vb_tail = (u16)((value32 & 0x1f800000) >> 20);
 945                 vbcrc = (u8)((value32 & 0x80000000) >> 28);
 946
 947         }
 948         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s", "VHT-SIG-B"));
 949         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x", "length/Rsv/tail/CRC", v_length, vbrsv, vb_tail, vbcrc));
 950
 951         /*for Condition number*/
 952         if (p_dm_odm->support_ic_type & ODM_RTL8822B) {
 953                 s32     condition_num = 0;
 954                 char *factor = NULL;
 955
 956                 odm_set_bb_reg(p_dm_odm, 0x1988, BIT(22), 0x1); /*enable report condition number*/
 957
 958                 condition_num = odm_get_bb_reg(p_dm_odm, 0xf84, MASKDWORD);
 959                 condition_num = (condition_num & 0x3ffff) >> 4;
 960
 961                 if (*p_dm_odm->p_band_width == ODM_BW80M)
 962                         factor = "256/234";
 963                 else if (*p_dm_odm->p_band_width == ODM_BW40M)
 964                         factor = "128/108";
 965                 else if (*p_dm_odm->p_band_width == ODM_BW20M) {
 966                         if (RX_HT != 2 || RX_HT != 1)
 967                                 factor = "64/52";       /*HT or VHT*/
 968                         else
 969                                 factor = "64/48";       /*legacy*/
 970                 }
 971
 972                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = %d (factor = %s)", "Condition number", condition_num, factor));
 973
 974         }
 975
 976 }
 977 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
 978
 979 #if (DM_ODM_SUPPORT_TYPE & ODM_WIN)
 980
 981 #if CONFIG_PHYDM_DEBUG_FUNCTION
 982 void phydm_sbd_check(
 983         struct PHY_DM_STRUCT                                    *p_dm_odm
 984 )
 985 {
 986         static u32      pkt_cnt = 0;
 987         static boolean sbd_state = 0;
 988         u32     sym_count, count, value32;
 989
 990         if (sbd_state == 0) {
 991                 pkt_cnt++;
 992                 if (pkt_cnt % 5 == 0) { /*read SBD conter once every 5 packets*/
 993                         odm_set_timer(p_dm_odm, &p_dm_odm->sbdcnt_timer, 0); /*ms*/
 994                         sbd_state = 1;
 995                 }
 996         } else { /*read counter*/
 997                 value32 = odm_get_bb_reg(p_dm_odm, 0xF98, MASKDWORD);
 998                 sym_count = (value32 & 0x7C000000) >> 26;
 999                 count = (value32 & 0x3F00000) >> 20;
1000                 dbg_print("#SBD#    sym_count   %d   count   %d\n", sym_count, count);
1001                 sbd_state = 0;
1002         }
1003 }
1004 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
1005
1006 void phydm_sbd_callback(
1007         struct timer_list               *p_timer
1008 )
1009 {
1010 #if CONFIG_PHYDM_DEBUG_FUNCTION
1011         struct _ADAPTER         *adapter = (struct _ADAPTER *)p_timer->Adapter;
1012         HAL_DATA_TYPE   *p_hal_data = GET_HAL_DATA(adapter);
1013         struct PHY_DM_STRUCT            *p_dm_odm = &p_hal_data->DM_OutSrc;
1014
1015 #if USE_WORKITEM
1016         odm_schedule_work_item(&p_dm_odm->sbdcnt_workitem);
1017 #else
1018         phydm_sbd_check(p_dm_odm);
1019 #endif
1020 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
1021 }
1022
1023 void phydm_sbd_workitem_callback(
1024         void            *p_context
1025 )
1026 {
1027 #if CONFIG_PHYDM_DEBUG_FUNCTION
1028         struct _ADAPTER *p_adapter = (struct _ADAPTER *)p_context;
1029         HAL_DATA_TYPE   *p_hal_data = GET_HAL_DATA(p_adapter);
1030         struct PHY_DM_STRUCT            *p_dm_odm = &p_hal_data->DM_OutSrc;
1031
1032         phydm_sbd_check(p_dm_odm);
1033 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
1034 }
1035 #endif
1036 void
1037 phydm_basic_dbg_message
1038 (
1039         void                    *p_dm_void
1040 )
1041 {
1042 #if (DM_ODM_SUPPORT_TYPE & (ODM_WIN | ODM_CE))
1043         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1044         struct _FALSE_ALARM_STATISTICS *false_alm_cnt = (struct _FALSE_ALARM_STATISTICS *)phydm_get_structure(p_dm_odm, PHYDM_FALSEALMCNT);
1045         struct _CFO_TRACKING_                           *p_cfo_track = (struct _CFO_TRACKING_ *)phydm_get_structure(p_dm_odm, PHYDM_CFOTRACK);
1046         struct _dynamic_initial_gain_threshold_ *p_dm_dig_table = &p_dm_odm->dm_dig_table;
1047         struct _rate_adaptive_table_    *p_ra_table = &p_dm_odm->dm_ra_table;
1048         u16     macid, phydm_macid, client_cnt = 0;
1049         struct sta_info *p_entry;
1050         s32     tmp_val = 0;
1051         u8      tmp_val_u1 = 0;
1052
1053         ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("[PHYDM Common MSG] System up time: ((%d sec))----->\n", p_dm_odm->phydm_sys_up_time));
1054
1055         if (p_dm_odm->is_linked) {
1056                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("ID=%d, BW=((%d)), CH=((%d))\n", p_dm_odm->curr_station_id, 20<<(*(p_dm_odm->p_band_width)), *(p_dm_odm->p_channel)));
1057
1058                 /*Print RX rate*/
1059                 if (p_dm_odm->rx_rate <= ODM_RATE11M) {
1060                         ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("[CCK AGC Report] LNA_idx = 0x%x, VGA_idx = 0x%x\n",
1061                                 p_dm_odm->cck_lna_idx, p_dm_odm->cck_vga_idx));
1062                 } else {
1063                         ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("[OFDM AGC Report] { 0x%x, 0x%x, 0x%x, 0x%x }\n",
1064                                 p_dm_odm->ofdm_agc_idx[0], p_dm_odm->ofdm_agc_idx[1], p_dm_odm->ofdm_agc_idx[2], p_dm_odm->ofdm_agc_idx[3]));
1065                 }
1066
1067                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("RSSI: { %d,  %d,  %d,  %d },    rx_rate:",
1068                         (p_dm_odm->RSSI_A == 0xff) ? 0 : p_dm_odm->RSSI_A,
1069                         (p_dm_odm->RSSI_B == 0xff) ? 0 : p_dm_odm->RSSI_B,
1070                         (p_dm_odm->RSSI_C == 0xff) ? 0 : p_dm_odm->RSSI_C,
1071                         (p_dm_odm->RSSI_D == 0xff) ? 0 : p_dm_odm->RSSI_D));
1072
1073                 phydm_print_rate(p_dm_odm, p_dm_odm->rx_rate, ODM_COMP_COMMON);
1074
1075                 /*Print TX rate*/
1076                 for (macid = 0; macid < ODM_ASSOCIATE_ENTRY_NUM; macid++) {
1077
1078                         p_entry = p_dm_odm->p_odm_sta_info[macid];
1079                         if (IS_STA_VALID(p_entry)) {
1080
1081                                 phydm_macid = (p_dm_odm->platform2phydm_macid_table[macid]);
1082                                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("TXRate [%d]:", macid));
1083                                 phydm_print_rate(p_dm_odm, p_ra_table->link_tx_rate[macid], ODM_COMP_COMMON);
1084
1085                                 client_cnt++;
1086
1087                                 if (client_cnt == p_dm_odm->number_linked_client)
1088                                         break;
1089                         }
1090                 }
1091
1092                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("TP { TX, RX, total} = {%d, %d, %d }Mbps, traffic_load = (%d))\n",
1093                         p_dm_odm->tx_tp, p_dm_odm->rx_tp, p_dm_odm->total_tp, p_dm_odm->traffic_load));
1094
1095                 tmp_val_u1 = (p_cfo_track->crystal_cap > p_cfo_track->def_x_cap) ? (p_cfo_track->crystal_cap - p_cfo_track->def_x_cap) : (p_cfo_track->def_x_cap - p_cfo_track->crystal_cap);
1096                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("CFO_avg = ((%d kHz)) , CrystalCap_tracking = ((%s%d))\n",
1097                         p_cfo_track->CFO_ave_pre, ((p_cfo_track->crystal_cap > p_cfo_track->def_x_cap) ? "+" : "-"), tmp_val_u1));
1098
1099                 /* Condition number */
1100 #if (RTL8822B_SUPPORT == 1)
1101                 if (p_dm_odm->support_ic_type == ODM_RTL8822B) {
1102                         tmp_val = phydm_get_condition_number_8822B(p_dm_odm);
1103                         ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("Condition number = ((%d))\n", tmp_val));
1104                 }
1105 #endif
1106
1107 #if (ODM_PHY_STATUS_NEW_TYPE_SUPPORT == 1)
1108                 /*STBC or LDPC pkt*/
1109                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("LDPC = %s, STBC = %s\n", (p_dm_odm->phy_dbg_info.is_ldpc_pkt) ? "Y" : "N", (p_dm_odm->phy_dbg_info.is_stbc_pkt) ? "Y" : "N"));
1110 #endif
1111         } else
1112                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("No Link !!!\n"));
1113
1114         ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("[CCA Cnt] {CCK, OFDM, Total} = {%d, %d, %d}\n",
1115                 false_alm_cnt->cnt_cck_cca, false_alm_cnt->cnt_ofdm_cca, false_alm_cnt->cnt_cca_all));
1116
1117         ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("[FA Cnt] {CCK, OFDM, Total} = {%d, %d, %d}\n",
1118                 false_alm_cnt->cnt_cck_fail, false_alm_cnt->cnt_ofdm_fail, false_alm_cnt->cnt_all));
1119
1120 #if (ODM_IC_11N_SERIES_SUPPORT == 1)
1121         if (p_dm_odm->support_ic_type & ODM_IC_11N_SERIES) {
1122                 ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("[OFDM FA Detail] Parity_Fail = (( %d )), Rate_Illegal = (( %d )), CRC8_fail = (( %d )), Mcs_fail = (( %d )), Fast_Fsync = (( %d )), SB_Search_fail = (( %d ))\n",
1123                         false_alm_cnt->cnt_parity_fail, false_alm_cnt->cnt_rate_illegal, false_alm_cnt->cnt_crc8_fail, false_alm_cnt->cnt_mcs_fail, false_alm_cnt->cnt_fast_fsync, false_alm_cnt->cnt_sb_search_fail));
1124         }
1125 #endif
1126
1127         ODM_RT_TRACE(p_dm_odm, ODM_COMP_COMMON, ODM_DBG_LOUD, ("is_linked = %d, Num_client = %d, rssi_min = %d, current_igi = 0x%x, bNoisy=%d\n\n",
1128                 p_dm_odm->is_linked, p_dm_odm->number_linked_client, p_dm_odm->rssi_min, p_dm_dig_table->cur_ig_value, p_dm_odm->noisy_decision));
1129
1130         /*
1131                 temp_reg = odm_get_bb_reg(p_dm_odm, 0xDD0, MASKBYTE0);
1132                 ODM_RT_TRACE(p_dm_odm,ODM_COMP_COMMON, ODM_DBG_LOUD, ("0xDD0 = 0x%x\n",temp_reg));
1133
1134                 temp_reg = odm_get_bb_reg(p_dm_odm, 0xDDc, MASKBYTE1);
1135                 ODM_RT_TRACE(p_dm_odm,ODM_COMP_COMMON, ODM_DBG_LOUD, ("0xDDD = 0x%x\n",temp_reg));
1136
1137                 temp_reg = odm_get_bb_reg(p_dm_odm, 0xc50, MASKBYTE0);
1138                 ODM_RT_TRACE(p_dm_odm,ODM_COMP_COMMON, ODM_DBG_LOUD, ("0xC50 = 0x%x\n",temp_reg));
1139
1140                 temp_reg = odm_get_rf_reg(p_dm_odm, ODM_RF_PATH_A, 0x0, 0x3fe0);
1141                 ODM_RT_TRACE(p_dm_odm,ODM_COMP_COMMON, ODM_DBG_LOUD, ("RF 0x0[13:5] = 0x%x\n\n",temp_reg));
1142         */
1143
1144 #endif
1145 }
1146
1147
1148 void phydm_basic_profile(
1149         void                    *p_dm_void,
1150         u32                     *_used,
1151         char                            *output,
1152         u32                     *_out_len
1153 )
1154 {
1155 #if CONFIG_PHYDM_DEBUG_FUNCTION
1156         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1157         char  *cut = NULL;
1158         char *ic_type = NULL;
1159         u32 used = *_used;
1160         u32 out_len = *_out_len;
1161         u32     commit_ver = 0;
1162         u32     date = 0;
1163         char    *commit_by = NULL;
1164         u32     release_ver = 0;
1165
1166         PHYDM_SNPRINTF((output + used, out_len - used, "%-35s\n", "% Basic Profile %"));
1167
1168         if (p_dm_odm->support_ic_type == ODM_RTL8188E) {
1169 #if (RTL8188E_SUPPORT == 1)
1170                 ic_type = "RTL8188E";
1171                 date = RELEASE_DATE_8188E;
1172                 commit_by = COMMIT_BY_8188E;
1173                 release_ver = RELEASE_VERSION_8188E;
1174 #endif
1175         }
1176 #if (RTL8812A_SUPPORT == 1)
1177         else if (p_dm_odm->support_ic_type == ODM_RTL8812) {
1178                 ic_type = "RTL8812A";
1179                 date = RELEASE_DATE_8812A;
1180                 commit_by = COMMIT_BY_8812A;
1181                 release_ver = RELEASE_VERSION_8812A;
1182         }
1183 #endif
1184 #if (RTL8821A_SUPPORT == 1)
1185         else if (p_dm_odm->support_ic_type == ODM_RTL8821) {
1186                 ic_type = "RTL8821A";
1187                 date = RELEASE_DATE_8821A;
1188                 commit_by = COMMIT_BY_8821A;
1189                 release_ver = RELEASE_VERSION_8821A;
1190         }
1191 #endif
1192 #if (RTL8192E_SUPPORT == 1)
1193         else if (p_dm_odm->support_ic_type == ODM_RTL8192E) {
1194                 ic_type = "RTL8192E";
1195                 date = RELEASE_DATE_8192E;
1196                 commit_by = COMMIT_BY_8192E;
1197                 release_ver = RELEASE_VERSION_8192E;
1198         }
1199 #endif
1200 #if (RTL8723B_SUPPORT == 1)
1201         else if (p_dm_odm->support_ic_type == ODM_RTL8723B) {
1202                 ic_type = "RTL8723B";
1203                 date = RELEASE_DATE_8723B;
1204                 commit_by = COMMIT_BY_8723B;
1205                 release_ver = RELEASE_VERSION_8723B;
1206         }
1207 #endif
1208 #if (RTL8814A_SUPPORT == 1)
1209         else if (p_dm_odm->support_ic_type == ODM_RTL8814A) {
1210                 ic_type = "RTL8814A";
1211                 date = RELEASE_DATE_8814A;
1212                 commit_by = COMMIT_BY_8814A;
1213                 release_ver = RELEASE_VERSION_8814A;
1214         }
1215 #endif
1216 #if (RTL8881A_SUPPORT == 1)
1217         else if (p_dm_odm->support_ic_type == ODM_RTL8881A) {
1218                 ic_type = "RTL8881A";
1219                 /**/
1220         }
1221 #endif
1222 #if (RTL8822B_SUPPORT == 1)
1223         else if (p_dm_odm->support_ic_type == ODM_RTL8822B) {
1224                 ic_type = "RTL8822B";
1225                 date = RELEASE_DATE_8822B;
1226                 commit_by = COMMIT_BY_8822B;
1227                 release_ver = RELEASE_VERSION_8822B;
1228         }
1229 #endif
1230 #if (RTL8197F_SUPPORT == 1)
1231         else if (p_dm_odm->support_ic_type == ODM_RTL8197F) {
1232                 ic_type = "RTL8197F";
1233                 date = RELEASE_DATE_8197F;
1234                 commit_by = COMMIT_BY_8197F;
1235                 release_ver = RELEASE_VERSION_8197F;
1236         }
1237 #endif
1238
1239 #if (RTL8703B_SUPPORT == 1)
1240         else if (p_dm_odm->support_ic_type == ODM_RTL8703B) {
1241
1242                 ic_type = "RTL8703B";
1243                 date = RELEASE_DATE_8703B;
1244                 commit_by = COMMIT_BY_8703B;
1245                 release_ver = RELEASE_VERSION_8703B;
1246
1247         }
1248 #endif
1249 #if (RTL8195A_SUPPORT == 1)
1250         else if (p_dm_odm->support_ic_type == ODM_RTL8195A) {
1251                 ic_type = "RTL8195A";
1252                 /**/
1253         }
1254 #endif
1255 #if (RTL8188F_SUPPORT == 1)
1256         else if (p_dm_odm->support_ic_type == ODM_RTL8188F) {
1257                 ic_type = "RTL8188F";
1258                 date = RELEASE_DATE_8188F;
1259                 commit_by = COMMIT_BY_8188F;
1260                 release_ver = RELEASE_VERSION_8188F;
1261         }
1262 #endif
1263 #if (RTL8723D_SUPPORT == 1)
1264         else if (p_dm_odm->support_ic_type == ODM_RTL8723D) {
1265                 ic_type = "RTL8723D";
1266                 date = RELEASE_DATE_8723D;
1267                 commit_by = COMMIT_BY_8723D;
1268                 release_ver = RELEASE_VERSION_8723D;
1269                 /**/
1270         }
1271 #endif
1272
1273 /* JJ ADD 20161014 */
1274 #if (RTL8710B_SUPPORT == 1)
1275         else if (p_dm_odm->support_ic_type == ODM_RTL8710B) {
1276                 ic_type = "RTL8710B";
1277                 date = RELEASE_DATE_8710B;
1278                 commit_by = COMMIT_BY_8710B;
1279                 release_ver = RELEASE_VERSION_8710B;
1280                 /**/
1281         }
1282 #endif
1283
1284 #if (RTL8821C_SUPPORT == 1)
1285         else if (p_dm_odm->support_ic_type == ODM_RTL8821C) {
1286                 ic_type = "RTL8821C";
1287                 date = RELEASE_DATE_8821C;
1288                 commit_by = COMMIT_BY_8821C;
1289                 release_ver = RELEASE_VERSION_8821C;
1290         }
1291 #endif
1292         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s (MP Chip: %s)\n", "IC type", ic_type, p_dm_odm->is_mp_chip ? "Yes" : "No"));
1293
1294         if (p_dm_odm->cut_version == ODM_CUT_A)
1295                 cut = "A";
1296         else if (p_dm_odm->cut_version == ODM_CUT_B)
1297                 cut = "B";
1298         else if (p_dm_odm->cut_version == ODM_CUT_C)
1299                 cut = "C";
1300         else if (p_dm_odm->cut_version == ODM_CUT_D)
1301                 cut = "D";
1302         else if (p_dm_odm->cut_version == ODM_CUT_E)
1303                 cut = "E";
1304         else if (p_dm_odm->cut_version == ODM_CUT_F)
1305                 cut = "F";
1306         else if (p_dm_odm->cut_version == ODM_CUT_I)
1307                 cut = "I";
1308         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "cut version", cut));
1309         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %d\n", "PHY Parameter version", odm_get_hw_img_version(p_dm_odm)));
1310         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %d\n", "PHY Parameter Commit date", date));
1311         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "PHY Parameter Commit by", commit_by));
1312         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %d\n", "PHY Parameter Release version", release_ver));
1313
1314 #if (DM_ODM_SUPPORT_TYPE & ODM_WIN)
1315         {
1316                 struct _ADAPTER         *adapter = p_dm_odm->adapter;
1317                 PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %d (Subversion: %d)\n", "FW version", adapter->MgntInfo.FirmwareVersion, adapter->MgntInfo.FirmwareSubVersion));
1318         }
1319 #elif (DM_ODM_SUPPORT_TYPE & ODM_AP)
1320         {
1321                 struct rtl8192cd_priv *priv = p_dm_odm->priv;
1322                 PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %d (Subversion: %d)\n", "FW version", priv->pshare->fw_version, priv->pshare->fw_sub_version));
1323         }
1324 #else
1325         {
1326                 struct _ADAPTER         *adapter = p_dm_odm->adapter;
1327                 HAL_DATA_TYPE           *p_hal_data = GET_HAL_DATA(adapter);
1328                 PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %d (Subversion: %d)\n", "FW version", p_hal_data->firmware_version, p_hal_data->firmware_sub_version));
1329         }
1330 #endif
1331         /* 1 PHY DM version List */
1332         PHYDM_SNPRINTF((output + used, out_len - used, "%-35s\n", "% PHYDM version %"));
1333         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Code base", PHYDM_CODE_BASE));
1334         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Release Date", PHYDM_RELEASE_DATE));
1335         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "adaptivity", ADAPTIVITY_VERSION));
1336         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "DIG", DIG_VERSION));
1337         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Dynamic BB PowerSaving", DYNAMIC_BBPWRSAV_VERSION));
1338         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "CFO Tracking", CFO_TRACKING_VERSION));
1339         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Antenna Diversity", ANTDIV_VERSION));
1340         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Power Tracking", POWRTRACKING_VERSION));
1341         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Dynamic TxPower", DYNAMIC_TXPWR_VERSION));
1342         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "RA Info", RAINFO_VERSION));
1343 #if (DM_ODM_SUPPORT_TYPE & ODM_WIN)
1344         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Antenna Detection", ANTDECT_VERSION));
1345 #endif
1346         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Auto channel Selection", ACS_VERSION));
1347 #if PHYDM_SUPPORT_EDCA
1348         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "EDCA Turbo", EDCATURBO_VERSION));
1349 #endif
1350         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "path Diversity", PATHDIV_VERSION));
1351         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "LA mode", DYNAMIC_LA_MODE));
1352         PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "Dynamic RX path", DYNAMIC_RX_PATH_VERSION));
1353
1354 #if (RTL8822B_SUPPORT == 1)
1355         if (p_dm_odm->support_ic_type & ODM_RTL8822B)
1356                 PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "PHY config 8822B", PHY_CONFIG_VERSION_8822B));
1357
1358 #endif
1359 #if (RTL8197F_SUPPORT == 1)
1360         if (p_dm_odm->support_ic_type & ODM_RTL8197F)
1361                 PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s: %s\n", "PHY config 8197F", PHY_CONFIG_VERSION_8197F));
1362 #endif
1363         *_used = used;
1364         *_out_len = out_len;
1365 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
1366 }
1367
1368 #if CONFIG_PHYDM_DEBUG_FUNCTION
1369 void
1370 phydm_fw_trace_en_h2c(
1371         void            *p_dm_void,
1372         boolean         enable,
1373         u32             fw_debug_component,
1374         u32             monitor_mode,
1375         u32             macid
1376 )
1377 {
1378         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1379         u8                      h2c_parameter[7] = {0};
1380         u8                      cmd_length;
1381
1382         if (p_dm_odm->support_ic_type & PHYDM_IC_3081_SERIES) {
1383
1384                 h2c_parameter[0] = enable;
1385                 h2c_parameter[1] = (u8)(fw_debug_component & MASKBYTE0);
1386                 h2c_parameter[2] = (u8)((fw_debug_component & MASKBYTE1) >> 8);
1387                 h2c_parameter[3] = (u8)((fw_debug_component & MASKBYTE2) >> 16);
1388                 h2c_parameter[4] = (u8)((fw_debug_component & MASKBYTE3) >> 24);
1389                 h2c_parameter[5] = (u8)monitor_mode;
1390                 h2c_parameter[6] = (u8)macid;
1391                 cmd_length = 7;
1392
1393         } else {
1394
1395                 h2c_parameter[0] = enable;
1396                 h2c_parameter[1] = (u8)monitor_mode;
1397                 h2c_parameter[2] = (u8)macid;
1398                 cmd_length = 3;
1399         }
1400
1401
1402         ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("---->\n"));
1403         if (monitor_mode == 0)
1404                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[H2C] FW_debug_en: (( %d ))\n", enable));
1405         else
1406                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[H2C] FW_debug_en: (( %d )), mode: (( %d )), macid: (( %d ))\n", enable, monitor_mode, macid));
1407         odm_fill_h2c_cmd(p_dm_odm, PHYDM_H2C_FW_TRACE_EN, cmd_length, h2c_parameter);
1408 }
1409
1410
1411 #if (RTL8822B_SUPPORT == 1 || RTL8197F_SUPPORT == 1 || RTL8821C_SUPPORT == 1)
1412 boolean
1413 phydm_api_set_txagc(
1414         struct PHY_DM_STRUCT                            *p_dm_odm,
1415         u32                                     power_index,
1416         enum odm_rf_radio_path_e                path,
1417         u8                                      hw_rate,
1418         boolean                                 is_single_rate
1419 )
1420 {
1421         boolean         ret = false;
1422
1423 #if ((RTL8822B_SUPPORT == 1) || (RTL8821C_SUPPORT == 1))
1424         if (p_dm_odm->support_ic_type & (ODM_RTL8822B | ODM_RTL8821C)) {
1425                 if (is_single_rate) {
1426 #if (RTL8822B_SUPPORT == 1)
1427                         if (p_dm_odm->support_ic_type == ODM_RTL8822B)
1428                                 ret = phydm_write_txagc_1byte_8822b(p_dm_odm, power_index, path, hw_rate);
1429 #endif
1430 #if (RTL8821C_SUPPORT == 1)
1431                         if (p_dm_odm->support_ic_type == ODM_RTL8821C)
1432                                 ret = phydm_write_txagc_1byte_8821c(p_dm_odm, power_index, path, hw_rate);
1433 #endif
1434 #if (DM_ODM_SUPPORT_TYPE & ODM_AP)
1435                         set_current_tx_agc(p_dm_odm->priv, path, hw_rate, (u8)power_index);
1436 #endif
1437
1438                 } else {
1439                         u8      i;
1440 #if (RTL8822B_SUPPORT == 1)
1441                         if (p_dm_odm->support_ic_type == ODM_RTL8822B)
1442                                 ret = config_phydm_write_txagc_8822b(p_dm_odm, power_index, path, hw_rate);
1443 #endif
1444 #if (RTL8821C_SUPPORT == 1)
1445                         if (p_dm_odm->support_ic_type == ODM_RTL8821C)
1446                                 ret = config_phydm_write_txagc_8821c(p_dm_odm, power_index, path, hw_rate);
1447 #endif
1448 #if (DM_ODM_SUPPORT_TYPE & ODM_AP)
1449                         for (i = 0; i < 4; i++)
1450                                 set_current_tx_agc(p_dm_odm->priv, path, (hw_rate + i), (u8)power_index);
1451 #endif
1452                 }
1453         }
1454 #endif
1455
1456
1457 #if (RTL8197F_SUPPORT == 1)
1458         if (p_dm_odm->support_ic_type & ODM_RTL8197F)
1459                 ret = config_phydm_write_txagc_8197f(p_dm_odm, power_index, path, hw_rate);
1460 #endif
1461
1462         return ret;
1463 }
1464
1465 u8
1466 phydm_api_get_txagc(
1467         struct PHY_DM_STRUCT                            *p_dm_odm,
1468         enum odm_rf_radio_path_e        path,
1469         u8                                      hw_rate
1470 )
1471 {
1472         u8      ret = 0;
1473
1474 #if (RTL8822B_SUPPORT == 1)
1475         if (p_dm_odm->support_ic_type & ODM_RTL8822B)
1476                 ret = config_phydm_read_txagc_8822b(p_dm_odm, path, hw_rate);
1477 #endif
1478
1479 #if (RTL8197F_SUPPORT == 1)
1480         if (p_dm_odm->support_ic_type & ODM_RTL8197F)
1481                 ret = config_phydm_read_txagc_8197f(p_dm_odm, path, hw_rate);
1482 #endif
1483
1484 #if (RTL8821C_SUPPORT == 1)
1485         if (p_dm_odm->support_ic_type & ODM_RTL8821C)
1486                 ret = config_phydm_read_txagc_8821c(p_dm_odm, path, hw_rate);
1487 #endif
1488
1489         return ret;
1490 }
1491
1492
1493 boolean
1494 phydm_api_switch_bw_channel(
1495         struct PHY_DM_STRUCT                            *p_dm_odm,
1496         u8                                      central_ch,
1497         u8                                      primary_ch_idx,
1498         enum odm_bw_e                           bandwidth
1499 )
1500 {
1501         boolean         ret = false;
1502
1503 #if (RTL8822B_SUPPORT == 1)
1504         if (p_dm_odm->support_ic_type & ODM_RTL8822B)
1505                 ret = config_phydm_switch_channel_bw_8822b(p_dm_odm, central_ch, primary_ch_idx, bandwidth);
1506 #endif
1507
1508 #if (RTL8197F_SUPPORT == 1)
1509         if (p_dm_odm->support_ic_type & ODM_RTL8197F)
1510                 ret = config_phydm_switch_channel_bw_8197f(p_dm_odm, central_ch, primary_ch_idx, bandwidth);
1511 #endif
1512
1513 #if (RTL8821C_SUPPORT == 1)
1514         if (p_dm_odm->support_ic_type & ODM_RTL8821C)
1515                 ret = config_phydm_switch_channel_bw_8821c(p_dm_odm, central_ch, primary_ch_idx, bandwidth);
1516 #endif
1517
1518         return ret;
1519 }
1520
1521 boolean
1522 phydm_api_trx_mode(
1523         struct PHY_DM_STRUCT                            *p_dm_odm,
1524         enum odm_rf_path_e                      tx_path,
1525         enum odm_rf_path_e                      rx_path,
1526         boolean                                 is_tx2_path
1527 )
1528 {
1529         boolean         ret = false;
1530
1531 #if (RTL8822B_SUPPORT == 1)
1532         if (p_dm_odm->support_ic_type & ODM_RTL8822B)
1533                 ret = config_phydm_trx_mode_8822b(p_dm_odm, tx_path, rx_path, is_tx2_path);
1534 #endif
1535
1536 #if (RTL8197F_SUPPORT == 1)
1537         if (p_dm_odm->support_ic_type & ODM_RTL8197F)
1538                 ret = config_phydm_trx_mode_8197f(p_dm_odm, tx_path, rx_path, is_tx2_path);
1539 #endif
1540
1541         return ret;
1542 }
1543 #endif
1544
1545 void
1546 phydm_get_per_path_txagc(
1547         void                    *p_dm_void,
1548         u8                      path,
1549         u32                     *_used,
1550         char                            *output,
1551         u32                     *_out_len
1552 )
1553 {
1554         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1555         u8                      rate_idx;
1556         u8                      txagc;
1557         u32                     used = *_used;
1558         u32                     out_len = *_out_len;
1559
1560 #if ((RTL8822B_SUPPORT == 1) || (RTL8197F_SUPPORT == 1) || (RTL8821C_SUPPORT == 1))
1561         if (((p_dm_odm->support_ic_type & (ODM_RTL8822B | ODM_RTL8197F)) && (path <= ODM_RF_PATH_B)) ||
1562             ((p_dm_odm->support_ic_type & (ODM_RTL8821C)) && (path <= ODM_RF_PATH_A))) {
1563                 for (rate_idx = 0; rate_idx <= 0x53; rate_idx++) {
1564                         if (rate_idx == ODM_RATE1M)
1565                                 PHYDM_SNPRINTF((output + used, out_len - used, "  %-35s\n", "CCK====>"));
1566                         else if (rate_idx == ODM_RATE6M)
1567                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "OFDM====>"));
1568                         else if (rate_idx == ODM_RATEMCS0)
1569                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "HT 1ss====>"));
1570                         else if (rate_idx == ODM_RATEMCS8)
1571                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "HT 2ss====>"));
1572                         else if (rate_idx == ODM_RATEMCS16)
1573                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "HT 3ss====>"));
1574                         else if (rate_idx == ODM_RATEMCS24)
1575                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "HT 4ss====>"));
1576                         else if (rate_idx == ODM_RATEVHTSS1MCS0)
1577                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "VHT 1ss====>"));
1578                         else if (rate_idx == ODM_RATEVHTSS2MCS0)
1579                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "VHT 2ss====>"));
1580                         else if (rate_idx == ODM_RATEVHTSS3MCS0)
1581                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "VHT 3ss====>"));
1582                         else if (rate_idx == ODM_RATEVHTSS4MCS0)
1583                                 PHYDM_SNPRINTF((output + used, out_len - used, "\n  %-35s\n", "VHT 4ss====>"));
1584
1585                         txagc = phydm_api_get_txagc(p_dm_odm, (enum odm_rf_radio_path_e) path, rate_idx);
1586                         if (config_phydm_read_txagc_check(txagc))
1587                                 PHYDM_SNPRINTF((output + used, out_len - used, "  0x%02x    ", txagc));
1588                         else
1589                                 PHYDM_SNPRINTF((output + used, out_len - used, "  0x%s    ", "xx"));
1590                 }
1591         }
1592 #endif
1593 }
1594
1595
1596 void
1597 phydm_get_txagc(
1598         void                    *p_dm_void,
1599         u32                     *_used,
1600         char                            *output,
1601         u32                     *_out_len
1602 )
1603 {
1604         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1605         u32                     used = *_used;
1606         u32                     out_len = *_out_len;
1607
1608         /* path-A */
1609         PHYDM_SNPRINTF((output + used, out_len - used, "%-35s\n", "path-A===================="));
1610         phydm_get_per_path_txagc(p_dm_odm, ODM_RF_PATH_A, _used, output, _out_len);
1611
1612         /* path-B */
1613         PHYDM_SNPRINTF((output + used, out_len - used, "\n%-35s\n", "path-B===================="));
1614         phydm_get_per_path_txagc(p_dm_odm, ODM_RF_PATH_B, _used, output, _out_len);
1615
1616         /* path-C */
1617         PHYDM_SNPRINTF((output + used, out_len - used, "\n%-35s\n", "path-C===================="));
1618         phydm_get_per_path_txagc(p_dm_odm, ODM_RF_PATH_C, _used, output, _out_len);
1619
1620         /* path-D */
1621         PHYDM_SNPRINTF((output + used, out_len - used, "\n%-35s\n", "path-D===================="));
1622         phydm_get_per_path_txagc(p_dm_odm, ODM_RF_PATH_D, _used, output, _out_len);
1623
1624 }
1625
1626 void
1627 phydm_set_txagc(
1628         void                    *p_dm_void,
1629         u32                     *const dm_value,
1630         u32                     *_used,
1631         char                            *output,
1632         u32                     *_out_len
1633 )
1634 {
1635         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1636         u32                     used = *_used;
1637         u32                     out_len = *_out_len;
1638
1639         /*dm_value[1] = path*/
1640         /*dm_value[2] = hw_rate*/
1641         /*dm_value[3] = power_index*/
1642
1643 #if (RTL8822B_SUPPORT == 1 || RTL8197F_SUPPORT == 1 || RTL8821C_SUPPORT == 1)
1644         if (p_dm_odm->support_ic_type & (ODM_RTL8822B | ODM_RTL8197F | ODM_RTL8821C)) {
1645                 if (dm_value[1] <= 1) {
1646                         if ((u8)dm_value[2] != 0xff) {
1647                                 if (phydm_api_set_txagc(p_dm_odm, dm_value[3], (enum odm_rf_radio_path_e) dm_value[1], (u8)dm_value[2], true))
1648                                         PHYDM_SNPRINTF((output + used, out_len - used, "  %s%d   %s%x%s%x\n", "Write path-", dm_value[1], "rate index-0x", dm_value[2], " = 0x", dm_value[3]));
1649                                 else
1650                                         PHYDM_SNPRINTF((output + used, out_len - used, "  %s%d   %s%x%s\n", "Write path-", (dm_value[1] & 0x1), "rate index-0x", (dm_value[2] & 0x7f), " fail"));
1651                         } else {
1652                                 u8      i;
1653                                 u32     power_index;
1654                                 boolean status = true;
1655
1656                                 power_index = (dm_value[3] & 0x3f);
1657
1658                                 if (p_dm_odm->support_ic_type & (ODM_RTL8822B | ODM_RTL8821C)) {
1659                                         power_index = (power_index << 24) | (power_index << 16) | (power_index << 8) | (power_index);
1660
1661                                         for (i = 0; i < ODM_RATEVHTSS2MCS9; i += 4)
1662                                                 status = (status & phydm_api_set_txagc(p_dm_odm, power_index, (enum odm_rf_radio_path_e) dm_value[1], i, false));
1663                                 } else if (p_dm_odm->support_ic_type & ODM_RTL8197F) {
1664                                         for (i = 0; i <= ODM_RATEMCS15; i++)
1665                                                 status = (status & phydm_api_set_txagc(p_dm_odm, power_index, (enum odm_rf_radio_path_e) dm_value[1], i, false));
1666                                 }
1667
1668                                 if (status)
1669                                         PHYDM_SNPRINTF((output + used, out_len - used, "  %s%d   %s%x\n", "Write all TXAGC of path-", dm_value[1], " = 0x", dm_value[3]));
1670                                 else
1671                                         PHYDM_SNPRINTF((output + used, out_len - used, "  %s%d   %s\n", "Write all TXAGC of path-", dm_value[1], " fail"));
1672                         }
1673                 } else
1674                         PHYDM_SNPRINTF((output + used, out_len - used, "  %s%d   %s%x%s\n", "Write path-", (dm_value[1] & 0x1), "rate index-0x", (dm_value[2] & 0x7f), " fail"));
1675         }
1676 #endif
1677 }
1678
1679 void
1680 phydm_debug_trace(
1681         void            *p_dm_void,
1682         u32             *const dm_value,
1683         u32             *_used,
1684         char            *output,
1685         u32             *_out_len
1686 )
1687 {
1688         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1689         u32                     pre_debug_components, one = 1;
1690         u32                     used = *_used;
1691         u32                     out_len = *_out_len;
1692
1693         pre_debug_components = p_dm_odm->debug_components;
1694
1695         PHYDM_SNPRINTF((output + used, out_len - used, "\n%s\n", "================================"));
1696         if (dm_value[0] == 100) {
1697                 PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "[Debug Message] PhyDM Selection"));
1698                 PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "================================"));
1699                 PHYDM_SNPRINTF((output + used, out_len - used, "00. (( %s ))DIG\n", ((p_dm_odm->debug_components & ODM_COMP_DIG) ? ("V") : ("."))));
1700                 PHYDM_SNPRINTF((output + used, out_len - used, "01. (( %s ))RA_MASK\n", ((p_dm_odm->debug_components & ODM_COMP_RA_MASK) ? ("V") : ("."))));
1701                 PHYDM_SNPRINTF((output + used, out_len - used, "02. (( %s ))DYNAMIC_TXPWR\n", ((p_dm_odm->debug_components & ODM_COMP_DYNAMIC_TXPWR) ? ("V") : ("."))));
1702                 PHYDM_SNPRINTF((output + used, out_len - used, "03. (( %s ))FA_CNT\n", ((p_dm_odm->debug_components & ODM_COMP_FA_CNT) ? ("V") : ("."))));
1703                 PHYDM_SNPRINTF((output + used, out_len - used, "04. (( %s ))RSSI_MONITOR\n", ((p_dm_odm->debug_components & ODM_COMP_RSSI_MONITOR) ? ("V") : ("."))));
1704                 PHYDM_SNPRINTF((output + used, out_len - used, "05. (( %s ))SNIFFER\n", ((p_dm_odm->debug_components & ODM_COMP_SNIFFER) ? ("V") : ("."))));
1705                 PHYDM_SNPRINTF((output + used, out_len - used, "06. (( %s ))ANT_DIV\n", ((p_dm_odm->debug_components & ODM_COMP_ANT_DIV) ? ("V") : ("."))));
1706                 PHYDM_SNPRINTF((output + used, out_len - used, "07. (( %s ))DFS\n", ((p_dm_odm->debug_components & ODM_COMP_DFS) ? ("V") : ("."))));
1707                 PHYDM_SNPRINTF((output + used, out_len - used, "08. (( %s ))NOISY_DETECT\n", ((p_dm_odm->debug_components & ODM_COMP_NOISY_DETECT) ? ("V") : ("."))));
1708                 PHYDM_SNPRINTF((output + used, out_len - used, "09. (( %s ))RATE_ADAPTIVE\n", ((p_dm_odm->debug_components & ODM_COMP_RATE_ADAPTIVE) ? ("V") : ("."))));
1709                 PHYDM_SNPRINTF((output + used, out_len - used, "10. (( %s ))PATH_DIV\n", ((p_dm_odm->debug_components & ODM_COMP_PATH_DIV) ? ("V") : ("."))));
1710                 PHYDM_SNPRINTF((output + used, out_len - used, "12. (( %s ))DYNAMIC_PRICCA\n", ((p_dm_odm->debug_components & ODM_COMP_DYNAMIC_PRICCA) ? ("V") : ("."))));
1711                 PHYDM_SNPRINTF((output + used, out_len - used, "14. (( %s ))MP\n", ((p_dm_odm->debug_components & ODM_COMP_MP) ? ("V") : ("."))));
1712                 PHYDM_SNPRINTF((output + used, out_len - used, "15. (( %s ))struct _CFO_TRACKING_\n", ((p_dm_odm->debug_components & ODM_COMP_CFO_TRACKING) ? ("V") : ("."))));
1713                 PHYDM_SNPRINTF((output + used, out_len - used, "16. (( %s ))struct _ACS_\n", ((p_dm_odm->debug_components & ODM_COMP_ACS) ? ("V") : ("."))));
1714                 PHYDM_SNPRINTF((output + used, out_len - used, "17. (( %s ))ADAPTIVITY\n", ((p_dm_odm->debug_components & PHYDM_COMP_ADAPTIVITY) ? ("V") : ("."))));
1715                 PHYDM_SNPRINTF((output + used, out_len - used, "18. (( %s ))RA_DBG\n", ((p_dm_odm->debug_components & PHYDM_COMP_RA_DBG) ? ("V") : ("."))));
1716                 PHYDM_SNPRINTF((output + used, out_len - used, "19. (( %s ))TXBF\n", ((p_dm_odm->debug_components & PHYDM_COMP_TXBF) ? ("V") : ("."))));
1717                 PHYDM_SNPRINTF((output + used, out_len - used, "20. (( %s ))EDCA_TURBO\n", ((p_dm_odm->debug_components & ODM_COMP_EDCA_TURBO) ? ("V") : ("."))));
1718                 PHYDM_SNPRINTF((output + used, out_len - used, "22. (( %s ))FW_DEBUG_TRACE\n", ((p_dm_odm->debug_components & ODM_FW_DEBUG_TRACE) ? ("V") : ("."))));
1719
1720                 PHYDM_SNPRINTF((output + used, out_len - used, "24. (( %s ))TX_PWR_TRACK\n", ((p_dm_odm->debug_components & ODM_COMP_TX_PWR_TRACK) ? ("V") : ("."))));
1721                 PHYDM_SNPRINTF((output + used, out_len - used, "26. (( %s ))CALIBRATION\n", ((p_dm_odm->debug_components & ODM_COMP_CALIBRATION) ? ("V") : ("."))));
1722                 PHYDM_SNPRINTF((output + used, out_len - used, "28. (( %s ))PHY_CONFIG\n", ((p_dm_odm->debug_components & ODM_PHY_CONFIG) ? ("V") : ("."))));
1723                 PHYDM_SNPRINTF((output + used, out_len - used, "29. (( %s ))INIT\n", ((p_dm_odm->debug_components & ODM_COMP_INIT) ? ("V") : ("."))));
1724                 PHYDM_SNPRINTF((output + used, out_len - used, "30. (( %s ))COMMON\n", ((p_dm_odm->debug_components & ODM_COMP_COMMON) ? ("V") : ("."))));
1725                 PHYDM_SNPRINTF((output + used, out_len - used, "31. (( %s ))API\n", ((p_dm_odm->debug_components & ODM_COMP_API) ? ("V") : ("."))));
1726                 PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "================================"));
1727
1728         } else if (dm_value[0] == 101) {
1729                 p_dm_odm->debug_components = 0;
1730                 PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "Disable all debug components"));
1731         } else {
1732                 if (dm_value[1] == 1)   /*enable*/
1733                         p_dm_odm->debug_components |= (one << dm_value[0]);
1734                 else if (dm_value[1] == 2)   /*disable*/
1735                         p_dm_odm->debug_components &= ~(one << dm_value[0]);
1736                 else
1737                         PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "[Warning!!!]  1:enable,  2:disable"));
1738         }
1739         PHYDM_SNPRINTF((output + used, out_len - used, "pre-DbgComponents = 0x%x\n", pre_debug_components));
1740         PHYDM_SNPRINTF((output + used, out_len - used, "Curr-DbgComponents = 0x%x\n", p_dm_odm->debug_components));
1741         PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "================================"));
1742 }
1743
1744 void
1745 phydm_fw_debug_trace(
1746         void            *p_dm_void,
1747         u32             *const dm_value,
1748         u32             *_used,
1749         char                    *output,
1750         u32             *_out_len
1751 )
1752 {
1753         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1754         u32                     pre_fw_debug_components, one = 1;
1755         u32                     used = *_used;
1756         u32                     out_len = *_out_len;
1757
1758         pre_fw_debug_components = p_dm_odm->fw_debug_components;
1759
1760         PHYDM_SNPRINTF((output + used, out_len - used, "\n%s\n", "================================"));
1761         if (dm_value[0] == 100) {
1762                 PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "[FW Debug Component]"));
1763                 PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "================================"));
1764                 PHYDM_SNPRINTF((output + used, out_len - used, "00. (( %s ))RA\n", ((p_dm_odm->fw_debug_components & PHYDM_FW_COMP_RA) ? ("V") : ("."))));
1765
1766                 if (p_dm_odm->support_ic_type & PHYDM_IC_3081_SERIES) {
1767                         PHYDM_SNPRINTF((output + used, out_len - used, "01. (( %s ))MU\n", ((p_dm_odm->fw_debug_components & PHYDM_FW_COMP_MU) ? ("V") : ("."))));
1768                         PHYDM_SNPRINTF((output + used, out_len - used, "02. (( %s ))path Div\n", ((p_dm_odm->fw_debug_components & PHYDM_FW_COMP_PHY_CONFIG) ? ("V") : ("."))));
1769                         PHYDM_SNPRINTF((output + used, out_len - used, "03. (( %s ))Phy Config\n", ((p_dm_odm->fw_debug_components & PHYDM_FW_COMP_PHY_CONFIG) ? ("V") : ("."))));
1770                 }
1771                 PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "================================"));
1772
1773         } else {
1774                 if (dm_value[0] == 101) {
1775                         p_dm_odm->fw_debug_components = 0;
1776                         PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "Clear all fw debug components"));
1777                 } else {
1778                         if (dm_value[1] == 1)   /*enable*/
1779                                 p_dm_odm->fw_debug_components |= (one << dm_value[0]);
1780                         else if (dm_value[1] == 2)   /*disable*/
1781                                 p_dm_odm->fw_debug_components &= ~(one << dm_value[0]);
1782                         else
1783                                 PHYDM_SNPRINTF((output + used, out_len - used, "%s\n", "[Warning!!!]  1:enable,  2:disable"));
1784                 }
1785
1786                 if (p_dm_odm->fw_debug_components == 0) {
1787                         p_dm_odm->debug_components &= ~ODM_FW_DEBUG_TRACE;
1788                         phydm_fw_trace_en_h2c(p_dm_odm, false, p_dm_odm->fw_debug_components, dm_value[2], dm_value[3]); /*H2C to enable C2H Msg*/
1789                 } else {
1790                         p_dm_odm->debug_components |= ODM_FW_DEBUG_TRACE;
1791                         phydm_fw_trace_en_h2c(p_dm_odm, true, p_dm_odm->fw_debug_components, dm_value[2], dm_value[3]); /*H2C to enable C2H Msg*/
1792                 }
1793         }
1794 }
1795
1796 void
1797 phydm_dump_bb_reg(
1798         void                    *p_dm_void,
1799         u32                     *_used,
1800         char                            *output,
1801         u32                     *_out_len
1802 )
1803 {
1804         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1805         u32                     addr = 0;
1806         u32                     used = *_used;
1807         u32                     out_len = *_out_len;
1808
1809
1810         /* BB Reg, For Nseries IC we only need to dump page8 to pageF using 3 digits*/
1811         for (addr = 0x800; addr < 0xfff; addr += 4) {
1812                 if (p_dm_odm->support_ic_type & ODM_IC_11N_SERIES)
1813                         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%03x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1814                 else
1815                         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1816         }
1817
1818         if (p_dm_odm->support_ic_type & (ODM_RTL8822B | ODM_RTL8814A | ODM_RTL8821C)) {
1819
1820                 if (p_dm_odm->rf_type > ODM_2T2R) {
1821                         for (addr = 0x1800; addr < 0x18ff; addr += 4)
1822                                 PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1823                 }
1824
1825                 if (p_dm_odm->rf_type > ODM_3T3R) {
1826                         for (addr = 0x1a00; addr < 0x1aff; addr += 4)
1827                                 PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1828                 }
1829
1830                 for (addr = 0x1900; addr < 0x19ff; addr += 4)
1831                         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1832
1833                 for (addr = 0x1c00; addr < 0x1cff; addr += 4)
1834                         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1835
1836                 for (addr = 0x1f00; addr < 0x1fff; addr += 4)
1837                         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1838         }
1839 }
1840
1841 void
1842 phydm_dump_all_reg(
1843         void                    *p_dm_void,
1844         u32                     *_used,
1845         char                            *output,
1846         u32                     *_out_len
1847 )
1848 {
1849         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
1850         u32                     addr = 0;
1851         u32                     used = *_used;
1852         u32                     out_len = *_out_len;
1853
1854         /* dump MAC register */
1855         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "MAC==========\n"));
1856         for (addr = 0; addr < 0x7ff; addr += 4)
1857                 PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1858
1859         for (addr = 0x1000; addr < 0x17ff; addr += 4)
1860                 PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(p_dm_odm, addr, MASKDWORD)));
1861
1862         /* dump BB register */
1863         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "BB==========\n"));
1864         phydm_dump_bb_reg(p_dm_odm, &used, output, &out_len);
1865
1866         /* dump RF register */
1867         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "RF-A==========\n"));
1868         for (addr = 0; addr < 0xFF; addr++)
1869                 PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%02x 0x%05x\n", addr, odm_get_rf_reg(p_dm_odm, ODM_RF_PATH_A, addr, RFREGOFFSETMASK)));
1870
1871         if (p_dm_odm->rf_type > ODM_1T1R) {
1872                 PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "RF-B==========\n"));
1873                 for (addr = 0; addr < 0xFF; addr++)
1874                         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%02x 0x%05x\n", addr, odm_get_rf_reg(p_dm_odm, ODM_RF_PATH_B, addr, RFREGOFFSETMASK)));
1875         }
1876
1877         if (p_dm_odm->rf_type > ODM_2T2R) {
1878                 PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "RF-C==========\n"));
1879                 for (addr = 0; addr < 0xFF; addr++)
1880                         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%02x 0x%05x\n", addr, odm_get_rf_reg(p_dm_odm, ODM_RF_PATH_C, addr, RFREGOFFSETMASK)));
1881         }
1882
1883         if (p_dm_odm->rf_type > ODM_3T3R) {
1884                 PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "RF-D==========\n"));
1885                 for (addr = 0; addr < 0xFF; addr++)
1886                         PHYDM_VAST_INFO_SNPRINTF((output + used, out_len - used, "0x%02x 0x%05x\n", addr, odm_get_rf_reg(p_dm_odm, ODM_RF_PATH_D, addr, RFREGOFFSETMASK)));
1887         }
1888 }
1889
1890 void
1891 phydm_enable_big_jump(
1892         struct PHY_DM_STRUCT    *p_dm_odm,
1893         boolean         state
1894 )
1895 {
1896 #if (RTL8822B_SUPPORT == 1)
1897         struct _dynamic_initial_gain_threshold_                 *p_dm_dig_table = &p_dm_odm->dm_dig_table;
1898
1899         if (state == false) {
1900                 p_dm_odm->dm_dig_table.enable_adjust_big_jump = false;
1901                 odm_set_bb_reg(p_dm_odm, 0x8c8, 0xfe, ((p_dm_dig_table->big_jump_step3 << 5) | (p_dm_dig_table->big_jump_step2 << 3) | p_dm_dig_table->big_jump_step1));
1902         } else
1903                 p_dm_odm->dm_dig_table.enable_adjust_big_jump = true;
1904 #endif
1905 }
1906
1907 #if (RTL8822B_SUPPORT == 1)
1908
1909 void
1910 phydm_show_rx_rate(
1911         struct PHY_DM_STRUCT                    *p_dm_odm,
1912         u32                     *_used,
1913         char                            *output,
1914         u32                     *_out_len
1915 )
1916 {
1917         u32                     used = *_used;
1918         u32                     out_len = *_out_len;
1919
1920         PHYDM_SNPRINTF((output + used, out_len - used, "=====Rx SU rate Statistics=====\n"));
1921         PHYDM_SNPRINTF((output + used, out_len - used, "1SS MCS0 = %d, 1SS MCS1 = %d, 1SS MCS2 = %d, 1SS MCS 3 = %d\n",
1922                 p_dm_odm->phy_dbg_info.num_qry_vht_pkt[0], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[1], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[2], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[3]));
1923         PHYDM_SNPRINTF((output + used, out_len - used, "1SS MCS4 = %d, 1SS MCS5 = %d, 1SS MCS6 = %d, 1SS MCS 7 = %d\n",
1924                 p_dm_odm->phy_dbg_info.num_qry_vht_pkt[4], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[5], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[6], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[7]));
1925         PHYDM_SNPRINTF((output + used, out_len - used, "1SS MCS8 = %d, 1SS MCS9 = %d\n",
1926                 p_dm_odm->phy_dbg_info.num_qry_vht_pkt[8], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[9]));
1927         PHYDM_SNPRINTF((output + used, out_len - used, "2SS MCS0 = %d, 2SS MCS1 = %d, 2SS MCS2 = %d, 2SS MCS 3 = %d\n",
1928                 p_dm_odm->phy_dbg_info.num_qry_vht_pkt[10], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[11], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[12], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[13]));
1929         PHYDM_SNPRINTF((output + used, out_len - used, "2SS MCS4 = %d, 2SS MCS5 = %d, 2SS MCS6 = %d, 2SS MCS 7 = %d\n",
1930                 p_dm_odm->phy_dbg_info.num_qry_vht_pkt[14], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[15], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[16], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[17]));
1931         PHYDM_SNPRINTF((output + used, out_len - used, "2SS MCS8 = %d, 2SS MCS9 = %d\n",
1932                 p_dm_odm->phy_dbg_info.num_qry_vht_pkt[18], p_dm_odm->phy_dbg_info.num_qry_vht_pkt[19]));
1933
1934         PHYDM_SNPRINTF((output + used, out_len - used, "=====Rx MU rate Statistics=====\n"));
1935         PHYDM_SNPRINTF((output + used, out_len - used, "1SS MCS0 = %d, 1SS MCS1 = %d, 1SS MCS2 = %d, 1SS MCS 3 = %d\n",
1936                 p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[0], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[1], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[2], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[3]));
1937         PHYDM_SNPRINTF((output + used, out_len - used, "1SS MCS4 = %d, 1SS MCS5 = %d, 1SS MCS6 = %d, 1SS MCS 7 = %d\n",
1938                 p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[4], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[5], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[6], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[7]));
1939         PHYDM_SNPRINTF((output + used, out_len - used, "1SS MCS8 = %d, 1SS MCS9 = %d\n",
1940                 p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[8], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[9]));
1941         PHYDM_SNPRINTF((output + used, out_len - used, "2SS MCS0 = %d, 2SS MCS1 = %d, 2SS MCS2 = %d, 2SS MCS 3 = %d\n",
1942                 p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[10], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[11], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[12], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[13]));
1943         PHYDM_SNPRINTF((output + used, out_len - used, "2SS MCS4 = %d, 2SS MCS5 = %d, 2SS MCS6 = %d, 2SS MCS 7 = %d\n",
1944                 p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[14], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[15], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[16], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[17]));
1945         PHYDM_SNPRINTF((output + used, out_len - used, "2SS MCS8 = %d, 2SS MCS9 = %d\n",
1946                 p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[18], p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[19]));
1947
1948 }
1949
1950 #endif
1951
1952
1953 struct _PHYDM_COMMAND {
1954         char name[16];
1955         u8 id;
1956 };
1957
1958 enum PHYDM_CMD_ID {
1959         PHYDM_HELP,
1960         PHYDM_DEMO,
1961         PHYDM_RA,
1962         PHYDM_PROFILE,
1963         PHYDM_ANTDIV,
1964         PHYDM_PATHDIV,
1965         PHYDM_DEBUG,
1966         PHYDM_FW_DEBUG,
1967         PHYDM_SUPPORT_ABILITY,
1968         PHYDM_GET_TXAGC,
1969         PHYDM_SET_TXAGC,
1970         PHYDM_SMART_ANT,
1971         PHYDM_API,
1972         PHYDM_TRX_PATH,
1973         PHYDM_LA_MODE,
1974         PHYDM_DUMP_REG,
1975         PHYDM_MU_MIMO,
1976         PHYDM_HANG,
1977         PHYDM_BIG_JUMP,
1978         PHYDM_SHOW_RXRATE,
1979         PHYDM_NBI_EN,
1980         PHYDM_CSI_MASK_EN,
1981         PHYDM_DFS,
1982         PHYDM_IQK,
1983         PHYDM_NHM,
1984         PHYDM_CLM,
1985         PHYDM_BB_INFO,
1986         PHYDM_TXBF,
1987         PHYDM_PAUSE_DIG_EN,
1988         PHYDM_H2C,
1989         PHYDM_ANT_SWITCH,
1990         PHYDM_DYNAMIC_RA_PATH,
1991         PHYDM_PSD,
1992         PHYDM_DEBUG_PORT,
1993         PHYDM_HTSTF_CONTROL
1994 };
1995
1996 struct _PHYDM_COMMAND phy_dm_ary[] = {
1997         {"-h", PHYDM_HELP},             /*do not move this element to other position*/
1998         {"demo", PHYDM_DEMO},   /*do not move this element to other position*/
1999         {"ra", PHYDM_RA},
2000         {"profile", PHYDM_PROFILE},
2001         {"antdiv", PHYDM_ANTDIV},
2002         {"pathdiv", PHYDM_PATHDIV},
2003         {"dbg", PHYDM_DEBUG},
2004         {"fw_dbg", PHYDM_FW_DEBUG},
2005         {"ability", PHYDM_SUPPORT_ABILITY},
2006         {"get_txagc", PHYDM_GET_TXAGC},
2007         {"set_txagc", PHYDM_SET_TXAGC},
2008         {"smtant", PHYDM_SMART_ANT},
2009         {"api", PHYDM_API},
2010         {"trxpath", PHYDM_TRX_PATH},
2011         {"lamode", PHYDM_LA_MODE},
2012         {"dumpreg", PHYDM_DUMP_REG},
2013         {"mu", PHYDM_MU_MIMO},
2014         {"hang", PHYDM_HANG},
2015         {"bigjump", PHYDM_BIG_JUMP},
2016         {"rxrate", PHYDM_SHOW_RXRATE},
2017         {"nbi", PHYDM_NBI_EN},
2018         {"csi_mask", PHYDM_CSI_MASK_EN},
2019         {"dfs", PHYDM_DFS},
2020         {"iqk", PHYDM_IQK},
2021         {"nhm", PHYDM_NHM},
2022         {"clm", PHYDM_CLM},
2023         {"bbinfo", PHYDM_BB_INFO},
2024         {"txbf", PHYDM_TXBF},
2025         {"pause_dig", PHYDM_PAUSE_DIG_EN},
2026         {"h2c", PHYDM_H2C},
2027         {"ant_switch", PHYDM_ANT_SWITCH},
2028         {"drp", PHYDM_DYNAMIC_RA_PATH},
2029         {"psd", PHYDM_PSD},
2030         {"dbgport", PHYDM_DEBUG_PORT},
2031         {"htstf", PHYDM_HTSTF_CONTROL}
2032 };
2033
2034 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
2035
2036 void
2037 phydm_cmd_parser(
2038         struct PHY_DM_STRUCT    *p_dm_odm,
2039         char            input[][MAX_ARGV],
2040         u32     input_num,
2041         u8      flag,
2042         char            *output,
2043         u32     out_len
2044 )
2045 {
2046 #if CONFIG_PHYDM_DEBUG_FUNCTION
2047         u32 used = 0;
2048         u8 id = 0;
2049         int var1[10] = {0};
2050         int i, input_idx = 0, phydm_ary_size;
2051         char help[] = "-h";
2052
2053         if (flag == 0) {
2054                 PHYDM_SNPRINTF((output + used, out_len - used, "GET, nothing to print\n"));
2055                 return;
2056         }
2057
2058         PHYDM_SNPRINTF((output + used, out_len - used, "\n"));
2059
2060         /* Parsing Cmd ID */
2061         if (input_num) {
2062
2063                 phydm_ary_size = sizeof(phy_dm_ary) / sizeof(struct _PHYDM_COMMAND);
2064                 for (i = 0; i < phydm_ary_size; i++) {
2065                         if (strcmp(phy_dm_ary[i].name, input[0]) == 0) {
2066                                 id = phy_dm_ary[i].id;
2067                                 break;
2068                         }
2069                 }
2070                 if (i == phydm_ary_size) {
2071                         PHYDM_SNPRINTF((output + used, out_len - used, "SET, command not found!\n"));
2072                         return;
2073                 }
2074         }
2075
2076         switch (id) {
2077
2078         case PHYDM_HELP:
2079         {
2080                 PHYDM_SNPRINTF((output + used, out_len - used, "BB cmd ==>\n"));
2081                 for (i = 0; i < phydm_ary_size - 2; i++) {
2082
2083                         PHYDM_SNPRINTF((output + used, out_len - used, "  %-5d: %s\n", i, phy_dm_ary[i + 2].name));
2084                         /**/
2085                 }
2086         }
2087         break;
2088
2089         case PHYDM_DEMO: { /*echo demo 10 0x3a z abcde >cmd*/
2090                 u32 directory = 0;
2091
2092 #if (DM_ODM_SUPPORT_TYPE & (ODM_CE | ODM_AP))
2093                 char char_temp;
2094 #else
2095                 u32 char_temp = ' ';
2096 #endif
2097
2098                 PHYDM_SSCANF(input[1], DCMD_DECIMAL, &directory);
2099                 PHYDM_SNPRINTF((output + used, out_len - used, "Decimal value = %d\n", directory));
2100                 PHYDM_SSCANF(input[2], DCMD_HEX, &directory);
2101                 PHYDM_SNPRINTF((output + used, out_len - used, "Hex value = 0x%x\n", directory));
2102                 PHYDM_SSCANF(input[3], DCMD_CHAR, &char_temp);
2103                 PHYDM_SNPRINTF((output + used, out_len - used, "Char = %c\n", char_temp));
2104                 PHYDM_SNPRINTF((output + used, out_len - used, "String = %s\n", input[4]));
2105         }
2106         break;
2107
2108         case PHYDM_RA:
2109
2110                 for (i = 0; i < 5; i++) {
2111                         if (input[i + 1]) {
2112                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2113
2114                                 /*PHYDM_SNPRINTF((output + used, out_len - used, "new SET, RA_var[%d]= (( %d ))\n", i, var1[i]));*/
2115                                 input_idx++;
2116                         }
2117                 }
2118
2119                 if (input_idx >= 1) {
2120                         /*PHYDM_SNPRINTF((output+used, out_len-used, "odm_RA_debug\n"));*/
2121 #if (defined(CONFIG_RA_DBG_CMD))
2122                         odm_RA_debug((void *)p_dm_odm, (u32 *) var1);
2123 #else
2124                         phydm_RA_debug_PCR(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2125 #endif
2126                 }
2127
2128
2129                 break;
2130
2131         case PHYDM_ANTDIV:
2132
2133                 for (i = 0; i < 5; i++) {
2134                         if (input[i + 1]) {
2135                                 PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]);
2136
2137                                 /*PHYDM_SNPRINTF((output+used, out_len-used, "new SET, PATHDIV_var[%d]= (( %d ))\n", i, var1[i]));*/
2138                                 input_idx++;
2139                         }
2140                 }
2141
2142                 if (input_idx >= 1) {
2143                         /*PHYDM_SNPRINTF((output+used, out_len-used, "odm_PATHDIV_debug\n"));*/
2144 #if (defined(CONFIG_PHYDM_ANTENNA_DIVERSITY))
2145                         phydm_antdiv_debug(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2146 #endif
2147                 }
2148
2149                 break;
2150
2151         case PHYDM_PATHDIV:
2152
2153                 for (i = 0; i < 5; i++) {
2154                         if (input[i + 1]) {
2155                                 PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]);
2156
2157                                 /*PHYDM_SNPRINTF((output+used, out_len-used, "new SET, PATHDIV_var[%d]= (( %d ))\n", i, var1[i]));*/
2158                                 input_idx++;
2159                         }
2160                 }
2161
2162                 if (input_idx >= 1) {
2163                         /*PHYDM_SNPRINTF((output+used, out_len-used, "odm_PATHDIV_debug\n"));*/
2164 #if (defined(CONFIG_PATH_DIVERSITY))
2165                         odm_pathdiv_debug(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2166 #endif
2167                 }
2168
2169                 break;
2170
2171         case PHYDM_DEBUG:
2172
2173                 for (i = 0; i < 5; i++) {
2174                         if (input[i + 1]) {
2175                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2176
2177                                 /*PHYDM_SNPRINTF((output+used, out_len-used, "new SET, Debug_var[%d]= (( %d ))\n", i, var1[i]));*/
2178                                 input_idx++;
2179                         }
2180                 }
2181
2182                 if (input_idx >= 1) {
2183                         /*PHYDM_SNPRINTF((output+used, out_len-used, "odm_debug_comp\n"));*/
2184                         phydm_debug_trace(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2185                 }
2186
2187
2188                 break;
2189
2190         case PHYDM_FW_DEBUG:
2191
2192                 for (i = 0; i < 5; i++) {
2193                         if (input[i + 1]) {
2194                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2195                                 input_idx++;
2196                         }
2197                 }
2198
2199                 if (input_idx >= 1)
2200                         phydm_fw_debug_trace(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2201
2202                 break;
2203
2204         case PHYDM_SUPPORT_ABILITY:
2205
2206                 for (i = 0; i < 5; i++) {
2207                         if (input[i + 1]) {
2208                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2209
2210                                 /*PHYDM_SNPRINTF((output+used, out_len-used, "new SET, support ablity_var[%d]= (( %d ))\n", i, var1[i]));*/
2211                                 input_idx++;
2212                         }
2213                 }
2214
2215                 if (input_idx >= 1) {
2216                         /*PHYDM_SNPRINTF((output+used, out_len-used, "support ablity\n"));*/
2217                         phydm_support_ability_debug(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2218                 }
2219
2220                 break;
2221
2222         case PHYDM_SMART_ANT:
2223
2224                 for (i = 0; i < 5; i++) {
2225                         if (input[i + 1]) {
2226                                 PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]);
2227                                 input_idx++;
2228                         }
2229                 }
2230
2231                 if (input_idx >= 1) {
2232 #if (defined(CONFIG_PHYDM_ANTENNA_DIVERSITY))
2233 #if (defined(CONFIG_HL_SMART_ANTENNA_TYPE1)) || (defined(CONFIG_HL_SMART_ANTENNA_TYPE2))
2234                         phydm_hl_smart_ant_debug(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2235 #endif
2236 #endif
2237                 }
2238
2239                 break;
2240
2241         case PHYDM_API:
2242 #if (RTL8822B_SUPPORT == 1 || RTL8197F_SUPPORT == 1 || RTL8821C_SUPPORT == 1)
2243                 {
2244                         if (p_dm_odm->support_ic_type & (ODM_RTL8822B | ODM_RTL8197F | ODM_RTL8821C)) {
2245                                 boolean is_enable_dbg_mode;
2246                                 u8 central_ch, primary_ch_idx, bandwidth;
2247
2248                                 for (i = 0; i < 4; i++) {
2249                                         if (input[i + 1])
2250                                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2251                                 }
2252
2253                                 is_enable_dbg_mode = (boolean)var1[0];
2254                                 central_ch = (u8) var1[1];
2255                                 primary_ch_idx = (u8) var1[2];
2256                                 bandwidth = (enum odm_bw_e) var1[3];
2257
2258                                 if (is_enable_dbg_mode) {
2259                                         p_dm_odm->is_disable_phy_api = false;
2260                                         phydm_api_switch_bw_channel(p_dm_odm, central_ch, primary_ch_idx, (enum odm_bw_e) bandwidth);
2261                                         p_dm_odm->is_disable_phy_api = true;
2262                                         PHYDM_SNPRINTF((output + used, out_len - used, "central_ch = %d, primary_ch_idx = %d, bandwidth = %d\n", central_ch, primary_ch_idx, bandwidth));
2263                                 } else {
2264                                         p_dm_odm->is_disable_phy_api = false;
2265                                         PHYDM_SNPRINTF((output + used, out_len - used, "Disable API debug mode\n"));
2266                                 }
2267                         } else
2268                                 PHYDM_SNPRINTF((output + used, out_len - used, "This IC doesn't support PHYDM API function\n"));
2269                 }
2270 #else
2271                 PHYDM_SNPRINTF((output + used, out_len - used, "This IC doesn't support PHYDM API function\n"));
2272 #endif
2273                 break;
2274
2275         case PHYDM_PROFILE: /*echo profile, >cmd*/
2276                 phydm_basic_profile(p_dm_odm, &used, output, &out_len);
2277                 break;
2278
2279         case PHYDM_GET_TXAGC:
2280                 phydm_get_txagc(p_dm_odm, &used, output, &out_len);
2281                 break;
2282
2283         case PHYDM_SET_TXAGC:
2284         {
2285                 boolean         is_enable_dbg_mode;
2286
2287                 for (i = 0; i < 5; i++) {
2288                         if (input[i + 1]) {
2289                                 PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]);
2290                                 input_idx++;
2291                         }
2292                 }
2293
2294                 if ((strcmp(input[1], help) == 0)) {
2295                         PHYDM_SNPRINTF((output + used, out_len - used, "{En} {pathA~D(0~3)} {rate_idx(Hex), All_rate:0xff} {txagc_idx (Hex)}\n"));
2296                         /**/
2297
2298                 } else {
2299
2300                         is_enable_dbg_mode = (boolean)var1[0];
2301                         if (is_enable_dbg_mode) {
2302                                 p_dm_odm->is_disable_phy_api = false;
2303                                 phydm_set_txagc(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2304                                 p_dm_odm->is_disable_phy_api = true;
2305                         } else {
2306                                 p_dm_odm->is_disable_phy_api = false;
2307                                 PHYDM_SNPRINTF((output + used, out_len - used, "Disable API debug mode\n"));
2308                         }
2309                 }
2310         }
2311         break;
2312
2313         case PHYDM_TRX_PATH:
2314
2315                 for (i = 0; i < 4; i++) {
2316                         if (input[i + 1])
2317                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2318                 }
2319 #if (RTL8822B_SUPPORT == 1 || RTL8197F_SUPPORT == 1)
2320                 if (p_dm_odm->support_ic_type & (ODM_RTL8822B | ODM_RTL8197F)) {
2321                         u8              tx_path, rx_path;
2322                         boolean         is_enable_dbg_mode, is_tx2_path;
2323
2324                         is_enable_dbg_mode = (boolean)var1[0];
2325                         tx_path = (u8) var1[1];
2326                         rx_path = (u8) var1[2];
2327                         is_tx2_path = (boolean) var1[3];
2328
2329                         if (is_enable_dbg_mode) {
2330                                 p_dm_odm->is_disable_phy_api = false;
2331                                 phydm_api_trx_mode(p_dm_odm, (enum odm_rf_path_e) tx_path, (enum odm_rf_path_e) rx_path, is_tx2_path);
2332                                 p_dm_odm->is_disable_phy_api = true;
2333                                 PHYDM_SNPRINTF((output + used, out_len - used, "tx_path = 0x%x, rx_path = 0x%x, is_tx2_path = %d\n", tx_path, rx_path, is_tx2_path));
2334                         } else {
2335                                 p_dm_odm->is_disable_phy_api = false;
2336                                 PHYDM_SNPRINTF((output + used, out_len - used, "Disable API debug mode\n"));
2337                         }
2338                 } else
2339 #endif
2340                         phydm_config_trx_path(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2341
2342                 break;
2343
2344         case PHYDM_LA_MODE:
2345
2346 #if (PHYDM_LA_MODE_SUPPORT == 1)
2347                 p_dm_odm->support_ability &= ~(ODM_BB_FA_CNT);
2348                 phydm_lamode_trigger_setting(p_dm_odm, &input[0], &used, output, &out_len, input_num);
2349                 p_dm_odm->support_ability |= ODM_BB_FA_CNT;
2350 #else
2351                 PHYDM_SNPRINTF((output + used, out_len - used, "This IC doesn't support LA mode\n"));
2352 #endif
2353
2354                 break;
2355
2356         case PHYDM_DUMP_REG:
2357         {
2358                 u8      type = 0;
2359
2360                 if (input[1]) {
2361                         PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2362                         type = (u8)var1[0];
2363                 }
2364
2365                 if (type == 0)
2366                         phydm_dump_bb_reg(p_dm_odm, &used, output, &out_len);
2367                 else if (type == 1)
2368                         phydm_dump_all_reg(p_dm_odm, &used, output, &out_len);
2369         }
2370         break;
2371
2372         case PHYDM_MU_MIMO:
2373 #if (RTL8822B_SUPPORT == 1)
2374
2375                 if (input[1])
2376                         PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2377                 else
2378                         var1[0] = 0;
2379
2380                 if (var1[0] == 1) {
2381                         int index, ptr;
2382                         u32 dword_h, dword_l;
2383
2384                         PHYDM_SNPRINTF((output + used, out_len - used, "Get MU BFee CSI\n"));
2385                         odm_set_bb_reg(p_dm_odm, 0x9e8, BIT(17) | BIT16, 2); /*Read BFee*/
2386                         odm_set_bb_reg(p_dm_odm, 0x1910, BIT(15), 1); /*Select BFee's CSI report*/
2387                         odm_set_bb_reg(p_dm_odm, 0x19b8, BIT(6), 1); /*set as CSI report*/
2388                         odm_set_bb_reg(p_dm_odm, 0x19a8, 0xFFFF, 0xFFFF); /*disable gated_clk*/
2389
2390                         for (index = 0; index < 80; index++) {
2391                                 ptr = index + 256;
2392                                 if (ptr > 311)
2393                                         ptr -= 312;
2394                                 odm_set_bb_reg(p_dm_odm, 0x1910, 0x03FF0000, ptr); /*Select Address*/
2395                                 dword_h = odm_get_bb_reg(p_dm_odm, 0xF74, MASKDWORD);
2396                                 dword_l = odm_get_bb_reg(p_dm_odm, 0xF5C, MASKDWORD);
2397                                 if (index % 2 == 0)
2398                                         PHYDM_SNPRINTF((output + used, out_len - used, "%02x  %02x  %02x  %02x  %02x  %02x  %02x  %02x\n",
2399                                                 dword_l & MASKBYTE0, (dword_l & MASKBYTE1) >> 8, (dword_l & MASKBYTE2) >> 16, (dword_l & MASKBYTE3) >> 24,
2400                                                 dword_h & MASKBYTE0, (dword_h & MASKBYTE1) >> 8, (dword_h & MASKBYTE2) >> 16, (dword_h & MASKBYTE3) >> 24));
2401                                 else
2402                                         PHYDM_SNPRINTF((output + used, out_len - used, "%02x  %02x  %02x  %02x  %02x  %02x  %02x  %02x\n",
2403                                                 dword_l & MASKBYTE0, (dword_l & MASKBYTE1) >> 8, (dword_l & MASKBYTE2) >> 16, (dword_l & MASKBYTE3) >> 24,
2404                                                 dword_h & MASKBYTE0, (dword_h & MASKBYTE1) >> 8, (dword_h & MASKBYTE2) >> 16, (dword_h & MASKBYTE3) >> 24));
2405                         }
2406                 } else if (var1[0] == 2) {
2407                         int index, ptr;
2408                         u32 dword_h, dword_l;
2409
2410                         PHYDM_SSCANF(input[2], DCMD_DECIMAL, &var1[1]);
2411                         PHYDM_SNPRINTF((output + used, out_len - used, "Get MU BFer's STA%d CSI\n", var1[1]));
2412                         odm_set_bb_reg(p_dm_odm, 0x9e8, BIT(24), 0); /*Read BFer*/
2413                         odm_set_bb_reg(p_dm_odm, 0x9e8, BIT(25), 1); /*enable Read/Write RAM*/
2414                         odm_set_bb_reg(p_dm_odm, 0x9e8, BIT(30) | BIT29 | BIT28, var1[1]); /*read which STA's CSI report*/
2415                         odm_set_bb_reg(p_dm_odm, 0x1910, BIT(15), 0); /*select BFer's CSI*/
2416                         odm_set_bb_reg(p_dm_odm, 0x19e0, 0x00003FC0, 0xFF); /*disable gated_clk*/
2417
2418                         for (index = 0; index < 80; index++) {
2419                                 ptr = index + 256;
2420                                 if (ptr > 311)
2421                                         ptr -= 312;
2422                                 odm_set_bb_reg(p_dm_odm, 0x1910, 0x03FF0000, ptr); /*Select Address*/
2423                                 dword_h = odm_get_bb_reg(p_dm_odm, 0xF74, MASKDWORD);
2424                                 dword_l = odm_get_bb_reg(p_dm_odm, 0xF5C, MASKDWORD);
2425                                 if (index % 2 == 0)
2426                                         PHYDM_SNPRINTF((output + used, out_len - used, "%02x  %02x  %02x  %02x  %02x  %02x  %02x  %02x\n",
2427                                                 dword_l & MASKBYTE0, (dword_l & MASKBYTE1) >> 8, (dword_l & MASKBYTE2) >> 16, (dword_l & MASKBYTE3) >> 24,
2428                                                 dword_h & MASKBYTE0, (dword_h & MASKBYTE1) >> 8, (dword_h & MASKBYTE2) >> 16, (dword_h & MASKBYTE3) >> 24));
2429                                 else
2430                                         PHYDM_SNPRINTF((output + used, out_len - used, "%02x  %02x  %02x  %02x  %02x  %02x  %02x  %02x\n",
2431                                                 dword_l & MASKBYTE0, (dword_l & MASKBYTE1) >> 8, (dword_l & MASKBYTE2) >> 16, (dword_l & MASKBYTE3) >> 24,
2432                                                 dword_h & MASKBYTE0, (dword_h & MASKBYTE1) >> 8, (dword_h & MASKBYTE2) >> 16, (dword_h & MASKBYTE3) >> 24));
2433
2434                                 PHYDM_SNPRINTF((output + used, out_len - used, "ptr=%d : 0x%8x  %8x\n", ptr, dword_h, dword_l));
2435                         }
2436
2437                 }
2438 #endif
2439                 break;
2440
2441         case PHYDM_BIG_JUMP:
2442         {
2443 #if (RTL8822B_SUPPORT == 1)
2444                 if (input[1]) {
2445                         PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2446                         phydm_enable_big_jump(p_dm_odm, (boolean)(var1[0]));
2447                 } else
2448                         PHYDM_SNPRINTF((output + used, out_len - used, "unknown command!\n"));
2449 #else
2450                 PHYDM_SNPRINTF((output + used, out_len - used, "The command is only for 8822B!\n"));
2451 #endif
2452                 break;
2453         }
2454
2455         case PHYDM_HANG:
2456                 phydm_bb_rx_hang_info(p_dm_odm, &used, output, &out_len);
2457                 break;
2458
2459         case PHYDM_SHOW_RXRATE:
2460 #if (RTL8822B_SUPPORT == 1)
2461                 {
2462                         u8      rate_idx;
2463
2464                         if (input[1])
2465                                 PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2466
2467                         if (var1[0] == 1)
2468                                 phydm_show_rx_rate(p_dm_odm, &used, output, &out_len);
2469                         else {
2470                                 PHYDM_SNPRINTF((output + used, out_len - used, "Reset Rx rate counter\n"));
2471
2472                                 for (rate_idx = 0; rate_idx < 40; rate_idx++) {
2473                                         p_dm_odm->phy_dbg_info.num_qry_vht_pkt[rate_idx] = 0;
2474                                         p_dm_odm->phy_dbg_info.num_qry_mu_vht_pkt[rate_idx] = 0;
2475                                 }
2476                         }
2477                 }
2478 #endif
2479                 break;
2480
2481         case PHYDM_NBI_EN:
2482
2483                 for (i = 0; i < 5; i++) {
2484                         if (input[i + 1]) {
2485                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2486                                 input_idx++;
2487                         }
2488                 }
2489
2490                 if (input_idx >= 1) {
2491
2492                         phydm_api_debug(p_dm_odm, PHYDM_API_NBI, (u32 *)var1, &used, output, &out_len);
2493                         /**/
2494                 }
2495
2496
2497                 break;
2498
2499         case PHYDM_CSI_MASK_EN:
2500
2501                 for (i = 0; i < 5; i++) {
2502                         if (input[i + 1]) {
2503                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2504                                 input_idx++;
2505                         }
2506                 }
2507
2508                 if (input_idx >= 1) {
2509
2510                         phydm_api_debug(p_dm_odm, PHYDM_API_CSI_MASK, (u32 *)var1, &used, output, &out_len);
2511                         /**/
2512                 }
2513
2514
2515                 break;
2516
2517         case PHYDM_DFS:
2518 #if (DM_ODM_SUPPORT_TYPE & ODM_CE)
2519                 {
2520                         u32 var[6] = {0};
2521
2522                         for (i = 0; i < 6; i++) {
2523                                 if (input[i + 1]) {
2524                                         PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var[i]);
2525                                         input_idx++;
2526                                 }
2527                         }
2528
2529                         if (input_idx >= 1)
2530                                 phydm_dfs_debug(p_dm_odm, var, &used, output, &out_len);
2531                 }
2532 #endif
2533                 break;
2534
2535         case PHYDM_IQK:
2536 #if (DM_ODM_SUPPORT_TYPE & ODM_AP)
2537                 phy_iq_calibrate(p_dm_odm->priv);
2538                 PHYDM_SNPRINTF((output + used, out_len - used, "IQK !!\n"));
2539 #elif (DM_ODM_SUPPORT_TYPE & ODM_WIN)
2540                 PHY_IQCalibrate(p_dm_odm->adapter, false);
2541                 PHYDM_SNPRINTF((output + used, out_len - used, "IQK !!\n"));
2542 #endif
2543                 break;
2544
2545         case PHYDM_NHM:
2546         {
2547                 u8              target_rssi;
2548                 u32             value32;
2549                 u16             nhm_period = 0xC350;    /* 200ms */
2550                 u8              IGI;
2551                 struct _CCX_INFO        *ccx_info = &p_dm_odm->dm_ccx_info;
2552
2553                 PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2554
2555                 if (input_num == 1) {
2556
2557                         ccx_info->echo_NHM_en = false;
2558                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n Trigger NHM: echo nhm 1\n"));
2559                         PHYDM_SNPRINTF((output + used, out_len - used, "\r (Exclude CCA)\n"));
2560                         PHYDM_SNPRINTF((output + used, out_len - used, "\r Trigger NHM: echo nhm 2\n"));
2561                         PHYDM_SNPRINTF((output + used, out_len - used, "\r (Include CCA)\n"));
2562                         PHYDM_SNPRINTF((output + used, out_len - used, "\r Get NHM results: echo nhm 3\n"));
2563
2564                         return;
2565                 }
2566
2567                 /* NMH trigger */
2568                 if ((var1[0] <= 2) && (var1[0] != 0)) {
2569
2570                         ccx_info->echo_NHM_en = true;
2571                         ccx_info->echo_IGI = (u8)odm_get_bb_reg(p_dm_odm, 0xC50, MASKBYTE0);
2572
2573                         target_rssi = ccx_info->echo_IGI - 10;
2574
2575                         ccx_info->NHM_th[0] = (target_rssi - 15 + 10) * 2;
2576
2577                         for (i = 1; i <= 10; i++)
2578                                 ccx_info->NHM_th[i] = ccx_info->NHM_th[0] + 6 * i;
2579
2580                         /* 4 1. store previous NHM setting */
2581                         phydm_nhm_setting(p_dm_odm, STORE_NHM_SETTING);
2582
2583                         /* 4 2. Set NHM period, 0x990[31:16]=0xC350, Time duration for NHM unit: 4us, 0xC350=200ms */
2584                         ccx_info->NHM_period = nhm_period;
2585
2586                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n Monitor NHM for %d us", nhm_period * 4));
2587
2588                         /* 4 3. Set NHM inexclude_txon, inexclude_cca, ccx_en */
2589
2590
2591                         ccx_info->nhm_inexclude_cca = (var1[0] == 1) ? NHM_EXCLUDE_CCA : NHM_INCLUDE_CCA;
2592                         ccx_info->nhm_inexclude_txon = NHM_EXCLUDE_TXON;
2593
2594                         phydm_nhm_setting(p_dm_odm, SET_NHM_SETTING);
2595
2596                         for (i = 0; i <= 10; i++) {
2597
2598                                 if (i == 5)
2599                                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n NHM_th[%d] = 0x%x, echo_IGI = 0x%x", i, ccx_info->NHM_th[i], ccx_info->echo_IGI));
2600                                 else if (i == 10)
2601                                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n NHM_th[%d] = 0x%x\n", i, ccx_info->NHM_th[i]));
2602                                 else
2603                                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n NHM_th[%d] = 0x%x", i, ccx_info->NHM_th[i]));
2604                         }
2605
2606                         /* 4 4. Trigger NHM */
2607                         phydm_nhm_trigger(p_dm_odm);
2608
2609                 }
2610
2611                 /*Get NHM results*/
2612                 else if (var1[0] == 3) {
2613
2614                         IGI = (u8)odm_get_bb_reg(p_dm_odm, 0xC50, MASKBYTE0);
2615
2616                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n Cur_IGI = 0x%x", IGI));
2617
2618                         phydm_get_nhm_result(p_dm_odm);
2619
2620                         /* 4 Resotre NHM setting */
2621                         phydm_nhm_setting(p_dm_odm, RESTORE_NHM_SETTING);
2622
2623                         for (i = 0; i <= 11; i++) {
2624
2625                                 if (i == 5)
2626                                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n nhm_result[%d] = %d, echo_IGI = 0x%x", i, ccx_info->NHM_result[i], ccx_info->echo_IGI));
2627                                 else if (i == 11)
2628                                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n nhm_result[%d] = %d\n", i, ccx_info->NHM_result[i]));
2629                                 else
2630                                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n nhm_result[%d] = %d", i, ccx_info->NHM_result[i]));
2631                         }
2632
2633                         ccx_info->echo_NHM_en = false;
2634                 } else {
2635
2636                         ccx_info->echo_NHM_en = false;
2637                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n Trigger NHM: echo nhm 1\n"));
2638                         PHYDM_SNPRINTF((output + used, out_len - used, "\r (Exclude CCA)\n"));
2639                         PHYDM_SNPRINTF((output + used, out_len - used, "\r Trigger NHM: echo nhm 2\n"));
2640                         PHYDM_SNPRINTF((output + used, out_len - used, "\r (Include CCA)\n"));
2641                         PHYDM_SNPRINTF((output + used, out_len - used, "\r Get NHM results: echo nhm 3\n"));
2642
2643                         return;
2644                 }
2645         }
2646         break;
2647
2648         case PHYDM_CLM:
2649         {
2650                 struct _CCX_INFO        *ccx_info = &p_dm_odm->dm_ccx_info;
2651                 PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2652
2653                 /* PHYDM_SNPRINTF((output + used, out_len - used, "\r\n input_num = %d\n", input_num)); */
2654
2655                 if (input_num == 1) {
2656
2657                         ccx_info->echo_CLM_en = false;
2658                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n Trigger CLM: echo clm 1\n"));
2659                         PHYDM_SNPRINTF((output + used, out_len - used, "\r Get CLM results: echo clm 2\n"));
2660                         return;
2661                 }
2662
2663                 /* Set & trigger CLM */
2664                 if (var1[0] == 1) {
2665
2666                         ccx_info->echo_CLM_en = true;
2667                         ccx_info->CLM_period = 0xC350;          /*100ms*/
2668                         phydm_clm_setting(p_dm_odm);
2669                         phydm_clm_trigger(p_dm_odm);
2670                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n Monitor CLM for 200ms\n"));
2671                 }
2672
2673                 /* Get CLM results */
2674                 else if (var1[0] == 2) {
2675
2676                         ccx_info->echo_CLM_en = false;
2677                         phydm_get_cl_mresult(p_dm_odm);
2678                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n CLM_result = %d us\n", ccx_info->CLM_result * 4));
2679
2680                 } else {
2681
2682                         ccx_info->echo_CLM_en = false;
2683                         PHYDM_SNPRINTF((output + used, out_len - used, "\n\r Error command !\n"));
2684                         PHYDM_SNPRINTF((output + used, out_len - used, "\r Trigger CLM: echo clm 1\n"));
2685                         PHYDM_SNPRINTF((output + used, out_len - used, "\r Get CLM results: echo clm 2\n"));
2686                 }
2687         }
2688         break;
2689
2690         case PHYDM_BB_INFO:
2691         {
2692                 s32 value32 = 0;
2693
2694                 phydm_bb_debug_info(p_dm_odm, &used, output, &out_len);
2695
2696                 if (p_dm_odm->support_ic_type & ODM_RTL8822B && input[1]) {
2697                         PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2698                         odm_set_bb_reg(p_dm_odm, 0x1988, 0x003fff00, var1[0]);
2699                         value32 = odm_get_bb_reg(p_dm_odm, 0xf84, MASKDWORD);
2700                         value32 = (value32 & 0xff000000) >> 24;
2701                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n %-35s = condition num = %d, subcarriers = %d\n", "Over condition num subcarrier", var1[0], value32));
2702                         odm_set_bb_reg(p_dm_odm, 0x1988, BIT(22), 0x0); /*disable report condition number*/
2703                 }
2704         }
2705         break;
2706
2707         case PHYDM_TXBF:
2708         {
2709 #if (DM_ODM_SUPPORT_TYPE & (ODM_WIN | ODM_CE))
2710 #if (BEAMFORMING_SUPPORT == 1)
2711                 struct _RT_BEAMFORMING_INFO     *p_beamforming_info = &p_dm_odm->beamforming_info;
2712
2713                 PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2714                 if (var1[0] == 0) {
2715                         p_beamforming_info->apply_v_matrix = false;
2716                         p_beamforming_info->snding3ss = true;
2717                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n dont apply V matrix and 3SS 789 snding\n"));
2718                 } else if (var1[0] == 1) {
2719                         p_beamforming_info->apply_v_matrix = true;
2720                         p_beamforming_info->snding3ss = true;
2721                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n apply V matrix and 3SS 789 snding\n"));
2722                 } else if (var1[0] == 2) {
2723                         p_beamforming_info->apply_v_matrix = true;
2724                         p_beamforming_info->snding3ss = false;
2725                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n default txbf setting\n"));
2726                 } else
2727                         PHYDM_SNPRINTF((output + used, out_len - used, "\r\n unknown cmd!!\n"));
2728 #else
2729                 PHYDM_SNPRINTF((output + used, out_len - used, "\r\n no TxBF !!\n"));
2730 #endif
2731 #endif
2732         }
2733         break;
2734
2735         case PHYDM_PAUSE_DIG_EN:
2736
2737
2738                 for (i = 0; i < 5; i++) {
2739                         if (input[i + 1]) {
2740                                 PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]);
2741                                 input_idx++;
2742                         }
2743                 }
2744
2745                 if (input_idx >= 1) {
2746                         if (var1[0] == 0) {
2747                                 odm_pause_dig(p_dm_odm, PHYDM_PAUSE, PHYDM_PAUSE_LEVEL_7, (u8)var1[1]);
2748                                 PHYDM_SNPRINTF((output + used, out_len - used, "Set IGI_value = ((%x))\n", var1[1]));
2749                         } else if (var1[0] == 1) {
2750                                 odm_pause_dig(p_dm_odm, PHYDM_RESUME, PHYDM_PAUSE_LEVEL_7, (u8)var1[1]);
2751                                 PHYDM_SNPRINTF((output + used, out_len - used, "Resume IGI_value\n"));
2752                         } else
2753                                 PHYDM_SNPRINTF((output + used, out_len - used, "echo  (1:pause, 2resume)  (IGI_value)\n"));
2754                 }
2755
2756                 break;
2757
2758         case PHYDM_H2C:
2759
2760                 for (i = 0; i < 8; i++) {
2761                         if (input[i + 1]) {
2762                                 PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]);
2763                                 input_idx++;
2764                         }
2765                 }
2766
2767                 if (input_idx >= 1)
2768                         phydm_h2C_debug(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2769
2770
2771                 break;
2772
2773         case PHYDM_ANT_SWITCH:
2774
2775                 for (i = 0; i < 8; i++) {
2776                         if (input[i + 1]) {
2777                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2778                                 input_idx++;
2779                         }
2780                 }
2781
2782                 if (input_idx >= 1) {
2783
2784 #if (RTL8821A_SUPPORT == 1)
2785                         if (p_dm_odm->support_ic_type == ODM_RTL8821)
2786                                 phydm_set_ext_switch(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2787                         else
2788                                 PHYDM_SNPRINTF((output + used, out_len - used, "Not Support IC"));
2789 #endif
2790                 }
2791
2792
2793                 break;
2794
2795         case PHYDM_DYNAMIC_RA_PATH:
2796
2797 #if (CONFIG_DYNAMIC_RX_PATH == 1)
2798                 for (i = 0; i < 8; i++) {
2799                         if (input[i + 1]) {
2800                                 PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]);
2801                                 input_idx++;
2802                         }
2803                 }
2804
2805                 if (input_idx >= 1)
2806                         phydm_drp_debug(p_dm_odm, (u32 *)var1, &used, output, &out_len);
2807
2808 #else
2809                 PHYDM_SNPRINTF((output + used, out_len - used, "Not Support IC"));
2810 #endif
2811
2812                 break;
2813
2814         case PHYDM_PSD:
2815
2816                 #if (CONFIG_PSD_TOOL== 1)
2817                 phydm_psd_debug(p_dm_odm, &input[0], &used, output, &out_len, input_num);
2818                 #endif
2819
2820                 break;
2821
2822         case PHYDM_DEBUG_PORT:
2823                 {
2824                         u32     dbg_port_value;
2825
2826                         PHYDM_SSCANF(input[1], DCMD_HEX, &var1[0]);
2827
2828                         if (phydm_set_bb_dbg_port(p_dm_odm, BB_DBGPORT_PRIORITY_3, var1[0])) {/*set debug port to 0x0*/
2829
2830                                 dbg_port_value = phydm_get_bb_dbg_port_value(p_dm_odm);
2831                                 phydm_release_bb_dbg_port(p_dm_odm);
2832
2833                                 PHYDM_SNPRINTF((output + used, out_len - used, "Debug Port[0x%x] = ((0x%x))\n", var1[1], dbg_port_value));
2834                         }
2835                 }
2836                 break;
2837
2838         case PHYDM_HTSTF_CONTROL:
2839                 {
2840                         if (input[1])
2841                                 PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]);
2842
2843                         if (var1[0] == 1) {
2844                                 /* phydm_dynamic_switch_htstf_mumimo_8822b(p_dm_odm);*/
2845                                 p_dm_odm->bhtstfenabled = TRUE;
2846                                 PHYDM_SNPRINTF((output + used, out_len - used, "Dynamic HT-STF Gain Control is Enable\n"));
2847                         }
2848                         else {
2849                                 p_dm_odm->bhtstfenabled = FALSE;
2850                                 PHYDM_SNPRINTF((output + used, out_len - used, "Dynamic HT-STF Gain Control is Disable\n"));
2851                         }
2852                 }
2853                 break;
2854         default:
2855                 PHYDM_SNPRINTF((output + used, out_len - used, "SET, unknown command!\n"));
2856                 break;
2857
2858         }
2859 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
2860 }
2861
2862 #ifdef __ECOS
2863 char *strsep(char **s, const char *ct)
2864 {
2865         char *sbegin = *s;
2866         char *end;
2867
2868         if (sbegin == NULL)
2869                 return NULL;
2870
2871         end = strpbrk(sbegin, ct);
2872         if (end)
2873                 *end++ = '\0';
2874         *s = end;
2875         return sbegin;
2876 }
2877 #endif
2878
2879 #if (DM_ODM_SUPPORT_TYPE & (ODM_CE | ODM_AP))
2880 s32
2881 phydm_cmd(
2882         struct PHY_DM_STRUCT    *p_dm_odm,
2883         char            *input,
2884         u32     in_len,
2885         u8      flag,
2886         char    *output,
2887         u32     out_len
2888 )
2889 {
2890         char *token;
2891         u32     argc = 0;
2892         char            argv[MAX_ARGC][MAX_ARGV];
2893
2894         do {
2895                 token = strsep(&input, ", ");
2896                 if (token) {
2897                         strcpy(argv[argc], token);
2898                         argc++;
2899                 } else
2900                         break;
2901         } while (argc < MAX_ARGC);
2902
2903         if (argc == 1)
2904                 argv[0][strlen(argv[0]) - 1] = '\0';
2905
2906         phydm_cmd_parser(p_dm_odm, argv, argc, flag, output, out_len);
2907
2908         return 0;
2909 }
2910 #endif
2911
2912
2913 void
2914 phydm_fw_trace_handler(
2915         void    *p_dm_void,
2916         u8      *cmd_buf,
2917         u8      cmd_len
2918 )
2919 {
2920 #if CONFIG_PHYDM_DEBUG_FUNCTION
2921         struct PHY_DM_STRUCT            *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
2922
2923         /*u8    debug_trace_11byte[60];*/
2924         u8              freg_num, c2h_seq, buf_0 = 0;
2925
2926         if (!(p_dm_odm->support_ic_type & PHYDM_IC_3081_SERIES))
2927                 return;
2928
2929         if (cmd_len > 12)
2930                 return;
2931
2932         buf_0 = cmd_buf[0];
2933         freg_num = (buf_0 & 0xf);
2934         c2h_seq = (buf_0 & 0xf0) >> 4;
2935         /*ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE,ODM_DBG_LOUD,("[FW debug message] freg_num = (( %d )), c2h_seq = (( %d ))\n", freg_num,c2h_seq ));*/
2936
2937         /*strncpy(debug_trace_11byte,&cmd_buf[1],(cmd_len-1));*/
2938         /*debug_trace_11byte[cmd_len-1] = '\0';*/
2939         /*ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE,ODM_DBG_LOUD,("[FW debug message] %s\n", debug_trace_11byte));*/
2940         /*ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE,ODM_DBG_LOUD,("[FW debug message] cmd_len = (( %d ))\n", cmd_len));*/
2941         /*ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE,ODM_DBG_LOUD,("[FW debug message] c2h_cmd_start  = (( %d ))\n", p_dm_odm->c2h_cmd_start));*/
2942
2943
2944
2945         /*ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE,ODM_DBG_LOUD,("pre_seq = (( %d )), current_seq = (( %d ))\n", p_dm_odm->pre_c2h_seq, c2h_seq));*/
2946         /*ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE,ODM_DBG_LOUD,("fw_buff_is_enpty = (( %d ))\n", p_dm_odm->fw_buff_is_enpty));*/
2947
2948         if ((c2h_seq != p_dm_odm->pre_c2h_seq)  &&  p_dm_odm->fw_buff_is_enpty == false) {
2949                 p_dm_odm->fw_debug_trace[p_dm_odm->c2h_cmd_start] = '\0';
2950                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW Dbg Queue Overflow] %s\n", p_dm_odm->fw_debug_trace));
2951                 p_dm_odm->c2h_cmd_start = 0;
2952         }
2953
2954         if ((cmd_len - 1) > (60 - p_dm_odm->c2h_cmd_start)) {
2955                 p_dm_odm->fw_debug_trace[p_dm_odm->c2h_cmd_start] = '\0';
2956                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW Dbg Queue error: wrong C2H length] %s\n", p_dm_odm->fw_debug_trace));
2957                 p_dm_odm->c2h_cmd_start = 0;
2958                 return;
2959         }
2960
2961         strncpy((char *)&(p_dm_odm->fw_debug_trace[p_dm_odm->c2h_cmd_start]), (char *)&cmd_buf[1], (cmd_len - 1));
2962         p_dm_odm->c2h_cmd_start += (cmd_len - 1);
2963         p_dm_odm->fw_buff_is_enpty = false;
2964
2965         if (freg_num == 0 || p_dm_odm->c2h_cmd_start >= 60) {
2966                 if (p_dm_odm->c2h_cmd_start < 60)
2967                         p_dm_odm->fw_debug_trace[p_dm_odm->c2h_cmd_start] = '\0';
2968                 else
2969                         p_dm_odm->fw_debug_trace[59] = '\0';
2970
2971                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW DBG Msg] %s\n", p_dm_odm->fw_debug_trace));
2972                 /*dbg_print("[FW DBG Msg] %s\n", p_dm_odm->fw_debug_trace);*/
2973                 p_dm_odm->c2h_cmd_start = 0;
2974                 p_dm_odm->fw_buff_is_enpty = true;
2975         }
2976
2977         p_dm_odm->pre_c2h_seq = c2h_seq;
2978 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
2979 }
2980
2981 void
2982 phydm_fw_trace_handler_code(
2983         void    *p_dm_void,
2984         u8      *buffer,
2985         u8      cmd_len
2986 )
2987 {
2988 #if CONFIG_PHYDM_DEBUG_FUNCTION
2989         struct PHY_DM_STRUCT    *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
2990         u8      function = buffer[0];
2991         u8      dbg_num = buffer[1];
2992         u16     content_0 = (((u16)buffer[3]) << 8) | ((u16)buffer[2]);
2993         u16     content_1 = (((u16)buffer[5]) << 8) | ((u16)buffer[4]);
2994         u16     content_2 = (((u16)buffer[7]) << 8) | ((u16)buffer[6]);
2995         u16     content_3 = (((u16)buffer[9]) << 8) | ((u16)buffer[8]);
2996         u16     content_4 = (((u16)buffer[11]) << 8) | ((u16)buffer[10]);
2997
2998         if (cmd_len > 12)
2999                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW Msg] Invalid cmd length (( %d )) >12\n", cmd_len));
3000
3001         /* ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE,ODM_DBG_LOUD,("[FW Msg] Func=((%d)),  num=((%d)), ct_0=((%d)), ct_1=((%d)), ct_2=((%d)), ct_3=((%d)), ct_4=((%d))\n", */
3002         /*      function, dbg_num, content_0, content_1, content_2, content_3, content_4)); */
3003
3004         /*--------------------------------------------*/
3005 #if (CONFIG_RA_FW_DBG_CODE)
3006         if (function == RATE_DECISION) {
3007                 if (dbg_num == 0) {
3008                         if (content_0 == 1)
3009                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] RA_CNT=((%d))  Max_device=((%d))--------------------------->\n", content_1, content_2));
3010                         else if (content_0 == 2)
3011                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] Check RA macid= ((%d)), MediaStatus=((%d)), Dis_RA=((%d)),  try_bit=((0x%x))\n", content_1, content_2, content_3, content_4));
3012                         else if (content_0 == 3)
3013                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] Check RA  total=((%d)),  drop=((0x%x)), TXRPT_TRY_bit=((%x)), bNoisy=((%x))\n", content_1, content_2, content_3, content_4));
3014                 } else if (dbg_num == 1) {
3015                         if (content_0 == 1)
3016                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] RTY[0,1,2,3]=[ %d , %d , %d , %d ]\n", content_1, content_2, content_3, content_4));
3017                         else if (content_0 == 2) {
3018                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] RTY[4]=[ %d ], drop=(( %d )), total=(( %d )), current_rate=((0x %x ))", content_1, content_2, content_3, content_4));
3019                                 phydm_print_rate(p_dm_odm, (u8)content_4, ODM_FW_DEBUG_TRACE);
3020                         } else if (content_0 == 3)
3021                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] penality_idx=(( %d ))\n", content_1));
3022                         else if (content_0 == 4)
3023                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] RSSI=(( %d )), ra_stage = (( %d ))\n", content_1, content_2));
3024                 }
3025
3026                 else if (dbg_num == 3) {
3027                         if (content_0 == 1)
3028                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] Fast_RA (( DOWN ))  total=((%d)),  total>>1=((%d)), R4+R3+R2 = ((%d)), RateDownHold = ((%d))\n", content_1, content_2, content_3, content_4));
3029                         else if (content_0 == 2)
3030                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] Fast_RA (( UP ))  total_acc=((%d)),  total_acc>>1=((%d)), R4+R3+R2 = ((%d)), RateDownHold = ((%d))\n", content_1, content_2, content_3, content_4));
3031                         else if (content_0 == 3)
3032                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] Fast_RA (( UP )) ((rate Down Hold))  RA_CNT=((%d))\n", content_1));
3033                         else if (content_0 == 4)
3034                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] Fast_RA (( UP )) ((tota_accl<5 skip))  RA_CNT=((%d))\n", content_1));
3035                         else if (content_0 == 8)
3036                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] Fast_RA (( Reset Tx Rpt )) RA_CNT=((%d))\n", content_1));
3037                 }
3038
3039                 else if (dbg_num == 4) {
3040                         if (content_0 == 3) {
3041                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] RER_CNT   PCR_ori =(( %d )),  ratio_ori =(( %d )), pcr_updown_bitmap =(( 0x%x )), pcr_var_diff =(( %d ))\n", content_1, content_2, content_3, content_4));
3042                                 /**/
3043                         } else if (content_0 == 4) {
3044                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] pcr_shift_value =(( %s%d )), rate_down_threshold =(( %d )), rate_up_threshold =(( %d ))\n", ((content_1) ? "+" : "-"), content_2, content_3, content_4));
3045                                 /**/
3046                         } else if (content_0 == 5) {
3047                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] pcr_mean =(( %d )), PCR_VAR =(( %d )), offset =(( %d )), decision_offset_p =(( %d ))\n", content_1, content_2, content_3, content_4));
3048                                 /**/
3049                         }
3050                 }
3051
3052                 else if (dbg_num == 5) {
3053                         if (content_0 == 1)
3054                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] (( UP))  Nsc=(( %d )), N_High=(( %d )), RateUp_Waiting=(( %d )), RateUp_Fail=(( %d ))\n", content_1, content_2, content_3, content_4));
3055                         else if (content_0 == 2)
3056                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] ((DOWN))  Nsc=(( %d )), N_Low=(( %d ))\n", content_1, content_2));
3057                         else if (content_0 == 3)
3058                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] ((HOLD))  Nsc=((%d)), N_High=((%d)), N_Low=((%d)), Reset_CNT=((%d))\n", content_1, content_2, content_3, content_4));
3059                 } else if (dbg_num == 0x60) {
3060                         if (content_0 == 1)
3061                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] ((AP RPT))  macid=((%d)), BUPDATE[macid]=((%d))\n", content_1, content_2));
3062                         else if (content_0 == 4)
3063                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] ((AP RPT))  pass=((%d)), rty_num=((%d)), drop=((%d)), total=((%d))\n", content_1, content_2, content_3, content_4));
3064                         else if (content_0 == 5)
3065                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW] ((AP RPT))  PASS=((%d)), RTY_NUM=((%d)), DROP=((%d)), TOTAL=((%d))\n", content_1, content_2, content_3, content_4));
3066                 }
3067         }
3068         /*--------------------------------------------*/
3069         else if (function == INIT_RA_TABLE) {
3070                 if (dbg_num == 3)
3071                         ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][INIT_RA_INFO] Ra_init, RA_SKIP_CNT = (( %d ))\n", content_0));
3072
3073         }
3074         /*--------------------------------------------*/
3075         else if (function == RATE_UP) {
3076                 if (dbg_num == 2) {
3077                         if (content_0 == 1)
3078                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][RateUp]  ((Highest rate->return)), macid=((%d))  Nsc=((%d))\n", content_1, content_2));
3079                 } else if (dbg_num == 5) {
3080                         if (content_0 == 0)
3081                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][RateUp]  ((rate UP)), up_rate_tmp=((0x%x)), rate_idx=((0x%x)), SGI_en=((%d)),  SGI=((%d))\n", content_1, content_2, content_3, content_4));
3082                         else if (content_0 == 1)
3083                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][RateUp]  ((rate UP)), rate_1=((0x%x)), rate_2=((0x%x)), BW=((%d)), Try_Bit=((%d))\n", content_1, content_2, content_3, content_4));
3084                 }
3085
3086         }
3087         /*--------------------------------------------*/
3088         else if (function == RATE_DOWN) {
3089                 if (dbg_num == 5) {
3090                         if (content_0 == 1)
3091                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][RateDownStep]  ((rate Down)), macid=((%d)), rate1=((0x%x)),  rate2=((0x%x)), BW=((%d))\n", content_1, content_2, content_3, content_4));
3092                 }
3093         } else if (function == TRY_DONE) {
3094                 if (dbg_num == 1) {
3095                         if (content_0 == 1) {
3096                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][Try Done]  ((try succsess )) macid=((%d)), Try_Done_cnt=((%d))\n", content_1, content_2));
3097                                 /**/
3098                         }
3099                 } else if (dbg_num == 2) {
3100                         if (content_0 == 1) {
3101                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][Try Done]  ((try)) macid=((%d)), Try_Done_cnt=((%d)),  rate_2=((%d)),  try_succes=((%d))\n", content_1, content_2, content_3, content_4));
3102                                 /**/
3103                         }
3104                 }
3105         }
3106         /*--------------------------------------------*/
3107         else if (function == RA_H2C) {
3108                 if (dbg_num == 1) {
3109                         if (content_0 == 0) {
3110                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][H2C=0x49]  fw_trace_en=((%d)), mode =((%d)),  macid=((%d))\n", content_1, content_2, content_3));
3111                                 /**/
3112                                 /*C2H_RA_Dbg_code(F_RA_H2C,1,0, SysMib.ODM.DEBUG.fw_trace_en, mode, macid, 0);    //RA MASK*/
3113                         }
3114                 }
3115         }
3116         /*--------------------------------------------*/
3117         else if (function == F_RATE_AP_RPT) {
3118                 if (dbg_num == 1) {
3119                         if (content_0 == 1)
3120                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][AP RPT]  ((1)), SPE_STATIS=((0x%x))---------->\n", content_3));
3121                 } else if (dbg_num == 2) {
3122                         if (content_0 == 1)
3123                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][AP RPT]  RTY_all=((%d))\n", content_1));
3124                 } else if (dbg_num == 3) {
3125                         if (content_0 == 1)
3126                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][AP RPT]  MACID1[%d], TOTAL=((%d)),  RTY=((%d))\n", content_3, content_1, content_2));
3127                 } else if (dbg_num == 4) {
3128                         if (content_0 == 1)
3129                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][AP RPT]  MACID2[%d], TOTAL=((%d)),  RTY=((%d))\n", content_3, content_1, content_2));
3130                 } else if (dbg_num == 5) {
3131                         if (content_0 == 1)
3132                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][AP RPT]  MACID1[%d], PASS=((%d)),  DROP=((%d))\n", content_3, content_1, content_2));
3133                 } else if (dbg_num == 6) {
3134                         if (content_0 == 1)
3135                                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][AP RPT]  MACID2[%d],, PASS=((%d)),  DROP=((%d))\n", content_3, content_1, content_2));
3136                 }
3137         } else {
3138                 ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][general][%d, %d, %d] = {%d, %d, %d, %d}\n", function, dbg_num, content_0, content_1, content_2, content_3, content_4));
3139                 /**/
3140         }
3141 #else
3142         ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW][general][%d, %d, %d] = {%d, %d, %d, %d}\n", function, dbg_num, content_0, content_1, content_2, content_3, content_4));
3143 #endif
3144         /*--------------------------------------------*/
3145
3146 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
3147 }
3148
3149 void
3150 phydm_fw_trace_handler_8051(
3151         void    *p_dm_void,
3152         u8      *buffer,
3153         u8      cmd_len
3154 )
3155 {
3156 #if CONFIG_PHYDM_DEBUG_FUNCTION
3157         struct PHY_DM_STRUCT    *p_dm_odm = (struct PHY_DM_STRUCT *)p_dm_void;
3158         int i = 0;
3159         u8      extend_c2h_sub_id = 0, extend_c2h_dbg_len = 0, extend_c2h_dbg_seq = 0;
3160         u8      fw_debug_trace[128];
3161         u8      *extend_c2h_dbg_content = 0;
3162
3163         if (cmd_len > 127)
3164                 return;
3165
3166         extend_c2h_sub_id = buffer[0];
3167         extend_c2h_dbg_len = buffer[1];
3168         extend_c2h_dbg_content = buffer + 2; /*DbgSeq+DbgContent  for show HEX*/
3169
3170 #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
3171         RT_DISP(FC2H, C2H_Summary, ("[Extend C2H packet], Extend_c2hSubId=0x%x, extend_c2h_dbg_len=%d\n",
3172                                     extend_c2h_sub_id, extend_c2h_dbg_len));
3173
3174         RT_DISP_DATA(FC2H, C2H_Summary, "[Extend C2H packet], Content Hex:", extend_c2h_dbg_content, cmd_len - 2);
3175 #endif
3176
3177 go_backfor_aggre_dbg_pkt:
3178         i = 0;
3179         extend_c2h_dbg_seq = buffer[2];
3180         extend_c2h_dbg_content = buffer + 3;
3181
3182 #if (DM_ODM_SUPPORT_TYPE == ODM_WIN)
3183         RT_DISP(FC2H, C2H_Summary, ("[RTKFW, SEQ= %d] :", extend_c2h_dbg_seq));
3184 #endif
3185
3186         for (; ; i++) {
3187                 fw_debug_trace[i] = extend_c2h_dbg_content[i];
3188                 if (extend_c2h_dbg_content[i + 1] == '\0') {
3189                         fw_debug_trace[i + 1] = '\0';
3190                         ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW DBG Msg] %s", &(fw_debug_trace[0])));
3191                         break;
3192                 } else if (extend_c2h_dbg_content[i] == '\n') {
3193                         fw_debug_trace[i + 1] = '\0';
3194                         ODM_RT_TRACE(p_dm_odm, ODM_FW_DEBUG_TRACE, ODM_DBG_LOUD, ("[FW DBG Msg] %s", &(fw_debug_trace[0])));
3195                         buffer = extend_c2h_dbg_content + i + 3;
3196                         goto go_backfor_aggre_dbg_pkt;
3197                 }
3198         }
3199 #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/
3200 }