Loading...
1/*
2 * Copyright (c) 2014 Redpine Signals Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17#include "rsi_debugfs.h"
18#include "rsi_sdio.h"
19
20/**
21 * rsi_sdio_stats_read() - This function returns the sdio status of the driver.
22 * @seq: Pointer to the sequence file structure.
23 * @data: Pointer to the data.
24 *
25 * Return: 0 on success, -1 on failure.
26 */
27static int rsi_sdio_stats_read(struct seq_file *seq, void *data)
28{
29 struct rsi_common *common = seq->private;
30 struct rsi_hw *adapter = common->priv;
31 struct rsi_91x_sdiodev *dev = adapter->rsi_dev;
32
33 seq_printf(seq, "total_sdio_interrupts: %d\n",
34 dev->rx_info.sdio_int_counter);
35 seq_printf(seq, "sdio_msdu_pending_intr_count: %d\n",
36 dev->rx_info.total_sdio_msdu_pending_intr);
37 seq_printf(seq, "sdio_buff_full_count : %d\n",
38 dev->rx_info.buf_full_counter);
39 seq_printf(seq, "sdio_buf_semi_full_count %d\n",
40 dev->rx_info.buf_semi_full_counter);
41 seq_printf(seq, "sdio_unknown_intr_count: %d\n",
42 dev->rx_info.total_sdio_unknown_intr);
43 /* RX Path Stats */
44 seq_printf(seq, "BUFFER FULL STATUS : %d\n",
45 dev->rx_info.buffer_full);
46 seq_printf(seq, "SEMI BUFFER FULL STATUS : %d\n",
47 dev->rx_info.semi_buffer_full);
48 seq_printf(seq, "MGMT BUFFER FULL STATUS : %d\n",
49 dev->rx_info.mgmt_buffer_full);
50 seq_printf(seq, "BUFFER FULL COUNTER : %d\n",
51 dev->rx_info.buf_full_counter);
52 seq_printf(seq, "BUFFER SEMI FULL COUNTER : %d\n",
53 dev->rx_info.buf_semi_full_counter);
54 seq_printf(seq, "MGMT BUFFER FULL COUNTER : %d\n",
55 dev->rx_info.mgmt_buf_full_counter);
56
57 return 0;
58}
59
60/**
61 * rsi_sdio_stats_open() - This function calls single open function of seq_file
62 * to open file and read contents from it.
63 * @inode: Pointer to the inode structure.
64 * @file: Pointer to the file structure.
65 *
66 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
67 */
68static int rsi_sdio_stats_open(struct inode *inode,
69 struct file *file)
70{
71 return single_open(file, rsi_sdio_stats_read, inode->i_private);
72}
73
74/**
75 * rsi_version_read() - This function gives driver and firmware version number.
76 * @seq: Pointer to the sequence file structure.
77 * @data: Pointer to the data.
78 *
79 * Return: 0 on success, -1 on failure.
80 */
81static int rsi_version_read(struct seq_file *seq, void *data)
82{
83 struct rsi_common *common = seq->private;
84
85 seq_printf(seq, "LMAC : %d.%d.%d.%d\n",
86 common->lmac_ver.major,
87 common->lmac_ver.minor,
88 common->lmac_ver.release_num,
89 common->lmac_ver.patch_num);
90
91 return 0;
92}
93
94/**
95 * rsi_version_open() - This function calls single open function of seq_file to
96 * open file and read contents from it.
97 * @inode: Pointer to the inode structure.
98 * @file: Pointer to the file structure.
99 *
100 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
101 */
102static int rsi_version_open(struct inode *inode,
103 struct file *file)
104{
105 return single_open(file, rsi_version_read, inode->i_private);
106}
107
108/**
109 * rsi_stats_read() - This function return the status of the driver.
110 * @seq: Pointer to the sequence file structure.
111 * @data: Pointer to the data.
112 *
113 * Return: 0 on success, -1 on failure.
114 */
115static int rsi_stats_read(struct seq_file *seq, void *data)
116{
117 struct rsi_common *common = seq->private;
118
119 static const unsigned char fsm_state[][32] = {
120 "FSM_FW_NOT_LOADED",
121 "FSM_CARD_NOT_READY",
122 "FSM_COMMON_DEV_PARAMS_SENT",
123 "FSM_BOOT_PARAMS_SENT",
124 "FSM_EEPROM_READ_MAC_ADDR",
125 "FSM_EEPROM_READ_RF_TYPE",
126 "FSM_RESET_MAC_SENT",
127 "FSM_RADIO_CAPS_SENT",
128 "FSM_BB_RF_PROG_SENT",
129 "FSM_MAC_INIT_DONE"
130 };
131 seq_puts(seq, "==> RSI STA DRIVER STATUS <==\n");
132 seq_puts(seq, "DRIVER_FSM_STATE: ");
133
134 BUILD_BUG_ON(ARRAY_SIZE(fsm_state) != NUM_FSM_STATES);
135
136 if (common->fsm_state <= FSM_MAC_INIT_DONE)
137 seq_printf(seq, "%s", fsm_state[common->fsm_state]);
138
139 seq_printf(seq, "(%d)\n\n", common->fsm_state);
140
141 /* Mgmt TX Path Stats */
142 seq_printf(seq, "total_mgmt_pkt_send : %d\n",
143 common->tx_stats.total_tx_pkt_send[MGMT_SOFT_Q]);
144 seq_printf(seq, "total_mgmt_pkt_queued : %d\n",
145 skb_queue_len(&common->tx_queue[MGMT_SOFT_Q]));
146 seq_printf(seq, "total_mgmt_pkt_freed : %d\n",
147 common->tx_stats.total_tx_pkt_freed[MGMT_SOFT_Q]);
148
149 /* Data TX Path Stats */
150 seq_printf(seq, "total_data_vo_pkt_send: %8d\t",
151 common->tx_stats.total_tx_pkt_send[VO_Q]);
152 seq_printf(seq, "total_data_vo_pkt_queued: %8d\t",
153 skb_queue_len(&common->tx_queue[VO_Q]));
154 seq_printf(seq, "total_vo_pkt_freed: %8d\n",
155 common->tx_stats.total_tx_pkt_freed[VO_Q]);
156 seq_printf(seq, "total_data_vi_pkt_send: %8d\t",
157 common->tx_stats.total_tx_pkt_send[VI_Q]);
158 seq_printf(seq, "total_data_vi_pkt_queued: %8d\t",
159 skb_queue_len(&common->tx_queue[VI_Q]));
160 seq_printf(seq, "total_vi_pkt_freed: %8d\n",
161 common->tx_stats.total_tx_pkt_freed[VI_Q]);
162 seq_printf(seq, "total_data_be_pkt_send: %8d\t",
163 common->tx_stats.total_tx_pkt_send[BE_Q]);
164 seq_printf(seq, "total_data_be_pkt_queued: %8d\t",
165 skb_queue_len(&common->tx_queue[BE_Q]));
166 seq_printf(seq, "total_be_pkt_freed: %8d\n",
167 common->tx_stats.total_tx_pkt_freed[BE_Q]);
168 seq_printf(seq, "total_data_bk_pkt_send: %8d\t",
169 common->tx_stats.total_tx_pkt_send[BK_Q]);
170 seq_printf(seq, "total_data_bk_pkt_queued: %8d\t",
171 skb_queue_len(&common->tx_queue[BK_Q]));
172 seq_printf(seq, "total_bk_pkt_freed: %8d\n",
173 common->tx_stats.total_tx_pkt_freed[BK_Q]);
174
175 seq_puts(seq, "\n");
176 return 0;
177}
178
179/**
180 * rsi_stats_open() - This function calls single open function of seq_file to
181 * open file and read contents from it.
182 * @inode: Pointer to the inode structure.
183 * @file: Pointer to the file structure.
184 *
185 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
186 */
187static int rsi_stats_open(struct inode *inode,
188 struct file *file)
189{
190 return single_open(file, rsi_stats_read, inode->i_private);
191}
192
193/**
194 * rsi_debug_zone_read() - This function display the currently enabled debug zones.
195 * @seq: Pointer to the sequence file structure.
196 * @data: Pointer to the data.
197 *
198 * Return: 0 on success, -1 on failure.
199 */
200static int rsi_debug_zone_read(struct seq_file *seq, void *data)
201{
202 rsi_dbg(FSM_ZONE, "%x: rsi_enabled zone", rsi_zone_enabled);
203 seq_printf(seq, "The zones available are %#x\n",
204 rsi_zone_enabled);
205 return 0;
206}
207
208/**
209 * rsi_debug_read() - This function calls single open function of seq_file to
210 * open file and read contents from it.
211 * @inode: Pointer to the inode structure.
212 * @file: Pointer to the file structure.
213 *
214 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
215 */
216static int rsi_debug_read(struct inode *inode,
217 struct file *file)
218{
219 return single_open(file, rsi_debug_zone_read, inode->i_private);
220}
221
222/**
223 * rsi_debug_zone_write() - This function writes into hal queues as per user
224 * requirement.
225 * @filp: Pointer to the file structure.
226 * @buff: Pointer to the character buffer.
227 * @len: Length of the data to be written into buffer.
228 * @data: Pointer to the data.
229 *
230 * Return: len: Number of bytes read.
231 */
232static ssize_t rsi_debug_zone_write(struct file *filp,
233 const char __user *buff,
234 size_t len,
235 loff_t *data)
236{
237 unsigned long dbg_zone;
238 int ret;
239
240 if (!len)
241 return 0;
242
243 ret = kstrtoul_from_user(buff, len, 16, &dbg_zone);
244
245 if (ret)
246 return ret;
247
248 rsi_zone_enabled = dbg_zone;
249 return len;
250}
251
252#define FOPS(fopen) { \
253 .owner = THIS_MODULE, \
254 .open = (fopen), \
255 .read = seq_read, \
256 .llseek = seq_lseek, \
257}
258
259#define FOPS_RW(fopen, fwrite) { \
260 .owner = THIS_MODULE, \
261 .open = (fopen), \
262 .read = seq_read, \
263 .llseek = seq_lseek, \
264 .write = (fwrite), \
265}
266
267static const struct rsi_dbg_files dev_debugfs_files[] = {
268 {"version", 0644, FOPS(rsi_version_open),},
269 {"stats", 0644, FOPS(rsi_stats_open),},
270 {"debug_zone", 0666, FOPS_RW(rsi_debug_read, rsi_debug_zone_write),},
271 {"sdio_stats", 0644, FOPS(rsi_sdio_stats_open),},
272};
273
274/**
275 * rsi_init_dbgfs() - This function initializes the dbgfs entry.
276 * @adapter: Pointer to the adapter structure.
277 *
278 * Return: 0 on success, -1 on failure.
279 */
280int rsi_init_dbgfs(struct rsi_hw *adapter)
281{
282 struct rsi_common *common = adapter->priv;
283 struct rsi_debugfs *dev_dbgfs;
284 char devdir[6];
285 int ii;
286 const struct rsi_dbg_files *files;
287
288 dev_dbgfs = kzalloc(sizeof(*dev_dbgfs), GFP_KERNEL);
289 if (!dev_dbgfs)
290 return -ENOMEM;
291
292 adapter->dfsentry = dev_dbgfs;
293
294 snprintf(devdir, sizeof(devdir), "%s",
295 wiphy_name(adapter->hw->wiphy));
296
297 dev_dbgfs->subdir = debugfs_create_dir(devdir, NULL);
298
299 for (ii = 0; ii < adapter->num_debugfs_entries; ii++) {
300 files = &dev_debugfs_files[ii];
301 dev_dbgfs->rsi_files[ii] =
302 debugfs_create_file(files->name,
303 files->perms,
304 dev_dbgfs->subdir,
305 common,
306 &files->fops);
307 }
308 return 0;
309}
310EXPORT_SYMBOL_GPL(rsi_init_dbgfs);
311
312/**
313 * rsi_remove_dbgfs() - Removes the previously created dbgfs file entries
314 * in the reverse order of creation.
315 * @adapter: Pointer to the adapter structure.
316 *
317 * Return: None.
318 */
319void rsi_remove_dbgfs(struct rsi_hw *adapter)
320{
321 struct rsi_debugfs *dev_dbgfs = adapter->dfsentry;
322
323 if (!dev_dbgfs)
324 return;
325
326 debugfs_remove_recursive(dev_dbgfs->subdir);
327}
328EXPORT_SYMBOL_GPL(rsi_remove_dbgfs);
1/*
2 * Copyright (c) 2014 Redpine Signals Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17#include "rsi_debugfs.h"
18#include "rsi_sdio.h"
19
20/**
21 * rsi_sdio_stats_read() - This function returns the sdio status of the driver.
22 * @seq: Pointer to the sequence file structure.
23 * @data: Pointer to the data.
24 *
25 * Return: 0 on success, -1 on failure.
26 */
27static int rsi_sdio_stats_read(struct seq_file *seq, void *data)
28{
29 struct rsi_common *common = seq->private;
30 struct rsi_hw *adapter = common->priv;
31 struct rsi_91x_sdiodev *dev =
32 (struct rsi_91x_sdiodev *)adapter->rsi_dev;
33
34 seq_printf(seq, "total_sdio_interrupts: %d\n",
35 dev->rx_info.sdio_int_counter);
36 seq_printf(seq, "sdio_msdu_pending_intr_count: %d\n",
37 dev->rx_info.total_sdio_msdu_pending_intr);
38 seq_printf(seq, "sdio_buff_full_count : %d\n",
39 dev->rx_info.buf_full_counter);
40 seq_printf(seq, "sdio_buf_semi_full_count %d\n",
41 dev->rx_info.buf_semi_full_counter);
42 seq_printf(seq, "sdio_unknown_intr_count: %d\n",
43 dev->rx_info.total_sdio_unknown_intr);
44 /* RX Path Stats */
45 seq_printf(seq, "BUFFER FULL STATUS : %d\n",
46 dev->rx_info.buffer_full);
47 seq_printf(seq, "SEMI BUFFER FULL STATUS : %d\n",
48 dev->rx_info.semi_buffer_full);
49 seq_printf(seq, "MGMT BUFFER FULL STATUS : %d\n",
50 dev->rx_info.mgmt_buffer_full);
51 seq_printf(seq, "BUFFER FULL COUNTER : %d\n",
52 dev->rx_info.buf_full_counter);
53 seq_printf(seq, "BUFFER SEMI FULL COUNTER : %d\n",
54 dev->rx_info.buf_semi_full_counter);
55 seq_printf(seq, "MGMT BUFFER FULL COUNTER : %d\n",
56 dev->rx_info.mgmt_buf_full_counter);
57
58 return 0;
59}
60
61/**
62 * rsi_sdio_stats_open() - This function calls single open function of seq_file
63 * to open file and read contents from it.
64 * @inode: Pointer to the inode structure.
65 * @file: Pointer to the file structure.
66 *
67 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
68 */
69static int rsi_sdio_stats_open(struct inode *inode,
70 struct file *file)
71{
72 return single_open(file, rsi_sdio_stats_read, inode->i_private);
73}
74
75/**
76 * rsi_version_read() - This function gives driver and firmware version number.
77 * @seq: Pointer to the sequence file structure.
78 * @data: Pointer to the data.
79 *
80 * Return: 0 on success, -1 on failure.
81 */
82static int rsi_version_read(struct seq_file *seq, void *data)
83{
84 struct rsi_common *common = seq->private;
85
86 seq_printf(seq, "LMAC : %d.%d.%d.%d\n",
87 common->lmac_ver.major,
88 common->lmac_ver.minor,
89 common->lmac_ver.release_num,
90 common->lmac_ver.patch_num);
91
92 return 0;
93}
94
95/**
96 * rsi_version_open() - This function calls single open function of seq_file to
97 * open file and read contents from it.
98 * @inode: Pointer to the inode structure.
99 * @file: Pointer to the file structure.
100 *
101 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
102 */
103static int rsi_version_open(struct inode *inode,
104 struct file *file)
105{
106 return single_open(file, rsi_version_read, inode->i_private);
107}
108
109/**
110 * rsi_stats_read() - This function return the status of the driver.
111 * @seq: Pointer to the sequence file structure.
112 * @data: Pointer to the data.
113 *
114 * Return: 0 on success, -1 on failure.
115 */
116static int rsi_stats_read(struct seq_file *seq, void *data)
117{
118 struct rsi_common *common = seq->private;
119
120 static const unsigned char fsm_state[][32] = {
121 "FSM_FW_NOT_LOADED",
122 "FSM_CARD_NOT_READY",
123 "FSM_COMMON_DEV_PARAMS_SENT",
124 "FSM_BOOT_PARAMS_SENT",
125 "FSM_EEPROM_READ_MAC_ADDR",
126 "FSM_EEPROM_READ_RF_TYPE",
127 "FSM_RESET_MAC_SENT",
128 "FSM_RADIO_CAPS_SENT",
129 "FSM_BB_RF_PROG_SENT",
130 "FSM_MAC_INIT_DONE"
131 };
132 seq_puts(seq, "==> RSI STA DRIVER STATUS <==\n");
133 seq_puts(seq, "DRIVER_FSM_STATE: ");
134
135 BUILD_BUG_ON(ARRAY_SIZE(fsm_state) != NUM_FSM_STATES);
136
137 if (common->fsm_state <= FSM_MAC_INIT_DONE)
138 seq_printf(seq, "%s", fsm_state[common->fsm_state]);
139
140 seq_printf(seq, "(%d)\n\n", common->fsm_state);
141
142 /* Mgmt TX Path Stats */
143 seq_printf(seq, "total_mgmt_pkt_send : %d\n",
144 common->tx_stats.total_tx_pkt_send[MGMT_SOFT_Q]);
145 seq_printf(seq, "total_mgmt_pkt_queued : %d\n",
146 skb_queue_len(&common->tx_queue[MGMT_SOFT_Q]));
147 seq_printf(seq, "total_mgmt_pkt_freed : %d\n",
148 common->tx_stats.total_tx_pkt_freed[MGMT_SOFT_Q]);
149
150 /* Data TX Path Stats */
151 seq_printf(seq, "total_data_vo_pkt_send: %8d\t",
152 common->tx_stats.total_tx_pkt_send[VO_Q]);
153 seq_printf(seq, "total_data_vo_pkt_queued: %8d\t",
154 skb_queue_len(&common->tx_queue[VO_Q]));
155 seq_printf(seq, "total_vo_pkt_freed: %8d\n",
156 common->tx_stats.total_tx_pkt_freed[VO_Q]);
157 seq_printf(seq, "total_data_vi_pkt_send: %8d\t",
158 common->tx_stats.total_tx_pkt_send[VI_Q]);
159 seq_printf(seq, "total_data_vi_pkt_queued: %8d\t",
160 skb_queue_len(&common->tx_queue[VI_Q]));
161 seq_printf(seq, "total_vi_pkt_freed: %8d\n",
162 common->tx_stats.total_tx_pkt_freed[VI_Q]);
163 seq_printf(seq, "total_data_be_pkt_send: %8d\t",
164 common->tx_stats.total_tx_pkt_send[BE_Q]);
165 seq_printf(seq, "total_data_be_pkt_queued: %8d\t",
166 skb_queue_len(&common->tx_queue[BE_Q]));
167 seq_printf(seq, "total_be_pkt_freed: %8d\n",
168 common->tx_stats.total_tx_pkt_freed[BE_Q]);
169 seq_printf(seq, "total_data_bk_pkt_send: %8d\t",
170 common->tx_stats.total_tx_pkt_send[BK_Q]);
171 seq_printf(seq, "total_data_bk_pkt_queued: %8d\t",
172 skb_queue_len(&common->tx_queue[BK_Q]));
173 seq_printf(seq, "total_bk_pkt_freed: %8d\n",
174 common->tx_stats.total_tx_pkt_freed[BK_Q]);
175
176 seq_puts(seq, "\n");
177 return 0;
178}
179
180/**
181 * rsi_stats_open() - This function calls single open function of seq_file to
182 * open file and read contents from it.
183 * @inode: Pointer to the inode structure.
184 * @file: Pointer to the file structure.
185 *
186 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
187 */
188static int rsi_stats_open(struct inode *inode,
189 struct file *file)
190{
191 return single_open(file, rsi_stats_read, inode->i_private);
192}
193
194/**
195 * rsi_debug_zone_read() - This function display the currently enabled debug zones.
196 * @seq: Pointer to the sequence file structure.
197 * @data: Pointer to the data.
198 *
199 * Return: 0 on success, -1 on failure.
200 */
201static int rsi_debug_zone_read(struct seq_file *seq, void *data)
202{
203 rsi_dbg(FSM_ZONE, "%x: rsi_enabled zone", rsi_zone_enabled);
204 seq_printf(seq, "The zones available are %#x\n",
205 rsi_zone_enabled);
206 return 0;
207}
208
209/**
210 * rsi_debug_read() - This function calls single open function of seq_file to
211 * open file and read contents from it.
212 * @inode: Pointer to the inode structure.
213 * @file: Pointer to the file structure.
214 *
215 * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure.
216 */
217static int rsi_debug_read(struct inode *inode,
218 struct file *file)
219{
220 return single_open(file, rsi_debug_zone_read, inode->i_private);
221}
222
223/**
224 * rsi_debug_zone_write() - This function writes into hal queues as per user
225 * requirement.
226 * @filp: Pointer to the file structure.
227 * @buff: Pointer to the character buffer.
228 * @len: Length of the data to be written into buffer.
229 * @data: Pointer to the data.
230 *
231 * Return: len: Number of bytes read.
232 */
233static ssize_t rsi_debug_zone_write(struct file *filp,
234 const char __user *buff,
235 size_t len,
236 loff_t *data)
237{
238 unsigned long dbg_zone;
239 int ret;
240
241 if (!len)
242 return 0;
243
244 ret = kstrtoul_from_user(buff, len, 16, &dbg_zone);
245
246 if (ret)
247 return ret;
248
249 rsi_zone_enabled = dbg_zone;
250 return len;
251}
252
253#define FOPS(fopen) { \
254 .owner = THIS_MODULE, \
255 .open = (fopen), \
256 .read = seq_read, \
257 .llseek = seq_lseek, \
258}
259
260#define FOPS_RW(fopen, fwrite) { \
261 .owner = THIS_MODULE, \
262 .open = (fopen), \
263 .read = seq_read, \
264 .llseek = seq_lseek, \
265 .write = (fwrite), \
266}
267
268static const struct rsi_dbg_files dev_debugfs_files[] = {
269 {"version", 0644, FOPS(rsi_version_open),},
270 {"stats", 0644, FOPS(rsi_stats_open),},
271 {"debug_zone", 0666, FOPS_RW(rsi_debug_read, rsi_debug_zone_write),},
272 {"sdio_stats", 0644, FOPS(rsi_sdio_stats_open),},
273};
274
275/**
276 * rsi_init_dbgfs() - This function initializes the dbgfs entry.
277 * @adapter: Pointer to the adapter structure.
278 *
279 * Return: 0 on success, -1 on failure.
280 */
281int rsi_init_dbgfs(struct rsi_hw *adapter)
282{
283 struct rsi_common *common = adapter->priv;
284 struct rsi_debugfs *dev_dbgfs;
285 char devdir[6];
286 int ii;
287 const struct rsi_dbg_files *files;
288
289 dev_dbgfs = kzalloc(sizeof(*dev_dbgfs), GFP_KERNEL);
290 if (!dev_dbgfs)
291 return -ENOMEM;
292
293 adapter->dfsentry = dev_dbgfs;
294
295 snprintf(devdir, sizeof(devdir), "%s",
296 wiphy_name(adapter->hw->wiphy));
297
298 dev_dbgfs->subdir = debugfs_create_dir(devdir, NULL);
299
300 for (ii = 0; ii < adapter->num_debugfs_entries; ii++) {
301 files = &dev_debugfs_files[ii];
302 dev_dbgfs->rsi_files[ii] =
303 debugfs_create_file(files->name,
304 files->perms,
305 dev_dbgfs->subdir,
306 common,
307 &files->fops);
308 }
309 return 0;
310}
311EXPORT_SYMBOL_GPL(rsi_init_dbgfs);
312
313/**
314 * rsi_remove_dbgfs() - Removes the previously created dbgfs file entries
315 * in the reverse order of creation.
316 * @adapter: Pointer to the adapter structure.
317 *
318 * Return: None.
319 */
320void rsi_remove_dbgfs(struct rsi_hw *adapter)
321{
322 struct rsi_debugfs *dev_dbgfs = adapter->dfsentry;
323
324 if (!dev_dbgfs)
325 return;
326
327 debugfs_remove_recursive(dev_dbgfs->subdir);
328}
329EXPORT_SYMBOL_GPL(rsi_remove_dbgfs);