1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2017 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_data.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 RTW_PRINT_SEL(sel, "Driver Version: %s\n", DRIVERVERSION);
57 RTW_PRINT_SEL(sel, "------------------------------------------------\n");
58 #ifdef CONFIG_IOCTL_CFG80211
59 RTW_PRINT_SEL(sel, "CFG80211\n");
60 #ifdef RTW_USE_CFG80211_STA_EVENT
61 RTW_PRINT_SEL(sel, "RTW_USE_CFG80211_STA_EVENT\n");
62 #endif
63 #ifdef CONFIG_RADIO_WORK
64 RTW_PRINT_SEL(sel, "CONFIG_RADIO_WORK\n");
65 #endif
66 #else
67 RTW_PRINT_SEL(sel, "WEXT\n");
68 #endif
69
70 RTW_PRINT_SEL(sel, "DBG:%d\n", DBG);
71 #ifdef CONFIG_RTW_DEBUG
72 RTW_PRINT_SEL(sel, "CONFIG_RTW_DEBUG\n");
73 #endif
74
75 #ifdef CONFIG_CONCURRENT_MODE
76 RTW_PRINT_SEL(sel, "CONFIG_CONCURRENT_MODE\n");
77 #endif
78
79 #ifdef CONFIG_POWER_SAVING
80 RTW_PRINT_SEL(sel, "CONFIG_POWER_SAVING\n");
81 #endif
82
83 #ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
84 RTW_PRINT_SEL(sel, "LOAD_PHY_PARA_FROM_FILE - REALTEK_CONFIG_PATH=%s\n", REALTEK_CONFIG_PATH);
85 #if defined(CONFIG_MULTIDRV) || defined(REALTEK_CONFIG_PATH_WITH_IC_NAME_FOLDER)
86 RTW_PRINT_SEL(sel, "LOAD_PHY_PARA_FROM_FILE - REALTEK_CONFIG_PATH_WITH_IC_NAME_FOLDER\n");
87 #endif
88
89 /* configurations about TX power */
90 #ifdef CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY
91 RTW_PRINT_SEL(sel, "CONFIG_CALIBRATE_TX_POWER_BY_REGULATORY\n");
92 #endif
93 #ifdef CONFIG_CALIBRATE_TX_POWER_TO_MAX
94 RTW_PRINT_SEL(sel, "CONFIG_CALIBRATE_TX_POWER_TO_MAX\n");
95 #endif
96 #endif
97 RTW_PRINT_SEL(sel, "RTW_DEF_MODULE_REGULATORY_CERT=0x%02x\n", RTW_DEF_MODULE_REGULATORY_CERT);
98
99 RTW_PRINT_SEL(sel, "CONFIG_TXPWR_BY_RATE_EN=%d\n", CONFIG_TXPWR_BY_RATE_EN);
100 RTW_PRINT_SEL(sel, "CONFIG_TXPWR_LIMIT_EN=%d\n", CONFIG_TXPWR_LIMIT_EN);
101
102
103 #ifdef CONFIG_DISABLE_ODM
104 RTW_PRINT_SEL(sel, "CONFIG_DISABLE_ODM\n");
105 #endif
106
107 #ifdef CONFIG_MINIMAL_MEMORY_USAGE
108 RTW_PRINT_SEL(sel, "CONFIG_MINIMAL_MEMORY_USAGE\n");
109 #endif
110
111 RTW_PRINT_SEL(sel, "CONFIG_RTW_ADAPTIVITY_EN = %d\n", CONFIG_RTW_ADAPTIVITY_EN);
112 #if (CONFIG_RTW_ADAPTIVITY_EN)
113 RTW_PRINT_SEL(sel, "ADAPTIVITY_MODE = %s\n", (CONFIG_RTW_ADAPTIVITY_MODE) ? "carrier_sense" : "normal");
114 #endif
115
116 #ifdef CONFIG_WOWLAN
117 RTW_PRINT_SEL(sel, "CONFIG_WOWLAN - ");
118
119 #ifdef CONFIG_GPIO_WAKEUP
120 RTW_PRINT_SEL(sel, "CONFIG_GPIO_WAKEUP - WAKEUP_GPIO_IDX:%d\n", WAKEUP_GPIO_IDX);
121 #endif
122 #endif
123
124 #ifdef CONFIG_TDLS
125 RTW_PRINT_SEL(sel, "CONFIG_TDLS\n");
126 #endif
127
128 #ifdef CONFIG_RTW_80211R
129 RTW_PRINT_SEL(sel, "CONFIG_RTW_80211R\n");
130 #endif
131
132 #ifdef CONFIG_RTW_WIFI_HAL
133 RTW_PRINT_SEL(sel, "CONFIG_RTW_WIFI_HAL\n");
134 #endif
135
136 #ifdef CONFIG_USB_HCI
137 #ifdef CONFIG_SUPPORT_USB_INT
138 RTW_PRINT_SEL(sel, "CONFIG_SUPPORT_USB_INT\n");
139 #endif
140 #ifdef CONFIG_USB_INTERRUPT_IN_PIPE
141 RTW_PRINT_SEL(sel, "CONFIG_USB_INTERRUPT_IN_PIPE\n");
142 #endif
143 #ifdef CONFIG_USB_TX_AGGREGATION
144 RTW_PRINT_SEL(sel, "CONFIG_USB_TX_AGGREGATION\n");
145 #endif
146 #ifdef CONFIG_USB_RX_AGGREGATION
147 RTW_PRINT_SEL(sel, "CONFIG_USB_RX_AGGREGATION\n");
148 #endif
149 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX
150 RTW_PRINT_SEL(sel, "CONFIG_USE_USB_BUFFER_ALLOC_TX\n");
151 #endif
152 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
153 RTW_PRINT_SEL(sel, "CONFIG_USE_USB_BUFFER_ALLOC_RX\n");
154 #endif
155 #ifdef CONFIG_PREALLOC_RECV_SKB
156 RTW_PRINT_SEL(sel, "CONFIG_PREALLOC_RECV_SKB\n");
157 #endif
158 #ifdef CONFIG_FIX_NR_BULKIN_BUFFER
159 RTW_PRINT_SEL(sel, "CONFIG_FIX_NR_BULKIN_BUFFER\n");
160 #endif
161 #endif /*CONFIG_USB_HCI*/
162
163 #ifdef CONFIG_SDIO_HCI
164 #ifdef CONFIG_TX_AGGREGATION
165 RTW_PRINT_SEL(sel, "CONFIG_TX_AGGREGATION\n");
166 #endif
167 #ifdef CONFIG_RX_AGGREGATION
168 RTW_PRINT_SEL(sel, "CONFIG_RX_AGGREGATION\n");
169 #endif
170 #endif /*CONFIG_SDIO_HCI*/
171
172 #ifdef CONFIG_PCI_HCI
173 #endif
174
175 RTW_PRINT_SEL(sel, "\n=== XMIT-INFO ===\n");
176 RTW_PRINT_SEL(sel, "NR_XMITFRAME = %d\n", NR_XMITFRAME);
177 RTW_PRINT_SEL(sel, "NR_XMITBUFF = %d\n", NR_XMITBUFF);
178 RTW_PRINT_SEL(sel, "MAX_XMITBUF_SZ = %d\n", MAX_XMITBUF_SZ);
179 RTW_PRINT_SEL(sel, "NR_XMIT_EXTBUFF = %d\n", NR_XMIT_EXTBUFF);
180 RTW_PRINT_SEL(sel, "MAX_XMIT_EXTBUF_SZ = %d\n", MAX_XMIT_EXTBUF_SZ);
181 RTW_PRINT_SEL(sel, "MAX_CMDBUF_SZ = %d\n", MAX_CMDBUF_SZ);
182
183 RTW_PRINT_SEL(sel, "\n=== RECV-INFO ===\n");
184 RTW_PRINT_SEL(sel, "NR_RECVFRAME = %d\n", NR_RECVFRAME);
185 RTW_PRINT_SEL(sel, "NR_RECVBUFF = %d\n", NR_RECVBUFF);
186 RTW_PRINT_SEL(sel, "MAX_RECVBUF_SZ = %d\n", MAX_RECVBUF_SZ);
187
188 }
189
dump_log_level(void * sel)190 void dump_log_level(void *sel)
191 {
192 #ifdef CONFIG_RTW_DEBUG
193 int i;
194
195 RTW_PRINT_SEL(sel, "drv_log_level:%d\n", rtw_drv_log_level);
196 for (i = 0; i <= _DRV_MAX_; i++) {
197 if (rtw_log_level_str[i])
198 RTW_PRINT_SEL(sel, "%c %s = %d\n",
199 (rtw_drv_log_level == i) ? '+' : ' ', rtw_log_level_str[i], i);
200 }
201 #else
202 RTW_PRINT_SEL(sel, "CONFIG_RTW_DEBUG is disabled\n");
203 #endif
204 }
205
206 #ifdef CONFIG_SDIO_HCI
sd_f0_reg_dump(void * sel,_adapter * adapter)207 void sd_f0_reg_dump(void *sel, _adapter *adapter)
208 {
209 int i;
210
211 for (i = 0x0; i <= 0xff; i++) {
212 if (i % 16 == 0)
213 RTW_PRINT_SEL(sel, "0x%02x ", i);
214
215 _RTW_PRINT_SEL(sel, "%02x ", rtw_sd_f0_read8(adapter, i));
216
217 if (i % 16 == 15)
218 _RTW_PRINT_SEL(sel, "\n");
219 else if (i % 8 == 7)
220 _RTW_PRINT_SEL(sel, "\t");
221 }
222 }
223
sdio_local_reg_dump(void * sel,_adapter * adapter)224 void sdio_local_reg_dump(void *sel, _adapter *adapter)
225 {
226 int i, j = 1;
227
228 for (i = 0x0; i < 0x100; i += 4) {
229 if (j % 4 == 1)
230 RTW_PRINT_SEL(sel, "0x%02x", i);
231 _RTW_PRINT_SEL(sel, " 0x%08x ", rtw_read32(adapter, (0x1025 << 16) | i));
232 if ((j++) % 4 == 0)
233 _RTW_PRINT_SEL(sel, "\n");
234 }
235 }
236 #endif /* CONFIG_SDIO_HCI */
237
mac_reg_dump(void * sel,_adapter * adapter)238 void mac_reg_dump(void *sel, _adapter *adapter)
239 {
240 int i, j = 1;
241
242 RTW_PRINT_SEL(sel, "======= MAC REG =======\n");
243
244 for (i = 0x0; i < 0x800; i += 4) {
245 if (j % 4 == 1)
246 RTW_PRINT_SEL(sel, "0x%04x", i);
247 _RTW_PRINT_SEL(sel, " 0x%08x ", rtw_read32(adapter, i));
248 if ((j++) % 4 == 0)
249 _RTW_PRINT_SEL(sel, "\n");
250 }
251
252 #ifdef CONFIG_RTL8814A
253 {
254 for (i = 0x1000; i < 0x1650; i += 4) {
255 if (j % 4 == 1)
256 RTW_PRINT_SEL(sel, "0x%04x", i);
257 _RTW_PRINT_SEL(sel, " 0x%08x ", rtw_read32(adapter, i));
258 if ((j++) % 4 == 0)
259 _RTW_PRINT_SEL(sel, "\n");
260 }
261 }
262 #endif /* CONFIG_RTL8814A */
263
264
265 #if defined(CONFIG_RTL8822B) || defined(CONFIG_RTL8821C)
266 for (i = 0x1000; i < 0x1800; i += 4) {
267 if (j % 4 == 1)
268 RTW_PRINT_SEL(sel, "0x%04x", i);
269 _RTW_PRINT_SEL(sel, " 0x%08x ", rtw_read32(adapter, i));
270 if ((j++) % 4 == 0)
271 _RTW_PRINT_SEL(sel, "\n");
272 }
273 #endif /* CONFIG_RTL8822B */
274 }
275
bb_reg_dump(void * sel,_adapter * adapter)276 void bb_reg_dump(void *sel, _adapter *adapter)
277 {
278 int i, j = 1;
279
280 RTW_PRINT_SEL(sel, "======= BB REG =======\n");
281 for (i = 0x800; i < 0x1000; i += 4) {
282 if (j % 4 == 1)
283 RTW_PRINT_SEL(sel, "0x%04x", i);
284 _RTW_PRINT_SEL(sel, " 0x%08x ", rtw_read32(adapter, i));
285 if ((j++) % 4 == 0)
286 _RTW_PRINT_SEL(sel, "\n");
287 }
288
289 #if defined(CONFIG_RTL8822B) || defined(CONFIG_RTL8821C)
290 for (i = 0x1800; i < 0x2000; i += 4) {
291 if (j % 4 == 1)
292 RTW_PRINT_SEL(sel, "0x%04x", i);
293 _RTW_PRINT_SEL(sel, " 0x%08x ", rtw_read32(adapter, i));
294 if ((j++) % 4 == 0)
295 _RTW_PRINT_SEL(sel, "\n");
296 }
297 #endif /* CONFIG_RTL8822B */
298 }
299
bb_reg_dump_ex(void * sel,_adapter * adapter)300 void bb_reg_dump_ex(void *sel, _adapter *adapter)
301 {
302 int i, j = 1;
303
304 RTW_PRINT_SEL(sel, "======= BB REG =======\n");
305 for (i = 0x800; i < 0x1000; i += 4) {
306 RTW_PRINT_SEL(sel, "0x%04x", i);
307 _RTW_PRINT_SEL(sel, " 0x%08x ", rtw_read32(adapter, i));
308 _RTW_PRINT_SEL(sel, "\n");
309 }
310
311 #if defined(CONFIG_RTL8822B) || defined(CONFIG_RTL8821C)
312 for (i = 0x1800; i < 0x2000; i += 4) {
313 RTW_PRINT_SEL(sel, "0x%04x", i);
314 _RTW_PRINT_SEL(sel, " 0x%08x ", rtw_read32(adapter, i));
315 _RTW_PRINT_SEL(sel, "\n");
316 }
317 #endif /* CONFIG_RTL8822B */
318 }
319
rf_reg_dump(void * sel,_adapter * adapter)320 void rf_reg_dump(void *sel, _adapter *adapter)
321 {
322 int i, j = 1, path;
323 u32 value;
324 u8 rf_type = 0;
325 u8 path_nums = 0;
326
327 rtw_hal_get_hwreg(adapter, HW_VAR_RF_TYPE, (u8 *)(&rf_type));
328 if ((RF_1T2R == rf_type) || (RF_1T1R == rf_type))
329 path_nums = 1;
330 else
331 path_nums = 2;
332
333 RTW_PRINT_SEL(sel, "======= RF REG =======\n");
334
335 for (path = 0; path < path_nums; path++) {
336 RTW_PRINT_SEL(sel, "RF_Path(%x)\n", path);
337 for (i = 0; i < 0x100; i++) {
338 value = rtw_hal_read_rfreg(adapter, path, i, 0xffffffff);
339 if (j % 4 == 1)
340 RTW_PRINT_SEL(sel, "0x%02x ", i);
341 _RTW_PRINT_SEL(sel, " 0x%08x ", value);
342 if ((j++) % 4 == 0)
343 _RTW_PRINT_SEL(sel, "\n");
344 }
345 }
346 }
347
rtw_sink_rtp_seq_dbg(_adapter * adapter,_pkt * pkt)348 void rtw_sink_rtp_seq_dbg(_adapter *adapter, _pkt *pkt)
349 {
350 struct recv_priv *precvpriv = &(adapter->recvpriv);
351 if (precvpriv->sink_udpport > 0) {
352 if (*((u16 *)((pkt->data) + 0x24)) == cpu_to_be16(precvpriv->sink_udpport)) {
353 precvpriv->pre_rtp_rxseq = precvpriv->cur_rtp_rxseq;
354 precvpriv->cur_rtp_rxseq = be16_to_cpu(*((u16 *)((pkt->data) + 0x2C)));
355 if (precvpriv->pre_rtp_rxseq + 1 != precvpriv->cur_rtp_rxseq)
356 RTW_INFO("%s : RTP Seq num from %d to %d\n", __FUNCTION__, precvpriv->pre_rtp_rxseq, precvpriv->cur_rtp_rxseq);
357 }
358 }
359 }
360
sta_rx_reorder_ctl_dump(void * sel,struct sta_info * sta)361 void sta_rx_reorder_ctl_dump(void *sel, struct sta_info *sta)
362 {
363 struct recv_reorder_ctrl *reorder_ctl;
364 int i;
365
366 for (i = 0; i < 16; i++) {
367 reorder_ctl = &sta->recvreorder_ctrl[i];
368 if (reorder_ctl->ampdu_size != RX_AMPDU_SIZE_INVALID || reorder_ctl->indicate_seq != 0xFFFF) {
369 RTW_PRINT_SEL(sel, "tid=%d, enable=%d, ampdu_size=%u, indicate_seq=%u\n"
370 , i, reorder_ctl->enable, reorder_ctl->ampdu_size, reorder_ctl->indicate_seq
371 );
372 }
373 }
374 }
375
dump_tx_rate_bmp(void * sel,struct dvobj_priv * dvobj)376 void dump_tx_rate_bmp(void *sel, struct dvobj_priv *dvobj)
377 {
378 _adapter *adapter = dvobj_get_primary_adapter(dvobj);
379 struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
380 u8 bw;
381
382 RTW_PRINT_SEL(sel, "%-6s", "bw");
383 if (hal_chk_proto_cap(adapter, PROTO_CAP_11AC))
384 _RTW_PRINT_SEL(sel, " %-11s", "vht");
385
386 _RTW_PRINT_SEL(sel, " %-11s %-4s %-3s\n", "ht", "ofdm", "cck");
387
388 for (bw = CHANNEL_WIDTH_20; bw <= CHANNEL_WIDTH_160; bw++) {
389 if (!hal_is_bw_support(adapter, bw))
390 continue;
391
392 RTW_PRINT_SEL(sel, "%6s", ch_width_str(bw));
393 if (hal_chk_proto_cap(adapter, PROTO_CAP_11AC)) {
394 _RTW_PRINT_SEL(sel, " %03x %03x %03x"
395 , RATE_BMP_GET_VHT_3SS(rfctl->rate_bmp_vht_by_bw[bw])
396 , RATE_BMP_GET_VHT_2SS(rfctl->rate_bmp_vht_by_bw[bw])
397 , RATE_BMP_GET_VHT_1SS(rfctl->rate_bmp_vht_by_bw[bw])
398 );
399 }
400
401 _RTW_PRINT_SEL(sel, " %02x %02x %02x %02x"
402 , bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_4SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
403 , bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_3SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
404 , bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_2SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
405 , bw <= CHANNEL_WIDTH_40 ? RATE_BMP_GET_HT_1SS(rfctl->rate_bmp_ht_by_bw[bw]) : 0
406 );
407
408 _RTW_PRINT_SEL(sel, " %03x %01x\n"
409 , bw <= CHANNEL_WIDTH_20 ? RATE_BMP_GET_OFDM(rfctl->rate_bmp_cck_ofdm) : 0
410 , bw <= CHANNEL_WIDTH_20 ? RATE_BMP_GET_CCK(rfctl->rate_bmp_cck_ofdm) : 0
411 );
412 }
413 }
414
dump_adapters_status(void * sel,struct dvobj_priv * dvobj)415 void dump_adapters_status(void *sel, struct dvobj_priv *dvobj)
416 {
417 struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
418 int i;
419 _adapter *iface;
420 u8 u_ch, u_bw, u_offset;
421
422 dump_mi_status(sel, dvobj);
423
424 #ifdef CONFIG_FW_MULTI_PORT_SUPPORT
425 RTW_PRINT_SEL(sel, "default port id:%d\n\n", dvobj->default_port_id);
426 #endif /* CONFIG_FW_MULTI_PORT_SUPPORT */
427
428 RTW_PRINT_SEL(sel, "dev status:%s%s\n\n"
429 , dev_is_surprise_removed(dvobj) ? " SR" : ""
430 , dev_is_drv_stopped(dvobj) ? " DS" : ""
431 );
432
433 #ifdef CONFIG_P2P
434 #define P2P_INFO_TITLE_FMT " %-3s %-4s"
435 #define P2P_INFO_TITLE_ARG , "lch", "p2ps"
436 #ifdef CONFIG_IOCTL_CFG80211
437 #define P2P_INFO_VALUE_FMT " %3u %c%3u"
438 #define P2P_INFO_VALUE_ARG , iface->wdinfo.listen_channel, iface->wdev_data.p2p_enabled ? 'e' : ' ', rtw_p2p_state(&iface->wdinfo)
439 #else
440 #define P2P_INFO_VALUE_FMT " %3u %4u"
441 #define P2P_INFO_VALUE_ARG , iface->wdinfo.listen_channel, rtw_p2p_state(&iface->wdinfo)
442 #endif
443 #define P2P_INFO_DASH "---------"
444 #else
445 #define P2P_INFO_TITLE_FMT ""
446 #define P2P_INFO_TITLE_ARG
447 #define P2P_INFO_VALUE_FMT ""
448 #define P2P_INFO_VALUE_ARG
449 #define P2P_INFO_DASH
450 #endif
451
452 RTW_PRINT_SEL(sel, "%-2s %-15s %c %-3s %-3s %-3s %-17s %-4s %-7s"
453 P2P_INFO_TITLE_FMT
454 " %s\n"
455 , "id", "ifname", ' ', "bup", "nup", "ncd", "macaddr", "port", "ch"
456 P2P_INFO_TITLE_ARG
457 , "status");
458
459 RTW_PRINT_SEL(sel, "---------------------------------------------------------------"
460 P2P_INFO_DASH
461 "-------\n");
462
463 for (i = 0; i < dvobj->iface_nums; i++) {
464 iface = dvobj->padapters[i];
465 if (iface) {
466 RTW_PRINT_SEL(sel, "%2d %-15s %c %3u %3u %3u "MAC_FMT" %4hhu %3u,%u,%u"
467 P2P_INFO_VALUE_FMT
468 " "MLME_STATE_FMT"\n"
469 , i, iface->registered ? ADPT_ARG(iface) : NULL
470 , iface->registered ? 'R' : ' '
471 , iface->bup
472 , iface->netif_up
473 , iface->net_closed
474 , MAC_ARG(adapter_mac_addr(iface))
475 , get_hw_port(iface)
476 , iface->mlmeextpriv.cur_channel
477 , iface->mlmeextpriv.cur_bwmode
478 , iface->mlmeextpriv.cur_ch_offset
479 P2P_INFO_VALUE_ARG
480 , MLME_STATE_ARG(iface)
481 );
482 }
483 }
484
485 RTW_PRINT_SEL(sel, "---------------------------------------------------------------"
486 P2P_INFO_DASH
487 "-------\n");
488
489 rtw_mi_get_ch_setting_union(dvobj_get_primary_adapter(dvobj), &u_ch, &u_bw, &u_offset);
490 RTW_PRINT_SEL(sel, "%55s %3u,%u,%u\n"
491 , "union:"
492 , u_ch, u_bw, u_offset
493 );
494
495 RTW_PRINT_SEL(sel, "%55s %3u,%u,%u\n"
496 , "oper:"
497 , dvobj->oper_channel
498 , dvobj->oper_bwmode
499 , dvobj->oper_ch_offset
500 );
501
502 #ifdef CONFIG_DFS_MASTER
503 if (rfctl->radar_detect_ch != 0) {
504 RTW_PRINT_SEL(sel, "%55s %3u,%u,%u"
505 , "radar_detect:"
506 , rfctl->radar_detect_ch
507 , rfctl->radar_detect_bw
508 , rfctl->radar_detect_offset
509 );
510
511 if (rfctl->radar_detect_by_others)
512 _RTW_PRINT_SEL(sel, ", by AP of STA link");
513 else {
514 u32 non_ocp_ms;
515 u32 cac_ms;
516 u8 dfs_domain = rtw_odm_get_dfs_domain(dvobj_get_primary_adapter(dvobj));
517
518 _RTW_PRINT_SEL(sel, ", domain:%u", dfs_domain);
519
520 for (i = 0; i < dvobj->iface_nums; i++) {
521 if (!dvobj->padapters[i])
522 continue;
523 if (check_fwstate(&dvobj->padapters[i]->mlmepriv, WIFI_AP_STATE | WIFI_MESH_STATE)
524 && check_fwstate(&dvobj->padapters[i]->mlmepriv, WIFI_ASOC_STATE))
525 break;
526 }
527
528 if (i >= dvobj->iface_nums) {
529 RTW_PRINT_SEL(sel, "DFS master enable without AP/Mesh mode???");
530 goto end_dfs_master;
531 }
532
533 rtw_get_ch_waiting_ms(dvobj->padapters[i]
534 , rfctl->radar_detect_ch
535 , rfctl->radar_detect_bw
536 , rfctl->radar_detect_offset
537 , &non_ocp_ms
538 , &cac_ms
539 );
540
541 if (non_ocp_ms)
542 _RTW_PRINT_SEL(sel, ", non_ocp:%d", non_ocp_ms);
543 if (cac_ms)
544 _RTW_PRINT_SEL(sel, ", cac:%d", cac_ms);
545 }
546
547 end_dfs_master:
548 _RTW_PRINT_SEL(sel, "\n");
549 }
550 #endif /* CONFIG_DFS_MASTER */
551 }
552
553 #define SEC_CAM_ENT_ID_TITLE_FMT "%-2s"
554 #define SEC_CAM_ENT_ID_TITLE_ARG "id"
555 #define SEC_CAM_ENT_ID_VALUE_FMT "%2u"
556 #define SEC_CAM_ENT_ID_VALUE_ARG(id) (id)
557
558 #define SEC_CAM_ENT_TITLE_FMT "%-6s %-17s %-32s %-3s %-7s %-2s %-2s %-5s"
559 #define SEC_CAM_ENT_TITLE_ARG "ctrl", "addr", "key", "kid", "type", "MK", "GK", "valid"
560 #define SEC_CAM_ENT_VALUE_FMT "0x%04x "MAC_FMT" "KEY_FMT" %3u %-7s %2u %2u %5u"
561 #define SEC_CAM_ENT_VALUE_ARG(ent) \
562 (ent)->ctrl \
563 , MAC_ARG((ent)->mac) \
564 , KEY_ARG((ent)->key) \
565 , ((ent)->ctrl) & 0x03 \
566 , security_type_str((((ent)->ctrl) >> 2) & 0x07) \
567 , (((ent)->ctrl) >> 5) & 0x01 \
568 , (((ent)->ctrl) >> 6) & 0x01 \
569 , (((ent)->ctrl) >> 15) & 0x01
570
dump_sec_cam_ent(void * sel,struct sec_cam_ent * ent,int id)571 void dump_sec_cam_ent(void *sel, struct sec_cam_ent *ent, int id)
572 {
573 if (id >= 0) {
574 RTW_PRINT_SEL(sel, SEC_CAM_ENT_ID_VALUE_FMT " " SEC_CAM_ENT_VALUE_FMT"\n"
575 , SEC_CAM_ENT_ID_VALUE_ARG(id), SEC_CAM_ENT_VALUE_ARG(ent));
576 } else
577 RTW_PRINT_SEL(sel, SEC_CAM_ENT_VALUE_FMT"\n", SEC_CAM_ENT_VALUE_ARG(ent));
578 }
579
dump_sec_cam_ent_title(void * sel,u8 has_id)580 void dump_sec_cam_ent_title(void *sel, u8 has_id)
581 {
582 if (has_id) {
583 RTW_PRINT_SEL(sel, SEC_CAM_ENT_ID_TITLE_FMT " " SEC_CAM_ENT_TITLE_FMT"\n"
584 , SEC_CAM_ENT_ID_TITLE_ARG, SEC_CAM_ENT_TITLE_ARG);
585 } else
586 RTW_PRINT_SEL(sel, SEC_CAM_ENT_TITLE_FMT"\n", SEC_CAM_ENT_TITLE_ARG);
587 }
588
dump_sec_cam(void * sel,_adapter * adapter)589 void dump_sec_cam(void *sel, _adapter *adapter)
590 {
591 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
592 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
593 struct sec_cam_ent ent;
594 int i;
595
596 RTW_PRINT_SEL(sel, "HW sec cam:\n");
597 dump_sec_cam_ent_title(sel, 1);
598 for (i = 0; i < cam_ctl->num; i++) {
599 rtw_sec_read_cam_ent(adapter, i, (u8 *)(&ent.ctrl), ent.mac, ent.key);
600 dump_sec_cam_ent(sel , &ent, i);
601 }
602 }
603
dump_sec_cam_cache(void * sel,_adapter * adapter)604 void dump_sec_cam_cache(void *sel, _adapter *adapter)
605 {
606 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
607 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
608 int i;
609
610 RTW_PRINT_SEL(sel, "SW sec cam cache:\n");
611 dump_sec_cam_ent_title(sel, 1);
612 for (i = 0; i < cam_ctl->num; i++) {
613 if (dvobj->cam_cache[i].ctrl != 0)
614 dump_sec_cam_ent(sel, &dvobj->cam_cache[i], i);
615 }
616
617 }
618
619 #ifdef CONFIG_PROC_DEBUG
proc_set_write_reg(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)620 ssize_t proc_set_write_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
621 {
622 struct net_device *dev = data;
623 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
624 char tmp[32];
625 u32 addr, val, len;
626
627 if (count < 3) {
628 RTW_INFO("argument size is less than 3\n");
629 return -EFAULT;
630 }
631
632 if (count > sizeof(tmp)) {
633 rtw_warn_on(1);
634 return -EFAULT;
635 }
636
637 if (buffer && !copy_from_user(tmp, buffer, count)) {
638
639 int num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
640
641 if (num != 3) {
642 RTW_INFO("invalid write_reg parameter!\n");
643 return count;
644 }
645
646 switch (len) {
647 case 1:
648 rtw_write8(padapter, addr, (u8)val);
649 break;
650 case 2:
651 rtw_write16(padapter, addr, (u16)val);
652 break;
653 case 4:
654 rtw_write32(padapter, addr, val);
655 break;
656 default:
657 RTW_INFO("error write length=%d", len);
658 break;
659 }
660
661 }
662
663 return count;
664
665 }
666
667 static u32 proc_get_read_addr = 0xeeeeeeee;
668 static u32 proc_get_read_len = 0x4;
669
proc_get_read_reg(struct seq_file * m,void * v)670 int proc_get_read_reg(struct seq_file *m, void *v)
671 {
672 struct net_device *dev = m->private;
673 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
674
675 if (proc_get_read_addr == 0xeeeeeeee) {
676 RTW_PRINT_SEL(m, "address not initialized\n");
677 return 0;
678 }
679
680 switch (proc_get_read_len) {
681 case 1:
682 RTW_PRINT_SEL(m, "rtw_read8(0x%x)=0x%x\n", proc_get_read_addr, rtw_read8(padapter, proc_get_read_addr));
683 break;
684 case 2:
685 RTW_PRINT_SEL(m, "rtw_read16(0x%x)=0x%x\n", proc_get_read_addr, rtw_read16(padapter, proc_get_read_addr));
686 break;
687 case 4:
688 RTW_PRINT_SEL(m, "rtw_read32(0x%x)=0x%x\n", proc_get_read_addr, rtw_read32(padapter, proc_get_read_addr));
689 break;
690 default:
691 RTW_PRINT_SEL(m, "error read length=%d\n", proc_get_read_len);
692 break;
693 }
694
695 return 0;
696 }
697
proc_set_read_reg(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)698 ssize_t proc_set_read_reg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
699 {
700 struct net_device *dev = data;
701 char tmp[16];
702 u32 addr, len;
703
704 if (count < 2) {
705 RTW_INFO("argument size is less than 2\n");
706 return -EFAULT;
707 }
708
709 if (count > sizeof(tmp)) {
710 rtw_warn_on(1);
711 return -EFAULT;
712 }
713
714 if (buffer && !copy_from_user(tmp, buffer, count)) {
715
716 int num = sscanf(tmp, "%x %x", &addr, &len);
717
718 if (num != 2) {
719 RTW_INFO("invalid read_reg parameter!\n");
720 return count;
721 }
722
723 proc_get_read_addr = addr;
724
725 proc_get_read_len = len;
726 }
727
728 return count;
729
730 }
731
proc_get_rx_stat(struct seq_file * m,void * v)732 int proc_get_rx_stat(struct seq_file *m, void *v)
733 {
734 _irqL irqL;
735 _list *plist, *phead;
736 struct net_device *dev = m->private;
737 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
738 struct sta_info *psta = NULL;
739 struct stainfo_stats *pstats = NULL;
740 struct sta_priv *pstapriv = &(adapter->stapriv);
741 u32 i, j;
742 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
743 u8 null_addr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
744
745 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
746 for (i = 0; i < NUM_STA; i++) {
747 phead = &(pstapriv->sta_hash[i]);
748 plist = get_next(phead);
749 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
750 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
751 plist = get_next(plist);
752 pstats = &psta->sta_stats;
753
754 if (pstats == NULL)
755 continue;
756 if ((_rtw_memcmp(psta->cmn.mac_addr, bc_addr, 6) != _TRUE)
757 && (_rtw_memcmp(psta->cmn.mac_addr, null_addr, 6) != _TRUE)
758 && (_rtw_memcmp(psta->cmn.mac_addr, adapter_mac_addr(adapter), 6) != _TRUE)) {
759 RTW_PRINT_SEL(m, "MAC :\t\t"MAC_FMT "\n", MAC_ARG(psta->cmn.mac_addr));
760 RTW_PRINT_SEL(m, "data_rx_cnt :\t%llu\n", pstats->rx_data_pkts - pstats->rx_data_last_pkts);
761 pstats->rx_data_last_pkts = pstats->rx_data_pkts;
762 RTW_PRINT_SEL(m, "duplicate_cnt :\t%u\n", pstats->duplicate_cnt);
763 pstats->duplicate_cnt = 0;
764 RTW_PRINT_SEL(m, "rx_per_rate_cnt :\n");
765
766 for (j = 0; j < 0x60; j++) {
767 RTW_PRINT_SEL(m, "%08u ", pstats->rxratecnt[j]);
768 pstats->rxratecnt[j] = 0;
769 if ((j%8) == 7)
770 RTW_PRINT_SEL(m, "\n");
771 }
772 RTW_PRINT_SEL(m, "\n");
773 }
774 }
775 }
776 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
777 return 0;
778 }
779
proc_get_tx_stat(struct seq_file * m,void * v)780 int proc_get_tx_stat(struct seq_file *m, void *v)
781 {
782 _irqL irqL;
783 _list *plist, *phead;
784 struct net_device *dev = m->private;
785 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
786 struct sta_info *psta = NULL, *sta_rec[NUM_STA];
787 struct stainfo_stats *pstats = NULL;
788 struct sta_priv *pstapriv = &(adapter->stapriv);
789 u32 i, macid_rec_idx = 0;
790 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
791 u8 null_addr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
792 struct submit_ctx gotc2h;
793
794 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
795 for (i = 0; i < NUM_STA; i++) {
796 sta_rec[i] = NULL;
797 phead = &(pstapriv->sta_hash[i]);
798 plist = get_next(phead);
799 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
800 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
801 plist = get_next(plist);
802 if ((_rtw_memcmp(psta->cmn.mac_addr, bc_addr, 6) != _TRUE)
803 && (_rtw_memcmp(psta->cmn.mac_addr, null_addr, 6) != _TRUE)
804 && (_rtw_memcmp(psta->cmn.mac_addr, adapter_mac_addr(adapter), 6) != _TRUE)) {
805 sta_rec[macid_rec_idx++] = psta;
806 }
807 }
808 }
809 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
810 for (i = 0; i < macid_rec_idx; i++) {
811 pstats = &(sta_rec[i]->sta_stats);
812 if (pstats == NULL)
813 continue;
814 pstapriv->c2h_sta = sta_rec[i];
815 rtw_hal_reqtxrpt(adapter, sta_rec[i]->cmn.mac_id);
816 rtw_sctx_init(&gotc2h, 60);
817 pstapriv->gotc2h = &gotc2h;
818 if (rtw_sctx_wait(&gotc2h, __func__)) {
819 RTW_PRINT_SEL(m, "MAC :\t\t"MAC_FMT "\n", MAC_ARG(sta_rec[i]->cmn.mac_addr));
820 RTW_PRINT_SEL(m, "data_sent_cnt :\t%u\n", pstats->tx_ok_cnt + pstats->tx_fail_cnt);
821 RTW_PRINT_SEL(m, "success_cnt :\t%u\n", pstats->tx_ok_cnt);
822 RTW_PRINT_SEL(m, "failure_cnt :\t%u\n", pstats->tx_fail_cnt);
823 RTW_PRINT_SEL(m, "retry_cnt :\t%u\n\n", pstats->tx_retry_cnt);
824 } else {
825 RTW_PRINT_SEL(m, "Warming : Query timeout, operation abort!!\n");
826 RTW_PRINT_SEL(m, "\n");
827 pstapriv->c2h_sta = NULL;
828 break;
829 }
830 }
831 return 0;
832 }
833
proc_get_fwstate(struct seq_file * m,void * v)834 int proc_get_fwstate(struct seq_file *m, void *v)
835 {
836 struct net_device *dev = m->private;
837 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
838 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
839
840 RTW_PRINT_SEL(m, "fwstate=0x%x\n", get_fwstate(pmlmepriv));
841
842 return 0;
843 }
844
proc_get_sec_info(struct seq_file * m,void * v)845 int proc_get_sec_info(struct seq_file *m, void *v)
846 {
847 struct net_device *dev = m->private;
848 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
849 struct security_priv *sec = &padapter->securitypriv;
850
851 RTW_PRINT_SEL(m, "auth_alg=0x%x, enc_alg=0x%x, auth_type=0x%x, enc_type=0x%x\n",
852 sec->dot11AuthAlgrthm, sec->dot11PrivacyAlgrthm,
853 sec->ndisauthtype, sec->ndisencryptstatus);
854
855 RTW_PRINT_SEL(m, "hw_decrypted=%d\n", sec->hw_decrypted);
856
857 #ifdef DBG_SW_SEC_CNT
858 RTW_PRINT_SEL(m, "wep_sw_enc_cnt=%llu, %llu, %llu\n"
859 , sec->wep_sw_enc_cnt_bc , sec->wep_sw_enc_cnt_mc, sec->wep_sw_enc_cnt_uc);
860 RTW_PRINT_SEL(m, "wep_sw_dec_cnt=%llu, %llu, %llu\n"
861 , sec->wep_sw_dec_cnt_bc , sec->wep_sw_dec_cnt_mc, sec->wep_sw_dec_cnt_uc);
862
863 RTW_PRINT_SEL(m, "tkip_sw_enc_cnt=%llu, %llu, %llu\n"
864 , sec->tkip_sw_enc_cnt_bc , sec->tkip_sw_enc_cnt_mc, sec->tkip_sw_enc_cnt_uc);
865 RTW_PRINT_SEL(m, "tkip_sw_dec_cnt=%llu, %llu, %llu\n"
866 , sec->tkip_sw_dec_cnt_bc , sec->tkip_sw_dec_cnt_mc, sec->tkip_sw_dec_cnt_uc);
867
868 RTW_PRINT_SEL(m, "aes_sw_enc_cnt=%llu, %llu, %llu\n"
869 , sec->aes_sw_enc_cnt_bc , sec->aes_sw_enc_cnt_mc, sec->aes_sw_enc_cnt_uc);
870 RTW_PRINT_SEL(m, "aes_sw_dec_cnt=%llu, %llu, %llu\n"
871 , sec->aes_sw_dec_cnt_bc , sec->aes_sw_dec_cnt_mc, sec->aes_sw_dec_cnt_uc);
872 #endif /* DBG_SW_SEC_CNT */
873
874 return 0;
875 }
876
proc_get_mlmext_state(struct seq_file * m,void * v)877 int proc_get_mlmext_state(struct seq_file *m, void *v)
878 {
879 struct net_device *dev = m->private;
880 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
881 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
882 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
883
884 RTW_PRINT_SEL(m, "pmlmeinfo->state=0x%x\n", pmlmeinfo->state);
885
886 return 0;
887 }
888
889 #ifdef CONFIG_LAYER2_ROAMING
proc_get_roam_flags(struct seq_file * m,void * v)890 int proc_get_roam_flags(struct seq_file *m, void *v)
891 {
892 struct net_device *dev = m->private;
893 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
894
895 RTW_PRINT_SEL(m, "0x%02x\n", rtw_roam_flags(adapter));
896
897 return 0;
898 }
899
proc_set_roam_flags(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)900 ssize_t proc_set_roam_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
901 {
902 struct net_device *dev = data;
903 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
904
905 char tmp[32];
906 u8 flags;
907
908 if (count < 1)
909 return -EFAULT;
910
911 if (count > sizeof(tmp)) {
912 rtw_warn_on(1);
913 return -EFAULT;
914 }
915
916 if (buffer && !copy_from_user(tmp, buffer, count)) {
917
918 int num = sscanf(tmp, "%hhx", &flags);
919
920 if (num == 1)
921 rtw_assign_roam_flags(adapter, flags);
922 }
923
924 return count;
925
926 }
927
proc_get_roam_param(struct seq_file * m,void * v)928 int proc_get_roam_param(struct seq_file *m, void *v)
929 {
930 struct net_device *dev = m->private;
931 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
932 struct mlme_priv *mlme = &adapter->mlmepriv;
933
934 RTW_PRINT_SEL(m, "%12s %12s %11s %14s\n", "rssi_diff_th", "scanr_exp_ms", "scan_int_ms", "rssi_threshold");
935 RTW_PRINT_SEL(m, "%-12u %-12u %-11u %-14u\n"
936 , mlme->roam_rssi_diff_th
937 , mlme->roam_scanr_exp_ms
938 , mlme->roam_scan_int_ms
939 , mlme->roam_rssi_threshold
940 );
941
942 return 0;
943 }
944
proc_set_roam_param(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)945 ssize_t proc_set_roam_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
946 {
947 struct net_device *dev = data;
948 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
949 struct mlme_priv *mlme = &adapter->mlmepriv;
950
951 char tmp[32];
952 u8 rssi_diff_th;
953 u32 scanr_exp_ms;
954 u32 scan_int_ms;
955 u8 rssi_threshold;
956
957 if (count < 1)
958 return -EFAULT;
959
960 if (count > sizeof(tmp)) {
961 rtw_warn_on(1);
962 return -EFAULT;
963 }
964
965 if (buffer && !copy_from_user(tmp, buffer, count)) {
966
967 int num = sscanf(tmp, "%hhu %u %u %hhu", &rssi_diff_th, &scanr_exp_ms, &scan_int_ms, &rssi_threshold);
968
969 if (num >= 1)
970 mlme->roam_rssi_diff_th = rssi_diff_th;
971 if (num >= 2)
972 mlme->roam_scanr_exp_ms = scanr_exp_ms;
973 if (num >= 3)
974 mlme->roam_scan_int_ms = scan_int_ms;
975 if (num >= 4)
976 mlme->roam_rssi_threshold = rssi_threshold;
977 }
978
979 return count;
980
981 }
982
proc_set_roam_tgt_addr(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)983 ssize_t proc_set_roam_tgt_addr(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
984 {
985 struct net_device *dev = data;
986 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
987
988 char tmp[32];
989 u8 addr[ETH_ALEN];
990
991 if (count < 1)
992 return -EFAULT;
993
994 if (count > sizeof(tmp)) {
995 rtw_warn_on(1);
996 return -EFAULT;
997 }
998
999 if (buffer && !copy_from_user(tmp, buffer, count)) {
1000
1001 int num = sscanf(tmp, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", addr, addr + 1, addr + 2, addr + 3, addr + 4, addr + 5);
1002 if (num == 6)
1003 _rtw_memcpy(adapter->mlmepriv.roam_tgt_addr, addr, ETH_ALEN);
1004
1005 RTW_INFO("set roam_tgt_addr to "MAC_FMT"\n", MAC_ARG(adapter->mlmepriv.roam_tgt_addr));
1006 }
1007
1008 return count;
1009 }
1010 #endif /* CONFIG_LAYER2_ROAMING */
1011
1012 #ifdef CONFIG_RTW_80211R
proc_set_ft_flags(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1013 ssize_t proc_set_ft_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1014 {
1015 struct net_device *dev = data;
1016 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1017
1018 char tmp[32];
1019 u8 flags;
1020
1021 if (count < 1)
1022 return -EFAULT;
1023
1024 if (count > sizeof(tmp)) {
1025 rtw_warn_on(1);
1026 return -EFAULT;
1027 }
1028
1029 if (buffer && !copy_from_user(tmp, buffer, count)) {
1030 int num = sscanf(tmp, "%hhx", &flags);
1031
1032 if (num == 1)
1033 adapter->mlmepriv.ftpriv.ft_flags = flags;
1034 }
1035
1036 return count;
1037
1038 }
1039
proc_get_ft_flags(struct seq_file * m,void * v)1040 int proc_get_ft_flags(struct seq_file *m, void *v)
1041 {
1042 struct net_device *dev = m->private;
1043 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1044
1045 RTW_PRINT_SEL(m, "0x%02x\n", adapter->mlmepriv.ftpriv.ft_flags);
1046
1047 return 0;
1048 }
1049 #endif
1050
proc_get_qos_option(struct seq_file * m,void * v)1051 int proc_get_qos_option(struct seq_file *m, void *v)
1052 {
1053 struct net_device *dev = m->private;
1054 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1055 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1056
1057 RTW_PRINT_SEL(m, "qos_option=%d\n", pmlmepriv->qospriv.qos_option);
1058
1059 return 0;
1060 }
1061
proc_get_ht_option(struct seq_file * m,void * v)1062 int proc_get_ht_option(struct seq_file *m, void *v)
1063 {
1064 struct net_device *dev = m->private;
1065 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1066 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1067
1068 #ifdef CONFIG_80211N_HT
1069 RTW_PRINT_SEL(m, "ht_option=%d\n", pmlmepriv->htpriv.ht_option);
1070 #endif /* CONFIG_80211N_HT */
1071
1072 return 0;
1073 }
1074
proc_get_rf_info(struct seq_file * m,void * v)1075 int proc_get_rf_info(struct seq_file *m, void *v)
1076 {
1077 struct net_device *dev = m->private;
1078 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1079 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1080
1081 RTW_PRINT_SEL(m, "cur_ch=%d, cur_bw=%d, cur_ch_offet=%d\n",
1082 pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
1083
1084 RTW_PRINT_SEL(m, "oper_ch=%d, oper_bw=%d, oper_ch_offet=%d\n",
1085 rtw_get_oper_ch(padapter), rtw_get_oper_bw(padapter), rtw_get_oper_choffset(padapter));
1086
1087 return 0;
1088 }
1089
proc_get_scan_param(struct seq_file * m,void * v)1090 int proc_get_scan_param(struct seq_file *m, void *v)
1091 {
1092 struct net_device *dev = m->private;
1093 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1094 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1095 struct ss_res *ss = &mlmeext->sitesurvey_res;
1096
1097 #define SCAN_PARAM_TITLE_FMT "%10s"
1098 #define SCAN_PARAM_VALUE_FMT "%-10u"
1099 #define SCAN_PARAM_TITLE_ARG , "scan_ch_ms"
1100 #define SCAN_PARAM_VALUE_ARG , ss->scan_ch_ms
1101 #ifdef CONFIG_80211N_HT
1102 #define SCAN_PARAM_TITLE_FMT_HT " %15s %13s"
1103 #define SCAN_PARAM_VALUE_FMT_HT " %-15u %-13u"
1104 #define SCAN_PARAM_TITLE_ARG_HT , "rx_ampdu_accept", "rx_ampdu_size"
1105 #define SCAN_PARAM_VALUE_ARG_HT , ss->rx_ampdu_accept, ss->rx_ampdu_size
1106 #else
1107 #define SCAN_PARAM_TITLE_FMT_HT ""
1108 #define SCAN_PARAM_VALUE_FMT_HT ""
1109 #define SCAN_PARAM_TITLE_ARG_HT
1110 #define SCAN_PARAM_VALUE_ARG_HT
1111 #endif
1112 #ifdef CONFIG_SCAN_BACKOP
1113 #define SCAN_PARAM_TITLE_FMT_BACKOP " %9s %12s"
1114 #define SCAN_PARAM_VALUE_FMT_BACKOP " %-9u %-12u"
1115 #define SCAN_PARAM_TITLE_ARG_BACKOP , "backop_ms", "scan_cnt_max"
1116 #define SCAN_PARAM_VALUE_ARG_BACKOP , ss->backop_ms, ss->scan_cnt_max
1117 #else
1118 #define SCAN_PARAM_TITLE_FMT_BACKOP ""
1119 #define SCAN_PARAM_VALUE_FMT_BACKOP ""
1120 #define SCAN_PARAM_TITLE_ARG_BACKOP
1121 #define SCAN_PARAM_VALUE_ARG_BACKOP
1122 #endif
1123
1124 RTW_PRINT_SEL(m,
1125 SCAN_PARAM_TITLE_FMT
1126 SCAN_PARAM_TITLE_FMT_HT
1127 SCAN_PARAM_TITLE_FMT_BACKOP
1128 "\n"
1129 SCAN_PARAM_TITLE_ARG
1130 SCAN_PARAM_TITLE_ARG_HT
1131 SCAN_PARAM_TITLE_ARG_BACKOP
1132 );
1133
1134 RTW_PRINT_SEL(m,
1135 SCAN_PARAM_VALUE_FMT
1136 SCAN_PARAM_VALUE_FMT_HT
1137 SCAN_PARAM_VALUE_FMT_BACKOP
1138 "\n"
1139 SCAN_PARAM_VALUE_ARG
1140 SCAN_PARAM_VALUE_ARG_HT
1141 SCAN_PARAM_VALUE_ARG_BACKOP
1142 );
1143
1144 return 0;
1145 }
1146
proc_set_scan_param(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1147 ssize_t proc_set_scan_param(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1148 {
1149 struct net_device *dev = data;
1150 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1151 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1152 struct ss_res *ss = &mlmeext->sitesurvey_res;
1153
1154 char tmp[32] = {0};
1155
1156 u16 scan_ch_ms;
1157 #define SCAN_PARAM_INPUT_FMT "%hu"
1158 #define SCAN_PARAM_INPUT_ARG , &scan_ch_ms
1159 #ifdef CONFIG_80211N_HT
1160 u8 rx_ampdu_accept;
1161 u8 rx_ampdu_size;
1162 #define SCAN_PARAM_INPUT_FMT_HT " %hhu %hhu"
1163 #define SCAN_PARAM_INPUT_ARG_HT , &rx_ampdu_accept, &rx_ampdu_size
1164 #else
1165 #define SCAN_PARAM_INPUT_FMT_HT ""
1166 #define SCAN_PARAM_INPUT_ARG_HT
1167 #endif
1168 #ifdef CONFIG_SCAN_BACKOP
1169 u16 backop_ms;
1170 u8 scan_cnt_max;
1171 #define SCAN_PARAM_INPUT_FMT_BACKOP " %hu %hhu"
1172 #define SCAN_PARAM_INPUT_ARG_BACKOP , &backop_ms, &scan_cnt_max
1173 #else
1174 #define SCAN_PARAM_INPUT_FMT_BACKOP ""
1175 #define SCAN_PARAM_INPUT_ARG_BACKOP
1176 #endif
1177
1178 if (count < 1)
1179 return -EFAULT;
1180
1181 if (count > sizeof(tmp)) {
1182 rtw_warn_on(1);
1183 return -EFAULT;
1184 }
1185
1186 if (buffer && !copy_from_user(tmp, buffer, count)) {
1187
1188 int num = sscanf(tmp,
1189 SCAN_PARAM_INPUT_FMT
1190 SCAN_PARAM_INPUT_FMT_HT
1191 SCAN_PARAM_INPUT_FMT_BACKOP
1192 SCAN_PARAM_INPUT_ARG
1193 SCAN_PARAM_INPUT_ARG_HT
1194 SCAN_PARAM_INPUT_ARG_BACKOP
1195 );
1196
1197 if (num-- > 0)
1198 ss->scan_ch_ms = scan_ch_ms;
1199 #ifdef CONFIG_80211N_HT
1200 if (num-- > 0)
1201 ss->rx_ampdu_accept = rx_ampdu_accept;
1202 if (num-- > 0)
1203 ss->rx_ampdu_size = rx_ampdu_size;
1204 #endif
1205 #ifdef CONFIG_SCAN_BACKOP
1206 if (num-- > 0)
1207 ss->backop_ms = backop_ms;
1208 if (num-- > 0)
1209 ss->scan_cnt_max = scan_cnt_max;
1210 #endif
1211 }
1212
1213 return count;
1214 }
1215
proc_get_scan_abort(struct seq_file * m,void * v)1216 int proc_get_scan_abort(struct seq_file *m, void *v)
1217 {
1218 struct net_device *dev = m->private;
1219 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1220 u32 pass_ms;
1221
1222 pass_ms = rtw_scan_abort_timeout(adapter, 10000);
1223
1224 RTW_PRINT_SEL(m, "%u\n", pass_ms);
1225
1226 return 0;
1227 }
1228
1229 #ifdef CONFIG_SCAN_BACKOP
proc_get_backop_flags_sta(struct seq_file * m,void * v)1230 int proc_get_backop_flags_sta(struct seq_file *m, void *v)
1231 {
1232 struct net_device *dev = m->private;
1233 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1234 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1235
1236 RTW_PRINT_SEL(m, "0x%02x\n", mlmeext_scan_backop_flags_sta(mlmeext));
1237
1238 return 0;
1239 }
1240
proc_set_backop_flags_sta(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1241 ssize_t proc_set_backop_flags_sta(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1242 {
1243 struct net_device *dev = data;
1244 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1245 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1246
1247 char tmp[32];
1248 u8 flags;
1249
1250 if (count < 1)
1251 return -EFAULT;
1252
1253 if (count > sizeof(tmp)) {
1254 rtw_warn_on(1);
1255 return -EFAULT;
1256 }
1257
1258 if (buffer && !copy_from_user(tmp, buffer, count)) {
1259
1260 int num = sscanf(tmp, "%hhx", &flags);
1261
1262 if (num == 1)
1263 mlmeext_assign_scan_backop_flags_sta(mlmeext, flags);
1264 }
1265
1266 return count;
1267 }
1268
proc_get_backop_flags_ap(struct seq_file * m,void * v)1269 int proc_get_backop_flags_ap(struct seq_file *m, void *v)
1270 {
1271 struct net_device *dev = m->private;
1272 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1273 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1274
1275 RTW_PRINT_SEL(m, "0x%02x\n", mlmeext_scan_backop_flags_ap(mlmeext));
1276
1277 return 0;
1278 }
1279
proc_set_backop_flags_ap(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1280 ssize_t proc_set_backop_flags_ap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1281 {
1282 struct net_device *dev = data;
1283 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1284 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1285
1286 char tmp[32];
1287 u8 flags;
1288
1289 if (count < 1)
1290 return -EFAULT;
1291
1292 if (count > sizeof(tmp)) {
1293 rtw_warn_on(1);
1294 return -EFAULT;
1295 }
1296
1297 if (buffer && !copy_from_user(tmp, buffer, count)) {
1298
1299 int num = sscanf(tmp, "%hhx", &flags);
1300
1301 if (num == 1)
1302 mlmeext_assign_scan_backop_flags_ap(mlmeext, flags);
1303 }
1304
1305 return count;
1306 }
1307
1308 #endif /* CONFIG_SCAN_BACKOP */
1309
1310 #ifdef CONFIG_RTW_REPEATER_SON
proc_get_rson_data(struct seq_file * m,void * v)1311 int proc_get_rson_data(struct seq_file *m, void *v)
1312 {
1313 struct net_device *dev = m->private;
1314 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1315 char rson_data_str[256];
1316
1317 rtw_rson_get_property_str(padapter, rson_data_str);
1318 RTW_PRINT_SEL(m, "%s\n", rson_data_str);
1319 return 0;
1320 }
1321
proc_set_rson_data(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1322 ssize_t proc_set_rson_data(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1323 {
1324 struct net_device *dev = data;
1325 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1326 struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter);
1327 char tmp[64] = {0};
1328 int num;
1329 u8 field[10], value[64];
1330
1331 if (count < 1)
1332 return -EFAULT;
1333
1334 if (count > sizeof(tmp)) {
1335 rtw_warn_on(1);
1336 return -EFAULT;
1337 }
1338
1339 if (buffer && !copy_from_user(tmp, buffer, count)) {
1340 num = sscanf(tmp, "%s %s", field, value);
1341 if (num != 2) {
1342 RTW_INFO("Invalid format : echo <field> <value> > son_data\n");
1343 return count;
1344 }
1345 RTW_INFO("field=%s value=%s\n", field, value);
1346 num = rtw_rson_set_property(padapter, field, value);
1347 if (num != 1) {
1348 RTW_INFO("Invalid field(%s) or value(%s)\n", field, value);
1349 return count;
1350 }
1351 }
1352 return count;
1353 }
1354 #endif /*CONFIG_RTW_REPEATER_SON*/
1355
proc_get_survey_info(struct seq_file * m,void * v)1356 int proc_get_survey_info(struct seq_file *m, void *v)
1357 {
1358 _irqL irqL;
1359 struct net_device *dev = m->private;
1360 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1361 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1362 _queue *queue = &(pmlmepriv->scanned_queue);
1363 struct wlan_network *pnetwork = NULL;
1364 _list *plist, *phead;
1365 s32 notify_signal;
1366 s16 notify_noise = 0;
1367 u16 index = 0, ie_cap = 0;
1368 unsigned char *ie_wpa = NULL, *ie_wpa2 = NULL, *ie_wps = NULL;
1369 unsigned char *ie_p2p = NULL, *ssid = NULL;
1370 char flag_str[64];
1371 int ielen = 0;
1372 u32 wpsielen = 0;
1373
1374 _enter_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
1375 phead = get_list_head(queue);
1376 if (!phead)
1377 goto _exit;
1378 plist = get_next(phead);
1379 if (!plist)
1380 goto _exit;
1381
1382 #ifdef CONFIG_RTW_REPEATER_SON
1383 rtw_rson_show_survey_info(m, plist, phead);
1384 #else
1385
1386 RTW_PRINT_SEL(m, "%5s %-17s %3s %-3s %-4s %-4s %5s %32s %32s\n", "index", "bssid", "ch", "RSSI", "SdBm", "Noise", "age", "flag", "ssid");
1387 while (1) {
1388 if (rtw_end_of_queue_search(phead, plist) == _TRUE)
1389 break;
1390
1391 pnetwork = LIST_CONTAINOR(plist, struct wlan_network, list);
1392 if (!pnetwork)
1393 break;
1394
1395 if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE &&
1396 is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) {
1397 notify_signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);/* dbm */
1398 } else {
1399 notify_signal = translate_percentage_to_dbm(pnetwork->network.PhyInfo.SignalStrength);/* dbm */
1400 }
1401
1402 #ifdef CONFIG_BACKGROUND_NOISE_MONITOR
1403 if (IS_NM_ENABLE(padapter))
1404 notify_noise = rtw_noise_query_by_chan_num(padapter, pnetwork->network.Configuration.DSConfig);
1405 #endif
1406
1407 ie_wpa = rtw_get_wpa_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength - 12);
1408 ie_wpa2 = rtw_get_wpa2_ie(&pnetwork->network.IEs[12], &ielen, pnetwork->network.IELength - 12);
1409 ie_cap = rtw_get_capability(&pnetwork->network);
1410 ie_wps = rtw_get_wps_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &wpsielen);
1411 ie_p2p = rtw_get_p2p_ie(&pnetwork->network.IEs[12], pnetwork->network.IELength - 12, NULL, &ielen);
1412 ssid = pnetwork->network.Ssid.Ssid;
1413 sprintf(flag_str, "%s%s%s%s%s%s%s",
1414 (ie_wpa) ? "[WPA]" : "",
1415 (ie_wpa2) ? "[WPA2]" : "",
1416 (!ie_wpa && !ie_wpa && ie_cap & BIT(4)) ? "[WEP]" : "",
1417 (ie_wps) ? "[WPS]" : "",
1418 (pnetwork->network.InfrastructureMode == Ndis802_11IBSS) ? "[IBSS]" : "",
1419 (ie_cap & BIT(0)) ? "[ESS]" : "",
1420 (ie_p2p) ? "[P2P]" : "");
1421 RTW_PRINT_SEL(m, "%5d "MAC_FMT" %3d %3d %4d %4d %5d %32s %32s\n",
1422 ++index,
1423 MAC_ARG(pnetwork->network.MacAddress),
1424 pnetwork->network.Configuration.DSConfig,
1425 (int)pnetwork->network.Rssi,
1426 notify_signal,
1427 notify_noise,
1428 rtw_get_passing_time_ms(pnetwork->last_scanned),
1429 flag_str,
1430 pnetwork->network.Ssid.Ssid);
1431 plist = get_next(plist);
1432 }
1433 #endif
1434 _exit:
1435 _exit_critical_bh(&(pmlmepriv->scanned_queue.lock), &irqL);
1436
1437 return 0;
1438 }
1439
proc_set_survey_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1440 ssize_t proc_set_survey_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1441 {
1442 _irqL irqL;
1443 struct net_device *dev = data;
1444 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1445 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1446 bool need_indicate_scan_done = _FALSE;
1447 u8 _status = _FALSE;
1448 NDIS_802_11_SSID ssid[RTW_SSID_SCAN_AMOUNT];
1449
1450 if (count < 1)
1451 return -EFAULT;
1452
1453 #ifdef CONFIG_MP_INCLUDED
1454 if (rtw_mp_mode_check(padapter)) {
1455 RTW_INFO("MP mode block Scan request\n");
1456 goto exit;
1457 }
1458 #endif
1459 if (rtw_is_scan_deny(padapter)) {
1460 RTW_INFO(FUNC_ADPT_FMT ": scan deny\n", FUNC_ADPT_ARG(padapter));
1461 goto exit;
1462 }
1463
1464 rtw_ps_deny(padapter, PS_DENY_SCAN);
1465 if (_FAIL == rtw_pwr_wakeup(padapter))
1466 goto cancel_ps_deny;
1467
1468 if (!rtw_is_adapter_up(padapter)) {
1469 RTW_INFO("scan abort!! adapter cannot use\n");
1470 goto cancel_ps_deny;
1471 }
1472
1473 if (rtw_mi_busy_traffic_check(padapter, _FALSE)) {
1474 RTW_INFO("scan abort!! BusyTraffic == _TRUE\n");
1475 goto cancel_ps_deny;
1476 }
1477
1478 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) && check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
1479 RTW_INFO("scan abort!! AP mode process WPS\n");
1480 goto cancel_ps_deny;
1481 }
1482 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING) == _TRUE) {
1483 RTW_INFO("scan abort!! fwstate=0x%x\n", pmlmepriv->fw_state);
1484 goto cancel_ps_deny;
1485 }
1486
1487 #ifdef CONFIG_CONCURRENT_MODE
1488 if (rtw_mi_buddy_check_fwstate(padapter,
1489 _FW_UNDER_SURVEY | _FW_UNDER_LINKING | WIFI_UNDER_WPS)) {
1490 RTW_INFO("scan abort!! buddy_fwstate check failed\n");
1491 goto cancel_ps_deny;
1492 }
1493 #endif
1494 _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0, NULL, 0);
1495
1496 cancel_ps_deny:
1497 rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
1498 exit:
1499 return count;
1500 }
1501
proc_get_ap_info(struct seq_file * m,void * v)1502 int proc_get_ap_info(struct seq_file *m, void *v)
1503 {
1504 struct net_device *dev = m->private;
1505 struct sta_info *psta;
1506 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1507 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1508 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1509 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
1510 struct sta_priv *pstapriv = &padapter->stapriv;
1511
1512 psta = rtw_get_stainfo(pstapriv, cur_network->network.MacAddress);
1513 if (psta) {
1514 int i;
1515 struct recv_reorder_ctrl *preorder_ctrl;
1516
1517 RTW_PRINT_SEL(m, "SSID=%s\n", cur_network->network.Ssid.Ssid);
1518 RTW_PRINT_SEL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->cmn.mac_addr));
1519 RTW_PRINT_SEL(m, "cur_channel=%d, cur_bwmode=%d, cur_ch_offset=%d\n", pmlmeext->cur_channel, pmlmeext->cur_bwmode, pmlmeext->cur_ch_offset);
1520 RTW_PRINT_SEL(m, "wireless_mode=0x%x, rtsen=%d, cts2slef=%d\n", psta->wireless_mode, psta->rtsen, psta->cts2self);
1521 RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n",
1522 psta->state, psta->cmn.aid, psta->cmn.mac_id, psta->cmn.ra_info.rate_id);
1523 #ifdef CONFIG_80211N_HT
1524 RTW_PRINT_SEL(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
1525 RTW_PRINT_SEL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n"
1526 , psta->cmn.bw_mode, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
1527 RTW_PRINT_SEL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
1528 RTW_PRINT_SEL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
1529 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);
1530 #endif /* CONFIG_80211N_HT */
1531 #ifdef CONFIG_80211AC_VHT
1532 RTW_PRINT_SEL(m, "vht_en=%d, vht_sgi_80m=%d\n", psta->vhtpriv.vht_option, psta->vhtpriv.sgi_80m);
1533 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);
1534 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);
1535 #endif
1536
1537 sta_rx_reorder_ctl_dump(m, psta);
1538 } else
1539 RTW_PRINT_SEL(m, "can't get sta's macaddr, cur_network's macaddr:" MAC_FMT "\n", MAC_ARG(cur_network->network.MacAddress));
1540
1541 return 0;
1542 }
1543
proc_reset_trx_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1544 ssize_t proc_reset_trx_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1545 {
1546 struct net_device *dev = data;
1547 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1548 struct recv_priv *precvpriv = &padapter->recvpriv;
1549 char cmd[32] = {0};
1550 u8 cnt = 0;
1551
1552 if (count > sizeof(cmd)) {
1553 rtw_warn_on(1);
1554 return -EFAULT;
1555 }
1556
1557 if (buffer && !copy_from_user(cmd, buffer, count)) {
1558 int num = sscanf(cmd, "%hhx", &cnt);
1559
1560 if (0 == cnt) {
1561 precvpriv->dbg_rx_ampdu_drop_count = 0;
1562 precvpriv->dbg_rx_ampdu_forced_indicate_count = 0;
1563 precvpriv->dbg_rx_ampdu_loss_count = 0;
1564 precvpriv->dbg_rx_dup_mgt_frame_drop_count = 0;
1565 precvpriv->dbg_rx_ampdu_window_shift_cnt = 0;
1566 precvpriv->dbg_rx_conflic_mac_addr_cnt = 0;
1567 precvpriv->dbg_rx_drop_count = 0;
1568 }
1569 }
1570
1571 return count;
1572 }
1573
proc_get_trx_info(struct seq_file * m,void * v)1574 int proc_get_trx_info(struct seq_file *m, void *v)
1575 {
1576 struct net_device *dev = m->private;
1577 int i;
1578 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1579 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
1580 struct recv_priv *precvpriv = &padapter->recvpriv;
1581 struct hw_xmit *phwxmit;
1582
1583 dump_os_queue(m, padapter);
1584
1585 RTW_PRINT_SEL(m, "free_xmitbuf_cnt=%d, free_xmitframe_cnt=%d\n"
1586 , pxmitpriv->free_xmitbuf_cnt, pxmitpriv->free_xmitframe_cnt);
1587 RTW_PRINT_SEL(m, "free_ext_xmitbuf_cnt=%d, free_xframe_ext_cnt=%d\n"
1588 , pxmitpriv->free_xmit_extbuf_cnt, pxmitpriv->free_xframe_ext_cnt);
1589 RTW_PRINT_SEL(m, "free_recvframe_cnt=%d\n"
1590 , precvpriv->free_recvframe_cnt);
1591
1592 for (i = 0; i < 4; i++) {
1593 phwxmit = pxmitpriv->hwxmits + i;
1594 RTW_PRINT_SEL(m, "%d, hwq.accnt=%d\n", i, phwxmit->accnt);
1595 }
1596
1597 rtw_hal_get_hwreg(padapter, HW_VAR_DUMP_MAC_TXFIFO, (u8 *)m);
1598
1599 #ifdef CONFIG_USB_HCI
1600 RTW_PRINT_SEL(m, "rx_urb_pending_cn=%d\n", ATOMIC_READ(&(precvpriv->rx_pending_cnt)));
1601 #endif
1602
1603 dump_rx_bh_tk(m, &GET_PRIMARY_ADAPTER(padapter)->recvpriv);
1604
1605 /* Folowing are RX info */
1606 RTW_PRINT_SEL(m, "RX: Count of Packets dropped by Driver: %llu\n", (unsigned long long)precvpriv->dbg_rx_drop_count);
1607 /* Counts of packets whose seq_num is less than preorder_ctrl->indicate_seq, Ex delay, retransmission, redundant packets and so on */
1608 RTW_PRINT_SEL(m, "Rx: Counts of Packets Whose Seq_Num Less Than Reorder Control Seq_Num: %llu\n", (unsigned long long)precvpriv->dbg_rx_ampdu_drop_count);
1609 /* How many times the Rx Reorder Timer is triggered. */
1610 RTW_PRINT_SEL(m, "Rx: Reorder Time-out Trigger Counts: %llu\n", (unsigned long long)precvpriv->dbg_rx_ampdu_forced_indicate_count);
1611 /* Total counts of packets loss */
1612 RTW_PRINT_SEL(m, "Rx: Packet Loss Counts: %llu\n", (unsigned long long)precvpriv->dbg_rx_ampdu_loss_count);
1613 RTW_PRINT_SEL(m, "Rx: Duplicate Management Frame Drop Count: %llu\n", (unsigned long long)precvpriv->dbg_rx_dup_mgt_frame_drop_count);
1614 RTW_PRINT_SEL(m, "Rx: AMPDU BA window shift Count: %llu\n", (unsigned long long)precvpriv->dbg_rx_ampdu_window_shift_cnt);
1615 /*The same mac addr counts*/
1616 RTW_PRINT_SEL(m, "Rx: Conflict MAC Address Frames Count: %llu\n", (unsigned long long)precvpriv->dbg_rx_conflic_mac_addr_cnt);
1617 return 0;
1618 }
1619
proc_get_dis_pwt(struct seq_file * m,void * v)1620 int proc_get_dis_pwt(struct seq_file *m, void *v)
1621 {
1622 struct net_device *dev = m->private;
1623 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1624 u8 dis_pwt = 0;
1625 rtw_hal_get_def_var(padapter, HAL_DEF_DBG_DIS_PWT, &(dis_pwt));
1626 RTW_PRINT_SEL(m, " Tx Power training mode:%s\n", (dis_pwt == _TRUE) ? "Disable" : "Enable");
1627 return 0;
1628 }
proc_set_dis_pwt(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1629 ssize_t proc_set_dis_pwt(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1630 {
1631 struct net_device *dev = data;
1632 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1633 char tmp[4] = {0};
1634 u8 dis_pwt = 0;
1635
1636 if (count < 1)
1637 return -EFAULT;
1638
1639 if (count > sizeof(tmp)) {
1640 rtw_warn_on(1);
1641 return -EFAULT;
1642 }
1643
1644 if (buffer && !copy_from_user(tmp, buffer, count)) {
1645
1646 int num = sscanf(tmp, "%hhx", &dis_pwt);
1647 RTW_INFO("Set Tx Power training mode:%s\n", (dis_pwt == _TRUE) ? "Disable" : "Enable");
1648
1649 if (num >= 1)
1650 rtw_hal_set_def_var(padapter, HAL_DEF_DBG_DIS_PWT, &(dis_pwt));
1651 }
1652
1653 return count;
1654
1655 }
1656
proc_get_rate_ctl(struct seq_file * m,void * v)1657 int proc_get_rate_ctl(struct seq_file *m, void *v)
1658 {
1659 struct net_device *dev = m->private;
1660 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1661 u8 data_rate = 0, sgi = 0, data_fb = 0;
1662
1663 if (adapter->fix_rate != 0xff) {
1664 data_rate = adapter->fix_rate & 0x7F;
1665 sgi = adapter->fix_rate >> 7;
1666 data_fb = adapter->data_fb ? 1 : 0;
1667 RTW_PRINT_SEL(m, "FIXED %s%s%s\n"
1668 , HDATA_RATE(data_rate)
1669 , data_rate > DESC_RATE54M ? (sgi ? " SGI" : " LGI") : ""
1670 , data_fb ? " FB" : ""
1671 );
1672 RTW_PRINT_SEL(m, "0x%02x %u\n", adapter->fix_rate, adapter->data_fb);
1673 } else
1674 RTW_PRINT_SEL(m, "RA\n");
1675
1676 return 0;
1677 }
1678
proc_set_rate_ctl(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1679 ssize_t proc_set_rate_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1680 {
1681 struct net_device *dev = data;
1682 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1683 HAL_DATA_TYPE *hal_data = GET_HAL_DATA(adapter);
1684 char tmp[32];
1685 u8 fix_rate;
1686 u8 data_fb;
1687
1688 if (count < 1)
1689 return -EFAULT;
1690
1691 if (count > sizeof(tmp)) {
1692 rtw_warn_on(1);
1693 return -EFAULT;
1694 }
1695
1696 if (buffer && !copy_from_user(tmp, buffer, count)) {
1697
1698 int num = sscanf(tmp, "%hhx %hhu", &fix_rate, &data_fb);
1699
1700 if (num >= 1) {
1701 u8 fix_rate_ori = adapter->fix_rate;
1702
1703 adapter->fix_rate = fix_rate;
1704 if (fix_rate == 0xFF)
1705 hal_data->ForcedDataRate = 0;
1706 else
1707 hal_data->ForcedDataRate = hw_rate_to_m_rate(fix_rate & 0x7F);
1708
1709 if (adapter->fix_bw != 0xFF && fix_rate_ori != fix_rate)
1710 rtw_update_tx_rate_bmp(adapter_to_dvobj(adapter));
1711 }
1712 if (num >= 2)
1713 adapter->data_fb = data_fb ? 1 : 0;
1714 }
1715
1716 return count;
1717 }
1718
1719 #ifdef CONFIG_AP_MODE
proc_get_bmc_tx_rate(struct seq_file * m,void * v)1720 int proc_get_bmc_tx_rate(struct seq_file *m, void *v)
1721 {
1722 struct net_device *dev = m->private;
1723 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1724 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
1725 struct sta_info *psta = NULL;
1726
1727 if (!MLME_IS_AP(adapter) && !MLME_IS_MESH(adapter)) {
1728 RTW_PRINT_SEL(m, "[ERROR] Not in SoftAP/Mesh mode !!\n");
1729 return 0;
1730 }
1731
1732 RTW_PRINT_SEL(m, " BMC Tx rate - %s\n", MGN_RATE_STR(adapter->bmc_tx_rate));
1733 return 0;
1734 }
1735
proc_set_bmc_tx_rate(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1736 ssize_t proc_set_bmc_tx_rate(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1737 {
1738 struct net_device *dev = data;
1739 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1740 HAL_DATA_TYPE *hal_data = GET_HAL_DATA(adapter);
1741 char tmp[32];
1742 u8 bmc_tx_rate;
1743
1744 if (count < 1)
1745 return -EFAULT;
1746
1747 if (count > sizeof(tmp)) {
1748 rtw_warn_on(1);
1749 return -EFAULT;
1750 }
1751
1752 if (buffer && !copy_from_user(tmp, buffer, count)) {
1753
1754 int num = sscanf(tmp, "%hhx", &bmc_tx_rate);
1755
1756 if (num >= 1)
1757 /*adapter->bmc_tx_rate = hw_rate_to_m_rate(bmc_tx_rate);*/
1758 adapter->bmc_tx_rate = bmc_tx_rate;
1759 }
1760
1761 return count;
1762 }
1763 #endif /*CONFIG_AP_MODE*/
1764
1765
proc_get_tx_power_offset(struct seq_file * m,void * v)1766 int proc_get_tx_power_offset(struct seq_file *m, void *v)
1767 {
1768 struct net_device *dev = m->private;
1769 int i;
1770 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1771
1772 RTW_PRINT_SEL(m, "Tx power offset - %u\n", adapter->power_offset);
1773 return 0;
1774 }
1775
proc_set_tx_power_offset(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1776 ssize_t proc_set_tx_power_offset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1777 {
1778 struct net_device *dev = data;
1779 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1780 char tmp[32];
1781 u8 power_offset = 0;
1782
1783 if (count < 1)
1784 return -EFAULT;
1785
1786 if (count > sizeof(tmp)) {
1787 rtw_warn_on(1);
1788 return -EFAULT;
1789 }
1790
1791 if (buffer && !copy_from_user(tmp, buffer, count)) {
1792
1793 int num = sscanf(tmp, "%hhu", &power_offset);
1794
1795 if (num >= 1) {
1796 if (power_offset > 5)
1797 power_offset = 0;
1798
1799 adapter->power_offset = power_offset;
1800 }
1801 }
1802
1803 return count;
1804 }
1805
proc_get_bw_ctl(struct seq_file * m,void * v)1806 int proc_get_bw_ctl(struct seq_file *m, void *v)
1807 {
1808 struct net_device *dev = m->private;
1809 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1810 u8 data_bw = 0;
1811
1812 if (adapter->fix_bw != 0xff) {
1813 data_bw = adapter->fix_bw;
1814 RTW_PRINT_SEL(m, "FIXED %s\n", ch_width_str(data_bw));
1815 } else
1816 RTW_PRINT_SEL(m, "Auto\n");
1817
1818 return 0;
1819 }
1820
proc_set_bw_ctl(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1821 ssize_t proc_set_bw_ctl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1822 {
1823 struct net_device *dev = data;
1824 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1825 char tmp[32];
1826 u8 fix_bw;
1827
1828 if (count < 1)
1829 return -EFAULT;
1830
1831 if (count > sizeof(tmp)) {
1832 rtw_warn_on(1);
1833 return -EFAULT;
1834 }
1835
1836 if (buffer && !copy_from_user(tmp, buffer, count)) {
1837 int num = sscanf(tmp, "%hhu", &fix_bw);
1838
1839 if (num >= 1) {
1840 u8 fix_bw_ori = adapter->fix_bw;
1841
1842 adapter->fix_bw = fix_bw;
1843
1844 if (adapter->fix_rate != 0xFF && fix_bw_ori != fix_bw)
1845 rtw_update_tx_rate_bmp(adapter_to_dvobj(adapter));
1846 }
1847 }
1848
1849 return count;
1850 }
1851
1852 #ifdef DBG_RX_COUNTER_DUMP
proc_get_rx_cnt_dump(struct seq_file * m,void * v)1853 int proc_get_rx_cnt_dump(struct seq_file *m, void *v)
1854 {
1855 struct net_device *dev = m->private;
1856 int i;
1857 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1858
1859 RTW_PRINT_SEL(m, "BIT0- Dump RX counters of DRV\n");
1860 RTW_PRINT_SEL(m, "BIT1- Dump RX counters of MAC\n");
1861 RTW_PRINT_SEL(m, "BIT2- Dump RX counters of PHY\n");
1862 RTW_PRINT_SEL(m, "BIT3- Dump TRX data frame of DRV\n");
1863 RTW_PRINT_SEL(m, "dump_rx_cnt_mode = 0x%02x\n", adapter->dump_rx_cnt_mode);
1864
1865 return 0;
1866 }
proc_set_rx_cnt_dump(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1867 ssize_t proc_set_rx_cnt_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1868 {
1869 struct net_device *dev = data;
1870 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1871 char tmp[32];
1872 u8 dump_rx_cnt_mode;
1873
1874 if (count < 1)
1875 return -EFAULT;
1876
1877 if (count > sizeof(tmp)) {
1878 rtw_warn_on(1);
1879 return -EFAULT;
1880 }
1881
1882 if (buffer && !copy_from_user(tmp, buffer, count)) {
1883
1884 int num = sscanf(tmp, "%hhx", &dump_rx_cnt_mode);
1885
1886 rtw_dump_phy_rxcnts_preprocess(adapter, dump_rx_cnt_mode);
1887 adapter->dump_rx_cnt_mode = dump_rx_cnt_mode;
1888
1889 }
1890
1891 return count;
1892 }
1893 #endif
1894
1895 static u8 fwdl_test_chksum_fail = 0;
1896 static u8 fwdl_test_wintint_rdy_fail = 0;
1897
rtw_fwdl_test_trigger_chksum_fail(void)1898 bool rtw_fwdl_test_trigger_chksum_fail(void)
1899 {
1900 if (fwdl_test_chksum_fail) {
1901 RTW_PRINT("fwdl test case: trigger chksum_fail\n");
1902 fwdl_test_chksum_fail--;
1903 return _TRUE;
1904 }
1905 return _FALSE;
1906 }
1907
rtw_fwdl_test_trigger_wintint_rdy_fail(void)1908 bool rtw_fwdl_test_trigger_wintint_rdy_fail(void)
1909 {
1910 if (fwdl_test_wintint_rdy_fail) {
1911 RTW_PRINT("fwdl test case: trigger wintint_rdy_fail\n");
1912 fwdl_test_wintint_rdy_fail--;
1913 return _TRUE;
1914 }
1915 return _FALSE;
1916 }
1917
proc_set_fwdl_test_case(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1918 ssize_t proc_set_fwdl_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1919 {
1920 struct net_device *dev = data;
1921 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1922 char tmp[32];
1923 int num;
1924
1925 if (count < 1)
1926 return -EFAULT;
1927
1928 if (count > sizeof(tmp)) {
1929 rtw_warn_on(1);
1930 return -EFAULT;
1931 }
1932
1933 if (buffer && !copy_from_user(tmp, buffer, count))
1934 num = sscanf(tmp, "%hhu %hhu", &fwdl_test_chksum_fail, &fwdl_test_wintint_rdy_fail);
1935
1936 return count;
1937 }
1938
1939 static u8 del_rx_ampdu_test_no_tx_fail = 0;
1940
rtw_del_rx_ampdu_test_trigger_no_tx_fail(void)1941 bool rtw_del_rx_ampdu_test_trigger_no_tx_fail(void)
1942 {
1943 if (del_rx_ampdu_test_no_tx_fail) {
1944 RTW_PRINT("del_rx_ampdu test case: trigger no_tx_fail\n");
1945 del_rx_ampdu_test_no_tx_fail--;
1946 return _TRUE;
1947 }
1948 return _FALSE;
1949 }
1950
proc_set_del_rx_ampdu_test_case(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1951 ssize_t proc_set_del_rx_ampdu_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1952 {
1953 struct net_device *dev = data;
1954 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1955 char tmp[32];
1956 int num;
1957
1958 if (count < 1)
1959 return -EFAULT;
1960
1961 if (count > sizeof(tmp)) {
1962 rtw_warn_on(1);
1963 return -EFAULT;
1964 }
1965
1966 if (buffer && !copy_from_user(tmp, buffer, count))
1967 num = sscanf(tmp, "%hhu", &del_rx_ampdu_test_no_tx_fail);
1968
1969 return count;
1970 }
1971
1972 #ifdef CONFIG_DFS_MASTER
proc_get_dfs_master_test_case(struct seq_file * m,void * v)1973 int proc_get_dfs_master_test_case(struct seq_file *m, void *v)
1974 {
1975 struct net_device *dev = m->private;
1976 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1977 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
1978
1979 RTW_PRINT_SEL(m, "%-24s %-19s\n", "radar_detect_trigger_non", "choose_dfs_ch_first");
1980 RTW_PRINT_SEL(m, "%24hhu %19hhu\n"
1981 , rfctl->dbg_dfs_master_radar_detect_trigger_non
1982 , rfctl->dbg_dfs_master_choose_dfs_ch_first
1983 );
1984
1985 return 0;
1986 }
1987
proc_set_dfs_master_test_case(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1988 ssize_t proc_set_dfs_master_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1989 {
1990 struct net_device *dev = data;
1991 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1992 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
1993 char tmp[32];
1994 u8 radar_detect_trigger_non;
1995 u8 choose_dfs_ch_first;
1996
1997 if (count < 1)
1998 return -EFAULT;
1999
2000 if (count > sizeof(tmp)) {
2001 rtw_warn_on(1);
2002 return -EFAULT;
2003 }
2004
2005 if (buffer && !copy_from_user(tmp, buffer, count)) {
2006 int num = sscanf(tmp, "%hhu %hhu", &radar_detect_trigger_non, &choose_dfs_ch_first);
2007
2008 if (num >= 1)
2009 rfctl->dbg_dfs_master_radar_detect_trigger_non = radar_detect_trigger_non;
2010 if (num >= 2)
2011 rfctl->dbg_dfs_master_choose_dfs_ch_first = choose_dfs_ch_first;
2012 }
2013
2014 return count;
2015 }
2016 #endif /* CONFIG_DFS_MASTER */
2017
2018 static u32 g_wait_hiq_empty_ms = 0;
2019
rtw_get_wait_hiq_empty_ms(void)2020 u32 rtw_get_wait_hiq_empty_ms(void)
2021 {
2022 return g_wait_hiq_empty_ms;
2023 }
2024
proc_set_wait_hiq_empty(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2025 ssize_t proc_set_wait_hiq_empty(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2026 {
2027 struct net_device *dev = data;
2028 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2029 char tmp[32];
2030 int num;
2031
2032 if (count < 1)
2033 return -EFAULT;
2034
2035 if (count > sizeof(tmp)) {
2036 rtw_warn_on(1);
2037 return -EFAULT;
2038 }
2039
2040 if (buffer && !copy_from_user(tmp, buffer, count))
2041 num = sscanf(tmp, "%u", &g_wait_hiq_empty_ms);
2042
2043 return count;
2044 }
2045
2046 static systime sta_linking_test_start_time = 0;
2047 static u32 sta_linking_test_wait_ms = 0;
2048 static u8 sta_linking_test_force_fail = 0;
2049
rtw_sta_linking_test_set_start(void)2050 void rtw_sta_linking_test_set_start(void)
2051 {
2052 sta_linking_test_start_time = rtw_get_current_time();
2053 }
2054
rtw_sta_linking_test_wait_done(void)2055 bool rtw_sta_linking_test_wait_done(void)
2056 {
2057 return rtw_get_passing_time_ms(sta_linking_test_start_time) >= sta_linking_test_wait_ms;
2058 }
2059
rtw_sta_linking_test_force_fail(void)2060 bool rtw_sta_linking_test_force_fail(void)
2061 {
2062 return sta_linking_test_force_fail;
2063 }
2064
proc_set_sta_linking_test(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2065 ssize_t proc_set_sta_linking_test(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2066 {
2067 struct net_device *dev = data;
2068 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2069 char tmp[32];
2070
2071 if (count < 1)
2072 return -EFAULT;
2073
2074 if (count > sizeof(tmp)) {
2075 rtw_warn_on(1);
2076 return -EFAULT;
2077 }
2078
2079 if (buffer && !copy_from_user(tmp, buffer, count)) {
2080 u32 wait_ms = 0;
2081 u8 force_fail = 0;
2082 int num = sscanf(tmp, "%u %hhu", &wait_ms, &force_fail);
2083
2084 if (num >= 1)
2085 sta_linking_test_wait_ms = wait_ms;
2086 if (num >= 2)
2087 sta_linking_test_force_fail = force_fail;
2088 }
2089
2090 return count;
2091 }
2092
proc_get_ps_dbg_info(struct seq_file * m,void * v)2093 int proc_get_ps_dbg_info(struct seq_file *m, void *v)
2094 {
2095 struct net_device *dev = m->private;
2096 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2097 struct dvobj_priv *dvobj = padapter->dvobj;
2098 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
2099
2100 RTW_PRINT_SEL(m, "dbg_sdio_alloc_irq_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_cnt);
2101 RTW_PRINT_SEL(m, "dbg_sdio_free_irq_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_cnt);
2102 RTW_PRINT_SEL(m, "dbg_sdio_alloc_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_alloc_irq_error_cnt);
2103 RTW_PRINT_SEL(m, "dbg_sdio_free_irq_error_cnt=%d\n", pdbgpriv->dbg_sdio_free_irq_error_cnt);
2104 RTW_PRINT_SEL(m, "dbg_sdio_init_error_cnt=%d\n", pdbgpriv->dbg_sdio_init_error_cnt);
2105 RTW_PRINT_SEL(m, "dbg_sdio_deinit_error_cnt=%d\n", pdbgpriv->dbg_sdio_deinit_error_cnt);
2106 RTW_PRINT_SEL(m, "dbg_suspend_error_cnt=%d\n", pdbgpriv->dbg_suspend_error_cnt);
2107 RTW_PRINT_SEL(m, "dbg_suspend_cnt=%d\n", pdbgpriv->dbg_suspend_cnt);
2108 RTW_PRINT_SEL(m, "dbg_resume_cnt=%d\n", pdbgpriv->dbg_resume_cnt);
2109 RTW_PRINT_SEL(m, "dbg_resume_error_cnt=%d\n", pdbgpriv->dbg_resume_error_cnt);
2110 RTW_PRINT_SEL(m, "dbg_deinit_fail_cnt=%d\n", pdbgpriv->dbg_deinit_fail_cnt);
2111 RTW_PRINT_SEL(m, "dbg_carddisable_cnt=%d\n", pdbgpriv->dbg_carddisable_cnt);
2112 RTW_PRINT_SEL(m, "dbg_ps_insuspend_cnt=%d\n", pdbgpriv->dbg_ps_insuspend_cnt);
2113 RTW_PRINT_SEL(m, "dbg_dev_unload_inIPS_cnt=%d\n", pdbgpriv->dbg_dev_unload_inIPS_cnt);
2114 RTW_PRINT_SEL(m, "dbg_scan_pwr_state_cnt=%d\n", pdbgpriv->dbg_scan_pwr_state_cnt);
2115 RTW_PRINT_SEL(m, "dbg_downloadfw_pwr_state_cnt=%d\n", pdbgpriv->dbg_downloadfw_pwr_state_cnt);
2116 RTW_PRINT_SEL(m, "dbg_carddisable_error_cnt=%d\n", pdbgpriv->dbg_carddisable_error_cnt);
2117 RTW_PRINT_SEL(m, "dbg_fw_read_ps_state_fail_cnt=%d\n", pdbgpriv->dbg_fw_read_ps_state_fail_cnt);
2118 RTW_PRINT_SEL(m, "dbg_leave_ips_fail_cnt=%d\n", pdbgpriv->dbg_leave_ips_fail_cnt);
2119 RTW_PRINT_SEL(m, "dbg_leave_lps_fail_cnt=%d\n", pdbgpriv->dbg_leave_lps_fail_cnt);
2120 RTW_PRINT_SEL(m, "dbg_h2c_leave32k_fail_cnt=%d\n", pdbgpriv->dbg_h2c_leave32k_fail_cnt);
2121 RTW_PRINT_SEL(m, "dbg_diswow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_diswow_dload_fw_fail_cnt);
2122 RTW_PRINT_SEL(m, "dbg_enwow_dload_fw_fail_cnt=%d\n", pdbgpriv->dbg_enwow_dload_fw_fail_cnt);
2123 RTW_PRINT_SEL(m, "dbg_ips_drvopen_fail_cnt=%d\n", pdbgpriv->dbg_ips_drvopen_fail_cnt);
2124 RTW_PRINT_SEL(m, "dbg_poll_fail_cnt=%d\n", pdbgpriv->dbg_poll_fail_cnt);
2125 RTW_PRINT_SEL(m, "dbg_rpwm_toogle_cnt=%d\n", pdbgpriv->dbg_rpwm_toogle_cnt);
2126 RTW_PRINT_SEL(m, "dbg_rpwm_timeout_fail_cnt=%d\n", pdbgpriv->dbg_rpwm_timeout_fail_cnt);
2127 RTW_PRINT_SEL(m, "dbg_sreset_cnt=%d\n", pdbgpriv->dbg_sreset_cnt);
2128 RTW_PRINT_SEL(m, "dbg_fw_mem_dl_error_cnt=%d\n", pdbgpriv->dbg_fw_mem_dl_error_cnt);
2129
2130 return 0;
2131 }
proc_set_ps_dbg_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2132 ssize_t proc_set_ps_dbg_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2133 {
2134 struct net_device *dev = data;
2135 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2136 struct dvobj_priv *dvobj = adapter->dvobj;
2137 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
2138 char tmp[32];
2139 u8 ps_dbg_cmd_id;
2140
2141 if (count < 1)
2142 return -EFAULT;
2143
2144 if (count > sizeof(tmp)) {
2145 rtw_warn_on(1);
2146 return -EFAULT;
2147 }
2148
2149 if (buffer && !copy_from_user(tmp, buffer, count)) {
2150
2151 int num = sscanf(tmp, "%hhx", &ps_dbg_cmd_id);
2152
2153 if (ps_dbg_cmd_id == 1) /*Clean all*/
2154 _rtw_memset(pdbgpriv, 0, sizeof(struct debug_priv));
2155
2156 }
2157
2158 return count;
2159 }
2160
2161
2162 #ifdef CONFIG_DBG_COUNTER
2163
proc_get_rx_logs(struct seq_file * m,void * v)2164 int proc_get_rx_logs(struct seq_file *m, void *v)
2165 {
2166 struct net_device *dev = m->private;
2167 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2168 struct rx_logs *rx_logs = &padapter->rx_logs;
2169
2170 RTW_PRINT_SEL(m,
2171 "intf_rx=%d\n"
2172 "intf_rx_err_recvframe=%d\n"
2173 "intf_rx_err_skb=%d\n"
2174 "intf_rx_report=%d\n"
2175 "core_rx=%d\n"
2176 "core_rx_pre=%d\n"
2177 "core_rx_pre_ver_err=%d\n"
2178 "core_rx_pre_mgmt=%d\n"
2179 "core_rx_pre_mgmt_err_80211w=%d\n"
2180 "core_rx_pre_mgmt_err=%d\n"
2181 "core_rx_pre_ctrl=%d\n"
2182 "core_rx_pre_ctrl_err=%d\n"
2183 "core_rx_pre_data=%d\n"
2184 "core_rx_pre_data_wapi_seq_err=%d\n"
2185 "core_rx_pre_data_wapi_key_err=%d\n"
2186 "core_rx_pre_data_handled=%d\n"
2187 "core_rx_pre_data_err=%d\n"
2188 "core_rx_pre_data_unknown=%d\n"
2189 "core_rx_pre_unknown=%d\n"
2190 "core_rx_enqueue=%d\n"
2191 "core_rx_dequeue=%d\n"
2192 "core_rx_post=%d\n"
2193 "core_rx_post_decrypt=%d\n"
2194 "core_rx_post_decrypt_wep=%d\n"
2195 "core_rx_post_decrypt_tkip=%d\n"
2196 "core_rx_post_decrypt_aes=%d\n"
2197 "core_rx_post_decrypt_wapi=%d\n"
2198 "core_rx_post_decrypt_hw=%d\n"
2199 "core_rx_post_decrypt_unknown=%d\n"
2200 "core_rx_post_decrypt_err=%d\n"
2201 "core_rx_post_defrag_err=%d\n"
2202 "core_rx_post_portctrl_err=%d\n"
2203 "core_rx_post_indicate=%d\n"
2204 "core_rx_post_indicate_in_oder=%d\n"
2205 "core_rx_post_indicate_reoder=%d\n"
2206 "core_rx_post_indicate_err=%d\n"
2207 "os_indicate=%d\n"
2208 "os_indicate_ap_mcast=%d\n"
2209 "os_indicate_ap_forward=%d\n"
2210 "os_indicate_ap_self=%d\n"
2211 "os_indicate_err=%d\n"
2212 "os_netif_ok=%d\n"
2213 "os_netif_err=%d\n",
2214 rx_logs->intf_rx,
2215 rx_logs->intf_rx_err_recvframe,
2216 rx_logs->intf_rx_err_skb,
2217 rx_logs->intf_rx_report,
2218 rx_logs->core_rx,
2219 rx_logs->core_rx_pre,
2220 rx_logs->core_rx_pre_ver_err,
2221 rx_logs->core_rx_pre_mgmt,
2222 rx_logs->core_rx_pre_mgmt_err_80211w,
2223 rx_logs->core_rx_pre_mgmt_err,
2224 rx_logs->core_rx_pre_ctrl,
2225 rx_logs->core_rx_pre_ctrl_err,
2226 rx_logs->core_rx_pre_data,
2227 rx_logs->core_rx_pre_data_wapi_seq_err,
2228 rx_logs->core_rx_pre_data_wapi_key_err,
2229 rx_logs->core_rx_pre_data_handled,
2230 rx_logs->core_rx_pre_data_err,
2231 rx_logs->core_rx_pre_data_unknown,
2232 rx_logs->core_rx_pre_unknown,
2233 rx_logs->core_rx_enqueue,
2234 rx_logs->core_rx_dequeue,
2235 rx_logs->core_rx_post,
2236 rx_logs->core_rx_post_decrypt,
2237 rx_logs->core_rx_post_decrypt_wep,
2238 rx_logs->core_rx_post_decrypt_tkip,
2239 rx_logs->core_rx_post_decrypt_aes,
2240 rx_logs->core_rx_post_decrypt_wapi,
2241 rx_logs->core_rx_post_decrypt_hw,
2242 rx_logs->core_rx_post_decrypt_unknown,
2243 rx_logs->core_rx_post_decrypt_err,
2244 rx_logs->core_rx_post_defrag_err,
2245 rx_logs->core_rx_post_portctrl_err,
2246 rx_logs->core_rx_post_indicate,
2247 rx_logs->core_rx_post_indicate_in_oder,
2248 rx_logs->core_rx_post_indicate_reoder,
2249 rx_logs->core_rx_post_indicate_err,
2250 rx_logs->os_indicate,
2251 rx_logs->os_indicate_ap_mcast,
2252 rx_logs->os_indicate_ap_forward,
2253 rx_logs->os_indicate_ap_self,
2254 rx_logs->os_indicate_err,
2255 rx_logs->os_netif_ok,
2256 rx_logs->os_netif_err
2257 );
2258
2259 return 0;
2260 }
2261
proc_get_tx_logs(struct seq_file * m,void * v)2262 int proc_get_tx_logs(struct seq_file *m, void *v)
2263 {
2264 struct net_device *dev = m->private;
2265 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2266 struct tx_logs *tx_logs = &padapter->tx_logs;
2267
2268 RTW_PRINT_SEL(m,
2269 "os_tx=%d\n"
2270 "os_tx_err_up=%d\n"
2271 "os_tx_err_xmit=%d\n"
2272 "os_tx_m2u=%d\n"
2273 "os_tx_m2u_ignore_fw_linked=%d\n"
2274 "os_tx_m2u_ignore_self=%d\n"
2275 "os_tx_m2u_entry=%d\n"
2276 "os_tx_m2u_entry_err_xmit=%d\n"
2277 "os_tx_m2u_entry_err_skb=%d\n"
2278 "os_tx_m2u_stop=%d\n"
2279 "core_tx=%d\n"
2280 "core_tx_err_pxmitframe=%d\n"
2281 "core_tx_err_brtx=%d\n"
2282 "core_tx_upd_attrib=%d\n"
2283 "core_tx_upd_attrib_adhoc=%d\n"
2284 "core_tx_upd_attrib_sta=%d\n"
2285 "core_tx_upd_attrib_ap=%d\n"
2286 "core_tx_upd_attrib_unknown=%d\n"
2287 "core_tx_upd_attrib_dhcp=%d\n"
2288 "core_tx_upd_attrib_icmp=%d\n"
2289 "core_tx_upd_attrib_active=%d\n"
2290 "core_tx_upd_attrib_err_ucast_sta=%d\n"
2291 "core_tx_upd_attrib_err_ucast_ap_link=%d\n"
2292 "core_tx_upd_attrib_err_sta=%d\n"
2293 "core_tx_upd_attrib_err_link=%d\n"
2294 "core_tx_upd_attrib_err_sec=%d\n"
2295 "core_tx_ap_enqueue_warn_fwstate=%d\n"
2296 "core_tx_ap_enqueue_warn_sta=%d\n"
2297 "core_tx_ap_enqueue_warn_nosta=%d\n"
2298 "core_tx_ap_enqueue_warn_link=%d\n"
2299 "core_tx_ap_enqueue_warn_trigger=%d\n"
2300 "core_tx_ap_enqueue_mcast=%d\n"
2301 "core_tx_ap_enqueue_ucast=%d\n"
2302 "core_tx_ap_enqueue=%d\n"
2303 "intf_tx=%d\n"
2304 "intf_tx_pending_ac=%d\n"
2305 "intf_tx_pending_fw_under_survey=%d\n"
2306 "intf_tx_pending_fw_under_linking=%d\n"
2307 "intf_tx_pending_xmitbuf=%d\n"
2308 "intf_tx_enqueue=%d\n"
2309 "core_tx_enqueue=%d\n"
2310 "core_tx_enqueue_class=%d\n"
2311 "core_tx_enqueue_class_err_sta=%d\n"
2312 "core_tx_enqueue_class_err_nosta=%d\n"
2313 "core_tx_enqueue_class_err_fwlink=%d\n"
2314 "intf_tx_direct=%d\n"
2315 "intf_tx_direct_err_coalesce=%d\n"
2316 "intf_tx_dequeue=%d\n"
2317 "intf_tx_dequeue_err_coalesce=%d\n"
2318 "intf_tx_dump_xframe=%d\n"
2319 "intf_tx_dump_xframe_err_txdesc=%d\n"
2320 "intf_tx_dump_xframe_err_port=%d\n",
2321 tx_logs->os_tx,
2322 tx_logs->os_tx_err_up,
2323 tx_logs->os_tx_err_xmit,
2324 tx_logs->os_tx_m2u,
2325 tx_logs->os_tx_m2u_ignore_fw_linked,
2326 tx_logs->os_tx_m2u_ignore_self,
2327 tx_logs->os_tx_m2u_entry,
2328 tx_logs->os_tx_m2u_entry_err_xmit,
2329 tx_logs->os_tx_m2u_entry_err_skb,
2330 tx_logs->os_tx_m2u_stop,
2331 tx_logs->core_tx,
2332 tx_logs->core_tx_err_pxmitframe,
2333 tx_logs->core_tx_err_brtx,
2334 tx_logs->core_tx_upd_attrib,
2335 tx_logs->core_tx_upd_attrib_adhoc,
2336 tx_logs->core_tx_upd_attrib_sta,
2337 tx_logs->core_tx_upd_attrib_ap,
2338 tx_logs->core_tx_upd_attrib_unknown,
2339 tx_logs->core_tx_upd_attrib_dhcp,
2340 tx_logs->core_tx_upd_attrib_icmp,
2341 tx_logs->core_tx_upd_attrib_active,
2342 tx_logs->core_tx_upd_attrib_err_ucast_sta,
2343 tx_logs->core_tx_upd_attrib_err_ucast_ap_link,
2344 tx_logs->core_tx_upd_attrib_err_sta,
2345 tx_logs->core_tx_upd_attrib_err_link,
2346 tx_logs->core_tx_upd_attrib_err_sec,
2347 tx_logs->core_tx_ap_enqueue_warn_fwstate,
2348 tx_logs->core_tx_ap_enqueue_warn_sta,
2349 tx_logs->core_tx_ap_enqueue_warn_nosta,
2350 tx_logs->core_tx_ap_enqueue_warn_link,
2351 tx_logs->core_tx_ap_enqueue_warn_trigger,
2352 tx_logs->core_tx_ap_enqueue_mcast,
2353 tx_logs->core_tx_ap_enqueue_ucast,
2354 tx_logs->core_tx_ap_enqueue,
2355 tx_logs->intf_tx,
2356 tx_logs->intf_tx_pending_ac,
2357 tx_logs->intf_tx_pending_fw_under_survey,
2358 tx_logs->intf_tx_pending_fw_under_linking,
2359 tx_logs->intf_tx_pending_xmitbuf,
2360 tx_logs->intf_tx_enqueue,
2361 tx_logs->core_tx_enqueue,
2362 tx_logs->core_tx_enqueue_class,
2363 tx_logs->core_tx_enqueue_class_err_sta,
2364 tx_logs->core_tx_enqueue_class_err_nosta,
2365 tx_logs->core_tx_enqueue_class_err_fwlink,
2366 tx_logs->intf_tx_direct,
2367 tx_logs->intf_tx_direct_err_coalesce,
2368 tx_logs->intf_tx_dequeue,
2369 tx_logs->intf_tx_dequeue_err_coalesce,
2370 tx_logs->intf_tx_dump_xframe,
2371 tx_logs->intf_tx_dump_xframe_err_txdesc,
2372 tx_logs->intf_tx_dump_xframe_err_port
2373 );
2374
2375 return 0;
2376 }
2377
proc_get_int_logs(struct seq_file * m,void * v)2378 int proc_get_int_logs(struct seq_file *m, void *v)
2379 {
2380 struct net_device *dev = m->private;
2381 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2382
2383 RTW_PRINT_SEL(m,
2384 "all=%d\n"
2385 "err=%d\n"
2386 "tbdok=%d\n"
2387 "tbder=%d\n"
2388 "bcnderr=%d\n"
2389 "bcndma=%d\n"
2390 "bcndma_e=%d\n"
2391 "rx=%d\n"
2392 "rx_rdu=%d\n"
2393 "rx_fovw=%d\n"
2394 "txfovw=%d\n"
2395 "mgntok=%d\n"
2396 "highdok=%d\n"
2397 "bkdok=%d\n"
2398 "bedok=%d\n"
2399 "vidok=%d\n"
2400 "vodok=%d\n",
2401 padapter->int_logs.all,
2402 padapter->int_logs.err,
2403 padapter->int_logs.tbdok,
2404 padapter->int_logs.tbder,
2405 padapter->int_logs.bcnderr,
2406 padapter->int_logs.bcndma,
2407 padapter->int_logs.bcndma_e,
2408 padapter->int_logs.rx,
2409 padapter->int_logs.rx_rdu,
2410 padapter->int_logs.rx_fovw,
2411 padapter->int_logs.txfovw,
2412 padapter->int_logs.mgntok,
2413 padapter->int_logs.highdok,
2414 padapter->int_logs.bkdok,
2415 padapter->int_logs.bedok,
2416 padapter->int_logs.vidok,
2417 padapter->int_logs.vodok
2418 );
2419
2420 return 0;
2421 }
2422
2423 #endif /* CONFIG_DBG_COUNTER */
2424
proc_get_hw_status(struct seq_file * m,void * v)2425 int proc_get_hw_status(struct seq_file *m, void *v)
2426 {
2427 struct net_device *dev = m->private;
2428 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2429 struct dvobj_priv *dvobj = padapter->dvobj;
2430 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
2431 struct registry_priv *regsty = dvobj_to_regsty(dvobj);
2432
2433 if (regsty->check_hw_status == 0)
2434 RTW_PRINT_SEL(m, "RX FIFO full count: not check in watch dog\n");
2435 else if (pdbgpriv->dbg_rx_fifo_last_overflow == 1
2436 && pdbgpriv->dbg_rx_fifo_curr_overflow == 1
2437 && pdbgpriv->dbg_rx_fifo_diff_overflow == 1
2438 )
2439 RTW_PRINT_SEL(m, "RX FIFO full count: no implementation\n");
2440 else {
2441 RTW_PRINT_SEL(m, "RX FIFO full count: last_time=%llu, current_time=%llu, differential=%llu\n"
2442 , pdbgpriv->dbg_rx_fifo_last_overflow, pdbgpriv->dbg_rx_fifo_curr_overflow, pdbgpriv->dbg_rx_fifo_diff_overflow);
2443 }
2444
2445 return 0;
2446 }
2447
proc_set_hw_status(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2448 ssize_t proc_set_hw_status(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2449 {
2450 struct net_device *dev = data;
2451 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2452 struct dvobj_priv *dvobj = padapter->dvobj;
2453 struct registry_priv *regsty = dvobj_to_regsty(dvobj);
2454 char tmp[32];
2455 u32 enable;
2456
2457 if (count < 1)
2458 return -EFAULT;
2459
2460 if (count > sizeof(tmp)) {
2461 rtw_warn_on(1);
2462 return -EFAULT;
2463 }
2464
2465 if (buffer && !copy_from_user(tmp, buffer, count)) {
2466
2467 int num = sscanf(tmp, "%d ", &enable);
2468
2469 if (regsty && enable <= 1) {
2470 regsty->check_hw_status = enable;
2471 RTW_INFO("check_hw_status=%d\n", regsty->check_hw_status);
2472 }
2473 }
2474
2475 return count;
2476 }
2477
proc_get_trx_info_debug(struct seq_file * m,void * v)2478 int proc_get_trx_info_debug(struct seq_file *m, void *v)
2479 {
2480 struct net_device *dev = m->private;
2481 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2482 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
2483
2484 int i;
2485
2486
2487 /*============ tx info ============ */
2488 rtw_hal_get_def_var(padapter, HW_DEF_RA_INFO_DUMP, m);
2489
2490 /*============ rx info ============ */
2491 rtw_hal_set_odm_var(padapter, HAL_ODM_RX_INFO_DUMP, m, _FALSE);
2492
2493
2494 return 0;
2495 }
2496
proc_get_rx_signal(struct seq_file * m,void * v)2497 int proc_get_rx_signal(struct seq_file *m, void *v)
2498 {
2499 struct net_device *dev = m->private;
2500 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2501 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2502
2503 RTW_PRINT_SEL(m, "rssi:%d\n", padapter->recvpriv.rssi);
2504 /* RTW_PRINT_SEL(m, "rxpwdb:%d\n", padapter->recvpriv.rxpwdb); */
2505 RTW_PRINT_SEL(m, "signal_strength:%u\n", padapter->recvpriv.signal_strength);
2506 RTW_PRINT_SEL(m, "signal_qual:%u\n", padapter->recvpriv.signal_qual);
2507 #ifdef CONFIG_MP_INCLUDED
2508 if (padapter->registrypriv.mp_mode == 1) {
2509 if (padapter->mppriv.antenna_rx == ANTENNA_A)
2510 RTW_PRINT_SEL(m, "Antenna: A\n");
2511 else if (padapter->mppriv.antenna_rx == ANTENNA_B)
2512 RTW_PRINT_SEL(m, "Antenna: B\n");
2513 else if (padapter->mppriv.antenna_rx == ANTENNA_C)
2514 RTW_PRINT_SEL(m, "Antenna: C\n");
2515 else if (padapter->mppriv.antenna_rx == ANTENNA_D)
2516 RTW_PRINT_SEL(m, "Antenna: D\n");
2517 else if (padapter->mppriv.antenna_rx == ANTENNA_AB)
2518 RTW_PRINT_SEL(m, "Antenna: AB\n");
2519 else if (padapter->mppriv.antenna_rx == ANTENNA_BC)
2520 RTW_PRINT_SEL(m, "Antenna: BC\n");
2521 else if (padapter->mppriv.antenna_rx == ANTENNA_CD)
2522 RTW_PRINT_SEL(m, "Antenna: CD\n");
2523 else
2524 RTW_PRINT_SEL(m, "Antenna: __\n");
2525 return 0;
2526 }
2527 #endif
2528 #ifdef DBG_RX_SIGNAL_DISPLAY_RAW_DATA
2529 rtw_odm_get_perpkt_rssi(m, padapter);
2530 rtw_get_raw_rssi_info(m, padapter);
2531 #endif
2532 return 0;
2533 }
2534
proc_set_rx_signal(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2535 ssize_t proc_set_rx_signal(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2536 {
2537 struct net_device *dev = data;
2538 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2539 char tmp[32];
2540 u32 is_signal_dbg, signal_strength;
2541
2542 if (count < 1)
2543 return -EFAULT;
2544
2545 if (count > sizeof(tmp)) {
2546 rtw_warn_on(1);
2547 return -EFAULT;
2548 }
2549
2550 if (buffer && !copy_from_user(tmp, buffer, count)) {
2551
2552 int num = sscanf(tmp, "%u %u", &is_signal_dbg, &signal_strength);
2553
2554 is_signal_dbg = is_signal_dbg == 0 ? 0 : 1;
2555
2556 if (is_signal_dbg && num != 2)
2557 return count;
2558
2559 signal_strength = signal_strength > 100 ? 100 : signal_strength;
2560
2561 padapter->recvpriv.is_signal_dbg = is_signal_dbg;
2562 padapter->recvpriv.signal_strength_dbg = signal_strength;
2563
2564 if (is_signal_dbg)
2565 RTW_INFO("set %s %u\n", "DBG_SIGNAL_STRENGTH", signal_strength);
2566 else
2567 RTW_INFO("set %s\n", "HW_SIGNAL_STRENGTH");
2568
2569 }
2570
2571 return count;
2572
2573 }
2574 #ifdef CONFIG_80211N_HT
2575
proc_get_ht_enable(struct seq_file * m,void * v)2576 int proc_get_ht_enable(struct seq_file *m, void *v)
2577 {
2578 struct net_device *dev = m->private;
2579 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2580 struct registry_priv *pregpriv = &padapter->registrypriv;
2581
2582 if (pregpriv)
2583 RTW_PRINT_SEL(m, "%d\n", pregpriv->ht_enable);
2584
2585 return 0;
2586 }
2587
proc_set_ht_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2588 ssize_t proc_set_ht_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2589 {
2590 struct net_device *dev = data;
2591 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2592 struct registry_priv *pregpriv = &padapter->registrypriv;
2593 char tmp[32];
2594 u32 mode;
2595
2596 if (count < 1)
2597 return -EFAULT;
2598
2599 if (count > sizeof(tmp)) {
2600 rtw_warn_on(1);
2601 return -EFAULT;
2602 }
2603
2604 if (buffer && !copy_from_user(tmp, buffer, count)) {
2605
2606 int num = sscanf(tmp, "%d ", &mode);
2607
2608 if (pregpriv && mode < 2) {
2609 pregpriv->ht_enable = mode;
2610 RTW_INFO("ht_enable=%d\n", pregpriv->ht_enable);
2611 }
2612 }
2613
2614 return count;
2615
2616 }
2617
proc_get_bw_mode(struct seq_file * m,void * v)2618 int proc_get_bw_mode(struct seq_file *m, void *v)
2619 {
2620 struct net_device *dev = m->private;
2621 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2622 struct registry_priv *pregpriv = &padapter->registrypriv;
2623
2624 if (pregpriv)
2625 RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->bw_mode);
2626
2627 return 0;
2628 }
2629
proc_set_bw_mode(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2630 ssize_t proc_set_bw_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2631 {
2632 struct net_device *dev = data;
2633 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2634 struct registry_priv *pregpriv = &padapter->registrypriv;
2635 char tmp[32];
2636 u32 mode;
2637 u8 bw_2g;
2638 u8 bw_5g;
2639
2640 if (count < 1)
2641 return -EFAULT;
2642
2643 if (count > sizeof(tmp)) {
2644 rtw_warn_on(1);
2645 return -EFAULT;
2646 }
2647
2648 if (buffer && !copy_from_user(tmp, buffer, count)) {
2649
2650 int num = sscanf(tmp, "%x ", &mode);
2651 bw_5g = mode >> 4;
2652 bw_2g = mode & 0x0f;
2653
2654 if (pregpriv && bw_2g <= 4 && bw_5g <= 4) {
2655
2656 pregpriv->bw_mode = mode;
2657 printk("bw_mode=0x%x\n", mode);
2658
2659 }
2660 }
2661
2662 return count;
2663
2664 }
2665
proc_get_ampdu_enable(struct seq_file * m,void * v)2666 int proc_get_ampdu_enable(struct seq_file *m, void *v)
2667 {
2668 struct net_device *dev = m->private;
2669 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2670 struct registry_priv *pregpriv = &padapter->registrypriv;
2671
2672 if (pregpriv)
2673 RTW_PRINT_SEL(m, "%d\n", pregpriv->ampdu_enable);
2674
2675 return 0;
2676 }
2677
proc_set_ampdu_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2678 ssize_t proc_set_ampdu_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2679 {
2680 struct net_device *dev = data;
2681 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2682 struct registry_priv *pregpriv = &padapter->registrypriv;
2683 char tmp[32];
2684 u32 mode;
2685
2686 if (count < 1)
2687 return -EFAULT;
2688
2689 if (count > sizeof(tmp)) {
2690 rtw_warn_on(1);
2691 return -EFAULT;
2692 }
2693
2694 if (buffer && !copy_from_user(tmp, buffer, count)) {
2695
2696 int num = sscanf(tmp, "%d ", &mode);
2697
2698 if (pregpriv && mode < 2) {
2699 pregpriv->ampdu_enable = mode;
2700 printk("ampdu_enable=%d\n", mode);
2701 }
2702
2703 }
2704
2705 return count;
2706
2707 }
2708
proc_get_mac_rptbuf(struct seq_file * m,void * v)2709 int proc_get_mac_rptbuf(struct seq_file *m, void *v)
2710 {
2711 struct net_device *dev = m->private;
2712 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2713 u16 i;
2714 u16 mac_id;
2715 u32 shcut_addr = 0;
2716 u32 read_addr = 0;
2717 #ifdef CONFIG_RTL8814A
2718 RTW_PRINT_SEL(m, "TX ShortCut:\n");
2719 for (mac_id = 0; mac_id < 64; mac_id++) {
2720 rtw_write16(padapter, 0x140, 0x662 | ((mac_id & BIT5) >> 5));
2721 shcut_addr = 0x8000;
2722 shcut_addr = shcut_addr | ((mac_id & 0x1f) << 7);
2723 RTW_PRINT_SEL(m, "mac_id=%d, 0x140=%x =>\n", mac_id, 0x662 | ((mac_id & BIT5) >> 5));
2724 for (i = 0; i < 30; i++) {
2725 read_addr = 0;
2726 read_addr = shcut_addr | (i << 2);
2727 RTW_PRINT_SEL(m, "i=%02d: MAC_%04x= %08x ", i, read_addr, rtw_read32(padapter, read_addr));
2728 if (!((i + 1) % 4))
2729 RTW_PRINT_SEL(m, "\n");
2730 if (i == 29)
2731 RTW_PRINT_SEL(m, "\n");
2732 }
2733 }
2734 #endif /* CONFIG_RTL8814A */
2735 return 0;
2736 }
2737
dump_regsty_rx_ampdu_size_limit(void * sel,_adapter * adapter)2738 void dump_regsty_rx_ampdu_size_limit(void *sel, _adapter *adapter)
2739 {
2740 struct registry_priv *regsty = adapter_to_regsty(adapter);
2741 int i;
2742
2743 RTW_PRINT_SEL(sel, "%-3s %-3s %-3s %-3s %-4s\n"
2744 , "", "20M", "40M", "80M", "160M");
2745 for (i = 0; i < 4; i++)
2746 RTW_PRINT_SEL(sel, "%dSS %3u %3u %3u %4u\n", i + 1
2747 , regsty->rx_ampdu_sz_limit_by_nss_bw[i][0]
2748 , regsty->rx_ampdu_sz_limit_by_nss_bw[i][1]
2749 , regsty->rx_ampdu_sz_limit_by_nss_bw[i][2]
2750 , regsty->rx_ampdu_sz_limit_by_nss_bw[i][3]);
2751 }
2752
proc_get_rx_ampdu(struct seq_file * m,void * v)2753 int proc_get_rx_ampdu(struct seq_file *m, void *v)
2754 {
2755 struct net_device *dev = m->private;
2756 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2757
2758 _RTW_PRINT_SEL(m, "accept: ");
2759 if (padapter->fix_rx_ampdu_accept == RX_AMPDU_ACCEPT_INVALID)
2760 RTW_PRINT_SEL(m, "%u%s\n", rtw_rx_ampdu_is_accept(padapter), "(auto)");
2761 else
2762 RTW_PRINT_SEL(m, "%u%s\n", padapter->fix_rx_ampdu_accept, "(fixed)");
2763
2764 _RTW_PRINT_SEL(m, "size: ");
2765 if (padapter->fix_rx_ampdu_size == RX_AMPDU_SIZE_INVALID) {
2766 RTW_PRINT_SEL(m, "%u%s\n", rtw_rx_ampdu_size(padapter), "(auto) with conditional limit:");
2767 dump_regsty_rx_ampdu_size_limit(m, padapter);
2768 } else
2769 RTW_PRINT_SEL(m, "%u%s\n", padapter->fix_rx_ampdu_size, "(fixed)");
2770 RTW_PRINT_SEL(m, "\n");
2771
2772 RTW_PRINT_SEL(m, "%19s %17s\n", "fix_rx_ampdu_accept", "fix_rx_ampdu_size");
2773
2774 _RTW_PRINT_SEL(m, "%-19d %-17u\n"
2775 , padapter->fix_rx_ampdu_accept
2776 , padapter->fix_rx_ampdu_size);
2777
2778 return 0;
2779 }
2780
proc_set_rx_ampdu(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2781 ssize_t proc_set_rx_ampdu(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2782 {
2783 struct net_device *dev = data;
2784 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2785 struct registry_priv *pregpriv = &padapter->registrypriv;
2786 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2787 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2788 char tmp[32];
2789 u8 accept;
2790 u8 size;
2791
2792 if (count < 1)
2793 return -EFAULT;
2794
2795 if (count > sizeof(tmp)) {
2796 rtw_warn_on(1);
2797 return -EFAULT;
2798 }
2799
2800 if (buffer && !copy_from_user(tmp, buffer, count)) {
2801
2802 int num = sscanf(tmp, "%hhu %hhu", &accept, &size);
2803
2804 if (num >= 1)
2805 rtw_rx_ampdu_set_accept(padapter, accept, RX_AMPDU_DRV_FIXED);
2806 if (num >= 2)
2807 rtw_rx_ampdu_set_size(padapter, size, RX_AMPDU_DRV_FIXED);
2808
2809 rtw_rx_ampdu_apply(padapter);
2810 }
2811
2812 exit:
2813 return count;
2814 }
proc_get_rx_ampdu_factor(struct seq_file * m,void * v)2815 int proc_get_rx_ampdu_factor(struct seq_file *m, void *v)
2816 {
2817 struct net_device *dev = m->private;
2818 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2819
2820
2821 if (padapter)
2822 RTW_PRINT_SEL(m, "rx ampdu factor = %x\n", padapter->driver_rx_ampdu_factor);
2823
2824 return 0;
2825 }
2826
proc_set_rx_ampdu_factor(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2827 ssize_t proc_set_rx_ampdu_factor(struct file *file, const char __user *buffer
2828 , size_t count, loff_t *pos, void *data)
2829 {
2830 struct net_device *dev = data;
2831 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2832 char tmp[32];
2833 u32 factor;
2834
2835 if (count < 1)
2836 return -EFAULT;
2837
2838 if (count > sizeof(tmp)) {
2839 rtw_warn_on(1);
2840 return -EFAULT;
2841 }
2842
2843 if (buffer && !copy_from_user(tmp, buffer, count)) {
2844
2845 int num = sscanf(tmp, "%d ", &factor);
2846
2847 if (padapter && (num == 1)) {
2848 RTW_INFO("padapter->driver_rx_ampdu_factor = %x\n", factor);
2849
2850 if (factor > 0x03)
2851 padapter->driver_rx_ampdu_factor = 0xFF;
2852 else
2853 padapter->driver_rx_ampdu_factor = factor;
2854 }
2855 }
2856
2857 return count;
2858 }
2859
proc_get_tx_max_agg_num(struct seq_file * m,void * v)2860 int proc_get_tx_max_agg_num(struct seq_file *m, void *v)
2861 {
2862 struct net_device *dev = m->private;
2863 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2864
2865
2866 if (padapter)
2867 RTW_PRINT_SEL(m, "tx max AMPDU num = 0x%02x\n", padapter->driver_tx_max_agg_num);
2868
2869 return 0;
2870 }
2871
proc_set_tx_max_agg_num(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2872 ssize_t proc_set_tx_max_agg_num(struct file *file, const char __user *buffer
2873 , size_t count, loff_t *pos, void *data)
2874 {
2875 struct net_device *dev = data;
2876 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2877 char tmp[32];
2878 u8 agg_num;
2879
2880 if (count < 1)
2881 return -EFAULT;
2882
2883 if (count > sizeof(tmp)) {
2884 rtw_warn_on(1);
2885 return -EFAULT;
2886 }
2887
2888 if (buffer && !copy_from_user(tmp, buffer, count)) {
2889
2890 int num = sscanf(tmp, "%hhx ", &agg_num);
2891
2892 if (padapter && (num == 1)) {
2893 RTW_INFO("padapter->driver_tx_max_agg_num = 0x%02x\n", agg_num);
2894
2895 padapter->driver_tx_max_agg_num = agg_num;
2896 }
2897 }
2898
2899 return count;
2900 }
2901
proc_get_rx_ampdu_density(struct seq_file * m,void * v)2902 int proc_get_rx_ampdu_density(struct seq_file *m, void *v)
2903 {
2904 struct net_device *dev = m->private;
2905 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2906
2907
2908 if (padapter)
2909 RTW_PRINT_SEL(m, "rx ampdu densityg = %x\n", padapter->driver_rx_ampdu_spacing);
2910
2911 return 0;
2912 }
2913
proc_set_rx_ampdu_density(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2914 ssize_t proc_set_rx_ampdu_density(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2915 {
2916 struct net_device *dev = data;
2917 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2918 char tmp[32];
2919 u32 density;
2920
2921 if (count < 1)
2922 return -EFAULT;
2923
2924 if (count > sizeof(tmp)) {
2925 rtw_warn_on(1);
2926 return -EFAULT;
2927 }
2928
2929 if (buffer && !copy_from_user(tmp, buffer, count)) {
2930
2931 int num = sscanf(tmp, "%d ", &density);
2932
2933 if (padapter && (num == 1)) {
2934 RTW_INFO("padapter->driver_rx_ampdu_spacing = %x\n", density);
2935
2936 if (density > 0x07)
2937 padapter->driver_rx_ampdu_spacing = 0xFF;
2938 else
2939 padapter->driver_rx_ampdu_spacing = density;
2940 }
2941 }
2942
2943 return count;
2944 }
2945
proc_get_tx_ampdu_density(struct seq_file * m,void * v)2946 int proc_get_tx_ampdu_density(struct seq_file *m, void *v)
2947 {
2948 struct net_device *dev = m->private;
2949 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2950
2951
2952 if (padapter)
2953 RTW_PRINT_SEL(m, "tx ampdu density = %x\n", padapter->driver_ampdu_spacing);
2954
2955 return 0;
2956 }
2957
proc_set_tx_ampdu_density(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2958 ssize_t proc_set_tx_ampdu_density(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2959 {
2960 struct net_device *dev = data;
2961 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2962 char tmp[32];
2963 u32 density;
2964
2965 if (count < 1)
2966 return -EFAULT;
2967
2968 if (count > sizeof(tmp)) {
2969 rtw_warn_on(1);
2970 return -EFAULT;
2971 }
2972
2973 if (buffer && !copy_from_user(tmp, buffer, count)) {
2974
2975 int num = sscanf(tmp, "%d ", &density);
2976
2977 if (padapter && (num == 1)) {
2978 RTW_INFO("padapter->driver_ampdu_spacing = %x\n", density);
2979
2980 if (density > 0x07)
2981 padapter->driver_ampdu_spacing = 0xFF;
2982 else
2983 padapter->driver_ampdu_spacing = density;
2984 }
2985 }
2986
2987 return count;
2988 }
2989
2990 #ifdef CONFIG_TX_AMSDU
proc_get_tx_amsdu(struct seq_file * m,void * v)2991 int proc_get_tx_amsdu(struct seq_file *m, void *v)
2992 {
2993 struct net_device *dev = m->private;
2994 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2995 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
2996
2997 if (padapter)
2998 {
2999 RTW_PRINT_SEL(m, "tx amsdu = %d\n", padapter->tx_amsdu);
3000 RTW_PRINT_SEL(m, "amsdu set timer conut = %u\n", pxmitpriv->amsdu_debug_set_timer);
3001 RTW_PRINT_SEL(m, "amsdu time out count = %u\n", pxmitpriv->amsdu_debug_timeout);
3002 RTW_PRINT_SEL(m, "amsdu coalesce one count = %u\n", pxmitpriv->amsdu_debug_coalesce_one);
3003 RTW_PRINT_SEL(m, "amsdu coalesce two count = %u\n", pxmitpriv->amsdu_debug_coalesce_two);
3004 }
3005
3006 return 0;
3007 }
3008
proc_set_tx_amsdu(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3009 ssize_t proc_set_tx_amsdu(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3010 {
3011 struct net_device *dev = data;
3012 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3013 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3014 char tmp[32];
3015 u32 amsdu;
3016
3017 if (count < 1)
3018 return -EFAULT;
3019
3020 if (count > sizeof(tmp)) {
3021 rtw_warn_on(1);
3022 return -EFAULT;
3023 }
3024
3025 if (buffer && !copy_from_user(tmp, buffer, count)) {
3026
3027 int num = sscanf(tmp, "%d ", &amsdu);
3028
3029 if (padapter && (num == 1)) {
3030 RTW_INFO("padapter->tx_amsdu = %x\n", amsdu);
3031
3032 if (amsdu > 3)
3033 padapter->tx_amsdu = 0;
3034 else if(amsdu == 3)
3035 {
3036 pxmitpriv->amsdu_debug_set_timer = 0;
3037 pxmitpriv->amsdu_debug_timeout = 0;
3038 pxmitpriv->amsdu_debug_coalesce_one = 0;
3039 pxmitpriv->amsdu_debug_coalesce_two = 0;
3040 }
3041 else
3042 padapter->tx_amsdu = amsdu;
3043 }
3044 }
3045
3046 return count;
3047 }
3048
proc_get_tx_amsdu_rate(struct seq_file * m,void * v)3049 int proc_get_tx_amsdu_rate(struct seq_file *m, void *v)
3050 {
3051 struct net_device *dev = m->private;
3052 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3053
3054 if (padapter)
3055 RTW_PRINT_SEL(m, "tx amsdu rate = %d Mbps\n", padapter->tx_amsdu_rate);
3056
3057 return 0;
3058 }
3059
proc_set_tx_amsdu_rate(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3060 ssize_t proc_set_tx_amsdu_rate(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3061 {
3062 struct net_device *dev = data;
3063 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3064 char tmp[32];
3065 u32 amsdu_rate;
3066
3067 if (count < 1)
3068 return -EFAULT;
3069
3070 if (count > sizeof(tmp)) {
3071 rtw_warn_on(1);
3072 return -EFAULT;
3073 }
3074
3075 if (buffer && !copy_from_user(tmp, buffer, count)) {
3076
3077 int num = sscanf(tmp, "%d ", &amsdu_rate);
3078
3079 if (padapter && (num == 1)) {
3080 RTW_INFO("padapter->tx_amsdu_rate = %x\n", amsdu_rate);
3081 padapter->tx_amsdu_rate = amsdu_rate;
3082 }
3083 }
3084
3085 return count;
3086 }
3087 #endif /* CONFIG_TX_AMSDU */
3088 #endif /* CONFIG_80211N_HT */
3089
proc_get_en_fwps(struct seq_file * m,void * v)3090 int proc_get_en_fwps(struct seq_file *m, void *v)
3091 {
3092 struct net_device *dev = m->private;
3093 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3094 struct registry_priv *pregpriv = &padapter->registrypriv;
3095 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3096 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3097
3098 if (pregpriv)
3099 RTW_PRINT_SEL(m, "check_fw_ps = %d , 1:enable get FW PS state , 0: disable get FW PS state\n"
3100 , pregpriv->check_fw_ps);
3101
3102 return 0;
3103 }
3104
proc_set_en_fwps(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3105 ssize_t proc_set_en_fwps(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3106 {
3107 struct net_device *dev = data;
3108 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3109 struct registry_priv *pregpriv = &padapter->registrypriv;
3110 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3111 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3112 char tmp[32];
3113 u32 mode;
3114
3115 if (count < 1)
3116 return -EFAULT;
3117
3118 if (count > sizeof(tmp)) {
3119 rtw_warn_on(1);
3120 return -EFAULT;
3121 }
3122
3123 if (buffer && !copy_from_user(tmp, buffer, count)) {
3124
3125 int num = sscanf(tmp, "%d ", &mode);
3126
3127 if (pregpriv && mode < 2) {
3128 pregpriv->check_fw_ps = mode;
3129 RTW_INFO("pregpriv->check_fw_ps=%d\n", pregpriv->check_fw_ps);
3130 }
3131
3132 }
3133
3134 return count;
3135 }
3136
3137 /*
3138 int proc_get_two_path_rssi(struct seq_file *m, void *v)
3139 {
3140 struct net_device *dev = m->private;
3141 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3142
3143 if(padapter)
3144 RTW_PRINT_SEL(m, "%d %d\n",
3145 padapter->recvpriv.RxRssi[0], padapter->recvpriv.RxRssi[1]);
3146
3147 return 0;
3148 }
3149 */
3150 #ifdef CONFIG_80211N_HT
rtw_dump_dft_phy_cap(void * sel,_adapter * adapter)3151 void rtw_dump_dft_phy_cap(void *sel, _adapter *adapter)
3152 {
3153 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
3154 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
3155 #ifdef CONFIG_80211AC_VHT
3156 struct vht_priv *pvhtpriv = &pmlmepriv->vhtpriv;
3157 #endif
3158
3159 #ifdef CONFIG_80211AC_VHT
3160 RTW_PRINT_SEL(sel, "[DFT CAP] VHT STBC Tx : %s\n", (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_TX)) ? "V" : "X");
3161 RTW_PRINT_SEL(sel, "[DFT CAP] VHT STBC Rx : %s\n", (TEST_FLAG(pvhtpriv->stbc_cap, STBC_VHT_ENABLE_RX)) ? "V" : "X");
3162 #endif
3163 RTW_PRINT_SEL(sel, "[DFT CAP] HT STBC Tx : %s\n", (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX)) ? "V" : "X");
3164 RTW_PRINT_SEL(sel, "[DFT CAP] HT STBC Rx : %s\n\n", (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX)) ? "V" : "X");
3165
3166 #ifdef CONFIG_80211AC_VHT
3167 RTW_PRINT_SEL(sel, "[DFT CAP] VHT LDPC Tx : %s\n", (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_TX)) ? "V" : "X");
3168 RTW_PRINT_SEL(sel, "[DFT CAP] VHT LDPC Rx : %s\n", (TEST_FLAG(pvhtpriv->ldpc_cap, LDPC_VHT_ENABLE_RX)) ? "V" : "X");
3169 #endif
3170 RTW_PRINT_SEL(sel, "[DFT CAP] HT LDPC Tx : %s\n", (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX)) ? "V" : "X");
3171 RTW_PRINT_SEL(sel, "[DFT CAP] HT LDPC Rx : %s\n\n", (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX)) ? "V" : "X");
3172
3173 #ifdef CONFIG_BEAMFORMING
3174 #ifdef CONFIG_80211AC_VHT
3175 RTW_PRINT_SEL(sel, "[DFT CAP] VHT MU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_AP_ENABLE)) ? "V" : "X");
3176 RTW_PRINT_SEL(sel, "[DFT CAP] VHT MU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_MU_MIMO_STA_ENABLE)) ? "V" : "X");
3177 RTW_PRINT_SEL(sel, "[DFT CAP] VHT SU Bfer : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMER_ENABLE)) ? "V" : "X");
3178 RTW_PRINT_SEL(sel, "[DFT CAP] VHT SU Bfee : %s\n", (TEST_FLAG(pvhtpriv->beamform_cap, BEAMFORMING_VHT_BEAMFORMEE_ENABLE)) ? "V" : "X");
3179 #endif
3180 RTW_PRINT_SEL(sel, "[DFT CAP] HT Bfer : %s\n", (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE)) ? "V" : "X");
3181 RTW_PRINT_SEL(sel, "[DFT CAP] HT Bfee : %s\n", (TEST_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE)) ? "V" : "X");
3182 #endif
3183 }
3184
rtw_get_dft_phy_cap(void * sel,_adapter * adapter)3185 void rtw_get_dft_phy_cap(void *sel, _adapter *adapter)
3186 {
3187 RTW_PRINT_SEL(sel, "\n ======== PHY CAP protocol ========\n");
3188 rtw_ht_use_default_setting(adapter);
3189 #ifdef CONFIG_80211AC_VHT
3190 rtw_vht_use_default_setting(adapter);
3191 #endif
3192 rtw_dump_dft_phy_cap(sel, adapter);
3193 }
3194
rtw_dump_drv_phy_cap(void * sel,_adapter * adapter)3195 void rtw_dump_drv_phy_cap(void *sel, _adapter *adapter)
3196 {
3197 struct registry_priv *pregistry_priv = &adapter->registrypriv;
3198
3199 RTW_PRINT_SEL(sel, "\n ======== DRV's configuration ========\n");
3200 #if 0
3201 RTW_PRINT_SEL(sel, "[DRV CAP] TRx Capability : 0x%08x\n", phy_spec->trx_cap);
3202 RTW_PRINT_SEL(sel, "[DRV CAP] Tx Stream Num Index : %d\n", (phy_spec->trx_cap >> 24) & 0xFF); /*Tx Stream Num Index [31:24]*/
3203 RTW_PRINT_SEL(sel, "[DRV CAP] Rx Stream Num Index : %d\n", (phy_spec->trx_cap >> 16) & 0xFF); /*Rx Stream Num Index [23:16]*/
3204 RTW_PRINT_SEL(sel, "[DRV CAP] Tx Path Num Index : %d\n", (phy_spec->trx_cap >> 8) & 0xFF);/*Tx Path Num Index [15:8]*/
3205 RTW_PRINT_SEL(sel, "[DRV CAP] Rx Path Num Index : %d\n", (phy_spec->trx_cap & 0xFF));/*Rx Path Num Index [7:0]*/
3206 #endif
3207
3208 RTW_PRINT_SEL(sel, "[DRV CAP] STBC Capability : 0x%02x\n", pregistry_priv->stbc_cap);
3209 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*/
3210 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*/
3211 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*/
3212 RTW_PRINT_SEL(sel, "[DRV CAP] HT STBC Rx : %s\n\n", (TEST_FLAG(pregistry_priv->stbc_cap, BIT4)) ? "V" : "X"); /*BIT4: Enable HT STBC Rx*/
3213
3214 RTW_PRINT_SEL(sel, "[DRV CAP] LDPC Capability : 0x%02x\n", pregistry_priv->ldpc_cap);
3215 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*/
3216 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*/
3217 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*/
3218 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*/
3219 #ifdef CONFIG_BEAMFORMING
3220 #if 0
3221 RTW_PRINT_SEL(sel, "[DRV CAP] TxBF parameter : 0x%08x\n", phy_spec->txbf_param);
3222 RTW_PRINT_SEL(sel, "[DRV CAP] VHT Sounding Dim : %d\n", (phy_spec->txbf_param >> 24) & 0xFF); /*VHT Sounding Dim [31:24]*/
3223 RTW_PRINT_SEL(sel, "[DRV CAP] VHT Steering Ant : %d\n", (phy_spec->txbf_param >> 16) & 0xFF); /*VHT Steering Ant [23:16]*/
3224 RTW_PRINT_SEL(sel, "[DRV CAP] HT Sounding Dim : %d\n", (phy_spec->txbf_param >> 8) & 0xFF); /*HT Sounding Dim [15:8]*/
3225 RTW_PRINT_SEL(sel, "[DRV CAP] HT Steering Ant : %d\n", phy_spec->txbf_param & 0xFF); /*HT Steering Ant [7:0]*/
3226 #endif
3227
3228 /*
3229 * BIT0: Enable VHT SU Beamformer
3230 * BIT1: Enable VHT SU Beamformee
3231 * BIT2: Enable VHT MU Beamformer, depend on VHT SU Beamformer
3232 * BIT3: Enable VHT MU Beamformee, depend on VHT SU Beamformee
3233 * BIT4: Enable HT Beamformer
3234 * BIT5: Enable HT Beamformee
3235 */
3236 RTW_PRINT_SEL(sel, "[DRV CAP] TxBF Capability : 0x%02x\n", pregistry_priv->beamform_cap);
3237 RTW_PRINT_SEL(sel, "[DRV CAP] VHT MU Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT2)) ? "V" : "X");
3238 RTW_PRINT_SEL(sel, "[DRV CAP] VHT MU Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT3)) ? "V" : "X");
3239 RTW_PRINT_SEL(sel, "[DRV CAP] VHT SU Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT0)) ? "V" : "X");
3240 RTW_PRINT_SEL(sel, "[DRV CAP] VHT SU Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT1)) ? "V" : "X");
3241 RTW_PRINT_SEL(sel, "[DRV CAP] HT Bfer : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT4)) ? "V" : "X");
3242 RTW_PRINT_SEL(sel, "[DRV CAP] HT Bfee : %s\n", (TEST_FLAG(pregistry_priv->beamform_cap, BIT5)) ? "V" : "X");
3243
3244 RTW_PRINT_SEL(sel, "[DRV CAP] Tx Bfer rf_num : %d\n", pregistry_priv->beamformer_rf_num);
3245 RTW_PRINT_SEL(sel, "[DRV CAP] Tx Bfee rf_num : %d\n", pregistry_priv->beamformee_rf_num);
3246 #endif
3247 }
3248
proc_get_stbc_cap(struct seq_file * m,void * v)3249 int proc_get_stbc_cap(struct seq_file *m, void *v)
3250 {
3251 struct net_device *dev = m->private;
3252 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3253 struct registry_priv *pregpriv = &padapter->registrypriv;
3254
3255 if (pregpriv)
3256 RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->stbc_cap);
3257
3258 return 0;
3259 }
3260
proc_set_stbc_cap(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3261 ssize_t proc_set_stbc_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3262 {
3263 struct net_device *dev = data;
3264 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3265 struct registry_priv *pregpriv = &padapter->registrypriv;
3266 char tmp[32];
3267 u32 mode;
3268
3269 if (count < 1)
3270 return -EFAULT;
3271
3272 if (count > sizeof(tmp)) {
3273 rtw_warn_on(1);
3274 return -EFAULT;
3275 }
3276
3277 if (buffer && !copy_from_user(tmp, buffer, count)) {
3278
3279 int num = sscanf(tmp, "%d ", &mode);
3280
3281 if (pregpriv) {
3282 pregpriv->stbc_cap = mode;
3283 RTW_INFO("stbc_cap = 0x%02x\n", mode);
3284 }
3285 }
3286
3287 return count;
3288 }
proc_get_rx_stbc(struct seq_file * m,void * v)3289 int proc_get_rx_stbc(struct seq_file *m, void *v)
3290 {
3291 struct net_device *dev = m->private;
3292 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3293 struct registry_priv *pregpriv = &padapter->registrypriv;
3294
3295 if (pregpriv)
3296 RTW_PRINT_SEL(m, "%d\n", pregpriv->rx_stbc);
3297
3298 return 0;
3299 }
3300
proc_set_rx_stbc(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3301 ssize_t proc_set_rx_stbc(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3302 {
3303 struct net_device *dev = data;
3304 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3305 struct registry_priv *pregpriv = &padapter->registrypriv;
3306 char tmp[32];
3307 u32 mode;
3308
3309 if (count < 1)
3310 return -EFAULT;
3311
3312 if (count > sizeof(tmp)) {
3313 rtw_warn_on(1);
3314 return -EFAULT;
3315 }
3316
3317 if (buffer && !copy_from_user(tmp, buffer, count)) {
3318
3319 int num = sscanf(tmp, "%d ", &mode);
3320
3321 if (pregpriv && (mode == 0 || mode == 1 || mode == 2 || mode == 3)) {
3322 pregpriv->rx_stbc = mode;
3323 printk("rx_stbc=%d\n", mode);
3324 }
3325 }
3326
3327 return count;
3328
3329 }
proc_get_ldpc_cap(struct seq_file * m,void * v)3330 int proc_get_ldpc_cap(struct seq_file *m, void *v)
3331 {
3332 struct net_device *dev = m->private;
3333 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3334 struct registry_priv *pregpriv = &padapter->registrypriv;
3335
3336 if (pregpriv)
3337 RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->ldpc_cap);
3338
3339 return 0;
3340 }
3341
proc_set_ldpc_cap(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3342 ssize_t proc_set_ldpc_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3343 {
3344 struct net_device *dev = data;
3345 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3346 struct registry_priv *pregpriv = &padapter->registrypriv;
3347 char tmp[32];
3348 u32 mode;
3349
3350 if (count < 1)
3351 return -EFAULT;
3352
3353 if (count > sizeof(tmp)) {
3354 rtw_warn_on(1);
3355 return -EFAULT;
3356 }
3357
3358 if (buffer && !copy_from_user(tmp, buffer, count)) {
3359
3360 int num = sscanf(tmp, "%d ", &mode);
3361
3362 if (pregpriv) {
3363 pregpriv->ldpc_cap = mode;
3364 RTW_INFO("ldpc_cap = 0x%02x\n", mode);
3365 }
3366 }
3367
3368 return count;
3369 }
3370 #ifdef CONFIG_BEAMFORMING
proc_get_txbf_cap(struct seq_file * m,void * v)3371 int proc_get_txbf_cap(struct seq_file *m, void *v)
3372 {
3373 struct net_device *dev = m->private;
3374 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3375 struct registry_priv *pregpriv = &padapter->registrypriv;
3376
3377 if (pregpriv)
3378 RTW_PRINT_SEL(m, "0x%02x\n", pregpriv->beamform_cap);
3379
3380 return 0;
3381 }
3382
proc_set_txbf_cap(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3383 ssize_t proc_set_txbf_cap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3384 {
3385 struct net_device *dev = data;
3386 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3387 struct registry_priv *pregpriv = &padapter->registrypriv;
3388 char tmp[32];
3389 u32 mode;
3390
3391 if (count < 1)
3392 return -EFAULT;
3393
3394 if (count > sizeof(tmp)) {
3395 rtw_warn_on(1);
3396 return -EFAULT;
3397 }
3398
3399 if (buffer && !copy_from_user(tmp, buffer, count)) {
3400
3401 int num = sscanf(tmp, "%d ", &mode);
3402
3403 if (pregpriv) {
3404 pregpriv->beamform_cap = mode;
3405 RTW_INFO("beamform_cap = 0x%02x\n", mode);
3406 }
3407 }
3408
3409 return count;
3410 }
3411 #endif
3412 #endif /* CONFIG_80211N_HT */
3413
3414 /*int proc_get_rssi_disp(struct seq_file *m, void *v)
3415 {
3416 struct net_device *dev = m->private;
3417 return 0;
3418 }
3419 */
3420
3421 /*ssize_t proc_set_rssi_disp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3422 {
3423 struct net_device *dev = data;
3424 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3425 char tmp[32];
3426 u32 enable=0;
3427
3428 if (count < 1)
3429 {
3430 RTW_INFO("argument size is less than 1\n");
3431 return -EFAULT;
3432 }
3433
3434 if (count > sizeof(tmp)) {
3435 rtw_warn_on(1);
3436 return -EFAULT;
3437 }
3438
3439 if (buffer && !copy_from_user(tmp, buffer, count)) {
3440
3441 int num = sscanf(tmp, "%x", &enable);
3442
3443 if (num != 1) {
3444 RTW_INFO("invalid set_rssi_disp parameter!\n");
3445 return count;
3446 }
3447
3448 if(enable)
3449 {
3450 RTW_INFO("Linked info Function Enable\n");
3451 padapter->bLinkInfoDump = enable ;
3452 }
3453 else
3454 {
3455 RTW_INFO("Linked info Function Disable\n");
3456 padapter->bLinkInfoDump = 0 ;
3457 }
3458
3459 }
3460
3461 return count;
3462
3463 }
3464
3465 */
3466 #ifdef CONFIG_AP_MODE
3467
proc_get_all_sta_info(struct seq_file * m,void * v)3468 int proc_get_all_sta_info(struct seq_file *m, void *v)
3469 {
3470 struct net_device *dev = m->private;
3471 _irqL irqL;
3472 struct sta_info *psta;
3473 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3474 struct sta_priv *pstapriv = &padapter->stapriv;
3475 int i;
3476 _list *plist, *phead;
3477
3478 RTW_PRINT_SEL(m, "sta_dz_bitmap=0x%x, tim_bitmap=0x%x\n", pstapriv->sta_dz_bitmap, pstapriv->tim_bitmap);
3479
3480 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
3481
3482 for (i = 0; i < NUM_STA; i++) {
3483 phead = &(pstapriv->sta_hash[i]);
3484 plist = get_next(phead);
3485
3486 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
3487 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
3488
3489 plist = get_next(plist);
3490
3491 /* if(extra_arg == psta->cmn.aid) */
3492 {
3493 RTW_PRINT_SEL(m, "==============================\n");
3494 RTW_PRINT_SEL(m, "sta's macaddr:" MAC_FMT "\n", MAC_ARG(psta->cmn.mac_addr));
3495 RTW_PRINT_SEL(m, "rtsen=%d, cts2slef=%d\n", psta->rtsen, psta->cts2self);
3496 RTW_PRINT_SEL(m, "state=0x%x, aid=%d, macid=%d, raid=%d\n",
3497 psta->state, psta->cmn.aid, psta->cmn.mac_id, psta->cmn.ra_info.rate_id);
3498 #ifdef CONFIG_80211N_HT
3499 RTW_PRINT_SEL(m, "qos_en=%d, ht_en=%d, init_rate=%d\n", psta->qos_option, psta->htpriv.ht_option, psta->init_rate);
3500 RTW_PRINT_SEL(m, "bwmode=%d, ch_offset=%d, sgi_20m=%d,sgi_40m=%d\n"
3501 , psta->cmn.bw_mode, psta->htpriv.ch_offset, psta->htpriv.sgi_20m, psta->htpriv.sgi_40m);
3502 RTW_PRINT_SEL(m, "ampdu_enable = %d\n", psta->htpriv.ampdu_enable);
3503 RTW_PRINT_SEL(m, "tx_amsdu_enable = %d\n", psta->htpriv.tx_amsdu_enable);
3504 RTW_PRINT_SEL(m, "agg_enable_bitmap=%x, candidate_tid_bitmap=%x\n", psta->htpriv.agg_enable_bitmap, psta->htpriv.candidate_tid_bitmap);
3505 #endif /* CONFIG_80211N_HT */
3506 RTW_PRINT_SEL(m, "sleepq_len=%d\n", psta->sleepq_len);
3507 RTW_PRINT_SEL(m, "sta_xmitpriv.vo_q_qcnt=%d\n", psta->sta_xmitpriv.vo_q.qcnt);
3508 RTW_PRINT_SEL(m, "sta_xmitpriv.vi_q_qcnt=%d\n", psta->sta_xmitpriv.vi_q.qcnt);
3509 RTW_PRINT_SEL(m, "sta_xmitpriv.be_q_qcnt=%d\n", psta->sta_xmitpriv.be_q.qcnt);
3510 RTW_PRINT_SEL(m, "sta_xmitpriv.bk_q_qcnt=%d\n", psta->sta_xmitpriv.bk_q.qcnt);
3511
3512 RTW_PRINT_SEL(m, "capability=0x%x\n", psta->capability);
3513 RTW_PRINT_SEL(m, "flags=0x%x\n", psta->flags);
3514 RTW_PRINT_SEL(m, "wpa_psk=0x%x\n", psta->wpa_psk);
3515 RTW_PRINT_SEL(m, "wpa2_group_cipher=0x%x\n", psta->wpa2_group_cipher);
3516 RTW_PRINT_SEL(m, "wpa2_pairwise_cipher=0x%x\n", psta->wpa2_pairwise_cipher);
3517 RTW_PRINT_SEL(m, "qos_info=0x%x\n", psta->qos_info);
3518 RTW_PRINT_SEL(m, "dot118021XPrivacy=0x%x\n", psta->dot118021XPrivacy);
3519
3520 sta_rx_reorder_ctl_dump(m, psta);
3521
3522 #ifdef CONFIG_TDLS
3523 RTW_PRINT_SEL(m, "tdls_sta_state=0x%08x\n", psta->tdls_sta_state);
3524 RTW_PRINT_SEL(m, "PeerKey_Lifetime=%d\n", psta->TDLS_PeerKey_Lifetime);
3525 #endif /* CONFIG_TDLS */
3526 RTW_PRINT_SEL(m, "rx_data_pkts=%llu\n", psta->sta_stats.rx_data_pkts);
3527 RTW_PRINT_SEL(m, "rx_bytes=%llu\n", psta->sta_stats.rx_bytes);
3528 RTW_PRINT_SEL(m, "rx_avg_tp =%d (Bps)\n", psta->cmn.rx_moving_average_tp);
3529
3530 RTW_PRINT_SEL(m, "tx_data_pkts=%llu\n", psta->sta_stats.tx_pkts);
3531 RTW_PRINT_SEL(m, "tx_bytes=%llu\n", psta->sta_stats.tx_bytes);
3532 RTW_PRINT_SEL(m, "tx_avg_tp =%d (MBps)\n", psta->cmn.tx_moving_average_tp);
3533
3534 dump_st_ctl(m, &psta->st_ctl);
3535
3536 if (STA_OP_WFD_MODE(psta))
3537 RTW_PRINT_SEL(m, "op_wfd_mode:0x%02x\n", STA_OP_WFD_MODE(psta));
3538
3539 RTW_PRINT_SEL(m, "==============================\n");
3540 }
3541
3542 }
3543
3544 }
3545
3546 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
3547
3548 return 0;
3549 }
3550
3551 #endif
3552
3553 #ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
proc_get_rtkm_info(struct seq_file * m,void * v)3554 int proc_get_rtkm_info(struct seq_file *m, void *v)
3555 {
3556 struct net_device *dev = m->private;
3557 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3558 struct recv_priv *precvpriv = &padapter->recvpriv;
3559 struct recv_buf *precvbuf;
3560
3561 precvbuf = (struct recv_buf *)precvpriv->precv_buf;
3562
3563 RTW_PRINT_SEL(m, "============[RTKM Info]============\n");
3564 RTW_PRINT_SEL(m, "MAX_RTKM_NR_PREALLOC_RECV_SKB: %d\n", rtw_rtkm_get_nr_recv_skb());
3565 RTW_PRINT_SEL(m, "MAX_RTKM_RECVBUF_SZ: %d\n", rtw_rtkm_get_buff_size());
3566
3567 RTW_PRINT_SEL(m, "============[Driver Info]============\n");
3568 RTW_PRINT_SEL(m, "NR_PREALLOC_RECV_SKB: %d\n", NR_PREALLOC_RECV_SKB);
3569 RTW_PRINT_SEL(m, "MAX_RECVBUF_SZ: %d\n", precvbuf->alloc_sz);
3570
3571 return 0;
3572 }
3573 #endif /* CONFIG_PREALLOC_RX_SKB_BUFFER */
3574
3575 #ifdef DBG_MEMORY_LEAK
3576 #include <asm/atomic.h>
3577 extern atomic_t _malloc_cnt;;
3578 extern atomic_t _malloc_size;;
3579
proc_get_malloc_cnt(struct seq_file * m,void * v)3580 int proc_get_malloc_cnt(struct seq_file *m, void *v)
3581 {
3582 RTW_PRINT_SEL(m, "_malloc_cnt=%d\n", atomic_read(&_malloc_cnt));
3583 RTW_PRINT_SEL(m, "_malloc_size=%d\n", atomic_read(&_malloc_size));
3584
3585 return 0;
3586 }
3587 #endif /* DBG_MEMORY_LEAK */
3588
3589 #ifdef CONFIG_FIND_BEST_CHANNEL
proc_get_best_channel(struct seq_file * m,void * v)3590 int proc_get_best_channel(struct seq_file *m, void *v)
3591 {
3592 struct net_device *dev = m->private;
3593 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3594 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
3595 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3596 u32 i, best_channel_24G = 1, best_channel_5G = 36, index_24G = 0, index_5G = 0;
3597
3598 for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++) {
3599 if (rfctl->channel_set[i].ChannelNum == 1)
3600 index_24G = i;
3601 if (rfctl->channel_set[i].ChannelNum == 36)
3602 index_5G = i;
3603 }
3604
3605 for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++) {
3606 /* 2.4G */
3607 if (rfctl->channel_set[i].ChannelNum == 6) {
3608 if (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_24G].rx_count) {
3609 index_24G = i;
3610 best_channel_24G = rfctl->channel_set[i].ChannelNum;
3611 }
3612 }
3613
3614 /* 5G */
3615 if (rfctl->channel_set[i].ChannelNum >= 36
3616 && rfctl->channel_set[i].ChannelNum < 140) {
3617 /* Find primary channel */
3618 if (((rfctl->channel_set[i].ChannelNum - 36) % 8 == 0)
3619 && (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_5G].rx_count)) {
3620 index_5G = i;
3621 best_channel_5G = rfctl->channel_set[i].ChannelNum;
3622 }
3623 }
3624
3625 if (rfctl->channel_set[i].ChannelNum >= 149
3626 && rfctl->channel_set[i].ChannelNum < 165) {
3627 /* find primary channel */
3628 if (((rfctl->channel_set[i].ChannelNum - 149) % 8 == 0)
3629 && (rfctl->channel_set[i].rx_count < rfctl->channel_set[index_5G].rx_count)) {
3630 index_5G = i;
3631 best_channel_5G = rfctl->channel_set[i].ChannelNum;
3632 }
3633 }
3634 #if 1 /* debug */
3635 RTW_PRINT_SEL(m, "The rx cnt of channel %3d = %d\n",
3636 rfctl->channel_set[i].ChannelNum, rfctl->channel_set[i].rx_count);
3637 #endif
3638 }
3639
3640 RTW_PRINT_SEL(m, "best_channel_5G = %d\n", best_channel_5G);
3641 RTW_PRINT_SEL(m, "best_channel_24G = %d\n", best_channel_24G);
3642
3643 return 0;
3644 }
3645
proc_set_best_channel(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3646 ssize_t proc_set_best_channel(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3647 {
3648 struct net_device *dev = data;
3649 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3650 struct rf_ctl_t *rfctl = adapter_to_rfctl(padapter);
3651 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3652 char tmp[32];
3653
3654 if (count < 1)
3655 return -EFAULT;
3656
3657 if (count > sizeof(tmp)) {
3658 rtw_warn_on(1);
3659 return -EFAULT;
3660 }
3661
3662 if (buffer && !copy_from_user(tmp, buffer, count)) {
3663 int i;
3664 for (i = 0; i < rfctl->max_chan_nums && rfctl->channel_set[i].ChannelNum != 0; i++)
3665 rfctl->channel_set[i].rx_count = 0;
3666
3667 RTW_INFO("set %s\n", "Clean Best Channel Count");
3668 }
3669
3670 return count;
3671 }
3672 #endif /* CONFIG_FIND_BEST_CHANNEL */
3673
3674 #ifdef CONFIG_BT_COEXIST
proc_get_btcoex_dbg(struct seq_file * m,void * v)3675 int proc_get_btcoex_dbg(struct seq_file *m, void *v)
3676 {
3677 struct net_device *dev = m->private;
3678 PADAPTER padapter;
3679 char buf[512] = {0};
3680 padapter = (PADAPTER)rtw_netdev_priv(dev);
3681
3682 rtw_btcoex_GetDBG(padapter, buf, 512);
3683
3684 _RTW_PRINT_SEL(m, "%s", buf);
3685
3686 return 0;
3687 }
3688
proc_set_btcoex_dbg(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3689 ssize_t proc_set_btcoex_dbg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3690 {
3691 struct net_device *dev = data;
3692 PADAPTER padapter;
3693 u8 tmp[80] = {0};
3694 u32 module[2] = {0};
3695 u32 num;
3696
3697 padapter = (PADAPTER)rtw_netdev_priv(dev);
3698
3699 /* RTW_INFO("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter)); */
3700
3701 if (NULL == buffer) {
3702 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n",
3703 FUNC_ADPT_ARG(padapter));
3704
3705 return -EFAULT;
3706 }
3707
3708 if (count < 1) {
3709 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n",
3710 FUNC_ADPT_ARG(padapter));
3711
3712 return -EFAULT;
3713 }
3714
3715 num = count;
3716 if (num > (sizeof(tmp) - 1))
3717 num = (sizeof(tmp) - 1);
3718
3719 if (copy_from_user(tmp, buffer, num)) {
3720 RTW_INFO(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
3721 FUNC_ADPT_ARG(padapter));
3722
3723 return -EFAULT;
3724 }
3725
3726 num = sscanf(tmp, "%x %x", module, module + 1);
3727 if (1 == num) {
3728 if (0 == module[0])
3729 _rtw_memset(module, 0, sizeof(module));
3730 else
3731 _rtw_memset(module, 0xFF, sizeof(module));
3732 } else if (2 != num) {
3733 RTW_INFO(FUNC_ADPT_FMT ": input(\"%s\") format incorrect!\n",
3734 FUNC_ADPT_ARG(padapter), tmp);
3735
3736 if (0 == num)
3737 return -EFAULT;
3738 }
3739
3740 RTW_INFO(FUNC_ADPT_FMT ": input 0x%08X 0x%08X\n",
3741 FUNC_ADPT_ARG(padapter), module[0], module[1]);
3742 rtw_btcoex_SetDBG(padapter, module);
3743
3744 return count;
3745 }
3746
proc_get_btcoex_info(struct seq_file * m,void * v)3747 int proc_get_btcoex_info(struct seq_file *m, void *v)
3748 {
3749 struct net_device *dev = m->private;
3750 PADAPTER padapter;
3751 const u32 bufsize = 30 * 100;
3752 u8 *pbuf = NULL;
3753
3754 padapter = (PADAPTER)rtw_netdev_priv(dev);
3755
3756 pbuf = rtw_zmalloc(bufsize);
3757 if (NULL == pbuf)
3758 return -ENOMEM;
3759
3760 rtw_btcoex_DisplayBtCoexInfo(padapter, pbuf, bufsize);
3761
3762 _RTW_PRINT_SEL(m, "%s\n", pbuf);
3763
3764 rtw_mfree(pbuf, bufsize);
3765
3766 return 0;
3767 }
3768
3769 #ifdef CONFIG_RF4CE_COEXIST
proc_get_rf4ce_state(struct seq_file * m,void * v)3770 int proc_get_rf4ce_state(struct seq_file *m, void *v)
3771 {
3772 struct net_device *dev = m->private;
3773 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3774 u8 state = 0, voice = 0;
3775
3776 state = rtw_btcoex_GetRf4ceLinkState(adapter);
3777
3778 RTW_PRINT_SEL(m, "RF4CE %s\n", state?"Connected":"Disconnect");
3779
3780 return 0;
3781 }
3782
3783 /* This interface is designed for user space application to inform RF4CE state
3784 * Initial define for DHC 1295 E387 project
3785 *
3786 * echo state voice > rf4ce_state
3787 * state
3788 * 0: RF4CE disconnected
3789 * 1: RF4CE connected
3790 */
proc_set_rf4ce_state(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3791 ssize_t proc_set_rf4ce_state(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3792 {
3793 struct net_device *dev = data;
3794 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3795 char tmp[32];
3796 u8 state;
3797
3798 if (count < 1)
3799 return -EFAULT;
3800
3801 if (count > sizeof(tmp)) {
3802 rtw_warn_on(1);
3803 return -EFAULT;
3804 }
3805
3806 if (buffer && !copy_from_user(tmp, buffer, count)) {
3807
3808 int num = sscanf(tmp, "%hhx", &state);
3809
3810 if (num >= 1)
3811 rtw_btcoex_SetRf4ceLinkState(adapter, state);
3812 }
3813
3814 return count;
3815 }
3816 #endif /* CONFIG_RF4CE_COEXIST */
3817 #endif /* CONFIG_BT_COEXIST */
3818
3819 #if defined(DBG_CONFIG_ERROR_DETECT)
proc_get_sreset(struct seq_file * m,void * v)3820 int proc_get_sreset(struct seq_file *m, void *v)
3821 {
3822 struct net_device *dev = m->private;
3823 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3824 struct dvobj_priv *psdpriv = padapter->dvobj;
3825 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
3826 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
3827 struct sreset_priv *psrtpriv = &pHalData->srestpriv;
3828 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
3829
3830 if (psrtpriv->dbg_sreset_ctrl == _TRUE) {
3831 RTW_PRINT_SEL(m, "self_dect_tx_cnt:%llu\n", psrtpriv->self_dect_tx_cnt);
3832 RTW_PRINT_SEL(m, "self_dect_rx_cnt:%llu\n", psrtpriv->self_dect_rx_cnt);
3833 RTW_PRINT_SEL(m, "self_dect_fw_cnt:%llu\n", psrtpriv->self_dect_fw_cnt);
3834 RTW_PRINT_SEL(m, "tx_dma_status_cnt:%llu\n", psrtpriv->tx_dma_status_cnt);
3835 RTW_PRINT_SEL(m, "rx_dma_status_cnt:%llu\n", psrtpriv->rx_dma_status_cnt);
3836 RTW_PRINT_SEL(m, "self_dect_case:%d\n", psrtpriv->self_dect_case);
3837 RTW_PRINT_SEL(m, "dbg_sreset_cnt:%d\n", pdbgpriv->dbg_sreset_cnt);
3838 }
3839 return 0;
3840 }
3841
proc_set_sreset(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3842 ssize_t proc_set_sreset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3843 {
3844 struct net_device *dev = data;
3845 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3846 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
3847 struct sreset_priv *psrtpriv = &pHalData->srestpriv;
3848 char tmp[32];
3849 s32 trigger_point;
3850
3851 if (count < 1)
3852 return -EFAULT;
3853
3854 if (count > sizeof(tmp)) {
3855 rtw_warn_on(1);
3856 return -EFAULT;
3857 }
3858
3859 if (buffer && !copy_from_user(tmp, buffer, count)) {
3860
3861 int num = sscanf(tmp, "%d", &trigger_point);
3862
3863 if (trigger_point == SRESET_TGP_NULL)
3864 rtw_hal_sreset_reset(padapter);
3865 else if (trigger_point == SRESET_TGP_INFO)
3866 psrtpriv->dbg_sreset_ctrl = _TRUE;
3867 else
3868 sreset_set_trigger_point(padapter, trigger_point);
3869 }
3870
3871 return count;
3872
3873 }
3874 #endif /* DBG_CONFIG_ERROR_DETECT */
3875
3876 #ifdef CONFIG_PCI_HCI
3877
proc_get_pci_aspm(struct seq_file * m,void * v)3878 int proc_get_pci_aspm(struct seq_file *m, void *v)
3879 {
3880 struct net_device *dev = m->private;
3881 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
3882 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
3883 HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
3884 struct pci_priv *pcipriv = &(pdvobjpriv->pcipriv);
3885 u8 tmp8 = 0;
3886 u16 tmp16 = 0;
3887 u32 tmp32 = 0;
3888
3889
3890 RTW_PRINT_SEL(m, "***** ASPM Capability *****\n");
3891
3892 pci_read_config_dword(pdvobjpriv->ppcidev, pcipriv->pciehdr_offset + PCI_EXP_LNKCAP, &tmp32);
3893
3894 RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp32&PCI_EXP_LNKCAP_CLKPM) ? "Enable" : "Disable");
3895 RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp32&BIT10) ? "Enable" : "Disable");
3896 RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp32&BIT11) ? "Enable" : "Disable");
3897
3898 tmp8 = rtw_hal_pci_l1off_capability(padapter);
3899 RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", tmp8 ? "Enable" : "Disable");
3900
3901 RTW_PRINT_SEL(m, "***** ASPM CTRL Reg *****\n");
3902
3903 pci_read_config_word(pdvobjpriv->ppcidev, pcipriv->pciehdr_offset + PCI_EXP_LNKCTL, &tmp16);
3904
3905 RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp16&PCI_EXP_LNKCTL_CLKREQ_EN) ? "Enable" : "Disable");
3906 RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp16&BIT0) ? "Enable" : "Disable");
3907 RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp16&BIT1) ? "Enable" : "Disable");
3908
3909 tmp8 = rtw_hal_pci_l1off_nic_support(padapter);
3910 RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", tmp8 ? "Enable" : "Disable");
3911
3912 RTW_PRINT_SEL(m, "***** ASPM Backdoor *****\n");
3913
3914 tmp8 = rtw_hal_pci_dbi_read(padapter, 0x719);
3915 RTW_PRINT_SEL(m, "CLK REQ: %s\n", (tmp8 & BIT4) ? "Enable" : "Disable");
3916
3917 tmp8 = rtw_hal_pci_dbi_read(padapter, 0x70f);
3918 RTW_PRINT_SEL(m, "ASPM L0s: %s\n", (tmp8&BIT7) ? "Enable" : "Disable");
3919
3920 tmp8 = rtw_hal_pci_dbi_read(padapter, 0x719);
3921 RTW_PRINT_SEL(m, "ASPM L1: %s\n", (tmp8 & BIT3) ? "Enable" : "Disable");
3922
3923 tmp8 = rtw_hal_pci_dbi_read(padapter, 0x718);
3924 RTW_PRINT_SEL(m, "ASPM L1OFF: %s\n", (tmp8 & BIT5) ? "Enable" : "Disable");
3925
3926 return 0;
3927 }
3928
proc_get_rx_ring(struct seq_file * m,void * v)3929 int proc_get_rx_ring(struct seq_file *m, void *v)
3930 {
3931 _irqL irqL;
3932 struct net_device *dev = m->private;
3933 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
3934 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
3935 struct recv_priv *precvpriv = &padapter->recvpriv;
3936 struct rtw_rx_ring *rx_ring = &precvpriv->rx_ring[RX_MPDU_QUEUE];
3937 int i, j;
3938
3939 RTW_PRINT_SEL(m, "rx ring (%p)\n", rx_ring);
3940 RTW_PRINT_SEL(m, " dma: 0x%08x\n", (int) rx_ring->dma);
3941 RTW_PRINT_SEL(m, " idx: %d\n", rx_ring->idx);
3942
3943 _enter_critical(&pdvobjpriv->irq_th_lock, &irqL);
3944 for (i = 0; i < precvpriv->rxringcount; i++) {
3945 #ifdef CONFIG_TRX_BD_ARCH
3946 struct rx_buf_desc *entry = &rx_ring->buf_desc[i];
3947 #else
3948 struct recv_stat *entry = &rx_ring->desc[i];
3949 #endif
3950 struct sk_buff *skb = rx_ring->rx_buf[i];
3951
3952 RTW_PRINT_SEL(m, " desc[%03d]: %p, rx_buf[%03d]: 0x%08x\n",
3953 i, entry, i, cpu_to_le32(*((dma_addr_t *)skb->cb)));
3954
3955 for (j = 0; j < sizeof(*entry) / 4; j++) {
3956 if ((j % 4) == 0)
3957 RTW_PRINT_SEL(m, " 0x%03x", j);
3958
3959 RTW_PRINT_SEL(m, " 0x%08x ", ((int *) entry)[j]);
3960
3961 if ((j % 4) == 3)
3962 RTW_PRINT_SEL(m, "\n");
3963 }
3964 }
3965 _exit_critical(&pdvobjpriv->irq_th_lock, &irqL);
3966
3967 return 0;
3968 }
3969
proc_get_tx_ring(struct seq_file * m,void * v)3970 int proc_get_tx_ring(struct seq_file *m, void *v)
3971 {
3972 _irqL irqL;
3973 struct net_device *dev = m->private;
3974 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
3975 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
3976 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
3977 int i, j, k;
3978
3979 _enter_critical(&pdvobjpriv->irq_th_lock, &irqL);
3980 for (i = 0; i < PCI_MAX_TX_QUEUE_COUNT; i++) {
3981 struct rtw_tx_ring *tx_ring = &pxmitpriv->tx_ring[i];
3982
3983 RTW_PRINT_SEL(m, "tx ring[%d] (%p)\n", i, tx_ring);
3984 RTW_PRINT_SEL(m, " dma: 0x%08x\n", (int) tx_ring->dma);
3985 RTW_PRINT_SEL(m, " idx: %d\n", tx_ring->idx);
3986 RTW_PRINT_SEL(m, " entries: %d\n", tx_ring->entries);
3987 /* RTW_PRINT_SEL(m, " queue: %d\n", tx_ring->queue); */
3988 RTW_PRINT_SEL(m, " qlen: %d\n", tx_ring->qlen);
3989
3990 for (j = 0; j < pxmitpriv->txringcount[i]; j++) {
3991 #ifdef CONFIG_TRX_BD_ARCH
3992 struct tx_buf_desc *entry = &tx_ring->buf_desc[j];
3993 RTW_PRINT_SEL(m, " buf_desc[%03d]: %p\n", j, entry);
3994 #else
3995 struct tx_desc *entry = &tx_ring->desc[j];
3996 RTW_PRINT_SEL(m, " desc[%03d]: %p\n", j, entry);
3997 #endif
3998
3999 for (k = 0; k < sizeof(*entry) / 4; k++) {
4000 if ((k % 4) == 0)
4001 RTW_PRINT_SEL(m, " 0x%03x", k);
4002
4003 RTW_PRINT_SEL(m, " 0x%08x ", ((int *) entry)[k]);
4004
4005 if ((k % 4) == 3)
4006 RTW_PRINT_SEL(m, "\n");
4007 }
4008 }
4009 }
4010 _exit_critical(&pdvobjpriv->irq_th_lock, &irqL);
4011
4012 return 0;
4013 }
4014
4015 #ifdef DBG_TXBD_DESC_DUMP
proc_get_tx_ring_ext(struct seq_file * m,void * v)4016 int proc_get_tx_ring_ext(struct seq_file *m, void *v)
4017 {
4018 _irqL irqL;
4019 struct net_device *dev = m->private;
4020 _adapter *padapter = (_adapter *) rtw_netdev_priv(dev);
4021 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4022 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
4023 struct rtw_tx_desc_backup *pbuf;
4024 int i, j, k, idx;
4025
4026 RTW_PRINT_SEL(m, "<<<< tx ring ext dump settings >>>>\n");
4027 RTW_PRINT_SEL(m, " - backup frame num: %d\n", TX_BAK_FRMAE_CNT);
4028 RTW_PRINT_SEL(m, " - backup max. desc size: %d bytes\n", TX_BAK_DESC_LEN);
4029 RTW_PRINT_SEL(m, " - backup data size: %d bytes\n\n", TX_BAK_DATA_LEN);
4030
4031 if (!pxmitpriv->dump_txbd_desc) {
4032 RTW_PRINT_SEL(m, "Dump function is disabled.\n");
4033 return 0;
4034 }
4035
4036 _enter_critical(&pdvobjpriv->irq_th_lock, &irqL);
4037 for (i = 0; i < HW_QUEUE_ENTRY; i++) {
4038 struct rtw_tx_ring *tx_ring = &pxmitpriv->tx_ring[i];
4039
4040 idx = rtw_get_tx_desc_backup(padapter, i, &pbuf);
4041
4042 RTW_PRINT_SEL(m, "Tx ring[%d]", i);
4043 switch (i) {
4044 case 0:
4045 RTW_PRINT_SEL(m, " (VO)\n");
4046 break;
4047 case 1:
4048 RTW_PRINT_SEL(m, " (VI)\n");
4049 break;
4050 case 2:
4051 RTW_PRINT_SEL(m, " (BE)\n");
4052 break;
4053 case 3:
4054 RTW_PRINT_SEL(m, " (BK)\n");
4055 break;
4056 case 4:
4057 RTW_PRINT_SEL(m, " (BCN)\n");
4058 break;
4059 case 5:
4060 RTW_PRINT_SEL(m, " (MGT)\n");
4061 break;
4062 case 6:
4063 RTW_PRINT_SEL(m, " (HIGH)\n");
4064 break;
4065 case 7:
4066 RTW_PRINT_SEL(m, " (TXCMD)\n");
4067 break;
4068 default:
4069 RTW_PRINT_SEL(m, " (?)\n");
4070 break;
4071 }
4072
4073 RTW_PRINT_SEL(m, " Entries: %d\n", TX_BAK_FRMAE_CNT);
4074 RTW_PRINT_SEL(m, " Last idx: %d\n", idx);
4075
4076 for (j = 0; j < TX_BAK_FRMAE_CNT; j++) {
4077 RTW_PRINT_SEL(m, " desc[%03d]:\n", j);
4078
4079 for (k = 0; k < (pbuf->tx_desc_size) / 4; k++) {
4080 if ((k % 4) == 0)
4081 RTW_PRINT_SEL(m, " 0x%03x", k);
4082
4083 RTW_PRINT_SEL(m, " 0x%08x ", ((int *)pbuf->tx_bak_desc)[k]);
4084
4085 if ((k % 4) == 3)
4086 RTW_PRINT_SEL(m, "\n");
4087 }
4088
4089 #if 1 /* data dump */
4090 if (pbuf->tx_desc_size) {
4091 RTW_PRINT_SEL(m, " data[%03d]:\n", j);
4092
4093 for (k = 0; k < (TX_BAK_DATA_LEN) / 4; k++) {
4094 if ((k % 4) == 0)
4095 RTW_PRINT_SEL(m, " 0x%03x", k);
4096
4097 RTW_PRINT_SEL(m, " 0x%08x ", ((int *)pbuf->tx_bak_data_hdr)[k]);
4098
4099 if ((k % 4) == 3)
4100 RTW_PRINT_SEL(m, "\n");
4101 }
4102 RTW_PRINT_SEL(m, "\n");
4103 }
4104 #endif
4105
4106 RTW_PRINT_SEL(m, " R/W pointer: %d/%d\n", pbuf->tx_bak_rp, pbuf->tx_bak_wp);
4107
4108 pbuf = pbuf + 1;
4109 }
4110 RTW_PRINT_SEL(m, "\n");
4111 }
4112 _exit_critical(&pdvobjpriv->irq_th_lock, &irqL);
4113
4114 return 0;
4115 }
4116
proc_set_tx_ring_ext(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4117 ssize_t proc_set_tx_ring_ext(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4118 {
4119 _irqL irqL;
4120 struct net_device *dev = data;
4121 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4122 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
4123 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
4124 char tmp[32];
4125 u32 reset = 0;
4126 u32 dump = 0;
4127
4128 if (count < 1)
4129 return -EFAULT;
4130
4131 if (count > sizeof(tmp)) {
4132 rtw_warn_on(1);
4133 return -EFAULT;
4134 }
4135
4136 if (buffer && !copy_from_user(tmp, buffer, count)) {
4137
4138 int num = sscanf(tmp, "%u %u", &dump, &reset);
4139
4140 if (num != 2) {
4141 RTW_INFO("invalid parameter!\n");
4142 return count;
4143 }
4144
4145 _enter_critical(&pdvobjpriv->irq_th_lock, &irqL);
4146 pxmitpriv->dump_txbd_desc = (BOOLEAN) dump;
4147
4148 if (reset == 1)
4149 rtw_tx_desc_backup_reset();
4150
4151 _exit_critical(&pdvobjpriv->irq_th_lock, &irqL);
4152
4153 }
4154
4155 return count;
4156 }
4157
4158 #endif
4159
4160 #endif
4161
4162 #ifdef CONFIG_WOWLAN
proc_get_pattern_info(struct seq_file * m,void * v)4163 int proc_get_pattern_info(struct seq_file *m, void *v)
4164 {
4165 struct net_device *dev = m->private;
4166 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4167 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4168 struct registry_priv *pregistrypriv = &padapter->registrypriv;
4169 u8 pattern_num = 0, val8;
4170 char str_1[128];
4171 char *p_str;
4172 int i = 0 , j = 0, k = 0;
4173 int len = 0, max_len = 0, total = 0;
4174
4175 p_str = str_1;
4176 max_len = sizeof(str_1);
4177
4178 total = pwrpriv->wowlan_pattern_idx;
4179
4180 rtw_set_default_pattern(padapter);
4181
4182 /*show pattern*/
4183 RTW_PRINT_SEL(m, "\n======[Pattern Info.]======\n");
4184 RTW_PRINT_SEL(m, "pattern number: %d\n", total);
4185 RTW_PRINT_SEL(m, "support default patterns: %c\n",
4186 (pwrpriv->default_patterns_en) ? 'Y' : 'N');
4187
4188 for (k = 0; k < total ; k++) {
4189 RTW_PRINT_SEL(m, "\npattern idx: %d\n", k);
4190 RTW_PRINT_SEL(m, "pattern content:\n");
4191
4192 p_str = str_1;
4193 max_len = sizeof(str_1);
4194 for (i = 0 ; i < MAX_WKFM_PATTERN_SIZE / 8 ; i++) {
4195 _rtw_memset(p_str, 0, max_len);
4196 len = 0;
4197 for (j = 0 ; j < 8 ; j++) {
4198 val8 = pwrpriv->patterns[k].content[i * 8 + j];
4199 len += snprintf(p_str + len, max_len - len,
4200 "%02x ", val8);
4201 }
4202 RTW_PRINT_SEL(m, "%s\n", p_str);
4203 }
4204 RTW_PRINT_SEL(m, "\npattern mask:\n");
4205 for (i = 0 ; i < MAX_WKFM_SIZE / 8 ; i++) {
4206 _rtw_memset(p_str, 0, max_len);
4207 len = 0;
4208 for (j = 0 ; j < 8 ; j++) {
4209 val8 = pwrpriv->patterns[k].mask[i * 8 + j];
4210 len += snprintf(p_str + len, max_len - len,
4211 "%02x ", val8);
4212 }
4213 RTW_PRINT_SEL(m, "%s\n", p_str);
4214 }
4215
4216 RTW_PRINT_SEL(m, "\npriv_pattern_len:\n");
4217 RTW_PRINT_SEL(m, "pattern_len: %d\n", pwrpriv->patterns[k].len);
4218 RTW_PRINT_SEL(m, "*****************\n");
4219 }
4220
4221 return 0;
4222 }
4223
proc_set_pattern_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4224 ssize_t proc_set_pattern_info(struct file *file, const char __user *buffer,
4225 size_t count, loff_t *pos, void *data)
4226 {
4227 struct net_device *dev = data;
4228 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4229 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4230 struct wowlan_ioctl_param poidparam;
4231 u8 tmp[MAX_WKFM_PATTERN_SIZE] = {0};
4232 int ret = 0, num = 0;
4233 u8 index = 0;
4234
4235 poidparam.subcode = 0;
4236
4237 if (count < 1)
4238 return -EFAULT;
4239
4240 if (count > sizeof(tmp)) {
4241 rtw_warn_on(1);
4242 return -EFAULT;
4243 }
4244
4245 if (pwrpriv->wowlan_pattern_idx >= MAX_WKFM_CAM_NUM) {
4246 RTW_INFO("WARNING: priv-pattern is full(idx: %d)\n",
4247 pwrpriv->wowlan_pattern_idx);
4248 RTW_INFO("WARNING: please clean priv-pattern first\n");
4249 return -ENOMEM;
4250 }
4251
4252 if (buffer && !copy_from_user(tmp, buffer, count)) {
4253 if (strncmp(tmp, "clean", 5) == 0) {
4254 poidparam.subcode = WOWLAN_PATTERN_CLEAN;
4255 rtw_hal_set_hwreg(padapter,
4256 HW_VAR_WOWLAN, (u8 *)&poidparam);
4257 } else {
4258 index = pwrpriv->wowlan_pattern_idx;
4259 ret = rtw_wowlan_parser_pattern_cmd(tmp,
4260 pwrpriv->patterns[index].content,
4261 &pwrpriv->patterns[index].len,
4262 pwrpriv->patterns[index].mask);
4263 if (ret == _TRUE)
4264 pwrpriv->wowlan_pattern_idx++;
4265 }
4266 }
4267
4268 return count;
4269 }
4270
proc_get_wakeup_event(struct seq_file * m,void * v)4271 int proc_get_wakeup_event(struct seq_file *m, void *v)
4272 {
4273 struct net_device *dev = m->private;
4274 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4275 struct registry_priv *registry_par = &padapter->registrypriv;
4276
4277 RTW_PRINT_SEL(m, "wakeup event: %#02x\n", registry_par->wakeup_event);
4278 return 0;
4279 }
4280
proc_set_wakeup_event(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4281 ssize_t proc_set_wakeup_event(struct file *file, const char __user *buffer,
4282 size_t count, loff_t *pos, void *data)
4283 {
4284 struct net_device *dev = data;
4285 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4286 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
4287 struct registry_priv *registry_par = &padapter->registrypriv;
4288 u32 wakeup_event = 0;
4289
4290 u8 tmp[8] = {0};
4291 int ret = 0, num = 0;
4292 u8 index = 0;
4293
4294 if (count < 1)
4295 return -EFAULT;
4296
4297 if (count > sizeof(tmp)) {
4298 rtw_warn_on(1);
4299 return -EFAULT;
4300 }
4301
4302 if (buffer && !copy_from_user(tmp, buffer, count))
4303 num = sscanf(tmp, "%u", &wakeup_event);
4304 else
4305 return -EFAULT;
4306
4307 if (wakeup_event <= 0x07) {
4308 registry_par->wakeup_event = wakeup_event;
4309
4310 if (wakeup_event & BIT(1))
4311 pwrctrlpriv->default_patterns_en = _TRUE;
4312 else
4313 pwrctrlpriv->default_patterns_en = _FALSE;
4314
4315 rtw_wow_pattern_sw_reset(padapter);
4316
4317 RTW_INFO("%s: wakeup_event: %#2x, default pattern: %d\n",
4318 __func__, registry_par->wakeup_event,
4319 pwrctrlpriv->default_patterns_en);
4320 } else {
4321 return -EINVAL;
4322 }
4323
4324 return count;
4325 }
4326
proc_get_wakeup_reason(struct seq_file * m,void * v)4327 int proc_get_wakeup_reason(struct seq_file *m, void *v)
4328 {
4329 struct net_device *dev = m->private;
4330 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4331 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4332 u8 val = pwrpriv->wowlan_last_wake_reason;
4333
4334 RTW_PRINT_SEL(m, "last wake reason: %#02x\n", val);
4335 return 0;
4336 }
4337 #endif /*CONFIG_WOWLAN*/
4338
4339 #ifdef CONFIG_GPIO_WAKEUP
proc_get_wowlan_gpio_info(struct seq_file * m,void * v)4340 int proc_get_wowlan_gpio_info(struct seq_file *m, void *v)
4341 {
4342 struct net_device *dev = m->private;
4343 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4344 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4345 u8 val = pwrpriv->is_high_active;
4346
4347 RTW_PRINT_SEL(m, "wakeup_gpio_idx: %d\n", WAKEUP_GPIO_IDX);
4348 RTW_PRINT_SEL(m, "high_active: %d\n", val);
4349
4350 return 0;
4351 }
4352
proc_set_wowlan_gpio_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4353 ssize_t proc_set_wowlan_gpio_info(struct file *file, const char __user *buffer,
4354 size_t count, loff_t *pos, void *data)
4355 {
4356 struct net_device *dev = data;
4357 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4358 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4359 char tmp[32] = {0};
4360 int num = 0;
4361 u32 is_high_active = 0;
4362 u8 val8 = 0;
4363
4364 if (count < 1)
4365 return -EFAULT;
4366
4367 if (count > sizeof(tmp)) {
4368 rtw_warn_on(1);
4369 return -EFAULT;
4370 }
4371
4372 if (buffer && !copy_from_user(tmp, buffer, count)) {
4373
4374 num = sscanf(tmp, "%u", &is_high_active);
4375
4376 is_high_active = is_high_active == 0 ? 0 : 1;
4377
4378 pwrpriv->is_high_active = is_high_active;
4379
4380 rtw_ps_deny(padapter, PS_DENY_IOCTL);
4381 LeaveAllPowerSaveModeDirect(padapter);
4382
4383 #ifdef CONFIG_WAKEUP_GPIO_INPUT_MODE
4384 if (pwrpriv->is_high_active == 0)
4385 rtw_hal_set_input_gpio(padapter, WAKEUP_GPIO_IDX);
4386 else
4387 rtw_hal_set_output_gpio(padapter, WAKEUP_GPIO_IDX, 0);
4388 #else
4389 val8 = (pwrpriv->is_high_active == 0) ? 1 : 0;
4390 rtw_hal_set_output_gpio(padapter, WAKEUP_GPIO_IDX, val8);
4391 #endif
4392 rtw_ps_deny_cancel(padapter, PS_DENY_IOCTL);
4393
4394 RTW_INFO("set %s %d\n", "gpio_high_active",
4395 pwrpriv->is_high_active);
4396 RTW_INFO("%s: set GPIO_%d %d as default.\n",
4397 __func__, WAKEUP_GPIO_IDX, val8);
4398 }
4399
4400 return count;
4401 }
4402 #endif /* CONFIG_GPIO_WAKEUP */
4403
4404 #ifdef CONFIG_P2P_WOWLAN
proc_get_p2p_wowlan_info(struct seq_file * m,void * v)4405 int proc_get_p2p_wowlan_info(struct seq_file *m, void *v)
4406 {
4407 struct net_device *dev = m->private;
4408 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4409 struct wifidirect_info *pwdinfo = &(padapter->wdinfo);
4410 struct p2p_wowlan_info peerinfo = pwdinfo->p2p_wow_info;
4411 if (_TRUE == peerinfo.is_trigger) {
4412 RTW_PRINT_SEL(m, "is_trigger: TRUE\n");
4413 switch (peerinfo.wowlan_recv_frame_type) {
4414 case P2P_WOWLAN_RECV_NEGO_REQ:
4415 RTW_PRINT_SEL(m, "Frame Type: Nego Request\n");
4416 break;
4417 case P2P_WOWLAN_RECV_INVITE_REQ:
4418 RTW_PRINT_SEL(m, "Frame Type: Invitation Request\n");
4419 break;
4420 case P2P_WOWLAN_RECV_PROVISION_REQ:
4421 RTW_PRINT_SEL(m, "Frame Type: Provision Request\n");
4422 break;
4423 default:
4424 break;
4425 }
4426 RTW_PRINT_SEL(m, "Peer Addr: "MAC_FMT"\n", MAC_ARG(peerinfo.wowlan_peer_addr));
4427 RTW_PRINT_SEL(m, "Peer WPS Config: %x\n", peerinfo.wowlan_peer_wpsconfig);
4428 RTW_PRINT_SEL(m, "Persistent Group: %d\n", peerinfo.wowlan_peer_is_persistent);
4429 RTW_PRINT_SEL(m, "Intivation Type: %d\n", peerinfo.wowlan_peer_invitation_type);
4430 } else
4431 RTW_PRINT_SEL(m, "is_trigger: False\n");
4432 return 0;
4433 }
4434 #endif /* CONFIG_P2P_WOWLAN */
4435
proc_get_new_bcn_max(struct seq_file * m,void * v)4436 int proc_get_new_bcn_max(struct seq_file *m, void *v)
4437 {
4438 extern int new_bcn_max;
4439
4440 RTW_PRINT_SEL(m, "%d", new_bcn_max);
4441 return 0;
4442 }
4443
proc_set_new_bcn_max(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4444 ssize_t proc_set_new_bcn_max(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4445 {
4446 char tmp[32];
4447 extern int new_bcn_max;
4448
4449 if (count < 1)
4450 return -EFAULT;
4451
4452 if (count > sizeof(tmp)) {
4453 rtw_warn_on(1);
4454 return -EFAULT;
4455 }
4456
4457 if (buffer && !copy_from_user(tmp, buffer, count))
4458 sscanf(tmp, "%d ", &new_bcn_max);
4459
4460 return count;
4461 }
4462
4463 #ifdef CONFIG_POWER_SAVING
proc_get_ps_info(struct seq_file * m,void * v)4464 int proc_get_ps_info(struct seq_file *m, void *v)
4465 {
4466 struct net_device *dev = m->private;
4467 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4468 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
4469 u8 ips_mode = pwrpriv->ips_mode;
4470 u8 lps_mode = pwrpriv->power_mgnt;
4471 u8 lps_level = pwrpriv->lps_level;
4472 char *str = "";
4473
4474 RTW_PRINT_SEL(m, "======Power Saving Info:======\n");
4475 RTW_PRINT_SEL(m, "*IPS:\n");
4476
4477 if (ips_mode == IPS_NORMAL) {
4478 #ifdef CONFIG_FWLPS_IN_IPS
4479 str = "FW_LPS_IN_IPS";
4480 #else
4481 str = "Card Disable";
4482 #endif
4483 } else if (ips_mode == IPS_NONE)
4484 str = "NO IPS";
4485 else if (ips_mode == IPS_LEVEL_2)
4486 str = "IPS_LEVEL_2";
4487 else
4488 str = "invalid ips_mode";
4489
4490 RTW_PRINT_SEL(m, " IPS mode: %s\n", str);
4491 RTW_PRINT_SEL(m, " IPS enter count:%d, IPS leave count:%d\n",
4492 pwrpriv->ips_enter_cnts, pwrpriv->ips_leave_cnts);
4493 RTW_PRINT_SEL(m, "------------------------------\n");
4494 RTW_PRINT_SEL(m, "*LPS:\n");
4495
4496 if (lps_mode == PS_MODE_ACTIVE)
4497 str = "NO LPS";
4498 else if (lps_mode == PS_MODE_MIN)
4499 str = "MIN";
4500 else if (lps_mode == PS_MODE_MAX)
4501 str = "MAX";
4502 else if (lps_mode == PS_MODE_DTIM)
4503 str = "DTIM";
4504 else
4505 sprintf(str, "%d", lps_mode);
4506
4507 RTW_PRINT_SEL(m, " LPS mode: %s\n", str);
4508
4509 if (pwrpriv->dtim != 0)
4510 RTW_PRINT_SEL(m, " DTIM: %d\n", pwrpriv->dtim);
4511 RTW_PRINT_SEL(m, " LPS enter count:%d, LPS leave count:%d\n",
4512 pwrpriv->lps_enter_cnts, pwrpriv->lps_leave_cnts);
4513
4514 if (lps_level == LPS_LCLK)
4515 str = "LPS_LCLK";
4516 else if (lps_level == LPS_PG)
4517 str = "LPS_PG";
4518 else
4519 str = "LPS_NORMAL";
4520 RTW_PRINT_SEL(m, " LPS level: %s\n", str);
4521
4522 RTW_PRINT_SEL(m, "=============================\n");
4523 return 0;
4524 }
4525
4526 #ifdef CONFIG_WMMPS_STA
proc_get_wmmps_info(struct seq_file * m,void * v)4527 int proc_get_wmmps_info(struct seq_file *m, void *v)
4528 {
4529 struct net_device *dev = m->private;
4530 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4531 struct registry_priv *pregpriv = &padapter->registrypriv;
4532 char *uapsd_max_sp_str="";
4533
4534 if (pregpriv){
4535 switch(pregpriv->uapsd_max_sp_len) {
4536 case 0:
4537 uapsd_max_sp_str = "NO_LIMIT";
4538 break;
4539 case 1:
4540 uapsd_max_sp_str = "TWO_MSDU";
4541 break;
4542 case 2:
4543 uapsd_max_sp_str = "FOUR_MSDU";
4544 break;
4545 case 3:
4546 uapsd_max_sp_str = "SIX_MSDU";
4547 break;
4548 default:
4549 uapsd_max_sp_str = "UNSPECIFIED";
4550 break;
4551 }
4552
4553 RTW_PRINT_SEL(m, "====== WMMPS_STA Info:======\n");
4554 RTW_PRINT_SEL(m, "uapsd_max_sp_len=0x%02x (%s)\n", pregpriv->uapsd_max_sp_len, uapsd_max_sp_str);
4555 RTW_PRINT_SEL(m, "uapsd_ac_enable=0x%02x\n", pregpriv->uapsd_ac_enable);
4556 RTW_PRINT_SEL(m, "BIT0 - AC_VO UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_VO) ? "Enabled" : "Disabled");
4557 RTW_PRINT_SEL(m, "BIT1 - AC_VI UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_VI) ? "Enabled" : "Disabled");
4558 RTW_PRINT_SEL(m, "BIT2 - AC_BK UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_BK) ? "Enabled" : "Disabled");
4559 RTW_PRINT_SEL(m, "BIT3 - AC_BE UAPSD: %s\n", (pregpriv->uapsd_ac_enable & DRV_CFG_UAPSD_BE) ? "Enabled" : "Disabled");
4560 RTW_PRINT_SEL(m, "============================\n");
4561 }
4562
4563 return 0;
4564 }
4565
proc_set_wmmps_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4566 ssize_t proc_set_wmmps_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4567 {
4568 struct net_device *dev = data;
4569 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4570 struct registry_priv *pregpriv = &padapter->registrypriv;
4571 char tmp[32];
4572 u8 uapsd_ac_setting;
4573 u8 uapsd_max_sp_len_setting;
4574
4575 if (count < 1)
4576 return -EFAULT;
4577
4578 if (count > sizeof(tmp)) {
4579 rtw_warn_on(1);
4580 return -EFAULT;
4581 }
4582
4583 if (buffer && !copy_from_user(tmp, buffer, count)) {
4584
4585 int num = sscanf(tmp, "%hhu %hhx", &uapsd_max_sp_len_setting, &uapsd_ac_setting);
4586
4587 if (pregpriv) {
4588 if (num >= 1){
4589 pregpriv->uapsd_max_sp_len = uapsd_max_sp_len_setting;
4590 RTW_INFO("uapsd_max_sp_len = %d\n", pregpriv->uapsd_max_sp_len);
4591 }
4592
4593 if (num >= 2){
4594 pregpriv->uapsd_ac_enable = uapsd_ac_setting;
4595 RTW_INFO("uapsd_ac_enable = 0x%02x\n", pregpriv->uapsd_ac_enable);
4596 }
4597 }
4598 }
4599
4600 return count;
4601 }
4602 #endif /* CONFIG_WMMPS_STA */
4603 #endif /* CONFIG_POWER_SAVING */
4604
4605 #ifdef CONFIG_TDLS
proc_get_tdls_enable(struct seq_file * m,void * v)4606 int proc_get_tdls_enable(struct seq_file *m, void *v)
4607 {
4608 struct net_device *dev = m->private;
4609 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4610 struct registry_priv *pregpriv = &padapter->registrypriv;
4611
4612 if (pregpriv)
4613 RTW_PRINT_SEL(m, "TDLS is %s !\n", (rtw_is_tdls_enabled(padapter) == _TRUE) ? "enabled" : "disabled");
4614
4615 return 0;
4616 }
4617
proc_set_tdls_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4618 ssize_t proc_set_tdls_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4619 {
4620 struct net_device *dev = data;
4621 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4622 struct registry_priv *pregpriv = &padapter->registrypriv;
4623 char tmp[32];
4624 u32 en_tdls = 0;
4625
4626 if (count < 1)
4627 return -EFAULT;
4628
4629 if (count > sizeof(tmp)) {
4630 rtw_warn_on(1);
4631 return -EFAULT;
4632 }
4633
4634 if (buffer && !copy_from_user(tmp, buffer, count)) {
4635
4636 int num = sscanf(tmp, "%d ", &en_tdls);
4637
4638 if (pregpriv) {
4639 if (en_tdls > 0)
4640 rtw_enable_tdls_func(padapter);
4641 else
4642 rtw_disable_tdls_func(padapter, _FALSE);
4643 }
4644 }
4645
4646 return count;
4647 }
4648
proc_tdls_display_tdls_function_info(struct seq_file * m)4649 static int proc_tdls_display_tdls_function_info(struct seq_file *m)
4650 {
4651 struct net_device *dev = m->private;
4652 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4653 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
4654 u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
4655 u8 SpaceBtwnItemAndValueTmp = 0;
4656 BOOLEAN FirstMatchFound = _FALSE;
4657 int j = 0;
4658
4659 RTW_PRINT_SEL(m, "============[TDLS Function Info]============\n");
4660 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Enable", (rtw_is_tdls_enabled(padapter) == _TRUE) ? "_TRUE" : "_FALSE");
4661 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Driver Setup", (ptdlsinfo->driver_setup == _TRUE) ? "_TRUE" : "_FALSE");
4662 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Prohibited", (ptdlsinfo->ap_prohibited == _TRUE) ? "_TRUE" : "_FALSE");
4663 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Channel Switch Prohibited", (ptdlsinfo->ch_switch_prohibited == _TRUE) ? "_TRUE" : "_FALSE");
4664 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Link Established", (ptdlsinfo->link_established == _TRUE) ? "_TRUE" : "_FALSE");
4665 RTW_PRINT_SEL(m, "%-*s = %d/%d\n", SpaceBtwnItemAndValue, "TDLS STA Num (Linked/Allowed)", ptdlsinfo->sta_cnt, MAX_ALLOWED_TDLS_STA_NUM);
4666 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Allowed STA Num Reached", (ptdlsinfo->sta_maximum == _TRUE) ? "_TRUE" : "_FALSE");
4667
4668 #ifdef CONFIG_TDLS_CH_SW
4669 RTW_PRINT_SEL(m, "%-*s =", SpaceBtwnItemAndValue, "TDLS CH SW State");
4670 if (ptdlsinfo->chsw_info.ch_sw_state == TDLS_STATE_NONE)
4671 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_STATE_NONE");
4672 else {
4673 for (j = 0; j < 32; j++) {
4674 if (ptdlsinfo->chsw_info.ch_sw_state & BIT(j)) {
4675 if (FirstMatchFound == _FALSE) {
4676 SpaceBtwnItemAndValueTmp = 1;
4677 FirstMatchFound = _TRUE;
4678 } else
4679 SpaceBtwnItemAndValueTmp = SpaceBtwnItemAndValue + 3;
4680 switch (BIT(j)) {
4681 case TDLS_INITIATOR_STATE:
4682 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_INITIATOR_STATE");
4683 break;
4684 case TDLS_RESPONDER_STATE:
4685 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_RESPONDER_STATE");
4686 break;
4687 case TDLS_LINKED_STATE:
4688 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_LINKED_STATE");
4689 break;
4690 case TDLS_WAIT_PTR_STATE:
4691 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_WAIT_PTR_STATE");
4692 break;
4693 case TDLS_ALIVE_STATE:
4694 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_ALIVE_STATE");
4695 break;
4696 case TDLS_CH_SWITCH_ON_STATE:
4697 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SWITCH_ON_STATE");
4698 break;
4699 case TDLS_PEER_AT_OFF_STATE:
4700 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_PEER_AT_OFF_STATE");
4701 break;
4702 case TDLS_CH_SW_INITIATOR_STATE:
4703 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SW_INITIATOR_STATE");
4704 break;
4705 case TDLS_WAIT_CH_RSP_STATE:
4706 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValue, " ", "TDLS_WAIT_CH_RSP_STATE");
4707 break;
4708 default:
4709 RTW_PRINT_SEL(m, "%-*sBIT(%d)\n", SpaceBtwnItemAndValueTmp, " ", j);
4710 break;
4711 }
4712 }
4713 }
4714 }
4715
4716 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS CH SW On", (ATOMIC_READ(&ptdlsinfo->chsw_info.chsw_on) == _TRUE) ? "_TRUE" : "_FALSE");
4717 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Off-Channel Num", ptdlsinfo->chsw_info.off_ch_num);
4718 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Channel Offset", ptdlsinfo->chsw_info.ch_offset);
4719 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Current Time", ptdlsinfo->chsw_info.cur_time);
4720 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS CH SW Delay Switch Back", (ptdlsinfo->chsw_info.delay_switch_back == _TRUE) ? "_TRUE" : "_FALSE");
4721 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "TDLS CH SW Dump Back", ptdlsinfo->chsw_info.dump_stack);
4722 #endif
4723
4724 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "TDLS Device Discovered", (ptdlsinfo->dev_discovered == _TRUE) ? "_TRUE" : "_FALSE");
4725
4726 return 0;
4727 }
4728
proc_tdls_display_network_info(struct seq_file * m)4729 static int proc_tdls_display_network_info(struct seq_file *m)
4730 {
4731 struct net_device *dev = m->private;
4732 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4733 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
4734 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4735 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
4736 int i = 0;
4737 u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
4738
4739 /* Display the linked AP/GO info */
4740 RTW_PRINT_SEL(m, "============[Associated AP/GO Info]============\n");
4741
4742 if ((pmlmepriv->fw_state & WIFI_STATION_STATE) && (pmlmepriv->fw_state & _FW_LINKED)) {
4743 RTW_PRINT_SEL(m, "%-*s = %s\n", SpaceBtwnItemAndValue, "BSSID", cur_network->network.Ssid.Ssid);
4744 RTW_PRINT_SEL(m, "%-*s = "MAC_FMT"\n", SpaceBtwnItemAndValue, "Mac Address", MAC_ARG(cur_network->network.MacAddress));
4745
4746 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Wireless Mode");
4747 for (i = 0; i < 8; i++) {
4748 if (pmlmeext->cur_wireless_mode & BIT(i)) {
4749 switch (BIT(i)) {
4750 case WIRELESS_11B:
4751 RTW_PRINT_SEL(m, "%4s", "11B ");
4752 break;
4753 case WIRELESS_11G:
4754 RTW_PRINT_SEL(m, "%4s", "11G ");
4755 break;
4756 case WIRELESS_11A:
4757 RTW_PRINT_SEL(m, "%4s", "11A ");
4758 break;
4759 case WIRELESS_11_24N:
4760 RTW_PRINT_SEL(m, "%7s", "11_24N ");
4761 break;
4762 case WIRELESS_11_5N:
4763 RTW_PRINT_SEL(m, "%6s", "11_5N ");
4764 break;
4765 case WIRELESS_AUTO:
4766 RTW_PRINT_SEL(m, "%5s", "AUTO ");
4767 break;
4768 case WIRELESS_11AC:
4769 RTW_PRINT_SEL(m, "%5s", "11AC ");
4770 break;
4771 }
4772 }
4773 }
4774 RTW_PRINT_SEL(m, "\n");
4775
4776 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Privacy");
4777 switch (padapter->securitypriv.dot11PrivacyAlgrthm) {
4778 case _NO_PRIVACY_:
4779 RTW_PRINT_SEL(m, "%s\n", "NO PRIVACY");
4780 break;
4781 case _WEP40_:
4782 RTW_PRINT_SEL(m, "%s\n", "WEP 40");
4783 break;
4784 case _TKIP_:
4785 RTW_PRINT_SEL(m, "%s\n", "TKIP");
4786 break;
4787 case _TKIP_WTMIC_:
4788 RTW_PRINT_SEL(m, "%s\n", "TKIP WTMIC");
4789 break;
4790 case _AES_:
4791 RTW_PRINT_SEL(m, "%s\n", "AES");
4792 break;
4793 case _WEP104_:
4794 RTW_PRINT_SEL(m, "%s\n", "WEP 104");
4795 break;
4796 case _WEP_WPA_MIXED_:
4797 RTW_PRINT_SEL(m, "%s\n", "WEP/WPA Mixed");
4798 break;
4799 case _SMS4_:
4800 RTW_PRINT_SEL(m, "%s\n", "SMS4");
4801 break;
4802 #ifdef CONFIG_IEEE80211W
4803 case _BIP_:
4804 RTW_PRINT_SEL(m, "%s\n", "BIP");
4805 break;
4806 #endif /* CONFIG_IEEE80211W */
4807 }
4808
4809 RTW_PRINT_SEL(m, "%-*s = %d\n", SpaceBtwnItemAndValue, "Channel", pmlmeext->cur_channel);
4810 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Channel Offset");
4811 switch (pmlmeext->cur_ch_offset) {
4812 case HAL_PRIME_CHNL_OFFSET_DONT_CARE:
4813 RTW_PRINT_SEL(m, "%s\n", "N/A");
4814 break;
4815 case HAL_PRIME_CHNL_OFFSET_LOWER:
4816 RTW_PRINT_SEL(m, "%s\n", "Lower");
4817 break;
4818 case HAL_PRIME_CHNL_OFFSET_UPPER:
4819 RTW_PRINT_SEL(m, "%s\n", "Upper");
4820 break;
4821 }
4822
4823 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Bandwidth Mode");
4824 switch (pmlmeext->cur_bwmode) {
4825 case CHANNEL_WIDTH_20:
4826 RTW_PRINT_SEL(m, "%s\n", "20MHz");
4827 break;
4828 case CHANNEL_WIDTH_40:
4829 RTW_PRINT_SEL(m, "%s\n", "40MHz");
4830 break;
4831 case CHANNEL_WIDTH_80:
4832 RTW_PRINT_SEL(m, "%s\n", "80MHz");
4833 break;
4834 case CHANNEL_WIDTH_160:
4835 RTW_PRINT_SEL(m, "%s\n", "160MHz");
4836 break;
4837 case CHANNEL_WIDTH_80_80:
4838 RTW_PRINT_SEL(m, "%s\n", "80MHz + 80MHz");
4839 break;
4840 }
4841 } else
4842 RTW_PRINT_SEL(m, "No association with AP/GO exists!\n");
4843
4844 return 0;
4845 }
4846
proc_tdls_display_tdls_sta_info(struct seq_file * m)4847 static int proc_tdls_display_tdls_sta_info(struct seq_file *m)
4848 {
4849 struct net_device *dev = m->private;
4850 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4851 struct sta_priv *pstapriv = &padapter->stapriv;
4852 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
4853 struct sta_info *psta;
4854 int i = 0, j = 0;
4855 _irqL irqL;
4856 _list *plist, *phead;
4857 u8 SpaceBtwnItemAndValue = TDLS_DBG_INFO_SPACE_BTWN_ITEM_AND_VALUE;
4858 u8 SpaceBtwnItemAndValueTmp = 0;
4859 u8 NumOfTdlsStaToShow = 0;
4860 BOOLEAN FirstMatchFound = _FALSE;
4861
4862 /* Search for TDLS sta info to display */
4863 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
4864 for (i = 0; i < NUM_STA; i++) {
4865 phead = &(pstapriv->sta_hash[i]);
4866 plist = get_next(phead);
4867 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
4868 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
4869 plist = get_next(plist);
4870 if (psta->tdls_sta_state != TDLS_STATE_NONE) {
4871 /* We got one TDLS sta info to show */
4872 RTW_PRINT_SEL(m, "============[TDLS Peer STA Info: STA %d]============\n", ++NumOfTdlsStaToShow);
4873 RTW_PRINT_SEL(m, "%-*s = "MAC_FMT"\n", SpaceBtwnItemAndValue, "Mac Address", MAC_ARG(psta->cmn.mac_addr));
4874 RTW_PRINT_SEL(m, "%-*s =", SpaceBtwnItemAndValue, "TDLS STA State");
4875 SpaceBtwnItemAndValueTmp = 0;
4876 FirstMatchFound = _FALSE;
4877 for (j = 0; j < 32; j++) {
4878 if (psta->tdls_sta_state & BIT(j)) {
4879 if (FirstMatchFound == _FALSE) {
4880 SpaceBtwnItemAndValueTmp = 1;
4881 FirstMatchFound = _TRUE;
4882 } else
4883 SpaceBtwnItemAndValueTmp = SpaceBtwnItemAndValue + 3;
4884 switch (BIT(j)) {
4885 case TDLS_INITIATOR_STATE:
4886 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_INITIATOR_STATE");
4887 break;
4888 case TDLS_RESPONDER_STATE:
4889 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_RESPONDER_STATE");
4890 break;
4891 case TDLS_LINKED_STATE:
4892 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_LINKED_STATE");
4893 break;
4894 case TDLS_WAIT_PTR_STATE:
4895 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_WAIT_PTR_STATE");
4896 break;
4897 case TDLS_ALIVE_STATE:
4898 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_ALIVE_STATE");
4899 break;
4900 case TDLS_CH_SWITCH_ON_STATE:
4901 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SWITCH_ON_STATE");
4902 break;
4903 case TDLS_PEER_AT_OFF_STATE:
4904 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_PEER_AT_OFF_STATE");
4905 break;
4906 case TDLS_CH_SW_INITIATOR_STATE:
4907 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValueTmp, " ", "TDLS_CH_SW_INITIATOR_STATE");
4908 break;
4909 case TDLS_WAIT_CH_RSP_STATE:
4910 RTW_PRINT_SEL(m, "%-*s%s\n", SpaceBtwnItemAndValue, " ", "TDLS_WAIT_CH_RSP_STATE");
4911 break;
4912 default:
4913 RTW_PRINT_SEL(m, "%-*sBIT(%d)\n", SpaceBtwnItemAndValueTmp, " ", j);
4914 break;
4915 }
4916 }
4917 }
4918
4919 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Wireless Mode");
4920 for (j = 0; j < 8; j++) {
4921 if (psta->wireless_mode & BIT(j)) {
4922 switch (BIT(j)) {
4923 case WIRELESS_11B:
4924 RTW_PRINT_SEL(m, "%4s", "11B ");
4925 break;
4926 case WIRELESS_11G:
4927 RTW_PRINT_SEL(m, "%4s", "11G ");
4928 break;
4929 case WIRELESS_11A:
4930 RTW_PRINT_SEL(m, "%4s", "11A ");
4931 break;
4932 case WIRELESS_11_24N:
4933 RTW_PRINT_SEL(m, "%7s", "11_24N ");
4934 break;
4935 case WIRELESS_11_5N:
4936 RTW_PRINT_SEL(m, "%6s", "11_5N ");
4937 break;
4938 case WIRELESS_AUTO:
4939 RTW_PRINT_SEL(m, "%5s", "AUTO ");
4940 break;
4941 case WIRELESS_11AC:
4942 RTW_PRINT_SEL(m, "%5s", "11AC ");
4943 break;
4944 }
4945 }
4946 }
4947 RTW_PRINT_SEL(m, "\n");
4948
4949 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Bandwidth Mode");
4950 switch (psta->cmn.bw_mode) {
4951 case CHANNEL_WIDTH_20:
4952 RTW_PRINT_SEL(m, "%s\n", "20MHz");
4953 break;
4954 case CHANNEL_WIDTH_40:
4955 RTW_PRINT_SEL(m, "%s\n", "40MHz");
4956 break;
4957 case CHANNEL_WIDTH_80:
4958 RTW_PRINT_SEL(m, "%s\n", "80MHz");
4959 break;
4960 case CHANNEL_WIDTH_160:
4961 RTW_PRINT_SEL(m, "%s\n", "160MHz");
4962 break;
4963 case CHANNEL_WIDTH_80_80:
4964 RTW_PRINT_SEL(m, "%s\n", "80MHz + 80MHz");
4965 break;
4966 case CHANNEL_WIDTH_5:
4967 RTW_PRINT_SEL(m, "%s\n", "5MHz");
4968 break;
4969 case CHANNEL_WIDTH_10:
4970 RTW_PRINT_SEL(m, "%s\n", "10MHz");
4971 break;
4972 default:
4973 RTW_PRINT_SEL(m, "(%d)%s\n", psta->cmn.bw_mode, "invalid");
4974 break;
4975 }
4976
4977 RTW_PRINT_SEL(m, "%-*s = ", SpaceBtwnItemAndValue, "Privacy");
4978 switch (psta->dot118021XPrivacy) {
4979 case _NO_PRIVACY_:
4980 RTW_PRINT_SEL(m, "%s\n", "NO PRIVACY");
4981 break;
4982 case _WEP40_:
4983 RTW_PRINT_SEL(m, "%s\n", "WEP 40");
4984 break;
4985 case _TKIP_:
4986 RTW_PRINT_SEL(m, "%s\n", "TKIP");
4987 break;
4988 case _TKIP_WTMIC_:
4989 RTW_PRINT_SEL(m, "%s\n", "TKIP WTMIC");
4990 break;
4991 case _AES_:
4992 RTW_PRINT_SEL(m, "%s\n", "AES");
4993 break;
4994 case _WEP104_:
4995 RTW_PRINT_SEL(m, "%s\n", "WEP 104");
4996 break;
4997 case _WEP_WPA_MIXED_:
4998 RTW_PRINT_SEL(m, "%s\n", "WEP/WPA Mixed");
4999 break;
5000 case _SMS4_:
5001 RTW_PRINT_SEL(m, "%s\n", "SMS4");
5002 break;
5003 #ifdef CONFIG_IEEE80211W
5004 case _BIP_:
5005 RTW_PRINT_SEL(m, "%s\n", "BIP");
5006 break;
5007 #endif /* CONFIG_IEEE80211W */
5008 }
5009
5010 RTW_PRINT_SEL(m, "%-*s = %d sec/%d sec\n", SpaceBtwnItemAndValue, "TPK Lifetime (Current/Expire)", psta->TPK_count, psta->TDLS_PeerKey_Lifetime);
5011 RTW_PRINT_SEL(m, "%-*s = %llu\n", SpaceBtwnItemAndValue, "Tx Packets Over Direct Link", psta->sta_stats.tx_pkts);
5012 RTW_PRINT_SEL(m, "%-*s = %llu\n", SpaceBtwnItemAndValue, "Rx Packets Over Direct Link", psta->sta_stats.rx_data_pkts);
5013 }
5014 }
5015 }
5016 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
5017 if (NumOfTdlsStaToShow == 0) {
5018 RTW_PRINT_SEL(m, "============[TDLS Peer STA Info]============\n");
5019 RTW_PRINT_SEL(m, "No TDLS direct link exists!\n");
5020 }
5021
5022 return 0;
5023 }
5024
proc_get_tdls_info(struct seq_file * m,void * v)5025 int proc_get_tdls_info(struct seq_file *m, void *v)
5026 {
5027 struct net_device *dev = m->private;
5028 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5029 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5030 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5031 struct wlan_network *cur_network = &(pmlmepriv->cur_network);
5032 struct sta_priv *pstapriv = &padapter->stapriv;
5033 struct tdls_info *ptdlsinfo = &padapter->tdlsinfo;
5034 struct sta_info *psta;
5035 int i = 0, j = 0;
5036 _irqL irqL;
5037 _list *plist, *phead;
5038 u8 SpaceBtwnItemAndValue = 41;
5039 u8 SpaceBtwnItemAndValueTmp = 0;
5040 u8 NumOfTdlsStaToShow = 0;
5041 BOOLEAN FirstMatchFound = _FALSE;
5042
5043 if (hal_chk_wl_func(padapter, WL_FUNC_TDLS) == _FALSE) {
5044 RTW_PRINT_SEL(m, "No tdls info can be shown since hal doesn't support tdls\n");
5045 return 0;
5046 }
5047
5048 proc_tdls_display_tdls_function_info(m);
5049 proc_tdls_display_network_info(m);
5050 proc_tdls_display_tdls_sta_info(m);
5051
5052 return 0;
5053 }
5054 #endif
5055
proc_get_monitor(struct seq_file * m,void * v)5056 int proc_get_monitor(struct seq_file *m, void *v)
5057 {
5058 struct net_device *dev = m->private;
5059 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5060 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5061 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5062
5063 if (WIFI_MONITOR_STATE == get_fwstate(pmlmepriv)) {
5064 RTW_PRINT_SEL(m, "Monitor mode : Enable\n");
5065
5066 RTW_PRINT_SEL(m, "ch=%d, ch_offset=%d, bw=%d\n",
5067 rtw_get_oper_ch(padapter), rtw_get_oper_choffset(padapter), rtw_get_oper_bw(padapter));
5068 } else
5069 RTW_PRINT_SEL(m, "Monitor mode : Disable\n");
5070
5071 return 0;
5072 }
5073
proc_set_monitor(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5074 ssize_t proc_set_monitor(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5075 {
5076 char tmp[32];
5077 struct net_device *dev = data;
5078 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5079 u8 target_chan, target_offset, target_bw;
5080
5081 if (count < 3) {
5082 RTW_INFO("argument size is less than 3\n");
5083 return -EFAULT;
5084 }
5085
5086 if (count > sizeof(tmp)) {
5087 rtw_warn_on(1);
5088 return -EFAULT;
5089 }
5090
5091 if (buffer && !copy_from_user(tmp, buffer, count)) {
5092 int num = sscanf(tmp, "%hhu %hhu %hhu", &target_chan, &target_offset, &target_bw);
5093
5094 if (num != 3) {
5095 RTW_INFO("invalid write_reg parameter!\n");
5096 return count;
5097 }
5098
5099 padapter->mlmeextpriv.cur_channel = target_chan;
5100 set_channel_bwmode(padapter, target_chan, target_offset, target_bw);
5101 }
5102
5103 return count;
5104 }
5105 #ifdef DBG_XMIT_BLOCK
proc_get_xmit_block(struct seq_file * m,void * v)5106 int proc_get_xmit_block(struct seq_file *m, void *v)
5107 {
5108 struct net_device *dev = m->private;
5109 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5110
5111 dump_xmit_block(m, padapter);
5112
5113 return 0;
5114 }
5115
proc_set_xmit_block(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5116 ssize_t proc_set_xmit_block(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5117 {
5118 struct net_device *dev = data;
5119 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5120 char tmp[32];
5121 u8 xb_mode, xb_reason;
5122
5123 if (count < 1)
5124 return -EFAULT;
5125
5126 if (count > sizeof(tmp)) {
5127 rtw_warn_on(1);
5128 return -EFAULT;
5129 }
5130
5131 if (buffer && !copy_from_user(tmp, buffer, count)) {
5132
5133 int num = sscanf(tmp, "%hhx %hhx", &xb_mode, &xb_reason);
5134
5135 if (num != 2) {
5136 RTW_INFO("invalid parameter!\n");
5137 return count;
5138 }
5139
5140 if (xb_mode == 0)/*set*/
5141 rtw_set_xmit_block(padapter, xb_reason);
5142 else if (xb_mode == 1)/*clear*/
5143 rtw_clr_xmit_block(padapter, xb_reason);
5144 else
5145 RTW_INFO("invalid parameter!\n");
5146 }
5147
5148 return count;
5149 }
5150 #endif
5151
5152 #include <hal_data.h>
proc_get_efuse_map(struct seq_file * m,void * v)5153 int proc_get_efuse_map(struct seq_file *m, void *v)
5154 {
5155 struct net_device *dev = m->private;
5156 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5157 PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
5158 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
5159 PEFUSE_HAL pEfuseHal = &pHalData->EfuseHal;
5160 int i, j;
5161 u8 ips_mode = IPS_NUM;
5162 u16 mapLen;
5163
5164 EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAP_LEN, (void *)&mapLen, _FALSE);
5165 if (mapLen > EFUSE_MAX_MAP_LEN)
5166 mapLen = EFUSE_MAX_MAP_LEN;
5167
5168 ips_mode = pwrctrlpriv->ips_mode;
5169 rtw_pm_set_ips(padapter, IPS_NONE);
5170
5171 if (pHalData->efuse_file_status == EFUSE_FILE_LOADED) {
5172 RTW_PRINT_SEL(m, "File eFuse Map loaded! file path:%s\nDriver eFuse Map From File\n", EFUSE_MAP_PATH);
5173 if (pHalData->bautoload_fail_flag)
5174 RTW_PRINT_SEL(m, "File Autoload fail!!!\n");
5175 } else if (pHalData->efuse_file_status == EFUSE_FILE_FAILED) {
5176 RTW_PRINT_SEL(m, "Open File eFuse Map Fail ! file path:%s\nDriver eFuse Map From Default\n", EFUSE_MAP_PATH);
5177 if (pHalData->bautoload_fail_flag)
5178 RTW_PRINT_SEL(m, "HW Autoload fail!!!\n");
5179 } else {
5180 RTW_PRINT_SEL(m, "Driver eFuse Map From HW\n");
5181 if (pHalData->bautoload_fail_flag)
5182 RTW_PRINT_SEL(m, "HW Autoload fail!!!\n");
5183 }
5184 for (i = 0; i < mapLen; i += 16) {
5185 RTW_PRINT_SEL(m, "0x%02x\t", i);
5186 for (j = 0; j < 8; j++)
5187 RTW_PRINT_SEL(m, "%02X ", pHalData->efuse_eeprom_data[i + j]);
5188 RTW_PRINT_SEL(m, "\t");
5189 for (; j < 16; j++)
5190 RTW_PRINT_SEL(m, "%02X ", pHalData->efuse_eeprom_data[i + j]);
5191 RTW_PRINT_SEL(m, "\n");
5192 }
5193
5194 if (rtw_efuse_map_read(padapter, 0, mapLen, pEfuseHal->fakeEfuseInitMap) == _FAIL) {
5195 RTW_PRINT_SEL(m, "WARN - Read Realmap Failed\n");
5196 return 0;
5197 }
5198
5199 RTW_PRINT_SEL(m, "\n");
5200 RTW_PRINT_SEL(m, "HW eFuse Map\n");
5201 for (i = 0; i < mapLen; i += 16) {
5202 RTW_PRINT_SEL(m, "0x%02x\t", i);
5203 for (j = 0; j < 8; j++)
5204 RTW_PRINT_SEL(m, "%02X ", pEfuseHal->fakeEfuseInitMap[i + j]);
5205 RTW_PRINT_SEL(m, "\t");
5206 for (; j < 16; j++)
5207 RTW_PRINT_SEL(m, "%02X ", pEfuseHal->fakeEfuseInitMap[i + j]);
5208 RTW_PRINT_SEL(m, "\n");
5209 }
5210
5211 rtw_pm_set_ips(padapter, ips_mode);
5212
5213 return 0;
5214 }
5215
proc_set_efuse_map(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5216 ssize_t proc_set_efuse_map(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5217 {
5218 #if 0
5219 char tmp[256] = {0};
5220 u32 addr, cnts;
5221 u8 efuse_data;
5222
5223 int jj, kk;
5224
5225 struct net_device *dev = data;
5226 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5227 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
5228 u8 ips_mode = IPS_NUM;
5229
5230 if (count < 3) {
5231 RTW_INFO("argument size is less than 3\n");
5232 return -EFAULT;
5233 }
5234
5235 if (count > sizeof(tmp)) {
5236 rtw_warn_on(1);
5237 return -EFAULT;
5238 }
5239
5240 if (buffer && !copy_from_user(tmp, buffer, count)) {
5241
5242 int num = sscanf(tmp, "%x %d %x", &addr, &cnts, &efuse_data);
5243
5244 if (num != 3) {
5245 RTW_INFO("invalid write_reg parameter!\n");
5246 return count;
5247 }
5248 }
5249 ips_mode = pwrctrlpriv->ips_mode;
5250 rtw_pm_set_ips(padapter, IPS_NONE);
5251 if (rtw_efuse_map_write(padapter, addr, cnts, &efuse_data) == _FAIL)
5252 RTW_INFO("WARN - rtw_efuse_map_write error!!\n");
5253 rtw_pm_set_ips(padapter, ips_mode);
5254 #endif
5255 return count;
5256 }
5257
5258 #ifdef CONFIG_IEEE80211W
proc_set_tx_sa_query(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5259 ssize_t proc_set_tx_sa_query(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5260 {
5261 struct net_device *dev = data;
5262 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5263 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5264 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5265 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5266 struct sta_priv *pstapriv = &padapter->stapriv;
5267 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
5268 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
5269 struct sta_info *psta;
5270 _list *plist, *phead;
5271 _irqL irqL;
5272 char tmp[16];
5273 u8 mac_addr[NUM_STA][ETH_ALEN];
5274 u32 key_type;
5275 u8 index;
5276
5277 if (count > 2) {
5278 RTW_INFO("argument size is more than 2\n");
5279 return -EFAULT;
5280 }
5281
5282 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
5283
5284 int num = sscanf(tmp, "%x", &key_type);
5285
5286 if (num != 1) {
5287 RTW_INFO("invalid read_reg parameter!\n");
5288 return count;
5289 }
5290 RTW_INFO("0: set sa query request , key_type=%d\n", key_type);
5291 }
5292
5293 if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
5294 && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE) && padapter->securitypriv.binstallBIPkey == _TRUE) {
5295 RTW_INFO("STA:"MAC_FMT"\n", MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));
5296 /* TX unicast sa_query to AP */
5297 issue_action_SA_Query(padapter, get_my_bssid(&(pmlmeinfo->network)), 0, 0, (u8)key_type);
5298 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE && padapter->securitypriv.binstallBIPkey == _TRUE) {
5299 /* TX unicast sa_query to every client STA */
5300 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
5301 for (index = 0; index < NUM_STA; index++) {
5302 psta = NULL;
5303
5304 phead = &(pstapriv->sta_hash[index]);
5305 plist = get_next(phead);
5306
5307 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
5308 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
5309 plist = get_next(plist);
5310 _rtw_memcpy(&mac_addr[psta->cmn.mac_id][0], psta->cmn.mac_addr, ETH_ALEN);
5311 }
5312 }
5313 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
5314
5315 for (index = 0; index < macid_ctl->num && index < NUM_STA; index++) {
5316 if (rtw_macid_is_used(macid_ctl, index) && !rtw_macid_is_bmc(macid_ctl, index)) {
5317 if (!_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)), &mac_addr[index][0], ETH_ALEN)
5318 && !IS_MCAST(&mac_addr[index][0])) {
5319 issue_action_SA_Query(padapter, &mac_addr[index][0], 0, 0, (u8)key_type);
5320 RTW_INFO("STA[%u]:"MAC_FMT"\n", index , MAC_ARG(&mac_addr[index][0]));
5321 }
5322 }
5323 }
5324 }
5325
5326 return count;
5327 }
5328
proc_get_tx_sa_query(struct seq_file * m,void * v)5329 int proc_get_tx_sa_query(struct seq_file *m, void *v)
5330 {
5331 struct net_device *dev = m->private;
5332 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5333
5334 RTW_PRINT_SEL(m, "%s\n", __func__);
5335 return 0;
5336 }
5337
proc_set_tx_deauth(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5338 ssize_t proc_set_tx_deauth(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5339 {
5340 struct net_device *dev = data;
5341 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5342 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5343 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5344 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5345 struct sta_priv *pstapriv = &padapter->stapriv;
5346 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
5347 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
5348 struct sta_info *psta;
5349 _list *plist, *phead;
5350 _irqL irqL;
5351 char tmp[16];
5352 u8 mac_addr[NUM_STA][ETH_ALEN];
5353 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
5354 u32 key_type;
5355 u8 index;
5356
5357
5358 if (count > 2) {
5359 RTW_INFO("argument size is more than 2\n");
5360 return -EFAULT;
5361 }
5362
5363 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
5364
5365 int num = sscanf(tmp, "%x", &key_type);
5366
5367 if (num != 1) {
5368 RTW_INFO("invalid read_reg parameter!\n");
5369 return count;
5370 }
5371 RTW_INFO("key_type=%d\n", key_type);
5372 }
5373 if (key_type < 0 || key_type > 4)
5374 return count;
5375
5376 if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
5377 && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
5378 if (key_type == 3) /* key_type 3 only for AP mode */
5379 return count;
5380 /* TX unicast deauth to AP */
5381 issue_deauth_11w(padapter, get_my_bssid(&(pmlmeinfo->network)), 0, (u8)key_type);
5382 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE) {
5383
5384 if (key_type == 3)
5385 issue_deauth_11w(padapter, bc_addr, 0, IEEE80211W_RIGHT_KEY);
5386
5387 /* TX unicast deauth to every client STA */
5388 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
5389 for (index = 0; index < NUM_STA; index++) {
5390 psta = NULL;
5391
5392 phead = &(pstapriv->sta_hash[index]);
5393 plist = get_next(phead);
5394
5395 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
5396 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
5397 plist = get_next(plist);
5398 _rtw_memcpy(&mac_addr[psta->cmn.mac_id][0], psta->cmn.mac_addr, ETH_ALEN);
5399 }
5400 }
5401 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
5402
5403 for (index = 0; index < macid_ctl->num && index < NUM_STA; index++) {
5404 if (rtw_macid_is_used(macid_ctl, index) && !rtw_macid_is_bmc(macid_ctl, index)) {
5405 if (!_rtw_memcmp(get_my_bssid(&(pmlmeinfo->network)), &mac_addr[index][0], ETH_ALEN)) {
5406 if (key_type != 3)
5407 issue_deauth_11w(padapter, &mac_addr[index][0], 0, (u8)key_type);
5408
5409 psta = rtw_get_stainfo(pstapriv, &mac_addr[index][0]);
5410 if (psta && key_type != IEEE80211W_WRONG_KEY && key_type != IEEE80211W_NO_KEY) {
5411 u8 updated = _FALSE;
5412
5413 _enter_critical_bh(&pstapriv->asoc_list_lock, &irqL);
5414 if (rtw_is_list_empty(&psta->asoc_list) == _FALSE) {
5415 rtw_list_delete(&psta->asoc_list);
5416 pstapriv->asoc_list_cnt--;
5417 updated = ap_free_sta(padapter, psta, _FALSE, WLAN_REASON_PREV_AUTH_NOT_VALID, _TRUE);
5418
5419 }
5420 _exit_critical_bh(&pstapriv->asoc_list_lock, &irqL);
5421
5422 associated_clients_update(padapter, updated, STA_INFO_UPDATE_ALL);
5423 }
5424
5425 RTW_INFO("STA[%u]:"MAC_FMT"\n", index , MAC_ARG(&mac_addr[index][0]));
5426 }
5427 }
5428 }
5429 }
5430
5431 return count;
5432 }
5433
proc_get_tx_deauth(struct seq_file * m,void * v)5434 int proc_get_tx_deauth(struct seq_file *m, void *v)
5435 {
5436 struct net_device *dev = m->private;
5437 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5438
5439 RTW_PRINT_SEL(m, "%s\n", __func__);
5440 return 0;
5441 }
5442
proc_set_tx_auth(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5443 ssize_t proc_set_tx_auth(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5444 {
5445 struct net_device *dev = data;
5446 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5447 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
5448 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
5449 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
5450 struct sta_priv *pstapriv = &padapter->stapriv;
5451 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
5452 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
5453 struct sta_info *psta;
5454 _list *plist, *phead;
5455 _irqL irqL;
5456 char tmp[16];
5457 u8 mac_addr[NUM_STA][ETH_ALEN];
5458 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
5459 u32 tx_auth;
5460 u8 index;
5461
5462
5463 if (count > 2) {
5464 RTW_INFO("argument size is more than 2\n");
5465 return -EFAULT;
5466 }
5467
5468 if (buffer && !copy_from_user(tmp, buffer, sizeof(tmp))) {
5469
5470 int num = sscanf(tmp, "%x", &tx_auth);
5471
5472 if (num != 1) {
5473 RTW_INFO("invalid read_reg parameter!\n");
5474 return count;
5475 }
5476 RTW_INFO("1: setnd auth, 2: send assoc request. tx_auth=%d\n", tx_auth);
5477 }
5478
5479 if ((check_fwstate(pmlmepriv, WIFI_STATION_STATE) == _TRUE)
5480 && (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)) {
5481 if (tx_auth == 1) {
5482 /* TX unicast auth to AP */
5483 issue_auth(padapter, NULL, 0);
5484 } else if (tx_auth == 2) {
5485 /* TX unicast auth to AP */
5486 issue_assocreq(padapter);
5487 }
5488 }
5489
5490 return count;
5491 }
5492
proc_get_tx_auth(struct seq_file * m,void * v)5493 int proc_get_tx_auth(struct seq_file *m, void *v)
5494 {
5495 struct net_device *dev = m->private;
5496 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5497
5498 RTW_PRINT_SEL(m, "%s\n", __func__);
5499 return 0;
5500 }
5501 #endif /* CONFIG_IEEE80211W */
5502
5503 #ifdef CONFIG_MCC_MODE
proc_get_mcc_info(struct seq_file * m,void * v)5504 int proc_get_mcc_info(struct seq_file *m, void *v)
5505 {
5506 struct net_device *dev = m->private;
5507 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
5508
5509 dump_adapters_status(m, adapter_to_dvobj(adapter));
5510 rtw_hal_dump_mcc_info(m, adapter_to_dvobj(adapter));
5511 return 0;
5512 }
5513
proc_get_mcc_policy_table(struct seq_file * m,void * v)5514 int proc_get_mcc_policy_table(struct seq_file *m, void *v)
5515 {
5516 struct net_device *dev = m->private;
5517 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
5518
5519 rtw_hal_dump_mcc_policy_table(m);
5520 return 0;
5521 }
5522
proc_set_mcc_policy_table(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5523 ssize_t proc_set_mcc_policy_table(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5524 {
5525 struct net_device *dev = data;
5526 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5527 char tmp[255];
5528 s32 mcc_policy_table_idx;
5529 u32 mcc_duration;
5530 u32 mcc_tsf_sync_offset;
5531 u32 mcc_start_time_offset;
5532 u32 mcc_interval;
5533 s32 mcc_guard_offset0;
5534 s32 mcc_guard_offset1;
5535
5536 if (NULL == buffer) {
5537 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5538 return -EFAULT;
5539 }
5540
5541 if (count < 1) {
5542 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5543 return -EFAULT;
5544 }
5545
5546 if (count > sizeof(tmp)) {
5547 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5548 rtw_warn_on(1);
5549 return -EFAULT;
5550 }
5551
5552 if (buffer && !copy_from_user(tmp, buffer, count)) {
5553 #if 1
5554 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
5555 _adapter *iface = NULL;
5556 u8 i = 0;
5557 int num = sscanf(tmp, "%d %u %u %u %u %d %d"
5558 , &mcc_policy_table_idx, &mcc_duration, &mcc_tsf_sync_offset, &mcc_start_time_offset
5559 , &mcc_interval, &mcc_guard_offset0, &mcc_guard_offset1);
5560
5561 if (num < 7) {
5562 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 7\n", FUNC_ADPT_ARG(padapter));
5563 return -EINVAL;
5564 }
5565 #if 0
5566 RTW_INFO("mcc_policy_table_idx:%d\n", mcc_policy_table_idx);
5567 RTW_INFO("mcc_duration:%d\n", mcc_duration);
5568 RTW_INFO("mcc_tsf_sync_offset:%d\n", mcc_tsf_sync_offset);
5569 RTW_INFO("mcc_start_time_offset:%d\n", mcc_start_time_offset);
5570 RTW_INFO("mcc_interval:%d\n", mcc_interval);
5571 RTW_INFO("mcc_guard_offset0:%d\n", mcc_guard_offset0);
5572 RTW_INFO("mcc_guard_offset1:%d\n", mcc_guard_offset1);
5573 #endif
5574 for (i = 0; i < dvobj->iface_nums; i++) {
5575 iface = dvobj->padapters[i];
5576 if (!iface)
5577 continue;
5578 iface->registrypriv.rtw_mcc_policy_table_idx = mcc_policy_table_idx;
5579 iface->registrypriv.rtw_mcc_duration = mcc_duration;
5580 iface->registrypriv.rtw_mcc_tsf_sync_offset = mcc_tsf_sync_offset;
5581 iface->registrypriv.rtw_mcc_start_time_offset = mcc_start_time_offset;
5582 iface->registrypriv.rtw_mcc_interval = mcc_interval;
5583 iface->registrypriv.rtw_mcc_guard_offset0 = mcc_guard_offset0;
5584 iface->registrypriv.rtw_mcc_guard_offset1 = mcc_guard_offset1;
5585 }
5586
5587 rtw_hal_mcc_update_switch_channel_policy_table(padapter);
5588 #endif
5589 }
5590
5591 return count;
5592 }
5593
proc_set_mcc_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5594 ssize_t proc_set_mcc_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5595 {
5596 struct net_device *dev = data;
5597 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5598 char tmp[255];
5599 u32 en_mcc = 0;
5600
5601 if (NULL == buffer) {
5602 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5603 return -EFAULT;
5604 }
5605
5606 if (count < 1) {
5607 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5608 return -EFAULT;
5609 }
5610
5611 if (count > sizeof(tmp)) {
5612 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5613 rtw_warn_on(1);
5614 return -EFAULT;
5615 }
5616
5617 if (buffer && !copy_from_user(tmp, buffer, count)) {
5618 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
5619 _adapter *iface = NULL;
5620 u8 i = 0;
5621 int num = sscanf(tmp, "%u", &en_mcc);
5622
5623 if (num < 1) {
5624 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5625 return -EINVAL;
5626 }
5627
5628 RTW_INFO("%s: en_mcc = %d\n", __func__, en_mcc);
5629
5630 for (i = 0; i < dvobj->iface_nums; i++) {
5631 iface = dvobj->padapters[i];
5632 if (!iface)
5633 continue;
5634 iface->registrypriv.en_mcc = en_mcc;
5635 }
5636 }
5637
5638 return count;
5639 }
5640
proc_set_mcc_single_tx_criteria(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5641 ssize_t proc_set_mcc_single_tx_criteria(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5642 {
5643 struct net_device *dev = data;
5644 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5645 char tmp[255];
5646 u32 mcc_single_tx_criteria = 0;
5647
5648 if (NULL == buffer) {
5649 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5650 return -EFAULT;
5651 }
5652
5653 if (count < 1) {
5654 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5655 return -EFAULT;
5656 }
5657
5658 if (count > sizeof(tmp)) {
5659 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5660 rtw_warn_on(1);
5661 return -EFAULT;
5662 }
5663
5664 if (buffer && !copy_from_user(tmp, buffer, count)) {
5665 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
5666 _adapter *iface = NULL;
5667 u8 i = 0;
5668 int num = sscanf(tmp, "%u", &mcc_single_tx_criteria);
5669
5670 if (num < 1) {
5671 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5672 return -EINVAL;
5673 }
5674
5675 RTW_INFO("%s: mcc_single_tx_criteria = %d\n", __func__, mcc_single_tx_criteria);
5676
5677 for (i = 0; i < dvobj->iface_nums; i++) {
5678 iface = dvobj->padapters[i];
5679 if (!iface)
5680 continue;
5681 iface->registrypriv.rtw_mcc_single_tx_cri = mcc_single_tx_criteria;
5682 }
5683
5684
5685 }
5686
5687 return count;
5688 }
5689
5690
proc_set_mcc_ap_bw20_target_tp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5691 ssize_t proc_set_mcc_ap_bw20_target_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5692 {
5693 struct net_device *dev = data;
5694 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5695 char tmp[255];
5696 u32 mcc_ap_bw20_target_tp = 0;
5697
5698 if (NULL == buffer) {
5699 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5700 return -EFAULT;
5701 }
5702
5703 if (count < 1) {
5704 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5705 return -EFAULT;
5706 }
5707
5708 if (count > sizeof(tmp)) {
5709 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5710 rtw_warn_on(1);
5711 return -EFAULT;
5712 }
5713
5714 if (buffer && !copy_from_user(tmp, buffer, count)) {
5715 int num = sscanf(tmp, "%u", &mcc_ap_bw20_target_tp);
5716
5717 if (num < 1) {
5718 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5719 return -EINVAL;
5720 }
5721
5722 RTW_INFO("%s: mcc_ap_bw20_target_tp = %d\n", __func__, mcc_ap_bw20_target_tp);
5723
5724 padapter->registrypriv.rtw_mcc_ap_bw20_target_tx_tp = mcc_ap_bw20_target_tp;
5725
5726
5727 }
5728
5729 return count;
5730 }
5731
proc_set_mcc_ap_bw40_target_tp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5732 ssize_t proc_set_mcc_ap_bw40_target_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5733 {
5734 struct net_device *dev = data;
5735 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5736 char tmp[255];
5737 u32 mcc_ap_bw40_target_tp = 0;
5738
5739 if (NULL == buffer) {
5740 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5741 return -EFAULT;
5742 }
5743
5744 if (count < 1) {
5745 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5746 return -EFAULT;
5747 }
5748
5749 if (count > sizeof(tmp)) {
5750 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5751 rtw_warn_on(1);
5752 return -EFAULT;
5753 }
5754
5755 if (buffer && !copy_from_user(tmp, buffer, count)) {
5756 int num = sscanf(tmp, "%u", &mcc_ap_bw40_target_tp);
5757
5758 if (num < 1) {
5759 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5760 return -EINVAL;
5761 }
5762
5763 RTW_INFO("%s: mcc_ap_bw40_target_tp = %d\n", __func__, mcc_ap_bw40_target_tp);
5764
5765 padapter->registrypriv.rtw_mcc_ap_bw40_target_tx_tp = mcc_ap_bw40_target_tp;
5766
5767
5768 }
5769
5770 return count;
5771 }
5772
proc_set_mcc_ap_bw80_target_tp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5773 ssize_t proc_set_mcc_ap_bw80_target_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5774 {
5775 struct net_device *dev = data;
5776 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5777 char tmp[255];
5778 u32 mcc_ap_bw80_target_tp = 0;
5779
5780 if (NULL == buffer) {
5781 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5782 return -EFAULT;
5783 }
5784
5785 if (count < 1) {
5786 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5787 return -EFAULT;
5788 }
5789
5790 if (count > sizeof(tmp)) {
5791 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5792 rtw_warn_on(1);
5793 return -EFAULT;
5794 }
5795
5796 if (buffer && !copy_from_user(tmp, buffer, count)) {
5797 int num = sscanf(tmp, "%u", &mcc_ap_bw80_target_tp);
5798
5799 if (num < 1) {
5800 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5801 return -EINVAL;
5802 }
5803
5804 RTW_INFO("%s: mcc_ap_bw80_target_tp = %d\n", __func__, mcc_ap_bw80_target_tp);
5805
5806 padapter->registrypriv.rtw_mcc_ap_bw80_target_tx_tp = mcc_ap_bw80_target_tp;
5807
5808
5809 }
5810
5811 return count;
5812 }
5813
proc_set_mcc_sta_bw20_target_tp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5814 ssize_t proc_set_mcc_sta_bw20_target_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5815 {
5816 struct net_device *dev = data;
5817 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5818 char tmp[255];
5819 u32 mcc_sta_bw20_target_tp = 0;
5820
5821 if (NULL == buffer) {
5822 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5823 return -EFAULT;
5824 }
5825
5826 if (count < 1) {
5827 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5828 return -EFAULT;
5829 }
5830
5831 if (count > sizeof(tmp)) {
5832 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5833 rtw_warn_on(1);
5834 return -EFAULT;
5835 }
5836
5837 if (buffer && !copy_from_user(tmp, buffer, count)) {
5838 int num = sscanf(tmp, "%u", &mcc_sta_bw20_target_tp);
5839
5840 if (num < 1) {
5841 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5842 return -EINVAL;
5843 }
5844
5845 RTW_INFO("%s: mcc_sta_bw20_target_tp = %d\n", __func__, mcc_sta_bw20_target_tp);
5846
5847 padapter->registrypriv.rtw_mcc_sta_bw20_target_tx_tp = mcc_sta_bw20_target_tp;
5848
5849
5850 }
5851
5852 return count;
5853 }
5854
proc_set_mcc_sta_bw40_target_tp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5855 ssize_t proc_set_mcc_sta_bw40_target_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5856 {
5857 struct net_device *dev = data;
5858 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5859 char tmp[255];
5860 u32 mcc_sta_bw40_target_tp = 0;
5861
5862 if (NULL == buffer) {
5863 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5864 return -EFAULT;
5865 }
5866
5867 if (count < 1) {
5868 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5869 return -EFAULT;
5870 }
5871
5872 if (count > sizeof(tmp)) {
5873 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5874 rtw_warn_on(1);
5875 return -EFAULT;
5876 }
5877
5878 if (buffer && !copy_from_user(tmp, buffer, count)) {
5879 int num = sscanf(tmp, "%u", &mcc_sta_bw40_target_tp);
5880
5881 if (num < 1) {
5882 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5883 return -EINVAL;
5884 }
5885
5886 RTW_INFO("%s: mcc_sta_bw40_target_tp = %d\n", __func__, mcc_sta_bw40_target_tp);
5887
5888 padapter->registrypriv.rtw_mcc_sta_bw40_target_tx_tp = mcc_sta_bw40_target_tp;
5889
5890
5891 }
5892
5893 return count;
5894 }
5895
proc_set_mcc_sta_bw80_target_tp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5896 ssize_t proc_set_mcc_sta_bw80_target_tp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5897 {
5898 struct net_device *dev = data;
5899 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5900 char tmp[255];
5901 u32 mcc_sta_bw80_target_tp = 0;
5902
5903 if (NULL == buffer) {
5904 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n", FUNC_ADPT_ARG(padapter));
5905 return -EFAULT;
5906 }
5907
5908 if (count < 1) {
5909 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n", FUNC_ADPT_ARG(padapter));
5910 return -EFAULT;
5911 }
5912
5913 if (count > sizeof(tmp)) {
5914 RTW_INFO(FUNC_ADPT_FMT ": input length is too large\n", FUNC_ADPT_ARG(padapter));
5915 rtw_warn_on(1);
5916 return -EFAULT;
5917 }
5918
5919 if (buffer && !copy_from_user(tmp, buffer, count)) {
5920 int num = sscanf(tmp, "%u", &mcc_sta_bw80_target_tp);
5921
5922 if (num < 1) {
5923 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5924 return -EINVAL;
5925 }
5926
5927 RTW_INFO("%s: mcc_sta_bw80_target_tp = %d\n", __func__, mcc_sta_bw80_target_tp);
5928
5929 padapter->registrypriv.rtw_mcc_sta_bw80_target_tx_tp = mcc_sta_bw80_target_tp;
5930
5931
5932 }
5933
5934 return count;
5935 }
5936 #endif /* CONFIG_MCC_MODE */
5937
proc_get_ack_timeout(struct seq_file * m,void * v)5938 int proc_get_ack_timeout(struct seq_file *m, void *v)
5939 {
5940 struct net_device *dev = m->private;
5941 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5942 u8 ack_timeout_val, ack_timeout_val_cck;
5943
5944 ack_timeout_val = rtw_read8(padapter, REG_ACKTO);
5945
5946 #ifdef CONFIG_RTL8821C
5947 ack_timeout_val_cck = rtw_read8(padapter, REG_ACKTO_CCK_8821C);
5948 RTW_PRINT_SEL(m, "Current CCK packet ACK Timeout = %d us (0x%x).\n", ack_timeout_val_cck, ack_timeout_val_cck);
5949 RTW_PRINT_SEL(m, "Current non-CCK packet ACK Timeout = %d us (0x%x).\n", ack_timeout_val, ack_timeout_val);
5950 #else
5951 RTW_PRINT_SEL(m, "Current ACK Timeout = %d us (0x%x).\n", ack_timeout_val, ack_timeout_val);
5952 #endif
5953
5954 return 0;
5955 }
5956
proc_set_ack_timeout(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5957 ssize_t proc_set_ack_timeout(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5958 {
5959 struct net_device *dev = data;
5960 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5961 char tmp[32];
5962 u32 ack_timeout_ms, ack_timeout_ms_cck;
5963
5964 if (count > sizeof(tmp)) {
5965 rtw_warn_on(1);
5966 return -EFAULT;
5967 }
5968
5969 if (buffer && !copy_from_user(tmp, buffer, count)) {
5970 int num = sscanf(tmp, "%u %u", &ack_timeout_ms, &ack_timeout_ms_cck);
5971
5972 #ifdef CONFIG_RTL8821C
5973 if (num < 2) {
5974 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 2\n", FUNC_ADPT_ARG(padapter));
5975 return -EINVAL;
5976 }
5977 #else
5978 if (num < 1) {
5979 RTW_INFO(FUNC_ADPT_FMT ": input parameters < 1\n", FUNC_ADPT_ARG(padapter));
5980 return -EINVAL;
5981 }
5982 #endif
5983 /* This register sets the Ack time out value after Tx unicast packet. It is in units of us. */
5984 rtw_write8(padapter, REG_ACKTO, (u8)ack_timeout_ms);
5985
5986 #ifdef CONFIG_RTL8821C
5987 /* This register sets the Ack time out value after Tx unicast CCK packet. It is in units of us. */
5988 rtw_write8(padapter, REG_ACKTO_CCK_8821C, (u8)ack_timeout_ms_cck);
5989 RTW_INFO("Set CCK packet ACK Timeout to %d us.\n", ack_timeout_ms_cck);
5990 RTW_INFO("Set non-CCK packet ACK Timeout to %d us.\n", ack_timeout_ms);
5991 #else
5992 RTW_INFO("Set ACK Timeout to %d us.\n", ack_timeout_ms);
5993 #endif
5994 }
5995
5996 return count;
5997 }
5998
proc_set_iqk_fw_offload(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5999 ssize_t proc_set_iqk_fw_offload(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6000 {
6001 struct net_device *dev = data;
6002 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6003 _adapter *pri_adapter = GET_PRIMARY_ADAPTER(adapter);
6004 HAL_DATA_TYPE *hal = GET_HAL_DATA(adapter);
6005 char tmp[32];
6006 u32 enable = 0;
6007
6008 if (buffer == NULL) {
6009 RTW_INFO("input buffer is NULL!\n");
6010 return -EFAULT;
6011 }
6012
6013 if (count < 1) {
6014 RTW_INFO("input length is 0!\n");
6015 return -EFAULT;
6016 }
6017
6018 if (count > sizeof(tmp)) {
6019 RTW_INFO("input length is too large\n");
6020 rtw_warn_on(1);
6021 return -EFAULT;
6022 }
6023
6024 if (buffer && !copy_from_user(tmp, buffer, count)) {
6025 int num = sscanf(tmp, "%d", &enable);
6026
6027 if (num < 1) {
6028 RTW_INFO("input parameters < 1\n");
6029 return -EINVAL;
6030 }
6031
6032 if (hal->RegIQKFWOffload != enable) {
6033 hal->RegIQKFWOffload = enable;
6034 rtw_hal_update_iqk_fw_offload_cap(pri_adapter);
6035 }
6036 }
6037
6038 return count;
6039 }
6040
proc_get_iqk_fw_offload(struct seq_file * m,void * v)6041 int proc_get_iqk_fw_offload(struct seq_file *m, void *v)
6042 {
6043 struct net_device *dev = m->private;
6044 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
6045 HAL_DATA_TYPE *hal = GET_HAL_DATA(adapter);
6046
6047
6048 RTW_PRINT_SEL(m, "IQK FW offload:%s\n", hal->RegIQKFWOffload?"enable":"disable");
6049 return 0;
6050 }
6051
6052 #ifdef CONFIG_DBG_RF_CAL
proc_get_iqk_info(struct seq_file * m,void * v)6053 int proc_get_iqk_info(struct seq_file *m, void *v)
6054 {
6055 struct net_device *dev = m->private;
6056 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6057
6058 return 0;
6059 }
6060
proc_set_iqk(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6061 ssize_t proc_set_iqk(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6062 {
6063 struct net_device *dev = data;
6064 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6065 char tmp[32];
6066 u32 recovery, clear, segment;
6067
6068 if (count < 1)
6069 return -EFAULT;
6070
6071 if (count > sizeof(tmp)) {
6072 rtw_warn_on(1);
6073 return -EFAULT;
6074 }
6075
6076 if (buffer && !copy_from_user(tmp, buffer, count)) {
6077
6078 int num = sscanf(tmp, "%d %d %d", &recovery, &clear, &segment);
6079
6080 rtw_hal_iqk_test(padapter, recovery, clear, segment);
6081 }
6082
6083 return count;
6084
6085 }
6086
proc_get_lck_info(struct seq_file * m,void * v)6087 int proc_get_lck_info(struct seq_file *m, void *v)
6088 {
6089 struct net_device *dev = m->private;
6090 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6091
6092 return 0;
6093 }
6094
proc_set_lck(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)6095 ssize_t proc_set_lck(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
6096 {
6097 struct net_device *dev = data;
6098 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
6099 char tmp[32];
6100 u32 trigger;
6101
6102 if (count < 1)
6103 return -EFAULT;
6104
6105 if (count > sizeof(tmp)) {
6106 rtw_warn_on(1);
6107 return -EFAULT;
6108 }
6109
6110 if (buffer && !copy_from_user(tmp, buffer, count)) {
6111
6112 int num = sscanf(tmp, "%d", &trigger);
6113
6114 rtw_hal_lck_test(padapter);
6115 }
6116
6117 return count;
6118 }
6119 #endif /* CONFIG_DBG_RF_CAL */
6120
6121 #endif /* CONFIG_PROC_DEBUG */
6122