1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2019 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15 #define _RTW_DEBUG_C_
16
17 #include <drv_types.h>
18 #include "_hal_rate.h"
19
20 #ifdef CONFIG_RTW_DEBUG
21 const char *rtw_log_level_str[] = {
22 "_DRV_NONE_ = 0",
23 "_DRV_ALWAYS_ = 1",
24 "_DRV_ERR_ = 2",
25 "_DRV_WARNING_ = 3",
26 "_DRV_INFO_ = 4",
27 "_DRV_DEBUG_ = 5",
28 "_DRV_MAX_ = 6",
29 };
30 #endif
31
32 #ifdef CONFIG_DEBUG_RTL871X
33 u64 GlobalDebugComponents = 0;
34 #endif /* CONFIG_DEBUG_RTL871X */
35
36 #include <rtw_version.h>
37
38 #ifdef CONFIG_TDLS
39 #define TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE 41
40 #endif
41
dump_drv_version(void * sel)42 void dump_drv_version(void *sel)
43 {
44 RTW_PRINT_SEL(sel, "%s %s\n", DRV_NAME, DRIVERVERSION);
45 RTW_PRINT_SEL(sel, "build time: %s %s\n", __DATE__, __TIME__);
46 }
47
dump_drv_cfg(void * sel)48 void dump_drv_cfg(void *sel)
49 {
50 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
51 char *kernel_version = utsname()->release;
52
53 RTW_PRINT_SEL(sel, "\nKernel Version: %s\n", kernel_version);
54 #endif
55
56 #ifdef CONFIG_RTW_ANDROID
57 RTW_PRINT_SEL(sel, "Android Driver: %d\n", CONFIG_RTW_ANDROID);
58 #else
59 RTW_PRINT_SEL(sel, "Linux Driver: \n");
60 #endif /* CONFIG_RTW_ANDROID */
61
62 RTW_PRINT_SEL(sel, "Driver Version: %s\n", DRIVERVERSION);
63 RTW_PRINT_SEL(sel, "------------------------------------------------\n");
64
65 #ifdef CONFIG_IOCTL_CFG80211
66 RTW_PRINT_SEL(sel, "CFG80211\n");
67 #ifdef RTW_USE_CFG80211_STA_EVENT
68 RTW_PRINT_SEL(sel, "RTW_USE_CFG80211_STA_EVENT\n");
69 #endif
70 #ifdef CONFIG_RADIO_WORK
71 RTW_PRINT_SEL(sel, "CONFIG_RADIO_WORK\n");
72 #endif
73 #else
74 RTW_PRINT_SEL(sel, "WEXT\n");
75 #endif
76
77 RTW_PRINT_SEL(sel, "DBG:%d\n", DBG);
78 #ifdef CONFIG_RTW_DEBUG
79 RTW_PRINT_SEL(sel, "CONFIG_RTW_DEBUG\n");
80 #endif
81
82 #ifdef CONFIG_CONCURRENT_MODE
83 RTW_PRINT_SEL(sel, "CONFIG_CONCURRENT_MODE\n");
84
85 #ifdef CONFIG_RTW_STATIC_NDEV_NUM
86 RTW_PRINT_SEL(sel, "CONFIG_RTW_STATIC_NDEV_NUM = %d\n", CONFIG_RTW_STATIC_NDEV_NUM);
87 #endif
88 #if (RTW_P2P_GROUP_INTERFACE == 1)
89 RTW_PRINT_SEL(sel, "RTW_P2P_GROUP_INTERFACE\n");
90 #endif
91 #ifdef RTW_DEDICATED_P2P_DEVICE
92 RTW_PRINT_SEL(sel, "RTW_DEDICATED_P2P_DEVICE\n");
93 #endif
94 #if defined(CONFIG_P2P) && defined(CONFIG_SEL_P2P_IFACE)
95 RTW_PRINT_SEL(sel, "CONFIG_SEL_P2P_IFACE = %d\n", CONFIG_SEL_P2P_IFACE);
96 #endif
97 #endif
98
99 #ifdef CONFIG_POWER_SAVING
100 RTW_PRINT_SEL(sel, "CONFIG_POWER_SAVING\n");
101 #ifdef CONFIG_IPS
102 RTW_PRINT_SEL(sel, "CONFIG_IPS\n");
103 #endif
104 #ifdef CONFIG_LPS
105 RTW_PRINT_SEL(sel, "CONFIG_LPS\n");
106 #ifdef CONFIG_LPS_LCLK
107 RTW_PRINT_SEL(sel, "CONFIG_LPS_LCLK\n");
108 #ifdef CONFIG_DETECT_CPWM_BY_POLLING
109 RTW_PRINT_SEL(sel, "CONFIG_DETECT_CPWM_BY_POLLING\n");
110 #endif
111 #endif /*CONFIG_LPS_LCLK*/
112 #ifdef CONFIG_LPS_CHK_BY_TP
113 RTW_PRINT_SEL(sel, "CONFIG_LPS_CHK_BY_TP\n");
114 #endif
115 #ifdef CONFIG_LPS_ACK
116 RTW_PRINT_SEL(sel, "CONFIG_LPS_ACK\n");
117 #endif
118 #endif/*CONFIG_LPS*/
119 #endif
120
121 #ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
122 RTW_PRINT_SEL(sel, "LOAD_PHY_PARA_FROM_FILE - REALTEK_CONFIG_PATH=%s\n", REALTEK_CONFIG_PATH);
123 #if defined(CONFIG_MULTIDRV) || defined(REALTEK_CONFIG_PATH_WITH_IC_NAME_FOLDER)
124 RTW_PRINT_SEL(sel, "LOAD_PHY_PARA_FROM_FILE - REALTEK_CONFIG_PATH_WITH_IC_NAME_FOLDER\n");
125 #endif
126
127 /* configurations about TX power */
128 #ifdef CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY
129 RTW_PRINT_SEL(sel, "CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY\n");
130 #endif
131 #ifdef CONFIG_CALIBRATE_TX_POWER_TO_MAX
132 RTW_PRINT_SEL(sel, "CONFIG_CALIBRATE_TX_POWER_TO_MAX\n");
133 #endif
134 #endif
135 RTW_PRINT_SEL(sel, "RTW_DEF_MODULE_REGULATORY_CERT=0x%02x\n", RTW_DEF_MODULE_REGULATORY_CERT);
136
137 RTW_PRINT_SEL(sel, "CONFIG_TXPWR_BY_RATE=%d\n", CONFIG_TXPWR_BY_RATE);
138 RTW_PRINT_SEL(sel, "CONFIG_TXPWR_BY_RATE_EN=%d\n", CONFIG_TXPWR_BY_RATE_EN);
139 RTW_PRINT_SEL(sel, "CONFIG_TXPWR_LIMIT=%d\n", CONFIG_TXPWR_LIMIT);
140 RTW_PRINT_SEL(sel, "CONFIG_TXPWR_LIMIT_EN=%d\n", CONFIG_TXPWR_LIMIT_EN);
141
142
143 #ifdef CONFIG_DISABLE_ODM
144 RTW_PRINT_SEL(sel, "CONFIG_DISABLE_ODM\n");
145 #endif
146
147 #ifdef CONFIG_MINIMAL_MEMORY_USAGE
148 RTW_PRINT_SEL(sel, "CONFIG_MINIMAL_MEMORY_USAGE\n");
149 #endif
150
151 RTW_PRINT_SEL(sel, "CONFIG_RTW_ADAPTIVITY_EN = %d\n", CONFIG_RTW_ADAPTIVITY_EN);
152 RTW_PRINT_SEL(sel, "CONFIG_RTW_ADAPTIVITY_MODE = %d\n", CONFIG_RTW_ADAPTIVITY_MODE);
153
154 #ifdef CONFIG_WOWLAN
155 RTW_PRINT_SEL(sel, "CONFIG_WOWLAN - ");
156
157 #ifdef CONFIG_GPIO_WAKEUP
158 RTW_PRINT_SEL(sel, "CONFIG_GPIO_WAKEUP - WAKEUP_GPIO_IDX:%d\n", WAKEUP_GPIO_IDX);
159 #endif
160 #endif
161
162 #ifdef CONFIG_TDLS
163 RTW_PRINT_SEL(sel, "CONFIG_TDLS\n");
164 #endif
165
166 #ifdef CONFIG_RTW_80211R
167 RTW_PRINT_SEL(sel, "CONFIG_RTW_80211R\n");
168 #endif
169
170 #ifdef CONFIG_RTW_NETIF_SG
171 RTW_PRINT_SEL(sel, "CONFIG_RTW_NETIF_SG\n");
172 #endif
173
174 #ifdef CONFIG_RTW_WIFI_HAL
175 RTW_PRINT_SEL(sel, "CONFIG_RTW_WIFI_HAL\n");
176 #endif
177
178 #ifdef RTW_BUSY_DENY_SCAN
179 RTW_PRINT_SEL(sel, "RTW_BUSY_DENY_SCAN\n");
180 RTW_PRINT_SEL(sel, "BUSY_TRAFFIC_SCAN_DENY_PERIOD = %u ms\n", \
181 BUSY_TRAFFIC_SCAN_DENY_PERIOD);
182 #endif
183
184
185 #ifdef CONFIG_USB_HCI
186 #ifdef CONFIG_SUPPORT_USB_INT
187 RTW_PRINT_SEL(sel, "CONFIG_SUPPORT_USB_INT\n");
188 #endif
189 #ifdef CONFIG_USB_INTERRUPT_IN_PIPE
190 RTW_PRINT_SEL(sel, "CONFIG_USB_INTERRUPT_IN_PIPE\n");
191 #endif
192 #ifdef CONFIG_USB_TX_AGGREGATION
193 RTW_PRINT_SEL(sel, "CONFIG_USB_TX_AGGREGATION\n");
194 #endif
195 #ifdef CONFIG_USB_RX_AGGREGATION
196 RTW_PRINT_SEL(sel, "CONFIG_USB_RX_AGGREGATION\n");
197 #endif
198 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX
199 RTW_PRINT_SEL(sel, "CONFIG_USE_USB_BUFFER_ALLOC_TX\n");
200 #endif
201 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
202 RTW_PRINT_SEL(sel, "CONFIG_USE_USB_BUFFER_ALLOC_RX\n");
203 #endif
204
205 #ifdef CONFIG_FIX_NR_BULKIN_BUFFER
206 RTW_PRINT_SEL(sel, "CONFIG_FIX_NR_BULKIN_BUFFER\n");
207 #endif
208 #endif /*CONFIG_USB_HCI*/
209
210 #ifdef CONFIG_SDIO_HCI
211 #ifdef CONFIG_TX_AGGREGATION
212 RTW_PRINT_SEL(sel, "CONFIG_TX_AGGREGATION\n");
213 #endif
214 #ifdef CONFIG_RX_AGGREGATION
215 RTW_PRINT_SEL(sel, "CONFIG_RX_AGGREGATION\n");
216 #endif
217 #ifdef RTW_XMIT_THREAD_HIGH_PRIORITY
218 RTW_PRINT_SEL(sel, "RTW_XMIT_THREAD_HIGH_PRIORITY\n");
219 #endif
220 #ifdef RTW_XMIT_THREAD_HIGH_PRIORITY_AGG
221 RTW_PRINT_SEL(sel, "RTW_XMIT_THREAD_HIGH_PRIORITY_AGG\n");
222 #endif
223
224 #ifdef DBG_SDIO
225 RTW_PRINT_SEL(sel, "DBG_SDIO = %d\n", DBG_SDIO);
226 #endif
227 #endif /*CONFIG_SDIO_HCI*/
228
229 #ifdef CONFIG_PCI_HCI
230 #ifdef CONFIG_DMA_USE_COHERENT_MEM
231 RTW_PRINT_SEL(sel, "CONFIG_DMA_USE_COHERENT_MEM = y\n");
232 #ifdef CONFIG_DMA_TX_USE_COHERENT_MEM
233 RTW_PRINT_SEL(sel, "CONFIG_DMA_TX_USE_COHERENT_MEM = y\n");
234 #endif
235 #ifdef CONFIG_DMA_RX_USE_COHERENT_MEM
236 RTW_PRINT_SEL(sel, "CONFIG_DMA_RX_USE_COHERENT_MEM = y\n");
237 #endif
238 #else
239 RTW_PRINT_SEL(sel, "CONFIG_DMA_USE_COHERENT_MEM = n\n");
240 #endif
241 #endif
242
243 RTW_PRINT_SEL(sel, "CONFIG_IFACE_NUMBER = %d\n", CONFIG_IFACE_NUMBER);
244
245
246 #ifdef CONFIG_PCI_TX_POLLING
247 RTW_PRINT_SEL(sel, "CONFIG_PCI_TX_POLLING\n");
248 #endif
249 RTW_PRINT_SEL(sel, "CONFIG_RTW_UP_MAPPING_RULE = %s\n", (CONFIG_RTW_UP_MAPPING_RULE == 1) ? "dscp" : "tos");
250 #ifdef CONFIG_MSG_NUM
251 RTW_PRINT_SEL(sel, "CONFIG_MSG_NUM = %d\n", CONFIG_MSG_NUM);
252 #endif
253 #ifdef CONFIG_DIS_DYN_RXBUF
254 RTW_PRINT_SEL(sel, "CONFIG_DIS_DYN_RXBUF\n");
255 #endif
256 #ifdef CONFIG_DYNAMIC_RX_BUF
257 RTW_PRINT_SEL(sel, "CONFIG_DYNAMIC_RX_BUF\n");
258 #endif
259 #ifdef CONFIG_TX_SKB_ORPHAN
260 RTW_PRINT_SEL(sel, "CONFIG_TX_SKB_ORPHAN\n");
261 #endif
262 #ifdef RTW_WKARD_98D_RXTAG
263 RTW_PRINT_SEL(sel, "RTW_WKARD_98D_RXTAG\n");
264 #endif
265 #ifdef CONFIG_RXBUF_NUM_1024
266 RTW_PRINT_SEL(sel, "CONFIG_RXBUF_NUM_1024\n");
267 #endif
268 #ifdef CONFIG_PHL_CPU_BALANCE
269 RTW_PRINT_SEL(sel, "CONFIG_PHL_CPU_BALANCE\n");
270 #ifdef CONFIG_PHL_CPU_BALANCE_TX
271 RTW_PRINT_SEL(sel, "CONFIG_PHL_CPU_BALANCE_TX\n");
272 #endif
273 #ifdef CONFIG_PHL_CPU_BALANCE_RX
274 RTW_PRINT_SEL(sel, "CONFIG_PHL_CPU_BALANCE_RX\n");
275 #endif
276 #endif
277 #ifdef USE_AML_PCIE_TEE_MEM
278 RTW_PRINT_SEL(sel, "USE_AML_PCIE_TEE_MEM\n");
279 #endif
280
281 /*GEORGIA_TODO_TRX - need get trx buff accroding to IC spec*/
282 RTW_PRINT_SEL(sel, "\n=== XMIT-INFO ===\n");
283 RTW_PRINT_SEL(sel, "NR_XMITFRAME = %d\n", NR_XMITFRAME);
284 /*
285 RTW_PRINT_SEL(sel, "NR_XMITBUFF = %d\n", NR_XMITBUFF);
286 RTW_PRINT_SEL(sel, "MAX_XMITBUF_SZ = %d\n", MAX_XMITBUF_SZ);
287 RTW_PRINT_SEL(sel, "NR_XMIT_EXTBUFF = %d\n", NR_XMIT_EXTBUFF);
288 RTW_PRINT_SEL(sel, "MAX_XMIT_EXTBUF_SZ = %d\n", MAX_XMIT_EXTBUF_SZ);
289 RTW_PRINT_SEL(sel, "MAX_CMDBUF_SZ = %d\n", MAX_CMDBUF_SZ);
290 */
291
292 RTW_PRINT_SEL(sel, "\n=== RECV-INFO ===\n");
293 RTW_PRINT_SEL(sel, "NR_RECVFRAME = %d\n", NR_RECVFRAME);
294 /*
295 RTW_PRINT_SEL(sel, "NR_RECVBUFF = %d\n", NR_RECVBUFF);
296 RTW_PRINT_SEL(sel, "MAX_RECVBUF_SZ = %d\n", MAX_RECVBUF_SZ);
297 */
298
299 }
300
dump_log_level(void * sel)301 void dump_log_level(void *sel)
302 {
303 #ifdef CONFIG_RTW_DEBUG
304 int i;
305
306 RTW_PRINT_SEL(sel, "drv_log_level:%d\n", rtw_drv_log_level);
307 for (i = 0; i <= _DRV_MAX_; i++) {
308 if (rtw_log_level_str[i])
309 RTW_PRINT_SEL(sel, "%c %s = %d\n",
310 (rtw_drv_log_level == i) ? '+' : ' ', rtw_log_level_str[i], i);
311 }
312 #else
313 RTW_PRINT_SEL(sel, "CONFIG_RTW_DEBUG is disabled\n");
314 #endif
315 }
316
317
rtw_sink_rtp_seq_dbg(_adapter * adapter,u8 * ehdr_pos)318 void rtw_sink_rtp_seq_dbg(_adapter *adapter, u8 *ehdr_pos)
319 {
320 struct recv_info *precvinfo = &(adapter->recvinfo);
321 if (precvinfo->sink_udpport > 0) {
322 if (*((u16 *)(ehdr_pos + 0x24)) == cpu_to_be16(precvinfo->sink_udpport)) {
323 precvinfo->pre_rtp_rxseq = precvinfo->cur_rtp_rxseq;
324 precvinfo->cur_rtp_rxseq = be16_to_cpu(*((u16 *)(ehdr_pos + 0x2C)));
325 if (precvinfo->pre_rtp_rxseq + 1 != precvinfo->cur_rtp_rxseq) {
326 if(precvinfo->pre_rtp_rxseq == 65535 ) {
327 if( precvinfo->cur_rtp_rxseq != 0) {
328 RTW_INFO("%s : RTP Seq num from %d to %d\n", __FUNCTION__, precvinfo->pre_rtp_rxseq, precvinfo->cur_rtp_rxseq);
329 }
330 } else {
331 RTW_INFO("%s : RTP Seq num from %d to %d\n", __FUNCTION__, precvinfo->pre_rtp_rxseq, precvinfo->cur_rtp_rxseq);
332 }
333 }
334 }
335 }
336 }
337
sta_rx_reorder_ctl_dump(void * sel,struct sta_info * sta)338 void sta_rx_reorder_ctl_dump(void *sel, struct sta_info *sta)
339 {
340 struct recv_reorder_ctrl *reorder_ctl;
341 int i;
342
343 for (i = 0; i < 16; i++) {
344 reorder_ctl = &sta->recvreorder_ctrl[i];
345 if (reorder_ctl->ampdu_size != RX_AMPDU_SIZE_INVALID || reorder_ctl->indicate_seq != 0xFFFF) {
346 RTW_PRINT_SEL(sel, "tid=%d, enable=%d, ampdu_size=%u, indicate_seq=%u\n"
347 , i, reorder_ctl->enable, reorder_ctl->ampdu_size, reorder_ctl->indicate_seq
348 );
349 }
350 }
351 }
352
dump_tx_rate_bmp(void * sel,struct dvobj_priv * dvobj)353 void dump_tx_rate_bmp(void *sel, struct dvobj_priv *dvobj)
354 {
355 _adapter *adapter = dvobj_get_primary_adapter(dvobj);
356 struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
357 u8 bw;
358
359 RTW_PRINT_SEL(sel, "%-6s", "bw");
360 if (rtw_hw_chk_proto_cap(dvobj, PROTO_CAP_11AC))
361 _RTW_PRINT_SEL(sel, " %-15s", "vht");
362
363 _RTW_PRINT_SEL(sel, " %-11s %-4s %-3s\n", "ht", "ofdm", "cck");
364
365 for (bw = CHANNEL_WIDTH_20; bw <= CHANNEL_WIDTH_160; bw++) {
366 if (!rtw_hw_is_bw_support(adapter_to_dvobj(adapter), bw))
367 continue;
368
369 RTW_PRINT_SEL(sel, "%6s", ch_width_str(bw));
370 if (rtw_hw_chk_proto_cap(dvobj, PROTO_CAP_11AC)) {
371 _RTW_PRINT_SEL(sel, " %03x %03x %03x %03x"
372 , RATE_BMP_GET_VHT_4SS(rfctl->rate_bmp_vht_by_bw[bw])
373 , RATE_BMP_GET_VHT_3SS(rfctl->rate_bmp_vht_by_bw[bw])
374 , RATE_BMP_GET_VHT_2SS(rfctl->rate_bmp_vht_by_bw[bw])
375 , RATE_BMP_GET_VHT_1SS(rfctl->rate_bmp_vht_by_bw[bw])
376 );
377 }
378
379 _RTW_PRINT_SEL(sel, " %02x %02x %02x %02x"
380 , bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_4SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
381 , bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_3SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
382 , bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_2SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
383 , bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_1SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
384 );
385
386 _RTW_PRINT_SEL(sel, " %03x %01x\n"
387 , bw <= CHANNEL_WIDTH_20 ? RATE_BMP_GET_OFDM(rfctl->rate_bmp_cck_ofdm) : 0
388 , bw <= CHANNEL_WIDTH_20 ? RATE_BMP_GET_CCK(rfctl->rate_bmp_cck_ofdm) : 0
389 );
390 }
391 }
392
dump_adapters_status(void * sel,struct dvobj_priv * dvobj)393 void dump_adapters_status(void *sel, struct dvobj_priv *dvobj)
394 {
395 struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
396 int i;
397 _adapter *iface;
398 u8 u_ch, u_bw, u_offset;
399 dump_mi_status(sel, dvobj);
400
401 RTW_PRINT_SEL(sel, "dev status:%s%s\n\n"
402 , dev_is_surprise_removed(dvobj) ? " SR" : ""
403 , dev_is_drv_stopped(dvobj) ? " DS" : ""
404 );
405
406 #ifdef CONFIG_P2P
407 #define P2P_INFO_TITLE_FMT " %-3s %-4s"
408 #define P2P_INFO_TITLE_ARG , "lch", "p2ps"
409 #ifdef CONFIG_IOCTL_CFG80211
410 #define P2P_INFO_VALUE_FMT " %3u %c"
411 #define P2P_INFO_VALUE_ARG , iface->wdinfo.listen_channel, iface->wdev_data.p2p_enabled ? 'e' : ' '
412 #else
413 #define P2P_INFO_VALUE_FMT " %3u"
414 #define P2P_INFO_VALUE_ARG , iface->wdinfo.listen_channel
415 #endif
416 #define P2P_INFO_DASH "---------"
417 #else
418 #define P2P_INFO_TITLE_FMT ""
419 #define P2P_INFO_TITLE_ARG
420 #define P2P_INFO_VALUE_FMT ""
421 #define P2P_INFO_VALUE_ARG
422 #define P2P_INFO_DASH
423 #endif
424
425 #define INFO_FMT ""
426 #define INFO_ARG
427 #define INFO_CNT_FMT ""
428 #define INFO_CNT_ARG
429
430
431 RTW_PRINT_SEL(sel, "%-2s %-15s %c %-3s %-17s %-4s %-7s %-5s"
432 P2P_INFO_TITLE_FMT
433 " %s"INFO_FMT"\n"
434 , "id", "ifname", ' ', "netif_up", "macaddr", "port", "ch", "class"
435 P2P_INFO_TITLE_ARG
436 , "status"INFO_ARG);
437
438 RTW_PRINT_SEL(sel, "---------------------------------------------------------------"
439 P2P_INFO_DASH
440 "-------\n");
441
442 for (i = 0; i < dvobj->iface_nums; i++) {
443 iface = dvobj->padapters[i];
444 if (iface) {
445 RTW_PRINT_SEL(sel, "%2d %-15s %c %3u "MAC_FMT" %4hhu %3u,%u,%u %5u"
446 P2P_INFO_VALUE_FMT
447 " "MLME_STATE_FMT" " INFO_CNT_FMT"\n"
448 , i, iface->registered ? ADPT_ARG(iface) : NULL
449 , iface->registered ? 'R' : ' '
450 , iface->netif_up
451 , MAC_ARG(adapter_mac_addr(iface))
452 , rtw_hal_get_port(iface)
453 , iface->mlmeextpriv.chandef.chan
454 , iface->mlmeextpriv.chandef.bw
455 , iface->mlmeextpriv.chandef.offset
456 , rtw_get_op_class_by_chbw(iface->mlmeextpriv.chandef.chan
457 , iface->mlmeextpriv.chandef.bw
458 , iface->mlmeextpriv.chandef.offset)
459 P2P_INFO_VALUE_ARG
460 , MLME_STATE_ARG(iface)
461 INFO_CNT_ARG
462 );
463 }
464 }
465
466 RTW_PRINT_SEL(sel, "---------------------------------------------------------------"
467 P2P_INFO_DASH
468 "-------\n");
469
470 if (rtw_mi_get_ch_setting_union(dvobj_get_primary_adapter(dvobj), &u_ch, &u_bw, &u_offset))
471 RTW_PRINT_SEL(sel, "%55s %3u,%u,%u %5u\n"
472 , "union:"
473 , u_ch, u_bw, u_offset, rtw_get_op_class_by_chbw(u_ch, u_bw, u_offset));
474 #if 0
475 RTW_PRINT_SEL(sel, "%55s %3u,%u,%u offch_state:%d\n"
476 , "oper:"
477 , dvobj->chandef.chan
478 , dvobj->chandef.bw
479 , dvobj->chandef.offset
480 , rfctl->offch_state
481 );
482 #endif
483
484 #ifdef CONFIG_DFS_MASTER
485 if (rfctl->radar_detect_ch != 0) {
486 RTW_PRINT_SEL(sel, "%55s %3u,%u,%u"
487 , "radar_detect:"
488 , rfctl->radar_detect_ch
489 , rfctl->radar_detect_bw
490 , rfctl->radar_detect_offset
491 );
492
493 if (rfctl->radar_detect_by_others)
494 _RTW_PRINT_SEL(sel, ", by AP of STA link");
495 else {
496 u32 non_ocp_ms;
497 u32 cac_ms;
498 u8 dfs_domain = rtw_rfctl_get_dfs_domain(rfctl);
499
500 _RTW_PRINT_SEL(sel, ", domain:%s(%u)", rtw_dfs_regd_str(dfs_domain), dfs_domain);
501
502 rtw_get_ch_waiting_ms(rfctl
503 , rfctl->radar_detect_ch
504 , rfctl->radar_detect_bw
505 , rfctl->radar_detect_offset
506 , &non_ocp_ms
507 , &cac_ms
508 );
509
510 if (non_ocp_ms)
511 _RTW_PRINT_SEL(sel, ", non_ocp:%d", non_ocp_ms);
512 if (cac_ms)
513 _RTW_PRINT_SEL(sel, ", cac:%d", cac_ms);
514 }
515
516 _RTW_PRINT_SEL(sel, "\n");
517 }
518 #endif /* CONFIG_DFS_MASTER */
519 }
520
521 #define SEC_CAM_ENT_ID_TITLE_FMT "%-2s"
522 #define SEC_CAM_ENT_ID_TITLE_ARG "id"
523 #define SEC_CAM_ENT_ID_VALUE_FMT "%2u"
524 #define SEC_CAM_ENT_ID_VALUE_ARG(id) (id)
525
526 #define SEC_CAM_ENT_TITLE_FMT "%-6s %-17s %-32s %-3s %-8s %-2s %-2s %-5s"
527 #define SEC_CAM_ENT_TITLE_ARG "ctrl", "addr", "key", "kid", "type", "MK", "GK", "valid"
528 #define SEC_CAM_ENT_VALUE_FMT "0x%04x "MAC_FMT" "KEY_FMT" %3u %-8s %2u %2u %5u"
529 #define SEC_CAM_ENT_VALUE_ARG(ent) \
530 (ent)->ctrl \
531 , MAC_ARG((ent)->mac) \
532 , KEY_ARG((ent)->key) \
533 , ((ent)->ctrl) & 0x03 \
534 , (((ent)->ctrl) & 0x200) ? \
535 security_type_str((((ent)->ctrl) >> 2 & 0x7) | _SEC_TYPE_256_) : \
536 security_type_str(((ent)->ctrl) >> 2 & 0x7) \
537 , (((ent)->ctrl) >> 5) & 0x01 \
538 , (((ent)->ctrl) >> 6) & 0x01 \
539 , (((ent)->ctrl) >> 15) & 0x01
540
dump_sec_cam_ent(void * sel,struct sec_cam_ent * ent,int id)541 void dump_sec_cam_ent(void *sel, struct sec_cam_ent *ent, int id)
542 {
543 if (id >= 0) {
544 RTW_PRINT_SEL(sel, SEC_CAM_ENT_ID_VALUE_FMT " " SEC_CAM_ENT_VALUE_FMT"\n"
545 , SEC_CAM_ENT_ID_VALUE_ARG(id), SEC_CAM_ENT_VALUE_ARG(ent));
546 } else
547 RTW_PRINT_SEL(sel, SEC_CAM_ENT_VALUE_FMT"\n", SEC_CAM_ENT_VALUE_ARG(ent));
548 }
549
dump_sec_cam_ent_title(void * sel,u8 has_id)550 void dump_sec_cam_ent_title(void *sel, u8 has_id)
551 {
552 if (has_id) {
553 RTW_PRINT_SEL(sel, SEC_CAM_ENT_ID_TITLE_FMT " " SEC_CAM_ENT_TITLE_FMT"\n"
554 , SEC_CAM_ENT_ID_TITLE_ARG, SEC_CAM_ENT_TITLE_ARG);
555 } else
556 RTW_PRINT_SEL(sel, SEC_CAM_ENT_TITLE_FMT"\n", SEC_CAM_ENT_TITLE_ARG);
557 }
558
dump_sec_cam(void * sel,_adapter * adapter)559 void dump_sec_cam(void *sel, _adapter *adapter)
560 {
561 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
562 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
563 struct sec_cam_ent ent;
564 int i;
565
566 RTW_PRINT_SEL(sel, "HW sec cam:\n");
567 dump_sec_cam_ent_title(sel, 1);
568 for (i = 0; i < cam_ctl->num; i++) {
569 rtw_hal_sec_read_cam_ent(adapter, i, (u8 *)(&ent.ctrl), ent.mac, ent.key);
570 dump_sec_cam_ent(sel , &ent, i);
571 }
572 }
573
dump_sec_cam_cache(void * sel,_adapter * adapter)574 void dump_sec_cam_cache(void *sel, _adapter *adapter)
575 {
576 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
577 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
578 int i;
579
580 RTW_PRINT_SEL(sel, "SW sec cam cache:\n");
581 dump_sec_cam_ent_title(sel, 1);
582 for (i = 0; i < cam_ctl->num; i++) {
583 if (dvobj->cam_cache[i].ctrl != 0)
584 dump_sec_cam_ent(sel, &dvobj->cam_cache[i], i);
585 }
586
587 }
588
589 static u8 del_rx_ampdu_test_no_tx_fail = 0;
590
rtw_del_rx_ampdu_test_trigger_no_tx_fail(void)591 bool rtw_del_rx_ampdu_test_trigger_no_tx_fail(void)
592 {
593 if (del_rx_ampdu_test_no_tx_fail) {
594 RTW_PRINT("del_rx_ampdu test case: trigger no_tx_fail\n");
595 del_rx_ampdu_test_no_tx_fail--;
596 return _TRUE;
597 }
598 return _FALSE;
599 }
600
601 static u32 g_wait_hiq_empty_ms = 0;
602
rtw_get_wait_hiq_empty_ms(void)603 u32 rtw_get_wait_hiq_empty_ms(void)
604 {
605 return g_wait_hiq_empty_ms;
606 }
607
608 static systime sta_linking_test_start_time = 0;
609 static u32 sta_linking_test_wait_ms = 0;
610 static u8 sta_linking_test_force_fail = 0;
611
rtw_sta_linking_test_set_start(void)612 void rtw_sta_linking_test_set_start(void)
613 {
614 sta_linking_test_start_time = rtw_get_current_time();
615 }
616
rtw_sta_linking_test_wait_done(void)617 bool rtw_sta_linking_test_wait_done(void)
618 {
619 return rtw_get_passing_time_ms(sta_linking_test_start_time) >= sta_linking_test_wait_ms;
620 }
621
rtw_sta_linking_test_force_fail(void)622 bool rtw_sta_linking_test_force_fail(void)
623 {
624 return sta_linking_test_force_fail;
625 }
626
627 #ifdef CONFIG_AP_MODE
628 static u16 ap_linking_test_force_auth_fail = 0;
629 static u16 ap_linking_test_force_asoc_fail = 0;
630
rtw_ap_linking_test_force_auth_fail(void)631 u16 rtw_ap_linking_test_force_auth_fail(void)
632 {
633 return ap_linking_test_force_auth_fail;
634 }
635
rtw_ap_linking_test_force_asoc_fail(void)636 u16 rtw_ap_linking_test_force_asoc_fail(void)
637 {
638 return ap_linking_test_force_asoc_fail;
639 }
640 #endif
641
proc_get_defs_param(struct seq_file * m,void * v)642 int proc_get_defs_param(struct seq_file *m, void *v)
643 {
644 struct net_device *dev = m->private;
645 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
646 struct mlme_priv *mlme = &adapter->mlmepriv;
647
648 RTW_PRINT_SEL(m, "%s %15s\n", "lmt_sta", "lmt_time");
649 RTW_PRINT_SEL(m, "%-15u %-15u\n"
650 , mlme->defs_lmt_sta
651 , mlme->defs_lmt_time
652 );
653
654 return 0;
655 }
656
proc_set_defs_param(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)657 ssize_t proc_set_defs_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
658 {
659 struct net_device *dev = data;
660 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
661 struct mlme_priv *mlme = &adapter->mlmepriv;
662
663 char tmp[32];
664 u32 defs_lmt_sta;
665 u32 defs_lmt_time;
666
667 if (count < 1)
668 return -EFAULT;
669
670 if (count > sizeof(tmp)) {
671 rtw_warn_on(1);
672 return -EFAULT;
673 }
674
675 if (buffer && !copy_from_user(tmp, buffer, count)) {
676
677 int num = sscanf(tmp, "%u %u", &defs_lmt_sta, &defs_lmt_time);
678
679 if (num >= 1)
680 mlme->defs_lmt_sta = defs_lmt_sta;
681 if (num >= 2)
682 mlme->defs_lmt_time = defs_lmt_time;
683 }
684
685 return count;
686
687 }
688
proc_set_write_reg(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)689 ssize_t proc_set_write_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
690 {
691 struct net_device *dev = data;
692 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
693 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
694 char tmp[32];
695 u32 addr, val, len;
696
697 if (count < 3) {
698 RTW_INFO("argument size is less than 3\n");
699 return -EFAULT;
700 }
701
702 if (count > sizeof(tmp)) {
703 rtw_warn_on(1);
704 return -EFAULT;
705 }
706
707 if (buffer && !copy_from_user(tmp, buffer, count)) {
708
709 int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
710
711 if (num != 3) {
712 RTW_INFO("invalid write_reg parameter!\n");
713 return count;
714 }
715
716 switch (len) {
717 case 1:
718 rtw_phl_write8(dvobj->phl, addr, (u8)val);
719 break;
720 case 2:
721 rtw_phl_write16(dvobj->phl, addr, (u16)val);
722 break;
723 case 4:
724 rtw_phl_write32(dvobj->phl, addr, val);
725 break;
726 default:
727 RTW_INFO("error write length=%d", len);
728 break;
729 }
730
731 }
732 return count;
733
734 }
735
736 static u32 proc_get_read_addr = 0xeeeeeeee;
737 static u32 proc_get_read_len = 0x4;
738
proc_get_read_reg(struct seq_file * m,void * v)739 int proc_get_read_reg(struct seq_file *m, void *v)
740 {
741 struct net_device *dev = m->private;
742 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
743 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
744
745 if (proc_get_read_addr == 0xeeeeeeee) {
746 RTW_PRINT_SEL(m, "address not initialized\n");
747 return 0;
748 }
749
750 switch (proc_get_read_len) {
751 case 1:
752 RTW_PRINT_SEL(m, "reg_read8(0x%x)=0x%x\n", proc_get_read_addr,
753 rtw_phl_read8(dvobj->phl, proc_get_read_addr));
754 break;
755 case 2:
756 RTW_PRINT_SEL(m, "reg_read16(0x%x)=0x%x\n", proc_get_read_addr,
757 rtw_phl_read16(dvobj->phl, proc_get_read_addr));
758 break;
759 case 4:
760 RTW_PRINT_SEL(m, "reg_read32(0x%x)=0x%x\n", proc_get_read_addr,
761 rtw_phl_read32(dvobj->phl, proc_get_read_addr));
762 break;
763 default:
764 RTW_PRINT_SEL(m, "error read length=%d\n", proc_get_read_len);
765 break;
766 }
767
768 return 0;
769 }
770
proc_set_read_reg(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)771 ssize_t proc_set_read_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
772 {
773 char tmp[16];
774 u32 addr, len;
775
776 if (count < 2) {
777 RTW_INFO("argument size is less than 2\n");
778 return -EFAULT;
779 }
780
781 if (count > sizeof(tmp)) {
782 rtw_warn_on(1);
783 return -EFAULT;
784 }
785
786 if (buffer && !copy_from_user(tmp, buffer, count)) {
787
788 int num = sscanf(tmp, "%x %x", &addr, &len);
789
790 if (num != 2) {
791 RTW_INFO("invalid read_reg parameter!\n");
792 return count;
793 }
794
795 proc_get_read_addr = addr;
796
797 proc_get_read_len = len;
798 }
799
800 return count;
801
802 }
803
proc_set_mac_dbg_status_dump(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)804 ssize_t proc_set_mac_dbg_status_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
805 {
806 struct net_device *dev = data;
807 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
808 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
809 char tmp[32] = {0};
810 u32 val[2] = {0};
811 u32 en;
812 u8 en_u8;
813
814 if (count < 1) {
815 RTW_INFO("argument size is less than 1\n");
816 return -EFAULT;
817 }
818
819 if (count > sizeof(tmp)) {
820 rtw_warn_on(1);
821 return -EFAULT;
822 }
823
824 if (buffer && !copy_from_user(tmp, buffer, count)) {
825
826 int num = sscanf(tmp, "%x", &en);
827
828 if (num != 1) {
829 RTW_INFO("invalid mac_dbg_status_dump parameter!\n");
830 return count;
831 }
832 en_u8 = (u8)en;
833 rtw_phl_mac_dbg_status_dump(dvobj->phl, val, &en_u8);
834 if (en & BIT0)
835 RTW_INFO_DUMP("ss_dbgpkg: ", (const u8 *)val, 8);
836 }
837 return count;
838
839 }
840
841 #ifdef CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST
proc_get_ignore_go_and_low_rssi_in_scan(struct seq_file * m,void * v)842 int proc_get_ignore_go_and_low_rssi_in_scan(struct seq_file *m, void *v)
843 {
844 struct net_device *dev = m->private;
845 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
846 struct registry_priv *pregpriv = &padapter->registrypriv;
847
848 RTW_PRINT_SEL(m, "ignore_go_in_scan=%d, ignore_low_rssi_in_scan=%d\n",
849 pregpriv->ignore_go_in_scan, pregpriv->ignore_low_rssi_in_scan);
850 return 0;
851 }
852
proc_set_ignore_go_and_low_rssi_in_scan(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)853 ssize_t proc_set_ignore_go_and_low_rssi_in_scan(struct file *file,
854 const char __user *buffer, size_t count, loff_t *pos, void *data)
855 {
856 struct net_device *dev = data;
857 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
858 struct registry_priv *pregpriv = &padapter->registrypriv;
859
860 char tmp[32] = {0};
861 int enable = 0;
862 int num = 0, low_rssi=0;
863
864 if (count < 1)
865 return -EFAULT;
866
867 if (count > sizeof(tmp)) {
868 rtw_warn_on(1);
869 return -EFAULT;
870 }
871
872 if (buffer && !copy_from_user(tmp, buffer, count)) {
873
874 num = sscanf(tmp, "%d %d", &enable, &low_rssi);
875 RTW_INFO("num=%d enable=%d low_rssi=%d\n", num, enable, low_rssi);
876
877 if (num != 2) {
878 RTW_INFO("argument number is wrong\n");
879 return -EFAULT;
880 }
881
882 pregpriv->ignore_go_in_scan = enable;
883 pregpriv->ignore_low_rssi_in_scan = low_rssi;
884 }
885 return count;
886 }
887 #endif /*CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST*/
888
889 #ifdef CONFIG_PROC_DEBUG
proc_get_rx_stat(struct seq_file * m,void * v)890 int proc_get_rx_stat(struct seq_file *m, void *v)
891 {
892 _list *plist, *phead;
893 struct net_device *dev = m->private;
894 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
895 struct sta_info *psta = NULL;
896 struct stainfo_stats *pstats = NULL;
897 struct sta_priv *pstapriv = &(adapter->stapriv);
898 u32 i, j;
899 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
900 u8 null_addr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
901
902 _rtw_spinlock_bh(&pstapriv->sta_hash_lock);
903 for (i = 0; i < NUM_STA; i++) {
904 phead = &(pstapriv->sta_hash[i]);
905 plist = get_next(phead);
906 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
907 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
908 plist = get_next(plist);
909 pstats = &psta->sta_stats;
910
911 if (pstats == NULL)
912 continue;
913 if ((_rtw_memcmp(psta->phl_sta->mac_addr, bc_addr, ETH_ALEN) != _TRUE)
914 && (_rtw_memcmp(psta->phl_sta->mac_addr, null_addr, ETH_ALEN) != _TRUE)
915 && (_rtw_memcmp(psta->phl_sta->mac_addr, adapter_mac_addr(adapter), ETH_ALEN) != _TRUE)) {
916 RTW_PRINT_SEL(m, "MAC :\t\t"MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
917 RTW_PRINT_SEL(m, "data_rx_cnt :\t%llu\n", sta_rx_data_uc_pkts(psta) - pstats->last_rx_data_uc_pkts);
918 pstats->last_rx_data_uc_pkts = sta_rx_data_uc_pkts(psta);
919 RTW_PRINT_SEL(m, "duplicate_cnt :\t%u\n", pstats->duplicate_cnt);
920 pstats->duplicate_cnt = 0;
921 RTW_PRINT_SEL(m, "rx_per_rate_cnt :\n");
922
923 for (j = 0; j < 0x60; j++) {
924 RTW_PRINT_SEL(m, "%08u ", pstats->rxratecnt[j]);
925 pstats->rxratecnt[j] = 0;
926 if ((j%8) == 7)
927 RTW_PRINT_SEL(m, "\n");
928 }
929 RTW_PRINT_SEL(m, "\n");
930 }
931 }
932 }
933 _rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
934 return 0;
935 }
936
proc_get_sta_tx_stat(struct seq_file * m,void * v)937 int proc_get_sta_tx_stat(struct seq_file *m, void *v)
938 {
939 struct net_device *dev = m->private;
940 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
941 struct sta_priv *stapriv = &(adapter->stapriv);
942 struct sta_priv *stapriv_primary = &(GET_PRIMARY_ADAPTER(adapter))->stapriv;
943 struct sta_info *sta;
944 struct stainfo_stats *stats;
945 u8 mac[ETH_ALEN] = {0};
946 int ret = 0;
947
948 _rtw_memcpy(mac, stapriv_primary->c2h_sta_mac, ETH_ALEN);
949 sta = rtw_get_stainfo(stapriv, mac);
950 if (sta) {
951 ret = rtw_get_sta_tx_stat(adapter, sta);
952 stats = &sta->sta_stats;
953 RTW_PRINT_SEL(m, "MAC: " MAC_FMT " fail: %u retry: %u\n",
954 MAC_ARG(mac), stats->tx_fail_cnt_sum, stats->tx_retry_cnt_sum);
955 } else
956 ret = -ENODATA;
957 return ret;
958 }
959
proc_set_sta_tx_stat(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)960 ssize_t proc_set_sta_tx_stat(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
961 {
962 struct net_device *dev = data;
963 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
964 struct sta_priv *stapriv_primary = &(GET_PRIMARY_ADAPTER(adapter))->stapriv;
965 char tmp[18] = {0};
966
967 if (count < 1)
968 return -EFAULT;
969
970 if (count > sizeof(tmp)) {
971 rtw_warn_on(1);
972 return -EFAULT;
973 }
974
975 if (buffer && !copy_from_user(tmp, buffer, count)) {
976 if (sscanf(tmp, MAC_SFMT, MAC_SARG(stapriv_primary->c2h_sta_mac)) != 6) {
977 _rtw_memset(stapriv_primary->c2h_sta_mac, 0, 6);
978 RTW_PRINT(FUNC_ADPT_FMT" Invalid format\n",
979 FUNC_ADPT_ARG(adapter));
980 }
981
982 }
983
984 return count;
985 }
986
proc_get_tx_stat(struct seq_file * m,void * v)987 int proc_get_tx_stat(struct seq_file *m, void *v)
988 {
989 _list *plist, *phead;
990 struct net_device *dev = m->private;
991 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
992 struct sta_info *psta = NULL;
993 u8 sta_mac[NUM_STA][ETH_ALEN] = {{0}};
994 uint mac_id[NUM_STA];
995 struct stainfo_stats *pstats = NULL;
996 struct sta_priv *pstapriv = &(adapter->stapriv);
997 struct sta_priv *pstapriv_primary = &(GET_PRIMARY_ADAPTER(adapter))->stapriv;
998 u32 i, macid_rec_idx = 0;
999 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1000 u8 null_addr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1001
1002 _rtw_spinlock_bh(&pstapriv->sta_hash_lock);
1003 for (i = 0; i < NUM_STA; i++) {
1004 phead = &(pstapriv->sta_hash[i]);
1005 plist = get_next(phead);
1006 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
1007 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
1008 plist = get_next(plist);
1009 if ((_rtw_memcmp(psta->phl_sta->mac_addr, bc_addr, ETH_ALEN) != _TRUE)
1010 && (_rtw_memcmp(psta->phl_sta->mac_addr, null_addr, ETH_ALEN) != _TRUE)
1011 && (_rtw_memcmp(psta->phl_sta->mac_addr, adapter_mac_addr(adapter), ETH_ALEN) != _TRUE)) {
1012 _rtw_memcpy(&sta_mac[macid_rec_idx][0], psta->phl_sta->mac_addr, ETH_ALEN);
1013 mac_id[macid_rec_idx] = psta->phl_sta->macid;
1014 macid_rec_idx++;
1015 }
1016 }
1017 }
1018 _rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
1019 for (i = 0; i < macid_rec_idx; i++) {
1020 psta = rtw_get_stainfo(pstapriv, &sta_mac[i][0]);
1021 if(psta) {
1022 rtw_get_sta_tx_stat(adapter, psta);
1023 pstats = &psta->sta_stats;
1024 #if (!defined(ROKU_PRIVATE) && !defined(CONFIG_RTW_MULTI_AP))
1025 RTW_PRINT_SEL(m, "data_sent_cnt :\t%u\n", pstats->tx_ok_cnt + pstats->tx_fail_cnt);
1026 RTW_PRINT_SEL(m, "success_cnt :\t%u\n", pstats->tx_ok_cnt);
1027 RTW_PRINT_SEL(m, "failure_cnt :\t%u\n", pstats->tx_fail_cnt);
1028 RTW_PRINT_SEL(m, "retry_cnt :\t%u\n\n", pstats->tx_retry_cnt);
1029 #else
1030 RTW_PRINT_SEL(m, "MAC: " MAC_FMT " sent: %u fail: %u retry: %u\n",
1031 MAC_ARG(&sta_mac[i][0]), pstats->tx_ok_cnt, pstats->tx_fail_cnt, pstats->tx_retry_cnt);
1032 #endif /* ROKU_PRIVATE */
1033
1034 } else
1035 RTW_PRINT_SEL(m, "STA is gone\n");
1036 }
1037 return 0;
1038 }
1039
proc_get_fwstate(struct seq_file * m,void * v)1040 int proc_get_fwstate(struct seq_file *m, void *v)
1041 {
1042 struct net_device *dev = m->private;
1043 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1044 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1045
1046 RTW_PRINT_SEL(m, "fwstate=0x%x\n", get_fwstate(pmlmepriv));
1047
1048 return 0;
1049 }
1050
proc_get_sec_info(struct seq_file * m,void * v)1051 int proc_get_sec_info(struct seq_file *m, void *v)
1052 {
1053 struct net_device *dev = m->private;
1054 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1055 struct security_priv *sec = &padapter->securitypriv;
1056
1057 RTW_PRINT_SEL(m, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
1058 sec->dot11AuthAlgrthm, sec->dot11PrivacyAlgrthm,
1059 sec->ndisauthtype, sec->ndisencryptstatus);
1060
1061 RTW_PRINT_SEL(m, "hw_decrypted=%d\n", sec->hw_decrypted);
1062 RTW_PRINT_SEL(m, "wpa_psk=");
1063 if(sec->wpa_psk & BIT(0))
1064 RTW_PRINT_SEL(m, "WPA ");
1065 if(sec->wpa_psk & BIT(1))
1066 RTW_PRINT_SEL(m, "WPA2 ");
1067 RTW_PRINT_SEL(m, "\n");
1068 RTW_PRINT_SEL(m, "wpa2_group_cipher=%d\n", sec->wpa2_group_cipher);
1069 RTW_PRINT_SEL(m, "wpa2_pairwise_cipher=%d\n", sec->wpa2_pairwise_cipher);
1070 RTW_PRINT_SEL(m, "wpa_group_cipher=%d\n", sec->wpa_group_cipher);
1071 RTW_PRINT_SEL(m, "wpa_pairwise_cipher=%d\n", sec->wpa_pairwise_cipher);
1072 RTW_PRINT_SEL(m, "80211W_enable=%d\n", sec->mfp_opt);
1073 RTW_PRINT_SEL(m, "akm_suite_bitmap=0x%x\n", sec->akmp);
1074
1075 #ifdef DBG_SW_SEC_CNT
1076 RTW_PRINT_SEL(m, "==sw counters(bc, mc, uc)==\n");
1077 RTW_PRINT_SEL(m, "wep_sw_enc_cnt=%llu, %llu, %llu\n"
1078 , sec->wep_sw_enc_cnt_bc , sec->wep_sw_enc_cnt_mc, sec->wep_sw_enc_cnt_uc);
1079 RTW_PRINT_SEL(m, "wep_sw_dec_cnt=%llu, %llu, %llu\n"
1080 , sec->wep_sw_dec_cnt_bc , sec->wep_sw_dec_cnt_mc, sec->wep_sw_dec_cnt_uc);
1081
1082 RTW_PRINT_SEL(m, "tkip_sw_enc_cnt=%llu, %llu, %llu\n"
1083 , sec->tkip_sw_enc_cnt_bc , sec->tkip_sw_enc_cnt_mc, sec->tkip_sw_enc_cnt_uc);
1084 RTW_PRINT_SEL(m, "tkip_sw_dec_cnt=%llu, %llu, %llu\n"
1085 , sec->tkip_sw_dec_cnt_bc , sec->tkip_sw_dec_cnt_mc, sec->tkip_sw_dec_cnt_uc);
1086
1087 RTW_PRINT_SEL(m, "aes_sw_enc_cnt=%llu, %llu, %llu\n"
1088 , sec->aes_sw_enc_cnt_bc , sec->aes_sw_enc_cnt_mc, sec->aes_sw_enc_cnt_uc);
1089 RTW_PRINT_SEL(m, "aes_sw_dec_cnt=%llu, %llu, %llu\n"
1090 , sec->aes_sw_dec_cnt_bc , sec->aes_sw_dec_cnt_mc, sec->aes_sw_dec_cnt_uc);
1091
1092 RTW_PRINT_SEL(m, "gcmp_sw_enc_cnt=%llu, %llu, %llu\n"
1093 , sec->gcmp_sw_enc_cnt_bc , sec->gcmp_sw_enc_cnt_mc, sec->gcmp_sw_enc_cnt_uc);
1094 RTW_PRINT_SEL(m, "gcmp_sw_dec_cnt=%llu, %llu, %llu\n"
1095 , sec->gcmp_sw_dec_cnt_bc , sec->gcmp_sw_dec_cnt_mc, sec->gcmp_sw_dec_cnt_uc);
1096 #endif /* DBG_SW_SEC_CNT */
1097
1098 return 0;
1099 }
1100
proc_get_mlmext_state(struct seq_file * m,void * v)1101 int proc_get_mlmext_state(struct seq_file *m, void *v)
1102 {
1103 struct net_device *dev = m->private;
1104 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1105 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1106 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1107
1108 RTW_PRINT_SEL(m, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
1109
1110 return 0;
1111 }
1112
1113 #ifdef CONFIG_LAYER2_ROAMING
proc_get_roam_flags(struct seq_file * m,void * v)1114 int proc_get_roam_flags(struct seq_file *m, void *v)
1115 {
1116 struct net_device *dev = m->private;
1117 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1118
1119 RTW_PRINT_SEL(m, "0x%02x\n", rtw_roam_flags(adapter));
1120
1121 return 0;
1122 }
1123
proc_set_roam_flags(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1124 ssize_t proc_set_roam_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1125 {
1126 struct net_device *dev = data;
1127 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1128
1129 char tmp[32];
1130 u8 flags;
1131
1132 if (count < 1)
1133 return -EFAULT;
1134
1135 if (count > sizeof(tmp)) {
1136 rtw_warn_on(1);
1137 return -EFAULT;
1138 }
1139
1140 if (buffer && !copy_from_user(tmp, buffer, count)) {
1141
1142 int num = sscanf(tmp, "%hhx", &flags);
1143
1144 if (num == 1)
1145 rtw_assign_roam_flags(adapter, flags);
1146 }
1147
1148 return count;
1149
1150 }
1151
proc_get_roam_param(struct seq_file * m,void * v)1152 int proc_get_roam_param(struct seq_file *m, void *v)
1153 {
1154 struct net_device *dev = m->private;
1155 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1156 struct mlme_priv *mlme = &adapter->mlmepriv;
1157
1158 RTW_PRINT_SEL(m, "%12s %15s %26s %16s\n", "rssi_diff_th", "scanr_exp_ms", "scan_interval(unit:2 sec)", "rssi_threshold");
1159 RTW_PRINT_SEL(m, "%-15u %-13u %-27u %-11u\n"
1160 , mlme->roam_rssi_diff_th
1161 , mlme->roam_scanr_exp_ms
1162 , mlme->roam_scan_int
1163 , mlme->roam_rssi_threshold
1164 );
1165
1166 return 0;
1167 }
1168
proc_set_roam_param(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1169 ssize_t proc_set_roam_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1170 {
1171 struct net_device *dev = data;
1172 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1173 struct mlme_priv *mlme = &adapter->mlmepriv;
1174
1175 char tmp[32];
1176 u8 rssi_diff_th;
1177 u32 scanr_exp_ms;
1178 u32 scan_int;
1179 u8 rssi_threshold;
1180
1181 if (count < 1)
1182 return -EFAULT;
1183
1184 if (count > sizeof(tmp)) {
1185 rtw_warn_on(1);
1186 return -EFAULT;
1187 }
1188
1189 if (buffer && !copy_from_user(tmp, buffer, count)) {
1190
1191 int num = sscanf(tmp, "%hhu %u %u %hhu", &rssi_diff_th, &scanr_exp_ms, &scan_int, &rssi_threshold);
1192
1193 if (num >= 1)
1194 mlme->roam_rssi_diff_th = rssi_diff_th;
1195 if (num >= 2)
1196 mlme->roam_scanr_exp_ms = scanr_exp_ms;
1197 if (num >= 3)
1198 mlme->roam_scan_int = scan_int;
1199 if (num >= 4)
1200 mlme->roam_rssi_threshold = rssi_threshold;
1201 }
1202
1203 return count;
1204
1205 }
1206
proc_set_roam_tgt_addr(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1207 ssize_t proc_set_roam_tgt_addr(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1208 {
1209 struct net_device *dev = data;
1210 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1211
1212 char tmp[32];
1213 u8 addr[ETH_ALEN];
1214
1215 if (count < 1)
1216 return -EFAULT;
1217
1218 if (count > sizeof(tmp)) {
1219 rtw_warn_on(1);
1220 return -EFAULT;
1221 }
1222
1223 if (buffer && !copy_from_user(tmp, buffer, count)) {
1224
1225 int num = sscanf(tmp, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", addr, addr + 1, addr + 2, addr + 3, addr + 4, addr + 5);
1226 if (num == 6)
1227 _rtw_memcpy(adapter->mlmepriv.roam_tgt_addr, addr, ETH_ALEN);
1228
1229 RTW_INFO("set roam_tgt_addr to "MAC_FMT"\n", MAC_ARG(adapter->mlmepriv.roam_tgt_addr));
1230 }
1231
1232 return count;
1233 }
1234 #endif /* CONFIG_LAYER2_ROAMING */
1235
1236
proc_get_qos_option(struct seq_file * m,void * v)1237 int proc_get_qos_option(struct seq_file *m, void *v)
1238 {
1239 struct net_device *dev = m->private;
1240 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1241 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1242
1243 RTW_PRINT_SEL(m, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
1244
1245 return 0;
1246 }
1247
proc_get_ht_option(struct seq_file * m,void * v)1248 int proc_get_ht_option(struct seq_file *m, void *v)
1249 {
1250 struct net_device *dev = m->private;
1251 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1252 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1253
1254 #ifdef CONFIG_80211N_HT
1255 RTW_PRINT_SEL(m, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
1256 #endif /* CONFIG_80211N_HT */
1257
1258 return 0;
1259 }
1260
proc_get_rf_info(struct seq_file * m,void * v)1261 int proc_get_rf_info(struct seq_file *m, void *v)
1262 {
1263 struct net_device *dev = m->private;
1264 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1265 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1266
1267 RTW_PRINT_SEL(m, "cur_ch=%d, cur_bw=%d, cur_ch_offet=%d\n",
1268 pmlmeext->chandef.chan, pmlmeext->chandef.bw, pmlmeext->chandef.offset);
1269
1270 RTW_PRINT_SEL(m, "oper_ch=%d, oper_bw=%d, oper_ch_offet=%d\n",
1271 rtw_get_oper_ch(padapter), rtw_get_oper_bw(padapter), rtw_get_oper_choffset(padapter));
1272
1273 return 0;
1274 }
1275
proc_get_scan_param(struct seq_file * m,void * v)1276 int proc_get_scan_param(struct seq_file *m, void *v)
1277 {
1278 struct net_device *dev = m->private;
1279 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1280 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1281 struct ss_res *ss = &mlmeext->sitesurvey_res;
1282
1283 #define SCAN_PARAM_TITLE_FMT "%10s"
1284 #define SCAN_PARAM_VALUE_FMT "%-10u"
1285 #define SCAN_PARAM_TITLE_ARG , "scan_ch_ms"
1286 #define SCAN_PARAM_VALUE_ARG , ss->scan_ch_ms
1287 #ifdef CONFIG_80211N_HT
1288 #define SCAN_PARAM_TITLE_FMT_HT " %15s %13s"
1289 #define SCAN_PARAM_VALUE_FMT_HT " %-15u %-13u"
1290 #define SCAN_PARAM_TITLE_ARG_HT , "rx_ampdu_accept", "rx_ampdu_size"
1291 #define SCAN_PARAM_VALUE_ARG_HT , ss->rx_ampdu_accept, ss->rx_ampdu_size
1292 #else
1293 #define SCAN_PARAM_TITLE_FMT_HT ""
1294 #define SCAN_PARAM_VALUE_FMT_HT ""
1295 #define SCAN_PARAM_TITLE_ARG_HT
1296 #define SCAN_PARAM_VALUE_ARG_HT
1297 #endif
1298 #ifdef CONFIG_SCAN_BACKOP
1299 #define SCAN_PARAM_TITLE_FMT_BACKOP " %9s %12s"
1300 #define SCAN_PARAM_VALUE_FMT_BACKOP " %-9u %-12u"
1301 #define SCAN_PARAM_TITLE_ARG_BACKOP , "backop_ms", "scan_cnt_max"
1302 #define SCAN_PARAM_VALUE_ARG_BACKOP , ss->backop_ms, ss->scan_cnt_max
1303 #else
1304 #define SCAN_PARAM_TITLE_FMT_BACKOP ""
1305 #define SCAN_PARAM_VALUE_FMT_BACKOP ""
1306 #define SCAN_PARAM_TITLE_ARG_BACKOP
1307 #define SCAN_PARAM_VALUE_ARG_BACKOP
1308 #endif
1309
1310 RTW_PRINT_SEL(m,
1311 SCAN_PARAM_TITLE_FMT
1312 SCAN_PARAM_TITLE_FMT_HT
1313 SCAN_PARAM_TITLE_FMT_BACKOP
1314 "\n"
1315 SCAN_PARAM_TITLE_ARG
1316 SCAN_PARAM_TITLE_ARG_HT
1317 SCAN_PARAM_TITLE_ARG_BACKOP
1318 );
1319
1320 RTW_PRINT_SEL(m,
1321 SCAN_PARAM_VALUE_FMT
1322 SCAN_PARAM_VALUE_FMT_HT
1323 SCAN_PARAM_VALUE_FMT_BACKOP
1324 "\n"
1325 SCAN_PARAM_VALUE_ARG
1326 SCAN_PARAM_VALUE_ARG_HT
1327 SCAN_PARAM_VALUE_ARG_BACKOP
1328 );
1329
1330 return 0;
1331 }
1332
proc_set_scan_param(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1333 ssize_t proc_set_scan_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1334 {
1335 struct net_device *dev = data;
1336 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1337 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1338 struct ss_res *ss = &mlmeext->sitesurvey_res;
1339
1340 char tmp[32] = {0};
1341
1342 u16 scan_ch_ms;
1343 #define SCAN_PARAM_INPUT_FMT "%hu"
1344 #define SCAN_PARAM_INPUT_ARG , &scan_ch_ms
1345 #ifdef CONFIG_80211N_HT
1346 u8 rx_ampdu_accept;
1347 u8 rx_ampdu_size;
1348 #define SCAN_PARAM_INPUT_FMT_HT " %hhu %hhu"
1349 #define SCAN_PARAM_INPUT_ARG_HT , &rx_ampdu_accept, &rx_ampdu_size
1350 #else
1351 #define SCAN_PARAM_INPUT_FMT_HT ""
1352 #define SCAN_PARAM_INPUT_ARG_HT
1353 #endif
1354 #ifdef CONFIG_SCAN_BACKOP
1355 u16 backop_ms;
1356 u8 scan_cnt_max;
1357 #define SCAN_PARAM_INPUT_FMT_BACKOP " %hu %hhu"
1358 #define SCAN_PARAM_INPUT_ARG_BACKOP , &backop_ms, &scan_cnt_max
1359 #else
1360 #define SCAN_PARAM_INPUT_FMT_BACKOP ""
1361 #define SCAN_PARAM_INPUT_ARG_BACKOP
1362 #endif
1363
1364 if (count < 1)
1365 return -EFAULT;
1366
1367 if (count > sizeof(tmp)) {
1368 rtw_warn_on(1);
1369 return -EFAULT;
1370 }
1371
1372 if (buffer && !copy_from_user(tmp, buffer, count)) {
1373
1374 int num = sscanf(tmp,
1375 SCAN_PARAM_INPUT_FMT
1376 SCAN_PARAM_INPUT_FMT_HT
1377 SCAN_PARAM_INPUT_FMT_BACKOP
1378 SCAN_PARAM_INPUT_ARG
1379 SCAN_PARAM_INPUT_ARG_HT
1380 SCAN_PARAM_INPUT_ARG_BACKOP
1381 );
1382
1383 if (num-- > 0)
1384 ss->scan_ch_ms = scan_ch_ms;
1385 #ifdef CONFIG_80211N_HT
1386 if (num-- > 0)
1387 ss->rx_ampdu_accept = rx_ampdu_accept;
1388 if (num-- > 0)
1389 ss->rx_ampdu_size = rx_ampdu_size;
1390 #endif
1391 #ifdef CONFIG_SCAN_BACKOP
1392 if (num-- > 0)
1393 ss->backop_ms = backop_ms;
1394 if (num-- > 0)
1395 ss->scan_cnt_max = scan_cnt_max;
1396 #endif
1397 }
1398
1399 return count;
1400 }
proc_set_scan_abort(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1401 ssize_t proc_set_scan_abort(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1402 {
1403 char tmp[32];
1404 struct net_device *dev = data;
1405 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1406 u32 timeout = 0;
1407
1408 if (count < 1) {
1409 RTW_INFO("argument size is less than 1\n");
1410 return -EFAULT;
1411 }
1412
1413 if (count > sizeof(tmp)) {
1414 rtw_warn_on(1);
1415 return -EFAULT;
1416 }
1417
1418 if (buffer && !copy_from_user(tmp, buffer, count)) {
1419 int num = 0;
1420
1421 num = sscanf(tmp, "%d", &timeout);
1422 if (num != 1) {
1423 RTW_INFO("invalid parameter!\n");
1424 return count;
1425 }
1426
1427 rtw_scan_abort(padapter, timeout);
1428 }
1429
1430 return count;
1431 }
1432
proc_get_scan_abort(struct seq_file * m,void * v)1433 int proc_get_scan_abort(struct seq_file *m, void *v)
1434 {
1435 struct net_device *dev = m->private;
1436 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1437
1438
1439 return 0;
1440 }
1441
proc_get_survey_info(struct seq_file * m,void * v)1442 int proc_get_survey_info(struct seq_file *m, void *v)
1443 {
1444 struct net_device *dev = m->private;
1445 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1446 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1447 _queue *queue = &(pmlmepriv->scanned_queue);
1448 struct wlan_network *pnetwork = NULL;
1449 _list *plist, *phead;
1450 s32 notify_signal;
1451 s16 notify_noise = 0;
1452 u16 index = 0, ie_cap = 0;
1453 unsigned char *ie_wpa = NULL, *ie_wpa2 = NULL, *ie_wps = NULL;
1454 unsigned char *ie_p2p = NULL, *ssid = NULL;
1455 char flag_str[64];
1456 int ielen = 0;
1457 u32 wpsielen = 0;
1458 #ifdef CONFIG_RTW_MESH
1459 const char *ssid_title_str = "ssid/mesh_id";
1460 #else
1461 const char *ssid_title_str = "ssid";
1462 #endif
1463
1464 _rtw_spinlock_bh(&(pmlmepriv->scanned_queue.lock));
1465 phead = get_list_head(queue);
1466 if (!phead)
1467 goto _exit;
1468 plist = get_next(phead);
1469 if (!plist)
1470 goto _exit;
1471
1472 RTW_PRINT_SEL(m, "%5s %-17s %3s %-3s %-4s %-4s %5s %32s %32s\n", "index", "bssid", "ch", "RSSI", "SdBm", "Noise", "age", "flag", ssid_title_str);
1473 while (1) {
1474 if (rtw_end_of_queue_search(phead, plist) == _TRUE)
1475 break;
1476
1477 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
1478 if (!pnetwork)
1479 break;
1480
1481 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE &&
1482 is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network)) {
1483 notify_signal = rtw_phl_rssi_to_dbm(padapter->recvinfo.signal_strength);/* dbm */
1484 } else {
1485 notify_signal = rtw_phl_rssi_to_dbm(pnetwork->network.PhyInfo.SignalStrength);/* dbm */
1486 }
1487
1488 #if 0 /*def CONFIG_BACKGROUND_NOISE_MONITOR*/
1489 if (IS_NM_ENABLE(padapter))
1490 notify_noise = rtw_noise_query_by_chan_num(padapter, pnetwork->network.Configuration.DSConfig);
1491 #endif
1492
1493 ie_wpa = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength - 12);
1494 ie_wpa2 = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength - 12);
1495 ie_cap = rtw_get_capability(&pnetwork->network);
1496 ie_wps = rtw_get_wps_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &wpsielen);
1497 ie_p2p = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &ielen);
1498 ssid = pnetwork->network.Ssid.Ssid;
1499 sprintf(flag_str, "%s%s%s%s%s%s%s%s",
1500 (ie_wpa) ? "[WPA]" : "",
1501 (ie_wpa2) ? "[WPA2]" : "",
1502 (!ie_wpa && !ie_wpa && ie_cap & BIT(4)) ? "[WEP]" : "",
1503 (ie_wps) ? "[WPS]" : "",
1504 (pnetwork->network.InfrastructureMode == Ndis802_11IBSS) ? "[IBSS]" :
1505 (pnetwork->network.InfrastructureMode == Ndis802_11_mesh) ? "[MESH]" : "",
1506 (ie_cap & BIT(0)) ? "[ESS]" : "",
1507 (pnetwork->network.Reserved[0] == BSS_TYPE_BCN) ? "[B]" : \
1508 (pnetwork->network.Reserved[0] == BSS_TYPE_PROB_RSP) ? "[P]" : "[U]",
1509 (ie_p2p) ? "[P2P]" : "");
1510 RTW_PRINT_SEL(m, "%5d "MAC_FMT" %3d %3d %4d %4d %5d %32s %32s\n",
1511 ++index,
1512 MAC_ARG(pnetwork->network.MacAddress),
1513 pnetwork->network.Configuration.DSConfig,
1514 pnetwork->network.PhyInfo.rssi,
1515 notify_signal,
1516 notify_noise,
1517 rtw_get_passing_time_ms(pnetwork->last_scanned),
1518 flag_str,
1519 pnetwork->network.InfrastructureMode == Ndis802_11_mesh ? pnetwork->network.mesh_id.Ssid : pnetwork->network.Ssid.Ssid
1520 );
1521 plist = get_next(plist);
1522 }
1523 _exit:
1524 _rtw_spinunlock_bh(&(pmlmepriv->scanned_queue.lock));
1525
1526 return 0;
1527 }
1528
proc_set_survey_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1529 ssize_t proc_set_survey_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1530 {
1531 struct net_device *dev = data;
1532 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1533 u8 _status = _FALSE;
1534 u8 ssc_chk;
1535 char tmp[32] = {0};
1536 char cmd[8] = {0};
1537 bool acs = 0;
1538
1539 if (count < 1)
1540 return -EFAULT;
1541
1542 if (count > sizeof(tmp)) {
1543 rtw_warn_on(1);
1544 return -EFAULT;
1545 }
1546
1547 if (buffer && !copy_from_user(tmp, buffer, count)) {
1548 int num = sscanf(tmp, "%s", cmd);
1549
1550 if (num < 1)
1551 return count;
1552
1553 if (strcmp("acs", cmd) == 0)
1554 acs = 1;
1555 }
1556
1557 #if 1
1558 ssc_chk = rtw_sitesurvey_condition_check(padapter, _FALSE);
1559 if (ssc_chk != SS_ALLOW)
1560 goto exit;
1561
1562 rtw_ps_deny(padapter, PS_DENY_SCAN);
1563 if (_FAIL == rtw_pwr_wakeup(padapter))
1564 goto cancel_ps_deny;
1565 if (!rtw_is_adapter_up(padapter)) {
1566 RTW_INFO("scan abort!! adapter cannot use\n");
1567 goto cancel_ps_deny;
1568 }
1569 #else
1570 #ifdef CONFIG_MP_INCLUDED
1571 if (rtw_mp_mode_check(padapter)) {
1572 RTW_INFO("MP mode block Scan request\n");
1573 goto exit;
1574 }
1575 #endif
1576 if (rtw_is_scan_deny(padapter)) {
1577 RTW_INFO(FUNC_ADPT_FMT ": scan deny\n", FUNC_ADPT_ARG(padapter));
1578 goto exit;
1579 }
1580
1581 rtw_ps_deny(padapter, PS_DENY_SCAN);
1582 if (_FAIL == rtw_pwr_wakeup(padapter))
1583 goto cancel_ps_deny;
1584
1585 if (!rtw_is_adapter_up(padapter)) {
1586 RTW_INFO("scan abort!! adapter cannot use\n");
1587 goto cancel_ps_deny;
1588 }
1589
1590 if (rtw_mi_busy_traffic_check(padapter)) {
1591 RTW_INFO("scan abort!! BusyTraffic == _TRUE\n");
1592 goto cancel_ps_deny;
1593 }
1594
1595 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) && check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
1596 RTW_INFO("scan abort!! AP mode process WPS\n");
1597 goto cancel_ps_deny;
1598 }
1599 if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY | WIFI_UNDER_LINKING) == _TRUE) {
1600 RTW_INFO("scan abort!! fwstate=0x%x\n", pmlmepriv->fw_state);
1601 goto cancel_ps_deny;
1602 }
1603
1604 #ifdef CONFIG_CONCURRENT_MODE
1605 if (rtw_mi_buddy_check_fwstate(padapter,
1606 WIFI_UNDER_SURVEY | WIFI_UNDER_LINKING | WIFI_UNDER_WPS)) {
1607 RTW_INFO("scan abort!! buddy_fwstate check failed\n");
1608 goto cancel_ps_deny;
1609 }
1610 #endif
1611 #endif
1612
1613 if (acs) {
1614 #ifdef CONFIG_RTW_ACS
1615 _status = rtw_set_acs_sitesurvey(padapter);
1616 #endif
1617 } else
1618 _status = rtw_sitesurvey_cmd(padapter, NULL);
1619
1620 cancel_ps_deny:
1621 rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
1622 exit:
1623 return count;
1624 }
1625 #ifdef ROKU_PRIVATE
proc_get_infra_ap(struct seq_file * m,void * v)1626 int proc_get_infra_ap(struct seq_file *m, void *v)
1627 {
1628 struct net_device *dev = m->private;
1629 struct sta_info *psta;
1630 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1631 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1632 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1633 struct ht_priv_infra_ap *phtpriv = &pmlmepriv->htpriv_infra_ap;
1634 #ifdef CONFIG_80211AC_VHT
1635 struct vht_priv_infra_ap *pvhtpriv = &pmlmepriv->vhtpriv_infra_ap;
1636 #endif
1637 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1638 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1639 struct sta_priv *pstapriv = &padapter->stapriv;
1640
1641 if (MLME_IS_STA(padapter)) {
1642 psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
1643 if (psta) {
1644 unsigned int i, j;
1645 unsigned int Rx_ss = 0, Tx_ss = 0;
1646
1647 RTW_PRINT_SEL(m, "SSID=%s\n", pmlmeinfo->network.Ssid.Ssid);
1648 RTW_PRINT_SEL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
1649 RTW_PRINT_SEL(m, "Supported rate=");
1650 for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
1651 if (pmlmeinfo->SupportedRates_infra_ap[i] == 0)
1652 break;
1653 RTW_PRINT_SEL(m, " 0x%x", pmlmeinfo->SupportedRates_infra_ap[i]);
1654 }
1655 RTW_PRINT_SEL(m, "\n");
1656 #ifdef CONFIG_80211N_HT
1657 if (pmlmeinfo->ht_vht_received & BIT(0)) {
1658 RTW_PRINT_SEL(m, "Supported MCS set=");
1659 for (i = 0; i < 16 ; i++)
1660 RTW_PRINT_SEL(m, " 0x%02x", phtpriv->MCS_set_infra_ap[i]);
1661 RTW_PRINT_SEL(m, "\n");
1662 RTW_PRINT_SEL(m, "highest supported data rate=0x%x\n", phtpriv->rx_highest_data_rate_infra_ap);
1663 RTW_PRINT_SEL(m, "HT_supported_channel_width_set=0x%x\n", phtpriv->channel_width_infra_ap);
1664 RTW_PRINT_SEL(m, "sgi_20m=%d, sgi_40m=%d\n", phtpriv->sgi_20m_infra_ap, phtpriv->sgi_40m_infra_ap);
1665 RTW_PRINT_SEL(m, "ldpc_cap=0x%x, stbc_cap=0x%x\n", phtpriv->ldpc_cap_infra_ap, phtpriv->stbc_cap_infra_ap);
1666 RTW_PRINT_SEL(m, "HT_number_of_stream=%d\n", phtpriv->Rx_ss_infra_ap);
1667 }
1668 #endif
1669
1670 #ifdef CONFIG_80211AC_VHT
1671 if (pmlmeinfo->ht_vht_received & BIT(1)) {
1672 RTW_PRINT_SEL(m, "VHT_supported_channel_width_set=0x%x\n", pvhtpriv->channel_width_infra_ap);
1673 RTW_PRINT_SEL(m, "vht_ldpc_cap=0x%x, vht_stbc_cap=0x%x, vht_beamform_cap=0x%x\n", pvhtpriv->ldpc_cap_infra_ap, pvhtpriv->stbc_cap_infra_ap, pvhtpriv->beamform_cap_infra_ap);
1674 RTW_PRINT_SEL(m, "Rx_vht_mcs_map=0x%x, Tx_vht_mcs_map=0x%x\n", *(u16 *)pvhtpriv->vht_mcs_map_infra_ap, *(u16 *)pvhtpriv->vht_mcs_map_tx_infra_ap);
1675 RTW_PRINT_SEL(m, "VHT_number_of_stream=%d\n", pvhtpriv->number_of_streams_infra_ap);
1676 }
1677 #endif
1678 } else
1679 RTW_PRINT_SEL(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
1680 } else
1681 RTW_PRINT_SEL(m, "this only applies to STA mode\n");
1682 return 0;
1683 }
1684
1685 #endif /* ROKU_PRIVATE */
1686
wireless_mode_to_str(u32 mode,char * str)1687 static int wireless_mode_to_str(u32 mode, char *str)
1688 {
1689 str[0]='\0';
1690 if (mode & WLAN_MD_11A)
1691 sprintf(str+strlen(str),"%s","A/");
1692 if (mode & WLAN_MD_11B)
1693 sprintf(str+strlen(str),"%s","B/");
1694 if (mode & WLAN_MD_11G)
1695 sprintf(str+strlen(str),"%s","G/");
1696 #ifdef CONFIG_80211N_HT
1697 if (mode & WLAN_MD_11N)
1698 sprintf(str+strlen(str),"%s","N/");
1699 #endif
1700 #ifdef CONFIG_80211AC_VHT
1701 if (mode & WLAN_MD_11AC)
1702 sprintf(str+strlen(str),"%s","AC/");
1703 #endif
1704 #ifdef CONFIG_80211AX_HE
1705 if (mode & WLAN_MD_11AX)
1706 sprintf(str+strlen(str),"%s","AX/");
1707 #endif
1708 if (strlen(str)>1)
1709 str[strlen(str)-1]='\0';
1710
1711 return strlen(str);
1712 }
1713
proc_get_ap_info(struct seq_file * m,void * v)1714 int proc_get_ap_info(struct seq_file *m, void *v)
1715 {
1716 struct net_device *dev = m->private;
1717 struct sta_info *psta;
1718 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1719 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1720 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1721 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1722 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1723 struct sta_priv *pstapriv = &padapter->stapriv;
1724 char wl_mode[16];
1725
1726 /* ap vendor */
1727 char vendor[VENDOR_NAME_LEN] = {0};
1728 get_assoc_AP_Vendor(vendor,pmlmeinfo->assoc_AP_vendor);
1729 RTW_PRINT_SEL(m,"AP Vendor %s\n", vendor);
1730
1731 psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
1732 if (psta) {
1733 wireless_mode_to_str(psta->phl_sta->wmode, wl_mode);
1734 RTW_PRINT_SEL(m, "SSID=%s\n", cur_network->network.Ssid.Ssid);
1735 RTW_PRINT_SEL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
1736 RTW_PRINT_SEL(m, "cur_channel=%d, cur_bwmode=%d(%s), cur_ch_offset=%d\n", pmlmeext->chandef.chan, pmlmeext->chandef.bw, ch_width_str(pmlmeext->chandef.bw), pmlmeext->chandef.offset);
1737 RTW_PRINT_SEL(m, "wireless_mode=0x%x(%s), rtsen=%d, cts2slef=%d hw_rts_en=%d\n",
1738 psta->phl_sta->wmode, wl_mode, psta->rtsen, psta->cts2self, psta->hw_rts_en);
1739 /* ToDo: need API to query hal_sta->ra_info.rate_id */
1740 /* RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n",
1741 psta->state, psta->phl_sta->aid, psta->phl_sta->macid, psta->phl_sta->ra_info.rate_id); */
1742 RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d\n",
1743 psta->state, psta->phl_sta->aid, psta->phl_sta->macid);
1744 #ifdef CONFIG_80211N_HT
1745 RTW_PRINT_SEL(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
1746 RTW_PRINT_SEL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n"
1747 , psta->phl_sta->chandef.bw, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
1748 RTW_PRINT_SEL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
1749 RTW_PRINT_SEL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
1750 RTW_PRINT_SEL(m, "ldpc_cap=0x%x, stbc_cap=0x%x, beamform_cap=0x%x\n", psta->htpriv.ldpc_cap, psta->htpriv.stbc_cap, psta->htpriv.beamform_cap);
1751 #endif /* CONFIG_80211N_HT */
1752 if (MLME_IS_AP(padapter))
1753 RTW_PRINT_SEL(m, " VHT or HE IE is configured by upper layer : %s\n", pmlmepriv->upper_layer_setting ? "True" : "False");
1754 #ifdef CONFIG_80211AC_VHT
1755 RTW_PRINT_SEL(m, "vht_en=%u, vht_sgi_80m=%u\n", psta->vhtpriv.vht_option, psta->vhtpriv.sgi_80m);
1756 RTW_PRINT_SEL(m, "vht_ldpc_cap=0x%x, vht_stbc_cap=0x%x, vht_beamform_cap=0x%x\n", psta->vhtpriv.ldpc_cap, psta->vhtpriv.stbc_cap, psta->vhtpriv.beamform_cap);
1757 RTW_PRINT_SEL(m, "vht_mcs_map=0x%x, vht_highest_rate=0x%x, vht_ampdu_len=%d\n", *(u16 *)psta->vhtpriv.vht_mcs_map, psta->vhtpriv.vht_highest_rate, psta->vhtpriv.ampdu_len);
1758 if (psta->vhtpriv.vht_option) {
1759 RTW_MAP_DUMP_SEL_ALWAYS(m, "vht_cap=", psta->vhtpriv.vht_cap, 32);
1760 } else {
1761 RTW_PRINT_SEL(m, "vht_cap=N/A\n");
1762 }
1763 #endif
1764 #ifdef CONFIG_80211AX_HE
1765 RTW_PRINT_SEL(m, "he_en=%d\n", psta->hepriv.he_option);
1766 if (psta->hepriv.he_option) {
1767 RTW_MAP_DUMP_SEL_ALWAYS(m, "he_cap=", psta->hepriv.he_cap, HE_CAP_ELE_MAX_LEN);
1768 } else {
1769 RTW_PRINT_SEL(m, "he_cap=N/A\n");
1770 }
1771 #endif
1772 #ifdef CONFIG_RECV_REORDERING_CTRL
1773 sta_rx_reorder_ctl_dump(m, psta);
1774 #endif
1775 } else
1776 RTW_PRINT_SEL(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
1777
1778 return 0;
1779 }
1780
proc_reset_trx_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1781 ssize_t proc_reset_trx_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1782 {
1783 struct net_device *dev = data;
1784 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1785 struct recv_info *precvinfo = &padapter->recvinfo;
1786 char cmd[32] = {0};
1787 u8 cnt = 0;
1788
1789 if (count > sizeof(cmd)) {
1790 rtw_warn_on(1);
1791 return -EFAULT;
1792 }
1793
1794 if (buffer && !copy_from_user(cmd, buffer, count)) {
1795 int num = sscanf(cmd, "%hhx", &cnt);
1796
1797 if (num == 1 && cnt == 0) {
1798 precvinfo->dbg_rx_ampdu_drop_count = 0;
1799 precvinfo->dbg_rx_ampdu_forced_indicate_count = 0;
1800 precvinfo->dbg_rx_ampdu_loss_count = 0;
1801 precvinfo->dbg_rx_dup_mgt_frame_drop_count = 0;
1802 precvinfo->dbg_rx_ampdu_window_shift_cnt = 0;
1803 precvinfo->dbg_rx_conflic_mac_addr_cnt = 0;
1804 precvinfo->dbg_rx_drop_count = 0;
1805 }
1806 }
1807
1808 return count;
1809 }
1810
proc_get_trx_info(struct seq_file * m,void * v)1811 int proc_get_trx_info(struct seq_file *m, void *v)
1812 {
1813 struct net_device *dev = m->private;
1814 int i;
1815 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1816 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1817 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1818 struct recv_info *precvinfo = &padapter->recvinfo;
1819 struct recv_priv *precvpriv = &adapter_to_dvobj(padapter)->recvpriv;
1820 struct hw_xmit *phwxmit;
1821 struct trx_data_buf_q *litexmitbuf_q = &dvobj->litexmitbuf_q;
1822 struct trx_data_buf_q *literecvbuf_q = &dvobj->literecvbuf_q;
1823 #ifdef CONFIG_USB_HCI
1824 struct trx_urb_buf_q *xmit_urb_q = &dvobj->xmit_urb_q;
1825 struct trx_urb_buf_q *recv_urb_q = &dvobj->recv_urb_q;
1826 #endif
1827 u16 vo_params[4]={0}, vi_params[4]={0}, be_params[4]={0}, bk_params[4]={0};
1828
1829 rtw_hal_read_edca(padapter, vo_params, vi_params, be_params, bk_params);
1830
1831 RTW_PRINT_SEL(m, "wmm_edca_vo, aifs = %u us, cw_min = %u, cw_max = %u, txop_limit = %u us\n", vo_params[0], vo_params[1], vo_params[2], vo_params[3]);
1832 RTW_PRINT_SEL(m, "wmm_edca_vi, aifs = %u us, cw_min = %u, cw_max = %u, txop_limit = %u us\n", vi_params[0], vi_params[1], vi_params[2], vi_params[3]);
1833 RTW_PRINT_SEL(m, "wmm_edca_be, aifs = %u us, cw_min = %u, cw_max = %u, txop_limit = %u us\n", be_params[0], be_params[1], be_params[2], be_params[3]);
1834 RTW_PRINT_SEL(m, "wmm_edca_bk, aifs = %u us, cw_min = %u, cw_max = %u, txop_limit = %u us\n", bk_params[0], bk_params[1], bk_params[2], bk_params[3]);
1835
1836 dump_os_queue(m, padapter);
1837
1838 #if 0 /*CONFIG_CORE_XMITBUF*/
1839 RTW_PRINT_SEL(m, "free_xmitbuf_cnt=%d\n"
1840 , pxmitpriv->free_xmitbuf_cnt);
1841 RTW_PRINT_SEL(m, "free_ext_xmitbuf_cnt=%d\n"
1842 , pxmitpriv->free_xmit_extbuf_cnt);
1843 #endif
1844
1845 RTW_PRINT_SEL(m, "free_xmitframe_cnt=%d\n"
1846 , pxmitpriv->free_xmitframe_cnt);
1847 RTW_PRINT_SEL(m, "free_xframe_ext_cnt=%d\n"
1848 , pxmitpriv->free_xframe_ext_cnt);
1849 RTW_PRINT_SEL(m, "free_recvframe_cnt=%d\n"
1850 , precvpriv->free_recvframe_cnt);
1851
1852 RTW_PRINT_SEL(m, "free_litexmitbuf_cnt=%d\n"
1853 , litexmitbuf_q->free_data_buf_cnt);
1854 RTW_PRINT_SEL(m, "free_recvbuf_cnt=%d\n"
1855 , literecvbuf_q->free_data_buf_cnt);
1856
1857 for (i = 0; i < 4; i++) {
1858 phwxmit = pxmitpriv->hwxmits + i;
1859 RTW_PRINT_SEL(m, "%d, hwq.accnt=%d\n", i, phwxmit->accnt);
1860 }
1861
1862 rtw_hal_get_hwreg(padapter, HW_VAR_DUMP_MAC_TXFIFO, (u8 *)m);
1863
1864 #ifdef CONFIG_USB_HCI
1865 RTW_PRINT_SEL(m, "tx_urb_cnt=%d\n", xmit_urb_q->free_urb_buf_cnt);
1866 RTW_PRINT_SEL(m, "rx_urb_cnt=%d\n", recv_urb_q->free_urb_buf_cnt);
1867 RTW_PRINT_SEL(m, "rx_urb_pending_cn=%d\n", ATOMIC_READ(&(dvobj->rx_pending_cnt)));
1868 #endif
1869
1870 /* Folowing are RX info */
1871 RTW_PRINT_SEL(m, "RX: Count of Packets dropped by Driver: %llu\n", (unsigned long long)precvinfo->dbg_rx_drop_count);
1872 /* Counts of packets whose seq_num is less than preorder_ctrl->indicate_seq, Ex delay, retransmission, redundant packets and so on */
1873 RTW_PRINT_SEL(m, "Rx: Counts of Packets Whose Seq_Num Less Than Reorder Control Seq_Num: %llu\n", (unsigned long long)precvinfo->dbg_rx_ampdu_drop_count);
1874 /* How many times the Rx Reorder Timer is triggered. */
1875 RTW_PRINT_SEL(m, "Rx: Reorder Time-out Trigger Counts: %llu\n", (unsigned long long)precvinfo->dbg_rx_ampdu_forced_indicate_count);
1876 /* Total counts of packets loss */
1877 RTW_PRINT_SEL(m, "Rx: Packet Loss Counts: %llu\n", (unsigned long long)precvinfo->dbg_rx_ampdu_loss_count);
1878 RTW_PRINT_SEL(m, "Rx: Duplicate Management Frame Drop Count: %llu\n", (unsigned long long)precvinfo->dbg_rx_dup_mgt_frame_drop_count);
1879 RTW_PRINT_SEL(m, "Rx: AMPDU BA window shift Count: %llu\n", (unsigned long long)precvinfo->dbg_rx_ampdu_window_shift_cnt);
1880 /*The same mac addr counts*/
1881 RTW_PRINT_SEL(m, "Rx: Conflict MAC Address Frames Count: %llu\n", (unsigned long long)precvinfo->dbg_rx_conflic_mac_addr_cnt);
1882 return 0;
1883 }
1884
rtw_data_rate_str(enum rtw_data_rate rate)1885 static const char *rtw_data_rate_str(enum rtw_data_rate rate)
1886 {
1887 if (rate >= RTW_DATA_RATE_CCK1 && rate <= RTW_DATA_RATE_CCK11) {
1888 switch (rate) {
1889 #define CASE_CCK_RATE(cck) case RTW_DATA_RATE_CCK ## cck: return "CCK_" # cck "M"
1890 CASE_CCK_RATE(1);
1891 CASE_CCK_RATE(2);
1892 CASE_CCK_RATE(5_5);
1893 CASE_CCK_RATE(11);
1894 #undef CASE_CCK_RATE
1895 default:
1896 return "CCK_UNKNOWN";
1897 }
1898 } else if (rate >= RTW_DATA_RATE_OFDM6 && rate <= RTW_DATA_RATE_OFDM54) {
1899 switch (rate) {
1900 #define CASE_OFDM_RATE(ofdm) case RTW_DATA_RATE_OFDM ## ofdm: return "OFDM_" # ofdm "M"
1901 CASE_OFDM_RATE(6);
1902 CASE_OFDM_RATE(9);
1903 CASE_OFDM_RATE(12);
1904 CASE_OFDM_RATE(18);
1905 CASE_OFDM_RATE(24);
1906 CASE_OFDM_RATE(36);
1907 CASE_OFDM_RATE(48);
1908 CASE_OFDM_RATE(54);
1909 #undef CASE_OFDM_RATE
1910 default:
1911 return "OFDM_UNKNOWN";
1912 }
1913 } else if (rate >= RTW_DATA_RATE_MCS0 && rate <= RTW_DATA_RATE_MCS31) {
1914 switch (rate) {
1915 #define CASE_HT_RATE(mcs) case RTW_DATA_RATE_MCS ## mcs: return "MCS_" # mcs
1916 CASE_HT_RATE(0);
1917 CASE_HT_RATE(1);
1918 CASE_HT_RATE(2);
1919 CASE_HT_RATE(3);
1920 CASE_HT_RATE(4);
1921 CASE_HT_RATE(5);
1922 CASE_HT_RATE(6);
1923 CASE_HT_RATE(7);
1924 CASE_HT_RATE(8);
1925 CASE_HT_RATE(9);
1926 CASE_HT_RATE(10);
1927 CASE_HT_RATE(11);
1928 CASE_HT_RATE(12);
1929 CASE_HT_RATE(13);
1930 CASE_HT_RATE(14);
1931 CASE_HT_RATE(15);
1932 CASE_HT_RATE(16);
1933 CASE_HT_RATE(17);
1934 CASE_HT_RATE(18);
1935 CASE_HT_RATE(19);
1936 CASE_HT_RATE(20);
1937 CASE_HT_RATE(21);
1938 CASE_HT_RATE(22);
1939 CASE_HT_RATE(23);
1940 CASE_HT_RATE(24);
1941 CASE_HT_RATE(25);
1942 CASE_HT_RATE(26);
1943 CASE_HT_RATE(27);
1944 CASE_HT_RATE(28);
1945 CASE_HT_RATE(29);
1946 CASE_HT_RATE(30);
1947 CASE_HT_RATE(31);
1948 #undef CASE_HT_RATE
1949 default:
1950 return "HT_UNKNOWN";
1951 }
1952 } else if (rate >= RTW_DATA_RATE_VHT_NSS1_MCS0 && rate <= RTW_DATA_RATE_VHT_NSS4_MCS9) {
1953 switch (rate) {
1954 #define CASE_VHT_RATE(ss, mcs) case RTW_DATA_RATE_VHT_NSS ## ss ##_MCS ##mcs: return "VHT_SS" #ss "MCS" #mcs
1955 CASE_VHT_RATE(1, 0);
1956 CASE_VHT_RATE(1, 1);
1957 CASE_VHT_RATE(1, 2);
1958 CASE_VHT_RATE(1, 3);
1959 CASE_VHT_RATE(1, 4);
1960 CASE_VHT_RATE(1, 5);
1961 CASE_VHT_RATE(1, 6);
1962 CASE_VHT_RATE(1, 7);
1963 CASE_VHT_RATE(1, 8);
1964 CASE_VHT_RATE(1, 9);
1965 CASE_VHT_RATE(2, 0);
1966 CASE_VHT_RATE(2, 1);
1967 CASE_VHT_RATE(2, 2);
1968 CASE_VHT_RATE(2, 3);
1969 CASE_VHT_RATE(2, 4);
1970 CASE_VHT_RATE(2, 5);
1971 CASE_VHT_RATE(2, 6);
1972 CASE_VHT_RATE(2, 7);
1973 CASE_VHT_RATE(2, 8);
1974 CASE_VHT_RATE(2, 9);
1975 CASE_VHT_RATE(3, 0);
1976 CASE_VHT_RATE(3, 1);
1977 CASE_VHT_RATE(3, 2);
1978 CASE_VHT_RATE(3, 3);
1979 CASE_VHT_RATE(3, 4);
1980 CASE_VHT_RATE(3, 5);
1981 CASE_VHT_RATE(3, 6);
1982 CASE_VHT_RATE(3, 7);
1983 CASE_VHT_RATE(3, 8);
1984 CASE_VHT_RATE(3, 9);
1985 CASE_VHT_RATE(4, 0);
1986 CASE_VHT_RATE(4, 1);
1987 CASE_VHT_RATE(4, 2);
1988 CASE_VHT_RATE(4, 3);
1989 CASE_VHT_RATE(4, 4);
1990 CASE_VHT_RATE(4, 5);
1991 CASE_VHT_RATE(4, 6);
1992 CASE_VHT_RATE(4, 7);
1993 CASE_VHT_RATE(4, 8);
1994 CASE_VHT_RATE(4, 9);
1995 #undef CASE_VHT_RATE
1996 default:
1997 return "VHT_UNKNOWN";
1998 }
1999 } else if (rate >= RTW_DATA_RATE_HE_NSS1_MCS0 && rate <= RTW_DATA_RATE_HE_NSS4_MCS11) {
2000 switch (rate) {
2001 #define CASE_HE_RATE(ss, mcs) case RTW_DATA_RATE_HE_NSS ## ss ##_MCS ##mcs: return "HE_SS" #ss "MCS" #mcs
2002 CASE_HE_RATE(1, 0);
2003 CASE_HE_RATE(1, 1);
2004 CASE_HE_RATE(1, 2);
2005 CASE_HE_RATE(1, 3);
2006 CASE_HE_RATE(1, 4);
2007 CASE_HE_RATE(1, 5);
2008 CASE_HE_RATE(1, 6);
2009 CASE_HE_RATE(1, 7);
2010 CASE_HE_RATE(1, 8);
2011 CASE_HE_RATE(1, 9);
2012 CASE_HE_RATE(1, 10);
2013 CASE_HE_RATE(1, 11);
2014 CASE_HE_RATE(2, 0);
2015 CASE_HE_RATE(2, 1);
2016 CASE_HE_RATE(2, 2);
2017 CASE_HE_RATE(2, 3);
2018 CASE_HE_RATE(2, 4);
2019 CASE_HE_RATE(2, 5);
2020 CASE_HE_RATE(2, 6);
2021 CASE_HE_RATE(2, 7);
2022 CASE_HE_RATE(2, 8);
2023 CASE_HE_RATE(2, 9);
2024 CASE_HE_RATE(2, 10);
2025 CASE_HE_RATE(2, 11);
2026 CASE_HE_RATE(3, 0);
2027 CASE_HE_RATE(3, 1);
2028 CASE_HE_RATE(3, 2);
2029 CASE_HE_RATE(3, 3);
2030 CASE_HE_RATE(3, 4);
2031 CASE_HE_RATE(3, 5);
2032 CASE_HE_RATE(3, 6);
2033 CASE_HE_RATE(3, 7);
2034 CASE_HE_RATE(3, 8);
2035 CASE_HE_RATE(3, 9);
2036 CASE_HE_RATE(3, 10);
2037 CASE_HE_RATE(3, 11);
2038 CASE_HE_RATE(4, 0);
2039 CASE_HE_RATE(4, 1);
2040 CASE_HE_RATE(4, 2);
2041 CASE_HE_RATE(4, 3);
2042 CASE_HE_RATE(4, 4);
2043 CASE_HE_RATE(4, 5);
2044 CASE_HE_RATE(4, 6);
2045 CASE_HE_RATE(4, 7);
2046 CASE_HE_RATE(4, 8);
2047 CASE_HE_RATE(4, 9);
2048 CASE_HE_RATE(4, 10);
2049 CASE_HE_RATE(4, 11);
2050 #undef CASE_HE_RATE
2051 default:
2052 return "HE_UNKNOWN";
2053 }
2054 }
2055
2056 return "ALL_UNKNOWN";
2057 }
2058
proc_get_rate_ctl(struct seq_file * m,void * v)2059 int proc_get_rate_ctl(struct seq_file *m, void *v)
2060 {
2061 struct net_device *dev = m->private;
2062 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2063 u16 data_rate = 0;
2064 u8 sgi = 0, data_fb = 0;
2065
2066 if (adapter->fix_rate != NO_FIX_RATE) {
2067 data_rate = GET_FIX_RATE(adapter->fix_rate);
2068 sgi = GET_FIX_RATE_SGI(adapter->fix_rate);
2069 data_fb = adapter->data_fb ? 1 : 0;
2070 RTW_PRINT_SEL(m, "FIXED %s%s%s\n"
2071 , rtw_data_rate_str(data_rate)
2072 , data_rate >= RTW_DATA_RATE_MCS0 ? (sgi ? " SGI" : " LGI") : ""
2073 , data_fb ? " FB" : ""
2074 );
2075 RTW_PRINT_SEL(m, "0x%02x %u\n", adapter->fix_rate, adapter->data_fb);
2076 } else
2077 RTW_PRINT_SEL(m, "RA\n");
2078
2079 return 0;
2080 }
2081
proc_set_rate_ctl(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2082 ssize_t proc_set_rate_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2083 {
2084 struct net_device *dev = data;
2085 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2086 char tmp[32];
2087 u16 fix_rate = NO_FIX_RATE;
2088 u8 data_fb = 0;
2089
2090
2091 if (count < 1)
2092 return -EFAULT;
2093
2094 if (count > sizeof(tmp)) {
2095 rtw_warn_on(1);
2096 return -EFAULT;
2097 }
2098
2099 if (buffer && !copy_from_user(tmp, buffer, count)) {
2100 int num = sscanf(tmp, "%hx %hhu", &fix_rate, &data_fb);
2101
2102 if (num >= 1) {
2103 u16 fix_rate_ori = adapter->fix_rate;
2104
2105 adapter->fix_rate = fix_rate;
2106 #if 0 /*GEORGIA_TODO_FIXIT*/
2107 if (fix_rate == 0xFF)
2108 hal_data->ForcedDataRate = 0;
2109 else
2110 hal_data->ForcedDataRate = hwrate_to_mrate(fix_rate & 0x7F);
2111 #endif
2112 if (adapter->fix_bw != NO_FIX_BW && fix_rate_ori != fix_rate)
2113 rtw_run_in_thread_cmd(adapter, ((void *)(rtw_update_tx_rate_bmp)), adapter_to_dvobj(adapter));
2114 }
2115 if (num >= 2)
2116 adapter->data_fb = data_fb ? 1 : 0;
2117 }
2118
2119 return count;
2120 }
2121
2122 #ifdef CONFIG_AP_MODE
proc_get_bmc_tx_rate(struct seq_file * m,void * v)2123 int proc_get_bmc_tx_rate(struct seq_file *m, void *v)
2124 {
2125 struct net_device *dev = m->private;
2126 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2127
2128 if (!MLME_IS_AP(adapter) && !MLME_IS_MESH(adapter)) {
2129 RTW_PRINT_SEL(m, "[ERROR] Not in SoftAP/Mesh mode !!\n");
2130 return 0;
2131 }
2132
2133 RTW_PRINT_SEL(m, " BMC Tx rate - %s\n", MGN_RATE_STR(adapter->bmc_tx_rate));
2134 return 0;
2135 }
2136
proc_set_bmc_tx_rate(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2137 ssize_t proc_set_bmc_tx_rate(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2138 {
2139 struct net_device *dev = data;
2140 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2141 char tmp[32];
2142 u8 bmc_tx_rate;
2143
2144 if (count < 1)
2145 return -EFAULT;
2146
2147 if (count > sizeof(tmp)) {
2148 rtw_warn_on(1);
2149 return -EFAULT;
2150 }
2151
2152 if (buffer && !copy_from_user(tmp, buffer, count)) {
2153
2154 int num = sscanf(tmp, "%hhx", &bmc_tx_rate);
2155
2156 if (num >= 1)
2157 /*adapter->bmc_tx_rate = hwrate_to_mrate(bmc_tx_rate);*/
2158 adapter->bmc_tx_rate = bmc_tx_rate;
2159 }
2160
2161 return count;
2162 }
2163 #endif /*CONFIG_AP_MODE*/
2164
2165
proc_get_tx_power_offset(struct seq_file * m,void * v)2166 int proc_get_tx_power_offset(struct seq_file *m, void *v)
2167 {
2168 struct net_device *dev = m->private;
2169 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2170
2171 RTW_PRINT_SEL(m, "Tx power offset - %u\n", adapter->power_offset);
2172 return 0;
2173 }
2174
proc_set_tx_power_offset(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2175 ssize_t proc_set_tx_power_offset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2176 {
2177 struct net_device *dev = data;
2178 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2179 char tmp[32];
2180 u8 power_offset = 0;
2181
2182 if (count < 1)
2183 return -EFAULT;
2184
2185 if (count > sizeof(tmp)) {
2186 rtw_warn_on(1);
2187 return -EFAULT;
2188 }
2189
2190 if (buffer && !copy_from_user(tmp, buffer, count)) {
2191
2192 int num = sscanf(tmp, "%hhu", &power_offset);
2193
2194 if (num >= 1) {
2195 if (power_offset > 5)
2196 power_offset = 0;
2197
2198 adapter->power_offset = power_offset;
2199 }
2200 }
2201
2202 return count;
2203 }
2204
proc_get_bw_ctl(struct seq_file * m,void * v)2205 int proc_get_bw_ctl(struct seq_file *m, void *v)
2206 {
2207 struct net_device *dev = m->private;
2208 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2209 u8 data_bw = 0;
2210
2211 if (adapter->fix_bw != NO_FIX_BW) {
2212 data_bw = adapter->fix_bw;
2213 RTW_PRINT_SEL(m, "FIXED %s\n", ch_width_str(data_bw));
2214 } else
2215 RTW_PRINT_SEL(m, "Auto\n");
2216
2217 return 0;
2218 }
2219
proc_set_bw_ctl(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2220 ssize_t proc_set_bw_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2221 {
2222 struct net_device *dev = data;
2223 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2224 char tmp[32];
2225 u8 fix_bw;
2226
2227 if (count < 1)
2228 return -EFAULT;
2229
2230 if (count > sizeof(tmp)) {
2231 rtw_warn_on(1);
2232 return -EFAULT;
2233 }
2234
2235 if (buffer && !copy_from_user(tmp, buffer, count)) {
2236 int num = sscanf(tmp, "%hhu", &fix_bw);
2237
2238 if (num >= 1) {
2239 u8 fix_bw_ori = adapter->fix_bw;
2240
2241 adapter->fix_bw = fix_bw;
2242
2243 if (adapter->fix_rate != NO_FIX_RATE && fix_bw_ori != fix_bw)
2244 rtw_run_in_thread_cmd(adapter, ((void *)(rtw_update_tx_rate_bmp)), adapter_to_dvobj(adapter));
2245 }
2246 }
2247
2248 return count;
2249 }
2250
2251 #ifdef DBG_RX_COUNTER_DUMP
proc_get_rx_cnt_dump(struct seq_file * m,void * v)2252 int proc_get_rx_cnt_dump(struct seq_file *m, void *v)
2253 {
2254 struct net_device *dev = m->private;
2255 int i;
2256 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2257
2258 RTW_PRINT_SEL(m, "BIT0- Dump RX counters of DRV\n");
2259 RTW_PRINT_SEL(m, "BIT1- Dump RX counters of MAC\n");
2260 RTW_PRINT_SEL(m, "BIT2- Dump RX counters of PHY\n");
2261 RTW_PRINT_SEL(m, "BIT3- Dump TRX data frame of DRV\n");
2262 RTW_PRINT_SEL(m, "dump_rx_cnt_mode = 0x%02x\n", adapter->dump_rx_cnt_mode);
2263
2264 return 0;
2265 }
proc_set_rx_cnt_dump(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2266 ssize_t proc_set_rx_cnt_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2267 {
2268 struct net_device *dev = data;
2269 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2270 char tmp[32];
2271 u8 dump_rx_cnt_mode;
2272
2273 if (count < 1)
2274 return -EFAULT;
2275
2276 if (count > sizeof(tmp)) {
2277 rtw_warn_on(1);
2278 return -EFAULT;
2279 }
2280
2281 if (buffer && !copy_from_user(tmp, buffer, count)) {
2282
2283 int num = sscanf(tmp, "%hhx", &dump_rx_cnt_mode);
2284
2285 if (num == 1) {
2286 rtw_dump_phy_rxcnts_preprocess(adapter, dump_rx_cnt_mode);
2287 adapter->dump_rx_cnt_mode = dump_rx_cnt_mode;
2288 }
2289 }
2290
2291 return count;
2292 }
2293 #endif
2294
2295
proc_set_del_rx_ampdu_test_case(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2296 ssize_t proc_set_del_rx_ampdu_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2297 {
2298 char tmp[32];
2299
2300 if (count < 1)
2301 return -EFAULT;
2302
2303 if (count > sizeof(tmp)) {
2304 rtw_warn_on(1);
2305 return -EFAULT;
2306 }
2307
2308 if (buffer && !copy_from_user(tmp, buffer, count))
2309 sscanf(tmp, "%hhu", &del_rx_ampdu_test_no_tx_fail);
2310
2311 return count;
2312 }
2313
proc_set_wait_hiq_empty(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2314 ssize_t proc_set_wait_hiq_empty(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2315 {
2316 char tmp[32];
2317
2318 if (count < 1)
2319 return -EFAULT;
2320
2321 if (count > sizeof(tmp)) {
2322 rtw_warn_on(1);
2323 return -EFAULT;
2324 }
2325
2326 if (buffer && !copy_from_user(tmp, buffer, count))
2327 sscanf(tmp, "%u", &g_wait_hiq_empty_ms);
2328
2329 return count;
2330 }
2331
proc_set_sta_linking_test(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2332 ssize_t proc_set_sta_linking_test(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2333 {
2334 char tmp[32];
2335
2336 if (count < 1)
2337 return -EFAULT;
2338
2339 if (count > sizeof(tmp)) {
2340 rtw_warn_on(1);
2341 return -EFAULT;
2342 }
2343
2344 if (buffer && !copy_from_user(tmp, buffer, count)) {
2345 u32 wait_ms = 0;
2346 u8 force_fail = 0;
2347 int num = sscanf(tmp, "%u %hhu", &wait_ms, &force_fail);
2348
2349 if (num >= 1)
2350 sta_linking_test_wait_ms = wait_ms;
2351 if (num >= 2)
2352 sta_linking_test_force_fail = force_fail;
2353 }
2354
2355 return count;
2356 }
2357
2358 #ifdef CONFIG_AP_MODE
proc_set_ap_linking_test(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2359 ssize_t proc_set_ap_linking_test(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2360 {
2361 char tmp[32];
2362
2363 if (count < 1)
2364 return -EFAULT;
2365
2366 if (count > sizeof(tmp)) {
2367 rtw_warn_on(1);
2368 return -EFAULT;
2369 }
2370
2371 if (buffer && !copy_from_user(tmp, buffer, count)) {
2372 u16 force_auth_fail = 0;
2373 u16 force_asoc_fail = 0;
2374 int num = sscanf(tmp, "%hu %hu", &force_auth_fail, &force_asoc_fail);
2375
2376 if (num >= 1)
2377 ap_linking_test_force_auth_fail = force_auth_fail;
2378 if (num >= 2)
2379 ap_linking_test_force_asoc_fail = force_asoc_fail;
2380 }
2381
2382 return count;
2383 }
2384 #endif /* CONFIG_AP_MODE */
2385
proc_get_ps_dbg_info(struct seq_file * m,void * v)2386 int proc_get_ps_dbg_info(struct seq_file *m, void *v)
2387 {
2388 struct net_device *dev = m->private;
2389 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2390 struct dvobj_priv *dvobj = padapter->dvobj;
2391 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
2392
2393 RTW_PRINT_SEL(m, "dbg_sdio_alloc_irq_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_cnt);
2394 RTW_PRINT_SEL(m, "dbg_sdio_free_irq_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_cnt);
2395 RTW_PRINT_SEL(m, "dbg_sdio_alloc_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_error_cnt);
2396 RTW_PRINT_SEL(m, "dbg_sdio_free_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_error_cnt);
2397 RTW_PRINT_SEL(m, "dbg_sdio_init_error_cnt=%d\n", pdbgpriv->dbg_sdio_init_error_cnt);
2398 RTW_PRINT_SEL(m, "dbg_sdio_deinit_error_cnt=%d\n", pdbgpriv->dbg_sdio_deinit_error_cnt);
2399 RTW_PRINT_SEL(m, "dbg_suspend_error_cnt=%d\n", pdbgpriv->dbg_suspend_error_cnt);
2400 RTW_PRINT_SEL(m, "dbg_suspend_cnt=%d\n", pdbgpriv->dbg_suspend_cnt);
2401 RTW_PRINT_SEL(m, "dbg_resume_cnt=%d\n", pdbgpriv->dbg_resume_cnt);
2402 RTW_PRINT_SEL(m, "dbg_resume_error_cnt=%d\n", pdbgpriv->dbg_resume_error_cnt);
2403 RTW_PRINT_SEL(m, "dbg_deinit_fail_cnt=%d\n", pdbgpriv->dbg_deinit_fail_cnt);
2404 RTW_PRINT_SEL(m, "dbg_carddisable_cnt=%d\n", pdbgpriv->dbg_carddisable_cnt);
2405 RTW_PRINT_SEL(m, "dbg_ps_insuspend_cnt=%d\n", pdbgpriv->dbg_ps_insuspend_cnt);
2406 RTW_PRINT_SEL(m, "dbg_dev_unload_inIPS_cnt=%d\n", pdbgpriv->dbg_dev_unload_inIPS_cnt);
2407 RTW_PRINT_SEL(m, "dbg_scan_pwr_state_cnt=%d\n", pdbgpriv->dbg_scan_pwr_state_cnt);
2408 RTW_PRINT_SEL(m, "dbg_downloadfw_pwr_state_cnt=%d\n", pdbgpriv->dbg_downloadfw_pwr_state_cnt);
2409 RTW_PRINT_SEL(m, "dbg_carddisable_error_cnt=%d\n", pdbgpriv->dbg_carddisable_error_cnt);
2410 RTW_PRINT_SEL(m, "dbg_fw_read_ps_state_fail_cnt=%d\n", pdbgpriv->dbg_fw_read_ps_state_fail_cnt);
2411 RTW_PRINT_SEL(m, "dbg_leave_ips_fail_cnt=%d\n", pdbgpriv->dbg_leave_ips_fail_cnt);
2412 RTW_PRINT_SEL(m, "dbg_leave_lps_fail_cnt=%d\n", pdbgpriv->dbg_leave_lps_fail_cnt);
2413 RTW_PRINT_SEL(m, "dbg_h2c_leave32k_fail_cnt=%d\n", pdbgpriv->dbg_h2c_leave32k_fail_cnt);
2414 RTW_PRINT_SEL(m, "dbg_diswow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_diswow_dload_fw_fail_cnt);
2415 RTW_PRINT_SEL(m, "dbg_enwow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_enwow_dload_fw_fail_cnt);
2416 RTW_PRINT_SEL(m, "dbg_ips_drvopen_fail_cnt=%d\n", pdbgpriv->dbg_ips_drvopen_fail_cnt);
2417 RTW_PRINT_SEL(m, "dbg_poll_fail_cnt=%d\n", pdbgpriv->dbg_poll_fail_cnt);
2418 RTW_PRINT_SEL(m, "dbg_rpwm_toogle_cnt=%d\n", pdbgpriv->dbg_rpwm_toogle_cnt);
2419 RTW_PRINT_SEL(m, "dbg_rpwm_timeout_fail_cnt=%d\n", pdbgpriv->dbg_rpwm_timeout_fail_cnt);
2420 RTW_PRINT_SEL(m, "dbg_sreset_cnt=%d\n", pdbgpriv->dbg_sreset_cnt);
2421 RTW_PRINT_SEL(m, "dbg_fw_mem_dl_error_cnt=%d\n", pdbgpriv->dbg_fw_mem_dl_error_cnt);
2422
2423 return 0;
2424 }
proc_set_ps_dbg_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2425 ssize_t proc_set_ps_dbg_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2426 {
2427 struct net_device *dev = data;
2428 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2429 struct dvobj_priv *dvobj = adapter->dvobj;
2430 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
2431 char tmp[32];
2432 u8 ps_dbg_cmd_id;
2433
2434 if (count < 1)
2435 return -EFAULT;
2436
2437 if (count > sizeof(tmp)) {
2438 rtw_warn_on(1);
2439 return -EFAULT;
2440 }
2441
2442 if (buffer && !copy_from_user(tmp, buffer, count)) {
2443
2444 int num = sscanf(tmp, "%hhx", &ps_dbg_cmd_id);
2445
2446 if (num == 1 && ps_dbg_cmd_id == 1) /*Clean all*/
2447 _rtw_memset(pdbgpriv, 0, sizeof(struct debug_priv));
2448
2449 }
2450
2451 return count;
2452 }
2453
2454
2455 #ifdef CONFIG_DBG_COUNTER
2456
proc_get_rx_logs(struct seq_file * m,void * v)2457 int proc_get_rx_logs(struct seq_file *m, void *v)
2458 {
2459 struct net_device *dev = m->private;
2460 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2461 struct rx_logs *rx_logs = &padapter->rx_logs;
2462
2463 RTW_PRINT_SEL(m,
2464 "intf_rx=%d\n"
2465 "intf_rx_err_recvframe=%d\n"
2466 "intf_rx_err_skb=%d\n"
2467 "intf_rx_report=%d\n"
2468 "core_rx=%d\n"
2469 "core_rx_pre=%d\n"
2470 "core_rx_pre_ver_err=%d\n"
2471 "core_rx_pre_mgmt=%d\n"
2472 "core_rx_pre_mgmt_err_80211w=%d\n"
2473 "core_rx_pre_mgmt_err=%d\n"
2474 "core_rx_pre_ctrl=%d\n"
2475 "core_rx_pre_ctrl_err=%d\n"
2476 "core_rx_pre_data=%d\n"
2477 "core_rx_pre_data_wapi_seq_err=%d\n"
2478 "core_rx_pre_data_wapi_key_err=%d\n"
2479 "core_rx_pre_data_handled=%d\n"
2480 "core_rx_pre_data_err=%d\n"
2481 "core_rx_pre_data_unknown=%d\n"
2482 "core_rx_pre_unknown=%d\n"
2483 "core_rx_enqueue=%d\n"
2484 "core_rx_dequeue=%d\n"
2485 "core_rx_post=%d\n"
2486 "core_rx_post_decrypt=%d\n"
2487 "core_rx_post_decrypt_wep=%d\n"
2488 "core_rx_post_decrypt_tkip=%d\n"
2489 "core_rx_post_decrypt_aes=%d\n"
2490 "core_rx_post_decrypt_wapi=%d\n"
2491 "core_rx_post_decrypt_hw=%d\n"
2492 "core_rx_post_decrypt_unknown=%d\n"
2493 "core_rx_post_decrypt_err=%d\n"
2494 "core_rx_post_defrag_err=%d\n"
2495 "core_rx_post_portctrl_err=%d\n"
2496 "core_rx_post_indicate=%d\n"
2497 "core_rx_post_indicate_in_oder=%d\n"
2498 "core_rx_post_indicate_reoder=%d\n"
2499 "core_rx_post_indicate_err=%d\n"
2500 "os_indicate=%d\n"
2501 "os_indicate_ap_mcast=%d\n"
2502 "os_indicate_ap_forward=%d\n"
2503 "os_indicate_ap_self=%d\n"
2504 "os_indicate_err=%d\n"
2505 "os_netif_ok=%d\n"
2506 "os_netif_err=%d\n",
2507 rx_logs->intf_rx,
2508 rx_logs->intf_rx_err_recvframe,
2509 rx_logs->intf_rx_err_skb,
2510 rx_logs->intf_rx_report,
2511 rx_logs->core_rx,
2512 rx_logs->core_rx_pre,
2513 rx_logs->core_rx_pre_ver_err,
2514 rx_logs->core_rx_pre_mgmt,
2515 rx_logs->core_rx_pre_mgmt_err_80211w,
2516 rx_logs->core_rx_pre_mgmt_err,
2517 rx_logs->core_rx_pre_ctrl,
2518 rx_logs->core_rx_pre_ctrl_err,
2519 rx_logs->core_rx_pre_data,
2520 rx_logs->core_rx_pre_data_wapi_seq_err,
2521 rx_logs->core_rx_pre_data_wapi_key_err,
2522 rx_logs->core_rx_pre_data_handled,
2523 rx_logs->core_rx_pre_data_err,
2524 rx_logs->core_rx_pre_data_unknown,
2525 rx_logs->core_rx_pre_unknown,
2526 rx_logs->core_rx_enqueue,
2527 rx_logs->core_rx_dequeue,
2528 rx_logs->core_rx_post,
2529 rx_logs->core_rx_post_decrypt,
2530 rx_logs->core_rx_post_decrypt_wep,
2531 rx_logs->core_rx_post_decrypt_tkip,
2532 rx_logs->core_rx_post_decrypt_aes,
2533 rx_logs->core_rx_post_decrypt_wapi,
2534 rx_logs->core_rx_post_decrypt_hw,
2535 rx_logs->core_rx_post_decrypt_unknown,
2536 rx_logs->core_rx_post_decrypt_err,
2537 rx_logs->core_rx_post_defrag_err,
2538 rx_logs->core_rx_post_portctrl_err,
2539 rx_logs->core_rx_post_indicate,
2540 rx_logs->core_rx_post_indicate_in_oder,
2541 rx_logs->core_rx_post_indicate_reoder,
2542 rx_logs->core_rx_post_indicate_err,
2543 rx_logs->os_indicate,
2544 rx_logs->os_indicate_ap_mcast,
2545 rx_logs->os_indicate_ap_forward,
2546 rx_logs->os_indicate_ap_self,
2547 rx_logs->os_indicate_err,
2548 rx_logs->os_netif_ok,
2549 rx_logs->os_netif_err
2550 );
2551
2552 return 0;
2553 }
2554
proc_get_tx_logs(struct seq_file * m,void * v)2555 int proc_get_tx_logs(struct seq_file *m, void *v)
2556 {
2557 struct net_device *dev = m->private;
2558 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2559 struct tx_logs *tx_logs = &padapter->tx_logs;
2560
2561 RTW_PRINT_SEL(m,
2562 "os_tx=%d\n"
2563 "os_tx_err_up=%d\n"
2564 "os_tx_err_xmit=%d\n"
2565 "os_tx_m2u=%d\n"
2566 "os_tx_m2u_ignore_fw_linked=%d\n"
2567 "os_tx_m2u_ignore_self=%d\n"
2568 "os_tx_m2u_entry=%d\n"
2569 "os_tx_m2u_entry_err_xmit=%d\n"
2570 "os_tx_m2u_entry_err_skb=%d\n"
2571 "os_tx_m2u_stop=%d\n"
2572 "core_tx=%d\n"
2573 "core_tx_err_pxmitframe=%d\n"
2574 "core_tx_err_brtx=%d\n"
2575 "core_tx_upd_attrib=%d\n"
2576 "core_tx_upd_attrib_adhoc=%d\n"
2577 "core_tx_upd_attrib_sta=%d\n"
2578 "core_tx_upd_attrib_ap=%d\n"
2579 "core_tx_upd_attrib_unknown=%d\n"
2580 "core_tx_upd_attrib_dhcp=%d\n"
2581 "core_tx_upd_attrib_icmp=%d\n"
2582 "core_tx_upd_attrib_active=%d\n"
2583 "core_tx_upd_attrib_err_ucast_sta=%d\n"
2584 "core_tx_upd_attrib_err_ucast_ap_link=%d\n"
2585 "core_tx_upd_attrib_err_sta=%d\n"
2586 "core_tx_upd_attrib_err_link=%d\n"
2587 "core_tx_upd_attrib_err_sec=%d\n"
2588 "core_tx_ap_enqueue_warn_fwstate=%d\n"
2589 "core_tx_ap_enqueue_warn_sta=%d\n"
2590 "core_tx_ap_enqueue_warn_nosta=%d\n"
2591 "core_tx_ap_enqueue_warn_link=%d\n"
2592 "core_tx_ap_enqueue_warn_trigger=%d\n"
2593 "core_tx_ap_enqueue_mcast=%d\n"
2594 "core_tx_ap_enqueue_ucast=%d\n"
2595 "core_tx_ap_enqueue=%d\n"
2596 "intf_tx=%d\n"
2597 "intf_tx_pending_ac=%d\n"
2598 "intf_tx_pending_fw_under_survey=%d\n"
2599 "intf_tx_pending_fw_under_linking=%d\n"
2600 "intf_tx_pending_xmitbuf=%d\n"
2601 "intf_tx_enqueue=%d\n"
2602 "core_tx_enqueue=%d\n"
2603 "core_tx_enqueue_class=%d\n"
2604 "core_tx_enqueue_class_err_sta=%d\n"
2605 "core_tx_enqueue_class_err_nosta=%d\n"
2606 "core_tx_enqueue_class_err_fwlink=%d\n"
2607 "intf_tx_direct=%d\n"
2608 "intf_tx_direct_err_coalesce=%d\n"
2609 "intf_tx_dequeue=%d\n"
2610 "intf_tx_dequeue_err_coalesce=%d\n"
2611 "intf_tx_dump_xframe=%d\n"
2612 "intf_tx_dump_xframe_err_txdesc=%d\n"
2613 "intf_tx_dump_xframe_err_port=%d\n",
2614 tx_logs->os_tx,
2615 tx_logs->os_tx_err_up,
2616 tx_logs->os_tx_err_xmit,
2617 tx_logs->os_tx_m2u,
2618 tx_logs->os_tx_m2u_ignore_fw_linked,
2619 tx_logs->os_tx_m2u_ignore_self,
2620 tx_logs->os_tx_m2u_entry,
2621 tx_logs->os_tx_m2u_entry_err_xmit,
2622 tx_logs->os_tx_m2u_entry_err_skb,
2623 tx_logs->os_tx_m2u_stop,
2624 tx_logs->core_tx,
2625 tx_logs->core_tx_err_pxmitframe,
2626 tx_logs->core_tx_err_brtx,
2627 tx_logs->core_tx_upd_attrib,
2628 tx_logs->core_tx_upd_attrib_adhoc,
2629 tx_logs->core_tx_upd_attrib_sta,
2630 tx_logs->core_tx_upd_attrib_ap,
2631 tx_logs->core_tx_upd_attrib_unknown,
2632 tx_logs->core_tx_upd_attrib_dhcp,
2633 tx_logs->core_tx_upd_attrib_icmp,
2634 tx_logs->core_tx_upd_attrib_active,
2635 tx_logs->core_tx_upd_attrib_err_ucast_sta,
2636 tx_logs->core_tx_upd_attrib_err_ucast_ap_link,
2637 tx_logs->core_tx_upd_attrib_err_sta,
2638 tx_logs->core_tx_upd_attrib_err_link,
2639 tx_logs->core_tx_upd_attrib_err_sec,
2640 tx_logs->core_tx_ap_enqueue_warn_fwstate,
2641 tx_logs->core_tx_ap_enqueue_warn_sta,
2642 tx_logs->core_tx_ap_enqueue_warn_nosta,
2643 tx_logs->core_tx_ap_enqueue_warn_link,
2644 tx_logs->core_tx_ap_enqueue_warn_trigger,
2645 tx_logs->core_tx_ap_enqueue_mcast,
2646 tx_logs->core_tx_ap_enqueue_ucast,
2647 tx_logs->core_tx_ap_enqueue,
2648 tx_logs->intf_tx,
2649 tx_logs->intf_tx_pending_ac,
2650 tx_logs->intf_tx_pending_fw_under_survey,
2651 tx_logs->intf_tx_pending_fw_under_linking,
2652 tx_logs->intf_tx_pending_xmitbuf,
2653 tx_logs->intf_tx_enqueue,
2654 tx_logs->core_tx_enqueue,
2655 tx_logs->core_tx_enqueue_class,
2656 tx_logs->core_tx_enqueue_class_err_sta,
2657 tx_logs->core_tx_enqueue_class_err_nosta,
2658 tx_logs->core_tx_enqueue_class_err_fwlink,
2659 tx_logs->intf_tx_direct,
2660 tx_logs->intf_tx_direct_err_coalesce,
2661 tx_logs->intf_tx_dequeue,
2662 tx_logs->intf_tx_dequeue_err_coalesce,
2663 tx_logs->intf_tx_dump_xframe,
2664 tx_logs->intf_tx_dump_xframe_err_txdesc,
2665 tx_logs->intf_tx_dump_xframe_err_port
2666 );
2667
2668 return 0;
2669 }
2670
proc_get_int_logs(struct seq_file * m,void * v)2671 int proc_get_int_logs(struct seq_file *m, void *v)
2672 {
2673 struct net_device *dev = m->private;
2674 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2675
2676 RTW_PRINT_SEL(m,
2677 "all=%d\n"
2678 "err=%d\n"
2679 "tbdok=%d\n"
2680 "tbder=%d\n"
2681 "bcnderr=%d\n"
2682 "bcndma=%d\n"
2683 "bcndma_e=%d\n"
2684 "rx=%d\n"
2685 "rx_rdu=%d\n"
2686 "rx_fovw=%d\n"
2687 "txfovw=%d\n"
2688 "mgntok=%d\n"
2689 "highdok=%d\n"
2690 "bkdok=%d\n"
2691 "bedok=%d\n"
2692 "vidok=%d\n"
2693 "vodok=%d\n",
2694 padapter->int_logs.all,
2695 padapter->int_logs.err,
2696 padapter->int_logs.tbdok,
2697 padapter->int_logs.tbder,
2698 padapter->int_logs.bcnderr,
2699 padapter->int_logs.bcndma,
2700 padapter->int_logs.bcndma_e,
2701 padapter->int_logs.rx,
2702 padapter->int_logs.rx_rdu,
2703 padapter->int_logs.rx_fovw,
2704 padapter->int_logs.txfovw,
2705 padapter->int_logs.mgntok,
2706 padapter->int_logs.highdok,
2707 padapter->int_logs.bkdok,
2708 padapter->int_logs.bedok,
2709 padapter->int_logs.vidok,
2710 padapter->int_logs.vodok
2711 );
2712
2713 return 0;
2714 }
2715
2716 #endif /* CONFIG_DBG_COUNTER */
2717
proc_get_hw_status(struct seq_file * m,void * v)2718 int proc_get_hw_status(struct seq_file *m, void *v)
2719 {
2720 struct net_device *dev = m->private;
2721 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2722 struct dvobj_priv *dvobj = padapter->dvobj;
2723 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
2724 struct registry_priv *regsty = dvobj_to_regsty(dvobj);
2725
2726 if (regsty->check_hw_status == 0)
2727 RTW_PRINT_SEL(m, "RX FIFO full count: not check in watch dog\n");
2728 else if (pdbgpriv->dbg_rx_fifo_last_overflow == 1
2729 && pdbgpriv->dbg_rx_fifo_curr_overflow == 1
2730 && pdbgpriv->dbg_rx_fifo_diff_overflow == 1
2731 )
2732 RTW_PRINT_SEL(m, "RX FIFO full count: no implementation\n");
2733 else {
2734 RTW_PRINT_SEL(m, "RX FIFO full count: last_time=%llu, current_time=%llu, differential=%llu\n"
2735 , pdbgpriv->dbg_rx_fifo_last_overflow, pdbgpriv->dbg_rx_fifo_curr_overflow, pdbgpriv->dbg_rx_fifo_diff_overflow);
2736 }
2737
2738 return 0;
2739 }
2740
proc_set_hw_status(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2741 ssize_t proc_set_hw_status(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2742 {
2743 struct net_device *dev = data;
2744 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2745 struct dvobj_priv *dvobj = padapter->dvobj;
2746 struct registry_priv *regsty = dvobj_to_regsty(dvobj);
2747 char tmp[32];
2748 u32 enable;
2749
2750 if (count < 1)
2751 return -EFAULT;
2752
2753 if (count > sizeof(tmp)) {
2754 rtw_warn_on(1);
2755 return -EFAULT;
2756 }
2757
2758 if (buffer && !copy_from_user(tmp, buffer, count)) {
2759
2760 int num = sscanf(tmp, "%d ", &enable);
2761
2762 if (num == 1 && regsty && enable <= 1) {
2763 regsty->check_hw_status = enable;
2764 RTW_INFO("check_hw_status=%d\n", regsty->check_hw_status);
2765 }
2766 }
2767
2768 return count;
2769 }
2770
proc_get_trx_info_debug(struct seq_file * m,void * v)2771 int proc_get_trx_info_debug(struct seq_file *m, void *v)
2772 {
2773 struct net_device *dev = m->private;
2774 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2775
2776 /*============ tx info ============ */
2777 rtw_hal_get_def_var(padapter, HW_DEF_RA_INFO_DUMP, m);
2778
2779 /*============ rx info ============ */
2780 /*rtw_hal_set_phydm_var(padapter, HAL_PHYDM_RX_INFO_DUMP, m, _FALSE);*/
2781
2782 return 0;
2783 }
2784
proc_get_rx_signal(struct seq_file * m,void * v)2785 int proc_get_rx_signal(struct seq_file *m, void *v)
2786 {
2787 struct net_device *dev = m->private;
2788 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2789
2790 RTW_PRINT_SEL(m, "rssi:%d\n", padapter->recvinfo.rssi);
2791 #if 0//def CONFIG_MP_INCLUDED
2792 if (padapter->registrypriv.mp_mode == 1) {
2793 struct dm_struct *odm = adapter_to_phydm(padapter);
2794 if (padapter->mppriv.antenna_rx == ANTENNA_A)
2795 RTW_PRINT_SEL(m, "Antenna: A\n");
2796 else if (padapter->mppriv.antenna_rx == ANTENNA_B)
2797 RTW_PRINT_SEL(m, "Antenna: B\n");
2798 else if (padapter->mppriv.antenna_rx == ANTENNA_C)
2799 RTW_PRINT_SEL(m, "Antenna: C\n");
2800 else if (padapter->mppriv.antenna_rx == ANTENNA_D)
2801 RTW_PRINT_SEL(m, "Antenna: D\n");
2802 else if (padapter->mppriv.antenna_rx == ANTENNA_AB)
2803 RTW_PRINT_SEL(m, "Antenna: AB\n");
2804 else if (padapter->mppriv.antenna_rx == ANTENNA_BC)
2805 RTW_PRINT_SEL(m, "Antenna: BC\n");
2806 else if (padapter->mppriv.antenna_rx == ANTENNA_CD)
2807 RTW_PRINT_SEL(m, "Antenna: CD\n");
2808 else
2809 RTW_PRINT_SEL(m, "Antenna: __\n");
2810
2811 RTW_PRINT_SEL(m, "rx_rate = %s\n", HDATA_RATE(odm->rx_rate));
2812 return 0;
2813 } else
2814 #endif
2815 {
2816 /* RTW_PRINT_SEL(m, "rxpwdb:%d\n", padapter->recvinfo.rxpwdb); */
2817 RTW_PRINT_SEL(m, "signal_strength:%u\n", padapter->recvinfo.signal_strength);
2818 RTW_PRINT_SEL(m, "signal_qual:%u\n", padapter->recvinfo.signal_qual);
2819 }
2820
2821 return 0;
2822 }
2823
proc_set_rx_signal(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2824 ssize_t proc_set_rx_signal(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2825 {
2826 struct net_device *dev = data;
2827 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2828 char tmp[32];
2829 u32 is_signal_dbg, signal_strength;
2830
2831 if (count < 1)
2832 return -EFAULT;
2833
2834 if (count > sizeof(tmp)) {
2835 rtw_warn_on(1);
2836 return -EFAULT;
2837 }
2838
2839 if (buffer && !copy_from_user(tmp, buffer, count)) {
2840
2841 int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
2842
2843 if (num < 1)
2844 return count;
2845
2846 is_signal_dbg = is_signal_dbg == 0 ? 0 : 1;
2847
2848 if (is_signal_dbg && num < 2)
2849 return count;
2850
2851 signal_strength = signal_strength > PHL_MAX_RSSI ? PHL_MAX_RSSI : signal_strength;
2852
2853 padapter->recvinfo.is_signal_dbg = is_signal_dbg;
2854 padapter->recvinfo.signal_strength_dbg = signal_strength;
2855
2856 if (is_signal_dbg)
2857 RTW_INFO("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
2858 else
2859 RTW_INFO("set %s\n", "HW_SIGNAL_STRENGTH");
2860
2861 }
2862
2863 return count;
2864
2865 }
2866
proc_get_mac_rptbuf(struct seq_file * m,void * v)2867 int proc_get_mac_rptbuf(struct seq_file *m, void *v)
2868 {
2869 return 0;
2870 }
2871
2872 #ifdef CONFIG_80211N_HT
2873
proc_get_ht_enable(struct seq_file * m,void * v)2874 int proc_get_ht_enable(struct seq_file *m, void *v)
2875 {
2876 struct net_device *dev = m->private;
2877 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2878 struct registry_priv *pregpriv = &padapter->registrypriv;
2879
2880 if (pregpriv)
2881 RTW_PRINT_SEL(m, "%d\n", pregpriv->ht_enable);
2882
2883 return 0;
2884 }
2885
proc_set_ht_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2886 ssize_t proc_set_ht_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2887 {
2888 struct net_device *dev = data;
2889 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2890 struct registry_priv *pregpriv = &padapter->registrypriv;
2891 char tmp[32];
2892 u32 mode;
2893
2894 if (count < 1)
2895 return -EFAULT;
2896
2897 if (count > sizeof(tmp)) {
2898 rtw_warn_on(1);
2899 return -EFAULT;
2900 }
2901
2902 if (buffer && !copy_from_user(tmp, buffer, count)) {
2903
2904 int num = sscanf(tmp, "%d ", &mode);
2905
2906 if ( num == 1 && pregpriv && mode < 2) {
2907 pregpriv->ht_enable = mode;
2908 RTW_INFO("ht_enable=%d\n", pregpriv->ht_enable);
2909 }
2910 }
2911
2912 return count;
2913
2914 }
2915
proc_get_bw_mode(struct seq_file * m,void * v)2916 int proc_get_bw_mode(struct seq_file *m, void *v)
2917 {
2918 struct net_device *dev = m->private;
2919 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2920 struct registry_priv *pregpriv = &padapter->registrypriv;
2921
2922 if (pregpriv)
2923 RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->bw_mode);
2924
2925 return 0;
2926 }
2927
proc_set_bw_mode(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2928 ssize_t proc_set_bw_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2929 {
2930 struct net_device *dev = data;
2931 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2932 struct registry_priv *pregpriv = &padapter->registrypriv;
2933 char tmp[32];
2934 u32 mode;
2935 u8 bw_2g;
2936 u8 bw_5g;
2937
2938 if (count < 1)
2939 return -EFAULT;
2940
2941 if (count > sizeof(tmp)) {
2942 rtw_warn_on(1);
2943 return -EFAULT;
2944 }
2945
2946 if (buffer && !copy_from_user(tmp, buffer, count)) {
2947
2948 int num = sscanf(tmp, "%x ", &mode);
2949 bw_5g = mode >> 4;
2950 bw_2g = mode & 0x0f;
2951
2952 if (num == 1 && pregpriv && bw_2g <= 4 && bw_5g <= 4) {
2953 pregpriv->bw_mode = mode;
2954 printk("bw_mode=0x%x\n", mode);
2955 }
2956 }
2957
2958 return count;
2959
2960 }
2961
proc_get_ampdu_enable(struct seq_file * m,void * v)2962 int proc_get_ampdu_enable(struct seq_file *m, void *v)
2963 {
2964 struct net_device *dev = m->private;
2965 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2966 struct registry_priv *pregpriv = &padapter->registrypriv;
2967
2968 if (pregpriv)
2969 RTW_PRINT_SEL(m, "%d\n", pregpriv->ampdu_enable);
2970
2971 return 0;
2972 }
2973
proc_set_ampdu_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2974 ssize_t proc_set_ampdu_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2975 {
2976 struct net_device *dev = data;
2977 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2978 struct registry_priv *pregpriv = &padapter->registrypriv;
2979 char tmp[32];
2980 u32 mode;
2981
2982 if (count < 1)
2983 return -EFAULT;
2984
2985 if (count > sizeof(tmp)) {
2986 rtw_warn_on(1);
2987 return -EFAULT;
2988 }
2989
2990 if (buffer && !copy_from_user(tmp, buffer, count)) {
2991
2992 int num = sscanf(tmp, "%d ", &mode);
2993
2994 if (num == 1 && pregpriv && mode < 2) {
2995 pregpriv->ampdu_enable = mode;
2996 printk("ampdu_enable=%d\n", mode);
2997 }
2998
2999 }
3000
3001 return count;
3002
3003 }
3004
3005
dump_regsty_rx_ampdu_size_limit(void * sel,_adapter * adapter)3006 void dump_regsty_rx_ampdu_size_limit(void *sel, _adapter *adapter)
3007 {
3008 struct registry_priv *regsty = adapter_to_regsty(adapter);
3009 int i;
3010
3011 RTW_PRINT_SEL(sel, "%-3s %-3s %-3s %-3s %-4s\n"
3012 , "", "20M", "40M", "80M", "160M");
3013 for (i = 0; i < 4; i++)
3014 RTW_PRINT_SEL(sel, "%dSS %3u %3u %3u %4u\n", i + 1
3015 , regsty->rx_ampdu_sz_limit_by_nss_bw[i][0]
3016 , regsty->rx_ampdu_sz_limit_by_nss_bw[i][1]
3017 , regsty->rx_ampdu_sz_limit_by_nss_bw[i][2]
3018 , regsty->rx_ampdu_sz_limit_by_nss_bw[i][3]);
3019 }
3020
proc_get_rx_ampdu(struct seq_file * m,void * v)3021 int proc_get_rx_ampdu(struct seq_file *m, void *v)
3022 {
3023 struct net_device *dev = m->private;
3024 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3025
3026 _RTW_PRINT_SEL(m, "accept: ");
3027 if (padapter->fix_rx_ampdu_accept == RX_AMPDU_ACCEPT_INVALID)
3028 RTW_PRINT_SEL(m, "%u%s\n", rtw_rx_ampdu_is_accept(padapter), "(auto)");
3029 else
3030 RTW_PRINT_SEL(m, "%u%s\n", padapter->fix_rx_ampdu_accept, "(fixed)");
3031
3032 _RTW_PRINT_SEL(m, "size: ");
3033 if (padapter->fix_rx_ampdu_size == RX_AMPDU_SIZE_INVALID) {
3034 RTW_PRINT_SEL(m, "%u%s\n", rtw_rx_ampdu_size(padapter), "(auto) with conditional limit:");
3035 dump_regsty_rx_ampdu_size_limit(m, padapter);
3036 } else
3037 RTW_PRINT_SEL(m, "%u%s\n", padapter->fix_rx_ampdu_size, "(fixed)");
3038 RTW_PRINT_SEL(m, "\n");
3039
3040 RTW_PRINT_SEL(m, "%19s %17s\n", "fix_rx_ampdu_accept", "fix_rx_ampdu_size");
3041
3042 _RTW_PRINT_SEL(m, "%-19d %-17u\n"
3043 , padapter->fix_rx_ampdu_accept
3044 , padapter->fix_rx_ampdu_size);
3045
3046 return 0;
3047 }
3048
proc_set_rx_ampdu(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3049 ssize_t proc_set_rx_ampdu(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3050 {
3051 struct net_device *dev = data;
3052 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3053 char tmp[32];
3054 u8 accept;
3055 u8 size;
3056
3057 if (count < 1)
3058 return -EFAULT;
3059
3060 if (count > sizeof(tmp)) {
3061 rtw_warn_on(1);
3062 return -EFAULT;
3063 }
3064
3065 if (buffer && !copy_from_user(tmp, buffer, count)) {
3066
3067 int num = sscanf(tmp, "%hhu %hhu", &accept, &size);
3068
3069 if (num >= 1)
3070 rtw_rx_ampdu_set_accept(padapter, accept, RX_AMPDU_DRV_FIXED);
3071 if (num >= 2)
3072 rtw_rx_ampdu_set_size(padapter, size, RX_AMPDU_DRV_FIXED);
3073
3074 rtw_rx_ampdu_apply(padapter);
3075 }
3076
3077 return count;
3078 }
3079
proc_get_rx_ampdu_factor(struct seq_file * m,void * v)3080 int proc_get_rx_ampdu_factor(struct seq_file *m, void *v)
3081 {
3082 struct net_device *dev = m->private;
3083 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3084
3085
3086 if (padapter)
3087 RTW_PRINT_SEL(m, "rx ampdu factor = %x\n", padapter->driver_rx_ampdu_factor);
3088
3089 return 0;
3090 }
3091
proc_set_rx_ampdu_factor(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3092 ssize_t proc_set_rx_ampdu_factor(struct file *file, const char __user *buffer
3093 , size_t count, loff_t *pos, void *data)
3094 {
3095 struct net_device *dev = data;
3096 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3097 char tmp[32];
3098 u32 factor;
3099
3100 if (count < 1)
3101 return -EFAULT;
3102
3103 if (count > sizeof(tmp)) {
3104 rtw_warn_on(1);
3105 return -EFAULT;
3106 }
3107
3108 if (buffer && !copy_from_user(tmp, buffer, count)) {
3109
3110 int num = sscanf(tmp, "%d ", &factor);
3111
3112 if (padapter && (num == 1)) {
3113 RTW_INFO("padapter->driver_rx_ampdu_factor = %x\n", factor);
3114
3115 if (factor > 0x03)
3116 padapter->driver_rx_ampdu_factor = 0xFF;
3117 else
3118 padapter->driver_rx_ampdu_factor = factor;
3119 }
3120 }
3121
3122 return count;
3123 }
3124
proc_get_tx_max_agg_num(struct seq_file * m,void * v)3125 int proc_get_tx_max_agg_num(struct seq_file *m, void *v)
3126 {
3127 struct net_device *dev = m->private;
3128 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3129
3130
3131 if (padapter)
3132 RTW_PRINT_SEL(m, "tx max AMPDU num = 0x%02x\n", padapter->driver_tx_max_agg_num);
3133
3134 return 0;
3135 }
3136
proc_set_tx_max_agg_num(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3137 ssize_t proc_set_tx_max_agg_num(struct file *file, const char __user *buffer
3138 , size_t count, loff_t *pos, void *data)
3139 {
3140 struct net_device *dev = data;
3141 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3142 char tmp[32];
3143 u8 agg_num;
3144
3145 if (count < 1)
3146 return -EFAULT;
3147
3148 if (count > sizeof(tmp)) {
3149 rtw_warn_on(1);
3150 return -EFAULT;
3151 }
3152
3153 if (buffer && !copy_from_user(tmp, buffer, count)) {
3154
3155 int num = sscanf(tmp, "%hhx ", &agg_num);
3156
3157 if (padapter && (num == 1)) {
3158 RTW_INFO("padapter->driver_tx_max_agg_num = 0x%02x\n", agg_num);
3159
3160 padapter->driver_tx_max_agg_num = agg_num;
3161 }
3162 }
3163
3164 return count;
3165 }
3166
proc_get_rx_ampdu_density(struct seq_file * m,void * v)3167 int proc_get_rx_ampdu_density(struct seq_file *m, void *v)
3168 {
3169 struct net_device *dev = m->private;
3170 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3171
3172
3173 if (padapter)
3174 RTW_PRINT_SEL(m, "rx ampdu densityg = %x\n", padapter->driver_rx_ampdu_spacing);
3175
3176 return 0;
3177 }
3178
proc_set_rx_ampdu_density(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3179 ssize_t proc_set_rx_ampdu_density(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3180 {
3181 struct net_device *dev = data;
3182 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3183 char tmp[32];
3184 u32 density;
3185
3186 if (count < 1)
3187 return -EFAULT;
3188
3189 if (count > sizeof(tmp)) {
3190 rtw_warn_on(1);
3191 return -EFAULT;
3192 }
3193
3194 if (buffer && !copy_from_user(tmp, buffer, count)) {
3195
3196 int num = sscanf(tmp, "%d ", &density);
3197
3198 if (padapter && (num == 1)) {
3199 RTW_INFO("padapter->driver_rx_ampdu_spacing = %x\n", density);
3200
3201 if (density > 0x07)
3202 padapter->driver_rx_ampdu_spacing = 0xFF;
3203 else
3204 padapter->driver_rx_ampdu_spacing = density;
3205 }
3206 }
3207
3208 return count;
3209 }
3210
proc_get_tx_ampdu_density(struct seq_file * m,void * v)3211 int proc_get_tx_ampdu_density(struct seq_file *m, void *v)
3212 {
3213 struct net_device *dev = m->private;
3214 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3215
3216
3217 if (padapter)
3218 RTW_PRINT_SEL(m, "tx ampdu density = %x\n", padapter->driver_ampdu_spacing);
3219
3220 return 0;
3221 }
3222
proc_set_tx_ampdu_density(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3223 ssize_t proc_set_tx_ampdu_density(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3224 {
3225 struct net_device *dev = data;
3226 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3227 char tmp[32];
3228 u32 density;
3229
3230 if (count < 1)
3231 return -EFAULT;
3232
3233 if (count > sizeof(tmp)) {
3234 rtw_warn_on(1);
3235 return -EFAULT;
3236 }
3237
3238 if (buffer && !copy_from_user(tmp, buffer, count)) {
3239
3240 int num = sscanf(tmp, "%d ", &density);
3241
3242 if (padapter && (num == 1)) {
3243 RTW_INFO("padapter->driver_ampdu_spacing = %x\n", density);
3244
3245 if (density > 0x07)
3246 padapter->driver_ampdu_spacing = 0xFF;
3247 else
3248 padapter->driver_ampdu_spacing = density;
3249 }
3250 }
3251
3252 return count;
3253 }
3254
proc_get_tx_quick_addba_req(struct seq_file * m,void * v)3255 int proc_get_tx_quick_addba_req(struct seq_file *m, void *v)
3256 {
3257 struct net_device *dev = m->private;
3258 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3259 struct registry_priv *pregpriv = &padapter->registrypriv;
3260
3261 if (padapter)
3262 RTW_PRINT_SEL(m, "tx_quick_addba_req = %x\n", pregpriv->tx_quick_addba_req);
3263
3264 return 0;
3265 }
3266
proc_set_tx_quick_addba_req(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3267 ssize_t proc_set_tx_quick_addba_req(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3268 {
3269 struct net_device *dev = data;
3270 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3271 struct registry_priv *pregpriv = &padapter->registrypriv;
3272 char tmp[32];
3273 u32 enable;
3274
3275 if (count < 1)
3276 return -EFAULT;
3277
3278 if (count > sizeof(tmp)) {
3279 rtw_warn_on(1);
3280 return -EFAULT;
3281 }
3282
3283 if (buffer && !copy_from_user(tmp, buffer, count)) {
3284
3285 int num = sscanf(tmp, "%d ", &enable);
3286
3287 if (padapter && (num == 1)) {
3288 pregpriv->tx_quick_addba_req = enable;
3289 RTW_INFO("tx_quick_addba_req = %d\n", pregpriv->tx_quick_addba_req);
3290 }
3291 }
3292
3293 return count;
3294 }
3295 #ifdef CONFIG_TX_AMSDU
proc_get_tx_amsdu(struct seq_file * m,void * v)3296 int proc_get_tx_amsdu(struct seq_file *m, void *v)
3297 {
3298 struct net_device *dev = m->private;
3299 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3300 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3301 int i;
3302
3303 if (padapter)
3304 {
3305 RTW_PRINT_SEL(m, "tx amsdu = %d\n", padapter->tx_amsdu);
3306 RTW_PRINT_SEL(m, "amsdu set timer conut = %u\n", pxmitpriv->amsdu_debug_set_timer);
3307 RTW_PRINT_SEL(m, "amsdu time out count = %u\n", pxmitpriv->amsdu_debug_timeout);
3308 for (i = 0; i < (AMSDU_DEBUG_MAX_COUNT - 1); i++) {
3309 RTW_PRINT_SEL(m, "amsdu coalesce %d count = %u\n",
3310 i + 1, pxmitpriv->amsdu_debug_coalesce[i]);
3311 }
3312 RTW_PRINT_SEL(m, "amsdu coalesce >%d count = %u\n",
3313 i, pxmitpriv->amsdu_debug_coalesce[i]);
3314 RTW_PRINT_SEL(m, "amsdu tasklet count = %u\n", pxmitpriv->amsdu_debug_tasklet);
3315 RTW_PRINT_SEL(m, "amsdu enqueue count = %u\n", pxmitpriv->amsdu_debug_enqueue);
3316 RTW_PRINT_SEL(m, "amsdu dequeue count = %u\n", pxmitpriv->amsdu_debug_dequeue);
3317 }
3318
3319 return 0;
3320 }
3321
proc_set_tx_amsdu(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3322 ssize_t proc_set_tx_amsdu(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3323 {
3324 struct net_device *dev = data;
3325 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3326 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3327 char tmp[32];
3328 u32 i, amsdu;
3329
3330 if (count < 1)
3331 return -EFAULT;
3332
3333 if (count > sizeof(tmp)) {
3334 rtw_warn_on(1);
3335 return -EFAULT;
3336 }
3337
3338 if (buffer && !copy_from_user(tmp, buffer, count)) {
3339
3340 int num = sscanf(tmp, "%d ", &amsdu);
3341
3342 if (padapter && (num == 1)) {
3343 RTW_INFO("padapter->tx_amsdu = %x\n", amsdu);
3344
3345 if (amsdu == 255) {
3346 pxmitpriv->amsdu_debug_set_timer = 0;
3347 pxmitpriv->amsdu_debug_timeout = 0;
3348 pxmitpriv->amsdu_debug_tasklet = 0;
3349 pxmitpriv->amsdu_debug_enqueue = 0;
3350 pxmitpriv->amsdu_debug_dequeue = 0;
3351 for (i = 0; i < AMSDU_DEBUG_MAX_COUNT; i++)
3352 pxmitpriv->amsdu_debug_coalesce[i] = 0;
3353 } else {
3354 padapter->tx_amsdu = amsdu;
3355 }
3356 }
3357 }
3358
3359 return count;
3360 }
3361
proc_get_tx_amsdu_rate(struct seq_file * m,void * v)3362 int proc_get_tx_amsdu_rate(struct seq_file *m, void *v)
3363 {
3364 struct net_device *dev = m->private;
3365 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3366
3367 if (padapter)
3368 RTW_PRINT_SEL(m, "tx amsdu rate = %d Mbps\n", padapter->tx_amsdu_rate);
3369
3370 return 0;
3371 }
3372
proc_set_tx_amsdu_rate(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3373 ssize_t proc_set_tx_amsdu_rate(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3374 {
3375 struct net_device *dev = data;
3376 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3377 char tmp[32];
3378 u32 amsdu_rate;
3379
3380 if (count < 1)
3381 return -EFAULT;
3382
3383 if (count > sizeof(tmp)) {
3384 rtw_warn_on(1);
3385 return -EFAULT;
3386 }
3387
3388 if (buffer && !copy_from_user(tmp, buffer, count)) {
3389
3390 int num = sscanf(tmp, "%d ", &amsdu_rate);
3391
3392 if (padapter && (num == 1)) {
3393 RTW_INFO("padapter->tx_amsdu_rate = %x\n", amsdu_rate);
3394 padapter->tx_amsdu_rate = amsdu_rate;
3395 }
3396 }
3397
3398 return count;
3399 }
3400 #endif /* CONFIG_TX_AMSDU */
3401 #endif /* CONFIG_80211N_HT */
3402
3403 #ifdef CONFIG_80211AC_VHT
proc_get_vht_24g_enable(struct seq_file * m,void * v)3404 int proc_get_vht_24g_enable(struct seq_file *m, void *v)
3405 {
3406 struct net_device *dev = m->private;
3407 struct _ADAPTER *a = (struct _ADAPTER *)rtw_netdev_priv(dev);
3408 struct registry_priv *regpriv = &a->registrypriv;
3409
3410
3411 if (regpriv)
3412 RTW_PRINT_SEL(m, "%d\n", regpriv->vht_24g_enable);
3413
3414 return 0;
3415 }
3416
proc_set_vht_24g_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3417 ssize_t proc_set_vht_24g_enable(struct file *file, const char __user *buffer,
3418 size_t count, loff_t *pos, void *data)
3419 {
3420 struct net_device *dev = data;
3421 struct _ADAPTER *a = (struct _ADAPTER *)rtw_netdev_priv(dev);
3422 struct registry_priv *regpriv = &a->registrypriv;
3423 char tmp[32];
3424 u32 mode;
3425
3426
3427 if (count < 1)
3428 return -EFAULT;
3429
3430 if (count > sizeof(tmp)) {
3431 rtw_warn_on(1);
3432 return -EFAULT;
3433 }
3434
3435 if (buffer && !copy_from_user(tmp, buffer, count)) {
3436
3437 int num = sscanf(tmp, "%d ", &mode);
3438
3439 if ((num == 1) && regpriv && (mode < 2)) {
3440 regpriv->vht_24g_enable = mode;
3441 RTW_INFO("vht_24g_enable = %d\n", regpriv->vht_24g_enable);
3442 }
3443 }
3444
3445 return count;
3446 }
3447 #endif /* CONFIG_80211AC_VHT */
3448
proc_set_dyn_rrsr(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3449 ssize_t proc_set_dyn_rrsr(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3450 {
3451 struct net_device *dev = data;
3452 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3453 struct registry_priv *pregpriv = &padapter->registrypriv;
3454
3455 char tmp[32] = {0};
3456 u32 num = 0, enable = 0, rrsr_val = 0; /* gpio_mode:0 input 1:output; */
3457
3458 if (count < 2)
3459 return -EFAULT;
3460
3461 if (count > sizeof(tmp)) {
3462 rtw_warn_on(1);
3463 return -EFAULT;
3464 }
3465
3466 if (buffer && !copy_from_user(tmp, buffer, count)) {
3467 num = sscanf(tmp, "%d 0x%x", &enable, &rrsr_val);
3468 RTW_INFO("num=%u enable=%d rrsr_val=0x%x\n", num, enable, rrsr_val);
3469 pregpriv->en_dyn_rrsr = enable;
3470 pregpriv->set_rrsr_value = rrsr_val;
3471 /*rtw_phydm_dyn_rrsr_en(padapter, enable);*/
3472 /*rtw_phydm_set_rrsr(padapter, rrsr_val, _TRUE);*/
3473
3474 }
3475 return count;
3476
3477 }
proc_get_dyn_rrsr(struct seq_file * m,void * v)3478 int proc_get_dyn_rrsr(struct seq_file *m, void *v) {
3479
3480 struct net_device *dev = m->private;
3481 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3482 struct registry_priv *pregpriv = &padapter->registrypriv;
3483 u32 init_rrsr =0xFFFFFFFF;
3484
3485 if (padapter)
3486 RTW_PRINT_SEL(m, "en_dyn_rrsr = %d fixed_rrsr_value =0x%x %s\n"
3487 , pregpriv->en_dyn_rrsr
3488 , pregpriv->set_rrsr_value
3489 , (pregpriv->set_rrsr_value == init_rrsr)?"(default)":"(fixed)"
3490 );
3491
3492 return 0;
3493 }
proc_get_en_fwps(struct seq_file * m,void * v)3494 int proc_get_en_fwps(struct seq_file *m, void *v)
3495 {
3496 struct net_device *dev = m->private;
3497 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3498 struct registry_priv *pregpriv = &padapter->registrypriv;
3499
3500 if (pregpriv)
3501 RTW_PRINT_SEL(m, "check_fw_ps = %d , 1:enable get FW PS state , 0: disable get FW PS state\n"
3502 , pregpriv->check_fw_ps);
3503
3504 return 0;
3505 }
3506
proc_set_en_fwps(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3507 ssize_t proc_set_en_fwps(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3508 {
3509 struct net_device *dev = data;
3510 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3511 struct registry_priv *pregpriv = &padapter->registrypriv;
3512 char tmp[32];
3513 u32 mode;
3514
3515 if (count < 1)
3516 return -EFAULT;
3517
3518 if (count > sizeof(tmp)) {
3519 rtw_warn_on(1);
3520 return -EFAULT;
3521 }
3522
3523 if (buffer && !copy_from_user(tmp, buffer, count)) {
3524
3525 int num = sscanf(tmp, "%d ", &mode);
3526
3527 if (num == 1 && pregpriv && mode < 2) {
3528 pregpriv->check_fw_ps = mode;
3529 RTW_INFO("pregpriv->check_fw_ps=%d\n", pregpriv->check_fw_ps);
3530 }
3531
3532 }
3533
3534 return count;
3535 }
3536
3537 #ifdef CONFIG_80211N_HT
rtw_dump_dft_phy_cap(void * sel,_adapter * adapter)3538 void rtw_dump_dft_phy_cap(void *sel, _adapter *adapter)
3539 {
3540 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
3541 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
3542 #ifdef CONFIG_80211AC_VHT
3543 struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
3544 #endif
3545
3546 #ifdef CONFIG_80211AC_VHT
3547 RTW_PRINT_SEL(sel, "[DFT CAP] VHT STBC Tx : %s\n", (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX)) ? "V" : "X");
3548 RTW_PRINT_SEL(sel, "[DFT CAP] VHT STBC Rx : %s\n", (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_RX)) ? "V" : "X");
3549 #endif
3550 RTW_PRINT_SEL(sel, "[DFT CAP] HT STBC Tx : %s\n", (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX)) ? "V" : "X");
3551 RTW_PRINT_SEL(sel, "[DFT CAP] HT STBC Rx : %s\n\n", (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX)) ? "V" : "X");
3552
3553 #ifdef CONFIG_80211AC_VHT
3554 RTW_PRINT_SEL(sel, "[DFT CAP] VHT LDPC Tx : %s\n", (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX)) ? "V" : "X");
3555 RTW_PRINT_SEL(sel, "[DFT CAP] VHT LDPC Rx : %s\n", (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_RX)) ? "V" : "X");
3556 #endif
3557 RTW_PRINT_SEL(sel, "[DFT CAP] HT LDPC Tx : %s\n", (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX)) ? "V" : "X");
3558 RTW_PRINT_SEL(sel, "[DFT CAP] HT LDPC Rx : %s\n\n", (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX)) ? "V" : "X");
3559
3560 #ifdef CONFIG_BEAMFORMING
3561 #ifdef CONFIG_80211AX_HE
3562 RTW_PRINT_SEL(sel, "[DFT CAP] HE MU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_HE_MU_MIMO_AP_ENABLE)) ? "V" : "X");
3563 RTW_PRINT_SEL(sel, "[DFT CAP] HE MU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_HE_MU_MIMO_STA_ENABLE)) ? "V" : "X");
3564 RTW_PRINT_SEL(sel, "[DFT CAP] HE SU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_HE_BEAMFORMER_ENABLE)) ? "V" : "X");
3565 RTW_PRINT_SEL(sel, "[DFT CAP] HE SU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_HE_BEAMFORMEE_ENABLE)) ? "V" : "X");
3566 #endif
3567 #ifdef CONFIG_80211AC_VHT
3568 RTW_PRINT_SEL(sel, "[DFT CAP] VHT MU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE)) ? "V" : "X");
3569 RTW_PRINT_SEL(sel, "[DFT CAP] VHT MU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE)) ? "V" : "X");
3570 RTW_PRINT_SEL(sel, "[DFT CAP] VHT SU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE)) ? "V" : "X");
3571 RTW_PRINT_SEL(sel, "[DFT CAP] VHT SU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE)) ? "V" : "X");
3572 #endif
3573 RTW_PRINT_SEL(sel, "[DFT CAP] HT Bfer : %s\n", (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE)) ? "V" : "X");
3574 RTW_PRINT_SEL(sel, "[DFT CAP] HT Bfee : %s\n", (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE)) ? "V" : "X");
3575 #endif
3576 }
3577
rtw_get_dft_phy_cap(void * sel,_adapter * adapter)3578 void rtw_get_dft_phy_cap(void *sel, _adapter *adapter)
3579 {
3580 RTW_PRINT_SEL(sel, "\n ======== PHY CAP protocol ========\n");
3581 rtw_ht_use_default_setting(adapter);
3582 #ifdef CONFIG_80211AC_VHT
3583 rtw_vht_get_real_setting(adapter);
3584 #endif
3585 #ifdef CONFIG_80211N_HT
3586 rtw_dump_dft_phy_cap(sel, adapter);
3587 #endif
3588 }
3589
rtw_dump_drv_phy_cap(void * sel,_adapter * adapter)3590 void rtw_dump_drv_phy_cap(void *sel, _adapter *adapter)
3591 {
3592 struct registry_priv *pregistry_priv = &adapter->registrypriv;
3593
3594 RTW_PRINT_SEL(sel, "\n ======== DRV's configuration ========\n");
3595 #if 0
3596 RTW_PRINT_SEL(sel, "[DRV CAP] TRx Capability : 0x%08x\n", phy_spec->trx_cap);
3597 RTW_PRINT_SEL(sel, "[DRV CAP] Tx Stream Num Index : %d\n", (phy_spec->trx_cap >> 24) & 0xFF); /*Tx Stream Num Index [31:24]*/
3598 RTW_PRINT_SEL(sel, "[DRV CAP] Rx Stream Num Index : %d\n", (phy_spec->trx_cap >> 16) & 0xFF); /*Rx Stream Num Index [23:16]*/
3599 RTW_PRINT_SEL(sel, "[DRV CAP] Tx Path Num Index : %d\n", (phy_spec->trx_cap >> 8) & 0xFF);/*Tx Path Num Index [15:8]*/
3600 RTW_PRINT_SEL(sel, "[DRV CAP] Rx Path Num Index : %d\n", (phy_spec->trx_cap & 0xFF));/*Rx Path Num Index [7:0]*/
3601 #endif
3602 #ifdef CONFIG_80211N_HT
3603 RTW_PRINT_SEL(sel, "[DRV CAP] STBC Capability : 0x%04x\n", pregistry_priv->stbc_cap);
3604 RTW_PRINT_SEL(sel, "[DRV CAP] HT STBC Tx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT5)) ? "V" : "X"); /*BIT5: Enable HT STBC Tx*/
3605 RTW_PRINT_SEL(sel, "[DRV CAP] HT STBC Rx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT4)) ? "V" : "X"); /*BIT4: Enable HT STBC Rx*/
3606 RTW_PRINT_SEL(sel, "[DRV CAP] VHT STBC Tx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT1)) ? "V" : "X"); /*BIT1: Enable VHT STBC Tx*/
3607 RTW_PRINT_SEL(sel, "[DRV CAP] VHT STBC Rx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT0)) ? "V" : "X"); /*BIT0: Enable VHT STBC Rx*/
3608 RTW_PRINT_SEL(sel, "[DRV CAP] HE STBC Tx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT10)) ? "V" : "X"); /*BIT10: Enable HE STBC Tx*/
3609 RTW_PRINT_SEL(sel, "[DRV CAP] HE STBC Rx : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT8)) ? "V" : "X"); /*BIT8: Enable HE STBC Rx*/
3610 RTW_PRINT_SEL(sel, "[DRV CAP] HE STBC Tx(>80M) : %s\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT11)) ? "V" : "X"); /*BIT11: Enable HE STBC Tx(>80M)*/
3611 RTW_PRINT_SEL(sel, "[DRV CAP] HE STBC Rx(>80M) : %s\n\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT9)) ? "V" : "X"); /*BIT9: Enable HE STBC Rx(>80M)*/
3612
3613
3614 RTW_PRINT_SEL(sel, "[DRV CAP] LDPC Capability : 0x%02x\n", pregistry_priv->ldpc_cap);
3615 RTW_PRINT_SEL(sel, "[DRV CAP] VHT LDPC Tx : %s\n", (TEST_FLAG(pregistry_priv->ldpc_cap, BIT1)) ? "V" : "X"); /*BIT1: Enable VHT LDPC Tx*/
3616 RTW_PRINT_SEL(sel, "[DRV CAP] VHT LDPC Rx : %s\n", (TEST_FLAG(pregistry_priv->ldpc_cap, BIT0)) ? "V" : "X"); /*BIT0: Enable VHT LDPC Rx*/
3617 RTW_PRINT_SEL(sel, "[DRV CAP] HT LDPC Tx : %s\n", (TEST_FLAG(pregistry_priv->ldpc_cap, BIT5)) ? "V" : "X"); /*BIT5: Enable HT LDPC Tx*/
3618 RTW_PRINT_SEL(sel, "[DRV CAP] HT LDPC Rx : %s\n\n", (TEST_FLAG(pregistry_priv->ldpc_cap, BIT4)) ? "V" : "X"); /*BIT4: Enable HT LDPC Rx*/
3619 #endif /* CONFIG_80211N_HT */
3620 #ifdef CONFIG_BEAMFORMING
3621 #if 0
3622 RTW_PRINT_SEL(sel, "[DRV CAP] TxBF parameter : 0x%08x\n", phy_spec->txbf_param);
3623 RTW_PRINT_SEL(sel, "[DRV CAP] VHT Sounding Dim : %d\n", (phy_spec->txbf_param >> 24) & 0xFF); /*VHT Sounding Dim [31:24]*/
3624 RTW_PRINT_SEL(sel, "[DRV CAP] VHT Steering Ant : %d\n", (phy_spec->txbf_param >> 16) & 0xFF); /*VHT Steering Ant [23:16]*/
3625 RTW_PRINT_SEL(sel, "[DRV CAP] HT Sounding Dim : %d\n", (phy_spec->txbf_param >> 8) & 0xFF); /*HT Sounding Dim [15:8]*/
3626 RTW_PRINT_SEL(sel, "[DRV CAP] HT Steering Ant : %d\n", phy_spec->txbf_param & 0xFF); /*HT Steering Ant [7:0]*/
3627 #endif
3628
3629 /*
3630 * BIT0: Enable VHT SU Beamformer
3631 * BIT1: Enable VHT SU Beamformee
3632 * BIT2: Enable VHT MU Beamformer, depend on VHT SU Beamformer
3633 * BIT3: Enable VHT MU Beamformee, depend on VHT SU Beamformee
3634 * BIT4: Enable HT Beamformer
3635 * BIT5: Enable HT Beamformee
3636 */
3637 RTW_PRINT_SEL(sel, "[DRV CAP] TxBF Capability : 0x%02x\n", pregistry_priv->beamform_cap);
3638 RTW_PRINT_SEL(sel, "[DRV CAP] VHT MU Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT2)) ? "V" : "X");
3639 RTW_PRINT_SEL(sel, "[DRV CAP] VHT MU Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT3)) ? "V" : "X");
3640 RTW_PRINT_SEL(sel, "[DRV CAP] VHT SU Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT0)) ? "V" : "X");
3641 RTW_PRINT_SEL(sel, "[DRV CAP] VHT SU Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT1)) ? "V" : "X");
3642 RTW_PRINT_SEL(sel, "[DRV CAP] HT Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT4)) ? "V" : "X");
3643 RTW_PRINT_SEL(sel, "[DRV CAP] HT Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT5)) ? "V" : "X");
3644
3645 RTW_PRINT_SEL(sel, "[DRV CAP] Tx Bfer rf_num : %d\n", pregistry_priv->beamformer_rf_num);
3646 RTW_PRINT_SEL(sel, "[DRV CAP] Tx Bfee rf_num : %d\n", pregistry_priv->beamformee_rf_num);
3647 #endif
3648 }
3649
proc_get_stbc_cap(struct seq_file * m,void * v)3650 int proc_get_stbc_cap(struct seq_file *m, void *v)
3651 {
3652 struct net_device *dev = m->private;
3653 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3654 struct registry_priv *pregpriv = &padapter->registrypriv;
3655
3656 if (pregpriv)
3657 RTW_PRINT_SEL(m, "0x%04x\n", pregpriv->stbc_cap);
3658
3659 return 0;
3660 }
3661
proc_set_stbc_cap(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3662 ssize_t proc_set_stbc_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3663 {
3664 struct net_device *dev = data;
3665 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3666 struct registry_priv *pregpriv = &padapter->registrypriv;
3667 char tmp[32];
3668 u32 mode;
3669
3670 if (count < 1)
3671 return -EFAULT;
3672
3673 if (count > sizeof(tmp)) {
3674 rtw_warn_on(1);
3675 return -EFAULT;
3676 }
3677
3678 if (buffer && !copy_from_user(tmp, buffer, count)) {
3679
3680 int num = sscanf(tmp, "%d ", &mode);
3681
3682 if (num == 1 && pregpriv) {
3683 pregpriv->stbc_cap = mode;
3684 RTW_INFO("stbc_cap = 0x%02x\n", mode);
3685 }
3686 }
3687
3688 return count;
3689 }
3690
proc_get_ldpc_cap(struct seq_file * m,void * v)3691 int proc_get_ldpc_cap(struct seq_file *m, void *v)
3692 {
3693 struct net_device *dev = m->private;
3694 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3695 struct registry_priv *pregpriv = &padapter->registrypriv;
3696
3697 if (pregpriv)
3698 RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->ldpc_cap);
3699
3700 return 0;
3701 }
3702
proc_set_ldpc_cap(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3703 ssize_t proc_set_ldpc_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3704 {
3705 struct net_device *dev = data;
3706 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3707 struct registry_priv *pregpriv = &padapter->registrypriv;
3708 char tmp[32];
3709 u32 mode;
3710
3711 if (count < 1)
3712 return -EFAULT;
3713
3714 if (count > sizeof(tmp)) {
3715 rtw_warn_on(1);
3716 return -EFAULT;
3717 }
3718
3719 if (buffer && !copy_from_user(tmp, buffer, count)) {
3720
3721 int num = sscanf(tmp, "%d ", &mode);
3722
3723 if (num == 1 && pregpriv) {
3724 pregpriv->ldpc_cap = mode;
3725 RTW_INFO("ldpc_cap = 0x%02x\n", mode);
3726 }
3727 }
3728
3729 return count;
3730 }
3731 #ifdef CONFIG_BEAMFORMING
proc_get_txbf_cap(struct seq_file * m,void * v)3732 int proc_get_txbf_cap(struct seq_file *m, void *v)
3733 {
3734 struct net_device *dev = m->private;
3735 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3736 struct registry_priv *pregpriv = &padapter->registrypriv;
3737
3738 if (pregpriv)
3739 RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->beamform_cap);
3740
3741 return 0;
3742 }
3743
proc_set_txbf_cap(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3744 ssize_t proc_set_txbf_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3745 {
3746 struct net_device *dev = data;
3747 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3748 struct registry_priv *pregpriv = &padapter->registrypriv;
3749 char tmp[32];
3750 u32 mode;
3751
3752 if (count < 1)
3753 return -EFAULT;
3754
3755 if (count > sizeof(tmp)) {
3756 rtw_warn_on(1);
3757 return -EFAULT;
3758 }
3759
3760 if (buffer && !copy_from_user(tmp, buffer, count)) {
3761
3762 int num = sscanf(tmp, "%d ", &mode);
3763
3764 if (num == 1 && pregpriv) {
3765 pregpriv->beamform_cap = mode;
3766 RTW_INFO("beamform_cap = 0x%02x\n", mode);
3767 }
3768 }
3769
3770 return count;
3771 }
3772 #endif
3773 #endif /* CONFIG_80211N_HT */
3774
3775 /*int proc_get_rssi_disp(struct seq_file *m, void *v)
3776 {
3777 struct net_device *dev = m->private;
3778 return 0;
3779 }
3780 */
3781
3782 /*ssize_t proc_set_rssi_disp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3783 {
3784 struct net_device *dev = data;
3785 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3786 char tmp[32];
3787 u32 enable=0;
3788
3789 if (count < 1)
3790 {
3791 RTW_INFO("argument size is less than 1\n");
3792 return -EFAULT;
3793 }
3794
3795 if (count > sizeof(tmp)) {
3796 rtw_warn_on(1);
3797 return -EFAULT;
3798 }
3799
3800 if (buffer && !copy_from_user(tmp, buffer, count)) {
3801
3802 int num = sscanf(tmp, "%x", &enable);
3803
3804 if (num != 1) {
3805 RTW_INFO("invalid set_rssi_disp parameter!\n");
3806 return count;
3807 }
3808
3809 if(enable)
3810 {
3811 RTW_INFO("Linked info Function Enable\n");
3812 padapter->bLinkInfoDump = enable ;
3813 }
3814 else
3815 {
3816 RTW_INFO("Linked info Function Disable\n");
3817 padapter->bLinkInfoDump = 0 ;
3818 }
3819
3820 }
3821
3822 return count;
3823
3824 }
3825
3826 */
3827 #ifdef CONFIG_AP_MODE
3828
dump_phl_tring_status(struct seq_file * m,_adapter * padapter,struct sta_info * psta)3829 void dump_phl_tring_status(struct seq_file *m, _adapter *padapter, struct sta_info *psta)
3830 {
3831 int i = 0;
3832 u16 tring_len = 0;
3833
3834 RTW_PRINT_SEL(m, "PHL_tring_len=");
3835 for (i = 0; i < MAX_PHL_RING_CAT_NUM; i++) {
3836 tring_len = rtw_phl_tring_rsc(padapter->dvobj->phl, psta->phl_sta->macid, i);
3837 RTW_PRINT_SEL(m, "%d ", tring_len);
3838 }
3839 RTW_PRINT_SEL(m, "\n");
3840 }
3841
proc_get_all_sta_info(struct seq_file * m,void * v)3842 int proc_get_all_sta_info(struct seq_file *m, void *v)
3843 {
3844 struct net_device *dev = m->private;
3845 struct sta_info *psta;
3846 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3847 struct sta_priv *pstapriv = &padapter->stapriv;
3848 int i;
3849 _list *plist, *phead;
3850
3851 RTW_MAP_DUMP_SEL_ALWAYS(m, "sta_dz_bitmap=", pstapriv->sta_dz_bitmap, pstapriv->aid_bmp_len);
3852 RTW_MAP_DUMP_SEL_ALWAYS(m, "tim_bitmap=", pstapriv->tim_bitmap, pstapriv->aid_bmp_len);
3853
3854 _rtw_spinlock_bh(&pstapriv->sta_hash_lock);
3855
3856 for (i = 0; i < NUM_STA; i++) {
3857 phead = &(pstapriv->sta_hash[i]);
3858 plist = get_next(phead);
3859
3860 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
3861 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
3862
3863 plist = get_next(plist);
3864
3865 /* if(extra_arg == psta->phl_sta->aid) */
3866 {
3867 RTW_PRINT_SEL(m, "==============================\n");
3868 RTW_PRINT_SEL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->phl_sta->mac_addr));
3869 RTW_PRINT_SEL(m, "ieee8021x_blocked=%d\n", psta->ieee8021x_blocked);
3870 RTW_PRINT_SEL(m, "rtsen=%d, cts2slef=%d, hw_rts_en=%d\n",
3871 psta->rtsen, psta->cts2self, psta->hw_rts_en);
3872 /* ToDo: need API to query hal_sta->ra_info.rate_id */
3873 /* RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n",
3874 psta->state, psta->phl_sta->aid, psta->phl_sta->macid, psta->phl_sta->hal_sta->ra_info.rate_id); */
3875 RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d\n",
3876 psta->state, psta->phl_sta->aid, psta->phl_sta->macid);
3877 #ifdef CONFIG_RTS_FULL_BW
3878 if(psta->vendor_8812)
3879 RTW_PRINT_SEL(m,"Vendor Realtek 8812\n");
3880 #endif/*CONFIG_RTS_FULL_BW*/
3881 #ifdef CONFIG_80211N_HT
3882 RTW_PRINT_SEL(m, "qos_en=%d, ht_en=%d, init_rate=%d, ht_bitrate=%u\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate
3883 , rtw_desc_rate_to_bitrate(psta->phl_sta->chandef.bw, psta->init_rate, psta->phl_sta->chandef.bw ? psta->htpriv.sgi_40m : psta->htpriv.sgi_20m) / 10);
3884 RTW_PRINT_SEL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n"
3885 , psta->phl_sta->chandef.bw, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
3886 RTW_PRINT_SEL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
3887 RTW_PRINT_SEL(m, "tx_amsdu_enable = %d\n", psta->htpriv.tx_amsdu_enable);
3888 RTW_PRINT_SEL(m, "Is_8K_AMSDU = %d\n", (psta->htpriv.ht_cap.cap_info & IEEE80211_HT_CAP_MAX_AMSDU)?1:0);
3889 RTW_PRINT_SEL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
3890 #endif /* CONFIG_80211N_HT */
3891 #ifdef CONFIG_80211AC_VHT
3892 RTW_PRINT_SEL(m, "vht_en=%d, vht_sgi_80m=%d, vht_bitrate=%u\n", psta->vhtpriv.vht_option, psta->vhtpriv.sgi_80m
3893 , psta->vhtpriv.vht_option ? rtw_vht_mcs_to_data_rate(CHANNEL_WIDTH_80, psta->vhtpriv.sgi_80m, psta->vhtpriv.vht_highest_rate) / 2 : 0);
3894 RTW_PRINT_SEL(m, "vht_ldpc_cap=0x%x, vht_stbc_cap=0x%x, vht_beamform_cap=0x%x\n", psta->vhtpriv.ldpc_cap, psta->vhtpriv.stbc_cap, psta->vhtpriv.beamform_cap);
3895 RTW_PRINT_SEL(m, "vht_mcs_map=0x%x, vht_highest_rate=0x%x, vht_ampdu_len=%d\n", *(u16 *)psta->vhtpriv.vht_mcs_map, psta->vhtpriv.vht_highest_rate, psta->vhtpriv.ampdu_len);
3896 if (psta->vhtpriv.vht_option) {
3897 RTW_MAP_DUMP_SEL_ALWAYS(m, "vht_cap=", psta->vhtpriv.vht_cap, 32);
3898 } else {
3899 RTW_PRINT_SEL(m, "vht_cap=N/A\n");
3900 }
3901 #endif
3902 #ifdef CONFIG_80211AX_HE
3903 RTW_PRINT_SEL(m, "he_en=%d\n", psta->hepriv.he_option);
3904 if (psta->hepriv.he_option) {
3905 RTW_MAP_DUMP_SEL_ALWAYS(m, "he_cap=", psta->hepriv.he_cap, HE_CAP_ELE_MAX_LEN);
3906 } else {
3907 RTW_PRINT_SEL(m, "he_cap=N/A\n");
3908 }
3909 #endif
3910 RTW_PRINT_SEL(m, "tx_nss=%d\n", rtw_get_sta_tx_nss(padapter, psta));
3911 RTW_PRINT_SEL(m, "rx_nss=%d\n", rtw_get_sta_rx_nss(padapter, psta));
3912 RTW_PRINT_SEL(m, "sleepq_len=%d\n", psta->sleepq_len);
3913 RTW_PRINT_SEL(m, "sta_xmitpriv.vo_q_qcnt=%d\n", psta->sta_xmitpriv.vo_q.qcnt);
3914 RTW_PRINT_SEL(m, "sta_xmitpriv.vi_q_qcnt=%d\n", psta->sta_xmitpriv.vi_q.qcnt);
3915 RTW_PRINT_SEL(m, "sta_xmitpriv.be_q_qcnt=%d\n", psta->sta_xmitpriv.be_q.qcnt);
3916 RTW_PRINT_SEL(m, "sta_xmitpriv.bk_q_qcnt=%d\n", psta->sta_xmitpriv.bk_q.qcnt);
3917
3918 RTW_PRINT_SEL(m, "capability=0x%x\n", psta->capability);
3919 RTW_PRINT_SEL(m, "flags=0x%x\n", psta->flags);
3920 RTW_PRINT_SEL(m, "isPMF=%d\n", (psta->flags & WLAN_STA_MFP)?1:0);
3921 RTW_PRINT_SEL(m, "wpa_psk=0x%x\n", psta->wpa_psk);
3922 RTW_PRINT_SEL(m, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
3923 RTW_PRINT_SEL(m, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
3924 RTW_PRINT_SEL(m, "qos_info=0x%x\n", psta->qos_info);
3925 RTW_PRINT_SEL(m, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
3926 RTW_PRINT_SEL(m, "AuthAlgrthm=0x%x\n", psta->authalg);
3927 #ifdef CONFIG_RECV_REORDERING_CTRL
3928 sta_rx_reorder_ctl_dump(m, psta);
3929 #endif
3930 #ifdef CONFIG_TDLS
3931 RTW_PRINT_SEL(m, "tdls_sta_state=0x%08x\n", psta->tdls_sta_state);
3932 RTW_PRINT_SEL(m, "PeerKey_Lifetime=%d\n", psta->TDLS_PeerKey_Lifetime);
3933 #endif /* CONFIG_TDLS */
3934 if(psta->bssratelen >= 0 && psta->bssratelen <= 16)
3935 RTW_MAP_DUMP_SEL_ALWAYS(m, "bssrateset=", psta->bssrateset, psta->bssratelen);
3936 RTW_PRINT_SEL(m, "rx_data_uc_pkts=%llu\n", sta_rx_data_uc_pkts(psta));
3937 RTW_PRINT_SEL(m, "rx_data_mc_pkts=%llu\n", psta->sta_stats.rx_data_mc_pkts);
3938 RTW_PRINT_SEL(m, "rx_data_bc_pkts=%llu\n", psta->sta_stats.rx_data_bc_pkts);
3939 RTW_PRINT_SEL(m, "rx_uc_bytes=%llu\n", sta_rx_uc_bytes(psta));
3940 RTW_PRINT_SEL(m, "rx_mc_bytes=%llu\n", psta->sta_stats.rx_mc_bytes);
3941 RTW_PRINT_SEL(m, "rx_bc_bytes=%llu\n", psta->sta_stats.rx_bc_bytes);
3942 if (psta->sta_stats.rx_tp_kbits >> 10)
3943 RTW_PRINT_SEL(m, "rx_tp =%d (Mbps)\n", psta->sta_stats.rx_tp_kbits >> 10);
3944 else
3945 RTW_PRINT_SEL(m, "rx_tp =%d (Kbps)\n", psta->sta_stats.rx_tp_kbits);
3946
3947 RTW_PRINT_SEL(m, "tx_data_pkts=%llu\n", psta->sta_stats.tx_pkts);
3948 RTW_PRINT_SEL(m, "tx_bytes=%llu\n", psta->sta_stats.tx_bytes);
3949 if (psta->sta_stats.tx_tp_kbits >> 10)
3950 RTW_PRINT_SEL(m, "tx_tp =%d (Mbps)\n", psta->sta_stats.tx_tp_kbits >> 10);
3951 else
3952 RTW_PRINT_SEL(m, "tx_tp =%d (Kbps)\n", psta->sta_stats.tx_tp_kbits);
3953 #ifdef CONFIG_RTW_80211K
3954 RTW_PRINT_SEL(m, "rm_en_cap="RM_CAP_FMT"\n", RM_CAP_ARG(psta->rm_en_cap));
3955 #endif
3956 dump_st_ctl(m, &psta->st_ctl);
3957
3958 if (STA_OP_WFD_MODE(psta))
3959 RTW_PRINT_SEL(m, "op_wfd_mode:0x%02x\n", STA_OP_WFD_MODE(psta));
3960
3961 RTW_PRINT_SEL(m, "tx_bitrate_100kbps=%u\n",
3962 rtw_desc_rate_to_bitrate(psta->phl_sta->wrole->chandef.bw,
3963 rtw_get_current_tx_rate(padapter, psta),
3964 rtw_get_current_tx_sgi(padapter, psta)));
3965 RTW_PRINT_SEL(m, "rx_bitrate_100kbps=%u\n",
3966 rtw_desc_rate_to_bitrate(psta->phl_sta->wrole->chandef.bw,
3967 psta->curr_rx_rate, psta->curr_rx_gi_ltf));
3968
3969 RTW_PRINT_SEL(m, "rssi=%d\n", rtw_phl_get_sta_rssi(psta->phl_sta));
3970
3971 dump_phl_tring_status(m, padapter, psta);
3972 RTW_PRINT_SEL(m, "==============================\n");
3973 }
3974
3975 }
3976
3977 }
3978
3979 _rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
3980
3981 return 0;
3982 }
3983
3984 #endif
3985
3986 #ifdef CONFIG_RTKM
proc_get_rtkm_info(struct seq_file * m,void * v)3987 int proc_get_rtkm_info(struct seq_file *m, void *v)
3988 {
3989 rtkm_dump_mstatus(m);
3990 return 0;
3991 }
3992
proc_set_rtkm_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3993 ssize_t proc_set_rtkm_info(struct file *file, const char __user *buffer,
3994 size_t count, loff_t *pos, void *data)
3995 {
3996 char tmp[32] = { 0 };
3997 unsigned int mask = 0;
3998
3999 if (count < 1)
4000 return -EFAULT;
4001
4002 if (count > sizeof(tmp)) {
4003 rtw_warn_on(1);
4004 return -EFAULT;
4005 }
4006
4007 if (buffer && !copy_from_user(tmp, buffer, count)) {
4008 int num = sscanf(tmp, "%x", &mask);
4009
4010 if (num == 1)
4011 rtkm_set_trace(mask);
4012 }
4013
4014 return count;
4015 }
4016 #endif /* CONFIG_RTKM */
4017
4018 #ifdef DBG_MEMORY_LEAK
4019 #include <asm/atomic.h>
4020 extern ATOMIC_T _malloc_cnt;
4021 extern ATOMIC_T _malloc_size;
4022
proc_get_malloc_cnt(struct seq_file * m,void * v)4023 int proc_get_malloc_cnt(struct seq_file *m, void *v)
4024 {
4025 RTW_PRINT_SEL(m, "_malloc_cnt=%d\n", atomic_read(&_malloc_cnt));
4026 RTW_PRINT_SEL(m, "_malloc_size=%d\n", atomic_read(&_malloc_size));
4027
4028 return 0;
4029 }
4030 #endif /* DBG_MEMORY_LEAK */
4031
4032 #ifdef CONFIG_FIND_BEST_CHANNEL
proc_get_best_channel(struct seq_file * m,void * v)4033 int proc_get_best_channel(struct seq_file *m, void *v)
4034 {
4035 struct net_device *dev = m->private;
4036 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4037 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
4038 u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
4039
4040 for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++) {
4041 if (rfctl->channel_set[i].ChannelNum == 1)
4042 index_24G = i;
4043 if (rfctl->channel_set[i].ChannelNum == 36)
4044 index_5G = i;
4045 }
4046
4047 for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++) {
4048 /* 2.4G */
4049 if (rfctl->channel_set[i].ChannelNum == 6) {
4050 if (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_24G].rx_count) {
4051 index_24G = i;
4052 best_channel_24G = rfctl->channel_set[i].ChannelNum;
4053 }
4054 }
4055
4056 /* 5G */
4057 if (rfctl->channel_set[i].ChannelNum >= 36
4058 && rfctl->channel_set[i].ChannelNum < 140) {
4059 /* Find primary channel */
4060 if (((rfctl->channel_set[i].ChannelNum - 36) % 8 == 0)
4061 && (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_5G].rx_count)) {
4062 index_5G = i;
4063 best_channel_5G = rfctl->channel_set[i].ChannelNum;
4064 }
4065 }
4066
4067 if (rfctl->channel_set[i].ChannelNum >= 149
4068 && rfctl->channel_set[i].ChannelNum < 165) {
4069 /* find primary channel */
4070 if (((rfctl->channel_set[i].ChannelNum - 149) % 8 == 0)
4071 && (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_5G].rx_count)) {
4072 index_5G = i;
4073 best_channel_5G = rfctl->channel_set[i].ChannelNum;
4074 }
4075 }
4076 #if 1 /* debug */
4077 RTW_PRINT_SEL(m, "The rx cnt of channel %3d = %d\n",
4078 rfctl->channel_set[i].ChannelNum, rfctl->channel_set[i].rx_count);
4079 #endif
4080 }
4081
4082 RTW_PRINT_SEL(m, "best_channel_5G = %d\n", best_channel_5G);
4083 RTW_PRINT_SEL(m, "best_channel_24G = %d\n", best_channel_24G);
4084
4085 return 0;
4086 }
4087
proc_set_best_channel(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4088 ssize_t proc_set_best_channel(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4089 {
4090 struct net_device *dev = data;
4091 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4092 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
4093 char tmp[32];
4094
4095 if (count < 1)
4096 return -EFAULT;
4097
4098 if (count > sizeof(tmp)) {
4099 rtw_warn_on(1);
4100 return -EFAULT;
4101 }
4102
4103 if (buffer && !copy_from_user(tmp, buffer, count)) {
4104 int i;
4105 for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++)
4106 rfctl->channel_set[i].rx_count = 0;
4107
4108 RTW_INFO("set %s\n", "Clean Best Channel Count");
4109 }
4110
4111 return count;
4112 }
4113 #endif /* CONFIG_FIND_BEST_CHANNEL */
4114
4115 #ifdef CONFIG_BTC
proc_get_btc_dbg(struct seq_file * m,void * v)4116 int proc_get_btc_dbg(struct seq_file *m, void *v)
4117 {
4118 struct net_device *dev = m->private;
4119 _adapter *padapter;
4120 char buf[512] = {0};
4121 padapter = (_adapter *)rtw_netdev_priv(dev);
4122
4123 rtw_btc_get_dbg(padapter, buf, 512);
4124
4125 _RTW_PRINT_SEL(m, "%s", buf);
4126
4127 return 0;
4128 }
4129
proc_set_btc_dbg(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4130 ssize_t proc_set_btc_dbg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4131 {
4132 struct net_device *dev = data;
4133 _adapter *padapter;
4134 u8 tmp[80] = {0};
4135 u32 module[2] = {0};
4136 u32 num;
4137
4138 padapter = (_adapter *)rtw_netdev_priv(dev);
4139
4140 /* RTW_INFO("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter)); */
4141
4142 if (NULL == buffer) {
4143 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n",
4144 FUNC_ADPT_ARG(padapter));
4145
4146 return -EFAULT;
4147 }
4148
4149 if (count < 1) {
4150 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n",
4151 FUNC_ADPT_ARG(padapter));
4152
4153 return -EFAULT;
4154 }
4155
4156 num = count;
4157 if (num > (sizeof(tmp) - 1))
4158 num = (sizeof(tmp) - 1);
4159
4160 if (copy_from_user(tmp, buffer, num)) {
4161 RTW_INFO(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
4162 FUNC_ADPT_ARG(padapter));
4163
4164 return -EFAULT;
4165 }
4166
4167 num = sscanf(tmp, "%x %x", module, module + 1);
4168 if (1 == num) {
4169 if (0 == module[0])
4170 _rtw_memset(module, 0, sizeof(module));
4171 else
4172 _rtw_memset(module, 0xFF, sizeof(module));
4173 } else if (2 != num) {
4174 RTW_INFO(FUNC_ADPT_FMT ": input(\"%s\") format incorrect!\n",
4175 FUNC_ADPT_ARG(padapter), tmp);
4176
4177 if (0 == num)
4178 return -EFAULT;
4179 }
4180
4181 RTW_INFO(FUNC_ADPT_FMT ": input 0x%08X 0x%08X\n",
4182 FUNC_ADPT_ARG(padapter), module[0], module[1]);
4183 rtw_btc_set_dbg(padapter, module);
4184
4185 return count;
4186 }
4187
proc_get_btc_info(struct seq_file * m,void * v)4188 int proc_get_btc_info(struct seq_file *m, void *v)
4189 {
4190 struct net_device *dev = m->private;
4191 _adapter *padapter;
4192
4193 padapter = (_adapter *)rtw_netdev_priv(dev);
4194
4195 rtw_btc_disp_btc_info(padapter, (void*)m, 0);
4196
4197 return 0;
4198 }
4199 #endif /* CONFIG_BTC */
4200
4201 #if defined(DBG_CONFIG_ERROR_DETECT)
proc_get_sreset(struct seq_file * m,void * v)4202 int proc_get_sreset(struct seq_file *m, void *v)
4203 {
4204 struct net_device *dev = m->private;
4205 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4206 struct dvobj_priv *psdpriv = padapter->dvobj;
4207 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
4208 HAL_DATA_TYPE *pHalData = GET_PHL_COM(psdpriv);
4209 struct sreset_priv *psrtpriv = &pHalData->srestpriv;
4210
4211 if (psrtpriv->dbg_sreset_ctrl == _TRUE) {
4212 RTW_PRINT_SEL(m, "self_dect_tx_cnt:%llu\n", psrtpriv->self_dect_tx_cnt);
4213 RTW_PRINT_SEL(m, "self_dect_rx_cnt:%llu\n", psrtpriv->self_dect_rx_cnt);
4214 RTW_PRINT_SEL(m, "self_dect_fw_cnt:%llu\n", psrtpriv->self_dect_fw_cnt);
4215 RTW_PRINT_SEL(m, "tx_dma_status_cnt:%llu\n", psrtpriv->tx_dma_status_cnt);
4216 RTW_PRINT_SEL(m, "rx_dma_status_cnt:%llu\n", psrtpriv->rx_dma_status_cnt);
4217 RTW_PRINT_SEL(m, "self_dect_case:%d\n", psrtpriv->self_dect_case);
4218 RTW_PRINT_SEL(m, "dbg_sreset_cnt:%d\n", pdbgpriv->dbg_sreset_cnt);
4219 }
4220 return 0;
4221 }
4222
proc_set_sreset(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4223 ssize_t proc_set_sreset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4224 {
4225 struct net_device *dev = data;
4226 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4227 HAL_DATA_TYPE *pHalData = GET_PHL_COM(adapter_to_dvobj(padapter));
4228 struct sreset_priv *psrtpriv = &pHalData->srestpriv;
4229 char tmp[32];
4230 s32 trigger_point;
4231
4232 if (count < 1)
4233 return -EFAULT;
4234
4235 if (count > sizeof(tmp)) {
4236 rtw_warn_on(1);
4237 return -EFAULT;
4238 }
4239
4240 if (buffer && !copy_from_user(tmp, buffer, count)) {
4241
4242 int num = sscanf(tmp, "%d", &trigger_point);
4243
4244 if (num < 1)
4245 return count;
4246
4247 if (trigger_point == SRESET_TGP_NULL)
4248 rtw_hal_sreset_reset(padapter);
4249 else if (trigger_point == SRESET_TGP_INFO)
4250 psrtpriv->dbg_sreset_ctrl = _TRUE;
4251 else
4252 sreset_set_trigger_point(padapter, trigger_point);
4253 }
4254
4255 return count;
4256
4257 }
4258 #endif /* DBG_CONFIG_ERROR_DETECT */
4259
4260 #ifdef CONFIG_PCI_HCI
4261
proc_set_pci_bridge_conf_space(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4262 ssize_t proc_set_pci_bridge_conf_space(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4263 {
4264 struct net_device *dev = data;
4265 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4266 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4267 PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
4268 struct pci_dev *pdev = pci_data->ppcidev;
4269 struct pci_dev *bridge_pdev = pdev->bus->self;
4270
4271 char tmp[32] = { 0 };
4272 int num;
4273
4274 u32 reg = 0, value = 0;
4275
4276 if (count < 1)
4277 return -EFAULT;
4278
4279 if (count > sizeof(tmp)) {
4280 rtw_warn_on(1);
4281 return -EFAULT;
4282 }
4283
4284 if (buffer && !copy_from_user(tmp, buffer, count)) {
4285
4286 num = sscanf(tmp, "%x %x", ®, &value);
4287 if (num != 2) {
4288 RTW_INFO("invalid parameter!\n");
4289 return count;
4290 }
4291
4292 if (reg >= 0x1000) {
4293 RTW_INFO("invalid register!\n");
4294 return count;
4295 }
4296
4297 if (value > 0xFF) {
4298 RTW_INFO("invalid value! Only one byte\n");
4299 return count;
4300 }
4301
4302 RTW_INFO(FUNC_ADPT_FMT ": register 0x%x value 0x%x\n",
4303 FUNC_ADPT_ARG(padapter), reg, value);
4304
4305 pci_write_config_byte(bridge_pdev, reg, value);
4306 }
4307 return count;
4308 }
4309
4310
proc_get_pci_bridge_conf_space(struct seq_file * m,void * v)4311 int proc_get_pci_bridge_conf_space(struct seq_file *m, void *v)
4312 {
4313 struct net_device *dev = m->private;
4314 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
4315 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4316 PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
4317 struct pci_dev *pdev = pci_data->ppcidev;
4318 struct pci_dev *bridge_pdev = pdev->bus->self;
4319
4320 u32 tmp[4] = { 0 };
4321 u32 i, j;
4322
4323 RTW_PRINT_SEL(m, "\n***** PCI Host Device Configuration Space*****\n\n");
4324
4325 for (i = 0; i < 0x1000; i += 0x10) {
4326 for (j = 0 ; j < 4 ; j++)
4327 pci_read_config_dword(bridge_pdev, i + j * 4, tmp+j);
4328
4329 RTW_PRINT_SEL(m, "%03x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
4330 i, tmp[0] & 0xFF, (tmp[0] >> 8) & 0xFF, (tmp[0] >> 16) & 0xFF, (tmp[0] >> 24) & 0xFF,
4331 tmp[1] & 0xFF, (tmp[1] >> 8) & 0xFF, (tmp[1] >> 16) & 0xFF, (tmp[1] >> 24) & 0xFF,
4332 tmp[2] & 0xFF, (tmp[2] >> 8) & 0xFF, (tmp[2] >> 16) & 0xFF, (tmp[2] >> 24) & 0xFF,
4333 tmp[3] & 0xFF, (tmp[3] >> 8) & 0xFF, (tmp[3] >> 16) & 0xFF, (tmp[3] >> 24) & 0xFF);
4334 }
4335 return 0;
4336 }
4337
4338
proc_set_pci_conf_space(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4339 ssize_t proc_set_pci_conf_space(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4340 {
4341 struct net_device *dev = data;
4342 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4343 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4344 PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
4345 struct pci_dev *pdev = pci_data->ppcidev;
4346
4347 char tmp[32] = { 0 };
4348 int num;
4349
4350 u32 reg = 0, value = 0;
4351
4352 if (count < 1)
4353 return -EFAULT;
4354
4355 if (count > sizeof(tmp)) {
4356 rtw_warn_on(1);
4357 return -EFAULT;
4358 }
4359
4360 if (buffer && !copy_from_user(tmp, buffer, count)) {
4361
4362 num = sscanf(tmp, "%x %x", ®, &value);
4363
4364 if (num != 2) {
4365 RTW_INFO("invalid parameter!\n");
4366 return count;
4367 }
4368
4369
4370 if (reg >= 0x1000) {
4371 RTW_INFO("invalid register!\n");
4372 return count;
4373 }
4374
4375 if (value > 0xFF) {
4376 RTW_INFO("invalid value! Only one byte\n");
4377 return count;
4378 }
4379
4380 RTW_INFO(FUNC_ADPT_FMT ": register 0x%x value 0x%x\n",
4381 FUNC_ADPT_ARG(padapter), reg, value);
4382
4383 pci_write_config_byte(pdev, reg, value);
4384
4385
4386 }
4387 return count;
4388 }
4389
4390
proc_get_pci_conf_space(struct seq_file * m,void * v)4391 int proc_get_pci_conf_space(struct seq_file *m, void *v)
4392 {
4393 struct net_device *dev = m->private;
4394 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
4395 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4396 PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
4397 struct pci_dev *pdev = pci_data->ppcidev;
4398 struct pci_dev *bridge_pdev = pdev->bus->self;
4399
4400 u32 tmp[4] = { 0 };
4401 u32 i, j;
4402
4403 RTW_PRINT_SEL(m, "\n***** PCI Device Configuration Space *****\n\n");
4404
4405 for (i = 0; i < 0x1000; i += 0x10) {
4406 for (j = 0 ; j < 4 ; j++)
4407 pci_read_config_dword(pdev, i + j * 4, tmp+j);
4408
4409 RTW_PRINT_SEL(m, "%03x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
4410 i, tmp[0] & 0xFF, (tmp[0] >> 8) & 0xFF, (tmp[0] >> 16) & 0xFF, (tmp[0] >> 24) & 0xFF,
4411 tmp[1] & 0xFF, (tmp[1] >> 8) & 0xFF, (tmp[1] >> 16) & 0xFF, (tmp[1] >> 24) & 0xFF,
4412 tmp[2] & 0xFF, (tmp[2] >> 8) & 0xFF, (tmp[2] >> 16) & 0xFF, (tmp[2] >> 24) & 0xFF,
4413 tmp[3] & 0xFF, (tmp[3] >> 8) & 0xFF, (tmp[3] >> 16) & 0xFF, (tmp[3] >> 24) & 0xFF);
4414 }
4415
4416 return 0;
4417 }
4418
4419
proc_get_pci_aspm(struct seq_file * m,void * v)4420 int proc_get_pci_aspm(struct seq_file *m, void *v)
4421 {
4422 struct net_device *dev = m->private;
4423 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
4424 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4425 PPCI_DATA pci_data = dvobj_to_pci(pdvobjpriv);
4426 struct pci_priv *pcipriv = &(pci_data->pcipriv);
4427 u8 tmp8 = 0;
4428 u16 tmp16 = 0;
4429 u32 tmp32 = 0;
4430 u8 l1_idle = 0;
4431
4432
4433 RTW_PRINT_SEL(m, "***** ASPM Capability *****\n");
4434
4435 pci_read_config_dword(pci_data->ppcidev, pcipriv->pciehdr_offset + PCI_EXP_LNKCAP, &tmp32);
4436
4437 RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp32&PCI_EXP_LNKCAP_CLKPM) ? "Enable" : "Disable");
4438 RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp32&BIT10) ? "Enable" : "Disable");
4439 RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp32&BIT11) ? "Enable" : "Disable");
4440
4441 tmp8 = rtw_hal_pci_l1off_capability(padapter);
4442 RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", tmp8 ? "Enable" : "Disable");
4443
4444 RTW_PRINT_SEL(m, "***** ASPM CTRL Reg *****\n");
4445
4446 pci_read_config_word(pci_data->ppcidev, pcipriv->pciehdr_offset + PCI_EXP_LNKCTL, &tmp16);
4447
4448 RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp16&PCI_EXP_LNKCTL_CLKREQ_EN) ? "Enable" : "Disable");
4449 RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp16&BIT0) ? "Enable" : "Disable");
4450 RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp16&BIT1) ? "Enable" : "Disable");
4451
4452 tmp8 = rtw_hal_pci_l1off_nic_support(padapter);
4453 RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", tmp8 ? "Enable" : "Disable");
4454
4455 RTW_PRINT_SEL(m, "***** ASPM Backdoor *****\n");
4456
4457 pci_read_config_byte(pci_data->ppcidev, 0x719, &tmp8);
4458 RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp8 & BIT4) ? "Enable" : "Disable");
4459
4460 pci_read_config_byte(pci_data->ppcidev, 0x70f, &tmp8);
4461 l1_idle = tmp8 & 0x38;
4462 RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp8 & BIT7) ? "Enable" : "Disable");
4463
4464 pci_read_config_byte(pci_data->ppcidev, 0x719, &tmp8);
4465 RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp8 & BIT3) ? "Enable" : "Disable");
4466
4467 pci_read_config_byte(pci_data->ppcidev, 0x718, &tmp8);
4468 RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", (tmp8 & BIT5) ? "Enable" : "Disable");
4469
4470 RTW_PRINT_SEL(m, "********* MISC **********\n");
4471 RTW_PRINT_SEL(m, "ASPM L1 Idel Time: 0x%x\n", l1_idle>>3);
4472 RTW_PRINT_SEL(m, "*************************\n");
4473
4474 #ifdef CONFIG_PCI_DYNAMIC_ASPM
4475 RTW_PRINT_SEL(m, "Dynamic ASPM mode: %d (%s)\n", pcipriv->aspm_mode,
4476 pcipriv->aspm_mode == ASPM_MODE_PERF ? "Perf" :
4477 pcipriv->aspm_mode == ASPM_MODE_PS ? "PS" : "Und");
4478 #endif
4479
4480 return 0;
4481 }
4482
proc_get_rx_ring(struct seq_file * m,void * v)4483 int proc_get_rx_ring(struct seq_file *m, void *v)
4484 {
4485
4486 return 0;
4487 }
4488
proc_get_tx_ring(struct seq_file * m,void * v)4489 int proc_get_tx_ring(struct seq_file *m, void *v)
4490 {
4491 struct net_device *dev = m->private;
4492 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
4493 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4494 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
4495 int i, j, k;
4496 unsigned long sp_flags;
4497
4498 _rtw_spinlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
4499 for (i = 0; i < PCI_MAX_TX_QUEUE_COUNT; i++) {
4500 struct rtw_tx_ring *tx_ring = &pxmitpriv->tx_ring[i];
4501
4502 RTW_PRINT_SEL(m, "tx ring[%d] (%p)\n", i, tx_ring);
4503 RTW_PRINT_SEL(m, " dma: 0x%08x\n", (int) tx_ring->dma);
4504 RTW_PRINT_SEL(m, " idx: %d\n", tx_ring->idx);
4505 RTW_PRINT_SEL(m, " entries: %d\n", tx_ring->entries);
4506 /* RTW_PRINT_SEL(m, " queue: %d\n", tx_ring->queue); */
4507 RTW_PRINT_SEL(m, " qlen: %d\n", tx_ring->qlen);
4508
4509 for (j = 0; j < pxmitpriv->txringcount[i]; j++) {
4510 #ifdef CONFIG_TRX_BD_ARCH
4511 struct tx_buf_desc *entry = &tx_ring->buf_desc[j];
4512 RTW_PRINT_SEL(m, " buf_desc[%03d]: %p\n", j, entry);
4513 #else
4514 struct tx_desc *entry = &tx_ring->desc[j];
4515 RTW_PRINT_SEL(m, " desc[%03d]: %p\n", j, entry);
4516 #endif
4517
4518 for (k = 0; k < sizeof(*entry) / 4; k++) {
4519 if ((k % 4) == 0)
4520 RTW_PRINT_SEL(m, " 0x%03x", k);
4521
4522 RTW_PRINT_SEL(m, " 0x%08x ", ((int *) entry)[k]);
4523
4524 if ((k % 4) == 3)
4525 RTW_PRINT_SEL(m, "\n");
4526 }
4527 }
4528 }
4529 _rtw_spinunlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
4530
4531 return 0;
4532 }
4533
4534 #ifdef DBG_TXBD_DESC_DUMP
proc_get_tx_ring_ext(struct seq_file * m,void * v)4535 int proc_get_tx_ring_ext(struct seq_file *m, void *v)
4536 {
4537 struct net_device *dev = m->private;
4538 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
4539 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4540 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
4541 struct rtw_tx_desc_backup *pbuf;
4542 int i, j, k, idx;
4543 unsigned long sp_flags;
4544
4545 RTW_PRINT_SEL(m, "<<<< tx ring ext dump settings >>>>\n");
4546 RTW_PRINT_SEL(m, " - backup frame num: %d\n", TX_BAK_FRMAE_CNT);
4547 RTW_PRINT_SEL(m, " - backup max. desc size: %d bytes\n", TX_BAK_DESC_LEN);
4548 RTW_PRINT_SEL(m, " - backup data size: %d bytes\n\n", TX_BAK_DATA_LEN);
4549
4550 if (!pxmitpriv->dump_txbd_desc) {
4551 RTW_PRINT_SEL(m, "Dump function is disabled.\n");
4552 return 0;
4553 }
4554
4555 _rtw_spinlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
4556 for (i = 0; i < HW_QUEUE_ENTRY; i++) {
4557 struct rtw_tx_ring *tx_ring = &pxmitpriv->tx_ring[i];
4558
4559 idx = rtw_get_tx_desc_backup(padapter, i, &pbuf);
4560
4561 RTW_PRINT_SEL(m, "Tx ring[%d]", i);
4562 switch (i) {
4563 case 0:
4564 RTW_PRINT_SEL(m, " (VO)\n");
4565 break;
4566 case 1:
4567 RTW_PRINT_SEL(m, " (VI)\n");
4568 break;
4569 case 2:
4570 RTW_PRINT_SEL(m, " (BE)\n");
4571 break;
4572 case 3:
4573 RTW_PRINT_SEL(m, " (BK)\n");
4574 break;
4575 case 4:
4576 RTW_PRINT_SEL(m, " (BCN)\n");
4577 break;
4578 case 5:
4579 RTW_PRINT_SEL(m, " (MGT)\n");
4580 break;
4581 case 6:
4582 RTW_PRINT_SEL(m, " (HIGH)\n");
4583 break;
4584 case 7:
4585 RTW_PRINT_SEL(m, " (TXCMD)\n");
4586 break;
4587 default:
4588 RTW_PRINT_SEL(m, " (?)\n");
4589 break;
4590 }
4591
4592 RTW_PRINT_SEL(m, " Entries: %d\n", TX_BAK_FRMAE_CNT);
4593 RTW_PRINT_SEL(m, " Last idx: %d\n", idx);
4594
4595 for (j = 0; j < TX_BAK_FRMAE_CNT; j++) {
4596 RTW_PRINT_SEL(m, " desc[%03d]:\n", j);
4597
4598 for (k = 0; k < (pbuf->tx_desc_size) / 4; k++) {
4599 if ((k % 4) == 0)
4600 RTW_PRINT_SEL(m, " 0x%03x", k);
4601
4602 RTW_PRINT_SEL(m, " 0x%08x ", ((int *)pbuf->tx_bak_desc)[k]);
4603
4604 if ((k % 4) == 3)
4605 RTW_PRINT_SEL(m, "\n");
4606 }
4607
4608 #if 1 /* data dump */
4609 if (pbuf->tx_desc_size) {
4610 RTW_PRINT_SEL(m, " data[%03d]:\n", j);
4611
4612 for (k = 0; k < (TX_BAK_DATA_LEN) / 4; k++) {
4613 if ((k % 4) == 0)
4614 RTW_PRINT_SEL(m, " 0x%03x", k);
4615
4616 RTW_PRINT_SEL(m, " 0x%08x ", ((int *)pbuf->tx_bak_data_hdr)[k]);
4617
4618 if ((k % 4) == 3)
4619 RTW_PRINT_SEL(m, "\n");
4620 }
4621 RTW_PRINT_SEL(m, "\n");
4622 }
4623 #endif
4624
4625 RTW_PRINT_SEL(m, " R/W pointer: %d/%d\n", pbuf->tx_bak_rp, pbuf->tx_bak_wp);
4626
4627 pbuf = pbuf + 1;
4628 }
4629 RTW_PRINT_SEL(m, "\n");
4630 }
4631 _rtw_spinunlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
4632
4633 return 0;
4634 }
4635
proc_set_tx_ring_ext(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4636 ssize_t proc_set_tx_ring_ext(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4637 {
4638 struct net_device *dev = data;
4639 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4640 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
4641 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4642 char tmp[32];
4643 u32 reset = 0;
4644 u32 dump = 0;
4645 unsigned long sp_flags;
4646
4647 if (count < 1)
4648 return -EFAULT;
4649
4650 if (count > sizeof(tmp)) {
4651 rtw_warn_on(1);
4652 return -EFAULT;
4653 }
4654
4655 if (buffer && !copy_from_user(tmp, buffer, count)) {
4656
4657 int num = sscanf(tmp, "%u %u", &dump, &reset);
4658
4659 if (num != 2) {
4660 RTW_INFO("invalid parameter!\n");
4661 return count;
4662 }
4663
4664 _rtw_spinlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
4665 pxmitpriv->dump_txbd_desc = (BOOLEAN) dump;
4666
4667 if (reset == 1)
4668 rtw_tx_desc_backup_reset();
4669
4670 _rtw_spinunlock_irq(&dvobj_to_pci(pdvobjpriv)->irq_th_lock, &sp_flags);
4671
4672 }
4673
4674 return count;
4675 }
4676
4677 #endif
4678
4679 #endif
4680
4681 #ifdef CONFIG_WOWLAN
proc_get_wow_enable(struct seq_file * m,void * v)4682 int proc_get_wow_enable(struct seq_file *m, void *v)
4683 {
4684 struct net_device *dev = m->private;
4685 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4686 struct registry_priv *registry_pair = &padapter->registrypriv;
4687
4688 RTW_PRINT_SEL(m, "wow - %s\n", (registry_pair->wowlan_enable)? "enable" : "disable");
4689 return 0;
4690 }
4691
proc_set_wow_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4692 ssize_t proc_set_wow_enable(struct file *file, const char __user *buffer,
4693 size_t count, loff_t *pos, void *data)
4694 {
4695 struct net_device *dev = data;
4696 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4697 struct registry_priv *registry_pair = &padapter->registrypriv;
4698 char tmp[8];
4699 int num = 0;
4700 int mode = 0;
4701
4702 if (count < 1)
4703 return -EFAULT;
4704
4705 if (count > sizeof(tmp)) {
4706 rtw_warn_on(1);
4707 return -EFAULT;
4708 }
4709
4710 if (buffer && !copy_from_user(tmp, buffer, count))
4711 num = sscanf(tmp, "%d", &mode);
4712 else
4713 return -EFAULT;
4714
4715 if (num != 1) {
4716 RTW_ERR("%s: %s - invalid parameter!\n", __func__, tmp);
4717 return -EINVAL;
4718 }
4719
4720 if (mode == 1) {
4721 RTW_PRINT("%s: wowlan - enable\n", __func__);
4722 } else if (mode == 0) {
4723 RTW_PRINT("%s: wowlan - disable\n", __func__);
4724 } else {
4725 RTW_ERR("%s: %s - invalid parameter!, mode=%d\n",
4726 __func__, tmp, mode);
4727 return -EINVAL;
4728 }
4729
4730 registry_pair->wowlan_enable = mode;
4731
4732 return count;
4733 }
4734
proc_get_pattern_info(struct seq_file * m,void * v)4735 int proc_get_pattern_info(struct seq_file *m, void *v)
4736 {
4737 // TODO(jw.hou): Get pattern info from PHL.
4738 #if 0
4739 struct net_device *dev = m->private;
4740 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4741 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4742 u8 val8;
4743 char str_1[128];
4744 char *p_str;
4745 int i = 0 , j = 0, k = 0;
4746 int len = 0, max_len = 0, total = 0;
4747
4748 p_str = str_1;
4749 max_len = sizeof(str_1);
4750
4751 total = pwrpriv->wowlan_pattern_idx;
4752
4753 rtw_set_default_pattern(padapter);
4754
4755 /*show pattern*/
4756 RTW_PRINT_SEL(m, "\n======[Pattern Info.]======\n");
4757 RTW_PRINT_SEL(m, "pattern number: %d\n", total);
4758 RTW_PRINT_SEL(m, "support default patterns: %c\n",
4759 (pwrpriv->default_patterns_en) ? 'Y' : 'N');
4760
4761 for (k = 0; k < total ; k++) {
4762 RTW_PRINT_SEL(m, "\npattern idx: %d\n", k);
4763 RTW_PRINT_SEL(m, "pattern content:\n");
4764
4765 p_str = str_1;
4766 max_len = sizeof(str_1);
4767 for (i = 0 ; i < MAX_WKFM_PATTERN_SIZE / 8 ; i++) {
4768 _rtw_memset(p_str, 0, max_len);
4769 len = 0;
4770 for (j = 0 ; j < 8 ; j++) {
4771 val8 = pwrpriv->patterns[k].content[i * 8 + j];
4772 len += snprintf(p_str + len, max_len - len,
4773 "%02x ", val8);
4774 }
4775 RTW_PRINT_SEL(m, "%s\n", p_str);
4776 }
4777 RTW_PRINT_SEL(m, "\npattern mask:\n");
4778 for (i = 0 ; i < MAX_WKFM_SIZE / 8 ; i++) {
4779 _rtw_memset(p_str, 0, max_len);
4780 len = 0;
4781 for (j = 0 ; j < 8 ; j++) {
4782 val8 = pwrpriv->patterns[k].mask[i * 8 + j];
4783 len += snprintf(p_str + len, max_len - len,
4784 "%02x ", val8);
4785 }
4786 RTW_PRINT_SEL(m, "%s\n", p_str);
4787 }
4788
4789 RTW_PRINT_SEL(m, "\npriv_pattern_len:\n");
4790 RTW_PRINT_SEL(m, "pattern_len: %d\n", pwrpriv->patterns[k].len);
4791 RTW_PRINT_SEL(m, "*****************\n");
4792 }
4793 #endif
4794
4795 return 0;
4796 }
4797
proc_set_pattern_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4798 ssize_t proc_set_pattern_info(struct file *file, const char __user *buffer,
4799 size_t count, loff_t *pos, void *data)
4800 {
4801 struct net_device *dev = data;
4802 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4803 struct registry_priv *registry_par = &adapter->registrypriv;
4804 struct rtw_wowcam_upd_info wowcam_info = {0};
4805 u8 tmp[MAX_WKFM_PATTERN_STR_LEN + 1] = {0};
4806
4807 if (!(registry_par->wakeup_event & BIT(3))) {
4808 RTW_INFO("%s: customized pattern disabled, wakeup_event: %#2x\n",
4809 __func__, registry_par->wakeup_event);
4810 return -EOPNOTSUPP;
4811 }
4812
4813 if (count < 1)
4814 return -EINVAL;
4815
4816 if (count >= sizeof(tmp)) {
4817 RTW_ERR("%s: pattern string is too long, count=%zu\n",
4818 __func__, count);
4819 return -EINVAL;
4820 }
4821
4822 if (buffer && !copy_from_user(tmp, buffer, count)) {
4823 if (strncmp(tmp, "clean", 5) == 0) {
4824 rtw_wow_pattern_clean(adapter, RTW_CUSTOMIZED_PATTERN);
4825 } else {
4826 if (rtw_wowlan_parser_pattern_cmd(tmp,
4827 wowcam_info.ptrn,
4828 &wowcam_info.ptrn_len,
4829 wowcam_info.mask)) {
4830 if (_FAIL == rtw_wow_pattern_set(adapter,
4831 &wowcam_info,
4832 RTW_CUSTOMIZED_PATTERN))
4833 return -EFAULT;
4834 } else {
4835 return -EINVAL;
4836 }
4837 }
4838 } else {
4839 rtw_warn_on(1);
4840 return -EFAULT;
4841 }
4842
4843 return count;
4844 }
4845
proc_get_wakeup_event(struct seq_file * m,void * v)4846 int proc_get_wakeup_event(struct seq_file *m, void *v)
4847 {
4848 struct net_device *dev = m->private;
4849 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4850 struct registry_priv *registry_par = &padapter->registrypriv;
4851
4852 RTW_PRINT_SEL(m, "wakeup event: %#02x\n", registry_par->wakeup_event);
4853 return 0;
4854 }
4855
proc_set_wakeup_event(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4856 ssize_t proc_set_wakeup_event(struct file *file, const char __user *buffer,
4857 size_t count, loff_t *pos, void *data)
4858 {
4859 struct net_device *dev = data;
4860 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4861 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
4862 struct registry_priv *registry_par = &padapter->registrypriv;
4863 u32 wakeup_event = 0;
4864
4865 u8 tmp[8] = {0};
4866 int num = 0;
4867
4868 if (count < 1)
4869 return -EFAULT;
4870
4871 if (count > sizeof(tmp)) {
4872 rtw_warn_on(1);
4873 return -EFAULT;
4874 }
4875
4876 if (buffer && !copy_from_user(tmp, buffer, count))
4877 num = sscanf(tmp, "%u", &wakeup_event);
4878 else
4879 return -EFAULT;
4880
4881 if (num == 1 && wakeup_event <= 0x1f) {
4882 registry_par->wakeup_event = wakeup_event;
4883
4884 if (!(wakeup_event & BIT(1)))
4885 rtw_wow_pattern_clean(padapter, RTW_DEFAULT_PATTERN);
4886
4887 if (!(wakeup_event & BIT(3)))
4888 rtw_wow_pattern_clean(padapter, RTW_CUSTOMIZED_PATTERN);
4889
4890 RTW_INFO("%s: wakeup_event: %#2x\n",
4891 __func__, registry_par->wakeup_event);
4892 } else {
4893 return -EINVAL;
4894 }
4895
4896 return count;
4897 }
4898
proc_get_wakeup_reason(struct seq_file * m,void * v)4899 int proc_get_wakeup_reason(struct seq_file *m, void *v)
4900 {
4901 struct net_device *dev = m->private;
4902 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4903 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4904 u8 val = pwrpriv->wowlan_last_wake_reason;
4905
4906 RTW_PRINT_SEL(m, "last wake reason: %#02x\n", val);
4907 return 0;
4908 }
4909 #endif /*CONFIG_WOWLAN*/
4910
4911 #ifdef CONFIG_GPIO_WAKEUP
proc_get_wowlan_gpio_info(struct seq_file * m,void * v)4912 int proc_get_wowlan_gpio_info(struct seq_file *m, void *v)
4913 {
4914 struct net_device *dev = m->private;
4915 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4916 struct wow_priv *wowpriv = adapter_to_wowlan(padapter);
4917 struct rtw_wow_gpio_info *wow_gpio = &wowpriv->wow_gpio;
4918 struct rtw_dev2hst_gpio_info *d2h_gpio_info = &wow_gpio->d2h_gpio_info;
4919
4920 RTW_PRINT_SEL(m, "wakeup_gpio_idx: %d\n", WAKEUP_GPIO_IDX);
4921 RTW_PRINT_SEL(m, "high_active: %d\n", d2h_gpio_info->gpio_active);
4922
4923 return 0;
4924 }
4925
proc_set_wowlan_gpio_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4926 ssize_t proc_set_wowlan_gpio_info(struct file *file, const char __user *buffer,
4927 size_t count, loff_t *pos, void *data)
4928 {
4929 struct net_device *dev = data;
4930 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4931 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
4932 void *phl = GET_PHL_INFO(dvobj);
4933 enum rtw_phl_status status = RTW_PHL_STATUS_FAILURE;
4934 struct wow_priv *wowpriv = adapter_to_wowlan(padapter);
4935 struct rtw_wow_gpio_info *wow_gpio = &wowpriv->wow_gpio;
4936 struct rtw_dev2hst_gpio_info *d2h_gpio_info = &wow_gpio->d2h_gpio_info;
4937 char tmp[32] = {0};
4938 int num = 0;
4939 u32 is_high_active = 0;
4940
4941 if (count < 1)
4942 return -EFAULT;
4943
4944 if (count > sizeof(tmp)) {
4945 rtw_warn_on(1);
4946 return -EFAULT;
4947 }
4948
4949 if (buffer && !copy_from_user(tmp, buffer, count)) {
4950
4951 num = sscanf(tmp, "%u", &is_high_active);
4952
4953 if (num != 1) {
4954 RTW_INFO("Invalid format\n");
4955 return count;
4956 }
4957
4958 wow_gpio->dev2hst_high = is_high_active == 0 ? 1 : 0;
4959 d2h_gpio_info->gpio_active = is_high_active;
4960
4961 rtw_ps_deny(padapter, PS_DENY_IOCTL);
4962 LeaveAllPowerSaveModeDirect(padapter);
4963 status = rtw_phl_cfg_wow_sw_gpio_ctrl(phl, wow_gpio);
4964
4965 rtw_ps_deny_cancel(padapter, PS_DENY_IOCTL);
4966
4967 RTW_INFO("set %s %d\n", "gpio_high_active",
4968 d2h_gpio_info->gpio_active);
4969 RTW_INFO("%s: set GPIO_%d %d as default. status=%d\n",
4970 __func__, WAKEUP_GPIO_IDX, wow_gpio->dev2hst_high, status);
4971 }
4972
4973 return count;
4974 }
4975 #endif /* CONFIG_GPIO_WAKEUP */
4976
4977 #ifdef CONFIG_P2P_WOWLAN
proc_get_p2p_wowlan_info(struct seq_file * m,void * v)4978 int proc_get_p2p_wowlan_info(struct seq_file *m, void *v)
4979 {
4980 struct net_device *dev = m->private;
4981 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4982 struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
4983 struct p2p_wowlan_info peerinfo = pwdinfo->p2p_wow_info;
4984 if (_TRUE == peerinfo.is_trigger) {
4985 RTW_PRINT_SEL(m, "is_trigger: TRUE\n");
4986 switch (peerinfo.wowlan_recv_frame_type) {
4987 case P2P_WOWLAN_RECV_NEGO_REQ:
4988 RTW_PRINT_SEL(m, "Frame Type: Nego Request\n");
4989 break;
4990 case P2P_WOWLAN_RECV_INVITE_REQ:
4991 RTW_PRINT_SEL(m, "Frame Type: Invitation Request\n");
4992 break;
4993 case P2P_WOWLAN_RECV_PROVISION_REQ:
4994 RTW_PRINT_SEL(m, "Frame Type: Provision Request\n");
4995 break;
4996 default:
4997 break;
4998 }
4999 RTW_PRINT_SEL(m, "Peer Addr: "MAC_FMT"\n", MAC_ARG(peerinfo.wowlan_peer_addr));
5000 RTW_PRINT_SEL(m, "Peer WPS Config: %x\n", peerinfo.wowlan_peer_wpsconfig);
5001 RTW_PRINT_SEL(m, "Persistent Group: %d\n", peerinfo.wowlan_peer_is_persistent);
5002 RTW_PRINT_SEL(m, "Intivation Type: %d\n", peerinfo.wowlan_peer_invitation_type);
5003 } else
5004 RTW_PRINT_SEL(m, "is_trigger: False\n");
5005 return 0;
5006 }
5007 #endif /* CONFIG_P2P_WOWLAN */
5008 #ifdef CONFIG_POWER_SAVING
proc_get_ps_info(struct seq_file * m,void * v)5009 int proc_get_ps_info(struct seq_file *m, void *v)
5010 {
5011 struct net_device *dev = m->private;
5012 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5013 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
5014 u8 ips_mode = pwrpriv->ips_mode_req;
5015 u8 lps_mode = pwrpriv->power_mgnt;
5016 u8 lps_level = pwrpriv->lps_level;
5017 #ifdef CONFIG_LPS_1T1R
5018 u8 lps_1t1r = pwrpriv->lps_1t1r;
5019 #endif
5020 #ifdef CONFIG_WOWLAN
5021 u8 wow_lps_mode = pwrpriv->wowlan_power_mgmt;
5022 u8 wow_lps_level = pwrpriv->wowlan_lps_level;
5023 #ifdef CONFIG_LPS_1T1R
5024 u8 wow_lps_1t1r = pwrpriv->wowlan_lps_1t1r;
5025 #endif
5026 #endif /* CONFIG_WOWLAN */
5027 char *str = "";
5028
5029 RTW_PRINT_SEL(m, "======Power Saving Info:======\n");
5030 RTW_PRINT_SEL(m, "*IPS:\n");
5031
5032 if (ips_mode == IPS_NORMAL) {
5033 #ifdef CONFIG_FWLPS_IN_IPS
5034 str = "FW_LPS_IN_IPS";
5035 #else
5036 str = "Card Disable";
5037 #endif
5038 } else if (ips_mode == IPS_NONE)
5039 str = "NO IPS";
5040 else if (ips_mode == IPS_LEVEL_2)
5041 str = "IPS_LEVEL_2";
5042 else
5043 str = "invalid ips_mode";
5044
5045 RTW_PRINT_SEL(m, " IPS mode: %s\n", str);
5046 RTW_PRINT_SEL(m, " IPS enter count:%d, IPS leave count:%d\n",
5047 pwrpriv->ips_enter_cnts, pwrpriv->ips_leave_cnts);
5048 RTW_PRINT_SEL(m, "------------------------------\n");
5049 RTW_PRINT_SEL(m, "*LPS:\n");
5050
5051 if (lps_mode == PM_PS_MODE_ACTIVE)
5052 str = "NO LPS";
5053 else if (lps_mode == PM_PS_MODE_MIN)
5054 str = "MIN";
5055 else if (lps_mode == PM_PS_MODE_MAX)
5056 str = "MAX";
5057 else if (lps_mode == PM_PS_MODE_DTIM)
5058 str = "DTIM";
5059 else
5060 sprintf(str, "%d", lps_mode);
5061
5062 RTW_PRINT_SEL(m, " LPS mode: %s\n", str);
5063
5064 if (pwrpriv->dtim != 0)
5065 RTW_PRINT_SEL(m, " DTIM: %d\n", pwrpriv->dtim);
5066 RTW_PRINT_SEL(m, " LPS enter count:%d, LPS leave count:%d\n",
5067 pwrpriv->lps_enter_cnts, pwrpriv->lps_leave_cnts);
5068
5069 if (lps_level == LPS_LCLK)
5070 str = "LPS_LCLK";
5071 else if (lps_level == LPS_PG)
5072 str = "LPS_PG";
5073 else
5074 str = "LPS_NORMAL";
5075 RTW_PRINT_SEL(m, " LPS level: %s\n", str);
5076
5077 #ifdef CONFIG_LPS_1T1R
5078 RTW_PRINT_SEL(m, " LPS 1T1R: %d\n", lps_1t1r);
5079 #endif
5080
5081 #ifdef CONFIG_WOWLAN
5082 RTW_PRINT_SEL(m, "------------------------------\n");
5083 RTW_PRINT_SEL(m, "*WOW LPS:\n");
5084
5085 if (wow_lps_mode == PM_PS_MODE_ACTIVE)
5086 str = "NO LPS";
5087 else if (wow_lps_mode == PM_PS_MODE_MIN)
5088 str = "MIN";
5089 else if (wow_lps_mode == PM_PS_MODE_MAX)
5090 str = "MAX";
5091 else if (wow_lps_mode == PM_PS_MODE_DTIM)
5092 str = "DTIM";
5093 else
5094 sprintf(str, "%d", wow_lps_mode);
5095
5096 RTW_PRINT_SEL(m, " WOW LPS mode: %s\n", str);
5097
5098 if (wow_lps_level == LPS_LCLK)
5099 str = "LPS_LCLK";
5100 else if (wow_lps_level == LPS_PG)
5101 str = "LPS_PG";
5102 else
5103 str = "LPS_NORMAL";
5104 RTW_PRINT_SEL(m, " WOW LPS level: %s\n", str);
5105
5106 #ifdef CONFIG_LPS_1T1R
5107 RTW_PRINT_SEL(m, " WOW LPS 1T1R: %d\n", wow_lps_1t1r);
5108 #endif
5109 #endif /* CONFIG_WOWLAN */
5110
5111 RTW_PRINT_SEL(m, "=============================\n");
5112 return 0;
5113 }
5114
proc_set_ps_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5115 ssize_t proc_set_ps_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5116 {
5117 struct net_device *dev = data;
5118 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
5119 char tmp[8];
5120 int num = 0;
5121 int mode = 0;
5122 int en = 0;
5123
5124 if (count > sizeof(tmp)) {
5125 rtw_warn_on(1);
5126 return -EFAULT;
5127 }
5128
5129 if (!buffer || copy_from_user(tmp, buffer, count))
5130 goto exit;
5131
5132 num = sscanf(tmp, "%d %d", &mode, &en);
5133 if (num > 2) {
5134 RTW_ERR("%s: invalid parameter!\n", __FUNCTION__);
5135 goto exit;
5136 }
5137
5138 if (num == 1 && mode == 0) {
5139 /* back to original LPS/IPS Mode */
5140 RTW_INFO("%s: back to original LPS/IPS Mode\n", __FUNCTION__);
5141
5142 rtw_pm_set_lps(adapter, adapter->registrypriv.power_mgnt);
5143
5144 rtw_pm_set_ips(adapter, adapter->registrypriv.ips_mode);
5145
5146 #ifdef CONFIG_WOWLAN
5147 RTW_INFO("%s: back to original WOW LPS Mode\n", __FUNCTION__);
5148
5149 rtw_pm_set_wow_lps(adapter, adapter->registrypriv.wow_power_mgnt);
5150 #endif /* CONFIG_WOWLAN */
5151
5152 goto exit;
5153 }
5154
5155 if (mode == 1) {
5156 /* LPS */
5157 RTW_INFO("%s: LPS: %s, en=%d\n", __FUNCTION__, (en == 0) ? "disable":"enable", en);
5158 if (rtw_pm_set_lps(adapter, en) != 0 )
5159 RTW_ERR("%s: invalid parameter, mode=%d, level=%d\n", __FUNCTION__, mode, en);
5160
5161 } else if (mode == 2) {
5162 /* IPS */
5163 RTW_INFO("%s: IPS: %s, en=%d\n", __FUNCTION__, (en == 0) ? "disable":"enable", en);
5164 if (rtw_pm_set_ips(adapter, en) != 0 )
5165 RTW_ERR("%s: invalid parameter, mode=%d, level=%d\n", __FUNCTION__, mode, en);
5166 }
5167 #ifdef CONFIG_WOWLAN
5168 else if (mode == 3) {
5169 /* WOW LPS */
5170 RTW_INFO("%s: WOW LPS: %s, en=%d\n", __FUNCTION__, (en == 0) ? "disable":"enable", en);
5171 if (rtw_pm_set_wow_lps(adapter, en) != 0 )
5172 RTW_ERR("%s: invalid parameter, mode=%d, level=%d\n", __FUNCTION__, mode, en);
5173 }
5174 #endif /* CONFIG_WOWLAN */
5175 else
5176 RTW_ERR("%s: invalid parameter, mode = %d!\n", __FUNCTION__, mode);
5177
5178 exit:
5179 return count;
5180 }
5181
5182 #ifdef CONFIG_WMMPS_STA
proc_get_wmmps_info(struct seq_file * m,void * v)5183 int proc_get_wmmps_info(struct seq_file *m, void *v)
5184 {
5185 struct net_device *dev = m->private;
5186 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5187 struct registry_priv *pregpriv = &padapter->registrypriv;
5188 char *uapsd_max_sp_str="";
5189
5190 if (pregpriv){
5191 switch(pregpriv->uapsd_max_sp_len) {
5192 case 0:
5193 uapsd_max_sp_str = "NO_LIMIT";
5194 break;
5195 case 1:
5196 uapsd_max_sp_str = "TWO_MSDU";
5197 break;
5198 case 2:
5199 uapsd_max_sp_str = "FOUR_MSDU";
5200 break;
5201 case 3:
5202 uapsd_max_sp_str = "SIX_MSDU";
5203 break;
5204 default:
5205 uapsd_max_sp_str = "UNSPECIFIED";
5206 break;
5207 }
5208
5209 RTW_PRINT_SEL(m, "====== WMMPS_STA Info:======\n");
5210 RTW_PRINT_SEL(m, "uapsd_max_sp_len=0x%02x (%s)\n", pregpriv->uapsd_max_sp_len, uapsd_max_sp_str);
5211 RTW_PRINT_SEL(m, "uapsd_ac_enable=0x%02x\n", pregpriv->uapsd_ac_enable);
5212 RTW_PRINT_SEL(m, "BIT0 - AC_VO UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_VO) ? "Enabled" : "Disabled");
5213 RTW_PRINT_SEL(m, "BIT1 - AC_VI UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_VI) ? "Enabled" : "Disabled");
5214 RTW_PRINT_SEL(m, "BIT2 - AC_BK UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_BK) ? "Enabled" : "Disabled");
5215 RTW_PRINT_SEL(m, "BIT3 - AC_BE UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_BE) ? "Enabled" : "Disabled");
5216 RTW_PRINT_SEL(m, "============================\n");
5217 }
5218
5219 return 0;
5220 }
5221
proc_set_wmmps_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5222 ssize_t proc_set_wmmps_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5223 {
5224 struct net_device *dev = data;
5225 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5226 struct registry_priv *pregpriv = &padapter->registrypriv;
5227 char tmp[32];
5228 u8 uapsd_ac_setting;
5229 u8 uapsd_max_sp_len_setting;
5230
5231 if (count < 1)
5232 return -EFAULT;
5233
5234 if (count > sizeof(tmp)) {
5235 rtw_warn_on(1);
5236 return -EFAULT;
5237 }
5238
5239 if (buffer && !copy_from_user(tmp, buffer, count)) {
5240
5241 int num = sscanf(tmp, "%hhu %hhx", &uapsd_max_sp_len_setting, &uapsd_ac_setting);
5242
5243 if (pregpriv) {
5244 if (num >= 1) {
5245 pregpriv->uapsd_max_sp_len = uapsd_max_sp_len_setting;
5246 RTW_INFO("uapsd_max_sp_len = %d\n", pregpriv->uapsd_max_sp_len);
5247 }
5248
5249 if (num >= 2) {
5250 pregpriv->uapsd_ac_enable = uapsd_ac_setting;
5251 RTW_INFO("uapsd_ac_enable = 0x%02x\n", pregpriv->uapsd_ac_enable);
5252 }
5253 }
5254 }
5255
5256 return count;
5257 }
5258 #endif /* CONFIG_WMMPS_STA */
5259 #endif /* CONFIG_POWER_SAVING */
5260
5261 #ifdef CONFIG_TDLS
proc_get_tdls_enable(struct seq_file * m,void * v)5262 int proc_get_tdls_enable(struct seq_file *m, void *v)
5263 {
5264 struct net_device *dev = m->private;
5265 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5266 struct registry_priv *pregpriv = &padapter->registrypriv;
5267
5268 if (pregpriv)
5269 RTW_PRINT_SEL(m, "TDLS is %s !\n", (rtw_is_tdls_enabled(padapter) == _TRUE) ? "enabled" : "disabled");
5270
5271 return 0;
5272 }
5273
proc_set_tdls_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5274 ssize_t proc_set_tdls_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5275 {
5276 struct net_device *dev = data;
5277 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5278 struct registry_priv *pregpriv = &padapter->registrypriv;
5279 char tmp[32];
5280 u32 en_tdls = 0;
5281
5282 if (count < 1)
5283 return -EFAULT;
5284
5285 if (count > sizeof(tmp)) {
5286 rtw_warn_on(1);
5287 return -EFAULT;
5288 }
5289
5290 if (buffer && !copy_from_user(tmp, buffer, count)) {
5291
5292 int num = sscanf(tmp, "%d ", &en_tdls);
5293
5294 if (num == 1 && pregpriv) {
5295 if (en_tdls > 0)
5296 rtw_enable_tdls_func(padapter);
5297 else
5298 rtw_disable_tdls_func(padapter, _TRUE);
5299 }
5300 }
5301
5302 return count;
5303 }
5304
proc_tdls_display_tdls_function_info(struct seq_file * m)5305 static int proc_tdls_display_tdls_function_info(struct seq_file *m)
5306 {
5307 struct net_device *dev = m->private;
5308 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5309 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
5310 u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
5311 u8 SpaceBtwnItemAndValueTmp = 0;
5312 BOOLEAN FirstMatchFound = _FALSE;
5313 int j = 0;
5314
5315 RTW_PRINT_SEL(m, "============[TDLS Function Info]============\n");
5316 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Enable", (rtw_is_tdls_enabled(padapter) == _TRUE) ? "_TRUE" : "_FALSE");
5317 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Driver Setup", (ptdlsinfo->driver_setup == _TRUE) ? "_TRUE" : "_FALSE");
5318 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Prohibited", (ptdlsinfo->ap_prohibited == _TRUE) ? "_TRUE" : "_FALSE");
5319 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Channel Switch Prohibited", (ptdlsinfo->ch_switch_prohibited == _TRUE) ? "_TRUE" : "_FALSE");
5320 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Link Established", (ptdlsinfo->link_established == _TRUE) ? "_TRUE" : "_FALSE");
5321 RTW_PRINT_SEL(m, "%-*s = %d/%d\n", SpaceBtwnItemAndValue, "TDLS STA Num (Linked/Allowed)", ptdlsinfo->sta_cnt, MAX_ALLOWED_TDLS_STA_NUM);
5322 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Allowed STA Num Reached", (ptdlsinfo->sta_maximum == _TRUE) ? "_TRUE" : "_FALSE");
5323
5324 #ifdef CONFIG_TDLS_CH_SW
5325 RTW_PRINT_SEL(m, "%-*s =", SpaceBtwnItemAndValue, "TDLS CH SW State");
5326 if (ptdlsinfo->chsw_info.ch_sw_state == TDLS_STATE_NONE)
5327 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_STATE_NONE");
5328 else {
5329 for (j = 0; j < 32; j++) {
5330 if (ptdlsinfo->chsw_info.ch_sw_state & BIT(j)) {
5331 if (FirstMatchFound == _FALSE) {
5332 SpaceBtwnItemAndValueTmp = 1;
5333 FirstMatchFound = _TRUE;
5334 } else
5335 SpaceBtwnItemAndValueTmp = SpaceBtwnItemAndValue + 3;
5336 switch (BIT(j)) {
5337 case TDLS_INITIATOR_STATE:
5338 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_INITIATOR_STATE");
5339 break;
5340 case TDLS_RESPONDER_STATE:
5341 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_RESPONDER_STATE");
5342 break;
5343 case TDLS_LINKED_STATE:
5344 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_LINKED_STATE");
5345 break;
5346 case TDLS_WAIT_PTR_STATE:
5347 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_WAIT_PTR_STATE");
5348 break;
5349 case TDLS_ALIVE_STATE:
5350 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_ALIVE_STATE");
5351 break;
5352 case TDLS_CH_SWITCH_ON_STATE:
5353 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SWITCH_ON_STATE");
5354 break;
5355 case TDLS_PEER_AT_OFF_STATE:
5356 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_PEER_AT_OFF_STATE");
5357 break;
5358 case TDLS_CH_SW_INITIATOR_STATE:
5359 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SW_INITIATOR_STATE");
5360 break;
5361 case TDLS_WAIT_CH_RSP_STATE:
5362 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValue, " ", "TDLS_WAIT_CH_RSP_STATE");
5363 break;
5364 default:
5365 RTW_PRINT_SEL(m, "%-*sBIT(%d)\n", SpaceBtwnItemAndValueTmp, " ", j);
5366 break;
5367 }
5368 }
5369 }
5370 }
5371
5372 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS CH SW On", (ATOMIC_READ(&ptdlsinfo->chsw_info.chsw_on) == _TRUE) ? "_TRUE" : "_FALSE");
5373 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Off-Channel Num", ptdlsinfo->chsw_info.off_ch_num);
5374 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Channel Offset", ptdlsinfo->chsw_info.ch_offset);
5375 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Current Time", ptdlsinfo->chsw_info.cur_time);
5376 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS CH SW Delay Switch Back", (ptdlsinfo->chsw_info.delay_switch_back == _TRUE) ? "_TRUE" : "_FALSE");
5377 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Dump Back", ptdlsinfo->chsw_info.dump_stack);
5378 #endif
5379
5380 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Device Discovered", (ptdlsinfo->dev_discovered == _TRUE) ? "_TRUE" : "_FALSE");
5381
5382 return 0;
5383 }
5384
proc_tdls_display_network_info(struct seq_file * m)5385 static int proc_tdls_display_network_info(struct seq_file *m)
5386 {
5387 struct net_device *dev = m->private;
5388 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5389 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5390 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5391 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
5392 int i = 0;
5393 u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
5394
5395 /* Display the linked AP/GO info */
5396 RTW_PRINT_SEL(m, "============[Associated AP/GO Info]============\n");
5397
5398 if ((pmlmepriv->fw_state & WIFI_STATION_STATE) && (pmlmepriv->fw_state & WIFI_ASOC_STATE)) {
5399 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "BSSID", cur_network->network.Ssid.Ssid);
5400 RTW_PRINT_SEL(m, "%-*s = "MAC_FMT"\n", SpaceBtwnItemAndValue, "Mac Address", MAC_ARG(cur_network->network.MacAddress));
5401
5402 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Wireless Mode");
5403 for (i = 0; i < 8; i++) {
5404 if (pmlmeext->cur_wireless_mode & BIT(i)) {
5405 switch (BIT(i)) {
5406 case WIRELESS_11B:
5407 RTW_PRINT_SEL(m, "%4s", "11B ");
5408 break;
5409 case WIRELESS_11G:
5410 RTW_PRINT_SEL(m, "%4s", "11G ");
5411 break;
5412 case WIRELESS_11A:
5413 RTW_PRINT_SEL(m, "%4s", "11A ");
5414 break;
5415 case WIRELESS_11_24N:
5416 RTW_PRINT_SEL(m, "%7s", "11_24N ");
5417 break;
5418 case WIRELESS_11_5N:
5419 RTW_PRINT_SEL(m, "%6s", "11_5N ");
5420 break;
5421 case WIRELESS_AUTO:
5422 RTW_PRINT_SEL(m, "%5s", "AUTO ");
5423 break;
5424 case WIRELESS_11AC:
5425 RTW_PRINT_SEL(m, "%5s", "11AC ");
5426 break;
5427 }
5428 }
5429 }
5430 RTW_PRINT_SEL(m, "\n");
5431
5432 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Privacy");
5433 switch (padapter->securitypriv.dot11PrivacyAlgrthm) {
5434 case _NO_PRIVACY_:
5435 RTW_PRINT_SEL(m, "%s\n", "NO PRIVACY");
5436 break;
5437 case _WEP40_:
5438 RTW_PRINT_SEL(m, "%s\n", "WEP 40");
5439 break;
5440 case _TKIP_:
5441 RTW_PRINT_SEL(m, "%s\n", "TKIP");
5442 break;
5443 case _TKIP_WTMIC_:
5444 RTW_PRINT_SEL(m, "%s\n", "TKIP WTMIC");
5445 break;
5446 case _AES_:
5447 RTW_PRINT_SEL(m, "%s\n", "AES");
5448 break;
5449 case _WEP104_:
5450 RTW_PRINT_SEL(m, "%s\n", "WEP 104");
5451 break;
5452 #if 0 /* no this setting */
5453 case _WEP_WPA_MIXED_:
5454 RTW_PRINT_SEL(m, "%s\n", "WEP/WPA Mixed");
5455 break;
5456 #endif
5457 case _SMS4_:
5458 RTW_PRINT_SEL(m, "%s\n", "SMS4");
5459 break;
5460 #ifdef CONFIG_IEEE80211W
5461 case _BIP_CMAC_128_:
5462 RTW_PRINT_SEL(m, "%s\n", "BIP");
5463 break;
5464 #endif /* CONFIG_IEEE80211W */
5465 }
5466
5467 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "Channel", pmlmeext->chandef.chan);
5468 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Channel Offset");
5469 switch (pmlmeext->chandef.offset) {
5470 case CHAN_OFFSET_NO_EXT:
5471 RTW_PRINT_SEL(m, "%s\n", "SCN");
5472 break;
5473 case CHAN_OFFSET_UPPER:
5474 RTW_PRINT_SEL(m, "%s\n", "SCA");
5475 break;
5476 case CHAN_OFFSET_LOWER:
5477 RTW_PRINT_SEL(m, "%s\n", "SCB");
5478 break;
5479 }
5480
5481 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Bandwidth Mode");
5482 switch (pmlmeext->chandef.bw) {
5483 case CHANNEL_WIDTH_20:
5484 RTW_PRINT_SEL(m, "%s\n", "20MHz");
5485 break;
5486 case CHANNEL_WIDTH_40:
5487 RTW_PRINT_SEL(m, "%s\n", "40MHz");
5488 break;
5489 case CHANNEL_WIDTH_80:
5490 RTW_PRINT_SEL(m, "%s\n", "80MHz");
5491 break;
5492 case CHANNEL_WIDTH_160:
5493 RTW_PRINT_SEL(m, "%s\n", "160MHz");
5494 break;
5495 case CHANNEL_WIDTH_80_80:
5496 RTW_PRINT_SEL(m, "%s\n", "80MHz + 80MHz");
5497 break;
5498 }
5499 } else
5500 RTW_PRINT_SEL(m, "No association with AP/GO exists!\n");
5501
5502 return 0;
5503 }
5504
proc_tdls_display_tdls_sta_info(struct seq_file * m)5505 static int proc_tdls_display_tdls_sta_info(struct seq_file *m)
5506 {
5507 struct net_device *dev = m->private;
5508 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5509 struct sta_priv *pstapriv = &padapter->stapriv;
5510 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
5511 struct sta_info *psta;
5512 int i = 0, j = 0;
5513 _list *plist, *phead;
5514 u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
5515 u8 SpaceBtwnItemAndValueTmp = 0;
5516 u8 NumOfTdlsStaToShow = 0;
5517 BOOLEAN FirstMatchFound = _FALSE;
5518
5519 /* Search for TDLS sta info to display */
5520 _rtw_spinlock_bh(&pstapriv->sta_hash_lock);
5521 for (i = 0; i < NUM_STA; i++) {
5522 phead = &(pstapriv->sta_hash[i]);
5523 plist = get_next(phead);
5524 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
5525 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
5526 plist = get_next(plist);
5527 if (psta->tdls_sta_state != TDLS_STATE_NONE) {
5528 /* We got one TDLS sta info to show */
5529 RTW_PRINT_SEL(m, "============[TDLS Peer STA Info: STA %d]============\n", ++NumOfTdlsStaToShow);
5530 RTW_PRINT_SEL(m, "%-*s = "MAC_FMT"\n", SpaceBtwnItemAndValue, "Mac Address", MAC_ARG(psta->phl_sta->mac_addr));
5531 RTW_PRINT_SEL(m, "%-*s =", SpaceBtwnItemAndValue, "TDLS STA State");
5532 SpaceBtwnItemAndValueTmp = 0;
5533 FirstMatchFound = _FALSE;
5534 for (j = 0; j < 32; j++) {
5535 if (psta->tdls_sta_state & BIT(j)) {
5536 if (FirstMatchFound == _FALSE) {
5537 SpaceBtwnItemAndValueTmp = 1;
5538 FirstMatchFound = _TRUE;
5539 } else
5540 SpaceBtwnItemAndValueTmp = SpaceBtwnItemAndValue + 3;
5541 switch (BIT(j)) {
5542 case TDLS_INITIATOR_STATE:
5543 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_INITIATOR_STATE");
5544 break;
5545 case TDLS_RESPONDER_STATE:
5546 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_RESPONDER_STATE");
5547 break;
5548 case TDLS_LINKED_STATE:
5549 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_LINKED_STATE");
5550 break;
5551 case TDLS_WAIT_PTR_STATE:
5552 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_WAIT_PTR_STATE");
5553 break;
5554 case TDLS_ALIVE_STATE:
5555 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_ALIVE_STATE");
5556 break;
5557 case TDLS_CH_SWITCH_ON_STATE:
5558 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SWITCH_ON_STATE");
5559 break;
5560 case TDLS_PEER_AT_OFF_STATE:
5561 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_PEER_AT_OFF_STATE");
5562 break;
5563 case TDLS_CH_SW_INITIATOR_STATE:
5564 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SW_INITIATOR_STATE");
5565 break;
5566 case TDLS_WAIT_CH_RSP_STATE:
5567 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValue, " ", "TDLS_WAIT_CH_RSP_STATE");
5568 break;
5569 default:
5570 RTW_PRINT_SEL(m, "%-*sBIT(%d)\n", SpaceBtwnItemAndValueTmp, " ", j);
5571 break;
5572 }
5573 }
5574 }
5575
5576 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Wireless Mode");
5577 for (j = 0; j < 8; j++) {
5578 if (psta->phl_sta->wmode & BIT(j)) {
5579 switch (BIT(j)) {
5580 case WIRELESS_11B:
5581 RTW_PRINT_SEL(m, "%4s", "11B ");
5582 break;
5583 case WIRELESS_11G:
5584 RTW_PRINT_SEL(m, "%4s", "11G ");
5585 break;
5586 case WIRELESS_11A:
5587 RTW_PRINT_SEL(m, "%4s", "11A ");
5588 break;
5589 case WIRELESS_11_24N:
5590 RTW_PRINT_SEL(m, "%7s", "11_24N ");
5591 break;
5592 case WIRELESS_11_5N:
5593 RTW_PRINT_SEL(m, "%6s", "11_5N ");
5594 break;
5595 case WIRELESS_AUTO:
5596 RTW_PRINT_SEL(m, "%5s", "AUTO ");
5597 break;
5598 case WIRELESS_11AC:
5599 RTW_PRINT_SEL(m, "%5s", "11AC ");
5600 break;
5601 }
5602 }
5603 }
5604 RTW_PRINT_SEL(m, "\n");
5605
5606 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Bandwidth Mode");
5607 switch (psta->phl_sta->chandef.bw) {
5608 case CHANNEL_WIDTH_20:
5609 RTW_PRINT_SEL(m, "%s\n", "20MHz");
5610 break;
5611 case CHANNEL_WIDTH_40:
5612 RTW_PRINT_SEL(m, "%s\n", "40MHz");
5613 break;
5614 case CHANNEL_WIDTH_80:
5615 RTW_PRINT_SEL(m, "%s\n", "80MHz");
5616 break;
5617 case CHANNEL_WIDTH_160:
5618 RTW_PRINT_SEL(m, "%s\n", "160MHz");
5619 break;
5620 case CHANNEL_WIDTH_80_80:
5621 RTW_PRINT_SEL(m, "%s\n", "80MHz + 80MHz");
5622 break;
5623 case CHANNEL_WIDTH_5:
5624 RTW_PRINT_SEL(m, "%s\n", "5MHz");
5625 break;
5626 case CHANNEL_WIDTH_10:
5627 RTW_PRINT_SEL(m, "%s\n", "10MHz");
5628 break;
5629 default:
5630 RTW_PRINT_SEL(m, "(%d)%s\n", psta->phl_sta->chandef.bw, "invalid");
5631 break;
5632 }
5633
5634 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Privacy");
5635 switch (psta->dot118021XPrivacy) {
5636 case _NO_PRIVACY_:
5637 RTW_PRINT_SEL(m, "%s\n", "NO PRIVACY");
5638 break;
5639 case _WEP40_:
5640 RTW_PRINT_SEL(m, "%s\n", "WEP 40");
5641 break;
5642 case _TKIP_:
5643 RTW_PRINT_SEL(m, "%s\n", "TKIP");
5644 break;
5645 case _TKIP_WTMIC_:
5646 RTW_PRINT_SEL(m, "%s\n", "TKIP WTMIC");
5647 break;
5648 case _AES_:
5649 RTW_PRINT_SEL(m, "%s\n", "AES");
5650 break;
5651 case _WEP104_:
5652 RTW_PRINT_SEL(m, "%s\n", "WEP 104");
5653 break;
5654 #if 0 /* no this setting */
5655 case _WEP_WPA_MIXED_:
5656 RTW_PRINT_SEL(m, "%s\n", "WEP/WPA Mixed");
5657 break;
5658 #endif
5659 case _SMS4_:
5660 RTW_PRINT_SEL(m, "%s\n", "SMS4");
5661 break;
5662 #ifdef CONFIG_IEEE80211W
5663 case _BIP_CMAC_128_:
5664 RTW_PRINT_SEL(m, "%s\n", "BIP");
5665 break;
5666 #endif /* CONFIG_IEEE80211W */
5667 }
5668
5669 RTW_PRINT_SEL(m, "%-*s = %d sec/%d sec\n", SpaceBtwnItemAndValue, "TPK Lifetime (Current/Expire)", psta->TPK_count, psta->TDLS_PeerKey_Lifetime);
5670 RTW_PRINT_SEL(m, "%-*s = %llu\n", SpaceBtwnItemAndValue, "Tx Packets Over Direct Link", psta->sta_stats.tx_pkts);
5671 RTW_PRINT_SEL(m, "%-*s = %llu\n", SpaceBtwnItemAndValue, "Rx Packets Over Direct Link", psta->sta_stats.rx_data_pkts);
5672 }
5673 }
5674 }
5675 _rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
5676 if (NumOfTdlsStaToShow == 0) {
5677 RTW_PRINT_SEL(m, "============[TDLS Peer STA Info]============\n");
5678 RTW_PRINT_SEL(m, "No TDLS direct link exists!\n");
5679 }
5680
5681 return 0;
5682 }
5683
proc_get_tdls_info(struct seq_file * m,void * v)5684 int proc_get_tdls_info(struct seq_file *m, void *v)
5685 {
5686 struct net_device *dev = m->private;
5687 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5688 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5689 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5690 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
5691 struct sta_priv *pstapriv = &padapter->stapriv;
5692 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
5693 struct sta_info *psta;
5694 int i = 0, j = 0;
5695 _list *plist, *phead;
5696 u8 SpaceBtwnItemAndValue = 41;
5697 u8 SpaceBtwnItemAndValueTmp = 0;
5698 u8 NumOfTdlsStaToShow = 0;
5699 BOOLEAN FirstMatchFound = _FALSE;
5700
5701 if (rtw_hw_chk_wl_func(adapter_to_dvobj(padapter), WL_FUNC_TDLS) == _FALSE) {
5702 RTW_PRINT_SEL(m, "No tdls info can be shown since hal doesn't support tdls\n");
5703 return 0;
5704 }
5705
5706 proc_tdls_display_tdls_function_info(m);
5707 proc_tdls_display_network_info(m);
5708 proc_tdls_display_tdls_sta_info(m);
5709
5710 return 0;
5711 }
5712 #endif
5713
proc_get_monitor(struct seq_file * m,void * v)5714 int proc_get_monitor(struct seq_file *m, void *v)
5715 {
5716 struct net_device *dev = m->private;
5717 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5718 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5719
5720 if (MLME_IS_MONITOR(padapter)) {
5721 RTW_PRINT_SEL(m, "Monitor mode : Enable\n");
5722 RTW_PRINT_SEL(m, "Device type : %u\n", dev->type);
5723
5724 RTW_PRINT_SEL(m, "ch=%d, ch_offset=%d, bw=%d\n",
5725 rtw_get_oper_ch(padapter),
5726 rtw_get_oper_choffset(padapter),
5727 rtw_get_oper_bw(padapter));
5728 } else
5729 RTW_PRINT_SEL(m, "Monitor mode : Disable\n");
5730
5731 return 0;
5732 }
5733
proc_set_monitor(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5734 ssize_t proc_set_monitor(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5735 {
5736 char tmp[32];
5737 struct net_device *dev = data;
5738 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5739 u16 target_type;
5740 u8 target_ch, target_offset, target_bw;
5741
5742 if (count < 3) {
5743 RTW_INFO("argument size is less than 3\n");
5744 return -EFAULT;
5745 }
5746
5747 if (count > sizeof(tmp)) {
5748 rtw_warn_on(1);
5749 return -EFAULT;
5750 }
5751
5752 if (buffer && !copy_from_user(tmp, buffer, count)) {
5753 int num = 0;
5754
5755 num = sscanf(tmp, "type %hu", &target_type);
5756 if ((num == 1) &&
5757 ((target_type != ARPHRD_IEEE80211) &&
5758 (target_type != ARPHRD_IEEE80211_RADIOTAP))) {
5759 dev->type = ARPHRD_IEEE80211_RADIOTAP;
5760 return count;
5761 }
5762
5763 num = sscanf(tmp, "%hhu %hhu %hhu", &target_ch, &target_offset, &target_bw);
5764 if (num != 3) {
5765 RTW_INFO("invalid write_reg parameter!\n");
5766 return count;
5767 }
5768
5769 padapter->mlmeextpriv.chandef.chan = target_ch;
5770 set_channel_bwmode(padapter, target_ch, target_offset, target_bw, _TRUE);
5771 }
5772
5773 return count;
5774 }
5775 #ifdef DBG_XMIT_BLOCK
proc_get_xmit_block(struct seq_file * m,void * v)5776 int proc_get_xmit_block(struct seq_file *m, void *v)
5777 {
5778 struct net_device *dev = m->private;
5779 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5780
5781 dump_xmit_block(m, padapter);
5782
5783 return 0;
5784 }
5785
proc_set_xmit_block(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5786 ssize_t proc_set_xmit_block(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5787 {
5788 struct net_device *dev = data;
5789 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5790 char tmp[32];
5791 u8 xb_mode, xb_reason;
5792
5793 if (count < 1)
5794 return -EFAULT;
5795
5796 if (count > sizeof(tmp)) {
5797 rtw_warn_on(1);
5798 return -EFAULT;
5799 }
5800
5801 if (buffer && !copy_from_user(tmp, buffer, count)) {
5802
5803 int num = sscanf(tmp, "%hhx %hhx", &xb_mode, &xb_reason);
5804
5805 if (num != 2) {
5806 RTW_INFO("invalid parameter!\n");
5807 return count;
5808 }
5809
5810 if (xb_mode == 0)/*set*/
5811 rtw_set_xmit_block(padapter, xb_reason);
5812 else if (xb_mode == 1)/*clear*/
5813 rtw_clr_xmit_block(padapter, xb_reason);
5814 else
5815 RTW_INFO("invalid parameter!\n");
5816 }
5817
5818 return count;
5819 }
5820 #endif
5821
proc_get_efuse_map(struct seq_file * m,void * v)5822 int proc_get_efuse_map(struct seq_file *m, void *v)
5823 {
5824 #if 0
5825 struct net_device *dev = m->private;
5826 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5827 HAL_DATA_TYPE *pHalData = GET_PHL_COM(adapter_to_dvobj(padapter));
5828 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
5829 PEFUSE_HAL pEfuseHal = &pHalData->EfuseHal;
5830 struct efuse_info *efuse = adapter_to_efuse(padapter);
5831 int i, j;
5832 u8 ips_mode = IPS_NUM;
5833 u16 mapLen;
5834
5835 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
5836 if (mapLen > EFUSE_MAX_MAP_LEN)
5837 mapLen = EFUSE_MAX_MAP_LEN;
5838
5839 ips_mode = pwrctrlpriv->ips_mode;
5840 rtw_pm_set_ips(padapter, IPS_NONE);
5841
5842 if (efuse->file_status == EFUSE_FILE_LOADED) {
5843 RTW_PRINT_SEL(m, "File eFuse Map loaded! file path:%s\nDriver eFuse Map From File\n", EFUSE_MAP_PATH);
5844 if (efuse->is_autoload_fail)
5845 RTW_PRINT_SEL(m, "File Autoload fail!!!\n");
5846 } else if (efuse->file_status == EFUSE_FILE_FAILED) {
5847 RTW_PRINT_SEL(m, "Open File eFuse Map Fail ! file path:%s\nDriver eFuse Map From Default\n", EFUSE_MAP_PATH);
5848 if (efuse->is_autoload_fail)
5849 RTW_PRINT_SEL(m, "HW Autoload fail!!!\n");
5850 } else {
5851 RTW_PRINT_SEL(m, "Driver eFuse Map From HW\n");
5852 if (efuse->is_autoload_fail)
5853 RTW_PRINT_SEL(m, "HW Autoload fail!!!\n");
5854 }
5855 for (i = 0; i < mapLen; i += 16) {
5856 RTW_PRINT_SEL(m, "0x%02x\t", i);
5857 for (j = 0; j < 8; j++)
5858 RTW_PRINT_SEL(m, "%02X ", efuse->data[i + j]);
5859 RTW_PRINT_SEL(m, "\t");
5860 for (; j < 16; j++)
5861 RTW_PRINT_SEL(m, "%02X ", efuse->data[i + j]);
5862 RTW_PRINT_SEL(m, "\n");
5863 }
5864
5865 if (rtw_efuse_map_read(padapter, 0, mapLen, pEfuseHal->fakeEfuseInitMap) == _FAIL) {
5866 RTW_PRINT_SEL(m, "WARN - Read Realmap Failed\n");
5867 return 0;
5868 }
5869
5870 RTW_PRINT_SEL(m, "\n");
5871 RTW_PRINT_SEL(m, "HW eFuse Map\n");
5872 for (i = 0; i < mapLen; i += 16) {
5873 RTW_PRINT_SEL(m, "0x%02x\t", i);
5874 for (j = 0; j < 8; j++)
5875 RTW_PRINT_SEL(m, "%02X ", pEfuseHal->fakeEfuseInitMap[i + j]);
5876 RTW_PRINT_SEL(m, "\t");
5877 for (; j < 16; j++)
5878 RTW_PRINT_SEL(m, "%02X ", pEfuseHal->fakeEfuseInitMap[i + j]);
5879 RTW_PRINT_SEL(m, "\n");
5880 }
5881
5882 rtw_pm_set_ips(padapter, ips_mode);
5883 #endif
5884 return 0;
5885 }
5886
proc_set_efuse_map(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5887 ssize_t proc_set_efuse_map(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5888 {
5889 #if 0
5890 char tmp[256] = {0};
5891 u32 addr, cnts;
5892 u8 efuse_data;
5893
5894 int jj, kk;
5895
5896 struct net_device *dev = data;
5897 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5898 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
5899 u8 ips_mode = IPS_NUM;
5900
5901 if (count < 3) {
5902 RTW_INFO("argument size is less than 3\n");
5903 return -EFAULT;
5904 }
5905
5906 if (count > sizeof(tmp)) {
5907 rtw_warn_on(1);
5908 return -EFAULT;
5909 }
5910
5911 if (buffer && !copy_from_user(tmp, buffer, count)) {
5912
5913 int num = sscanf(tmp, "%x %d %x", &addr, &cnts, &efuse_data);
5914
5915 if (num != 3) {
5916 RTW_INFO("invalid write_reg parameter!\n");
5917 return count;
5918 }
5919 }
5920 ips_mode = pwrctrlpriv->ips_mode;
5921 rtw_pm_set_ips(padapter, IPS_NONE);
5922 if (rtw_efuse_map_write(padapter, addr, cnts, &efuse_data) == _FAIL)
5923 RTW_INFO("WARN - rtw_efuse_map_write error!!\n");
5924 rtw_pm_set_ips(padapter, ips_mode);
5925 #endif
5926 return count;
5927 }
5928
5929 #ifdef CONFIG_IEEE80211W
proc_set_tx_sa_query(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5930 ssize_t proc_set_tx_sa_query(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5931 {
5932 struct net_device *dev = data;
5933 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5934 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5935 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5936 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5937 struct sta_priv *pstapriv = &padapter->stapriv;
5938 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
5939 /* macid_ctl move to phl */
5940 /* struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj); */
5941 struct sta_info *psta;
5942 _list *plist, *phead;
5943 char tmp[16];
5944 u8 mac_addr[NUM_STA][ETH_ALEN];
5945 u32 key_type;
5946 u8 index;
5947 void *phl = GET_PHL_INFO(dvobj);
5948 u16 macid_num = rtw_phl_get_macid_max_num(phl);
5949
5950 if (count > 2) {
5951 RTW_INFO("argument size is more than 2\n");
5952 return -EFAULT;
5953 }
5954
5955 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
5956
5957 int num = sscanf(tmp, "%x", &key_type);
5958
5959 if (num != 1) {
5960 RTW_INFO("invalid read_reg parameter!\n");
5961 return count;
5962 }
5963 RTW_INFO("0: set sa query request , key_type=%d\n", key_type);
5964 }
5965
5966 if (MLME_IS_STA(padapter)
5967 && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) && SEC_IS_BIP_KEY_INSTALLED(&padapter->securitypriv) == _TRUE) {
5968 RTW_INFO("STA:"MAC_FMT"\n", MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));
5969 /* TX unicast sa_query to AP */
5970 issue_action_SA_Query(padapter, get_my_bssid(&(pmlmeinfo->network)), 0, 0, (u8)key_type);
5971 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE && SEC_IS_BIP_KEY_INSTALLED(&padapter->securitypriv) == _TRUE) {
5972 /* TX unicast sa_query to every client STA */
5973 _rtw_spinlock_bh(&pstapriv->sta_hash_lock);
5974 for (index = 0; index < NUM_STA; index++) {
5975 psta = NULL;
5976
5977 phead = &(pstapriv->sta_hash[index]);
5978 plist = get_next(phead);
5979
5980 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
5981 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
5982 plist = get_next(plist);
5983 _rtw_memcpy(&mac_addr[psta->phl_sta->macid][0], psta->phl_sta->mac_addr, ETH_ALEN);
5984 }
5985 }
5986 _rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
5987
5988 for (index = 0; index < macid_num && index < NUM_STA; index++) {
5989 if (rtw_phl_macid_is_used(phl, index) && !rtw_phl_macid_is_bmc(phl, index)) {
5990 if (!_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)), &mac_addr[index][0], ETH_ALEN)
5991 && !IS_MCAST(&mac_addr[index][0])) {
5992 issue_action_SA_Query(padapter, &mac_addr[index][0], 0, 0, (u8)key_type);
5993 RTW_INFO("STA[%u]:"MAC_FMT"\n", index , MAC_ARG(&mac_addr[index][0]));
5994 }
5995 }
5996 }
5997 }
5998
5999 return count;
6000 }
6001
proc_get_tx_sa_query(struct seq_file * m,void * v)6002 int proc_get_tx_sa_query(struct seq_file *m, void *v)
6003 {
6004 struct net_device *dev = m->private;
6005 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6006
6007 RTW_PRINT_SEL(m, "%s\n", __func__);
6008 return 0;
6009 }
6010
proc_set_tx_deauth(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6011 ssize_t proc_set_tx_deauth(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6012 {
6013 struct net_device *dev = data;
6014 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6015 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
6016 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
6017 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
6018 struct sta_priv *pstapriv = &padapter->stapriv;
6019 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
6020 /* macid_ctl move to phl */
6021 /* struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj); */
6022 struct sta_info *psta;
6023 _list *plist, *phead;
6024 char tmp[16];
6025 u8 mac_addr[NUM_STA][ETH_ALEN];
6026 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
6027 u32 key_type = 0;
6028 u8 index;
6029 void *phl = GET_PHL_INFO(dvobj);
6030 u16 macid_num = rtw_phl_get_macid_max_num(phl);
6031
6032
6033 if (count > 2) {
6034 RTW_INFO("argument size is more than 2\n");
6035 return -EFAULT;
6036 }
6037
6038 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
6039
6040 int num = sscanf(tmp, "%x", &key_type);
6041
6042 if (num != 1) {
6043 RTW_INFO("invalid read_reg parameter!\n");
6044 return count;
6045 }
6046 RTW_INFO("key_type=%d\n", key_type);
6047 }
6048 if (key_type > 4)
6049 return count;
6050
6051 if (MLME_IS_STA(padapter)
6052 && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
6053 if (key_type == 3) /* key_type 3 only for AP mode */
6054 return count;
6055 /* TX unicast deauth to AP */
6056 issue_deauth_11w(padapter, get_my_bssid(&(pmlmeinfo->network)), 0, (u8)key_type);
6057 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) {
6058 u8 updated = _FALSE;
6059
6060 if (key_type == 3)
6061 issue_deauth_11w(padapter, bc_addr, 0, IEEE80211W_RIGHT_KEY);
6062
6063 /* TX unicast deauth to every client STA */
6064 _rtw_spinlock_bh(&pstapriv->sta_hash_lock);
6065 for (index = 0; index < NUM_STA; index++) {
6066 psta = NULL;
6067
6068 phead = &(pstapriv->sta_hash[index]);
6069 plist = get_next(phead);
6070
6071 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
6072 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
6073 plist = get_next(plist);
6074 _rtw_memcpy(&mac_addr[psta->phl_sta->macid][0], psta->phl_sta->mac_addr, ETH_ALEN);
6075 }
6076 }
6077 _rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
6078
6079 for (index = 0; index < macid_num && index < NUM_STA; index++) {
6080 if (rtw_phl_macid_is_used(phl, index) && !rtw_phl_macid_is_bmc(phl, index)) {
6081 if (!_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)), &mac_addr[index][0], ETH_ALEN)) {
6082 if (key_type != 3)
6083 issue_deauth_11w(padapter, &mac_addr[index][0], 0, (u8)key_type);
6084
6085 psta = rtw_get_stainfo(pstapriv, &mac_addr[index][0]);
6086 if (psta && key_type != IEEE80211W_WRONG_KEY && key_type != IEEE80211W_NO_KEY) {
6087 _rtw_spinlock_bh(&pstapriv->asoc_list_lock);
6088 if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
6089 rtw_list_delete(&psta->asoc_list);
6090 pstapriv->asoc_list_cnt--;
6091 #ifdef CONFIG_RTW_TOKEN_BASED_XMIT
6092 if (psta->tbtx_enable)
6093 pstapriv->tbtx_asoc_list_cnt--;
6094 #endif
6095 updated |= ap_free_sta(padapter, psta, _FALSE, WLAN_REASON_PREV_AUTH_NOT_VALID, _TRUE, _FALSE);
6096
6097 }
6098 _rtw_spinunlock_bh(&pstapriv->asoc_list_lock);
6099 }
6100
6101 RTW_INFO("STA[%u]:"MAC_FMT"\n", index , MAC_ARG(&mac_addr[index][0]));
6102 }
6103 }
6104 }
6105
6106 associated_clients_update(padapter, updated, STA_INFO_UPDATE_ALL);
6107 }
6108
6109 return count;
6110 }
6111
proc_get_tx_deauth(struct seq_file * m,void * v)6112 int proc_get_tx_deauth(struct seq_file *m, void *v)
6113 {
6114 struct net_device *dev = m->private;
6115 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6116
6117 RTW_PRINT_SEL(m, "%s\n", __func__);
6118 return 0;
6119 }
6120
proc_set_tx_auth(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6121 ssize_t proc_set_tx_auth(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6122 {
6123 struct net_device *dev = data;
6124 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6125 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
6126 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
6127 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
6128 struct sta_priv *pstapriv = &padapter->stapriv;
6129 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
6130 /* macid_ctl move to phl */
6131 /*struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj); */
6132 struct sta_info *psta;
6133 _list *plist, *phead;
6134 char tmp[16];
6135 u8 mac_addr[NUM_STA][ETH_ALEN];
6136 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
6137 u32 tx_auth;
6138 u8 index;
6139
6140
6141 if (count > 2) {
6142 RTW_INFO("argument size is more than 2\n");
6143 return -EFAULT;
6144 }
6145
6146 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
6147
6148 int num = sscanf(tmp, "%x", &tx_auth);
6149
6150 if (num != 1) {
6151 RTW_INFO("invalid read_reg parameter!\n");
6152 return count;
6153 }
6154 RTW_INFO("1: setnd auth, 2: send assoc request. tx_auth=%d\n", tx_auth);
6155 }
6156
6157 if (MLME_IS_STA(padapter)
6158 && (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)) {
6159 if (tx_auth == 1) {
6160 /* TX unicast auth to AP */
6161 issue_auth(padapter, NULL, 0);
6162 } else if (tx_auth == 2) {
6163 /* TX unicast auth to AP */
6164 issue_assocreq(padapter);
6165 }
6166 }
6167
6168 return count;
6169 }
6170
proc_get_tx_auth(struct seq_file * m,void * v)6171 int proc_get_tx_auth(struct seq_file *m, void *v)
6172 {
6173 struct net_device *dev = m->private;
6174 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6175
6176 RTW_PRINT_SEL(m, "%s\n", __func__);
6177 return 0;
6178 }
6179 #endif /* CONFIG_IEEE80211W */
6180
proc_get_ack_timeout(struct seq_file * m,void * v)6181 int proc_get_ack_timeout(struct seq_file *m, void *v)
6182 {
6183 struct net_device *dev = m->private;
6184 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6185 u8 ack_timeout_val = 0;
6186 u8 ack_timeout_val_cck = 0;
6187
6188 rtw_hal_get_hwreg(padapter, HW_VAR_ACKTO, &ack_timeout_val);
6189 rtw_hal_get_hwreg(padapter, HW_VAR_ACKTO_CCK, &ack_timeout_val_cck);
6190
6191 RTW_PRINT_SEL(m, "Current CCK packet ACK Timeout = %d us (0x%x).\n", ack_timeout_val_cck, ack_timeout_val_cck);
6192 RTW_PRINT_SEL(m, "Current non-CCK packet ACK Timeout = %d us (0x%x).\n", ack_timeout_val, ack_timeout_val);
6193 return 0;
6194 }
6195
proc_set_ack_timeout(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6196 ssize_t proc_set_ack_timeout(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6197 {
6198 struct net_device *dev = data;
6199 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6200 char tmp[32];
6201 u32 tmp_v1 = 0, tmp_v2 = 0;
6202 u8 ack_to_ms = 0, ack_to_cck_ms = 0;
6203
6204 if (count > sizeof(tmp)) {
6205 rtw_warn_on(1);
6206 return -EFAULT;
6207 }
6208
6209 if (buffer && !copy_from_user(tmp, buffer, count)) {
6210 int num = sscanf(tmp, "%u %u", &tmp_v1, &tmp_v2);
6211
6212 if (num < 1) {
6213 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
6214 return -EINVAL;
6215 }
6216
6217 if (tmp_v1) {
6218 ack_to_ms = (u8)tmp_v1;
6219 rtw_hal_set_hwreg(padapter, HW_VAR_ACKTO, &ack_to_ms);
6220 }
6221
6222 if (tmp_v2) {
6223 ack_to_cck_ms = (u8)tmp_v2;
6224 rtw_hal_set_hwreg(padapter, HW_VAR_ACKTO_CCK, &ack_to_cck_ms);
6225 }
6226 /* This register sets the Ack time out value after Tx unicast packet. It is in units of us. */
6227 /* This register sets the Ack time out value after Tx unicast CCK packet. It is in units of us. */
6228 RTW_INFO("Set CCK packet ACK Timeout to %d us.\n", ack_to_cck_ms);
6229 RTW_INFO("Set non-CCK packet ACK Timeout to %d us.\n", ack_to_ms);
6230 }
6231
6232 return count;
6233 }
6234
proc_set_fw_offload(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6235 ssize_t proc_set_fw_offload(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6236 {
6237
6238 #if 0 /*GEORGIA_TODO_FIXIT*/
6239 struct net_device *dev = data;
6240 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6241 _adapter *pri_adapter = GET_PRIMARY_ADAPTER(adapter);
6242 HAL_DATA_TYPE *hal = GET_PHL_COM(adapter_to_dvobj(adapter));
6243 char tmp[32];
6244 u32 iqk_offload_enable = 0, ch_switch_offload_enable = 0;
6245
6246 if (buffer == NULL) {
6247 RTW_INFO("input buffer is NULL!\n");
6248 return -EFAULT;
6249 }
6250
6251 if (count < 1) {
6252 RTW_INFO("input length is 0!\n");
6253 return -EFAULT;
6254 }
6255
6256 if (count > sizeof(tmp)) {
6257 RTW_INFO("input length is too large\n");
6258 rtw_warn_on(1);
6259 return -EFAULT;
6260 }
6261
6262 if (buffer && !copy_from_user(tmp, buffer, count)) {
6263 int num = sscanf(tmp, "%d %d", &iqk_offload_enable, &ch_switch_offload_enable);
6264
6265 if (num < 2) {
6266 RTW_INFO("input parameters < 1\n");
6267 return -EINVAL;
6268 }
6269
6270 if (hal->RegIQKFWOffload != iqk_offload_enable) {
6271 hal->RegIQKFWOffload = iqk_offload_enable;
6272 rtw_run_in_thread_cmd(pri_adapter, ((void *)(rtw_hal_update_iqk_fw_offload_cap)), pri_adapter);
6273 }
6274
6275 if (hal->ch_switch_offload != ch_switch_offload_enable)
6276 hal->ch_switch_offload = ch_switch_offload_enable;
6277 }
6278
6279 return count;
6280 #endif
6281 return 0;
6282 }
6283
proc_get_fw_offload(struct seq_file * m,void * v)6284 int proc_get_fw_offload(struct seq_file *m, void *v)
6285 {
6286 #if 0 /*GEORGIA_TODO_FIXIT*/
6287 struct net_device *dev = m->private;
6288 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6289 HAL_DATA_TYPE *hal = GET_PHL_COM(adapter_to_dvobj(adapter));
6290
6291
6292 RTW_PRINT_SEL(m, "IQK FW offload:%s\n", hal->RegIQKFWOffload?"enable":"disable");
6293 RTW_PRINT_SEL(m, "Channel switch FW offload:%s\n", hal->ch_switch_offload?"enable":"disable");
6294 #endif
6295 return 0;
6296 }
6297
6298 #ifdef CONFIG_CTRL_TXSS_BY_TP
proc_set_txss_tp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6299 ssize_t proc_set_txss_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6300 {
6301 struct net_device *dev = data;
6302 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6303 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
6304
6305 char tmp[32];
6306 u32 enable = 0;
6307 u32 txss_tx_tp = 0;
6308 int txss_chk_cnt = 0;
6309
6310 if (buffer == NULL) {
6311 RTW_INFO("input buffer is NULL!\n");
6312 return -EFAULT;
6313 }
6314
6315 if (count < 1) {
6316 RTW_INFO("input length is 0!\n");
6317 return -EFAULT;
6318 }
6319
6320 if (count > sizeof(tmp)) {
6321 RTW_INFO("input length is too large\n");
6322 rtw_warn_on(1);
6323 return -EFAULT;
6324 }
6325
6326 if (buffer && !copy_from_user(tmp, buffer, count)) {
6327 int num = sscanf(tmp, "%u %u %d",
6328 &enable, &txss_tx_tp, &txss_chk_cnt);
6329
6330 if (num < 1) {
6331 RTW_INFO("input parameters < 1\n");
6332 return -EINVAL;
6333 }
6334 pmlmeext->txss_ctrl_en = enable;
6335
6336 if (txss_tx_tp)
6337 pmlmeext->txss_tp_th = txss_tx_tp;
6338 if (txss_chk_cnt)
6339 pmlmeext->txss_tp_chk_cnt = txss_chk_cnt;
6340
6341 RTW_INFO("%s txss_ctl_en :%s , txss_tp_th:%d, tp_chk_cnt:%d\n",
6342 __func__, pmlmeext->txss_tp_th ? "Y" : "N",
6343 pmlmeext->txss_tp_th, pmlmeext->txss_tp_chk_cnt);
6344
6345 }
6346
6347 return count;
6348 }
6349
proc_get_txss_tp(struct seq_file * m,void * v)6350 int proc_get_txss_tp(struct seq_file *m, void *v)
6351 {
6352 struct net_device *dev = m->private;
6353 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6354 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
6355
6356 RTW_PRINT_SEL(m, "TXSS Control - %s\n", pmlmeext->txss_ctrl_en ? "enable" : "disable");
6357 RTW_PRINT_SEL(m, "TXSS Tx TP TH - %d\n", pmlmeext->txss_tp_th);
6358 RTW_PRINT_SEL(m, "TXSS check cnt - %d\n", pmlmeext->txss_tp_chk_cnt);
6359
6360 return 0;
6361 }
6362 #ifdef DBG_CTRL_TXSS
proc_set_txss_ctrl(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6363 ssize_t proc_set_txss_ctrl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6364 {
6365 struct net_device *dev = data;
6366 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6367 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
6368
6369 char tmp[32];
6370 u32 tx_1ss = 0;
6371
6372 if (buffer == NULL) {
6373 RTW_INFO("input buffer is NULL!\n");
6374 return -EFAULT;
6375 }
6376
6377 if (count < 1) {
6378 RTW_INFO("input length is 0!\n");
6379 return -EFAULT;
6380 }
6381
6382 if (count > sizeof(tmp)) {
6383 RTW_INFO("input length is too large\n");
6384 rtw_warn_on(1);
6385 return -EFAULT;
6386 }
6387
6388 if (buffer && !copy_from_user(tmp, buffer, count)) {
6389 int num = sscanf(tmp, "%u", &tx_1ss);
6390
6391 if (num < 1) {
6392 RTW_INFO("input parameters < 1\n");
6393 return -EINVAL;
6394 }
6395
6396 pmlmeext->txss_ctrl_en = _FALSE;
6397
6398 dbg_ctrl_txss(adapter, tx_1ss);
6399
6400 RTW_INFO("%s set tx to 1ss :%s\n", __func__, tx_1ss ? "Y" : "N");
6401 }
6402
6403 return count;
6404 }
6405
proc_get_txss_ctrl(struct seq_file * m,void * v)6406 int proc_get_txss_ctrl(struct seq_file *m, void *v)
6407 {
6408 struct net_device *dev = m->private;
6409 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6410 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
6411
6412 RTW_PRINT_SEL(m, "TXSS 1ss - %s\n", pmlmeext->txss_1ss ? "Y" : "N");
6413
6414 return 0;
6415 }
6416 #endif
6417 #endif
6418
6419 #ifdef CONFIG_DBG_RF_CAL
proc_get_iqk_info(struct seq_file * m,void * v)6420 int proc_get_iqk_info(struct seq_file *m, void *v)
6421 {
6422 struct net_device *dev = m->private;
6423 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6424
6425 return 0;
6426 }
6427
proc_set_iqk(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6428 ssize_t proc_set_iqk(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6429 {
6430 struct net_device *dev = data;
6431 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6432 char tmp[32];
6433 u32 recovery, clear, segment;
6434
6435 if (count < 1)
6436 return -EFAULT;
6437
6438 if (count > sizeof(tmp)) {
6439 rtw_warn_on(1);
6440 return -EFAULT;
6441 }
6442
6443 if (buffer && !copy_from_user(tmp, buffer, count)) {
6444
6445 int num = sscanf(tmp, "%d %d %d", &recovery, &clear, &segment);
6446
6447 if (num != 3) {
6448 RTW_INFO("Invalid format\n");
6449 return count;
6450 }
6451
6452 rtw_hal_iqk_test(padapter, recovery, clear, segment);
6453 }
6454
6455 return count;
6456
6457 }
6458
proc_get_lck_info(struct seq_file * m,void * v)6459 int proc_get_lck_info(struct seq_file *m, void *v)
6460 {
6461 struct net_device *dev = m->private;
6462 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6463
6464 return 0;
6465 }
6466
proc_set_lck(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6467 ssize_t proc_set_lck(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6468 {
6469 struct net_device *dev = data;
6470 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6471 char tmp[32];
6472 u32 trigger;
6473
6474 if (count < 1)
6475 return -EFAULT;
6476
6477 if (count > sizeof(tmp)) {
6478 rtw_warn_on(1);
6479 return -EFAULT;
6480 }
6481
6482 if (buffer && !copy_from_user(tmp, buffer, count)) {
6483
6484 int num = sscanf(tmp, "%d", &trigger);
6485
6486 if (num != 1) {
6487 RTW_INFO("Invalid format\n");
6488 return count;
6489 }
6490
6491 rtw_hal_lck_test(padapter);
6492 }
6493
6494 return count;
6495 }
6496 #endif /* CONFIG_DBG_RF_CAL */
6497
6498 #ifdef CONFIG_LPS_CHK_BY_TP
proc_set_lps_chk_tp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6499 ssize_t proc_set_lps_chk_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6500 {
6501 struct net_device *dev = data;
6502 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6503 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
6504 char tmp[32];
6505 u32 enable = 0;
6506 u32 lps_tx_tp = 0, lps_rx_tp = 0, lps_bi_tp = 0;
6507 int lps_chk_cnt_th = 0;
6508 u32 lps_tx_pkts = 0, lps_rx_pkts = 0;
6509
6510 if (buffer == NULL) {
6511 RTW_INFO("input buffer is NULL!\n");
6512 return -EFAULT;
6513 }
6514
6515 if (count < 1) {
6516 RTW_INFO("input length is 0!\n");
6517 return -EFAULT;
6518 }
6519
6520 if (count > sizeof(tmp)) {
6521 RTW_INFO("input length is too large\n");
6522 rtw_warn_on(1);
6523 return -EFAULT;
6524 }
6525
6526 if (buffer && !copy_from_user(tmp, buffer, count)) {
6527 int num = sscanf(tmp, "%u %u %u %u %d %u %u",
6528 &enable, &lps_tx_tp, &lps_rx_tp, &lps_bi_tp,
6529 &lps_chk_cnt_th, &lps_tx_pkts, &lps_rx_pkts);
6530
6531 if (num < 1) {
6532 RTW_INFO("input parameters < 1\n");
6533 return -EINVAL;
6534 }
6535 pwrpriv->lps_chk_by_tp = enable;
6536
6537 if (lps_tx_tp) {
6538 pwrpriv->lps_tx_tp_th = lps_tx_tp;
6539 pwrpriv->lps_rx_tp_th = lps_tx_tp;
6540 pwrpriv->lps_bi_tp_th = lps_tx_tp;
6541 }
6542 if (lps_rx_tp)
6543 pwrpriv->lps_rx_tp_th = lps_rx_tp;
6544 if (lps_bi_tp)
6545 pwrpriv->lps_bi_tp_th = lps_bi_tp;
6546
6547 if (lps_chk_cnt_th)
6548 pwrpriv->lps_chk_cnt_th = lps_chk_cnt_th;
6549
6550 if (lps_tx_pkts)
6551 pwrpriv->lps_tx_pkts = lps_tx_pkts;
6552
6553 if (lps_rx_pkts)
6554 pwrpriv->lps_rx_pkts = lps_rx_pkts;
6555
6556 RTW_INFO("%s lps_chk_by_tp:%s , lps_tx_tp_th:%d, lps_tx_tp_th:%d, lps_bi_tp:%d\n",
6557 __func__, pwrpriv->lps_chk_by_tp ? "Y" : "N",
6558 pwrpriv->lps_tx_tp_th, pwrpriv->lps_tx_tp_th, pwrpriv->lps_bi_tp_th);
6559 RTW_INFO("%s lps_chk_cnt_th:%d , lps_tx_pkts:%d, lps_rx_pkts:%d\n",
6560 __func__, pwrpriv->lps_chk_cnt_th, pwrpriv->lps_tx_pkts, pwrpriv->lps_rx_pkts);
6561 }
6562
6563 return count;
6564 }
6565
proc_get_lps_chk_tp(struct seq_file * m,void * v)6566 int proc_get_lps_chk_tp(struct seq_file *m, void *v)
6567 {
6568 struct net_device *dev = m->private;
6569 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6570 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(adapter);
6571
6572 RTW_PRINT_SEL(m, "LPS chk by tp - %s\n", pwrpriv->lps_chk_by_tp ? "enable" : "disable");
6573 RTW_PRINT_SEL(m, "LPS Tx TP TH - %d(Mbps)\n", pwrpriv->lps_tx_tp_th);
6574 RTW_PRINT_SEL(m, "LPS Rx TP TH - %d(Mbps)\n", pwrpriv->lps_rx_tp_th);
6575 RTW_PRINT_SEL(m, "LPS BI TP TH - %d(Mbps)\n", pwrpriv->lps_bi_tp_th);
6576
6577 RTW_PRINT_SEL(m, "LPS CHK CNT - %d\n", pwrpriv->lps_chk_cnt_th);
6578 RTW_PRINT_SEL(m, "LPS Tx PKTs - %d\n", pwrpriv->lps_tx_pkts);
6579 RTW_PRINT_SEL(m, "LPS Rx PKTs - %d\n", pwrpriv->lps_rx_pkts);
6580 return 0;
6581 }
6582 #endif /*CONFIG_LPS_CHK_BY_TP*/
6583 #ifdef CONFIG_SUPPORT_STATIC_SMPS
proc_set_smps(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6584 ssize_t proc_set_smps(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6585 {
6586 struct net_device *dev = data;
6587 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6588 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
6589 char tmp[32];
6590 u32 enable = 0;
6591 u32 smps_en, smps_tx_tp = 0, smps_rx_tp = 0;
6592 u32 smps_test = 0, smps_test_en = 0;
6593
6594 if (buffer == NULL) {
6595 RTW_INFO("input buffer is NULL!\n");
6596 return -EFAULT;
6597 }
6598
6599 if (count < 1) {
6600 RTW_INFO("input length is 0!\n");
6601 return -EFAULT;
6602 }
6603
6604 if (count > sizeof(tmp)) {
6605 RTW_INFO("input length is too large\n");
6606 rtw_warn_on(1);
6607 return -EFAULT;
6608 }
6609
6610 if (buffer && !copy_from_user(tmp, buffer, count)) {
6611 int num = sscanf(tmp, "%u %u %u %u %u", &smps_en, &smps_tx_tp, &smps_rx_tp,
6612 &smps_test, &smps_test_en);
6613
6614 if (num < 1) {
6615 RTW_INFO("input parameters < 1\n");
6616 return -EINVAL;
6617 }
6618
6619 pmlmeext->ssmps_en = smps_en;
6620 if (smps_tx_tp) {
6621 pmlmeext->ssmps_tx_tp_th= smps_tx_tp;
6622 pmlmeext->ssmps_rx_tp_th= smps_tx_tp;
6623 }
6624 if (smps_rx_tp)
6625 pmlmeext->ssmps_rx_tp_th = smps_rx_tp;
6626
6627 #ifdef DBG_STATIC_SMPS
6628 if (num > 3) {
6629 pmlmeext->ssmps_test = smps_test;
6630 pmlmeext->ssmps_test_en = smps_test_en;
6631 }
6632 #endif
6633 RTW_INFO("SM PS : %s tx_tp_th:%d, rx_tp_th:%d\n",
6634 (smps_en) ? "Enable" : "Disable",
6635 pmlmeext->ssmps_tx_tp_th,
6636 pmlmeext->ssmps_rx_tp_th);
6637 #ifdef DBG_STATIC_SMPS
6638 RTW_INFO("SM PS : %s ssmps_test_en:%d\n",
6639 (smps_test) ? "Enable" : "Disable",
6640 pmlmeext->ssmps_test_en);
6641 #endif
6642 }
6643
6644 return count;
6645 }
6646
proc_get_smps(struct seq_file * m,void * v)6647 int proc_get_smps(struct seq_file *m, void *v)
6648 {
6649 struct net_device *dev = m->private;
6650 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6651 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
6652
6653 RTW_PRINT_SEL(m, "Static SMPS %s\n", pmlmeext->ssmps_en ? "enable" : "disable");
6654 RTW_PRINT_SEL(m, "Tx TP TH %d\n", pmlmeext->ssmps_tx_tp_th);
6655 RTW_PRINT_SEL(m, "Rx TP TH %d\n", pmlmeext->ssmps_rx_tp_th);
6656 #ifdef DBG_STATIC_SMPS
6657 RTW_PRINT_SEL(m, "test %d, test_en:%d\n", pmlmeext->ssmps_test, pmlmeext->ssmps_test_en);
6658 #endif
6659 return 0;
6660 }
6661 #endif /*CONFIG_SUPPORT_STATIC_SMPS*/
6662
6663 #ifdef RTW_DETECT_HANG
proc_get_hang_info(struct seq_file * m,void * v)6664 int proc_get_hang_info(struct seq_file *m, void *v)
6665 {
6666 struct net_device *dev = m->private;
6667 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6668 struct dvobj_priv *pdvobjpriv = padapter->dvobj;
6669 struct debug_priv *pdbgpriv = &pdvobjpriv->drv_dbg;
6670 struct hang_info *phang_info = &pdbgpriv->dbg_hang_info;
6671 struct fw_hang_info *pfw_hang_info = &phang_info->dbg_fw_hang_info;
6672 struct rxff_hang_info *prxff_hang_info = &phang_info->dbg_rxff_hang_info;
6673 u8 is_hang = _FALSE;
6674 u8 fw_gone = _FALSE;
6675
6676 if (dev_is_surprise_removed(pdvobjpriv))
6677 is_hang = _TRUE;
6678
6679 if (pfw_hang_info->dbg_is_fw_gone &&
6680 rtw_hw_get_init_completed(pdvobjpriv) &&
6681 !padapter->registrypriv.mp_mode)
6682 fw_gone = _TRUE;
6683
6684 if (pfw_hang_info->dbg_is_fw_hang || is_hang || fw_gone ||
6685 prxff_hang_info->dbg_is_rxff_hang) {
6686 RTW_PRINT_SEL(m, "1\n");
6687
6688 if (pfw_hang_info->dbg_is_fw_hang)
6689 RTW_PRINT_SEL(m, "FW hang\n");
6690 if (prxff_hang_info->dbg_is_rxff_hang)
6691 RTW_PRINT_SEL(m, "RXFF hang\n");
6692 if (is_hang)
6693 RTW_PRINT_SEL(m, "surprise remove\n");
6694 if (fw_gone)
6695 RTW_PRINT_SEL(m, "FW gone\n");
6696 } else {
6697 RTW_PRINT_SEL(m, "0\n");
6698 }
6699
6700 RTW_PRINT_SEL(m, "Enter cnt = %d\n", phang_info->enter_cnt);
6701 exit:
6702 return 0;
6703 }
6704 #endif /* RTW_DETECT_HANG */
6705
proc_get_disconnect_info(struct seq_file * m,void * v)6706 int proc_get_disconnect_info(struct seq_file *m, void *v)
6707 {
6708 struct net_device *dev = m->private;
6709 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6710 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
6711 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
6712 char *disconnect_reason;
6713 char *illegal_beacon_reason;
6714
6715 if (pmlmeinfo) {
6716 switch (pmlmeinfo->disconnect_code) {
6717 case DISCONNECTION_NOT_YET_OCCUR:
6718 disconnect_reason = "Disconnection has not yet occurred.";
6719 break;
6720 case DISCONNECTION_BY_SYSTEM_DUE_TO_HIGH_LAYER_COMMAND:
6721 disconnect_reason = "System requests to disconnect by command.";
6722 break;
6723 case DISCONNECTION_BY_SYSTEM_DUE_TO_NET_DEVICE_DOWN:
6724 disconnect_reason = "System makes net_device down to cause disconnection.";
6725 break;
6726 case DISCONNECTION_BY_SYSTEM_DUE_TO_SYSTEM_IN_SUSPEND:
6727 disconnect_reason = "System enters suspend state to cause disconnection.";
6728 break;
6729 case DISCONNECTION_BY_DRIVER_DUE_TO_CONNECTION_EXIST:
6730 disconnect_reason = "The connection is exist so it triggers disconnection when joinbss.";
6731 break;
6732 case DISCONNECTION_BY_DRIVER_DUE_TO_EACH_IFACE_CHBW_NOT_SYNC:
6733 disconnect_reason = "Multiple interfaces do not synchronize channel and bandwidth when joinbss.";
6734 break;
6735 case DISCONNECTION_BY_DRIVER_DUE_TO_DFS_DETECTION:
6736 disconnect_reason = "DFS Slave mechanism detects radar to cause disconnection.";
6737 break;
6738 case DISCONNECTION_BY_DRIVER_DUE_TO_IOCTL_DBG_PORT:
6739 disconnect_reason = "Using ioctl dbg port command to accomplish disconnection.";
6740 break;
6741 case DISCONNECTION_BY_DRIVER_DUE_TO_AP_BEACON_CHANGED:
6742 disconnect_reason = "AP's beacon content was changed to cause disconnection.";
6743 break;
6744 case DISCONNECTION_BY_DRIVER_DUE_TO_KEEPALIVE_TIMEOUT:
6745 disconnect_reason = "Maybe AP disappears to trigger station keepalive timeout and connection break.";
6746 break;
6747 case DISCONNECTION_BY_DRIVER_DUE_TO_LAYER2_ROAMING_TERMINATE:
6748 disconnect_reason = "Layer2 roaming terminated to trigger disconnection.";
6749 break;
6750 case DISCONNECTION_BY_DRIVER_DUE_TO_JOINBSS_TIMEOUT:
6751 disconnect_reason = "Station joinbss process is timeout to trigger disconnection.";
6752 break;
6753 case DISCONNECTION_BY_FW_DUE_TO_FW_DECISION_IN_WOW_RESUME:
6754 disconnect_reason = "FW decides to disconnect in WOW resume flow.";
6755 break;
6756 case DISCONNECTION_BY_AP_DUE_TO_RECEIVE_DISASSOC_IN_WOW_RESUME:
6757 disconnect_reason = "Receiving Disassociation frame from AP to cause disconnection in WOW resume flow.";
6758 break;
6759 case DISCONNECTION_BY_AP_DUE_TO_RECEIVE_DEAUTH_IN_WOW_RESUME:
6760 disconnect_reason = "Receiving Deauth frame from AP to cause disconnection in WOW resume flow.";
6761 break;
6762 case DISCONNECTION_BY_AP_DUE_TO_RECEIVE_DEAUTH:
6763 disconnect_reason = "Receiving Deauth frame from AP to cause disconnection.";
6764 break;
6765 case DISCONNECTION_BY_AP_DUE_TO_RECEIVE_DISASSOC:
6766 disconnect_reason = "Receiving Disassociation frame from AP to cause disconnection.";
6767 break;
6768 case DISCONNECTION_BY_DRIVER_DUE_TO_RECEIVE_CSA_NON_DFS:
6769 disconnect_reason = "Disconnection due to AP switched to unsupported channel.";
6770 break;
6771 case DISCONNECTION_BY_DRIVER_DUE_TO_RECEIVE_CSA_DFS:
6772 disconnect_reason = "Disconnection due to AP switched to unsupported DFS channel.";
6773 break;
6774 case DISCONNECTION_BY_DRIVER_DUE_TO_RECEIVE_INVALID_CSA:
6775 disconnect_reason = "Disconnection due to received invalid CSA IE";
6776 break;
6777 case DISCONNECTION_BY_DRIVER_DUE_TO_JOIN_WRONG_CHANNEL:
6778 disconnect_reason = "Disconnection due to joined wrong channel";
6779 break;
6780 case DISCONNECTION_BY_DRIVER_DUE_TO_FT:
6781 disconnect_reason = "Disconnection due to FT";
6782 break;
6783 case DISCONNECTION_BY_DRIVER_DUE_TO_ROAMING:
6784 disconnect_reason = "Disconnection due to roaming";
6785 break;
6786 case DISCONNECTION_BY_DRIVER_DUE_TO_SA_QUERY_TIMEOUT:
6787 disconnect_reason = "Disconnection due to SA Query timeout";
6788 break;
6789 default:
6790 disconnect_reason = "Unspecified";
6791 break;
6792 }
6793
6794 RTW_PRINT_SEL(m, "occurred disconnection time = %d\n", pmlmeinfo->disconnect_occurred_time);
6795 RTW_PRINT_SEL(m, "disconnect code = %d\n", pmlmeinfo->disconnect_code);
6796 RTW_PRINT_SEL(m, "last disconnect reason: %s\n", disconnect_reason);
6797 RTW_PRINT_SEL(m, "beacon code: %d\n", pmlmeinfo->illegal_beacon_code);
6798 if (pmlmeinfo->disconnect_code == DISCONNECTION_BY_DRIVER_DUE_TO_AP_BEACON_CHANGED) {
6799 if(pmlmeinfo->illegal_beacon_code & SSID_CHANGED)
6800 RTW_PRINT_SEL(m, "illegal beacon reason: The SSID of beacon is changed.\n");
6801 if(pmlmeinfo->illegal_beacon_code & SSID_LENGTH_CHANGED)
6802 RTW_PRINT_SEL(m, "illegal beacon reason: The SSID length of beacon is changed.\n");
6803 if(pmlmeinfo->illegal_beacon_code & BEACON_CHANNEL_CHANGED)
6804 RTW_PRINT_SEL(m, "illegal beacon reason: The Beacon channel of beacon is changed.\n");
6805 if(pmlmeinfo->illegal_beacon_code & ENCRYPT_PROTOCOL_CHANGED)
6806 RTW_PRINT_SEL(m, "illegal beacon reason: The Encrypt protocol of beacon is changed.\n");
6807 if(pmlmeinfo->illegal_beacon_code & PAIRWISE_CIPHER_CHANGED)
6808 RTW_PRINT_SEL(m, "illegal beacon reason: The Pairwise cipheris of beacon changed.\n");
6809 if(pmlmeinfo->illegal_beacon_code & GROUP_CIPHER_CHANGED)
6810 RTW_PRINT_SEL(m, "illegal beacon reason: The Group cipher of beacon is changed.\n");
6811 if(pmlmeinfo->illegal_beacon_code & IS_8021X_CHANGED)
6812 RTW_PRINT_SEL(m, "illegal beacon reason: The 802.1x of beacon is changed.\n");
6813 } else {
6814 RTW_PRINT_SEL(m, "illegal beacon reason: NA.\n");
6815 }
6816
6817 RTW_PRINT_SEL(m, "Wi-Fi reason code: %d\n",
6818 pmlmeinfo->disconnect_code ? pmlmeinfo->wifi_reason_code : 0);
6819 }
6820
6821 return 0;
6822 }
6823
proc_set_disconnect_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6824 ssize_t proc_set_disconnect_info(struct file *file, const char __user *buffer,
6825 size_t count, loff_t *pos, void *data)
6826 {
6827 struct net_device *dev = data;
6828 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6829 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
6830 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
6831 char tmp[32];
6832 u8 clear;
6833
6834 if (!pmlmeinfo)
6835 return -EPERM;
6836
6837 if (count < 1)
6838 return -EFAULT;
6839
6840 if (count > sizeof(tmp)) {
6841 rtw_warn_on(1);
6842 return -EFAULT;
6843 }
6844
6845 if (buffer && !copy_from_user(tmp, buffer, count)) {
6846 int num = sscanf(tmp, "%hhd", &clear);
6847 if (num == 1 && clear == 0) {
6848 pmlmeinfo->disconnect_occurred_time = 0;
6849 pmlmeinfo->disconnect_code = DISCONNECTION_NOT_YET_OCCUR;
6850 pmlmeinfo->illegal_beacon_code = 0;
6851 }
6852 }
6853
6854 return count;
6855 }
6856
proc_get_chan(struct seq_file * m,void * v)6857 int proc_get_chan(struct seq_file *m, void *v)
6858 {
6859 struct net_device *dev = m->private;
6860 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6861
6862 RTW_PRINT_SEL(m, "ch=%d, ch_offset=%d, bw=%d\n",
6863 rtw_get_oper_ch(padapter),
6864 rtw_get_oper_choffset(padapter),
6865 rtw_get_oper_bw(padapter));
6866
6867 RTW_PRINT_SEL(m, "PHL ch=%d\n",
6868 rtw_phl_get_cur_ch(padapter->phl_role));
6869 return 0;
6870 }
6871
proc_set_chan(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6872 ssize_t proc_set_chan(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6873 {
6874 char tmp[32];
6875 struct net_device *dev = data;
6876 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6877 u8 target_ch, target_offset, target_bw;
6878 #ifdef DBG_CONFIG_CMD_DISP
6879 u8 cmd_type = 0xFF;
6880 u8 cmd_to = 0;
6881 #endif
6882 if (count < 3) {
6883 RTW_INFO("argument size is less than 3\n");
6884 return -EFAULT;
6885 }
6886
6887 if (count > sizeof(tmp)) {
6888 rtw_warn_on(1);
6889 return -EFAULT;
6890 }
6891
6892 if (buffer && !copy_from_user(tmp, buffer, count)) {
6893 int num = 0;
6894 #ifdef DBG_CONFIG_CMD_DISP
6895 num = sscanf(tmp, "%hhu %hhu %hhu %hhu %hhu",
6896 &target_ch, &target_offset, &target_bw,
6897 &cmd_type, &cmd_to);
6898 if (num != 5) {
6899 RTW_INFO("invalid write_reg parameter!\n");
6900 return count;
6901 }
6902
6903 padapter->cmd_type = cmd_type;
6904 padapter->cmd_timeout = cmd_to;
6905 #else
6906 num = sscanf(tmp, "%hhu %hhu %hhu",
6907 &target_ch, &target_offset, &target_bw);
6908 if (num != 3) {
6909 RTW_INFO("invalid write_reg parameter!\n");
6910 return count;
6911 }
6912 #endif
6913 set_channel_bwmode(padapter, target_ch, target_offset, target_bw, _FALSE);
6914 }
6915
6916 return count;
6917 }
6918
proc_get_mr_test(struct seq_file * m,void * v)6919 int proc_get_mr_test(struct seq_file *m, void *v)
6920 {
6921 struct net_device *dev = m->private;
6922 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6923
6924 return 0;
6925 }
6926
proc_set_mr_test(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6927 ssize_t proc_set_mr_test(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6928 {
6929 char tmp[32];
6930 struct net_device *dev = data;
6931 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6932 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
6933 u8 mode, param, param_1, param_2;
6934 bool show_caller;
6935
6936 if (count < 2) {
6937 RTW_INFO("argument size is less than 3\n");
6938 return -EFAULT;
6939 }
6940
6941 if (count > sizeof(tmp)) {
6942 rtw_warn_on(1);
6943 return -EFAULT;
6944 }
6945
6946 if (buffer && !copy_from_user(tmp, buffer, count)) {
6947 int num = 0;
6948
6949 num = sscanf(tmp, "%hhu %hhu %hhu %hhu", &mode, ¶m, ¶m_1, ¶m_2);
6950 if (num < 2) {
6951 RTW_INFO("invalid write_reg parameter!\n");
6952 return count;
6953 }
6954 #ifdef PHL_MR_PROC_CMD
6955 if (mode == 1) {
6956 show_caller = (param) ? _TRUE : _FALSE;
6957 rtw_phl_mr_dump_info(dvobj->phl, show_caller);
6958 }
6959 else if (mode == 2) {
6960 show_caller = (param) ? _TRUE : _FALSE;
6961 rtw_phl_mr_dump_band_ctl(dvobj->phl, show_caller);
6962 }
6963 else if (mode == 3) {
6964 if (param == 1)
6965 rtw_phl_mr_dump_mac_addr(dvobj->phl, padapter->phl_role);
6966 else if (param == 2)
6967 rtw_phl_mr_buddy_dump_mac_addr(dvobj->phl, padapter->phl_role);
6968 }
6969 else if (mode == 4 || mode == 5) {
6970 u8 chan;
6971 enum channel_width bw;
6972 enum chan_offset offset;
6973 bool rst, is_add;
6974
6975 is_add = (mode == 4) ? _TRUE : _FALSE;
6976 chan = param;
6977 bw = param_1;
6978 offset = param_2;
6979
6980 rst = rtw_phl_chanctx_test(dvobj->phl, padapter->phl_role, is_add, &chan, &bw, &offset);
6981 RTW_INFO("%s s_ch:%d,s_bw:%d,s_offset:%d, r_ch:%d, r_bw:%d, r_offset:%d\n",
6982 __func__, param, param_1, param_2, chan, bw, offset);
6983 }
6984 else if (mode == 6) {
6985 show_caller = (param) ? _TRUE : _FALSE;
6986 rtw_phl_sta_dump_info(dvobj->phl, show_caller, padapter->phl_role, param_1);
6987 }
6988 #endif
6989 }
6990
6991 return count;
6992 }
6993
proc_get_deny_legacy(struct seq_file * m,void * v)6994 int proc_get_deny_legacy(struct seq_file *m, void *v)
6995 {
6996 struct net_device *dev = m->private;
6997 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6998 struct registry_priv *pregpriv = &padapter->registrypriv;
6999 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
7000
7001 if (pregpriv)
7002 RTW_PRINT_SEL(m, "deny_legacy = 0x%x\n", pregpriv->deny_legacy);
7003
7004 if (pmlmeext)
7005 RTW_PRINT_SEL(m, "cur_wireless_mode = 0x%x\n", pmlmeext->cur_wireless_mode);
7006
7007 return 0;
7008 }
7009
proc_set_deny_legacy(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)7010 ssize_t proc_set_deny_legacy(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
7011 {
7012 struct net_device *dev = data;
7013 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
7014 struct registry_priv *pregpriv = &padapter->registrypriv;
7015 char tmp[32];
7016 u8 legacy;
7017
7018 if (count < 1)
7019 return -EFAULT;
7020
7021 if (count > sizeof(tmp)) {
7022 rtw_warn_on(1);
7023 return -EFAULT;
7024 }
7025
7026 if (buffer && !copy_from_user(tmp, buffer, count)) {
7027
7028 int num = sscanf(tmp, "%hhu ", &legacy);
7029
7030 if (num == 1 && pregpriv) {
7031 pregpriv->deny_legacy = legacy;
7032 RTW_INFO("deny_legacy=%d\n", legacy);
7033 }
7034 }
7035
7036 return count;
7037 }
7038
7039 #ifdef CONFIG_80211AX_HE
proc_get_tx_ul_mu_disable(struct seq_file * m,void * v)7040 int proc_get_tx_ul_mu_disable(struct seq_file *m, void *v)
7041 {
7042 struct net_device *dev = m->private;
7043 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
7044 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
7045 struct rtw_he_actrl_om *cur_om_info = &(pmlmepriv->hepriv.om_info);
7046
7047 RTW_PRINT_SEL(m, "OM ul_mu_disable = %s\n", cur_om_info->om_actrl_ele.ul_mu_disable ? "True" : "False");
7048 return 0;
7049 }
7050
proc_set_tx_ul_mu_disable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)7051 ssize_t proc_set_tx_ul_mu_disable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
7052 {
7053 struct net_device *dev = data;
7054 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
7055 struct rtw_he_actrl_om om_info;
7056 u8 om_mask = 0;
7057 char tmp[32];
7058 u8 ul_mu_disable;
7059
7060 if (count < 1)
7061 return -EFAULT;
7062
7063 if (count > sizeof(tmp)) {
7064 rtw_warn_on(1);
7065 return -EFAULT;
7066 }
7067
7068 if (buffer && !copy_from_user(tmp, buffer, count)) {
7069
7070 int num = sscanf(tmp, "%hhu ", &ul_mu_disable);
7071
7072 if (num == 1) {
7073 om_mask = om_mask | OM_UL_MU_DIS;
7074 /*om_info.actrl_om_normal_tx = _TRUE;*/
7075 /*om_info.actrl_om_normal_tx_cnt = 8;*/
7076 if (ul_mu_disable == _TRUE)
7077 om_info.om_actrl_ele.ul_mu_disable = _TRUE;
7078 else
7079 om_info.om_actrl_ele.ul_mu_disable = _FALSE;
7080
7081 #if 0
7082 /*om others control setting*/
7083 om_mask = om_mask | OM_RX_NSS;
7084 om_info.om_actrl_ele.rx_nss = 1;
7085 om_mask = om_mask | OM_CH_BW;
7086 om_info.om_actrl_ele.channel_width= 2;
7087 om_mask = om_mask | OM_TX_NSTS;
7088 om_info.om_actrl_ele.tx_nsts= 2;
7089 om_mask = om_mask | OM_ER_SU_DIS;
7090 om_info.om_actrl_ele.er_su_disable = _TRUE;
7091 om_mask = om_mask | OM_DL_MU_RR;
7092 om_info.om_actrl_ele.dl_mu_mimo_rr= _TRUE;
7093 om_mask = om_mask | OM_UL_MU_DATA_DIS;
7094 om_info.om_actrl_ele.ul_mu_data_disable= _TRUE;
7095 #endif
7096 rtw_he_set_om_info(padapter, om_mask, &om_info);
7097 issue_qos_nulldata(padapter, NULL, 0, 0, 3, 10, _TRUE);
7098 }
7099 }
7100
7101 return count;
7102 }
7103 #endif
7104
7105 #endif /* CONFIG_PROC_DEBUG */
7106 #define RTW_BUFDUMP_BSIZE 16
7107 #if 1
RTW_BUF_DUMP_SEL(uint _loglevel,void * sel,u8 * _titlestring,bool _idx_show,const u8 * _hexdata,int _hexdatalen)7108 inline void RTW_BUF_DUMP_SEL(uint _loglevel, void *sel, u8 *_titlestring,
7109 bool _idx_show, const u8 *_hexdata, int _hexdatalen)
7110 {
7111 #ifdef CONFIG_RTW_DEBUG
7112 int __i;
7113 u8 *ptr = (u8 *)_hexdata;
7114
7115 if (_loglevel <= rtw_drv_log_level) {
7116 if (_titlestring) {
7117 if (sel == RTW_DBGDUMP)
7118 RTW_PRINT("");
7119 _RTW_PRINT_SEL(sel, "%s", _titlestring);
7120 if (_hexdatalen >= RTW_BUFDUMP_BSIZE)
7121 _RTW_PRINT_SEL(sel, "\n");
7122 }
7123
7124 for (__i = 0; __i < _hexdatalen; __i++) {
7125 if (((__i % RTW_BUFDUMP_BSIZE) == 0) && (_hexdatalen >= RTW_BUFDUMP_BSIZE)) {
7126 if (sel == RTW_DBGDUMP)
7127 RTW_PRINT("");
7128 if (_idx_show)
7129 _RTW_PRINT_SEL(sel, "0x%03X: ", __i);
7130 }
7131 _RTW_PRINT_SEL(sel, "%02X%s", ptr[__i], (((__i + 1) % 4) == 0) ? " " : " ");
7132 if ((__i + 1 < _hexdatalen) && ((__i + 1) % RTW_BUFDUMP_BSIZE) == 0)
7133 _RTW_PRINT_SEL(sel, "\n");
7134 }
7135 _RTW_PRINT_SEL(sel, "\n");
7136 }
7137 #endif
7138 }
7139
RTW_BUF_DUMP_SEL_ALWAYS(void * sel,u8 * _titlestring,bool _idx_show,const u8 * _hexdata,int _hexdatalen)7140 inline void RTW_BUF_DUMP_SEL_ALWAYS(void *sel, u8 *_titlestring,
7141 bool _idx_show, const u8 *_hexdata, int _hexdatalen)
7142 {
7143 int __i;
7144 u8 *ptr = (u8 *)_hexdata;
7145
7146 if (_titlestring) {
7147 if (sel == RTW_DBGDUMP)
7148 RTW_PRINT("");
7149 _RTW_PRINT_SEL(sel, "%s", _titlestring);
7150 if (_hexdatalen >= RTW_BUFDUMP_BSIZE)
7151 _RTW_PRINT_SEL(sel, "\n");
7152 }
7153
7154 for (__i = 0; __i < _hexdatalen; __i++) {
7155 if (((__i % RTW_BUFDUMP_BSIZE) == 0) && (_hexdatalen >= RTW_BUFDUMP_BSIZE)) {
7156 if (sel == RTW_DBGDUMP)
7157 RTW_PRINT("");
7158 if (_idx_show)
7159 _RTW_PRINT_SEL(sel, "0x%03X: ", __i);
7160 }
7161 _RTW_PRINT_SEL(sel, "%02X%s", ptr[__i], (((__i + 1) % 4) == 0) ? " " : " ");
7162 if ((__i + 1 < _hexdatalen) && ((__i + 1) % RTW_BUFDUMP_BSIZE) == 0)
7163 _RTW_PRINT_SEL(sel, "\n");
7164 }
7165 _RTW_PRINT_SEL(sel, "\n");
7166 }
7167 #else
_RTW_STR_DUMP_SEL(void * sel,char * str_out)7168 inline void _RTW_STR_DUMP_SEL(void *sel, char *str_out)
7169 {
7170 if (sel == RTW_DBGDUMP)
7171 _dbgdump("%s\n", str_out);
7172 #if defined(_seqdump)
7173 else
7174 _seqdump(sel, "%s\n", str_out);
7175 #endif /*_seqdump*/
7176 }
RTW_BUF_DUMP_SEL(uint _loglevel,void * sel,u8 * _titlestring,bool _idx_show,u8 * _hexdata,int _hexdatalen)7177 inline void RTW_BUF_DUMP_SEL(uint _loglevel, void *sel, u8 *_titlestring,
7178 bool _idx_show, u8 *_hexdata, int _hexdatalen)
7179 {
7180 int __i, len;
7181 int __j, idx;
7182 int block_num, remain_byte;
7183 char str_out[128] = {'\0'};
7184 char str_val[32] = {'\0'};
7185 char *p = NULL;
7186 u8 *ptr = (u8 *)_hexdata;
7187
7188 if (_loglevel <= rtw_drv_log_level) {
7189 /*dump title*/
7190 p = &str_out[0];
7191 if (_titlestring) {
7192 if (sel == RTW_DBGDUMP) {
7193 len = snprintf(str_val, sizeof(str_val), "%s", DRIVER_PREFIX);
7194 strncpy(p, str_val, len);
7195 p += len;
7196 }
7197 len = snprintf(str_val, sizeof(str_val), "%s", _titlestring);
7198 strncpy(p, str_val, len);
7199 p += len;
7200 }
7201 if (p != &str_out[0]) {
7202 _RTW_STR_DUMP_SEL(sel, str_out);
7203 _rtw_memset(&str_out, '\0', sizeof(str_out));
7204 }
7205
7206 /*dump buffer*/
7207 block_num = _hexdatalen / RTW_BUFDUMP_BSIZE;
7208 remain_byte = _hexdatalen % RTW_BUFDUMP_BSIZE;
7209 for (__i = 0; __i < block_num; __i++) {
7210 p = &str_out[0];
7211 if (sel == RTW_DBGDUMP) {
7212 len = snprintf(str_val, sizeof(str_val), "%s", DRIVER_PREFIX);
7213 strncpy(p, str_val, len);
7214 p += len;
7215 }
7216 if (_idx_show) {
7217 len = snprintf(str_val, sizeof(str_val), "0x%03X: ", __i * RTW_BUFDUMP_BSIZE);
7218 strncpy(p, str_val, len);
7219 p += len;
7220 }
7221 for (__j =0; __j < RTW_BUFDUMP_BSIZE; __j++) {
7222 idx = __i * RTW_BUFDUMP_BSIZE + __j;
7223 len = snprintf(str_val, sizeof(str_val), "%02X%s", ptr[idx], (((__j + 1) % 4) == 0) ? " " : " ");
7224 strncpy(p, str_val, len);
7225 p += len;
7226 }
7227 _RTW_STR_DUMP_SEL(sel, str_out);
7228 _rtw_memset(&str_out, '\0', sizeof(str_out));
7229 }
7230
7231 p = &str_out[0];
7232 if ((sel == RTW_DBGDUMP) && remain_byte) {
7233 len = snprintf(str_val, sizeof(str_val), "%s", DRIVER_PREFIX);
7234 strncpy(p, str_val, len);
7235 p += len;
7236 }
7237 if (_idx_show && remain_byte) {
7238 len = snprintf(str_val, sizeof(str_val), "0x%03X: ", block_num * RTW_BUFDUMP_BSIZE);
7239 strncpy(p, str_val, len);
7240 p += len;
7241 }
7242 for (__i = 0; __i < remain_byte; __i++) {
7243 idx = block_num * RTW_BUFDUMP_BSIZE + __i;
7244 len = snprintf(str_val, sizeof(str_val), "%02X%s", ptr[idx], (((__i + 1) % 4) == 0) ? " " : " ");
7245 strncpy(p, str_val, len);
7246 p += len;
7247 }
7248 _RTW_STR_DUMP_SEL(sel, str_out);
7249 }
7250 }
7251
7252 #endif
7253