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
16 #include <linux/ctype.h> /* tolower() */
17 #include <drv_types.h>
18 #include "rtw_proc.h"
19 #include <rtw_btc.h>
20 #include "_hal_rate.h"
21
22 #ifdef CONFIG_PROC_DEBUG
23
24 static struct proc_dir_entry *rtw_proc = NULL;
25
get_rtw_drv_proc(void)26 inline struct proc_dir_entry *get_rtw_drv_proc(void)
27 {
28 return rtw_proc;
29 }
30
31 #define RTW_PROC_NAME DRV_NAME
32
33 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0))
34 #define file_inode(file) ((file)->f_dentry->d_inode)
35 #endif
36
37 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0))
38 #define PDE_DATA(inode) PDE((inode))->data
39 #define proc_get_parent_data(inode) PDE((inode))->parent->data
40 #elif (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 17, 0))
41 #define PDE_DATA pde_data
42 #endif
43
44 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24))
45 #define get_proc_net proc_net
46 #else
47 #define get_proc_net init_net.proc_net
48 #endif
49
50 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0))
single_open_size(struct file * file,int (* show)(struct seq_file *,void *),void * data,size_t size)51 int single_open_size(struct file *file, int (*show)(struct seq_file *, void *),
52 void *data, size_t size)
53 {
54 char *buf = kmalloc(size, GFP_KERNEL);
55 int ret;
56 if (!buf)
57 return -ENOMEM;
58 ret = single_open(file, show, data);
59 if (ret) {
60 kfree(buf);
61 return ret;
62 }
63 ((struct seq_file *)file->private_data)->buf = buf;
64 ((struct seq_file *)file->private_data)->size = size;
65 return 0;
66 }
67 #endif
68
rtw_proc_create_dir(const char * name,struct proc_dir_entry * parent,void * data)69 inline struct proc_dir_entry *rtw_proc_create_dir(const char *name, struct proc_dir_entry *parent, void *data)
70 {
71 struct proc_dir_entry *entry;
72
73 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
74 entry = proc_mkdir_data(name, S_IRUGO | S_IXUGO, parent, data);
75 #else
76 /* entry = proc_mkdir_mode(name, S_IRUGO|S_IXUGO, parent); */
77 entry = proc_mkdir(name, parent);
78 if (entry)
79 entry->data = data;
80 #endif
81
82 return entry;
83 }
84
rtw_proc_create_entry(const char * name,struct proc_dir_entry * parent,const struct rtw_proc_ops * fops,void * data)85 inline struct proc_dir_entry *rtw_proc_create_entry(const char *name, struct proc_dir_entry *parent,
86 const struct rtw_proc_ops *fops, void * data)
87 {
88 struct proc_dir_entry *entry;
89
90 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26))
91 entry = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUGO, parent, fops, data);
92 #else
93 entry = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUGO, parent);
94 if (entry) {
95 entry->data = data;
96 entry->proc_fops = fops;
97 }
98 #endif
99
100 return entry;
101 }
102
proc_get_dummy(struct seq_file * m,void * v)103 static int proc_get_dummy(struct seq_file *m, void *v)
104 {
105 return 0;
106 }
107
proc_get_drv_version(struct seq_file * m,void * v)108 static int proc_get_drv_version(struct seq_file *m, void *v)
109 {
110 dump_drv_version(m);
111 return 0;
112 }
113
proc_get_log_level(struct seq_file * m,void * v)114 static int proc_get_log_level(struct seq_file *m, void *v)
115 {
116 dump_log_level(m);
117 return 0;
118 }
119
proc_get_drv_cfg(struct seq_file * m,void * v)120 static int proc_get_drv_cfg(struct seq_file *m, void *v)
121 {
122 dump_drv_cfg(m);
123 return 0;
124 }
125
proc_set_log_level(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)126 static ssize_t proc_set_log_level(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
127 {
128 char tmp[32];
129 int log_level;
130
131 if (count < 1)
132 return -EINVAL;
133
134 if (count > sizeof(tmp)) {
135 rtw_warn_on(1);
136 return -EFAULT;
137 }
138
139 #ifdef CONFIG_RTW_DEBUG
140 if (buffer && !copy_from_user(tmp, buffer, count)) {
141
142 int num = sscanf(tmp, "%d ", &log_level);
143
144 if (num == 1 &&
145 log_level >= _DRV_NONE_ && log_level <= _DRV_MAX_) {
146 rtw_drv_log_level = log_level;
147 printk("rtw_drv_log_level:%d\n", rtw_drv_log_level);
148 }
149 } else
150 return -EFAULT;
151 #else
152 printk("CONFIG_RTW_DEBUG is disabled\n");
153 #endif
154
155 return count;
156 }
157
158 #ifdef DBG_MEM_ALLOC
proc_get_mstat(struct seq_file * m,void * v)159 static int proc_get_mstat(struct seq_file *m, void *v)
160 {
161 rtw_mstat_dump(m);
162 return 0;
163 }
164 #endif /* DBG_MEM_ALLOC */
165
166 static bool regd_info;
proc_get_country_chplan_map(struct seq_file * m,void * v)167 static int proc_get_country_chplan_map(struct seq_file *m, void *v)
168 {
169 dump_country_chplan_map(m, regd_info);
170 return 0;
171 }
172
proc_set_country_chplan_map(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)173 static ssize_t proc_set_country_chplan_map(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
174 {
175 char tmp[32];
176 int regd_info_val;
177
178 if (count < 1)
179 return -EINVAL;
180
181 if (count > sizeof(tmp)) {
182 rtw_warn_on(1);
183 return -EFAULT;
184 }
185
186 if (buffer && !copy_from_user(tmp, buffer, count)) {
187 int num = sscanf(tmp, "%d", ®d_info_val);
188
189 if (num >= 1)
190 regd_info = regd_info_val ? 1 : 0;
191 } else
192 return -EFAULT;
193
194 return count;
195 }
196
proc_get_country_list(struct seq_file * m,void * v)197 static int proc_get_country_list(struct seq_file *m, void *v)
198 {
199 dump_country_list(m);
200 return 0;
201 }
202
proc_get_chplan_id_list(struct seq_file * m,void * v)203 static int proc_get_chplan_id_list(struct seq_file *m, void *v)
204 {
205 dump_chplan_id_list(m);
206 return 0;
207 }
208
proc_get_chplan_country_list(struct seq_file * m,void * v)209 static int proc_get_chplan_country_list(struct seq_file *m, void *v)
210 {
211 dump_chplan_country_list(m);
212 return 0;
213 }
214
215 #if CONFIG_IEEE80211_BAND_6GHZ
proc_get_chplan_6g_id_list(struct seq_file * m,void * v)216 static int proc_get_chplan_6g_id_list(struct seq_file *m, void *v)
217 {
218 dump_chplan_6g_id_list(m);
219 return 0;
220 }
221
proc_get_chplan_6g_country_list(struct seq_file * m,void * v)222 static int proc_get_chplan_6g_country_list(struct seq_file *m, void *v)
223 {
224 dump_chplan_6g_country_list(m);
225 return 0;
226 }
227 #endif
228
229 #ifdef CONFIG_RTW_DEBUG
proc_get_chplan_test(struct seq_file * m,void * v)230 static int proc_get_chplan_test(struct seq_file *m, void *v)
231 {
232 dump_chplan_test(m);
233 return 0;
234 }
235 #endif
236
proc_get_chplan_ver(struct seq_file * m,void * v)237 static int proc_get_chplan_ver(struct seq_file *m, void *v)
238 {
239 dump_chplan_ver(m);
240 return 0;
241 }
242
proc_get_global_op_class(struct seq_file * m,void * v)243 static int proc_get_global_op_class(struct seq_file *m, void *v)
244 {
245 dump_global_op_class(m);
246 return 0;
247 }
248
249 extern void rtw_hal_get_version(char *str, u32 len);
250
proc_get_hal_info(struct seq_file * m,void * v)251 static int proc_get_hal_info(struct seq_file *m, void *v)
252 {
253 char ver[30] = {0};
254
255 rtw_hal_get_version(ver, 30);
256
257 RTW_PRINT_SEL(m, "version: %s\n", ver);
258
259 return 0;
260 }
261
262
263 /*
264 * rtw_drv_proc:
265 * init/deinit when register/unregister driver
266 */
267 const struct rtw_proc_hdl drv_proc_hdls[] = {
268 RTW_PROC_HDL_SSEQ("ver_info", proc_get_drv_version, NULL),
269 RTW_PROC_HDL_SSEQ("log_level", proc_get_log_level, proc_set_log_level),
270 RTW_PROC_HDL_SSEQ("drv_cfg", proc_get_drv_cfg, NULL),
271 #ifdef DBG_MEM_ALLOC
272 RTW_PROC_HDL_SSEQ("mstat", proc_get_mstat, NULL),
273 #endif /* DBG_MEM_ALLOC */
274 RTW_PROC_HDL_SSEQ("country_chplan_map", proc_get_country_chplan_map, proc_set_country_chplan_map),
275 RTW_PROC_HDL_SSEQ("country_list", proc_get_country_list, NULL),
276 RTW_PROC_HDL_SSEQ("chplan_id_list", proc_get_chplan_id_list, NULL),
277 RTW_PROC_HDL_SSEQ("chplan_country_list", proc_get_chplan_country_list, NULL),
278 #if CONFIG_IEEE80211_BAND_6GHZ
279 RTW_PROC_HDL_SSEQ("chplan_6g_id_list", proc_get_chplan_6g_id_list, NULL),
280 RTW_PROC_HDL_SSEQ("chplan_6g_country_list", proc_get_chplan_6g_country_list, NULL),
281 #endif
282 #ifdef CONFIG_RTW_DEBUG
283 RTW_PROC_HDL_SSEQ("chplan_test", proc_get_chplan_test, NULL),
284 #endif
285 RTW_PROC_HDL_SSEQ("chplan_ver", proc_get_chplan_ver, NULL),
286 RTW_PROC_HDL_SSEQ("global_op_class", proc_get_global_op_class, NULL),
287 RTW_PROC_HDL_SSEQ("hal_info", proc_get_hal_info, NULL),
288 #ifdef CONFIG_RTKM
289 RTW_PROC_HDL_SSEQ("rtkm", proc_get_rtkm_info, proc_set_rtkm_info),
290 #endif /* CONFIG_RTKM */
291 };
292
293 const int drv_proc_hdls_num = sizeof(drv_proc_hdls) / sizeof(struct rtw_proc_hdl);
294
rtw_drv_proc_open(struct inode * inode,struct file * file)295 static int rtw_drv_proc_open(struct inode *inode, struct file *file)
296 {
297 /* struct net_device *dev = proc_get_parent_data(inode); */
298 ssize_t index = (ssize_t)PDE_DATA(inode);
299 const struct rtw_proc_hdl *hdl = drv_proc_hdls + index;
300 void *private = NULL;
301
302 if (hdl->type == RTW_PROC_HDL_TYPE_SEQ) {
303 int res = seq_open(file, hdl->u.seq_op);
304
305 if (res == 0)
306 ((struct seq_file *)file->private_data)->private = private;
307
308 return res;
309 } else if (hdl->type == RTW_PROC_HDL_TYPE_SSEQ) {
310 int (*show)(struct seq_file *, void *) = hdl->u.show ? hdl->u.show : proc_get_dummy;
311
312 return single_open(file, show, private);
313 } else if (hdl->type == RTW_PROC_HDL_TYPE_SZSEQ) {
314 int (*show)(struct seq_file *, void *) = hdl->u.sz.show ? hdl->u.sz.show : proc_get_dummy;
315 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
316 return single_open_size(file, show, private, hdl->u.sz.size);
317 #else
318 return single_open(file, show, private);
319 #endif
320 } else {
321 return -EROFS;
322 }
323 }
324
rtw_drv_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * pos)325 static ssize_t rtw_drv_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos)
326 {
327 ssize_t index = (ssize_t)PDE_DATA(file_inode(file));
328 const struct rtw_proc_hdl *hdl = drv_proc_hdls + index;
329 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *, void *) = hdl->write;
330
331 if (write)
332 return write(file, buffer, count, pos, NULL);
333
334 return -EROFS;
335 }
336
337 static const struct rtw_proc_ops rtw_drv_proc_seq_fops = {
338 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
339 .proc_open = rtw_drv_proc_open,
340 .proc_read = seq_read,
341 .proc_lseek = seq_lseek,
342 .proc_release = seq_release,
343 .proc_write = rtw_drv_proc_write,
344 #else
345 .owner = THIS_MODULE,
346 .open = rtw_drv_proc_open,
347 .read = seq_read,
348 .llseek = seq_lseek,
349 .release = seq_release,
350 .write = rtw_drv_proc_write,
351 #endif
352 };
353
354 static const struct rtw_proc_ops rtw_drv_proc_sseq_fops = {
355 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
356 .proc_open = rtw_drv_proc_open,
357 .proc_read = seq_read,
358 .proc_lseek = seq_lseek,
359 .proc_release = single_release,
360 .proc_write = rtw_drv_proc_write,
361 #else
362 .owner = THIS_MODULE,
363 .open = rtw_drv_proc_open,
364 .read = seq_read,
365 .llseek = seq_lseek,
366 .release = single_release,
367 .write = rtw_drv_proc_write,
368 #endif
369 };
370
rtw_drv_proc_init(void)371 int rtw_drv_proc_init(void)
372 {
373 int ret = _FAIL;
374 ssize_t i;
375 struct proc_dir_entry *entry = NULL;
376
377 if (rtw_proc != NULL) {
378 rtw_warn_on(1);
379 goto exit;
380 }
381
382 rtw_proc = rtw_proc_create_dir(RTW_PROC_NAME, get_proc_net, NULL);
383
384 if (rtw_proc == NULL) {
385 rtw_warn_on(1);
386 goto exit;
387 }
388
389 for (i = 0; i < drv_proc_hdls_num; i++) {
390 if (drv_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SEQ)
391 entry = rtw_proc_create_entry(drv_proc_hdls[i].name, rtw_proc, &rtw_drv_proc_seq_fops, (void *)i);
392 else if (drv_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SSEQ ||
393 drv_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SZSEQ)
394 entry = rtw_proc_create_entry(drv_proc_hdls[i].name, rtw_proc, &rtw_drv_proc_sseq_fops, (void *)i);
395 else
396 entry = NULL;
397
398 if (!entry) {
399 rtw_warn_on(1);
400 goto exit;
401 }
402 }
403
404 ret = _SUCCESS;
405
406 exit:
407 return ret;
408 }
409
rtw_drv_proc_deinit(void)410 void rtw_drv_proc_deinit(void)
411 {
412 int i;
413
414 if (rtw_proc == NULL)
415 return;
416
417 for (i = 0; i < drv_proc_hdls_num; i++)
418 remove_proc_entry(drv_proc_hdls[i].name, rtw_proc);
419
420 remove_proc_entry(RTW_PROC_NAME, get_proc_net);
421 rtw_proc = NULL;
422 }
423
424 #ifndef RTW_SEQ_FILE_TEST
425 #define RTW_SEQ_FILE_TEST 0
426 #endif
427
428 #if RTW_SEQ_FILE_TEST
429 #define RTW_SEQ_FILE_TEST_SHOW_LIMIT 300
proc_start_seq_file_test(struct seq_file * m,loff_t * pos)430 static void *proc_start_seq_file_test(struct seq_file *m, loff_t *pos)
431 {
432 struct net_device *dev = m->private;
433 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
434
435 RTW_PRINT(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
436 if (*pos >= RTW_SEQ_FILE_TEST_SHOW_LIMIT) {
437 RTW_PRINT(FUNC_ADPT_FMT" pos:%llu, out of range return\n", FUNC_ADPT_ARG(adapter), *pos);
438 return NULL;
439 }
440
441 RTW_PRINT(FUNC_ADPT_FMT" return pos:%lld\n", FUNC_ADPT_ARG(adapter), *pos);
442 return pos;
443 }
proc_stop_seq_file_test(struct seq_file * m,void * v)444 void proc_stop_seq_file_test(struct seq_file *m, void *v)
445 {
446 struct net_device *dev = m->private;
447 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
448
449 RTW_PRINT(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
450 }
451
proc_next_seq_file_test(struct seq_file * m,void * v,loff_t * pos)452 void *proc_next_seq_file_test(struct seq_file *m, void *v, loff_t *pos)
453 {
454 struct net_device *dev = m->private;
455 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
456
457 (*pos)++;
458 if (*pos >= RTW_SEQ_FILE_TEST_SHOW_LIMIT) {
459 RTW_PRINT(FUNC_ADPT_FMT" pos:%lld, out of range return\n", FUNC_ADPT_ARG(adapter), *pos);
460 return NULL;
461 }
462
463 RTW_PRINT(FUNC_ADPT_FMT" return pos:%lld\n", FUNC_ADPT_ARG(adapter), *pos);
464 return pos;
465 }
466
proc_get_seq_file_test(struct seq_file * m,void * v)467 static int proc_get_seq_file_test(struct seq_file *m, void *v)
468 {
469 struct net_device *dev = m->private;
470 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
471
472 u32 pos = *((loff_t *)(v));
473 RTW_PRINT(FUNC_ADPT_FMT" pos:%d\n", FUNC_ADPT_ARG(adapter), pos);
474 RTW_PRINT_SEL(m, FUNC_ADPT_FMT" pos:%d\n", FUNC_ADPT_ARG(adapter), pos);
475 return 0;
476 }
477
478 struct seq_operations seq_file_test = {
479 .start = proc_start_seq_file_test,
480 .stop = proc_stop_seq_file_test,
481 .next = proc_next_seq_file_test,
482 .show = proc_get_seq_file_test,
483 };
484 #endif /* RTW_SEQ_FILE_TEST */
485
486 #ifdef CONFIG_SDIO_HCI
487 #include "rtw_sdio.h"
488 #define CCCR_LEN 0x100
sd_f0_reg_dump(void * sel,struct _ADAPTER * a)489 static void sd_f0_reg_dump(void *sel, struct _ADAPTER *a)
490 {
491 struct dvobj_priv *d = adapter_to_dvobj(a);
492 u8 *cccr = NULL, *ptr, val;
493 u8 ret;
494 int i;
495
496
497 cccr = rtw_vmalloc(CCCR_LEN);
498 if (cccr) {
499 ret = rtw_sdio_f0_read(d, 0, cccr, CCCR_LEN);
500 if (ret == _FAIL) {
501 RTW_PRINT_SEL(sel, "Fail to read F0 register!");
502 goto exit;
503 }
504 } else {
505 RTW_WARN(FUNC_ADPT_FMT ": alloc memory FAIL!\n",
506 FUNC_ADPT_ARG(a));
507 ptr = &val;
508 }
509
510 for (i = 0x0; i < CCCR_LEN; i++) {
511 if (cccr) {
512 ptr = &cccr[i];
513 } else {
514 ret = rtw_sdio_f0_read(d, i, &val, 1);
515 if (ret == _FAIL) {
516 RTW_ERR(FUNC_ADPT_FMT ": Fail to read F0 "
517 "register 0x%02x!\n",
518 FUNC_ADPT_ARG(a), i);
519 RTW_PRINT_SEL(sel, "... error!\n");
520 goto exit;
521 }
522 }
523
524 if (i % 16 == 0)
525 RTW_PRINT_SEL(sel, "0x%02x ", i);
526
527 _RTW_PRINT_SEL(sel, "%02x ", *ptr);
528
529 if (i % 16 == 15)
530 _RTW_PRINT_SEL(sel, "\n");
531 else if (i % 8 == 7)
532 _RTW_PRINT_SEL(sel, "\t");
533 }
534
535 exit:
536 if (cccr)
537 rtw_vmfree(cccr, CCCR_LEN);
538 }
539
proc_get_sd_f0_reg_dump(struct seq_file * m,void * v)540 static int proc_get_sd_f0_reg_dump(struct seq_file *m, void *v)
541 {
542 struct net_device *dev = m->private;
543 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
544 // struct dvobj_priv *d = adapter_to_dvobj(adapter);
545
546 // rtw_hal_sd_f0_reg_dump(m, GET_PHL_INFO(d));
547 sd_f0_reg_dump(m, adapter);
548
549 return 0;
550 }
551
proc_get_sdio_local_reg_dump(struct seq_file * m,void * v)552 static int proc_get_sdio_local_reg_dump(struct seq_file *m, void *v)
553 {
554 struct net_device *dev = m->private;
555 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
556 struct dvobj_priv *d = adapter_to_dvobj(adapter);
557
558 rtw_hal_sdio_local_reg_dump(m, GET_PHL_INFO(d));
559
560 return 0;
561 }
proc_get_sdio_card_info(struct seq_file * m,void * v)562 static int proc_get_sdio_card_info(struct seq_file *m, void *v)
563 {
564 struct net_device *dev = m->private;
565 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
566
567 dump_sdio_card_info(m, adapter_to_dvobj(adapter));
568
569 return 0;
570 }
571
572 #ifdef DBG_SDIO
proc_get_sdio_dbg(struct seq_file * m,void * v)573 static int proc_get_sdio_dbg(struct seq_file *m, void *v)
574 {
575 struct net_device *dev;
576 _adapter *a;
577 struct dvobj_priv *d;
578 struct sdio_data *sdio;
579
580
581 dev = m->private;
582 a = (_adapter *)rtw_netdev_priv(dev);
583 d = adapter_to_dvobj(a);
584 sdio = dvobj_to_sdio(d);
585
586 dump_sdio_card_info(m, d);
587
588 RTW_PRINT_SEL(m, "CMD52 error cnt: %d\n", sdio->cmd52_err_cnt);
589 RTW_PRINT_SEL(m, "CMD53 error cnt: %d\n", sdio->cmd53_err_cnt);
590
591 #if (DBG_SDIO >= 3)
592 RTW_PRINT_SEL(m, "dbg: %s\n", sdio->dbg_enable?"enable":"disable");
593 RTW_PRINT_SEL(m, "err_stop: %s\n", sdio->err_stop?"enable":"disable");
594 RTW_PRINT_SEL(m, "err_test: %s\n", sdio->err_test?"enable":"disable");
595 RTW_PRINT_SEL(m, "err_test_triggered: %s\n",
596 sdio->err_test_triggered?"yes":"no");
597 #endif /* DBG_SDIO >= 3 */
598
599 #if (DBG_SDIO >= 2)
600 RTW_PRINT_SEL(m, "I/O error dump mark: %d\n", sdio->reg_dump_mark);
601 if (sdio->reg_dump_mark) {
602 if (sdio->dbg_msg)
603 RTW_PRINT_SEL(m, "debug messages: %s\n", sdio->dbg_msg);
604 if (sdio->reg_mac)
605 RTW_BUF_DUMP_SEL(_DRV_ALWAYS_, m, "MAC register:",
606 _TRUE, sdio->reg_mac, 0x800);
607 if (sdio->reg_mac_ext)
608 RTW_BUF_DUMP_SEL(_DRV_ALWAYS_, m, "MAC EXT register:",
609 _TRUE, sdio->reg_mac_ext, 0x800);
610 if (sdio->reg_local)
611 RTW_BUF_DUMP_SEL(_DRV_ALWAYS_, m, "SDIO Local register:",
612 _TRUE, sdio->reg_local, 0x100);
613 if (sdio->reg_cia)
614 RTW_BUF_DUMP_SEL(_DRV_ALWAYS_, m, "SDIO CIA register:",
615 _TRUE, sdio->reg_cia, 0x200);
616 }
617 #endif /* DBG_SDIO >= 2 */
618
619 return 0;
620 }
621
622 #if (DBG_SDIO >= 2)
623 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 0, 0))
624 #define strnicmp strncasecmp
625 #endif /* Linux kernel >= 4.0.0 */
626 void rtw_sdio_dbg_reg_free(struct dvobj_priv *d);
627 #endif /* DBG_SDIO >= 2 */
628
proc_set_sdio_dbg(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)629 ssize_t proc_set_sdio_dbg(struct file *file, const char __user *buffer,
630 size_t count, loff_t *pos, void *data)
631 {
632 #if (DBG_SDIO >= 2)
633 struct net_device *dev = data;
634 struct dvobj_priv *d;
635 _adapter *a;
636 struct sdio_data *sdio;
637 char tmp[32], cmd[32] = {0};
638 int num;
639
640
641 if (count < 1)
642 return -EFAULT;
643
644 if (count > sizeof(tmp)) {
645 rtw_warn_on(1);
646 return -EFAULT;
647 }
648
649 a = (_adapter *)rtw_netdev_priv(dev);
650 d = adapter_to_dvobj(a);
651 sdio = dvobj_to_sdio(d);
652
653 if (buffer && !copy_from_user(tmp, buffer, count)) {
654 num = sscanf(tmp, "%s", cmd);
655
656 if (num >= 1) {
657 if (strnicmp(cmd, "reg_reset", 10) == 0) {
658 sdio->reg_dump_mark = 0;
659 goto exit;
660 }
661 if (strnicmp(cmd, "reg_free", 9) == 0) {
662 rtw_sdio_dbg_reg_free(d);
663 sdio->reg_dump_mark = 0;
664 goto exit;
665 }
666 #if (DBG_SDIO >= 3)
667 if (strnicmp(cmd, "dbg_enable", 11) == 0) {
668 sdio->dbg_enable = 1;
669 goto exit;
670 }
671 if (strnicmp(cmd, "dbg_disable", 12) == 0) {
672 sdio->dbg_enable = 0;
673 goto exit;
674 }
675 if (strnicmp(cmd, "err_stop", 9) == 0) {
676 sdio->err_stop = 1;
677 goto exit;
678 }
679 if (strnicmp(cmd, "err_stop_disable", 16) == 0) {
680 sdio->err_stop = 0;
681 goto exit;
682 }
683 if (strnicmp(cmd, "err_test", 9) == 0) {
684 sdio->err_test_triggered = 0;
685 sdio->err_test = 1;
686 goto exit;
687 }
688 #endif /* DBG_SDIO >= 3 */
689 }
690
691 return -EINVAL;
692 }
693
694 exit:
695 #endif /* DBG_SDIO >= 2 */
696 return count;
697 }
698 #endif /* DBG_SDIO */
699 #endif /* CONFIG_SDIO_HCI */
700
proc_get_mac_reg_dump(struct seq_file * m,void * v)701 static int proc_get_mac_reg_dump(struct seq_file *m, void *v)
702 {
703 struct net_device *dev = m->private;
704 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
705 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
706
707 rtw_phl_mac_reg_dump(m, GET_PHL_INFO(dvobj));
708
709 return 0;
710 }
711
proc_get_bb_reg_dump(struct seq_file * m,void * v)712 static int proc_get_bb_reg_dump(struct seq_file *m, void *v)
713 {
714 struct net_device *dev = m->private;
715 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
716 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
717
718 rtw_phl_bb_reg_dump(m, GET_PHL_INFO(dvobj));
719
720 return 0;
721 }
722
proc_get_bb_reg_dump_ex(struct seq_file * m,void * v)723 static int proc_get_bb_reg_dump_ex(struct seq_file *m, void *v)
724 {
725 struct net_device *dev = m->private;
726 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
727 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
728
729 rtw_phl_bb_reg_dump_ex(m, GET_PHL_INFO(dvobj));
730
731 return 0;
732 }
733
proc_get_rf_reg_dump(struct seq_file * m,void * v)734 static int proc_get_rf_reg_dump(struct seq_file *m, void *v)
735 {
736 struct net_device *dev = m->private;
737 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
738 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
739
740 rtw_phl_rf_reg_dump(m, GET_PHL_INFO(dvobj));
741
742 return 0;
743 }
744
745 #if 0
746 int proc_get_led_config(struct seq_file *m, void *v)
747 {
748 struct net_device *dev = m->private;
749 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
750
751 dump_led_config(m, adapter);
752
753 return 0;
754 }
755
756 ssize_t proc_set_led_config(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
757 {
758 struct net_device *dev = data;
759 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
760
761 char tmp[32];
762 u8 strategy;
763 u8 iface_en_mask;
764
765 if (count < 1)
766 return -EFAULT;
767
768 if (count > sizeof(tmp)) {
769 rtw_warn_on(1);
770 return -EFAULT;
771 }
772
773 if (buffer && !copy_from_user(tmp, buffer, count)) {
774
775 int num = sscanf(tmp, "%hhu %hhx", &strategy, &iface_en_mask);
776
777 if (num >= 1)
778 rtw_led_set_strategy(adapter, strategy);
779 if (num >= 2)
780 rtw_led_set_iface_en_mask(adapter, iface_en_mask);
781 }
782
783 return count;
784 }
785 #endif /* CONFIG_RTW_LED */
786
787 #ifdef CONFIG_AP_MODE
proc_get_aid_status(struct seq_file * m,void * v)788 int proc_get_aid_status(struct seq_file *m, void *v)
789 {
790 struct net_device *dev = m->private;
791 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
792
793 dump_aid_status(m, adapter);
794
795 return 0;
796 }
797
proc_set_aid_status(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)798 ssize_t proc_set_aid_status(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
799 {
800 struct net_device *dev = data;
801 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
802 struct sta_priv *stapriv = &adapter->stapriv;
803
804 char tmp[32];
805 u8 rr;
806 u16 started_aid;
807
808 if (count < 1)
809 return -EFAULT;
810
811 if (count > sizeof(tmp)) {
812 rtw_warn_on(1);
813 return -EFAULT;
814 }
815
816 if (buffer && !copy_from_user(tmp, buffer, count)) {
817
818 int num = sscanf(tmp, "%hhu %hu", &rr, &started_aid);
819
820 if (num >= 1)
821 stapriv->rr_aid = rr ? 1 : 0;
822 if (num >= 2) {
823 started_aid = started_aid % (stapriv->max_aid + 1);
824 stapriv->started_aid = started_aid ? started_aid : 1;
825 }
826 }
827
828 return count;
829 }
830
831 #if CONFIG_RTW_AP_DATA_BMC_TO_UC
proc_get_ap_b2u_flags(struct seq_file * m,void * v)832 static int proc_get_ap_b2u_flags(struct seq_file *m, void *v)
833 {
834 struct net_device *dev = m->private;
835 _adapter *adapter = rtw_netdev_priv(dev);
836
837 if (MLME_IS_AP(adapter))
838 dump_ap_b2u_flags(m, adapter);
839
840 return 0;
841 }
842
proc_set_ap_b2u_flags(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)843 static ssize_t proc_set_ap_b2u_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
844 {
845 struct net_device *dev = data;
846 _adapter *adapter = rtw_netdev_priv(dev);
847 char tmp[32];
848
849 if (count < 1)
850 return -EFAULT;
851
852 if (count > sizeof(tmp)) {
853 rtw_warn_on(1);
854 return -EFAULT;
855 }
856
857 if (buffer && !copy_from_user(tmp, buffer, count)) {
858 u8 src, fwd;
859 int num = sscanf(tmp, "%hhx %hhx", &src, &fwd);
860
861 if (num >= 1)
862 adapter->b2u_flags_ap_src = src;
863 if (num >= 2)
864 adapter->b2u_flags_ap_fwd = fwd;
865 }
866
867 return count;
868 }
869 #endif /* CONFIG_RTW_AP_DATA_BMC_TO_UC */
870 #endif /* CONFIG_AP_MODE */
871
proc_get_dump_tx_rate_bmp(struct seq_file * m,void * v)872 static int proc_get_dump_tx_rate_bmp(struct seq_file *m, void *v)
873 {
874 struct net_device *dev = m->private;
875 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
876
877 dump_tx_rate_bmp(m, adapter_to_dvobj(adapter));
878
879 return 0;
880 }
881
proc_get_dump_adapters_status(struct seq_file * m,void * v)882 static int proc_get_dump_adapters_status(struct seq_file *m, void *v)
883 {
884 struct net_device *dev = m->private;
885 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
886
887 dump_adapters_status(m, adapter_to_dvobj(adapter));
888
889 return 0;
890 }
891
892 #ifdef CONFIG_RTW_CUSTOMER_STR
proc_get_customer_str(struct seq_file * m,void * v)893 static int proc_get_customer_str(struct seq_file *m, void *v)
894 {
895 struct net_device *dev = m->private;
896 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
897 u8 cstr[RTW_CUSTOMER_STR_LEN];
898
899 rtw_ps_deny(adapter, PS_DENY_IOCTL);
900 if (rtw_pwr_wakeup(adapter) == _FAIL)
901 goto exit;
902
903 if (rtw_hal_customer_str_read(adapter, cstr) != _SUCCESS)
904 goto exit;
905
906 RTW_PRINT_SEL(m, RTW_CUSTOMER_STR_FMT"\n", RTW_CUSTOMER_STR_ARG(cstr));
907
908 exit:
909 rtw_ps_deny_cancel(adapter, PS_DENY_IOCTL);
910 return 0;
911 }
912 #endif /* CONFIG_RTW_CUSTOMER_STR */
913
914 #ifdef CONFIG_SCAN_BACKOP
proc_get_backop_flags_sta(struct seq_file * m,void * v)915 static int proc_get_backop_flags_sta(struct seq_file *m, void *v)
916 {
917 struct net_device *dev = m->private;
918 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
919 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
920
921 RTW_PRINT_SEL(m, "0x%02x\n", mlmeext_scan_backop_flags_sta(mlmeext));
922
923 return 0;
924 }
925
proc_set_backop_flags_sta(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)926 static ssize_t proc_set_backop_flags_sta(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
927 {
928 struct net_device *dev = data;
929 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
930 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
931
932 char tmp[32];
933 u8 flags;
934
935 if (count < 1)
936 return -EFAULT;
937
938 if (count > sizeof(tmp)) {
939 rtw_warn_on(1);
940 return -EFAULT;
941 }
942
943 if (buffer && !copy_from_user(tmp, buffer, count)) {
944
945 int num = sscanf(tmp, "%hhx", &flags);
946
947 if (num == 1)
948 mlmeext_assign_scan_backop_flags_sta(mlmeext, flags);
949 }
950
951 return count;
952 }
953
954 #ifdef CONFIG_AP_MODE
proc_get_backop_flags_ap(struct seq_file * m,void * v)955 static int proc_get_backop_flags_ap(struct seq_file *m, void *v)
956 {
957 struct net_device *dev = m->private;
958 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
959 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
960
961 RTW_PRINT_SEL(m, "0x%02x\n", mlmeext_scan_backop_flags_ap(mlmeext));
962
963 return 0;
964 }
965
proc_set_backop_flags_ap(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)966 static ssize_t proc_set_backop_flags_ap(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
967 {
968 struct net_device *dev = data;
969 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
970 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
971
972 char tmp[32];
973 u8 flags;
974
975 if (count < 1)
976 return -EFAULT;
977
978 if (count > sizeof(tmp)) {
979 rtw_warn_on(1);
980 return -EFAULT;
981 }
982
983 if (buffer && !copy_from_user(tmp, buffer, count)) {
984
985 int num = sscanf(tmp, "%hhx", &flags);
986
987 if (num == 1)
988 mlmeext_assign_scan_backop_flags_ap(mlmeext, flags);
989 }
990
991 return count;
992 }
993 #endif /* CONFIG_AP_MODE */
994
995 #ifdef CONFIG_RTW_MESH
proc_get_backop_flags_mesh(struct seq_file * m,void * v)996 static int proc_get_backop_flags_mesh(struct seq_file *m, void *v)
997 {
998 struct net_device *dev = m->private;
999 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1000 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1001
1002 RTW_PRINT_SEL(m, "0x%02x\n", mlmeext_scan_backop_flags_mesh(mlmeext));
1003
1004 return 0;
1005 }
1006
proc_set_backop_flags_mesh(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1007 static ssize_t proc_set_backop_flags_mesh(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1008 {
1009 struct net_device *dev = data;
1010 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1011 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
1012
1013 char tmp[32];
1014 u8 flags;
1015
1016 if (count < 1)
1017 return -EFAULT;
1018
1019 if (count > sizeof(tmp)) {
1020 rtw_warn_on(1);
1021 return -EFAULT;
1022 }
1023
1024 if (buffer && !copy_from_user(tmp, buffer, count)) {
1025
1026 int num = sscanf(tmp, "%hhx", &flags);
1027
1028 if (num == 1)
1029 mlmeext_assign_scan_backop_flags_mesh(mlmeext, flags);
1030 }
1031
1032 return count;
1033 }
1034 #endif /* CONFIG_RTW_MESH */
1035
1036 #endif /* CONFIG_SCAN_BACKOP */
1037
1038 #if defined(CONFIG_LPS_PG) && defined(CONFIG_RTL8822C)
proc_get_lps_pg_debug(struct seq_file * m,void * v)1039 static int proc_get_lps_pg_debug(struct seq_file *m, void *v)
1040 {
1041 struct net_device *dev = m->private;
1042 _adapter *adapter = rtw_netdev_priv(dev);
1043 struct dm_struct *dm = adapter_to_phydm(adapter);
1044
1045 rtw_run_in_thread_cmd(adapter, ((void *)(odm_lps_pg_debug_8822c)), dm);
1046
1047 return 0;
1048 }
1049 #endif
1050
1051 /* gpio setting */
1052 #ifdef CONFIG_GPIO_API
proc_set_config_gpio(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1053 static ssize_t proc_set_config_gpio(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1054 {
1055 struct net_device *dev = data;
1056 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1057 char tmp[32] = {0};
1058 int num = 0, gpio_pin = 0, gpio_mode = 0; /* gpio_mode:0 input 1:output; */
1059
1060 if (count < 2)
1061 return -EFAULT;
1062
1063 if (count > sizeof(tmp)) {
1064 rtw_warn_on(1);
1065 return -EFAULT;
1066 }
1067
1068 if (buffer && !copy_from_user(tmp, buffer, count)) {
1069 num = sscanf(tmp, "%d %d", &gpio_pin, &gpio_mode);
1070 RTW_INFO("num=%d gpio_pin=%d mode=%d\n", num, gpio_pin, gpio_mode);
1071 padapter->pre_gpio_pin = gpio_pin;
1072
1073 if (gpio_mode == 0 || gpio_mode == 1)
1074 rtw_hal_config_gpio(padapter, gpio_pin, gpio_mode);
1075 }
1076 return count;
1077
1078 }
proc_set_gpio_output_value(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1079 static ssize_t proc_set_gpio_output_value(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1080 {
1081 struct net_device *dev = data;
1082 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1083 char tmp[32] = {0};
1084 int num = 0, gpio_pin = 0, pin_mode = 0; /* pin_mode: 1 high 0:low */
1085
1086 if (count < 2)
1087 return -EFAULT;
1088
1089 if (count > sizeof(tmp)) {
1090 rtw_warn_on(1);
1091 return -EFAULT;
1092 }
1093
1094 if (buffer && !copy_from_user(tmp, buffer, count)) {
1095 num = sscanf(tmp, "%d %d", &gpio_pin, &pin_mode);
1096 RTW_INFO("num=%d gpio_pin=%d pin_high=%d\n", num, gpio_pin, pin_mode);
1097 padapter->pre_gpio_pin = gpio_pin;
1098
1099 if (pin_mode == 0 || pin_mode == 1)
1100 rtw_hal_set_gpio_output_value(padapter, gpio_pin, pin_mode);
1101 }
1102 return count;
1103 }
proc_get_gpio(struct seq_file * m,void * v)1104 static int proc_get_gpio(struct seq_file *m, void *v)
1105 {
1106 u8 gpioreturnvalue = 0;
1107 struct net_device *dev = m->private;
1108
1109 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1110 if (!padapter)
1111 return -EFAULT;
1112 gpioreturnvalue = rtw_hal_get_gpio(padapter, padapter->pre_gpio_pin);
1113 RTW_PRINT_SEL(m, "get_gpio %d:%d\n", padapter->pre_gpio_pin, gpioreturnvalue);
1114
1115 return 0;
1116
1117 }
proc_set_gpio(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1118 static ssize_t proc_set_gpio(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1119 {
1120 struct net_device *dev = data;
1121 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1122 char tmp[32] = {0};
1123 int num = 0, gpio_pin = 0;
1124
1125 if (count < 1)
1126 return -EFAULT;
1127
1128 if (count > sizeof(tmp)) {
1129 rtw_warn_on(1);
1130 return -EFAULT;
1131 }
1132
1133 if (buffer && !copy_from_user(tmp, buffer, count)) {
1134 num = sscanf(tmp, "%d", &gpio_pin);
1135 RTW_INFO("num=%d gpio_pin=%d\n", num, gpio_pin);
1136 padapter->pre_gpio_pin = gpio_pin;
1137
1138 }
1139 return count;
1140 }
1141 #endif
1142
proc_set_rx_info_msg(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1143 static ssize_t proc_set_rx_info_msg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1144 {
1145
1146 struct net_device *dev = data;
1147 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1148 char tmp[32] = {0};
1149 int phy_info_flag = 0;
1150
1151 if (!padapter)
1152 return -EFAULT;
1153
1154 if (count < 1) {
1155 RTW_INFO("argument size is less than 1\n");
1156 return -EFAULT;
1157 }
1158
1159 if (count > sizeof(tmp)) {
1160 rtw_warn_on(1);
1161 return -EFAULT;
1162 }
1163
1164 if (buffer && !copy_from_user(tmp, buffer, count)) {
1165 int num = sscanf(tmp, "%d", &phy_info_flag);
1166
1167 }
1168 return count;
1169 }
proc_get_rx_info_msg(struct seq_file * m,void * v)1170 static int proc_get_rx_info_msg(struct seq_file *m, void *v)
1171 {
1172 struct net_device *dev = m->private;
1173 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1174
1175 /*rtw_hal_set_phydm_var(padapter, HAL_PHYDM_RX_DATA_INFO, m, _FALSE);*/
1176 return 0;
1177 }
proc_get_tx_info_msg(struct seq_file * m,void * v)1178 static int proc_get_tx_info_msg(struct seq_file *m, void *v)
1179 {
1180 struct net_device *dev = m->private;
1181 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1182 struct sta_info *psta;
1183 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1184 u8 null_addr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1185 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1186 struct sta_priv *pstapriv = &padapter->stapriv;
1187 int i;
1188 _list *plist, *phead;
1189 u16 current_rate_id = 0, current_sgi = 0;
1190
1191 char *BW, *status;
1192
1193 _rtw_spinlock_bh(&pstapriv->sta_hash_lock);
1194
1195 if (MLME_IS_STA(padapter))
1196 status = "station mode";
1197 else if (MLME_IS_AP(padapter))
1198 status = "AP mode";
1199 else if (MLME_IS_MESH(padapter))
1200 status = "mesh mode";
1201 else
1202 status = " ";
1203 _RTW_PRINT_SEL(m, "status=%s\n", status);
1204 for (i = 0; i < NUM_STA; i++) {
1205 phead = &(pstapriv->sta_hash[i]);
1206 plist = get_next(phead);
1207
1208 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
1209
1210 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
1211
1212 plist = get_next(plist);
1213
1214 if ((_rtw_memcmp(psta->phl_sta->mac_addr, bc_addr, ETH_ALEN) != _TRUE)
1215 && (_rtw_memcmp(psta->phl_sta->mac_addr, null_addr, ETH_ALEN) != _TRUE)
1216 && (_rtw_memcmp(psta->phl_sta->mac_addr, adapter_mac_addr(padapter), ETH_ALEN) != _TRUE)) {
1217
1218 switch (psta->phl_sta->chandef.bw) {
1219
1220 case CHANNEL_WIDTH_20:
1221 BW = "20M";
1222 break;
1223
1224 case CHANNEL_WIDTH_40:
1225 BW = "40M";
1226 break;
1227
1228 case CHANNEL_WIDTH_80:
1229 BW = "80M";
1230 break;
1231
1232 case CHANNEL_WIDTH_160:
1233 BW = "160M";
1234 break;
1235
1236 default:
1237 BW = "";
1238 break;
1239 }
1240 current_rate_id = rtw_get_current_tx_rate(adapter, psta);
1241 current_sgi = rtw_get_current_tx_sgi(adapter, psta);
1242
1243 RTW_PRINT_SEL(m, "==============================\n");
1244 _RTW_PRINT_SEL(m, "macaddr=" MAC_FMT"\n", MAC_ARG(psta->phl_sta->mac_addr));
1245 _RTW_PRINT_SEL(m, "Tx_Data_Rate=%s\n", HDATA_RATE(current_rate_id));
1246 _RTW_PRINT_SEL(m, "BW=%s,sgi=%u\n", BW, current_sgi);
1247
1248 }
1249 }
1250 }
1251
1252 _rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
1253
1254 return 0;
1255
1256 }
1257
proc_get_false_alarm_accumulated(struct seq_file * m,void * v)1258 static int proc_get_false_alarm_accumulated(struct seq_file *m, void *v)
1259 {
1260 struct net_device *dev = m->private;
1261 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1262 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1263 struct rtw_wifi_role_t *wrole = padapter->phl_role;
1264 enum phl_band_idx hw_band = wrole->hw_band;
1265
1266 _RTW_PRINT_SEL(m , "Accumulated False Alarm:%u\n",
1267 ATOMIC_READ((ATOMIC_T *)&dvobj->fa_cnt_acc[hw_band]));
1268
1269 return 0;
1270 }
1271
proc_set_false_alarm_accumulated(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1272 static ssize_t proc_set_false_alarm_accumulated(struct file *file,
1273 const char __user *buffer,
1274 size_t count, loff_t *pos,
1275 void *data)
1276 {
1277 struct net_device *dev = data;
1278 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1279 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1280 struct rtw_wifi_role_t *wrole = padapter->phl_role;
1281 enum phl_band_idx hw_band = wrole->hw_band;
1282 char tmp[32];
1283 u32 false_clr;
1284
1285 if (count < 1)
1286 return -EINVAL;
1287
1288 if (count > sizeof(tmp)) {
1289 rtw_warn_on(1);
1290 return -EFAULT;
1291 }
1292
1293 if (buffer && !copy_from_user(tmp, buffer, count)) {
1294 u32 num = sscanf(tmp, "%u ", &false_clr);
1295 ATOMIC_SET((ATOMIC_T *)&dvobj->fa_cnt_acc[hw_band],
1296 (int)false_clr);
1297 } else {
1298 return -EFAULT;
1299 }
1300
1301 return count;
1302 }
1303
1304 #ifdef ROKU_PRIVATE
proc_get_roku_trx_info_msg(struct seq_file * m,void * v)1305 static int proc_get_roku_trx_info_msg(struct seq_file *m, void *v)
1306 {
1307 struct net_device *dev = m->private;
1308 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1309 _list *plist, *phead;
1310 struct sta_info *psta = NULL;
1311 u8 sta_mac[NUM_STA][ETH_ALEN] = {{0}};
1312 uint mac_id[NUM_STA];
1313 struct stainfo_stats *pstats = NULL;
1314 struct sta_priv *pstapriv = &(adapter->stapriv);
1315 u32 i, j, macid_rec_idx = 0;
1316 u8 bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1317 u8 null_addr[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1318 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
1319 struct xmit_priv *pxmitpriv = &(adapter->xmitpriv);
1320 u32 tx_retry_cnt[PHL_AC_QUEUE_TOTAL] = {0};
1321 u32 tx_fail_cnt[PHL_AC_QUEUE_TOTAL] = {0};
1322 u32 tx_ok_cnt[PHL_AC_QUEUE_TOTAL] = {0};
1323
1324 #if 0
1325 psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
1326 if (psta) {
1327 RTW_PRINT_SEL(m, "Interface Name: %s\n", ADPT_ARG(adapter));
1328
1329 RTW_PRINT_SEL(m, "===== TX and RX Count Statistics =====\n");
1330 RTW_PRINT_SEL(m , "TX packets:%llu\n", pxmitpriv->tx_pkts);
1331 RTW_PRINT_SEL(m , "RX packets:%llu\n", precvpriv->rx_pkts);
1332
1333 RTW_PRINT_SEL(m, "===== TX Drop Statistics =====\n");
1334 RTW_PRINT_SEL(m, "[Driver] BK packets drop count: %llu\n", pxmitpriv->tx_bk_drop_cnt);
1335 RTW_PRINT_SEL(m, "[Driver] BE packets drop count: %llu\n", pxmitpriv->tx_be_drop_cnt);
1336 RTW_PRINT_SEL(m, "[Driver] VI packets drop count: %llu\n", pxmitpriv->tx_vi_drop_cnt);
1337 RTW_PRINT_SEL(m, "[Driver] VO packets drop count: %llu\n", pxmitpriv->tx_vo_drop_cnt);
1338
1339 RTW_PRINT_SEL(m, "===== RX VO packets Statistics =====\n");
1340
1341 for(i = DESC_RATE1M ; i <= DESC_RATE11M ; i++) {
1342 snprintf(tmp_str, sizeof(tmp_str), "%llu ", precvpriv->rx_vo_pkt_count_per_data_rate[i]);
1343 strncat(cnt_str, tmp_str, strlen(tmp_str));
1344 }
1345 RTW_PRINT_SEL(m, "CCK (1M, 2M, 5.5M, 11M): [ %s]\n", cnt_str);
1346 _rtw_memset(&cnt_str, '\0', sizeof(cnt_str));
1347
1348 for(i = DESC_RATE6M ; i <= DESC_RATE54M ; i++) {
1349 snprintf(tmp_str, sizeof(tmp_str), "%llu ", precvpriv->rx_vo_pkt_count_per_data_rate[i]);
1350 strncat(cnt_str, tmp_str, strlen(tmp_str));
1351 }
1352 RTW_PRINT_SEL(m, "OFDM (6M, 9M, 12M, 18M, 24M, 36M, 48M, 54M): [ %s]\n", cnt_str);
1353 _rtw_memset(&cnt_str, '\0', sizeof(cnt_str));
1354
1355 for(i = 0 ; i < rx_nss_num ; i++) {
1356 for(j = DESC_RATEMCS0 ; j <= DESC_RATEMCS7 ; j++) {
1357 snprintf(tmp_str, sizeof(tmp_str), "%llu ", precvpriv->rx_vo_pkt_count_per_data_rate[j + (i<<3)]);
1358 strncat(cnt_str, tmp_str, strlen(tmp_str));
1359 }
1360 RTW_PRINT_SEL(m, "HT_MCS (%d-%d): [ %s]\n", (i<<3), (i<<3) + 7, cnt_str);
1361 _rtw_memset(&cnt_str, '\0', sizeof(cnt_str));
1362 }
1363
1364 if (rx_nss_num == 1)
1365 RTW_PRINT_SEL(m, "HT_MCS (8-15): [ 0 0 0 0 0 0 0 0 ]\n");
1366
1367 for(i = 0 ; i < rx_nss_num ; i++) {
1368 for(j = DESC_RATEVHTSS1MCS0 ; j <= DESC_RATEVHTSS1MCS9 ; j++) {
1369 snprintf(tmp_str, sizeof(tmp_str), "%llu ", precvpriv->rx_vo_pkt_count_per_data_rate[j + (i * 10)]);
1370 strncat(cnt_str, tmp_str, strlen(tmp_str));
1371 }
1372 RTW_PRINT_SEL(m, "VHT_%dSS_MCS (0-9): [ %s]\n", (i + 1), cnt_str);
1373 _rtw_memset(&cnt_str, '\0', sizeof(cnt_str));
1374 }
1375
1376 if (rx_nss_num == 1)
1377 RTW_PRINT_SEL(m, "VHT_2SS_MCS (0-9): [ 0 0 0 0 0 0 0 0 0 0 ]\n");
1378
1379 RTW_PRINT_SEL(m, "RX counter for VO packets with retry bit set: %llu\n\n", precvpriv->rx_vo_pkt_retry_count);
1380 }
1381 #endif
1382 _rtw_spinlock_bh(&pstapriv->sta_hash_lock);
1383 for (i = 0; i < NUM_STA; i++) {
1384 phead = &(pstapriv->sta_hash[i]);
1385 plist = get_next(phead);
1386 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
1387 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
1388 plist = get_next(plist);
1389 if ((_rtw_memcmp(psta->phl_sta->mac_addr, bc_addr, 6) != _TRUE)
1390 && (_rtw_memcmp(psta->phl_sta->mac_addr, null_addr, 6) != _TRUE)
1391 && (_rtw_memcmp(psta->phl_sta->mac_addr, adapter_mac_addr(adapter), 6) != _TRUE)) {
1392 _rtw_memcpy(&sta_mac[macid_rec_idx][0], psta->phl_sta->mac_addr, ETH_ALEN);
1393 mac_id[macid_rec_idx] = psta->phl_sta->macid;
1394 macid_rec_idx++;
1395 }
1396 }
1397 }
1398 _rtw_spinunlock_bh(&pstapriv->sta_hash_lock);
1399
1400 for (i = 0; i < macid_rec_idx; i++) {
1401 psta = rtw_get_stainfo(pstapriv, &sta_mac[i][0]);
1402
1403 #if 0
1404 if (psta) {
1405 psta_dframe_info = &psta->sta_dframe_info;
1406
1407 isCCKrate = (psta_dframe_info->sta_data_rate <= DESC_RATE11M) ? TRUE : FALSE;
1408
1409 switch (psta_dframe_info->sta_bw_mode) {
1410 case CHANNEL_WIDTH_20:
1411 BW = "20M";
1412 break;
1413 case CHANNEL_WIDTH_40:
1414 BW = "40M";
1415 break;
1416 case CHANNEL_WIDTH_80:
1417 BW = "80M";
1418 break;
1419 case CHANNEL_WIDTH_160:
1420 BW = "160M";
1421 break;
1422 default:
1423 BW = "";
1424 break;
1425 }
1426
1427 RTW_PRINT_SEL(m, "========= STA("MAC_FMT") =========\n", MAC_ARG(psta->cmn.mac_addr));
1428 RTW_PRINT_SEL(m, "oper_ch=%d, oper_bw=%d, oper_ch_offet=%d\n",
1429 rtw_get_oper_ch(adapter), rtw_get_oper_bw(adapter), rtw_get_oper_choffset(adapter));
1430 RTW_PRINT_SEL(m, "BW=%s, sgi =%d\n", BW, psta_dframe_info->sta_sgi);
1431 RTW_PRINT_SEL(m, "Rx_Data_Rate = %s\n", HDATA_RATE(psta_dframe_info->sta_data_rate));
1432 RTW_PRINT_SEL(m, "Rx_Data_Rate_Int = %d\n", (psta_dframe_info->sta_data_rate));
1433
1434 for (rf_path = 0; rf_path < pHalData->NumTotalRFPath; rf_path++) {
1435 if (!isCCKrate) {
1436 RTW_PRINT_SEL(m , "RF_PATH_%d RSSI:%d(dBm)", rf_path, psta_dframe_info->sta_RxPwr[rf_path]);
1437 RTW_PRINT_SEL(m , "\nrx_ofdm_snr:%d(dB)\n", psta_dframe_info->sta_ofdm_snr[rf_path]);
1438 } else
1439 RTW_PRINT_SEL(m , "RF_PATH_%d RSSI:%d(dBm)\n", rf_path, (psta_dframe_info->sta_mimo_signal_strength[rf_path]) - 100);
1440 }
1441
1442 if (pHalData->NumTotalRFPath == 1) {
1443 if (!isCCKrate) {
1444 RTW_PRINT_SEL(m , "RF_PATH_1 RSSI:%d(dBm)", 0);
1445 RTW_PRINT_SEL(m , "\nrx_ofdm_snr:%d(dB)\n", 0);
1446 } else
1447 RTW_PRINT_SEL(m , "RF_PATH_1 RSSI:%d(dBm)\n", 0);
1448 }
1449
1450 RTW_PRINT_SEL(m , "Total False Alarm:%d / Cnt_CCA_all:%d\n", rtw_phydm_get_phy_cnt(adapter, FA_TOTAL) , rtw_phydm_get_phy_cnt(adapter, CCA_ALL));
1451 } else
1452 RTW_PRINT_SEL(m, "STA is gone\n");
1453 #endif
1454
1455 if(psta) {
1456 rtw_get_sta_tx_stat(adapter, psta);
1457 pstats = &psta->sta_stats;
1458
1459 RTW_PRINT_SEL(m, "MAC: " MAC_FMT " sent: %u fail: %u retry: %u\n",
1460 MAC_ARG(&sta_mac[i][0]), pstats->tx_ok_cnt, pstats->tx_fail_cnt, pstats->tx_retry_cnt);
1461 RTW_PRINT_SEL(m, "total_tx_retry: %llu, rx_retry: %u\n", pstats->total_tx_retry_cnt,
1462 ATOMIC_READ((ATOMIC_T *)&pstats->rx_retry_cnt));
1463 ATOMIC_SET((ATOMIC_T *)&pstats->rx_retry_cnt, 0);
1464
1465 RTW_PRINT_SEL(m, "[HW] BK packets drop count: %u\n", tx_fail_cnt[PHL_BE_QUEUE_SEL]);
1466 RTW_PRINT_SEL(m, "[HW] BE packets drop count: %u\n", tx_fail_cnt[PHL_BK_QUEUE_SEL]);
1467 RTW_PRINT_SEL(m, "[HW] VI packets drop count: %u\n", tx_fail_cnt[PHL_VI_QUEUE_SEL]);
1468 RTW_PRINT_SEL(m, "[HW] VO packets drop count: %u\n", tx_fail_cnt[PHL_VO_QUEUE_SEL]);
1469 } else {
1470 RTW_PRINT_SEL(m, "STA is gone\n");
1471 }
1472
1473 }
1474
1475 return 0;
1476 }
1477 #endif /* ROKU_PRIVATE */
1478
1479
proc_get_linked_info_dump(struct seq_file * m,void * v)1480 static int proc_get_linked_info_dump(struct seq_file *m, void *v)
1481 {
1482 struct net_device *dev = m->private;
1483 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1484 if (padapter)
1485 RTW_PRINT_SEL(m, "rtw_hal_linked_info_dump :%s\n", (padapter->bLinkInfoDump) ? "enable" : "disable");
1486
1487 return 0;
1488 }
1489
1490
proc_set_linked_info_dump(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1491 static ssize_t proc_set_linked_info_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1492 {
1493 struct net_device *dev = data;
1494 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1495
1496 char tmp[32] = {0};
1497 int mode = 0, pre_mode = 0;
1498 int num = 0;
1499
1500 if (count < 1)
1501 return -EFAULT;
1502
1503 if (count > sizeof(tmp)) {
1504 rtw_warn_on(1);
1505 return -EFAULT;
1506 }
1507
1508 pre_mode = padapter->bLinkInfoDump;
1509 RTW_INFO("pre_mode=%d\n", pre_mode);
1510
1511 if (buffer && !copy_from_user(tmp, buffer, count)) {
1512
1513 num = sscanf(tmp, "%d ", &mode);
1514 RTW_INFO("num=%d mode=%d\n", num, mode);
1515
1516 if (num != 1) {
1517 RTW_INFO("argument number is wrong\n");
1518 return -EFAULT;
1519 }
1520
1521 if (mode == 1 || (mode == 0 && pre_mode == 1)) /* not consider pwr_saving 0: */
1522 padapter->bLinkInfoDump = mode;
1523
1524 else if ((mode == 2) || (mode == 0 && pre_mode == 2)) { /* consider power_saving */
1525 /* RTW_INFO("rtw_hal_linked_info_dump =%s\n", (padapter->bLinkInfoDump)?"enable":"disable") */
1526 rtw_hal_linked_info_dump(padapter, mode);
1527 }
1528 }
1529 return count;
1530 }
1531
1532
proc_get_sta_tp_dump(struct seq_file * m,void * v)1533 static int proc_get_sta_tp_dump(struct seq_file *m, void *v)
1534 {
1535 struct net_device *dev = m->private;
1536 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1537
1538 if (padapter)
1539 RTW_PRINT_SEL(m, "sta_tp_dump :%s\n", (padapter->bsta_tp_dump) ? "enable" : "disable");
1540
1541 return 0;
1542 }
1543
proc_set_sta_tp_dump(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1544 static ssize_t proc_set_sta_tp_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1545 {
1546 struct net_device *dev = data;
1547 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1548
1549 char tmp[32] = {0};
1550 int mode = 0;
1551 int num = 0;
1552
1553 if (count < 1)
1554 return -EFAULT;
1555
1556 if (count > sizeof(tmp)) {
1557 rtw_warn_on(1);
1558 return -EFAULT;
1559 }
1560
1561 if (buffer && !copy_from_user(tmp, buffer, count)) {
1562
1563 num = sscanf(tmp, "%d ", &mode);
1564
1565 if (num != 1) {
1566 RTW_INFO("argument number is wrong\n");
1567 return -EFAULT;
1568 }
1569 if (padapter)
1570 padapter->bsta_tp_dump = mode;
1571 }
1572 return count;
1573 }
1574
proc_get_sta_tp_info(struct seq_file * m,void * v)1575 static int proc_get_sta_tp_info(struct seq_file *m, void *v)
1576 {
1577 struct net_device *dev = m->private;
1578 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1579
1580 if (padapter)
1581 rtw_sta_traffic_info(m, padapter);
1582
1583 return 0;
1584 }
1585
proc_get_turboedca_ctrl(struct seq_file * m,void * v)1586 static int proc_get_turboedca_ctrl(struct seq_file *m, void *v)
1587 {
1588 struct net_device *dev = m->private;
1589 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1590
1591 if (padapter->dis_turboedca == EN_TURBO)
1592 RTW_PRINT_SEL(m, "Turbo-EDCA : %s\n", "Enable");
1593 else if (padapter->dis_turboedca == DIS_TURBO)
1594 RTW_PRINT_SEL(m, "Turbo-EDCA : %s\n", "Disable");
1595 else
1596 RTW_PRINT_SEL(m, "Turbo-EDCA : %s, mode=%d, edca_param_mode=0x%x\n",
1597 "Disable", padapter->dis_turboedca, padapter->edca_param_mode);
1598
1599 _RTW_PRINT_SEL(m, "PARAM_BE:0x%x\n", padapter->edca_param_mode);
1600
1601 return 0;
1602 }
1603
proc_set_turboedca_ctrl(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1604 static ssize_t proc_set_turboedca_ctrl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1605 {
1606 struct net_device *dev = data;
1607 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1608 char tmp[32] = {0};
1609 int mode = 0, num = 0;
1610 u32 param_mode = 0;
1611
1612 if (count < 1)
1613 return -EFAULT;
1614
1615 if (count > sizeof(tmp))
1616 return -EFAULT;
1617
1618 if (buffer && !copy_from_user(tmp, buffer, count)) {
1619
1620 num = sscanf(tmp, "%d %x", &mode, ¶m_mode);
1621
1622 if (num < 1 || num > 2) {
1623 RTW_INFO("argument number is wrong\n");
1624 return -EFAULT;
1625 }
1626
1627 /* 0: enable turboedca,
1628 1: disable turboedca,
1629 2: disable turboedca and setting EDCA parameter based on the input parameter
1630 > 2 : currently reset to 0 */
1631
1632 if (mode > 2)
1633 mode = 0;
1634
1635 padapter->dis_turboedca = mode;
1636
1637 padapter->edca_param_mode = 0; /* init. value */
1638
1639 RTW_INFO("dis_turboedca mode = 0x%x\n", padapter->dis_turboedca);
1640
1641 if (num == 2) {
1642
1643 padapter->edca_param_mode = param_mode;
1644
1645 RTW_INFO("param_mode = 0x%x\n", param_mode);
1646 }
1647
1648 }
1649 return count;
1650 }
1651
proc_get_mac_qinfo(struct seq_file * m,void * v)1652 static int proc_get_mac_qinfo(struct seq_file *m, void *v)
1653 {
1654 struct net_device *dev = m->private;
1655 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1656
1657 rtw_hal_get_hwreg(adapter, HW_VAR_DUMP_MAC_QUEUE_INFO, (u8 *)m);
1658
1659 return 0;
1660 }
1661
proc_get_wifi_spec(struct seq_file * m,void * v)1662 int proc_get_wifi_spec(struct seq_file *m, void *v)
1663 {
1664 struct net_device *dev = m->private;
1665 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1666 struct registry_priv *pregpriv = &padapter->registrypriv;
1667
1668 RTW_PRINT_SEL(m, "wifi_spec=%d\n", pregpriv->wifi_spec);
1669 return 0;
1670 }
1671
proc_get_chan_plan(struct seq_file * m,void * v)1672 static int proc_get_chan_plan(struct seq_file *m, void *v)
1673 {
1674 struct net_device *dev = m->private;
1675 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1676
1677 dump_cur_chset(m, adapter_to_rfctl(adapter));
1678
1679 return 0;
1680 }
1681
proc_set_chan_plan(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1682 static ssize_t proc_set_chan_plan(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1683 {
1684 struct net_device *dev = data;
1685 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1686 char tmp[32];
1687 u16 chplan = RTW_CHPLAN_UNSPECIFIED;
1688 u16 chplan_6g = RTW_CHPLAN_6G_UNSPECIFIED;
1689
1690 if (!padapter)
1691 return -EFAULT;
1692
1693 if (count < 1) {
1694 RTW_INFO("argument size is less than 1\n");
1695 return -EFAULT;
1696 }
1697
1698 if (count > sizeof(tmp)) {
1699 rtw_warn_on(1);
1700 return -EFAULT;
1701 }
1702
1703 if (buffer && !copy_from_user(tmp, buffer, count)) {
1704 int num = sscanf(tmp, "%hx %hx", &chplan, &chplan_6g);
1705 if (num < 1)
1706 return count;
1707
1708 rtw_chplan_ioctl_input_mapping(&chplan, &chplan_6g);
1709 }
1710
1711 rtw_set_channel_plan(padapter, chplan, chplan_6g, RTW_REGD_SET_BY_USER);
1712
1713 return count;
1714 }
1715
proc_get_country_code(struct seq_file * m,void * v)1716 static int proc_get_country_code(struct seq_file *m, void *v)
1717 {
1718 struct net_device *dev = m->private;
1719 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1720 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
1721
1722 dump_cur_country(m, rfctl);
1723
1724 return 0;
1725 }
1726
proc_set_country_code(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1727 static ssize_t proc_set_country_code(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1728 {
1729 struct net_device *dev = data;
1730 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1731 char tmp[32];
1732 char alpha2[2];
1733 int num;
1734
1735 if (count < 1)
1736 return -EFAULT;
1737
1738 if (count > sizeof(tmp)) {
1739 rtw_warn_on(1);
1740 return -EFAULT;
1741 }
1742
1743 if (!buffer || copy_from_user(tmp, buffer, count))
1744 goto exit;
1745
1746 num = sscanf(tmp, "%c%c", &alpha2[0], &alpha2[1]);
1747 if (num != 2)
1748 return count;
1749
1750 rtw_set_country(padapter, alpha2, RTW_REGD_SET_BY_USER);
1751
1752 exit:
1753 return count;
1754 }
1755
1756 static int cap_spt_op_class_ch_detail = 0;
1757
proc_get_cap_spt_op_class_ch(struct seq_file * m,void * v)1758 static int proc_get_cap_spt_op_class_ch(struct seq_file *m, void *v)
1759 {
1760 struct net_device *dev = m->private;
1761 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1762
1763 dump_cap_spt_op_class_ch(m , adapter_to_rfctl(adapter), cap_spt_op_class_ch_detail);
1764 return 0;
1765 }
1766
proc_set_cap_spt_op_class_ch(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1767 static ssize_t proc_set_cap_spt_op_class_ch(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1768 {
1769 struct net_device *dev = data;
1770 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1771 char tmp[32];
1772 int num;
1773
1774 if (count < 1)
1775 return -EFAULT;
1776
1777 if (count > sizeof(tmp)) {
1778 rtw_warn_on(1);
1779 return -EFAULT;
1780 }
1781
1782 if (!buffer || copy_from_user(tmp, buffer, count))
1783 goto exit;
1784
1785 num = sscanf(tmp, "%d", &cap_spt_op_class_ch_detail);
1786
1787 exit:
1788 return count;
1789 }
1790
1791 static int reg_spt_op_class_ch_detail = 0;
1792
proc_get_reg_spt_op_class_ch(struct seq_file * m,void * v)1793 static int proc_get_reg_spt_op_class_ch(struct seq_file *m, void *v)
1794 {
1795 struct net_device *dev = m->private;
1796 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1797
1798 dump_reg_spt_op_class_ch(m , adapter_to_rfctl(adapter), reg_spt_op_class_ch_detail);
1799 return 0;
1800 }
1801
proc_set_reg_spt_op_class_ch(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1802 static ssize_t proc_set_reg_spt_op_class_ch(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1803 {
1804 struct net_device *dev = data;
1805 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1806 char tmp[32];
1807 int num;
1808
1809 if (count < 1)
1810 return -EFAULT;
1811
1812 if (count > sizeof(tmp)) {
1813 rtw_warn_on(1);
1814 return -EFAULT;
1815 }
1816
1817 if (!buffer || copy_from_user(tmp, buffer, count))
1818 goto exit;
1819
1820 num = sscanf(tmp, "%d", ®_spt_op_class_ch_detail);
1821
1822 exit:
1823 return count;
1824 }
1825
1826 static int cur_spt_op_class_ch_detail = 0;
1827
proc_get_cur_spt_op_class_ch(struct seq_file * m,void * v)1828 static int proc_get_cur_spt_op_class_ch(struct seq_file *m, void *v)
1829 {
1830 struct net_device *dev = m->private;
1831 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1832
1833 dump_cur_spt_op_class_ch(m , adapter_to_rfctl(adapter), cur_spt_op_class_ch_detail);
1834 return 0;
1835 }
1836
proc_set_cur_spt_op_class_ch(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1837 static ssize_t proc_set_cur_spt_op_class_ch(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1838 {
1839 struct net_device *dev = data;
1840 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1841 char tmp[32];
1842 int num;
1843
1844 if (count < 1)
1845 return -EFAULT;
1846
1847 if (count > sizeof(tmp)) {
1848 rtw_warn_on(1);
1849 return -EFAULT;
1850 }
1851
1852 if (!buffer || copy_from_user(tmp, buffer, count))
1853 goto exit;
1854
1855 num = sscanf(tmp, "%d", &cur_spt_op_class_ch_detail);
1856
1857 exit:
1858 return count;
1859 }
1860
1861 #if CONFIG_RTW_MACADDR_ACL
proc_get_macaddr_acl(struct seq_file * m,void * v)1862 static int proc_get_macaddr_acl(struct seq_file *m, void *v)
1863 {
1864 struct net_device *dev = m->private;
1865 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1866
1867 dump_macaddr_acl(m, adapter);
1868 return 0;
1869 }
1870
proc_set_macaddr_acl(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)1871 ssize_t proc_set_macaddr_acl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1872 {
1873 struct net_device *dev = data;
1874 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1875 char tmp[17 * NUM_ACL + 32] = {0};
1876 u8 period;
1877 char cmd[32];
1878 u8 mode;
1879 u8 addr[ETH_ALEN];
1880
1881 #define MAC_ACL_CMD_MODE 0
1882 #define MAC_ACL_CMD_ADD 1
1883 #define MAC_ACL_CMD_DEL 2
1884 #define MAC_ACL_CMD_CLR 3
1885 #define MAC_ACL_CMD_NUM 4
1886
1887 static const char * const mac_acl_cmd_str[] = {
1888 "mode",
1889 "add",
1890 "del",
1891 "clr",
1892 };
1893 u8 cmd_id = MAC_ACL_CMD_NUM;
1894
1895 if (count < 1)
1896 return -EFAULT;
1897
1898 if (count > sizeof(tmp)) {
1899 rtw_warn_on(1);
1900 return -EFAULT;
1901 }
1902
1903 if (buffer && !copy_from_user(tmp, buffer, count)) {
1904 /*
1905 * <period> mode <mode> <macaddr> [<macaddr>]
1906 * <period> mode <mode>
1907 * <period> add <macaddr> [<macaddr>]
1908 * <period> del <macaddr> [<macaddr>]
1909 * <period> clr
1910 */
1911 char *c, *next;
1912 int i;
1913 u8 is_bcast;
1914
1915 next = tmp;
1916 c = strsep(&next, " \t");
1917 if (!c || sscanf(c, "%hhu", &period) != 1)
1918 goto exit;
1919
1920 if (period >= RTW_ACL_PERIOD_NUM) {
1921 RTW_WARN(FUNC_ADPT_FMT" invalid period:%u", FUNC_ADPT_ARG(adapter), period);
1922 goto exit;
1923 }
1924
1925 c = strsep(&next, " \t");
1926 if (!c || sscanf(c, "%s", cmd) != 1)
1927 goto exit;
1928
1929 for (i = 0; i < MAC_ACL_CMD_NUM; i++)
1930 if (strcmp(mac_acl_cmd_str[i], cmd) == 0)
1931 cmd_id = i;
1932
1933 switch (cmd_id) {
1934 case MAC_ACL_CMD_MODE:
1935 c = strsep(&next, " \t");
1936 if (!c || sscanf(c, "%hhu", &mode) != 1)
1937 goto exit;
1938
1939 if (mode >= RTW_ACL_MODE_MAX) {
1940 RTW_WARN(FUNC_ADPT_FMT" invalid mode:%u", FUNC_ADPT_ARG(adapter), mode);
1941 goto exit;
1942 }
1943 break;
1944
1945 case MAC_ACL_CMD_ADD:
1946 case MAC_ACL_CMD_DEL:
1947 break;
1948
1949 case MAC_ACL_CMD_CLR:
1950 /* clear settings */
1951 rtw_macaddr_acl_clear(adapter, period);
1952 goto exit;
1953
1954 default:
1955 RTW_WARN(FUNC_ADPT_FMT" invalid cmd:\"%s\"", FUNC_ADPT_ARG(adapter), cmd);
1956 goto exit;
1957 }
1958
1959 /* check for macaddr list */
1960 c = strsep(&next, " \t");
1961 if (!c && cmd_id == MAC_ACL_CMD_MODE) {
1962 /* set mode only */
1963 rtw_set_macaddr_acl(adapter, period, mode);
1964 goto exit;
1965 }
1966
1967 if (cmd_id == MAC_ACL_CMD_MODE) {
1968 /* set mode and entire macaddr list */
1969 rtw_macaddr_acl_clear(adapter, period);
1970 rtw_set_macaddr_acl(adapter, period, mode);
1971 }
1972
1973 while (c != NULL) {
1974 if (sscanf(c, MAC_SFMT, MAC_SARG(addr)) != 6)
1975 break;
1976
1977 is_bcast = is_broadcast_mac_addr(addr);
1978 if (is_bcast
1979 || rtw_check_invalid_mac_address(addr, 0) == _FALSE
1980 ) {
1981 if (cmd_id == MAC_ACL_CMD_DEL) {
1982 rtw_acl_remove_sta(adapter, period, addr);
1983 if (is_bcast)
1984 break;
1985 } else if (!is_bcast)
1986 rtw_acl_add_sta(adapter, period, addr);
1987 }
1988
1989 c = strsep(&next, " \t");
1990 }
1991 }
1992
1993 exit:
1994 return count;
1995 }
1996 #endif /* CONFIG_RTW_MACADDR_ACL */
1997
1998 #if CONFIG_RTW_PRE_LINK_STA
proc_get_pre_link_sta(struct seq_file * m,void * v)1999 static int proc_get_pre_link_sta(struct seq_file *m, void *v)
2000 {
2001 struct net_device *dev = m->private;
2002 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2003
2004 dump_pre_link_sta_ctl(m, &adapter->stapriv);
2005 return 0;
2006 }
2007
proc_set_pre_link_sta(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2008 ssize_t proc_set_pre_link_sta(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2009 {
2010 struct net_device *dev = data;
2011 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2012 struct mlme_priv *mlme = &adapter->mlmepriv;
2013 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
2014 char tmp[17 * RTW_PRE_LINK_STA_NUM + 32] = {0};
2015 char arg0[16] = {0};
2016 u8 addr[ETH_ALEN];
2017
2018 #define PRE_LINK_STA_CMD_RESET 0
2019 #define PRE_LINK_STA_CMD_ADD 1
2020 #define PRE_LINK_STA_CMD_DEL 2
2021 #define PRE_LINK_STA_CMD_NUM 3
2022
2023 static const char * const pre_link_sta_cmd_str[] = {
2024 "reset",
2025 "add",
2026 "del"
2027 };
2028 u8 cmd_id = PRE_LINK_STA_CMD_NUM;
2029
2030 if (count < 1)
2031 return -EFAULT;
2032
2033 if (count > sizeof(tmp)) {
2034 rtw_warn_on(1);
2035 return -EFAULT;
2036 }
2037
2038 if (buffer && !copy_from_user(tmp, buffer, count)) {
2039 /* cmd [<macaddr>] */
2040 char *c, *next;
2041 int i;
2042
2043 next = tmp;
2044 c = strsep(&next, " \t");
2045
2046 if (sscanf(c, "%s", arg0) != 1)
2047 goto exit;
2048
2049 for (i = 0; i < PRE_LINK_STA_CMD_NUM; i++)
2050 if (strcmp(pre_link_sta_cmd_str[i], arg0) == 0)
2051 cmd_id = i;
2052
2053 switch (cmd_id) {
2054 case PRE_LINK_STA_CMD_RESET:
2055 rtw_pre_link_sta_ctl_reset(&adapter->stapriv);
2056 goto exit;
2057 case PRE_LINK_STA_CMD_ADD:
2058 case PRE_LINK_STA_CMD_DEL:
2059 break;
2060 default:
2061 goto exit;
2062 }
2063
2064 /* macaddr list */
2065 c = strsep(&next, " \t");
2066 while (c != NULL) {
2067 if (sscanf(c, MAC_SFMT, MAC_SARG(addr)) != 6)
2068 break;
2069
2070 if (rtw_check_invalid_mac_address(addr, 0) == _FALSE) {
2071 if (cmd_id == PRE_LINK_STA_CMD_ADD)
2072 rtw_pre_link_sta_add(&adapter->stapriv, addr);
2073 else
2074 rtw_pre_link_sta_del(&adapter->stapriv, addr);
2075 }
2076
2077 c = strsep(&next, " \t");
2078 }
2079 }
2080
2081 exit:
2082 return count;
2083 }
2084 #endif /* CONFIG_RTW_PRE_LINK_STA */
2085
proc_get_ch_sel_policy(struct seq_file * m,void * v)2086 static int proc_get_ch_sel_policy(struct seq_file *m, void *v)
2087 {
2088 struct net_device *dev = m->private;
2089 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2090 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2091
2092 RTW_PRINT_SEL(m, "%-16s\n", "within_same_band");
2093
2094 RTW_PRINT_SEL(m, "%16d\n", rfctl->ch_sel_within_same_band);
2095
2096 return 0;
2097 }
2098
proc_set_ch_sel_policy(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2099 static ssize_t proc_set_ch_sel_policy(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2100 {
2101 struct net_device *dev = data;
2102 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2103 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2104 char tmp[32];
2105 u8 within_sb;
2106 int num;
2107
2108 if (count < 1)
2109 return -EFAULT;
2110
2111 if (count > sizeof(tmp)) {
2112 rtw_warn_on(1);
2113 return -EFAULT;
2114 }
2115
2116 if (!buffer || copy_from_user(tmp, buffer, count))
2117 goto exit;
2118
2119 num = sscanf(tmp, "%hhu", &within_sb);
2120 if (num >= 1)
2121 rfctl->ch_sel_within_same_band = within_sb ? 1 : 0;
2122
2123 exit:
2124 return count;
2125 }
2126
2127 #ifdef CONFIG_80211D
proc_get_country_ie_slave_en_conds(struct seq_file * m,void * v)2128 static int proc_get_country_ie_slave_en_conds(struct seq_file *m, void *v)
2129 {
2130 struct net_device *dev = m->private;
2131 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2132 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2133
2134 RTW_PRINT_SEL(m, "%-4s %-5s\n", "role", "ifbmp");
2135 RTW_PRINT_SEL(m, "0x%02x 0x%02x\n"
2136 , rfctl->country_ie_slave_en_role
2137 , rfctl->country_ie_slave_en_ifbmp
2138 );
2139
2140 return 0;
2141 }
2142
proc_set_country_ie_slave_en_conds(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2143 static ssize_t proc_set_country_ie_slave_en_conds(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2144 {
2145 struct net_device *dev = data;
2146 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2147 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2148 char tmp[32];
2149
2150 if (count < 1)
2151 return -EFAULT;
2152
2153 if (count > sizeof(tmp)) {
2154 rtw_warn_on(1);
2155 return -EFAULT;
2156 }
2157
2158 if (buffer && !copy_from_user(tmp, buffer, count)) {
2159 u8 role, ifbmp;
2160 int num = sscanf(tmp, "%hhx %hhx", &role, &ifbmp);
2161
2162 if (num >= 1)
2163 rfctl->country_ie_slave_en_role = role;
2164 if (num >= 2)
2165 rfctl->country_ie_slave_en_ifbmp = ifbmp;
2166 }
2167
2168 return count;
2169 }
2170
proc_get_country_ie_slave_records(struct seq_file * m,void * v)2171 static int proc_get_country_ie_slave_records(struct seq_file *m, void *v)
2172 {
2173 struct net_device *dev = m->private;
2174 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2175 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2176
2177 dump_country_ie_slave_records(m, rfctl, 0);
2178
2179 return 0;
2180 }
2181 #endif /* CONFIG_80211D */
2182
2183 #ifdef CONFIG_DFS_MASTER
proc_get_dfs_test_case(struct seq_file * m,void * v)2184 static int proc_get_dfs_test_case(struct seq_file *m, void *v)
2185 {
2186 struct net_device *dev = m->private;
2187 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2188 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2189
2190 RTW_PRINT_SEL(m, "%-24s %-19s\n", "radar_detect_trigger_non", "choose_dfs_ch_first");
2191 RTW_PRINT_SEL(m, "%24hhu %19hhu\n"
2192 , rfctl->dbg_dfs_radar_detect_trigger_non
2193 , rfctl->dbg_dfs_choose_dfs_ch_first
2194 );
2195
2196 return 0;
2197 }
2198
proc_set_dfs_test_case(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2199 static ssize_t proc_set_dfs_test_case(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2200 {
2201 struct net_device *dev = data;
2202 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2203 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2204 char tmp[32];
2205 u8 radar_detect_trigger_non;
2206 u8 choose_dfs_ch_first;
2207
2208 if (count < 1)
2209 return -EFAULT;
2210
2211 if (count > sizeof(tmp)) {
2212 rtw_warn_on(1);
2213 return -EFAULT;
2214 }
2215
2216 if (buffer && !copy_from_user(tmp, buffer, count)) {
2217 int num = sscanf(tmp, "%hhu %hhu", &radar_detect_trigger_non, &choose_dfs_ch_first);
2218
2219 if (num >= 1)
2220 rfctl->dbg_dfs_radar_detect_trigger_non = radar_detect_trigger_non;
2221 if (num >= 2)
2222 rfctl->dbg_dfs_choose_dfs_ch_first = choose_dfs_ch_first;
2223 }
2224
2225 return count;
2226 }
2227
proc_set_update_non_ocp(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2228 ssize_t proc_set_update_non_ocp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2229 {
2230 struct net_device *dev = data;
2231 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2232 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2233 char tmp[32];
2234 u8 ch, bw = CHANNEL_WIDTH_20, offset = CHAN_OFFSET_NO_EXT;
2235 int ms = -1;
2236 bool updated = 0;
2237
2238 if (count < 1)
2239 return -EFAULT;
2240
2241 if (count > sizeof(tmp)) {
2242 rtw_warn_on(1);
2243 return -EFAULT;
2244 }
2245
2246 if (buffer && !copy_from_user(tmp, buffer, count)) {
2247
2248 int num = sscanf(tmp, "%hhu %hhu %hhu %d", &ch, &bw, &offset, &ms);
2249
2250 if (num < 1 || (bw != CHANNEL_WIDTH_20 && num < 3))
2251 goto exit;
2252
2253 if (bw == CHANNEL_WIDTH_20)
2254 updated = rtw_chset_update_non_ocp_ms(rfctl->channel_set
2255 , ch, bw, CHAN_OFFSET_NO_EXT, ms);
2256 else
2257 updated = rtw_chset_update_non_ocp_ms(rfctl->channel_set
2258 , ch, bw, offset, ms);
2259
2260 if (updated) {
2261 u8 cch = rtw_get_center_ch(ch, bw, offset);
2262
2263 rtw_nlrtw_nop_start_event(adapter, cch, bw);
2264 }
2265 }
2266
2267 exit:
2268 return count;
2269 }
2270
proc_set_radar_detect(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2271 ssize_t proc_set_radar_detect(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2272 {
2273 struct net_device *dev = data;
2274 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2275 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2276 char tmp[32];
2277 u8 fake_radar_detect_cnt = 0;
2278
2279 if (count < 1)
2280 return -EFAULT;
2281
2282 if (count > sizeof(tmp)) {
2283 rtw_warn_on(1);
2284 return -EFAULT;
2285 }
2286
2287 if (buffer && !copy_from_user(tmp, buffer, count)) {
2288
2289 int num = sscanf(tmp, "%hhu", &fake_radar_detect_cnt);
2290
2291 if (num < 1)
2292 goto exit;
2293
2294 rfctl->dbg_dfs_fake_radar_detect_cnt = fake_radar_detect_cnt;
2295 }
2296
2297 exit:
2298 return count;
2299 }
2300
proc_get_dfs_ch_sel_e_flags(struct seq_file * m,void * v)2301 static int proc_get_dfs_ch_sel_e_flags(struct seq_file *m, void *v)
2302 {
2303 struct net_device *dev = m->private;
2304 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2305 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2306
2307 RTW_PRINT_SEL(m, "0x%02x\n", rfctl->dfs_ch_sel_e_flags);
2308
2309 return 0;
2310 }
2311
proc_set_dfs_ch_sel_e_flags(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2312 static ssize_t proc_set_dfs_ch_sel_e_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2313 {
2314 struct net_device *dev = data;
2315 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2316 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2317 char tmp[32];
2318 u8 e_flags;
2319 int num;
2320
2321 if (count < 1)
2322 return -EFAULT;
2323
2324 if (count > sizeof(tmp)) {
2325 rtw_warn_on(1);
2326 return -EFAULT;
2327 }
2328
2329 if (!buffer || copy_from_user(tmp, buffer, count))
2330 goto exit;
2331
2332 num = sscanf(tmp, "%hhx", &e_flags);
2333 if (num != 1)
2334 goto exit;
2335
2336 rfctl->dfs_ch_sel_e_flags = e_flags;
2337
2338 exit:
2339 return count;
2340 }
2341
proc_get_dfs_ch_sel_d_flags(struct seq_file * m,void * v)2342 static int proc_get_dfs_ch_sel_d_flags(struct seq_file *m, void *v)
2343 {
2344 struct net_device *dev = m->private;
2345 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2346 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2347
2348 RTW_PRINT_SEL(m, "0x%02x\n", rfctl->dfs_ch_sel_d_flags);
2349
2350 return 0;
2351 }
2352
proc_set_dfs_ch_sel_d_flags(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2353 static ssize_t proc_set_dfs_ch_sel_d_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2354 {
2355 struct net_device *dev = data;
2356 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2357 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2358 char tmp[32];
2359 u8 d_flags;
2360 int num;
2361
2362 if (count < 1)
2363 return -EFAULT;
2364
2365 if (count > sizeof(tmp)) {
2366 rtw_warn_on(1);
2367 return -EFAULT;
2368 }
2369
2370 if (!buffer || copy_from_user(tmp, buffer, count))
2371 goto exit;
2372
2373 num = sscanf(tmp, "%hhx", &d_flags);
2374 if (num != 1)
2375 goto exit;
2376
2377 rfctl->dfs_ch_sel_d_flags = d_flags;
2378
2379 exit:
2380 return count;
2381 }
2382
2383 #if CONFIG_DFS_SLAVE_WITH_RADAR_DETECT
proc_get_dfs_slave_with_rd(struct seq_file * m,void * v)2384 static int proc_get_dfs_slave_with_rd(struct seq_file *m, void *v)
2385 {
2386 struct net_device *dev = m->private;
2387 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2388 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2389
2390 RTW_PRINT_SEL(m, "%u\n", rfctl->dfs_slave_with_rd);
2391
2392 return 0;
2393 }
2394
proc_set_dfs_slave_with_rd(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2395 static ssize_t proc_set_dfs_slave_with_rd(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2396 {
2397 struct net_device *dev = data;
2398 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2399 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
2400 char tmp[32];
2401 u8 rd;
2402 int num;
2403
2404 if (count < 1)
2405 return -EFAULT;
2406
2407 if (count > sizeof(tmp)) {
2408 rtw_warn_on(1);
2409 return -EFAULT;
2410 }
2411
2412 if (!buffer || copy_from_user(tmp, buffer, count))
2413 goto exit;
2414
2415 num = sscanf(tmp, "%hhu", &rd);
2416 if (num != 1)
2417 goto exit;
2418
2419 rd = rd ? 1 : 0;
2420
2421 if (rfctl->dfs_slave_with_rd != rd) {
2422 rfctl->dfs_slave_with_rd = rd;
2423 rtw_dfs_rd_en_decision_cmd(adapter);
2424 }
2425
2426 exit:
2427 return count;
2428 }
2429 #endif /* CONFIG_DFS_SLAVE_WITH_RADAR_DETECT */
2430 #endif /* CONFIG_DFS_MASTER */
2431
2432 #ifdef CONFIG_80211N_HT
proc_get_rx_ampdu_size_limit(struct seq_file * m,void * v)2433 int proc_get_rx_ampdu_size_limit(struct seq_file *m, void *v)
2434 {
2435 struct net_device *dev = m->private;
2436 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2437
2438 dump_regsty_rx_ampdu_size_limit(m, adapter);
2439
2440 return 0;
2441 }
2442
proc_set_rx_ampdu_size_limit(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2443 ssize_t proc_set_rx_ampdu_size_limit(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2444 {
2445 struct net_device *dev = data;
2446 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2447 struct registry_priv *regsty = adapter_to_regsty(adapter);
2448 char tmp[32];
2449 u8 nss;
2450 u8 limit_by_bw[4] = {0xFF};
2451
2452 if (count < 1)
2453 return -EFAULT;
2454
2455 if (count > sizeof(tmp)) {
2456 rtw_warn_on(1);
2457 return -EFAULT;
2458 }
2459
2460 if (buffer && !copy_from_user(tmp, buffer, count)) {
2461 int i;
2462 int num = sscanf(tmp, "%hhu %hhu %hhu %hhu %hhu"
2463 , &nss, &limit_by_bw[0], &limit_by_bw[1], &limit_by_bw[2], &limit_by_bw[3]);
2464
2465 if (num < 2)
2466 goto exit;
2467 if (nss == 0 || nss > 4)
2468 goto exit;
2469
2470 for (i = 0; i < num - 1; i++)
2471 regsty->rx_ampdu_sz_limit_by_nss_bw[nss - 1][i] = limit_by_bw[i];
2472
2473 rtw_rx_ampdu_apply(adapter);
2474 }
2475
2476 exit:
2477 return count;
2478 }
2479 #endif /* CONFIG_80211N_HT */
2480
proc_get_rx_chk_limit(struct seq_file * m,void * v)2481 static int proc_get_rx_chk_limit(struct seq_file *m, void *v)
2482 {
2483 struct net_device *dev = m->private;
2484 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2485
2486 RTW_PRINT_SEL(m, "Rx chk limit : %d\n", rtw_get_rx_chk_limit(padapter));
2487
2488 return 0;
2489 }
2490
proc_set_rx_chk_limit(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2491 static ssize_t proc_set_rx_chk_limit(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2492 {
2493 char tmp[32];
2494 struct net_device *dev = data;
2495 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2496 int rx_chk_limit;
2497
2498 if (count < 1) {
2499 RTW_INFO("argument size is less than 1\n");
2500 return -EFAULT;
2501 }
2502
2503 if (count > sizeof(tmp)) {
2504 rtw_warn_on(1);
2505 return -EFAULT;
2506 }
2507
2508 if (buffer && !copy_from_user(tmp, buffer, count)) {
2509 int num = sscanf(tmp, "%d", &rx_chk_limit);
2510
2511 rtw_set_rx_chk_limit(padapter, rx_chk_limit);
2512 }
2513
2514 return count;
2515 }
2516
proc_get_udpport(struct seq_file * m,void * v)2517 static int proc_get_udpport(struct seq_file *m, void *v)
2518 {
2519 struct net_device *dev = m->private;
2520 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2521 struct recv_info *precvinfo = &(padapter->recvinfo);
2522
2523 RTW_PRINT_SEL(m, "%d\n", precvinfo->sink_udpport);
2524 return 0;
2525 }
proc_set_udpport(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2526 static ssize_t proc_set_udpport(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2527 {
2528 struct net_device *dev = data;
2529 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2530 struct recv_info *precvinfo = &(padapter->recvinfo);
2531 int sink_udpport = 0;
2532 char tmp[32];
2533
2534
2535 if (!padapter)
2536 return -EFAULT;
2537
2538 if (count < 1) {
2539 RTW_INFO("argument size is less than 1\n");
2540 return -EFAULT;
2541 }
2542
2543 if (count > sizeof(tmp)) {
2544 rtw_warn_on(1);
2545 return -EFAULT;
2546 }
2547
2548 if (buffer && !copy_from_user(tmp, buffer, count)) {
2549
2550 int num = sscanf(tmp, "%d", &sink_udpport);
2551
2552 if (num != 1) {
2553 RTW_INFO("invalid input parameter number!\n");
2554 return count;
2555 }
2556
2557 }
2558 precvinfo->sink_udpport = sink_udpport;
2559
2560 return count;
2561
2562 }
2563
2564 #if 0
2565 static int proc_get_mi_ap_bc_info(struct seq_file *m, void *v)
2566 {
2567 struct net_device *dev = m->private;
2568 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2569 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
2570 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
2571 u8 i;
2572
2573 for (i = 0; i < dvobj->iface_nums; i++)
2574 RTW_PRINT_SEL(m, "iface_id:%d, mac_id && sec_cam_id = %d\n", i, macid_ctl->iface_bmc[i]);
2575
2576 return 0;
2577 }
2578 #endif
2579 #if 0
2580 static int proc_get_macid_info(struct seq_file *m, void *v)
2581 {
2582 struct net_device *dev = m->private;
2583 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2584 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
2585 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
2586 u8 i;
2587 u8 null_addr[ETH_ALEN] = {0};
2588 u8 *macaddr;
2589
2590 RTW_PRINT_SEL(m, "max_num:%u\n", macid_ctl->num);
2591 RTW_PRINT_SEL(m, "\n");
2592
2593 RTW_PRINT_SEL(m, "used:\n");
2594 dump_macid_map(m, &macid_ctl->used, macid_ctl->num);
2595 RTW_PRINT_SEL(m, "\n");
2596
2597 RTW_PRINT_SEL(m, "%-3s %-3s %-5s %-4s %-17s %-6s %-3s"
2598 , "id", "bmc", "ifbmp", "ch_g", "macaddr", "bw", "vht");
2599
2600 if (GET_HAL_TX_NSS(dvobj) > 2)
2601 _RTW_PRINT_SEL(m, " %-10s", "rate_bmp1");
2602
2603 _RTW_PRINT_SEL(m, " %-10s %s\n", "rate_bmp0", "status");
2604
2605 for (i = 0; i < macid_ctl->num; i++) {
2606 if (rtw_macid_is_used(macid_ctl, i)
2607 || macid_ctl->h2c_msr[i]
2608 ) {
2609 if (macid_ctl->sta[i])
2610 macaddr = macid_ctl->sta[i]->phl_sta->mac_addr;
2611 else
2612 macaddr = null_addr;
2613
2614 RTW_PRINT_SEL(m, "%3u %3u 0x%02x %4d "MAC_FMT" %6s %3u"
2615 , i
2616 , rtw_macid_is_bmc(macid_ctl, i)
2617 , rtw_macid_get_iface_bmp(macid_ctl, i)
2618 , rtw_macid_get_ch_g(macid_ctl, i)
2619 , MAC_ARG(macaddr)
2620 , ch_width_str(macid_ctl->bw[i])
2621 , macid_ctl->vht_en[i]
2622 );
2623
2624 if (GET_HAL_TX_NSS(dvobj) > 2)
2625 _RTW_PRINT_SEL(m, " 0x%08X", macid_ctl->rate_bmp1[i]);
2626 #ifdef DBG_MACID_MSR_INFO
2627 _RTW_PRINT_SEL(m, " 0x%08X "H2C_MSR_FMT" %s\n"
2628 , macid_ctl->rate_bmp0[i]
2629 , H2C_MSR_ARG(&macid_ctl->h2c_msr[i])
2630 , rtw_macid_is_used(macid_ctl, i) ? "" : "[unused]"
2631 );
2632 #endif
2633 }
2634 }
2635
2636 return 0;
2637 }
2638 #endif
proc_get_sec_cam(struct seq_file * m,void * v)2639 static int proc_get_sec_cam(struct seq_file *m, void *v)
2640 {
2641 struct net_device *dev = m->private;
2642 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2643 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
2644 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
2645
2646 RTW_PRINT_SEL(m, "sec_cap:0x%02x\n", cam_ctl->sec_cap);
2647 RTW_PRINT_SEL(m, "flags:0x%08x\n", cam_ctl->flags);
2648 RTW_PRINT_SEL(m, "\n");
2649
2650 RTW_PRINT_SEL(m, "max_num:%u\n", cam_ctl->num);
2651 RTW_PRINT_SEL(m, "used:\n");
2652 dump_sec_cam_map(m, &cam_ctl->used, cam_ctl->num);
2653 RTW_PRINT_SEL(m, "\n");
2654
2655 #if 0 /*GEORGIA_TODO_REDEFINE_IO*/
2656 RTW_PRINT_SEL(m, "reg_scr:0x%04x\n", rtw_read16(adapter, 0x680));
2657 #endif
2658 RTW_PRINT_SEL(m, "\n");
2659
2660 dump_sec_cam(m, adapter);
2661
2662 return 0;
2663 }
2664
proc_set_sec_cam(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2665 static ssize_t proc_set_sec_cam(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2666 {
2667 struct net_device *dev = data;
2668 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2669 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
2670 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
2671 char tmp[32] = {0};
2672 char cmd[4];
2673 u8 id_1 = 0, id_2 = 0;
2674
2675 if (count > sizeof(tmp)) {
2676 rtw_warn_on(1);
2677 return -EFAULT;
2678 }
2679
2680 if (buffer && !copy_from_user(tmp, buffer, count)) {
2681
2682 /* c <id_1>: clear specific cam entry */
2683 /* wfc <id_1>: write specific cam entry from cam cache */
2684 /* sw <id_1> <id_2>: sec_cam 1/2 swap */
2685
2686 int num = sscanf(tmp, "%s %hhu %hhu", cmd, &id_1, &id_2);
2687
2688 if (num < 2)
2689 return count;
2690
2691 if ((id_1 >= cam_ctl->num) || (id_2 >= cam_ctl->num)) {
2692 RTW_ERR(FUNC_ADPT_FMT" invalid id_1:%u id_2:%u\n", FUNC_ADPT_ARG(adapter), id_1, id_2);
2693 return count;
2694 }
2695
2696 if (strcmp("c", cmd) == 0) {
2697 _clear_cam_entry(adapter, id_1);
2698 adapter->securitypriv.hw_decrypted = _FALSE; /* temporarily set this for TX path to use SW enc */
2699 } else if (strcmp("wfc", cmd) == 0)
2700 write_cam_from_cache(adapter, id_1);
2701 else if (strcmp("sw", cmd) == 0)
2702 rtw_sec_cam_swap(adapter, id_1, id_2);
2703 else if (strcmp("cdk", cmd) == 0)
2704 rtw_clean_dk_section(adapter);
2705 #ifdef DBG_SEC_CAM_MOVE
2706 else if (strcmp("sgd", cmd) == 0)
2707 rtw_hal_move_sta_gk_to_dk(adapter);
2708 else if (strcmp("rsd", cmd) == 0)
2709 rtw_hal_read_sta_dk_key(adapter, id_1);
2710 #endif
2711 }
2712
2713 return count;
2714 }
2715
proc_get_sec_cam_cache(struct seq_file * m,void * v)2716 static int proc_get_sec_cam_cache(struct seq_file *m, void *v)
2717 {
2718 struct net_device *dev = m->private;
2719 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2720
2721 dump_sec_cam_cache(m, adapter);
2722 return 0;
2723 }
2724
2725 #ifdef CONFIG_DBG_AX_CAM
2726
proc_get_ax_address_cam(struct seq_file * m,void * v)2727 static int proc_get_ax_address_cam(struct seq_file *m, void *v) {
2728 struct net_device *dev = m->private;
2729 struct _ADAPTER *adapter = (struct _ADAPTER *)rtw_netdev_priv(dev);
2730
2731 get_ax_address_cam(m, adapter);
2732 return 0;
2733 }
2734
proc_get_ax_sec_cam(struct seq_file * m,void * v)2735 static int proc_get_ax_sec_cam(struct seq_file *m, void *v) {
2736 struct net_device *dev = m->private;
2737 struct _ADAPTER *adapter = (struct _ADAPTER *)rtw_netdev_priv(dev);
2738
2739 get_ax_sec_cam(m, adapter);
2740 return 0;
2741 }
2742
proc_get_ax_valid_key(struct seq_file * m,void * v)2743 static int proc_get_ax_valid_key(struct seq_file *m, void *v) {
2744 struct net_device *dev = m->private;
2745 struct _ADAPTER *adapter = (struct _ADAPTER *)rtw_netdev_priv(dev);
2746
2747 get_ax_valid_key(m, adapter);
2748 return 0;
2749 }
2750
2751 #endif
2752
proc_set_change_bss_chbw(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2753 static ssize_t proc_set_change_bss_chbw(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2754 {
2755 struct net_device *dev = data;
2756 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2757 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
2758 int i;
2759 char tmp[32];
2760 s16 ch;
2761 s8 bw = REQ_BW_NONE, offset = REQ_OFFSET_NONE;
2762 u8 ifbmp = 0;
2763
2764 if (count < 1)
2765 return -EFAULT;
2766
2767 if (count > sizeof(tmp)) {
2768 rtw_warn_on(1);
2769 return -EFAULT;
2770 }
2771
2772 if (buffer && !copy_from_user(tmp, buffer, count)) {
2773
2774 int num = sscanf(tmp, "%hd %hhd %hhd %hhx", &ch, &bw, &offset, &ifbmp);
2775
2776 if (num < 1 || (bw != CHANNEL_WIDTH_20 && num < 3))
2777 goto exit;
2778
2779 if (num < 4)
2780 ifbmp = BIT(adapter->iface_id);
2781 else
2782 ifbmp &= (1 << dvobj->iface_nums) - 1;
2783
2784 for (i = 0; i < dvobj->iface_nums; i++) {
2785 if (!(ifbmp & BIT(i)) || !dvobj->padapters[i])
2786 continue;
2787
2788 if (!CHK_MLME_STATE(dvobj->padapters[i], WIFI_AP_STATE | WIFI_MESH_STATE)
2789 || !MLME_IS_ASOC(dvobj->padapters[i]))
2790 ifbmp &= ~BIT(i);
2791 }
2792
2793 if (ifbmp)
2794 rtw_change_bss_chbw_cmd(adapter, RTW_CMDF_WAIT_ACK, ifbmp, 0, ch, bw, offset);
2795 }
2796
2797 exit:
2798 return count;
2799 }
2800
proc_get_tx_bw_mode(struct seq_file * m,void * v)2801 static int proc_get_tx_bw_mode(struct seq_file *m, void *v)
2802 {
2803 struct net_device *dev = m->private;
2804 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2805
2806 RTW_PRINT_SEL(m, "0x%02x\n", adapter->driver_tx_bw_mode);
2807 RTW_PRINT_SEL(m, "2.4G:%s\n", ch_width_str(ADAPTER_TX_BW_2G(adapter)));
2808 RTW_PRINT_SEL(m, "5G:%s\n", ch_width_str(ADAPTER_TX_BW_5G(adapter)));
2809
2810 return 0;
2811 }
2812
rtw_set_tx_bw_mode(_adapter * adapter,u8 bw_mode)2813 static void rtw_set_tx_bw_mode(_adapter *adapter, u8 bw_mode)
2814 {
2815 struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv);
2816 /* macid_ctl move to phl */
2817 /* struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl; */
2818 u8 update = _FALSE;
2819
2820 if ((MLME_STATE(adapter) & WIFI_ASOC_STATE)
2821 && ((mlmeext->chandef.chan <= 14 && BW_MODE_2G(bw_mode) != ADAPTER_TX_BW_2G(adapter))
2822 || (mlmeext->chandef.chan >= 36 && BW_MODE_5G(bw_mode) != ADAPTER_TX_BW_5G(adapter)))
2823 ) {
2824 /* RA mask update needed */
2825 update = _TRUE;
2826 }
2827 adapter->driver_tx_bw_mode = bw_mode;
2828
2829 #if 0
2830 if (update == _TRUE) {
2831 struct sta_info *sta;
2832 int i;
2833
2834 /*for (i = 0; i < MACID_NUM_SW_LIMIT; i++) {*/
2835 //sta = macid_ctl->sta[i];
2836
2837 sta = rtw_get_stainfo(&adapter->stapriv, get_bssid(&adapter->mlmepriv));
2838 if (sta && !is_broadcast_mac_addr(sta->phl_sta->mac_addr)) {
2839 rtw_phl_cmd_change_stainfo(adapter_to_dvobj(adapter)->phl,
2840 sta->phl_sta,
2841 STA_CHG_RAMASK,
2842 NULL,
2843 0,
2844 PHL_CMD_NO_WAIT, /*PHL_CMD_DIRECTLY,PHL_CMD_WAIT*/
2845 0);
2846 }
2847 }
2848 /*}*/
2849 #endif
2850 }
2851
proc_set_tx_bw_mode(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2852 static ssize_t proc_set_tx_bw_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2853 {
2854 struct net_device *dev = data;
2855 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2856 char tmp[32];
2857 u8 bw_mode;
2858
2859 if (count < 1)
2860 return -EFAULT;
2861
2862 if (count > sizeof(tmp)) {
2863 rtw_warn_on(1);
2864 return -EFAULT;
2865 }
2866
2867 if (buffer && !copy_from_user(tmp, buffer, count)) {
2868
2869 int num = sscanf(tmp, "%hhx", &bw_mode);
2870
2871 if (num < 1 || bw_mode == adapter->driver_tx_bw_mode)
2872 goto exit;
2873
2874 rtw_set_tx_bw_mode(adapter, bw_mode);
2875 }
2876
2877 exit:
2878 return count;
2879 }
2880
proc_get_hal_txpwr_info(struct seq_file * m,void * v)2881 static int proc_get_hal_txpwr_info(struct seq_file *m, void *v)
2882 {
2883 #ifdef CONFIG_TXPWR_PG_WITH_PWR_IDX
2884 struct net_device *dev = m->private;
2885 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2886 struct dvobj_priv *devob = adapter_to_dvobj(adapter);
2887 HAL_DATA_TYPE *hal_data = GET_PHL_COM(devob);
2888 struct hal_spec_t *hal_spec = GET_HAL_SPEC(devob);
2889
2890 if (hal_data->txpwr_pg_mode == TXPWR_PG_WITH_PWR_IDX) {
2891 if (rtw_hw_is_band_support(devob, BAND_ON_24G))
2892 dump_hal_txpwr_info_2g(m, adapter, hal_spec->rfpath_num_2g, hal_data->max_tx_cnt);
2893
2894 #if CONFIG_IEEE80211_BAND_5GHZ
2895 if (rtw_hw_is_band_support(devob, BAND_ON_5G))
2896 dump_hal_txpwr_info_5g(m, adapter, hal_spec->rfpath_num_5g, hal_data->max_tx_cnt);
2897 #endif
2898 }
2899 #endif
2900
2901 return 0;
2902 }
2903
proc_get_target_tx_power(struct seq_file * m,void * v)2904 static int proc_get_target_tx_power(struct seq_file *m, void *v)
2905 {
2906 struct net_device *dev = m->private;
2907 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2908
2909 rtw_hal_dump_target_tx_power(m, adapter);
2910
2911 return 0;
2912 }
2913
proc_get_tx_power_by_rate(struct seq_file * m,void * v)2914 static int proc_get_tx_power_by_rate(struct seq_file *m, void *v)
2915 {
2916 struct net_device *dev = m->private;
2917 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2918
2919 rtw_hal_dump_tx_power_by_rate(m, adapter);
2920
2921 return 0;
2922 }
2923
2924 #if CONFIG_TXPWR_LIMIT
proc_get_tx_power_limit(struct seq_file * m,void * v)2925 static int proc_get_tx_power_limit(struct seq_file *m, void *v)
2926 {
2927 struct net_device *dev = m->private;
2928 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2929
2930 dump_txpwr_lmt(m, adapter);
2931
2932 return 0;
2933 }
2934 #endif /* CONFIG_TXPWR_LIMIT */
2935
proc_get_tx_power_ext_info(struct seq_file * m,void * v)2936 static int proc_get_tx_power_ext_info(struct seq_file *m, void *v)
2937 {
2938 struct net_device *dev = m->private;
2939 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2940
2941 rtw_dump_phl_tx_power_ext_info(m, adapter);
2942
2943 return 0;
2944 }
2945
proc_set_tx_power_ext_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)2946 static ssize_t proc_set_tx_power_ext_info(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
2951 char tmp[32] = {0};
2952 char cmd[16] = {0};
2953
2954 if (count > sizeof(tmp)) {
2955 rtw_warn_on(1);
2956 return -EFAULT;
2957 }
2958
2959 if (buffer && !copy_from_user(tmp, buffer, count)) {
2960
2961 int num = sscanf(tmp, "%s", cmd);
2962
2963 if (num < 1)
2964 return count;
2965
2966 #if 0 /* TODO */
2967 #ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
2968 phy_free_filebuf_mask(adapter, LOAD_BB_PG_PARA_FILE | LOAD_RF_TXPWR_LMT_PARA_FILE);
2969 #endif
2970
2971 rtw_ps_deny(adapter, PS_DENY_IOCTL);
2972 if (rtw_pwr_wakeup(adapter) == _FALSE)
2973 goto clear_ps_deny;
2974
2975 if (strcmp("default", cmd) == 0)
2976 rtw_run_in_thread_cmd(adapter, ((void *)(phy_reload_default_tx_power_ext_info)), adapter);
2977 else
2978 rtw_run_in_thread_cmd(adapter, ((void *)(phy_reload_tx_power_ext_info)), adapter);
2979
2980 rtw_run_in_thread_cmd_wait(adapter, ((void *)(rtw_hal_update_txpwr_level)), adapter, 2000);
2981
2982 clear_ps_deny:
2983 rtw_ps_deny_cancel(adapter, PS_DENY_IOCTL);
2984 #endif
2985 }
2986
2987 return count;
2988 }
2989
2990 #ifdef GEORGIA_TODO_TX_PWR
proc_start_tx_power_idx(struct seq_file * m,loff_t * pos)2991 static void *proc_start_tx_power_idx(struct seq_file *m, loff_t *pos)
2992 {
2993 u8 path = ((*pos) & 0xFF00) >> 8;
2994
2995 if (path >= RF_PATH_MAX)
2996 return NULL;
2997
2998 return pos;
2999 }
proc_stop_tx_power_idx(struct seq_file * m,void * v)3000 static void proc_stop_tx_power_idx(struct seq_file *m, void *v)
3001 {
3002 }
3003
proc_next_tx_power_idx(struct seq_file * m,void * v,loff_t * pos)3004 static void *proc_next_tx_power_idx(struct seq_file *m, void *v, loff_t *pos)
3005 {
3006 u8 path = ((*pos) & 0xFF00) >> 8;
3007 u8 rs = *pos & 0xFF;
3008
3009 rs++;
3010 if (rs >= RATE_SECTION_NUM) {
3011 rs = 0;
3012 path++;
3013 }
3014
3015 if (path >= RF_PATH_MAX)
3016 return NULL;
3017
3018 *pos = (path << 8) | rs;
3019
3020 return pos;
3021 }
3022
proc_get_tx_power_idx(struct seq_file * m,void * v)3023 static int proc_get_tx_power_idx(struct seq_file *m, void *v)
3024 {
3025 struct net_device *dev = m->private;
3026 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3027 u32 pos = *((loff_t *)(v));
3028 u8 path = (pos & 0xFF00) >> 8;
3029 u8 rs = pos & 0xFF;
3030
3031 if (0)
3032 RTW_INFO("%s path=%u, rs=%u\n", __func__, path, rs);
3033
3034 if (path == RF_PATH_A && rs == CCK)
3035 dump_tx_power_idx_title(m, adapter);
3036 dump_tx_power_idx_by_path_rs(m, adapter, path, rs);
3037
3038 return 0;
3039 }
3040
3041 static struct seq_operations seq_ops_tx_power_idx = {
3042 .start = proc_start_tx_power_idx,
3043 .stop = proc_stop_tx_power_idx,
3044 .next = proc_next_tx_power_idx,
3045 .show = proc_get_tx_power_idx,
3046 };
3047
proc_start_txpwr_total_dbm(struct seq_file * m,loff_t * pos)3048 static void *proc_start_txpwr_total_dbm(struct seq_file *m, loff_t *pos)
3049 {
3050 u8 rs = *pos;
3051
3052 if (rs >= RATE_SECTION_NUM)
3053 return NULL;
3054
3055 return pos;
3056 }
3057
proc_stop_txpwr_total_dbm(struct seq_file * m,void * v)3058 static void proc_stop_txpwr_total_dbm(struct seq_file *m, void *v)
3059 {
3060 }
3061
proc_next_txpwr_total_dbm(struct seq_file * m,void * v,loff_t * pos)3062 static void *proc_next_txpwr_total_dbm(struct seq_file *m, void *v, loff_t *pos)
3063 {
3064 u8 rs = *pos;
3065
3066 rs++;
3067 if (rs >= RATE_SECTION_NUM)
3068 return NULL;
3069
3070 *pos = rs;
3071
3072 return pos;
3073 }
3074
proc_get_txpwr_total_dbm(struct seq_file * m,void * v)3075 static int proc_get_txpwr_total_dbm(struct seq_file *m, void *v)
3076 {
3077 struct net_device *dev = m->private;
3078 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3079 u32 pos = *((loff_t *)(v));
3080 u8 rs = pos;
3081
3082 if (rs == CCK)
3083 dump_txpwr_total_dbm_title(m, adapter);
3084 dump_txpwr_total_dbm_by_rs(m, adapter, rs);
3085
3086 return 0;
3087 }
3088
3089 static struct seq_operations seq_ops_txpwr_total_dbm = {
3090 .start = proc_start_txpwr_total_dbm,
3091 .stop = proc_stop_txpwr_total_dbm,
3092 .next = proc_next_txpwr_total_dbm,
3093 .show = proc_get_txpwr_total_dbm,
3094 };
3095 #endif
3096
3097 #ifdef CONFIG_BTC
3098 static u8 btreg_read_type = 0;
3099 static u16 btreg_read_addr = 0;
3100 static int btreg_read_error = 0;
3101 static u8 btreg_write_type = 0;
3102 static u16 btreg_write_addr = 0;
3103 static int btreg_write_error = 0;
3104
3105 static u8 *btreg_type[] = {
3106 "rf",
3107 "modem",
3108 "bluewize",
3109 "vendor",
3110 "le"
3111 };
3112
btreg_parse_str(char const * input,u8 * type,u16 * addr,u16 * val)3113 static int btreg_parse_str(char const *input, u8 *type, u16 *addr, u16 *val)
3114 {
3115 u32 num;
3116 u8 str[80] = {0};
3117 u8 t = 0;
3118 u32 a, v;
3119 u8 i, n;
3120
3121
3122 num = sscanf(input, "%s %x %x", str, &a, &v);
3123 if (num < 2) {
3124 RTW_INFO("%s: INVALID input!(%s)\n", __FUNCTION__, input);
3125 return -EINVAL;
3126 }
3127 if ((num < 3) && val) {
3128 RTW_INFO("%s: INVALID input!(%s)\n", __FUNCTION__, input);
3129 return -EINVAL;
3130 }
3131
3132 n = sizeof(btreg_type) / sizeof(btreg_type[0]);
3133 for (i = 0; i < n; i++) {
3134 if (!strcasecmp(str, btreg_type[i])) {
3135 t = i;
3136 break;
3137 }
3138 }
3139 if (i == n) {
3140 RTW_INFO("%s: unknown type(%s)!\n", __FUNCTION__, str);
3141 return -EINVAL;
3142 }
3143
3144 switch (t) {
3145 case 0:
3146 /* RF */
3147 if (a & 0xFFFFFF80) {
3148 RTW_INFO("%s: INVALID address(0x%X) for type %s(%d)!\n",
3149 __FUNCTION__, a, btreg_type[t], t);
3150 return -EINVAL;
3151 }
3152 break;
3153 case 1:
3154 /* Modem */
3155 if (a & 0xFFFFFE00) {
3156 RTW_INFO("%s: INVALID address(0x%X) for type %s(%d)!\n",
3157 __FUNCTION__, a, btreg_type[t], t);
3158 return -EINVAL;
3159 }
3160 break;
3161 default:
3162 /* Others(Bluewize, Vendor, LE) */
3163 if (a & 0xFFFFF000) {
3164 RTW_INFO("%s: INVALID address(0x%X) for type %s(%d)!\n",
3165 __FUNCTION__, a, btreg_type[t], t);
3166 return -EINVAL;
3167 }
3168 break;
3169 }
3170
3171 if (val) {
3172 if (v & 0xFFFF0000) {
3173 RTW_INFO("%s: INVALID value(0x%x)!\n", __FUNCTION__, v);
3174 return -EINVAL;
3175 }
3176 *val = (u16)v;
3177 }
3178
3179 *type = (u8)t;
3180 *addr = (u16)a;
3181
3182 return 0;
3183 }
3184
proc_get_btreg_read(struct seq_file * m,void * v)3185 int proc_get_btreg_read(struct seq_file *m, void *v)
3186 {
3187 #if 0
3188 struct net_device *dev;
3189 _adapter *padapter;
3190 u16 ret;
3191 u32 data;
3192
3193
3194 if (btreg_read_error)
3195 return btreg_read_error;
3196
3197 dev = m->private;
3198 padapter = (_adapter *)rtw_netdev_priv(dev);
3199
3200 ret = rtw_btc_btreg_read(padapter, btreg_read_type, btreg_read_addr, &data);
3201 if (CHECK_STATUS_CODE_FROM_BT_MP_OPER_RET(ret, BT_STATUS_BT_OP_SUCCESS))
3202 RTW_PRINT_SEL(m, "BTREG read: (%s)0x%04X = 0x%08x\n", btreg_type[btreg_read_type], btreg_read_addr, data);
3203 else
3204 RTW_PRINT_SEL(m, "BTREG read: (%s)0x%04X read fail. error code = 0x%04x.\n", btreg_type[btreg_read_type], btreg_read_addr, ret);
3205 #endif
3206
3207 return 0;
3208 }
3209
proc_set_btreg_read(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3210 ssize_t proc_set_btreg_read(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3211 {
3212 #if 0
3213 struct net_device *dev = data;
3214 _adapter *padapter;
3215 u8 tmp[80] = {0};
3216 u32 num;
3217 int err;
3218
3219
3220 padapter = (_adapter *)rtw_netdev_priv(dev);
3221
3222 if (NULL == buffer) {
3223 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n",
3224 FUNC_ADPT_ARG(padapter));
3225 err = -EFAULT;
3226 goto exit;
3227 }
3228
3229 if (count < 1) {
3230 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n",
3231 FUNC_ADPT_ARG(padapter));
3232 err = -EFAULT;
3233 goto exit;
3234 }
3235
3236 num = count;
3237 if (num > (sizeof(tmp) - 1))
3238 num = (sizeof(tmp) - 1);
3239
3240 if (copy_from_user(tmp, buffer, num)) {
3241 RTW_INFO(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
3242 FUNC_ADPT_ARG(padapter));
3243 err = -EFAULT;
3244 goto exit;
3245 }
3246 /* [Coverity] sure tmp end with '\0'(string terminal) */
3247 tmp[sizeof(tmp) - 1] = 0;
3248
3249 err = btreg_parse_str(tmp, &btreg_read_type, &btreg_read_addr, NULL);
3250 if (err)
3251 goto exit;
3252
3253 RTW_INFO(FUNC_ADPT_FMT ": addr=(%s)0x%X\n",
3254 FUNC_ADPT_ARG(padapter), btreg_type[btreg_read_type], btreg_read_addr);
3255
3256 exit:
3257 btreg_read_error = err;
3258 #endif
3259
3260 return count;
3261 }
3262
proc_get_btreg_write(struct seq_file * m,void * v)3263 int proc_get_btreg_write(struct seq_file *m, void *v)
3264 {
3265 #if 0
3266 struct net_device *dev;
3267 _adapter *padapter;
3268 u16 ret;
3269 u32 data;
3270
3271
3272 if (btreg_write_error < 0)
3273 return btreg_write_error;
3274 else if (btreg_write_error > 0) {
3275 RTW_PRINT_SEL(m, "BTREG write: (%s)0x%04X write fail. error code = 0x%04x.\n", btreg_type[btreg_write_type], btreg_write_addr, btreg_write_error);
3276 return 0;
3277 }
3278
3279 dev = m->private;
3280 padapter = (_adapter *)rtw_netdev_priv(dev);
3281
3282 ret = rtw_btc_btreg_read(padapter, btreg_write_type, btreg_write_addr, &data);
3283 if (CHECK_STATUS_CODE_FROM_BT_MP_OPER_RET(ret, BT_STATUS_BT_OP_SUCCESS))
3284 RTW_PRINT_SEL(m, "BTREG read: (%s)0x%04X = 0x%08x\n", btreg_type[btreg_write_type], btreg_write_addr, data);
3285 else
3286 RTW_PRINT_SEL(m, "BTREG read: (%s)0x%04X read fail. error code = 0x%04x.\n", btreg_type[btreg_write_type], btreg_write_addr, ret);
3287 #endif
3288
3289 return 0;
3290 }
3291
proc_set_btreg_write(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3292 ssize_t proc_set_btreg_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3293 {
3294 #if 0
3295 struct net_device *dev = data;
3296 _adapter *padapter;
3297 u8 tmp[80] = {0};
3298 u32 num;
3299 u16 val;
3300 u16 ret;
3301 int err;
3302
3303
3304 padapter = (_adapter *)rtw_netdev_priv(dev);
3305
3306 if (NULL == buffer) {
3307 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n",
3308 FUNC_ADPT_ARG(padapter));
3309 err = -EFAULT;
3310 goto exit;
3311 }
3312
3313 if (count < 1) {
3314 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n",
3315 FUNC_ADPT_ARG(padapter));
3316 err = -EFAULT;
3317 goto exit;
3318 }
3319
3320 num = count;
3321 if (num > (sizeof(tmp) - 1))
3322 num = (sizeof(tmp) - 1);
3323
3324 if (copy_from_user(tmp, buffer, num)) {
3325 RTW_INFO(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
3326 FUNC_ADPT_ARG(padapter));
3327 err = -EFAULT;
3328 goto exit;
3329 }
3330
3331 err = btreg_parse_str(tmp, &btreg_write_type, &btreg_write_addr, &val);
3332 if (err)
3333 goto exit;
3334
3335 RTW_INFO(FUNC_ADPT_FMT ": Set (%s)0x%X = 0x%x\n",
3336 FUNC_ADPT_ARG(padapter), btreg_type[btreg_write_type], btreg_write_addr, val);
3337
3338 ret = rtw_btc_btreg_write(padapter, btreg_write_type, btreg_write_addr, val);
3339 if (!CHECK_STATUS_CODE_FROM_BT_MP_OPER_RET(ret, BT_STATUS_BT_OP_SUCCESS))
3340 err = ret;
3341
3342 exit:
3343 btreg_write_error = err;
3344 #endif
3345
3346 return count;
3347 }
3348
3349 #endif /* CONFIG_BTC */
3350
3351
proc_get_mac_addr(struct seq_file * m,void * v)3352 int proc_get_mac_addr(struct seq_file *m, void *v)
3353 {
3354 struct net_device *dev = m->private;
3355 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3356
3357 rtw_hal_dump_macaddr(m, adapter);
3358 return 0;
3359 }
3360
proc_get_skip_band(struct seq_file * m,void * v)3361 static int proc_get_skip_band(struct seq_file *m, void *v)
3362 {
3363 struct net_device *dev = m->private;
3364 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3365 int bandskip;
3366
3367 bandskip = RTW_GET_SCAN_BAND_SKIP(adapter);
3368 RTW_PRINT_SEL(m, "bandskip:0x%02x\n", bandskip);
3369 return 0;
3370 }
3371
proc_set_skip_band(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3372 static ssize_t proc_set_skip_band(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3373 {
3374 struct net_device *dev = data;
3375 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3376 char tmp[6];
3377 u8 skip_band;
3378
3379 if (count < 1)
3380 return -EFAULT;
3381
3382 if (count > sizeof(tmp)) {
3383 rtw_warn_on(1);
3384 return -EFAULT;
3385 }
3386 if (buffer && !copy_from_user(tmp, buffer, count)) {
3387
3388 int num = sscanf(tmp, "%hhu", &skip_band);
3389
3390 if (num < 1)
3391 return -EINVAL;
3392
3393 if (1 == skip_band)
3394 RTW_SET_SCAN_BAND_SKIP(padapter, BAND_24G);
3395 else if (2 == skip_band)
3396 RTW_SET_SCAN_BAND_SKIP(padapter, BAND_5G);
3397 else if (3 == skip_band)
3398 RTW_CLR_SCAN_BAND_SKIP(padapter, BAND_24G);
3399 else if (4 == skip_band)
3400 RTW_CLR_SCAN_BAND_SKIP(padapter, BAND_5G);
3401 }
3402 return count;
3403
3404 }
3405
3406 #ifdef CONFIG_RTW_ACS
3407 #ifdef WKARD_ACS
rtw_acs_chan_info_dump(struct seq_file * m,_adapter * a)3408 static void rtw_acs_chan_info_dump(struct seq_file *m, _adapter *a)
3409 {
3410 }
3411
rtw_acs_info_dump(struct seq_file * m,_adapter * a)3412 static void rtw_acs_info_dump(struct seq_file *m, _adapter *a)
3413 {
3414 }
3415
proc_get_chan_info(struct seq_file * m,void * v)3416 static int proc_get_chan_info(struct seq_file *m, void *v)
3417 {
3418 struct net_device *dev = m->private;
3419 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3420
3421 rtw_acs_chan_info_dump(m, adapter);
3422 return 0;
3423 }
3424
proc_get_best_chan(struct seq_file * m,void * v)3425 static int proc_get_best_chan(struct seq_file *m, void *v)
3426 {
3427 struct net_device *dev = m->private;
3428 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3429
3430 if (IS_ACS_ENABLE(adapter))
3431 rtw_acs_info_dump(m, adapter);
3432 else
3433 _RTW_PRINT_SEL(m,"ACS disabled\n");
3434 return 0;
3435 }
3436
proc_set_acs(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3437 static ssize_t proc_set_acs(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3438 {
3439 #ifdef CONFIG_RTW_ACS_DBG
3440 struct net_device *dev = data;
3441 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3442 char tmp[32];
3443 u8 acs_state = 0;
3444 u16 scan_ch_ms= 0, acs_scan_ch_ms = 0;
3445 u8 scan_type = SCAN_ACTIVE, igi= 0, bw = 0;
3446 u8 acs_scan_type = SCAN_ACTIVE, acs_igi= 0, acs_bw = 0;
3447
3448 if (count < 1)
3449 return -EFAULT;
3450
3451 if (count > sizeof(tmp)) {
3452 rtw_warn_on(1);
3453 return -EFAULT;
3454 }
3455 if (buffer && !copy_from_user(tmp, buffer, count)) {
3456
3457 int num = sscanf(tmp, "%hhu %hhu %hu %hhx %hhu",
3458 &acs_state, &scan_type, &scan_ch_ms, &igi, &bw);
3459
3460 if (num < 1)
3461 return -EINVAL;
3462
3463 if (acs_state)
3464 rtw_acs_start(padapter);
3465 else
3466 rtw_acs_stop(padapter);
3467 num = num -1;
3468
3469 if(num) {
3470 if (num-- > 0)
3471 acs_scan_type = scan_type;
3472 if (num-- > 0)
3473 acs_scan_ch_ms = scan_ch_ms;
3474 if (num-- > 0)
3475 acs_igi = igi;
3476 if (num-- > 0)
3477 acs_bw = bw;
3478 rtw_acs_adv_setting(padapter, acs_scan_type, acs_scan_ch_ms, acs_igi, acs_bw);
3479 }
3480 }
3481 #endif /*CONFIG_RTW_ACS_DBG*/
3482 return count;
3483 }
3484 #endif /* WKARD_ACS */
3485 #endif /*CONFIG_RTW_ACS*/
3486
proc_get_env_rpt(struct seq_file * m,void * v)3487 static int proc_get_env_rpt(struct seq_file *m, void *v)
3488 {
3489 struct net_device *dev = m->private;
3490 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3491
3492 rtw_dump_env_rpt(adapter, m);
3493
3494 return 0;
3495 }
3496
proc_get_hal_spec(struct seq_file * m,void * v)3497 static int proc_get_hal_spec(struct seq_file *m, void *v)
3498 {
3499 struct net_device *dev = m->private;
3500 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3501
3502 rtw_hw_dump_hal_spec(m, adapter_to_dvobj(adapter));
3503 return 0;
3504 }
3505
proc_get_hal_trx_mode(struct seq_file * m,void * v)3506 static int proc_get_hal_trx_mode(struct seq_file *m, void *v)
3507 {
3508 struct net_device *dev = m->private;
3509 _adapter *adapter = rtw_netdev_priv(dev);
3510
3511 rtw_hal_dump_trx_mode(m, adapter);
3512 return 0;
3513 }
3514
proc_get_phy_cap(struct seq_file * m,void * v)3515 static int proc_get_phy_cap(struct seq_file *m, void *v)
3516 {
3517 struct net_device *dev = m->private;
3518 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3519
3520 #ifdef CONFIG_80211N_HT
3521 rtw_dump_drv_phy_cap(m, adapter);
3522 rtw_get_dft_phy_cap(m, adapter);
3523 #endif /* CONFIG_80211N_HT */
3524 return 0;
3525 }
3526
proc_dump_rsvd_page(struct seq_file * m,void * v)3527 static int proc_dump_rsvd_page(struct seq_file *m, void *v)
3528 {
3529 struct net_device *dev = m->private;
3530 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3531
3532 rtw_hal_dump_rsvd_page(m, adapter, adapter->rsvd_page_offset, adapter->rsvd_page_num);
3533 return 0;
3534 }
proc_set_rsvd_page_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3535 static ssize_t proc_set_rsvd_page_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3536 {
3537 struct net_device *dev = data;
3538 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3539 char tmp[32];
3540 u8 page_offset, page_num;
3541
3542 if (count < 2)
3543 return -EFAULT;
3544
3545 if (count > sizeof(tmp)) {
3546 rtw_warn_on(1);
3547 return -EFAULT;
3548 }
3549 if (buffer && !copy_from_user(tmp, buffer, count)) {
3550
3551 int num = sscanf(tmp, "%hhu %hhu", &page_offset, &page_num);
3552
3553 if (num < 2)
3554 return -EINVAL;
3555 padapter->rsvd_page_offset = page_offset;
3556 padapter->rsvd_page_num = page_num;
3557 }
3558 return count;
3559 }
3560
3561 #ifdef CONFIG_SUPPORT_FIFO_DUMP
proc_dump_fifo(struct seq_file * m,void * v)3562 static int proc_dump_fifo(struct seq_file *m, void *v)
3563 {
3564 struct net_device *dev = m->private;
3565 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3566
3567 rtw_dump_fifo(m, adapter, adapter->fifo_sel, adapter->fifo_addr, adapter->fifo_size);
3568 return 0;
3569 }
proc_set_fifo_info(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3570 static ssize_t proc_set_fifo_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3571 {
3572 struct net_device *dev = data;
3573 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3574 char tmp[32];
3575 u8 fifo_sel = 0;
3576 u32 fifo_addr = 0;
3577 u32 fifo_size = 0;
3578
3579 if (count < 3)
3580 return -EFAULT;
3581
3582 if (count > sizeof(tmp)) {
3583 rtw_warn_on(1);
3584 return -EFAULT;
3585 }
3586 if (buffer && !copy_from_user(tmp, buffer, count)) {
3587
3588 int num = sscanf(tmp, "%hhu %x %d", &fifo_sel, &fifo_addr, &fifo_size);
3589
3590 if (num < 3)
3591 return -EINVAL;
3592
3593 padapter->fifo_sel = fifo_sel;
3594 padapter->fifo_addr = fifo_addr;
3595 padapter->fifo_size = fifo_size;
3596 }
3597 return count;
3598 }
3599 #endif
3600
3601
3602 #ifdef CONFIG_WOWLAN
proc_dump_pattern_cam(struct seq_file * m,void * v)3603 int proc_dump_pattern_cam(struct seq_file *m, void *v)
3604 {
3605 struct net_device *dev = m->private;
3606 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3607 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
3608 int i;
3609 #if 0 /* WOW_ToDo */
3610 struct rtl_wow_pattern context;
3611
3612 for (i = 0 ; i < pwrpriv->wowlan_pattern_idx; i++) {
3613 rtw_wow_pattern_read_cam_ent(padapter, i, &context);
3614 rtw_dump_wow_pattern(m, &context, i);
3615 }
3616 #endif
3617 return 0;
3618 }
3619 #endif
3620
3621
proc_get_napi_info(struct seq_file * m,void * v)3622 static int proc_get_napi_info(struct seq_file *m, void *v)
3623 {
3624 struct net_device *dev = m->private;
3625 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3626 struct registry_priv *pregistrypriv = &adapter->registrypriv;
3627 u8 napi = 0, gro = 0;
3628 u32 weight = 0;
3629 struct dvobj_priv *d;
3630 d = adapter_to_dvobj(adapter);
3631
3632
3633 #ifdef CONFIG_RTW_NAPI
3634 if (pregistrypriv->en_napi) {
3635 napi = 1;
3636 weight = RTL_NAPI_WEIGHT;
3637 }
3638
3639 #ifdef CONFIG_RTW_GRO
3640 if (pregistrypriv->en_gro)
3641 gro = 1;
3642 #endif /* CONFIG_RTW_GRO */
3643 #endif /* CONFIG_RTW_NAPI */
3644
3645 if (napi) {
3646 RTW_PRINT_SEL(m, "NAPI enable, weight=%d\n", weight);
3647 #ifdef CONFIG_RTW_NAPI_DYNAMIC
3648 RTW_PRINT_SEL(m, "Dynamaic NAPI mechanism is on, current NAPI %s\n",
3649 d->en_napi_dynamic ? "enable" : "disable");
3650 RTW_PRINT_SEL(m, "Dynamaic NAPI info:\n"
3651 "\ttcp_rx_threshold = %d Mbps\n"
3652 "\tcur_rx_tp = %d Mbps\n",
3653 pregistrypriv->napi_threshold,
3654 d->traffic_stat.cur_rx_tp);
3655 #endif /* CONFIG_RTW_NAPI_DYNAMIC */
3656 } else {
3657 RTW_PRINT_SEL(m, "NAPI disable\n");
3658 }
3659 RTW_PRINT_SEL(m, "GRO %s\n", gro?"enable":"disable");
3660
3661 return 0;
3662
3663 }
3664
3665 #ifdef CONFIG_RTW_NAPI_DYNAMIC
proc_set_napi_th(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3666 static ssize_t proc_set_napi_th(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3667 {
3668 struct net_device *dev = data;
3669 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3670 struct registry_priv *registry = &adapter->registrypriv;
3671 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
3672 _adapter *iface = NULL;
3673 char tmp[32] = {0};
3674 int thrshld = 0;
3675 int num = 0, i = 0;
3676
3677
3678 if (count < 1)
3679 return -EFAULT;
3680
3681 if (count > sizeof(tmp)) {
3682 rtw_warn_on(1);
3683 return -EFAULT;
3684 }
3685
3686 RTW_INFO("%s: Last threshold = %d Mbps\n", __FUNCTION__, registry->napi_threshold);
3687
3688
3689 for (i = 0; i < dvobj->iface_nums; i++) {
3690 iface = dvobj->padapters[i];
3691 if (iface) {
3692 if (buffer && !copy_from_user(tmp, buffer, count)) {
3693 registry = &iface->registrypriv;
3694 num = sscanf(tmp, "%d", &thrshld);
3695 if (num > 0) {
3696 if (thrshld > 0)
3697 registry->napi_threshold = thrshld;
3698 }
3699 }
3700 }
3701 }
3702 RTW_INFO("%s: New threshold = %d Mbps\n", __FUNCTION__, registry->napi_threshold);
3703 RTW_INFO("%s: Current RX throughput = %d Mbps\n",
3704 __FUNCTION__, adapter_to_dvobj(adapter)->traffic_stat.cur_rx_tp);
3705
3706 return count;
3707 }
3708 #endif /* CONFIG_RTW_NAPI_DYNAMIC */
3709
3710
proc_set_dynamic_agg_enable(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3711 ssize_t proc_set_dynamic_agg_enable(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3712 {
3713 struct net_device *dev = data;
3714 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
3715 char tmp[32];
3716 int enable = 0, i = 0;
3717
3718 if (count > sizeof(tmp)) {
3719 rtw_warn_on(1);
3720 return -EFAULT;
3721 }
3722
3723 if (buffer && !copy_from_user(tmp, buffer, count)) {
3724
3725 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3726 _adapter *iface = NULL;
3727 int num = sscanf(tmp, "%d", &enable);
3728
3729 if (num != 1) {
3730 RTW_INFO("invalid parameter!\n");
3731 return count;
3732 }
3733
3734 RTW_INFO("dynamic_agg_enable:%d\n", enable);
3735
3736 for (i = 0; i < dvobj->iface_nums; i++) {
3737 iface = dvobj->padapters[i];
3738 if (iface)
3739 iface->registrypriv.dynamic_agg_enable = enable;
3740 }
3741
3742 }
3743
3744 return count;
3745
3746 }
3747
proc_get_dynamic_agg_enable(struct seq_file * m,void * v)3748 static int proc_get_dynamic_agg_enable(struct seq_file *m, void *v)
3749 {
3750 struct net_device *dev = m->private;
3751 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
3752 struct registry_priv *pregistrypriv = &adapter->registrypriv;
3753
3754 RTW_PRINT_SEL(m, "dynamic_agg_enable:%d\n", pregistrypriv->dynamic_agg_enable);
3755
3756 return 0;
3757 }
3758
3759 #ifdef CONFIG_RTW_WDS
proc_get_wds_en(struct seq_file * m,void * v)3760 static int proc_get_wds_en(struct seq_file *m, void *v)
3761 {
3762 struct net_device *dev = m->private;
3763 _adapter *adapter = rtw_netdev_priv(dev);
3764
3765 if (MLME_STATE(adapter) & (WIFI_AP_STATE | WIFI_STATION_STATE))
3766 RTW_PRINT_SEL(m, "%d\n", adapter_use_wds(adapter));
3767
3768 return 0;
3769 }
3770
proc_set_wds_en(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3771 static ssize_t proc_set_wds_en(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3772 {
3773 struct net_device *dev = data;
3774 _adapter *adapter = rtw_netdev_priv(dev);
3775 char tmp[32];
3776
3777 if (!(MLME_STATE(adapter) & (WIFI_AP_STATE | WIFI_STATION_STATE)))
3778 return -EFAULT;
3779
3780 if (count < 1)
3781 return -EFAULT;
3782
3783 if (count > sizeof(tmp)) {
3784 rtw_warn_on(1);
3785 return -EFAULT;
3786 }
3787
3788 if (buffer && !copy_from_user(tmp, buffer, count)) {
3789 u8 enable;
3790 int num = sscanf(tmp, "%hhu", &enable);
3791
3792 if (num >= 1)
3793 adapter_set_use_wds(adapter, enable);
3794 }
3795
3796 return count;
3797 }
3798
proc_set_sta_wds_en(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3799 static ssize_t proc_set_sta_wds_en(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3800 {
3801 struct net_device *dev = data;
3802 _adapter *adapter = rtw_netdev_priv(dev);
3803 char tmp[32];
3804
3805 if (count < 1)
3806 return -EFAULT;
3807
3808 if (count > sizeof(tmp)) {
3809 rtw_warn_on(1);
3810 return -EFAULT;
3811 }
3812
3813 if (buffer && !copy_from_user(tmp, buffer, count)) {
3814 u8 enable;
3815 u8 addr[ETH_ALEN];
3816 struct sta_info *sta;
3817 int num = sscanf(tmp, "%hhu "MAC_SFMT, &enable, MAC_SARG(addr));
3818
3819 if (num != 7)
3820 return -EINVAL;
3821
3822 if (IS_MCAST(addr) || _rtw_memcmp(adapter_mac_addr(adapter), addr, ETH_ALEN))
3823 return -EINVAL;
3824
3825 sta = rtw_get_stainfo(&adapter->stapriv, addr);
3826 if (!sta)
3827 return -EINVAL;
3828
3829 if (enable)
3830 sta->flags |= WLAN_STA_WDS;
3831 else
3832 sta->flags &= ~WLAN_STA_WDS;
3833 }
3834
3835 return count;
3836 }
3837
proc_get_wds_gptr(struct seq_file * m,void * v)3838 static int proc_get_wds_gptr(struct seq_file *m, void *v)
3839 {
3840 struct net_device *dev = m->private;
3841 _adapter *adapter = rtw_netdev_priv(dev);
3842
3843 if (MLME_IS_STA(adapter) && MLME_IS_ASOC(adapter))
3844 dump_wgptr(m, adapter);
3845
3846 return 0;
3847 }
3848
3849 #ifdef CONFIG_AP_MODE
proc_get_wds_path(struct seq_file * m,void * v)3850 static int proc_get_wds_path(struct seq_file *m, void *v)
3851 {
3852 struct net_device *dev = m->private;
3853 _adapter *adapter = rtw_netdev_priv(dev);
3854
3855 if (MLME_IS_AP(adapter) && MLME_IS_ASOC(adapter))
3856 dump_wpath(m, adapter);
3857
3858 return 0;
3859 }
3860 #endif /* CONFIG_AP_MODE */
3861 #endif /* CONFIG_RTW_WDS */
3862
3863 #ifdef CONFIG_RTW_MULTI_AP
proc_get_multi_ap_opmode(struct seq_file * m,void * v)3864 static int proc_get_multi_ap_opmode(struct seq_file *m, void *v)
3865 {
3866 struct net_device *dev = m->private;
3867 _adapter *adapter = rtw_netdev_priv(dev);
3868
3869 if (MLME_STATE(adapter) & (WIFI_AP_STATE | WIFI_STATION_STATE))
3870 RTW_PRINT_SEL(m, "0x%02x\n", adapter->multi_ap);
3871
3872 return 0;
3873 }
3874
proc_set_multi_ap_opmode(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3875 static ssize_t proc_set_multi_ap_opmode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3876 {
3877 struct net_device *dev = data;
3878 _adapter *adapter = rtw_netdev_priv(dev);
3879 char tmp[32];
3880
3881 if (!(MLME_STATE(adapter) & (WIFI_AP_STATE | WIFI_STATION_STATE)))
3882 return -EFAULT;
3883
3884 if (count < 1)
3885 return -EFAULT;
3886
3887 if (count > sizeof(tmp)) {
3888 rtw_warn_on(1);
3889 return -EFAULT;
3890 }
3891
3892 if (buffer && !copy_from_user(tmp, buffer, count)) {
3893 u8 mode;
3894 int num = sscanf(tmp, "%hhx", &mode);
3895
3896 if (num >= 1) {
3897 if (MLME_IS_AP(adapter))
3898 adapter->multi_ap = mode & (MULTI_AP_FRONTHAUL_BSS | MULTI_AP_BACKHAUL_BSS);
3899 else
3900 adapter->multi_ap = mode & MULTI_AP_BACKHAUL_STA;
3901 if (adapter->multi_ap & (MULTI_AP_BACKHAUL_BSS | MULTI_AP_BACKHAUL_STA))
3902 adapter_set_use_wds(adapter, 1);
3903 }
3904 }
3905
3906 return count;
3907 }
3908
proc_get_unassoc_sta(struct seq_file * m,void * v)3909 static int proc_get_unassoc_sta(struct seq_file *m, void *v)
3910 {
3911 struct net_device *dev = m->private;
3912 _adapter *adapter = GET_PRIMARY_ADAPTER(rtw_netdev_priv(dev));
3913
3914 dump_unassoc_sta(m, adapter);
3915 return 0;
3916 }
3917
proc_set_unassoc_sta(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)3918 ssize_t proc_set_unassoc_sta(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
3919 {
3920 struct net_device *dev = data;
3921 _adapter *adapter = GET_PRIMARY_ADAPTER(rtw_netdev_priv(dev));
3922 char tmp[17 * 10 + 32] = {0};
3923 char cmd[32];
3924 u8 mode;
3925 u8 stype = 0;
3926 u8 addr[ETH_ALEN];
3927
3928 #define UNASOC_STA_CMD_MODE 0
3929 #define UNASOC_STA_CMD_ADD 1
3930 #define UNASOC_STA_CMD_DEL 2
3931 #define UNASOC_STA_CMD_CLR 3
3932 #define UNASOC_STA_CMD_UNINT 4
3933 #define UNASOC_STA_CMD_NUM 5
3934
3935 static const char * const unasoc_sta_cmd_str[] = {
3936 "mode",
3937 "add",
3938 "del",
3939 "clr",
3940 "uninterest",
3941 };
3942 u8 cmd_id = UNASOC_STA_CMD_NUM;
3943
3944 if (count < 1)
3945 return -EFAULT;
3946
3947 if (count > sizeof(tmp)) {
3948 RTW_WARN(FUNC_ADPT_FMT" input string too long\n", FUNC_ADPT_ARG(adapter));
3949 rtw_warn_on(1);
3950 return -EFAULT;
3951 }
3952
3953 if (buffer && !copy_from_user(tmp, buffer, count)) {
3954 /*
3955 * mode <stype>,<mode>
3956 * add <macaddr> [<macaddr>]
3957 * del <macaddr> [<macaddr>]
3958 * clr
3959 */
3960 char *c, *next;
3961 int i;
3962 u8 is_bcast;
3963
3964 next = tmp;
3965 c = strsep(&next, " \t");
3966 if (!c || sscanf(c, "%s", cmd) != 1)
3967 goto exit;
3968
3969 for (i = 0; i < UNASOC_STA_CMD_NUM; i++)
3970 if (strcmp(unasoc_sta_cmd_str[i], cmd) == 0)
3971 cmd_id = i;
3972
3973 switch (cmd_id) {
3974 case UNASOC_STA_CMD_MODE:
3975 c = strsep(&next, " \t");
3976 if (!c || sscanf(c, "%hhu,%hhu", &stype, &mode) != 2) {
3977 RTW_WARN(FUNC_ADPT_FMT" invalid arguments of mode cmd\n", FUNC_ADPT_ARG(adapter));
3978 goto exit;
3979 }
3980
3981 if (stype >= UNASOC_STA_SRC_NUM) {
3982 RTW_WARN(FUNC_ADPT_FMT" invalid stype:%u\n", FUNC_ADPT_ARG(adapter), stype);
3983 goto exit;
3984 }
3985
3986 if (mode >= UNASOC_STA_MODE_NUM) {
3987 RTW_WARN(FUNC_ADPT_FMT" invalid mode:%u\n", FUNC_ADPT_ARG(adapter), mode);
3988 goto exit;
3989 }
3990
3991 rtw_unassoc_sta_set_mode(adapter, stype, mode);
3992 break;
3993
3994 case UNASOC_STA_CMD_ADD:
3995 case UNASOC_STA_CMD_DEL:
3996 case UNASOC_STA_CMD_UNINT:
3997 /* check for macaddr list */
3998 c = strsep(&next, " \t");
3999 while (c != NULL) {
4000 if (sscanf(c, MAC_SFMT, MAC_SARG(addr)) != 6)
4001 break;
4002
4003 is_bcast = is_broadcast_mac_addr(addr);
4004 if (is_bcast
4005 || rtw_check_invalid_mac_address(addr, 0) == _FALSE
4006 ) {
4007 if (cmd_id == UNASOC_STA_CMD_DEL) {
4008 if (is_bcast) {
4009 rtw_del_unassoc_sta_queue(adapter);
4010 break;
4011 } else
4012 rtw_del_unassoc_sta(adapter, addr);
4013 } else if (cmd_id == UNASOC_STA_CMD_UNINT) {
4014 if (is_bcast) {
4015 rtw_undo_all_interested_unassoc_sta(adapter);
4016 break;
4017 } else
4018 rtw_undo_interested_unassoc_sta(adapter, addr);
4019 } else if (!is_bcast)
4020 rtw_add_interested_unassoc_sta(adapter, addr);
4021 }
4022
4023 c = strsep(&next, " \t");
4024 }
4025 break;
4026
4027 case UNASOC_STA_CMD_CLR:
4028 /* clear sta list */
4029 rtw_del_unassoc_sta_queue(adapter);
4030 goto exit;
4031
4032 default:
4033 RTW_WARN(FUNC_ADPT_FMT" invalid cmd:\"%s\"\n", FUNC_ADPT_ARG(adapter), cmd);
4034 goto exit;
4035 }
4036 }
4037
4038 exit:
4039 return count;
4040 }
4041
4042 #ifdef CONFIG_IOCTL_CFG80211
4043 static u8 assoc_req_mac_addr[6];
proc_get_sta_assoc_req_frame_body(struct seq_file * m,void * v)4044 int proc_get_sta_assoc_req_frame_body(struct seq_file *m, void *v)
4045 {
4046 struct net_device *dev = m->private;
4047 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4048
4049 if (MLME_IS_AP(adapter)) {
4050 struct sta_info *psta;
4051 u8 *passoc_req = NULL;
4052 u32 assoc_req_len = 0;
4053
4054 psta = rtw_get_stainfo(&adapter->stapriv, assoc_req_mac_addr);
4055 if (psta == NULL) {
4056 RTW_PRINT(FUNC_ADPT_FMT" sta("MAC_FMT") not found\n",
4057 FUNC_ADPT_ARG(adapter), MAC_ARG(assoc_req_mac_addr));
4058 return 0;
4059 }
4060
4061 RTW_PRINT(FUNC_ADPT_FMT" sta("MAC_FMT") found\n",
4062 FUNC_ADPT_ARG(adapter), MAC_ARG(assoc_req_mac_addr));
4063 _rtw_spinlock_bh(&psta->lock);
4064 if (psta->passoc_req && psta->assoc_req_len > 0) {
4065 passoc_req = rtw_zmalloc(psta->assoc_req_len);
4066 if (passoc_req) {
4067 assoc_req_len = psta->assoc_req_len;
4068 _rtw_memcpy(passoc_req, psta->passoc_req, assoc_req_len);
4069 }
4070 }
4071
4072 _rtw_spinunlock_bh(&psta->lock);
4073 if (passoc_req && assoc_req_len > IEEE80211_3ADDR_LEN) {
4074 u8 *body = passoc_req + IEEE80211_3ADDR_LEN;
4075 u32 body_len = assoc_req_len - IEEE80211_3ADDR_LEN;
4076 u16 i;
4077
4078 for (i = 0; i < body_len; i++)
4079 _RTW_PRINT_SEL(m, "%02X", body[i]);
4080 _RTW_PRINT_SEL(m, "\n");
4081 }
4082
4083 if (passoc_req && assoc_req_len > 0)
4084 rtw_mfree(passoc_req, assoc_req_len);
4085 }
4086
4087 return 0;
4088 }
4089
proc_set_sta_assoc_req_frame_body(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4090 ssize_t proc_set_sta_assoc_req_frame_body(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4091 {
4092 struct net_device *dev = data;
4093 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4094 char tmp[18] = {0};
4095
4096 if (count < 1)
4097 return -EFAULT;
4098
4099 if (count > sizeof(tmp)) {
4100 rtw_warn_on(1);
4101 return -EFAULT;
4102 }
4103
4104 if (buffer && !copy_from_user(tmp, buffer, count)) {
4105 if (sscanf(tmp, MAC_SFMT, MAC_SARG(assoc_req_mac_addr)) != 6) {
4106 _rtw_memset(assoc_req_mac_addr, 0, 6);
4107 RTW_PRINT(FUNC_ADPT_FMT" Invalid format\n",
4108 FUNC_ADPT_ARG(adapter));
4109 }
4110
4111 }
4112
4113 return count;
4114 }
4115 #endif /* CONFIG_IOCTL_CFG80211 */
4116
proc_get_ch_util_threshold(struct seq_file * m,void * v)4117 static int proc_get_ch_util_threshold(struct seq_file *m, void *v)
4118 {
4119 struct net_device *dev = m->private;
4120 _adapter *adapter = GET_PRIMARY_ADAPTER(rtw_netdev_priv(dev));
4121
4122 RTW_PRINT_SEL(m, "%hhu\n", adapter->ch_util_threshold);
4123
4124 return 0;
4125 }
4126
proc_set_ch_util_threshold(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4127 static ssize_t proc_set_ch_util_threshold(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4128 {
4129 struct net_device *dev = data;
4130 _adapter *adapter = GET_PRIMARY_ADAPTER(rtw_netdev_priv(dev));
4131 char tmp[4];
4132
4133 if (count < 1)
4134 return -EFAULT;
4135
4136 if (count > sizeof(tmp)) {
4137 rtw_warn_on(1);
4138 return -EFAULT;
4139 }
4140
4141 if (buffer && !copy_from_user(tmp, buffer, count)) {
4142 u8 threshold;
4143 int num = sscanf(tmp, "%hhu", &threshold);
4144
4145 if (num == 1)
4146 adapter->ch_util_threshold = threshold;
4147 }
4148
4149 return count;
4150 }
4151
proc_get_ch_utilization(struct seq_file * m,void * v)4152 static int proc_get_ch_utilization(struct seq_file *m, void *v)
4153 {
4154 struct net_device *dev = m->private;
4155 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4156
4157 RTW_PRINT_SEL(m, "%hhu\n", rtw_get_ch_utilization(adapter));
4158
4159 return 0;
4160 }
4161 #endif /* CONFIG_RTW_MULTI_AP */
4162
4163 #ifdef CONFIG_RTW_MESH
proc_get_mesh_peer_sel_policy(struct seq_file * m,void * v)4164 static int proc_get_mesh_peer_sel_policy(struct seq_file *m, void *v)
4165 {
4166 struct net_device *dev = m->private;
4167 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4168
4169 dump_mesh_peer_sel_policy(m, adapter);
4170
4171 return 0;
4172 }
4173
4174 #if CONFIG_RTW_MESH_ACNODE_PREVENT
proc_get_mesh_acnode_prevent(struct seq_file * m,void * v)4175 static int proc_get_mesh_acnode_prevent(struct seq_file *m, void *v)
4176 {
4177 struct net_device *dev = m->private;
4178 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4179
4180 if (MLME_IS_MESH(adapter))
4181 dump_mesh_acnode_prevent_settings(m, adapter);
4182
4183 return 0;
4184 }
4185
proc_set_mesh_acnode_prevent(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4186 static ssize_t proc_set_mesh_acnode_prevent(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4187 {
4188 struct net_device *dev = data;
4189 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4190 char tmp[32];
4191
4192 if (count < 1)
4193 return -EFAULT;
4194
4195 if (count > sizeof(tmp)) {
4196 rtw_warn_on(1);
4197 return -EFAULT;
4198 }
4199
4200 if (buffer && !copy_from_user(tmp, buffer, count)) {
4201 struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
4202 u8 enable;
4203 u32 conf_timeout_ms;
4204 u32 notify_timeout_ms;
4205 int num = sscanf(tmp, "%hhu %u %u", &enable, &conf_timeout_ms, ¬ify_timeout_ms);
4206
4207 if (num >= 1)
4208 peer_sel_policy->acnode_prevent = enable;
4209 if (num >= 2)
4210 peer_sel_policy->acnode_conf_timeout_ms = conf_timeout_ms;
4211 if (num >= 3)
4212 peer_sel_policy->acnode_notify_timeout_ms = notify_timeout_ms;
4213 }
4214
4215 return count;
4216 }
4217 #endif /* CONFIG_RTW_MESH_ACNODE_PREVENT */
4218
4219 #if CONFIG_RTW_MESH_OFFCH_CAND
proc_get_mesh_offch_cand(struct seq_file * m,void * v)4220 static int proc_get_mesh_offch_cand(struct seq_file *m, void *v)
4221 {
4222 struct net_device *dev = m->private;
4223 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4224
4225 if (MLME_IS_MESH(adapter))
4226 dump_mesh_offch_cand_settings(m, adapter);
4227
4228 return 0;
4229 }
4230
proc_set_mesh_offch_cand(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4231 static ssize_t proc_set_mesh_offch_cand(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4232 {
4233 struct net_device *dev = data;
4234 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4235 char tmp[32];
4236
4237 if (count < 1)
4238 return -EFAULT;
4239
4240 if (count > sizeof(tmp)) {
4241 rtw_warn_on(1);
4242 return -EFAULT;
4243 }
4244
4245 if (buffer && !copy_from_user(tmp, buffer, count)) {
4246 struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
4247 u8 enable;
4248 u32 find_int_ms;
4249 int num = sscanf(tmp, "%hhu %u", &enable, &find_int_ms);
4250
4251 if (num >= 1)
4252 peer_sel_policy->offch_cand = enable;
4253 if (num >= 2)
4254 peer_sel_policy->offch_find_int_ms = find_int_ms;
4255 }
4256
4257 return count;
4258 }
4259 #endif /* CONFIG_RTW_MESH_OFFCH_CAND */
4260
4261 #if CONFIG_RTW_MESH_PEER_BLACKLIST
proc_get_mesh_peer_blacklist(struct seq_file * m,void * v)4262 static int proc_get_mesh_peer_blacklist(struct seq_file *m, void *v)
4263 {
4264 struct net_device *dev = m->private;
4265 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4266
4267 if (MLME_IS_MESH(adapter)) {
4268 dump_mesh_peer_blacklist_settings(m, adapter);
4269 if (MLME_IS_ASOC(adapter))
4270 dump_mesh_peer_blacklist(m, adapter);
4271 }
4272
4273 return 0;
4274 }
4275
proc_set_mesh_peer_blacklist(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4276 static ssize_t proc_set_mesh_peer_blacklist(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4277 {
4278 struct net_device *dev = data;
4279 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4280 char tmp[32];
4281
4282 if (count < 1)
4283 return -EFAULT;
4284
4285 if (count > sizeof(tmp)) {
4286 rtw_warn_on(1);
4287 return -EFAULT;
4288 }
4289
4290 if (buffer && !copy_from_user(tmp, buffer, count)) {
4291 struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
4292 u32 conf_timeout_ms;
4293 u32 blacklist_timeout_ms;
4294 int num = sscanf(tmp, "%u %u", &conf_timeout_ms, &blacklist_timeout_ms);
4295
4296 if (num >= 1)
4297 peer_sel_policy->peer_conf_timeout_ms = conf_timeout_ms;
4298 if (num >= 2)
4299 peer_sel_policy->peer_blacklist_timeout_ms = blacklist_timeout_ms;
4300 }
4301
4302 return count;
4303 }
4304 #endif /* CONFIG_RTW_MESH_PEER_BLACKLIST */
4305
4306 #if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
proc_get_mesh_cto_mgate_require(struct seq_file * m,void * v)4307 static int proc_get_mesh_cto_mgate_require(struct seq_file *m, void *v)
4308 {
4309 struct net_device *dev = m->private;
4310 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4311
4312 if (MLME_IS_MESH(adapter))
4313 RTW_PRINT_SEL(m, "%u\n", adapter->mesh_cfg.peer_sel_policy.cto_mgate_require);
4314
4315 return 0;
4316 }
4317
proc_set_mesh_cto_mgate_require(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4318 static ssize_t proc_set_mesh_cto_mgate_require(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4319 {
4320 struct net_device *dev = data;
4321 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4322 char tmp[32];
4323
4324 if (count < 1)
4325 return -EFAULT;
4326
4327 if (count > sizeof(tmp)) {
4328 rtw_warn_on(1);
4329 return -EFAULT;
4330 }
4331
4332 if (buffer && !copy_from_user(tmp, buffer, count)) {
4333 struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
4334 u8 require;
4335 int num = sscanf(tmp, "%hhu", &require);
4336
4337 if (num >= 1) {
4338 peer_sel_policy->cto_mgate_require = require;
4339 #if CONFIG_RTW_MESH_CTO_MGATE_CARRIER
4340 if (rtw_mesh_cto_mgate_required(adapter))
4341 rtw_netif_carrier_off(adapter->pnetdev);
4342 else
4343 rtw_netif_carrier_on(adapter->pnetdev);
4344 #endif
4345 }
4346 }
4347
4348 return count;
4349 }
4350
proc_get_mesh_cto_mgate_blacklist(struct seq_file * m,void * v)4351 static int proc_get_mesh_cto_mgate_blacklist(struct seq_file *m, void *v)
4352 {
4353 struct net_device *dev = m->private;
4354 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4355
4356 if (MLME_IS_MESH(adapter)) {
4357 dump_mesh_cto_mgate_blacklist_settings(m, adapter);
4358 if (MLME_IS_ASOC(adapter))
4359 dump_mesh_cto_mgate_blacklist(m, adapter);
4360 }
4361
4362 return 0;
4363 }
4364
proc_set_mesh_cto_mgate_blacklist(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4365 static ssize_t proc_set_mesh_cto_mgate_blacklist(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4366 {
4367 struct net_device *dev = data;
4368 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4369 char tmp[32];
4370
4371 if (count < 1)
4372 return -EFAULT;
4373
4374 if (count > sizeof(tmp)) {
4375 rtw_warn_on(1);
4376 return -EFAULT;
4377 }
4378
4379 if (buffer && !copy_from_user(tmp, buffer, count)) {
4380 struct mesh_peer_sel_policy *peer_sel_policy = &adapter->mesh_cfg.peer_sel_policy;
4381 u32 conf_timeout_ms;
4382 u32 blacklist_timeout_ms;
4383 int num = sscanf(tmp, "%u %u", &conf_timeout_ms, &blacklist_timeout_ms);
4384
4385 if (num >= 1)
4386 peer_sel_policy->cto_mgate_conf_timeout_ms = conf_timeout_ms;
4387 if (num >= 2)
4388 peer_sel_policy->cto_mgate_blacklist_timeout_ms = blacklist_timeout_ms;
4389 }
4390
4391 return count;
4392 }
4393 #endif /* CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST */
4394
proc_get_mesh_networks(struct seq_file * m,void * v)4395 static int proc_get_mesh_networks(struct seq_file *m, void *v)
4396 {
4397 struct net_device *dev = m->private;
4398 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4399
4400 dump_mesh_networks(m, adapter);
4401
4402 return 0;
4403 }
4404
proc_get_mesh_plink_ctl(struct seq_file * m,void * v)4405 static int proc_get_mesh_plink_ctl(struct seq_file *m, void *v)
4406 {
4407 struct net_device *dev = m->private;
4408 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4409
4410 if (MLME_IS_MESH(adapter))
4411 dump_mesh_plink_ctl(m, adapter);
4412
4413 return 0;
4414 }
4415
proc_get_mesh_mpath(struct seq_file * m,void * v)4416 static int proc_get_mesh_mpath(struct seq_file *m, void *v)
4417 {
4418 struct net_device *dev = m->private;
4419 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4420
4421 if (MLME_IS_MESH(adapter) && MLME_IS_ASOC(adapter))
4422 dump_mpath(m, adapter);
4423
4424 return 0;
4425 }
4426
proc_get_mesh_mpp(struct seq_file * m,void * v)4427 static int proc_get_mesh_mpp(struct seq_file *m, void *v)
4428 {
4429 struct net_device *dev = m->private;
4430 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4431
4432 if (MLME_IS_MESH(adapter) && MLME_IS_ASOC(adapter))
4433 dump_mpp(m, adapter);
4434
4435 return 0;
4436 }
4437
proc_get_mesh_known_gates(struct seq_file * m,void * v)4438 static int proc_get_mesh_known_gates(struct seq_file *m, void *v)
4439 {
4440 struct net_device *dev = m->private;
4441 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4442
4443 if (MLME_IS_MESH(adapter))
4444 dump_known_gates(m, adapter);
4445
4446 return 0;
4447 }
4448
4449 #if CONFIG_RTW_MESH_DATA_BMC_TO_UC
proc_get_mesh_b2u_flags(struct seq_file * m,void * v)4450 static int proc_get_mesh_b2u_flags(struct seq_file *m, void *v)
4451 {
4452 struct net_device *dev = m->private;
4453 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4454
4455 if (MLME_IS_MESH(adapter))
4456 dump_mesh_b2u_flags(m, adapter);
4457
4458 return 0;
4459 }
4460
proc_set_mesh_b2u_flags(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4461 static ssize_t proc_set_mesh_b2u_flags(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4462 {
4463 struct net_device *dev = data;
4464 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4465 char tmp[32];
4466
4467 if (count < 1)
4468 return -EFAULT;
4469
4470 if (count > sizeof(tmp)) {
4471 rtw_warn_on(1);
4472 return -EFAULT;
4473 }
4474
4475 if (buffer && !copy_from_user(tmp, buffer, count)) {
4476 struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
4477 u8 msrc, mfwd;
4478 int num = sscanf(tmp, "%hhx %hhx", &msrc, &mfwd);
4479
4480 if (num >= 1)
4481 mcfg->b2u_flags_msrc = msrc;
4482 if (num >= 2)
4483 mcfg->b2u_flags_mfwd = mfwd;
4484 }
4485
4486 return count;
4487 }
4488 #endif /* CONFIG_RTW_MESH_DATA_BMC_TO_UC */
4489
proc_get_mesh_stats(struct seq_file * m,void * v)4490 static int proc_get_mesh_stats(struct seq_file *m, void *v)
4491 {
4492 struct net_device *dev = m->private;
4493 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4494
4495 if (MLME_IS_MESH(adapter))
4496 dump_mesh_stats(m, adapter);
4497
4498 return 0;
4499 }
4500
proc_get_mesh_gate_timeout(struct seq_file * m,void * v)4501 static int proc_get_mesh_gate_timeout(struct seq_file *m, void *v)
4502 {
4503 struct net_device *dev = m->private;
4504 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4505
4506 if (MLME_IS_MESH(adapter))
4507 RTW_PRINT_SEL(m, "%u factor\n",
4508 adapter->mesh_cfg.path_gate_timeout_factor);
4509
4510 return 0;
4511 }
4512
proc_set_mesh_gate_timeout(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4513 static ssize_t proc_set_mesh_gate_timeout(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4514 {
4515 struct net_device *dev = data;
4516 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4517 char tmp[32];
4518
4519 if (count < 1)
4520 return -EFAULT;
4521
4522 if (count > sizeof(tmp)) {
4523 rtw_warn_on(1);
4524 return -EFAULT;
4525 }
4526
4527 if (buffer && !copy_from_user(tmp, buffer, count)) {
4528 struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
4529 u32 timeout;
4530 int num = sscanf(tmp, "%u", &timeout);
4531
4532 if (num < 1)
4533 goto exit;
4534
4535 mcfg->path_gate_timeout_factor = timeout;
4536 }
4537
4538 exit:
4539 return count;
4540 }
4541
proc_get_mesh_gate_state(struct seq_file * m,void * v)4542 static int proc_get_mesh_gate_state(struct seq_file *m, void *v)
4543 {
4544 struct net_device *dev = m->private;
4545 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4546 struct rtw_mesh_cfg *mcfg = &adapter->mesh_cfg;
4547 u8 cto_mgate = 0;
4548
4549 if (MLME_IS_MESH(adapter)) {
4550 if (rtw_mesh_is_primary_gate(adapter))
4551 RTW_PRINT_SEL(m, "PG\n");
4552 else if (mcfg->dot11MeshGateAnnouncementProtocol)
4553 RTW_PRINT_SEL(m, "G\n");
4554 else if (rtw_mesh_gate_num(adapter))
4555 RTW_PRINT_SEL(m, "C\n");
4556 else
4557 RTW_PRINT_SEL(m, "N\n");
4558 }
4559
4560 return 0;
4561 }
4562
proc_get_peer_alive_based_preq(struct seq_file * m,void * v)4563 static int proc_get_peer_alive_based_preq(struct seq_file *m, void *v)
4564 {
4565 struct net_device *dev = m->private;
4566 _adapter *adapter= (_adapter *)rtw_netdev_priv(dev);
4567 struct registry_priv *rp = &adapter->registrypriv;
4568
4569 RTW_PRINT_SEL(m, "peer_alive_based_preq = %u\n",
4570 rp->peer_alive_based_preq);
4571
4572 return 0;
4573 }
4574
4575 static ssize_t
proc_set_peer_alive_based_preq(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4576 proc_set_peer_alive_based_preq(struct file *file, const char __user *buffer,
4577 size_t count, loff_t *pos, void *data)
4578 {
4579 struct net_device *dev = data;
4580 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4581 struct registry_priv *rp = &adapter->registrypriv;
4582 char tmp[8];
4583 int num = 0;
4584 u8 enable = 0;
4585
4586 if (count > sizeof(tmp)) {
4587 rtw_warn_on(1);
4588 return -EFAULT;
4589 }
4590
4591 if (!buffer || copy_from_user(tmp, buffer, count))
4592 goto exit;
4593
4594 num = sscanf(tmp, "%hhu", &enable);
4595 if (num != 1) {
4596 RTW_ERR("%s: invalid parameter!\n", __FUNCTION__);
4597 goto exit;
4598 }
4599
4600 if (enable > 1) {
4601 RTW_ERR("%s: invalid value!\n", __FUNCTION__);
4602 goto exit;
4603 }
4604 rp->peer_alive_based_preq = enable;
4605
4606 exit:
4607 return count;
4608 }
4609
4610 #endif /* CONFIG_RTW_MESH */
4611
4612 #ifdef RTW_BUSY_DENY_SCAN
proc_get_scan_interval_thr(struct seq_file * m,void * v)4613 static int proc_get_scan_interval_thr(struct seq_file *m, void *v)
4614 {
4615 struct net_device *dev = m->private;
4616 _adapter *adapter= (_adapter *)rtw_netdev_priv(dev);
4617 struct registry_priv *rp = &adapter->registrypriv;
4618
4619
4620 RTW_PRINT_SEL(m, "scan interval threshold = %u ms\n",
4621 rp->scan_interval_thr);
4622
4623 return 0;
4624 }
4625
proc_set_scan_interval_thr(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4626 static ssize_t proc_set_scan_interval_thr(struct file *file,
4627 const char __user *buffer,
4628 size_t count, loff_t *pos, void *data)
4629 {
4630 struct net_device *dev = data;
4631 _adapter *adapter= (_adapter *)rtw_netdev_priv(dev);
4632 struct registry_priv *rp = &adapter->registrypriv;
4633 char tmp[12];
4634 int num = 0;
4635 u32 thr = 0;
4636
4637
4638 if (count > sizeof(tmp)) {
4639 rtw_warn_on(1);
4640 return -EFAULT;
4641 }
4642
4643 if (!buffer || copy_from_user(tmp, buffer, count))
4644 goto exit;
4645
4646 num = sscanf(tmp, "%u", &thr);
4647 if (num != 1) {
4648 RTW_ERR("%s: invalid parameter!\n", __FUNCTION__);
4649 goto exit;
4650 }
4651
4652 rp->scan_interval_thr = thr;
4653
4654 RTW_PRINT("%s: scan interval threshold = %u ms\n",
4655 __FUNCTION__, rp->scan_interval_thr);
4656
4657 exit:
4658 return count;
4659 }
4660
4661 #endif /* RTW_BUSY_DENY_SCAN */
4662
proc_get_scan_deny(struct seq_file * m,void * v)4663 static int proc_get_scan_deny(struct seq_file *m, void *v)
4664 {
4665 struct net_device *dev = m->private;
4666 _adapter *adapter= (_adapter *)rtw_netdev_priv(dev);
4667 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
4668
4669 RTW_PRINT_SEL(m, "scan_deny is %s\n", (dvobj->scan_deny == _TRUE) ? "enable":"disable");
4670
4671 return 0;
4672 }
4673
proc_set_scan_deny(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4674 static ssize_t proc_set_scan_deny(struct file *file, const char __user *buffer,
4675 size_t count, loff_t *pos, void *data)
4676 {
4677 struct net_device *dev = data;
4678 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4679 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
4680 char tmp[8];
4681 int num = 0;
4682 int enable = 0;
4683
4684 if (count > sizeof(tmp)) {
4685 rtw_warn_on(1);
4686 return -EFAULT;
4687 }
4688
4689 if (!buffer || copy_from_user(tmp, buffer, count))
4690 goto exit;
4691
4692 num = sscanf(tmp, "%d", &enable);
4693 if (num != 1) {
4694 RTW_ERR("%s: invalid parameter!\n", __FUNCTION__);
4695 goto exit;
4696 }
4697
4698 dvobj->scan_deny = enable ? _TRUE : _FALSE;
4699
4700 RTW_PRINT("%s: scan_deny is %s\n",
4701 __FUNCTION__, (dvobj->scan_deny == _TRUE) ? "enable":"disable");
4702
4703 exit:
4704 return count;
4705 }
4706
proc_get_cur_beacon_keys(struct seq_file * m,void * v)4707 int proc_get_cur_beacon_keys(struct seq_file *m, void *v)
4708 {
4709 struct net_device *dev = m->private;
4710 _adapter *adapter = rtw_netdev_priv(dev);
4711 struct mlme_priv *mlme = &adapter->mlmepriv;
4712
4713 rtw_dump_bcn_keys(m, &mlme->cur_beacon_keys);
4714
4715 return 0;
4716 }
4717
4718 #if defined(ROKU_PRIVATE) && defined(CONFIG_P2P)
proc_get_go_hidden_ssid_mode(struct seq_file * m,void * v)4719 static int proc_get_go_hidden_ssid_mode(struct seq_file *m, void *v)
4720 {
4721 struct net_device *dev = m->private;
4722 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4723 struct registry_priv *pregpriv = &padapter->registrypriv;
4724
4725 if (pregpriv)
4726 RTW_PRINT_SEL(m, "0x%lx\n", pregpriv->go_hidden_ssid_mode);
4727
4728 return 0;
4729 }
4730
proc_set_go_hidden_ssid_mode(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4731 static ssize_t proc_set_go_hidden_ssid_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4732 {
4733
4734 struct net_device *dev = data;
4735 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4736 struct registry_priv *pregpriv = &padapter->registrypriv;
4737 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4738 char tmp[32];
4739 int go_hidden_ssid_mode, feature_bit;
4740
4741 if (!padapter)
4742 return -EFAULT;
4743
4744 if (count < 1) {
4745 RTW_INFO("argument size is less than 1\n");
4746 return -EFAULT;
4747 }
4748
4749 if (count > sizeof(tmp)) {
4750 rtw_warn_on(1);
4751 return -EFAULT;
4752 }
4753
4754 if (buffer && !copy_from_user(tmp, buffer, count)) {
4755
4756 int num = sscanf(tmp, "%d %d",&feature_bit, &go_hidden_ssid_mode);
4757
4758 if (num < 1)
4759 return -EINVAL;
4760
4761 /* Cancel hide_ssid_timer and reset flag when unhide SSID by proc */
4762 if (!feature_bit && !go_hidden_ssid_mode) {
4763 ATOMIC_SET(&pregpriv->set_hide_ssid_timer, 0);
4764 _cancel_timer_ex(&pmlmeext->hide_ssid_timer);
4765 }
4766 if (go_hidden_ssid_mode == 1)
4767 rtw_set_bit(feature_bit, &pregpriv->go_hidden_ssid_mode);
4768 else if (!go_hidden_ssid_mode)
4769 rtw_clear_bit(feature_bit, &pregpriv->go_hidden_ssid_mode);
4770 else
4771 return -EFAULT;
4772
4773 RTW_INFO("go_hidden_ssid_mode:0x%lx\n", pregpriv->go_hidden_ssid_mode);
4774 } else
4775 return -EFAULT;
4776
4777 issue_beacon(padapter, 0);
4778
4779 return count;
4780 }
4781
4782 #endif
4783
proc_get_amsdu_mode(struct seq_file * m,void * v)4784 static int proc_get_amsdu_mode(struct seq_file *m, void *v)
4785 {
4786 struct net_device *dev = m->private;
4787 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4788 struct registry_priv *pregpriv = &padapter->registrypriv;
4789
4790 if (pregpriv) {
4791 if (pregpriv->amsdu_mode == RTW_AMSDU_MODE_NON_SPP)
4792 RTW_PRINT_SEL(m, "amsdu mode: NON-SPP\n");
4793 else if (pregpriv->amsdu_mode == RTW_AMSDU_MODE_SPP)
4794 RTW_PRINT_SEL(m, "amsdu mode: SPP\n");
4795 else if (pregpriv->amsdu_mode == RTW_AMSDU_MODE_ALL_DROP)
4796 RTW_PRINT_SEL(m, "amsdu mode: ALL DROP\n");
4797 else
4798 RTW_PRINT_SEL(m, "unexpected amsdu mode\n");
4799 }
4800
4801 return 0;
4802 }
4803
proc_set_amsdu_mode(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4804 static ssize_t proc_set_amsdu_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4805 {
4806 struct net_device *dev = data;
4807 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
4808 struct registry_priv *pregpriv = &padapter->registrypriv;
4809 char tmp[32];
4810 u32 mode;
4811 u8 bw_2g;
4812 u8 bw_5g;
4813
4814 if (count < 1)
4815 return -EFAULT;
4816
4817 if (count > sizeof(tmp)) {
4818 rtw_warn_on(1);
4819 return -EFAULT;
4820 }
4821
4822 if (buffer && !copy_from_user(tmp, buffer, count)) {
4823
4824 int num = sscanf(tmp, "%d", &mode);
4825
4826 if (mode == RTW_AMSDU_MODE_NON_SPP
4827 || mode == RTW_AMSDU_MODE_SPP
4828 || mode == RTW_AMSDU_MODE_ALL_DROP) {
4829 pregpriv->amsdu_mode = mode;
4830 RTW_INFO("amsdu mode=%u\n", mode);
4831 } else {
4832 RTW_INFO("set unexpected mode = %d, won't apply\n", mode);
4833 }
4834 }
4835
4836 return count;
4837
4838 }
4839
4840 #ifdef ROKU_PRIVATE
proc_get_vendor_ie_filter(struct seq_file * m,void * v)4841 static int proc_get_vendor_ie_filter(struct seq_file *m, void *v)
4842 {
4843 struct net_device *dev = m->private;
4844 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4845 struct mlme_priv *mlmepriv = &adapter->mlmepriv;
4846 int i, j;
4847
4848 if (!mlmepriv)
4849 return -EFAULT;
4850
4851 RTW_PRINT_SEL(m, "enable: %u\n", mlmepriv->vendor_ie_filter_enable);
4852 RTW_PRINT_SEL(m, "index\tcontent\n");
4853
4854 for (i = 0; i < MAX_VENDOR_IE_NUM; i++) {
4855 RTW_PRINT_SEL(m, "%d\t", i);
4856 if (mlmepriv->vendor_ie_len[i])
4857 for (j = 0; j < mlmepriv->vendor_ie_len[i] + 2; j++)
4858 RTW_PRINT_SEL(m, "%02x", mlmepriv->vendor_ie_filter[i][j]);
4859 RTW_PRINT_SEL(m, "\n");
4860 }
4861
4862 return 0;
4863 }
4864
proc_set_vendor_ie_filter(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)4865 static ssize_t proc_set_vendor_ie_filter(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
4866 {
4867 struct net_device *dev = data;
4868 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
4869 struct mlme_priv *mlmepriv = &adapter->mlmepriv;
4870 char tmp[MAX_VENDOR_IE_PARAM_LEN];
4871 u8 vendor_ie_num = 0;
4872 u8 *vendor_ie;
4873 u8 enable;
4874 int num, i, len = 0;
4875
4876 vendor_ie = rtw_malloc(MAX_VENDOR_IE_LEN);
4877
4878 if (!vendor_ie || !adapter)
4879 return -EFAULT;
4880
4881 if (count < 1) {
4882 RTW_INFO("argument size is less than 1\n");
4883 return -EFAULT;
4884 }
4885
4886 if (count > sizeof(tmp)) {
4887 rtw_warn_on(1);
4888 return -EFAULT;
4889 }
4890
4891 if (buffer && !copy_from_user(tmp, buffer, count)) {
4892 if (count > 2) {
4893 num = sscanf(tmp, "%hhu %s", &vendor_ie_num, vendor_ie);
4894
4895 if (num < 1)
4896 return -EINVAL;
4897
4898 if (vendor_ie_num > MAX_VENDOR_IE_NUM - 1)
4899 return -EINVAL;
4900
4901 if (_rtw_memcmp(vendor_ie, "0", 1)) {
4902 _rtw_memset(mlmepriv->vendor_ie_filter[vendor_ie_num] , 0 , MAX_VENDOR_IE_LEN);
4903 mlmepriv->vendor_ie_len[vendor_ie_num] = 0;
4904 }
4905
4906 for (i = 0; i < strlen(vendor_ie); i += 2) {
4907 mlmepriv->vendor_ie_filter[vendor_ie_num][len] = key_2char2num(vendor_ie[i], vendor_ie[i+1]);
4908 if (len == 1)
4909 mlmepriv->vendor_ie_len[vendor_ie_num] = mlmepriv->vendor_ie_filter[vendor_ie_num][len];
4910 len++;
4911 }
4912 rtw_mfree(vendor_ie, MAX_VENDOR_IE_LEN);
4913 } else if (count == 2) {
4914 num = sscanf(tmp, "%hhu", &mlmepriv->vendor_ie_filter_enable);
4915 } else {
4916 RTW_INFO("argument size is wrong\n");
4917 return -EINVAL;
4918 }
4919 } else {
4920 return -EFAULT;
4921 }
4922
4923 return count;
4924 }
4925 #endif
4926
4927 /*
4928 * rtw_adapter_proc:
4929 * init/deinit when register/unregister net_device
4930 */
4931 const struct rtw_proc_hdl adapter_proc_hdls[] = {
4932 #if RTW_SEQ_FILE_TEST
4933 RTW_PROC_HDL_SEQ("seq_file_test", &seq_file_test, NULL),
4934 #endif
4935 RTW_PROC_HDL_SSEQ("write_reg", NULL, proc_set_write_reg),
4936 RTW_PROC_HDL_SSEQ("read_reg", proc_get_read_reg, proc_set_read_reg),
4937
4938 RTW_PROC_HDL_SSEQ("mac_dbg_status_dump", NULL, proc_set_mac_dbg_status_dump),
4939
4940 RTW_PROC_HDL_SSEQ("tx_rate_bmp", proc_get_dump_tx_rate_bmp, NULL),
4941 RTW_PROC_HDL_SSEQ("adapters_status", proc_get_dump_adapters_status, NULL),
4942 #ifdef CONFIG_RTW_CUSTOMER_STR
4943 RTW_PROC_HDL_SSEQ("customer_str", proc_get_customer_str, NULL),
4944 #endif
4945 RTW_PROC_HDL_SSEQ("fwstate", proc_get_fwstate, NULL),
4946 RTW_PROC_HDL_SSEQ("sec_info", proc_get_sec_info, NULL),
4947 RTW_PROC_HDL_SSEQ("mlmext_state", proc_get_mlmext_state, NULL),
4948 RTW_PROC_HDL_SSEQ("qos_option", proc_get_qos_option, NULL),
4949 RTW_PROC_HDL_SSEQ("ht_option", proc_get_ht_option, NULL),
4950 RTW_PROC_HDL_SSEQ("rf_info", proc_get_rf_info, NULL),
4951 RTW_PROC_HDL_SSEQ("scan_param", proc_get_scan_param, proc_set_scan_param),
4952 RTW_PROC_HDL_SSEQ("scan_abort", proc_get_scan_abort, proc_set_scan_abort),
4953 #ifdef CONFIG_SCAN_BACKOP
4954 RTW_PROC_HDL_SSEQ("backop_flags_sta", proc_get_backop_flags_sta, proc_set_backop_flags_sta),
4955 #ifdef CONFIG_AP_MODE
4956 RTW_PROC_HDL_SSEQ("backop_flags_ap", proc_get_backop_flags_ap, proc_set_backop_flags_ap),
4957 #endif
4958 #ifdef CONFIG_RTW_MESH
4959 RTW_PROC_HDL_SSEQ("backop_flags_mesh", proc_get_backop_flags_mesh, proc_set_backop_flags_mesh),
4960 #endif
4961 #endif
4962 RTW_PROC_HDL_SSEQ("survey_info", proc_get_survey_info, proc_set_survey_info),
4963 RTW_PROC_HDL_SSEQ("ap_info", proc_get_ap_info, NULL),
4964 #ifdef ROKU_PRIVATE
4965 RTW_PROC_HDL_SSEQ("infra_ap", proc_get_infra_ap, NULL),
4966 #endif /* ROKU_PRIVATE */
4967 RTW_PROC_HDL_SSEQ("trx_info", proc_get_trx_info, proc_reset_trx_info),
4968 RTW_PROC_HDL_SSEQ("tx_power_offset", proc_get_tx_power_offset, proc_set_tx_power_offset),
4969 RTW_PROC_HDL_SSEQ("rate_ctl", proc_get_rate_ctl, proc_set_rate_ctl),
4970 RTW_PROC_HDL_SSEQ("bw_ctl", proc_get_bw_ctl, proc_set_bw_ctl),
4971 RTW_PROC_HDL_SSEQ("mac_qinfo", proc_get_mac_qinfo, NULL),
4972 /*RTW_PROC_HDL_SSEQ("macid_info", proc_get_macid_info, NULL), */
4973 /* RTW_PROC_HDL_SSEQ("bcmc_info", proc_get_mi_ap_bc_info, NULL), */
4974 RTW_PROC_HDL_SSEQ("sec_cam", proc_get_sec_cam, proc_set_sec_cam),
4975 RTW_PROC_HDL_SSEQ("sec_cam_cache", proc_get_sec_cam_cache, NULL),
4976 #ifdef CONFIG_DBG_AX_CAM
4977 RTW_PROC_HDL_SSEQ("dump_ax_valid_key", proc_get_ax_valid_key, NULL),
4978 RTW_PROC_HDL_SSEQ("dump_ax_address_cam", proc_get_ax_address_cam, NULL),
4979 RTW_PROC_HDL_SSEQ("dump_ax_security_cam", proc_get_ax_sec_cam, NULL),
4980 #endif
4981
4982 RTW_PROC_HDL_SSEQ("ps_dbg_info", proc_get_ps_dbg_info, proc_set_ps_dbg_info),
4983 RTW_PROC_HDL_SSEQ("wifi_spec", proc_get_wifi_spec, NULL),
4984 #ifdef CONFIG_LAYER2_ROAMING
4985 RTW_PROC_HDL_SSEQ("roam_flags", proc_get_roam_flags, proc_set_roam_flags),
4986 RTW_PROC_HDL_SSEQ("roam_param", proc_get_roam_param, proc_set_roam_param),
4987 RTW_PROC_HDL_SSEQ("roam_tgt_addr", NULL, proc_set_roam_tgt_addr),
4988 #endif /* CONFIG_LAYER2_ROAMING */
4989 #ifdef CONFIG_RTW_MBO
4990 RTW_PROC_HDL_SSEQ("non_pref_ch", rtw_mbo_proc_non_pref_chans_get, rtw_mbo_proc_non_pref_chans_set),
4991 RTW_PROC_HDL_SSEQ("cell_data", rtw_mbo_proc_cell_data_get, rtw_mbo_proc_cell_data_set),
4992 RTW_PROC_HDL_SSEQ("mbo_attr", rtw_mbo_proc_attr_get, rtw_mbo_proc_attr_set),
4993 #endif
4994 #ifdef CONFIG_RTW_80211R
4995 RTW_PROC_HDL_SSEQ("ft_flags", rtw_ft_proc_flags_get, rtw_ft_proc_flags_set),
4996 #endif
4997 RTW_PROC_HDL_SSEQ("defs_param", proc_get_defs_param, proc_set_defs_param),
4998 #ifdef CONFIG_SDIO_HCI
4999 RTW_PROC_HDL_SSEQ("sd_f0_reg_dump", proc_get_sd_f0_reg_dump, NULL),
5000 RTW_PROC_HDL_SSEQ("sdio_local_reg_dump", proc_get_sdio_local_reg_dump, NULL),
5001 RTW_PROC_HDL_SSEQ("sdio_card_info", proc_get_sdio_card_info, NULL),
5002 #ifdef DBG_SDIO
5003 RTW_PROC_HDL_SSEQ("sdio_dbg", proc_get_sdio_dbg, proc_set_sdio_dbg),
5004 #endif /* DBG_SDIO */
5005 #endif /* CONFIG_SDIO_HCI */
5006
5007 RTW_PROC_HDL_SSEQ("del_rx_ampdu_test_case", NULL, proc_set_del_rx_ampdu_test_case),
5008 RTW_PROC_HDL_SSEQ("wait_hiq_empty", NULL, proc_set_wait_hiq_empty),
5009 RTW_PROC_HDL_SSEQ("sta_linking_test", NULL, proc_set_sta_linking_test),
5010 #ifdef CONFIG_AP_MODE
5011 RTW_PROC_HDL_SSEQ("ap_linking_test", NULL, proc_set_ap_linking_test),
5012 #endif
5013
5014 RTW_PROC_HDL_SSEQ("mac_reg_dump", proc_get_mac_reg_dump, NULL),
5015 RTW_PROC_HDL_SSEQ("bb_reg_dump", proc_get_bb_reg_dump, NULL),
5016 RTW_PROC_HDL_SSEQ("bb_reg_dump_ex", proc_get_bb_reg_dump_ex, NULL),
5017 RTW_PROC_HDL_SSEQ("rf_reg_dump", proc_get_rf_reg_dump, NULL),
5018
5019 #if 0
5020 RTW_PROC_HDL_SSEQ("led_config", proc_get_led_config, proc_set_led_config),
5021 #endif
5022
5023 #ifdef CONFIG_AP_MODE
5024 RTW_PROC_HDL_SSEQ("aid_status", proc_get_aid_status, proc_set_aid_status),
5025 RTW_PROC_HDL_SSEQ("all_sta_info", proc_get_all_sta_info, NULL),
5026 RTW_PROC_HDL_SSEQ("bmc_tx_rate", proc_get_bmc_tx_rate, proc_set_bmc_tx_rate),
5027 #if CONFIG_RTW_AP_DATA_BMC_TO_UC
5028 RTW_PROC_HDL_SSEQ("ap_b2u_flags", proc_get_ap_b2u_flags, proc_set_ap_b2u_flags),
5029 #endif
5030 #endif /* CONFIG_AP_MODE */
5031
5032 #ifdef DBG_MEMORY_LEAK
5033 RTW_PROC_HDL_SSEQ("_malloc_cnt", proc_get_malloc_cnt, NULL),
5034 #endif /* DBG_MEMORY_LEAK */
5035
5036 #ifdef CONFIG_FIND_BEST_CHANNEL
5037 RTW_PROC_HDL_SSEQ("best_channel", proc_get_best_channel, proc_set_best_channel),
5038 #endif
5039
5040 RTW_PROC_HDL_SSEQ("rx_signal", proc_get_rx_signal, proc_set_rx_signal),
5041 RTW_PROC_HDL_SSEQ("rx_chk_limit", proc_get_rx_chk_limit, proc_set_rx_chk_limit),
5042 RTW_PROC_HDL_SSEQ("hw_info", proc_get_hw_status, proc_set_hw_status),
5043 RTW_PROC_HDL_SSEQ("mac_rptbuf", proc_get_mac_rptbuf, NULL),
5044 #ifdef CONFIG_80211N_HT
5045 RTW_PROC_HDL_SSEQ("ht_enable", proc_get_ht_enable, proc_set_ht_enable),
5046 RTW_PROC_HDL_SSEQ("bw_mode", proc_get_bw_mode, proc_set_bw_mode),
5047 RTW_PROC_HDL_SSEQ("ampdu_enable", proc_get_ampdu_enable, proc_set_ampdu_enable),
5048 RTW_PROC_HDL_SSEQ("rx_ampdu", proc_get_rx_ampdu, proc_set_rx_ampdu),
5049 RTW_PROC_HDL_SSEQ("rx_ampdu_size_limit", proc_get_rx_ampdu_size_limit, proc_set_rx_ampdu_size_limit),
5050 RTW_PROC_HDL_SSEQ("rx_ampdu_factor", proc_get_rx_ampdu_factor, proc_set_rx_ampdu_factor),
5051 RTW_PROC_HDL_SSEQ("rx_ampdu_density", proc_get_rx_ampdu_density, proc_set_rx_ampdu_density),
5052 RTW_PROC_HDL_SSEQ("tx_ampdu_density", proc_get_tx_ampdu_density, proc_set_tx_ampdu_density),
5053 RTW_PROC_HDL_SSEQ("tx_max_agg_num", proc_get_tx_max_agg_num, proc_set_tx_max_agg_num),
5054 RTW_PROC_HDL_SSEQ("tx_quick_addba_req", proc_get_tx_quick_addba_req, proc_set_tx_quick_addba_req),
5055 #ifdef CONFIG_TX_AMSDU
5056 RTW_PROC_HDL_SSEQ("tx_amsdu", proc_get_tx_amsdu, proc_set_tx_amsdu),
5057 RTW_PROC_HDL_SSEQ("tx_amsdu_rate", proc_get_tx_amsdu_rate, proc_set_tx_amsdu_rate),
5058 #endif
5059 #endif /* CONFIG_80211N_HT */
5060
5061 #ifdef CONFIG_80211AC_VHT
5062 RTW_PROC_HDL_SSEQ("vht_24g_enable", proc_get_vht_24g_enable, proc_set_vht_24g_enable),
5063 #endif /* CONFIG_80211AC_VHT */
5064
5065 RTW_PROC_HDL_SSEQ("dynamic_rrsr", proc_get_dyn_rrsr, proc_set_dyn_rrsr),
5066 RTW_PROC_HDL_SSEQ("en_fwps", proc_get_en_fwps, proc_set_en_fwps),
5067
5068 /* RTW_PROC_HDL_SSEQ("path_rssi", proc_get_two_path_rssi, NULL),
5069 * RTW_PROC_HDL_SSEQ("rssi_disp",proc_get_rssi_disp, proc_set_rssi_disp), */
5070
5071 #ifdef CONFIG_BTC
5072 RTW_PROC_HDL_SSEQ("btc_dbg", proc_get_btc_dbg, proc_set_btc_dbg),
5073 RTW_PROC_HDL_SSEQ("btc", proc_get_btc_info, NULL),
5074 RTW_PROC_HDL_SSEQ("btreg_read", proc_get_btreg_read, proc_set_btreg_read),
5075 RTW_PROC_HDL_SSEQ("btreg_write", proc_get_btreg_write, proc_set_btreg_write),
5076 #endif /* CONFIG_BTC */
5077
5078 #if defined(DBG_CONFIG_ERROR_DETECT)
5079 RTW_PROC_HDL_SSEQ("sreset", proc_get_sreset, proc_set_sreset),
5080 #endif /* DBG_CONFIG_ERROR_DETECT */
5081 RTW_PROC_HDL_SSEQ("trx_info_debug", proc_get_trx_info_debug, NULL),
5082
5083 #ifdef CONFIG_HUAWEI_PROC
5084 RTW_PROC_HDL_SSEQ("huawei_trx_info", proc_get_huawei_trx_info, NULL),
5085 #endif
5086 RTW_PROC_HDL_SSEQ("rtw_hal_linked_info_dump", proc_get_linked_info_dump, proc_set_linked_info_dump),
5087 RTW_PROC_HDL_SSEQ("sta_tp_dump", proc_get_sta_tp_dump, proc_set_sta_tp_dump),
5088 RTW_PROC_HDL_SSEQ("sta_tp_info", proc_get_sta_tp_info, NULL),
5089 RTW_PROC_HDL_SSEQ("dis_turboedca", proc_get_turboedca_ctrl, proc_set_turboedca_ctrl),
5090 RTW_PROC_HDL_SSEQ("tx_info_msg", proc_get_tx_info_msg, NULL),
5091 RTW_PROC_HDL_SSEQ("rx_info_msg", proc_get_rx_info_msg, proc_set_rx_info_msg),
5092 RTW_PROC_HDL_SSEQ("false_alarm_accumulated",
5093 proc_get_false_alarm_accumulated,
5094 proc_set_false_alarm_accumulated),
5095 #ifdef ROKU_PRIVATE
5096 RTW_PROC_HDL_SSEQ("roku_trx_info_msg", proc_get_roku_trx_info_msg, NULL),
5097 #endif
5098 #if defined(CONFIG_LPS_PG) && defined(CONFIG_RTL8822C)
5099 RTW_PROC_HDL_SSEQ("lps_pg_debug", proc_get_lps_pg_debug, NULL),
5100 #endif
5101
5102 #ifdef CONFIG_GPIO_API
5103 RTW_PROC_HDL_SSEQ("gpio_info", proc_get_gpio, proc_set_gpio),
5104 RTW_PROC_HDL_SSEQ("gpio_set_output_value", NULL, proc_set_gpio_output_value),
5105 RTW_PROC_HDL_SSEQ("gpio_set_direction", NULL, proc_set_config_gpio),
5106 #endif
5107
5108 #ifdef CONFIG_DBG_COUNTER
5109 RTW_PROC_HDL_SSEQ("rx_logs", proc_get_rx_logs, NULL),
5110 RTW_PROC_HDL_SSEQ("tx_logs", proc_get_tx_logs, NULL),
5111 RTW_PROC_HDL_SSEQ("int_logs", proc_get_int_logs, NULL),
5112 #endif
5113
5114 #ifdef CONFIG_DBG_RF_CAL
5115 RTW_PROC_HDL_SSEQ("iqk", proc_get_iqk_info, proc_set_iqk),
5116 RTW_PROC_HDL_SSEQ("lck", proc_get_lck_info, proc_set_lck),
5117 #endif
5118
5119 #ifdef CONFIG_PCI_HCI
5120 RTW_PROC_HDL_SSEQ("rx_ring", proc_get_rx_ring, NULL),
5121 RTW_PROC_HDL_SSEQ("tx_ring", proc_get_tx_ring, NULL),
5122 #ifdef DBG_TXBD_DESC_DUMP
5123 RTW_PROC_HDL_SSEQ("tx_ring_ext", proc_get_tx_ring_ext, proc_set_tx_ring_ext),
5124 #endif
5125 RTW_PROC_HDL_SSEQ("pci_aspm", proc_get_pci_aspm, NULL),
5126
5127 RTW_PROC_HDL_SSEQ("pci_conf_space", proc_get_pci_conf_space, proc_set_pci_conf_space),
5128
5129 RTW_PROC_HDL_SSEQ("pci_bridge_conf_space", proc_get_pci_bridge_conf_space, proc_set_pci_bridge_conf_space),
5130
5131 #endif
5132
5133 #ifdef CONFIG_WOWLAN
5134 RTW_PROC_HDL_SSEQ("wow_enable", proc_get_wow_enable, proc_set_wow_enable),
5135 RTW_PROC_HDL_SSEQ("wow_pattern_info", proc_get_pattern_info, proc_set_pattern_info),
5136 RTW_PROC_HDL_SSEQ("wow_wakeup_event", proc_get_wakeup_event,
5137 proc_set_wakeup_event),
5138 RTW_PROC_HDL_SSEQ("wowlan_last_wake_reason", proc_get_wakeup_reason, NULL),
5139 RTW_PROC_HDL_SSEQ("wow_pattern_cam", proc_dump_pattern_cam, NULL),
5140 #endif
5141
5142 #ifdef CONFIG_GPIO_WAKEUP
5143 RTW_PROC_HDL_SSEQ("wowlan_gpio_info", proc_get_wowlan_gpio_info, proc_set_wowlan_gpio_info),
5144 #endif
5145 #ifdef CONFIG_P2P_WOWLAN
5146 RTW_PROC_HDL_SSEQ("p2p_wowlan_info", proc_get_p2p_wowlan_info, NULL),
5147 #endif
5148 RTW_PROC_HDL_SSEQ("country_code", proc_get_country_code, proc_set_country_code),
5149 RTW_PROC_HDL_SSEQ("chan_plan", proc_get_chan_plan, proc_set_chan_plan),
5150 RTW_PROC_HDL_SSEQ("cap_spt_op_class_ch", proc_get_cap_spt_op_class_ch, proc_set_cap_spt_op_class_ch),
5151 RTW_PROC_HDL_SSEQ("reg_spt_op_class_ch", proc_get_reg_spt_op_class_ch, proc_set_reg_spt_op_class_ch),
5152 RTW_PROC_HDL_SSEQ("cur_spt_op_class_ch", proc_get_cur_spt_op_class_ch, proc_set_cur_spt_op_class_ch),
5153 #if CONFIG_RTW_MACADDR_ACL
5154 RTW_PROC_HDL_SSEQ("macaddr_acl", proc_get_macaddr_acl, proc_set_macaddr_acl),
5155 #endif
5156 #if CONFIG_RTW_PRE_LINK_STA
5157 RTW_PROC_HDL_SSEQ("pre_link_sta", proc_get_pre_link_sta, proc_set_pre_link_sta),
5158 #endif
5159 RTW_PROC_HDL_SSEQ("ch_sel_policy", proc_get_ch_sel_policy, proc_set_ch_sel_policy),
5160 #ifdef CONFIG_80211D
5161 RTW_PROC_HDL_SSEQ("country_ie_slave_en_conds", proc_get_country_ie_slave_en_conds, proc_set_country_ie_slave_en_conds),
5162 RTW_PROC_HDL_SSEQ("country_ie_slave_records", proc_get_country_ie_slave_records, NULL),
5163 #endif
5164 #ifdef CONFIG_DFS_MASTER
5165 RTW_PROC_HDL_SSEQ("dfs_test_case", proc_get_dfs_test_case, proc_set_dfs_test_case),
5166 RTW_PROC_HDL_SSEQ("update_non_ocp", NULL, proc_set_update_non_ocp),
5167 RTW_PROC_HDL_SSEQ("radar_detect", NULL, proc_set_radar_detect),
5168 RTW_PROC_HDL_SSEQ("dfs_ch_sel_e_flags", proc_get_dfs_ch_sel_e_flags, proc_set_dfs_ch_sel_e_flags),
5169 RTW_PROC_HDL_SSEQ("dfs_ch_sel_d_flags", proc_get_dfs_ch_sel_d_flags, proc_set_dfs_ch_sel_d_flags),
5170 #if CONFIG_DFS_SLAVE_WITH_RADAR_DETECT
5171 RTW_PROC_HDL_SSEQ("dfs_slave_with_rd", proc_get_dfs_slave_with_rd, proc_set_dfs_slave_with_rd),
5172 #endif
5173 #endif
5174 RTW_PROC_HDL_SSEQ("sink_udpport", proc_get_udpport, proc_set_udpport),
5175 #ifdef DBG_RX_COUNTER_DUMP
5176 RTW_PROC_HDL_SSEQ("dump_rx_cnt_mode", proc_get_rx_cnt_dump, proc_set_rx_cnt_dump),
5177 #endif
5178 RTW_PROC_HDL_SSEQ("change_bss_chbw", NULL, proc_set_change_bss_chbw),
5179 RTW_PROC_HDL_SSEQ("tx_bw_mode", proc_get_tx_bw_mode, proc_set_tx_bw_mode),
5180
5181 RTW_PROC_HDL_SSEQ("target_tx_power", proc_get_target_tx_power, NULL),
5182 RTW_PROC_HDL_SSEQ("tx_power_by_rate", proc_get_tx_power_by_rate, NULL),
5183 #if CONFIG_TXPWR_LIMIT
5184 RTW_PROC_HDL_SSEQ("tx_power_limit", proc_get_tx_power_limit, NULL),
5185 #endif
5186 RTW_PROC_HDL_SSEQ("tx_power_ext_info", proc_get_tx_power_ext_info, proc_set_tx_power_ext_info),
5187 #ifdef GEORGIA_TODO_TX_PWR
5188 RTW_PROC_HDL_SEQ("tx_power_idx", &seq_ops_tx_power_idx, NULL),
5189 RTW_PROC_HDL_SEQ("txpwr_total_dbm", &seq_ops_txpwr_total_dbm, NULL),
5190 #endif
5191 #ifdef CONFIG_POWER_SAVING
5192 RTW_PROC_HDL_SSEQ("ps_info", proc_get_ps_info, proc_set_ps_info),
5193 #ifdef CONFIG_WMMPS_STA
5194 RTW_PROC_HDL_SSEQ("wmmps_info", proc_get_wmmps_info, proc_set_wmmps_info),
5195 #endif /* CONFIG_WMMPS_STA */
5196 #endif
5197 #ifdef CONFIG_TDLS
5198 RTW_PROC_HDL_SSEQ("tdls_info", proc_get_tdls_info, NULL),
5199 RTW_PROC_HDL_SSEQ("tdls_enable", proc_get_tdls_enable, proc_set_tdls_enable),
5200 #endif
5201 RTW_PROC_HDL_SSEQ("monitor", proc_get_monitor, proc_set_monitor),
5202
5203 #ifdef CONFIG_RTW_ACS
5204 #ifdef WKARD_ACS
5205 RTW_PROC_HDL_SSEQ("acs", proc_get_best_chan, proc_set_acs),
5206 RTW_PROC_HDL_SSEQ("chan_info", proc_get_chan_info, NULL),
5207 #endif
5208 #endif
5209 RTW_PROC_HDL_SSEQ("env_info", proc_get_env_rpt, NULL),
5210 RTW_PROC_HDL_SSEQ("hal_spec", proc_get_hal_spec, NULL),
5211 RTW_PROC_HDL_SSEQ("hal_trx_mode", proc_get_hal_trx_mode, NULL),
5212 RTW_PROC_HDL_SSEQ("hal_txpwr_info", proc_get_hal_txpwr_info, NULL),
5213
5214 RTW_PROC_HDL_SSEQ("efuse_map", proc_get_efuse_map, NULL),
5215 #ifdef CONFIG_IEEE80211W
5216 RTW_PROC_HDL_SSEQ("11w_tx_sa_query", proc_get_tx_sa_query, proc_set_tx_sa_query),
5217 RTW_PROC_HDL_SSEQ("11w_tx_deauth", proc_get_tx_deauth, proc_set_tx_deauth),
5218 RTW_PROC_HDL_SSEQ("11w_tx_auth", proc_get_tx_auth, proc_set_tx_auth),
5219 #endif /* CONFIG_IEEE80211W */
5220
5221 RTW_PROC_HDL_SSEQ("mac_addr", proc_get_mac_addr, NULL),
5222 RTW_PROC_HDL_SSEQ("skip_band", proc_get_skip_band, proc_set_skip_band),
5223
5224 RTW_PROC_HDL_SSEQ("rx_stat", proc_get_rx_stat, NULL),
5225
5226 RTW_PROC_HDL_SSEQ("tx_stat", proc_get_tx_stat, NULL),
5227 RTW_PROC_HDL_SSEQ("sta_tx_stat", proc_get_sta_tx_stat, proc_set_sta_tx_stat),
5228 /**** PHY Capability ****/
5229 RTW_PROC_HDL_SSEQ("phy_cap", proc_get_phy_cap, NULL),
5230 #ifdef CONFIG_80211N_HT
5231 RTW_PROC_HDL_SSEQ("stbc_cap", proc_get_stbc_cap, proc_set_stbc_cap),
5232 RTW_PROC_HDL_SSEQ("ldpc_cap", proc_get_ldpc_cap, proc_set_ldpc_cap),
5233 #endif /* CONFIG_80211N_HT */
5234 #ifdef CONFIG_BEAMFORMING
5235 RTW_PROC_HDL_SSEQ("txbf_cap", proc_get_txbf_cap, proc_set_txbf_cap),
5236 #endif
5237
5238 RTW_PROC_HDL_SSEQ("napi_info", proc_get_napi_info, NULL),
5239 #ifdef CONFIG_RTW_NAPI_DYNAMIC
5240 RTW_PROC_HDL_SSEQ("napi_th", proc_get_napi_info, proc_set_napi_th),
5241 #endif /* CONFIG_RTW_NAPI_DYNAMIC */
5242
5243 RTW_PROC_HDL_SSEQ("rsvd_page", proc_dump_rsvd_page, proc_set_rsvd_page_info),
5244
5245 #ifdef CONFIG_SUPPORT_FIFO_DUMP
5246 RTW_PROC_HDL_SSEQ("fifo_dump", proc_dump_fifo, proc_set_fifo_info),
5247 #endif
5248
5249 #ifdef CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST
5250 RTW_PROC_HDL_SSEQ("ignore_go_and_low_rssi_in_scan",
5251 proc_get_ignore_go_and_low_rssi_in_scan,
5252 proc_set_ignore_go_and_low_rssi_in_scan),
5253 #endif /*CONFIG_IGNORE_GO_AND_LOW_RSSI_IN_SCAN_LIST*/
5254
5255 #ifdef DBG_XMIT_BLOCK
5256 RTW_PROC_HDL_SSEQ("xmit_block", proc_get_xmit_block, proc_set_xmit_block),
5257 #endif
5258
5259 RTW_PROC_HDL_SSEQ("ack_timeout", proc_get_ack_timeout, proc_set_ack_timeout),
5260
5261 RTW_PROC_HDL_SSEQ("dynamic_agg_enable", proc_get_dynamic_agg_enable, proc_set_dynamic_agg_enable),
5262 RTW_PROC_HDL_SSEQ("fw_offload", proc_get_fw_offload, proc_set_fw_offload),
5263
5264 #ifdef CONFIG_RTW_WDS
5265 RTW_PROC_HDL_SSEQ("wds_en", proc_get_wds_en, proc_set_wds_en),
5266 RTW_PROC_HDL_SSEQ("sta_wds_en", NULL, proc_set_sta_wds_en),
5267 RTW_PROC_HDL_SSEQ("wds_gptr", proc_get_wds_gptr, NULL),
5268 #ifdef CONFIG_AP_MODE
5269 RTW_PROC_HDL_SSEQ("wds_path", proc_get_wds_path, NULL),
5270 #endif
5271 #endif
5272
5273 #ifdef CONFIG_RTW_MULTI_AP
5274 RTW_PROC_HDL_SSEQ("multi_ap_opmode", proc_get_multi_ap_opmode, proc_set_multi_ap_opmode),
5275 RTW_PROC_HDL_SSEQ("unassoc_sta", proc_get_unassoc_sta, proc_set_unassoc_sta),
5276 #ifdef CONFIG_IOCTL_CFG80211
5277 RTW_PROC_HDL_SSEQ("sta_assoc_req_frame_body", proc_get_sta_assoc_req_frame_body, proc_set_sta_assoc_req_frame_body),
5278 #endif
5279 RTW_PROC_HDL_SSEQ("ch_util_threshold", proc_get_ch_util_threshold, proc_set_ch_util_threshold),
5280 RTW_PROC_HDL_SSEQ("ch_utilization", proc_get_ch_utilization, NULL),
5281 #endif
5282
5283 #ifdef CONFIG_RTW_MESH
5284 #if CONFIG_RTW_MESH_ACNODE_PREVENT
5285 RTW_PROC_HDL_SSEQ("mesh_acnode_prevent", proc_get_mesh_acnode_prevent, proc_set_mesh_acnode_prevent),
5286 #endif
5287 #if CONFIG_RTW_MESH_OFFCH_CAND
5288 RTW_PROC_HDL_SSEQ("mesh_offch_cand", proc_get_mesh_offch_cand, proc_set_mesh_offch_cand),
5289 #endif
5290 #if CONFIG_RTW_MESH_PEER_BLACKLIST
5291 RTW_PROC_HDL_SSEQ("mesh_peer_blacklist", proc_get_mesh_peer_blacklist, proc_set_mesh_peer_blacklist),
5292 #endif
5293 #if CONFIG_RTW_MESH_CTO_MGATE_BLACKLIST
5294 RTW_PROC_HDL_SSEQ("mesh_cto_mgate_require", proc_get_mesh_cto_mgate_require, proc_set_mesh_cto_mgate_require),
5295 RTW_PROC_HDL_SSEQ("mesh_cto_mgate_blacklist", proc_get_mesh_cto_mgate_blacklist, proc_set_mesh_cto_mgate_blacklist),
5296 #endif
5297 RTW_PROC_HDL_SSEQ("mesh_peer_sel_policy", proc_get_mesh_peer_sel_policy, NULL),
5298 RTW_PROC_HDL_SSEQ("mesh_networks", proc_get_mesh_networks, NULL),
5299 RTW_PROC_HDL_SSEQ("mesh_plink_ctl", proc_get_mesh_plink_ctl, NULL),
5300 RTW_PROC_HDL_SSEQ("mesh_mpath", proc_get_mesh_mpath, NULL),
5301 RTW_PROC_HDL_SSEQ("mesh_mpp", proc_get_mesh_mpp, NULL),
5302 RTW_PROC_HDL_SSEQ("mesh_known_gates", proc_get_mesh_known_gates, NULL),
5303 #if CONFIG_RTW_MESH_DATA_BMC_TO_UC
5304 RTW_PROC_HDL_SSEQ("mesh_b2u_flags", proc_get_mesh_b2u_flags, proc_set_mesh_b2u_flags),
5305 #endif
5306 RTW_PROC_HDL_SSEQ("mesh_stats", proc_get_mesh_stats, NULL),
5307 RTW_PROC_HDL_SSEQ("mesh_gate_timeout_factor", proc_get_mesh_gate_timeout, proc_set_mesh_gate_timeout),
5308 RTW_PROC_HDL_SSEQ("mesh_gate_state", proc_get_mesh_gate_state, NULL),
5309 RTW_PROC_HDL_SSEQ("mesh_peer_alive_based_preq", proc_get_peer_alive_based_preq, proc_set_peer_alive_based_preq),
5310 #endif
5311
5312 #ifdef CONFIG_LPS_CHK_BY_TP
5313 RTW_PROC_HDL_SSEQ("lps_chk_tp", proc_get_lps_chk_tp, proc_set_lps_chk_tp),
5314 #endif
5315 #ifdef CONFIG_SUPPORT_STATIC_SMPS
5316 RTW_PROC_HDL_SSEQ("smps", proc_get_smps, proc_set_smps),
5317 #endif
5318
5319 #ifdef RTW_BUSY_DENY_SCAN
5320 RTW_PROC_HDL_SSEQ("scan_interval_thr", proc_get_scan_interval_thr, \
5321 proc_set_scan_interval_thr),
5322 #endif
5323 RTW_PROC_HDL_SSEQ("scan_deny", proc_get_scan_deny, proc_set_scan_deny),
5324
5325 #ifdef CONFIG_CTRL_TXSS_BY_TP
5326 RTW_PROC_HDL_SSEQ("txss_tp", proc_get_txss_tp, proc_set_txss_tp),
5327 #ifdef DBG_CTRL_TXSS
5328 RTW_PROC_HDL_SSEQ("txss_ctrl", proc_get_txss_ctrl, proc_set_txss_ctrl),
5329 #endif
5330 #endif
5331
5332 RTW_PROC_HDL_SSEQ("cur_beacon_keys", proc_get_cur_beacon_keys, NULL),
5333
5334 RTW_PROC_HDL_SSEQ("chan", proc_get_chan, proc_set_chan),
5335
5336 RTW_PROC_HDL_SSEQ("mr_test", proc_get_mr_test, proc_set_mr_test),
5337
5338 RTW_PROC_HDL_SSEQ("deny_legacy", proc_get_deny_legacy, proc_set_deny_legacy),
5339 #if defined(ROKU_PRIVATE) && defined(CONFIG_P2P)
5340 RTW_PROC_HDL_SSEQ("go_hidden_ssid_mode", proc_get_go_hidden_ssid_mode, proc_set_go_hidden_ssid_mode),
5341 #endif
5342 RTW_PROC_HDL_SSEQ("rtw_amsdu_mode", proc_get_amsdu_mode, proc_set_amsdu_mode),
5343 #ifdef CONFIG_80211AX_HE
5344 RTW_PROC_HDL_SSEQ("tx_ul_mu_disable", proc_get_tx_ul_mu_disable, proc_set_tx_ul_mu_disable),
5345 #endif
5346 #ifdef ROKU_PRIVATE
5347 RTW_PROC_HDL_SSEQ("vendor_ie_filter", proc_get_vendor_ie_filter, proc_set_vendor_ie_filter),
5348 #endif
5349 #ifdef RTW_DETECT_HANG
5350 RTW_PROC_HDL_SSEQ("hang_info", proc_get_hang_info, NULL),
5351 #endif
5352 RTW_PROC_HDL_SSEQ("disconnect_info", proc_get_disconnect_info,
5353 proc_set_disconnect_info),
5354 };
5355
5356 const int adapter_proc_hdls_num = sizeof(adapter_proc_hdls) / sizeof(struct rtw_proc_hdl);
5357
rtw_adapter_proc_open(struct inode * inode,struct file * file)5358 static int rtw_adapter_proc_open(struct inode *inode, struct file *file)
5359 {
5360 ssize_t index = (ssize_t)PDE_DATA(inode);
5361 const struct rtw_proc_hdl *hdl = adapter_proc_hdls + index;
5362 void *private = proc_get_parent_data(inode);
5363
5364 if (hdl->type == RTW_PROC_HDL_TYPE_SEQ) {
5365 int res = seq_open(file, hdl->u.seq_op);
5366
5367 if (res == 0)
5368 ((struct seq_file *)file->private_data)->private = private;
5369
5370 return res;
5371 } else if (hdl->type == RTW_PROC_HDL_TYPE_SSEQ) {
5372 int (*show)(struct seq_file *, void *) = hdl->u.show ? hdl->u.show : proc_get_dummy;
5373
5374 return single_open(file, show, private);
5375 } else if (hdl->type == RTW_PROC_HDL_TYPE_SZSEQ) {
5376 int (*show)(struct seq_file *, void *) = hdl->u.sz.show ? hdl->u.sz.show : proc_get_dummy;
5377
5378 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
5379 return single_open_size(file, show, private, hdl->u.sz.size);
5380 #else
5381 return single_open(file, show, private);
5382 #endif
5383 } else {
5384 return -EROFS;
5385 }
5386 }
5387
rtw_adapter_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * pos)5388 static ssize_t rtw_adapter_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos)
5389 {
5390 ssize_t index = (ssize_t)PDE_DATA(file_inode(file));
5391 const struct rtw_proc_hdl *hdl = adapter_proc_hdls + index;
5392 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *, void *) = hdl->write;
5393
5394 if (write)
5395 return write(file, buffer, count, pos, ((struct seq_file *)file->private_data)->private);
5396
5397 return -EROFS;
5398 }
5399
5400 static const struct rtw_proc_ops rtw_adapter_proc_seq_fops = {
5401 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
5402 .proc_open = rtw_adapter_proc_open,
5403 .proc_read = seq_read,
5404 .proc_lseek = seq_lseek,
5405 .proc_release = seq_release,
5406 .proc_write = rtw_adapter_proc_write,
5407 #else
5408 .owner = THIS_MODULE,
5409 .open = rtw_adapter_proc_open,
5410 .read = seq_read,
5411 .llseek = seq_lseek,
5412 .release = seq_release,
5413 .write = rtw_adapter_proc_write,
5414 #endif
5415 };
5416
5417 static const struct rtw_proc_ops rtw_adapter_proc_sseq_fops = {
5418 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
5419 .proc_open = rtw_adapter_proc_open,
5420 .proc_read = seq_read,
5421 .proc_lseek = seq_lseek,
5422 .proc_release = seq_release,
5423 .proc_write = rtw_adapter_proc_write,
5424 #else
5425 .owner = THIS_MODULE,
5426 .open = rtw_adapter_proc_open,
5427 .read = seq_read,
5428 .llseek = seq_lseek,
5429 .release = single_release,
5430 .write = rtw_adapter_proc_write,
5431 #endif
5432 };
5433
proc_get_phy_adaptivity(struct seq_file * m,void * v)5434 int proc_get_phy_adaptivity(struct seq_file *m, void *v)
5435 {
5436 struct net_device *dev = m->private;
5437 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5438
5439 rtw_cfg_adaptivity_config_msg(m, padapter);
5440 rtw_hal_phy_adaptivity_parm_msg(m, padapter);
5441
5442 return 0;
5443 }
5444
proc_set_phy_adaptivity(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5445 ssize_t proc_set_phy_adaptivity(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5446 {
5447 struct net_device *dev = data;
5448 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
5449 char tmp[32];
5450 u32 th_l2h_ini;
5451 s8 th_edcca_hl_diff;
5452
5453 if (count < 1)
5454 return -EFAULT;
5455
5456 if (count > sizeof(tmp)) {
5457 rtw_warn_on(1);
5458 return -EFAULT;
5459 }
5460
5461 if (buffer && !copy_from_user(tmp, buffer, count)) {
5462
5463 int num = sscanf(tmp, "%x %hhd", &th_l2h_ini, &th_edcca_hl_diff);
5464
5465 if (num != 2)
5466 return count;
5467
5468 rtw_hal_phy_adaptivity_parm_set(padapter, (s8)th_l2h_ini, th_edcca_hl_diff);
5469 }
5470
5471 return count;
5472 }
5473
5474 static char *phydm_msg = NULL;
5475 #define PHYDM_MSG_LEN 80*24*4
5476
proc_get_phydm_cmd(struct seq_file * m,void * v)5477 static int proc_get_phydm_cmd(struct seq_file *m, void *v)
5478 {
5479 struct net_device *netdev = m->private;
5480 _adapter *padapter = (_adapter *)rtw_netdev_priv(netdev);
5481
5482 if (NULL == phydm_msg) {
5483 _RTW_PRINT_SEL(m, "(Nothing to output)\n");
5484 return 0;
5485 #if 0
5486 phydm_msg = rtw_zmalloc(PHYDM_MSG_LEN);
5487 if (NULL == phydm_msg)
5488 return -ENOMEM;
5489
5490 phydm_cmd(phydm, NULL, 0, 0, phydm_msg, PHYDM_MSG_LEN);
5491 #endif
5492 }
5493
5494 _RTW_PRINT_SEL(m, "%s\n", phydm_msg);
5495
5496 rtw_mfree(phydm_msg, PHYDM_MSG_LEN);
5497 phydm_msg = NULL;
5498
5499 return 0;
5500 }
5501
proc_get_phl_cmd(struct seq_file * m,void * v)5502 static int proc_get_phl_cmd(struct seq_file *m, void *v)
5503 {
5504 return proc_get_phydm_cmd(m, v);
5505 }
5506
proc_set_phydm_cmd(struct file * file,char * buffer,size_t count,loff_t * pos,void * data,enum rtw_proc_cmd_type type)5507 static ssize_t proc_set_phydm_cmd(struct file *file, char *buffer, size_t count,
5508 loff_t *pos, void *data,
5509 enum rtw_proc_cmd_type type)
5510 {
5511 struct net_device *netdev = (struct net_device *)data;
5512 _adapter *padapter = (_adapter *)rtw_netdev_priv(netdev);
5513 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
5514 struct rtw_proc_cmd cmd;
5515
5516 if (count < 1)
5517 return -EFAULT;
5518
5519 if (buffer) {
5520 if (NULL == phydm_msg) {
5521 phydm_msg = rtw_zmalloc(PHYDM_MSG_LEN);
5522 if (NULL == phydm_msg)
5523 return -ENOMEM;
5524 } else
5525 _rtw_memset(phydm_msg, 0, PHYDM_MSG_LEN);
5526
5527 cmd.in_type = RTW_ARG_TYPE_BUF;
5528 cmd.in_cnt_len = count;
5529 cmd.in.buf = buffer;
5530
5531 rtw_phl_proc_cmd(GET_PHL_INFO(dvobj), type, &cmd, phydm_msg, PHYDM_MSG_LEN);
5532
5533 if (strlen(phydm_msg) == 0) {
5534 rtw_mfree(phydm_msg, PHYDM_MSG_LEN);
5535 phydm_msg = NULL;
5536 }
5537 }
5538
5539 return count;
5540 }
5541
proc_set_phl_cmd(struct file * file,const char __user * buffer,size_t count,loff_t * pos,void * data)5542 static ssize_t proc_set_phl_cmd(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
5543 {
5544 char *buf, *p;
5545 enum rtw_proc_cmd_type type;
5546 ssize_t ret, len;
5547 int type_len;
5548
5549 buf = _rtw_malloc(count + 1);
5550 if (!buf)
5551 return -ENOMEM;
5552
5553 if (copy_from_user(buf, buffer, count)) {
5554 ret = -EFAULT;
5555 goto err;
5556 }
5557
5558 if (strncmp(buf, "bb ", 3) == 0) {
5559 type = RTW_PROC_CMD_BB;
5560 type_len = 3;
5561 } else if (strncmp(buf, "rf ", 3) == 0) {
5562 type = RTW_PROC_CMD_RF;
5563 type_len = 3;
5564 } else if (strncmp(buf, "mac ", 4) == 0) {
5565 type = RTW_PROC_CMD_MAC;
5566 type_len = 4;
5567 } else if (strncmp(buf, "phl ", 4) == 0) {
5568 type = RTW_PROC_CMD_PHL;
5569 type_len = 4;
5570 } else if (strncmp(buf, "core ", 5) == 0) {
5571 printk("%s(%d)\n",__func__,__LINE__);
5572 type = RTW_PROC_CMD_CORE;
5573 type_len = 5;
5574 } else if (strncmp(buf, "btc ", 4) == 0) {
5575 printk("%s(%d)\n",__func__,__LINE__);
5576 type = RTW_PROC_CMD_BTC;
5577 type_len = 4;
5578 } else if (strncmp(buf, "efuse ", 6) == 0) {
5579 type = RTW_PROC_CMD_EFUSE;
5580 type_len = 6;
5581 } else {
5582 ret = -EINVAL;
5583 goto err;
5584 }
5585
5586 /* skip first type token, like 'bb ', 'rf ' */
5587 p = buf + type_len;
5588 len = count - type_len;
5589
5590 /* remove trailing newline character, because BB/RF parser uses
5591 * " ," as delimiter that leads the last token contains '\n' if
5592 * we use 'echo' command without '-n' argument.
5593 */
5594 if (p[len - 1] == '\n')
5595 len--;
5596 p[len++] = '\0';
5597
5598 ret = proc_set_phydm_cmd(file, p, len, pos, data, type);
5599
5600 err:
5601 _rtw_mfree(buf, count + 1);
5602
5603 if (ret >= 0)
5604 return count;
5605
5606 return ret;
5607 }
5608
5609 /*
5610 * rtw_odm_proc:
5611 * init/deinit when register/unregister net_device, along with rtw_adapter_proc
5612 */
5613 const struct rtw_proc_hdl odm_proc_hdls[] = {
5614 RTW_PROC_HDL_SSEQ("adaptivity", proc_get_phy_adaptivity, proc_set_phy_adaptivity),
5615 RTW_PROC_HDL_SZSEQ("phl_cmd", proc_get_phl_cmd, proc_set_phl_cmd, PHYDM_MSG_LEN),
5616 };
5617
5618 const int odm_proc_hdls_num = sizeof(odm_proc_hdls) / sizeof(struct rtw_proc_hdl);
5619
rtw_odm_proc_open(struct inode * inode,struct file * file)5620 static int rtw_odm_proc_open(struct inode *inode, struct file *file)
5621 {
5622 ssize_t index = (ssize_t)PDE_DATA(inode);
5623 const struct rtw_proc_hdl *hdl = odm_proc_hdls + index;
5624 void *private = proc_get_parent_data(inode);
5625
5626 if (hdl->type == RTW_PROC_HDL_TYPE_SEQ) {
5627 int res = seq_open(file, hdl->u.seq_op);
5628
5629 if (res == 0)
5630 ((struct seq_file *)file->private_data)->private = private;
5631
5632 return res;
5633 } else if (hdl->type == RTW_PROC_HDL_TYPE_SSEQ) {
5634 int (*show)(struct seq_file *, void *) = hdl->u.show ? hdl->u.show : proc_get_dummy;
5635
5636 return single_open(file, show, private);
5637 } else if (hdl->type == RTW_PROC_HDL_TYPE_SZSEQ) {
5638 int (*show)(struct seq_file *, void *) = hdl->u.sz.show ? hdl->u.sz.show : proc_get_dummy;
5639
5640 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
5641 return single_open_size(file, show, private, hdl->u.sz.size);
5642 #else
5643 return single_open(file, show, private);
5644 #endif
5645 } else {
5646 return -EROFS;
5647 }
5648 }
5649
rtw_odm_proc_write(struct file * file,const char __user * buffer,size_t count,loff_t * pos)5650 static ssize_t rtw_odm_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos)
5651 {
5652 ssize_t index = (ssize_t)PDE_DATA(file_inode(file));
5653 const struct rtw_proc_hdl *hdl = odm_proc_hdls + index;
5654 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *, void *) = hdl->write;
5655
5656 if (write)
5657 return write(file, buffer, count, pos, ((struct seq_file *)file->private_data)->private);
5658
5659 return -EROFS;
5660 }
5661
5662 static const struct rtw_proc_ops rtw_odm_proc_seq_fops = {
5663 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
5664 .proc_open = rtw_odm_proc_open,
5665 .proc_read = seq_read,
5666 .proc_lseek = seq_lseek,
5667 .proc_release = seq_release,
5668 .proc_write = rtw_odm_proc_write,
5669 #else
5670 .owner = THIS_MODULE,
5671 .open = rtw_odm_proc_open,
5672 .read = seq_read,
5673 .llseek = seq_lseek,
5674 .release = seq_release,
5675 .write = rtw_odm_proc_write,
5676 #endif
5677 };
5678
5679 static const struct rtw_proc_ops rtw_odm_proc_sseq_fops = {
5680 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
5681 .proc_open = rtw_odm_proc_open,
5682 .proc_read = seq_read,
5683 .proc_lseek = seq_lseek,
5684 .proc_release = single_release,
5685 .proc_write = rtw_odm_proc_write,
5686 #else
5687 .owner = THIS_MODULE,
5688 .open = rtw_odm_proc_open,
5689 .read = seq_read,
5690 .llseek = seq_lseek,
5691 .release = single_release,
5692 .write = rtw_odm_proc_write,
5693 #endif
5694 };
5695
rtw_odm_proc_init(struct net_device * dev)5696 struct proc_dir_entry *rtw_odm_proc_init(struct net_device *dev)
5697 {
5698 struct proc_dir_entry *dir_odm = NULL;
5699 struct proc_dir_entry *entry = NULL;
5700 _adapter *adapter = rtw_netdev_priv(dev);
5701 ssize_t i;
5702
5703 if (adapter->dir_dev == NULL) {
5704 rtw_warn_on(1);
5705 goto exit;
5706 }
5707
5708 if (adapter->dir_odm != NULL) {
5709 rtw_warn_on(1);
5710 goto exit;
5711 }
5712
5713 dir_odm = rtw_proc_create_dir("odm", adapter->dir_dev, dev);
5714 if (dir_odm == NULL) {
5715 rtw_warn_on(1);
5716 goto exit;
5717 }
5718
5719 adapter->dir_odm = dir_odm;
5720
5721 for (i = 0; i < odm_proc_hdls_num; i++) {
5722 if (odm_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SEQ)
5723 entry = rtw_proc_create_entry(odm_proc_hdls[i].name, dir_odm, &rtw_odm_proc_seq_fops, (void *)i);
5724 else if (odm_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SSEQ ||
5725 odm_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SZSEQ)
5726 entry = rtw_proc_create_entry(odm_proc_hdls[i].name, dir_odm, &rtw_odm_proc_sseq_fops, (void *)i);
5727 else
5728 entry = NULL;
5729
5730 if (!entry) {
5731 rtw_warn_on(1);
5732 goto exit;
5733 }
5734 }
5735
5736 exit:
5737 return dir_odm;
5738 }
5739
rtw_odm_proc_deinit(_adapter * adapter)5740 void rtw_odm_proc_deinit(_adapter *adapter)
5741 {
5742 struct proc_dir_entry *dir_odm = NULL;
5743 int i;
5744
5745 dir_odm = adapter->dir_odm;
5746
5747 if (dir_odm == NULL) {
5748 rtw_warn_on(1);
5749 return;
5750 }
5751
5752 for (i = 0; i < odm_proc_hdls_num; i++)
5753 remove_proc_entry(odm_proc_hdls[i].name, dir_odm);
5754
5755 remove_proc_entry("odm", adapter->dir_dev);
5756
5757 adapter->dir_odm = NULL;
5758
5759 if (phydm_msg) {
5760 rtw_mfree(phydm_msg, PHYDM_MSG_LEN);
5761 phydm_msg = NULL;
5762 }
5763 }
5764
rtw_adapter_proc_init(struct net_device * dev)5765 struct proc_dir_entry *rtw_adapter_proc_init(struct net_device *dev)
5766 {
5767 struct proc_dir_entry *drv_proc = get_rtw_drv_proc();
5768 struct proc_dir_entry *dir_dev = NULL;
5769 struct proc_dir_entry *entry = NULL;
5770 _adapter *adapter = rtw_netdev_priv(dev);
5771 ssize_t i;
5772
5773 if (drv_proc == NULL) {
5774 rtw_warn_on(1);
5775 goto exit;
5776 }
5777
5778 if (adapter->dir_dev != NULL) {
5779 rtw_warn_on(1);
5780 goto exit;
5781 }
5782
5783 dir_dev = rtw_proc_create_dir(dev->name, drv_proc, dev);
5784 if (dir_dev == NULL) {
5785 rtw_warn_on(1);
5786 goto exit;
5787 }
5788
5789 adapter->dir_dev = dir_dev;
5790
5791 for (i = 0; i < adapter_proc_hdls_num; i++) {
5792 if (adapter_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SEQ)
5793 entry = rtw_proc_create_entry(adapter_proc_hdls[i].name, dir_dev, &rtw_adapter_proc_seq_fops, (void *)i);
5794 else if (adapter_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SSEQ ||
5795 adapter_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SZSEQ)
5796 entry = rtw_proc_create_entry(adapter_proc_hdls[i].name, dir_dev, &rtw_adapter_proc_sseq_fops, (void *)i);
5797 else
5798 entry = NULL;
5799
5800 if (!entry) {
5801 rtw_warn_on(1);
5802 goto exit;
5803 }
5804 }
5805
5806 rtw_odm_proc_init(dev);
5807 exit:
5808 return dir_dev;
5809 }
5810
rtw_adapter_proc_deinit(struct net_device * dev)5811 void rtw_adapter_proc_deinit(struct net_device *dev)
5812 {
5813 struct proc_dir_entry *drv_proc = get_rtw_drv_proc();
5814 struct proc_dir_entry *dir_dev = NULL;
5815 _adapter *adapter = rtw_netdev_priv(dev);
5816 int i;
5817
5818 dir_dev = adapter->dir_dev;
5819
5820 if (dir_dev == NULL) {
5821 rtw_warn_on(1);
5822 return;
5823 }
5824
5825 for (i = 0; i < adapter_proc_hdls_num; i++)
5826 remove_proc_entry(adapter_proc_hdls[i].name, dir_dev);
5827
5828 rtw_odm_proc_deinit(adapter);
5829 remove_proc_entry(dev->name, drv_proc);
5830
5831 adapter->dir_dev = NULL;
5832 }
5833
rtw_adapter_proc_replace(struct net_device * dev)5834 void rtw_adapter_proc_replace(struct net_device *dev)
5835 {
5836 struct proc_dir_entry *drv_proc = get_rtw_drv_proc();
5837 struct proc_dir_entry *dir_dev = NULL;
5838 _adapter *adapter = rtw_netdev_priv(dev);
5839 int i;
5840
5841 dir_dev = adapter->dir_dev;
5842
5843 if (dir_dev == NULL) {
5844 rtw_warn_on(1);
5845 return;
5846 }
5847
5848 for (i = 0; i < adapter_proc_hdls_num; i++)
5849 remove_proc_entry(adapter_proc_hdls[i].name, dir_dev);
5850
5851 rtw_odm_proc_deinit(adapter);
5852
5853 remove_proc_entry(adapter->old_ifname, drv_proc);
5854
5855 adapter->dir_dev = NULL;
5856
5857 rtw_adapter_proc_init(dev);
5858
5859 }
5860
5861 #endif /* CONFIG_PROC_DEBUG */
5862