drivers/staging/rtlwifi/phydm/phydm_debug.c

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