2 * Marvell Wireless LAN device driver: debugfs
4 * Copyright (C) 2011, Marvell International Ltd.
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17 * this warranty disclaimer.
20 #include <linux/debugfs.h>
26 static struct dentry
*mwifiex_dfs_dir
;
28 static char *bss_modes
[] = {
42 /* size/addr for mwifiex_debug_info */
43 #define item_size(n) (FIELD_SIZEOF(struct mwifiex_debug_info, n))
44 #define item_addr(n) (offsetof(struct mwifiex_debug_info, n))
46 /* size/addr for struct mwifiex_adapter */
47 #define adapter_item_size(n) (FIELD_SIZEOF(struct mwifiex_adapter, n))
48 #define adapter_item_addr(n) (offsetof(struct mwifiex_adapter, n))
50 struct mwifiex_debug_data
{
51 char name
[32]; /* variable/array name */
52 u32 size
; /* size of the variable/array */
53 size_t addr
; /* address of the variable/array */
54 int num
; /* number of variables in an array */
57 static struct mwifiex_debug_data items
[] = {
58 {"int_counter", item_size(int_counter
),
59 item_addr(int_counter
), 1},
60 {"wmm_ac_vo", item_size(packets_out
[WMM_AC_VO
]),
61 item_addr(packets_out
[WMM_AC_VO
]), 1},
62 {"wmm_ac_vi", item_size(packets_out
[WMM_AC_VI
]),
63 item_addr(packets_out
[WMM_AC_VI
]), 1},
64 {"wmm_ac_be", item_size(packets_out
[WMM_AC_BE
]),
65 item_addr(packets_out
[WMM_AC_BE
]), 1},
66 {"wmm_ac_bk", item_size(packets_out
[WMM_AC_BK
]),
67 item_addr(packets_out
[WMM_AC_BK
]), 1},
68 {"tx_buf_size", item_size(tx_buf_size
),
69 item_addr(tx_buf_size
), 1},
70 {"curr_tx_buf_size", item_size(curr_tx_buf_size
),
71 item_addr(curr_tx_buf_size
), 1},
72 {"ps_mode", item_size(ps_mode
),
73 item_addr(ps_mode
), 1},
74 {"ps_state", item_size(ps_state
),
75 item_addr(ps_state
), 1},
76 {"is_deep_sleep", item_size(is_deep_sleep
),
77 item_addr(is_deep_sleep
), 1},
78 {"wakeup_dev_req", item_size(pm_wakeup_card_req
),
79 item_addr(pm_wakeup_card_req
), 1},
80 {"wakeup_tries", item_size(pm_wakeup_fw_try
),
81 item_addr(pm_wakeup_fw_try
), 1},
82 {"hs_configured", item_size(is_hs_configured
),
83 item_addr(is_hs_configured
), 1},
84 {"hs_activated", item_size(hs_activated
),
85 item_addr(hs_activated
), 1},
86 {"num_tx_timeout", item_size(num_tx_timeout
),
87 item_addr(num_tx_timeout
), 1},
88 {"is_cmd_timedout", item_size(is_cmd_timedout
),
89 item_addr(is_cmd_timedout
), 1},
90 {"timeout_cmd_id", item_size(timeout_cmd_id
),
91 item_addr(timeout_cmd_id
), 1},
92 {"timeout_cmd_act", item_size(timeout_cmd_act
),
93 item_addr(timeout_cmd_act
), 1},
94 {"last_cmd_id", item_size(last_cmd_id
),
95 item_addr(last_cmd_id
), DBG_CMD_NUM
},
96 {"last_cmd_act", item_size(last_cmd_act
),
97 item_addr(last_cmd_act
), DBG_CMD_NUM
},
98 {"last_cmd_index", item_size(last_cmd_index
),
99 item_addr(last_cmd_index
), 1},
100 {"last_cmd_resp_id", item_size(last_cmd_resp_id
),
101 item_addr(last_cmd_resp_id
), DBG_CMD_NUM
},
102 {"last_cmd_resp_index", item_size(last_cmd_resp_index
),
103 item_addr(last_cmd_resp_index
), 1},
104 {"last_event", item_size(last_event
),
105 item_addr(last_event
), DBG_CMD_NUM
},
106 {"last_event_index", item_size(last_event_index
),
107 item_addr(last_event_index
), 1},
108 {"num_cmd_h2c_fail", item_size(num_cmd_host_to_card_failure
),
109 item_addr(num_cmd_host_to_card_failure
), 1},
110 {"num_cmd_sleep_cfm_fail",
111 item_size(num_cmd_sleep_cfm_host_to_card_failure
),
112 item_addr(num_cmd_sleep_cfm_host_to_card_failure
), 1},
113 {"num_tx_h2c_fail", item_size(num_tx_host_to_card_failure
),
114 item_addr(num_tx_host_to_card_failure
), 1},
115 {"num_evt_deauth", item_size(num_event_deauth
),
116 item_addr(num_event_deauth
), 1},
117 {"num_evt_disassoc", item_size(num_event_disassoc
),
118 item_addr(num_event_disassoc
), 1},
119 {"num_evt_link_lost", item_size(num_event_link_lost
),
120 item_addr(num_event_link_lost
), 1},
121 {"num_cmd_deauth", item_size(num_cmd_deauth
),
122 item_addr(num_cmd_deauth
), 1},
123 {"num_cmd_assoc_ok", item_size(num_cmd_assoc_success
),
124 item_addr(num_cmd_assoc_success
), 1},
125 {"num_cmd_assoc_fail", item_size(num_cmd_assoc_failure
),
126 item_addr(num_cmd_assoc_failure
), 1},
127 {"cmd_sent", item_size(cmd_sent
),
128 item_addr(cmd_sent
), 1},
129 {"data_sent", item_size(data_sent
),
130 item_addr(data_sent
), 1},
131 {"cmd_resp_received", item_size(cmd_resp_received
),
132 item_addr(cmd_resp_received
), 1},
133 {"event_received", item_size(event_received
),
134 item_addr(event_received
), 1},
136 /* variables defined in struct mwifiex_adapter */
137 {"cmd_pending", adapter_item_size(cmd_pending
),
138 adapter_item_addr(cmd_pending
), 1},
139 {"tx_pending", adapter_item_size(tx_pending
),
140 adapter_item_addr(tx_pending
), 1},
141 {"rx_pending", adapter_item_size(rx_pending
),
142 adapter_item_addr(rx_pending
), 1},
145 static int num_of_items
= ARRAY_SIZE(items
);
148 * Proc info file read handler.
150 * This function is called when the 'info' file is opened for reading.
151 * It prints the following driver related information -
154 * - Driver extended version
157 * - Media state (connected or disconnected)
159 * - Total number of Tx bytes
160 * - Total number of Rx bytes
161 * - Total number of Tx packets
162 * - Total number of Rx packets
163 * - Total number of dropped Tx packets
164 * - Total number of dropped Rx packets
165 * - Total number of corrupted Tx packets
166 * - Total number of corrupted Rx packets
167 * - Carrier status (on or off)
168 * - Tx queue status (started or stopped)
170 * For STA mode drivers, it also prints the following extra -
176 * - Multicast addresses
179 mwifiex_info_read(struct file
*file
, char __user
*ubuf
,
180 size_t count
, loff_t
*ppos
)
182 struct mwifiex_private
*priv
=
183 (struct mwifiex_private
*) file
->private_data
;
184 struct net_device
*netdev
= priv
->netdev
;
185 struct netdev_hw_addr
*ha
;
186 struct netdev_queue
*txq
;
187 unsigned long page
= get_zeroed_page(GFP_KERNEL
);
188 char *p
= (char *) page
, fmt
[64];
189 struct mwifiex_bss_info info
;
196 memset(&info
, 0, sizeof(info
));
197 ret
= mwifiex_get_bss_info(priv
, &info
);
201 mwifiex_drv_get_driver_version(priv
->adapter
, fmt
, sizeof(fmt
) - 1);
203 if (!priv
->version_str
[0])
204 mwifiex_get_ver_ext(priv
);
206 p
+= sprintf(p
, "driver_name = " "\"mwifiex\"\n");
207 p
+= sprintf(p
, "driver_version = %s", fmt
);
208 p
+= sprintf(p
, "\nverext = %s", priv
->version_str
);
209 p
+= sprintf(p
, "\ninterface_name=\"%s\"\n", netdev
->name
);
211 if (info
.bss_mode
>= ARRAY_SIZE(bss_modes
))
212 p
+= sprintf(p
, "bss_mode=\"%d\"\n", info
.bss_mode
);
214 p
+= sprintf(p
, "bss_mode=\"%s\"\n", bss_modes
[info
.bss_mode
]);
216 p
+= sprintf(p
, "media_state=\"%s\"\n",
217 (!priv
->media_connected
? "Disconnected" : "Connected"));
218 p
+= sprintf(p
, "mac_address=\"%pM\"\n", netdev
->dev_addr
);
220 if (GET_BSS_ROLE(priv
) == MWIFIEX_BSS_ROLE_STA
) {
221 p
+= sprintf(p
, "multicast_count=\"%d\"\n",
222 netdev_mc_count(netdev
));
223 p
+= sprintf(p
, "essid=\"%s\"\n", info
.ssid
.ssid
);
224 p
+= sprintf(p
, "bssid=\"%pM\"\n", info
.bssid
);
225 p
+= sprintf(p
, "channel=\"%d\"\n", (int) info
.bss_chan
);
226 p
+= sprintf(p
, "country_code = \"%s\"\n", info
.country_code
);
228 netdev_for_each_mc_addr(ha
, netdev
)
229 p
+= sprintf(p
, "multicast_address[%d]=\"%pM\"\n",
233 p
+= sprintf(p
, "num_tx_bytes = %lu\n", priv
->stats
.tx_bytes
);
234 p
+= sprintf(p
, "num_rx_bytes = %lu\n", priv
->stats
.rx_bytes
);
235 p
+= sprintf(p
, "num_tx_pkts = %lu\n", priv
->stats
.tx_packets
);
236 p
+= sprintf(p
, "num_rx_pkts = %lu\n", priv
->stats
.rx_packets
);
237 p
+= sprintf(p
, "num_tx_pkts_dropped = %lu\n", priv
->stats
.tx_dropped
);
238 p
+= sprintf(p
, "num_rx_pkts_dropped = %lu\n", priv
->stats
.rx_dropped
);
239 p
+= sprintf(p
, "num_tx_pkts_err = %lu\n", priv
->stats
.tx_errors
);
240 p
+= sprintf(p
, "num_rx_pkts_err = %lu\n", priv
->stats
.rx_errors
);
241 p
+= sprintf(p
, "carrier %s\n", ((netif_carrier_ok(priv
->netdev
))
243 p
+= sprintf(p
, "tx queue");
244 for (i
= 0; i
< netdev
->num_tx_queues
; i
++) {
245 txq
= netdev_get_tx_queue(netdev
, i
);
246 p
+= sprintf(p
, " %d:%s", i
, netif_tx_queue_stopped(txq
) ?
247 "stopped" : "started");
249 p
+= sprintf(p
, "\n");
251 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, (char *) page
,
252 (unsigned long) p
- page
);
260 * Proc firmware dump read handler.
262 * This function is called when the 'fw_dump' file is opened for
264 * This function dumps firmware memory in different files
265 * (ex. DTCM, ITCM, SQRAM etc.) based on the the segments for
269 mwifiex_fw_dump_read(struct file
*file
, char __user
*ubuf
,
270 size_t count
, loff_t
*ppos
)
272 struct mwifiex_private
*priv
= file
->private_data
;
274 if (!priv
->adapter
->if_ops
.fw_dump
)
277 priv
->adapter
->if_ops
.fw_dump(priv
->adapter
);
283 * Proc getlog file read handler.
285 * This function is called when the 'getlog' file is opened for reading
286 * It prints the following log information -
287 * - Number of multicast Tx frames
288 * - Number of failed packets
289 * - Number of Tx retries
290 * - Number of multicast Tx retries
291 * - Number of duplicate frames
292 * - Number of RTS successes
293 * - Number of RTS failures
294 * - Number of ACK failures
295 * - Number of fragmented Rx frames
296 * - Number of multicast Rx frames
297 * - Number of FCS errors
298 * - Number of Tx frames
299 * - WEP ICV error counts
302 mwifiex_getlog_read(struct file
*file
, char __user
*ubuf
,
303 size_t count
, loff_t
*ppos
)
305 struct mwifiex_private
*priv
=
306 (struct mwifiex_private
*) file
->private_data
;
307 unsigned long page
= get_zeroed_page(GFP_KERNEL
);
308 char *p
= (char *) page
;
310 struct mwifiex_ds_get_stats stats
;
315 memset(&stats
, 0, sizeof(stats
));
316 ret
= mwifiex_get_stats_info(priv
, &stats
);
333 "wepicverrcnt-1 %u\n"
334 "wepicverrcnt-2 %u\n"
335 "wepicverrcnt-3 %u\n"
336 "wepicverrcnt-4 %u\n",
337 stats
.mcast_tx_frame
,
346 stats
.mcast_rx_frame
,
349 stats
.wep_icv_error
[0],
350 stats
.wep_icv_error
[1],
351 stats
.wep_icv_error
[2],
352 stats
.wep_icv_error
[3]);
355 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, (char *) page
,
356 (unsigned long) p
- page
);
363 static struct mwifiex_debug_info info
;
366 * Proc debug file read handler.
368 * This function is called when the 'debug' file is opened for reading
369 * It prints the following log information -
371 * - WMM AC VO packets count
372 * - WMM AC VI packets count
373 * - WMM AC BE packets count
374 * - WMM AC BK packets count
375 * - Maximum Tx buffer size
377 * - Current Tx buffer size
380 * - Deep Sleep status
381 * - Device wakeup required status
382 * - Number of wakeup tries
383 * - Host Sleep configured status
384 * - Host Sleep activated status
385 * - Number of Tx timeouts
386 * - Number of command timeouts
387 * - Last timed out command ID
388 * - Last timed out command action
390 * - Last command action
391 * - Last command index
392 * - Last command response ID
393 * - Last command response index
396 * - Number of host to card command failures
397 * - Number of sleep confirm command failures
398 * - Number of host to card data failure
399 * - Number of deauthentication events
400 * - Number of disassociation events
401 * - Number of link lost events
402 * - Number of deauthentication commands
403 * - Number of association success commands
404 * - Number of association failure commands
405 * - Number of commands sent
406 * - Number of data packets sent
407 * - Number of command responses received
408 * - Number of events received
409 * - Tx BA stream table (TID, RA)
410 * - Rx reorder table (TID, TA, Start window, Window size, Buffer)
413 mwifiex_debug_read(struct file
*file
, char __user
*ubuf
,
414 size_t count
, loff_t
*ppos
)
416 struct mwifiex_private
*priv
=
417 (struct mwifiex_private
*) file
->private_data
;
418 struct mwifiex_debug_data
*d
= &items
[0];
419 unsigned long page
= get_zeroed_page(GFP_KERNEL
);
420 char *p
= (char *) page
;
429 ret
= mwifiex_get_debug_info(priv
, &info
);
433 for (i
= 0; i
< num_of_items
; i
++) {
434 p
+= sprintf(p
, "%s=", d
[i
].name
);
436 size
= d
[i
].size
/ d
[i
].num
;
438 if (i
< (num_of_items
- 3))
439 addr
= d
[i
].addr
+ (size_t) &info
;
440 else /* The last 3 items are struct mwifiex_adapter variables */
441 addr
= d
[i
].addr
+ (size_t) priv
->adapter
;
443 for (j
= 0; j
< d
[i
].num
; j
++) {
446 val
= *((u8
*) addr
);
449 val
= *((u16
*) addr
);
452 val
= *((u32
*) addr
);
455 val
= *((long long *) addr
);
462 p
+= sprintf(p
, "%#lx ", val
);
466 p
+= sprintf(p
, "\n");
469 if (info
.tx_tbl_num
) {
470 p
+= sprintf(p
, "Tx BA stream table:\n");
471 for (i
= 0; i
< info
.tx_tbl_num
; i
++)
472 p
+= sprintf(p
, "tid = %d, ra = %pM\n",
473 info
.tx_tbl
[i
].tid
, info
.tx_tbl
[i
].ra
);
476 if (info
.rx_tbl_num
) {
477 p
+= sprintf(p
, "Rx reorder table:\n");
478 for (i
= 0; i
< info
.rx_tbl_num
; i
++) {
479 p
+= sprintf(p
, "tid = %d, ta = %pM, "
481 "win_size = %d, buffer: ",
484 info
.rx_tbl
[i
].start_win
,
485 info
.rx_tbl
[i
].win_size
);
487 for (j
= 0; j
< info
.rx_tbl
[i
].win_size
; j
++)
488 p
+= sprintf(p
, "%c ",
489 info
.rx_tbl
[i
].buffer
[j
] ?
492 p
+= sprintf(p
, "\n");
496 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, (char *) page
,
497 (unsigned long) p
- page
);
504 static u32 saved_reg_type
, saved_reg_offset
, saved_reg_value
;
507 * Proc regrdwr file write handler.
509 * This function is called when the 'regrdwr' file is opened for writing
511 * This function can be used to write to a register.
514 mwifiex_regrdwr_write(struct file
*file
,
515 const char __user
*ubuf
, size_t count
, loff_t
*ppos
)
517 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
518 char *buf
= (char *) addr
;
519 size_t buf_size
= min_t(size_t, count
, PAGE_SIZE
- 1);
521 u32 reg_type
= 0, reg_offset
= 0, reg_value
= UINT_MAX
;
527 if (copy_from_user(buf
, ubuf
, buf_size
)) {
532 sscanf(buf
, "%u %x %x", ®_type
, ®_offset
, ®_value
);
534 if (reg_type
== 0 || reg_offset
== 0) {
538 saved_reg_type
= reg_type
;
539 saved_reg_offset
= reg_offset
;
540 saved_reg_value
= reg_value
;
549 * Proc regrdwr file read handler.
551 * This function is called when the 'regrdwr' file is opened for reading
553 * This function can be used to read from a register.
556 mwifiex_regrdwr_read(struct file
*file
, char __user
*ubuf
,
557 size_t count
, loff_t
*ppos
)
559 struct mwifiex_private
*priv
=
560 (struct mwifiex_private
*) file
->private_data
;
561 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
562 char *buf
= (char *) addr
;
563 int pos
= 0, ret
= 0;
569 if (!saved_reg_type
) {
570 /* No command has been given */
571 pos
+= snprintf(buf
, PAGE_SIZE
, "0");
574 /* Set command has been given */
575 if (saved_reg_value
!= UINT_MAX
) {
576 ret
= mwifiex_reg_write(priv
, saved_reg_type
, saved_reg_offset
,
579 pos
+= snprintf(buf
, PAGE_SIZE
, "%u 0x%x 0x%x\n",
580 saved_reg_type
, saved_reg_offset
,
583 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
587 /* Get command has been given */
588 ret
= mwifiex_reg_read(priv
, saved_reg_type
,
589 saved_reg_offset
, ®_value
);
595 pos
+= snprintf(buf
, PAGE_SIZE
, "%u 0x%x 0x%x\n", saved_reg_type
,
596 saved_reg_offset
, reg_value
);
598 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
605 static u32 saved_offset
= -1, saved_bytes
= -1;
608 * Proc rdeeprom file write handler.
610 * This function is called when the 'rdeeprom' file is opened for writing
612 * This function can be used to write to a RDEEPROM location.
615 mwifiex_rdeeprom_write(struct file
*file
,
616 const char __user
*ubuf
, size_t count
, loff_t
*ppos
)
618 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
619 char *buf
= (char *) addr
;
620 size_t buf_size
= min_t(size_t, count
, PAGE_SIZE
- 1);
622 int offset
= -1, bytes
= -1;
628 if (copy_from_user(buf
, ubuf
, buf_size
)) {
633 sscanf(buf
, "%d %d", &offset
, &bytes
);
635 if (offset
== -1 || bytes
== -1) {
639 saved_offset
= offset
;
649 * Proc rdeeprom read write handler.
651 * This function is called when the 'rdeeprom' file is opened for reading
653 * This function can be used to read from a RDEEPROM location.
656 mwifiex_rdeeprom_read(struct file
*file
, char __user
*ubuf
,
657 size_t count
, loff_t
*ppos
)
659 struct mwifiex_private
*priv
=
660 (struct mwifiex_private
*) file
->private_data
;
661 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
662 char *buf
= (char *) addr
;
663 int pos
= 0, ret
= 0, i
;
664 u8 value
[MAX_EEPROM_DATA
];
669 if (saved_offset
== -1) {
670 /* No command has been given */
671 pos
+= snprintf(buf
, PAGE_SIZE
, "0");
675 /* Get command has been given */
676 ret
= mwifiex_eeprom_read(priv
, (u16
) saved_offset
,
677 (u16
) saved_bytes
, value
);
683 pos
+= snprintf(buf
, PAGE_SIZE
, "%d %d ", saved_offset
, saved_bytes
);
685 for (i
= 0; i
< saved_bytes
; i
++)
686 pos
+= snprintf(buf
+ strlen(buf
), PAGE_SIZE
, "%d ", value
[i
]);
688 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
696 #define MWIFIEX_DFS_ADD_FILE(name) do { \
697 if (!debugfs_create_file(#name, 0644, priv->dfs_dev_dir, \
698 priv, &mwifiex_dfs_##name##_fops)) \
702 #define MWIFIEX_DFS_FILE_OPS(name) \
703 static const struct file_operations mwifiex_dfs_##name##_fops = { \
704 .read = mwifiex_##name##_read, \
705 .write = mwifiex_##name##_write, \
706 .open = simple_open, \
709 #define MWIFIEX_DFS_FILE_READ_OPS(name) \
710 static const struct file_operations mwifiex_dfs_##name##_fops = { \
711 .read = mwifiex_##name##_read, \
712 .open = simple_open, \
715 #define MWIFIEX_DFS_FILE_WRITE_OPS(name) \
716 static const struct file_operations mwifiex_dfs_##name##_fops = { \
717 .write = mwifiex_##name##_write, \
718 .open = simple_open, \
722 MWIFIEX_DFS_FILE_READ_OPS(info
);
723 MWIFIEX_DFS_FILE_READ_OPS(debug
);
724 MWIFIEX_DFS_FILE_READ_OPS(getlog
);
725 MWIFIEX_DFS_FILE_READ_OPS(fw_dump
);
726 MWIFIEX_DFS_FILE_OPS(regrdwr
);
727 MWIFIEX_DFS_FILE_OPS(rdeeprom
);
730 * This function creates the debug FS directory structure and the files.
733 mwifiex_dev_debugfs_init(struct mwifiex_private
*priv
)
735 if (!mwifiex_dfs_dir
|| !priv
)
738 priv
->dfs_dev_dir
= debugfs_create_dir(priv
->netdev
->name
,
741 if (!priv
->dfs_dev_dir
)
744 MWIFIEX_DFS_ADD_FILE(info
);
745 MWIFIEX_DFS_ADD_FILE(debug
);
746 MWIFIEX_DFS_ADD_FILE(getlog
);
747 MWIFIEX_DFS_ADD_FILE(regrdwr
);
748 MWIFIEX_DFS_ADD_FILE(rdeeprom
);
749 MWIFIEX_DFS_ADD_FILE(fw_dump
);
753 * This function removes the debug FS directory structure and the files.
756 mwifiex_dev_debugfs_remove(struct mwifiex_private
*priv
)
761 debugfs_remove_recursive(priv
->dfs_dev_dir
);
765 * This function creates the top level proc directory.
768 mwifiex_debugfs_init(void)
770 if (!mwifiex_dfs_dir
)
771 mwifiex_dfs_dir
= debugfs_create_dir("mwifiex", NULL
);
775 * This function removes the top level proc directory.
778 mwifiex_debugfs_remove(void)
781 debugfs_remove(mwifiex_dfs_dir
);