]>
Commit | Line | Data |
---|---|---|
dad0d04f FF |
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 | */ | |
27 | static 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 funtion 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 | */ | |
69 | static 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 | */ | |
82 | static int rsi_version_read(struct seq_file *seq, void *data) | |
83 | { | |
84 | struct rsi_common *common = seq->private; | |
85 | ||
86 | common->driver_ver.major = 0; | |
87 | common->driver_ver.minor = 1; | |
88 | common->driver_ver.release_num = 0; | |
89 | common->driver_ver.patch_num = 0; | |
90 | seq_printf(seq, "Driver : %x.%d.%d.%d\nLMAC : %d.%d.%d.%d\n", | |
91 | common->driver_ver.major, | |
92 | common->driver_ver.minor, | |
93 | common->driver_ver.release_num, | |
94 | common->driver_ver.patch_num, | |
95 | common->fw_ver.major, | |
96 | common->fw_ver.minor, | |
97 | common->fw_ver.release_num, | |
98 | common->fw_ver.patch_num); | |
99 | return 0; | |
100 | } | |
101 | ||
102 | /** | |
103 | * rsi_version_open() - This funtion calls single open function of seq_file to | |
104 | * open file and read contents from it. | |
105 | * @inode: Pointer to the inode structure. | |
106 | * @file: Pointer to the file structure. | |
107 | * | |
108 | * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure. | |
109 | */ | |
110 | static int rsi_version_open(struct inode *inode, | |
111 | struct file *file) | |
112 | { | |
113 | return single_open(file, rsi_version_read, inode->i_private); | |
114 | } | |
115 | ||
116 | /** | |
117 | * rsi_stats_read() - This function return the status of the driver. | |
118 | * @seq: Pointer to the sequence file structure. | |
119 | * @data: Pointer to the data. | |
120 | * | |
121 | * Return: 0 on success, -1 on failure. | |
122 | */ | |
123 | static int rsi_stats_read(struct seq_file *seq, void *data) | |
124 | { | |
125 | struct rsi_common *common = seq->private; | |
126 | ||
127 | unsigned char fsm_state[][32] = { | |
128 | "FSM_CARD_NOT_READY", | |
129 | "FSM_BOOT_PARAMS_SENT", | |
130 | "FSM_EEPROM_READ_MAC_ADDR", | |
131 | "FSM_RESET_MAC_SENT", | |
132 | "FSM_RADIO_CAPS_SENT", | |
133 | "FSM_BB_RF_PROG_SENT", | |
134 | "FSM_MAC_INIT_DONE" | |
135 | }; | |
136 | seq_puts(seq, "==> RSI STA DRIVER STATUS <==\n"); | |
137 | seq_puts(seq, "DRIVER_FSM_STATE: "); | |
138 | ||
139 | if (common->fsm_state <= FSM_MAC_INIT_DONE) | |
140 | seq_printf(seq, "%s", fsm_state[common->fsm_state]); | |
141 | ||
142 | seq_printf(seq, "(%d)\n\n", common->fsm_state); | |
143 | ||
144 | /* Mgmt TX Path Stats */ | |
145 | seq_printf(seq, "total_mgmt_pkt_send : %d\n", | |
146 | common->tx_stats.total_tx_pkt_send[MGMT_SOFT_Q]); | |
147 | seq_printf(seq, "total_mgmt_pkt_queued : %d\n", | |
148 | skb_queue_len(&common->tx_queue[4])); | |
149 | seq_printf(seq, "total_mgmt_pkt_freed : %d\n", | |
150 | common->tx_stats.total_tx_pkt_freed[MGMT_SOFT_Q]); | |
151 | ||
152 | /* Data TX Path Stats */ | |
153 | seq_printf(seq, "total_data_vo_pkt_send: %8d\t", | |
154 | common->tx_stats.total_tx_pkt_send[VO_Q]); | |
155 | seq_printf(seq, "total_data_vo_pkt_queued: %8d\t", | |
156 | skb_queue_len(&common->tx_queue[0])); | |
157 | seq_printf(seq, "total_vo_pkt_freed: %8d\n", | |
158 | common->tx_stats.total_tx_pkt_freed[VO_Q]); | |
159 | seq_printf(seq, "total_data_vi_pkt_send: %8d\t", | |
160 | common->tx_stats.total_tx_pkt_send[VI_Q]); | |
161 | seq_printf(seq, "total_data_vi_pkt_queued: %8d\t", | |
162 | skb_queue_len(&common->tx_queue[1])); | |
163 | seq_printf(seq, "total_vi_pkt_freed: %8d\n", | |
164 | common->tx_stats.total_tx_pkt_freed[VI_Q]); | |
165 | seq_printf(seq, "total_data_be_pkt_send: %8d\t", | |
166 | common->tx_stats.total_tx_pkt_send[BE_Q]); | |
167 | seq_printf(seq, "total_data_be_pkt_queued: %8d\t", | |
168 | skb_queue_len(&common->tx_queue[2])); | |
169 | seq_printf(seq, "total_be_pkt_freed: %8d\n", | |
170 | common->tx_stats.total_tx_pkt_freed[BE_Q]); | |
171 | seq_printf(seq, "total_data_bk_pkt_send: %8d\t", | |
172 | common->tx_stats.total_tx_pkt_send[BK_Q]); | |
173 | seq_printf(seq, "total_data_bk_pkt_queued: %8d\t", | |
174 | skb_queue_len(&common->tx_queue[3])); | |
175 | seq_printf(seq, "total_bk_pkt_freed: %8d\n", | |
176 | common->tx_stats.total_tx_pkt_freed[BK_Q]); | |
177 | ||
178 | seq_puts(seq, "\n"); | |
179 | return 0; | |
180 | } | |
181 | ||
182 | /** | |
183 | * rsi_stats_open() - This funtion calls single open function of seq_file to | |
184 | * open file and read contents from it. | |
185 | * @inode: Pointer to the inode structure. | |
186 | * @file: Pointer to the file structure. | |
187 | * | |
188 | * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure. | |
189 | */ | |
190 | static int rsi_stats_open(struct inode *inode, | |
191 | struct file *file) | |
192 | { | |
193 | return single_open(file, rsi_stats_read, inode->i_private); | |
194 | } | |
195 | ||
196 | /** | |
197 | * rsi_debug_zone_read() - This function display the currently enabled debug zones. | |
198 | * @seq: Pointer to the sequence file structure. | |
199 | * @data: Pointer to the data. | |
200 | * | |
201 | * Return: 0 on success, -1 on failure. | |
202 | */ | |
203 | static int rsi_debug_zone_read(struct seq_file *seq, void *data) | |
204 | { | |
205 | rsi_dbg(FSM_ZONE, "%x: rsi_enabled zone", rsi_zone_enabled); | |
206 | seq_printf(seq, "The zones available are %#x\n", | |
207 | rsi_zone_enabled); | |
208 | return 0; | |
209 | } | |
210 | ||
211 | /** | |
212 | * rsi_debug_read() - This funtion calls single open function of seq_file to | |
213 | * open file and read contents from it. | |
214 | * @inode: Pointer to the inode structure. | |
215 | * @file: Pointer to the file structure. | |
216 | * | |
217 | * Return: Pointer to the opened file status: 0 on success, ENOMEM on failure. | |
218 | */ | |
219 | static int rsi_debug_read(struct inode *inode, | |
220 | struct file *file) | |
221 | { | |
222 | return single_open(file, rsi_debug_zone_read, inode->i_private); | |
223 | } | |
224 | ||
225 | /** | |
226 | * rsi_debug_zone_write() - This function writes into hal queues as per user | |
227 | * requirement. | |
228 | * @filp: Pointer to the file structure. | |
229 | * @buff: Pointer to the character buffer. | |
230 | * @len: Length of the data to be written into buffer. | |
231 | * @data: Pointer to the data. | |
232 | * | |
233 | * Return: len: Number of bytes read. | |
234 | */ | |
235 | static ssize_t rsi_debug_zone_write(struct file *filp, | |
236 | const char __user *buff, | |
237 | size_t len, | |
238 | loff_t *data) | |
239 | { | |
240 | unsigned long dbg_zone; | |
241 | int ret; | |
242 | ||
243 | if (!len) | |
244 | return 0; | |
245 | ||
246 | ret = kstrtoul_from_user(buff, len, 16, &dbg_zone); | |
247 | ||
248 | if (ret) | |
249 | return ret; | |
250 | ||
251 | rsi_zone_enabled = dbg_zone; | |
252 | return len; | |
253 | } | |
254 | ||
255 | #define FOPS(fopen) { \ | |
256 | .owner = THIS_MODULE, \ | |
257 | .open = (fopen), \ | |
258 | .read = seq_read, \ | |
259 | .llseek = seq_lseek, \ | |
260 | } | |
261 | ||
262 | #define FOPS_RW(fopen, fwrite) { \ | |
263 | .owner = THIS_MODULE, \ | |
264 | .open = (fopen), \ | |
265 | .read = seq_read, \ | |
266 | .llseek = seq_lseek, \ | |
267 | .write = (fwrite), \ | |
268 | } | |
269 | ||
270 | static const struct rsi_dbg_files dev_debugfs_files[] = { | |
271 | {"version", 0644, FOPS(rsi_version_open),}, | |
272 | {"stats", 0644, FOPS(rsi_stats_open),}, | |
273 | {"debug_zone", 0666, FOPS_RW(rsi_debug_read, rsi_debug_zone_write),}, | |
274 | {"sdio_stats", 0644, FOPS(rsi_sdio_stats_open),}, | |
275 | }; | |
276 | ||
277 | /** | |
278 | * rsi_init_dbgfs() - This function initializes the dbgfs entry. | |
279 | * @adapter: Pointer to the adapter structure. | |
280 | * | |
281 | * Return: 0 on success, -1 on failure. | |
282 | */ | |
283 | int rsi_init_dbgfs(struct rsi_hw *adapter) | |
284 | { | |
285 | struct rsi_common *common = adapter->priv; | |
286 | struct rsi_debugfs *dev_dbgfs; | |
287 | char devdir[6]; | |
288 | int ii; | |
289 | const struct rsi_dbg_files *files; | |
290 | ||
291 | dev_dbgfs = kzalloc(sizeof(*dev_dbgfs), GFP_KERNEL); | |
b25e77fd FF |
292 | if (!dev_dbgfs) |
293 | return -ENOMEM; | |
294 | ||
dad0d04f FF |
295 | adapter->dfsentry = dev_dbgfs; |
296 | ||
297 | snprintf(devdir, sizeof(devdir), "%s", | |
298 | wiphy_name(adapter->hw->wiphy)); | |
dad0d04f | 299 | |
b25e77fd | 300 | dev_dbgfs->subdir = debugfs_create_dir(devdir, NULL); |
dad0d04f | 301 | |
b25e77fd | 302 | if (!dev_dbgfs->subdir) { |
dad0d04f | 303 | kfree(dev_dbgfs); |
b25e77fd FF |
304 | return -ENOMEM; |
305 | } | |
306 | ||
307 | for (ii = 0; ii < adapter->num_debugfs_entries; ii++) { | |
308 | files = &dev_debugfs_files[ii]; | |
309 | dev_dbgfs->rsi_files[ii] = | |
310 | debugfs_create_file(files->name, | |
311 | files->perms, | |
312 | dev_dbgfs->subdir, | |
313 | common, | |
314 | &files->fops); | |
dad0d04f FF |
315 | } |
316 | return 0; | |
317 | } | |
318 | EXPORT_SYMBOL_GPL(rsi_init_dbgfs); | |
319 | ||
320 | /** | |
321 | * rsi_remove_dbgfs() - Removes the previously created dbgfs file entries | |
322 | * in the reverse order of creation. | |
323 | * @adapter: Pointer to the adapter structure. | |
324 | * | |
325 | * Return: None. | |
326 | */ | |
327 | void rsi_remove_dbgfs(struct rsi_hw *adapter) | |
328 | { | |
329 | struct rsi_debugfs *dev_dbgfs = adapter->dfsentry; | |
330 | ||
331 | if (!dev_dbgfs) | |
332 | return; | |
333 | ||
334 | debugfs_remove_recursive(dev_dbgfs->subdir); | |
335 | } | |
336 | EXPORT_SYMBOL_GPL(rsi_remove_dbgfs); |