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