Commit | Line | Data |
---|---|---|
71ee6730 DS |
1 | /* This file is part of the Emulex RoCE Device Driver for |
2 | * RoCE (RDMA over Converged Ethernet) adapters. | |
3 | * Copyright (C) 2012-2015 Emulex. All rights reserved. | |
4 | * EMULEX and SLI are trademarks of Emulex. | |
5 | * www.emulex.com | |
6 | * | |
7 | * This software is available to you under a choice of one of two licenses. | |
8 | * You may choose to be licensed under the terms of the GNU General Public | |
9 | * License (GPL) Version 2, available from the file COPYING in the main | |
10 | * directory of this source tree, or the BSD license below: | |
11 | * | |
12 | * Redistribution and use in source and binary forms, with or without | |
13 | * modification, are permitted provided that the following conditions | |
14 | * are met: | |
15 | * | |
16 | * - Redistributions of source code must retain the above copyright notice, | |
17 | * this list of conditions and the following disclaimer. | |
18 | * | |
19 | * - Redistributions in binary form must reproduce the above copyright | |
20 | * notice, this list of conditions and the following disclaimer in | |
21 | * the documentation and/or other materials provided with the distribution. | |
22 | * | |
23 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
24 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,THE | |
25 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
26 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE | |
27 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
28 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
29 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR | |
30 | * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
31 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
32 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | |
33 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
a51f06e1 SX |
34 | * |
35 | * Contact Information: | |
36 | * linux-drivers@emulex.com | |
37 | * | |
38 | * Emulex | |
39 | * 3333 Susan Street | |
40 | * Costa Mesa, CA 92626 | |
71ee6730 | 41 | */ |
a51f06e1 SX |
42 | |
43 | #include <rdma/ib_addr.h> | |
cad1fbb0 | 44 | #include <rdma/ib_pma.h> |
a51f06e1 SX |
45 | #include "ocrdma_stats.h" |
46 | ||
47 | static struct dentry *ocrdma_dbgfs_dir; | |
48 | ||
49 | static int ocrdma_add_stat(char *start, char *pcur, | |
50 | char *name, u64 count) | |
51 | { | |
52 | char buff[128] = {0}; | |
53 | int cpy_len = 0; | |
54 | ||
55 | snprintf(buff, 128, "%s: %llu\n", name, count); | |
56 | cpy_len = strlen(buff); | |
57 | ||
58 | if (pcur + cpy_len > start + OCRDMA_MAX_DBGFS_MEM) { | |
59 | pr_err("%s: No space in stats buff\n", __func__); | |
60 | return 0; | |
61 | } | |
62 | ||
63 | memcpy(pcur, buff, cpy_len); | |
64 | return cpy_len; | |
65 | } | |
66 | ||
fd98d896 | 67 | bool ocrdma_alloc_stats_resources(struct ocrdma_dev *dev) |
a51f06e1 SX |
68 | { |
69 | struct stats_mem *mem = &dev->stats_mem; | |
70 | ||
fd98d896 | 71 | mutex_init(&dev->stats_lock); |
a51f06e1 SX |
72 | /* Alloc mbox command mem*/ |
73 | mem->size = max_t(u32, sizeof(struct ocrdma_rdma_stats_req), | |
74 | sizeof(struct ocrdma_rdma_stats_resp)); | |
75 | ||
76 | mem->va = dma_alloc_coherent(&dev->nic_info.pdev->dev, mem->size, | |
77 | &mem->pa, GFP_KERNEL); | |
78 | if (!mem->va) { | |
79 | pr_err("%s: stats mbox allocation failed\n", __func__); | |
80 | return false; | |
81 | } | |
82 | ||
83 | memset(mem->va, 0, mem->size); | |
84 | ||
85 | /* Alloc debugfs mem */ | |
86 | mem->debugfs_mem = kzalloc(OCRDMA_MAX_DBGFS_MEM, GFP_KERNEL); | |
87 | if (!mem->debugfs_mem) { | |
88 | pr_err("%s: stats debugfs mem allocation failed\n", __func__); | |
89 | return false; | |
90 | } | |
91 | ||
92 | return true; | |
93 | } | |
94 | ||
fd98d896 | 95 | void ocrdma_release_stats_resources(struct ocrdma_dev *dev) |
a51f06e1 SX |
96 | { |
97 | struct stats_mem *mem = &dev->stats_mem; | |
98 | ||
99 | if (mem->va) | |
100 | dma_free_coherent(&dev->nic_info.pdev->dev, mem->size, | |
101 | mem->va, mem->pa); | |
fd98d896 | 102 | mem->va = NULL; |
a51f06e1 SX |
103 | kfree(mem->debugfs_mem); |
104 | } | |
105 | ||
106 | static char *ocrdma_resource_stats(struct ocrdma_dev *dev) | |
107 | { | |
108 | char *stats = dev->stats_mem.debugfs_mem, *pcur; | |
109 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
110 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
111 | struct ocrdma_rsrc_stats *rsrc_stats = &rdma_stats->act_rsrc_stats; | |
112 | ||
113 | memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
114 | ||
115 | pcur = stats; | |
116 | pcur += ocrdma_add_stat(stats, pcur, "active_dpp_pds", | |
117 | (u64)rsrc_stats->dpp_pds); | |
118 | pcur += ocrdma_add_stat(stats, pcur, "active_non_dpp_pds", | |
119 | (u64)rsrc_stats->non_dpp_pds); | |
120 | pcur += ocrdma_add_stat(stats, pcur, "active_rc_dpp_qps", | |
121 | (u64)rsrc_stats->rc_dpp_qps); | |
122 | pcur += ocrdma_add_stat(stats, pcur, "active_uc_dpp_qps", | |
123 | (u64)rsrc_stats->uc_dpp_qps); | |
124 | pcur += ocrdma_add_stat(stats, pcur, "active_ud_dpp_qps", | |
125 | (u64)rsrc_stats->ud_dpp_qps); | |
126 | pcur += ocrdma_add_stat(stats, pcur, "active_rc_non_dpp_qps", | |
127 | (u64)rsrc_stats->rc_non_dpp_qps); | |
128 | pcur += ocrdma_add_stat(stats, pcur, "active_uc_non_dpp_qps", | |
129 | (u64)rsrc_stats->uc_non_dpp_qps); | |
130 | pcur += ocrdma_add_stat(stats, pcur, "active_ud_non_dpp_qps", | |
131 | (u64)rsrc_stats->ud_non_dpp_qps); | |
132 | pcur += ocrdma_add_stat(stats, pcur, "active_srqs", | |
133 | (u64)rsrc_stats->srqs); | |
134 | pcur += ocrdma_add_stat(stats, pcur, "active_rbqs", | |
135 | (u64)rsrc_stats->rbqs); | |
136 | pcur += ocrdma_add_stat(stats, pcur, "active_64K_nsmr", | |
137 | (u64)rsrc_stats->r64K_nsmr); | |
138 | pcur += ocrdma_add_stat(stats, pcur, "active_64K_to_2M_nsmr", | |
139 | (u64)rsrc_stats->r64K_to_2M_nsmr); | |
140 | pcur += ocrdma_add_stat(stats, pcur, "active_2M_to_44M_nsmr", | |
141 | (u64)rsrc_stats->r2M_to_44M_nsmr); | |
142 | pcur += ocrdma_add_stat(stats, pcur, "active_44M_to_1G_nsmr", | |
143 | (u64)rsrc_stats->r44M_to_1G_nsmr); | |
144 | pcur += ocrdma_add_stat(stats, pcur, "active_1G_to_4G_nsmr", | |
145 | (u64)rsrc_stats->r1G_to_4G_nsmr); | |
146 | pcur += ocrdma_add_stat(stats, pcur, "active_nsmr_count_4G_to_32G", | |
147 | (u64)rsrc_stats->nsmr_count_4G_to_32G); | |
148 | pcur += ocrdma_add_stat(stats, pcur, "active_32G_to_64G_nsmr", | |
149 | (u64)rsrc_stats->r32G_to_64G_nsmr); | |
150 | pcur += ocrdma_add_stat(stats, pcur, "active_64G_to_128G_nsmr", | |
151 | (u64)rsrc_stats->r64G_to_128G_nsmr); | |
152 | pcur += ocrdma_add_stat(stats, pcur, "active_128G_to_higher_nsmr", | |
153 | (u64)rsrc_stats->r128G_to_higher_nsmr); | |
154 | pcur += ocrdma_add_stat(stats, pcur, "active_embedded_nsmr", | |
155 | (u64)rsrc_stats->embedded_nsmr); | |
156 | pcur += ocrdma_add_stat(stats, pcur, "active_frmr", | |
157 | (u64)rsrc_stats->frmr); | |
158 | pcur += ocrdma_add_stat(stats, pcur, "active_prefetch_qps", | |
159 | (u64)rsrc_stats->prefetch_qps); | |
160 | pcur += ocrdma_add_stat(stats, pcur, "active_ondemand_qps", | |
161 | (u64)rsrc_stats->ondemand_qps); | |
162 | pcur += ocrdma_add_stat(stats, pcur, "active_phy_mr", | |
163 | (u64)rsrc_stats->phy_mr); | |
164 | pcur += ocrdma_add_stat(stats, pcur, "active_mw", | |
165 | (u64)rsrc_stats->mw); | |
166 | ||
167 | /* Print the threshold stats */ | |
168 | rsrc_stats = &rdma_stats->th_rsrc_stats; | |
169 | ||
170 | pcur += ocrdma_add_stat(stats, pcur, "threshold_dpp_pds", | |
171 | (u64)rsrc_stats->dpp_pds); | |
172 | pcur += ocrdma_add_stat(stats, pcur, "threshold_non_dpp_pds", | |
173 | (u64)rsrc_stats->non_dpp_pds); | |
174 | pcur += ocrdma_add_stat(stats, pcur, "threshold_rc_dpp_qps", | |
175 | (u64)rsrc_stats->rc_dpp_qps); | |
176 | pcur += ocrdma_add_stat(stats, pcur, "threshold_uc_dpp_qps", | |
177 | (u64)rsrc_stats->uc_dpp_qps); | |
178 | pcur += ocrdma_add_stat(stats, pcur, "threshold_ud_dpp_qps", | |
179 | (u64)rsrc_stats->ud_dpp_qps); | |
180 | pcur += ocrdma_add_stat(stats, pcur, "threshold_rc_non_dpp_qps", | |
181 | (u64)rsrc_stats->rc_non_dpp_qps); | |
182 | pcur += ocrdma_add_stat(stats, pcur, "threshold_uc_non_dpp_qps", | |
183 | (u64)rsrc_stats->uc_non_dpp_qps); | |
184 | pcur += ocrdma_add_stat(stats, pcur, "threshold_ud_non_dpp_qps", | |
185 | (u64)rsrc_stats->ud_non_dpp_qps); | |
186 | pcur += ocrdma_add_stat(stats, pcur, "threshold_srqs", | |
187 | (u64)rsrc_stats->srqs); | |
188 | pcur += ocrdma_add_stat(stats, pcur, "threshold_rbqs", | |
189 | (u64)rsrc_stats->rbqs); | |
190 | pcur += ocrdma_add_stat(stats, pcur, "threshold_64K_nsmr", | |
191 | (u64)rsrc_stats->r64K_nsmr); | |
192 | pcur += ocrdma_add_stat(stats, pcur, "threshold_64K_to_2M_nsmr", | |
193 | (u64)rsrc_stats->r64K_to_2M_nsmr); | |
194 | pcur += ocrdma_add_stat(stats, pcur, "threshold_2M_to_44M_nsmr", | |
195 | (u64)rsrc_stats->r2M_to_44M_nsmr); | |
196 | pcur += ocrdma_add_stat(stats, pcur, "threshold_44M_to_1G_nsmr", | |
197 | (u64)rsrc_stats->r44M_to_1G_nsmr); | |
198 | pcur += ocrdma_add_stat(stats, pcur, "threshold_1G_to_4G_nsmr", | |
199 | (u64)rsrc_stats->r1G_to_4G_nsmr); | |
200 | pcur += ocrdma_add_stat(stats, pcur, "threshold_nsmr_count_4G_to_32G", | |
201 | (u64)rsrc_stats->nsmr_count_4G_to_32G); | |
202 | pcur += ocrdma_add_stat(stats, pcur, "threshold_32G_to_64G_nsmr", | |
203 | (u64)rsrc_stats->r32G_to_64G_nsmr); | |
204 | pcur += ocrdma_add_stat(stats, pcur, "threshold_64G_to_128G_nsmr", | |
205 | (u64)rsrc_stats->r64G_to_128G_nsmr); | |
206 | pcur += ocrdma_add_stat(stats, pcur, "threshold_128G_to_higher_nsmr", | |
207 | (u64)rsrc_stats->r128G_to_higher_nsmr); | |
208 | pcur += ocrdma_add_stat(stats, pcur, "threshold_embedded_nsmr", | |
209 | (u64)rsrc_stats->embedded_nsmr); | |
210 | pcur += ocrdma_add_stat(stats, pcur, "threshold_frmr", | |
211 | (u64)rsrc_stats->frmr); | |
212 | pcur += ocrdma_add_stat(stats, pcur, "threshold_prefetch_qps", | |
213 | (u64)rsrc_stats->prefetch_qps); | |
214 | pcur += ocrdma_add_stat(stats, pcur, "threshold_ondemand_qps", | |
215 | (u64)rsrc_stats->ondemand_qps); | |
216 | pcur += ocrdma_add_stat(stats, pcur, "threshold_phy_mr", | |
217 | (u64)rsrc_stats->phy_mr); | |
218 | pcur += ocrdma_add_stat(stats, pcur, "threshold_mw", | |
219 | (u64)rsrc_stats->mw); | |
220 | return stats; | |
221 | } | |
222 | ||
223 | static char *ocrdma_rx_stats(struct ocrdma_dev *dev) | |
224 | { | |
225 | char *stats = dev->stats_mem.debugfs_mem, *pcur; | |
226 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
227 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
228 | struct ocrdma_rx_stats *rx_stats = &rdma_stats->rx_stats; | |
229 | ||
230 | memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
231 | ||
232 | pcur = stats; | |
233 | pcur += ocrdma_add_stat | |
234 | (stats, pcur, "roce_frame_bytes", | |
235 | convert_to_64bit(rx_stats->roce_frame_bytes_lo, | |
236 | rx_stats->roce_frame_bytes_hi)); | |
237 | pcur += ocrdma_add_stat(stats, pcur, "roce_frame_icrc_drops", | |
238 | (u64)rx_stats->roce_frame_icrc_drops); | |
239 | pcur += ocrdma_add_stat(stats, pcur, "roce_frame_payload_len_drops", | |
240 | (u64)rx_stats->roce_frame_payload_len_drops); | |
241 | pcur += ocrdma_add_stat(stats, pcur, "ud_drops", | |
242 | (u64)rx_stats->ud_drops); | |
243 | pcur += ocrdma_add_stat(stats, pcur, "qp1_drops", | |
244 | (u64)rx_stats->qp1_drops); | |
245 | pcur += ocrdma_add_stat(stats, pcur, "psn_error_request_packets", | |
246 | (u64)rx_stats->psn_error_request_packets); | |
247 | pcur += ocrdma_add_stat(stats, pcur, "psn_error_resp_packets", | |
248 | (u64)rx_stats->psn_error_resp_packets); | |
249 | pcur += ocrdma_add_stat(stats, pcur, "rnr_nak_timeouts", | |
250 | (u64)rx_stats->rnr_nak_timeouts); | |
251 | pcur += ocrdma_add_stat(stats, pcur, "rnr_nak_receives", | |
252 | (u64)rx_stats->rnr_nak_receives); | |
253 | pcur += ocrdma_add_stat(stats, pcur, "roce_frame_rxmt_drops", | |
254 | (u64)rx_stats->roce_frame_rxmt_drops); | |
255 | pcur += ocrdma_add_stat(stats, pcur, "nak_count_psn_sequence_errors", | |
256 | (u64)rx_stats->nak_count_psn_sequence_errors); | |
257 | pcur += ocrdma_add_stat(stats, pcur, "rc_drop_count_lookup_errors", | |
258 | (u64)rx_stats->rc_drop_count_lookup_errors); | |
259 | pcur += ocrdma_add_stat(stats, pcur, "rq_rnr_naks", | |
260 | (u64)rx_stats->rq_rnr_naks); | |
261 | pcur += ocrdma_add_stat(stats, pcur, "srq_rnr_naks", | |
262 | (u64)rx_stats->srq_rnr_naks); | |
263 | pcur += ocrdma_add_stat(stats, pcur, "roce_frames", | |
264 | convert_to_64bit(rx_stats->roce_frames_lo, | |
265 | rx_stats->roce_frames_hi)); | |
266 | ||
267 | return stats; | |
268 | } | |
269 | ||
cad1fbb0 MA |
270 | static u64 ocrdma_sysfs_rcv_pkts(struct ocrdma_dev *dev) |
271 | { | |
272 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
273 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
274 | struct ocrdma_rx_stats *rx_stats = &rdma_stats->rx_stats; | |
275 | ||
276 | return convert_to_64bit(rx_stats->roce_frames_lo, | |
277 | rx_stats->roce_frames_hi) + (u64)rx_stats->roce_frame_icrc_drops | |
278 | + (u64)rx_stats->roce_frame_payload_len_drops; | |
279 | } | |
280 | ||
281 | static u64 ocrdma_sysfs_rcv_data(struct ocrdma_dev *dev) | |
282 | { | |
283 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
284 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
285 | struct ocrdma_rx_stats *rx_stats = &rdma_stats->rx_stats; | |
286 | ||
287 | return (convert_to_64bit(rx_stats->roce_frame_bytes_lo, | |
288 | rx_stats->roce_frame_bytes_hi))/4; | |
289 | } | |
290 | ||
a51f06e1 SX |
291 | static char *ocrdma_tx_stats(struct ocrdma_dev *dev) |
292 | { | |
293 | char *stats = dev->stats_mem.debugfs_mem, *pcur; | |
294 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
295 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
296 | struct ocrdma_tx_stats *tx_stats = &rdma_stats->tx_stats; | |
297 | ||
298 | memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
299 | ||
300 | pcur = stats; | |
301 | pcur += ocrdma_add_stat(stats, pcur, "send_pkts", | |
302 | convert_to_64bit(tx_stats->send_pkts_lo, | |
303 | tx_stats->send_pkts_hi)); | |
304 | pcur += ocrdma_add_stat(stats, pcur, "write_pkts", | |
305 | convert_to_64bit(tx_stats->write_pkts_lo, | |
306 | tx_stats->write_pkts_hi)); | |
307 | pcur += ocrdma_add_stat(stats, pcur, "read_pkts", | |
308 | convert_to_64bit(tx_stats->read_pkts_lo, | |
309 | tx_stats->read_pkts_hi)); | |
310 | pcur += ocrdma_add_stat(stats, pcur, "read_rsp_pkts", | |
311 | convert_to_64bit(tx_stats->read_rsp_pkts_lo, | |
312 | tx_stats->read_rsp_pkts_hi)); | |
313 | pcur += ocrdma_add_stat(stats, pcur, "ack_pkts", | |
314 | convert_to_64bit(tx_stats->ack_pkts_lo, | |
315 | tx_stats->ack_pkts_hi)); | |
316 | pcur += ocrdma_add_stat(stats, pcur, "send_bytes", | |
317 | convert_to_64bit(tx_stats->send_bytes_lo, | |
318 | tx_stats->send_bytes_hi)); | |
319 | pcur += ocrdma_add_stat(stats, pcur, "write_bytes", | |
320 | convert_to_64bit(tx_stats->write_bytes_lo, | |
321 | tx_stats->write_bytes_hi)); | |
322 | pcur += ocrdma_add_stat(stats, pcur, "read_req_bytes", | |
323 | convert_to_64bit(tx_stats->read_req_bytes_lo, | |
324 | tx_stats->read_req_bytes_hi)); | |
325 | pcur += ocrdma_add_stat(stats, pcur, "read_rsp_bytes", | |
326 | convert_to_64bit(tx_stats->read_rsp_bytes_lo, | |
327 | tx_stats->read_rsp_bytes_hi)); | |
328 | pcur += ocrdma_add_stat(stats, pcur, "ack_timeouts", | |
329 | (u64)tx_stats->ack_timeouts); | |
330 | ||
331 | return stats; | |
332 | } | |
333 | ||
cad1fbb0 MA |
334 | static u64 ocrdma_sysfs_xmit_pkts(struct ocrdma_dev *dev) |
335 | { | |
336 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
337 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
338 | struct ocrdma_tx_stats *tx_stats = &rdma_stats->tx_stats; | |
339 | ||
340 | return (convert_to_64bit(tx_stats->send_pkts_lo, | |
341 | tx_stats->send_pkts_hi) + | |
342 | convert_to_64bit(tx_stats->write_pkts_lo, tx_stats->write_pkts_hi) + | |
343 | convert_to_64bit(tx_stats->read_pkts_lo, tx_stats->read_pkts_hi) + | |
344 | convert_to_64bit(tx_stats->read_rsp_pkts_lo, | |
345 | tx_stats->read_rsp_pkts_hi) + | |
346 | convert_to_64bit(tx_stats->ack_pkts_lo, tx_stats->ack_pkts_hi)); | |
347 | } | |
348 | ||
349 | static u64 ocrdma_sysfs_xmit_data(struct ocrdma_dev *dev) | |
350 | { | |
351 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
352 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
353 | struct ocrdma_tx_stats *tx_stats = &rdma_stats->tx_stats; | |
354 | ||
355 | return (convert_to_64bit(tx_stats->send_bytes_lo, | |
356 | tx_stats->send_bytes_hi) + | |
357 | convert_to_64bit(tx_stats->write_bytes_lo, | |
358 | tx_stats->write_bytes_hi) + | |
359 | convert_to_64bit(tx_stats->read_req_bytes_lo, | |
360 | tx_stats->read_req_bytes_hi) + | |
361 | convert_to_64bit(tx_stats->read_rsp_bytes_lo, | |
362 | tx_stats->read_rsp_bytes_hi))/4; | |
363 | } | |
364 | ||
a51f06e1 SX |
365 | static char *ocrdma_wqe_stats(struct ocrdma_dev *dev) |
366 | { | |
367 | char *stats = dev->stats_mem.debugfs_mem, *pcur; | |
368 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
369 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
370 | struct ocrdma_wqe_stats *wqe_stats = &rdma_stats->wqe_stats; | |
371 | ||
372 | memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
373 | ||
374 | pcur = stats; | |
375 | pcur += ocrdma_add_stat(stats, pcur, "large_send_rc_wqes", | |
376 | convert_to_64bit(wqe_stats->large_send_rc_wqes_lo, | |
377 | wqe_stats->large_send_rc_wqes_hi)); | |
378 | pcur += ocrdma_add_stat(stats, pcur, "large_write_rc_wqes", | |
379 | convert_to_64bit(wqe_stats->large_write_rc_wqes_lo, | |
380 | wqe_stats->large_write_rc_wqes_hi)); | |
381 | pcur += ocrdma_add_stat(stats, pcur, "read_wqes", | |
382 | convert_to_64bit(wqe_stats->read_wqes_lo, | |
383 | wqe_stats->read_wqes_hi)); | |
384 | pcur += ocrdma_add_stat(stats, pcur, "frmr_wqes", | |
385 | convert_to_64bit(wqe_stats->frmr_wqes_lo, | |
386 | wqe_stats->frmr_wqes_hi)); | |
387 | pcur += ocrdma_add_stat(stats, pcur, "mw_bind_wqes", | |
388 | convert_to_64bit(wqe_stats->mw_bind_wqes_lo, | |
389 | wqe_stats->mw_bind_wqes_hi)); | |
390 | pcur += ocrdma_add_stat(stats, pcur, "invalidate_wqes", | |
391 | convert_to_64bit(wqe_stats->invalidate_wqes_lo, | |
392 | wqe_stats->invalidate_wqes_hi)); | |
393 | pcur += ocrdma_add_stat(stats, pcur, "dpp_wqe_drops", | |
394 | (u64)wqe_stats->dpp_wqe_drops); | |
395 | return stats; | |
396 | } | |
397 | ||
398 | static char *ocrdma_db_errstats(struct ocrdma_dev *dev) | |
399 | { | |
400 | char *stats = dev->stats_mem.debugfs_mem, *pcur; | |
401 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
402 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
403 | struct ocrdma_db_err_stats *db_err_stats = &rdma_stats->db_err_stats; | |
404 | ||
405 | memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
406 | ||
407 | pcur = stats; | |
408 | pcur += ocrdma_add_stat(stats, pcur, "sq_doorbell_errors", | |
409 | (u64)db_err_stats->sq_doorbell_errors); | |
410 | pcur += ocrdma_add_stat(stats, pcur, "cq_doorbell_errors", | |
411 | (u64)db_err_stats->cq_doorbell_errors); | |
412 | pcur += ocrdma_add_stat(stats, pcur, "rq_srq_doorbell_errors", | |
413 | (u64)db_err_stats->rq_srq_doorbell_errors); | |
414 | pcur += ocrdma_add_stat(stats, pcur, "cq_overflow_errors", | |
415 | (u64)db_err_stats->cq_overflow_errors); | |
416 | return stats; | |
417 | } | |
418 | ||
419 | static char *ocrdma_rxqp_errstats(struct ocrdma_dev *dev) | |
420 | { | |
421 | char *stats = dev->stats_mem.debugfs_mem, *pcur; | |
422 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
423 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
424 | struct ocrdma_rx_qp_err_stats *rx_qp_err_stats = | |
425 | &rdma_stats->rx_qp_err_stats; | |
426 | ||
427 | memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
428 | ||
429 | pcur = stats; | |
430 | pcur += ocrdma_add_stat(stats, pcur, "nak_invalid_requst_errors", | |
431 | (u64)rx_qp_err_stats->nak_invalid_requst_errors); | |
432 | pcur += ocrdma_add_stat(stats, pcur, "nak_remote_operation_errors", | |
433 | (u64)rx_qp_err_stats->nak_remote_operation_errors); | |
434 | pcur += ocrdma_add_stat(stats, pcur, "nak_count_remote_access_errors", | |
435 | (u64)rx_qp_err_stats->nak_count_remote_access_errors); | |
436 | pcur += ocrdma_add_stat(stats, pcur, "local_length_errors", | |
437 | (u64)rx_qp_err_stats->local_length_errors); | |
438 | pcur += ocrdma_add_stat(stats, pcur, "local_protection_errors", | |
439 | (u64)rx_qp_err_stats->local_protection_errors); | |
440 | pcur += ocrdma_add_stat(stats, pcur, "local_qp_operation_errors", | |
441 | (u64)rx_qp_err_stats->local_qp_operation_errors); | |
442 | return stats; | |
443 | } | |
444 | ||
445 | static char *ocrdma_txqp_errstats(struct ocrdma_dev *dev) | |
446 | { | |
447 | char *stats = dev->stats_mem.debugfs_mem, *pcur; | |
448 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
449 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
450 | struct ocrdma_tx_qp_err_stats *tx_qp_err_stats = | |
451 | &rdma_stats->tx_qp_err_stats; | |
452 | ||
453 | memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
454 | ||
455 | pcur = stats; | |
456 | pcur += ocrdma_add_stat(stats, pcur, "local_length_errors", | |
457 | (u64)tx_qp_err_stats->local_length_errors); | |
458 | pcur += ocrdma_add_stat(stats, pcur, "local_protection_errors", | |
459 | (u64)tx_qp_err_stats->local_protection_errors); | |
460 | pcur += ocrdma_add_stat(stats, pcur, "local_qp_operation_errors", | |
461 | (u64)tx_qp_err_stats->local_qp_operation_errors); | |
462 | pcur += ocrdma_add_stat(stats, pcur, "retry_count_exceeded_errors", | |
463 | (u64)tx_qp_err_stats->retry_count_exceeded_errors); | |
464 | pcur += ocrdma_add_stat(stats, pcur, "rnr_retry_count_exceeded_errors", | |
465 | (u64)tx_qp_err_stats->rnr_retry_count_exceeded_errors); | |
466 | return stats; | |
467 | } | |
468 | ||
469 | static char *ocrdma_tx_dbg_stats(struct ocrdma_dev *dev) | |
470 | { | |
471 | int i; | |
472 | char *pstats = dev->stats_mem.debugfs_mem; | |
473 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
474 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
475 | struct ocrdma_tx_dbg_stats *tx_dbg_stats = | |
476 | &rdma_stats->tx_dbg_stats; | |
477 | ||
478 | memset(pstats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
479 | ||
480 | for (i = 0; i < 100; i++) | |
481 | pstats += snprintf(pstats, 80, "DW[%d] = 0x%x\n", i, | |
482 | tx_dbg_stats->data[i]); | |
483 | ||
484 | return dev->stats_mem.debugfs_mem; | |
485 | } | |
486 | ||
487 | static char *ocrdma_rx_dbg_stats(struct ocrdma_dev *dev) | |
488 | { | |
489 | int i; | |
490 | char *pstats = dev->stats_mem.debugfs_mem; | |
491 | struct ocrdma_rdma_stats_resp *rdma_stats = | |
492 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
493 | struct ocrdma_rx_dbg_stats *rx_dbg_stats = | |
494 | &rdma_stats->rx_dbg_stats; | |
495 | ||
496 | memset(pstats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
497 | ||
498 | for (i = 0; i < 200; i++) | |
499 | pstats += snprintf(pstats, 80, "DW[%d] = 0x%x\n", i, | |
500 | rx_dbg_stats->data[i]); | |
501 | ||
502 | return dev->stats_mem.debugfs_mem; | |
503 | } | |
504 | ||
ad56ebb4 SX |
505 | static char *ocrdma_driver_dbg_stats(struct ocrdma_dev *dev) |
506 | { | |
507 | char *stats = dev->stats_mem.debugfs_mem, *pcur; | |
508 | ||
509 | ||
510 | memset(stats, 0, (OCRDMA_MAX_DBGFS_MEM)); | |
511 | ||
512 | pcur = stats; | |
513 | pcur += ocrdma_add_stat(stats, pcur, "async_cq_err", | |
514 | (u64)(dev->async_err_stats | |
515 | [OCRDMA_CQ_ERROR].counter)); | |
516 | pcur += ocrdma_add_stat(stats, pcur, "async_cq_overrun_err", | |
517 | (u64)dev->async_err_stats | |
518 | [OCRDMA_CQ_OVERRUN_ERROR].counter); | |
519 | pcur += ocrdma_add_stat(stats, pcur, "async_cq_qpcat_err", | |
520 | (u64)dev->async_err_stats | |
521 | [OCRDMA_CQ_QPCAT_ERROR].counter); | |
522 | pcur += ocrdma_add_stat(stats, pcur, "async_qp_access_err", | |
523 | (u64)dev->async_err_stats | |
524 | [OCRDMA_QP_ACCESS_ERROR].counter); | |
525 | pcur += ocrdma_add_stat(stats, pcur, "async_qp_commm_est_evt", | |
526 | (u64)dev->async_err_stats | |
527 | [OCRDMA_QP_COMM_EST_EVENT].counter); | |
528 | pcur += ocrdma_add_stat(stats, pcur, "async_sq_drained_evt", | |
529 | (u64)dev->async_err_stats | |
530 | [OCRDMA_SQ_DRAINED_EVENT].counter); | |
531 | pcur += ocrdma_add_stat(stats, pcur, "async_dev_fatal_evt", | |
532 | (u64)dev->async_err_stats | |
533 | [OCRDMA_DEVICE_FATAL_EVENT].counter); | |
534 | pcur += ocrdma_add_stat(stats, pcur, "async_srqcat_err", | |
535 | (u64)dev->async_err_stats | |
536 | [OCRDMA_SRQCAT_ERROR].counter); | |
537 | pcur += ocrdma_add_stat(stats, pcur, "async_srq_limit_evt", | |
538 | (u64)dev->async_err_stats | |
539 | [OCRDMA_SRQ_LIMIT_EVENT].counter); | |
540 | pcur += ocrdma_add_stat(stats, pcur, "async_qp_last_wqe_evt", | |
541 | (u64)dev->async_err_stats | |
542 | [OCRDMA_QP_LAST_WQE_EVENT].counter); | |
543 | ||
544 | pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_len_err", | |
545 | (u64)dev->cqe_err_stats | |
546 | [OCRDMA_CQE_LOC_LEN_ERR].counter); | |
547 | pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_qp_op_err", | |
548 | (u64)dev->cqe_err_stats | |
549 | [OCRDMA_CQE_LOC_QP_OP_ERR].counter); | |
550 | pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_eec_op_err", | |
551 | (u64)dev->cqe_err_stats | |
552 | [OCRDMA_CQE_LOC_EEC_OP_ERR].counter); | |
553 | pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_prot_err", | |
554 | (u64)dev->cqe_err_stats | |
555 | [OCRDMA_CQE_LOC_PROT_ERR].counter); | |
556 | pcur += ocrdma_add_stat(stats, pcur, "cqe_wr_flush_err", | |
557 | (u64)dev->cqe_err_stats | |
558 | [OCRDMA_CQE_WR_FLUSH_ERR].counter); | |
559 | pcur += ocrdma_add_stat(stats, pcur, "cqe_mw_bind_err", | |
560 | (u64)dev->cqe_err_stats | |
561 | [OCRDMA_CQE_MW_BIND_ERR].counter); | |
562 | pcur += ocrdma_add_stat(stats, pcur, "cqe_bad_resp_err", | |
563 | (u64)dev->cqe_err_stats | |
564 | [OCRDMA_CQE_BAD_RESP_ERR].counter); | |
565 | pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_access_err", | |
566 | (u64)dev->cqe_err_stats | |
567 | [OCRDMA_CQE_LOC_ACCESS_ERR].counter); | |
568 | pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_inv_req_err", | |
569 | (u64)dev->cqe_err_stats | |
570 | [OCRDMA_CQE_REM_INV_REQ_ERR].counter); | |
571 | pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_access_err", | |
572 | (u64)dev->cqe_err_stats | |
573 | [OCRDMA_CQE_REM_ACCESS_ERR].counter); | |
574 | pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_op_err", | |
575 | (u64)dev->cqe_err_stats | |
576 | [OCRDMA_CQE_REM_OP_ERR].counter); | |
577 | pcur += ocrdma_add_stat(stats, pcur, "cqe_retry_exc_err", | |
578 | (u64)dev->cqe_err_stats | |
579 | [OCRDMA_CQE_RETRY_EXC_ERR].counter); | |
580 | pcur += ocrdma_add_stat(stats, pcur, "cqe_rnr_retry_exc_err", | |
581 | (u64)dev->cqe_err_stats | |
582 | [OCRDMA_CQE_RNR_RETRY_EXC_ERR].counter); | |
583 | pcur += ocrdma_add_stat(stats, pcur, "cqe_loc_rdd_viol_err", | |
584 | (u64)dev->cqe_err_stats | |
585 | [OCRDMA_CQE_LOC_RDD_VIOL_ERR].counter); | |
586 | pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_inv_rd_req_err", | |
587 | (u64)dev->cqe_err_stats | |
588 | [OCRDMA_CQE_REM_INV_RD_REQ_ERR].counter); | |
589 | pcur += ocrdma_add_stat(stats, pcur, "cqe_rem_abort_err", | |
590 | (u64)dev->cqe_err_stats | |
591 | [OCRDMA_CQE_REM_ABORT_ERR].counter); | |
592 | pcur += ocrdma_add_stat(stats, pcur, "cqe_inv_eecn_err", | |
593 | (u64)dev->cqe_err_stats | |
594 | [OCRDMA_CQE_INV_EECN_ERR].counter); | |
595 | pcur += ocrdma_add_stat(stats, pcur, "cqe_inv_eec_state_err", | |
596 | (u64)dev->cqe_err_stats | |
597 | [OCRDMA_CQE_INV_EEC_STATE_ERR].counter); | |
598 | pcur += ocrdma_add_stat(stats, pcur, "cqe_fatal_err", | |
599 | (u64)dev->cqe_err_stats | |
600 | [OCRDMA_CQE_FATAL_ERR].counter); | |
601 | pcur += ocrdma_add_stat(stats, pcur, "cqe_resp_timeout_err", | |
602 | (u64)dev->cqe_err_stats | |
603 | [OCRDMA_CQE_RESP_TIMEOUT_ERR].counter); | |
604 | pcur += ocrdma_add_stat(stats, pcur, "cqe_general_err", | |
605 | (u64)dev->cqe_err_stats | |
606 | [OCRDMA_CQE_GENERAL_ERR].counter); | |
607 | return stats; | |
608 | } | |
609 | ||
a51f06e1 SX |
610 | static void ocrdma_update_stats(struct ocrdma_dev *dev) |
611 | { | |
612 | ulong now = jiffies, secs; | |
0ca4c39f | 613 | int status; |
9ba1377d MA |
614 | struct ocrdma_rdma_stats_resp *rdma_stats = |
615 | (struct ocrdma_rdma_stats_resp *)dev->stats_mem.va; | |
616 | struct ocrdma_rsrc_stats *rsrc_stats = &rdma_stats->act_rsrc_stats; | |
a51f06e1 SX |
617 | |
618 | secs = jiffies_to_msecs(now - dev->last_stats_time) / 1000U; | |
619 | if (secs) { | |
620 | /* update */ | |
621 | status = ocrdma_mbx_rdma_stats(dev, false); | |
622 | if (status) | |
623 | pr_err("%s: stats mbox failed with status = %d\n", | |
624 | __func__, status); | |
9ba1377d MA |
625 | /* Update PD counters from PD resource manager */ |
626 | if (dev->pd_mgr->pd_prealloc_valid) { | |
627 | rsrc_stats->dpp_pds = dev->pd_mgr->pd_dpp_count; | |
628 | rsrc_stats->non_dpp_pds = dev->pd_mgr->pd_norm_count; | |
629 | /* Threshold stata*/ | |
630 | rsrc_stats = &rdma_stats->th_rsrc_stats; | |
631 | rsrc_stats->dpp_pds = dev->pd_mgr->pd_dpp_thrsh; | |
632 | rsrc_stats->non_dpp_pds = dev->pd_mgr->pd_norm_thrsh; | |
633 | } | |
a51f06e1 SX |
634 | dev->last_stats_time = jiffies; |
635 | } | |
636 | } | |
637 | ||
ad56ebb4 SX |
638 | static ssize_t ocrdma_dbgfs_ops_write(struct file *filp, |
639 | const char __user *buffer, | |
640 | size_t count, loff_t *ppos) | |
641 | { | |
642 | char tmp_str[32]; | |
643 | long reset; | |
0ca4c39f | 644 | int status; |
ad56ebb4 SX |
645 | struct ocrdma_stats *pstats = filp->private_data; |
646 | struct ocrdma_dev *dev = pstats->dev; | |
647 | ||
648 | if (count > 32) | |
649 | goto err; | |
650 | ||
651 | if (copy_from_user(tmp_str, buffer, count)) | |
652 | goto err; | |
653 | ||
654 | tmp_str[count-1] = '\0'; | |
655 | if (kstrtol(tmp_str, 10, &reset)) | |
656 | goto err; | |
657 | ||
658 | switch (pstats->type) { | |
659 | case OCRDMA_RESET_STATS: | |
660 | if (reset) { | |
661 | status = ocrdma_mbx_rdma_stats(dev, true); | |
662 | if (status) { | |
663 | pr_err("Failed to reset stats = %d", status); | |
664 | goto err; | |
665 | } | |
666 | } | |
667 | break; | |
668 | default: | |
669 | goto err; | |
670 | } | |
671 | ||
672 | return count; | |
673 | err: | |
674 | return -EFAULT; | |
675 | } | |
676 | ||
cad1fbb0 MA |
677 | int ocrdma_pma_counters(struct ocrdma_dev *dev, |
678 | struct ib_mad *out_mad) | |
679 | { | |
680 | struct ib_pma_portcounters *pma_cnt; | |
681 | ||
682 | memset(out_mad->data, 0, sizeof out_mad->data); | |
683 | pma_cnt = (void *)(out_mad->data + 40); | |
684 | ocrdma_update_stats(dev); | |
685 | ||
686 | pma_cnt->port_xmit_data = cpu_to_be32(ocrdma_sysfs_xmit_data(dev)); | |
687 | pma_cnt->port_rcv_data = cpu_to_be32(ocrdma_sysfs_rcv_data(dev)); | |
688 | pma_cnt->port_xmit_packets = cpu_to_be32(ocrdma_sysfs_xmit_pkts(dev)); | |
689 | pma_cnt->port_rcv_packets = cpu_to_be32(ocrdma_sysfs_rcv_pkts(dev)); | |
690 | return 0; | |
691 | } | |
692 | ||
a51f06e1 SX |
693 | static ssize_t ocrdma_dbgfs_ops_read(struct file *filp, char __user *buffer, |
694 | size_t usr_buf_len, loff_t *ppos) | |
695 | { | |
696 | struct ocrdma_stats *pstats = filp->private_data; | |
697 | struct ocrdma_dev *dev = pstats->dev; | |
698 | ssize_t status = 0; | |
699 | char *data = NULL; | |
700 | ||
701 | /* No partial reads */ | |
702 | if (*ppos != 0) | |
703 | return 0; | |
704 | ||
705 | mutex_lock(&dev->stats_lock); | |
706 | ||
707 | ocrdma_update_stats(dev); | |
708 | ||
709 | switch (pstats->type) { | |
710 | case OCRDMA_RSRC_STATS: | |
711 | data = ocrdma_resource_stats(dev); | |
712 | break; | |
713 | case OCRDMA_RXSTATS: | |
714 | data = ocrdma_rx_stats(dev); | |
715 | break; | |
716 | case OCRDMA_WQESTATS: | |
717 | data = ocrdma_wqe_stats(dev); | |
718 | break; | |
719 | case OCRDMA_TXSTATS: | |
720 | data = ocrdma_tx_stats(dev); | |
721 | break; | |
722 | case OCRDMA_DB_ERRSTATS: | |
723 | data = ocrdma_db_errstats(dev); | |
724 | break; | |
725 | case OCRDMA_RXQP_ERRSTATS: | |
726 | data = ocrdma_rxqp_errstats(dev); | |
727 | break; | |
728 | case OCRDMA_TXQP_ERRSTATS: | |
729 | data = ocrdma_txqp_errstats(dev); | |
730 | break; | |
731 | case OCRDMA_TX_DBG_STATS: | |
732 | data = ocrdma_tx_dbg_stats(dev); | |
733 | break; | |
734 | case OCRDMA_RX_DBG_STATS: | |
735 | data = ocrdma_rx_dbg_stats(dev); | |
736 | break; | |
ad56ebb4 SX |
737 | case OCRDMA_DRV_STATS: |
738 | data = ocrdma_driver_dbg_stats(dev); | |
739 | break; | |
a51f06e1 SX |
740 | |
741 | default: | |
742 | status = -EFAULT; | |
743 | goto exit; | |
744 | } | |
745 | ||
746 | if (usr_buf_len < strlen(data)) { | |
747 | status = -ENOSPC; | |
748 | goto exit; | |
749 | } | |
750 | ||
751 | status = simple_read_from_buffer(buffer, usr_buf_len, ppos, data, | |
752 | strlen(data)); | |
753 | exit: | |
754 | mutex_unlock(&dev->stats_lock); | |
755 | return status; | |
756 | } | |
757 | ||
a51f06e1 SX |
758 | static const struct file_operations ocrdma_dbg_ops = { |
759 | .owner = THIS_MODULE, | |
0cc65dd6 | 760 | .open = simple_open, |
a51f06e1 | 761 | .read = ocrdma_dbgfs_ops_read, |
ad56ebb4 | 762 | .write = ocrdma_dbgfs_ops_write, |
a51f06e1 SX |
763 | }; |
764 | ||
765 | void ocrdma_add_port_stats(struct ocrdma_dev *dev) | |
766 | { | |
767 | if (!ocrdma_dbgfs_dir) | |
768 | return; | |
769 | ||
770 | /* Create post stats base dir */ | |
771 | dev->dir = debugfs_create_dir(dev->ibdev.name, ocrdma_dbgfs_dir); | |
772 | if (!dev->dir) | |
773 | goto err; | |
774 | ||
775 | dev->rsrc_stats.type = OCRDMA_RSRC_STATS; | |
776 | dev->rsrc_stats.dev = dev; | |
777 | if (!debugfs_create_file("resource_stats", S_IRUSR, dev->dir, | |
778 | &dev->rsrc_stats, &ocrdma_dbg_ops)) | |
779 | goto err; | |
780 | ||
781 | dev->rx_stats.type = OCRDMA_RXSTATS; | |
782 | dev->rx_stats.dev = dev; | |
783 | if (!debugfs_create_file("rx_stats", S_IRUSR, dev->dir, | |
784 | &dev->rx_stats, &ocrdma_dbg_ops)) | |
785 | goto err; | |
786 | ||
787 | dev->wqe_stats.type = OCRDMA_WQESTATS; | |
788 | dev->wqe_stats.dev = dev; | |
789 | if (!debugfs_create_file("wqe_stats", S_IRUSR, dev->dir, | |
790 | &dev->wqe_stats, &ocrdma_dbg_ops)) | |
791 | goto err; | |
792 | ||
793 | dev->tx_stats.type = OCRDMA_TXSTATS; | |
794 | dev->tx_stats.dev = dev; | |
795 | if (!debugfs_create_file("tx_stats", S_IRUSR, dev->dir, | |
796 | &dev->tx_stats, &ocrdma_dbg_ops)) | |
797 | goto err; | |
798 | ||
799 | dev->db_err_stats.type = OCRDMA_DB_ERRSTATS; | |
800 | dev->db_err_stats.dev = dev; | |
801 | if (!debugfs_create_file("db_err_stats", S_IRUSR, dev->dir, | |
802 | &dev->db_err_stats, &ocrdma_dbg_ops)) | |
803 | goto err; | |
804 | ||
805 | ||
806 | dev->tx_qp_err_stats.type = OCRDMA_TXQP_ERRSTATS; | |
807 | dev->tx_qp_err_stats.dev = dev; | |
808 | if (!debugfs_create_file("tx_qp_err_stats", S_IRUSR, dev->dir, | |
809 | &dev->tx_qp_err_stats, &ocrdma_dbg_ops)) | |
810 | goto err; | |
811 | ||
812 | dev->rx_qp_err_stats.type = OCRDMA_RXQP_ERRSTATS; | |
813 | dev->rx_qp_err_stats.dev = dev; | |
814 | if (!debugfs_create_file("rx_qp_err_stats", S_IRUSR, dev->dir, | |
815 | &dev->rx_qp_err_stats, &ocrdma_dbg_ops)) | |
816 | goto err; | |
817 | ||
818 | ||
819 | dev->tx_dbg_stats.type = OCRDMA_TX_DBG_STATS; | |
820 | dev->tx_dbg_stats.dev = dev; | |
821 | if (!debugfs_create_file("tx_dbg_stats", S_IRUSR, dev->dir, | |
822 | &dev->tx_dbg_stats, &ocrdma_dbg_ops)) | |
823 | goto err; | |
824 | ||
825 | dev->rx_dbg_stats.type = OCRDMA_RX_DBG_STATS; | |
826 | dev->rx_dbg_stats.dev = dev; | |
827 | if (!debugfs_create_file("rx_dbg_stats", S_IRUSR, dev->dir, | |
828 | &dev->rx_dbg_stats, &ocrdma_dbg_ops)) | |
829 | goto err; | |
830 | ||
ad56ebb4 SX |
831 | dev->driver_stats.type = OCRDMA_DRV_STATS; |
832 | dev->driver_stats.dev = dev; | |
833 | if (!debugfs_create_file("driver_dbg_stats", S_IRUSR, dev->dir, | |
834 | &dev->driver_stats, &ocrdma_dbg_ops)) | |
835 | goto err; | |
836 | ||
837 | dev->reset_stats.type = OCRDMA_RESET_STATS; | |
838 | dev->reset_stats.dev = dev; | |
839 | if (!debugfs_create_file("reset_stats", S_IRUSR, dev->dir, | |
840 | &dev->reset_stats, &ocrdma_dbg_ops)) | |
841 | goto err; | |
842 | ||
a51f06e1 SX |
843 | |
844 | return; | |
845 | err: | |
a51f06e1 SX |
846 | debugfs_remove_recursive(dev->dir); |
847 | dev->dir = NULL; | |
848 | } | |
849 | ||
850 | void ocrdma_rem_port_stats(struct ocrdma_dev *dev) | |
851 | { | |
852 | if (!dev->dir) | |
853 | return; | |
7425f410 | 854 | debugfs_remove_recursive(dev->dir); |
a51f06e1 SX |
855 | } |
856 | ||
857 | void ocrdma_init_debugfs(void) | |
858 | { | |
859 | /* Create base dir in debugfs root dir */ | |
860 | ocrdma_dbgfs_dir = debugfs_create_dir("ocrdma", NULL); | |
861 | } | |
862 | ||
863 | void ocrdma_rem_debugfs(void) | |
864 | { | |
865 | debugfs_remove_recursive(ocrdma_dbgfs_dir); | |
866 | } |