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