2 * Marvell Wireless LAN device driver: debugfs
4 * Copyright (C) 2011-2014, 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 if (info
.tdls_peer_num
) {
497 p
+= sprintf(p
, "TDLS peer table:\n");
498 for (i
= 0; i
< info
.tdls_peer_num
; i
++) {
499 p
+= sprintf(p
, "peer = %pM",
500 info
.tdls_list
[i
].peer_addr
);
501 p
+= sprintf(p
, "\n");
505 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, (char *) page
,
506 (unsigned long) p
- page
);
513 static u32 saved_reg_type
, saved_reg_offset
, saved_reg_value
;
516 * Proc regrdwr file write handler.
518 * This function is called when the 'regrdwr' file is opened for writing
520 * This function can be used to write to a register.
523 mwifiex_regrdwr_write(struct file
*file
,
524 const char __user
*ubuf
, size_t count
, loff_t
*ppos
)
526 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
527 char *buf
= (char *) addr
;
528 size_t buf_size
= min_t(size_t, count
, PAGE_SIZE
- 1);
530 u32 reg_type
= 0, reg_offset
= 0, reg_value
= UINT_MAX
;
536 if (copy_from_user(buf
, ubuf
, buf_size
)) {
541 sscanf(buf
, "%u %x %x", ®_type
, ®_offset
, ®_value
);
543 if (reg_type
== 0 || reg_offset
== 0) {
547 saved_reg_type
= reg_type
;
548 saved_reg_offset
= reg_offset
;
549 saved_reg_value
= reg_value
;
558 * Proc regrdwr file read handler.
560 * This function is called when the 'regrdwr' file is opened for reading
562 * This function can be used to read from a register.
565 mwifiex_regrdwr_read(struct file
*file
, char __user
*ubuf
,
566 size_t count
, loff_t
*ppos
)
568 struct mwifiex_private
*priv
=
569 (struct mwifiex_private
*) file
->private_data
;
570 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
571 char *buf
= (char *) addr
;
572 int pos
= 0, ret
= 0;
578 if (!saved_reg_type
) {
579 /* No command has been given */
580 pos
+= snprintf(buf
, PAGE_SIZE
, "0");
583 /* Set command has been given */
584 if (saved_reg_value
!= UINT_MAX
) {
585 ret
= mwifiex_reg_write(priv
, saved_reg_type
, saved_reg_offset
,
588 pos
+= snprintf(buf
, PAGE_SIZE
, "%u 0x%x 0x%x\n",
589 saved_reg_type
, saved_reg_offset
,
592 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
596 /* Get command has been given */
597 ret
= mwifiex_reg_read(priv
, saved_reg_type
,
598 saved_reg_offset
, ®_value
);
604 pos
+= snprintf(buf
, PAGE_SIZE
, "%u 0x%x 0x%x\n", saved_reg_type
,
605 saved_reg_offset
, reg_value
);
607 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
614 static u32 saved_offset
= -1, saved_bytes
= -1;
617 * Proc rdeeprom file write handler.
619 * This function is called when the 'rdeeprom' file is opened for writing
621 * This function can be used to write to a RDEEPROM location.
624 mwifiex_rdeeprom_write(struct file
*file
,
625 const char __user
*ubuf
, size_t count
, loff_t
*ppos
)
627 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
628 char *buf
= (char *) addr
;
629 size_t buf_size
= min_t(size_t, count
, PAGE_SIZE
- 1);
631 int offset
= -1, bytes
= -1;
637 if (copy_from_user(buf
, ubuf
, buf_size
)) {
642 sscanf(buf
, "%d %d", &offset
, &bytes
);
644 if (offset
== -1 || bytes
== -1) {
648 saved_offset
= offset
;
658 * Proc rdeeprom read write handler.
660 * This function is called when the 'rdeeprom' file is opened for reading
662 * This function can be used to read from a RDEEPROM location.
665 mwifiex_rdeeprom_read(struct file
*file
, char __user
*ubuf
,
666 size_t count
, loff_t
*ppos
)
668 struct mwifiex_private
*priv
=
669 (struct mwifiex_private
*) file
->private_data
;
670 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
671 char *buf
= (char *) addr
;
672 int pos
= 0, ret
= 0, i
;
673 u8 value
[MAX_EEPROM_DATA
];
678 if (saved_offset
== -1) {
679 /* No command has been given */
680 pos
+= snprintf(buf
, PAGE_SIZE
, "0");
684 /* Get command has been given */
685 ret
= mwifiex_eeprom_read(priv
, (u16
) saved_offset
,
686 (u16
) saved_bytes
, value
);
692 pos
+= snprintf(buf
, PAGE_SIZE
, "%d %d ", saved_offset
, saved_bytes
);
694 for (i
= 0; i
< saved_bytes
; i
++)
695 pos
+= snprintf(buf
+ strlen(buf
), PAGE_SIZE
, "%d ", value
[i
]);
697 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
704 /* Proc hscfg file write handler
705 * This function can be used to configure the host sleep parameters.
708 mwifiex_hscfg_write(struct file
*file
, const char __user
*ubuf
,
709 size_t count
, loff_t
*ppos
)
711 struct mwifiex_private
*priv
= (void *)file
->private_data
;
712 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
713 char *buf
= (char *)addr
;
714 size_t buf_size
= min_t(size_t, count
, PAGE_SIZE
- 1);
716 struct mwifiex_ds_hs_cfg hscfg
;
717 int conditions
= HS_CFG_COND_DEF
;
718 u32 gpio
= HS_CFG_GPIO_DEF
, gap
= HS_CFG_GAP_DEF
;
723 if (copy_from_user(buf
, ubuf
, buf_size
)) {
728 arg_num
= sscanf(buf
, "%d %x %x", &conditions
, &gpio
, &gap
);
730 memset(&hscfg
, 0, sizeof(struct mwifiex_ds_hs_cfg
));
733 dev_err(priv
->adapter
->dev
, "Too many arguments\n");
738 if (arg_num
>= 1 && arg_num
< 3)
739 mwifiex_set_hs_params(priv
, HostCmd_ACT_GEN_GET
,
740 MWIFIEX_SYNC_CMD
, &hscfg
);
743 if (conditions
== HS_CFG_CANCEL
) {
744 mwifiex_cancel_hs(priv
, MWIFIEX_ASYNC_CMD
);
748 hscfg
.conditions
= conditions
;
755 hscfg
.is_invoke_hostcmd
= false;
756 mwifiex_set_hs_params(priv
, HostCmd_ACT_GEN_SET
,
757 MWIFIEX_SYNC_CMD
, &hscfg
);
759 mwifiex_enable_hs(priv
->adapter
);
760 priv
->adapter
->hs_enabling
= false;
767 /* Proc hscfg file read handler
768 * This function can be used to read host sleep configuration
769 * parameters from driver.
772 mwifiex_hscfg_read(struct file
*file
, char __user
*ubuf
,
773 size_t count
, loff_t
*ppos
)
775 struct mwifiex_private
*priv
= (void *)file
->private_data
;
776 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
777 char *buf
= (char *)addr
;
779 struct mwifiex_ds_hs_cfg hscfg
;
784 mwifiex_set_hs_params(priv
, HostCmd_ACT_GEN_GET
,
785 MWIFIEX_SYNC_CMD
, &hscfg
);
787 pos
= snprintf(buf
, PAGE_SIZE
, "%u 0x%x 0x%x\n", hscfg
.conditions
,
788 hscfg
.gpio
, hscfg
.gap
);
790 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
796 #define MWIFIEX_DFS_ADD_FILE(name) do { \
797 if (!debugfs_create_file(#name, 0644, priv->dfs_dev_dir, \
798 priv, &mwifiex_dfs_##name##_fops)) \
802 #define MWIFIEX_DFS_FILE_OPS(name) \
803 static const struct file_operations mwifiex_dfs_##name##_fops = { \
804 .read = mwifiex_##name##_read, \
805 .write = mwifiex_##name##_write, \
806 .open = simple_open, \
809 #define MWIFIEX_DFS_FILE_READ_OPS(name) \
810 static const struct file_operations mwifiex_dfs_##name##_fops = { \
811 .read = mwifiex_##name##_read, \
812 .open = simple_open, \
815 #define MWIFIEX_DFS_FILE_WRITE_OPS(name) \
816 static const struct file_operations mwifiex_dfs_##name##_fops = { \
817 .write = mwifiex_##name##_write, \
818 .open = simple_open, \
822 MWIFIEX_DFS_FILE_READ_OPS(info
);
823 MWIFIEX_DFS_FILE_READ_OPS(debug
);
824 MWIFIEX_DFS_FILE_READ_OPS(getlog
);
825 MWIFIEX_DFS_FILE_READ_OPS(fw_dump
);
826 MWIFIEX_DFS_FILE_OPS(regrdwr
);
827 MWIFIEX_DFS_FILE_OPS(rdeeprom
);
828 MWIFIEX_DFS_FILE_OPS(hscfg
);
831 * This function creates the debug FS directory structure and the files.
834 mwifiex_dev_debugfs_init(struct mwifiex_private
*priv
)
836 if (!mwifiex_dfs_dir
|| !priv
)
839 priv
->dfs_dev_dir
= debugfs_create_dir(priv
->netdev
->name
,
842 if (!priv
->dfs_dev_dir
)
845 MWIFIEX_DFS_ADD_FILE(info
);
846 MWIFIEX_DFS_ADD_FILE(debug
);
847 MWIFIEX_DFS_ADD_FILE(getlog
);
848 MWIFIEX_DFS_ADD_FILE(regrdwr
);
849 MWIFIEX_DFS_ADD_FILE(rdeeprom
);
850 MWIFIEX_DFS_ADD_FILE(fw_dump
);
851 MWIFIEX_DFS_ADD_FILE(hscfg
);
855 * This function removes the debug FS directory structure and the files.
858 mwifiex_dev_debugfs_remove(struct mwifiex_private
*priv
)
863 debugfs_remove_recursive(priv
->dfs_dev_dir
);
867 * This function creates the top level proc directory.
870 mwifiex_debugfs_init(void)
872 if (!mwifiex_dfs_dir
)
873 mwifiex_dfs_dir
= debugfs_create_dir("mwifiex", NULL
);
877 * This function removes the top level proc directory.
880 mwifiex_debugfs_remove(void)
883 debugfs_remove(mwifiex_dfs_dir
);