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
300 * - Number of received beacons
301 * - Number of missed beacons
304 mwifiex_getlog_read(struct file
*file
, char __user
*ubuf
,
305 size_t count
, loff_t
*ppos
)
307 struct mwifiex_private
*priv
=
308 (struct mwifiex_private
*) file
->private_data
;
309 unsigned long page
= get_zeroed_page(GFP_KERNEL
);
310 char *p
= (char *) page
;
312 struct mwifiex_ds_get_stats stats
;
317 memset(&stats
, 0, sizeof(stats
));
318 ret
= mwifiex_get_stats_info(priv
, &stats
);
335 "wepicverrcnt-1 %u\n"
336 "wepicverrcnt-2 %u\n"
337 "wepicverrcnt-3 %u\n"
338 "wepicverrcnt-4 %u\n"
341 stats
.mcast_tx_frame
,
350 stats
.mcast_rx_frame
,
353 stats
.wep_icv_error
[0],
354 stats
.wep_icv_error
[1],
355 stats
.wep_icv_error
[2],
356 stats
.wep_icv_error
[3],
361 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, (char *) page
,
362 (unsigned long) p
- page
);
369 static struct mwifiex_debug_info info
;
372 * Proc debug file read handler.
374 * This function is called when the 'debug' file is opened for reading
375 * It prints the following log information -
377 * - WMM AC VO packets count
378 * - WMM AC VI packets count
379 * - WMM AC BE packets count
380 * - WMM AC BK packets count
381 * - Maximum Tx buffer size
383 * - Current Tx buffer size
386 * - Deep Sleep status
387 * - Device wakeup required status
388 * - Number of wakeup tries
389 * - Host Sleep configured status
390 * - Host Sleep activated status
391 * - Number of Tx timeouts
392 * - Number of command timeouts
393 * - Last timed out command ID
394 * - Last timed out command action
396 * - Last command action
397 * - Last command index
398 * - Last command response ID
399 * - Last command response index
402 * - Number of host to card command failures
403 * - Number of sleep confirm command failures
404 * - Number of host to card data failure
405 * - Number of deauthentication events
406 * - Number of disassociation events
407 * - Number of link lost events
408 * - Number of deauthentication commands
409 * - Number of association success commands
410 * - Number of association failure commands
411 * - Number of commands sent
412 * - Number of data packets sent
413 * - Number of command responses received
414 * - Number of events received
415 * - Tx BA stream table (TID, RA)
416 * - Rx reorder table (TID, TA, Start window, Window size, Buffer)
419 mwifiex_debug_read(struct file
*file
, char __user
*ubuf
,
420 size_t count
, loff_t
*ppos
)
422 struct mwifiex_private
*priv
=
423 (struct mwifiex_private
*) file
->private_data
;
424 struct mwifiex_debug_data
*d
= &items
[0];
425 unsigned long page
= get_zeroed_page(GFP_KERNEL
);
426 char *p
= (char *) page
;
435 ret
= mwifiex_get_debug_info(priv
, &info
);
439 for (i
= 0; i
< num_of_items
; i
++) {
440 p
+= sprintf(p
, "%s=", d
[i
].name
);
442 size
= d
[i
].size
/ d
[i
].num
;
444 if (i
< (num_of_items
- 3))
445 addr
= d
[i
].addr
+ (size_t) &info
;
446 else /* The last 3 items are struct mwifiex_adapter variables */
447 addr
= d
[i
].addr
+ (size_t) priv
->adapter
;
449 for (j
= 0; j
< d
[i
].num
; j
++) {
452 val
= *((u8
*) addr
);
455 val
= *((u16
*) addr
);
458 val
= *((u32
*) addr
);
461 val
= *((long long *) addr
);
468 p
+= sprintf(p
, "%#lx ", val
);
472 p
+= sprintf(p
, "\n");
475 if (info
.tx_tbl_num
) {
476 p
+= sprintf(p
, "Tx BA stream table:\n");
477 for (i
= 0; i
< info
.tx_tbl_num
; i
++)
478 p
+= sprintf(p
, "tid = %d, ra = %pM\n",
479 info
.tx_tbl
[i
].tid
, info
.tx_tbl
[i
].ra
);
482 if (info
.rx_tbl_num
) {
483 p
+= sprintf(p
, "Rx reorder table:\n");
484 for (i
= 0; i
< info
.rx_tbl_num
; i
++) {
485 p
+= sprintf(p
, "tid = %d, ta = %pM, "
487 "win_size = %d, buffer: ",
490 info
.rx_tbl
[i
].start_win
,
491 info
.rx_tbl
[i
].win_size
);
493 for (j
= 0; j
< info
.rx_tbl
[i
].win_size
; j
++)
494 p
+= sprintf(p
, "%c ",
495 info
.rx_tbl
[i
].buffer
[j
] ?
498 p
+= sprintf(p
, "\n");
502 if (info
.tdls_peer_num
) {
503 p
+= sprintf(p
, "TDLS peer table:\n");
504 for (i
= 0; i
< info
.tdls_peer_num
; i
++) {
505 p
+= sprintf(p
, "peer = %pM",
506 info
.tdls_list
[i
].peer_addr
);
507 p
+= sprintf(p
, "\n");
511 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, (char *) page
,
512 (unsigned long) p
- page
);
519 static u32 saved_reg_type
, saved_reg_offset
, saved_reg_value
;
522 * Proc regrdwr file write handler.
524 * This function is called when the 'regrdwr' file is opened for writing
526 * This function can be used to write to a register.
529 mwifiex_regrdwr_write(struct file
*file
,
530 const char __user
*ubuf
, size_t count
, loff_t
*ppos
)
532 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
533 char *buf
= (char *) addr
;
534 size_t buf_size
= min_t(size_t, count
, PAGE_SIZE
- 1);
536 u32 reg_type
= 0, reg_offset
= 0, reg_value
= UINT_MAX
;
542 if (copy_from_user(buf
, ubuf
, buf_size
)) {
547 sscanf(buf
, "%u %x %x", ®_type
, ®_offset
, ®_value
);
549 if (reg_type
== 0 || reg_offset
== 0) {
553 saved_reg_type
= reg_type
;
554 saved_reg_offset
= reg_offset
;
555 saved_reg_value
= reg_value
;
564 * Proc regrdwr file read handler.
566 * This function is called when the 'regrdwr' file is opened for reading
568 * This function can be used to read from a register.
571 mwifiex_regrdwr_read(struct file
*file
, char __user
*ubuf
,
572 size_t count
, loff_t
*ppos
)
574 struct mwifiex_private
*priv
=
575 (struct mwifiex_private
*) file
->private_data
;
576 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
577 char *buf
= (char *) addr
;
578 int pos
= 0, ret
= 0;
584 if (!saved_reg_type
) {
585 /* No command has been given */
586 pos
+= snprintf(buf
, PAGE_SIZE
, "0");
589 /* Set command has been given */
590 if (saved_reg_value
!= UINT_MAX
) {
591 ret
= mwifiex_reg_write(priv
, saved_reg_type
, saved_reg_offset
,
594 pos
+= snprintf(buf
, PAGE_SIZE
, "%u 0x%x 0x%x\n",
595 saved_reg_type
, saved_reg_offset
,
598 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
602 /* Get command has been given */
603 ret
= mwifiex_reg_read(priv
, saved_reg_type
,
604 saved_reg_offset
, ®_value
);
610 pos
+= snprintf(buf
, PAGE_SIZE
, "%u 0x%x 0x%x\n", saved_reg_type
,
611 saved_reg_offset
, reg_value
);
613 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
620 static u32 saved_offset
= -1, saved_bytes
= -1;
623 * Proc rdeeprom file write handler.
625 * This function is called when the 'rdeeprom' file is opened for writing
627 * This function can be used to write to a RDEEPROM location.
630 mwifiex_rdeeprom_write(struct file
*file
,
631 const char __user
*ubuf
, size_t count
, loff_t
*ppos
)
633 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
634 char *buf
= (char *) addr
;
635 size_t buf_size
= min_t(size_t, count
, PAGE_SIZE
- 1);
637 int offset
= -1, bytes
= -1;
643 if (copy_from_user(buf
, ubuf
, buf_size
)) {
648 sscanf(buf
, "%d %d", &offset
, &bytes
);
650 if (offset
== -1 || bytes
== -1) {
654 saved_offset
= offset
;
664 * Proc rdeeprom read write handler.
666 * This function is called when the 'rdeeprom' file is opened for reading
668 * This function can be used to read from a RDEEPROM location.
671 mwifiex_rdeeprom_read(struct file
*file
, char __user
*ubuf
,
672 size_t count
, loff_t
*ppos
)
674 struct mwifiex_private
*priv
=
675 (struct mwifiex_private
*) file
->private_data
;
676 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
677 char *buf
= (char *) addr
;
678 int pos
= 0, ret
= 0, i
;
679 u8 value
[MAX_EEPROM_DATA
];
684 if (saved_offset
== -1) {
685 /* No command has been given */
686 pos
+= snprintf(buf
, PAGE_SIZE
, "0");
690 /* Get command has been given */
691 ret
= mwifiex_eeprom_read(priv
, (u16
) saved_offset
,
692 (u16
) saved_bytes
, value
);
698 pos
+= snprintf(buf
, PAGE_SIZE
, "%d %d ", saved_offset
, saved_bytes
);
700 for (i
= 0; i
< saved_bytes
; i
++)
701 pos
+= snprintf(buf
+ strlen(buf
), PAGE_SIZE
, "%d ", value
[i
]);
703 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
710 /* Proc hscfg file write handler
711 * This function can be used to configure the host sleep parameters.
714 mwifiex_hscfg_write(struct file
*file
, const char __user
*ubuf
,
715 size_t count
, loff_t
*ppos
)
717 struct mwifiex_private
*priv
= (void *)file
->private_data
;
718 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
719 char *buf
= (char *)addr
;
720 size_t buf_size
= min_t(size_t, count
, PAGE_SIZE
- 1);
722 struct mwifiex_ds_hs_cfg hscfg
;
723 int conditions
= HS_CFG_COND_DEF
;
724 u32 gpio
= HS_CFG_GPIO_DEF
, gap
= HS_CFG_GAP_DEF
;
729 if (copy_from_user(buf
, ubuf
, buf_size
)) {
734 arg_num
= sscanf(buf
, "%d %x %x", &conditions
, &gpio
, &gap
);
736 memset(&hscfg
, 0, sizeof(struct mwifiex_ds_hs_cfg
));
739 dev_err(priv
->adapter
->dev
, "Too many arguments\n");
744 if (arg_num
>= 1 && arg_num
< 3)
745 mwifiex_set_hs_params(priv
, HostCmd_ACT_GEN_GET
,
746 MWIFIEX_SYNC_CMD
, &hscfg
);
749 if (conditions
== HS_CFG_CANCEL
) {
750 mwifiex_cancel_hs(priv
, MWIFIEX_ASYNC_CMD
);
754 hscfg
.conditions
= conditions
;
761 hscfg
.is_invoke_hostcmd
= false;
762 mwifiex_set_hs_params(priv
, HostCmd_ACT_GEN_SET
,
763 MWIFIEX_SYNC_CMD
, &hscfg
);
765 mwifiex_enable_hs(priv
->adapter
);
766 priv
->adapter
->hs_enabling
= false;
773 /* Proc hscfg file read handler
774 * This function can be used to read host sleep configuration
775 * parameters from driver.
778 mwifiex_hscfg_read(struct file
*file
, char __user
*ubuf
,
779 size_t count
, loff_t
*ppos
)
781 struct mwifiex_private
*priv
= (void *)file
->private_data
;
782 unsigned long addr
= get_zeroed_page(GFP_KERNEL
);
783 char *buf
= (char *)addr
;
785 struct mwifiex_ds_hs_cfg hscfg
;
790 mwifiex_set_hs_params(priv
, HostCmd_ACT_GEN_GET
,
791 MWIFIEX_SYNC_CMD
, &hscfg
);
793 pos
= snprintf(buf
, PAGE_SIZE
, "%u 0x%x 0x%x\n", hscfg
.conditions
,
794 hscfg
.gpio
, hscfg
.gap
);
796 ret
= simple_read_from_buffer(ubuf
, count
, ppos
, buf
, pos
);
802 #define MWIFIEX_DFS_ADD_FILE(name) do { \
803 if (!debugfs_create_file(#name, 0644, priv->dfs_dev_dir, \
804 priv, &mwifiex_dfs_##name##_fops)) \
808 #define MWIFIEX_DFS_FILE_OPS(name) \
809 static const struct file_operations mwifiex_dfs_##name##_fops = { \
810 .read = mwifiex_##name##_read, \
811 .write = mwifiex_##name##_write, \
812 .open = simple_open, \
815 #define MWIFIEX_DFS_FILE_READ_OPS(name) \
816 static const struct file_operations mwifiex_dfs_##name##_fops = { \
817 .read = mwifiex_##name##_read, \
818 .open = simple_open, \
821 #define MWIFIEX_DFS_FILE_WRITE_OPS(name) \
822 static const struct file_operations mwifiex_dfs_##name##_fops = { \
823 .write = mwifiex_##name##_write, \
824 .open = simple_open, \
828 MWIFIEX_DFS_FILE_READ_OPS(info
);
829 MWIFIEX_DFS_FILE_READ_OPS(debug
);
830 MWIFIEX_DFS_FILE_READ_OPS(getlog
);
831 MWIFIEX_DFS_FILE_READ_OPS(fw_dump
);
832 MWIFIEX_DFS_FILE_OPS(regrdwr
);
833 MWIFIEX_DFS_FILE_OPS(rdeeprom
);
834 MWIFIEX_DFS_FILE_OPS(hscfg
);
837 * This function creates the debug FS directory structure and the files.
840 mwifiex_dev_debugfs_init(struct mwifiex_private
*priv
)
842 if (!mwifiex_dfs_dir
|| !priv
)
845 priv
->dfs_dev_dir
= debugfs_create_dir(priv
->netdev
->name
,
848 if (!priv
->dfs_dev_dir
)
851 MWIFIEX_DFS_ADD_FILE(info
);
852 MWIFIEX_DFS_ADD_FILE(debug
);
853 MWIFIEX_DFS_ADD_FILE(getlog
);
854 MWIFIEX_DFS_ADD_FILE(regrdwr
);
855 MWIFIEX_DFS_ADD_FILE(rdeeprom
);
856 MWIFIEX_DFS_ADD_FILE(fw_dump
);
857 MWIFIEX_DFS_ADD_FILE(hscfg
);
861 * This function removes the debug FS directory structure and the files.
864 mwifiex_dev_debugfs_remove(struct mwifiex_private
*priv
)
869 debugfs_remove_recursive(priv
->dfs_dev_dir
);
873 * This function creates the top level proc directory.
876 mwifiex_debugfs_init(void)
878 if (!mwifiex_dfs_dir
)
879 mwifiex_dfs_dir
= debugfs_create_dir("mwifiex", NULL
);
883 * This function removes the top level proc directory.
886 mwifiex_debugfs_remove(void)
889 debugfs_remove(mwifiex_dfs_dir
);