drivers/staging/rtlwifi/phydm/phydm_debug.c

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