1 /******************************************************************************
3 * Copyright(c) 2007 - 2013 Realtek Corporation. All rights reserved.
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.
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
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
21 #include <linux/ctype.h> /* tolower() */
22 #include <drv_types.h>
25 #ifdef CONFIG_BT_COEXIST
26 #include <rtw_btcoex.h>
29 #ifdef CONFIG_PROC_DEBUG
31 static struct proc_dir_entry *rtw_proc = NULL;
33 inline struct proc_dir_entry *get_rtw_drv_proc(void)
38 #define RTW_PROC_NAME DRV_NAME
40 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0))
41 #define file_inode(file) ((file)->f_dentry->d_inode)
44 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0))
45 #define PDE_DATA(inode) PDE((inode))->data
46 #define proc_get_parent_data(inode) PDE((inode))->parent->data
49 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24))
50 #define get_proc_net proc_net
52 #define get_proc_net init_net.proc_net
55 inline struct proc_dir_entry *rtw_proc_create_dir(const char *name, struct proc_dir_entry *parent, void *data)
57 struct proc_dir_entry *entry;
59 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0))
60 entry = proc_mkdir_data(name, S_IRUGO | S_IXUGO, parent, data);
62 /* entry = proc_mkdir_mode(name, S_IRUGO|S_IXUGO, parent); */
63 entry = proc_mkdir(name, parent);
71 inline struct proc_dir_entry *rtw_proc_create_entry(const char *name, struct proc_dir_entry *parent,
72 const struct file_operations *fops, void * data)
74 struct proc_dir_entry *entry;
76 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 26))
77 entry = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUGO, parent, fops, data);
79 entry = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUGO, parent);
82 entry->proc_fops = fops;
89 static int proc_get_dummy(struct seq_file *m, void *v)
94 static int proc_get_drv_version(struct seq_file *m, void *v)
100 static int proc_get_log_level(struct seq_file *m, void *v)
106 static int proc_get_drv_cfg(struct seq_file *m, void *v)
112 static ssize_t proc_set_log_level(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
120 if (count > sizeof(tmp)) {
125 #ifdef CONFIG_RTW_DEBUG
126 if (buffer && !copy_from_user(tmp, buffer, count)) {
128 int num = sscanf(tmp, "%d ", &log_level);
130 if (log_level >= _DRV_NONE_ && log_level <= _DRV_MAX_) {
131 rtw_drv_log_level = log_level;
132 printk("rtw_drv_log_level:%d\n", rtw_drv_log_level);
137 printk("CONFIG_RTW_DEBUG is disabled\n");
144 static int proc_get_mstat(struct seq_file *m, void *v)
149 #endif /* DBG_MEM_ALLOC */
151 static int proc_get_country_chplan_map(struct seq_file *m, void *v)
153 dump_country_chplan_map(m);
157 static int proc_get_chplan_id_list(struct seq_file *m, void *v)
159 dump_chplan_id_list(m);
163 static int proc_get_chplan_test(struct seq_file *m, void *v)
171 * init/deinit when register/unregister driver
173 const struct rtw_proc_hdl drv_proc_hdls[] = {
174 RTW_PROC_HDL_SSEQ("ver_info", proc_get_drv_version, NULL),
175 RTW_PROC_HDL_SSEQ("log_level", proc_get_log_level, proc_set_log_level),
176 RTW_PROC_HDL_SSEQ("drv_cfg", proc_get_drv_cfg, NULL),
178 RTW_PROC_HDL_SSEQ("mstat", proc_get_mstat, NULL),
179 #endif /* DBG_MEM_ALLOC */
180 RTW_PROC_HDL_SSEQ("country_chplan_map", proc_get_country_chplan_map, NULL),
181 RTW_PROC_HDL_SSEQ("chplan_id_list", proc_get_chplan_id_list, NULL),
182 RTW_PROC_HDL_SSEQ("chplan_test", proc_get_chplan_test, NULL),
185 const int drv_proc_hdls_num = sizeof(drv_proc_hdls) / sizeof(struct rtw_proc_hdl);
187 static int rtw_drv_proc_open(struct inode *inode, struct file *file)
189 /* struct net_device *dev = proc_get_parent_data(inode); */
190 ssize_t index = (ssize_t)PDE_DATA(inode);
191 const struct rtw_proc_hdl *hdl = drv_proc_hdls + index;
192 void *private = NULL;
194 if (hdl->type == RTW_PROC_HDL_TYPE_SEQ) {
195 int res = seq_open(file, hdl->u.seq_op);
198 ((struct seq_file *)file->private_data)->private = private;
201 } else if (hdl->type == RTW_PROC_HDL_TYPE_SSEQ) {
202 int (*show)(struct seq_file *, void *) = hdl->u.show ? hdl->u.show : proc_get_dummy;
204 return single_open(file, show, private);
210 static ssize_t rtw_drv_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos)
212 ssize_t index = (ssize_t)PDE_DATA(file_inode(file));
213 const struct rtw_proc_hdl *hdl = drv_proc_hdls + index;
214 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *, void *) = hdl->write;
217 return write(file, buffer, count, pos, NULL);
222 static const struct file_operations rtw_drv_proc_seq_fops = {
223 .owner = THIS_MODULE,
224 .open = rtw_drv_proc_open,
227 .release = seq_release,
228 .write = rtw_drv_proc_write,
231 static const struct file_operations rtw_drv_proc_sseq_fops = {
232 .owner = THIS_MODULE,
233 .open = rtw_drv_proc_open,
236 .release = single_release,
237 .write = rtw_drv_proc_write,
240 int rtw_drv_proc_init(void)
244 struct proc_dir_entry *entry = NULL;
246 if (rtw_proc != NULL) {
251 rtw_proc = rtw_proc_create_dir(RTW_PROC_NAME, get_proc_net, NULL);
253 if (rtw_proc == NULL) {
258 for (i = 0; i < drv_proc_hdls_num; i++) {
259 if (drv_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SEQ)
260 entry = rtw_proc_create_entry(drv_proc_hdls[i].name, rtw_proc, &rtw_drv_proc_seq_fops, (void *)i);
261 else if (drv_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SSEQ)
262 entry = rtw_proc_create_entry(drv_proc_hdls[i].name, rtw_proc, &rtw_drv_proc_sseq_fops, (void *)i);
278 void rtw_drv_proc_deinit(void)
282 if (rtw_proc == NULL)
285 for (i = 0; i < drv_proc_hdls_num; i++)
286 remove_proc_entry(drv_proc_hdls[i].name, rtw_proc);
288 remove_proc_entry(RTW_PROC_NAME, get_proc_net);
292 #ifndef RTW_SEQ_FILE_TEST
293 #define RTW_SEQ_FILE_TEST 0
296 #if RTW_SEQ_FILE_TEST
297 #define RTW_SEQ_FILE_TEST_SHOW_LIMIT 300
298 static void *proc_start_seq_file_test(struct seq_file *m, loff_t *pos)
300 struct net_device *dev = m->private;
301 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
303 RTW_PRINT(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
304 if (*pos >= RTW_SEQ_FILE_TEST_SHOW_LIMIT) {
305 RTW_PRINT(FUNC_ADPT_FMT" pos:%llu, out of range return\n", FUNC_ADPT_ARG(adapter), *pos);
309 RTW_PRINT(FUNC_ADPT_FMT" return pos:%lld\n", FUNC_ADPT_ARG(adapter), *pos);
312 void proc_stop_seq_file_test(struct seq_file *m, void *v)
314 struct net_device *dev = m->private;
315 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
317 RTW_PRINT(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
320 void *proc_next_seq_file_test(struct seq_file *m, void *v, loff_t *pos)
322 struct net_device *dev = m->private;
323 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
326 if (*pos >= RTW_SEQ_FILE_TEST_SHOW_LIMIT) {
327 RTW_PRINT(FUNC_ADPT_FMT" pos:%lld, out of range return\n", FUNC_ADPT_ARG(adapter), *pos);
331 RTW_PRINT(FUNC_ADPT_FMT" return pos:%lld\n", FUNC_ADPT_ARG(adapter), *pos);
335 static int proc_get_seq_file_test(struct seq_file *m, void *v)
337 struct net_device *dev = m->private;
338 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
340 u32 pos = *((loff_t *)(v));
341 RTW_PRINT(FUNC_ADPT_FMT" pos:%d\n", FUNC_ADPT_ARG(adapter), pos);
342 RTW_PRINT_SEL(m, FUNC_ADPT_FMT" pos:%d\n", FUNC_ADPT_ARG(adapter), pos);
346 struct seq_operations seq_file_test = {
347 .start = proc_start_seq_file_test,
348 .stop = proc_stop_seq_file_test,
349 .next = proc_next_seq_file_test,
350 .show = proc_get_seq_file_test,
352 #endif /* RTW_SEQ_FILE_TEST */
354 #ifdef CONFIG_SDIO_HCI
355 static int proc_get_sd_f0_reg_dump(struct seq_file *m, void *v)
357 struct net_device *dev = m->private;
358 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
360 sd_f0_reg_dump(m, adapter);
365 static int proc_get_sdio_local_reg_dump(struct seq_file *m, void *v)
367 struct net_device *dev = m->private;
368 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
370 sdio_local_reg_dump(m, adapter);
374 #endif /* CONFIG_SDIO_HCI */
376 static int proc_get_mac_reg_dump(struct seq_file *m, void *v)
378 struct net_device *dev = m->private;
379 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
381 mac_reg_dump(m, adapter);
386 static int proc_get_bb_reg_dump(struct seq_file *m, void *v)
388 struct net_device *dev = m->private;
389 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
391 bb_reg_dump(m, adapter);
396 static int proc_get_rf_reg_dump(struct seq_file *m, void *v)
398 struct net_device *dev = m->private;
399 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
401 rf_reg_dump(m, adapter);
406 static int proc_get_dump_tx_rate_bmp(struct seq_file *m, void *v)
408 struct net_device *dev = m->private;
409 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
411 dump_tx_rate_bmp(m, adapter_to_dvobj(adapter));
416 static int proc_get_dump_adapters_status(struct seq_file *m, void *v)
418 struct net_device *dev = m->private;
419 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
421 dump_adapters_status(m, adapter_to_dvobj(adapter));
426 #ifdef CONFIG_RTW_CUSTOMER_STR
427 static int proc_get_customer_str(struct seq_file *m, void *v)
429 struct net_device *dev = m->private;
430 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
431 u8 cstr[RTW_CUSTOMER_STR_LEN];
433 if (rtw_hal_customer_str_read(adapter, cstr) != _SUCCESS)
436 RTW_PRINT_SEL(m, RTW_CUSTOMER_STR_FMT"\n", RTW_CUSTOMER_STR_ARG(cstr));
441 #endif /* CONFIG_RTW_CUSTOMER_STR */
444 #ifdef CONFIG_GPIO_API
445 static ssize_t proc_set_config_gpio(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
447 struct net_device *dev = data;
448 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
450 int num = 0, gpio_pin = 0, gpio_mode = 0; /* gpio_mode:0 input 1:output; */
455 if (count > sizeof(tmp)) {
460 if (buffer && !copy_from_user(tmp, buffer, count)) {
461 num = sscanf(tmp, "%d %d", &gpio_pin, &gpio_mode);
462 RTW_INFO("num=%d gpio_pin=%d mode=%d\n", num, gpio_pin, gpio_mode);
463 padapter->pre_gpio_pin = gpio_pin;
465 if (gpio_mode == 0 || gpio_mode == 1)
466 rtw_hal_config_gpio(padapter, gpio_pin, gpio_mode);
471 static ssize_t proc_set_gpio_output_value(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
473 struct net_device *dev = data;
474 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
476 int num = 0, gpio_pin = 0, pin_mode = 0; /* pin_mode: 1 high 0:low */
481 if (count > sizeof(tmp)) {
486 if (buffer && !copy_from_user(tmp, buffer, count)) {
487 num = sscanf(tmp, "%d %d", &gpio_pin, &pin_mode);
488 RTW_INFO("num=%d gpio_pin=%d pin_high=%d\n", num, gpio_pin, pin_mode);
489 padapter->pre_gpio_pin = gpio_pin;
491 if (pin_mode == 0 || pin_mode == 1)
492 rtw_hal_set_gpio_output_value(padapter, gpio_pin, pin_mode);
496 static int proc_get_gpio(struct seq_file *m, void *v)
498 u8 gpioreturnvalue = 0;
499 struct net_device *dev = m->private;
501 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
504 gpioreturnvalue = rtw_hal_get_gpio(padapter, padapter->pre_gpio_pin);
505 RTW_PRINT_SEL(m, "get_gpio %d:%d\n", padapter->pre_gpio_pin, gpioreturnvalue);
510 static ssize_t proc_set_gpio(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
512 struct net_device *dev = data;
513 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
515 int num = 0, gpio_pin = 0;
520 if (count > sizeof(tmp)) {
525 if (buffer && !copy_from_user(tmp, buffer, count)) {
526 num = sscanf(tmp, "%d", &gpio_pin);
527 RTW_INFO("num=%d gpio_pin=%d\n", num, gpio_pin);
528 padapter->pre_gpio_pin = gpio_pin;
534 static ssize_t proc_set_rx_info_msg(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
537 struct net_device *dev = data;
538 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
539 struct recv_priv *precvpriv = &(padapter->recvpriv);
541 int phy_info_flag = 0;
547 RTW_INFO("argument size is less than 1\n");
551 if (count > sizeof(tmp)) {
556 if (buffer && !copy_from_user(tmp, buffer, count)) {
557 int num = sscanf(tmp, "%d", &phy_info_flag);
559 precvpriv->store_law_data_flag = (BOOLEAN) phy_info_flag;
561 /*RTW_INFO("precvpriv->store_law_data_flag = %d\n",( BOOLEAN )(precvpriv->store_law_data_flag));*/
565 static int proc_get_rx_info_msg(struct seq_file *m, void *v)
567 struct net_device *dev = m->private;
568 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
570 rtw_hal_set_odm_var(padapter, HAL_ODM_RX_Dframe_INFO, m, _FALSE);
573 static int proc_get_tx_info_msg(struct seq_file *m, void *v)
576 struct net_device *dev = m->private;
577 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
578 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
579 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
580 struct sta_info *psta;
581 u8 bc_addr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
582 u8 null_addr[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
583 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
584 struct sta_priv *pstapriv = &padapter->stapriv;
586 _list *plist, *phead;
587 u8 current_rate_id = 0, current_sgi = 0;
591 _enter_critical_bh(&pstapriv->sta_hash_lock, &irqL);
593 if (check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE))
594 status = "station mode";
595 else if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE))
599 _RTW_PRINT_SEL(m, "status=%s\n", status);
600 for (i = 0; i < NUM_STA; i++) {
601 phead = &(pstapriv->sta_hash[i]);
602 plist = get_next(phead);
604 while ((rtw_end_of_queue_search(phead, plist)) == _FALSE) {
606 psta = LIST_CONTAINOR(plist, struct sta_info, hash_list);
608 plist = get_next(plist);
610 if ((_rtw_memcmp(psta->hwaddr, bc_addr, 6) != _TRUE)
611 && (_rtw_memcmp(psta->hwaddr, null_addr, 6) != _TRUE)
612 && (_rtw_memcmp(psta->hwaddr, adapter_mac_addr(padapter), 6) != _TRUE)) {
614 switch (psta->bw_mode) {
616 case CHANNEL_WIDTH_20:
620 case CHANNEL_WIDTH_40:
624 case CHANNEL_WIDTH_80:
628 case CHANNEL_WIDTH_160:
636 current_rate_id = rtw_get_current_tx_rate(adapter, psta->mac_id);
637 current_sgi = rtw_get_current_tx_sgi(adapter, psta->mac_id);
639 RTW_PRINT_SEL(m, "==============================\n");
640 _RTW_PRINT_SEL(m, "macaddr=" MAC_FMT"\n", MAC_ARG(psta->hwaddr));
641 _RTW_PRINT_SEL(m, "Tx_Data_Rate=%s\n", HDATA_RATE(current_rate_id));
642 _RTW_PRINT_SEL(m, "BW=%s,sgi=%u\n", BW, current_sgi);
648 _exit_critical_bh(&pstapriv->sta_hash_lock, &irqL);
655 static int proc_get_linked_info_dump(struct seq_file *m, void *v)
657 struct net_device *dev = m->private;
658 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
660 RTW_PRINT_SEL(m, "linked_info_dump :%s\n", (padapter->bLinkInfoDump) ? "enable" : "disable");
666 static ssize_t proc_set_linked_info_dump(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
668 struct net_device *dev = data;
669 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
672 int mode = 0, pre_mode = 0;
678 if (count > sizeof(tmp)) {
683 pre_mode = padapter->bLinkInfoDump;
684 RTW_INFO("pre_mode=%d\n", pre_mode);
686 if (buffer && !copy_from_user(tmp, buffer, count)) {
688 num = sscanf(tmp, "%d ", &mode);
689 RTW_INFO("num=%d mode=%d\n", num, mode);
692 RTW_INFO("argument number is wrong\n");
696 if (mode == 1 || (mode == 0 && pre_mode == 1)) /* not consider pwr_saving 0: */
697 padapter->bLinkInfoDump = mode;
699 else if ((mode == 2) || (mode == 0 && pre_mode == 2)) { /* consider power_saving */
700 /* RTW_INFO("linked_info_dump =%s\n", (padapter->bLinkInfoDump)?"enable":"disable") */
701 linked_info_dump(padapter, mode);
707 static int proc_get_mac_qinfo(struct seq_file *m, void *v)
709 struct net_device *dev = m->private;
710 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
712 rtw_hal_get_hwreg(adapter, HW_VAR_DUMP_MAC_QUEUE_INFO, (u8 *)m);
717 int proc_get_wifi_spec(struct seq_file *m, void *v)
719 struct net_device *dev = m->private;
720 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
721 struct registry_priv *pregpriv = &padapter->registrypriv;
723 RTW_PRINT_SEL(m, "wifi_spec=%d\n", pregpriv->wifi_spec);
727 static int proc_get_chan_plan(struct seq_file *m, void *v)
729 struct net_device *dev = m->private;
730 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
732 dump_cur_chset(m, adapter);
737 static ssize_t proc_set_chan_plan(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
739 struct net_device *dev = data;
740 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
742 u8 chan_plan = RTW_CHPLAN_MAX;
748 RTW_INFO("argument size is less than 1\n");
752 if (count > sizeof(tmp)) {
757 if (buffer && !copy_from_user(tmp, buffer, count)) {
758 int num = sscanf(tmp, "%hhx", &chan_plan);
763 rtw_set_channel_plan(padapter, chan_plan);
768 static int proc_get_country_code(struct seq_file *m, void *v)
770 struct net_device *dev = m->private;
771 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
773 if (adapter->mlmepriv.country_ent)
774 dump_country_chplan(m, adapter->mlmepriv.country_ent);
776 RTW_PRINT_SEL(m, "unspecified\n");
781 static ssize_t proc_set_country_code(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
783 struct net_device *dev = data;
784 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
792 if (count > sizeof(tmp)) {
797 if (!buffer || copy_from_user(tmp, buffer, count))
800 num = sscanf(tmp, "%c%c", &alpha2[0], &alpha2[1]);
804 rtw_set_country(padapter, alpha2);
810 #if CONFIG_RTW_MACADDR_ACL
811 static int proc_get_macaddr_acl(struct seq_file *m, void *v)
813 struct net_device *dev = m->private;
814 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
816 dump_macaddr_acl(m, adapter);
820 ssize_t proc_set_macaddr_acl(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
822 struct net_device *dev = data;
823 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
824 struct mlme_priv *mlme = &adapter->mlmepriv;
825 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
826 char tmp[17 * NUM_ACL + 32] = {0};
833 if (count > sizeof(tmp)) {
838 if (buffer && !copy_from_user(tmp, buffer, count)) {
839 /* mode [<macaddr>] */
843 c = strsep(&next, " \t");
845 if (sscanf(c, "%hhu", &mode) != 1)
848 if (mode >= RTW_ACL_MODE_MAX)
849 mode = RTW_ACL_MODE_DISABLED;
851 rtw_set_macaddr_acl(adapter, RTW_ACL_MODE_DISABLED); /* deinit first */
852 if (mode == RTW_ACL_MODE_DISABLED)
855 rtw_set_macaddr_acl(adapter, mode);
858 c = strsep(&next, " \t");
860 if (sscanf(c, MAC_SFMT, MAC_SARG(addr)) != 6)
863 if (rtw_check_invalid_mac_address(addr, 0) == _FALSE)
864 rtw_acl_add_sta(adapter, addr);
866 c = strsep(&next, " \t");
874 #endif /* CONFIG_RTW_MACADDR_ACL */
876 #ifdef CONFIG_DFS_MASTER
877 ssize_t proc_set_update_non_ocp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
879 struct net_device *dev = data;
880 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
881 struct mlme_priv *mlme = &adapter->mlmepriv;
882 struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
884 u8 ch, bw = CHANNEL_WIDTH_20, offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
890 if (count > sizeof(tmp)) {
895 if (buffer && !copy_from_user(tmp, buffer, count)) {
897 int num = sscanf(tmp, "%hhu %hhu %hhu %d", &ch, &bw, &offset, &ms);
899 if (num < 1 || (bw != CHANNEL_WIDTH_20 && num < 3))
902 if (bw == CHANNEL_WIDTH_20)
903 rtw_chset_update_non_ocp_ms(mlmeext->channel_set
904 , ch, bw, HAL_PRIME_CHNL_OFFSET_DONT_CARE, ms);
906 rtw_chset_update_non_ocp_ms(mlmeext->channel_set
907 , ch, bw, offset, ms);
914 ssize_t proc_set_radar_detect(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
916 struct net_device *dev = data;
917 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
918 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
920 u8 fake_radar_detect_cnt = 0;
925 if (count > sizeof(tmp)) {
930 if (buffer && !copy_from_user(tmp, buffer, count)) {
932 int num = sscanf(tmp, "%hhu", &fake_radar_detect_cnt);
937 rfctl->dbg_dfs_master_fake_radar_detect_cnt = fake_radar_detect_cnt;
944 static int proc_get_dfs_ch_sel_d_flags(struct seq_file *m, void *v)
946 struct net_device *dev = m->private;
947 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
948 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
950 RTW_PRINT_SEL(m, "0x%02x\n", rfctl->dfs_ch_sel_d_flags);
955 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)
957 struct net_device *dev = data;
958 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
959 struct rf_ctl_t *rfctl = adapter_to_rfctl(adapter);
967 if (count > sizeof(tmp)) {
972 if (!buffer || copy_from_user(tmp, buffer, count))
975 num = sscanf(tmp, "%hhx", &d_flags);
979 rfctl->dfs_ch_sel_d_flags = d_flags;
984 #endif /* CONFIG_DFS_MASTER */
986 static int proc_get_udpport(struct seq_file *m, void *v)
988 struct net_device *dev = m->private;
989 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
990 struct recv_priv *precvpriv = &(padapter->recvpriv);
992 RTW_PRINT_SEL(m, "%d\n", precvpriv->sink_udpport);
995 static ssize_t proc_set_udpport(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
997 struct net_device *dev = data;
998 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
999 struct recv_priv *precvpriv = &(padapter->recvpriv);
1000 int sink_udpport = 0;
1008 RTW_INFO("argument size is less than 1\n");
1012 if (count > sizeof(tmp)) {
1017 if (buffer && !copy_from_user(tmp, buffer, count)) {
1019 int num = sscanf(tmp, "%d", &sink_udpport);
1022 RTW_INFO("invalid input parameter number!\n");
1027 precvpriv->sink_udpport = sink_udpport;
1033 static int proc_get_mi_ap_bc_info(struct seq_file *m, void *v)
1035 struct net_device *dev = m->private;
1036 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1037 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1038 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
1041 for (i = 0; i < dvobj->iface_nums; i++)
1042 RTW_PRINT_SEL(m, "iface_id:%d, mac_id && sec_cam_id = %d\n", i, macid_ctl->iface_bmc[i]);
1046 static int proc_get_macid_info(struct seq_file *m, void *v)
1048 struct net_device *dev = m->private;
1049 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1050 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1051 struct macid_ctl_t *macid_ctl = dvobj_to_macidctl(dvobj);
1052 u8 chip_type = rtw_get_chip_type(adapter);
1054 u8 null_addr[ETH_ALEN] = {0};
1057 RTW_PRINT_SEL(m, "max_num:%u\n", macid_ctl->num);
1058 RTW_PRINT_SEL(m, "\n");
1060 RTW_PRINT_SEL(m, "used:\n");
1061 dump_macid_map(m, &macid_ctl->used, macid_ctl->num);
1062 RTW_PRINT_SEL(m, "\n");
1064 RTW_PRINT_SEL(m, "%-3s %-3s %-4s %-4s %-17s %-6s %-3s"
1065 , "id", "bmc", "if_g", "ch_g", "macaddr", "bw", "vht");
1067 if (chip_type == RTL8814A)
1068 _RTW_PRINT_SEL(m, " %-10s", "rate_bmp1");
1070 _RTW_PRINT_SEL(m, " %-10s %s\n", "rate_bmp0", "status");
1072 for (i = 0; i < macid_ctl->num; i++) {
1073 if (rtw_macid_is_used(macid_ctl, i)
1074 || macid_ctl->h2c_msr[i]
1076 if (macid_ctl->sta[i])
1077 macaddr = macid_ctl->sta[i]->hwaddr;
1079 macaddr = null_addr;
1081 RTW_PRINT_SEL(m, "%3u %3u %4d %4d "MAC_FMT" %6s %3u"
1083 , rtw_macid_is_bmc(macid_ctl, i)
1084 , rtw_macid_get_if_g(macid_ctl, i)
1085 , rtw_macid_get_ch_g(macid_ctl, i)
1087 , ch_width_str(macid_ctl->bw[i])
1088 , macid_ctl->vht_en[i]
1091 if (chip_type == RTL8814A)
1092 _RTW_PRINT_SEL(m, " 0x%08X", macid_ctl->rate_bmp1[i]);
1094 _RTW_PRINT_SEL(m, " 0x%08X "H2C_MSR_FMT" %s\n"
1095 , macid_ctl->rate_bmp0[i]
1096 , H2C_MSR_ARG(&macid_ctl->h2c_msr[i])
1097 , rtw_macid_is_used(macid_ctl, i) ? "" : "[unused]"
1105 static int proc_get_sec_cam(struct seq_file *m, void *v)
1107 struct net_device *dev = m->private;
1108 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1109 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1110 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
1112 RTW_PRINT_SEL(m, "sec_cap:0x%02x\n", cam_ctl->sec_cap);
1113 RTW_PRINT_SEL(m, "flags:0x%08x\n", cam_ctl->flags);
1114 RTW_PRINT_SEL(m, "\n");
1116 RTW_PRINT_SEL(m, "max_num:%u\n", cam_ctl->num);
1117 RTW_PRINT_SEL(m, "used:\n");
1118 dump_sec_cam_map(m, &cam_ctl->used, cam_ctl->num);
1119 RTW_PRINT_SEL(m, "\n");
1121 RTW_PRINT_SEL(m, "reg_scr:0x%04x\n", rtw_read16(adapter, 0x680));
1122 RTW_PRINT_SEL(m, "\n");
1124 dump_sec_cam(m, adapter);
1129 static ssize_t proc_set_sec_cam(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1131 struct net_device *dev = data;
1132 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1133 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1134 struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
1137 u8 id_1 = 0, id_2 = 0;
1139 if (count > sizeof(tmp)) {
1144 if (buffer && !copy_from_user(tmp, buffer, count)) {
1146 /* c <id_1>: clear specific cam entry */
1147 /* wfc <id_1>: write specific cam entry from cam cache */
1148 /* sw <id_1> <id_2>: sec_cam 1/2 swap */
1150 int num = sscanf(tmp, "%s %hhu %hhu", cmd, &id_1, &id_2);
1155 if ((id_1 >= cam_ctl->num) || (id_2 >= cam_ctl->num)) {
1156 RTW_ERR(FUNC_ADPT_FMT" invalid id_1:%u id_2:%u\n", FUNC_ADPT_ARG(adapter), id_1, id_2);
1160 if (strcmp("c", cmd) == 0) {
1161 _clear_cam_entry(adapter, id_1);
1162 adapter->securitypriv.hw_decrypted = _FALSE; /* temporarily set this for TX path to use SW enc */
1163 } else if (strcmp("wfc", cmd) == 0)
1164 write_cam_from_cache(adapter, id_1);
1165 else if (strcmp("sw", cmd) == 0)
1166 rtw_sec_cam_swap(adapter, id_1, id_2);
1167 else if (strcmp("cdk", cmd) == 0)
1168 rtw_clean_dk_section(adapter);
1169 #ifdef DBG_SEC_CAM_MOVE
1170 else if (strcmp("sgd", cmd) == 0)
1171 rtw_hal_move_sta_gk_to_dk(adapter);
1172 else if (strcmp("rsd", cmd) == 0)
1173 rtw_hal_read_sta_dk_key(adapter, id_1);
1180 static int proc_get_sec_cam_cache(struct seq_file *m, void *v)
1182 struct net_device *dev = m->private;
1183 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1185 dump_sec_cam_cache(m, adapter);
1189 static ssize_t proc_set_change_bss_chbw(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1191 struct net_device *dev = data;
1192 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1193 struct mlme_priv *mlme = &(adapter->mlmepriv);
1194 struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv);
1197 s8 bw = -1, offset = -1;
1202 if (count > sizeof(tmp)) {
1207 if (buffer && !copy_from_user(tmp, buffer, count)) {
1209 int num = sscanf(tmp, "%hd %hhd %hhd", &ch, &bw, &offset);
1211 if (num < 1 || (bw != CHANNEL_WIDTH_20 && num < 3))
1214 if (check_fwstate(mlme, WIFI_AP_STATE) && check_fwstate(mlme, WIFI_ASOC_STATE))
1215 rtw_change_bss_chbw_cmd(adapter, RTW_CMDF_WAIT_ACK, ch, bw, offset);
1222 #ifdef CONFIG_80211N_HT
1223 static int proc_get_tx_bw_mode(struct seq_file *m, void *v)
1225 struct net_device *dev = m->private;
1226 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1228 RTW_PRINT_SEL(m, "0x%02x\n", adapter->driver_tx_bw_mode);
1229 RTW_PRINT_SEL(m, "2.4G:%s\n", ch_width_str(ADAPTER_TX_BW_2G(adapter)));
1230 RTW_PRINT_SEL(m, "5G:%s\n", ch_width_str(ADAPTER_TX_BW_5G(adapter)));
1235 static ssize_t proc_set_tx_bw_mode(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1237 struct net_device *dev = data;
1238 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1239 struct macid_ctl_t *macid_ctl = &adapter->dvobj->macid_ctl;
1240 struct mlme_priv *mlme = &(adapter->mlmepriv);
1241 struct mlme_ext_priv *mlmeext = &(adapter->mlmeextpriv);
1248 if (count > sizeof(tmp)) {
1253 if (buffer && !copy_from_user(tmp, buffer, count)) {
1256 int num = sscanf(tmp, "%hhx", &bw_mode);
1258 if (num < 1 || bw_mode == adapter->driver_tx_bw_mode)
1261 if ((MLME_STATE(adapter) & WIFI_ASOC_STATE)
1262 && ((mlmeext->cur_channel <= 14 && BW_MODE_2G(bw_mode) != ADAPTER_TX_BW_2G(adapter))
1263 || (mlmeext->cur_channel >= 36 && BW_MODE_5G(bw_mode) != ADAPTER_TX_BW_5G(adapter)))
1265 /* RA mask update needed */
1268 adapter->driver_tx_bw_mode = bw_mode;
1270 if (update == _TRUE) {
1271 struct sta_info *sta;
1274 for (i = 0; i < MACID_NUM_SW_LIMIT; i++) {
1275 sta = macid_ctl->sta[i];
1276 if (sta && !is_broadcast_mac_addr(sta->hwaddr))
1277 rtw_dm_ra_mask_wk_cmd(adapter, (u8 *)sta);
1285 #endif /* CONFIG_80211N_HT */
1287 static int proc_get_hal_txpwr_info(struct seq_file *m, void *v)
1289 struct net_device *dev = m->private;
1290 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1291 struct hal_spec_t *hal_spec = GET_HAL_SPEC(adapter);
1293 if (hal_is_band_support(adapter, BAND_ON_2_4G))
1294 dump_hal_txpwr_info_2g(m, adapter, hal_spec->rfpath_num_2g, hal_spec->max_tx_cnt);
1296 #ifdef CONFIG_IEEE80211_BAND_5GHZ
1297 if (hal_is_band_support(adapter, BAND_ON_5G))
1298 dump_hal_txpwr_info_5g(m, adapter, hal_spec->rfpath_num_5g, hal_spec->max_tx_cnt);
1304 static int proc_get_target_tx_power(struct seq_file *m, void *v)
1306 struct net_device *dev = m->private;
1307 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1309 dump_target_tx_power(m, adapter);
1314 static int proc_get_tx_power_by_rate(struct seq_file *m, void *v)
1316 struct net_device *dev = m->private;
1317 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1319 dump_tx_power_by_rate(m, adapter);
1324 static int proc_get_tx_power_limit(struct seq_file *m, void *v)
1326 struct net_device *dev = m->private;
1327 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1329 dump_tx_power_limit(m, adapter);
1334 static int proc_get_tx_power_ext_info(struct seq_file *m, void *v)
1336 struct net_device *dev = m->private;
1337 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1339 dump_tx_power_ext_info(m, adapter);
1344 static ssize_t proc_set_tx_power_ext_info(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1346 struct net_device *dev = data;
1347 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1352 if (count > sizeof(tmp)) {
1357 if (buffer && !copy_from_user(tmp, buffer, count)) {
1359 int num = sscanf(tmp, "%s", cmd);
1364 #ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
1365 phy_free_filebuf_mask(adapter, LOAD_BB_PG_PARA_FILE | LOAD_RF_TXPWR_LMT_PARA_FILE);
1368 rtw_ps_deny(adapter, PS_DENY_IOCTL);
1369 LeaveAllPowerSaveModeDirect(adapter);
1371 if (strcmp("default", cmd) == 0)
1372 rtw_run_in_thread_cmd(adapter, ((void *)(phy_reload_default_tx_power_ext_info)), adapter);
1374 rtw_run_in_thread_cmd(adapter, ((void *)(phy_reload_tx_power_ext_info)), adapter);
1376 rtw_ps_deny_cancel(adapter, PS_DENY_IOCTL);
1382 static void *proc_start_tx_power_idx(struct seq_file *m, loff_t *pos)
1384 struct net_device *dev = m->private;
1385 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1386 u8 path = ((*pos) & 0xFF00) >> 8;
1387 u8 rs = *pos & 0xFF;
1389 if (path >= RF_PATH_MAX)
1394 static void proc_stop_tx_power_idx(struct seq_file *m, void *v)
1396 struct net_device *dev = m->private;
1397 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1400 static void *proc_next_tx_power_idx(struct seq_file *m, void *v, loff_t *pos)
1402 struct net_device *dev = m->private;
1403 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1404 u8 path = ((*pos) & 0xFF00) >> 8;
1405 u8 rs = *pos & 0xFF;
1408 if (rs >= RATE_SECTION_NUM) {
1413 if (path >= RF_PATH_MAX)
1416 *pos = (path << 8) | rs;
1421 static int proc_get_tx_power_idx(struct seq_file *m, void *v)
1423 struct net_device *dev = m->private;
1424 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1425 u32 pos = *((loff_t *)(v));
1426 u8 path = (pos & 0xFF00) >> 8;
1430 RTW_INFO("%s path=%u, rs=%u\n", __func__, path, rs);
1432 if (path == RF_PATH_A && rs == CCK)
1433 dump_tx_power_idx_title(m, adapter);
1434 dump_tx_power_idx_by_path_rs(m, adapter, path, rs);
1439 static struct seq_operations seq_ops_tx_power_idx = {
1440 .start = proc_start_tx_power_idx,
1441 .stop = proc_stop_tx_power_idx,
1442 .next = proc_next_tx_power_idx,
1443 .show = proc_get_tx_power_idx,
1446 #ifdef CONFIG_RF_POWER_TRIM
1447 static int proc_get_kfree_flag(struct seq_file *m, void *v)
1449 struct net_device *dev = m->private;
1450 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1451 struct kfree_data_t *kfree_data = GET_KFREE_DATA(adapter);
1453 RTW_PRINT_SEL(m, "0x%02x\n", kfree_data->flag);
1458 static ssize_t proc_set_kfree_flag(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1460 struct net_device *dev = data;
1461 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1462 struct kfree_data_t *kfree_data = GET_KFREE_DATA(adapter);
1466 if (count > sizeof(tmp)) {
1471 if (buffer && !copy_from_user(tmp, buffer, count)) {
1473 int num = sscanf(tmp, "%hhx", &flag);
1478 kfree_data->flag = flag;
1484 static int proc_get_kfree_bb_gain(struct seq_file *m, void *v)
1486 struct net_device *dev = m->private;
1487 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1488 HAL_DATA_TYPE *hal_data = GET_HAL_DATA(adapter);
1489 struct kfree_data_t *kfree_data = GET_KFREE_DATA(adapter);
1492 for (i = 0; i < BB_GAIN_NUM; i++) {
1494 _RTW_PRINT_SEL(m, "2G: ");
1496 _RTW_PRINT_SEL(m, "5GLB1: ");
1498 _RTW_PRINT_SEL(m, "5GLB2: ");
1500 _RTW_PRINT_SEL(m, "5GMB1: ");
1502 _RTW_PRINT_SEL(m, "5GMB2: ");
1504 _RTW_PRINT_SEL(m, "5GHB: ");
1506 for (j = 0; j < hal_data->NumTotalRFPath; j++)
1507 _RTW_PRINT_SEL(m, "%d ", kfree_data->bb_gain[i][j]);
1508 _RTW_PRINT_SEL(m, "\n");
1514 static ssize_t proc_set_kfree_bb_gain(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1516 struct net_device *dev = data;
1517 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1518 HAL_DATA_TYPE *hal_data = GET_HAL_DATA(adapter);
1519 struct kfree_data_t *kfree_data = GET_KFREE_DATA(adapter);
1520 char tmp[BB_GAIN_NUM * RF_PATH_MAX] = {0};
1522 s8 bb_gain[BB_GAIN_NUM];
1523 char ch_band_Group[6];
1525 if (count > sizeof(tmp)) {
1530 if (buffer && !copy_from_user(tmp, buffer, count)) {
1535 c = strsep(&next, " \t");
1537 if (sscanf(c, "%s", ch_band_Group) != 1) {
1538 RTW_INFO("Error Head Format, channel Group select\n,Please input:\t 2G , 5GLB1 , 5GLB2 , 5GMB1 , 5GMB2 , 5GHB\n");
1541 if (strcmp("2G", ch_band_Group) == 0)
1543 #ifdef CONFIG_IEEE80211_BAND_5GHZ
1544 else if (strcmp("5GLB1", ch_band_Group) == 0)
1545 chidx = BB_GAIN_5GLB1;
1546 else if (strcmp("5GLB2", ch_band_Group) == 0)
1547 chidx = BB_GAIN_5GLB2;
1548 else if (strcmp("5GMB1", ch_band_Group) == 0)
1549 chidx = BB_GAIN_5GMB1;
1550 else if (strcmp("5GMB2", ch_band_Group) == 0)
1551 chidx = BB_GAIN_5GMB2;
1552 else if (strcmp("5GHB", ch_band_Group) == 0)
1553 chidx = BB_GAIN_5GHB;
1554 #endif /*CONFIG_IEEE80211_BAND_5GHZ*/
1556 RTW_INFO("Error Head Format, channel Group select\n,Please input:\t 2G , 5GLB1 , 5GLB2 , 5GMB1 , 5GMB2 , 5GHB\n");
1559 c = strsep(&next, " \t");
1562 if (sscanf(c, "%hhx", &bb_gain[i]) != 1)
1565 kfree_data->bb_gain[chidx][i] = bb_gain[i];
1566 RTW_INFO("%s,kfree_data->bb_gain[%d][%d]=%x\n", __func__, chidx, i, kfree_data->bb_gain[chidx][i]);
1568 c = strsep(&next, " \t");
1578 static int proc_get_kfree_thermal(struct seq_file *m, void *v)
1580 struct net_device *dev = m->private;
1581 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1582 struct kfree_data_t *kfree_data = GET_KFREE_DATA(adapter);
1584 _RTW_PRINT_SEL(m, "%d\n", kfree_data->thermal);
1589 static ssize_t proc_set_kfree_thermal(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1591 struct net_device *dev = data;
1592 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1593 struct kfree_data_t *kfree_data = GET_KFREE_DATA(adapter);
1597 if (count > sizeof(tmp)) {
1602 if (buffer && !copy_from_user(tmp, buffer, count)) {
1604 int num = sscanf(tmp, "%hhd", &thermal);
1609 kfree_data->thermal = thermal;
1615 static ssize_t proc_set_tx_gain_offset(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1617 struct net_device *dev = data;
1623 adapter = (_adapter *)rtw_netdev_priv(dev);
1627 if (count > sizeof(tmp)) {
1632 if (buffer && !copy_from_user(tmp, buffer, count)) {
1634 int num = sscanf(tmp, "%hhu %hhd", &rf_path, &offset);
1639 RTW_INFO("write rf_path:%u tx gain offset:%d\n", rf_path, offset);
1640 rtw_rf_set_tx_gain_offset(adapter, rf_path, offset);
1645 #endif /* CONFIG_RF_POWER_TRIM */
1647 #ifdef CONFIG_BT_COEXIST
1648 ssize_t proc_set_btinfo_evt(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1650 struct net_device *dev = data;
1651 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1658 if (count > sizeof(tmp)) {
1663 if (buffer && !copy_from_user(tmp, buffer, count)) {
1666 _rtw_memset(btinfo, 0, 8);
1668 num = sscanf(tmp, "%hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx"
1669 , &btinfo[0], &btinfo[1], &btinfo[2], &btinfo[3]
1670 , &btinfo[4], &btinfo[5], &btinfo[6], &btinfo[7]);
1675 btinfo[1] = num - 2;
1677 rtw_btinfo_cmd(padapter, btinfo, btinfo[1] + 2);
1683 static u8 btreg_read_type = 0;
1684 static u16 btreg_read_addr = 0;
1685 static int btreg_read_error = 0;
1686 static u8 btreg_write_type = 0;
1687 static u16 btreg_write_addr = 0;
1688 static int btreg_write_error = 0;
1690 static u8 *btreg_type[] = {
1698 static int btreg_parse_str(char const *input, u8 *type, u16 *addr, u16 *val)
1708 num = sscanf(input, "%s %x %x", str, &a, &v);
1710 RTW_INFO("%s: INVALID input!(%s)\n", __FUNCTION__, input);
1713 if ((num < 3) && val) {
1714 RTW_INFO("%s: INVALID input!(%s)\n", __FUNCTION__, input);
1718 /* convert to lower case for following type compare */
1722 n = sizeof(btreg_type) / sizeof(btreg_type[0]);
1723 for (i = 0; i < n; i++) {
1724 if (!strcmp(str, btreg_type[i])) {
1730 RTW_INFO("%s: unknown type(%s)!\n", __FUNCTION__, str);
1737 if (a & 0xFFFFFF80) {
1738 RTW_INFO("%s: INVALID address(0x%X) for type %s(%d)!\n",
1739 __FUNCTION__, a, btreg_type[t], t);
1745 if (a & 0xFFFFFE00) {
1746 RTW_INFO("%s: INVALID address(0x%X) for type %s(%d)!\n",
1747 __FUNCTION__, a, btreg_type[t], t);
1752 /* Others(Bluewize, Vendor, LE) */
1753 if (a & 0xFFFFF000) {
1754 RTW_INFO("%s: INVALID address(0x%X) for type %s(%d)!\n",
1755 __FUNCTION__, a, btreg_type[t], t);
1762 if (v & 0xFFFF0000) {
1763 RTW_INFO("%s: INVALID value(0x%x)!\n", __FUNCTION__, v);
1775 int proc_get_btreg_read(struct seq_file *m, void *v)
1777 struct net_device *dev;
1783 if (btreg_read_error)
1784 return btreg_read_error;
1787 padapter = (PADAPTER)rtw_netdev_priv(dev);
1789 ret = rtw_btcoex_btreg_read(padapter, btreg_read_type, btreg_read_addr, &data);
1790 if (CHECK_STATUS_CODE_FROM_BT_MP_OPER_RET(ret, BT_STATUS_BT_OP_SUCCESS))
1791 RTW_PRINT_SEL(m, "BTREG read: (%s)0x%04X = 0x%08x\n", btreg_type[btreg_read_type], btreg_read_addr, data);
1793 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);
1798 ssize_t proc_set_btreg_read(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1800 struct net_device *dev = data;
1807 padapter = (PADAPTER)rtw_netdev_priv(dev);
1809 if (NULL == buffer) {
1810 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n",
1811 FUNC_ADPT_ARG(padapter));
1817 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n",
1818 FUNC_ADPT_ARG(padapter));
1824 if (num > (sizeof(tmp) - 1))
1825 num = (sizeof(tmp) - 1);
1827 if (copy_from_user(tmp, buffer, num)) {
1828 RTW_INFO(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
1829 FUNC_ADPT_ARG(padapter));
1833 /* [Coverity] sure tmp end with '\0'(string terminal) */
1834 tmp[sizeof(tmp) - 1] = 0;
1836 err = btreg_parse_str(tmp, &btreg_read_type, &btreg_read_addr, NULL);
1840 RTW_INFO(FUNC_ADPT_FMT ": addr=(%s)0x%X\n",
1841 FUNC_ADPT_ARG(padapter), btreg_type[btreg_read_type], btreg_read_addr);
1844 btreg_read_error = err;
1849 int proc_get_btreg_write(struct seq_file *m, void *v)
1851 struct net_device *dev;
1857 if (btreg_write_error < 0)
1858 return btreg_write_error;
1859 else if (btreg_write_error > 0) {
1860 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);
1865 padapter = (PADAPTER)rtw_netdev_priv(dev);
1867 ret = rtw_btcoex_btreg_read(padapter, btreg_write_type, btreg_write_addr, &data);
1868 if (CHECK_STATUS_CODE_FROM_BT_MP_OPER_RET(ret, BT_STATUS_BT_OP_SUCCESS))
1869 RTW_PRINT_SEL(m, "BTREG read: (%s)0x%04X = 0x%08x\n", btreg_type[btreg_write_type], btreg_write_addr, data);
1871 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);
1876 ssize_t proc_set_btreg_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1878 struct net_device *dev = data;
1887 padapter = (PADAPTER)rtw_netdev_priv(dev);
1889 if (NULL == buffer) {
1890 RTW_INFO(FUNC_ADPT_FMT ": input buffer is NULL!\n",
1891 FUNC_ADPT_ARG(padapter));
1897 RTW_INFO(FUNC_ADPT_FMT ": input length is 0!\n",
1898 FUNC_ADPT_ARG(padapter));
1904 if (num > (sizeof(tmp) - 1))
1905 num = (sizeof(tmp) - 1);
1907 if (copy_from_user(tmp, buffer, num)) {
1908 RTW_INFO(FUNC_ADPT_FMT ": copy buffer from user space FAIL!\n",
1909 FUNC_ADPT_ARG(padapter));
1914 err = btreg_parse_str(tmp, &btreg_write_type, &btreg_write_addr, &val);
1918 RTW_INFO(FUNC_ADPT_FMT ": Set (%s)0x%X = 0x%x\n",
1919 FUNC_ADPT_ARG(padapter), btreg_type[btreg_write_type], btreg_write_addr, val);
1921 ret = rtw_btcoex_btreg_write(padapter, btreg_write_type, btreg_write_addr, val);
1922 if (!CHECK_STATUS_CODE_FROM_BT_MP_OPER_RET(ret, BT_STATUS_BT_OP_SUCCESS))
1926 btreg_write_error = err;
1930 #endif /* CONFIG_BT_COEXIST */
1932 #ifdef CONFIG_MBSSID_CAM
1933 int proc_get_mbid_cam_cache(struct seq_file *m, void *v)
1935 struct net_device *dev = m->private;
1936 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1938 rtw_mbid_cam_cache_dump(m, __func__, adapter);
1939 rtw_mbid_cam_dump(m, __func__, adapter);
1942 #endif /* CONFIG_MBSSID_CAM */
1944 int proc_get_mac_addr(struct seq_file *m, void *v)
1946 struct net_device *dev = m->private;
1947 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1949 rtw_hal_dump_macaddr(m, adapter);
1953 static int proc_get_skip_band(struct seq_file *m, void *v)
1955 struct net_device *dev = m->private;
1956 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
1959 bandskip = RTW_GET_SCAN_BAND_SKIP(adapter);
1960 RTW_PRINT_SEL(m, "bandskip:0x%02x\n", bandskip);
1964 static ssize_t proc_set_skip_band(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
1966 struct net_device *dev = data;
1967 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
1974 if (count > sizeof(tmp)) {
1978 if (buffer && !copy_from_user(tmp, buffer, count)) {
1980 int num = sscanf(tmp, "%hhu", &skip_band);
1986 RTW_SET_SCAN_BAND_SKIP(padapter, BAND_24G);
1987 else if (2 == skip_band)
1988 RTW_SET_SCAN_BAND_SKIP(padapter, BAND_5G);
1989 else if (3 == skip_band)
1990 RTW_CLR_SCAN_BAND_SKIP(padapter, BAND_24G);
1991 else if (4 == skip_band)
1992 RTW_CLR_SCAN_BAND_SKIP(padapter, BAND_5G);
1998 #ifdef CONFIG_AUTO_CHNL_SEL_NHM
1999 static int proc_get_best_chan(struct seq_file *m, void *v)
2001 struct net_device *dev = m->private;
2002 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2003 u8 best_24g_ch = 0, best_5g_ch = 0;
2005 rtw_hal_get_odm_var(adapter, HAL_ODM_AUTO_CHNL_SEL, &(best_24g_ch), &(best_5g_ch));
2007 RTW_PRINT_SEL(m, "Best 2.4G CH:%u\n", best_24g_ch);
2008 RTW_PRINT_SEL(m, "Best 5G CH:%u\n", best_5g_ch);
2012 static ssize_t proc_set_acs(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2014 struct net_device *dev = data;
2015 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2022 if (count > sizeof(tmp)) {
2026 if (buffer && !copy_from_user(tmp, buffer, count)) {
2028 int num = sscanf(tmp, "%hhu", &acs_satae);
2034 rtw_acs_start(padapter, _TRUE);
2036 rtw_acs_start(padapter, _FALSE);
2043 static int proc_get_hal_spec(struct seq_file *m, void *v)
2045 struct net_device *dev = m->private;
2046 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2048 dump_hal_spec(m, adapter);
2052 #ifdef CONFIG_SUPPORT_TRX_SHARED
2053 #include "../../hal/hal_halmac.h"
2054 static int proc_get_trx_share_mode(struct seq_file *m, void *v)
2056 struct net_device *dev = m->private;
2057 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2059 dump_trx_share_mode(m, adapter);
2064 static int proc_get_napi_info(struct seq_file *m, void *v)
2066 struct net_device *dev = m->private;
2067 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2068 struct registry_priv *pregistrypriv = &adapter->registrypriv;
2069 u8 napi = 0, gro = 0;
2073 #ifdef CONFIG_RTW_NAPI
2074 if (pregistrypriv->en_napi) {
2076 weight = RTL_NAPI_WEIGHT;
2079 #ifdef CONFIG_RTW_GRO
2080 if (pregistrypriv->en_gro)
2082 #endif /* CONFIG_RTW_GRO */
2083 #endif /* CONFIG_RTW_NAPI */
2086 RTW_PRINT_SEL(m, "NAPI enable, weight=%d\n", weight);
2088 RTW_PRINT_SEL(m, "NAPI disable\n");
2089 RTW_PRINT_SEL(m, "GRO %s\n", gro?"enable":"disable");
2096 * init/deinit when register/unregister net_device
2098 const struct rtw_proc_hdl adapter_proc_hdls[] = {
2099 #if RTW_SEQ_FILE_TEST
2100 RTW_PROC_HDL_SEQ("seq_file_test", &seq_file_test, NULL),
2102 RTW_PROC_HDL_SSEQ("write_reg", NULL, proc_set_write_reg),
2103 RTW_PROC_HDL_SSEQ("read_reg", proc_get_read_reg, proc_set_read_reg),
2104 RTW_PROC_HDL_SSEQ("tx_rate_bmp", proc_get_dump_tx_rate_bmp, NULL),
2105 RTW_PROC_HDL_SSEQ("adapters_status", proc_get_dump_adapters_status, NULL),
2106 #ifdef CONFIG_RTW_CUSTOMER_STR
2107 RTW_PROC_HDL_SSEQ("customer_str", proc_get_customer_str, NULL),
2109 RTW_PROC_HDL_SSEQ("fwstate", proc_get_fwstate, NULL),
2110 RTW_PROC_HDL_SSEQ("sec_info", proc_get_sec_info, NULL),
2111 RTW_PROC_HDL_SSEQ("mlmext_state", proc_get_mlmext_state, NULL),
2112 RTW_PROC_HDL_SSEQ("qos_option", proc_get_qos_option, NULL),
2113 RTW_PROC_HDL_SSEQ("ht_option", proc_get_ht_option, NULL),
2114 RTW_PROC_HDL_SSEQ("rf_info", proc_get_rf_info, NULL),
2115 RTW_PROC_HDL_SSEQ("scan_param", proc_get_scan_param, proc_set_scan_param),
2116 RTW_PROC_HDL_SSEQ("scan_abort", proc_get_scan_abort, NULL),
2117 #ifdef CONFIG_SCAN_BACKOP
2118 RTW_PROC_HDL_SSEQ("backop_flags_sta", proc_get_backop_flags_sta, proc_set_backop_flags_sta),
2119 RTW_PROC_HDL_SSEQ("backop_flags_ap", proc_get_backop_flags_ap, proc_set_backop_flags_ap),
2121 RTW_PROC_HDL_SSEQ("survey_info", proc_get_survey_info, proc_set_survey_info),
2122 RTW_PROC_HDL_SSEQ("ap_info", proc_get_ap_info, NULL),
2123 RTW_PROC_HDL_SSEQ("trx_info", proc_get_trx_info, proc_reset_trx_info),
2124 RTW_PROC_HDL_SSEQ("rate_ctl", proc_get_rate_ctl, proc_set_rate_ctl),
2125 RTW_PROC_HDL_SSEQ("bw_ctl", proc_get_bw_ctl, proc_set_bw_ctl),
2126 RTW_PROC_HDL_SSEQ("dis_pwt_ctl", proc_get_dis_pwt, proc_set_dis_pwt),
2127 RTW_PROC_HDL_SSEQ("mac_qinfo", proc_get_mac_qinfo, NULL),
2128 RTW_PROC_HDL_SSEQ("macid_info", proc_get_macid_info, NULL),
2129 RTW_PROC_HDL_SSEQ("bcmc_info", proc_get_mi_ap_bc_info, NULL),
2130 RTW_PROC_HDL_SSEQ("sec_cam", proc_get_sec_cam, proc_set_sec_cam),
2131 RTW_PROC_HDL_SSEQ("sec_cam_cache", proc_get_sec_cam_cache, NULL),
2132 RTW_PROC_HDL_SSEQ("suspend_info", proc_get_suspend_resume_info, NULL),
2133 RTW_PROC_HDL_SSEQ("wifi_spec", proc_get_wifi_spec, NULL),
2134 #ifdef CONFIG_LAYER2_ROAMING
2135 RTW_PROC_HDL_SSEQ("roam_flags", proc_get_roam_flags, proc_set_roam_flags),
2136 RTW_PROC_HDL_SSEQ("roam_param", proc_get_roam_param, proc_set_roam_param),
2137 RTW_PROC_HDL_SSEQ("roam_tgt_addr", NULL, proc_set_roam_tgt_addr),
2138 #endif /* CONFIG_LAYER2_ROAMING */
2140 #ifdef CONFIG_RTW_80211R
2141 RTW_PROC_HDL_SSEQ("ft_flags", proc_get_ft_flags, proc_set_ft_flags),
2144 #ifdef CONFIG_SDIO_HCI
2145 RTW_PROC_HDL_SSEQ("sd_f0_reg_dump", proc_get_sd_f0_reg_dump, NULL),
2146 RTW_PROC_HDL_SSEQ("sdio_local_reg_dump", proc_get_sdio_local_reg_dump, NULL),
2147 #endif /* CONFIG_SDIO_HCI */
2149 RTW_PROC_HDL_SSEQ("fwdl_test_case", NULL, proc_set_fwdl_test_case),
2150 RTW_PROC_HDL_SSEQ("del_rx_ampdu_test_case", NULL, proc_set_del_rx_ampdu_test_case),
2151 RTW_PROC_HDL_SSEQ("wait_hiq_empty", NULL, proc_set_wait_hiq_empty),
2153 RTW_PROC_HDL_SSEQ("mac_reg_dump", proc_get_mac_reg_dump, NULL),
2154 RTW_PROC_HDL_SSEQ("bb_reg_dump", proc_get_bb_reg_dump, NULL),
2155 RTW_PROC_HDL_SSEQ("rf_reg_dump", proc_get_rf_reg_dump, NULL),
2157 #ifdef CONFIG_AP_MODE
2158 RTW_PROC_HDL_SSEQ("all_sta_info", proc_get_all_sta_info, NULL),
2159 #endif /* CONFIG_AP_MODE */
2161 #ifdef DBG_MEMORY_LEAK
2162 RTW_PROC_HDL_SSEQ("_malloc_cnt", proc_get_malloc_cnt, NULL),
2163 #endif /* DBG_MEMORY_LEAK */
2165 #ifdef CONFIG_FIND_BEST_CHANNEL
2166 RTW_PROC_HDL_SSEQ("best_channel", proc_get_best_channel, proc_set_best_channel),
2169 RTW_PROC_HDL_SSEQ("rx_signal", proc_get_rx_signal, proc_set_rx_signal),
2170 RTW_PROC_HDL_SSEQ("hw_info", proc_get_hw_status, proc_set_hw_status),
2172 #ifdef CONFIG_80211N_HT
2173 RTW_PROC_HDL_SSEQ("ht_enable", proc_get_ht_enable, proc_set_ht_enable),
2174 RTW_PROC_HDL_SSEQ("bw_mode", proc_get_bw_mode, proc_set_bw_mode),
2175 RTW_PROC_HDL_SSEQ("ampdu_enable", proc_get_ampdu_enable, proc_set_ampdu_enable),
2176 RTW_PROC_HDL_SSEQ("rx_stbc", proc_get_rx_stbc, proc_set_rx_stbc),
2177 RTW_PROC_HDL_SSEQ("rx_ampdu", proc_get_rx_ampdu, proc_set_rx_ampdu),
2178 RTW_PROC_HDL_SSEQ("rx_ampdu_factor", proc_get_rx_ampdu_factor, proc_set_rx_ampdu_factor),
2179 RTW_PROC_HDL_SSEQ("rx_ampdu_density", proc_get_rx_ampdu_density, proc_set_rx_ampdu_density),
2180 RTW_PROC_HDL_SSEQ("tx_ampdu_density", proc_get_tx_ampdu_density, proc_set_tx_ampdu_density),
2181 #endif /* CONFIG_80211N_HT */
2183 RTW_PROC_HDL_SSEQ("en_fwps", proc_get_en_fwps, proc_set_en_fwps),
2184 RTW_PROC_HDL_SSEQ("mac_rptbuf", proc_get_mac_rptbuf, NULL),
2186 /* RTW_PROC_HDL_SSEQ("path_rssi", proc_get_two_path_rssi, NULL),
2187 * RTW_PROC_HDL_SSEQ("rssi_disp",proc_get_rssi_disp, proc_set_rssi_disp), */
2189 #ifdef CONFIG_BT_COEXIST
2190 RTW_PROC_HDL_SSEQ("btcoex_dbg", proc_get_btcoex_dbg, proc_set_btcoex_dbg),
2191 RTW_PROC_HDL_SSEQ("btcoex", proc_get_btcoex_info, NULL),
2192 RTW_PROC_HDL_SSEQ("btinfo_evt", NULL, proc_set_btinfo_evt),
2193 RTW_PROC_HDL_SSEQ("btreg_read", proc_get_btreg_read, proc_set_btreg_read),
2194 RTW_PROC_HDL_SSEQ("btreg_write", proc_get_btreg_write, proc_set_btreg_write),
2195 #endif /* CONFIG_BT_COEXIST */
2197 #if defined(DBG_CONFIG_ERROR_DETECT)
2198 RTW_PROC_HDL_SSEQ("sreset", proc_get_sreset, proc_set_sreset),
2199 #endif /* DBG_CONFIG_ERROR_DETECT */
2200 RTW_PROC_HDL_SSEQ("trx_info_debug", proc_get_trx_info_debug, NULL),
2201 RTW_PROC_HDL_SSEQ("linked_info_dump", proc_get_linked_info_dump, proc_set_linked_info_dump),
2202 RTW_PROC_HDL_SSEQ("tx_info_msg", proc_get_tx_info_msg, NULL),
2203 RTW_PROC_HDL_SSEQ("rx_info_msg", proc_get_rx_info_msg, proc_set_rx_info_msg),
2204 #ifdef CONFIG_GPIO_API
2205 RTW_PROC_HDL_SSEQ("gpio_info", proc_get_gpio, proc_set_gpio),
2206 RTW_PROC_HDL_SSEQ("gpio_set_output_value", NULL, proc_set_gpio_output_value),
2207 RTW_PROC_HDL_SSEQ("gpio_set_direction", NULL, proc_set_config_gpio),
2210 #ifdef CONFIG_DBG_COUNTER
2211 RTW_PROC_HDL_SSEQ("rx_logs", proc_get_rx_logs, NULL),
2212 RTW_PROC_HDL_SSEQ("tx_logs", proc_get_tx_logs, NULL),
2213 RTW_PROC_HDL_SSEQ("int_logs", proc_get_int_logs, NULL),
2216 #ifdef CONFIG_PCI_HCI
2217 RTW_PROC_HDL_SSEQ("rx_ring", proc_get_rx_ring, NULL),
2218 RTW_PROC_HDL_SSEQ("tx_ring", proc_get_tx_ring, NULL),
2221 #ifdef CONFIG_WOWLAN
2222 RTW_PROC_HDL_SSEQ("wow_pattern_info", proc_get_pattern_info, proc_set_pattern_info),
2223 RTW_PROC_HDL_SSEQ("wowlan_last_wake_reason", proc_get_wakeup_reason, NULL),
2226 #ifdef CONFIG_GPIO_WAKEUP
2227 RTW_PROC_HDL_SSEQ("wowlan_gpio_info", proc_get_wowlan_gpio_info, proc_set_wowlan_gpio_info),
2229 #ifdef CONFIG_P2P_WOWLAN
2230 RTW_PROC_HDL_SSEQ("p2p_wowlan_info", proc_get_p2p_wowlan_info, NULL),
2232 RTW_PROC_HDL_SSEQ("country_code", proc_get_country_code, proc_set_country_code),
2233 RTW_PROC_HDL_SSEQ("chan_plan", proc_get_chan_plan, proc_set_chan_plan),
2234 #if CONFIG_RTW_MACADDR_ACL
2235 RTW_PROC_HDL_SSEQ("macaddr_acl", proc_get_macaddr_acl, proc_set_macaddr_acl),
2237 #ifdef CONFIG_DFS_MASTER
2238 RTW_PROC_HDL_SSEQ("dfs_master_test_case", proc_get_dfs_master_test_case, proc_set_dfs_master_test_case),
2239 RTW_PROC_HDL_SSEQ("update_non_ocp", NULL, proc_set_update_non_ocp),
2240 RTW_PROC_HDL_SSEQ("radar_detect", NULL, proc_set_radar_detect),
2241 RTW_PROC_HDL_SSEQ("dfs_ch_sel_d_flags", proc_get_dfs_ch_sel_d_flags, proc_set_dfs_ch_sel_d_flags),
2243 RTW_PROC_HDL_SSEQ("new_bcn_max", proc_get_new_bcn_max, proc_set_new_bcn_max),
2244 RTW_PROC_HDL_SSEQ("sink_udpport", proc_get_udpport, proc_set_udpport),
2245 #ifdef DBG_RX_COUNTER_DUMP
2246 RTW_PROC_HDL_SSEQ("dump_rx_cnt_mode", proc_get_rx_cnt_dump, proc_set_rx_cnt_dump),
2248 RTW_PROC_HDL_SSEQ("change_bss_chbw", NULL, proc_set_change_bss_chbw),
2249 #ifdef CONFIG_80211N_HT
2250 RTW_PROC_HDL_SSEQ("tx_bw_mode", proc_get_tx_bw_mode, proc_set_tx_bw_mode),
2251 #endif /* CONFIG_80211N_HT */
2252 RTW_PROC_HDL_SSEQ("hal_txpwr_info", proc_get_hal_txpwr_info, NULL),
2253 RTW_PROC_HDL_SSEQ("target_tx_power", proc_get_target_tx_power, NULL),
2254 RTW_PROC_HDL_SSEQ("tx_power_by_rate", proc_get_tx_power_by_rate, NULL),
2255 RTW_PROC_HDL_SSEQ("tx_power_limit", proc_get_tx_power_limit, NULL),
2256 RTW_PROC_HDL_SSEQ("tx_power_ext_info", proc_get_tx_power_ext_info, proc_set_tx_power_ext_info),
2257 RTW_PROC_HDL_SEQ("tx_power_idx", &seq_ops_tx_power_idx, NULL),
2258 #ifdef CONFIG_RF_POWER_TRIM
2259 RTW_PROC_HDL_SSEQ("tx_gain_offset", NULL, proc_set_tx_gain_offset),
2260 RTW_PROC_HDL_SSEQ("kfree_flag", proc_get_kfree_flag, proc_set_kfree_flag),
2261 RTW_PROC_HDL_SSEQ("kfree_bb_gain", proc_get_kfree_bb_gain, proc_set_kfree_bb_gain),
2262 RTW_PROC_HDL_SSEQ("kfree_thermal", proc_get_kfree_thermal, proc_set_kfree_thermal),
2264 #ifdef CONFIG_POWER_SAVING
2265 RTW_PROC_HDL_SSEQ("ps_info", proc_get_ps_info, NULL),
2268 RTW_PROC_HDL_SSEQ("tdls_info", proc_get_tdls_info, NULL),
2270 RTW_PROC_HDL_SSEQ("monitor", proc_get_monitor, proc_set_monitor),
2272 #ifdef CONFIG_AUTO_CHNL_SEL_NHM
2273 RTW_PROC_HDL_SSEQ("acs", proc_get_best_chan, proc_set_acs),
2275 #ifdef CONFIG_PREALLOC_RX_SKB_BUFFER
2276 RTW_PROC_HDL_SSEQ("rtkm_info", proc_get_rtkm_info, NULL),
2278 RTW_PROC_HDL_SSEQ("efuse_map", proc_get_efuse_map, NULL),
2279 #ifdef CONFIG_IEEE80211W
2280 RTW_PROC_HDL_SSEQ("11w_tx_sa_query", proc_get_tx_sa_query, proc_set_tx_sa_query),
2281 RTW_PROC_HDL_SSEQ("11w_tx_deauth", proc_get_tx_deauth, proc_set_tx_deauth),
2282 RTW_PROC_HDL_SSEQ("11w_tx_auth", proc_get_tx_auth, proc_set_tx_auth),
2283 #endif /* CONFIG_IEEE80211W */
2285 #ifdef CONFIG_MBSSID_CAM
2286 RTW_PROC_HDL_SSEQ("mbid_cam", proc_get_mbid_cam_cache, NULL),
2288 RTW_PROC_HDL_SSEQ("mac_addr", proc_get_mac_addr, NULL),
2289 RTW_PROC_HDL_SSEQ("skip_band", proc_get_skip_band, proc_set_skip_band),
2290 RTW_PROC_HDL_SSEQ("hal_spec", proc_get_hal_spec, NULL),
2291 #ifdef CONFIG_SUPPORT_TRX_SHARED
2292 RTW_PROC_HDL_SSEQ("trx_share_mode", proc_get_trx_share_mode, NULL),
2294 RTW_PROC_HDL_SSEQ("napi_info", proc_get_napi_info, NULL),
2297 const int adapter_proc_hdls_num = sizeof(adapter_proc_hdls) / sizeof(struct rtw_proc_hdl);
2299 static int rtw_adapter_proc_open(struct inode *inode, struct file *file)
2301 ssize_t index = (ssize_t)PDE_DATA(inode);
2302 const struct rtw_proc_hdl *hdl = adapter_proc_hdls + index;
2303 void *private = proc_get_parent_data(inode);
2305 if (hdl->type == RTW_PROC_HDL_TYPE_SEQ) {
2306 int res = seq_open(file, hdl->u.seq_op);
2309 ((struct seq_file *)file->private_data)->private = private;
2312 } else if (hdl->type == RTW_PROC_HDL_TYPE_SSEQ) {
2313 int (*show)(struct seq_file *, void *) = hdl->u.show ? hdl->u.show : proc_get_dummy;
2315 return single_open(file, show, private);
2321 static ssize_t rtw_adapter_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos)
2323 ssize_t index = (ssize_t)PDE_DATA(file_inode(file));
2324 const struct rtw_proc_hdl *hdl = adapter_proc_hdls + index;
2325 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *, void *) = hdl->write;
2328 return write(file, buffer, count, pos, ((struct seq_file *)file->private_data)->private);
2333 static const struct file_operations rtw_adapter_proc_seq_fops = {
2334 .owner = THIS_MODULE,
2335 .open = rtw_adapter_proc_open,
2337 .llseek = seq_lseek,
2338 .release = seq_release,
2339 .write = rtw_adapter_proc_write,
2342 static const struct file_operations rtw_adapter_proc_sseq_fops = {
2343 .owner = THIS_MODULE,
2344 .open = rtw_adapter_proc_open,
2346 .llseek = seq_lseek,
2347 .release = single_release,
2348 .write = rtw_adapter_proc_write,
2351 int proc_get_odm_dbg_comp(struct seq_file *m, void *v)
2353 struct net_device *dev = m->private;
2354 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2356 rtw_odm_dbg_comp_msg(m, adapter);
2361 ssize_t proc_set_odm_dbg_comp(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2363 struct net_device *dev = data;
2364 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2372 if (count > sizeof(tmp)) {
2377 if (buffer && !copy_from_user(tmp, buffer, count)) {
2379 int num = sscanf(tmp, "%llx", &dbg_comp);
2384 rtw_odm_dbg_comp_set(adapter, dbg_comp);
2390 int proc_get_odm_dbg_level(struct seq_file *m, void *v)
2392 struct net_device *dev = m->private;
2393 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2395 rtw_odm_dbg_level_msg(m, adapter);
2400 ssize_t proc_set_odm_dbg_level(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2402 struct net_device *dev = data;
2403 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2411 if (count > sizeof(tmp)) {
2416 if (buffer && !copy_from_user(tmp, buffer, count)) {
2418 int num = sscanf(tmp, "%u", &dbg_level);
2423 rtw_odm_dbg_level_set(adapter, dbg_level);
2429 int proc_get_odm_ability(struct seq_file *m, void *v)
2431 struct net_device *dev = m->private;
2432 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2434 rtw_odm_ability_msg(m, adapter);
2439 ssize_t proc_set_odm_ability(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2441 struct net_device *dev = data;
2442 _adapter *adapter = (_adapter *)rtw_netdev_priv(dev);
2450 if (count > sizeof(tmp)) {
2455 if (buffer && !copy_from_user(tmp, buffer, count)) {
2457 int num = sscanf(tmp, "%x", &ability);
2462 rtw_odm_ability_set(adapter, ability);
2468 int proc_get_odm_force_igi_lb(struct seq_file *m, void *v)
2470 struct net_device *dev = m->private;
2471 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2473 RTW_PRINT_SEL(m, "force_igi_lb:0x%02x\n", rtw_odm_get_force_igi_lb(padapter));
2478 ssize_t proc_set_odm_force_igi_lb(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2480 struct net_device *dev = data;
2481 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2488 if (count > sizeof(tmp)) {
2493 if (buffer && !copy_from_user(tmp, buffer, count)) {
2495 int num = sscanf(tmp, "%hhx", &force_igi_lb);
2500 rtw_odm_set_force_igi_lb(padapter, force_igi_lb);
2506 int proc_get_odm_adaptivity(struct seq_file *m, void *v)
2508 struct net_device *dev = m->private;
2509 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2511 rtw_odm_adaptivity_parm_msg(m, padapter);
2516 ssize_t proc_set_odm_adaptivity(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2518 struct net_device *dev = data;
2519 _adapter *padapter = (_adapter *)rtw_netdev_priv(dev);
2522 u32 TH_L2H_ini_mode2;
2523 s8 TH_EDCCA_HL_diff;
2524 s8 TH_EDCCA_HL_diff_mode2;
2530 if (count > sizeof(tmp)) {
2535 if (buffer && !copy_from_user(tmp, buffer, count)) {
2537 int num = sscanf(tmp, "%x %hhd %x %hhd %hhu", &TH_L2H_ini, &TH_EDCCA_HL_diff, &TH_L2H_ini_mode2, &TH_EDCCA_HL_diff_mode2, &EDCCA_enable);
2542 rtw_odm_adaptivity_parm_set(padapter, (s8)TH_L2H_ini, TH_EDCCA_HL_diff, (s8)TH_L2H_ini_mode2, TH_EDCCA_HL_diff_mode2, EDCCA_enable);
2548 static char *phydm_msg = NULL;
2549 #define PHYDM_MSG_LEN 80*24
2551 int proc_get_phydm_cmd(struct seq_file *m, void *v)
2553 struct net_device *netdev;
2555 PHAL_DATA_TYPE pHalData;
2559 netdev = m->private;
2560 padapter = (PADAPTER)rtw_netdev_priv(netdev);
2561 pHalData = GET_HAL_DATA(padapter);
2562 phydm = &pHalData->odmpriv;
2564 if (NULL == phydm_msg) {
2565 phydm_msg = rtw_zmalloc(PHYDM_MSG_LEN);
2566 if (NULL == phydm_msg)
2569 phydm_cmd(phydm, NULL, 0, 0, phydm_msg, PHYDM_MSG_LEN);
2572 _RTW_PRINT_SEL(m, "%s\n", phydm_msg);
2574 rtw_mfree(phydm_msg, PHYDM_MSG_LEN);
2580 ssize_t proc_set_phydm_cmd(struct file *file, const char __user *buffer, size_t count, loff_t *pos, void *data)
2582 struct net_device *netdev;
2584 PHAL_DATA_TYPE pHalData;
2589 netdev = (struct net_device *)data;
2590 padapter = (PADAPTER)rtw_netdev_priv(netdev);
2591 pHalData = GET_HAL_DATA(padapter);
2592 phydm = &pHalData->odmpriv;
2597 if (count > sizeof(tmp))
2600 if (buffer && !copy_from_user(tmp, buffer, count)) {
2601 if (NULL == phydm_msg) {
2602 phydm_msg = rtw_zmalloc(PHYDM_MSG_LEN);
2603 if (NULL == phydm_msg)
2606 _rtw_memset(phydm_msg, 0, PHYDM_MSG_LEN);
2608 phydm_cmd(phydm, tmp, count, 1, phydm_msg, PHYDM_MSG_LEN);
2610 if (strlen(phydm_msg) == 0) {
2611 rtw_mfree(phydm_msg, PHYDM_MSG_LEN);
2621 * init/deinit when register/unregister net_device, along with rtw_adapter_proc
2623 const struct rtw_proc_hdl odm_proc_hdls[] = {
2624 RTW_PROC_HDL_SSEQ("dbg_comp", proc_get_odm_dbg_comp, proc_set_odm_dbg_comp),
2625 RTW_PROC_HDL_SSEQ("dbg_level", proc_get_odm_dbg_level, proc_set_odm_dbg_level),
2626 RTW_PROC_HDL_SSEQ("ability", proc_get_odm_ability, proc_set_odm_ability),
2627 RTW_PROC_HDL_SSEQ("adaptivity", proc_get_odm_adaptivity, proc_set_odm_adaptivity),
2628 RTW_PROC_HDL_SSEQ("force_igi_lb", proc_get_odm_force_igi_lb, proc_set_odm_force_igi_lb),
2629 RTW_PROC_HDL_SSEQ("cmd", proc_get_phydm_cmd, proc_set_phydm_cmd),
2632 const int odm_proc_hdls_num = sizeof(odm_proc_hdls) / sizeof(struct rtw_proc_hdl);
2634 static int rtw_odm_proc_open(struct inode *inode, struct file *file)
2636 ssize_t index = (ssize_t)PDE_DATA(inode);
2637 const struct rtw_proc_hdl *hdl = odm_proc_hdls + index;
2638 void *private = proc_get_parent_data(inode);
2640 if (hdl->type == RTW_PROC_HDL_TYPE_SEQ) {
2641 int res = seq_open(file, hdl->u.seq_op);
2644 ((struct seq_file *)file->private_data)->private = private;
2647 } else if (hdl->type == RTW_PROC_HDL_TYPE_SSEQ) {
2648 int (*show)(struct seq_file *, void *) = hdl->u.show ? hdl->u.show : proc_get_dummy;
2650 return single_open(file, show, private);
2656 static ssize_t rtw_odm_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos)
2658 ssize_t index = (ssize_t)PDE_DATA(file_inode(file));
2659 const struct rtw_proc_hdl *hdl = odm_proc_hdls + index;
2660 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *, void *) = hdl->write;
2663 return write(file, buffer, count, pos, ((struct seq_file *)file->private_data)->private);
2668 static const struct file_operations rtw_odm_proc_seq_fops = {
2669 .owner = THIS_MODULE,
2670 .open = rtw_odm_proc_open,
2672 .llseek = seq_lseek,
2673 .release = seq_release,
2674 .write = rtw_odm_proc_write,
2677 static const struct file_operations rtw_odm_proc_sseq_fops = {
2678 .owner = THIS_MODULE,
2679 .open = rtw_odm_proc_open,
2681 .llseek = seq_lseek,
2682 .release = single_release,
2683 .write = rtw_odm_proc_write,
2686 struct proc_dir_entry *rtw_odm_proc_init(struct net_device *dev)
2688 struct proc_dir_entry *dir_odm = NULL;
2689 struct proc_dir_entry *entry = NULL;
2690 _adapter *adapter = rtw_netdev_priv(dev);
2693 if (adapter->dir_dev == NULL) {
2698 if (adapter->dir_odm != NULL) {
2703 dir_odm = rtw_proc_create_dir("odm", adapter->dir_dev, dev);
2704 if (dir_odm == NULL) {
2709 adapter->dir_odm = dir_odm;
2711 for (i = 0; i < odm_proc_hdls_num; i++) {
2712 if (odm_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SEQ)
2713 entry = rtw_proc_create_entry(odm_proc_hdls[i].name, dir_odm, &rtw_odm_proc_seq_fops, (void *)i);
2714 else if (odm_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SSEQ)
2715 entry = rtw_proc_create_entry(odm_proc_hdls[i].name, dir_odm, &rtw_odm_proc_sseq_fops, (void *)i);
2729 void rtw_odm_proc_deinit(_adapter *adapter)
2731 struct proc_dir_entry *dir_odm = NULL;
2734 dir_odm = adapter->dir_odm;
2736 if (dir_odm == NULL) {
2741 for (i = 0; i < odm_proc_hdls_num; i++)
2742 remove_proc_entry(odm_proc_hdls[i].name, dir_odm);
2744 remove_proc_entry("odm", adapter->dir_dev);
2746 adapter->dir_odm = NULL;
2749 rtw_mfree(phydm_msg, PHYDM_MSG_LEN);
2754 #ifdef CONFIG_MCC_MODE
2757 * init/deinit when register/unregister net_device, along with rtw_adapter_proc
2759 const struct rtw_proc_hdl mcc_proc_hdls[] = {
2760 RTW_PROC_HDL_SSEQ("mcc_info", proc_get_mcc_info, NULL),
2761 RTW_PROC_HDL_SSEQ("mcc_enable", proc_get_mcc_info, proc_set_mcc_enable),
2762 RTW_PROC_HDL_SSEQ("mcc_single_tx_criteria", proc_get_mcc_info, proc_set_mcc_single_tx_criteria),
2763 RTW_PROC_HDL_SSEQ("mcc_ap_bw20_target_tp", proc_get_mcc_info, proc_set_mcc_ap_bw20_target_tp),
2764 RTW_PROC_HDL_SSEQ("mcc_ap_bw40_target_tp", proc_get_mcc_info, proc_set_mcc_ap_bw40_target_tp),
2765 RTW_PROC_HDL_SSEQ("mcc_ap_bw80_target_tp", proc_get_mcc_info, proc_set_mcc_ap_bw80_target_tp),
2766 RTW_PROC_HDL_SSEQ("mcc_sta_bw20_target_tp", proc_get_mcc_info, proc_set_mcc_sta_bw20_target_tp),
2767 RTW_PROC_HDL_SSEQ("mcc_sta_bw40_target_tp", proc_get_mcc_info, proc_set_mcc_sta_bw40_target_tp),
2768 RTW_PROC_HDL_SSEQ("mcc_sta_bw80_target_tp", proc_get_mcc_info, proc_set_mcc_sta_bw80_target_tp),
2771 const int mcc_proc_hdls_num = sizeof(mcc_proc_hdls) / sizeof(struct rtw_proc_hdl);
2773 static int rtw_mcc_proc_open(struct inode *inode, struct file *file)
2775 ssize_t index = (ssize_t)PDE_DATA(inode);
2776 const struct rtw_proc_hdl *hdl = mcc_proc_hdls + index;
2777 void *private = proc_get_parent_data(inode);
2779 if (hdl->type == RTW_PROC_HDL_TYPE_SEQ) {
2780 int res = seq_open(file, hdl->u.seq_op);
2783 ((struct seq_file *)file->private_data)->private = private;
2786 } else if (hdl->type == RTW_PROC_HDL_TYPE_SSEQ) {
2787 int (*show)(struct seq_file *, void *) = hdl->u.show ? hdl->u.show : proc_get_dummy;
2789 return single_open(file, show, private);
2795 static ssize_t rtw_mcc_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos)
2797 ssize_t index = (ssize_t)PDE_DATA(file_inode(file));
2798 const struct rtw_proc_hdl *hdl = mcc_proc_hdls + index;
2799 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *, void *) = hdl->write;
2802 return write(file, buffer, count, pos, ((struct seq_file *)file->private_data)->private);
2807 static const struct file_operations rtw_mcc_proc_seq_fops = {
2808 .owner = THIS_MODULE,
2809 .open = rtw_mcc_proc_open,
2811 .llseek = seq_lseek,
2812 .release = seq_release,
2813 .write = rtw_mcc_proc_write,
2816 static const struct file_operations rtw_mcc_proc_sseq_fops = {
2817 .owner = THIS_MODULE,
2818 .open = rtw_mcc_proc_open,
2820 .llseek = seq_lseek,
2821 .release = single_release,
2822 .write = rtw_mcc_proc_write,
2825 struct proc_dir_entry *rtw_mcc_proc_init(struct net_device *dev)
2827 struct proc_dir_entry *dir_mcc = NULL;
2828 struct proc_dir_entry *entry = NULL;
2829 _adapter *adapter = rtw_netdev_priv(dev);
2832 if (adapter->dir_dev == NULL) {
2837 if (adapter->dir_mcc != NULL) {
2842 dir_mcc = rtw_proc_create_dir("mcc", adapter->dir_dev, dev);
2843 if (dir_mcc == NULL) {
2848 adapter->dir_mcc = dir_mcc;
2850 for (i = 0; i < mcc_proc_hdls_num; i++) {
2851 if (mcc_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SEQ)
2852 entry = rtw_proc_create_entry(mcc_proc_hdls[i].name, dir_mcc, &rtw_mcc_proc_seq_fops, (void *)i);
2853 else if (mcc_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SSEQ)
2854 entry = rtw_proc_create_entry(mcc_proc_hdls[i].name, dir_mcc, &rtw_mcc_proc_sseq_fops, (void *)i);
2868 void rtw_mcc_proc_deinit(_adapter *adapter)
2870 struct proc_dir_entry *dir_mcc = NULL;
2873 dir_mcc = adapter->dir_mcc;
2875 if (dir_mcc == NULL) {
2880 for (i = 0; i < mcc_proc_hdls_num; i++)
2881 remove_proc_entry(mcc_proc_hdls[i].name, dir_mcc);
2883 remove_proc_entry("mcc", adapter->dir_dev);
2885 adapter->dir_mcc = NULL;
2887 #endif /* CONFIG_MCC_MODE */
2889 struct proc_dir_entry *rtw_adapter_proc_init(struct net_device *dev)
2891 struct proc_dir_entry *drv_proc = get_rtw_drv_proc();
2892 struct proc_dir_entry *dir_dev = NULL;
2893 struct proc_dir_entry *entry = NULL;
2894 _adapter *adapter = rtw_netdev_priv(dev);
2898 if (drv_proc == NULL) {
2903 if (adapter->dir_dev != NULL) {
2908 dir_dev = rtw_proc_create_dir(dev->name, drv_proc, dev);
2909 if (dir_dev == NULL) {
2914 adapter->dir_dev = dir_dev;
2916 for (i = 0; i < adapter_proc_hdls_num; i++) {
2917 if (adapter_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SEQ)
2918 entry = rtw_proc_create_entry(adapter_proc_hdls[i].name, dir_dev, &rtw_adapter_proc_seq_fops, (void *)i);
2919 else if (adapter_proc_hdls[i].type == RTW_PROC_HDL_TYPE_SSEQ)
2920 entry = rtw_proc_create_entry(adapter_proc_hdls[i].name, dir_dev, &rtw_adapter_proc_sseq_fops, (void *)i);
2930 rtw_odm_proc_init(dev);
2932 #ifdef CONFIG_MCC_MODE
2933 rtw_mcc_proc_init(dev);
2934 #endif /* CONFIG_MCC_MODE */
2940 void rtw_adapter_proc_deinit(struct net_device *dev)
2942 struct proc_dir_entry *drv_proc = get_rtw_drv_proc();
2943 struct proc_dir_entry *dir_dev = NULL;
2944 _adapter *adapter = rtw_netdev_priv(dev);
2947 dir_dev = adapter->dir_dev;
2949 if (dir_dev == NULL) {
2954 for (i = 0; i < adapter_proc_hdls_num; i++)
2955 remove_proc_entry(adapter_proc_hdls[i].name, dir_dev);
2957 rtw_odm_proc_deinit(adapter);
2959 #ifdef CONFIG_MCC_MODE
2960 rtw_mcc_proc_deinit(adapter);
2961 #endif /* CONFIG_MCC_MODE */
2963 remove_proc_entry(dev->name, drv_proc);
2965 adapter->dir_dev = NULL;
2968 void rtw_adapter_proc_replace(struct net_device *dev)
2970 struct proc_dir_entry *drv_proc = get_rtw_drv_proc();
2971 struct proc_dir_entry *dir_dev = NULL;
2972 _adapter *adapter = rtw_netdev_priv(dev);
2975 dir_dev = adapter->dir_dev;
2977 if (dir_dev == NULL) {
2982 for (i = 0; i < adapter_proc_hdls_num; i++)
2983 remove_proc_entry(adapter_proc_hdls[i].name, dir_dev);
2985 rtw_odm_proc_deinit(adapter);
2987 #ifdef CONFIG_MCC_MODE
2988 rtw_mcc_proc_deinit(adapter);
2989 #endif /* CONIG_MCC_MODE */
2991 remove_proc_entry(adapter->old_ifname, drv_proc);
2993 adapter->dir_dev = NULL;
2995 rtw_adapter_proc_init(dev);
2999 #endif /* CONFIG_PROC_DEBUG */