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