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