Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
staging: rtl8723bs: remove unused private debug counters
The driver maintains a private `struct debug_priv` embedded within
`struct dvobj_priv` to track various error counters (e.g., suspend
errors, alloc failures, RX drops).
These counters are incremented in various files but the data is
never read or exposed to userspace.
Remove the unused `debug_priv` structure definition, the instance
in `dvobj_priv`, and all associated increment operations across
the driver to clean up the code.
This also removes the following helper functions which were used
solely to update these counters:
- rtw_reset_rx_info()
- recv_indicatepkts_pkt_loss_cnt()
Signed-off-by: Ethan Tidmore <ethantidmore06@gmail.com>
Reviewed-by: Dan Carpenter <dan.carpenter@linaro.org>
Link: https://patch.msgid.link/20260131212128.25548-1-ethantidmore06@gmail.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
authored by
Ethan Tidmore
and committed by
Greg Kroah-Hartman
7de30d5d
c41ac353
+15
-157
-13
drivers/staging/rtl8723bs/core/rtw_mlme.c
-13
drivers/staging/rtl8723bs/core/rtw_mlme.c
···
819
819
spin_unlock_bh(&scan_queue->lock);
820
820
}
821
821
822
-
static void rtw_reset_rx_info(struct debug_priv *pdbgpriv)
823
-
{
824
-
pdbgpriv->dbg_rx_ampdu_drop_count = 0;
825
-
pdbgpriv->dbg_rx_ampdu_forced_indicate_count = 0;
826
-
pdbgpriv->dbg_rx_ampdu_loss_count = 0;
827
-
pdbgpriv->dbg_rx_dup_mgt_frame_drop_count = 0;
828
-
pdbgpriv->dbg_rx_ampdu_window_shift_cnt = 0;
829
-
}
830
-
831
822
static void find_network(struct adapter *adapter)
832
823
{
833
824
struct wlan_network *pwlan = NULL;
···
839
848
{
840
849
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
841
850
struct wlan_network *tgt_network = &pmlmepriv->cur_network;
842
-
struct dvobj_priv *psdpriv = adapter->dvobj;
843
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
844
851
845
852
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_AP_STATE)) {
846
853
struct sta_info *psta;
···
862
873
863
874
if (lock_scanned_queue)
864
875
adapter->securitypriv.key_mask = 0;
865
-
866
-
rtw_reset_rx_info(pdbgpriv);
867
876
}
868
877
869
878
/* rtw_indicate_connect: the caller has to lock pmlmepriv->lock */
-3
drivers/staging/rtl8723bs/core/rtw_mlme_ext.c
-3
drivers/staging/rtl8723bs/core/rtw_mlme_ext.c
···
438
438
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
439
439
u8 *pframe = precv_frame->u.hdr.rx_data;
440
440
struct sta_info *psta = rtw_get_stainfo(&padapter->stapriv, GetAddr2Ptr(pframe));
441
-
struct dvobj_priv *psdpriv = padapter->dvobj;
442
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
443
441
444
442
if (GetFrameType(pframe) != WIFI_MGT_TYPE)
445
443
return;
···
461
463
if (GetRetry(pframe)) {
462
464
if (precv_frame->u.hdr.attrib.seq_num == psta->RxMgmtFrameSeqNum) {
463
465
/* drop the duplicate management frame */
464
-
pdbgpriv->dbg_rx_dup_mgt_frame_drop_count++;
465
466
return;
466
467
}
467
468
}
+1
-5
drivers/staging/rtl8723bs/core/rtw_pwrctrl.c
+1
-5
drivers/staging/rtl8723bs/core/rtw_pwrctrl.c
···
139
139
void rtw_ps_processor(struct adapter *padapter)
140
140
{
141
141
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
142
-
struct dvobj_priv *psdpriv = padapter->dvobj;
143
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
144
142
u32 ps_deny = 0;
145
143
146
144
mutex_lock(&adapter_to_pwrctl(padapter)->lock);
···
147
149
if (ps_deny != 0)
148
150
goto exit;
149
151
150
-
if (pwrpriv->bInSuspend) {/* system suspend or autosuspend */
151
-
pdbgpriv->dbg_ps_insuspend_cnt++;
152
+
if (pwrpriv->bInSuspend) /* system suspend or autosuspend */
152
153
return;
153
-
}
154
154
155
155
pwrpriv->ps_processing = true;
156
156
+1
-23
drivers/staging/rtl8723bs/core/rtw_recv.c
+1
-23
drivers/staging/rtl8723bs/core/rtw_recv.c
···
1782
1782
1783
1783
static int check_indicate_seq(struct recv_reorder_ctrl *preorder_ctrl, u16 seq_num)
1784
1784
{
1785
-
struct adapter *padapter = preorder_ctrl->padapter;
1786
-
struct dvobj_priv *psdpriv = padapter->dvobj;
1787
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1788
1785
u8 wsize = preorder_ctrl->wsize_b;
1789
1786
u16 wend = (preorder_ctrl->indicate_seq + wsize - 1) % 4096u;
1790
1787
···
1807
1810
preorder_ctrl->indicate_seq = seq_num + 1 - wsize;
1808
1811
else
1809
1812
preorder_ctrl->indicate_seq = 0xFFF - (wsize - (seq_num + 1)) + 1;
1810
-
pdbgpriv->dbg_rx_ampdu_window_shift_cnt++;
1811
1813
}
1812
1814
1813
1815
return true;
···
1857
1861
1858
1862
}
1859
1863
1860
-
static void recv_indicatepkts_pkt_loss_cnt(struct debug_priv *pdbgpriv, u64 prev_seq, u64 current_seq)
1861
-
{
1862
-
if (current_seq < prev_seq)
1863
-
pdbgpriv->dbg_rx_ampdu_loss_count += (4096 + current_seq - prev_seq);
1864
-
else
1865
-
pdbgpriv->dbg_rx_ampdu_loss_count += (current_seq - prev_seq);
1866
-
1867
-
}
1868
-
1869
1864
static int rtw_recv_indicatepkt(struct adapter *padapter, union recv_frame *precv_frame)
1870
1865
{
1871
1866
struct recv_priv *precvpriv;
···
1903
1916
int bPktInBuf = false;
1904
1917
struct recv_priv *precvpriv = &padapter->recvpriv;
1905
1918
struct __queue *ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
1906
-
struct dvobj_priv *psdpriv = padapter->dvobj;
1907
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1908
1919
1909
1920
/* spin_lock_irqsave(&ppending_recvframe_queue->lock, irql); */
1910
1921
/* spin_lock(&ppending_recvframe_queue->lock); */
···
1912
1927
1913
1928
/* Handling some condition for forced indicate case. */
1914
1929
if (bforced == true) {
1915
-
pdbgpriv->dbg_rx_ampdu_forced_indicate_count++;
1916
1930
if (list_empty(phead)) {
1917
1931
/* spin_unlock_irqrestore(&ppending_recvframe_queue->lock, irql); */
1918
1932
/* spin_unlock(&ppending_recvframe_queue->lock); */
···
1921
1937
prframe = (union recv_frame *)plist;
1922
1938
pattrib = &prframe->u.hdr.attrib;
1923
1939
1924
-
recv_indicatepkts_pkt_loss_cnt(pdbgpriv, preorder_ctrl->indicate_seq, pattrib->seq_num);
1925
1940
preorder_ctrl->indicate_seq = pattrib->seq_num;
1926
1941
1927
1942
}
···
1981
1998
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
1982
1999
struct recv_reorder_ctrl *preorder_ctrl = prframe->u.hdr.preorder_ctrl;
1983
2000
struct __queue *ppending_recvframe_queue = &preorder_ctrl->pending_recvframe_queue;
1984
-
struct dvobj_priv *psdpriv = padapter->dvobj;
1985
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1986
2001
1987
2002
if (!pattrib->amsdu) {
1988
2003
/* s1. */
···
2023
2042
spin_lock_bh(&ppending_recvframe_queue->lock);
2024
2043
2025
2044
/* s2. check if winstart_b(indicate_seq) needs to been updated */
2026
-
if (!check_indicate_seq(preorder_ctrl, pattrib->seq_num)) {
2027
-
pdbgpriv->dbg_rx_ampdu_drop_count++;
2045
+
if (!check_indicate_seq(preorder_ctrl, pattrib->seq_num))
2028
2046
goto _err_exit;
2029
-
}
2030
-
2031
2047
2032
2048
/* s3. Insert all packet into Reorder Queue to maintain its ordering. */
2033
2049
if (!enqueue_reorder_recvframe(preorder_ctrl, prframe)) {
-13
drivers/staging/rtl8723bs/hal/hal_com.c
-13
drivers/staging/rtl8723bs/hal/hal_com.c
···
782
782
783
783
void rtw_hal_check_rxfifo_full(struct adapter *adapter)
784
784
{
785
-
struct dvobj_priv *psdpriv = adapter->dvobj;
786
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
787
-
int save_cnt = false;
788
-
789
785
/* switch counter to RX fifo */
790
786
rtw_write8(adapter, REG_RXERR_RPT+3, rtw_read8(adapter, REG_RXERR_RPT+3)|0xf0);
791
-
save_cnt = true;
792
-
/* todo: other chips */
793
-
794
-
if (save_cnt) {
795
-
/* rtw_write8(adapter, REG_RXERR_RPT+3, rtw_read8(adapter, REG_RXERR_RPT+3)|0xa0); */
796
-
pdbgpriv->dbg_rx_fifo_last_overflow = pdbgpriv->dbg_rx_fifo_curr_overflow;
797
-
pdbgpriv->dbg_rx_fifo_curr_overflow = rtw_read16(adapter, REG_RXERR_RPT);
798
-
pdbgpriv->dbg_rx_fifo_diff_overflow = pdbgpriv->dbg_rx_fifo_curr_overflow-pdbgpriv->dbg_rx_fifo_last_overflow;
799
-
}
800
787
}
801
788
802
789
static u32 Array_kfreemap[] = {
-4
drivers/staging/rtl8723bs/hal/rtl8723b_hal_init.c
-4
drivers/staging/rtl8723bs/hal/rtl8723b_hal_init.c
···
304
304
const struct firmware *fw;
305
305
struct device *device = dvobj_to_dev(padapter->dvobj);
306
306
u8 *fwfilepath;
307
-
struct dvobj_priv *psdpriv = padapter->dvobj;
308
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
309
307
u8 tmp_ps;
310
308
311
309
pFirmware = kzalloc(sizeof(struct rt_firmware), GFP_KERNEL);
···
322
324
/* 2. read power_state = 0xA0[1:0] */
323
325
tmp_ps = rtw_read8(padapter, 0xa0);
324
326
tmp_ps &= 0x03;
325
-
if (tmp_ps != 0x01)
326
-
pdbgpriv->dbg_downloadfw_pwr_state_cnt++;
327
327
328
328
fwfilepath = "rtlwifi/rtl8723bs_nic.bin";
329
329
+1
-7
drivers/staging/rtl8723bs/hal/sdio_halinit.c
+1
-7
drivers/staging/rtl8723bs/hal/sdio_halinit.c
···
886
886
887
887
u32 rtl8723bs_hal_deinit(struct adapter *padapter)
888
888
{
889
-
struct dvobj_priv *psdpriv = padapter->dvobj;
890
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
891
-
892
889
if (padapter->hw_init_completed) {
893
890
if (adapter_to_pwrctl(padapter)->bips_processing) {
894
891
if (padapter->netif_up) {
···
918
921
adapter_to_pwrctl(padapter)->pre_ips_type = 0;
919
922
920
923
} else {
921
-
pdbgpriv->dbg_carddisable_cnt++;
922
924
CardDisableRTL8723BSdio(padapter);
923
925
924
926
adapter_to_pwrctl(padapter)->pre_ips_type = 1;
925
927
}
926
928
927
929
} else {
928
-
pdbgpriv->dbg_carddisable_cnt++;
929
930
CardDisableRTL8723BSdio(padapter);
930
931
}
931
-
} else
932
-
pdbgpriv->dbg_deinit_fail_cnt++;
932
+
}
933
933
934
934
return _SUCCESS;
935
935
}
-41
drivers/staging/rtl8723bs/include/drv_types.h
-41
drivers/staging/rtl8723bs/include/drv_types.h
···
173
173
#define GET_IFACE_NUMS(padapter) (((struct adapter *)padapter)->dvobj->iface_nums)
174
174
#define GET_ADAPTER(padapter, iface_id) (((struct adapter *)padapter)->dvobj->padapters[iface_id])
175
175
176
-
struct debug_priv {
177
-
u32 dbg_sdio_free_irq_error_cnt;
178
-
u32 dbg_sdio_alloc_irq_error_cnt;
179
-
u32 dbg_sdio_free_irq_cnt;
180
-
u32 dbg_sdio_alloc_irq_cnt;
181
-
u32 dbg_sdio_deinit_error_cnt;
182
-
u32 dbg_sdio_init_error_cnt;
183
-
u32 dbg_suspend_error_cnt;
184
-
u32 dbg_suspend_cnt;
185
-
u32 dbg_resume_cnt;
186
-
u32 dbg_resume_error_cnt;
187
-
u32 dbg_deinit_fail_cnt;
188
-
u32 dbg_carddisable_cnt;
189
-
u32 dbg_carddisable_error_cnt;
190
-
u32 dbg_ps_insuspend_cnt;
191
-
u32 dbg_dev_unload_inIPS_cnt;
192
-
u32 dbg_wow_leave_ps_fail_cnt;
193
-
u32 dbg_scan_pwr_state_cnt;
194
-
u32 dbg_downloadfw_pwr_state_cnt;
195
-
u32 dbg_fw_read_ps_state_fail_cnt;
196
-
u32 dbg_leave_ips_fail_cnt;
197
-
u32 dbg_leave_lps_fail_cnt;
198
-
u32 dbg_h2c_leave32k_fail_cnt;
199
-
u32 dbg_diswow_dload_fw_fail_cnt;
200
-
u32 dbg_enwow_dload_fw_fail_cnt;
201
-
u32 dbg_ips_drvopen_fail_cnt;
202
-
u32 dbg_poll_fail_cnt;
203
-
u32 dbg_rpwm_toggle_cnt;
204
-
u32 dbg_rpwm_timeout_fail_cnt;
205
-
u64 dbg_rx_fifo_last_overflow;
206
-
u64 dbg_rx_fifo_curr_overflow;
207
-
u64 dbg_rx_fifo_diff_overflow;
208
-
u64 dbg_rx_ampdu_drop_count;
209
-
u64 dbg_rx_ampdu_forced_indicate_count;
210
-
u64 dbg_rx_ampdu_loss_count;
211
-
u64 dbg_rx_dup_mgt_frame_drop_count;
212
-
u64 dbg_rx_ampdu_window_shift_cnt;
213
-
};
214
-
215
176
struct rtw_traffic_statistics {
216
177
/* tx statistics */
217
178
u64 tx_bytes;
···
207
246
struct adapter *if1; /* PRIMARY_ADAPTER */
208
247
209
248
s32 processing_dev_remove;
210
-
211
-
struct debug_priv drv_dbg;
212
249
213
250
/* for local/global synchronization */
214
251
/* */
+2
-13
drivers/staging/rtl8723bs/os_dep/os_intfs.c
+2
-13
drivers/staging/rtl8723bs/os_dep/os_intfs.c
···
973
973
void rtw_dev_unload(struct adapter *padapter)
974
974
{
975
975
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
976
-
struct dvobj_priv *pobjpriv = padapter->dvobj;
977
-
struct debug_priv *pdbgpriv = &pobjpriv->drv_dbg;
978
976
struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
979
977
u8 cnt = 0;
980
978
···
1001
1003
/* check HW status and SW state */
1002
1004
netdev_dbg(padapter->pnetdev,
1003
1005
"%s: driver in IPS-FWLPS\n", __func__);
1004
-
pdbgpriv->dbg_dev_unload_inIPS_cnt++;
1005
1006
LeaveAllPowerSaveMode(padapter);
1006
1007
} else {
1007
1008
netdev_dbg(padapter->pnetdev,
···
1083
1086
void rtw_suspend_common(struct adapter *padapter)
1084
1087
{
1085
1088
struct dvobj_priv *psdpriv = padapter->dvobj;
1086
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1087
1089
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
1088
1090
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1089
1091
1090
1092
unsigned long start_time = jiffies;
1091
1093
1092
1094
netdev_dbg(padapter->pnetdev, " suspend start\n");
1093
-
pdbgpriv->dbg_suspend_cnt++;
1094
1095
1095
1096
pwrpriv->bInSuspend = true;
1096
1097
1097
1098
while (pwrpriv->bips_processing)
1098
1099
msleep(1);
1099
1100
1100
-
if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved)) {
1101
-
pdbgpriv->dbg_suspend_error_cnt++;
1101
+
if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved))
1102
1102
return;
1103
-
}
1103
+
1104
1104
rtw_ps_deny(padapter, PS_DENY_SUSPEND);
1105
1105
1106
1106
rtw_cancel_all_timer(padapter);
···
1125
1131
struct net_device *pnetdev;
1126
1132
struct pwrctrl_priv *pwrpriv;
1127
1133
struct mlme_priv *pmlmepriv;
1128
-
struct dvobj_priv *psdpriv;
1129
-
struct debug_priv *pdbgpriv;
1130
1134
1131
1135
int ret = _SUCCESS;
1132
1136
···
1136
1144
pnetdev = padapter->pnetdev;
1137
1145
pwrpriv = adapter_to_pwrctl(padapter);
1138
1146
pmlmepriv = &padapter->mlmepriv;
1139
-
psdpriv = padapter->dvobj;
1140
-
pdbgpriv = &psdpriv->drv_dbg;
1141
1147
/* interface init */
1142
1148
/* if (sdio_init(adapter_to_dvobj(padapter)) != _SUCCESS) */
1143
1149
if ((padapter->intf_init) && (padapter->intf_init(adapter_to_dvobj(padapter)) != _SUCCESS)) {
···
1154
1164
1155
1165
if (pm_netdev_open(pnetdev, true) != 0) {
1156
1166
ret = -1;
1157
-
pdbgpriv->dbg_resume_error_cnt++;
1158
1167
goto exit;
1159
1168
}
1160
1169
+10
-35
drivers/staging/rtl8723bs/os_dep/sdio_intf.c
+10
-35
drivers/staging/rtl8723bs/os_dep/sdio_intf.c
···
70
70
sdio_claim_host(func);
71
71
72
72
err = sdio_claim_irq(func, &sd_sync_int_hdl);
73
-
if (err) {
74
-
dvobj->drv_dbg.dbg_sdio_alloc_irq_error_cnt++;
73
+
if (err)
75
74
netdev_crit(dvobj->if1->pnetdev, "%s: sdio_claim_irq FAIL(%d)!\n", __func__, err);
76
-
} else {
77
-
dvobj->drv_dbg.dbg_sdio_alloc_irq_cnt++;
75
+
else
78
76
dvobj->irq_alloc = 1;
79
-
}
80
77
81
78
sdio_release_host(func);
82
79
···
94
97
sdio_claim_host(func);
95
98
err = sdio_release_irq(func);
96
99
if (err) {
97
-
dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
98
100
netdev_err(dvobj->if1->pnetdev,
99
101
"%s: sdio_release_irq FAIL(%d)!\n",
100
102
__func__, err);
101
-
} else
102
-
dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
103
+
}
103
104
sdio_release_host(func);
104
105
}
105
106
dvobj->irq_alloc = 0;
···
117
122
sdio_claim_host(func);
118
123
119
124
err = sdio_enable_func(func);
120
-
if (err) {
121
-
dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
125
+
if (err)
122
126
goto release;
123
-
}
124
127
125
128
err = sdio_set_block_size(func, 512);
126
-
if (err) {
127
-
dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
129
+
if (err)
128
130
goto release;
129
-
}
131
+
130
132
psdio_data->block_transfer_len = 512;
131
133
psdio_data->tx_block_mode = 1;
132
134
psdio_data->rx_block_mode = 1;
···
139
147
static void sdio_deinit(struct dvobj_priv *dvobj)
140
148
{
141
149
struct sdio_func *func;
142
-
int err;
143
150
144
151
func = dvobj->intf_data.func;
145
152
146
153
if (func) {
147
154
sdio_claim_host(func);
148
-
err = sdio_disable_func(func);
149
-
if (err)
150
-
dvobj->drv_dbg.dbg_sdio_deinit_error_cnt++;
155
+
sdio_disable_func(func);
151
156
152
157
if (dvobj->irq_alloc) {
153
-
err = sdio_release_irq(func);
154
-
if (err)
155
-
dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
156
-
else
157
-
dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
158
+
sdio_release_irq(func);
158
159
}
159
160
160
161
sdio_release_host(func);
···
419
434
struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
420
435
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
421
436
struct adapter *padapter = psdpriv->if1;
422
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
423
437
424
438
if (padapter->bDriverStopped)
425
439
return 0;
426
440
427
-
if (pwrpriv->bInSuspend) {
428
-
pdbgpriv->dbg_suspend_error_cnt++;
441
+
if (pwrpriv->bInSuspend)
429
442
return 0;
430
-
}
431
443
432
444
rtw_suspend_common(padapter);
433
445
···
434
452
static int rtw_resume_process(struct adapter *padapter)
435
453
{
436
454
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
437
-
struct dvobj_priv *psdpriv = padapter->dvobj;
438
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
439
455
440
-
if (!pwrpriv->bInSuspend) {
441
-
pdbgpriv->dbg_resume_error_cnt++;
456
+
if (!pwrpriv->bInSuspend)
442
457
return -1;
443
-
}
444
458
445
459
return rtw_resume_common(padapter);
446
460
}
···
448
470
struct adapter *padapter = psdpriv->if1;
449
471
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
450
472
int ret = 0;
451
-
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
452
-
453
-
pdbgpriv->dbg_resume_cnt++;
454
473
455
474
ret = rtw_resume_process(padapter);
456
475