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