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