/****************************************************************************** * * Copyright(c) 2007 - 2017 Realtek Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * The full GNU General Public License is included in this distribution in the * file called LICENSE. * * Contact Information: * wlanfae * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park, * Hsinchu 300, Taiwan. * * Larry Finger * *****************************************************************************/ /* ************************************************************ * include files * ************************************************************ */ #include "mp_precomp.h" #include "phydm_precomp.h" void phydm_init_debug_setting( struct dm_struct *dm ) { dm->debug_level = ODM_DBG_TRACE; dm->fw_debug_components = 0; dm->debug_components = \ #if DBG /*BB Functions*/ /* DBG_DIG |*/ /* DBG_RA_MASK |*/ /* DBG_DYN_TXPWR |*/ /* DBG_FA_CNT |*/ /* DBG_RSSI_MNTR |*/ /* DBG_CCKPD |*/ /* DBG_ANT_DIV |*/ /* DBG_SMT_ANT |*/ /* DBG_PWR_TRAIN |*/ /* DBG_RA |*/ /* DBG_PATH_DIV |*/ /* DBG_DFS |*/ /* DBG_DYN_ARFR |*/ /* DBG_ADPTVTY |*/ /* DBG_CFO_TRK |*/ /* DBG_ENV_MNTR |*/ /* DBG_PRI_CCA |*/ /* DBG_ADPTV_SOML |*/ /* DBG_LNA_SAT_CHK |*/ /* DBG_DYN_RX_PATH |*/ /* DBG_PHY_STATUS |*/ /* DBG_TMP |*/ /* DBG_FW_TRACE |*/ /* DBG_TXBF |*/ /* DBG_COMMON_FLOW |*/ /* ODM_COMP_TX_PWR_TRACK |*/ /* ODM_COMP_CALIBRATION |*/ /* ODM_COMP_MP |*/ /* ODM_PHY_CONFIG |*/ /* ODM_COMP_INIT |*/ /* ODM_COMP_COMMON |*/ /* ODM_COMP_API |*/ #endif 0; dm->fw_buff_is_enpty = true; dm->pre_c2h_seq = 0; dm->c2h_cmd_start = 0; dm->cmn_dbg_msg_cnt = PHYDM_WATCH_DOG_PERIOD; dm->cmn_dbg_msg_period = PHYDM_WATCH_DOG_PERIOD; } void phydm_bb_dbg_port_header_sel( void *dm_void, u32 header_idx ) { struct dm_struct *dm = (struct dm_struct *)dm_void; if (dm->support_ic_type & ODM_IC_11AC_SERIES) { odm_set_bb_reg(dm, 0x8f8, (BIT(25) | BIT(24) | BIT(23) | BIT(22)), header_idx); /* header_idx: (0:) '{ofdm_dbg[31:0]}' (1:) '{cca,crc32_fail,dbg_ofdm[29:0]}' (2:) '{vbon,crc32_fail,dbg_ofdm[29:0]}' (3:) '{cca,crc32_ok,dbg_ofdm[29:0]}' (4:) '{vbon,crc32_ok,dbg_ofdm[29:0]}' (5:) '{dbg_iqk_anta}' (6:) '{cca,ofdm_crc_ok,dbg_dp_anta[29:0]}' (7:) '{dbg_iqk_antb}' (8:) '{DBGOUT_RFC_b[31:0]}' (9:) '{DBGOUT_RFC_a[31:0]}' (a:) '{dbg_ofdm}' (b:) '{dbg_cck}' */ } } void phydm_bb_dbg_port_clock_en( void *dm_void, u8 enable ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 reg_value = 0; if (dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8821C | ODM_RTL8814A | ODM_RTL8814B)) { reg_value = enable ? 0x7 : 0; odm_set_bb_reg(dm, 0x198c, 0x7, reg_value); /*enable/disable debug port clock, for power saving*/ } } u8 phydm_set_bb_dbg_port( void *dm_void, u8 curr_dbg_priority, u32 debug_port ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u8 dbg_port_result = false; if (curr_dbg_priority > dm->pre_dbg_priority) { if (dm->support_ic_type & ODM_IC_11AC_SERIES) { phydm_bb_dbg_port_clock_en(dm, true); odm_set_bb_reg(dm, 0x8fc, MASKDWORD, debug_port); /**/ } else /*if (dm->support_ic_type & ODM_IC_11N_SERIES)*/ { odm_set_bb_reg(dm, 0x908, MASKDWORD, debug_port); /**/ } PHYDM_DBG(dm, ODM_COMP_API, "DbgPort ((0x%x)) set success, Cur_priority=((%d)), Pre_priority=((%d))\n", debug_port, curr_dbg_priority, dm->pre_dbg_priority); dm->pre_dbg_priority = curr_dbg_priority; dbg_port_result = true; } return dbg_port_result; } void phydm_release_bb_dbg_port( void *dm_void ) { struct dm_struct *dm = (struct dm_struct *)dm_void; phydm_bb_dbg_port_clock_en(dm, false); phydm_bb_dbg_port_header_sel(dm, 0); dm->pre_dbg_priority = BB_DBGPORT_RELEASE; PHYDM_DBG(dm, ODM_COMP_API, "Release BB dbg_port\n"); } u32 phydm_get_bb_dbg_port_value( void *dm_void ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 dbg_port_value = 0; if (dm->support_ic_type & ODM_IC_11AC_SERIES) { dbg_port_value = odm_get_bb_reg(dm, 0xfa0, MASKDWORD); /**/ } else /*if (dm->support_ic_type & ODM_IC_11N_SERIES)*/ { dbg_port_value = odm_get_bb_reg(dm, 0xdf4, MASKDWORD); /**/ } PHYDM_DBG(dm, ODM_COMP_API, "dbg_port_value = 0x%x\n", dbg_port_value); return dbg_port_value; } #ifdef CONFIG_PHYDM_DEBUG_FUNCTION void phydm_bb_debug_info_n_series( void *dm_void, u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 used = *_used; u32 out_len = *_out_len; u32 value32 = 0, value32_1 = 0; u8 rf_gain_a = 0, rf_gain_b = 0, rf_gain_c = 0, rf_gain_d = 0; u8 rx_snr_a = 0, rx_snr_b = 0, rx_snr_c = 0, rx_snr_d = 0; s8 rxevm_0 = 0, rxevm_1 = 0; s32 short_cfo_a = 0, short_cfo_b = 0, long_cfo_a = 0, long_cfo_b = 0; s32 scfo_a = 0, scfo_b = 0, avg_cfo_a = 0, avg_cfo_b = 0; s32 cfo_end_a = 0, cfo_end_b = 0, acq_cfo_a = 0, acq_cfo_b = 0; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s\n", "BB Report Info"); /*AGC result*/ value32 = odm_get_bb_reg(dm, 0xdd0, MASKDWORD); rf_gain_a = (u8)(value32 & 0x3f); rf_gain_a = rf_gain_a << 1; rf_gain_b = (u8)((value32 >> 8) & 0x3f); rf_gain_b = rf_gain_b << 1; rf_gain_c = (u8)((value32 >> 16) & 0x3f); rf_gain_c = rf_gain_c << 1; rf_gain_d = (u8)((value32 >> 24) & 0x3f); rf_gain_d = rf_gain_d << 1; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d / %d", "OFDM RX RF Gain(A/B/C/D)", rf_gain_a, rf_gain_b, rf_gain_c, rf_gain_d); /*SNR report*/ value32 = odm_get_bb_reg(dm, 0xdd4, MASKDWORD); rx_snr_a = (u8)(value32 & 0xff); rx_snr_a = rx_snr_a >> 1; rx_snr_b = (u8)((value32 >> 8) & 0xff); rx_snr_b = rx_snr_b >> 1; rx_snr_c = (u8)((value32 >> 16) & 0xff); rx_snr_c = rx_snr_c >> 1; rx_snr_d = (u8)((value32 >> 24) & 0xff); rx_snr_d = rx_snr_d >> 1; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d / %d", "RXSNR(A/B/C/D, dB)", rx_snr_a, rx_snr_b, rx_snr_c, rx_snr_d); /* PostFFT related info*/ value32 = odm_get_bb_reg(dm, 0xdd8, MASKDWORD); rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_0 /= 2; if (rxevm_0 < -63) rxevm_0 = 0; rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24); rxevm_1 /= 2; if (rxevm_1 < -63) rxevm_1 = 0; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "RXEVM (1ss/2ss)", rxevm_0, rxevm_1); /*CFO Report Info*/ odm_set_bb_reg(dm, 0xd00, BIT(26), 1); /*Short CFO*/ value32 = odm_get_bb_reg(dm, 0xdac, MASKDWORD); value32_1 = odm_get_bb_reg(dm, 0xdb0, MASKDWORD); short_cfo_b = (s32)(value32 & 0xfff); /*S(12,11)*/ short_cfo_a = (s32)((value32 & 0x0fff0000) >> 16); long_cfo_b = (s32)(value32_1 & 0x1fff); /*S(13,12)*/ long_cfo_a = (s32)((value32_1 & 0x1fff0000) >> 16); /*SFO 2's to dec*/ if (short_cfo_a > 2047) short_cfo_a = short_cfo_a - 4096; if (short_cfo_b > 2047) short_cfo_b = short_cfo_b - 4096; short_cfo_a = (short_cfo_a * 312500) / 2048; short_cfo_b = (short_cfo_b * 312500) / 2048; /*LFO 2's to dec*/ if (long_cfo_a > 4095) long_cfo_a = long_cfo_a - 8192; if (long_cfo_b > 4095) long_cfo_b = long_cfo_b - 8192; long_cfo_a = long_cfo_a * 312500 / 4096; long_cfo_b = long_cfo_b * 312500 / 4096; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s", "CFO Report Info"); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "Short CFO(Hz) ", short_cfo_a, short_cfo_b); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "Long CFO(Hz) ", long_cfo_a, long_cfo_b); /*SCFO*/ value32 = odm_get_bb_reg(dm, 0xdb8, MASKDWORD); value32_1 = odm_get_bb_reg(dm, 0xdb4, MASKDWORD); scfo_b = (s32)(value32 & 0x7ff); /*S(11,10)*/ scfo_a = (s32)((value32 & 0x07ff0000) >> 16); if (scfo_a > 1023) scfo_a = scfo_a - 2048; if (scfo_b > 1023) scfo_b = scfo_b - 2048; scfo_a = scfo_a * 312500 / 1024; scfo_b = scfo_b * 312500 / 1024; avg_cfo_b = (s32)(value32_1 & 0x1fff); /*S(13,12)*/ avg_cfo_a = (s32)((value32_1 & 0x1fff0000) >> 16); if (avg_cfo_a > 4095) avg_cfo_a = avg_cfo_a - 8192; if (avg_cfo_b > 4095) avg_cfo_b = avg_cfo_b - 8192; avg_cfo_a = avg_cfo_a * 312500 / 4096; avg_cfo_b = avg_cfo_b * 312500 / 4096; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "value SCFO(Hz) ", scfo_a, scfo_b); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "Avg CFO(Hz) ", avg_cfo_a, avg_cfo_b); value32 = odm_get_bb_reg(dm, 0xdbc, MASKDWORD); value32_1 = odm_get_bb_reg(dm, 0xde0, MASKDWORD); cfo_end_b = (s32)(value32 & 0x1fff); /*S(13,12)*/ cfo_end_a = (s32)((value32 & 0x1fff0000) >> 16); if (cfo_end_a > 4095) cfo_end_a = cfo_end_a - 8192; if (cfo_end_b > 4095) cfo_end_b = cfo_end_b - 8192; cfo_end_a = cfo_end_a * 312500 / 4096; cfo_end_b = cfo_end_b * 312500 / 4096; acq_cfo_b = (s32)(value32_1 & 0x1fff); /*S(13,12)*/ acq_cfo_a = (s32)((value32_1 & 0x1fff0000) >> 16); if (acq_cfo_a > 4095) acq_cfo_a = acq_cfo_a - 8192; if (acq_cfo_b > 4095) acq_cfo_b = acq_cfo_b - 8192; acq_cfo_a = acq_cfo_a * 312500 / 4096; acq_cfo_b = acq_cfo_b * 312500 / 4096; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "End CFO(Hz) ", cfo_end_a, cfo_end_b); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "ACQ CFO(Hz) ", acq_cfo_a, acq_cfo_b); } void phydm_bb_debug_info( void *dm_void, u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 used = *_used; u32 out_len = *_out_len; char *tmp_string = NULL; u8 rx_ht_bw, rx_vht_bw, rxsc, rx_ht, rx_bw; static u8 v_rx_bw ; u32 value32, value32_1, value32_2, value32_3; s32 sfo_a, sfo_b, sfo_c, sfo_d; s32 lfo_a, lfo_b, lfo_c, lfo_d; static u8 MCSS, tail, parity, rsv, vrsv, idx, smooth, htsound, agg, stbc, vstbc, fec, fecext, sgi, sgiext, htltf, vgid, v_nsts, vtxops, vrsv2, vbrsv, bf, vbcrc; static u16 h_length, htcrc8, length; static u16 vpaid; static u16 v_length, vhtcrc8, v_mcss, v_tail, vb_tail; static u8 hmcss, hrx_bw; u8 pwdb; s8 rxevm_0, rxevm_1, rxevm_2 ; u8 rf_gain_path_a, rf_gain_path_b, rf_gain_path_c, rf_gain_path_d; u8 rx_snr_path_a, rx_snr_path_b, rx_snr_path_c, rx_snr_path_d; s32 sig_power; const char *L_rate[8] = {"6M", "9M", "12M", "18M", "24M", "36M", "48M", "54M"}; #if 0 const double evm_comp_20M = 0.579919469776867; /* 10*log10(64.0/56.0) */ const double evm_comp_40M = 0.503051183113957; /* 10*log10(128.0/114.0) */ const double evm_comp_80M = 0.244245993314183; /* 10*log10(256.0/242.0) */ const double evm_comp_160M = 0.244245993314183; /* 10*log10(512.0/484.0) */ #endif if (dm->support_ic_type & ODM_IC_11N_SERIES) { phydm_bb_debug_info_n_series(dm, &used, output, &out_len); return; } PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s\n", "BB Report Info"); /*BW & mode Detection*/ value32 = odm_get_bb_reg(dm, 0xf80, MASKDWORD); value32_2 = value32; rx_ht_bw = (u8)(value32 & 0x1); rx_vht_bw = (u8)((value32 >> 1) & 0x3); rxsc = (u8)(value32 & 0x78); value32_1 = (value32 & 0x180) >> 7; rx_ht = (u8)(value32_1); rx_bw = 0; if (rx_ht == 2) { if (rx_vht_bw == 0) tmp_string = "20M"; else if (rx_vht_bw == 1) tmp_string = "40M"; else tmp_string = "80M"; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s %s %s", "mode", "VHT", tmp_string); rx_bw = rx_vht_bw; } else if (rx_ht == 1) { if (rx_ht_bw == 0) tmp_string = "20M"; else if (rx_ht_bw == 1) tmp_string = "40M"; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s %s %s", "mode", "HT", tmp_string); rx_bw = rx_ht_bw; } else PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s %s", "mode", "Legacy"); if (rx_ht != 0) { if (rxsc == 0) tmp_string = "duplicate/full bw"; else if (rxsc == 1) tmp_string = "usc20-1"; else if (rxsc == 2) tmp_string = "lsc20-1"; else if (rxsc == 3) tmp_string = "usc20-2"; else if (rxsc == 4) tmp_string = "lsc20-2"; else if (rxsc == 9) tmp_string = "usc40"; else if (rxsc == 10) tmp_string = "lsc40"; PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s", tmp_string); } /* RX signal power and AGC related info*/ value32 = odm_get_bb_reg(dm, 0xF90, MASKDWORD); pwdb = (u8)((value32 & MASKBYTE1) >> 8); pwdb = pwdb >> 1; sig_power = -110 + pwdb; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d", "OFDM RX Signal Power(dB)", sig_power); value32 = odm_get_bb_reg(dm, 0xd14, MASKDWORD); rx_snr_path_a = (u8)(value32 & 0xFF) >> 1; rf_gain_path_a = (s8)((value32 & MASKBYTE1) >> 8); rf_gain_path_a *= 2; value32 = odm_get_bb_reg(dm, 0xd54, MASKDWORD); rx_snr_path_b = (u8)(value32 & 0xFF) >> 1; rf_gain_path_b = (s8)((value32 & MASKBYTE1) >> 8); rf_gain_path_b *= 2; value32 = odm_get_bb_reg(dm, 0xd94, MASKDWORD); rx_snr_path_c = (u8)(value32 & 0xFF) >> 1; rf_gain_path_c = (s8)((value32 & MASKBYTE1) >> 8); rf_gain_path_c *= 2; value32 = odm_get_bb_reg(dm, 0xdd4, MASKDWORD); rx_snr_path_d = (u8)(value32 & 0xFF) >> 1; rf_gain_path_d = (s8)((value32 & MASKBYTE1) >> 8); rf_gain_path_d *= 2; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d / %d", "OFDM RX RF Gain(A/B/C/D)", rf_gain_path_a, rf_gain_path_b, rf_gain_path_c, rf_gain_path_d); /* RX counter related info*/ value32 = odm_get_bb_reg(dm, 0xF08, MASKDWORD); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d", "OFDM CCA counter", ((value32 & 0xFFFF0000) >> 16)); value32 = odm_get_bb_reg(dm, 0xFD0, MASKDWORD); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d", "OFDM SBD Fail counter", value32 & 0xFFFF); value32 = odm_get_bb_reg(dm, 0xFC4, MASKDWORD); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "VHT SIGA/SIGB CRC8 Fail counter", value32 & 0xFFFF, ((value32 & 0xFFFF0000) >> 16)); value32 = odm_get_bb_reg(dm, 0xFCC, MASKDWORD); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d", "CCK CCA counter", value32 & 0xFFFF); value32 = odm_get_bb_reg(dm, 0xFBC, MASKDWORD); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "LSIG (parity Fail/rate Illegal) counter", value32 & 0xFFFF, ((value32 & 0xFFFF0000) >> 16)); value32_1 = odm_get_bb_reg(dm, 0xFC8, MASKDWORD); value32_2 = odm_get_bb_reg(dm, 0xFC0, MASKDWORD); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "HT/VHT MCS NOT SUPPORT counter", ((value32_2 & 0xFFFF0000) >> 16), value32_1 & 0xFFFF); /* PostFFT related info*/ value32 = odm_get_bb_reg(dm, 0xF8c, MASKDWORD); rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_0 /= 2; if (rxevm_0 < -63) rxevm_0 = 0; rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24); rxevm_1 /= 2; value32 = odm_get_bb_reg(dm, 0xF88, MASKDWORD); rxevm_2 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_2 /= 2; if (rxevm_1 < -63) rxevm_1 = 0; if (rxevm_2 < -63) rxevm_2 = 0; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d", "RXEVM (1ss/2ss/3ss)", rxevm_0, rxevm_1, rxevm_2); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d / %d", "RXSNR(A/B/C/D, dB)", rx_snr_path_a, rx_snr_path_b, rx_snr_path_c, rx_snr_path_d); value32 = odm_get_bb_reg(dm, 0xF8C, MASKDWORD); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d", "CSI_1st /CSI_2nd", value32 & 0xFFFF, ((value32 & 0xFFFF0000) >> 16)); /*BW & mode Detection*/ /*Reset Page F counter*/ odm_set_bb_reg(dm, 0xB58, BIT(0), 1); odm_set_bb_reg(dm, 0xB58, BIT(0), 0); /*CFO Report Info*/ /*Short CFO*/ value32 = odm_get_bb_reg(dm, 0xd0c, MASKDWORD); value32_1 = odm_get_bb_reg(dm, 0xd4c, MASKDWORD); value32_2 = odm_get_bb_reg(dm, 0xd8c, MASKDWORD); value32_3 = odm_get_bb_reg(dm, 0xdcc, MASKDWORD); sfo_a = (s32)(value32 & 0xfff); sfo_b = (s32)(value32_1 & 0xfff); sfo_c = (s32)(value32_2 & 0xfff); sfo_d = (s32)(value32_3 & 0xfff); lfo_a = (s32)(value32 >> 16); lfo_b = (s32)(value32_1 >> 16); lfo_c = (s32)(value32_2 >> 16); lfo_d = (s32)(value32_3 >> 16); /*SFO 2's to dec*/ if (sfo_a > 2047) sfo_a = sfo_a - 4096; sfo_a = (sfo_a * 312500) / 2048; if (sfo_b > 2047) sfo_b = sfo_b - 4096; sfo_b = (sfo_b * 312500) / 2048; if (sfo_c > 2047) sfo_c = sfo_c - 4096; sfo_c = (sfo_c * 312500) / 2048; if (sfo_d > 2047) sfo_d = sfo_d - 4096; sfo_d = (sfo_d * 312500) / 2048; /*LFO 2's to dec*/ if (lfo_a > 4095) lfo_a = lfo_a - 8192; if (lfo_b > 4095) lfo_b = lfo_b - 8192; if (lfo_c > 4095) lfo_c = lfo_c - 8192; if (lfo_d > 4095) lfo_d = lfo_d - 8192; lfo_a = lfo_a * 312500 / 4096; lfo_b = lfo_b * 312500 / 4096; lfo_c = lfo_c * 312500 / 4096; lfo_d = lfo_d * 312500 / 4096; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s", "CFO Report Info"); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "Short CFO(Hz) ", sfo_a, sfo_b, sfo_c, sfo_d); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "Long CFO(Hz) ", lfo_a, lfo_b, lfo_c, lfo_d); /*SCFO*/ value32 = odm_get_bb_reg(dm, 0xd10, MASKDWORD); value32_1 = odm_get_bb_reg(dm, 0xd50, MASKDWORD); value32_2 = odm_get_bb_reg(dm, 0xd90, MASKDWORD); value32_3 = odm_get_bb_reg(dm, 0xdd0, MASKDWORD); sfo_a = (s32)(value32 & 0x7ff); sfo_b = (s32)(value32_1 & 0x7ff); sfo_c = (s32)(value32_2 & 0x7ff); sfo_d = (s32)(value32_3 & 0x7ff); if (sfo_a > 1023) sfo_a = sfo_a - 2048; if (sfo_b > 2047) sfo_b = sfo_b - 4096; if (sfo_c > 2047) sfo_c = sfo_c - 4096; if (sfo_d > 2047) sfo_d = sfo_d - 4096; sfo_a = sfo_a * 312500 / 1024; sfo_b = sfo_b * 312500 / 1024; sfo_c = sfo_c * 312500 / 1024; sfo_d = sfo_d * 312500 / 1024; lfo_a = (s32)(value32 >> 16); lfo_b = (s32)(value32_1 >> 16); lfo_c = (s32)(value32_2 >> 16); lfo_d = (s32)(value32_3 >> 16); if (lfo_a > 4095) lfo_a = lfo_a - 8192; if (lfo_b > 4095) lfo_b = lfo_b - 8192; if (lfo_c > 4095) lfo_c = lfo_c - 8192; if (lfo_d > 4095) lfo_d = lfo_d - 8192; lfo_a = lfo_a * 312500 / 4096; lfo_b = lfo_b * 312500 / 4096; lfo_c = lfo_c * 312500 / 4096; lfo_d = lfo_d * 312500 / 4096; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "value SCFO(Hz) ", sfo_a, sfo_b, sfo_c, sfo_d); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "ACQ CFO(Hz) ", lfo_a, lfo_b, lfo_c, lfo_d); value32 = odm_get_bb_reg(dm, 0xd14, MASKDWORD); value32_1 = odm_get_bb_reg(dm, 0xd54, MASKDWORD); value32_2 = odm_get_bb_reg(dm, 0xd94, MASKDWORD); value32_3 = odm_get_bb_reg(dm, 0xdd4, MASKDWORD); lfo_a = (s32)(value32 >> 16); lfo_b = (s32)(value32_1 >> 16); lfo_c = (s32)(value32_2 >> 16); lfo_d = (s32)(value32_3 >> 16); if (lfo_a > 4095) lfo_a = lfo_a - 8192; if (lfo_b > 4095) lfo_b = lfo_b - 8192; if (lfo_c > 4095) lfo_c = lfo_c - 8192; if (lfo_d > 4095) lfo_d = lfo_d - 8192; lfo_a = lfo_a * 312500 / 4096; lfo_b = lfo_b * 312500 / 4096; lfo_c = lfo_c * 312500 / 4096; lfo_d = lfo_d * 312500 / 4096; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d / %d / %d /%d", "End CFO(Hz) ", lfo_a, lfo_b, lfo_c, lfo_d); value32 = odm_get_bb_reg(dm, 0xf20, MASKDWORD); /*L SIG*/ tail = (u8)((value32 & 0xfc0000) >> 16); parity = (u8)((value32 & 0x20000) >> 16); length = (u16)((value32 & 0x1ffe00) >> 8); rsv = (u8)(value32 & 0x10); MCSS = (u8)(value32 & 0x0f); switch (MCSS) { case 0x0b: idx = 0; break; case 0x0f: idx = 1; break; case 0x0a: idx = 2; break; case 0x0e: idx = 3; break; case 0x09: idx = 4; break; case 0x08: idx = 5; break; case 0x0c: idx = 6; break; default: idx = 6; break; } PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s", "L-SIG"); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s : %s", "rate", L_rate[idx]); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %x / %x / %x", "Rsv/length/parity", rsv, rx_bw, length); value32 = odm_get_bb_reg(dm, 0xf2c, MASKDWORD); /*HT SIG*/ if (rx_ht == 1) { hmcss = (u8)(value32 & 0x7F); hrx_bw = (u8)(value32 & 0x80); h_length = (u16)((value32 >> 8) & 0xffff); } PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s", "HT-SIG1"); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %x / %x / %x", "MCS/BW/length", hmcss, hrx_bw, h_length); value32 = odm_get_bb_reg(dm, 0xf30, MASKDWORD); /*HT SIG*/ if (rx_ht == 1) { smooth = (u8)(value32 & 0x01); htsound = (u8)(value32 & 0x02); rsv = (u8)(value32 & 0x04); agg = (u8)(value32 & 0x08); stbc = (u8)(value32 & 0x30); fec = (u8)(value32 & 0x40); sgi = (u8)(value32 & 0x80); htltf = (u8)((value32 & 0x300) >> 8); htcrc8 = (u16)((value32 & 0x3fc00) >> 8); tail = (u8)((value32 & 0xfc0000) >> 16); } PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s", "HT-SIG2"); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x / %x / %x", "Smooth/NoSound/Rsv/Aggregate/STBC/LDPC", smooth, htsound, rsv, agg, stbc, fec); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x", "SGI/E-HT-LTFs/CRC/tail", sgi, htltf, htcrc8, tail); value32 = odm_get_bb_reg(dm, 0xf2c, MASKDWORD); /*VHT SIG A1*/ if (rx_ht == 2) { /* value32 = odm_get_bb_reg(dm, 0xf2c,MASKDWORD);*/ v_rx_bw = (u8)(value32 & 0x03); vrsv = (u8)(value32 & 0x04); vstbc = (u8)(value32 & 0x08); vgid = (u8)((value32 & 0x3f0) >> 4); v_nsts = (u8)(((value32 & 0x1c00) >> 8) + 1); vpaid = (u16)(value32 & 0x3fe); vtxops = (u8)((value32 & 0x400000) >> 20); vrsv2 = (u8)((value32 & 0x800000) >> 20); } PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s", "VHT-SIG-A1"); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x / %x / %x / %x / %x", "BW/Rsv1/STBC/GID/Nsts/PAID/TXOPPS/Rsv2", v_rx_bw, vrsv, vstbc, vgid, v_nsts, vpaid, vtxops, vrsv2); value32 = odm_get_bb_reg(dm, 0xf30, MASKDWORD); /*VHT SIG*/ if (rx_ht == 2) { /*value32 = odm_get_bb_reg(dm, 0xf30,MASKDWORD); */ /*VHT SIG*/ /* sgi=(u8)(value32&0x01); */ sgiext = (u8)(value32 & 0x03); /* fec = (u8)(value32&0x04); */ fecext = (u8)(value32 & 0x0C); v_mcss = (u8)(value32 & 0xf0); bf = (u8)((value32 & 0x100) >> 8); vrsv = (u8)((value32 & 0x200) >> 8); vhtcrc8 = (u16)((value32 & 0x3fc00) >> 8); v_tail = (u8)((value32 & 0xfc0000) >> 16); } PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s", "VHT-SIG-A2"); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x / %x / %x / %x", "SGI/FEC/MCS/BF/Rsv/CRC/tail", sgiext, fecext, v_mcss, bf, vrsv, vhtcrc8, v_tail); value32 = odm_get_bb_reg(dm, 0xf34, MASKDWORD); /*VHT SIG*/ { v_length = (u16)(value32 & 0x1fffff); vbrsv = (u8)((value32 & 0x600000) >> 20); vb_tail = (u16)((value32 & 0x1f800000) >> 20); vbcrc = (u8)((value32 & 0x80000000) >> 28); } PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s", "VHT-SIG-B"); PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %x / %x / %x / %x", "length/Rsv/tail/CRC", v_length, vbrsv, vb_tail, vbcrc); /*for Condition number*/ if (dm->support_ic_type & ODM_RTL8822B) { s32 condition_num = 0; char *factor = NULL; odm_set_bb_reg(dm, 0x1988, BIT(22), 0x1); /*enable report condition number*/ condition_num = odm_get_bb_reg(dm, 0xf84, MASKDWORD); condition_num = (condition_num & 0x3ffff) >> 4; if (*dm->band_width == CHANNEL_WIDTH_80) factor = "256/234"; else if (*dm->band_width == CHANNEL_WIDTH_40) factor = "128/108"; else if (*dm->band_width == CHANNEL_WIDTH_20) { if (rx_ht != 2 || rx_ht != 1) factor = "64/52"; /*HT or VHT*/ else factor = "64/48"; /*legacy*/ } PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = %d (factor = %s)", "Condition number", condition_num, factor); } *_used = used; *_out_len = out_len; } #endif /*#ifdef CONFIG_PHYDM_DEBUG_FUNCTION*/ #if (DM_ODM_SUPPORT_TYPE & ODM_WIN) #ifdef CONFIG_PHYDM_DEBUG_FUNCTION void phydm_sbd_check( struct dm_struct *dm ) { static u32 pkt_cnt = 0; static boolean sbd_state = 0; u32 sym_count, count, value32; if (sbd_state == 0) { pkt_cnt++; if (pkt_cnt % 5 == 0) { /*read SBD conter once every 5 packets*/ odm_set_timer(dm, &dm->sbdcnt_timer, 0); /*ms*/ sbd_state = 1; } } else { /*read counter*/ value32 = odm_get_bb_reg(dm, 0xF98, MASKDWORD); sym_count = (value32 & 0x7C000000) >> 26; count = (value32 & 0x3F00000) >> 20; pr_debug("#SBD# sym_count %d count %d\n", sym_count, count); sbd_state = 0; } } #endif void phydm_sbd_callback( struct phydm_timer_list *timer ) { #ifdef CONFIG_PHYDM_DEBUG_FUNCTION void *adapter = timer->Adapter; HAL_DATA_TYPE *hal_data = GET_HAL_DATA((PADAPTER)adapter); struct dm_struct *dm = &hal_data->DM_OutSrc; #if USE_WORKITEM odm_schedule_work_item(&dm->sbdcnt_workitem); #else phydm_sbd_check(dm); #endif #endif } void phydm_sbd_workitem_callback( void *context ) { #ifdef CONFIG_PHYDM_DEBUG_FUNCTION void *adapter = (void *)context; HAL_DATA_TYPE *hal_data = GET_HAL_DATA((PADAPTER)adapter); struct dm_struct *dm = &hal_data->DM_OutSrc; phydm_sbd_check(dm); #endif } #endif void phydm_reset_rx_rate_distribution( struct dm_struct *dm ) { struct odm_phy_dbg_info *dbg = &dm->phy_dbg_info; odm_memory_set(dm, &dbg->num_qry_legacy_pkt[0], 0, (LEGACY_RATE_NUM * 2)); odm_memory_set(dm, &dbg->num_qry_ht_pkt[0], 0, (HT_RATE_NUM * 2)); odm_memory_set(dm, &dbg->num_qry_pkt_sc_20m[0], 0, (LOW_BW_RATE_NUM * 2)); dbg->ht_pkt_not_zero = false; dbg->low_bw_20_occur = false; #if ODM_IC_11AC_SERIES_SUPPORT odm_memory_set(dm, &dbg->num_qry_vht_pkt[0], 0, (VHT_RATE_NUM * 2)); odm_memory_set(dm, &dbg->num_qry_pkt_sc_40m[0], 0, (LOW_BW_RATE_NUM * 2)); dbg->vht_pkt_not_zero = false; dbg->low_bw_40_occur = false; #endif } void phydm_rx_rate_distribution ( void *dm_void ) { struct dm_struct *dm = (struct dm_struct *)dm_void; struct odm_phy_dbg_info *dbg = &dm->phy_dbg_info; u8 i = 0, j = 0; u8 rate_num = dm->num_rf_path, rate_ss_shift = 0; PHYDM_DBG(dm, ODM_COMP_COMMON, "[RxRate Cnt] =============>\n"); /*======CCK=============================================================*/ if (*dm->channel <= 14) { PHYDM_DBG(dm, ODM_COMP_COMMON, "* CCK = {%d, %d, %d, %d}\n", dbg->num_qry_legacy_pkt[0], dbg->num_qry_legacy_pkt[1], dbg->num_qry_legacy_pkt[2], dbg->num_qry_legacy_pkt[3] ); } /*======OFDM============================================================*/ PHYDM_DBG(dm, ODM_COMP_COMMON, "* OFDM = {%d, %d, %d, %d, %d, %d, %d, %d}\n", dbg->num_qry_legacy_pkt[4], dbg->num_qry_legacy_pkt[5], dbg->num_qry_legacy_pkt[6], dbg->num_qry_legacy_pkt[7], dbg->num_qry_legacy_pkt[8], dbg->num_qry_legacy_pkt[9], dbg->num_qry_legacy_pkt[10], dbg->num_qry_legacy_pkt[11]); /*======HT==============================================================*/ if (dbg->ht_pkt_not_zero) { for (i = 0; i < rate_num; i++) { rate_ss_shift = (i << 3); PHYDM_DBG(dm, ODM_COMP_COMMON, "* HT MCS[%d :%d ] = {%d, %d, %d, %d, %d, %d, %d, %d}\n", (rate_ss_shift), (rate_ss_shift+7), dbg->num_qry_ht_pkt[rate_ss_shift + 0], dbg->num_qry_ht_pkt[rate_ss_shift + 1], dbg->num_qry_ht_pkt[rate_ss_shift + 2], dbg->num_qry_ht_pkt[rate_ss_shift + 3], dbg->num_qry_ht_pkt[rate_ss_shift + 4], dbg->num_qry_ht_pkt[rate_ss_shift + 5], dbg->num_qry_ht_pkt[rate_ss_shift + 6], dbg->num_qry_ht_pkt[rate_ss_shift + 7]); } if (dbg->low_bw_20_occur) { for (i = 0; i < rate_num; i++) { rate_ss_shift = (i << 3); PHYDM_DBG(dm, ODM_COMP_COMMON, "* [Low BW 20M] HT MCS[%d :%d ] = {%d, %d, %d, %d, %d, %d, %d, %d}\n", (rate_ss_shift), (rate_ss_shift+7), dbg->num_qry_pkt_sc_20m[rate_ss_shift + 0], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 1], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 2], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 3], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 4], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 5], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 6], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 7]); } } } #if ODM_IC_11AC_SERIES_SUPPORT /*======VHT=============================================================*/ if (dbg->vht_pkt_not_zero) { for (i = 0; i < rate_num; i++) { rate_ss_shift = 10 * i; PHYDM_DBG(dm, ODM_COMP_COMMON, "* VHT-%d ss MCS[0:9] = {%d, %d, %d, %d, %d, %d, %d, %d, %d, %d}\n", (i + 1), dbg->num_qry_vht_pkt[rate_ss_shift + 0], dbg->num_qry_vht_pkt[rate_ss_shift + 1], dbg->num_qry_vht_pkt[rate_ss_shift + 2], dbg->num_qry_vht_pkt[rate_ss_shift + 3], dbg->num_qry_vht_pkt[rate_ss_shift + 4], dbg->num_qry_vht_pkt[rate_ss_shift + 5], dbg->num_qry_vht_pkt[rate_ss_shift + 6], dbg->num_qry_vht_pkt[rate_ss_shift + 7], dbg->num_qry_vht_pkt[rate_ss_shift + 8], dbg->num_qry_vht_pkt[rate_ss_shift + 9]); } if (dbg->low_bw_20_occur) { for (i = 0; i < rate_num; i++) { rate_ss_shift = 10 * i; PHYDM_DBG(dm, ODM_COMP_COMMON, "*[Low BW 20M] VHT-%d ss MCS[0:9] = {%d, %d, %d, %d, %d, %d, %d, %d, %d, %d}\n", (i + 1), dbg->num_qry_pkt_sc_20m[rate_ss_shift + 0], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 1], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 2], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 3], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 4], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 5], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 6], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 7], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 8], dbg->num_qry_pkt_sc_20m[rate_ss_shift + 9]); } } if (dbg->low_bw_40_occur) { for (i = 0; i < rate_num; i++) { rate_ss_shift = 10 * i; PHYDM_DBG(dm, ODM_COMP_COMMON, "*[Low BW 40M] VHT-%d ss MCS[0:9] = {%d, %d, %d, %d, %d, %d, %d, %d, %d, %d}\n", (i + 1), dbg->num_qry_pkt_sc_40m[rate_ss_shift + 0], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 1], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 2], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 3], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 4], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 5], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 6], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 7], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 8], dbg->num_qry_pkt_sc_40m[rate_ss_shift + 9]); } } } #endif } void phydm_get_avg_phystatus_val ( void *dm_void ) { struct dm_struct *dm = (struct dm_struct *)dm_void; struct phydm_phystatus_statistic *dbg_statistic = &dm->phy_dbg_info.phystatus_statistic_info; struct phydm_phystatus_avg *dbg_avg = &dm->phy_dbg_info.phystatus_statistic_avg; PHYDM_DBG(dm, ODM_COMP_COMMON, "[Avg PHY Statistic] ==============>\n"); phydm_reset_phystatus_avg(dm); /*CCK*/ dbg_avg->rssi_cck_avg = (u8)((dbg_statistic->rssi_cck_cnt != 0) ? (dbg_statistic->rssi_cck_sum/dbg_statistic->rssi_cck_cnt) : 0); PHYDM_DBG(dm, ODM_COMP_COMMON, "* cck Cnt= ((%d)) RSSI:{%d}\n", dbg_statistic->rssi_cck_cnt, dbg_avg->rssi_cck_avg); /*OFDM*/ if (dbg_statistic->rssi_ofdm_cnt != 0) { dbg_avg->rssi_ofdm_avg = (u8)(dbg_statistic->rssi_ofdm_sum/dbg_statistic->rssi_ofdm_cnt); dbg_avg->evm_ofdm_avg = (u8)(dbg_statistic->evm_ofdm_sum/dbg_statistic->rssi_ofdm_cnt); dbg_avg->snr_ofdm_avg = (u8)(dbg_statistic->snr_ofdm_sum/dbg_statistic->rssi_ofdm_cnt); } PHYDM_DBG(dm, ODM_COMP_COMMON, "* ofdm Cnt= ((%d)) RSSI:{%d} EVM:{%d} SNR:{%d}\n", dbg_statistic->rssi_ofdm_cnt, dbg_avg->rssi_ofdm_avg, dbg_avg->evm_ofdm_avg, dbg_avg->snr_ofdm_avg); if (dbg_statistic->rssi_1ss_cnt != 0) { dbg_avg->rssi_1ss_avg = (u8)(dbg_statistic->rssi_1ss_sum/dbg_statistic->rssi_1ss_cnt); dbg_avg->evm_1ss_avg = (u8)(dbg_statistic->evm_1ss_sum/dbg_statistic->rssi_1ss_cnt); dbg_avg->snr_1ss_avg = (u8)(dbg_statistic->snr_1ss_sum/dbg_statistic->rssi_1ss_cnt); } PHYDM_DBG(dm, ODM_COMP_COMMON, "* 1-ss Cnt= ((%d)) RSSI:{%d} EVM:{%d} SNR:{%d}\n", dbg_statistic->rssi_1ss_cnt, dbg_avg->rssi_1ss_avg, dbg_avg->evm_1ss_avg, dbg_avg->snr_1ss_avg); #if (defined(PHYDM_COMPILE_ABOVE_2SS)) if (dm->support_ic_type & (PHYDM_IC_ABOVE_2SS)) { if (dbg_statistic->rssi_2ss_cnt != 0) { dbg_avg->rssi_2ss_avg[0] = (u8)(dbg_statistic->rssi_2ss_sum[0] /dbg_statistic->rssi_2ss_cnt); dbg_avg->rssi_2ss_avg[1] = (u8)(dbg_statistic->rssi_2ss_sum[1] /dbg_statistic->rssi_2ss_cnt); dbg_avg->evm_2ss_avg[0] = (u8)(dbg_statistic->evm_2ss_sum[0] /dbg_statistic->rssi_2ss_cnt); dbg_avg->evm_2ss_avg[1] = (u8)(dbg_statistic->evm_2ss_sum[1] /dbg_statistic->rssi_2ss_cnt); dbg_avg->snr_2ss_avg[0] = (u8)(dbg_statistic->snr_2ss_sum[0] /dbg_statistic->rssi_2ss_cnt); dbg_avg->snr_2ss_avg[1] = (u8)(dbg_statistic->snr_2ss_sum[1] /dbg_statistic->rssi_2ss_cnt); } PHYDM_DBG(dm, ODM_COMP_COMMON, "* 2-ss Cnt= ((%d)) RSSI:{%d, %d}, EVM:{%d, %d}, SNR:{%d, %d}\n", dbg_statistic->rssi_2ss_cnt, dbg_avg->rssi_2ss_avg[0], dbg_avg->rssi_2ss_avg[1], dbg_avg->evm_2ss_avg[0], dbg_avg->evm_2ss_avg[1], dbg_avg->snr_2ss_avg[0], dbg_avg->snr_2ss_avg[1]); } #endif #if (defined(PHYDM_COMPILE_ABOVE_3SS)) if (dm->support_ic_type & (PHYDM_IC_ABOVE_3SS)) { if (dbg_statistic->rssi_3ss_cnt != 0) { dbg_avg->rssi_3ss_avg[0] = (u8)(dbg_statistic->rssi_3ss_sum[0] /dbg_statistic->rssi_3ss_cnt); dbg_avg->rssi_3ss_avg[1] = (u8)(dbg_statistic->rssi_3ss_sum[1] /dbg_statistic->rssi_3ss_cnt); dbg_avg->rssi_3ss_avg[2] = (u8)(dbg_statistic->rssi_3ss_sum[2] /dbg_statistic->rssi_3ss_cnt); dbg_avg->evm_3ss_avg[0] = (u8)(dbg_statistic->evm_3ss_sum[0] /dbg_statistic->rssi_3ss_cnt); dbg_avg->evm_3ss_avg[1] = (u8)(dbg_statistic->evm_3ss_sum[1] /dbg_statistic->rssi_3ss_cnt); dbg_avg->evm_3ss_avg[2] = (u8)(dbg_statistic->evm_3ss_sum[2] /dbg_statistic->rssi_3ss_cnt); dbg_avg->snr_3ss_avg[0] = (u8)(dbg_statistic->snr_3ss_sum[0] /dbg_statistic->rssi_3ss_cnt); dbg_avg->snr_3ss_avg[1] = (u8)(dbg_statistic->snr_3ss_sum[1] /dbg_statistic->rssi_3ss_cnt); dbg_avg->snr_3ss_avg[2] = (u8)(dbg_statistic->snr_3ss_sum[2] /dbg_statistic->rssi_3ss_cnt); } PHYDM_DBG(dm, ODM_COMP_COMMON, "* 3-ss Cnt= ((%d)) RSSI:{%d, %d, %d} EVM:{%d, %d, %d} SNR:{%d, %d, %d}\n", dbg_statistic->rssi_3ss_cnt, dbg_avg->rssi_3ss_avg[0], dbg_avg->rssi_3ss_avg[1], dbg_avg->rssi_3ss_avg[2], dbg_avg->evm_3ss_avg[0], dbg_avg->evm_3ss_avg[1], dbg_avg->evm_3ss_avg[2], dbg_avg->snr_3ss_avg[0], dbg_avg->snr_3ss_avg[1], dbg_avg->snr_3ss_avg[2]); } #endif #if (defined(PHYDM_COMPILE_ABOVE_4SS)) if (dm->support_ic_type & PHYDM_IC_ABOVE_4SS) { if (dbg_statistic->rssi_4ss_cnt != 0) { dbg_avg->rssi_4ss_avg[0] = (u8)(dbg_statistic->rssi_4ss_sum[0] /dbg_statistic->rssi_4ss_cnt); dbg_avg->rssi_4ss_avg[1] = (u8)(dbg_statistic->rssi_4ss_sum[1] /dbg_statistic->rssi_4ss_cnt); dbg_avg->rssi_4ss_avg[2] = (u8)(dbg_statistic->rssi_4ss_sum[2] /dbg_statistic->rssi_4ss_cnt); dbg_avg->rssi_4ss_avg[3] = (u8)(dbg_statistic->rssi_4ss_sum[3] /dbg_statistic->rssi_4ss_cnt); dbg_avg->evm_4ss_avg[0] = (u8)(dbg_statistic->evm_4ss_sum[0] /dbg_statistic->rssi_4ss_cnt); dbg_avg->evm_4ss_avg[1] = (u8)(dbg_statistic->evm_4ss_sum[1] /dbg_statistic->rssi_4ss_cnt); dbg_avg->evm_4ss_avg[2] = (u8)(dbg_statistic->evm_4ss_sum[2] /dbg_statistic->rssi_4ss_cnt); dbg_avg->evm_4ss_avg[3] = (u8)(dbg_statistic->evm_4ss_sum[3] /dbg_statistic->rssi_4ss_cnt); dbg_avg->snr_4ss_avg[0] = (u8)(dbg_statistic->snr_4ss_sum[0] /dbg_statistic->rssi_4ss_cnt); dbg_avg->snr_4ss_avg[1] = (u8)(dbg_statistic->snr_4ss_sum[1] /dbg_statistic->rssi_4ss_cnt); dbg_avg->snr_4ss_avg[2] = (u8)(dbg_statistic->snr_4ss_sum[2] /dbg_statistic->rssi_4ss_cnt); dbg_avg->snr_4ss_avg[3] = (u8)(dbg_statistic->snr_4ss_sum[3] /dbg_statistic->rssi_4ss_cnt); } PHYDM_DBG(dm, ODM_COMP_COMMON, "* 4-ss Cnt= ((%d)) RSSI:{%d, %d, %d, %d} EVM:{%d, %d, %d, %d} SNR:{%d, %d, %d, %d}\n", dbg_statistic->rssi_4ss_cnt, dbg_avg->rssi_4ss_avg[0], dbg_avg->rssi_4ss_avg[1], dbg_avg->rssi_4ss_avg[2], dbg_avg->rssi_4ss_avg[3], dbg_avg->evm_4ss_avg[0], dbg_avg->evm_4ss_avg[1], dbg_avg->evm_4ss_avg[2], dbg_avg->evm_4ss_avg[3], dbg_avg->snr_4ss_avg[0], dbg_avg->snr_4ss_avg[1], dbg_avg->snr_4ss_avg[2], dbg_avg->snr_4ss_avg[3]); } #endif } void phydm_get_phy_statistic( void *dm_void ) { struct dm_struct *dm = (struct dm_struct *)dm_void; phydm_rx_rate_distribution(dm); phydm_reset_rx_rate_distribution(dm); phydm_get_avg_phystatus_val(dm); phydm_reset_phystatus_statistic(dm); }; void phydm_basic_dbg_message ( void *dm_void ) { struct dm_struct *dm = (struct dm_struct *)dm_void; struct phydm_fa_struct *false_alm_cnt = (struct phydm_fa_struct *)phydm_get_structure(dm, PHYDM_FALSEALMCNT); struct phydm_cfo_track_struct *cfo_track = (struct phydm_cfo_track_struct *)phydm_get_structure(dm, PHYDM_CFOTRACK); struct phydm_dig_struct *dig_t = &dm->dm_dig_table; struct ra_table *ra_tab = &dm->dm_ra_table; u16 macid, phydm_macid, client_cnt = 0; struct cmn_sta_info *entry = NULL; s32 tmp_val = 0; u8 tmp_val_u1 = 0; if (!(dm->debug_components & ODM_COMP_COMMON)) return; if (dm->cmn_dbg_msg_cnt < dm->cmn_dbg_msg_period) { dm->cmn_dbg_msg_cnt += PHYDM_WATCH_DOG_PERIOD; return; } else { dm->cmn_dbg_msg_cnt = PHYDM_WATCH_DOG_PERIOD; } PHYDM_DBG(dm, ODM_COMP_COMMON, "[PHYDM Common MSG] System up time: ((%d sec))----->\n", dm->phydm_sys_up_time); if (dm->is_linked) { PHYDM_DBG(dm, ODM_COMP_COMMON, "ID=((%d)), BW=((%d)), fc=((CH-%d))\n", dm->curr_station_id, 20<<*dm->band_width, *dm->channel); if ((*dm->channel <= 14) && (*dm->band_width == CHANNEL_WIDTH_40)) { PHYDM_DBG(dm, ODM_COMP_COMMON, "Primary CCA at ((%s SB))\n", ((*dm->sec_ch_offset == SECOND_CH_AT_LSB)?"U":"L")); } if ((dm->support_ic_type & PHYSTS_2ND_TYPE_IC) || dm->rx_rate > ODM_RATE11M) { PHYDM_DBG(dm, ODM_COMP_COMMON, "[AGC Idx] {0x%x, 0x%x, 0x%x, 0x%x}\n", dm->ofdm_agc_idx[0], dm->ofdm_agc_idx[1], dm->ofdm_agc_idx[2], dm->ofdm_agc_idx[3]); } else { PHYDM_DBG(dm, ODM_COMP_COMMON, "[CCK AGC Idx] {LNA, VGA}={0x%x, 0x%x}\n", dm->cck_lna_idx, dm->cck_vga_idx); } PHYDM_DBG(dm, ODM_COMP_COMMON, "RSSI:{%d, %d, %d, %d}, RxRate:", (dm->rssi_a == 0xff) ? 0 : dm->rssi_a, (dm->rssi_b == 0xff) ? 0 : dm->rssi_b, (dm->rssi_c == 0xff) ? 0 : dm->rssi_c, (dm->rssi_d == 0xff) ? 0 : dm->rssi_d); phydm_print_rate(dm, dm->rx_rate, ODM_COMP_COMMON); phydm_get_phy_statistic(dm); /*Print TX rate*/ for (macid = 0; macid < ODM_ASSOCIATE_ENTRY_NUM; macid++) { entry = dm->phydm_sta_info[macid]; if (!is_sta_active(entry)) { continue; } phydm_macid = (dm->phydm_macid_table[macid]); PHYDM_DBG(dm, ODM_COMP_COMMON, "TxRate[%d]:", macid); phydm_print_rate(dm, entry->ra_info.curr_tx_rate, ODM_COMP_COMMON); client_cnt++; if (client_cnt >= dm->number_linked_client) break; } PHYDM_DBG(dm, ODM_COMP_COMMON, "TP {Tx, Rx, Total} = {%d, %d, %d}Mbps, Traffic_Load=(%d))\n", dm->tx_tp, dm->rx_tp, dm->total_tp, dm->traffic_load); tmp_val_u1 = (cfo_track->crystal_cap > cfo_track->def_x_cap) ? (cfo_track->crystal_cap - cfo_track->def_x_cap) : (cfo_track->def_x_cap - cfo_track->crystal_cap); PHYDM_DBG(dm, ODM_COMP_COMMON, "CFO_avg = ((%d kHz)) , CFO_tracking = ((%s%d))\n", cfo_track->CFO_ave_pre, ((cfo_track->crystal_cap > cfo_track->def_x_cap) ? "+" : "-"), tmp_val_u1); /* Condition number */ #if (RTL8822B_SUPPORT == 1) if (dm->support_ic_type == ODM_RTL8822B) { tmp_val = phydm_get_condition_number_8822B(dm); PHYDM_DBG(dm, ODM_COMP_COMMON, "Condi_Num=((%d))\n", tmp_val); } #endif #if (ODM_PHY_STATUS_NEW_TYPE_SUPPORT == 1) /*STBC or LDPC pkt*/ if (dm->support_ic_type & PHYSTS_2ND_TYPE_IC) PHYDM_DBG(dm, ODM_COMP_COMMON, "Coding: LDPC=((%s)), STBC=((%s))\n", (dm->phy_dbg_info.is_ldpc_pkt) ? "Y" : "N", (dm->phy_dbg_info.is_stbc_pkt) ? "Y" : "N"); #endif } else { PHYDM_DBG(dm, ODM_COMP_COMMON, "No Link !!!\n"); } PHYDM_DBG(dm, ODM_COMP_COMMON, "[CCA Cnt] {CCK, OFDM, Total} = {%d, %d, %d}\n", false_alm_cnt->cnt_cck_cca, false_alm_cnt->cnt_ofdm_cca, false_alm_cnt->cnt_cca_all); PHYDM_DBG(dm, ODM_COMP_COMMON, "[FA Cnt] {CCK, OFDM, Total} = {%d, %d, %d}\n", false_alm_cnt->cnt_cck_fail, false_alm_cnt->cnt_ofdm_fail, false_alm_cnt->cnt_all); #if (ODM_IC_11N_SERIES_SUPPORT == 1) if (dm->support_ic_type & ODM_IC_11N_SERIES) { PHYDM_DBG(dm, ODM_COMP_COMMON, "[OFDM FA Detail] Parity_Fail = (( %d )), Rate_Illegal = (( %d )), CRC8_fail = (( %d )), Mcs_fail = (( %d )), Fast_Fsync = (( %d )), SB_Search_fail = (( %d ))\n", false_alm_cnt->cnt_parity_fail, false_alm_cnt->cnt_rate_illegal, false_alm_cnt->cnt_crc8_fail, false_alm_cnt->cnt_mcs_fail, false_alm_cnt->cnt_fast_fsync, false_alm_cnt->cnt_sb_search_fail); } #endif PHYDM_DBG(dm, ODM_COMP_COMMON, "is_linked = %d, Num_client = %d, rssi_min = %d, IGI = 0x%x, bNoisy=%d\n\n", dm->is_linked, dm->number_linked_client, dm->rssi_min, dig_t->cur_ig_value, dm->noisy_decision); } void phydm_basic_profile( void *dm_void, u32 *_used, char *output, u32 *_out_len ) { #ifdef CONFIG_PHYDM_DEBUG_FUNCTION struct dm_struct *dm = (struct dm_struct *)dm_void; char *cut = NULL; char *ic_type = NULL; u32 used = *_used; u32 out_len = *_out_len; u32 date = 0; char *commit_by = NULL; u32 release_ver = 0; PDM_SNPF(out_len, used, output + used, out_len - used, "%-35s\n", "% Basic Profile %"); if (dm->support_ic_type == ODM_RTL8188E) { #if (RTL8188E_SUPPORT == 1) ic_type = "RTL8188E"; date = RELEASE_DATE_8188E; commit_by = COMMIT_BY_8188E; release_ver = RELEASE_VERSION_8188E; #endif } #if (RTL8812A_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8812) { ic_type = "RTL8812A"; date = RELEASE_DATE_8812A; commit_by = COMMIT_BY_8812A; release_ver = RELEASE_VERSION_8812A; } #endif #if (RTL8821A_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8821) { ic_type = "RTL8821A"; date = RELEASE_DATE_8821A; commit_by = COMMIT_BY_8821A; release_ver = RELEASE_VERSION_8821A; } #endif #if (RTL8192E_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8192E) { ic_type = "RTL8192E"; date = RELEASE_DATE_8192E; commit_by = COMMIT_BY_8192E; release_ver = RELEASE_VERSION_8192E; } #endif #if (RTL8723B_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8723B) { ic_type = "RTL8723B"; date = RELEASE_DATE_8723B; commit_by = COMMIT_BY_8723B; release_ver = RELEASE_VERSION_8723B; } #endif #if (RTL8814A_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8814A) { ic_type = "RTL8814A"; date = RELEASE_DATE_8814A; commit_by = COMMIT_BY_8814A; release_ver = RELEASE_VERSION_8814A; } #endif #if (RTL8881A_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8881A) { ic_type = "RTL8881A"; /**/ } #endif #if (RTL8822B_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8822B) { ic_type = "RTL8822B"; date = RELEASE_DATE_8822B; commit_by = COMMIT_BY_8822B; release_ver = RELEASE_VERSION_8822B; } #endif #if (RTL8197F_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8197F) { ic_type = "RTL8197F"; date = RELEASE_DATE_8197F; commit_by = COMMIT_BY_8197F; release_ver = RELEASE_VERSION_8197F; } #endif #if (RTL8703B_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8703B) { ic_type = "RTL8703B"; date = RELEASE_DATE_8703B; commit_by = COMMIT_BY_8703B; release_ver = RELEASE_VERSION_8703B; } #endif #if (RTL8195A_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8195A) { ic_type = "RTL8195A"; /**/ } #endif #if (RTL8188F_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8188F) { ic_type = "RTL8188F"; date = RELEASE_DATE_8188F; commit_by = COMMIT_BY_8188F; release_ver = RELEASE_VERSION_8188F; } #endif #if (RTL8723D_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8723D) { ic_type = "RTL8723D"; date = RELEASE_DATE_8723D; commit_by = COMMIT_BY_8723D; release_ver = RELEASE_VERSION_8723D; /**/ } #endif /* JJ ADD 20161014 */ #if (RTL8710B_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8710B) { ic_type = "RTL8710B"; date = RELEASE_DATE_8710B; commit_by = COMMIT_BY_8710B; release_ver = RELEASE_VERSION_8710B; /**/ } #endif #if (RTL8821C_SUPPORT == 1) else if (dm->support_ic_type == ODM_RTL8821C) { ic_type = "RTL8821C"; date = RELEASE_DATE_8821C; commit_by = COMMIT_BY_8821C; release_ver = RELEASE_VERSION_8821C; } #endif PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s (MP Chip: %s)\n", "IC type", ic_type, dm->is_mp_chip ? "Yes" : "No"); if (dm->cut_version == ODM_CUT_A) cut = "A"; else if (dm->cut_version == ODM_CUT_B) cut = "B"; else if (dm->cut_version == ODM_CUT_C) cut = "C"; else if (dm->cut_version == ODM_CUT_D) cut = "D"; else if (dm->cut_version == ODM_CUT_E) cut = "E"; else if (dm->cut_version == ODM_CUT_F) cut = "F"; else if (dm->cut_version == ODM_CUT_I) cut = "I"; PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %d\n", "RFE type", dm->rfe_type); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "Cut Ver", cut); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %d\n", "PHY Para Ver", odm_get_hw_img_version(dm)); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %d\n", "PHY Para Commit date", date); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "PHY Para Commit by", commit_by); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %d\n", "PHY Para Release Ver", release_ver); #if (DM_ODM_SUPPORT_TYPE & ODM_WIN) { void *adapter = dm->adapter; PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %d (Subversion: %d)\n", "FW Ver", ((PADAPTER)adapter)->MgntInfo.FirmwareVersion, ((PADAPTER)adapter)->MgntInfo.FirmwareSubVersion); } #elif (DM_ODM_SUPPORT_TYPE & ODM_AP) { struct rtl8192cd_priv *priv = dm->priv; PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %d (Subversion: %d)\n", "FW Ver", priv->pshare->fw_version, priv->pshare->fw_sub_version); } #elif (DM_ODM_SUPPORT_TYPE == ODM_CE) && defined(DM_ODM_CE_MAC80211) { struct rtl_priv *rtlpriv = (struct rtl_priv *)dm->adapter; struct rtl_hal *rtlhal = rtl_hal(rtlpriv); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %d (Subversion: %d)\n", "FW Ver", rtlhal->fw_version, rtlhal->fw_subversion); } #else { void *adapter = dm->adapter; HAL_DATA_TYPE *hal_data = GET_HAL_DATA((PADAPTER)adapter); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %d (Subversion: %d)\n", "FW Ver", hal_data->firmware_version, hal_data->firmware_sub_version); } #endif /* 1 PHY DM version List */ PDM_SNPF(out_len, used, output + used, out_len - used, "%-35s\n", "% PHYDM version %"); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "Code base", PHYDM_CODE_BASE); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "Release Date", PHYDM_RELEASE_DATE); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "Adaptivity", ADAPTIVITY_VERSION); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "DIG", DIG_VERSION); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "CFO Tracking", CFO_TRACKING_VERSION); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "AntDiv", ANTDIV_VERSION); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "Dynamic TxPower", DYNAMIC_TXPWR_VERSION); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "RA Info", RAINFO_VERSION); #if (DM_ODM_SUPPORT_TYPE & ODM_WIN) PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "AntDetect", ANTDECT_VERSION); #endif PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "PathDiv", PATHDIV_VERSION); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "LA mode", DYNAMIC_LA_MODE); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "Primary CCA", PRIMARYCCA_VERSION); PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "DFS", DFS_VERSION); #if (RTL8822B_SUPPORT == 1) if (dm->support_ic_type & ODM_RTL8822B) PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "PHY config 8822B", PHY_CONFIG_VERSION_8822B); #endif #if (RTL8197F_SUPPORT == 1) if (dm->support_ic_type & ODM_RTL8197F) PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s: %s\n", "PHY config 8197F", PHY_CONFIG_VERSION_8197F); #endif *_used = used; *_out_len = out_len; /* RF Function version List */ halrf_basic_profile(dm_void, &used, output, &out_len); #endif /*#if CONFIG_PHYDM_DEBUG_FUNCTION*/ } #ifdef CONFIG_PHYDM_DEBUG_FUNCTION void phydm_fw_trace_en_h2c( void *dm_void, boolean enable, u32 fw_debug_component, u32 monitor_mode, u32 macid ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u8 h2c_parameter[7] = {0}; u8 cmd_length; if (dm->support_ic_type & PHYDM_IC_3081_SERIES) { h2c_parameter[0] = enable; h2c_parameter[1] = (u8)(fw_debug_component & MASKBYTE0); h2c_parameter[2] = (u8)((fw_debug_component & MASKBYTE1) >> 8); h2c_parameter[3] = (u8)((fw_debug_component & MASKBYTE2) >> 16); h2c_parameter[4] = (u8)((fw_debug_component & MASKBYTE3) >> 24); h2c_parameter[5] = (u8)monitor_mode; h2c_parameter[6] = (u8)macid; cmd_length = 7; } else { h2c_parameter[0] = enable; h2c_parameter[1] = (u8)monitor_mode; h2c_parameter[2] = (u8)macid; cmd_length = 3; } PHYDM_DBG(dm, DBG_FW_TRACE, "---->\n"); if (monitor_mode == 0) { PHYDM_DBG(dm, DBG_FW_TRACE, "[H2C] FW_debug_en: (( %d ))\n", enable); } else { PHYDM_DBG(dm, DBG_FW_TRACE, "[H2C] FW_debug_en: (( %d )), mode: (( %d )), macid: (( %d ))\n", enable, monitor_mode, macid); odm_fill_h2c_cmd(dm, PHYDM_H2C_FW_TRACE_EN, cmd_length, h2c_parameter); } } void phydm_get_per_path_txagc( void *dm_void, u8 path, u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u8 rate_idx; u8 txagc; u32 used = *_used; u32 out_len = *_out_len; #ifdef PHYDM_COMMON_API_SUPPORT if (((dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8197F)) && (path <= RF_PATH_B)) || ((dm->support_ic_type & (ODM_RTL8821C)) && (path <= RF_PATH_A))) { for (rate_idx = 0; rate_idx <= 0x53; rate_idx++) { if (rate_idx == ODM_RATE1M) PDM_SNPF(out_len, used, output + used, out_len - used, " %-35s\n", "CCK====>"); else if (rate_idx == ODM_RATE6M) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "OFDM====>"); else if (rate_idx == ODM_RATEMCS0) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "HT 1ss====>"); else if (rate_idx == ODM_RATEMCS8) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "HT 2ss====>"); else if (rate_idx == ODM_RATEMCS16) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "HT 3ss====>"); else if (rate_idx == ODM_RATEMCS24) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "HT 4ss====>"); else if (rate_idx == ODM_RATEVHTSS1MCS0) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "VHT 1ss====>"); else if (rate_idx == ODM_RATEVHTSS2MCS0) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "VHT 2ss====>"); else if (rate_idx == ODM_RATEVHTSS3MCS0) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "VHT 3ss====>"); else if (rate_idx == ODM_RATEVHTSS4MCS0) PDM_SNPF(out_len, used, output + used, out_len - used, "\n %-35s\n", "VHT 4ss====>"); txagc = phydm_api_get_txagc(dm, (enum rf_path) path, rate_idx); if (config_phydm_read_txagc_check(txagc)) PDM_SNPF(out_len, used, output + used, out_len - used, " 0x%02x ", txagc); else PDM_SNPF(out_len, used, output + used, out_len - used, " 0x%s ", "xx"); } } #endif *_used = used; *_out_len = out_len; } void phydm_get_txagc( void *dm_void, u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 used = *_used; u32 out_len = *_out_len; /* path-A */ PDM_SNPF(out_len, used, output + used, out_len - used, "%-35s\n", "path-A===================="); phydm_get_per_path_txagc(dm, RF_PATH_A, &used, output, &out_len); /* path-B */ PDM_SNPF(out_len, used, output + used, out_len - used, "\n%-35s\n", "path-B===================="); phydm_get_per_path_txagc(dm, RF_PATH_B, &used, output, &out_len); /* path-C */ PDM_SNPF(out_len, used, output + used, out_len - used, "\n%-35s\n", "path-C===================="); phydm_get_per_path_txagc(dm, RF_PATH_C, &used, output, &out_len); /* path-D */ PDM_SNPF(out_len, used, output + used, out_len - used, "\n%-35s\n", "path-D===================="); phydm_get_per_path_txagc(dm, RF_PATH_D, &used, output, &out_len); *_used = used; *_out_len = out_len; } void phydm_set_txagc( void *dm_void, u32 *const dm_value, u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 used = *_used; u32 out_len = *_out_len; u8 i; u32 power_index; boolean status = true; /*dm_value[1] = path*/ /*dm_value[2] = hw_rate*/ /*dm_value[3] = power_index*/ #ifdef PHYDM_COMMON_API_SUPPORT if ((dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8197F | ODM_RTL8821C)) == 0) return; if (dm_value[1] >= dm->num_rf_path) { PDM_SNPF(out_len, used, output + used, out_len - used, " %s%d %s%x%s\n", "Write path-", (dm_value[1] & 0x1), "rate index-0x", (dm_value[2] & 0x7f), " fail"); } else if ((u8)dm_value[2] != 0xff) { if (phydm_api_set_txagc(dm, dm_value[3], (enum rf_path) dm_value[1], (u8)dm_value[2], true)) PDM_SNPF(out_len, used, output + used, out_len - used, " %s%d %s%x%s%x\n", "Write path-", dm_value[1], "rate index-0x", dm_value[2], " = 0x", dm_value[3]); else PDM_SNPF(out_len, used, output + used, out_len - used, " %s%d %s%x%s\n", "Write path-", (dm_value[1] & 0x1), "rate index-0x", (dm_value[2] & 0x7f), " fail"); } else { power_index = (dm_value[3] & 0x3f); if (dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8821C)) { power_index = (power_index << 24) | (power_index << 16) | (power_index << 8) | (power_index); for (i = 0; i < ODM_RATEVHTSS2MCS9; i += 4) status = (status & phydm_api_set_txagc(dm, power_index, (enum rf_path) dm_value[1], i, false)); } else if (dm->support_ic_type & ODM_RTL8197F) { for (i = 0; i <= ODM_RATEMCS15; i++) status = (status & phydm_api_set_txagc(dm, power_index, (enum rf_path) dm_value[1], i, false)); } if (status) PDM_SNPF(out_len, used, output + used, out_len - used, " %s%d %s%x\n", "Write all TXAGC of path-", dm_value[1], " = 0x", dm_value[3]); else PDM_SNPF(out_len, used, output + used, out_len - used, " %s%d %s\n", "Write all TXAGC of path-", dm_value[1], " fail"); } #endif *_used = used; *_out_len = out_len; } void phydm_debug_trace( void *dm_void, char input[][16], u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u64 pre_debug_components, one = 1; u32 used = *_used; u32 out_len = *_out_len; u32 dm_value[10] = {0}; u8 i; for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &dm_value[i]); } } pre_debug_components = dm->debug_components; PDM_SNPF(out_len, used, output + used, out_len - used, "\n================================\n"); if (dm_value[0] == 100) { PDM_SNPF(out_len, used, output + used, out_len - used, "[DBG MSG] Component Selection\n"); PDM_SNPF(out_len, used, output + used, out_len - used, "================================\n"); PDM_SNPF(out_len, used, output + used, out_len - used, "00. (( %s ))DIG\n", ((dm->debug_components & DBG_DIG) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "01. (( %s ))RA_MASK\n", ((dm->debug_components & DBG_RA_MASK) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "02. (( %s ))DYN_TXPWR\n", ((dm->debug_components & DBG_DYN_TXPWR) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "03. (( %s ))FA_CNT\n", ((dm->debug_components & DBG_FA_CNT) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "04. (( %s ))RSSI_MNTR\n", ((dm->debug_components & DBG_RSSI_MNTR) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "05. (( %s ))CCKPD\n", ((dm->debug_components & DBG_CCKPD) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "06. (( %s ))ANT_DIV\n", ((dm->debug_components & DBG_ANT_DIV) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "07. (( %s ))SMT_ANT\n", ((dm->debug_components & DBG_SMT_ANT) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "08. (( %s ))PWR_TRAIN\n", ((dm->debug_components & F08_PWR_TRAIN) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "09. (( %s ))RA\n", ((dm->debug_components & DBG_RA) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "10. (( %s ))PATH_DIV\n", ((dm->debug_components & DBG_PATH_DIV) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "11. (( %s ))DFS\n", ((dm->debug_components & DBG_DFS) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "12. (( %s ))DYN_ARFR\n", ((dm->debug_components & DBG_DYN_ARFR) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "13. (( %s ))ADAPTIVITY\n", ((dm->debug_components & DBG_ADPTVTY) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "14. (( %s ))CFO_TRK\n", ((dm->debug_components & DBG_CFO_TRK) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "15. (( %s ))ENV_MNTR\n", ((dm->debug_components & DBG_ENV_MNTR) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "16. (( %s ))PRI_CCA\n", ((dm->debug_components & DBG_PRI_CCA) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "17. (( %s ))ADPTV_SOML\n", ((dm->debug_components & DBG_ADPTV_SOML) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "18. (( %s ))LNA_SAT_CHK\n", ((dm->debug_components & DBG_LNA_SAT_CHK) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "19. (( %s ))DRP\n", ((dm->debug_components & DBG_DYN_RX_PATH) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "20. (( %s ))PHY_STATUS\n", ((dm->debug_components & DBG_PHY_STATUS) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "21. (( %s ))TMP\n", ((dm->debug_components & DBG_TMP) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "22. (( %s ))FW_DBG_TRACE\n", ((dm->debug_components & DBG_FW_TRACE) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "23. (( %s ))TXBF\n", ((dm->debug_components & DBG_TXBF) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "24. (( %s ))COMMON_FLOW\n", ((dm->debug_components & DBG_COMMON_FLOW) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "25. (( %s ))TX_PWR_TRK\n", ((dm->debug_components & ODM_COMP_TX_PWR_TRACK) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "26. (( %s ))CALIBRATION\n", ((dm->debug_components & ODM_COMP_CALIBRATION) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "27. (( %s ))MP\n", ((dm->debug_components & ODM_COMP_MP) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "28. (( %s ))PHY_CONFIG\n", ((dm->debug_components & ODM_PHY_CONFIG) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "29. (( %s ))INIT\n", ((dm->debug_components & ODM_COMP_INIT) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "30. (( %s ))COMMON\n", ((dm->debug_components & ODM_COMP_COMMON) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "31. (( %s ))API\n", ((dm->debug_components & ODM_COMP_API) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "================================\n"); } else if (dm_value[0] == 101) { dm->debug_components = 0; PDM_SNPF(out_len, used, output + used, out_len - used, "Disable all debug components\n"); } else { if (dm_value[1] == 1) /*enable*/ dm->debug_components |= (one << dm_value[0]); else if (dm_value[1] == 2) /*disable*/ dm->debug_components &= ~(one << dm_value[0]); else PDM_SNPF(out_len, used, output + used, out_len - used, "[Warning] 1:on, 2:off\n"); if ((BIT(dm_value[0]) == DBG_PHY_STATUS) && (dm_value[1] == 1)) { dm->phy_dbg_info.show_phy_sts_all_pkt = (u8)dm_value[2]; dm->phy_dbg_info.show_phy_sts_max_cnt = (u16)dm_value[3]; PDM_SNPF(out_len, used, output + used, out_len - used, "show_phy_sts_all_pkt=%d, show_phy_sts_max=%d\n\n", dm->phy_dbg_info.show_phy_sts_all_pkt, dm->phy_dbg_info.show_phy_sts_max_cnt); } else if ((BIT(dm_value[0]) == ODM_COMP_COMMON) && (dm_value[1] == 1)) { dm->cmn_dbg_msg_period = (u8)dm_value[2]; if (dm->cmn_dbg_msg_period < PHYDM_WATCH_DOG_PERIOD) dm->cmn_dbg_msg_period = PHYDM_WATCH_DOG_PERIOD; PDM_SNPF(out_len, used, output + used, out_len - used, "cmn_dbg_msg_period=%d\n", dm->cmn_dbg_msg_period); } } PDM_SNPF(out_len, used, output + used, out_len - used, "pre-DbgComponents = 0x%llx\n", pre_debug_components); PDM_SNPF(out_len, used, output + used, out_len - used, "Curr-DbgComponents = 0x%llx\n", dm->debug_components); PDM_SNPF(out_len, used, output + used, out_len - used, "================================\n"); *_used = used; *_out_len = out_len; } void phydm_fw_debug_trace( void *dm_void, u32 *const dm_value, u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 pre_fw_debug_components, one = 1; u32 used = *_used; u32 out_len = *_out_len; pre_fw_debug_components = dm->fw_debug_components; PDM_SNPF(out_len, used, output + used, out_len - used, "\n%s\n", "================================"); if (dm_value[0] == 100) { PDM_SNPF(out_len, used, output + used, out_len - used, "%s\n", "[FW Debug Component]"); PDM_SNPF(out_len, used, output + used, out_len - used, "%s\n", "================================"); PDM_SNPF(out_len, used, output + used, out_len - used, "00. (( %s ))RA\n", ((dm->fw_debug_components & PHYDM_FW_COMP_RA) ? ("V") : ("."))); if (dm->support_ic_type & PHYDM_IC_3081_SERIES) { PDM_SNPF(out_len, used, output + used, out_len - used, "01. (( %s ))MU\n", ((dm->fw_debug_components & PHYDM_FW_COMP_MU) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "02. (( %s ))path Div\n", ((dm->fw_debug_components & PHYDM_FW_COMP_PATH_DIV) ? ("V") : ("."))); PDM_SNPF(out_len, used, output + used, out_len - used, "03. (( %s ))Power training\n", ((dm->fw_debug_components & PHYDM_FW_COMP_PT) ? ("V") : ("."))); } PDM_SNPF(out_len, used, output + used, out_len - used, "%s\n", "================================"); } else { if (dm_value[0] == 101) { dm->fw_debug_components = 0; PDM_SNPF(out_len, used, output + used, out_len - used, "%s\n", "Clear all fw debug components"); } else { if (dm_value[1] == 1) /*enable*/ dm->fw_debug_components |= (one << dm_value[0]); else if (dm_value[1] == 2) /*disable*/ dm->fw_debug_components &= ~(one << dm_value[0]); else PDM_SNPF(out_len, used, output + used, out_len - used, "%s\n", "[Warning!!!] 1:enable, 2:disable"); } if (dm->fw_debug_components == 0) { dm->debug_components &= ~DBG_FW_TRACE; phydm_fw_trace_en_h2c(dm, false, dm->fw_debug_components, dm_value[2], dm_value[3]); /*H2C to enable C2H Msg*/ } else { dm->debug_components |= DBG_FW_TRACE; phydm_fw_trace_en_h2c(dm, true, dm->fw_debug_components, dm_value[2], dm_value[3]); /*H2C to enable C2H Msg*/ } } } void phydm_dump_bb_reg( void *dm_void, u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 addr = 0; u32 used = *_used; u32 out_len = *_out_len; /* BB Reg, For Nseries IC we only need to dump page8 to pageF using 3 digits*/ for (addr = 0x800; addr < 0xfff; addr += 4) { if (dm->support_ic_type & ODM_IC_11N_SERIES) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%03x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); else PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); } if (dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8814A | ODM_RTL8821C)) { if (dm->rf_type > RF_2T2R) { for (addr = 0x1800; addr < 0x18ff; addr += 4) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); } if (dm->rf_type > RF_3T3R) { for (addr = 0x1a00; addr < 0x1aff; addr += 4) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); } for (addr = 0x1900; addr < 0x19ff; addr += 4) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); for (addr = 0x1c00; addr < 0x1cff; addr += 4) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); for (addr = 0x1f00; addr < 0x1fff; addr += 4) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); } *_used = used; *_out_len = out_len; } void phydm_dump_all_reg( void *dm_void, u32 *_used, char *output, u32 *_out_len ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u32 addr = 0; u32 used = *_used; u32 out_len = *_out_len; /* dump MAC register */ PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "MAC==========\n"); for (addr = 0; addr < 0x7ff; addr += 4) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); for (addr = 0x1000; addr < 0x17ff; addr += 4) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%04x 0x%08x\n", addr, odm_get_bb_reg(dm, addr, MASKDWORD)); /* dump BB register */ PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "BB==========\n"); phydm_dump_bb_reg(dm, &used, output, &out_len); /* dump RF register */ PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "RF-A==========\n"); for (addr = 0; addr < 0xFF; addr++) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%02x 0x%05x\n", addr, odm_get_rf_reg(dm, RF_PATH_A, addr, RFREGOFFSETMASK)); if (dm->rf_type > RF_1T1R) { PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "RF-B==========\n"); for (addr = 0; addr < 0xFF; addr++) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%02x 0x%05x\n", addr, odm_get_rf_reg(dm, RF_PATH_B, addr, RFREGOFFSETMASK)); } if (dm->rf_type > RF_2T2R) { PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "RF-C==========\n"); for (addr = 0; addr < 0xFF; addr++) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%02x 0x%05x\n", addr, odm_get_rf_reg(dm, RF_PATH_C, addr, RFREGOFFSETMASK)); } if (dm->rf_type > RF_3T3R) { PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "RF-D==========\n"); for (addr = 0; addr < 0xFF; addr++) PHYDM_VAST_INFO_SNPRINTF(out_len, used, output + used, out_len - used, "0x%02x 0x%05x\n", addr, odm_get_rf_reg(dm, RF_PATH_D, addr, RFREGOFFSETMASK)); } *_used = used; *_out_len = out_len; } void phydm_enable_big_jump( struct dm_struct *dm, boolean state ) { #if (RTL8822B_SUPPORT == 1) struct phydm_dig_struct *dig_t = &dm->dm_dig_table; if (state == false) { dm->dm_dig_table.enable_adjust_big_jump = false; odm_set_bb_reg(dm, 0x8c8, 0xfe, ((dig_t->big_jump_step3 << 5) | (dig_t->big_jump_step2 << 3) | dig_t->big_jump_step1)); } else dm->dm_dig_table.enable_adjust_big_jump = true; #endif } #if (RTL8822B_SUPPORT == 1 | RTL8821C_SUPPORT == 1 | RTL8814B_SUPPORT == 1) void phydm_show_rx_rate( struct dm_struct *dm, u32 *_used, char *output, u32 *_out_len ) { u32 used = *_used; u32 out_len = *_out_len; PDM_SNPF(out_len, used, output + used, out_len - used, "=====Rx SU rate Statistics=====\n"); PDM_SNPF(out_len, used, output + used, out_len - used, "1SS MCS0 = %d, 1SS MCS1 = %d, 1SS MCS2 = %d, 1SS MCS 3 = %d\n", dm->phy_dbg_info.num_qry_vht_pkt[0], dm->phy_dbg_info.num_qry_vht_pkt[1], dm->phy_dbg_info.num_qry_vht_pkt[2], dm->phy_dbg_info.num_qry_vht_pkt[3]); PDM_SNPF(out_len, used, output + used, out_len - used, "1SS MCS4 = %d, 1SS MCS5 = %d, 1SS MCS6 = %d, 1SS MCS 7 = %d\n", dm->phy_dbg_info.num_qry_vht_pkt[4], dm->phy_dbg_info.num_qry_vht_pkt[5], dm->phy_dbg_info.num_qry_vht_pkt[6], dm->phy_dbg_info.num_qry_vht_pkt[7]); PDM_SNPF(out_len, used, output + used, out_len - used, "1SS MCS8 = %d, 1SS MCS9 = %d\n", dm->phy_dbg_info.num_qry_vht_pkt[8], dm->phy_dbg_info.num_qry_vht_pkt[9]); #if (defined(PHYDM_COMPILE_ABOVE_2SS)) if (dm->support_ic_type & (PHYDM_IC_ABOVE_2SS)) { PDM_SNPF(out_len, used, output + used, out_len - used, "2SS MCS0 = %d, 2SS MCS1 = %d, 2SS MCS2 = %d, 2SS MCS 3 = %d\n", dm->phy_dbg_info.num_qry_vht_pkt[10], dm->phy_dbg_info.num_qry_vht_pkt[11], dm->phy_dbg_info.num_qry_vht_pkt[12], dm->phy_dbg_info.num_qry_vht_pkt[13]); PDM_SNPF(out_len, used, output + used, out_len - used, "2SS MCS4 = %d, 2SS MCS5 = %d, 2SS MCS6 = %d, 2SS MCS 7 = %d\n", dm->phy_dbg_info.num_qry_vht_pkt[14], dm->phy_dbg_info.num_qry_vht_pkt[15], dm->phy_dbg_info.num_qry_vht_pkt[16], dm->phy_dbg_info.num_qry_vht_pkt[17]); PDM_SNPF(out_len, used, output + used, out_len - used, "2SS MCS8 = %d, 2SS MCS9 = %d\n", dm->phy_dbg_info.num_qry_vht_pkt[18], dm->phy_dbg_info.num_qry_vht_pkt[19]); } #endif PDM_SNPF(out_len, used, output + used, out_len - used, "=====Rx MU rate Statistics=====\n"); PDM_SNPF(out_len, used, output + used, out_len - used, "1SS MCS0 = %d, 1SS MCS1 = %d, 1SS MCS2 = %d, 1SS MCS 3 = %d\n", dm->phy_dbg_info.num_qry_mu_vht_pkt[0], dm->phy_dbg_info.num_qry_mu_vht_pkt[1], dm->phy_dbg_info.num_qry_mu_vht_pkt[2], dm->phy_dbg_info.num_qry_mu_vht_pkt[3]); PDM_SNPF(out_len, used, output + used, out_len - used, "1SS MCS4 = %d, 1SS MCS5 = %d, 1SS MCS6 = %d, 1SS MCS 7 = %d\n", dm->phy_dbg_info.num_qry_mu_vht_pkt[4], dm->phy_dbg_info.num_qry_mu_vht_pkt[5], dm->phy_dbg_info.num_qry_mu_vht_pkt[6], dm->phy_dbg_info.num_qry_mu_vht_pkt[7]); PDM_SNPF(out_len, used, output + used, out_len - used, "1SS MCS8 = %d, 1SS MCS9 = %d\n", dm->phy_dbg_info.num_qry_mu_vht_pkt[8], dm->phy_dbg_info.num_qry_mu_vht_pkt[9]); #if (defined(PHYDM_COMPILE_ABOVE_2SS)) if (dm->support_ic_type & (PHYDM_IC_ABOVE_2SS)) { PDM_SNPF(out_len, used, output + used, out_len - used, "2SS MCS0 = %d, 2SS MCS1 = %d, 2SS MCS2 = %d, 2SS MCS 3 = %d\n", dm->phy_dbg_info.num_qry_mu_vht_pkt[10], dm->phy_dbg_info.num_qry_mu_vht_pkt[11], dm->phy_dbg_info.num_qry_mu_vht_pkt[12], dm->phy_dbg_info.num_qry_mu_vht_pkt[13]); PDM_SNPF(out_len, used, output + used, out_len - used, "2SS MCS4 = %d, 2SS MCS5 = %d, 2SS MCS6 = %d, 2SS MCS 7 = %d\n", dm->phy_dbg_info.num_qry_mu_vht_pkt[14], dm->phy_dbg_info.num_qry_mu_vht_pkt[15], dm->phy_dbg_info.num_qry_mu_vht_pkt[16], dm->phy_dbg_info.num_qry_mu_vht_pkt[17]); PDM_SNPF(out_len, used, output + used, out_len - used, "2SS MCS8 = %d, 2SS MCS9 = %d\n", dm->phy_dbg_info.num_qry_mu_vht_pkt[18], dm->phy_dbg_info.num_qry_mu_vht_pkt[19]); } #endif *_used = used; *_out_len = out_len; } #endif void phydm_per_tone_evm( void *dm_void, char input[][16], u32 *_used, char *output, u32 *_out_len, u32 input_num ) { struct dm_struct *dm = (struct dm_struct *)dm_void; u8 i, j; u32 used = *_used; u32 out_len = *_out_len; u32 var1[4] = {0}; u32 value32, tone_num, round; s8 rxevm_0, rxevm_1; s32 avg_num, evm_tone_0[256] = {0}, evm_tone_1[256] = {0}; s32 rxevm_sum_0, rxevm_sum_1; if (dm->support_ic_type & ODM_IC_11N_SERIES) { pr_debug("n series not support yet !\n"); return; } for (i = 0; i < 4; i++) { if (input[i + 1]) PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); } avg_num = var1[0]; round = var1[1]; if (dm->is_linked) { pr_debug("ID=((%d)), BW=((%d)), fc=((CH-%d))\n", dm->curr_station_id, 20<<*dm->band_width, *dm->channel); pr_debug("avg_num =((%d)), round =((%d))\n", avg_num, round); #if (DM_ODM_SUPPORT_TYPE & ODM_AP) watchdog_stop(dm->priv); #endif for (j = 0; j < round; j++) { pr_debug("\nround((%d))\n", (j + 1)); if (*dm->band_width == CHANNEL_WIDTH_20) { for (tone_num = 228; tone_num <= 255; tone_num++) { odm_set_bb_reg(dm, 0x8c4, 0xff8, tone_num); rxevm_sum_0 = 0; rxevm_sum_1 = 0; for (i = 0; i < avg_num; i++) { value32 = odm_get_bb_reg(dm, 0xF8c, MASKDWORD); rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_0 = (rxevm_0 / 2); if (rxevm_0 < -63) rxevm_0 = 0; rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24); rxevm_1 = (rxevm_1 / 2); if (rxevm_1 < -63) rxevm_1 = 0; rxevm_sum_0 += rxevm_0; rxevm_sum_1 += rxevm_1; ODM_delay_ms(1); } evm_tone_0[tone_num] = (rxevm_sum_0 / avg_num); evm_tone_1[tone_num] = (rxevm_sum_1 / avg_num); pr_debug("Tone((-%-3d)) RXEVM (1ss/2ss) =%d , %d\n", (256 - tone_num), evm_tone_0[tone_num], evm_tone_1[tone_num]); } for (tone_num = 1; tone_num <= 28; tone_num++) { odm_set_bb_reg(dm, 0x8c4, 0xff8, tone_num); rxevm_sum_0 = 0; rxevm_sum_1 = 0; for (i = 0; i < avg_num; i++) { value32 = odm_get_bb_reg(dm, 0xF8c, MASKDWORD); rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_0 = (rxevm_0 / 2); if (rxevm_0 < -63) rxevm_0 = 0; rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24); rxevm_1 = (rxevm_1 / 2); if (rxevm_1 < -63) rxevm_1 = 0; rxevm_sum_0 += rxevm_0; rxevm_sum_1 += rxevm_1; ODM_delay_ms(1); } evm_tone_0[tone_num] = (rxevm_sum_0 / avg_num); evm_tone_1[tone_num] = (rxevm_sum_1 / avg_num); pr_debug("Tone(( %-3d)) RXEVM (1ss/2ss) =%d , %d\n", tone_num, evm_tone_0[tone_num], evm_tone_1[tone_num]); } } else if (*dm->band_width == CHANNEL_WIDTH_40) { for (tone_num = 198; tone_num <= 254; tone_num++) { odm_set_bb_reg(dm, 0x8c4, 0xff8, tone_num); rxevm_sum_0 = 0; rxevm_sum_1 = 0; for (i = 0; i < avg_num; i++) { value32 = odm_get_bb_reg(dm, 0xF8c, MASKDWORD); rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_0 = (rxevm_0 / 2); if (rxevm_0 < -63) rxevm_0 = 0; rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24); rxevm_1 = (rxevm_1 / 2); if (rxevm_1 < -63) rxevm_1 = 0; rxevm_sum_0 += rxevm_0; rxevm_sum_1 += rxevm_1; ODM_delay_ms(1); } evm_tone_0[tone_num] = (rxevm_sum_0 / avg_num); evm_tone_1[tone_num] = (rxevm_sum_1 / avg_num); pr_debug("Tone((-%-3d)) RXEVM (1ss/2ss) =%d , %d\n", (256 - tone_num), evm_tone_0[tone_num], evm_tone_1[tone_num]); } for (tone_num = 2; tone_num <= 58; tone_num++) { odm_set_bb_reg(dm, 0x8c4, 0xff8, tone_num); rxevm_sum_0 = 0; rxevm_sum_1 = 0; for (i = 0; i < avg_num; i++) { value32 = odm_get_bb_reg(dm, 0xF8c, MASKDWORD); rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_0 = (rxevm_0 / 2); if (rxevm_0 < -63) rxevm_0 = 0; rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24); rxevm_1 = (rxevm_1 / 2); if (rxevm_1 < -63) rxevm_1 = 0; rxevm_sum_0 += rxevm_0; rxevm_sum_1 += rxevm_1; ODM_delay_ms(1); } evm_tone_0[tone_num] = (rxevm_sum_0 / avg_num); evm_tone_1[tone_num] = (rxevm_sum_1 / avg_num); pr_debug("Tone(( %-3d)) RXEVM (1ss/2ss) =%d , %d\n", tone_num, evm_tone_0[tone_num], evm_tone_1[tone_num]); } } else if (*dm->band_width == CHANNEL_WIDTH_80) { for (tone_num = 134; tone_num <= 254; tone_num++) { odm_set_bb_reg(dm, 0x8c4, 0xff8, tone_num); rxevm_sum_0 = 0; rxevm_sum_1 = 0; for (i = 0; i < avg_num; i++) { value32 = odm_get_bb_reg(dm, 0xF8c, MASKDWORD); rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_0 = (rxevm_0 / 2); if (rxevm_0 < -63) rxevm_0 = 0; rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24); rxevm_1 = (rxevm_1 / 2); if (rxevm_1 < -63) rxevm_1 = 0; rxevm_sum_0 += rxevm_0; rxevm_sum_1 += rxevm_1; ODM_delay_ms(1); } evm_tone_0[tone_num] = (rxevm_sum_0 / avg_num); evm_tone_1[tone_num] = (rxevm_sum_1 / avg_num); pr_debug("Tone((-%-3d)) RXEVM (1ss/2ss) =%d , %d\n", (256 - tone_num), evm_tone_0[tone_num], evm_tone_1[tone_num]); } for (tone_num = 2; tone_num <= 122; tone_num++) { odm_set_bb_reg(dm, 0x8c4, 0xff8, tone_num); rxevm_sum_0 = 0; rxevm_sum_1 = 0; for (i = 0; i < avg_num; i++) { value32 = odm_get_bb_reg(dm, 0xF8c, MASKDWORD); rxevm_0 = (s8)((value32 & MASKBYTE2) >> 16); rxevm_0 = (rxevm_0 / 2); if (rxevm_0 < -63) rxevm_0 = 0; rxevm_1 = (s8)((value32 & MASKBYTE3) >> 24); rxevm_1 = (rxevm_1 / 2); if (rxevm_1 < -63) rxevm_1 = 0; rxevm_sum_0 += rxevm_0; rxevm_sum_1 += rxevm_1; ODM_delay_ms(1); } evm_tone_0[tone_num] = (rxevm_sum_0 / avg_num); evm_tone_1[tone_num] = (rxevm_sum_1 / avg_num); pr_debug("Tone(( %-3d)) RXEVM (1ss/2ss) =%d , %d\n", tone_num, evm_tone_0[tone_num], evm_tone_1[tone_num]); } } } } else PDM_SNPF(out_len, used, output + used, out_len - used, "No Link !!\n"); } void phydm_api_adjust( void *dm_void, char input[][16], u32 *_used, char *output, u32 *_out_len, u32 input_num ) { struct dm_struct *dm = (struct dm_struct *)dm_void; char help[] = "-h"; u32 var1[10] = {0}; u32 used = *_used; u32 out_len = *_out_len; u8 i; boolean is_enable_dbg_mode; u8 central_ch, primary_ch_idx; enum channel_width bandwidth; #ifdef PHYDM_COMMON_API_SUPPORT if ((strcmp(input[1], help) == 0)) { PDM_SNPF(out_len, used, output + used, out_len - used, "{en} {ch_num} {prm_ch 1/2/3/4/9/10} {0:20M, 1:40M, 2:80M}\n"); goto out; } if ((dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8197F | ODM_RTL8821C)) == 0) { PDM_SNPF(out_len, used, output + used, out_len - used, "This IC doesn't support PHYDM API function\n"); /**/ goto out; } for (i = 0; i < 4; i++) { if (input[i + 1]) PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); } is_enable_dbg_mode = (boolean)var1[0]; central_ch = (u8) var1[1]; primary_ch_idx = (u8) var1[2]; bandwidth = (enum channel_width)var1[3]; if (is_enable_dbg_mode) { dm->is_disable_phy_api = false; phydm_api_switch_bw_channel(dm, central_ch, primary_ch_idx, bandwidth); dm->is_disable_phy_api = true; PDM_SNPF(out_len, used, output + used, out_len - used, "central_ch = %d, primary_ch_idx = %d, bandwidth = %d\n", central_ch, primary_ch_idx, bandwidth); } else { dm->is_disable_phy_api = false; PDM_SNPF(out_len, used, output + used, out_len - used, "Disable API debug mode\n"); } out: #else PDM_SNPF(out_len, used, output + used, out_len - used, "This IC doesn't support PHYDM API function\n"); #endif *_used = used; *_out_len = out_len; } void phydm_parameter_adjust( void *dm_void, char input[][16], u32 *_used, char *output, u32 *_out_len, u32 input_num ) { struct dm_struct *dm = (struct dm_struct *)dm_void; struct phydm_cfo_track_struct *cfo_track = (struct phydm_cfo_track_struct *)phydm_get_structure(dm, PHYDM_CFOTRACK); char help[] = "-h"; u32 var1[10] = {0}; u32 used = *_used; u32 out_len = *_out_len; u8 i; if ((strcmp(input[1], help) == 0)) { PDM_SNPF(out_len, used, output + used, out_len - used, "1. X_cap = ((0x%x))\n", cfo_track->crystal_cap); } else { PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]); if (var1[0] == 0) { PHYDM_SSCANF(input[2], DCMD_HEX, &var1[1]); phydm_set_crystal_cap(dm, (u8)var1[1]); PDM_SNPF(out_len, used, output + used, out_len - used, "X_cap = ((0x%x))\n", cfo_track->crystal_cap); } } *_used = used; *_out_len = out_len; } struct phydm_command { char name[16]; u8 id; }; enum PHYDM_CMD_ID { PHYDM_HELP, PHYDM_DEMO, PHYDM_DIG, PHYDM_RA, PHYDM_PROFILE, PHYDM_ANTDIV, PHYDM_PATHDIV, PHYDM_DEBUG, PHYDM_FW_DEBUG, PHYDM_SUPPORT_ABILITY, PHYDM_RF_SUPPORTABILITY, PHYDM_RF_PROFILE, PHYDM_RF_IQK_INFO, PHYDM_IQK, PHYDM_IQK_DEBUG, PHYDM_GET_TXAGC, PHYDM_SET_TXAGC, PHYDM_SMART_ANT, PHYDM_API, PHYDM_TRX_PATH, PHYDM_LA_MODE, PHYDM_DUMP_REG, PHYDM_AUTO_DBG, PHYDM_BIG_JUMP, PHYDM_SHOW_RXRATE, PHYDM_NBI_EN, PHYDM_CSI_MASK_EN, PHYDM_DFS_DEBUG, PHYDM_NHM, PHYDM_CLM, PHYDM_FAHM, PHYDM_ENV_MNTR, PHYDM_BB_INFO, PHYDM_TXBF, PHYDM_H2C, PHYDM_ANT_SWITCH, PHYDM_DYNAMIC_RA_PATH, PHYDM_ADAPTIVE_SOML, PHYDM_PSD, PHYDM_DEBUG_PORT, PHYDM_DIS_HTSTF_CONTROL, PHYDM_TUNE_PARAMETER, PHYDM_ADAPTIVITY_DEBUG, PHYDM_DIS_DYM_ANT_WEIGHTING, PHYDM_FORECE_PT_STATE, PHYDM_DIS_RXHP_CTR, PHYDM_STA_INFO, PHYDM_PAUSE_FUNC, PHYDM_PER_TONE_EVM }; struct phydm_command phy_dm_ary[] = { {"-h", PHYDM_HELP}, /*do not move this element to other position*/ {"demo", PHYDM_DEMO}, /*do not move this element to other position*/ {"dig", PHYDM_DIG}, {"ra", PHYDM_RA}, {"profile", PHYDM_PROFILE}, {"antdiv", PHYDM_ANTDIV}, {"pathdiv", PHYDM_PATHDIV}, {"dbg", PHYDM_DEBUG}, {"fw_dbg", PHYDM_FW_DEBUG}, {"ability", PHYDM_SUPPORT_ABILITY}, {"rf_ability", PHYDM_RF_SUPPORTABILITY}, {"rf_profile", PHYDM_RF_PROFILE}, {"iqk_info", PHYDM_RF_IQK_INFO}, {"iqk", PHYDM_IQK}, {"iqk_dbg", PHYDM_IQK_DEBUG}, {"get_txagc", PHYDM_GET_TXAGC}, {"set_txagc", PHYDM_SET_TXAGC}, {"smtant", PHYDM_SMART_ANT}, {"api", PHYDM_API}, {"trxpath", PHYDM_TRX_PATH}, {"lamode", PHYDM_LA_MODE}, {"dumpreg", PHYDM_DUMP_REG}, {"auto_dbg", PHYDM_AUTO_DBG}, {"bigjump", PHYDM_BIG_JUMP}, {"rxrate", PHYDM_SHOW_RXRATE}, {"nbi", PHYDM_NBI_EN}, {"csi_mask", PHYDM_CSI_MASK_EN}, {"dfs", PHYDM_DFS_DEBUG}, {"nhm", PHYDM_NHM}, {"clm", PHYDM_CLM}, {"fahm", PHYDM_FAHM}, {"env_mntr", PHYDM_ENV_MNTR}, {"bbinfo", PHYDM_BB_INFO}, {"txbf", PHYDM_TXBF}, {"h2c", PHYDM_H2C}, {"ant_switch", PHYDM_ANT_SWITCH}, {"drp", PHYDM_DYNAMIC_RA_PATH}, {"soml", PHYDM_ADAPTIVE_SOML}, {"psd", PHYDM_PSD}, {"dbgport", PHYDM_DEBUG_PORT}, {"dis_htstf", PHYDM_DIS_HTSTF_CONTROL}, {"tune_para", PHYDM_TUNE_PARAMETER}, {"adapt_debug", PHYDM_ADAPTIVITY_DEBUG}, {"dis_dym_ant_wgt", PHYDM_DIS_DYM_ANT_WEIGHTING}, {"force_pt_state", PHYDM_FORECE_PT_STATE}, {"dis_drxhp", PHYDM_DIS_RXHP_CTR}, {"sta_info", PHYDM_STA_INFO}, {"pause", PHYDM_PAUSE_FUNC}, {"evm", PHYDM_PER_TONE_EVM} }; #endif /*#ifdef CONFIG_PHYDM_DEBUG_FUNCTION*/ void phydm_cmd_parser( struct dm_struct *dm, char input[][MAX_ARGV], u32 input_num, u8 flag, char *output, u32 out_len ) { #ifdef CONFIG_PHYDM_DEBUG_FUNCTION u32 used = 0; u8 id = 0; int var1[10] = {0}; int i, input_idx = 0, phydm_ary_size = sizeof(phy_dm_ary) / sizeof(struct phydm_command); char help[] = "-h"; if (flag == 0) { PDM_SNPF(out_len, used, output + used, out_len - used, "GET, nothing to print\n"); return; } PDM_SNPF(out_len, used, output + used, out_len - used, "\n"); /* Parsing Cmd ID */ if (input_num) { for (i = 0; i < phydm_ary_size; i++) { if (strcmp(phy_dm_ary[i].name, input[0]) == 0) { id = phy_dm_ary[i].id; break; } } if (i == phydm_ary_size) { PDM_SNPF(out_len, used, output + used, out_len - used, "SET, command not found!\n"); return; } } switch (id) { case PHYDM_HELP: { PDM_SNPF(out_len, used, output + used, out_len - used, "BB cmd ==>\n"); for (i = 0; i < phydm_ary_size - 2; i++) { PDM_SNPF(out_len, used, output + used, out_len - used, " %-5d: %s\n", i, phy_dm_ary[i + 2].name); /**/ } } break; case PHYDM_DEMO: { /*echo demo 10 0x3a z abcde >cmd*/ u32 directory = 0; #if (DM_ODM_SUPPORT_TYPE & (ODM_CE | ODM_AP)) char char_temp; #else u32 char_temp = ' '; #endif PHYDM_SSCANF(input[1], DCMD_DECIMAL, &directory); PDM_SNPF(out_len, used, output + used, out_len - used, "Decimal value = %d\n", directory); PHYDM_SSCANF(input[2], DCMD_HEX, &directory); PDM_SNPF(out_len, used, output + used, out_len - used, "Hex value = 0x%x\n", directory); PHYDM_SSCANF(input[3], DCMD_CHAR, &char_temp); PDM_SNPF(out_len, used, output + used, out_len - used, "Char = %c\n", char_temp); PDM_SNPF(out_len, used, output + used, out_len - used, "String = %s\n", input[4]); } break; case PHYDM_DIG: phydm_dig_debug(dm, &input[0], &used, output, &out_len, input_num); break; case PHYDM_RA: phydm_ra_debug(dm, &input[0], &used, output, &out_len); break; case PHYDM_ANTDIV: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]); /*PDM_SNPF((output+used, out_len-used, "new SET, PATHDIV_var[%d]= (( %d ))\n", i, var1[i]));*/ input_idx++; } } if (input_idx >= 1) { /*PDM_SNPF((output+used, out_len-used, "odm_PATHDIV_debug\n"));*/ #if (defined(CONFIG_PHYDM_ANTENNA_DIVERSITY)) phydm_antdiv_debug(dm, (u32 *)var1, &used, output, &out_len); #endif } break; case PHYDM_PATHDIV: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]); /*PDM_SNPF((output+used, out_len-used, "new SET, PATHDIV_var[%d]= (( %d ))\n", i, var1[i]));*/ input_idx++; } } if (input_idx >= 1) { /*PDM_SNPF((output+used, out_len-used, "odm_PATHDIV_debug\n"));*/ #if (defined(CONFIG_PATH_DIVERSITY)) odm_pathdiv_debug(dm, (u32 *)var1, &used, output, &out_len); #endif } break; case PHYDM_DEBUG: phydm_debug_trace(dm, &input[0], &used, output, &out_len); break; case PHYDM_FW_DEBUG: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); input_idx++; } } if (input_idx >= 1) phydm_fw_debug_trace(dm, (u32 *)var1, &used, output, &out_len); break; case PHYDM_SUPPORT_ABILITY: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); /*PDM_SNPF((output+used, out_len-used, "new SET, support ablity_var[%d]= (( %d ))\n", i, var1[i]));*/ input_idx++; } } if (input_idx >= 1) { /*PDM_SNPF((output+used, out_len-used, "support ablity\n"));*/ phydm_support_ability_debug(dm, (u32 *)var1, &used, output, &out_len); } break; case PHYDM_RF_SUPPORTABILITY: halrf_support_ability_debug(dm, &input[0], &used, output, &out_len); break; case PHYDM_RF_PROFILE: halrf_basic_profile(dm, &used, output, &out_len); break; case PHYDM_RF_IQK_INFO: #if (RTL8822B_SUPPORT == 1 || RTL8821C_SUPPORT == 1) if (dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8821C)) halrf_iqk_info_dump(dm, &used, output, &out_len); #endif break; case PHYDM_IQK: PDM_SNPF(out_len, used, output + used, out_len - used, "TRX IQK Trigger\n"); halrf_iqk_trigger(dm, false); #if (RTL8822B_SUPPORT == 1 || RTL8821C_SUPPORT == 1) if (dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8821C)) halrf_iqk_info_dump(dm, &used, output, &out_len); #endif break; case PHYDM_IQK_DEBUG: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]); input_idx++; } } if (input_idx >= 1) { #if (RTL8822B_SUPPORT == 1 || RTL8821C_SUPPORT == 1) if (dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8821C)) halrf_iqk_debug(dm, (u32 *)var1, &used, output, &out_len); #endif } break; case PHYDM_SMART_ANT: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]); input_idx++; } } if (input_idx >= 1) { #if (defined(CONFIG_PHYDM_ANTENNA_DIVERSITY)) #ifdef CONFIG_HL_SMART_ANTENNA_TYPE2 phydm_hl_smart_ant_debug_type2(dm, &input[0], &used, output, &out_len, input_num); #elif (defined(CONFIG_HL_SMART_ANTENNA_TYPE1)) phydm_hl_smart_ant_debug(dm, &input[0], &used, output, &out_len, input_num); #endif #endif #if (defined(CONFIG_CUMITEK_SMART_ANTENNA)) phydm_cumitek_smt_ant_debug(dm, &input[0], &used, output, &out_len, input_num); #endif } break; case PHYDM_API: phydm_api_adjust(dm, &input[0], &used, output, &out_len, input_num); break; case PHYDM_PROFILE: phydm_basic_profile(dm, &used, output, &out_len); break; case PHYDM_GET_TXAGC: phydm_get_txagc(dm, &used, output, &out_len); break; case PHYDM_SET_TXAGC: { boolean is_enable_dbg_mode; for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]); input_idx++; } } if ((strcmp(input[1], help) == 0)) { PDM_SNPF(out_len, used, output + used, out_len - used, "{En} {pathA~D(0~3)} {rate_idx(Hex), All_rate:0xff} {txagc_idx (Hex)}\n"); /**/ } else { is_enable_dbg_mode = (boolean)var1[0]; if (is_enable_dbg_mode) { dm->is_disable_phy_api = false; phydm_set_txagc(dm, (u32 *)var1, &used, output, &out_len); dm->is_disable_phy_api = true; } else { dm->is_disable_phy_api = false; PDM_SNPF(out_len, used, output + used, out_len - used, "Disable API debug mode\n"); } } } break; case PHYDM_TRX_PATH: for (i = 0; i < 4; i++) { if (input[i + 1]) PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); } #if (RTL8822B_SUPPORT == 1 || RTL8197F_SUPPORT == 1) if (dm->support_ic_type & (ODM_RTL8822B | ODM_RTL8197F)) { u8 tx_path, rx_path; boolean is_enable_dbg_mode, is_tx2_path; is_enable_dbg_mode = (boolean)var1[0]; tx_path = (u8) var1[1]; rx_path = (u8) var1[2]; is_tx2_path = (boolean) var1[3]; if (is_enable_dbg_mode) { dm->is_disable_phy_api = false; phydm_api_trx_mode(dm, (enum bb_path) tx_path, (enum bb_path) rx_path, is_tx2_path); dm->is_disable_phy_api = true; PDM_SNPF(out_len, used, output + used, out_len - used, "tx_path = 0x%x, rx_path = 0x%x, is_tx2_path = %d\n", tx_path, rx_path, is_tx2_path); } else { dm->is_disable_phy_api = false; PDM_SNPF(out_len, used, output + used, out_len - used, "Disable API debug mode\n"); } } else #endif phydm_config_trx_path(dm, (u32 *)var1, &used, output, &out_len); break; case PHYDM_LA_MODE: #if (PHYDM_LA_MODE_SUPPORT == 1) phydm_lamode_trigger_setting(dm, &input[0], &used, output, &out_len, input_num); #else PDM_SNPF(out_len, used, output + used, out_len - used, "This IC doesn't support LA mode\n"); #endif break; case PHYDM_DUMP_REG: { u8 type = 0; if (input[1]) { PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]); type = (u8)var1[0]; } if (type == 0) phydm_dump_bb_reg(dm, &used, output, &out_len); else if (type == 1) phydm_dump_all_reg(dm, &used, output, &out_len); } break; case PHYDM_BIG_JUMP: { #if (RTL8822B_SUPPORT == 1) if (dm->support_ic_type & ODM_RTL8822B) { if (input[1]) { PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]); phydm_enable_big_jump(dm, (boolean)(var1[0])); } else PDM_SNPF(out_len, used, output + used, out_len - used, "unknown command!\n"); } else PDM_SNPF(out_len, used, output + used, out_len - used, "The command is only for 8822B!\n"); #endif break; } case PHYDM_AUTO_DBG: #ifdef PHYDM_AUTO_DEGBUG phydm_auto_dbg_console(dm, &input[0], &used, output, &out_len, input_num); #endif break; case PHYDM_SHOW_RXRATE: { #if (RTL8822B_SUPPORT == 1 | RTL8821C_SUPPORT == 1 | RTL8814B_SUPPORT == 1) u8 rate_idx; if ((dm->support_ic_type & PHYDM_IC_SUPPORT_MU_BFEE) == 0) break; if (input[1]) PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]); if (var1[0] == 1) phydm_show_rx_rate(dm, &used, output, &out_len); else { PDM_SNPF(out_len, used, output + used, out_len - used, "Reset Rx rate counter\n"); for (rate_idx = 0; rate_idx < VHT_RATE_NUM; rate_idx++) { dm->phy_dbg_info.num_qry_vht_pkt[rate_idx] = 0; dm->phy_dbg_info.num_qry_mu_vht_pkt[rate_idx] = 0; } } #endif break; } case PHYDM_NBI_EN: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); input_idx++; } } if (input_idx >= 1) { phydm_api_debug(dm, PHYDM_API_NBI, (u32 *)var1, &used, output, &out_len); /**/ } break; case PHYDM_CSI_MASK_EN: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); input_idx++; } } if (input_idx >= 1) { phydm_api_debug(dm, PHYDM_API_CSI_MASK, (u32 *)var1, &used, output, &out_len); /**/ } break; case PHYDM_DFS_DEBUG: { #ifdef CONFIG_PHYDM_DFS_MASTER u32 var[4] = {0}; for (i = 0; i < 4; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var[i]); input_idx++; } } if (input_idx >= 1) phydm_dfs_debug(dm, var, &used, output, &out_len); #endif break; } case PHYDM_NHM: #ifdef NHM_SUPPORT phydm_nhm_dbg(dm, &input[0], &used, output, &out_len, input_num); #endif break; case PHYDM_CLM: #ifdef CLM_SUPPORT phydm_clm_dbg(dm, &input[0], &used, output, &out_len, input_num); #endif break; #ifdef FAHM_SUPPORT case PHYDM_FAHM: phydm_fahm_dbg(dm, &input[0], &used, output, &out_len, input_num); break; #endif case PHYDM_ENV_MNTR: phydm_env_mntr_dbg(dm, &input[0], &used, output, &out_len, input_num); break; case PHYDM_BB_INFO: { s32 value32 = 0; phydm_bb_debug_info(dm, &used, output, &out_len); if (dm->support_ic_type & ODM_RTL8822B && input[1]) { PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]); odm_set_bb_reg(dm, 0x1988, 0x003fff00, var1[0]); value32 = odm_get_bb_reg(dm, 0xf84, MASKDWORD); value32 = (value32 & 0xff000000) >> 24; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n %-35s = condition num = %d, subcarriers = %d\n", "Over condition num subcarrier", var1[0], value32); odm_set_bb_reg(dm, 0x1988, BIT(22), 0x0); /*disable report condition number*/ } } break; case PHYDM_TXBF: { #if (DM_ODM_SUPPORT_TYPE & (ODM_WIN | ODM_CE)) #if (BEAMFORMING_SUPPORT == 1) struct _RT_BEAMFORMING_INFO *beamforming_info = &dm->beamforming_info; PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]); if (var1[0] == 0) { beamforming_info->apply_v_matrix = false; beamforming_info->snding3ss = true; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n dont apply V matrix and 3SS 789 snding\n"); } else if (var1[0] == 1) { beamforming_info->apply_v_matrix = true; beamforming_info->snding3ss = true; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n apply V matrix and 3SS 789 snding\n"); } else if (var1[0] == 2) { beamforming_info->apply_v_matrix = true; beamforming_info->snding3ss = false; PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n default txbf setting\n"); } else PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n unknown cmd!!\n"); #else PDM_SNPF(out_len, used, output + used, out_len - used, "\r\n no TxBF !!\n"); #endif #endif } break; case PHYDM_H2C: for (i = 0; i < 8; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]); input_idx++; } } if (input_idx >= 1) phydm_h2C_debug(dm, (u32 *)var1, &used, output, &out_len); break; case PHYDM_ANT_SWITCH: for (i = 0; i < 8; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); input_idx++; } } if (input_idx >= 1) { #if (RTL8821A_SUPPORT == 1) phydm_set_ext_switch(dm, (u32 *)var1, &used, output, &out_len); #else PDM_SNPF(out_len, used, output + used, out_len - used, "Not Support IC"); #endif } break; case PHYDM_DYNAMIC_RA_PATH: #ifdef CONFIG_DYNAMIC_RX_PATH for (i = 0; i < 8; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); input_idx++; } } if (input_idx >= 1) phydm_drp_debug(dm, (u32 *)var1, &used, output, &out_len); #else PDM_SNPF(out_len, used, output + used, out_len - used, "Not Support IC"); #endif break; case PHYDM_ADAPTIVE_SOML: #ifdef CONFIG_ADAPTIVE_SOML for (i = 0; i < 8; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_DECIMAL, &var1[i]); input_idx++; } } if (input_idx >= 1) phydm_soml_debug(dm, (u32 *)var1, &used, output, &out_len); #else PDM_SNPF(out_len, used, output + used, out_len - used, "Not Support IC"); #endif break; case PHYDM_PSD: #ifdef CONFIG_PSD_TOOL phydm_psd_debug(dm, &input[0], &used, output, &out_len, input_num); #endif break; case PHYDM_DEBUG_PORT: { u32 dbg_port_value; PHYDM_SSCANF(input[1], DCMD_HEX, &var1[0]); dm->debug_components |= ODM_COMP_API; if (phydm_set_bb_dbg_port(dm, BB_DBGPORT_PRIORITY_3, var1[0])) {/*set debug port to 0x0*/ dbg_port_value = phydm_get_bb_dbg_port_value(dm); phydm_release_bb_dbg_port(dm); PDM_SNPF(out_len, used, output + used, out_len - used, "Dbg Port[0x%x] = ((0x%x))\n", var1[0], dbg_port_value); } dm->debug_components &= (~ODM_COMP_API); } break; case PHYDM_DIS_HTSTF_CONTROL: { if (input[1]) PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]); if (var1[0] == 1) { /* setting being false is for debug */ dm->bhtstfdisabled = true; PDM_SNPF(out_len, used, output + used, out_len - used, "Dynamic HT-STF Gain Control is Disable\n"); } else { /* default setting should be true, always be dynamic control*/ dm->bhtstfdisabled = false; PDM_SNPF(out_len, used, output + used, out_len - used, "Dynamic HT-STF Gain Control is Enable\n"); } } break; case PHYDM_TUNE_PARAMETER: phydm_parameter_adjust(dm, &input[0], &used, output, &out_len, input_num); break; case PHYDM_ADAPTIVITY_DEBUG: for (i = 0; i < 5; i++) { if (input[i + 1]) { PHYDM_SSCANF(input[i + 1], DCMD_HEX, &var1[i]); input_idx++; } } if (input_idx >= 1) phydm_adaptivity_debug(dm, (u32 *)var1, &used, output, &out_len); break; case PHYDM_DIS_DYM_ANT_WEIGHTING: #ifdef DYN_ANT_WEIGHTING_SUPPORT phydm_dyn_ant_weight_dbg(dm, &input[0], &used, output, &out_len, input_num); #endif break; case PHYDM_FORECE_PT_STATE: { #ifdef PHYDM_POWER_TRAINING_SUPPORT phydm_pow_train_debug(dm, &input[0], &used, output, &out_len, input_num); #else PDM_SNPF(out_len, used, output + used, out_len - used, "Pow training: Not Support\n"); #endif break; } case PHYDM_DIS_RXHP_CTR: { if (input[1]) PHYDM_SSCANF(input[1], DCMD_DECIMAL, &var1[0]); if (var1[0] == 1) { /* the setting being on is at debug mode to disconnect RxHP seeting with SoML on/odd */ dm->disrxhpsoml = true; PDM_SNPF(out_len, used, output + used, out_len - used, "Dynamic RxHP Control with SoML on/off is Disable\n"); } else if (var1[0] == 0) { /* default setting, RxHP setting will follow SoML on/off setting */ dm->disrxhpsoml = false; PDM_SNPF(out_len, used, output + used, out_len - used, "Dynamic RxHP Control with SoML on/off is Enable\n"); } else { dm->disrxhpsoml = false; PDM_SNPF(out_len, used, output + used, out_len - used, "Default Setting, Dynamic RxHP Control with SoML on/off is Enable\n"); } } break; case PHYDM_STA_INFO: phydm_show_sta_info(dm, &input[0], &used, output, &out_len, input_num); break; case PHYDM_PAUSE_FUNC: phydm_pause_func_console(dm, &input[0], &used, output, &out_len, input_num); break; case PHYDM_PER_TONE_EVM: phydm_per_tone_evm(dm, &input[0], &used, output, &out_len, input_num); break; default: PDM_SNPF(out_len, used, output + used, out_len - used, "SET, unknown command!\n"); break; } #endif /*#ifdef CONFIG_PHYDM_DEBUG_FUNCTION*/ } #ifdef __ECOS char *strsep(char **s, const char *ct) { char *sbegin = *s; char *end; if (sbegin == NULL) return NULL; end = strpbrk(sbegin, ct); if (end) *end++ = '\0'; *s = end; return sbegin; } #endif #if (DM_ODM_SUPPORT_TYPE & (ODM_CE | ODM_AP)) s32 phydm_cmd( struct dm_struct *dm, char *input, u32 in_len, u8 flag, char *output, u32 out_len ) { char *token; u32 argc = 0; char argv[MAX_ARGC][MAX_ARGV]; do { token = strsep(&input, ", "); if (token) { strcpy(argv[argc], token); argc++; } else break; } while (argc < MAX_ARGC); if (argc == 1) argv[0][strlen(argv[0]) - 1] = '\0'; phydm_cmd_parser(dm, argv, argc, flag, output, out_len); return 0; } #endif void phydm_fw_trace_handler( void *dm_void, u8 *cmd_buf, u8 cmd_len ) { #ifdef CONFIG_PHYDM_DEBUG_FUNCTION struct dm_struct *dm = (struct dm_struct *)dm_void; /*u8 debug_trace_11byte[60];*/ u8 freg_num, c2h_seq, buf_0 = 0; if (!(dm->support_ic_type & PHYDM_IC_3081_SERIES)) return; if ((cmd_len > 12) || (cmd_len == 0)) { pr_debug("[Warning] Error C2H cmd_len=%d\n", cmd_len); return; } buf_0 = cmd_buf[0]; freg_num = (buf_0 & 0xf); c2h_seq = (buf_0 & 0xf0) >> 4; /*PHYDM_DBG(dm, DBG_FW_TRACE,"[FW debug message] freg_num = (( %d )), c2h_seq = (( %d ))\n", freg_num,c2h_seq );*/ /*strncpy(debug_trace_11byte,&cmd_buf[1],(cmd_len-1));*/ /*debug_trace_11byte[cmd_len-1] = '\0';*/ /*PHYDM_DBG(dm, DBG_FW_TRACE,"[FW debug message] %s\n", debug_trace_11byte);*/ /*PHYDM_DBG(dm, DBG_FW_TRACE,"[FW debug message] cmd_len = (( %d ))\n", cmd_len);*/ /*PHYDM_DBG(dm, DBG_FW_TRACE,"[FW debug message] c2h_cmd_start = (( %d ))\n", dm->c2h_cmd_start);*/ /*PHYDM_DBG(dm, DBG_FW_TRACE,"pre_seq = (( %d )), current_seq = (( %d ))\n", dm->pre_c2h_seq, c2h_seq);*/ /*PHYDM_DBG(dm, DBG_FW_TRACE,"fw_buff_is_enpty = (( %d ))\n", dm->fw_buff_is_enpty);*/ if ((c2h_seq != dm->pre_c2h_seq) && dm->fw_buff_is_enpty == false) { dm->fw_debug_trace[dm->c2h_cmd_start] = '\0'; PHYDM_DBG(dm, DBG_FW_TRACE, "[FW Dbg Queue Overflow] %s\n", dm->fw_debug_trace); dm->c2h_cmd_start = 0; } if ((cmd_len - 1) > (60 - dm->c2h_cmd_start)) { dm->fw_debug_trace[dm->c2h_cmd_start] = '\0'; PHYDM_DBG(dm, DBG_FW_TRACE, "[FW Dbg Queue error: wrong C2H length] %s\n", dm->fw_debug_trace); dm->c2h_cmd_start = 0; return; } strncpy((char *)&dm->fw_debug_trace[dm->c2h_cmd_start], (char *)&cmd_buf[1], (cmd_len - 1)); dm->c2h_cmd_start += (cmd_len - 1); dm->fw_buff_is_enpty = false; if (freg_num == 0 || dm->c2h_cmd_start >= 60) { if (dm->c2h_cmd_start < 60) dm->fw_debug_trace[dm->c2h_cmd_start] = '\0'; else dm->fw_debug_trace[59] = '\0'; PHYDM_DBG(dm, DBG_FW_TRACE, "[FW DBG Msg] %s\n", dm->fw_debug_trace); /*dbg_print("[FW DBG Msg] %s\n", dm->fw_debug_trace);*/ dm->c2h_cmd_start = 0; dm->fw_buff_is_enpty = true; } dm->pre_c2h_seq = c2h_seq; #endif /*#ifdef CONFIG_PHYDM_DEBUG_FUNCTION*/ } void phydm_fw_trace_handler_code( void *dm_void, u8 *buffer, u8 cmd_len ) { #ifdef CONFIG_PHYDM_DEBUG_FUNCTION struct dm_struct *dm = (struct dm_struct *)dm_void; u8 function = buffer[0]; u8 dbg_num = buffer[1]; u16 content_0 = (((u16)buffer[3]) << 8) | ((u16)buffer[2]); u16 content_1 = (((u16)buffer[5]) << 8) | ((u16)buffer[4]); u16 content_2 = (((u16)buffer[7]) << 8) | ((u16)buffer[6]); u16 content_3 = (((u16)buffer[9]) << 8) | ((u16)buffer[8]); u16 content_4 = (((u16)buffer[11]) << 8) | ((u16)buffer[10]); if (cmd_len > 12) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW Msg] Invalid cmd length (( %d )) >12\n", cmd_len); } /* PHYDM_DBG(dm, DBG_FW_TRACE,"[FW Msg] Func=((%d)), num=((%d)), ct_0=((%d)), ct_1=((%d)), ct_2=((%d)), ct_3=((%d)), ct_4=((%d))\n", */ /* function, dbg_num, content_0, content_1, content_2, content_3, content_4); */ /*--------------------------------------------*/ #ifdef CONFIG_RA_FW_DBG_CODE if (function == RATE_DECISION) { if (dbg_num == 0) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] RA_CNT=((%d)) Max_device=((%d))--------------------------->\n", content_1, content_2); else if (content_0 == 2) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] Check RA macid= ((%d)), MediaStatus=((%d)), Dis_RA=((%d)), try_bit=((0x%x))\n", content_1, content_2, content_3, content_4); else if (content_0 == 3) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] Check RA total=((%d)), drop=((0x%x)), TXRPT_TRY_bit=((%x)), bNoisy=((%x))\n", content_1, content_2, content_3, content_4); } else if (dbg_num == 1) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] RTY[0,1,2,3]=[ %d , %d , %d , %d ]\n", content_1, content_2, content_3, content_4); else if (content_0 == 2) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] RTY[4]=[ %d ], drop=(( %d )), total=(( %d )), current_rate=((0x %x ))", content_1, content_2, content_3, content_4); phydm_print_rate(dm, (u8)content_4, DBG_FW_TRACE); } else if (content_0 == 3) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] penality_idx=(( %d ))\n", content_1); else if (content_0 == 4) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] RSSI=(( %d )), ra_stage = (( %d ))\n", content_1, content_2); } else if (dbg_num == 3) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] Fast_RA (( DOWN )) total=((%d)), total>>1=((%d)), R4+R3+R2 = ((%d)), RateDownHold = ((%d))\n", content_1, content_2, content_3, content_4); else if (content_0 == 2) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] Fast_RA (( UP )) total_acc=((%d)), total_acc>>1=((%d)), R4+R3+R2 = ((%d)), RateDownHold = ((%d))\n", content_1, content_2, content_3, content_4); else if (content_0 == 3) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] Fast_RA (( UP )) ((rate Down Hold)) RA_CNT=((%d))\n", content_1); else if (content_0 == 4) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] Fast_RA (( UP )) ((tota_accl<5 skip)) RA_CNT=((%d))\n", content_1); else if (content_0 == 8) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] Fast_RA (( Reset Tx Rpt )) RA_CNT=((%d))\n", content_1); } else if (dbg_num == 4) { if (content_0 == 3) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] RER_CNT PCR_ori =(( %d )), ratio_ori =(( %d )), pcr_updown_bitmap =(( 0x%x )), pcr_var_diff =(( %d ))\n", content_1, content_2, content_3, content_4); /**/ } else if (content_0 == 4) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] pcr_shift_value =(( %s%d )), rate_down_threshold =(( %d )), rate_up_threshold =(( %d ))\n", ((content_1) ? "+" : "-"), content_2, content_3, content_4); /**/ } else if (content_0 == 5) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] pcr_mean =(( %d )), PCR_VAR =(( %d )), offset =(( %d )), decision_offset_p =(( %d ))\n", content_1, content_2, content_3, content_4); /**/ } } else if (dbg_num == 5) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] (( UP)) Nsc=(( %d )), N_High=(( %d )), RateUp_Waiting=(( %d )), RateUp_Fail=(( %d ))\n", content_1, content_2, content_3, content_4); else if (content_0 == 2) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] ((DOWN)) Nsc=(( %d )), N_Low=(( %d ))\n", content_1, content_2); else if (content_0 == 3) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] ((HOLD)) Nsc=((%d)), N_High=((%d)), N_Low=((%d)), Reset_CNT=((%d))\n", content_1, content_2, content_3, content_4); } else if (dbg_num == 0x60) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] ((AP RPT)) macid=((%d)), BUPDATE[macid]=((%d))\n", content_1, content_2); else if (content_0 == 4) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] ((AP RPT)) pass=((%d)), rty_num=((%d)), drop=((%d)), total=((%d))\n", content_1, content_2, content_3, content_4); else if (content_0 == 5) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW] ((AP RPT)) PASS=((%d)), RTY_NUM=((%d)), DROP=((%d)), TOTAL=((%d))\n", content_1, content_2, content_3, content_4); } } else if (function == INIT_RA_TABLE) { if (dbg_num == 3) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][INIT_RA_INFO] Ra_init, RA_SKIP_CNT = (( %d ))\n", content_0); } else if (function == RATE_UP) { if (dbg_num == 2) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][RateUp] ((Highest rate->return)), macid=((%d)) Nsc=((%d))\n", content_1, content_2); } else if (dbg_num == 5) { if (content_0 == 0) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][RateUp] ((rate UP)), up_rate_tmp=((0x%x)), rate_idx=((0x%x)), SGI_en=((%d)), SGI=((%d))\n", content_1, content_2, content_3, content_4); else if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][RateUp] ((rate UP)), rate_1=((0x%x)), rate_2=((0x%x)), BW=((%d)), Try_Bit=((%d))\n", content_1, content_2, content_3, content_4); } } else if (function == RATE_DOWN) { if (dbg_num == 5) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][RateDownStep] ((rate Down)), macid=((%d)), rate1=((0x%x)), rate2=((0x%x)), BW=((%d))\n", content_1, content_2, content_3, content_4); } } else if (function == TRY_DONE) { if (dbg_num == 1) { if (content_0 == 1) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][Try Done] ((try succsess )) macid=((%d)), Try_Done_cnt=((%d))\n", content_1, content_2); /**/ } } else if (dbg_num == 2) { if (content_0 == 1) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][Try Done] ((try)) macid=((%d)), Try_Done_cnt=((%d)), rate_2=((%d)), try_succes=((%d))\n", content_1, content_2, content_3, content_4); /**/ } } } else if (function == RA_H2C) { if (dbg_num == 1) { if (content_0 == 0) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][H2C=0x49] fw_trace_en=((%d)), mode =((%d)), macid=((%d))\n", content_1, content_2, content_3); /**/ } } } else if (function == F_RATE_AP_RPT) { if (dbg_num == 1) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][AP RPT] ((1)), SPE_STATIS=((0x%x))---------->\n", content_3); } else if (dbg_num == 2) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][AP RPT] RTY_all=((%d))\n", content_1); } else if (dbg_num == 3) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][AP RPT] MACID1[%d], TOTAL=((%d)), RTY=((%d))\n", content_3, content_1, content_2); } else if (dbg_num == 4) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][AP RPT] MACID2[%d], TOTAL=((%d)), RTY=((%d))\n", content_3, content_1, content_2); } else if (dbg_num == 5) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][AP RPT] MACID1[%d], PASS=((%d)), DROP=((%d))\n", content_3, content_1, content_2); } else if (dbg_num == 6) { if (content_0 == 1) PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][AP RPT] MACID2[%d],, PASS=((%d)), DROP=((%d))\n", content_3, content_1, content_2); } } else if (function == DBC_FW_CLM) { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][CLM][%d, %d] = {%d, %d, %d, %d}\n", dbg_num, content_0, content_1, content_2, content_3, content_4); } else { PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][general][%d, %d, %d] = {%d, %d, %d, %d}\n", function, dbg_num, content_0, content_1, content_2, content_3, content_4); } #else PHYDM_DBG(dm, DBG_FW_TRACE, "[FW][general][%d, %d, %d] = {%d, %d, %d, %d}\n", function, dbg_num, content_0, content_1, content_2, content_3, content_4); #endif /*--------------------------------------------*/ #endif /*#ifdef CONFIG_PHYDM_DEBUG_FUNCTION*/ } void phydm_fw_trace_handler_8051( void *dm_void, u8 *buffer, u8 cmd_len ) { #ifdef CONFIG_PHYDM_DEBUG_FUNCTION struct dm_struct *dm = (struct dm_struct *)dm_void; #if 0 if (cmd_len >= 3) cmd_buf[cmd_len - 1] = '\0'; PHYDM_DBG(dm, DBG_FW_TRACE, "[FW DBG Msg] %s\n", &(cmd_buf[3])); #else int i = 0; u8 extend_c2h_sub_id = 0, extend_c2h_dbg_len = 0, extend_c2h_dbg_seq = 0; u8 fw_debug_trace[128]; u8 *extend_c2h_dbg_content = 0; if (cmd_len > 127) return; extend_c2h_sub_id = buffer[0]; extend_c2h_dbg_len = buffer[1]; extend_c2h_dbg_content = buffer + 2; /*DbgSeq+DbgContent for show HEX*/ #if (DM_ODM_SUPPORT_TYPE == ODM_WIN) RT_DISP(FC2H, C2H_Summary, ("[Extend C2H packet], Extend_c2hSubId=0x%x, extend_c2h_dbg_len=%d\n", extend_c2h_sub_id, extend_c2h_dbg_len)); RT_DISP_DATA(FC2H, C2H_Summary, "[Extend C2H packet], Content Hex:", extend_c2h_dbg_content, cmd_len - 2); #endif go_backfor_aggre_dbg_pkt: i = 0; extend_c2h_dbg_seq = buffer[2]; extend_c2h_dbg_content = buffer + 3; #if (DM_ODM_SUPPORT_TYPE == ODM_WIN) RT_DISP(FC2H, C2H_Summary, ("[RTKFW, SEQ= %d] :", extend_c2h_dbg_seq)); #endif for (; ; i++) { fw_debug_trace[i] = extend_c2h_dbg_content[i]; if (extend_c2h_dbg_content[i + 1] == '\0') { fw_debug_trace[i + 1] = '\0'; PHYDM_DBG(dm, DBG_FW_TRACE, "[FW DBG Msg] %s", &fw_debug_trace[0]); break; } else if (extend_c2h_dbg_content[i] == '\n') { fw_debug_trace[i + 1] = '\0'; PHYDM_DBG(dm, DBG_FW_TRACE, "[FW DBG Msg] %s", &fw_debug_trace[0]); buffer = extend_c2h_dbg_content + i + 3; goto go_backfor_aggre_dbg_pkt; } } #endif #endif /*#ifdef CONFIG_PHYDM_DEBUG_FUNCTION*/ }